Track side-effect free paths in the graph to allow CSE and LICM for instructions that depend on som…

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 263 matching lines @@
 
   virtual void Update() {
     type_ = source_->CopyNonNullable();
   }
 
  private:
   CompileType* source_;
 };
 
 
+class EffectSet : public ValueObject {
+ public:
+  enum Effects {
+    kNoEffects = 0,
+    kExternalization = 1,
+    kLastEffect = kExternalization
+  };
+
+  EffectSet(const EffectSet& other)
+      : ValueObject(), effects_(other.effects_) {
+  }
+
+  bool IsNone() const { return effects_ == kNoEffects; }
+
+  static EffectSet None() { return EffectSet(kNoEffects); }
+  static EffectSet All() {
+    ASSERT(EffectSet::kLastEffect == 1);
+    return EffectSet(kExternalization);
+  }
+
+  static EffectSet Externalization() {
+    return EffectSet(kExternalization);
+  }
+
+  bool ToInt() { return effects_; }
+
+ private:
+  explicit EffectSet(intptr_t effects) : effects_(effects) { }
+
+  intptr_t effects_;
+};
+
+
 class Value : public ZoneAllocated {
  public:
   // A forward iterator that allows removing the current value from the
   // underlying use list during iteration.
   class Iterator {
    public:
     explicit Iterator(Value* head) : next_(head) { Advance(); }
     Value* Current() const { return current_; }
     bool Done() const { return current_ == NULL; }
     void Advance() {
@@ skipping 293 matching lines @@
   virtual intptr_t ArgumentCount() const = 0;
   virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     UNREACHABLE();
     return NULL;
   }
   inline Definition* ArgumentAt(intptr_t index) const;
 
   // 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 96 matching lines @@
   virtual Instruction* Canonicalize(FlowGraphOptimizer* optimizer);
 
   // Insert this instruction before 'next' after use lists are computed.
   // Instructions cannot be inserted before a block entry or any other
   // instruction without a previous instruction.
   void InsertBefore(Instruction* next) { InsertAfter(next->previous()); }
 
   // Insert this instruction after 'prev' after use lists are computed.
   void InsertAfter(Instruction* prev);
 
-  // Returns true if the instruction is affected by side effects.
-  // Only instructions that are not affected by side effects can participate
-  // in redundancy elimination or loop invariant code motion.
-  // TODO(fschneider): Make this abstract and implement for all instructions
-  // instead of returning the safe default (true).
-  virtual bool AffectedBySideEffect() const { return true; }
+  // Returns true if CSE and LICM are allowed for this instruction.
+  virtual bool AllowsCSE() const {
+    return false;
+  }
+
+  // Returns set of effects created by this instruction.
+  virtual EffectSet Effects() const = 0;
+
+  // 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 instructions used in CSE.
   intptr_t expr_id() const { return expr_id_; }
   void set_expr_id(intptr_t expr_id) { expr_id_ = expr_id; }
 
   // Returns a hash code for use with hash maps.
   virtual intptr_t Hashcode() const;
@@ skipping 169 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; }
+  virtual EffectSet Effects() const {
+    UNREACHABLE();  // This instruction never visited by optimization passes.
+    return EffectSet::None();
+  }
+
+  virtual EffectSet Dependencies() const {
+    UNREACHABLE();  // This instruction never visited by optimization passes.
+    return EffectSet::None();
+  }
 
   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);
@@ skipping 98 matching lines @@
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanBeDeoptimizationTarget() const {
     // BlockEntry environment is copied to Goto and Branch instructions
     // when we insert new blocks targeting this block.
     return true;
   }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool HasSideEffect() const { return false; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
   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;
   }
 
   virtual BlockEntryInstr* GetBlock() const {
     return const_cast<BlockEntryInstr*>(this);
@@ skipping 168 matching lines @@
 
   virtual void PrepareEntry(FlowGraphCompiler* compiler);
 
   void InsertPhi(intptr_t var_index, intptr_t var_count);
   void RemoveDeadPhis(Definition* replacement);
 
   void InsertPhi(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;
 
   // Direct access to phis_ in order to resize it due to phi elimination.
   friend class ConstantPropagator;
 
   virtual void ClearPredecessors() { predecessors_.Clear(); }
   virtual void AddPredecessor(BlockEntryInstr* predecessor);
@@ skipping 290 matching lines @@
   virtual bool RecomputeType();
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   intptr_t InputCount() const { return inputs_.length(); }
 
   Value* InputAt(intptr_t i) const { return inputs_[i]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool HasSideEffect() 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; }
 
   virtual Representation RequiredInputRepresentation(intptr_t i) const {
     return representation_;
   }
 
   virtual Representation representation() const {
@@ skipping 56 matching lines @@
   virtual intptr_t ArgumentCount() const { return 0; }
 
   intptr_t InputCount() const { return 0; }
   Value* InputAt(intptr_t i) const {
     UNREACHABLE();
     return NULL;
   }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool HasSideEffect() const { return false; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
   virtual intptr_t Hashcode() const {
     UNREACHABLE();
     return 0;
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual CompileType ComputeType() const;
 
@@ skipping 35 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 EffectSet Effects() const { return EffectSet::None(); }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     ASSERT(i == 0);
     value_ = value;
   }
 
   Value* value_;
@@ skipping 23 matching lines @@
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanBeDeoptimizationTarget() const {
     // Return instruction might turn into a Goto instruction after inlining.
     // Every Goto must have an environment.
     return true;
   }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool HasSideEffect() const { return false; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
 
  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 true; }
 
-  virtual bool HasSideEffect() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
 
  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 true; }
 
-  virtual bool HasSideEffect() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(ReThrowInstr);
 };
 
 
 class GotoInstr : public TemplateInstruction<0> {
  public:
@@ skipping 11 matching lines @@
   virtual BlockEntryInstr* SuccessorAt(intptr_t index) const;
 
   virtual bool CanBeDeoptimizationTarget() const {
     // Goto instruction can be used as a deoptimization target when LICM
     // hoists instructions out of the loop.
     return true;
   }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool HasSideEffect() const { return false; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
 
   ParallelMoveInstr* parallel_move() const {
     return parallel_move_;
   }
 
   bool HasParallelMove() const {
     return parallel_move_ != NULL;
   }
 
   ParallelMoveInstr* GetParallelMove() {
@@ skipping 47 matching lines @@
   explicit BranchInstr(ComparisonInstr* comparison, bool is_checked = false);
 
   DECLARE_INSTRUCTION(Branch)
 
   virtual intptr_t ArgumentCount() const;
   intptr_t InputCount() const;
   Value* InputAt(intptr_t i) const;
   virtual bool CanDeoptimize() const;
   virtual bool CanBeDeoptimizationTarget() const;
 
-  virtual bool HasSideEffect() const;
+  virtual EffectSet Effects() const;
 
   ComparisonInstr* comparison() const { return comparison_; }
   void SetComparison(ComparisonInstr* comp);
 
   bool is_checked() const { return is_checked_; }
 
   virtual LocationSummary* locs();
   virtual intptr_t DeoptimizationTarget() const;
   virtual Representation RequiredInputRepresentation(intptr_t i) const;
 
@@ skipping 52 matching lines @@
   }
 
   DECLARE_INSTRUCTION(StoreContext);
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool HasSideEffect() const { return false; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(StoreContextInstr);
 };
 
 
 template<intptr_t N>
 class TemplateDefinition : public Definition {
  public:
   TemplateDefinition<N>() : locs_(NULL) { }
@@ skipping 196 matching lines @@
   DECLARE_INSTRUCTION(Constraint)
 
   virtual intptr_t InputCount() const {
     return (inputs_[1] == NULL) ? 1 : 2;
   }
 
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool HasSideEffect() const { return false; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual bool AttributesEqual(Instruction* other) const {
     UNREACHABLE();
     return false;
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   Value* value() const { return inputs_[0]; }
   Range* constraint() const { return constraint_; }
@@ skipping 37 matching lines @@
   virtual CompileType ComputeType() const;
 
   virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
 
   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 void InferRange();
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const;
-  virtual bool AffectedBySideEffect() const { return false; }
-
-  virtual void InferRange();
 
  private:
   const Object& value_;
 
   DISALLOW_COPY_AND_ASSIGN(ConstantInstr);
 };
 
 
 class AssertAssignableInstr : public TemplateDefinition<3> {
  public:
@@ skipping 25 matching lines @@
   const AbstractType& dst_type() const { return dst_type_; }
   void set_dst_type(const AbstractType& dst_type) {
     dst_type_ = dst_type.raw();
   }
   const String& dst_name() const { return dst_name_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
-  virtual bool HasSideEffect() const { return false; }
+  virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
 
-  virtual bool AffectedBySideEffect() const { return false; }
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const;
 
-  virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
-
  private:
   const intptr_t token_pos_;
   AbstractType& dst_type_;
   const String& dst_name_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertAssignableInstr);
 };
 
 
 class AssertBooleanInstr : public TemplateDefinition<1> {
  public:
   AssertBooleanInstr(intptr_t token_pos, Value* value)
       : token_pos_(token_pos) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(AssertBoolean)
   virtual CompileType ComputeType() const;
 
   intptr_t token_pos() const { return token_pos_; }
   Value* value() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
-  virtual bool HasSideEffect() const { return false; }
+  virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
 
-  virtual bool AffectedBySideEffect() const { return false; }
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
-  virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
-
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertBooleanInstr);
 };
 
 
 class ArgumentDefinitionTestInstr : public TemplateDefinition<1> {
  public:
   ArgumentDefinitionTestInstr(ArgumentDefinitionTestNode* node,
@@ skipping 12 matching lines @@
   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 true; }
 
-  virtual bool HasSideEffect() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
 
  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 CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool HasSideEffect() const { return false; }
-
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CurrentContextInstr);
 };
 
 
 class ClosureCallInstr : public TemplateDefinition<0> {
  public:
   ClosureCallInstr(ClosureCallNode* node,
                    ZoneGrowableArray<PushArgumentInstr*>* arguments)
       : ast_node_(*node),
         arguments_(arguments) { }
 
   DECLARE_INSTRUCTION(ClosureCall)
 
   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(); }
   virtual PushArgumentInstr* PushArgumentAt(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 EffectSet Effects() const { return EffectSet::All(); }
 
  private:
   const ClosureCallNode& ast_node_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(ClosureCallInstr);
 };
 
 
 class InstanceCallInstr : public TemplateDefinition<0> {
@@ skipping 41 matching lines @@
   virtual PushArgumentInstr* PushArgumentAt(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 EffectSet Effects() const { return EffectSet::All(); }
 
  protected:
   friend class FlowGraphOptimizer;
   void set_ic_data(ICData* value) { ic_data_ = value; }
 
  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.
@@ skipping 25 matching lines @@
   virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     return instance_call()->PushArgumentAt(index);
   }
 
   DECLARE_INSTRUCTION(PolymorphicInstanceCall)
 
   const ICData& ic_data() const { return ic_data_; }
 
   virtual bool CanDeoptimize() const { return true; }
 
-  virtual bool HasSideEffect() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::All(); }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
   InstanceCallInstr* instance_call_;
   const ICData& ic_data_;
   const bool with_checks_;
 
   DISALLOW_COPY_AND_ASSIGN(PolymorphicInstanceCallInstr);
 };
@@ skipping 47 matching lines @@
   // can throw a type check error.
   return comparison()->CanDeoptimize() || is_checked();
 }
 
 
 inline bool BranchInstr::CanBeDeoptimizationTarget() const {
   return comparison()->CanBeDeoptimizationTarget();
 }
 
 
-inline bool BranchInstr::HasSideEffect() const {
-  return comparison()->HasSideEffect();
+inline EffectSet BranchInstr::Effects() const {
+  return comparison()->Effects();
 }
 
 
 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;
   }
@@ skipping 21 matching lines @@
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanBeDeoptimizationTarget() const {
     // StrictCompare can be merged into Branch and thus needs an environment.
     return true;
   }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool HasSideEffect() const { return false; }
-
-  virtual bool AttributesEqual(Instruction* other) const;
-  virtual bool AffectedBySideEffect() const { return false; }
-
   virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch);
 
   bool needs_number_check() const { return needs_number_check_; }
   void set_needs_number_check(bool value) { needs_number_check_ = value; }
   void set_kind(Token::Kind value) { kind_ = value; }
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const;
+
  private:
   // True if the comparison must check for double, Mint or Bigint and
   // use value comparison instead.
   bool needs_number_check_;
 
   DISALLOW_COPY_AND_ASSIGN(StrictCompareInstr);
 };
 
 
 class EqualityCompareInstr : public ComparisonInstr {
@@ skipping 31 matching lines @@
         || (receiver_class_id() == kMintCid)
         || (receiver_class_id() == kSmiCid);
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const {
     return !IsInlinedNumericComparison();
   }
 
-  virtual bool HasSideEffect() const {
-    return !IsInlinedNumericComparison();
-  }
-
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch);
 
   virtual intptr_t DeoptimizationTarget() const {
     return GetDeoptId();
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     if (receiver_class_id() == kDoubleCid) return kUnboxedDouble;
     if (receiver_class_id() == kMintCid) return kUnboxedMint;
     return kTagged;
   }
 
   bool IsPolymorphic() const;
 
+  virtual EffectSet Effects() const {
+    return IsInlinedNumericComparison() ? EffectSet::None() : EffectSet::All();
+  }
+
  private:
   const ICData* ic_data_;
   const intptr_t token_pos_;
   intptr_t receiver_class_id_;  // Set by optimizer.
 
   DISALLOW_COPY_AND_ASSIGN(EqualityCompareInstr);
 };
 
 
 class RelationalOpInstr : public ComparisonInstr {
@@ skipping 34 matching lines @@
     return (operands_class_id() == kDoubleCid)
         || (operands_class_id() == kMintCid)
         || (operands_class_id() == kSmiCid);
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const {
     return !IsInlinedNumericComparison();
   }
-  virtual bool HasSideEffect() const {
-    return !IsInlinedNumericComparison();
-  }
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch);
 
 
   virtual intptr_t DeoptimizationTarget() const {
     return GetDeoptId();
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     if (operands_class_id() == kDoubleCid) return kUnboxedDouble;
     if (operands_class_id() == kMintCid) return kUnboxedMint;
     return kTagged;
   }
 
+  virtual EffectSet Effects() const {
+    return IsInlinedNumericComparison() ? EffectSet::None() : EffectSet::All();
+  }
+
  private:
   const ICData* ic_data_;
   const intptr_t token_pos_;
   intptr_t operands_class_id_;  // class id of both operands.
 
   DISALLOW_COPY_AND_ASSIGN(RelationalOpInstr);
 };
 
 
 // TODO(vegorov): ComparisonInstr should be switched to use IfTheElseInstr for
@@ skipping 22 matching lines @@
 
   DECLARE_INSTRUCTION(IfThenElse)
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual CompileType ComputeType() const;
 
   virtual void InferRange();
 
   virtual bool CanDeoptimize() const { return false; }
-  virtual bool HasSideEffect() const { return false; }
-
-  virtual bool AttributesEqual(Instruction* other) const {
-    IfThenElseInstr* other_if_then_else = other->AsIfThenElse();
-    return (kind_ == other_if_then_else->kind_) &&
-           (if_true_ == other_if_then_else->if_true_) &&
-           (if_false_ == other_if_then_else->if_false_);
-  }
-
-  virtual bool AffectedBySideEffect() const {
-    return false;
-  }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
   intptr_t if_true() const { return if_true_; }
   intptr_t if_false() const { return if_false_; }
 
   Token::Kind kind() const { return kind_; }
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const {
+    IfThenElseInstr* other_if_then_else = other->AsIfThenElse();
+    return (kind_ == other_if_then_else->kind_) &&
+           (if_true_ == other_if_then_else->if_true_) &&
+           (if_false_ == other_if_then_else->if_false_);
+  }
+
  private:
   const Token::Kind kind_;
   const intptr_t if_true_;
   const intptr_t if_false_;
 
   DISALLOW_COPY_AND_ASSIGN(IfThenElseInstr);
 };
 
 
 class StaticCallInstr : public TemplateDefinition<0> {
@@ skipping 22 matching lines @@
 
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   virtual PushArgumentInstr* PushArgumentAt(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 EffectSet Effects() const { return EffectSet::All(); }
 
   void set_result_cid(intptr_t value) { result_cid_ = value; }
 
   bool is_known_list_constructor() const { return is_known_list_constructor_; }
   void set_is_known_list_constructor(bool value) {
     is_known_list_constructor_ = value;
   }
 
  private:
   const intptr_t token_pos_;
@@ skipping 16 matching lines @@
 
   DECLARE_INSTRUCTION(LoadLocal)
   virtual CompileType ComputeType() const;
 
   const LocalVariable& local() const { return local_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool HasSideEffect() const {
-    UNREACHABLE();
-    return false;
+  virtual EffectSet Effects() const {
+    UNREACHABLE();  // Eliminated by SSA construction.
+    return EffectSet::None();
   }
 
   void mark_last() { is_last_ = true; }
   bool is_last() const { return is_last_; }
 
  private:
   const LocalVariable& local_;
   bool is_last_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadLocalInstr);
@@ skipping 10 matching lines @@
   DECLARE_INSTRUCTION(StoreLocal)
   virtual CompileType* ComputeInitialType() const;
 
   const LocalVariable& local() const { return local_; }
   Value* value() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool HasSideEffect() const {
-    UNREACHABLE();
-    return false;
-  }
-
   void mark_dead() { is_dead_ = true; }
   bool is_dead() const { return is_dead_; }
 
   void mark_last() { is_last_ = true; }
   bool is_last() const { return is_last_; }
 
+  virtual EffectSet Effects() const {
+    UNREACHABLE();  // Eliminated by SSA construction.
+    return EffectSet::None();
+  }
+
  private:
   const LocalVariable& local_;
   bool is_dead_;
   bool is_last_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreLocalInstr);
 };
 
 
 class NativeCallInstr : public TemplateDefinition<0> {
@@ skipping 12 matching lines @@
   }
 
   NativeFunction native_c_function() const {
     return ast_node_.native_c_function();
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool HasSideEffect() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::All(); }
 
  private:
   const NativeBodyNode& ast_node_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeCallInstr);
 };
 
 
 enum StoreBarrierType {
   kNoStoreBarrier,
@@ skipping 22 matching lines @@
   Value* value() const { return inputs_[1]; }
   bool ShouldEmitStoreBarrier() const {
     return value()->NeedsStoreBuffer()
         && (emit_store_barrier_ == kEmitStoreBarrier);
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool HasSideEffect() const { return true; }
+  // Currently CSE/LICM don't operate on any instructions that can be affected
+  // by stores/loads. LoadOptimizer handles loads separately. Hence stores
+  // are marked as having no side-effects.
+  virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   bool CanValueBeSmi() const {
     const intptr_t cid = value()->Type()->ToNullableCid();
     // Write barrier is skipped for nullable and non-nullable smis.
     ASSERT(cid != kSmiCid);
     return (cid == kDynamicCid);
   }
 
   const Field& field_;
   const StoreBarrierType emit_store_barrier_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreInstanceFieldInstr);
 };
 
 
 class GuardFieldInstr : public TemplateInstruction<1> {
  public:
   GuardFieldInstr(Value* value,
                   const Field& field,
                   intptr_t deopt_id)
     : field_(field) {
     deopt_id_ = deopt_id;
     SetInputAt(0, value);
   }
 
+  Value* value() const { return inputs_[0]; }
+
+  const Field& field() const { return field_; }
+
   DECLARE_INSTRUCTION(GuardField)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
 
-  virtual bool HasSideEffect() const { return false; }
-
-  virtual bool AttributesEqual(Instruction* other) const;
-
-  virtual bool AffectedBySideEffect() const;
-
-  Value* value() const { return inputs_[0]; }
-
   virtual Instruction* Canonicalize(FlowGraphOptimizer* optimizer);
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
-  const Field& field() const { return field_; }
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const;
 
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(GuardFieldInstr);
 };
 
 
 class LoadStaticFieldInstr : public TemplateDefinition<0> {
  public:
   explicit LoadStaticFieldInstr(const Field& field) : field_(field) {}
 
   DECLARE_INSTRUCTION(LoadStaticField);
   virtual CompileType ComputeType() 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 bool AffectedBySideEffect() const { return !field().is_final(); }
+  virtual bool AllowsCSE() const { return field_.is_final(); }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const;
   virtual bool AttributesEqual(Instruction* other) const;
 
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadStaticFieldInstr);
 };
 
 
 class StoreStaticFieldInstr : public TemplateDefinition<1> {
  public:
   StoreStaticFieldInstr(const Field& field, Value* value)
       : field_(field) {
     ASSERT(field.IsZoneHandle());
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(StoreStaticField);
   virtual CompileType* ComputeInitialType() 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; }
+  // Currently CSE/LICM don't operate on any instructions that can be affected
+  // by stores/loads. LoadOptimizer handles loads separately. Hence stores
+  // are marked as having no side-effects.
+  virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   bool CanValueBeSmi() const {
     const intptr_t cid = value()->Type()->ToNullableCid();
     // Write barrier is skipped for nullable and non-nullable smis.
     ASSERT(cid != kSmiCid);
     return (cid == kDynamicCid);
   }
 
   const Field& field_;
@@ skipping 31 matching lines @@
 
   Value* array() const { return inputs_[0]; }
   Value* index() const { return inputs_[1]; }
   intptr_t index_scale() const { return index_scale_; }
   intptr_t class_id() const { return class_id_; }
 
   virtual bool CanDeoptimize() const {
     return deopt_id_ != Isolate::kNoDeoptId;
   }
 
-  virtual bool HasSideEffect() const { return false; }
 
   virtual Representation representation() const;
+  virtual void InferRange();
 
+  virtual bool AllowsCSE() const { return false; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const;
   virtual bool AttributesEqual(Instruction* other) const;
 
-  virtual bool AffectedBySideEffect() const { return true; }
-
-  virtual void InferRange();
-
  private:
   const intptr_t index_scale_;
   const intptr_t class_id_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadIndexedInstr);
 };
 
 
 class StringFromCharCodeInstr : public TemplateDefinition<1> {
  public:
   StringFromCharCodeInstr(Value* char_code, intptr_t cid) : cid_(cid) {
     ASSERT(char_code != NULL);
     ASSERT(char_code->definition()->IsLoadIndexed() &&
            (char_code->definition()->AsLoadIndexed()->class_id() ==
             kOneByteStringCid));
     SetInputAt(0, char_code);
   }
 
   DECLARE_INSTRUCTION(StringFromCharCode)
   virtual CompileType ComputeType() const;
 
   Value* char_code() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool HasSideEffect() const { return false; }
-
-  virtual bool AttributesEqual(Instruction* other) const { return true; }
-
-  virtual bool AffectedBySideEffect() const { return false; }
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const {
+    return other->AsStringFromCharCode()->cid_ == cid_;
+  }
 
  private:
   const intptr_t cid_;
 
   DISALLOW_COPY_AND_ASSIGN(StringFromCharCodeInstr);
 };
 
 
 class StoreIndexedInstr : public TemplateDefinition<3> {
  public:
@@ skipping 21 matching lines @@
   intptr_t index_scale() const { return index_scale_; }
   intptr_t class_id() const { return class_id_; }
 
   bool ShouldEmitStoreBarrier() const {
     return value()->NeedsStoreBuffer()
         && (emit_store_barrier_ == kEmitStoreBarrier);
   }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool HasSideEffect() const { return true; }
-
   virtual Representation RequiredInputRepresentation(intptr_t idx) const;
 
   bool IsExternal() const {
     return array()->definition()->representation() == kUntagged;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return deopt_id_;
   }
 
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+
  private:
   const StoreBarrierType emit_store_barrier_;
   const intptr_t index_scale_;
   const intptr_t class_id_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreIndexedInstr);
 };
 
 
 // Note overrideable, built-in: value? false : true.
 class BooleanNegateInstr : public TemplateDefinition<1> {
  public:
   explicit BooleanNegateInstr(Value* value) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(BooleanNegate)
   virtual CompileType ComputeType() const;
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool HasSideEffect() const { return false; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BooleanNegateInstr);
 };
 
 
 class InstanceOfInstr : public TemplateDefinition<3> {
  public:
   InstanceOfInstr(intptr_t token_pos,
                   Value* value,
@@ skipping 20 matching lines @@
   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 true; }
 
-  virtual bool HasSideEffect() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   const intptr_t token_pos_;
   Value* value_;
   Value* instantiator_;
   Value* type_arguments_;
   const AbstractType& type_;
   const bool negate_result_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceOfInstr);
@@ skipping 19 matching lines @@
     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 EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   const ConstructorCallNode& ast_node_;
   ZoneGrowableArray<PushArgumentInstr*>* const arguments_;
   const intptr_t cid_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateObjectInstr);
 };
 
 
 class AllocateObjectWithBoundsCheckInstr : public TemplateDefinition<2> {
  public:
   AllocateObjectWithBoundsCheckInstr(ConstructorCallNode* node,
                                      Value* type_arguments,
                                      Value* instantiator)
       : ast_node_(*node) {
     SetInputAt(0, type_arguments);
     SetInputAt(1, instantiator);
   }
 
   DECLARE_INSTRUCTION(AllocateObjectWithBoundsCheck)
 
   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 true; }
 
-  virtual bool HasSideEffect() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   const ConstructorCallNode& ast_node_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateObjectWithBoundsCheckInstr);
 };
 
 
 class CreateArrayInstr : public TemplateDefinition<1> {
  public:
@@ skipping 16 matching lines @@
   intptr_t num_elements() const { return num_elements_; }
 
   intptr_t token_pos() const { return token_pos_; }
   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 EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   const intptr_t token_pos_;
   const intptr_t num_elements_;
   const AbstractType& type_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateArrayInstr);
 };
 
 
@@ skipping 14 matching lines @@
 
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   virtual PushArgumentInstr* PushArgumentAt(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 EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   const Function& function_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
   intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateClosureInstr);
 };
 
 
 class LoadUntaggedInstr : public TemplateDefinition<1> {
  public:
   explicit LoadUntaggedInstr(Value* object, intptr_t offset) : offset_(offset) {
     SetInputAt(0, object);
   }
 
   virtual Representation representation() const {
     return kUntagged;
   }
   DECLARE_INSTRUCTION(LoadUntagged)
   virtual CompileType ComputeType() const;
 
   Value* object() const { return inputs_[0]; }
   intptr_t offset() const { return offset_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool HasSideEffect() const { return false; }
-
-  virtual bool AttributesEqual(Instruction* other) const { return true; }
-
   // This instruction must not be moved without the indexed access that
   // depends on it (e.g. out of loops). GC may cause collect
   // the array while the external data-array is still accessed.
-  virtual bool AffectedBySideEffect() const { return true; }
+  virtual bool AllowsCSE() const { return false; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   intptr_t offset_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadUntaggedInstr);
 };
 
 
 class LoadFieldInstr : public TemplateDefinition<1> {
  public:
   LoadFieldInstr(Value* value,
                  intptr_t offset_in_bytes,
                  const AbstractType& type,
                  bool immutable = false)
       : offset_in_bytes_(offset_in_bytes),
         type_(type),
         result_cid_(kDynamicCid),
         immutable_(immutable),
         recognized_kind_(MethodRecognizer::kUnknown),
         field_name_(NULL),
         field_(NULL) {
     ASSERT(type.IsZoneHandle());  // May be null if field is not an instance.
     SetInputAt(0, value);
   }
 
-  DECLARE_INSTRUCTION(LoadField)
-  virtual CompileType ComputeType() 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; }
   intptr_t result_cid() const { return result_cid_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
+  void set_field_name(const char* name) { field_name_ = name; }
+  const char* field_name() const { return field_name_; }
 
-  virtual bool CanDeoptimize() const { return false; }
-
-  virtual bool HasSideEffect() const { return false; }
-
-  virtual bool AttributesEqual(Instruction* other) const;
-
-  virtual bool AffectedBySideEffect() const { return !immutable_; }
-
-  virtual void InferRange();
+  Field* field() const { return field_; }
+  void set_field(Field* field) { field_ = field; }
 
   void set_recognized_kind(MethodRecognizer::Kind kind) {
     recognized_kind_ = kind;
   }
 
   MethodRecognizer::Kind recognized_kind() const {
     return recognized_kind_;
   }
 
+  DECLARE_INSTRUCTION(LoadField)
+  virtual CompileType ComputeType() const;
+
+  virtual void PrintOperandsTo(BufferFormatter* f) const;
+
+  virtual bool CanDeoptimize() const { return false; }
+
+  virtual void InferRange();
+
   bool IsImmutableLengthLoad() const;
 
   virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
 
   static MethodRecognizer::Kind RecognizedKindFromArrayCid(intptr_t cid);
 
   static bool IsFixedLengthArrayCid(intptr_t cid);
 
-  void set_field_name(const char* name) { field_name_ = name; }
-  const char* field_name() const { return field_name_; }
-
-  Field* field() const { return field_; }
-  void set_field(Field* field) { field_ = field; }
+  virtual bool AllowsCSE() const { return immutable_; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const;
+  virtual bool AttributesEqual(Instruction* other) const;
 
  private:
   const intptr_t offset_in_bytes_;
   const AbstractType& type_;
   intptr_t result_cid_;
   const bool immutable_;
 
   MethodRecognizer::Kind recognized_kind_;
 
   const char* field_name_;
@@ skipping 20 matching lines @@
 
   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 EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   const intptr_t offset_in_bytes_;
   const AbstractType& type_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreVMFieldInstr);
 };
 
 
 class InstantiateTypeArgumentsInstr : public TemplateDefinition<1> {
@@ skipping 12 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 true; }
 
-  virtual bool HasSideEffect() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   const intptr_t token_pos_;
   const AbstractTypeArguments& type_arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(InstantiateTypeArgumentsInstr);
 };
 
 
 class ExtractConstructorTypeArgumentsInstr : public TemplateDefinition<1> {
@@ skipping 12 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 EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   const intptr_t token_pos_;
   const AbstractTypeArguments& type_arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtractConstructorTypeArgumentsInstr);
 };
 
 
 class ExtractConstructorInstantiatorInstr : public TemplateDefinition<1> {
  public:
   ExtractConstructorInstantiatorInstr(ConstructorCallNode* ast_node,
                                       Value* instantiator)
       : ast_node_(*ast_node) {
     SetInputAt(0, instantiator);
   }
 
   DECLARE_INSTRUCTION(ExtractConstructorInstantiator)
 
   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 EffectSet Effects() const { return EffectSet::None(); }
 
  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 CompileType ComputeType() 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 EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   const intptr_t token_pos_;
   const intptr_t num_context_variables_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateContextInstr);
 };
 
 
 class ChainContextInstr : public TemplateInstruction<1> {
  public:
   explicit ChainContextInstr(Value* context_value) {
     SetInputAt(0, context_value);
   }
 
   DECLARE_INSTRUCTION(ChainContext)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   Value* context_value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool HasSideEffect() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChainContextInstr);
 };
 
 
 class CloneContextInstr : public TemplateDefinition<1> {
  public:
   CloneContextInstr(intptr_t token_pos, Value* context_value)
       : token_pos_(token_pos) {
     SetInputAt(0, context_value);
   }
 
   intptr_t token_pos() const { return token_pos_; }
   Value* context_value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(CloneContext)
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return true; }
 
-  virtual bool HasSideEffect() const { return false; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(CloneContextInstr);
 };
 
 
 class CatchEntryInstr : public TemplateInstruction<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 intptr_t ArgumentCount() const { return 0; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool HasSideEffect() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::All(); }
 
  private:
   const LocalVariable& exception_var_;
   const LocalVariable& stacktrace_var_;
 
   DISALLOW_COPY_AND_ASSIGN(CatchEntryInstr);
 };
 
 
 class CheckEitherNonSmiInstr : public TemplateInstruction<2> {
  public:
   CheckEitherNonSmiInstr(Value* left,
                          Value* right,
                          InstanceCallInstr* instance_call) {
     SetInputAt(0, left);
     SetInputAt(1, right);
     deopt_id_ = instance_call->deopt_id();
   }
 
+  Value* left() const { return inputs_[0]; }
+  Value* right() const { return inputs_[1]; }
+
   DECLARE_INSTRUCTION(CheckEitherNonSmi)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
 
-  virtual bool HasSideEffect() const { return false; }
+  virtual Instruction* Canonicalize(FlowGraphOptimizer* optimizer);
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
-  virtual bool AffectedBySideEffect() const { return false; }
-
-  Value* left() const { return inputs_[0]; }
-
-  Value* right() const { return inputs_[1]; }
-
-  virtual Instruction* Canonicalize(FlowGraphOptimizer* optimizer);
-
  private:
   DISALLOW_COPY_AND_ASSIGN(CheckEitherNonSmiInstr);
 };
 
 
 class BoxDoubleInstr : public TemplateDefinition<1> {
  public:
   explicit BoxDoubleInstr(Value* value) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
+  DECLARE_INSTRUCTION(BoxDouble)
+  virtual CompileType ComputeType() const;
+
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool HasSideEffect() const { return false; }
-
-  virtual bool AffectedBySideEffect() const { return false; }
-  virtual bool AttributesEqual(Instruction* other) const { return true; }
-
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
-  DECLARE_INSTRUCTION(BoxDouble)
-  virtual CompileType ComputeType() const;
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxDoubleInstr);
 };
 
 
 class BoxFloat32x4Instr : public TemplateDefinition<1> {
  public:
   explicit BoxFloat32x4Instr(Value* value) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool HasSideEffect() const { return false; }
-
-  virtual bool AffectedBySideEffect() const { return false; }
-  virtual bool AttributesEqual(Instruction* other) const { return true; }
-
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedFloat32x4;
   }
 
   DECLARE_INSTRUCTION(BoxFloat32x4)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const { return true; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxFloat32x4Instr);
 };
 
 
 class BoxIntegerInstr : public TemplateDefinition<1> {
  public:
   explicit BoxIntegerInstr(Value* value) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool HasSideEffect() const { return false; }
-
-  virtual bool AffectedBySideEffect() const { return false; }
-  virtual bool AttributesEqual(Instruction* other) const { return true; }
-
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedMint;
   }
 
   DECLARE_INSTRUCTION(BoxInteger)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const { return true; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxIntegerInstr);
 };
 
 
 class UnboxDoubleInstr : public TemplateDefinition<1> {
  public:
   UnboxDoubleInstr(Value* value, intptr_t deopt_id) {
     SetInputAt(0, value);
     deopt_id_ = deopt_id;
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const {
     return (value()->Type()->ToCid() != kDoubleCid)
         && (value()->Type()->ToCid() != kSmiCid);
   }
 
-  virtual bool HasSideEffect() const { return false; }
-
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
-  virtual bool AffectedBySideEffect() const { return false; }
-  virtual bool AttributesEqual(Instruction* other) const { return true; }
-
   DECLARE_INSTRUCTION(UnboxDouble)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const { return true; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxDoubleInstr);
 };
 
 
 class UnboxFloat32x4Instr : public TemplateDefinition<1> {
  public:
   UnboxFloat32x4Instr(Value* value, intptr_t deopt_id) {
     SetInputAt(0, value);
     deopt_id_ = deopt_id;
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const {
     return (value()->Type()->ToCid() != kFloat32x4Cid);
   }
 
-  virtual bool HasSideEffect() const { return false; }
-
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
-  virtual bool AffectedBySideEffect() const { return false; }
-  virtual bool AttributesEqual(Instruction* other) const { return true; }
-
   DECLARE_INSTRUCTION(UnboxFloat32x4)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const { return true; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxFloat32x4Instr);
 };
 
 
 class UnboxIntegerInstr : public TemplateDefinition<1> {
  public:
   UnboxIntegerInstr(Value* value, intptr_t deopt_id) {
     SetInputAt(0, value);
     deopt_id_ = deopt_id;
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const {
     return (value()->Type()->ToCid() != kSmiCid)
         && (value()->Type()->ToCid() != kMintCid);
   }
 
-  virtual bool HasSideEffect() const { return false; }
-
-  virtual CompileType ComputeType() const;
-
   virtual Representation representation() const {
     return kUnboxedMint;
   }
 
 
-  virtual bool AffectedBySideEffect() const { return false; }
+  DECLARE_INSTRUCTION(UnboxInteger)
+  virtual CompileType ComputeType() const;
+
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
-  DECLARE_INSTRUCTION(UnboxInteger)
-
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxIntegerInstr);
 };
 
 
 class MathSqrtInstr : public TemplateDefinition<1> {
  public:
   MathSqrtInstr(Value* value, StaticCallInstr* instance_call) {
     SetInputAt(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(Instruction* other) const {
-    return true;
-  }
-
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return deopt_id_;
   }
 
   DECLARE_INSTRUCTION(MathSqrt)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const { return true; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(MathSqrtInstr);
 };
 
 
 class BinaryDoubleOpInstr : public TemplateDefinition<2> {
  public:
   BinaryDoubleOpInstr(Token::Kind op_kind,
                       Value* left,
                       Value* right,
                       InstanceCallInstr* instance_call)
       : op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
     deopt_id_ = instance_call->deopt_id();
   }
 
   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(Instruction* other) const {
-    return op_kind() == other->AsBinaryDoubleOp()->op_kind();
-  }
-
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return deopt_id_;
   }
 
   DECLARE_INSTRUCTION(BinaryDoubleOp)
   virtual CompileType ComputeType() const;
 
   virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const {
+    return op_kind() == other->AsBinaryDoubleOp()->op_kind();
+  }
+
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(BinaryDoubleOpInstr);
 };
 
 
 class BinaryFloat32x4OpInstr : public TemplateDefinition<2> {
  public:
   BinaryFloat32x4OpInstr(Token::Kind op_kind,
                          Value* left,
                          Value* right,
                          InstanceCallInstr* instance_call)
       : op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
     deopt_id_ = instance_call->deopt_id();
   }
 
   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(Instruction* other) const {
-    return op_kind() == other->AsBinaryFloat32x4Op()->op_kind();
-  }
-
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return deopt_id_;
   }
 
   DECLARE_INSTRUCTION(BinaryFloat32x4Op)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const {
+    return op_kind() == other->AsBinaryFloat32x4Op()->op_kind();
+  }
+
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(BinaryFloat32x4OpInstr);
 };
 
 
 class Float32x4ShuffleInstr : public TemplateDefinition<1> {
  public:
   Float32x4ShuffleInstr(MethodRecognizer::Kind op_kind, Value* value,
                         InstanceCallInstr* instance_call)
       : op_kind_(op_kind) {
     SetInputAt(0, value);
     deopt_id_ = instance_call->deopt_id();
   }
 
   Value* value() const { return inputs_[0]; }
 
   MethodRecognizer::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(Instruction* other) const {
-    return op_kind() == other->AsFloat32x4Shuffle()->op_kind();
-  }
-
   virtual Representation representation() const {
     if ((op_kind_ == MethodRecognizer::kFloat32x4ShuffleX) ||
         (op_kind_ == MethodRecognizer::kFloat32x4ShuffleY) ||
         (op_kind_ == MethodRecognizer::kFloat32x4ShuffleZ) ||
         (op_kind_ == MethodRecognizer::kFloat32x4ShuffleW)) {
       return kUnboxedDouble;
     }
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return deopt_id_;
   }
 
   DECLARE_INSTRUCTION(Float32x4Shuffle)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const {
+    return op_kind() == other->AsFloat32x4Shuffle()->op_kind();
+  }
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Float32x4ShuffleInstr);
 };
 
 
 class Float32x4ConstructorInstr : public TemplateDefinition<4> {
  public:
   Float32x4ConstructorInstr(Value* value0, Value* value1, Value* value2,
                             Value* value3, StaticCallInstr* static_call) {
     SetInputAt(0, value0);
     SetInputAt(1, value1);
     SetInputAt(2, value2);
     SetInputAt(3, value3);
     deopt_id_ = static_call->deopt_id();
   }
 
   Value* value0() const { return inputs_[0]; }
   Value* value1() const { return inputs_[1]; }
   Value* value2() const { return inputs_[2]; }
   Value* value3() const { return inputs_[3]; }
 
   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(Instruction* other) const { return true; }
-
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx >= 0 && idx < 4);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return deopt_id_;
   }
 
   DECLARE_INSTRUCTION(Float32x4Constructor)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const { return true; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Float32x4ConstructorInstr);
 };
 
 
 class Float32x4SplatInstr : public TemplateDefinition<1> {
  public:
   Float32x4SplatInstr(Value* value, StaticCallInstr* static_call) {
     SetInputAt(0, value);
     deopt_id_ = static_call->deopt_id();
   }
 
   Value* value() const { return inputs_[0]; }
 
   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(Instruction* other) const { return true; }
-
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return deopt_id_;
   }
 
   DECLARE_INSTRUCTION(Float32x4Splat)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const { return true; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Float32x4SplatInstr);
 };
 
 
 class Float32x4ZeroInstr : public TemplateDefinition<0> {
  public:
   explicit Float32x4ZeroInstr(StaticCallInstr* static_call) {
     deopt_id_ = static_call->deopt_id();
   }
 
   Value* value() const { return inputs_[0]; }
 
   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(Instruction* other) const { return true; }
-
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     UNIMPLEMENTED();
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return deopt_id_;
   }
 
   DECLARE_INSTRUCTION(Float32x4Zero)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const { return true; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Float32x4ZeroInstr);
 };
 
 
 class BinaryMintOpInstr : public TemplateDefinition<2> {
  public:
   BinaryMintOpInstr(Token::Kind op_kind,
                            Value* left,
                            Value* right,
@@ skipping 11 matching lines @@
   Token::Kind op_kind() const { return op_kind_; }
 
   InstanceCallInstr* instance_call() const { return instance_call_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const {
     return (op_kind() == Token::kADD) || (op_kind() == Token::kSUB);
   }
 
-  virtual bool HasSideEffect() const { return false; }
-
-  virtual bool AffectedBySideEffect() const { return false; }
-
-  virtual bool AttributesEqual(Instruction* other) const {
-    ASSERT(other->IsBinaryMintOp());
-    return op_kind() == other->AsBinaryMintOp()->op_kind();
-  }
-
-  virtual CompileType ComputeType() const;
-
   virtual Representation representation() const {
     return kUnboxedMint;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedMint;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return deopt_id_;
   }
 
   virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
 
   DECLARE_INSTRUCTION(BinaryMintOp)
+  virtual CompileType ComputeType() const;
+
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const {
+    ASSERT(other->IsBinaryMintOp());
+    return op_kind() == other->AsBinaryMintOp()->op_kind();
+  }
 
  private:
   const Token::Kind op_kind_;
   InstanceCallInstr* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(BinaryMintOpInstr);
 };
 
 
 class ShiftMintOpInstr : public TemplateDefinition<2> {
@@ skipping 11 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 true; }
 
-  virtual bool HasSideEffect() const { return false; }
-
-  virtual bool AffectedBySideEffect() const { return false; }
-
-  virtual bool AttributesEqual(Instruction* other) const {
-    return op_kind() == other->AsShiftMintOp()->op_kind();
-  }
-
   virtual CompileType ComputeType() const;
 
   virtual Representation representation() const {
     return kUnboxedMint;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return (idx == 0) ? kUnboxedMint : kTagged;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return deopt_id_;
   }
 
   DECLARE_INSTRUCTION(ShiftMintOp)
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const {
+    return op_kind() == other->AsShiftMintOp()->op_kind();
+  }
+
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(ShiftMintOpInstr);
 };
 
 
 class UnaryMintOpInstr : public TemplateDefinition<1> {
  public:
   UnaryMintOpInstr(Token::Kind op_kind,
                           Value* value,
                           InstanceCallInstr* instance_call)
       : op_kind_(op_kind) {
     ASSERT(op_kind == Token::kBIT_NOT);
     SetInputAt(0, value);
     deopt_id_ = instance_call->deopt_id();
   }
 
   Value* value() const { return inputs_[0]; }
 
   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(Instruction* other) const {
-    return op_kind() == other->AsUnaryMintOp()->op_kind();
-  }
-
-  virtual CompileType ComputeType() const;
-
   virtual Representation representation() const {
     return kUnboxedMint;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedMint;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return deopt_id_;
   }
 
   DECLARE_INSTRUCTION(UnaryMintOp)
+  virtual CompileType ComputeType() const;
+
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const {
+    return op_kind() == other->AsUnaryMintOp()->op_kind();
+  }
 
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(UnaryMintOpInstr);
 };
 
 
 class BinarySmiOpInstr : public TemplateDefinition<2> {
  public:
@@ skipping 12 matching lines @@
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   Token::Kind op_kind() const { return op_kind_; }
 
   InstanceCallInstr* instance_call() const { return instance_call_; }
 
   const ICData* ic_data() const { return instance_call()->ic_data(); }
 
+  void set_overflow(bool overflow) { overflow_ = overflow; }
+
+  void set_is_truncating(bool value) { is_truncating_ = value; }
+  bool is_truncating() const { return is_truncating_; }
+
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   DECLARE_INSTRUCTION(BinarySmiOp)
-
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const;
 
-  virtual bool HasSideEffect() const { return false; }
-
-  virtual bool AffectedBySideEffect() const { return false; }
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const;
 
-  void set_overflow(bool overflow) {
-    overflow_ = overflow;
-  }
-
-  void set_is_truncating(bool value) {
-    is_truncating_ = value;
-  }
-  bool is_truncating() const { return is_truncating_; }
-
   void PrintTo(BufferFormatter* f) const;
 
   virtual void InferRange();
 
   virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
 
   // Returns true if right is a non-zero Smi constant which absolute value is
   // a power of two.
   bool RightIsPowerOfTwoConstant() const;
 
@@ skipping 22 matching lines @@
   Value* value() const { return inputs_[0]; }
   Token::Kind op_kind() const { return op_kind_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   DECLARE_INSTRUCTION(UnarySmiOp)
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return op_kind() == Token::kNEGATE; }
 
-  virtual bool HasSideEffect() const { return false; }
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const {
+    return other->AsUnarySmiOp()->op_kind() == op_kind();
+  }
 
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(UnarySmiOpInstr);
 };
 
 
 class CheckStackOverflowInstr : public TemplateInstruction<0> {
  public:
   explicit CheckStackOverflowInstr(intptr_t token_pos)
       : token_pos_(token_pos) {}
 
   intptr_t token_pos() const { return token_pos_; }
 
   DECLARE_INSTRUCTION(CheckStackOverflow)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
 
-  virtual bool HasSideEffect() const { return false; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckStackOverflowInstr);
 };
 
 
 class SmiToDoubleInstr : public TemplateDefinition<1> {
  public:
   explicit SmiToDoubleInstr(Value* value) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(SmiToDouble)
   virtual CompileType ComputeType() const;
 
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual intptr_t ArgumentCount() const { return 1; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool HasSideEffect() const { return false; }
-  virtual bool AffectedBySideEffect() const { return false; }
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SmiToDoubleInstr);
 };
 
 
 class DoubleToIntegerInstr : public TemplateDefinition<1> {
  public:
   DoubleToIntegerInstr(Value* value, InstanceCallInstr* instance_call)
       : instance_call_(instance_call) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
   InstanceCallInstr* instance_call() const { return instance_call_; }
 
   DECLARE_INSTRUCTION(DoubleToInteger)
   virtual CompileType ComputeType() const;
 
   virtual intptr_t ArgumentCount() const { return 1; }
 
   virtual bool CanDeoptimize() const { return true; }
 
-  virtual bool HasSideEffect() const { return false; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   InstanceCallInstr* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(DoubleToIntegerInstr);
 };
 
 
 // Similar to 'DoubleToIntegerInstr' but expects unboxed double as input
 // and creates a Smi.
 class DoubleToSmiInstr : public TemplateDefinition<1> {
  public:
   DoubleToSmiInstr(Value* value, InstanceCallInstr* instance_call) {
     SetInputAt(0, value);
     deopt_id_ = instance_call->deopt_id();
   }
 
   Value* value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(DoubleToSmi)
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return true; }
 
-  virtual bool HasSideEffect() const { return false; }
-
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const { return deopt_id_; }
 
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(DoubleToSmiInstr);
 };
 
 
 class DoubleToDoubleInstr : public TemplateDefinition<1> {
  public:
   DoubleToDoubleInstr(Value* value,
                       InstanceCallInstr* instance_call,
                       MethodRecognizer::Kind recognized_kind)
     : recognized_kind_(recognized_kind) {
     SetInputAt(0, value);
     deopt_id_ = instance_call->deopt_id();
   }
 
   Value* value() const { return inputs_[0]; }
 
   MethodRecognizer::Kind recognized_kind() const { return recognized_kind_; }
 
   DECLARE_INSTRUCTION(DoubleToDouble)
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool HasSideEffect() const { return false; }
-  virtual bool AffectedBySideEffect() const { return false; }
-  virtual bool AttributesEqual(Instruction* other) const {
-    return other->AsDoubleToDouble()->recognized_kind() == recognized_kind();
-  }
-
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const { return deopt_id_; }
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const {
+    return other->AsDoubleToDouble()->recognized_kind() == recognized_kind();
+  }
+
  private:
   const MethodRecognizer::Kind recognized_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(DoubleToDoubleInstr);
 };
 
 
 class InvokeMathCFunctionInstr : public Definition {
  public:
   InvokeMathCFunctionInstr(ZoneGrowableArray<Value*>* inputs,
                            InstanceCallInstr* instance_call,
                            MethodRecognizer::Kind recognized_kind);
 
   static intptr_t ArgumentCountFor(MethodRecognizer::Kind recognized_kind_);
 
   const RuntimeEntry& TargetFunction() const;
 
   MethodRecognizer::Kind recognized_kind() const { return recognized_kind_; }
 
   DECLARE_INSTRUCTION(InvokeMathCFunction)
   virtual CompileType ComputeType() const;
   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(Instruction* other) const {
-    return other->AsDoubleToDouble()->recognized_kind() == recognized_kind();
-  }
-
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((0 <= idx) && (idx < InputCount()));
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const { return deopt_id_; }
 
   virtual intptr_t InputCount() const {
     return inputs_->length();
   }
 
   virtual Value* InputAt(intptr_t i) const {
     return (*inputs_)[i];
   }
 
   // Returns a structure describing the location constraints required
   // to emit native code for this definition.
   LocationSummary* locs() {
     if (locs_ == NULL) {
       locs_ = MakeLocationSummary();
     }
     return locs_;
   }
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) {
+    return other->AsInvokeMathCFunction()->recognized_kind() ==
+        recognized_kind();
+  }
+
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     (*inputs_)[i] = value;
   }
 
   ZoneGrowableArray<Value*>* inputs_;
 
   LocationSummary* locs_;
 
   const MethodRecognizer::Kind recognized_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(InvokeMathCFunctionInstr);
 };
 
 
 class CheckClassInstr : public TemplateInstruction<1> {
  public:
   CheckClassInstr(Value* value,
                   intptr_t deopt_id,
                   const ICData& unary_checks);
 
   DECLARE_INSTRUCTION(CheckClass)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
 
-  virtual bool HasSideEffect() const { return false; }
-
-  virtual bool AttributesEqual(Instruction* other) const;
-
-  virtual bool AffectedBySideEffect() const;
-
   Value* value() const { return inputs_[0]; }
 
   const ICData& unary_checks() const { return unary_checks_; }
 
   virtual Instruction* Canonicalize(FlowGraphOptimizer* optimizer);
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   void set_null_check(bool flag) { null_check_ = flag; }
 
   bool null_check() const { return null_check_; }
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const;
+  virtual bool AttributesEqual(Instruction* other) const;
+
  private:
   const ICData& unary_checks_;
 
   bool null_check_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckClassInstr);
 };
 
 
 class CheckSmiInstr : public TemplateInstruction<1> {
  public:
   CheckSmiInstr(Value* value, intptr_t original_deopt_id) {
     ASSERT(original_deopt_id != Isolate::kNoDeoptId);
     SetInputAt(0, value);
     deopt_id_ = original_deopt_id;
   }
 
+  Value* value() const { return inputs_[0]; }
+
   DECLARE_INSTRUCTION(CheckSmi)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
 
-  virtual bool HasSideEffect() const { return false; }
-
-  virtual bool AttributesEqual(Instruction* other) const { return true; }
-
-  virtual bool AffectedBySideEffect() const { return false; }
-
   virtual Instruction* Canonicalize(FlowGraphOptimizer* optimizer);
 
-  Value* value() const { return inputs_[0]; }
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CheckSmiInstr);
 };
 
 
 class CheckArrayBoundInstr : public TemplateInstruction<2> {
  public:
   CheckArrayBoundInstr(Value* length,
                        Value* index,
                        intptr_t array_type,
                        InstanceCallInstr* instance_call)
       : array_type_(array_type) {
     SetInputAt(0, length);
     SetInputAt(1, index);
     deopt_id_ = instance_call->deopt_id();
   }
 
+  Value* length() const { return inputs_[0]; }
+  Value* index() const { return inputs_[1]; }
+
+  intptr_t array_type() const { return array_type_; }
+
   DECLARE_INSTRUCTION(CheckArrayBound)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
 
-  virtual bool HasSideEffect() const { return false; }
-
-  virtual bool AttributesEqual(Instruction* other) const;
-
-  virtual bool AffectedBySideEffect() const { return false; }
-
-  Value* length() const { return inputs_[0]; }
-  Value* index() const { return inputs_[1]; }
-
-  intptr_t array_type() const { return array_type_; }
-
   bool IsRedundant(RangeBoundary length);
 
   // Returns the length offset for array and string types.
   static intptr_t LengthOffsetFor(intptr_t class_id);
 
   static bool IsFixedLengthArrayType(intptr_t class_id);
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const;
+
  private:
   intptr_t array_type_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckArrayBoundInstr);
 };
 
 
 #undef DECLARE_INSTRUCTION
 
 class Environment : public ZoneAllocated {
@@ skipping 211 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_