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