1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
/*
* Copyright (C) 2008, 2012 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef JITCode_h
#define JITCode_h
#if ENABLE(JIT) || ENABLE(LLINT)
#include "CallFrame.h"
#include "Disassembler.h"
#include "JITStubs.h"
#include "JSCJSValue.h"
#include "LegacyProfiler.h"
#include "MacroAssemblerCodeRef.h"
#endif
namespace JSC {
#if ENABLE(JIT)
class VM;
class JSStack;
#endif
class JITCode {
#if ENABLE(JIT) || ENABLE(LLINT)
typedef MacroAssemblerCodeRef CodeRef;
typedef MacroAssemblerCodePtr CodePtr;
#else
JITCode() { }
#endif
public:
enum JITType { None, HostCallThunk, InterpreterThunk, BaselineJIT, DFGJIT };
static JITType bottomTierJIT()
{
return BaselineJIT;
}
static JITType topTierJIT()
{
return DFGJIT;
}
static JITType nextTierJIT(JITType jitType)
{
ASSERT_UNUSED(jitType, jitType == BaselineJIT || jitType == DFGJIT);
return DFGJIT;
}
static bool isOptimizingJIT(JITType jitType)
{
return jitType == DFGJIT;
}
static bool isBaselineCode(JITType jitType)
{
return jitType == InterpreterThunk || jitType == BaselineJIT;
}
#if ENABLE(JIT) || ENABLE(LLINT)
JITCode()
: m_jitType(None)
{
}
JITCode(const CodeRef ref, JITType jitType)
: m_ref(ref)
, m_jitType(jitType)
{
ASSERT(jitType != None);
}
bool operator !() const
{
return !m_ref;
}
CodePtr addressForCall()
{
return m_ref.code();
}
void* executableAddressAtOffset(size_t offset) const
{
ASSERT(offset < size());
return reinterpret_cast<char*>(m_ref.code().executableAddress()) + offset;
}
void* executableAddress() const
{
return executableAddressAtOffset(0);
}
void* dataAddressAtOffset(size_t offset) const
{
ASSERT(offset <= size()); // use <= instead of < because it is valid to ask for an address at the exclusive end of the code.
return reinterpret_cast<char*>(m_ref.code().dataLocation()) + offset;
}
// This function returns the offset in bytes of 'pointerIntoCode' into
// this block of code. The pointer provided must be a pointer into this
// block of code. It is ASSERTed that no codeblock >4gb in size.
unsigned offsetOf(void* pointerIntoCode)
{
intptr_t result = reinterpret_cast<intptr_t>(pointerIntoCode) - reinterpret_cast<intptr_t>(m_ref.code().executableAddress());
ASSERT(static_cast<intptr_t>(static_cast<unsigned>(result)) == result);
return static_cast<unsigned>(result);
}
#if ENABLE(JIT)
// Execute the code!
inline JSValue execute(JSStack* stack, CallFrame* callFrame, VM* vm)
{
JSValue result = JSValue::decode(ctiTrampoline(m_ref.code().executableAddress(), stack, callFrame, 0, 0, vm));
return vm->exception ? jsNull() : result;
}
#endif
void* start() const
{
return m_ref.code().dataLocation();
}
size_t size() const
{
ASSERT(m_ref.code().executableAddress());
return m_ref.size();
}
bool tryToDisassemble(const char* prefix) const
{
return m_ref.tryToDisassemble(prefix);
}
ExecutableMemoryHandle* getExecutableMemory()
{
return m_ref.executableMemory();
}
JITType jitType() const
{
return m_jitType;
}
// Host functions are a bit special; they have a m_code pointer but they
// do not individully ref the executable pool containing the trampoline.
static JITCode HostFunction(CodeRef code)
{
return JITCode(code, HostCallThunk);
}
void clear()
{
m_ref.~CodeRef();
new (NotNull, &m_ref) CodeRef();
}
private:
JITCode(PassRefPtr<ExecutableMemoryHandle> executableMemory, JITType jitType)
: m_ref(executableMemory)
, m_jitType(jitType)
{
}
CodeRef m_ref;
JITType m_jitType;
#endif // ENABLE(JIT) || ENABLE(LLINT)
};
} // namespace JSC
namespace WTF {
class PrintStream;
void printInternal(PrintStream&, JSC::JITCode::JITType);
} // namespace WTF
#endif
|
