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