MIPS: Fix 'MIPS: [es6] implement Reflect.apply() & Reflect.construct()'

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.
 
 
 
 #include "src/v8.h"
 
 #if V8_TARGET_ARCH_MIPS64
 
@@ skipping 1422 matching lines @@
     __ ld(a0, MemOperand(fp, kArgumentsOffset));  // Get the args array.
     __ push(a0);
 
     // Returns (in v0) number of arguments to copy to stack as Smi.
     if (targetIsArgument) {
       __ InvokeBuiltin(Builtins::REFLECT_APPLY_PREPARE, CALL_FUNCTION);
     } else {
       __ InvokeBuiltin(Builtins::APPLY_PREPARE, CALL_FUNCTION);
     }
 
+    // Returns the result in v0.
     Generate_CheckStackOverflow(masm, kFunctionOffset);
 
     // Push current limit and index.
     const int kIndexOffset =
         StandardFrameConstants::kExpressionsOffset - (2 * kPointerSize);
     const int kLimitOffset =
         StandardFrameConstants::kExpressionsOffset - (1 * kPointerSize);
     __ mov(a1, zero_reg);
     __ Push(v0, a1);  // Limit and initial index.
 
@@ skipping 84 matching lines @@
   __ Ret(USE_DELAY_SLOT);
   __ Daddu(sp, sp, Operand(kStackSize * kPointerSize));  // In delay slot.
 }
 
 
 static void Generate_ConstructHelper(MacroAssembler* masm) {
   const int kFormalParameters = 3;
   const int kStackSize = kFormalParameters + 1;
 
   {
-    FrameAndConstantPoolScope frame_scope(masm, StackFrame::INTERNAL);
+    FrameScope frame_scope(masm, StackFrame::INTERNAL);
     const int kNewTargetOffset = kFPOnStackSize + kPCOnStackSize;
     const int kArgumentsOffset = kNewTargetOffset + kPointerSize;
     const int kFunctionOffset = kArgumentsOffset + kPointerSize;
 
     // If newTarget is not supplied, set it to constructor
     Label validate_arguments;
     __ ld(a0, MemOperand(fp, kNewTargetOffset));
     __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
     __ Branch(&validate_arguments, ne, a0, Operand(at));
     __ ld(a0, MemOperand(fp, kFunctionOffset));
     __ sd(a0, MemOperand(fp, kNewTargetOffset));
 
     // Validate arguments
     __ bind(&validate_arguments);
     __ ld(a0, MemOperand(fp, kFunctionOffset));  // get the function
     __ push(a0);
     __ ld(a0, MemOperand(fp, kArgumentsOffset));  // get the args array
     __ push(a0);
     __ ld(a0, MemOperand(fp, kNewTargetOffset));  // get the new.target
     __ push(a0);
+    // Returns argument count in v0.
     __ InvokeBuiltin(Builtins::REFLECT_CONSTRUCT_PREPARE, CALL_FUNCTION);
 
+    // Returns result in v0.
     Generate_CheckStackOverflow(masm, kFunctionOffset);
 
     // Push current limit and index.
     const int kIndexOffset =
         StandardFrameConstants::kExpressionsOffset - (2 * kPointerSize);
     const int kLimitOffset =
         StandardFrameConstants::kExpressionsOffset - (1 * kPointerSize);
     __ push(v0);  // limit
     __ mov(a1, zero_reg);  // initial index
     __ push(a1);
@@ skipping 12 matching lines @@
     __ ld(a1, MemOperand(fp, kFunctionOffset));
 
     // Call the function.
     CallConstructStub stub(masm->isolate(), SUPER_CONSTRUCTOR_CALL);
     __ Call(stub.GetCode(), RelocInfo::CONSTRUCT_CALL);
 
     __ Drop(1);
 
     // Leave internal frame.
   }
-  __ Daddu(sp, sp, Operand(kStackSize * kPointerSize));
-  __ Jump(ra);
+  __ jr(ra);
+  __ Daddu(sp, sp, Operand(kStackSize * kPointerSize));  // In delay slot.
 }
 
 
 void Builtins::Generate_FunctionApply(MacroAssembler* masm) {
   Generate_ApplyHelper(masm, false);
 }
 
 
 void Builtins::Generate_ReflectApply(MacroAssembler* masm) {
   Generate_ApplyHelper(masm, true);
@@ skipping 180 matching lines @@
     __ break_(0xCC);
   }
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_MIPS64