Optimize functions containing try-catch.

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 808 matching lines @@
   bool NeedsEnvironment() const {
     return CanDeoptimize() || CanBeDeoptimizationTarget();
   }
 
   virtual bool CanBeDeoptimizationTarget() const {
     return false;
   }
 
   void InheritDeoptTargetAfter(Instruction* other);
 
+  virtual bool MayThrow() const  = 0;

[Kevin Millikin (Google), 2013/05/08 11:42:00]

There's an extra space after const for some reason.

[Florian Schneider, 2013/05/08 17:10:55]

Done.

+
  protected:
   // Fetch deopt id without checking if this computation can deoptimize.
   intptr_t GetDeoptId() const {
     return deopt_id_;
   }
 
  private:
   friend class Definition;  // Needed for InsertBefore, InsertAfter.
 
   // Classes that set deopt_id_.
@@ skipping 170 matching lines @@
 
   MoveOperands* MoveOperandsAt(intptr_t index) const { return moves_[index]; }
 
   void SetSrcSlotAt(intptr_t index, const Location& loc);
   void SetDestSlotAt(intptr_t index, const Location& loc);
 
   intptr_t NumMoves() const { return moves_.length(); }
 
   virtual void PrintTo(BufferFormatter* f) const;
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   GrowableArray<MoveOperands*> moves_;   // Elements cannot be null.
 
   DISALLOW_COPY_AND_ASSIGN(ParallelMoveInstr);
 };
 
 
 // Basic block entries are administrative nodes.  There is a distinguished
 // graph entry with no predecessor.  Joins are the only nodes with multiple
 // predecessors.  Targets are all other basic block entries.  The types
@@ skipping 85 matching lines @@
     // 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 EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return false; }
+
   intptr_t try_index() const { return try_index_; }
 
   BitVector* loop_info() const { return loop_info_; }
   void set_loop_info(BitVector* loop_info) {
     loop_info_ = loop_info;
   }
 
   virtual BlockEntryInstr* GetBlock() const {
     return const_cast<BlockEntryInstr*>(this);
   }
@@ skipping 106 matching lines @@
   virtual intptr_t PredecessorCount() const { return 0; }
   virtual BlockEntryInstr* PredecessorAt(intptr_t index) const {
     UNREACHABLE();
     return NULL;
   }
   virtual intptr_t SuccessorCount() const;
   virtual BlockEntryInstr* SuccessorAt(intptr_t index) const;
 
   void AddCatchEntry(CatchBlockEntryInstr* entry) { catch_entries_.Add(entry); }
 
+  CatchBlockEntryInstr* GetCatchEntry(intptr_t index);
+
   virtual void PrepareEntry(FlowGraphCompiler* compiler);
 
   GrowableArray<Definition*>* initial_definitions() {
     return &initial_definitions_;
   }
   ConstantInstr* constant_null();
 
   intptr_t spill_slot_count() const { return spill_slot_count_; }
   void set_spill_slot_count(intptr_t count) {
     ASSERT(count >= 0);
     spill_slot_count_ = count;
   }
 
+  // Number of stack slots reserved for compiling try-catch. For functions
+  // without try-catch, this is 0. Otherwise, it is the number of local
+  // variables.
+  intptr_t fixed_slot_count() const { return fixed_slot_count_; }
+  void set_fixed_slot_count(intptr_t count) {
+    ASSERT(count >= 0);
+    fixed_slot_count_ = count;
+  }
   TargetEntryInstr* normal_entry() const { return normal_entry_; }
 
   const ParsedFunction& parsed_function() const {
     return parsed_function_;
   }
 
+  const GrowableArray<CatchBlockEntryInstr*>& catch_entries() const {
+    return catch_entries_;
+  }
+
   virtual void PrintTo(BufferFormatter* f) const;
 
  private:
   virtual void ClearPredecessors() {}
   virtual void AddPredecessor(BlockEntryInstr* predecessor) { UNREACHABLE(); }
 
   const ParsedFunction& parsed_function_;
   TargetEntryInstr* normal_entry_;
   GrowableArray<CatchBlockEntryInstr*> catch_entries_;
   GrowableArray<Definition*> initial_definitions_;
   intptr_t spill_slot_count_;
+  intptr_t fixed_slot_count_;  // For try-catch in optimized code.
 
   DISALLOW_COPY_AND_ASSIGN(GraphEntryInstr);
 };
 
 
 class JoinEntryInstr : public BlockEntryInstr {
  public:
   JoinEntryInstr(intptr_t block_id, intptr_t try_index)
       : BlockEntryInstr(block_id, try_index),
         predecessors_(2),  // Two is the assumed to be the common case.
@@ skipping 119 matching lines @@
   virtual BlockEntryInstr* PredecessorAt(intptr_t index) const {
     ASSERT((index == 0) && (predecessor_ != NULL));
     return predecessor_;
   }
 
   // Returns try index for the try block to which this catch handler
   // corresponds.
   intptr_t catch_try_index() const {
     return catch_try_index_;
   }
+  GrowableArray<Definition*>* initial_definitions() {
+    return &initial_definitions_;
+  }
 
   virtual void PrepareEntry(FlowGraphCompiler* compiler);
 
   virtual void PrintTo(BufferFormatter* f) const;
 
  private:
   friend class BlockEntryInstr;  // Access to predecessor_ when inlining.
 
   virtual void ClearPredecessors() { predecessor_ = NULL; }
   virtual void AddPredecessor(BlockEntryInstr* predecessor) {
     ASSERT(predecessor_ == NULL);
     predecessor_ = predecessor;
   }
 
   BlockEntryInstr* predecessor_;
   const Array& catch_handler_types_;
   const intptr_t catch_try_index_;
+  GrowableArray<Definition*> initial_definitions_;
 
   DISALLOW_COPY_AND_ASSIGN(CatchBlockEntryInstr);
 };
 
 
 // Abstract super-class of all instructions that define a value (Bind, Phi).
 class Definition : public Instruction {
  public:
   enum UseKind { kEffect, kValue };
 
@@ skipping 208 matching lines @@
   virtual void InferRange();
 
   BitVector* reaching_defs() const {
     return reaching_defs_;
   }
 
   void set_reaching_defs(BitVector* reaching_defs) {
     reaching_defs_ = reaching_defs;
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   // Direct access to inputs_ in order to resize it due to unreachable
   // predecessors.
   friend class ConstantPropagator;
 
   void RawSetInputAt(intptr_t i, Value* value) { inputs_[i] = value; }
 
   JoinEntryInstr* block_;
   GrowableArray<Value*> inputs_;
   bool is_alive_;
   Representation representation_;
 
   BitVector* reaching_defs_;
 
   DISALLOW_COPY_AND_ASSIGN(PhiInstr);
 };
 
 
 class ParameterInstr : public Definition {
  public:
-  ParameterInstr(intptr_t index, GraphEntryInstr* block)
+  ParameterInstr(intptr_t index, BlockEntryInstr* block)
       : index_(index), block_(block) { }
 
   DECLARE_INSTRUCTION(Parameter)
 
   intptr_t index() const { return index_; }
 
   // Get the block entry for that instruction.
   virtual BlockEntryInstr* GetBlock() const { return block_; }
 
   virtual intptr_t ArgumentCount() const { return 0; }
@@ skipping 11 matching lines @@
 
   virtual intptr_t Hashcode() const {
     UNREACHABLE();
     return 0;
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual CompileType ComputeType() const;
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
 
   const intptr_t index_;
-  GraphEntryInstr* block_;
+  BlockEntryInstr* block_;
 
   DISALLOW_COPY_AND_ASSIGN(ParameterInstr);
 };
 
 
 class PushArgumentInstr : public Definition {
  public:
   explicit PushArgumentInstr(Value* value) : locs_(NULL) {
     SetInputAt(0, value);
     set_use_kind(kEffect);  // Override the default.
@@ skipping 24 matching lines @@
     UNREACHABLE();
     return 0;
   }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     ASSERT(i == 0);
     value_ = value;
   }
 
   Value* value_;
   LocationSummary* locs_;
 
   DISALLOW_COPY_AND_ASSIGN(PushArgumentInstr);
@@ skipping 22 matching lines @@
   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 EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return false; }
+
  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 EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return true; }
+
  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 EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return true; }
+
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(ReThrowInstr);
 };
 
 
 class GotoInstr : public TemplateInstruction<0> {
  public:
   explicit GotoInstr(JoinEntryInstr* entry)
@@ skipping 29 matching lines @@
 
   ParallelMoveInstr* GetParallelMove() {
     if (parallel_move_ == NULL) {
       parallel_move_ = new ParallelMoveInstr();
     }
     return parallel_move_;
   }
 
   virtual void PrintTo(BufferFormatter* f) const;
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   JoinEntryInstr* successor_;
 
   // Parallel move that will be used by linear scan register allocator to
   // connect live ranges at the end of the block and resolve phis.
   ParallelMoveInstr* parallel_move_;
 };
 
 
 class ControlInstruction : public Instruction {
@@ skipping 74 matching lines @@
   void set_constant_target(TargetEntryInstr* target) {
     ASSERT(target == true_successor() || target == false_successor());
     constant_target_ = target;
   }
   TargetEntryInstr* constant_target() const {
     return constant_target_;
   }
 
   virtual void InheritDeoptTarget(Instruction* other);
 
+  virtual bool MayThrow() const;
+
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value);
 
   ComparisonInstr* comparison_;
   const bool is_checked_;
 
   ConstrainedCompileType* constrained_type_;
 
   TargetEntryInstr* constant_target_;
 
@@ skipping 10 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 EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(StoreContextInstr);
 };
 
 
 template<intptr_t N>
 class TemplateDefinition : public Definition {
  public:
   TemplateDefinition<N>() : locs_(NULL) { }
 
@@ skipping 33 matching lines @@
 
   Value* value() const { return inputs_[0]; }
 
   virtual CompileType ComputeType() const;
   virtual bool RecomputeType();
 
   virtual bool CanDeoptimize() const { return false; }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(RedefinitionInstr);
 };
 
 
 class RangeBoundary : public ValueObject {
  public:
   enum Kind { kUnknown, kSymbol, kConstant };
 
   RangeBoundary() : kind_(kUnknown), value_(0), offset_(0) { }
@@ skipping 171 matching lines @@
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual bool AttributesEqual(Instruction* other) const {
     UNREACHABLE();
     return false;
   }
 
+  virtual bool MayThrow() const { return false; }
+
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   Value* value() const { return inputs_[0]; }
   Range* constraint() const { return constraint_; }
 
   virtual void InferRange();
 
   void AddDependency(Definition* defn) {
     Value* val = new Value(defn);
     defn->AddInputUse(val);
@@ skipping 38 matching lines @@
 
   virtual bool CanDeoptimize() 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 MayThrow() const { return false; }
+
  private:
   const Object& value_;
 
   DISALLOW_COPY_AND_ASSIGN(ConstantInstr);
 };
 
 
 class AssertAssignableInstr : public TemplateDefinition<3> {
  public:
   AssertAssignableInstr(intptr_t token_pos,
@@ skipping 31 matching lines @@
 
   virtual bool CanDeoptimize() const { return true; }
 
   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;
 
+  virtual bool MayThrow() const { return true; }
+
  private:
   const intptr_t token_pos_;
   AbstractType& dst_type_;
   const String& dst_name_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertAssignableInstr);
 };
 
 
 class AssertBooleanInstr : public TemplateDefinition<1> {
@@ skipping 13 matching lines @@
 
   virtual bool CanDeoptimize() const { return true; }
 
   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 true; }
 
+  virtual bool MayThrow() const { return true; }
+
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertBooleanInstr);
 };
 
 
 class ArgumentDefinitionTestInstr : public TemplateDefinition<1> {
  public:
   ArgumentDefinitionTestInstr(ArgumentDefinitionTestNode* node,
@@ skipping 14 matching lines @@
   }
 
   Value* saved_arguments_descriptor() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return true; }
+
  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 EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
  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 EffectSet Effects() const { return EffectSet::All(); }
 
+  virtual bool MayThrow() const { return true; }
+
  private:
   const ClosureCallNode& ast_node_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(ClosureCallInstr);
 };
 
 
 class InstanceCallInstr : public TemplateDefinition<0> {
  public:
@@ skipping 42 matching lines @@
   }
   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 EffectSet Effects() const { return EffectSet::All(); }
 
+  virtual bool MayThrow() const { return true; }
+
  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.
   ZoneGrowableArray<PushArgumentInstr*>* const arguments_;
@@ skipping 29 matching lines @@
   DECLARE_INSTRUCTION(PolymorphicInstanceCall)
 
   const ICData& ic_data() const { return ic_data_; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::All(); }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool MayThrow() const { return true; }
+
  private:
   InstanceCallInstr* instance_call_;
   const ICData& ic_data_;
   const bool with_checks_;
 
   DISALLOW_COPY_AND_ASSIGN(PolymorphicInstanceCallInstr);
 };
 
 
 class ComparisonInstr : public TemplateDefinition<2> {
@@ skipping 71 matching lines @@
   return comparison()->DeoptimizationTarget();
 }
 
 
 inline Representation BranchInstr::RequiredInputRepresentation(
     intptr_t i) const {
   return comparison()->RequiredInputRepresentation(i);
 }
 
 
+inline bool BranchInstr::MayThrow() const {
+  return comparison()->MayThrow();
+}
+
+
 class StrictCompareInstr : public ComparisonInstr {
  public:
   StrictCompareInstr(Token::Kind kind, Value* left, Value* right);
 
   DECLARE_INSTRUCTION(StrictCompare)
   virtual CompileType ComputeType() const;
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanBeDeoptimizationTarget() const {
@@ skipping 10 matching lines @@
 
   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;
 
+  virtual bool MayThrow() const { return false; }
+
  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 25 matching lines @@
   // Receiver class id is computed from collected ICData.
   void set_receiver_class_id(intptr_t value) { receiver_class_id_ = value; }
   intptr_t receiver_class_id() const { return receiver_class_id_; }
 
   bool IsInlinedNumericComparison() const {
     return (receiver_class_id() == kDoubleCid)
         || (receiver_class_id() == kMintCid)
         || (receiver_class_id() == kSmiCid);
   }
 
+  bool is_checked_strict_equal() const {
+    return HasICData() && ic_data()->AllTargetsHaveSameOwner(kInstanceCid);
+  }
+
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() 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();
   }
 
+  virtual bool MayThrow() const {
+    return !IsInlinedNumericComparison() && !is_checked_strict_equal();
+  }
+
  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 54 matching lines @@
     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();
   }
 
+  virtual bool MayThrow() const { return !IsInlinedNumericComparison(); }
+
  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 40 matching lines @@
   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_);
   }
 
+  virtual bool MayThrow() const { return 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 31 matching lines @@
 
   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;
   }
 
+  virtual bool MayThrow() const { return true; }
+
  private:
   const intptr_t token_pos_;
   const Function& function_;
   const Array& argument_names_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
   intptr_t result_cid_;  // For some library functions we know the result.
 
   // 'True' for recognized list constructors.
   bool is_known_list_constructor_;
 
@@ skipping 16 matching lines @@
   virtual bool CanDeoptimize() const { 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_; }
 
+  virtual bool MayThrow() const {
+    UNREACHABLE();
+    return false;
+  }
+
  private:
   const LocalVariable& local_;
   bool is_last_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadLocalInstr);
 };
 
 
 class StoreLocalInstr : public TemplateDefinition<1> {
  public:
@@ skipping 16 matching lines @@
   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();
   }
 
+  virtual bool MayThrow() const {
+    UNREACHABLE();
+    return false;
+  }
+
  private:
   const LocalVariable& local_;
   bool is_dead_;
   bool is_last_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreLocalInstr);
 };
 
 
 class NativeCallInstr : public TemplateDefinition<0> {
@@ skipping 14 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 EffectSet Effects() const { return EffectSet::All(); }
 
+  virtual bool MayThrow() const {
+    UNREACHABLE();
+    return true;
+  }
+
  private:
   const NativeBodyNode& ast_node_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeCallInstr);
 };
 
 
 enum StoreBarrierType {
   kNoStoreBarrier,
   kEmitStoreBarrier
@@ skipping 26 matching lines @@
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() 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 MayThrow() const { return false; }
+
  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_;
@@ skipping 24 matching lines @@
 
   virtual Instruction* Canonicalize(FlowGraphOptimizer* optimizer);
 
   virtual void PrintOperandsTo(BufferFormatter* f) 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;
 
+  virtual bool MayThrow() const { return false; }
+
  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 AllowsCSE() const { return field_.is_final(); }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const;
   virtual bool AttributesEqual(Instruction* other) const;
 
+  virtual bool MayThrow() const { return false; }
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadStaticFieldInstr);
 };
 
 
 class StoreStaticFieldInstr : public TemplateDefinition<1> {
  public:
   StoreStaticFieldInstr(const Field& field, Value* value)
@@ skipping 10 matching lines @@
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() 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 MayThrow() const { return false; }
+
  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 39 matching lines @@
 
 
   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 MayThrow() const { return false; }
+
  private:
   const intptr_t index_scale_;
   const intptr_t class_id_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadIndexedInstr);
 };
 
 
 class StringFromCharCodeInstr : public TemplateDefinition<1> {
  public:
@@ skipping 12 matching lines @@
 
   virtual bool CanDeoptimize() 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_;
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const intptr_t cid_;
 
   DISALLOW_COPY_AND_ASSIGN(StringFromCharCodeInstr);
 };
 
 
 class StoreIndexedInstr : public TemplateDefinition<3> {
  public:
   StoreIndexedInstr(Value* array,
@@ skipping 34 matching lines @@
   }
 
   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(); }
 
+  virtual bool MayThrow() const { return false; }
+
  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 EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(BooleanNegateInstr);
 };
 
 
 class InstanceOfInstr : public TemplateDefinition<3> {
  public:
   InstanceOfInstr(intptr_t token_pos,
                   Value* value,
                   Value* instantiator,
@@ skipping 21 matching lines @@
   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 EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return true; }
+
  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 21 matching lines @@
 
   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 EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return false; }
+
   // If the result of the allocation is not stored into any field, passed
   // as an argument or used in a phi then it can't alias with any other
   // SSA value.
   enum Identity {
     kUnknown,
     kAliased,
     kNotAliased
   };
 
   Identity identity() const { return identity_; }
@@ skipping 23 matching lines @@
 
   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 EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const ConstructorCallNode& ast_node_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateObjectWithBoundsCheckInstr);
 };
 
 
 class CreateArrayInstr : public TemplateDefinition<1> {
  public:
   CreateArrayInstr(intptr_t token_pos,
@@ skipping 17 matching lines @@
   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 EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const intptr_t token_pos_;
   const intptr_t num_elements_;
   const AbstractType& type_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateArrayInstr);
 };
 
 
 class CreateClosureInstr : public TemplateDefinition<0> {
@@ skipping 15 matching lines @@
   virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const Function& function_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
   intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateClosureInstr);
 };
 
 
 class LoadUntaggedInstr : public TemplateDefinition<1> {
@@ skipping 14 matching lines @@
   virtual bool CanDeoptimize() const { return false; }
 
   // 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 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; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   intptr_t offset_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadUntaggedInstr);
 };
 
 
 class LoadClassIdInstr : public TemplateDefinition<1> {
  public:
   explicit LoadClassIdInstr(Value* object) {
@@ skipping 10 matching lines @@
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const {
     return EffectSet::Externalization();
   }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(LoadClassIdInstr);
 };
 
 
 class LoadFieldInstr : public TemplateDefinition<1> {
  public:
   LoadFieldInstr(Value* instance,
                  intptr_t offset_in_bytes,
                  const AbstractType& type,
@@ skipping 44 matching lines @@
 
   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 EffectSet Dependencies() const;
   virtual bool AttributesEqual(Instruction* other) const;
 
+  virtual bool MayThrow() const { return false; }
+
  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_;
   const Field* field_;
@@ skipping 21 matching lines @@
   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 EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const intptr_t offset_in_bytes_;
   const AbstractType& type_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreVMFieldInstr);
 };
 
 
 class InstantiateTypeArgumentsInstr : public TemplateDefinition<1> {
  public:
@@ skipping 16 matching lines @@
   }
   const Class& instantiator_class() const { return instantiator_class_; }
   intptr_t token_pos() const { return token_pos_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return true; }
+
  private:
   const intptr_t token_pos_;
   const AbstractTypeArguments& type_arguments_;
   const Class& instantiator_class_;
 
   DISALLOW_COPY_AND_ASSIGN(InstantiateTypeArgumentsInstr);
 };
 
 
 class ExtractConstructorTypeArgumentsInstr : public TemplateDefinition<1> {
@@ skipping 17 matching lines @@
   }
   const Class& instantiator_class() const { return instantiator_class_; }
   intptr_t token_pos() const { return token_pos_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const intptr_t token_pos_;
   const AbstractTypeArguments& type_arguments_;
   const Class& instantiator_class_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtractConstructorTypeArgumentsInstr);
 };
 
 
 class ExtractConstructorInstantiatorInstr : public TemplateDefinition<1> {
@@ skipping 12 matching lines @@
     return ast_node_.type_arguments();
   }
   const Function& constructor() const { return ast_node_.constructor(); }
   const Class& instantiator_class() const { return instantiator_class_; }
   intptr_t token_pos() const { return ast_node_.token_pos(); }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const ConstructorCallNode& ast_node_;
   const Class& instantiator_class_;
 
   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 EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return false; }
+
  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 EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return false; }
+
  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 EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return false; }
+
  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 EffectSet Effects() const { return EffectSet::All(); }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const LocalVariable& exception_var_;
   const LocalVariable& stacktrace_var_;
 
   DISALLOW_COPY_AND_ASSIGN(CatchEntryInstr);
 };
 
 
 class CheckEitherNonSmiInstr : public TemplateInstruction<2> {
  public:
@@ skipping 14 matching lines @@
 
   virtual bool CanDeoptimize() const { return true; }
 
   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 MayThrow() const { return false; }
+
  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 Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   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 MayThrow() const { return false; }
+
   Definition* Canonicalize(FlowGraphOptimizer* optimizer);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxDoubleInstr);
 };
 
 
 class BoxFloat32x4Instr : public TemplateDefinition<1> {
  public:
   explicit BoxFloat32x4Instr(Value* value) {
@@ skipping 10 matching lines @@
   }
 
   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; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxFloat32x4Instr);
 };
 
 
 class BoxUint32x4Instr : public TemplateDefinition<1> {
  public:
   explicit BoxUint32x4Instr(Value* value) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedUint32x4;
   }
 
   DECLARE_INSTRUCTION(BoxUint32x4)
   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; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxUint32x4Instr);
 };
 
 
 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 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; }
 
+  virtual bool MayThrow() const { return false; }
+
  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;
@@ skipping 11 matching lines @@
   }
 
   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; }
 
+  virtual bool MayThrow() const { return false; }
+
   Definition* Canonicalize(FlowGraphOptimizer* optimizer);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxDoubleInstr);
 };
 
 
 class UnboxFloat32x4Instr : public TemplateDefinition<1> {
  public:
   UnboxFloat32x4Instr(Value* value, intptr_t deopt_id) {
@@ skipping 12 matching lines @@
   }
 
   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; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxFloat32x4Instr);
 };
 
 
 class UnboxUint32x4Instr : public TemplateDefinition<1> {
  public:
   UnboxUint32x4Instr(Value* value, intptr_t deopt_id) {
     SetInputAt(0, value);
     deopt_id_ = deopt_id;
@@ skipping 10 matching lines @@
   }
 
   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(UnboxUint32x4)
   virtual CompileType ComputeType() const;
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxUint32x4Instr);
 };
 
 
 class UnboxIntegerInstr : public TemplateDefinition<1> {
  public:
   UnboxIntegerInstr(Value* value, intptr_t deopt_id) {
     SetInputAt(0, value);
     deopt_id_ = deopt_id;
@@ skipping 12 matching lines @@
 
 
   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; }
 
+  virtual bool MayThrow() const { return false; }
+
  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();
@@ skipping 19 matching lines @@
   }
 
   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; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(MathSqrtInstr);
 };
 
 
 class BinaryDoubleOpInstr : public TemplateDefinition<2> {
  public:
   BinaryDoubleOpInstr(Token::Kind op_kind,
                       Value* left,
                       Value* right,
@@ skipping 33 matching lines @@
 
   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();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(BinaryDoubleOpInstr);
 };
 
 
 class BinaryFloat32x4OpInstr : public TemplateDefinition<2> {
  public:
   BinaryFloat32x4OpInstr(Token::Kind op_kind,
@@ skipping 33 matching lines @@
   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();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(BinaryFloat32x4OpInstr);
 };
 
 
 class Float32x4ShuffleInstr : public TemplateDefinition<1> {
  public:
   Float32x4ShuffleInstr(MethodRecognizer::Kind op_kind, Value* value,
@@ skipping 35 matching lines @@
   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();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Float32x4ShuffleInstr);
 };
 
 
 class Float32x4ConstructorInstr : public TemplateDefinition<4> {
  public:
   Float32x4ConstructorInstr(Value* value0, Value* value1, Value* value2,
@@ skipping 30 matching lines @@
   }
 
   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; }
 
+  virtual bool MayThrow() const { return false; }
+
  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();
@@ skipping 21 matching lines @@
   }
 
   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; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Float32x4SplatInstr);
 };
 
 
 class Float32x4ZeroInstr : public TemplateDefinition<0> {
  public:
   explicit Float32x4ZeroInstr(StaticCallInstr* static_call) {
     deopt_id_ = static_call->deopt_id();
   }
@@ skipping 20 matching lines @@
   }
 
   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; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Float32x4ZeroInstr);
 };
 
 
 class Float32x4ComparisonInstr : public TemplateDefinition<2> {
  public:
   Float32x4ComparisonInstr(MethodRecognizer::Kind op_kind, Value* left,
                            Value* right, InstanceCallInstr* instance_call)
       : op_kind_(op_kind) {
@@ skipping 29 matching lines @@
   DECLARE_INSTRUCTION(Float32x4Comparison)
   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->AsFloat32x4Comparison()->op_kind();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Float32x4ComparisonInstr);
 };
 
 
 class Float32x4MinMaxInstr : public TemplateDefinition<2> {
  public:
   Float32x4MinMaxInstr(MethodRecognizer::Kind op_kind, Value* left,
@@ skipping 31 matching lines @@
   DECLARE_INSTRUCTION(Float32x4MinMax)
   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->AsFloat32x4MinMax()->op_kind();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Float32x4MinMaxInstr);
 };
 
 
 class Float32x4ScaleInstr : public TemplateDefinition<2> {
  public:
   Float32x4ScaleInstr(MethodRecognizer::Kind op_kind, Value* left,
@@ skipping 34 matching lines @@
   DECLARE_INSTRUCTION(Float32x4Scale)
   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->AsFloat32x4Scale()->op_kind();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Float32x4ScaleInstr);
 };
 
 
 class Float32x4SqrtInstr : public TemplateDefinition<1> {
  public:
   Float32x4SqrtInstr(MethodRecognizer::Kind op_kind, Value* left,
@@ skipping 28 matching lines @@
   DECLARE_INSTRUCTION(Float32x4Sqrt)
   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->AsFloat32x4Sqrt()->op_kind();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Float32x4SqrtInstr);
 };
 
 
 class Float32x4ZeroArgInstr : public TemplateDefinition<1> {
  public:
   Float32x4ZeroArgInstr(MethodRecognizer::Kind op_kind, Value* left,
@@ skipping 28 matching lines @@
   DECLARE_INSTRUCTION(Float32x4ZeroArg)
   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->AsFloat32x4ZeroArg()->op_kind();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Float32x4ZeroArgInstr);
 };
 
 
 class Float32x4ClampInstr : public TemplateDefinition<3> {
  public:
   Float32x4ClampInstr(Value* left, Value* lower, Value* upper,
@@ skipping 28 matching lines @@
   }
 
   DECLARE_INSTRUCTION(Float32x4Clamp)
   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; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Float32x4ClampInstr);
 };
 
 
 class Float32x4WithInstr : public TemplateDefinition<2> {
  public:
   Float32x4WithInstr(MethodRecognizer::Kind op_kind, Value* left,
                      Value* replacement, InstanceCallInstr* instance_call)
       : op_kind_(op_kind) {
@@ skipping 32 matching lines @@
   DECLARE_INSTRUCTION(Float32x4With)
   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->AsFloat32x4With()->op_kind();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Float32x4WithInstr);
 };
 
 
 class Float32x4ToUint32x4Instr : public TemplateDefinition<1> {
  public:
   Float32x4ToUint32x4Instr(Value* left, InstanceCallInstr* instance_call) {
@@ skipping 23 matching lines @@
   }
 
   DECLARE_INSTRUCTION(Float32x4ToUint32x4)
   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; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Float32x4ToUint32x4Instr);
 };
 
 
 class BinaryMintOpInstr : public TemplateDefinition<2> {
  public:
   BinaryMintOpInstr(Token::Kind op_kind,
                            Value* left,
                            Value* right,
@@ skipping 39 matching lines @@
   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();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const Token::Kind op_kind_;
   InstanceCallInstr* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(BinaryMintOpInstr);
 };
 
 
 class ShiftMintOpInstr : public TemplateDefinition<2> {
  public:
@@ skipping 36 matching lines @@
 
   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();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(ShiftMintOpInstr);
 };
 
 
 class UnaryMintOpInstr : public TemplateDefinition<1> {
  public:
   UnaryMintOpInstr(Token::Kind op_kind,
@@ skipping 31 matching lines @@
   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();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(UnaryMintOpInstr);
 };
 
 
 class BinarySmiOpInstr : public TemplateDefinition<2> {
  public:
   BinarySmiOpInstr(Token::Kind op_kind,
@@ skipping 38 matching lines @@
   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;
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const Token::Kind op_kind_;
   InstanceCallInstr* instance_call_;
   bool overflow_;
   bool is_truncating_;
 
   DISALLOW_COPY_AND_ASSIGN(BinarySmiOpInstr);
 };
 
 
@@ skipping 19 matching lines @@
 
   virtual bool CanDeoptimize() const { return op_kind() == Token::kNEGATE; }
 
   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();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  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 EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckStackOverflowInstr);
 };
 
 
 class SmiToDoubleInstr : public TemplateDefinition<1> {
  public:
   explicit SmiToDoubleInstr(Value* value) {
@@ skipping 11 matching lines @@
 
   virtual intptr_t ArgumentCount() const { return 1; }
 
   virtual bool CanDeoptimize() 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 bool MayThrow() const { return false; }
+
  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);
     deopt_id_ = instance_call->deopt_id();
   }
 
   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 EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return true; }
+
  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> {
@@ skipping 12 matching lines @@
 
   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(); }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(DoubleToSmiInstr);
 };
 
 
 class DoubleToDoubleInstr : public TemplateDefinition<1> {
  public:
   DoubleToDoubleInstr(Value* value,
                       InstanceCallInstr* instance_call,
                       MethodRecognizer::Kind recognized_kind)
@@ skipping 22 matching lines @@
 
   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();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const MethodRecognizer::Kind recognized_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(DoubleToDoubleInstr);
 };
 
 
 class InvokeMathCFunctionInstr : public Definition {
  public:
   InvokeMathCFunctionInstr(ZoneGrowableArray<Value*>* inputs,
@@ skipping 41 matching lines @@
   }
 
   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 {
     InvokeMathCFunctionInstr* other_invoke = other->AsInvokeMathCFunction();
     return other_invoke->recognized_kind() == recognized_kind();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     (*inputs_)[i] = value;
   }
 
   ZoneGrowableArray<Value*>* inputs_;
 
   LocationSummary* locs_;
 
   const MethodRecognizer::Kind recognized_kind_;
@@ skipping 24 matching lines @@
 
   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;
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const ICData& unary_checks_;
 
   bool null_check_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckClassInstr);
 };
 
 
 class CheckSmiInstr : public TemplateInstruction<1> {
@@ skipping 12 matching lines @@
 
   virtual bool CanDeoptimize() const { return true; }
 
   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 MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(CheckSmiInstr);
 };
 
 
 class CheckArrayBoundInstr : public TemplateInstruction<2> {
  public:
   CheckArrayBoundInstr(Value* length,
                        Value* index,
                        intptr_t array_type,
@@ skipping 20 matching lines @@
   // 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;
 
+  virtual bool MayThrow() const { return false; }
+
  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_