Support allocation sinking for compound objects.

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 104 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;
 }
 
 
+static void DeepLiveness(MaterializeObjectInstr* mat, BitVector* live_in) {
+  if (mat->was_visited_for_liveness()) {
+    return;
+  }
+  mat->mark_visited_for_liveness();
+
+  for (intptr_t i = 0; i < mat->InputCount(); i++) {
+    if (!mat->InputAt(i)->BindsToConstant()) {
+      Definition* defn = mat->InputAt(i)->definition();
+      MaterializeObjectInstr* inner_mat = defn->AsMaterializeObject();
+      if (inner_mat != NULL) {
+        DeepLiveness(inner_mat, live_in);
+      } else {
+        intptr_t idx = defn->ssa_temp_index();
+        live_in->Add(idx);
+      }
+    }
+  }
+}
+
+
 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 31 matching lines @@
       // 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()) {
           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()) {
-                intptr_t idx = defn->InputAt(i)->definition()->ssa_temp_index();
-                live_in->Add(idx);
-              }
-            }
+            DeepLiveness(defn->AsMaterializeObject(), live_in);
           } else if (!defn->IsPushArgument() && !defn->IsConstant()) {
             live_in->Add(defn->ssa_temp_index());
             if (defn->HasPairRepresentation()) {
               live_in->Add(ToSecondPairVreg(defn->ssa_temp_index()));
             }
           }
         }
       }
     }
 
@@ skipping 690 matching lines @@
     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());
+  mat->set_locations(locations);
 
   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;
     }
 
     if (def->HasPairRepresentation()) {
       locations[i] = Location::Pair(Location::Any(), Location::Any());
       PairLocation* location_pair = locations[i].AsPairLocation();
       {
         // First live range.
         LiveRange* range = GetLiveRange(def->ssa_temp_index());
         range->AddUseInterval(block_start_pos, use_pos);
         range->AddUse(use_pos, location_pair->SlotAt(0));
       }
       {
         // Second live range.
         LiveRange* range =
             GetLiveRange(ToSecondPairVreg(def->ssa_temp_index()));
         range->AddUseInterval(block_start_pos, use_pos);
         range->AddUse(use_pos, location_pair->SlotAt(1));
       }
+    } else if (def->IsMaterializeObject()) {
+      locations[i] = Location::NoLocation();
+      ProcessMaterializationUses(
+          block, block_start_pos, use_pos, def->AsMaterializeObject());
     } else {
       locations[i] = Location::Any();
       LiveRange* range = GetLiveRange(def->ssa_temp_index());
       range->AddUseInterval(block_start_pos, use_pos);
       range->AddUse(use_pos, &locations[i]);
     }
   }
-
-  mat->set_locations(locations);
 }
 
 
 void FlowGraphAllocator::ProcessOneInput(BlockEntryInstr* block,
                                          intptr_t pos,
                                          Location* in_ref,
                                          Value* input,
                                          intptr_t vreg,
                                          RegisterSet* live_registers) {
   ASSERT(in_ref != NULL);
@@ skipping 1950 matching lines @@
     OS::Print("-- [after ssa allocator] ir [%s] -------------\n",
               function.ToFullyQualifiedCString());
     FlowGraphPrinter printer(flow_graph_, true);
     printer.PrintBlocks();
     OS::Print("----------------------------------------------\n");
   }
 }
 
 
 }  // namespace dart