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