Adding Native Call node : a native function consists of that node, it does call into C runtime. In …

runtime/vm/flow_graph_builder.cc

Index: runtime/vm/flow_graph_builder.cc
===================================================================
--- runtime/vm/flow_graph_builder.cc	(revision 4774)
+++ runtime/vm/flow_graph_builder.cc	(working copy)
@@ -178,10 +178,7 @@
   CloseFragment();
 }
 
-void ValueGraphVisitor::VisitReturnNode(ReturnNode* node) { UNREACHABLE(); }
-void TestGraphVisitor::VisitReturnNode(ReturnNode* node) { UNREACHABLE(); }
 
-
 // <Expression> ::= Literal { literal: Instance }
 void EffectGraphVisitor::VisitLiteralNode(LiteralNode* node) {
   return;
@@ -199,233 +196,125 @@
 // 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(); }
 
 
 // <Expression> :: Assignable { expr:     <Expression>
 //                              type:     AbstractType
 //                              dst_name: String }
-AssertAssignableComp* EffectGraphVisitor::TranslateAssignable(
-    const AssignableNode& node) {
+void EffectGraphVisitor::VisitAssignableNode(AssignableNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
-  node.expr()->Visit(&for_value);
+  node->expr()->Visit(&for_value);
   Append(for_value);
-  CHECK_ALIVE(return NULL);
-
-  return new AssertAssignableComp(for_value.value(), node.type());
-}
-
-void EffectGraphVisitor::VisitAssignableNode(AssignableNode* node) {
-  AssertAssignableComp* assert = TranslateAssignable(*node);
   CHECK_ALIVE(return);
-  DoComputation(assert);
-}
 
-void ValueGraphVisitor::VisitAssignableNode(AssignableNode* node) {
-  AssertAssignableComp* assert = TranslateAssignable(*node);
-  CHECK_ALIVE(return);
-  ReturnValueOf(assert);
+  AssertAssignableComp* assert =
+      new AssertAssignableComp(for_value.value(), node->type());
+  ReturnComputation(assert);
 }
 
 
-void TestGraphVisitor::VisitAssignableNode(AssignableNode* node) {
-  AssertAssignableComp* assert = TranslateAssignable(*node);
-  CHECK_ALIVE(return);
-  BranchOnValueOf(assert);
-}
-
-
 // <Expression> :: BinaryOp { kind:  Token::Kind
 //                            left:  <Expression>
 //                            right: <Expression> }
-InstanceCallComp* EffectGraphVisitor::TranslateBinaryOp(
-    const BinaryOpNode& node) {
+void EffectGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
-  if ((node.kind() == Token::kAND) || (node.kind() == Token::kOR)) {
+  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);
+  node->left()->Visit(&for_left_value);
   Append(for_left_value);
-  CHECK_ALIVE(return NULL);
+  CHECK_ALIVE(return);
   ValueGraphVisitor for_right_value(owner(), for_left_value.temp_index());
-  node.right()->Visit(&for_right_value);
+  node->right()->Visit(&for_right_value);
   Append(for_right_value);
-  CHECK_ALIVE(return NULL);
+  CHECK_ALIVE(return);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(for_left_value.value());
   arguments->Add(for_right_value.value());
-  return new InstanceCallComp(node.Name(), arguments);
+  InstanceCallComp* call = new InstanceCallComp(node->Name(), arguments);
+  ReturnComputation(call);
 }
 
-void EffectGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
-  InstanceCallComp* call = TranslateBinaryOp(*node);
-  CHECK_ALIVE(return);
-  DoComputation(call);
-}
 
-void ValueGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
-  InstanceCallComp* call = TranslateBinaryOp(*node);
-  CHECK_ALIVE(return);
-  ReturnValueOf(call);
-}
-
-void TestGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
-  InstanceCallComp* call = TranslateBinaryOp(*node);
-  CHECK_ALIVE(return);
-  BranchOnValueOf(call);
-}
-
-
 void EffectGraphVisitor::VisitStringConcatNode(StringConcatNode* node) {
   Bailout("EffectGraphVisitor::VisitStringConcatNode");
 }
-void ValueGraphVisitor::VisitStringConcatNode(StringConcatNode* node) {
-  Bailout("ValueGraphVisitor::VisitStringConcatNode");
-}
-void TestGraphVisitor::VisitStringConcatNode(StringConcatNode* node) {
-  Bailout("TestGraphVisitor::VisitStringConcatNode");
-}
 
 
 // <Expression> :: Comparison { kind:  Token::Kind
 //                              left:  <Expression>
 //                              right: <Expression> }
-Computation* EffectGraphVisitor::TranslateComparison(
-    const ComparisonNode& node) {
-  if (Token::IsInstanceofOperator(node.kind())) {
+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)) {
+  } 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);
+  node->left()->Visit(&for_left_value);
   Append(for_left_value);
-  CHECK_ALIVE(return NULL);
+  CHECK_ALIVE(return);
   ValueGraphVisitor for_right_value(owner(), for_left_value.temp_index());
-  node.right()->Visit(&for_right_value);
+  node->right()->Visit(&for_right_value);
   Append(for_right_value);
-  CHECK_ALIVE(return NULL);
-  if ((node.kind() == Token::kEQ_STRICT) ||
-      (node.kind() == Token::kNE_STRICT)) {
-    return new StrictCompareComp(
-        node.kind(), for_left_value.value(), for_right_value.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());
-  return new InstanceCallComp(node.Name(), arguments);
+  InstanceCallComp* call = new InstanceCallComp(node->Name(), arguments);
+  ReturnComputation(call);
 }
 
-void EffectGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
-  Computation* call = TranslateComparison(*node);
-  CHECK_ALIVE(return);
-  DoComputation(call);
-}
 
-void ValueGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
-  Computation* call = TranslateComparison(*node);
-  CHECK_ALIVE(return);
-  ReturnValueOf(call);
-}
-
-void TestGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
-  Computation* call = TranslateComparison(*node);
-  CHECK_ALIVE(return);
-  BranchOnValueOf(call);
-}
-
-
-
-InstanceCallComp* EffectGraphVisitor::TranslateUnaryOp(
-    const UnaryOpNode& node) {
+void EffectGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
   // "!" cannot be overloaded, therefore do not call operator.
-  if (node.kind() == Token::kNOT) {
+  if (node->kind() == Token::kNOT) {
     Bailout("EffectGraphVisitor::VisitUnaryOpNode NOT");
   }
   ValueGraphVisitor for_value(owner(), temp_index());
-  node.operand()->Visit(&for_value);
+  node->operand()->Visit(&for_value);
   Append(for_value);
   ZoneGrowableArray<Value*>* argument = new ZoneGrowableArray<Value*>(1);
   argument->Add(for_value.value());
-  return new InstanceCallComp(node.Name(), argument);
+  InstanceCallComp* call = new InstanceCallComp(node->Name(), argument);
+  ReturnComputation(call);
 }
 
 
-void EffectGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
-  InstanceCallComp* call = TranslateUnaryOp(*node);
-  DoComputation(call);
-}
-void ValueGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
-  InstanceCallComp* call = TranslateUnaryOp(*node);
-  ReturnValueOf(call);
-}
-void TestGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
-  InstanceCallComp* call = TranslateUnaryOp(*node);
-  BranchOnValueOf(call);
-}
-
-
 void EffectGraphVisitor::VisitIncrOpLocalNode(IncrOpLocalNode* node) {
   Bailout("EffectGraphVisitor::VisitIncrOpLocalNode");
 }
-void ValueGraphVisitor::VisitIncrOpLocalNode(IncrOpLocalNode* node) {
-  Bailout("ValueGraphVisitor::VisitIncrOpLocalNode");
-}
-void TestGraphVisitor::VisitIncrOpLocalNode(IncrOpLocalNode* node) {
-  Bailout("TestGraphVisitor::VisitIncrOpLocalNode");
-}
 
 
 void EffectGraphVisitor::VisitIncrOpInstanceFieldNode(
     IncrOpInstanceFieldNode* node) {
   Bailout("EffectGraphVisitor::VisitIncrOpInstanceFieldNode");
 }
-void ValueGraphVisitor::VisitIncrOpInstanceFieldNode(
-    IncrOpInstanceFieldNode* node) {
-  Bailout("ValueGraphVisitor::VisitIncrOpInstanceFieldNode");
-}
-void TestGraphVisitor::VisitIncrOpInstanceFieldNode(
-    IncrOpInstanceFieldNode* node) {
-  Bailout("TestGraphVisitor::VisitIncrOpInstanceFieldNode");
-}
 
 
 void EffectGraphVisitor::VisitIncrOpStaticFieldNode(
     IncrOpStaticFieldNode* node) {
   Bailout("EffectGraphVisitor::VisitIncrOpStaticFieldNode");
 }
-void ValueGraphVisitor::VisitIncrOpStaticFieldNode(
-    IncrOpStaticFieldNode* node) {
-  Bailout("ValueGraphVisitor::VisitIncrOpStaticFieldNode");
-}
-void TestGraphVisitor::VisitIncrOpStaticFieldNode(IncrOpStaticFieldNode* node) {
-  Bailout("TestGraphVisitor::VisitIncrOpStaticFieldNode");
-}
 
 
 void EffectGraphVisitor::VisitIncrOpIndexedNode(IncrOpIndexedNode* node) {
   Bailout("EffectGraphVisitor::VisitIncrOpIndexedNode");
 }
-void ValueGraphVisitor::VisitIncrOpIndexedNode(IncrOpIndexedNode* node) {
-  Bailout("ValueGraphVisitor::VisitIncrOpIndexedNode");
-}
-void TestGraphVisitor::VisitIncrOpIndexedNode(IncrOpIndexedNode* node) {
-  Bailout("TestGraphVisitor::VisitIncrOpIndexedNode");
-}
 
 
 void EffectGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
   Bailout("EffectGraphVisitor::VisitConditionalExprNode");
 }
-void ValueGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
-  Bailout("ValueGraphVisitor::VisitConditionalExprNode");
-}
-void TestGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
-  Bailout("TestGraphVisitor::VisitConditionalExprNode");
-}
 
 
 // <Statement> ::= If { condition: <Expression>
@@ -447,30 +336,15 @@
   Join(for_test, for_true, for_false);
 }
 
-void ValueGraphVisitor::VisitIfNode(IfNode* node) { UNREACHABLE(); }
-void TestGraphVisitor::VisitIfNode(IfNode* node) { UNREACHABLE(); }
 
-
 void EffectGraphVisitor::VisitSwitchNode(SwitchNode* node) {
   Bailout("EffectGraphVisitor::VisitSwitchNode");
 }
-void ValueGraphVisitor::VisitSwitchNode(SwitchNode* node) {
-  Bailout("ValueGraphVisitor::VisitSwitchNode");
-}
-void TestGraphVisitor::VisitSwitchNode(SwitchNode* node) {
-  Bailout("TestGraphVisitor::VisitSwitchNode");
-}
 
 
 void EffectGraphVisitor::VisitCaseNode(CaseNode* node) {
   Bailout("EffectGraphVisitor::VisitCaseNode");
 }
-void ValueGraphVisitor::VisitCaseNode(CaseNode* node) {
-  Bailout("ValueGraphVisitor::VisitCaseNode");
-}
-void TestGraphVisitor::VisitCaseNode(CaseNode* node) {
-  Bailout("TestGraphVisitor::VisitCaseNode");
-}
 
 
 // <Statement> ::= While { label:     SourceLabel
@@ -485,114 +359,60 @@
   TieLoop(for_test, for_body);
 }
 
-void ValueGraphVisitor::VisitWhileNode(WhileNode* node) { UNREACHABLE(); }
-void TestGraphVisitor::VisitWhileNode(WhileNode* node) { UNREACHABLE(); }
 
-
 void EffectGraphVisitor::VisitDoWhileNode(DoWhileNode* node) {
   Bailout("EffectGraphVisitor::VisitDoWhileNode");
 }
-void ValueGraphVisitor::VisitDoWhileNode(DoWhileNode* node) {
-  Bailout("ValueGraphVisitor::VisitDoWhileNode");
-}
-void TestGraphVisitor::VisitDoWhileNode(DoWhileNode* node) {
-  Bailout("TestGraphVisitor::VisitDoWhileNode");
-}
 
 
 void EffectGraphVisitor::VisitForNode(ForNode* node) {
   Bailout("EffectGraphVisitor::VisitForNode");
 }
-void ValueGraphVisitor::VisitForNode(ForNode* node) {
-  Bailout("ValueGraphVisitor::VisitForNode");
-}
-void TestGraphVisitor::VisitForNode(ForNode* node) {
-  Bailout("TestGraphVisitor::VisitForNode");
-}
 
 
 void EffectGraphVisitor::VisitJumpNode(JumpNode* node) {
   Bailout("EffectGraphVisitor::VisitJumpNode");
 }
-void ValueGraphVisitor::VisitJumpNode(JumpNode* node) {
-  Bailout("ValueGraphVisitor::VisitJumpNode");
-}
-void TestGraphVisitor::VisitJumpNode(JumpNode* node) {
-  Bailout("TestGraphVisitor::VisitJumpNode");
-}
 
 
 void EffectGraphVisitor::VisitArgumentListNode(ArgumentListNode* node) {
   UNREACHABLE();
 }
-void ValueGraphVisitor::VisitArgumentListNode(ArgumentListNode* node) {
-  UNREACHABLE();
-}
-void TestGraphVisitor::VisitArgumentListNode(ArgumentListNode* node) {
-  UNREACHABLE();
-}
 
 
 void EffectGraphVisitor::VisitArrayNode(ArrayNode* node) {
   Bailout("EffectGraphVisitor::VisitArrayNode");
 }
-void ValueGraphVisitor::VisitArrayNode(ArrayNode* node) {
-  Bailout("ValueGraphVisitor::VisitArrayNode");
-}
-void TestGraphVisitor::VisitArrayNode(ArrayNode* node) {
-  Bailout("TestGraphVisitor::VisitArrayNode");
-}
 
 
 void EffectGraphVisitor::VisitClosureNode(ClosureNode* node) {
   Bailout("EffectGraphVisitor::VisitClosureNode");
 }
-void ValueGraphVisitor::VisitClosureNode(ClosureNode* node) {
-  Bailout("ValueGraphVisitor::VisitClosureNode");
-}
-void TestGraphVisitor::VisitClosureNode(ClosureNode* node) {
-  Bailout("TestGraphVisitor::VisitClosureNode");
-}
 
 
-InstanceCallComp* EffectGraphVisitor::TranslateInstanceCall(
-    const InstanceCallNode& node) {
-  ArgumentListNode* arguments = node.arguments();
+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);
+  node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
-  CHECK_ALIVE(return NULL);
-  values->Add(for_receiver.value());
-  int index = temp_index();
-  for (intptr_t i = 0; i < length; ++i) {
-    ValueGraphVisitor for_value(owner(), index);
-    arguments->NodeAt(i)->Visit(&for_value);
-    Append(for_value);
-    CHECK_ALIVE(return NULL);
-    values->Add(for_value.value());
-    index = for_value.temp_index();
+  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());
   }
-  return new InstanceCallComp(node.function_name().ToCString(), values);
-}
+  values->Add(receiver_value);
 
-
-void EffectGraphVisitor::VisitInstanceCallNode(InstanceCallNode* node) {
-  InstanceCallComp* call = TranslateInstanceCall(*node);
+  TranslateArgumentList(*arguments, values);
   CHECK_ALIVE(return);
-  DoComputation(call);
+  InstanceCallComp* call =
+      new InstanceCallComp(node->function_name().ToCString(), values);
+  ReturnComputation(call);
 }
-void ValueGraphVisitor::VisitInstanceCallNode(InstanceCallNode* node) {
-  InstanceCallComp* call = TranslateInstanceCall(*node);
-  CHECK_ALIVE(return);
-  ReturnValueOf(call);
-}
-void TestGraphVisitor::VisitInstanceCallNode(InstanceCallNode* node) {
-  InstanceCallComp* call = TranslateInstanceCall(*node);
-  CHECK_ALIVE(return);
-  BranchOnValueOf(call);
-}
 
 
 void EffectGraphVisitor::TranslateArgumentList(
@@ -615,131 +435,60 @@
 
 // <Expression> ::= StaticCall { function: Function
 //                               arguments: <ArgumentList> }
-StaticCallComp* EffectGraphVisitor::TranslateStaticCall(
-    const StaticCallNode& node) {
-  int length = node.arguments()->length();
-  ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>(length);
-  TranslateArgumentList(*node.arguments(), values);
-  CHECK_ALIVE(return NULL);
-  return new StaticCallComp(node.function(), values);
-}
-
 void EffectGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
-  StaticCallComp* call = TranslateStaticCall(*node);
+  int length = node->arguments()->length();
+  ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>(length);
+  TranslateArgumentList(*node->arguments(), values);
   CHECK_ALIVE(return);
-  DoComputation(call);
+  StaticCallComp* call = new StaticCallComp(node->function(), values);
+  ReturnComputation(call);
 }
 
-void ValueGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
-  StaticCallComp* call = TranslateStaticCall(*node);
-  CHECK_ALIVE(return);
-  ReturnValueOf(call);
-}
 
-void TestGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
-  StaticCallComp* call = TranslateStaticCall(*node);
-  CHECK_ALIVE(return);
-  BranchOnValueOf(call);
-}
-
-
 void EffectGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
   Bailout("EffectGraphVisitor::VisitClosureCallNode");
 }
-void ValueGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
-  Bailout("ValueGraphVisitor::VisitClosureCallNode");
-}
-void TestGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
-  Bailout("TestGraphVisitor::VisitClosureCallNode");
-}
 
 
 void EffectGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
   Bailout("EffectGraphVisitor::VisitCloneContextNode");
 }
-void ValueGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
-  Bailout("ValueGraphVisitor::VisitCloneContextNode");
-}
-void TestGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
-  Bailout("TestGraphVisitor::VisitCloneContextNode");
-}
 
 
 void EffectGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   Bailout("EffectGraphVisitor::VisitConstructorCallNode");
 }
-void ValueGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
-  Bailout("ValueGraphVisitor::VisitConstructorCallNode");
-}
-void TestGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
-  Bailout("TestGraphVisitor::VisitConstructorCallNode");
-}
 
 
 void EffectGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
   Bailout("EffectGraphVisitor::VisitInstanceGetterNode");
 }
-void ValueGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
-  Bailout("ValueGraphVisitor::VisitInstanceGetterNode");
-}
-void TestGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
-  Bailout("TestGraphVisitor::VisitInstanceGetterNode");
-}
 
 
 void EffectGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
   Bailout("EffectGraphVisitor::VisitInstanceSetterNode");
 }
-void ValueGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
-  Bailout("ValueGraphVisitor::VisitInstanceSetterNode");
-}
-void TestGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
-  Bailout("TestGraphVisitor::VisitInstanceSetterNode");
-}
 
 
 void EffectGraphVisitor::VisitStaticGetterNode(StaticGetterNode* node) {
   Bailout("EffectGraphVisitor::VisitStaticGetterNode");
 }
-void ValueGraphVisitor::VisitStaticGetterNode(StaticGetterNode* node) {
-  Bailout("ValueGraphVisitor::VisitStaticGetterNode");
-}
-void TestGraphVisitor::VisitStaticGetterNode(StaticGetterNode* node) {
-  Bailout("TestGraphVisitor::VisitStaticGetterNode");
-}
 
 
 void EffectGraphVisitor::VisitStaticSetterNode(StaticSetterNode* node) {
   Bailout("EffectGraphVisitor::VisitStaticSetterNode");
 }
-void ValueGraphVisitor::VisitStaticSetterNode(StaticSetterNode* node) {
-  Bailout("ValueGraphVisitor::VisitStaticSetterNode");
-}
-void TestGraphVisitor::VisitStaticSetterNode(StaticSetterNode* node) {
-  Bailout("TestGraphVisitor::VisitStaticSetterNode");
-}
 
 
 void EffectGraphVisitor::VisitNativeBodyNode(NativeBodyNode* node) {
-  Bailout("EffectGraphVisitor::VisitNativeBodyNode");
+  NativeCallComp* native_call = new NativeCallComp(node);
+  ReturnComputation(native_call);
 }
-void ValueGraphVisitor::VisitNativeBodyNode(NativeBodyNode* node) {
-  Bailout("ValueGraphVisitor::VisitNativeBodyNode");
-}
-void TestGraphVisitor::VisitNativeBodyNode(NativeBodyNode* node) {
-  Bailout("TestGraphVisitor::VisitNativeBodyNode");
-}
 
 
 void EffectGraphVisitor::VisitPrimaryNode(PrimaryNode* node) {
   Bailout("EffectGraphVisitor::VisitPrimaryNode");
 }
-void ValueGraphVisitor::VisitPrimaryNode(PrimaryNode* node) {
-  Bailout("ValueGraphVisitor::VisitPrimaryNode");
-}
-void TestGraphVisitor::VisitPrimaryNode(PrimaryNode* node) {
-  Bailout("TestGraphVisitor::VisitPrimaryNode");
-}
 
 
 // <Expression> ::= LoadLocal { local: LocalVariable }
@@ -749,114 +498,57 @@
 
 void ValueGraphVisitor::VisitLoadLocalNode(LoadLocalNode* node) {
   LoadLocalComp* load = new LoadLocalComp(node->local());
-  ReturnValueOf(load);
+  ReturnComputation(load);
 }
 
 void TestGraphVisitor::VisitLoadLocalNode(LoadLocalNode* node) {
   LoadLocalComp* load = new LoadLocalComp(node->local());
-  BranchOnValueOf(load);
+  ReturnComputation(load);
 }
 
 
 // <Expression> ::= StoreLocal { local: LocalVariable
 //                               value: <Expression> }
-StoreLocalComp* EffectGraphVisitor::TranslateStoreLocal(
-    const StoreLocalNode& node) {
+void EffectGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
-  node.value()->Visit(&for_value);
+  node->value()->Visit(&for_value);
   Append(for_value);
-  CHECK_ALIVE(return NULL);
-  return new StoreLocalComp(node.local(), for_value.value());
-}
-
-void EffectGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
-  StoreLocalComp* store = TranslateStoreLocal(*node);
   CHECK_ALIVE(return);
-  DoComputation(store);
+  StoreLocalComp* store = new StoreLocalComp(node->local(), for_value.value());
+  ReturnComputation(store);
 }
 
-void ValueGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
-  StoreLocalComp* store = TranslateStoreLocal(*node);
-  CHECK_ALIVE(return);
-  ReturnValueOf(store);
-}
 
-void TestGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
-  StoreLocalComp* store = TranslateStoreLocal(*node);
-  CHECK_ALIVE(return);
-  BranchOnValueOf(store);
-}
-
-
 void EffectGraphVisitor::VisitLoadInstanceFieldNode(
     LoadInstanceFieldNode* node) {
   Bailout("EffectGraphVisitor::VisitLoadInstanceFieldNode");
 }
-void ValueGraphVisitor::VisitLoadInstanceFieldNode(
-    LoadInstanceFieldNode* node) {
-  Bailout("ValueGraphVisitor::VisitLoadInstanceFieldNode");
-}
-void TestGraphVisitor::VisitLoadInstanceFieldNode(LoadInstanceFieldNode* node) {
-  Bailout("TestGraphVisitor::VisitLoadInstanceFieldNode");
-}
 
 
 void EffectGraphVisitor::VisitStoreInstanceFieldNode(
     StoreInstanceFieldNode* node) {
   Bailout("EffectGraphVisitor::VisitStoreInstanceFieldNode");
 }
-void ValueGraphVisitor::VisitStoreInstanceFieldNode(
-    StoreInstanceFieldNode* node) {
-  Bailout("ValueGraphVisitor::VisitStoreInstanceFieldNode");
-}
-void TestGraphVisitor::VisitStoreInstanceFieldNode(
-    StoreInstanceFieldNode* node) {
-  Bailout("TestGraphVisitor::VisitStoreInstanceFieldNode");
-}
 
 
 void EffectGraphVisitor::VisitLoadStaticFieldNode(LoadStaticFieldNode* node) {
   Bailout("EffectGraphVisitor::VisitLoadStaticFieldNode");
 }
-void ValueGraphVisitor::VisitLoadStaticFieldNode(LoadStaticFieldNode* node) {
-  Bailout("ValueGraphVisitor::VisitLoadStaticFieldNode");
-}
-void TestGraphVisitor::VisitLoadStaticFieldNode(LoadStaticFieldNode* node) {
-  Bailout("TestGraphVisitor::VisitLoadStaticFieldNode");
-}
 
 
 void EffectGraphVisitor::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
   Bailout("EffectGraphVisitor::VisitStoreStaticFieldNode");
 }
-void ValueGraphVisitor::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
-  Bailout("ValueGraphVisitor::VisitStoreStaticFieldNode");
-}
-void TestGraphVisitor::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
-  Bailout("TestGraphVisitor::VisitStoreStaticFieldNode");
-}
 
 
 void EffectGraphVisitor::VisitLoadIndexedNode(LoadIndexedNode* node) {
   Bailout("EffectGraphVisitor::VisitLoadIndexedNode");
 }
-void ValueGraphVisitor::VisitLoadIndexedNode(LoadIndexedNode* node) {
-  Bailout("ValueGraphVisitor::VisitLoadIndexedNode");
-}
-void TestGraphVisitor::VisitLoadIndexedNode(LoadIndexedNode* node) {
-  Bailout("TestGraphVisitor::VisitLoadIndexedNode");
-}
 
 
 void EffectGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
   Bailout("EffectGraphVisitor::VisitStoreIndexedNode");
 }
-void ValueGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
-  Bailout("ValueGraphVisitor::VisitStoreIndexedNode");
-}
-void TestGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
-  Bailout("TestGraphVisitor::VisitStoreIndexedNode");
-}
 
 
 // <Statement> ::= Sequence { scope: LocalScope
@@ -875,52 +567,25 @@
   }
 }
 
-void ValueGraphVisitor::VisitSequenceNode(SequenceNode* node) { UNREACHABLE(); }
-void TestGraphVisitor::VisitSequenceNode(SequenceNode* node) { UNREACHABLE(); }
 
-
 void EffectGraphVisitor::VisitCatchClauseNode(CatchClauseNode* node) {
   Bailout("EffectGraphVisitor::VisitCatchClauseNode");
 }
-void ValueGraphVisitor::VisitCatchClauseNode(CatchClauseNode* node) {
-  Bailout("ValueGraphVisitor::VisitCatchClauseNode");
-}
-void TestGraphVisitor::VisitCatchClauseNode(CatchClauseNode* node) {
-  Bailout("TestGraphVisitor::VisitCatchClauseNode");
-}
 
 
 void EffectGraphVisitor::VisitTryCatchNode(TryCatchNode* node) {
   Bailout("EffectGraphVisitor::VisitTryCatchNode");
 }
-void ValueGraphVisitor::VisitTryCatchNode(TryCatchNode* node) {
-  Bailout("ValueGraphVisitor::VisitTryCatchNode");
-}
-void TestGraphVisitor::VisitTryCatchNode(TryCatchNode* node) {
-  Bailout("TestGraphVisitor::VisitTryCatchNode");
-}
 
 
 void EffectGraphVisitor::VisitThrowNode(ThrowNode* node) {
   Bailout("EffectGraphVisitor::VisitThrowNode");
 }
-void ValueGraphVisitor::VisitThrowNode(ThrowNode* node) {
-  Bailout("ValueGraphVisitor::VisitThrowNode");
-}
-void TestGraphVisitor::VisitThrowNode(ThrowNode* node) {
-  Bailout("TestGraphVisitor::VisitThrowNode");
-}
 
 
 void EffectGraphVisitor::VisitInlinedFinallyNode(InlinedFinallyNode* node) {
   Bailout("EffectGraphVisitor::VisitInlinedFinallyNode");
 }
-void ValueGraphVisitor::VisitInlinedFinallyNode(InlinedFinallyNode* node) {
-  Bailout("ValueGraphVisitor::VisitInlinedFinallyNode");
-}
-void TestGraphVisitor::VisitInlinedFinallyNode(InlinedFinallyNode* node) {
-  Bailout("TestGraphVisitor::VisitInlinedFinallyNode");
-}
 
 
 // Graph printing.
@@ -1038,6 +703,11 @@
 }
 
 
+void FlowGraphPrinter::VisitNativeCall(NativeCallComp* comp) {
+  OS::Print("NativeCall '%s'", comp->native_name().ToCString());

[Kevin Millikin (Google), 2012/03/01 09:26:22]

For uniformity this should probably print as

NativeCall(%s)

(I don't care too much about the actual print representation, as long as it's
uniform.)

[srdjan, 2012/03/01 17:25:42]

Done.

+}
+
+
 void FlowGraphPrinter::VisitJoinEntry(JoinEntryInstr* instr) {
   OS::Print("%2d: [join]", instr->block_number());
 }