MIPS: Use BOVC/BNVC for overflow checking on r6.

src/full-codegen/mips/full-codegen-mips.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.
 
 #if V8_TARGET_ARCH_MIPS
 
 // Note on Mips implementation:
 //
 // The result_register() for mips is the 'v0' register, which is defined
 // by the ABI to contain function return values. However, the first
@@ skipping 2279 matching lines @@
     case Token::SHR: {
       __ SmiUntag(scratch1, left);
       __ GetLeastBitsFromSmi(scratch2, right, 5);
       __ srlv(scratch1, scratch1, scratch2);
       __ And(scratch2, scratch1, 0xc0000000);
       __ Branch(&stub_call, ne, scratch2, Operand(zero_reg));
       __ SmiTag(v0, scratch1);
       break;
     }
     case Token::ADD:
-      __ AdduAndCheckForOverflow(v0, left, right, scratch1);
-      __ BranchOnOverflow(&stub_call, scratch1);
+      __ AddBranchOvf(v0, left, Operand(right), &stub_call);
       break;
     case Token::SUB:
-      __ SubuAndCheckForOverflow(v0, left, right, scratch1);
+      __ SubBranchOvf(v0, left, Operand(right), &stub_call);
       __ BranchOnOverflow(&stub_call, scratch1);

[paul.l..., 2015/12/04 20:04:12]

No need for this macro-instr anymore, handled in previous instr.

[balazs.kilvady, 2015/12/05 11:58:44]

Thanks for catching it.
Done.

       break;
     case Token::MUL: {
       __ SmiUntag(scratch1, right);
       __ Mul(scratch2, v0, left, scratch1);
       __ sra(scratch1, v0, 31);
       __ Branch(&stub_call, ne, scratch1, Operand(scratch2));
       __ Branch(&done, ne, v0, Operand(zero_reg));
       __ Addu(scratch2, right, left);
       __ Branch(&stub_call, lt, scratch2, Operand(zero_reg));
       DCHECK(Smi::FromInt(0) == 0);
@@ skipping 1634 matching lines @@
               Operand(zero_reg));
   }
   __ bind(&loop);
   __ lw(string, MemOperand(element));
   __ Addu(element, element, kPointerSize);
   __ JumpIfSmi(string, &bailout);
   __ lw(scratch1, FieldMemOperand(string, HeapObject::kMapOffset));
   __ lbu(scratch1, FieldMemOperand(scratch1, Map::kInstanceTypeOffset));
   __ JumpIfInstanceTypeIsNotSequentialOneByte(scratch1, scratch2, &bailout);
   __ lw(scratch1, FieldMemOperand(string, SeqOneByteString::kLengthOffset));
-  __ AdduAndCheckForOverflow(string_length, string_length, scratch1, scratch3);
-  __ BranchOnOverflow(&bailout, scratch3);
+  __ AddBranchOvf(string_length, string_length, Operand(scratch1), &bailout);
   __ Branch(&loop, lt, element, Operand(elements_end));
 
   // If array_length is 1, return elements[0], a string.
   __ Branch(&not_size_one_array, ne, array_length, Operand(1));
   __ lw(v0, FieldMemOperand(elements, FixedArray::kHeaderSize));
   __ Branch(&done);
 
   __ bind(&not_size_one_array);
 
   // Live values in registers:
@@ skipping 12 matching lines @@
   // string_length to get the length of the result string. array_length is not
   // smi but the other values are, so the result is a smi.
   __ lw(scratch1, FieldMemOperand(separator, SeqOneByteString::kLengthOffset));
   __ Subu(string_length, string_length, Operand(scratch1));
   __ Mul(scratch3, scratch2, array_length, scratch1);
   // Check for smi overflow. No overflow if higher 33 bits of 64-bit result are
   // zero.
   __ Branch(&bailout, ne, scratch3, Operand(zero_reg));
   __ And(scratch3, scratch2, Operand(0x80000000));
   __ Branch(&bailout, ne, scratch3, Operand(zero_reg));
-  __ AdduAndCheckForOverflow(string_length, string_length, scratch2, scratch3);
-  __ BranchOnOverflow(&bailout, scratch3);
+  __ AddBranchOvf(string_length, string_length, Operand(scratch2), &bailout);
   __ SmiUntag(string_length);
 
   // Bailout for large object allocations.
   __ Branch(&bailout, gt, string_length,
             Operand(Page::kMaxRegularHeapObjectSize));
 
   // Get first element in the array to free up the elements register to be used
   // for the result.
   __ Addu(element,
           elements, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
@@ skipping 445 matching lines @@
             __ sw(v0, MemOperand(sp, 2 * kPointerSize));
             break;
           case KEYED_SUPER_PROPERTY:
             __ sw(v0, MemOperand(sp, 3 * kPointerSize));
             break;
         }
       }
     }
 
     Register scratch1 = a1;
-    Register scratch2 = t0;
     __ li(scratch1, Operand(Smi::FromInt(count_value)));
-    __ AdduAndCheckForOverflow(v0, v0, scratch1, scratch2);
-    __ BranchOnNoOverflow(&done, scratch2);
+    __ AddBranchNoOvf(v0, v0, Operand(scratch1), &done);
     // Call stub. Undo operation first.
     __ Move(v0, a0);
     __ jmp(&stub_call);
     __ bind(&slow);
   }
   if (!is_strong(language_mode())) {
     ToNumberStub convert_stub(isolate());
     __ CallStub(&convert_stub);
     PrepareForBailoutForId(expr->ToNumberId(), TOS_REG);
   }
@@ skipping 494 matching lines @@
          reinterpret_cast<uint32_t>(
              isolate->builtins()->OsrAfterStackCheck()->entry()));
   return OSR_AFTER_STACK_CHECK;
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_MIPS