Implement object allocation/construction as effect (no result), sequence labels and unchaining fro…

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/dart_entry.h"
 #include "vm/flags.h"
 #include "vm/intermediate_language.h"
@@ skipping 1258 matching lines @@
 void EffectGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
   AddInstruction(new BindInstr(temp_index(), new CurrentContextComp()));
   TempVal* ctx = new TempVal(temp_index());
   AddInstruction(new BindInstr(temp_index(),
                  new CloneContextComp(node->id(), node->token_index(), ctx)));
   TempVal* cloned_ctx = new TempVal(temp_index());
   ReturnComputation(new StoreContextComp(cloned_ctx));
 }
 
 
+TempVal* EffectGraphVisitor::BuildObjectAllocation(ConstructorCallNode* node,
+                                                   int start_index) {
+  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, start_index, allocate_arguments);
+  }
+  AllocateObjectComp* alloc_comp =
+      new AllocateObjectComp(node, allocate_arguments);
+  AddInstruction(new BindInstr(start_index, alloc_comp));
+  return new TempVal(start_index);
+}
+
+
+void EffectGraphVisitor::BuildConstructorCall(ConstructorCallNode* node,
+                                              int start_index,
+                                              Value* alloc_value) {
+  ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>();
+  values->Add(alloc_value);
+  const Smi& ctor_arg = Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll));
+  TempVal* ctor_arg_value = new TempVal(start_index);
+  AddInstruction(
+      new BindInstr(ctor_arg_value->index(), new ConstantVal(ctor_arg)));
+  values->Add(ctor_arg_value);
+  TranslateArgumentList(*node->arguments(), start_index + 1, values);
+  StaticCallComp* call =
+      new StaticCallComp(node->token_index(),
+                         node->constructor(),
+                         node->arguments()->names(),
+                         values);
+  AddInstruction(new DoInstr(call));
+}
+
+
 void EffectGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
     ZoneGrowableArray<Value*>* factory_arguments =
         new ZoneGrowableArray<Value*>();
     factory_arguments->Add(BuildFactoryTypeArguments(node, temp_index()));
     ASSERT(factory_arguments->length() == 1);
     TranslateArgumentList(*node->arguments(),
                           temp_index() + 1,
                           factory_arguments);
     StaticCallComp* call =
         new StaticCallComp(node->token_index(),
                            node->constructor(),
                            node->arguments()->names(),
                            factory_arguments);
     ReturnComputation(call);
     return;
   }
-  Bailout("EffectGraphVisitor::VisitConstructorCallNode");
+  // t_n contains the allocated and initialized object.
+  //   t_n      <- AllocateObject(class)
+  //   t_n+1    <- ctor-arg
+  //   t_n+2... <- constructor arguments start here
+  //   StaticCall(constructor, t_n+1, t_n+2, ...)
+  // No need to preserve allocated value (simpler than in ValueGraphVisitor).
+  TempVal* alloc_value = BuildObjectAllocation(node, temp_index());
+  BuildConstructorCall(node, alloc_value->index() + 1, alloc_value);
 }
 
 
 Value* EffectGraphVisitor::BuildInstantiatorTypeArguments(
     intptr_t token_index, intptr_t start_index) {
   const Class& instantiator_class = Class::Handle(
       owner()->parsed_function().function().owner());
   if (instantiator_class.NumTypeParameters() == 0) {
     // The type arguments are compile time constants.
     AbstractTypeArguments& type_arguments = AbstractTypeArguments::ZoneHandle();
@@ skipping 97 matching lines @@
   args->Add(constructor_instantiator_value);
 }
 
 
 void ValueGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
     EffectGraphVisitor::VisitConstructorCallNode(node);
     return;
   }
 
-  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, temp_index(), allocate_arguments);
-  }
   // t_n contains the allocated and initialized object.
   //   t_n      <- AllocateObject(class)
   //   t_n+1    <- Pick(t_n)
   //   t_n+2    <- ctor-arg
   //   t_n+3... <- constructor arguments start here
   //   StaticCall(constructor, t_n+1, t_n+2, ...)
 
-  AllocateObjectComp* alloc_comp =
-      new AllocateObjectComp(node, allocate_arguments);
-  AddInstruction(new BindInstr(temp_index(), alloc_comp));
+  TempVal* alloc_value = BuildObjectAllocation(node, temp_index());
   intptr_t result_index = AllocateTempIndex();
-  TempVal* alloc_value = new TempVal(result_index);
+
   TempVal* dup_alloc_value = new TempVal(result_index + 1);
-  TempVal* ctor_arg_value = new TempVal(result_index + 2);
   AddInstruction(
       new PickTempInstr(dup_alloc_value->index(), alloc_value->index()));
 
-  ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>();
-  values->Add(dup_alloc_value);
-  const Smi& ctor_arg = Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll));
-  AddInstruction(
-      new BindInstr(ctor_arg_value->index(), new ConstantVal(ctor_arg)));
-  values->Add(ctor_arg_value);
-  TranslateArgumentList(*node->arguments(), result_index + 3, values);
-  StaticCallComp* call =
-      new StaticCallComp(node->token_index(),
-                         node->constructor(),
-                         node->arguments()->names(),
-                         values);
-  AddInstruction(new DoInstr(call));
+  BuildConstructorCall(node, dup_alloc_value->index() + 1, dup_alloc_value);
   ReturnValue(alloc_value);
 }
 
 
 void EffectGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
   ArgumentGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(1);
   arguments->Add(for_receiver.value());
@@ skipping 53 matching lines @@
 }
 
 
 void EffectGraphVisitor::VisitNativeBodyNode(NativeBodyNode* node) {
   NativeCallComp* native_call = new NativeCallComp(node);
   ReturnComputation(native_call);
 }
 
 
 void EffectGraphVisitor::VisitPrimaryNode(PrimaryNode* node) {
-  Bailout("EffectGraphVisitor::VisitPrimaryNode");
+  // PrimaryNodes are temporary during parsing.
+  UNREACHABLE();
 }
 
 
 // <Expression> ::= LoadLocal { local: LocalVariable }
 void EffectGraphVisitor::VisitLoadLocalNode(LoadLocalNode* node) {
   return;
 }
 
 
 void ValueGraphVisitor::VisitLoadLocalNode(LoadLocalNode* node) {
@@ skipping 247 matching lines @@
           new LoadLocalComp(*owner()->parsed_function().saved_context_var(), 0);
       AddInstruction(new BindInstr(temp_index(), load_comp));
       TempVal* local_value = new TempVal(temp_index());
       StoreContextComp* store_context = new StoreContextComp(local_value);
       AddInstruction(new DoInstr(store_context));
     } else if (num_context_variables > 0) {
       UnchainContext();
     }
   }
 
+  // No continue on sequence allowed.
+  ASSERT((node->label() == NULL) ||
+         (node->label()->join_for_continue() == NULL));
   // If this node sequence is labeled, a break out of the sequence will have
   // taken care of unchaining the context.
   if ((node->label() != NULL) &&
-      ((node->label()->join_for_break() != NULL) ||
-      (node->label()->join_for_continue() != NULL))) {
-    Bailout("Jump in SequenceNode");
+      (node->label()->join_for_break() != NULL)) {
+    if (is_open()) {
+      AddInstruction(node->label()->join_for_break());
+    } else {
+      exit_ = node->label()->join_for_break();
+    }
   }
 
-  if (node->label() != NULL) {
-    // TODO(srdjan): Check that the break label is bound? Is this a jump?
-    Bailout("VisitSequenceNode bind break and unchain CTX");
-  }
+  // The outermost function sequence cannot contain a label.
+  ASSERT((node->label() == NULL) ||
+         (node != owner()->parsed_function().node_sequence()));
   owner()->set_context_level(previous_context_level);
 }
 
 
 void EffectGraphVisitor::VisitCatchClauseNode(CatchClauseNode* node) {
   Bailout("EffectGraphVisitor::VisitCatchClauseNode");
 }
 
 
 void EffectGraphVisitor::VisitTryCatchNode(TryCatchNode* node) {
@@ skipping 524 matching lines @@
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(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