Put PushArgument into the environment instead of raw values.

runtime/vm/flow_graph_allocator.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/flow_graph_allocator.h"
 
 #include "vm/bit_vector.h"
 #include "vm/intermediate_language.h"
 #include "vm/il_printer.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 82 matching lines @@
     for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
       Instruction* current = it.Current();
       if (current->CanDeoptimize()) {
         ASSERT(current->env() != NULL);
         GrowableArray<Value*>* values = current->env()->values_ptr();
 
         for (intptr_t i = 0; i < values->length(); i++) {
           UseVal* use = (*values)[i]->AsUse();
           if (use == NULL) continue;
 
-          PhiInstr* phi = use->definition()->AsPhi();
-          if (phi == NULL) continue;
+          Definition* def = use->definition();
 
-          if (!phi->is_alive()) (*values)[i] = null_value;
+          PushArgumentInstr* push_argument = def->AsPushArgument();
+          if ((push_argument != NULL) && push_argument->WasEliminated()) {
+            (*values)[i] = push_argument->value();
+            continue;
+          }
+
+          PhiInstr* phi = def->AsPhi();
+          if ((phi != NULL) && !phi->is_alive()) {
+            (*values)[i] = null_value;
+            continue;
+          }
         }
       } else {
         current->set_env(NULL);
       }
     }
   }
 }
 
 
 void FlowGraphAllocator::ComputeInitialSets() {
@@ skipping 21 matching lines @@
         if (input->IsUse()) {
           const intptr_t use = input->AsUse()->definition()->ssa_temp_index();
           live_in->Add(use);
         }
       }
 
       // Add uses from the deoptimization environment.
       if (current->env() != NULL) {
         const GrowableArray<Value*>& values = current->env()->values();
         for (intptr_t j = 0; j < values.length(); j++) {
           Value* val = values[j];

[srdjan, 2012/08/09 20:25:26]

I think this looks simpler :

UseVal* use_val = values[j]->AsUse();
if ((use_val != NULL) && !use_val->definition()-IsPushArgument()) {
  live_in->Add(use_val->definition()->ssa_temp_index());
}

[Vyacheslav Egorov (Google), 2012/08/10 14:27:46]

Agreed.

-          if (val->IsUse()) {
-            const intptr_t use = val->AsUse()->definition()->ssa_temp_index();
-            live_in->Add(use);
-          }
+          if (!val->IsUse()) continue;
+
+          Definition* def = val->AsUse()->definition();
+          if (def->IsPushArgument()) continue;
+
+          live_in->Add(def->ssa_temp_index());
         }
       }
     }
 
     // Handle phis.
     if (block->IsJoinEntry()) {
       JoinEntryInstr* join = block->AsJoinEntry();
       if (join->phis() != NULL) {
         for (intptr_t j = 0; j < join->phis()->length(); j++) {
           PhiInstr* phi = (*join->phis())[j];
@@ skipping 486 matching lines @@
       // All phi resolution moves are connected. Phi's live range is
       // complete.
       AddToUnallocated(range);
 
       move_idx++;
     }
   }
 }
 
 
+void FlowGraphAllocator::ProcessEnvironmentUses(BlockEntryInstr* block,
+                                                Instruction* current) {
+  ASSERT(current->env() != NULL);
+
+  Environment* env = current->env();
+
+  // Any value mentioned in the deoptimization environment should survive
+  // until the end of instruction but it does not need to be in the register.
+  // Expected shape of live range:
+  //
+  //                 i  i'
+  //      value    -----*
+  //
+
+  const GrowableArray<Value*>& values = env->values();
+  if (values.length() == 0) return;
+
+  const intptr_t block_start_pos = block->start_pos();
+  const intptr_t use_pos = current->lifetime_position() + 1;
+
+  Location* locations =
+      Isolate::Current()->current_zone()->Alloc<Location>(values.length());
+
+  for (intptr_t i = 0; i < values.length(); ++i) {
+    Value* value = values[i];
+    if (value->IsUse()) {
+      locations[i] = Location::Any();
+      Definition* def = value->AsUse()->definition();
+
+      if (def->IsPushArgument()) {
+        // Frame size is unknown until after allocation.
+        locations[i] = Location::NoLocation();
+        continue;
+      }
+
+      const intptr_t vreg = def->ssa_temp_index();
+      LiveRange* range = GetLiveRange(vreg);
+      range->AddUseInterval(block_start_pos, use_pos);
+      range->AddUse(use_pos, &locations[i]);
+    } else {
+      ASSERT(value->IsConstant());
+      locations[i] = Location::NoLocation();
+    }
+  }
+
+  env->set_locations(locations);
+}
+
+
 // Create and update live ranges corresponding to instruction's inputs,
 // temporaries and output.
 void FlowGraphAllocator::ProcessOneInstruction(BlockEntryInstr* block,
                                                Instruction* current) {
   const intptr_t pos = current->lifetime_position();
   ASSERT(IsInstructionStartPosition(pos));
 
   LocationSummary* locs = current->locs();
 
   // TODO(vegorov): number of inputs must match number of input locations.
   if (locs->input_count() != current->InputCount()) {
     builder_->Bailout("ssa allocator: number of input locations mismatch");
   }
 
   // Normalize same-as-first-input output if input is specified as
   // fixed register.
   if (locs->out().IsUnallocated() &&
       (locs->out().policy() == Location::kSameAsFirstInput) &&
       (locs->in(0).IsRegister())) {
     locs->set_out(locs->in(0));
   }
 
   const bool output_same_as_first_input =
       locs->out().IsUnallocated() &&
       (locs->out().policy() == Location::kSameAsFirstInput);
 
   // Add uses from the deoptimization environment.
-  Environment* env = current->env();
-  if (env != NULL) {
-    env->InitializeLocations(this, block->start_pos(), pos + 1);
-  }
+  if (current->env() != NULL) ProcessEnvironmentUses(block, current);
 
   // Process inputs.
   // Skip the first input if output is specified with kSameAsFirstInput policy,
   // they will be processed together at the very end.
   for (intptr_t j = output_same_as_first_input ? 1 : 0;
        j < current->InputCount();
        j++) {
     Value* input = current->InputAt(j);
     ASSERT(input->IsUse());  // Can not be a constant currently.
     const intptr_t vreg = input->AsUse()->definition()->ssa_temp_index();
@@ skipping 1187 matching lines @@
     OS::Print("-- [after ssa allocator] ir [%s] -------------\n",
               function.ToFullyQualifiedCString());
     FlowGraphPrinter printer(Function::Handle(), block_order_, true);
     printer.PrintBlocks();
     OS::Print("----------------------------------------------\n");
   }
 }
 
 
 }  // namespace dart