Remove excessive headers from JavaScriptCore
[WebKit-https.git] / Source / JavaScriptCore / interpreter / Interpreter.h
1 /*
2  * Copyright (C) 2008-2017 Apple Inc. All rights reserved.
3  * Copyright (C) 2012 Research In Motion Limited. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * 1.  Redistributions of source code must retain the above copyright
10  *     notice, this list of conditions and the following disclaimer.
11  * 2.  Redistributions in binary form must reproduce the above copyright
12  *     notice, this list of conditions and the following disclaimer in the
13  *     documentation and/or other materials provided with the distribution.
14  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
15  *     its contributors may be used to endorse or promote products derived
16  *     from this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #pragma once
31
32 #include "ArgList.h"
33 #include "JSCJSValue.h"
34 #include "JSObject.h"
35 #include "Opcode.h"
36 #include "StackAlignment.h"
37 #include <wtf/HashMap.h>
38
39 #if !ENABLE(JIT)
40 #include "CLoopStack.h"
41 #endif
42
43
44 namespace JSC {
45
46     class CodeBlock;
47     class EvalExecutable;
48     class FunctionExecutable;
49     class VM;
50     class JSFunction;
51     class JSGlobalObject;
52     class JSModuleEnvironment;
53     class JSModuleRecord;
54     class LLIntOffsetsExtractor;
55     class ProgramExecutable;
56     class ModuleProgramExecutable;
57     class Register;
58     class JSScope;
59     class SourceCode;
60     class StackFrame;
61     struct CallFrameClosure;
62     struct HandlerInfo;
63     struct Instruction;
64     struct ProtoCallFrame;
65     struct UnlinkedInstruction;
66
67     enum UnwindStart : uint8_t { UnwindFromCurrentFrame, UnwindFromCallerFrame };
68
69     enum DebugHookType {
70         WillExecuteProgram,
71         DidExecuteProgram,
72         DidEnterCallFrame,
73         DidReachBreakpoint,
74         WillLeaveCallFrame,
75         WillExecuteStatement,
76         WillExecuteExpression,
77     };
78
79     enum StackFrameCodeType {
80         StackFrameGlobalCode,
81         StackFrameEvalCode,
82         StackFrameModuleCode,
83         StackFrameFunctionCode,
84         StackFrameNativeCode
85     };
86
87     class Interpreter {
88         WTF_MAKE_FAST_ALLOCATED;
89         friend class CachedCall;
90         friend class LLIntOffsetsExtractor;
91         friend class JIT;
92         friend class VM;
93
94     public:
95         Interpreter(VM &);
96         ~Interpreter();
97         
98 #if !ENABLE(JIT)
99         CLoopStack& cloopStack() { return m_cloopStack; }
100 #endif
101         
102         static inline Opcode getOpcode(OpcodeID);
103
104         static inline OpcodeID getOpcodeID(Opcode);
105         static inline OpcodeID getOpcodeID(const Instruction&);
106         static inline OpcodeID getOpcodeID(const UnlinkedInstruction&);
107
108 #if !ASSERT_DISABLED
109         static bool isOpcode(Opcode);
110 #endif
111
112         JSValue executeProgram(const SourceCode&, CallFrame*, JSObject* thisObj);
113         JSValue executeModuleProgram(ModuleProgramExecutable*, CallFrame*, JSModuleEnvironment*);
114         JSValue executeCall(CallFrame*, JSObject* function, CallType, const CallData&, JSValue thisValue, const ArgList&);
115         JSObject* executeConstruct(CallFrame*, JSObject* function, ConstructType, const ConstructData&, const ArgList&, JSValue newTarget);
116         JSValue execute(EvalExecutable*, CallFrame*, JSValue thisValue, JSScope*);
117
118         void getArgumentsData(CallFrame*, JSFunction*&, ptrdiff_t& firstParameterIndex, Register*& argv, int& argc);
119         
120         NEVER_INLINE HandlerInfo* unwind(VM&, CallFrame*&, Exception*, UnwindStart);
121         void notifyDebuggerOfExceptionToBeThrown(VM&, CallFrame*, Exception*);
122         NEVER_INLINE void debug(CallFrame*, DebugHookType);
123         static JSString* stackTraceAsString(VM&, const Vector<StackFrame>&);
124
125         static EncodedJSValue JSC_HOST_CALL constructWithErrorConstructor(ExecState*);
126         static EncodedJSValue JSC_HOST_CALL callErrorConstructor(ExecState*);
127         static EncodedJSValue JSC_HOST_CALL constructWithNativeErrorConstructor(ExecState*);
128         static EncodedJSValue JSC_HOST_CALL callNativeErrorConstructor(ExecState*);
129
130         JS_EXPORT_PRIVATE void dumpCallFrame(CallFrame*);
131
132         void getStackTrace(Vector<StackFrame>& results, size_t framesToSkip = 0, size_t maxStackSize = std::numeric_limits<size_t>::max());
133
134     private:
135         enum ExecutionFlag { Normal, InitializeAndReturn };
136
137         CallFrameClosure prepareForRepeatCall(FunctionExecutable*, CallFrame*, ProtoCallFrame*, JSFunction*, int argumentCountIncludingThis, JSScope*, const ArgList&);
138
139         JSValue execute(CallFrameClosure&);
140
141
142
143         void dumpRegisters(CallFrame*);
144         
145         VM& m_vm;
146 #if !ENABLE(JIT)
147         CLoopStack m_cloopStack;
148 #endif
149         
150 #if ENABLE(COMPUTED_GOTO_OPCODES)
151 #if !USE(LLINT_EMBEDDED_OPCODE_ID) || !ASSERT_DISABLED
152         static HashMap<Opcode, OpcodeID>& opcodeIDTable(); // Maps Opcode => OpcodeID.
153 #endif // !USE(LLINT_EMBEDDED_OPCODE_ID) || !ASSERT_DISABLED
154 #endif // ENABLE(COMPUTED_GOTO_OPCODES)
155     };
156
157     JSValue eval(CallFrame*);
158
159     inline CallFrame* calleeFrameForVarargs(CallFrame* callFrame, unsigned numUsedStackSlots, unsigned argumentCountIncludingThis)
160     {
161         // We want the new frame to be allocated on a stack aligned offset with a stack
162         // aligned size. Align the size here.
163         argumentCountIncludingThis = WTF::roundUpToMultipleOf(
164             stackAlignmentRegisters(),
165             argumentCountIncludingThis + CallFrame::headerSizeInRegisters) - CallFrame::headerSizeInRegisters;
166
167         // Align the frame offset here.
168         unsigned paddedCalleeFrameOffset = WTF::roundUpToMultipleOf(
169             stackAlignmentRegisters(),
170             numUsedStackSlots + argumentCountIncludingThis + CallFrame::headerSizeInRegisters);
171         return CallFrame::create(callFrame->registers() - paddedCalleeFrameOffset);
172     }
173
174     unsigned sizeOfVarargs(CallFrame* exec, JSValue arguments, uint32_t firstVarArgOffset);
175     static const unsigned maxArguments = 0x10000;
176     unsigned sizeFrameForVarargs(CallFrame* exec, VM&, JSValue arguments, unsigned numUsedStackSlots, uint32_t firstVarArgOffset);
177     unsigned sizeFrameForForwardArguments(CallFrame* exec, VM&, unsigned numUsedStackSlots);
178     void loadVarargs(CallFrame* execCaller, VirtualRegister firstElementDest, JSValue source, uint32_t offset, uint32_t length);
179     void setupVarargsFrame(CallFrame* execCaller, CallFrame* execCallee, JSValue arguments, uint32_t firstVarArgOffset, uint32_t length);
180     void setupVarargsFrameAndSetThis(CallFrame* execCaller, CallFrame* execCallee, JSValue thisValue, JSValue arguments, uint32_t firstVarArgOffset, uint32_t length);
181     void setupForwardArgumentsFrame(CallFrame* execCaller, CallFrame* execCallee, uint32_t length);
182     void setupForwardArgumentsFrameAndSetThis(CallFrame* execCaller, CallFrame* execCallee, JSValue thisValue, uint32_t length);
183     
184 } // namespace JSC