// 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/bits-iterator.h" #include "src/base/iterator.h" #include "src/builtins/builtins-descriptors.h" #include "src/builtins/builtins-inl.h" #include "src/codegen/code-factory.h" #include "src/codegen/interface-descriptors-inl.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/codegen/x64/assembler-x64.h" #include "src/common/globals.h" #include "src/deoptimizer/deoptimizer.h" #include "src/execution/frame-constants.h" #include "src/execution/frames.h" #include "src/heap/heap-inl.h" #include "src/logging/counters.h" #include "src/objects/cell.h" #include "src/objects/code.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" #if V8_ENABLE_WEBASSEMBLY #include "src/wasm/baseline/liftoff-assembler-defs.h" #include "src/wasm/object-access.h" #include "src/wasm/stacks.h" #include "src/wasm/wasm-constants.h" #include "src/wasm/wasm-linkage.h" #include "src/wasm/wasm-objects.h" #endif // V8_ENABLE_WEBASSEMBLY namespace v8 { namespace internal { #define __ … void Builtins::Generate_Adaptor(MacroAssembler* masm, Address address) { … } namespace { constexpr int kReceiverOnStackSize = …; enum class ArgumentsElementType { … }; void Generate_PushArguments(MacroAssembler* masm, Register array, Register argc, Register scratch, ArgumentsElementType element_type) { … } void Generate_JSBuiltinsConstructStubHelper(MacroAssembler* masm) { … } } // namespace // The construct stub for ES5 constructor functions and ES6 class constructors. void Builtins::Generate_JSConstructStubGeneric(MacroAssembler* masm) { … } void Builtins::Generate_JSBuiltinsConstructStub(MacroAssembler* masm) { … } void Builtins::Generate_ConstructedNonConstructable(MacroAssembler* masm) { … } 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, Builtin entry_trampoline) { … } } // namespace void Builtins::Generate_JSEntry(MacroAssembler* masm) { … } void Builtins::Generate_JSConstructEntry(MacroAssembler* masm) { … } void Builtins::Generate_JSRunMicrotasksEntry(MacroAssembler* masm) { … } static void Generate_JSEntryTrampolineHelper(MacroAssembler* masm, bool is_construct) { … } void Builtins::Generate_JSEntryTrampoline(MacroAssembler* masm) { … } void Builtins::Generate_JSConstructEntryTrampoline(MacroAssembler* masm) { … } void Builtins::Generate_RunMicrotasksTrampoline(MacroAssembler* masm) { … } static void AssertCodeIsBaselineAllowClobber(MacroAssembler* masm, Register code, Register scratch) { … } static void AssertCodeIsBaseline(MacroAssembler* masm, Register code, Register scratch) { … } static void CheckSharedFunctionInfoBytecodeOrBaseline(MacroAssembler* masm, Register data, Register scratch, Label* is_baseline, Label* is_bytecode) { … } static void GetSharedFunctionInfoBytecodeOrBaseline( MacroAssembler* masm, Register sfi, Register bytecode, Register scratch1, Label* is_baseline, Label* is_unavailable) { … } // static void Builtins::Generate_ResumeGeneratorTrampoline(MacroAssembler* masm) { … } static void LeaveInterpreterFrame(MacroAssembler* masm, Register scratch1, Register scratch2) { … } // Tail-call |function_id| if |actual_state| == |expected_state| // 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. Will not advance // the bytecode offset if the current bytecode is a JumpLoop, instead just // re-executing the JumpLoop to jump to the correct bytecode. static void AdvanceBytecodeOffsetOrReturn(MacroAssembler* masm, Register bytecode_array, Register bytecode_offset, Register bytecode, Register scratch1, Register scratch2, Label* if_return) { … } namespace { void ResetSharedFunctionInfoAge(MacroAssembler* masm, Register sfi) { … } void ResetJSFunctionAge(MacroAssembler* masm, Register js_function) { … } void ResetFeedbackVectorOsrUrgency(MacroAssembler* masm, Register feedback_vector, Register scratch) { … } } // namespace // 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 live registers are: // o rax: actual argument count // 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 // frame-constants.h for its layout. void Builtins::Generate_InterpreterEntryTrampoline( MacroAssembler* masm, InterpreterEntryTrampolineMode mode) { … } static void GenerateInterpreterPushArgs(MacroAssembler* masm, Register num_args, Register start_address, Register scratch) { … } // static void Builtins::Generate_InterpreterPushArgsThenCallImpl( MacroAssembler* masm, ConvertReceiverMode receiver_mode, InterpreterPushArgsMode mode) { … } // static void Builtins::Generate_InterpreterPushArgsThenConstructImpl( MacroAssembler* masm, InterpreterPushArgsMode mode) { … } // static void Builtins::Generate_ConstructForwardAllArgsImpl( MacroAssembler* masm, ForwardWhichFrame which_frame) { … } namespace { void NewImplicitReceiver(MacroAssembler* masm) { … } } // namespace // static void Builtins::Generate_InterpreterPushArgsThenFastConstructFunction( MacroAssembler* masm) { … } static void Generate_InterpreterEnterBytecode(MacroAssembler* masm) { … } void Builtins::Generate_InterpreterEnterAtNextBytecode(MacroAssembler* masm) { … } void Builtins::Generate_InterpreterEnterAtBytecode(MacroAssembler* masm) { … } // static void Builtins::Generate_BaselineOutOfLinePrologue(MacroAssembler* masm) { … } // static void Builtins::Generate_BaselineOutOfLinePrologueDeopt(MacroAssembler* masm) { … } namespace { void Generate_ContinueToBuiltinHelper(MacroAssembler* masm, bool java_script_builtin, bool with_result) { … } } // namespace void Builtins::Generate_ContinueToCodeStubBuiltin(MacroAssembler* masm) { … } void Builtins::Generate_ContinueToCodeStubBuiltinWithResult( MacroAssembler* masm) { … } void Builtins::Generate_ContinueToJavaScriptBuiltin(MacroAssembler* masm) { … } void Builtins::Generate_ContinueToJavaScriptBuiltinWithResult( MacroAssembler* masm) { … } void Builtins::Generate_NotifyDeoptimized(MacroAssembler* masm) { … } // static void Builtins::Generate_FunctionPrototypeApply(MacroAssembler* masm) { … } // static void Builtins::Generate_FunctionPrototypeCall(MacroAssembler* masm) { … } void Builtins::Generate_ReflectApply(MacroAssembler* masm) { … } void Builtins::Generate_ReflectConstruct(MacroAssembler* masm) { … } namespace { // Allocate new stack space for |count| arguments and shift all existing // arguments already on the stack. |pointer_to_new_space_out| points to the // first free slot on the stack to copy additional arguments to and // |argc_in_out| is updated to include |count|. void Generate_AllocateSpaceAndShiftExistingArguments( MacroAssembler* masm, Register count, Register argc_in_out, Register pointer_to_new_space_out, Register scratch1, Register scratch2) { … } } // namespace // static // TODO(v8:11615): Observe Code::kMaxArguments in CallOrConstructVarargs void Builtins::Generate_CallOrConstructVarargs(MacroAssembler* masm, Builtin target_builtin) { … } // static void Builtins::Generate_CallOrConstructForwardVarargs(MacroAssembler* masm, CallOrConstructMode mode, Builtin target_builtin) { … } // static void Builtins::Generate_CallFunction(MacroAssembler* masm, ConvertReceiverMode mode) { … } namespace { void Generate_PushBoundArguments(MacroAssembler* masm) { … } } // namespace // static void Builtins::Generate_CallBoundFunctionImpl(MacroAssembler* masm) { … } // static void Builtins::Generate_Call(MacroAssembler* masm, ConvertReceiverMode mode) { … } // static void Builtins::Generate_ConstructFunction(MacroAssembler* masm) { … } // static void Builtins::Generate_ConstructBoundFunction(MacroAssembler* masm) { … } // static void Builtins::Generate_Construct(MacroAssembler* masm) { … } namespace { void Generate_OSREntry(MacroAssembler* masm, Register entry_address) { … } enum class OsrSourceTier { … }; void OnStackReplacement(MacroAssembler* masm, OsrSourceTier source, Register maybe_target_code) { … } } // namespace void Builtins::Generate_InterpreterOnStackReplacement(MacroAssembler* masm) { … } void Builtins::Generate_BaselineOnStackReplacement(MacroAssembler* masm) { … } void Builtins::Generate_MaglevOnStackReplacement(MacroAssembler* masm) { … } #ifdef V8_ENABLE_MAGLEV // static void Builtins::Generate_MaglevFunctionEntryStackCheck(MacroAssembler* masm, bool save_new_target) { … } #endif // V8_ENABLE_MAGLEV #if V8_ENABLE_WEBASSEMBLY // Returns the offset beyond the last saved FP register. int SaveWasmParams(MacroAssembler* masm) { … } // Consumes the offset beyond the last saved FP register (as returned by // {SaveWasmParams}). void RestoreWasmParams(MacroAssembler* masm, int offset) { … } // When this builtin is called, the topmost stack entry is the calling pc. // This is replaced with the following: // // [ calling pc ] <-- rsp; popped by {ret}. // [ feedback vector ] // [ Wasm instance data ] // [ WASM frame marker ] // [ saved rbp ] <-- rbp; this is where "calling pc" used to be. void Builtins::Generate_WasmLiftoffFrameSetup(MacroAssembler* masm) { … } void Builtins::Generate_WasmCompileLazy(MacroAssembler* masm) { … } void Builtins::Generate_WasmDebugBreak(MacroAssembler* masm) { … } namespace { // Check that the stack was in the old state (if generated code assertions are // enabled), and switch to the new state. void SwitchStackState(MacroAssembler* masm, Register jmpbuf, wasm::JumpBuffer::StackState old_state, wasm::JumpBuffer::StackState new_state) { … } void FillJumpBuffer(MacroAssembler* masm, Register jmpbuf, Label* pc) { … } void LoadJumpBuffer(MacroAssembler* masm, Register jmpbuf, bool load_pc) { … } void SaveState(MacroAssembler* masm, Register active_continuation, Register tmp, Label* suspend) { … } void LoadTargetJumpBuffer(MacroAssembler* masm, Register target_continuation) { … } // Updates the stack limit to match the new active stack. // Pass the {finished_continuation} argument to indicate that the stack that we // are switching from has returned, and in this case return its memory to the // stack pool. void SwitchStacks(MacroAssembler* masm, Register finished_continuation, const Register& keep1, const Register& keep2 = no_reg, const Register& keep3 = no_reg) { … } void ReloadParentContinuation(MacroAssembler* masm, Register promise, Register return_value, Register context, Register tmp1, Register tmp2) { … } // Loads the context field of the WasmTrustedInstanceData or WasmImportData // depending on the data's type, and places the result in the input register. void GetContextFromImplicitArg(MacroAssembler* masm, Register data) { … } void RestoreParentSuspender(MacroAssembler* masm, Register tmp1, Register tmp2) { … } void ResetStackSwitchFrameStackSlots(MacroAssembler* masm) { … } void SwitchToAllocatedStack(MacroAssembler* masm, Register wasm_instance, Register wrapper_buffer, Register original_fp, Register new_wrapper_buffer, Register scratch, Label* suspend) { … } void SwitchBackAndReturnPromise(MacroAssembler* masm, Register tmp1, Register tmp2, Label* return_promise) { … } void GenerateExceptionHandlingLandingPad(MacroAssembler* masm, Label* return_promise) { … } void JSToWasmWrapperHelper(MacroAssembler* masm, bool stack_switch) { … } } // namespace void Builtins::Generate_JSToWasmWrapperAsm(MacroAssembler* masm) { … } void Builtins::Generate_WasmReturnPromiseOnSuspendAsm(MacroAssembler* masm) { … } void Builtins::Generate_WasmToJsWrapperAsm(MacroAssembler* masm) { … } void Builtins::Generate_WasmTrapHandlerLandingPad(MacroAssembler* masm) { … } void Builtins::Generate_WasmSuspend(MacroAssembler* masm) { … } namespace { // Resume the suspender stored in the closure. We generate two variants of this // builtin: the onFulfilled variant resumes execution at the saved PC and // forwards the value, the onRejected variant throws the value. void Generate_WasmResumeHelper(MacroAssembler* masm, wasm::OnResume on_resume) { … } } // namespace void Builtins::Generate_WasmResume(MacroAssembler* masm) { … } void Builtins::Generate_WasmReject(MacroAssembler* masm) { … } void Builtins::Generate_WasmOnStackReplace(MacroAssembler* masm) { … } namespace { static constexpr Register kOldSPRegister = …; void SwitchToTheCentralStackIfNeeded(MacroAssembler* masm, int r12_stack_slot_index) { … } void SwitchFromTheCentralStackIfNeeded(MacroAssembler* masm, int r12_stack_slot_index) { … } } // namespace void Builtins::Generate_WasmToOnHeapWasmToJsTrampoline(MacroAssembler* masm) { … } #endif // V8_ENABLE_WEBASSEMBLY void Builtins::Generate_CEntry(MacroAssembler* masm, int result_size, ArgvMode argv_mode, bool builtin_exit_frame, bool switch_to_central_stack) { … } #if V8_ENABLE_WEBASSEMBLY void Builtins::Generate_WasmHandleStackOverflow(MacroAssembler* masm) { … } #endif // V8_ENABLE_WEBASSEMBLY void Builtins::Generate_DoubleToI(MacroAssembler* masm) { … } // 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_CallApiCallbackImpl(MacroAssembler* masm, CallApiCallbackMode mode) { … } void Builtins::Generate_CallApiGetter(MacroAssembler* masm) { … } void Builtins::Generate_DirectCEntry(MacroAssembler* masm) { … } namespace { void Generate_DeoptimizationEntry(MacroAssembler* masm, DeoptimizeKind deopt_kind) { … } } // namespace void Builtins::Generate_DeoptimizationEntry_Eager(MacroAssembler* masm) { … } void Builtins::Generate_DeoptimizationEntry_Lazy(MacroAssembler* masm) { … } namespace { // Restarts execution either at the current or next (in execution order) // bytecode. If there is baseline code on the shared function info, converts an // interpreter frame into a baseline frame and continues execution in baseline // code. Otherwise execution continues with bytecode. void Generate_BaselineOrInterpreterEntry(MacroAssembler* masm, bool next_bytecode, bool is_osr = false) { … } } // namespace void Builtins::Generate_BaselineOrInterpreterEnterAtBytecode( MacroAssembler* masm) { … } void Builtins::Generate_BaselineOrInterpreterEnterAtNextBytecode( MacroAssembler* masm) { … } void Builtins::Generate_InterpreterOnStackReplacement_ToBaseline( MacroAssembler* masm) { … } void Builtins::Generate_RestartFrameTrampoline(MacroAssembler* masm) { … } #undef __ } // namespace internal } // namespace v8 #endif // V8_TARGET_ARCH_X64
Codebase Browser
chromium