VM: Replace StoreVMField with StoreInstanceField.

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 "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/class_finalizer.h"
@@ skipping 687 matching lines @@
   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, bool result_is_needed) {
+Definition* EffectGraphVisitor::BuildStoreLocal(const LocalVariable& local,
+                                                Value* value) {
   if (local.is_captured()) {
-    if (result_is_needed) {
-      value = Bind(BuildStoreExprTemp(value));
-    }
-
+    LocalVariable* tmp_var = EnterTempLocalScope(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 LoadFieldInstr(
           context, Context::parent_offset(), Type::ZoneHandle()));
     }
-
-    StoreVMFieldInstr* store =
-        new StoreVMFieldInstr(context,
-                              Context::variable_offset(local.index()),
-                              value,
-                              local.type());
-    if (result_is_needed) {
-      Do(store);
-      return BuildLoadExprTemp();
-    } else {
-      return store;
-    }
+    Value* tmp_val = Bind(new LoadLocalInstr(*tmp_var));
+    StoreInstanceFieldInstr* store =
+        new StoreInstanceFieldInstr(Context::variable_offset(local.index()),
+                                    context,
+                                    tmp_val,
+                                    kEmitStoreBarrier);
+    Do(store);
+    return ExitTempLocalScope(tmp_var);
   } else {
     return new StoreLocalInstr(local, value);
   }
 }
 
 
 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 LoadFieldInstr(
           context, Context::parent_offset(), Type::ZoneHandle()));
     }
     return new LoadFieldInstr(context,
                               Context::variable_offset(local.index()),
                               local.type());
   } else {
     return new LoadLocalInstr(local);
   }
 }
 
 
 // Stores current context into the 'variable'
 void EffectGraphVisitor::BuildSaveContext(const LocalVariable& variable) {
   Value* context = Bind(new CurrentContextInstr());
-  Do(BuildStoreLocal(variable, context, kResultNotNeeded));
+  Do(BuildStoreLocal(variable, context));
 }
 
 
 // Loads context saved in 'context_variable' into the current context.
 void EffectGraphVisitor::BuildRestoreContext(const LocalVariable& variable) {
   Value* load_saved_context = Bind(BuildLoadLocal(variable));
   AddInstruction(new StoreContextInstr(load_saved_context));
 }
 
 
@@ skipping 172 matching lines @@
 // <Statement> ::= Return { value:                <Expression>
 //                          inlined_finally_list: <InlinedFinally>* }
 void EffectGraphVisitor::VisitReturnNode(ReturnNode* node) {
   ValueGraphVisitor for_value(owner());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* return_value = for_value.value();
 
   if (node->inlined_finally_list_length() > 0) {
     LocalVariable* temp = node->saved_return_value_var();
-    Do(BuildStoreLocal(*temp, return_value, kResultNotNeeded));
+    Do(BuildStoreLocal(*temp, return_value));
     for (intptr_t i = 0; i < node->inlined_finally_list_length(); i++) {
       InlineBailout("EffectGraphVisitor::VisitReturnNode (exception)");
       EffectGraphVisitor for_effect(owner());
       node->InlinedFinallyNodeAt(i)->Visit(&for_effect);
       Append(for_effect);
       if (!is_open()) {
         return;
       }
     }
     return_value = Bind(BuildLoadLocal(*temp));
@@ skipping 2123 matching lines @@
 
 
 void ValueGraphVisitor::VisitLoadLocalNode(LoadLocalNode* node) {
   Definition* load = BuildLoadLocal(node->local());
   ReturnDefinition(load);
 }
 
 
 // <Expression> ::= StoreLocal { local: LocalVariable
 //                               value: <Expression> }
-void EffectGraphVisitor::HandleStoreLocal(StoreLocalNode* node,
-                                          bool result_is_needed) {
+void EffectGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
   // If the right hand side is an expression that does not contain
   // a safe point for the debugger to stop, add an explicit stub
   // call.
   if (node->value()->IsLiteralNode() ||
       node->value()->IsLoadLocalNode()) {
     AddInstruction(new DebugStepCheckInstr(node->token_pos(),
                                            PcDescriptors::kRuntimeCall));
   }
 
   ValueGraphVisitor for_value(owner());
   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,
-                                      result_is_needed);
+  Definition* store = BuildStoreLocal(node->local(), store_value);
   ReturnDefinition(store);
 }
 
 
-void EffectGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
-  HandleStoreLocal(node, kResultNotNeeded);
-}
-
-
-void ValueGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
-  HandleStoreLocal(node, kResultNeeded);
-}
-
-
 void EffectGraphVisitor::VisitLoadInstanceFieldNode(
     LoadInstanceFieldNode* node) {
   ValueGraphVisitor for_instance(owner());
   node->instance()->Visit(&for_instance);
   Append(for_instance);
   LoadFieldInstr* load = new LoadFieldInstr(
       for_instance.value(),
-      node->field().Offset(),
+      &node->field(),
       AbstractType::ZoneHandle(node->field().type()));
-  load->set_field(&node->field());
   if (owner()->exit_collector() != NULL) {
     // While inlining into an optimized function, the field has
     // to be added to the list of guarded fields of the caller.
     if (node->field().guarded_cid() != kIllegalCid) {
       if (!node->field().is_nullable() ||
           (node->field().guarded_cid() == kNullCid)) {
         load->set_result_cid(node->field().guarded_cid());
       }
       FlowGraph::AddToGuardedFields(owner()->guarded_fields(), &node->field());
     }
@@ skipping 295 matching lines @@
     Value* allocated_context =
         Bind(new AllocateContextInstr(node->token_pos(),
                                       num_context_variables));
     { LocalVariable* tmp_var = EnterTempLocalScope(allocated_context);
       // If this node_sequence is the body of the function being compiled, and
       // if this function allocates context variables, but none of its enclosing
       // functions do, the context on entry is not linked as parent of the
       // allocated context but saved on entry and restored on exit as to prevent
       // memory leaks.
       // In this case, the parser pre-allocates a variable to save the context.
+      Value* tmp_val = Bind(new LoadLocalInstr(*tmp_var));
       Value* parent_context = NULL;
       if (MustSaveRestoreContext(node)) {
         BuildSaveContext(
             *owner()->parsed_function()->saved_entry_context_var());
         parent_context = Bind(new ConstantInstr(Object::ZoneHandle()));
       } else {
         parent_context = Bind(new CurrentContextInstr());
       }
-      Value* tmp_val = Bind(new LoadLocalInstr(*tmp_var));
-      Do(new StoreVMFieldInstr(tmp_val,
-                               Context::parent_offset(),
-                               parent_context,
-                               Type::ZoneHandle()));
+      Do(new StoreInstanceFieldInstr(Context::parent_offset(),
+                                     tmp_val,
+                                     parent_context,
+                                     kEmitStoreBarrier));
       AddInstruction(
           new StoreContextInstr(Bind(ExitTempLocalScope(tmp_var))));
     }
 
     // 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()) {
       ASSERT(scope->context_level() == 1);
       const Function& function = owner()->parsed_function()->function();
       const int num_params = function.NumParameters();
       int param_frame_index = (num_params == function.num_fixed_parameters()) ?
           (kParamEndSlotFromFp + num_params) : kFirstLocalSlotFromFp;
       for (int pos = 0; pos < num_params; param_frame_index--, pos++) {
         const LocalVariable& parameter = *scope->VariableAt(pos);
         ASSERT(parameter.owner() == scope);
         if (parameter.is_captured()) {
           // Create a temporary local describing the original position.
           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, kResultNotNeeded));
+          Do(BuildStoreLocal(parameter, load));
           // 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, kResultNotNeeded));
+          Do(BuildStoreLocal(*temp_local, null_constant));
         }
       }
     }
   }
 
   if (FLAG_enable_type_checks &&
       (node == owner()->parsed_function()->node_sequence())) {
     const Function& function = owner()->parsed_function()->function();
     const int num_params = function.NumParameters();
     int pos = 0;
@@ skipping 15 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, kResultNotNeeded));
+        Do(BuildStoreLocal(parameter, parameter_value));
       }
       pos++;
     }
   }
 
   intptr_t i = 0;
   while (is_open() && (i < node->length())) {
     EffectGraphVisitor for_effect(owner());
     node->NodeAt(i++)->Visit(&for_effect);
     Append(for_effect);
@@ skipping 386 matching lines @@
                                   LanguageError::kError,
                                   Heap::kNew,
                                   "FlowGraphBuilder Bailout: %s %s",
                                   String::Handle(function.name()).ToCString(),
                                   reason));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart