Eliminate unnecessary deoptimization environments.

vm/intermediate_language.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 128 matching lines @@
   virtual void Accept(FlowGraphVisitor* visitor, BindInstr* instr) = 0;
 
   virtual intptr_t InputCount() const = 0;
   virtual Value* InputAt(intptr_t i) const = 0;
   virtual void SetInputAt(intptr_t i, Value* value) = 0;
 
   // Call computations override this function and return the
   // number of pushed arguments.
   virtual intptr_t ArgumentCount() const = 0;
 
+  // Returns true, if this computation can deoptimize. By default
+  // we assume every computation can deoptimize.

[srdjan, 2012/07/31 15:53:15]

The comment (by default we return true) does not match the implementation
(abstract method). Change method to return true or change comment.

[Florian Schneider, 2012/08/01 11:46:36]

Done.

+  virtual bool CanDeoptimize() const  = 0;
+
   // Static type of the computation.
   virtual RawAbstractType* StaticType() const = 0;
 
   // Mutate assigned_vars to add the local variable index for all
   // frame-allocated locals assigned to by the computation.
   virtual void RecordAssignedVars(BitVector* assigned_vars,
                                   intptr_t fixed_parameter_count);
 
   virtual const char* DebugName() const = 0;
 
@@ skipping 186 matching lines @@
  public:
   explicit UseVal(Definition* definition) : definition_(definition) {}
 
   DECLARE_VALUE(Use)
 
   inline Definition* definition() const;
   void set_definition(Definition* definition) {
     definition_ = definition;
   }
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   Definition* definition_;
 
   DISALLOW_COPY_AND_ASSIGN(UseVal);
 };
 
 
 class ConstantVal: public Value {
  public:
   explicit ConstantVal(const Object& value)
       : value_(value) {
     ASSERT(value.IsZoneHandle());
     ASSERT(value.IsSmi() || value.IsOld());
   }
 
   DECLARE_VALUE(Constant)
 
   const Object& value() const { return value_; }
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const Object& value_;
 
   DISALLOW_COPY_AND_ASSIGN(ConstantVal);
 };
 
 #undef DECLARE_VALUE
 
 
 class AssertAssignableComp : public TemplateComputation<3> {
@@ skipping 25 matching lines @@
   Value* instantiator() const { return inputs_[1]; }
   Value* instantiator_type_arguments() const { return inputs_[2]; }
 
   intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   const AbstractType& dst_type() const { return dst_type_; }
   const String& dst_name() const { return dst_name_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   const AbstractType& dst_type_;
   const String& dst_name_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertAssignableComp);
 };
 
 
 class AssertBooleanComp : public TemplateComputation<1> {
  public:
   AssertBooleanComp(intptr_t token_pos,
                     intptr_t try_index,
                     Value* value)
       : token_pos_(token_pos),
         try_index_(try_index) {
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   DECLARE_COMPUTATION(AssertBoolean)
 
   intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   Value* value() const { return inputs_[0]; }
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertBooleanComp);
 };
 
 
 // Denotes the current context, normally held in a register.  This is
 // a computation, not a value, because it's mutable.
 class CurrentContextComp : public TemplateComputation<0> {
  public:
   CurrentContextComp() { }
 
   DECLARE_COMPUTATION(CurrentContext)
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(CurrentContextComp);
 };
 
 
 class StoreContextComp : public TemplateComputation<1> {
  public:
   explicit StoreContextComp(Value* value) {
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   DECLARE_COMPUTATION(StoreContext);
 
   Value* value() const { return inputs_[0]; }
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(StoreContextComp);
 };
 
 
 class ClosureCallComp : public Computation {
  public:
   ClosureCallComp(ClosureCallNode* node,
                   intptr_t try_index,
                   ZoneGrowableArray<PushArgumentInstr*>* arguments)
       : ast_node_(*node),
         try_index_(try_index),
         arguments_(arguments) { }
 
   DECLARE_CALL_COMPUTATION(ClosureCall)
 
   const Array& argument_names() const { return ast_node_.arguments()->names(); }
   intptr_t token_pos() const { return ast_node_.token_pos(); }
   intptr_t try_index() const { return try_index_; }
 
   intptr_t ArgumentCount() const { return arguments_->length(); }
   PushArgumentInstr* ArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanDeoptimize() const { return false; }

[srdjan, 2012/07/31 19:49:28]

All calls have to return true (future work).

[Florian Schneider, 2012/08/01 11:46:36]

Yes. It will have to change once we have something like that. If we accidentally
remove an environment that is needed the ASSERT in the code generator will
trigger.

+
  private:
   const ClosureCallNode& ast_node_;
   const intptr_t try_index_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(ClosureCallComp);
 };
 
 
 class InstanceCallComp : public Computation {
@@ skipping 29 matching lines @@
   Token::Kind token_kind() const { return token_kind_; }
   intptr_t ArgumentCount() const { return arguments_->length(); }
   PushArgumentInstr* ArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
   const Array& argument_names() const { return argument_names_; }
   intptr_t checked_argument_count() const { return checked_argument_count_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   const String& function_name_;
   const Token::Kind token_kind_;  // Binary op, unary op, kGET or kILLEGAL.
   ZoneGrowableArray<PushArgumentInstr*>* const arguments_;
   const Array& argument_names_;
   const intptr_t checked_argument_count_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceCallComp);
@@ skipping 13 matching lines @@
   virtual Value* InputAt(intptr_t i) const {
     UNREACHABLE();
     return NULL;
   }
   virtual void SetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
 
   void PrintTo(BufferFormatter* f) const;
 
   DECLARE_COMPUTATION(PolymorphicInstanceCall)
 
+  virtual bool CanDeoptimize() const { return true; }
+
  private:
   InstanceCallComp* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(PolymorphicInstanceCallComp);
 };
 
 
 class ComparisonComp : public TemplateComputation<2> {
  public:
   ComparisonComp(Token::Kind kind, Value* left, Value* right) : kind_(kind) {
@@ skipping 19 matching lines @@
  public:
   StrictCompareComp(Token::Kind kind, Value* left, Value* right)
       : ComparisonComp(kind, left, right) {
     ASSERT((kind == Token::kEQ_STRICT) || (kind == Token::kNE_STRICT));
   }
 
   DECLARE_COMPUTATION(StrictCompare)
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(StrictCompareComp);
 };
 
 
 class EqualityCompareComp : public ComparisonComp {
  public:
   EqualityCompareComp(intptr_t token_pos,
                       intptr_t try_index,
                       Token::Kind kind,
                       Value* left,
                       Value* right)
       : ComparisonComp(kind, left, right),
         token_pos_(token_pos),
         try_index_(try_index),
         receiver_class_id_(kObject) {
     ASSERT((kind == Token::kEQ) || (kind == Token::kNE));
   }
 
   DECLARE_COMPUTATION(EqualityCompare)
 
   intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
 
   void set_receiver_class_id(intptr_t value) { receiver_class_id_ = value; }
   intptr_t receiver_class_id() const { return receiver_class_id_; }
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanDeoptimize() const { return true; }
+
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   intptr_t receiver_class_id_;  // Set by optimizer.
 
   DISALLOW_COPY_AND_ASSIGN(EqualityCompareComp);
 };
 
 
 class RelationalOpComp : public ComparisonComp {
@@ skipping 18 matching lines @@
   // TODO(srdjan): instead of class-id pass an enum that can differentiate
   // between boxed and unboxed doubles and integers.
   void set_operands_class_id(intptr_t value) {
     operands_class_id_ = value;
   }
 
   intptr_t operands_class_id() const { return operands_class_id_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanDeoptimize() const { return true; }
+
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   intptr_t operands_class_id_;  // class id of both operands.
 
   DISALLOW_COPY_AND_ASSIGN(RelationalOpComp);
 };
 
 
 class StaticCallComp : public Computation {
@@ skipping 24 matching lines @@
   intptr_t ArgumentCount() const { return arguments_->length(); }
   PushArgumentInstr* ArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
   MethodRecognizer::Kind recognized() const { return recognized_; }
   void set_recognized(MethodRecognizer::Kind kind) { recognized_ = kind; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   const Function& function_;
   const Array& argument_names_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
   MethodRecognizer::Kind recognized_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticCallComp);
 };
 
 
 class LoadLocalComp : public TemplateComputation<0> {
  public:
   LoadLocalComp(const LocalVariable& local, intptr_t context_level)
       : local_(local),
         context_level_(context_level) { }
 
   DECLARE_COMPUTATION(LoadLocal)
 
   const LocalVariable& local() const { return local_; }
   intptr_t context_level() const { return context_level_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const LocalVariable& local_;
   const intptr_t context_level_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadLocalComp);
 };
 
 
 class StoreLocalComp : public TemplateComputation<1> {
  public:
   StoreLocalComp(const LocalVariable& local,
                  Value* value,
                  intptr_t context_level)
       : local_(local),
         context_level_(context_level) {
     inputs_[0] = value;
   }
 
   DECLARE_COMPUTATION(StoreLocal)
 
   const LocalVariable& local() const { return local_; }
   Value* value() const { return inputs_[0]; }
   intptr_t context_level() const { return context_level_; }
 
   virtual void RecordAssignedVars(BitVector* assigned_vars,
                                   intptr_t fixed_parameter_count);
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const LocalVariable& local_;
   const intptr_t context_level_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreLocalComp);
 };
 
 
 class NativeCallComp : public TemplateComputation<0> {
  public:
@@ skipping 18 matching lines @@
   bool has_optional_parameters() const {
     return ast_node_.has_optional_parameters();
   }
 
   bool is_native_instance_closure() const {
     return ast_node_.is_native_instance_closure();
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const NativeBodyNode& ast_node_;
   const intptr_t try_index_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeCallComp);
 };
 
 
 class LoadInstanceFieldComp : public TemplateComputation<1> {
  public:
   LoadInstanceFieldComp(const Field& field,
                         Value* instance,
                         InstanceCallComp* original)  // Maybe NULL.
       : field_(field), original_(original) {
     ASSERT(instance != NULL);
     inputs_[0] = instance;
   }
 
   DECLARE_COMPUTATION(LoadInstanceField)
 
   const Field& field() const { return field_; }
   Value* instance() const { return inputs_[0]; }
   const InstanceCallComp* original() const { return original_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanDeoptimize() const { return true; }
+
  private:
   const Field& field_;
   const InstanceCallComp* original_;  // For optimizations.
 
   DISALLOW_COPY_AND_ASSIGN(LoadInstanceFieldComp);
 };
 
 
 class StoreInstanceFieldComp : public TemplateComputation<2> {
  public:
@@ skipping 12 matching lines @@
 
   const Field& field() const { return field_; }
 
   Value* instance() const { return inputs_[0]; }
   Value* value() const { return inputs_[1]; }
 
   const InstanceSetterComp* original() const { return original_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanDeoptimize() const { return true; }
+
  private:
   const Field& field_;
   const InstanceSetterComp* original_;  // For optimizations.
 
   DISALLOW_COPY_AND_ASSIGN(StoreInstanceFieldComp);
 };
 
 
 class LoadStaticFieldComp : public TemplateComputation<0> {
  public:
   explicit LoadStaticFieldComp(const Field& field) : field_(field) {}
 
   DECLARE_COMPUTATION(LoadStaticField);
 
   const Field& field() const { return field_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadStaticFieldComp);
 };
 
 
 class StoreStaticFieldComp : public TemplateComputation<1> {
  public:
   StoreStaticFieldComp(const Field& field, Value* value)
       : field_(field) {
     ASSERT(field.IsZoneHandle());
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   DECLARE_COMPUTATION(StoreStaticField);
 
   const Field& field() const { return field_; }
   Value* value() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreStaticFieldComp);
 };
 
 
 class LoadIndexedComp : public TemplateComputation<2> {
  public:
   LoadIndexedComp(intptr_t token_pos,
@@ skipping 17 matching lines @@
   Value* index() const { return inputs_[1]; }
 
   void set_receiver_type(ObjectKind receiver_type) {
     receiver_type_ = receiver_type;
   }
 
   ObjectKind receiver_type() const {
     return receiver_type_;
   }
 
+  virtual bool CanDeoptimize() const { return true; }
+
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   ObjectKind receiver_type_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadIndexedComp);
 };
 
 
 // Not simply an InstanceCall because it has somewhat more complicated
@@ skipping 22 matching lines @@
   Value* value() const { return inputs_[2]; }
 
   void set_receiver_type(ObjectKind receiver_type) {
     receiver_type_ = receiver_type;
   }
 
   ObjectKind receiver_type() const {
     return receiver_type_;
   }
 
+  virtual bool CanDeoptimize() const { return true; }
+
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   ObjectKind receiver_type_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreIndexedComp);
 };
 
 
 // Not simply an InstanceCall because it has somewhat more complicated
@@ skipping 13 matching lines @@
   }
 
   DECLARE_COMPUTATION(InstanceSetter)
 
   intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   const String& field_name() const { return field_name_; }
   Value* receiver() const { return inputs_[0]; }
   Value* value() const { return inputs_[1]; }
 
+  virtual bool CanDeoptimize() const { return true; }
+
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   const String& field_name_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceSetterComp);
 };
 
 
 // Not simply a StaticCall because it has somewhat more complicated
@@ skipping 10 matching lines @@
     inputs_[0] = value;
   }
 
   DECLARE_COMPUTATION(StaticSetter)
 
   intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   const Function& setter_function() const { return setter_function_; }
   Value* value() const { return inputs_[0]; }
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   const Function& setter_function_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticSetterComp);
 };
 
 
 // Note overrideable, built-in: value? false : true.
 class BooleanNegateComp : public TemplateComputation<1> {
  public:
   explicit BooleanNegateComp(Value* value) {
     inputs_[0] = value;
   }
 
   DECLARE_COMPUTATION(BooleanNegate)
 
   Value* value() const { return inputs_[0]; }
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(BooleanNegateComp);
 };
 
 
 class InstanceOfComp : public TemplateComputation<3> {
  public:
   InstanceOfComp(intptr_t token_pos,
                  intptr_t try_index,
                  Value* value,
@@ skipping 20 matching lines @@
   Value* instantiator() const { return inputs_[1]; }
   Value* instantiator_type_arguments() const { return inputs_[2]; }
 
   bool negate_result() const { return negate_result_; }
   const AbstractType& type() const { return type_; }
   intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   Value* value_;
   Value* instantiator_;
   Value* type_arguments_;
   const AbstractType& type_;
   const bool negate_result_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceOfComp);
@@ skipping 18 matching lines @@
   const ZoneGrowableArray<Value*>& arguments() const { return *arguments_; }
 
   virtual intptr_t InputCount() const;
   virtual Value* InputAt(intptr_t i) const { return arguments()[i]; }
   virtual void SetInputAt(intptr_t i, Value* value) {
     (*arguments_)[i] = value;
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const ConstructorCallNode& ast_node_;
   const intptr_t try_index_;
   ZoneGrowableArray<Value*>* const arguments_;
   DISALLOW_COPY_AND_ASSIGN(AllocateObjectComp);
 };
 
 
 class AllocateObjectWithBoundsCheckComp : public Computation {
  public:
@@ skipping 13 matching lines @@
   const ZoneGrowableArray<Value*>& arguments() const { return *arguments_; }
 
   virtual intptr_t InputCount() const;
   virtual Value* InputAt(intptr_t i) const { return arguments()[i]; }
   virtual void SetInputAt(intptr_t i, Value* value) {
     (*arguments_)[i] = value;
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const ConstructorCallNode& ast_node_;
   const intptr_t try_index_;
   ZoneGrowableArray<Value*>* const arguments_;
   DISALLOW_COPY_AND_ASSIGN(AllocateObjectWithBoundsCheckComp);
 };
 
 
 class CreateArrayComp : public TemplateComputation<1> {
  public:
@@ skipping 20 matching lines @@
   intptr_t ElementCount() const { return elements_->length(); }
   Value* ElementAt(intptr_t i) const { return (*elements_)[i]; }
   Value* element_type() const { return inputs_[0]; }
 
   virtual intptr_t InputCount() const;
   virtual Value* InputAt(intptr_t i) const;
   virtual void SetInputAt(intptr_t i, Value* value);
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   ZoneGrowableArray<Value*>* const elements_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateArrayComp);
 };
 
 
 class CreateClosureComp : public Computation {
@@ skipping 11 matching lines @@
   intptr_t try_index() const { return try_index_; }
   const Function& function() const { return ast_node_.function(); }
 
   intptr_t ArgumentCount() const { return arguments_->length(); }
   PushArgumentInstr* ArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const ClosureNode& ast_node_;
   const intptr_t try_index_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateClosureComp);
 };
 
 
 class LoadVMFieldComp : public TemplateComputation<1> {
@@ skipping 12 matching lines @@
   DECLARE_COMPUTATION(LoadVMField)
 
   Value* value() const { return inputs_[0]; }
   intptr_t offset_in_bytes() const { return offset_in_bytes_; }
   const AbstractType& type() const { return type_; }
   const InstanceCallComp* original() const { return original_; }
   void set_original(InstanceCallComp* value) { original_ = value; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanDeoptimize() const { return true; }
+
  private:
   const intptr_t offset_in_bytes_;
   const AbstractType& type_;
   const InstanceCallComp* original_;  // For optimizations.
   // If non-NULL, the instruction is valid only for the class ids listed.
 
   DISALLOW_COPY_AND_ASSIGN(LoadVMFieldComp);
 };
 
 
@@ skipping 12 matching lines @@
 
   DECLARE_COMPUTATION(StoreVMField)
 
   Value* value() const { return inputs_[0]; }
   Value* dest() const { return inputs_[1]; }
   intptr_t offset_in_bytes() const { return offset_in_bytes_; }
   const AbstractType& type() const { return type_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const intptr_t offset_in_bytes_;
   const AbstractType& type_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreVMFieldComp);
 };
 
 
 class InstantiateTypeArgumentsComp : public TemplateComputation<1> {
  public:
@@ skipping 12 matching lines @@
 
   Value* instantiator() const { return inputs_[0]; }
   const AbstractTypeArguments& type_arguments() const {
     return type_arguments_;
   }
   intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   const AbstractTypeArguments& type_arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(InstantiateTypeArgumentsComp);
 };
 
 
 class ExtractConstructorTypeArgumentsComp : public TemplateComputation<1> {
@@ skipping 14 matching lines @@
 
   Value* instantiator() const { return inputs_[0]; }
   const AbstractTypeArguments& type_arguments() const {
     return type_arguments_;
   }
   intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   const AbstractTypeArguments& type_arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtractConstructorTypeArgumentsComp);
 };
 
 
 class ExtractConstructorInstantiatorComp : public TemplateComputation<1> {
  public:
   ExtractConstructorInstantiatorComp(ConstructorCallNode* ast_node,
                                      Value* instantiator)
       : ast_node_(*ast_node) {
     ASSERT(instantiator != NULL);
     inputs_[0] = instantiator;
   }
 
   DECLARE_COMPUTATION(ExtractConstructorInstantiator)
 
   Value* instantiator() const { return inputs_[0]; }
   const AbstractTypeArguments& type_arguments() const {
     return ast_node_.type_arguments();
   }
   const Function& constructor() const { return ast_node_.constructor(); }
   intptr_t token_pos() const { return ast_node_.token_pos(); }
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const ConstructorCallNode& ast_node_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtractConstructorInstantiatorComp);
 };
 
 
 class AllocateContextComp : public TemplateComputation<0> {
  public:
   AllocateContextComp(intptr_t token_pos,
                       intptr_t try_index,
                       intptr_t num_context_variables)
       : token_pos_(token_pos),
         try_index_(try_index),
         num_context_variables_(num_context_variables) {}
 
   DECLARE_COMPUTATION(AllocateContext);
 
   intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   intptr_t num_context_variables() const { return num_context_variables_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   const intptr_t num_context_variables_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateContextComp);
 };
 
 
 class ChainContextComp : public TemplateComputation<1> {
  public:
   explicit ChainContextComp(Value* context_value) {
     ASSERT(context_value != NULL);
     inputs_[0] = context_value;
   }
 
   DECLARE_COMPUTATION(ChainContext)
 
   Value* context_value() const { return inputs_[0]; }
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(ChainContextComp);
 };
 
 
 class CloneContextComp : public TemplateComputation<1> {
  public:
   CloneContextComp(intptr_t token_pos,
                    intptr_t try_index,
                    Value* context_value)
       : token_pos_(token_pos),
         try_index_(try_index) {
     ASSERT(context_value != NULL);
     inputs_[0] = context_value;
   }
 
   intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   Value* context_value() const { return inputs_[0]; }
 
   DECLARE_COMPUTATION(CloneContext)
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
 
   DISALLOW_COPY_AND_ASSIGN(CloneContextComp);
 };
 
 
 class CatchEntryComp : public TemplateComputation<0> {
  public:
   CatchEntryComp(const LocalVariable& exception_var,
                  const LocalVariable& stacktrace_var)
       : exception_var_(exception_var), stacktrace_var_(stacktrace_var) {}
 
   const LocalVariable& exception_var() const { return exception_var_; }
   const LocalVariable& stacktrace_var() const { return stacktrace_var_; }
 
   DECLARE_COMPUTATION(CatchEntry)
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const LocalVariable& exception_var_;
   const LocalVariable& stacktrace_var_;
 
   DISALLOW_COPY_AND_ASSIGN(CatchEntryComp);
 };
 
 
 class BinaryOpComp : public TemplateComputation<2> {
  public:
@@ skipping 24 matching lines @@
   Token::Kind op_kind() const { return op_kind_; }
 
   OperandsType operands_type() const { return operands_type_; }
 
   InstanceCallComp* instance_call() const { return instance_call_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   DECLARE_COMPUTATION(BinaryOp)
 
+  virtual bool CanDeoptimize() const { return true; }
+
  private:
   const Token::Kind op_kind_;
   const OperandsType operands_type_;
   InstanceCallComp* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(BinaryOpComp);
 };
 
 
 // Handles both Smi operations: BIT_OR and NEGATE.
 class UnarySmiOpComp : public TemplateComputation<1> {
  public:
   UnarySmiOpComp(Token::Kind op_kind,
                  InstanceCallComp* instance_call,
                 Value* value)
       : op_kind_(op_kind), instance_call_(instance_call) {
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   Value* value() const { return inputs_[0]; }
   Token::Kind op_kind() const { return op_kind_; }
 
   InstanceCallComp* instance_call() const { return instance_call_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   DECLARE_COMPUTATION(UnarySmiOp)
 
+  virtual bool CanDeoptimize() const { return true; }
+
  private:
   const Token::Kind op_kind_;
   InstanceCallComp* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(UnarySmiOpComp);
 };
 
 
 // Handles non-Smi NEGATE operations
 class NumberNegateComp : public TemplateComputation<1> {
  public:
   NumberNegateComp(InstanceCallComp* instance_call,
                    Value* value) : instance_call_(instance_call) {
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   Value* value() const { return inputs_[0]; }
 
   InstanceCallComp* instance_call() const { return instance_call_; }
 
   DECLARE_COMPUTATION(NumberNegate)
 
+  virtual bool CanDeoptimize() const { return true; }
+
  private:
   InstanceCallComp* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(NumberNegateComp);
 };
 
 
 class CheckStackOverflowComp : public TemplateComputation<0> {
  public:
   CheckStackOverflowComp(intptr_t token_pos, intptr_t try_index)
       : token_pos_(token_pos),
         try_index_(try_index) {}
 
   intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
 
   DECLARE_COMPUTATION(CheckStackOverflow)
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckStackOverflowComp);
 };
 
 
 class ToDoubleComp : public TemplateComputation<1> {
  public:
   ToDoubleComp(Value* value,
                ObjectKind from,
                InstanceCallComp* instance_call)
       : from_(from), instance_call_(instance_call) {
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   Value* value() const { return inputs_[0]; }
   ObjectKind from() const { return from_; }
 
   InstanceCallComp* instance_call() const { return instance_call_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   DECLARE_COMPUTATION(ToDouble)
 
+  virtual bool CanDeoptimize() const { return true; }
+
  private:
   const ObjectKind from_;
   InstanceCallComp* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(ToDoubleComp);
 };
 
 
 #undef DECLARE_COMPUTATION
 
@@ skipping 86 matching lines @@
   virtual Definition* AsDefinition() { return NULL; }
 
   virtual intptr_t InputCount() const = 0;
   virtual Value* InputAt(intptr_t i) const = 0;
   virtual void SetInputAt(intptr_t i, Value* value) = 0;
 
   // Call instructions override this function and return the
   // number of pushed arguments.
   virtual intptr_t ArgumentCount() const = 0;
 
+  // Returns true, if this instruction can deoptimize.
+  virtual bool CanDeoptimize() const = 0;
+
   // Visiting support.
   virtual void Accept(FlowGraphVisitor* visitor) = 0;
 
   Instruction* previous() const { return previous_; }
   void set_previous(Instruction* instr) {
     ASSERT(!IsBlockEntry());
     previous_ = instr;
   }
 
   Instruction* next() const { return next_; }
@@ skipping 160 matching lines @@
       BlockEntryInstr* current_block,
       GrowableArray<BlockEntryInstr*>* preorder,
       GrowableArray<BlockEntryInstr*>* postorder,
       GrowableArray<intptr_t>* parent,
       GrowableArray<BitVector*>* assigned_vars,
       intptr_t variable_count,
       intptr_t fixed_parameter_count);
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
+  virtual bool CanDeoptimize() const { return false; }
+
  protected:
   BlockEntryInstr()
       : preorder_number_(-1),
         postorder_number_(-1),
         block_id_(-1),
         dominator_(NULL),
         dominated_blocks_(1),
         last_instruction_(NULL) { }
 
  private:
@@ skipping 242 matching lines @@
       : computation_(computation), is_used_(used != kUnused) {
     ASSERT(computation != NULL);
   }
 
   DECLARE_INSTRUCTION(Bind)
 
   virtual intptr_t ArgumentCount() const {
     return computation()->ArgumentCount();
   }
 
+  virtual bool CanDeoptimize() const { return computation()->CanDeoptimize(); }
+
   Computation* computation() const { return computation_; }
   void set_computation(Computation* value) { computation_ = value; }
   bool is_used() const { return is_used_; }
 
   // Static type of the underlying computation.
   virtual RawAbstractType* StaticType() const {
     return computation()->StaticType();
   }
 
   virtual void RecordAssignedVars(BitVector* assigned_vars,
@@ skipping 19 matching lines @@
     for (intptr_t i = 0; i < num_inputs; ++i) {
       inputs_.Add(NULL);
     }
   }
 
   // Least upper bound of the static types of the inputs.
   virtual RawAbstractType* StaticType() const;
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
+  virtual bool CanDeoptimize() const { return false; }
+
   DECLARE_INSTRUCTION(Phi)
 
  private:
   GrowableArray<Value*> inputs_;
 
   DISALLOW_COPY_AND_ASSIGN(PhiInstr);
 };
 
 
 class ParameterInstr : public Definition {
  public:
   explicit ParameterInstr(intptr_t index) : index_(index) { }
 
+  DECLARE_INSTRUCTION(Parameter)
+
   intptr_t index() const { return index_; }
 
   // Static type of the passed-in parameter.
   virtual RawAbstractType* StaticType() const;
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
-  DECLARE_INSTRUCTION(Parameter)
+  virtual bool CanDeoptimize() const { return false; }
 
  private:
   const intptr_t index_;
 
   DISALLOW_COPY_AND_ASSIGN(ParameterInstr);
 };
 
 
 class PushArgumentInstr : public InstructionWithInputs {
  public:
   explicit PushArgumentInstr(Value* value) : value_(value) { }
 
   DECLARE_INSTRUCTION(PushArgument)
 
   Value* value() const { return value_; }
 
   virtual LocationSummary* MakeLocationSummary() const;
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   Value* value_;
 
   DISALLOW_COPY_AND_ASSIGN(PushArgumentInstr);
 };
 
 
 class ReturnInstr : public InstructionWithInputs {
  public:
   ReturnInstr(intptr_t token_pos, Value* value)
       : InstructionWithInputs(), token_pos_(token_pos), value_(value) {
     ASSERT(value_ != NULL);
   }
 
   DECLARE_INSTRUCTION(Return)
 
   Value* value() const { return value_; }
   intptr_t token_pos() const { return token_pos_; }
 
   virtual LocationSummary* MakeLocationSummary() const;
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const intptr_t token_pos_;
   Value* value_;
 
   DISALLOW_COPY_AND_ASSIGN(ReturnInstr);
 };
 
 
 class ThrowInstr : public InstructionWithInputs {
  public:
@@ skipping 10 matching lines @@
   DECLARE_INSTRUCTION(Throw)
 
   intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   Value* exception() const { return exception_; }
 
   virtual LocationSummary* MakeLocationSummary() const;
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   Value* exception_;
 
   DISALLOW_COPY_AND_ASSIGN(ThrowInstr);
 };
 
 
 class ReThrowInstr : public InstructionWithInputs {
@@ skipping 15 matching lines @@
 
   intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   Value* exception() const { return exception_; }
   Value* stack_trace() const { return stack_trace_; }
 
   virtual LocationSummary* MakeLocationSummary() const;
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   Value* exception_;
   Value* stack_trace_;
 
   DISALLOW_COPY_AND_ASSIGN(ReThrowInstr);
 };
 
 
 class GotoInstr : public InstructionWithInputs {
  public:
   explicit GotoInstr(JoinEntryInstr* entry) : successor_(entry) { }
 
   DECLARE_INSTRUCTION(Goto)
 
   JoinEntryInstr* successor() const { return successor_; }
   void set_successor(JoinEntryInstr* successor) { successor_ = successor; }
   virtual intptr_t SuccessorCount() const;
   virtual BlockEntryInstr* SuccessorAt(intptr_t index) const;
 
   virtual LocationSummary* MakeLocationSummary() const;
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   JoinEntryInstr* successor_;
 };
 
 
 class BranchInstr : public InstructionWithInputs {
  public:
   BranchInstr(intptr_t token_pos,
               intptr_t try_index,
                Value* left,
@@ skipping 46 matching lines @@
       intptr_t variable_count,
       intptr_t fixed_parameter_count);
 
   virtual LocationSummary* MakeLocationSummary() const;
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
   void EmitBranchOnCondition(FlowGraphCompiler* compiler,
                              Condition true_condition);
 
+  virtual bool CanDeoptimize() const { return true; }
+
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   Value* left_;
   Value* right_;
   Token::Kind kind_;
   TargetEntryInstr* true_successor_;
   TargetEntryInstr* false_successor_;
 
   DISALLOW_COPY_AND_ASSIGN(BranchInstr);
@@ skipping 73 matching lines @@
     return move;
   }
 
   MoveOperands* MoveOperandsAt(intptr_t index) const { return moves_[index]; }
 
   void SetSrcSlotAt(intptr_t index, const Location& loc);
   void SetDestSlotAt(intptr_t index, const Location& loc);
 
   intptr_t NumMoves() const { return moves_.length(); }
 
+  virtual bool CanDeoptimize() const { return false; }
+
  private:
   GrowableArray<MoveOperands*> moves_;   // Elements cannot be null.
 
   DISALLOW_COPY_AND_ASSIGN(ParallelMoveInstr);
 };
 
 #undef DECLARE_INSTRUCTION
 
 
 class Environment : public ZoneAllocated {
@@ skipping 71 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_