explicit CallSiteIndex(uint32_t bits)

: m_bits(bits)

{ }

#if USE(JSVALUE32_64)

explicit CallSiteIndex(Instruction* instruction)

: m_bits(bitwise_cast<uint32_t>(instruction))

{ }

#endif

inline uint32_t bits() const { return m_bits; }

private:

uint32_t m_bits;

public:

JSValue calleeAsValue() const { return this[JSStack::Callee].jsValue(); }

JSObject* callee() const { return this[JSStack::Callee].object(); }

CodeBlock* codeBlock() const { return this[JSStack::CodeBlock].Register::codeBlock(); }

JSScope* scope(int scopeRegisterOffset) const

{

ASSERT(this[scopeRegisterOffset].Register::scope());

return this[scopeRegisterOffset].Register::scope();

}

bool hasActivation() const;

JSLexicalEnvironment* lexicalEnvironment() const;

JSLexicalEnvironment* lexicalEnvironmentOrNullptr() const;

JSValue uncheckedActivation() const;

// Global object in which execution began.

JS_EXPORT_PRIVATE JSGlobalObject* vmEntryGlobalObject();

// Global object in which the currently executing code was defined.

// Differs from vmEntryGlobalObject() during function calls across web browser frames.

JSGlobalObject* lexicalGlobalObject() const;

// Differs from lexicalGlobalObject because this will have DOM window shell rather than

// the actual DOM window, which can't be "this" for security reasons.

JSObject* globalThisValue() const;

VM& vm() const;

// Convenience functions for access to global data.

// It takes a few memory references to get from a call frame to the global data

// pointer, so these are inefficient, and should be used sparingly in new code.

// But they're used in many places in legacy code, so they're not going away any time soon.

void clearException() { vm().clearException(); }

Exception* exception() const { return vm().exception(); }

bool hadException() const { return !!vm().exception(); }

Exception* lastException() const { return vm().lastException(); }

void clearLastException() { vm().clearLastException(); }

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 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 static_cast<CallFrame*>(callerFrameOrVMEntryFrame()); }

void* callerFrameOrVMEntryFrame() const { return callerFrameAndPC().callerFrame; }

JS_EXPORT_PRIVATE CallFrame* callerFrame(VMEntryFrame*&);

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); }

bool callSiteBitsAreBytecodeOffset() const;

bool callSiteBitsAreCodeOriginIndex() const;

unsigned callSiteAsRawBits() const;

CallSiteIndex callSiteIndex() const;

private:

unsigned callSiteBitsAsBytecodeOffset() const;

public:

// This will try to get you the bytecode offset, but you should be aware that

// this bytecode offset may be bogus in the presence of inlining. This will

// also return 0 if the call frame has no notion of bytecode offsets (for

// example if it's native code).

// https://bugs.webkit.org/show_bug.cgi?id=121754

unsigned bytecodeOffset();

// This will get you a CodeOrigin. It will always succeed. May return

// CodeOrigin(0) if we're in native code.

CodeOrigin codeOrigin();

Register* topOfFrame()

{

if (!codeBlock())

return registers();

return topOfFrameInternal();

}

Instruction* currentVPC() const; // This only makes sense in the LLInt and baseline.

void setCurrentVPC(Instruction* vpc);

void setCallerFrame(CallFrame* frame) { callerFrameAndPC().callerFrame = frame; }

void setScope(int scopeRegisterOffset, JSScope* scope) { static_cast<Register*>(this)[scopeRegisterOffset] = scope; }

void setActivation(JSLexicalEnvironment*);

ALWAYS_INLINE void init(CodeBlock* codeBlock, Instruction* vPC,

CallFrame* callerFrame, int argc, JSObject* callee)

{

ASSERT(callerFrame == noCaller() || callerFrame->stack()->containsAddress(this));

setCodeBlock(codeBlock);

setCallerFrame(callerFrame);

setReturnPC(vPC); // This is either an Instruction* or a pointer into JIT generated code stored as an Instruction*.

setArgumentCountIncludingThis(argc); // original argument count (for the sake of the "arguments" object)

setCallee(callee);

}

// Read a register from the codeframe (or constant from the CodeBlock).

Register& r(int);

Register& r(VirtualRegister);

// Read a register for a non-constant

Register& uncheckedR(int);

Register& uncheckedR(VirtualRegister);

// Access to arguments as passed. (After capture, arguments may move to a different location.)

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); }

// In the following (argument() and setArgument()), the 'argument'

// parameter is the index of the arguments of the target function of

// this frame. The index starts at 0 for the first arg, 1 for the

// second, etc.

//

// The arguments (in this case) do not include the 'this' value.

// arguments(0) will not fetch the 'this' value. To get/set 'this',

// use thisValue() and setThisValue() below.

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;

}

JSValue getArgumentUnsafe(size_t argIndex)

{

// User beware! This method does not verify that there is a valid

// argument at the specified argIndex. This is used for debugging

// and verification code only. The caller is expected to know what

// he/she is doing when calling this method.

return this[argumentOffset(argIndex)].jsValue();

}

static int thisArgumentOffset() { return argumentOffsetIncludingThis(0); }

JSValue thisValue() { return this[thisArgumentOffset()].jsValue(); }

void setThisValue(JSValue value) { this[thisArgumentOffset()] = value; }

// Under the constructor implemented in C++, thisValue holds the newTarget instead of the automatically constructed value.

// The result of this function is only effective under the "construct" context.

JSValue newTarget() { return thisValue(); }

JSValue argumentAfterCapture(size_t argument);

static int offsetFor(size_t argumentCountIncludingThis) { return argumentCountIncludingThis + JSStack::ThisArgument - 1; }

static CallFrame* noCaller() { return 0; }

void setArgumentCountIncludingThis(int count) { static_cast<Register*>(this)[JSStack::ArgumentCount].payload() = count; }

void setCallee(JSObject* callee) { static_cast<Register*>(this)[JSStack::Callee] = callee; }

void setCodeBlock(CodeBlock* codeBlock) { static_cast<Register*>(this)[JSStack::CodeBlock] = codeBlock; }

void setReturnPC(void* value) { callerFrameAndPC().pc = reinterpret_cast<Instruction*>(value); }

// CallFrame::iterate() expects a Functor that implements the following method:

// StackVisitor::Status operator()(StackVisitor&);

template <typename Functor> void iterate(Functor& functor)

{

StackVisitor::visit<Functor>(this, functor);

}

void dump(PrintStream&);

JS_EXPORT_PRIVATE const char* describeFrame();

private:

#ifndef NDEBUG

JSStack* stack();

#endif

ExecState();

~ExecState();

Register* topOfFrameInternal();

// The following are for internal use in debugging and verification

// code only and not meant as an API for general usage:

size_t argIndexForRegister(Register* reg)

{

// The register at 'offset' number of slots from the frame pointer

// i.e.

// reg = frame[offset];

// ==> reg = frame + offset;

// ==> offset = reg - frame;

int offset = reg - this->registers();

// The offset is defined (based on argumentOffset()) to be:

// offset = JSStack::FirstArgument - argIndex;

// Hence:

// argIndex = JSStack::FirstArgument - offset;

size_t argIndex = offset - JSStack::FirstArgument;

return argIndex;

}

CallerFrameAndPC& callerFrameAndPC() { return *reinterpret_cast<CallerFrameAndPC*>(this); }

const CallerFrameAndPC& callerFrameAndPC() const { return *reinterpret_cast<const CallerFrameAndPC*>(this); }

friend class JSStack;