// 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(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) 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(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(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(offset) == offset); return static_cast(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 __ 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