2223f6c30cd1074d87a0fc7e4c77072609559dad
[WebKit-https.git] / Source / JavaScriptCore / bytecode / UnlinkedFunctionExecutable.h
1 /*
2  * Copyright (C) 2012-2015 Apple Inc. All Rights Reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #ifndef UnlinkedFunctionExecutable_h
27 #define UnlinkedFunctionExecutable_h
28
29 #include "BytecodeConventions.h"
30 #include "CodeSpecializationKind.h"
31 #include "CodeType.h"
32 #include "ConstructAbility.h"
33 #include "ExpressionRangeInfo.h"
34 #include "HandlerInfo.h"
35 #include "Identifier.h"
36 #include "JSCell.h"
37 #include "JSString.h"
38 #include "ParserModes.h"
39 #include "RegExp.h"
40 #include "SpecialPointer.h"
41 #include "VariableEnvironment.h"
42 #include "VirtualRegister.h"
43 #include <wtf/RefCountedArray.h>
44 #include <wtf/Vector.h>
45
46 namespace JSC {
47
48 class FunctionMetadataNode;
49 class FunctionExecutable;
50 class ParserError;
51 class SourceCode;
52 class SourceProvider;
53 class UnlinkedFunctionCodeBlock;
54
55 enum UnlinkedFunctionKind {
56     UnlinkedNormalFunction,
57     UnlinkedBuiltinFunction,
58 };
59
60 class UnlinkedFunctionExecutable final : public JSCell {
61 public:
62     friend class BuiltinExecutables;
63     friend class CodeCache;
64     friend class VM;
65
66     typedef JSCell Base;
67     static const unsigned StructureFlags = Base::StructureFlags | StructureIsImmortal;
68
69     static UnlinkedFunctionExecutable* create(VM* vm, const SourceCode& source, FunctionMetadataNode* node, UnlinkedFunctionKind unlinkedFunctionKind, ConstructAbility constructAbility, VariableEnvironment& parentScopeTDZVariables, RefPtr<SourceProvider>&& sourceOverride = nullptr)
70     {
71         UnlinkedFunctionExecutable* instance = new (NotNull, allocateCell<UnlinkedFunctionExecutable>(vm->heap))
72             UnlinkedFunctionExecutable(vm, vm->unlinkedFunctionExecutableStructure.get(), source, WTF::move(sourceOverride), node, unlinkedFunctionKind, constructAbility, parentScopeTDZVariables);
73         instance->finishCreation(*vm);
74         return instance;
75     }
76
77     const Identifier& name() const { return m_name; }
78     const Identifier& inferredName() const { return m_inferredName; }
79     JSString* nameValue() const { return m_nameValue.get(); }
80     unsigned parameterCount() const { return m_parameterCount; };
81     SourceParseMode parseMode() const { return m_parseMode; };
82     bool isInStrictContext() const { return m_isInStrictContext; }
83     FunctionMode functionMode() const { return static_cast<FunctionMode>(m_functionMode); }
84     ConstructorKind constructorKind() const { return static_cast<ConstructorKind>(m_constructorKind); }
85
86     unsigned unlinkedFunctionNameStart() const { return m_unlinkedFunctionNameStart; }
87     unsigned unlinkedBodyStartColumn() const { return m_unlinkedBodyStartColumn; }
88     unsigned unlinkedBodyEndColumn() const { return m_unlinkedBodyEndColumn; }
89     unsigned startOffset() const { return m_startOffset; }
90     unsigned sourceLength() { return m_sourceLength; }
91     unsigned parametersStartOffset() const { return m_parametersStartOffset; }
92     unsigned typeProfilingStartOffset() const { return m_typeProfilingStartOffset; }
93     unsigned typeProfilingEndOffset() const { return m_typeProfilingEndOffset; }
94     void setInvalidTypeProfilingOffsets();
95
96     UnlinkedFunctionCodeBlock* unlinkedCodeBlockFor(
97         VM&, const SourceCode&, CodeSpecializationKind, DebuggerMode, ProfilerMode, 
98         ParserError&, bool);
99
100     static UnlinkedFunctionExecutable* fromGlobalCode(
101         const Identifier&, ExecState&, const SourceCode&, JSObject*& exception, 
102         int overrideLineNumber);
103
104     FunctionExecutable* link(VM&, const SourceCode&, int overrideLineNumber = -1);
105
106     void clearCode()
107     {
108         m_unlinkedCodeBlockForCall.clear();
109         m_unlinkedCodeBlockForConstruct.clear();
110     }
111
112     void recordParse(CodeFeatures features, bool hasCapturedVariables)
113     {
114         m_features = features;
115         m_hasCapturedVariables = hasCapturedVariables;
116     }
117
118     CodeFeatures features() const { return m_features; }
119     bool hasCapturedVariables() const { return m_hasCapturedVariables; }
120
121     static const bool needsDestruction = true;
122     static void destroy(JSCell*);
123
124     bool isBuiltinFunction() const { return m_isBuiltinFunction; }
125     ConstructAbility constructAbility() const { return static_cast<ConstructAbility>(m_constructAbility); }
126     bool isClassConstructorFunction() const { return constructorKind() != ConstructorKind::None; }
127     const VariableEnvironment* parentScopeTDZVariables() const { return &m_parentScopeTDZVariables; }
128     bool isArrowFunction() const { return m_isArrowFunction; }
129
130 private:
131     UnlinkedFunctionExecutable(VM*, Structure*, const SourceCode&, RefPtr<SourceProvider>&& sourceOverride, FunctionMetadataNode*, UnlinkedFunctionKind, ConstructAbility, VariableEnvironment&);
132     WriteBarrier<UnlinkedFunctionCodeBlock> m_unlinkedCodeBlockForCall;
133     WriteBarrier<UnlinkedFunctionCodeBlock> m_unlinkedCodeBlockForConstruct;
134
135     Identifier m_name;
136     Identifier m_inferredName;
137     WriteBarrier<JSString> m_nameValue;
138     RefPtr<SourceProvider> m_sourceOverride;
139     VariableEnvironment m_parentScopeTDZVariables;
140     unsigned m_firstLineOffset;
141     unsigned m_lineCount;
142     unsigned m_unlinkedFunctionNameStart;
143     unsigned m_unlinkedBodyStartColumn;
144     unsigned m_unlinkedBodyEndColumn;
145     unsigned m_startOffset;
146     unsigned m_sourceLength;
147     unsigned m_parametersStartOffset;
148     unsigned m_typeProfilingStartOffset;
149     unsigned m_typeProfilingEndOffset;
150     unsigned m_parameterCount;
151     SourceParseMode m_parseMode;
152
153     CodeFeatures m_features;
154
155     unsigned m_isInStrictContext : 1;
156     unsigned m_hasCapturedVariables : 1;
157     unsigned m_isBuiltinFunction : 1;
158     unsigned m_constructAbility: 1;
159     unsigned m_constructorKind : 2;
160     unsigned m_functionMode : 1; // FunctionMode
161     unsigned m_isArrowFunction : 1;
162
163 protected:
164     void finishCreation(VM& vm)
165     {
166         Base::finishCreation(vm);
167         m_nameValue.set(vm, this, jsString(&vm, name().string()));
168     }
169
170     static void visitChildren(JSCell*, SlotVisitor&);
171
172 public:
173     static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue proto)
174     {
175         return Structure::create(vm, globalObject, proto, TypeInfo(UnlinkedFunctionExecutableType, StructureFlags), info());
176     }
177
178     DECLARE_EXPORT_INFO;
179 };
180
181 } // namespace JSC
182
183 #endif // UnlinkedFunctionExecutable_h