Remove the is_used_ field from BindInstr.

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"
 #include "vm/handles_impl.h"
 #include "vm/locations.h"
 #include "vm/object.h"
 
 namespace dart {
 
 class BindInstr;
 class BitVector;
 class BlockEntryInstr;
 class BufferFormatter;
 class ComparisonComp;
 class Computation;
+class ControlInstruction;
 class Definition;
 class Environment;
 class FlowGraphCompiler;
 class FlowGraphVisitor;
 class Instruction;
 class LocalVariable;
 
 
 // TODO(srdjan): Add _ByteArrayBase, get:length.
 
@@ skipping 162 matching lines @@
 
 
 #define FORWARD_DECLARATION(type) class type##Instr;
 FOR_EACH_INSTRUCTION(FORWARD_DECLARATION)
 #undef FORWARD_DECLARATION
 
 
 // Functions required in all concrete instruction classes.
 #define DECLARE_INSTRUCTION(type)                                              \
   virtual void Accept(FlowGraphVisitor* visitor);                              \
-  virtual bool Is##type() const { return true; }                               \
   virtual type##Instr* As##type() { return this; }                             \
   virtual const char* DebugName() const { return #type; }                      \
   virtual void PrintTo(BufferFormatter* f) const;                              \
   virtual void PrintToVisualizer(BufferFormatter* f) const;
 
 
 class Instruction : public ZoneAllocated {
  public:
   Instruction()
       : lifetime_position_(-1), previous_(NULL), next_(NULL), env_(NULL) { }
 
-  virtual bool IsBlockEntry() const { return false; }
-  BlockEntryInstr* AsBlockEntry() {
-    return IsBlockEntry() ? reinterpret_cast<BlockEntryInstr*>(this) : NULL;
-  }
-  virtual bool IsDefinition() const { return false; }
+  bool IsBlockEntry() { return (AsBlockEntry() != NULL); }
+  virtual BlockEntryInstr* AsBlockEntry() { return NULL; }
+
+  bool IsDefinition() { return (AsDefinition() != NULL); }
   virtual Definition* AsDefinition() { return NULL; }
-  virtual bool IsControl() const { return false; }
+
+  bool IsControl() { return (AsControl() != NULL); }
+  virtual ControlInstruction* AsControl() { return NULL; }
 
   virtual intptr_t InputCount() const = 0;
   virtual Value* InputAt(intptr_t i) const = 0;
   virtual void SetInputAt(intptr_t i, Value* value) = 0;
 
   // Call instructions override this function and return the
   // number of pushed arguments.
   virtual intptr_t ArgumentCount() const = 0;
 
   // Returns true, if this instruction can deoptimize.
@@ skipping 61 matching lines @@
   // Mutate assigned_vars to add the local variable index for all
   // frame-allocated locals assigned to by the instruction.
   virtual void RecordAssignedVars(BitVector* assigned_vars,
                                   intptr_t fixed_parameter_count);
 
   // Printing support.
   virtual void PrintTo(BufferFormatter* f) const = 0;
   virtual void PrintToVisualizer(BufferFormatter* f) const = 0;
 
 #define INSTRUCTION_TYPE_CHECK(type)                                           \
-  virtual bool Is##type() const { return false; }                              \
+  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
   // to emit native code for this instruction.
   virtual LocationSummary* locs() {
     // TODO(vegorov): This should be pure virtual method.
     // However we are temporary using NULL for instructions that
     // were not converted to the location based code generation yet.
@@ skipping 28 matching lines @@
 
   // Returns deoptimization id that corresponds to the deoptimization target
   // that input operands conversions inserted for this instruction can jump
   // to.
   virtual intptr_t DeoptimizationTarget() const {
     UNREACHABLE();
     return Isolate::kNoDeoptId;
   }
 
  private:
-  friend class BindInstr;  // Needed for BindInstr::InsertBefore.
+  friend class Definition;  // Needed for InsertBefore, InsertAfter.
 
   intptr_t lifetime_position_;  // Position used by register allocator.
   Instruction* previous_;
   Instruction* next_;
   Environment* env_;
   DISALLOW_COPY_AND_ASSIGN(Instruction);
 };
 
 
 template<intptr_t N>
@@ skipping 117 matching lines @@
 };
 
 
 // Basic block entries are administrative nodes.  There is a distinguished
 // graph entry with no predecessor.  Joins are the only nodes with multiple
 // predecessors.  Targets are all other basic block entries.  The types
 // enforce edge-split form---joins are forbidden as the successors of
 // branches.
 class BlockEntryInstr : public Instruction {
  public:
-  virtual bool IsBlockEntry() const { return true; }
+  virtual BlockEntryInstr* AsBlockEntry() { return this; }
 
   virtual intptr_t PredecessorCount() const = 0;
   virtual BlockEntryInstr* PredecessorAt(intptr_t index) const = 0;
   virtual void AddPredecessor(BlockEntryInstr* predecessor) = 0;
   virtual void PrepareEntry(FlowGraphCompiler* compiler) = 0;
 
   intptr_t preorder_number() const { return preorder_number_; }
   void set_preorder_number(intptr_t number) { preorder_number_ = number; }
 
   intptr_t postorder_number() const { return postorder_number_; }
@@ skipping 276 matching lines @@
   BlockEntryInstr* predecessor_;
   const intptr_t catch_try_index_;
 
   DISALLOW_COPY_AND_ASSIGN(TargetEntryInstr);
 };
 
 
 // Abstract super-class of all instructions that define a value (Bind, Phi).
 class Definition : public Instruction {
  public:
+  enum UseKind { kEffect, kValue };
+
   Definition()
       : temp_index_(-1),
         ssa_temp_index_(-1),
         propagated_type_(AbstractType::Handle()),
         propagated_cid_(kIllegalCid),
         input_use_list_(NULL),
-        env_use_list_(NULL) { }
+        env_use_list_(NULL),
+        use_kind_(kValue) {  // Phis and parameters rely on this default.
+  }
 
-  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; }
 
   intptr_t ssa_temp_index() const { return ssa_temp_index_; }
   void set_ssa_temp_index(intptr_t index) {
     ASSERT(index >= 0);
+    ASSERT(is_used());
     ssa_temp_index_ = index;
   }
   bool HasSSATemp() const { return ssa_temp_index_ >= 0; }
 
+  bool is_used() const { return (use_kind_ != kEffect); }
+  void set_use_kind(UseKind kind) { use_kind_ = kind; }
+
   // Compile time type of the definition, which may be requested before type
   // propagation during graph building.
   virtual RawAbstractType* CompileType() const = 0;
 
   bool HasPropagatedType() const {
     return !propagated_type_.IsNull();
   }
   RawAbstractType* PropagatedType() const {
     ASSERT(HasPropagatedType());
     return propagated_type_.raw();
@@ skipping 22 matching lines @@
   void set_input_use_list(Value* head) { input_use_list_ = head; }
 
   Value* env_use_list() { return env_use_list_; }
   void set_env_use_list(Value* head) { env_use_list_ = head; }
 
   // Replace uses of this definition with uses of other definition or value.
   // Precondition: use lists must be properly calculated.
   // Postcondition: use lists and use values are still valid.
   void ReplaceUsesWith(Definition* other);
 
+  // Insert this definition before 'next'.
+  void InsertBefore(Instruction* next);
+
+  // Insert this definition after 'prev'.
+  void InsertAfter(Instruction* prev);
+
  private:
   intptr_t temp_index_;
   intptr_t ssa_temp_index_;
   // TODO(regis): GrowableArray<const AbstractType*> propagated_types_;
   // For now:
   AbstractType& propagated_type_;
   intptr_t propagated_cid_;
   Value* input_use_list_;
   Value* env_use_list_;
+  UseKind use_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Definition);
 };
 
 
 class BindInstr : public Definition {
  public:
-  enum UseKind { kUnused, kUsed };
-
   BindInstr(UseKind used, Computation* computation)
-      : computation_(computation), is_used_(used != kUnused) {
+      : computation_(computation) {
     ASSERT(computation != NULL);
+    set_use_kind(used);
   }
 
   DECLARE_INSTRUCTION(Bind)
 
+  // Overridden functions from class Instruction.
   virtual intptr_t ArgumentCount() const;
   intptr_t InputCount() const;
   Value* InputAt(intptr_t i) const;
   void SetInputAt(intptr_t i, Value* value);
   virtual bool CanDeoptimize() const;
-
-  Computation* computation() const { return computation_; }
-  void set_computation(Computation* value) { computation_ = value; }
-  bool is_used() const { return is_used_; }
-
-  virtual RawAbstractType* CompileType() const;
-  virtual intptr_t GetPropagatedCid();
-
   virtual void RecordAssignedVars(BitVector* assigned_vars,
                                   intptr_t fixed_parameter_count);
-
-  intptr_t Hashcode() const;
-  bool Equals(BindInstr* other) const;
   virtual LocationSummary* locs();
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
-
-  // Insert this instruction before 'next'.
-  void InsertBefore(Instruction* next);
-
-  // Insert this instruction after 'prev'.
-  void InsertAfter(Instruction* prev);
-
   virtual Representation RequiredInputRepresentation(intptr_t i) const;
   virtual Representation representation() const;
   virtual intptr_t DeoptimizationTarget() const;
 
+  Computation* computation() const { return computation_; }
+  void set_computation(Computation* value) { computation_ = value; }
+
+  // Overridden functions from class Definition.
+  virtual RawAbstractType* CompileType() const;
+  virtual intptr_t GetPropagatedCid();
+
+  // Other functions that forward to the computation.
+  intptr_t Hashcode() const;
+  bool Equals(BindInstr* other) const;
+
  private:
   Computation* computation_;
-  const bool is_used_;
 
   DISALLOW_COPY_AND_ASSIGN(BindInstr);
 };
 
 
 class PhiInstr : public Definition {
  public:
   explicit PhiInstr(JoinEntryInstr* block, intptr_t num_inputs)
     : block_(block),
       inputs_(num_inputs),
@@ skipping 246 matching lines @@
   // Parallel move that will be used by linear scan register allocator to
   // connect live ranges at the end of the block and resolve phis.
   ParallelMoveInstr* parallel_move_;
 };
 
 
 class ControlInstruction : public Instruction {
  public:
   ControlInstruction() : true_successor_(NULL), false_successor_(NULL) { }
 
-  virtual bool IsControl() const { return true; }
+  virtual ControlInstruction* AsControl() { return this; }
 
   TargetEntryInstr* true_successor() const { return true_successor_; }
   TargetEntryInstr* false_successor() const { return false_successor_; }
 
   TargetEntryInstr** true_successor_address() { return &true_successor_; }
   TargetEntryInstr** false_successor_address() { return &false_successor_; }
 
   virtual intptr_t SuccessorCount() const;
   virtual BlockEntryInstr* SuccessorAt(intptr_t index) const;
 
@@ skipping 2223 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_