Refactor load forwarding pass to use a Place abstraction.

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 622 matching lines @@
     FOR_EACH_INSTRUCTION(DECLARE_TAG)
   };
 #undef DECLARE_TAG
 
   Instruction()
       : deopt_id_(Isolate::Current()->GetNextDeoptId()),
         lifetime_position_(-1),
         previous_(NULL),
         next_(NULL),
         env_(NULL),
-        expr_id_(kNoExprId) { }
+        place_id_(kNoPlaceId) { }
 
   virtual Tag tag() const = 0;
 
   intptr_t deopt_id() const {
     ASSERT(CanDeoptimize() || CanBecomeDeoptimizationTarget());
     return deopt_id_;
   }
 
   ICData* GetICData(const Array& ic_data_array) const;
 
@@ skipping 70 matching lines @@
   // 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);
 
   virtual const char* DebugName() const = 0;
 
   // Printing support.
+  const char* ToCString() const;
   virtual void PrintTo(BufferFormatter* f) const;
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
 #define INSTRUCTION_TYPE_CHECK(type)                                           \
   bool Is##type() { return (As##type() != NULL); }                             \
   virtual type##Instr* As##type() { return NULL; }
 FOR_EACH_INSTRUCTION(INSTRUCTION_TYPE_CHECK)
 #undef INSTRUCTION_TYPE_CHECK
 
   // Returns structure describing location constraints required
@@ skipping 72 matching lines @@
 
   // Returns set of effects that affect this instruction.
   virtual EffectSet Dependencies() const {
     UNREACHABLE();
     return EffectSet::All();
   }
 
   // Get the block entry for this instruction.
   virtual BlockEntryInstr* GetBlock() const;
 
-  // Id for load instructions used during load forwarding pass and later in
-  // LICM.
-  intptr_t expr_id() const { return expr_id_; }
-  void set_expr_id(intptr_t expr_id) { expr_id_ = expr_id; }
-  bool HasExprId() const { return expr_id_ != kNoExprId; }
+  // Place identifiers used by the load optimization pass.
+  intptr_t place_id() const { return place_id_; }
+  void set_place_id(intptr_t place_id) { place_id_ = place_id; }
+  bool HasPlaceId() const { return place_id_ != kNoPlaceId; }
 
   // Returns a hash code for use with hash maps.
   virtual intptr_t Hashcode() const;
 
   // Compares two instructions.  Returns true, iff:
   // 1. They have the same tag.
   // 2. All input operands are Equals.
   // 3. They satisfy AttributesEqual.
   bool Equals(Instruction* other) const;
 
@@ skipping 79 matching lines @@
   friend class InstanceOfInstr;
   friend class PolymorphicInstanceCallInstr;
   friend class SmiToDoubleInstr;
   friend class DoubleToIntegerInstr;
   friend class BranchSimplifier;
   friend class BlockEntryInstr;
 
   virtual void RawSetInputAt(intptr_t i, Value* value) = 0;
 
   enum {
-    kNoExprId = -1
+    kNoPlaceId = -1
   };
 
   intptr_t deopt_id_;
   intptr_t lifetime_position_;  // Position used by register allocator.
   Instruction* previous_;
   Instruction* next_;
   Environment* env_;
-  intptr_t expr_id_;
+  intptr_t place_id_;
 
   DISALLOW_COPY_AND_ASSIGN(Instruction);
 };
 
 
 template<intptr_t N>
 class TemplateInstruction: public Instruction {
  public:
   TemplateInstruction<N>() : locs_(NULL) { }
 
@@ skipping 423 matching lines @@
 
   // Returns -1 if pred is not in the list.
   intptr_t IndexOfPredecessor(BlockEntryInstr* pred) const;
 
   ZoneGrowableArray<PhiInstr*>* phis() const { return phis_; }
 
   void InsertPhi(intptr_t var_index, intptr_t var_count);
   void RemoveDeadPhis(Definition* replacement);
 
   void InsertPhi(PhiInstr* phi);
+  void RemovePhi(PhiInstr* phi);
 
   virtual void PrintTo(BufferFormatter* f) const;
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
  private:
   // Classes that have access to predecessors_ when inlining.
   friend class BlockEntryInstr;
   friend class InlineExitCollector;
@@ skipping 302 matching lines @@
 
   Value* InputAt(intptr_t i) const { return inputs_[i]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   // Phi is alive if it reaches a non-environment use.
   bool is_alive() const { return is_alive_; }
   void mark_alive() { is_alive_ = true; }
+  void mark_dead() { is_alive_ = false; }
 
   virtual Representation RequiredInputRepresentation(intptr_t i) const {
     return representation_;
   }
 
   virtual Representation representation() const {
     return representation_;
   }
 
   virtual void set_representation(Representation r) {
@@ skipping 4775 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_