Simplify generated code for object allocation with type arguments.

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 5530 matching lines @@
     Place* place = (*places)[i];
     aliased_set->AddRepresentative(place);
   }
 
   aliased_set->EnsureAliasingForIndexes();
 
   return aliased_set;
 }
 
 
-static bool HasSimpleTypeArguments(AllocateObjectInstr* alloc) {
-  if (alloc->ArgumentCount() == 0) return true;
-  ASSERT(alloc->ArgumentCount() == 2);
-  Value* arg1 = alloc->PushArgumentAt(1)->value();
-  if (!arg1->BindsToConstant()) return false;
-
-  const Object& obj = arg1->BoundConstant();
-  return obj.IsSmi()
-      && (Smi::Cast(obj).Value() == StubCode::kNoInstantiator);
-}
-
-
 class LoadOptimizer : public ValueObject {
  public:
   LoadOptimizer(FlowGraph* graph,
                 AliasedSet* aliased_set,
                 DirectChainedHashMap<PointerKeyValueTrait<Place> >* map)
       : graph_(graph),
         map_(map),
         aliased_set_(aliased_set),
         in_(graph_->preorder().length()),
         out_(graph_->preorder().length()),
@@ skipping 143 matching lines @@
         // initialized in constructor that potentially can be not inlined into
         // the function that we are currently optimizing. However at the same
         // time we assume that values of the final fields can be forwarded
         // across side-effects. If we add 'null' as known values for these
         // fields here we will incorrectly propagate this null across
         // constructor invocation.
         // TODO(vegorov): record null-values at least for not final fields of
         // escaping object.
         AllocateObjectInstr* alloc = instr->AsAllocateObject();
         if ((alloc != NULL) &&
-            !AliasedSet::CanBeAliased(alloc) &&
-            HasSimpleTypeArguments(alloc)) {
+            !AliasedSet::CanBeAliased(alloc)) {

[regis, 2014/02/13 19:07:50]

single line

[Florian Schneider, 2014/02/14 11:36:34]

Done.

           for (Value* use = alloc->input_use_list();
                use != NULL;
                use = use->next_use()) {
             // Look for all immediate loads from this object.
             if (use->use_index() != 0) {
               continue;
             }
 
             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);
+                ASSERT(alloc->ArgumentCount() == 1);
                 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();
             }
@@ skipping 1468 matching lines @@
         instr->type_arguments().CanShareInstantiatorTypeArguments(
             instr->instantiator_class())) {
       SetValue(instr, object);
       return;
     }
     SetValue(instr, non_constant_);
   }
 }
 
 
-void ConstantPropagator::VisitExtractConstructorTypeArguments(
-    ExtractConstructorTypeArgumentsInstr* instr) {
-  CompileType* type = instr->instantiator()->Type();
-  if (type->HasDecidableNullability()) {
-    if (!type->is_nullable()) {
-      SetValue(instr, instr->type_arguments());
-      return;
-    }
-    ASSERT(type->IsNull());
-    SetValue(instr, instr->instantiator()->definition()->constant_value());
-    return;
-  }
-  SetValue(instr, non_constant_);
-}
-
-
-void ConstantPropagator::VisitExtractConstructorInstantiator(
-    ExtractConstructorInstantiatorInstr* instr) {
-  CompileType* type = instr->instantiator()->Type();
-  if (type->HasDecidableNullability()) {
-    if (type->IsNull()) {
-      SetValue(instr, Smi::ZoneHandle(Smi::New(StubCode::kNoInstantiator)));
-      return;
-    }
-    ASSERT(!type->is_nullable());
-    SetValue(instr, instr->instantiator()->definition()->constant_value());
-    return;
-  }
-  SetValue(instr, non_constant_);
-}
-
-
 void ConstantPropagator::VisitAllocateContext(AllocateContextInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitCloneContext(CloneContextInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
@@ skipping 977 matching lines @@
     }
   }
 }
 
 
 // Right now we are attempting to sink allocation only into
 // 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))) {
       return false;
     }
   }
 
   return true;
@@ skipping 17 matching lines @@
        use = alloc->input_use_list()) {
     use->instruction()->RemoveFromGraph();
   }
 
   // There should be no environment uses. The pass replaced them with
   // MaterializeObject instructions.
   ASSERT(alloc->env_use_list() == NULL);
   ASSERT(alloc->input_use_list() == NULL);
   alloc->RemoveFromGraph();
   if (alloc->ArgumentCount() > 0) {
-    ASSERT(alloc->ArgumentCount() == 2);
+    ASSERT(alloc->ArgumentCount() == 1);
     for (intptr_t i = 0; i < alloc->ArgumentCount(); ++i) {
       alloc->PushArgumentAt(i)->RemoveFromGraph();
     }
   }
 }
 
 
 void AllocationSinking::Optimize() {
   GrowableArray<AllocateObjectInstr*> candidates(5);
 
@@ skipping 154 matching lines @@
       new ZoneGrowableArray<const Field*>(5);
 
   for (Value* use = alloc->input_use_list();
        use != NULL;
        use = use->next_use()) {
     ASSERT(use->instruction()->IsStoreInstanceField());
     AddField(fields, use->instruction()->AsStoreInstanceField()->field());
   }
 
   if (alloc->ArgumentCount() > 0) {
-    ASSERT(alloc->ArgumentCount() == 2);
+    ASSERT(alloc->ArgumentCount() == 1);
     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
             alloc->cls(),
             0));  // No token position.
     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.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *fields);
   }
 }
 
 
 }  // namespace dart