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

runtime/vm/intermediate_language_arm64.cc

 // Copyright (c) 2014, 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.
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_ARM64.
 #if defined(TARGET_ARCH_ARM64)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/compiler.h"
@@ skipping 2777 matching lines @@
       __ cmp(left, Operand(TMP, ASR, value));
       __ b(deopt, NE);  // Overflow.
     }
     // Shift for result now we know there is no overflow.
     __ LslImmediate(result, left, value);
     return;
   }
 
   // Right (locs.in(1)) is not constant.
   const Register right = locs.in(1).reg();
-  Range* right_range = shift_left->right()->definition()->range();
+  Range* right_range = shift_left->right_range();
   if (shift_left->left()->BindsToConstant() && shift_left->can_overflow()) {
     // TODO(srdjan): Implement code below for is_truncating().
     // If left is constant, we know the maximal allowed size for right.
     const Object& obj = shift_left->left()->BoundConstant();
     if (obj.IsSmi()) {
       const intptr_t left_int = Smi::Cast(obj).Value();
       if (left_int == 0) {
         __ CompareRegisters(right, ZR);
         __ b(deopt, MI);
         __ mov(result, ZR);
@@ skipping 10 matching lines @@
       __ SmiUntag(TMP, right);
       __ lslv(result, left, TMP);
     }
     return;
   }
 
   const bool right_needs_check =
       !RangeUtils::IsWithin(right_range, 0, (Smi::kBits - 1));
   if (!shift_left->can_overflow()) {
     if (right_needs_check) {
-      const bool right_may_be_negative =
-          (right_range == NULL) || !right_range->IsPositive();
-      if (right_may_be_negative) {
+      if (!RangeUtils::IsPositive(right_range)) {
         ASSERT(shift_left->CanDeoptimize());
         __ CompareRegisters(right, ZR);
         __ b(deopt, MI);
       }
 
       __ CompareImmediate(right,
                           reinterpret_cast<int64_t>(Smi::New(Smi::kBits)));
       __ csel(result, ZR, result, CS);
       __ SmiUntag(TMP, right);
       __ lslv(TMP, left, TMP);
@@ skipping 429 matching lines @@
         break;
       }
       default:
         UNREACHABLE();
         break;
     }
     return;
   }
 
   const Register right = locs()->in(1).reg();
-  Range* right_range = this->right()->definition()->range();
   switch (op_kind()) {
     case Token::kADD: {
       if (deopt == NULL) {
         __ add(result, left, Operand(right));
       } else {
         __ adds(result, left, Operand(right));
         __ b(deopt, VS);
       }
       break;
     }
@@ skipping 28 matching lines @@
       // No overflow check.
       __ orr(result, left, Operand(right));
       break;
     }
     case Token::kBIT_XOR: {
       // No overflow check.
       __ eor(result, left, Operand(right));
       break;
     }
     case Token::kTRUNCDIV: {
-      if ((right_range == NULL) || right_range->Overlaps(0, 0)) {
+      if (RangeUtils::CanBeZero(right_range())) {
         // Handle divide by zero in runtime.
         __ CompareRegisters(right, ZR);
         __ b(deopt, EQ);
       }
       const Register temp = TMP2;
       __ SmiUntag(temp, left);
       __ SmiUntag(TMP, right);
 
       __ sdiv(result, temp, TMP);
 
       // Check the corner case of dividing the 'MIN_SMI' with -1, in which
       // case we cannot tag the result.
       __ CompareImmediate(result, 0x4000000000000000LL);
       __ b(deopt, EQ);
       __ SmiTag(result);
       break;
     }
     case Token::kMOD: {
-      if ((right_range == NULL) || right_range->Overlaps(0, 0)) {
+      if (RangeUtils::CanBeZero(right_range())) {
         // Handle divide by zero in runtime.
         __ CompareRegisters(right, ZR);
         __ b(deopt, EQ);
       }
       const Register temp = TMP2;
       __ SmiUntag(temp, left);
       __ SmiUntag(TMP, right);
 
       __ sdiv(result, temp, TMP);
 
@@ skipping 20 matching lines @@
       break;
     }
     case Token::kSHR: {
       if (CanDeoptimize()) {
         __ CompareRegisters(right, ZR);
         __ b(deopt, LT);
       }
       __ SmiUntag(TMP, right);
       // sarl operation masks the count to 6 bits.
       const intptr_t kCountLimit = 0x3F;
-      if ((right_range == NULL) ||
-          !right_range->OnlyLessThanOrEqualTo(kCountLimit)) {
+      if (!RangeUtils::OnlyLessThanOrEqualTo(right_range(), kCountLimit)) {
         __ LoadImmediate(TMP2, kCountLimit);
         __ CompareRegisters(TMP, TMP2);
         __ csel(TMP, TMP2, TMP, GT);
       }
       const Register temp = locs()->temp(0).reg();
       __ SmiUntag(temp, left);
       __ asrv(result, temp, TMP);
       __ SmiTag(result);
       break;
     }
@@ skipping 1973 matching lines @@
     __ fmovdd(out, in);
   } else {
     ASSERT(representation() == kTagged);
     const Register out = locs()->out(0).reg();
     const Register in = in_loc.reg();
     __ mov(out, in);
   }
 }
 
 
-LocationSummary* MergedMathInstr::MakeLocationSummary(Zone* zone,
-                                                      bool opt) const {
-  if (kind() == MergedMathInstr::kTruncDivMod) {
-    const intptr_t kNumInputs = 2;
-    const intptr_t kNumTemps = 0;
-    LocationSummary* summary = new (zone)
-        LocationSummary(zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
-    summary->set_in(0, Location::RequiresRegister());
-    summary->set_in(1, Location::RequiresRegister());
-    // Output is a pair of registers.
-    summary->set_out(0, Location::Pair(Location::RequiresRegister(),
-                                       Location::RequiresRegister()));
-    return summary;
-  }
-  UNIMPLEMENTED();
-  return NULL;
+LocationSummary* TruncDivModInstr::MakeLocationSummary(Zone* zone,
+                                                       bool opt) const {
+  const intptr_t kNumInputs = 2;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* summary = new (zone)
+      LocationSummary(zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  summary->set_in(0, Location::RequiresRegister());
+  summary->set_in(1, Location::RequiresRegister());
+  // Output is a pair of registers.
+  summary->set_out(0, Location::Pair(Location::RequiresRegister(),
+                                     Location::RequiresRegister()));
+  return summary;
 }
 
 
-void MergedMathInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  Label* deopt = NULL;
-  if (CanDeoptimize()) {
-    deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptBinarySmiOp);
+void TruncDivModInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  ASSERT(CanDeoptimize());
+  Label* deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptBinarySmiOp);
+  const Register left = locs()->in(0).reg();
+  const Register right = locs()->in(1).reg();
+  ASSERT(locs()->out(0).IsPairLocation());
+  const PairLocation* pair = locs()->out(0).AsPairLocation();
+  const Register result_div = pair->At(0).reg();
+  const Register result_mod = pair->At(1).reg();
+  if (RangeUtils::CanBeZero(divisor_range())) {
+    // Handle divide by zero in runtime.
+    __ CompareRegisters(right, ZR);
+    __ b(deopt, EQ);
   }
-  if (kind() == MergedMathInstr::kTruncDivMod) {
-    const Register left = locs()->in(0).reg();
-    const Register right = locs()->in(1).reg();
-    ASSERT(locs()->out(0).IsPairLocation());
-    const PairLocation* pair = locs()->out(0).AsPairLocation();
-    const Register result_div = pair->At(0).reg();
-    const Register result_mod = pair->At(1).reg();
-    const Range* right_range = InputAt(1)->definition()->range();
-    if ((right_range == NULL) || right_range->Overlaps(0, 0)) {
-      // Handle divide by zero in runtime.
-      __ CompareRegisters(right, ZR);
-      __ b(deopt, EQ);
-    }
 
-    __ SmiUntag(result_mod, left);
-    __ SmiUntag(TMP, right);
+  __ SmiUntag(result_mod, left);
+  __ SmiUntag(TMP, right);
 
-    __ sdiv(result_div, result_mod, TMP);
+  __ sdiv(result_div, result_mod, TMP);
 
-    // Check the corner case of dividing the 'MIN_SMI' with -1, in which
-    // case we cannot tag the result.
-    __ CompareImmediate(result_div, 0x4000000000000000);
-    __ b(deopt, EQ);
-    // result_mod <- left - right * result_div.
-    __ msub(result_mod, TMP, result_div, result_mod);
-    __ SmiTag(result_div);
-    __ SmiTag(result_mod);
-    // Correct MOD result:
-    //  res = left % right;
-    //  if (res < 0) {
-    //    if (right < 0) {
-    //      res = res - right;
-    //    } else {
-    //      res = res + right;
-    //    }
-    //  }
-    Label done;
-    __ CompareRegisters(result_mod, ZR);
-    __ b(&done, GE);
-    // Result is negative, adjust it.
-    __ CompareRegisters(right, ZR);
-    __ sub(TMP2, result_mod, Operand(right));
-    __ add(TMP, result_mod, Operand(right));
-    __ csel(result_mod, TMP, TMP2, GE);
-    __ Bind(&done);
-    return;
-  }
-  UNIMPLEMENTED();
+  // Check the corner case of dividing the 'MIN_SMI' with -1, in which
+  // case we cannot tag the result.
+  __ CompareImmediate(result_div, 0x4000000000000000);
+  __ b(deopt, EQ);
+  // result_mod <- left - right * result_div.
+  __ msub(result_mod, TMP, result_div, result_mod);
+  __ SmiTag(result_div);
+  __ SmiTag(result_mod);
+  // Correct MOD result:
+  //  res = left % right;
+  //  if (res < 0) {
+  //    if (right < 0) {
+  //      res = res - right;
+  //    } else {
+  //      res = res + right;
+  //    }
+  //  }
+  Label done;
+  __ CompareRegisters(result_mod, ZR);
+  __ b(&done, GE);
+  // Result is negative, adjust it.
+  __ CompareRegisters(right, ZR);
+  __ sub(TMP2, result_mod, Operand(right));
+  __ add(TMP, result_mod, Operand(right));
+  __ csel(result_mod, TMP, TMP2, GE);
+  __ Bind(&done);
 }
 
 
 LocationSummary* PolymorphicInstanceCallInstr::MakeLocationSummary(
     Zone* zone,
     bool opt) const {
   return MakeCallSummary(zone);
 }
 
 
@@ skipping 258 matching lines @@
   UNIMPLEMENTED();
   return NULL;
 }
 
 
 void BinaryMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNIMPLEMENTED();
 }
 
 
-bool ShiftMintOpInstr::has_shift_count_check() const {
-  UNREACHABLE();
-  return false;
-}
-
-
 LocationSummary* ShiftMintOpInstr::MakeLocationSummary(Zone* zone,
                                                        bool opt) const {
   UNIMPLEMENTED();
   return NULL;
 }
 
 
 void ShiftMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNIMPLEMENTED();
 }
@@ skipping 339 matching lines @@
   compiler->GenerateRuntimeCall(TokenPosition::kNoSource, deopt_id(),
                                 kGrowRegExpStackRuntimeEntry, 1, locs());
   __ Drop(1);
   __ Pop(result);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64