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

runtime/vm/flow_graph_compiler.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/globals.h"  // Needed here to get TARGET_ARCH_XXX.
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/cha.h"
 #include "vm/dart_entry.h"
@@ skipping 23 matching lines @@
 
 // Assign locations to incoming arguments, i.e., values pushed above spill slots
 // with PushArgument.  Recursively allocates from outermost to innermost
 // environment.
 void CompilerDeoptInfo::AllocateIncomingParametersRecursive(
     Environment* env,
     intptr_t* stack_height) {
   if (env == NULL) return;
   AllocateIncomingParametersRecursive(env->outer(), stack_height);
   for (Environment::ShallowIterator it(env); !it.Done(); it.Advance()) {
+    if (it.CurrentLocation().IsInvalid() &&
+        it.CurrentValue()->definition()->IsPushArgument()) {
+      it.SetCurrentLocation(Location::StackSlot((*stack_height)++));
+    }
+  }
+}
+
+
+void CompilerDeoptInfo::EmitMaterializations(Environment* env,
+                                             DeoptInfoBuilder* builder) {
+  for (Environment::DeepIterator it(env); !it.Done(); it.Advance()) {
     if (it.CurrentLocation().IsInvalid()) {
-      ASSERT(it.CurrentValue()->definition()->IsPushArgument());
-      it.SetCurrentLocation(Location::StackSlot((*stack_height)++));
+      MaterializeObjectInstr* mat =
+          it.CurrentValue()->definition()->AsMaterializeObject();
+      ASSERT(mat != NULL);
+      builder->AddMaterialization(mat);
     }
   }
 }
 
 
 RawDeoptInfo* CompilerDeoptInfo::CreateDeoptInfo(FlowGraphCompiler* compiler,
                                                  DeoptInfoBuilder* builder) {
   if (deoptimization_env_ == NULL) return DeoptInfo::null();
 
   intptr_t stack_height = compiler->StackSize();
   AllocateIncomingParametersRecursive(deoptimization_env_, &stack_height);
 
   intptr_t slot_ix = 0;
   Environment* current = deoptimization_env_;
 
+  // Emit all kMaterializeObject instructions describing objects to be
+  // materialized on the deoptimization as a prefix to the deoptimization info.
+  EmitMaterializations(deoptimization_env_, builder);
+
+  // The real frame starts here.
+  builder->MarkFrameStart();
   builder->AddReturnAddress(current->function(),
                             deopt_id(),
                             slot_ix++);
 
+  // Emit all values that are needed for materialization as a part of the
+  // expression stack for the bottom-most frame. This guarantees that GC
+  // will be able to find them during materialization.
+  slot_ix = builder->EmitMaterializationArguments();
+
   // For the innermost environment, set outgoing arguments and the locals.
   for (intptr_t i = current->Length() - 1;
        i >= current->fixed_parameter_count();
        i--) {
     builder->AddCopy(current->ValueAt(i), current->LocationAt(i), slot_ix++);
   }
 
   // PC marker and caller FP.
   builder->AddPcMarker(current->function(), slot_ix++);
   builder->AddCallerFp(slot_ix++);
@@ skipping 1065 matching lines @@
 
   for (int i = 0; i < len; i++) {
     sorted->Add(CidTarget(ic_data.GetReceiverClassIdAt(i),
                           &Function::ZoneHandle(ic_data.GetTargetAt(i)),
                           ic_data.GetCountAt(i)));
   }
   sorted->Sort(HighestCountFirst);
 }
 
 }  // namespace dart