Expand the instruction visitor to visit computations and values.

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 152 matching lines @@
     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(
               owner()->parsed_function().function().result_type());
       AssertAssignableComp* assert =
           new AssertAssignableComp(return_value, type);
       AddInstruction(new BindInstr(temp_index(), assert));
-      return_value = new TempValue(temp_index());
+      return_value = new TempVal(temp_index());
     }
   }
 
   AddInstruction(new ReturnInstr(return_value));
   CloseFragment();
 }
 
 void ValueGraphVisitor::VisitReturnNode(ReturnNode* node) { UNREACHABLE(); }
 void TestGraphVisitor::VisitReturnNode(ReturnNode* node) { UNREACHABLE(); }
 
 
 // <Expression> ::= Literal { literal: Instance }
 void EffectGraphVisitor::VisitLiteralNode(LiteralNode* node) {
   return;
 }
 
 void ValueGraphVisitor::VisitLiteralNode(LiteralNode* node) {
-  ReturnValue(new ConstantValue(node->literal()));
+  ReturnValue(new ConstantVal(node->literal()));
 }
 
 void TestGraphVisitor::VisitLiteralNode(LiteralNode* node) {
-  BranchOnValue(new ConstantValue(node->literal()));
+  BranchOnValue(new ConstantVal(node->literal()));
 }
 
 
 // Type nodes only occur as the right-hand side of instanceof comparisons,
 // and they are handled specially in that context.
 void EffectGraphVisitor::VisitTypeNode(TypeNode* node) { UNREACHABLE(); }
 void ValueGraphVisitor::VisitTypeNode(TypeNode* node) { UNREACHABLE(); }
 void TestGraphVisitor::VisitTypeNode(TypeNode* node) { UNREACHABLE(); }
 
 
@@ skipping 394 matching lines @@
   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 TempValue(index++);
+      argument_value = new TempVal(index++);
     }
     values->Add(argument_value);
   }
 }
 
 // <Expression> ::= StaticCall { function: Function
 //                               arguments: <ArgumentList> }
 StaticCallComp* EffectGraphVisitor::TranslateStaticCall(
     const StaticCallNode& node) {
   int length = node.arguments()->length();
@@ skipping 296 matching lines @@
 }
 void ValueGraphVisitor::VisitInlinedFinallyNode(InlinedFinallyNode* node) {
   Bailout("ValueGraphVisitor::VisitInlinedFinallyNode");
 }
 void TestGraphVisitor::VisitInlinedFinallyNode(InlinedFinallyNode* node) {
   Bailout("TestGraphVisitor::VisitInlinedFinallyNode");
 }
 
 
 // Graph printing.
-class FlowGraphPrinter : public InstructionVisitor {
+class FlowGraphPrinter : public FlowGraphVisitor {
  public:
   explicit FlowGraphPrinter(const Function& function) : function_(function) { }
 
   virtual ~FlowGraphPrinter() {}
 
   // Print the instructions in a block terminated by newlines.  Add "goto N"
   // to the end of the block if it ends with an unconditional jump to
   // another block and that block is not next in reverse postorder.
   void VisitBlocks(const GrowableArray<BlockEntryInstr*>& block_order);
 
-  // Each visit function prints an instruction with a four space
-  // indent and no trailing newline.  Basic block entries are labeled
-  // with their block number.
-#define DECLARE_VISIT(type)                             \
-  virtual void Visit##type(type##Instr* instr);
-  FOR_EACH_INSTRUCTION(DECLARE_VISIT)
-#undef DECLARE_VISIT
+  // Visiting a computation prints it with no indentation or newline.
+#define DECLARE_VISIT_COMPUTATION(ShortName, ClassName)                        \
+  virtual void Visit##ShortName(ClassName* comp);
+
+  // Visiting an instruction prints it with a four space indent and no
+  // trailing newline.  Basic block entries are labeled with their block
+  // number.
+#define DECLARE_VISIT_INSTRUCTION(ShortName)                                   \
+  virtual void Visit##ShortName(ShortName##Instr* instr);
+
+  FOR_EACH_COMPUTATION(DECLARE_VISIT_COMPUTATION)
+  FOR_EACH_INSTRUCTION(DECLARE_VISIT_INSTRUCTION)
+
+#undef DECLARE_VISIT_COMPUTATION
+#undef DECLARE_VISIT_INSTRUCTION
 
  private:
   const Function& function_;
 
   DISALLOW_COPY_AND_ASSIGN(FlowGraphPrinter);
 };
 
 
 void FlowGraphPrinter::VisitBlocks(
     const GrowableArray<BlockEntryInstr*>& block_order) {
   OS::Print("==== %s\n", function_.ToFullyQualifiedCString());
 
   for (intptr_t i = block_order.length() - 1; i >= 0; --i) {
     // Print the block entry.
     Instruction* current = block_order[i]->Accept(this);
     // And all the successors until an exit, branch, or a block entry.
     while ((current != NULL) && !current->IsBlockEntry()) {
       OS::Print("\n");
       current = current->Accept(this);
     }
     if ((current != NULL) && current->IsBlockEntry()) {
       OS::Print(" goto %d", BlockEntryInstr::cast(current)->block_number());
     }
     OS::Print("\n");
   }
 }
 
 
+void FlowGraphPrinter::VisitTemp(TempVal* val) {
+  OS::Print("t%d", val->index());
+}
+
+
+void FlowGraphPrinter::VisitConstant(ConstantVal* val) {
+  OS::Print("#%s", val->instance().ToCString());
+}
+
+
+void FlowGraphPrinter::VisitAssertAssignable(AssertAssignableComp* comp) {
+  OS::Print("AssertAssignable(");
+  comp->value()->Accept(this);
+  OS::Print(", %s)", comp->type().ToCString());
+}
+
+
+void FlowGraphPrinter::VisitInstanceCall(InstanceCallComp* comp) {
+  OS::Print("InstanceCall(%s", comp->name());
+  for (int i = 0; i < comp->ArgumentCount(); ++i) {
+    OS::Print(", ");
+    comp->ArgumentAt(i)->Accept(this);
+  }
+  OS::Print(")");
+}
+
+
+void FlowGraphPrinter::VisitStrictCompare(StrictCompareComp* comp) {
+  OS::Print("StrictCompare(%s, ", Token::Str(comp->kind()));
+  comp->left()->Accept(this);
+  OS::Print(", ");
+  comp->right()->Accept(this);
+  OS::Print(")");
+}
+
+
+
+void FlowGraphPrinter::VisitStaticCall(StaticCallComp* comp) {
+  OS::Print("StaticCall(%s",
+            String::Handle(comp->function().name()).ToCString());
+  for (int i = 0; i < comp->ArgumentCount(); ++i) {
+    OS::Print(", ");
+    comp->ArgumentAt(i)->Accept(this);
+  }
+  OS::Print(")");
+}
+
+
+void FlowGraphPrinter::VisitLoadLocal(LoadLocalComp* comp) {
+  OS::Print("LoadLocal(%s)", comp->local().name().ToCString());
+}
+
+
+void FlowGraphPrinter::VisitStoreLocal(StoreLocalComp* comp) {
+  OS::Print("StoreLocal(%s, ", comp->local().name().ToCString());
+  comp->value()->Accept(this);
+  OS::Print(")");
+}
+
+
 void FlowGraphPrinter::VisitJoinEntry(JoinEntryInstr* instr) {
   OS::Print("%2d: [join]", instr->block_number());
 }
 
 
 void FlowGraphPrinter::VisitTargetEntry(TargetEntryInstr* instr) {
   OS::Print("%2d: [target]", instr->block_number());
 }
 
 
 void FlowGraphPrinter::VisitDo(DoInstr* instr) {
   OS::Print("    ");
-  instr->computation()->Print();
+  instr->computation()->Accept(this);
 }
 
 
 void FlowGraphPrinter::VisitBind(BindInstr* instr) {
   OS::Print("    t%d <-", instr->temp_index());
-  instr->computation()->Print();
+  instr->computation()->Accept(this);
 }
 
 
 void FlowGraphPrinter::VisitReturn(ReturnInstr* instr) {
   OS::Print("    return ");
-  instr->value()->Print();
+  instr->value()->Accept(this);
 }
 
 
 void FlowGraphPrinter::VisitBranch(BranchInstr* instr) {
   OS::Print("    if ");
-  instr->value()->Print();
+  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);
   if (for_effect.entry() != NULL) {
@@ skipping 18 matching lines @@
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, kFormat, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart