wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity
b1906cec20
gecko/js/src/jsinterp.h
David Anderson 69b95ea914 ICs for scripted calls (bug 587698, r=dmandelin).
2010-09-02 20:04:33 -07:00

896 lines
26 KiB
C++
Raw Blame History

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
* vim: set ts=4 sw=4 et tw=78:
*
* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Mozilla Communicator client code, released
* March 31, 1998.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1998
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either of the GNU General Public License Version 2 or later (the "GPL"),
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef jsinterp_h___
#define jsinterp_h___
/*
* JS interpreter interface.
*/
#include "jsprvtd.h"
#include "jspubtd.h"
#include "jsfun.h"
#include "jsopcode.h"
#include "jsscript.h"
#include "jsvalue.h"
typedef struct JSFrameRegs {
js::Value *sp; /* stack pointer */
jsbytecode *pc; /* program counter */
JSStackFrame *fp; /* active frame */
} JSFrameRegs;
/* JS stack frame flags. */
enum JSFrameFlags {
JSFRAME_CONSTRUCTING = 0x01, /* frame is for a constructor invocation */
JSFRAME_OVERRIDE_ARGS = 0x02, /* overridden arguments local variable */
JSFRAME_ASSIGNING = 0x04, /* a complex (not simplex JOF_ASSIGNING) op
is currently assigning to a property */
JSFRAME_DEBUGGER = 0x08, /* frame for JS_EvaluateInStackFrame */
JSFRAME_EVAL = 0x10, /* frame for obj_eval */
JSFRAME_FLOATING_GENERATOR = 0x20, /* frame copy stored in a generator obj */
JSFRAME_YIELDING = 0x40, /* js_Interpret dispatched JSOP_YIELD */
JSFRAME_GENERATOR = 0x80, /* frame belongs to generator-iterator */
JSFRAME_BAILING = 0x100, /* walking out of a method JIT'd frame */
JSFRAME_RECORDING = 0x200, /* recording a trace */
JSFRAME_BAILED_AT_RETURN = 0x400, /* bailed at JSOP_RETURN */
JSFRAME_DUMMY = 0x800, /* frame is a dummy frame */
JSFRAME_IN_IMACRO = 0x1000, /* frame has imacpc value available */
JSFRAME_SPECIAL = JSFRAME_DEBUGGER | JSFRAME_EVAL
};
namespace js { namespace mjit {
class Compiler;
class InlineFrameAssembler;
} }
/*
* JS stack frame, may be allocated on the C stack by native callers. Always
* allocated on cx->stackPool for calls from the interpreter to an interpreted
* function.
*
* NB: This struct is manually initialized in jsinterp.c and jsiter.c. If you
* add new members, update both files.
*/
struct JSStackFrame
{
private:
JSObject *callobj; /* lazily created Call object */
JSObject *argsobj; /* lazily created arguments object */
jsbytecode *imacpc; /* null or interpreter macro call pc */
JSScript *script; /* script being interpreted */
/*
* The value of |this| in this stack frame, or JSVAL_NULL if |this|
* is to be computed lazily on demand.
*
* thisv is eagerly initialized for non-function-call frames and
* qualified method calls, but lazily initialized in most unqualified
* function calls. See getThisObject().
*
* Usually if argv != NULL then thisv == argv[-1], but natives may
* assign to argv[-1]. Also, obj_eval can trigger a special case
* where two stack frames have the same argv. If one of the frames fills
* in both argv[-1] and thisv, the other frame's thisv is left null.
*/
js::Value thisv; /* "this" pointer if in method */
JSFunction *fun; /* function being called or null */
public:
uintN argc; /* actual argument count */
js::Value *argv; /* base of argument stack slots */
private:
js::Value rval; /* function return value */
void *annotation; /* used by Java security */
public:
/* Maintained by StackSpace operations */
JSStackFrame *down; /* previous frame, part of
stack layout invariant */
jsbytecode *savedPC; /* only valid if cx->fp != this */
#ifdef DEBUG
static jsbytecode *const sInvalidPC;
#endif
void *ncode; /* jit return pc */
private:
JSObject *scopeChain;
JSObject *blockChain;
public:
uint32 flags; /* frame flags -- see below */
private:
/* Members only needed for inline calls. */
void *hookData; /* debugger call hook data */
JSVersion callerVersion; /* dynamic version of calling script */
public:
/* Get the frame's current bytecode, assuming |this| is in |cx|. */
jsbytecode *pc(JSContext *cx) const;
js::Value *argEnd() const {
return (js::Value *)this;
}
js::Value *slots() const {
return (js::Value *)(this + 1);
}
js::Value *base() const {
return slots() + getScript()->nfixed;
}
/* Call object accessors */
bool hasCallObj() const {
return callobj != NULL;
}
JSObject* getCallObj() const {
JS_ASSERT(hasCallObj());
return callobj;
}
JSObject* maybeCallObj() const {
return callobj;
}
void setCallObj(JSObject *obj) {
callobj = obj;
}
static size_t offsetCallObj() {
return offsetof(JSStackFrame, callobj);
}
/* Arguments object accessors */
bool hasArgsObj() const {
return argsobj != NULL;
}
JSObject* getArgsObj() const {
JS_ASSERT(hasArgsObj());
JS_ASSERT(!isEvalFrame());
return argsobj;
}
JSObject* maybeArgsObj() const {
return argsobj;
}
void setArgsObj(JSObject *obj) {
argsobj = obj;
}
JSObject** addressArgsObj() {
return &argsobj;
}
static size_t offsetArgsObj() {
return offsetof(JSStackFrame, argsobj);
}
/*
* We can't determine in advance which local variables can live on
* the stack and be freed when their dynamic scope ends, and which
* will be closed over and need to live in the heap. So we place
* variables on the stack initially, note when they are closed
* over, and copy those that are out to the heap when we leave
* their dynamic scope.
*
* The bytecode compiler produces a tree of block objects
* accompanying each JSScript representing those lexical blocks in
* the script that have let-bound variables associated with them.
* These block objects are never modified, and never become part
* of any function's scope chain. Their parent slots point to the
* innermost block that encloses them, or are NULL in the
* outermost blocks within a function or in eval or global code.
*
* When we are in the static scope of such a block, blockChain
* points to its compiler-allocated block object; otherwise, it is
* NULL.
*
* scopeChain is the current scope chain, including 'call' and
* 'block' objects for those function calls and lexical blocks
* whose static scope we are currently executing in, and 'with'
* objects for with statements; the chain is typically terminated
* by a global object. However, as an optimization, the young end
* of the chain omits block objects we have not yet cloned. To
* create a closure, we clone the missing blocks from blockChain
* (which is always current), place them at the head of
* scopeChain, and use that for the closure's scope chain. If we
* never close over a lexical block, we never place a mutable
* clone of it on scopeChain.
*
* This lazy cloning is implemented in js_GetScopeChain, which is
* also used in some other cases --- entering 'with' blocks, for
* example.
*/
/* Scope chain accessors */
bool hasScopeChain() const {
return scopeChain != NULL;
}
JSObject* getScopeChain() const {
JS_ASSERT(hasScopeChain());
return scopeChain;
}
JSObject* maybeScopeChain() const {
return scopeChain;
}
void setScopeChain(JSObject *obj) {
scopeChain = obj;
}
JSObject** addressScopeChain() {
return &scopeChain;
}
static size_t offsetScopeChain() {
return offsetof(JSStackFrame, scopeChain);
}
/* Block chain accessors */
bool hasBlockChain() const {
return blockChain != NULL;
}
JSObject* getBlockChain() const {
JS_ASSERT(hasBlockChain());
return blockChain;
}
JSObject* maybeBlockChain() const {
return blockChain;
}
void setBlockChain(JSObject *obj) {
blockChain = obj;
}
static size_t offsetBlockChain() {
return offsetof(JSStackFrame, blockChain);
}
/* IMacroPC accessors. */
bool hasIMacroPC() const { return flags & JSFRAME_IN_IMACRO; }
/*
* @pre hasIMacroPC
* @return The PC at which an imacro started executing (guaranteed non-null. The PC of the
* executing imacro must be in regs.pc, so the displaced
* original value is stored here.
*/
jsbytecode *getIMacroPC() const {
JS_ASSERT(flags & JSFRAME_IN_IMACRO);
return imacpc;
}
/* @return The imacro pc if hasIMacroPC; otherwise, NULL. */
jsbytecode *maybeIMacroPC() const { return hasIMacroPC() ? getIMacroPC() : NULL; }
void clearIMacroPC() { flags &= ~JSFRAME_IN_IMACRO; }
void setIMacroPC(jsbytecode *newIMacPC) {
JS_ASSERT(newIMacPC);
JS_ASSERT(!(flags & JSFRAME_IN_IMACRO));
imacpc = newIMacPC;
flags |= JSFRAME_IN_IMACRO;
}
/* Annotation accessors */
bool hasAnnotation() const {
return annotation != NULL;
}
void* getAnnotation() const {
JS_ASSERT(hasAnnotation());
return annotation;
}
void* maybeAnnotation() const {
return annotation;
}
void setAnnotation(void *annot) {
annotation = annot;
}
static size_t offsetAnnotation() {
return offsetof(JSStackFrame, annotation);
}
/* Debugger hook data accessors */
bool hasHookData() const {
return hookData != NULL;
}
void* getHookData() const {
JS_ASSERT(hasHookData());
return hookData;
}
void* maybeHookData() const {
return hookData;
}
void setHookData(void *data) {
hookData = data;
}
static size_t offsetHookData() {
return offsetof(JSStackFrame, hookData);
}
/* Version accessors */
JSVersion getCallerVersion() const {
return callerVersion;
}
void setCallerVersion(JSVersion version) {
callerVersion = version;
}
static size_t offsetCallerVersion() {
return offsetof(JSStackFrame, callerVersion);
}
/* Script accessors */
bool hasScript() const {
return script != NULL;
}
JSScript* getScript() const {
JS_ASSERT(hasScript());
return script;
}
JSScript* maybeScript() const {
return script;
}
size_t getFixedCount() const {
return getScript()->nfixed;
}
size_t getSlotCount() const {
return getScript()->nslots;
}
void setScript(JSScript *s) {
script = s;
}
static size_t offsetScript() {
return offsetof(JSStackFrame, script);
}
/* Function accessors */
bool hasFunction() const {
return fun != NULL;
}
JSFunction* getFunction() const {
JS_ASSERT(hasFunction());
return fun;
}
JSFunction* maybeFunction() const {
return fun;
}
static size_t offsetFunction() {
return offsetof(JSStackFrame, fun);
}
size_t numFormalArgs() const {
JS_ASSERT(!isEvalFrame());
return getFunction()->nargs;
}
void setFunction(JSFunction *f) {
fun = f;
}
/* This-value accessors */
const js::Value& getThisValue() {
return thisv;
}
void setThisValue(const js::Value &v) {
thisv = v;
}
static size_t offsetThisValue() {
return offsetof(JSStackFrame, thisv);
}
/* Return-value accessors */
const js::Value& getReturnValue() {
return rval;
}
void setReturnValue(const js::Value &v) {
rval = v;
}
void clearReturnValue() {
rval.setUndefined();
}
js::Value* addressReturnValue() {
return &rval;
}
static size_t offsetReturnValue() {
return offsetof(JSStackFrame, rval);
}
/* Argument count accessors */
size_t numActualArgs() const {
JS_ASSERT(!isEvalFrame());
return argc;
}
void setNumActualArgs(size_t n) {
argc = n;
}
static size_t offsetNumActualArgs() {
return offsetof(JSStackFrame, argc);
}
/* Other accessors */
void putActivationObjects(JSContext *cx) {
/*
* The order of calls here is important as js_PutCallObject needs to
* access argsobj.
*/
if (hasCallObj()) {
js_PutCallObject(cx, this);
JS_ASSERT(!hasArgsObj());
} else if (hasArgsObj()) {
js_PutArgsObject(cx, this);
}
}
const js::Value &calleeValue() {
JS_ASSERT(argv);
return argv[-2];
}
/* Infallible getter to return the callee object from this frame. */
JSObject &calleeObject() const {
JS_ASSERT(argv);
return argv[-2].toObject();
}
/*
* Fallible getter to compute the correct callee function object, which may
* require deferred cloning due to JSObject::methodReadBarrier. For a frame
* with null fun member, return true with *vp set from this->calleeValue(),
* which may not be an object (it could be undefined).
*/
bool getValidCalleeObject(JSContext *cx, js::Value *vp);
void setCalleeObject(JSObject &callable) {
JS_ASSERT(argv);
argv[-2].setObject(callable);
}
JSObject *callee() {
return argv ? &argv[-2].toObject() : NULL;
}
/*
* Get the "variable object" (ES3 term) associated with the Execution
* Context's VariableEnvironment (ES5 10.3). The given StackSegment
* must contain this stack frame.
*/
JSObject *varobj(js::StackSegment *seg) const;
/* Short for: varobj(cx->activeSegment()). */
JSObject *varobj(JSContext *cx) const;
inline JSObject *getThisObject(JSContext *cx);
bool isGenerator() const { return !!(flags & JSFRAME_GENERATOR); }
bool isFloatingGenerator() const {
JS_ASSERT_IF(flags & JSFRAME_FLOATING_GENERATOR, isGenerator());
return !!(flags & JSFRAME_FLOATING_GENERATOR);
}
bool isDummyFrame() const { return !!(flags & JSFRAME_DUMMY); }
bool isEvalFrame() const { return !!(flags & JSFRAME_EVAL); }
private:
JSObject *computeThisObject(JSContext *cx);
/* Contains static assertions for member alignment, don't call. */
inline void staticAsserts();
};
namespace js {
JS_STATIC_ASSERT(sizeof(JSStackFrame) % sizeof(Value) == 0);
static const size_t VALUES_PER_STACK_FRAME = sizeof(JSStackFrame) / sizeof(Value);
} /* namespace js */
inline void
JSStackFrame::staticAsserts()
{
JS_STATIC_ASSERT(offsetof(JSStackFrame, rval) % sizeof(js::Value) == 0);
JS_STATIC_ASSERT(offsetof(JSStackFrame, thisv) % sizeof(js::Value) == 0);
/* Static assert for x86 trampolines in MethodJIT.cpp */
#if defined(JS_METHODJIT)
# if defined(JS_CPU_X86)
JS_STATIC_ASSERT(offsetof(JSStackFrame, rval) == 0x28);
# elif defined(JS_CPU_X64)
JS_STATIC_ASSERT(offsetof(JSStackFrame, rval) == 0x40);
# endif
#endif
}
static JS_INLINE uintN
GlobalVarCount(JSStackFrame *fp)
{
JS_ASSERT(!fp->hasFunction());
return fp->getScript()->nfixed;
}
/*
* Refresh and return fp->scopeChain. It may be stale if block scopes are
* active but not yet reflected by objects in the scope chain. If a block
* scope contains a with, eval, XML filtering predicate, or similar such
* dynamically scoped construct, then compile-time block scope at fp->blocks
* must reflect at runtime.
*/
extern JSObject *
js_GetScopeChain(JSContext *cx, JSStackFrame *fp);
/*
* Given a context and a vector of [callee, this, args...] for a function that
* was specified with a JSFUN_THISP_PRIMITIVE flag, get the primitive value of
* |this| into *thisvp. In doing so, if |this| is an object, insist it is an
* instance of clasp and extract its private slot value to return via *thisvp.
*
* NB: this function loads and uses *vp before storing *thisvp, so the two may
* alias the same Value.
*/
extern JSBool
js_GetPrimitiveThis(JSContext *cx, js::Value *vp, js::Class *clasp,
const js::Value **vpp);
namespace js {
/*
* For a call with arguments argv including argv[-1] (nominal |this|) and
* argv[-2] (callee) replace null |this| with callee's parent and replace
* primitive values with the equivalent wrapper objects. argv[-1] must
* not be JSVAL_VOID or an activation object.
*/
extern bool
ComputeThisFromArgv(JSContext *cx, js::Value *argv);
JS_ALWAYS_INLINE JSObject *
ComputeThisFromVp(JSContext *cx, js::Value *vp)
{
extern bool ComputeThisFromArgv(JSContext *, js::Value *);
return ComputeThisFromArgv(cx, vp + 2) ? &vp[1].toObject() : NULL;
}
JS_ALWAYS_INLINE bool
ComputeThisFromVpInPlace(JSContext *cx, js::Value *vp)
{
extern bool ComputeThisFromArgv(JSContext *, js::Value *);
return ComputeThisFromArgv(cx, vp + 2);
}
JS_ALWAYS_INLINE bool
PrimitiveThisTest(JSFunction *fun, const Value &v)
{
uint16 flags = fun->flags;
return (v.isString() && !!(flags & JSFUN_THISP_STRING)) ||
(v.isNumber() && !!(flags & JSFUN_THISP_NUMBER)) ||
(v.isBoolean() && !!(flags & JSFUN_THISP_BOOLEAN));
}
/*
* Abstracts the layout of the stack passed to natives from the engine and from
* natives to js::Invoke.
*/
struct CallArgs
{
Value *argv_;
uintN argc_;
protected:
CallArgs() {}
CallArgs(Value *argv, uintN argc) : argv_(argv), argc_(argc) {}
public:
Value *base() const { return argv_ - 2; }
Value &callee() const { return argv_[-2]; }
Value &thisv() const { return argv_[-1]; }
Value &operator[](unsigned i) const { JS_ASSERT(i < argc_); return argv_[i]; }
Value *argv() const { return argv_; }
uintN argc() const { return argc_; }
Value &rval() const { return argv_[-2]; }
bool computeThis(JSContext *cx) const {
return ComputeThisFromArgv(cx, argv_);
}
};
/*
* The js::InvokeArgumentsGuard passed to js_Invoke must come from an
* immediately-enclosing successful call to js::StackSpace::pushInvokeArgs,
* i.e., there must have been no un-popped pushes to cx->stack(). Furthermore,
* |args.getvp()[0]| should be the callee, |args.getvp()[1]| should be |this|,
* and the range [args.getvp() + 2, args.getvp() + 2 + args.getArgc()) should
* be initialized actual arguments.
*/
extern JS_REQUIRES_STACK bool
Invoke(JSContext *cx, const CallArgs &args, uintN flags);
/*
* Consolidated js_Invoke flags simply rename certain JSFRAME_* flags, so that
* we can share bits stored in JSStackFrame.flags and passed to:
*
* js_Invoke
* js_InternalInvoke
* js_ValueToFunction
* js_ValueToFunctionObject
* js_ValueToCallableObject
* js_ReportIsNotFunction
*
* See jsfun.h for the latter four and flag renaming macros.
*/
#define JSINVOKE_CONSTRUCT JSFRAME_CONSTRUCTING
/*
* Mask to isolate construct and iterator flags for use with jsfun.h functions.
*/
#define JSINVOKE_FUNFLAGS JSINVOKE_CONSTRUCT
/*
* "External" calls may come from C or C++ code using a JSContext on which no
* JS is running (!cx->fp), so they may need to push a dummy JSStackFrame.
*/
extern bool
ExternalInvoke(JSContext *cx, const Value &thisv, const Value &fval,
uintN argc, Value *argv, Value *rval);
static JS_ALWAYS_INLINE bool
ExternalInvoke(JSContext *cx, JSObject *obj, const Value &fval,
uintN argc, Value *argv, Value *rval)
{
return ExternalInvoke(cx, ObjectOrNullValue(obj), fval, argc, argv, rval);
}
extern bool
ExternalGetOrSet(JSContext *cx, JSObject *obj, jsid id, const Value &fval,
JSAccessMode mode, uintN argc, Value *argv, Value *rval);
/*
* These two functions invoke a function called from a constructor context
* (e.g. 'new'). InvokeConstructor handles the general case where a new object
* needs to be created for/by the constructor. ConstructWithGivenThis directly
* calls the constructor with the given 'this', hence the caller must
* understand the semantics of the constructor call.
*/
extern JS_REQUIRES_STACK bool
InvokeConstructor(JSContext *cx, const CallArgs &args);
extern JS_REQUIRES_STACK bool
InvokeConstructorWithGivenThis(JSContext *cx, JSObject *thisobj, const Value &fval,
uintN argc, Value *argv, Value *rval);
/*
* Executes a script with the given scope chain in the context of the given
* frame.
*/
extern JS_FORCES_STACK bool
Execute(JSContext *cx, JSObject *chain, JSScript *script,
JSStackFrame *down, uintN flags, Value *result);
/*
* Execute the caller-initialized frame for a user-defined script or function
* pointed to by cx->fp until completion or error.
*/
extern JS_REQUIRES_STACK bool
Interpret(JSContext *cx, JSStackFrame *stopFp, uintN inlineCallCount = 0);
extern JS_REQUIRES_STACK bool
RunScript(JSContext *cx, JSScript *script, JSFunction *fun, JSObject *scopeChain);
#define JSPROP_INITIALIZER 0x100 /* NB: Not a valid property attribute. */
extern bool
CheckRedeclaration(JSContext *cx, JSObject *obj, jsid id, uintN attrs,
JSObject **objp, JSProperty **propp);
extern bool
StrictlyEqual(JSContext *cx, const Value &lval, const Value &rval);
/* === except that NaN is the same as NaN and -0 is not the same as +0. */
extern bool
SameValue(const Value &v1, const Value &v2, JSContext *cx);
extern JSType
TypeOfValue(JSContext *cx, const Value &v);
inline bool
InstanceOf(JSContext *cx, JSObject *obj, Class *clasp, Value *argv)
{
if (obj && obj->getClass() == clasp)
return true;
extern bool InstanceOfSlow(JSContext *, JSObject *, Class *, Value *);
return InstanceOfSlow(cx, obj, clasp, argv);
}
extern JSBool
HasInstance(JSContext *cx, JSObject *obj, const js::Value *v, JSBool *bp);
inline void *
GetInstancePrivate(JSContext *cx, JSObject *obj, Class *clasp, Value *argv)
{
if (!InstanceOf(cx, obj, clasp, argv))
return NULL;
return obj->getPrivate();
}
extern bool
ValueToId(JSContext *cx, const Value &v, jsid *idp);
/*
* @param closureLevel The static level of the closure that the cookie
* pertains to.
* @param cookie Level amount is a "skip" (delta) value from the
* closure level.
* @return The value of the upvar.
*/
extern const js::Value &
GetUpvar(JSContext *cx, uintN level, js::UpvarCookie cookie);
} /* namespace js */
/*
* JS_LONE_INTERPRET indicates that the compiler should see just the code for
* the js_Interpret function when compiling jsinterp.cpp. The rest of the code
* from the file should be visible only when compiling jsinvoke.cpp. It allows
* platform builds to optimize selectively js_Interpret when the granularity
* of the optimizations with the given compiler is a compilation unit.
*
* JS_STATIC_INTERPRET is the modifier for functions defined in jsinterp.cpp
* that only js_Interpret calls. When JS_LONE_INTERPRET is true all such
* functions are declared below.
*/
#ifndef JS_LONE_INTERPRET
# ifdef _MSC_VER
# define JS_LONE_INTERPRET 0
# else
# define JS_LONE_INTERPRET 1
# endif
#endif
#define JS_MAX_INLINE_CALL_COUNT 3000
#if !JS_LONE_INTERPRET
# define JS_STATIC_INTERPRET static
#else
# define JS_STATIC_INTERPRET
extern JS_REQUIRES_STACK JSBool
js_EnterWith(JSContext *cx, jsint stackIndex);
extern JS_REQUIRES_STACK void
js_LeaveWith(JSContext *cx);
/*
* Find the results of incrementing or decrementing *vp. For pre-increments,
* both *vp and *vp2 will contain the result on return. For post-increments,
* vp will contain the original value converted to a number and vp2 will get
* the result. Both vp and vp2 must be roots.
*/
extern JSBool
js_DoIncDec(JSContext *cx, const JSCodeSpec *cs, js::Value *vp, js::Value *vp2);
/*
* Opcode tracing helper. When len is not 0, cx->fp->regs->pc[-len] gives the
* previous opcode.
*/
extern JS_REQUIRES_STACK void
js_TraceOpcode(JSContext *cx);
/*
* JS_OPMETER helper functions.
*/
extern void
js_MeterOpcodePair(JSOp op1, JSOp op2);
extern void
js_MeterSlotOpcode(JSOp op, uint32 slot);
#endif /* JS_LONE_INTERPRET */
/*
* Unwind block and scope chains to match the given depth. The function sets
* fp->sp on return to stackDepth.
*/
extern JS_REQUIRES_STACK JSBool
js_UnwindScope(JSContext *cx, jsint stackDepth, JSBool normalUnwind);
extern JSBool
js_OnUnknownMethod(JSContext *cx, js::Value *vp);
extern JS_REQUIRES_STACK js::Class *
js_IsActiveWithOrBlock(JSContext *cx, JSObject *obj, int stackDepth);
inline JSObject *
JSStackFrame::getThisObject(JSContext *cx)
{
JS_ASSERT(!isDummyFrame());
return thisv.isPrimitive() ? computeThisObject(cx) : &thisv.toObject();
}
#endif /* jsinterp_h___ */
Reference in New Issue View Git Blame Copy Permalink