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