[v8-dev] [v8] r15011 committed - MIPS: Fill more branch delay slots....

codesite-noreply Fri, 07 Jun 2013 09:02:00 -0700

Revision: 15011
Author:   [email protected]
Date:     Fri Jun  7 09:00:19 2013
Log:      MIPS: Fill more branch delay slots.


TEST=
BUG=
[email protected]

Review URL: https://codereview.chromium.org/15967006

Patch from Dusan Milosavljevic <[email protected]>.
http://code.google.com/p/v8/source/detail?r=15011

Modified:
 /branches/bleeding_edge/src/mips/builtins-mips.cc
 /branches/bleeding_edge/src/mips/code-stubs-mips.cc
 /branches/bleeding_edge/src/mips/stub-cache-mips.cc

=======================================

--- /branches/bleeding_edge/src/mips/builtins-mips.cc Wed Jun 5 09:06:382013+++ /branches/bleeding_edge/src/mips/builtins-mips.cc Fri Jun 7 09:00:192013

@@ -335,9 +335,9 @@
                        call_generic_code);
   __ IncrementCounter(counters->array_function_native(), 1, a3, t0);
   // Set up return value, remove receiver from stack and return.
+  __ Addu(sp, sp, Operand(kPointerSize));
+  __ Ret(USE_DELAY_SLOT);
   __ mov(v0, a2);
-  __ Addu(sp, sp, Operand(kPointerSize));
-  __ Ret();

   // Check for one argument. Bail out if argument is not smi or if it is
   // negative.
@@ -378,9 +378,9 @@
   __ IncrementCounter(counters->array_function_native(), 1, a2, t0);

// Set up return value, remove receiver and argument from stack andreturn.

+  __ Addu(sp, sp, Operand(2 * kPointerSize));
+  __ Ret(USE_DELAY_SLOT);
   __ mov(v0, a3);
-  __ Addu(sp, sp, Operand(2 * kPointerSize));
-  __ Ret();

   // Handle construction of an array from a list of arguments.
   __ bind(&argc_two_or_more);
@@ -434,8 +434,8 @@
   // a3: JSArray
   // sp[0]: receiver
   __ Addu(sp, sp, Operand(kPointerSize));
+  __ Ret(USE_DELAY_SLOT);
   __ mov(v0, a3);
-  __ Ret();

   __ bind(&has_non_smi_element);
   // Double values are handled by the runtime.
@@ -1372,15 +1372,17 @@
   Label with_tos_register, unknown_state;
   __ Branch(&with_tos_register,
             ne, t2, Operand(FullCodeGenerator::NO_REGISTERS));
+  __ Ret(USE_DELAY_SLOT);
+  // Safe to fill delay slot Addu will emit one instruction.
   __ Addu(sp, sp, Operand(1 * kPointerSize));  // Remove state.
-  __ Ret();

   __ bind(&with_tos_register);
   __ lw(v0, MemOperand(sp, 1 * kPointerSize));
   __ Branch(&unknown_state, ne, t2, Operand(FullCodeGenerator::TOS_REG));

+  __ Ret(USE_DELAY_SLOT);
+  // Safe to fill delay slot Addu will emit one instruction.
   __ Addu(sp, sp, Operand(2 * kPointerSize));  // Remove state.
-  __ Ret();

   __ bind(&unknown_state);
   __ stop("no cases left");
=======================================

--- /branches/bleeding_edge/src/mips/code-stubs-mips.cc Thu Jun 6 06:22:422013+++ /branches/bleeding_edge/src/mips/code-stubs-mips.cc Fri Jun 7 09:00:192013

@@ -348,8 +348,8 @@
   __ 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);

@@ -969,9 +969,9 @@
   __ 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 mantissaof

@@ -983,9 +983,9 @@
   __ 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();
 }


@@ -1023,6 +1023,8 @@
         __ 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));
@@ -1030,13 +1032,13 @@
           // 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) {
@@ -1044,7 +1046,6 @@
   } else {
     __ mov(v0, zero_reg);         // Things are <=, >=, ==, === themselves.
   }
-  __ Ret();

// For less and greater we don't have to check for NaN since the resultof

   // x < x is false regardless.  For the others here is some code to check
@@ -1075,13 +1076,14 @@
     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.

@@ -1456,12 +1458,14 @@
   __ 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,
@@ -1725,6 +1729,7 @@
   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;
@@ -1746,9 +1751,9 @@
     __ 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();
 }


@@ -1768,8 +1773,8 @@
   __ 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);
@@ -1968,8 +1973,8 @@
       // Check that the signed result fits in a Smi.
       __ Addu(scratch2, scratch1, Operand(0x40000000));
       __ Branch(&not_smi_result, lt, scratch2, Operand(zero_reg));