/*
- * Copyright (C) 2008 Apple Inc. All rights reserved.
+ * Copyright (C) 2008, 2013, 2015 Apple Inc. All rights reserved.
+ * Copyright (C) 2012 Research In Motion Limited. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* 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.
- * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ * 3. Neither the name of Apple Inc. ("Apple") nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
#define Interpreter_h
#include "ArgList.h"
+#include "JSCJSValue.h"
#include "JSCell.h"
-#include "JSValue.h"
#include "JSObject.h"
+#include "JSStack.h"
+#include "LLIntData.h"
#include "Opcode.h"
-#include "RegisterFile.h"
+#include "SourceProvider.h"
+#include "StackAlignment.h"
#include <wtf/HashMap.h>
+#include <wtf/text/StringBuilder.h>
namespace JSC {
class CodeBlock;
class EvalExecutable;
+ class ExecutableBase;
class FunctionExecutable;
+ class VM;
class JSFunction;
class JSGlobalObject;
+ class LLIntOffsetsExtractor;
class ProgramExecutable;
class Register;
- class ScopeChainNode;
+ class JSScope;
class SamplingTool;
struct CallFrameClosure;
struct HandlerInfo;
struct Instruction;
-
+ struct ProtoCallFrame;
+
enum DebugHookID {
WillExecuteProgram,
DidExecuteProgram,
WillExecuteStatement
};
- // We use a smaller reentrancy limit on iPhone because of the high amount of
- // stack space required on the web thread.
- enum { MaxLargeThreadReentryDepth = 93, MaxSmallThreadReentryDepth = 32 };
+ enum StackFrameCodeType {
+ StackFrameGlobalCode,
+ StackFrameEvalCode,
+ StackFrameFunctionCode,
+ StackFrameNativeCode
+ };
+
+ struct StackFrame {
+ Strong<JSObject> callee;
+ StackFrameCodeType codeType;
+ Strong<ScriptExecutable> executable;
+ Strong<UnlinkedCodeBlock> codeBlock;
+ RefPtr<SourceProvider> code;
+ int lineOffset;
+ unsigned firstLineColumnOffset;
+ unsigned characterOffset;
+ unsigned bytecodeOffset;
+ String sourceURL;
+ JS_EXPORT_PRIVATE String toString(CallFrame*);
+ String friendlySourceURL() const;
+ String friendlyFunctionName(CallFrame*) const;
+ JS_EXPORT_PRIVATE void computeLineAndColumn(unsigned& line, unsigned& column);
+
+ private:
+ void expressionInfo(int& divot, int& startOffset, int& endOffset, unsigned& line, unsigned& column);
+ };
+
+ class SuspendExceptionScope {
+ public:
+ SuspendExceptionScope(VM* vm)
+ : m_vm(vm)
+ {
+ oldException = vm->exception();
+ vm->clearException();
+ }
+ ~SuspendExceptionScope()
+ {
+ m_vm->setException(oldException);
+ }
+ private:
+ Exception* oldException;
+ VM* m_vm;
+ };
+
+ class TopCallFrameSetter {
+ public:
+ TopCallFrameSetter(VM& currentVM, CallFrame* callFrame)
+ : vm(currentVM)
+ , oldCallFrame(currentVM.topCallFrame)
+ {
+ currentVM.topCallFrame = callFrame;
+ }
+
+ ~TopCallFrameSetter()
+ {
+ vm.topCallFrame = oldCallFrame;
+ }
+ private:
+ VM& vm;
+ CallFrame* oldCallFrame;
+ };
+
+ class NativeCallFrameTracer {
+ public:
+ ALWAYS_INLINE NativeCallFrameTracer(VM* vm, CallFrame* callFrame)
+ {
+ ASSERT(vm);
+ ASSERT(callFrame);
+ vm->topCallFrame = callFrame;
+ }
+ };
+
+ class NativeCallFrameTracerWithRestore {
+ public:
+ ALWAYS_INLINE NativeCallFrameTracerWithRestore(VM* vm, VMEntryFrame* vmEntryFrame, CallFrame* callFrame)
+ : m_vm(vm)
+ {
+ ASSERT(vm);
+ ASSERT(callFrame);
+ m_savedTopVMEntryFrame = vm->topVMEntryFrame;
+ m_savedTopCallFrame = vm->topCallFrame;
+ vm->topVMEntryFrame = vmEntryFrame;
+ vm->topCallFrame = callFrame;
+ }
+
+ ALWAYS_INLINE ~NativeCallFrameTracerWithRestore()
+ {
+ m_vm->topVMEntryFrame = m_savedTopVMEntryFrame;
+ m_vm->topCallFrame = m_savedTopCallFrame;
+ }
+
+ private:
+ VM* m_vm;
+ VMEntryFrame* m_savedTopVMEntryFrame;
+ CallFrame* m_savedTopCallFrame;
+ };
class Interpreter {
WTF_MAKE_FAST_ALLOCATED;
- friend class JIT;
friend class CachedCall;
+ friend class LLIntOffsetsExtractor;
+ friend class JIT;
+ friend class VM;
+
public:
- Interpreter(JSGlobalData&);
+ Interpreter(VM &);
+ ~Interpreter();
+
+ void initialize(bool canUseJIT);
- RegisterFile& registerFile() { return m_registerFile; }
+ JSStack& stack() { return m_stack; }
Opcode getOpcode(OpcodeID id)
{
- #if ENABLE(COMPUTED_GOTO_INTERPRETER)
- return m_opcodeTable[id];
- #else
- return id;
- #endif
+ ASSERT(m_initialized);
+#if ENABLE(COMPUTED_GOTO_OPCODES)
+ return m_opcodeTable[id];
+#else
+ return id;
+#endif
}
OpcodeID getOpcodeID(Opcode opcode)
{
- #if ENABLE(COMPUTED_GOTO_INTERPRETER)
- ASSERT(isOpcode(opcode));
- return m_opcodeIDTable.get(opcode);
- #else
- return opcode;
- #endif
+ ASSERT(m_initialized);
+#if ENABLE(COMPUTED_GOTO_OPCODES)
+ ASSERT(isOpcode(opcode));
+ return m_opcodeIDTable.get(opcode);
+#else
+ return opcode;
+#endif
}
-
+
bool isOpcode(Opcode);
- JSValue execute(ProgramExecutable*, CallFrame*, ScopeChainNode*, JSObject* thisObj);
+ JSValue execute(ProgramExecutable*, CallFrame*, JSObject* thisObj);
JSValue executeCall(CallFrame*, JSObject* function, CallType, const CallData&, JSValue thisValue, const ArgList&);
JSObject* executeConstruct(CallFrame*, JSObject* function, ConstructType, const ConstructData&, const ArgList&);
- JSValue execute(EvalExecutable* evalNode, CallFrame* exec, JSObject* thisObj, ScopeChainNode* scopeChain);
+ JSValue execute(EvalExecutable*, CallFrame*, JSValue thisValue, JSScope*);
- JSValue retrieveArguments(CallFrame*, JSFunction*) const;
- JSValue retrieveCaller(CallFrame*, JSFunction*) const;
- void retrieveLastCaller(CallFrame*, int& lineNumber, intptr_t& sourceID, UString& sourceURL, JSValue& function) const;
-
void getArgumentsData(CallFrame*, JSFunction*&, ptrdiff_t& firstParameterIndex, Register*& argv, int& argc);
SamplingTool* sampler() { return m_sampler.get(); }
- NEVER_INLINE JSValue callEval(CallFrame*, RegisterFile*, Register* argv, int argc, int registerOffset);
- NEVER_INLINE HandlerInfo* throwException(CallFrame*&, JSValue&, unsigned bytecodeOffset);
- NEVER_INLINE void debug(CallFrame*, DebugHookID, int firstLine, int lastLine);
+ NEVER_INLINE HandlerInfo* unwind(VMEntryFrame*&, CallFrame*&, Exception*);
+ NEVER_INLINE void debug(CallFrame*, DebugHookID);
+ JSString* stackTraceAsString(ExecState*, Vector<StackFrame>);
+
+ static EncodedJSValue JSC_HOST_CALL constructWithErrorConstructor(ExecState*);
+ static EncodedJSValue JSC_HOST_CALL callErrorConstructor(ExecState*);
+ static EncodedJSValue JSC_HOST_CALL constructWithNativeErrorConstructor(ExecState*);
+ static EncodedJSValue JSC_HOST_CALL callNativeErrorConstructor(ExecState*);
void dumpSampleData(ExecState* exec);
void startSampling();
void stopSampling();
- private:
- enum ExecutionFlag { Normal, InitializeAndReturn };
- CallFrameClosure prepareForRepeatCall(FunctionExecutable*, CallFrame*, JSFunction*, int argCount, ScopeChainNode*);
- void endRepeatCall(CallFrameClosure&);
- JSValue execute(CallFrameClosure&);
-
- JSValue execute(EvalExecutable*, CallFrame*, JSObject* thisObject, int globalRegisterOffset, ScopeChainNode*);
+ JS_EXPORT_PRIVATE void dumpCallFrame(CallFrame*);
-#if ENABLE(INTERPRETER)
- NEVER_INLINE bool resolve(CallFrame*, Instruction*, JSValue& exceptionValue);
- NEVER_INLINE bool resolveSkip(CallFrame*, Instruction*, JSValue& exceptionValue);
- NEVER_INLINE bool resolveGlobal(CallFrame*, Instruction*, JSValue& exceptionValue);
- NEVER_INLINE bool resolveGlobalDynamic(CallFrame*, Instruction*, JSValue& exceptionValue);
- NEVER_INLINE void resolveBase(CallFrame*, Instruction* vPC);
- NEVER_INLINE bool resolveBaseAndProperty(CallFrame*, Instruction*, JSValue& exceptionValue);
- NEVER_INLINE ScopeChainNode* createExceptionScope(CallFrame*, const Instruction* vPC);
+ void getStackTrace(Vector<StackFrame>& results, size_t maxStackSize = std::numeric_limits<size_t>::max());
- void tryCacheGetByID(CallFrame*, CodeBlock*, Instruction*, JSValue baseValue, const Identifier& propertyName, const PropertySlot&);
- void uncacheGetByID(CodeBlock*, Instruction* vPC);
- void tryCachePutByID(CallFrame*, CodeBlock*, Instruction*, JSValue baseValue, const PutPropertySlot&);
- void uncachePutByID(CodeBlock*, Instruction* vPC);
-#endif // ENABLE(INTERPRETER)
+ private:
+ enum ExecutionFlag { Normal, InitializeAndReturn };
- NEVER_INLINE bool unwindCallFrame(CallFrame*&, JSValue, unsigned& bytecodeOffset, CodeBlock*&);
+ CallFrameClosure prepareForRepeatCall(FunctionExecutable*, CallFrame*, ProtoCallFrame*, JSFunction*, int argumentCountIncludingThis, JSScope*, JSValue*);
- static ALWAYS_INLINE CallFrame* slideRegisterWindowForCall(CodeBlock*, RegisterFile*, CallFrame*, size_t registerOffset, int argc);
+ JSValue execute(CallFrameClosure&);
- static CallFrame* findFunctionCallFrame(CallFrame*, JSFunction*);
- JSValue privateExecute(ExecutionFlag, RegisterFile*, CallFrame*);
- void dumpCallFrame(CallFrame*);
void dumpRegisters(CallFrame*);
bool isCallBytecode(Opcode opcode) { return opcode == getOpcode(op_call) || opcode == getOpcode(op_construct) || opcode == getOpcode(op_call_eval); }
void enableSampler();
int m_sampleEntryDepth;
- OwnPtr<SamplingTool> m_sampler;
-
- int m_reentryDepth;
+ std::unique_ptr<SamplingTool> m_sampler;
- RegisterFile m_registerFile;
+ VM& m_vm;
+ JSStack m_stack;
+ int m_errorHandlingModeReentry;
-#if ENABLE(COMPUTED_GOTO_INTERPRETER)
- Opcode m_opcodeTable[numOpcodeIDs]; // Maps OpcodeID => Opcode for compiling
+#if ENABLE(COMPUTED_GOTO_OPCODES)
+ Opcode* m_opcodeTable; // Maps OpcodeID => Opcode for compiling
HashMap<Opcode, OpcodeID> m_opcodeIDTable; // Maps Opcode => OpcodeID for decompiling
#endif
+
+#if !ASSERT_DISABLED
+ bool m_initialized;
+#endif
};
+
+ JSValue eval(CallFrame*);
+
+ inline CallFrame* calleeFrameForVarargs(CallFrame* callFrame, unsigned numUsedStackSlots, unsigned argumentCountIncludingThis)
+ {
+ unsigned paddedCalleeFrameOffset = WTF::roundUpToMultipleOf(
+ stackAlignmentRegisters(),
+ numUsedStackSlots + argumentCountIncludingThis + JSStack::CallFrameHeaderSize);
+ return CallFrame::create(callFrame->registers() - paddedCalleeFrameOffset);
+ }
+
+ unsigned sizeOfVarargs(CallFrame* exec, JSValue arguments, uint32_t firstVarArgOffset);
+ static const unsigned maxArguments = 0x10000;
+ unsigned sizeFrameForVarargs(CallFrame* exec, JSStack*, JSValue arguments, unsigned numUsedStackSlots, uint32_t firstVarArgOffset);
+ void loadVarargs(CallFrame* execCaller, VirtualRegister firstElementDest, JSValue source, uint32_t offset, uint32_t length);
+ void setupVarargsFrame(CallFrame* execCaller, CallFrame* execCallee, JSValue arguments, uint32_t firstVarArgOffset, uint32_t length);
+ void setupVarargsFrameAndSetThis(CallFrame* execCaller, CallFrame* execCallee, JSValue thisValue, JSValue arguments, uint32_t firstVarArgOffset, uint32_t length);
} // namespace JSC
projects / apple / javascriptcore.git / blobdiff