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

src/arm64/lithium-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 1873 matching lines @@
     ASSERT(instr->left()->representation().Equals(instr->representation()));
     ASSERT(instr->right()->representation().Equals(instr->representation()));
 
     bool can_overflow = instr->CheckFlag(HValue::kCanOverflow);
     bool bailout_on_minus_zero = instr->CheckFlag(HValue::kBailoutOnMinusZero);
     bool needs_environment = can_overflow || bailout_on_minus_zero;
 
     HValue* least_const = instr->BetterLeftOperand();
     HValue* most_const = instr->BetterRightOperand();
 
-    LOperand* left = UseRegisterAtStart(least_const);
+    LOperand* left;
 
     // LMulConstI can handle a subset of constants:
     //  With support for overflow detection:
     //    -1, 0, 1, 2
+    //    2^n, -(2^n)
     //  Without support for overflow detection:
-    //    2^n, -(2^n)
     //    2^n + 1, -(2^n - 1)
     if (most_const->IsConstant()) {
       int32_t constant = HConstant::cast(most_const)->Integer32Value();
-      int32_t constant_abs = (constant >= 0) ? constant : -constant;
+      bool small_constant = (constant >= -1) && (constant <= 2);
+      bool end_range_constant = (constant <= -kMaxInt) || (constant == kMaxInt);
+      int32_t constant_abs = Abs(constant);
 
-      if (((constant >= -1) && (constant <= 2)) ||
-          (!can_overflow && (IsPowerOf2(constant_abs) ||
-                             IsPowerOf2(constant_abs + 1) ||
-                             IsPowerOf2(constant_abs - 1)))) {
+      if (!end_range_constant &&
+          (small_constant ||
+           (IsPowerOf2(constant_abs)) ||
+           (!can_overflow && (IsPowerOf2(constant_abs + 1) ||
+                              IsPowerOf2(constant_abs - 1))))) {
         LConstantOperand* right = UseConstant(most_const);
+        bool need_register = IsPowerOf2(constant_abs) && !small_constant;
+        left = need_register ? UseRegister(least_const)
+                             : UseRegisterAtStart(least_const);
         LMulConstIS* mul = new(zone()) LMulConstIS(left, right);
         if (needs_environment) AssignEnvironment(mul);
         return DefineAsRegister(mul);
       }
     }
 
+    left = UseRegisterAtStart(least_const);
     // LMulI/S can handle all cases, but it requires that a register is
     // allocated for the second operand.
     LInstruction* result;
     if (instr->representation().IsSmi()) {
       LOperand* right = UseRegisterAtStart(most_const);
       result = DefineAsRegister(new(zone()) LMulS(left, right));
     } else {
       LOperand* right = UseRegisterAtStart(most_const);
       result = DefineAsRegister(new(zone()) LMulI(left, right));
     }
@@ skipping 634 matching lines @@
 
 LInstruction* LChunkBuilder::DoWrapReceiver(HWrapReceiver* instr) {
   LOperand* receiver = UseRegister(instr->receiver());
   LOperand* function = UseRegister(instr->function());
   LWrapReceiver* result = new(zone()) LWrapReceiver(receiver, function);
   return AssignEnvironment(DefineAsRegister(result));
 }
 
 
 } }  // namespace v8::internal