Reland "VM: Handle null-comparisons in the flow graph type propagation"

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/growable_array.h"
@@ skipping 86 matching lines @@
   bool IsAssignableTo(const AbstractType& type) {
     bool is_instance;
     return CanComputeIsInstanceOf(type, kNullable, &is_instance) && is_instance;
   }
 
   // Create a new CompileType representing given combination of class id and
   // abstract type. The pair is assumed to be coherent.
   static CompileType Create(intptr_t cid, const AbstractType& type);
 
   CompileType CopyNonNullable() const {
-    return CompileType(kNonNullable, cid_, type_);
+    return CompileType(kNonNullable, kIllegalCid, type_);
   }
 
   static CompileType CreateNullable(bool is_nullable, intptr_t cid) {
     return CompileType(is_nullable, cid, NULL);
   }
 
   // Create a new CompileType representing given abstract type. By default
   // values as assumed to be nullable.
   static CompileType FromAbstractType(const AbstractType& type,
                                       bool is_nullable = kNullable);
@@ skipping 32 matching lines @@
   // Returns true if this and other types are the same.
   bool IsEqualTo(CompileType* other) {
     return (is_nullable_ == other->is_nullable_) &&
            (ToNullableCid() == other->ToNullableCid()) &&
            (ToAbstractType()->Equals(*other->ToAbstractType()));
   }
 
   bool IsNone() const { return (cid_ == kIllegalCid) && (type_ == NULL); }
 
   bool IsInt() {
-    return !is_nullable() && ((ToCid() == kSmiCid) || (ToCid() == kMintCid) ||
-                              ((type_ != NULL) &&
-                               (type_->Equals(Type::Handle(Type::IntType())))));
+    return !is_nullable() &&
+           ((ToCid() == kSmiCid) || (ToCid() == kMintCid) ||
+            ((type_ != NULL) &&
+             (type_->Equals(Type::Handle(Type::Int64Type())))));
   }
 
   void PrintTo(BufferFormatter* f) const;
   const char* ToCString() const;
 
  private:
   bool CanComputeIsInstanceOf(const AbstractType& type,
                               bool is_nullable,
                               bool* is_instance);
 
@@ skipping 387 matching lines @@
         next_(NULL),
         env_(NULL),
         locs_(NULL),
         inlining_id_(-1) {}
 
   virtual ~Instruction() {}
 
   virtual Tag tag() const = 0;
 
   intptr_t deopt_id() const {
-    ASSERT(CanDeoptimize() || CanBecomeDeoptimizationTarget());
+    ASSERT(ComputeCanDeoptimize() || CanBecomeDeoptimizationTarget());
     return GetDeoptId();
   }
 
   const ICData* GetICData(
       const ZoneGrowableArray<const ICData*>& ic_data_array) const;
 
   virtual TokenPosition token_pos() const { return TokenPosition::kNoSource; }
 
   virtual intptr_t InputCount() const = 0;
   virtual Value* InputAt(intptr_t i) const = 0;
@@ skipping 11 matching lines @@
   // Call instructions override this function and return the number of
   // pushed arguments.
   virtual intptr_t ArgumentCount() const { return 0; }
   virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     UNREACHABLE();
     return NULL;
   }
   inline Definition* ArgumentAt(intptr_t index) const;
 
   // Returns true, if this instruction can deoptimize.
-  virtual bool CanDeoptimize() const = 0;
+  virtual bool ComputeCanDeoptimize() const = 0;

[Vyacheslav Egorov (Google), 2017/03/31 10:39:44]

Maybe add a comment here that it is not currently sticky and might change as
graph is changed because we sometimes loose information (e.g. remove
redefinitions).

[Florian Schneider, 2017/03/31 16:39:31]

Done.

+
+  // Once we removed the deopt environment, we assume that this
+  // instructions can't deoptimize.
+  bool CanDeoptimize() const { return env() != NULL && ComputeCanDeoptimize(); }
 
   // Visiting support.
   virtual void Accept(FlowGraphVisitor* visitor) = 0;
 
   Instruction* previous() const { return previous_; }
   void set_previous(Instruction* instr) {
     ASSERT(!IsBlockEntry());
     previous_ = instr;
   }
 
@@ skipping 122 matching lines @@
   void InsertBefore(Instruction* next) { InsertAfter(next->previous()); }
 
   // Insert this instruction after 'prev' after use lists are computed.
   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);
 
-  virtual bool AllowsDCE() const { return false; }
-
   // Returns true if CSE and LICM are allowed for this instruction.
   virtual bool AllowsCSE() const { return false; }
 
   // Returns set of effects created by this instruction.
   virtual EffectSet Effects() const = 0;
 
   // Returns set of effects that affect this instruction.
   virtual EffectSet Dependencies() const {
     UNREACHABLE();
     return EffectSet::All();
@@ skipping 27 matching lines @@
   // All instructions that participate in CSE have to override this function.
   // This function can assume that the argument has the same type as this.
   virtual bool AttributesEqual(Instruction* other) const {
     UNREACHABLE();
     return false;
   }
 
   virtual void InheritDeoptTarget(Zone* zone, Instruction* other);
 
   bool NeedsEnvironment() const {
-    return CanDeoptimize() || CanBecomeDeoptimizationTarget();
+    return ComputeCanDeoptimize() || CanBecomeDeoptimizationTarget();
   }
 
   virtual bool CanBecomeDeoptimizationTarget() const { return false; }
 
   void InheritDeoptTargetAfter(FlowGraph* flow_graph,
                                Definition* call,
                                Definition* result);
 
   virtual bool MayThrow() const = 0;
 
@@ skipping 160 matching lines @@
 
 
 class ParallelMoveInstr : public TemplateInstruction<0, NoThrow> {
  public:
   ParallelMoveInstr() : moves_(4) {}
 
   DECLARE_INSTRUCTION(ParallelMove)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const {
     UNREACHABLE();  // This instruction never visited by optimization passes.
     return EffectSet::None();
   }
 
   virtual EffectSet Dependencies() const {
     UNREACHABLE();  // This instruction never visited by optimization passes.
     return EffectSet::None();
   }
@@ skipping 111 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 CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() 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_; }
   void set_try_index(intptr_t index) { try_index_ = index; }
 
   // True for blocks inside a try { } region.
@@ skipping 712 matching lines @@
   virtual BlockEntryInstr* GetBlock() { return block(); }
   JoinEntryInstr* block() const { return block_; }
 
   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 CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   // Phi is alive if it reaches a non-environment use.
   bool is_alive() const { return is_alive_; }
   void mark_alive() { is_alive_ = true; }
   void mark_dead() { is_alive_ = false; }
 
   virtual Representation RequiredInputRepresentation(intptr_t i) const {
     return representation_;
@@ skipping 74 matching lines @@
 
   // Get the block entry for that instruction.
   virtual BlockEntryInstr* GetBlock() { return block_; }
 
   intptr_t InputCount() const { return 0; }
   Value* InputAt(intptr_t i) const {
     UNREACHABLE();
     return NULL;
   }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
   virtual intptr_t Hashcode() const {
     UNREACHABLE();
     return 0;
   }
 
   virtual CompileType ComputeType() const;
@@ skipping 16 matching lines @@
 class PushArgumentInstr : public TemplateDefinition<1, NoThrow> {
  public:
   explicit PushArgumentInstr(Value* value) { SetInputAt(0, value); }
 
   DECLARE_INSTRUCTION(PushArgument)
 
   virtual CompileType ComputeType() const;
 
   Value* value() const { return InputAt(0); }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual TokenPosition token_pos() const {
     return TokenPosition::kPushArgument;
   }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
@@ skipping 18 matching lines @@
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   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 CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(ReturnInstr);
 };
 
 
 class ThrowInstr : public TemplateInstruction<0, Throws> {
  public:
   explicit ThrowInstr(TokenPosition token_pos)
       : TemplateInstruction(Thread::Current()->GetNextDeoptId()),
         token_pos_(token_pos) {}
 
   DECLARE_INSTRUCTION(Throw)
 
   virtual intptr_t ArgumentCount() const { return 1; }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
 
-  virtual bool CanDeoptimize() const { return true; }
+  virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
  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 artifically generated by the parser.
   ReThrowInstr(TokenPosition token_pos, intptr_t catch_try_index)
       : TemplateInstruction(Thread::Current()->GetNextDeoptId()),
         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 CanDeoptimize() const { return true; }
+  virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
  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 CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
  private:
   const char* message_;
 
   DISALLOW_COPY_AND_ASSIGN(StopInstr);
 };
@@ skipping 21 matching lines @@
   double edge_weight() const { return edge_weight_; }
   void set_edge_weight(double weight) { edge_weight_ = weight; }
   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 CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   ParallelMoveInstr* parallel_move() const { return parallel_move_; }
 
   bool HasParallelMove() const { return parallel_move_ != NULL; }
 
   bool HasNonRedundantParallelMove() const {
     return HasParallelMove() && !parallel_move()->IsRedundant();
   }
@@ skipping 55 matching lines @@
     ASSERT(successor->next()->AsGoto()->successor()->IsIndirectEntry());
     successors_.Add(successor);
   }
 
   virtual intptr_t SuccessorCount() const { return successors_.length(); }
   virtual TargetEntryInstr* SuccessorAt(intptr_t index) const {
     ASSERT(index < SuccessorCount());
     return successors_[index];
   }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
   virtual bool CanBecomeDeoptimizationTarget() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   Value* offset() const { return inputs_[0]; }
   void ComputeOffsetTable();
 
   PRINT_TO_SUPPORT
 
  private:
@@ skipping 112 matching lines @@
   virtual intptr_t ArgumentCount() const {
     return comparison()->ArgumentCount();
   }
 
   intptr_t InputCount() const { return comparison()->InputCount(); }
 
   Value* InputAt(intptr_t i) const { return comparison()->InputAt(i); }
 
   virtual TokenPosition token_pos() const { return comparison_->token_pos(); }
 
-  virtual bool CanDeoptimize() const { return comparison()->CanDeoptimize(); }
+  virtual bool ComputeCanDeoptimize() const {
+    return comparison()->ComputeCanDeoptimize();
+  }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     return comparison()->CanBecomeDeoptimizationTarget();
   }
 
   virtual EffectSet Effects() const { return comparison()->Effects(); }
 
   ComparisonInstr* comparison() const { return comparison_; }
   void SetComparison(ComparisonInstr* comp);
 
@@ skipping 40 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(BranchInstr);
 };
 
 
 class DeoptimizeInstr : public TemplateInstruction<0, NoThrow, Pure> {
  public:
   DeoptimizeInstr(ICData::DeoptReasonId deopt_reason, intptr_t deopt_id)
       : TemplateInstruction(deopt_id), deopt_reason_(deopt_reason) {}
 
-  virtual bool CanDeoptimize() const { return true; }
+  virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   DECLARE_INSTRUCTION(Deoptimize)
 
  private:
   const ICData::DeoptReasonId deopt_reason_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptimizeInstr);
 };
@@ skipping 10 matching lines @@
   Value* value() const { return inputs_[0]; }
 
   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 CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
  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 CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual bool AttributesEqual(Instruction* other) const {
     UNREACHABLE();
     return false;
   }
 
   Value* value() const { return inputs_[0]; }
   Range* constraint() const { return constraint_; }
@@ skipping 21 matching lines @@
   ConstantInstr(const Object& value,
                 TokenPosition token_pos = TokenPosition::kConstant);
 
   DECLARE_INSTRUCTION(Constant)
   virtual CompileType ComputeType() const;
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   const Object& value() const { return value_; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   virtual bool AttributesEqual(Instruction* other) const;
 
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
@@ skipping 56 matching lines @@
   Value* instantiator_type_arguments() const { return inputs_[1]; }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   const AbstractType& dst_type() const { return dst_type_; }
   void set_dst_type(const AbstractType& dst_type) {
     ASSERT(!dst_type.IsTypeRef());
     dst_type_ = dst_type.raw();
   }
   const String& dst_name() const { return dst_name_; }
 
-  virtual bool CanDeoptimize() const { return true; }
+  virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     // AssertAssignable instructions that are specialized by the optimizer
     // (e.g. replaced with CheckClass) need a deoptimization descriptor before.
     return true;
   }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AttributesEqual(Instruction* other) const;
@@ skipping 16 matching lines @@
         token_pos_(token_pos) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(AssertBoolean)
   virtual CompileType ComputeType() const;
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   Value* value() const { return inputs_[0]; }
 
-  virtual bool CanDeoptimize() const { return true; }
+  virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertBooleanInstr);
 };
 
 
 // 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, NoThrow> {
  public:
   CurrentContextInstr()
       : TemplateDefinition(Thread::Current()->GetNextDeoptId()) {}
 
   DECLARE_INSTRUCTION(CurrentContext)
   virtual CompileType ComputeType() const;
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CurrentContextInstr);
 };
 
 
@@ skipping 26 matching lines @@
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
   // TODO(kmillikin): implement exact call counts for closure calls.
   virtual intptr_t CallCount() const { return 1; }
 
-  virtual bool CanDeoptimize() const { return true; }
+  virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::All(); }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const Array& argument_names_;
   TokenPosition token_pos_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
 
@@ skipping 47 matching lines @@
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
   const Array& argument_names() const { return argument_names_; }
   intptr_t checked_argument_count() const { return checked_argument_count_; }
 
   bool has_unique_selector() const { return has_unique_selector_; }
   void set_has_unique_selector(bool b) { has_unique_selector_ = b; }
 
-  virtual bool CanDeoptimize() const { return true; }
+  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(); }
@@ skipping 65 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)
 
   const ICData& ic_data() const { return ic_data_; }
 
-  virtual bool CanDeoptimize() const { return true; }
+  virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::All(); }
 
   virtual Definition* Canonicalize(FlowGraph* graph);
 
   static RawType* ComputeRuntimeType(const ICData& ic_data);
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
@@ skipping 14 matching lines @@
                      Value* left,
                      Value* right,
                      bool needs_number_check);
 
   DECLARE_INSTRUCTION(StrictCompare)
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler, BranchInstr* branch);
 
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels);
 
   bool needs_number_check() const { return needs_number_check_; }
   void set_needs_number_check(bool value) { needs_number_check_ = value; }
@@ skipping 24 matching lines @@
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   DECLARE_INSTRUCTION(TestSmi);
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     return kTagged;
   }
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler, BranchInstr* branch);
 
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels);
 
@@ skipping 24 matching lines @@
   }
 
   DECLARE_INSTRUCTION(TestCids);
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
-  virtual bool CanDeoptimize() const {
+  virtual bool ComputeCanDeoptimize() const {
     return GetDeoptId() != Thread::kNoDeoptId;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     return kTagged;
   }
 
   virtual bool AttributesEqual(Instruction* other) const;
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler, BranchInstr* branch);
@@ skipping 26 matching lines @@
     SetInputAt(1, right);
     set_operation_cid(cid);
   }
 
   DECLARE_INSTRUCTION(EqualityCompare)
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler, BranchInstr* branch);
 
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels);
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     if (operation_cid() == kDoubleCid) return kUnboxedDouble;
     if (operation_cid() == kMintCid) return kUnboxedMint;
@@ skipping 21 matching lines @@
     SetInputAt(1, right);
     set_operation_cid(cid);
   }
 
   DECLARE_INSTRUCTION(RelationalOp)
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler, BranchInstr* branch);
 
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels);
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     if (operation_cid() == kDoubleCid) return kUnboxedDouble;
     if (operation_cid() == kMintCid) return kUnboxedMint;
@@ skipping 26 matching lines @@
   // Returns true if this combination of comparison and values flowing on
   // the true and false paths is supported on the current platform.
   static bool Supports(ComparisonInstr* comparison, Value* v1, Value* v2);
 
   DECLARE_INSTRUCTION(IfThenElse)
 
   intptr_t InputCount() const { return comparison()->InputCount(); }
 
   Value* InputAt(intptr_t i) const { return comparison()->InputAt(i); }
 
-  virtual bool CanDeoptimize() const { return comparison()->CanDeoptimize(); }
+  virtual bool ComputeCanDeoptimize() const {
+    return comparison()->ComputeCanDeoptimize();
+  }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     return comparison()->CanBecomeDeoptimizationTarget();
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     return comparison()->DeoptimizationTarget();
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t i) const {
@@ skipping 96 matching lines @@
 
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
   virtual intptr_t CallCount() const {
     return ic_data() == NULL ? 0 : ic_data()->AggregateCount();
   }
 
-  virtual bool CanDeoptimize() const { return true; }
+  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(); }
 
   void set_result_cid(intptr_t value) { result_cid_ = value; }
@@ skipping 30 matching lines @@
 class LoadLocalInstr : public TemplateDefinition<0, NoThrow> {
  public:
   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 CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() 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 TokenPosition token_pos() const { return token_pos_; }
@@ skipping 25 matching lines @@
     ASSERT((value_ != NULL) && (i == 0));
     return value_;
   }
 
   Value* value() const { return value_; }
 
   intptr_t num_temps() const { return num_temps_; }
 
   virtual CompileType ComputeType() const;
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const {
     UNREACHABLE();  // Eliminated by SSA construction.
     return EffectSet::None();
   }
 
   virtual bool MayThrow() const {
     UNREACHABLE();
     return false;
   }
@@ skipping 20 matching lines @@
       : local_(local), is_dead_(false), is_last_(false), token_pos_(token_pos) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(StoreLocal)
   virtual CompileType ComputeType() const;
 
   const LocalVariable& local() const { return local_; }
   Value* value() const { return inputs_[0]; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  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 {
     UNREACHABLE();  // Eliminated by SSA construction.
     return EffectSet::None();
@@ skipping 36 matching lines @@
 
   DECLARE_INSTRUCTION(NativeCall)
 
   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 link_lazily() const { return link_lazily_; }
   virtual TokenPosition token_pos() const { return token_pos_; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::All(); }
 
   void SetupNative();
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   void set_native_c_function(NativeFunction value) {
     native_c_function_ = value;
@@ skipping 13 matching lines @@
 
 
 class DebugStepCheckInstr : public TemplateInstruction<0, NoThrow> {
  public:
   DebugStepCheckInstr(TokenPosition token_pos, RawPcDescriptors::Kind stub_kind)
       : token_pos_(token_pos), stub_kind_(stub_kind) {}
 
   DECLARE_INSTRUCTION(DebugStepCheck)
 
   virtual TokenPosition token_pos() const { return token_pos_; }
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
   virtual EffectSet Effects() const { return EffectSet::All(); }
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
  private:
   const TokenPosition token_pos_;
   const RawPcDescriptors::Kind stub_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(DebugStepCheckInstr);
 };
 
@@ skipping 45 matching lines @@
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   const Field& field() const { return field_; }
   intptr_t offset_in_bytes() const { return offset_in_bytes_; }
 
   bool ShouldEmitStoreBarrier() const {
     return value()->NeedsStoreBuffer() &&
            (emit_store_barrier_ == kEmitStoreBarrier);
   }
 
-  virtual bool CanDeoptimize() const { return false; }
+  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(); }
 
   bool IsUnboxedStore() const;
@@ skipping 30 matching lines @@
   GuardFieldInstr(Value* value, const Field& field, intptr_t deopt_id)
       : TemplateInstruction(deopt_id), field_(field) {
     SetInputAt(0, value);
     CheckField(field);
   }
 
   Value* value() const { return inputs_[0]; }
 
   const Field& field() const { return field_; }
 
-  virtual bool CanDeoptimize() const { return true; }
+  virtual bool ComputeCanDeoptimize() const { return true; }
   virtual bool CanBecomeDeoptimizationTarget() const {
     // Ensure that we record kDeopt PC descriptor in unoptimized code.
     return true;
   }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const Field& field_;
 
@@ skipping 45 matching lines @@
     SetInputAt(0, field_value);
   }
 
   DECLARE_INSTRUCTION(LoadStaticField)
   virtual CompileType ComputeType() const;
 
   const Field& StaticField() const;
 
   Value* field_value() const { return inputs_[0]; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual bool AllowsCSE() const { return StaticField().is_final(); }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const;
   virtual bool AttributesEqual(Instruction* other) const;
 
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
@@ skipping 15 matching lines @@
     CheckField(field);
   }
 
   enum { kValuePos = 0 };
 
   DECLARE_INSTRUCTION(StoreStaticField)
 
   const Field& field() const { return field_; }
   Value* value() const { return inputs_[kValuePos]; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  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 TokenPosition token_pos() const { return token_pos_; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
@@ skipping 41 matching lines @@
   bool IsExternal() const {
     return array()->definition()->representation() == kUntagged;
   }
 
   Value* array() const { return inputs_[0]; }
   Value* index() const { return inputs_[1]; }
   intptr_t index_scale() const { return index_scale_; }
   intptr_t class_id() const { return class_id_; }
   bool aligned() const { return alignment_ == kAlignedAccess; }
 
-  virtual bool CanDeoptimize() const {
+  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(); }
 
  private:
   const intptr_t index_scale_;
@@ skipping 50 matching lines @@
   Value* array() const { return inputs_[0]; }
   Value* index() const { return inputs_[1]; }
   intptr_t index_scale() const { return Instance::ElementSizeFor(class_id_); }
   intptr_t class_id() const { return class_id_; }
   intptr_t element_count() const { return element_count_; }
 
   bool can_pack_into_smi() const {
     return element_count() <= kSmiBits / (index_scale() * kBitsPerByte);
   }
 
-  virtual bool CanDeoptimize() const { return false; }
+  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(); }
 
  private:
   const intptr_t class_id_;
   const TokenPosition token_pos_;
   const intptr_t element_count_;
   Representation representation_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadCodeUnitsInstr);
 };
 
 
 class OneByteStringFromCharCodeInstr
     : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   explicit OneByteStringFromCharCodeInstr(Value* char_code) {
     SetInputAt(0, char_code);
   }
 
   DECLARE_INSTRUCTION(OneByteStringFromCharCode)
   virtual CompileType ComputeType() const;
 
   Value* char_code() const { return inputs_[0]; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(OneByteStringFromCharCodeInstr);
 };
 
 
 class StringToCharCodeInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   StringToCharCodeInstr(Value* str, intptr_t cid) : cid_(cid) {
     ASSERT(str != NULL);
     SetInputAt(0, str);
   }
 
   DECLARE_INSTRUCTION(StringToCharCode)
   virtual CompileType ComputeType() const;
 
   Value* str() const { return inputs_[0]; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const {
     return other->AsStringToCharCode()->cid_ == cid_;
   }
 
  private:
   const intptr_t cid_;
 
   DISALLOW_COPY_AND_ASSIGN(StringToCharCodeInstr);
 };
 
 
 class StringInterpolateInstr : public TemplateDefinition<1, Throws> {
  public:
   StringInterpolateInstr(Value* value, TokenPosition token_pos)
       : TemplateDefinition(Thread::Current()->GetNextDeoptId()),
         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 CanDeoptimize() 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_;
   Function& function_;
@@ skipping 23 matching lines @@
 
   intptr_t index_scale() const { return index_scale_; }
   intptr_t class_id() const { return class_id_; }
   bool aligned() const { return alignment_ == kAlignedAccess; }
 
   bool ShouldEmitStoreBarrier() const {
     return value()->NeedsStoreBuffer() &&
            (emit_store_barrier_ == kEmitStoreBarrier);
   }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const;
 
   bool IsExternal() const {
     return array()->definition()->representation() == kUntagged;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
@@ skipping 16 matching lines @@
 // 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 CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BooleanNegateInstr);
 };
 
 
@@ skipping 14 matching lines @@
 
   DECLARE_INSTRUCTION(InstanceOf)
   virtual CompileType ComputeType() const;
 
   Value* value() const { return inputs_[0]; }
   Value* instantiator_type_arguments() const { return inputs_[1]; }
 
   const AbstractType& type() const { return type_; }
   virtual TokenPosition token_pos() const { return token_pos_; }
 
-  virtual bool CanDeoptimize() const { return true; }
+  virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const TokenPosition token_pos_;
   Value* value_;
   Value* type_arguments_;
   const AbstractType& type_;
@@ skipping 25 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 CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual AliasIdentity Identity() const { return identity_; }
   virtual void SetIdentity(AliasIdentity identity) { identity_ = identity; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const TokenPosition token_pos_;
@@ skipping 14 matching lines @@
       : token_pos_(token_pos),
         num_context_variables_(num_context_variables),
         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 CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual AliasIdentity Identity() const { return identity_; }
   virtual void SetIdentity(AliasIdentity identity) { identity_ = identity; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const TokenPosition token_pos_;
@@ skipping 66 matching lines @@
   // SelectRepresentations pass is run once more while MaterializeObject
   // 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 CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   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_; }
@@ skipping 36 matching lines @@
 
   DECLARE_INSTRUCTION(CreateArray)
   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 CanDeoptimize() const { return MayThrow(); }
+  virtual bool ComputeCanDeoptimize() const { return MayThrow(); }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual AliasIdentity Identity() const { return identity_; }
   virtual void SetIdentity(AliasIdentity identity) { identity_ = identity; }
 
  private:
   const TokenPosition token_pos_;
   AliasIdentity identity_;
 
@@ skipping 18 matching lines @@
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     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 CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   intptr_t offset_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadUntaggedInstr);
 };
 
 
 class LoadClassIdInstr : public TemplateDefinition<1, NoThrow> {
  public:
   explicit LoadClassIdInstr(Value* object) { SetInputAt(0, object); }
 
   virtual Representation representation() const { return kTagged; }
   DECLARE_INSTRUCTION(LoadClassId)
   virtual CompileType ComputeType() const;
 
   Value* object() const { return inputs_[0]; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Dependencies() const {
     return EffectSet::Externalization();
   }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(LoadClassIdInstr);
@@ skipping 63 matching lines @@
 
   void set_recognized_kind(MethodRecognizer::Kind kind) {
     recognized_kind_ = kind;
   }
 
   MethodRecognizer::Kind recognized_kind() const { return recognized_kind_; }
 
   DECLARE_INSTRUCTION(LoadField)
   virtual CompileType ComputeType() const;
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   bool IsImmutableLengthLoad() const;
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   static MethodRecognizer::Kind RecognizedKindFromArrayCid(intptr_t cid);
 
   static bool IsFixedLengthArrayCid(intptr_t cid);
@@ skipping 32 matching lines @@
     ASSERT(function_type_arguments == NULL);  // TODO(regis): Implement.
     SetInputAt(0, instantiator_type_arguments);
   }
 
   DECLARE_INSTRUCTION(InstantiateType)
 
   Value* instantiator_type_arguments() const { return inputs_[0]; }
   const AbstractType& type() const { return type_; }
   virtual TokenPosition token_pos() const { return token_pos_; }
 
-  virtual bool CanDeoptimize() const { return true; }
+  virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const TokenPosition token_pos_;
   const AbstractType& type_;
 
   DISALLOW_COPY_AND_ASSIGN(InstantiateTypeInstr);
@@ skipping 16 matching lines @@
     SetInputAt(0, instantiator_type_arguments);
   }
 
   DECLARE_INSTRUCTION(InstantiateTypeArguments)
 
   Value* instantiator_type_arguments() const { return inputs_[0]; }
   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 CanDeoptimize() const { return true; }
+  virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   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 CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   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)
       : TemplateInstruction(Thread::Current()->GetNextDeoptId()),
         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 CanDeoptimize() const { return true; }
+  virtual bool ComputeCanDeoptimize() const { return true; }
   virtual EffectSet Effects() const { return EffectSet::All(); }
   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)
       : TemplateDefinition(Thread::Current()->GetNextDeoptId()),
         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 CanDeoptimize() const { return true; }
+  virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
  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)
       : TemplateInstruction(deopt_id), licm_hoisted_(false) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   DECLARE_INSTRUCTION(CheckEitherNonSmi)
 
-  virtual bool CanDeoptimize() const { return true; }
+  virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   void set_licm_hoisted(bool value) { licm_hoisted_ = value; }
 
  private:
   bool licm_hoisted_;
 
@@ skipping 64 matching lines @@
 class BoxInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   static BoxInstr* Create(Representation from, Value* value);
 
   Value* value() const { return inputs_[0]; }
   Representation from_representation() const { return from_representation_; }
 
   DECLARE_INSTRUCTION(Box)
   virtual CompileType ComputeType() const;
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
   virtual intptr_t DeoptimizationTarget() const { return Thread::kNoDeoptId; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return from_representation();
   }
 
   virtual bool AttributesEqual(Instruction* other) const {
     return other->AsBox()->from_representation() == from_representation();
   }
@@ skipping 88 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(BoxInt64Instr);
 };
 
 
 class UnboxInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   static UnboxInstr* Create(Representation to, Value* value, intptr_t deopt_id);
 
   Value* value() const { return inputs_[0]; }
 
-  virtual bool CanDeoptimize() const {
+  virtual bool ComputeCanDeoptimize() const {
     const intptr_t value_cid = value()->Type()->ToCid();
 
     if (CanConvertSmi() && (value()->Type()->ToCid() == kSmiCid)) {
       return false;
     }
 
     return (value_cid != BoxCid());
   }
 
   virtual Representation representation() const { return representation_; }
@@ skipping 81 matching lines @@
 };
 
 
 class UnboxUint32Instr : public UnboxInteger32Instr {
  public:
   UnboxUint32Instr(Value* value, intptr_t deopt_id)
       : UnboxInteger32Instr(kUnboxedUint32, kTruncate, value, deopt_id) {
     ASSERT(is_truncating());
   }
 
-  virtual bool CanDeoptimize() const;
+  virtual bool ComputeCanDeoptimize() const;
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   DECLARE_INSTRUCTION_NO_BACKEND(UnboxUint32)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxUint32Instr);
 };
 
 
 class UnboxInt32Instr : public UnboxInteger32Instr {
  public:
   UnboxInt32Instr(TruncationMode truncation_mode,
                   Value* value,
                   intptr_t deopt_id)
       : UnboxInteger32Instr(kUnboxedInt32, truncation_mode, value, deopt_id) {}
 
-  virtual bool CanDeoptimize() const;
+  virtual bool ComputeCanDeoptimize() const;
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   DECLARE_INSTRUCTION_NO_BACKEND(UnboxInt32)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxInt32Instr);
 };
@@ skipping 27 matching lines @@
     kDoubleSquare,
   };
   MathUnaryInstr(MathUnaryKind kind, Value* value, intptr_t deopt_id)
       : TemplateDefinition(deopt_id), kind_(kind) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
   MathUnaryKind kind() const { return kind_; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedDouble; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
@@ skipping 47 matching lines @@
   Value* str() const { return inputs_[0]; }
   Value* lhs_index() const { return inputs_[1]; }
   Value* rhs_index() const { return inputs_[2]; }
   Value* length() const { return inputs_[3]; }
 
   const RuntimeEntry& TargetFunction() const;
   bool IsExternal() const { return cid_ == kExternalTwoByteStringCid; }
   intptr_t class_id() const { return cid_; }
   intptr_t index_scale() const { return Instance::ElementSizeFor(cid_); }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kTagged; }
 
   DECLARE_INSTRUCTION(CaseInsensitiveCompareUC16)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const {
     return other->AsCaseInsensitiveCompareUC16()->cid_ == cid_;
   }
 
@@ skipping 20 matching lines @@
     SetInputAt(1, right_value);
   }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   intptr_t result_cid() const { return result_cid_; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     if (result_cid() == kSmiCid) {
       return kTagged;
     }
     ASSERT(result_cid() == kDoubleCid);
     return kUnboxedDouble;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
@@ skipping 34 matching lines @@
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   Token::Kind op_kind() const { return op_kind_; }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedDouble; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
@@ skipping 27 matching lines @@
                     intptr_t deopt_id,
                     TokenPosition token_pos)
       : TemplateComparison(token_pos, Token::kEQ, deopt_id), op_kind_(op_kind) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return InputAt(0); }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   PRINT_OPERANDS_TO_SUPPORT
 
   DECLARE_INSTRUCTION(DoubleTestOp)
   virtual CompileType ComputeType() const;
@@ skipping 28 matching lines @@
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   Token::Kind op_kind() const { return op_kind_; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
@@ skipping 26 matching lines @@
       : TemplateDefinition(deopt_id), op_kind_(op_kind), mask_(mask) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   intptr_t mask() const { return mask_; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     if ((op_kind_ == MethodRecognizer::kFloat32x4ShuffleX) ||
         (op_kind_ == MethodRecognizer::kFloat32x4ShuffleY) ||
         (op_kind_ == MethodRecognizer::kFloat32x4ShuffleZ) ||
         (op_kind_ == MethodRecognizer::kFloat32x4ShuffleW)) {
       return kUnboxedDouble;
     }
     if ((op_kind_ == MethodRecognizer::kInt32x4Shuffle)) {
       return kUnboxedInt32x4;
@@ skipping 51 matching lines @@
     SetInputAt(1, zw);
   }
 
   Value* xy() const { return inputs_[0]; }
   Value* zw() const { return inputs_[1]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   intptr_t mask() const { return mask_; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     if (op_kind() == MethodRecognizer::kInt32x4ShuffleMix) {
       return kUnboxedInt32x4;
     }
     ASSERT(op_kind() == MethodRecognizer::kFloat32x4ShuffleMix);
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
@@ skipping 41 matching lines @@
     SetInputAt(1, value1);
     SetInputAt(2, value2);
     SetInputAt(3, value3);
   }
 
   Value* value0() const { return inputs_[0]; }
   Value* value1() const { return inputs_[1]; }
   Value* value2() const { return inputs_[2]; }
   Value* value3() const { return inputs_[3]; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx >= 0 && idx < 4);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
@@ skipping 15 matching lines @@
 
 class Float32x4SplatInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   Float32x4SplatInstr(Value* value, intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
@@ skipping 11 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(Float32x4SplatInstr);
 };
 
 
 // TODO(vegorov) replace with UnboxedConstantInstr.
 class Float32x4ZeroInstr : public TemplateDefinition<0, NoThrow, Pure> {
  public:
   Float32x4ZeroInstr() {}
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   DECLARE_INSTRUCTION(Float32x4Zero)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Float32x4ZeroInstr);
 };
 
 
 class Float32x4ComparisonInstr : public TemplateDefinition<2, NoThrow, Pure> {
  public:
   Float32x4ComparisonInstr(MethodRecognizer::Kind op_kind,
                            Value* left,
                            Value* right,
                            intptr_t deopt_id)
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedInt32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
@@ skipping 26 matching lines @@
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
@@ skipping 26 matching lines @@
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     if (idx == 0) {
       return kUnboxedDouble;
     }
     return kUnboxedFloat32x4;
   }
@@ skipping 26 matching lines @@
                      Value* left,
                      intptr_t deopt_id)
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
@@ skipping 24 matching lines @@
                         Value* left,
                         intptr_t deopt_id)
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
@@ skipping 26 matching lines @@
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, left);
     SetInputAt(1, lower);
     SetInputAt(2, upper);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* lower() const { return inputs_[1]; }
   Value* upper() const { return inputs_[2]; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1) || (idx == 2));
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
@@ skipping 22 matching lines @@
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, replacement);
     SetInputAt(1, left);
   }
 
   Value* left() const { return inputs_[1]; }
   Value* replacement() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     if (idx == 0) {
       return kUnboxedDouble;
     }
     return kUnboxedFloat32x4;
   }
@@ skipping 29 matching lines @@
       : TemplateDefinition(deopt_id), op_kind_(op_kind), mask_(mask) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   intptr_t mask() const { return mask_; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     if ((op_kind_ == MethodRecognizer::kFloat64x2GetX) ||
         (op_kind_ == MethodRecognizer::kFloat64x2GetY)) {
       return kUnboxedDouble;
     }
     UNIMPLEMENTED();
     return kUnboxedDouble;
   }
 
@@ skipping 33 matching lines @@
 
 class Float32x4ToInt32x4Instr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   Float32x4ToInt32x4Instr(Value* left, intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedInt32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
@@ skipping 15 matching lines @@
 
 class Float32x4ToFloat64x2Instr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   Float32x4ToFloat64x2Instr(Value* left, intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedFloat64x2; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
@@ skipping 15 matching lines @@
 
 class Float64x2ToFloat32x4Instr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   Float64x2ToFloat32x4Instr(Value* left, intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedFloat64x2;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
@@ skipping 17 matching lines @@
  public:
   Float64x2ConstructorInstr(Value* value0, Value* value1, intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, value0);
     SetInputAt(1, value1);
   }
 
   Value* value0() const { return inputs_[0]; }
   Value* value1() const { return inputs_[1]; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedFloat64x2; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx >= 0 && idx < 2);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
@@ skipping 15 matching lines @@
 
 class Float64x2SplatInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   Float64x2SplatInstr(Value* value, intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedFloat64x2; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
@@ skipping 10 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Float64x2SplatInstr);
 };
 
 
 class Float64x2ZeroInstr : public TemplateDefinition<0, NoThrow, Pure> {
  public:
   Float64x2ZeroInstr() {}
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedFloat64x2; }
 
   DECLARE_INSTRUCTION(Float64x2Zero)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Float64x2ZeroInstr);
 };
 
 
 // TODO(vegorov) rename to Unary to match arithmetic instructions.
 class Float64x2ZeroArgInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   Float64x2ZeroArgInstr(MethodRecognizer::Kind op_kind,
                         Value* left,
                         intptr_t deopt_id)
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     if (op_kind() == MethodRecognizer::kFloat64x2GetSignMask) {
       // Smi.
       return kTagged;
     }
     return kUnboxedFloat64x2;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
@@ skipping 32 matching lines @@
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedFloat64x2; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     if (idx == 0) {
       return kUnboxedFloat64x2;
     }
     ASSERT(idx == 1);
     if ((op_kind() == MethodRecognizer::kFloat64x2WithX) ||
         (op_kind() == MethodRecognizer::kFloat64x2WithY) ||
@@ skipping 37 matching lines @@
     SetInputAt(1, value1);
     SetInputAt(2, value2);
     SetInputAt(3, value3);
   }
 
   Value* value0() const { return inputs_[0]; }
   Value* value1() const { return inputs_[1]; }
   Value* value2() const { return inputs_[2]; }
   Value* value3() const { return inputs_[3]; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedInt32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx >= 0) && (idx < 4));
     return kUnboxedInt32;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
@@ skipping 26 matching lines @@
     SetInputAt(1, value1);
     SetInputAt(2, value2);
     SetInputAt(3, value3);
   }
 
   Value* value0() const { return inputs_[0]; }
   Value* value1() const { return inputs_[1]; }
   Value* value2() const { return inputs_[2]; }
   Value* value3() const { return inputs_[3]; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedInt32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx >= 0) && (idx < 4));
     return kTagged;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
@@ skipping 19 matching lines @@
                       Value* value,
                       intptr_t deopt_id)
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kTagged; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedInt32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
@@ skipping 23 matching lines @@
                            Value* value,
                            intptr_t deopt_id)
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kTagged; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     if (op_kind_ == MethodRecognizer::kFloat32x4GetSignMask) {
       return kUnboxedFloat32x4;
     }
     ASSERT(op_kind_ == MethodRecognizer::kInt32x4GetSignMask);
     return kUnboxedInt32x4;
@@ skipping 30 matching lines @@
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, mask);
     SetInputAt(1, trueValue);
     SetInputAt(2, falseValue);
   }
 
   Value* mask() const { return inputs_[0]; }
   Value* trueValue() const { return inputs_[1]; }
   Value* falseValue() const { return inputs_[2]; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1) || (idx == 2));
     if (idx == 0) {
       return kUnboxedInt32x4;
     }
     return kUnboxedFloat32x4;
   }
@@ skipping 25 matching lines @@
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, value);
     SetInputAt(1, flagValue);
   }
 
   Value* value() const { return inputs_[0]; }
   Value* flagValue() const { return inputs_[1]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedInt32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     if (idx == 1) {
       return kTagged;
     }
     return kUnboxedInt32x4;
   }
@@ skipping 22 matching lines @@
 
 class Int32x4ToFloat32x4Instr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   Int32x4ToFloat32x4Instr(Value* left, intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedInt32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
@@ skipping 22 matching lines @@
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   Token::Kind op_kind() const { return op_kind_; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedInt32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedInt32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
@@ skipping 26 matching lines @@
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   Token::Kind op_kind() const { return op_kind_; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedFloat64x2; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedFloat64x2;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
@@ skipping 54 matching lines @@
   const Token::Kind op_kind_;
 };
 
 
 // Handles both Smi operations: BIT_OR and NEGATE.
 class UnarySmiOpInstr : public UnaryIntegerOpInstr {
  public:
   UnarySmiOpInstr(Token::Kind op_kind, Value* value, intptr_t deopt_id)
       : UnaryIntegerOpInstr(op_kind, value, deopt_id) {}
 
-  virtual bool CanDeoptimize() const { return op_kind() == Token::kNEGATE; }
+  virtual bool ComputeCanDeoptimize() const {
+    return op_kind() == Token::kNEGATE;
+  }
 
   virtual CompileType ComputeType() const;
 
   DECLARE_INSTRUCTION(UnarySmiOp)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnarySmiOpInstr);
 };
 
 
 class UnaryUint32OpInstr : public UnaryIntegerOpInstr {
  public:
   UnaryUint32OpInstr(Token::Kind op_kind, Value* value, intptr_t deopt_id)
       : UnaryIntegerOpInstr(op_kind, value, deopt_id) {
     ASSERT(op_kind == Token::kBIT_NOT);
   }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual CompileType ComputeType() const;
 
   virtual Representation representation() const { return kUnboxedUint32; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedUint32;
   }
 
   DECLARE_INSTRUCTION(UnaryUint32Op)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnaryUint32OpInstr);
 };
 
 
 class UnaryMintOpInstr : public UnaryIntegerOpInstr {
  public:
   UnaryMintOpInstr(Token::Kind op_kind, Value* value, intptr_t deopt_id)
       : UnaryIntegerOpInstr(op_kind, value, deopt_id) {
     ASSERT(op_kind == Token::kBIT_NOT);
   }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual CompileType ComputeType() const;
 
   virtual Representation representation() const { return kUnboxedMint; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedMint;
   }
 
@@ skipping 13 matching lines @@
       : TemplateDefinition(call->deopt_id()), call_(call), op_kind_(op_kind) {
     SetInputAt(0, left);
     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 CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::All(); }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   PRINT_OPERANDS_TO_SUPPORT
 
   DECLARE_INSTRUCTION(CheckedSmiOp)
 
  private:
@@ skipping 11 matching lines @@
                             InstanceCallInstr* call)
       : TemplateComparison(call->token_pos(), op_kind, call->deopt_id()),
         call_(call),
         is_negated_(false) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   InstanceCallInstr* call() const { return call_; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   virtual void NegateComparison() {
     ComparisonInstr::NegateComparison();
     is_negated_ = !is_negated_;
   }
 
   bool is_negated() const { return is_negated_; }
 
@@ skipping 57 matching lines @@
   }
 
   // Returns true if right is a non-zero Smi constant which absolute value is
   // a power of two.
   bool RightIsPowerOfTwoConstant() const;
 
   RawInteger* Evaluate(const Integer& left, const Integer& right) const;
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
-  virtual bool AllowsDCE() const {
-    switch (op_kind()) {
-      case Token::kADD:
-      case Token::kSUB:
-      case Token::kMUL:
-      case Token::kBIT_AND:
-      case Token::kBIT_OR:
-      case Token::kBIT_XOR:
-        return true;
-
-      case Token::kSHR:
-      case Token::kSHL:
-        // These instructions throw on negative shifts.
-        return !CanDeoptimize();
-
-      default:
-        return false;
-    }
-  }
-
   virtual bool AttributesEqual(Instruction* other) const;
 
   virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
 
   PRINT_OPERANDS_TO_SUPPORT
 
   DEFINE_INSTRUCTION_TYPE_CHECK(BinaryIntegerOp)
 
  protected:
@@ skipping 12 matching lines @@
 
 
 class BinarySmiOpInstr : public BinaryIntegerOpInstr {
  public:
   BinarySmiOpInstr(Token::Kind op_kind,
                    Value* left,
                    Value* right,
                    intptr_t deopt_id)
       : BinaryIntegerOpInstr(op_kind, left, right, deopt_id) {}
 
-  virtual bool CanDeoptimize() const;
+  virtual bool ComputeCanDeoptimize() const;
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
   virtual CompileType ComputeType() const;
 
   DECLARE_INSTRUCTION(BinarySmiOp)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BinarySmiOpInstr);
 };
 
@@ skipping 25 matching lines @@
         return right->BindsToConstant();
 
       default:
         return false;
     }
 #else
     return false;
 #endif
   }
 
-  virtual bool CanDeoptimize() const;
+  virtual bool ComputeCanDeoptimize() const;
 
   virtual Representation representation() const { return kUnboxedInt32; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedInt32;
   }
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
   virtual CompileType ComputeType() const;
 
   DECLARE_INSTRUCTION(BinaryInt32Op)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BinaryInt32OpInstr);
 };
 
 
 class BinaryUint32OpInstr : public BinaryIntegerOpInstr {
  public:
   BinaryUint32OpInstr(Token::Kind op_kind,
                       Value* left,
                       Value* right,
                       intptr_t deopt_id)
       : BinaryIntegerOpInstr(op_kind, left, right, deopt_id) {
     mark_truncating();
   }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedUint32; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedUint32;
   }
 
   virtual CompileType ComputeType() const;
 
   DECLARE_INSTRUCTION(BinaryUint32Op)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BinaryUint32OpInstr);
 };
 
 
 class ShiftUint32OpInstr : public BinaryIntegerOpInstr {
  public:
   ShiftUint32OpInstr(Token::Kind op_kind,
                      Value* left,
                      Value* right,
                      intptr_t deopt_id)
       : BinaryIntegerOpInstr(op_kind, left, right, deopt_id) {
     ASSERT((op_kind == Token::kSHR) || (op_kind == Token::kSHL));
   }
 
-  virtual bool CanDeoptimize() const { return true; }
+  virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual Representation representation() const { return kUnboxedUint32; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return (idx == 0) ? kUnboxedUint32 : kTagged;
   }
 
   virtual CompileType ComputeType() const;
 
   DECLARE_INSTRUCTION(ShiftUint32Op)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ShiftUint32OpInstr);
 };
 
 
 class BinaryMintOpInstr : public BinaryIntegerOpInstr {
  public:
   BinaryMintOpInstr(Token::Kind op_kind,
                     Value* left,
                     Value* right,
                     intptr_t deopt_id)
       : BinaryIntegerOpInstr(op_kind, left, right, deopt_id) {}
 
-  virtual bool CanDeoptimize() const {
+  virtual bool ComputeCanDeoptimize() const {
     return (can_overflow() &&
             ((op_kind() == Token::kADD) || (op_kind() == Token::kSUB))) ||
            (op_kind() == Token::kMUL);  // Deopt if inputs are not int32.
   }
 
   virtual Representation representation() const { return kUnboxedMint; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedMint;
@@ skipping 12 matching lines @@
 class ShiftMintOpInstr : public BinaryIntegerOpInstr {
  public:
   ShiftMintOpInstr(Token::Kind op_kind,
                    Value* left,
                    Value* right,
                    intptr_t deopt_id)
       : BinaryIntegerOpInstr(op_kind, left, right, deopt_id) {
     ASSERT((op_kind == Token::kSHR) || (op_kind == Token::kSHL));
   }
 
-  virtual bool CanDeoptimize() const {
+  virtual bool ComputeCanDeoptimize() const {
     return has_shift_count_check() ||
            (can_overflow() && (op_kind() == Token::kSHL));
   }
 
   virtual Representation representation() const { return kUnboxedMint; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return (idx == 0) ? kUnboxedMint : kTagged;
   }
@@ skipping 18 matching lines @@
     ASSERT(op_kind == Token::kNEGATE);
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
   Token::Kind op_kind() const { return op_kind_; }
 
   DECLARE_INSTRUCTION(UnaryDoubleOp)
   virtual CompileType ComputeType() const;
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   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 Representation representation() const { return kUnboxedDouble; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
@@ skipping 18 matching lines @@
       : TemplateInstruction(Thread::Current()->GetNextDeoptId()),
         token_pos_(token_pos),
         loop_depth_(loop_depth) {}
 
   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 CanDeoptimize() const { return true; }
+  virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const TokenPosition token_pos_;
   const intptr_t loop_depth_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckStackOverflowInstr);
 };
 
 
 // TODO(vegorov): remove this instruction in favor of Int32ToDouble.
 class SmiToDoubleInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   SmiToDoubleInstr(Value* value, TokenPosition token_pos)
       : token_pos_(token_pos) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   DECLARE_INSTRUCTION(SmiToDouble)
   virtual CompileType ComputeType() const;
 
   virtual Representation representation() const { return kUnboxedDouble; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(SmiToDoubleInstr);
 };
 
 
 class Int32ToDoubleInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   explicit Int32ToDoubleInstr(Value* value) { SetInputAt(0, value); }
 
   Value* value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(Int32ToDouble)
   virtual CompileType ComputeType() const;
 
   virtual Representation RequiredInputRepresentation(intptr_t index) const {
     ASSERT(index == 0);
     return kUnboxedInt32;
   }
 
   virtual Representation representation() const { return kUnboxedDouble; }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Int32ToDoubleInstr);
 };
 
 
 class MintToDoubleInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
@@ skipping 13 matching lines @@
   }
 
   virtual Representation representation() const { return kUnboxedDouble; }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MintToDoubleInstr);
 };
 
 
 class DoubleToIntegerInstr : public TemplateDefinition<1, Throws> {
  public:
   DoubleToIntegerInstr(Value* value, InstanceCallInstr* instance_call)
       : TemplateDefinition(instance_call->deopt_id()),
         instance_call_(instance_call) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
   InstanceCallInstr* instance_call() const { return instance_call_; }
 
   DECLARE_INSTRUCTION(DoubleToInteger)
   virtual CompileType ComputeType() const;
 
   virtual intptr_t ArgumentCount() const { return 1; }
 
-  virtual bool CanDeoptimize() const { return true; }
+  virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   InstanceCallInstr* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(DoubleToIntegerInstr);
 };
 
 
 // Similar to 'DoubleToIntegerInstr' but expects unboxed double as input
 // and creates a Smi.
 class DoubleToSmiInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   DoubleToSmiInstr(Value* value, intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(DoubleToSmi)
   virtual CompileType ComputeType() const;
 
-  virtual bool CanDeoptimize() const { return true; }
+  virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
@@ skipping 11 matching lines @@
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   MethodRecognizer::Kind recognized_kind() const { return recognized_kind_; }
 
   DECLARE_INSTRUCTION(DoubleToDouble)
   virtual CompileType ComputeType() const;
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedDouble; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
@@ skipping 14 matching lines @@
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(DoubleToFloat)
 
   virtual CompileType ComputeType() const;
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     // This works since double is the representation that the typed array
     // store expects.
     // TODO(fschneider): Change this to a genuine float representation once it
     // is supported.
     return kUnboxedDouble;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
@@ skipping 18 matching lines @@
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(FloatToDouble)
 
   virtual CompileType ComputeType() const;
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedDouble; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
@@ skipping 17 matching lines @@
 
   const RuntimeEntry& TargetFunction() const;
 
   MethodRecognizer::Kind recognized_kind() const { return recognized_kind_; }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   DECLARE_INSTRUCTION(InvokeMathCFunction)
   virtual CompileType ComputeType() const;
 
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedDouble; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((0 <= idx) && (idx < InputCount()));
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
@@ skipping 38 matching lines @@
         definition_rep_(definition_rep),
         definition_cid_(definition_cid) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(ExtractNthOutput)
 
   virtual CompileType ComputeType() const;
-  virtual bool CanDeoptimize() const { return false; }
+  virtual bool ComputeCanDeoptimize() const { return false; }
 
   intptr_t index() const { return index_; }
 
   virtual Representation representation() const { return definition_rep_; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     if (representation() == kTagged) {
       return kPairOfTagged;
     }
@@ skipping 40 matching lines @@
 
   virtual intptr_t InputCount() const { return inputs_->length(); }
 
   virtual Value* InputAt(intptr_t i) const { return (*inputs_)[i]; }
 
   static intptr_t OutputIndexOf(MethodRecognizer::Kind kind);
   static intptr_t OutputIndexOf(Token::Kind token);
 
   virtual CompileType ComputeType() const;
 
-  virtual bool CanDeoptimize() const {
+  virtual bool ComputeCanDeoptimize() const {
     if (kind_ == kTruncDivMod) {
       return true;
     } else {
       UNIMPLEMENTED();
       return false;
     }
   }
 
   virtual Representation representation() const {
     if (kind_ == kTruncDivMod) {
@@ skipping 45 matching lines @@
 
 class CheckClassInstr : public TemplateInstruction<1, NoThrow> {
  public:
   CheckClassInstr(Value* value,
                   intptr_t deopt_id,
                   const ICData& unary_checks,
                   TokenPosition token_pos);
 
   DECLARE_INSTRUCTION(CheckClass)
 
-  virtual bool CanDeoptimize() const { return true; }
+  virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   Value* value() const { return inputs_[0]; }
 
   const ICData& unary_checks() const { return unary_checks_; }
 
   const GrowableArray<intptr_t>& cids() const { return cids_; }
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
@@ skipping 36 matching lines @@
         token_pos_(token_pos),
         licm_hoisted_(false) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   DECLARE_INSTRUCTION(CheckSmi)
 
-  virtual bool CanDeoptimize() const { return true; }
+  virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   bool licm_hoisted() const { return licm_hoisted_; }
   void set_licm_hoisted(bool value) { licm_hoisted_ = value; }
 
  private:
   const TokenPosition token_pos_;
   bool licm_hoisted_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckSmiInstr);
 };
 
 
 class CheckClassIdInstr : public TemplateInstruction<1, NoThrow> {
  public:
   CheckClassIdInstr(Value* value, intptr_t cid, intptr_t deopt_id)
       : TemplateInstruction(deopt_id), cid_(cid) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
   intptr_t cid() const { return cid_; }
 
   DECLARE_INSTRUCTION(CheckClassId)
 
-  virtual bool CanDeoptimize() const { return true; }
+  virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Dependencies() const;
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
@@ skipping 12 matching lines @@
         licm_hoisted_(false) {
     SetInputAt(kLengthPos, length);
     SetInputAt(kIndexPos, index);
   }
 
   Value* length() const { return inputs_[kLengthPos]; }
   Value* index() const { return inputs_[kIndexPos]; }
 
   DECLARE_INSTRUCTION(CheckArrayBound)
 
-  virtual bool CanDeoptimize() const { return true; }
+  virtual bool ComputeCanDeoptimize() const { return true; }
 
   bool IsRedundant(const RangeBoundary& length);
 
   void mark_generalized() { generalized_ = true; }
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   // Returns the length offset for array and string types.
   static intptr_t LengthOffsetFor(intptr_t class_id);
 
@@ skipping 23 matching lines @@
   }
 
   Value* length() const { return inputs_[kLengthPos]; }
   Value* index() const { return inputs_[kIndexPos]; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
   DECLARE_INSTRUCTION(GenericCheckBound)
 
-  virtual bool CanDeoptimize() const { return true; }
+  virtual bool ComputeCanDeoptimize() const { return true; }
 
   // Give a name to the location/input indices.
   enum { kLengthPos = 0, kIndexPos = 1 };
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GenericCheckBoundInstr);
 };
 
 
 class UnboxedIntConverterInstr : public TemplateDefinition<1, NoThrow> {
@@ skipping 17 matching lines @@
   Value* value() const { return inputs_[0]; }
 
   Representation from() const { return from_representation_; }
   Representation to() const { return to_representation_; }
   bool is_truncating() const { return is_truncating_; }
 
   void mark_truncating() { is_truncating_ = true; }
 
   Definition* Canonicalize(FlowGraph* flow_graph);
 
-  virtual bool CanDeoptimize() const;
+  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 EffectSet Dependencies() const { return EffectSet::None(); }
@@ skipping 25 matching lines @@
 
 
 class GrowRegExpStackInstr : public TemplateDefinition<1, Throws> {
  public:
   explicit GrowRegExpStackInstr(Value* typed_data_cell) {
     SetInputAt(0, typed_data_cell);
   }
 
   Value* typed_data_cell() const { return inputs_[0]; }
 
-  virtual bool CanDeoptimize() const { return MayThrow(); }
+  virtual bool ComputeCanDeoptimize() const { return MayThrow(); }
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   DECLARE_INSTRUCTION(GrowRegExpStack);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GrowRegExpStackInstr);
 };
 
 
 #undef DECLARE_INSTRUCTION
@@ skipping 185 matching lines @@
   // On all other architectures caller drops outgoing arguments itself
   // hence the difference.
   // Note: this method can only be used at the code generation stage because
   // it mutates environment in unsafe way (e.g. does not update def-use
   // chains).
   void DropArguments(intptr_t argc);
 #endif
 
  private:
   friend class ShallowIterator;
+  friend class BlockBuilder;  // For Environment constructor.
 
   Environment(intptr_t length,
               intptr_t fixed_parameter_count,
               intptr_t deopt_id,
               const ParsedFunction& parsed_function,
               Environment* outer)
       : values_(length),
         locations_(NULL),
         fixed_parameter_count_(fixed_parameter_count),
         deopt_id_(deopt_id),
@@ skipping 51 matching lines @@
   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_