MIPS: Refactoring after 'MIPS: split api call stubs into accessor and function call stubs'.

src/mips64/code-stubs-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
 
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
@@ skipping 4869 matching lines @@
   int64_t offset = (ref0.address() - ref1.address());
   DCHECK(static_cast<int>(offset) == offset);
   return static_cast<int>(offset);
 }
 
 
 // Calls an API function.  Allocates HandleScope, extracts returned value
 // from handle and propagates exceptions.  Restores context.  stack_space
 // - space to be unwound on exit (includes the call JS arguments space and
 // the additional space allocated for the fast call).
-static void CallApiFunctionAndReturn(MacroAssembler* masm,
-                                     Register function_address,
-                                     ExternalReference thunk_ref,
-                                     int stack_space,
-                                     MemOperand* stack_space_operand,
-                                     MemOperand return_value_operand,
-                                     MemOperand* context_restore_operand) {
+static void CallApiFunctionAndReturn(
+    MacroAssembler* masm, Register function_address,
+    ExternalReference thunk_ref, int stack_space, int32_t stack_space_offset,
+    MemOperand return_value_operand, MemOperand* context_restore_operand) {
   Isolate* isolate = masm->isolate();
   ExternalReference next_address =
       ExternalReference::handle_scope_next_address(isolate);
   const int kNextOffset = 0;
   const int kLimitOffset = AddressOffset(
       ExternalReference::handle_scope_limit_address(isolate), next_address);
   const int kLevelOffset = AddressOffset(
       ExternalReference::handle_scope_level_address(isolate), next_address);
 
   DCHECK(function_address.is(a1) || function_address.is(a2));
@@ skipping 73 matching lines @@
   __ LoadRoot(a4, Heap::kTheHoleValueRootIndex);
   __ li(at, Operand(ExternalReference::scheduled_exception_address(isolate)));
   __ ld(a5, MemOperand(at));
   __ Branch(&promote_scheduled_exception, ne, a4, Operand(a5));
   __ bind(&exception_handled);
 
   bool restore_context = context_restore_operand != NULL;
   if (restore_context) {
     __ ld(cp, *context_restore_operand);
   }
-  if (stack_space_operand != NULL) {
-    __ lw(s0, *stack_space_operand);
+  if (stack_space_offset != kInvalidStackOffset) {
+    DCHECK(kCArgsSlotsSize == 0);
+    __ ld(s0, MemOperand(sp, stack_space_offset));
   } else {
     __ li(s0, Operand(stack_space));
   }
   __ LeaveExitFrame(false, s0, !restore_context, EMIT_RETURN,
-                    stack_space_operand != NULL);
+                    stack_space_offset != kInvalidStackOffset);
   __ bind(&promote_scheduled_exception);
   {
     FrameScope frame(masm, StackFrame::INTERNAL);
     __ CallExternalReference(
         ExternalReference(Runtime::kPromoteScheduledException, isolate), 0);
   }
   __ jmp(&exception_handled);
 
   // HandleScope limit has changed. Delete allocated extensions.
   __ bind(&delete_allocated_handles);
@@ skipping 109 matching lines @@
       fp, (2 + FCA::kContextSaveIndex) * kPointerSize);
   // Stores return the first js argument.
   int return_value_offset = 0;
   if (return_first_arg) {
     return_value_offset = 2 + FCA::kArgsLength;
   } else {
     return_value_offset = 2 + FCA::kReturnValueOffset;
   }
   MemOperand return_value_operand(fp, return_value_offset * kPointerSize);
   int stack_space = 0;
-  MemOperand is_construct_call_operand = MemOperand(sp, 4 * kPointerSize);
-  MemOperand* stack_space_operand = &is_construct_call_operand;
+  int32_t stack_space_offset = 4 * kPointerSize;
   if (argc.is_immediate()) {
     stack_space = argc.immediate() + FCA::kArgsLength + 1;
-    stack_space_operand = NULL;
+    stack_space_offset = kInvalidStackOffset;
   }
   CallApiFunctionAndReturn(masm, api_function_address, thunk_ref, stack_space,
-                           stack_space_operand, return_value_operand,
+                           stack_space_offset, return_value_operand,
                            &context_restore_operand);
 }
 
 
 void CallApiFunctionStub::Generate(MacroAssembler* masm) {
   bool call_data_undefined = this->call_data_undefined();
   CallApiFunctionStubHelper(masm, ParameterCount(a3), false,
                             call_data_undefined);
 }
 
@@ skipping 28 matching lines @@
   // Create PropertyAccessorInfo instance on the stack above the exit frame with
   // a1 (internal::Object** args_) as the data.
   __ sd(a1, MemOperand(sp, 1 * kPointerSize));
   __ Daddu(a1, sp, Operand(1 * kPointerSize));  // a1 = AccessorInfo&
 
   const int kStackUnwindSpace = PropertyCallbackArguments::kArgsLength + 1;
 
   ExternalReference thunk_ref =
       ExternalReference::invoke_accessor_getter_callback(isolate());
   CallApiFunctionAndReturn(masm, api_function_address, thunk_ref,
-                           kStackUnwindSpace, NULL,
+                           kStackUnwindSpace, kInvalidStackOffset,
                            MemOperand(fp, 6 * kPointerSize), NULL);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_MIPS64