Added LoadLiteralComp, StrictCompareComp; implement InstanceCallNode.

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 170 matching lines @@
 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()));
+  LoadLiteralComp* load =
+      new LoadLiteralComp(new ConstantValue(node->literal()));

[Kevin Millikin (Google), 2012/02/24 10:53:04]

As mentioned: let's not materialize literals in all contexts, but only those
that will need it.

[srdjan, 2012/02/24 22:16:24]

OK, let's see how it works out.

+  ReturnValueOf(load);
 }
 
 void TestGraphVisitor::VisitLiteralNode(LiteralNode* node) {
-  BranchOnValue(new ConstantValue(node->literal()));
+  LoadLiteralComp* load =
+      new LoadLiteralComp(new ConstantValue(node->literal()));
+  BranchOnValueOf(load);
 }
 
 
 // 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 80 matching lines @@
   Bailout("ValueGraphVisitor::VisitStringConcatNode");
 }
 void TestGraphVisitor::VisitStringConcatNode(StringConcatNode* node) {
   Bailout("TestGraphVisitor::VisitStringConcatNode");
 }
 
 
 // <Expression> :: Comparison { kind:  Token::Kind
 //                              left:  <Expression>
 //                              right: <Expression> }
-InstanceCallComp* EffectGraphVisitor::TranslateComparison(
+Computation* EffectGraphVisitor::TranslateComparison(
     const ComparisonNode& node) {
-  if (Token::IsInstanceofOperator(node.kind()) ||
-      Token::IsEqualityOperator(node.kind())) {
-    Bailout("Some kind of comparison we don't handle yet");
-    return NULL;
+  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 NULL);
   ValueGraphVisitor for_right_value(owner(), for_left_value.temp_index());
   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());
+  }
   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);
 }
 
 void EffectGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
-  InstanceCallComp* call = TranslateComparison(*node);
+  Computation* call = TranslateComparison(*node);
   CHECK_ALIVE(return);
   DoComputation(call);
 }
 
 void ValueGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
-  InstanceCallComp* call = TranslateComparison(*node);
+  Computation* call = TranslateComparison(*node);
   CHECK_ALIVE(return);
   ReturnValueOf(call);
 }
 
 void TestGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
-  InstanceCallComp* call = TranslateComparison(*node);
+  Computation* call = TranslateComparison(*node);
   CHECK_ALIVE(return);
   BranchOnValueOf(call);
 }
 
 
 
 InstanceCallComp* EffectGraphVisitor::TranslateUnaryOp(
     const UnaryOpNode& node) {
   // "!" cannot be overloaded, therefore do not call operator.
   if (node.kind() == Token::kNOT) {
@@ skipping 202 matching lines @@
   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();
+  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 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();
+  }
+  return new InstanceCallComp(node.function_name().ToCString(), values);
+}
+
+
 void EffectGraphVisitor::VisitInstanceCallNode(InstanceCallNode* node) {
-  Bailout("EffectGraphVisitor::VisitInstanceCallNode");
+  InstanceCallComp* call = TranslateInstanceCall(*node);
+  CHECK_ALIVE(return);
+  DoComputation(call);
 }
 void ValueGraphVisitor::VisitInstanceCallNode(InstanceCallNode* node) {
-  Bailout("ValueGraphVisitor::VisitInstanceCallNode");
+  InstanceCallComp* call = TranslateInstanceCall(*node);
+  CHECK_ALIVE(return);
+  ReturnValueOf(call);
 }
 void TestGraphVisitor::VisitInstanceCallNode(InstanceCallNode* node) {
-  Bailout("TestGraphVisitor::VisitInstanceCallNode");
+  InstanceCallComp* call = TranslateInstanceCall(*node);
+  CHECK_ALIVE(return);
+  BranchOnValueOf(call);
 }
 
 
 // <Expression> ::= StaticCall { function: Function
 //                               arguments: <ArgumentList> }
 StaticCallComp* EffectGraphVisitor::TranslateStaticCall(
     const StaticCallNode& node) {
   ArgumentListNode* arguments = node.arguments();
   int length = arguments->length();
   ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>(length);
@@ skipping 417 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