X-Git-Url: https://git.saurik.com/apple/javascriptcore.git/blobdiff_plain/a253471d7f8e4d91bf6ebabab00155c3b387d3d0..93a3786624b2768d89bfa27e46598dc64e2fb70a:/runtime/JSFunction.h diff --git a/runtime/JSFunction.h b/runtime/JSFunction.h index 5553115..da50f95 100644 --- a/runtime/JSFunction.h +++ b/runtime/JSFunction.h @@ -25,7 +25,10 @@ #define JSFunction_h #include "InternalFunction.h" -#include "JSObject.h" +#include "JSDestructibleObject.h" +#include "JSScope.h" +#include "ObjectAllocationProfile.h" +#include "Watchpoint.h" namespace JSC { @@ -44,49 +47,52 @@ namespace JSC { JS_EXPORT_PRIVATE EncodedJSValue JSC_HOST_CALL callHostFunctionAsConstructor(ExecState*); - JS_EXPORT_PRIVATE UString getCalculatedDisplayName(CallFrame*, JSObject*); + JS_EXPORT_PRIVATE String getCalculatedDisplayName(CallFrame*, JSObject*); - class JSFunction : public JSNonFinalObject { + class JSFunction : public JSDestructibleObject { friend class JIT; friend class DFG::SpeculativeJIT; friend class DFG::JITCompiler; - friend class JSGlobalData; + friend class VM; public: - typedef JSNonFinalObject Base; + typedef JSDestructibleObject Base; - JS_EXPORT_PRIVATE static JSFunction* create(ExecState*, JSGlobalObject*, int length, const Identifier& name, NativeFunction nativeFunction, Intrinsic = NoIntrinsic, NativeFunction nativeConstructor = callHostFunctionAsConstructor); + JS_EXPORT_PRIVATE static JSFunction* create(ExecState*, JSGlobalObject*, int length, const String& name, NativeFunction, Intrinsic = NoIntrinsic, NativeFunction nativeConstructor = callHostFunctionAsConstructor); - static JSFunction* create(ExecState* exec, FunctionExecutable* executable, ScopeChainNode* scopeChain) + static JSFunction* create(ExecState* exec, FunctionExecutable* executable, JSScope* scope) { - JSFunction* function = new (NotNull, allocateCell(*exec->heap())) JSFunction(exec, executable, scopeChain); + VM& vm = exec->vm(); + JSFunction* function = new (NotNull, allocateCell(vm.heap)) JSFunction(vm, executable, scope); ASSERT(function->structure()->globalObject()); - function->finishCreation(exec, executable, scopeChain); + function->finishCreation(vm); return function; } - JS_EXPORT_PRIVATE const UString& name(ExecState*); - JS_EXPORT_PRIVATE const UString displayName(ExecState*); - const UString calculatedDisplayName(ExecState*); + static void destroy(JSCell*); + + JS_EXPORT_PRIVATE String name(ExecState*); + JS_EXPORT_PRIVATE String displayName(ExecState*); + const String calculatedDisplayName(ExecState*); - ScopeChainNode* scope() + JSScope* scope() { ASSERT(!isHostFunctionNonInline()); - return m_scopeChain.get(); + return m_scope.get(); } // This method may be called for host functins, in which case it // will return an arbitrary value. This should only be used for // optimized paths in which the return value does not matter for // host functions, and checking whether the function is a host // function is deemed too expensive. - ScopeChainNode* scopeUnchecked() + JSScope* scopeUnchecked() { - return m_scopeChain.get(); + return m_scope.get(); } - void setScope(JSGlobalData& globalData, ScopeChainNode* scopeChain) + void setScope(VM& vm, JSScope* scope) { ASSERT(!isHostFunctionNonInline()); - m_scopeChain.set(globalData, this, scopeChain); + m_scope.set(vm, this, scope); } ExecutableBase* executable() const { return m_executable.get(); } @@ -99,10 +105,10 @@ namespace JSC { static JS_EXPORTDATA const ClassInfo s_info; - static Structure* createStructure(JSGlobalData& globalData, JSGlobalObject* globalObject, JSValue prototype) + static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype) { ASSERT(globalObject); - return Structure::create(globalData, globalObject, prototype, TypeInfo(JSFunctionType, StructureFlags), &s_info); + return Structure::create(vm, globalObject, prototype, TypeInfo(JSFunctionType, StructureFlags), &s_info); } NativeFunction nativeFunction(); @@ -111,33 +117,62 @@ namespace JSC { static ConstructType getConstructData(JSCell*, ConstructData&); static CallType getCallData(JSCell*, CallData&); - static inline size_t offsetOfScopeChain() + static inline ptrdiff_t offsetOfScopeChain() { - return OBJECT_OFFSETOF(JSFunction, m_scopeChain); + return OBJECT_OFFSETOF(JSFunction, m_scope); } - static inline size_t offsetOfExecutable() + static inline ptrdiff_t offsetOfExecutable() { return OBJECT_OFFSETOF(JSFunction, m_executable); } + static inline ptrdiff_t offsetOfAllocationProfile() + { + return OBJECT_OFFSETOF(JSFunction, m_allocationProfile); + } + + ObjectAllocationProfile* allocationProfile(ExecState* exec, unsigned inlineCapacity) + { + if (UNLIKELY(m_allocationProfile.isNull())) + return createAllocationProfile(exec, inlineCapacity); + return &m_allocationProfile; + } + + ObjectAllocationProfile* tryGetAllocationProfile() + { + if (m_allocationProfile.isNull()) + return 0; + if (m_allocationProfileWatchpoint.hasBeenInvalidated()) + return 0; + return &m_allocationProfile; + } + + void addAllocationProfileWatchpoint(Watchpoint* watchpoint) + { + ASSERT(tryGetAllocationProfile()); + m_allocationProfileWatchpoint.add(watchpoint); + } + protected: const static unsigned StructureFlags = OverridesGetOwnPropertySlot | ImplementsHasInstance | OverridesVisitChildren | OverridesGetPropertyNames | JSObject::StructureFlags; JS_EXPORT_PRIVATE JSFunction(ExecState*, JSGlobalObject*, Structure*); - JSFunction(ExecState*, FunctionExecutable*, ScopeChainNode*); + JSFunction(VM&, FunctionExecutable*, JSScope*); - void finishCreation(ExecState*, NativeExecutable*, int length, const Identifier& name); - void finishCreation(ExecState*, FunctionExecutable*, ScopeChainNode*); + void finishCreation(ExecState*, NativeExecutable*, int length, const String& name); + using Base::finishCreation; + + ObjectAllocationProfile* createAllocationProfile(ExecState*, size_t inlineCapacity); - static bool getOwnPropertySlot(JSCell*, ExecState*, const Identifier&, PropertySlot&); - static bool getOwnPropertyDescriptor(JSObject*, ExecState*, const Identifier&, PropertyDescriptor&); - static void getOwnPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode = ExcludeDontEnumProperties); - static bool defineOwnProperty(JSObject*, ExecState*, const Identifier& propertyName, PropertyDescriptor&, bool shouldThrow); + static bool getOwnPropertySlot(JSCell*, ExecState*, PropertyName, PropertySlot&); + static bool getOwnPropertyDescriptor(JSObject*, ExecState*, PropertyName, PropertyDescriptor&); + static void getOwnNonIndexPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode = ExcludeDontEnumProperties); + static bool defineOwnProperty(JSObject*, ExecState*, PropertyName, PropertyDescriptor&, bool shouldThrow); - static void put(JSCell*, ExecState*, const Identifier& propertyName, JSValue, PutPropertySlot&); + static void put(JSCell*, ExecState*, PropertyName, JSValue, PutPropertySlot&); - static bool deleteProperty(JSCell*, ExecState*, const Identifier& propertyName); + static bool deleteProperty(JSCell*, ExecState*, PropertyName); static void visitChildren(JSCell*, SlotVisitor&); @@ -146,19 +181,17 @@ namespace JSC { JS_EXPORT_PRIVATE bool isHostFunctionNonInline() const; - static JSValue argumentsGetter(ExecState*, JSValue, const Identifier&); - static JSValue callerGetter(ExecState*, JSValue, const Identifier&); - static JSValue lengthGetter(ExecState*, JSValue, const Identifier&); + static JSValue argumentsGetter(ExecState*, JSValue, PropertyName); + static JSValue callerGetter(ExecState*, JSValue, PropertyName); + static JSValue lengthGetter(ExecState*, JSValue, PropertyName); + static JSValue nameGetter(ExecState*, JSValue, PropertyName); WriteBarrier m_executable; - WriteBarrier m_scopeChain; + WriteBarrier m_scope; + ObjectAllocationProfile m_allocationProfile; + InlineWatchpointSet m_allocationProfileWatchpoint; }; - inline bool JSValue::isFunction() const - { - return isCell() && (asCell()->inherits(&JSFunction::s_info) || asCell()->inherits(&InternalFunction::s_info)); - } - } // namespace JSC #endif // JSFunction_h