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