Allow test context to have multiple true and false branch slots.

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/code_descriptors.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
@@ skipping 128 matching lines @@
   // and a pair of effect graph fragments with zero or one available exits.
   // We want to append the branch and (if necessary) a join node to this
   // graph fragment.
   ASSERT(is_open());
 
   // 1. Connect the test to this graph.
   Append(test_fragment);
 
   // 2. Connect the true and false bodies to the test and record their exits
   // (if any).
-  TargetEntryInstr* true_entry = new TargetEntryInstr(owner()->try_index());
-  *test_fragment.true_successor_address() = true_entry;
+  BlockEntryInstr* true_entry = test_fragment.CreateTrueSuccessor();
   Instruction* true_exit = AppendFragment(true_entry, true_fragment);
 
-  TargetEntryInstr* false_entry = new TargetEntryInstr(owner()->try_index());
-  *test_fragment.false_successor_address() = false_entry;
+  BlockEntryInstr* false_entry = test_fragment.CreateFalseSuccessor();
   Instruction* false_exit = AppendFragment(false_entry, false_fragment);
 
   // 3. Add a join or select one (or neither) of the arms as exit.
   if (true_exit == NULL) {
     exit_ = false_exit;  // May be NULL.
     if (false_exit != NULL) temp_index_ = false_fragment.temp_index();
   } else if (false_exit == NULL) {
     exit_ = true_exit;
     temp_index_ = true_fragment.temp_index();
   } else {
@@ skipping 10 matching lines @@
 void EffectGraphVisitor::TieLoop(const TestGraphVisitor& test_fragment,
                                  const EffectGraphVisitor& body_fragment) {
   // We have: a test graph fragment with zero, one, or two available exits;
   // and an effect graph fragment with zero or one available exits.  We want
   // to append the 'while loop' consisting of the test graph fragment as
   // condition and the effect graph fragment as body.
   ASSERT(is_open());
 
   // 1. Connect the body to the test if it is reachable, and if so record
   // its exit (if any).
-  TargetEntryInstr* body_entry = new TargetEntryInstr(owner()->try_index());
-  *test_fragment.true_successor_address() = body_entry;
+  BlockEntryInstr* body_entry = test_fragment.CreateTrueSuccessor();
   Instruction* body_exit = AppendFragment(body_entry, body_fragment);
 
   // 2. Connect the test to this graph, including the body if reachable and
   // using a fresh join node if the body is reachable and has an open exit.
   if (body_exit == NULL) {
     Append(test_fragment);
   } else {
     JoinEntryInstr* join = new JoinEntryInstr(owner()->try_index());
     join->set_next(test_fragment.entry());
     Goto(join);
     body_exit->Goto(join);
   }
 
   // 3. Set the exit to the graph to be the false successor of the test, a
   // fresh target node
-  exit_ = *test_fragment.false_successor_address() =
-      new TargetEntryInstr(owner()->try_index());
+
+  exit_ = test_fragment.CreateFalseSuccessor();
 }
 
 
 PushArgumentInstr* EffectGraphVisitor::PushArgument(Value* value) {
   PushArgumentInstr* result = new PushArgumentInstr(value);
   AddInstruction(result);
   return result;
 }
 
 
@@ skipping 45 matching lines @@
 }
 
 
 // Loads context saved in 'context_variable' into the current context.
 void EffectGraphVisitor::BuildLoadContext(const LocalVariable& variable) {
   Value* load_saved_context = Bind(BuildLoadLocal(variable));
   Do(new StoreContextComp(load_saved_context));
 }
 
 
+void TestGraphVisitor::ConnectBranchesTo(
+    const GrowableArray<TargetEntryInstr**>& branches,
+    JoinEntryInstr* join) const {
+  ASSERT(!branches.is_empty());
+  for (intptr_t i = 0; i < branches.length(); i++) {
+    TargetEntryInstr* target = new TargetEntryInstr(owner()->try_index());
+    *(branches[i]) = target;
+    target->Goto(join);
+  }
+}
+
+
+void TestGraphVisitor::IfTrueGoto(JoinEntryInstr* join) const {
+  ConnectBranchesTo(true_successor_addresses_, join);
+}
+
+
+void TestGraphVisitor::IfFalseGoto(JoinEntryInstr* join) const {
+  ConnectBranchesTo(false_successor_addresses_, join);
+}
+
+
+BlockEntryInstr* TestGraphVisitor::CreateSuccessorFor(
+    const GrowableArray<TargetEntryInstr**>& branches) const {
+  ASSERT(!branches.is_empty());
+
+  if (branches.length() == 1) {
+    TargetEntryInstr* target = new TargetEntryInstr(owner()->try_index());
+    *(branches[0]) = target;
+    return target;
+  }
+
+  JoinEntryInstr* join = new JoinEntryInstr(owner()->try_index());
+  ConnectBranchesTo(branches, join);
+  return join;
+}
+
+
+BlockEntryInstr* TestGraphVisitor::CreateTrueSuccessor() const {
+  return CreateSuccessorFor(true_successor_addresses_);
+}
+
+
+BlockEntryInstr* TestGraphVisitor::CreateFalseSuccessor() const {
+  return CreateSuccessorFor(false_successor_addresses_);
+}
+
+
 void TestGraphVisitor::ReturnValue(Value* value) {
   if (FLAG_enable_type_checks) {
     value = Bind(new AssertBooleanComp(condition_token_pos(), value));
   }
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   Value* constant_true = Bind(new ConstantComp(bool_true));
   StrictCompareComp* comp =
       new StrictCompareComp(Token::kEQ_STRICT, value, constant_true);
   BranchInstr* branch = new BranchInstr(comp);
   AddInstruction(branch);
   CloseFragment();
-  true_successor_address_ = branch->true_successor_address();
-  false_successor_address_ = branch->false_successor_address();
+
+  true_successor_addresses_.Add(branch->true_successor_address());
+  false_successor_addresses_.Add(branch->false_successor_address());
 }
 
 
 void TestGraphVisitor::MergeBranchWithComparison(ComparisonComp* comp) {
   ASSERT(!FLAG_enable_type_checks);
   ControlInstruction* branch;
   if (Token::IsStrictEqualityOperator(comp->kind())) {
     branch = new BranchInstr(new StrictCompareComp(comp->kind(),
                                                    comp->left(),
                                                    comp->right()));
   } else if (Token::IsEqualityOperator(comp->kind()) &&
              (comp->left()->BindsToConstantNull() ||
               comp->right()->BindsToConstantNull())) {
     branch = new BranchInstr(new StrictCompareComp(
         (comp->kind() == Token::kEQ) ? Token::kEQ_STRICT : Token::kNE_STRICT,
         comp->left(),
         comp->right()));
   } else {
     branch = new BranchInstr(comp);
   }
   AddInstruction(branch);
   CloseFragment();
-  true_successor_address_ = branch->true_successor_address();
-  false_successor_address_ = branch->false_successor_address();
+  true_successor_addresses_.Add(branch->true_successor_address());
+  false_successor_addresses_.Add(branch->false_successor_address());
 }
 
 
 void TestGraphVisitor::MergeBranchWithNegate(BooleanNegateComp* comp) {
   ASSERT(!FLAG_enable_type_checks);
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   Value* constant_true = Bind(new ConstantComp(bool_true));
   BranchInstr* branch = new BranchInstr(
       new StrictCompareComp(Token::kNE_STRICT,
                             comp->value(),
                             constant_true));
   AddInstruction(branch);
   CloseFragment();
-  true_successor_address_ = branch->true_successor_address();
-  false_successor_address_ = branch->false_successor_address();
+  true_successor_addresses_.Add(branch->true_successor_address());
+  false_successor_addresses_.Add(branch->false_successor_address());
 }
 
 
 void TestGraphVisitor::ReturnComputation(Computation* computation) {
   if (!FLAG_enable_type_checks) {
     if (computation->AsComparison() != NULL) {
       MergeBranchWithComparison(computation->AsComparison());
       return;
     }
     if (computation->IsBooleanNegate()) {
       MergeBranchWithNegate(computation->AsBooleanNegate());
       return;
     }
   }
   ReturnValue(Bind(computation));
 }
 
 
+// Special handling for AND/OR.
+void TestGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
+  InlineBailout("TestGraphVisitor::VisitBinaryOpNode");
+
+  // Operators "&&" and "||" cannot be overloaded therefore do not call
+  // operator.
+  if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
+    TestGraphVisitor for_left(owner(),
+                              temp_index(),
+                              node->left()->token_pos());
+    node->left()->Visit(&for_left);
+
+    TestGraphVisitor for_right(owner(),
+                               temp_index(),
+                               node->right()->token_pos());
+    node->right()->Visit(&for_right);
+
+    Append(for_left);
+
+    if (node->kind() == Token::kAND) {
+      AppendFragment(for_left.CreateTrueSuccessor(), for_right);
+      true_successor_addresses_.AddArray(for_right.true_successor_addresses_);
+      false_successor_addresses_.AddArray(for_left.false_successor_addresses_);
+      false_successor_addresses_.AddArray(for_right.false_successor_addresses_);
+    } else {
+      ASSERT(node->kind() == Token::kOR);
+      AppendFragment(for_left.CreateFalseSuccessor(), for_right);
+      false_successor_addresses_.AddArray(for_right.false_successor_addresses_);
+      true_successor_addresses_.AddArray(for_left.true_successor_addresses_);
+      true_successor_addresses_.AddArray(for_right.true_successor_addresses_);
+    }
+    CloseFragment();
+    return;
+  }
+  ValueGraphVisitor::VisitBinaryOpNode(node);
+}
+
+
 void EffectGraphVisitor::Bailout(const char* reason) {
   owner()->Bailout(reason);
 }
 
 
 void EffectGraphVisitor::InlineBailout(const char* reason) {
   if (owner()->InInliningContext()) owner()->Bailout(reason);
 }
 
 
@@ skipping 668 matching lines @@
       AppendFragment(statement_start, for_case_statements);
   if (is_open() && (len == 0)) {
     ASSERT(node->contains_default());
     // Default only case node.
     Goto(statement_start);
     exit_ = statement_exit;
     return;
   }
 
   // Generate instructions for all case expressions.
-  TargetEntryInstr** previous_false_address = NULL;
+  TargetEntryInstr* next_target = NULL;
   for (intptr_t i = 0; i < len; i++) {
     AstNode* case_expr = node->case_expressions()->NodeAt(i);
     TestGraphVisitor for_case_expression(owner(),
                                          temp_index(),
                                          case_expr->token_pos());
     case_expr->Visit(&for_case_expression);
     if (i == 0) {
       // Append only the first one, everything else is connected from it.
       Append(for_case_expression);
     } else {
-      TargetEntryInstr* case_entry_target =
-          new TargetEntryInstr(owner()->try_index());
-      AppendFragment(case_entry_target, for_case_expression);
-      *previous_false_address = case_entry_target;
+      ASSERT(next_target != NULL);
+      AppendFragment(next_target, for_case_expression);
     }
-    TargetEntryInstr* true_target =
-        new TargetEntryInstr(owner()->try_index());
-    *for_case_expression.true_successor_address() = true_target;
-    true_target->Goto(statement_start);
-    previous_false_address = for_case_expression.false_successor_address();
+    for_case_expression.IfTrueGoto(statement_start);
+    next_target = for_case_expression.CreateFalseSuccessor()->AsTargetEntry();
   }
 
   // Once a test fragment has been added, this fragment is closed.
   ASSERT(!is_open());
 
   Instruction* exit_instruction = NULL;
   // Handle last (or only) case: false goes to exit or to statement if this
   // node contains default.
   if (len > 0) {
-    TargetEntryInstr* false_target =
-        new TargetEntryInstr(owner()->try_index());
-    *previous_false_address = false_target;
+    ASSERT(next_target != NULL);
     if (node->contains_default()) {
       // True and false go to statement start.
-      false_target->Goto(statement_start);
+      next_target->Goto(statement_start);
       exit_instruction = statement_exit;
     } else {
       if (statement_exit != NULL) {
         JoinEntryInstr* join = new JoinEntryInstr(owner()->try_index());
         statement_exit->Goto(join);
-        false_target->Goto(join);
+        next_target->Goto(join);
         exit_instruction = join;
       } else {
-        exit_instruction = false_target;
+        exit_instruction = next_target;
       }
     }
   } else {
     // A CaseNode without case expressions must contain default.
     ASSERT(node->contains_default());
     Goto(statement_start);
     exit_instruction = statement_exit;
   }
 
   ASSERT(!is_open());
@@ skipping 71 matching lines @@
 
   JoinEntryInstr* join = node->label()->join_for_continue();
   if ((body_exit != NULL) || (join != NULL)) {
     if (join == NULL) join = new JoinEntryInstr(owner()->try_index());
     join->set_next(for_test.entry());
     if (body_exit != NULL) {
       body_exit->Goto(join);
     }
   }
 
-  TargetEntryInstr* back_target_entry =
-      new TargetEntryInstr(owner()->try_index());
-  *for_test.true_successor_address() = back_target_entry;
-  back_target_entry->Goto(body_entry_join);
-  TargetEntryInstr* loop_exit_target =
-      new TargetEntryInstr(owner()->try_index());
-  *for_test.false_successor_address() = loop_exit_target;
+
+  for_test.IfTrueGoto(body_entry_join);
   if (node->label()->join_for_break() == NULL) {
-    exit_ = loop_exit_target;
+    exit_ = for_test.CreateFalseSuccessor();
   } else {
-    loop_exit_target->Goto(node->label()->join_for_break());
+    for_test.IfFalseGoto(node->label()->join_for_break());
     exit_ = node->label()->join_for_break();
   }
 }
 
 
 // A ForNode can contain break and continue jumps. 'break' joins to
 // ForNode exit, 'continue' joins at increment entry. The fragment is composed
 // as follows:
 // a) [ initializer ]
 // b) loop-join
@@ skipping 50 matching lines @@
   if (node->condition() == NULL) {
     // Endless loop, no test.
     JoinEntryInstr* body_entry = new JoinEntryInstr(owner()->try_index());
     AppendFragment(body_entry, for_body);
     Goto(body_entry);
     if (node->label()->join_for_break() != NULL) {
       // Control flow of ForLoop continues into join_for_break.
       exit_ = node->label()->join_for_break();
     }
   } else {
-    TargetEntryInstr* loop_exit = new TargetEntryInstr(owner()->try_index());
     TestGraphVisitor for_test(owner(),
                               temp_index(),
                               node->condition()->token_pos());
     node->condition()->Visit(&for_test);
     Append(for_test);
-    TargetEntryInstr* body_entry = new TargetEntryInstr(owner()->try_index());
+
+    BlockEntryInstr* body_entry = for_test.CreateTrueSuccessor();
     AppendFragment(body_entry, for_body);
-    *for_test.true_successor_address() = body_entry;
-    *for_test.false_successor_address() = loop_exit;
+
     if (node->label()->join_for_break() == NULL) {
-      exit_ = loop_exit;
+      exit_ = for_test.CreateFalseSuccessor();
     } else {
-      loop_exit->Goto(node->label()->join_for_break());
+      for_test.IfFalseGoto(node->label()->join_for_break());
       exit_ = node->label()->join_for_break();
     }
   }
 }
 
 
 void EffectGraphVisitor::VisitJumpNode(JumpNode* node) {
   InlineBailout("EffectGraphVisitor::VisitJumpNode");
   for (intptr_t i = 0; i < node->inlined_finally_list_length(); i++) {
     EffectGraphVisitor for_effect(owner(), temp_index());
@@ skipping 1271 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