Restore CodeBlock jettison code to jettison when a CodeBlock has been alive for a...
[WebKit-https.git] / Source / JavaScriptCore / interpreter / CallFrame.h
1 /*
2  *  Copyright (C) 1999-2001 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
4  *  Copyright (C) 2003, 2007-2008, 2011, 2013-2016 Apple Inc. All rights reserved.
5  *
6  *  This library is free software; you can redistribute it and/or
7  *  modify it under the terms of the GNU Library General Public
8  *  License as published by the Free Software Foundation; either
9  *  version 2 of the License, or (at your option) any later version.
10  *
11  *  This library is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  *  Library General Public License for more details.
15  *
16  *  You should have received a copy of the GNU Library General Public License
17  *  along with this library; see the file COPYING.LIB.  If not, write to
18  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  *  Boston, MA 02110-1301, USA.
20  *
21  */
22
23 #ifndef CallFrame_h
24 #define CallFrame_h
25
26 #include "AbstractPC.h"
27 #include "MacroAssemblerCodeRef.h"
28 #include "Register.h"
29 #include "StackVisitor.h"
30 #include "VM.h"
31 #include "VMEntryRecord.h"
32
33 namespace JSC  {
34
35     class Arguments;
36     class ExecState;
37     class Interpreter;
38     class JSCallee;
39     class JSScope;
40
41     struct Instruction;
42
43     typedef ExecState CallFrame;
44
45     struct CallSiteIndex {
46         CallSiteIndex()
47             : m_bits(UINT_MAX)
48         {
49         }
50         
51         explicit CallSiteIndex(uint32_t bits)
52             : m_bits(bits)
53         { }
54 #if USE(JSVALUE32_64)
55         explicit CallSiteIndex(Instruction* instruction)
56             : m_bits(bitwise_cast<uint32_t>(instruction))
57         { }
58 #endif
59
60         explicit operator bool() const { return m_bits != UINT_MAX; }
61         
62         inline uint32_t bits() const { return m_bits; }
63
64     private:
65         uint32_t m_bits;
66     };
67
68     struct CallerFrameAndPC {
69         CallFrame* callerFrame;
70         Instruction* pc;
71         static const int sizeInRegisters = 2 * sizeof(void*) / sizeof(Register);
72     };
73     static_assert(CallerFrameAndPC::sizeInRegisters == sizeof(CallerFrameAndPC) / sizeof(Register), "CallerFrameAndPC::sizeInRegisters is incorrect.");
74
75     struct CallFrameSlot {
76         static const int codeBlock = CallerFrameAndPC::sizeInRegisters;
77         static const int callee = codeBlock + 1;
78         static const int argumentCount = callee + 1;
79         static const int thisArgument = argumentCount + 1;
80         static const int firstArgument = thisArgument + 1;
81     };
82
83     // Represents the current state of script execution.
84     // Passed as the first argument to most functions.
85     class ExecState : private Register {
86     public:
87         static const int headerSizeInRegisters = CallFrameSlot::argumentCount + 1;
88
89         JSValue calleeAsValue() const { return this[CallFrameSlot::callee].jsValue(); }
90         JSObject* callee() const { return this[CallFrameSlot::callee].object(); }
91         SUPPRESS_ASAN JSValue unsafeCallee() const { return this[CallFrameSlot::callee].asanUnsafeJSValue(); }
92         CodeBlock* codeBlock() const { return this[CallFrameSlot::codeBlock].Register::codeBlock(); }
93         CodeBlock** addressOfCodeBlock() const { return bitwise_cast<CodeBlock**>(this + CallFrameSlot::codeBlock); }
94         SUPPRESS_ASAN CodeBlock* unsafeCodeBlock() const { return this[CallFrameSlot::codeBlock].Register::asanUnsafeCodeBlock(); }
95         JSScope* scope(int scopeRegisterOffset) const
96         {
97             ASSERT(this[scopeRegisterOffset].Register::scope());
98             return this[scopeRegisterOffset].Register::scope();
99         }
100
101         // Global object in which execution began.
102         JS_EXPORT_PRIVATE JSGlobalObject* vmEntryGlobalObject();
103
104         // Global object in which the currently executing code was defined.
105         // Differs from vmEntryGlobalObject() during function calls across web browser frames.
106         JSGlobalObject* lexicalGlobalObject() const;
107
108         // Differs from lexicalGlobalObject because this will have DOM window shell rather than
109         // the actual DOM window, which can't be "this" for security reasons.
110         JSObject* globalThisValue() const;
111
112         VM& vm() const;
113
114         // Convenience functions for access to global data.
115         // It takes a few memory references to get from a call frame to the global data
116         // pointer, so these are inefficient, and should be used sparingly in new code.
117         // But they're used in many places in legacy code, so they're not going away any time soon.
118
119         void clearException() { vm().clearException(); }
120
121         Exception* exception() const { return vm().exception(); }
122         bool hadException() const { return !!vm().exception(); }
123
124         Exception* lastException() const { return vm().lastException(); }
125         void clearLastException() { vm().clearLastException(); }
126
127         AtomicStringTable* atomicStringTable() const { return vm().atomicStringTable(); }
128         const CommonIdentifiers& propertyNames() const { return *vm().propertyNames; }
129         const MarkedArgumentBuffer& emptyList() const { return *vm().emptyList; }
130         Interpreter* interpreter() { return vm().interpreter; }
131         Heap* heap() { return &vm().heap; }
132
133
134         static CallFrame* create(Register* callFrameBase) { return static_cast<CallFrame*>(callFrameBase); }
135         Register* registers() { return this; }
136         const Register* registers() const { return this; }
137
138         CallFrame& operator=(const Register& r) { *static_cast<Register*>(this) = r; return *this; }
139
140         CallFrame* callerFrame() const { return static_cast<CallFrame*>(callerFrameOrVMEntryFrame()); }
141         void* callerFrameOrVMEntryFrame() const { return callerFrameAndPC().callerFrame; }
142         SUPPRESS_ASAN void* unsafeCallerFrameOrVMEntryFrame() const { return unsafeCallerFrameAndPC().callerFrame; }
143
144         CallFrame* unsafeCallerFrame(VMEntryFrame*&);
145         JS_EXPORT_PRIVATE CallFrame* callerFrame(VMEntryFrame*&);
146
147         static ptrdiff_t callerFrameOffset() { return OBJECT_OFFSETOF(CallerFrameAndPC, callerFrame); }
148
149         ReturnAddressPtr returnPC() const { return ReturnAddressPtr(callerFrameAndPC().pc); }
150         bool hasReturnPC() const { return !!callerFrameAndPC().pc; }
151         void clearReturnPC() { callerFrameAndPC().pc = 0; }
152         static ptrdiff_t returnPCOffset() { return OBJECT_OFFSETOF(CallerFrameAndPC, pc); }
153         AbstractPC abstractReturnPC(VM& vm) { return AbstractPC(vm, this); }
154
155         bool callSiteBitsAreBytecodeOffset() const;
156         bool callSiteBitsAreCodeOriginIndex() const;
157
158         unsigned callSiteAsRawBits() const;
159         unsigned unsafeCallSiteAsRawBits() const;
160         CallSiteIndex callSiteIndex() const;
161         CallSiteIndex unsafeCallSiteIndex() const;
162     private:
163         unsigned callSiteBitsAsBytecodeOffset() const;
164     public:
165
166         // This will try to get you the bytecode offset, but you should be aware that
167         // this bytecode offset may be bogus in the presence of inlining. This will
168         // also return 0 if the call frame has no notion of bytecode offsets (for
169         // example if it's native code).
170         // https://bugs.webkit.org/show_bug.cgi?id=121754
171         unsigned bytecodeOffset();
172         
173         // This will get you a CodeOrigin. It will always succeed. May return
174         // CodeOrigin(0) if we're in native code.
175         JS_EXPORT_PRIVATE CodeOrigin codeOrigin();
176
177         Register* topOfFrame()
178         {
179             if (!codeBlock())
180                 return registers();
181             return topOfFrameInternal();
182         }
183     
184         Instruction* currentVPC() const; // This only makes sense in the LLInt and baseline.
185         void setCurrentVPC(Instruction* vpc);
186
187         void setCallerFrame(CallFrame* frame) { callerFrameAndPC().callerFrame = frame; }
188         void setScope(int scopeRegisterOffset, JSScope* scope) { static_cast<Register*>(this)[scopeRegisterOffset] = scope; }
189
190         static void initGlobalExec(ExecState* globalExec, JSCallee* globalCallee);
191
192         // Read a register from the codeframe (or constant from the CodeBlock).
193         Register& r(int);
194         Register& r(VirtualRegister);
195         // Read a register for a non-constant
196         Register& uncheckedR(int);
197         Register& uncheckedR(VirtualRegister);
198
199         // Access to arguments as passed. (After capture, arguments may move to a different location.)
200         size_t argumentCount() const { return argumentCountIncludingThis() - 1; }
201         size_t argumentCountIncludingThis() const { return this[CallFrameSlot::argumentCount].payload(); }
202         static int argumentOffset(int argument) { return (CallFrameSlot::firstArgument + argument); }
203         static int argumentOffsetIncludingThis(int argument) { return (CallFrameSlot::thisArgument + argument); }
204
205         // In the following (argument() and setArgument()), the 'argument'
206         // parameter is the index of the arguments of the target function of
207         // this frame. The index starts at 0 for the first arg, 1 for the
208         // second, etc.
209         //
210         // The arguments (in this case) do not include the 'this' value.
211         // arguments(0) will not fetch the 'this' value. To get/set 'this',
212         // use thisValue() and setThisValue() below.
213
214         JSValue argument(size_t argument)
215         {
216             if (argument >= argumentCount())
217                  return jsUndefined();
218             return getArgumentUnsafe(argument);
219         }
220         JSValue uncheckedArgument(size_t argument)
221         {
222             ASSERT(argument < argumentCount());
223             return getArgumentUnsafe(argument);
224         }
225         void setArgument(size_t argument, JSValue value)
226         {
227             this[argumentOffset(argument)] = value;
228         }
229
230         JSValue getArgumentUnsafe(size_t argIndex)
231         {
232             // User beware! This method does not verify that there is a valid
233             // argument at the specified argIndex. This is used for debugging
234             // and verification code only. The caller is expected to know what
235             // he/she is doing when calling this method.
236             return this[argumentOffset(argIndex)].jsValue();
237         }
238
239         static int thisArgumentOffset() { return argumentOffsetIncludingThis(0); }
240         JSValue thisValue() { return this[thisArgumentOffset()].jsValue(); }
241         void setThisValue(JSValue value) { this[thisArgumentOffset()] = value; }
242
243         // Under the constructor implemented in C++, thisValue holds the newTarget instead of the automatically constructed value.
244         // The result of this function is only effective under the "construct" context.
245         JSValue newTarget() { return thisValue(); }
246
247         JSValue argumentAfterCapture(size_t argument);
248
249         static int offsetFor(size_t argumentCountIncludingThis) { return argumentCountIncludingThis + CallFrameSlot::thisArgument - 1; }
250
251         static CallFrame* noCaller() { return 0; }
252
253         void setArgumentCountIncludingThis(int count) { static_cast<Register*>(this)[CallFrameSlot::argumentCount].payload() = count; }
254         void setCallee(JSObject* callee) { static_cast<Register*>(this)[CallFrameSlot::callee] = callee; }
255         void setCodeBlock(CodeBlock* codeBlock) { static_cast<Register*>(this)[CallFrameSlot::codeBlock] = codeBlock; }
256         void setReturnPC(void* value) { callerFrameAndPC().pc = reinterpret_cast<Instruction*>(value); }
257
258         String friendlyFunctionName();
259
260         // CallFrame::iterate() expects a Functor that implements the following method:
261         //     StackVisitor::Status operator()(StackVisitor&) const;
262         // FIXME: This method is improper. We rely on the fact that we can call it with a null
263         // receiver. We should always be using StackVisitor directly.
264         template <typename Functor> void iterate(const Functor& functor)
265         {
266             StackVisitor::visit<Functor>(this, functor);
267         }
268
269         void dump(PrintStream&);
270         JS_EXPORT_PRIVATE const char* describeFrame();
271
272     private:
273
274         ExecState();
275         ~ExecState();
276
277         Register* topOfFrameInternal();
278
279         // The following are for internal use in debugging and verification
280         // code only and not meant as an API for general usage:
281
282         size_t argIndexForRegister(Register* reg)
283         {
284             // The register at 'offset' number of slots from the frame pointer
285             // i.e.
286             //       reg = frame[offset];
287             //   ==> reg = frame + offset;
288             //   ==> offset = reg - frame;
289             int offset = reg - this->registers();
290
291             // The offset is defined (based on argumentOffset()) to be:
292             //       offset = CallFrameSlot::firstArgument - argIndex;
293             // Hence:
294             //       argIndex = CallFrameSlot::firstArgument - offset;
295             size_t argIndex = offset - CallFrameSlot::firstArgument;
296             return argIndex;
297         }
298
299         CallerFrameAndPC& callerFrameAndPC() { return *reinterpret_cast<CallerFrameAndPC*>(this); }
300         const CallerFrameAndPC& callerFrameAndPC() const { return *reinterpret_cast<const CallerFrameAndPC*>(this); }
301         SUPPRESS_ASAN const CallerFrameAndPC& unsafeCallerFrameAndPC() const { return *reinterpret_cast<const CallerFrameAndPC*>(this); }
302     };
303
304 } // namespace JSC
305
306 #endif // CallFrame_h