Use same range info when emitting code and computing if instruction can deopt.

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 435 matching lines @@
   M(BinaryMintOp)                                                              \
   M(ShiftMintOp)                                                               \
   M(UnaryMintOp)                                                               \
   M(CheckArrayBound)                                                           \
   M(GenericCheckBound)                                                         \
   M(Constraint)                                                                \
   M(StringToCharCode)                                                          \
   M(OneByteStringFromCharCode)                                                 \
   M(StringInterpolate)                                                         \
   M(InvokeMathCFunction)                                                       \
-  M(MergedMath)                                                                \
+  M(TruncDivMod)                                                               \
   M(GuardFieldClass)                                                           \
   M(GuardFieldLength)                                                          \
   M(IfThenElse)                                                                \
   M(BinaryFloat32x4Op)                                                         \
   M(Simd32x4Shuffle)                                                           \
   M(Simd32x4ShuffleMix)                                                        \
   M(Simd32x4GetSignMask)                                                       \
   M(Float32x4Constructor)                                                      \
   M(Float32x4Zero)                                                             \
   M(Float32x4Splat)                                                            \
@@ skipping 6455 matching lines @@
   bool is_truncating_;
 };
 
 
 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) {}
+      : BinaryIntegerOpInstr(op_kind, left, right, deopt_id),
+        right_range_(NULL) {}
 
   virtual bool ComputeCanDeoptimize() const;
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
   virtual CompileType ComputeType() const;
 
   DECLARE_INSTRUCTION(BinarySmiOp)
 
+  Range* right_range() const { return right_range_; }
+
  private:
+  Range* right_range_;
+
   DISALLOW_COPY_AND_ASSIGN(BinarySmiOpInstr);
 };
 
 
 class BinaryInt32OpInstr : public BinaryIntegerOpInstr {
  public:
   BinaryInt32OpInstr(Token::Kind op_kind,
                      Value* left,
                      Value* right,
                      intptr_t deopt_id)
       : BinaryIntegerOpInstr(op_kind, left, right, deopt_id) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   static bool IsSupported(Token::Kind op, Value* left, Value* right) {
 #if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_ARM)
     switch (op) {
       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::kSHL:
       case Token::kSHR:
-        return right->BindsToConstant();
+        if (right->BindsToConstant() && right->BoundConstant().IsSmi()) {
+          const intptr_t value = Smi::Cast(right->BoundConstant()).Value();
+          return 0 <= value && value < kBitsPerWord;
+        }
+        return false;
 
       default:
         return false;
     }
 #else
     return false;
 #endif
   }
 
   virtual bool ComputeCanDeoptimize() const;
@@ skipping 101 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(BinaryMintOpInstr);
 };
 
 
 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) {
+      : BinaryIntegerOpInstr(op_kind, left, right, deopt_id),
+        shift_range_(NULL) {
     ASSERT((op_kind == Token::kSHR) || (op_kind == Token::kSHL));
   }
 
+  Range* shift_range() const { return shift_range_; }
+
   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;
   }
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
   virtual CompileType ComputeType() const;
 
   DECLARE_INSTRUCTION(ShiftMintOp)
 
  private:
+  static const intptr_t kMintShiftCountLimit = 63;
   bool has_shift_count_check() const;
 
+  Range* shift_range_;
+
   DISALLOW_COPY_AND_ASSIGN(ShiftMintOpInstr);
 };
 
 
 // Handles only NEGATE.
 class UnaryDoubleOpInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   UnaryDoubleOpInstr(Token::Kind op_kind, Value* value, intptr_t deopt_id)
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     ASSERT(op_kind == Token::kNEGATE);
@@ skipping 412 matching lines @@
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const intptr_t index_;
   const Representation definition_rep_;
   const intptr_t definition_cid_;
   DISALLOW_COPY_AND_ASSIGN(ExtractNthOutputInstr);
 };
 
 
-class MergedMathInstr : public PureDefinition {
+class TruncDivModInstr : public TemplateDefinition<2, NoThrow, Pure> {
  public:
-  enum Kind {
-    kTruncDivMod,
-  };
+  TruncDivModInstr(Value* lhs, Value* rhs, intptr_t deopt_id);
 
-  MergedMathInstr(ZoneGrowableArray<Value*>* inputs,
-                  intptr_t original_deopt_id,
-                  MergedMathInstr::Kind kind);
-
-  static intptr_t InputCountFor(MergedMathInstr::Kind kind) {
-    if (kind == kTruncDivMod) {
-      return 2;
-    } else {
-      UNIMPLEMENTED();
-      return -1;
-    }
-  }
-
-  MergedMathInstr::Kind kind() const { return kind_; }
-
-  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 ComputeCanDeoptimize() const {
-    if (kind_ == kTruncDivMod) {
-      return true;
-    } else {
-      UNIMPLEMENTED();
-      return false;
-    }
-  }
+  virtual bool ComputeCanDeoptimize() const { return true; }
 
-  virtual Representation representation() const {
-    if (kind_ == kTruncDivMod) {
-      return kPairOfTagged;
-    } else {
-      UNIMPLEMENTED();
-      return kTagged;
-    }
-  }
+  virtual Representation representation() const { return kPairOfTagged; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((0 <= idx) && (idx < InputCount()));
-    if (kind_ == kTruncDivMod) {
-      return kTagged;
-    } else {
-      UNIMPLEMENTED();
-      return kTagged;
-    }
+    return kTagged;
   }
 
   virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
-  DECLARE_INSTRUCTION(MergedMath)
+  DECLARE_INSTRUCTION(TruncDivMod)
 
-  virtual bool AttributesEqual(Instruction* other) const {
-    MergedMathInstr* other_invoke = other->AsMergedMath();
-    return other_invoke->kind() == kind();
-  }
-
-  virtual bool MayThrow() const { return false; }
-
-  static const char* KindToCString(MergedMathInstr::Kind kind) {
-    if (kind == kTruncDivMod) return "TruncDivMod";
-    UNIMPLEMENTED();
-    return "";
-  }
+  virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
-  virtual void RawSetInputAt(intptr_t i, Value* value) {
-    (*inputs_)[i] = value;
+  Range* divisor_range() const {
+    // Note: this range is only used to remove check for zero divisor from
+    // the emitted pattern. It is not used for deciding whether instruction
+    // will deoptimize or not - that is why it is ok to access range of
+    // the definition directly. Otherwise range analysis or another pass
+    // needs to cache range of the divisor in the operation to prevent
+    // bugs when range information gets out of sync with the final decision
+    // whether some instruction can deoptimize or not made in
+    // EliminateEnvironments().
+    return InputAt(1)->definition()->range();
   }
-  ZoneGrowableArray<Value*>* inputs_;
-  MergedMathInstr::Kind kind_;
-  DISALLOW_COPY_AND_ASSIGN(MergedMathInstr);
+
+  DISALLOW_COPY_AND_ASSIGN(TruncDivModInstr);
 };
 
 
 class CheckClassInstr : public TemplateInstruction<1, NoThrow> {
  public:
   CheckClassInstr(Value* value,
                   intptr_t deopt_id,
                   const Cids& cids,
                   TokenPosition token_pos);
 
@@ skipping 528 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_