| // 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_ARM |
| |
| #include "src/api-arguments.h" |
| #include "src/assembler-inl.h" |
| #include "src/base/bits.h" |
| #include "src/bootstrapper.h" |
| #include "src/code-stubs.h" |
| #include "src/counters.h" |
| #include "src/double.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/objects/regexp-match-info.h" |
| #include "src/regexp/jsregexp.h" |
| #include "src/regexp/regexp-macro-assembler.h" |
| #include "src/runtime/runtime.h" |
| |
| #include "src/arm/code-stubs-arm.h" // Cannot be the first include. |
| |
| namespace v8 { |
| namespace internal { |
| |
| #define __ ACCESS_MASM(masm) |
| |
| void JSEntryStub::Generate(MacroAssembler* masm) { |
| // r0: code entry |
| // r1: function |
| // r2: receiver |
| // r3: argc |
| // [sp+0]: argv |
| |
| Label invoke, handler_entry, exit; |
| |
| { |
| NoRootArrayScope no_root_array(masm); |
| |
| ProfileEntryHookStub::MaybeCallEntryHook(masm); |
| |
| // Called from C, so do not pop argc and args on exit (preserve sp) |
| // No need to save register-passed args |
| // Save callee-saved registers (incl. cp and fp), sp, and lr |
| __ stm(db_w, sp, kCalleeSaved | lr.bit()); |
| |
| // Save callee-saved vfp registers. |
| __ vstm(db_w, sp, kFirstCalleeSavedDoubleReg, kLastCalleeSavedDoubleReg); |
| // Set up the reserved register for 0.0. |
| __ vmov(kDoubleRegZero, Double(0.0)); |
| |
| __ InitializeRootRegister(); |
| } |
| |
| // Get address of argv, see stm above. |
| // r0: code entry |
| // r1: function |
| // r2: receiver |
| // r3: argc |
| |
| // Set up argv in r4. |
| int offset_to_argv = (kNumCalleeSaved + 1) * kPointerSize; |
| offset_to_argv += kNumDoubleCalleeSaved * kDoubleSize; |
| __ ldr(r4, MemOperand(sp, offset_to_argv)); |
| |
| // Push a frame with special values setup to mark it as an entry frame. |
| // r0: code entry |
| // r1: function |
| // r2: receiver |
| // r3: argc |
| // r4: argv |
| StackFrame::Type marker = type(); |
| __ mov(r7, Operand(StackFrame::TypeToMarker(marker))); |
| __ mov(r6, Operand(StackFrame::TypeToMarker(marker))); |
| __ mov(r5, Operand(ExternalReference::Create( |
| IsolateAddressId::kCEntryFPAddress, isolate()))); |
| __ ldr(r5, MemOperand(r5)); |
| { |
| UseScratchRegisterScope temps(masm); |
| Register scratch = temps.Acquire(); |
| |
| // Push a bad frame pointer to fail if it is used. |
| __ mov(scratch, Operand(-1)); |
| __ stm(db_w, sp, r5.bit() | r6.bit() | r7.bit() | scratch.bit()); |
| } |
| |
| Register scratch = r6; |
| |
| // Set up frame pointer for the frame to be pushed. |
| __ add(fp, sp, Operand(-EntryFrameConstants::kCallerFPOffset)); |
| |
| // 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()); |
| __ mov(r5, Operand(ExternalReference(js_entry_sp))); |
| __ ldr(scratch, MemOperand(r5)); |
| __ cmp(scratch, Operand::Zero()); |
| __ b(ne, &non_outermost_js); |
| __ str(fp, MemOperand(r5)); |
| __ mov(scratch, Operand(StackFrame::OUTERMOST_JSENTRY_FRAME)); |
| Label cont; |
| __ b(&cont); |
| __ bind(&non_outermost_js); |
| __ mov(scratch, Operand(StackFrame::INNER_JSENTRY_FRAME)); |
| __ bind(&cont); |
| __ push(scratch); |
| |
| // Jump to a faked try block that does the invoke, with a faked catch |
| // block that sets the pending exception. |
| __ jmp(&invoke); |
| |
| // Block literal pool emission whilst taking the position of the handler |
| // entry. This avoids making the assumption that literal pools are always |
| // emitted after an instruction is emitted, rather than before. |
| { |
| Assembler::BlockConstPoolScope block_const_pool(masm); |
| __ 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. |
| __ mov(scratch, |
| Operand(ExternalReference::Create( |
| IsolateAddressId::kPendingExceptionAddress, isolate()))); |
| } |
| __ str(r0, MemOperand(scratch)); |
| __ LoadRoot(r0, Heap::kExceptionRootIndex); |
| __ b(&exit); |
| |
| // Invoke: Link this frame into the handler chain. |
| __ bind(&invoke); |
| // Must preserve r0-r4, r5-r6 are available. |
| __ PushStackHandler(); |
| // If an exception not caught by another handler occurs, this handler |
| // returns control to the code after the bl(&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. |
| |
| // Expected registers by Builtins::JSEntryTrampoline |
| // r0: code entry |
| // r1: function |
| // r2: receiver |
| // r3: argc |
| // r4: argv |
| __ Call(EntryTrampoline(), RelocInfo::CODE_TARGET); |
| |
| // Unlink this frame from the handler chain. |
| __ PopStackHandler(); |
| |
| __ bind(&exit); // r0 holds result |
| // Check if the current stack frame is marked as the outermost JS frame. |
| Label non_outermost_js_2; |
| __ pop(r5); |
| __ cmp(r5, Operand(StackFrame::OUTERMOST_JSENTRY_FRAME)); |
| __ b(ne, &non_outermost_js_2); |
| __ mov(r6, Operand::Zero()); |
| __ mov(r5, Operand(ExternalReference(js_entry_sp))); |
| __ str(r6, MemOperand(r5)); |
| __ bind(&non_outermost_js_2); |
| |
| // Restore the top frame descriptors from the stack. |
| __ pop(r3); |
| __ mov(scratch, Operand(ExternalReference::Create( |
| IsolateAddressId::kCEntryFPAddress, isolate()))); |
| __ str(r3, MemOperand(scratch)); |
| |
| // Reset the stack to the callee saved registers. |
| __ add(sp, sp, Operand(-EntryFrameConstants::kCallerFPOffset)); |
| |
| // Restore callee-saved registers and return. |
| #ifdef DEBUG |
| if (FLAG_debug_code) { |
| __ mov(lr, Operand(pc)); |
| } |
| #endif |
| |
| // Restore callee-saved vfp registers. |
| __ vldm(ia_w, sp, kFirstCalleeSavedDoubleReg, kLastCalleeSavedDoubleReg); |
| |
| __ ldm(ia_w, sp, kCalleeSaved | pc.bit()); |
| } |
| |
| void DirectCEntryStub::Generate(MacroAssembler* masm) { |
| // Place the return address on the stack, making the call |
| // GC safe. The RegExp backend also relies on this. |
| __ str(lr, MemOperand(sp, 0)); |
| __ blx(ip); // Call the C++ function. |
| __ ldr(pc, MemOperand(sp, 0)); |
| } |
| |
| |
| void DirectCEntryStub::GenerateCall(MacroAssembler* masm, |
| Register target) { |
| #ifdef V8_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 lr instead of ip. |
| __ Move(ip, target); |
| __ IndirectLoadConstant(lr, GetCode()); |
| __ add(lr, lr, Operand(Code::kHeaderSize - kHeapObjectTag)); |
| __ blx(lr); |
| return; |
| } |
| #endif |
| intptr_t code = |
| reinterpret_cast<intptr_t>(GetCode().location()); |
| __ Move(ip, target); |
| __ mov(lr, Operand(code, RelocInfo::CODE_TARGET)); |
| __ blx(lr); // Call the stub. |
| } |
| |
| |
| void ProfileEntryHookStub::MaybeCallEntryHookDelayed(TurboAssembler* tasm, |
| Zone* zone) { |
| if (tasm->isolate()->function_entry_hook() != nullptr) { |
| tasm->MaybeCheckConstPool(); |
| PredictableCodeSizeScope predictable( |
| tasm, tasm->CallStubSize() + 2 * Assembler::kInstrSize); |
| tasm->push(lr); |
| tasm->CallStubDelayed(new (zone) ProfileEntryHookStub(nullptr)); |
| tasm->pop(lr); |
| } |
| } |
| |
| void ProfileEntryHookStub::MaybeCallEntryHook(MacroAssembler* masm) { |
| if (masm->isolate()->function_entry_hook() != nullptr) { |
| ProfileEntryHookStub stub(masm->isolate()); |
| masm->MaybeCheckConstPool(); |
| PredictableCodeSizeScope predictable( |
| masm, masm->CallStubSize() + 2 * Assembler::kInstrSize); |
| __ push(lr); |
| __ CallStub(&stub); |
| __ pop(lr); |
| } |
| } |
| |
| |
| void ProfileEntryHookStub::Generate(MacroAssembler* masm) { |
| // The entry hook is a "push lr" instruction, followed by a call. |
| const int32_t kReturnAddressDistanceFromFunctionStart = |
| 3 * Assembler::kInstrSize; |
| |
| // This should contain all kCallerSaved registers. |
| const RegList kSavedRegs = |
| 1 << 0 | // r0 |
| 1 << 1 | // r1 |
| 1 << 2 | // r2 |
| 1 << 3 | // r3 |
| 1 << 5 | // r5 |
| 1 << 9; // r9 |
| // We also save lr, so the count here is one higher than the mask indicates. |
| const int32_t kNumSavedRegs = 7; |
| |
| DCHECK_EQ(kCallerSaved & kSavedRegs, kCallerSaved); |
| |
| // Save all caller-save registers as this may be called from anywhere. |
| __ stm(db_w, sp, kSavedRegs | lr.bit()); |
| |
| // Compute the function's address for the first argument. |
| __ sub(r0, lr, Operand(kReturnAddressDistanceFromFunctionStart)); |
| |
| // The caller's return address is above the saved temporaries. |
| // Grab that for the second argument to the hook. |
| __ add(r1, sp, Operand(kNumSavedRegs * kPointerSize)); |
| |
| // Align the stack if necessary. |
| int frame_alignment = masm->ActivationFrameAlignment(); |
| if (frame_alignment > kPointerSize) { |
| __ mov(r5, sp); |
| DCHECK(base::bits::IsPowerOfTwo(frame_alignment)); |
| __ and_(sp, sp, Operand(-frame_alignment)); |
| } |
| |
| { |
| UseScratchRegisterScope temps(masm); |
| Register scratch = temps.Acquire(); |
| |
| #if V8_HOST_ARCH_ARM |
| int32_t entry_hook = |
| reinterpret_cast<int32_t>(isolate()->function_entry_hook()); |
| __ mov(scratch, 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 |
| __ mov(r2, Operand(ExternalReference::isolate_address(isolate()))); |
| |
| ApiFunction dispatcher(FUNCTION_ADDR(EntryHookTrampoline)); |
| __ mov(scratch, Operand(ExternalReference::Create( |
| &dispatcher, ExternalReference::BUILTIN_CALL))); |
| #endif |
| __ Call(scratch); |
| } |
| |
| // Restore the stack pointer if needed. |
| if (frame_alignment > kPointerSize) { |
| __ mov(sp, r5); |
| } |
| |
| // Also pop pc to get Ret(0). |
| __ ldm(ia_w, sp, kSavedRegs | pc.bit()); |
| } |
| |
| static int AddressOffset(ExternalReference ref0, ExternalReference ref1) { |
| return ref0.address() - ref1.address(); |
| } |
| |
| |
| // 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) { |
| 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 == r1 || function_address == r2); |
| |
| Label profiler_disabled; |
| Label end_profiler_check; |
| __ Move(r9, ExternalReference::is_profiling_address(isolate)); |
| __ ldrb(r9, MemOperand(r9, 0)); |
| __ cmp(r9, Operand(0)); |
| __ b(eq, &profiler_disabled); |
| |
| // Additional parameter is the address of the actual callback. |
| __ Move(r3, thunk_ref); |
| __ jmp(&end_profiler_check); |
| |
| __ bind(&profiler_disabled); |
| __ Move(r3, function_address); |
| __ bind(&end_profiler_check); |
| |
| // Allocate HandleScope in callee-save registers. |
| __ Move(r9, next_address); |
| __ ldr(r4, MemOperand(r9, kNextOffset)); |
| __ ldr(r5, MemOperand(r9, kLimitOffset)); |
| __ ldr(r6, MemOperand(r9, kLevelOffset)); |
| __ add(r6, r6, Operand(1)); |
| __ str(r6, MemOperand(r9, kLevelOffset)); |
| |
| if (FLAG_log_timer_events) { |
| FrameScope frame(masm, StackFrame::MANUAL); |
| __ PushSafepointRegisters(); |
| __ PrepareCallCFunction(1); |
| __ Move(r0, 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, r3); |
| |
| if (FLAG_log_timer_events) { |
| FrameScope frame(masm, StackFrame::MANUAL); |
| __ PushSafepointRegisters(); |
| __ PrepareCallCFunction(1); |
| __ Move(r0, 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 |
| __ ldr(r0, return_value_operand); |
| __ bind(&return_value_loaded); |
| // No more valid handles (the result handle was the last one). Restore |
| // previous handle scope. |
| __ str(r4, MemOperand(r9, kNextOffset)); |
| if (__ emit_debug_code()) { |
| __ ldr(r1, MemOperand(r9, kLevelOffset)); |
| __ cmp(r1, r6); |
| __ Check(eq, AbortReason::kUnexpectedLevelAfterReturnFromApiCall); |
| } |
| __ sub(r6, r6, Operand(1)); |
| __ str(r6, MemOperand(r9, kLevelOffset)); |
| __ ldr(r6, MemOperand(r9, kLimitOffset)); |
| __ cmp(r5, r6); |
| __ b(ne, &delete_allocated_handles); |
| |
| // Leave the API exit frame. |
| __ bind(&leave_exit_frame); |
| // LeaveExitFrame expects unwind space to be in a register. |
| if (stack_space_operand != nullptr) { |
| __ ldr(r4, *stack_space_operand); |
| } else { |
| __ mov(r4, Operand(stack_space)); |
| } |
| __ LeaveExitFrame(false, r4, stack_space_operand != nullptr); |
| |
| // Check if the function scheduled an exception. |
| __ LoadRoot(r4, Heap::kTheHoleValueRootIndex); |
| __ Move(r6, ExternalReference::scheduled_exception_address(isolate)); |
| __ ldr(r5, MemOperand(r6)); |
| __ cmp(r4, r5); |
| __ b(ne, &promote_scheduled_exception); |
| |
| __ mov(pc, lr); |
| |
| // 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); |
| __ str(r5, MemOperand(r9, kLimitOffset)); |
| __ mov(r4, r0); |
| __ PrepareCallCFunction(1); |
| __ Move(r0, ExternalReference::isolate_address(isolate)); |
| __ CallCFunction(ExternalReference::delete_handle_scope_extensions(), 1); |
| __ mov(r0, r4); |
| __ jmp(&leave_exit_frame); |
| } |
| |
| void CallApiCallbackStub::Generate(MacroAssembler* masm) { |
| // ----------- S t a t e ------------- |
| // -- r4 : call_data |
| // -- r2 : holder |
| // -- r1 : api_function_address |
| // -- cp : context |
| // -- |
| // -- sp[0] : last argument |
| // -- ... |
| // -- sp[(argc - 1) * 4] : first argument |
| // -- sp[argc * 4] : receiver |
| // ----------------------------------- |
| |
| Register call_data = r4; |
| Register holder = r2; |
| Register api_function_address = r1; |
| |
| 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 scratch0 = call_data; |
| Register scratch1 = r5; |
| __ LoadRoot(scratch0, Heap::kUndefinedValueRootIndex); |
| // return value |
| __ push(scratch0); |
| // return value default |
| __ push(scratch0); |
| // isolate |
| __ Move(scratch1, ExternalReference::isolate_address(masm->isolate())); |
| __ push(scratch1); |
| // holder |
| __ push(holder); |
| |
| // Prepare arguments. |
| __ mov(scratch0, 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 != r0 && scratch0 != r0); |
| // r0 = FunctionCallbackInfo& |
| // Arguments is after the return address. |
| __ add(r0, sp, Operand(1 * kPointerSize)); |
| // FunctionCallbackInfo::implicit_args_ |
| __ str(scratch0, MemOperand(r0, 0 * kPointerSize)); |
| // FunctionCallbackInfo::values_ |
| __ add(scratch1, scratch0, |
| Operand((FCA::kArgsLength - 1 + argc()) * kPointerSize)); |
| __ str(scratch1, MemOperand(r0, 1 * kPointerSize)); |
| // FunctionCallbackInfo::length_ = argc |
| __ mov(scratch0, Operand(argc())); |
| __ str(scratch0, MemOperand(r0, 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; |
| MemOperand* stack_space_operand = nullptr; |
| |
| CallApiFunctionAndReturn(masm, api_function_address, thunk_ref, stack_space, |
| stack_space_operand, 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 = r4; |
| DCHECK(!AreAliased(receiver, holder, callback, scratch)); |
| |
| Register api_function_address = r2; |
| |
| __ push(receiver); |
| // Push data from AccessorInfo. |
| __ ldr(scratch, FieldMemOperand(callback, AccessorInfo::kDataOffset)); |
| __ push(scratch); |
| __ LoadRoot(scratch, Heap::kUndefinedValueRootIndex); |
| __ Push(scratch, scratch); |
| __ Move(scratch, ExternalReference::isolate_address(isolate())); |
| __ Push(scratch, holder); |
| __ Push(Smi::kZero); // should_throw_on_error -> false |
| __ ldr(scratch, FieldMemOperand(callback, AccessorInfo::kNameOffset)); |
| __ push(scratch); |
| // v8::PropertyCallbackInfo::args_ array and name handle. |
| const int kStackUnwindSpace = PropertyCallbackArguments::kArgsLength + 1; |
| |
| // Load address of v8::PropertyAccessorInfo::args_ array and name handle. |
| __ mov(r0, sp); // r0 = Handle<Name> |
| __ add(r1, r0, Operand(1 * kPointerSize)); // r1 = 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. |
| __ str(r1, MemOperand(sp, 1 * kPointerSize)); |
| __ add(r1, sp, Operand(1 * kPointerSize)); // r1 = v8::PropertyCallbackInfo& |
| |
| ExternalReference thunk_ref = |
| ExternalReference::invoke_accessor_getter_callback(); |
| |
| __ ldr(scratch, FieldMemOperand(callback, AccessorInfo::kJsGetterOffset)); |
| __ ldr(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, nullptr, return_value_operand); |
| } |
| |
| #undef __ |
| |
| } // namespace internal |
| } // namespace v8 |
| |
| #endif // V8_TARGET_ARCH_ARM |