[JSC] Recover parser performance regression by async support
[WebKit-https.git] / Source / JavaScriptCore / bytecode / UnlinkedFunctionExecutable.h
1 /*
2  * Copyright (C) 2012-2016 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 "ExecutableInfo.h"
34 #include "ExpressionRangeInfo.h"
35 #include "HandlerInfo.h"
36 #include "Identifier.h"
37 #include "Intrinsic.h"
38 #include "JSCell.h"
39 #include "JSString.h"
40 #include "ParserModes.h"
41 #include "RegExp.h"
42 #include "SpecialPointer.h"
43 #include "VariableEnvironment.h"
44 #include "VirtualRegister.h"
45 #include <wtf/RefCountedArray.h>
46 #include <wtf/Vector.h>
47
48 namespace JSC {
49
50 class FunctionMetadataNode;
51 class FunctionExecutable;
52 class ParserError;
53 class RuntimeFlags;
54 class SourceCode;
55 class SourceProvider;
56 class UnlinkedFunctionCodeBlock;
57
58 enum UnlinkedFunctionKind {
59     UnlinkedNormalFunction,
60     UnlinkedBuiltinFunction,
61 };
62
63 class UnlinkedFunctionExecutable final : public JSCell {
64 public:
65     friend class CodeCache;
66     friend class VM;
67
68     typedef JSCell Base;
69     static const unsigned StructureFlags = Base::StructureFlags | StructureIsImmortal;
70
71     static UnlinkedFunctionExecutable* create(VM* vm, const SourceCode& source, FunctionMetadataNode* node, UnlinkedFunctionKind unlinkedFunctionKind, ConstructAbility constructAbility, VariableEnvironment& parentScopeTDZVariables, DerivedContextType derivedContextType, RefPtr<SourceProvider>&& sourceOverride = nullptr)
72     {
73         UnlinkedFunctionExecutable* instance = new (NotNull, allocateCell<UnlinkedFunctionExecutable>(vm->heap))
74             UnlinkedFunctionExecutable(vm, vm->unlinkedFunctionExecutableStructure.get(), source, WTFMove(sourceOverride), node, unlinkedFunctionKind, constructAbility, parentScopeTDZVariables, derivedContextType);
75         instance->finishCreation(*vm);
76         return instance;
77     }
78
79     const Identifier& name() const { return m_name; }
80     const Identifier& ecmaName() const { return m_ecmaName; }
81     void setEcmaName(const Identifier& name) { m_ecmaName = name; }
82     const Identifier& inferredName() const { return m_inferredName; }
83     unsigned parameterCount() const { return m_parameterCount; };
84     SourceParseMode parseMode() const { return static_cast<SourceParseMode>(m_sourceParseMode); };
85
86     const SourceCode& classSource() const { return m_classSource; };
87     void setClassSource(const SourceCode& source) { m_classSource = source; };
88
89     bool isInStrictContext() const { return m_isInStrictContext; }
90     FunctionMode functionMode() const { return static_cast<FunctionMode>(m_functionMode); }
91     ConstructorKind constructorKind() const { return static_cast<ConstructorKind>(m_constructorKind); }
92     SuperBinding superBinding() const { return static_cast<SuperBinding>(m_superBinding); }
93
94     unsigned unlinkedFunctionNameStart() const { return m_unlinkedFunctionNameStart; }
95     unsigned unlinkedBodyStartColumn() const { return m_unlinkedBodyStartColumn; }
96     unsigned unlinkedBodyEndColumn() const { return m_unlinkedBodyEndColumn; }
97     unsigned startOffset() const { return m_startOffset; }
98     unsigned sourceLength() { return m_sourceLength; }
99     unsigned parametersStartOffset() const { return m_parametersStartOffset; }
100     unsigned typeProfilingStartOffset() const { return m_typeProfilingStartOffset; }
101     unsigned typeProfilingEndOffset() const { return m_typeProfilingEndOffset; }
102     void setInvalidTypeProfilingOffsets();
103
104     UnlinkedFunctionCodeBlock* unlinkedCodeBlockFor(
105         VM&, const RuntimeFlags&, const SourceCode&, CodeSpecializationKind, DebuggerMode,
106         ParserError&, SourceParseMode);
107
108     static UnlinkedFunctionExecutable* fromGlobalCode(
109         const Identifier&, ExecState&, const SourceCode&, JSObject*& exception, 
110         int overrideLineNumber);
111
112     JS_EXPORT_PRIVATE FunctionExecutable* link(VM&, const SourceCode&, Optional<int> overrideLineNumber = Nullopt, Intrinsic = NoIntrinsic);
113
114     void clearCode()
115     {
116         m_unlinkedCodeBlockForCall.clear();
117         m_unlinkedCodeBlockForConstruct.clear();
118     }
119
120     void recordParse(CodeFeatures features, bool hasCapturedVariables)
121     {
122         m_features = features;
123         m_hasCapturedVariables = hasCapturedVariables;
124     }
125
126     CodeFeatures features() const { return m_features; }
127     bool hasCapturedVariables() const { return m_hasCapturedVariables; }
128
129     static const bool needsDestruction = true;
130     static void destroy(JSCell*);
131
132     bool isBuiltinFunction() const { return m_isBuiltinFunction; }
133     ConstructAbility constructAbility() const { return static_cast<ConstructAbility>(m_constructAbility); }
134     bool isClassConstructorFunction() const { return constructorKind() != ConstructorKind::None; }
135     const VariableEnvironment* parentScopeTDZVariables() const { return &m_parentScopeTDZVariables; }
136     
137     bool isArrowFunction() const { return parseMode() == SourceParseMode::ArrowFunctionMode; }
138
139     JSC::DerivedContextType derivedContextType() const {return static_cast<JSC::DerivedContextType>(m_derivedContextType); }
140
141     const String& sourceURLDirective() const { return m_sourceURLDirective; }
142     const String& sourceMappingURLDirective() const { return m_sourceMappingURLDirective; }
143     void setSourceURLDirective(const String& sourceURL) { m_sourceURLDirective = sourceURL; }
144     void setSourceMappingURLDirective(const String& sourceMappingURL) { m_sourceMappingURLDirective = sourceMappingURL; }
145
146 private:
147     UnlinkedFunctionExecutable(VM*, Structure*, const SourceCode&, RefPtr<SourceProvider>&& sourceOverride, FunctionMetadataNode*, UnlinkedFunctionKind, ConstructAbility, VariableEnvironment&,  JSC::DerivedContextType);
148
149     unsigned m_firstLineOffset;
150     unsigned m_lineCount;
151     unsigned m_unlinkedFunctionNameStart;
152     unsigned m_unlinkedBodyStartColumn;
153     unsigned m_unlinkedBodyEndColumn;
154     unsigned m_startOffset;
155     unsigned m_sourceLength;
156     unsigned m_parametersStartOffset;
157     unsigned m_typeProfilingStartOffset;
158     unsigned m_typeProfilingEndOffset;
159     unsigned m_parameterCount;
160     CodeFeatures m_features;
161     SourceParseMode m_sourceParseMode;
162     unsigned m_isInStrictContext : 1;
163     unsigned m_hasCapturedVariables : 1;
164     unsigned m_isBuiltinFunction : 1;
165     unsigned m_constructAbility: 1;
166     unsigned m_constructorKind : 2;
167     unsigned m_functionMode : 2; // FunctionMode
168     unsigned m_superBinding : 1;
169     unsigned m_derivedContextType: 2;
170
171     WriteBarrier<UnlinkedFunctionCodeBlock> m_unlinkedCodeBlockForCall;
172     WriteBarrier<UnlinkedFunctionCodeBlock> m_unlinkedCodeBlockForConstruct;
173
174     Identifier m_name;
175     Identifier m_ecmaName;
176     Identifier m_inferredName;
177     RefPtr<SourceProvider> m_sourceOverride;
178     SourceCode m_classSource;
179
180     String m_sourceURLDirective;
181     String m_sourceMappingURLDirective;
182
183     VariableEnvironment m_parentScopeTDZVariables;
184
185 protected:
186     static void visitChildren(JSCell*, SlotVisitor&);
187
188 public:
189     static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue proto)
190     {
191         return Structure::create(vm, globalObject, proto, TypeInfo(UnlinkedFunctionExecutableType, StructureFlags), info());
192     }
193
194     DECLARE_EXPORT_INFO;
195 };
196
197 } // namespace JSC
198
199 #endif // UnlinkedFunctionExecutable_h