[ES6] "super" and "this" should be lexically bound inside an arrow function and shoul...
[WebKit-https.git] / Source / JavaScriptCore / bytecode / UnlinkedFunctionExecutable.cpp
1 /*
2  * Copyright (C) 2012, 2013, 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 #include "config.h"
27 #include "UnlinkedFunctionExecutable.h"
28
29 #include "BytecodeGenerator.h"
30 #include "ClassInfo.h"
31 #include "CodeCache.h"
32 #include "Executable.h"
33 #include "ExecutableInfo.h"
34 #include "FunctionOverrides.h"
35 #include "JSCInlines.h"
36 #include "JSString.h"
37 #include "Parser.h"
38 #include "SourceProvider.h"
39 #include "Structure.h"
40 #include "SymbolTable.h"
41 #include "UnlinkedInstructionStream.h"
42 #include <wtf/DataLog.h>
43
44 namespace JSC {
45
46 static_assert(sizeof(UnlinkedFunctionExecutable) <= 256, "UnlinkedFunctionExecutable should fit in a 256-byte cell.");
47
48 const ClassInfo UnlinkedFunctionExecutable::s_info = { "UnlinkedFunctionExecutable", 0, 0, CREATE_METHOD_TABLE(UnlinkedFunctionExecutable) };
49
50 static UnlinkedFunctionCodeBlock* generateUnlinkedFunctionCodeBlock(
51     VM& vm, UnlinkedFunctionExecutable* executable, const SourceCode& source,
52     CodeSpecializationKind kind, DebuggerMode debuggerMode, ProfilerMode profilerMode,
53     UnlinkedFunctionKind functionKind, ParserError& error, SourceParseMode parseMode)
54 {
55     JSParserBuiltinMode builtinMode = executable->isBuiltinFunction() ? JSParserBuiltinMode::Builtin : JSParserBuiltinMode::NotBuiltin;
56     JSParserStrictMode strictMode = executable->isInStrictContext() ? JSParserStrictMode::Strict : JSParserStrictMode::NotStrict;
57     ASSERT(isFunctionParseMode(executable->parseMode()));
58     std::unique_ptr<FunctionNode> function = parse<FunctionNode>(
59         &vm, source, executable->name(), builtinMode, strictMode, executable->parseMode(), executable->superBinding(), error, nullptr);
60
61     if (!function) {
62         ASSERT(error.isValid());
63         return nullptr;
64     }
65
66     function->finishParsing(executable->name(), executable->functionMode());
67     executable->recordParse(function->features(), function->hasCapturedVariables());
68     
69     UnlinkedFunctionCodeBlock* result = UnlinkedFunctionCodeBlock::create(&vm, FunctionCode,
70         ExecutableInfo(function->needsActivation(), function->usesEval(), function->isStrictMode(), kind == CodeForConstruct, functionKind == UnlinkedBuiltinFunction, executable->constructorKind(), executable->generatorThisMode(), executable->superBinding(), parseMode,  executable->isDerivedConstructorContext(), false));
71
72     auto generator(std::make_unique<BytecodeGenerator>(vm, function.get(), result, debuggerMode, profilerMode, executable->parentScopeTDZVariables()));
73     error = generator->generate();
74     if (error.isValid())
75         return nullptr;
76     return result;
77 }
78
79 UnlinkedFunctionExecutable::UnlinkedFunctionExecutable(VM* vm, Structure* structure, const SourceCode& source, RefPtr<SourceProvider>&& sourceOverride, FunctionMetadataNode* node, UnlinkedFunctionKind kind, ConstructAbility constructAbility, GeneratorThisMode generatorThisMode, VariableEnvironment& parentScopeTDZVariables, bool isDerivedConstructorContext)
80     : Base(*vm, structure)
81     , m_name(node->ident())
82     , m_inferredName(node->inferredName())
83     , m_sourceOverride(WTF::move(sourceOverride))
84     , m_firstLineOffset(node->firstLine() - source.firstLine())
85     , m_lineCount(node->lastLine() - node->firstLine())
86     , m_unlinkedFunctionNameStart(node->functionNameStart() - source.startOffset())
87     , m_unlinkedBodyStartColumn(node->startColumn())
88     , m_unlinkedBodyEndColumn(m_lineCount ? node->endColumn() : node->endColumn() - node->startColumn())
89     , m_startOffset(node->source().startOffset() - source.startOffset())
90     , m_sourceLength(node->source().length())
91     , m_parametersStartOffset(node->parametersStart())
92     , m_typeProfilingStartOffset(node->functionKeywordStart())
93     , m_typeProfilingEndOffset(node->startStartOffset() + node->source().length() - 1)
94     , m_parameterCount(node->parameterCount())
95     , m_parseMode(node->parseMode())
96     , m_features(0)
97     , m_isInStrictContext(node->isInStrictContext())
98     , m_hasCapturedVariables(false)
99     , m_isBuiltinFunction(kind == UnlinkedBuiltinFunction)
100     , m_constructAbility(static_cast<unsigned>(constructAbility))
101     , m_constructorKind(static_cast<unsigned>(node->constructorKind()))
102     , m_functionMode(node->functionMode())
103     , m_generatorThisMode(static_cast<unsigned>(generatorThisMode))
104     , m_superBinding(static_cast<unsigned>(node->superBinding()))
105     , m_isDerivedConstructorContext(isDerivedConstructorContext)
106 {
107     ASSERT(m_constructorKind == static_cast<unsigned>(node->constructorKind()));
108     m_parentScopeTDZVariables.swap(parentScopeTDZVariables);
109 }
110
111 void UnlinkedFunctionExecutable::visitChildren(JSCell* cell, SlotVisitor& visitor)
112 {
113     UnlinkedFunctionExecutable* thisObject = jsCast<UnlinkedFunctionExecutable*>(cell);
114     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
115     Base::visitChildren(thisObject, visitor);
116     visitor.append(&thisObject->m_unlinkedCodeBlockForCall);
117     visitor.append(&thisObject->m_unlinkedCodeBlockForConstruct);
118     visitor.append(&thisObject->m_nameValue);
119 }
120
121 FunctionExecutable* UnlinkedFunctionExecutable::link(VM& vm, const SourceCode& ownerSource, int overrideLineNumber)
122 {
123     SourceCode source = m_sourceOverride ? SourceCode(m_sourceOverride) : ownerSource;
124     unsigned firstLine = source.firstLine() + m_firstLineOffset;
125     unsigned startOffset = source.startOffset() + m_startOffset;
126     unsigned lineCount = m_lineCount;
127
128     // Adjust to one-based indexing.
129     bool startColumnIsOnFirstSourceLine = !m_firstLineOffset;
130     unsigned startColumn = m_unlinkedBodyStartColumn + (startColumnIsOnFirstSourceLine ? source.startColumn() : 1);
131     bool endColumnIsOnStartLine = !lineCount;
132     unsigned endColumn = m_unlinkedBodyEndColumn + (endColumnIsOnStartLine ? startColumn : 1);
133
134     SourceCode code(source.provider(), startOffset, startOffset + m_sourceLength, firstLine, startColumn);
135     FunctionOverrides::OverrideInfo overrideInfo;
136     bool hasFunctionOverride = false;
137
138     if (UNLIKELY(Options::functionOverrides())) {
139         hasFunctionOverride = FunctionOverrides::initializeOverrideFor(code, overrideInfo);
140         if (hasFunctionOverride) {
141             firstLine = overrideInfo.firstLine;
142             lineCount = overrideInfo.lineCount;
143             startColumn = overrideInfo.startColumn;
144             endColumn = overrideInfo.endColumn;
145             code = overrideInfo.sourceCode;
146         }
147     }
148
149     FunctionExecutable* result = FunctionExecutable::create(vm, code, this, firstLine, firstLine + lineCount, startColumn, endColumn);
150     if (overrideLineNumber != -1)
151         result->setOverrideLineNumber(overrideLineNumber);
152
153     if (UNLIKELY(hasFunctionOverride)) {
154         result->overrideParameterAndTypeProfilingStartEndOffsets(
155             overrideInfo.parametersStartOffset,
156             overrideInfo.typeProfilingStartOffset,
157             overrideInfo.typeProfilingEndOffset);
158     }
159
160     return result;
161 }
162
163 UnlinkedFunctionExecutable* UnlinkedFunctionExecutable::fromGlobalCode(
164     const Identifier& name, ExecState& exec, const SourceCode& source, 
165     JSObject*& exception, int overrideLineNumber)
166 {
167     ParserError error;
168     VM& vm = exec.vm();
169     CodeCache* codeCache = vm.codeCache();
170     UnlinkedFunctionExecutable* executable = codeCache->getFunctionExecutableFromGlobalCode(vm, name, source, error);
171
172     auto& globalObject = *exec.lexicalGlobalObject();
173     if (globalObject.hasDebugger())
174         globalObject.debugger()->sourceParsed(&exec, source.provider(), error.line(), error.message());
175
176     if (error.isValid()) {
177         exception = error.toErrorObject(&globalObject, source, overrideLineNumber);
178         return nullptr;
179     }
180
181     return executable;
182 }
183
184 UnlinkedFunctionCodeBlock* UnlinkedFunctionExecutable::unlinkedCodeBlockFor(
185     VM& vm, const SourceCode& source, CodeSpecializationKind specializationKind, 
186     DebuggerMode debuggerMode, ProfilerMode profilerMode, ParserError& error, SourceParseMode parseMode)
187 {
188     switch (specializationKind) {
189     case CodeForCall:
190         if (UnlinkedFunctionCodeBlock* codeBlock = m_unlinkedCodeBlockForCall.get())
191             return codeBlock;
192         break;
193     case CodeForConstruct:
194         if (UnlinkedFunctionCodeBlock* codeBlock = m_unlinkedCodeBlockForConstruct.get())
195             return codeBlock;
196         break;
197     }
198
199     UnlinkedFunctionCodeBlock* result = generateUnlinkedFunctionCodeBlock(
200         vm, this, source, specializationKind, debuggerMode, profilerMode, 
201         isBuiltinFunction() ? UnlinkedBuiltinFunction : UnlinkedNormalFunction, 
202         error, parseMode);
203     
204     if (error.isValid())
205         return nullptr;
206
207     switch (specializationKind) {
208     case CodeForCall:
209         m_unlinkedCodeBlockForCall.set(vm, this, result);
210         break;
211     case CodeForConstruct:
212         m_unlinkedCodeBlockForConstruct.set(vm, this, result);
213         break;
214     }
215     return result;
216 }
217
218 void UnlinkedFunctionExecutable::setInvalidTypeProfilingOffsets()
219 {
220     m_typeProfilingStartOffset = std::numeric_limits<unsigned>::max();
221     m_typeProfilingEndOffset = std::numeric_limits<unsigned>::max();
222 }
223
224 } // namespace JSC