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

src/mips64/builtins-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.
 
 #if V8_TARGET_ARCH_MIPS64
 
 #include "src/codegen.h"
 #include "src/debug/debug.h"
 #include "src/deoptimizer.h"
 #include "src/full-codegen/full-codegen.h"
@@ skipping 147 matching lines @@
   // +Infinity), with the tagged value in a1 and the double value in f0.
   __ LoadRoot(a1, root_index);
   __ ldc1(f0, FieldMemOperand(a1, HeapNumber::kValueOffset));
   __ mov(a3, a0);
 
   Label done_loop, loop;
   __ bind(&loop);
   {
     // 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
     // parameter to a number first using the ToNumberStub if necessary.
     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);
       __ SmiTag(a0);
       __ SmiTag(a3);
       __ Push(a0, a1, a3);
       __ mov(a0, a2);
       ToNumberStub stub(masm->isolate());
       __ CallStub(&stub);
       __ mov(a2, v0);
       __ Pop(a0, a1, a3);
       {
         // Restore the double accumulator value (f0).
         Label restore_smi, done_restore;
         __ JumpIfSmi(a1, &restore_smi);
         __ 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);
       __ SmiUntag(a0);
     }
     __ jmp(&convert);
     __ bind(&convert_number);
     __ 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
     // side (d1) and the next parameter value on the right hand side (d2).
     Label compare_equal, compare_nan, compare_swap;
     __ BranchF(&compare_equal, &compare_nan, eq, f0, f2);
     __ BranchF(&compare_swap, nullptr, cc, f0, f2);
     __ Branch(&loop);
 
     // 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);
     __ mov_d(f0, f2);
     __ mov(a1, a2);
     __ jmp(&loop);
 
     // At least one side is NaN, which means that the result will be NaN too.
     __ bind(&compare_nan);
     __ LoadRoot(a1, Heap::kNanValueRootIndex);
     __ ldc1(f0, FieldMemOperand(a1, HeapNumber::kValueOffset));
     __ jmp(&loop);
   }
 
   __ bind(&done_loop);
-  __ dsll(a3, a3, kPointerSizeLog2);
-  __ Daddu(sp, sp, a3);
+  __ Dlsa(sp, sp, a3, kPointerSizeLog2);
   __ mov(v0, a1);
   __ DropAndRet(1);
 }
 
 // static
 void Builtins::Generate_NumberConstructor(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- a0                     : number of arguments
   //  -- a1                     : constructor function
   //  -- ra                     : return address
@@ skipping 2518 matching lines @@
   }
 }
 
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_MIPS64