Align AllocateObjectComp and AllocateObjectWithBoundsCheckComp with ssa allocator.

runtime/vm/flow_graph_builder.cc

 // Copyright (c) 2012, 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_builder.h"
 
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
@@ skipping 1435 matching lines @@
                                            context));
   ReturnComputation(new StoreContextComp(clone));
 }
 
 
 Value* EffectGraphVisitor::BuildObjectAllocation(
     ConstructorCallNode* node) {
   const Class& cls = Class::ZoneHandle(node->constructor().owner());
   const bool requires_type_arguments = cls.HasTypeArguments();
 
-  ZoneGrowableArray<Value*>* allocate_arguments =
-      new ZoneGrowableArray<Value*>();
-  if (requires_type_arguments) {
-    BuildConstructorTypeArguments(node, allocate_arguments);
-  }
   // In checked mode, if the type arguments are uninstantiated, they may need to
   // be checked against declared bounds at run time.
   Computation* allocate_comp = NULL;
   if (FLAG_enable_type_checks &&
       requires_type_arguments &&
       !node->type_arguments().IsNull() &&
       !node->type_arguments().IsInstantiated() &&
       !node->type_arguments().IsWithinBoundsOf(cls,
                                                node->type_arguments(),
                                                NULL)) {
+    Value* type_arguments = NULL;
+    Value* instantiator = NULL;
+    BuildConstructorTypeArguments(node, &type_arguments, &instantiator, NULL);
+
     // The uninstantiated type arguments cannot be verified to be within their
     // bounds at compile time, so verify them at runtime.
     // Although the type arguments may be uninstantiated at compile time, they
     // may represent the identity vector and may be replaced by the instantiated
     // type arguments of the instantiator at run time.
     allocate_comp = new AllocateObjectWithBoundsCheckComp(node,
                                                           owner()->try_index(),
-                                                          allocate_arguments);
+                                                          type_arguments,
+                                                          instantiator);
   } else {
+    ZoneGrowableArray<PushArgumentInstr*>* allocate_arguments =
+        new ZoneGrowableArray<PushArgumentInstr*>();
+
+    if (requires_type_arguments) {
+      BuildConstructorTypeArguments(node, NULL, NULL, allocate_arguments);
+    }
+
     allocate_comp = new AllocateObjectComp(node,
                                            owner()->try_index(),
                                            allocate_arguments);
   }
   return Bind(allocate_comp);
 }
 
 
 void EffectGraphVisitor::BuildConstructorCall(
     ConstructorCallNode* node,
@@ skipping 132 matching lines @@
       BuildInstantiatorTypeArguments(token_pos, NULL);
   return Bind(new InstantiateTypeArgumentsComp(token_pos,
                                                owner()->try_index(),
                                                type_arguments,
                                                instantiator_value));
 }
 
 
 void EffectGraphVisitor::BuildConstructorTypeArguments(
     ConstructorCallNode* node,
-    ZoneGrowableArray<Value*>* args) {
+    Value** type_arguments,
+    Value** instantiator,
+    ZoneGrowableArray<PushArgumentInstr*>* call_arguments) {

[Vyacheslav Egorov (Google), 2012/08/08 19:28:55]

This function became a little bit ugly.

I did not find any good way to share it properly because PushArgument should be
interleaved with Binds

[Florian Schneider, 2012/08/09 12:25:58]

Yes, it seems that this helper is not the right abstraction. We should keep in
mind cleaning it up at a later point.

   const Class& cls = Class::ZoneHandle(node->constructor().owner());
   ASSERT(cls.HasTypeArguments() && !node->constructor().IsFactory());
   if (node->type_arguments().IsNull() ||
       node->type_arguments().IsInstantiated()) {
-    Value* type_args = Bind(new ConstantVal(node->type_arguments()));
+    Value* type_arguments_val = Bind(new ConstantVal(node->type_arguments()));
+    if (call_arguments != NULL) {
+      ASSERT(type_arguments == NULL);
+      call_arguments->Add(PushArgument(type_arguments_val));
+    } else {
+      ASSERT(type_arguments != NULL);
+      *type_arguments = type_arguments_val;
+    }
+
     // No instantiator required.
-    Value* no_instantiator = Bind(
+    Value* instantiator_val = Bind(
         new ConstantVal(Smi::ZoneHandle(Smi::New(StubCode::kNoInstantiator))));
-    args->Add(type_args);
-    args->Add(no_instantiator);
+    if (call_arguments != NULL) {
+      ASSERT(instantiator == NULL);
+      call_arguments->Add(PushArgument(instantiator_val));
+    } else {
+      ASSERT(instantiator != NULL);
+      *instantiator = instantiator_val;
+    }
     return;
   }
   // The type arguments are uninstantiated. The generated pseudo code:
   //   t1 = InstantiatorTypeArguments();
   //   t2 = ExtractConstructorTypeArguments(t1);
   //   t1 = ExtractConstructorInstantiator(t1);
   //   t_n   <- t2
   //   t_n+1 <- t1
   // Use expression_temp_var and node->allocated_object_var() locals to keep
   // intermediate results around (t1 and t2 above).
@@ skipping 16 matching lines @@
 
   Do(BuildStoreLocal(t2, extract_type_arguments));
   // t2: extracted constructor type arguments.
   Value* load_instantiator = Bind(BuildLoadLocal(t1));
 
   Value* extract_instantiator =
       Bind(new ExtractConstructorInstantiatorComp(node, load_instantiator));
   Do(BuildStoreLocal(t1, extract_instantiator));
   // t2: extracted constructor type arguments.
   // t1: extracted constructor instantiator.
-  Value* load_0 = Bind(BuildLoadLocal(t2));
-  Value* load_1 = Bind(BuildLoadLocal(t1));
-  args->Add(load_0);
-  args->Add(load_1);
+  Value* type_arguments_val = Bind(BuildLoadLocal(t2));
+  if (call_arguments != NULL) {
+    ASSERT(type_arguments == NULL);
+    call_arguments->Add(PushArgument(type_arguments_val));
+  } else {
+    ASSERT(type_arguments != NULL);
+    *type_arguments = type_arguments_val;
+  }
+
+  Value* instantiator_val = Bind(BuildLoadLocal(t1));
+  if (call_arguments != NULL) {
+    ASSERT(instantiator == NULL);
+    call_arguments->Add(PushArgument(instantiator_val));
+  } else {
+    ASSERT(instantiator != NULL);
+    *instantiator = instantiator_val;
+  }
 }
 
 
 void ValueGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
     EffectGraphVisitor::VisitConstructorCallNode(node);
     return;
   }
 
   // t_n contains the allocated and initialized object.
@@ skipping 1052 matching lines @@
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart