a2c4fab7ba8e4059cfbbb260f0781bb6e9d9326e
[WebKit-https.git] / Source / JavaScriptCore / ChangeLog
1 2015-05-10  Andreas Kling  <akling@apple.com>
2
3         Remove unnecessary AtomicStringImpl* hash specification in PropertyNameArray.
4
5         Follow up to r184050 suggested by Darin.
6
7         * runtime/PropertyNameArray.h:
8
9 2015-05-10  Andreas Kling  <akling@apple.com>
10
11         Remove unused things from PropertyNameArray.
12         <https://webkit.org/b/144834>
13
14         Reviewed by Filip Pizlo.
15
16         PropertyNameArray had a bunch of bells and whistles added to it when for-in iteration
17         was refactored and optimized last year. Then more refactoring happened and this class
18         doesn't need to ring and toot anymore.
19
20         The RefCountedIdentifierSet class disappears since the JSPropertyNameEnumerator wasn't
21         actually using it for anything and we were just wasting time creating these.
22
23         Also made the member functions take AtomicStringImpl* instead of plain StringImpl*.
24
25         * runtime/JSObject.cpp:
26         (JSC::JSObject::getPropertyNames):
27         * runtime/JSPropertyNameEnumerator.cpp:
28         (JSC::JSPropertyNameEnumerator::create):
29         (JSC::JSPropertyNameEnumerator::JSPropertyNameEnumerator):
30         * runtime/JSPropertyNameEnumerator.h:
31         * runtime/PropertyNameArray.cpp:
32         (JSC::PropertyNameArray::add):
33         (JSC::PropertyNameArray::setPreviouslyEnumeratedProperties): Deleted.
34         * runtime/PropertyNameArray.h:
35         (JSC::PropertyNameArray::PropertyNameArray):
36         (JSC::PropertyNameArray::add):
37         (JSC::PropertyNameArray::addKnownUnique):
38         (JSC::PropertyNameArray::canAddKnownUniqueForStructure):
39         (JSC::RefCountedIdentifierSet::contains): Deleted.
40         (JSC::RefCountedIdentifierSet::size): Deleted.
41         (JSC::RefCountedIdentifierSet::add): Deleted.
42         (JSC::PropertyNameArray::identifierSet): Deleted.
43         (JSC::PropertyNameArray::numCacheableSlots): Deleted.
44         (JSC::PropertyNameArray::setNumCacheableSlotsForObject): Deleted.
45         (JSC::PropertyNameArray::setBaseObject): Deleted.
46         (JSC::PropertyNameArray::setPreviouslyEnumeratedLength): Deleted.
47
48 2015-05-09  Yoav Weiss  <yoav@yoav.ws>
49
50         Remove the PICTURE_SIZES build flag
51         https://bugs.webkit.org/show_bug.cgi?id=144679
52
53         Reviewed by Benjamin Poulain.
54
55         Removed the PICTURE_SIZES build time flag.
56
57         * Configurations/FeatureDefines.xcconfig:
58
59 2015-05-08  Filip Pizlo  <fpizlo@apple.com>
60
61         Extend the SaneChain optimization to Contiguous arrays
62         https://bugs.webkit.org/show_bug.cgi?id=144664
63
64         Reviewed by Mark Lam.
65         
66         Previously if you loaded from a hole, you'd either have to take slow path for the array
67         load (which means C++ calls and prototype chain walks) or you'd exit (if you hadn't
68         gathered the necessary profiling yet). But that's unnecessary if we know that the
69         prototype chain is sane - i.e. has no indexed properties. Then we can just return
70         Undefined for the hole.
71         
72         Making this change requires setting more watchpoints on the array prototype chain. But
73         that hit a horrible bug: ArrayPrototype still uses the static lookup tables and builds
74         itself up lazily. This means that this increased the number of recompilations we'd get
75         due to the array prototype chain being built up.
76         
77         So, this change also removes the laziness and static tables from ArrayPrototype.
78         
79         But to make that change, I also had to add a helper for eagerly building up a prototype
80         that has builtin functions.
81
82         * CMakeLists.txt:
83         * DerivedSources.make:
84         * dfg/DFGArrayMode.h:
85         * dfg/DFGFixupPhase.cpp:
86         (JSC::DFG::FixupPhase::fixupNode):
87         * dfg/DFGSpeculativeJIT32_64.cpp:
88         (JSC::DFG::SpeculativeJIT::compile):
89         * dfg/DFGSpeculativeJIT64.cpp:
90         (JSC::DFG::SpeculativeJIT::compile):
91         * ftl/FTLLowerDFGToLLVM.cpp:
92         (JSC::FTL::LowerDFGToLLVM::compileGetByVal):
93         * runtime/ArrayPrototype.cpp:
94         (JSC::ArrayPrototype::finishCreation):
95         (JSC::ArrayPrototype::getOwnPropertySlot): Deleted.
96         * runtime/ArrayPrototype.h:
97         * runtime/JSObject.h:
98
99 2015-05-08  Michael Saboff  <msaboff@apple.com>
100
101         Creating a large MarkedBlock sometimes results in more than one cell in the block
102         https://bugs.webkit.org/show_bug.cgi?id=144815
103
104         Reviewed by Mark Lam.
105
106         Large MarkedBlocks should have one and only one cell.  Changed the calculation of
107         m_endAtom for large blocks to use the location of the first cell + 1.  This
108         assures that large blocks only have one cell.
109
110         * heap/MarkedBlock.cpp:
111         (JSC::MarkedBlock::MarkedBlock):
112
113 2015-05-08  Oliver Hunt  <oliver@apple.com>
114
115         MapDataImpl::add() shouldn't do the same hash lookup twice.
116         https://bugs.webkit.org/show_bug.cgi?id=144759
117
118         Reviewed by Gavin Barraclough.
119
120         We don't actually need to do a double lookup here, all we need to
121         do is update the index to point to the correct m_size.
122
123         * runtime/MapDataInlines.h:
124         (JSC::JSIterator>::add):
125
126 2015-05-08  Andreas Kling  <akling@apple.com>
127
128         Micro-optimize JSON serialization of string primitives.
129         <https://webkit.org/b/144800>
130
131         Reviewed by Sam Weinig.
132
133         Don't use the out-of-line JSValue::getString() to grab at string primitives
134         in serialization. Just check if it's a JSString and then downcast to grab at
135         the WTF::String inside.
136
137         2% progression on Kraken/json-stringify-tinderbox.
138
139         * runtime/JSONObject.cpp:
140         (JSC::Stringifier::appendStringifiedValue):
141
142 2015-05-08  Andreas Kling  <akling@apple.com>
143
144         Optimize serialization of quoted JSON strings.
145         <https://webkit.org/b/144754>
146
147         Reviewed by Darin Adler.
148
149         Optimized the serialization of quoted strings into JSON by moving the logic into
150         StringBuilder so it can make smarter decisions about buffering.
151
152         12% progression on Kraken/json-stringify-tinderbox (on my Mac Pro.)
153
154         * bytecompiler/NodesCodegen.cpp:
155         (JSC::ObjectPatternNode::toString): Use the new StringBuilder API.
156
157         * runtime/JSONObject.h:
158         * runtime/JSONObject.cpp:
159         (JSC::Stringifier::Holder::appendNextProperty):
160         (JSC::appendStringToStringBuilder): Deleted.
161         (JSC::appendQuotedJSONStringToBuilder): Deleted.
162         (JSC::Stringifier::appendQuotedString): Deleted.
163         (JSC::Stringifier::appendStringifiedValue): Moved the bulk of this logic
164         to StringBuilder and call that from here.
165
166 2015-05-07  Commit Queue  <commit-queue@webkit.org>
167
168         Unreviewed, rolling out r183961.
169         https://bugs.webkit.org/show_bug.cgi?id=144784
170
171         Broke js/dom/JSON-stringify.html (Requested by kling on
172         #webkit).
173
174         Reverted changeset:
175
176         "Optimize serialization of quoted JSON strings."
177         https://bugs.webkit.org/show_bug.cgi?id=144754
178         http://trac.webkit.org/changeset/183961
179
180 2015-05-07  Filip Pizlo  <fpizlo@apple.com>
181
182         GC has trouble with pathologically large array allocations
183         https://bugs.webkit.org/show_bug.cgi?id=144609
184
185         Reviewed by Geoffrey Garen.
186
187         The bug was that SlotVisitor::copyLater() would return early for oversize blocks (right
188         after pinning them), and would skip the accounting. The GC calculates the size of the heap
189         in tandem with the scan to save time, and that accounting was part of how the GC would
190         know how big the heap was. The GC would then think that oversize copied blocks use no
191         memory, and would then mess up its scheduling of the next GC.
192         
193         Fixing this bug is harder than it seems. When running an eden GC, we figure out the heap
194         size by summing the size from the last collection and the size by walking the eden heap.
195         But this breaks when we eagerly delete objects that the last collection touched. We can do
196         that in one corner case: copied block reallocation. The old block will be deleted from old
197         space during the realloc and a new block will be allocated in new space. In order for the
198         GC to know that the size of old space actually shrank, we need a field to tell us how much
199         such shrinkage could occur. Since this is a very dirty corner case and it only works for
200         very particular reasons arising from the special properties of copied space (single owner,
201         and the realloc is used in places where the compiler already knows that it cannot register
202         allocate a pointer to the old block), I opted for an equally dirty shrinkage counter
203         devoted just to this case. It's called bytesRemovedFromOldSpaceDueToReallocation.
204         
205         To test this, I needed to add an Option to force a particular RAM size in the GC. This
206         allows us to write tests that assert that the GC heap size is some value X, without
207         worrying about machine-to-machine variations due to GC heuristics changing based on RAM
208         size.
209
210         * heap/CopiedSpace.cpp:
211         (JSC::CopiedSpace::CopiedSpace): Initialize the dirty shrinkage counter.
212         (JSC::CopiedSpace::tryReallocateOversize): Bump the dirty shrinkage counter.
213         * heap/CopiedSpace.h:
214         (JSC::CopiedSpace::takeBytesRemovedFromOldSpaceDueToReallocation): Swap out the counter. Used by the GC when it does its accounting.
215         * heap/Heap.cpp:
216         (JSC::Heap::Heap): Allow the user to force the RAM size.
217         (JSC::Heap::updateObjectCounts): Use the dirty shrinkage counter to good effect. Also, make this code less confusing.
218         * heap/SlotVisitorInlines.h:
219         (JSC::SlotVisitor::copyLater): The early return for isOversize() was the bug. We still need to report these bytes as live. Otherwise the GC doesn't know that it owns this memory.
220         * jsc.cpp: Add size measuring hooks to write the largeish test.
221         (GlobalObject::finishCreation):
222         (functionGCAndSweep):
223         (functionFullGC):
224         (functionEdenGC):
225         (functionHeapSize):
226         * runtime/Options.h:
227         * tests/stress/new-array-storage-array-with-size.js: Fix this so that it actually allocates ArrayStorage arrays and tests the thing it was supposed to test.
228         * tests/stress/new-largeish-contiguous-array-with-size.js: Added. This tests what the other test accidentally started testing, but does so without running your system out of memory.
229         (foo):
230         (test):
231
232 2015-05-07  Saam Barati  <saambarati1@gmail.com>
233
234         Global functions should be initialized as JSFunctions in byte code
235         https://bugs.webkit.org/show_bug.cgi?id=144178
236
237         Reviewed by Geoffrey Garen.
238
239         This patch makes the initialization of global functions more explicit by
240         moving initialization into bytecode. It also prepares JSC for having ES6
241         style lexical scoping because initializing global functions in bytecode
242         easily allows global functions to be initialized with the proper scope that
243         will have access to global lexical variables. Global lexical variables
244         should be visible to global functions but don't live on the global object.
245
246         * bytecode/UnlinkedCodeBlock.cpp:
247         (JSC::UnlinkedProgramCodeBlock::visitChildren):
248         * bytecode/UnlinkedCodeBlock.h:
249         * bytecompiler/BytecodeGenerator.cpp:
250         (JSC::BytecodeGenerator::generate):
251         (JSC::BytecodeGenerator::BytecodeGenerator):
252         * bytecompiler/BytecodeGenerator.h:
253         * runtime/Executable.cpp:
254         (JSC::ProgramExecutable::initializeGlobalProperties):
255         * runtime/JSGlobalObject.cpp:
256         (JSC::JSGlobalObject::addGlobalVar):
257         (JSC::JSGlobalObject::addFunction):
258         * runtime/JSGlobalObject.h:
259
260 2015-05-07  Benjamin Poulain  <bpoulain@apple.com>
261
262         Fix the x86 32bits build
263
264         * assembler/X86Assembler.h:
265
266 2015-05-07  Benjamin Poulain  <bpoulain@apple.com>
267
268         [JSC] Add basic DFG/FTL support for Math.round
269         https://bugs.webkit.org/show_bug.cgi?id=144725
270
271         Reviewed by Filip Pizlo.
272
273         This patch adds two optimizations targeting Math.round():
274         -Add a DFGNode ArithRound corresponding to the intrinsic RoundIntrinsic.
275         -Change the MacroAssembler to be stricter on how we fail to convert a double
276          to ingeter. Previously, any number valued zero would fail, now we only
277          fail for -0.
278
279         Since ArithRound speculate it produces int32, the MacroAssembler assembler
280         part became necessary because zero is a pretty common output of Math.round()
281         and we would OSR exit a lot (and eventually recompile for doubles).
282
283         The implementation itself of the inline Math.round() is exactly the same
284         as the C function that exists for Math.round(). We can very likely do better
285         but it is a good start known to be valid and inlining alone alread provides
286         significant speedups.
287
288         * assembler/X86Assembler.h:
289         (JSC::X86Assembler::movmskpd_rr):
290         * assembler/MacroAssemblerX86Common.h:
291         (JSC::MacroAssemblerX86Common::branchConvertDoubleToInt32):
292         When we have a zero, get the sign bit out of the double and check if is one.
293
294         I'll look into doing the same improvement for ARM.
295
296         * bytecode/SpeculatedType.cpp:
297         (JSC::typeOfDoubleRounding):
298         (JSC::typeOfDoubleFRound): Deleted.
299         * bytecode/SpeculatedType.h:
300         * dfg/DFGAbstractInterpreterInlines.h:
301         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
302         * dfg/DFGByteCodeParser.cpp:
303         (JSC::DFG::ByteCodeParser::handleIntrinsic):
304         * dfg/DFGClobberize.h:
305         (JSC::DFG::clobberize):
306         * dfg/DFGDoesGC.cpp:
307         (JSC::DFG::doesGC):
308         * dfg/DFGFixupPhase.cpp:
309         (JSC::DFG::FixupPhase::fixupNode):
310         * dfg/DFGGraph.h:
311         (JSC::DFG::Graph::roundShouldSpeculateInt32):
312         (JSC::DFG::Graph::negateShouldSpeculateMachineInt): Deleted.
313         * dfg/DFGNode.h:
314         (JSC::DFG::Node::arithNodeFlags):
315         (JSC::DFG::Node::hasHeapPrediction):
316         (JSC::DFG::Node::hasArithMode):
317         * dfg/DFGNodeType.h:
318         * dfg/DFGPredictionPropagationPhase.cpp:
319         (JSC::DFG::PredictionPropagationPhase::propagate):
320         * dfg/DFGSafeToExecute.h:
321         (JSC::DFG::safeToExecute):
322         * dfg/DFGSpeculativeJIT.cpp:
323         (JSC::DFG::SpeculativeJIT::compileArithRound):
324         * dfg/DFGSpeculativeJIT.h:
325         * dfg/DFGSpeculativeJIT32_64.cpp:
326         (JSC::DFG::SpeculativeJIT::compile):
327         * dfg/DFGSpeculativeJIT64.cpp:
328         (JSC::DFG::SpeculativeJIT::compile):
329         * ftl/FTLCapabilities.cpp:
330         (JSC::FTL::canCompile):
331         * ftl/FTLIntrinsicRepository.h:
332         * ftl/FTLLowerDFGToLLVM.cpp:
333         (JSC::FTL::LowerDFGToLLVM::compileNode):
334         (JSC::FTL::LowerDFGToLLVM::convertDoubleToInt32):
335         (JSC::FTL::LowerDFGToLLVM::compileDoubleAsInt32):
336         (JSC::FTL::LowerDFGToLLVM::compileArithRound):
337         * ftl/FTLOutput.h:
338         (JSC::FTL::Output::ceil64):
339         * jit/ThunkGenerators.cpp:
340         * runtime/MathCommon.cpp:
341         * runtime/MathCommon.h:
342         * runtime/MathObject.cpp:
343         (JSC::mathProtoFuncRound):
344         * tests/stress/math-round-basics.js: Added.
345         (mathRoundOnIntegers):
346         (mathRoundOnDoubles):
347         (mathRoundOnBooleans):
348         (uselessMathRound):
349         (mathRoundWithOverflow):
350         (mathRoundConsumedAsDouble):
351         (mathRoundDoesNotCareAboutMinusZero):
352         (mathRoundNoArguments):
353         (mathRoundTooManyArguments):
354         (testMathRoundOnConstants):
355         (mathRoundStructTransition):
356         (Math.round):
357
358 2015-05-07  Saam Barati  <saambarati1@gmail.com>
359
360         exceptionFuzz tests should explicitly initialize the exceptionFuzz boolean in JavaScript code through a function in jsc.cpp
361         https://bugs.webkit.org/show_bug.cgi?id=144753
362
363         Reviewed by Mark Lam.
364
365         This allows the BytecodeGenerator to freely emit startup code that "may"
366         throw exceptions without worrying that this startup code will trigger
367         the exceptionFuzz exception. The exceptionFuzz counter will only begin
368         ticking when the 'enableExceptionFuzz' function is explicitly called in 
369         the exceptionFuzz tests.
370
371         * jsc.cpp:
372         (GlobalObject::finishCreation):
373         (functionEnableExceptionFuzz):
374         * tests/exceptionFuzz/3d-cube.js:
375         * tests/exceptionFuzz/date-format-xparb.js:
376         * tests/exceptionFuzz/earley-boyer.js:
377
378 2015-05-07  Andreas Kling  <akling@apple.com>
379
380         Optimize serialization of quoted JSON strings.
381         <https://webkit.org/b/144754>
382
383         Reviewed by Darin Adler.
384
385         Optimized the serialization of quoted strings into JSON by moving the logic into
386         StringBuilder so it can make smarter decisions about buffering.
387
388         12% progression on Kraken/json-stringify-tinderbox (on my Mac Pro.)
389
390         * bytecompiler/NodesCodegen.cpp:
391         (JSC::ObjectPatternNode::toString): Use the new StringBuilder API.
392
393         * runtime/JSONObject.h:
394         * runtime/JSONObject.cpp:
395         (JSC::Stringifier::Holder::appendNextProperty):
396         (JSC::appendStringToStringBuilder): Deleted.
397         (JSC::appendQuotedJSONStringToBuilder): Deleted.
398         (JSC::Stringifier::appendQuotedString): Deleted.
399         (JSC::Stringifier::appendStringifiedValue): Moved the bulk of this logic
400         to StringBuilder and call that from here.
401
402 2015-05-07  Yusuke Suzuki  <utatane.tea@gmail.com>
403
404         FunctionCallBracketNode should store the base value to the temporary when subscript has assignment
405         https://bugs.webkit.org/show_bug.cgi?id=144678
406
407         Reviewed by Geoffrey Garen.
408
409         Currently, FunctionCallBracketNode directly use the RegisterID returned by emitNode.
410         But if the base part is the local register and the subscript part has assignment to it, the base result is accidentally rewritten.
411
412         function t() { var ok = {null: function () { } }; ok[ok = null](); }
413         t();  // Should not throw error.
414
415         This patch takes care about `subscriptHasAssignment`.
416         By using `emitNodeForLeftHandSide`, when there's assignment to local variables in RHS,
417         it correctly moves the LHS value to a temporary register.
418
419         * bytecompiler/NodesCodegen.cpp:
420         (JSC::FunctionCallBracketNode::emitBytecode):
421         * parser/ASTBuilder.h:
422         (JSC::ASTBuilder::makeFunctionCallNode):
423         * parser/NodeConstructors.h:
424         (JSC::FunctionCallBracketNode::FunctionCallBracketNode):
425         * parser/Nodes.h:
426         * tests/stress/assignment-in-function-call-bracket-node.js: Added.
427         (shouldBe):
428         (shouldBe.):
429
430 2015-05-07  Basile Clement  <basile_clement@apple.com>
431
432         Unreviewed, add missing braces on a single-line if that got expanded in r183939
433
434         * ftl/FTLLowerDFGToLLVM.cpp:
435         (JSC::FTL::LowerDFGToLLVM::buildExitArguments):
436
437 2015-05-05  Myles C. Maxfield  <mmaxfield@apple.com>
438
439         Revert "Introducing the Platform Abstraction Layer (PAL)"
440         https://bugs.webkit.org/show_bug.cgi?id=144751
441
442         Unreviewed.
443
444         PAL should be a new target inside WebCore, rather than a top-level folder.
445
446         * Configurations/FeatureDefines.xcconfig: Updated
447
448 2015-05-07  Basile Clement  <basile_clement@apple.com>
449
450         Dumping OSR ExitValue should expand materializations only once
451         https://bugs.webkit.org/show_bug.cgi?id=144694
452
453         Reviewed by Filip Pizlo.
454
455         Currently, dumping OSR exit values will print the full materialization
456         information each time it is encountered. We change it to print only a
457         brief description (only the materialization's address), and print the
458         whole set of materializations later on.
459
460         This makes the dump less confusing (less likely to think that two
461         instances of the same materialization are different), and will be a
462         necessary change if/when we support materialization cycles.
463
464         * ftl/FTLCompile.cpp:
465         (JSC::FTL::mmAllocateDataSection):
466         * ftl/FTLExitValue.cpp:
467         (JSC::FTL::ExitValue::dumpInContext):
468         * ftl/FTLLowerDFGToLLVM.cpp:
469         (JSC::FTL::LowerDFGToLLVM::buildExitArguments):
470
471 2015-05-07  Andreas Kling  <akling@apple.com>
472
473         Worker threads leak WeakBlocks (as seen on leaks bot)
474         <https://webkit.org/b/144721>
475         <rdar://problem/20848288>
476
477         Reviewed by Darin Adler.
478
479         Nuke any remaining empty WeakBlocks when the Heap is being torn down.
480         Trying to peek into these blocks after the VM is dead would be a bug anyway.
481
482         This fixes a ~750 KB leak seen on the leaks bot.
483
484         * heap/Heap.cpp:
485         (JSC::Heap::~Heap):
486
487 2015-05-05  Geoffrey Garen  <ggaren@apple.com>
488
489         Don't branch when accessing the callee
490         https://bugs.webkit.org/show_bug.cgi?id=144645
491
492         Reviewed by Michael Saboff.
493
494         The branch was added in <http://trac.webkit.org/changeset/81040> without
495         explanation.
496
497         kling found it to be a performance problem. See <https://webkit.org/b/144586>.
498
499         Our theory of access to Registers is that it's up to the client to access
500         them in the right way. So, let's do that.
501
502         * interpreter/CallFrame.h:
503         (JSC::ExecState::callee):
504         (JSC::ExecState::setCallee): Call the field object instead of function
505         because nothing guarantees that it's a function.
506         * interpreter/ProtoCallFrame.h:
507         (JSC::ProtoCallFrame::callee):
508         (JSC::ProtoCallFrame::setCallee):
509         * interpreter/Register.h:
510         * runtime/JSObject.h:
511         (JSC::Register::object): Just do a cast like our other accessors do.
512         (JSC::Register::operator=):
513         (JSC::Register::function): Deleted.
514         (JSC::Register::withCallee): Deleted.
515
516 2015-05-07  Dan Bernstein  <mitz@apple.com>
517
518         <rdar://problem/19317140> [Xcode] Remove usage of AspenFamily.xcconfig in Source/
519         https://bugs.webkit.org/show_bug.cgi?id=144727
520
521         Reviewed by Darin Adler.
522
523         * Configurations/Base.xcconfig: Don’t include AspenFamily.xcconfig, and define
524         INSTALL_PATH_PREFIX and LD_DYLIB_INSTALL_NAME for the iOS 8.x Simulator.
525
526 2015-05-07  Andreas Kling  <akling@apple.com>
527
528         Special-case Int32 values in JSON.stringify().
529         <https://webkit.org/b/144731>
530
531         Reviewed by Michael Saboff.
532
533         Add a fast path for serializing Int32 values to JSON. This is far faster than dragging
534         simple integers through the full-blown dtoa() machinery.
535
536         ~50% speedup on Kraken/json-stringify-tinderbox.
537
538         * runtime/JSONObject.cpp:
539         (JSC::Stringifier::appendStringifiedValue):
540
541 2015-05-06  Ryosuke Niwa  <rniwa@webkit.org>
542
543         ToT WebKit crashes while loading ES6 compatibility table
544         https://bugs.webkit.org/show_bug.cgi?id=144726
545
546         Reviewed by Filip Pizlo.
547
548         The bug was caused by parseClass superfluously avoiding to build up the string after seeing {.
549
550         Always build the identifier here as it could be a method name.
551
552         * parser/Parser.cpp:
553         (JSC::Parser<LexerType>::parseClass):
554
555 2015-05-05  Filip Pizlo  <fpizlo@apple.com>
556
557         Sane chain and string watchpoints should be set in FixupPhase or the backend rather than WatchpointCollectionPhase
558         https://bugs.webkit.org/show_bug.cgi?id=144665
559
560         Reviewed by Michael Saboff.
561         
562         This is a step towards getting rid of WatchpointCollectionPhase. It's also a step towards
563         extending SaneChain to all indexing shapes.
564
565         * dfg/DFGFixupPhase.cpp:
566         (JSC::DFG::FixupPhase::fixupNode): Set the watchpoints here so that we don't need a case in WatchpointCollectionPhase.
567         (JSC::DFG::FixupPhase::checkArray): Clarify the need for checking the structure. We often forget why we do this instead of always using CheckArray.
568         * dfg/DFGSpeculativeJIT.cpp:
569         (JSC::DFG::SpeculativeJIT::compileGetByValOnString): Set the watchpoints here so that we don't need a case in WatchpointCollectionPhase.
570         * dfg/DFGWatchpointCollectionPhase.cpp:
571         (JSC::DFG::WatchpointCollectionPhase::handle): Remove some code.
572         (JSC::DFG::WatchpointCollectionPhase::handleStringGetByVal): Deleted.
573         * ftl/FTLLowerDFGToLLVM.cpp:
574         (JSC::FTL::LowerDFGToLLVM::compileStringCharAt): Set the watchpoints here so that we don't need a case in WatchpointCollectionPhase.
575
576 2015-04-02  Myles C. Maxfield  <mmaxfield@apple.com>
577
578         Introducing the Platform Abstraction Layer (PAL)
579         https://bugs.webkit.org/show_bug.cgi?id=143358
580
581         Reviewed by Simon Fraser.
582
583         * Configurations/FeatureDefines.xcconfig: Updated
584
585 2015-05-06  Andreas Kling  <akling@apple.com>
586
587         Don't allocate a StringImpl for every Number JSValue in JSON.stringify().
588         <https://webkit.org/b/144676>
589
590         Reviewed by Darin Adler.
591
592         We were creating a new String for every number JSValue passing through the JSON stringifier.
593         These StringImpl allocations were dominating one of the Kraken JSON benchmarks.
594         Optimize this by using StringBuilder::appendECMAScriptNumber() which uses a stack buffer
595         for the conversion instead.
596
597         13% progression on Kraken/json-stringify-tinderbox.
598
599         * runtime/JSONObject.cpp:
600         (JSC::Stringifier::appendStringifiedValue):
601
602 2015-05-06  Commit Queue  <commit-queue@webkit.org>
603
604         Unreviewed, rolling out r183847.
605         https://bugs.webkit.org/show_bug.cgi?id=144691
606
607         Caused many assertion failures (Requested by ap on #webkit).
608
609         Reverted changeset:
610
611         "GC has trouble with pathologically large array allocations"
612         https://bugs.webkit.org/show_bug.cgi?id=144609
613         http://trac.webkit.org/changeset/183847
614
615 2015-05-05  Filip Pizlo  <fpizlo@apple.com>
616
617         PutGlobalVar shouldn't have an unconditional store barrier
618         https://bugs.webkit.org/show_bug.cgi?id=133104
619
620         Reviewed by Benjamin Poulain.
621         
622         We don't need a store barrier on PutGlobalVar if the value being stored can be
623         speculated to not be a cell.
624
625         * dfg/DFGFixupPhase.cpp:
626         (JSC::DFG::FixupPhase::fixupNode):
627
628 2015-05-05  Filip Pizlo  <fpizlo@apple.com>
629
630         CopiedBlock::reportLiveBytes() should be totally cool with oversize blocks
631         https://bugs.webkit.org/show_bug.cgi?id=144667
632
633         Reviewed by Andreas Kling.
634         
635         We are now calling this method for oversize blocks. It had an assertion that indirectly
636         implied that the block is not oversize, because it was claiming that the number of live
637         bytes should be smaller than the non-oversize-block size.
638
639         * heap/CopiedBlockInlines.h:
640         (JSC::CopiedBlock::reportLiveBytes):
641
642 2015-05-05  Filip Pizlo  <fpizlo@apple.com>
643
644         GC has trouble with pathologically large array allocations
645         https://bugs.webkit.org/show_bug.cgi?id=144609
646
647         Reviewed by Mark Lam.
648
649         * heap/Heap.cpp:
650         (JSC::Heap::updateObjectCounts): Make this code less confusing.
651         * heap/SlotVisitorInlines.h:
652         (JSC::SlotVisitor::copyLater): The early return for isOversize() was the bug. We still need to report these bytes as live. Otherwise the GC doesn't know that it owns this memory.
653         * jsc.cpp: Add size measuring hooks to write the largeish test.
654         (GlobalObject::finishCreation):
655         (functionGCAndSweep):
656         (functionFullGC):
657         (functionEdenGC):
658         (functionHeapSize):
659         * tests/stress/new-array-storage-array-with-size.js: Fix this so that it actually allocates ArrayStorage arrays and tests the thing it was supposed to test.
660         * tests/stress/new-largeish-contiguous-array-with-size.js: Added. This tests what the other test accidentally started testing, but does so without running your system out of memory.
661         (foo):
662         (test):
663
664 2015-05-05  Filip Pizlo  <fpizlo@apple.com>
665
666         FTL SwitchString slow case creates duplicate switch cases
667         https://bugs.webkit.org/show_bug.cgi?id=144634
668
669         Reviewed by Geoffrey Garen.
670         
671         The problem of duplicate switches is sufficiently annoying that I fixed the issue and also
672         added mostly-debug-only asserts to catch such issues earlier.
673
674         * bytecode/CallVariant.cpp:
675         (JSC::variantListWithVariant): Assertion to prevent similar bugs.
676         * ftl/FTLLowerDFGToLLVM.cpp:
677         (JSC::FTL::LowerDFGToLLVM::switchStringRecurse): Assertion to prevent similar bugs.
678         (JSC::FTL::LowerDFGToLLVM::switchStringSlow): This is the bug.
679         * jit/BinarySwitch.cpp:
680         (JSC::BinarySwitch::BinarySwitch): Assertion to prevent similar bugs.
681         * jit/Repatch.cpp:
682         (JSC::linkPolymorphicCall): Assertion to prevent similar bugs.
683         * tests/stress/ftl-switch-string-slow-duplicate-cases.js: Added. This tests the FTL SwitchString bug. It was previously crashing every time.
684         (foo):
685         (cat):
686
687 2015-05-05  Basile Clement  <basile_clement@apple.com>
688
689         Fix debug builds after r183812
690         https://bugs.webkit.org/show_bug.cgi?id=144300
691
692         Rubber stamped by Andreas Kling and Filip Pizlo.
693
694         hasObjectMaterializationData() didn't treat MaterializeCreateActivation
695         as having materialization data, which was causing an assertion failure when
696         sinking CreateActivations on debug builds.
697
698         * dfg/DFGNode.h:
699         (JSC::DFG::Node::hasObjectMaterializationData):
700
701 2015-05-04  Basile Clement  <basile_clement@apple.com>
702
703         Allow CreateActivation sinking
704         https://bugs.webkit.org/show_bug.cgi?id=144300
705
706         Reviewed by Filip Pizlo.
707
708         This pursues the work started in
709         https://bugs.webkit.org/show_bug.cgi?id=144016 to expand the set of
710         allocations we are able to sink by allowing sinking of CreateActivation
711         node.
712
713         This is achieved by following closely the way NewObject is currently
714         sunk: we add a new PhantomCreateActivation node to record the initial
715         position of the CreateActivation node, new ClosureVarPLoc promoted heap
716         locations to keep track of the variables put in the activation, and a
717         new MaterializeCreateActivation node to allocate and populate the sunk
718         activation.
719
720         * dfg/DFGAbstractInterpreterInlines.h:
721         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
722         * dfg/DFGClobberize.h:
723         (JSC::DFG::clobberize):
724         * dfg/DFGDoesGC.cpp:
725         (JSC::DFG::doesGC):
726         * dfg/DFGFixupPhase.cpp:
727         (JSC::DFG::FixupPhase::fixupNode):
728         * dfg/DFGNode.cpp:
729         (JSC::DFG::Node::convertToPutClosureVarHint):
730         * dfg/DFGNode.h:
731         (JSC::DFG::Node::convertToPhantomCreateActivation):
732         (JSC::DFG::Node::isActivationAllocation):
733         (JSC::DFG::Node::isPhantomActivationAllocation):
734         (JSC::DFG::Node::isPhantomAllocation):
735         * dfg/DFGNodeType.h:
736         * dfg/DFGObjectAllocationSinkingPhase.cpp:
737         (JSC::DFG::ObjectAllocationSinkingPhase::lowerNonReadingOperationsOnPhantomAllocations):
738         (JSC::DFG::ObjectAllocationSinkingPhase::handleNode):
739         (JSC::DFG::ObjectAllocationSinkingPhase::createMaterialize):
740         (JSC::DFG::ObjectAllocationSinkingPhase::populateMaterialize):
741         * dfg/DFGPredictionPropagationPhase.cpp:
742         (JSC::DFG::PredictionPropagationPhase::propagate):
743         * dfg/DFGPromotedHeapLocation.cpp:
744         (WTF::printInternal):
745         * dfg/DFGPromotedHeapLocation.h:
746         * dfg/DFGSafeToExecute.h:
747         (JSC::DFG::safeToExecute):
748         * dfg/DFGSpeculativeJIT32_64.cpp:
749         (JSC::DFG::SpeculativeJIT::compile):
750         * dfg/DFGSpeculativeJIT64.cpp:
751         (JSC::DFG::SpeculativeJIT::compile):
752         * dfg/DFGValidate.cpp:
753         (JSC::DFG::Validate::validateCPS):
754         * ftl/FTLCapabilities.cpp:
755         (JSC::FTL::canCompile):
756         * ftl/FTLLowerDFGToLLVM.cpp:
757         (JSC::FTL::LowerDFGToLLVM::compileNode):
758         (JSC::FTL::LowerDFGToLLVM::compileMaterializeCreateActivation):
759         * ftl/FTLOperations.cpp:
760         (JSC::FTL::operationMaterializeObjectInOSR):
761         * tests/stress/activation-sink-osrexit.js: Added.
762         (bar):
763         (foo.set result):
764         * tests/stress/activation-sink.js: Added.
765         (bar):
766
767 2015-05-04  Filip Pizlo  <fpizlo@apple.com>
768
769         Unreviewed, fix stale comment.
770
771         * tests/mozilla/js1_5/Array/regress-101964.js:
772
773 2015-05-04  Filip Pizlo  <fpizlo@apple.com>
774
775         Large array shouldn't be slow
776         https://bugs.webkit.org/show_bug.cgi?id=144617
777
778         Rubber stamped by Mark Lam.
779
780         * tests/mozilla/js1_5/Array/regress-101964.js: 500ms isn't enough in debug mode. We don't care how long this takes so long as we run it to completion. I've raised the limit much higher.
781
782 2015-05-04  Filip Pizlo  <fpizlo@apple.com>
783
784         Large array shouldn't be slow
785         https://bugs.webkit.org/show_bug.cgi?id=144617
786
787         Rubber stamped by Mark Lam.
788
789         * tests/mozilla/js1_5/Array/regress-101964.js: Mozilla may have cared about this being fast a decade ago (or more), but we don't care. We've consistently found that an array implementation that punishes this case to get speed on common-case array accesses is better. This should fix some test failures on the bots.
790
791 2015-05-04  Commit Queue  <commit-queue@webkit.org>
792
793         Unreviewed, rolling out r183789.
794         https://bugs.webkit.org/show_bug.cgi?id=144620
795
796         Causing flakiness on exceptionFuzz tests locally on 32-bit
797         build (Requested by saamyjoon on #webkit).
798
799         Reverted changeset:
800
801         "Global functions should be initialized as JSFunctions in byte
802         code"
803         https://bugs.webkit.org/show_bug.cgi?id=144178
804         http://trac.webkit.org/changeset/183789
805
806 2015-05-04  Saam Barati  <saambarati1@gmail.com>
807
808         Global functions should be initialized as JSFunctions in byte code
809         https://bugs.webkit.org/show_bug.cgi?id=144178
810
811         Reviewed by Geoffrey Garen.
812
813         This patch makes the initialization of global functions more explicit by
814         moving initialization into bytecode. It also prepares JSC for having ES6
815         style lexical scoping because initializing global functions in bytecode
816         easily allows global functions to be initialized with the proper scope that
817         will have access to global lexical variables. Global lexical variables
818         should be visible to global functions but don't live on the global object.
819
820         * bytecode/UnlinkedCodeBlock.cpp:
821         (JSC::UnlinkedProgramCodeBlock::visitChildren):
822         * bytecode/UnlinkedCodeBlock.h:
823         * bytecompiler/BytecodeGenerator.cpp:
824         (JSC::BytecodeGenerator::generate):
825         (JSC::BytecodeGenerator::BytecodeGenerator):
826         * bytecompiler/BytecodeGenerator.h:
827         * runtime/Executable.cpp:
828         (JSC::ProgramExecutable::initializeGlobalProperties):
829         * runtime/JSGlobalObject.cpp:
830         (JSC::JSGlobalObject::addGlobalVar):
831         (JSC::JSGlobalObject::addFunction):
832         * runtime/JSGlobalObject.h:
833
834 2015-05-04  Filip Pizlo  <fpizlo@apple.com>
835
836         Large array shouldn't be slow
837         https://bugs.webkit.org/show_bug.cgi?id=144617
838
839         Reviewed by Geoffrey Garen.
840         
841         Decouple MIN_SPARSE_ARRAY_INDEX, which is the threshold for storing to the sparse map when
842         you're already using ArrayStorage mode, from the minimul array length required to use
843         ArrayStorage in a new Array(length) allocation.
844         
845         Lift the array allocation length threshold to something very high. If this works, we'll
846         probably remove that threshold entirely.
847         
848         This is a 27% speed-up on JetStream/hash-map. Because run-jsc-benchmarks still can't run
849         JetStream as a discrete suite, this adds hash-map to LongSpider so that we run it somewhere
850         for now.
851
852         * dfg/DFGCallArrayAllocatorSlowPathGenerator.h:
853         * dfg/DFGSpeculativeJIT32_64.cpp:
854         (JSC::DFG::SpeculativeJIT::compile):
855         * dfg/DFGSpeculativeJIT64.cpp:
856         (JSC::DFG::SpeculativeJIT::compile):
857         * ftl/FTLLowerDFGToLLVM.cpp:
858         (JSC::FTL::LowerDFGToLLVM::compileNewArrayWithSize):
859         * runtime/ArrayConventions.h:
860         * runtime/JSArray.h:
861         (JSC::JSArray::create):
862         * runtime/JSGlobalObject.h:
863         (JSC::constructEmptyArray):
864         * tests/stress/new-array-storage-array-with-size.js: Skip this test until we fix https://bugs.webkit.org/show_bug.cgi?id=144609.
865
866 2015-05-03  Yusuke Suzuki  <utatane.tea@gmail.com>
867
868         Add backed intrinsics to private functions exposed with private symbols in global object
869         https://bugs.webkit.org/show_bug.cgi?id=144545
870
871         Reviewed by Darin Adler.
872
873         Math.abs and Math.floor have ASM intrinsics And it is further accelerated in DFG/FTL layers.
874         This patch adds intrinsic to private functions exposed with private symbols in global object,
875         @floor and @abs.
876
877         * runtime/JSGlobalObject.cpp:
878         (JSC::JSGlobalObject::init):
879         * runtime/JSGlobalObjectFunctions.cpp:
880         (JSC::globalPrivateFuncAbs): Deleted.
881         (JSC::globalPrivateFuncFloor): Deleted.
882         * runtime/MathObject.cpp:
883         * runtime/MathObject.h:
884         * tests/stress/array-from-abs-and-floor.js: Added.
885         (target1):
886         (target2):
887         (target3):
888
889 2015-05-04  Csaba Osztrogonác  <ossy@webkit.org>
890
891         [cmake] ARM related build system cleanup
892         https://bugs.webkit.org/show_bug.cgi?id=144566
893
894         Reviewed by Darin Adler.
895
896         * CMakeLists.txt:
897
898 2015-05-04  Andreas Kling  <akling@apple.com>
899
900         Optimize WeakBlock's "reap" and "visit" operations.
901         <https://webkit.org/b/144585>
902
903         Reviewed by Geoffrey Garen.
904
905         WeakBlock was using Heap::isLive(void*) to determine the liveness of weak pointees.
906         That function was really written with conservative roots marking in mind, and will do a bunch
907         of sanity and bounds checks.
908
909         For weaks, we know that the pointer will have been a valid cell pointer into a block
910         of appropriate cell size, so we can skip a lot of the checks.
911
912         We now keep a pointer to the MarkedBlock in each WeakBlock. That way we no longer have to do
913         MarkedBlock::blockFor() for every single cell when iterating.
914
915         Note that a WeakBlock's MarkedBlock pointer becomes null when we detach a logically empty
916         WeakBlock from its WeakSet and transfer ownership to Heap. At that point, the block will never
917         be pointing to any live cells, and the only operation that will run on the block is sweep().
918
919         Finally, MarkedBlock allows liveness queries in three states: Marked, Retired, and Allocated.
920         In Allocated state, all cells are reported as live. This state will reset to Marked on next GC.
921         This patch uses that knowledge to avoid branching on the MarkedBlock's state for every cell.
922
923         This is a ~3x speedup of visit() and a ~2x speedup of reap() on Dromaeo/dom-modify, netting
924         what looks like a 1% speedup locally.
925
926         * heap/MarkedBlock.cpp:
927         (JSC::MarkedBlock::MarkedBlock): Pass *this to the WeakSet's ctor.
928
929         * heap/MarkedBlock.h:
930         (JSC::MarkedBlock::isMarkedOrNewlyAllocated): Added, stripped-down version of isLive() when the
931         block's state is known to be either Marked or Retired.
932
933         (JSC::MarkedBlock::isAllocated): Added, tells WeakBlock it's okay to skip reap/visit since isLive()
934         would report that all cells are live anyway.
935
936         * heap/WeakBlock.cpp:
937         (JSC::WeakBlock::create):
938         (JSC::WeakBlock::WeakBlock): Stash a MarkedBlock* on each WeakBlock.
939
940         (JSC::WeakBlock::visit):
941         (JSC::WeakBlock::reap): Optimized these two to avoid a bunch of pointer arithmetic and branches.
942
943         * heap/WeakBlock.h:
944         (JSC::WeakBlock::disconnectMarkedBlock): Added.
945         * heap/WeakSet.cpp:
946         (JSC::WeakSet::sweep): Call the above when removing a WeakBlock from WeakSet and transferring
947         ownership to Heap until it can die peacefully.
948
949         (JSC::WeakSet::addAllocator):
950         * heap/WeakSet.h:
951         (JSC::WeakSet::WeakSet): Give WeakSet a MarkedBlock& for passing on to WeakBlocks.
952
953 2015-05-04  Basile Clement  <basile_clement@apple.com>
954
955         Allocation sinking is prohibiting the creation of phis between a Phantom object and its materialization
956         https://bugs.webkit.org/show_bug.cgi?id=144587
957
958         Rubber stamped by Filip Pizlo.
959
960         When sinking object allocations, we ensure in
961         determineMaterializationPoints that whenever an allocation is
962         materialized on a path to a block, it is materialized in all such
963         paths. Thus when running the SSA calculator to place Phis in
964         placeMaterializationPoints, we can't encounter a situation where some
965         Upsilons are referring to a materialization while others are referring
966         to the phantom object.
967
968         This replaces the code that was adding a materialization late in
969         placeMaterializationPoints to handle that case by an assertion that it
970         does not happen, which will make
971         https://bugs.webkit.org/show_bug.cgi?id=143073 easier to implement.
972
973         * dfg/DFGObjectAllocationSinkingPhase.cpp:
974         (JSC::DFG::ObjectAllocationSinkingPhase::placeMaterializationPoints):
975
976 2015-05-04  Ryosuke Niwa  <rniwa@webkit.org>
977
978         Extending undefined in class syntax should throw a TypeError
979         https://bugs.webkit.org/show_bug.cgi?id=144284
980
981         Reviewed by Darin Adler.
982
983         The bug was caused by op_eq_null evaluating to true when compared to undefined.
984         Explicitly check op_eq_undefined first to detect the case where we're extending undefined.
985
986         We also had bogus test cases checked in class-syntax-extends.html. This patch also fixes them.
987
988         * bytecompiler/NodesCodegen.cpp:
989         (JSC::ClassExprNode::emitBytecode):
990
991 2015-05-04  Ryosuke Niwa  <rniwa@webkit.org>
992
993         new super should be a syntax error
994         https://bugs.webkit.org/show_bug.cgi?id=144282
995
996         Reviewed by Joseph Pecoraro.
997
998         Disallow "new super" as ES6 spec doesn't allow this.
999
1000         * parser/Parser.cpp:
1001         (JSC::Parser<LexerType>::parseMemberExpression):
1002
1003 2015-05-04  Saam Barati  <saambarati1@gmail.com>
1004
1005         JSCallbackObject does not maintain symmetry between accesses for getOwnPropertySlot and put
1006         https://bugs.webkit.org/show_bug.cgi?id=144265
1007
1008         Reviewed by Geoffrey Garen.
1009
1010         JSCallbackObject will defer to a parent's implementation of getOwnPropertySlot
1011         for a static function if the parent has that property slot. JSCallbackObject::put 
1012         did not maintain this symmetry of also calling ::put on the parent if the parent 
1013         has the property. We should ensure that this symmetry exists.
1014
1015         * API/JSCallbackObjectFunctions.h:
1016         (JSC::JSCallbackObject<Parent>::put):
1017         * API/tests/testapi.c:
1018         * API/tests/testapi.js:
1019         (globalStaticFunction2):
1020         (this.globalStaticFunction2):
1021         (iAmNotAStaticFunction):
1022         (this.iAmNotAStaticFunction):
1023
1024 2015-05-04  Andreas Kling  <akling@apple.com>
1025
1026         Make ExecState::vm() branchless in release builds.
1027         <https://webkit.org/b/144586>
1028
1029         Reviewed by Geoffrey Garen.
1030
1031         Avoid null checking the ExecState's callee() before getting the
1032         VM from it. The code was already dereferencing it anyway, since we
1033         know it's not gonna be null.
1034
1035         * runtime/JSCellInlines.h:
1036         (JSC::ExecState::vm):
1037
1038 2015-05-04  Basile Clement  <basile_clement@apple.com>
1039
1040         Object allocation not sinking properly through CheckStructure
1041         https://bugs.webkit.org/show_bug.cgi?id=144465
1042
1043         Reviewed by Filip Pizlo.
1044
1045         Currently, sinking an allocation through a CheckStructure will
1046         completely ignore all structure checking, which is obviously wrong.
1047
1048         A CheckStructureImmediate node type was present for that purpose, but
1049         the CheckStructures were not properly replaced.  This ensures that
1050         CheckStructure nodes are replaced by CheckStructureImmediate nodes when
1051         sunk through, and that structure checking happens correctly.
1052
1053         * dfg/DFGNode.h:
1054         (JSC::DFG::Node::convertToCheckStructureImmediate): Added.
1055         (JSC::DFG::Node::hasStructureSet):
1056         * dfg/DFGObjectAllocationSinkingPhase.cpp:
1057         (JSC::DFG::ObjectAllocationSinkingPhase::promoteSunkenFields):
1058         * ftl/FTLLowerDFGToLLVM.cpp:
1059         (JSC::FTL::LowerDFGToLLVM::compileCheckStructure):
1060         (JSC::FTL::LowerDFGToLLVM::compileCheckStructureImmediate):
1061         (JSC::FTL::LowerDFGToLLVM::checkStructure):
1062         * tests/stress/sink_checkstructure.js: Added.
1063         (foo):
1064
1065 2015-05-01  Geoffrey Garen  <ggaren@apple.com>
1066
1067         REGRESSION(r183570): jslib-traverse-jquery is 22% slower
1068         https://bugs.webkit.org/show_bug.cgi?id=144476
1069
1070         Reviewed by Sam Weinig.
1071
1072         jslib-traverse-jquery is now 31% faster than its unregressed baseline.
1073
1074         The jQuery algorithm for sorting DOM nodes is so pathologically slow that,
1075         to my knowledge, the topic of how to optimize it is not covered in any
1076         literature about sorting.
1077
1078         On the slowest jQuery sorting test -- prevAll -- our new
1079         Array.prototype.sort, compared to its predecessor, performed 12% fewer
1080         comparisons and requireed 10X less overhead per comparison. Yet, it was
1081         slower.
1082
1083         It was slower because it inadvertantly increased the average cost of the
1084         comparison function by 2X. jQuery uses compareDocumentPosition to compare
1085         DOM nodes, and compareDocumentPosition(a, b) is O(N) in the distance
1086         required to traverse backwards from b to a. In prevAll, we encounter the
1087         worst case for merge sort of compareDocumentPosition: A long list of DOM
1088         nodes in mostly reverse order. In this case, merge sort will sequentially
1089         compareDocumentPosition(a, b), where a is not reachable backwards from
1090         b, and therefore compareDocumentPosition will traverse the whole sibling
1091         list.
1092
1093         The solution is simple enough: Call compareDocumentPosition(b, a) instead.
1094
1095         This is a pretty silly thing to do, but it is harmless, and jQuery is
1096         popular, so let's do it.
1097
1098         We do not risk suffering the same problem in reverse when sorting a long
1099         list of DOM nodes in forward order. (We still have a 37% speedup on the
1100         nextAll benchmark.) The reason is that merge sort performs 2X fewer
1101         comparisons when the list is already sorted, so we can worry less about
1102         the cost of each comparison.
1103
1104         A fully principled soultion to this problem would probably do something
1105         like Python's timsort, which special-cases ordered ranges to perform
1106         only O(n) comparisons. But that would contradict our original
1107         goal of just having something simple that works.
1108
1109         Another option is for elements to keep a compareDocumentPosition cache,
1110         like a node list cache, which allows you to determine the absolute
1111         position of a node using a hash lookup. I will leave this as an exercise
1112         for kling.
1113
1114         * builtins/Array.prototype.js:
1115         (sort.merge): Compare in an order that is favorable to a comparator
1116         that calls compareDocumentPosition.
1117
1118 2015-05-04  Csaba Osztrogonác  <ossy@webkit.org>
1119
1120         [cmake] Fix generate-js-builtins related incremental build issue
1121         https://bugs.webkit.org/show_bug.cgi?id=144094
1122
1123         Reviewed by Michael Saboff.
1124
1125         * CMakeLists.txt: Generated JSCBuiltins.<cpp|h> should depend on Source/JavaScriptCore/builtins directory.
1126         Pass input directory to generate-js-builtins instead of Source/JavaScriptCore/builtins/*.js.
1127         * DerivedSources.make:
1128         Pass input directory to generate-js-builtins instead of Source/JavaScriptCore/builtins/*.js.
1129         * generate-js-builtins: Accept input files and input directory too.
1130
1131 2015-05-03  Simon Fraser  <simon.fraser@apple.com>
1132
1133         Make some static data const
1134         https://bugs.webkit.org/show_bug.cgi?id=144552
1135
1136         Reviewed by Andreas Kling.
1137         
1138         Turn characterSetInfo into const data.
1139
1140         * yarr/YarrCanonicalizeUCS2.cpp:
1141         * yarr/YarrCanonicalizeUCS2.h:
1142
1143 2015-05-01  Filip Pizlo  <fpizlo@apple.com>
1144
1145         TypeOf should be fast
1146         https://bugs.webkit.org/show_bug.cgi?id=144396
1147
1148         Reviewed by Geoffrey Garen.
1149         
1150         Adds comprehensive support for fast typeof to the optimizing JITs. Calls into the runtime
1151         are only used for very exotic objects - they must have either the MasqueradesAsUndefined or
1152         TypeOfShouldCallGetCallData type flags set. All other cases are handled inline.
1153         
1154         This means optimizing IsObjectOrNull, IsFunction, and TypeOf - all node types that used to
1155         rely heavily on C++ calls to fulfill their function.
1156         
1157         Because TypeOf is now so fast, we no longer need to do any speculations on this node.
1158         
1159         In the FTL, we take this further by querying AI for each branch in the TypeOf decision tree.
1160         This means that if the TypeOf is dominated by any type checks, we will automatically prune
1161         out cases that are redundant.
1162         
1163         This patch anticipates the addition of SwitchTypeOf or something like that. So, the TypeOf
1164         code generation is designed to be reusable.
1165         
1166         This is a speed-up on most typeof benchmarks. But, it is a slow-down on benchmarks that take
1167         the exotic call trap hook. That hook is now in a deeper slow path than before.
1168
1169         * CMakeLists.txt:
1170         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
1171         * JavaScriptCore.xcodeproj/project.pbxproj:
1172         * dfg/DFGClobberize.h:
1173         (JSC::DFG::clobberize): TypeOf was pure all along, but we failed to realize this.
1174         * dfg/DFGFixupPhase.cpp:
1175         (JSC::DFG::FixupPhase::fixupNode):
1176         * dfg/DFGHeapLocation.cpp:
1177         (WTF::printInternal):
1178         * dfg/DFGHeapLocation.h:
1179         * dfg/DFGOperations.cpp:
1180         * dfg/DFGOperations.h:
1181         * dfg/DFGSpeculativeJIT.cpp:
1182         (JSC::DFG::SpeculativeJIT::compileIsObjectOrNull):
1183         (JSC::DFG::SpeculativeJIT::compileIsFunction):
1184         (JSC::DFG::SpeculativeJIT::compileTypeOf):
1185         * dfg/DFGSpeculativeJIT.h:
1186         (JSC::DFG::SpeculativeJIT::blessedBooleanResult):
1187         (JSC::DFG::SpeculativeJIT::callOperation):
1188         * dfg/DFGSpeculativeJIT32_64.cpp:
1189         (JSC::DFG::SpeculativeJIT::compile):
1190         * dfg/DFGSpeculativeJIT64.cpp:
1191         (JSC::DFG::SpeculativeJIT::compile):
1192         * ftl/FTLCapabilities.cpp:
1193         (JSC::FTL::canCompile):
1194         * ftl/FTLIntrinsicRepository.h:
1195         * ftl/FTLLowerDFGToLLVM.cpp:
1196         (JSC::FTL::LowerDFGToLLVM::compileNode):
1197         (JSC::FTL::LowerDFGToLLVM::compileIsObjectOrNull):
1198         (JSC::FTL::LowerDFGToLLVM::compileIsFunction):
1199         (JSC::FTL::LowerDFGToLLVM::compileTypeOf):
1200         (JSC::FTL::LowerDFGToLLVM::buildTypeOf): Reusable TypeOf building for the FTL.
1201         (JSC::FTL::LowerDFGToLLVM::isExoticForTypeof):
1202         * ftl/FTLSwitchCase.h:
1203         (JSC::FTL::SwitchCase::SwitchCase):
1204         * jit/AssemblyHelpers.h:
1205         (JSC::AssemblyHelpers::branchIfNotEqual):
1206         (JSC::AssemblyHelpers::branchIfEqual):
1207         (JSC::AssemblyHelpers::branchIfNumber):
1208         (JSC::AssemblyHelpers::branchIfNotNumber):
1209         (JSC::AssemblyHelpers::branchIfBoolean):
1210         (JSC::AssemblyHelpers::branchIfNotBoolean):
1211         (JSC::AssemblyHelpers::boxBooleanPayload):
1212         (JSC::AssemblyHelpers::boxBoolean):
1213         (JSC::AssemblyHelpers::emitTypeOf): Reusable TypeOf building for assembly JITs.
1214         * jit/JITOperations.h:
1215         * runtime/SmallStrings.h:
1216         (JSC::SmallStrings::typeString):
1217         * runtime/TypeofType.cpp: Added.
1218         (WTF::printInternal):
1219         * runtime/TypeofType.h: Added.
1220         * tests/stress/type-of-functions-and-objects.js: Modified this test to give more comprehensive feedback.
1221
1222 2015-05-02  Filip Pizlo  <fpizlo@apple.com>
1223
1224         Unreviewed, add a FIXME referencing https://bugs.webkit.org/show_bug.cgi?id=144527.
1225
1226         * dfg/DFGLICMPhase.cpp:
1227         (JSC::DFG::LICMPhase::attemptHoist):
1228
1229 2015-05-02  Filip Pizlo  <fpizlo@apple.com>
1230
1231         Unreviewed, add FIXMEs referencing https://bugs.webkit.org/show_bug.cgi?id=144524 and
1232         https://bugs.webkit.org/show_bug.cgi?id=144525.
1233
1234         * dfg/DFGLICMPhase.cpp:
1235         (JSC::DFG::LICMPhase::attemptHoist):
1236         * dfg/DFGPhantomInsertionPhase.cpp:
1237
1238 2015-05-02  Yusuke Suzuki  <utatane.tea@gmail.com>
1239
1240         Static property hashtable should only lookup with non-symbol key
1241         https://bugs.webkit.org/show_bug.cgi?id=144438
1242
1243         Reviewed by Darin Adler.
1244
1245         Static property hashtable compares the Identifier's uid
1246         with the normal C string without interning it.
1247         So this comparison is performed in their contents.
1248         As the result, in this comparison, symbol-ness is not considered.
1249
1250         So if accidentally the hash collision occur with the symbol and the string
1251         and they have the same contents, the hash table entry is looked up incorrectly.
1252
1253         * runtime/Lookup.h:
1254         (JSC::HashTable::entry):
1255
1256 2015-05-01  Ryosuke Niwa  <rniwa@webkit.org>
1257
1258         Class syntax should allow string and numeric identifiers for method names
1259         https://bugs.webkit.org/show_bug.cgi?id=144254
1260
1261         Reviewed by Darin Adler.
1262
1263         Added the support for string and numeric identifiers in class syntax.
1264
1265         * parser/Parser.cpp:
1266         (JSC::Parser<LexerType>::parseFunctionInfo): Instead of using ConstructorKind to indicate whether we're
1267         inside a class or not, use the newly added SuperBinding argument instead. ConstructorKind is now None
1268         outside a class constructor as it should be.
1269         (JSC::Parser<LexerType>::parseFunctionDeclaration):
1270         (JSC::Parser<LexerType>::parseClass): No longer expects an identifier at the beginning of every class
1271         element to allow numeric and string method names. For both of those method names, parse it here instead
1272         of parseFunctionInfo since it doesn't support either type. Also pass in SuperBinding::Needed.
1273         (JSC::Parser<LexerType>::parsePropertyMethod): Call parseFunctionInfo with SuperBinding::NotNeeded since
1274         this function is never used to parse a class method.
1275         (JSC::Parser<LexerType>::parseGetterSetter): Pass in superBinding argument to parseFunctionInfo.
1276         (JSC::Parser<LexerType>::parsePrimaryExpression): Call parseFunctionInfo with SuperBinding::NotNeeded.
1277         * parser/Parser.h:
1278         * parser/SyntaxChecker.h:
1279         (JSC::SyntaxChecker::createProperty):
1280
1281 2015-05-01  Filip Pizlo  <fpizlo@apple.com>
1282
1283         FTL should use AI more
1284         https://bugs.webkit.org/show_bug.cgi?id=144500
1285
1286         Reviewed by Oliver Hunt.
1287         
1288         This makes our type check folding even more comprehensive by ensuring that even if the FTL
1289         decides to emit some checks, it will still do another query to the abstract interpreter to
1290         see if the check is necessary. This helps with cases where we decided early on to speculate
1291         one way, but later proved a more specific type of the value in question, and the constant
1292         folder didn't catch it.
1293         
1294         This also makes it more natural to query the abstract interpreter. For example, if you just
1295         want the proven type, you can now say provenType(node) or provenType(edge).
1296
1297         * dfg/DFGArrayMode.cpp:
1298         (JSC::DFG::ArrayMode::alreadyChecked):
1299         * dfg/DFGArrayMode.h:
1300         * ftl/FTLLowerDFGToLLVM.cpp:
1301         (JSC::FTL::LowerDFGToLLVM::compileBooleanToNumber):
1302         (JSC::FTL::LowerDFGToLLVM::compileToThis):
1303         (JSC::FTL::LowerDFGToLLVM::compileValueAdd):
1304         (JSC::FTL::LowerDFGToLLVM::compileArithAddOrSub):
1305         (JSC::FTL::LowerDFGToLLVM::compileArithPow):
1306         (JSC::FTL::LowerDFGToLLVM::compileArithNegate):
1307         (JSC::FTL::LowerDFGToLLVM::compileGetById):
1308         (JSC::FTL::LowerDFGToLLVM::compileCheckArray):
1309         (JSC::FTL::LowerDFGToLLVM::compilePutByVal):
1310         (JSC::FTL::LowerDFGToLLVM::compileToStringOrCallStringConstructor):
1311         (JSC::FTL::LowerDFGToLLVM::compileToPrimitive):
1312         (JSC::FTL::LowerDFGToLLVM::compileStringCharAt):
1313         (JSC::FTL::LowerDFGToLLVM::compileStringCharCodeAt):
1314         (JSC::FTL::LowerDFGToLLVM::compileCompareStrictEq):
1315         (JSC::FTL::LowerDFGToLLVM::compileSwitch):
1316         (JSC::FTL::LowerDFGToLLVM::compileIsBoolean):
1317         (JSC::FTL::LowerDFGToLLVM::compileIsNumber):
1318         (JSC::FTL::LowerDFGToLLVM::compileIsString):
1319         (JSC::FTL::LowerDFGToLLVM::compileIsObject):
1320         (JSC::FTL::LowerDFGToLLVM::compileInstanceOf):
1321         (JSC::FTL::LowerDFGToLLVM::numberOrNotCellToInt32):
1322         (JSC::FTL::LowerDFGToLLVM::baseIndex):
1323         (JSC::FTL::LowerDFGToLLVM::compareEqObjectOrOtherToObject):
1324         (JSC::FTL::LowerDFGToLLVM::typedArrayLength):
1325         (JSC::FTL::LowerDFGToLLVM::boolify):
1326         (JSC::FTL::LowerDFGToLLVM::equalNullOrUndefined):
1327         (JSC::FTL::LowerDFGToLLVM::lowInt32):
1328         (JSC::FTL::LowerDFGToLLVM::lowInt52):
1329         (JSC::FTL::LowerDFGToLLVM::lowCell):
1330         (JSC::FTL::LowerDFGToLLVM::lowBoolean):
1331         (JSC::FTL::LowerDFGToLLVM::lowDouble):
1332         (JSC::FTL::LowerDFGToLLVM::isCellOrMisc):
1333         (JSC::FTL::LowerDFGToLLVM::isNotCellOrMisc):
1334         (JSC::FTL::LowerDFGToLLVM::isNumber):
1335         (JSC::FTL::LowerDFGToLLVM::isNotNumber):
1336         (JSC::FTL::LowerDFGToLLVM::isNotCell):
1337         (JSC::FTL::LowerDFGToLLVM::isCell):
1338         (JSC::FTL::LowerDFGToLLVM::isNotMisc):
1339         (JSC::FTL::LowerDFGToLLVM::isMisc):
1340         (JSC::FTL::LowerDFGToLLVM::isNotBoolean):
1341         (JSC::FTL::LowerDFGToLLVM::isBoolean):
1342         (JSC::FTL::LowerDFGToLLVM::isNotOther):
1343         (JSC::FTL::LowerDFGToLLVM::isOther):
1344         (JSC::FTL::LowerDFGToLLVM::isProvenValue):
1345         (JSC::FTL::LowerDFGToLLVM::isObject):
1346         (JSC::FTL::LowerDFGToLLVM::isNotObject):
1347         (JSC::FTL::LowerDFGToLLVM::isNotString):
1348         (JSC::FTL::LowerDFGToLLVM::isString):
1349         (JSC::FTL::LowerDFGToLLVM::isFunction):
1350         (JSC::FTL::LowerDFGToLLVM::isNotFunction):
1351         (JSC::FTL::LowerDFGToLLVM::speculateObjectOrOther):
1352         (JSC::FTL::LowerDFGToLLVM::speculateStringObjectForStructureID):
1353         (JSC::FTL::LowerDFGToLLVM::speculateNotStringVar):
1354         (JSC::FTL::LowerDFGToLLVM::abstractValue):
1355         (JSC::FTL::LowerDFGToLLVM::provenType):
1356         (JSC::FTL::LowerDFGToLLVM::provenValue):
1357         (JSC::FTL::LowerDFGToLLVM::abstractStructure):
1358
1359 2015-05-01  Martin Robinson  <mrobinson@igalia.com>
1360
1361         USE(...) macro should expect unprefixed variables
1362         https://bugs.webkit.org/show_bug.cgi?id=144454
1363
1364         Reviewed by Daniel Bates.
1365
1366         * CMakeLists.txt: Replace all occurrences WTF_USE with USE.
1367
1368 2015-05-01  Jordan Harband  <ljharb@gmail.com>
1369
1370         String#startsWith/endsWith/includes don't handle Infinity position/endPosition args correctly
1371         https://bugs.webkit.org/show_bug.cgi?id=144314
1372
1373         Reviewed by Darin Adler.
1374
1375         Fixing handling of Infinity position args, per
1376         https://people.mozilla.org/~jorendorff/es6-draft.html#sec-string.prototype.includes
1377         https://people.mozilla.org/~jorendorff/es6-draft.html#sec-string.prototype.startswith
1378         https://people.mozilla.org/~jorendorff/es6-draft.html#sec-string.prototype.endswith
1379
1380         * runtime/StringPrototype.cpp:
1381         (JSC::clampInt32):
1382         (JSC::stringProtoFuncStartsWith):
1383         (JSC::stringProtoFuncEndsWith):
1384         (JSC::stringProtoFuncIncludes):
1385
1386 2015-05-01  Basile Clement  <basile_clement@apple.com>
1387
1388         Math.abs() returns negative
1389         https://bugs.webkit.org/show_bug.cgi?id=137827
1390
1391         Reviewed by Michael Saboff.
1392
1393         Math.abs() on doubles was mistakenly assumed by the DFG AI to be the
1394         identity function.
1395
1396         * dfg/DFGAbstractInterpreterInlines.h:
1397         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
1398         * tests/stress/math-abs-positive.js: Added, was previously failing.
1399         (foo):
1400
1401 2015-05-01  Basile Clement  <basile_clement@apple.com>
1402
1403         Function allocation sinking shouldn't be performed on singleton functions
1404         https://bugs.webkit.org/show_bug.cgi?id=144166
1405
1406         Reviewed by Geoffrey Garen.
1407
1408         Function allocations usually are free of any other side effects, but
1409         this is not the case for allocations performed while the underlying
1410         FunctionExecutable is still a singleton (as this allogation will fire
1411         watchpoints invalidating code that depends on it being a singleton).
1412         As the object allocation sinking phase assumes object allocation is
1413         free of side-effects, sinking these allocations is not correct.
1414
1415         This also means that when materializing a function allocation on OSR
1416         exit, that function's executable will never be a singleton, and we don't have
1417         to worry about its watchpoint, allowing us to use
1418         JSFunction::createWithInvalidatedRellocationWatchpoint instead of
1419         JSFunction::create.
1420
1421         * dfg/DFGObjectAllocationSinkingPhase.cpp:
1422         (JSC::DFG::ObjectAllocationSinkingPhase::handleNode):
1423         * ftl/FTLOperations.cpp:
1424         (JSC::FTL::operationMaterializeObjectInOSR):
1425
1426 2015-04-30  Jon Davis  <jond@apple.com>
1427
1428         Web Inspector: console should show an icon for console.info() messages
1429         https://bugs.webkit.org/show_bug.cgi?id=18530
1430
1431         Reviewed by Timothy Hatcher.
1432
1433         * inspector/ConsoleMessage.cpp:
1434         (Inspector::messageLevelValue):
1435         * inspector/protocol/Console.json:
1436         * runtime/ConsoleClient.cpp:
1437         (JSC::appendMessagePrefix):
1438         * runtime/ConsolePrototype.cpp:
1439         (JSC::ConsolePrototype::finishCreation):
1440         (JSC::consoleProtoFuncInfo):
1441         * runtime/ConsoleTypes.h:
1442
1443 2015-04-30  Filip Pizlo  <fpizlo@apple.com>
1444
1445         Move all of the branchIs<type> helpers from SpeculativeJIT into AssemblyHelpers
1446         https://bugs.webkit.org/show_bug.cgi?id=144462
1447
1448         Reviewed by Geoffrey Garen and Mark Lam.
1449         
1450         At some point we started adding representation-agnostic helpers for doing common type tests.
1451         We added some in SpeculativeJIT, and then some in AssemblyHelpers. Prior to this change,
1452         they had overlapping powers, though SpeculativeJIT was a bit better.
1453         
1454         This removes SpeculativeJIT's helpers and strengthens AssemblyHelpers' helpers. This is
1455         better because now all of these helpers can be used in all of the assembly-based JITs, not
1456         just the DFG. It also settles on what I find to be a slightly better naming convention.
1457         For example where we previously would have said branchIsString, now we say
1458         branchIfString. Similarly, branchNotString becomes branchIfNotString.
1459
1460         * dfg/DFGSpeculativeJIT.cpp:
1461         (JSC::DFG::SpeculativeJIT::compilePeepHoleObjectEquality):
1462         (JSC::DFG::SpeculativeJIT::compileValueToInt32):
1463         (JSC::DFG::SpeculativeJIT::compileInstanceOfForObject):
1464         (JSC::DFG::SpeculativeJIT::compileInstanceOf):
1465         (JSC::DFG::SpeculativeJIT::compileStringToUntypedEquality):
1466         (JSC::DFG::SpeculativeJIT::compileStringIdentToNotStringVarEquality):
1467         (JSC::DFG::SpeculativeJIT::compileGetByValOnScopedArguments):
1468         (JSC::DFG::SpeculativeJIT::compileToStringOrCallStringConstructorOnCell):
1469         (JSC::DFG::SpeculativeJIT::speculateObject):
1470         (JSC::DFG::SpeculativeJIT::speculateObjectOrOther):
1471         (JSC::DFG::SpeculativeJIT::speculateString):
1472         (JSC::DFG::SpeculativeJIT::speculateNotStringVar):
1473         (JSC::DFG::SpeculativeJIT::speculateNotCell):
1474         (JSC::DFG::SpeculativeJIT::speculateOther):
1475         (JSC::DFG::SpeculativeJIT::emitSwitchChar):
1476         (JSC::DFG::SpeculativeJIT::emitSwitchString):
1477         (JSC::DFG::SpeculativeJIT::branchIsObject): Deleted.
1478         (JSC::DFG::SpeculativeJIT::branchNotObject): Deleted.
1479         (JSC::DFG::SpeculativeJIT::branchIsString): Deleted.
1480         (JSC::DFG::SpeculativeJIT::branchNotString): Deleted.
1481         * dfg/DFGSpeculativeJIT.h:
1482         * dfg/DFGSpeculativeJIT32_64.cpp:
1483         (JSC::DFG::SpeculativeJIT::nonSpeculativeNonPeepholeCompareNull):
1484         (JSC::DFG::SpeculativeJIT::nonSpeculativePeepholeBranchNull):
1485         (JSC::DFG::SpeculativeJIT::emitCall):
1486         (JSC::DFG::SpeculativeJIT::fillSpeculateCell):
1487         (JSC::DFG::SpeculativeJIT::compileObjectEquality):
1488         (JSC::DFG::SpeculativeJIT::compileObjectToObjectOrOtherEquality):
1489         (JSC::DFG::SpeculativeJIT::compilePeepHoleObjectToObjectOrOtherEquality):
1490         (JSC::DFG::SpeculativeJIT::compileObjectOrOtherLogicalNot):
1491         (JSC::DFG::SpeculativeJIT::emitObjectOrOtherBranch):
1492         (JSC::DFG::SpeculativeJIT::compile):
1493         (JSC::DFG::SpeculativeJIT::branchIsCell): Deleted.
1494         (JSC::DFG::SpeculativeJIT::branchNotCell): Deleted.
1495         (JSC::DFG::SpeculativeJIT::branchIsOther): Deleted.
1496         (JSC::DFG::SpeculativeJIT::branchNotOther): Deleted.
1497         * dfg/DFGSpeculativeJIT64.cpp:
1498         (JSC::DFG::SpeculativeJIT::nonSpeculativeNonPeepholeCompareNull):
1499         (JSC::DFG::SpeculativeJIT::nonSpeculativePeepholeBranchNull):
1500         (JSC::DFG::SpeculativeJIT::fillSpeculateCell):
1501         (JSC::DFG::SpeculativeJIT::compileObjectEquality):
1502         (JSC::DFG::SpeculativeJIT::compileObjectToObjectOrOtherEquality):
1503         (JSC::DFG::SpeculativeJIT::compilePeepHoleObjectToObjectOrOtherEquality):
1504         (JSC::DFG::SpeculativeJIT::compileObjectOrOtherLogicalNot):
1505         (JSC::DFG::SpeculativeJIT::emitObjectOrOtherBranch):
1506         (JSC::DFG::SpeculativeJIT::compile):
1507         (JSC::DFG::SpeculativeJIT::writeBarrier):
1508         (JSC::DFG::SpeculativeJIT::branchIsCell): Deleted.
1509         (JSC::DFG::SpeculativeJIT::branchNotCell): Deleted.
1510         (JSC::DFG::SpeculativeJIT::branchIsOther): Deleted.
1511         (JSC::DFG::SpeculativeJIT::branchNotOther): Deleted.
1512         * jit/AssemblyHelpers.h:
1513         (JSC::AssemblyHelpers::branchIfCell):
1514         (JSC::AssemblyHelpers::branchIfOther):
1515         (JSC::AssemblyHelpers::branchIfNotOther):
1516         (JSC::AssemblyHelpers::branchIfObject):
1517         (JSC::AssemblyHelpers::branchIfNotObject):
1518         (JSC::AssemblyHelpers::branchIfType):
1519         (JSC::AssemblyHelpers::branchIfNotType):
1520         (JSC::AssemblyHelpers::branchIfString):
1521         (JSC::AssemblyHelpers::branchIfNotString):
1522         (JSC::AssemblyHelpers::branchIfSymbol):
1523         (JSC::AssemblyHelpers::branchIfNotSymbol):
1524         (JSC::AssemblyHelpers::branchIfFunction):
1525         (JSC::AssemblyHelpers::branchIfNotFunction):
1526         (JSC::AssemblyHelpers::branchIfEmpty):
1527         (JSC::AssemblyHelpers::branchIsEmpty): Deleted.
1528         (JSC::AssemblyHelpers::branchIfCellNotObject): Deleted.
1529         * jit/JITPropertyAccess.cpp:
1530         (JSC::JIT::emitScopedArgumentsGetByVal):
1531
1532 2015-04-30  Filip Pizlo  <fpizlo@apple.com>
1533
1534         js/regress/is-string-fold-tricky.html and js/regress/is-string-fold.html are crashing
1535         https://bugs.webkit.org/show_bug.cgi?id=144463
1536
1537         Reviewed by Benjamin Poulain.
1538         
1539         Fixup phase was super cleverly folding an IsString(@x) when @x is predicted SpecString
1540         into a Check(String:@x) followed by JSConstant(true). Then in these tests the
1541         ValueAdd(IsString(@x), @stuff) would try to turn this into an integer add by cleverly
1542         converting the boolean into an integer. But as part of doing that, it would try to
1543         short-circuit any profiling by leveraging the fact that the IsString is now a constant,
1544         and it would try to figure out if the addition might overflow. Part of that logic
1545         involved checking if the immediate is either a boolean or a sufficiently small integer.
1546         But: it would check if it's a sufficiently small integer before checking if it was a
1547         boolean, so it would try to call asNumber() on the boolean.
1548         
1549         All of this cleverness was very deliberate, but apparently the @stuff + booleanConstant
1550         case was previously never hit until I wrote these tests, and so we never knew that
1551         calling asNumber() on a boolean was wrong.
1552         
1553         The fix is super simple: the expression should just check for boolean first.
1554         
1555         This bug was benign in release builds. JSValue::asNumber() on a boolean would return
1556         garbage, and that's OK, since we'd take the boolean case anyway.
1557
1558         * dfg/DFGGraph.h:
1559         (JSC::DFG::Graph::addImmediateShouldSpeculateInt32):
1560
1561 2015-04-30  Filip Pizlo  <fpizlo@apple.com>
1562
1563         Unreviewed, add a FIXME comment referencing https://bugs.webkit.org/show_bug.cgi?id=144458.
1564
1565         * jit/JITOperations.cpp:
1566
1567 2015-04-30  Filip Pizlo  <fpizlo@apple.com>
1568
1569         Add a comment clarifying the behavior and semantics of getCallData/getConstructData, in
1570         particular that they cannot change their minds and may be called from compiler threads.
1571
1572         Rubber stamped by Geoffrey Garen.
1573
1574         * runtime/JSCell.h:
1575
1576 2015-04-29  Filip Pizlo  <fpizlo@apple.com>
1577
1578         DFG Is<Blah> versions of TypeOf should fold based on proven input type
1579         https://bugs.webkit.org/show_bug.cgi?id=144409
1580
1581         Reviewed by Geoffrey Garen.
1582         
1583         We were missing some obvious folding opportunities here. I don't know how this affects real
1584         code, but in general, we like to ensure that our constant folding is comprehensive. So this
1585         is more about placating my static analysis OCD than anything else.
1586         
1587         I added a bunch of speed/correctness tests for this in LayoutTests/js/regress.
1588
1589         * dfg/DFGAbstractInterpreterInlines.h:
1590         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
1591
1592 2015-04-30  Yusuke Suzuki  <utatane.tea@gmail.com>
1593
1594         Use the default hash value for Symbolized StringImpl
1595         https://bugs.webkit.org/show_bug.cgi?id=144347
1596
1597         Reviewed by Darin Adler.
1598
1599         Before this patch, symbolized StringImpl* has a special hash value
1600         to avoid the hash collision with the other normal StringImpl*.
1601         I guess that it is introduced when private symbols are introduced.
1602         However, it prevents using symbolized StringImpl* in the other place
1603         For example, using it as WTFString cause a problem because of its special hash value.
1604
1605         When only using private symbols, they are not exposed to the outside of JSC,
1606         so we can handle it carefully. But now, it's extended to symbols.
1607         So I think storing a special hash value in StringImpl* causes an error.
1608
1609         To avoid this, I propose using the usual hash value in symbolized StringImpl*.
1610         And to provide significantly different hash value when using it as symbol,
1611         store the additional hash value in symbolized StringImpl*. It is used when
1612         the hash value is required by IdentifierRepHash.
1613
1614         * runtime/Identifier.h:
1615         (JSC::IdentifierRepHash::hash):
1616         * runtime/Lookup.h:
1617         (JSC::HashTable::entry):
1618         * runtime/PropertyMapHashTable.h:
1619         (JSC::PropertyTable::find):
1620         (JSC::PropertyTable::get):
1621         * runtime/Structure.cpp:
1622         (JSC::PropertyTable::checkConsistency):
1623
1624 2015-04-29  Benjamin Poulain  <bpoulain@apple.com>
1625
1626         [JSC] Remove RageConvert array conversion
1627         https://bugs.webkit.org/show_bug.cgi?id=144433
1628
1629         Reviewed by Filip Pizlo.
1630
1631         RageConvert was causing a subtle bug that was hitting the Kraken crypto tests
1632         pretty hard:
1633         -The indexing types shows that the array access varies between Int32 and DoubleArray.
1634         -ArrayMode::fromObserved() decided to use the most generic type: DoubleArray.
1635          An Arrayify node would convert the Int32 to that type.
1636         -Somewhere, a GetByVal or PutByVal would have the flag NodeBytecodeUsesAsInt. That
1637          node would use RageConvert instead of Convert.
1638         -The Arrayify for that GetByVal with RageConvert would not convert the array to
1639          Contiguous.
1640         -All the following array access that do not have the flag NodeBytecodeUsesAsInt would
1641          now expect a DoubleArray and always get a Contiguous Array. The CheckStructure
1642          fail systematically and we never get to run the later code.
1643
1644         Getting rid of RageConvert fixes the problem and does not seems to have any
1645         negative side effect on other benchmarks.
1646
1647         The improvments on Kraken are:
1648             -stanford-crypto-aes: definitely 1.0915x faster.
1649             -stanford-crypto-pbkdf2: definitely 1.2446x faster.
1650             -stanford-crypto-sha256-iterative: definitely 1.0544x faster.
1651
1652         * dfg/DFGAbstractInterpreterInlines.h:
1653         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
1654         * dfg/DFGArrayMode.cpp:
1655         (JSC::DFG::ArrayMode::refine):
1656         (JSC::DFG::arrayConversionToString):
1657         * dfg/DFGArrayMode.h:
1658         * dfg/DFGArrayifySlowPathGenerator.h:
1659         * dfg/DFGFixupPhase.cpp:
1660         (JSC::DFG::FixupPhase::fixupNode):
1661         * dfg/DFGOperations.cpp:
1662         * dfg/DFGOperations.h:
1663         * dfg/DFGPredictionPropagationPhase.cpp:
1664         (JSC::DFG::PredictionPropagationPhase::propagate):
1665         * dfg/DFGTypeCheckHoistingPhase.cpp:
1666         (JSC::DFG::TypeCheckHoistingPhase::identifyRedundantStructureChecks):
1667         * ftl/FTLLowerDFGToLLVM.cpp:
1668         (JSC::FTL::LowerDFGToLLVM::compileArrayifyToStructure):
1669         * runtime/JSObject.cpp:
1670         (JSC::JSObject::convertDoubleToContiguous):
1671         (JSC::JSObject::ensureContiguousSlow):
1672         (JSC::JSObject::genericConvertDoubleToContiguous): Deleted.
1673         (JSC::JSObject::rageConvertDoubleToContiguous): Deleted.
1674         (JSC::JSObject::rageEnsureContiguousSlow): Deleted.
1675         * runtime/JSObject.h:
1676         (JSC::JSObject::rageEnsureContiguous): Deleted.
1677
1678 2015-04-29  Joseph Pecoraro  <pecoraro@apple.com>
1679
1680         Gracefully handle missing auto pause key on remote inspector setup
1681         https://bugs.webkit.org/show_bug.cgi?id=144411
1682
1683         Reviewed by Timothy Hatcher.
1684
1685         * inspector/remote/RemoteInspector.mm:
1686         (Inspector::RemoteInspector::receivedSetupMessage):
1687
1688 2015-04-29  Joseph Pecoraro  <pecoraro@apple.com>
1689
1690         NodeList has issues with Symbol and empty string
1691         https://bugs.webkit.org/show_bug.cgi?id=144310
1692
1693         Reviewed by Darin Adler.
1694
1695         * runtime/PropertyName.h:
1696         (JSC::PropertyName::isSymbol):
1697         Helper to check if the PropertyName is a string or symbol property.
1698
1699 2015-04-29  Alex Christensen  <achristensen@webkit.org>
1700
1701         Fix non-cygwin incremental builds on Windows.
1702         https://bugs.webkit.org/show_bug.cgi?id=143264
1703
1704         Reviewed by Brent Fulgham.
1705
1706         * generate-js-builtins:
1707         Remove stale headers before calling os.rename to replace them.
1708
1709 2015-04-29  Filip Pizlo  <fpizlo@apple.com>
1710
1711         JSTypeInfo should have an inline type flag to indicate of getCallData() has been overridden
1712         https://bugs.webkit.org/show_bug.cgi?id=144397
1713
1714         Reviewed by Andreas Kling.
1715         
1716         Add the flag to JSTypeInfo. It's an inline flag so that it's fast to query. Slap the flag on
1717         callback objects and internal functions. Modify the TypeOf operation to use this flag to avoid
1718         making a getCallData() call if it isn't necessary.
1719
1720         * API/JSCallbackObject.h:
1721         * runtime/InternalFunction.h:
1722         * runtime/JSTypeInfo.h:
1723         (JSC::TypeInfo::typeOfShouldCallGetCallData):
1724         * runtime/Operations.cpp:
1725         (JSC::jsTypeStringForValue):
1726         * tests/stress/type-of-functions-and-objects.js: Added.
1727         (foo):
1728         (bar):
1729         (baz):
1730         (fuzz):
1731         (expect):
1732         (test):
1733
1734 2015-04-28  Geoffrey Garen  <ggaren@apple.com>
1735
1736         It shouldn't take 1846 lines of code and 5 FIXMEs to sort an array.
1737         https://bugs.webkit.org/show_bug.cgi?id=144013
1738
1739         Reviewed by Mark Lam.
1740
1741         This patch implements Array.prototype.sort in JavaScript, removing the
1742         C++ implementations. It is simpler and less error-prone to express our
1743         operations in JavaScript, which provides memory safety, exception safety,
1744         and recursion safety.
1745
1746         The performance result is mixed, but net positive in my opinion. It's
1747         difficult to enumerate all the results, since we used to have so many
1748         different sorting modes, and there are lots of different data patterns
1749         across which you might want to measure sorting. Suffice it to say:
1750
1751             (*) The benchmarks we track are faster or unchanged.
1752
1753             (*) Sorting random input using a comparator -- which we think is
1754             common -- is 3X faster.
1755
1756             (*) Sorting random input in a non-array object -- which jQuery does
1757             -- is 4X faster.
1758
1759             (*) Sorting random input in a compact array of integers using a
1760             trivial pattern-matchable comparator is 2X *slower*.
1761
1762         * builtins/Array.prototype.js:
1763         (sort.min):
1764         (sort.stringComparator):
1765         (sort.compactSparse): Special case compaction for sparse arrays because
1766         we don't want to hang when sorting new Array(BIG).
1767
1768         (sort.compact):
1769         (sort.merge):
1770         (sort.mergeSort): Use merge sort because it's a reasonably efficient
1771         stable sort. We have evidence that some sites depend on stable sort,
1772         even though the ES6 spec does not mandate it. (See
1773         <http://trac.webkit.org/changeset/33967>.)
1774
1775         This is a textbook implementation of merge sort with three optimizations:
1776
1777             (1) Use iteration instead of recursion;
1778
1779             (2) Use array subscripting instead of array copying in order to
1780             create logical sub-lists without creating physical sub-lists;
1781
1782             (3) Swap src and dst at each iteration instead of copying src into
1783             dst, and only copy src into the subject array at the end if src is
1784             not the subject array.
1785
1786         (sort.inflate):
1787         (sort.comparatorSort):
1788         (sort): Sort in JavaScript for the win.
1789
1790         * builtins/BuiltinExecutables.cpp:
1791         (JSC::BuiltinExecutables::createExecutableInternal): Allow non-private
1792         names so we can use helper functions.
1793
1794         * bytecode/CodeBlock.h:
1795         (JSC::CodeBlock::isNumericCompareFunction): Deleted.
1796         * bytecode/UnlinkedCodeBlock.cpp:
1797         (JSC::UnlinkedCodeBlock::UnlinkedCodeBlock):
1798         * bytecode/UnlinkedCodeBlock.h:
1799         (JSC::UnlinkedCodeBlock::setIsNumericCompareFunction): Deleted.
1800         (JSC::UnlinkedCodeBlock::isNumericCompareFunction): Deleted.
1801         * bytecompiler/BytecodeGenerator.cpp:
1802         (JSC::BytecodeGenerator::setIsNumericCompareFunction): Deleted.
1803         * bytecompiler/BytecodeGenerator.h:
1804         * bytecompiler/NodesCodegen.cpp:
1805         (JSC::FunctionNode::emitBytecode): We don't do this special casing based
1806         on pattern matching anymore. This was mainly an optimization to avoid 
1807         the overhead of calling from C++ to JS, which we now avoid by
1808         sorting in JS.
1809
1810         * heap/Heap.cpp:
1811         (JSC::Heap::markRoots):
1812         (JSC::Heap::pushTempSortVector): Deleted.
1813         (JSC::Heap::popTempSortVector): Deleted.
1814         (JSC::Heap::visitTempSortVectors): Deleted.
1815         * heap/Heap.h: We don't have temp sort vectors anymore because we sort
1816         in JavaScript using a normal JavaScript array for our temporary storage.
1817
1818         * parser/Parser.cpp:
1819         (JSC::Parser<LexerType>::parseInner): Allow capturing so we can use
1820         helper functions.
1821
1822         * runtime/ArrayPrototype.cpp:
1823         (JSC::isNumericCompareFunction): Deleted.
1824         (JSC::attemptFastSort): Deleted.
1825         (JSC::performSlowSort): Deleted.
1826         (JSC::arrayProtoFuncSort): Deleted.
1827
1828         * runtime/CommonIdentifiers.h: New strings used by sort.
1829
1830         * runtime/JSArray.cpp:
1831         (JSC::compareNumbersForQSortWithInt32): Deleted.
1832         (JSC::compareNumbersForQSortWithDouble): Deleted.
1833         (JSC::compareNumbersForQSort): Deleted.
1834         (JSC::compareByStringPairForQSort): Deleted.
1835         (JSC::JSArray::sortNumericVector): Deleted.
1836         (JSC::JSArray::sortNumeric): Deleted.
1837         (JSC::ContiguousTypeAccessor::getAsValue): Deleted.
1838         (JSC::ContiguousTypeAccessor::setWithValue): Deleted.
1839         (JSC::ContiguousTypeAccessor::replaceDataReference): Deleted.
1840         (JSC::ContiguousTypeAccessor<ArrayWithDouble>::getAsValue): Deleted.
1841         (JSC::ContiguousTypeAccessor<ArrayWithDouble>::setWithValue): Deleted.
1842         (JSC::ContiguousTypeAccessor<ArrayWithDouble>::replaceDataReference): Deleted.
1843         (JSC::JSArray::sortCompactedVector): Deleted.
1844         (JSC::JSArray::sort): Deleted.
1845         (JSC::AVLTreeAbstractorForArrayCompare::get_less): Deleted.
1846         (JSC::AVLTreeAbstractorForArrayCompare::set_less): Deleted.
1847         (JSC::AVLTreeAbstractorForArrayCompare::get_greater): Deleted.
1848         (JSC::AVLTreeAbstractorForArrayCompare::set_greater): Deleted.
1849         (JSC::AVLTreeAbstractorForArrayCompare::get_balance_factor): Deleted.
1850         (JSC::AVLTreeAbstractorForArrayCompare::set_balance_factor): Deleted.
1851         (JSC::AVLTreeAbstractorForArrayCompare::compare_key_key): Deleted.
1852         (JSC::AVLTreeAbstractorForArrayCompare::compare_key_node): Deleted.
1853         (JSC::AVLTreeAbstractorForArrayCompare::compare_node_node): Deleted.
1854         (JSC::AVLTreeAbstractorForArrayCompare::null): Deleted.
1855         (JSC::JSArray::sortVector): Deleted.
1856         (JSC::JSArray::compactForSorting): Deleted.
1857         * runtime/JSArray.h:
1858
1859         * runtime/JSGlobalObject.cpp:
1860         (JSC::JSGlobalObject::init):
1861         * runtime/ObjectConstructor.cpp:
1862         (JSC::ObjectConstructor::finishCreation): Provide some builtins used
1863         by sort.
1864
1865 2015-04-29  Mark Lam  <mark.lam@apple.com>
1866
1867         Safari WebKit crash when loading Google Spreadsheet.
1868         https://bugs.webkit.org/show_bug.cgi?id=144020
1869
1870         Reviewed by Filip Pizlo.
1871
1872         The bug is that the object allocation sinking phase did not account for a case
1873         where a property of a sunken object is only initialized on one path and not
1874         another.  As a result, on the path where the property is not initialized, we'll
1875         encounter an Upsilon with a BottomValue (which is not allowed by definition).
1876
1877         The fix is to use a JSConstant(undefined) as the bottom value instead (of
1878         BottomValue).  If the property is uninitialized, it should still be accessible
1879         and have the value undefined.
1880
1881         * dfg/DFGObjectAllocationSinkingPhase.cpp:
1882         (JSC::DFG::ObjectAllocationSinkingPhase::promoteSunkenFields):
1883         * tests/stress/object-allocation-sinking-with-uninitialized-property-on-one-path.js: Added.
1884         (foo):
1885         (foo2):
1886
1887 2015-04-29  Yusuke Suzuki  <utatane.tea@gmail.com>
1888
1889         REGRESSION (r183373): ASSERT failed in wtf/SHA1.h
1890         https://bugs.webkit.org/show_bug.cgi?id=144257
1891
1892         Reviewed by Darin Adler.
1893
1894         SHA1 is used to calculate CodeBlockHash.
1895         To calculate hash value, we pass the source code UTF-8 CString to SHA1::addBytes.
1896         However, the source code can contain null character.
1897         So when performing `strlen` on the source code's CString, it returns the incorrect length.
1898         In SHA1::addBytes, there's assertion `input.length() == strlen(string)` and it fails.
1899
1900         In the template-literal-syntax.js, we perform `eval` with the script contains "\0".
1901         As the result, `strlen(string)` accidentally shortened by the contained "\0", and assertion fails.
1902
1903         CString will be changed not to contain a null-character[1]. However, inserting the assertion here
1904         is not correct. Because
1905
1906         1. If CString should not contain a null character, this should be asserted in CString side instead of SHA1::addBytes.
1907         2. If CString can contain a null character, this assertion becomes incorrect.
1908
1909         So this patch just drops the assertion.
1910
1911         In the current implementation, we once convert the entire source code to the newly allocated
1912         UTF-8 string and pass it to the SHA1 processing. However, this is memory consuming.
1913         Ideally, we should stream the decoded bytes into the SHA1 processing iteratively.
1914         We'll implement it in the separate patch[2].
1915
1916         [1]: https://bugs.webkit.org/show_bug.cgi?id=144339
1917         [2]: https://bugs.webkit.org/show_bug.cgi?id=144263
1918
1919         * tests/stress/eval-script-contains-null-character.js: Added.
1920         (shouldBe):
1921         (test):
1922         * tests/stress/template-literal-line-terminators.js:
1923         * tests/stress/template-literal-syntax.js:
1924         * tests/stress/template-literal.js:
1925
1926 2015-04-29  Filip Pizlo  <fpizlo@apple.com>
1927
1928         Evict IsEnvironmentRecord from inline type flags
1929         https://bugs.webkit.org/show_bug.cgi?id=144398
1930
1931         Reviewed by Mark Lam and Michael Saboff.
1932         
1933         In https://bugs.webkit.org/show_bug.cgi?id=144397, we'll need an extra bit in the inline
1934         type flags. This change picks the least important inline type flag - IsEnvironmentRecord -
1935         and evicts it into the out-of-line type flags. This change has no performance implications
1936         because we never even accessed IsEnvironmentRecord via the StructureIDBlob. The only place
1937         where we access it at all is in String.prototype.repeat, and there we already load the
1938         structure anyway.
1939
1940         * runtime/JSTypeInfo.h:
1941         (JSC::TypeInfo::implementsHasInstance):
1942         (JSC::TypeInfo::structureIsImmortal):
1943         (JSC::TypeInfo::isEnvironmentRecord):
1944
1945 2015-04-29  Darin Adler  <darin@apple.com>
1946
1947         [ES6] Implement Unicode code point escapes
1948         https://bugs.webkit.org/show_bug.cgi?id=144377
1949
1950         Reviewed by Antti Koivisto.
1951
1952         * parser/Lexer.cpp: Moved the UnicodeHexValue class in here from
1953         the header. Made it a non-member class so it doesn't need to be part
1954         of a template. Made it use UChar32 instead of int for the value to
1955         make it clearer what goes into this class.
1956         (JSC::ParsedUnicodeEscapeValue::isIncomplete): Added. Replaces the
1957         old type() function.
1958         (JSC::Lexer<CharacterType>::parseUnicodeEscape): Renamed from
1959         parseFourDigitUnicodeHex and added support for code point escapes.
1960         (JSC::isLatin1): Added an overload for UChar32.
1961         (JSC::isIdentStart): Changed this to take UChar32; no caller tries
1962         to call it with a UChar, so no need to overload for that type for now.
1963         (JSC::isNonLatin1IdentPart): Changed argument type to UChar32 for clarity.
1964         Also added FIXME about a subtle ES6 change that we might want to make later.
1965         (JSC::isIdentPart): Changed this to take UChar32; no caller tries
1966         to call it with a UChar, so no need to overload for that type for now.
1967         (JSC::isIdentPartIncludingEscapeTemplate): Made this a template so that we
1968         don't need to repeat the code twice. Added code to handle code point escapes.
1969         (JSC::isIdentPartIncludingEscape): Call the template instead of having the
1970         code in line.
1971         (JSC::Lexer<CharacterType>::recordUnicodeCodePoint): Added.
1972         (JSC::Lexer<CharacterType>::parseIdentifierSlowCase): Made small tweaks and
1973         updated to call parseUnicodeEscape instead of parseFourDigitUnicodeHex.
1974         (JSC::Lexer<CharacterType>::parseComplexEscape): Call parseUnicodeEscape
1975         instead of parseFourDigitUnicodeHex. Move the code to handle "\u" before
1976         the code that handles the escapes, since the code point escape code now
1977         consumes characters while parsing rather than peeking ahead. Test case
1978         covers this: Symptom would be that "\u{" would evaluate to "u" instead of
1979         giving a syntax error.
1980
1981         * parser/Lexer.h: Updated for above changes.
1982
1983         * runtime/StringConstructor.cpp:
1984         (JSC::stringFromCodePoint): Use ICU's UCHAR_MAX_VALUE instead of writing
1985         out 0x10FFFF; clearer this way.
1986
1987 2015-04-29  Martin Robinson  <mrobinson@igalia.com>
1988
1989         [CMake] [GTK] Organize and clean up unused CMake variables
1990         https://bugs.webkit.org/show_bug.cgi?id=144364
1991
1992         Reviewed by Gyuyoung Kim.
1993
1994         * PlatformGTK.cmake: Add variables specific to this project.
1995
1996 2015-04-28  Filip Pizlo  <fpizlo@apple.com>
1997
1998         TypeOf should return SpecStringIdent and the DFG should know this
1999         https://bugs.webkit.org/show_bug.cgi?id=144376
2000
2001         Reviewed by Andreas Kling.
2002         
2003         Make TypeOf return atomic strings. That's a simple change in SmallStrings.
2004         
2005         Make the DFG know this and use it for optimization. This makes Switch(TypeOf) a bit less
2006         bad.
2007
2008         * dfg/DFGAbstractInterpreterInlines.h:
2009         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
2010         * dfg/DFGAbstractValue.cpp:
2011         (JSC::DFG::AbstractValue::setType):
2012         * dfg/DFGAbstractValue.h:
2013         (JSC::DFG::AbstractValue::setType):
2014         * dfg/DFGInPlaceAbstractState.cpp:
2015         (JSC::DFG::InPlaceAbstractState::initialize):
2016         * dfg/DFGPredictionPropagationPhase.cpp:
2017         (JSC::DFG::PredictionPropagationPhase::propagate):
2018         * runtime/SmallStrings.cpp:
2019         (JSC::SmallStrings::initialize):
2020         * tests/stress/switch-typeof-indirect.js: Added.
2021         (bar):
2022         (foo):
2023         (test):
2024         * tests/stress/switch-typeof-slightly-indirect.js: Added.
2025         (foo):
2026         (test):
2027         * tests/stress/switch-typeof.js: Added.
2028         (foo):
2029         (test):
2030
2031 2015-04-29  Joseph Pecoraro  <pecoraro@apple.com>
2032
2033         REGRESSION(181868): Windows Live SkyDrive cannot open an excel file
2034         https://bugs.webkit.org/show_bug.cgi?id=144373
2035
2036         Reviewed by Darin Adler.
2037
2038         Revert r181868 as it caused a failure on live.com. We can try
2039         re-enabling this exception after we make idl attributes configurable,
2040         which may have prevented this particular failure.
2041
2042         * runtime/ObjectPrototype.cpp:
2043         (JSC::objectProtoFuncDefineGetter):
2044         (JSC::objectProtoFuncDefineSetter):
2045
2046 2015-04-28  Joseph Pecoraro  <pecoraro@apple.com>
2047
2048         Deadlock on applications using JSContext on non-main thread
2049         https://bugs.webkit.org/show_bug.cgi?id=144370
2050
2051         Reviewed by Timothy Hatcher.
2052
2053         * inspector/remote/RemoteInspector.mm:
2054         (Inspector::RemoteInspector::singleton):
2055         Prevent a possible deadlock by assuming we can synchronously
2056         run something on the main queue at this time.
2057
2058 2015-04-28  Filip Pizlo  <fpizlo@apple.com>
2059
2060         FTL should fully support Switch (it currently lacks the SwitchString variant)
2061         https://bugs.webkit.org/show_bug.cgi?id=144348
2062
2063         Reviewed by Benjamin Poulain.
2064         
2065         This adds SwitchString support to the FTL. This is already tested by switch microbenchmarks
2066         in LayoutTests/js/regress.
2067
2068         * dfg/DFGCommon.cpp:
2069         (JSC::DFG::stringLessThan):
2070         * dfg/DFGCommon.h:
2071         * dfg/DFGOperations.cpp:
2072         * dfg/DFGOperations.h:
2073         * dfg/DFGSpeculativeJIT.cpp:
2074         (JSC::DFG::SpeculativeJIT::StringSwitchCase::operator<): Deleted.
2075         * dfg/DFGSpeculativeJIT.h:
2076         (JSC::DFG::SpeculativeJIT::StringSwitchCase::operator<):
2077         * ftl/FTLCapabilities.cpp:
2078         (JSC::FTL::canCompile):
2079         * ftl/FTLIntrinsicRepository.h:
2080         * ftl/FTLLowerDFGToLLVM.cpp:
2081         (JSC::FTL::LowerDFGToLLVM::compileSwitch):
2082         (JSC::FTL::LowerDFGToLLVM::switchString):
2083         (JSC::FTL::LowerDFGToLLVM::StringSwitchCase::StringSwitchCase):
2084         (JSC::FTL::LowerDFGToLLVM::StringSwitchCase::operator<):
2085         (JSC::FTL::LowerDFGToLLVM::CharacterCase::CharacterCase):
2086         (JSC::FTL::LowerDFGToLLVM::CharacterCase::operator<):
2087         (JSC::FTL::LowerDFGToLLVM::switchStringRecurse):
2088         (JSC::FTL::LowerDFGToLLVM::switchStringSlow):
2089         (JSC::FTL::LowerDFGToLLVM::appendOSRExit):
2090         * ftl/FTLOutput.cpp:
2091         (JSC::FTL::Output::check):
2092         * ftl/FTLOutput.h:
2093         * ftl/FTLWeight.h:
2094         (JSC::FTL::Weight::inverse):
2095         * jit/JITOperations.h:
2096
2097 2015-04-28  Michael Catanzaro  <mcatanzaro@igalia.com>
2098
2099         Fully replace ENABLE_LLINT_C_LOOP with ENABLE_JIT
2100         https://bugs.webkit.org/show_bug.cgi?id=144304
2101
2102         Reviewed by Geoffrey Garen.
2103
2104         * Configurations/FeatureDefines.xcconfig: Define ENABLE_JIT, enabled by default, instead of
2105         ENABLE_LLINT_C_LOOP, disabled by default.
2106         * llint/LLIntSlowPaths.cpp:
2107         (JSC::LLInt::LLINT_SLOW_PATH_DECL): Check ENABLE_JIT instead of ENABLE_LLINT_C_LOOP.
2108
2109 2015-04-28  Commit Queue  <commit-queue@webkit.org>
2110
2111         Unreviewed, rolling out r183514.
2112         https://bugs.webkit.org/show_bug.cgi?id=144359
2113
2114         It broke cloop test bots (Requested by mcatanzaro on #webkit).
2115
2116         Reverted changeset:
2117
2118         "Fully replace ENABLE_LLINT_C_LOOP with ENABLE_JIT"
2119         https://bugs.webkit.org/show_bug.cgi?id=144304
2120         http://trac.webkit.org/changeset/183514
2121
2122 2015-04-28  Michael Catanzaro  <mcatanzaro@igalia.com>
2123
2124         Fully replace ENABLE_LLINT_C_LOOP with ENABLE_JIT
2125         https://bugs.webkit.org/show_bug.cgi?id=144304
2126
2127         Reviewed by Geoffrey Garen.
2128
2129         * Configurations/FeatureDefines.xcconfig: Define ENABLE_JIT, enabled by default, instead of
2130         ENABLE_LLINT_C_LOOP, disabled by default.
2131         * llint/LLIntSlowPaths.cpp:
2132         (JSC::LLInt::LLINT_SLOW_PATH_DECL): Check ENABLE_JIT instead of ENABLE_LLINT_C_LOOP.
2133
2134 2015-04-28  Joseph Pecoraro  <pecoraro@apple.com>
2135
2136         Fix common typo "targetting" => "targeting"
2137         https://bugs.webkit.org/show_bug.cgi?id=144349
2138
2139         Reviewed by Daniel Bates.
2140
2141         * bytecode/ExecutionCounter.h:
2142
2143 2015-04-28  Yusuke Suzuki  <utatane.tea@gmail.com>
2144
2145         Update the features.json for WeakSet, WeakMap, Template literals, Tagged templates
2146         https://bugs.webkit.org/show_bug.cgi?id=144328
2147
2148         Reviewed by Andreas Kling.
2149
2150         Update the status of ES6 features.
2151
2152         * features.json:
2153
2154 2015-04-28  Filip Pizlo  <fpizlo@apple.com>
2155
2156         DFG should not use or preserve Phantoms during transformations
2157         https://bugs.webkit.org/show_bug.cgi?id=143736
2158
2159         Reviewed by Geoffrey Garen.
2160         
2161         Since http://trac.webkit.org/changeset/183207 and http://trac.webkit.org/changeset/183406, it is
2162         no longer necessary to preserve Phantoms during transformations. They are still useful just
2163         before FixupPhase to support backwards propagation analyses. They are still inserted late in the
2164         game in the DFG backend. But transformations don't need to worry about them. Inside a basic
2165         block, we can be sure that so long as the IR pinpoints the place where the value becomes
2166         available in a bytecode register (using MovHint) and so long as there is a SetLocal anytime some
2167         other block would need the value (either for OSR or for DFG execution), then we don't need any
2168         liveness markers.
2169         
2170         So, this removes any places where we inserted Phantoms just for liveness during transformation
2171         and it replaces convertToPhantom() with remove(), which just converts the node to a Check. A
2172         Check node only keeps its children so long as those children have checks.
2173         
2174         The fact that we no longer convertToPhantom() means that we have to be more careful when
2175         constant-folding GetLocal. Previously we would convertToPhantom() and use the fact that
2176         Phantom(Phi) was a valid construct. It's not valid anymore. So, when constant folding encounters
2177         a GetLocal it needs to insert a PhantomLocal directly. This allows us to simplify
2178         Graph::convertToConstant() a bit. Luckily, none of the other users of this method would see
2179         GetLocals.
2180         
2181         The only Phantom-like cruft left over after this patch is:
2182         
2183         - Phantoms before FixupPhase. I kind of like these. It means that before FixupPhase, we can do
2184           backwards analyses and rely on the fact that the users of a node in DFG IR are a superset of
2185           the users of the original local's live range in bytecode. This is essential for supporting our
2186           BackwardsPropagationPhase, which is an important optimization for things like asm.js.
2187         
2188         - PhantomLocals and GetLocals being NodeMustGenerate. See discussion in
2189           https://bugs.webkit.org/show_bug.cgi?id=144086. It appears that this is not as evil as the
2190           alternatives. The best long-term plan is to simply ditch the ThreadedCPS IR entirely and have
2191           the DFG use SSA. For now, so long as any new DFG optimizations we add are block-local and
2192           treat GetLocal/SetLocal conservatively, this should all be sound.
2193         
2194         This change should be perf-neutral although it does reduce the total work that the compiler
2195         does.
2196
2197         * CMakeLists.txt:
2198         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
2199         * JavaScriptCore.xcodeproj/project.pbxproj:
2200         * dfg/DFGAdjacencyList.h:
2201         (JSC::DFG::AdjacencyList::justChecks):
2202         * dfg/DFGArgumentsEliminationPhase.cpp:
2203         * dfg/DFGBasicBlock.cpp:
2204         (JSC::DFG::BasicBlock::replaceTerminal):
2205         * dfg/DFGBasicBlock.h:
2206         (JSC::DFG::BasicBlock::findTerminal):
2207         * dfg/DFGCFGSimplificationPhase.cpp:
2208         (JSC::DFG::CFGSimplificationPhase::keepOperandAlive):
2209         (JSC::DFG::CFGSimplificationPhase::mergeBlocks):
2210         * dfg/DFGCPSRethreadingPhase.cpp:
2211         (JSC::DFG::CPSRethreadingPhase::CPSRethreadingPhase):
2212         (JSC::DFG::CPSRethreadingPhase::clearVariables):
2213         (JSC::DFG::CPSRethreadingPhase::canonicalizeFlushOrPhantomLocalFor):
2214         (JSC::DFG::CPSRethreadingPhase::canonicalizeLocalsInBlock):
2215         * dfg/DFGCSEPhase.cpp:
2216         * dfg/DFGCleanUpPhase.cpp: Copied from Source/JavaScriptCore/dfg/DFGPhantomRemovalPhase.cpp.
2217         (JSC::DFG::CleanUpPhase::CleanUpPhase):
2218         (JSC::DFG::CleanUpPhase::run):
2219         (JSC::DFG::performCleanUp):
2220         (JSC::DFG::PhantomRemovalPhase::PhantomRemovalPhase): Deleted.
2221         (JSC::DFG::PhantomRemovalPhase::run): Deleted.
2222         (JSC::DFG::performPhantomRemoval): Deleted.
2223         * dfg/DFGCleanUpPhase.h: Copied from Source/JavaScriptCore/dfg/DFGPhantomRemovalPhase.h.
2224         * dfg/DFGConstantFoldingPhase.cpp:
2225         (JSC::DFG::ConstantFoldingPhase::foldConstants):
2226         (JSC::DFG::ConstantFoldingPhase::addBaseCheck):
2227         (JSC::DFG::ConstantFoldingPhase::fixUpsilons):
2228         * dfg/DFGDCEPhase.cpp:
2229         (JSC::DFG::DCEPhase::run):
2230         (JSC::DFG::DCEPhase::fixupBlock):
2231         (JSC::DFG::DCEPhase::cleanVariables):
2232         * dfg/DFGFixupPhase.cpp:
2233         (JSC::DFG::FixupPhase::fixupBlock):
2234         (JSC::DFG::FixupPhase::fixupNode):
2235         (JSC::DFG::FixupPhase::convertStringAddUse):
2236         (JSC::DFG::FixupPhase::attemptToMakeFastStringAdd):
2237         (JSC::DFG::FixupPhase::checkArray):
2238         (JSC::DFG::FixupPhase::fixIntConvertingEdge):
2239         (JSC::DFG::FixupPhase::fixIntOrBooleanEdge):
2240         (JSC::DFG::FixupPhase::fixDoubleOrBooleanEdge):
2241         (JSC::DFG::FixupPhase::injectTypeConversionsInBlock):
2242         (JSC::DFG::FixupPhase::tryToRelaxRepresentation):
2243         (JSC::DFG::FixupPhase::injectTypeConversionsForEdge):
2244         (JSC::DFG::FixupPhase::addRequiredPhantom): Deleted.
2245         (JSC::DFG::FixupPhase::addPhantomsIfNecessary): Deleted.
2246         * dfg/DFGGraph.cpp:
2247         (JSC::DFG::Graph::convertToConstant):
2248         (JSC::DFG::Graph::mergeRelevantToOSR): Deleted.
2249         * dfg/DFGGraph.h:
2250         * dfg/DFGInsertionSet.h:
2251         (JSC::DFG::InsertionSet::insertCheck):
2252         * dfg/DFGIntegerCheckCombiningPhase.cpp:
2253         (JSC::DFG::IntegerCheckCombiningPhase::handleBlock):
2254         * dfg/DFGLICMPhase.cpp:
2255         (JSC::DFG::LICMPhase::attemptHoist):
2256         * dfg/DFGNode.cpp:
2257         (JSC::DFG::Node::remove):
2258         * dfg/DFGNode.h:
2259         (JSC::DFG::Node::replaceWith):
2260         (JSC::DFG::Node::convertToPhantom): Deleted.
2261         (JSC::DFG::Node::convertToCheck): Deleted.
2262         (JSC::DFG::Node::willHaveCodeGenOrOSR): Deleted.
2263         * dfg/DFGNodeFlags.h:
2264         * dfg/DFGNodeType.h:
2265         * dfg/DFGObjectAllocationSinkingPhase.cpp:
2266         (JSC::DFG::ObjectAllocationSinkingPhase::lowerNonReadingOperationsOnPhantomAllocations):
2267         (JSC::DFG::ObjectAllocationSinkingPhase::handleNode):
2268         * dfg/DFGPhantomCanonicalizationPhase.cpp: Removed.
2269         * dfg/DFGPhantomCanonicalizationPhase.h: Removed.
2270         * dfg/DFGPhantomRemovalPhase.cpp: Removed.
2271         * dfg/DFGPhantomRemovalPhase.h: Removed.
2272         * dfg/DFGPlan.cpp:
2273         (JSC::DFG::Plan::compileInThreadImpl):
2274         * dfg/DFGPutStackSinkingPhase.cpp:
2275         * dfg/DFGResurrectionForValidationPhase.cpp: Removed.
2276         * dfg/DFGResurrectionForValidationPhase.h: Removed.
2277         * dfg/DFGSSAConversionPhase.cpp:
2278         (JSC::DFG::SSAConversionPhase::run):
2279         * dfg/DFGSpeculativeJIT64.cpp:
2280         (JSC::DFG::SpeculativeJIT::fillSpeculateDouble):
2281         * dfg/DFGStoreBarrierElisionPhase.cpp:
2282         (JSC::DFG::StoreBarrierElisionPhase::elideBarrier):
2283         * dfg/DFGStrengthReductionPhase.cpp:
2284         (JSC::DFG::StrengthReductionPhase::handleNode):
2285         (JSC::DFG::StrengthReductionPhase::convertToIdentityOverChild):
2286         * dfg/DFGValidate.cpp:
2287         (JSC::DFG::Validate::validate):
2288         (JSC::DFG::Validate::validateCPS):
2289         (JSC::DFG::Validate::validateSSA):
2290         * dfg/DFGVarargsForwardingPhase.cpp:
2291         * ftl/FTLLink.cpp:
2292         (JSC::FTL::link):
2293         * ftl/FTLLowerDFGToLLVM.cpp:
2294         (JSC::FTL::LowerDFGToLLVM::compileNode):
2295         (JSC::FTL::LowerDFGToLLVM::compileNoOp):
2296         (JSC::FTL::LowerDFGToLLVM::compilePhantom): Deleted.
2297
2298 2015-04-28  Andreas Kling  <akling@apple.com>
2299
2300         DFG+FTL should generate efficient code for branching on a string's boolean value.
2301         <https://webkit.org/b/144317>
2302
2303         Reviewed by Geoff Garen & Filip Pizlo
2304
2305         Teach Branch nodes about StringUse and have them generate an efficient zero-length string check
2306         instead of dropping out to C++ whenever we branch on a string.
2307
2308         The FTL JIT already handled Branch nodes with StringUse through its use of boolify(), so only
2309         the DFG JIT gets some new codegen logic in this patch.
2310
2311         Test: js/regress/branch-on-string-as-boolean.js (~4.5x speedup)
2312
2313         * dfg/DFGFixupPhase.cpp:
2314         (JSC::DFG::FixupPhase::fixupNode):
2315         * dfg/DFGSpeculativeJIT.cpp:
2316         (JSC::DFG::SpeculativeJIT::emitStringBranch):
2317         * dfg/DFGSpeculativeJIT.h:
2318         * dfg/DFGSpeculativeJIT32_64.cpp:
2319         (JSC::DFG::SpeculativeJIT::emitBranch):
2320         * dfg/DFGSpeculativeJIT64.cpp:
2321         (JSC::DFG::SpeculativeJIT::emitBranch):
2322
2323 2015-04-28  Filip Pizlo  <fpizlo@apple.com>
2324
2325         VarargsForwardingPhase should only consider MovHints that have the candidate as a child
2326         https://bugs.webkit.org/show_bug.cgi?id=144340
2327
2328         Reviewed by Michael Saboff and Mark Lam.
2329         
2330         Since we were considering all MovHints, we'd assume that the CreateDirectArguments or
2331         CreateClosedArguments node was live so long as any MovHinted bytecode variable was alive.
2332         Basically, we'd keep it alive until the end of the block. This maximized the chances of
2333         there being an interfering operation, which would prevent elimination.
2334         
2335         The fix is to only consider MovHints that have the arguments candidate as a child. We only
2336         care to track the liveness of those bytecode locals that would need an arguments object
2337         recovery on OSR exit.
2338         
2339         This is a speed-up on V8Spider/raytrace and Octane/raytrace because it undoes the regression
2340         introduced in http://trac.webkit.org/changeset/183406.
2341
2342         * dfg/DFGVarargsForwardingPhase.cpp:
2343
2344 2015-04-28  Csaba Osztrogonác  <ossy@webkit.org>
2345
2346         Remove WinCE cruft from cmake build system
2347         https://bugs.webkit.org/show_bug.cgi?id=144325
2348
2349         Reviewed by Gyuyoung Kim.
2350
2351         * CMakeLists.txt:
2352         * create_jit_stubs: Removed.
2353
2354 2015-04-27  Andreas Kling  <akling@apple.com>
2355
2356         RegExp matches arrays should use contiguous indexing.
2357         <https://webkit.org/b/144286>
2358
2359         Reviewed by Geoffrey Garen.
2360
2361         We had a custom Structure being used for RegExp matches arrays that would
2362         put the arrays into SlowPutArrayStorageShape mode. This was just left
2363         from when matches arrays were custom, lazily initialized objects.
2364
2365         This change removes that Structure and switches the matches arrays to
2366         using the default ContiguousShape Structure. This allows the FTL JIT
2367         to compile the inner loop of the Octane/regexp benchmark.
2368
2369         Also made a version of initializeIndex() [inline] that takes the indexing
2370         type in an argument, allowing createRegExpMatchesArray() to initialize
2371         the entire array without branching on the indexing type for each entry.
2372
2373         ~3% progression on Octane/regexp.
2374
2375         * runtime/JSGlobalObject.cpp:
2376         (JSC::JSGlobalObject::init):
2377         (JSC::JSGlobalObject::visitChildren):
2378         * runtime/JSGlobalObject.h:
2379         (JSC::JSGlobalObject::mapStructure):
2380         (JSC::JSGlobalObject::regExpMatchesArrayStructure): Deleted.
2381         * runtime/JSObject.h:
2382         (JSC::JSObject::initializeIndex):
2383         * runtime/RegExpMatchesArray.cpp:
2384         (JSC::createRegExpMatchesArray):
2385
2386 2015-04-27  Filip Pizlo  <fpizlo@apple.com>
2387
2388         FTL failed to initialize arguments.callee on the slow path as well as the fast path
2389         https://bugs.webkit.org/show_bug.cgi?id=144293
2390
2391         Reviewed by Mark Lam.
2392         
2393         The slow path doesn't fully initialize DirectArguments - it leaves callee blank. So, we need
2394         to initialize the callee on the common path after the fast and slow path.
2395
2396         * ftl/FTLLowerDFGToLLVM.cpp:
2397         (JSC::FTL::LowerDFGToLLVM::compileCreateDirectArguments):
2398         * tests/stress/arguments-callee-uninitialized.js: Added.
2399         (foo):
2400
2401 2015-04-27  Benjamin Poulain  <bpoulain@apple.com>
2402
2403         [JSC] Add support for typed arrays to the Array profiling
2404         https://bugs.webkit.org/show_bug.cgi?id=143913
2405
2406         Reviewed by Filip Pizlo.
2407
2408         This patch adds ArrayModes for every typed arrays. Having that information
2409         let us generate better GetByVal and PutByVal when the type speculation
2410         are not good enough.
2411
2412         A typical case where this is useful is any basic block for which the type
2413         of the object is always more restrictive than the speculation (for example, 
2414         a basic block gated by a branch only taken for on type).
2415
2416         * bytecode/ArrayProfile.cpp:
2417         (JSC::dumpArrayModes):
2418         * bytecode/ArrayProfile.h:
2419         (JSC::arrayModeFromStructure):
2420         * dfg/DFGArrayMode.cpp:
2421         (JSC::DFG::ArrayMode::fromObserved):
2422         (JSC::DFG::ArrayMode::refine):
2423         Maintain the refine() semantic. We do not support OutOfBounds access
2424         for GetByVal on typed array.
2425
2426         * runtime/IndexingType.h:
2427         * tests/stress/typed-array-get-by-val-profiling.js: Added.
2428         (testArray.testCode):
2429         (testArray):
2430         * tests/stress/typed-array-put-by-val-profiling.js: Added.
2431         (testArray.testCode):
2432         (testArray):
2433
2434 2015-04-27  Filip Pizlo  <fpizlo@apple.com>
2435
2436         Unreviewed, roll out r183438 "RegExp matches arrays should use contiguous indexing". It
2437         causes many debug test failures.
2438
2439         * runtime/JSGlobalObject.cpp:
2440         (JSC::JSGlobalObject::init):
2441         (JSC::JSGlobalObject::visitChildren):
2442         * runtime/JSGlobalObject.h:
2443         (JSC::JSGlobalObject::regExpMatchesArrayStructure):
2444         * runtime/JSObject.h:
2445         (JSC::JSObject::initializeIndex):
2446         * runtime/RegExpMatchesArray.cpp:
2447         (JSC::createRegExpMatchesArray):
2448
2449 2015-04-27  Andreas Kling  <akling@apple.com>
2450
2451         RegExp matches arrays should use contiguous indexing.
2452         <https://webkit.org/b/144286>
2453
2454         Reviewed by Geoffrey Garen.
2455
2456         We had a custom Structure being used for RegExp matches arrays that would
2457         put the arrays into SlowPutArrayStorageShape mode. This was just left
2458         from when matches arrays were custom, lazily initialized objects.
2459
2460         This change removes that Structure and switches the matches arrays to
2461         using the default ContiguousShape Structure. This allows the FTL JIT
2462         to compile the inner loop of the Octane/regexp benchmark.
2463
2464         Also made a version of initializeIndex() [inline] that takes the indexing
2465         type in an argument, allowing createRegExpMatchesArray() to initialize
2466         the entire array without branching on the indexing type for each entry.
2467
2468         ~3% progression on Octane/regexp.
2469
2470         * runtime/JSGlobalObject.cpp:
2471         (JSC::JSGlobalObject::init):
2472         (JSC::JSGlobalObject::visitChildren):
2473         * runtime/JSGlobalObject.h:
2474         (JSC::JSGlobalObject::mapStructure):
2475         (JSC::JSGlobalObject::regExpMatchesArrayStructure): Deleted.
2476         * runtime/JSObject.h:
2477         (JSC::JSObject::initializeIndex):
2478         * runtime/RegExpMatchesArray.cpp:
2479         (JSC::createRegExpMatchesArray):
2480
2481 2015-04-27  Ryosuke Niwa  <rniwa@webkit.org>
2482
2483         REGRESSION (r183373): ASSERT failed in wtf/SHA1.h
2484         https://bugs.webkit.org/show_bug.cgi?id=144257
2485
2486         Temporarily disable skip these tests.
2487
2488         * tests/stress/template-literal-line-terminators.js:
2489         * tests/stress/template-literal-syntax.js:
2490         * tests/stress/template-literal.js:
2491
2492 2015-04-27  Basile Clement  <basile_clement@apple.com>
2493
2494         Function allocations shouldn't sink through Put operations
2495         https://bugs.webkit.org/show_bug.cgi?id=144176
2496
2497         Reviewed by Filip Pizlo.
2498
2499         By design, we don't support function allocation sinking through any
2500         related operation ; however object allocation can sink through PutByOffset et
2501         al.
2502
2503         Currently, the checks to prevent function allocation to sink through
2504         these are misguided and do not prevent anything ; function allocation sinking
2505         through these operations is prevented as a side effect of requiring an
2506         AllocatePropertyStorage through which the function allocation is seen as
2507         escaping.
2508
2509         This changes it so that ObjectAllocationSinkingPhase::handleNode()
2510         checks properly that only object allocations sink through related write
2511         operations.
2512
2513         * dfg/DFGObjectAllocationSinkingPhase.cpp:
2514         (JSC::DFG::ObjectAllocationSinkingPhase::lowerNonReadingOperationsOnPhantomAllocations):
2515         (JSC::DFG::ObjectAllocationSinkingPhase::handleNode):
2516
2517 2015-04-25  Filip Pizlo  <fpizlo@apple.com>
2518
2519         VarargsForwardingPhase should use bytecode liveness in addition to other uses to determine the last point that a candidate is used
2520         https://bugs.webkit.org/show_bug.cgi?id=143843
2521
2522         Reviewed by Geoffrey Garen.
2523         
2524         It will soon come to pass that Phantom isn't available at the time that
2525         VarargsForwardingPhase runs. So, it needs to use some other mechanism for discovering when
2526         a value dies for OSR.
2527         
2528         This is simplified by two things:
2529         
2530         1) The bytecode kill analysis is now reusable. This patch makes it even more reusable than
2531            before by polishing the API.
2532         
2533         2) This phase already operates on one node at a time and allows itself to do a full search
2534            of the enclosing basic block for that node. This is fine because CreateDirectArguments
2535            and friends is a rarely occurring node. The fact that it operates on one node at a time
2536            makes it even easier to reason about OSR liveness - we just track the list of locals in
2537            which it is live.
2538         
2539         This change has no effect right now but it is a necessary prerequisite to implementing
2540         https://bugs.webkit.org/show_bug.cgi?id=143736.
2541
2542         * dfg/DFGBasicBlock.h:
2543         (JSC::DFG::BasicBlock::tryAt):
2544         * dfg/DFGForAllKills.h:
2545         (JSC::DFG::forAllKilledOperands):
2546         * dfg/DFGPhantomInsertionPhase.cpp:
2547         * dfg/DFGVarargsForwardingPhase.cpp:
2548
2549 2015-04-27  Jordan Harband  <ljharb@gmail.com>
2550
2551         Map#entries and Map#keys error for non-Maps is swapped
2552         https://bugs.webkit.org/show_bug.cgi?id=144253
2553
2554         Reviewed by Simon Fraser.
2555
2556         Correcting error messages on Set/Map methods when called on
2557         incompatible objects.
2558
2559         * runtime/MapPrototype.cpp:
2560         (JSC::mapProtoFuncEntries):
2561         (JSC::mapProtoFuncKeys):
2562         * runtime/SetPrototype.cpp:
2563         (JSC::setProtoFuncEntries):
2564
2565 2015-04-24  Filip Pizlo  <fpizlo@apple.com>
2566
2567         Rationalize DFG DCE handling of nodes that perform checks that propagate through AI
2568         https://bugs.webkit.org/show_bug.cgi?id=144186
2569
2570         Reviewed by Geoffrey Garen.
2571         
2572         If I do ArithAdd(Int32Use, Int32Use, CheckOverflow) then AI will prove that this returns
2573         Int32. We may later perform code simplifications based on the proof that this is Int32, and
2574         we may kill all DFG users of this ArithAdd. Then we may prove that there is no exit site at
2575         which the ArithAdd is live. This seems like it is sufficient to then kill the ArithAdd,
2576         except that we still need the overflow check!
2577
2578         Previously we mishandled this:
2579
2580         - In places where we want the overflow check we need to use MustGenerate(@ArithAdd) as a hack
2581           to keep it alive. That's dirty and it's just indicative of a deeper issue.
2582
2583         - Our MovHint removal doesn't do Phantom canonicalization which essentially makes it
2584           powerless. This was sort of hiding the bug.
2585
2586         - Nodes that have checks that AI leverages should always be NodeMustGenerate. You can't kill
2587           something that you are relying on for subsequent simplifications.
2588         
2589         This fixes MovHint removal to also canonicalize Phantoms. This also adds ModeMustGenerate to
2590         nodes that may perform checks that are used by AI to guarantee the result type. As a result,
2591         we no longer need the weird MustGenerate node.
2592
2593         * dfg/DFGAbstractInterpreterInlines.h:
2594         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
2595         * dfg/DFGArgumentsEliminationPhase.cpp:
2596         * dfg/DFGClobberize.h:
2597         (JSC::DFG::clobberize):
2598         * dfg/DFGDCEPhase.cpp:
2599         (JSC::DFG::DCEPhase::run):
2600         * dfg/DFGDoesGC.cpp:
2601         (JSC::DFG::doesGC):
2602         * dfg/DFGFixupPhase.cpp:
2603         (JSC::DFG::FixupPhase::fixupNode):
2604         (JSC::DFG::FixupPhase::tryToRelaxRepresentation):
2605         * dfg/DFGIntegerCheckCombiningPhase.cpp:
2606         (JSC::DFG::IntegerCheckCombiningPhase::handleBlock):
2607         (JSC::DFG::IntegerCheckCombiningPhase::insertMustAdd): Deleted.
2608         * dfg/DFGMayExit.cpp:
2609         (JSC::DFG::mayExit):
2610         * dfg/DFGNode.h:
2611         (JSC::DFG::Node::willHaveCodeGenOrOSR):
2612         * dfg/DFGNodeType.h:
2613         * dfg/DFGObjectAllocationSinkingPhase.cpp:
2614         (JSC::DFG::ObjectAllocationSinkingPhase::handleNode):
2615         * dfg/DFGPhantomCanonicalizationPhase.cpp:
2616         (JSC::DFG::PhantomCanonicalizationPhase::run):
2617         * dfg/DFGPhantomRemovalPhase.cpp:
2618         (JSC::DFG::PhantomRemovalPhase::run):
2619         * dfg/DFGPlan.cpp:
2620         (JSC::DFG::Plan::compileInThreadImpl):
2621         * dfg/DFGPredictionPropagationPhase.cpp:
2622         (JSC::DFG::PredictionPropagationPhase::propagate):
2623         * dfg/DFGSafeToExecute.h:
2624         (JSC::DFG::safeToExecute):
2625         * dfg/DFGSpeculativeJIT32_64.cpp:
2626         (JSC::DFG::SpeculativeJIT::compile):
2627         * dfg/DFGSpeculativeJIT64.cpp:
2628         (JSC::DFG::SpeculativeJIT::compile):
2629         * dfg/DFGTypeCheckHoistingPhase.cpp:
2630         (JSC::DFG::TypeCheckHoistingPhase::identifyRedundantStructureChecks):
2631         (JSC::DFG::TypeCheckHoistingPhase::identifyRedundantArrayChecks):
2632         * dfg/DFGVarargsForwardingPhase.cpp:
2633         * ftl/FTLCapabilities.cpp:
2634         (JSC::FTL::canCompile):
2635         * ftl/FTLLowerDFGToLLVM.cpp:
2636         (JSC::FTL::LowerDFGToLLVM::compileNode):
2637         * tests/stress/fold-based-on-int32-proof-mul-branch.js: Added.
2638         (foo):
2639         * tests/stress/fold-based-on-int32-proof-mul.js: Added.
2640         (foo):
2641         * tests/stress/fold-based-on-int32-proof-or-zero.js: Added.
2642         (foo):
2643         * tests/stress/fold-based-on-int32-proof.js: Added.
2644         (foo):
2645
2646 2015-04-26  Ryosuke Niwa  <rniwa@webkit.org>
2647
2648         Class body ending with a semicolon throws a SyntaxError
2649         https://bugs.webkit.org/show_bug.cgi?id=144244
2650
2651         Reviewed by Darin Adler.
2652
2653         The bug was caused by parseClass's inner loop for method definitions not moving onto the next iteration
2654         it encounters a semicolon. As a result, we always expected a method to appear after a semicolon. Fixed
2655         it by continue'ing when it encounters a semicolon.
2656
2657         * parser/Parser.cpp:
2658         (JSC::Parser<LexerType>::parseClass):
2659
2660 2015-04-26  Ryosuke Niwa  <rniwa@webkit.org>
2661
2662         Getter or setter method named "prototype" or "constrcutor" should throw SyntaxError
2663         https://bugs.webkit.org/show_bug.cgi?id=144243
2664
2665         Reviewed by Darin Adler.
2666
2667         Fixed the bug by adding explicit checks in parseGetterSetter when we're parsing class methods.
2668
2669         * parser/Parser.cpp:
2670         (JSC::Parser<LexerType>::parseGetterSetter):
2671
2672 2015-04-26  Jordan Harband  <ljharb@gmail.com>
2673
2674         Map#forEach does not pass "map" argument to callback.
2675         https://bugs.webkit.org/show_bug.cgi?id=144187
2676
2677         Reviewed by Darin Adler.
2678
2679         Per https://people.mozilla.org/~jorendorff/es6-draft.html#sec-map.prototype.foreach
2680         step 7.a.i., the callback should be called with three arguments.
2681
2682         * runtime/MapPrototype.cpp:
2683         (JSC::mapProtoFuncForEach):
2684
2685 2015-04-26  Yusuke Suzuki  <utatane.tea@gmail.com>
2686
2687         [ES6] Implement ES6 template literals
2688         https://bugs.webkit.org/show_bug.cgi?id=142691
2689
2690         Reviewed by Darin Adler.
2691
2692         This patch implements TemplateLiteral.
2693         Since TaggedTemplate requires some global states and
2694         primitive operations like GetTemplateObject,
2695         we separate the patch. It will be implemented in a subsequent patch.
2696
2697         Template Literal Syntax is guarded by ENABLE_ES6_TEMPLATE_LITERAL_SYNTAX compile time flag.
2698         By disabling it, we can disable Template Literal support.
2699
2700         To implement template literals, in this patch,
2701         we newly introduces bytecode op_to_string.
2702         In template literals, we alternately evaluate the expression and
2703         perform ToString onto the result of evaluation.
2704         For example,
2705
2706         `${f1()} ${f2()}`
2707
2708         In this template literal, execution order is the following,
2709         1. calling f1()
2710         2. ToString(the result of f1())
2711         3. calling f2()
2712         4. ToString(the result of f2())
2713
2714         op_strcat also performs ToString. However, performing ToString
2715         onto expressions are batched in op_strcat, it's not the same to the
2716         template literal spec. In the above example,
2717         ToString(f1()) should be called before calling f2().
2718
2719         * Configurations/FeatureDefines.xcconfig:
2720         * bytecode/BytecodeList.json:
2721         * bytecode/BytecodeUseDef.h:
2722         (JSC::computeUsesForBytecodeOffset):
2723         (JSC::computeDefsForBytecodeOffset):
2724         * bytecode/CodeBlock.cpp:
2725         (JSC::CodeBlock::dumpBytecode):
2726         * bytecompiler/BytecodeGenerator.h:
2727         (JSC::BytecodeGenerator::emitToString):
2728         (JSC::BytecodeGenerator::emitToNumber): Deleted.
2729         * bytecompiler/NodesCodegen.cpp:
2730         (JSC::TemplateStringNode::emitBytecode):
2731         (JSC::TemplateLiteralNode::emitBytecode):
2732         * dfg/DFGByteCodeParser.cpp:
2733         (JSC::DFG::ByteCodeParser::parseBlock):
2734         * dfg/DFGCapabilities.cpp:
2735         (JSC::DFG::capabilityLevel):
2736         * jit/JIT.cpp:
2737         (JSC::JIT::privateCompileMainPass):
2738         (JSC::JIT::privateCompileSlowCases):
2739         * jit/JIT.h:
2740         * jit/JITOpcodes.cpp:
2741         (JSC::JIT::emit_op_to_string):
2742         (JSC::JIT::emitSlow_op_to_string):
2743         * jit/JITOpcodes32_64.cpp:
2744         (JSC::JIT::emit_op_to_string):
2745         (JSC::JIT::emitSlow_op_to_string):
2746         * llint/LowLevelInterpreter32_64.asm:
2747         * llint/LowLevelInterpreter64.asm:
2748         * parser/ASTBuilder.h:
2749         (JSC::ASTBuilder::createTemplateString):
2750         (JSC::ASTBuilder::createTemplateStringList):
2751         (JSC::ASTBuilder::createTemplateExpressionList):
2752         (JSC::ASTBuilder::createTemplateLiteral):
2753         * parser/Lexer.cpp:
2754         (JSC::Lexer<T>::Lexer):
2755         (JSC::Lexer<T>::parseIdentifierSlowCase):
2756         (JSC::Lexer<T>::parseString):
2757         (JSC::LineNumberAdder::LineNumberAdder):
2758         (JSC::LineNumberAdder::clear):
2759         (JSC::LineNumberAdder::add):
2760         (JSC::Lexer<T>::parseTemplateLiteral):
2761         (JSC::Lexer<T>::lex):
2762         (JSC::Lexer<T>::scanRegExp):
2763         (JSC::Lexer<T>::scanTrailingTemplateString):
2764         (JSC::Lexer<T>::parseStringSlowCase): Deleted.
2765         * parser/Lexer.h:
2766         * parser/NodeConstructors.h:
2767         (JSC::TemplateExpressionListNode::TemplateExpressionListNode):
2768         (JSC::TemplateStringNode::TemplateStringNode):
2769         (JSC::TemplateStringListNode::TemplateStringListNode):
2770         (JSC::TemplateLiteralNode::TemplateLiteralNode):
2771         * parser/Nodes.h:
2772         (JSC::TemplateExpressionListNode::value):
2773         (JSC::TemplateExpressionListNode::next):
2774         (JSC::TemplateStringNode::cooked):
2775         (JSC::TemplateStringNode::raw):
2776         (JSC::TemplateStringListNode::value):
2777         (JSC::TemplateStringListNode::next):
2778         * parser/Parser.cpp:
2779         (JSC::Parser<LexerType>::parseTemplateString):
2780         (JSC::Parser<LexerType>::parseTemplateLiteral):
2781         (JSC::Parser<LexerType>::parsePrimaryExpression):
2782         * parser/Parser.h:
2783         * parser/ParserTokens.h:
2784         * parser/SyntaxChecker.h:
2785         (JSC::SyntaxChecker::createTemplateString):
2786         (JSC::SyntaxChecker::createTemplateStringList):
2787         (JSC::SyntaxChecker::createTemplateExpressionList):
2788         (JSC::SyntaxChecker::createTemplateLiteral):
2789         (JSC::SyntaxChecker::createSpreadExpression): Deleted.
2790         * runtime/CommonSlowPaths.cpp:
2791         (JSC::SLOW_PATH_DECL):
2792         * runtime/CommonSlowPaths.h:
2793         * tests/stress/template-literal-line-terminators.js: Added.
2794         (test):
2795         (testEval):
2796         (testEvalLineNumber):
2797         * tests/stress/template-literal-syntax.js: Added.
2798         (testSyntax):
2799         (testSyntaxError):
2800         * tests/stress/template-literal.js: Added.
2801         (test):
2802         (testEval):
2803         (testEmbedded):
2804
2805 2015-04-26  Jordan Harband  <ljharb@gmail.com>
2806
2807         Set#forEach does not pass "key" or "set" arguments to callback.
2808         https://bugs.webkit.org/show_bug.cgi?id=144188
2809
2810         Reviewed by Darin Adler.
2811
2812         Per https://people.mozilla.org/~jorendorff/es6-draft.html#sec-set.prototype.foreach
2813         Set#forEach should pass 3 arguments to the callback.
2814
2815         * runtime/SetPrototype.cpp:
2816         (JSC::setProtoFuncForEach):
2817
2818 2015-04-26  Benjamin Poulain  <benjamin@webkit.org>
2819
2820         [JSC] Implement Math.clz32(), remove Number.clz()
2821         https://bugs.webkit.org/show_bug.cgi?id=144205
2822
2823         Reviewed by Michael Saboff.
2824
2825         This patch adds the ES6 function Math.clz32(), and remove the non-standard
2826         Number.clz(). Number.clz() probably came from an older draft.
2827
2828         The new function has a corresponding instrinsic: Clz32Intrinsic,
2829         and a corresponding DFG node: ArithClz32, optimized all the way to LLVM.
2830
2831         * assembler/MacroAssemblerX86Common.h:
2832         (JSC::MacroAssemblerX86Common::countLeadingZeros32):
2833         * assembler/X86Assembler.h:
2834         (JSC::X86Assembler::bsr_rr):
2835         The x86 assembler did not have countLeadingZeros32() because there is
2836         no native CLZ instruction on that architecture.
2837
2838         I have added the version with bsr + branches for the case of zero.
2839         An other popular version uses cmov to handle the case of zero. I kept
2840         it simple since the Assembler has no support for cmov.
2841
2842         It is unlikely to matter much. If the code is hot enough, LLVM picks
2843         something good based on the surrounding code.
2844
2845         * dfg/DFGAbstractInterpreterInlines.h:
2846         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
2847         Constant handling + effect propagation. The node only produces integer (between 0 and 32).
2848
2849         * dfg/DFGBackwardsPropagationPhase.cpp:
2850         (JSC::DFG::BackwardsPropagationPhase::propagate):
2851         Thanks to the definition of toUint32(), we can ignore plenty of details
2852         from doubles.
2853
2854         * dfg/DFGByteCodeParser.cpp:
2855         (JSC::DFG::ByteCodeParser::handleIntrinsic):
2856         * dfg/DFGClobberize.h:
2857         (JSC::DFG::clobberize):
2858         * dfg/DFGDoesGC.cpp:
2859         (JSC::DFG::doesGC):
2860         * dfg/DFGFixupPhase.cpp:
2861         (JSC::DFG::FixupPhase::fixupNode):
2862         * dfg/DFGNodeType.h:
2863         * dfg/DFGPredictionPropagationPhase.cpp:
2864         (JSC::DFG::PredictionPropagationPhase::propagate):
2865         * dfg/DFGSafeToExecute.h:
2866         (JSC::DFG::safeToExecute):
2867         * dfg/DFGSpeculativeJIT.cpp:
2868         (JSC::DFG::SpeculativeJIT::compileArithClz32):
2869         * dfg/DFGSpeculativeJIT.h:
2870         * dfg/DFGSpeculativeJIT32_64.cpp:
2871         (JSC::DFG::SpeculativeJIT::compile):
2872         * dfg/DFGSpeculativeJIT64.cpp:
2873         (JSC::DFG::SpeculativeJIT::compile):
2874         * ftl/FTLCapabilities.cpp:
2875         (JSC::FTL::canCompile):
2876         * ftl/FTLIntrinsicRepository.h:
2877         * ftl/FTLLowerDFGToLLVM.cpp:
2878         (JSC::FTL::LowerDFGToLLVM::compileNode):
2879         (JSC::FTL::LowerDFGToLLVM::compileArithClz32):
2880         * ftl/FTLOutput.h:
2881         (JSC::FTL::Output::ctlz32):
2882         * jit/ThunkGenerators.cpp:
2883         (JSC::clz32ThunkGenerator):
2884         * jit/ThunkGenerators.h:
2885         * runtime/Intrinsic.h:
2886         * runtime/MathCommon.h:
2887         (JSC::clz32):
2888         Fun fact: InstCombine does not recognize this pattern to eliminate
2889         the branch which makes our FTL version better than the C version.
2890
2891         * runtime/MathObject.cpp:
2892         (JSC::MathObject::finishCreation):
2893         (JSC::mathProtoFuncClz32):
2894         * runtime/NumberPrototype.cpp:
2895         (JSC::clz): Deleted.
2896         (JSC::numberProtoFuncClz): Deleted.
2897         * runtime/VM.cpp:
2898         (JSC::thunkGeneratorForIntrinsic):
2899         * tests/stress/math-clz32-basics.js: Added.
2900         (mathClz32OnInteger):
2901         (testMathClz32OnIntegers):
2902         (verifyMathClz32OnIntegerWithOtherTypes):
2903         (mathClz32OnDouble):
2904         (testMathClz32OnDoubles):
2905         (verifyMathClz32OnDoublesWithOtherTypes):
2906         (mathClz32NoArguments):
2907         (mathClz32TooManyArguments):
2908         (testMathClz32OnConstants):
2909         (mathClz32StructTransition):
2910         (Math.clz32):
2911
2912 2015-04-26  Yusuke Suzuki  <utatane.tea@gmail.com>
2913
2914         [ES6] Array.from need to accept iterables
2915         https://bugs.webkit.org/show_bug.cgi?id=141055
2916
2917         Reviewed by Darin Adler.
2918
2919         ES6 spec requires that Array.from accepts iterable objects.
2920         This patch introduces this functionality, Array.from accepting iterable objects.
2921
2922         Currently, `isConstructor` is not used. Instead of it, `typeof thiObj === "function"` is used.
2923         However, it doesn't conform to the spec. While `isConstructor` queries the given object has `[[Construct]]`,
2924         `typeof thisObj === "function"` queries the given object has `[[Call]]`.
2925         This will be fixed in the subsequent patch[1].
2926
2927         [1]: https://bugs.webkit.org/show_bug.cgi?id=144093
2928
2929         * builtins/ArrayConstructor.js:
2930         (from):
2931         * parser/Parser.cpp:
2932         (JSC::Parser<LexerType>::parseInner):
2933         * runtime/CommonIdentifiers.h:
2934         * runtime/JSGlobalObject.cpp:
2935         (JSC::JSGlobalObject::init):
2936         * tests/stress/array-from-with-iterable.js: Added.
2937         (shouldBe):
2938         (.set for):
2939         (.set var):
2940         (.get var):
2941         (argumentsGenerators):
2942         (.set shouldBe):
2943         (.set new):
2944         * tests/stress/array-from-with-iterator.js: Added.
2945         (shouldBe):
2946         (shouldThrow):
2947         (createIterator.iterator.return):
2948         (createIterator):
2949         (.):
2950
2951 2015-04-25  Jordan Harband  <ljharb@gmail.com>
2952
2953         Set#keys !== Set#values
2954         https://bugs.webkit.org/show_bug.cgi?id=144190
2955
2956         Reviewed by Darin Adler.
2957
2958         per https://people.mozilla.org/~jorendorff/es6-draft.html#sec-set.prototype.keys
2959         Set#keys should === Set#values
2960
2961         * runtime/SetPrototype.cpp:
2962         (JSC::SetPrototype::finishCreation):
2963         (JSC::setProtoFuncValues):
2964         (JSC::setProtoFuncEntries):
2965         (JSC::setProtoFuncKeys): Deleted.
2966
2967 2015-04-25  Joseph Pecoraro  <pecoraro@apple.com>
2968
2969         Allow for pausing a JSContext when opening a Web Inspector
2970         <rdar://problem/20564788>
2971
2972         Reviewed by Timothy Hatcher.
2973
2974         * inspector/remote/RemoteInspector.mm:
2975         (Inspector::RemoteInspector::receivedSetupMessage):
2976         * inspector/remote/RemoteInspectorConstants.h:
2977         * inspector/remote/RemoteInspectorDebuggable.h:
2978         * inspector/remote/RemoteInspectorDebuggableConnection.h:
2979         * inspector/remote/RemoteInspectorDebuggableConnection.mm:
2980         (Inspector::RemoteInspectorDebuggableConnection::setup):
2981         On any incoming setup message, we may want to automatically
2982         pause the debuggable. If requested, pause the debuggable
2983         after we have setup the frontend connection.
2984
2985         * runtime/JSGlobalObjectDebuggable.h:
2986         * runtime/JSGlobalObjectDebuggable.cpp:
2987         (JSC::JSGlobalObjectDebuggable::pause):
2988         Pass through to the inspector controller.
2989
2990         * inspector/JSGlobalObjectInspectorController.h:
2991         * inspector/JSGlobalObjectInspectorController.cpp:
2992         (Inspector::JSGlobalObjectInspectorController::pause):
2993         Enable pause on next statement.
2994
2995 2015-04-23  Ryosuke Niwa  <rniwa@webkit.org>
2996
2997         class methods should be non-enumerable
2998         https://bugs.webkit.org/show_bug.cgi?id=143181
2999
3000         Reviewed by Darin Adler.
3001
3002         Fixed the bug by using Object.defineProperty to define methods.
3003
3004         This patch adds the concept of link time constants and uses it to resolve Object.defineProperty
3005         inside CodeBlock's constructor since bytecode can be linked against multiple global objects.
3006
3007         * bytecode/CodeBlock.cpp: 
3008         (JSC::CodeBlock::CodeBlock): Resolve link time constants that are used. Ignore ones with register
3009         index of zero.
3010         * bytecode/SpecialPointer.h: Added a new enum for link time constants. It currently contains
3011         exactly one entry for Object.defineProperty.
3012         * bytecode/UnlinkedCodeBlock.h:
3013         (JSC::UnlinkedCodeBlock::addConstant): Added. Like addConstant that takes JSValue, allocate a new
3014         constant register for the link time constant we're adding.
3015         (JSC::UnlinkedCodeBlock::registerIndexForLinkTimeConstant): Added.
3016         * bytecompiler/BytecodeGenerator.cpp:
3017         (JSC::BytecodeGenerator::emitMoveLinkTimeConstant): Added. Like addConstantValue, allocate a new
3018         register for the specified link time constant and notify UnlinkedCodeBlock about it.
3019         (JSC::BytecodeGenerator::emitCallDefineProperty): Added. Create a new property descriptor and call
3020         Object.defineProperty with it.
3021         * bytecompiler/BytecodeGenerator.h:
3022         * bytecompiler/NodesCodegen.cpp:
3023         (JSC::PropertyListNode::emitBytecode): Make static and non-static getters and setters for classes
3024         non-enumerable by using emitCallDefineProperty to define them.
3025         (JSC::PropertyListNode::emitPutConstantProperty): Ditto for a non-accessor properties.
3026         (JSC::ClassExprNode::emitBytecode): Make prototype.constructor non-enumerable and make prototype
3027         property on the class non-writable, non-configurable, and non-enumerable by using defineProperty.
3028         * runtime/CommonIdentifiers.h:
3029         * runtime/JSGlobalObject.cpp:
3030         (JSC::JSGlobalObject::init): Set m_definePropertyFunction.
3031         (JSC::JSGlobalObject::visitChildren): Visit m_definePropertyFunction.
3032         * runtime/JSGlobalObject.h:
3033         (JSC::JSGlobalObject::definePropertyFunction): Added.
3034         (JSC::JSGlobalObject::actualPointerFor): Added a variant that takes LinkTimeConstant.
3035         (JSC::JSGlobalObject::jsCellForLinkTimeConstant): Like actualPointerFor, takes LinkTimeConstant and
3036         returns a JSCell; e.g. Object.defineProperty.
3037         * runtime/ObjectConstructor.cpp:
3038         (JSC::ObjectConstructor::addDefineProperty): Added. Returns Object.defineProperty.
3039         * runtime/ObjectConstructor.h:
3040
3041 2015-04-25  Yusuke Suzuki  <utatane.tea@gmail.com>
3042
3043         [ES6] Implement String.fromCodePoint
3044         https://bugs.webkit.org/show_bug.cgi?id=144160
3045
3046         Reviewed by Darin Adler.
3047
3048         This patch implements String.fromCodePoint.
3049         It accepts multiple code points and generates a string that consists of given code points.
3050         The range [0x0000 - 0x10FFFF] is valid for code points.
3051         If the given value is out of range, throw a range error.
3052
3053         When a 0xFFFF <= valid code point is given,
3054         String.fromCodePoint generates a string that contains surrogate pairs.
3055
3056         * runtime/StringConstructor.cpp:
3057         (JSC::stringFromCodePoint):
3058         (JSC::constructWithStringConstructor):
3059         * tests/stress/string-from-code-point.js: Added.
3060         (shouldBe):
3061         (shouldThrow):
3062         (toCodePoints):
3063         (passThrough):
3064
3065 2015-04-25  Martin Robinson  <mrobinson@igalia.com>
3066
3067         Rename ENABLE_3D_RENDERING to ENABLE_3D_TRANSFORMS
3068         https://bugs.webkit.org/show_bug.cgi?id=144182
3069
3070         Reviewed by Simon Fraser.
3071
3072         * Configurations/FeatureDefines.xcconfig: Replace all instances of 3D_RENDERING with 3D_TRANSFORMS.
3073
3074 2015-04-25  Mark Lam  <mark.lam@apple.com>
3075
3076         mayExit() is wrong about Branch nodes with ObjectOrOtherUse: they can exit.
3077         https://bugs.webkit.org/show_bug.cgi?id=144152
3078
3079         Reviewed by Filip Pizlo.
3080
3081         Changed the EdgeMayExit functor to recognize ObjectUse, ObjectOrOtherUse,
3082         StringObjectUse, and StringOrStringObjectUse kinds as potentially triggering
3083         OSR exits.  This was overlooked in the original code.
3084
3085         While only the ObjectOrOtherUse kind is relevant for manifesting this bug with
3086         the Branch node, the other 3 may also trigger the same bug for other nodes.
3087         To prevent this bug from manifesting with other nodes (and future ones that
3088         are yet to be added to mayExits()'s "potential won't exit" set), we fix the
3089         EdgeMayExit functor to handle all 4 use kinds (instead of just ObjectOrOtherUse).
3090
3091         Also added a test to exercise a code path that will trigger this bug with
3092         the Branch node before the fix is applied.
3093
3094         * dfg/DFGMayExit.cpp:
3095         * tests/stress/branch-may-exit-due-to-object-or-other-use-kind.js: Added.
3096         (inlinedFunction):
3097         (foo):
3098
3099 2015-04-24  Commit Queue  <commit-queue@webkit.org>
3100
3101         Unreviewed, rolling out r183288.
3102         https://bugs.webkit.org/show_bug.cgi?id=144189
3103
3104         Made js/sort-with-side-effecting-comparisons.html time out in
3105         debug builds (Requested by ap on #webkit).
3106
3107         Reverted changeset:
3108
3109         "It shouldn't take 1846 lines of code and 5 FIXMEs to sort an
3110         array."
3111         https://bugs.webkit.org/show_bug.cgi?id=144013
3112         http://trac.webkit.org/changeset/183288
3113
3114 2015-04-24  Filip Pizlo  <fpizlo@apple.com>
3115
3116         CRASH in operationCreateDirectArgumentsDuringExit()
3117         https://bugs.webkit.org/show_bug.cgi?id=143962
3118
3119         Reviewed by Geoffrey Garen.
3120         
3121         We shouldn't assume that constant-like OSR exit values are always recoverable. They are only
3122         recoverable so long as they are live. Therefore, OSR exit should track liveness of
3123         constants instead of assuming that they are always live.
3124
3125         * dfg/DFGGenerationInfo.h:
3126         (JSC::DFG::GenerationInfo::noticeOSRBirth):
3127         (JSC::DFG::GenerationInfo::appendBirth):
3128         * dfg/DFGSpeculativeJIT.cpp:
3129         (JSC::DFG::SpeculativeJIT::compileCurrentBlock):
3130         * dfg/DFGVariableEvent.cpp:
3131         (JSC::DFG::VariableEvent::dump):
3132         * dfg/DFGVariableEvent.h:
3133         (JSC::DFG::VariableEvent::birth):
3134         (JSC::DFG::VariableEvent::id):
3135         (JSC::DFG::VariableEvent::dataFormat):
3136         * dfg/DFGVariableEventStream.cpp:
3137         (JSC::DFG::VariableEventStream::reconstruct):
3138         * tests/stress/phantom-direct-arguments-clobber-argument-count.js: Added.
3139         (foo):
3140         (bar):
3141         * tests/stress/phantom-direct-arguments-clobber-callee.js: Added.
3142         (foo):
3143         (bar):
3144
3145 2015-04-24  Benjamin Poulain  <bpoulain@apple.com>
3146
3147         [JSC] When inserting a NaN into a Int32 array, we convert it to DoubleArray then to ContiguousArray
3148         https://bugs.webkit.org/show_bug.cgi?id=144169
3149
3150         Reviewed by Geoffrey Garen.
3151
3152         * runtime/JSObject.cpp:
3153         (JSC::JSObject::convertInt32ForValue):
3154         DoubleArray do not store NaN, they are used for holes.
3155         What happened was:
3156         1) We fail to insert the NaN in the Int32 array because it is a double.
3157         2) We were converting the array to DoubleArray.
3158         3) We were trying to insert the value again. We would fail again because
3159            DoubleArray does not store NaN.
3160         4) We would convert the DoubleArrayt to Contiguous Array, converting the values
3161            to boxed values.
3162
3163         * tests/stress/int32array-transition-on-nan.js: Added.
3164         The behavior is not really observable. This only test nothing crashes in those
3165         cases.
3166
3167         (insertNaNWhileFilling):
3168         (testInsertNaNWhileFilling):
3169         (insertNaNAfterFilling):
3170         (testInsertNaNAfterFilling):
3171         (pushNaNWhileFilling):
3172         (testPushNaNWhileFilling):
3173
3174 2015-04-21  Geoffrey Garen  <ggaren@apple.com>
3175
3176         It shouldn't take 1846 lines of code and 5 FIXMEs to sort an array.
3177         https://bugs.webkit.org/show_bug.cgi?id=144013
3178
3179         Reviewed by Mark Lam.
3180
3181         This patch implements Array.prototype.sort in JavaScript, removing the
3182         C++ implementations. It is simpler and less error-prone to express our
3183         operations in JavaScript, which provides memory safety, exception safety,
3184         and recursion safety.
3185
3186         The performance result is mixed, but net positive in my opinion. It's
3187         difficult to enumerate all the results, since we used to have so many
3188         different sorting modes, and there are lots of different data patterns
3189         across which you might want to measure sorting. Suffice it to say:
3190
3191             (*) The benchmarks we track are faster or unchanged.
3192
3193             (*) Sorting random input using a comparator -- which we think is
3194             common -- is 3X faster.
3195
3196             (*) Sorting random input in a non-array object -- which jQuery does
3197             -- is 4X faster.
3198
3199             (*) Sorting random input in a compact array of integers using a
3200             trivial pattern-matchable comparator is 2X *slower*.
3201
3202         * builtins/Array.prototype.js:
3203         (sort.min):
3204         (sort.stringComparator):
3205         (sort.compactSparse): Special case compaction for sparse arrays because
3206         we don't want to hang when sorting new Array(BIG).
3207
3208         (sort.compact):
3209         (sort.merge):
3210         (sort.mergeSort): Use merge sort because it's a reasonably efficient
3211         stable sort. We have evidence that some sites depend on stable sort,
3212         even though the ES6 spec does not mandate it. (See
3213         <http://trac.webkit.org/changeset/33967>.)
3214
3215         This is a textbook implementation of merge sort with three optimizations:
3216
3217             (1) Use iteration instead of recursion;
3218
3219             (2) Use array subscripting instead of array copying in order to
3220             create logical sub-lists without creating physical sub-lists;
3221
3222             (3) Swap src and dst at each iteration instead of copying src into
3223             dst, and only copy src into the subject array at the end if src is
3224             not the subject array.
3225
3226         (sort.inflate):
3227         (sort.comparatorSort):
3228         (sort): Sort in JavaScript for the win.
3229
3230         * builtins/BuiltinExecutables.cpp:
3231         (JSC::BuiltinExecutables::createExecutableInternal): Allow non-private
3232         names so we can use helper functions.
3233
3234         * bytecode/CodeBlock.h:
3235         (JSC::CodeBlock::isNumericCompareFunction): Deleted.
3236         * bytecode/UnlinkedCodeBlock.cpp:
3237         (JSC::UnlinkedCodeBlock::UnlinkedCodeBlock):
3238         * bytecode/UnlinkedCodeBlock.h:
3239         (JSC::UnlinkedCodeBlock::setIsNumericCompareFunction): Deleted.
3240         (JSC::UnlinkedCodeBlock::isNumericCompareFunction): Deleted.
3241         * bytecompiler/BytecodeGenerator.cpp:
3242         (JSC::BytecodeGenerator::setIsNumericCompareFunction): Deleted.
3243         * bytecompiler/BytecodeGenerator.h:
3244         * bytecompiler/NodesCodegen.cpp:
3245         (JSC::FunctionNode::emitBytecode): We don't do this special casing based
3246         on pattern matching anymore. This was mainly an optimization to avoid 
3247         the overhead of calling from C++ to JS, which we now avoid by
3248         sorting in JS.
3249
3250         * heap/Heap.cpp:
3251         (JSC::Heap::markRoots):
3252         (JSC::Heap::pushTempSortVector): Deleted.
3253         (JSC::Heap::popTempSortVector): Deleted.
3254         (JSC::Heap::visitTempSortVectors): Deleted.
3255         * heap/Heap.h: We don't have temp sort vectors anymore because we sort
3256         in JavaScript using a normal JavaScript array for our temporary storage.
3257
3258         * parser/Parser.cpp:
3259         (JSC::Parser<LexerType>::parseInner): Allow capturing so we can use
3260         helper functions.
3261
3262         * runtime/ArrayPrototype.cpp:
3263         (JSC::isNumericCompareFunction): Deleted.
3264         (JSC::attemptFastSort): Deleted.
3265         (JSC::performSlowSort): Deleted.
3266         (JSC::arrayProtoFuncSort): Deleted.
3267
3268         * runtime/CommonIdentifiers.h: New strings used by sort.
3269
3270         * runtime/JSArray.cpp:
3271         (JSC::compareNumbersForQSortWithInt32): Deleted.
3272         (JSC::compareNumbersForQSortWithDouble): Deleted.
3273         (JSC::compareNumbersForQSort): Deleted.
3274         (JSC::compareByStringPairForQSort): Deleted.
3275         (JSC::JSArray::sortNumericVector): Deleted.
3276         (JSC::JSArray::sortNumeric): Deleted.
3277         (JSC::ContiguousTypeAccessor::getAsValue): Deleted.
3278         (JSC::ContiguousTypeAccessor::setWithValue): Deleted.
3279         (JSC::ContiguousTypeAccessor::replaceDataReference): Deleted.
3280         (JSC::ContiguousTypeAccessor<ArrayWithDouble>::getAsValue): Deleted.
3281         (JSC::ContiguousTypeAccessor<ArrayWithDouble>::setWithValue): Deleted.
3282         (JSC::ContiguousTypeAccessor<ArrayWithDouble>::replaceDataReference): Deleted.
3283         (JSC::JSArray::sortCompactedVector): Deleted.
3284         (JSC::JSArray::sort): Deleted.
3285         (JSC::AVLTreeAbstractorForArrayCompare::get_less): Deleted.
3286         (JSC::AVLTreeAbstractorForArrayCompare::set_less): Deleted.
3287         (JSC::AVLTreeAbstractorForArrayCompare::get_greater): Deleted.
3288         (JSC::AVLTreeAbstractorForArrayCompare::set_greater): Deleted.
3289         (JSC::AVLTreeAbstractorForArrayCompare::get_balance_factor): Deleted.
3290         (JSC::AVLTreeAbstractorForArrayCompare::set_balance_factor): Deleted.
3291         (JSC::AVLTreeAbstractorForArrayCompare::compare_key_key): Deleted.
3292         (JSC::AVLTreeAbstractorForArrayCompare::compare_key_node): Deleted.
3293         (JSC::AVLTreeAbstractorForArrayCompare::compare_node_node): Deleted.
3294         (JSC::AVLTreeAbstractorForArrayCompare::null): Deleted.
3295         (JSC::JSArray::sortVector): Deleted.
3296         (JSC::JSArray::compactForSorting): Deleted.
3297         * runtime/JSArray.h:
3298
3299         * runtime/JSGlobalObject.cpp:
3300         (JSC::JSGlobalObject::init):
3301         * runtime/ObjectConstructor.cpp:
3302         (JSC::ObjectConstructor::finishCreation): Provide some builtins used
3303         by sort.
3304
3305 2015-04-24  Matthew Mirman  <mmirman@apple.com>
3306
3307         Made Object.prototype.__proto__ native getter and setter check that this object not null or undefined
3308         https://bugs.webkit.org/show_bug.cgi?id=141865
3309         rdar://problem/19927273
3310
3311         Reviewed by Filip Pizlo.
3312
3313         * runtime/JSGlobalObjectFunctions.cpp:
3314         (JSC::globalFuncProtoGetter):
3315         (JSC::globalFuncProtoSetter):
3316
3317 2015-04-23  Benjamin Poulain  <bpoulain@apple.com>
3318
3319         Remove a useless branch on DFGGraph::addShouldSpeculateMachineInt()
3320         https://bugs.webkit.org/show_bug.cgi?id=144118
3321
3322         Reviewed by Geoffrey Garen.
3323
3324         * dfg/DFGGraph.h:
3325         (JSC::DFG::Graph::addShouldSpeculateMachineInt):
3326         Both block do the same thing.
3327
3328 2015-04-23  Joseph Pecoraro  <pecoraro@apple.com>
3329
3330         Web Inspector: Speculative fix for non-main thread auto-attach failures
3331         https://bugs.webkit.org/show_bug.cgi?id=144134
3332
3333         Reviewed by Timothy Hatcher.
3334
3335         * inspector/remote/RemoteInspector.mm:
3336         (Inspector::RemoteInspector::singleton):
3337
3338 2015-04-23  Basile Clement  <basile_clement@apple.com>
3339
3340         Allow function allocation sinking
3341         https://bugs.webkit.org/show_bug.cgi?id=144016
3342
3343         Reviewed by Filip Pizlo.
3344
3345         This adds the ability to sink function allocations in the
3346         DFGObjectAllocationSinkingPhase.
3347
3348         In order to enable this, we add a new PhantomNewFunction node that is
3349         used similarily to the PhantomNewObject node, i.e. as a placeholder to replace
3350         a sunk NewFunction and keep track of the allocations that have to be performed