5544cae800830f8186a43f84b99509326ea79b74
[WebKit-https.git] / Source / JavaScriptCore / ChangeLog
1 2013-07-31  Kwang Yul Seo  <skyul@company100.net>
2
3         Use emptyString instead of String("")
4         https://bugs.webkit.org/show_bug.cgi?id=119335
5
6         Reviewed by Darin Adler.
7
8         Use emptyString() instead of String("") because it is better style and
9         faster. This is a followup to r116908, removing all occurrences of
10         String("") from WebKit.
11
12         * runtime/RegExpConstructor.cpp:
13         (JSC::constructRegExp):
14         * runtime/RegExpPrototype.cpp:
15         (JSC::regExpProtoFuncCompile):
16         * runtime/StringPrototype.cpp:
17         (JSC::stringProtoFuncMatch):
18         (JSC::stringProtoFuncSearch):
19
20 2013-07-31  Ruth Fong  <ruth_fong@apple.com>
21
22         <input type=color> Mac UI behaviour
23         <rdar://problem/10269922> and https://bugs.webkit.org/show_bug.cgi?id=61276
24
25         Reviewed by Brady Eidson.
26
27         * Configurations/FeatureDefines.xcconfig: Enabled INPUT_TYPE_COLOR.
28
29 2013-07-31  Mark Hahnenberg  <mhahnenberg@apple.com>
30
31         DFG doesn't account for inlining of functions with switch statements that haven't been executed by the baseline JIT
32         https://bugs.webkit.org/show_bug.cgi?id=119349
33
34         Reviewed by Geoffrey Garen.
35
36         Prior to this patch, the baseline JIT was responsible for resizing the ctiOffsets Vector for 
37         SimpleJumpTables to be equal to the size of the branchOffsets Vector. The DFG implicitly relied
38         on code it compiled with any switch statements to have been run in the baseline JIT first. 
39         However, if the DFG chooses to inline a function that has never been compiled by the baseline 
40         JIT then this resizing never happens and we crash at link time in the DFG.
41
42         We can fix this by also doing the resize in the DFG to catch this case.
43
44         * dfg/DFGJITCompiler.cpp:
45         (JSC::DFG::JITCompiler::link):
46
47 2013-07-31  Gavin Barraclough  <barraclough@apple.com>
48
49         Speculative Windows build fix.
50
51         Reviewed by NOBODY
52
53         * runtime/JSString.cpp:
54         (JSC::JSRopeString::getIndexSlowCase):
55         * runtime/JSString.h:
56
57 2013-07-30  Gavin Barraclough  <barraclough@apple.com>
58
59         Some cleanup in JSValue::get
60         https://bugs.webkit.org/show_bug.cgi?id=119343
61
62         Reviewed by Geoff Garen.
63
64         JSValue::get is implemented to:
65             1) Check if the value is a cell – if not, synthesize a prototype to search,
66             2) call getOwnPropertySlot on the cell,
67             3) if this returns false, cast to JSObject to get the prototype, and walk the prototype chain.
68         By all rights this should crash when passed a string and accessing a property that does not exist, because
69         the string is a cell, getOwnPropertySlot should return false, and the cast to JSObject should be unsafe.
70         To work around this, JSString::getOwnPropertySlot actually implements 'get' functionality - searching the
71         prototype chain, and faking out a return value of undefined if no property is found.
72
73         This is a huge hazard, since fixing JSString::getOwnPropertySlot or calling getOwnPropertySlot on cells
74         from elsewhere would introduce bugs. Fortunately it is only ever called in this one place.
75
76         The fix here is to move getOwnPropertySlot onto JSObjecte and end this madness - cells don't have property
77         slots anyway.
78
79         Interesting changes are in JSCJSValueInlines.h, JSString.cpp - the rest is pretty much all JSCell -> JSObject.
80
81 2013-07-31  Michael Saboff  <msaboff@apple.com>
82
83         [Win] JavaScript crash.
84         https://bugs.webkit.org/show_bug.cgi?id=119339
85
86         Reviewed by Mark Hahnenberg.
87
88         * jit/JITStubsX86.h: Implement ctiVMThrowTrampoline and
89         ctiVMThrowTrampolineSlowpath the same way as the gcc x86 version does.
90
91 2013-07-30  Mark Hahnenberg  <mhahnenberg@apple.com>
92
93         GetByVal on Arguments does the wrong size load when checking the Arguments object length
94         https://bugs.webkit.org/show_bug.cgi?id=119281
95
96         Reviewed by Geoffrey Garen.
97
98         This leads to out of bounds accesses and subsequent crashes.
99
100         * dfg/DFGSpeculativeJIT.cpp:
101         (JSC::DFG::SpeculativeJIT::compileGetByValOnArguments):
102         * dfg/DFGSpeculativeJIT64.cpp:
103         (JSC::DFG::SpeculativeJIT::compile):
104
105 2013-07-30  Oliver Hunt  <oliver@apple.com>
106
107         Add an assertion to SpeculateCellOperand
108         https://bugs.webkit.org/show_bug.cgi?id=119276
109
110         Reviewed by Michael Saboff.
111
112         More assertions are better
113
114         * dfg/DFGSpeculativeJIT64.cpp:
115         (JSC::DFG::SpeculativeJIT::fillSpeculateCell):
116         (JSC::DFG::SpeculativeJIT::compile):
117
118 2013-07-30  Mark Lam  <mark.lam@apple.com>
119
120         Fix problems with divot and lineStart mismatches.
121         https://bugs.webkit.org/show_bug.cgi?id=118662.
122
123         Reviewed by Oliver Hunt.
124
125         r152494 added the recording of lineStart values for divot positions.
126         This is needed for the computation of column numbers. Similarly, it also
127         added the recording of line numbers for the divot positions. One problem
128         with the approach taken was that the line and lineStart values were
129         recorded independently, and hence were not always guaranteed to be
130         sampled at the same place that the divot position is recorded. This
131         resulted in potential mismatches that cause some assertions to fail.
132
133         The solution is to introduce a JSTextPosition abstraction that records
134         the divot position, line, and lineStart as a single quantity. Wherever
135         we record the divot position as an unsigned int previously, we now record
136         its JSTextPosition which captures all 3 values in one go. This ensures
137         that the captured line and lineStart will always match the captured divot
138         position.
139
140         * bytecompiler/BytecodeGenerator.cpp:
141         (JSC::BytecodeGenerator::emitCall):
142         (JSC::BytecodeGenerator::emitCallEval):
143         (JSC::BytecodeGenerator::emitCallVarargs):
144         (JSC::BytecodeGenerator::emitConstruct):
145         (JSC::BytecodeGenerator::emitDebugHook):
146         - Use JSTextPosition instead of passing line and lineStart explicitly.
147         * bytecompiler/BytecodeGenerator.h:
148         (JSC::BytecodeGenerator::emitExpressionInfo):
149         - Use JSTextPosition instead of passing line and lineStart explicitly.
150         * bytecompiler/NodesCodegen.cpp:
151         (JSC::ThrowableExpressionData::emitThrowReferenceError):
152         (JSC::ResolveNode::emitBytecode):
153         (JSC::BracketAccessorNode::emitBytecode):
154         (JSC::DotAccessorNode::emitBytecode):
155         (JSC::NewExprNode::emitBytecode):
156         (JSC::EvalFunctionCallNode::emitBytecode):
157         (JSC::FunctionCallValueNode::emitBytecode):
158         (JSC::FunctionCallResolveNode::emitBytecode):
159         (JSC::FunctionCallBracketNode::emitBytecode):
160         (JSC::FunctionCallDotNode::emitBytecode):
161         (JSC::CallFunctionCallDotNode::emitBytecode):
162         (JSC::ApplyFunctionCallDotNode::emitBytecode):
163         (JSC::PostfixNode::emitResolve):
164         (JSC::PostfixNode::emitBracket):
165         (JSC::PostfixNode::emitDot):
166         (JSC::DeleteResolveNode::emitBytecode):
167         (JSC::DeleteBracketNode::emitBytecode):
168         (JSC::DeleteDotNode::emitBytecode):
169         (JSC::PrefixNode::emitResolve):
170         (JSC::PrefixNode::emitBracket):
171         (JSC::PrefixNode::emitDot):
172         (JSC::UnaryOpNode::emitBytecode):
173         (JSC::BinaryOpNode::emitStrcat):
174         (JSC::BinaryOpNode::emitBytecode):
175         (JSC::ThrowableBinaryOpNode::emitBytecode):
176         (JSC::InstanceOfNode::emitBytecode):
177         (JSC::emitReadModifyAssignment):
178         (JSC::ReadModifyResolveNode::emitBytecode):
179         (JSC::AssignResolveNode::emitBytecode):
180         (JSC::AssignDotNode::emitBytecode):
181         (JSC::ReadModifyDotNode::emitBytecode):
182         (JSC::AssignBracketNode::emitBytecode):
183         (JSC::ReadModifyBracketNode::emitBytecode):
184         (JSC::ForInNode::emitBytecode):
185         (JSC::WithNode::emitBytecode):
186         (JSC::ThrowNode::emitBytecode):
187         - Use JSTextPosition instead of passing line and lineStart explicitly.
188         * parser/ASTBuilder.h:
189         - Replaced ASTBuilder::PositionInfo with JSTextPosition.
190         (JSC::ASTBuilder::BinaryOpInfo::BinaryOpInfo):
191         (JSC::ASTBuilder::AssignmentInfo::AssignmentInfo):
192         (JSC::ASTBuilder::createResolve):
193         (JSC::ASTBuilder::createBracketAccess):
194         (JSC::ASTBuilder::createDotAccess):
195         (JSC::ASTBuilder::createRegExp):
196         (JSC::ASTBuilder::createNewExpr):
197         (JSC::ASTBuilder::createAssignResolve):
198         (JSC::ASTBuilder::createExprStatement):
199         (JSC::ASTBuilder::createForInLoop):
200         (JSC::ASTBuilder::createReturnStatement):
201         (JSC::ASTBuilder::createBreakStatement):
202         (JSC::ASTBuilder::createContinueStatement):
203         (JSC::ASTBuilder::createLabelStatement):
204         (JSC::ASTBuilder::createWithStatement):
205         (JSC::ASTBuilder::createThrowStatement):
206         (JSC::ASTBuilder::appendBinaryExpressionInfo):
207         (JSC::ASTBuilder::appendUnaryToken):
208         (JSC::ASTBuilder::unaryTokenStackLastStart):
209         (JSC::ASTBuilder::assignmentStackAppend):
210         (JSC::ASTBuilder::createAssignment):
211         (JSC::ASTBuilder::setExceptionLocation):
212         (JSC::ASTBuilder::makeDeleteNode):
213         (JSC::ASTBuilder::makeFunctionCallNode):
214         (JSC::ASTBuilder::makeBinaryNode):
215         (JSC::ASTBuilder::makeAssignNode):
216         (JSC::ASTBuilder::makePrefixNode):
217         (JSC::ASTBuilder::makePostfixNode):
218         - Use JSTextPosition instead of passing line and lineStart explicitly.
219         * parser/Lexer.cpp:
220         (JSC::::lex):
221         - Added support for capturing the appropriate JSTextPositions instead
222           of just the character offset.
223         * parser/Lexer.h:
224         (JSC::Lexer::currentPosition):
225         (JSC::::lexExpectIdentifier):
226         - Added support for capturing the appropriate JSTextPositions instead
227           of just the character offset.
228         * parser/NodeConstructors.h:
229         (JSC::Node::Node):
230         (JSC::ResolveNode::ResolveNode):
231         (JSC::EvalFunctionCallNode::EvalFunctionCallNode):
232         (JSC::FunctionCallValueNode::FunctionCallValueNode):
233         (JSC::FunctionCallResolveNode::FunctionCallResolveNode):
234         (JSC::FunctionCallBracketNode::FunctionCallBracketNode):
235         (JSC::FunctionCallDotNode::FunctionCallDotNode):
236         (JSC::CallFunctionCallDotNode::CallFunctionCallDotNode):
237         (JSC::ApplyFunctionCallDotNode::ApplyFunctionCallDotNode):
238         (JSC::PostfixNode::PostfixNode):
239         (JSC::DeleteResolveNode::DeleteResolveNode):
240         (JSC::DeleteBracketNode::DeleteBracketNode):
241         (JSC::DeleteDotNode::DeleteDotNode):
242         (JSC::PrefixNode::PrefixNode):
243         (JSC::ReadModifyResolveNode::ReadModifyResolveNode):
244         (JSC::ReadModifyBracketNode::ReadModifyBracketNode):
245         (JSC::AssignBracketNode::AssignBracketNode):
246         (JSC::AssignDotNode::AssignDotNode):
247         (JSC::ReadModifyDotNode::ReadModifyDotNode):
248         (JSC::AssignErrorNode::AssignErrorNode):
249         (JSC::WithNode::WithNode):
250         (JSC::ForInNode::ForInNode):
251         - Use JSTextPosition instead of passing line and lineStart explicitly.
252         * parser/Nodes.cpp:
253         (JSC::StatementNode::setLoc):
254         - Use JSTextPosition instead of passing line and lineStart explicitly.
255         * parser/Nodes.h:
256         (JSC::Node::lineNo):
257         (JSC::Node::startOffset):
258         (JSC::Node::lineStartOffset):
259         (JSC::Node::position):
260         (JSC::ThrowableExpressionData::ThrowableExpressionData):
261         (JSC::ThrowableExpressionData::setExceptionSourceCode):
262         (JSC::ThrowableExpressionData::divot):
263         (JSC::ThrowableExpressionData::divotStart):
264         (JSC::ThrowableExpressionData::divotEnd):
265         (JSC::ThrowableSubExpressionData::ThrowableSubExpressionData):
266         (JSC::ThrowableSubExpressionData::setSubexpressionInfo):
267         (JSC::ThrowableSubExpressionData::subexpressionDivot):
268         (JSC::ThrowableSubExpressionData::subexpressionStart):
269         (JSC::ThrowableSubExpressionData::subexpressionEnd):
270         (JSC::ThrowablePrefixedSubExpressionData::ThrowablePrefixedSubExpressionData):
271         (JSC::ThrowablePrefixedSubExpressionData::setSubexpressionInfo):
272         (JSC::ThrowablePrefixedSubExpressionData::subexpressionDivot):
273         (JSC::ThrowablePrefixedSubExpressionData::subexpressionStart):
274         (JSC::ThrowablePrefixedSubExpressionData::subexpressionEnd):
275         - Use JSTextPosition instead of passing line and lineStart explicitly.
276         * parser/Parser.cpp:
277         (JSC::::Parser):
278         (JSC::::parseInner):
279         - Use JSTextPosition instead of passing line and lineStart explicitly.
280         (JSC::::didFinishParsing):
281         - Remove setting of m_lastLine value. We always pass in the value from
282           m_lastLine anyway. So, this assignment is effectively a nop.
283         (JSC::::parseVarDeclaration):
284         (JSC::::parseVarDeclarationList):
285         (JSC::::parseForStatement):
286         (JSC::::parseBreakStatement):
287         (JSC::::parseContinueStatement):
288         (JSC::::parseReturnStatement):
289         (JSC::::parseThrowStatement):
290         (JSC::::parseWithStatement):
291         (JSC::::parseTryStatement):
292         (JSC::::parseBlockStatement):
293         (JSC::::parseFunctionDeclaration):
294         (JSC::LabelInfo::LabelInfo):
295         (JSC::::parseExpressionOrLabelStatement):
296         (JSC::::parseExpressionStatement):
297         (JSC::::parseAssignmentExpression):
298         (JSC::::parseBinaryExpression):
299         (JSC::::parseProperty):
300         (JSC::::parsePrimaryExpression):
301         (JSC::::parseMemberExpression):
302         (JSC::::parseUnaryExpression):
303         - Use JSTextPosition instead of passing line and lineStart explicitly.
304         * parser/Parser.h:
305         (JSC::Parser::next):
306         (JSC::Parser::nextExpectIdentifier):
307         (JSC::Parser::getToken):
308         (JSC::Parser::tokenStartPosition):
309         (JSC::Parser::tokenEndPosition):
310         (JSC::Parser::lastTokenEndPosition):
311         (JSC::::parse):
312         - Use JSTextPosition instead of passing line and lineStart explicitly.
313         * parser/ParserTokens.h:
314         (JSC::JSTextPosition::JSTextPosition):
315         (JSC::JSTextPosition::operator+):
316         (JSC::JSTextPosition::operator-):
317         (JSC::JSTextPosition::operator int):
318         - Added JSTextPosition.
319         * parser/SyntaxChecker.h:
320         (JSC::SyntaxChecker::makeFunctionCallNode):
321         (JSC::SyntaxChecker::makeAssignNode):
322         (JSC::SyntaxChecker::makePrefixNode):
323         (JSC::SyntaxChecker::makePostfixNode):
324         (JSC::SyntaxChecker::makeDeleteNode):
325         (JSC::SyntaxChecker::createResolve):
326         (JSC::SyntaxChecker::createBracketAccess):
327         (JSC::SyntaxChecker::createDotAccess):
328         (JSC::SyntaxChecker::createRegExp):
329         (JSC::SyntaxChecker::createNewExpr):
330         (JSC::SyntaxChecker::createAssignResolve):
331         (JSC::SyntaxChecker::createForInLoop):
332         (JSC::SyntaxChecker::createReturnStatement):
333         (JSC::SyntaxChecker::createBreakStatement):
334         (JSC::SyntaxChecker::createContinueStatement):
335         (JSC::SyntaxChecker::createWithStatement):
336         (JSC::SyntaxChecker::createLabelStatement):
337         (JSC::SyntaxChecker::createThrowStatement):
338         (JSC::SyntaxChecker::appendBinaryExpressionInfo):
339         (JSC::SyntaxChecker::operatorStackPop):
340         - Use JSTextPosition instead of passing line and lineStart explicitly.
341
342 2013-07-29  Carlos Garcia Campos  <cgarcia@igalia.com>
343
344         Unreviewed. Fix make distcheck.
345
346         * GNUmakefile.list.am: Add missing files to compilation.
347         * bytecode/CodeBlock.cpp: Add a ENABLE(FTL_JIT) #if block to
348         include FTL header files not included in the compilation.
349         * dfg/DFGDriver.cpp: Ditto.
350         * dfg/DFGPlan.cpp: Ditto.
351
352 2013-07-29  Chris Curtis  <chris_curtis@apple.com>
353
354         Eager stack trace for error objects.
355         https://bugs.webkit.org/show_bug.cgi?id=118918
356
357         Reviewed by Geoffrey Garen.
358         
359         Chrome and Firefox give error objects the stack property and we wanted to match
360         that functionality. This allows developers to see the stack without throwing an object.
361
362         * runtime/ErrorInstance.cpp:
363         (JSC::ErrorInstance::finishCreation):
364          For error objects that are not thrown as an exception, we pass the stackTrace in 
365          as a parameter. This allows the error object to have the stack property.
366         
367         * interpreter/Interpreter.cpp:
368         (JSC::stackTraceAsString):
369         Helper function used to eliminate duplicate code.
370
371         (JSC::Interpreter::addStackTraceIfNecessary):
372         When an error object is created by the user the vm->exceptionStack is not set.
373         If the user throws this error object later the stack that is in the error object 
374         may not be the correct stack for the throw, so when we set the vm->exception stack,
375         the stack property on the error object is set as well.
376         
377         * runtime/ErrorConstructor.cpp:
378         (JSC::constructWithErrorConstructor):
379         (JSC::callErrorConstructor):
380         * runtime/NativeErrorConstructor.cpp:
381         (JSC::constructWithNativeErrorConstructor):
382         (JSC::callNativeErrorConstructor):
383         These functions indicate that the user created an error object. For all error objects 
384         that the user explicitly creates, the topCallFrame is at a new frame created to 
385         handle the user's call. In this case though, the error object needs the caller's 
386         frame to create the stack trace correctly.
387         
388         * interpreter/Interpreter.h:
389         * runtime/ErrorInstance.h:
390         (JSC::ErrorInstance::create):
391
392 2013-07-29  Gavin Barraclough  <barraclough@apple.com>
393
394         Some cleanup in PropertySlot
395         https://bugs.webkit.org/show_bug.cgi?id=119189
396
397         Reviewed by Geoff Garen.
398
399         PropertySlot represents a property in one of four states - value, getter, custom, or custom-index.
400         The state is currently tracked redundantly by two mechanisms - the custom getter function (m_getValue)
401         is set to a special value to indicate the type (other than custom), and the type is also tracked by
402         an enum - but only if cacheable. Cacheability can typically be determined by the value of m_offset
403         (this is invalidOffset if not cacheable).
404
405             * Internally, always track the type of the property using an enum value, PropertyType.
406             * Use m_offset to indicate cacheable.
407             * Keep the external interface (CachedPropertyType) unchanged.
408             * Better pack data into the m_data union.
409
410         Performance neutral.
411
412         * dfg/DFGRepatch.cpp:
413         (JSC::DFG::tryCacheGetByID):
414         (JSC::DFG::tryBuildGetByIDList):
415             - cachedPropertyType() -> isCacheable*()
416         * jit/JITPropertyAccess.cpp:
417         (JSC::JIT::privateCompileGetByIdProto):
418         (JSC::JIT::privateCompileGetByIdSelfList):
419         (JSC::JIT::privateCompileGetByIdProtoList):
420         (JSC::JIT::privateCompileGetByIdChainList):
421         (JSC::JIT::privateCompileGetByIdChain):
422             - cachedPropertyType() -> isCacheable*()
423         * jit/JITPropertyAccess32_64.cpp:
424         (JSC::JIT::privateCompileGetByIdProto):
425         (JSC::JIT::privateCompileGetByIdSelfList):
426         (JSC::JIT::privateCompileGetByIdProtoList):
427         (JSC::JIT::privateCompileGetByIdChainList):
428         (JSC::JIT::privateCompileGetByIdChain):
429             - cachedPropertyType() -> isCacheable*()
430         * jit/JITStubs.cpp:
431         (JSC::tryCacheGetByID):
432             - cachedPropertyType() -> isCacheable*()
433         * llint/LLIntSlowPaths.cpp:
434         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
435             - cachedPropertyType() -> isCacheable*()
436         * runtime/PropertySlot.cpp:
437         (JSC::PropertySlot::functionGetter):
438             - refactoring described above.
439         * runtime/PropertySlot.h:
440         (JSC::PropertySlot::PropertySlot):
441         (JSC::PropertySlot::getValue):
442         (JSC::PropertySlot::isCacheable):
443         (JSC::PropertySlot::isCacheableValue):
444         (JSC::PropertySlot::isCacheableGetter):
445         (JSC::PropertySlot::isCacheableCustom):
446         (JSC::PropertySlot::cachedOffset):
447         (JSC::PropertySlot::customGetter):
448         (JSC::PropertySlot::setValue):
449         (JSC::PropertySlot::setCustom):
450         (JSC::PropertySlot::setCacheableCustom):
451         (JSC::PropertySlot::setCustomIndex):
452         (JSC::PropertySlot::setGetterSlot):
453         (JSC::PropertySlot::setCacheableGetterSlot):
454         (JSC::PropertySlot::setUndefined):
455         (JSC::PropertySlot::slotBase):
456         (JSC::PropertySlot::setBase):
457             - refactoring described above.
458
459 2013-07-28  Oliver Hunt  <oliver@apple.com>
460
461         REGRESSION: Crash when opening Facebook.com
462         https://bugs.webkit.org/show_bug.cgi?id=119155
463
464         Reviewed by Andreas Kling.
465
466         Scope nodes are always objects, so we should be using SpecObjectOther
467         rather than SpecCellOther.  Marking Scopes as CellOther leads to a
468         contradiction in the CFA, resulting in bogus codegen.
469
470         * dfg/DFGAbstractInterpreterInlines.h:
471         (JSC::DFG::::executeEffects):
472         * dfg/DFGPredictionPropagationPhase.cpp:
473         (JSC::DFG::PredictionPropagationPhase::propagate):
474
475 2013-07-26  Oliver Hunt  <oliver@apple.com>
476
477         REGRESSION(FTL?): Crashes in plugin tests
478         https://bugs.webkit.org/show_bug.cgi?id=119141
479
480         Reviewed by Michael Saboff.
481
482         Re-export getStackTrace
483
484         * interpreter/Interpreter.h:
485
486 2013-07-26  Filip Pizlo  <fpizlo@apple.com>
487
488         REGRESSION: Crash when opening a message on Gmail
489         https://bugs.webkit.org/show_bug.cgi?id=119105
490
491         Reviewed by Oliver Hunt and Mark Hahnenberg.
492         
493         - GetById patching in the DFG needs to be more disciplined about how it derives the
494           slow path.
495         
496         - Fix some dumping code thread safety issues.
497
498         * bytecode/CallLinkStatus.cpp:
499         (JSC::CallLinkStatus::dump):
500         * bytecode/CodeBlock.cpp:
501         (JSC::CodeBlock::dumpBytecode):
502         * dfg/DFGRepatch.cpp:
503         (JSC::DFG::getPolymorphicStructureList):
504         (JSC::DFG::tryBuildGetByIDList):
505
506 2013-07-26  Balazs Kilvady  <kilvadyb@homejinni.com>
507
508         [mips] Fix LLINT build for mips backend
509         https://bugs.webkit.org/show_bug.cgi?id=119152
510
511         Reviewed by Oliver Hunt.
512
513         * offlineasm/mips.rb:
514
515 2013-07-19  Mark Hahnenberg  <mhahnenberg@apple.com>
516
517         Setting a large numeric property on an object causes it to allocate a huge backing store
518         https://bugs.webkit.org/show_bug.cgi?id=118914
519
520         Reviewed by Geoffrey Garen.
521
522         There are two distinct actions that we're trying to optimize for:
523
524         new Array(100000);
525
526         and:
527
528         a = [];
529         a[100000] = 42;
530         
531         In the first case, the programmer has indicated that they expect this Array to be very big, 
532         so they should get a contiguous array up until some threshold, above which we perform density 
533         calculations to see if it is indeed dense enough to warrant being contiguous.
534         
535         In the second case, the programmer hasn't indicated anything about the size of the Array, so 
536         we should be more conservative and assume it should be sparse until we've proven otherwise.
537         
538         Currently both of those cases are handled by MIN_SPARSE_ARRAY_INDEX. We should distinguish 
539         between them for the purposes of not over-allocating large backing stores like we see on 
540         http://www.peekanalytics.com/burgerjoints/
541         
542         The way that we'll do this is to keep the MIN_SPARSE_ARRAY_INDEX for the first case, and 
543         introduce a new heuristic for the second case. If we are putting to an index above a certain 
544         threshold (say, 1000) and it is beyond the length of the array, then we will use a sparse 
545         map instead. So for example, in the second case above the empty array has a blank indexing 
546         type and a length of 0. We put-by-val to an index > 1000 and > a.length, so we'll use a sparse map.
547
548         This fix is ~800x speedup on the accompanying regression test :-o
549
550         * runtime/ArrayConventions.h:
551         (JSC::indexIsSufficientlyBeyondLengthForSparseMap):
552         * runtime/JSObject.cpp:
553         (JSC::JSObject::putByIndexBeyondVectorLengthWithoutAttributes):
554         (JSC::JSObject::putByIndexBeyondVectorLengthWithArrayStorage):
555         (JSC::JSObject::putByIndexBeyondVectorLength):
556         (JSC::JSObject::putDirectIndexBeyondVectorLengthWithArrayStorage):
557
558 2013-07-26  Julien Brianceau  <jbrianceau@nds.com>
559
560         REGRESSION(FTL): Fix lots of crashes in sh4 baseline JIT.
561         https://bugs.webkit.org/show_bug.cgi?id=119148
562
563         Reviewed by Csaba Osztrogonác.
564
565         * jit/JSInterfaceJIT.h: "secondArgumentRegister" is wrong for sh4.
566         * llint/LowLevelInterpreter32_64.asm: "move t0, a0" is missing
567         in nativeCallTrampoline for sh4. Reuse MIPS implementation to avoid
568         code duplication.
569
570 2013-07-26  Julien Brianceau  <jbrianceau@nds.com>
571
572         REGRESSION(FTL): Crash in sh4 baseline JIT.
573         https://bugs.webkit.org/show_bug.cgi?id=119138
574
575         Reviewed by Csaba Osztrogonác.
576
577         This crash is due to incomplete report of r150146 and r148474.
578
579         * jit/JITStubsSH4.h:
580
581 2013-07-26  Zan Dobersek  <zdobersek@igalia.com>
582
583         Unreviewed.
584
585         * Target.pri: Adding missing DFG files to the Qt build.
586
587 2013-07-25  Csaba Osztrogonác  <ossy@webkit.org>
588
589         GTK and Qt buildfix after the intrusive win buildfix r153360.
590
591         * GNUmakefile.list.am:
592         * Target.pri:
593
594 2013-07-25  Gyuyoung Kim  <gyuyoung.kim@samsung.com>
595
596         Unreviewed, fix build break after r153360.
597
598         * CMakeLists.txt: Add CommonSlowPathsExceptions.cpp.
599
600 2013-07-25  Roger Fong  <roger_fong@apple.com>
601
602         Unreviewed build fix, AppleWin port.
603
604         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
605         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
606         * JavaScriptCore.vcxproj/copy-files.cmd:
607
608 2013-07-25  Roger Fong  <roger_fong@apple.com>
609
610         Unreviewed. Followup to r153360.
611
612         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
613         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
614
615 2013-07-25  Michael Saboff  <msaboff@apple.com>
616
617         [Windows] Speculative build fix.
618
619         Moved interpreterThrowInCaller() out of LLintExceptions.cpp into new CommonSlowPathsExceptions.cpp
620         that is always compiled.  Made LLInt::returnToThrow() conditional on LLINT being enabled.
621
622         * JavaScriptCore.xcodeproj/project.pbxproj:
623         * llint/LLIntExceptions.cpp:
624         * llint/LLIntExceptions.h:
625         * llint/LLIntSlowPaths.cpp:
626         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
627         * runtime/CommonSlowPaths.cpp:
628         (JSC::SLOW_PATH_DECL):
629         * runtime/CommonSlowPathsExceptions.cpp: Added.
630         (JSC::CommonSlowPaths::interpreterThrowInCaller):
631         * runtime/CommonSlowPathsExceptions.h: Added.
632
633 2013-07-25  Brent Fulgham  <bfulgham@apple.com>
634
635         [Windows] Unreviewed build fix.
636
637         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj: Add missing IntendedStructureChange.h,.cpp and
638         parser/SourceCode.h,.cpp.
639         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters: Ditto.
640
641 2013-07-25  Anders Carlsson  <andersca@apple.com>
642
643         ASSERT(m_vm->apiLock().currentThreadIsHoldingLock()); fails for Safari on current ToT
644         https://bugs.webkit.org/show_bug.cgi?id=119108
645
646         Reviewed by Mark Hahnenberg.
647
648         Add a currentThreadIsHoldingAPILock() function to VM that checks if the current thread is the exclusive API thread.
649
650         * heap/CopiedSpace.cpp:
651         (JSC::CopiedSpace::tryAllocateSlowCase):
652         * heap/Heap.cpp:
653         (JSC::Heap::protect):
654         (JSC::Heap::unprotect):
655         (JSC::Heap::collect):
656         * heap/MarkedAllocator.cpp:
657         (JSC::MarkedAllocator::allocateSlowCase):
658         * runtime/JSGlobalObject.cpp:
659         (JSC::JSGlobalObject::init):
660         * runtime/VM.h:
661         (JSC::VM::currentThreadIsHoldingAPILock):
662
663 2013-07-25  Zan Dobersek  <zdobersek@igalia.com>
664
665         REGRESSION(FTL): Most layout tests crashes
666         https://bugs.webkit.org/show_bug.cgi?id=119089
667
668         Reviewed by Oliver Hunt.
669
670         * runtime/ExecutionHarness.h:
671         (JSC::prepareForExecution): Move prepareForExecutionImpl call into its own statement. This prevents the GCC-compiled
672         code to create the PassOwnPtr<JSC::JITCode> (intended as a parameter to the installOptimizedCode call) from the jitCode
673         RefPtr<JSC::JITCode> parameter before the latter was actually given a proper value through the prepareForExecutionImpl call.
674         Currently it's created beforehand and therefor holds a null pointer before it's anchored as the JIT code in
675         JSC::CodeBlock::setJITCode, which later indirectly causes assertions in JSC::CodeBlock::jitCompile.
676         (JSC::prepareFunctionForExecution): Ditto for prepareFunctionForExecutionImpl.
677
678 2013-07-25  Brent Fulgham  <bfulgham@apple.com>
679
680         [Windows] Unreviewed build fix.
681
682         * JavaScriptCore.vcxproj/JavaScriptCoreCommon.props: Add missing 'ftl'
683         include path.
684
685 2013-07-25  Brent Fulgham  <bfulgham@apple.com>
686
687         [Windows] Unreviewed build fix.
688
689         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj: Add some missing files:
690         runtime/VM.h,.cpp; Remove deleted JSGlobalData.h,.cpp.
691         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters: Ditto.
692
693 2013-07-25  Oliver Hunt  <oliver@apple.com>
694
695         Make all jit & non-jit combos build cleanly
696         https://bugs.webkit.org/show_bug.cgi?id=119102
697
698         Reviewed by Anders Carlsson.
699
700         * bytecode/CodeBlock.cpp:
701         (JSC::CodeBlock::counterValueForOptimizeSoon):
702         * bytecode/CodeBlock.h:
703         (JSC::CodeBlock::optimizeAfterWarmUp):
704         (JSC::CodeBlock::numberOfDFGCompiles):
705
706 2013-07-25  Oliver Hunt  <oliver@apple.com>
707
708         32 bit portion of load validation logic
709         https://bugs.webkit.org/show_bug.cgi?id=118878
710
711         Reviewed by NOBODY (Build fix).
712
713         * dfg/DFGSpeculativeJIT32_64.cpp:
714         (JSC::DFG::SpeculativeJIT::compile):
715
716 2013-07-25  Oliver Hunt  <oliver@apple.com>
717
718         More 32bit build fixes
719
720         - Apparnetly some compilers don't track the fastcall directive everywhere we expect
721
722         * API/APICallbackFunction.h:
723         (JSC::APICallbackFunction::call):
724         * bytecode/CodeBlock.cpp:
725         * runtime/Structure.cpp:
726
727 2013-07-25  Yi Shen  <max.hong.shen@gmail.com>
728
729         Optimize the thread locks for API Shims
730         https://bugs.webkit.org/show_bug.cgi?id=118573
731
732         Reviewed by Geoffrey Garen.
733
734         Remove the thread lock from API Shims if the VM has an exclusive thread (e.g. the VM 
735         only used by WebCore's main thread).
736
737         * API/APIShims.h:
738         (JSC::APIEntryShim::APIEntryShim):
739         (JSC::APICallbackShim::APICallbackShim):
740         * runtime/JSLock.cpp:
741         (JSC::JSLockHolder::JSLockHolder):
742         (JSC::JSLockHolder::init):
743         (JSC::JSLockHolder::~JSLockHolder):
744         (JSC::JSLock::DropAllLocks::DropAllLocks):
745         (JSC::JSLock::DropAllLocks::~DropAllLocks):
746         * runtime/VM.cpp:
747         (JSC::VM::VM):
748         * runtime/VM.h:
749
750 2013-07-25  Christophe Dumez  <ch.dumez@sisa.samsung.com>
751
752         Unreviewed build fix after r153218.
753
754         Broke the EFL port build with gcc 4.7.
755
756         * interpreter/StackIterator.cpp:
757         (JSC::printif):
758
759 2013-07-25  Julien Brianceau  <jbrianceau@nds.com>
760
761         Build fix: add missing #include.
762         https://bugs.webkit.org/show_bug.cgi?id=119087
763
764         Reviewed by Allan Sandfeld Jensen.
765
766         * bytecode/ArrayProfile.cpp:
767
768 2013-07-25  Ryuan Choi  <ryuan.choi@samsung.com>
769
770         Unreviewed, build fix on the EFL port.
771
772         * CMakeLists.txt: Added JSCTestRunnerUtils.cpp.
773
774 2013-07-25  Julien Brianceau  <jbrianceau@nds.com>
775
776         [sh4] Add missing store8(TrustedImm32, void*) implementation in baseline JIT.
777         https://bugs.webkit.org/show_bug.cgi?id=119083
778
779         Reviewed by Allan Sandfeld Jensen.
780
781         * assembler/MacroAssemblerSH4.h:
782         (JSC::MacroAssemblerSH4::store8):
783
784 2013-07-25  Allan Sandfeld Jensen  <allan.jensen@digia.com>
785
786         [Qt] Fix test build after FTL upstream
787
788         Unreviewed build fix.
789
790         * Target.pri:
791
792 2013-07-25  Allan Sandfeld Jensen  <allan.jensen@digia.com>
793
794         [Qt] Build fix after FTL.
795
796         Un Reviewed build fix.
797
798         * Target.pri:
799         * interpreter/StackIterator.cpp:
800         (JSC::StackIterator::Frame::print):
801
802 2013-07-25  Gabor Rapcsanyi  <rgabor@webkit.org>
803
804         Unreviewed build fix after FTL upstream.
805
806         * dfg/DFGWorklist.cpp:
807         (JSC::DFG::Worklist::~Worklist):
808
809 2013-07-25  Ryuan Choi  <ryuan.choi@samsung.com>
810
811         Unreviewed, build fix on the EFL port.
812
813         * CMakeLists.txt:
814         Added SourceCode.cpp and removed BlackBerry file.
815         * jit/JITCode.h:
816         (JSC::JITCode::nextTierJIT):
817         Fixed to build break because of -Werror=return-type
818         * parser/Lexer.cpp: Includes JSFunctionInlines.h
819         * runtime/JSScope.h:
820         (JSC::makeType):
821         Fixed to build break because of -Werror=return-type
822
823 2013-07-25  Ádám Kallai  <kadam@inf.u-szeged.hu>
824
825         Unreviewed build fixing after FTL upstream.
826
827         * runtime/Executable.cpp:
828         (JSC::FunctionExecutable::produceCodeBlockFor):
829
830 2013-07-25  Julien Brianceau  <jbrianceau@nds.com>
831
832         Add missing implementation of bxxxnz in sh4 LLINT.
833         https://bugs.webkit.org/show_bug.cgi?id=119079
834
835         Reviewed by Allan Sandfeld Jensen.
836
837         * offlineasm/sh4.rb:
838
839 2013-07-25  Gabor Rapcsanyi  <rgabor@webkit.org>
840
841         Unreviewed, build fix on the Qt port.
842
843         * Target.pri: Add additional build files for the FTL.
844
845 2013-07-25  Ádám Kallai  <kadam@inf.u-szeged.hu>
846
847         Unreviewed buildfix after FTL upstream..
848
849         * interpreter/StackIterator.cpp:
850         (JSC::StackIterator::Frame::codeType):
851         (JSC::StackIterator::Frame::functionName):
852         (JSC::StackIterator::Frame::sourceURL):
853         (JSC::StackIterator::Frame::logicalFrame):
854
855 2013-07-25  Zan Dobersek  <zdobersek@igalia.com>
856
857         Unreviewed.
858
859         * heap/CopyVisitor.cpp: Include CopiedSpaceInlines header so the CopiedSpace::recycleEvacuatedBlock
860         method is not left undefined, causing build failures on (at least) the GTK port.
861
862 2013-07-25  Zan Dobersek  <zdobersek@igalia.com>
863
864         Unreviewed, further build fixing on the GTK port.
865
866         * GNUmakefile.list.am: Add CompilationResult source files to the build.
867
868 2013-07-25  Zan Dobersek  <zdobersek@igalia.com>
869
870         Unreviewed GTK build fixing.
871
872         * GNUmakefile.am: Make the shared libjsc library depend on any changes to the build target list.
873         * GNUmakefile.list.am: Add additional build targets for files that were introduced by the FTL branch merge.
874
875 2013-07-25  Csaba Osztrogonác  <ossy@webkit.org>
876
877         Buildfix after this error:
878         error: 'pathName' may be used uninitialized in this function [-Werror=uninitialized]
879
880         * dfg/DFGPlan.cpp:
881         (JSC::DFG::Plan::compileInThread):
882
883 2013-07-25  Csaba Osztrogonác  <ossy@webkit.org>
884
885         One more buildfix after FTL upstream.
886
887         Return a dummy value after RELEASE_ASSERT_NOT_REACHED() to make GCC happy.
888
889         * dfg/DFGLazyJSValue.cpp:
890         (JSC::DFG::LazyJSValue::getValue):
891         (JSC::DFG::LazyJSValue::strictEqual):
892
893 2013-07-25  Julien Brianceau  <jbrianceau@nds.com>
894
895         Fix "Unhandled opcode localAnnotation" build error in sh4 and mips LLINT.
896         https://bugs.webkit.org/show_bug.cgi?id=119076
897
898         Reviewed by Allan Sandfeld Jensen.
899
900         * offlineasm/mips.rb:
901         * offlineasm/sh4.rb:
902
903 2013-07-25  Zan Dobersek  <zdobersek@igalia.com>
904
905         Unreviewed GTK build fix.
906
907         * GNUmakefile.list.am: Adding JSCTestRunnerUtils files to the build.
908
909 2013-07-25  Zan Dobersek  <zdobersek@igalia.com>
910
911         Unreviewed. Further build fixing for the GTK port. Adding the forwarding header
912         for JSCTestRunnerUtils.h as required by the DumpRenderTree compilation.
913
914         * ForwardingHeaders/JavaScriptCore/JSCTestRunnerUtils.h: Added.
915
916 2013-07-25  Zan Dobersek  <zdobersek@igalia.com>
917
918         Unreviewed. Fixing the GTK build after the FTL merging by updating the build targets list.
919
920         * GNUmakefile.am:
921         * GNUmakefile.list.am:
922
923 2013-07-25  Ádám Kallai  <kadam@inf.u-szeged.hu>
924
925         Unreviewed buildfix after FTL upstream.
926
927         * runtime/JSScope.h:
928         (JSC::needsVarInjectionChecks):
929
930 2013-07-25  Csaba Osztrogonác  <ossy@webkit.org>
931
932         One more fix after FTL upstream.
933
934         * Target.pri:
935         * bytecode/CodeBlock.h:
936         * bytecode/GetByIdStatus.h:
937         (JSC::GetByIdStatus::GetByIdStatus):
938
939 2013-07-24  Csaba Osztrogonác  <ossy@webkit.org>
940
941         Unreviewed buildfix after FTL upstream.
942
943         Add ftl directory as include path.
944
945         * CMakeLists.txt:
946         * JavaScriptCore.pri:
947
948 2013-07-24  Csaba Osztrogonác  <ossy@webkit.org>
949
950         Unreviewed buildfix after FTL upstream for non C++11 builds.
951
952         * interpreter/CallFrame.h:
953         * interpreter/StackIteratorPrivate.h:
954         (JSC::StackIterator::end):
955
956 2013-07-24  Oliver Hunt  <oliver@apple.com>
957
958         Endeavour to fix CMakelist builds
959
960         * CMakeLists.txt:
961
962 2013-07-24  Filip Pizlo  <fpizlo@apple.com>
963
964         fourthTier: DFG IR dumps should be easier to read
965         https://bugs.webkit.org/show_bug.cgi?id=119050
966
967         Reviewed by Mark Hahnenberg.
968         
969         Added a DumpContext that includes support for printing an endnote
970         that describes all structures in full, while the main flow of the
971         dump just uses made-up names for the structures. This is helpful
972         since Structure::dump() may print a lot. The stuff it prints is
973         useful, but if it's all inline with the surrounding thing you're        
974         dumping (often, a node in the DFG), then you get a ridiculously
975         long print-out. All classes that dump structures (including
976         Structure itself) now have dumpInContext() methods that use
977         inContext() for dumping anything that might transitively print a
978         structure. If Structure::dumpInContext() is called with a NULL
979         context, it just uses dump() like before. Hence you don't have to
980         know anything about DumpContext unless you want to.
981         
982         inContext(*structure, context) dumps something like %B4:Array,
983         and the endnote will have something like:
984         
985             %B4:Array    = 0x10e91a180:[Array, {Edge:100, Normal:101, Line:102, NumPx:103, LastPx:104}, ArrayWithContiguous, Proto:0x10e99ffe0]
986         
987         where B4 is the inferred name that StringHashDumpContext came up
988         with.
989         
990         Also shortened a bunch of other dumps, removing information that
991         isn't so important.
992         
993         * JavaScriptCore.xcodeproj/project.pbxproj:
994         * bytecode/ArrayProfile.cpp:
995         (JSC::dumpArrayModes):
996         * bytecode/CodeBlockHash.cpp:
997         (JSC):
998         (JSC::CodeBlockHash::CodeBlockHash):
999         (JSC::CodeBlockHash::dump):
1000         * bytecode/CodeOrigin.cpp:
1001         (JSC::CodeOrigin::dumpInContext):
1002         (JSC):
1003         (JSC::InlineCallFrame::dumpInContext):
1004         (JSC::InlineCallFrame::dump):
1005         * bytecode/CodeOrigin.h:
1006         (CodeOrigin):
1007         (InlineCallFrame):
1008         * bytecode/Operands.h:
1009         (JSC::OperandValueTraits::isEmptyForDump):
1010         (Operands):
1011         (JSC::Operands::dump):
1012         (JSC):
1013         * bytecode/OperandsInlines.h: Added.
1014         (JSC):
1015         (JSC::::dumpInContext):
1016         * bytecode/StructureSet.h:
1017         (JSC::StructureSet::dumpInContext):
1018         (JSC::StructureSet::dump):
1019         (StructureSet):
1020         * dfg/DFGAbstractValue.cpp:
1021         (JSC::DFG::AbstractValue::dump):
1022         (DFG):
1023         (JSC::DFG::AbstractValue::dumpInContext):
1024         * dfg/DFGAbstractValue.h:
1025         (JSC::DFG::AbstractValue::operator!):
1026         (AbstractValue):
1027         * dfg/DFGCFAPhase.cpp:
1028         (JSC::DFG::CFAPhase::performBlockCFA):
1029         * dfg/DFGCommon.cpp:
1030         * dfg/DFGCommon.h:
1031         (JSC::DFG::NodePointerTraits::isEmptyForDump):
1032         * dfg/DFGDisassembler.cpp:
1033         (JSC::DFG::Disassembler::createDumpList):
1034         * dfg/DFGDisassembler.h:
1035         (Disassembler):
1036         * dfg/DFGFlushFormat.h:
1037         (WTF::inContext):
1038         (WTF):
1039         * dfg/DFGFlushLivenessAnalysisPhase.cpp:
1040         * dfg/DFGGraph.cpp:
1041         (JSC::DFG::Graph::dumpCodeOrigin):
1042         (JSC::DFG::Graph::dump):
1043         (JSC::DFG::Graph::dumpBlockHeader):
1044         * dfg/DFGGraph.h:
1045         (Graph):
1046         * dfg/DFGLazyJSValue.cpp:
1047         (JSC::DFG::LazyJSValue::dumpInContext):
1048         (JSC::DFG::LazyJSValue::dump):
1049         (DFG):
1050         * dfg/DFGLazyJSValue.h:
1051         (LazyJSValue):
1052         * dfg/DFGNode.h:
1053         (JSC::DFG::nodeMapDump):
1054         (WTF::inContext):
1055         (WTF):
1056         * dfg/DFGOSRExitCompiler32_64.cpp:
1057         (JSC::DFG::OSRExitCompiler::compileExit):
1058         * dfg/DFGOSRExitCompiler64.cpp:
1059         (JSC::DFG::OSRExitCompiler::compileExit):
1060         * dfg/DFGStructureAbstractValue.h:
1061         (JSC::DFG::StructureAbstractValue::dumpInContext):
1062         (JSC::DFG::StructureAbstractValue::dump):
1063         (StructureAbstractValue):
1064         * ftl/FTLExitValue.cpp:
1065         (JSC::FTL::ExitValue::dumpInContext):
1066         (JSC::FTL::ExitValue::dump):
1067         (FTL):
1068         * ftl/FTLExitValue.h:
1069         (ExitValue):
1070         * ftl/FTLLowerDFGToLLVM.cpp:
1071         * ftl/FTLValueSource.cpp:
1072         (JSC::FTL::ValueSource::dumpInContext):
1073         (FTL):
1074         * ftl/FTLValueSource.h:
1075         (ValueSource):
1076         * runtime/DumpContext.cpp: Added.
1077         (JSC):
1078         (JSC::DumpContext::DumpContext):
1079         (JSC::DumpContext::~DumpContext):
1080         (JSC::DumpContext::isEmpty):
1081         (JSC::DumpContext::dump):
1082         * runtime/DumpContext.h: Added.
1083         (JSC):
1084         (DumpContext):
1085         * runtime/JSCJSValue.cpp:
1086         (JSC::JSValue::dump):
1087         (JSC):
1088         (JSC::JSValue::dumpInContext):
1089         * runtime/JSCJSValue.h:
1090         (JSC):
1091         (JSValue):
1092         * runtime/Structure.cpp:
1093         (JSC::Structure::dumpInContext):
1094         (JSC):
1095         (JSC::Structure::dumpBrief):
1096         (JSC::Structure::dumpContextHeader):
1097         * runtime/Structure.h:
1098         (JSC):
1099         (Structure):
1100
1101 2013-07-22  Filip Pizlo  <fpizlo@apple.com>
1102
1103         fourthTier: DFG should do a high-level LICM before going to FTL
1104         https://bugs.webkit.org/show_bug.cgi?id=118749
1105
1106         Reviewed by Oliver Hunt.
1107         
1108         Implements LICM hoisting for nodes that never write anything and never read
1109         things that are clobbered by the loop. There are some other preconditions for
1110         hoisting, see DFGLICMPhase.cpp.
1111
1112         Also did a few fixes:
1113         
1114         - ClobberSet::add was failing to switch Super entries to Direct entries in
1115           some cases.
1116         
1117         - DFGClobberize.cpp needed to #include "Operations.h".
1118         
1119         - DCEPhase needs to process the graph in reverse DFS order, when we're in SSA.
1120         
1121         - AbstractInterpreter can now execute a Node without knowing its indexInBlock.
1122           Knowing the indexInBlock is an optional optimization that all other clients
1123           of AI still opt into, but LICM doesn't.
1124         
1125         This makes the FTL a 2.19x speed-up on imaging-gaussian-blur.
1126
1127         * JavaScriptCore.xcodeproj/project.pbxproj:
1128         * dfg/DFGAbstractInterpreter.h:
1129         (AbstractInterpreter):
1130         * dfg/DFGAbstractInterpreterInlines.h:
1131         (JSC::DFG::::executeEffects):
1132         (JSC::DFG::::execute):
1133         (DFG):
1134         (JSC::DFG::::clobberWorld):
1135         (JSC::DFG::::clobberStructures):
1136         * dfg/DFGAtTailAbstractState.cpp: Added.
1137         (DFG):
1138         (JSC::DFG::AtTailAbstractState::AtTailAbstractState):
1139         (JSC::DFG::AtTailAbstractState::~AtTailAbstractState):
1140         (JSC::DFG::AtTailAbstractState::createValueForNode):
1141         (JSC::DFG::AtTailAbstractState::forNode):
1142         * dfg/DFGAtTailAbstractState.h: Added.
1143         (DFG):
1144         (AtTailAbstractState):
1145         (JSC::DFG::AtTailAbstractState::initializeTo):
1146         (JSC::DFG::AtTailAbstractState::forNode):
1147         (JSC::DFG::AtTailAbstractState::variables):
1148         (JSC::DFG::AtTailAbstractState::block):
1149         (JSC::DFG::AtTailAbstractState::isValid):
1150         (JSC::DFG::AtTailAbstractState::setDidClobber):
1151         (JSC::DFG::AtTailAbstractState::setIsValid):
1152         (JSC::DFG::AtTailAbstractState::setBranchDirection):
1153         (JSC::DFG::AtTailAbstractState::setFoundConstants):
1154         (JSC::DFG::AtTailAbstractState::haveStructures):
1155         (JSC::DFG::AtTailAbstractState::setHaveStructures):
1156         * dfg/DFGBasicBlock.h:
1157         (JSC::DFG::BasicBlock::insertBeforeLast):
1158         * dfg/DFGBasicBlockInlines.h:
1159         (DFG):
1160         * dfg/DFGClobberSet.cpp:
1161         (JSC::DFG::ClobberSet::add):
1162         (JSC::DFG::ClobberSet::addAll):
1163         * dfg/DFGClobberize.cpp:
1164         (JSC::DFG::doesWrites):
1165         * dfg/DFGClobberize.h:
1166         (DFG):
1167         * dfg/DFGDCEPhase.cpp:
1168         (JSC::DFG::DCEPhase::DCEPhase):
1169         (JSC::DFG::DCEPhase::run):
1170         (JSC::DFG::DCEPhase::fixupBlock):
1171         (DCEPhase):
1172         * dfg/DFGEdgeDominates.h: Added.
1173         (DFG):
1174         (EdgeDominates):
1175         (JSC::DFG::EdgeDominates::EdgeDominates):
1176         (JSC::DFG::EdgeDominates::operator()):
1177         (JSC::DFG::EdgeDominates::result):
1178         (JSC::DFG::edgesDominate):
1179         * dfg/DFGFixupPhase.cpp:
1180         (JSC::DFG::FixupPhase::fixupNode):
1181         (JSC::DFG::FixupPhase::checkArray):
1182         * dfg/DFGLICMPhase.cpp: Added.
1183         (LICMPhase):
1184         (JSC::DFG::LICMPhase::LICMPhase):
1185         (JSC::DFG::LICMPhase::run):
1186         (JSC::DFG::LICMPhase::attemptHoist):
1187         (DFG):
1188         (JSC::DFG::performLICM):
1189         * dfg/DFGLICMPhase.h: Added.
1190         (DFG):
1191         * dfg/DFGPlan.cpp:
1192         (JSC::DFG::Plan::compileInThreadImpl):
1193
1194 2013-07-21  Filip Pizlo  <fpizlo@apple.com>
1195
1196         fourthTier: DFG Nodes should be able to abstractly tell you what they read and what they write
1197         https://bugs.webkit.org/show_bug.cgi?id=118910
1198
1199         Reviewed by Sam Weinig.
1200         
1201         Add the notion of AbstractHeap to the DFG. This is analogous to the AbstractHeap in
1202         the FTL, except that the FTL's AbstractHeaps are used during LLVM lowering and are
1203         engineered to obey LLVM TBAA logic. The FTL's AbstractHeaps are also engineered to
1204         be inexpensive to use (they just give you a TBAA node) but expensive to create (you
1205         create them all up front). FTL AbstractHeaps also don't actually give you the
1206         ability to reason about aliasing; they are *just* a mechanism for lowering to TBAA.
1207         The DFG's AbstractHeaps are engineered to be both cheap to create and cheap to use.
1208         They also give you aliasing machinery. The DFG AbstractHeaps are represented
1209         internally by a int64_t. Many comparisons between them are just integer comaprisons.
1210         AbstractHeaps form a three-level hierarchy (World is the supertype of everything,
1211         Kind with a TOP payload is a direct subtype of World, and Kind with a non-TOP
1212         payload is the direct subtype of its corresponding TOP Kind).
1213         
1214         Add the notion of a ClobberSet. This is the set of AbstractHeaps that you had
1215         clobbered. It represents the set that results from unifying a bunch of
1216         AbstractHeaps, and is intended to quickly answer overlap questions: does the given
1217         AbstractHeap overlap any AbstractHeap in the ClobberSet? To this end, if you add an
1218         AbstractHeap to a set, it "directly" adds the heap itself, and "super" adds all of
1219         its ancestors. An AbstractHeap is said to overlap a set if any direct or super
1220         member is equal to it, or if any of its ancestors are equal to a direct member.
1221         
1222         Example #1:
1223         
1224             - I add Variables(5). I.e. Variables is the Kind and 5 is the payload. This
1225               is a subtype of Variables, which is a subtype of World.
1226             - You query Variables. I.e. Variables with a TOP payload, which is the
1227               supertype of Variables(X) for any X, and a subtype of World.
1228             
1229             The set will have Variables(5) as a direct member, and Variables and World as
1230             super members. The Variables query will immediately return true, because
1231             Variables is indeed a super member.
1232         
1233         Example #2:
1234         
1235             - I add Variables(5)
1236             - You query NamedProperties
1237             
1238             NamedProperties is not a member at all (neither direct or super). We next
1239             query World. World is a member, but it's a super member, so we return false.
1240         
1241         Example #3:
1242         
1243             - I add Variables
1244             - You query Variables(5)
1245             
1246             The set will have Variables as a direct member, and World as a super member.
1247             The Variables(5) query will not find Variables(5) in the set, but then it
1248             will query Variables. Variables is a direct member, so we return true.
1249         
1250         Example #4:
1251         
1252             - I add Variables
1253             - You query NamedProperties(5)
1254             
1255             Neither NamedProperties nor NamedProperties(5) are members. We next query
1256             World. World is a member, but it's a super member, so we return false.
1257         
1258         Overlap queries require that either the heap being queried is in the set (either
1259         direct or super), or that one of its ancestors is a direct member. Another way to
1260         think about how this works is that two heaps A and B are said to overlap if
1261         A.isSubtypeOf(B) or B.isSubtypeOf(A). This is sound since heaps form a
1262         single-inheritance heirarchy. Consider that we wanted to implement a set that holds
1263         heaps and answers the question, "is any member in the set an ancestor (i.e.
1264         supertype) of some other heap". We would have the set contain the heaps themselves,
1265         and we would satisfy the query "A.isSubtypeOfAny(set)" by walking the ancestor
1266         chain of A, and repeatedly querying its membership in the set. This is what the
1267         "direct" members of our set do. Now consider the other part, where we want to ask if
1268         any member of the set is a descendent of a heap, or "A.isSupertypeOfAny(set)". We
1269         would implement this by implementing set.add(B) as adding not just B but also all of
1270         B's ancestors; then we would answer A.isSupertypeOfAny(set) by just checking if A is
1271         in the set. With two such sets - one that answers isSubtypeOfAny() and another that
1272         answers isSupertypeOfAny() - we could answer the "do any of my heaps overlap your
1273         heap" question. ClobberSet does this, but combines the two sets into a single
1274         HashMap. The HashMap's value, "direct", means that the key is a member of both the
1275         supertype set and the subtype set; if it's false then it's only a member of one of
1276         them.
1277         
1278         Finally, this adds a functorized clobberize() method that adds the read and write
1279         clobbers of a DFG::Node to read and write functors. Common functors for adding to
1280         ClobberSets, querying overlap, and doing nothing are provided. Convenient wrappers
1281         are also provided. This allows you to say things like:
1282         
1283             ClobberSet set;
1284             addWrites(graph, node1, set);
1285             if (readsOverlap(graph, node2, set))
1286                 // We know that node1 may write to something that node2 may read from.
1287         
1288         Currently this facility is only used to improve graph dumping, but it will be
1289         instrumental in both LICM and GVN. In the future, I want to completely kill the
1290         NodeClobbersWorld and NodeMightClobber flags, and eradicate CSEPhase's hackish way
1291         of accomplishing almost exactly what AbstractHeap gives you.
1292
1293         * JavaScriptCore.xcodeproj/project.pbxproj:
1294         * dfg/DFGAbstractHeap.cpp: Added.
1295         (DFG):
1296         (JSC::DFG::AbstractHeap::Payload::dump):
1297         (JSC::DFG::AbstractHeap::dump):
1298         (WTF):
1299         (WTF::printInternal):
1300         * dfg/DFGAbstractHeap.h: Added.
1301         (DFG):
1302         (AbstractHeap):
1303         (Payload):
1304         (JSC::DFG::AbstractHeap::Payload::Payload):
1305         (JSC::DFG::AbstractHeap::Payload::top):
1306         (JSC::DFG::AbstractHeap::Payload::isTop):
1307         (JSC::DFG::AbstractHeap::Payload::value):
1308         (JSC::DFG::AbstractHeap::Payload::valueImpl):
1309         (JSC::DFG::AbstractHeap::Payload::operator==):
1310         (JSC::DFG::AbstractHeap::Payload::operator!=):
1311         (JSC::DFG::AbstractHeap::Payload::operator<):
1312         (JSC::DFG::AbstractHeap::Payload::isDisjoint):
1313         (JSC::DFG::AbstractHeap::Payload::overlaps):
1314         (JSC::DFG::AbstractHeap::AbstractHeap):
1315         (JSC::DFG::AbstractHeap::operator!):
1316         (JSC::DFG::AbstractHeap::kind):
1317         (JSC::DFG::AbstractHeap::payload):
1318         (JSC::DFG::AbstractHeap::isDisjoint):
1319         (JSC::DFG::AbstractHeap::overlaps):
1320         (JSC::DFG::AbstractHeap::supertype):
1321         (JSC::DFG::AbstractHeap::hash):
1322         (JSC::DFG::AbstractHeap::operator==):
1323         (JSC::DFG::AbstractHeap::operator!=):
1324         (JSC::DFG::AbstractHeap::operator<):
1325         (JSC::DFG::AbstractHeap::isHashTableDeletedValue):
1326         (JSC::DFG::AbstractHeap::payloadImpl):
1327         (JSC::DFG::AbstractHeap::encode):
1328         (JSC::DFG::AbstractHeapHash::hash):
1329         (JSC::DFG::AbstractHeapHash::equal):
1330         (AbstractHeapHash):
1331         (WTF):
1332         * dfg/DFGClobberSet.cpp: Added.
1333         (DFG):
1334         (JSC::DFG::ClobberSet::ClobberSet):
1335         (JSC::DFG::ClobberSet::~ClobberSet):
1336         (JSC::DFG::ClobberSet::add):
1337         (JSC::DFG::ClobberSet::addAll):
1338         (JSC::DFG::ClobberSet::contains):
1339         (JSC::DFG::ClobberSet::overlaps):
1340         (JSC::DFG::ClobberSet::clear):
1341         (JSC::DFG::ClobberSet::direct):
1342         (JSC::DFG::ClobberSet::super):
1343         (JSC::DFG::ClobberSet::dump):
1344         (JSC::DFG::ClobberSet::setOf):
1345         (JSC::DFG::addReads):
1346         (JSC::DFG::addWrites):
1347         (JSC::DFG::addReadsAndWrites):
1348         (JSC::DFG::readsOverlap):
1349         (JSC::DFG::writesOverlap):
1350         * dfg/DFGClobberSet.h: Added.
1351         (DFG):
1352         (ClobberSet):
1353         (JSC::DFG::ClobberSet::isEmpty):
1354         (ClobberSetAdd):
1355         (JSC::DFG::ClobberSetAdd::ClobberSetAdd):
1356         (JSC::DFG::ClobberSetAdd::operator()):
1357         (ClobberSetOverlaps):
1358         (JSC::DFG::ClobberSetOverlaps::ClobberSetOverlaps):
1359         (JSC::DFG::ClobberSetOverlaps::operator()):
1360         (JSC::DFG::ClobberSetOverlaps::result):
1361         * dfg/DFGClobberize.cpp: Added.
1362         (DFG):
1363         (JSC::DFG::didWrites):
1364         * dfg/DFGClobberize.h: Added.
1365         (DFG):
1366         (JSC::DFG::clobberize):
1367         (NoOpClobberize):
1368         (JSC::DFG::NoOpClobberize::NoOpClobberize):
1369         (JSC::DFG::NoOpClobberize::operator()):
1370         (CheckClobberize):
1371         (JSC::DFG::CheckClobberize::CheckClobberize):
1372         (JSC::DFG::CheckClobberize::operator()):
1373         (JSC::DFG::CheckClobberize::result):
1374         * dfg/DFGGraph.cpp:
1375         (JSC::DFG::Graph::dump):
1376
1377 2013-07-21  Filip Pizlo  <fpizlo@apple.com>
1378
1379         fourthTier: It should be easy to figure out which blocks nodes belong to
1380         https://bugs.webkit.org/show_bug.cgi?id=118957
1381
1382         Reviewed by Sam Weinig.
1383
1384         * dfg/DFGGraph.cpp:
1385         (DFG):
1386         (JSC::DFG::Graph::initializeNodeOwners):
1387         * dfg/DFGGraph.h:
1388         (Graph):
1389         * dfg/DFGNode.h:
1390
1391 2013-07-21  Filip Pizlo  <fpizlo@apple.com>
1392
1393         fourthTier: NodeExitsForward shouldn't be duplicated in NodeType
1394         https://bugs.webkit.org/show_bug.cgi?id=118956
1395
1396         Reviewed by Sam Weinig.
1397         
1398         We had two way of expressing that something exits forward: the NodeExitsForward
1399         flag and the word 'Forward' in the NodeType. That's kind of dumb. This patch
1400         makes it just be a flag.
1401
1402         * dfg/DFGAbstractInterpreterInlines.h:
1403         (JSC::DFG::::executeEffects):
1404         * dfg/DFGArgumentsSimplificationPhase.cpp:
1405         (JSC::DFG::ArgumentsSimplificationPhase::run):
1406         * dfg/DFGCSEPhase.cpp:
1407         (JSC::DFG::CSEPhase::int32ToDoubleCSE):
1408         (JSC::DFG::CSEPhase::checkStructureElimination):
1409         (JSC::DFG::CSEPhase::structureTransitionWatchpointElimination):
1410         (JSC::DFG::CSEPhase::putStructureStoreElimination):
1411         (JSC::DFG::CSEPhase::checkArrayElimination):
1412         (JSC::DFG::CSEPhase::performNodeCSE):
1413         * dfg/DFGConstantFoldingPhase.cpp:
1414         (JSC::DFG::ConstantFoldingPhase::foldConstants):
1415         * dfg/DFGFixupPhase.cpp:
1416         (JSC::DFG::FixupPhase::fixupNode):
1417         (JSC::DFG::FixupPhase::injectInt32ToDoubleNode):
1418         * dfg/DFGMinifiedNode.h:
1419         (JSC::DFG::belongsInMinifiedGraph):
1420         (JSC::DFG::MinifiedNode::hasChild):
1421         * dfg/DFGNode.h:
1422         (JSC::DFG::Node::convertToStructureTransitionWatchpoint):
1423         (JSC::DFG::Node::hasStructureSet):
1424         (JSC::DFG::Node::hasStructure):
1425         (JSC::DFG::Node::hasArrayMode):
1426         (JSC::DFG::Node::willHaveCodeGenOrOSR):
1427         * dfg/DFGNodeType.h:
1428         (DFG):
1429         (JSC::DFG::needsOSRForwardRewiring):
1430         * dfg/DFGPredictionPropagationPhase.cpp:
1431         (JSC::DFG::PredictionPropagationPhase::propagate):
1432         * dfg/DFGSafeToExecute.h:
1433         (JSC::DFG::safeToExecute):
1434         * dfg/DFGSpeculativeJIT.cpp:
1435         (JSC::DFG::SpeculativeJIT::compileInt32ToDouble):
1436         * dfg/DFGSpeculativeJIT32_64.cpp:
1437         (JSC::DFG::SpeculativeJIT::compile):
1438         * dfg/DFGSpeculativeJIT64.cpp:
1439         (JSC::DFG::SpeculativeJIT::compile):
1440         * dfg/DFGTypeCheckHoistingPhase.cpp:
1441         (JSC::DFG::TypeCheckHoistingPhase::run):
1442         (JSC::DFG::TypeCheckHoistingPhase::identifyRedundantStructureChecks):
1443         (JSC::DFG::TypeCheckHoistingPhase::identifyRedundantArrayChecks):
1444         * dfg/DFGVariableEventStream.cpp:
1445         (JSC::DFG::VariableEventStream::reconstruct):
1446         * ftl/FTLCapabilities.cpp:
1447         (JSC::FTL::canCompile):
1448         * ftl/FTLLowerDFGToLLVM.cpp:
1449         (JSC::FTL::LowerDFGToLLVM::compileNode):
1450         (JSC::FTL::LowerDFGToLLVM::addExitArgumentForNode):
1451
1452 2013-07-21  Filip Pizlo  <fpizlo@apple.com>
1453
1454         fourthTier: It should be possible for a DFG::Node to claim to exit to one CodeOrigin, but then claim that it belongs to a different CodeOrigin for all other purposes
1455         https://bugs.webkit.org/show_bug.cgi?id=118946
1456
1457         Reviewed by Geoffrey Garen.
1458         
1459         We want to decouple the exit target code origin of a node from the code origin
1460         for all other purposes. The purposes of code origins are:
1461         
1462         - Where the node will exit, if it exits. The exit target should be consistent with
1463           the surrounding nodes, in that if you just looked at the code origins of nodes in
1464           the graph, they would be consistent with the code origins in bytecode. This is
1465           necessary for live-at-bytecode analyses to work, and to preserve the original
1466           bytecode semantics when exiting.
1467         
1468         - What kind of code the node came from, for semantics thingies. For example, we
1469           might use the code origin to find the node's global object for doing an original
1470           array check. Or we might use it to determine if the code is in strict mode. Or
1471           other similar things. When we use the code origin in this way, we're basically
1472           using it as a way of describing the node's meta-data without putting it into the
1473           node directly, to save space. In the absurd extreme you could imagine nodes not
1474           even having NodeTypes or NodeFlags, and just using the CodeOrigin to determine
1475           what bytecode the node originated from. We won't do that, but you can think of
1476           this use of code origins as just a way of compressing meta-data.
1477         
1478         - What code origin we should supply profiling to, if we exit. This is closely
1479           related to the semantics thingies, in that the exit profiling is a persistent
1480           kind of semantic meta-data that survives between recompiles, and the only way to
1481           do that is to ascribe it to the original bytecode via the code origin.
1482         
1483         If we hoist a node, we need to change the exit target code origin, but we must not
1484         change the code origin for other purposes. The best way to do this is to decouple
1485         the two kinds of code origin.
1486         
1487         OSR exit data structures already do this, because they may edit the exit target
1488         code origin while keeping the code origin for profiling intact. This happens for
1489         forward exits. So, we just need to thread separation all the way back to DFG::Node.
1490         That's what this patch does.
1491
1492         * dfg/DFGNode.h:
1493         (JSC::DFG::Node::Node):
1494         (Node):
1495         * dfg/DFGOSRExit.cpp:
1496         (JSC::DFG::OSRExit::OSRExit):
1497         * dfg/DFGOSRExitBase.h:
1498         (JSC::DFG::OSRExitBase::OSRExitBase):
1499         * dfg/DFGSpeculativeJIT.cpp:
1500         (JSC::DFG::SpeculativeJIT::compileCurrentBlock):
1501         (JSC::DFG::SpeculativeJIT::checkArgumentTypes):
1502         * dfg/DFGSpeculativeJIT.h:
1503         (SpeculativeJIT):
1504         * ftl/FTLLowerDFGToLLVM.cpp:
1505         (JSC::FTL::LowerDFGToLLVM::compileNode):
1506         (JSC::FTL::LowerDFGToLLVM::appendOSRExit):
1507         (LowerDFGToLLVM):
1508         * ftl/FTLOSRExit.cpp:
1509         (JSC::FTL::OSRExit::OSRExit):
1510         * ftl/FTLOSRExit.h:
1511         (OSRExit):
1512
1513 2013-07-20  Filip Pizlo  <fpizlo@apple.com>
1514
1515         fourthTier: each DFG node that relies on other nodes to do their type checks should be able to tell you if those type checks happened
1516         https://bugs.webkit.org/show_bug.cgi?id=118866
1517
1518         Reviewed by Sam Weinig.
1519         
1520         Adds a safeToExecute() method that takes a node and an abstract state and tells you
1521         if the node will run without crashing under that state.
1522
1523         * JavaScriptCore.xcodeproj/project.pbxproj:
1524         * bytecode/CodeBlock.cpp:
1525         (JSC::CodeBlock::CodeBlock):
1526         * dfg/DFGCFAPhase.cpp:
1527         (CFAPhase):
1528         (JSC::DFG::CFAPhase::CFAPhase):
1529         (JSC::DFG::CFAPhase::run):
1530         (JSC::DFG::CFAPhase::performBlockCFA):
1531         (JSC::DFG::CFAPhase::performForwardCFA):
1532         * dfg/DFGSafeToExecute.h: Added.
1533         (DFG):
1534         (SafeToExecuteEdge):
1535         (JSC::DFG::SafeToExecuteEdge::SafeToExecuteEdge):
1536         (JSC::DFG::SafeToExecuteEdge::operator()):
1537         (JSC::DFG::SafeToExecuteEdge::result):
1538         (JSC::DFG::safeToExecute):
1539         * dfg/DFGStructureAbstractValue.h:
1540         (JSC::DFG::StructureAbstractValue::isValidOffset):
1541         (StructureAbstractValue):
1542         * runtime/Options.h:
1543         (JSC):
1544
1545 2013-07-20  Filip Pizlo  <fpizlo@apple.com>
1546
1547         fourthTier: FTL should be able to generate LLVM IR that uses an intrinsic for OSR exit
1548         https://bugs.webkit.org/show_bug.cgi?id=118948
1549
1550         Reviewed by Sam Weinig.
1551         
1552         - Add the ability to generate LLVM IR but then not use it, via --llvmAlwaysFails=true.
1553           This allows doing "what if" experiments with IR generation, even if the generated IR
1554           can't yet execute.
1555         
1556         - Add an OSR exit path that just calls an intrinsic that combines the branch and the
1557           off-ramp.
1558
1559         * JavaScriptCore.xcodeproj/project.pbxproj:
1560         * dfg/DFGPlan.cpp:
1561         (JSC::DFG::Plan::compileInThreadImpl):
1562         * ftl/FTLFail.cpp: Added.
1563         (FTL):
1564         (JSC::FTL::fail):
1565         * ftl/FTLFail.h: Added.
1566         (FTL):
1567         * ftl/FTLIntrinsicRepository.h:
1568         (FTL):
1569         * ftl/FTLLowerDFGToLLVM.cpp:
1570         (JSC::FTL::LowerDFGToLLVM::appendOSRExit):
1571         (JSC::FTL::LowerDFGToLLVM::emitOSRExitCall):
1572         * runtime/Options.h:
1573         (JSC):
1574
1575 2013-07-19  Filip Pizlo  <fpizlo@apple.com>
1576
1577         fourthTier: StringObjectUse uses structures, and CSE should know that
1578         https://bugs.webkit.org/show_bug.cgi?id=118940
1579
1580         Reviewed by Geoffrey Garen.
1581         
1582         This is asymptomatic right now, but we should fix it.
1583
1584         * JavaScriptCore.xcodeproj/project.pbxproj:
1585         * dfg/DFGCSEPhase.cpp:
1586         (JSC::DFG::CSEPhase::putStructureStoreElimination):
1587         * dfg/DFGEdgeUsesStructure.h: Added.
1588         (DFG):
1589         (EdgeUsesStructure):
1590         (JSC::DFG::EdgeUsesStructure::EdgeUsesStructure):
1591         (JSC::DFG::EdgeUsesStructure::operator()):
1592         (JSC::DFG::EdgeUsesStructure::result):
1593         (JSC::DFG::edgesUseStructure):
1594         * dfg/DFGUseKind.h:
1595         (DFG):
1596         (JSC::DFG::usesStructure):
1597
1598 2013-07-19  Filip Pizlo  <fpizlo@apple.com>
1599
1600         fourthTier: String GetByVal out-of-bounds handling is so wrong
1601         https://bugs.webkit.org/show_bug.cgi?id=118935
1602
1603         Reviewed by Geoffrey Garen.
1604         
1605         Bunch of String GetByVal out-of-bounds fixes:
1606         
1607         - Even if the string proto chain is sane, we need to watch out for negative
1608           indices. They may get values or call getters in the prototypes, since proto
1609           sanity doesn't check for negative indexed properties, as they are not
1610           technically indexed properties.
1611         
1612         - GetByVal String out-of-bounds does in fact clobberWorld(). CSE should be
1613           given this information.
1614         
1615         - GetByVal String out-of-bounds does in fact clobberWorld(). CFA should be
1616           given this information.
1617         
1618         Also fixed some other things:
1619         
1620         - If the DFG is disabled, the testRunner should pretend that we've done a
1621           bunch of DFG compiles. That's necessary to prevent the tests from timing
1622           out.
1623         
1624         - Disassembler shouldn't try to dump source code since it's not safe in the
1625           concurrent JIT.
1626
1627         * API/JSCTestRunnerUtils.cpp:
1628         (JSC::numberOfDFGCompiles):
1629         * JavaScriptCore.xcodeproj/project.pbxproj:
1630         * dfg/DFGAbstractInterpreterInlines.h:
1631         (JSC::DFG::::executeEffects):
1632         * dfg/DFGDisassembler.cpp:
1633         (JSC::DFG::Disassembler::dumpHeader):
1634         * dfg/DFGGraph.h:
1635         (JSC::DFG::Graph::byValIsPure):
1636         * dfg/DFGSaneStringGetByValSlowPathGenerator.h: Added.
1637         (DFG):
1638         (SaneStringGetByValSlowPathGenerator):
1639         (JSC::DFG::SaneStringGetByValSlowPathGenerator::SaneStringGetByValSlowPathGenerator):
1640         (JSC::DFG::SaneStringGetByValSlowPathGenerator::generateInternal):
1641         * dfg/DFGSpeculativeJIT.cpp:
1642         (JSC::DFG::SpeculativeJIT::compileGetByValOnString):
1643
1644 2013-07-19  Filip Pizlo  <fpizlo@apple.com>
1645
1646         fourthTier: Structure::isValidOffset() should be able to tell you if you're loading a valid JSValue, and not just not crashing
1647         https://bugs.webkit.org/show_bug.cgi?id=118911
1648
1649         Reviewed by Geoffrey Garen.
1650         
1651         We could also have a separate method like "willNotCrash(offset)", but that's not
1652         what isValidOffset() is intended to mean.
1653
1654         * runtime/Structure.h:
1655         (JSC::Structure::isValidOffset):
1656
1657 2013-07-19  Filip Pizlo  <fpizlo@apple.com>
1658
1659         fourthTier: Structure should be able to tell you if it's valid to load at a given offset from any object with that structure
1660         https://bugs.webkit.org/show_bug.cgi?id=118878
1661
1662         Reviewed by Oliver Hunt.
1663         
1664         - Change Structure::isValidOffset() to actually answer the question "If I attempted
1665           to load from an object of this structure, at this offset, would I commit suicide
1666           or would I get back some kind of value?"
1667         
1668         - Change StorageAccessData::offset to use a PropertyOffset. It should have been that
1669           way from the start.
1670         
1671         - Fix PutStructure so that it sets haveStructures in all of the cases that it should.
1672         
1673         - Make GetByOffset also reference the base object in addition to the butterfly.
1674         
1675         The future use of this power will be to answer questions like "If I hoisted this
1676         GetByOffset or PutByOffset to this point, would it cause crashes, or would it be
1677         fine?"
1678         
1679         I don't currently plan to use this power to perform validation, since the CSE has
1680         the power to eliminate CheckStructure's that the CFA wouldn't be smart enough to
1681         remove - both in the case of StructureSets where size >= 2 and in the case of
1682         CheckStructures that match across PutStructures. At first I tried to write a
1683         validator that was aware of this, but the validation code got way too complicated
1684         and I started having nightmares of spurious assertion bugs being filed against me.
1685         
1686         This also changes some of the code for how we hash FunctionExecutable's for debug
1687         dumps, since that code still had some thread-safety issues. Basically, the
1688         concurrent JIT needs to use the CodeBlock's precomputed hash and never call anything
1689         that could transitively try to compute the hash from the source code. The source
1690         code is a string that may be lazily computed, and that involves all manner of thread
1691         unsafe things.
1692
1693         * bytecode/CodeOrigin.cpp:
1694         (JSC::InlineCallFrame::hash):
1695         * dfg/DFGAbstractInterpreterInlines.h:
1696         (JSC::DFG::::executeEffects):
1697         * dfg/DFGByteCodeParser.cpp:
1698         (JSC::DFG::ByteCodeParser::handleGetByOffset):
1699         (JSC::DFG::ByteCodeParser::handlePutByOffset):
1700         (JSC::DFG::ByteCodeParser::parseBlock):
1701         * dfg/DFGCFAPhase.cpp:
1702         (JSC::DFG::CFAPhase::performBlockCFA):
1703         * dfg/DFGConstantFoldingPhase.cpp:
1704         (JSC::DFG::ConstantFoldingPhase::foldConstants):
1705         * dfg/DFGFixupPhase.cpp:
1706         (JSC::DFG::FixupPhase::fixupNode):
1707         * dfg/DFGGraph.h:
1708         (StorageAccessData):
1709         * dfg/DFGNode.h:
1710         (JSC::DFG::Node::convertToGetByOffset):
1711         * dfg/DFGSpeculativeJIT64.cpp:
1712         (JSC::DFG::SpeculativeJIT::compile):
1713         * ftl/FTLLowerDFGToLLVM.cpp:
1714         (JSC::FTL::LowerDFGToLLVM::compileGetByOffset):
1715         (JSC::FTL::LowerDFGToLLVM::compilePutByOffset):
1716         * runtime/FunctionExecutableDump.cpp:
1717         (JSC::FunctionExecutableDump::dump):
1718         * runtime/Structure.h:
1719         (Structure):
1720         (JSC::Structure::isValidOffset):
1721
1722 2013-07-18  Filip Pizlo  <fpizlo@apple.com>
1723
1724         fourthTier: AbstractInterpreter should explicitly ask AbstractState to create new AbstractValues for newly born nodes
1725         https://bugs.webkit.org/show_bug.cgi?id=118880
1726
1727         Reviewed by Sam Weinig.
1728         
1729         It should be possible to have an AbstractState that is backed by a HashMap. But to
1730         do this, the AbstractInterpreter should explicitly ask for new nodes to be added to
1731         the map, since otherwise the idiom of getting a reference to the AbstractValue
1732         returned by forNode() would cause really subtle memory corruption bugs.
1733
1734         * dfg/DFGAbstractInterpreterInlines.h:
1735         (JSC::DFG::::executeEffects):
1736         * dfg/DFGInPlaceAbstractState.h:
1737         (JSC::DFG::InPlaceAbstractState::createValueForNode):
1738         (InPlaceAbstractState):
1739
1740 2013-07-18  Filip Pizlo  <fpizlo@apple.com>
1741
1742         fourthTier: Decouple the way that CFA stores its state from the way it does abstract interpretation
1743         https://bugs.webkit.org/show_bug.cgi?id=118835
1744
1745         Reviewed by Oliver Hunt.
1746         
1747         This separates AbstractState into two things:
1748         
1749         - InPlaceAbstractState, which can tell you the abstract state of anything you
1750           might care about, and uses the old AbstractState's algorithms and data
1751           structures for doing so.
1752         
1753         - AbstractInterpreter<AbstractStateType>, which can execute a DFG::Node* with
1754           respect to an AbstractStateType. Currently we always use
1755           AbstractStateType = InPlaceAbstractState. But we could drop in an other
1756           class that supports basic primitives like forNode() and variables().
1757         
1758         This is important because:
1759         
1760         - We want to hoist things out of loops.
1761
1762         - We don't know what things rely on what type checks.
1763
1764         - We only want to hoist type checks out of loops if they aren't clobbered.
1765
1766         - We may want to still hoist things that depended on those type checks, if it's
1767           safe to do those things based on the CFA state at the tail of the loop
1768           pre-header.
1769
1770         - We don't want things to rely on their type checks by way of a token, because
1771           that's just weird.
1772
1773         So, we want to be able to have a special form of the CFA that can
1774         incrementally update a basic block's state-at-tail, and we want to be able to
1775         do this for multiple blocks simultaneously. This requires *not* storing the
1776         per-node state in the nodes themselves, but instead using the at-tail HashMap
1777         directly.
1778
1779         Hence we need to have a way of making the abstract interpreter (i.e.
1780         AbstractState::execute) polymorphic with respect to state representation. Put
1781         another way, we need to separate the way that abstract state is represented
1782         from the way DFG IR is abstractly interpreted.
1783
1784         * JavaScriptCore.xcodeproj/project.pbxproj:
1785         * dfg/DFGAbstractInterpreter.h: Added.
1786         (DFG):
1787         (AbstractInterpreter):
1788         (JSC::DFG::AbstractInterpreter::forNode):
1789         (JSC::DFG::AbstractInterpreter::variables):
1790         (JSC::DFG::AbstractInterpreter::needsTypeCheck):
1791         (JSC::DFG::AbstractInterpreter::filterEdgeByUse):
1792         (JSC::DFG::AbstractInterpreter::filter):
1793         (JSC::DFG::AbstractInterpreter::filterArrayModes):
1794         (JSC::DFG::AbstractInterpreter::filterByValue):
1795         (JSC::DFG::AbstractInterpreter::trySetConstant):
1796         (JSC::DFG::AbstractInterpreter::filterByType):
1797         * dfg/DFGAbstractInterpreterInlines.h: Added.
1798         (DFG):
1799         (JSC::DFG::::AbstractInterpreter):
1800         (JSC::DFG::::~AbstractInterpreter):
1801         (JSC::DFG::::booleanResult):
1802         (JSC::DFG::::startExecuting):
1803         (JSC::DFG::::executeEdges):
1804         (JSC::DFG::::verifyEdge):
1805         (JSC::DFG::::verifyEdges):
1806         (JSC::DFG::::executeEffects):
1807         (JSC::DFG::::execute):
1808         (JSC::DFG::::clobberWorld):
1809         (JSC::DFG::::clobberCapturedVars):
1810         (JSC::DFG::::clobberStructures):
1811         (JSC::DFG::::dump):
1812         (JSC::DFG::::filter):
1813         (JSC::DFG::::filterArrayModes):
1814         (JSC::DFG::::filterByValue):
1815         * dfg/DFGAbstractState.cpp: Removed.
1816         * dfg/DFGAbstractState.h: Removed.
1817         * dfg/DFGArgumentsSimplificationPhase.cpp:
1818         * dfg/DFGCFAPhase.cpp:
1819         (JSC::DFG::CFAPhase::CFAPhase):
1820         (JSC::DFG::CFAPhase::performBlockCFA):
1821         (CFAPhase):
1822         * dfg/DFGCFGSimplificationPhase.cpp:
1823         * dfg/DFGConstantFoldingPhase.cpp:
1824         (JSC::DFG::ConstantFoldingPhase::ConstantFoldingPhase):
1825         (JSC::DFG::ConstantFoldingPhase::foldConstants):
1826         (ConstantFoldingPhase):
1827         * dfg/DFGInPlaceAbstractState.cpp: Added.
1828         (DFG):
1829         (JSC::DFG::InPlaceAbstractState::InPlaceAbstractState):
1830         (JSC::DFG::InPlaceAbstractState::~InPlaceAbstractState):
1831         (JSC::DFG::InPlaceAbstractState::beginBasicBlock):
1832         (JSC::DFG::setLiveValues):
1833         (JSC::DFG::InPlaceAbstractState::initialize):
1834         (JSC::DFG::InPlaceAbstractState::endBasicBlock):
1835         (JSC::DFG::InPlaceAbstractState::reset):
1836         (JSC::DFG::InPlaceAbstractState::mergeStateAtTail):
1837         (JSC::DFG::InPlaceAbstractState::merge):
1838         (JSC::DFG::InPlaceAbstractState::mergeToSuccessors):
1839         (JSC::DFG::InPlaceAbstractState::mergeVariableBetweenBlocks):
1840         * dfg/DFGInPlaceAbstractState.h: Added.
1841         (DFG):
1842         (InPlaceAbstractState):
1843         (JSC::DFG::InPlaceAbstractState::forNode):
1844         (JSC::DFG::InPlaceAbstractState::variables):
1845         (JSC::DFG::InPlaceAbstractState::block):
1846         (JSC::DFG::InPlaceAbstractState::didClobber):
1847         (JSC::DFG::InPlaceAbstractState::isValid):
1848         (JSC::DFG::InPlaceAbstractState::setDidClobber):
1849         (JSC::DFG::InPlaceAbstractState::setIsValid):
1850         (JSC::DFG::InPlaceAbstractState::setBranchDirection):
1851         (JSC::DFG::InPlaceAbstractState::setFoundConstants):
1852         (JSC::DFG::InPlaceAbstractState::haveStructures):
1853         (JSC::DFG::InPlaceAbstractState::setHaveStructures):
1854         * dfg/DFGMergeMode.h: Added.
1855         (DFG):
1856         * dfg/DFGSpeculativeJIT.cpp:
1857         (JSC::DFG::SpeculativeJIT::SpeculativeJIT):
1858         (JSC::DFG::SpeculativeJIT::backwardTypeCheck):
1859         (JSC::DFG::SpeculativeJIT::compileCurrentBlock):
1860         (JSC::DFG::SpeculativeJIT::compileToStringOnCell):
1861         (JSC::DFG::SpeculativeJIT::speculateStringIdentAndLoadStorage):
1862         (JSC::DFG::SpeculativeJIT::speculateStringObject):
1863         (JSC::DFG::SpeculativeJIT::speculateStringOrStringObject):
1864         * dfg/DFGSpeculativeJIT.h:
1865         (JSC::DFG::SpeculativeJIT::needsTypeCheck):
1866         (SpeculativeJIT):
1867         * dfg/DFGSpeculativeJIT32_64.cpp:
1868         (JSC::DFG::SpeculativeJIT::fillSpeculateIntInternal):
1869         (JSC::DFG::SpeculativeJIT::fillSpeculateDouble):
1870         (JSC::DFG::SpeculativeJIT::fillSpeculateCell):
1871         (JSC::DFG::SpeculativeJIT::fillSpeculateBoolean):
1872         * dfg/DFGSpeculativeJIT64.cpp:
1873         (JSC::DFG::SpeculativeJIT::fillSpeculateIntInternal):
1874         (JSC::DFG::SpeculativeJIT::fillSpeculateDouble):
1875         (JSC::DFG::SpeculativeJIT::fillSpeculateCell):
1876         (JSC::DFG::SpeculativeJIT::fillSpeculateBoolean):
1877         * ftl/FTLLowerDFGToLLVM.cpp:
1878         (FTL):
1879         (JSC::FTL::LowerDFGToLLVM::LowerDFGToLLVM):
1880         (JSC::FTL::LowerDFGToLLVM::compileNode):
1881         (JSC::FTL::LowerDFGToLLVM::appendTypeCheck):
1882         (JSC::FTL::LowerDFGToLLVM::speculate):
1883         (JSC::FTL::LowerDFGToLLVM::speculateNumber):
1884         (JSC::FTL::LowerDFGToLLVM::speculateRealNumber):
1885         (LowerDFGToLLVM):
1886
1887 2013-07-18  Filip Pizlo  <fpizlo@apple.com>
1888
1889         fourthTier: DFG shouldn't create CheckStructures for array accesses except if the ArrayMode implies an original array access
1890         https://bugs.webkit.org/show_bug.cgi?id=118867
1891
1892         Reviewed by Mark Hahnenberg.
1893         
1894         This allows us to kill off a bunch of code in the parser, in fixup, and to simplify
1895         ArrayProfile.
1896
1897         It also makes it easier to ask any array-using node how to create its type check.
1898         
1899         Doing this required fixing a bug in LowLevelInterpreter64, where it was storing into
1900         an array profile, thinking that it was storing into a value profile. Reshuffling the
1901         fields in ArrayProfile revealed this.
1902
1903         * bytecode/ArrayProfile.cpp:
1904         (JSC::ArrayProfile::computeUpdatedPrediction):
1905         (JSC::ArrayProfile::briefDescriptionWithoutUpdating):
1906         * bytecode/ArrayProfile.h:
1907         (JSC::ArrayProfile::ArrayProfile):
1908         (ArrayProfile):
1909         * bytecode/CodeBlock.cpp:
1910         (JSC::CodeBlock::updateAllArrayPredictions):
1911         (JSC::CodeBlock::updateAllPredictions):
1912         * bytecode/CodeBlock.h:
1913         (CodeBlock):
1914         (JSC::CodeBlock::updateAllArrayPredictions):
1915         * dfg/DFGArrayMode.h:
1916         (ArrayMode):
1917         * dfg/DFGByteCodeParser.cpp:
1918         (JSC::DFG::ByteCodeParser::getArrayModeConsideringSlowPath):
1919         (JSC::DFG::ByteCodeParser::parseBlock):
1920         * dfg/DFGFixupPhase.cpp:
1921         (JSC::DFG::FixupPhase::fixupNode):
1922         (FixupPhase):
1923         (JSC::DFG::FixupPhase::checkArray):
1924         (JSC::DFG::FixupPhase::blessArrayOperation):
1925         * llint/LowLevelInterpreter64.asm:
1926
1927 2013-07-18  Filip Pizlo  <fpizlo@apple.com>
1928
1929         fourthTier: CFA should consider live-at-head for clobbering and dumping
1930         https://bugs.webkit.org/show_bug.cgi?id=118857
1931
1932         Reviewed by Mark Hahnenberg.
1933         
1934         - clobberStructures() was not considering nodes live-at-head when in SSA
1935           form. This means it would fail to clobber some structures.
1936         
1937         - dump() was not considering nodes live-at-head when in SSA form. This
1938           means it wouldn't dump everything that you might be interested in.
1939         
1940         - AbstractState::m_currentNode is a useless variable and we should get
1941           rid of it.
1942
1943         * dfg/DFGAbstractState.cpp:
1944         (JSC::DFG::AbstractState::AbstractState):
1945         (JSC::DFG::AbstractState::beginBasicBlock):
1946         (JSC::DFG::AbstractState::reset):
1947         (JSC::DFG::AbstractState::startExecuting):
1948         (JSC::DFG::AbstractState::clobberStructures):
1949         (JSC::DFG::AbstractState::dump):
1950         * dfg/DFGAbstractState.h:
1951         (AbstractState):
1952
1953 2013-07-16  Filip Pizlo  <fpizlo@apple.com>
1954
1955         fourthTier: Add a phase to create loop pre-headers
1956         https://bugs.webkit.org/show_bug.cgi?id=118778
1957
1958         Reviewed by Oliver Hunt.
1959         
1960         Add a loop pre-header creation phase. Any loop that doesn't already have
1961         just one predecessor that isn't part of the loop has a pre-header
1962         prepended. All non-loop predecessors then jump to that pre-header.
1963         
1964         Also fix a handful of bugs:
1965         
1966         - DFG::Analysis should set m_valid before running the analysis, since that
1967           makes it easier to use ASSERT(m_valid) in the analysis' methods, which
1968           may be called by the analysis before the analysis completes. NaturalLoops
1969           does this with loopsOf().
1970         
1971         - NaturalLoops::headerOf() was missing a check for innerMostLoopOf()
1972           returning 0, since that'll happen if the block isn't in any loop.
1973         
1974         - Change BlockInsertionSet to dethread the graph, since anyone using it
1975           will want to do so.
1976         
1977         - Change dethreading to ignore SSA form graphs.
1978         
1979         This also adds NaturalLoops::belongsTo(), which I always used in the
1980         pre-header creation phase. I didn't end up using it but I'll probably use
1981         it in the near future.
1982         
1983         * JavaScriptCore.xcodeproj/project.pbxproj:
1984         * dfg/DFGAnalysis.h:
1985         (JSC::DFG::Analysis::computeIfNecessary):
1986         * dfg/DFGBlockInsertionSet.cpp:
1987         (JSC::DFG::BlockInsertionSet::execute):
1988         * dfg/DFGCriticalEdgeBreakingPhase.cpp:
1989         (JSC::DFG::CriticalEdgeBreakingPhase::breakCriticalEdge):
1990         * dfg/DFGGraph.cpp:
1991         (JSC::DFG::Graph::dethread):
1992         * dfg/DFGLoopPreHeaderCreationPhase.cpp: Added.
1993         (DFG):
1994         (LoopPreHeaderCreationPhase):
1995         (JSC::DFG::LoopPreHeaderCreationPhase::LoopPreHeaderCreationPhase):
1996         (JSC::DFG::LoopPreHeaderCreationPhase::run):
1997         (JSC::DFG::performLoopPreHeaderCreation):
1998         * dfg/DFGLoopPreHeaderCreationPhase.h: Added.
1999         (DFG):
2000         * dfg/DFGNaturalLoops.h:
2001         (NaturalLoop):
2002         (JSC::DFG::NaturalLoops::headerOf):
2003         (JSC::DFG::NaturalLoops::innerMostLoopOf):
2004         (JSC::DFG::NaturalLoops::innerMostOuterLoop):
2005         (JSC::DFG::NaturalLoops::belongsTo):
2006         (NaturalLoops):
2007         * dfg/DFGPlan.cpp:
2008         (JSC::DFG::Plan::compileInThreadImpl):
2009
2010 2013-07-16  Filip Pizlo  <fpizlo@apple.com>
2011
2012         fourthTier: Rationalize Node::replacement
2013         https://bugs.webkit.org/show_bug.cgi?id=118774
2014
2015         Reviewed by Oliver Hunt.
2016         
2017         - Clearing of replacements is now done in Graph::clearReplacements().
2018         
2019         - New nodes now have replacement set to 0.
2020         
2021         - Node::replacement is now part of a 'misc' union. I'll be putting at least
2022           one other field into that union as part of LICM work (see
2023           https://bugs.webkit.org/show_bug.cgi?id=118749).
2024
2025         * dfg/DFGCPSRethreadingPhase.cpp:
2026         (JSC::DFG::CPSRethreadingPhase::run):
2027         (JSC::DFG::CPSRethreadingPhase::freeUnnecessaryNodes):
2028         (JSC::DFG::CPSRethreadingPhase::canonicalizeGetLocalFor):
2029         * dfg/DFGCSEPhase.cpp:
2030         (JSC::DFG::CSEPhase::run):
2031         (JSC::DFG::CSEPhase::setReplacement):
2032         (JSC::DFG::CSEPhase::performBlockCSE):
2033         * dfg/DFGGraph.cpp:
2034         (DFG):
2035         (JSC::DFG::Graph::clearReplacements):
2036         * dfg/DFGGraph.h:
2037         (JSC::DFG::Graph::performSubstitutionForEdge):
2038         (Graph):
2039         * dfg/DFGNode.h:
2040         (JSC::DFG::Node::Node):
2041         * dfg/DFGSSAConversionPhase.cpp:
2042         (JSC::DFG::SSAConversionPhase::run):
2043
2044 2013-07-16  Filip Pizlo  <fpizlo@apple.com>
2045
2046         fourthTier: NaturalLoops should be able to quickly answer questions like "what loops own this basic block"
2047         https://bugs.webkit.org/show_bug.cgi?id=118750
2048
2049         Reviewed by Mark Hahnenberg.
2050
2051         * dfg/DFGBasicBlock.h:
2052         (BasicBlock):
2053         * dfg/DFGNaturalLoops.cpp:
2054         (JSC::DFG::NaturalLoops::compute):
2055         (JSC::DFG::NaturalLoops::loopsOf):
2056         * dfg/DFGNaturalLoops.h:
2057         (DFG):
2058         (JSC::DFG::NaturalLoop::NaturalLoop):
2059         (NaturalLoop):
2060         (JSC::DFG::NaturalLoop::index):
2061         (JSC::DFG::NaturalLoop::isOuterMostLoop):
2062         (JSC::DFG::NaturalLoop::addBlock):
2063         (JSC::DFG::NaturalLoops::headerOf):
2064         (JSC::DFG::NaturalLoops::innerMostLoopOf):
2065         (NaturalLoops):
2066         (JSC::DFG::NaturalLoops::innerMostOuterLoop):
2067         * dfg/DFGPlan.cpp:
2068         (JSC::DFG::Plan::compileInThreadImpl):
2069
2070 2013-07-16  Filip Pizlo  <fpizlo@apple.com>
2071
2072         fourthTier: don't GC when shutting down the VM
2073         https://bugs.webkit.org/show_bug.cgi?id=118751
2074
2075         Reviewed by Mark Hahnenberg.
2076
2077         * heap/Heap.h:
2078         (Heap):
2079         * runtime/VM.cpp:
2080         (JSC::VM::~VM):
2081
2082 2013-07-12  Filip Pizlo  <fpizlo@apple.com>
2083
2084         fourthTier: DFG should have an SSA form for use by FTL
2085         https://bugs.webkit.org/show_bug.cgi?id=118338
2086
2087         Reviewed by Mark Hahnenberg.
2088         
2089         Adds an SSA form to the DFG. We can convert ThreadedCPS form into SSA form
2090         after breaking critical edges. The conversion algorithm follows Aycock and
2091         Horspool, and the SSA form itself follows something I've done before, where
2092         instead of having Phi functions specify input nodes corresponding to block
2093         predecessors, we instead have Upsilon functions in the predecessors that
2094         specify which value in that block goes into which subsequent Phi. Upsilons
2095         don't have to dominate Phis (usually they don't) and they correspond to a
2096         non-SSA "mov" into the Phi's "variable". This gives all of the good
2097         properties of SSA, while ensuring that a bunch of CFG transformations don't
2098         have to be SSA-aware.
2099         
2100         So far the only DFG phases that are SSA-aware are DCE and CFA. CFG
2101         simplification is probably SSA-aware by default, though I haven't tried it.
2102         Constant folding probably needs a few tweaks, but is likely ready. Ditto
2103         for CSE, though it's not clear that we'd want to use block-local CSE when
2104         we could be doing GVN.
2105         
2106         Currently only the FTL can generate code from the SSA form, and there is no
2107         way to convert from SSA to ThreadedCPS or LoadStore. There probably will
2108         never be such a capability.
2109         
2110         In order to handle OSR exit state in the SSA, we place MovHints at Phi
2111         points. Other than that, you can reconstruct state-at-exit by forward
2112         propagating MovHints. Note that MovHint is the new SetLocal in SSA.
2113         SetLocal and GetLocal only survive into SSA if they are on captured
2114         variables, or in the case of flushes. A "live SetLocal" will be
2115         NodeMustGenerate and will always correspond to a flush. Computing the
2116         state-at-exit requires running SSA liveness analysis, OSR availability
2117         analysis, and flush liveness analysis. The FTL runs all of these prior to
2118         generating code. While OSR exit continues to be tricky, much of the logic
2119         is now factored into separate phases and the backend has to do less work
2120         to reason about what happened outside of the basic block that is being
2121         lowered.
2122         
2123         Conversion from DFG SSA to LLVM SSA is done by ensuring that we generate
2124         code in depth-first order, thus guaranteeing that a node will always be
2125         lowered (and hence have a LValue) before any of the blocks dominated by
2126         that node's block have code generated. For Upsilon/Phi, we just use
2127         alloca's. We could do something more clever there, but it's probably not
2128         worth it, at least not now.
2129         
2130         Finally, while the SSA form is currently only being converted to LLVM IR,
2131         there is nothing that prevents us from considering other backends in the
2132         future - with the caveat that this form is designed to be first lowered to
2133         a lower-level SSA before actual machine code generation commences. So we
2134         ought to either use LLVM (the intended path) or we will have to write our
2135         own SSA low-level backend.
2136         
2137         This runs all of the code that the FTL was known to run previously. No
2138         change in performance for now. But it does open some exciting
2139         possibilities!
2140
2141         * JavaScriptCore.xcodeproj/project.pbxproj:
2142         * bytecode/Operands.h:
2143         (JSC::OperandValueTraits::dump):
2144         (JSC::Operands::fill):
2145         (Operands):
2146         (JSC::Operands::clear):
2147         (JSC::Operands::operator==):
2148         * dfg/DFGAbstractState.cpp:
2149         (JSC::DFG::AbstractState::beginBasicBlock):
2150         (JSC::DFG::setLiveValues):
2151         (DFG):
2152         (JSC::DFG::AbstractState::initialize):
2153         (JSC::DFG::AbstractState::endBasicBlock):
2154         (JSC::DFG::AbstractState::executeEffects):
2155         (JSC::DFG::AbstractState::mergeStateAtTail):
2156         (JSC::DFG::AbstractState::merge):
2157         * dfg/DFGAbstractState.h:
2158         (AbstractState):
2159         * dfg/DFGAdjacencyList.h:
2160         (JSC::DFG::AdjacencyList::justOneChild):
2161         (AdjacencyList):
2162         * dfg/DFGBasicBlock.cpp: Added.
2163         (DFG):
2164         (JSC::DFG::BasicBlock::BasicBlock):
2165         (JSC::DFG::BasicBlock::~BasicBlock):
2166         (JSC::DFG::BasicBlock::ensureLocals):
2167         (JSC::DFG::BasicBlock::isInPhis):
2168         (JSC::DFG::BasicBlock::isInBlock):
2169         (JSC::DFG::BasicBlock::removePredecessor):
2170         (JSC::DFG::BasicBlock::replacePredecessor):
2171         (JSC::DFG::BasicBlock::dump):
2172         (JSC::DFG::BasicBlock::SSAData::SSAData):
2173         (JSC::DFG::BasicBlock::SSAData::~SSAData):
2174         * dfg/DFGBasicBlock.h:
2175         (BasicBlock):
2176         (JSC::DFG::BasicBlock::operator[]):
2177         (JSC::DFG::BasicBlock::successor):
2178         (JSC::DFG::BasicBlock::successorForCondition):
2179         (SSAData):
2180         * dfg/DFGBasicBlockInlines.h:
2181         (DFG):
2182         * dfg/DFGBlockInsertionSet.cpp: Added.
2183         (DFG):
2184         (JSC::DFG::BlockInsertionSet::BlockInsertionSet):
2185         (JSC::DFG::BlockInsertionSet::~BlockInsertionSet):
2186         (JSC::DFG::BlockInsertionSet::insert):
2187         (JSC::DFG::BlockInsertionSet::insertBefore):
2188         (JSC::DFG::BlockInsertionSet::execute):
2189         * dfg/DFGBlockInsertionSet.h: Added.
2190         (DFG):
2191         (BlockInsertionSet):
2192         * dfg/DFGCFAPhase.cpp:
2193         (JSC::DFG::CFAPhase::run):
2194         * dfg/DFGCFGSimplificationPhase.cpp:
2195         * dfg/DFGCPSRethreadingPhase.cpp:
2196         (JSC::DFG::CPSRethreadingPhase::canonicalizeLocalsInBlock):
2197         * dfg/DFGCommon.cpp:
2198         (WTF::printInternal):
2199         * dfg/DFGCommon.h:
2200         (JSC::DFG::doesKill):
2201         (DFG):
2202         (JSC::DFG::killStatusForDoesKill):
2203         * dfg/DFGConstantFoldingPhase.cpp:
2204         (JSC::DFG::ConstantFoldingPhase::foldConstants):
2205         (JSC::DFG::ConstantFoldingPhase::isCapturedAtOrAfter):
2206         * dfg/DFGCriticalEdgeBreakingPhase.cpp: Added.
2207         (DFG):
2208         (CriticalEdgeBreakingPhase):
2209         (JSC::DFG::CriticalEdgeBreakingPhase::CriticalEdgeBreakingPhase):
2210         (JSC::DFG::CriticalEdgeBreakingPhase::run):
2211         (JSC::DFG::CriticalEdgeBreakingPhase::breakCriticalEdge):
2212         (JSC::DFG::performCriticalEdgeBreaking):
2213         * dfg/DFGCriticalEdgeBreakingPhase.h: Added.
2214         (DFG):
2215         * dfg/DFGDCEPhase.cpp:
2216         (JSC::DFG::DCEPhase::run):
2217         (JSC::DFG::DCEPhase::findTypeCheckRoot):
2218         (JSC::DFG::DCEPhase::countNode):
2219         (DCEPhase):
2220         (JSC::DFG::DCEPhase::countEdge):
2221         (JSC::DFG::DCEPhase::eliminateIrrelevantPhantomChildren):
2222         * dfg/DFGDriver.cpp:
2223         (JSC::DFG::compile):
2224         * dfg/DFGEdge.cpp:
2225         (JSC::DFG::Edge::dump):
2226         * dfg/DFGEdge.h:
2227         (JSC::DFG::Edge::Edge):
2228         (JSC::DFG::Edge::setNode):
2229         (JSC::DFG::Edge::useKindUnchecked):
2230         (JSC::DFG::Edge::setUseKind):
2231         (JSC::DFG::Edge::setProofStatus):
2232         (JSC::DFG::Edge::willNotHaveCheck):
2233         (JSC::DFG::Edge::willHaveCheck):
2234         (Edge):
2235         (JSC::DFG::Edge::killStatusUnchecked):
2236         (JSC::DFG::Edge::killStatus):
2237         (JSC::DFG::Edge::setKillStatus):
2238         (JSC::DFG::Edge::doesKill):
2239         (JSC::DFG::Edge::doesNotKill):
2240         (JSC::DFG::Edge::shift):
2241         (JSC::DFG::Edge::makeWord):
2242         * dfg/DFGFixupPhase.cpp:
2243         (JSC::DFG::FixupPhase::fixupNode):
2244         * dfg/DFGFlushFormat.cpp: Added.
2245         (WTF):
2246         (WTF::printInternal):
2247         * dfg/DFGFlushFormat.h: Added.
2248         (DFG):
2249         (JSC::DFG::resultFor):
2250         (JSC::DFG::useKindFor):
2251         (WTF):
2252         * dfg/DFGFlushLivenessAnalysisPhase.cpp: Added.
2253         (DFG):
2254         (FlushLivenessAnalysisPhase):
2255         (JSC::DFG::FlushLivenessAnalysisPhase::FlushLivenessAnalysisPhase):
2256         (JSC::DFG::FlushLivenessAnalysisPhase::run):
2257         (JSC::DFG::FlushLivenessAnalysisPhase::process):
2258         (JSC::DFG::FlushLivenessAnalysisPhase::setForNode):
2259         (JSC::DFG::FlushLivenessAnalysisPhase::flushFormat):
2260         (JSC::DFG::performFlushLivenessAnalysis):
2261         * dfg/DFGFlushLivenessAnalysisPhase.h: Added.
2262         (DFG):
2263         * dfg/DFGGraph.cpp:
2264         (JSC::DFG::Graph::dump):
2265         (JSC::DFG::Graph::dumpBlockHeader):
2266         (DFG):
2267         (JSC::DFG::Graph::addForDepthFirstSort):
2268         (JSC::DFG::Graph::getBlocksInDepthFirstOrder):
2269         * dfg/DFGGraph.h:
2270         (JSC::DFG::Graph::convertToConstant):
2271         (JSC::DFG::Graph::valueProfileFor):
2272         (Graph):
2273         * dfg/DFGInsertionSet.h:
2274         (DFG):
2275         (JSC::DFG::InsertionSet::execute):
2276         * dfg/DFGLivenessAnalysisPhase.cpp: Added.
2277         (DFG):
2278         (LivenessAnalysisPhase):
2279         (JSC::DFG::LivenessAnalysisPhase::LivenessAnalysisPhase):
2280         (JSC::DFG::LivenessAnalysisPhase::run):
2281         (JSC::DFG::LivenessAnalysisPhase::process):
2282         (JSC::DFG::LivenessAnalysisPhase::addChildUse):
2283         (JSC::DFG::performLivenessAnalysis):
2284         * dfg/DFGLivenessAnalysisPhase.h: Added.
2285         (DFG):
2286         * dfg/DFGNode.cpp:
2287         (JSC::DFG::Node::hasVariableAccessData):
2288         (DFG):
2289         * dfg/DFGNode.h:
2290         (DFG):
2291         (Node):
2292         (JSC::DFG::Node::hasLocal):
2293         (JSC::DFG::Node::variableAccessData):
2294         (JSC::DFG::Node::hasPhi):
2295         (JSC::DFG::Node::phi):
2296         (JSC::DFG::Node::takenBlock):
2297         (JSC::DFG::Node::notTakenBlock):
2298         (JSC::DFG::Node::successor):
2299         (JSC::DFG::Node::successorForCondition):
2300         (JSC::DFG::nodeComparator):
2301         (JSC::DFG::nodeListDump):
2302         (JSC::DFG::nodeMapDump):
2303         * dfg/DFGNodeFlags.cpp:
2304         (JSC::DFG::dumpNodeFlags):
2305         * dfg/DFGNodeType.h:
2306         (DFG):
2307         * dfg/DFGOSRAvailabilityAnalysisPhase.cpp: Added.
2308         (DFG):
2309         (OSRAvailabilityAnalysisPhase):
2310         (JSC::DFG::OSRAvailabilityAnalysisPhase::OSRAvailabilityAnalysisPhase):
2311         (JSC::DFG::OSRAvailabilityAnalysisPhase::run):
2312         (JSC::DFG::performOSRAvailabilityAnalysis):
2313         * dfg/DFGOSRAvailabilityAnalysisPhase.h: Added.
2314         (DFG):
2315         * dfg/DFGPlan.cpp:
2316         (JSC::DFG::Plan::compileInThreadImpl):
2317         * dfg/DFGPredictionInjectionPhase.cpp:
2318         (JSC::DFG::PredictionInjectionPhase::run):
2319         * dfg/DFGPredictionPropagationPhase.cpp:
2320         (JSC::DFG::PredictionPropagationPhase::propagate):
2321         * dfg/DFGSSAConversionPhase.cpp: Added.
2322         (DFG):
2323         (SSAConversionPhase):
2324         (JSC::DFG::SSAConversionPhase::SSAConversionPhase):
2325         (JSC::DFG::SSAConversionPhase::run):
2326         (JSC::DFG::SSAConversionPhase::forwardPhiChildren):
2327         (JSC::DFG::SSAConversionPhase::forwardPhi):
2328         (JSC::DFG::SSAConversionPhase::forwardPhiEdge):
2329         (JSC::DFG::SSAConversionPhase::deduplicateChildren):
2330         (JSC::DFG::SSAConversionPhase::addFlushedLocalOp):
2331         (JSC::DFG::SSAConversionPhase::addFlushedLocalEdge):
2332         (JSC::DFG::performSSAConversion):
2333         * dfg/DFGSSAConversionPhase.h: Added.
2334         (DFG):
2335         * dfg/DFGSpeculativeJIT32_64.cpp:
2336         (JSC::DFG::SpeculativeJIT::compile):
2337         * dfg/DFGSpeculativeJIT64.cpp:
2338         (JSC::DFG::SpeculativeJIT::compile):
2339         * dfg/DFGValidate.cpp:
2340         (JSC::DFG::Validate::validate):
2341         (Validate):
2342         (JSC::DFG::Validate::validateCPS):
2343         * dfg/DFGVariableAccessData.h:
2344         (JSC::DFG::VariableAccessData::flushFormat):
2345         (VariableAccessData):
2346         * ftl/FTLCapabilities.cpp:
2347         (JSC::FTL::canCompile):
2348         * ftl/FTLLowerDFGToLLVM.cpp:
2349         (JSC::FTL::LowerDFGToLLVM::LowerDFGToLLVM):
2350         (JSC::FTL::LowerDFGToLLVM::lower):
2351         (JSC::FTL::LowerDFGToLLVM::createPhiVariables):
2352         (JSC::FTL::LowerDFGToLLVM::compileBlock):
2353         (JSC::FTL::LowerDFGToLLVM::compileNode):
2354         (JSC::FTL::LowerDFGToLLVM::compileUpsilon):
2355         (LowerDFGToLLVM):
2356         (JSC::FTL::LowerDFGToLLVM::compilePhi):
2357         (JSC::FTL::LowerDFGToLLVM::compileJSConstant):
2358         (JSC::FTL::LowerDFGToLLVM::compileWeakJSConstant):
2359         (JSC::FTL::LowerDFGToLLVM::compileGetArgument):
2360         (JSC::FTL::LowerDFGToLLVM::compileGetLocal):
2361         (JSC::FTL::LowerDFGToLLVM::compileSetLocal):
2362         (JSC::FTL::LowerDFGToLLVM::compileAdd):
2363         (JSC::FTL::LowerDFGToLLVM::compileArithSub):
2364         (JSC::FTL::LowerDFGToLLVM::compileArithMul):
2365         (JSC::FTL::LowerDFGToLLVM::compileArithDiv):
2366         (JSC::FTL::LowerDFGToLLVM::compileArithMod):
2367         (JSC::FTL::LowerDFGToLLVM::compileArithMinOrMax):
2368         (JSC::FTL::LowerDFGToLLVM::compileArithAbs):
2369         (JSC::FTL::LowerDFGToLLVM::compileArithNegate):
2370         (JSC::FTL::LowerDFGToLLVM::compileBitAnd):
2371         (JSC::FTL::LowerDFGToLLVM::compileBitOr):
2372         (JSC::FTL::LowerDFGToLLVM::compileBitXor):
2373         (JSC::FTL::LowerDFGToLLVM::compileBitRShift):
2374         (JSC::FTL::LowerDFGToLLVM::compileBitLShift):
2375         (JSC::FTL::LowerDFGToLLVM::compileBitURShift):
2376         (JSC::FTL::LowerDFGToLLVM::compileUInt32ToNumber):
2377         (JSC::FTL::LowerDFGToLLVM::compileInt32ToDouble):
2378         (JSC::FTL::LowerDFGToLLVM::compileGetButterfly):
2379         (JSC::FTL::LowerDFGToLLVM::compileGetArrayLength):
2380         (JSC::FTL::LowerDFGToLLVM::compileGetByVal):
2381         (JSC::FTL::LowerDFGToLLVM::compileGetByOffset):
2382         (JSC::FTL::LowerDFGToLLVM::compileGetGlobalVar):
2383         (JSC::FTL::LowerDFGToLLVM::compileCompareEqConstant):
2384         (JSC::FTL::LowerDFGToLLVM::compileCompareStrictEq):
2385         (JSC::FTL::LowerDFGToLLVM::compileCompareStrictEqConstant):
2386         (JSC::FTL::LowerDFGToLLVM::compileCompareLess):
2387         (JSC::FTL::LowerDFGToLLVM::compileCompareLessEq):
2388         (JSC::FTL::LowerDFGToLLVM::compileCompareGreater):
2389         (JSC::FTL::LowerDFGToLLVM::compileCompareGreaterEq):
2390         (JSC::FTL::LowerDFGToLLVM::compileLogicalNot):
2391         (JSC::FTL::LowerDFGToLLVM::speculateBackward):
2392         (JSC::FTL::LowerDFGToLLVM::lowInt32):
2393         (JSC::FTL::LowerDFGToLLVM::lowCell):
2394         (JSC::FTL::LowerDFGToLLVM::lowBoolean):
2395         (JSC::FTL::LowerDFGToLLVM::lowDouble):
2396         (JSC::FTL::LowerDFGToLLVM::lowJSValue):
2397         (JSC::FTL::LowerDFGToLLVM::lowStorage):
2398         (JSC::FTL::LowerDFGToLLVM::speculate):
2399         (JSC::FTL::LowerDFGToLLVM::speculateBoolean):
2400         (JSC::FTL::LowerDFGToLLVM::isLive):
2401         (JSC::FTL::LowerDFGToLLVM::use):
2402         (JSC::FTL::LowerDFGToLLVM::initializeOSRExitStateForBlock):
2403         (JSC::FTL::LowerDFGToLLVM::appendOSRExit):
2404         (JSC::FTL::LowerDFGToLLVM::emitOSRExitCall):
2405         (JSC::FTL::LowerDFGToLLVM::addExitArgumentForNode):
2406         (JSC::FTL::LowerDFGToLLVM::linkOSRExitsAndCompleteInitializationBlocks):
2407         (JSC::FTL::LowerDFGToLLVM::setInt32):
2408         (JSC::FTL::LowerDFGToLLVM::setJSValue):
2409         (JSC::FTL::LowerDFGToLLVM::setBoolean):
2410         (JSC::FTL::LowerDFGToLLVM::setStorage):
2411         (JSC::FTL::LowerDFGToLLVM::setDouble):
2412         (JSC::FTL::LowerDFGToLLVM::isValid):
2413         * ftl/FTLLoweredNodeValue.h: Added.
2414         (FTL):
2415         (LoweredNodeValue):
2416         (JSC::FTL::LoweredNodeValue::LoweredNodeValue):
2417         (JSC::FTL::LoweredNodeValue::isSet):
2418         (JSC::FTL::LoweredNodeValue::operator!):
2419         (JSC::FTL::LoweredNodeValue::value):
2420         (JSC::FTL::LoweredNodeValue::block):
2421         * ftl/FTLValueFromBlock.h:
2422         (JSC::FTL::ValueFromBlock::ValueFromBlock):
2423         (ValueFromBlock):
2424         * ftl/FTLValueSource.cpp:
2425         (JSC::FTL::ValueSource::dump):
2426         * ftl/FTLValueSource.h:
2427
2428 2013-07-11  Mark Lam  <mark.lam@apple.com>
2429
2430         Resurrect the CLoop LLINT on the FTL branch.
2431         https://bugs.webkit.org/show_bug.cgi?id=118144.
2432
2433         Reviewed by Mark Hahnenberg.
2434
2435         * bytecode/CodeBlock.h:
2436         (JSC::CodeBlock::jitType):
2437           - Fix the CodeBlock jitType to be InterpreterThunk when !ENABLE_JIT.
2438         * bytecode/JumpTable.h:
2439         (JSC::SimpleJumpTable::clear):
2440         * interpreter/StackIterator.cpp:
2441         (JSC::StackIterator::Frame::bytecodeOffset):
2442         (JSC::StackIterator::Frame::print):
2443         * jit/JITCode.cpp:
2444         (JSC):
2445         * jit/JITExceptions.cpp:
2446         (JSC::getExceptionLocation):
2447         * llint/LowLevelInterpreter.cpp:
2448         * offlineasm/cloop.rb:
2449         * runtime/Structure.cpp:
2450
2451 2013-07-08  Filip Pizlo  <fpizlo@apple.com>
2452
2453         NaturalLoops + Profiler = Crash
2454         https://bugs.webkit.org/show_bug.cgi?id=118486
2455
2456         Reviewed by Geoffrey Garen.
2457         
2458         I borked dominators in:
2459         http://trac.webkit.org/changeset/152431/branches/dfgFourthTier/Source/JavaScriptCore/dfg/DFGDominators.h
2460         
2461         This patch also adds some debug support, and fixes the loop that adds a block to
2462         an already-existing natural loop. Note that we currently don't take that path in
2463         most programs, but it will arise, for example if you use 'continue' - though you'd
2464         have to use it rather cleverly since the bytecode will not jump to the loop header
2465         in most uses of 'continue'.
2466
2467         * dfg/DFGDominators.cpp:
2468         (JSC::DFG::Dominators::dump):
2469         (DFG):
2470         * dfg/DFGDominators.h:
2471         (JSC::DFG::Dominators::dominates):
2472         (Dominators):
2473         * dfg/DFGNaturalLoops.cpp:
2474         (JSC::DFG::NaturalLoops::compute):
2475
2476 2013-07-08  Filip Pizlo  <fpizlo@apple.com>
2477
2478         fourthTier: DFG::AbstractState::beginBasicBlock() should set m_haveStructures if any of the valuesAtHead have either a current known structure or a non-top/non-bottom array modes
2479         https://bugs.webkit.org/show_bug.cgi?id=118489
2480
2481         Reviewed by Mark Hahnenberg.
2482
2483         * bytecode/ArrayProfile.h:
2484         (JSC::arrayModesAreClearOrTop):
2485         (JSC):
2486         * dfg/DFGAbstractState.cpp:
2487         (JSC::DFG::AbstractState::beginBasicBlock):
2488         * dfg/DFGAbstractValue.h:
2489         (JSC::DFG::AbstractValue::hasClobberableState):
2490         (AbstractValue):
2491
2492 2013-07-08  Mark Hahnenberg  <mhahnenberg@apple.com>
2493
2494         CheckArray should call the right version of filterArrayModes
2495         https://bugs.webkit.org/show_bug.cgi?id=118488
2496
2497         Reviewed by Filip Pizlo.
2498
2499         Currently in the CFA CheckArray doesn't call the right filterArrayMode which can cause 
2500         the CFA to ignore when it sees a contradiction.
2501
2502         * dfg/DFGAbstractState.cpp:
2503         (JSC::DFG::AbstractState::executeEffects):
2504
2505 2013-07-07  Filip Pizlo  <fpizlo@apple.com>
2506
2507         fourthTier: Graph::clearAndDerefChild() makes no sense anymore, and neither does Nop
2508         https://bugs.webkit.org/show_bug.cgi?id=118452
2509
2510         Reviewed by Sam Weinig.
2511         
2512         Noticed that ArgumentsSimplificationPhase was converting something to a Nop and then
2513         resetting its children using clearAndDerefChild(). Using Nop instead of Phantom is a
2514         holdover from back when we needed a no-MustGenerate no-op. We don't anymore. Using
2515         clearAndDerefChild() was necessary back when we did eager reference counting. We
2516         don't need to do that anymore, and in fact clearAndDerefChild() appeared to not do
2517         any reference counting, so it was badly named to begin with.
2518
2519         * dfg/DFGAbstractState.cpp:
2520         (JSC::DFG::AbstractState::executeEffects):
2521         * dfg/DFGArgumentsSimplificationPhase.cpp:
2522         (JSC::DFG::ArgumentsSimplificationPhase::run):
2523         * dfg/DFGCPSRethreadingPhase.cpp:
2524         (JSC::DFG::CPSRethreadingPhase::freeUnnecessaryNodes):
2525         * dfg/DFGCSEPhase.cpp:
2526         (JSC::DFG::CSEPhase::performNodeCSE):
2527         * dfg/DFGFixupPhase.cpp:
2528         (JSC::DFG::FixupPhase::fixupNode):
2529         * dfg/DFGGraph.h:
2530         (Graph):
2531         * dfg/DFGNode.h:
2532         (JSC::DFG::Node::willHaveCodeGenOrOSR):
2533         * dfg/DFGNodeType.h:
2534         (DFG):
2535         * dfg/DFGPredictionPropagationPhase.cpp:
2536         (JSC::DFG::PredictionPropagationPhase::propagate):
2537         * dfg/DFGSpeculativeJIT32_64.cpp:
2538         (JSC::DFG::SpeculativeJIT::compile):
2539         * dfg/DFGSpeculativeJIT64.cpp:
2540         (JSC::DFG::SpeculativeJIT::compile):
2541
2542 2013-07-04  Filip Pizlo  <fpizlo@apple.com>
2543
2544         fourthTier: FTL should better report its compile-times and it should be able to run in a mode where it doesn't spend time generating OSR exits
2545         https://bugs.webkit.org/show_bug.cgi?id=118401
2546
2547         Reviewed by Sam Weinig.
2548         
2549         Add two new OSR exit modes, which are useful only for playing with compile times:
2550         
2551         - All OSR exits are llvm.trap().
2552         
2553         - OSR exits don't take arguments and have no exit value marshaling.
2554
2555         * dfg/DFGPlan.cpp:
2556         (JSC::DFG::Plan::compileInThread):
2557         (JSC::DFG::Plan::compileInThreadImpl):
2558         * dfg/DFGPlan.h:
2559         (Plan):
2560         * ftl/FTLIntrinsicRepository.h:
2561         (FTL):
2562         * ftl/FTLLowerDFGToLLVM.cpp:
2563         (JSC::FTL::LowerDFGToLLVM::appendOSRExit):
2564         (LowerDFGToLLVM):
2565         (JSC::FTL::LowerDFGToLLVM::emitOSRExitCall):
2566         * ftl/FTLOutput.h:
2567         (JSC::FTL::Output::trap):
2568         * runtime/Options.h:
2569         (JSC):
2570
2571 2013-07-04  Filip Pizlo  <fpizlo@apple.com>
2572
2573         fourthTier: DFG should refer to BasicBlocks by BasicBlock* and not BlockIndex
2574         https://bugs.webkit.org/show_bug.cgi?id=118339
2575
2576         Reviewed by Michael Saboff.
2577         
2578         This accomplishes two goals:
2579
2580         1) Simplifies a bunch of code. You can now much more directly get to a successor
2581            or predecessor, since you just get the pointer directly. The backend(s) always
2582            hold onto a pointer to the block they're on, so you don't have to do work to
2583            get the block from the index.
2584         
2585         2) It allows for the possibility of inserting blocks into the program.
2586            Previously, if you did that, you'd have to edit all references to blocks since
2587            those references would have outdated indexing after an insertion. Now, if you
2588            change the indexing, you just have to invalidate some analyses and make sure
2589            that you change each block's BasicBlock::index accordingly.
2590
2591         * dfg/DFGAbstractState.cpp:
2592         (JSC::DFG::AbstractState::initialize):
2593         (JSC::DFG::AbstractState::endBasicBlock):
2594         (JSC::DFG::AbstractState::mergeToSuccessors):
2595         * dfg/DFGAbstractState.h:
2596         (AbstractState):
2597         * dfg/DFGArgumentsSimplificationPhase.cpp:
2598         (JSC::DFG::ArgumentsSimplificationPhase::run):
2599         * dfg/DFGBackwardsPropagationPhase.cpp:
2600         (JSC::DFG::BackwardsPropagationPhase::run):
2601         * dfg/DFGBasicBlock.h:
2602         (DFG):
2603         (JSC::DFG::BasicBlock::BasicBlock):
2604         (JSC::DFG::BasicBlock::size):
2605         (JSC::DFG::BasicBlock::isEmpty):
2606         (JSC::DFG::BasicBlock::at):
2607         (JSC::DFG::BasicBlock::operator[]):
2608         (JSC::DFG::BasicBlock::last):
2609         (JSC::DFG::BasicBlock::resize):
2610         (JSC::DFG::BasicBlock::grow):
2611         (BasicBlock):
2612         (JSC::DFG::BasicBlock::append):
2613         (JSC::DFG::BasicBlock::numSuccessors):
2614         (JSC::DFG::BasicBlock::successor):
2615         (JSC::DFG::BasicBlock::successorForCondition):
2616         (JSC::DFG::BasicBlock::dump):
2617         (UnlinkedBlock):
2618         (JSC::DFG::UnlinkedBlock::UnlinkedBlock):
2619         (JSC::DFG::getBytecodeBeginForBlock):
2620         (JSC::DFG::blockForBytecodeOffset):
2621         * dfg/DFGByteCodeParser.cpp:
2622         (ByteCodeParser):
2623         (InlineStackEntry):
2624         (JSC::DFG::ByteCodeParser::handleInlining):
2625         (JSC::DFG::ByteCodeParser::parseBlock):
2626         (JSC::DFG::ByteCodeParser::linkBlock):
2627         (JSC::DFG::ByteCodeParser::linkBlocks):
2628         (JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
2629         (JSC::DFG::ByteCodeParser::parseCodeBlock):
2630         (JSC::DFG::ByteCodeParser::parse):
2631         * dfg/DFGCFAPhase.cpp:
2632         (JSC::DFG::CFAPhase::performBlockCFA):
2633         (JSC::DFG::CFAPhase::performForwardCFA):
2634         * dfg/DFGCFGSimplificationPhase.cpp:
2635         (JSC::DFG::CFGSimplificationPhase::run):
2636         (JSC::DFG::CFGSimplificationPhase::convertToJump):
2637         * dfg/DFGCPSRethreadingPhase.cpp:
2638         (JSC::DFG::CPSRethreadingPhase::freeUnnecessaryNodes):
2639         (JSC::DFG::CPSRethreadingPhase::canonicalizeLocalsInBlocks):
2640         (JSC::DFG::CPSRethreadingPhase::propagatePhis):
2641         (CPSRethreadingPhase):
2642         * dfg/DFGCSEPhase.cpp:
2643         (JSC::DFG::CSEPhase::run):
2644         * dfg/DFGConstantFoldingPhase.cpp:
2645         (JSC::DFG::ConstantFoldingPhase::run):
2646         (JSC::DFG::ConstantFoldingPhase::foldConstants):
2647         * dfg/DFGDCEPhase.cpp:
2648         (JSC::DFG::DCEPhase::run):
2649         * dfg/DFGDisassembler.cpp:
2650         (JSC::DFG::Disassembler::Disassembler):
2651         (JSC::DFG::Disassembler::createDumpList):
2652         * dfg/DFGDisassembler.h:
2653         (JSC::DFG::Disassembler::setForBlockIndex):
2654         * dfg/DFGDominators.cpp:
2655         (JSC::DFG::Dominators::compute):
2656         (JSC::DFG::Dominators::iterateForBlock):
2657         * dfg/DFGDominators.h:
2658         (JSC::DFG::Dominators::dominates):
2659         * dfg/DFGFixupPhase.cpp:
2660         (JSC::DFG::FixupPhase::run):
2661         (JSC::DFG::FixupPhase::fixupNode):
2662         * dfg/DFGGraph.cpp:
2663         (JSC::DFG::Graph::dump):
2664         (JSC::DFG::Graph::dumpBlockHeader):
2665         (JSC::DFG::Graph::handleSuccessor):
2666         (JSC::DFG::Graph::determineReachability):
2667         (JSC::DFG::Graph::resetReachability):
2668         * dfg/DFGGraph.h:
2669         (JSC::DFG::Graph::numBlocks):
2670         (JSC::DFG::Graph::block):
2671         (JSC::DFG::Graph::lastBlock):
2672         (Graph):
2673         (JSC::DFG::Graph::appendBlock):
2674         (JSC::DFG::Graph::killBlock):
2675         (DFG):
2676         * dfg/DFGJITCompiler.cpp:
2677         (JSC::DFG::JITCompiler::JITCompiler):
2678         (JSC::DFG::JITCompiler::link):
2679         * dfg/DFGJITCompiler.h:
2680         (JSC::DFG::JITCompiler::setForBlockIndex):
2681         * dfg/DFGNaturalLoops.cpp:
2682         (JSC::DFG::NaturalLoop::dump):
2683         (JSC::DFG::NaturalLoops::compute):
2684         (JSC::DFG::NaturalLoops::loopsOf):
2685         * dfg/DFGNaturalLoops.h:
2686         (JSC::DFG::NaturalLoop::NaturalLoop):
2687         (JSC::DFG::NaturalLoop::addBlock):
2688         (JSC::DFG::NaturalLoop::header):
2689         (JSC::DFG::NaturalLoop::at):
2690         (JSC::DFG::NaturalLoop::operator[]):
2691         (JSC::DFG::NaturalLoop::contains):
2692         (NaturalLoop):
2693         (JSC::DFG::NaturalLoops::headerOf):
2694         (NaturalLoops):
2695         * dfg/DFGNode.h:
2696         (DFG):
2697         (JSC::DFG::SwitchCase::SwitchCase):
2698         (JSC::DFG::SwitchCase::withBytecodeIndex):
2699         (SwitchCase):
2700         (JSC::DFG::SwitchCase::targetBytecodeIndex):
2701         (JSC::DFG::SwitchData::SwitchData):
2702         (JSC::DFG::SwitchData::setFallThroughBytecodeIndex):
2703         (JSC::DFG::SwitchData::fallThroughBytecodeIndex):
2704         (SwitchData):
2705         (JSC::DFG::Node::setTakenBlock):
2706         (JSC::DFG::Node::setNotTakenBlock):
2707         (JSC::DFG::Node::takenBlock):
2708         (JSC::DFG::Node::notTakenBlock):
2709         (JSC::DFG::Node::successor):
2710         (JSC::DFG::Node::successorForCondition):
2711         * dfg/DFGPredictionInjectionPhase.cpp:
2712         (JSC::DFG::PredictionInjectionPhase::run):
2713         * dfg/DFGPredictionPropagationPhase.cpp:
2714         (JSC::DFG::PredictionPropagationPhase::propagateForward):
2715         (JSC::DFG::PredictionPropagationPhase::propagateBackward):
2716         (JSC::DFG::PredictionPropagationPhase::doRoundOfDoubleVoting):
2717         * dfg/DFGSpeculativeJIT.cpp:
2718         (JSC::DFG::SpeculativeJIT::convertLastOSRExitToForward):
2719         (JSC::DFG::SpeculativeJIT::nonSpeculativeCompare):
2720         (JSC::DFG::SpeculativeJIT::nonSpeculativeStrictEq):
2721         (JSC::DFG::SpeculativeJIT::compilePeepHoleDoubleBranch):
2722         (JSC::DFG::SpeculativeJIT::compilePeepHoleObjectEquality):
2723         (JSC::DFG::SpeculativeJIT::compilePeepHoleIntegerBranch):
2724         (JSC::DFG::SpeculativeJIT::compilePeepHoleBranch):
2725         (JSC::DFG::SpeculativeJIT::compileCurrentBlock):
2726         (JSC::DFG::SpeculativeJIT::compile):
2727         (JSC::DFG::SpeculativeJIT::createOSREntries):
2728         (JSC::DFG::SpeculativeJIT::linkOSREntries):
2729         (JSC::DFG::SpeculativeJIT::compileStrictEqForConstant):
2730         (JSC::DFG::SpeculativeJIT::compileStrictEq):
2731         (JSC::DFG::SpeculativeJIT::compileRegExpExec):
2732         (JSC::DFG::SpeculativeJIT::addBranch):
2733         (JSC::DFG::SpeculativeJIT::linkBranches):
2734         * dfg/DFGSpeculativeJIT.h:
2735         (JSC::DFG::SpeculativeJIT::nextBlock):
2736         (SpeculativeJIT):
2737         (JSC::DFG::SpeculativeJIT::detectPeepHoleBranch):
2738         (JSC::DFG::SpeculativeJIT::branchDouble):
2739         (JSC::DFG::SpeculativeJIT::branchDoubleNonZero):
2740         (JSC::DFG::SpeculativeJIT::branch32):
2741         (JSC::DFG::SpeculativeJIT::branchTest32):
2742         (JSC::DFG::SpeculativeJIT::branch64):
2743         (JSC::DFG::SpeculativeJIT::branch8):
2744         (JSC::DFG::SpeculativeJIT::branchPtr):
2745         (JSC::DFG::SpeculativeJIT::branchTestPtr):
2746         (JSC::DFG::SpeculativeJIT::branchTest8):
2747         (JSC::DFG::SpeculativeJIT::jump):
2748         (JSC::DFG::SpeculativeJIT::addBranch):
2749         (JSC::DFG::SpeculativeJIT::StringSwitchCase::StringSwitchCase):
2750         (StringSwitchCase):
2751         (JSC::DFG::SpeculativeJIT::BranchRecord::BranchRecord):
2752         (BranchRecord):
2753         * dfg/DFGSpeculativeJIT32_64.cpp:
2754         (JSC::DFG::SpeculativeJIT::nonSpeculativePeepholeBranchNull):
2755         (JSC::DFG::SpeculativeJIT::nonSpeculativeCompareNull):
2756         (JSC::DFG::SpeculativeJIT::nonSpeculativePeepholeBranch):
2757         (JSC::DFG::SpeculativeJIT::nonSpeculativePeepholeStrictEq):
2758         (JSC::DFG::SpeculativeJIT::compilePeepHoleObjectToObjectOrOtherEquality):
2759         (JSC::DFG::SpeculativeJIT::emitObjectOrOtherBranch):
2760         (JSC::DFG::SpeculativeJIT::emitBranch):
2761         (JSC::DFG::SpeculativeJIT::compile):
2762         * dfg/DFGSpeculativeJIT64.cpp:
2763         (JSC::DFG::SpeculativeJIT::nonSpeculativePeepholeBranchNull):
2764         (JSC::DFG::SpeculativeJIT::nonSpeculativeCompareNull):
2765         (JSC::DFG::SpeculativeJIT::nonSpeculativePeepholeBranch):
2766         (JSC::DFG::SpeculativeJIT::nonSpeculativePeepholeStrictEq):
2767         (JSC::DFG::SpeculativeJIT::compilePeepHoleObjectToObjectOrOtherEquality):
2768         (JSC::DFG::SpeculativeJIT::emitObjectOrOtherBranch):
2769         (JSC::DFG::SpeculativeJIT::emitBranch):
2770         (JSC::DFG::SpeculativeJIT::compile):
2771         * dfg/DFGTypeCheckHoistingPhase.cpp:
2772         (JSC::DFG::TypeCheckHoistingPhase::run):
2773         (JSC::DFG::TypeCheckHoistingPhase::identifyRedundantStructureChecks):
2774         (JSC::DFG::TypeCheckHoistingPhase::identifyRedundantArrayChecks):
2775         (JSC::DFG::TypeCheckHoistingPhase::disableHoistingAcrossOSREntries):
2776         * dfg/DFGUnificationPhase.cpp:
2777         (JSC::DFG::UnificationPhase::run):
2778         * dfg/DFGValidate.cpp:
2779         (JSC::DFG::Validate::validate):
2780         (JSC::DFG::Validate::checkOperand):
2781         (JSC::DFG::Validate::reportValidationContext):
2782         * dfg/DFGVirtualRegisterAllocationPhase.cpp:
2783         (JSC::DFG::VirtualRegisterAllocationPhase::run):
2784         * ftl/FTLCapabilities.cpp:
2785         (JSC::FTL::canCompile):
2786         * ftl/FTLLowerDFGToLLVM.cpp:
2787         (JSC::FTL::LowerDFGToLLVM::LowerDFGToLLVM):
2788         (JSC::FTL::LowerDFGToLLVM::lower):
2789         (JSC::FTL::LowerDFGToLLVM::compileBlock):
2790         (JSC::FTL::LowerDFGToLLVM::compileJump):
2791         (JSC::FTL::LowerDFGToLLVM::compileBranch):
2792         (JSC::FTL::LowerDFGToLLVM::lowBlock):
2793
2794 2013-07-04  Filip Pizlo  <fpizlo@apple.com>
2795
2796         Unreviewed, add a helpful comment for why DCE is needed in the FTL.
2797
2798         I believe I've now twice down the experiment of disabling DCE in the FTL,
2799         only to realize that this can't work, and that DCE is needed. I'd kind of
2800         like to not make that mistake again.
2801
2802         * dfg/DFGPlan.cpp:
2803         (JSC::DFG::Plan::compileInThreadImpl):
2804
2805 2013-07-02  Filip Pizlo  <fpizlo@apple.com>
2806
2807         fourthTier: DFG::Node::m_opInfo2 should also be a uintptr_t
2808         https://bugs.webkit.org/show_bug.cgi?id=118340
2809
2810         Reviewed by Sam Weinig.
2811
2812         * dfg/DFGNode.h:
2813         (JSC::DFG::Node::Node):
2814
2815 2013-07-02  Filip Pizlo  <fpizlo@apple.com>
2816
2817         Unreviewed, fix 32-bit build.
2818
2819         * assembler/MacroAssembler.h:
2820         (JSC::MacroAssembler::comparePtr):
2821         (MacroAssembler):
2822         * dfg/DFGBinarySwitch.cpp:
2823         (JSC::DFG::BinarySwitch::advance):
2824         * dfg/DFGBinarySwitch.h:
2825         (JSC::DFG::BinarySwitch::caseValue):
2826
2827 2013-07-02  Filip Pizlo  <fpizlo@apple.com>
2828
2829         fourthTier: Have fewer Arrayify's
2830         https://bugs.webkit.org/show_bug.cgi?id=118335
2831
2832         Reviewed by Mark Hahnenberg.
2833         
2834         A lot of Arrayify's arise because some program saw Int32 arrays early on in
2835         execution, but then they all got converted to Double arrays and the program
2836         will never see Int32 arrays ever again. Prior to this change you would always
2837         have an Arrayify in this case. But with this change, the first time that an
2838         ArrayProfile is about to go polymorphic in computeUpdatedPrediction(), it
2839         instead forcibly monomorphises itself to the latest-seen structure.
2840         Thereafter it will never again perform this monomorphisation. This is
2841         controlled by ArrayProfile::m_didPerformFirstRunPruning. This is a 5%
2842         speed-up on Kraken/imaging-gaussian-blur with the FTL enabled, and it
2843         unblocks a bunch of stuff we want to do in the future because it makes a
2844         bunch of loops effect-free.
2845         
2846         We will still want to implement Arrayify hoisting in the future, but this is
2847         great anyway because it's better to not have Arrayifications than it is to
2848         have hoisted Arrayifications.
2849
2850         * bytecode/ArrayProfile.cpp:
2851         (JSC::ArrayProfile::computeUpdatedPrediction):
2852         (JSC::ArrayProfile::briefDescription):
2853         (JSC):
2854         (JSC::ArrayProfile::briefDescriptionWithoutUpdating):
2855         * bytecode/ArrayProfile.h:
2856         (JSC::ArrayProfile::ArrayProfile):
2857         (ArrayProfile):
2858
2859 2013-07-02  Filip Pizlo  <fpizlo@apple.com>
2860
2861         fourthTier: add option to disable OSR entry in loops
2862         https://bugs.webkit.org/show_bug.cgi?id=118329
2863
2864         Reviewed by Mark Hahnenberg.
2865         
2866         This adds that option, and also makes the OSR exit reoptimization trigger rely less on
2867         OSR entry failing. Now even if we never attempt OSR entry but our execution counter gets
2868         high after a small number of OSR exits, we will recompile.
2869
2870         * dfg/DFGOSRExitCompilerCommon.cpp:
2871         (JSC::DFG::handleExitCounts):
2872         * dfg/DFGOperations.cpp:
2873         * jit/JITOpcodes.cpp:
2874         (JSC::JIT::emit_op_loop_hint):
2875         (JSC::JIT::emitSlow_op_loop_hint):
2876         * runtime/Options.h:
2877         (JSC):
2878
2879 2013-07-02  Filip Pizlo  <fpizlo@apple.com>
2880
2881         fourthTier: since the FTL disassembly hacks cannot distinguish between code and data, the LLVM disassembler symbol table callback should be able to deal gracefully with arbitrary garbage
2882         https://bugs.webkit.org/show_bug.cgi?id=118313
2883
2884         Reviewed by Mark Hahnenberg.
2885         
2886         Give it a mode where we can still crash on unrecognized reference types, so that we might
2887         implement them in the future, but by default just print some stuff and keep going.
2888
2889         * disassembler/LLVMDisassembler.cpp:
2890         (JSC):
2891         (JSC::symbolLookupCallback):
2892
2893 2013-07-02  Filip Pizlo  <fpizlo@apple.com>
2894
2895         fourthTier: FTL should use the equivalent of llvm opt -O2 by default
2896         https://bugs.webkit.org/show_bug.cgi?id=118311
2897
2898         Reviewed by Mark Hahnenberg.
2899         
2900         Use a PassManagerBuilder instead of rolling our own.
2901         
2902         This boosts our speed-up by another 5% or so.
2903
2904         * ftl/FTLCompile.cpp:
2905         (JSC::FTL::compile):
2906         * runtime/Options.h:
2907         (JSC):
2908
2909 2013-07-01  Filip Pizlo  <fpizlo@apple.com>
2910
2911         fourthTier: FTL should run LICM after AA setup
2912         https://bugs.webkit.org/show_bug.cgi?id=118277
2913
2914         Reviewed by Maciej Stachowiak.
2915         
2916         LICM queries alias analysis. Hence, just like GVN, it should run after
2917         we have set up the alias analysis.
2918
2919         * ftl/FTLCompile.cpp:
2920         (JSC::FTL::compile):
2921
2922 2013-07-01  Filip Pizlo  <fpizlo@apple.com>
2923
2924         fourthTier: FTL should run AA passes before GVN
2925         https://bugs.webkit.org/show_bug.cgi?id=118276
2926
2927         Rubber stamped by Geoffrey Garen.
2928         
2929         These enable load elimination in GVN.
2930         
2931         Immediately gives us a speed-up on a bunch of benchmarks I hacked to run
2932         properly in the FTL. One example is 20% on imaging-gaussian-blur. (Fair
2933         warning: the stock version of that benchmark won't see speed-ups -
2934         probably slow-downs instead - because the FTL can't do OSR entry yet.)
2935         Another example is the findGraphNode function, which now sees a 7%
2936         speed-up, and that's without even doing LICM or other good things.
2937
2938         * ftl/FTLCompile.cpp:
2939         (JSC::FTL::compile):
2940
2941 2013-06-27  Filip Pizlo  <fpizlo@apple.com>
2942
2943         Make Graph::substituteGetLocal() out-of-line
2944
2945         Rubber stamped by Geoffrey Garen.
2946
2947         * dfg/DFGGraph.cpp:
2948         (JSC::DFG::Graph::substituteGetLocal):
2949         (DFG):
2950         * dfg/DFGGraph.h:
2951         (Graph):
2952
2953 2013-06-27  Filip Pizlo  <fpizlo@apple.com>
2954
2955         fourthTier: DFG should know how to find natural loops
2956         https://bugs.webkit.org/show_bug.cgi?id=118152
2957
2958         Reviewed by Mark Hahnenberg.
2959         
2960         There are a bunch of things we can do when we know where the loops are.
2961         Previously we didn't. With this patch, we do.
2962         
2963         This patch adds the classic dominator based natural loop finder.
2964         
2965         The only client of this right now is the DFG::Disassembler. It prints out
2966         a summary of the analysis for each block.
2967         
2968         This will become more important when I do
2969         https://bugs.webkit.org/show_bug.cgi?id=118151, which definitely requires
2970         this kind of analysis, at least if we want to do the optimization over
2971         DFG IR (and I'm pretty sure we do).
2972
2973         * JavaScriptCore.xcodeproj/project.pbxproj:
2974         * dfg/DFGAnalysis.h: Added.
2975         (DFG):
2976         (Analysis):
2977         (JSC::DFG::Analysis::Analysis):
2978         (JSC::DFG::Analysis::invalidate):
2979         (JSC::DFG::Analysis::computeIfNecessary):
2980         (JSC::DFG::Analysis::isValid):
2981         * dfg/DFGCFGSimplificationPhase.cpp:
2982         (JSC::DFG::CFGSimplificationPhase::run):
2983         * dfg/DFGDisassembler.cpp:
2984         (JSC::DFG::Disassembler::createDumpList):
2985         * dfg/DFGDominators.cpp:
2986         (JSC::DFG::Dominators::Dominators):
2987         (JSC::DFG::Dominators::compute):
2988         * dfg/DFGDominators.h:
2989         (Dominators):
2990         * dfg/DFGGraph.cpp:
2991         (JSC::DFG::Graph::dumpBlockHeader):
2992         (JSC::DFG::Graph::invalidateCFG):
2993         (DFG):
2994         * dfg/DFGGraph.h:
2995         (Graph):
2996         * dfg/DFGNaturalLoops.cpp: Added.
2997         (DFG):
2998         (JSC::DFG::NaturalLoop::dump):
2999         (JSC::DFG::NaturalLoops::NaturalLoops):
3000         (JSC::DFG::NaturalLoops::~NaturalLoops):
3001         (JSC::DFG::NaturalLoops::compute):
3002         (JSC::DFG::NaturalLoops::loopsOf):
3003         (JSC::DFG::NaturalLoops::dump):
3004         * dfg/DFGNaturalLoops.h: Added.
3005         (DFG):
3006         (NaturalLoop):
3007         (JSC::DFG::NaturalLoop::NaturalLoop):
3008         (JSC::DFG::NaturalLoop::addBlock):
3009         (JSC::DFG::NaturalLoop::header):
3010         (JSC::DFG::NaturalLoop::size):
3011         (JSC::DFG::NaturalLoop::at):
3012         (JSC::DFG::NaturalLoop::operator[]):
3013         (JSC::DFG::NaturalLoop::contains):
3014         (NaturalLoops):
3015         (JSC::DFG::NaturalLoops::numLoops):
3016         (JSC::DFG::NaturalLoops::loop):
3017         (JSC::DFG::NaturalLoops::headerOf):
3018
3019 2013-06-27  Filip Pizlo  <fpizlo@apple.com>
3020
3021         fourthTier: JSC's disassembly infrastructure should be able to disassemble the code that LLVM generates
3022         https://bugs.webkit.org/show_bug.cgi?id=118148
3023
3024         Reviewed by Anders Carlsson.
3025         
3026         Oh boy. UDis86 cannot disassemble the AVX (or whatever it's called) stuff
3027         that LLVM generates for floating point. So the right decision is to
3028         switch to the LLVM disassembler, right? Wrong!! LLVM's disassembler
3029         cannot disassemble the load-from-absolute-address-into-%rax instructions
3030         that our JIT generates quite a lot of.
3031         
3032         So, this keeps the UDis86 disassembler, but adds the LLVM disassembler,
3033         and requires the caller of disassemble() to hint which one is likely to
3034         be less wrong for the given code.
3035         
3036         Maybe in the future LLVM will catch up to UDis86, but it's definitely not
3037         there right now.
3038         
3039         This now allows us to disassemble all of the code that LLVM generates.
3040
3041         * JavaScriptCore.xcodeproj/project.pbxproj:
3042         * disassembler/Disassembler.cpp:
3043         (JSC::disassemble):
3044         * disassembler/Disassembler.h:
3045         (JSC::tryToDisassemble):
3046         (JSC):
3047         * disassembler/LLVMDisassembler.cpp: Added.
3048         (JSC):
3049         (JSC::symbolLookupCallback):
3050         (JSC::tryToDisassembleWithLLVM):
3051         * disassembler/LLVMDisassembler.h: Added.
3052         (JSC):
3053         (JSC::tryToDisassembleWithLLVM):
3054         * disassembler/UDis86Disassembler.cpp:
3055         (JSC::tryToDisassembleWithUDis86):
3056         * disassembler/UDis86Disassembler.h: Added.
3057         (JSC):
3058         (JSC::tryToDisassembleWithUDis86):
3059         * disassembler/X86Disassembler.cpp: Added.
3060         (JSC):
3061         (JSC::tryToDisassemble):
3062         * ftl/FTLAbbreviatedTypes.h:
3063         * ftl/FTLCompile.cpp:
3064         (JSC::FTL::compile):
3065         * ftl/FTLJITCode.h:
3066         * ftl/FTLJITFinalizer.h:
3067         * ftl/FTLLLVMHeaders.h: Removed.
3068         * ftl/FTLLink.cpp:
3069         * runtime/InitializeThreading.cpp:
3070         (JSC::initializeThreadingOnce):
3071         * runtime/Options.h:
3072         (JSC):
3073
3074 2013-06-27  Filip Pizlo  <fpizlo@apple.com>
3075
3076         fourthTier: FTL should be able to dump disassembly
3077         https://bugs.webkit.org/show_bug.cgi?id=118141
3078
3079         Reviewed by Geoffrey Garen.
3080
3081         * ftl/FTLCompile.cpp:
3082         (JSC::FTL::compile):
3083
3084 2013-06-27  Filip Pizlo  <fpizlo@apple.com>
3085
3086         Unreviewed, fix build for LLVM ToT.
3087
3088         This doesn't affect those using the binary drops, but if you're building from
3089         LLVM ToT you'll get link errors. These arise because we expect there to be a
3090         libLLVMArchive, but that is no longer built by LLVM ToT. This casues the linker
3091         to fall back on the system's libLLVMArchive, which is incompatible with the
3092         other LLVM libs we pull in.
3093         
3094         Also, we didn't need that library anyway and shouldn't have been linking
3095         against it.
3096
3097         * Configurations/JavaScriptCore.xcconfig:
3098
3099 2013-06-26  Filip Pizlo  <fpizlo@apple.com>
3100
3101         fourthTier: FTL should support hole/OOB PutByVal's
3102         https://bugs.webkit.org/show_bug.cgi?id=118112
3103
3104         Reviewed by Geoffrey Garen.
3105         
3106         Added a common code generator for the out-of-bounds case that is reused by
3107         all contiguous-like arrays (Int32, Double, Contiguous).
3108         
3109         This is relatively straight-forward, except that it's the first time that
3110         the FTL has to call DFG operations that take more than two arguments.
3111
3112         * ftl/FTLAbbreviations.h:
3113         (JSC::FTL::functionType):
3114         (JSC::FTL::buildCall):
3115         * ftl/FTLAbstractHeapRepository.h:
3116         (FTL):
3117         * ftl/FTLCapabilities.cpp:
3118         (JSC::FTL::canCompile):
3119         * ftl/FTLIntrinsicRepository.h:
3120         (FTL):
3121         * ftl/FTLLowerDFGToLLVM.cpp:
3122         (JSC::FTL::LowerDFGToLLVM::compilePutByVal):
3123         (LowerDFGToLLVM):
3124         (JSC::FTL::LowerDFGToLLVM::contiguousPutByValOutOfBounds):
3125         (JSC::FTL::LowerDFGToLLVM::vmCall):
3126         * ftl/FTLOutput.h:
3127         (JSC::FTL::Output::call):
3128
3129 2013-06-26  Filip Pizlo  <fpizlo@apple.com>
3130
3131         fourthTier: FTL::canCompile(Graph&) should not consider nodes that won't be compiled
3132         https://bugs.webkit.org/show_bug.cgi?id=118097
3133
3134         Reviewed by Mark Hahnenberg.
3135         
3136         This increases coverage to include programs that have unprofiled paths. Those paths will
3137         often have nodes that appear to do untyped speculations, and the FTL sometimes doesn't
3138         support those; except that it doesn't matter since the reason why they were untyped is
3139         that they were unprofiled and anyway we won't run them because we'll exit before them.
3140
3141         * ftl/FTLCapabilities.cpp:
3142         (JSC::FTL::canCompile):
3143
3144 2013-06-26  Filip Pizlo  <fpizlo@apple.com>
3145
3146         fourthTier: FTL should support ArrayifyToStructure
3147         https://bugs.webkit.org/show_bug.cgi?id=118095
3148
3149         Reviewed by Mark Hahnenberg.
3150
3151         * ftl/FTLCapabilities.cpp:
3152         (JSC::FTL::canCompile):
3153         * ftl/FTLIntrinsicRepository.h:
3154         (FTL):
3155         * ftl/FTLLowerDFGToLLVM.cpp:
3156         (JSC::FTL::LowerDFGToLLVM::compileNode):
3157         (JSC::FTL::LowerDFGToLLVM::compileArrayifyToStructure):
3158         (LowerDFGToLLVM):
3159
3160 2013-06-26  Filip Pizlo  <fpizlo@apple.com>
3161
3162         fourthTier: FTL should support ForwardCheckStructure/ForwardStructureTransitionWatchpoint and doing so shouldn't break V8/crypto
3163         https://bugs.webkit.org/show_bug.cgi?id=118091
3164
3165         Reviewed by Mark Hahnenberg.
3166         
3167         I was going to just add ForwardCheckStructure/ForwardStructureTransitionWatchpoint support,
3168         which is trivial. But doing so increases coverage a lot, and revealed long-standing bugs in
3169         the FTL. I then fixed those bugs, also:
3170         
3171         - The FTL should not attempt to compile a block that is not reachable according to the CFA.
3172           This is analogous to terminating basic block compilation if the CFA becomes !isValid().
3173           Attempting to compile such a block means that you're running on broken CFA state, and the
3174           CFA will become inconsistent with the code you're generating, leading to some
3175           strangeness. For example, the FTL relies on the CFA to tell it that we gave up compiling
3176           a node and hence don't have LValue's for that node (by virtue of us giving up due to
3177           !isValid()). But the CFA's isValid() bit will not be set correctly for blocks that
3178           weren't visited by the CFA at all, and the CFA expects you to know this because it
3179           expects that you already checked BasicBlock::cfaHasVisited.
3180         
3181         - SetLocal needs to change the ValueSource of the operand to indicate that its value has
3182           been stashed in the local (i.e. the "reference" corresponding to the operand in FTL
3183           speak). This is because although OSR exit already knows that the value of the operand is
3184           stored in the Node, and it already knows what LValue corresponds to the node, OSR exit
3185           will also assume that if the Node dies then the value-at-exit for that operand should be
3186           Dead (i.e. jsUndefined). But the Node dying, and the local dying, are two distinct
3187           things; in particular the local always outlives the Node in the case of a SetLocal. So,
3188           we just need to have SetLocal have the ValueSource be BlahInLocal rather than HaveNode,
3189           to ensure that OSR exit knows that the darn thing is really live until the end of the
3190           basic block, as opposed to until whenever the Node dies (which could be at any time).
3191         
3192         - PutByOffset was erroneously storing to an offset from the base object, rather than an
3193           offset from the storage. Note that the storage will be the base object (exactly - i.e.
3194           same node, same value) for inline stores, but will be a distinct thing for out-of-line
3195           stores.
3196         
3197         - At-head set-up of OSR exit state was using ValueInLocals for variables forced double,
3198           when it should have been using DoubleInLocals.
3199
3200         * ftl/FTLCapabilities.cpp:
3201         (JSC::FTL::canCompile):
3202         * ftl/FTLLowerDFGToLLVM.cpp:
3203         (JSC::FTL::LowerDFGToLLVM::compileBlock):
3204         (JSC::FTL::LowerDFGToLLVM::compileNode):
3205         (JSC::FTL::LowerDFGToLLVM::compileSetLocal):
3206         (JSC::FTL::LowerDFGToLLVM::compilePutByOffset):
3207         (JSC::FTL::LowerDFGToLLVM::initializeOSRExitStateForBlock):
3208         (JSC::FTL::LowerDFGToLLVM::addExitArgumentForNode):
3209
3210 2013-06-26  Filip Pizlo  <fpizlo@apple.com>
3211
3212         fourthTier: FTL should support PutByVal
3213         https://bugs.webkit.org/show_bug.cgi?id=118075
3214
3215         Reviewed by Mark Hahnenberg.
3216
3217         * ftl/FTLCapabilities.cpp:
3218         (JSC::FTL::canCompile):
3219         * ftl/FTLLowerDFGToLLVM.cpp:
3220         (JSC::FTL::LowerDFGToLLVM::lower):
3221         (JSC::FTL::LowerDFGToLLVM::compileNode):
3222         (JSC::FTL::LowerDFGToLLVM::compileGetByVal):
3223         (LowerDFGToLLVM):
3224         (JSC::FTL::LowerDFGToLLVM::compilePutByVal):
3225
3226 2013-06-25  Filip Pizlo  <fpizlo@apple.com>
3227
3228         fourthTier: Convert versus AsIs should have no bearing on whether we can do the SaneChain optimization for double array GetByVals
3229         https://bugs.webkit.org/show_bug.cgi?id=118028
3230
3231         Reviewed by Sam Weinig.
3232         
3233         The SaneChain optimization allows us to get rid of the NaN check on loading from
3234         a double array, if the result is used in an arithmetic op that wouldn't
3235         distinguish between NaN and undefined. Normally the NaN check would be needed
3236         because NaN is the hole marker.
3237         
3238         The SaneChain optimization definitely requires that you're an Original array,
3239         since we need to watchpoint the array prototype chain. And so it also needs to
3240         be a JSArray, and not an object that has indexed double properties. We also
3241         require an in-bounds access, since the backend is only capable of the
3242         optimization in the in-bounds case (though we could extend it to OOB in the
3243         future). But whether the array is being converted or is as-is isn't relevant.
3244         Either way, if it's a double original array in-bounds access by the time that
3245         the array check (or conversion!) completes, we can do the optimization.
3246         
3247         Ever-so-slight speed-up on Kraken/imaging-gaussian-blur.
3248
3249         * dfg/DFGFixupPhase.cpp:
3250         (JSC::DFG::FixupPhase::fixupNode):
3251
3252 2013-06-25  Filip Pizlo  <fpizlo@apple.com>
3253
3254         fourthTier: DFG should support switch_string
3255         https://bugs.webkit.org/show_bug.cgi?id=117967
3256
3257         Reviewed by Sam Weinig.
3258         
3259         Add a reusable binary switch creator.
3260         
3261         Implement switch on string using three modes:
3262         
3263         - Binary switch on StringImpl* in the case of identifiers.
3264         
3265         - Trie of binary switches on characters in the case of a not-too-big
3266           switch over not-too-big 8-bit strings.
3267         
3268         - Hash lookup if all else fails.
3269         
3270         Anywhere from a 2x to 3x speed-up on microbenchmarks that stress
3271         string switches. 25-35% speed-up on HashMap tests. 4% speed-up on
3272         pdfjs.
3273
3274         * JavaScriptCore.xcodeproj/project.pbxproj:
3275         * bytecode/JumpTable.h:
3276         (StringJumpTable):
3277         (JSC::StringJumpTable::clear):
3278         * dfg/DFGBackwardsPropagationPhase.cpp:
3279         (JSC::DFG::BackwardsPropagationPhase::propagate):
3280         * dfg/DFGBinarySwitch.cpp: Added.
3281         (DFG):
3282         (JSC::DFG::BinarySwitch::BinarySwitch):
3283         (JSC::DFG::BinarySwitch::advance):
3284         (JSC::DFG::BinarySwitch::build):
3285         * dfg/DFGBinarySwitch.h: Added.
3286         (DFG):
3287         (BinarySwitch):
3288         (JSC::DFG::BinarySwitch::caseIndex):
3289         (JSC::DFG::BinarySwitch::caseValue):
3290         (JSC::DFG::BinarySwitch::fallThrough):
3291         (JSC::DFG::BinarySwitch::Case::Case):
3292         (Case):
3293         (JSC::DFG::BinarySwitch::Case::operator<):
3294         (JSC::DFG::BinarySwitch::BranchCode::BranchCode):
3295         (BranchCode):
3296         * dfg/DFGByteCodeParser.cpp:
3297         (JSC::DFG::ByteCodeParser::parseBlock):
3298         * dfg/DFGCapabilities.cpp:
3299         (JSC::DFG::capabilityLevel):
3300         * dfg/DFGFixupPhase.cpp:
3301         (JSC::DFG::FixupPhase::fixupNode):
3302         * dfg/DFGJITCompiler.cpp:
3303         (JSC::DFG::JITCompiler::link):
3304         * dfg/DFGLazyJSValue.cpp:
3305         (JSC::DFG::LazyJSValue::getValue):
3306         (JSC::DFG::equalToStringImpl):
3307         (DFG):
3308         (JSC::DFG::LazyJSValue::strictEqual):
3309         (JSC::DFG::LazyJSValue::dump):
3310         * dfg/DFGLazyJSValue.h:
3311         (JSC::DFG::LazyJSValue::knownStringImpl):
3312         (LazyJSValue):
3313         (JSC::DFG::LazyJSValue::stringImpl):
3314         (JSC::DFG::LazyJSValue::switchLookupValue):
3315         * dfg/DFGNode.cpp:
3316         (WTF::printInternal):
3317         * dfg/DFGNode.h:
3318         * dfg/DFGOperations.cpp:
3319         * dfg/DFGOperations.h:
3320         * dfg/DFGSpeculativeJIT.cpp:
3321         (JSC::DFG::SpeculativeJIT::emitSwitchChar):
3322         (JSC::DFG::SpeculativeJIT::StringSwitchCase::operator<):
3323         (DFG):
3324         (JSC::DFG::SpeculativeJIT::emitBinarySwitchStringRecurse):
3325         (JSC::DFG::SpeculativeJIT::emitSwitchStringOnString):
3326         (JSC::DFG::SpeculativeJIT::emitSwitchString):
3327         (JSC::DFG::SpeculativeJIT::emitSwitch):
3328         (JSC::DFG::SpeculativeJIT::addBranch):
3329         * dfg/DFGSpeculativeJIT.h:
3330         (JSC::DFG::SpeculativeJIT::callOperation):
3331         (JSC::DFG::SpeculativeJIT::branch8):
3332         (SpeculativeJIT):
3333         (JSC::DFG::SpeculativeJIT::StringSwitchCase::StringSwitchCase):
3334         (StringSwitchCase):
3335         * ftl/FTLLowerDFGToLLVM.cpp:
3336         (JSC::FTL::LowerDFGToLLVM::compileSwitch):
3337         * runtime/Options.h:
3338         (JSC):
3339
3340 2013-06-24  Filip Pizlo  <fpizlo@apple.com>
3341
3342         fourthTier: Count external memory usage towards heap footprint
3343         https://bugs.webkit.org/show_bug.cgi?id=117948
3344
3345         Reviewed by Geoffrey Garen.
3346
3347         Currently just count strings. Strings get counted in such a way that we won't re-count strings
3348         that are aliased, by dividing by the reference count. This then ups the GC footprint and allows
3349         the collector to appropriately amortize itself.
3350
3351         * heap/Heap.cpp:
3352         (JSC::Heap::Heap):
3353         (JSC::Heap::size):
3354         (JSC::Heap::collect):
3355         * heap/Heap.h:
3356         (Heap):
3357         * heap/SlotVisitor.h:
3358         * heap/SlotVisitorInlines.h:
3359         (JSC::SlotVisitor::reportExtraMemoryUsage):
3360         (JSC):
3361         * runtime/JSString.cpp:
3362         (JSC::JSString::visitChildren):
3363
3364 2013-06-23  Filip Pizlo  <fpizlo@apple.com>
3365
3366         fourthTier: DFG should optimize identifier string equality
3367         https://bugs.webkit.org/show_bug.cgi?id=117920
3368
3369         Reviewed by Sam Weinig.
3370         
3371         This is a 20% speed-up for string equality comparisons when both strings are
3372         identifiers.
3373         
3374         This is important for two reasons:
3375         
3376         1) Using strings as enumerations is an idiom. A great example is typeof. It
3377            would be great if this performed better.
3378         
3379         2) When I implement switch_string in the DFG, it would be great to optimize
3380            the case where the switched-on value is an identifier. That would involve
3381            a simple binary switch rather than a more complicated trie-switch over
3382            characters.
3383
3384         * bytecode/SpeculatedType.cpp:
3385         (JSC::dumpSpeculation):
3386         (JSC::speculationToAbbreviatedString):
3387         (JSC::speculationFromCell):
3388         * bytecode/SpeculatedType.h:
3389         (JSC):
3390         (JSC::isStringIdentSpeculation):
3391         (JSC::isStringSpeculation):
3392         * dfg/DFGAbstractState.cpp:
3393         (JSC::DFG::AbstractState::executeEffects):
3394         * dfg/DFGFixupPhase.cpp:
3395         (JSC::DFG::FixupPhase::fixupNode):
3396         * dfg/DFGNode.h:
3397         (JSC::DFG::Node::shouldSpeculateStringIdent):
3398         (Node):
3399         * dfg/DFGSpeculativeJIT.cpp:
3400         (JSC::DFG::SpeculativeJIT::compilePeepHoleBranch):
3401         (JSC::DFG::SpeculativeJIT::compare):
3402         (JSC::DFG::SpeculativeJIT::compileStrictEq):
3403         (JSC::DFG::SpeculativeJIT::compileStringEquality):
3404         (JSC::DFG::SpeculativeJIT::compileStringIdentEquality):
3405         (DFG):
3406         (JSC::DFG::SpeculativeJIT::speculateString):
3407         (JSC::DFG::SpeculativeJIT::speculateStringIdentAndLoadStorage):
3408         (JSC::DFG::SpeculativeJIT::speculateStringIdent):
3409         (JSC::DFG::SpeculativeJIT::speculate):
3410         * dfg/DFGSpeculativeJIT.h:
3411         (SpeculativeJIT):
3412         * dfg/DFGUseKind.cpp:
3413         (WTF::printInternal):
3414         * dfg/DFGUseKind.h:
3415         (JSC::DFG::typeFilterFor):
3416         (JSC::DFG::isCell):
3417
3418 2013-06-22  Filip Pizlo  <fpizlo@apple.com>
3419
3420         fourthTier: DFG shouldn't exit just because a String GetByVal went out-of-bounds
3421         https://bugs.webkit.org/show_bug.cgi?id=117906
3422
3423         Reviewed by Mark Hahnenberg.
3424         
3425         This does the obvious thing, but also makes sure that out-of-bounds accesses
3426         don't fall off into a C call, but try to do the fast thing if the prototype
3427         chain is sane. We ought to probably do this for other array accesses in the
3428         future, as well, since it's so darn easy.
3429
3430         * dfg/DFGAbstractState.cpp:
3431         (JSC::DFG::AbstractState::executeEffects):
3432         * dfg/DFGFixupPhase.cpp:
3433         (JSC::DFG::FixupPhase::fixupNode):
3434         * dfg/DFGOperations.cpp:
3435         * dfg/DFGOperations.h:
3436         * dfg/DFGSpeculativeJIT.cpp:
3437         (JSC::DFG::SpeculativeJIT::compileGetByValOnString):
3438         * dfg/DFGSpeculativeJIT.h:
3439         (JSC::DFG::SpeculativeJIT::callOperation):
3440         * runtime/JSGlobalObject.cpp:
3441         (JSC::JSGlobalObject::objectPrototypeIsSane):
3442         (JSC):
3443         (JSC::JSGlobalObject::arrayPrototypeChainIsSane):
3444         (JSC::JSGlobalObject::stringPrototypeChainIsSane):
3445         * runtime/JSGlobalObject.h:
3446         (JSGlobalObject):
3447
3448 2013-06-22  Filip Pizlo  <fpizlo@apple.com>
3449
3450         fourthTier: GC's put_by_id transition fixpoint should converge more quickly
3451         https://bugs.webkit.org/show_bug.cgi?id=117912
3452
3453         Reviewed by Mark Hahnenberg.
3454
3455         This was a rookie mistake. The GC does a classic forward data flow fixpoint. These work well so long as you
3456         iterate the program in program order, or at least something close to program order. Because I enjoy reverse
3457         loops ("while (n--) blah"), I ended up iterating in *reverse* of program order which ensured worst-case
3458         pathologies every single time. And unsurprisingly, this slowed down a program, namely pdfjs.
3459
3460         Flipping the loops to iterate forward fixes a 90% regression in Octane/pdfjs and is otherwise neutral.
3461
3462         * bytecode/CodeBlock.cpp:
3463         (JSC::CodeBlock::propagateTransitions):
3464
3465 2013-06-21  Filip Pizlo  <fpizlo@apple.com>
3466
3467         fourthTier: DFG should CSE MakeRope
3468         https://bugs.webkit.org/show_bug.cgi?id=117905
3469
3470         Reviewed by Geoffrey Garen.
3471         
3472         Adds MakeRope to the CSE phase and removes the comment that says that
3473         we could do it but aren't doing it.
3474         
3475         Also fixed SpeculatedType dumping so that if you have a Cell type then
3476         it just prints "Cell" and if you just have Object then it just prints
3477         "Object", instead of printing the long list of types.
3478
3479         * bytecode/SpeculatedType.cpp:
3480         (JSC::dumpSpeculation):
3481         * dfg/DFGCSEPhase.cpp:
3482         (JSC::DFG::CSEPhase::performNodeCSE):
3483
3484 2013-06-21  Filip Pizlo  <fpizlo@apple.com>
3485
3486         fourthTier: DFG should't exit just because it GetByVal'd a big character
3487         https://bugs.webkit.org/show_bug.cgi?id=117899
3488
3489         Reviewed by Mark Hahnenberg.
3490         
3491         Add a slow path. Also clarify handling of GetByVal in PutStructure elimination.
3492         Previously it would fail due to canExit() but now we can also fail because
3493         GetByVal(String) can allocate. Just make it so GetByVal is totally poisoned, in
3494         a very explicit way.
3495
3496         * dfg/DFGCSEPhase.cpp:
3497         (JSC::DFG::CSEPhase::putStructureStoreElimination):
3498         * dfg/DFGOperations.cpp:
3499         * dfg/DFGOperations.h:
3500         * dfg/DFGSpeculativeJIT.cpp:
3501         (JSC::DFG::SpeculativeJIT::compileGetByValOnString):
3502         * dfg/DFGSpeculativeJIT.h:
3503         (JSC::DFG::SpeculativeJIT::callOperation):
3504         (SpeculativeJIT):
3505
3506 2013-06-21  Filip Pizlo  <fpizlo@apple.com>
3507
3508         fourthTier: Small strings shouldn't get GC'd
3509         https://bugs.webkit.org/show_bug.cgi?id=117897
3510
3511         Reviewed by Mark Hahnenberg.
3512         
3513         Kill off the code needed to allocate them lazily and finalize them.
3514
3515         * dfg/DFGSpeculativeJIT.cpp:
3516         (JSC::DFG::SpeculativeJIT::compileGetByValOnString):
3517         * heap/Heap.cpp:
3518         (JSC::Heap::collect):
3519         * runtime/JSString.h:
3520         (JSC::jsSingleCharacterString):
3521         (JSC::jsSingleCharacterSubstring):
3522         (JSC::jsString):
3523         (JSC::jsSubstring8):
3524         (JSC::jsSubstring):
3525         (JSC::jsOwnedString):
3526         * runtime/NumberPrototype.cpp:
3527         (JSC::integerValueToString):
3528         * runtime/SmallStrings.cpp:
3529         (JSC):
3530         (JSC::SmallStrings::initializeCommonStrings):
3531         (JSC::SmallStrings::visitStrongReferences):
3532         * runtime/SmallStrings.h:
3533         (JSC::SmallStrings::singleCharacterString):
3534         (SmallStrings):
3535
3536 2013-06-20  Filip Pizlo  <fpizlo@apple.com>
3537
3538         fourthTier: Structure should have a dump()
3539         https://bugs.webkit.org/show_bug.cgi?id=117859
3540
3541         Reviewed by Geoffrey Garen.
3542         
3543         This is pretty cool. Anywhere we previously printed Structure pointers in dumps,
3544         we now print a bunch of other info as well. For example, for an object literal
3545         like "{f:42, g:64, h:24}", when we print the structure we'll now get:
3546
3547             0x107a0af80:[Object, {f:0, g:1, h:2}, NonArray, Proto:0x107a8fff0]
3548         
3549         This also changes a bunch of places to use the dump method.
3550
3551         * bytecode/StructureSet.h:
3552         (JSC::StructureSet::dump):
3553         * dfg/DFGGraph.cpp:
3554         (JSC::DFG::Graph::dump):
3555         * dfg/DFGStructureAbstractValue.h:
3556         (JSC::DFG::StructureAbstractValue::dump):
3557         * runtime/JSCJSValue.cpp:
3558         (JSC::JSValue::dump):
3559         * runtime/Structure.cpp:
3560         (JSC::Structure::dump):
3561         (JSC):
3562         * runtime/Structure.h:
3563         (Structure):
3564
3565 2013-06-20  Filip Pizlo  <fpizlo@apple.com>
3566
3567         fourthTier: There should only be one table of SimpleJumpTables
3568         https://bugs.webkit.org/show_bug.cgi?id=117856
3569
3570         Reviewed by Geoffrey Garen.
3571         
3572         Having multiple tables of SimpleJumpTables just means we have to duplicate a
3573         ton of code. This patch deduplicates all of it.
3574
3575         * bytecode/CodeBlock.cpp:
3576         (JSC::CodeBlock::dumpBytecode):
3577         (JSC):
3578         (JSC::CodeBlock::CodeBlock):
3579         (JSC::CodeBlock::shrinkToFit):
3580         * bytecode/CodeBlock.h:
3581         (JSC::CodeBlock::numberOfSwitchJumpTables):
3582         (JSC::CodeBlock::addSwitchJumpTable):
3583         (JSC::CodeBlock::switchJumpTable):
3584         (JSC::CodeBlock::clearSwitchJumpTables):
3585         (RareData):
3586         * bytecode/PreciseJumpTargets.cpp:
3587         (JSC):
3588         (JSC::computePreciseJumpTargets):
3589         * bytecode/UnlinkedCodeBlock.h:
3590         (JSC::UnlinkedCodeBlock::shrinkToFit):
3591         (JSC::UnlinkedCodeBlock::numberOfSwitchJumpTables):
3592         (JSC::UnlinkedCodeBlock::addSwitchJumpTable):
3593         (JSC::UnlinkedCodeBlock::switchJumpTable):
3594         (RareData):
3595         * bytecompiler/BytecodeGenerator.cpp:
3596         (JSC):
3597         (JSC::prepareJumpTableForSwitch):
3598         (JSC::BytecodeGenerator::endSwitch):
3599         * dfg/DFGByteCodeParser.cpp:
3600         (InlineStackEntry):
3601         (JSC::DFG::ByteCodeParser::parseBlock):
3602         (JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
3603         * dfg/DFGJITCompiler.cpp:
3604         (JSC::DFG::JITCompiler::link):
3605         * dfg/DFGJITCompiler.h:
3606         (JITCompiler):
3607         * dfg/DFGOperations.cpp:
3608         * dfg/DFGSpeculativeJIT.cpp:
3609         (JSC::DFG::SpeculativeJIT::emitSwitchIntJump):
3610         (DFG):
3611         (JSC::DFG::SpeculativeJIT::emitSwitchImm):
3612         (JSC::DFG::SpeculativeJIT::emitSwitchCharStringJump):
3613         * dfg/DFGSpeculativeJIT.h:
3614         (SpeculativeJIT):
3615         * ftl/FTLLink.cpp:
3616         (JSC::FTL::link):
3617         * jit/JITOpcodes.cpp:
3618         (JSC::JIT::emit_op_switch_imm):
3619         (JSC::JIT::emit_op_switch_char):
3620         * jit/JITOpcodes32_64.cpp:
3621         (JSC::JIT::emit_op_switch_imm):
3622         (JSC::JIT::emit_op_switch_char):
3623         * jit/JITStubs.cpp:
3624         (JSC::DEFINE_STUB_FUNCTION):
3625         * llint/LLIntSlowPaths.cpp:
3626         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
3627         * llint/LowLevelInterpreter32_64.asm:
3628         * llint/LowLevelInterpreter64.asm:
3629
3630 2013-06-20  Filip Pizlo  <fpizlo@apple.com>
3631
3632         fourthTier: FTL should clear character switch jump tables
3633         https://bugs.webkit.org/show_bug.cgi?id=117852
3634
3635         Reviewed by Sam Weinig.
3636         
3637         The FTL just uses LLVM's switch, which results in LLVM allocating its own switch
3638         jump tables as needed.
3639
3640         * bytecode/CodeBlock.h:
3641         (JSC::CodeBlock::clearCharacterSwitchJumpTables):
3642         * ftl/FTLLink.cpp:
3643         (JSC::FTL::link):
3644
3645 2013-06-20  Filip Pizlo  <fpizlo@apple.com>
3646
3647         fourthTier: FTL should support SwitchChar
3648         https://bugs.webkit.org/show_bug.cgi?id=117849
3649
3650         Reviewed by Geoffrey Garen.
3651         
3652         This adds Switch(SwitchChar) to the FTL and also implicitly does some other things.
3653         SwitchChar requires calling a slow path to resolve ropes. Previously the FTL had no
3654         support for calling slow paths, and we avoided adding coverage that would require
3655         that. Well, this patch adds the ability to call slow paths and just uses that for
3656         resolving ropes for SwitchChar. Also SwitchChar required adding awareness of strings,
3657         so I did that, too.
3658
3659         * bytecode/CodeBlock.h:
3660         (CodeBlock):
3661         (JSC::CodeBlock::addCodeOrigin):
3662         * dfg/DFGBackwardsPropagationPhase.cpp:
3663         (JSC::DFG::BackwardsPropagationPhase::propagate):
3664         * dfg/DFGGraph.cpp:
3665         (JSC::DFG::Graph::dump):
3666         * dfg/DFGNode.cpp:
3667         (WTF):
3668         (WTF::printInternal):
3669         * dfg/DFGNode.h:
3670         (WTF):
3671         * dfg/DFGOperations.h:
3672         * dfg/DFGSpeculativeJIT.h:
3673         (JSC::DFG::SpeculativeJIT::callOperation):
3674         * ftl/FTLAbbreviations.h:
3675         (JSC::FTL::int16Type):
3676         (JSC::FTL::constInt):
3677         * ftl/FTLAbstractHeapRepository.h:
3678         (FTL):
3679         * ftl/FTLCapabilities.cpp:
3680         (JSC::FTL::canCompile):
3681         * ftl/FTLCommonValues.cpp:
3682         (JSC::FTL::CommonValues::CommonValues):
3683         * ftl/FTLCommonValues.h:
3684         (CommonValues):
3685         * ftl/FTLIntrinsicRepository.cpp:
3686         (JSC::FTL::IntrinsicRepository::IntrinsicRepository):
3687         (FTL):
3688         * ftl/FTLIntrinsicRepository.h:
3689         (FTL):
3690         (IntrinsicRepository):
3691         * ftl/FTLLowerDFGToLLVM.cpp:
3692         (JSC::FTL::LowerDFGToLLVM::lower):
3693         (JSC::FTL::LowerDFGToLLVM::transferAndCheckArguments):
3694         (JSC::FTL::LowerDFGToLLVM::compileJump):
3695         (JSC::FTL::LowerDFGToLLVM::compileBranch):
3696         (JSC::FTL::LowerDFGToLLVM::compileSwitch):
3697         (JSC::FTL::LowerDFGToLLVM::buildSwitch):
3698         (LowerDFGToLLVM):
3699         (JSC::FTL::LowerDFGToLLVM::lowString):
3700         (JSC::FTL::LowerDFGToLLVM::speculate):
3701         (JSC::FTL::LowerDFGToLLVM::isObject):
3702         (JSC::FTL::LowerDFGToLLVM::isNotString):
3703         (JSC::FTL::LowerDFGToLLVM::isString):
3704         (JSC::FTL::LowerDFGToLLVM::isNotObject):
3705         (JSC::FTL::LowerDFGToLLVM::speculateObject):
3706         (JSC::FTL::LowerDFGToLLVM::speculateString):
3707         (JSC::FTL::LowerDFGToLLVM::speculateNonNullObject):
3708         (JSC::FTL::LowerDFGToLLVM::vmCall):
3709         (JSC::FTL::LowerDFGToLLVM::callPreflight):
3710         (JSC::FTL::LowerDFGToLLVM::callCheck):
3711         (JSC::FTL::LowerDFGToLLVM::lowBlock):
3712         * ftl/FTLOutput.h:
3713         (JSC::FTL::Output::constBool):
3714         (JSC::FTL::Output::constInt8):
3715         (JSC::FTL::Output::constInt32):
3716         (JSC::FTL::Output::constIntPtr):
3717         (JSC::FTL::Output::constInt64):
3718         (JSC::FTL::Output::load16):
3719         (JSC::FTL::Output::isNull):
3720         (JSC::FTL::Output::notNull):
3721         (JSC::FTL::Output::testIsZero32):
3722         (JSC::FTL::Output::testNonZero32):
3723         (Output):
3724         (JSC::FTL::Output::operation):
3725         (JSC::FTL::Output::crash):
3726
3727 2013-06-18  Filip Pizlo  <fpizlo@apple.com>
3728
3729         fourthTier: DFG should have switch_char
3730         https://bugs.webkit.org/show_bug.cgi?id=117710
3731
3732         Reviewed by Michael Saboff.
3733         
3734         Add op_switch_char. Most of this is fairly simple, except for the whole
3735         LazyJSValue thing.
3736         
3737         It's long been the case that anytime you wanted the DFG to speak of a string
3738         that didn't appear in the constant pool, you would have a hard time since
3739         the DFG isn't allowed to allocate in the GC heap. For example, if you know
3740         that you want to speak of a single character string, you might find that
3741         the one you wanted to speak of had been GC'd. Another example is if you
3742         wanted to add constant folding for string concatenation - something we don't
3743         have yet but will want eventually.
3744         
3745         I solve this by finally adding the notion of LazyJSValue. In the future I
3746         anticipate using this for a variety of string-related things. The idea here
3747         is that the DFG can either say that it already knows what the value is, or
3748         it can describe the value. For example, in this patch I needed to be able to
3749         describe single-character strings.
3750
3751         * JavaScriptCore.xcodeproj/project.pbxproj:
3752         * bytecode/CodeBlock.cpp:
3753         (JSC::CodeBlock::dumpBytecode):
3754         (JSC::CodeBlock::CodeBlock):
3755         * bytecode/JumpTable.h:
3756         * dfg/DFGBackwardsPropagationPhase.cpp:
3757         (JSC::DFG::BackwardsPropagationPhase::propagate):
3758         * dfg/DFGByteCodeParser.cpp:
3759         (InlineStackEntry):
3760         (JSC::DFG::ByteCodeParser::parseBlock):
3761         (JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
3762         * dfg/DFGCFGSimplificationPhase.cpp:
3763         (JSC::DFG::CFGSimplificationPhase::run):
3764         * dfg/DFGCapabilities.cpp:
3765         (JSC::DFG::capabilityLevel):
3766         * dfg/DFGDriver.cpp:
3767         (JSC::DFG::compile):
3768         * dfg/DFGFixupPhase.cpp:
3769         (JSC::DFG::FixupPhase::fixupNode):
3770         * dfg/DFGGPRInfo.h:
3771         (JSC::DFG::JSValueRegs::payloadGPR):
3772         * dfg/DFGJITCompiler.cpp:
3773         (JSC::DFG::JITCompiler::jumpTable):
3774         (DFG):
3775         (JSC::DFG::JITCompiler::numberOfJumpTables):
3776         (JSC::DFG::JITCompiler::linkSwitches):
3777         (JSC::DFG::JITCompiler::link):
3778         * dfg/DFGJITCompiler.h:
3779         (JITCompiler):
3780         * dfg/DFGLazyJSValue.cpp: Added.
3781         (DFG):
3782         (JSC::DFG::LazyJSValue::getValue):
3783         (JSC::DFG::equalToSingleCharacter):
3784         (JSC::DFG::LazyJSValue::strictEqual):
3785         (JSC::DFG::LazyJSValue::dump):
3786         * dfg/DFGLazyJSValue.h: Added.
3787         (DFG):
3788         (LazyJSValue):
3789         (JSC::DFG::LazyJSValue::LazyJSValue):
3790         (JSC::DFG::LazyJSValue::singleCharacterString):
3791         (JSC::DFG::LazyJSValue::tryGetValue):
3792         (JSC::DFG::LazyJSValue::value):
3793         (JSC::DFG::LazyJSValue::character):
3794         (JSC::DFG::LazyJSValue::switchLookupValue):
3795         * dfg/DFGNode.h:
3796         (JSC::DFG::SwitchCase::SwitchCase):
3797         (SwitchCase):
3798         * dfg/DFGSpeculativeJIT.cpp:
3799         (JSC::DFG::SpeculativeJIT::emitSwitchIntJump):
3800         (JSC::DFG::SpeculativeJIT::emitSwitchImmIntJump):
3801         (DFG):
3802         (JSC::DFG::SpeculativeJIT::emitSwitchImm):
3803         (JSC::DFG::SpeculativeJIT::emitSwitchCharStringJump):
3804         (JSC::DFG::SpeculativeJIT::emitSwitchChar):
3805         (JSC::DFG::SpeculativeJIT::emitSwitch):
3806         * dfg/DFGSpeculativeJIT.h:
3807         (SpeculativeJIT):
3808
3809 2013-06-19  Mark Hahnenberg  <mhahnenberg@apple.com>
3810
3811         Refactor ObjCCallbackFunction to inherit directly from InternalFunction
3812         https://bugs.webkit.org/show_bug.cgi?id=117595
3813
3814         Reviewed by Geoffrey Garen.
3815
3816         * API/APICallbackFunction.h: Added. New struct that allows JSCallbackFunction and 
3817         ObjCCallbackFunction to share their host call() implementation through the magic of 
3818         templates.
3819         (JSC::APICallbackFunction::call):
3820         * API/JSCallbackFunction.cpp:
3821         (JSC::JSCallbackFunction::getCallData): Changed to get the template-ized version of 
3822         the host function.
3823         * API/JSCallbackFunction.h:
3824         * API/ObjCCallbackFunction.h: Now inherits directly from InternalFunction.
3825         * API/ObjCCallbackFunction.mm:
3826         (JSC::ObjCCallbackFunction::ObjCCallbackFunction):
3827         (JSC::ObjCCallbackFunction::getCallData): Ditto.
3828         * GNUmakefile.list.am: Build files!
3829         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
3830         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
3831         * JavaScriptCore.xcodeproj/project.pbxproj:
3832
3833 2013-06-19  Michael Saboff  <msaboff@apple.com>
3834
3835         fourthTier: Arity fixup should be done while on same stack
3836         https://bugs.webkit.org/show_bug.cgi?id=117102
3837
3838         Reviewed by Oliver Hunt.
3839
3840         Removed the fixup part of op_call_arityCheck() and op_construct_arityCheck() and moved it to
3841         a thunk for the JITs and as assembly for the llint.  This patch provides the plumbing needed to
3842         move to the C stack for JS execution.  The fixup thunk and llint code would need to be change to
3843         work with a stack that grows down when we do move to the C stack.
3844         
3845         Due to an issue with the offline assembler, I moved the const at the top of LowLevelInterpreter64.asm
3846         and LowLevelInterpreter32_64.asm to LowLevelInterpreter.asm.  The problem is that a const defined in
3847         one file that are used in a macro doesn't resolve the const if the macro is used in another file.  This
3848         seemed like the quickest path.
3849
3850         * dfg/DFGJITCompiler.cpp:
3851         (JSC::DFG::JITCompiler::compileFunction):
3852         (JSC::DFG::JITCompiler::linkFunction):
3853         * dfg/DFGJITCompiler.h:
3854         (JITCompiler):
3855         * ftl/FTLLink.cpp:
3856         (JSC::FTL::link):
3857         * jit/JIT.cpp:
3858         (JSC::JIT::privateCompile):
3859         * jit/JITStubs.cpp:
3860         (JSC::DEFINE_STUB_FUNCTION):
3861         * jit/JITStubs.h:
3862         * jit/ThunkGenerators.cpp:
3863         (JSC::arityFixup):
3864         * jit/ThunkGenerators.h:
3865         * llint/LowLevelInterpreter.asm:
3866         * llint/LowLevelInterpreter32_64.asm:
3867         * llint/LowLevelInterpreter64.asm:
3868         * runtime/CommonSlowPaths.cpp:
3869         (JSC::SLOW_PATH_DECL):
3870         * runtime/CommonSlowPaths.h:
3871         (JSC::CommonSlowPaths::arityCheckFor):
3872
3873 2013-06-19  Michael Saboff  <msaboff@apple.com>
3874
3875         FTL: arm build is broken in ToT
3876         https://bugs.webkit.org/show_bug.cgi?id=117800
3877
3878         Unreviewed build fixes.
3879
3880         * assembler/ARMv7Assembler.h:
3881         (ARMv7Assembler): Merge of r147941
3882         * jit/JITArithmetic32_64.cpp:
3883         (JSC::JIT::emit_op_mod): Moved variable declaration back inside #ifdef where used.
3884
3885 2013-06-17  Michael Saboff  <msaboff@apple.com>
3886
3887         FTL: Add another temp register regT4 to JSInterfaceJIT
3888         https://bugs.webkit.org/show_bug.cgi?id=117719
3889
3890         Reviewed by Geoffrey Garen.
3891
3892         Made the dedicated bucketCounterRegister to be regT4 and then used regT4 wherever
3893         bucketCounterRegister had been used.  Since it is masked whenever it is used and
3894         we are looking for some randomness in the register anyway, we can use it without
3895         any issues.
3896
3897         * jit/JIT.cpp:
3898         (JSC::JIT::privateCompile):
3899         * jit/JIT.h:
3900         (JSC::JIT::emitValueProfilingSite):
3901         * jit/JITCall.cpp:
3902         (JSC::JIT::emitPutCallResult):
3903         * jit/JITCall32_64.cpp:
3904         (JSC::JIT::emitPutCallResult):
3905         * jit/JITInlines.h:
3906         (JSC::JIT::emitValueProfilingSite):
3907         * jit/JITOpcodes.cpp:
3908         (JSC::JIT::emit_op_to_this):
3909         (JSC::JIT::emit_op_get_callee):
3910         (JSC::JIT::emit_op_get_argument_by_val):
3911         * jit/JITOpcodes32_64.cpp:
3912         (JSC::JIT::emit_op_get_callee):
3913         (JSC::JIT::emit_op_to_this):
3914         (JSC::JIT::emit_op_get_argument_by_val):
3915         * jit/JITPropertyAccess.cpp:
3916         (JSC::JIT::emit_op_get_by_val):
3917         (JSC::JIT::emitSlow_op_get_by_val):
3918         (JSC::JIT::emit_op_get_by_id):
3919         (JSC::JIT::emitSlow_op_get_by_id):
3920         (JSC::JIT::emit_op_get_from_scope):
3921         (JSC::JIT::emitSlow_op_get_from_scope):
3922         * jit/JITPropertyAccess32_64.cpp:
3923         (JSC::JIT::emit_op_get_by_val):
3924         (JSC::JIT::emitSlow_op_get_by_val):
3925         (JSC::JIT::emit_op_get_by_id):
3926         (JSC::JIT::emitSlow_op_get_by_id):
3927         (JSC::JIT::emit_op_get_from_scope):
3928         (JSC::JIT::emitSlow_op_get_from_scope):
3929         * jit/JITStubCall.h:
3930         (JSC::JITStubCall::callWithValueProfiling):
3931         * jit/JSInterfaceJIT.h: