Enable allocation sinking for closures.

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/dart_entry.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 1309 matching lines @@
       field.Offset(),
       AbstractType::ZoneHandle(field.type()),
       field.is_final());
   load->set_field(&field);
   if (field.guarded_cid() != kIllegalCid) {
     if (!field.is_nullable() || (field.guarded_cid() == kNullCid)) {
       load->set_result_cid(field.guarded_cid());
     }
     AddToGuardedFields(field);
   }
-  load->set_field_name(String::Handle(field.name()).ToCString());
 
   // Discard the environment from the original instruction because the load
   // can't deoptimize.
   call->RemoveEnvironment();
   ReplaceCall(call, load);
 
   if (load->result_cid() != kDynamicCid) {
     // Reset value types if guarded_cid was used.
     for (Value::Iterator it(load->input_use_list());
          !it.Done();
@@ skipping 3432 matching lines @@
 
             LoadFieldInstr* load = use->instruction()->AsLoadField();
             if (load != NULL) {
               // Found a load. Initialize current value of the field to null for
               // normal fields, or with type arguments.
               gen->Add(load->place_id());
               if (out_values == NULL) out_values = CreateBlockOutValues();
 
               if (alloc->ArgumentCount() > 0) {
                 ASSERT(alloc->ArgumentCount() == 2);
-                const Class& cls = Class::Handle(alloc->constructor().Owner());
-                intptr_t type_args_offset = cls.type_arguments_field_offset();
+                intptr_t type_args_offset =
+                    alloc->cls().type_arguments_field_offset();
                 if (load->offset_in_bytes() == type_args_offset) {
                   (*out_values)[load->place_id()] =
                       alloc->PushArgumentAt(0)->value()->definition();
                   continue;
                 }
               }
               (*out_values)[load->place_id()] = graph_->constant_null();
             }
           }
           continue;
@@ skipping 2373 matching lines @@
 // deoptimization exit. So candidate should only be used in StoreInstanceField
 // instructions that write into fields of the allocated object.
 // We do not support materialization of the object that has type arguments.
 static bool IsAllocationSinkingCandidate(AllocateObjectInstr* alloc) {
   if (!HasSimpleTypeArguments(alloc)) return false;
 
   for (Value* use = alloc->input_use_list();
        use != NULL;
        use = use->next_use()) {
     if (!(use->instruction()->IsStoreInstanceField() &&
-          use->use_index() == 0)) {
+          (use->use_index() == 0))) {
       return false;
     }
   }
 
   return true;
 }
 
 
 // Remove the given allocation from the graph. It is not observable.
 // If deoptimization occurs the object will be materialized.
@@ skipping 117 matching lines @@
     }
   }
   fields->Add(&field);
 }
 
 
 // Add given instruction to the list of the instructions if it is not yet
 // present there.
 static void AddInstruction(GrowableArray<Instruction*>* exits,
                            Instruction* exit) {
+  ASSERT(!exit->IsGraphEntry());
   for (intptr_t i = 0; i < exits->length(); i++) {
     if ((*exits)[i] == exit) {
       return;
     }
   }
   exits->Add(exit);
 }
 
 
 // Insert MaterializeObject instruction for the given allocation before
@@ skipping 55 matching lines @@
 
   if (alloc->ArgumentCount() > 0) {
     ASSERT(alloc->ArgumentCount() == 2);
     const String& name = String::Handle(Symbols::New(":type_args"));
     const Field& type_args_field =
         Field::ZoneHandle(Field::New(
             name,
             false,  // !static
             false,  // !final
             false,  // !const
-            Class::Handle(alloc->constructor().Owner()),
+            alloc->cls(),
             0));  // No token position.
-    const Class& cls = Class::Handle(alloc->constructor().Owner());
-    type_args_field.SetOffset(cls.type_arguments_field_offset());
+    type_args_field.SetOffset(alloc->cls().type_arguments_field_offset());
     AddField(fields, type_args_field);
   }
 
   // Collect all instructions that mention this object in the environment.
   GrowableArray<Instruction*> exits(10);
   for (Value* use = alloc->env_use_list();
        use != NULL;
        use = use->next_use()) {
     AddInstruction(&exits, use->instruction());
   }
 
   // Insert materializations at environment uses.
-  const Class& cls = Class::Handle(alloc->constructor().Owner());
   for (intptr_t i = 0; i < exits.length(); i++) {
-    CreateMaterializationAt(exits[i], alloc, cls, *fields);
+    CreateMaterializationAt(exits[i], alloc, alloc->cls(), *fields);
   }
 }
 
 
 }  // namespace dart