Revert "MIPS64: Fix lithium arithmetic operations for integers to sign-extend result."

src/mips64/lithium-codegen-mips64.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/code-factory.h"
 #include "src/code-stubs.h"
 #include "src/cpu-profiler.h"
 #include "src/hydrogen-osr.h"
@@ skipping 1473 matching lines @@
       DeoptimizeIf(eq, instr, Deoptimizer::kMinusZero, left, Operand(zero_reg));
     }
 
     switch (constant) {
       case -1:
         if (overflow) {
           __ SubuAndCheckForOverflow(result, zero_reg, left, scratch);
           DeoptimizeIf(gt, instr, Deoptimizer::kOverflow, scratch,
                        Operand(kMaxInt));
         } else {
-          __ Subu(result, zero_reg, left);
+          __ Dsubu(result, zero_reg, left);
         }
         break;
       case 0:
         if (bailout_on_minus_zero) {
           // If left is strictly negative and the constant is null, the
           // result is -0. Deoptimize if required, otherwise return 0.
           DeoptimizeIf(lt, instr, Deoptimizer::kMinusZero, left,
                        Operand(zero_reg));
         }
         __ mov(result, zero_reg);
         break;
       case 1:
         // Nothing to do.
         __ Move(result, left);
         break;
       default:
         // Multiplying by powers of two and powers of two plus or minus
         // one can be done faster with shifted operands.
         // For other constants we emit standard code.
         int32_t mask = constant >> 31;
         uint32_t constant_abs = (constant + mask) ^ mask;
 
         if (base::bits::IsPowerOfTwo32(constant_abs)) {
           int32_t shift = WhichPowerOf2(constant_abs);
-          __ sll(result, left, shift);
+          __ dsll(result, left, shift);
           // Correct the sign of the result if the constant is negative.
-          if (constant < 0) __ Subu(result, zero_reg, result);
+          if (constant < 0) __ Dsubu(result, zero_reg, result);
         } else if (base::bits::IsPowerOfTwo32(constant_abs - 1)) {
           int32_t shift = WhichPowerOf2(constant_abs - 1);
-          __ sll(scratch, left, shift);
-          __ addu(result, scratch, left);
+          __ dsll(scratch, left, shift);
+          __ Daddu(result, scratch, left);
           // Correct the sign of the result if the constant is negative.
           if (constant < 0)  __ Dsubu(result, zero_reg, result);
         } else if (base::bits::IsPowerOfTwo32(constant_abs + 1)) {
           int32_t shift = WhichPowerOf2(constant_abs + 1);
-          __ sll(scratch, left, shift);
-          __ Subu(result, scratch, left);
+          __ dsll(scratch, left, shift);
+          __ Dsubu(result, scratch, left);
           // Correct the sign of the result if the constant is negative.
           if (constant < 0)  __ Dsubu(result, zero_reg, result);
         } else {
           // Generate standard code.
           __ li(at, constant);
-          __ Mul(result, left, at);
+          __ Dmul(result, left, at);
         }
     }
 
   } else {
     DCHECK(right_op->IsRegister());
     Register right = ToRegister(right_op);
 
     if (overflow) {
       // hi:lo = left * right.
       if (instr->hydrogen()->representation().IsSmi()) {
         __ Dmulh(result, left, right);
       } else {
         __ Dmul(result, left, right);
       }
       __ dsra32(scratch, result, 0);
       __ sra(at, result, 31);
       if (instr->hydrogen()->representation().IsSmi()) {
         __ SmiTag(result);
       }
       DeoptimizeIf(ne, instr, Deoptimizer::kOverflow, scratch, Operand(at));
     } else {
       if (instr->hydrogen()->representation().IsSmi()) {
         __ SmiUntag(result, left);
-        __ mul(result, result, right);
+        __ Dmul(result, result, right);
       } else {
-        __ mul(result, left, right);
+        __ Dmul(result, left, right);
       }
     }
 
     if (bailout_on_minus_zero) {
       Label done;
       __ Xor(at, left, right);
       __ Branch(&done, ge, at, Operand(zero_reg));
       // Bail out if the result is minus zero.
       DeoptimizeIf(eq, instr, Deoptimizer::kMinusZero, result,
                    Operand(zero_reg));
@@ skipping 125 matching lines @@
 
 void LCodeGen::DoSubI(LSubI* instr) {
   LOperand* left = instr->left();
   LOperand* right = instr->right();
   LOperand* result = instr->result();
   bool can_overflow = instr->hydrogen()->CheckFlag(HValue::kCanOverflow);
 
   if (!can_overflow) {
     if (right->IsStackSlot()) {
       Register right_reg = EmitLoadRegister(right, at);
-      __ Subu(ToRegister(result), ToRegister(left), Operand(right_reg));
+      __ Dsubu(ToRegister(result), ToRegister(left), Operand(right_reg));
     } else {
       DCHECK(right->IsRegister() || right->IsConstantOperand());
-      __ Subu(ToRegister(result), ToRegister(left), ToOperand(right));
+      __ Dsubu(ToRegister(result), ToRegister(left), ToOperand(right));
     }
   } else {  // can_overflow.
     Register overflow = scratch0();
     Register scratch = scratch1();
     if (right->IsStackSlot() || right->IsConstantOperand()) {
       Register right_reg = EmitLoadRegister(right, scratch);
       __ SubuAndCheckForOverflow(ToRegister(result),
                                  ToRegister(left),
                                  right_reg,
                                  overflow);  // Reg at also used as scratch.
@@ skipping 168 matching lines @@
 
 void LCodeGen::DoAddI(LAddI* instr) {
   LOperand* left = instr->left();
   LOperand* right = instr->right();
   LOperand* result = instr->result();
   bool can_overflow = instr->hydrogen()->CheckFlag(HValue::kCanOverflow);
 
   if (!can_overflow) {
     if (right->IsStackSlot()) {
       Register right_reg = EmitLoadRegister(right, at);
-      __ Addu(ToRegister(result), ToRegister(left), Operand(right_reg));
+      __ Daddu(ToRegister(result), ToRegister(left), Operand(right_reg));
     } else {
       DCHECK(right->IsRegister() || right->IsConstantOperand());
-      __ Addu(ToRegister(result), ToRegister(left), ToOperand(right));
+      __ Daddu(ToRegister(result), ToRegister(left), ToOperand(right));
     }
   } else {  // can_overflow.
     Register overflow = scratch0();
     Register scratch = scratch1();
     if (right->IsStackSlot() ||
         right->IsConstantOperand()) {
       Register right_reg = EmitLoadRegister(right, scratch);
       __ AdduAndCheckForOverflow(ToRegister(result),
                                  ToRegister(left),
                                  right_reg,
@@ skipping 4202 matching lines @@
   __ Push(at, ToRegister(instr->function()));
   CallRuntime(Runtime::kPushBlockContext, 2, instr);
   RecordSafepoint(Safepoint::kNoLazyDeopt);
 }
 
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8