Get rid of CHECK_ALIVE, test only is_open during sequence node traversal.

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/flags.h"
 #include "vm/intermediate_language.h"
 #include "vm/longjump.h"
 #include "vm/os.h"
@@ skipping 116 matching lines @@
   true_successor_address_ = branch->true_successor_address();
   false_successor_address_ = branch->false_successor_address();
 }
 
 
 void EffectGraphVisitor::Bailout(const char* reason) {
   owner()->Bailout(reason);
 }
 
 
-// 'bailout' is a statement (without a semicolon), typically a return.
-#define CHECK_ALIVE(bailout)                            \
-  do {                                                  \
-    if (!is_open()) {                                   \
-      bailout;                                          \
-    }                                                   \
-  } while (false)
-
-
 // <Statement> ::= Return { value:                <Expression>
 //                          inlined_finally_list: <InlinedFinally>* }
 void EffectGraphVisitor::VisitReturnNode(ReturnNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
-  CHECK_ALIVE(return);
 
   for (intptr_t i = 0; i < node->inlined_finally_list_length(); i++) {
     EffectGraphVisitor for_effect(owner(), for_value.temp_index());
     node->InlinedFinallyNodeAt(i)->Visit(&for_effect);
     Append(for_effect);
-    CHECK_ALIVE(return);
+    if (!is_open()) return;
   }
 
   Value* return_value = for_value.value();
   if (FLAG_enable_type_checks) {
     const RawFunction::Kind kind = owner()->parsed_function().function().kind();
     // Implicit getters do not need a type check at return.
     if ((kind != RawFunction::kImplicitGetter) &&
         (kind != RawFunction::kConstImplicitGetter)) {
       const AbstractType& type =
           AbstractType::ZoneHandle(
@@ skipping 29 matching lines @@
 void EffectGraphVisitor::VisitTypeNode(TypeNode* node) { UNREACHABLE(); }
 
 
 // <Expression> :: Assignable { expr:     <Expression>
 //                              type:     AbstractType
 //                              dst_name: String }
 void EffectGraphVisitor::VisitAssignableNode(AssignableNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->expr()->Visit(&for_value);
   Append(for_value);
-  CHECK_ALIVE(return);
-
   AssertAssignableComp* assert =
       new AssertAssignableComp(for_value.value(), node->type());
   ReturnComputation(assert);
 }
 
 
 // <Expression> :: BinaryOp { kind:  Token::Kind
 //                            left:  <Expression>
 //                            right: <Expression> }
 void EffectGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     Bailout("EffectGraphVisitor::VisitBinaryOpNode AND/OR");
   }
   ValueGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
-  CHECK_ALIVE(return);
   ValueGraphVisitor for_right_value(owner(), for_left_value.temp_index());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
-  CHECK_ALIVE(return);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(for_left_value.value());
   arguments->Add(for_right_value.value());
   InstanceCallComp* call = new InstanceCallComp(node->Name(), arguments);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitStringConcatNode(StringConcatNode* node) {
   Bailout("EffectGraphVisitor::VisitStringConcatNode");
 }
 
 
 // <Expression> :: Comparison { kind:  Token::Kind
 //                              left:  <Expression>
 //                              right: <Expression> }
 void EffectGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
   if (Token::IsInstanceofOperator(node->kind())) {
     Bailout("instanceof not yet implemented");
   } else if ((node->kind() == Token::kEQ) || (node->kind() == Token::kNE)) {
     Bailout("'==' or '!=' comparison not yet implemented");
   }
   ValueGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
-  CHECK_ALIVE(return);
   ValueGraphVisitor for_right_value(owner(), for_left_value.temp_index());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
-  CHECK_ALIVE(return);
   if ((node->kind() == Token::kEQ_STRICT) ||
       (node->kind() == Token::kNE_STRICT)) {
     StrictCompareComp* comp = new StrictCompareComp(
         node->kind(), for_left_value.value(), for_right_value.value());
     ReturnComputation(comp);
     return;
   }
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(for_left_value.value());
   arguments->Add(for_right_value.value());
@@ skipping 118 matching lines @@
 
 
 void EffectGraphVisitor::VisitInstanceCallNode(InstanceCallNode* node) {
   ArgumentListNode* arguments = node->arguments();
   int length = arguments->length();
   ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>(length + 1);
 
   ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
-  CHECK_ALIVE(return);
   Value* receiver_value = for_receiver.value();
   temp_index_ = for_receiver.temp_index();
   if (receiver_value->IsConstant()) {
     AddInstruction(new BindInstr(temp_index(), receiver_value));
     receiver_value = new TempVal(AllocateTempIndex());
   }
   values->Add(receiver_value);
 
   TranslateArgumentList(*arguments, values);
-  CHECK_ALIVE(return);
   InstanceCallComp* call =
       new InstanceCallComp(node->function_name().ToCString(), values);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::TranslateArgumentList(
     const ArgumentListNode& node, ZoneGrowableArray<Value*>* values) {
   int index = temp_index();
   for (intptr_t i = 0; i < node.length(); ++i) {
     ValueGraphVisitor for_value(owner(), index);
     node.NodeAt(i)->Visit(&for_value);
     Append(for_value);
-    CHECK_ALIVE(return);
     Value* argument_value = for_value.value();
     index = for_value.temp_index();
     if (argument_value->IsConstant()) {
       AddInstruction(new BindInstr(index, argument_value));
       argument_value = new TempVal(index++);
     }
     values->Add(argument_value);
   }
 }
 
 // <Expression> ::= StaticCall { function: Function
 //                               arguments: <ArgumentList> }
 void EffectGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
   int length = node->arguments()->length();
   ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>(length);
   TranslateArgumentList(*node->arguments(), values);
-  CHECK_ALIVE(return);
   StaticCallComp* call = new StaticCallComp(node->function(), values);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
   Bailout("EffectGraphVisitor::VisitClosureCallNode");
 }
 
 
@@ skipping 52 matching lines @@
   ReturnComputation(load);
 }
 
 
 // <Expression> ::= StoreLocal { local: LocalVariable
 //                               value: <Expression> }
 void EffectGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
-  CHECK_ALIVE(return);
   StoreLocalComp* store = new StoreLocalComp(node->local(), for_value.value());
   ReturnComputation(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadInstanceFieldNode(
     LoadInstanceFieldNode* node) {
   Bailout("EffectGraphVisitor::VisitLoadInstanceFieldNode");
 }
 
@@ skipping 25 matching lines @@
 
 
 // <Statement> ::= Sequence { scope: LocalScope
 //                            nodes: <Statement>*
 //                            label: SourceLabel }
 void EffectGraphVisitor::VisitSequenceNode(SequenceNode* node) {
   if ((node->scope() != NULL) &&
       (node->scope()->num_context_variables() != 0)) {
     Bailout("Sequence needs a context.  Gotta have a context.");
   }
-  for (intptr_t i = 0; i < node->length(); ++i) {
+  intptr_t i = 0;
+  while (is_open() && (i < node->length())) {
     EffectGraphVisitor for_effect(owner(), temp_index());
-    node->NodeAt(i)->Visit(&for_effect);
+    node->NodeAt(i++)->Visit(&for_effect);
     Append(for_effect);
-    CHECK_ALIVE(return);
   }
 }
 
 
 void EffectGraphVisitor::VisitCatchClauseNode(CatchClauseNode* node) {
   Bailout("EffectGraphVisitor::VisitCatchClauseNode");
 }
 
 
 void EffectGraphVisitor::VisitTryCatchNode(TryCatchNode* node) {
@@ skipping 159 matching lines @@
   instr->value()->Accept(this);
   OS::Print(" goto(%d, %d)", instr->true_successor()->block_number(),
             instr->false_successor()->block_number());
 }
 
 
 void FlowGraphBuilder::BuildGraph() {
   EffectGraphVisitor for_effect(this, 0);
   for_effect.AddInstruction(new TargetEntryInstr());
   parsed_function().node_sequence()->Visit(&for_effect);
+  // Check that the graph is properly terminated.
+  ASSERT(!for_effect.is_open());
   if (for_effect.entry() != NULL) {
     // Accumulate basic block entries via postorder traversal.
     for_effect.entry()->Postorder(&postorder_block_entries_);
     // Number the blocks in reverse postorder starting with 0.
     intptr_t last_index = postorder_block_entries_.length() - 1;
     for (intptr_t i = last_index; i >= 0; --i) {
       postorder_block_entries_[i]->set_block_number(last_index - i);
     }
   }
   if (FLAG_print_flow_graph) {
@@ skipping 10 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