Ensure that all goto instructions have deoptimization target.

runtime/vm/intermediate_language.h

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 517 matching lines @@
       : deopt_id_(Isolate::Current()->GetNextDeoptId()),
         lifetime_position_(-1),
         previous_(NULL),
         next_(NULL),
         env_(NULL),
         expr_id_(-1) { }
 
   virtual Tag tag() const = 0;
 
   intptr_t deopt_id() const {
-    ASSERT(CanDeoptimize());
+    ASSERT(CanDeoptimize() || CanBeDeoptimizationTarget());
     return deopt_id_;
   }
 
   bool IsBlockEntry() { return (AsBlockEntry() != NULL); }
   virtual BlockEntryInstr* AsBlockEntry() { return NULL; }
 
   bool IsDefinition() { return (AsDefinition() != NULL); }
   virtual Definition* AsDefinition() { return NULL; }
 
   bool IsControl() { return (AsControl() != NULL); }
@@ skipping 172 matching lines @@
   bool Equals(Instruction* other) const;
 
   // Compare attributes of a instructions (except input operands and tag).
   // 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(Instruction* other);
+
+  bool NeedsEnvironment() const {
+    return CanDeoptimize() || CanBeDeoptimizationTarget();
+  }
+
+  virtual bool CanBeDeoptimizationTarget() const {
+    return false;
+  }
+
+  void InheritDeoptTargetAfter(Instruction* other);
+
  protected:
   // Fetch deopt id without checking if this computation can deoptimize.
   intptr_t GetDeoptId() const {
     return deopt_id_;
   }
 
  private:
   friend class Definition;  // Needed for InsertBefore, InsertAfter.
 
   // Classes that set deopt_id_.
@@ skipping 12 matching lines @@
   friend class CheckArrayBoundInstr;
   friend class CheckEitherNonSmiInstr;
   friend class LICM;
   friend class DoubleToSmiInstr;
   friend class DoubleToDoubleInstr;
   friend class InvokeMathCFunctionInstr;
   friend class FlowGraphOptimizer;
   friend class LoadIndexedInstr;
   friend class StoreIndexedInstr;
   friend class StoreInstanceFieldInstr;
+  friend class ControlInstruction;
+  friend class ComparisonInstr;
+  friend class TargetEntryInstr;
+  friend class JoinEntryInstr;
+  friend class InstanceOfInstr;
 
   virtual void RawSetInputAt(intptr_t i, Value* value) = 0;
 
   intptr_t deopt_id_;
   intptr_t lifetime_position_;  // Position used by register allocator.
   Instruction* previous_;
   Instruction* next_;
   Environment* env_;
   intptr_t expr_id_;
 
@@ skipping 201 matching lines @@
       intptr_t fixed_parameter_count);
 
   virtual intptr_t InputCount() const { return 0; }
   virtual Value* InputAt(intptr_t i) const {
     UNREACHABLE();
     return NULL;
   }
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
+  virtual bool CanBeDeoptimizationTarget() const {
+    // BlockEntry environment is copied to Goto and Branch instructions
+    // when we insert new blocks targeting this block.
+    return true;
+  }
+
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   intptr_t try_index() const { return try_index_; }
 
   BitVector* loop_info() const { return loop_info_; }
   void set_loop_info(BitVector* loop_info) {
     loop_info_ = loop_info;
   }
@@ skipping 652 matching lines @@
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(Return)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   intptr_t token_pos() const { return token_pos_; }
   Value* value() const { return inputs_[0]; }
 
+  virtual bool CanBeDeoptimizationTarget() const {
+    // Return instruction might turn into a Goto instruction after inlining.
+    // Every Goto must have an environment.
+    return true;
+  }
+
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(ReturnInstr);
 };
 
@@ skipping 48 matching lines @@
 
   DECLARE_INSTRUCTION(Goto)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   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 bool CanBeDeoptimizationTarget() const {
+    // Goto instruction can be used as a deoptimization target when LICM
+    // hoists instructions out of the loop.
+    return true;
+  }
+
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   ParallelMoveInstr* parallel_move() const {
     return parallel_move_;
   }
 
   bool HasParallelMove() const {
     return parallel_move_ != NULL;
@@ skipping 48 matching lines @@
 class BranchInstr : public ControlInstruction {
  public:
   explicit BranchInstr(ComparisonInstr* comparison, bool is_checked = false);
 
   DECLARE_INSTRUCTION(Branch)
 
   virtual intptr_t ArgumentCount() const;
   intptr_t InputCount() const;
   Value* InputAt(intptr_t i) const;
   virtual bool CanDeoptimize() const;
+  virtual bool CanBeDeoptimizationTarget() const;
 
   virtual bool HasSideEffect() const;
 
   ComparisonInstr* comparison() const { return comparison_; }
   void SetComparison(ComparisonInstr* comp);
 
   bool is_checked() const { return is_checked_; }
 
   virtual LocationSummary* locs();
   virtual intptr_t DeoptimizationTarget() const;
@@ skipping 16 matching lines @@
   // successor.
   void set_constrained_type(ConstrainedCompileType* type) {
     constrained_type_ = type;
   }
 
   // Return compile type constrained by the comparison of this branch.
   ConstrainedCompileType* constrained_type() const {
     return constrained_type_;
   }
 
+  virtual void InheritDeoptTarget(Instruction* other);
+
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value);
 
   ComparisonInstr* comparison_;
   const bool is_checked_;
 
   ConstrainedCompileType* constrained_type_;
 
   DISALLOW_COPY_AND_ASSIGN(BranchInstr);
 };
@@ skipping 577 matching lines @@
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   virtual ComparisonInstr* AsComparison() { return this; }
 
   Token::Kind kind() const { return kind_; }
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch) = 0;
 
+  void SetDeoptId(intptr_t deopt_id) {
+    deopt_id_ = deopt_id;
+  }
+
  protected:
   Token::Kind kind_;
 };
 
 
 // Inlined functions from class BranchInstr that forward to their comparison.
 inline intptr_t BranchInstr::ArgumentCount() const {
   return comparison()->ArgumentCount();
 }
 
 
 inline intptr_t BranchInstr::InputCount() const {
   return comparison()->InputCount();
 }
 
 
 inline Value* BranchInstr::InputAt(intptr_t i) const {
   return comparison()->InputAt(i);
 }
 
 
 inline bool BranchInstr::CanDeoptimize() const {
   // Branches need a deoptimization info in checked mode if they
   // can throw a type check error.
   return comparison()->CanDeoptimize() || is_checked();
 }
 
 
+inline bool BranchInstr::CanBeDeoptimizationTarget() const {
+  return comparison()->CanBeDeoptimizationTarget();
+}
+
+
 inline bool BranchInstr::HasSideEffect() const {
   return comparison()->HasSideEffect();
 }
 
 
 inline LocationSummary* BranchInstr::locs() {
   if (comparison()->locs_ == NULL) {
     LocationSummary* summary = comparison()->MakeLocationSummary();
     // Branches don't produce a result.
     summary->set_out(Location::NoLocation());
@@ skipping 16 matching lines @@
 
 class StrictCompareInstr : public ComparisonInstr {
  public:
   StrictCompareInstr(Token::Kind kind, Value* left, Value* right);
 
   DECLARE_INSTRUCTION(StrictCompare)
   virtual CompileType ComputeType() const;
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool CanBeDeoptimizationTarget() const {
+    // StrictCompare can be merged into Branch and thus needs an environment.
+    return true;
+  }
+
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const;
   virtual bool AffectedBySideEffect() const { return false; }
 
   virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
@@ skipping 27 matching lines @@
   }
 
   DECLARE_INSTRUCTION(EqualityCompare)
   virtual CompileType ComputeType() const;
   virtual bool RecomputeType();
 
   const ICData* ic_data() const { return ic_data_; }
   bool HasICData() const {
     return (ic_data() != NULL) && !ic_data()->IsNull();
   }
+  void set_ic_data(const ICData* value) { ic_data_ = value; }
 
   intptr_t token_pos() const { return token_pos_; }
 
   // Receiver class id is computed from collected ICData.
   void set_receiver_class_id(intptr_t value) { receiver_class_id_ = value; }
   intptr_t receiver_class_id() const { return receiver_class_id_; }
 
   bool IsInlinedNumericComparison() const {
     return (receiver_class_id() == kDoubleCid)
         || (receiver_class_id() == kMintCid)
@@ skipping 50 matching lines @@
   }
 
   DECLARE_INSTRUCTION(RelationalOp)
   virtual CompileType ComputeType() const;
   virtual bool RecomputeType();
 
   const ICData* ic_data() const { return ic_data_; }
   bool HasICData() const {
     return (ic_data() != NULL) && !ic_data()->IsNull();
   }
+  void set_ic_data(const ICData* value) { ic_data_ = value; }
 
   intptr_t token_pos() const { return token_pos_; }
 
   // 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_; }
@@ skipping 487 matching lines @@
 };
 
 
 class InstanceOfInstr : public TemplateDefinition<3> {
  public:
   InstanceOfInstr(intptr_t token_pos,
                   Value* value,
                   Value* instantiator,
                   Value* instantiator_type_arguments,
                   const AbstractType& type,
-                  bool negate_result)
+                  bool negate_result,
+                  intptr_t deopt_id)
       : token_pos_(token_pos),
         type_(type),
         negate_result_(negate_result) {
     ASSERT(!type.IsNull());
     SetInputAt(0, value);
     SetInputAt(1, instantiator);
     SetInputAt(2, instantiator_type_arguments);
+    deopt_id_ = deopt_id;
   }
 
   DECLARE_INSTRUCTION(InstanceOf)
   virtual CompileType ComputeType() const;
 
   Value* value() const { return inputs_[0]; }
   Value* instantiator() const { return inputs_[1]; }
   Value* instantiator_type_arguments() const { return inputs_[2]; }
 
   bool negate_result() const { return negate_result_; }
@@ skipping 1546 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_