Add functions for setting an environment and rebinding a use.

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 54 matching lines @@
                              Environment* env,
                              Definition::UseKind use_kind) {
   InsertAfter(next->previous(), instr, env, use_kind);
 }
 
 
 void FlowGraph::InsertAfter(Instruction* prev,
                             Instruction* instr,
                             Environment* env,
                             Definition::UseKind use_kind) {
-  for (intptr_t i = instr->InputCount() - 1; i >= 0; --i) {
-    Value* input = instr->InputAt(i);
-    input->definition()->AddInputUse(input);
-  }
-  ASSERT(instr->env() == NULL);
-  if (env != NULL) env->DeepCopyTo(instr);
   if (use_kind == Definition::kValue) {
     ASSERT(instr->IsDefinition());
     instr->AsDefinition()->set_ssa_temp_index(alloc_ssa_temp_index());
   }
   instr->InsertAfter(prev);
+  ASSERT(instr->env() == NULL);
+  if (env != NULL) env->DeepCopyTo(instr);
 }
 
 
 void FlowGraph::DiscoverBlocks() {
   // Initialize state.
   preorder_.Clear();
   postorder_.Clear();
   reverse_postorder_.Clear();
   parent_.Clear();
   assigned_vars_.Clear();
@@ skipping 369 matching lines @@
   for (ForwardInstructionIterator it(block_entry); !it.Done(); it.Advance()) {
     Instruction* current = it.Current();
     // Attach current environment to the instructions that can deoptimize and
     // at goto instructions. Optimizations like LICM expect an environment at
     // gotos.
     if (current->CanDeoptimize() || current->IsGoto()) {
       Environment* deopt_env =
           Environment::From(*env,
                             num_non_copied_params_,
                             parsed_function_.function());
-      current->set_env(deopt_env);
-      intptr_t use_index = 0;
+      current->SetEnvironment(deopt_env);
       for (Environment::DeepIterator it(deopt_env); !it.Done(); it.Advance()) {
         Value* use = it.CurrentValue();
-        use->set_instruction(current);
-        use->set_use_index(use_index++);
         use->definition()->AddEnvUse(use);
       }
     }
     if (current->CanDeoptimize()) {
       current->env()->set_deopt_id(current->deopt_id());
     }
 
     // 2a. Handle uses:
     // Update expression stack environment for each use.
     // For each use of a LoadLocal or StoreLocal: Replace it with the value
     // from the environment.
     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()) {
         // Remove the load/store from the graph.
-        input_defn->UnuseAllInputs();
         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.
@@ skipping 24 matching lines @@
           if ((phi != NULL) && !phi->is_alive()) {
             phi->mark_alive();
             live_phis->Add(phi);
           }
         }
         // Update expression stack or remove from graph.
         if (definition->is_used()) {
           env->Add((*env)[index]);
           // We remove load/store instructions when we find their use in 2a.
         } else {
-          definition->UnuseAllInputs();
           it.RemoveCurrentFromGraph();
         }
       } else {
         // Not a load or store.
         if (definition->is_used()) {
           // Assign fresh SSA temporary and update expression stack.
           definition->set_ssa_temp_index(alloc_ssa_temp_index());
           env->Add(definition);
         }
       }
@@ skipping 136 matching lines @@
          !it.Done();
          it.Advance()) {
       ++size;
     }
   }
   return size;
 }
 
 
 }  // namespace dart