MIPS: Fill more branch delay slots.

src/mips/code-stubs-mips.cc

 // Copyright 2012 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 330 matching lines @@
     __ And(at, a1, a1);
     __ Branch(&check_optimized, ne, at, Operand(zero_reg));
   }
   __ bind(&install_unoptimized);
   __ LoadRoot(t0, Heap::kUndefinedValueRootIndex);
   __ sw(t0, FieldMemOperand(v0, JSFunction::kNextFunctionLinkOffset));
   __ lw(a3, FieldMemOperand(a3, SharedFunctionInfo::kCodeOffset));
   __ Addu(a3, a3, Operand(Code::kHeaderSize - kHeapObjectTag));
 
   // Return result. The argument function info has been popped already.
+  __ Ret(USE_DELAY_SLOT);
   __ sw(a3, FieldMemOperand(v0, JSFunction::kCodeEntryOffset));
-  __ Ret();
 
   __ bind(&check_optimized);
 
   __ IncrementCounter(counters->fast_new_closure_try_optimized(), 1, t2, t3);
 
   // a2 holds native context, a1 points to fixed array of 3-element entries
   // (native context, optimized code, literals).
   // The optimized code map must never be empty, so check the first elements.
   Label install_optimized;
   // Speculatively move code object into t0.
@@ skipping 599 matching lines @@
   // but it just ends up combining harmlessly with the last digit of the
   // exponent that happens to be 1.  The sign bit is 0 so we shift 10 to get
   // the most significant 1 to hit the last bit of the 12 bit sign and exponent.
   ASSERT(((1 << HeapNumber::kExponentShift) & non_smi_exponent) != 0);
   const int shift_distance = HeapNumber::kNonMantissaBitsInTopWord - 2;
   __ srl(at, the_int_, shift_distance);
   __ or_(scratch_, scratch_, at);
   __ sw(scratch_, FieldMemOperand(the_heap_number_,
                                    HeapNumber::kExponentOffset));
   __ sll(scratch_, the_int_, 32 - shift_distance);
+  __ Ret(USE_DELAY_SLOT);
   __ sw(scratch_, FieldMemOperand(the_heap_number_,
                                    HeapNumber::kMantissaOffset));
-  __ Ret();
 
   __ bind(&max_negative_int);
   // The max negative int32 is stored as a positive number in the mantissa of
   // a double because it uses a sign bit instead of using two's complement.
   // The actual mantissa bits stored are all 0 because the implicit most
   // significant 1 bit is not stored.
   non_smi_exponent += 1 << HeapNumber::kExponentShift;
   __ li(scratch_, Operand(HeapNumber::kSignMask | non_smi_exponent));
   __ sw(scratch_,
         FieldMemOperand(the_heap_number_, HeapNumber::kExponentOffset));
   __ mov(scratch_, zero_reg);
+  __ Ret(USE_DELAY_SLOT);
   __ sw(scratch_,
         FieldMemOperand(the_heap_number_, HeapNumber::kMantissaOffset));
-  __ Ret();
 }
 
 
 // Handle the case where the lhs and rhs are the same object.
 // Equality is almost reflexive (everything but NaN), so this is a test
 // for "identity and not NaN".
 static void EmitIdenticalObjectComparison(MacroAssembler* masm,
                                           Label* slow,
                                           Condition cc) {
   Label not_identical;
@@ skipping 17 matching lines @@
     // Comparing JS objects with <=, >= is complicated.
     if (cc != eq) {
     __ Branch(slow, greater, t4, Operand(FIRST_SPEC_OBJECT_TYPE));
       // Normally here we fall through to return_equal, but undefined is
       // special: (undefined == undefined) == true, but
       // (undefined <= undefined) == false!  See ECMAScript 11.8.5.
       if (cc == less_equal || cc == greater_equal) {
         __ Branch(&return_equal, ne, t4, Operand(ODDBALL_TYPE));
         __ LoadRoot(t2, Heap::kUndefinedValueRootIndex);
         __ Branch(&return_equal, ne, a0, Operand(t2));
+        ASSERT(is_int16(GREATER) && is_int16(LESS));
+        __ Ret(USE_DELAY_SLOT);
         if (cc == le) {
           // undefined <= undefined should fail.
           __ li(v0, Operand(GREATER));
         } else  {
           // undefined >= undefined should fail.
           __ li(v0, Operand(LESS));
         }
-        __ Ret();
       }
     }
   }
 
   __ bind(&return_equal);
-
+  ASSERT(is_int16(GREATER) && is_int16(LESS));
+  __ Ret(USE_DELAY_SLOT);
   if (cc == less) {
     __ li(v0, Operand(GREATER));  // Things aren't less than themselves.
   } else if (cc == greater) {
     __ li(v0, Operand(LESS));     // Things aren't greater than themselves.
   } else {
     __ mov(v0, zero_reg);         // Things are <=, >=, ==, === themselves.
   }
-  __ Ret();
 
   // For less and greater we don't have to check for NaN since the result of
   // x < x is false regardless.  For the others here is some code to check
   // for NaN.
   if (cc != lt && cc != gt) {
     __ bind(&heap_number);
     // It is a heap number, so return non-equal if it's NaN and equal if it's
     // not NaN.
 
     // The representation of NaN values has all exponent bits (52..62) set,
@@ skipping 10 matching lines @@
     // Or with all low-bits of mantissa.
     __ lw(t3, FieldMemOperand(a0, HeapNumber::kMantissaOffset));
     __ Or(v0, t3, Operand(t2));
     // For equal we already have the right value in v0:  Return zero (equal)
     // if all bits in mantissa are zero (it's an Infinity) and non-zero if
     // not (it's a NaN).  For <= and >= we need to load v0 with the failing
     // value if it's a NaN.
     if (cc != eq) {
       // All-zero means Infinity means equal.
       __ Ret(eq, v0, Operand(zero_reg));
+      ASSERT(is_int16(GREATER) && is_int16(LESS));
+      __ Ret(USE_DELAY_SLOT);
       if (cc == le) {
         __ li(v0, Operand(GREATER));  // NaN <= NaN should fail.
       } else {
         __ li(v0, Operand(LESS));     // NaN >= NaN should fail.
       }
     }
-    __ Ret();
   }
   // No fall through here.
 
   __ bind(&not_identical);
 }
 
 
 static void EmitSmiNonsmiComparison(MacroAssembler* masm,
                                     Register lhs,
                                     Register rhs,
@@ skipping 354 matching lines @@
   // Check if EQUAL condition is satisfied. If true, move conditionally
   // result to v0.
   __ c(EQ, D, f12, f14);
   __ Movt(v0, t2);
 
   __ Ret();
 
   __ bind(&nan);
   // NaN comparisons always fail.
   // Load whatever we need in v0 to make the comparison fail.
+  ASSERT(is_int16(GREATER) && is_int16(LESS));
+  __ Ret(USE_DELAY_SLOT);
   if (cc == lt || cc == le) {
     __ li(v0, Operand(GREATER));
   } else {
     __ li(v0, Operand(LESS));
   }
-  __ Ret();
+
 
   __ bind(&not_smis);
   // At this point we know we are dealing with two different objects,
   // and neither of them is a Smi. The objects are in lhs_ and rhs_.
   if (strict()) {
     // This returns non-equal for some object types, or falls through if it
     // was not lucky.
     EmitStrictTwoHeapObjectCompare(masm, lhs, rhs);
   }
 
@@ skipping 243 matching lines @@
 }
 
 
 void UnaryOpStub::GenerateHeapNumberCodeSub(MacroAssembler* masm,
                                             Label* slow) {
   EmitCheckForHeapNumber(masm, a0, a1, t2, slow);
   // a0 is a heap number.  Get a new heap number in a1.
   if (mode_ == UNARY_OVERWRITE) {
     __ lw(a2, FieldMemOperand(a0, HeapNumber::kExponentOffset));
     __ Xor(a2, a2, Operand(HeapNumber::kSignMask));  // Flip sign.
+    __ Ret(USE_DELAY_SLOT);
     __ sw(a2, FieldMemOperand(a0, HeapNumber::kExponentOffset));
   } else {
     Label slow_allocate_heapnumber, heapnumber_allocated;
     __ AllocateHeapNumber(a1, a2, a3, t2, &slow_allocate_heapnumber);
     __ jmp(&heapnumber_allocated);
 
     __ bind(&slow_allocate_heapnumber);
     {
       FrameScope scope(masm, StackFrame::INTERNAL);
       __ push(a0);
       __ CallRuntime(Runtime::kNumberAlloc, 0);
       __ mov(a1, v0);
       __ pop(a0);
     }
 
     __ bind(&heapnumber_allocated);
     __ lw(a3, FieldMemOperand(a0, HeapNumber::kMantissaOffset));
     __ lw(a2, FieldMemOperand(a0, HeapNumber::kExponentOffset));
     __ sw(a3, FieldMemOperand(a1, HeapNumber::kMantissaOffset));
     __ Xor(a2, a2, Operand(HeapNumber::kSignMask));  // Flip sign.
     __ sw(a2, FieldMemOperand(a1, HeapNumber::kExponentOffset));
+    __ Ret(USE_DELAY_SLOT);
     __ mov(v0, a1);
   }
-  __ Ret();
 }
 
 
 void UnaryOpStub::GenerateHeapNumberCodeBitNot(
     MacroAssembler* masm,
     Label* slow) {
   Label impossible;
 
   EmitCheckForHeapNumber(masm, a0, a1, t2, slow);
   // Convert the heap number in a0 to an untagged integer in a1.
   __ ConvertToInt32(a0, a1, a2, a3, f0, slow);
 
   // Do the bitwise operation and check if the result fits in a smi.
   Label try_float;
   __ Neg(a1, a1);
   __ Addu(a2, a1, Operand(0x40000000));
   __ Branch(&try_float, lt, a2, Operand(zero_reg));
 
   // Tag the result as a smi and we're done.
+  __ Ret(USE_DELAY_SLOT);  // SmiTag emits one instruction in delay slot.
   __ SmiTag(v0, a1);
-  __ Ret();
 
   // Try to store the result in a heap number.
   __ bind(&try_float);
   if (mode_ == UNARY_NO_OVERWRITE) {
     Label slow_allocate_heapnumber, heapnumber_allocated;
     // Allocate a new heap number without zapping v0, which we need if it fails.
     __ AllocateHeapNumber(a2, a3, t0, t2, &slow_allocate_heapnumber);
     __ jmp(&heapnumber_allocated);
 
     __ bind(&slow_allocate_heapnumber);
@@ skipping 178 matching lines @@
       // Check for no remainder first.
       __ mfhi(scratch1);
       __ Branch(&not_smi_result, ne, scratch1, Operand(zero_reg));
       __ mflo(scratch1);
       __ Branch(&done, ne, scratch1, Operand(zero_reg));
       __ Branch(&not_smi_result, lt, scratch2, Operand(zero_reg));
       __ bind(&done);
       // Check that the signed result fits in a Smi.
       __ Addu(scratch2, scratch1, Operand(0x40000000));
       __ Branch(&not_smi_result, lt, scratch2, Operand(zero_reg));
+      __ Ret(USE_DELAY_SLOT);  // SmiTag emits one instruction in delay slot.
       __ SmiTag(v0, scratch1);
-      __ Ret();
       }
       break;
     case Token::MOD: {
       Label done;
       __ SmiUntag(scratch2, right);
       __ SmiUntag(scratch1, left);
       __ Div(scratch1, scratch2);
       // A minor optimization: div may be calculated asynchronously, so we check
       // for division by 0 before calling mfhi.
       // Check for zero on the right hand side.
       __ Branch(&not_smi_result, eq, scratch2, Operand(zero_reg));
       // If the result is 0, we need to make sure the dividend (left) is
       // positive (or 0), otherwise it is a -0 case.
       // Remainder is in 'hi'.
       __ mfhi(scratch2);
       __ Branch(&done, ne, scratch2, Operand(zero_reg));
       __ Branch(&not_smi_result, lt, scratch1, Operand(zero_reg));
       __ bind(&done);
       // Check that the signed result fits in a Smi.
       __ Addu(scratch1, scratch2, Operand(0x40000000));
       __ Branch(&not_smi_result, lt, scratch1, Operand(zero_reg));
+      __ Ret(USE_DELAY_SLOT);   // SmiTag emits one instruction in delay slot.
       __ SmiTag(v0, scratch2);
-      __ Ret();
       }
       break;
     case Token::BIT_OR:
       __ Ret(USE_DELAY_SLOT);
       __ or_(v0, left, right);
       break;
     case Token::BIT_AND:
       __ Ret(USE_DELAY_SLOT);
       __ and_(v0, left, right);
       break;
@@ skipping 13 matching lines @@
       // Remove tags from operands. We can't do this on a 31 bit number
       // because then the 0s get shifted into bit 30 instead of bit 31.
       __ SmiUntag(scratch1, left);
       __ GetLeastBitsFromSmi(scratch2, right, 5);
       __ srlv(v0, scratch1, scratch2);
       // Unsigned shift is not allowed to produce a negative number, so
       // check the sign bit and the sign bit after Smi tagging.
       __ And(scratch1, v0, Operand(0xc0000000));
       __ Branch(&not_smi_result, ne, scratch1, Operand(zero_reg));
       // Smi tag result.
+      __ Ret(USE_DELAY_SLOT);  // SmiTag emits one instruction in delay slot.
       __ SmiTag(v0);
-      __ Ret();
       break;
     case Token::SHL:
       // Remove tags from operands.
       __ SmiUntag(scratch1, left);
       __ GetLeastBitsFromSmi(scratch2, right, 5);
       __ sllv(scratch1, scratch1, scratch2);
       // Check that the signed result fits in a Smi.
       __ Addu(scratch2, scratch1, Operand(0x40000000));
       __ Branch(&not_smi_result, lt, scratch2, Operand(zero_reg));
-      __ SmiTag(v0, scratch1);
-      __ Ret();
+      __ Ret(USE_DELAY_SLOT);
+      __ SmiTag(v0, scratch1);  // SmiTag emits one instruction in delay slot.
       break;
     default:
       UNREACHABLE();
   }
   __ bind(&not_smi_result);
 }
 
 
 void BinaryOpStub_GenerateHeapResultAllocation(MacroAssembler* masm,
                                                Register result,
@@ skipping 181 matching lines @@
           // Use only the 5 least significant bits of the shift count.
           __ GetLeastBitsFromInt32(a2, a2, 5);
           __ sllv(a2, a3, a2);
           break;
         default:
           UNREACHABLE();
       }
       // Check that the *signed* result fits in a smi.
       __ Addu(a3, a2, Operand(0x40000000));
       __ Branch(&result_not_a_smi, lt, a3, Operand(zero_reg));
+      __ Ret(USE_DELAY_SLOT);  // SmiTag emits one instruction in delay slot.
       __ SmiTag(v0, a2);
-      __ Ret();
 
       // Allocate new heap number for result.
       __ bind(&result_not_a_smi);
       Register result = t1;
       if (smi_operands) {
         __ AllocateHeapNumber(
             result, scratch1, scratch2, heap_number_map, gc_required);
       } else {
         BinaryOpStub_GenerateHeapResultAllocation(
             masm, result, heap_number_map, scratch1, scratch2, gc_required,
@@ skipping 258 matching lines @@
           __ mfc1(scratch2, f11);
           __ And(scratch2, scratch2, HeapNumber::kSignMask);
           __ Branch(result_type_ <= BinaryOpIC::INT32 ? &transition
                     : &return_heap_number,
                     ne,
                     scratch2,
                     Operand(zero_reg));
           __ bind(&not_zero);
 
           // Tag the result and return.
-          __ SmiTag(v0, scratch1);
-          __ Ret();
+          __ Ret(USE_DELAY_SLOT);
+          __ SmiTag(v0, scratch1);  // SmiTag emits one instruction.
         } else {
           // DIV just falls through to allocating a heap number.
         }
 
         __ bind(&return_heap_number);
         // Return a heap number, or fall through to type transition or runtime
         // call if we can't.
         // We are using FPU registers so s0 is available.
         heap_number_result = s0;
         BinaryOpStub_GenerateHeapResultAllocation(masm,
                                                   heap_number_result,
                                                   heap_number_map,
                                                   scratch1,
                                                   scratch2,
                                                   &call_runtime,
                                                   mode_);
+        __ sdc1(f10,
+                FieldMemOperand(heap_number_result, HeapNumber::kValueOffset));
+        __ Ret(USE_DELAY_SLOT);
         __ mov(v0, heap_number_result);
-        __ sdc1(f10, FieldMemOperand(v0, HeapNumber::kValueOffset));
-        __ Ret();
 
         // A DIV operation expecting an integer result falls through
         // to type transition.
 
       } else {
         if (has_fixed_right_arg_) {
           __ Move(f16, fixed_right_arg_value());
           __ BranchF(&transition, NULL, ne, f14, f16);
         }
 
@@ skipping 99 matching lines @@
           break;
         default:
           UNREACHABLE();
       }
 
       // Check if the result fits in a smi.
       __ Addu(scratch1, a2, Operand(0x40000000));
       // If not try to return a heap number. (We know the result is an int32.)
       __ Branch(&return_heap_number, lt, scratch1, Operand(zero_reg));
       // Tag the result and return.
+      __ Ret(USE_DELAY_SLOT);  // SmiTag emits one instruction in delay slot.
       __ SmiTag(v0, a2);
-      __ Ret();
 
       __ bind(&return_heap_number);
       heap_number_result = t1;
       BinaryOpStub_GenerateHeapResultAllocation(masm,
                                                 heap_number_result,
                                                 heap_number_map,
                                                 scratch1,
                                                 scratch2,
                                                 &call_runtime,
                                                 mode_);
 
       if (op_ != Token::SHR) {
         // Convert the result to a floating point value.
         __ mtc1(a2, double_scratch);
         __ cvt_d_w(double_scratch, double_scratch);
       } else {
         // The result must be interpreted as an unsigned 32-bit integer.
         __ mtc1(a2, double_scratch);
         __ Cvt_d_uw(double_scratch, double_scratch, single_scratch);
       }
 
       // Store the result.
+      __ sdc1(double_scratch,
+              FieldMemOperand(heap_number_result, HeapNumber::kValueOffset));
+      __ Ret(USE_DELAY_SLOT);
       __ mov(v0, heap_number_result);
-      __ sdc1(double_scratch, FieldMemOperand(v0, HeapNumber::kValueOffset));
-      __ Ret();
 
       break;
     }
 
     default:
       UNREACHABLE();
   }
 
   // We never expect DIV to yield an integer result, so we always generate
   // type transition code for DIV operations expecting an integer result: the
@@ skipping 1417 matching lines @@
 
   // Check index (a1) against formal parameters count limit passed in
   // through register a0. Use unsigned comparison to get negative
   // check for free.
   __ Branch(&slow, hs, a1, Operand(a0));
 
   // Read the argument from the stack and return it.
   __ subu(a3, a0, a1);
   __ sll(t3, a3, kPointerSizeLog2 - kSmiTagSize);
   __ Addu(a3, fp, Operand(t3));
+  __ Ret(USE_DELAY_SLOT);
   __ lw(v0, MemOperand(a3, kDisplacement));
-  __ Ret();
 
   // Arguments adaptor case: Check index (a1) against actual arguments
   // limit found in the arguments adaptor frame. Use unsigned
   // comparison to get negative check for free.
   __ bind(&adaptor);
   __ lw(a0, MemOperand(a2, ArgumentsAdaptorFrameConstants::kLengthOffset));
   __ Branch(&slow, Ugreater_equal, a1, Operand(a0));
 
   // Read the argument from the adaptor frame and return it.
   __ subu(a3, a0, a1);
   __ sll(t3, a3, kPointerSizeLog2 - kSmiTagSize);
   __ Addu(a3, a2, Operand(t3));
+  __ Ret(USE_DELAY_SLOT);
   __ lw(v0, MemOperand(a3, kDisplacement));
-  __ Ret();
 
   // Slow-case: Handle non-smi or out-of-bounds access to arguments
   // by calling the runtime system.
   __ bind(&slow);
   __ push(a1);
   __ TailCallRuntime(Runtime::kGetArgumentsProperty, 1, 1);
 }
 
 
 void ArgumentsAccessStub::GenerateNewNonStrictSlow(MacroAssembler* masm) {
@@ skipping 1842 matching lines @@
                                                       Register scratch2,
                                                       Register scratch3) {
   Register length = scratch1;
 
   // Compare lengths.
   Label strings_not_equal, check_zero_length;
   __ lw(length, FieldMemOperand(left, String::kLengthOffset));
   __ lw(scratch2, FieldMemOperand(right, String::kLengthOffset));
   __ Branch(&check_zero_length, eq, length, Operand(scratch2));
   __ bind(&strings_not_equal);
+  ASSERT(is_int16(NOT_EQUAL));
+  __ Ret(USE_DELAY_SLOT);
   __ li(v0, Operand(Smi::FromInt(NOT_EQUAL)));
-  __ Ret();
 
   // Check if the length is zero.
   Label compare_chars;
   __ bind(&check_zero_length);
   STATIC_ASSERT(kSmiTag == 0);
   __ Branch(&compare_chars, ne, length, Operand(zero_reg));
+  ASSERT(is_int16(EQUAL));
+  __ Ret(USE_DELAY_SLOT);
   __ li(v0, Operand(Smi::FromInt(EQUAL)));
-  __ Ret();
 
   // Compare characters.
   __ bind(&compare_chars);
 
   GenerateAsciiCharsCompareLoop(masm,
                                 left, right, length, scratch2, scratch3, v0,
                                 &strings_not_equal);
 
   // Characters are equal.
+  __ Ret(USE_DELAY_SLOT);
   __ li(v0, Operand(Smi::FromInt(EQUAL)));
-  __ Ret();
 }
 
 
 void StringCompareStub::GenerateCompareFlatAsciiStrings(MacroAssembler* masm,
                                                         Register left,
                                                         Register right,
                                                         Register scratch1,
                                                         Register scratch2,
                                                         Register scratch3,
                                                         Register scratch4) {
@@ skipping 497 matching lines @@
 
 
 void ICCompareStub::GenerateSmis(MacroAssembler* masm) {
   ASSERT(state_ == CompareIC::SMI);
   Label miss;
   __ Or(a2, a1, a0);
   __ JumpIfNotSmi(a2, &miss);
 
   if (GetCondition() == eq) {
     // For equality we do not care about the sign of the result.
+    __ Ret(USE_DELAY_SLOT);
     __ Subu(v0, a0, a1);
   } else {
     // Untag before subtracting to avoid handling overflow.
     __ SmiUntag(a1);
     __ SmiUntag(a0);
+    __ Ret(USE_DELAY_SLOT);
     __ Subu(v0, a1, a0);
   }
-  __ Ret();
 
   __ bind(&miss);
   GenerateMiss(masm);
 }
 
 
 void ICCompareStub::GenerateNumbers(MacroAssembler* masm) {
   ASSERT(state_ == CompareIC::NUMBER);
 
   Label generic_stub;
@@ skipping 40 matching lines @@
 
   // Return a result of -1, 0, or 1, or use CompareStub for NaNs.
   Label fpu_eq, fpu_lt;
   // Test if equal, and also handle the unordered/NaN case.
   __ BranchF(&fpu_eq, &unordered, eq, f0, f2);
 
   // Test if less (unordered case is already handled).
   __ BranchF(&fpu_lt, NULL, lt, f0, f2);
 
   // Otherwise it's greater, so just fall thru, and return.
+  ASSERT(is_int16(GREATER) && is_int16(EQUAL) && is_int16(LESS));
+  __ Ret(USE_DELAY_SLOT);
   __ li(v0, Operand(GREATER));
-  __ Ret();
 
   __ bind(&fpu_eq);
+  __ Ret(USE_DELAY_SLOT);
   __ li(v0, Operand(EQUAL));
-  __ Ret();
 
   __ bind(&fpu_lt);
+  __ Ret(USE_DELAY_SLOT);
   __ li(v0, Operand(LESS));
-  __ Ret();
 
   __ bind(&unordered);
   __ bind(&generic_stub);
   ICCompareStub stub(op_, CompareIC::GENERIC, CompareIC::GENERIC,
                      CompareIC::GENERIC);
   __ Jump(stub.GetCode(masm->isolate()), RelocInfo::CODE_TARGET);
 
   __ bind(&maybe_undefined1);
   if (Token::IsOrderedRelationalCompareOp(op_)) {
     __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
@@ skipping 38 matching lines @@
   __ And(tmp1, tmp1, kIsInternalizedMask);
   __ Branch(&miss, eq, tmp1, Operand(zero_reg));
   // Make sure a0 is non-zero. At this point input operands are
   // guaranteed to be non-zero.
   ASSERT(right.is(a0));
   STATIC_ASSERT(EQUAL == 0);
   STATIC_ASSERT(kSmiTag == 0);
   __ mov(v0, right);
   // Internalized strings are compared by identity.
   __ Ret(ne, left, Operand(right));
+  ASSERT(is_int16(EQUAL));
+  __ Ret(USE_DELAY_SLOT);
   __ li(v0, Operand(Smi::FromInt(EQUAL)));
-  __ Ret();
 
   __ bind(&miss);
   GenerateMiss(masm);
 }
 
 
 void ICCompareStub::GenerateUniqueNames(MacroAssembler* masm) {
   ASSERT(state_ == CompareIC::UNIQUE_NAME);
   ASSERT(GetCondition() == eq);
   Label miss;
@@ skipping 863 matching lines @@
   CEntryStub ces(1, fp_registers_ ? kSaveFPRegs : kDontSaveFPRegs);
   __ Call(ces.GetCode(masm->isolate()), RelocInfo::CODE_TARGET);
   int parameter_count_offset =
       StubFailureTrampolineFrame::kCallerStackParameterCountFrameOffset;
   __ lw(a1, MemOperand(fp, parameter_count_offset));
   if (function_mode_ == JS_FUNCTION_STUB_MODE) {
     __ Addu(a1, a1, Operand(1));
   }
   masm->LeaveFrame(StackFrame::STUB_FAILURE_TRAMPOLINE);
   __ sll(a1, a1, kPointerSizeLog2);
+  __ Ret(USE_DELAY_SLOT);
   __ Addu(sp, sp, a1);
-  __ Ret();
 }
 
 
 void ProfileEntryHookStub::MaybeCallEntryHook(MacroAssembler* masm) {
   if (entry_hook_ != NULL) {
     ProfileEntryHookStub stub;
     __ push(ra);
     __ CallStub(&stub);
     __ pop(ra);
   }
@@ skipping 341 matching lines @@
     __ Jump(generic_construct_stub, RelocInfo::CODE_TARGET);
   }
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_MIPS