Roll out r108309, r108323, and r108326
[WebKit-https.git] / Source / JavaScriptCore / interpreter / Interpreter.h
1 /*
2  * Copyright (C) 2008 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  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #ifndef Interpreter_h
30 #define Interpreter_h
31
32 #include "ArgList.h"
33 #include "JSCell.h"
34 #include "JSFunction.h"
35 #include "JSValue.h"
36 #include "JSObject.h"
37 #include "Opcode.h"
38 #include "RegisterFile.h"
39
40 #include <wtf/HashMap.h>
41
42 namespace JSC {
43
44     class CodeBlock;
45     class EvalExecutable;
46     class ExecutableBase;
47     class FunctionExecutable;
48     class JSGlobalObject;
49     class ProgramExecutable;
50     class Register;
51     class ScopeChainNode;
52     class SamplingTool;
53     struct CallFrameClosure;
54     struct HandlerInfo;
55     struct Instruction;
56     
57     enum DebugHookID {
58         WillExecuteProgram,
59         DidExecuteProgram,
60         DidEnterCallFrame,
61         DidReachBreakpoint,
62         WillLeaveCallFrame,
63         WillExecuteStatement
64     };
65
66     enum StackFrameCodeType {
67         StackFrameGlobalCode,
68         StackFrameEvalCode,
69         StackFrameFunctionCode,
70         StackFrameNativeCode
71     };
72
73     struct StackFrame {
74         Strong<JSObject> callee;
75         StackFrameCodeType codeType;
76         Strong<ExecutableBase> executable;
77         int line;
78         UString sourceURL;
79         UString toString(CallFrame* callFrame) const
80         {
81             bool hasSourceURLInfo = !sourceURL.isNull() && !sourceURL.isEmpty();
82             bool hasLineInfo = line > -1;
83             String traceLine;
84             JSObject* stackFrameCallee = callee.get();
85
86             switch (codeType) {
87             case StackFrameEvalCode:
88                 if (hasSourceURLInfo) {
89                     traceLine = hasLineInfo ? String::format("eval code@%s:%d", sourceURL.ascii().data(), line) 
90                                             : String::format("eval code@%s", sourceURL.ascii().data());
91                 } else
92                     traceLine = String::format("eval code");
93                 break;
94             case StackFrameNativeCode: {
95                 if (callee) {
96                     UString functionName = getCalculatedDisplayName(callFrame, stackFrameCallee);
97                     traceLine = String::format("%s@[native code]", functionName.ascii().data());
98                 } else
99                     traceLine = "[native code]";
100                 break;
101             }
102             case StackFrameFunctionCode: {
103                 UString functionName = getCalculatedDisplayName(callFrame, stackFrameCallee);
104                 if (hasSourceURLInfo) {
105                     traceLine = hasLineInfo ? String::format("%s@%s:%d", functionName.ascii().data(), sourceURL.ascii().data(), line)
106                                             : String::format("%s@%s", functionName.ascii().data(), sourceURL.ascii().data());
107                 } else
108                     traceLine = String::format("%s\n", functionName.ascii().data());
109                 break;
110             }
111             case StackFrameGlobalCode:
112                 if (hasSourceURLInfo) {
113                     traceLine = hasLineInfo ? String::format("global code@%s:%d", sourceURL.ascii().data(), line)
114                                             : String::format("global code@%s", sourceURL.ascii().data());
115                 } else
116                     traceLine = String::format("global code");
117                     
118             }
119             return traceLine.impl();
120         }
121     };
122
123     class TopCallFrameSetter {
124     public:
125         TopCallFrameSetter(JSGlobalData& global, CallFrame* callFrame)
126             : globalData(global)
127             , oldCallFrame(global.topCallFrame) 
128         {
129             global.topCallFrame = callFrame;
130         }
131         
132         ~TopCallFrameSetter() 
133         {
134             globalData.topCallFrame = oldCallFrame;
135         }
136     private:
137         JSGlobalData& globalData;
138         CallFrame* oldCallFrame;
139     };
140     
141     class NativeCallFrameTracer {
142     public:
143         ALWAYS_INLINE NativeCallFrameTracer(JSGlobalData* global, CallFrame* callFrame)
144         {
145             ASSERT(global);
146             ASSERT(callFrame);
147             global->topCallFrame = callFrame;
148         }
149     };
150
151     // We use a smaller reentrancy limit on iPhone because of the high amount of
152     // stack space required on the web thread.
153 #if PLATFORM(IOS)
154     enum { MaxLargeThreadReentryDepth = 64, MaxSmallThreadReentryDepth = 16 };
155 #else
156     enum { MaxLargeThreadReentryDepth = 256, MaxSmallThreadReentryDepth = 16 };
157 #endif // PLATFORM(IOS)
158
159     class Interpreter {
160         WTF_MAKE_FAST_ALLOCATED;
161         friend class JIT;
162         friend class CachedCall;
163     public:
164         Interpreter();
165         
166         void initialize(bool canUseJIT);
167
168         RegisterFile& registerFile() { return m_registerFile; }
169         
170         Opcode getOpcode(OpcodeID id)
171         {
172             ASSERT(m_initialized);
173 #if ENABLE(COMPUTED_GOTO_CLASSIC_INTERPRETER)
174             return m_opcodeTable[id];
175 #else
176             return id;
177 #endif
178         }
179
180         OpcodeID getOpcodeID(Opcode opcode)
181         {
182             ASSERT(m_initialized);
183 #if ENABLE(COMPUTED_GOTO_CLASSIC_INTERPRETER)
184             ASSERT(isOpcode(opcode));
185             if (!m_enabled)
186                 return static_cast<OpcodeID>(bitwise_cast<uintptr_t>(opcode));
187
188             return m_opcodeIDTable.get(opcode);
189 #else
190             return opcode;
191 #endif
192         }
193
194         bool isOpcode(Opcode);
195
196         JSValue execute(ProgramExecutable*, CallFrame*, ScopeChainNode*, JSObject* thisObj);
197         JSValue executeCall(CallFrame*, JSObject* function, CallType, const CallData&, JSValue thisValue, const ArgList&);
198         JSObject* executeConstruct(CallFrame*, JSObject* function, ConstructType, const ConstructData&, const ArgList&);
199         JSValue execute(EvalExecutable*, CallFrame*, JSValue thisValue, ScopeChainNode*);
200         JSValue execute(EvalExecutable*, CallFrame*, JSValue thisValue, ScopeChainNode*, int globalRegisterOffset);
201
202         JSValue retrieveArgumentsFromVMCode(CallFrame*, JSFunction*) const;
203         JSValue retrieveCallerFromVMCode(CallFrame*, JSFunction*) const;
204         JS_EXPORT_PRIVATE void retrieveLastCaller(CallFrame*, int& lineNumber, intptr_t& sourceID, UString& sourceURL, JSValue& function) const;
205         
206         void getArgumentsData(CallFrame*, JSFunction*&, ptrdiff_t& firstParameterIndex, Register*& argv, int& argc);
207         
208         SamplingTool* sampler() { return m_sampler.get(); }
209
210         NEVER_INLINE HandlerInfo* throwException(CallFrame*&, JSValue&, unsigned bytecodeOffset);
211         NEVER_INLINE void debug(CallFrame*, DebugHookID, int firstLine, int lastLine);
212         static const UString getTraceLine(CallFrame*, StackFrameCodeType, const UString&, int);
213         JS_EXPORT_PRIVATE static void getStackTrace(JSGlobalData*, int line, Vector<StackFrame>& results);
214
215         void dumpSampleData(ExecState* exec);
216         void startSampling();
217         void stopSampling();
218     private:
219         enum ExecutionFlag { Normal, InitializeAndReturn };
220
221         CallFrameClosure prepareForRepeatCall(FunctionExecutable*, CallFrame*, JSFunction*, int argumentCountIncludingThis, ScopeChainNode*);
222         void endRepeatCall(CallFrameClosure&);
223         JSValue execute(CallFrameClosure&);
224
225 #if ENABLE(CLASSIC_INTERPRETER)
226         NEVER_INLINE bool resolve(CallFrame*, Instruction*, JSValue& exceptionValue);
227         NEVER_INLINE bool resolveSkip(CallFrame*, Instruction*, JSValue& exceptionValue);
228         NEVER_INLINE bool resolveGlobal(CallFrame*, Instruction*, JSValue& exceptionValue);
229         NEVER_INLINE bool resolveGlobalDynamic(CallFrame*, Instruction*, JSValue& exceptionValue);
230         NEVER_INLINE void resolveBase(CallFrame*, Instruction* vPC);
231         NEVER_INLINE bool resolveBaseAndProperty(CallFrame*, Instruction*, JSValue& exceptionValue);
232         NEVER_INLINE bool resolveThisAndProperty(CallFrame*, Instruction*, JSValue& exceptionValue);
233         NEVER_INLINE ScopeChainNode* createExceptionScope(CallFrame*, const Instruction* vPC);
234
235         void tryCacheGetByID(CallFrame*, CodeBlock*, Instruction*, JSValue baseValue, const Identifier& propertyName, const PropertySlot&);
236         void uncacheGetByID(CodeBlock*, Instruction* vPC);
237         void tryCachePutByID(CallFrame*, CodeBlock*, Instruction*, JSValue baseValue, const PutPropertySlot&);
238         void uncachePutByID(CodeBlock*, Instruction* vPC);        
239 #endif // ENABLE(CLASSIC_INTERPRETER)
240
241         NEVER_INLINE bool unwindCallFrame(CallFrame*&, JSValue, unsigned& bytecodeOffset, CodeBlock*&);
242
243         static ALWAYS_INLINE CallFrame* slideRegisterWindowForCall(CodeBlock*, RegisterFile*, CallFrame*, size_t registerOffset, int argc);
244
245         static CallFrame* findFunctionCallFrameFromVMCode(CallFrame*, JSFunction*);
246
247         JSValue privateExecute(ExecutionFlag, RegisterFile*, CallFrame*);
248
249         void dumpCallFrame(CallFrame*);
250         void dumpRegisters(CallFrame*);
251         
252         bool isCallBytecode(Opcode opcode) { return opcode == getOpcode(op_call) || opcode == getOpcode(op_construct) || opcode == getOpcode(op_call_eval); }
253
254         void enableSampler();
255         int m_sampleEntryDepth;
256         OwnPtr<SamplingTool> m_sampler;
257
258         int m_reentryDepth;
259
260         RegisterFile m_registerFile;
261         
262 #if ENABLE(COMPUTED_GOTO_CLASSIC_INTERPRETER)
263         Opcode m_opcodeTable[numOpcodeIDs]; // Maps OpcodeID => Opcode for compiling
264         HashMap<Opcode, OpcodeID> m_opcodeIDTable; // Maps Opcode => OpcodeID for decompiling
265 #endif
266
267 #if !ASSERT_DISABLED
268         bool m_initialized;
269 #endif
270         bool m_enabled;
271     };
272
273     // This value must not be an object that would require this conversion (WebCore's global object).
274     inline bool isValidThisObject(JSValue thisValue, ExecState* exec)
275     {
276         return !thisValue.isObject() || thisValue.toThisObject(exec) == thisValue;
277     }
278
279     inline JSValue Interpreter::execute(EvalExecutable* eval, CallFrame* callFrame, JSValue thisValue, ScopeChainNode* scopeChain)
280     {
281         return execute(eval, callFrame, thisValue, scopeChain, m_registerFile.size() + 1 + RegisterFile::CallFrameHeaderSize);
282     }
283
284     JSValue eval(CallFrame*);
285     CallFrame* loadVarargs(CallFrame*, RegisterFile*, JSValue thisValue, JSValue arguments, int firstFreeRegister);
286
287 } // namespace JSC
288
289 #endif // Interpreter_h