MIPS: Refine '[builtins] Make Math.max and Math.min fast by default.'

src/mips64/builtins-mips64.cc

Index: src/mips64/builtins-mips64.cc
diff --git a/src/mips64/builtins-mips64.cc b/src/mips64/builtins-mips64.cc
index f377f755b519265760fc3b1cbb0d6d5d11e52494..507fefd1975947a19877a394768f9f04e3e307d8 100644
--- a/src/mips64/builtins-mips64.cc
+++ b/src/mips64/builtins-mips64.cc
@@ -165,11 +165,10 @@ void Builtins::Generate_MathMaxMin(MacroAssembler* masm, MathMaxMinKind kind) {
   {
     // Check if all parameters done.
     __ Dsubu(a0, a0, Operand(1));
-    __ Branch(USE_DELAY_SLOT, &done_loop, lt, a0, Operand(zero_reg));
+    __ Branch(&done_loop, lt, a0, Operand(zero_reg));
 
     // Load the next parameter tagged value into a2.
-    __ dsll(at, a0, kPointerSizeLog2);  // In delay slot
-    __ Daddu(at, at, sp);
+    __ Dlsa(at, sp, a0, kPointerSizeLog2);
     __ ld(a2, MemOperand(at));
 
     // Load the double value of the parameter into f2, maybe converting the
@@ -177,8 +176,8 @@ void Builtins::Generate_MathMaxMin(MacroAssembler* masm, MathMaxMinKind kind) {
     Label convert, convert_smi, convert_number, done_convert;
     __ bind(&convert);
     __ JumpIfSmi(a2, &convert_smi);
-    __ ld(t0, FieldMemOperand(a2, HeapObject::kMapOffset));
-    __ JumpIfRoot(t0, Heap::kHeapNumberMapRootIndex, &convert_number);
+    __ ld(a4, FieldMemOperand(a2, HeapObject::kMapOffset));
+    __ JumpIfRoot(a4, Heap::kHeapNumberMapRootIndex, &convert_number);
     {
       // Parameter is not a Number, use the ToNumberStub to convert it.
       FrameScope scope(masm, StackFrame::INTERNAL);
@@ -197,7 +196,7 @@ void Builtins::Generate_MathMaxMin(MacroAssembler* masm, MathMaxMinKind kind) {
         __ ldc1(f0, FieldMemOperand(a1, HeapNumber::kValueOffset));
         __ jmp(&done_restore);
         __ bind(&restore_smi);
-        __ SmiToDoubleFPURegister(a1, f0, t0);
+        __ SmiToDoubleFPURegister(a1, f0, a4);
         __ bind(&done_restore);
       }
       __ SmiUntag(a3);
@@ -208,7 +207,7 @@ void Builtins::Generate_MathMaxMin(MacroAssembler* masm, MathMaxMinKind kind) {
     __ ldc1(f2, FieldMemOperand(a2, HeapNumber::kValueOffset));
     __ jmp(&done_convert);
     __ bind(&convert_smi);
-    __ SmiToDoubleFPURegister(a2, f2, t0);
+    __ SmiToDoubleFPURegister(a2, f2, a4);
     __ bind(&done_convert);
 
     // Perform the actual comparison with the accumulator value on the left hand
@@ -220,8 +219,10 @@ void Builtins::Generate_MathMaxMin(MacroAssembler* masm, MathMaxMinKind kind) {
 
     // Left and right hand side are equal, check for -0 vs. +0.
     __ bind(&compare_equal);
-    __ FmoveHigh(t0, reg);
-    __ Branch(&loop, ne, t0, Operand(0x80000000));
+    __ FmoveHigh(a4, reg);

[Benedikt Meurer, 2016/01/29 05:14:22]

In this case it is sufficient to know that the value of reg interpreted as int64
is negative. So you could also load the full value into a4 and then check
whether a4 is negative I guess?

[balazs.kilvady, 2016/01/29 11:09:21]

I have tryed that solution and that was fine for min-max tests but other test
failed, for example:
=== mjsunit/constant-folding-2 ===                              
/home/balazs_kilvady/Work/v8/test/mjsunit/mjsunit.js:210: Failure: expected
<"-Infinity"> found <"Infinity">

+    // Make a4 unsigned.
+    __ dsll32(a4, a4, 0);
+    __ Branch(&loop, ne, a4, Operand(0x8000000000000000));
 
     // Result is on the right hand side.
     __ bind(&compare_swap);
@@ -237,8 +238,7 @@ void Builtins::Generate_MathMaxMin(MacroAssembler* masm, MathMaxMinKind kind) {
   }
 
   __ bind(&done_loop);
-  __ dsll(a3, a3, kPointerSizeLog2);
-  __ Daddu(sp, sp, a3);
+  __ Dlsa(sp, sp, a3, kPointerSizeLog2);
   __ mov(v0, a1);
   __ DropAndRet(1);
 }