Eliminate the type distinction between BindInstr and DoInstr.

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 90 matching lines @@
   M(NumberNegate, NumberNegateComp)                                            \
   M(CheckStackOverflow, CheckStackOverflowComp)                                \
   M(ToDouble, ToDoubleComp)                                                    \
 
 
 #define FORWARD_DECLARATION(ShortName, ClassName) class ClassName;
 FOR_EACH_COMPUTATION(FORWARD_DECLARATION)
 #undef FORWARD_DECLARATION
 
 // Forward declarations.
+class BindInstr;
+class BranchInstr;
 class BufferFormatter;
-class BranchInstr;
 class Instruction;
 class Value;
 
-
 class Computation : public ZoneAllocated {
  public:
   static const int kNoCid = -1;
 
   Computation() : cid_(-1), ic_data_(NULL), instr_(NULL), locs_(NULL) {
     Isolate* isolate = Isolate::Current();
     cid_ = GetNextCid(isolate);
     ic_data_ = GetICDataForCid(cid_, isolate);
   }
 
@@ skipping 29 matching lines @@
 
   // Returns structure describing location constraints required
   // to emit native code for this computation.
   LocationSummary* locs() {
     if (locs_ == NULL) {
       locs_ = MakeLocationSummary();
     }
     return locs_;
   }
 
-  // TODO(srdjan): Eliminate Instructions hierarchy. If 'use' is NULL
-  // it acts as a DoInstr, otherwise a BindInstr.
-  void set_instr(Instruction* value) { instr_ = value; }
-  Instruction* instr() const { return instr_; }
+  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();
@@ skipping 35 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_;
-  Instruction* instr_;
+  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 76 matching lines @@
   virtual LocationSummary* MakeLocationSummary() const;                        \
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
 // Functions defined in all concrete value classes.
 #define DECLARE_VALUE(ShortName)                                               \
   DECLARE_COMPUTATION(ShortName)                                               \
   virtual void PrintTo(BufferFormatter* f) const;
 
 
 class Definition;
-class BindInstr;
 class PhiInstr;
 
 class UseVal : public Value {
  public:
   explicit UseVal(Definition* definition) : definition_(definition) {}
 
   DECLARE_VALUE(Use)
 
   inline Definition* definition() const;
   void set_definition(Definition* definition) {
@@ skipping 1345 matching lines @@
 }                                                                              \
 ClassName* Computation::As##ShortName() {                                      \
   if (!Is##ShortName()) return NULL;                                           \
   return static_cast<ClassName*>(this);                                        \
 }
 FOR_EACH_COMPUTATION(DEFINE_PREDICATE)
 #undef DEFINE_PREDICATE
 
 
 // Instructions.
-//
-// <Instruction> ::= JoinEntry <Instruction>
-//                 | TargetEntry <Instruction>
-//                 | Do <Computation> <Instruction>
-//                 | Return <Value>
-//                 | Branch <Value> <Instruction> <Instruction>
-// <Definition>  ::= Bind <int> <Computation> <Instruction>
 
 // M is a single argument macro.  It is applied to each concrete instruction
 // type name.  The concrete instruction classes are the name with Instr
 // concatenated.
 #define FOR_EACH_INSTRUCTION(M)                                                \
   M(GraphEntry)                                                                \
   M(JoinEntry)                                                                 \
   M(TargetEntry)                                                               \
-  M(Do)                                                                        \
   M(Bind)                                                                      \
   M(Phi)                                                                       \
   M(Return)                                                                    \
   M(Throw)                                                                     \
   M(ReThrow)                                                                   \
   M(Branch)                                                                    \
   M(ParallelMove)                                                              \
   M(Parameter)
 
 
@@ skipping 75 matching lines @@
   // Remove instruction from the graph and return the instruction following the
   // removed instruction.
   Instruction* RemoveFromGraph();
 
   // 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;
 
-  virtual void replace_computation(Computation* value) {
-    UNREACHABLE();
-  }
   // Discover basic-block structure by performing a recursive depth first
   // traversal of the instruction graph reachable from this instruction.  As
   // a side effect, the block entry instructions in the graph are assigned
   // numbers in both preorder and postorder.  The array 'preorder' maps
   // preorder block numbers to the block entry instruction with that number
   // and analogously for the array 'postorder'.  The depth first spanning
   // tree is recorded in the array 'parent', which maps preorder block
   // numbers to the preorder number of the block's spanning-tree parent.
   // The array 'assigned_vars' maps preorder block numbers to the set of
   // assigned frame-allocated local variables in the block.  As a side
@@ skipping 262 matching lines @@
   virtual void PrepareEntry(FlowGraphCompiler* compiler);
 
  private:
   BlockEntryInstr* predecessor_;
   const intptr_t try_index_;
 
   DISALLOW_COPY_AND_ASSIGN(TargetEntryInstr);
 };
 
 
-class DoInstr : public Instruction {
- public:
-  explicit DoInstr(Computation* computation)
-      : computation_(computation) {
-    ASSERT(computation != NULL);
-    computation->set_instr(this);
-  }
-
-  DECLARE_INSTRUCTION(Do)
-
-  Computation* computation() const { return computation_; }
-  virtual void replace_computation(Computation* value) { computation_ = value; }
-
-  virtual void RecordAssignedVars(BitVector* assigned_vars);
-
-  virtual LocationSummary* locs() {
-    return computation()->locs();
-  }
-
-  virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
-    computation()->EmitNativeCode(compiler);
-  }
-
- private:
-  Computation* computation_;
-
-  DISALLOW_COPY_AND_ASSIGN(DoInstr);
-};
-
-
 // Abstract super-class of all instructions that define a value (Bind, Phi).
 class Definition : public Instruction {
  public:
   Definition() : temp_index_(-1), ssa_temp_index_(-1) { }
 
   virtual bool IsDefinition() const { return true; }
   virtual Definition* AsDefinition() { return this; }
 
   intptr_t temp_index() const { return temp_index_; }
   void set_temp_index(intptr_t index) { temp_index_ = index; }
@@ skipping 11 matching lines @@
 
 Definition* UseVal::definition() const {
   // Check that the definition is either a Phi or a linked in the the IR.
   ASSERT(definition_ != NULL);
   return definition_;
 }
 
 
 class BindInstr : public Definition {
  public:
-  explicit BindInstr(Computation* computation)
-      : computation_(computation) {
+  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_; }
-  virtual void replace_computation(Computation* value) { computation_ = value; }
+  void replace_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() {
     return computation()->locs();
   }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
  private:
   Computation* computation_;
+  bool is_used_;
 
   DISALLOW_COPY_AND_ASSIGN(BindInstr);
 };
 
 
 class PhiInstr: public Definition {
  public:
   explicit PhiInstr(intptr_t num_inputs) : inputs_(num_inputs) {
     for (intptr_t i = 0; i < num_inputs; ++i) {
       inputs_.Add(NULL);
@@ skipping 255 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_