Reapply "Deoptimization support in inlined code."

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.h"
@@ skipping 131 matching lines @@
       // Handle uses.
       for (intptr_t j = 0; j < current->InputCount(); j++) {
         Value* input = current->InputAt(j);
         const intptr_t use = input->definition()->ssa_temp_index();
         live_in->Add(use);
       }
 
       // Add non-argument uses from the deoptimization environment (pushed
       // arguments are not allocated by the register allocator).
       if (current->env() != NULL) {
-        for (intptr_t i = 0; i < current->env()->Length(); ++i) {
-          Value* value = current->env()->ValueAt(i);
-          if (!value->definition()->IsPushArgument()) {
+        for (Environment::DeepIterator env_it(current->env());
+             !env_it.Done();
+             env_it.Advance()) {
+          Value* value = env_it.CurrentValue();
+          if (!value->definition()->IsPushArgument() &&
+              !value->BindsToConstant()) {
             live_in->Add(value->definition()->ssa_temp_index());
           }
         }
       }
     }
 
     // Handle phis.
     if (block->IsJoinEntry()) {
       JoinEntryInstr* join = block->AsJoinEntry();
       if (join->phis() != NULL) {
@@ skipping 566 matching lines @@
 
       move_idx++;
     }
   }
 }
 
 
 void FlowGraphAllocator::ProcessEnvironmentUses(BlockEntryInstr* block,
                                                 Instruction* current) {
   ASSERT(current->env() != NULL);
+  Environment* env = current->env();
+  while (env != NULL) {
+    // 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    -----*
+    //
 
-  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    -----*
-  //
-
-  if (env->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>(env->Length());
-
-  for (intptr_t i = 0; i < env->Length(); ++i) {
-    Value* value = env->ValueAt(i);
-    locations[i] = Location::Any();
-    Definition* def = value->definition();
-
-    if (def->IsPushArgument()) {
-      // Frame size is unknown until after allocation.
-      locations[i] = Location::NoLocation();
+    if (env->Length() == 0) {
+      env = env->outer();
       continue;
     }
 
-    ConstantInstr* constant = def->AsConstant();
-    if (constant != NULL) {
-      locations[i] = Location::Constant(constant->value());
-      continue;
+    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>(env->Length());
+
+    for (intptr_t i = 0; i < env->Length(); ++i) {
+      Value* value = env->ValueAt(i);
+      locations[i] = Location::Any();
+      Definition* def = value->definition();
+
+      if (def->IsPushArgument()) {
+        // Frame size is unknown until after allocation.
+        locations[i] = Location::NoLocation();
+        continue;
+      }
+
+      ConstantInstr* constant = def->AsConstant();
+      if (constant != NULL) {
+        locations[i] = Location::Constant(constant->value());
+        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]);
     }
 
-    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]);
+    env->set_locations(locations);
+    env = env->outer();
   }
-
-  env->set_locations(locations);
 }
 
 
 // Create and update live ranges corresponding to instruction's inputs,
 // temporaries and output.
 void FlowGraphAllocator::ProcessOneInstruction(BlockEntryInstr* block,
                                                Instruction* current) {
   LocationSummary* locs = current->locs();
 
   Definition* def = current->AsDefinition();
@@ skipping 570 matching lines @@
   UseInterval* first_after_split = interval;
   if (!split_at_start && interval->Contains(split_pos)) {
     first_after_split = new UseInterval(split_pos,
                                         interval->end(),
                                         interval->next());
     interval->end_ = split_pos;
     interval->next_ = first_after_split;
     last_before_split = interval;
   }
 
+  ASSERT(last_before_split != NULL);
   ASSERT(last_before_split->next() == first_after_split);
   ASSERT(last_before_split->end() <= split_pos);
   ASSERT(split_pos <= first_after_split->start());
 
   UsePosition* first_use_after_split =
       SplitListOfPositions(&uses_, split_pos, split_at_start);
 
   SafepointPosition* first_safepoint_after_split =
       SplitListOfPositions(&first_safepoint_, split_pos, split_at_start);
 
@@ skipping 822 matching lines @@
     OS::Print("-- [after ssa allocator] ir [%s] -------------\n",
               function.ToFullyQualifiedCString());
     FlowGraphPrinter printer(flow_graph_, true);
     printer.PrintBlocks();
     OS::Print("----------------------------------------------\n");
   }
 }
 
 
 }  // namespace dart