���� JFIF �� � ( %"1"%)+...383,7(-.-
![]() Server : Apache/2.4.6 (CentOS) OpenSSL/1.0.2k-fips PHP/7.4.20 System : Linux st2.domain.com 3.10.0-1127.10.1.el7.x86_64 #1 SMP Wed Jun 3 14:28:03 UTC 2020 x86_64 User : apache ( 48) PHP Version : 7.4.20 Disable Function : NONE Directory : /home/real/node-v13.0.1/deps/v8/src/builtins/x64/ |
// 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_X64 #include "src/api/api-arguments.h" #include "src/base/adapters.h" #include "src/codegen/code-factory.h" #include "src/deoptimizer/deoptimizer.h" #include "src/execution/frame-constants.h" #include "src/execution/frames.h" #include "src/logging/counters.h" // For interpreter_entry_return_pc_offset. TODO(jkummerow): Drop. #include "src/codegen/macro-assembler-inl.h" #include "src/codegen/register-configuration.h" #include "src/heap/heap-inl.h" #include "src/objects/cell.h" #include "src/objects/debug-objects.h" #include "src/objects/foreign.h" #include "src/objects/heap-number.h" #include "src/objects/js-generator.h" #include "src/objects/objects-inl.h" #include "src/objects/smi.h" #include "src/wasm/wasm-linkage.h" #include "src/wasm/wasm-objects.h" namespace v8 { namespace internal { #define __ ACCESS_MASM(masm) void Builtins::Generate_Adaptor(MacroAssembler* masm, Address address) { __ LoadAddress(kJavaScriptCallExtraArg1Register, ExternalReference::Create(address)); __ Jump(BUILTIN_CODE(masm->isolate(), AdaptorWithBuiltinExitFrame), RelocInfo::CODE_TARGET); } static void GenerateTailCallToReturnedCode(MacroAssembler* masm, Runtime::FunctionId function_id) { // ----------- S t a t e ------------- // -- rdx : new target (preserved for callee) // -- rdi : target function (preserved for callee) // ----------------------------------- { FrameScope scope(masm, StackFrame::INTERNAL); // Push a copy of the target function and the new target. __ Push(rdi); __ Push(rdx); // Function is also the parameter to the runtime call. __ Push(rdi); __ CallRuntime(function_id, 1); __ movq(rcx, rax); // Restore target function and new target. __ Pop(rdx); __ Pop(rdi); } static_assert(kJavaScriptCallCodeStartRegister == rcx, "ABI mismatch"); __ JumpCodeObject(rcx); } namespace { Operand RealStackLimitAsOperand(MacroAssembler* masm) { DCHECK(masm->root_array_available()); Isolate* isolate = masm->isolate(); ExternalReference limit = ExternalReference::address_of_real_jslimit(isolate); DCHECK(TurboAssembler::IsAddressableThroughRootRegister(isolate, limit)); intptr_t offset = TurboAssembler::RootRegisterOffsetForExternalReference(isolate, limit); CHECK(is_int32(offset)); return Operand(kRootRegister, static_cast<int32_t>(offset)); } void Generate_StackOverflowCheck( MacroAssembler* masm, Register num_args, Register scratch, Label* stack_overflow, Label::Distance stack_overflow_distance = Label::kFar) { // Check the stack for overflow. We are not trying to catch // interruptions (e.g. debug break and preemption) here, so the "real stack // limit" is checked. __ movq(kScratchRegister, RealStackLimitAsOperand(masm)); __ movq(scratch, rsp); // Make scratch the space we have left. The stack might already be overflowed // here which will cause scratch to become negative. __ subq(scratch, kScratchRegister); __ sarq(scratch, Immediate(kSystemPointerSizeLog2)); // Check if the arguments will overflow the stack. __ cmpq(scratch, num_args); // Signed comparison. __ j(less_equal, stack_overflow, stack_overflow_distance); } void Generate_JSBuiltinsConstructStubHelper(MacroAssembler* masm) { // ----------- S t a t e ------------- // -- rax: number of arguments // -- rdi: constructor function // -- rdx: new target // -- rsi: context // ----------------------------------- Label stack_overflow; Generate_StackOverflowCheck(masm, rax, rcx, &stack_overflow, Label::kFar); // Enter a construct frame. { FrameScope scope(masm, StackFrame::CONSTRUCT); // Preserve the incoming parameters on the stack. __ SmiTag(rcx, rax); __ Push(rsi); __ Push(rcx); // The receiver for the builtin/api call. __ PushRoot(RootIndex::kTheHoleValue); // Set up pointer to last argument. __ leaq(rbx, Operand(rbp, StandardFrameConstants::kCallerSPOffset)); // Copy arguments and receiver to the expression stack. Label loop, entry; __ movq(rcx, rax); // ----------- S t a t e ------------- // -- rax: number of arguments (untagged) // -- rdi: constructor function // -- rdx: new target // -- rbx: pointer to last argument // -- rcx: counter // -- sp[0*kSystemPointerSize]: the hole (receiver) // -- sp[1*kSystemPointerSize]: number of arguments (tagged) // -- sp[2*kSystemPointerSize]: context // ----------------------------------- __ jmp(&entry); __ bind(&loop); __ Push(Operand(rbx, rcx, times_system_pointer_size, 0)); __ bind(&entry); __ decq(rcx); __ j(greater_equal, &loop, Label::kNear); // Call the function. // rax: number of arguments (untagged) // rdi: constructor function // rdx: new target ParameterCount actual(rax); __ InvokeFunction(rdi, rdx, actual, CALL_FUNCTION); // Restore context from the frame. __ movq(rsi, Operand(rbp, ConstructFrameConstants::kContextOffset)); // Restore smi-tagged arguments count from the frame. __ movq(rbx, Operand(rbp, ConstructFrameConstants::kLengthOffset)); // Leave construct frame. } // Remove caller arguments from the stack and return. __ PopReturnAddressTo(rcx); SmiIndex index = masm->SmiToIndex(rbx, rbx, kSystemPointerSizeLog2); __ leaq(rsp, Operand(rsp, index.reg, index.scale, 1 * kSystemPointerSize)); __ PushReturnAddressFrom(rcx); __ ret(0); __ bind(&stack_overflow); { FrameScope scope(masm, StackFrame::INTERNAL); __ CallRuntime(Runtime::kThrowStackOverflow); __ int3(); // This should be unreachable. } } } // namespace // The construct stub for ES5 constructor functions and ES6 class constructors. void Builtins::Generate_JSConstructStubGeneric(MacroAssembler* masm) { // ----------- S t a t e ------------- // -- rax: number of arguments (untagged) // -- rdi: constructor function // -- rdx: new target // -- rsi: context // -- sp[...]: constructor arguments // ----------------------------------- // Enter a construct frame. { FrameScope scope(masm, StackFrame::CONSTRUCT); Label post_instantiation_deopt_entry, not_create_implicit_receiver; // Preserve the incoming parameters on the stack. __ SmiTag(rcx, rax); __ Push(rsi); __ Push(rcx); __ Push(rdi); __ PushRoot(RootIndex::kTheHoleValue); __ Push(rdx); // ----------- S t a t e ------------- // -- sp[0*kSystemPointerSize]: new target // -- sp[1*kSystemPointerSize]: padding // -- rdi and sp[2*kSystemPointerSize]: constructor function // -- sp[3*kSystemPointerSize]: argument count // -- sp[4*kSystemPointerSize]: context // ----------------------------------- __ LoadTaggedPointerField( rbx, FieldOperand(rdi, JSFunction::kSharedFunctionInfoOffset)); __ movl(rbx, FieldOperand(rbx, SharedFunctionInfo::kFlagsOffset)); __ DecodeField<SharedFunctionInfo::FunctionKindBits>(rbx); __ JumpIfIsInRange(rbx, kDefaultDerivedConstructor, kDerivedConstructor, ¬_create_implicit_receiver, Label::kNear); // If not derived class constructor: Allocate the new receiver object. __ IncrementCounter(masm->isolate()->counters()->constructed_objects(), 1); __ Call(BUILTIN_CODE(masm->isolate(), FastNewObject), RelocInfo::CODE_TARGET); __ jmp(&post_instantiation_deopt_entry, Label::kNear); // Else: use TheHoleValue as receiver for constructor call __ bind(¬_create_implicit_receiver); __ LoadRoot(rax, RootIndex::kTheHoleValue); // ----------- S t a t e ------------- // -- rax implicit receiver // -- Slot 4 / sp[0*kSystemPointerSize] new target // -- Slot 3 / sp[1*kSystemPointerSize] padding // -- Slot 2 / sp[2*kSystemPointerSize] constructor function // -- Slot 1 / sp[3*kSystemPointerSize] number of arguments (tagged) // -- Slot 0 / sp[4*kSystemPointerSize] context // ----------------------------------- // Deoptimizer enters here. masm->isolate()->heap()->SetConstructStubCreateDeoptPCOffset( masm->pc_offset()); __ bind(&post_instantiation_deopt_entry); // Restore new target. __ Pop(rdx); // Push the allocated receiver to the stack. We need two copies // because we may have to return the original one and the calling // conventions dictate that the called function pops the receiver. __ Push(rax); __ Push(rax); // ----------- S t a t e ------------- // -- sp[0*kSystemPointerSize] implicit receiver // -- sp[1*kSystemPointerSize] implicit receiver // -- sp[2*kSystemPointerSize] padding // -- sp[3*kSystemPointerSize] constructor function // -- sp[4*kSystemPointerSize] number of arguments (tagged) // -- sp[5*kSystemPointerSize] context // ----------------------------------- // Restore constructor function and argument count. __ movq(rdi, Operand(rbp, ConstructFrameConstants::kConstructorOffset)); __ SmiUntag(rax, Operand(rbp, ConstructFrameConstants::kLengthOffset)); // Set up pointer to last argument. __ leaq(rbx, Operand(rbp, StandardFrameConstants::kCallerSPOffset)); // Check if we have enough stack space to push all arguments. // Argument count in rax. Clobbers rcx. Label enough_stack_space, stack_overflow; Generate_StackOverflowCheck(masm, rax, rcx, &stack_overflow, Label::kNear); __ jmp(&enough_stack_space, Label::kNear); __ bind(&stack_overflow); // Restore context from the frame. __ movq(rsi, Operand(rbp, ConstructFrameConstants::kContextOffset)); __ CallRuntime(Runtime::kThrowStackOverflow); // This should be unreachable. __ int3(); __ bind(&enough_stack_space); // Copy arguments and receiver to the expression stack. Label loop, entry; __ movq(rcx, rax); // ----------- S t a t e ------------- // -- rax: number of arguments (untagged) // -- rdx: new target // -- rbx: pointer to last argument // -- rcx: counter (tagged) // -- sp[0*kSystemPointerSize]: implicit receiver // -- sp[1*kSystemPointerSize]: implicit receiver // -- sp[2*kSystemPointerSize]: padding // -- rdi and sp[3*kSystemPointerSize]: constructor function // -- sp[4*kSystemPointerSize]: number of arguments (tagged) // -- sp[5*kSystemPointerSize]: context // ----------------------------------- __ jmp(&entry, Label::kNear); __ bind(&loop); __ Push(Operand(rbx, rcx, times_system_pointer_size, 0)); __ bind(&entry); __ decq(rcx); __ j(greater_equal, &loop, Label::kNear); // Call the function. ParameterCount actual(rax); __ InvokeFunction(rdi, rdx, actual, CALL_FUNCTION); // ----------- S t a t e ------------- // -- rax constructor result // -- sp[0*kSystemPointerSize] implicit receiver // -- sp[1*kSystemPointerSize] padding // -- sp[2*kSystemPointerSize] constructor function // -- sp[3*kSystemPointerSize] number of arguments // -- sp[4*kSystemPointerSize] context // ----------------------------------- // Store offset of return address for deoptimizer. masm->isolate()->heap()->SetConstructStubInvokeDeoptPCOffset( masm->pc_offset()); // Restore context from the frame. __ movq(rsi, Operand(rbp, ConstructFrameConstants::kContextOffset)); // If the result is an object (in the ECMA sense), we should get rid // of the receiver and use the result; see ECMA-262 section 13.2.2-7 // on page 74. Label use_receiver, do_throw, leave_frame; // If the result is undefined, we jump out to using the implicit receiver. __ JumpIfRoot(rax, RootIndex::kUndefinedValue, &use_receiver, Label::kNear); // Otherwise we do a smi check and fall through to check if the return value // is a valid receiver. // If the result is a smi, it is *not* an object in the ECMA sense. __ JumpIfSmi(rax, &use_receiver, Label::kNear); // If the type of the result (stored in its map) is less than // FIRST_JS_RECEIVER_TYPE, it is not an object in the ECMA sense. STATIC_ASSERT(LAST_JS_RECEIVER_TYPE == LAST_TYPE); __ CmpObjectType(rax, FIRST_JS_RECEIVER_TYPE, rcx); __ j(above_equal, &leave_frame, Label::kNear); __ jmp(&use_receiver, Label::kNear); __ bind(&do_throw); __ CallRuntime(Runtime::kThrowConstructorReturnedNonObject); // Throw away the result of the constructor invocation and use the // on-stack receiver as the result. __ bind(&use_receiver); __ movq(rax, Operand(rsp, 0 * kSystemPointerSize)); __ JumpIfRoot(rax, RootIndex::kTheHoleValue, &do_throw, Label::kNear); __ bind(&leave_frame); // Restore the arguments count. __ movq(rbx, Operand(rbp, ConstructFrameConstants::kLengthOffset)); // Leave construct frame. } // Remove caller arguments from the stack and return. __ PopReturnAddressTo(rcx); SmiIndex index = masm->SmiToIndex(rbx, rbx, kSystemPointerSizeLog2); __ leaq(rsp, Operand(rsp, index.reg, index.scale, 1 * kSystemPointerSize)); __ PushReturnAddressFrom(rcx); __ ret(0); } void Builtins::Generate_JSBuiltinsConstructStub(MacroAssembler* masm) { Generate_JSBuiltinsConstructStubHelper(masm); } void Builtins::Generate_ConstructedNonConstructable(MacroAssembler* masm) { FrameScope scope(masm, StackFrame::INTERNAL); __ Push(rdi); __ CallRuntime(Runtime::kThrowConstructedNonConstructable); } namespace { // Called with the native C calling convention. The corresponding function // signature is either: // using JSEntryFunction = GeneratedCode<Address( // Address root_register_value, Address new_target, Address target, // Address receiver, intptr_t argc, Address** argv)>; // or // using JSEntryFunction = GeneratedCode<Address( // Address root_register_value, MicrotaskQueue* microtask_queue)>; void Generate_JSEntryVariant(MacroAssembler* masm, StackFrame::Type type, Builtins::Name entry_trampoline) { Label invoke, handler_entry, exit; Label not_outermost_js, not_outermost_js_2; { // NOLINT. Scope block confuses linter. NoRootArrayScope uninitialized_root_register(masm); // Set up frame. __ pushq(rbp); __ movq(rbp, rsp); // Push the stack frame type. __ Push(Immediate(StackFrame::TypeToMarker(type))); // Reserve a slot for the context. It is filled after the root register has // been set up. __ AllocateStackSpace(kSystemPointerSize); // Save callee-saved registers (X64/X32/Win64 calling conventions). __ pushq(r12); __ pushq(r13); __ pushq(r14); __ pushq(r15); #ifdef _WIN64 __ pushq(rdi); // Only callee save in Win64 ABI, argument in AMD64 ABI. __ pushq(rsi); // Only callee save in Win64 ABI, argument in AMD64 ABI. #endif __ pushq(rbx); #ifdef _WIN64 // On Win64 XMM6-XMM15 are callee-save. __ AllocateStackSpace(EntryFrameConstants::kXMMRegistersBlockSize); __ movdqu(Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 0), xmm6); __ movdqu(Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 1), xmm7); __ movdqu(Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 2), xmm8); __ movdqu(Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 3), xmm9); __ movdqu(Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 4), xmm10); __ movdqu(Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 5), xmm11); __ movdqu(Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 6), xmm12); __ movdqu(Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 7), xmm13); __ movdqu(Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 8), xmm14); __ movdqu(Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 9), xmm15); STATIC_ASSERT(EntryFrameConstants::kCalleeSaveXMMRegisters == 10); STATIC_ASSERT(EntryFrameConstants::kXMMRegistersBlockSize == EntryFrameConstants::kXMMRegisterSize * EntryFrameConstants::kCalleeSaveXMMRegisters); #endif // Initialize the root register. // C calling convention. The first argument is passed in arg_reg_1. __ movq(kRootRegister, arg_reg_1); } // Save copies of the top frame descriptor on the stack. ExternalReference c_entry_fp = ExternalReference::Create( IsolateAddressId::kCEntryFPAddress, masm->isolate()); { Operand c_entry_fp_operand = masm->ExternalReferenceAsOperand(c_entry_fp); __ Push(c_entry_fp_operand); } // Store the context address in the previously-reserved slot. ExternalReference context_address = ExternalReference::Create( IsolateAddressId::kContextAddress, masm->isolate()); __ Load(kScratchRegister, context_address); static constexpr int kOffsetToContextSlot = -2 * kSystemPointerSize; __ movq(Operand(rbp, kOffsetToContextSlot), kScratchRegister); // If this is the outermost JS call, set js_entry_sp value. ExternalReference js_entry_sp = ExternalReference::Create( IsolateAddressId::kJSEntrySPAddress, masm->isolate()); __ Load(rax, js_entry_sp); __ testq(rax, rax); __ j(not_zero, ¬_outermost_js); __ Push(Immediate(StackFrame::OUTERMOST_JSENTRY_FRAME)); __ movq(rax, rbp); __ Store(js_entry_sp, rax); Label cont; __ jmp(&cont); __ bind(¬_outermost_js); __ Push(Immediate(StackFrame::INNER_JSENTRY_FRAME)); __ bind(&cont); // 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); // Store the current pc as the handler offset. It's used later to create the // handler table. masm->isolate()->builtins()->SetJSEntryHandlerOffset(handler_entry.pos()); // Caught exception: Store result (exception) in the pending exception // field in the JSEnv and return a failure sentinel. ExternalReference pending_exception = ExternalReference::Create( IsolateAddressId::kPendingExceptionAddress, masm->isolate()); __ Store(pending_exception, rax); __ LoadRoot(rax, RootIndex::kException); __ jmp(&exit); // Invoke: Link this frame into the handler chain. __ bind(&invoke); __ PushStackHandler(); // Invoke the function by calling through JS entry trampoline builtin and // pop the faked function when we return. Handle<Code> trampoline_code = masm->isolate()->builtins()->builtin_handle(entry_trampoline); __ Call(trampoline_code, RelocInfo::CODE_TARGET); // Unlink this frame from the handler chain. __ PopStackHandler(); __ bind(&exit); // Check if the current stack frame is marked as the outermost JS frame. __ Pop(rbx); __ cmpq(rbx, Immediate(StackFrame::OUTERMOST_JSENTRY_FRAME)); __ j(not_equal, ¬_outermost_js_2); __ Move(kScratchRegister, js_entry_sp); __ movq(Operand(kScratchRegister, 0), Immediate(0)); __ bind(¬_outermost_js_2); // Restore the top frame descriptor from the stack. { Operand c_entry_fp_operand = masm->ExternalReferenceAsOperand(c_entry_fp); __ Pop(c_entry_fp_operand); } // Restore callee-saved registers (X64 conventions). #ifdef _WIN64 // On Win64 XMM6-XMM15 are callee-save __ movdqu(xmm6, Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 0)); __ movdqu(xmm7, Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 1)); __ movdqu(xmm8, Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 2)); __ movdqu(xmm9, Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 3)); __ movdqu(xmm10, Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 4)); __ movdqu(xmm11, Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 5)); __ movdqu(xmm12, Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 6)); __ movdqu(xmm13, Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 7)); __ movdqu(xmm14, Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 8)); __ movdqu(xmm15, Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 9)); __ addq(rsp, Immediate(EntryFrameConstants::kXMMRegistersBlockSize)); #endif __ popq(rbx); #ifdef _WIN64 // Callee save on in Win64 ABI, arguments/volatile in AMD64 ABI. __ popq(rsi); __ popq(rdi); #endif __ popq(r15); __ popq(r14); __ popq(r13); __ popq(r12); __ addq(rsp, Immediate(2 * kSystemPointerSize)); // remove markers // Restore frame pointer and return. __ popq(rbp); __ ret(0); } } // namespace void Builtins::Generate_JSEntry(MacroAssembler* masm) { Generate_JSEntryVariant(masm, StackFrame::ENTRY, Builtins::kJSEntryTrampoline); } void Builtins::Generate_JSConstructEntry(MacroAssembler* masm) { Generate_JSEntryVariant(masm, StackFrame::CONSTRUCT_ENTRY, Builtins::kJSConstructEntryTrampoline); } void Builtins::Generate_JSRunMicrotasksEntry(MacroAssembler* masm) { Generate_JSEntryVariant(masm, StackFrame::ENTRY, Builtins::kRunMicrotasksTrampoline); } static void Generate_JSEntryTrampolineHelper(MacroAssembler* masm, bool is_construct) { // Expects six C++ function parameters. // - Address root_register_value // - Address new_target (tagged Object pointer) // - Address function (tagged JSFunction pointer) // - Address receiver (tagged Object pointer) // - intptr_t argc // - Address** argv (pointer to array of tagged Object pointers) // (see Handle::Invoke in execution.cc). // Open a C++ scope for the FrameScope. { // Platform specific argument handling. After this, the stack contains // an internal frame and the pushed function and receiver, and // register rax and rbx holds the argument count and argument array, // while rdi holds the function pointer, rsi the context, and rdx the // new.target. // MSVC parameters in: // rcx : root_register_value // rdx : new_target // r8 : function // r9 : receiver // [rsp+0x20] : argc // [rsp+0x28] : argv // // GCC parameters in: // rdi : root_register_value // rsi : new_target // rdx : function // rcx : receiver // r8 : argc // r9 : argv __ movq(rdi, arg_reg_3); __ Move(rdx, arg_reg_2); // rdi : function // rdx : new_target // Clear the context before we push it when entering the internal frame. __ Set(rsi, 0); // Enter an internal frame. FrameScope scope(masm, StackFrame::INTERNAL); // Setup the context (we need to use the caller context from the isolate). ExternalReference context_address = ExternalReference::Create( IsolateAddressId::kContextAddress, masm->isolate()); __ movq(rsi, masm->ExternalReferenceAsOperand(context_address)); // Push the function and the receiver onto the stack. __ Push(rdi); __ Push(arg_reg_4); #ifdef _WIN64 // Load the previous frame pointer to access C arguments on stack __ movq(kScratchRegister, Operand(rbp, 0)); // Load the number of arguments and setup pointer to the arguments. __ movq(rax, Operand(kScratchRegister, EntryFrameConstants::kArgcOffset)); __ movq(rbx, Operand(kScratchRegister, EntryFrameConstants::kArgvOffset)); #else // _WIN64 // Load the number of arguments and setup pointer to the arguments. __ movq(rax, r8); __ movq(rbx, r9); #endif // _WIN64 // Current stack contents: // [rsp + 2 * kSystemPointerSize ... ] : Internal frame // [rsp + kSystemPointerSize] : function // [rsp] : receiver // Current register contents: // rax : argc // rbx : argv // rsi : context // rdi : function // rdx : new.target // Check if we have enough stack space to push all arguments. // Argument count in rax. Clobbers rcx. Label enough_stack_space, stack_overflow; Generate_StackOverflowCheck(masm, rax, rcx, &stack_overflow, Label::kNear); __ jmp(&enough_stack_space, Label::kNear); __ bind(&stack_overflow); __ CallRuntime(Runtime::kThrowStackOverflow); // This should be unreachable. __ int3(); __ bind(&enough_stack_space); // Copy arguments to the stack in a loop. // Register rbx points to array of pointers to handle locations. // Push the values of these handles. Label loop, entry; __ Set(rcx, 0); // Set loop variable to 0. __ jmp(&entry, Label::kNear); __ bind(&loop); __ movq(kScratchRegister, Operand(rbx, rcx, times_system_pointer_size, 0)); __ Push(Operand(kScratchRegister, 0)); // dereference handle __ addq(rcx, Immediate(1)); __ bind(&entry); __ cmpq(rcx, rax); __ j(not_equal, &loop, Label::kNear); // Invoke the builtin code. Handle<Code> builtin = is_construct ? BUILTIN_CODE(masm->isolate(), Construct) : masm->isolate()->builtins()->Call(); __ Call(builtin, RelocInfo::CODE_TARGET); // Exit the internal frame. Notice that this also removes the empty // context and the function left on the stack by the code // invocation. } __ ret(0); } void Builtins::Generate_JSEntryTrampoline(MacroAssembler* masm) { Generate_JSEntryTrampolineHelper(masm, false); } void Builtins::Generate_JSConstructEntryTrampoline(MacroAssembler* masm) { Generate_JSEntryTrampolineHelper(masm, true); } void Builtins::Generate_RunMicrotasksTrampoline(MacroAssembler* masm) { // arg_reg_2: microtask_queue __ movq(RunMicrotasksDescriptor::MicrotaskQueueRegister(), arg_reg_2); __ Jump(BUILTIN_CODE(masm->isolate(), RunMicrotasks), RelocInfo::CODE_TARGET); } static void GetSharedFunctionInfoBytecode(MacroAssembler* masm, Register sfi_data, Register scratch1) { Label done; __ CmpObjectType(sfi_data, INTERPRETER_DATA_TYPE, scratch1); __ j(not_equal, &done, Label::kNear); __ LoadTaggedPointerField( sfi_data, FieldOperand(sfi_data, InterpreterData::kBytecodeArrayOffset)); __ bind(&done); } // static void Builtins::Generate_ResumeGeneratorTrampoline(MacroAssembler* masm) { // ----------- S t a t e ------------- // -- rax : the value to pass to the generator // -- rdx : the JSGeneratorObject to resume // -- rsp[0] : return address // ----------------------------------- __ AssertGeneratorObject(rdx); // Store input value into generator object. __ StoreTaggedField( FieldOperand(rdx, JSGeneratorObject::kInputOrDebugPosOffset), rax); __ RecordWriteField(rdx, JSGeneratorObject::kInputOrDebugPosOffset, rax, rcx, kDontSaveFPRegs); Register decompr_scratch1 = COMPRESS_POINTERS_BOOL ? r11 : no_reg; Register decompr_scratch2 = COMPRESS_POINTERS_BOOL ? r12 : no_reg; // Load suspended function and context. __ LoadTaggedPointerField( rdi, FieldOperand(rdx, JSGeneratorObject::kFunctionOffset)); __ LoadTaggedPointerField(rsi, FieldOperand(rdi, JSFunction::kContextOffset)); // Flood function if we are stepping. Label prepare_step_in_if_stepping, prepare_step_in_suspended_generator; Label stepping_prepared; ExternalReference debug_hook = ExternalReference::debug_hook_on_function_call_address(masm->isolate()); Operand debug_hook_operand = masm->ExternalReferenceAsOperand(debug_hook); __ cmpb(debug_hook_operand, Immediate(0)); __ j(not_equal, &prepare_step_in_if_stepping); // Flood function if we need to continue stepping in the suspended generator. ExternalReference debug_suspended_generator = ExternalReference::debug_suspended_generator_address(masm->isolate()); Operand debug_suspended_generator_operand = masm->ExternalReferenceAsOperand(debug_suspended_generator); __ cmpq(rdx, debug_suspended_generator_operand); __ j(equal, &prepare_step_in_suspended_generator); __ bind(&stepping_prepared); // Check the stack for overflow. We are not trying to catch interruptions // (i.e. debug break and preemption) here, so check the "real stack limit". Label stack_overflow; __ cmpq(rsp, RealStackLimitAsOperand(masm)); __ j(below, &stack_overflow); // Pop return address. __ PopReturnAddressTo(rax); // Push receiver. __ PushTaggedPointerField( FieldOperand(rdx, JSGeneratorObject::kReceiverOffset), decompr_scratch1); // ----------- S t a t e ------------- // -- rax : return address // -- rdx : the JSGeneratorObject to resume // -- rdi : generator function // -- rsi : generator context // -- rsp[0] : generator receiver // ----------------------------------- // Copy the function arguments from the generator object's register file. __ LoadTaggedPointerField( rcx, FieldOperand(rdi, JSFunction::kSharedFunctionInfoOffset)); __ movzxwq( rcx, FieldOperand(rcx, SharedFunctionInfo::kFormalParameterCountOffset)); __ LoadTaggedPointerField( rbx, FieldOperand(rdx, JSGeneratorObject::kParametersAndRegistersOffset)); { Label done_loop, loop; __ Set(r9, 0); __ bind(&loop); __ cmpl(r9, rcx); __ j(greater_equal, &done_loop, Label::kNear); __ PushTaggedAnyField( FieldOperand(rbx, r9, times_tagged_size, FixedArray::kHeaderSize), decompr_scratch1, decompr_scratch2); __ addl(r9, Immediate(1)); __ jmp(&loop); __ bind(&done_loop); } // Underlying function needs to have bytecode available. if (FLAG_debug_code) { __ LoadTaggedPointerField( rcx, FieldOperand(rdi, JSFunction::kSharedFunctionInfoOffset)); __ LoadTaggedPointerField( rcx, FieldOperand(rcx, SharedFunctionInfo::kFunctionDataOffset)); GetSharedFunctionInfoBytecode(masm, rcx, kScratchRegister); __ CmpObjectType(rcx, BYTECODE_ARRAY_TYPE, rcx); __ Assert(equal, AbortReason::kMissingBytecodeArray); } // Resume (Ignition/TurboFan) generator object. { __ PushReturnAddressFrom(rax); __ LoadTaggedPointerField( rax, FieldOperand(rdi, JSFunction::kSharedFunctionInfoOffset)); __ movzxwq(rax, FieldOperand( rax, SharedFunctionInfo::kFormalParameterCountOffset)); // We abuse new.target both to indicate that this is a resume call and to // pass in the generator object. In ordinary calls, new.target is always // undefined because generator functions are non-constructable. static_assert(kJavaScriptCallCodeStartRegister == rcx, "ABI mismatch"); __ LoadTaggedPointerField(rcx, FieldOperand(rdi, JSFunction::kCodeOffset)); __ JumpCodeObject(rcx); } __ bind(&prepare_step_in_if_stepping); { FrameScope scope(masm, StackFrame::INTERNAL); __ Push(rdx); __ Push(rdi); // Push hole as receiver since we do not use it for stepping. __ PushRoot(RootIndex::kTheHoleValue); __ CallRuntime(Runtime::kDebugOnFunctionCall); __ Pop(rdx); __ LoadTaggedPointerField( rdi, FieldOperand(rdx, JSGeneratorObject::kFunctionOffset)); } __ jmp(&stepping_prepared); __ bind(&prepare_step_in_suspended_generator); { FrameScope scope(masm, StackFrame::INTERNAL); __ Push(rdx); __ CallRuntime(Runtime::kDebugPrepareStepInSuspendedGenerator); __ Pop(rdx); __ LoadTaggedPointerField( rdi, FieldOperand(rdx, JSGeneratorObject::kFunctionOffset)); } __ jmp(&stepping_prepared); __ bind(&stack_overflow); { FrameScope scope(masm, StackFrame::INTERNAL); __ CallRuntime(Runtime::kThrowStackOverflow); __ int3(); // This should be unreachable. } } // TODO(juliana): if we remove the code below then we don't need all // the parameters. static void ReplaceClosureCodeWithOptimizedCode( MacroAssembler* masm, Register optimized_code, Register closure, Register scratch1, Register scratch2, Register scratch3) { // Store the optimized code in the closure. __ StoreTaggedField(FieldOperand(closure, JSFunction::kCodeOffset), optimized_code); __ movq(scratch1, optimized_code); // Write barrier clobbers scratch1 below. __ RecordWriteField(closure, JSFunction::kCodeOffset, scratch1, scratch2, kDontSaveFPRegs, OMIT_REMEMBERED_SET, OMIT_SMI_CHECK); } static void LeaveInterpreterFrame(MacroAssembler* masm, Register scratch1, Register scratch2) { Register args_count = scratch1; Register return_pc = scratch2; // Get the arguments + receiver count. __ movq(args_count, Operand(rbp, InterpreterFrameConstants::kBytecodeArrayFromFp)); __ movl(args_count, FieldOperand(args_count, BytecodeArray::kParameterSizeOffset)); // Leave the frame (also dropping the register file). __ leave(); // Drop receiver + arguments. __ PopReturnAddressTo(return_pc); __ addq(rsp, args_count); __ PushReturnAddressFrom(return_pc); } // Tail-call |function_id| if |smi_entry| == |marker| static void TailCallRuntimeIfMarkerEquals(MacroAssembler* masm, Register smi_entry, OptimizationMarker marker, Runtime::FunctionId function_id) { Label no_match; __ SmiCompare(smi_entry, Smi::FromEnum(marker)); __ j(not_equal, &no_match); GenerateTailCallToReturnedCode(masm, function_id); __ bind(&no_match); } static void MaybeTailCallOptimizedCodeSlot(MacroAssembler* masm, Register feedback_vector, Register scratch1, Register scratch2, Register scratch3) { // ----------- S t a t e ------------- // -- rdx : new target (preserved for callee if needed, and caller) // -- rdi : target function (preserved for callee if needed, and caller) // -- feedback vector (preserved for caller if needed) // ----------------------------------- DCHECK(!AreAliased(feedback_vector, rdx, rdi, scratch1, scratch2, scratch3)); Label optimized_code_slot_is_weak_ref, fallthrough; Register closure = rdi; Register optimized_code_entry = scratch1; Register decompr_scratch = COMPRESS_POINTERS_BOOL ? scratch2 : no_reg; __ LoadAnyTaggedField( optimized_code_entry, FieldOperand(feedback_vector, FeedbackVector::kOptimizedCodeWeakOrSmiOffset), decompr_scratch); // Check if the code entry is a Smi. If yes, we interpret it as an // optimisation marker. Otherwise, interpret it as a weak reference to a code // object. __ JumpIfNotSmi(optimized_code_entry, &optimized_code_slot_is_weak_ref); { // Optimized code slot is a Smi optimization marker. // Fall through if no optimization trigger. __ SmiCompare(optimized_code_entry, Smi::FromEnum(OptimizationMarker::kNone)); __ j(equal, &fallthrough); // TODO(v8:8394): The logging of first execution will break if // feedback vectors are not allocated. We need to find a different way of // logging these events if required. TailCallRuntimeIfMarkerEquals(masm, optimized_code_entry, OptimizationMarker::kLogFirstExecution, Runtime::kFunctionFirstExecution); TailCallRuntimeIfMarkerEquals(masm, optimized_code_entry, OptimizationMarker::kCompileOptimized, Runtime::kCompileOptimized_NotConcurrent); TailCallRuntimeIfMarkerEquals( masm, optimized_code_entry, OptimizationMarker::kCompileOptimizedConcurrent, Runtime::kCompileOptimized_Concurrent); { // Otherwise, the marker is InOptimizationQueue, so fall through hoping // that an interrupt will eventually update the slot with optimized code. if (FLAG_debug_code) { __ SmiCompare(optimized_code_entry, Smi::FromEnum(OptimizationMarker::kInOptimizationQueue)); __ Assert(equal, AbortReason::kExpectedOptimizationSentinel); } __ jmp(&fallthrough); } } { // Optimized code slot is a weak reference. __ bind(&optimized_code_slot_is_weak_ref); __ LoadWeakValue(optimized_code_entry, &fallthrough); // Check if the optimized code is marked for deopt. If it is, call the // runtime to clear it. Label found_deoptimized_code; __ LoadTaggedPointerField( scratch2, FieldOperand(optimized_code_entry, Code::kCodeDataContainerOffset)); __ testl( FieldOperand(scratch2, CodeDataContainer::kKindSpecificFlagsOffset), Immediate(1 << Code::kMarkedForDeoptimizationBit)); __ j(not_zero, &found_deoptimized_code); // Optimized code is good, get it into the closure and link the closure into // the optimized functions list, then tail call the optimized code. // The feedback vector is no longer used, so re-use it as a scratch // register. ReplaceClosureCodeWithOptimizedCode(masm, optimized_code_entry, closure, scratch2, scratch3, feedback_vector); static_assert(kJavaScriptCallCodeStartRegister == rcx, "ABI mismatch"); __ Move(rcx, optimized_code_entry); __ JumpCodeObject(rcx); // Optimized code slot contains deoptimized code, evict it and re-enter the // closure's code. __ bind(&found_deoptimized_code); GenerateTailCallToReturnedCode(masm, Runtime::kEvictOptimizedCodeSlot); } // Fall-through if the optimized code cell is clear and there is no // optimization marker. __ bind(&fallthrough); } // Advance the current bytecode offset. This simulates what all bytecode // handlers do upon completion of the underlying operation. Will bail out to a // label if the bytecode (without prefix) is a return bytecode. static void AdvanceBytecodeOffsetOrReturn(MacroAssembler* masm, Register bytecode_array, Register bytecode_offset, Register bytecode, Register scratch1, Label* if_return) { Register bytecode_size_table = scratch1; DCHECK(!AreAliased(bytecode_array, bytecode_offset, bytecode_size_table, bytecode)); __ Move(bytecode_size_table, ExternalReference::bytecode_size_table_address()); // Check if the bytecode is a Wide or ExtraWide prefix bytecode. Label process_bytecode, extra_wide; STATIC_ASSERT(0 == static_cast<int>(interpreter::Bytecode::kWide)); STATIC_ASSERT(1 == static_cast<int>(interpreter::Bytecode::kExtraWide)); STATIC_ASSERT(2 == static_cast<int>(interpreter::Bytecode::kDebugBreakWide)); STATIC_ASSERT(3 == static_cast<int>(interpreter::Bytecode::kDebugBreakExtraWide)); __ cmpb(bytecode, Immediate(0x3)); __ j(above, &process_bytecode, Label::kNear); __ testb(bytecode, Immediate(0x1)); __ j(not_equal, &extra_wide, Label::kNear); // Load the next bytecode and update table to the wide scaled table. __ incl(bytecode_offset); __ movzxbq(bytecode, Operand(bytecode_array, bytecode_offset, times_1, 0)); __ addq(bytecode_size_table, Immediate(kIntSize * interpreter::Bytecodes::kBytecodeCount)); __ jmp(&process_bytecode, Label::kNear); __ bind(&extra_wide); // Load the next bytecode and update table to the extra wide scaled table. __ incl(bytecode_offset); __ movzxbq(bytecode, Operand(bytecode_array, bytecode_offset, times_1, 0)); __ addq(bytecode_size_table, Immediate(2 * kIntSize * interpreter::Bytecodes::kBytecodeCount)); __ bind(&process_bytecode); // Bailout to the return label if this is a return bytecode. #define JUMP_IF_EQUAL(NAME) \ __ cmpb(bytecode, \ Immediate(static_cast<int>(interpreter::Bytecode::k##NAME))); \ __ j(equal, if_return, Label::kFar); RETURN_BYTECODE_LIST(JUMP_IF_EQUAL) #undef JUMP_IF_EQUAL // Otherwise, load the size of the current bytecode and advance the offset. __ addl(bytecode_offset, Operand(bytecode_size_table, bytecode, times_int_size, 0)); } // Generate code for entering a JS function with the interpreter. // On entry to the function the receiver and arguments have been pushed on the // stack left to right. The actual argument count matches the formal parameter // count expected by the function. // // The live registers are: // o rdi: the JS function object being called // o rdx: the incoming new target or generator object // o rsi: our context // o rbp: the caller's frame pointer // o rsp: stack pointer (pointing to return address) // // The function builds an interpreter frame. See InterpreterFrameConstants in // frames.h for its layout. void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) { Register closure = rdi; Register feedback_vector = rbx; // Get the bytecode array from the function object and load it into // kInterpreterBytecodeArrayRegister. __ LoadTaggedPointerField( rax, FieldOperand(closure, JSFunction::kSharedFunctionInfoOffset)); __ LoadTaggedPointerField( kInterpreterBytecodeArrayRegister, FieldOperand(rax, SharedFunctionInfo::kFunctionDataOffset)); GetSharedFunctionInfoBytecode(masm, kInterpreterBytecodeArrayRegister, kScratchRegister); // The bytecode array could have been flushed from the shared function info, // if so, call into CompileLazy. Label compile_lazy; __ CmpObjectType(kInterpreterBytecodeArrayRegister, BYTECODE_ARRAY_TYPE, rax); __ j(not_equal, &compile_lazy); // Load the feedback vector from the closure. __ LoadTaggedPointerField( feedback_vector, FieldOperand(closure, JSFunction::kFeedbackCellOffset)); __ LoadTaggedPointerField(feedback_vector, FieldOperand(feedback_vector, Cell::kValueOffset)); Label push_stack_frame; // Check if feedback vector is valid. If valid, check for optimized code // and update invocation count. Otherwise, setup the stack frame. __ LoadTaggedPointerField( rcx, FieldOperand(feedback_vector, HeapObject::kMapOffset)); __ CmpInstanceType(rcx, FEEDBACK_VECTOR_TYPE); __ j(not_equal, &push_stack_frame); // Read off the optimized code slot in the feedback vector, and if there // is optimized code or an optimization marker, call that instead. MaybeTailCallOptimizedCodeSlot(masm, feedback_vector, rcx, r11, r15); // Increment invocation count for the function. __ incl( FieldOperand(feedback_vector, FeedbackVector::kInvocationCountOffset)); // Open a frame scope to indicate that there is a frame on the stack. The // MANUAL indicates that the scope shouldn't actually generate code to set up // the frame (that is done below). __ bind(&push_stack_frame); FrameScope frame_scope(masm, StackFrame::MANUAL); __ pushq(rbp); // Caller's frame pointer. __ movq(rbp, rsp); __ Push(rsi); // Callee's context. __ Push(rdi); // Callee's JS function. // Reset code age and the OSR arming. The OSR field and BytecodeAgeOffset are // 8-bit fields next to each other, so we could just optimize by writing a // 16-bit. These static asserts guard our assumption is valid. STATIC_ASSERT(BytecodeArray::kBytecodeAgeOffset == BytecodeArray::kOsrNestingLevelOffset + kCharSize); STATIC_ASSERT(BytecodeArray::kNoAgeBytecodeAge == 0); __ movw(FieldOperand(kInterpreterBytecodeArrayRegister, BytecodeArray::kOsrNestingLevelOffset), Immediate(0)); // Load initial bytecode offset. __ movq(kInterpreterBytecodeOffsetRegister, Immediate(BytecodeArray::kHeaderSize - kHeapObjectTag)); // Push bytecode array and Smi tagged bytecode offset. __ Push(kInterpreterBytecodeArrayRegister); __ SmiTag(rcx, kInterpreterBytecodeOffsetRegister); __ Push(rcx); // Allocate the local and temporary register file on the stack. { // Load frame size from the BytecodeArray object. __ movl(rcx, FieldOperand(kInterpreterBytecodeArrayRegister, BytecodeArray::kFrameSizeOffset)); // Do a stack check to ensure we don't go over the limit. Label ok; __ movq(rax, rsp); __ subq(rax, rcx); __ cmpq(rax, RealStackLimitAsOperand(masm)); __ j(above_equal, &ok, Label::kNear); __ CallRuntime(Runtime::kThrowStackOverflow); __ bind(&ok); // If ok, push undefined as the initial value for all register file entries. Label loop_header; Label loop_check; __ LoadRoot(rax, RootIndex::kUndefinedValue); __ j(always, &loop_check, Label::kNear); __ bind(&loop_header); // TODO(rmcilroy): Consider doing more than one push per loop iteration. __ Push(rax); // Continue loop if not done. __ bind(&loop_check); __ subq(rcx, Immediate(kSystemPointerSize)); __ j(greater_equal, &loop_header, Label::kNear); } // If the bytecode array has a valid incoming new target or generator object // register, initialize it with incoming value which was passed in rdx. Label no_incoming_new_target_or_generator_register; __ movsxlq( rax, FieldOperand(kInterpreterBytecodeArrayRegister, BytecodeArray::kIncomingNewTargetOrGeneratorRegisterOffset)); __ testl(rax, rax); __ j(zero, &no_incoming_new_target_or_generator_register, Label::kNear); __ movq(Operand(rbp, rax, times_system_pointer_size, 0), rdx); __ bind(&no_incoming_new_target_or_generator_register); // Load accumulator with undefined. __ LoadRoot(kInterpreterAccumulatorRegister, RootIndex::kUndefinedValue); // Load the dispatch table into a register and dispatch to the bytecode // handler at the current bytecode offset. Label do_dispatch; __ bind(&do_dispatch); __ Move( kInterpreterDispatchTableRegister, ExternalReference::interpreter_dispatch_table_address(masm->isolate())); __ movzxbq(r11, Operand(kInterpreterBytecodeArrayRegister, kInterpreterBytecodeOffsetRegister, times_1, 0)); __ movq(kJavaScriptCallCodeStartRegister, Operand(kInterpreterDispatchTableRegister, r11, times_system_pointer_size, 0)); __ call(kJavaScriptCallCodeStartRegister); masm->isolate()->heap()->SetInterpreterEntryReturnPCOffset(masm->pc_offset()); // Any returns to the entry trampoline are either due to the return bytecode // or the interpreter tail calling a builtin and then a dispatch. // Get bytecode array and bytecode offset from the stack frame. __ movq(kInterpreterBytecodeArrayRegister, Operand(rbp, InterpreterFrameConstants::kBytecodeArrayFromFp)); __ movq(kInterpreterBytecodeOffsetRegister, Operand(rbp, InterpreterFrameConstants::kBytecodeOffsetFromFp)); __ SmiUntag(kInterpreterBytecodeOffsetRegister, kInterpreterBytecodeOffsetRegister); // Either return, or advance to the next bytecode and dispatch. Label do_return; __ movzxbq(rbx, Operand(kInterpreterBytecodeArrayRegister, kInterpreterBytecodeOffsetRegister, times_1, 0)); AdvanceBytecodeOffsetOrReturn(masm, kInterpreterBytecodeArrayRegister, kInterpreterBytecodeOffsetRegister, rbx, rcx, &do_return); __ jmp(&do_dispatch); __ bind(&do_return); // The return value is in rax. LeaveInterpreterFrame(masm, rbx, rcx); __ ret(0); __ bind(&compile_lazy); GenerateTailCallToReturnedCode(masm, Runtime::kCompileLazy); __ int3(); // Should not return. } static void Generate_InterpreterPushArgs(MacroAssembler* masm, Register num_args, Register start_address, Register scratch) { // Find the address of the last argument. __ Move(scratch, num_args); __ shlq(scratch, Immediate(kSystemPointerSizeLog2)); __ negq(scratch); __ addq(scratch, start_address); // Push the arguments. Label loop_header, loop_check; __ j(always, &loop_check, Label::kNear); __ bind(&loop_header); __ Push(Operand(start_address, 0)); __ subq(start_address, Immediate(kSystemPointerSize)); __ bind(&loop_check); __ cmpq(start_address, scratch); __ j(greater, &loop_header, Label::kNear); } // static void Builtins::Generate_InterpreterPushArgsThenCallImpl( MacroAssembler* masm, ConvertReceiverMode receiver_mode, InterpreterPushArgsMode mode) { DCHECK(mode != InterpreterPushArgsMode::kArrayFunction); // ----------- S t a t e ------------- // -- rax : the number of arguments (not including the receiver) // -- rbx : the address of the first argument to be pushed. Subsequent // arguments should be consecutive above this, in the same order as // they are to be pushed onto the stack. // -- rdi : the target to call (can be any Object). // ----------------------------------- Label stack_overflow; // Number of values to be pushed. __ leal(rcx, Operand(rax, 1)); // Add one for receiver. // Add a stack check before pushing arguments. Generate_StackOverflowCheck(masm, rcx, rdx, &stack_overflow); // Pop return address to allow tail-call after pushing arguments. __ PopReturnAddressTo(kScratchRegister); // Push "undefined" as the receiver arg if we need to. if (receiver_mode == ConvertReceiverMode::kNullOrUndefined) { __ PushRoot(RootIndex::kUndefinedValue); __ decl(rcx); // Subtract one for receiver. } // rbx and rdx will be modified. Generate_InterpreterPushArgs(masm, rcx, rbx, rdx); if (mode == InterpreterPushArgsMode::kWithFinalSpread) { __ Pop(rbx); // Pass the spread in a register __ decl(rax); // Subtract one for spread } // Call the target. __ PushReturnAddressFrom(kScratchRegister); // Re-push return address. if (mode == InterpreterPushArgsMode::kWithFinalSpread) { __ Jump(BUILTIN_CODE(masm->isolate(), CallWithSpread), RelocInfo::CODE_TARGET); } else { __ Jump(masm->isolate()->builtins()->Call(receiver_mode), RelocInfo::CODE_TARGET); } // Throw stack overflow exception. __ bind(&stack_overflow); { __ TailCallRuntime(Runtime::kThrowStackOverflow); // This should be unreachable. __ int3(); } } // static void Builtins::Generate_InterpreterPushArgsThenConstructImpl( MacroAssembler* masm, InterpreterPushArgsMode mode) { // ----------- S t a t e ------------- // -- rax : the number of arguments (not including the receiver) // -- rdx : the new target (either the same as the constructor or // the JSFunction on which new was invoked initially) // -- rdi : the constructor to call (can be any Object) // -- rbx : the allocation site feedback if available, undefined otherwise // -- rcx : the address of the first argument to be pushed. Subsequent // arguments should be consecutive above this, in the same order as // they are to be pushed onto the stack. // ----------------------------------- Label stack_overflow; // Add a stack check before pushing arguments. Generate_StackOverflowCheck(masm, rax, r8, &stack_overflow); // Pop return address to allow tail-call after pushing arguments. __ PopReturnAddressTo(kScratchRegister); // Push slot for the receiver to be constructed. __ Push(Immediate(0)); // rcx and r8 will be modified. Generate_InterpreterPushArgs(masm, rax, rcx, r8); if (mode == InterpreterPushArgsMode::kWithFinalSpread) { __ Pop(rbx); // Pass the spread in a register __ decl(rax); // Subtract one for spread // Push return address in preparation for the tail-call. __ PushReturnAddressFrom(kScratchRegister); } else { __ PushReturnAddressFrom(kScratchRegister); __ AssertUndefinedOrAllocationSite(rbx); } if (mode == InterpreterPushArgsMode::kArrayFunction) { // Tail call to the array construct stub (still in the caller // context at this point). __ AssertFunction(rdi); // Jump to the constructor function (rax, rbx, rdx passed on). Handle<Code> code = BUILTIN_CODE(masm->isolate(), ArrayConstructorImpl); __ Jump(code, RelocInfo::CODE_TARGET); } else if (mode == InterpreterPushArgsMode::kWithFinalSpread) { // Call the constructor (rax, rdx, rdi passed on). __ Jump(BUILTIN_CODE(masm->isolate(), ConstructWithSpread), RelocInfo::CODE_TARGET); } else { DCHECK_EQ(InterpreterPushArgsMode::kOther, mode); // Call the constructor (rax, rdx, rdi passed on). __ Jump(BUILTIN_CODE(masm->isolate(), Construct), RelocInfo::CODE_TARGET); } // Throw stack overflow exception. __ bind(&stack_overflow); { __ TailCallRuntime(Runtime::kThrowStackOverflow); // This should be unreachable. __ int3(); } } static void Generate_InterpreterEnterBytecode(MacroAssembler* masm) { // Set the return address to the correct point in the interpreter entry // trampoline. Label builtin_trampoline, trampoline_loaded; Smi interpreter_entry_return_pc_offset( masm->isolate()->heap()->interpreter_entry_return_pc_offset()); DCHECK_NE(interpreter_entry_return_pc_offset, Smi::kZero); // If the SFI function_data is an InterpreterData, the function will have a // custom copy of the interpreter entry trampoline for profiling. If so, // get the custom trampoline, otherwise grab the entry address of the global // trampoline. __ movq(rbx, Operand(rbp, StandardFrameConstants::kFunctionOffset)); __ LoadTaggedPointerField( rbx, FieldOperand(rbx, JSFunction::kSharedFunctionInfoOffset)); __ LoadTaggedPointerField( rbx, FieldOperand(rbx, SharedFunctionInfo::kFunctionDataOffset)); __ CmpObjectType(rbx, INTERPRETER_DATA_TYPE, kScratchRegister); __ j(not_equal, &builtin_trampoline, Label::kNear); __ movq(rbx, FieldOperand(rbx, InterpreterData::kInterpreterTrampolineOffset)); __ addq(rbx, Immediate(Code::kHeaderSize - kHeapObjectTag)); __ jmp(&trampoline_loaded, Label::kNear); __ bind(&builtin_trampoline); // TODO(jgruber): Replace this by a lookup in the builtin entry table. __ movq(rbx, __ ExternalReferenceAsOperand( ExternalReference:: address_of_interpreter_entry_trampoline_instruction_start( masm->isolate()), kScratchRegister)); __ bind(&trampoline_loaded); __ addq(rbx, Immediate(interpreter_entry_return_pc_offset.value())); __ Push(rbx); // Initialize dispatch table register. __ Move( kInterpreterDispatchTableRegister, ExternalReference::interpreter_dispatch_table_address(masm->isolate())); // Get the bytecode array pointer from the frame. __ movq(kInterpreterBytecodeArrayRegister, Operand(rbp, InterpreterFrameConstants::kBytecodeArrayFromFp)); if (FLAG_debug_code) { // Check function data field is actually a BytecodeArray object. __ AssertNotSmi(kInterpreterBytecodeArrayRegister); __ CmpObjectType(kInterpreterBytecodeArrayRegister, BYTECODE_ARRAY_TYPE, rbx); __ Assert( equal, AbortReason::kFunctionDataShouldBeBytecodeArrayOnInterpreterEntry); } // Get the target bytecode offset from the frame. __ movq(kInterpreterBytecodeOffsetRegister, Operand(rbp, InterpreterFrameConstants::kBytecodeOffsetFromFp)); __ SmiUntag(kInterpreterBytecodeOffsetRegister, kInterpreterBytecodeOffsetRegister); // Dispatch to the target bytecode. __ movzxbq(r11, Operand(kInterpreterBytecodeArrayRegister, kInterpreterBytecodeOffsetRegister, times_1, 0)); __ movq(kJavaScriptCallCodeStartRegister, Operand(kInterpreterDispatchTableRegister, r11, times_system_pointer_size, 0)); __ jmp(kJavaScriptCallCodeStartRegister); } void Builtins::Generate_InterpreterEnterBytecodeAdvance(MacroAssembler* masm) { // Get bytecode array and bytecode offset from the stack frame. __ movq(kInterpreterBytecodeArrayRegister, Operand(rbp, InterpreterFrameConstants::kBytecodeArrayFromFp)); __ movq(kInterpreterBytecodeOffsetRegister, Operand(rbp, InterpreterFrameConstants::kBytecodeOffsetFromFp)); __ SmiUntag(kInterpreterBytecodeOffsetRegister, kInterpreterBytecodeOffsetRegister); // Load the current bytecode. __ movzxbq(rbx, Operand(kInterpreterBytecodeArrayRegister, kInterpreterBytecodeOffsetRegister, times_1, 0)); // Advance to the next bytecode. Label if_return; AdvanceBytecodeOffsetOrReturn(masm, kInterpreterBytecodeArrayRegister, kInterpreterBytecodeOffsetRegister, rbx, rcx, &if_return); // Convert new bytecode offset to a Smi and save in the stackframe. __ SmiTag(rbx, kInterpreterBytecodeOffsetRegister); __ movq(Operand(rbp, InterpreterFrameConstants::kBytecodeOffsetFromFp), rbx); Generate_InterpreterEnterBytecode(masm); // We should never take the if_return path. __ bind(&if_return); __ Abort(AbortReason::kInvalidBytecodeAdvance); } void Builtins::Generate_InterpreterEnterBytecodeDispatch(MacroAssembler* masm) { Generate_InterpreterEnterBytecode(masm); } void Builtins::Generate_InstantiateAsmJs(MacroAssembler* masm) { // ----------- S t a t e ------------- // -- rax : argument count (preserved for callee) // -- rdx : new target (preserved for callee) // -- rdi : target function (preserved for callee) // ----------------------------------- Label failed; { FrameScope scope(masm, StackFrame::INTERNAL); // Preserve argument count for later compare. __ movq(rcx, rax); // Push the number of arguments to the callee. __ SmiTag(rax, rax); __ Push(rax); // Push a copy of the target function and the new target. __ Push(rdi); __ Push(rdx); // The function. __ Push(rdi); // Copy arguments from caller (stdlib, foreign, heap). Label args_done; for (int j = 0; j < 4; ++j) { Label over; if (j < 3) { __ cmpq(rcx, Immediate(j)); __ j(not_equal, &over, Label::kNear); } for (int i = j - 1; i >= 0; --i) { __ Push(Operand(rbp, StandardFrameConstants::kCallerSPOffset + i * kSystemPointerSize)); } for (int i = 0; i < 3 - j; ++i) { __ PushRoot(RootIndex::kUndefinedValue); } if (j < 3) { __ jmp(&args_done, Label::kNear); __ bind(&over); } } __ bind(&args_done); // Call runtime, on success unwind frame, and parent frame. __ CallRuntime(Runtime::kInstantiateAsmJs, 4); // A smi 0 is returned on failure, an object on success. __ JumpIfSmi(rax, &failed, Label::kNear); __ Drop(2); __ Pop(rcx); __ SmiUntag(rcx, rcx); scope.GenerateLeaveFrame(); __ PopReturnAddressTo(rbx); __ incq(rcx); __ leaq(rsp, Operand(rsp, rcx, times_system_pointer_size, 0)); __ PushReturnAddressFrom(rbx); __ ret(0); __ bind(&failed); // Restore target function and new target. __ Pop(rdx); __ Pop(rdi); __ Pop(rax); __ SmiUntag(rax, rax); } // On failure, tail call back to regular js by re-calling the function // which has be reset to the compile lazy builtin. __ LoadTaggedPointerField(rcx, FieldOperand(rdi, JSFunction::kCodeOffset)); __ JumpCodeObject(rcx); } namespace { void Generate_ContinueToBuiltinHelper(MacroAssembler* masm, bool java_script_builtin, bool with_result) { const RegisterConfiguration* config(RegisterConfiguration::Default()); int allocatable_register_count = config->num_allocatable_general_registers(); if (with_result) { // Overwrite the hole inserted by the deoptimizer with the return value from // the LAZY deopt point. __ movq( Operand(rsp, config->num_allocatable_general_registers() * kSystemPointerSize + BuiltinContinuationFrameConstants::kFixedFrameSize), rax); } for (int i = allocatable_register_count - 1; i >= 0; --i) { int code = config->GetAllocatableGeneralCode(i); __ popq(Register::from_code(code)); if (java_script_builtin && code == kJavaScriptCallArgCountRegister.code()) { __ SmiUntag(Register::from_code(code), Register::from_code(code)); } } __ movq( rbp, Operand(rsp, BuiltinContinuationFrameConstants::kFixedFrameSizeFromFp)); const int offsetToPC = BuiltinContinuationFrameConstants::kFixedFrameSizeFromFp - kSystemPointerSize; __ popq(Operand(rsp, offsetToPC)); __ Drop(offsetToPC / kSystemPointerSize); // Replace the builtin index Smi on the stack with the instruction start // address of the builtin from the builtins table, and then Ret to this // address __ movq(kScratchRegister, Operand(rsp, 0)); __ movq(kScratchRegister, __ EntryFromBuiltinIndexAsOperand(kScratchRegister)); __ movq(Operand(rsp, 0), kScratchRegister); __ Ret(); } } // namespace void Builtins::Generate_ContinueToCodeStubBuiltin(MacroAssembler* masm) { Generate_ContinueToBuiltinHelper(masm, false, false); } void Builtins::Generate_ContinueToCodeStubBuiltinWithResult( MacroAssembler* masm) { Generate_ContinueToBuiltinHelper(masm, false, true); } void Builtins::Generate_ContinueToJavaScriptBuiltin(MacroAssembler* masm) { Generate_ContinueToBuiltinHelper(masm, true, false); } void Builtins::Generate_ContinueToJavaScriptBuiltinWithResult( MacroAssembler* masm) { Generate_ContinueToBuiltinHelper(masm, true, true); } void Builtins::Generate_NotifyDeoptimized(MacroAssembler* masm) { // Enter an internal frame. { FrameScope scope(masm, StackFrame::INTERNAL); __ CallRuntime(Runtime::kNotifyDeoptimized); // Tear down internal frame. } DCHECK_EQ(kInterpreterAccumulatorRegister.code(), rax.code()); __ movq(rax, Operand(rsp, kPCOnStackSize)); __ ret(1 * kSystemPointerSize); // Remove rax. } // static void Builtins::Generate_FunctionPrototypeApply(MacroAssembler* masm) { // ----------- S t a t e ------------- // -- rax : argc // -- rsp[0] : return address // -- rsp[8] : argArray // -- rsp[16] : thisArg // -- rsp[24] : receiver // ----------------------------------- // 1. Load receiver into rdi, argArray into rbx (if present), remove all // arguments from the stack (including the receiver), and push thisArg (if // present) instead. { Label no_arg_array, no_this_arg; StackArgumentsAccessor args(rsp, rax); __ LoadRoot(rdx, RootIndex::kUndefinedValue); __ movq(rbx, rdx); __ movq(rdi, args.GetReceiverOperand()); __ testq(rax, rax); __ j(zero, &no_this_arg, Label::kNear); { __ movq(rdx, args.GetArgumentOperand(1)); __ cmpq(rax, Immediate(1)); __ j(equal, &no_arg_array, Label::kNear); __ movq(rbx, args.GetArgumentOperand(2)); __ bind(&no_arg_array); } __ bind(&no_this_arg); __ PopReturnAddressTo(rcx); __ leaq(rsp, Operand(rsp, rax, times_system_pointer_size, kSystemPointerSize)); __ Push(rdx); __ PushReturnAddressFrom(rcx); } // ----------- S t a t e ------------- // -- rbx : argArray // -- rdi : receiver // -- rsp[0] : return address // -- rsp[8] : thisArg // ----------------------------------- // 2. We don't need to check explicitly for callable receiver here, // since that's the first thing the Call/CallWithArrayLike builtins // will do. // 3. Tail call with no arguments if argArray is null or undefined. Label no_arguments; __ JumpIfRoot(rbx, RootIndex::kNullValue, &no_arguments, Label::kNear); __ JumpIfRoot(rbx, RootIndex::kUndefinedValue, &no_arguments, Label::kNear); // 4a. Apply the receiver to the given argArray. __ Jump(BUILTIN_CODE(masm->isolate(), CallWithArrayLike), RelocInfo::CODE_TARGET); // 4b. The argArray is either null or undefined, so we tail call without any // arguments to the receiver. Since we did not create a frame for // Function.prototype.apply() yet, we use a normal Call builtin here. __ bind(&no_arguments); { __ Set(rax, 0); __ Jump(masm->isolate()->builtins()->Call(), RelocInfo::CODE_TARGET); } } // static void Builtins::Generate_FunctionPrototypeCall(MacroAssembler* masm) { // Stack Layout: // rsp[0] : Return address // rsp[8] : Argument n // rsp[16] : Argument n-1 // ... // rsp[8 * n] : Argument 1 // rsp[8 * (n + 1)] : Receiver (callable to call) // // rax contains the number of arguments, n, not counting the receiver. // // 1. Make sure we have at least one argument. { Label done; __ testq(rax, rax); __ j(not_zero, &done, Label::kNear); __ PopReturnAddressTo(rbx); __ PushRoot(RootIndex::kUndefinedValue); __ PushReturnAddressFrom(rbx); __ incq(rax); __ bind(&done); } // 2. Get the callable to call (passed as receiver) from the stack. { StackArgumentsAccessor args(rsp, rax); __ movq(rdi, args.GetReceiverOperand()); } // 3. Shift arguments and return address one slot down on the stack // (overwriting the original receiver). Adjust argument count to make // the original first argument the new receiver. { Label loop; __ movq(rcx, rax); StackArgumentsAccessor args(rsp, rcx); __ bind(&loop); __ movq(rbx, args.GetArgumentOperand(1)); __ movq(args.GetArgumentOperand(0), rbx); __ decq(rcx); __ j(not_zero, &loop); // While non-zero. __ DropUnderReturnAddress(1, rbx); // Drop one slot under return address. __ decq(rax); // One fewer argument (first argument is new receiver). } // 4. Call the callable. // Since we did not create a frame for Function.prototype.call() yet, // we use a normal Call builtin here. __ Jump(masm->isolate()->builtins()->Call(), RelocInfo::CODE_TARGET); } void Builtins::Generate_ReflectApply(MacroAssembler* masm) { // ----------- S t a t e ------------- // -- rax : argc // -- rsp[0] : return address // -- rsp[8] : argumentsList // -- rsp[16] : thisArgument // -- rsp[24] : target // -- rsp[32] : receiver // ----------------------------------- // 1. Load target into rdi (if present), argumentsList into rbx (if present), // remove all arguments from the stack (including the receiver), and push // thisArgument (if present) instead. { Label done; StackArgumentsAccessor args(rsp, rax); __ LoadRoot(rdi, RootIndex::kUndefinedValue); __ movq(rdx, rdi); __ movq(rbx, rdi); __ cmpq(rax, Immediate(1)); __ j(below, &done, Label::kNear); __ movq(rdi, args.GetArgumentOperand(1)); // target __ j(equal, &done, Label::kNear); __ movq(rdx, args.GetArgumentOperand(2)); // thisArgument __ cmpq(rax, Immediate(3)); __ j(below, &done, Label::kNear); __ movq(rbx, args.GetArgumentOperand(3)); // argumentsList __ bind(&done); __ PopReturnAddressTo(rcx); __ leaq(rsp, Operand(rsp, rax, times_system_pointer_size, kSystemPointerSize)); __ Push(rdx); __ PushReturnAddressFrom(rcx); } // ----------- S t a t e ------------- // -- rbx : argumentsList // -- rdi : target // -- rsp[0] : return address // -- rsp[8] : thisArgument // ----------------------------------- // 2. We don't need to check explicitly for callable target here, // since that's the first thing the Call/CallWithArrayLike builtins // will do. // 3. Apply the target to the given argumentsList. __ Jump(BUILTIN_CODE(masm->isolate(), CallWithArrayLike), RelocInfo::CODE_TARGET); } void Builtins::Generate_ReflectConstruct(MacroAssembler* masm) { // ----------- S t a t e ------------- // -- rax : argc // -- rsp[0] : return address // -- rsp[8] : new.target (optional) // -- rsp[16] : argumentsList // -- rsp[24] : target // -- rsp[32] : receiver // ----------------------------------- // 1. Load target into rdi (if present), argumentsList into rbx (if present), // new.target into rdx (if present, otherwise use target), remove all // arguments from the stack (including the receiver), and push thisArgument // (if present) instead. { Label done; StackArgumentsAccessor args(rsp, rax); __ LoadRoot(rdi, RootIndex::kUndefinedValue); __ movq(rdx, rdi); __ movq(rbx, rdi); __ cmpq(rax, Immediate(1)); __ j(below, &done, Label::kNear); __ movq(rdi, args.GetArgumentOperand(1)); // target __ movq(rdx, rdi); // new.target defaults to target __ j(equal, &done, Label::kNear); __ movq(rbx, args.GetArgumentOperand(2)); // argumentsList __ cmpq(rax, Immediate(3)); __ j(below, &done, Label::kNear); __ movq(rdx, args.GetArgumentOperand(3)); // new.target __ bind(&done); __ PopReturnAddressTo(rcx); __ leaq(rsp, Operand(rsp, rax, times_system_pointer_size, kSystemPointerSize)); __ PushRoot(RootIndex::kUndefinedValue); __ PushReturnAddressFrom(rcx); } // ----------- S t a t e ------------- // -- rbx : argumentsList // -- rdx : new.target // -- rdi : target // -- rsp[0] : return address // -- rsp[8] : receiver (undefined) // ----------------------------------- // 2. We don't need to check explicitly for constructor target here, // since that's the first thing the Construct/ConstructWithArrayLike // builtins will do. // 3. We don't need to check explicitly for constructor new.target here, // since that's the second thing the Construct/ConstructWithArrayLike // builtins will do. // 4. Construct the target with the given new.target and argumentsList. __ Jump(BUILTIN_CODE(masm->isolate(), ConstructWithArrayLike), RelocInfo::CODE_TARGET); } void Builtins::Generate_InternalArrayConstructor(MacroAssembler* masm) { // ----------- S t a t e ------------- // -- rax : argc // -- rsp[0] : return address // -- rsp[8] : last argument // ----------------------------------- if (FLAG_debug_code) { // Initial map for the builtin InternalArray functions should be maps. __ LoadTaggedPointerField( rbx, FieldOperand(rdi, JSFunction::kPrototypeOrInitialMapOffset)); // Will both indicate a nullptr and a Smi. STATIC_ASSERT(kSmiTag == 0); Condition not_smi = NegateCondition(masm->CheckSmi(rbx)); __ Check(not_smi, AbortReason::kUnexpectedInitialMapForInternalArrayFunction); __ CmpObjectType(rbx, MAP_TYPE, rcx); __ Check(equal, AbortReason::kUnexpectedInitialMapForInternalArrayFunction); } // Run the native code for the InternalArray function called as a normal // function. __ Jump(BUILTIN_CODE(masm->isolate(), InternalArrayConstructorImpl), RelocInfo::CODE_TARGET); } static void EnterArgumentsAdaptorFrame(MacroAssembler* masm) { __ pushq(rbp); __ movq(rbp, rsp); // Store the arguments adaptor context sentinel. __ Push(Immediate(StackFrame::TypeToMarker(StackFrame::ARGUMENTS_ADAPTOR))); // Push the function on the stack. __ Push(rdi); // Preserve the number of arguments on the stack. Must preserve rax, // rbx and rcx because these registers are used when copying the // arguments and the receiver. __ SmiTag(r8, rax); __ Push(r8); __ Push(Immediate(0)); // Padding. } static void LeaveArgumentsAdaptorFrame(MacroAssembler* masm) { // Retrieve the number of arguments from the stack. Number is a Smi. __ movq(rbx, Operand(rbp, ArgumentsAdaptorFrameConstants::kLengthOffset)); // Leave the frame. __ movq(rsp, rbp); __ popq(rbp); // Remove caller arguments from the stack. __ PopReturnAddressTo(rcx); SmiIndex index = masm->SmiToIndex(rbx, rbx, kSystemPointerSizeLog2); __ leaq(rsp, Operand(rsp, index.reg, index.scale, 1 * kSystemPointerSize)); __ PushReturnAddressFrom(rcx); } void Builtins::Generate_ArgumentsAdaptorTrampoline(MacroAssembler* masm) { // ----------- S t a t e ------------- // -- rax : actual number of arguments // -- rbx : expected number of arguments // -- rdx : new target (passed through to callee) // -- rdi : function (passed through to callee) // ----------------------------------- Label dont_adapt_arguments, stack_overflow, skip_adapt_arguments; __ cmpq(rbx, Immediate(SharedFunctionInfo::kDontAdaptArgumentsSentinel)); __ j(equal, &dont_adapt_arguments); __ LoadTaggedPointerField( rcx, FieldOperand(rdi, JSFunction::kSharedFunctionInfoOffset)); __ testl( FieldOperand(rcx, SharedFunctionInfo::kFlagsOffset), Immediate(SharedFunctionInfo::IsSafeToSkipArgumentsAdaptorBit::kMask)); __ j(not_zero, &skip_adapt_arguments); // ------------------------------------------- // Adapt arguments. // ------------------------------------------- { EnterArgumentsAdaptorFrame(masm); Generate_StackOverflowCheck(masm, rbx, rcx, &stack_overflow); Label under_application, over_application, invoke; __ cmpq(rax, rbx); __ j(less, &under_application, Label::kNear); // Enough parameters: Actual >= expected. __ bind(&over_application); { // Copy receiver and all expected arguments. const int offset = StandardFrameConstants::kCallerSPOffset; __ leaq(r8, Operand(rbp, rax, times_system_pointer_size, offset)); __ Set(rax, -1); // account for receiver Label copy; __ bind(©); __ incq(rax); __ Push(Operand(r8, 0)); __ subq(r8, Immediate(kSystemPointerSize)); __ cmpq(rax, rbx); __ j(less, ©); __ jmp(&invoke, Label::kNear); } // Too few parameters: Actual < expected. __ bind(&under_application); { // Copy receiver and all actual arguments. const int offset = StandardFrameConstants::kCallerSPOffset; __ leaq(r9, Operand(rbp, rax, times_system_pointer_size, offset)); __ Set(r8, -1); // account for receiver Label copy; __ bind(©); __ incq(r8); __ Push(Operand(r9, 0)); __ subq(r9, Immediate(kSystemPointerSize)); __ cmpq(r8, rax); __ j(less, ©); // Fill remaining expected arguments with undefined values. Label fill; __ LoadRoot(kScratchRegister, RootIndex::kUndefinedValue); __ bind(&fill); __ incq(rax); __ Push(kScratchRegister); __ cmpq(rax, rbx); __ j(less, &fill); } // Call the entry point. __ bind(&invoke); // rax : expected number of arguments // rdx : new target (passed through to callee) // rdi : function (passed through to callee) static_assert(kJavaScriptCallCodeStartRegister == rcx, "ABI mismatch"); __ LoadTaggedPointerField(rcx, FieldOperand(rdi, JSFunction::kCodeOffset)); __ CallCodeObject(rcx); // Store offset of return address for deoptimizer. masm->isolate()->heap()->SetArgumentsAdaptorDeoptPCOffset( masm->pc_offset()); // Leave frame and return. LeaveArgumentsAdaptorFrame(masm); __ ret(0); } // ------------------------------------------- // Skip adapt arguments. // ------------------------------------------- __ bind(&skip_adapt_arguments); { // The callee cannot observe the actual arguments, so it's safe to just // pass the expected arguments by massaging the stack appropriately. See // http://bit.ly/v8-faster-calls-with-arguments-mismatch for details. Label under_application, over_application, invoke; __ PopReturnAddressTo(rcx); __ cmpq(rax, rbx); __ j(less, &under_application, Label::kNear); __ bind(&over_application); { // Remove superfluous parameters from the stack. __ xchgq(rax, rbx); __ subq(rbx, rax); __ leaq(rsp, Operand(rsp, rbx, times_system_pointer_size, 0)); __ jmp(&invoke, Label::kNear); } __ bind(&under_application); { // Fill remaining expected arguments with undefined values. Label fill; __ LoadRoot(kScratchRegister, RootIndex::kUndefinedValue); __ bind(&fill); __ incq(rax); __ Push(kScratchRegister); __ cmpq(rax, rbx); __ j(less, &fill); } __ bind(&invoke); __ PushReturnAddressFrom(rcx); } // ------------------------------------------- // Don't adapt arguments. // ------------------------------------------- __ bind(&dont_adapt_arguments); static_assert(kJavaScriptCallCodeStartRegister == rcx, "ABI mismatch"); __ LoadTaggedPointerField(rcx, FieldOperand(rdi, JSFunction::kCodeOffset)); __ JumpCodeObject(rcx); __ bind(&stack_overflow); { FrameScope frame(masm, StackFrame::MANUAL); __ CallRuntime(Runtime::kThrowStackOverflow); __ int3(); } } // static void Builtins::Generate_CallOrConstructVarargs(MacroAssembler* masm, Handle<Code> code) { // ----------- S t a t e ------------- // -- rdi : target // -- rax : number of parameters on the stack (not including the receiver) // -- rbx : arguments list (a FixedArray) // -- rcx : len (number of elements to push from args) // -- rdx : new.target (for [[Construct]]) // -- rsp[0] : return address // ----------------------------------- Register scratch = r11; Register decompr_scratch = COMPRESS_POINTERS_BOOL ? r12 : no_reg; if (masm->emit_debug_code()) { // Allow rbx to be a FixedArray, or a FixedDoubleArray if rcx == 0. Label ok, fail; __ AssertNotSmi(rbx); Register map = r9; __ LoadTaggedPointerField(map, FieldOperand(rbx, HeapObject::kMapOffset)); __ CmpInstanceType(map, FIXED_ARRAY_TYPE); __ j(equal, &ok); __ CmpInstanceType(map, FIXED_DOUBLE_ARRAY_TYPE); __ j(not_equal, &fail); __ cmpl(rcx, Immediate(0)); __ j(equal, &ok); // Fall through. __ bind(&fail); __ Abort(AbortReason::kOperandIsNotAFixedArray); __ bind(&ok); } Label stack_overflow; Generate_StackOverflowCheck(masm, rcx, r8, &stack_overflow, Label::kNear); // Push additional arguments onto the stack. { Register value = scratch; __ PopReturnAddressTo(r8); __ Set(r9, 0); Label done, push, loop; __ bind(&loop); __ cmpl(r9, rcx); __ j(equal, &done, Label::kNear); // Turn the hole into undefined as we go. __ LoadAnyTaggedField( value, FieldOperand(rbx, r9, times_tagged_size, FixedArray::kHeaderSize), decompr_scratch); __ CompareRoot(value, RootIndex::kTheHoleValue); __ j(not_equal, &push, Label::kNear); __ LoadRoot(value, RootIndex::kUndefinedValue); __ bind(&push); __ Push(value); __ incl(r9); __ jmp(&loop); __ bind(&done); __ PushReturnAddressFrom(r8); __ addq(rax, r9); } // Tail-call to the actual Call or Construct builtin. __ Jump(code, RelocInfo::CODE_TARGET); __ bind(&stack_overflow); __ TailCallRuntime(Runtime::kThrowStackOverflow); } // static void Builtins::Generate_CallOrConstructForwardVarargs(MacroAssembler* masm, CallOrConstructMode mode, Handle<Code> code) { // ----------- S t a t e ------------- // -- rax : the number of arguments (not including the receiver) // -- rdx : the new target (for [[Construct]] calls) // -- rdi : the target to call (can be any Object) // -- rcx : start index (to support rest parameters) // ----------------------------------- // Check if new.target has a [[Construct]] internal method. if (mode == CallOrConstructMode::kConstruct) { Label new_target_constructor, new_target_not_constructor; __ JumpIfSmi(rdx, &new_target_not_constructor, Label::kNear); __ LoadTaggedPointerField(rbx, FieldOperand(rdx, HeapObject::kMapOffset)); __ testb(FieldOperand(rbx, Map::kBitFieldOffset), Immediate(Map::IsConstructorBit::kMask)); __ j(not_zero, &new_target_constructor, Label::kNear); __ bind(&new_target_not_constructor); { FrameScope scope(masm, StackFrame::MANUAL); __ EnterFrame(StackFrame::INTERNAL); __ Push(rdx); __ CallRuntime(Runtime::kThrowNotConstructor); } __ bind(&new_target_constructor); } // Check if we have an arguments adaptor frame below the function frame. Label arguments_adaptor, arguments_done; __ movq(rbx, Operand(rbp, StandardFrameConstants::kCallerFPOffset)); __ cmpq(Operand(rbx, CommonFrameConstants::kContextOrFrameTypeOffset), Immediate(StackFrame::TypeToMarker(StackFrame::ARGUMENTS_ADAPTOR))); __ j(equal, &arguments_adaptor, Label::kNear); { __ movq(r8, Operand(rbp, JavaScriptFrameConstants::kFunctionOffset)); __ LoadTaggedPointerField( r8, FieldOperand(r8, JSFunction::kSharedFunctionInfoOffset)); __ movzxwq( r8, FieldOperand(r8, SharedFunctionInfo::kFormalParameterCountOffset)); __ movq(rbx, rbp); } __ jmp(&arguments_done, Label::kNear); __ bind(&arguments_adaptor); { __ SmiUntag(r8, Operand(rbx, ArgumentsAdaptorFrameConstants::kLengthOffset)); } __ bind(&arguments_done); Label stack_done, stack_overflow; __ subl(r8, rcx); __ j(less_equal, &stack_done); { // Check for stack overflow. Generate_StackOverflowCheck(masm, r8, rcx, &stack_overflow, Label::kNear); // Forward the arguments from the caller frame. { Label loop; __ addl(rax, r8); __ PopReturnAddressTo(rcx); __ bind(&loop); { StackArgumentsAccessor args(rbx, r8, ARGUMENTS_DONT_CONTAIN_RECEIVER); __ Push(args.GetArgumentOperand(0)); __ decl(r8); __ j(not_zero, &loop); } __ PushReturnAddressFrom(rcx); } } __ jmp(&stack_done, Label::kNear); __ bind(&stack_overflow); __ TailCallRuntime(Runtime::kThrowStackOverflow); __ bind(&stack_done); // Tail-call to the {code} handler. __ Jump(code, RelocInfo::CODE_TARGET); } // static void Builtins::Generate_CallFunction(MacroAssembler* masm, ConvertReceiverMode mode) { // ----------- S t a t e ------------- // -- rax : the number of arguments (not including the receiver) // -- rdi : the function to call (checked to be a JSFunction) // ----------------------------------- StackArgumentsAccessor args(rsp, rax); __ AssertFunction(rdi); // ES6 section 9.2.1 [[Call]] ( thisArgument, argumentsList) // Check that the function is not a "classConstructor". Label class_constructor; __ LoadTaggedPointerField( rdx, FieldOperand(rdi, JSFunction::kSharedFunctionInfoOffset)); __ testl(FieldOperand(rdx, SharedFunctionInfo::kFlagsOffset), Immediate(SharedFunctionInfo::IsClassConstructorBit::kMask)); __ j(not_zero, &class_constructor); // ----------- S t a t e ------------- // -- rax : the number of arguments (not including the receiver) // -- rdx : the shared function info. // -- rdi : the function to call (checked to be a JSFunction) // ----------------------------------- // Enter the context of the function; ToObject has to run in the function // context, and we also need to take the global proxy from the function // context in case of conversion. __ LoadTaggedPointerField(rsi, FieldOperand(rdi, JSFunction::kContextOffset)); // We need to convert the receiver for non-native sloppy mode functions. Label done_convert; __ testl(FieldOperand(rdx, SharedFunctionInfo::kFlagsOffset), Immediate(SharedFunctionInfo::IsNativeBit::kMask | SharedFunctionInfo::IsStrictBit::kMask)); __ j(not_zero, &done_convert); { // ----------- S t a t e ------------- // -- rax : the number of arguments (not including the receiver) // -- rdx : the shared function info. // -- rdi : the function to call (checked to be a JSFunction) // -- rsi : the function context. // ----------------------------------- if (mode == ConvertReceiverMode::kNullOrUndefined) { // Patch receiver to global proxy. __ LoadGlobalProxy(rcx); } else { Label convert_to_object, convert_receiver; __ movq(rcx, args.GetReceiverOperand()); __ JumpIfSmi(rcx, &convert_to_object, Label::kNear); STATIC_ASSERT(LAST_JS_RECEIVER_TYPE == LAST_TYPE); __ CmpObjectType(rcx, FIRST_JS_RECEIVER_TYPE, rbx); __ j(above_equal, &done_convert); if (mode != ConvertReceiverMode::kNotNullOrUndefined) { Label convert_global_proxy; __ JumpIfRoot(rcx, RootIndex::kUndefinedValue, &convert_global_proxy, Label::kNear); __ JumpIfNotRoot(rcx, RootIndex::kNullValue, &convert_to_object, Label::kNear); __ bind(&convert_global_proxy); { // Patch receiver to global proxy. __ LoadGlobalProxy(rcx); } __ jmp(&convert_receiver); } __ bind(&convert_to_object); { // Convert receiver using ToObject. // TODO(bmeurer): Inline the allocation here to avoid building the frame // in the fast case? (fall back to AllocateInNewSpace?) FrameScope scope(masm, StackFrame::INTERNAL); __ SmiTag(rax, rax); __ Push(rax); __ Push(rdi); __ movq(rax, rcx); __ Push(rsi); __ Call(BUILTIN_CODE(masm->isolate(), ToObject), RelocInfo::CODE_TARGET); __ Pop(rsi); __ movq(rcx, rax); __ Pop(rdi); __ Pop(rax); __ SmiUntag(rax, rax); } __ LoadTaggedPointerField( rdx, FieldOperand(rdi, JSFunction::kSharedFunctionInfoOffset)); __ bind(&convert_receiver); } __ movq(args.GetReceiverOperand(), rcx); } __ bind(&done_convert); // ----------- S t a t e ------------- // -- rax : the number of arguments (not including the receiver) // -- rdx : the shared function info. // -- rdi : the function to call (checked to be a JSFunction) // -- rsi : the function context. // ----------------------------------- __ movzxwq( rbx, FieldOperand(rdx, SharedFunctionInfo::kFormalParameterCountOffset)); ParameterCount actual(rax); ParameterCount expected(rbx); __ InvokeFunctionCode(rdi, no_reg, expected, actual, JUMP_FUNCTION); // The function is a "classConstructor", need to raise an exception. __ bind(&class_constructor); { FrameScope frame(masm, StackFrame::INTERNAL); __ Push(rdi); __ CallRuntime(Runtime::kThrowConstructorNonCallableError); } } namespace { void Generate_PushBoundArguments(MacroAssembler* masm) { // ----------- S t a t e ------------- // -- rax : the number of arguments (not including the receiver) // -- rdx : new.target (only in case of [[Construct]]) // -- rdi : target (checked to be a JSBoundFunction) // ----------------------------------- Register decompr_scratch = COMPRESS_POINTERS_BOOL ? r11 : no_reg; // Load [[BoundArguments]] into rcx and length of that into rbx. Label no_bound_arguments; __ LoadTaggedPointerField( rcx, FieldOperand(rdi, JSBoundFunction::kBoundArgumentsOffset)); __ SmiUntagField(rbx, FieldOperand(rcx, FixedArray::kLengthOffset)); __ testl(rbx, rbx); __ j(zero, &no_bound_arguments); { // ----------- S t a t e ------------- // -- rax : the number of arguments (not including the receiver) // -- rdx : new.target (only in case of [[Construct]]) // -- rdi : target (checked to be a JSBoundFunction) // -- rcx : the [[BoundArguments]] (implemented as FixedArray) // -- rbx : the number of [[BoundArguments]] (checked to be non-zero) // ----------------------------------- // Check the stack for overflow. { Label done; __ shlq(rbx, Immediate(kSystemPointerSizeLog2)); __ movq(kScratchRegister, rsp); __ subq(kScratchRegister, rbx); // We are not trying to catch interruptions (i.e. debug break and // preemption) here, so check the "real stack limit". __ cmpq(kScratchRegister, RealStackLimitAsOperand(masm)); __ j(above_equal, &done, Label::kNear); { FrameScope scope(masm, StackFrame::MANUAL); __ EnterFrame(StackFrame::INTERNAL); __ CallRuntime(Runtime::kThrowStackOverflow); } __ bind(&done); } // Reserve stack space for the [[BoundArguments]]. __ movq(kScratchRegister, rbx); __ AllocateStackSpace(kScratchRegister); // Adjust effective number of arguments to include return address. __ incl(rax); // Relocate arguments and return address down the stack. { Label loop; __ Set(rcx, 0); __ addq(rbx, rsp); __ bind(&loop); __ movq(kScratchRegister, Operand(rbx, rcx, times_system_pointer_size, 0)); __ movq(Operand(rsp, rcx, times_system_pointer_size, 0), kScratchRegister); __ incl(rcx); __ cmpl(rcx, rax); __ j(less, &loop); } // Copy [[BoundArguments]] to the stack (below the arguments). { Label loop; __ LoadTaggedPointerField( rcx, FieldOperand(rdi, JSBoundFunction::kBoundArgumentsOffset)); __ SmiUntagField(rbx, FieldOperand(rcx, FixedArray::kLengthOffset)); __ bind(&loop); // Instead of doing decl(rbx) here subtract kTaggedSize from the header // offset in order to move be able to move decl(rbx) right before the loop // condition. This is necessary in order to avoid flags corruption by // pointer decompression code. __ LoadAnyTaggedField(r12, FieldOperand(rcx, rbx, times_tagged_size, FixedArray::kHeaderSize - kTaggedSize), decompr_scratch); __ movq(Operand(rsp, rax, times_system_pointer_size, 0), r12); __ leal(rax, Operand(rax, 1)); __ decl(rbx); __ j(greater, &loop); } // Adjust effective number of arguments (rax contains the number of // arguments from the call plus return address plus the number of // [[BoundArguments]]), so we need to subtract one for the return address. __ decl(rax); } __ bind(&no_bound_arguments); } } // namespace // static void Builtins::Generate_CallBoundFunctionImpl(MacroAssembler* masm) { // ----------- S t a t e ------------- // -- rax : the number of arguments (not including the receiver) // -- rdi : the function to call (checked to be a JSBoundFunction) // ----------------------------------- __ AssertBoundFunction(rdi); Register decompr_scratch = COMPRESS_POINTERS_BOOL ? r11 : no_reg; // Patch the receiver to [[BoundThis]]. StackArgumentsAccessor args(rsp, rax); __ LoadAnyTaggedField(rbx, FieldOperand(rdi, JSBoundFunction::kBoundThisOffset), decompr_scratch); __ movq(args.GetReceiverOperand(), rbx); // Push the [[BoundArguments]] onto the stack. Generate_PushBoundArguments(masm); // Call the [[BoundTargetFunction]] via the Call builtin. __ LoadTaggedPointerField( rdi, FieldOperand(rdi, JSBoundFunction::kBoundTargetFunctionOffset)); __ Jump(BUILTIN_CODE(masm->isolate(), Call_ReceiverIsAny), RelocInfo::CODE_TARGET); } // static void Builtins::Generate_Call(MacroAssembler* masm, ConvertReceiverMode mode) { // ----------- S t a t e ------------- // -- rax : the number of arguments (not including the receiver) // -- rdi : the target to call (can be any Object) // ----------------------------------- StackArgumentsAccessor args(rsp, rax); Label non_callable; __ JumpIfSmi(rdi, &non_callable); __ CmpObjectType(rdi, JS_FUNCTION_TYPE, rcx); __ Jump(masm->isolate()->builtins()->CallFunction(mode), RelocInfo::CODE_TARGET, equal); __ CmpInstanceType(rcx, JS_BOUND_FUNCTION_TYPE); __ Jump(BUILTIN_CODE(masm->isolate(), CallBoundFunction), RelocInfo::CODE_TARGET, equal); // Check if target has a [[Call]] internal method. __ testb(FieldOperand(rcx, Map::kBitFieldOffset), Immediate(Map::IsCallableBit::kMask)); __ j(zero, &non_callable, Label::kNear); // Check if target is a proxy and call CallProxy external builtin __ CmpInstanceType(rcx, JS_PROXY_TYPE); __ Jump(BUILTIN_CODE(masm->isolate(), CallProxy), RelocInfo::CODE_TARGET, equal); // 2. Call to something else, which might have a [[Call]] internal method (if // not we raise an exception). // Overwrite the original receiver with the (original) target. __ movq(args.GetReceiverOperand(), rdi); // Let the "call_as_function_delegate" take care of the rest. __ LoadNativeContextSlot(Context::CALL_AS_FUNCTION_DELEGATE_INDEX, rdi); __ Jump(masm->isolate()->builtins()->CallFunction( ConvertReceiverMode::kNotNullOrUndefined), RelocInfo::CODE_TARGET); // 3. Call to something that is not callable. __ bind(&non_callable); { FrameScope scope(masm, StackFrame::INTERNAL); __ Push(rdi); __ CallRuntime(Runtime::kThrowCalledNonCallable); } } // static void Builtins::Generate_ConstructFunction(MacroAssembler* masm) { // ----------- S t a t e ------------- // -- rax : the number of arguments (not including the receiver) // -- rdx : the new target (checked to be a constructor) // -- rdi : the constructor to call (checked to be a JSFunction) // ----------------------------------- __ AssertConstructor(rdi); __ AssertFunction(rdi); // Calling convention for function specific ConstructStubs require // rbx to contain either an AllocationSite or undefined. __ LoadRoot(rbx, RootIndex::kUndefinedValue); // Jump to JSBuiltinsConstructStub or JSConstructStubGeneric. __ LoadTaggedPointerField( rcx, FieldOperand(rdi, JSFunction::kSharedFunctionInfoOffset)); __ testl(FieldOperand(rcx, SharedFunctionInfo::kFlagsOffset), Immediate(SharedFunctionInfo::ConstructAsBuiltinBit::kMask)); __ Jump(BUILTIN_CODE(masm->isolate(), JSBuiltinsConstructStub), RelocInfo::CODE_TARGET, not_zero); __ Jump(BUILTIN_CODE(masm->isolate(), JSConstructStubGeneric), RelocInfo::CODE_TARGET); } // static void Builtins::Generate_ConstructBoundFunction(MacroAssembler* masm) { // ----------- S t a t e ------------- // -- rax : the number of arguments (not including the receiver) // -- rdx : the new target (checked to be a constructor) // -- rdi : the constructor to call (checked to be a JSBoundFunction) // ----------------------------------- __ AssertConstructor(rdi); __ AssertBoundFunction(rdi); // Push the [[BoundArguments]] onto the stack. Generate_PushBoundArguments(masm); // Patch new.target to [[BoundTargetFunction]] if new.target equals target. { Label done; __ cmpq(rdi, rdx); __ j(not_equal, &done, Label::kNear); __ LoadTaggedPointerField( rdx, FieldOperand(rdi, JSBoundFunction::kBoundTargetFunctionOffset)); __ bind(&done); } // Construct the [[BoundTargetFunction]] via the Construct builtin. __ LoadTaggedPointerField( rdi, FieldOperand(rdi, JSBoundFunction::kBoundTargetFunctionOffset)); __ Jump(BUILTIN_CODE(masm->isolate(), Construct), RelocInfo::CODE_TARGET); } // static void Builtins::Generate_Construct(MacroAssembler* masm) { // ----------- S t a t e ------------- // -- rax : the number of arguments (not including the receiver) // -- rdx : the new target (either the same as the constructor or // the JSFunction on which new was invoked initially) // -- rdi : the constructor to call (can be any Object) // ----------------------------------- StackArgumentsAccessor args(rsp, rax); // Check if target is a Smi. Label non_constructor; __ JumpIfSmi(rdi, &non_constructor); // Check if target has a [[Construct]] internal method. __ LoadTaggedPointerField(rcx, FieldOperand(rdi, HeapObject::kMapOffset)); __ testb(FieldOperand(rcx, Map::kBitFieldOffset), Immediate(Map::IsConstructorBit::kMask)); __ j(zero, &non_constructor); // Dispatch based on instance type. __ CmpInstanceType(rcx, JS_FUNCTION_TYPE); __ Jump(BUILTIN_CODE(masm->isolate(), ConstructFunction), RelocInfo::CODE_TARGET, equal); // Only dispatch to bound functions after checking whether they are // constructors. __ CmpInstanceType(rcx, JS_BOUND_FUNCTION_TYPE); __ Jump(BUILTIN_CODE(masm->isolate(), ConstructBoundFunction), RelocInfo::CODE_TARGET, equal); // Only dispatch to proxies after checking whether they are constructors. __ CmpInstanceType(rcx, JS_PROXY_TYPE); __ Jump(BUILTIN_CODE(masm->isolate(), ConstructProxy), RelocInfo::CODE_TARGET, equal); // Called Construct on an exotic Object with a [[Construct]] internal method. { // Overwrite the original receiver with the (original) target. __ movq(args.GetReceiverOperand(), rdi); // Let the "call_as_constructor_delegate" take care of the rest. __ LoadNativeContextSlot(Context::CALL_AS_CONSTRUCTOR_DELEGATE_INDEX, rdi); __ Jump(masm->isolate()->builtins()->CallFunction(), RelocInfo::CODE_TARGET); } // Called Construct on an Object that doesn't have a [[Construct]] internal // method. __ bind(&non_constructor); __ Jump(BUILTIN_CODE(masm->isolate(), ConstructedNonConstructable), RelocInfo::CODE_TARGET); } void Builtins::Generate_InterpreterOnStackReplacement(MacroAssembler* masm) { // Lookup the function in the JavaScript frame. __ movq(rax, Operand(rbp, StandardFrameConstants::kCallerFPOffset)); __ movq(rax, Operand(rax, JavaScriptFrameConstants::kFunctionOffset)); { FrameScope scope(masm, StackFrame::INTERNAL); // Pass function as argument. __ Push(rax); __ CallRuntime(Runtime::kCompileForOnStackReplacement); } Label skip; // If the code object is null, just return to the caller. __ testq(rax, rax); __ j(not_equal, &skip, Label::kNear); __ ret(0); __ bind(&skip); // Drop the handler frame that is be sitting on top of the actual // JavaScript frame. This is the case then OSR is triggered from bytecode. __ leave(); // Load deoptimization data from the code object. __ LoadTaggedPointerField(rbx, FieldOperand(rax, Code::kDeoptimizationDataOffset)); // Load the OSR entrypoint offset from the deoptimization data. __ SmiUntagField( rbx, FieldOperand(rbx, FixedArray::OffsetOfElementAt( DeoptimizationData::kOsrPcOffsetIndex))); // Compute the target address = code_obj + header_size + osr_offset __ leaq(rax, FieldOperand(rax, rbx, times_1, Code::kHeaderSize)); // Overwrite the return address on the stack. __ movq(StackOperandForReturnAddress(0), rax); // And "return" to the OSR entry point of the function. __ ret(0); } void Builtins::Generate_WasmCompileLazy(MacroAssembler* masm) { // The function index was pushed to the stack by the caller as int32. __ Pop(r11); // Convert to Smi for the runtime call. __ SmiTag(r11, r11); { HardAbortScope hard_abort(masm); // Avoid calls to Abort. FrameScope scope(masm, StackFrame::WASM_COMPILE_LAZY); // Save all parameter registers (see wasm-linkage.cc). They might be // overwritten in the runtime call below. We don't have any callee-saved // registers in wasm, so no need to store anything else. static_assert(WasmCompileLazyFrameConstants::kNumberOfSavedGpParamRegs == arraysize(wasm::kGpParamRegisters), "frame size mismatch"); for (Register reg : wasm::kGpParamRegisters) { __ Push(reg); } static_assert(WasmCompileLazyFrameConstants::kNumberOfSavedFpParamRegs == arraysize(wasm::kFpParamRegisters), "frame size mismatch"); __ AllocateStackSpace(kSimd128Size * arraysize(wasm::kFpParamRegisters)); int offset = 0; for (DoubleRegister reg : wasm::kFpParamRegisters) { __ movdqu(Operand(rsp, offset), reg); offset += kSimd128Size; } // Push the WASM instance as an explicit argument to WasmCompileLazy. __ Push(kWasmInstanceRegister); // Push the function index as second argument. __ Push(r11); // Load the correct CEntry builtin from the instance object. __ movq(rcx, FieldOperand(kWasmInstanceRegister, WasmInstanceObject::kIsolateRootOffset)); auto centry_id = Builtins::kCEntry_Return1_DontSaveFPRegs_ArgvOnStack_NoBuiltinExit; __ LoadTaggedPointerField( rcx, MemOperand(rcx, IsolateData::builtin_slot_offset(centry_id))); // Initialize the JavaScript context with 0. CEntry will use it to // set the current context on the isolate. __ Move(kContextRegister, Smi::zero()); __ CallRuntimeWithCEntry(Runtime::kWasmCompileLazy, rcx); // The entrypoint address is the return value. __ movq(r11, kReturnRegister0); // Restore registers. for (DoubleRegister reg : base::Reversed(wasm::kFpParamRegisters)) { offset -= kSimd128Size; __ movdqu(reg, Operand(rsp, offset)); } DCHECK_EQ(0, offset); __ addq(rsp, Immediate(kSimd128Size * arraysize(wasm::kFpParamRegisters))); for (Register reg : base::Reversed(wasm::kGpParamRegisters)) { __ Pop(reg); } } // Finally, jump to the entrypoint. __ jmp(r11); } void Builtins::Generate_CEntry(MacroAssembler* masm, int result_size, SaveFPRegsMode save_doubles, ArgvMode argv_mode, bool builtin_exit_frame) { // rax: number of arguments including receiver // rbx: pointer to C function (C callee-saved) // rbp: frame pointer of calling JS frame (restored after C call) // rsp: stack pointer (restored after C call) // rsi: current context (restored) // // If argv_mode == kArgvInRegister: // r15: pointer to the first argument #ifdef _WIN64 // Windows 64-bit ABI passes arguments in rcx, rdx, r8, r9. It requires the // stack to be aligned to 16 bytes. It only allows a single-word to be // returned in register rax. Larger return sizes must be written to an address // passed as a hidden first argument. const Register kCCallArg0 = rcx; const Register kCCallArg1 = rdx; const Register kCCallArg2 = r8; const Register kCCallArg3 = r9; const int kArgExtraStackSpace = 2; const int kMaxRegisterResultSize = 1; #else // GCC / Clang passes arguments in rdi, rsi, rdx, rcx, r8, r9. Simple results // are returned in rax, and a struct of two pointers are returned in rax+rdx. // Larger return sizes must be written to an address passed as a hidden first // argument. const Register kCCallArg0 = rdi; const Register kCCallArg1 = rsi; const Register kCCallArg2 = rdx; const Register kCCallArg3 = rcx; const int kArgExtraStackSpace = 0; const int kMaxRegisterResultSize = 2; #endif // _WIN64 // Enter the exit frame that transitions from JavaScript to C++. int arg_stack_space = kArgExtraStackSpace + (result_size <= kMaxRegisterResultSize ? 0 : result_size); if (argv_mode == kArgvInRegister) { DCHECK(save_doubles == kDontSaveFPRegs); DCHECK(!builtin_exit_frame); __ EnterApiExitFrame(arg_stack_space); // Move argc into r14 (argv is already in r15). __ movq(r14, rax); } else { __ EnterExitFrame( arg_stack_space, save_doubles == kSaveFPRegs, builtin_exit_frame ? StackFrame::BUILTIN_EXIT : StackFrame::EXIT); } // rbx: pointer to builtin function (C callee-saved). // rbp: frame pointer of exit frame (restored after C call). // rsp: stack pointer (restored after C call). // r14: number of arguments including receiver (C callee-saved). // r15: argv pointer (C callee-saved). // Check stack alignment. if (FLAG_debug_code) { __ CheckStackAlignment(); } // Call C function. The arguments object will be created by stubs declared by // DECLARE_RUNTIME_FUNCTION(). if (result_size <= kMaxRegisterResultSize) { // Pass a pointer to the Arguments object as the first argument. // Return result in single register (rax), or a register pair (rax, rdx). __ movq(kCCallArg0, r14); // argc. __ movq(kCCallArg1, r15); // argv. __ Move(kCCallArg2, ExternalReference::isolate_address(masm->isolate())); } else { DCHECK_LE(result_size, 2); // Pass a pointer to the result location as the first argument. __ leaq(kCCallArg0, StackSpaceOperand(kArgExtraStackSpace)); // Pass a pointer to the Arguments object as the second argument. __ movq(kCCallArg1, r14); // argc. __ movq(kCCallArg2, r15); // argv. __ Move(kCCallArg3, ExternalReference::isolate_address(masm->isolate())); } __ call(rbx); if (result_size > kMaxRegisterResultSize) { // Read result values stored on stack. Result is stored // above the the two Arguments object slots on Win64. DCHECK_LE(result_size, 2); __ movq(kReturnRegister0, StackSpaceOperand(kArgExtraStackSpace + 0)); __ movq(kReturnRegister1, StackSpaceOperand(kArgExtraStackSpace + 1)); } // Result is in rax or rdx:rax - do not destroy these registers! // Check result for exception sentinel. Label exception_returned; __ CompareRoot(rax, RootIndex::kException); __ j(equal, &exception_returned); // Check that there is no pending exception, otherwise we // should have returned the exception sentinel. if (FLAG_debug_code) { Label okay; __ LoadRoot(r14, RootIndex::kTheHoleValue); ExternalReference pending_exception_address = ExternalReference::Create( IsolateAddressId::kPendingExceptionAddress, masm->isolate()); Operand pending_exception_operand = masm->ExternalReferenceAsOperand(pending_exception_address); __ cmpq(r14, pending_exception_operand); __ j(equal, &okay, Label::kNear); __ int3(); __ bind(&okay); } // Exit the JavaScript to C++ exit frame. __ LeaveExitFrame(save_doubles == kSaveFPRegs, argv_mode == kArgvOnStack); __ ret(0); // Handling of exception. __ bind(&exception_returned); ExternalReference pending_handler_context_address = ExternalReference::Create( IsolateAddressId::kPendingHandlerContextAddress, masm->isolate()); ExternalReference pending_handler_entrypoint_address = ExternalReference::Create( IsolateAddressId::kPendingHandlerEntrypointAddress, masm->isolate()); ExternalReference pending_handler_fp_address = ExternalReference::Create( IsolateAddressId::kPendingHandlerFPAddress, masm->isolate()); ExternalReference pending_handler_sp_address = ExternalReference::Create( IsolateAddressId::kPendingHandlerSPAddress, masm->isolate()); // Ask the runtime for help to determine the handler. This will set rax to // contain the current pending exception, don't clobber it. ExternalReference find_handler = ExternalReference::Create(Runtime::kUnwindAndFindExceptionHandler); { FrameScope scope(masm, StackFrame::MANUAL); __ movq(arg_reg_1, Immediate(0)); // argc. __ movq(arg_reg_2, Immediate(0)); // argv. __ Move(arg_reg_3, ExternalReference::isolate_address(masm->isolate())); __ PrepareCallCFunction(3); __ CallCFunction(find_handler, 3); } // Retrieve the handler context, SP and FP. __ movq(rsi, masm->ExternalReferenceAsOperand(pending_handler_context_address)); __ movq(rsp, masm->ExternalReferenceAsOperand(pending_handler_sp_address)); __ movq(rbp, masm->ExternalReferenceAsOperand(pending_handler_fp_address)); // If the handler is a JS frame, restore the context to the frame. Note that // the context will be set to (rsi == 0) for non-JS frames. Label skip; __ testq(rsi, rsi); __ j(zero, &skip, Label::kNear); __ movq(Operand(rbp, StandardFrameConstants::kContextOffset), rsi); __ bind(&skip); // Reset the masking register. This is done independent of the underlying // feature flag {FLAG_untrusted_code_mitigations} to make the snapshot work // with both configurations. It is safe to always do this, because the // underlying register is caller-saved and can be arbitrarily clobbered. __ ResetSpeculationPoisonRegister(); // Compute the handler entry address and jump to it. __ movq(rdi, masm->ExternalReferenceAsOperand(pending_handler_entrypoint_address)); __ jmp(rdi); } void Builtins::Generate_DoubleToI(MacroAssembler* masm) { Label check_negative, process_64_bits, done; // Account for return address and saved regs. const int kArgumentOffset = 4 * kSystemPointerSize; MemOperand mantissa_operand(MemOperand(rsp, kArgumentOffset)); MemOperand exponent_operand( MemOperand(rsp, kArgumentOffset + kDoubleSize / 2)); // The result is returned on the stack. MemOperand return_operand = mantissa_operand; Register scratch1 = rbx; // Since we must use rcx for shifts below, use some other register (rax) // to calculate the result if ecx is the requested return register. Register result_reg = rax; // Save ecx if it isn't the return register and therefore volatile, or if it // is the return register, then save the temp register we use in its stead // for the result. Register save_reg = rax; __ pushq(rcx); __ pushq(scratch1); __ pushq(save_reg); __ movl(scratch1, mantissa_operand); __ Movsd(kScratchDoubleReg, mantissa_operand); __ movl(rcx, exponent_operand); __ andl(rcx, Immediate(HeapNumber::kExponentMask)); __ shrl(rcx, Immediate(HeapNumber::kExponentShift)); __ leal(result_reg, MemOperand(rcx, -HeapNumber::kExponentBias)); __ cmpl(result_reg, Immediate(HeapNumber::kMantissaBits)); __ j(below, &process_64_bits, Label::kNear); // Result is entirely in lower 32-bits of mantissa int delta = HeapNumber::kExponentBias + Double::kPhysicalSignificandSize; __ subl(rcx, Immediate(delta)); __ xorl(result_reg, result_reg); __ cmpl(rcx, Immediate(31)); __ j(above, &done, Label::kNear); __ shll_cl(scratch1); __ jmp(&check_negative, Label::kNear); __ bind(&process_64_bits); __ Cvttsd2siq(result_reg, kScratchDoubleReg); __ jmp(&done, Label::kNear); // If the double was negative, negate the integer result. __ bind(&check_negative); __ movl(result_reg, scratch1); __ negl(result_reg); __ cmpl(exponent_operand, Immediate(0)); __ cmovl(greater, result_reg, scratch1); // Restore registers __ bind(&done); __ movl(return_operand, result_reg); __ popq(save_reg); __ popq(scratch1); __ popq(rcx); __ ret(0); } void Builtins::Generate_InternalArrayConstructorImpl(MacroAssembler* masm) { // ----------- S t a t e ------------- // -- rax : argc // -- rdi : constructor // -- rsp[0] : return address // -- rsp[8] : last argument // ----------------------------------- if (FLAG_debug_code) { // The array construct code is only set for the global and natives // builtin Array functions which always have maps. // Initial map for the builtin Array function should be a map. __ LoadTaggedPointerField( rcx, FieldOperand(rdi, JSFunction::kPrototypeOrInitialMapOffset)); // Will both indicate a nullptr and a Smi. STATIC_ASSERT(kSmiTag == 0); Condition not_smi = NegateCondition(masm->CheckSmi(rcx)); __ Check(not_smi, AbortReason::kUnexpectedInitialMapForArrayFunction); __ CmpObjectType(rcx, MAP_TYPE, rcx); __ Check(equal, AbortReason::kUnexpectedInitialMapForArrayFunction); // Figure out the right elements kind __ LoadTaggedPointerField( rcx, FieldOperand(rdi, JSFunction::kPrototypeOrInitialMapOffset)); // Load the map's "bit field 2" into |result|. We only need the first byte, // but the following masking takes care of that anyway. __ movzxbq(rcx, FieldOperand(rcx, Map::kBitField2Offset)); // Retrieve elements_kind from bit field 2. __ DecodeField<Map::ElementsKindBits>(rcx); // Initial elements kind should be packed elements. __ cmpl(rcx, Immediate(PACKED_ELEMENTS)); __ Assert(equal, AbortReason::kInvalidElementsKindForInternalPackedArray); // No arguments should be passed. __ testq(rax, rax); __ Assert(zero, AbortReason::kWrongNumberOfArgumentsForInternalPackedArray); } __ Jump( BUILTIN_CODE(masm->isolate(), InternalArrayNoArgumentConstructor_Packed), RelocInfo::CODE_TARGET); } namespace { int Offset(ExternalReference ref0, ExternalReference ref1) { int64_t offset = (ref0.address() - ref1.address()); // Check that fits into int. 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. Clobbers r14, r15, rbx and // caller-save registers. Restores context. On return removes // stack_space * kSystemPointerSize (GCed). void CallApiFunctionAndReturn(MacroAssembler* masm, Register function_address, ExternalReference thunk_ref, Register thunk_last_arg, int stack_space, Operand* stack_space_operand, Operand return_value_operand) { Label prologue; Label promote_scheduled_exception; Label delete_allocated_handles; Label leave_exit_frame; Isolate* isolate = masm->isolate(); Factory* factory = isolate->factory(); ExternalReference next_address = ExternalReference::handle_scope_next_address(isolate); const int kNextOffset = 0; const int kLimitOffset = Offset( ExternalReference::handle_scope_limit_address(isolate), next_address); const int kLevelOffset = Offset( ExternalReference::handle_scope_level_address(isolate), next_address); ExternalReference scheduled_exception_address = ExternalReference::scheduled_exception_address(isolate); DCHECK(rdx == function_address || r8 == function_address); // Allocate HandleScope in callee-save registers. Register prev_next_address_reg = r14; Register prev_limit_reg = rbx; Register base_reg = r15; __ Move(base_reg, next_address); __ movq(prev_next_address_reg, Operand(base_reg, kNextOffset)); __ movq(prev_limit_reg, Operand(base_reg, kLimitOffset)); __ addl(Operand(base_reg, kLevelOffset), Immediate(1)); Label profiler_enabled, end_profiler_check; __ Move(rax, ExternalReference::is_profiling_address(isolate)); __ cmpb(Operand(rax, 0), Immediate(0)); __ j(not_zero, &profiler_enabled); __ Move(rax, ExternalReference::address_of_runtime_stats_flag()); __ cmpl(Operand(rax, 0), Immediate(0)); __ j(not_zero, &profiler_enabled); { // Call the api function directly. __ Move(rax, function_address); __ jmp(&end_profiler_check); } __ bind(&profiler_enabled); { // Third parameter is the address of the actual getter function. __ Move(thunk_last_arg, function_address); __ Move(rax, thunk_ref); } __ bind(&end_profiler_check); // Call the api function! __ call(rax); // Load the value from ReturnValue __ movq(rax, return_value_operand); __ bind(&prologue); // No more valid handles (the result handle was the last one). Restore // previous handle scope. __ subl(Operand(base_reg, kLevelOffset), Immediate(1)); __ movq(Operand(base_reg, kNextOffset), prev_next_address_reg); __ cmpq(prev_limit_reg, Operand(base_reg, kLimitOffset)); __ j(not_equal, &delete_allocated_handles); // Leave the API exit frame. __ bind(&leave_exit_frame); if (stack_space_operand != nullptr) { DCHECK_EQ(stack_space, 0); __ movq(rbx, *stack_space_operand); } __ LeaveApiExitFrame(); // Check if the function scheduled an exception. __ Move(rdi, scheduled_exception_address); __ Cmp(Operand(rdi, 0), factory->the_hole_value()); __ j(not_equal, &promote_scheduled_exception); #if DEBUG // Check if the function returned a valid JavaScript value. Label ok; Register return_value = rax; Register map = rcx; __ JumpIfSmi(return_value, &ok, Label::kNear); __ LoadTaggedPointerField(map, FieldOperand(return_value, HeapObject::kMapOffset)); __ CmpInstanceType(map, LAST_NAME_TYPE); __ j(below_equal, &ok, Label::kNear); __ CmpInstanceType(map, FIRST_JS_RECEIVER_TYPE); __ j(above_equal, &ok, Label::kNear); __ CompareRoot(map, RootIndex::kHeapNumberMap); __ j(equal, &ok, Label::kNear); __ CompareRoot(map, RootIndex::kBigIntMap); __ j(equal, &ok, Label::kNear); __ CompareRoot(return_value, RootIndex::kUndefinedValue); __ j(equal, &ok, Label::kNear); __ CompareRoot(return_value, RootIndex::kTrueValue); __ j(equal, &ok, Label::kNear); __ CompareRoot(return_value, RootIndex::kFalseValue); __ j(equal, &ok, Label::kNear); __ CompareRoot(return_value, RootIndex::kNullValue); __ j(equal, &ok, Label::kNear); __ Abort(AbortReason::kAPICallReturnedInvalidObject); __ bind(&ok); #endif if (stack_space_operand == nullptr) { DCHECK_NE(stack_space, 0); __ ret(stack_space * kSystemPointerSize); } else { DCHECK_EQ(stack_space, 0); __ PopReturnAddressTo(rcx); __ addq(rsp, rbx); __ jmp(rcx); } // 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); __ movq(Operand(base_reg, kLimitOffset), prev_limit_reg); __ movq(prev_limit_reg, rax); __ LoadAddress(arg_reg_1, ExternalReference::isolate_address(isolate)); __ LoadAddress(rax, ExternalReference::delete_handle_scope_extensions()); __ call(rax); __ movq(rax, prev_limit_reg); __ jmp(&leave_exit_frame); } } // namespace // TODO(jgruber): Instead of explicitly setting up implicit_args_ on the stack // in CallApiCallback, we could use the calling convention to set up the stack // correctly in the first place. // // TODO(jgruber): I suspect that most of CallApiCallback could be implemented // as a C++ trampoline, vastly simplifying the assembly implementation. void Builtins::Generate_CallApiCallback(MacroAssembler* masm) { // ----------- S t a t e ------------- // -- rsi : context // -- rdx : api function address // -- rcx : arguments count (not including the receiver) // -- rbx : call data // -- rdi : holder // -- rsp[0] : return address // -- rsp[8] : last argument // -- ... // -- rsp[argc * 8] : first argument // -- rsp[(argc + 1) * 8] : receiver // ----------------------------------- Register api_function_address = rdx; Register argc = rcx; Register call_data = rbx; Register holder = rdi; DCHECK(!AreAliased(api_function_address, argc, holder, call_data, kScratchRegister)); using FCA = FunctionCallbackArguments; 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); // Set up FunctionCallbackInfo's implicit_args on the stack as follows: // // Current state: // rsp[0]: return address // // Target state: // rsp[0 * kSystemPointerSize]: return address // rsp[1 * kSystemPointerSize]: kHolder // rsp[2 * kSystemPointerSize]: kIsolate // rsp[3 * kSystemPointerSize]: undefined (kReturnValueDefaultValue) // rsp[4 * kSystemPointerSize]: undefined (kReturnValue) // rsp[5 * kSystemPointerSize]: kData // rsp[6 * kSystemPointerSize]: undefined (kNewTarget) __ PopReturnAddressTo(rax); __ LoadRoot(kScratchRegister, RootIndex::kUndefinedValue); __ Push(kScratchRegister); __ Push(call_data); __ Push(kScratchRegister); __ Push(kScratchRegister); __ PushAddress(ExternalReference::isolate_address(masm->isolate())); __ Push(holder); __ PushReturnAddressFrom(rax); // Keep a pointer to kHolder (= implicit_args) in a scratch register. // We use it below to set up the FunctionCallbackInfo object. Register scratch = rbx; __ leaq(scratch, Operand(rsp, 1 * kSystemPointerSize)); // Allocate the v8::Arguments structure in the arguments' space since // it's not controlled by GC. static constexpr int kApiStackSpace = 4; __ EnterApiExitFrame(kApiStackSpace); // FunctionCallbackInfo::implicit_args_ (points at kHolder as set up above). __ movq(StackSpaceOperand(0), scratch); // FunctionCallbackInfo::values_ (points at the first varargs argument passed // on the stack). __ leaq(scratch, Operand(scratch, argc, times_system_pointer_size, (FCA::kArgsLength - 1) * kSystemPointerSize)); __ movq(StackSpaceOperand(1), scratch); // FunctionCallbackInfo::length_. __ movq(StackSpaceOperand(2), argc); // We also store the number of bytes to drop from the stack after returning // from the API function here. __ leaq(kScratchRegister, Operand(argc, times_system_pointer_size, (FCA::kArgsLength + 1 /* receiver */) * kSystemPointerSize)); __ movq(StackSpaceOperand(3), kScratchRegister); Register arguments_arg = arg_reg_1; Register callback_arg = arg_reg_2; // It's okay if api_function_address == callback_arg // but not arguments_arg DCHECK(api_function_address != arguments_arg); // v8::InvocationCallback's argument. __ leaq(arguments_arg, StackSpaceOperand(0)); ExternalReference thunk_ref = ExternalReference::invoke_function_callback(); // There are two stack slots above the arguments we constructed on the stack: // the stored ebp (pushed by EnterApiExitFrame), and the return address. static constexpr int kStackSlotsAboveFCA = 2; Operand return_value_operand( rbp, (kStackSlotsAboveFCA + FCA::kReturnValueOffset) * kSystemPointerSize); static constexpr int kUseStackSpaceOperand = 0; Operand stack_space_operand = StackSpaceOperand(3); CallApiFunctionAndReturn(masm, api_function_address, thunk_ref, callback_arg, kUseStackSpaceOperand, &stack_space_operand, return_value_operand); } void Builtins::Generate_CallApiGetter(MacroAssembler* masm) { Register name_arg = arg_reg_1; Register accessor_info_arg = arg_reg_2; Register getter_arg = arg_reg_3; Register api_function_address = r8; Register receiver = ApiGetterDescriptor::ReceiverRegister(); Register holder = ApiGetterDescriptor::HolderRegister(); Register callback = ApiGetterDescriptor::CallbackRegister(); Register scratch = rax; Register decompr_scratch1 = COMPRESS_POINTERS_BOOL ? r11 : no_reg; Register decompr_scratch2 = COMPRESS_POINTERS_BOOL ? r12 : no_reg; DCHECK(!AreAliased(receiver, holder, callback, scratch, decompr_scratch1, decompr_scratch2)); // 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); // Insert additional parameters into the stack frame above return address. __ PopReturnAddressTo(scratch); __ Push(receiver); __ PushTaggedAnyField(FieldOperand(callback, AccessorInfo::kDataOffset), decompr_scratch1, decompr_scratch2); __ LoadRoot(kScratchRegister, RootIndex::kUndefinedValue); __ Push(kScratchRegister); // return value __ Push(kScratchRegister); // return value default __ PushAddress(ExternalReference::isolate_address(masm->isolate())); __ Push(holder); __ Push(Smi::zero()); // should_throw_on_error -> false __ PushTaggedPointerField(FieldOperand(callback, AccessorInfo::kNameOffset), decompr_scratch1); __ PushReturnAddressFrom(scratch); // v8::PropertyCallbackInfo::args_ array and name handle. const int kStackUnwindSpace = PropertyCallbackArguments::kArgsLength + 1; // Allocate v8::PropertyCallbackInfo in non-GCed stack space. const int kArgStackSpace = 1; // Load address of v8::PropertyAccessorInfo::args_ array. __ leaq(scratch, Operand(rsp, 2 * kSystemPointerSize)); __ EnterApiExitFrame(kArgStackSpace); // Create v8::PropertyCallbackInfo object on the stack and initialize // it's args_ field. Operand info_object = StackSpaceOperand(0); __ movq(info_object, scratch); __ leaq(name_arg, Operand(scratch, -kSystemPointerSize)); // The context register (rsi) has been saved in EnterApiExitFrame and // could be used to pass arguments. __ leaq(accessor_info_arg, info_object); ExternalReference thunk_ref = ExternalReference::invoke_accessor_getter_callback(); // It's okay if api_function_address == getter_arg // but not accessor_info_arg or name_arg DCHECK(api_function_address != accessor_info_arg); DCHECK(api_function_address != name_arg); __ LoadTaggedPointerField( scratch, FieldOperand(callback, AccessorInfo::kJsGetterOffset)); __ movq(api_function_address, FieldOperand(scratch, Foreign::kForeignAddressOffset)); // +3 is to skip prolog, return address and name handle. Operand return_value_operand( rbp, (PropertyCallbackArguments::kReturnValueOffset + 3) * kSystemPointerSize); Operand* const kUseStackSpaceConstant = nullptr; CallApiFunctionAndReturn(masm, api_function_address, thunk_ref, getter_arg, kStackUnwindSpace, kUseStackSpaceConstant, return_value_operand); } void Builtins::Generate_DirectCEntry(MacroAssembler* masm) { __ int3(); // Unused on this architecture. } #undef __ } // namespace internal } // namespace v8 #endif // V8_TARGET_ARCH_X64