#ifndef CallFrame_h
#define CallFrame_h
#include "AbstractPC.h"
#include "VM.h"
#include "JSStack.h"
#include "MacroAssemblerCodeRef.h"
#include "Register.h"
#include "StackVisitor.h"
namespace JSC {
class Arguments;
class JSActivation;
class Interpreter;
class JSScope;
class ExecState : private Register {
public:
JSValue calleeAsValue() const { return this[JSStack::Callee].jsValue(); }
JSObject* callee() const { return this[JSStack::Callee].function(); }
CodeBlock* codeBlock() const { return this[JSStack::CodeBlock].Register::codeBlock(); }
JSScope* scope() const
{
ASSERT(this[JSStack::ScopeChain].Register::scope());
return this[JSStack::ScopeChain].Register::scope();
}
bool hasActivation() const { return !!uncheckedActivation(); }
JSActivation* activation() const;
JSValue uncheckedActivation() const;
JS_EXPORT_PRIVATE JSGlobalObject* vmEntryGlobalObject();
JSGlobalObject* lexicalGlobalObject() const;
JSObject* globalThisValue() const;
VM& vm() const;
void clearException() { vm().clearException(); }
void clearSupplementaryExceptionInfo()
{
vm().clearExceptionStack();
}
JSValue exception() const { return vm().exception(); }
bool hadException() const { return !vm().exception().isEmpty(); }
AtomicStringTable* atomicStringTable() const { return vm().atomicStringTable(); }
const CommonIdentifiers& propertyNames() const { return *vm().propertyNames; }
const MarkedArgumentBuffer& emptyList() const { return *vm().emptyList; }
Interpreter* interpreter() { return vm().interpreter; }
Heap* heap() { return &vm().heap; }
static const HashTable& arrayConstructorTable(VM& vm) { return *vm.arrayConstructorTable; }
static const HashTable& arrayPrototypeTable(VM& vm) { return *vm.arrayPrototypeTable; }
static const HashTable& booleanPrototypeTable(VM& vm) { return *vm.booleanPrototypeTable; }
static const HashTable& dataViewTable(VM& vm) { return *vm.dataViewTable; }
static const HashTable& dateTable(VM& vm) { return *vm.dateTable; }
static const HashTable& dateConstructorTable(VM& vm) { return *vm.dateConstructorTable; }
static const HashTable& errorPrototypeTable(VM& vm) { return *vm.errorPrototypeTable; }
static const HashTable& globalObjectTable(VM& vm) { return *vm.globalObjectTable; }
static const HashTable& jsonTable(VM& vm) { return *vm.jsonTable; }
static const HashTable& numberConstructorTable(VM& vm) { return *vm.numberConstructorTable; }
static const HashTable& numberPrototypeTable(VM& vm) { return *vm.numberPrototypeTable; }
static const HashTable& objectConstructorTable(VM& vm) { return *vm.objectConstructorTable; }
static const HashTable& privateNamePrototypeTable(VM& vm) { return *vm.privateNamePrototypeTable; }
static const HashTable& regExpTable(VM& vm) { return *vm.regExpTable; }
static const HashTable& regExpConstructorTable(VM& vm) { return *vm.regExpConstructorTable; }
static const HashTable& regExpPrototypeTable(VM& vm) { return *vm.regExpPrototypeTable; }
static const HashTable& stringConstructorTable(VM& vm) { return *vm.stringConstructorTable; }
#if ENABLE(PROMISES)
static const HashTable& promisePrototypeTable(VM& vm) { return *vm.promisePrototypeTable; }
static const HashTable& promiseConstructorTable(VM& vm) { return *vm.promiseConstructorTable; }
#endif
static CallFrame* create(Register* callFrameBase) { return static_cast<CallFrame*>(callFrameBase); }
Register* registers() { return this; }
const Register* registers() const { return this; }
CallFrame& operator=(const Register& r) { *static_cast<Register*>(this) = r; return *this; }
CallFrame* callerFrame() const { return callerFrameAndPC().callerFrame; }
static ptrdiff_t callerFrameOffset() { return OBJECT_OFFSETOF(CallerFrameAndPC, callerFrame); }
ReturnAddressPtr returnPC() const { return ReturnAddressPtr(callerFrameAndPC().pc); }
bool hasReturnPC() const { return !!callerFrameAndPC().pc; }
void clearReturnPC() { callerFrameAndPC().pc = 0; }
static ptrdiff_t returnPCOffset() { return OBJECT_OFFSETOF(CallerFrameAndPC, pc); }
AbstractPC abstractReturnPC(VM& vm) { return AbstractPC(vm, this); }
class Location {
public:
static inline uint32_t decode(uint32_t bits);
static inline bool isBytecodeLocation(uint32_t bits);
#if USE(JSVALUE64)
static inline uint32_t encodeAsBytecodeOffset(uint32_t bits);
#else
static inline uint32_t encodeAsBytecodeInstruction(Instruction*);
#endif
static inline bool isCodeOriginIndex(uint32_t bits);
static inline uint32_t encodeAsCodeOriginIndex(uint32_t bits);
private:
enum TypeTag {
BytecodeLocationTag = 0,
CodeOriginIndexTag = 1,
};
static inline uint32_t encode(TypeTag, uint32_t bits);
static const uint32_t s_mask = 0x1;
#if USE(JSVALUE64)
static const uint32_t s_shift = 31;
static const uint32_t s_shiftedMask = s_mask << s_shift;
#else
static const uint32_t s_shift = 1;
#endif
};
bool hasLocationAsBytecodeOffset() const;
bool hasLocationAsCodeOriginIndex() const;
unsigned locationAsRawBits() const;
unsigned locationAsBytecodeOffset() const;
unsigned locationAsCodeOriginIndex() const;
void setLocationAsRawBits(unsigned);
void setLocationAsBytecodeOffset(unsigned);
#if ENABLE(DFG_JIT)
unsigned bytecodeOffsetFromCodeOriginIndex();
#endif
unsigned bytecodeOffset();
CodeOrigin codeOrigin();
Register* topOfFrame()
{
if (isVMEntrySentinel() || !codeBlock())
return registers();
return topOfFrameInternal();
}
#if USE(JSVALUE32_64)
Instruction* currentVPC() const
{
ASSERT(!isVMEntrySentinel());
return bitwise_cast<Instruction*>(this[JSStack::ArgumentCount].tag());
}
void setCurrentVPC(Instruction* vpc)
{
ASSERT(!isVMEntrySentinel());
this[JSStack::ArgumentCount].tag() = bitwise_cast<int32_t>(vpc);
}
#else
Instruction* currentVPC() const;
void setCurrentVPC(Instruction* vpc);
#endif
void setCallerFrame(CallFrame* frame) { callerFrameAndPC().callerFrame = frame; }
void setScope(JSScope* scope) { static_cast<Register*>(this)[JSStack::ScopeChain] = scope; }
void setActivation(JSActivation*);
ALWAYS_INLINE void init(CodeBlock* codeBlock, Instruction* vPC, JSScope* scope,
CallFrame* callerFrame, int argc, JSObject* callee)
{
ASSERT(callerFrame == noCaller() || callerFrame->isVMEntrySentinel() || callerFrame->stack()->containsAddress(this));
setCodeBlock(codeBlock);
setScope(scope);
setCallerFrame(callerFrame);
setReturnPC(vPC); setArgumentCountIncludingThis(argc); setCallee(callee);
}
Register& r(int);
Register& uncheckedR(int);
size_t argumentCount() const { return argumentCountIncludingThis() - 1; }
size_t argumentCountIncludingThis() const { return this[JSStack::ArgumentCount].payload(); }
static int argumentOffset(int argument) { return (JSStack::FirstArgument + argument); }
static int argumentOffsetIncludingThis(int argument) { return (JSStack::ThisArgument + argument); }
JSValue argument(size_t argument)
{
if (argument >= argumentCount())
return jsUndefined();
return getArgumentUnsafe(argument);
}
JSValue uncheckedArgument(size_t argument)
{
ASSERT(argument < argumentCount());
return getArgumentUnsafe(argument);
}
void setArgument(size_t argument, JSValue value)
{
this[argumentOffset(argument)] = value;
}
static int thisArgumentOffset() { return argumentOffsetIncludingThis(0); }
JSValue thisValue() { return this[thisArgumentOffset()].jsValue(); }
void setThisValue(JSValue value) { this[thisArgumentOffset()] = value; }
JSValue argumentAfterCapture(size_t argument);
static int offsetFor(size_t argumentCountIncludingThis) { return argumentCountIncludingThis + JSStack::ThisArgument - 1; }
static CallFrame* noCaller() { return 0; }
bool isVMEntrySentinel() const
{
return !!this && codeBlock() == vmEntrySentinelCodeBlock();
}
CallFrame* vmEntrySentinelCallerFrame() const
{
ASSERT(isVMEntrySentinel());
return this[JSStack::ScopeChain].callFrame();
}
void initializeVMEntrySentinelFrame(CallFrame* callFrame)
{
setCallerFrame(noCaller());
setReturnPC(0);
setCodeBlock(vmEntrySentinelCodeBlock());
static_cast<Register*>(this)[JSStack::ScopeChain] = callFrame;
setCallee(0);
setArgumentCountIncludingThis(0);
}
CallFrame* callerFrameSkippingVMEntrySentinel()
{
CallFrame* caller = callerFrame();
if (caller->isVMEntrySentinel())
return caller->vmEntrySentinelCallerFrame();
return caller;
}
void setArgumentCountIncludingThis(int count) { static_cast<Register*>(this)[JSStack::ArgumentCount].payload() = count; }
void setCallee(JSObject* callee) { static_cast<Register*>(this)[JSStack::Callee] = Register::withCallee(callee); }
void setCodeBlock(CodeBlock* codeBlock) { static_cast<Register*>(this)[JSStack::CodeBlock] = codeBlock; }
void setReturnPC(void* value) { callerFrameAndPC().pc = reinterpret_cast<Instruction*>(value); }
template <typename Functor> void iterate(Functor& functor)
{
StackVisitor::visit<Functor>(this, functor);
}
void dump(PrintStream&);
JS_EXPORT_PRIVATE const char* describeFrame();
private:
static const intptr_t s_VMEntrySentinel = 1;
#ifndef NDEBUG
JSStack* stack();
#endif
ExecState();
~ExecState();
Register* topOfFrameInternal();
size_t argIndexForRegister(Register* reg)
{
int offset = reg - this->registers();
size_t argIndex = offset - JSStack::FirstArgument;
return argIndex;
}
JSValue getArgumentUnsafe(size_t argIndex)
{
return this[argumentOffset(argIndex)].jsValue();
}
CallerFrameAndPC& callerFrameAndPC() { return *reinterpret_cast<CallerFrameAndPC*>(this); }
const CallerFrameAndPC& callerFrameAndPC() const { return *reinterpret_cast<const CallerFrameAndPC*>(this); }
static CodeBlock* vmEntrySentinelCodeBlock() { return reinterpret_cast<CodeBlock*>(s_VMEntrySentinel); }
friend class JSStack;
friend class VMInspector;
};
}
#endif // CallFrame_h