[vm] Cleanup Instruction::Effects(), prepare to cleanup Dependencies()

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 RUNTIME_VM_INTERMEDIATE_LANGUAGE_H_
 #define RUNTIME_VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/flags.h"
@@ skipping 160 matching lines @@
  private:
   bool CanComputeIsInstanceOf(const AbstractType& type,
                               bool is_nullable,
                               bool* is_instance);
 
   bool is_nullable_;
   intptr_t cid_;
   const AbstractType* type_;
 };
 
-// TODO(alexmarkov): remove EffectSet as there are no tracked effects anymore
+// TODO(dartbug.com/30474): remove EffectSet as there are no tracked effects
+// anymore.
 class EffectSet : public ValueObject {
  public:
   enum Effects {
     kNoEffects = 0,
     kUnusedEffect = 1,  // Currently unused.
     kLastEffect = kUnusedEffect
   };
 
   EffectSet(const EffectSet& other) : ValueObject(), effects_(other.effects_) {}
 
@@ skipping 673 matching lines @@
   void InsertAfter(Instruction* prev);
 
   // Append an instruction to the current one and return the tail.
   // This function updated def-use chains of the newly appended
   // instruction.
   Instruction* AppendInstruction(Instruction* tail);
 
   // 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 true if this instruction has any side-effects.
+  virtual bool HasSideEffects() const = 0;

[Vyacheslav Egorov (Google), 2017/08/22 14:08:39]

I would give it a name like HasUnknownSideEffects() or something similar.

The reason being is that some side-effectfull instructions (e.g. stores) return
false from this function.

Maybe also reflect this in the comment above the function: e.g. "if this
instruction has any side-effects besides storing. See
StoreInstanceFieldInstr::Has...Effect() for rationale."

  

[alexmarkov, 2017/08/22 15:51:57]

Done.

 
   // 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();
 
@@ skipping 92 matching lines @@
   Label* fall_through;
 };
 
 class PureInstruction : public Instruction {
  public:
   explicit PureInstruction(intptr_t deopt_id) : Instruction(deopt_id) {}
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 };
 
 // Types to be used as ThrowsTrait for TemplateInstruction/TemplateDefinition.
 struct Throws {
   static const bool kCanThrow = true;
 };
 
 struct NoThrow {
   static const bool kCanThrow = false;
 };
@@ skipping 92 matching lines @@
 class ParallelMoveInstr : public TemplateInstruction<0, NoThrow> {
  public:
   ParallelMoveInstr() : moves_(4) {}
 
   DECLARE_INSTRUCTION(ParallelMove)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
-  virtual EffectSet Effects() const {
+  virtual bool HasSideEffects() const {
     UNREACHABLE();  // This instruction never visited by optimization passes.
-    return EffectSet::None();
+    return false;
   }
 
   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);
@@ skipping 101 matching lines @@
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     // BlockEntry environment is copied to Goto and Branch instructions
     // when we insert new blocks targeting this block.
     return true;
   }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
   virtual bool MayThrow() const { return false; }
 
   intptr_t try_index() const { return try_index_; }
   void set_try_index(intptr_t index) { try_index_ = index; }
 
   // True for blocks inside a try { } region.
   bool InsideTryBlock() const {
     return try_index_ != CatchClauseNode::kInvalidTryIndex;
@@ skipping 225 matching lines @@
   intptr_t IndexOfPredecessor(BlockEntryInstr* pred) const;
 
   ZoneGrowableArray<PhiInstr*>* phis() const { return phis_; }
 
   PhiInstr* InsertPhi(intptr_t var_index, intptr_t var_count);
   void RemoveDeadPhis(Definition* replacement);
 
   void InsertPhi(PhiInstr* phi);
   void RemovePhi(PhiInstr* phi);
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
   PRINT_TO_SUPPORT
 
  private:
   // Classes that have access to predecessors_ when inlining.
   friend class BlockEntryInstr;
   friend class InlineExitCollector;
   friend class PolymorphicInliner;
   friend class IndirectEntryInstr;  // Access in il_printer.cc.
@@ skipping 394 matching lines @@
   def->AddEnvUse(this);
 }
 
 class PureDefinition : public Definition {
  public:
   explicit PureDefinition(intptr_t deopt_id) : Definition(deopt_id) {}
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 };
 
 template <intptr_t N,
           typename ThrowsTrait,
           template <typename Impure, typename Pure> class CSETrait = NoCSE>
 class TemplateDefinition : public CSETrait<Definition, PureDefinition>::Base {
  public:
   explicit TemplateDefinition(intptr_t deopt_id = Thread::kNoDeoptId)
       : CSETrait<Definition, PureDefinition>::Base(deopt_id), inputs_() {}
 
@@ skipping 35 matching lines @@
 
   virtual CompileType ComputeType() const;
   virtual bool RecomputeType();
 
   intptr_t InputCount() const { return inputs_.length(); }
 
   Value* InputAt(intptr_t i) const { return inputs_[i]; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
   // Phi is alive if it reaches a non-environment use.
   bool is_alive() const { return is_alive_; }
   void mark_alive() { is_alive_ = true; }
   void mark_dead() { is_alive_ = false; }
 
   virtual Representation RequiredInputRepresentation(intptr_t i) const {
     return representation_;
   }
 
@@ skipping 73 matching lines @@
   virtual BlockEntryInstr* GetBlock() { return block_; }
 
   intptr_t InputCount() const { return 0; }
   Value* InputAt(intptr_t i) const {
     UNREACHABLE();
     return NULL;
   }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
   virtual intptr_t Hashcode() const {
     UNREACHABLE();
     return 0;
   }
 
   virtual CompileType ComputeType() const;
 
   virtual bool MayThrow() const { return false; }
@@ skipping 15 matching lines @@
   explicit PushArgumentInstr(Value* value) { SetInputAt(0, value); }
 
   DECLARE_INSTRUCTION(PushArgument)
 
   virtual CompileType ComputeType() const;
 
   Value* value() const { return InputAt(0); }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
   virtual TokenPosition token_pos() const {
     return TokenPosition::kPushArgument;
   }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PushArgumentInstr);
 };
@@ skipping 15 matching lines @@
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     // Return instruction might turn into a Goto instruction after inlining.
     // Every Goto must have an environment.
     return true;
   }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
  private:
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(ReturnInstr);
 };
 
 class ThrowInstr : public TemplateInstruction<0, Throws> {
  public:
   explicit ThrowInstr(TokenPosition token_pos, intptr_t deopt_id)
       : TemplateInstruction(deopt_id), token_pos_(token_pos) {}
 
   DECLARE_INSTRUCTION(Throw)
 
   virtual intptr_t ArgumentCount() const { return 1; }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
  private:
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(ThrowInstr);
 };
 
 class ReThrowInstr : public TemplateInstruction<0, Throws> {
  public:
   // 'catch_try_index' can be CatchClauseNode::kInvalidTryIndex if the
   // rethrow has been artificially generated by the parser.
   ReThrowInstr(TokenPosition token_pos,
                intptr_t catch_try_index,
                intptr_t deopt_id)
       : TemplateInstruction(deopt_id),
         token_pos_(token_pos),
         catch_try_index_(catch_try_index) {}
 
   DECLARE_INSTRUCTION(ReThrow)
 
   virtual intptr_t ArgumentCount() const { return 2; }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   intptr_t catch_try_index() const { return catch_try_index_; }
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
  private:
   const TokenPosition token_pos_;
   const intptr_t catch_try_index_;
 
   DISALLOW_COPY_AND_ASSIGN(ReThrowInstr);
 };
 
 class StopInstr : public TemplateInstruction<0, NoThrow> {
  public:
   explicit StopInstr(const char* message) : message_(message) {
     ASSERT(message != NULL);
   }
 
   const char* message() const { return message_; }
 
   DECLARE_INSTRUCTION(Stop);
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
  private:
   const char* message_;
 
   DISALLOW_COPY_AND_ASSIGN(StopInstr);
 };
 
 class GotoInstr : public TemplateInstruction<0, NoThrow> {
@@ skipping 20 matching lines @@
   void adjust_edge_weight(double scale_factor) { edge_weight_ *= scale_factor; }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     // Goto instruction can be used as a deoptimization target when LICM
     // hoists instructions out of the loop.
     return true;
   }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
   ParallelMoveInstr* parallel_move() const { return parallel_move_; }
 
   bool HasParallelMove() const { return parallel_move_ != NULL; }
 
   bool HasNonRedundantParallelMove() const {
     return HasParallelMove() && !parallel_move()->IsRedundant();
   }
 
   ParallelMoveInstr* GetParallelMove() {
@@ skipping 55 matching lines @@
 
   virtual intptr_t SuccessorCount() const { return successors_.length(); }
   virtual TargetEntryInstr* SuccessorAt(intptr_t index) const {
     ASSERT(index < SuccessorCount());
     return successors_[index];
   }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
   virtual bool CanBecomeDeoptimizationTarget() const { return false; }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
   Value* offset() const { return inputs_[0]; }
   void ComputeOffsetTable();
 
   PRINT_TO_SUPPORT
 
  private:
   GrowableArray<TargetEntryInstr*> successors_;
   TypedData& offsets_;
 };
@@ skipping 70 matching lines @@
   intptr_t operation_cid_;  // Set by optimizer.
 
   DISALLOW_COPY_AND_ASSIGN(ComparisonInstr);
 };
 
 class PureComparison : public ComparisonInstr {
  public:
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
  protected:
   PureComparison(TokenPosition token_pos, Token::Kind kind, intptr_t deopt_id)
       : ComparisonInstr(token_pos, kind, deopt_id) {}
 };
 
 template <intptr_t N,
           typename ThrowsTrait,
           template <typename Impure, typename Pure> class CSETrait = NoCSE>
 class TemplateComparison
@@ skipping 42 matching lines @@
   virtual TokenPosition token_pos() const { return comparison_->token_pos(); }
 
   virtual bool ComputeCanDeoptimize() const {
     return comparison()->ComputeCanDeoptimize();
   }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     return comparison()->CanBecomeDeoptimizationTarget();
   }
 
-  virtual EffectSet Effects() const { return comparison()->Effects(); }
+  virtual bool HasSideEffects() const { return comparison()->HasSideEffects(); }
 
   ComparisonInstr* comparison() const { return comparison_; }
   void SetComparison(ComparisonInstr* comp);
 
   virtual intptr_t DeoptimizationTarget() const {
     return comparison()->DeoptimizationTarget();
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t i) const {
     return comparison()->RequiredInputRepresentation(i);
@@ skipping 65 matching lines @@
   virtual CompileType ComputeType() const;
   virtual bool RecomputeType();
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   void set_constrained_type(CompileType* type) { constrained_type_ = type; }
   CompileType* constrained_type() const { return constrained_type_; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
  private:
   CompileType* constrained_type_;
   DISALLOW_COPY_AND_ASSIGN(RedefinitionInstr);
 };
 
 class ConstraintInstr : public TemplateDefinition<1, NoThrow> {
  public:
   ConstraintInstr(Value* value, Range* constraint)
       : constraint_(constraint), target_(NULL) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(Constraint)
 
   virtual CompileType ComputeType() const;
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const {
     UNREACHABLE();
     return false;
   }
 
   Value* value() const { return inputs_[0]; }
   Range* constraint() const { return constraint_; }
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
@@ skipping 156 matching lines @@
  public:
   enum SpecialParameterKind { kContext, kTypeArgs };
   SpecialParameterInstr(SpecialParameterKind kind, intptr_t deopt_id)
       : TemplateDefinition(deopt_id), kind_(kind) {}
 
   DECLARE_INSTRUCTION(SpecialParameter)
   virtual CompileType ComputeType() const;
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return kind() == other->AsSpecialParameter()->kind();
   }
   SpecialParameterKind kind() const { return kind_; }
 
  private:
   const SpecialParameterKind kind_;
   DISALLOW_COPY_AND_ASSIGN(SpecialParameterInstr);
 };
@@ skipping 89 matching lines @@
     SetInputAt(0, function);
   }
 
   DECLARE_INSTRUCTION(ClosureCall)
 
   // TODO(kmillikin): implement exact call counts for closure calls.
   virtual intptr_t CallCount() const { return 1; }
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
-  virtual EffectSet Effects() const { return EffectSet::All(); }
+  virtual bool HasSideEffects() const { return true; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ClosureCallInstr);
 };
 
 class InstanceCallInstr : public TemplateDartCall<0> {
  public:
   InstanceCallInstr(
@@ skipping 55 matching lines @@
   virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     // Instance calls that are specialized by the optimizer need a
     // deoptimization descriptor before the call.
     return true;
   }
 
-  virtual EffectSet Effects() const { return EffectSet::All(); }
+  virtual bool HasSideEffects() const { return true; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
   bool MatchesCoreName(const String& name);
 
   RawFunction* ResolveForReceiverClass(const Class& cls);
 
  protected:
   friend class JitOptimizer;
   void set_ic_data(ICData* value) { ic_data_ = value; }
@@ skipping 59 matching lines @@
   // 10 calls in the CallCount above, but the heuristics need to know that the
   // last two cids cover 7% and 3% of the calls, not 70% and 30%.
   intptr_t total_call_count() { return total_call_count_; }
 
   void set_total_call_count(intptr_t count) { total_call_count_ = count; }
 
   DECLARE_INSTRUCTION(PolymorphicInstanceCall)
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
-  virtual EffectSet Effects() const { return EffectSet::All(); }
+  virtual bool HasSideEffects() const { return true; }
 
   virtual Definition* Canonicalize(FlowGraph* graph);
 
   static RawType* ComputeRuntimeType(const CallTargets& targets);
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   InstanceCallInstr* instance_call_;
   const CallTargets& targets_;
@@ skipping 235 matching lines @@
 
   virtual CompileType ComputeType() const;
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   ComparisonInstr* comparison() const { return comparison_; }
   intptr_t if_true() const { return if_true_; }
   intptr_t if_false() const { return if_false_; }
 
   virtual bool AllowsCSE() const { return comparison()->AllowsCSE(); }
-  virtual EffectSet Effects() const { return comparison()->Effects(); }
+  virtual bool HasSideEffects() const { return comparison()->HasSideEffects(); }
   virtual EffectSet Dependencies() const {
     return comparison()->Dependencies();
   }
   virtual bool AttributesEqual(Instruction* other) const {
     IfThenElseInstr* other_if_then_else = other->AsIfThenElse();
     return (comparison()->tag() == other_if_then_else->comparison()->tag()) &&
            comparison()->AttributesEqual(other_if_then_else->comparison()) &&
            (if_true_ == other_if_then_else->if_true_) &&
            (if_false_ == other_if_then_else->if_false_);
   }
@@ skipping 95 matching lines @@
   }
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     // Static calls that are specialized by the optimizer (e.g. sqrt) need a
     // deoptimization descriptor before the call.
     return true;
   }
 
-  virtual EffectSet Effects() const { return EffectSet::All(); }
+  virtual bool HasSideEffects() const { return true; }
 
   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;
   }
 
   bool IsRecognizedFactory() const { return is_known_list_constructor(); }
 
@@ skipping 21 matching lines @@
   LoadLocalInstr(const LocalVariable& local, TokenPosition token_pos)
       : local_(local), is_last_(false), token_pos_(token_pos) {}
 
   DECLARE_INSTRUCTION(LoadLocal)
   virtual CompileType ComputeType() const;
 
   const LocalVariable& local() const { return local_; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
-  virtual EffectSet Effects() const {
+  virtual bool HasSideEffects() const {
     UNREACHABLE();  // Eliminated by SSA construction.
-    return EffectSet::None();
+    return false;
   }
 
   void mark_last() { is_last_ = true; }
   bool is_last() const { return is_last_; }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
@@ skipping 22 matching lines @@
   }
 
   Value* value() const { return value_; }
 
   intptr_t num_temps() const { return num_temps_; }
 
   virtual CompileType ComputeType() const;
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
-  virtual EffectSet Effects() const {
+  virtual bool HasSideEffects() const {
     UNREACHABLE();  // Eliminated by SSA construction.
-    return EffectSet::None();
+    return false;
   }
 
   virtual bool MayThrow() const {
     UNREACHABLE();
     return false;
   }
 
   virtual TokenPosition token_pos() const { return TokenPosition::kTempMove; }
 
   PRINT_OPERANDS_TO_SUPPORT
@@ skipping 23 matching lines @@
   Value* value() const { return inputs_[0]; }
 
   virtual bool ComputeCanDeoptimize() const { 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 {
+  virtual bool HasSideEffects() const {
     UNREACHABLE();  // Eliminated by SSA construction.
-    return EffectSet::None();
+    return false;
   }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const LocalVariable& local_;
   bool is_dead_;
   bool is_last_;
@@ skipping 29 matching lines @@
   const String& native_name() const { return *native_name_; }
   const Function& function() const { return *function_; }
   NativeFunction native_c_function() const { return native_c_function_; }
   bool is_bootstrap_native() const { return is_bootstrap_native_; }
   bool is_auto_scope() const { return is_auto_scope_; }
   bool link_lazily() const { return link_lazily_; }
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
-  virtual EffectSet Effects() const { return EffectSet::All(); }
+  virtual bool HasSideEffects() const { return true; }
 
   void SetupNative();
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   void set_native_c_function(NativeFunction value) {
     native_c_function_ = value;
   }
 
@@ skipping 17 matching lines @@
                       RawPcDescriptors::Kind stub_kind,
                       intptr_t deopt_id)
       : TemplateInstruction<0, NoThrow>(deopt_id),
         token_pos_(token_pos),
         stub_kind_(stub_kind) {}
 
   DECLARE_INSTRUCTION(DebugStepCheck)
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   virtual bool ComputeCanDeoptimize() const { return false; }
-  virtual EffectSet Effects() const { return EffectSet::All(); }
+  virtual bool HasSideEffects() const { return true; }
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
  private:
   const TokenPosition token_pos_;
   const RawPcDescriptors::Kind stub_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(DebugStepCheckInstr);
 };
 
 enum StoreBarrierType { kNoStoreBarrier, kEmitStoreBarrier };
@@ skipping 50 matching lines @@
   }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   // May require a deoptimization target for input conversions.
   virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
   // 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(); }
+  virtual bool HasSideEffects() const { return false; }
 
   bool IsUnboxedStore() const;
 
   bool IsPotentialUnboxedStore() const;
 
   virtual Representation RequiredInputRepresentation(intptr_t index) const;
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
@@ skipping 86 matching lines @@
 
   DECLARE_INSTRUCTION(LoadStaticField)
   virtual CompileType ComputeType() const;
 
   const Field& StaticField() const;
 
   Value* field_value() const { return inputs_[0]; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
-  virtual bool AllowsCSE() const { return StaticField().is_final(); }
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool AllowsCSE() const {
+    return StaticField().is_final() && !FLAG_fields_may_be_reset;
+  }
+  virtual bool HasSideEffects() const { return false; }
   virtual EffectSet Dependencies() const;
   virtual bool AttributesEqual(Instruction* other) const;
 
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const TokenPosition token_pos_;
 
@@ skipping 16 matching lines @@
   DECLARE_INSTRUCTION(StoreStaticField)
 
   const Field& field() const { return field_; }
   Value* value() const { return inputs_[kValuePos]; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   // 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(); }
+  virtual bool HasSideEffects() const { return false; }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   bool CanValueBeSmi() const {
     const intptr_t cid = value()->Type()->ToNullableCid();
     // Write barrier is skipped for nullable and non-nullable smis.
     ASSERT(cid != kSmiCid);
@@ skipping 43 matching lines @@
   intptr_t class_id() const { return class_id_; }
   bool aligned() const { return alignment_ == kAlignedAccess; }
 
   virtual bool ComputeCanDeoptimize() const {
     return GetDeoptId() != Thread::kNoDeoptId;
   }
 
   virtual Representation representation() const;
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
  private:
   const intptr_t index_scale_;
   const intptr_t class_id_;
   const AlignmentType alignment_;
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadIndexedInstr);
 };
 
@@ skipping 48 matching lines @@
   bool can_pack_into_smi() const {
     return element_count() <= kSmiBits / (index_scale() * kBitsPerByte);
   }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return representation_; }
   void set_representation(Representation repr) { representation_ = repr; }
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
  private:
   const intptr_t class_id_;
   const TokenPosition token_pos_;
   const intptr_t element_count_;
   Representation representation_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadCodeUnitsInstr);
 };
 
@@ skipping 50 matching lines @@
         token_pos_(token_pos),
         function_(Function::ZoneHandle()) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   virtual CompileType ComputeType() const;
   // Issues a static call to Dart code which calls toString on objects.
-  virtual EffectSet Effects() const { return EffectSet::All(); }
+  virtual bool HasSideEffects() const { return true; }
   virtual bool ComputeCanDeoptimize() const { return true; }
 
   const Function& CallFunction() const;
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   DECLARE_INSTRUCTION(StringInterpolate)
 
  private:
   const TokenPosition token_pos_;
@@ skipping 37 matching lines @@
   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 GetDeoptId();
   }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
  private:
   const StoreBarrierType emit_store_barrier_;
   const intptr_t index_scale_;
   const intptr_t class_id_;
   const AlignmentType alignment_;
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreIndexedInstr);
 };
 
 // Note overrideable, built-in: value ? false : true.
 class BooleanNegateInstr : public TemplateDefinition<1, NoThrow> {
  public:
   explicit BooleanNegateInstr(Value* value) { SetInputAt(0, value); }
 
   DECLARE_INSTRUCTION(BooleanNegate)
   virtual CompileType ComputeType() const;
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BooleanNegateInstr);
 };
 
 class InstanceOfInstr : public TemplateDefinition<3, Throws> {
  public:
   InstanceOfInstr(TokenPosition token_pos,
@@ skipping 14 matching lines @@
 
   Value* value() const { return inputs_[0]; }
   Value* instantiator_type_arguments() const { return inputs_[1]; }
   Value* function_type_arguments() const { return inputs_[2]; }
 
   const AbstractType& type() const { return type_; }
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const TokenPosition token_pos_;
   Value* value_;
   Value* type_arguments_;
   const AbstractType& type_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceOfInstr);
@@ skipping 24 matching lines @@
   const Class& cls() const { return cls_; }
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   const Function& closure_function() const { return closure_function_; }
   void set_closure_function(const Function& function) {
     closure_function_ ^= function.raw();
   }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
   virtual AliasIdentity Identity() const { return identity_; }
   virtual void SetIdentity(AliasIdentity identity) { identity_ = identity; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const TokenPosition token_pos_;
   const Class& cls_;
   ZoneGrowableArray<PushArgumentInstr*>* const arguments_;
@@ skipping 13 matching lines @@
         identity_(AliasIdentity::Unknown()) {}
 
   DECLARE_INSTRUCTION(AllocateUninitializedContext)
   virtual CompileType ComputeType() const;
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   intptr_t num_context_variables() const { return num_context_variables_; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
   virtual AliasIdentity Identity() const { return identity_; }
   virtual void SetIdentity(AliasIdentity identity) { identity_ = identity; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const TokenPosition token_pos_;
   const intptr_t num_context_variables_;
   AliasIdentity identity_;
@@ skipping 64 matching lines @@
   // instructions are still in the graph. To avoid any redundant boxing
   // operations inserted by that pass we should indicate that this
   // instruction can cope with any representation as it is essentially
   // an environment use.
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(0 <= idx && idx < InputCount());
     return kNoRepresentation;
   }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
   Location* locations() { return locations_; }
   void set_locations(Location* locations) { locations_ = locations; }
 
   virtual bool MayThrow() const { return false; }
 
   void RemapRegisters(intptr_t* cpu_reg_slots, intptr_t* fpu_reg_slots);
 
   bool was_visited_for_liveness() const { return visited_for_liveness_; }
   void mark_visited_for_liveness() { visited_for_liveness_ = true; }
@@ skipping 37 matching lines @@
   virtual CompileType ComputeType() const;
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   Value* element_type() const { return inputs_[kElementTypePos]; }
   Value* num_elements() const { return inputs_[kLengthPos]; }
 
   // Throw needs environment, which is created only if instruction can
   // deoptimize.
   virtual bool ComputeCanDeoptimize() const { return MayThrow(); }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
   virtual AliasIdentity Identity() const { return identity_; }
   virtual void SetIdentity(AliasIdentity identity) { identity_ = identity; }
 
  private:
   const TokenPosition token_pos_;
   AliasIdentity identity_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateArrayInstr);
 };
@@ skipping 17 matching lines @@
     ASSERT(idx == 0);
     // The object may be tagged or untagged (for external objects).
     return kNoRepresentation;
   }
 
   Value* object() const { return inputs_[0]; }
   intptr_t offset() const { return offset_; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   intptr_t offset_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadUntaggedInstr);
 };
 
 class LoadClassIdInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
@@ skipping 96 matching lines @@
   // instance has the field.
   bool Evaluate(const Object& instance_value, Object* result);
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   static MethodRecognizer::Kind RecognizedKindFromArrayCid(intptr_t cid);
 
   static bool IsFixedLengthArrayCid(intptr_t cid);
 
   virtual bool AllowsCSE() const { return immutable_; }
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
   virtual EffectSet Dependencies() const;
   virtual bool AttributesEqual(Instruction* other) const;
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const intptr_t offset_in_bytes_;
   const AbstractType& type_;
   intptr_t result_cid_;
   bool immutable_;
@@ skipping 20 matching lines @@
 
   DECLARE_INSTRUCTION(InstantiateType)
 
   Value* instantiator_type_arguments() const { return inputs_[0]; }
   Value* function_type_arguments() const { return inputs_[1]; }
   const AbstractType& type() const { return type_; }
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const TokenPosition token_pos_;
   const AbstractType& type_;
 
   DISALLOW_COPY_AND_ASSIGN(InstantiateTypeInstr);
 };
 
@@ skipping 17 matching lines @@
   DECLARE_INSTRUCTION(InstantiateTypeArguments)
 
   Value* instantiator_type_arguments() const { return inputs_[0]; }
   Value* function_type_arguments() const { return inputs_[1]; }
   const TypeArguments& type_arguments() const { return type_arguments_; }
   const Class& instantiator_class() const { return instantiator_class_; }
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const TokenPosition token_pos_;
   const TypeArguments& type_arguments_;
   const Class& instantiator_class_;
 
   DISALLOW_COPY_AND_ASSIGN(InstantiateTypeArgumentsInstr);
 };
 
 class AllocateContextInstr : public TemplateDefinition<0, NoThrow> {
  public:
   AllocateContextInstr(TokenPosition token_pos, intptr_t num_context_variables)
       : token_pos_(token_pos), num_context_variables_(num_context_variables) {}
 
   DECLARE_INSTRUCTION(AllocateContext)
   virtual CompileType ComputeType() const;
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   intptr_t num_context_variables() const { return num_context_variables_; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const TokenPosition token_pos_;
   const intptr_t num_context_variables_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateContextInstr);
 };
 
 class InitStaticFieldInstr : public TemplateInstruction<1, Throws> {
  public:
   InitStaticFieldInstr(Value* input, const Field& field, intptr_t deopt_id)
       : TemplateInstruction(deopt_id), field_(field) {
     SetInputAt(0, input);
     CheckField(field);
   }
 
   virtual TokenPosition token_pos() const { return field_.token_pos(); }
   const Field& field() const { return field_; }
 
   DECLARE_INSTRUCTION(InitStaticField)
 
   virtual bool ComputeCanDeoptimize() const { return true; }
-  virtual EffectSet Effects() const { return EffectSet::All(); }
+  virtual bool HasSideEffects() const { return true; }
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(InitStaticFieldInstr);
 };
 
 class CloneContextInstr : public TemplateDefinition<1, NoThrow> {
  public:
   CloneContextInstr(TokenPosition token_pos,
                     Value* context_value,
                     intptr_t deopt_id)
       : TemplateDefinition(deopt_id), token_pos_(token_pos) {
     SetInputAt(0, context_value);
   }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   Value* context_value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(CloneContext)
   virtual CompileType ComputeType() const;
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
  private:
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(CloneContextInstr);
 };
 
 class CheckEitherNonSmiInstr : public TemplateInstruction<2, NoThrow, Pure> {
  public:
   CheckEitherNonSmiInstr(Value* left, Value* right, intptr_t deopt_id)
@@ skipping 2058 matching lines @@
     SetInputAt(1, right);
   }
 
   InstanceCallInstr* call() const { return call_; }
   Token::Kind op_kind() const { return op_kind_; }
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
-  virtual EffectSet Effects() const { return EffectSet::All(); }
+  virtual bool HasSideEffects() const { return true; }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   PRINT_OPERANDS_TO_SUPPORT
 
   DECLARE_INSTRUCTION(CheckedSmiOp)
 
  private:
   InstanceCallInstr* call_;
   const Token::Kind op_kind_;
@@ skipping 20 matching lines @@
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   virtual void NegateComparison() {
     ComparisonInstr::NegateComparison();
     is_negated_ = !is_negated_;
   }
 
   bool is_negated() const { return is_negated_; }
 
-  virtual EffectSet Effects() const { return EffectSet::All(); }
+  virtual bool HasSideEffects() const { return true; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
   DECLARE_INSTRUCTION(CheckedSmiComparison)
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler, BranchInstr* branch);
 
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels);
 
@@ skipping 375 matching lines @@
   virtual TokenPosition token_pos() const { return token_pos_; }
   bool in_loop() const { return loop_depth_ > 0; }
   intptr_t loop_depth() const { return loop_depth_; }
 
   DECLARE_INSTRUCTION(CheckStackOverflow)
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const TokenPosition token_pos_;
   const intptr_t loop_depth_;
   const Kind kind_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckStackOverflowInstr);
 };
@@ skipping 91 matching lines @@
   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 ComputeCanDeoptimize() const { return true; }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
 
  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, NoThrow, Pure> {
@@ skipping 300 matching lines @@
 
   bool IsDeoptIfNull() const;
   bool IsDeoptIfNotNull() const;
 
   bool IsBitTest() const;
   static bool IsCompactCidRange(const Cids& cids);
   intptr_t ComputeCidMask() const;
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
   virtual bool AttributesEqual(Instruction* other) const;
 
   bool licm_hoisted() const { return licm_hoisted_; }
   void set_licm_hoisted(bool value) { licm_hoisted_ = value; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const Cids& cids_;
   bool licm_hoisted_;
@@ skipping 59 matching lines @@
   const CidRange& cids() const { return cids_; }
 
   DECLARE_INSTRUCTION(CheckClassId)
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   bool Contains(intptr_t cid) const;
 
   CidRange cids_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckClassIdInstr);
@@ skipping 45 matching lines @@
  public:
   GenericCheckBoundInstr(Value* length, Value* index, intptr_t deopt_id)
       : TemplateInstruction(deopt_id) {
     SetInputAt(kLengthPos, length);
     SetInputAt(kIndexPos, index);
   }
 
   Value* length() const { return inputs_[kLengthPos]; }
   Value* index() const { return inputs_[kIndexPos]; }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
   DECLARE_INSTRUCTION(GenericCheckBound)
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
   // Give a name to the location/input indices.
   enum { kLengthPos = 0, kIndexPos = 1 };
 
  private:
@@ skipping 30 matching lines @@
 
   virtual bool ComputeCanDeoptimize() const;
 
   virtual Representation representation() const { return to(); }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return from();
   }
 
-  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool HasSideEffects() const { return false; }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     ASSERT(other->IsUnboxedIntConverter());
     UnboxedIntConverterInstr* converter = other->AsUnboxedIntConverter();
     return (converter->from() == from()) && (converter->to() == to()) &&
            (converter->is_truncating() == is_truncating());
   }
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
@@ skipping 271 matching lines @@
 #define DEFINE_UNIMPLEMENTED_INSTRUCTION(Name)                                 \
   LocationSummary* Name::MakeLocationSummary(Zone* zone, bool opt) const {     \
     UNIMPLEMENTED();                                                           \
     return NULL;                                                               \
   }                                                                            \
   void Name::EmitNativeCode(FlowGraphCompiler* compiler) { UNIMPLEMENTED(); }
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_INTERMEDIATE_LANGUAGE_H_