A64: Add support for SMI representation to MulConstI. Also add a test.

src/a64/lithium-a64.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 1830 matching lines @@
 
   } else if (hmod->representation().IsSmiOrTagged()) {
     return DoArithmeticT(Token::MOD, hmod);
   } else {
     return DoArithmeticD(Token::MOD, hmod);
   }
 }
 
 
 LInstruction* LChunkBuilder::DoMul(HMul* instr) {
-  if (instr->representation().IsSmi()) {
-    // TODO(jbramley): Implement LMulConstS, then merge this into the Integer32
-    // case.
+  if (instr->representation().IsSmiOrInteger32()) {
     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;
-
-    LOperand* left = UseRegister(instr->BetterLeftOperand());
-    LOperand* right = UseRegister(instr->BetterRightOperand());
-
-    LMulS* mul = new(zone()) LMulS(left, right);
-    if (needs_environment) AssignEnvironment(mul);
-    return DefineAsRegister(mul);
-  } else if (instr->representation().IsSmiOrInteger32()) {
-    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);
 
     // LMulConstI can handle a subset of constants:
     //  With support for overflow detection:
     //    -1, 0, 1, 2
     //  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;
 
       if (((constant >= -1) && (constant <= 2)) ||
           (!can_overflow && (IsPowerOf2(constant_abs) ||
                              IsPowerOf2(constant_abs + 1) ||
                              IsPowerOf2(constant_abs - 1)))) {
         LConstantOperand* right = UseConstant(most_const);
-        LMulConstI* mul = new(zone()) LMulConstI(left, right);
+        LMulConstIS* mul = new(zone()) LMulConstIS(left, right);
         if (needs_environment) AssignEnvironment(mul);
         return DefineAsRegister(mul);
       }
     }
 
-    // LMulI can handle all cases, but it requires that a register is allocated
-    // for the second operand.
-    LOperand* right = UseRegisterAtStart(most_const);
-    LMulI* mul = new(zone()) LMulI(left, right);
-    if (needs_environment) AssignEnvironment(mul);
-    return DefineAsRegister(mul);
+    // LMulI/S can handle all cases, but it requires that a register is
+    // allocated for the second operand.
+    LInstruction* result;
+    if (instr->representation().IsSmi()) {
+      // TODO(jbramley/rmcilroy): Fix LMulS so we can UseRegisterAtStart here.
+      LOperand* right = UseRegister(most_const);
+      result = DefineAsRegister(new(zone()) LMulS(left, right));
+    } else {
+      LOperand* right = UseRegisterAtStart(most_const);
+      result = DefineAsRegister(new(zone()) LMulI(left, right));
+    }
+    if (needs_environment) AssignEnvironment(result);
+    return result;
   } else if (instr->representation().IsDouble()) {
     return DoArithmeticD(Token::MUL, instr);
   } else {
     return DoArithmeticT(Token::MUL, instr);
   }
 }
 
 
 LInstruction* LChunkBuilder::DoOsrEntry(HOsrEntry* instr) {
   ASSERT(argument_count_ == 0);
@@ skipping 614 matching lines @@
 LInstruction* LChunkBuilder::DoWrapReceiver(HWrapReceiver* instr) {
   LOperand* receiver = UseRegister(instr->receiver());
   LOperand* function = UseRegisterAtStart(instr->function());
   LOperand* temp = TempRegister();
   LWrapReceiver* result = new(zone()) LWrapReceiver(receiver, function, temp);
   return AssignEnvironment(DefineAsRegister(result));
 }
 
 
 } }  // namespace v8::internal