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