Materialize all constant operands on the stack in the non-optimizing compiler.

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 159 matching lines @@
     value = new UseVal(assert_boolean);
   }
   BranchInstr* branch = new BranchInstr(value);
   AddInstruction(branch);
   CloseFragment();
   true_successor_address_ = branch->true_successor_address();
   false_successor_address_ = branch->false_successor_address();
 }
 
 
-void ArgumentGraphVisitor::ReturnValue(Value* value) {
-  value_ = value;
-  if (value->IsConstant()) {
-    BindInstr* defn = new BindInstr(temp_index(), value);
-    AddInstruction(defn);
-    value_ = new UseVal(defn);
-    AllocateTempIndex();
-  }
-}
-
-
 void EffectGraphVisitor::Bailout(const char* reason) {
   owner()->Bailout(reason);
 }
 
 
 // <Statement> ::= Return { value:                <Expression>
 //                          inlined_finally_list: <InlinedFinally>* }
 void EffectGraphVisitor::VisitReturnNode(ReturnNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
@@ skipping 15 matching lines @@
     const bool is_static = owner()->parsed_function().function().is_static();
     // Implicit getters do not need a type check at return, unless they compute
     // the initial value of a static field.
     if (is_static || !is_implicit_getter) {
       const AbstractType& dst_type =
           AbstractType::ZoneHandle(
               owner()->parsed_function().function().result_type());
       const String& dst_name =
           String::ZoneHandle(String::NewSymbol("function result"));
       return_value = BuildAssignableValue(node->id(),
-                                          node->value()->token_index(),
+                                          node->value(),
                                           return_value,
                                           dst_type,
                                           dst_name,
                                           temp_index());
     }
   }
 
   intptr_t current_context_level = owner()->context_level();
   ASSERT(current_context_level >= 0);
   if (owner()->parsed_function().saved_context_var() != NULL) {
@@ skipping 10 matching lines @@
   CloseFragment();
 }
 
 
 // <Expression> ::= Literal { literal: Instance }
 void EffectGraphVisitor::VisitLiteralNode(LiteralNode* node) {
   return;
 }
 
 void ValueGraphVisitor::VisitLiteralNode(LiteralNode* node) {
-  ReturnValue(new ConstantVal(node->literal()));
+  ReturnComputation(new ConstantVal(node->literal()));
 }
 
-void TestGraphVisitor::VisitLiteralNode(LiteralNode* node) {
-  ReturnValue(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(); }
 
 
 // Returns true if the type check can be skipped, for example, if the type is
 // Dynamic or if the value is a compile time constant and an instance of type.
-static bool CanSkipTypeCheck(Value* value, const AbstractType& dst_type) {
+static bool CanSkipTypeCheck(AstNode* value, const AbstractType& dst_type) {
   ASSERT(FLAG_enable_type_checks);
   ASSERT(!dst_type.IsNull());
   ASSERT(dst_type.IsFinalized());
 
   // Any expression is assignable to the Dynamic type and to the Object type.
   // Skip the test.
   if (!dst_type.IsMalformed() &&
       (dst_type.IsDynamicType() || dst_type.IsObjectType())) {
     return true;
   }
 
   // It is a compile-time error to explicitly return a value (including null)
   // from a void function. However, functions that do not explicitly return a
   // value, implicitly return null. This includes void functions. Therefore, we
   // skip the type test here and trust the parser to only return null in void
   // function.
   if (dst_type.IsVoidType()) {
     return true;
   }
 
   // Eliminate the test if it can be performed successfully at compile time.
-  if ((value != NULL) && value->IsConstant()) {
-    Instance& literal_value = Instance::Handle();
-    literal_value ^= value->AsConstant()->value().raw();
+  if ((value != NULL) && value->IsLiteralNode()) {

[Kevin Millikin (Google), 2012/04/30 14:54:53]

We still need this constant check, because in the case of the sentinels below,
we not only can but *must* skip the type check.  :)

+    const Instance& literal_value = value->AsLiteralNode()->literal();
     const Class& cls = Class::Handle(literal_value.clazz());
     if (cls.IsNullClass()) {
       // There are only three instances that can be of Class Null:
       // Object::null(), Object::sentinel(), and Object::transition_sentinel().
       // The inline code and run time code performing the type check will never
       // encounter the 2 sentinel values. The type check of a sentinel value
       // will always be eliminated here, because these sentinel values can only
       // be encountered as constants, never as actual value of an heap object
       // being type checked.
       ASSERT(literal_value.IsNull() ||
              (literal_value.raw() == Object::sentinel()) ||
              (literal_value.raw() == Object::transition_sentinel()));
       return true;
     }
     Error& malformed_error = Error::Handle();
     if (!dst_type.IsMalformed() &&
         dst_type.IsInstantiated() &&
         literal_value.IsInstanceOf(dst_type,
                                    TypeArguments::Handle(),
                                    &malformed_error)) {
       return true;
     }
   }
+
   return false;
 }
 
 
 // <Expression> :: Assignable { expr:     <Expression>
 //                              type:     AbstractType
 //                              dst_name: String }
 void EffectGraphVisitor::VisitAssignableNode(AssignableNode* node) {
   UNREACHABLE();
 }
 
 
 void ValueGraphVisitor::VisitAssignableNode(AssignableNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->expr()->Visit(&for_value);
   Append(for_value);
   ReturnValue(BuildAssignableValue(node->id(),
-                                   node->token_index(),
+                                   node->expr(),

[Kevin Millikin (Google), 2012/04/30 14:54:53]

This changes the token index from node->token_index() to
node->expr()->token_index().  I think that's OK and matches the pattern we have
everywhere else.

                                    for_value.value(),
                                    node->type(),
                                    node->dst_name(),
                                    temp_index()));
 }
 
 
 // <Expression> :: BinaryOp { kind:  Token::Kind
 //                            left:  <Expression>
 //                            right: <Expression> }
@@ skipping 10 matching lines @@
     EffectGraphVisitor for_right(owner(), temp_index());
     node->right()->Visit(&for_right);
     EffectGraphVisitor empty(owner(), temp_index());
     if (node->kind() == Token::kAND) {
       Join(for_left, for_right, empty);
     } else {
       Join(for_left, empty, for_right);
     }
     return;
   }
-  ArgumentGraphVisitor for_left_value(owner(), temp_index());
+  ValueGraphVisitor 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());
+  ValueGraphVisitor 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());
   arguments->Add(for_right_value.value());
   const String& name = String::ZoneHandle(String::NewSymbol(node->Name()));
   InstanceCallComp* call = new InstanceCallComp(node->id(),
                                                 node->token_index(),
                                                 owner()->try_index(),
                                                 name,
@@ skipping 19 matching lines @@
     TestGraphVisitor for_test(owner(),
                               temp_index(),
                               node->left()->id(),
                               node->left()->token_index());
     node->left()->Visit(&for_test);
 
     ValueGraphVisitor for_right(owner(), temp_index());
     node->right()->Visit(&for_right);
     Value* right_value = for_right.value();
     if (FLAG_enable_type_checks) {
-      AssertBooleanComp* assert_boolean =
-          new AssertBooleanComp(node->right()->id(),
-                                node->right()->token_index(),
-                                owner()->try_index(),
-                                right_value);
-      for_right.AddInstruction(new BindInstr(temp_index(), assert_boolean));
-      right_value = new TempVal(temp_index());
+      BindInstr* assert_boolean =
+          new BindInstr(temp_index(),
+                        new AssertBooleanComp(node->right()->id(),
+                                              node->right()->token_index(),
+                                              owner()->try_index(),
+                                              right_value));
+      for_right.AddInstruction(assert_boolean);
+      right_value = new UseVal(assert_boolean);
     }
+    BindInstr* constant_true =
+        new BindInstr(temp_index(), new ConstantVal(bool_true));
+    for_right.AddInstruction(constant_true);
     StrictCompareComp* comp = new StrictCompareComp(Token::kEQ_STRICT,
-        right_value, new ConstantVal(bool_true));
+        right_value, new UseVal(constant_true));
     for_right.AddInstruction(new BindInstr(temp_index(), comp));
 
     if (node->kind() == Token::kAND) {
       ValueGraphVisitor for_false(owner(), temp_index());
-      for_false.AddInstruction(
-          new BindInstr(temp_index(), new ConstantVal(bool_false)));
+      for_false.ReturnComputation(new ConstantVal(bool_false));
       Join(for_test, for_right, for_false);
     } else {
       ASSERT(node->kind() == Token::kOR);
       ValueGraphVisitor for_true(owner(), temp_index());
-      for_true.AddInstruction(
-          new BindInstr(temp_index(), new ConstantVal(bool_true)));
+      for_true.ReturnComputation(new ConstantVal(bool_true));
       Join(for_test, for_true, for_right);
     }
     ReturnValue(new TempVal(AllocateTempIndex()));
     return;
   }
   EffectGraphVisitor::VisitBinaryOpNode(node);
 }
 
 
 void EffectGraphVisitor::CompiletimeStringInterpolation(
@@ skipping 12 matching lines @@
   String& concatenated = String::ZoneHandle();
   concatenated ^= DartEntry::InvokeStatic(interpol_func,
                                           interpolate_arg,
                                           kNoArgumentNames);
   if (concatenated.IsUnhandledException()) {
     // TODO(srdjan): Remove this node and this UNREACHABLE.
     UNREACHABLE();
   }
   ASSERT(!concatenated.IsNull());
   concatenated = String::NewSymbol(concatenated);
-  ReturnValue(new ConstantVal(concatenated));
+  ReturnComputation(new ConstantVal(concatenated));
 }
 
 
 
 // TODO(srdjan): Remove this node once the "+" string operator has been
 // eliminated.
 void EffectGraphVisitor::VisitStringConcatNode(StringConcatNode* node) {
   const String& cls_name = String::Handle(String::NewSymbol("StringBase"));
   const Library& core_lib = Library::Handle(
       Isolate::Current()->object_store()->core_library());
@@ skipping 39 matching lines @@
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::BuildAssertAssignable(intptr_t node_id,
                                                intptr_t token_index,
                                                Value* value,
                                                const AbstractType& dst_type,
                                                const String& dst_name,
                                                intptr_t start_index) {
-  // We should not call this function if the type check can be skipped.
-  ASSERT(!CanSkipTypeCheck(value, dst_type));
-
   // Build the type check computation.
   Value* instantiator_type_arguments = NULL;
   if (!dst_type.IsInstantiated()) {
     instantiator_type_arguments =
         BuildInstantiatorTypeArguments(token_index, start_index + 1);
   }
   AssertAssignableComp* assert_assignable =
       new AssertAssignableComp(node_id,
                                token_index,
                                owner()->try_index(),
                                value,
                                instantiator_type_arguments,
                                dst_type,
                                dst_name);
   AddInstruction(new DoInstr(assert_assignable));
 }
 
 
 Value* EffectGraphVisitor::BuildAssignableValue(intptr_t node_id,
-                                                intptr_t token_index,
+                                                AstNode* value_node,
                                                 Value* value,
                                                 const AbstractType& dst_type,
                                                 const String& dst_name,
                                                 intptr_t start_index) {
-  if (CanSkipTypeCheck(value, dst_type)) {
+  if (CanSkipTypeCheck(value_node, dst_type)) {
     return value;
   }
 
   // Build the type check computation.
   Value* instantiator_type_arguments = NULL;
   if (!dst_type.IsInstantiated()) {
     instantiator_type_arguments =
-        BuildInstantiatorTypeArguments(token_index, start_index + 1);
+        BuildInstantiatorTypeArguments(value_node->token_index(),
+                                       start_index + 1);
   }
   BindInstr* assert_assignable =
       new BindInstr(start_index,
                     new AssertAssignableComp(node_id,
-                                             token_index,
+                                             value_node->token_index(),
                                              owner()->try_index(),
                                              value,
                                              instantiator_type_arguments,
                                              dst_type,
                                              dst_name));
   AddInstruction(assert_assignable);
   return new UseVal(assert_assignable);
 }
 
 
@@ skipping 15 matching lines @@
   // All objects are instances of type T if Object type is a subtype of type T.
   const Type& object_type =
       Type::Handle(Isolate::Current()->object_store()->object_type());
   Error& malformed_error = Error::Handle();
   if (type.IsInstantiated() &&
       object_type.IsSubtypeOf(type, &malformed_error)) {
     // Must evaluate left side.
     EffectGraphVisitor for_left_value(owner(), temp_index());
     node->left()->Visit(&for_left_value);
     Append(for_left_value);
-    ReturnValue(new ConstantVal(negate_result ? bool_false : bool_true));
+    ReturnComputation(new ConstantVal(negate_result ? bool_false : bool_true));
     return;
   }
 
   // Eliminate the test if it can be performed successfully at compile time.
   if ((node->left() != NULL) &&
       node->left()->IsLiteralNode() &&
       type.IsInstantiated()) {
     const Instance& literal_value = node->left()->AsLiteralNode()->literal();
     const Class& cls = Class::Handle(literal_value.clazz());
     ConstantVal* result = NULL;
     if (cls.IsNullClass()) {
       // A null object is only an instance of Object and Dynamic, which has
       // already been checked above (if the type is instantiated). So we can
       // return false here if the instance is null (and if the type is
       // instantiated).
       result = new ConstantVal(negate_result ? bool_true : bool_false);
     } else {
       Error& malformed_error = Error::Handle();
       if (literal_value.IsInstanceOf(type,
                                      TypeArguments::Handle(),
                                      &malformed_error)) {
         result = new ConstantVal(negate_result ? bool_false : bool_true);
       } else {
         ASSERT(malformed_error.IsNull());
         result = new ConstantVal(negate_result ? bool_true : bool_false);
       }
     }
-    ReturnValue(result);
+    ReturnComputation(result);
     return;
   }
 
-  ArgumentGraphVisitor for_left_value(owner(), temp_index());
+  ValueGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   Value* type_arguments = NULL;
   if (!type.IsInstantiated()) {
     type_arguments =
         BuildInstantiatorTypeArguments(node->token_index(),
                                        for_left_value.temp_index());
   }
   InstanceOfComp* instance_of =
       new InstanceOfComp(node->id(),
@@ skipping 53 matching lines @@
                                                 owner()->try_index(),
                                                 new UseVal(eq_result)));
         AddInstruction(eq_result);
       }
       BooleanNegateComp* negate = new BooleanNegateComp(new UseVal(eq_result));
       ReturnComputation(negate);
     }
     return;
   }
 
-  ArgumentGraphVisitor for_left_value(owner(), temp_index());
+  ValueGraphVisitor 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());
+  ValueGraphVisitor 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());
   arguments->Add(for_right_value.value());
   const String& name = String::ZoneHandle(String::NewSymbol(node->Name()));
   InstanceCallComp* call = new InstanceCallComp(
       node->id(), node->token_index(), owner()->try_index(), name,
       arguments, Array::ZoneHandle(), 2);
   ReturnComputation(call);
@@ skipping 14 matching lines @@
                                               node->operand()->token_index(),
                                               owner()->try_index(),
                                               value));
       AddInstruction(assert_boolean);
       value = new UseVal(assert_boolean);
     }
     BooleanNegateComp* negate = new BooleanNegateComp(value);
     ReturnComputation(negate);
     return;
   }
-  ArgumentGraphVisitor for_value(owner(), temp_index());
+  ValueGraphVisitor for_value(owner(), temp_index());
   node->operand()->Visit(&for_value);
   Append(for_value);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(1);
   arguments->Add(for_value.value());
   const String& name =
       String::ZoneHandle(String::NewSymbol((node->kind() == Token::kSUB)
                                                ? Token::Str(Token::kNEGATE)
                                                : node->Name()));
   InstanceCallComp* call = new InstanceCallComp(
       node->id(), node->token_index(), owner()->try_index(), name,
@@ skipping 58 matching lines @@
   ReturnValue(new UseVal(load));
 }
 
 
 Definition* EffectGraphVisitor::BuildIncrOpFieldLoad(
     IncrOpInstanceFieldNode* node,
     Value** receiver) {
   // Evaluate the receiver and duplicate it (it has two uses).
   //   t_n   <- ... receiver ...
   //   t_n+1 <- Pick(t_n)
-  ArgumentGraphVisitor for_receiver(owner(), temp_index());
+  ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   AllocateTempIndex();
   ASSERT(temp_index() == for_receiver.temp_index());
   PickTempInstr* duplicate =
       new PickTempInstr(temp_index(), temp_index() - 1);
   AddInstruction(duplicate);
 
   // Load the value.
   //   t_n+1 <- InstanceCall(get:name, t_n+1)
@@ skipping 114 matching lines @@
 }
 
 
 Definition* EffectGraphVisitor::BuildIncrOpIndexedLoad(
     IncrOpIndexedNode* node,
     Value** receiver,
     Value** index) {
   // Evaluate the receiver and index.
   //   t_n   <- ... receiver ...
   //   t_n+1 <- ... index ...
-  ArgumentGraphVisitor for_receiver(owner(), temp_index());
+  ValueGraphVisitor for_receiver(owner(), temp_index());
   node->array()->Visit(&for_receiver);
   Append(for_receiver);
   AllocateTempIndex();
   ASSERT(temp_index() == for_receiver.temp_index());
 
-  ArgumentGraphVisitor for_index(owner(), temp_index());
+  ValueGraphVisitor for_index(owner(), temp_index());
   node->index()->Visit(&for_index);
   Append(for_index);
   AllocateTempIndex();
   ASSERT(temp_index() == for_index.temp_index());
 
   // Duplicate the receiver and index values, load the value.
   //   t_n+2 <- Pick(t_n)
   //   t_n+3 <- Pick(t_n+1)
   //   t_n+2 <- InstanceCall([], t_n+2, t_n+3)
   PickTempInstr* duplicate_receiver =
@@ skipping 598 matching lines @@
       new CreateClosureComp(node, owner()->try_index(), type_arguments);
   ReturnComputation(create);
 }
 
 
 void EffectGraphVisitor::TranslateArgumentList(
     const ArgumentListNode& node,
     intptr_t next_temp_index,
     ZoneGrowableArray<Value*>* values) {
   for (intptr_t i = 0; i < node.length(); ++i) {
-    ArgumentGraphVisitor for_argument(owner(), next_temp_index);
+    ValueGraphVisitor for_argument(owner(), next_temp_index);
     node.NodeAt(i)->Visit(&for_argument);
     Append(for_argument);
     next_temp_index = for_argument.temp_index();
     values->Add(for_argument.value());
   }
 }
 
 void EffectGraphVisitor::VisitInstanceCallNode(InstanceCallNode* node) {
   ArgumentListNode* arguments = node->arguments();
   int length = arguments->length();
   ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>(length + 1);
 
-  ArgumentGraphVisitor for_receiver(owner(), temp_index());
+  ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   values->Add(for_receiver.value());
 
   TranslateArgumentList(*arguments, for_receiver.temp_index(), values);
   InstanceCallComp* call = new InstanceCallComp(
       node->id(), node->token_index(), owner()->try_index(),
       node->function_name(), values,
                            arguments->names(), 1);
   ReturnComputation(call);
@@ skipping 15 matching lines @@
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
   // Context is saved around the call, it's treated as an extra operand
   // consumed by the call (but not an argument).
   BindInstr* context = new BindInstr(temp_index(), new CurrentContextComp());
   AddInstruction(context);
 
-  ArgumentGraphVisitor for_closure(owner(), temp_index() + 1);
+  ValueGraphVisitor for_closure(owner(), temp_index() + 1);
   node->closure()->Visit(&for_closure);
   Append(for_closure);
 
   ZoneGrowableArray<Value*>* arguments =
       new ZoneGrowableArray<Value*>(node->arguments()->length());
   arguments->Add(for_closure.value());
   TranslateArgumentList(*node->arguments(), temp_index() + 2, arguments);
   // First operand is the saved context, consumed by the call.
   ClosureCallComp* call =  new ClosureCallComp(node,
                                                owner()->try_index(),
@@ skipping 106 matching lines @@
         Type::New(instantiator_class, type_arguments, token_index));
     type ^= ClassFinalizer::FinalizeType(
         instantiator_class, type, ClassFinalizer::kFinalizeWellFormed);
     type_arguments = type.arguments();
     BindInstr* args =
         new BindInstr(temp_index(), new ConstantVal(type_arguments));
     AddInstruction(args);
     return new UseVal(args);
   }
   ASSERT(owner()->parsed_function().instantiator() != NULL);
-  ArgumentGraphVisitor for_instantiator(owner(), start_index);
+  ValueGraphVisitor for_instantiator(owner(), start_index);
   owner()->parsed_function().instantiator()->Visit(&for_instantiator);
   Append(for_instantiator);
   Function& outer_function =
       Function::Handle(owner()->parsed_function().function().raw());
   while (outer_function.IsLocalFunction()) {
     outer_function = outer_function.parent_function();
   }
   if (outer_function.IsFactory()) {
     // All OK.
     return for_instantiator.value();
@@ skipping 112 matching lines @@
   PickTempInstr* duplicate =
       new PickTempInstr(temp_index(), allocate->temp_index());
   AddInstruction(duplicate);
   AllocateTempIndex();
   BuildConstructorCall(node, new UseVal(duplicate));
   ReturnValue(new UseVal(allocate));
 }
 
 
 void EffectGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
-  ArgumentGraphVisitor for_receiver(owner(), temp_index());
+  ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(1);
   arguments->Add(for_receiver.value());
   const String& name =
       String::ZoneHandle(Field::GetterSymbol(node->field_name()));
   InstanceCallComp* call = new InstanceCallComp(
       node->id(), node->token_index(), owner()->try_index(), name,
       arguments, Array::ZoneHandle(), 1);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
-  ArgumentGraphVisitor for_receiver(owner(), temp_index());
+  ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
-  ArgumentGraphVisitor for_value(owner(), for_receiver.temp_index());
+  ValueGraphVisitor for_value(owner(), for_receiver.temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   InstanceSetterComp* setter =
       new InstanceSetterComp(node->id(),
                              node->token_index(),
                              owner()->try_index(),
                              node->field_name(),
                              for_receiver.value(),
                              for_value.value());
   ReturnComputation(setter);
@@ skipping 15 matching lines @@
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitStaticSetterNode(StaticSetterNode* node) {
   const String& setter_name =
       String::Handle(Field::SetterName(node->field_name()));
   const Function& setter_function =
       Function::ZoneHandle(node->cls().LookupStaticFunction(setter_name));
   ASSERT(!setter_function.IsNull());
-  ArgumentGraphVisitor for_value(owner(), temp_index());
+  ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   StaticSetterComp* call = new StaticSetterComp(node->token_index(),
                                                 owner()->try_index(),
                                                 setter_function,
                                                 for_value.value());
   ReturnComputation(call);
 }
 
 
@@ skipping 16 matching lines @@
 }
 
 
 void ValueGraphVisitor::VisitLoadLocalNode(LoadLocalNode* node) {
   LoadLocalComp* load = new LoadLocalComp(node->local(),
                                           owner()->context_level());
   ReturnComputation(load);
 }
 
 
-void TestGraphVisitor::VisitLoadLocalNode(LoadLocalNode* node) {
-  LoadLocalComp* load = new LoadLocalComp(node->local(),
-                                          owner()->context_level());
-  ReturnComputation(load);
-}
-
-
 // <Expression> ::= StoreLocal { local: LocalVariable
 //                               value: <Expression> }
 void EffectGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
     store_value = BuildAssignableValue(node->id(),
-                                       node->value()->token_index(),
+                                       node->value(),
                                        store_value,
                                        node->local().type(),
                                        node->local().name(),
                                        temp_index());
   }
   StoreLocalComp* store =
       new StoreLocalComp(node->local(), store_value, owner()->context_level());
   ReturnComputation(store);
 }
 
@@ skipping 15 matching lines @@
   node->instance()->Visit(&for_instance);
   Append(for_instance);
   ValueGraphVisitor for_value(owner(), for_instance.temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
     const AbstractType& type = AbstractType::ZoneHandle(node->field().type());
     const String& dst_name = String::ZoneHandle(node->field().name());
     store_value = BuildAssignableValue(node->id(),
-                                       node->value()->token_index(),
+                                       node->value(),
                                        store_value,
                                        type,
                                        dst_name,
                                        for_instance.temp_index());
   }
   StoreInstanceFieldComp* store =
       new StoreInstanceFieldComp(node, for_instance.value(), store_value);
   ReturnComputation(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadStaticFieldNode(LoadStaticFieldNode* node) {
   LoadStaticFieldComp* load = new LoadStaticFieldComp(node->field());
   ReturnComputation(load);
 }
 
 
 void EffectGraphVisitor::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
     const AbstractType& type = AbstractType::ZoneHandle(node->field().type());
     const String& dst_name = String::ZoneHandle(node->field().name());
     store_value = BuildAssignableValue(node->id(),
-                                       node->value()->token_index(),
+                                       node->value(),
                                        store_value,
                                        type,
                                        dst_name,
                                        temp_index());
   }
   StoreStaticFieldComp* store =
       new StoreStaticFieldComp(node->field(), store_value);
   ReturnComputation(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadIndexedNode(LoadIndexedNode* node) {
-  ArgumentGraphVisitor for_array(owner(), temp_index());
+  ValueGraphVisitor for_array(owner(), temp_index());
   node->array()->Visit(&for_array);
   Append(for_array);
-  ArgumentGraphVisitor for_index(owner(), for_array.temp_index());
+  ValueGraphVisitor for_index(owner(), for_array.temp_index());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(for_array.value());
   arguments->Add(for_index.value());
   const String& name =
       String::ZoneHandle(String::NewSymbol(Token::Str(Token::kINDEX)));
   InstanceCallComp* call = new InstanceCallComp(
       node->id(), node->token_index(), owner()->try_index(), name,
       arguments, Array::ZoneHandle(), 1);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
-  ArgumentGraphVisitor for_array(owner(), temp_index());
+  ValueGraphVisitor for_array(owner(), temp_index());
   node->array()->Visit(&for_array);
   Append(for_array);
-  ArgumentGraphVisitor for_index(owner(), for_array.temp_index());
+  ValueGraphVisitor for_index(owner(), for_array.temp_index());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
-  ArgumentGraphVisitor for_value(owner(), for_index.temp_index());
+  ValueGraphVisitor for_value(owner(), for_index.temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   StoreIndexedComp* store = new StoreIndexedComp(node->id(),
                                                  node->token_index(),
                                                  owner()->try_index(),
                                                  for_array.value(),
                                                  for_index.value(),
                                                  for_value.value());
   ReturnComputation(store);
 }
@@ skipping 42 matching lines @@
     // save it in a pre-allocated variable and restore it on exit.
     if (MustSaveRestoreContext(node)) {
       BindInstr* current_context =
           new BindInstr(temp_index() + 1, new CurrentContextComp());
       AddInstruction(current_context);
       StoreLocalComp* store_local = new StoreLocalComp(
           *owner()->parsed_function().saved_context_var(),
           new UseVal(current_context),
           0);
       AddInstruction(new DoInstr(store_local));
+      BindInstr* null_context =
+          new BindInstr(temp_index() + 1,
+                        new ConstantVal(Object::ZoneHandle()));
+      AddInstruction(null_context);
       StoreContextComp* store_context =
-          new StoreContextComp(new ConstantVal(Object::ZoneHandle()));
+          new StoreContextComp(new UseVal(null_context));
       AddInstruction(new DoInstr(store_context));
     }
 
     ChainContextComp* chain_context =
         new ChainContextComp(new UseVal(allocated_context));
     AddInstruction(new DoInstr(chain_context));
     owner()->set_context_level(scope->context_level());
 
     // If this node_sequence is the body of the function being compiled, copy
     // the captured parameters from the frame into the context.
@@ skipping 23 matching lines @@
                                               owner()->context_level()));
           AddInstruction(load);
           StoreLocalComp* store_local = new StoreLocalComp(
               parameter,
               new UseVal(load),
               owner()->context_level());
           AddInstruction(new DoInstr(store_local));
           // Write NULL to the source location to detect buggy accesses and
           // allow GC of passed value if it gets overwritten by a new value in
           // the function.
+          BindInstr* null_constant =
+              new BindInstr(temp_index(),
+                            new ConstantVal(Object::ZoneHandle()));
+          AddInstruction(null_constant);
           StoreLocalComp* clear_local = new StoreLocalComp(
               *temp_local,
-              new ConstantVal(Object::ZoneHandle()),
+              new UseVal(null_constant),
               owner()->context_level());
           AddInstruction(new DoInstr(clear_local));
         }
       }
     }
   }
 
   if (FLAG_enable_type_checks &&
       (node == owner()->parsed_function().node_sequence())) {
     const int num_params =
@@ skipping 146 matching lines @@
   BuildThrowNode(node);
   CloseFragment();
 }
 
 
 // A throw cannot be part of an expression, however, the parser may replace
 // certain expression nodes with a throw. In that case generate a literal null
 // so that the fragment is not closed in the middle of an expression.
 void ValueGraphVisitor::VisitThrowNode(ThrowNode* node) {
   BuildThrowNode(node);
-  ReturnValue(new ConstantVal(Instance::ZoneHandle()));
+  ReturnComputation(new ConstantVal(Instance::ZoneHandle()));
 }
 
 
 void EffectGraphVisitor::VisitInlinedFinallyNode(InlinedFinallyNode* node) {
   const intptr_t try_index = owner()->try_index();
   if (try_index >= 0) {
     // We are about to generate code for an inlined finally block. Exceptions
     // thrown in this block of code should be treated as though they are
     // thrown not from the current try block but the outer try block if any.
     owner()->set_try_index((try_index - 1));
@@ skipping 555 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