Add functions for setting an environment and rebinding a use.

runtime/vm/intermediate_language.h

 // Copyright (c) 2013, 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.
 
 #ifndef VM_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 269 matching lines @@
 
   Instruction* instruction() const { return instruction_; }
   void set_instruction(Instruction* instruction) { instruction_ = instruction; }
 
   intptr_t use_index() const { return use_index_; }
   void set_use_index(intptr_t index) { use_index_ = index; }
 
   static void AddToList(Value* value, Value** list);
   void RemoveFromUseList();
 
+  // Change the definition after use lists have been computed.
+  inline void BindTo(Definition* definition);
+
   Value* Copy() { return new Value(definition_); }
 
   // This function must only be used when the new Value is dominated by
   // the original Value.
   Value* CopyWithType() {
     Value* copy = new Value(definition_);
     copy->reaching_type_ = reaching_type_;
     return copy;
   }
 
@@ skipping 270 matching lines @@
     next_ = instr;
   }
 
   // Link together two instruction.
   void LinkTo(Instruction* next) {
     ASSERT(this != next);
     this->set_next(next);
     next->set_previous(this);
   }
 
-  // Removed this instruction from the graph.
+  // Removed this instruction from the graph, after use lists have been
+  // computed.  If the instruction is a definition with uses, those uses are
+  // unaffected (so the instruction can be reinserted, e.g., hoisting).
   Instruction* RemoveFromGraph(bool return_previous = true);
 
   // Normal instructions can have 0 (inside a block) or 1 (last instruction in
   // a block) successors. Branch instruction with >1 successors override this
   // function.
   virtual intptr_t SuccessorCount() const;
   virtual BlockEntryInstr* SuccessorAt(intptr_t index) const;
 
   void Goto(JoinEntryInstr* entry);
 
@@ skipping 25 matching lines @@
 
   virtual LocationSummary* MakeLocationSummary() const = 0;
 
   static LocationSummary* MakeCallSummary();
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     UNIMPLEMENTED();
   }
 
   Environment* env() const { return env_; }
-  void set_env(Environment* env) { env_ = env; }
+  void SetEnvironment(Environment* deopt_env);
+  void RemoveEnvironment();
 
   intptr_t lifetime_position() const { return lifetime_position_; }
   void set_lifetime_position(intptr_t pos) {
     lifetime_position_ = pos;
   }
 
   // Returns representation expected for the input operand at the given index.
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     return kTagged;
   }
@@ skipping 13 matching lines @@
   virtual intptr_t DeoptimizationTarget() const {
     UNREACHABLE();
     return Isolate::kNoDeoptId;
   }
 
   // Returns a replacement for the instruction or NULL if the instruction can
   // be eliminated.  By default returns the this instruction which means no
   // change.
   virtual Instruction* Canonicalize(FlowGraphOptimizer* optimizer);
 
-  // Insert this instruction before 'next'.
-  void InsertBefore(Instruction* next);
+  // Insert this instruction before 'next' after use lists are computed.
+  // Instructions cannot be inserted before a block entry or any other
+  // instruction without a previous instruction.
+  void InsertBefore(Instruction* next) { InsertAfter(next->previous()); }
 
-  // Insert this instruction after 'prev'.
+  // Insert this instruction after 'prev' after use lists are computed.
   void InsertAfter(Instruction* prev);
 
   // Returns true if the instruction is affected by side effects.
   // Only instructions that are not affected by side effects can participate
   // in redundancy elimination or loop invariant code motion.
   // TODO(fschneider): Make this abstract and implement for all instructions
   // instead of returning the safe default (true).
   virtual bool AffectedBySideEffect() const { return true; }
 
   // Get the block entry for this instruction.
@@ skipping 707 matching lines @@
   Value* input_use_list_;
   Value* env_use_list_;
   UseKind use_kind_;
 
   Object& constant_value_;
 
   DISALLOW_COPY_AND_ASSIGN(Definition);
 };
 
 
+// Change a value's definition after use lists have been computed.
+inline void Value::BindTo(Definition* def) {
+  RemoveFromUseList();
+  set_definition(def);
+  def->AddInputUse(this);
+}
+
+
 class PhiInstr : public Definition {
  public:
   PhiInstr(JoinEntryInstr* block, intptr_t num_inputs)
     : block_(block),
       inputs_(num_inputs),
       is_alive_(false),
       representation_(kTagged),
       reaching_defs_(NULL) {
     for (intptr_t i = 0; i < num_inputs; ++i) {
       inputs_.Add(NULL);
@@ skipping 3077 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_