// 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/api-arguments.h"
|
#include "src/bootstrapper.h"
|
#include "src/code-stubs.h"
|
#include "src/frame-constants.h"
|
#include "src/frames.h"
|
#include "src/heap/heap-inl.h"
|
#include "src/ic/ic.h"
|
#include "src/ic/stub-cache.h"
|
#include "src/isolate.h"
|
#include "src/objects/api-callbacks.h"
|
#include "src/regexp/jsregexp.h"
|
#include "src/regexp/regexp-macro-assembler.h"
|
#include "src/runtime/runtime.h"
|
|
#include "src/mips64/code-stubs-mips64.h" // Cannot be the first include.
|
|
namespace v8 {
|
namespace internal {
|
|
#define __ ACCESS_MASM(masm)
|
|
void JSEntryStub::Generate(MacroAssembler* masm) {
|
Label invoke, handler_entry, exit;
|
Isolate* isolate = masm->isolate();
|
|
{
|
NoRootArrayScope no_root_array(masm);
|
|
// TODO(plind): unify the ABI description here.
|
// Registers:
|
// a0: entry address
|
// a1: function
|
// a2: receiver
|
// a3: argc
|
// a4 (a4): on mips64
|
|
// Stack:
|
// 0 arg slots on mips64 (4 args slots on mips)
|
// args -- in a4/a4 on mips64, on stack on mips
|
|
ProfileEntryHookStub::MaybeCallEntryHook(masm);
|
|
// Save callee saved registers on the stack.
|
__ MultiPush(kCalleeSaved | ra.bit());
|
|
// Save callee-saved FPU registers.
|
__ MultiPushFPU(kCalleeSavedFPU);
|
// Set up the reserved register for 0.0.
|
__ Move(kDoubleRegZero, 0.0);
|
|
// Load argv in s0 register.
|
__ mov(s0, a4); // 5th parameter in mips64 a4 (a4) register.
|
|
__ InitializeRootRegister();
|
}
|
|
// We build an EntryFrame.
|
__ li(a7, Operand(-1)); // Push a bad frame pointer to fail if it is used.
|
StackFrame::Type marker = type();
|
__ li(a6, Operand(StackFrame::TypeToMarker(marker)));
|
__ li(a5, Operand(StackFrame::TypeToMarker(marker)));
|
ExternalReference c_entry_fp =
|
ExternalReference::Create(IsolateAddressId::kCEntryFPAddress, isolate);
|
__ li(a4, Operand(c_entry_fp));
|
__ Ld(a4, MemOperand(a4));
|
__ Push(a7, a6, a5, a4);
|
// Set up frame pointer for the frame to be pushed.
|
__ daddiu(fp, sp, -EntryFrameConstants::kCallerFPOffset);
|
|
// Registers:
|
// a0: entry_address
|
// a1: function
|
// a2: receiver_pointer
|
// a3: argc
|
// s0: argv
|
//
|
// Stack:
|
// caller fp |
|
// function slot | entry frame
|
// context slot |
|
// bad fp (0xFF...F) |
|
// callee saved registers + ra
|
// [ O32: 4 args slots]
|
// args
|
|
// If this is the outermost JS call, set js_entry_sp value.
|
Label non_outermost_js;
|
ExternalReference js_entry_sp =
|
ExternalReference::Create(IsolateAddressId::kJSEntrySPAddress, isolate);
|
__ li(a5, js_entry_sp);
|
__ Ld(a6, MemOperand(a5));
|
__ Branch(&non_outermost_js, ne, a6, Operand(zero_reg));
|
__ Sd(fp, MemOperand(a5));
|
__ li(a4, Operand(StackFrame::OUTERMOST_JSENTRY_FRAME));
|
Label cont;
|
__ b(&cont);
|
__ nop(); // Branch delay slot nop.
|
__ bind(&non_outermost_js);
|
__ li(a4, Operand(StackFrame::INNER_JSENTRY_FRAME));
|
__ bind(&cont);
|
__ push(a4);
|
|
// Jump to a faked try block that does the invoke, with a faked catch
|
// block that sets the pending exception.
|
__ jmp(&invoke);
|
__ bind(&handler_entry);
|
handler_offset_ = handler_entry.pos();
|
// Caught exception: Store result (exception) in the pending exception
|
// field in the JSEnv and return a failure sentinel. Coming in here the
|
// fp will be invalid because the PushStackHandler below sets it to 0 to
|
// signal the existence of the JSEntry frame.
|
__ li(a4, ExternalReference::Create(
|
IsolateAddressId::kPendingExceptionAddress, isolate));
|
__ Sd(v0, MemOperand(a4)); // We come back from 'invoke'. result is in v0.
|
__ LoadRoot(v0, Heap::kExceptionRootIndex);
|
__ b(&exit); // b exposes branch delay slot.
|
__ nop(); // Branch delay slot nop.
|
|
// Invoke: Link this frame into the handler chain.
|
__ bind(&invoke);
|
__ PushStackHandler();
|
// If an exception not caught by another handler occurs, this handler
|
// returns control to the code after the bal(&invoke) above, which
|
// restores all kCalleeSaved registers (including cp and fp) to their
|
// saved values before returning a failure to C.
|
|
// Invoke the function by calling through JS entry trampoline builtin.
|
// Notice that we cannot store a reference to the trampoline code directly in
|
// this stub, because runtime stubs are not traversed when doing GC.
|
|
// Registers:
|
// a0: entry_address
|
// a1: function
|
// a2: receiver_pointer
|
// a3: argc
|
// s0: argv
|
//
|
// Stack:
|
// handler frame
|
// entry frame
|
// callee saved registers + ra
|
// [ O32: 4 args slots]
|
// args
|
__ Call(EntryTrampoline(), RelocInfo::CODE_TARGET);
|
|
// Unlink this frame from the handler chain.
|
__ PopStackHandler();
|
|
__ bind(&exit); // v0 holds result
|
// Check if the current stack frame is marked as the outermost JS frame.
|
Label non_outermost_js_2;
|
__ pop(a5);
|
__ Branch(&non_outermost_js_2, ne, a5,
|
Operand(StackFrame::OUTERMOST_JSENTRY_FRAME));
|
__ li(a5, ExternalReference(js_entry_sp));
|
__ Sd(zero_reg, MemOperand(a5));
|
__ bind(&non_outermost_js_2);
|
|
// Restore the top frame descriptors from the stack.
|
__ pop(a5);
|
__ li(a4,
|
ExternalReference::Create(IsolateAddressId::kCEntryFPAddress, isolate));
|
__ Sd(a5, MemOperand(a4));
|
|
// Reset the stack to the callee saved registers.
|
__ daddiu(sp, sp, -EntryFrameConstants::kCallerFPOffset);
|
|
// Restore callee-saved fpu registers.
|
__ MultiPopFPU(kCalleeSavedFPU);
|
|
// Restore callee saved registers from the stack.
|
__ MultiPop(kCalleeSaved | ra.bit());
|
// Return.
|
__ Jump(ra);
|
}
|
|
void DirectCEntryStub::Generate(MacroAssembler* masm) {
|
// Make place for arguments to fit C calling convention. Most of the callers
|
// of DirectCEntryStub::GenerateCall are using EnterExitFrame/LeaveExitFrame
|
// so they handle stack restoring and we don't have to do that here.
|
// Any caller of DirectCEntryStub::GenerateCall must take care of dropping
|
// kCArgsSlotsSize stack space after the call.
|
__ daddiu(sp, sp, -kCArgsSlotsSize);
|
// Place the return address on the stack, making the call
|
// GC safe. The RegExp backend also relies on this.
|
__ Sd(ra, MemOperand(sp, kCArgsSlotsSize));
|
__ Call(t9); // Call the C++ function.
|
__ Ld(t9, MemOperand(sp, kCArgsSlotsSize));
|
|
if (FLAG_debug_code && FLAG_enable_slow_asserts) {
|
// In case of an error the return address may point to a memory area
|
// filled with kZapValue by the GC.
|
// Dereference the address and check for this.
|
__ Uld(a4, MemOperand(t9));
|
__ Assert(ne, AbortReason::kReceivedInvalidReturnAddress, a4,
|
Operand(reinterpret_cast<uint64_t>(kZapValue)));
|
}
|
__ Jump(t9);
|
}
|
|
|
void DirectCEntryStub::GenerateCall(MacroAssembler* masm,
|
Register target) {
|
if (FLAG_embedded_builtins) {
|
if (masm->root_array_available() &&
|
isolate()->ShouldLoadConstantsFromRootList()) {
|
// This is basically an inlined version of Call(Handle<Code>) that loads
|
// the code object into kScratchReg instead of t9.
|
__ Move(t9, target);
|
__ IndirectLoadConstant(kScratchReg, GetCode());
|
__ Daddu(kScratchReg, kScratchReg,
|
Operand(Code::kHeaderSize - kHeapObjectTag));
|
__ Call(kScratchReg);
|
return;
|
}
|
}
|
intptr_t loc =
|
reinterpret_cast<intptr_t>(GetCode().location());
|
__ Move(t9, target);
|
__ li(kScratchReg, Operand(loc, RelocInfo::CODE_TARGET), CONSTANT_SIZE);
|
__ Call(kScratchReg);
|
}
|
|
|
void ProfileEntryHookStub::MaybeCallEntryHookDelayed(TurboAssembler* tasm,
|
Zone* zone) {
|
if (tasm->isolate()->function_entry_hook() != nullptr) {
|
tasm->push(ra);
|
tasm->CallStubDelayed(new (zone) ProfileEntryHookStub(nullptr));
|
tasm->pop(ra);
|
}
|
}
|
|
void ProfileEntryHookStub::MaybeCallEntryHook(MacroAssembler* masm) {
|
if (masm->isolate()->function_entry_hook() != nullptr) {
|
ProfileEntryHookStub stub(masm->isolate());
|
__ push(ra);
|
__ CallStub(&stub);
|
__ pop(ra);
|
}
|
}
|
|
|
void ProfileEntryHookStub::Generate(MacroAssembler* masm) {
|
// The entry hook is a "push ra" instruction, followed by a call.
|
// Note: on MIPS "push" is 2 instruction
|
const int32_t kReturnAddressDistanceFromFunctionStart =
|
Assembler::kCallTargetAddressOffset + (2 * kInstrSize);
|
|
// This should contain all kJSCallerSaved registers.
|
const RegList kSavedRegs =
|
kJSCallerSaved | // Caller saved registers.
|
s5.bit(); // Saved stack pointer.
|
|
// We also save ra, so the count here is one higher than the mask indicates.
|
const int32_t kNumSavedRegs = kNumJSCallerSaved + 2;
|
|
// Save all caller-save registers as this may be called from anywhere.
|
__ MultiPush(kSavedRegs | ra.bit());
|
|
// Compute the function's address for the first argument.
|
__ Dsubu(a0, ra, Operand(kReturnAddressDistanceFromFunctionStart));
|
|
// The caller's return address is above the saved temporaries.
|
// Grab that for the second argument to the hook.
|
__ Daddu(a1, sp, Operand(kNumSavedRegs * kPointerSize));
|
|
// Align the stack if necessary.
|
int frame_alignment = masm->ActivationFrameAlignment();
|
if (frame_alignment > kPointerSize) {
|
__ mov(s5, sp);
|
DCHECK(base::bits::IsPowerOfTwo(frame_alignment));
|
__ And(sp, sp, Operand(-frame_alignment));
|
}
|
|
__ Dsubu(sp, sp, kCArgsSlotsSize);
|
#if defined(V8_HOST_ARCH_MIPS) || defined(V8_HOST_ARCH_MIPS64)
|
int64_t entry_hook =
|
reinterpret_cast<int64_t>(isolate()->function_entry_hook());
|
__ li(t9, Operand(entry_hook));
|
#else
|
// Under the simulator we need to indirect the entry hook through a
|
// trampoline function at a known address.
|
// It additionally takes an isolate as a third parameter.
|
__ li(a2, ExternalReference::isolate_address(isolate()));
|
|
ApiFunction dispatcher(FUNCTION_ADDR(EntryHookTrampoline));
|
__ li(t9, ExternalReference::Create(&dispatcher,
|
ExternalReference::BUILTIN_CALL));
|
#endif
|
// Call C function through t9 to conform ABI for PIC.
|
__ Call(t9);
|
|
// Restore the stack pointer if needed.
|
if (frame_alignment > kPointerSize) {
|
__ mov(sp, s5);
|
} else {
|
__ Daddu(sp, sp, kCArgsSlotsSize);
|
}
|
|
// Also pop ra to get Ret(0).
|
__ MultiPop(kSavedRegs | ra.bit());
|
__ Ret();
|
}
|
|
static int AddressOffset(ExternalReference ref0, ExternalReference ref1) {
|
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,
|
int32_t stack_space_offset,
|
MemOperand return_value_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 == a1 || function_address == a2);
|
|
Label profiler_disabled;
|
Label end_profiler_check;
|
__ li(t9, ExternalReference::is_profiling_address(isolate));
|
__ Lb(t9, MemOperand(t9, 0));
|
__ Branch(&profiler_disabled, eq, t9, Operand(zero_reg));
|
|
// Additional parameter is the address of the actual callback.
|
__ li(t9, thunk_ref);
|
__ jmp(&end_profiler_check);
|
|
__ bind(&profiler_disabled);
|
__ mov(t9, function_address);
|
__ bind(&end_profiler_check);
|
|
// Allocate HandleScope in callee-save registers.
|
__ li(s5, next_address);
|
__ Ld(s0, MemOperand(s5, kNextOffset));
|
__ Ld(s1, MemOperand(s5, kLimitOffset));
|
__ Lw(s2, MemOperand(s5, kLevelOffset));
|
__ Addu(s2, s2, Operand(1));
|
__ Sw(s2, MemOperand(s5, kLevelOffset));
|
|
if (FLAG_log_timer_events) {
|
FrameScope frame(masm, StackFrame::MANUAL);
|
__ PushSafepointRegisters();
|
__ PrepareCallCFunction(1, a0);
|
__ li(a0, ExternalReference::isolate_address(isolate));
|
__ CallCFunction(ExternalReference::log_enter_external_function(), 1);
|
__ PopSafepointRegisters();
|
}
|
|
// Native call returns to the DirectCEntry stub which redirects to the
|
// return address pushed on stack (could have moved after GC).
|
// DirectCEntry stub itself is generated early and never moves.
|
DirectCEntryStub stub(isolate);
|
stub.GenerateCall(masm, t9);
|
|
if (FLAG_log_timer_events) {
|
FrameScope frame(masm, StackFrame::MANUAL);
|
__ PushSafepointRegisters();
|
__ PrepareCallCFunction(1, a0);
|
__ li(a0, ExternalReference::isolate_address(isolate));
|
__ CallCFunction(ExternalReference::log_leave_external_function(), 1);
|
__ PopSafepointRegisters();
|
}
|
|
Label promote_scheduled_exception;
|
Label delete_allocated_handles;
|
Label leave_exit_frame;
|
Label return_value_loaded;
|
|
// Load value from ReturnValue.
|
__ Ld(v0, return_value_operand);
|
__ bind(&return_value_loaded);
|
|
// No more valid handles (the result handle was the last one). Restore
|
// previous handle scope.
|
__ Sd(s0, MemOperand(s5, kNextOffset));
|
if (__ emit_debug_code()) {
|
__ Lw(a1, MemOperand(s5, kLevelOffset));
|
__ Check(eq, AbortReason::kUnexpectedLevelAfterReturnFromApiCall, a1,
|
Operand(s2));
|
}
|
__ Subu(s2, s2, Operand(1));
|
__ Sw(s2, MemOperand(s5, kLevelOffset));
|
__ Ld(kScratchReg, MemOperand(s5, kLimitOffset));
|
__ Branch(&delete_allocated_handles, ne, s1, Operand(kScratchReg));
|
|
// Leave the API exit frame.
|
__ bind(&leave_exit_frame);
|
|
if (stack_space_offset != kInvalidStackOffset) {
|
DCHECK_EQ(kCArgsSlotsSize, 0);
|
__ Ld(s0, MemOperand(sp, stack_space_offset));
|
} else {
|
__ li(s0, Operand(stack_space));
|
}
|
__ LeaveExitFrame(false, s0, NO_EMIT_RETURN,
|
stack_space_offset != kInvalidStackOffset);
|
|
// Check if the function scheduled an exception.
|
__ LoadRoot(a4, Heap::kTheHoleValueRootIndex);
|
__ li(kScratchReg, ExternalReference::scheduled_exception_address(isolate));
|
__ Ld(a5, MemOperand(kScratchReg));
|
__ Branch(&promote_scheduled_exception, ne, a4, Operand(a5));
|
|
__ Ret();
|
|
// Re-throw by promoting a scheduled exception.
|
__ bind(&promote_scheduled_exception);
|
__ TailCallRuntime(Runtime::kPromoteScheduledException);
|
|
// HandleScope limit has changed. Delete allocated extensions.
|
__ bind(&delete_allocated_handles);
|
__ Sd(s1, MemOperand(s5, kLimitOffset));
|
__ mov(s0, v0);
|
__ mov(a0, v0);
|
__ PrepareCallCFunction(1, s1);
|
__ li(a0, ExternalReference::isolate_address(isolate));
|
__ CallCFunction(ExternalReference::delete_handle_scope_extensions(), 1);
|
__ mov(v0, s0);
|
__ jmp(&leave_exit_frame);
|
}
|
|
void CallApiCallbackStub::Generate(MacroAssembler* masm) {
|
// ----------- S t a t e -------------
|
// -- a4 : call_data
|
// -- a2 : holder
|
// -- a1 : api_function_address
|
// -- cp : context
|
// --
|
// -- sp[0] : last argument
|
// -- ...
|
// -- sp[(argc - 1) * 8] : first argument
|
// -- sp[argc * 8] : receiver
|
// -----------------------------------
|
|
Register call_data = a4;
|
Register holder = a2;
|
Register api_function_address = a1;
|
|
typedef FunctionCallbackArguments FCA;
|
|
STATIC_ASSERT(FCA::kArgsLength == 6);
|
STATIC_ASSERT(FCA::kNewTargetIndex == 5);
|
STATIC_ASSERT(FCA::kDataIndex == 4);
|
STATIC_ASSERT(FCA::kReturnValueOffset == 3);
|
STATIC_ASSERT(FCA::kReturnValueDefaultValueIndex == 2);
|
STATIC_ASSERT(FCA::kIsolateIndex == 1);
|
STATIC_ASSERT(FCA::kHolderIndex == 0);
|
|
// new target
|
__ PushRoot(Heap::kUndefinedValueRootIndex);
|
|
// call data.
|
__ Push(call_data);
|
|
Register scratch = call_data;
|
__ LoadRoot(scratch, Heap::kUndefinedValueRootIndex);
|
// Push return value and default return value.
|
__ Push(scratch, scratch);
|
__ li(scratch, ExternalReference::isolate_address(masm->isolate()));
|
// Push isolate and holder.
|
__ Push(scratch, holder);
|
|
// Prepare arguments.
|
__ mov(scratch, sp);
|
|
// Allocate the v8::Arguments structure in the arguments' space since
|
// it's not controlled by GC.
|
const int kApiStackSpace = 3;
|
|
FrameScope frame_scope(masm, StackFrame::MANUAL);
|
__ EnterExitFrame(false, kApiStackSpace);
|
|
DCHECK(api_function_address != a0 && scratch != a0);
|
// a0 = FunctionCallbackInfo&
|
// Arguments is after the return address.
|
__ Daddu(a0, sp, Operand(1 * kPointerSize));
|
// FunctionCallbackInfo::implicit_args_
|
__ Sd(scratch, MemOperand(a0, 0 * kPointerSize));
|
// FunctionCallbackInfo::values_
|
__ Daddu(kScratchReg, scratch,
|
Operand((FCA::kArgsLength - 1 + argc()) * kPointerSize));
|
__ Sd(kScratchReg, MemOperand(a0, 1 * kPointerSize));
|
// FunctionCallbackInfo::length_ = argc
|
// Stored as int field, 32-bit integers within struct on stack always left
|
// justified by n64 ABI.
|
__ li(kScratchReg, Operand(argc()));
|
__ Sw(kScratchReg, MemOperand(a0, 2 * kPointerSize));
|
|
ExternalReference thunk_ref = ExternalReference::invoke_function_callback();
|
|
AllowExternalCallThatCantCauseGC scope(masm);
|
// Stores return the first js argument.
|
int return_value_offset = 2 + FCA::kReturnValueOffset;
|
MemOperand return_value_operand(fp, return_value_offset * kPointerSize);
|
const int stack_space = argc() + FCA::kArgsLength + 1;
|
// TODO(adamk): Why are we clobbering this immediately?
|
const int32_t stack_space_offset = kInvalidStackOffset;
|
CallApiFunctionAndReturn(masm, api_function_address, thunk_ref, stack_space,
|
stack_space_offset, return_value_operand);
|
}
|
|
|
void CallApiGetterStub::Generate(MacroAssembler* masm) {
|
// Build v8::PropertyCallbackInfo::args_ array on the stack and push property
|
// name below the exit frame to make GC aware of them.
|
STATIC_ASSERT(PropertyCallbackArguments::kShouldThrowOnErrorIndex == 0);
|
STATIC_ASSERT(PropertyCallbackArguments::kHolderIndex == 1);
|
STATIC_ASSERT(PropertyCallbackArguments::kIsolateIndex == 2);
|
STATIC_ASSERT(PropertyCallbackArguments::kReturnValueDefaultValueIndex == 3);
|
STATIC_ASSERT(PropertyCallbackArguments::kReturnValueOffset == 4);
|
STATIC_ASSERT(PropertyCallbackArguments::kDataIndex == 5);
|
STATIC_ASSERT(PropertyCallbackArguments::kThisIndex == 6);
|
STATIC_ASSERT(PropertyCallbackArguments::kArgsLength == 7);
|
|
Register receiver = ApiGetterDescriptor::ReceiverRegister();
|
Register holder = ApiGetterDescriptor::HolderRegister();
|
Register callback = ApiGetterDescriptor::CallbackRegister();
|
Register scratch = a4;
|
DCHECK(!AreAliased(receiver, holder, callback, scratch));
|
|
Register api_function_address = a2;
|
|
// Here and below +1 is for name() pushed after the args_ array.
|
typedef PropertyCallbackArguments PCA;
|
__ Dsubu(sp, sp, (PCA::kArgsLength + 1) * kPointerSize);
|
__ Sd(receiver, MemOperand(sp, (PCA::kThisIndex + 1) * kPointerSize));
|
__ Ld(scratch, FieldMemOperand(callback, AccessorInfo::kDataOffset));
|
__ Sd(scratch, MemOperand(sp, (PCA::kDataIndex + 1) * kPointerSize));
|
__ LoadRoot(scratch, Heap::kUndefinedValueRootIndex);
|
__ Sd(scratch, MemOperand(sp, (PCA::kReturnValueOffset + 1) * kPointerSize));
|
__ Sd(scratch, MemOperand(sp, (PCA::kReturnValueDefaultValueIndex + 1) *
|
kPointerSize));
|
__ li(scratch, ExternalReference::isolate_address(isolate()));
|
__ Sd(scratch, MemOperand(sp, (PCA::kIsolateIndex + 1) * kPointerSize));
|
__ Sd(holder, MemOperand(sp, (PCA::kHolderIndex + 1) * kPointerSize));
|
// should_throw_on_error -> false
|
DCHECK_NULL(Smi::kZero);
|
__ Sd(zero_reg,
|
MemOperand(sp, (PCA::kShouldThrowOnErrorIndex + 1) * kPointerSize));
|
__ Ld(scratch, FieldMemOperand(callback, AccessorInfo::kNameOffset));
|
__ Sd(scratch, MemOperand(sp, 0 * kPointerSize));
|
|
// v8::PropertyCallbackInfo::args_ array and name handle.
|
const int kStackUnwindSpace = PropertyCallbackArguments::kArgsLength + 1;
|
|
// Load address of v8::PropertyAccessorInfo::args_ array and name handle.
|
__ mov(a0, sp); // a0 = Handle<Name>
|
__ Daddu(a1, a0, Operand(1 * kPointerSize)); // a1 = v8::PCI::args_
|
|
const int kApiStackSpace = 1;
|
FrameScope frame_scope(masm, StackFrame::MANUAL);
|
__ EnterExitFrame(false, kApiStackSpace);
|
|
// Create v8::PropertyCallbackInfo object on the stack and initialize
|
// it's args_ field.
|
__ Sd(a1, MemOperand(sp, 1 * kPointerSize));
|
__ Daddu(a1, sp, Operand(1 * kPointerSize));
|
// a1 = v8::PropertyCallbackInfo&
|
|
ExternalReference thunk_ref =
|
ExternalReference::invoke_accessor_getter_callback();
|
|
__ Ld(scratch, FieldMemOperand(callback, AccessorInfo::kJsGetterOffset));
|
__ Ld(api_function_address,
|
FieldMemOperand(scratch, Foreign::kForeignAddressOffset));
|
|
// +3 is to skip prolog, return address and name handle.
|
MemOperand return_value_operand(
|
fp, (PropertyCallbackArguments::kReturnValueOffset + 3) * kPointerSize);
|
CallApiFunctionAndReturn(masm, api_function_address, thunk_ref,
|
kStackUnwindSpace, kInvalidStackOffset,
|
return_value_operand);
|
}
|
|
#undef __
|
|
} // namespace internal
|
} // namespace v8
|
|
#endif // V8_TARGET_ARCH_MIPS64
|
