Implement DoWhile.

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/flags.h"
 #include "vm/intermediate_language.h"
 #include "vm/longjump.h"
 #include "vm/os.h"
 #include "vm/parser.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, print_flow_graph, false, "Print the IR flow graph.");
 DECLARE_FLAG(bool, enable_type_checks);
+DECLARE_FLAG(bool, print_ast);
 
 void EffectGraphVisitor::Append(const EffectGraphVisitor& other_fragment) {
   ASSERT(is_open());
   if (other_fragment.is_empty()) return;
   if (is_empty()) {
     entry_ = other_fragment.entry();
     exit_ = other_fragment.exit();
   } else {
     exit()->SetSuccessor(other_fragment.entry());
     exit_ = other_fragment.exit();
@@ skipping 183 matching lines @@
 }
 
 
 // <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)) {
+    // Implement short-circuit logic: do not evaluate right if evaluation
+    // of left is sufficient.
     Bailout("EffectGraphVisitor::VisitBinaryOpNode AND/OR");
   }
   ArgumentGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   ArgumentGraphVisitor for_right_value(owner(), for_left_value.temp_index());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(for_left_value.value());
@@ skipping 202 matching lines @@
   TestGraphVisitor for_test(owner(), temp_index());
   node->condition()->Visit(&for_test);
 
   EffectGraphVisitor for_body(owner(), temp_index());
   if (for_test.can_be_true()) node->body()->Visit(&for_body);
   TieLoop(for_test, for_body);
 }
 
 
 void EffectGraphVisitor::VisitDoWhileNode(DoWhileNode* node) {
-  Bailout("EffectGraphVisitor::VisitDoWhileNode");
+  EffectGraphVisitor for_body(owner(), temp_index());
+  node->body()->Visit(&for_body);
+  TestGraphVisitor for_test(owner(), temp_index());
+  node->condition()->Visit(&for_test);
+  ASSERT(is_open());
+
+  // Tie do-while loop (test is after the body).

[Kevin Millikin (Google), 2012/03/07 09:15:44]

I think we can come up with a generic loop-tying function, for all loop forms. 
It is parameterized over two edges: entry to the whole loop (either entry to
test for test at the top, or entry to body for test at the bottom), optional
back edge (body exit for test at the top, true successor of test for test at the
bottom).  It takes a partially tied loop and does the rest.

Let's keep that in mind for later.  There isn't really much duplicated code
between the two kinds of loop right now, but there will be for break and
continue handling.

+  JoinEntryInstr* join = new JoinEntryInstr();
+  AddInstruction(join);
+  join->SetSuccessor(for_body.entry());
+  Instruction* body_exit = for_body.is_empty() ? join : for_body.exit();

[Kevin Millikin (Google), 2012/03/07 09:15:44]

This is correct but contains introduces an extra basic block in the case where
the body is not empty.  OK to leave it as is for now (especially since we
haven't sorted out continue), but it can be eliminated if we want later.

+
+  if (body_exit != NULL) {
+    TargetEntryInstr* target_entry = new TargetEntryInstr();
+    target_entry->SetSuccessor(for_test.entry());
+    body_exit->SetSuccessor(target_entry);
+  }
+
+  *for_test.true_successor_address() = join;
+  exit_ = *for_test.false_successor_address() = new TargetEntryInstr();
 }
 
 
 void EffectGraphVisitor::VisitForNode(ForNode* node) {
   Bailout("EffectGraphVisitor::VisitForNode");
 }
 
 
 void EffectGraphVisitor::VisitJumpNode(JumpNode* node) {
   Bailout("EffectGraphVisitor::VisitJumpNode");
@@ skipping 500 matching lines @@
 
 void FlowGraphPrinter::VisitBranch(BranchInstr* instr) {
   OS::Print("    if ");
   instr->value()->Accept(this);
   OS::Print(" goto(%d, %d)", instr->true_successor()->block_number(),
             instr->false_successor()->block_number());
 }
 
 
 void FlowGraphBuilder::BuildGraph() {
+  if (FLAG_print_ast) {
+    // Print the function ast before IL generation.
+    AstPrinter::PrintFunctionNodes(parsed_function_);
+  }
   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;
@@ skipping 15 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