JavaScriptCore-7601.1.46.3.tar.gz

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

diff --git a/runtime/JSFunction.h b/runtime/JSFunction.h
index 6a43737ad77ec78d3f9f3f6aba40f479e77aa4d6..0b87d75c91450c5af1aaed27a61a748ef80f093e 100644 (file)
--- a/runtime/JSFunction.h
+++ b/runtime/JSFunction.h
@@ -1,6 +1,6 @@
 /*
  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
 /*
  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)

- *  Copyright (C) 2003, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
+ *  Copyright (C) 2003, 2006, 2007, 2008, 2009, 2015 Apple Inc. All rights reserved.

  *  Copyright (C) 2007 Cameron Zwarich (cwzwarich@uwaterloo.ca)
  *  Copyright (C) 2007 Maks Orlovich
  *
  *  Copyright (C) 2007 Cameron Zwarich (cwzwarich@uwaterloo.ca)
  *  Copyright (C) 2007 Maks Orlovich
  *


@@ -24,80 +24,160 @@
 #ifndef JSFunction_h
 #define JSFunction_h
 
 #ifndef JSFunction_h
 #define JSFunction_h
 

+#include "FunctionRareData.h"

 #include "InternalFunction.h"
 #include "InternalFunction.h"

-#include "JSVariableObject.h"
-#include "SymbolTable.h"
-#include "Nodes.h"
-#include "JSObject.h"
+#include "JSCallee.h"
+#include "JSScope.h"
+#include "Watchpoint.h"

 
 namespace JSC {
 
 
 namespace JSC {
 

-    class FunctionBodyNode;
-    class FunctionPrototype;
-    class JSActivation;
-    class JSGlobalObject;
+class ExecutableBase;
+class FunctionExecutable;
+class FunctionPrototype;
+class JSLexicalEnvironment;
+class JSGlobalObject;
+class LLIntOffsetsExtractor;
+class NativeExecutable;
+class SourceCode;
+namespace DFG {
+class SpeculativeJIT;
+class JITCompiler;
+}

 
 

-    class JSFunction : public InternalFunction {
-        friend class JIT;
-        friend class Interpreter;
+typedef std::function<EncodedJSValue (ExecState*)> NativeStdFunction;

 
 

-        typedef InternalFunction Base;
+JS_EXPORT_PRIVATE EncodedJSValue JSC_HOST_CALL callHostFunctionAsConstructor(ExecState*);

 
 

-        JSFunction(PassRefPtr<Structure> structure)
-            : InternalFunction(structure)
-            , m_scopeChain(NoScopeChain())
-        {
-        }
+JS_EXPORT_PRIVATE String getCalculatedDisplayName(CallFrame*, JSObject*);

 
 

-    public:
-        JSFunction(ExecState*, const Identifier&, FunctionBodyNode*, ScopeChainNode*);
-        ~JSFunction();
+class JSFunction : public JSCallee {
+    friend class JIT;
+    friend class DFG::SpeculativeJIT;
+    friend class DFG::JITCompiler;
+    friend class VM;

 
 

-        virtual bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&);
-        virtual void put(ExecState*, const Identifier& propertyName, JSValuePtr, PutPropertySlot&);
-        virtual bool deleteProperty(ExecState*, const Identifier& propertyName);
+public:
+    typedef JSCallee Base;
+    const static unsigned StructureFlags = Base::StructureFlags | OverridesGetOwnPropertySlot | OverridesGetPropertyNames;

 
 

-        JSObject* construct(ExecState*, const ArgList&);
-        JSValuePtr call(ExecState*, JSValuePtr thisValue, const ArgList&);
+    static size_t allocationSize(size_t inlineCapacity)
+    {
+        ASSERT_UNUSED(inlineCapacity, !inlineCapacity);
+        return sizeof(JSFunction);
+    }
+
+    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*);
+    JS_EXPORT_PRIVATE static JSFunction* create(VM&, JSGlobalObject*, int length, const String& name, NativeStdFunction&&, Intrinsic = NoIntrinsic, NativeFunction nativeConstructor = callHostFunctionAsConstructor);
+
+    static JSFunction* create(VM&, FunctionExecutable*, JSScope*);

 
 

-        void setScope(const ScopeChain& scopeChain) { m_scopeChain = scopeChain; }
-        ScopeChain& scope() { return m_scopeChain; }
+    static JSFunction* createBuiltinFunction(VM&, FunctionExecutable*, JSGlobalObject*);
+    static JSFunction* createBuiltinFunction(VM&, FunctionExecutable*, JSGlobalObject*, const String& name);

 
 

-        void setBody(FunctionBodyNode* body) { m_body = body; }
-        void setBody(PassRefPtr<FunctionBodyNode> body) { m_body = body; }
-        FunctionBodyNode* body() const { return m_body.get(); }
+    JS_EXPORT_PRIVATE String name(ExecState*);
+    JS_EXPORT_PRIVATE String displayName(ExecState*);
+    const String calculatedDisplayName(ExecState*);

 
 

-        virtual void mark();
+    ExecutableBase* executable() const { return m_executable.get(); }

 
 

-        static const ClassInfo info;
+    // To call either of these methods include Executable.h
+    bool isHostFunction() const;
+    FunctionExecutable* jsExecutable() const;

 
 

-        static PassRefPtr<Structure> createStructure(JSValuePtr prototype) 
-        { 
-            return Structure::create(prototype, TypeInfo(ObjectType, ImplementsHasInstance)); 
-        }
+    JS_EXPORT_PRIVATE const SourceCode* sourceCode() const;

 
 

-    private:
-        virtual const ClassInfo* classInfo() const { return &info; }
+    DECLARE_EXPORT_INFO;

 
 

-        virtual ConstructType getConstructData(ConstructData&);
-        virtual CallType getCallData(CallData&);
+    static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype) 
+    {
+        ASSERT(globalObject);
+        return Structure::create(vm, globalObject, prototype, TypeInfo(JSFunctionType, StructureFlags), info()); 
+    }

 
 

-        static JSValuePtr argumentsGetter(ExecState*, const Identifier&, const PropertySlot&);
-        static JSValuePtr callerGetter(ExecState*, const Identifier&, const PropertySlot&);
-        static JSValuePtr lengthGetter(ExecState*, const Identifier&, const PropertySlot&);
+    NativeFunction nativeFunction();
+    NativeFunction nativeConstructor();

 
 

-        RefPtr<FunctionBodyNode> m_body;
-        ScopeChain m_scopeChain;
-    };
+    static ConstructType getConstructData(JSCell*, ConstructData&);
+    static CallType getCallData(JSCell*, CallData&);

 
 

-    JSFunction* asFunction(JSValuePtr);
+    static inline ptrdiff_t offsetOfExecutable()
+    {
+        return OBJECT_OFFSETOF(JSFunction, m_executable);
+    }

 
 

-    inline JSFunction* asFunction(JSValuePtr value)
+    static inline ptrdiff_t offsetOfRareData()

     {
     {

-        ASSERT(asObject(value)->inherits(&JSFunction::info));
-        return static_cast<JSFunction*>(asObject(value));
+        return OBJECT_OFFSETOF(JSFunction, m_rareData);

     }
 
     }
 

+    FunctionRareData* rareData(ExecState* exec, unsigned inlineCapacity)
+    {
+        if (UNLIKELY(!m_rareData))
+            return allocateAndInitializeRareData(exec, inlineCapacity);
+        if (UNLIKELY(!m_rareData->isInitialized()))
+            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*);
+
+    void finishCreation(VM&, NativeExecutable*, int length, const String& name);
+    using Base::finishCreation;
+
+    FunctionRareData* allocateAndInitializeRareData(ExecState*, size_t inlineCapacity);
+    FunctionRareData* initializeRareData(ExecState*, size_t inlineCapacity);
+
+    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&);
+
+private:
+    static JSFunction* createImpl(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;
+    }
+    
+    friend class LLIntOffsetsExtractor;
+
+    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<FunctionRareData> m_rareData;
+};
+

 } // namespace JSC
 
 #endif // JSFunction_h
 } // namespace JSC
 
 #endif // JSFunction_h