1/*
2 * Copyright (C) 2012-2018 Apple Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
17 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 */
25
26#include "config.h"
27#include "LLIntThunks.h"
28
29#include "CallData.h"
30#include "ExceptionHelpers.h"
31#include "Interpreter.h"
32#include "JSCJSValueInlines.h"
33#include "JSInterfaceJIT.h"
34#include "JSObject.h"
35#include "LLIntCLoop.h"
36#include "LLIntData.h"
37#include "LinkBuffer.h"
38#include "LowLevelInterpreter.h"
39#include "ProtoCallFrame.h"
40#include "StackAlignment.h"
41#include "VM.h"
42#include <wtf/NeverDestroyed.h>
43
44namespace JSC {
45
46#if ENABLE(JIT)
47
48namespace LLInt {
49
50// These thunks are necessary because of nearCall used on JITed code.
51// It requires that the distance from nearCall address to the destination address
52// fits on 32-bits, and that's not the case of getCodeRef(llint_function_for_call_prologue)
53// and others LLIntEntrypoints.
54
55static MacroAssemblerCodeRef<JITThunkPtrTag> generateThunkWithJumpTo(OpcodeID opcodeID, const char *thunkKind)
56{
57 JSInterfaceJIT jit;
58
59 // FIXME: there's probably a better way to do it on X86, but I'm not sure I care.
60 LLIntCode target = LLInt::getCodeFunctionPtr<JSEntryPtrTag>(opcodeID);
61 assertIsTaggedWith(target, JSEntryPtrTag);
62
63 jit.move(JSInterfaceJIT::TrustedImmPtr(target), JSInterfaceJIT::regT0);
64 jit.jump(JSInterfaceJIT::regT0, JSEntryPtrTag);
65
66 LinkBuffer patchBuffer(jit, GLOBAL_THUNK_ID);
67 return FINALIZE_CODE(patchBuffer, JITThunkPtrTag, "LLInt %s prologue thunk", thunkKind);
68}
69
70MacroAssemblerCodeRef<JITThunkPtrTag> functionForCallEntryThunk()
71{
72 static LazyNeverDestroyed<MacroAssemblerCodeRef<JITThunkPtrTag>> codeRef;
73 static std::once_flag onceKey;
74 std::call_once(onceKey, [&] {
75 codeRef.construct(generateThunkWithJumpTo(llint_function_for_call_prologue, "function for call"));
76 });
77 return codeRef;
78}
79
80MacroAssemblerCodeRef<JITThunkPtrTag> functionForConstructEntryThunk()
81{
82 static LazyNeverDestroyed<MacroAssemblerCodeRef<JITThunkPtrTag>> codeRef;
83 static std::once_flag onceKey;
84 std::call_once(onceKey, [&] {
85 codeRef.construct(generateThunkWithJumpTo(llint_function_for_construct_prologue, "function for construct"));
86 });
87 return codeRef;
88}
89
90MacroAssemblerCodeRef<JITThunkPtrTag> functionForCallArityCheckThunk()
91{
92 static LazyNeverDestroyed<MacroAssemblerCodeRef<JITThunkPtrTag>> codeRef;
93 static std::once_flag onceKey;
94 std::call_once(onceKey, [&] {
95 codeRef.construct(generateThunkWithJumpTo(llint_function_for_call_arity_check, "function for call with arity check"));
96 });
97 return codeRef;
98}
99
100MacroAssemblerCodeRef<JITThunkPtrTag> functionForConstructArityCheckThunk()
101{
102 static LazyNeverDestroyed<MacroAssemblerCodeRef<JITThunkPtrTag>> codeRef;
103 static std::once_flag onceKey;
104 std::call_once(onceKey, [&] {
105 codeRef.construct(generateThunkWithJumpTo(llint_function_for_construct_arity_check, "function for construct with arity check"));
106 });
107 return codeRef;
108}
109
110MacroAssemblerCodeRef<JITThunkPtrTag> evalEntryThunk()
111{
112 static LazyNeverDestroyed<MacroAssemblerCodeRef<JITThunkPtrTag>> codeRef;
113 static std::once_flag onceKey;
114 std::call_once(onceKey, [&] {
115 codeRef.construct(generateThunkWithJumpTo(llint_eval_prologue, "eval"));
116 });
117 return codeRef;
118}
119
120MacroAssemblerCodeRef<JITThunkPtrTag> programEntryThunk()
121{
122 static LazyNeverDestroyed<MacroAssemblerCodeRef<JITThunkPtrTag>> codeRef;
123 static std::once_flag onceKey;
124 std::call_once(onceKey, [&] {
125 codeRef.construct(generateThunkWithJumpTo(llint_program_prologue, "program"));
126 });
127 return codeRef;
128}
129
130MacroAssemblerCodeRef<JITThunkPtrTag> moduleProgramEntryThunk()
131{
132 static LazyNeverDestroyed<MacroAssemblerCodeRef<JITThunkPtrTag>> codeRef;
133 static std::once_flag onceKey;
134 std::call_once(onceKey, [&] {
135 codeRef.construct(generateThunkWithJumpTo(llint_module_program_prologue, "module_program"));
136 });
137 return codeRef;
138}
139
140} // namespace LLInt
141
142#endif
143
144#if ENABLE(C_LOOP)
145// Non-JIT (i.e. C Loop LLINT) case:
146
147EncodedJSValue vmEntryToJavaScript(void* executableAddress, VM* vm, ProtoCallFrame* protoCallFrame)
148{
149 JSValue result = CLoop::execute(llint_vm_entry_to_javascript, executableAddress, vm, protoCallFrame);
150 return JSValue::encode(result);
151}
152
153EncodedJSValue vmEntryToNative(void* executableAddress, VM* vm, ProtoCallFrame* protoCallFrame)
154{
155 JSValue result = CLoop::execute(llint_vm_entry_to_native, executableAddress, vm, protoCallFrame);
156 return JSValue::encode(result);
157}
158
159extern "C" VMEntryRecord* vmEntryRecord(EntryFrame* entryFrame)
160{
161 // The C Loop doesn't have any callee save registers, so the VMEntryRecord is allocated at the base of the frame.
162 intptr_t stackAlignment = stackAlignmentBytes();
163 intptr_t VMEntryTotalFrameSize = (sizeof(VMEntryRecord) + (stackAlignment - 1)) & ~(stackAlignment - 1);
164 return reinterpret_cast<VMEntryRecord*>(reinterpret_cast<char*>(entryFrame) - VMEntryTotalFrameSize);
165}
166
167#endif // ENABLE(C_LOOP)
168
169} // namespace JSC
170