Reland "ARM64: Add overflow checking support for multiplications by constant powers of 2."

src/arm64/lithium-codegen-arm64.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 4235 matching lines @@
 
 
 void LCodeGen::DoMulConstIS(LMulConstIS* instr) {
   ASSERT(instr->hydrogen()->representation().IsSmiOrInteger32());
   bool is_smi = instr->hydrogen()->representation().IsSmi();
   Register result =
       is_smi ? ToRegister(instr->result()) : ToRegister32(instr->result());
   Register left =
       is_smi ? ToRegister(instr->left()) : ToRegister32(instr->left()) ;
   int32_t right = ToInteger32(instr->right());
+  ASSERT((right > -kMaxInt) || (right < kMaxInt));
 
   bool can_overflow = instr->hydrogen()->CheckFlag(HValue::kCanOverflow);
   bool bailout_on_minus_zero =
     instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero);
 
   if (bailout_on_minus_zero) {
     if (right < 0) {
       // The result is -0 if right is negative and left is zero.
       DeoptimizeIfZero(left, instr->environment());
     } else if (right == 0) {
@@ skipping 23 matching lines @@
       break;
     case 2:
       if (can_overflow) {
         __ Adds(result, left, left);
         DeoptimizeIf(vs, instr->environment());
       } else {
         __ Add(result, left, left);
       }
       break;
 
-    // All other cases cannot detect overflow, because it would probably be no
-    // faster than using the smull method in LMulI.
-    // TODO(jbramley): Investigate this, and add overflow support if it would
-    // be useful.
     default:
+      // Multiplication by constant powers of two (and some related values)
+      // can be done efficiently with shifted operands.
+      int32_t right_abs = Abs(right);
+
+      if (IsPowerOf2(right_abs)) {
+        int right_log2 = WhichPowerOf2(right_abs);
+
+        if (can_overflow) {
+          Register scratch = result;
+          ASSERT(!AreAliased(scratch, left));
+          __ Cls(scratch, left);
+          __ Cmp(scratch, right_log2);
+          DeoptimizeIf(lt, instr->environment());
+        }
+
+        if (right >= 0) {
+          // result = left << log2(right)
+          __ Lsl(result, left, right_log2);
+        } else {
+          // result = -left << log2(-right)
+          if (can_overflow) {
+            __ Negs(result, Operand(left, LSL, right_log2));
+            DeoptimizeIf(vs, instr->environment());
+          } else {
+            __ Neg(result, Operand(left, LSL, right_log2));
+          }
+        }
+        return;
+      }
+
+
+      // For the following cases, we could perform a conservative overflow check
+      // with CLS as above. However the few cycles saved are likely not worth
+      // the risk of deoptimizing more often than required.
       ASSERT(!can_overflow);
 
-      // Multiplication by constant powers of two (and some related values)
-      // can be done efficiently with shifted operands.
       if (right >= 0) {
-        if (IsPowerOf2(right)) {
-          // result = left << log2(right)
-          __ Lsl(result, left, WhichPowerOf2(right));
-        } else if (IsPowerOf2(right - 1)) {
+        if (IsPowerOf2(right - 1)) {
           // result = left + left << log2(right - 1)
           __ Add(result, left, Operand(left, LSL, WhichPowerOf2(right - 1)));
         } else if (IsPowerOf2(right + 1)) {
           // result = -left + left << log2(right + 1)
           __ Sub(result, left, Operand(left, LSL, WhichPowerOf2(right + 1)));
           __ Neg(result, result);
         } else {
           UNREACHABLE();
         }
       } else {
-        if (IsPowerOf2(-right)) {
-          // result = -left << log2(-right)
-          __ Neg(result, Operand(left, LSL, WhichPowerOf2(-right)));
-        } else if (IsPowerOf2(-right + 1)) {
+        if (IsPowerOf2(-right + 1)) {
           // result = left - left << log2(-right + 1)
           __ Sub(result, left, Operand(left, LSL, WhichPowerOf2(-right + 1)));
         } else if (IsPowerOf2(-right - 1)) {
           // result = -left - left << log2(-right - 1)
           __ Add(result, left, Operand(left, LSL, WhichPowerOf2(-right - 1)));
           __ Neg(result, result);
         } else {
           UNREACHABLE();
         }
       }
-      break;
   }
 }
 
 
 void LCodeGen::DoMulI(LMulI* instr) {
   Register result = ToRegister32(instr->result());
   Register left = ToRegister32(instr->left());
   Register right = ToRegister32(instr->right());
 
   bool can_overflow = instr->hydrogen()->CheckFlag(HValue::kCanOverflow);
@@ skipping 1523 matching lines @@
   __ Bind(&out_of_object);
   __ Ldr(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
   // Index is equal to negated out of object property index plus 1.
   __ Sub(result, result, Operand::UntagSmiAndScale(index, kPointerSizeLog2));
   __ Ldr(result, FieldMemOperand(result,
                                  FixedArray::kHeaderSize - kPointerSize));
   __ Bind(&done);
 }
 
 } }  // namespace v8::internal