Refactor the IL for object allocation with type arguments.

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 "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
@@ skipping 1999 matching lines @@
 }
 
 
 Value* EffectGraphVisitor::BuildObjectAllocation(
     ConstructorCallNode* node) {
   const Class& cls = Class::ZoneHandle(node->constructor().Owner());
   const bool requires_type_arguments = cls.HasTypeArguments();
 
   // In checked mode, if the type arguments are uninstantiated, they may need to
   // be checked against declared bounds at run time.
-  Definition* allocate_comp = NULL;
+  Definition* allocation = NULL;
   if (FLAG_enable_type_checks &&
       requires_type_arguments &&
       !node->type_arguments().IsNull() &&
       !node->type_arguments().IsInstantiated() &&
       node->type_arguments().IsBounded()) {
-    Value* type_arguments = NULL;
-    Value* instantiator = NULL;
-    BuildConstructorTypeArguments(node, &type_arguments, &instantiator, NULL);
+    ZoneGrowableArray<PushArgumentInstr*>* allocate_arguments =
+        new ZoneGrowableArray<PushArgumentInstr*>(4);
+    // Argument 1: Empty argument slot for return value.
+    Value* null_val = Bind(new ConstantInstr(Object::ZoneHandle()));
+    allocate_arguments->Add(PushArgument(null_val));
+    // Argument 2: Class.
+    Value* cls_val =
+        Bind(new ConstantInstr(Class::ZoneHandle(node->constructor().Owner())));
+    allocate_arguments->Add(PushArgument(cls_val));
+    // Build arguments 3 and 4.
+    BuildConstructorTypeArguments(node, allocate_arguments);
 
     // The uninstantiated type arguments cannot be verified to be within their
     // bounds at compile time, so verify them at runtime.
-    allocate_comp = new AllocateObjectWithBoundsCheckInstr(node,
-                                                           type_arguments,
-                                                           instantiator);
+    allocation = new AllocateObjectWithBoundsCheckInstr(node);
   } else {
     ZoneGrowableArray<PushArgumentInstr*>* allocate_arguments =
         new ZoneGrowableArray<PushArgumentInstr*>();
-
     if (requires_type_arguments) {
-      BuildConstructorTypeArguments(node, NULL, NULL, allocate_arguments);
+      BuildConstructorTypeArguments(node, allocate_arguments);
     }
 
-    allocate_comp = new AllocateObjectInstr(node, allocate_arguments);
+    allocation = new AllocateObjectInstr(node, allocate_arguments);
   }
-  return Bind(allocate_comp);
+  return Bind(allocation);
 }
 
 
 void EffectGraphVisitor::BuildConstructorCall(
     ConstructorCallNode* node,
     PushArgumentInstr* push_alloc_value) {
   Value* ctor_arg = Bind(
       new ConstantInstr(Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll))));
   PushArgumentInstr* push_ctor_arg = PushArgument(ctor_arg);
 
@@ skipping 186 matching lines @@
       BuildInstantiatorTypeArguments(token_pos, instantiator_class, NULL);
   return Bind(new InstantiateTypeArgumentsInstr(token_pos,
                                                 type_arguments,
                                                 instantiator_class,
                                                 instantiator_value));
 }
 
 
 void EffectGraphVisitor::BuildConstructorTypeArguments(
     ConstructorCallNode* node,
-    Value** type_arguments,
-    Value** instantiator,
     ZoneGrowableArray<PushArgumentInstr*>* call_arguments) {
   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_arguments_val = Bind(new ConstantInstr(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;
-    }
+    call_arguments->Add(PushArgument(type_arguments_val));
 
     // No instantiator required.
     Value* instantiator_val = Bind(new ConstantInstr(
         Smi::ZoneHandle(Smi::New(StubCode::kNoInstantiator))));
-    if (call_arguments != NULL) {
-      ASSERT(instantiator == NULL);
-      call_arguments->Add(PushArgument(instantiator_val));
-    } else {
-      ASSERT(instantiator != NULL);
-      *instantiator = instantiator_val;
-    }
+    call_arguments->Add(PushArgument(instantiator_val));
     return;
   }
+
   // The type arguments are uninstantiated. We use expression_temp_var to save
-  // the instantiator type arguments becuase they have two uses.
+  // the instantiator type arguments because they have two uses.
   ASSERT(owner()->parsed_function().expression_temp_var() != NULL);
   const LocalVariable& temp = *owner()->parsed_function().expression_temp_var();
   const Class& instantiator_class = Class::Handle(
       owner()->parsed_function().function().Owner());
   Value* type_arguments_val = BuildInstantiatorTypeArguments(
       node->token_pos(), instantiator_class, NULL);
 
   const bool use_instantiator_type_args =
       node->type_arguments().IsUninstantiatedIdentity() ||
       node->type_arguments().CanShareInstantiatorTypeArguments(
           instantiator_class);
 
   if (!use_instantiator_type_args) {
-    type_arguments_val =
-        Bind(BuildStoreTemp(temp, type_arguments_val));
-    type_arguments_val = Bind(
-        new ExtractConstructorTypeArgumentsInstr(
-            node->token_pos(),
-            node->type_arguments(),
-            instantiator_class,
-            type_arguments_val));
+    const intptr_t len = node->type_arguments().Length();
+    if (node->type_arguments().IsRawInstantiatedRaw(len)) {
+      type_arguments_val =
+          Bind(BuildStoreTemp(temp, type_arguments_val));
+      type_arguments_val = Bind(
+          new ExtractConstructorTypeArgumentsInstr(
+              node->token_pos(),
+              node->type_arguments(),
+              instantiator_class,
+              type_arguments_val));
+    } else {
+      Do(BuildStoreTemp(temp, type_arguments_val));
+      type_arguments_val = Bind(new ConstantInstr(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;
-  }
+  call_arguments->Add(PushArgument(type_arguments_val));
 
   Value* instantiator_val = NULL;
   if (!use_instantiator_type_args) {
     instantiator_val = Bind(BuildLoadLocal(temp));
-    instantiator_val =
-        Bind(new ExtractConstructorInstantiatorInstr(node,
-                                                     instantiator_class,
-                                                     instantiator_val));
+    const intptr_t len = node->type_arguments().Length();
+    if (node->type_arguments().IsRawInstantiatedRaw(len)) {
+      instantiator_val =
+          Bind(new ExtractConstructorInstantiatorInstr(node,
+                                                       instantiator_class,
+                                                       instantiator_val));
+    }
   } else {
     // No instantiator required.
     instantiator_val = Bind(new ConstantInstr(
         Smi::ZoneHandle(Smi::New(StubCode::kNoInstantiator))));
   }
-
-  if (call_arguments != NULL) {
-    ASSERT(instantiator == NULL);
-    call_arguments->Add(PushArgument(instantiator_val));
-  } else {
-    ASSERT(instantiator != NULL);
-    *instantiator = instantiator_val;
-  }
+  call_arguments->Add(PushArgument(instantiator_val));
 }
 
 
 void ValueGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
     EffectGraphVisitor::VisitConstructorCallNode(node);
     return;
   }
 
   // t_n contains the allocated and initialized object.
@@ skipping 1046 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