MIPS: [builtins] Fix MathMaxMin.

src/mips/builtins-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
 
 #include "src/codegen.h"
 #include "src/debug/debug.h"
 #include "src/deoptimizer.h"
 #include "src/full-codegen/full-codegen.h"
@@ skipping 110 matching lines @@
   __ mov(a3, a1);
   __ LoadRoot(a2, Heap::kUndefinedValueRootIndex);
   ArrayConstructorStub stub(masm->isolate());
   __ TailCallStub(&stub);
 }
 
 
 // static
 void Builtins::Generate_MathMaxMin(MacroAssembler* masm, MathMaxMinKind kind) {
   // ----------- S t a t e -------------
-  //  -- a0                 : number of arguments
-  //  -- a1                 : function
-  //  -- cp                 : context
-  //  -- ra                 : return address
-  //  -- sp[(argc - n) * 8] : arg[n] (zero-based)
-  //  -- sp[(argc + 1) * 8] : receiver
+  //  -- a0                     : number of arguments
+  //  -- a1                     : function
+  //  -- cp                     : context
+  //  -- ra                     : return address
+  //  -- sp[(argc - n - 1) * 4] : arg[n] (zero-based)
+  //  -- sp[argc * 4]           : receiver
   // -----------------------------------
   Heap::RootListIndex const root_index =
       (kind == MathMaxMinKind::kMin) ? Heap::kInfinityValueRootIndex
                                      : Heap::kMinusInfinityValueRootIndex;
 
   // Load the accumulator with the default return value (either -Infinity or
   // +Infinity), with the tagged value in t2 and the double value in f0.
   __ LoadRoot(t2, root_index);
   __ ldc1(f0, FieldMemOperand(t2, HeapNumber::kValueOffset));
-  __ Addu(a3, a0, Operand(1));
 
   Label done_loop, loop;
+  __ mov(a3, a0);
   __ bind(&loop);
   {
     // Check if all parameters done.
-    __ Subu(a0, a0, Operand(1));
-    __ Branch(&done_loop, lt, a0, Operand(zero_reg));
+    __ Subu(a3, a3, Operand(1));
+    __ Branch(&done_loop, lt, a3, Operand(zero_reg));

[ivica.bogosavljevic, 2016/07/01 12:40:50]

You could fill delay slot here, the next instruction writes to at, so if jump is
taken, it doesn't matter, otherwise you save one nop :)

[balazs.kilvady, 2016/07/01 13:17:25]

Since we support r6 I try to avoid delay slot usage in conditional branches as
with them we lose the chance for an r6 compact branch optimization. Especially
when the result of the previous op is the input of the branch condition.

 
     // Load the next parameter tagged value into a2.
-    __ Lsa(at, sp, a0, kPointerSizeLog2);
+    __ Lsa(at, sp, a3, kPointerSizeLog2);
     __ lw(a2, MemOperand(at));
 
     // Load the double value of the parameter into f2, maybe converting the
     // parameter to a number first using the ToNumber builtin if necessary.
     Label convert, convert_smi, convert_number, done_convert;
     __ bind(&convert);
     __ JumpIfSmi(a2, &convert_smi);
     __ lw(t0, FieldMemOperand(a2, HeapObject::kMapOffset));
     __ JumpIfRoot(t0, Heap::kHeapNumberMapRootIndex, &convert_number);
     {
@@ skipping 54 matching lines @@
     __ jmp(&loop);
 
     // At least one side is NaN, which means that the result will be NaN too.
     __ bind(&compare_nan);
     __ LoadRoot(t2, Heap::kNanValueRootIndex);
     __ ldc1(f0, FieldMemOperand(t2, HeapNumber::kValueOffset));
     __ jmp(&loop);
   }
 
   __ bind(&done_loop);
-  __ Lsa(sp, sp, a3, kPointerSizeLog2);
+  // Drop all slots, including the receiver.
+  __ Addu(a0, a0, Operand(1));
+  __ Lsa(sp, sp, a0, kPointerSizeLog2);
   __ Ret(USE_DELAY_SLOT);
   __ mov(v0, t2);  // In delay slot.
 }
 
 // static
 void Builtins::Generate_NumberConstructor(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- a0                     : number of arguments
   //  -- a1                     : constructor function
   //  -- ra                     : return address
@@ skipping 2766 matching lines @@
   }
 }
 
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_MIPS