3085e9373d54f0b2072306add4b7351c3ee98180
[WebKit-https.git] / Source / JavaScriptCore / ChangeLog
1 2015-06-09  Andreas Kling  <akling@apple.com>
2
3         [JSC] CodeBlock::m_constantRegisters should be sized-to-fit.
4         <https://webkit.org/b/145784>
5
6         Reviewed by Darin Adler.
7
8         Spotted this Vector looking chubby on cnet.com, with 1.23 MB of memory
9         allocated below CodeBlock::setConstantRegisters().
10
11         Use resizeToFit() instead since we know the final size up front.
12         Also removed some unused functions that operated on this constants vector
13         and the corresponding one in UnlinkedCodeBlock.
14
15         * bytecode/CodeBlock.cpp:
16         (JSC::CodeBlock::addOrFindConstant): Deleted.
17         (JSC::CodeBlock::findConstant): Deleted.
18         * bytecode/CodeBlock.h:
19         (JSC::CodeBlock::setConstantRegisters):
20         (JSC::CodeBlock::numberOfConstantRegisters): Deleted.
21         * bytecode/UnlinkedCodeBlock.cpp:
22         (JSC::UnlinkedCodeBlock::addOrFindConstant): Deleted.
23         * bytecode/UnlinkedCodeBlock.h:
24         (JSC::UnlinkedCodeBlock::numberOfConstantRegisters): Deleted.
25         (JSC::UnlinkedCodeBlock::getConstant): Deleted.
26
27 2015-06-09  Andreas Kling  <akling@apple.com>
28
29         [JSC] Polymorphic{Get,Put}ByIdList::addAccess() should optimize for size, not speed.
30         <https://webkit.org/b/145786>
31
32         Reviewed by Darin Adler.
33
34         These functions already contained comments saying they optimize for size over speed,
35         but they were using Vector::resize() which adds the usual slack for faster append().
36
37         Switch them over to using Vector::resizeToFit() instead, which makes the Vector
38         allocate a perfectly sized backing store.
39
40         Spotted 670 kB of the GetById ones, and 165 kB of PutById on cnet.com, so these
41         Vectors are definitely worth shrink-wrapping.
42
43         * bytecode/PolymorphicGetByIdList.cpp:
44         (JSC::PolymorphicGetByIdList::addAccess):
45         * bytecode/PolymorphicPutByIdList.cpp:
46         (JSC::PolymorphicPutByIdList::addAccess):
47
48 2015-06-09  Andreas Kling  <akling@apple.com>
49
50         [JSC] JSPropertyNameEnumerator's property name vector should be sized-to-fit.
51         <https://webkit.org/b/145787>
52
53         Reviewed by Darin Adler.
54
55         Saw 108 kB worth of JSPropertyNameEnumerator backing store Vectors on cnet.com.
56         Use Vector::resizeToFit() since we know the perfect size up front.
57
58         * runtime/JSPropertyNameEnumerator.cpp:
59         (JSC::JSPropertyNameEnumerator::finishCreation):
60
61 2015-06-09  Andreas Kling  <akling@apple.com>
62
63         FunctionExecutable::isCompiling() is weird and wrong.
64         <https://webkit.org/b/145689>
65
66         Reviewed by Geoffrey Garen.
67
68         Remove FunctionExecutable::isCompiling() and the clearCodeIfNotCompiling() style
69         functions that called it before throwing away code.
70
71         isCompiling() would consider the executable to be "compiling" if it had a CodeBlock
72         but no JITCode. In practice, every executable gets a JITCode at the same time as it
73         gets a CodeBlock, by way of prepareForExecutionImpl().
74
75         * debugger/Debugger.cpp:
76         * heap/Heap.cpp:
77         (JSC::Heap::deleteAllCompiledCode):
78         (JSC::Heap::deleteAllUnlinkedFunctionCode):
79         * inspector/agents/InspectorRuntimeAgent.cpp:
80         (Inspector::TypeRecompiler::visit):
81         * runtime/Executable.cpp:
82         (JSC::FunctionExecutable::clearUnlinkedCodeForRecompilation):
83         (JSC::FunctionExecutable::clearCodeIfNotCompiling): Deleted.
84         (JSC::FunctionExecutable::clearUnlinkedCodeForRecompilationIfNotCompiling): Deleted.
85         * runtime/Executable.h:
86         * runtime/VM.cpp:
87         (JSC::StackPreservingRecompiler::visit):
88
89 2015-06-09  Yusuke Suzuki  <utatane.tea@gmail.com>
90
91         Introduce getter definition into static hash tables and use it for getters in RegExp.prototype.
92         https://bugs.webkit.org/show_bug.cgi?id=145705
93
94         Reviewed by Darin Adler.
95
96         In this patch, we introduce Accessor type into property tables.
97         With Accessor type, create_hash_table creates a static getter property.
98         This getter property is reified as the same to the static functions.
99
100         In the mean time, we only support getter because `putEntry` and `lookupPut`
101         only work with null setter currently. However, in the spec, there's
102         no need to add static setter properties. So we will add it if it becomes
103         necessary in the future.
104
105         And at the same time, this patch fixes the issue 145738. Before this patch,
106         `putEntry` in `JSObject::deleteProperty` adds `undefined` property if
107         `isValidOffset(...)` is false (deleted). As the result, deleting twice
108         revives the property with `undefined` value.
109
110         If the static functions are reified and the entry is
111         `BuiltinOrFunctionOrAccessor`, there's no need to execute `putEntry` with
112         static hash table entry. They should be handled in the normal structure's
113         looking up because they should be already reified. So added guard for this.
114
115         * CMakeLists.txt:
116         * DerivedSources.make:
117         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
118         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
119         * JavaScriptCore.xcodeproj/project.pbxproj:
120         * create_hash_table:
121         * runtime/JSObject.cpp:
122         (JSC::getClassPropertyNames):
123         (JSC::JSObject::put):
124         (JSC::JSObject::deleteProperty):
125         (JSC::JSObject::reifyStaticFunctionsForDelete):
126         * runtime/Lookup.cpp:
127         (JSC::reifyStaticAccessor):
128         (JSC::setUpStaticFunctionSlot):
129         * runtime/Lookup.h:
130         (JSC::HashTableValue::propertyGetter):
131         (JSC::HashTableValue::propertyPutter):
132         (JSC::HashTableValue::accessorGetter):
133         (JSC::HashTableValue::accessorSetter):
134         (JSC::getStaticPropertySlot):
135         (JSC::getStaticValueSlot):
136         (JSC::putEntry):
137         (JSC::reifyStaticProperties):
138         * runtime/PropertySlot.h:
139         * runtime/RegExpObject.cpp:
140         (JSC::RegExpObject::getOwnPropertySlot):
141         (JSC::regExpObjectGlobal): Deleted.
142         (JSC::regExpObjectIgnoreCase): Deleted.
143         (JSC::regExpObjectMultiline): Deleted.
144         (JSC::appendLineTerminatorEscape<LChar>): Deleted.
145         (JSC::appendLineTerminatorEscape<UChar>): Deleted.
146         (JSC::regExpObjectSourceInternal): Deleted.
147         (JSC::regExpObjectSource): Deleted.
148         * runtime/RegExpPrototype.cpp:
149         (JSC::RegExpPrototype::getOwnPropertySlot):
150         (JSC::regExpProtoGetterGlobal):
151         (JSC::regExpProtoGetterIgnoreCase):
152         (JSC::regExpProtoGetterMultiline):
153         (JSC::appendLineTerminatorEscape<LChar>):
154         (JSC::appendLineTerminatorEscape<UChar>):
155         (JSC::regExpProtoGetterSourceInternal):
156         (JSC::regExpProtoGetterSource):
157         * tests/stress/static-function-delete.js: Added.
158         (shouldBe):
159         * tests/stress/static-function-put.js: Added.
160         (shouldBe):
161         * tests/stress/static-getter-delete.js: Added.
162         (shouldBe):
163         (shouldThrow):
164         * tests/stress/static-getter-descriptors.js: Added.
165         (shouldBe):
166         * tests/stress/static-getter-enumeration.js: Added.
167         (shouldBe):
168         * tests/stress/static-getter-get.js: Added.
169         (shouldBe):
170         * tests/stress/static-getter-in-names.js: Added.
171         (shouldBe):
172         * tests/stress/static-getter-names.js: Added.
173         (shouldBe):
174         * tests/stress/static-getter-put.js: Added.
175         (shouldBe):
176         (shouldThrow):
177
178 2015-06-09  Andreas Kling  <akling@apple.com>
179
180         [JSC] JSString::getIndex() should avoid reifying substrings.
181         <https://webkit.org/b/145803>
182
183         Reviewed by Darin Adler.
184
185         Implement getIndex() using JSString::view(), which cuts it down to a one-liner
186         and also avoids reifying substrings.
187
188         I saw 178 kB of reified substrings below operationGetByVal -> getIndex()
189         on cnet.com, so this should help.
190
191         * runtime/JSString.cpp:
192         (JSC::JSRopeString::getIndexSlowCase): Deleted.
193         * runtime/JSString.h:
194         (JSC::JSString::getIndex):
195
196 2015-06-09  Andreas Kling  <akling@apple.com>
197
198         [JSC] String.prototype.indexOf() should use StringView.
199         <https://webkit.org/b/145351>
200
201         Reviewed by Darin Adler.
202
203         Use StringView::find() to implement String.prototype.indexOf().
204         This avoids reifying the needle and haystack JSStrings in case they
205         are substrings.
206
207         Reduces malloc memory by ~190 kB on cnet.com.
208
209         * runtime/StringPrototype.cpp:
210         (JSC::stringProtoFuncIndexOf):
211
212 2015-06-09  Csaba Osztrogonác  <ossy@webkit.org>
213
214         [cmake] Fix the style issues in cmake project files
215         https://bugs.webkit.org/show_bug.cgi?id=145755
216
217         Reviewed by Darin Adler.
218
219         * CMakeLists.txt:
220
221 2015-06-08  Gyuyoung Kim  <gyuyoung.kim@webkit.org>
222
223         Purge PassRefPtr in JavaScriptCore
224         https://bugs.webkit.org/show_bug.cgi?id=145750
225
226         As a step to purge PassRefPtr, this patch replaces PassRefPtr with Ref or RefPtr.
227
228         Reviewed by Darin Adler.
229
230         * API/JSClassRef.cpp:
231         (OpaqueJSClass::createNoAutomaticPrototype):
232         * API/JSClassRef.h:
233         * API/JSContextRef.cpp:
234         * API/JSScriptRef.cpp:
235         (OpaqueJSScript::create):
236         * API/JSStringRef.cpp:
237         (JSStringCreateWithCharacters):
238         (JSStringCreateWithUTF8CString):
239         * API/OpaqueJSString.cpp:
240         (OpaqueJSString::create):
241         * API/OpaqueJSString.h:
242         (OpaqueJSString::create):
243         * bytecompiler/StaticPropertyAnalysis.h:
244         (JSC::StaticPropertyAnalysis::create):
245         * debugger/DebuggerCallFrame.h:
246         (JSC::DebuggerCallFrame::create):
247         * dfg/DFGToFTLDeferredCompilationCallback.cpp:
248         (JSC::DFG::ToFTLDeferredCompilationCallback::create):
249         * dfg/DFGToFTLDeferredCompilationCallback.h:
250         * dfg/DFGToFTLForOSREntryDeferredCompilationCallback.cpp:
251         (JSC::DFG::Ref<ToFTLForOSREntryDeferredCompilationCallback>ToFTLForOSREntryDeferredCompilationCallback::create):
252         (JSC::DFG::ToFTLForOSREntryDeferredCompilationCallback::create): Deleted.
253         * dfg/DFGToFTLForOSREntryDeferredCompilationCallback.h:
254         * dfg/DFGWorklist.cpp:
255         (JSC::DFG::Worklist::create):
256         (JSC::DFG::ensureGlobalDFGWorklist):
257         (JSC::DFG::ensureGlobalFTLWorklist):
258         * dfg/DFGWorklist.h:
259         * heap/EdenGCActivityCallback.h:
260         (JSC::GCActivityCallback::createEdenTimer):
261         * heap/FullGCActivityCallback.h:
262         (JSC::GCActivityCallback::createFullTimer):
263         * heap/GCActivityCallback.h:
264         * inspector/InjectedScriptHost.h:
265         * inspector/JavaScriptCallFrame.h:
266         (Inspector::JavaScriptCallFrame::create):
267         * inspector/ScriptArguments.cpp:
268         (Inspector::ScriptArguments::create):
269         * inspector/ScriptArguments.h:
270         * jit/JITStubRoutine.h:
271         (JSC::JITStubRoutine::createSelfManagedRoutine):
272         * jit/JITToDFGDeferredCompilationCallback.cpp:
273         (JSC::JITToDFGDeferredCompilationCallback::create):
274         * jit/JITToDFGDeferredCompilationCallback.h:
275         * jsc.cpp:
276         (jscmain):
277         * parser/NodeConstructors.h:
278         (JSC::ArrayPatternNode::create):
279         (JSC::ObjectPatternNode::create):
280         (JSC::BindingNode::create):
281         * parser/Nodes.cpp:
282         (JSC::FunctionParameters::create):
283         * parser/Nodes.h:
284         * parser/SourceProvider.h:
285         (JSC::StringSourceProvider::create):
286         * profiler/Profile.cpp:
287         (JSC::Profile::create):
288         * profiler/Profile.h:
289         * profiler/ProfileGenerator.cpp:
290         (JSC::ProfileGenerator::create):
291         * profiler/ProfileGenerator.h:
292         * profiler/ProfileNode.h:
293         (JSC::ProfileNode::create):
294         * runtime/DataView.cpp:
295         (JSC::DataView::create):
296         * runtime/DataView.h:
297         * runtime/DateInstanceCache.h:
298         (JSC::DateInstanceData::create):
299         * runtime/JSPromiseReaction.cpp:
300         (JSC::createExecutePromiseReactionMicrotask):
301         * runtime/JSPromiseReaction.h:
302         * runtime/PropertyNameArray.h:
303         (JSC::PropertyNameArrayData::create):
304         * runtime/TypeSet.h:
305         (JSC::StructureShape::create):
306         (JSC::TypeSet::create):
307         * runtime/TypedArrayBase.h:
308         (JSC::TypedArrayBase::create):
309         (JSC::TypedArrayBase::createUninitialized):
310         (JSC::TypedArrayBase::subarrayImpl):
311         * runtime/VM.cpp:
312         (JSC::VM::createContextGroup):
313         (JSC::VM::create):
314         (JSC::VM::createLeaked):
315         * runtime/VM.h:
316         * yarr/RegularExpression.cpp:
317         (JSC::Yarr::RegularExpression::Private::create):
318
319 2015-06-08  Filip Pizlo  <fpizlo@apple.com>
320
321         It should be possible to hoist all constants in DFG SSA
322         https://bugs.webkit.org/show_bug.cgi?id=145769
323
324         Reviewed by Geoffrey Garen.
325         
326         It's sometimes somewhat more efficient, and convenient, to have all constants at the
327         top of the root block. We don't require this as an IR invariant because too many phases
328         want to be able to insert constants in weird places. But, this phase will be great for
329         preparing for https://bugs.webkit.org/show_bug.cgi?id=145768.
330
331         * CMakeLists.txt:
332         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
333         * JavaScriptCore.xcodeproj/project.pbxproj:
334         * dfg/DFGConstantHoistingPhase.cpp: Added.
335         (JSC::DFG::performConstantHoisting):
336         * dfg/DFGConstantHoistingPhase.h: Added.
337         * dfg/DFGPlan.cpp:
338         (JSC::DFG::Plan::compileInThreadImpl):
339
340 2015-06-07  Filip Pizlo  <fpizlo@apple.com>
341
342         The tiny set magic in StructureSet should be available in WTF
343         https://bugs.webkit.org/show_bug.cgi?id=145722
344
345         Reviewed by Geoffrey Garen.
346         
347         I moved the generic logic of small sets of pointers and moved it into WTF. Now,
348         StructureSet is a subclass of TinyPtrSet<Structure*>. There shouldn't be any functional
349         change.
350
351         * bytecode/StructureSet.cpp:
352         (JSC::StructureSet::filter):
353         (JSC::StructureSet::filterArrayModes):
354         (JSC::StructureSet::speculationFromStructures):
355         (JSC::StructureSet::arrayModesFromStructures):
356         (JSC::StructureSet::dumpInContext):
357         (JSC::StructureSet::dump):
358         (JSC::StructureSet::clear): Deleted.
359         (JSC::StructureSet::add): Deleted.
360         (JSC::StructureSet::remove): Deleted.
361         (JSC::StructureSet::contains): Deleted.
362         (JSC::StructureSet::merge): Deleted.
363         (JSC::StructureSet::exclude): Deleted.
364         (JSC::StructureSet::isSubsetOf): Deleted.
365         (JSC::StructureSet::overlaps): Deleted.
366         (JSC::StructureSet::operator==): Deleted.
367         (JSC::StructureSet::addOutOfLine): Deleted.
368         (JSC::StructureSet::containsOutOfLine): Deleted.
369         (JSC::StructureSet::copyFromOutOfLine): Deleted.
370         (JSC::StructureSet::OutOfLineList::create): Deleted.
371         (JSC::StructureSet::OutOfLineList::destroy): Deleted.
372         * bytecode/StructureSet.h:
373         (JSC::StructureSet::onlyStructure):
374         (JSC::StructureSet::StructureSet): Deleted.
375         (JSC::StructureSet::operator=): Deleted.
376         (JSC::StructureSet::~StructureSet): Deleted.
377         (JSC::StructureSet::isEmpty): Deleted.
378         (JSC::StructureSet::genericFilter): Deleted.
379         (JSC::StructureSet::isSupersetOf): Deleted.
380         (JSC::StructureSet::size): Deleted.
381         (JSC::StructureSet::at): Deleted.
382         (JSC::StructureSet::operator[]): Deleted.
383         (JSC::StructureSet::last): Deleted.
384         (JSC::StructureSet::iterator::iterator): Deleted.
385         (JSC::StructureSet::iterator::operator*): Deleted.
386         (JSC::StructureSet::iterator::operator++): Deleted.
387         (JSC::StructureSet::iterator::operator==): Deleted.
388         (JSC::StructureSet::iterator::operator!=): Deleted.
389         (JSC::StructureSet::begin): Deleted.
390         (JSC::StructureSet::end): Deleted.
391         (JSC::StructureSet::ContainsOutOfLine::ContainsOutOfLine): Deleted.
392         (JSC::StructureSet::ContainsOutOfLine::operator()): Deleted.
393         (JSC::StructureSet::copyFrom): Deleted.
394         (JSC::StructureSet::OutOfLineList::list): Deleted.
395         (JSC::StructureSet::OutOfLineList::OutOfLineList): Deleted.
396         (JSC::StructureSet::deleteStructureListIfNecessary): Deleted.
397         (JSC::StructureSet::isThin): Deleted.
398         (JSC::StructureSet::pointer): Deleted.
399         (JSC::StructureSet::singleStructure): Deleted.
400         (JSC::StructureSet::structureList): Deleted.
401         (JSC::StructureSet::set): Deleted.
402         (JSC::StructureSet::setEmpty): Deleted.
403         (JSC::StructureSet::getReservedFlag): Deleted.
404         (JSC::StructureSet::setReservedFlag): Deleted.
405         * dfg/DFGStructureAbstractValue.cpp:
406         (JSC::DFG::StructureAbstractValue::clobber):
407         (JSC::DFG::StructureAbstractValue::filter):
408         (JSC::DFG::StructureAbstractValue::filterSlow):
409         (JSC::DFG::StructureAbstractValue::contains):
410         * dfg/DFGStructureAbstractValue.h:
411         (JSC::DFG::StructureAbstractValue::makeTop):
412
413 2015-06-08  Csaba Osztrogonác  <ossy@webkit.org>
414
415         [ARM] Add the missing setupArgumentsWithExecState functions after r185240
416         https://bugs.webkit.org/show_bug.cgi?id=145754
417
418         Reviewed by Benjamin Poulain.
419
420         * jit/CCallHelpers.h:
421         (JSC::CCallHelpers::setupArgumentsWithExecState):
422
423 2015-06-08  Brady Eidson  <beidson@apple.com>
424
425         Completely remove all IDB properties/constructors when it is disabled at runtime.
426         rdar://problem/18429374 and https://bugs.webkit.org/show_bug.cgi?id=137034
427
428         Reviewed by Geoffrey Garen.
429
430         * runtime/CommonIdentifiers.h:
431
432 2015-06-06  Mark Lam  <mark.lam@apple.com>
433
434         Returned Exception* values need to be initialized to nullptr when no exceptions are thrown.
435         https://bugs.webkit.org/show_bug.cgi?id=145720
436
437         Reviewed by Dan Bernstein.
438
439         * debugger/DebuggerCallFrame.cpp:
440         (JSC::DebuggerCallFrame::evaluate):
441
442 2015-06-05  Mark Lam  <mark.lam@apple.com>
443
444         Subclasses of JSNonFinalObject with gc'able children need to implement visitChildren().
445         https://bugs.webkit.org/show_bug.cgi?id=145709
446
447         Reviewed by Geoffrey Garen.
448
449         * jsc.cpp:
450         (functionSetElementRoot):
451         - The Element class has a member of type Root which extends JSDestructibleObject.
452           It should be stored in a WriteBarrier, and visited by visitChildren().  
453
454         * runtime/ClonedArguments.cpp:
455         (JSC::ClonedArguments::materializeSpecialsIfNecessary):
456         (JSC::ClonedArguments::visitChildren):
457         * runtime/ClonedArguments.h:
458         - Add missing visitChildren().
459
460         * tests/stress/cloned-arguments-should-visit-callee-during-gc.js: Added.
461         (makeTransientFunction.transientFunc):
462         (makeTransientFunction):
463
464 2015-06-05  Geoffrey Garen  <ggaren@apple.com>
465
466         DropAllLocks RELEASE_ASSERT on iOS
467         https://bugs.webkit.org/show_bug.cgi?id=139654
468
469         Reviewed by Mark Lam.
470
471         * runtime/JSLock.cpp:
472         (JSC::JSLock::dropAllLocks): Removed a comment because it duplicated
473         the code beneath it. Removed a FIXME because we can't ASSERT that
474         we're holding the lock. WebKit1 on iOS drops the lock before calling to
475         delegates, not knowing whether it holds the lock or not.
476
477         (JSC::JSLock::DropAllLocks::DropAllLocks): Only ASSERT that we are not
478         GC'ing if we hold the lock. If we do not hold the lock, it is perfectly
479         valid for some other thread, which does hold the lock, to be GC'ing.
480         What is not valid is to drop the lock in the middle of GC, since GC
481         must be atomic.
482
483 2015-06-05  Filip Pizlo  <fpizlo@apple.com>
484
485         speculateRealNumber() should early exit if you're already a real number, not if you're already a real double.
486
487         Rubber stamped by Mark Lam.
488         
489         This was causing: https://build.webkit.org/results/Apple%20Yosemite%20Debug%20WK1%20(Tests)/r185261%20(5180)/webaudio/note-grain-on-timing-crash-log.txt
490
491         * dfg/DFGSpeculativeJIT.cpp:
492         (JSC::DFG::SpeculativeJIT::speculateRealNumber):
493
494 2015-06-05  Mark Lam  <mark.lam@apple.com>
495
496         finally blocks should not set the exception stack trace when re-throwing the exception.
497         https://bugs.webkit.org/show_bug.cgi?id=145525
498
499         Reviewed by Geoffrey Garen.
500
501         How exceptions presently work:
502         =============================
503         1. op_throw can throw any JSValue.
504         2. the VM tries to capture the stack at the throw point and propagate that as needed.
505         3. finally blocks are implemented using op_catch to catch the thrown value, and throws it again using op_throw.
506
507         What's wrong with how it presently works:
508         ========================================
509         1. finally's makes for bad exception throw line numbers in the Inspector console.
510
511            The op_throw in finally will throw the value anew i.e. it captures a stack from the re-throw point.
512            As a result, the Inspector sees the finally block as the throw point.  The original stack is lost.
513
514         2. finally's breaks the Inspector's "Breaks on Uncaught Exception"
515
516            This is because finally blocks are indistinguishable from catch blocks.  As a result, a try-finally,
517            which should break in the Inspector on the throw, does not because the Inspector thought the
518            exception was "caught".
519
520         3. finally's yields confusing break points when the Inspector "Breaks on All Exceptions"
521
522            a. In a try-finally scenario, the Inspector breaks 2 times: 1 at the throw, 1 at the finally.
523            b. In a for-of loop (which has synthesized finallys), the Inspector will do another break.
524               Similarly for other cases of JS code which synthesize finallys.
525            c. At VM re-entry boundaries (e.g. js throws & returns to native code, which returns to js),
526               the Inspector will do another break if there's an uncaught exception.
527
528         How this patch fixes the issues:
529         ===============================
530         1. We introduce an Exception object that wraps the thrown value and the exception stack.
531
532            When throwing an exception, the VM will check if the thrown value is an Exception
533            object or not.  If it is not an Exception object, then we must be throwing a new
534            exception.  The VM will create an Exception object to wrap the thrown value and
535            capture the current stack for it.
536
537            If the thrown value is already an Exception object, then the requested throw operation
538            must be a re-throw.  The VM will not capture a new stack for it.
539
540         2. op_catch will now populate 2 locals: 1 for the Exception, 1 for the thrown JSValue.
541
542            The VM is aware of the Exception object and uses it for rethrows in finally blocks.
543            JS source code is never aware of the Exception object.
544
545            JS code is aware of the thrown value.  If it throws the caught thrown value, that
546            constitutes a new throw, and a new Exception object will be created for it.
547
548         3. The VM no longer tracks the thrown JSValue and the exception stack.  It will only
549            track a m_exception field which is an Exception*.
550
551         4. The BytecodeGenerator has already been updated in a prior patch to distinguish
552            between Catch, Finally, and SynthesizedFinally blocks.  The interpreter runtime will
553            now report to the debugger whether we have a Catch handler, not just any handlers.
554
555            The debugger will use this detail to determine whether to break or not.  "Break on
556            uncaught exceptions" will only break if no Catch handler was found.
557
558            This solves the issue of the debugger breaking at finally blocks, and for-of statements.
559
560         5. The Exception object will also have a flag to indicate whether the debugger has been
561            notified of the Exception being thrown.  Once the Interpreter notifies the debugger
562            of the Exception object, it will mark this flag and not repeat the notify the debugger
563            again of the same Exception.
564
565            This solves the issue of the debugger breaking at VM re-entry points due to uncaught
566            exceptions.
567
568         6. The life-cycle of the captured exception stack trace will now follow the life-cycle
569            of the Exception object.
570
571         Other changes:
572         7. Change all clients of the VM::exception() to expect an Exception* instead of JSValue.
573
574         8. Fixed a few bugs where thrown exceptions are not cleared before exiting the VM.
575
576         9. Also renamed some variables and classes to better describe what they are.
577
578         * API/JSBase.cpp:
579         (JSEvaluateScript):
580         (JSCheckScriptSyntax):
581
582         * API/JSObjectRef.cpp:
583         (handleExceptionIfNeeded):
584         - The functions below all do the same exception check.  Added this helper
585           to simplify the code.
586         (JSClassCreate):
587         (JSObjectMakeFunction):
588         (JSObjectMakeArray):
589         (JSObjectMakeDate):
590         (JSObjectMakeError):
591         (JSObjectMakeRegExp):
592         (JSObjectGetProperty):
593         (JSObjectSetProperty):
594         (JSObjectGetPropertyAtIndex):
595         (JSObjectSetPropertyAtIndex):
596         (JSObjectDeleteProperty):
597         (JSObjectCallAsFunction):
598         (JSObjectCallAsConstructor):
599
600         * API/JSScriptRef.cpp:
601         * API/JSValue.mm:
602         (JSContainerConvertor::take):
603         (reportExceptionToInspector):
604
605         * API/JSValueRef.cpp:
606         (handleExceptionIfNeeded):
607         - The functions below all do the same exception check.  Added this helper
608           to simplify the code.
609         (evernoteHackNeeded):
610         (JSValueIsEqual):
611         (JSValueIsInstanceOfConstructor):
612         (JSValueCreateJSONString):
613         (JSValueToNumber):
614         (JSValueToStringCopy):
615         (JSValueToObject):
616
617         * CMakeLists.txt:
618         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
619         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
620         * JavaScriptCore.xcodeproj/project.pbxproj:
621         - Added new files Exception.h and Exception.cpp.
622
623         * bindings/ScriptFunctionCall.cpp:
624         (Deprecated::ScriptFunctionCall::call):
625         * bindings/ScriptFunctionCall.h:
626
627         * bytecode/BytecodeList.json:
628         - op_catch now had 2 operands: the exception register, and the thrown value register.
629
630         * bytecode/BytecodeUseDef.h:
631         (JSC::computeDefsForBytecodeOffset):
632         * bytecode/CodeBlock.cpp:
633         (JSC::CodeBlock::dumpBytecode):
634         (JSC::CodeBlock::handlerForBytecodeOffset):
635         * bytecode/CodeBlock.h:
636         - handlerForBytecodeOffset() now can look for just Catch handlers only.
637
638         * bytecode/HandlerInfo.h:
639         - Cleaned up some white space I accidentally added in a previous patch.
640
641         * bytecompiler/BytecodeGenerator.cpp:
642         (JSC::BytecodeGenerator::pushTry):
643         (JSC::BytecodeGenerator::popTryAndEmitCatch):
644         (JSC::BytecodeGenerator::emitThrowReferenceError):
645         (JSC::BytecodeGenerator::emitEnumeration):
646         * bytecompiler/BytecodeGenerator.h:
647         (JSC::BytecodeGenerator::emitThrow):
648         * bytecompiler/NodesCodegen.cpp:
649         (JSC::TryNode::emitBytecode):
650         - Adding support for op_catch's 2 operands.
651
652         * debugger/Debugger.cpp:
653         (JSC::Debugger::hasBreakpoint):
654         (JSC::Debugger::pauseIfNeeded):
655         (JSC::Debugger::exception):
656         * debugger/Debugger.h:
657         * debugger/DebuggerCallFrame.cpp:
658         (JSC::DebuggerCallFrame::thisValue):
659         (JSC::DebuggerCallFrame::evaluate):
660         * debugger/DebuggerCallFrame.h:
661         (JSC::DebuggerCallFrame::isValid):
662         * inspector/InjectedScriptManager.cpp:
663         (Inspector::InjectedScriptManager::createInjectedScript):
664         * inspector/InspectorEnvironment.h:
665         * inspector/JSGlobalObjectInspectorController.cpp:
666         (Inspector::JSGlobalObjectInspectorController::appendAPIBacktrace):
667         (Inspector::JSGlobalObjectInspectorController::reportAPIException):
668         * inspector/JSGlobalObjectInspectorController.h:
669         * inspector/JSGlobalObjectScriptDebugServer.h:
670         * inspector/JSJavaScriptCallFrame.cpp:
671         (Inspector::JSJavaScriptCallFrame::evaluate):
672         * inspector/JavaScriptCallFrame.h:
673         (Inspector::JavaScriptCallFrame::vmEntryGlobalObject):
674         (Inspector::JavaScriptCallFrame::thisValue):
675         (Inspector::JavaScriptCallFrame::evaluate):
676         * inspector/ScriptCallStackFactory.cpp:
677         (Inspector::extractSourceInformationFromException):
678         (Inspector::createScriptCallStackFromException):
679         * inspector/ScriptCallStackFactory.h:
680         * inspector/ScriptDebugServer.cpp:
681         (Inspector::ScriptDebugServer::evaluateBreakpointAction):
682         (Inspector::ScriptDebugServer::handleBreakpointHit):
683         (Inspector::ScriptDebugServer::handleExceptionInBreakpointCondition):
684         * inspector/ScriptDebugServer.h:
685         * interpreter/CallFrame.h:
686         (JSC::ExecState::clearException):
687         (JSC::ExecState::exception):
688         (JSC::ExecState::hadException):
689         (JSC::ExecState::atomicStringTable):
690         (JSC::ExecState::propertyNames):
691         (JSC::ExecState::clearSupplementaryExceptionInfo): Deleted.
692
693         * interpreter/Interpreter.cpp:
694         (JSC::unwindCallFrame):
695         (JSC::Interpreter::stackTraceAsString):
696         (JSC::GetCatchHandlerFunctor::GetCatchHandlerFunctor):
697         (JSC::GetCatchHandlerFunctor::operator()):
698         (JSC::Interpreter::unwind):
699         - Added a check for didNotifyInspectorOfThrow() here to prevent duplicate reports
700           of the same Exception to the debugger.
701
702         (JSC::GetExceptionHandlerFunctor::GetExceptionHandlerFunctor): Deleted.
703         (JSC::GetExceptionHandlerFunctor::operator()): Deleted.
704         - Renamed GetExceptionHandlerFunctor to GetCatchHandlerFunctor since the debugger
705           is only interested in knowing whether we have Catch handlers.
706
707         * interpreter/Interpreter.h:
708         (JSC::SuspendExceptionScope::SuspendExceptionScope):
709         (JSC::SuspendExceptionScope::~SuspendExceptionScope):
710         (JSC::Interpreter::sampler):
711         (JSC::ClearExceptionScope::ClearExceptionScope): Deleted.
712         (JSC::ClearExceptionScope::~ClearExceptionScope): Deleted.
713         - Renamed ClearExceptionScope to SuspendExceptionScope because "clear" implies that
714           we're purging the exception.  Instead, we're merely suspending any handling of
715           that exception for a period defined by the scope.
716
717         * jit/AssemblyHelpers.cpp:
718         (JSC::AssemblyHelpers::emitExceptionCheck):
719
720         * jit/JITExceptions.cpp:
721         (JSC::genericUnwind):
722         - Removed the exception argument.  It is always the value in VM::exception() anyway.
723           genericUnwind() can just get it from the VM, and save everyone some work.
724
725         * jit/JITExceptions.h:
726         * jit/JITOpcodes.cpp:
727         (JSC::JIT::emit_op_catch):
728         * jit/JITOpcodes32_64.cpp:
729         (JSC::JIT::privateCompileCTINativeCall):
730         (JSC::JIT::emit_op_catch):
731         - Add support for the new op_catch operands.
732
733         * jit/JITOperations.cpp:
734         * jit/ThunkGenerators.cpp:
735         (JSC::nativeForGenerator):
736         * jsc.cpp:
737         (functionRun):
738         (functionLoad):
739         (runWithScripts):
740         (runInteractive):
741         * llint/LLIntOffsetsExtractor.cpp:
742         * llint/LLIntSlowPaths.cpp:
743         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
744
745         * llint/LowLevelInterpreter32_64.asm:
746         * llint/LowLevelInterpreter64.asm:
747         - Add support for the new op_catch operands.  Also update the code to handle
748           VM::m_exception being an Exception pointer, not a JSValue.
749
750         * parser/NodeConstructors.h:
751         (JSC::TryNode::TryNode):
752         * parser/Nodes.h:
753         * runtime/CallData.cpp:
754         (JSC::call):
755         * runtime/CallData.h:
756
757         * runtime/Completion.cpp:
758         (JSC::evaluate):
759         * runtime/Completion.h:
760         (JSC::evaluate):
761         - Change evaluate() to take a reference to the returned exception value instead
762           of a pointer.  In all but 2 or 3 cases, we want the returned exception anyway.
763           Might as well simplify the code by requiring the reference.
764
765         * runtime/Error.h:
766         (JSC::throwVMError):
767         (JSC::throwVMTypeError):
768
769         * runtime/Exception.cpp: Added.
770         (JSC::Exception::create):
771         (JSC::Exception::destroy):
772         (JSC::Exception::createStructure):
773         (JSC::Exception::visitChildren):
774         (JSC::Exception::Exception):
775         (JSC::Exception::~Exception):
776         * runtime/Exception.h: Added.
777         (JSC::Exception::valueOffset):
778         (JSC::Exception::cast):
779         (JSC::Exception::value):
780         (JSC::Exception::stack):
781         (JSC::Exception::didNotifyInspectorOfThrow):
782         (JSC::Exception::setDidNotifyInspectorOfThrow):
783
784         * runtime/ExceptionHelpers.cpp:
785         (JSC::createTerminatedExecutionException):
786         (JSC::isTerminatedExecutionException):
787         (JSC::createStackOverflowError):
788         * runtime/ExceptionHelpers.h:
789         * runtime/GetterSetter.cpp:
790         (JSC::callGetter):
791         * runtime/IteratorOperations.cpp:
792         (JSC::iteratorClose):
793         * runtime/JSObject.cpp:
794         * runtime/JSPromiseConstructor.cpp:
795         (JSC::constructPromise):
796         * runtime/JSPromiseDeferred.cpp:
797         (JSC::updateDeferredFromPotentialThenable):
798         (JSC::abruptRejection):
799         * runtime/JSPromiseReaction.cpp:
800         (JSC::ExecutePromiseReactionMicrotask::run):
801
802         * runtime/VM.cpp:
803         (JSC::VM::VM):
804         (JSC::VM::releaseExecutableMemory):
805         (JSC::VM::throwException):
806         (JSC::VM::setStackPointerAtVMEntry):
807         (JSC::VM::getExceptionInfo): Deleted.
808         (JSC::VM::setExceptionInfo): Deleted.
809         (JSC::VM::clearException): Deleted.
810         (JSC::clearExceptionStack): Deleted.
811         * runtime/VM.h:
812         (JSC::VM::targetMachinePCForThrowOffset):
813         (JSC::VM::clearException):
814         (JSC::VM::setException):
815         (JSC::VM::exception):
816         (JSC::VM::addressOfException):
817         (JSC::VM::exceptionStack): Deleted.
818         * runtime/VMEntryScope.cpp:
819         (JSC::VMEntryScope::VMEntryScope):
820         (JSC::VMEntryScope::setEntryScopeDidPopListener):
821
822 2015-06-04  Benjamin Poulain  <bpoulain@apple.com>
823
824         [JSC] Always track out-of-bounds array access explicitly instead of relying on the slow case
825         https://bugs.webkit.org/show_bug.cgi?id=145673
826
827         Reviewed by Geoffrey Garen.
828
829         Previously, we were deciding to use out-of-bounds speculation based on two informations:
830         -Explicitly detected out-of-bounds accesses tracked on ArrayProfile.
831         -The number of time we took the slow cases in the baseline JIT.
832
833         The heuristic based on slow cases was a little too fragile.
834
835         In some cases, we were running into that limit just because the indexing type changes between
836         two values (typically Int32Array and DoubleArray). Sometimes we were just unlucky on what
837         we used for the inline cache.
838
839         In Kraken, this was hurting us on "audio-beat-detection" and "audio-fft". The array types we see
840         change between Int32 and Double. We run into the slow path a bit but never hit
841         out-of-bounds.
842
843         By the time we compile in DFG, we have stable Double Arrays but we speculate out-of-bounds based
844         on the number of slow cases we took. Because of that, we start boxing the double on GetByVal,
845         using DoubleRep, etc. adding a ton of overhead over otherwise very simple operations.
846
847         WebXPRT was also suffering from this problem but the other way arround: we were missing
848         the out-of-bounds accesses due to changes in indexing types, we were below the threshold
849         of slow-path access, thus we predicted in-bounds accesses for code that was doing plenty
850         of out-of-bands.
851
852
853         This patch fixes the problem by tracking the out-of-bounds access explicitly any time we go
854         into the slow path in baseline JIT. Since we no longer miss any out-of-bounds, we can remove
855         the slow-path heuristic.
856
857         There is new additional special case in the C code regarding out-of-bounds: Arguments access.
858         Mispredicting out-of-bounds accesses on arguments is a disaster for performance, so those are
859         tracked in the way DFG expect it.
860
861
862         There are a few important cases that are still not covered optimally:
863         -PutByVal on Arguments.
864         -Get/Put ByVal on TypedArray.
865         Those are simply not used by DFG in any way. TypedArrays should probably be looked at in the future.
866
867         * bytecode/ArrayProfile.cpp:
868         (JSC::ArrayProfile::computeUpdatedPrediction):
869         The inline-cache repatch cases now update the ArrayProfile information. This has no value in baseline
870         JIT but it helps avoiding one recompile in DFG for the missing ArrayProfile information.
871
872         * bytecode/ArrayProfile.h:
873         (JSC::ArrayProfile::setOutOfBounds):
874         * dfg/DFGByteCodeParser.cpp:
875         (JSC::DFG::ByteCodeParser::getArrayMode):
876         (JSC::DFG::ByteCodeParser::parseBlock):
877         (JSC::DFG::ByteCodeParser::getArrayModeConsideringSlowPath): Deleted.
878         * jit/CCallHelpers.h:
879         (JSC::CCallHelpers::setupArgumentsWithExecState):
880         * jit/JIT.h:
881         * jit/JITInlines.h:
882         (JSC::JIT::callOperation):
883         * jit/JITOpcodes.cpp:
884         (JSC::JIT::emitSlow_op_has_indexed_property):
885         * jit/JITOpcodes32_64.cpp:
886         (JSC::JIT::emitSlow_op_has_indexed_property):
887         * jit/JITOperations.cpp:
888         (JSC::canUseFastArgumentAccess):
889         This is not my favorite part of this patch.
890
891         I tried having JSObject::canGetIndexQuickly() handle arguments which would put everything
892         on the generic path. Unfortunately, that code is very performance sensitive and some benchmarks were
893         impacted by over 10%
894
895         I left JSObject::canGetIndexQuickly() alone, and I added the canUseFastArgumentAccess() mirroring
896         how DFG uses out-of-bounds for Arguments.
897
898         (JSC::getByVal):
899         * jit/JITOperations.h:
900         * jit/JITPropertyAccess.cpp:
901         (JSC::JIT::emitSlow_op_get_by_val):
902         (JSC::JIT::emitSlow_op_put_by_val):
903         * jit/JITPropertyAccess32_64.cpp:
904         (JSC::JIT::emitSlow_op_get_by_val):
905         (JSC::JIT::emitSlow_op_put_by_val):
906         * runtime/JSPromiseFunctions.cpp:
907         * tests/stress/get-by-val-out-of-bounds-basics.js: Added.
908         (opaqueGetByValOnInt32ArrayEarlyOutOfBounds):
909         (testInt32ArrayEarlyOutOfBounds):
910         (testIndexingTypeChangesOnInt32Array):
911         (opaqueGetByValOnStringArrayHotOutOfBounds):
912         (testStringArrayHotOutOfBounds):
913         (testIndexingTypeChangesOnStringArray):
914         (opaqueGetByValOnStringAndInt32ArrayHotOutOfBounds):
915         (testStringAndInt32ArrayHotOutOfBounds):
916         (opaqueGetByValOnDoubleArrayHotOutOfBounds):
917         * tests/stress/put-by-val-out-of-bounds-basics.js: Added.
918         (opaquePutByValOnInt32ArrayEarlyOutOfBounds):
919         (testInt32ArrayEarlyOutOfBounds):
920         (opaquePutByValOnStringArrayHotOutOfBounds):
921         (testStringArrayHotOutOfBounds):
922
923 2015-06-03  Filip Pizlo  <fpizlo@apple.com>
924
925         Simplify unboxing of double JSValues known to be not NaN and not Int32
926         https://bugs.webkit.org/show_bug.cgi?id=145618
927
928         Reviewed by Geoffrey Garen.
929         
930         In many cases we know that we most likely loaded a non-NaN double value from the heap.
931         Prior to this patch, we would do two branches before unboxing the double. This patch
932         reduces this to one branch in the common case. Before:
933         
934             if (is int32)
935                 unbox int32 and convert to double
936             else if (is number)
937                 unbox double
938             else
939                 exit
940         
941         After:
942
943             tmp = unbox double
944             if (tmp == tmp)
945                 done
946             else if (is int32)
947                 unbox int32 and convert to double
948             else
949                 exit
950         
951         We only use the new style if we have profiling that tells us that we are unlikely to see
952         either Int32 or NaN - since we will now exit on NaN and int32 requires an extra branch.
953         
954         This is a 8% speed-up on Octane/box2d. On one microbenchmark this is a 25% speed-up.
955         
956         Rolling this back in after I made DFG::SpeculativeJIT call a new version of unboxDouble()
957         that doesn't assert that the JSValue is a double, since we are intentionally using it
958         before doing the "is a double" test. This wasn't a problem on 32-bit since unboxDouble()
959         does no such assertion on 32-bit.
960
961         * dfg/DFGAbstractInterpreterInlines.h:
962         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
963         * dfg/DFGFixupPhase.cpp:
964         (JSC::DFG::FixupPhase::observeUseKindOnNode):
965         (JSC::DFG::FixupPhase::fixEdgeRepresentation):
966         (JSC::DFG::FixupPhase::injectTypeConversionsForEdge):
967         * dfg/DFGNode.h:
968         (JSC::DFG::Node::shouldSpeculateDouble):
969         (JSC::DFG::Node::shouldSpeculateDoubleReal):
970         (JSC::DFG::Node::shouldSpeculateNumber):
971         * dfg/DFGSafeToExecute.h:
972         (JSC::DFG::SafeToExecuteEdge::operator()):
973         * dfg/DFGSpeculativeJIT.cpp:
974         (JSC::DFG::SpeculativeJIT::compileDoubleRep):
975         (JSC::DFG::SpeculativeJIT::speculateNumber):
976         (JSC::DFG::SpeculativeJIT::speculateRealNumber):
977         (JSC::DFG::SpeculativeJIT::speculateDoubleRepReal):
978         (JSC::DFG::SpeculativeJIT::speculate):
979         (JSC::DFG::SpeculativeJIT::speculateDoubleReal): Deleted.
980         * dfg/DFGSpeculativeJIT.h:
981         * dfg/DFGUseKind.cpp:
982         (WTF::printInternal):
983         * dfg/DFGUseKind.h:
984         (JSC::DFG::typeFilterFor):
985         (JSC::DFG::isNumerical):
986         * ftl/FTLCapabilities.cpp:
987         (JSC::FTL::canCompile):
988         * ftl/FTLLowerDFGToLLVM.cpp:
989         (JSC::FTL::LowerDFGToLLVM::compileDoubleRep):
990         (JSC::FTL::LowerDFGToLLVM::boxDouble):
991         (JSC::FTL::LowerDFGToLLVM::jsValueToStrictInt52):
992         (JSC::FTL::LowerDFGToLLVM::speculate):
993         (JSC::FTL::LowerDFGToLLVM::speculateNumber):
994         (JSC::FTL::LowerDFGToLLVM::speculateRealNumber):
995         (JSC::FTL::LowerDFGToLLVM::speculateDoubleRepReal):
996         (JSC::FTL::LowerDFGToLLVM::jsValueToDouble): Deleted.
997         (JSC::FTL::LowerDFGToLLVM::speculateDoubleReal): Deleted.
998         * jit/AssemblyHelpers.h:
999         (JSC::AssemblyHelpers::branchIfNotOther):
1000         (JSC::AssemblyHelpers::branchIfInt32):
1001         (JSC::AssemblyHelpers::branchIfNotInt32):
1002         (JSC::AssemblyHelpers::branchIfNumber):
1003
1004 2015-06-04  Joseph Pecoraro  <pecoraro@apple.com>
1005
1006         Web Inspector: Class constructor appearing as Object Tree property does not include parameters
1007         https://bugs.webkit.org/show_bug.cgi?id=145661
1008
1009         Reviewed by Timothy Hatcher.
1010
1011         * inspector/InjectedScriptSource.js:
1012         (InjectedScript.prototype._classPreview):
1013         (InjectedScript.RemoteObject.prototype._appendPropertyPreviews):
1014         The string we will return for previews of class constructor functions.
1015
1016         (InjectedScript.RemoteObject):
1017         (InjectedScript.RemoteObject.prototype._describe):
1018         No longer return the class name as the description string.
1019         Instead return the class name for the RemoteObject.className.
1020
1021 2015-06-04  Commit Queue  <commit-queue@webkit.org>
1022
1023         Unreviewed, rolling out r185216.
1024         https://bugs.webkit.org/show_bug.cgi?id=145666
1025
1026         it caused a bunch of debug crashes (Requested by pizlo on
1027         #webkit).
1028
1029         Reverted changeset:
1030
1031         "Simplify unboxing of double JSValues known to be not NaN and
1032         not Int32"
1033         https://bugs.webkit.org/show_bug.cgi?id=145618
1034         http://trac.webkit.org/changeset/185216
1035
1036 2015-06-03  Filip Pizlo  <fpizlo@apple.com>
1037
1038         Simplify unboxing of double JSValues known to be not NaN and not Int32
1039         https://bugs.webkit.org/show_bug.cgi?id=145618
1040
1041         Reviewed by Geoffrey Garen.
1042         
1043         In many cases we know that we most likely loaded a non-NaN double value from the heap.
1044         Prior to this patch, we would do two branches before unboxing the double. This patch
1045         reduces this to one branch in the common case. Before:
1046         
1047             if (is int32)
1048                 unbox int32 and convert to double
1049             else if (is number)
1050                 unbox double
1051             else
1052                 exit
1053         
1054         After:
1055
1056             tmp = unbox double
1057             if (tmp == tmp)
1058                 done
1059             else if (is int32)
1060                 unbox int32 and convert to double
1061             else
1062                 exit
1063         
1064         We only use the new style if we have profiling that tells us that we are unlikely to see
1065         either Int32 or NaN - since we will now exit on NaN and int32 requires an extra branch.
1066         
1067         This is a 8% speed-up on Octane/box2d. On one microbenchmark this is a 25% speed-up.
1068
1069         * dfg/DFGAbstractInterpreterInlines.h:
1070         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
1071         * dfg/DFGFixupPhase.cpp:
1072         (JSC::DFG::FixupPhase::observeUseKindOnNode):
1073         (JSC::DFG::FixupPhase::fixEdgeRepresentation):
1074         (JSC::DFG::FixupPhase::injectTypeConversionsForEdge):
1075         * dfg/DFGNode.h:
1076         (JSC::DFG::Node::shouldSpeculateDouble):
1077         (JSC::DFG::Node::shouldSpeculateDoubleReal):
1078         (JSC::DFG::Node::shouldSpeculateNumber):
1079         * dfg/DFGSafeToExecute.h:
1080         (JSC::DFG::SafeToExecuteEdge::operator()):
1081         * dfg/DFGSpeculativeJIT.cpp:
1082         (JSC::DFG::SpeculativeJIT::compileDoubleRep):
1083         (JSC::DFG::SpeculativeJIT::speculateNumber):
1084         (JSC::DFG::SpeculativeJIT::speculateRealNumber):
1085         (JSC::DFG::SpeculativeJIT::speculateDoubleRepReal):
1086         (JSC::DFG::SpeculativeJIT::speculate):
1087         (JSC::DFG::SpeculativeJIT::speculateDoubleReal): Deleted.
1088         * dfg/DFGSpeculativeJIT.h:
1089         * dfg/DFGUseKind.cpp:
1090         (WTF::printInternal):
1091         * dfg/DFGUseKind.h:
1092         (JSC::DFG::typeFilterFor):
1093         (JSC::DFG::isNumerical):
1094         * ftl/FTLCapabilities.cpp:
1095         (JSC::FTL::canCompile):
1096         * ftl/FTLLowerDFGToLLVM.cpp:
1097         (JSC::FTL::LowerDFGToLLVM::compileDoubleRep):
1098         (JSC::FTL::LowerDFGToLLVM::boxDouble):
1099         (JSC::FTL::LowerDFGToLLVM::jsValueToStrictInt52):
1100         (JSC::FTL::LowerDFGToLLVM::speculate):
1101         (JSC::FTL::LowerDFGToLLVM::speculateNumber):
1102         (JSC::FTL::LowerDFGToLLVM::speculateRealNumber):
1103         (JSC::FTL::LowerDFGToLLVM::speculateDoubleRepReal):
1104         (JSC::FTL::LowerDFGToLLVM::jsValueToDouble): Deleted.
1105         (JSC::FTL::LowerDFGToLLVM::speculateDoubleReal): Deleted.
1106         * jit/AssemblyHelpers.h:
1107         (JSC::AssemblyHelpers::branchIfNotOther):
1108         (JSC::AssemblyHelpers::branchIfInt32):
1109         (JSC::AssemblyHelpers::branchIfNotInt32):
1110         (JSC::AssemblyHelpers::branchIfNumber):
1111
1112 2015-06-04  Filip Pizlo  <fpizlo@apple.com>
1113
1114         SideState should be a distinct abstract heap from Heap and Stack
1115         https://bugs.webkit.org/show_bug.cgi?id=145653
1116
1117         Reviewed by Geoffrey Garen.
1118         
1119         Before, SideState fit into the hierarchy like so:
1120         
1121         World
1122            |
1123            +-- Stack
1124            |
1125            +-- Heap
1126                  |
1127                  +-- SideState
1128         
1129         Now we will have:
1130         
1131         World
1132            |
1133            +-- Stack
1134            |
1135            +-- Heap
1136            |
1137            +-- SideState
1138         
1139         This makes it easy to ask if a writing operation wrote to anything that is observable even
1140         if we don't exit. SideState is only observable if we exit.
1141
1142         * dfg/DFGAbstractHeap.h:
1143         (JSC::DFG::AbstractHeap::AbstractHeap):
1144         (JSC::DFG::AbstractHeap::supertype):
1145
1146 2015-06-04  Chris Dumez  <cdumez@apple.com>
1147
1148         [WK2] Prune more resources from the MemoryCache before process suspension
1149         https://bugs.webkit.org/show_bug.cgi?id=145633
1150
1151         Reviewed by Andreas Kling.
1152
1153         No longer move protect IncrementalSweeper::fullSweep() behind
1154         USE(CF) so we don't need #ifdefs at call sites, similarly to what is
1155         done for the rest of the IncrementalSweeper API.
1156
1157         * heap/IncrementalSweeper.cpp:
1158         (JSC::IncrementalSweeper::fullSweep):
1159         * heap/IncrementalSweeper.h:
1160
1161 2015-06-01  Filip Pizlo  <fpizlo@apple.com>
1162
1163         CallLinkStatus should return takesSlowPath if the GC often cleared the IC
1164         https://bugs.webkit.org/show_bug.cgi?id=145502
1165
1166         Reviewed by Geoffrey Garen.
1167         
1168         CallLinkInfo now remembers when it has been cleared by GC. This has some safeguards for when
1169         a call gets cleared by GC only because we hadn't converted it into a closure call; in that
1170         case the GC will just tell us that it should be a closure call. The DFG will not optimize
1171         a call that was cleared by GC, and the DFG will always prefer a closure call if the GC told
1172         us that the specific callee was dead but the executable wasn't.
1173         
1174         This guards us from some scenarios that came up in Speedometer. It's neutral on the pure JS
1175         benchmarks, most likely just because those benchmarks aren't real enough to have interesting
1176         GC of code.
1177
1178         * bytecode/CallLinkInfo.cpp:
1179         (JSC::CallLinkInfo::visitWeak):
1180         (JSC::CallLinkInfo::dummy):
1181         * bytecode/CallLinkInfo.h:
1182         (JSC::CallLinkInfo::CallLinkInfo):
1183         * bytecode/CallLinkStatus.cpp:
1184         (JSC::CallLinkStatus::computeFromCallLinkInfo):
1185
1186 2015-06-02  Filip Pizlo  <fpizlo@apple.com>
1187
1188         GetById and PutById profiling should be more precise about it takes slow path
1189         https://bugs.webkit.org/show_bug.cgi?id=145590
1190
1191         Reviewed by Geoffrey Garen.
1192         
1193         If a ById access ever takes slow path, we want the DFG and FTL to know this. Previously we
1194         were relying on slow path counts, which conflate slow paths taken due to a megamorphic
1195         access and slow paths taken due to IC building.
1196
1197         * bytecode/GetByIdStatus.cpp:
1198         (JSC::GetByIdStatus::computeFor):
1199         (JSC::GetByIdStatus::computeForStubInfo):
1200         * bytecode/PutByIdStatus.cpp:
1201         (JSC::PutByIdStatus::computeFor):
1202         (JSC::PutByIdStatus::computeForStubInfo):
1203         * bytecode/StructureStubInfo.h:
1204         (JSC::StructureStubInfo::StructureStubInfo):
1205         * ftl/FTLIntrinsicRepository.h:
1206         * ftl/FTLLowerDFGToLLVM.cpp:
1207         (JSC::FTL::LowerDFGToLLVM::compileGetById):
1208         * jit/JITOperations.cpp:
1209         * jit/JITOperations.h:
1210
1211 2015-06-03  Michael Saboff  <msaboff@apple.com>
1212
1213         Improve test coverage for changes made in 145527
1214         https://bugs.webkit.org/show_bug.cgi?id=145578
1215
1216         Reviewed by Geoffrey Garen.
1217
1218         Added more complexity to poly-setter-combo.js stress test to create more turmoil in the
1219         polymorphic get-by-id / put-by-id with getters and setters to exercise the code change in
1220         https://bugs.webkit.org/show_bug.cgi?id=145527.  By changing the objects that the main test
1221         function sees, we are able to test those paths.  Verified with temporary logging code.
1222
1223         * tests/stress/poly-setter-combo.js:
1224         (Cons2):
1225         (Cons3):
1226         (Cons4):
1227         (foo):
1228         (test):
1229         (runTestWithConstructors):
1230
1231 2015-06-02  Mark Lam  <mark.lam@apple.com>
1232
1233         Gardening: fix broken CLoop build.
1234
1235         Not reviewed.
1236
1237         * bytecode/CallLinkStatus.cpp:
1238         (JSC::CallLinkStatus::computeExitSiteData):
1239
1240 2015-06-02  Keith Miller  <keith_miller@apple.com>
1241
1242         JavaScriptCore: JSExport protocol with an NSInteger property converts negative values to 18446744073709552000
1243         https://bugs.webkit.org/show_bug.cgi?id=145563
1244
1245         Reviewed by Darin Adler.
1246
1247         The Objective-C bindings were improperly converting negative
1248         long long/NSIntegers to 18446744073709552000 because they
1249         were converted to unsigned numbers.
1250
1251         * API/ObjcRuntimeExtras.h:
1252         (parseObjCType):
1253         * API/tests/testapi.mm:
1254         (testObjectiveCAPIMain):
1255         (checkNegativeNSIntegers):
1256         (testObjectiveCAPI):
1257
1258 2015-06-02  Yusuke Suzuki  <utatane.tea@gmail.com>
1259
1260         Heap-use-after-free read of size 4 in JavaScriptCore: WTF::StringImpl::isSymbol() (StringImpl.h:496)
1261         https://bugs.webkit.org/show_bug.cgi?id=145532
1262
1263         Reviewed by Geoffrey Garen.
1264
1265         AtomicStringImpl::lookUp returns AtomicStringImpl*,
1266         it doesn't give any ownership to the caller.
1267         Originally, this is ok because the ownership is taken
1268         by AtomicStringImpl's table (& the register side).
1269
1270         But if we would like to use this returned AtomicStringImpl*,
1271         we should take its ownership immediately.
1272         Because if the register side releases its ownership (ref count),
1273         it will be destroyed.
1274
1275         In JSString::toExistingAtomicString, it returns AtomicStringImpl*.
1276         But it's not appropriate.
1277         If the owner of AtomicStringImpl* is always JSString*, it is ok.
1278         But it looks up the table-registered AtomicStringImpl* from
1279         the AtomicStringImpl table. So JSString* may not have the ownership
1280         of the returned AtomicStringImpl*.
1281
1282         The failure situation is the following.
1283
1284         1. A creates AtomicStringImpl. A has its ownership.
1285            And A registers it to AtomicStringImpl table.
1286         2. JSString looks up the AtomicStringImpl from the table.
1287            It gets AtomicStringImpl*. And JSString doesn't have its ownership.
1288            It returns the raw pointer immediately to the users
1289         3. A is released. There's no owner for AtomicStringImpl*.
1290            So it's also destroyed.
1291         4. Use looked up AtomicStringImpl in (2). It becomes use-after-free.
1292
1293         This patch fixes it by the following changes.
1294
1295         1. Change the signature of `AtomicStringImpl* AtomicStringImpl::lookUp(...)`
1296            to `RefPtr<AtomicStringImpl> AtomicStringImpl::lookUp(..)`.
1297            Use `RefPtr` because it may return `nullptr`.
1298         2. Change the signature of `AtomicStringImpl* JSString::toExistingAtomicString(...)`
1299            to `RefPtr<AtomicStringImpl> JSString::toExistingAtomicString(...)`.
1300            Using `RefPtr` is the same reason.
1301         3. Receive the result with `RefPtr<AtomicStringImpl>` in the caller side.
1302
1303         * dfg/DFGOperations.cpp:
1304         * jit/JITOperations.cpp:
1305         (JSC::getByVal):
1306         * llint/LLIntSlowPaths.cpp:
1307         (JSC::LLInt::getByVal):
1308         * runtime/JSString.cpp:
1309         (JSC::JSRopeString::resolveRopeToExistingAtomicString):
1310         * runtime/JSString.h:
1311         (JSC::JSString::toExistingAtomicString):
1312
1313 2015-05-30  Filip Pizlo  <fpizlo@apple.com>
1314
1315         Any exit from any JIT due to profiling for an inline cache should force all future compilations to be wary
1316         https://bugs.webkit.org/show_bug.cgi?id=145496
1317
1318         Reviewed by Geoffrey Garen.
1319         
1320         This pessimizes compilation a bit, but it reduces the likelihood of exiting from FTL. I
1321         couldn't find any convincing reason not to do this, and we know from Speedometer that this
1322         change is necessary for weirder code.
1323
1324         * bytecode/CallLinkStatus.cpp:
1325         (JSC::CallLinkStatus::computeFor):
1326         (JSC::CallLinkStatus::computeExitSiteData):
1327         (JSC::CallLinkStatus::computeDFGStatuses):
1328         * bytecode/CallLinkStatus.h:
1329         * bytecode/GetByIdStatus.cpp:
1330         (JSC::GetByIdStatus::appendVariant):
1331         (JSC::GetByIdStatus::hasExitSite):
1332         (JSC::GetByIdStatus::computeFor):
1333         * bytecode/GetByIdStatus.h:
1334         * bytecode/PutByIdStatus.cpp:
1335         (JSC::PutByIdStatus::appendVariant):
1336         (JSC::PutByIdStatus::hasExitSite):
1337         (JSC::PutByIdStatus::computeFor):
1338         * bytecode/PutByIdStatus.h:
1339
1340 2015-05-31  Filip Pizlo  <fpizlo@apple.com>
1341
1342         If a call has ever taken the virtual slow path, make sure that the DFG knows this
1343         https://bugs.webkit.org/show_bug.cgi?id=145501
1344
1345         Reviewed by Geoffrey Garen.
1346         
1347         Now now return higher fidelity information in the case of no polymorphic call stub. If the
1348         virtual slow path was ever taken, we note this, and we note either zero or one call variant
1349         based on the IC's last callee.
1350
1351         * bytecode/CallLinkStatus.cpp:
1352         (JSC::CallLinkStatus::computeFromCallLinkInfo):
1353         (JSC::CallLinkStatus::computeFor):
1354
1355 2015-06-01  Michael Saboff  <msaboff@apple.com>
1356
1357         Crash in com.apple.WebKit.WebContent at com.apple.JavaScriptCore: JSC::revertCall + 24
1358         https://bugs.webkit.org/show_bug.cgi?id=145527
1359
1360         Reviewed by Filip Pizlo.
1361
1362         If a CallLinkInfo is GC'ed, we need to notify any PolymorphicCallNode's that reference it.
1363         Added plumbling to clear the m_callLinkInfo of a PolymorphicCallNode when that CallLinkInfo
1364         is going away.
1365
1366         * bytecode/CallLinkInfo.h:
1367         (JSC::CallLinkInfo::~CallLinkInfo):
1368         * jit/PolymorphicCallStubRoutine.cpp:
1369         (JSC::PolymorphicCallNode::unlink):
1370         (JSC::PolymorphicCallNode::clearCallLinkInfo):
1371         (JSC::PolymorphicCallCase::dump):
1372         (JSC::PolymorphicCallStubRoutine::edges):
1373         (JSC::PolymorphicCallStubRoutine::clearCallNodesFor):
1374         (JSC::PolymorphicCallStubRoutine::visitWeak):
1375         * jit/PolymorphicCallStubRoutine.h:
1376         (JSC::PolymorphicCallNode::hasCallLinkInfo):
1377
1378 2015-06-01  Mark Lam  <mark.lam@apple.com>
1379
1380         Add the ability to tell between Catch and Finally blocks.
1381         https://bugs.webkit.org/show_bug.cgi?id=145524 
1382
1383         Reviewed by Michael Saboff.
1384
1385         ... and also SynthesizedFinally blocks too.  A SynthesizedFinally block
1386         is a finally block that is synthesized by the bytecode generator but
1387         does not actually correspond to any exception handling construct at the
1388         JS source code level.  An example of this is the "for ... of" statement
1389         where it needs to do some "final" clean up before passing on the
1390         exception.
1391
1392         Manually tested by inspecting the bytecode dump of functions with
1393         try-catch-finally blocks as well as for of statements which have
1394         synthesized finally blocks.  The bytecode dumps contains the exception
1395         handlers table which has these blocks labelled with their newly added
1396         types.  No automatic test because this type info is not visible to JS
1397         code.
1398
1399         * bytecode/CodeBlock.cpp:
1400         (JSC::CodeBlock::dumpBytecode):
1401         * bytecode/HandlerInfo.h:
1402         (JSC::HandlerInfoBase::type):
1403         (JSC::HandlerInfoBase::setType):
1404         (JSC::HandlerInfoBase::typeName):
1405         (JSC::HandlerInfoBase::isCatchHandler):
1406         (JSC::UnlinkedHandlerInfo::UnlinkedHandlerInfo):
1407         (JSC::HandlerInfo::initialize):
1408         * bytecompiler/BytecodeGenerator.cpp:
1409         (JSC::BytecodeGenerator::generate):
1410         (JSC::BytecodeGenerator::pushTry):
1411         (JSC::BytecodeGenerator::popTryAndEmitCatch):
1412         (JSC::BytecodeGenerator::emitEnumeration):
1413         * bytecompiler/BytecodeGenerator.h:
1414         (JSC::BytecodeGenerator::emitThrow):
1415         * bytecompiler/NodesCodegen.cpp:
1416         (JSC::TryNode::emitBytecode):
1417
1418 2015-05-29  Geoffrey Garen  <ggaren@apple.com>
1419
1420         REGRESSION: These sorting idioms used by Peacekeeper and Browsermark are ~20X slower
1421         https://bugs.webkit.org/show_bug.cgi?id=145412
1422
1423         Reviewed by Darin Adler.
1424
1425         Moar speedup.
1426
1427         Added a bucket sort for string sorting.
1428
1429         * builtins/Array.prototype.js:
1430         (sort.compactSparse):
1431         (sort.compactSlow):
1432         (sort.compact): Split out a compaction fast path for dense arrays. Without
1433         it, compaction can increase sort time by 2X for simple sorts.
1434
1435         (sort.bucketSort):
1436         (sort.stringSort): Use a bucket sorting algorithm if we know we're sorting
1437         strings. This makes average case string sorting O(N) with O(N) additional
1438         memory use.
1439
1440         The worst case bucket sort can require O(M * N) additional
1441         space. We avoid this by falling back to merge sort when things are
1442         simple or overly duplicative. These are the two cases that accumulate
1443         excessive -- and potentially pathological -- bucketing overhead.
1444
1445 2015-06-01  Mark Lam  <mark.lam@apple.com>
1446
1447         HandlerInfo::initialize() should not assume that CodeLocationLabel is available.
1448         https://bugs.webkit.org/show_bug.cgi?id=145515
1449
1450         Reviewed by Csaba Osztrogonác.
1451
1452         CodeLocationLabel is only defined for ENABLE(ASSEMBLER) builds.  r185022's
1453         attempt at simplifying code to increase readability failed to take this into
1454         account.  This patch fixes it.
1455
1456         * bytecode/CodeBlock.cpp:
1457         (JSC::CodeBlock::CodeBlock):
1458         * bytecode/HandlerInfo.h:
1459         (JSC::HandlerInfo::initialize):
1460
1461 2015-05-31  Filip Pizlo  <fpizlo@apple.com>
1462
1463         Unreviewed, add a FIXME referencing https://bugs.webkit.org/show_bug.cgi?id=145503.
1464
1465         * dfg/DFGByteCodeParser.cpp:
1466         (JSC::DFG::ByteCodeParser::inliningCost):
1467
1468 2015-05-31  Yusuke Suzuki  <utatane.tea@gmail.com>
1469
1470         [ES6] Drop WeakMap#clear
1471         https://bugs.webkit.org/show_bug.cgi?id=145489
1472
1473         Reviewed by Mark Lam.
1474
1475         ES6 spec intentionally drops the WeakMap#clear
1476         to allow engine to implement WeakMap as a per-object table.
1477
1478         This patch drops WeakMap.prototype.clear.
1479
1480         * runtime/WeakMapPrototype.cpp:
1481         (JSC::WeakMapPrototype::finishCreation): Deleted.
1482         (JSC::protoFuncWeakMapClear): Deleted.
1483
1484 2015-05-31  Jordan Harband  <ljharb@gmail.com>
1485
1486         Array#reduce and reduceRight don't follow ToLength
1487         https://bugs.webkit.org/show_bug.cgi?id=145364
1488         Per https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength
1489
1490         Reviewed by Yusuke Suzuki.
1491
1492         * builtins/Array.prototype.js:
1493         (reduce):
1494         (reduceRight):
1495         * runtime/ArrayPrototype.cpp:
1496         (JSC::ArrayPrototype::finishCreation):
1497         (JSC::arrayProtoFuncReduce): Deleted.
1498         (JSC::arrayProtoFuncReduceRight): Deleted.
1499
1500 2015-05-29  Filip Pizlo  <fpizlo@apple.com>
1501
1502         FTL codegen for MultiGetByOffset and MultiPutByOffset where the structure set is already proved should have an unreachable default case instead of an exit
1503         https://bugs.webkit.org/show_bug.cgi?id=145469
1504
1505         Reviewed by Geoffrey Garen.
1506         
1507         Omitting the speculation on the fail path when the speculation is guaranteed not to be
1508         taken hints to LLVM that the default case is impossible. This enables some useful
1509         optimizations.
1510
1511         * ftl/FTLLowerDFGToLLVM.cpp:
1512         (JSC::FTL::LowerDFGToLLVM::compileMultiGetByOffset):
1513         (JSC::FTL::LowerDFGToLLVM::compileMultiPutByOffset):
1514
1515 2015-05-29  Mark Lam  <mark.lam@apple.com>
1516
1517         Refactoring HandlerInfo and UnlinkedHandlerInfo.
1518         https://bugs.webkit.org/show_bug.cgi?id=145480
1519
1520         Reviewed by Benjamin Poulain.
1521
1522         HandlerInfo and UnlinkedHandlerInfo have common parts, but are not currently
1523         expressed as 2 unrelated structs that happen to have near identical fields.
1524         We can refactor them to better express their relationship.  We can also add
1525         some convenience functions to make the code that uses them a little more
1526         readable.
1527
1528         * bytecode/CodeBlock.cpp:
1529         (JSC::CodeBlock::dumpBytecode):
1530         (JSC::CodeBlock::CodeBlock):
1531         (JSC::CodeBlock::handlerForBytecodeOffset):
1532         * bytecode/HandlerInfo.h:
1533         (JSC::UnlinkedHandlerInfo::UnlinkedHandlerInfo):
1534         (JSC::HandlerInfo::initialize):
1535         - I chose to include CodeLocationLabel arg even though it is unused by
1536           by non-JIT builds.  This makes the call site cleaner to read.
1537
1538         * bytecode/UnlinkedCodeBlock.h:
1539         (JSC::UnlinkedSimpleJumpTable::add):
1540         (JSC::UnlinkedInstruction::UnlinkedInstruction):
1541         (JSC::UnlinkedCodeBlock::numberOfExceptionHandlers):
1542         (JSC::UnlinkedCodeBlock::addExceptionHandler):
1543         (JSC::UnlinkedCodeBlock::exceptionHandler):
1544         (JSC::UnlinkedCodeBlock::symbolTable):
1545         * bytecompiler/BytecodeGenerator.cpp:
1546         (JSC::BytecodeGenerator::generate):
1547
1548 2015-05-28  Filip Pizlo  <fpizlo@apple.com>
1549
1550         Non-speculative Branch should be fast in the FTL
1551         https://bugs.webkit.org/show_bug.cgi?id=145452
1552
1553         Reviewed by Andreas Kling.
1554         
1555         Inlines the code for convertJSValueToBoolean into the FTL. This also includes some other
1556         clean-ups that I found along the way.
1557         
1558         I found this by looking at the hottest functions in DeltaBlue. Despite having so many
1559         Branch specializations, apparently there was still a hot one that we missed that was going
1560         down the untyped path. It was either Int32 or Other. Maybe we could specialize for that
1561         combo, but it makes so much sense to just make all of this nonsense fast.
1562
1563         * dfg/DFGWatchpointCollectionPhase.cpp:
1564         (JSC::DFG::WatchpointCollectionPhase::handle): Need to watch the masquerades watchpoint on UntypedUse: forms of Branch now.
1565         * ftl/FTLLowerDFGToLLVM.cpp:
1566         (JSC::FTL::LowerDFGToLLVM::boolify): The actual fix.
1567         (JSC::FTL::LowerDFGToLLVM::int52ToStrictInt52):
1568         (JSC::FTL::LowerDFGToLLVM::isInt32):
1569         (JSC::FTL::LowerDFGToLLVM::isNotInt32):
1570         (JSC::FTL::LowerDFGToLLVM::unboxInt32):
1571         * runtime/JSCellInlines.h:
1572         (JSC::JSCell::toBoolean): Symbol is always true.
1573         (JSC::JSCell::pureToBoolean): Symbol is always true.
1574         * runtime/JSString.cpp:
1575         (JSC::JSString::getPrimitiveNumber):
1576         (JSC::JSString::toNumber):
1577         (JSC::JSString::toBoolean): Deleted. This is a tiny method. It doesn't need to be out-of-line.
1578         * runtime/JSString.h:
1579         (JSC::JSString::length):
1580         (JSC::JSString::toBoolean): This method shouldbe inline.
1581         * runtime/Symbol.cpp:
1582         (JSC::Symbol::toPrimitive):
1583         (JSC::Symbol::getPrimitiveNumber):
1584         (JSC::Symbol::toBoolean): Deleted. A Symbol is always true, so we don't need a method for this.
1585         * runtime/Symbol.h:
1586
1587 2015-05-29  Commit Queue  <commit-queue@webkit.org>
1588
1589         Unreviewed, rolling out r184860.
1590         https://bugs.webkit.org/show_bug.cgi?id=145456
1591
1592         May have caused ~1% Octane regression (Requested by kling on
1593         #webkit).
1594
1595         Reverted changeset:
1596
1597         "Try to use StringView when comparing JSStrings for equality."
1598         https://bugs.webkit.org/show_bug.cgi?id=145379
1599         http://trac.webkit.org/changeset/184860
1600
1601 2015-05-28  Michael Saboff  <msaboff@apple.com>
1602
1603         mozilla/js1_5/Array/regress-154338.js test causes ARM 32 bit iOS devices to run out of memory
1604         https://bugs.webkit.org/show_bug.cgi?id=145444
1605
1606         Reviewed by Geoffrey Garen.
1607
1608         Disabled mozilla/js1_5/Array/regress-154338.js when run on iOS ARM 32 bit devices and
1609         the --memory-limited option is passed to run-jsc-stress-tests.
1610
1611         * tests/mozilla/mozilla-tests.yaml:
1612
1613 2015-05-28  Benjamin Poulain  <benjamin@webkit.org>
1614
1615         [iOS8][ARMv7(s)] Optimized Object.create in 'use strict' context sometimes breaks.
1616         https://bugs.webkit.org/show_bug.cgi?id=138038
1617
1618         Reviewed by Michael Saboff.
1619
1620         TL;DR: sometimes the baseline JIT could accidentally nuke the tag before calling
1621                to C++, making put_by_id behave erratically.
1622
1623         The bug was that put_by_id would randomly not work correctly in 32bits. It happened
1624         in the baseline JIT if we were unlucky enough:
1625         -The code get hot enough and the structure is stable so we get a fast path for
1626          put_by_id.
1627         -We repatch the fast-path branch with a stub generated by
1628          emitPutTransitionStubAndGetOldStructure().
1629         -In emitPutTransitionStubAndGetOldStructure(), we only preserve the payload of the base
1630          register, the tag register is ignored.
1631         -emitPutTransitionStubAndGetOldStructure() allocate 2 to 3 registers. Any of those
1632          could be the one used for the base's tag before the fast path and the value is trashed.
1633         -If we hit one of the failure case, we fallback to the slow path, but we destroyed
1634          the tag pointer.
1635         -We now have unrelated bits in the tag, the most likely value type is now "double"
1636          and we fail the put_by_id because we try to set a property on a number.
1637
1638         The most obvious solution would be to change emitPutTransitionStubAndGetOldStructure()
1639         to preserve the tag register in addition to the value register.
1640         I decided against that option because of the added complexity. The DFG does not need
1641         that case, so I would have to add branches everywhere to distinguish the cases
1642         were we need to preserve the tag or not.
1643
1644         Instead, I just load the tag back from memory in the slow path. The function in the slow
1645         path is several order of magnitude slower than a load, it is not worth eliminating it,
1646         especially in baseline JIT.
1647
1648         I also discovered 4 useless loads in the fast path, so even with my extra load, this patch
1649         makes the baseline faster :)
1650
1651         * jit/JITPropertyAccess32_64.cpp:
1652         (JSC::JIT::emitSlow_op_put_by_id):
1653         (JSC::JIT::emit_op_put_by_id): Deleted.
1654         * tests/stress/put-by-id-on-new-object-after-prototype-transition-non-strict.js: Added.
1655         (opaqueNewObject):
1656         (putValueOnNewObject):
1657         * tests/stress/put-by-id-on-new-object-after-prototype-transition-strict.js: Added.
1658         (string_appeared_here.opaqueNewObject):
1659         (putValueOnNewObject):
1660
1661 2015-05-28  Benjamin Poulain  <benjamin@webkit.org>
1662
1663         [JSC] reduction the iteration count of the DoubleRep stress tests
1664
1665         Once again, I used big numbers for manual testing and I forgot to fix them before landing.
1666
1667         * tests/stress/double-rep-with-non-cell.js:
1668         * tests/stress/double-rep-with-null.js:
1669         * tests/stress/double-rep-with-undefined.js:
1670
1671 2015-05-28  Basile Clement  <basile_clement@apple.com>
1672
1673         Add debug mode assertions for accessors casting JSC::DFG::Node.m_opInfo
1674         https://bugs.webkit.org/show_bug.cgi?id=145441
1675
1676         Reviewed by Filip Pizlo.
1677
1678         Most accessor functions casting m_opInfo in JSC::DFG::Node are
1679         performing debug checks that they are only accessed for node types that
1680         should have them. This patch adds similar checks for the accessors that
1681         were missing them.
1682
1683         * dfg/DFGNode.h:
1684         (JSC::DFG::Node::watchpointSet):
1685         (JSC::DFG::Node::storagePointer):
1686         (JSC::DFG::Node::multiGetByOffsetData):
1687         (JSC::DFG::Node::multiPutByOffsetData):
1688         (JSC::DFG::Node::hasTypeLocation):
1689         (JSC::DFG::Node::typeLocation):
1690         (JSC::DFG::Node::hasBasicBlockLocation):
1691         (JSC::DFG::Node::basicBlockLocation):
1692
1693 2015-05-28  Matt Rajca  <mrajca@apple.com>
1694
1695         Add ENABLE_MEDIA_SESSION feature flag (which is off by default).
1696         https://bugs.webkit.org/show_bug.cgi?id=145415
1697
1698         Reviewed by Eric Carlson.
1699
1700         * Configurations/FeatureDefines.xcconfig:
1701
1702 2015-05-27  Jordan Harband  <ljharb@gmail.com>
1703
1704         Array.of should work with other constructors
1705         https://bugs.webkit.org/show_bug.cgi?id=145365
1706         Per https://people.mozilla.org/~jorendorff/es6-draft.html#sec-array.of
1707         step 4
1708
1709         Reviewed by Yusuke Suzuki.
1710
1711         * builtins/ArrayConstructor.js:
1712         (of):
1713         * runtime/ArrayConstructor.cpp:
1714         (JSC::arrayConstructorOf): Deleted.
1715
1716 2015-05-27  Benjamin Poulain  <bpoulain@apple.com>
1717
1718         [JSC] Add undefined->double conversion to DoubleRep
1719         https://bugs.webkit.org/show_bug.cgi?id=145293
1720
1721         Reviewed by Filip Pizlo.
1722
1723         This patch adds undefined to double conversion to the DoubleRep
1724         node for the cases were we speculate "undefined" as part of the types
1725         processed.
1726
1727         The use case is doing math with accidental out-of-bounds access. For example,
1728         something like:
1729             for (var i = 0; i <= length; ++i)
1730                 ouptput += array[i];
1731
1732         would cause us to OSR exit every time i === length.
1733
1734         When hitting one of those cases, we would already speculate double math,
1735         but the DoubleRep node was unable to convert the undefined and would exit.
1736
1737         With this patch the use kind NotCellUse cover this conversion for DoubleRep.
1738         I have been quite conservative so in general we will not find "undefined"
1739         until a few recompile but being optimistic seems better since this is a corner case.
1740
1741         This patch is a 80% progression on WebXPRT's DNA Sequencing test.
1742
1743         * dfg/DFGAbstractInterpreterInlines.h:
1744         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
1745         * dfg/DFGFixupPhase.cpp:
1746         (JSC::DFG::FixupPhase::injectTypeConversionsForEdge):
1747         * dfg/DFGNode.h:
1748         (JSC::DFG::Node::sawUndefined):
1749         * dfg/DFGPredictionPropagationPhase.cpp:
1750         (JSC::DFG::PredictionPropagationPhase::propagate):
1751         * dfg/DFGSafeToExecute.h:
1752         (JSC::DFG::SafeToExecuteEdge::operator()):
1753         * dfg/DFGSpeculativeJIT.cpp:
1754         (JSC::DFG::SpeculativeJIT::compileDoubleRep):
1755         * dfg/DFGUseKind.cpp:
1756         (WTF::printInternal):
1757         * dfg/DFGUseKind.h:
1758         (JSC::DFG::typeFilterFor):
1759         * ftl/FTLCapabilities.cpp:
1760         (JSC::FTL::canCompile):
1761         * ftl/FTLLowerDFGToLLVM.cpp:
1762         (JSC::FTL::LowerDFGToLLVM::compileDoubleRep):
1763         (JSC::FTL::LowerDFGToLLVM::jsValueToDouble):
1764         * tests/stress/double-rep-with-undefined.js: Added.
1765         (addArgsNumberAndUndefined):
1766         (addArgsInt32AndUndefined):
1767         (testFallbackWithDouble):
1768         (addArgsDoubleAndUndefined):
1769         (testFallbackWithObject.):
1770         (testFallbackWithObject):
1771         (addArgsOnlyUndefined):
1772         (testFallbackWithString):
1773
1774 2015-05-27  Dean Jackson  <dino@apple.com>
1775
1776         img.currentSrc problem in strict mode with old picturefill
1777         https://bugs.webkit.org/show_bug.cgi?id=144095
1778         <rdar://problem/21087013>
1779
1780         Reviewed by Simon Fraser.
1781
1782         Add a PICTURE_SIZES flag.
1783
1784         * Configurations/FeatureDefines.xcconfig:
1785
1786 2015-05-27  Basile Clement  <basile_clement@apple.com>
1787
1788         LazyNode comparison can return incorrect results when comparing an empty value
1789         https://bugs.webkit.org/show_bug.cgi?id=145421
1790
1791         Reviewed by Geoffrey Garen.
1792
1793         When comparing a LazyNode to another, we compare the value pointers if
1794         we have one, and otherwise compare the nodes.
1795         We should be comparing value pointers if the other LazyNode has one as
1796         well, otherwise we risk an incoherency when we are a empty LazyNode
1797         being compared to a FrozenValue without node.
1798
1799         Note that this is not a problem in any other case because if we don't
1800         have a FrozenValue and we are not an empty LazyNode, we are a
1801         non-constant node, and comparing the node pointers is correct.
1802
1803         * dfg/DFGLazyNode.h:
1804         (JSC::DFG::LazyNode::operator==):
1805
1806 2015-05-27  Geoffrey Garen  <ggaren@apple.com>
1807
1808         REGRESSION: These sorting idioms used by Peacekeeper and Browsermark are ~20X slower
1809         https://bugs.webkit.org/show_bug.cgi?id=145412
1810
1811         Reviewed by Benjamin Poulain.
1812
1813         Cache strings when doing a string-converting sort.
1814
1815         This is a 21% speedup.
1816
1817         * builtins/Array.prototype.js:
1818         (sort.stringComparator): Use subtraction instead of branching because
1819         it's slightly faster.
1820
1821         (sort.comparatorSort):
1822         (sort.stringSort):
1823         (sort): Add a special case for string sorting to avoid redundant string
1824         conversion.
1825
1826         * parser/Parser.cpp:
1827         (JSC::Parser<LexerType>::createBindingPattern): Names can be empty if
1828         they are private names.
1829
1830 2015-05-26  Filip Pizlo  <fpizlo@apple.com>
1831
1832         JIT-generated store barrier code should assume the buffer pointer and capacity to be compile-time constants
1833         https://bugs.webkit.org/show_bug.cgi?id=145404
1834
1835         Reviewed by Andreas Kling.
1836         
1837         We never change the capacity of a write barrier buffer. We never repoint the buffer
1838         pointer. So, the JIT shouldn't load those from memory; it should take advantage of the
1839         fact that these are compile-time constants.
1840
1841         * dfg/DFGSpeculativeJIT.cpp:
1842         (JSC::DFG::SpeculativeJIT::storeToWriteBarrierBuffer):
1843         * ftl/FTLLowerDFGToLLVM.cpp:
1844         (JSC::FTL::LowerDFGToLLVM::emitStoreBarrier):
1845         * heap/WriteBarrierBuffer.h:
1846         (JSC::WriteBarrierBuffer::currentIndexAddress):
1847         (JSC::WriteBarrierBuffer::capacity):
1848         (JSC::WriteBarrierBuffer::buffer):
1849         (JSC::WriteBarrierBuffer::currentIndexOffset): Deleted.
1850         (JSC::WriteBarrierBuffer::capacityOffset): Deleted.
1851         (JSC::WriteBarrierBuffer::bufferOffset): Deleted.
1852         * jit/Repatch.cpp:
1853         (JSC::emitPutTransitionStubAndGetOldStructure):
1854
1855 2015-05-27  Geoffrey Garen  <ggaren@apple.com>
1856
1857         REGRESSION: These sorting idioms used by Peacekeeper and Browsermark are ~20X slower
1858         https://bugs.webkit.org/show_bug.cgi?id=145412
1859
1860         Reviewed by Darin Adler.
1861
1862         Use @toString instead of the String constructor because calls to the
1863         String constructor are never optimized. (See
1864         https://bugs.webkit.org/show_bug.cgi?id=144458.)
1865
1866         This is a ~2X speedup.
1867
1868         * builtins/Array.prototype.js:
1869         (sort.stringComparator):
1870
1871 2015-05-27  Dan Bernstein  <mitz@apple.com>
1872
1873         Remove JSC_OBJC_API_AVAILABLE_MAC_OS_X_1080
1874         https://bugs.webkit.org/show_bug.cgi?id=145403
1875
1876         Reviewed by Anders Carlsson.
1877
1878         JSC_OBJC_API_AVAILABLE_MAC_OS_X_1080 was used to enable the JavaScriptCore Objective-C API
1879         for WebKit and Safari projects building with JavaScriptCore targeting OS X 10.8. We don’t
1880         need it anymore.
1881
1882         * API/JSBase.h:
1883         * API/JSContext.h:
1884         * API/JSManagedValue.h:
1885         * API/JSValue.h:
1886         * API/JSVirtualMachine.h:
1887         * Configurations/Base.xcconfig:
1888         * postprocess-headers.sh:
1889
1890 2015-05-26  Geoffrey Garen  <ggaren@apple.com>
1891
1892         Photo Booth hangs under JSC::MachineThreads::tryCopyOtherThreadStacks
1893         https://bugs.webkit.org/show_bug.cgi?id=145395
1894
1895         Reviewed by Mark Hahnenberg.
1896
1897         No test case because we already have --threaded mode, which runs lots of
1898         parallel GC, but it (and the original in-app test case) can't reproduce
1899         this bug.
1900
1901         * heap/MachineStackMarker.cpp:
1902         (JSC::MachineThreads::tryCopyOtherThreadStacks): Use a lock to prevent
1903         two threads from mutually suspending each other.
1904
1905 2015-05-26  Yusuke Suzuki  <utatane.tea@gmail.com>
1906
1907         Add Array.prototype.copyWithin to JSC features.json
1908         https://bugs.webkit.org/show_bug.cgi?id=145387
1909
1910         Reviewed by Darin Adler.
1911
1912         * features.json:
1913
1914 2015-05-26  Yusuke Suzuki  <utatane.tea@gmail.com>
1915
1916         Reflect nits for r184863
1917         https://bugs.webkit.org/show_bug.cgi?id=145107
1918
1919         Reviewed by Darin Adler.
1920
1921         1. Added the copyright line.
1922         2. Added an optional argument (/*, end */). To do so, fixed generate-js-builtins.
1923         3. Dropped the unnecessary variable `thisValue`.
1924         4. Fix the type error messages. This is also found in StringIterator.prototype.js.
1925         5. Added tests for 0 arguments.
1926
1927         * builtins/Array.prototype.js:
1928         (copyWithin):
1929         * builtins/StringIterator.prototype.js:
1930         (next):
1931         * generate-js-builtins:
1932         * tests/stress/array-copywithin.js:
1933         * tests/stress/string-iterators.js:
1934
1935 2015-05-26  Yusuke Suzuki  <utatane.tea@gmail.com>
1936
1937         Inline @Array / @Object callsites
1938         https://bugs.webkit.org/show_bug.cgi?id=145382
1939
1940         Reviewed by Geoffrey Garen.
1941
1942         As the same to Array/Object callsite inlining, @Array/@Object also
1943         should be inlined in bytecode level.
1944         While `new @Object` style is not encouraged in the builtins,
1945         `@Array(len)` is already used at least in Array.from code.
1946
1947         * bytecompiler/BytecodeGenerator.cpp:
1948         (JSC::BytecodeGenerator::expectedFunctionForIdentifier):
1949
1950 2015-05-26  Andreas Kling  <akling@apple.com>
1951
1952         String.prototype.charCodeAt() should use StringView.
1953         <https://webkit.org/b/145353>
1954
1955         Reviewed by Darin Adler.
1956
1957         Use JSString::view() in charCodeAt() to avoid reifying the JSString if it's
1958         a substring. This avoids StringImpl allocation in some cases and ref churn
1959         in all cases.
1960
1961         * runtime/StringPrototype.cpp:
1962         (JSC::stringProtoFuncCharCodeAt):
1963
1964 2015-05-26  Andreas Kling  <akling@apple.com>
1965
1966         String.prototype.charAt() should use StringView.
1967         <https://webkit.org/b/145352>
1968
1969         Reviewed by Darin Adler.
1970
1971         Remove the jsSingleCharacterSubstring() function since it's actually completely
1972         counter-productive: it could create a single-character string that would retain
1973         a much larger string for the duration of its lifetime.
1974
1975         This made sense before StringImpl learned to put its characters at the tail end
1976         of its own allocation. Now that it does, it's far better to just create a new
1977         single-character StringImpl.
1978
1979         With that out of the way, we can make String.prototype.charAt() use StringView
1980         to avoid reifying substring JSStrings (and avoid some ref churn too.)
1981
1982         * runtime/JSString.cpp:
1983         (JSC::JSRopeString::getIndexSlowCase):
1984         * runtime/JSString.h:
1985         (JSC::JSString::getIndex):
1986         (JSC::jsSingleCharacterSubstring): Deleted.
1987         * runtime/StringPrototype.cpp:
1988         (JSC::stringProtoFuncCharAt):
1989         (JSC::stringProtoFuncSplit):
1990
1991 2015-05-26  Yusuke Suzuki  <utatane.tea@gmail.com>
1992
1993         [ES6] Implement Array.prototype.copyWithin
1994         https://bugs.webkit.org/show_bug.cgi?id=145107
1995
1996         Reviewed by Darin Adler.
1997
1998         This patch implements ES6 Array.prototype.copyWithin.
1999         It is intended to be used for copying the region to the other region
2000         in the callee array itself safely (like memmove, not memcpy).
2001         This function is proposed in the context of WebGL.
2002
2003         * builtins/Array.prototype.js:
2004         (.maxWithPositives):
2005         (.minWithMaybeNegativeZeroAndPositive):
2006         (copyWithin):
2007         * runtime/ArrayPrototype.cpp:
2008         (JSC::ArrayPrototype::finishCreation):
2009         * tests/stress/array-copywithin.js: Added.
2010         (shouldBe):
2011         (shouldBeArray):
2012         (shouldThrow):
2013         (arrayToObject):
2014         (valueOf):
2015
2016 2015-05-26  Dan Bernstein  <mitz@apple.com>
2017
2018         <rdar://problem/21104551> Update build settings
2019
2020         Reviewed by Anders Carlsson.
2021
2022         * Configurations/DebugRelease.xcconfig:
2023         * Configurations/FeatureDefines.xcconfig:
2024         * Configurations/Version.xcconfig:
2025
2026 2015-05-26  Andreas Kling  <akling@apple.com>
2027
2028         Try to use StringView when comparing JSStrings for equality.
2029         <https://webkit.org/b/145379>
2030
2031         Reviewed by Darin Adler.
2032
2033         Use JSString::view() when sending two JSStrings to WTF::equal()
2034         for comparison. This avoids creating new objects in the case where
2035         the strings are actually substrings.
2036
2037         * jit/JITOperations.cpp:
2038         * runtime/JSCJSValueInlines.h:
2039         (JSC::JSValue::equalSlowCaseInline):
2040         (JSC::JSValue::strictEqualSlowCaseInline):
2041
2042 2015-05-26  Yusuke Suzuki  <utatane.tea@gmail.com>
2043
2044         [JSC] Generate put_by_val_direct for indexed identifiers instead of put_by_id with direct postfix
2045         https://bugs.webkit.org/show_bug.cgi?id=145360
2046
2047         Reviewed by Darin Adler.
2048
2049         JSObject::putDirect only accepts non-indexed properties.
2050         So when generating put_by_id (with direct postfix) for indexed property,
2051         we should generate put_by_val_direct instead.
2052
2053         * bytecompiler/BytecodeGenerator.cpp:
2054         (JSC::BytecodeGenerator::emitDirectPutById):
2055         * bytecompiler/NodesCodegen.cpp:
2056         (JSC::PropertyListNode::emitPutConstantProperty):
2057         * tests/stress/put-by-id-direct-should-be-done-for-non-index-property.js: Added.
2058
2059 2015-05-24  Jordan Harband  <ljharb@gmail.com>
2060
2061         Array#findIndex/find should not skip holes
2062         https://bugs.webkit.org/show_bug.cgi?id=145361
2063         per https://people.mozilla.org/~jorendorff/es6-draft.html#sec-array.prototype.findindex
2064         and https://people.mozilla.org/~jorendorff/es6-draft.html#sec-array.prototype.find
2065
2066         Reviewed by Yusuke Suzuki.
2067
2068         * builtins/Array.prototype.js:
2069         (find): Deleted.
2070         (findIndex): Deleted.
2071
2072 2015-05-24  Brian J. Burg  <burg@cs.washington.edu>
2073
2074         Web Inspector: Uncaught exception when using Inspect tool on SVG elements
2075         https://bugs.webkit.org/show_bug.cgi?id=145363
2076
2077         Reviewed by Joseph Pecoraro.
2078
2079         The injected script failed by chaining a call to String.prototype.trim to the result of
2080         SVG*Element.className, which is an SVGAnimatedString and lacks useful methods. So, obtain
2081         the class name using Node.getAttribute, which always returns a DOMString.
2082
2083         * inspector/InjectedScriptSource.js:
2084         (InjectedScriptSource.prototype._getDescription): use getAttribute instead of className.
2085
2086 2015-05-23  Dan Bernstein  <mitz@apple.com>
2087
2088         Remove unused definitions of WEBKIT_VERSION_MIN_REQUIRED
2089         https://bugs.webkit.org/show_bug.cgi?id=145345
2090
2091         Reviewed by Sam Weinig.
2092
2093         * Configurations/Base.xcconfig: Also changed to use $(inherited).
2094
2095 2015-05-23  Yusuke Suzuki  <utatane.tea@gmail.com>
2096
2097         Introduce UniquedStringImpl and SymbolImpl to separate symbolic strings from AtomicStringImpl
2098         https://bugs.webkit.org/show_bug.cgi?id=144848
2099
2100         Reviewed by Darin Adler.
2101
2102         Use UniquedStringImpl, SymbolImpl and AtomicStringImpl.
2103
2104         * API/JSCallbackObject.h:
2105         * builtins/BuiltinNames.h:
2106         (JSC::BuiltinNames::isPrivateName):
2107         * bytecode/BytecodeIntrinsicRegistry.h:
2108         * bytecode/CodeBlock.cpp:
2109         (JSC::CodeBlock::CodeBlock):
2110         * bytecode/ComplexGetStatus.cpp:
2111         (JSC::ComplexGetStatus::computeFor):
2112         * bytecode/ComplexGetStatus.h:
2113         * bytecode/GetByIdStatus.cpp:
2114         (JSC::GetByIdStatus::computeFromLLInt):
2115         (JSC::GetByIdStatus::computeFor):
2116         (JSC::GetByIdStatus::computeForStubInfo):
2117         * bytecode/GetByIdStatus.h:
2118         * bytecode/Instruction.h:
2119         (JSC::Instruction::Instruction):
2120         * bytecode/PutByIdStatus.cpp:
2121         (JSC::PutByIdStatus::computeFromLLInt):
2122         (JSC::PutByIdStatus::computeFor):
2123         (JSC::PutByIdStatus::computeForStubInfo):
2124         * bytecode/PutByIdStatus.h:
2125         * bytecompiler/BytecodeGenerator.cpp:
2126         (JSC::BytecodeGenerator::BytecodeGenerator):
2127         (JSC::BytecodeGenerator::visibleNameForParameter):
2128         (JSC::BytecodeGenerator::hasConstant):
2129         (JSC::BytecodeGenerator::addConstant):
2130         * bytecompiler/BytecodeGenerator.h:
2131         * bytecompiler/NodesCodegen.cpp:
2132         (JSC::PropertyListNode::emitBytecode):
2133         * dfg/DFGByteCodeParser.cpp:
2134         (JSC::DFG::ByteCodeParser::parseBlock):
2135         (JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
2136         * dfg/DFGDesiredIdentifiers.cpp:
2137         (JSC::DFG::DesiredIdentifiers::addLazily):
2138         (JSC::DFG::DesiredIdentifiers::at):
2139         (JSC::DFG::DesiredIdentifiers::reallyAdd):
2140         * dfg/DFGDesiredIdentifiers.h:
2141         (JSC::DFG::DesiredIdentifiers::operator[]):
2142         * dfg/DFGFixupPhase.cpp:
2143         (JSC::DFG::FixupPhase::fixupNode):
2144         (JSC::DFG::FixupPhase::isStringPrototypeMethodSane):
2145         * dfg/DFGSpeculativeJIT.cpp:
2146         (JSC::DFG::SpeculativeJIT::compileIn):
2147         * dfg/DFGSpeculativeJIT.h:
2148         (JSC::DFG::SpeculativeJIT::identifierUID):
2149         (JSC::DFG::SpeculativeJIT::callOperation):
2150         * ftl/FTLCompile.cpp:
2151         (JSC::FTL::mmAllocateDataSection):
2152         * ftl/FTLInlineCacheDescriptor.h:
2153         (JSC::FTL::InlineCacheDescriptor::InlineCacheDescriptor):
2154         (JSC::FTL::InlineCacheDescriptor::uid):
2155         (JSC::FTL::GetByIdDescriptor::GetByIdDescriptor):
2156         (JSC::FTL::PutByIdDescriptor::PutByIdDescriptor):
2157         (JSC::FTL::CheckInDescriptor::CheckInDescriptor):
2158         * ftl/FTLIntrinsicRepository.h:
2159         * ftl/FTLLowerDFGToLLVM.cpp:
2160         (JSC::FTL::LowerDFGToLLVM::compilePutById):
2161         (JSC::FTL::LowerDFGToLLVM::compileIn):
2162         (JSC::FTL::LowerDFGToLLVM::compileMaterializeCreateActivation):
2163         (JSC::FTL::LowerDFGToLLVM::getById):
2164         * ftl/FTLOperations.cpp:
2165         (JSC::FTL::operationMaterializeObjectInOSR):
2166         * ftl/FTLSlowPathCall.cpp:
2167         (JSC::FTL::callOperation):
2168         * ftl/FTLSlowPathCall.h:
2169         * jit/JIT.h:
2170         * jit/JITInlines.h:
2171         (JSC::JIT::callOperation):
2172         * jit/JITOperations.cpp:
2173         * jit/JITOperations.h:
2174         * parser/Nodes.cpp:
2175         (JSC::ProgramNode::setClosedVariables):
2176         * parser/Nodes.h:
2177         (JSC::ScopeNode::captures):
2178         (JSC::ScopeNode::setClosedVariables):
2179         (JSC::ProgramNode::closedVariables):
2180         * parser/Parser.cpp:
2181         (JSC::Parser<LexerType>::parseInner):
2182         (JSC::Parser<LexerType>::didFinishParsing):
2183         (JSC::Parser<LexerType>::parseContinueStatement):
2184         * parser/Parser.h:
2185         (JSC::Scope::Scope):
2186         (JSC::Scope::pushLabel):
2187         (JSC::Scope::getLabel):
2188         (JSC::Scope::declareCallee):
2189         (JSC::Scope::declareVariable):
2190         (JSC::Scope::declareParameter):
2191         (JSC::Scope::declareBoundParameter):
2192         (JSC::Scope::useVariable):
2193         (JSC::Scope::copyCapturedVariablesToVector):
2194         (JSC::Parser::closedVariables):
2195         (JSC::ScopeLabelInfo::ScopeLabelInfo): Deleted.
2196         * parser/SourceProviderCacheItem.h:
2197         (JSC::SourceProviderCacheItem::usedVariables):
2198         (JSC::SourceProviderCacheItem::writtenVariables):
2199         (JSC::SourceProviderCacheItem::create):
2200         * runtime/CommonIdentifiers.cpp:
2201         (JSC::CommonIdentifiers::isPrivateName):
2202         * runtime/CommonIdentifiers.h:
2203         * runtime/Identifier.h:
2204         (JSC::Identifier::impl):
2205         (JSC::Identifier::Identifier):
2206         (JSC::parseIndex):
2207         (JSC::IdentifierRepHash::hash):
2208         * runtime/IdentifierInlines.h:
2209         (JSC::Identifier::fromUid):
2210         * runtime/IntendedStructureChain.cpp:
2211         (JSC::IntendedStructureChain::mayInterceptStoreTo):
2212         * runtime/IntendedStructureChain.h:
2213         * runtime/JSGlobalObject.cpp:
2214         (JSC::JSGlobalObject::init):
2215         * runtime/Lookup.h:
2216         (JSC::HashTable::entry):
2217         * runtime/MapData.h:
2218         * runtime/ObjectConstructor.cpp:
2219         (JSC::objectConstructorGetOwnPropertySymbols):
2220         * runtime/PrivateName.h:
2221         (JSC::PrivateName::PrivateName):
2222         (JSC::PrivateName::uid):
2223         * runtime/PropertyMapHashTable.h:
2224         * runtime/PropertyName.h:
2225         (JSC::PropertyName::PropertyName):
2226         (JSC::PropertyName::uid):
2227         (JSC::PropertyName::publicName):
2228         (JSC::parseIndex):
2229         * runtime/PropertyNameArray.h:
2230         (JSC::PropertyNameArray::addKnownUnique):
2231         (JSC::PropertyNameArray::add):
2232         * runtime/Structure.cpp:
2233         (JSC::StructureTransitionTable::contains):
2234         (JSC::StructureTransitionTable::get):
2235         (JSC::StructureTransitionTable::add):
2236         (JSC::Structure::addPropertyTransitionToExistingStructureImpl):
2237         (JSC::Structure::addPropertyTransitionToExistingStructureConcurrently):
2238         (JSC::Structure::getConcurrently):
2239         (JSC::Structure::add):
2240         (JSC::Structure::remove):
2241         (JSC::Structure::toStructureShape):
2242         * runtime/Structure.h:
2243         (JSC::PropertyMapEntry::PropertyMapEntry):
2244         * runtime/StructureInlines.h:
2245         (JSC::Structure::getConcurrently):
2246         * runtime/StructureTransitionTable.h:
2247         (JSC::StructureTransitionTable::Hash::hash):
2248         * runtime/Symbol.cpp:
2249         (JSC::Symbol::Symbol):
2250         * runtime/Symbol.h:
2251         * runtime/SymbolConstructor.cpp:
2252         (JSC::symbolConstructorFor):
2253         (JSC::symbolConstructorKeyFor):
2254         * runtime/SymbolTable.cpp:
2255         (JSC::SymbolTable::uniqueIDForVariable):
2256         (JSC::SymbolTable::globalTypeSetForVariable):
2257         * runtime/SymbolTable.h:
2258         * runtime/TypeSet.cpp:
2259         (JSC::StructureShape::addProperty):
2260         (JSC::StructureShape::propertyHash):
2261         * runtime/TypeSet.h:
2262
2263 2015-05-21  Filip Pizlo  <fpizlo@apple.com>
2264
2265         Arguments elimination phase mishandles arity check failure in its reduction of LoadVarargs to GetStack/PutStacks
2266         https://bugs.webkit.org/show_bug.cgi?id=145298
2267
2268         Reviewed by Geoffrey Garen.
2269
2270         * dfg/DFGArgumentsEliminationPhase.cpp: Fix the bug. I restructured the loop to make it more obvious that we're initializing everything that we're supposed to initialize.
2271         * dfg/DFGNode.h: Add a comment to clarify something I was confused about while writing this code.
2272         * dfg/DFGPutStackSinkingPhase.cpp: Hacking on PutStacks made me think deep thoughts, and I added some FIXMEs.
2273         * tests/stress/fold-load-varargs-arity-check-fail-barely.js: Added. This test crashes or fails before this patch.
2274         * tests/stress/fold-load-varargs-arity-check-fail.js: Added. This is even more sure to crash or fail.
2275         * tests/stress/simplify-varargs-mandatory-minimum-smaller-than-limit.js: Added. Not sure if we had coverage for this case before.
2276
2277 2015-05-22  Basile Clement  <basile_clement@apple.com>
2278
2279         Allow DFGClobberize to return non-node constants that must be later created
2280         https://bugs.webkit.org/show_bug.cgi?id=145272
2281
2282         Reviewed by Filip Pizlo.
2283
2284         This adds a new LazyNode class in DFG that represents either a Node*,
2285         or a FrozenValue* with a way to convert it to a Node* provided a block
2286         to insert it into. DFGClobberize is converted to use LazyNode instead
2287         of Node* when def()'ing values, which allows to now define the array's
2288         length as well as the value of its various fields in NewArray and
2289         NewArrayBuffer nodes.
2290
2291         We also introduce a Vector<uint32_t> in DFG::Graph to collect all the
2292         values that can be used as index, in order to avoid def()'ing too many
2293         values at once for big NewArrayBuffers.
2294
2295         HeapLocation had to be updated to use a LazyNode as its index to be
2296         able to define array values.
2297
2298         * CMakeLists.txt:
2299         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
2300         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
2301         * JavaScriptCore.xcodeproj/project.pbxproj:
2302         * dfg/DFGCSEPhase.cpp:
2303         * dfg/DFGClobberize.h:
2304         (JSC::DFG::clobberize):
2305         (JSC::DFG::DefMethodClobberize::operator()):
2306         * dfg/DFGGraph.cpp:
2307         (JSC::DFG::Graph::freezeFragile):
2308         * dfg/DFGGraph.h:
2309         * dfg/DFGHeapLocation.h:
2310         (JSC::DFG::HeapLocation::HeapLocation):
2311         (JSC::DFG::HeapLocation::index):
2312         (JSC::DFG::HeapLocation::hash):
2313         * dfg/DFGLazyNode.cpp: Added.
2314         (JSC::DFG::LazyNode::dump):
2315         * dfg/DFGLazyNode.h: Added.
2316         (JSC::DFG::LazyNode::LazyNode):
2317         (JSC::DFG::LazyNode::setNode):
2318         (JSC::DFG::LazyNode::isHashTableDeletedValue):
2319         (JSC::DFG::LazyNode::isNode):
2320         (JSC::DFG::LazyNode::op):
2321         (JSC::DFG::LazyNode::asNode):
2322         (JSC::DFG::LazyNode::asValue):
2323         (JSC::DFG::LazyNode::hash):
2324         (JSC::DFG::LazyNode::operator==):
2325         (JSC::DFG::LazyNode::operator!=):
2326         (JSC::DFG::LazyNode::ensureIsNode):
2327         (JSC::DFG::LazyNode::operator->):
2328         (JSC::DFG::LazyNode::operator*):
2329         (JSC::DFG::LazyNode::operator!):
2330         (JSC::DFG::LazyNode::operator UnspecifiedBoolType*):
2331         (JSC::DFG::LazyNode::setFrozenValue):
2332         * dfg/DFGPreciseLocalClobberize.h:
2333         (JSC::DFG::PreciseLocalClobberizeAdaptor::def):
2334         * dfg/DFGPutStackSinkingPhase.cpp:
2335
2336 2015-05-22  Andreas Kling  <akling@apple.com>
2337
2338         [JSC] Speed up new array construction in Array.prototype.splice().
2339         <https://webkit.org/b/145303>
2340
2341         Reviewed by Benjamin Poulain.
2342
2343         Give splice() a fast path just like slice(), for indexing types where the backing
2344         store can be memcpy'd. I generalized JSArray::fastSlice() a little bit so it works
2345         for this optimization as well.
2346
2347         7% progression on Kraken/stanford-crypto-pbkdf2.
2348
2349         * runtime/JSArray.h:
2350         * runtime/JSArray.cpp:
2351         (JSC::JSArray::fastSlice): Tweak this to return JSArray*, and don't bother throwing
2352         out-of-memory exceptions. Let the caller worry about that.
2353
2354         * runtime/ArrayPrototype.cpp:
2355         (JSC::arrayProtoFuncSlice): Update for fastSlice() changes.
2356         (JSC::arrayProtoFuncSplice): If the object we're splicing out of is a bona fide
2357         JSArray, use fastSlice() to create the returned array instead of doing a generic
2358         get/put loop.
2359
2360 2015-05-21  Filip Pizlo  <fpizlo@apple.com>
2361
2362         CPS rethreading should really get rid of GetLocals
2363         https://bugs.webkit.org/show_bug.cgi?id=145290
2364
2365         Reviewed by Benjamin Poulain.
2366         
2367         CPS rethreading is intended to get rid of redundant GetLocals. CSE can also do it, but
2368         the idea is that you should be able to disable CSE and everything would still work. This
2369         fixes a bug in CPS rethreading's GetLocal elimination: we should be calling replaceWith
2370         rather than setReplacement, since setReplacement still leaves the original node.
2371
2372         * dfg/DFGCPSRethreadingPhase.cpp:
2373         (JSC::DFG::CPSRethreadingPhase::canonicalizeGetLocalFor): Fix the bug.
2374         * dfg/DFGFixupPhase.cpp:
2375         (JSC::DFG::FixupPhase::fixupNode): Eliminating GetLocals means that they turn into Check. We should handle Checks that have zero inputs.
2376         * dfg/DFGValidate.cpp:
2377         (JSC::DFG::Validate::validateCPS): Add a validation for what a GetLocal should look like in ThreadedCPS.
2378         * tests/stress/get-local-elimination.js: Added.
2379         (foo):
2380
2381 2015-05-21  Saam Barati  <saambarati1@gmail.com>
2382
2383         Object allocation sinking phase should explicitly create bottom values for CreateActivation sink candidates and CreateActivation should have SymbolTable as a child node
2384         https://bugs.webkit.org/show_bug.cgi?id=145192
2385
2386         Reviewed by Filip Pizlo.
2387
2388         When we sink CreateActivation and generate MaterializeCreateActivation
2389         in the object allocation sinking phase, we now explictly add PutHints for 
2390         all variables on the activation setting those variables to their default value 
2391         (undefined for Function activations and soon to be JS Empty Value for block scope activations). 
2392         This allows us to remove code that fills FTL fast activation allocations with Undefined.
2393
2394         This patch also adds the constant SymbolTable as an OpInfo of CreateActivation and MaterializeCreateActivation
2395         nodes. This is in preparation for ES6 block scoping which will introduce a new 
2396         op code that gets lowered to CreateActivation.
2397
2398         * dfg/DFGByteCodeParser.cpp:
2399         (JSC::DFG::ByteCodeParser::parseBlock):
2400         * dfg/DFGClobberize.h:
2401         (JSC::DFG::clobberize):
2402         * dfg/DFGNode.h:
2403         (JSC::DFG::Node::hasCellOperand):
2404         (JSC::DFG::Node::cellOperand):
2405         * dfg/DFGObjectAllocationSinkingPhase.cpp:
2406         (JSC::DFG::ObjectAllocationSinkingPhase::lowerNonReadingOperationsOnPhantomAllocations):
2407         (JSC::DFG::ObjectAllocationSinkingPhase::handleNode):
2408         (JSC::DFG::ObjectAllocationSinkingPhase::createMaterialize):
2409         (JSC::DFG::ObjectAllocationSinkingPhase::populateMaterialize):
2410         * dfg/DFGPromotedHeapLocation.cpp:
2411         (WTF::printInternal):
2412         * dfg/DFGPromotedHeapLocation.h:
2413         * dfg/DFGSpeculativeJIT.cpp:
2414         (JSC::DFG::SpeculativeJIT::compileCreateActivation):
2415         * ftl/FTLLowerDFGToLLVM.cpp:
2416         (JSC::FTL::LowerDFGToLLVM::compileCreateActivation):
2417         (JSC::FTL::LowerDFGToLLVM::compileMaterializeCreateActivation):
2418         * ftl/FTLOperations.cpp:
2419         (JSC::FTL::operationMaterializeObjectInOSR):
2420         * tests/stress/activation-sink-default-value.js: Added.
2421         (bar):
2422         * tests/stress/activation-sink-osrexit-default-value.js: Added.
2423         (foo.set result):
2424
2425 2015-05-21  Per Arne Vollan  <peavo@outlook.com>
2426
2427         MSVC internal compiler error when compiling TemplateRegistryKey class.
2428         https://bugs.webkit.org/show_bug.cgi?id=145259
2429
2430         Reviewed by Alex Christensen.
2431
2432         MSVC is not able to handle the brace initialization of a class member in this case.
2433
2434         * runtime/TemplateRegistryKey.h:
2435
2436 2015-05-21  Csaba Osztrogonác  <ossy@webkit.org>
2437
2438         Fix the !ENABLE(ES6_TEMPLATE_LITERAL_SYNTAX) build after r184337
2439         https://bugs.webkit.org/show_bug.cgi?id=145248
2440
2441         Reviewed by Yusuke Suzuki.
2442
2443         * bytecompiler/BytecodeGenerator.cpp:
2444         * bytecompiler/BytecodeGenerator.h:
2445         * parser/Parser.cpp:
2446         (JSC::Parser<LexerType>::parseMemberExpression):
2447
2448 2015-05-20  Joseph Pecoraro  <pecoraro@apple.com>
2449
2450         Web Inspector: array previews should have a much smaller cap on values
2451         https://bugs.webkit.org/show_bug.cgi?id=145195
2452
2453         Reviewed by Timothy Hatcher.
2454
2455         * inspector/InjectedScriptSource.js:
2456         (InjectedScript.RemoteObject.prototype._generatePreview):
2457         Reduce the indexes threshold for previews.
2458
2459 2015-05-20  Joseph Pecoraro  <pecoraro@apple.com>
2460
2461         Web Inspector: Use native Arguments detection instead of using toString
2462         https://bugs.webkit.org/show_bug.cgi?id=145235
2463
2464         Reviewed by Timothy Hatcher.
2465
2466         * inspector/InjectedScriptSource.js:
2467         (InjectedScript.prototype._subtype):
2468         Deleted the old string code.
2469
2470         * inspector/JSInjectedScriptHost.cpp:
2471         (Inspector::JSInjectedScriptHost::subtype):
2472         Replaced with a stricter, more accurate check.
2473
2474 2015-05-20  Andreas Kling  <akling@apple.com>
2475
2476         Remove unused MarkedBlock::m_rememberedSet.
2477         <https://webkit.org/b/145224>
2478
2479         Reviewed by Mark Hahnenberg.
2480
2481         The MarkedBlock had a copy of the remembered bit for each of its cells,
2482         and we were maintaining that bitmap despite no one actually ever consulting it.
2483
2484         This patch removes MarkedBlock::m_rememberedSet, freeing up 128 bytes in each
2485         block and making write barriers a little faster.
2486
2487         * heap/Heap.cpp:
2488         (JSC::Heap::clearRememberedSet):
2489         (JSC::Heap::addToRememberedSet):
2490         * heap/HeapInlines.h:
2491         (JSC::Heap::isRemembered):
2492         * heap/MarkedBlock.cpp:
2493         (JSC::MarkedBlock::clearRememberedSet): Deleted.
2494         (JSC::MarkedBlock::clearMarksWithCollectionType):
2495         * heap/MarkedBlock.h:
2496         (JSC::MarkedBlock::setRemembered): Deleted.
2497         (JSC::MarkedBlock::clearRemembered): Deleted.
2498         (JSC::MarkedBlock::atomicClearRemembered): Deleted.
2499         (JSC::MarkedBlock::isRemembered): Deleted.
2500         * heap/MarkedSpace.h:
2501         (JSC::ClearRememberedSet::operator()): Deleted.
2502         (JSC::MarkedSpace::clearRememberedSet): Deleted.
2503
2504 2015-05-20  Andreas Kling  <akling@apple.com>
2505
2506         Eden collections should extend the IncrementalSweeper work list, not replace it.
2507         <https://webkit.org/b/145213>
2508         <rdar://problem/21002666>
2509
2510         Reviewed by Geoffrey Garen.
2511
2512         After an eden collection, the garbage collector was adding all MarkedBlocks containing
2513         new objects to the IncrementalSweeper's work list, to make sure they didn't have to
2514         wait until the next full collection before getting swept.
2515
2516         Or at least, that's what it thought it was doing. It turns out that IncrementalSweeper's
2517         internal work list is really just a reference to Heap::m_blockSnapshot. I didn't realize
2518         this when writing the post-eden sweep code, and instead made eden collections cancel
2519         all pending sweeps and *replace* them with the list of blocks with new objects.
2520
2521         This made it so that rapidly occurring eden collections could prevent large numbers of
2522         heap blocks from ever getting swept. This would manifest as accumulation of MarkedBlocks
2523         when a system under heavy load was also allocating short lived objects at a high rate.
2524         Things would eventually get cleaned up when there was a lull and a full collection was
2525         allowed to run its heap sweep to completion.
2526
2527         Fix this by moving all management of the block snapshot to Heap. snapshotMarkedSpace()
2528         now handles eden collections by merging the list of blocks with new objects into the
2529         existing block snapshot.
2530
2531         * heap/Heap.cpp:
2532         (JSC::Heap::snapshotMarkedSpace):
2533         (JSC::Heap::notifyIncrementalSweeper):
2534         * heap/IncrementalSweeper.cpp:
2535         (JSC::IncrementalSweeper::startSweeping):
2536         (JSC::IncrementalSweeper::addBlocksAndContinueSweeping): Deleted.
2537         * heap/IncrementalSweeper.h:
2538
2539 2015-05-20  Youenn Fablet  <youenn.fablet@crf.canon.fr>
2540
2541         AudioContext resume/close/suspend should reject promises with a DOM exception in lieu of throwing exceptions
2542         https://bugs.webkit.org/show_bug.cgi?id=145064
2543
2544         Reviewed by Darin Adler.
2545
2546         Added default message for TypeError.
2547
2548         * runtime/Error.cpp:
2549         (JSC::throwTypeError):
2550         * runtime/Error.h:
2551
2552 2015-05-20  Joseph Pecoraro  <pecoraro@apple.com>
2553
2554         No LLInt Test Failure: jsc-layout-tests.yaml/js/script-tests/object-literal-duplicate-properties.js.layout-no-llint
2555         https://bugs.webkit.org/show_bug.cgi?id=145219
2556
2557         Reviewed by Mark Lam.
2558
2559         * jit/JITOperations.cpp:
2560         Throw the error we just got, instead of a stack overflow exception.
2561         This matches other error handling for callers of prepareForExecution.
2562
2563 2015-05-19  Filip Pizlo  <fpizlo@apple.com>
2564
2565         Add some assertions about the CFG in the loop pre-header creation phase
2566         https://bugs.webkit.org/show_bug.cgi?id=145205
2567
2568         Reviewed by Geoffrey Garen.
2569         
2570         * dfg/DFGByteCodeParser.cpp:
2571         (JSC::DFG::ByteCodeParser::currentNodeOrigin): Add a FIXME.
2572         * dfg/DFGLICMPhase.cpp:
2573         (JSC::DFG::LICMPhase::run): Add a FIXME.
2574         * dfg/DFGLoopPreHeaderCreationPhase.cpp:
2575         (JSC::DFG::LoopPreHeaderCreationPhase::run): Add the assertions.
2576
2577 2015-05-20  Joseph Pecoraro  <pecoraro@apple.com>
2578
2579         ES6: Implement Object.setPrototypeOf
2580         https://bugs.webkit.org/show_bug.cgi?id=145202
2581
2582         Reviewed by Darin Adler.
2583
2584         * runtime/JSGlobalObjectFunctions.h:
2585         * runtime/JSGlobalObjectFunctions.cpp:
2586         (JSC::globalFuncProtoSetter):
2587         (JSC::checkProtoSetterAccessAllowed):
2588         Extract a helper to share this code between __proto__ setter and setPrototypeOf.
2589
2590         * runtime/ObjectConstructor.cpp:
2591         (JSC::objectConstructorSetPrototypeOf):
2592         Implementation is very similiar to __proto__ setter.
2593
2594 2015-05-20  Joseph Pecoraro  <pecoraro@apple.com>
2595
2596         ES6: Should not allow duplicate basic __proto__ properties in Object Literals
2597         https://bugs.webkit.org/show_bug.cgi?id=145138
2598
2599         Reviewed by Darin Adler.
2600
2601         Implement ES6 Annex B.3.1, which disallows duplicate basic __proto__
2602         properties in object literals. This doesn't affect computed properties,
2603         shorthand properties, or getters/setters all of which avoid setting
2604         the actual prototype of the object anyway.
2605
2606         * interpreter/Interpreter.cpp:
2607         (JSC::eval):
2608         Remove out of date comment. Duplicate property names are allowed
2609         now in ES6, they were not in ES5 strict mode.
2610
2611         * parser/ASTBuilder.h:
2612         (JSC::ASTBuilder::getName):
2613         (JSC::ASTBuilder::getType):
2614         * parser/SyntaxChecker.h:
2615         (JSC::SyntaxChecker::getName):
2616         Add back getName to get the property name depending on the tree builder.
2617         Also tighten up the parameter types.
2618
2619         * runtime/LiteralParser.cpp:
2620         (JSC::LiteralParser<CharType>::parse):
2621         In quick JSON literal parsing for eval, we actually need to evaluate
2622         the __proto__ property assignment, instead of just building up a list
2623         of direct properties. Only do this when not doing a strict JSON parse.
2624
2625         * parser/Nodes.h:
2626         Add "Shorthand" to the list of PropertyNode types to allow it to
2627         be distinguished without relying on other information.
2628
2629         * parser/Parser.h:
2630         * parser/Parser.cpp:
2631         (JSC::Parser<LexerType>::parseProperty):
2632         Add the Shorthand type when parsing a shorthand property.
2633
2634         (JSC::Parser<LexerType>::shouldCheckPropertyForUnderscoreProtoDuplicate):
2635         (JSC::Parser<LexerType>::parseObjectLiteral):
2636         (JSC::Parser<LexerType>::parseStrictObjectLiteral):
2637         Check for duplicate __proto__ properties, and throw a SyntaxError
2638         if that was the case.
2639
2640 2015-05-20  Csaba Osztrogonác  <ossy@webkit.org>
2641
2642         [JSC] Add missing copyrights and licenses for some scripts
2643         https://bugs.webkit.org/show_bug.cgi?id=145044
2644
2645         Reviewed by Darin Adler.
2646
2647         * build-symbol-table-index.py:
2648         * create-llvm-ir-from-source-file.py:
2649         * create-symbol-table-index.py:
2650
2651 2015-05-20  Joseph Pecoraro  <pecoraro@apple.com>
2652
2653         Web Inspector: Slightly better node previews in arrays
2654         https://bugs.webkit.org/show_bug.cgi?id=145188
2655
2656         Reviewed by Timothy Hatcher.
2657
2658         * inspector/InjectedScriptSource.js:
2659         (InjectedScript.prototype._nodeDescription):
2660         (InjectedScript.prototype._nodePreview):
2661         Different stringified representations for a basic object description or in a preview.
2662
2663         (InjectedScript.RemoteObject.prototype._appendPropertyPreviews):
2664         Use the node preview string representation inside previews.
2665
2666 2015-05-19  Commit Queue  <commit-queue@webkit.org>
2667
2668         Unreviewed, rolling out r184613 and r184614.
2669         https://bugs.webkit.org/show_bug.cgi?id=145206
2670
2671         Broke 10 tests :| (Requested by kling on #webkit).
2672
2673         Reverted changesets:
2674
2675         "[JSC] Speed up URL encode/decode by using bitmaps instead of
2676         strchr()."
2677         https://bugs.webkit.org/show_bug.cgi?id=145115
2678         http://trac.webkit.org/changeset/184613
2679
2680         "[JSC] Speed up URL encode/decode by using bitmaps instead of
2681         strchr()."
2682         https://bugs.webkit.org/show_bug.cgi?id=145115
2683         http://trac.webkit.org/changeset/184614
2684
2685 2015-05-19  Andreas Kling  <akling@apple.com>
2686
2687         Give StringView a utf8() API.
2688         <https://webkit.org/b/145201>
2689
2690         Reviewed by Anders Carlsson.
2691
2692         Use JSString::view() in a few places where we couldn't before due to StringView
2693         lacking a utf8() API. This is a minor speed-up on Kraken's crypto subtests,
2694         which like to call encode() with substring JSStrings.
2695
2696         * jsc.cpp:
2697         (functionPrint):
2698         (functionDebug):
2699         * runtime/JSGlobalObjectFunctions.cpp:
2700         (JSC::encode):
2701
2702 2015-05-19  Andreas Kling  <akling@apple.com>
2703
2704         [JSC] Speed up URL encode/decode by using bitmaps instead of strchr().
2705         <https://webkit.org/b/145115>
2706
2707         Incorporate review feedback from Darin, removing some unnecessary zero checks.
2708
2709         * runtime/JSGlobalObjectFunctions.cpp:
2710         (JSC::encode):
2711         (JSC::decode):
2712         (JSC::globalFuncEscape):
2713
2714 2015-05-19  Yusuke Suzuki  <utatane.tea@gmail.com>
2715
2716         Move AtomicStringImpl table related operations from AtomicString to AtomicStringImpl
2717         https://bugs.webkit.org/show_bug.cgi?id=145109
2718
2719         Reviewed by Darin Adler.
2720
2721         * bytecode/CodeBlock.cpp:
2722         (JSC::CodeBlock::nameForRegister):
2723         * runtime/Identifier.cpp:
2724         (JSC::Identifier::add):
2725         (JSC::Identifier::add8):
2726         * runtime/Identifier.h:
2727         (JSC::Identifier::add):
2728         * runtime/IdentifierInlines.h:
2729         (JSC::Identifier::Identifier):
2730         (JSC::Identifier::add):
2731         * runtime/JSString.cpp:
2732         (JSC::JSRopeString::resolveRopeToExistingAtomicString):
2733         * runtime/JSString.h:
2734         (JSC::JSString::toExistingAtomicString):
2735         * runtime/SmallStrings.cpp:
2736         (JSC::SmallStringsStorage::SmallStringsStorage):
2737         * runtime/TypeSet.cpp:
2738         (JSC::StructureShape::propertyHash):
2739
2740 2015-05-19  Joseph Pecoraro  <pecoraro@apple.com>
2741
2742         Web Inspector: Improve Preview for NodeList / array like collections
2743         https://bugs.webkit.org/show_bug.cgi?id=145177
2744
2745         Reviewed by Timothy Hatcher.
2746
2747         * inspector/InjectedScriptSource.js:
2748         (InjectedScript.RemoteObject.prototype._appendPropertyPreviews):
2749         For "array" like object previews skip over non-index properties.
2750         We are not marking the object as lossless by choice, but we
2751         may return to this decision later.
2752
2753 2015-05-19  Michael Saboff  <msaboff@apple.com>
2754
2755         REGRESSION(183787): JIT is enabled for all builds
2756         https://bugs.webkit.org/show_bug.cgi?id=145179
2757
2758         Reviewed by Geoffrey Garen.
2759
2760         Eliminated the setting of ENABLE_JIT, as wtf/Platform.h has appropriate logic to
2761         set it depending on OS and CPU type.
2762
2763         * Configurations/FeatureDefines.xcconfig:
2764
2765 2015-05-19  Youenn Fablet  <youenn.fablet@crf.canon.fr>
2766
2767         Rename createIterResultObject as createIteratorResultObject
2768         https://bugs.webkit.org/show_bug.cgi?id=145116
2769
2770         Reviewed by Darin Adler.
2771
2772         Renamed createIterResultObject as createIteratorResultObject.
2773         Made this function exportable for future use by streams API.
2774
2775         * runtime/IteratorOperations.cpp:
2776         (JSC::createIteratorResultObject):
2777         * runtime/IteratorOperations.h:
2778         * runtime/MapIteratorPrototype.cpp:
2779         (JSC::MapIteratorPrototypeFuncNext):
2780         * runtime/SetIteratorPrototype.cpp:
2781         (JSC::SetIteratorPrototypeFuncNext):
2782
2783 2015-05-19  Yusuke Suzuki  <utatane.tea@gmail.com>
2784
2785         Array.prototype methods must use ToLength
2786         https://bugs.webkit.org/show_bug.cgi?id=144128
2787
2788         Reviewed by Oliver Hunt.
2789
2790         Patch by Jordan Harband  <ljharb@gmail.com> and Yusuke Suzuki <utatane.tea@gmail.com>
2791
2792         Per https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength
2793
2794         This patch introduces ToLength and ToInteger JS implementation to encourage the DFG/FTL's inlining.
2795         These implementations are located in GlobalObject.js.
2796         And set to the JSGlobalObject with the private symbols @ToLength and @ToInteger manually.
2797
2798         * builtins/Array.prototype.js:
2799         (every):
2800         (forEach):
2801         (filter):
2802         (map):
2803         (some):
2804         (fill):
2805         (find):
2806         (findIndex):
2807         (includes):
2808         * builtins/ArrayConstructor.js:
2809         (from):
2810         * builtins/GlobalObject.js: Copied from Source/JavaScriptCore/builtins/StringConstructor.js.
2811         (ToInteger):
2812         (ToLength):
2813         * builtins/StringConstructor.js:
2814         (raw):
2815         * runtime/JSGlobalObject.cpp:
2816         (JSC::JSGlobalObject::init):
2817         * runtime/JSGlobalObjectFunctions.h:
2818
2819 2015-05-19  Mark Lam  <mark.lam@apple.com>
2820
2821         Fix the build of a universal binary with ARMv7k of JavaScriptCore.
2822         https://bugs.webkit.org/show_bug.cgi?id=145143
2823
2824         Reviewed by Geoffrey Garen.
2825
2826         The offlineasm works in 3 phases:
2827
2828         Phase 1:
2829            Parse the llint asm files for config options and desired offsets.
2830            Let's say the offlineasm discovers C unique options and O unique offsets.
2831            The offlineasm will then generate a LLIntDesiredOffsets.h file with
2832            C x C build configurations, each with a set of O offsets.
2833
2834            Each of these build configurations is given a unique configuration index number.
2835
2836         Phase 2: 
2837            Compile the LLIntDesiredOffsets.h file into a JSCLLIntOffsetsExtractor binary.
2838
2839            If we're building a fat binary with 2 configurations: armv7, and armv7k,
2840            then the fat binary will contain 2 blobs of offsets, one for each of these
2841            build configurations.
2842
2843         Phase 3:
2844            Parse the llint asm files and emit asm code using the offsets that are
2845            extracted from the JSCLLIntOffsetsExtractor binary for the corresponding
2846            configuration index number.
2847
2848         In the pre-existing code, there are no "if ARMv7k" statements in the llint asm
2849         source.  As a result, OFFLINE_ASM_ARMv7k is not one of the config options in
2850         the set of C unique options.
2851
2852         For armv7k builds, OFFLINE_ASM_ARMv7 is also true.  As a result, for an armv7k
2853         target, we will end up building armv7 source.  In general, this is fine except:
2854
2855         1. armv7k has different alignment requirements from armv7.  Hence, their offset
2856            values (in JSCLLIntOffsetsExtractor) will be different.
2857
2858         2. The offlineasm was never told that it needed to make a different configuration
2859            for armv7k builds.  Hence, the armv7k build of LLIntDesiredOffsets.h will
2860            build the armv7 configuration, and consequently, the armv7k blob of offsets in
2861            JSCLLIntOffsetsExtractor will have the same configuration index number as
2862            the armv7 blob of offsets.
2863
2864         In phase 3, when the offlineasm parses the JSCLLIntOffsetsExtractor fat binary
2865         looking for the armv7 build's configuration index number, it discovers the
2866         armv7k blob which has the same configuration number.  As a result, it
2867         erroneously thinks the armv7k offsets are appropriate for emitting armv7 code.
2868         Needless to say, armv7 code using armv7k offsets will lead to incorrect behavior
2869         and all round badness.
2870
2871         The fix is to add a simple "if ARMv7k" statement to the llint asm files.  While
2872         the if statement has no body, it does make the offlineasm aware of the need for
2873         ARMv7k as a configuration option.  As a result, it will generate an armv7k
2874         variant configuration in the LLIntDesiredOffsets.h file with its own unique
2875         configuration index number.  With that, the JSCLLIntOffsetsExtractor fat binary
2876         will no longer have duplicate configuration index numbers for the armv7 and
2877         armv7k blobs of offsets, and the issue is resolved.
2878
2879         * llint/LLIntOfflineAsmConfig.h:
2880         * llint/LowLevelInterpreter.asm:
2881
2882 2015-05-19  Andreas Kling  <akling@apple.com>
2883
2884         Give JSString a StringView getter and start using it.
2885         <https://webkit.org/b/145131>
2886
2887         Reviewed by Anders Carlsson.
2888
2889         When JSString is a substring internally, calling value(ExecState*) on it
2890         will reify the baseString/start/length tuple into a new StringImpl.
2891
2892         For clients that only want to look at the characters of a JSString, but
2893         don't actually need a reffable StringImpl, adding a light-weight StringView
2894         getter lets them avoid constructing anything.
2895
2896         This patch adds JSString::view(ExecState*) and uses it in a few places.
2897         There are many more opportunities to use this API, but let's do a few things
2898         at a time.
2899
2900         * runtime/FunctionConstructor.cpp:
2901         (JSC::constructFunctionSkippingEvalEnabledCheck):
2902         * runtime/JSGlobalObjectFunctions.cpp:
2903         (JSC::decode):
2904         (JSC::parseInt):
2905         (JSC::jsToNumber):
2906         (JSC::parseFloat):
2907         (JSC::globalFuncParseInt):
2908         (JSC::globalFuncParseFloat):
2909         (JSC::globalFuncEscape):
2910         (JSC::globalFuncUnescape):
2911         * runtime/JSGlobalObjectFunctions.h:
2912         * runtime/JSONObject.cpp:
2913         (JSC::JSONProtoFuncParse):
2914         * runtime/JSString.cpp:
2915         (JSC::JSString::getPrimitiveNumber):
2916         (JSC::JSString::toNumber):
2917         * runtime/JSString.h:
2918         (JSC::JSRopeString::view):
2919         (JSC::JSString::view):
2920
2921 2015-05-18  Filip Pizlo  <fpizlo@apple.com>
2922
2923         Better optimize 'if' with ternaries conditional tests.
2924         https://bugs.webkit.org/show_bug.cgi?id=144136
2925
2926         Reviewed by Benjamin Poulain.
2927         
2928         This is the last fix I'll do for this for now. BooleanToNumber(Untyped:) where the input
2929         is proved to be either BoolInt32 or Boolean should be optimized to just masking the
2930         lowest bit.
2931         
2932         This is another 37% speed-up on JSRegress/slow-ternaries.
2933
2934         * dfg/DFGSpeculativeJIT32_64.cpp:
2935         (JSC::DFG::SpeculativeJIT::compile):
2936         * dfg/DFGSpeculativeJIT64.cpp:
2937         (JSC::DFG::SpeculativeJIT::compile):
2938         * ftl/FTLLowerDFGToLLVM.cpp:
2939         (JSC::FTL::LowerDFGToLLVM::compileBooleanToNumber):
2940
2941 2015-05-18  Benjamin Poulain  <bpoulain@apple.com>
2942
2943         <rdar://problem/21003555> cloberrize() is wrong for ArithRound because it doesn't account for the arith mode
2944         https://bugs.webkit.org/show_bug.cgi?id=145147
2945
2946         Reviewed by Filip Pizlo.
2947
2948         Really stupid bug: ArithRound nodes with different rounding modes
2949         were not distinguished and CSE would happily unify with a node of
2950         a different rounding mode.
2951
2952         DFG::clobberize() already support additional data but I was not using it.
2953
2954         * dfg/DFGClobberize.h:
2955         (JSC::DFG::clobberize):
2956         * tests/stress/math-round-arith-rounding-mode.js: Added.
2957         (firstCareAboutZeroSecondDoesNot):
2958         (firstDoNotCareAboutZeroSecondDoes):
2959         (warmup):
2960         (verifyNegativeZeroIsPreserved):
2961
2962 2015-05-18  Filip Pizlo  <fpizlo@apple.com>
2963
2964         Add SpecBoolInt32 type that means "I'm an int and I'm either 0 or 1"
2965         https://bugs.webkit.org/show_bug.cgi?id=145137
2966
2967         Reviewed by Benjamin Poulain.
2968         
2969         It's super useful to know if an integer value could be either zero or one. We have an
2970         immediate need for this because of Int32|Boolean uses, where knowing that the Int32 is
2971         either 0 or 1 means that there is no actual polymorphism if you just look at the low bit
2972         (1 behaves like true, 0 behaves like false, and the low bit of 1|true is 1, and the low
2973         bit of 0|false is 0).
2974         
2975         We do this by splitting the SpecInt32 type into SpecBoolInt32 and SpecNonBoolInt32. This
2976         change doesn't have any effect on behavior, yet. But it does give us the ability to
2977         predict and prove when values are SpecBoolInt32; it's just we don't leverage this yet.
2978         
2979         This is perf-neutral.
2980
2981         * bytecode/SpeculatedType.cpp:
2982         (JSC::dumpSpeculation):
2983         (JSC::speculationToAbbreviatedString):
2984         (JSC::speculationFromValue):
2985         * bytecode/SpeculatedType.h:
2986         (JSC::isStringOrStringObjectSpeculation):
2987         (JSC::isBoolInt32Speculation):
2988         (JSC::isInt32Speculation):
2989         (JSC::isInt32OrBooleanSpeculation):
2990         * dfg/DFGAbstractInterpreterInlines.h:
2991         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
2992
2993 2015-05-18  Michael Catanzaro  <mcatanzaro@igalia.com>
2994
2995         [CMake] Ignore warnings in system headers
2996         https://bugs.webkit.org/show_bug.cgi?id=144747
2997
2998         Reviewed by Darin Adler.
2999
3000         Separate include directories into WebKit project includes and system includes. Suppress all
3001         warnings from headers in system include directories using the SYSTEM argument to
3002         the include_directories command.
3003
3004         * CMakeLists.txt:
3005         * PlatformGTK.cmake:
3006
3007 2015-05-18  Skachkov Alexandr  <gskachkov@gmail.com>
3008
3009         [ES6] Arrow function syntax. Feature flag for arrow function
3010         https://bugs.webkit.org/show_bug.cgi?id=145108
3011
3012         Reviewed by Ryosuke Niwa.
3013
3014         Added feature flag ENABLE_ES6_ARROWFUNCTION_SYNTAX for arrow function
3015
3016         * Configurations/FeatureDefines.xcconfig:
3017         
3018 2015-05-18  Benjamin Poulain  <benjamin@webkit.org>
3019
3020         [JSC] When entering a CheckTierUp without OSREntry, force the CheckTierUp for the outer loops with OSR Entry
3021         https://bugs.webkit.org/show_bug.cgi?id=145092
3022
3023         Reviewed by Filip Pizlo.
3024
3025         When we have a hot loop without OSR Entry inside a slower loop that support OSR Entry,
3026         we get the inside loop driving the tierUpCounter and we have very little chance of
3027         doing a CheckTierUp on the outer loop. In turn, this give almost no opportunity to tier
3028         up in the outer loop and OSR Enter there.
3029
3030         This patches changes CheckTierUp to force its outer loops to do a CheckTierUp themselves.
3031
3032         To do that, CheckTierUp sets a flag "nestedTriggerIsSet" to force the outer loop to
3033         enter their CheckTierUp regardless of the tier-up counter.
3034
3035         * bytecode/ExecutionCounter.cpp:
3036         (JSC::ExecutionCounter<countingVariant>::setThreshold):
3037         This is somewhat unrelated. This assertion is incorrect because it relies on
3038         m_counter, which changes on an other thread.
3039
3040         I have hit it a couple of times with this patch because we are a bit more aggressive
3041         on CheckTierUp. What happens is:
3042         1) ExecutionCounter<countingVariant>::checkIfThresholdCrossedAndSet() first checks
3043            hasCrossedThreshold(), and it is false.
3044         2) On the main thread, the hot loops keeps running and the counter becomes large
3045            enough to cross the threshold.
3046         3) ExecutionCounter<countingVariant>::checkIfThresholdCrossedAndSet() runs the next
3047            test, setThreshold(), where the assertion is. Since the counter is now large enough,
3048            the assertion fails.
3049
3050         * dfg/DFGAbstractInterpreterInlines.h:
3051         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
3052         * dfg/DFGClobberize.h:
3053         (JSC::DFG::clobberize):
3054         * dfg/DFGDoesGC.cpp:
3055         (JSC::DFG::doesGC):
3056         * dfg/DFGFixupPhase.cpp:
3057         (JSC::DFG::FixupPhase::fixupNode):
3058
3059         * dfg/DFGJITCode.h:
3060         I used a uint8_t instead of a boolean to make the code generation clearer
3061         in DFGSpeculativeJIT64.
3062
3063         * dfg/DFGNodeType.h:
3064         * dfg/DFGOperations.cpp:
3065         * dfg/DFGOperations.h:
3066
3067         * dfg/DFGPredictionPropagationPhase.cpp:
3068         (JSC::DFG::PredictionPropagationPhase::propagate):
3069         This is a bit annoying: we have the NaturalLoops analysis that provides us
3070         everything we need to know about loops, but the TierUpCheck are conservative
3071         and set on LoopHint.
3072
3073         To make the two work together, we first find all the CheckTierUp that cannot
3074         OSR enter and we keep a list of all the natural loops containing them.
3075
3076         Then we do a second pass over the LoopHints, get their NaturalLoop, and check
3077         if it contains a loop that cannot OSR enter.
3078
3079         * dfg/DFGSafeToExecute.h:
3080         (JSC::DFG::safeToExecute):
3081         * dfg/DFGSpeculativeJIT32_64.cpp:
3082         (JSC::DFG::SpeculativeJIT::compile):
3083         * dfg/DFGSpeculativeJIT64.cpp:
3084         (JSC::DFG::SpeculativeJIT::compile):
3085         * dfg/DFGTierUpCheckInjectionPhase.cpp:
3086         (JSC::DFG::TierUpCheckInjectionPhase::run):
3087         (JSC::DFG::TierUpCheckInjectionPhase::canOSREnterAtLoopHint):
3088
3089 2015-05-18  Filip Pizlo  <fpizlo@apple.com>
3090
3091         Add a Int-or-Boolean speculation to Branch
3092         https://bugs.webkit.org/show_bug.cgi?id=145134
3093
3094         Reviewed by Benjamin Poulain.
3095         
3096         After https://bugs.webkit.org/show_bug.cgi?id=126778 we no longer have a reason not to do the
3097         int-or-boolean optimization that we already do everywhere else.
3098
3099         * dfg/DFGFixupPhase.cpp:
3100         (JSC::DFG::FixupPhase::fixupNode):
3101
3102 2015-05-18  Andreas Kling  <akling@apple.com>
3103
3104         [JSC] Speed up URL encode/decode by using bitmaps instead of strchr().
3105         <https://webkit.org/b/145115>
3106
3107         Reviewed by Anders Carlsson.
3108
3109         We were calling strchr() for every character when doing URL encoding/decoding and it stood out
3110         like a sore O(n) thumb in Instruments. Optimize this by using a Bitmap<256> instead.
3111
3112         5.5% progression on Kraken/stanford-crypto-sha256-iterative.
3113
3114         * runtime/JSGlobalObjectFunctions.cpp:
3115         (JSC::makeCharacterBitmap):
3116         (JSC::encode):
3117         (JSC::decode):
3118         (JSC::globalFuncDecodeURI):
3119         (JSC::globalFuncDecodeURIComponent):
3120         (JSC::globalFuncEncodeURI):
3121         (JSC::globalFuncEncodeURIComponent):
3122         (JSC::globalFuncEscape):
3123
3124 2015-05-17  Benjamin Poulain  <benjamin@webkit.org>
3125
3126         Do not use fastMallocGoodSize anywhere
3127         https://bugs.webkit.org/show_bug.cgi?id=145103
3128
3129         Reviewed by Michael Saboff.
3130
3131         * assembler/AssemblerBuffer.h:
3132         (JSC::AssemblerData::AssemblerData):
3133         (JSC::AssemblerData::grow):
3134
3135 2015-05-17  Benjamin Poulain  <benjamin@webkit.org>
3136
3137         [JSC] Make StringRecursionChecker faster in the simple cases without any recursion
3138         https://bugs.webkit.org/show_bug.cgi?id=145102
3139
3140         Reviewed by Darin Adler.
3141
3142         In general, the array targeted by Array.toString() or Array.join() are pretty
3143         simple. In those simple cases, we spend as much time in StringRecursionChecker
3144         as we do on the actual operation.
3145
3146         The reason for this is the HashSet stringRecursionCheckVisitedObjects used
3147         to detect recursion. We are constantly adding and removing objects which
3148         dirty buckets and force constant rehash.
3149
3150         This patch adds a simple shortcut for those simple case: in addition to the HashSet,
3151         we keep a pointer to the root object of the recursion.
3152         In the vast majority of cases, we no longer touch the HashSet at all.
3153
3154         This patch is a 12% progression on the overall score of ArrayWeighted.
3155
3156         * runtime/StringRecursionChecker.h:
3157         (JSC::StringRecursionChecker::performCheck):
3158         (JSC::StringRecursionChecker::~StringRecursionChecker):
3159         * runtime/VM.h:
3160
3161 2015-05-17  Filip Pizlo  <fpizlo@apple.com>
3162
3163         Insert store barriers late so that IR transformations don't have to worry about them
3164         https://bugs.webkit.org/show_bug.cgi?id=145015
3165
3166         Reviewed by Geoffrey Garen.
3167         
3168         We have had three kinds of bugs with store barriers. For the sake of discussion we say
3169         that a store barrier is needed when we have something like:
3170         
3171             base.field = value
3172         
3173         - We sometimes fail to realize that we could remove a barrier when value is a non-cell.
3174           This might happen if we prove value to be a non-cell even though in the FixupPhase it
3175           wasn't predicted non-cell.
3176         
3177         - We sometimes have a barrier in the wrong place after object allocation sinking. We
3178           might sink an allocation to just above the store, but that puts it just after the
3179           StoreBarrier that FixupPhase inserted.
3180         
3181         - We don't remove redundant barriers across basic blocks.
3182         
3183         This comprehensively fixes these issues by doing store barrier insertion late, and
3184         removing the store barrier elision phase. Store barrier insertion uses an epoch-based
3185         algorithm to determine when stores need barriers. Briefly, a barrier is not needed if
3186         base is in the current GC epoch (i.e. was the last object that we allocated or had a
3187         barrier since last GC) or if base has a newer GC epoch than value (i.e. value would have
3188         always been allocated before base). We do conservative things when merging epoch state
3189         between basic blocks, and we only do such inter-block removal in the FTL. FTL also
3190         queries AI to determine what type we've proved about value, and avoids barriers when
3191         value is not a cell. FixupPhase still inserts type checks on some stores, to maximize
3192         the likelihood that this AI-based removal is effective.
3193         
3194         Rolling back in after fixing some debug build test failures.
3195
3196         * CMakeLists.txt:
3197         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
3198         * JavaScriptCore.xcodeproj/project.pbxproj:
3199         * dfg/DFGBlockMap.h:
3200         (JSC::DFG::BlockMap::at):
3201         * dfg/DFGConstantFoldingPhase.cpp:
3202         (JSC::DFG::ConstantFoldingPhase::emitPutByOffset):
3203         * dfg/DFGEpoch.h:
3204         (JSC::DFG::Epoch::operator<):
3205         (JSC::DFG::Epoch::operator>):
3206         (JSC::DFG::Epoch::operator<=):
3207         (JSC::DFG::Epoch::operator>=):
3208         * dfg/DFGFixupPhase.cpp:
3209         (JSC::DFG::FixupPhase::fixupNode):
3210         (JSC::DFG::FixupPhase::speculateForBarrier):
3211         (JSC::DFG::FixupPhase::insertStoreBarrier): Deleted.
3212         * dfg/DFGPlan.cpp:
3213         (JSC::DFG::Plan::compileInThreadImpl):
3214         * dfg/DFGStoreBarrierElisionPhase.cpp: Removed.
3215         * dfg/DFGStoreBarrierElisionPhase.h: Removed.
3216         * dfg/DFGStoreBarrierInsertionPhase.cpp: Added.
3217         (JSC::DFG::performFastStoreBarrierInsertion):
3218         (JSC::DFG::performGlobalStoreBarrierInsertion):
3219         * dfg/DFGStoreBarrierInsertionPhase.h: Added.
3220         * ftl/FTLOperations.cpp:
3221         (JSC::FTL::operationMaterializeObjectInOSR): Fix an unrelated debug-only bug.
3222         * tests/stress/load-varargs-then-inlined-call-and-exit.js: Test for that debug-only bug.
3223         * tests/stress/load-varargs-then-inlined-call-and-exit-strict.js: Strict version of that test.
3224
3225 2015-05-16  Commit Queue  <commit-queue@webkit.org>
3226
3227         Unreviewed, rolling out r184415.
3228         https://bugs.webkit.org/show_bug.cgi?id=145096
3229
3230         Broke several tests (Requested by msaboff on #webkit).
3231
3232         Reverted changeset:
3233
3234         "Insert store barriers late so that IR transformations don't
3235         have to worry about them"
3236         https://bugs.webkit.org/show_bug.cgi?id=145015
3237         http://trac.webkit.org/changeset/184415
3238
3239 2015-05-14  Filip Pizlo  <fpizlo@apple.com>
3240
3241         Insert store barriers late so that IR transformations don't have to worry about them
3242         https://bugs.webkit.org/show_bug.cgi?id=145015
3243
3244         Reviewed by Geoffrey Garen.
3245         
3246         We have had three kinds of bugs with store barriers. For the sake of discussion we say
3247         that a store barrier is needed when we have something like:
3248         
3249             base.field = value
3250         
3251         - We sometimes fail to realize that we could remove a barrier when value is a non-cell.
3252           This might happen if we prove value to be a non-cell even though in the FixupPhase it
3253           wasn't predicted non-cell.
3254         
3255         - We sometimes have a barrier in the wrong place after object allocation sinking. We
3256           might sink an allocation to just above the store, but that puts it just after the
3257           StoreBarrier that FixupPhase inserted.
3258         
3259         - We don't remove redundant barriers across basic blocks.
3260         
3261         This comprehensively fixes these issues by doing store barrier insertion late, and
3262         removing the store barrier elision phase. Store barrier insertion uses an epoch-based
3263         algorithm to determine when stores need barriers. Briefly, a barrier is not needed if
3264         base is in the current GC epoch (i.e. was the last object that we allocated or had a
3265         barrier since last GC) or if base has a newer GC epoch than value (i.e. value would have
3266         always been allocated before base). We do conservative things when merging epoch state
3267         between basic blocks, and we only do such inter-block removal in the FTL. FTL also
3268         queries AI to determine what type we've proved about value, and avoids barriers when
3269         value is not a cell. FixupPhase still inserts type checks on some stores, to maximize
3270         the likelihood that this AI-based removal is effective.
3271
3272         * CMakeLists.txt:
3273         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
3274         * JavaScriptCore.xcodeproj/project.pbxproj:
3275         * dfg/DFGBlockMap.h:
3276         (JSC::DFG::BlockMap::at):
3277         * dfg/DFGConstantFoldingPhase.cpp:
3278         (JSC::DFG::ConstantFoldingPhase::emitPutByOffset):
3279         * dfg/DFGEpoch.h:
3280         (JSC::DFG::Epoch::operator<):
3281         (JSC::DFG::Epoch::operator>):
3282         (JSC::DFG::Epoch::operator<=):
3283         (JSC::DFG::Epoch::operator>=):
3284         * dfg/DFGFixupPhase.cpp:
3285         (JSC::DFG::FixupPhase::fixupNode):
3286         (JSC::DFG::FixupPhase::speculateForBarrier):
3287         (JSC::DFG::FixupPhase::insertStoreBarrier): Deleted.
3288         * dfg/DFGPlan.cpp:
3289         (JSC::DFG::Plan::compileInThreadImpl):
3290         * dfg/DFGStoreBarrierElisionPhase.cpp: Removed.
3291         * dfg/DFGStoreBarrierElisionPhase.h: Removed.
3292         * dfg/DFGStoreBarrierInsertionPhase.cpp: Added.
3293         (JSC::DFG::performFastStoreBarrierInsertion):
3294         (JSC::DFG::performGlobalStoreBarrierInsertion):
3295         * dfg/DFGStoreBarrierInsertionPhase.h: Added.
3296
3297 2015-05-15  Benjamin Poulain  <bpoulain@apple.com>
3298
3299         [ARM64] Do not fail branchConvertDoubleToInt32 when the result is zero and not negative zero
3300         https://bugs.webkit.org/show_bug.cgi?id=144976
3301
3302         Reviewed by Michael Saboff.
3303
3304         Failing the conversion on zero is pretty dangerous as we discovered on x86.
3305
3306         This patch does not really impact performance significantly because
3307         r184220 removed the zero checks from Kraken. This patch is just to be
3308         on the safe side for cases not covered by existing benchmarks.
3309
3310         * assembler/MacroAssemblerARM64.h:
3311         (JSC::MacroAssemblerARM64::branchConvertDoubleToInt32):
3312
3313 2015-05-15  Sungmann Cho  <sungmann.cho@navercorp.com>
3314
3315         Remove unnecessary forward declarations in PropertyNameArray.h.
3316         https://bugs.webkit.org/show_bug.cgi?id=145058
3317
3318         Reviewed by Andreas Kling.
3319
3320         No new tests, no behavior change.
3321
3322         * runtime/PropertyNameArray.h:
3323
3324 2015-05-15  Mark Lam  <mark.lam@apple.com>
3325
3326         JSArray::setLength() should reallocate instead of zero-filling if the reallocation would be small enough.
3327         https://bugs.webkit.org/show_bug.cgi?id=144622
3328
3329         Reviewed by Geoffrey Garen.
3330
3331         When setting the array to a new length that is shorter, we now check if it is worth
3332         just making a new butterfly instead of clearing out the slots in the old butterfly
3333         that resides beyond the new length.  If so, we will make a new butterfly instead.
3334
3335         There is no perf differences in the benchmark results.  However, this does benefit
3336         the perf of pathological cases where we need to shorten the length of a very large
3337         array, as is the case in tests/mozilla/js1_5/Array/regress-101964.js.  With this
3338         patch, we can expect that test to complete in a short time again.
3339
3340         * runtime/JSArray.cpp:
3341         (JSC::JSArray::setLength):
3342         * runtime/JSObject.cpp:
3343         (JSC::JSObject::reallocateAndShrinkButterfly):
3344         - makes a new butterfly with a new shorter length.
3345         * runtime/JSObject.h:
3346         * tests/mozilla/js1_5/Array/regress-101964.js:
3347         - Undo this test change since this patch will prevent us from spending a lot of time
3348           clearing a large butterfly.
3349
3350 2015-05-15  Basile Clement  <basile_clement@apple.com>
3351
3352         DFGLICMPhase shouldn't create NodeOrigins with forExit but without semantic
3353         https://bugs.webkit.org/show_bug.cgi?id=145062
3354
3355         Reviewed by Filip Pizlo.
3356
3357         We assert in various places (including NodeOrigin::isSet()) that a
3358         NodeOrigin's semantic and forExit must be either both set, or both
3359         unset.  However, LICM'ing a node with unset NodeOrigin would only set
3360         forExit, and leave semantic unset. This can for instance happen when a
3361         Phi node is constant-folded into a JSConstant, which in turn gets
3362         LICM'd.
3363
3364         This patch changes DFGLICMPhase to set the NodeOrigin's semantic in
3365         addition to its forExit if semantic was previously unset.
3366
3367         It also adds two validators to DFGValidate.cpp:
3368          - In both SSA and CPS form, a NodeOrigin semantic and forExit must be either both set or both unset
3369          - In CPS form, all nodes must have a set NodeOrigin forExit (this is
3370            the CPS counterpart to the SSA validator that checks that all nodes
3371            must have a set NodeOrigin except possibly for a continuous chunk of
3372            nodes at the top of a block)
3373
3374         * dfg/DFGLICMPhase.cpp:
3375         (JSC::DFG::LICMPhase::attemptHoist):
3376         * dfg/DFGValidate.cpp:
3377         (JSC::DFG::Validate::validate):
3378         (JSC::DFG::Validate::validateCPS):
3379
3380 2015-05-15  Filip Pizlo  <fpizlo@apple.com>
3381
3382         Unreviewed, remove an unused declaration.
3383
3384         * dfg/DFGSpeculativeJIT.h:
3385
3386 2015-05-14  Filip Pizlo  <fpizlo@apple.com>
3387
3388         Remove unused constant-base and constant-value store barrier code in the DFG
3389         https://bugs.webkit.org/show_bug.cgi?id=145039
3390
3391         Reviewed by Andreas Kling.
3392         
3393         Just killing dead code.
3394
3395         * dfg/DFGSpeculativeJIT.cpp:
3396         (JSC::DFG::SpeculativeJIT::storeToWriteBarrierBuffer): Deleted.
3397         (JSC::DFG::SpeculativeJIT::writeBarrier): Deleted.
3398         * dfg/DFGSpeculativeJIT.h:
3399         * dfg/DFGSpeculativeJIT32_64.cpp:
3400         (JSC::DFG::SpeculativeJIT::writeBarrier):
3401         * dfg/DFGSpeculativeJIT64.cpp:
3402         (JSC::DFG::SpeculativeJIT::writeBarrier):
3403
3404 2015-05-15  Alexandr Skachkov  <gskachkov@gmail.com>
3405
3406         Fix typo in function name parseFunctionParamters -> parseFunctionParameters
3407         https://bugs.webkit.org/show_bug.cgi?id=145040
3408
3409         Reviewed by Mark Lam.
3410
3411         * parser/Parser.h:
3412         * parser/Parser.cpp:
3413
3414 2015-05-14  Filip Pizlo  <fpizlo@apple.com>
3415
3416         Remove StoreBarrierWithNullCheck, nobody ever generates this.
3417         
3418         Rubber stamped by Benjamin Poulain and Michael Saboff.
3419
3420         If we did bring something like this back in the future, we would just use UntypedUse instead
3421         of CellUse to indicate that this is what we want.
3422
3423         * dfg/DFGAbstractInterpreterInlines.h:
3424         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
3425         * dfg/DFGClobberize.h:
3426         (JSC::DFG::clobberize):
3427         * dfg/DFGDoesGC.cpp:
3428         (JSC::DFG::doesGC):
3429         * dfg/DFGFixupPhase.cpp:
3430         (JSC::DFG::FixupPhase::fixupNode):
3431         * dfg/DFGNode.h:
3432         (JSC::DFG::Node::isStoreBarrier):
3433         * dfg/DFGNodeType.h:
3434         * dfg/DFGObjectAllocationSinkingPhase.cpp:
3435         (JSC::DFG::ObjectAllocationSinkingPhase::lowerNonReadingOperationsOnPhantomAllocations):
3436         (JSC::DFG::ObjectAllocationSinkingPhase::handleNode):
3437         * dfg/DFGPredictionPropagationPhase.cpp:
3438         (JSC::DFG::PredictionPropagationPhase::propagate):
3439         * dfg/DFGSafeToExecute.h:
3440         (JSC::DFG::safeToExecute):
3441         * dfg/DFGSpeculativeJIT.cpp:
3442         (JSC::DFG::SpeculativeJIT::compileStoreBarrier):
3443         * dfg/DFGSpeculativeJIT32_64.cpp:
3444         (JSC::DFG::SpeculativeJIT::compile):
3445         * dfg/DFGSpeculativeJIT64.cpp:
3446         (JSC::DFG::SpeculativeJIT::compile):
3447         * ftl/FTLCapabilities.cpp:
3448         (JSC::FTL::canCompile):
3449         * ftl/FTLLowerDFGToLLVM.cpp:
3450         (JSC::FTL::LowerDFGToLLVM::compileNode):
3451         (JSC::FTL::LowerDFGToLLVM::compileStoreBarrierWithNullCheck): Deleted.
3452
3453 2015-05-14  Filip Pizlo  <fpizlo@apple.com>
3454
3455         PutGlobalVar should reference the global object it's storing into
3456         https://bugs.webkit.org/show_bug.cgi?id=145036
3457
3458         Reviewed by Michael Saboff.
3459         
3460         This makes it easier to reason about store barrier insertion and elimination. This changes
3461         the format of PutGlobalVar so that child1 is the global object and child2 is the value.
3462         Previously it just had child1, and that was the value.
3463
3464         * dfg/DFGByteCodeParser.cpp:
3465         (JSC::DFG::ByteCodeParser::parseBlock):
3466         * dfg/DFGClobberize.h:
3467         (JSC::DFG::clobberize):
3468         * dfg/DFGFixupPhase.cpp:
3469         (JSC::DFG::FixupPhase::fixupNode):
3470         * dfg/DFGSpeculativeJIT32_64.cpp:
3471         (JSC::DFG::SpeculativeJIT::compile):
3472         * dfg/DFGSpeculativeJIT64.cpp:
3473         (JSC::DFG::SpeculativeJIT::compile):
3474         * ftl/FTLLowerDFGToLLVM.cpp:
3475         (JSC::FTL::LowerDFGToLLVM::compilePutGlobalVar):
3476
3477 2015-05-14  Michael Catanzaro  <mcatanzaro@igalia.com>
3478
3479         [CMake] Error out when ruby is too old
3480         https://bugs.webkit.org/show_bug.cgi?id=145014
3481
3482         Reviewed by Martin Robinson.
3483
3484         Don't enforce the check for the Ruby executable here; it's now enforced in the top-level
3485         CMakeLists.txt instead.
3486
3487         * CMakeLists.txt:
3488
3489 2015-05-12  Basile Clement  <basile_clement@apple.com>
3490
3491         Enforce options coherency
3492         https://bugs.webkit.org/show_bug.cgi?id=144921
3493
3494         Reviewed by Mark Lam.
3495
3496         JavaScriptCore should be failing early when the options are set in such
3497         a way that we don't have a meaningful way to execute JavaScript, rather
3498         than failing for obscure reasons at some point during execution.
3499
3500         This patch adds a new function that checks whether the options are set
3501         in a coherent way, and makes JSC::Options::initialize() crash when the
3502         environment enforces incoherent options.
3503         Client applications able to add or change additional options are
3504         responsible to check for coherency again before starting to actually
3505         execute JavaScript, if any additional options have been set. This is
3506         implemented for the jsc executable in this patch.
3507
3508         * jsc.cpp:
3509         (CommandLine::parseArguments):
3510         * runtime/Options.cpp:
3511         (JSC::Options::initialize):
3512         (JSC::Options::ensureOptionsAreCoherent): Added.
3513         * runtime/Options.h:
3514         (JSC::Options::ensureOptionsAreCoherent): Added.
3515
3516 2015-05-14  Yusuke Suzuki  <utatane.tea@gmail.com>
3517
3518         REGRESSION (r184337): [EFL] unresolved reference errors in ARM builds
3519         https://bugs.webkit.org/show_bug.cgi?id=145019
3520
3521         Reviewed by Ryosuke Niwa.
3522
3523         Attempt to fix compile errors in EFL ARM buildbots.
3524         By executing `nm`, found JSTemplateRegistryKey.cpp.o and TemplateRegistry.cpp.o have
3525         unresolved reference to Structure::get. That is inlined function in StructureInlines.h.
3526
3527         * runtime/JSTemplateRegistryKey.cpp:
3528         * runtime/TemplateRegistry.cpp:
3529
3530 2015-05-14  Alexandr Skachkov  <gskachkov@gmail.com>
3531
3532         Small refactoring before implementation of the ES6 arrow function.
3533         https://bugs.webkit.org/show_bug.cgi?id=144954
3534
3535         Reviewed by Ryosuke Niwa.
3536
3537         * parser/Parser.h:
3538         * parser/Parser.cpp:
3539
3540 2015-05-14  Yusuke Suzuki  <utatane.tea@gmail.com>
3541
3542         REGRESSION (r184337): ASSERT failed in debug builds for tagged templates
3543         https://bugs.webkit.org/show_bug.cgi?id=145013
3544
3545         Reviewed by Filip Pizlo.
3546
3547         Fix the regression introduced by r184337.
3548
3549         1. JSTemporaryRegistryKey::s_info should inherit the Base::s_info,
3550            JSDestructibleObject::s_info.
3551
3552         2. The first register argument of BytecodeGenerator::emitNode
3553            should be a referenced register if it is a temporary register.
3554
3555         * bytecompiler/NodesCodegen.cpp:
3556         (JSC::TaggedTemplateNode::emitBytecode):
3557         * runtime/JSTemplateRegistryKey.cpp:
3558
3559 2015-05-14  Andreas Kling  <akling@apple.com>
3560
3561         String.prototype.split() should create efficient substrings.
3562         <https://webkit.org/b/144985>
3563         <rdar://problem/20949344>
3564
3565         Reviewed by Geoffrey Garen.
3566
3567         Teach split() how to make substring JSStrings instead of relying on StringImpl's
3568         substring sharing mechanism. The optimization works by deferring the construction
3569         of a StringImpl until the substring's value is actually needed.
3570
3571         This knocks ~2MB off of theverge.com by avoiding the extra StringImpl allocations.
3572         Out of ~70000 substrings created by split(), only ~2000 of them get reified.
3573
3574         * runtime/StringPrototype.cpp:
3575         (JSC::jsSubstring):
3576         (JSC::splitStringByOneCharacterImpl):
3577         (JSC::stringProtoFuncSplit):
3578
3579 2015-05-14  Yusuke Suzuki  <utatane.tea@gmail.com>
3580
3581         Change the status of ES6 tagged templates to Done in features.json
3582         https://bugs.webkit.org/show_bug.cgi?id=145003
3583
3584         Reviewed by Benjamin Poulain.
3585
3586         Now it's implemented in r184337.
3587
3588         * features.json:
3589
3590 2015-05-14  Yusuke Suzuki  <utatane.tea@gmail.com>
3591
3592         Introduce SymbolType into SpeculativeTypes
3593         https://bugs.webkit.org/show_bug.cgi?id=142651
3594
3595         Reviewed by Filip Pizlo.
3596
3597         Introduce SpecSymbol type into speculative types.
3598         Previously symbol type is categorized into SpecCellOther.
3599         But SpecCellOther is not intended to be used for such cells.
3600
3601         This patch just introduces SpecSymbol.
3602         It represents the type of target value is definitely the symbol type.
3603         It is the part of SpecCell.
3604
3605         In this patch, we do not introduce SymbolUse tracking.
3606         It will be added in the separate patch.
3607
3608         * bytecode/SpeculatedType.cpp:
3609         (JSC::dumpSpeculation):
3610         (JSC::speculationFromStructure):
3611         * bytecode/SpeculatedType.h:
3612         (JSC::isSymbolSpeculation):
3613         * dfg/DFGAbstractInterpreterInlines.h:
3614         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
3615         * dfg/DFGAbstractValue.cpp:
3616         (JSC::DFG::AbstractValue::setType):
3617         * dfg/DFGConstantFoldingPhase.cpp:
3618         (JSC::DFG::ConstantFoldingPhase::foldConstants):
3619         * tests/stress/typeof-symbol.js: Added.
3620
3621 2015-05-14  Yusuke Suzuki  <utatane.tea@gmail.com>
3622
3623         [ES6] Implement tagged templates
3624         https://bugs.webkit.org/show_bug.cgi?id=143183
3625
3626         Reviewed by Oliver Hunt.
3627
3628         This patch implements ES6 tagged templates.
3629         In tagged templates, the function takes the template object.
3630
3631         The template object contains the raw and cooked template strings,
3632         so when parsing the tagged templates, we need to tokenize the raw and cooked strings.
3633         While tagged templates require the both strings, the template literal only requires
3634         the cooked strings. So when tokenizing under the template literal context,
3635         we only builds the cooked strings.
3636
3637         As per ES6 spec, the template objects for the same raw strings are shared in the same realm.
3638         The template objects is cached. And every time we evaluate the same tagged templates,
3639         the same (cached) template objects are used.
3640         Since the spec freezes this template objects completely,
3641         we cannot attach some properties to it.
3642         So we can say that it behaves as if the template objects are the primitive values (like JSString).
3643         Since we cannot attach properties, the only way to test the identity of the template object is comparing. (===)
3644         As the result, when there is no reference to the template object, we can garbage collect it
3645         because the user has no way to test that the newly created template object does not equal
3646         to the already collected template object.
3647
3648         So, to implement tagged templates, we implement the following components.
3649
3650         1. JSTemplateRegistryKey
3651         It holds the template registry key and it does not exposed to users.
3652         TemplateRegistryKey holds the vector of raw and cooked strings with the pre-computed hash value.
3653         When obtaining the template object for the (statically, a.k.a. at the parsing time) given raw string vectors,
3654         we use this JSTemplateRegistryKey as a key to the map and look up the template object from
3655         TemplateRegistry.
3656         JSTemplateRegistryKey is created at the bytecode compiling time and
3657         stored in the CodeBlock as like as JSString content values.
3658
3659         2. TemplateRegistry
3660         This manages the cached template objects.
3661         It holds the weak map (JSTemplateRegistryKey -> the template object).
3662         The template object is weakly referenced.
3663         So if there is no reference to the template object,
3664         the template object is automatically GC-ed.
3665         When looking up the template object, it searches the cached template object.
3666         If it is found, it is returned to the users.
3667         If there is no cached template objects, it creates the new template object and
3668         stores it with the given template registry key.
3669
3670         * CMakeLists.txt:
3671         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
3672         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
3673         * JavaScriptCore.xcodeproj/project.pbxproj:
3674         * bytecompiler/BytecodeGenerator.cpp:
3675         (JSC::BytecodeGenerator::addTemplateRegistryKeyConstant):
3676         (JSC::BytecodeGenerator::emitGetTemplateObject):
3677         * bytecompiler/BytecodeGenerator.h:
3678         * bytecompiler/NodesCodegen.cpp:
3679         (JSC::TaggedTemplateNode::emitBytecode):
3680         (JSC::TemplateLiteralNode::emitBytecode): Deleted.
3681         * parser/ASTBuilder.h:
3682         (JSC::ASTBuilder::createTaggedTemplate):
3683         (JSC::ASTBuilder::createTemplateLiteral): Deleted.
3684         * parser/Lexer.cpp:
3685         (JSC::Lexer<T>::setCode):
3686         (JSC::Lexer<T>::parseTemplateLiteral):
3687         (JSC::Lexer<T>::lex):
3688         (JSC::Lexer<T>::scanTrailingTemplateString):
3689         (JSC::Lexer<T>::clear):
3690         * parser/Lexer.h:
3691         (JSC::Lexer<T>::makeEmptyIdentifier):
3692         * parser/NodeConstructors.h:
3693         (JSC::TaggedTemplateNode::TaggedTemplateNode):
3694         (JSC::TemplateLiteralNode::TemplateLiteralNode): Deleted.
3695         * parser/Nodes.h:
3696         (JSC::TemplateLiteralNode::templateStrings):
3697         (JSC::TemplateLiteralNode::templateExpressions):
3698         (JSC::TaggedTemplateNode::templateLiteral):
3699         * parser/Parser.cpp:
3700         (JSC::Parser<LexerType>::parseTemplateString):
3701         (JSC::Parser<LexerType>::parseTemplateLiteral):
3702         (JSC::Parser<LexerType>::parsePrimaryExpression):
3703         (JSC::Parser<LexerType>::parseMemberExpression):
3704         * parser/Parser.h:
3705         * parser/ParserArena.h:
3706         (JSC::IdentifierArena::makeEmptyIdentifier):
3707         * parser/SyntaxChecker.h:
3708         (JSC::SyntaxChecker::createTaggedTemplate):
3709         (JSC::SyntaxChecker::createTemplateLiteral): Deleted.
3710         * runtime/CommonIdentifiers.h:
3711         * runtime/JSGlobalObject.cpp:
3712         (JSC::getTemplateObject):
3713         (JSC::JSGlobalObject::JSGlobalObject):
3714         (JSC::JSGlobalObject::init):
3715         * runtime/JSGlobalObject.h:
3716         (JSC::JSGlobalObject::templateRegistry):
3717         * runtime/JSTemplateRegistryKey.cpp: Added.
3718         (JSC::JSTemplateRegistryKey::JSTemplateRegistryKey):
3719         (JSC::JSTemplateRegistryKey::create):
3720         (JSC::JSTemplateRegistryKey::destroy):
3721         * runtime/JSTemplateRegistryKey.h: Added.
3722         * runtime/ObjectConstructor.cpp:
3723         (JSC::objectConstructorFreeze):
3724         * runtime/ObjectConstructor.h:
3725         * runtime/TemplateRegistry.cpp: Added.
3726         (JSC::TemplateRegistry::TemplateRegistry):
3727         (JSC::TemplateRegistry::getTemplateObject):
3728         * runtime/TemplateRegistry.h: Added.
3729         * runtime/TemplateRegistryKey.h: Added.
3730         (JSC::TemplateRegistryKey::isDeletedValue):
3731         (JSC::TemplateRegistryKey::isEmptyValue):
3732         (JSC::TemplateRegistryKey::hash):
3733         (JSC::TemplateRegistryKey::rawStrings):
3734         (JSC::TemplateRegistryKey::cookedStrings):
3735         (JSC::TemplateRegistryKey::operator==):
3736         (JSC::TemplateRegistryKey::operator!=):
3737         (JSC::TemplateRegistryKey::Hasher::hash):
3738         (JSC::TemplateRegistryKey::Hasher::equal):
3739         (JSC::TemplateRegistryKey::TemplateRegistryKey):
3740         * runtime/VM.cpp:
3741         (JSC::VM::VM):
3742         * runtime/VM.h:
3743         * tests/stress/tagged-templates-identity.js: Added.
3744         (shouldBe):
3745         * tests/stress/tagged-templates-raw-strings.js: Added.
3746         (shouldBe):
3747         (tag):
3748         (testEval):
3749         * tests/stress/tagged-templates-syntax.js: Added.
3750         (tag):
3751         (testSyntax):
3752         (testSyntaxError):
3753         * tests/stress/tagged-templates-template-object.js: Added.
3754         (shouldBe):
3755         (tag):
3756         * tests/stress/tagged-templates-this.js: Added.
3757         (shouldBe):
3758         (tag):
3759         * tests/stress/tagged-templates.js: Added.
3760         (shouldBe):
3761         (raw):
3762         (cooked):
3763         (Counter):
3764
3765 2015-05-13  Ryosuke Niwa  <rniwa@webkit.org>
3766
3767         REGRESSION(r180595): same-callee profiling no longer works
3768         https://bugs.webkit.org/show_bug.cgi?id=144787
3769
3770         Reviewed by Filip Pizlo.
3771
3772         This patch introduces a DFG optimization to use NewObject node when the callee of op_create_this is
3773         always the same JSFunction. This condition doesn't hold when the byte code creates multiple
3774         JSFunction objects at runtime as in: function y() { return function () {} }; new y(); new y();
3775
3776         To enable this optimization, LLint and baseline JIT now store the last callee we saw in the newly
3777         added fourth operand of op_create_this. We use this JSFunction's structure in DFG after verifying
3778         our speculation that the callee is the same. To avoid recompiling the same code for different callee
3779         objects in the polymorphic case, the special value of seenMultipleCalleeObjects() is set in
3780         LLint and baseline JIT when multiple callees are observed.
3781
3782         Tests: stress/create-this-with-callee-variants.js
3783
3784         * bytecode/BytecodeList.json: Increased the number of operands to 5.
3785         * bytecode/CodeBlock.cpp:
3786         (JSC::CodeBlock::dumpBytecode): Dump the newly added callee cache.
3787         (JSC::CodeBlock::finalizeUnconditionally): Clear the callee cache if the callee is no longer alive.
3788         * bytecompiler/BytecodeGenerator.cpp:
3789         (JSC::BytecodeGenerator::emitCreateThis): Add the instruction to propertyAccessInstructions so that
3790         we can clear the callee cache in CodeBlock::finalizeUnconditionally. Also initialize the newly added
3791         operand.
3792         * dfg/DFGByteCodeParser.cpp:
3793         (JSC::DFG::ByteCodeParser::parseBlock): Implement the optimization. Speculate the actual callee to
3794         match the cache. Use the cached callee's structure if the speculation succeeds. Otherwise, OSR exit.
3795         * jit/JITOpcodes.cpp:
3796         (JSC::JIT::emit_op_create_this): Go to the slow path to update the cache unless it's already marked
3797         as seenMultipleCalleeObjects() to indicate the polymorphic behavior and/or we've OSR exited here.
3798         (JSC::JIT::emitSlow_op_create_this):
3799         * jit/JITOpcodes32_64.cpp:
3800         (JSC::JIT::emit_op_create_this): Ditto.
3801         (JSC::JIT::emitSlow_op_create_this):
3802         * llint/LowLevelInterpreter32_64.asm:
3803         (_llint_op_create_this): Ditto.
3804         * llint/LowLevelInterpreter64.asm:
3805         (_llint_op_create_this): Ditto.
3806         * runtime/CommonSlowPaths.cpp:
3807         (slow_path_create_this): Set the callee cache to the actual callee if it's not set. If the cache has
3808         been set to a JSFunction* different from the actual callee, set it to seenMultipleCalleeObjects().
3809         * runtime/JSCell.h:
3810         (JSC::JSCell::seenMultipleCalleeObjects): Added.
3811         * runtime/WriteBarrier.h:
3812         (JSC::WriteBarrierBase::unvalidatedGet): Removed the compile guard around it.
3813         * tests/stress/create-this-with-callee-variants.js: Added.
3814
3815 2015-05-13  Joseph Pecoraro  <pecoraro@apple.com>
3816
3817         Clean up some possible RefPtr to PassRefPtr churn
3818         https://bugs.webkit.org/show_bug.cgi?id=144779
3819
3820         Reviewed by Darin Adler.
3821
3822         * runtime/GenericTypedArrayViewInlines.h:
3823         (JSC::GenericTypedArrayView<Adaptor>::create):
3824         (JSC::GenericTypedArrayView<Adaptor>::createUninitialized):
3825         * runtime/JSArrayBufferConstructor.cpp:
3826         (JSC::constructArrayBuffer):
3827         * runtime/Structure.cpp:
3828         (JSC::Structure::toStructureShape):
3829         * runtime/TypedArrayBase.h:
3830         (JSC::TypedArrayBase::create):
3831         (JSC::TypedArrayBase::createUninitialized):
3832         * tools/FunctionOverrides.cpp:
3833         (JSC::initializeOverrideInfo):
3834         Release the last use of a RefPtr as it is passed on.
3835
3836 2015-05-13  Joseph Pecoraro  <pecoraro@apple.com>
3837
3838         ES6: Allow duplicate property names
3839         https://bugs.webkit.org/show_bug.cgi?id=142895
3840
3841         Reviewed by Geoffrey Garen.
3842
3843         Introduce new `op_put_getter_by_id` and `op_put_setter_by_id` opcodes
3844         that will define a single getter or setter property on an object.
3845
3846         The existing `op_put_getter_setter` opcode is still preferred for
3847         putting both a getter and setter at the same time but cannot be used
3848         for putting an individual getter or setter which is needed in
3849         some cases.
3850
3851         Add a new slow path when generating bytecodes for a property list
3852         with computed properties, as computed properties are the only time
3853         the list of properties cannot be determined statically.
3854
3855         * bytecompiler/NodesCodegen.cpp:
3856         (JSC::PropertyListNode::emitBytecode):
3857         - fast path for all constant properties
3858         - slow but paired getter/setter path if there are no computed properties
3859         - slow path, individual put operation for every property, if there are computed properties
3860
3861         * parser/Nodes.h:
3862         Distinguish a Computed property from a Constant property.
3863
3864         * parser/Parser.cpp:
3865         (JSC::Parser<LexerType>::parseProperty):
3866         (JSC::Parser<LexerType>::parsePropertyMethod):
3867         Distingish Computed and Constant properties.
3868
3869         (JSC::Parser<LexerType>::parseObjectLiteral):
3870         When we drop into strict mode it is because we saw a getter
3871         or setter, so be more explicit.
3872
3873         (JSC::Parser<LexerType>::parseStrictObjectLiteral):
3874         Eliminate duplicate property syntax error exception.
3875
3876         * parser/SyntaxChecker.h:
3877         (JSC::SyntaxChecker::getName):
3878         * parser/ASTBuilder.h:
3879         (JSC::ASTBuilder::getName): Deleted.
3880         No longer used.
3881
3882         * runtime/JSObject.h:
3883         (JSC::JSObject::putDirectInternal):
3884         When updating a property. If the Accessor attribute changed
3885         update the Structure.
3886
3887         * runtime/JSObject.cpp:
3888         (JSC::JSObject::putGetter):
3889         (JSC::JSObject::putSetter):
3890         Called by the opcodes, just perform the same operation that
3891         __defineGetter__ or __defineSetter__ would do.
3892
3893         (JSC::JSObject::putDirectNonIndexAccessor):
3894         This transition is now handled in putDirectInternal.
3895
3896         * runtime/Structure.h:
3897         Add needed export.
3898
3899         * bytecode/BytecodeList.json:
3900         * bytecode/BytecodeUseDef.h:
3901         (JSC::computeUsesForBytecodeOffset):
3902         (JSC::computeDefsForBytecodeOffset):
3903         * bytecode/CodeBlock.cpp:
3904         (JSC::CodeBlock::dumpBytecode):
3905         * bytecompiler/BytecodeGenerator.cpp:
3906         (JSC::BytecodeGenerator::emitPutGetterById):
3907         (JSC::BytecodeGenerator::emitPutSetterById):
3908         * bytecompiler/BytecodeGenerator.h:
3909         * jit/JIT.cpp:
3910         (JSC::JIT::privateCompileMainPass):
3911         * jit/JIT.h:
3912         * jit/JITInlines.h:
3913         (JSC::JIT::callOperation):
3914         * jit/JITOperations.cpp:
3915         * jit/JITOperations.h:
3916         * jit/JITPropertyAccess.cpp:
3917         (JSC::JIT::emit_op_put_getter_by_id):
3918         (JSC::JIT::emit_op_put_setter_by_id):
3919         * jit/JITPropertyAccess32_64.cpp:
3920         (JSC::JIT::emit_op_put_getter_by_id):
3921         (JSC::JIT::emit_op_put_setter_by_id):
3922         * llint/LLIntSlowPaths.cpp:
3923         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
3924         * llint/LLIntSlowPaths.h:
3925         * llint/LowLevelInterpreter.asm:
3926         New bytecodes. Modelled after existing op_put_getter_setter.
3927
3928 2015-05-13  Filip Pizlo  <fpizlo@apple.com>
3929
3930         Creating a new blank document in icloud pages causes an AI error: Abstract value (CellBytecodedoubleBoolOther, TOP, TOP) for double node has type outside SpecFullDouble.