VM: Optimized context allocation on all platforms.

runtime/vm/flow_graph_optimizer.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_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 4392 matching lines @@
       }
       field.set_is_unboxing_candidate(false);
       field.DeoptimizeDependentCode();
     } else {
       FlowGraph::AddToGuardedFields(flow_graph_->guarded_fields(), &field);
     }
   }
 }
 
 
+void FlowGraphOptimizer::VisitAllocateContext(AllocateContextInstr* instr) {

[srdjan, 2014/08/11 21:42:34]

Why don't you do that in the FlowGraphBuilder instead?

[Florian Schneider, 2014/08/13 14:56:12]

I only want the inlined code for unoptimized code for code size reasons.
Performance-wise it only matters in optimized code anyway.

+  // Replace generic allocation with a sequence of inlined allocation and
+  // explicit initalizing stores.
+  AllocateUninitializedContextInstr* replacement =
+      new AllocateUninitializedContextInstr(instr->token_pos(),
+                                            instr->num_context_variables());
+  instr->ReplaceWith(replacement, current_iterator());
+
+  Definition* def =
+      new(I) StoreInstanceFieldInstr(Context::parent_offset(),
+                                     new Value(replacement),
+                                     new Value(flow_graph_->constant_null()),
+                                     kNoStoreBarrier,
+                                     instr->token_pos());
+  flow_graph_->InsertAfter(replacement, def, NULL, FlowGraph::kEffect);
+  Definition* cursor = def;
+  for (intptr_t i = 0; i < instr->num_context_variables(); ++i) {
+    def =
+        new(I) StoreInstanceFieldInstr(Context::variable_offset(i),
+                                       new Value(replacement),
+                                       new Value(flow_graph_->constant_null()),
+                                       kNoStoreBarrier,
+                                       instr->token_pos());
+    flow_graph_->InsertAfter(cursor, def, NULL, FlowGraph::kEffect);
+    cursor = def;
+  }
+}
+
+
 bool FlowGraphOptimizer::TryInlineInstanceSetter(InstanceCallInstr* instr,
                                                  const ICData& unary_ic_data) {
   ASSERT((unary_ic_data.NumberOfChecks() > 0) &&
       (unary_ic_data.NumArgsTested() == 1));
   if (FLAG_enable_type_checks) {
     // Checked mode setters are inlined like normal methods by conventional
     // inlining.
     return false;
   }
 
@@ skipping 4217 matching lines @@
     SetValue(instr, non_constant_);
   }
 }
 
 
 void ConstantPropagator::VisitAllocateContext(AllocateContextInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
+void ConstantPropagator::VisitAllocateUninitializedContext(
+    AllocateUninitializedContextInstr* instr) {
+  SetValue(instr, non_constant_);
+}
+
+
 void ConstantPropagator::VisitCloneContext(CloneContextInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::HandleBinaryOp(Definition* instr,
                                         Token::Kind op_kind,
                                         const Value& left_val,
                                         const Value& right_val) {
   const Object& left = left_val.definition()->constant_value();
@@ skipping 1755 matching lines @@
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits_collector_.exits().length(); i++) {
     CreateMaterializationAt(
         exits_collector_.exits()[i], alloc, alloc->cls(), *slots);
   }
 }
 
 
 }  // namespace dart