webkitgtk-2.4.11webkitgtk-2.4.11

1 files changed, 148 insertions, 164 deletions

diff --git a/Source/JavaScriptCore/runtime/JSFunction.h b/Source/JavaScriptCore/runtime/JSFunction.h
index 878bbab42..7cd14b8c2 100644
--- a/Source/JavaScriptCore/runtime/JSFunction.h
+++ b/Source/JavaScriptCore/runtime/JSFunction.h
@@ -1,6 +1,6 @@
 /*
  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
- *  Copyright (C) 2003, 2006-2009, 2015-2016 Apple Inc. All rights reserved.
+ *  Copyright (C) 2003, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  *  Copyright (C) 2007 Cameron Zwarich (cwzwarich@uwaterloo.ca)
  *  Copyright (C) 2007 Maks Orlovich
  *
@@ -24,179 +24,163 @@
 #ifndef JSFunction_h
 #define JSFunction_h
 
-#include "FunctionRareData.h"
 #include "InternalFunction.h"
-#include "JSCallee.h"
+#include "JSDestructibleObject.h"
 #include "JSScope.h"
+#include "ObjectAllocationProfile.h"
 #include "Watchpoint.h"
 
 namespace JSC {
 
-class ExecutableBase;
-class FunctionExecutable;
-class FunctionPrototype;
-class JSLexicalEnvironment;
-class JSGlobalObject;
-class LLIntOffsetsExtractor;
-class NativeExecutable;
-class SourceCode;
-class WebAssemblyExecutable;
-class InternalFunction;
-namespace DFG {
-class SpeculativeJIT;
-class JITCompiler;
-}
-
-JS_EXPORT_PRIVATE EncodedJSValue JSC_HOST_CALL callHostFunctionAsConstructor(ExecState*);
-
-JS_EXPORT_PRIVATE String getCalculatedDisplayName(CallFrame*, JSObject*);
-
-class JSFunction : public JSCallee {
-    friend class JIT;
-    friend class DFG::SpeculativeJIT;
-    friend class DFG::JITCompiler;
-    friend class VM;
-    friend class InternalFunction;
-
-public:
-    typedef JSCallee Base;
-    const static unsigned StructureFlags = Base::StructureFlags | OverridesGetOwnPropertySlot | OverridesGetPropertyNames;
-
-    static size_t allocationSize(size_t inlineCapacity)
-    {
-        ASSERT_UNUSED(inlineCapacity, !inlineCapacity);
-        return sizeof(JSFunction);
+    class ExecutableBase;
+    class FunctionExecutable;
+    class FunctionPrototype;
+    class JSActivation;
+    class JSGlobalObject;
+    class LLIntOffsetsExtractor;
+    class NativeExecutable;
+    class SourceCode;
+    namespace DFG {
+    class SpeculativeJIT;
+    class JITCompiler;
     }
 
-    JS_EXPORT_PRIVATE static JSFunction* create(VM&, JSGlobalObject*, int length, const String& name, NativeFunction, Intrinsic = NoIntrinsic, NativeFunction nativeConstructor = callHostFunctionAsConstructor);
-    
-    static JSFunction* createWithInvalidatedReallocationWatchpoint(VM&, FunctionExecutable*, JSScope*);
-
-    static JSFunction* create(VM&, FunctionExecutable*, JSScope*);
-    static JSFunction* create(VM&, FunctionExecutable*, JSScope*, Structure*);
-#if ENABLE(WEBASSEMBLY)
-    static JSFunction* create(VM&, WebAssemblyExecutable*, JSScope*);
-#endif
-
-    JS_EXPORT_PRIVATE static JSFunction* createBuiltinFunction(VM&, FunctionExecutable*, JSGlobalObject*);
-    static JSFunction* createBuiltinFunction(VM&, FunctionExecutable*, JSGlobalObject*, const String& name);
-
-    JS_EXPORT_PRIVATE String name(ExecState*);
-    JS_EXPORT_PRIVATE String displayName(ExecState*);
-    const String calculatedDisplayName(ExecState*);
-
-    ExecutableBase* executable() const { return m_executable.get(); }
-
-    // To call any of these methods include JSFunctionInlines.h
-    bool isHostFunction() const;
-    FunctionExecutable* jsExecutable() const;
-    Intrinsic intrinsic() const;
-
-    JS_EXPORT_PRIVATE const SourceCode* sourceCode() const;
-
-    DECLARE_EXPORT_INFO;
-
-    static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype) 
-    {
-        ASSERT(globalObject);
-        return Structure::create(vm, globalObject, prototype, TypeInfo(JSFunctionType, StructureFlags), info()); 
-    }
-
-    NativeFunction nativeFunction();
-    NativeFunction nativeConstructor();
-
-    static ConstructType getConstructData(JSCell*, ConstructData&);
-    static CallType getCallData(JSCell*, CallData&);
-
-    static inline ptrdiff_t offsetOfExecutable()
-    {
-        return OBJECT_OFFSETOF(JSFunction, m_executable);
-    }
-
-    static inline ptrdiff_t offsetOfRareData()
-    {
-        return OBJECT_OFFSETOF(JSFunction, m_rareData);
-    }
-
-    FunctionRareData* rareData(VM& vm)
-    {
-        if (UNLIKELY(!m_rareData))
-            return allocateRareData(vm);
-        return m_rareData.get();
-    }
-
-    FunctionRareData* rareData(ExecState* exec, unsigned inlineCapacity)
-    {
-        if (UNLIKELY(!m_rareData))
-            return allocateAndInitializeRareData(exec, inlineCapacity);
-        if (UNLIKELY(!m_rareData->isObjectAllocationProfileInitialized()))
-            return initializeRareData(exec, inlineCapacity);
-        return m_rareData.get();
-    }
-
-    FunctionRareData* rareData()
-    {
-        FunctionRareData* rareData = m_rareData.get();
-
-        // The JS thread may be concurrently creating the rare data
-        // If we see it, we want to ensure it has been properly created
-        WTF::loadLoadFence();
-
-        return rareData;
-    }
-
-    bool isHostOrBuiltinFunction() const;
-    bool isBuiltinFunction() const;
-    JS_EXPORT_PRIVATE bool isHostFunctionNonInline() const;
-    bool isClassConstructorFunction() const;
-
-protected:
-    JS_EXPORT_PRIVATE JSFunction(VM&, JSGlobalObject*, Structure*);
-    JSFunction(VM&, FunctionExecutable*, JSScope*, Structure*);
-
-#if ENABLE(WEBASSEMBLY)
-    JSFunction(VM&, WebAssemblyExecutable*, JSScope*);
-#endif
-
-    void finishCreation(VM&, NativeExecutable*, int length, const String& name);
-    using Base::finishCreation;
-
-    FunctionRareData* allocateRareData(VM&);
-    FunctionRareData* allocateAndInitializeRareData(ExecState*, size_t inlineCapacity);
-    FunctionRareData* initializeRareData(ExecState*, size_t inlineCapacity);
+    JS_EXPORT_PRIVATE EncodedJSValue JSC_HOST_CALL callHostFunctionAsConstructor(ExecState*);
 
-    static bool getOwnPropertySlot(JSObject*, ExecState*, PropertyName, PropertySlot&);
-    static void getOwnNonIndexPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode = EnumerationMode());
-    static bool defineOwnProperty(JSObject*, ExecState*, PropertyName, const PropertyDescriptor&, bool shouldThrow);
-
-    static void put(JSCell*, ExecState*, PropertyName, JSValue, PutPropertySlot&);
-
-    static bool deleteProperty(JSCell*, ExecState*, PropertyName);
-
-    static void visitChildren(JSCell*, SlotVisitor&);
-
-
-    static NativeExecutable* lookUpOrCreateNativeExecutable(VM&, NativeFunction, Intrinsic, NativeFunction nativeConstructor, const String& name);
-
-private:
-    static JSFunction* createImpl(VM& vm, FunctionExecutable* executable, JSScope* scope, Structure* structure)
-    {
-        JSFunction* function = new (NotNull, allocateCell<JSFunction>(vm.heap)) JSFunction(vm, executable, scope, structure);
-        ASSERT(function->structure()->globalObject());
-        function->finishCreation(vm);
-        return function;
-    }
+    JS_EXPORT_PRIVATE String getCalculatedDisplayName(CallFrame*, JSObject*);
     
-    friend class LLIntOffsetsExtractor;
-
-    static EncodedJSValue argumentsGetter(ExecState*, EncodedJSValue, PropertyName);
-    static EncodedJSValue callerGetter(ExecState*, EncodedJSValue, PropertyName);
-    static EncodedJSValue lengthGetter(ExecState*, EncodedJSValue, PropertyName);
-    static EncodedJSValue nameGetter(ExecState*, EncodedJSValue, PropertyName);
-
-    WriteBarrier<ExecutableBase> m_executable;
-    WriteBarrier<FunctionRareData> m_rareData;
-};
+    class JSFunction : public JSDestructibleObject {
+        friend class JIT;
+        friend class DFG::SpeculativeJIT;
+        friend class DFG::JITCompiler;
+        friend class VM;
+
+    public:
+        typedef JSDestructibleObject Base;
+
+        JS_EXPORT_PRIVATE static JSFunction* create(VM&, JSGlobalObject*, int length, const String& name, NativeFunction, Intrinsic = NoIntrinsic, NativeFunction nativeConstructor = callHostFunctionAsConstructor);
+
+        static JSFunction* create(VM& vm, FunctionExecutable* executable, JSScope* scope)
+        {
+            JSFunction* function = new (NotNull, allocateCell<JSFunction>(vm.heap)) JSFunction(vm, executable, scope);
+            ASSERT(function->structure()->globalObject());
+            function->finishCreation(vm);
+            return function;
+        }
+        
+        static void destroy(JSCell*);
+        
+        JS_EXPORT_PRIVATE String name(ExecState*);
+        JS_EXPORT_PRIVATE String displayName(ExecState*);
+        const String calculatedDisplayName(ExecState*);
+
+        JSScope* scope()
+        {
+            ASSERT(!isHostFunctionNonInline());
+            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.
+        JSScope* scopeUnchecked()
+        {
+            return m_scope.get();
+        }
+        void setScope(VM& vm, JSScope* scope)
+        {
+            ASSERT(!isHostFunctionNonInline());
+            m_scope.set(vm, this, scope);
+        }
+
+        ExecutableBase* executable() const { return m_executable.get(); }
+
+        // To call either of these methods include Executable.h
+        inline bool isHostFunction() const;
+        FunctionExecutable* jsExecutable() const;
+
+        JS_EXPORT_PRIVATE const SourceCode* sourceCode() const;
+
+        DECLARE_EXPORT_INFO;
+
+        static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype) 
+        {
+            ASSERT(globalObject);
+            return Structure::create(vm, globalObject, prototype, TypeInfo(JSFunctionType, StructureFlags), info()); 
+        }
+
+        NativeFunction nativeFunction();
+        NativeFunction nativeConstructor();
+
+        static ConstructType getConstructData(JSCell*, ConstructData&);
+        static CallType getCallData(JSCell*, CallData&);
+
+        static inline ptrdiff_t offsetOfScopeChain()
+        {
+            return OBJECT_OFFSETOF(JSFunction, m_scope);
+        }
+
+        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;
+        }
+        
+        Structure* allocationStructure() { return m_allocationProfile.structure(); }
+
+        InlineWatchpointSet& allocationProfileWatchpointSet()
+        {
+            return m_allocationProfileWatchpoint;
+        }
+
+    protected:
+        const static unsigned StructureFlags = OverridesGetOwnPropertySlot | ImplementsHasInstance | OverridesVisitChildren | OverridesGetPropertyNames | JSObject::StructureFlags;
+
+        JS_EXPORT_PRIVATE JSFunction(VM&, JSGlobalObject*, Structure*);
+        JSFunction(VM&, FunctionExecutable*, JSScope*);
+        
+        void finishCreation(VM&, NativeExecutable*, int length, const String& name);
+        using Base::finishCreation;
+
+        ObjectAllocationProfile* createAllocationProfile(ExecState*, size_t inlineCapacity);
+
+        static bool getOwnPropertySlot(JSObject*, ExecState*, PropertyName, PropertySlot&);
+        static void getOwnNonIndexPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode = ExcludeDontEnumProperties);
+        static bool defineOwnProperty(JSObject*, ExecState*, PropertyName, const PropertyDescriptor&, bool shouldThrow);
+
+        static void put(JSCell*, ExecState*, PropertyName, JSValue, PutPropertySlot&);
+
+        static bool deleteProperty(JSCell*, ExecState*, PropertyName);
+
+        static void visitChildren(JSCell*, SlotVisitor&);
+
+    private:
+        friend class LLIntOffsetsExtractor;
+        
+        JS_EXPORT_PRIVATE bool isHostFunctionNonInline() const;
+
+        static EncodedJSValue argumentsGetter(ExecState*, EncodedJSValue, EncodedJSValue, PropertyName);
+        static EncodedJSValue callerGetter(ExecState*, EncodedJSValue, EncodedJSValue, PropertyName);
+        static EncodedJSValue lengthGetter(ExecState*, EncodedJSValue, EncodedJSValue, PropertyName);
+        static EncodedJSValue nameGetter(ExecState*, EncodedJSValue, EncodedJSValue, PropertyName);
+
+        WriteBarrier<ExecutableBase> m_executable;
+        WriteBarrier<JSScope> m_scope;
+        ObjectAllocationProfile m_allocationProfile;
+        InlineWatchpointSet m_allocationProfileWatchpoint;
+    };
 
 } // namespace JSC