Refactor building of StoreStaticField and StoreLocal to manually preserve value.

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 190 matching lines @@
 }
 
 
 PushArgumentInstr* EffectGraphVisitor::PushArgument(Value* value) {
   PushArgumentInstr* result = new PushArgumentInstr(value);
   AddInstruction(result);
   return result;
 }
 
 
+Definition* EffectGraphVisitor::BuildStoreTemp(const LocalVariable& local,
+                                               Value* value) {
+  ASSERT(!local.is_captured());
+  return new StoreLocalInstr(local, value, owner()->context_level());
+}
+
+
+Definition* EffectGraphVisitor::BuildStoreExprTemp(Value* value) {
+  return BuildStoreTemp(*owner()->parsed_function().expression_temp_var(),
+                        value);
+}
+
+
+Definition* EffectGraphVisitor::BuildLoadExprTemp() {
+  return BuildLoadLocal(*owner()->parsed_function().expression_temp_var());
+}
+
+
 Definition* EffectGraphVisitor::BuildStoreLocal(
-    const LocalVariable& local, Value* value) {
+    const LocalVariable& local, Value* value, bool result_is_needed) {
   if (local.is_captured()) {
+    if (result_is_needed) {
+      value = Bind(BuildStoreExprTemp(value));
+    }
+
     intptr_t delta =
         owner()->context_level() - local.owner()->context_level();
     ASSERT(delta >= 0);
     Value* context = Bind(new CurrentContextInstr());
     while (delta-- > 0) {
       context = Bind(new LoadVMFieldInstr(
           context, Context::parent_offset(), Type::ZoneHandle()));
     }
-    return new StoreVMFieldInstr(
-        context,
-        Context::variable_offset(local.index()),
-        value,
-        local.type());
+
+    StoreVMFieldInstr* store =
+        new StoreVMFieldInstr(context,
+                              Context::variable_offset(local.index()),
+                              value,
+                              local.type());
+    if (result_is_needed) {
+      Do(store);
+      return BuildLoadExprTemp();
+    } else {
+      return store;
+    }
   } else {
     return new StoreLocalInstr(local, value, owner()->context_level());
   }
 }
 
 
 Definition* EffectGraphVisitor::BuildLoadLocal(const LocalVariable& local) {
   if (local.is_captured()) {
     intptr_t delta =
         owner()->context_level() - local.owner()->context_level();
     ASSERT(delta >= 0);
     Value* context = Bind(new CurrentContextInstr());
     while (delta-- > 0) {
       context = Bind(new LoadVMFieldInstr(
           context, Context::parent_offset(), Type::ZoneHandle()));
     }
     return new LoadVMFieldInstr(context,
                                 Context::variable_offset(local.index()),
                                 local.type());
   } else {
     return new LoadLocalInstr(local, owner()->context_level());
   }
 }
 
 
 // Stores current context into the 'variable'
 void EffectGraphVisitor::BuildStoreContext(const LocalVariable& variable) {
   Value* context = Bind(new CurrentContextInstr());
-  Do(BuildStoreLocal(variable, context));
+  Do(BuildStoreLocal(variable, context, kResultNotNeeded));
 }
 
 
 // Loads context saved in 'context_variable' into the current context.
 void EffectGraphVisitor::BuildLoadContext(const LocalVariable& variable) {
   Value* load_saved_context = Bind(BuildLoadLocal(variable));
   Do(new StoreContextInstr(load_saved_context));
 }
 
 
@@ skipping 383 matching lines @@
     if (FLAG_enable_type_checks) {
       right_value =
           for_right.Bind(new AssertBooleanInstr(node->right()->token_pos(),
                                                 right_value));
     }
     Value* constant_true = for_right.Bind(new ConstantInstr(bool_true));
     Value* compare =
         for_right.Bind(new StrictCompareInstr(Token::kEQ_STRICT,
                                               right_value,
                                               constant_true));
-    for_right.Do(BuildStoreLocal(
-        *owner()->parsed_function().expression_temp_var(),
-        compare));
+    for_right.Do(BuildStoreExprTemp(compare));
 
     if (node->kind() == Token::kAND) {
       ValueGraphVisitor for_false(owner(), temp_index());
       Value* constant_false = for_false.Bind(new ConstantInstr(bool_false));
-      for_false.Do(BuildStoreLocal(
-          *owner()->parsed_function().expression_temp_var(),
-          constant_false));
+      for_false.Do(BuildStoreExprTemp(constant_false));
       Join(for_test, for_right, for_false);
     } else {
       ASSERT(node->kind() == Token::kOR);
       ValueGraphVisitor for_true(owner(), temp_index());
       Value* constant_true = for_true.Bind(new ConstantInstr(bool_true));
-      for_true.Do(BuildStoreLocal(
-          *owner()->parsed_function().expression_temp_var(),
-          constant_true));
+      for_true.Do(BuildStoreExprTemp(constant_true));
       Join(for_test, for_true, for_right);
     }
-    ReturnDefinition(
-        BuildLoadLocal(*owner()->parsed_function().expression_temp_var()));
+    ReturnDefinition(BuildLoadExprTemp());
     return;
   }
   EffectGraphVisitor::VisitBinaryOpNode(node);
 }
 
 
 void EffectGraphVisitor::BuildTypecheckArguments(
     intptr_t token_pos,
     Value** instantiator_result,
     Value** instantiator_type_arguments_result) {
   InlineBailout("EffectGraphVisitor::VisitBinaryOpNode");
   Value* instantiator = NULL;
   Value* instantiator_type_arguments = NULL;
   const Class& instantiator_class = Class::Handle(
       owner()->parsed_function().function().Owner());
   // Since called only when type tested against is not instantiated.
   ASSERT(instantiator_class.NumTypeParameters() > 0);
   instantiator = BuildInstantiator();
   if (instantiator == NULL) {
     // No instantiator when inside factory.
     instantiator = BuildNullValue();
     instantiator_type_arguments =
         BuildInstantiatorTypeArguments(token_pos, NULL);
   } else {
     // Preserve instantiator.
-    const LocalVariable& expr_temp =
-        *owner()->parsed_function().expression_temp_var();
-    instantiator = Bind(BuildStoreLocal(expr_temp, instantiator));
-    Value* loaded = Bind(BuildLoadLocal(expr_temp));
+    instantiator = Bind(BuildStoreExprTemp(instantiator));
+    Value* loaded = Bind(BuildLoadExprTemp());
     instantiator_type_arguments =
         BuildInstantiatorTypeArguments(token_pos, loaded);
   }
   *instantiator_result = instantiator;
   *instantiator_type_arguments_result = instantiator_type_arguments;
 }
 
 
 Value* EffectGraphVisitor::BuildNullValue() {
   InlineBailout("EffectGraphVisitor::BuildNullValue");
@@ skipping 280 matching lines @@
 void ValueGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
   InlineBailout("ValueGraphVisitor::VisitConditionalExprNode");
   TestGraphVisitor for_test(owner(),
                             temp_index(),
                             node->condition()->token_pos());
   node->condition()->Visit(&for_test);
 
   ValueGraphVisitor for_true(owner(), temp_index());
   node->true_expr()->Visit(&for_true);
   ASSERT(for_true.is_open());
-  for_true.Do(BuildStoreLocal(
-      *owner()->parsed_function().expression_temp_var(), for_true.value()));
+  for_true.Do(BuildStoreExprTemp(for_true.value()));
 
   ValueGraphVisitor for_false(owner(), temp_index());
   node->false_expr()->Visit(&for_false);
   ASSERT(for_false.is_open());
-  for_false.Do(BuildStoreLocal(
-      *owner()->parsed_function().expression_temp_var(), for_false.value()));
+  for_false.Do(BuildStoreExprTemp(for_false.value()));
 
   Join(for_test, for_true, for_false);
-  ReturnDefinition(
-      BuildLoadLocal(*owner()->parsed_function().expression_temp_var()));
+  ReturnDefinition(BuildLoadExprTemp());
 }
 
 
 // <Statement> ::= If { condition: <Expression>
 //                      true_branch: <Sequence>
 //                      false_branch: <Sequence> }
 void EffectGraphVisitor::VisitIfNode(IfNode* node) {
   TestGraphVisitor for_test(owner(),
                             temp_index(),
                             node->condition()->token_pos());
@@ skipping 774 matching lines @@
   //   t_n   <- t2
   //   t_n+1 <- t1
   // Use expression_temp_var and node->allocated_object_var() locals to keep
   // intermediate results around (t1 and t2 above).
   ASSERT(owner()->parsed_function().expression_temp_var() != NULL);
   const LocalVariable& t1 = *owner()->parsed_function().expression_temp_var();
   const LocalVariable& t2 = node->allocated_object_var();
   Value* instantiator_type_arguments = BuildInstantiatorTypeArguments(
       node->token_pos(), NULL);
   Value* stored_instantiator =
-      Bind(BuildStoreLocal(t1, instantiator_type_arguments));
+      Bind(BuildStoreTemp(t1, instantiator_type_arguments));
   // t1: instantiator type arguments.
 
   Value* extract_type_arguments = Bind(
       new ExtractConstructorTypeArgumentsInstr(
           node->token_pos(),
           node->type_arguments(),
           stored_instantiator));
 
-  Do(BuildStoreLocal(t2, extract_type_arguments));
+  Do(BuildStoreTemp(t2, extract_type_arguments));
   // t2: extracted constructor type arguments.
   Value* load_instantiator = Bind(BuildLoadLocal(t1));
 
   Value* extract_instantiator =
       Bind(new ExtractConstructorInstantiatorInstr(node, load_instantiator));
-  Do(BuildStoreLocal(t1, extract_instantiator));
+  Do(BuildStoreTemp(t1, extract_instantiator));
   // t2: extracted constructor type arguments.
   // t1: extracted constructor instantiator.
   Value* type_arguments_val = Bind(BuildLoadLocal(t2));
   if (call_arguments != NULL) {
     ASSERT(type_arguments == NULL);
     call_arguments->Add(PushArgument(type_arguments_val));
   } else {
     ASSERT(type_arguments != NULL);
     *type_arguments = type_arguments_val;
   }
@@ skipping 18 matching lines @@
 
   // t_n contains the allocated and initialized object.
   //   t_n      <- AllocateObject(class)
   //   t_n      <- StoreLocal(temp, t_n);
   //   t_n+1    <- ctor-arg
   //   t_n+2... <- constructor arguments start here
   //   StaticCall(constructor, t_n, t_n+1, ...)
   //   tn       <- LoadLocal(temp)
 
   Value* allocate = BuildObjectAllocation(node);
-  Definition* store_allocated = BuildStoreLocal(
+  Value* allocated_value = Bind(BuildStoreTemp(
       node->allocated_object_var(),
-      allocate);
-  Value* allocated_value = Bind(store_allocated);
+      allocate));
   PushArgumentInstr* push_allocated_value = PushArgument(allocated_value);
   BuildConstructorCall(node, push_allocated_value);
   Definition* load_allocated = BuildLoadLocal(
       node->allocated_object_var());
   allocated_value = Bind(load_allocated);
   ReturnValue(allocated_value);
 }
 
 
 void EffectGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
@@ skipping 23 matching lines @@
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   arguments->Add(PushArgument(for_receiver.value()));
 
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
 
   Value* value = NULL;
   if (result_is_needed) {
-    value = Bind(
-        BuildStoreLocal(*owner()->parsed_function().expression_temp_var(),
-                        for_value.value()));
+    value = Bind(BuildStoreExprTemp(for_value.value()));
   } else {
     value = for_value.value();
   }
   arguments->Add(PushArgument(value));
 }
 
 
 void EffectGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
   InlineBailout("EffectGraphVisitor::VisitInstanceSetterNode");
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
-  BuildInstanceSetterArguments(node, arguments, false);  // Value not used.
+  BuildInstanceSetterArguments(node, arguments, kResultNotNeeded);
   const String& name =
       String::ZoneHandle(Field::SetterSymbol(node->field_name()));
   InstanceCallInstr* call = new InstanceCallInstr(node->token_pos(),
                                                   name,
                                                   Token::kSET,
                                                   arguments,
                                                   Array::ZoneHandle(),
                                                   1);  // Checked arg count.
   ReturnDefinition(call);
 }
 
 
 void ValueGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
   InlineBailout("ValueGraphVisitor::VisitInstanceSetterNode");
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
-  BuildInstanceSetterArguments(node, arguments, true);  // Value used.
+  BuildInstanceSetterArguments(node, arguments, kResultNeeded);
   const String& name =
       String::ZoneHandle(Field::SetterSymbol(node->field_name()));
   Do(new InstanceCallInstr(node->token_pos(),
                            name,
                            Token::kSET,
                            arguments,
                            Array::ZoneHandle(),
                            1));  // Checked argument count.
-  ReturnDefinition(
-       BuildLoadLocal(*owner()->parsed_function().expression_temp_var()));
+  ReturnDefinition(BuildLoadExprTemp());
 }
 
 
 void EffectGraphVisitor::VisitStaticGetterNode(StaticGetterNode* node) {
   InlineBailout("EffectGraphVisitor::VisitStaticGetterNode");
   const String& getter_name =
       String::Handle(Field::GetterName(node->field_name()));
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>();
   Function& getter_function = Function::ZoneHandle();
@@ skipping 41 matching lines @@
     ValueGraphVisitor for_receiver(owner(), temp_index());
     node->receiver()->Visit(&for_receiver);
     Append(for_receiver);
     arguments->Add(PushArgument(for_receiver.value()));
   }
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* value = NULL;
   if (result_is_needed) {
-    value = Bind(
-        BuildStoreLocal(*owner()->parsed_function().expression_temp_var(),
-                        for_value.value()));
+    value = Bind(BuildStoreExprTemp(for_value.value()));
   } else {
     value = for_value.value();
   }
   arguments->Add(PushArgument(value));
 
   StaticCallInstr* call = new StaticCallInstr(node->token_pos(),
                                               setter_function,
                                               Array::ZoneHandle(),  // No names.
                                               arguments);
   if (result_is_needed) {
     Do(call);
-    ReturnDefinition(
-         BuildLoadLocal(*owner()->parsed_function().expression_temp_var()));
+    ReturnDefinition(BuildLoadExprTemp());
   } else {
     ReturnDefinition(call);
   }
 }
 
 
 void EffectGraphVisitor::VisitStaticSetterNode(StaticSetterNode* node) {
   InlineBailout("EffectGraphVisitor::VisitStaticSetterNode");
   BuildStaticSetter(node, false);  // Result not needed.
 }
@@ skipping 33 matching lines @@
 void ValueGraphVisitor::VisitLoadLocalNode(LoadLocalNode* node) {
   InlineBailout("ValueGraphVisitor::VisitLoadLocalNode");
   EffectGraphVisitor::VisitLoadLocalNode(node);
   Definition* load = BuildLoadLocal(node->local());
   ReturnDefinition(load);
 }
 
 
 // <Expression> ::= StoreLocal { local: LocalVariable
 //                               value: <Expression> }
-void EffectGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
+void EffectGraphVisitor::HandleStoreLocal(StoreLocalNode* node,
+                                          bool result_is_needed) {
   InlineBailout("EffectGraphVisitor::VisitStoreLocalNode");
   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->value()->token_pos(),
                                        store_value,
                                        node->local().type(),
                                        node->local().name());
   }
-  Definition* store = BuildStoreLocal(node->local(), store_value);
+  Definition* store = BuildStoreLocal(node->local(),
+                                      store_value,
+                                      result_is_needed);
   ReturnDefinition(store);
 }
 
 
+void EffectGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
+  HandleStoreLocal(node, kResultNotNeeded);
+}
+
+
+void ValueGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
+  HandleStoreLocal(node, kResultNeeded);
+}
+
+
 void EffectGraphVisitor::VisitLoadInstanceFieldNode(
     LoadInstanceFieldNode* node) {
   InlineBailout("EffectGraphVisitor::VisitLoadInstanceFieldNode");
   ValueGraphVisitor for_instance(owner(), temp_index());
   node->instance()->Visit(&for_instance);
   Append(for_instance);
   LoadInstanceFieldInstr* load = new LoadInstanceFieldInstr(
       node->field(), for_instance.value());
   ReturnDefinition(load);
 }
@@ skipping 31 matching lines @@
 }
 
 
 void EffectGraphVisitor::VisitLoadStaticFieldNode(LoadStaticFieldNode* node) {
   InlineBailout("EffectGraphVisitor::VisitLoadStaticFieldNode");
   LoadStaticFieldInstr* load = new LoadStaticFieldInstr(node->field());
   ReturnDefinition(load);
 }
 
 
-void EffectGraphVisitor::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
+Definition* EffectGraphVisitor::BuildStoreStaticField(
+  StoreStaticFieldNode* node, bool result_is_needed) {
   InlineBailout("EffectGraphVisitor::VisitStoreStaticFieldNode");
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
-  Value* store_value = for_value.value();
+  Value* store_value = NULL;
+  if (result_is_needed) {
+    store_value = Bind(BuildStoreExprTemp(for_value.value()));
+  } else {
+    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->value()->token_pos(),
                                        store_value,
                                        type,
                                        dst_name);
   }
   StoreStaticFieldInstr* store =
       new StoreStaticFieldInstr(node->field(), store_value);
-  ReturnDefinition(store);
+
+  if (result_is_needed) {
+    Do(store);
+    return BuildLoadExprTemp();
+  } else {
+    return store;
+  }
 }
 
 
+void EffectGraphVisitor::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
+  ReturnDefinition(BuildStoreStaticField(node, kResultNotNeeded));
+}
+
+
+void ValueGraphVisitor::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
+  ReturnDefinition(BuildStoreStaticField(node, kResultNeeded));
+}
+
+
 void EffectGraphVisitor::VisitLoadIndexedNode(LoadIndexedNode* node) {
   InlineBailout("EffectGraphVisitor::VisitLoadIndexedNode");
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   ValueGraphVisitor for_array(owner(), temp_index());
   node->array()->Visit(&for_array);
   Append(for_array);
   arguments->Add(PushArgument(for_array.value()));
 
   ValueGraphVisitor for_index(owner(), temp_index());
@@ skipping 28 matching lines @@
   ValueGraphVisitor for_index(owner(), temp_index());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
   arguments->Add(PushArgument(for_index.value()));
 
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* value = NULL;
   if (result_is_needed) {
-    value = Bind(
-        BuildStoreLocal(*owner()->parsed_function().expression_temp_var(),
-                        for_value.value()));
+    value = Bind(BuildStoreExprTemp(for_value.value()));
   } else {
     value = for_value.value();
   }
   arguments->Add(PushArgument(value));
 
   const intptr_t checked_argument_count = 1;
   const String& name =
       String::ZoneHandle(Symbols::New(Token::Str(Token::kASSIGN_INDEX)));
   InstanceCallInstr* store = new InstanceCallInstr(node->token_pos(),
                                                    name,
                                                    Token::kASSIGN_INDEX,
                                                    arguments,
                                                    Array::ZoneHandle(),
                                                    checked_argument_count);
   if (result_is_needed) {
     Do(store);
-    return BuildLoadLocal(*owner()->parsed_function().expression_temp_var());
+    return BuildLoadExprTemp();
   } else {
     return store;
   }
 }
 
 
 void EffectGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
   InlineBailout("EffectGraphVisitor::VisitStoreIndexedNode");
-  ReturnDefinition(BuildStoreIndexedValues(node,
-                                           false));  // Result not needed.
+  ReturnDefinition(BuildStoreIndexedValues(node, kResultNotNeeded));
 }
 
 
 void ValueGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
   InlineBailout("ValueGraphVisitor::VisitStoreIndexedNode");
-  ReturnDefinition(BuildStoreIndexedValues(node,
-                                           true));  // Result is needed.
+  ReturnDefinition(BuildStoreIndexedValues(node, kResultNeeded));
 }
 
 
 bool EffectGraphVisitor::MustSaveRestoreContext(SequenceNode* node) const {
   return (node == owner()->parsed_function().node_sequence()) &&
          (owner()->parsed_function().saved_context_var() != NULL);
 }
 
 
 void EffectGraphVisitor::UnchainContext() {
@@ skipping 23 matching lines @@
     Value* allocated_context =
         Bind(new AllocateContextInstr(node->token_pos(),
                                       num_context_variables));
 
     // If this node_sequence is the body of the function being compiled, and if
     // this function is not a closure, do not link the current context as the
     // parent of the newly allocated context, as it is not accessible. Instead,
     // save it in a pre-allocated variable and restore it on exit.
     if (MustSaveRestoreContext(node)) {
       Value* current_context = Bind(new CurrentContextInstr());
-      Do(BuildStoreLocal(*owner()->parsed_function().saved_context_var(),
-                         current_context));
+      Do(BuildStoreTemp(*owner()->parsed_function().saved_context_var(),
+                        current_context));
       Value* null_context = Bind(new ConstantInstr(Object::ZoneHandle()));
       Do(new StoreContextInstr(null_context));
     }
 
     Do(new ChainContextInstr(allocated_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.
     if (node == owner()->parsed_function().node_sequence()) {
@@ skipping 15 matching lines @@
           const String& temp_name = String::ZoneHandle(String::Concat(
               parameter.name(), String::Handle(Symbols::New("-orig"))));
           LocalVariable* temp_local = new LocalVariable(
               0,  // Token index.
               temp_name,
               Type::ZoneHandle(Type::DynamicType()));  // Type.
           temp_local->set_index(param_frame_index);
 
           // Copy parameter from local frame to current context.
           Value* load = Bind(BuildLoadLocal(*temp_local));
-          Do(BuildStoreLocal(parameter, load));
+          Do(BuildStoreLocal(parameter, load, kResultNotNeeded));
           // 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.
           Value* null_constant =
               Bind(new ConstantInstr(Object::ZoneHandle()));
-          Do(BuildStoreLocal(*temp_local, null_constant));
+          Do(BuildStoreLocal(*temp_local, null_constant, kResultNotNeeded));
         }
       }
     }
   }
 
   if (FLAG_enable_type_checks &&
       (node == owner()->parsed_function().node_sequence())) {
     InlineBailout("EffectGraphVisitor::VisitSequenceNode (type check)");
     const Function& function = owner()->parsed_function().function();
     const int num_params = function.NumberOfParameters();
@@ skipping 16 matching lines @@
         Value* parameter_value = Bind(BuildLoadLocal(parameter));
         AssertAssignableInstr* assert_assignable =
             BuildAssertAssignable(parameter.token_pos(),
                                   parameter_value,
                                   parameter.type(),
                                   parameter.name());
         parameter_value = Bind(assert_assignable);
         // Store the type checked argument back to its corresponding local
         // variable so that ssa renaming detects the dependency and makes use
         // of the checked type in type propagation.
-        Do(BuildStoreLocal(parameter, parameter_value));
+        Do(BuildStoreLocal(parameter, parameter_value, kResultNotNeeded));
       }
       pos++;
     }
   }
 
   intptr_t i = 0;
   while (is_open() && (i < node->length())) {
     EffectGraphVisitor for_effect(owner(), temp_index());
     node->NodeAt(i++)->Visit(&for_effect);
     Append(for_effect);
@@ skipping 215 matching lines @@
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(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