/* -*- 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 "jsobj.h" #include "jsscript.h" #include "jstypes.h" namespace js { namespace frontend { class FunctionBox; } class FunctionExtended; typedef JSNative Native; } // namespace js struct JSAtomState; class JSFunction : public js::NativeObject { public: static const js::Class class_; enum FunctionKind { NormalFunction = 0, Arrow, /* ES6 '(args) => body' syntax */ Method, /* ES6 MethodDefinition */ ClassConstructor, Getter, Setter, AsmJS, /* function is an asm.js module or exported function */ FunctionKindLimit }; enum Flags { INTERPRETED = 0x0001, /* function has a JSScript and environment. */ CONSTRUCTOR = 0x0002, /* function that can be called as a constructor */ EXTENDED = 0x0004, /* structure is FunctionExtended */ IS_FUN_PROTO = 0x0008, /* function is Function.prototype for some global object */ EXPR_BODY = 0x0010, /* arrow function with expression body or * expression closure: function(x) x*x */ HAS_GUESSED_ATOM = 0x0020, /* function had no explicit name, but a name was guessed for it anyway */ LAMBDA = 0x0040, /* function comes from a FunctionExpression, ArrowFunction, or Function() call (not a FunctionDeclaration or nonstandard function-statement) */ SELF_HOSTED = 0x0080, /* function is self-hosted builtin and must not be decompilable nor constructible. */ HAS_REST = 0x0100, /* function has a rest (...) parameter */ INTERPRETED_LAZY = 0x0200, /* function is interpreted but doesn't have a script yet */ RESOLVED_LENGTH = 0x0400, /* f.length has been resolved (see fun_resolve). */ RESOLVED_NAME = 0x0800, /* f.name has been resolved (see fun_resolve). */ BEING_PARSED = 0x1000, /* function is currently being parsed; has a funbox in place of an environment */ FUNCTION_KIND_SHIFT = 13, FUNCTION_KIND_MASK = 0x7 << FUNCTION_KIND_SHIFT, ASMJS_KIND = AsmJS << FUNCTION_KIND_SHIFT, ARROW_KIND = Arrow << FUNCTION_KIND_SHIFT, METHOD_KIND = Method << FUNCTION_KIND_SHIFT, CLASSCONSTRUCTOR_KIND = ClassConstructor << FUNCTION_KIND_SHIFT, GETTER_KIND = Getter << FUNCTION_KIND_SHIFT, SETTER_KIND = Setter << FUNCTION_KIND_SHIFT, /* Derived Flags values for convenience: */ NATIVE_FUN = 0, NATIVE_CTOR = NATIVE_FUN | CONSTRUCTOR, NATIVE_CLASS_CTOR = NATIVE_FUN | CONSTRUCTOR | CLASSCONSTRUCTOR_KIND, ASMJS_CTOR = ASMJS_KIND | NATIVE_CTOR, ASMJS_LAMBDA_CTOR = ASMJS_KIND | NATIVE_CTOR | LAMBDA, INTERPRETED_METHOD = INTERPRETED | METHOD_KIND, INTERPRETED_METHOD_GENERATOR = INTERPRETED | METHOD_KIND, INTERPRETED_CLASS_CONSTRUCTOR = INTERPRETED | CLASSCONSTRUCTOR_KIND | CONSTRUCTOR, INTERPRETED_GETTER = INTERPRETED | GETTER_KIND, INTERPRETED_SETTER = INTERPRETED | SETTER_KIND, INTERPRETED_LAMBDA = INTERPRETED | LAMBDA | CONSTRUCTOR, INTERPRETED_LAMBDA_ARROW = INTERPRETED | LAMBDA | ARROW_KIND, INTERPRETED_LAMBDA_GENERATOR = INTERPRETED | LAMBDA, INTERPRETED_NORMAL = INTERPRETED | CONSTRUCTOR, INTERPRETED_GENERATOR = INTERPRETED, NO_XDR_FLAGS = RESOLVED_LENGTH | RESOLVED_NAME, STABLE_ACROSS_CLONES = IS_FUN_PROTO | CONSTRUCTOR | EXPR_BODY | HAS_GUESSED_ATOM | LAMBDA | SELF_HOSTED | HAS_REST | FUNCTION_KIND_MASK }; static_assert((INTERPRETED | INTERPRETED_LAZY) == js::JS_FUNCTION_INTERPRETED_BITS, "jsfriendapi.h's JSFunction::INTERPRETED-alike is wrong"); static_assert(((FunctionKindLimit - 1) << FUNCTION_KIND_SHIFT) <= FUNCTION_KIND_MASK, "FunctionKind doesn't fit into flags_"); // Implemented in Parser.cpp. Used so the static scope chain may be walked // in Parser without a JSScript. class MOZ_STACK_CLASS AutoParseUsingFunctionBox { js::RootedFunction fun_; js::RootedObject oldEnv_; public: AutoParseUsingFunctionBox(js::ExclusiveContext* cx, js::frontend::FunctionBox* funbox); ~AutoParseUsingFunctionBox(); }; private: uint16_t nargs_; /* number of formal arguments (including defaults and the rest parameter unlike f.length) */ uint16_t flags_; /* bitfield composed of the above Flags enum, as well as the kind */ 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 nullptr */ } s; union { JSObject* env_; /* environment for new activations; use the accessor! */ js::frontend::FunctionBox* funbox_; /* the function box when parsing */ }; } i; void* nativeOrScript; } u; js::HeapPtrAtom atom_; /* name for diagnostics and decompiling */ public: /* Call objects must be created for each invocation of this function. */ bool needsCallObject() const { MOZ_ASSERT(!isInterpretedLazy()); MOZ_ASSERT(!isBeingParsed()); if (isNative()) return false; // Note: this should be kept in sync with FunctionBox::needsCallObject(). return nonLazyScript()->hasAnyAliasedBindings() || nonLazyScript()->funHasExtensibleScope() || nonLazyScript()->funNeedsDeclEnvObject() || nonLazyScript()->needsHomeObject() || nonLazyScript()->isDerivedClassConstructor() || isGenerator(); } size_t nargs() const { return nargs_; } uint16_t flags() const { return flags_; } FunctionKind kind() const { return static_cast((flags_ & FUNCTION_KIND_MASK) >> FUNCTION_KIND_SHIFT); } /* 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(); } bool isConstructor() const { return flags() & CONSTRUCTOR; } /* Possible attributes of a native function: */ bool isAsmJSNative() const { return kind() == AsmJS; } /* Possible attributes of an interpreted function: */ bool isFunctionPrototype() const { return flags() & IS_FUN_PROTO; } bool isExprBody() const { return flags() & EXPR_BODY; } bool hasGuessedAtom() const { return flags() & HAS_GUESSED_ATOM; } bool isLambda() const { return flags() & LAMBDA; } bool isSelfHostedBuiltin() const { return flags() & SELF_HOSTED; } bool hasRest() const { return flags() & HAS_REST; } bool isInterpretedLazy() const { return flags() & INTERPRETED_LAZY; } bool hasScript() const { return flags() & INTERPRETED; } bool isBeingParsed() const { return flags() & BEING_PARSED; } // Arrow functions store their lexical new.target in the first extended slot. bool isArrow() const { return kind() == Arrow; } // Every class-constructor is also a method. bool isMethod() const { return kind() == Method || kind() == ClassConstructor; } bool isClassConstructor() const { return kind() == ClassConstructor; } bool isGetter() const { return kind() == Getter; } bool isSetter() const { return kind() == Setter; } bool allowSuperProperty() const { return isMethod() || isGetter() || isSetter(); } bool hasResolvedLength() const { return flags() & RESOLVED_LENGTH; } bool hasResolvedName() const { return flags() & RESOLVED_NAME; } bool hasJITCode() const { if (!hasScript()) return false; return nonLazyScript()->hasBaselineScript() || nonLazyScript()->hasIonScript(); } /* Compound attributes: */ bool isBuiltin() const { return (isNative() && !isAsmJSNative()) || isSelfHostedBuiltin(); } bool isNamedLambda() const { return isLambda() && displayAtom() && !hasGuessedAtom(); } bool hasLexicalThis() const { return isArrow() || nonLazyScript()->isGeneratorExp(); } bool isBuiltinFunctionConstructor(); /* Returns the strictness of this function, which must be interpreted. */ bool strict() const { MOZ_ASSERT(isInterpreted()); return isInterpretedLazy() ? lazyScript()->strict() : nonLazyScript()->strict(); } void setFlags(uint16_t flags) { this->flags_ = flags; } void setKind(FunctionKind kind) { this->flags_ &= ~FUNCTION_KIND_MASK; this->flags_ |= static_cast(kind) << FUNCTION_KIND_SHIFT; } // Make the function constructible. void setIsConstructor() { MOZ_ASSERT(!isConstructor()); MOZ_ASSERT(isSelfHostedBuiltin()); flags_ |= CONSTRUCTOR; } // 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; } void setIsSelfHostedBuiltin() { MOZ_ASSERT(!isSelfHostedBuiltin()); flags_ |= SELF_HOSTED; // Self-hosted functions should not be constructable. flags_ &= ~CONSTRUCTOR; } void setIsFunctionPrototype() { MOZ_ASSERT(!isFunctionPrototype()); flags_ |= IS_FUN_PROTO; } // Can be called multiple times by the parser. void setIsExprBody() { flags_ |= EXPR_BODY; } void setArrow() { setKind(Arrow); } void setResolvedLength() { flags_ |= RESOLVED_LENGTH; } void setResolvedName() { flags_ |= RESOLVED_NAME; } void setAsyncKind(js::FunctionAsyncKind asyncKind) { if (isInterpretedLazy()) lazyScript()->setAsyncKind(asyncKind); else nonLazyScript()->setAsyncKind(asyncKind); } JSAtom* atom() const { return hasGuessedAtom() ? nullptr : atom_.get(); } js::PropertyName* name() const { return hasGuessedAtom() || !atom_ ? nullptr : atom_->asPropertyName(); } void initAtom(JSAtom* atom) { atom_.init(atom); } void setAtom(JSAtom* atom) { atom_ = atom; } JSAtom* displayAtom() const { return atom_; } void setGuessedAtom(JSAtom* atom) { MOZ_ASSERT(!atom_); MOZ_ASSERT(atom); MOZ_ASSERT(!hasGuessedAtom()); atom_ = atom; flags_ |= HAS_GUESSED_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. */ JSObject* environment() const { MOZ_ASSERT(isInterpreted() && !isBeingParsed()); return u.i.env_; } void setEnvironment(JSObject* obj) { MOZ_ASSERT(isInterpreted() && !isBeingParsed()); *reinterpret_cast(&u.i.env_) = obj; } void initEnvironment(JSObject* obj) { MOZ_ASSERT(isInterpreted() && !isBeingParsed()); reinterpret_cast(&u.i.env_)->init(obj); } void unsetEnvironment() { setEnvironment(nullptr); } private: void setFunctionBox(js::frontend::FunctionBox* funbox) { MOZ_ASSERT(isInterpreted()); MOZ_ASSERT_IF(!isBeingParsed(), !environment()); flags_ |= BEING_PARSED; u.i.funbox_ = funbox; } void unsetFunctionBox() { MOZ_ASSERT(isBeingParsed()); flags_ &= ~BEING_PARSED; u.i.funbox_ = nullptr; } public: static inline size_t offsetOfNargs() { return offsetof(JSFunction, nargs_); } static inline size_t offsetOfFlags() { return offsetof(JSFunction, flags_); } static inline size_t offsetOfEnvironment() { return offsetof(JSFunction, u.i.env_); } static inline size_t offsetOfAtom() { return offsetof(JSFunction, atom_); } static bool createScriptForLazilyInterpretedFunction(JSContext* cx, js::HandleFunction fun); void maybeRelazify(JSRuntime* rt); // 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 nullptr 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 inlined functions which may have a LazyScript but whose JSScript // is known to exist, existingScriptForInlinedFunction() 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) { MOZ_ASSERT(isInterpreted()); MOZ_ASSERT(cx); if (isInterpretedLazy()) { JS::RootedFunction self(cx, this); if (!createScriptForLazilyInterpretedFunction(cx, self)) return nullptr; return self->nonLazyScript(); } return nonLazyScript(); } JSScript* existingScriptForInlinedFunction() { MOZ_ASSERT(isInterpreted()); if (isInterpretedLazy()) { // Get the script from the canonical function. Ion used the // canonical function to inline the script and because it has // Baseline code it has not been relazified. Note that we can't // use lazyScript->script_ here as it may be null in some cases, // see bug 976536. js::LazyScript* lazy = lazyScript(); JSFunction* fun = lazy->functionNonDelazifying(); MOZ_ASSERT(fun); JSScript* script = fun->nonLazyScript(); if (shadowZone()->needsIncrementalBarrier()) js::LazyScript::writeBarrierPre(lazy); flags_ &= ~INTERPRETED_LAZY; flags_ |= INTERPRETED; initScript(script); } return nonLazyScript(); } // If this is a scripted function, returns its canonical function (the // original function allocated by the frontend). Note that lazy self-hosted // builtins don't have a lazy script so in that case we also return nullptr. JSFunction* maybeCanonicalFunction() const { if (hasScript()) { return nonLazyScript()->functionNonDelazifying(); } if (isInterpretedLazy() && !isSelfHostedBuiltin()) { return lazyScript()->functionNonDelazifying(); } return nullptr; } // The state of a JSFunction whose script errored out during bytecode // compilation. Such JSFunctions are only reachable via GC iteration and // not from script. bool hasUncompiledScript() const { MOZ_ASSERT(hasScript()); return !u.i.s.script_; } JSScript* nonLazyScript() const { MOZ_ASSERT(!hasUncompiledScript()); return u.i.s.script_; } bool getLength(JSContext* cx, uint16_t* length) { JS::RootedFunction self(cx, this); if (self->isInterpretedLazy() && !self->getOrCreateScript(cx)) return false; *length = self->hasScript() ? self->nonLazyScript()->funLength() : (self->nargs() - self->hasRest()); return true; } js::LazyScript* lazyScript() const { MOZ_ASSERT(isInterpretedLazy() && u.i.s.lazy_); return u.i.s.lazy_; } js::LazyScript* lazyScriptOrNull() const { MOZ_ASSERT(isInterpretedLazy()); return u.i.s.lazy_; } js::frontend::FunctionBox* functionBox() const { MOZ_ASSERT(isBeingParsed()); return u.i.funbox_; } js::GeneratorKind generatorKind() const { if (!isInterpreted()) return js::NotGenerator; if (hasScript()) return nonLazyScript()->generatorKind(); if (js::LazyScript* lazy = lazyScriptOrNull()) return lazy->generatorKind(); MOZ_ASSERT(isSelfHostedBuiltin()); return js::NotGenerator; } bool isGenerator() const { return generatorKind() != js::NotGenerator; } bool isLegacyGenerator() const { return generatorKind() == js::LegacyGenerator; } bool isStarGenerator() const { return generatorKind() == js::StarGenerator; } js::FunctionAsyncKind asyncKind() const { return isInterpretedLazy() ? lazyScript()->asyncKind() : nonLazyScript()->asyncKind(); } bool isAsync() const { if (isInterpretedLazy()) return lazyScript()->asyncKind() == js::AsyncFunction; if (hasScript()) return nonLazyScript()->asyncKind() == js::AsyncFunction; return false; } void setScript(JSScript* script_) { mutableScript() = script_; } void initScript(JSScript* script_) { mutableScript().init(script_); } void setUnlazifiedScript(JSScript* script) { // Note: createScriptForLazilyInterpretedFunction triggers a barrier on // lazy script before it is overwritten here. MOZ_ASSERT(isInterpretedLazy()); if (lazyScriptOrNull() && !lazyScript()->maybeScript()) lazyScript()->initScript(script); flags_ &= ~INTERPRETED_LAZY; flags_ |= INTERPRETED; initScript(script); } void initLazyScript(js::LazyScript* lazy) { MOZ_ASSERT(isInterpreted()); flags_ &= ~INTERPRETED; flags_ |= INTERPRETED_LAZY; u.i.s.lazy_ = lazy; } JSNative native() const { MOZ_ASSERT(isNative()); return u.n.native; } JSNative maybeNative() const { return isInterpreted() ? nullptr : native(); } void initNative(js::Native native, const JSJitInfo* jitinfo) { MOZ_ASSERT(native); u.n.native = native; u.n.jitinfo = jitinfo; } const JSJitInfo* jitInfo() const { MOZ_ASSERT(isNative()); return u.n.jitinfo; } void setJitInfo(const JSJitInfo* data) { MOZ_ASSERT(isNative()); u.n.jitinfo = data; } bool isDerivedClassConstructor() { bool derived; if (isInterpretedLazy()) derived = !isSelfHostedBuiltin() && lazyScript()->isDerivedClassConstructor(); else derived = nonLazyScript()->isDerivedClassConstructor(); MOZ_ASSERT_IF(derived, isClassConstructor()); return derived; } static unsigned offsetOfNativeOrScript() { static_assert(offsetof(U, n.native) == offsetof(U, i.s.script_), "native and script pointers must be in the same spot " "for offsetOfNativeOrScript() have any sense"); static_assert(offsetof(U, n.native) == offsetof(U, nativeOrScript), "U::nativeOrScript must be at the same offset as " "native"); return offsetof(JSFunction, u.nativeOrScript); } inline void trace(JSTracer* trc); /* Bound function accessors. */ inline bool initBoundFunction(JSContext* cx, js::HandleObject target, js::HandleValue thisArg, const js::Value* args, unsigned argslen); JSObject* getBoundFunctionTarget() const; const js::Value& getBoundFunctionThis() const; const js::Value& getBoundFunctionArgument(unsigned which) const; size_t getBoundFunctionArgumentCount() const; private: js::HeapPtrScript& mutableScript() { MOZ_ASSERT(hasScript()); return *(js::HeapPtrScript*)&u.i.s.script_; } inline js::FunctionExtended* toExtended(); inline const js::FunctionExtended* toExtended() const; public: inline bool isExtended() const { bool extended = !!(flags() & EXTENDED); MOZ_ASSERT_IF(isTenured(), extended == (asTenured().getAllocKind() == js::gc::AllocKind::FUNCTION_EXTENDED)); return 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(js::ExclusiveContext* cx, js::HandleFunction fun, bool singleton = false); /* GC support. */ js::gc::AllocKind getAllocKind() const { static_assert(js::gc::AllocKind::FUNCTION != js::gc::AllocKind::FUNCTION_EXTENDED, "extended/non-extended AllocKinds have to be different " "for getAllocKind() to have a reason to exist"); js::gc::AllocKind kind = js::gc::AllocKind::FUNCTION; if (isExtended()) kind = js::gc::AllocKind::FUNCTION_EXTENDED; MOZ_ASSERT_IF(isTenured(), kind == asTenured().getAllocKind()); return kind; } }; static_assert(sizeof(JSFunction) == sizeof(js::shadow::Function), "shadow interface must match actual interface"); extern JSString* fun_toStringHelper(JSContext* cx, js::HandleObject obj, unsigned indent); namespace js { extern bool Function(JSContext* cx, unsigned argc, Value* vp); extern bool Generator(JSContext* cx, unsigned argc, Value* vp); // Allocate a new function backed by a JSNative. extern JSFunction* NewNativeFunction(ExclusiveContext* cx, JSNative native, unsigned nargs, HandleAtom atom, gc::AllocKind allocKind = gc::AllocKind::FUNCTION, NewObjectKind newKind = GenericObject); // Allocate a new constructor backed by a JSNative. extern JSFunction* NewNativeConstructor(ExclusiveContext* cx, JSNative native, unsigned nargs, HandleAtom atom, gc::AllocKind allocKind = gc::AllocKind::FUNCTION, NewObjectKind newKind = GenericObject, JSFunction::Flags flags = JSFunction::NATIVE_CTOR); // Allocate a new scripted function. If enclosingDynamicScope is null, the // global will be used. In all cases the parent of the resulting object will be // the global. extern JSFunction* NewScriptedFunction(ExclusiveContext* cx, unsigned nargs, JSFunction::Flags flags, HandleAtom atom, gc::AllocKind allocKind = gc::AllocKind::FUNCTION, NewObjectKind newKind = GenericObject, HandleObject enclosingDynamicScope = nullptr); // By default, if proto is nullptr, Function.prototype is used instead.i // If protoHandling is NewFunctionExactProto, and proto is nullptr, the created // function will use nullptr as its [[Prototype]] instead. If // enclosingDynamicScope is null, the function will have a null environment() // (yes, null, not the global). In all cases, the global will be used as the // parent. enum NewFunctionProtoHandling { NewFunctionClassProto, NewFunctionGivenProto }; extern JSFunction* NewFunctionWithProto(ExclusiveContext* cx, JSNative native, unsigned nargs, JSFunction::Flags flags, HandleObject enclosingDynamicScope, HandleAtom atom, HandleObject proto, gc::AllocKind allocKind = gc::AllocKind::FUNCTION, NewObjectKind newKind = GenericObject, NewFunctionProtoHandling protoHandling = NewFunctionClassProto); extern JSAtom* IdToFunctionName(JSContext* cx, HandleId id); extern JSFunction* DefineFunction(JSContext* cx, HandleObject obj, HandleId id, JSNative native, unsigned nargs, unsigned flags, gc::AllocKind allocKind = gc::AllocKind::FUNCTION); bool FunctionHasResolveHook(const JSAtomState& atomState, jsid id); extern bool fun_toString(JSContext* cx, unsigned argc, Value* vp); extern bool fun_bind(JSContext* cx, unsigned argc, Value* vp); struct WellKnownSymbols; extern bool FunctionHasDefaultHasInstance(JSFunction* fun, const WellKnownSymbols& symbols); extern bool fun_symbolHasInstance(JSContext* cx, unsigned argc, Value* vp); extern bool OrdinaryHasInstance(JSContext* cx, HandleObject objArg, MutableHandleValue v, bool* bp); /* * 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; /* Arrow functions store their lexical new.target in the first extended slot. */ static const unsigned ARROW_NEWTARGET_SLOT = 0; static const unsigned METHOD_HOMEOBJECT_SLOT = 0; static inline size_t offsetOfExtendedSlot(unsigned which) { MOZ_ASSERT(which < NUM_EXTENDED_SLOTS); return offsetof(FunctionExtended, extendedSlots) + which * sizeof(HeapValue); } static inline size_t offsetOfArrowNewTargetSlot() { return offsetOfExtendedSlot(ARROW_NEWTARGET_SLOT); } private: friend class JSFunction; /* Reserved slots available for storage by particular native functions. */ HeapValue extendedSlots[NUM_EXTENDED_SLOTS]; }; extern bool CanReuseScriptForClone(JSCompartment* compartment, HandleFunction fun, HandleObject newParent); extern JSFunction* CloneFunctionReuseScript(JSContext* cx, HandleFunction fun, HandleObject parent, gc::AllocKind kind = gc::AllocKind::FUNCTION, NewObjectKind newKindArg = GenericObject, HandleObject proto = nullptr); // Functions whose scripts are cloned are always given singleton types. extern JSFunction* CloneFunctionAndScript(JSContext* cx, HandleFunction fun, HandleObject parent, HandleObject newStaticScope, gc::AllocKind kind = gc::AllocKind::FUNCTION, HandleObject proto = nullptr); extern bool FindBody(JSContext* cx, HandleFunction fun, HandleLinearString src, size_t* bodyStart, size_t* bodyEnd); } // namespace js inline js::FunctionExtended* JSFunction::toExtended() { MOZ_ASSERT(isExtended()); return static_cast(this); } inline const js::FunctionExtended* JSFunction::toExtended() const { MOZ_ASSERT(isExtended()); return static_cast(this); } inline void JSFunction::initializeExtended() { MOZ_ASSERT(isExtended()); MOZ_ASSERT(mozilla::ArrayLength(toExtended()->extendedSlots) == 2); toExtended()->extendedSlots[0].init(js::UndefinedValue()); toExtended()->extendedSlots[1].init(js::UndefinedValue()); } inline void JSFunction::initExtendedSlot(size_t which, const js::Value& val) { MOZ_ASSERT(which < mozilla::ArrayLength(toExtended()->extendedSlots)); toExtended()->extendedSlots[which].init(val); } inline void JSFunction::setExtendedSlot(size_t which, const js::Value& val) { MOZ_ASSERT(which < mozilla::ArrayLength(toExtended()->extendedSlots)); toExtended()->extendedSlots[which] = val; } inline const js::Value& JSFunction::getExtendedSlot(size_t which) const { MOZ_ASSERT(which < mozilla::ArrayLength(toExtended()->extendedSlots)); return toExtended()->extendedSlots[which]; } namespace js { JSString* FunctionToString(JSContext* cx, HandleFunction fun, bool lambdaParen); template bool XDRInterpretedFunction(XDRState* xdr, HandleObject enclosingScope, HandleScript enclosingScript, MutableHandleFunction objp); /* * Report an error that call.thisv is not compatible with the specified class, * assuming that the method (clasp->name).prototype. * is what was called. */ extern void ReportIncompatibleMethod(JSContext* cx, CallReceiver call, const Class* clasp); /* * Report an error that call.thisv is not an acceptable this for the callee * function. */ extern void ReportIncompatible(JSContext* cx, CallReceiver call); bool CallOrConstructBoundFunction(JSContext*, unsigned, js::Value*); extern const JSFunctionSpec function_methods[]; extern bool fun_apply(JSContext* cx, unsigned argc, Value* vp); extern bool fun_call(JSContext* cx, unsigned argc, Value* vp); } /* namespace js */ #ifdef DEBUG namespace JS { namespace detail { JS_PUBLIC_API(void) CheckIsValidConstructible(Value calleev); } // namespace detail } // namespace JS #endif #endif /* jsfun_h */