blob: 7ebe8451dcaad16051bb0cf8eb46a8cc77ad1089 [file] [log] [blame]
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
* vim: set ts=8 sts=4 et sw=4 tw=99:
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef jsfun_h
#define jsfun_h
/*
* JS function definitions.
*/
#include "jsprvtd.h"
#include "jsobj.h"
#include "gc/Barrier.h"
namespace js { class FunctionExtended; }
class JSFunction : public JSObject
{
public:
static js::Class class_;
enum Flags {
INTERPRETED = 0x0001, /* function has a JSScript and environment. */
NATIVE_CTOR = 0x0002, /* native that can be called as a constructor */
EXTENDED = 0x0004, /* structure is FunctionExtended */
IS_FUN_PROTO = 0x0010, /* function is Function.prototype for some global object */
EXPR_CLOSURE = 0x0020, /* expression closure: function(x) x*x */
HAS_GUESSED_ATOM = 0x0040, /* function had no explicit name, but a
name was guessed for it anyway */
LAMBDA = 0x0080, /* function comes from a FunctionExpression, ArrowFunction, or
Function() call (not a FunctionDeclaration or nonstandard
function-statement) */
SELF_HOSTED = 0x0100, /* function is self-hosted builtin and must not be
decompilable nor constructible. */
SELF_HOSTED_CTOR = 0x0200, /* function is self-hosted builtin constructor and
must be constructible but not decompilable. */
HAS_REST = 0x0400, /* function has a rest (...) parameter */
HAS_DEFAULTS = 0x0800, /* function has at least one default parameter */
INTERPRETED_LAZY = 0x1000, /* function is interpreted but doesn't have a script yet */
ARROW = 0x2000, /* ES6 '(args) => body' syntax */
SH_WRAPPABLE = 0x4000, /* self-hosted function is wrappable, doesn't need to be cloned */
/* Derived Flags values for convenience: */
NATIVE_FUN = 0,
INTERPRETED_LAMBDA = INTERPRETED | LAMBDA,
INTERPRETED_LAMBDA_ARROW = INTERPRETED | LAMBDA | ARROW
};
static void staticAsserts() {
JS_STATIC_ASSERT(INTERPRETED == JS_FUNCTION_INTERPRETED_BIT);
MOZ_STATIC_ASSERT(sizeof(JSFunction) == sizeof(js::shadow::Function),
"shadow interface must match actual interface");
}
uint16_t nargs; /* maximum number of specified arguments,
reflected as f.length/f.arity */
uint16_t flags; /* bitfield composed of the above Flags enum */
union U {
class Native {
friend class JSFunction;
js::Native native; /* native method pointer or null */
const JSJitInfo *jitinfo; /* Information about this function to be
used by the JIT;
use the accessor! */
} n;
struct Scripted {
union {
JSScript *script_; /* interpreted bytecode descriptor or null;
use the accessor! */
js::LazyScript *lazy_; /* lazily compiled script, or NULL */
} s;
JSObject *env_; /* environment for new activations;
use the accessor! */
} i;
void *nativeOrScript;
} u;
private:
js::HeapPtrAtom atom_; /* name for diagnostics and decompiling */
public:
/* Call objects must be created for each invocation of a heavyweight function. */
inline bool isHeavyweight() const;
/* A function can be classified as either native (C++) or interpreted (JS): */
bool isInterpreted() const { return flags & (INTERPRETED | INTERPRETED_LAZY); }
bool isNative() const { return !isInterpreted(); }
/* Possible attributes of a native function: */
bool isNativeConstructor() const { return flags & NATIVE_CTOR; }
/* Possible attributes of an interpreted function: */
bool isFunctionPrototype() const { return flags & IS_FUN_PROTO; }
bool isInterpretedLazy() const { return flags & INTERPRETED_LAZY; }
bool hasScript() const { return flags & INTERPRETED; }
bool isExprClosure() const { return flags & EXPR_CLOSURE; }
bool hasGuessedAtom() const { return flags & HAS_GUESSED_ATOM; }
bool isLambda() const { return flags & LAMBDA; }
bool isSelfHostedBuiltin() const { return flags & SELF_HOSTED; }
bool isSelfHostedConstructor() const { return flags & SELF_HOSTED_CTOR; }
bool hasRest() const { return flags & HAS_REST; }
bool hasDefaults() const { return flags & HAS_DEFAULTS; }
bool isWrappable() const {
JS_ASSERT_IF(flags & SH_WRAPPABLE, isSelfHostedBuiltin());
return flags & SH_WRAPPABLE;
}
// Arrow functions are a little weird.
//
// Like all functions, (1) when the compiler parses an arrow function, it
// creates a function object that gets stored with the enclosing script;
// and (2) at run time the script's function object is cloned.
//
// But then, unlike other functions, (3) a bound function is created with
// the clone as its target.
//
// isArrow() is true for all three of these Function objects.
// isBoundFunction() is true only for the last one.
bool isArrow() const { return flags & ARROW; }
/* Compound attributes: */
bool isBuiltin() const {
return isNative() || isSelfHostedBuiltin();
}
bool isInterpretedConstructor() const {
return isInterpreted() && !isFunctionPrototype() &&
(!isSelfHostedBuiltin() || isSelfHostedConstructor());
}
bool isNamedLambda() const {
return isLambda() && atom_ && !hasGuessedAtom();
}
/* Returns the strictness of this function, which must be interpreted. */
inline bool strict() const;
// Can be called multiple times by the parser.
void setArgCount(uint16_t nargs) {
this->nargs = nargs;
}
// Can be called multiple times by the parser.
void setHasRest() {
flags |= HAS_REST;
}
// Can be called multiple times by the parser.
void setHasDefaults() {
flags |= HAS_DEFAULTS;
}
void setIsSelfHostedBuiltin() {
JS_ASSERT(!isSelfHostedBuiltin());
flags |= SELF_HOSTED;
}
void setIsSelfHostedConstructor() {
JS_ASSERT(!isSelfHostedConstructor());
flags |= SELF_HOSTED_CTOR;
}
void makeWrappable() {
JS_ASSERT(isSelfHostedBuiltin());
JS_ASSERT(!isWrappable());
flags |= SH_WRAPPABLE;
}
void setIsFunctionPrototype() {
JS_ASSERT(!isFunctionPrototype());
flags |= IS_FUN_PROTO;
}
// Can be called multiple times by the parser.
void setIsExprClosure() {
flags |= EXPR_CLOSURE;
}
JSAtom *atom() const { return hasGuessedAtom() ? NULL : atom_.get(); }
js::PropertyName *name() const { return hasGuessedAtom() || !atom_ ? NULL : atom_->asPropertyName(); }
inline void initAtom(JSAtom *atom);
JSAtom *displayAtom() const { return atom_; }
inline void setGuessedAtom(JSAtom *atom);
/* uint16_t representation bounds number of call object dynamic slots. */
enum { MAX_ARGS_AND_VARS = 2 * ((1U << 16) - 1) };
/*
* For an interpreted function, accessors for the initial scope object of
* activations (stack frames) of the function.
*/
inline JSObject *environment() const;
inline void setEnvironment(JSObject *obj);
inline void initEnvironment(JSObject *obj);
static inline size_t offsetOfEnvironment() { return offsetof(JSFunction, u.i.env_); }
static inline size_t offsetOfAtom() { return offsetof(JSFunction, atom_); }
#if defined(JS_CPU_MIPS)
static inline size_t offsetOfNargs() { return offsetof(JSFunction, nargs); }
static inline size_t offsetOfFlags() { return offsetof(JSFunction, flags); }
#endif
static bool createScriptForLazilyInterpretedFunction(JSContext *cx, js::HandleFunction fun);
// Function Scripts
//
// Interpreted functions may either have an explicit JSScript (hasScript())
// or be lazy with sufficient information to construct the JSScript if
// necessary (isInterpretedLazy()).
//
// A lazy function will have a LazyScript if the function came from parsed
// source, or NULL if the function is a clone of a self hosted function.
//
// There are several methods to get the script of an interpreted function:
//
// - For all interpreted functions, getOrCreateScript() will get the
// JSScript, delazifying the function if necessary. This is the safest to
// use, but has extra checks, requires a cx and may trigger a GC.
//
// - For functions which may have a LazyScript but whose JSScript is known
// to exist, existingScript() will get the script and delazify the
// function if necessary.
//
// - For functions known to have a JSScript, nonLazyScript() will get it.
JSScript *getOrCreateScript(JSContext *cx) {
JS_ASSERT(isInterpreted());
JS_ASSERT(cx);
if (isInterpretedLazy()) {
JS::RootedFunction self(cx, this);
if (!createScriptForLazilyInterpretedFunction(cx, self))
return NULL;
JS_ASSERT(self->hasScript());
return self->u.i.s.script_;
}
JS_ASSERT(hasScript());
return u.i.s.script_;
}
inline JSScript *existingScript();
inline JSScript* existingScriptForInlinedFunction();
JSScript *nonLazyScript() const {
JS_ASSERT(hasScript());
return JS::HandleScript::fromMarkedLocation(&u.i.s.script_);
}
js::HeapPtrScript &mutableScript() {
JS_ASSERT(isInterpreted());
return *(js::HeapPtrScript *)&u.i.s.script_;
}
js::LazyScript *lazyScript() const {
JS_ASSERT(isInterpretedLazy() && u.i.s.lazy_);
return u.i.s.lazy_;
}
js::LazyScript *lazyScriptOrNull() const {
JS_ASSERT(isInterpretedLazy());
return u.i.s.lazy_;
}
inline void setScript(JSScript *script_);
inline void initScript(JSScript *script_);
inline void initLazyScript(js::LazyScript *script);
JSNative native() const {
JS_ASSERT(isNative());
return u.n.native;
}
JSNative maybeNative() const {
return isInterpreted() ? NULL : native();
}
inline void initNative(js::Native native, const JSJitInfo *jitinfo);
inline const JSJitInfo *jitInfo() const;
inline void setJitInfo(const JSJitInfo *data);
static unsigned offsetOfNativeOrScript() {
JS_STATIC_ASSERT(offsetof(U, n.native) == offsetof(U, i.s.script_));
JS_STATIC_ASSERT(offsetof(U, n.native) == offsetof(U, nativeOrScript));
return offsetof(JSFunction, u.nativeOrScript);
}
#if JS_BITS_PER_WORD == 32
static const js::gc::AllocKind FinalizeKind = js::gc::FINALIZE_OBJECT2_BACKGROUND;
static const js::gc::AllocKind ExtendedFinalizeKind = js::gc::FINALIZE_OBJECT4_BACKGROUND;
#else
static const js::gc::AllocKind FinalizeKind = js::gc::FINALIZE_OBJECT4_BACKGROUND;
static const js::gc::AllocKind ExtendedFinalizeKind = js::gc::FINALIZE_OBJECT8_BACKGROUND;
#endif
inline void trace(JSTracer *trc);
/* Bound function accessors. */
inline bool initBoundFunction(JSContext *cx, js::HandleValue thisArg,
const js::Value *args, unsigned argslen);
inline JSObject *getBoundFunctionTarget() const;
inline const js::Value &getBoundFunctionThis() const;
inline const js::Value &getBoundFunctionArgument(unsigned which) const;
inline size_t getBoundFunctionArgumentCount() const;
private:
inline js::FunctionExtended *toExtended();
inline const js::FunctionExtended *toExtended() const;
public:
inline bool isExtended() const {
JS_STATIC_ASSERT(FinalizeKind != ExtendedFinalizeKind);
JS_ASSERT_IF(isTenured(), !!(flags & EXTENDED) == (tenuredGetAllocKind() == ExtendedFinalizeKind));
return !!(flags & EXTENDED);
}
/*
* Accessors for data stored in extended functions. Use setExtendedSlot if
* the function has already been initialized. Otherwise use
* initExtendedSlot.
*/
inline void initializeExtended();
inline void initExtendedSlot(size_t which, const js::Value &val);
inline void setExtendedSlot(size_t which, const js::Value &val);
inline const js::Value &getExtendedSlot(size_t which) const;
/* Constructs a new type for the function if necessary. */
static bool setTypeForScriptedFunction(JSContext *cx, js::HandleFunction fun,
bool singleton = false);
/* GC support. */
js::gc::AllocKind getAllocKind() const {
js::gc::AllocKind kind = FinalizeKind;
if (isExtended())
kind = ExtendedFinalizeKind;
JS_ASSERT_IF(isTenured(), kind == tenuredGetAllocKind());
return kind;
}
};
extern JSString *
fun_toStringHelper(JSContext *cx, js::HandleObject obj, unsigned indent);
inline JSFunction::Flags
JSAPIToJSFunctionFlags(unsigned flags)
{
return (flags & JSFUN_CONSTRUCTOR)
? JSFunction::NATIVE_CTOR
: JSFunction::NATIVE_FUN;
}
namespace js {
extern JSFunction *
NewFunction(JSContext *cx, HandleObject funobj, JSNative native, unsigned nargs,
JSFunction::Flags flags, HandleObject parent, HandleAtom atom,
gc::AllocKind allocKind = JSFunction::FinalizeKind,
NewObjectKind newKind = GenericObject);
extern JSFunction *
DefineFunction(JSContext *cx, HandleObject obj, HandleId id, JSNative native,
unsigned nargs, unsigned flags,
gc::AllocKind allocKind = JSFunction::FinalizeKind,
NewObjectKind newKind = GenericObject);
/*
* Function extended with reserved slots for use by various kinds of functions.
* Most functions do not have these extensions, but enough do that efficient
* storage is required (no malloc'ed reserved slots).
*/
class FunctionExtended : public JSFunction
{
public:
static const unsigned NUM_EXTENDED_SLOTS = 2;
private:
friend class JSFunction;
/* Reserved slots available for storage by particular native functions. */
HeapValue extendedSlots[NUM_EXTENDED_SLOTS];
};
extern JSFunction *
CloneFunctionObject(JSContext *cx, HandleFunction fun, HandleObject parent,
gc::AllocKind kind = JSFunction::FinalizeKind,
NewObjectKind newKindArg = GenericObject);
} // namespace js
inline js::FunctionExtended *
JSFunction::toExtended()
{
JS_ASSERT(isExtended());
return static_cast<js::FunctionExtended *>(this);
}
inline const js::FunctionExtended *
JSFunction::toExtended() const
{
JS_ASSERT(isExtended());
return static_cast<const js::FunctionExtended *>(this);
}
namespace js {
JSString *FunctionToString(JSContext *cx, HandleFunction fun, bool bodyOnly, bool lambdaParen);
template<XDRMode mode>
bool
XDRInterpretedFunction(XDRState<mode> *xdr, HandleObject enclosingScope,
HandleScript enclosingScript, MutableHandleObject objp);
extern JSObject *
CloneFunctionAndScript(JSContext *cx, HandleObject enclosingScope, HandleFunction fun);
/*
* Report an error that call.thisv is not compatible with the specified class,
* assuming that the method (clasp->name).prototype.<name of callee function>
* is what was called.
*/
extern void
ReportIncompatibleMethod(JSContext *cx, CallReceiver call, Class *clasp);
/*
* Report an error that call.thisv is not an acceptable this for the callee
* function.
*/
extern void
ReportIncompatible(JSContext *cx, CallReceiver call);
JSBool
CallOrConstructBoundFunction(JSContext *, unsigned, js::Value *);
extern const JSFunctionSpec function_methods[];
} /* namespace js */
extern JSBool
js_fun_apply(JSContext *cx, unsigned argc, js::Value *vp);
extern JSBool
js_fun_call(JSContext *cx, unsigned argc, js::Value *vp);
extern JSObject*
js_fun_bind(JSContext *cx, js::HandleObject target, js::HandleValue thisArg,
js::Value *boundArgs, unsigned argslen);
#endif /* jsfun_h */