Remove the instruction pointer from computations.

runtime/vm/intermediate_language.h

 // 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.
 
 #ifndef VM_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 100 matching lines @@
 class BindInstr;
 class BranchInstr;
 class BufferFormatter;
 class Instruction;
 class Value;
 
 class Computation : public ZoneAllocated {
  public:
   static const int kNoCid = -1;
 
-  Computation() : cid_(-1), ic_data_(NULL), instr_(NULL), locs_(NULL) {
+  Computation() : cid_(-1), ic_data_(NULL), locs_(NULL) {
     Isolate* isolate = Isolate::Current();
     cid_ = GetNextCid(isolate);
     ic_data_ = GetICDataForCid(cid_, isolate);
   }
 
   // Unique computation/instruction id, used for deoptimization.
   intptr_t cid() const { return cid_; }
 
   ICData* ic_data() const { return ic_data_; }
   void set_ic_data(ICData* value) { ic_data_ = value; }
   bool HasICData() const {
     return (ic_data() != NULL) && !ic_data()->IsNull();
   }
 
   // Visiting support.
-  virtual void Accept(FlowGraphVisitor* visitor) = 0;
+  virtual void Accept(FlowGraphVisitor* visitor, BindInstr* instr) = 0;
 
   virtual intptr_t InputCount() const = 0;
   virtual Value* InputAt(intptr_t i) const = 0;
   virtual void SetInputAt(intptr_t i, Value* value) = 0;
 
   // Static type of the computation.
   virtual RawAbstractType* StaticType() const = 0;
 
   // Mutate assigned_vars to add the local variable index for all
   // frame-allocated locals assigned to by the computation.
   virtual void RecordAssignedVars(BitVector* assigned_vars);
 
   virtual const char* DebugName() const = 0;
 
   // Printing support. These functions are sometimes overridden for custom
   // formatting. Otherwise, it prints in the format "opcode(op1, op2, op3)".
   virtual void PrintTo(BufferFormatter* f) const;
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   // Returns structure describing location constraints required
   // to emit native code for this computation.
   LocationSummary* locs() {
     if (locs_ == NULL) {
       locs_ = MakeLocationSummary();
     }
     return locs_;
   }
 
-  void set_instr(BindInstr* instr) { instr_ = instr; }
-  BindInstr* instr() const { return instr_; }
-
   // Create a location summary for this computation.
   // TODO(fschneider): Temporarily returns NULL for instructions
   // that are not yet converted to the location based code generation.
   virtual LocationSummary* MakeLocationSummary() const = 0;
 
   // TODO(fschneider): Make EmitNativeCode and locs const.
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) = 0;
 
   static LocationSummary* MakeCallSummary();
 
-  void ReplaceWith(Computation* other);
-
   // Declare an enum value used to define type-test predicates.
   enum ComputationType {
 #define DECLARE_COMPUTATION_TYPE(ShortName, ClassName) k##ShortName,
 
   FOR_EACH_COMPUTATION(DECLARE_COMPUTATION_TYPE)
 
 #undef DECLARE_COMPUTATION_TYPE
   };
 
   virtual ComputationType computation_type() const = 0;
@@ skipping 22 matching lines @@
         return NULL;
       }
       ICData& ic_data_handle = ICData::ZoneHandle();
       ic_data_handle ^= array_handle.At(cid);
       return &ic_data_handle;
     }
   }
 
   intptr_t cid_;
   ICData* ic_data_;
-  BindInstr* instr_;
   LocationSummary* locs_;
 
   DISALLOW_COPY_AND_ASSIGN(Computation);
 };
 
 
 // An embedded container with N elements of type T.  Used (with partial
 // specialization for N=0) because embedded arrays cannot have size 0.
 template<typename T, intptr_t N>
 class EmbeddedArray {
@@ skipping 60 matching lines @@
  public:
   Value() { }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Value);
 };
 
 
 // Functions defined in all concrete computation classes.
 #define DECLARE_COMPUTATION(ShortName)                                         \
-  virtual void Accept(FlowGraphVisitor* visitor);                              \
+  virtual void Accept(FlowGraphVisitor* visitor, BindInstr* instr);            \
   virtual ComputationType computation_type() const {                           \
     return Computation::k##ShortName;                                          \
   }                                                                            \
   virtual const char* DebugName() const { return #ShortName; }                 \
   virtual RawAbstractType* StaticType() const;                                 \
   virtual LocationSummary* MakeLocationSummary() const;                        \
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
 // Functions defined in all concrete value classes.
 #define DECLARE_VALUE(ShortName)                                               \
@@ skipping 1781 matching lines @@
 }
 
 
 class BindInstr : public Definition {
  public:
   enum UseKind { kUnused, kUsed };
 
   BindInstr(UseKind used, Computation* computation)
       : computation_(computation), is_used_(used != kUnused) {
     ASSERT(computation != NULL);
-    computation->set_instr(this);
   }
 
   DECLARE_INSTRUCTION(Bind)
 
   Computation* computation() const { return computation_; }
-  void replace_computation(Computation* value) { computation_ = value; }
+  void set_computation(Computation* value) { computation_ = value; }
   bool is_used() const { return is_used_; }
 
   // Static type of the underlying computation.
   virtual RawAbstractType* StaticType() const {
     return computation()->StaticType();
   }
 
   virtual void RecordAssignedVars(BitVector* assigned_vars);
 
   virtual LocationSummary* locs() {
@@ skipping 251 matching lines @@
       : block_order_(block_order) { }
   virtual ~FlowGraphVisitor() { }
 
   // Visit each block in the block order, and for each block its
   // instructions in order from the block entry to exit.
   virtual void VisitBlocks();
 
   // Visit functions for instruction and computation classes, with empty
   // default implementations.
 #define DECLARE_VISIT_COMPUTATION(ShortName, ClassName)                        \
-  virtual void Visit##ShortName(ClassName* comp) { }
+  virtual void Visit##ShortName(ClassName* comp, BindInstr* instr) { }
 
 #define DECLARE_VISIT_INSTRUCTION(ShortName)                                   \
   virtual void Visit##ShortName(ShortName##Instr* instr) { }
 
   FOR_EACH_COMPUTATION(DECLARE_VISIT_COMPUTATION)
   FOR_EACH_INSTRUCTION(DECLARE_VISIT_INSTRUCTION)
 
 #undef DECLARE_VISIT_COMPUTATION
 #undef DECLARE_VISIT_INSTRUCTION
 
  protected:
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_