Introducing construct ability into JS executables
[WebKit-https.git] / Source / JavaScriptCore / bytecode / UnlinkedCodeBlock.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
28 #include "UnlinkedCodeBlock.h"
29
30 #include "BytecodeGenerator.h"
31 #include "ClassInfo.h"
32 #include "CodeCache.h"
33 #include "Executable.h"
34 #include "FunctionOverrides.h"
35 #include "JSString.h"
36 #include "JSCInlines.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 const ClassInfo UnlinkedCodeBlock::s_info = { "UnlinkedCodeBlock", 0, 0, CREATE_METHOD_TABLE(UnlinkedCodeBlock) };
50 const ClassInfo UnlinkedGlobalCodeBlock::s_info = { "UnlinkedGlobalCodeBlock", &Base::s_info, 0, CREATE_METHOD_TABLE(UnlinkedGlobalCodeBlock) };
51 const ClassInfo UnlinkedProgramCodeBlock::s_info = { "UnlinkedProgramCodeBlock", &Base::s_info, 0, CREATE_METHOD_TABLE(UnlinkedProgramCodeBlock) };
52 const ClassInfo UnlinkedEvalCodeBlock::s_info = { "UnlinkedEvalCodeBlock", &Base::s_info, 0, CREATE_METHOD_TABLE(UnlinkedEvalCodeBlock) };
53 const ClassInfo UnlinkedFunctionCodeBlock::s_info = { "UnlinkedFunctionCodeBlock", &Base::s_info, 0, CREATE_METHOD_TABLE(UnlinkedFunctionCodeBlock) };
54
55 static UnlinkedFunctionCodeBlock* generateFunctionCodeBlock(
56     VM& vm, UnlinkedFunctionExecutable* executable, const SourceCode& source,
57     CodeSpecializationKind kind, DebuggerMode debuggerMode, ProfilerMode profilerMode,
58     UnlinkedFunctionKind functionKind, ParserError& error)
59 {
60     JSParserBuiltinMode builtinMode = executable->isBuiltinFunction() ? JSParserBuiltinMode::Builtin : JSParserBuiltinMode::NotBuiltin;
61     JSParserStrictMode strictMode = executable->isInStrictContext() ? JSParserStrictMode::Strict : JSParserStrictMode::NotStrict;
62     std::unique_ptr<FunctionNode> function = parse<FunctionNode>(
63         &vm, source, executable->name(), builtinMode, strictMode, 
64         JSParserCodeType::Function, error, nullptr, executable->parseMode());
65
66     if (!function) {
67         ASSERT(error.isValid());
68         return nullptr;
69     }
70
71     function->finishParsing(executable->name(), executable->functionMode());
72     executable->recordParse(function->features(), function->hasCapturedVariables());
73     
74     UnlinkedFunctionCodeBlock* result = UnlinkedFunctionCodeBlock::create(&vm, FunctionCode,
75         ExecutableInfo(function->needsActivation(), function->usesEval(), function->isStrictMode(), kind == CodeForConstruct, functionKind == UnlinkedBuiltinFunction, executable->constructorKind()));
76     auto generator(std::make_unique<BytecodeGenerator>(vm, function.get(), result, debuggerMode, profilerMode, executable->parentScopeTDZVariables()));
77     error = generator->generate();
78     if (error.isValid())
79         return nullptr;
80     return result;
81 }
82
83 UnlinkedFunctionExecutable::UnlinkedFunctionExecutable(VM* vm, Structure* structure, const SourceCode& source, RefPtr<SourceProvider>&& sourceOverride, FunctionBodyNode* node, UnlinkedFunctionKind kind, ConstructAbility constructAbility, VariableEnvironment& parentScopeTDZVariables)
84     : Base(*vm, structure)
85     , m_name(node->ident())
86     , m_inferredName(node->inferredName())
87     , m_sourceOverride(WTF::move(sourceOverride))
88     , m_firstLineOffset(node->firstLine() - source.firstLine())
89     , m_lineCount(node->lastLine() - node->firstLine())
90     , m_unlinkedFunctionNameStart(node->functionNameStart() - source.startOffset())
91     , m_unlinkedBodyStartColumn(node->startColumn())
92     , m_unlinkedBodyEndColumn(m_lineCount ? node->endColumn() : node->endColumn() - node->startColumn())
93     , m_startOffset(node->source().startOffset() - source.startOffset())
94     , m_sourceLength(node->source().length())
95     , m_parametersStartOffset(node->parametersStart())
96     , m_typeProfilingStartOffset(node->functionKeywordStart())
97     , m_typeProfilingEndOffset(node->startStartOffset() + node->source().length() - 1)
98     , m_parameterCount(node->parameterCount())
99     , m_parseMode(node->parseMode())
100     , m_features(0)
101     , m_isInStrictContext(node->isInStrictContext())
102     , m_hasCapturedVariables(false)
103     , m_isBuiltinFunction(kind == UnlinkedBuiltinFunction)
104     , m_constructAbility(static_cast<unsigned>(constructAbility))
105     , m_constructorKind(static_cast<unsigned>(node->constructorKind()))
106     , m_functionMode(node->functionMode())
107 {
108     ASSERT(m_constructorKind == static_cast<unsigned>(node->constructorKind()));
109     m_parentScopeTDZVariables.swap(parentScopeTDZVariables);
110 }
111
112 void UnlinkedFunctionExecutable::visitChildren(JSCell* cell, SlotVisitor& visitor)
113 {
114     UnlinkedFunctionExecutable* thisObject = jsCast<UnlinkedFunctionExecutable*>(cell);
115     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
116     Base::visitChildren(thisObject, visitor);
117     visitor.append(&thisObject->m_codeBlockForCall);
118     visitor.append(&thisObject->m_codeBlockForConstruct);
119     visitor.append(&thisObject->m_nameValue);
120 }
121
122 FunctionExecutable* UnlinkedFunctionExecutable::link(VM& vm, const SourceCode& ownerSource, int overrideLineNumber)
123 {
124     SourceCode source = m_sourceOverride ? SourceCode(m_sourceOverride) : ownerSource;
125     unsigned firstLine = source.firstLine() + m_firstLineOffset;
126     unsigned startOffset = source.startOffset() + m_startOffset;
127     unsigned lineCount = m_lineCount;
128
129     // Adjust to one-based indexing.
130     bool startColumnIsOnFirstSourceLine = !m_firstLineOffset;
131     unsigned startColumn = m_unlinkedBodyStartColumn + (startColumnIsOnFirstSourceLine ? source.startColumn() : 1);
132     bool endColumnIsOnStartLine = !lineCount;
133     unsigned endColumn = m_unlinkedBodyEndColumn + (endColumnIsOnStartLine ? startColumn : 1);
134
135     SourceCode code(source.provider(), startOffset, startOffset + m_sourceLength, firstLine, startColumn);
136     FunctionOverrides::OverrideInfo overrideInfo;
137     bool hasFunctionOverride = false;
138
139     if (UNLIKELY(Options::functionOverrides())) {
140         hasFunctionOverride = FunctionOverrides::initializeOverrideFor(code, overrideInfo);
141         if (hasFunctionOverride) {
142             firstLine = overrideInfo.firstLine;
143             lineCount = overrideInfo.lineCount;
144             startColumn = overrideInfo.startColumn;
145             endColumn = overrideInfo.endColumn;
146             code = overrideInfo.sourceCode;
147         }
148     }
149
150     FunctionExecutable* result = FunctionExecutable::create(vm, code, this, firstLine, firstLine + lineCount, startColumn, endColumn);
151     if (overrideLineNumber != -1)
152         result->setOverrideLineNumber(overrideLineNumber);
153
154     if (UNLIKELY(hasFunctionOverride)) {
155         result->overrideParameterAndTypeProfilingStartEndOffsets(
156             overrideInfo.parametersStartOffset,
157             overrideInfo.typeProfilingStartOffset,
158             overrideInfo.typeProfilingEndOffset);
159     }
160
161     return result;
162 }
163
164 UnlinkedFunctionExecutable* UnlinkedFunctionExecutable::fromGlobalCode(
165     const Identifier& name, ExecState& exec, const SourceCode& source, 
166     JSObject*& exception, int overrideLineNumber)
167 {
168     ParserError error;
169     VM& vm = exec.vm();
170     CodeCache* codeCache = vm.codeCache();
171     UnlinkedFunctionExecutable* executable = codeCache->getFunctionExecutableFromGlobalCode(vm, name, source, error);
172
173     auto& globalObject = *exec.lexicalGlobalObject();
174     if (globalObject.hasDebugger())
175         globalObject.debugger()->sourceParsed(&exec, source.provider(), error.line(), error.message());
176
177     if (error.isValid()) {
178         exception = error.toErrorObject(&globalObject, source, overrideLineNumber);
179         return nullptr;
180     }
181
182     return executable;
183 }
184
185 UnlinkedFunctionCodeBlock* UnlinkedFunctionExecutable::codeBlockFor(
186     VM& vm, const SourceCode& source, CodeSpecializationKind specializationKind, 
187     DebuggerMode debuggerMode, ProfilerMode profilerMode, ParserError& error)
188 {
189     switch (specializationKind) {
190     case CodeForCall:
191         if (UnlinkedFunctionCodeBlock* codeBlock = m_codeBlockForCall.get())
192             return codeBlock;
193         break;
194     case CodeForConstruct:
195         if (UnlinkedFunctionCodeBlock* codeBlock = m_codeBlockForConstruct.get())
196             return codeBlock;
197         break;
198     }
199
200     UnlinkedFunctionCodeBlock* result = generateFunctionCodeBlock(
201         vm, this, source, specializationKind, debuggerMode, profilerMode, 
202         isBuiltinFunction() ? UnlinkedBuiltinFunction : UnlinkedNormalFunction, 
203         error);
204     
205     if (error.isValid())
206         return nullptr;
207
208     switch (specializationKind) {
209     case CodeForCall:
210         m_codeBlockForCall.set(vm, this, result);
211         break;
212     case CodeForConstruct:
213         m_codeBlockForConstruct.set(vm, this, result);
214         break;
215     }
216     return result;
217 }
218
219 UnlinkedCodeBlock::UnlinkedCodeBlock(VM* vm, Structure* structure, CodeType codeType, const ExecutableInfo& info)
220     : Base(*vm, structure)
221     , m_numVars(0)
222     , m_numCalleeRegisters(0)
223     , m_numParameters(0)
224     , m_vm(vm)
225     , m_globalObjectRegister(VirtualRegister())
226     , m_needsFullScopeChain(info.needsActivation())
227     , m_usesEval(info.usesEval())
228     , m_isStrictMode(info.isStrictMode())
229     , m_isConstructor(info.isConstructor())
230     , m_hasCapturedVariables(false)
231     , m_isBuiltinFunction(info.isBuiltinFunction())
232     , m_constructorKind(static_cast<unsigned>(info.constructorKind()))
233     , m_firstLine(0)
234     , m_lineCount(0)
235     , m_endColumn(UINT_MAX)
236     , m_features(0)
237     , m_codeType(codeType)
238     , m_arrayProfileCount(0)
239     , m_arrayAllocationProfileCount(0)
240     , m_objectAllocationProfileCount(0)
241     , m_valueProfileCount(0)
242     , m_llintCallLinkInfoCount(0)
243 #if ENABLE(BYTECODE_COMMENTS)
244     , m_bytecodeCommentIterator(0)
245 #endif
246 {
247     for (auto& constantRegisterIndex : m_linkTimeConstants)
248         constantRegisterIndex = 0;
249     ASSERT(m_constructorKind == static_cast<unsigned>(info.constructorKind()));
250 }
251
252 void UnlinkedCodeBlock::visitChildren(JSCell* cell, SlotVisitor& visitor)
253 {
254     UnlinkedCodeBlock* thisObject = jsCast<UnlinkedCodeBlock*>(cell);
255     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
256     Base::visitChildren(thisObject, visitor);
257     visitor.append(&thisObject->m_symbolTable);
258     for (FunctionExpressionVector::iterator ptr = thisObject->m_functionDecls.begin(), end = thisObject->m_functionDecls.end(); ptr != end; ++ptr)
259         visitor.append(ptr);
260     for (FunctionExpressionVector::iterator ptr = thisObject->m_functionExprs.begin(), end = thisObject->m_functionExprs.end(); ptr != end; ++ptr)
261         visitor.append(ptr);
262     visitor.appendValues(thisObject->m_constantRegisters.data(), thisObject->m_constantRegisters.size());
263     if (thisObject->m_rareData) {
264         for (size_t i = 0, end = thisObject->m_rareData->m_regexps.size(); i != end; i++)
265             visitor.append(&thisObject->m_rareData->m_regexps[i]);
266     }
267 }
268
269 int UnlinkedCodeBlock::lineNumberForBytecodeOffset(unsigned bytecodeOffset)
270 {
271     ASSERT(bytecodeOffset < instructions().count());
272     int divot;
273     int startOffset;
274     int endOffset;
275     unsigned line;
276     unsigned column;
277     expressionRangeForBytecodeOffset(bytecodeOffset, divot, startOffset, endOffset, line, column);
278     return line;
279 }
280
281 inline void UnlinkedCodeBlock::getLineAndColumn(ExpressionRangeInfo& info,
282     unsigned& line, unsigned& column)
283 {
284     switch (info.mode) {
285     case ExpressionRangeInfo::FatLineMode:
286         info.decodeFatLineMode(line, column);
287         break;
288     case ExpressionRangeInfo::FatColumnMode:
289         info.decodeFatColumnMode(line, column);
290         break;
291     case ExpressionRangeInfo::FatLineAndColumnMode: {
292         unsigned fatIndex = info.position;
293         ExpressionRangeInfo::FatPosition& fatPos = m_rareData->m_expressionInfoFatPositions[fatIndex];
294         line = fatPos.line;
295         column = fatPos.column;
296         break;
297     }
298     } // switch
299 }
300
301 #ifndef NDEBUG
302 static void dumpLineColumnEntry(size_t index, const UnlinkedInstructionStream& instructionStream, unsigned instructionOffset, unsigned line, unsigned column)
303 {
304     const auto& instructions = instructionStream.unpackForDebugging();
305     OpcodeID opcode = instructions[instructionOffset].u.opcode;
306     const char* event = "";
307     if (opcode == op_debug) {
308         switch (instructions[instructionOffset + 1].u.operand) {
309         case WillExecuteProgram: event = " WillExecuteProgram"; break;
310         case DidExecuteProgram: event = " DidExecuteProgram"; break;
311         case DidEnterCallFrame: event = " DidEnterCallFrame"; break;
312         case DidReachBreakpoint: event = " DidReachBreakpoint"; break;
313         case WillLeaveCallFrame: event = " WillLeaveCallFrame"; break;
314         case WillExecuteStatement: event = " WillExecuteStatement"; break;
315         }
316     }
317     dataLogF("  [%zu] pc %u @ line %u col %u : %s%s\n", index, instructionOffset, line, column, opcodeNames[opcode], event);
318 }
319
320 void UnlinkedCodeBlock::dumpExpressionRangeInfo()
321 {
322     Vector<ExpressionRangeInfo>& expressionInfo = m_expressionInfo;
323
324     size_t size = m_expressionInfo.size();
325     dataLogF("UnlinkedCodeBlock %p expressionRangeInfo[%zu] {\n", this, size);
326     for (size_t i = 0; i < size; i++) {
327         ExpressionRangeInfo& info = expressionInfo[i];
328         unsigned line;
329         unsigned column;
330         getLineAndColumn(info, line, column);
331         dumpLineColumnEntry(i, instructions(), info.instructionOffset, line, column);
332     }
333     dataLog("}\n");
334 }
335 #endif
336
337 void UnlinkedCodeBlock::expressionRangeForBytecodeOffset(unsigned bytecodeOffset,
338     int& divot, int& startOffset, int& endOffset, unsigned& line, unsigned& column)
339 {
340     ASSERT(bytecodeOffset < instructions().count());
341
342     if (!m_expressionInfo.size()) {
343         startOffset = 0;
344         endOffset = 0;
345         divot = 0;
346         line = 0;
347         column = 0;
348         return;
349     }
350
351     Vector<ExpressionRangeInfo>& expressionInfo = m_expressionInfo;
352
353     int low = 0;
354     int high = expressionInfo.size();
355     while (low < high) {
356         int mid = low + (high - low) / 2;
357         if (expressionInfo[mid].instructionOffset <= bytecodeOffset)
358             low = mid + 1;
359         else
360             high = mid;
361     }
362
363     if (!low)
364         low = 1;
365
366     ExpressionRangeInfo& info = expressionInfo[low - 1];
367     startOffset = info.startOffset;
368     endOffset = info.endOffset;
369     divot = info.divotPoint;
370     getLineAndColumn(info, line, column);
371 }
372
373 void UnlinkedCodeBlock::addExpressionInfo(unsigned instructionOffset,
374     int divot, int startOffset, int endOffset, unsigned line, unsigned column)
375 {
376     if (divot > ExpressionRangeInfo::MaxDivot) {
377         // Overflow has occurred, we can only give line number info for errors for this region
378         divot = 0;
379         startOffset = 0;
380         endOffset = 0;
381     } else if (startOffset > ExpressionRangeInfo::MaxOffset) {
382         // If the start offset is out of bounds we clear both offsets
383         // so we only get the divot marker. Error message will have to be reduced
384         // to line and charPosition number.
385         startOffset = 0;
386         endOffset = 0;
387     } else if (endOffset > ExpressionRangeInfo::MaxOffset) {
388         // The end offset is only used for additional context, and is much more likely
389         // to overflow (eg. function call arguments) so we are willing to drop it without
390         // dropping the rest of the range.
391         endOffset = 0;
392     }
393
394     unsigned positionMode =
395         (line <= ExpressionRangeInfo::MaxFatLineModeLine && column <= ExpressionRangeInfo::MaxFatLineModeColumn) 
396         ? ExpressionRangeInfo::FatLineMode
397         : (line <= ExpressionRangeInfo::MaxFatColumnModeLine && column <= ExpressionRangeInfo::MaxFatColumnModeColumn)
398         ? ExpressionRangeInfo::FatColumnMode
399         : ExpressionRangeInfo::FatLineAndColumnMode;
400
401     ExpressionRangeInfo info;
402     info.instructionOffset = instructionOffset;
403     info.divotPoint = divot;
404     info.startOffset = startOffset;
405     info.endOffset = endOffset;
406
407     info.mode = positionMode;
408     switch (positionMode) {
409     case ExpressionRangeInfo::FatLineMode:
410         info.encodeFatLineMode(line, column);
411         break;
412     case ExpressionRangeInfo::FatColumnMode:
413         info.encodeFatColumnMode(line, column);
414         break;
415     case ExpressionRangeInfo::FatLineAndColumnMode: {
416         createRareDataIfNecessary();
417         unsigned fatIndex = m_rareData->m_expressionInfoFatPositions.size();
418         ExpressionRangeInfo::FatPosition fatPos = { line, column };
419         m_rareData->m_expressionInfoFatPositions.append(fatPos);
420         info.position = fatIndex;
421     }
422     } // switch
423
424     m_expressionInfo.append(info);
425 }
426
427 bool UnlinkedCodeBlock::typeProfilerExpressionInfoForBytecodeOffset(unsigned bytecodeOffset, unsigned& startDivot, unsigned& endDivot)
428 {
429     static const bool verbose = false;
430     auto iter = m_typeProfilerInfoMap.find(bytecodeOffset);
431     if (iter == m_typeProfilerInfoMap.end()) {
432         if (verbose)
433             dataLogF("Don't have assignment info for offset:%u\n", bytecodeOffset);
434         startDivot = UINT_MAX;
435         endDivot = UINT_MAX;
436         return false;
437     }
438     
439     TypeProfilerExpressionRange& range = iter->value;
440     startDivot = range.m_startDivot;
441     endDivot = range.m_endDivot;
442     return true;
443 }
444
445 void UnlinkedCodeBlock::addTypeProfilerExpressionInfo(unsigned instructionOffset, unsigned startDivot, unsigned endDivot)
446 {
447     TypeProfilerExpressionRange range;
448     range.m_startDivot = startDivot;
449     range.m_endDivot = endDivot;
450     m_typeProfilerInfoMap.set(instructionOffset, range);  
451 }
452
453 void UnlinkedProgramCodeBlock::visitChildren(JSCell* cell, SlotVisitor& visitor)
454 {
455     UnlinkedProgramCodeBlock* thisObject = jsCast<UnlinkedProgramCodeBlock*>(cell);
456     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
457     Base::visitChildren(thisObject, visitor);
458 }
459
460 UnlinkedCodeBlock::~UnlinkedCodeBlock()
461 {
462 }
463
464 void UnlinkedProgramCodeBlock::destroy(JSCell* cell)
465 {
466     jsCast<UnlinkedProgramCodeBlock*>(cell)->~UnlinkedProgramCodeBlock();
467 }
468
469 void UnlinkedEvalCodeBlock::destroy(JSCell* cell)
470 {
471     jsCast<UnlinkedEvalCodeBlock*>(cell)->~UnlinkedEvalCodeBlock();
472 }
473
474 void UnlinkedFunctionCodeBlock::destroy(JSCell* cell)
475 {
476     jsCast<UnlinkedFunctionCodeBlock*>(cell)->~UnlinkedFunctionCodeBlock();
477 }
478
479 void UnlinkedFunctionExecutable::destroy(JSCell* cell)
480 {
481     jsCast<UnlinkedFunctionExecutable*>(cell)->~UnlinkedFunctionExecutable();
482 }
483
484 void UnlinkedCodeBlock::setInstructions(std::unique_ptr<UnlinkedInstructionStream> instructions)
485 {
486     m_unlinkedInstructions = WTF::move(instructions);
487 }
488
489 const UnlinkedInstructionStream& UnlinkedCodeBlock::instructions() const
490 {
491     ASSERT(m_unlinkedInstructions.get());
492     return *m_unlinkedInstructions;
493 }
494
495 }
496