Implement a variation of scalar replacement for non-escaping allocations.

runtime/vm/flow_graph_allocator.cc

 // Copyright (c) 2013, 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 84 matching lines @@
     blocked_cpu_registers_[PP] = true;
   }
   blocked_cpu_registers_[SPREG] = true;
   blocked_cpu_registers_[FPREG] = true;
 
   // FpuTMP is used as scratch by optimized code and parallel move resolver.
   blocked_fpu_registers_[FpuTMP] = true;
 }
 
 
-// Remove environments from the instructions which can't deoptimize.
-void FlowGraphAllocator::EliminateEnvironments() {
-  for (intptr_t i = 0; i < block_order_.length(); ++i) {
-    BlockEntryInstr* block = block_order_[i];
-    for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
-      Instruction* current = it.Current();
-      if (!current->CanDeoptimize()) current->RemoveEnvironment();
-    }
-  }
-}
-
-
 void SSALivenessAnalysis::ComputeInitialSets() {
   const intptr_t block_count = postorder_.length();
   for (intptr_t i = 0; i < block_count; i++) {
     BlockEntryInstr* block = postorder_[i];
 
     BitVector* kill = kill_[i];
     BitVector* live_in = live_in_[i];
 
     // Iterate backwards starting at the last instruction.
     for (BackwardInstructionIterator it(block); !it.Done(); it.Advance()) {
@@ skipping 18 matching lines @@
 
         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 (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());
+          Definition* defn = env_it.CurrentValue()->definition();
+          if (defn->IsMaterializeObject()) {
+            // MaterializeObject instruction is not in the graph.
+            // Treat its inputs as part of the environment.
+            for (intptr_t i = 0; i < defn->InputCount(); i++) {
+              if (!defn->InputAt(i)->BindsToConstant()) {
+                live_in->Add(defn->InputAt(i)->definition()->ssa_temp_index());
+              }
+            }
+          } else if (!defn->IsPushArgument() && !defn->IsConstant()) {
+            live_in->Add(defn->ssa_temp_index());
           }
         }
       }
     }
 
     // Handle phis.
     if (block->IsJoinEntry()) {
       JoinEntryInstr* join = block->AsJoinEntry();
       for (PhiIterator it(join); !it.Done(); it.Advance()) {
         PhiInstr* phi = it.Current();
@@ skipping 566 matching lines @@
         locations[i] = Location::NoLocation();
         continue;
       }
 
       ConstantInstr* constant = def->AsConstant();
       if (constant != NULL) {
         locations[i] = Location::Constant(constant->value());
         continue;
       }
 
+      MaterializeObjectInstr* mat = def->AsMaterializeObject();
+      if (mat != NULL) {
+        // MaterializeObject itself produces no value. But its uses
+        // are treated as part of the environment: allocated locations
+        // will be used when building deoptimization data.
+        locations[i] = Location::NoLocation();
+        ProcessMaterializationUses(block, block_start_pos, use_pos, mat);
+        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]);
     }
 
     env->set_locations(locations);
     env = env->outer();
   }
 }
 
 
+void FlowGraphAllocator::ProcessMaterializationUses(
+    BlockEntryInstr* block,
+    const intptr_t block_start_pos,
+    const intptr_t use_pos,
+    MaterializeObjectInstr* mat) {
+  // Materialization can occur several times in the same environment.
+  // Check if we already processed this one.
+  if (mat->locations() != NULL) {
+    return;  // Already processed.
+  }
+
+  // Initialize location for every input of the MaterializeObject instruction.
+  Location* locations =
+      Isolate::Current()->current_zone()->Alloc<Location>(mat->InputCount());
+
+  for (intptr_t i = 0; i < mat->InputCount(); ++i) {
+    Definition* def = mat->InputAt(i)->definition();
+
+    ConstantInstr* constant = def->AsConstant();
+    if (constant != NULL) {
+      locations[i] = Location::Constant(constant->value());
+      continue;
+    }
+
+    locations[i] = Location::Any();
+
+    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]);
+  }
+
+  mat->set_locations(locations);
+}
+
+
 // Create and update live ranges corresponding to instruction's inputs,
 // temporaries and output.
 void FlowGraphAllocator::ProcessOneInstruction(BlockEntryInstr* block,
                                                Instruction* current,
                                                BitVector* interference_set) {
   LocationSummary* locs = current->locs();
 
   Definition* def = current->AsDefinition();
   if ((def != NULL) && (def->AsConstant() != NULL)) {
     LiveRange* range = (def->ssa_temp_index() != -1) ?
@@ skipping 1661 matching lines @@
         value_representations_[def->ssa_temp_index()] = def->representation();
       }
     }
   }
 }
 
 
 void FlowGraphAllocator::AllocateRegisters() {
   CollectRepresentations();
 
-  EliminateEnvironments();
-
   liveness_.Analyze();
 
   NumberInstructions();
 
   DiscoverLoops();
 
   BuildLiveRanges();
 
   if (FLAG_print_ssa_liveness) {
     liveness_.Dump();
@@ skipping 50 matching lines @@
     OS::Print("-- [after ssa allocator] ir [%s] -------------\n",
               function.ToFullyQualifiedCString());
     FlowGraphPrinter printer(flow_graph_, true);
     printer.PrintBlocks();
     OS::Print("----------------------------------------------\n");
   }
 }
 
 
 }  // namespace dart