JavaScriptCore-7600.1.4.9.tar.gz

[apple/javascriptcore.git] / runtime / JSFunction.h

diff --git a/runtime/JSFunction.h b/runtime/JSFunction.h
index 5553115bf12149666251376a043a65b9f59075ab..f7b7f1633cd871c67bcf25a0049d793cbcb67eb7 100644 (file)
--- a/runtime/JSFunction.h
+++ b/runtime/JSFunction.h
@@ -25,7 +25,10 @@
 #define JSFunction_h
 
 #include "InternalFunction.h"
 #define JSFunction_h
 
 #include "InternalFunction.h"

-#include "JSObject.h"
+#include "JSDestructibleObject.h"
+#include "JSScope.h"
+#include "ObjectAllocationProfile.h"
+#include "Watchpoint.h"

 
 namespace JSC {
 
 
 namespace JSC {
 


@@ -44,65 +47,70 @@ namespace JSC {
 
     JS_EXPORT_PRIVATE EncodedJSValue JSC_HOST_CALL callHostFunctionAsConstructor(ExecState*);
 
 
     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 JIT;
         friend class DFG::SpeculativeJIT;
         friend class DFG::JITCompiler;

-        friend class JSGlobalData;
+        friend class VM;

 
     public:
 
     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(VM&, JSGlobalObject*, int length, const String& name, NativeFunction, Intrinsic = NoIntrinsic, NativeFunction nativeConstructor = callHostFunctionAsConstructor);

 
 

-        static JSFunction* create(ExecState* exec, FunctionExecutable* executable, ScopeChainNode* scopeChain)
+        static JSFunction* create(VM& vm, FunctionExecutable* executable, JSScope* scope)

         {
         {

-            JSFunction* function = new (NotNull, allocateCell<JSFunction>(*exec->heap())) JSFunction(exec, executable, scopeChain);
+            JSFunction* function = new (NotNull, allocateCell<JSFunction>(vm.heap)) JSFunction(vm, executable, scope);

             ASSERT(function->structure()->globalObject());
             ASSERT(function->structure()->globalObject());

-            function->finishCreation(exec, executable, scopeChain);
+            function->finishCreation(vm);

             return function;
         }
         
             return function;
         }
         

-        JS_EXPORT_PRIVATE const UString& name(ExecState*);
-        JS_EXPORT_PRIVATE const UString displayName(ExecState*);
-        const UString calculatedDisplayName(ExecState*);
+        static JSFunction* createBuiltinFunction(VM&, FunctionExecutable*, JSGlobalObject*);
+        
+        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());
         {
             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.
         }
         // 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());
         {
             ASSERT(!isHostFunctionNonInline());

-            m_scopeChain.set(globalData, this, scopeChain);
+            m_scope.set(vm, this, scope);

         }
         }

+        void addNameScopeIfNeeded(VM&);

 
         ExecutableBase* executable() const { return m_executable.get(); }
 
         // To call either of these methods include Executable.h
 
         ExecutableBase* executable() const { return m_executable.get(); }
 
         // To call either of these methods include Executable.h

-        inline bool isHostFunction() const;
+        bool isHostFunction() const;

         FunctionExecutable* jsExecutable() const;
 
         JS_EXPORT_PRIVATE const SourceCode* sourceCode() const;
 
         FunctionExecutable* jsExecutable() const;
 
         JS_EXPORT_PRIVATE const SourceCode* sourceCode() const;
 

-        static JS_EXPORTDATA const ClassInfo s_info;
+        DECLARE_EXPORT_INFO;

 
 

-        static Structure* createStructure(JSGlobalData& globalData, JSGlobalObject* globalObject, JSValue prototype) 
+        static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype) 

         {
             ASSERT(globalObject);
         {
             ASSERT(globalObject);

-            return Structure::create(globalData, globalObject, prototype, TypeInfo(JSFunctionType, StructureFlags), &s_info); 
+            return Structure::create(vm, globalObject, prototype, TypeInfo(JSFunctionType, StructureFlags), info()); 

         }
 
         NativeFunction nativeFunction();
         }
 
         NativeFunction nativeFunction();


@@ -111,54 +119,74 @@ namespace JSC {
         static ConstructType getConstructData(JSCell*, ConstructData&);
         static CallType getCallData(JSCell*, CallData&);
 
         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);
         }
 
         {
             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;
+        }
+
+        bool isHostOrBuiltinFunction() const;
+        bool isBuiltinFunction() const;
+        JS_EXPORT_PRIVATE bool isHostFunctionNonInline() const;
+

     protected:
         const static unsigned StructureFlags = OverridesGetOwnPropertySlot | ImplementsHasInstance | OverridesVisitChildren | OverridesGetPropertyNames | JSObject::StructureFlags;
 
     protected:
         const static unsigned StructureFlags = OverridesGetOwnPropertySlot | ImplementsHasInstance | OverridesVisitChildren | OverridesGetPropertyNames | JSObject::StructureFlags;
 

-        JS_EXPORT_PRIVATE JSFunction(ExecState*, JSGlobalObject*, Structure*);
-        JSFunction(ExecState*, FunctionExecutable*, ScopeChainNode*);
+        JS_EXPORT_PRIVATE JSFunction(VM&, JSGlobalObject*, Structure*);
+        JSFunction(VM&, FunctionExecutable*, JSScope*);

         
         

-        void finishCreation(ExecState*, NativeExecutable*, int length, const Identifier& name);
-        void finishCreation(ExecState*, FunctionExecutable*, ScopeChainNode*);
+        void finishCreation(VM&, 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(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*, 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&);
 
     private:
         friend class LLIntOffsetsExtractor;
         
 
         static void visitChildren(JSCell*, SlotVisitor&);
 
     private:
         friend class LLIntOffsetsExtractor;
         

-        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 EncodedJSValue argumentsGetter(ExecState*, JSObject*, EncodedJSValue, PropertyName);
+        static EncodedJSValue callerGetter(ExecState*, JSObject*, EncodedJSValue, PropertyName);
+        static EncodedJSValue lengthGetter(ExecState*, JSObject*, EncodedJSValue, PropertyName);
+        static EncodedJSValue nameGetter(ExecState*, JSObject*, EncodedJSValue, PropertyName);

 
         WriteBarrier<ExecutableBase> m_executable;
 
         WriteBarrier<ExecutableBase> m_executable;

-        WriteBarrier<ScopeChainNode> m_scopeChain;
+        WriteBarrier<JSScope> 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
 } // namespace JSC
 
 #endif // JSFunction_h