Use range information to omit checks in TRUNCDIV/MOD operations.

runtime/vm/intermediate_language_x64.cc

 // 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.
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 2358 matching lines @@
         break;
     }
     if (FLAG_throw_on_javascript_int_overflow) {
       EmitJavascriptOverflowCheck(compiler, range(), deopt, result);
     }
     return;
   }  // locs()->in(1).IsStackSlot().
 
   // if locs()->in(1).IsRegister.
   Register right = locs()->in(1).reg();
+  Range* right_range = this->right()->definition()->range();
   switch (op_kind()) {
     case Token::kADD: {
       __ addq(left, right);
       if (deopt != NULL) __ j(OVERFLOW, deopt);
       break;
     }
     case Token::kSUB: {
       __ subq(left, right);
       if (deopt != NULL) __ j(OVERFLOW, deopt);
       break;
@@ skipping 20 matching lines @@
       break;
     }
     case Token::kTRUNCDIV: {
       Label not_32bit, done;
 
       Register temp = locs()->temp(0).reg();
       ASSERT(left == RAX);
       ASSERT((right != RDX) && (right != RAX));
       ASSERT(temp == RDX);
       ASSERT(result == RAX);
-
-      // Handle divide by zero in runtime.
-      __ testq(right, right);
-      __ j(ZERO, deopt);
-
+      if ((right_range == NULL) || right_range->Overlaps(0, 0)) {
+        // Handle divide by zero in runtime.
+        __ testq(right, right);
+        __ j(ZERO, deopt);
+      }
       // Check if both operands fit into 32bits as idiv with 64bit operands
       // requires twice as many cycles and has much higher latency.
       // We are checking this before untagging them to avoid corner case
       // dividing INT_MAX by -1 that raises exception because quotient is
       // too large for 32bit register.
       __ movsxd(temp, left);
       __ cmpq(temp, left);
       __ j(NOT_EQUAL, &not_32bit);
       __ movsxd(temp, right);
       __ cmpq(temp, right);
@@ skipping 22 matching lines @@
       break;
     }
     case Token::kMOD: {
       Label not_32bit, div_done;
 
       Register temp = locs()->temp(0).reg();
       ASSERT(left == RDX);
       ASSERT((right != RDX) && (right != RAX));
       ASSERT(temp == RAX);
       ASSERT(result == RDX);
-      // Handle divide by zero in runtime.
-      __ testq(right, right);
-      __ j(ZERO, deopt);
+      if ((right_range == NULL) || right_range->Overlaps(0, 0)) {
+        // Handle divide by zero in runtime.
+        __ testq(right, right);
+        __ j(ZERO, deopt);
+      }
       // Check if both operands fit into 32bits as idiv with 64bit operands
       // requires twice as many cycles and has much higher latency.
       // We are checking this before untagging them to avoid corner case
       // dividing INT_MAX by -1 that raises exception because quotient is
       // too large for 32bit register.
       __ movsxd(temp, left);
       __ cmpq(temp, left);
       __ j(NOT_EQUAL, &not_32bit);
       __ movsxd(temp, right);
       __ cmpq(temp, right);
@@ skipping 16 matching lines @@
       __ idivq(right);  //  RAX: quotient, RDX: remainder.
       __ Bind(&div_done);
       //  res = left % right;
       //  if (res < 0) {
       //    if (right < 0) {
       //      res = res - right;
       //    } else {
       //      res = res + right;
       //    }
       //  }
-      Label subtract, all_done;
+      Label all_done;
       __ cmpq(result, Immediate(0));
       __ j(GREATER_EQUAL, &all_done, Assembler::kNearJump);
       // Result is negative, adjust it.
-      __ cmpq(right, Immediate(0));
-      __ j(LESS, &subtract, Assembler::kNearJump);
-      __ addq(result, right);
-      __ jmp(&all_done, Assembler::kNearJump);
-      __ Bind(&subtract);
-      __ subq(result, right);
+      if ((right_range == NULL) || right_range->Overlaps(-1, 1)) {
+        Label subtract;
+        __ cmpq(right, Immediate(0));
+        __ j(LESS, &subtract, Assembler::kNearJump);
+        __ addq(result, right);
+        __ jmp(&all_done, Assembler::kNearJump);
+        __ Bind(&subtract);
+        __ subq(result, right);
+      } else if (right_range->IsWithin(0, RangeBoundary::kPlusInfinity)) {
+        // Right is positive.
+        __ addq(result, right);
+      } else {
+        // Right is negative.
+        __ subq(result, right);
+      }
       __ Bind(&all_done);
       __ SmiTag(result);
       break;
     }
     case Token::kSHR: {
       if (CanDeoptimize()) {
         __ CompareImmediate(right, Immediate(0), PP);
         __ j(LESS, deopt);
       }
       __ SmiUntag(right);
       // sarq operation masks the count to 6 bits.
       const intptr_t kCountLimit = 0x3F;
-      Range* right_range = this->right()->definition()->range();
       if ((right_range == NULL) ||
           !right_range->IsWithin(RangeBoundary::kMinusInfinity, kCountLimit)) {
         __ CompareImmediate(right, Immediate(kCountLimit), PP);
         Label count_ok;
         __ j(LESS, &count_ok, Assembler::kNearJump);
         __ LoadImmediate(right, Immediate(kCountLimit), PP);
         __ Bind(&count_ok);
       }
       ASSERT(right == RCX);  // Count must be in RCX
       __ SmiUntag(left);
@@ skipping 1516 matching lines @@
   if (kind() == MergedMathInstr::kTruncDivMod) {
     Register left = locs()->in(0).reg();
     Register right = locs()->in(1).reg();
     Register result = locs()->out().reg();
     Label not_32bit, done;
     Register temp = locs()->temp(0).reg();
     ASSERT(left == RAX);
     ASSERT((right != RDX) && (right != RAX));
     ASSERT(temp == RDX);
     ASSERT((result != RDX) && (result != RAX));
-    // Handle divide by zero in runtime.
-    __ testq(right, right);
-    __ j(ZERO, deopt);
+
+    Range* right_range = InputAt(1)->definition()->range();
+    if ((right_range == NULL) || right_range->Overlaps(0, 0)) {
+      // Handle divide by zero in runtime.
+      __ testq(right, right);
+      __ j(ZERO, deopt);
+    }
     // Check if both operands fit into 32bits as idiv with 64bit operands
     // requires twice as many cycles and has much higher latency.
     // We are checking this before untagging them to avoid corner case
     // dividing INT_MAX by -1 that raises exception because quotient is
     // too large for 32bit register.
     __ movsxd(temp, left);
     __ cmpq(temp, left);
     __ j(NOT_EQUAL, &not_32bit);
     __ movsxd(temp, right);
     __ cmpq(temp, right);
@@ skipping 22 matching lines @@
 
     // Modulo correction (RDX).
     //  res = left % right;
     //  if (res < 0) {
     //    if (right < 0) {
     //      res = res - right;
     //    } else {
     //      res = res + right;
     //    }
     //  }
-    Label subtract, all_done;
+    Label all_done;
     __ cmpq(RDX, Immediate(0));
     __ j(GREATER_EQUAL, &all_done, Assembler::kNearJump);
     // Result is negative, adjust it.
-    __ cmpq(right, Immediate(0));
-    __ j(LESS, &subtract, Assembler::kNearJump);
-    __ addq(RDX, right);
-    __ jmp(&all_done, Assembler::kNearJump);
-    __ Bind(&subtract);
-    __ subq(RDX, right);
+    if ((right_range == NULL) || right_range->Overlaps(-1, 1)) {
+      Label subtract;
+      __ cmpq(right, Immediate(0));
+      __ j(LESS, &subtract, Assembler::kNearJump);
+      __ addq(RDX, right);
+      __ jmp(&all_done, Assembler::kNearJump);
+      __ Bind(&subtract);
+      __ subq(RDX, right);
+    } else if (right_range->IsWithin(0, RangeBoundary::kPlusInfinity)) {
+      // Right is positive.
+      __ addq(RDX, right);
+    } else {
+      // Right is negative.
+      __ subq(RDX, right);
+    }
     __ Bind(&all_done);
     __ SmiTag(result);
 
     __ LoadObject(result, Array::ZoneHandle(Array::New(2, Heap::kOld)), PP);
     const intptr_t index_scale = FlowGraphCompiler::ElementSizeFor(kArrayCid);
     Address trunc_div_address(
         FlowGraphCompiler::ElementAddressForIntIndex(kArrayCid,
                                                      index_scale,
                                                      result,
                                                      0));
@@ skipping 540 matching lines @@
                          PcDescriptors::kOther,
                          locs());
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64