Simple redundant load elimination.

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 260 matching lines @@
   enum Tag {
     FOR_EACH_INSTRUCTION(DECLARE_TAG)
   };
 #undef DECLARE_TAG
 
   Instruction()
       : deopt_id_(Isolate::Current()->GetNextDeoptId()),
         lifetime_position_(-1),
         previous_(NULL),
         next_(NULL),
-        env_(NULL) { }
+        env_(NULL),
+        expr_id_(-1) { }
 
   virtual Tag tag() const = 0;
 
   intptr_t deopt_id() const {
     ASSERT(CanDeoptimize());
     return deopt_id_;
   }
 
   bool IsBlockEntry() { return (AsBlockEntry() != NULL); }
   virtual BlockEntryInstr* AsBlockEntry() { return NULL; }
@@ skipping 12 matching lines @@
   // pushed arguments.
   virtual intptr_t ArgumentCount() const = 0;
   virtual PushArgumentInstr* ArgumentAt(intptr_t index) const {
     UNREACHABLE();
     return NULL;
   };
 
   // Returns true, if this instruction can deoptimize.
   virtual bool CanDeoptimize() const = 0;
 
+  // Returns true if the instruction may have side effects.
+  virtual bool HasSideEffect() const  = 0;
+
   // Visiting support.
   virtual void Accept(FlowGraphVisitor* visitor) = 0;
 
   Instruction* previous() const { return previous_; }
   void set_previous(Instruction* instr) {
     ASSERT(!IsBlockEntry());
     previous_ = instr;
   }
 
   Instruction* next() const { return next_; }
@@ skipping 103 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;
   }
 
+  // Id for instructions used in CSE.
+  intptr_t expr_id() const { return expr_id_; }
+  void set_expr_id(intptr_t expr_id) { expr_id_ = expr_id; }
+
  protected:
   // Fetch deopt id without checking if this computation can deoptimize.
   intptr_t GetDeoptId() const {
     return deopt_id_;
   }
 
  private:
   friend class Definition;  // Needed for InsertBefore, InsertAfter.
 
   // Classes that set deopt_id_.
   friend class UnboxDoubleInstr;
   friend class UnboxedDoubleBinaryOpInstr;
   friend class MathSqrtInstr;
   friend class CheckClassInstr;
   friend class CheckSmiInstr;
   friend class CheckArrayBoundInstr;
   friend class CheckEitherNonSmiInstr;
   friend class LICM;
 
   intptr_t deopt_id_;
   intptr_t lifetime_position_;  // Position used by register allocator.
   Instruction* previous_;
   Instruction* next_;
   Environment* env_;
+  intptr_t expr_id_;
+
   DISALLOW_COPY_AND_ASSIGN(Instruction);
 };
 
 
 template<intptr_t N>
 class TemplateInstruction: public Instruction {
  public:
   TemplateInstruction<N>() : locs_(NULL) { }
 
   virtual intptr_t InputCount() const { return N; }
@@ skipping 79 matching lines @@
 class ParallelMoveInstr : public TemplateInstruction<0> {
  public:
   ParallelMoveInstr() : moves_(4) { }
 
   DECLARE_INSTRUCTION(ParallelMove)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return false; }
 
+  virtual bool HasSideEffect() const { return false; }
+
   MoveOperands* AddMove(Location dest, Location src) {
     MoveOperands* move = new MoveOperands(dest, src);
     moves_.Add(move);
     return move;
   }
 
   MoveOperands* MoveOperandsAt(intptr_t index) const { return moves_[index]; }
 
   void SetSrcSlotAt(intptr_t index, const Location& loc);
   void SetDestSlotAt(intptr_t index, const Location& loc);
@@ skipping 82 matching lines @@
   virtual Value* InputAt(intptr_t i) const {
     UNREACHABLE();
     return NULL;
   }
   virtual void SetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return false; }
 
+  virtual bool HasSideEffect() const { return false; }
+
   intptr_t try_index() const { return try_index_; }
 
   BitVector* loop_info() const { return loop_info_; }
   void set_loop_info(BitVector* loop_info) {
     loop_info_ = loop_info;
   }
 
  protected:
   explicit BlockEntryInstr(intptr_t try_index)
       : try_index_(try_index),
@@ skipping 407 matching lines @@
   virtual intptr_t ArgumentCount() const { return 0; }
 
   intptr_t InputCount() const { return inputs_.length(); }
 
   Value* InputAt(intptr_t i) const { return inputs_[i]; }
 
   void SetInputAt(intptr_t i, Value* value) { inputs_[i] = value; }
 
   virtual bool CanDeoptimize() const { return false; }
 
+  virtual bool HasSideEffect() const { return false; }
+
   // TODO(regis): This helper will be removed once we support type sets.
   RawAbstractType* LeastSpecificInputType() const;
 
   // Phi is alive if it reaches a non-environment use.
   bool is_alive() const { return is_alive_; }
   void mark_alive() { is_alive_ = true; }
 
   virtual Representation RequiredInputRepresentation(intptr_t i) const {
     return representation_;
   }
@@ skipping 53 matching lines @@
 
   intptr_t InputCount() const { return 0; }
   Value* InputAt(intptr_t i) const {
     UNREACHABLE();
     return NULL;
   }
   void SetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
 
   virtual bool CanDeoptimize() const { return false; }
 
+  virtual bool HasSideEffect() const { return false; }
+
   virtual intptr_t Hashcode() const {
     UNREACHABLE();
     return 0;
   }
 
   virtual intptr_t ResultCid() const {
     UNREACHABLE();
     return kIllegalCid;
   }
 
@@ skipping 45 matching lines @@
     return locs_;
   }
 
   virtual intptr_t Hashcode() const {
     UNREACHABLE();
     return 0;
   }
 
   virtual bool CanDeoptimize() const { return false; }
 
+  virtual bool HasSideEffect() const { return false; }
+
   virtual void PrintOperandsTo(BufferFormatter* f) const;
   virtual void PrintToVisualizer(BufferFormatter* f) const;
 
  private:
   Value* value_;
   LocationSummary* locs_;
 
   DISALLOW_COPY_AND_ASSIGN(PushArgumentInstr);
 };
 
 
 class ReturnInstr : public TemplateInstruction<1> {
  public:
   ReturnInstr(intptr_t token_pos, Value* value)
       : token_pos_(token_pos) {
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   DECLARE_INSTRUCTION(Return)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   intptr_t token_pos() const { return token_pos_; }
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
+  virtual bool HasSideEffect() const { return false; }
+
   virtual void PrintTo(BufferFormatter* f) const;
   virtual void PrintToVisualizer(BufferFormatter* f) const;
 
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(ReturnInstr);
 };
 
 
 class ThrowInstr : public TemplateInstruction<0> {
  public:
   explicit ThrowInstr(intptr_t token_pos) : token_pos_(token_pos) { }
 
   DECLARE_INSTRUCTION(Throw)
 
   virtual intptr_t ArgumentCount() const { return 1; }
 
   intptr_t token_pos() const { return token_pos_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
+  virtual bool HasSideEffect() const { return true; }
+
   virtual void PrintTo(BufferFormatter* f) const;
   virtual void PrintToVisualizer(BufferFormatter* f) const;
 
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(ThrowInstr);
 };
 
 
 class ReThrowInstr : public TemplateInstruction<0> {
  public:
   explicit ReThrowInstr(intptr_t token_pos) : token_pos_(token_pos) { }
 
   DECLARE_INSTRUCTION(ReThrow)
 
   virtual intptr_t ArgumentCount() const { return 2; }
 
   intptr_t token_pos() const { return token_pos_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
+  virtual bool HasSideEffect() const { return true; }
+
   virtual void PrintTo(BufferFormatter* f) const;
   virtual void PrintToVisualizer(BufferFormatter* f) const;
 
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(ReThrowInstr);
 };
 
 
 class GotoInstr : public TemplateInstruction<0> {
  public:
   explicit GotoInstr(JoinEntryInstr* entry)
     : successor_(entry),
       parallel_move_(NULL) { }
 
   DECLARE_INSTRUCTION(Goto)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   JoinEntryInstr* successor() const { return successor_; }
   void set_successor(JoinEntryInstr* successor) { successor_ = successor; }
   virtual intptr_t SuccessorCount() const;
   virtual BlockEntryInstr* SuccessorAt(intptr_t index) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
+  virtual bool HasSideEffect() const { return false; }
+
   ParallelMoveInstr* parallel_move() const {
     return parallel_move_;
   }
 
   bool HasParallelMove() const {
     return parallel_move_ != NULL;
   }
 
   ParallelMoveInstr* GetParallelMove() {
     if (parallel_move_ == NULL) {
@@ skipping 58 matching lines @@
       : comparison_(comparison) { }
 
   DECLARE_INSTRUCTION(Branch)
 
   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;
 
+  virtual bool HasSideEffect() const;
+
   ComparisonInstr* comparison() const { return comparison_; }
   void set_comparison(ComparisonInstr* value) { comparison_ = value; }
 
   virtual LocationSummary* locs();
   virtual intptr_t DeoptimizationTarget() const;
   virtual Representation RequiredInputRepresentation(intptr_t i) const;
 
   // Replace the comparison with another, leaving the branch intact.
   void ReplaceWith(ComparisonInstr* other,
                    ForwardInstructionIterator* ignored) {
@@ skipping 47 matching lines @@
 
   DECLARE_INSTRUCTION(Constant)
   virtual RawAbstractType* CompileType() const;
 
   const Object& value() const { return value_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
+  virtual bool HasSideEffect() const { return false; }
+
   virtual intptr_t ResultCid() const;
 
   virtual bool AttributesEqual(Definition* other) const;
 
  private:
   const Object& value_;
 
   DISALLOW_COPY_AND_ASSIGN(ConstantInstr);
 };
 
@@ skipping 35 matching lines @@
     return is_eliminated_;
   }
   void eliminate() {
     ASSERT(!is_eliminated_);
     is_eliminated_ = true;
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return false; }
+
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
  private:
   const intptr_t token_pos_;
   const AbstractType& dst_type_;
   const String& dst_name_;
   bool is_eliminated_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertAssignableInstr);
 };
@@ skipping 18 matching lines @@
     return is_eliminated_;
   }
   void eliminate() {
     ASSERT(!is_eliminated_);
     is_eliminated_ = true;
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return false; }
+
   virtual intptr_t ResultCid() const { return kBoolCid; }
 
  private:
   const intptr_t token_pos_;
   bool is_eliminated_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertBooleanInstr);
 };
 
 
@@ skipping 14 matching lines @@
     return ast_node_.formal_parameter_index();
   }
   const String& formal_parameter_name() const {
     return ast_node_.formal_parameter_name();
   }
   Value* saved_arguments_descriptor() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return true; }
+
   virtual intptr_t ResultCid() const { return kBoolCid; }
 
  private:
   const ArgumentDefinitionTestNode& ast_node_;
 
   DISALLOW_COPY_AND_ASSIGN(ArgumentDefinitionTestInstr);
 };
 
 
 // Denotes the current context, normally held in a register.  This is
 // a computation, not a value, because it's mutable.
 class CurrentContextInstr : public TemplateDefinition<0> {
  public:
   CurrentContextInstr() { }
 
   DECLARE_INSTRUCTION(CurrentContext)
   virtual RawAbstractType* CompileType() const;
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return false; }
+
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CurrentContextInstr);
 };
 
 
 class StoreContextInstr : public TemplateDefinition<1> {
  public:
   explicit StoreContextInstr(Value* value) {
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   DECLARE_INSTRUCTION(StoreContext);
   virtual RawAbstractType* CompileType() const;
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return false; }
+
   virtual intptr_t ResultCid() const { return kIllegalCid; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(StoreContextInstr);
 };
 
 
 class ClosureCallInstr : public TemplateDefinition<0> {
  public:
   ClosureCallInstr(ClosureCallNode* node,
                    ZoneGrowableArray<PushArgumentInstr*>* arguments)
       : ast_node_(*node),
         arguments_(arguments) { }
 
   DECLARE_INSTRUCTION(ClosureCall)
   virtual RawAbstractType* CompileType() const;
 
   const Array& argument_names() const { return ast_node_.arguments()->names(); }
   intptr_t token_pos() const { return ast_node_.token_pos(); }
 
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   PushArgumentInstr* ArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
+
+  virtual bool HasSideEffect() const { return true; }
+
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
  private:
   const ClosureCallNode& ast_node_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(ClosureCallInstr);
 };
 
 
@@ skipping 37 matching lines @@
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   PushArgumentInstr* ArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
   const Array& argument_names() const { return argument_names_; }
   intptr_t checked_argument_count() const { return checked_argument_count_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
+
+  virtual bool HasSideEffect() const { return true; }
+
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
  private:
   const ICData* ic_data_;
   const intptr_t token_pos_;
   const String& function_name_;
   const Token::Kind token_kind_;  // Binary op, unary op, kGET or kILLEGAL.
   ZoneGrowableArray<PushArgumentInstr*>* const arguments_;
   const Array& argument_names_;
   const intptr_t checked_argument_count_;
@@ skipping 22 matching lines @@
   PushArgumentInstr* ArgumentAt(intptr_t index) const {
     return instance_call()->ArgumentAt(index);
   }
 
   DECLARE_INSTRUCTION(PolymorphicInstanceCall)
   virtual RawAbstractType* CompileType() const;
 
   const ICData& ic_data() const { return ic_data_; }
 
   virtual bool CanDeoptimize() const { return true; }
+
+  virtual bool HasSideEffect() const { return true; }
+
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
   InstanceCallInstr* instance_call_;
   const ICData& ic_data_;
   const bool with_checks_;
 
   DISALLOW_COPY_AND_ASSIGN(PolymorphicInstanceCallInstr);
@@ skipping 43 matching lines @@
 inline void BranchInstr::SetInputAt(intptr_t i, Value* value) {
   comparison()->SetInputAt(i, value);
 }
 
 
 inline bool BranchInstr::CanDeoptimize() const {
   return comparison()->CanDeoptimize();
 }
 
 
+inline bool BranchInstr::HasSideEffect() const {
+  return comparison()->HasSideEffect();
+}
+
+
 inline LocationSummary* BranchInstr::locs() {
   if (comparison()->locs_ == NULL) {
     LocationSummary* summary = comparison()->MakeLocationSummary();
     // Branches don't produce a result.
     summary->set_out(Location::NoLocation());
     comparison()->locs_ = summary;
   }
   return comparison()->locs_;
 }
 
@@ skipping 16 matching lines @@
     ASSERT((kind == Token::kEQ_STRICT) || (kind == Token::kNE_STRICT));
   }
 
   DECLARE_INSTRUCTION(StrictCompare)
   virtual RawAbstractType* CompileType() const;
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
+  virtual bool HasSideEffect() const { return false; }
+
+  virtual bool AttributesEqual(Definition* other) const;
+  virtual bool AffectedBySideEffect() const { return false; }
+
   virtual Definition* Canonicalize();
 
   virtual intptr_t ResultCid() const { return kBoolCid; }
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(StrictCompareInstr);
 };
@@ skipping 25 matching lines @@
   // Receiver class id is computed from collected ICData.
   void set_receiver_class_id(intptr_t value) { receiver_class_id_ = value; }
   intptr_t receiver_class_id() const { return receiver_class_id_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const {
     return (receiver_class_id() != kDoubleCid)
         && (receiver_class_id() != kSmiCid);
   }
+  virtual bool HasSideEffect() const {
+    return (receiver_class_id() != kDoubleCid)
+        && (receiver_class_id() != kSmiCid);
+  }
 
   virtual intptr_t ResultCid() const;
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch);
 
   virtual intptr_t DeoptimizationTarget() const {
     return GetDeoptId();
   }
 
@@ skipping 41 matching lines @@
   }
 
   intptr_t operands_class_id() const { return operands_class_id_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const {
     return (operands_class_id() != kDoubleCid)
         && (operands_class_id() != kSmiCid);
   }
+  virtual bool HasSideEffect() const {
+    return (operands_class_id() != kDoubleCid)
+        && (operands_class_id() != kSmiCid);
+  }
 
   virtual intptr_t ResultCid() const;
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch);
 
 
   virtual intptr_t DeoptimizationTarget() const {
     return GetDeoptId();
   }
@@ skipping 36 matching lines @@
   intptr_t token_pos() const { return token_pos_; }
 
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   PushArgumentInstr* ArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
+
+  virtual bool HasSideEffect() const { return true; }
+
   virtual intptr_t ResultCid() const { return result_cid_; }
   void set_result_cid(intptr_t value) { result_cid_ = value; }
 
  private:
   const intptr_t token_pos_;
   const Function& function_;
   const Array& argument_names_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
   intptr_t result_cid_;  // For some library functions we know the result.
 
   DISALLOW_COPY_AND_ASSIGN(StaticCallInstr);
 };
 
 
 class LoadLocalInstr : public TemplateDefinition<0> {
  public:
   LoadLocalInstr(const LocalVariable& local, intptr_t context_level)
       : local_(local),
         context_level_(context_level) { }
 
   DECLARE_INSTRUCTION(LoadLocal)
   virtual RawAbstractType* CompileType() const;
 
   const LocalVariable& local() const { return local_; }
   intptr_t context_level() const { return context_level_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const {
+    UNREACHABLE();
+    return false;
+  }
+
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
  private:
   const LocalVariable& local_;
   const intptr_t context_level_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadLocalInstr);
 };
 
 
@@ skipping 14 matching lines @@
   const LocalVariable& local() const { return local_; }
   Value* value() const { return inputs_[0]; }
   intptr_t context_level() const { return context_level_; }
 
   virtual void RecordAssignedVars(BitVector* assigned_vars,
                                   intptr_t fixed_parameter_count);
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const {
+    UNREACHABLE();
+    return false;
+  }
+
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
  private:
   const LocalVariable& local_;
   const intptr_t context_level_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreLocalInstr);
 };
 
 
@@ skipping 21 matching lines @@
     return ast_node_.has_optional_parameters();
   }
 
   bool is_native_instance_closure() const {
     return ast_node_.is_native_instance_closure();
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return true; }
+
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
  private:
   const NativeBodyNode& ast_node_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeCallInstr);
 };
 
 
 class StoreInstanceFieldInstr : public TemplateDefinition<2> {
@@ skipping 16 matching lines @@
 
   Value* instance() const { return inputs_[0]; }
   Value* value() const { return inputs_[1]; }
   bool ShouldEmitStoreBarrier() const {
     return value()->NeedsStoreBuffer() && emit_store_barrier_;
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return true; }
+
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
  private:
   const Field& field_;
   const bool emit_store_barrier_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreInstanceFieldInstr);
 };
 
 
 class LoadStaticFieldInstr : public TemplateDefinition<0> {
  public:
   explicit LoadStaticFieldInstr(const Field& field) : field_(field) {}
 
   DECLARE_INSTRUCTION(LoadStaticField);
   virtual RawAbstractType* CompileType() const;
 
   const Field& field() const { return field_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return false; }
+
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
   virtual bool AffectedBySideEffect() const { return !field().is_final(); }
   virtual bool AttributesEqual(Definition* other) const;
 
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadStaticFieldInstr);
 };
@@ skipping 10 matching lines @@
 
   DECLARE_INSTRUCTION(StoreStaticField);
   virtual RawAbstractType* CompileType() const;
 
   const Field& field() const { return field_; }
   Value* value() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return true; }
+
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreStaticFieldInstr);
 };
 
 
 class LoadIndexedInstr : public TemplateDefinition<2> {
  public:
   LoadIndexedInstr(Value* array, Value* index) {
     ASSERT(array != NULL);
     ASSERT(index != NULL);
     inputs_[0] = array;
     inputs_[1] = index;
   }
 
   DECLARE_INSTRUCTION(LoadIndexed)
   virtual RawAbstractType* CompileType() const;
 
   Value* array() const { return inputs_[0]; }
   Value* index() const { return inputs_[1]; }
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return false; }
+
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(LoadIndexedInstr);
 };
 
 
 class StoreIndexedInstr : public TemplateDefinition<3> {
  public:
   StoreIndexedInstr(Value* array,
@@ skipping 14 matching lines @@
 
   Value* array() const { return inputs_[0]; }
   Value* index() const { return inputs_[1]; }
   Value* value() const { return inputs_[2]; }
 
   bool ShouldEmitStoreBarrier() const {
     return value()->NeedsStoreBuffer() && emit_store_barrier_;
   }
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return true; }
+
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
  private:
   const bool emit_store_barrier_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreIndexedInstr);
 };
 
 
 // Note overrideable, built-in: value? false : true.
 class BooleanNegateInstr : public TemplateDefinition<1> {
  public:
   explicit BooleanNegateInstr(Value* value) {
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   DECLARE_INSTRUCTION(BooleanNegate)
   virtual RawAbstractType* CompileType() const;
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return false; }
+
   virtual intptr_t ResultCid() const { return kBoolCid; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BooleanNegateInstr);
 };
 
 
 class InstanceOfInstr : public TemplateDefinition<3> {
  public:
   InstanceOfInstr(intptr_t token_pos,
@@ skipping 21 matching lines @@
   Value* instantiator() const { return inputs_[1]; }
   Value* instantiator_type_arguments() const { return inputs_[2]; }
 
   bool negate_result() const { return negate_result_; }
   const AbstractType& type() const { return type_; }
   intptr_t token_pos() const { return token_pos_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return true; }
+
   virtual intptr_t ResultCid() const { return kBoolCid; }
 
  private:
   const intptr_t token_pos_;
   Value* value_;
   Value* instantiator_;
   Value* type_arguments_;
   const AbstractType& type_;
   const bool negate_result_;
 
@@ skipping 17 matching lines @@
   PushArgumentInstr* ArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
   const Function& constructor() const { return ast_node_.constructor(); }
   intptr_t token_pos() const { return ast_node_.token_pos(); }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return true; }
+
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
  private:
   const ConstructorCallNode& ast_node_;
   ZoneGrowableArray<PushArgumentInstr*>* const arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateObjectInstr);
 };
 
 
@@ skipping 11 matching lines @@
 
   DECLARE_INSTRUCTION(AllocateObjectWithBoundsCheck)
   virtual RawAbstractType* CompileType() const;
 
   const Function& constructor() const { return ast_node_.constructor(); }
   intptr_t token_pos() const { return ast_node_.token_pos(); }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return true; }
+
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
  private:
   const ConstructorCallNode& ast_node_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateObjectWithBoundsCheckInstr);
 };
 
 
 class CreateArrayInstr : public TemplateDefinition<1> {
@@ skipping 23 matching lines @@
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
 
   intptr_t token_pos() const { return token_pos_; }
   PushArgumentInstr* ArgumentAt(intptr_t i) const { return (*arguments_)[i]; }
   const AbstractType& type() const { return type_; }
   Value* element_type() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return true; }
+
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
  private:
   const intptr_t token_pos_;
   ZoneGrowableArray<PushArgumentInstr*>* const arguments_;
   const AbstractType& type_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateArrayInstr);
 };
 
@@ skipping 12 matching lines @@
   const Function& function() const { return ast_node_.function(); }
 
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   PushArgumentInstr* ArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return true; }
+
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
  private:
   const ClosureNode& ast_node_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateClosureInstr);
 };
 
 
@@ skipping 16 matching lines @@
   virtual RawAbstractType* CompileType() const;
 
   Value* value() const { return inputs_[0]; }
   intptr_t offset_in_bytes() const { return offset_in_bytes_; }
   const AbstractType& type() const { return type_; }
   void set_result_cid(intptr_t value) { result_cid_ = value; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return false; }
+
   virtual intptr_t ResultCid() const { return result_cid_; }
 
   virtual bool AttributesEqual(Definition* other) const;
 
   virtual bool AffectedBySideEffect() const { return !immutable_; }
 
  private:
   const intptr_t offset_in_bytes_;
   const AbstractType& type_;
   intptr_t result_cid_;
@@ skipping 21 matching lines @@
   virtual RawAbstractType* CompileType() const;
 
   Value* value() const { return inputs_[0]; }
   Value* dest() const { return inputs_[1]; }
   intptr_t offset_in_bytes() const { return offset_in_bytes_; }
   const AbstractType& type() const { return type_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return true; }
+
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
  private:
   const intptr_t offset_in_bytes_;
   const AbstractType& type_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreVMFieldInstr);
 };
 
 
@@ skipping 14 matching lines @@
 
   Value* instantiator() const { return inputs_[0]; }
   const AbstractTypeArguments& type_arguments() const {
     return type_arguments_;
   }
   intptr_t token_pos() const { return token_pos_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return true; }
+
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
  private:
   const intptr_t token_pos_;
   const AbstractTypeArguments& type_arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(InstantiateTypeArgumentsInstr);
 };
 
 
@@ skipping 14 matching lines @@
 
   Value* instantiator() const { return inputs_[0]; }
   const AbstractTypeArguments& type_arguments() const {
     return type_arguments_;
   }
   intptr_t token_pos() const { return token_pos_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return false; }
+
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
  private:
   const intptr_t token_pos_;
   const AbstractTypeArguments& type_arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtractConstructorTypeArgumentsInstr);
 };
 
 
@@ skipping 10 matching lines @@
   virtual RawAbstractType* CompileType() const;
 
   Value* instantiator() const { return inputs_[0]; }
   const AbstractTypeArguments& type_arguments() const {
     return ast_node_.type_arguments();
   }
   const Function& constructor() const { return ast_node_.constructor(); }
   intptr_t token_pos() const { return ast_node_.token_pos(); }
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return false; }
+
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
  private:
   const ConstructorCallNode& ast_node_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtractConstructorInstantiatorInstr);
 };
 
 
 class AllocateContextInstr : public TemplateDefinition<0> {
  public:
   AllocateContextInstr(intptr_t token_pos,
                        intptr_t num_context_variables)
       : token_pos_(token_pos),
         num_context_variables_(num_context_variables) {}
 
   DECLARE_INSTRUCTION(AllocateContext);
   virtual RawAbstractType* CompileType() const;
 
   intptr_t token_pos() const { return token_pos_; }
   intptr_t num_context_variables() const { return num_context_variables_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return false; }
+
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
  private:
   const intptr_t token_pos_;
   const intptr_t num_context_variables_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateContextInstr);
 };
 
 
 class ChainContextInstr : public TemplateDefinition<1> {
  public:
   explicit ChainContextInstr(Value* context_value) {
     ASSERT(context_value != NULL);
     inputs_[0] = context_value;
   }
 
   DECLARE_INSTRUCTION(ChainContext)
   virtual RawAbstractType* CompileType() const;
 
   Value* context_value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return true; }
+
   virtual intptr_t ResultCid() const { return kIllegalCid; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChainContextInstr);
 };
 
 
 class CloneContextInstr : public TemplateDefinition<1> {
  public:
   CloneContextInstr(intptr_t token_pos, Value* context_value)
       : token_pos_(token_pos) {
     ASSERT(context_value != NULL);
     inputs_[0] = context_value;
   }
 
   intptr_t token_pos() const { return token_pos_; }
   Value* context_value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(CloneContext)
   virtual RawAbstractType* CompileType() const;
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return false; }
+
   virtual intptr_t ResultCid() const { return kIllegalCid; }
 
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(CloneContextInstr);
 };
 
 
 class CatchEntryInstr : public TemplateDefinition<0> {
  public:
   CatchEntryInstr(const LocalVariable& exception_var,
                   const LocalVariable& stacktrace_var)
       : exception_var_(exception_var), stacktrace_var_(stacktrace_var) {}
 
   const LocalVariable& exception_var() const { return exception_var_; }
   const LocalVariable& stacktrace_var() const { return stacktrace_var_; }
 
   DECLARE_INSTRUCTION(CatchEntry)
   virtual RawAbstractType* CompileType() const;
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return true; }
+
   virtual intptr_t ResultCid() const { return kIllegalCid; }
 
  private:
   const LocalVariable& exception_var_;
   const LocalVariable& stacktrace_var_;
 
   DISALLOW_COPY_AND_ASSIGN(CatchEntryInstr);
 };
 
 
 class CheckEitherNonSmiInstr : public TemplateDefinition<2> {
  public:
   CheckEitherNonSmiInstr(Value* left,
                          Value* right,
                          InstanceCallInstr* instance_call) {
     ASSERT(left != NULL);
     ASSERT(right != NULL);
     inputs_[0] = left;
     inputs_[1] = right;
     deopt_id_ = instance_call->deopt_id();
   }
 
   DECLARE_INSTRUCTION(CheckEitherNonSmi)
   virtual RawAbstractType* CompileType() const;
 
   virtual bool CanDeoptimize() const { return true; }
+
+  virtual bool HasSideEffect() const { return false; }
+
   virtual intptr_t ResultCid() const { return kIllegalCid; }
 
   virtual bool AttributesEqual(Definition* other) const { return true; }
 
   virtual bool AffectedBySideEffect() const { return false; }
 
   Value* left() const { return inputs_[0]; }
 
   Value* right() const { return inputs_[1]; }
 
@@ skipping 10 matching lines @@
       : token_pos_((instance_call != NULL) ? instance_call->token_pos() : 0) {
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   Value* value() const { return inputs_[0]; }
 
   intptr_t token_pos() const { return token_pos_; }
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return false; }
+
   virtual bool AffectedBySideEffect() const { return false; }
   virtual bool AttributesEqual(Definition* other) const { return true; }
 
   virtual intptr_t ResultCid() const;
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
@@ skipping 14 matching lines @@
     inputs_[0] = value;
     deopt_id_ = deopt_id;
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const {
     return value()->ResultCid() != kDoubleCid;
   }
 
+  virtual bool HasSideEffect() const { return false; }
+
   // The output is not an instance but when it is boxed it becomes double.
   virtual intptr_t ResultCid() const { return kDoubleCid; }
 
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual bool AffectedBySideEffect() const { return false; }
   virtual bool AttributesEqual(Definition* other) const { return true; }
 
   DECLARE_INSTRUCTION(UnboxDouble)
   virtual RawAbstractType* CompileType() const;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxDoubleInstr);
 };
 
 
 class MathSqrtInstr : public TemplateDefinition<1> {
  public:
   MathSqrtInstr(Value* value, StaticCallInstr* instance_call) {
     ASSERT(value != NULL);
     inputs_[0] = value;
     deopt_id_ = instance_call->deopt_id();
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
+
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AttributesEqual(Definition* other) const {
     return true;
   }
 
   // The output is not an instance but when it is boxed it becomes double.
   virtual intptr_t ResultCid() const { return kDoubleCid; }
 
   virtual Representation representation() const {
@@ skipping 34 matching lines @@
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   Token::Kind op_kind() const { return op_kind_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return false; }
+
   virtual bool AffectedBySideEffect() const { return false; }
 
   virtual bool AttributesEqual(Definition* other) const {
     return op_kind() == other->AsUnboxedDoubleBinaryOp()->op_kind();
   }
 
   // The output is not an instance but when it is boxed it becomes double.
   virtual intptr_t ResultCid() const { return kDoubleCid; }
 
   virtual Representation representation() const {
@@ skipping 44 matching lines @@
 
   const ICData* ic_data() const { return instance_call()->ic_data(); }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   DECLARE_INSTRUCTION(BinarySmiOp)
   virtual RawAbstractType* CompileType() const;
 
   virtual bool CanDeoptimize() const;
 
+  virtual bool HasSideEffect() const { return false; }
+
+  virtual bool AffectedByEffect() const { return false; }
+  virtual bool AttributesEqual(Definition* other) const;
+
   virtual intptr_t ResultCid() const;
 
  private:
   const Token::Kind op_kind_;
   InstanceCallInstr* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(BinarySmiOpInstr);
 };
 
 
@@ skipping 19 matching lines @@
   InstanceCallInstr* instance_call() const { return instance_call_; }
 
   const ICData* ic_data() const { return instance_call()->ic_data(); }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   DECLARE_INSTRUCTION(BinaryMintOp)
   virtual RawAbstractType* CompileType() const;
 
   virtual bool CanDeoptimize() const { return true; }
+
+  virtual bool HasSideEffect() const { return false; }
+
   virtual intptr_t ResultCid() const;
 
  private:
   const Token::Kind op_kind_;
   InstanceCallInstr* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(BinaryMintOpInstr);
 };
 
 
@@ skipping 13 matching lines @@
   Token::Kind op_kind() const { return op_kind_; }
 
   InstanceCallInstr* instance_call() const { return instance_call_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   DECLARE_INSTRUCTION(UnarySmiOp)
   virtual RawAbstractType* CompileType() const;
 
   virtual bool CanDeoptimize() const { return op_kind() == Token::kNEGATE; }
+
+  virtual bool HasSideEffect() const { return false; }
+
   virtual intptr_t ResultCid() const { return kSmiCid; }
 
  private:
   const Token::Kind op_kind_;
   InstanceCallInstr* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(UnarySmiOpInstr);
 };
 
 
 // Handles non-Smi NEGATE operations
 class NumberNegateInstr : public TemplateDefinition<1> {
  public:
   NumberNegateInstr(InstanceCallInstr* instance_call, Value* value)
       : instance_call_(instance_call) {
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   Value* value() const { return inputs_[0]; }
 
   InstanceCallInstr* instance_call() const { return instance_call_; }
 
   const ICData* ic_data() const { return instance_call()->ic_data(); }
 
   DECLARE_INSTRUCTION(NumberNegate)
   virtual RawAbstractType* CompileType() const;
 
   virtual bool CanDeoptimize() const { return true; }
+
+  virtual bool HasSideEffect() const { return false; }
+
   virtual intptr_t ResultCid() const { return kDoubleCid; }
 
  private:
   InstanceCallInstr* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(NumberNegateInstr);
 };
 
 
 class CheckStackOverflowInstr : public TemplateDefinition<0> {
  public:
   explicit CheckStackOverflowInstr(intptr_t token_pos)
       : token_pos_(token_pos) {}
 
   intptr_t token_pos() const { return token_pos_; }
 
   DECLARE_INSTRUCTION(CheckStackOverflow)
   virtual RawAbstractType* CompileType() const;
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool HasSideEffect() const { return false; }
+
   virtual intptr_t ResultCid() const { return kIllegalCid; }
 
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckStackOverflowInstr);
 };
 
 
 class DoubleToDoubleInstr : public TemplateDefinition<1> {
  public:
   DoubleToDoubleInstr(Value* value, InstanceCallInstr* instance_call)
       : instance_call_(instance_call) {
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   Value* value() const { return inputs_[0]; }
 
   InstanceCallInstr* instance_call() const { return instance_call_; }
 
   DECLARE_INSTRUCTION(DoubleToDouble)
   virtual RawAbstractType* CompileType() const;
 
   virtual bool CanDeoptimize() const { return true; }
+
+  virtual bool HasSideEffect() const { return false; }
+
   virtual intptr_t ResultCid() const { return kDoubleCid; }
 
  private:
   InstanceCallInstr* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(DoubleToDoubleInstr);
 };
 
 
 class SmiToDoubleInstr : public TemplateDefinition<0> {
  public:
   explicit SmiToDoubleInstr(InstanceCallInstr* instance_call)
       : instance_call_(instance_call) { }
 
   InstanceCallInstr* instance_call() const { return instance_call_; }
 
   DECLARE_INSTRUCTION(SmiToDouble)
   virtual RawAbstractType* CompileType() const;
 
   virtual intptr_t ArgumentCount() const { return 1; }
 
   virtual bool CanDeoptimize() const { return true; }
+
+  virtual bool HasSideEffect() const { return false; }
+
   virtual intptr_t ResultCid() const { return kDoubleCid; }
 
  private:
   InstanceCallInstr* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(SmiToDoubleInstr);
 };
 
 
 class CheckClassInstr : public TemplateDefinition<1> {
  public:
   CheckClassInstr(Value* value,
                   InstanceCallInstr* instance_call,
                   const ICData& unary_checks)
       : unary_checks_(unary_checks) {
     ASSERT(value != NULL);
     inputs_[0] = value;
     deopt_id_ = instance_call->deopt_id();
   }
 
   DECLARE_INSTRUCTION(CheckClass)
   virtual RawAbstractType* CompileType() const;
 
   virtual bool CanDeoptimize() const { return true; }
+
+  virtual bool HasSideEffect() const { return false; }
+
   virtual intptr_t ResultCid() const { return kIllegalCid; }
 
   virtual bool AttributesEqual(Definition* other) const;
 
   virtual bool AffectedBySideEffect() const { return false; }
 
   Value* value() const { return inputs_[0]; }
 
   const ICData& unary_checks() const { return unary_checks_; }
 
@@ skipping 14 matching lines @@
     ASSERT(value != NULL);
     ASSERT(original_deopt_id != Isolate::kNoDeoptId);
     inputs_[0] = value;
     deopt_id_ = original_deopt_id;
   }
 
   DECLARE_INSTRUCTION(CheckSmi)
   virtual RawAbstractType* CompileType() const;
 
   virtual bool CanDeoptimize() const { return true; }
+
+  virtual bool HasSideEffect() const { return false; }
+
   virtual intptr_t ResultCid() const { return kIllegalCid; }
 
   virtual bool AttributesEqual(Definition* other) const { return true; }
 
   virtual bool AffectedBySideEffect() const { return false; }
 
   virtual Definition* Canonicalize();
 
   Value* value() const { return inputs_[0]; }
 
@@ skipping 13 matching lines @@
     ASSERT(index != NULL);
     inputs_[0] = array;
     inputs_[1] = index;
     deopt_id_ = instance_call->deopt_id();
   }
 
   DECLARE_INSTRUCTION(CheckArrayBound)
   virtual RawAbstractType* CompileType() const;
 
   virtual bool CanDeoptimize() const { return true; }
+
+  virtual bool HasSideEffect() const { return false; }
+
   virtual intptr_t ResultCid() const { return kIllegalCid; }
 
   virtual bool AttributesEqual(Definition* other) const;
 
   virtual bool AffectedBySideEffect() const { return false; }
 
   Value* array() const { return inputs_[0]; }
   Value* index() const { return inputs_[1]; }
 
   intptr_t array_type() const { return array_type_; }
@@ skipping 186 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_