Eliminate temporary locals for some expressions

runtime/vm/flow_graph.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.h"
 
 #include "vm/bit_vector.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/intermediate_language.h"
 #include "vm/longjump.h"
@@ skipping 400 matching lines @@
       continue;
     }
 
     // Iterate backwards starting at the last instruction.
     for (BackwardInstructionIterator it(block); !it.Done(); it.Advance()) {
       Instruction* current = it.Current();
 
       LoadLocalInstr* load = current->AsLoadLocal();
       if (load != NULL) {
         const intptr_t index = load->local().BitIndexIn(num_non_copied_params_);
+        if (index >= live_in->length()) continue;  // Skip tmp_locals.
         live_in->Add(index);
         if (!last_loads->Contains(index)) {
           last_loads->Add(index);
           load->mark_last();
         }
         continue;
       }
 
       StoreLocalInstr* store = current->AsStoreLocal();
       if (store != NULL) {
@@ skipping 336 matching lines @@
     // the renamed value.
     for (intptr_t i = current->InputCount() - 1; i >= 0; --i) {
       Value* v = current->InputAt(i);
       // Update expression stack.
       ASSERT(env->length() > variable_count());
 
       Definition* reaching_defn = env->RemoveLast();
       Definition* input_defn = v->definition();
       if (input_defn->IsLoadLocal() ||
           input_defn->IsStoreLocal() ||
+          input_defn->IsPushTemp() ||
+          input_defn->IsDropTemps() ||
           input_defn->IsConstant()) {
         // Remove the load/store from the graph.
         input_defn->RemoveFromGraph();
         // Assert we are not referencing nulls in the initial environment.
         ASSERT(reaching_defn->ssa_temp_index() != -1);
         v->set_definition(reaching_defn);
         input_defn = reaching_defn;
       }
       input_defn->AddInputUse(v);
     }
 
     // Drop pushed arguments for calls.
     for (intptr_t j = 0; j < current->ArgumentCount(); j++) {
       env->RemoveLast();
     }
 
     // 2b. Handle LoadLocal, StoreLocal, and Constant.
     Definition* definition = current->AsDefinition();
     if (definition != NULL) {
       LoadLocalInstr* load = definition->AsLoadLocal();
       StoreLocalInstr* store = definition->AsStoreLocal();
+      PushTempInstr* push = definition->AsPushTemp();
+      DropTempsInstr* drop = definition->AsDropTemps();
       ConstantInstr* constant = definition->AsConstant();
-      if ((load != NULL) || (store != NULL) || (constant != NULL)) {
+      if ((load != NULL) ||
+          (store != NULL) ||
+          (push != NULL) ||
+          (drop != NULL) ||
+          (constant != NULL)) {
         intptr_t index;
         Definition* result;
         if (store != NULL) {
           // Update renaming environment.
           index = store->local().BitIndexIn(num_non_copied_params_);
           result = store->value()->definition();
 
           if (variable_liveness->IsStoreAlive(block_entry, store)) {
             (*env)[index] = result;
           } else {
             (*env)[index] = constant_null();
           }
         } else if (load != NULL) {
           // The graph construction ensures we do not have an unused LoadLocal
           // computation.
           ASSERT(definition->is_used());
           index = load->local().BitIndexIn(num_non_copied_params_);
           result = (*env)[index];
 
           PhiInstr* phi = result->AsPhi();
           if ((phi != NULL) && !phi->is_alive()) {
             phi->mark_alive();
             live_phis->Add(phi);
           }
 
           if (variable_liveness->IsLastLoad(block_entry, load)) {
             (*env)[index] = constant_null();
           }
+        } else if (push != NULL) {
+          result = push->value()->definition();
+          env->Add(result);
+          it.RemoveCurrentFromGraph();
+          continue;
+        } else if (drop != NULL) {
+          // Drop temps from the environment.
+          for (intptr_t j = 0; j < drop->num_temps(); j++) {
+            env->RemoveLast();
+          }
+          result = drop->value()->definition();
         } else {
           ASSERT(definition->is_used());
           result = GetConstant(constant->value());
         }
         // Update expression stack or remove from graph.
         if (definition->is_used()) {
           ASSERT(result != NULL);
           env->Add(result);
           // We remove load/store/constant instructions when we find their
           // use in 2a.
@@ skipping 277 matching lines @@
 }
 
 
 bool BlockEffects::IsSideEffectFreePath(BlockEntryInstr* from,
                                         BlockEntryInstr* to) const {
   return available_at_[to->postorder_number()]->Contains(
       from->postorder_number());
 }
 
 }  // namespace dart