Remove the LoadLocal used at the end of a temp local scope.

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/compiler.h"
@@ skipping 842 matching lines @@
   ASSERT(!token_pos.IsClassifying());
   return BuildLoadLocal(*owner()->parsed_function().expression_temp_var(),
                         token_pos);
 }
 
 
 Definition* EffectGraphVisitor::BuildStoreLocal(const LocalVariable& local,
                                                 Value* value,
                                                 TokenPosition token_pos) {
   if (local.is_captured()) {
-    LocalVariable* tmp_var = EnterTempLocalScope(value, token_pos);
+    LocalVariable* tmp_var = EnterTempLocalScope(value);
     intptr_t delta =
         owner()->context_level() - local.owner()->context_level();
     ASSERT(delta >= 0);
     Value* context = Bind(BuildCurrentContext(token_pos));
     while (delta-- > 0) {
       context = Bind(new(Z) LoadFieldInstr(
           context, Context::parent_offset(), Type::ZoneHandle(Z, Type::null()),
           token_pos));
     }
     Value* tmp_val = Bind(new(Z) LoadLocalInstr(*tmp_var, token_pos));
     StoreInstanceFieldInstr* store =
         new(Z) StoreInstanceFieldInstr(Context::variable_offset(local.index()),
                                        context,
                                        tmp_val,
                                        kEmitStoreBarrier,
                                        token_pos);
     Do(store);
-    return ExitTempLocalScope(tmp_var, token_pos);
+    return ExitTempLocalScope(value);
   } else {
     return new(Z) StoreLocalInstr(local, value, token_pos);
   }
 }
 
 
 Definition* EffectGraphVisitor::BuildLoadLocal(const LocalVariable& local,
                                                TokenPosition token_pos) {
   if (local.IsConst()) {
     return new(Z) ConstantInstr(*local.ConstValue(), token_pos);
@@ skipping 419 matching lines @@
 }
 
 
 // <Expression> :: Assignable { expr:     <Expression>
 //                              type:     AbstractType
 //                              dst_name: String }
 void EffectGraphVisitor::VisitAssignableNode(AssignableNode* node) {
   ValueGraphVisitor for_value(owner());
   node->expr()->Visit(&for_value);
   Append(for_value);
-  Definition* checked_value;
   if (CanSkipTypeCheck(node->expr()->token_pos(),
                        for_value.value(),
                        node->type(),
                        node->dst_name())) {
-    // Drop the value and 0 additional temporaries.
-    checked_value = new(Z) DropTempsInstr(0, for_value.value());
+    ReturnValue(for_value.value());
   } else {
-    checked_value = BuildAssertAssignable(node->expr()->token_pos(),
-                                          for_value.value(),
-                                          node->type(),
-                                          node->dst_name());
+    ReturnDefinition(BuildAssertAssignable(node->expr()->token_pos(),
+                                           for_value.value(),
+                                           node->type(),
+                                           node->dst_name()));
   }
-  ReturnDefinition(checked_value);
 }
 
 
 void ValueGraphVisitor::VisitAssignableNode(AssignableNode* node) {
   ValueGraphVisitor for_value(owner());
   node->expr()->Visit(&for_value);
   Append(for_value);
   ReturnValue(BuildAssignableValue(node->expr()->token_pos(),
                                    for_value.value(),
                                    node->type(),
@@ skipping 893 matching lines @@
 
 intptr_t EffectGraphVisitor::GetCurrentTempLocalIndex() const {
   return kFirstLocalSlotFromFp
       - owner()->num_stack_locals()
       - owner()->num_copied_params()
       - owner()->args_pushed()
       - owner()->temp_count() + 1;
 }
 
 
-LocalVariable* EffectGraphVisitor::EnterTempLocalScope(
-    Value* value, TokenPosition token_pos) {
+LocalVariable* EffectGraphVisitor::EnterTempLocalScope(Value* value) {
   ASSERT(value->definition()->temp_index() == (owner()->temp_count() - 1));
   intptr_t index = GetCurrentTempLocalIndex();
   char name[64];
   OS::SNPrint(name, 64, ":tmp_local%" Pd, index);
   LocalVariable*  var =
       new(Z) LocalVariable(TokenPosition::kNoSource,
                            String::ZoneHandle(Z, Symbols::New(T, name)),
                            *value->Type()->ToAbstractType());
   var->set_index(index);
   return var;
 }
 
 
-Definition* EffectGraphVisitor::ExitTempLocalScope(
-    LocalVariable* var, TokenPosition token_pos) {
-  Value* tmp = Bind(new(Z) LoadLocalInstr(*var, token_pos));
-  owner()->DeallocateTemps(1);
-  ASSERT(GetCurrentTempLocalIndex() == var->index());
-  return new(Z) DropTempsInstr(1, tmp);
+Definition* EffectGraphVisitor::ExitTempLocalScope(Value* value) {
+  return new(Z) DropTempsInstr(0, value);

[Kevin Millikin (Google), 2016/05/10 08:19:47]

We can eliminate this Drop instruction if the value is needed and just use the
value instead which will consume it from the stack.

That change requires plumbing a flag through a few levels of helper functions
and changing the responsibility of emitting the possible Drop instruction from
the callers to this function.  I didn't make that change here.

 }
 
 
 void EffectGraphVisitor::BuildLetTempExpressions(LetNode* node) {
   intptr_t num_temps = node->num_temps();
   for (intptr_t i = 0; i < num_temps; ++i) {
     ValueGraphVisitor for_value(owner());
     node->InitializerAt(i)->Visit(&for_value);
     Append(for_value);
     ASSERT(!node->TempAt(i)->HasIndex() ||
@@ skipping 51 matching lines @@
       TypeArguments::ZoneHandle(Z, node->type().arguments());
   Value* element_type = BuildInstantiatedTypeArguments(node->token_pos(),
                                                        type_args);
   Value* num_elements =
       Bind(new(Z) ConstantInstr(Smi::ZoneHandle(Z, Smi::New(node->length()))));
   CreateArrayInstr* create = new(Z) CreateArrayInstr(node->token_pos(),
                                                      element_type,
                                                      num_elements);
   Value* array_val = Bind(create);
 
-  { LocalVariable* tmp_var = EnterTempLocalScope(array_val, node->token_pos());
+  { LocalVariable* tmp_var = EnterTempLocalScope(array_val);
     const intptr_t class_id = kArrayCid;
     const intptr_t deopt_id = Thread::kNoDeoptId;
     for (int i = 0; i < node->length(); ++i) {
       Value* array = Bind(new(Z) LoadLocalInstr(*tmp_var, node->token_pos()));
       Value* index =
           Bind(new(Z) ConstantInstr(Smi::ZoneHandle(Z, Smi::New(i)),
                                     node->token_pos()));
       ValueGraphVisitor for_value(owner());
       node->ElementAt(i)->Visit(&for_value);
       Append(for_value);
       // No store barrier needed for constants.
       const StoreBarrierType emit_store_barrier =
           for_value.value()->BindsToConstant()
               ? kNoStoreBarrier
               : kEmitStoreBarrier;
       const intptr_t index_scale = Instance::ElementSizeFor(class_id);
       StoreIndexedInstr* store = new(Z) StoreIndexedInstr(
           array, index, for_value.value(), emit_store_barrier,
           index_scale, class_id, deopt_id, node->token_pos());
       Do(store);
     }
-    ReturnDefinition(ExitTempLocalScope(tmp_var, node->token_pos()));
+    ReturnDefinition(ExitTempLocalScope(array_val));
   }
 }
 
 
 void EffectGraphVisitor::VisitStringInterpolateNode(
     StringInterpolateNode* node) {
   ValueGraphVisitor for_argument(owner());
   ArrayNode* arguments = node->value();
   if (arguments->length() == 1) {
     ZoneGrowableArray<PushArgumentInstr*>* values =
@@ skipping 72 matching lines @@
   const Class& closure_class =
       Class::ZoneHandle(Z, isolate()->object_store()->closure_class());
   ZoneGrowableArray<PushArgumentInstr*>* no_arguments =
       new(Z) ZoneGrowableArray<PushArgumentInstr*>(0);
   AllocateObjectInstr* alloc = new(Z) AllocateObjectInstr(node->token_pos(),
                                                           closure_class,
                                                           no_arguments);
   alloc->set_closure_function(function);
 
   Value* closure_val = Bind(alloc);
-  { LocalVariable* closure_tmp_var = EnterTempLocalScope(closure_val,
-                                                         node->token_pos());
+  { LocalVariable* closure_tmp_var = EnterTempLocalScope(closure_val);
     // Store type arguments if scope class is generic.
     const Type& function_type = Type::ZoneHandle(Z, function.SignatureType());
     const Class& scope_cls = Class::ZoneHandle(Z, function_type.type_class());
     if (scope_cls.IsGeneric()) {
       ASSERT(function.Owner() == scope_cls.raw());
       Value* closure_tmp_val = Bind(new(Z) LoadLocalInstr(*closure_tmp_var,
                                                           node->token_pos()));
       const Class& instantiator_class = Class::Handle(
           Z, owner()->function().Owner());
       Value* type_arguments = BuildInstantiatorTypeArguments(node->token_pos(),
@@ skipping 15 matching lines @@
                                       closure_tmp_val,
                                       func_val,
                                       kEmitStoreBarrier,
                                       node->token_pos()));
     if (is_implicit) {
       // Create new context containing the receiver.
       const intptr_t kNumContextVariables = 1;  // The receiver.
       Value* allocated_context =
           Bind(new(Z) AllocateContextInstr(node->token_pos(),
                                            kNumContextVariables));
-      { LocalVariable* context_tmp_var =
-            EnterTempLocalScope(allocated_context, node->token_pos());
+      { LocalVariable* context_tmp_var = EnterTempLocalScope(allocated_context);
         // Store receiver in context.
         Value* context_tmp_val =
             Bind(new(Z) LoadLocalInstr(*context_tmp_var, node->token_pos()));
         ValueGraphVisitor for_receiver(owner());
         node->receiver()->Visit(&for_receiver);
         Append(for_receiver);
         Value* receiver = for_receiver.value();
         Do(new(Z) StoreInstanceFieldInstr(Context::variable_offset(0),
                                           context_tmp_val,
                                           receiver,
                                           kEmitStoreBarrier,
                                           node->token_pos()));
         // Store new context in closure.
         closure_tmp_val =
             Bind(new(Z) LoadLocalInstr(*closure_tmp_var, node->token_pos()));
         context_tmp_val =
             Bind(new(Z) LoadLocalInstr(*context_tmp_var, node->token_pos()));
         Do(new(Z) StoreInstanceFieldInstr(Closure::context_offset(),
                                           closure_tmp_val,
                                           context_tmp_val,
                                           kEmitStoreBarrier,
                                           node->token_pos()));
-        Do(ExitTempLocalScope(context_tmp_var, node->token_pos()));
+        Do(ExitTempLocalScope(allocated_context));
       }
     } else {
       // Store current context in closure.
       closure_tmp_val = Bind(
           new(Z) LoadLocalInstr(*closure_tmp_var, node->token_pos()));
       Value* context = Bind(BuildCurrentContext(node->token_pos()));
       Do(new(Z) StoreInstanceFieldInstr(Closure::context_offset(),
                                         closure_tmp_val,
                                         context,
                                         kEmitStoreBarrier,
                                         node->token_pos()));
     }
-    ReturnDefinition(ExitTempLocalScope(closure_tmp_var, node->token_pos()));
+    ReturnDefinition(ExitTempLocalScope(closure_val));
   }
 }
 
 
 void EffectGraphVisitor::BuildPushArguments(
     const ArgumentListNode& node,
     ZoneGrowableArray<PushArgumentInstr*>* values) {
   for (intptr_t i = 0; i < node.length(); ++i) {
     ValueGraphVisitor for_argument(owner());
     node.NodeAt(i)->Visit(&for_argument);
@@ skipping 140 matching lines @@
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::BuildClosureCall(
     ClosureCallNode* node, bool result_needed) {
   ValueGraphVisitor for_closure(owner());
   node->closure()->Visit(&for_closure);
   Append(for_closure);
 
-  LocalVariable* tmp_var =
-      EnterTempLocalScope(for_closure.value(), node->token_pos());
+  Value* closure_value = for_closure.value();
+  LocalVariable* tmp_var = EnterTempLocalScope(closure_value);
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new(Z) ZoneGrowableArray<PushArgumentInstr*>(node->arguments()->length());
   Value* closure_val = Bind(new(Z) LoadLocalInstr(*tmp_var, node->token_pos()));
   PushArgumentInstr* push_closure = PushArgument(closure_val);
   arguments->Add(push_closure);
   BuildPushArguments(*node->arguments(), arguments);
 
   closure_val = Bind(new(Z) LoadLocalInstr(*tmp_var, node->token_pos()));
   LoadFieldInstr* function_load = new(Z) LoadFieldInstr(
       closure_val,
       Closure::function_offset(),
       AbstractType::ZoneHandle(Z, AbstractType::null()),
       node->token_pos());
   function_load->set_is_immutable(true);
   Value* function_val = Bind(function_load);
 
   Definition* closure_call =
       new(Z) ClosureCallInstr(function_val, node, arguments);
   if (result_needed) {
     Value* result = Bind(closure_call);
     Do(new(Z) StoreLocalInstr(*tmp_var, result, ST(node->token_pos())));
   } else {
     Do(closure_call);
   }
-  ReturnDefinition(ExitTempLocalScope(tmp_var, node->token_pos()));
+  ReturnDefinition(ExitTempLocalScope(closure_value));
 }
 
 
 void EffectGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
   BuildClosureCall(node, false);
 }
 
 
 void ValueGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
   BuildClosureCall(node, true);
@@ skipping 218 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);
-  { LocalVariable* tmp_var = EnterTempLocalScope(allocate, node->token_pos());
+  { LocalVariable* tmp_var = EnterTempLocalScope(allocate);
     Value* allocated_tmp =
         Bind(new(Z) LoadLocalInstr(*tmp_var, node->token_pos()));
     PushArgumentInstr* push_allocated_value = PushArgument(allocated_tmp);
     BuildConstructorCall(node, push_allocated_value);
-    ReturnDefinition(ExitTempLocalScope(tmp_var, node->token_pos()));
+    ReturnDefinition(ExitTempLocalScope(allocate));
   }
 }
 
 
 
 void EffectGraphVisitor::BuildInstanceGetterConditional(
     InstanceGetterNode* node) {
   const TokenPosition token_pos = node->token_pos();
   LocalVariable* temp_var = owner()->parsed_function().expression_temp_var();
   LoadLocalNode* load_temp = new(Z) LoadLocalNode(token_pos, temp_var);
@@ skipping 995 matching lines @@
   ASSERT((node->label() == NULL) || !is_top_level_sequence);
   NestedBlock nested_block(owner(), node);
 
   if (num_context_variables > 0) {
     // The local scope declares variables that are captured.
     // Allocate and chain a new context (Except don't chain when at the function
     // entry if the function does not capture any variables from outer scopes).
     Value* allocated_context =
         Bind(new(Z) AllocateContextInstr(node->token_pos(),
                                          num_context_variables));
-    { LocalVariable* tmp_var =
-          EnterTempLocalScope(allocated_context, node->token_pos());
+    { LocalVariable* tmp_var = EnterTempLocalScope(allocated_context);
       if (!is_top_level_sequence || HasContextScope()) {
         ASSERT(is_top_level_sequence ||
                (nested_block.ContextLevel() ==
                 nested_block.outer()->ContextLevel() + 1));
         Value* tmp_val = Bind(
             new(Z) LoadLocalInstr(*tmp_var, node->token_pos()));
         Value* parent_context = Bind(BuildCurrentContext(node->token_pos()));
         Do(new(Z) StoreInstanceFieldInstr(Context::parent_offset(),
                                           tmp_val,
                                           parent_context,
                                           kEmitStoreBarrier,
                                           node->token_pos()));
       }
       Do(BuildStoreContext(
-          Bind(ExitTempLocalScope(tmp_var, node->token_pos())),
+          Bind(ExitTempLocalScope(allocated_context)),
           node->token_pos()));
     }
 
     // If this node_sequence is the body of the function being compiled, copy
     // the captured parameters from the frame into the context.
     if (is_top_level_sequence) {
       ASSERT(scope->context_level() == 1);
       const int num_params = function.NumParameters();
       int param_frame_index = (num_params == function.num_fixed_parameters()) ?
           (kParamEndSlotFromFp + num_params) : kFirstLocalSlotFromFp;
@@ skipping 606 matching lines @@
                    Script::Handle(function.script()),
                    function.token_pos(),
                    Report::AtLocation,
                    "FlowGraphBuilder Bailout: %s %s",
                    String::Handle(function.name()).ToCString(),
                    reason);
   UNREACHABLE();
 }
 
 }  // namespace dart