Source/JavaScriptCore:
[WebKit-https.git] / Source / JavaScriptCore / ChangeLog
1 2015-06-24  Doug Russell  <d_russell@apple.com>
2
3         Bug 146177 - AX: AXObjectCache should try to use an unignored accessibilityObject 
4         when posting a selection notification when on the border between two accessibilityObjects
5         https://bugs.webkit.org/show_bug.cgi?id=146177
6
7         Add an adopt() function to simplify JSRetainPtr<JSStringRef> { Adopt, string } to adopt(string).
8
9         Reviewed by Darin Adler.
10
11         * API/JSRetainPtr.h:
12         (adopt):
13
14 2015-06-24  Keith Miller  <keith_miller@apple.com>
15
16         Strict Equality on objects should only check that one of the two sides is an object.
17         https://bugs.webkit.org/show_bug.cgi?id=145992
18
19         This patch adds a new optimization for checking strict equality on objects.
20         If we speculate that a strict equality comparison has an object on one side
21         we only need to type check that side. Equality is then determined by a pointer
22         comparison between the two values (although in the 32-bit case we must also check
23         that the other side is a cell). Once LICM hoists type checks out of a loop we
24         can be cleverer about how we choose the operand we type check if both are
25         speculated to be objects.
26
27         For testing I added the addressOf function, which returns the address
28         of a Cell to the runtime.
29
30         Reviewed by Mark Lam.
31
32         * dfg/DFGFixupPhase.cpp:
33         (JSC::DFG::FixupPhase::fixupNode):
34         * dfg/DFGSpeculativeJIT.cpp:
35         (JSC::DFG::SpeculativeJIT::compileStrictEq):
36         * dfg/DFGSpeculativeJIT.h:
37         * dfg/DFGSpeculativeJIT32_64.cpp:
38         (JSC::DFG::SpeculativeJIT::compileObjectStrictEquality):
39         (JSC::DFG::SpeculativeJIT::compilePeepHoleObjectStrictEquality):
40         * dfg/DFGSpeculativeJIT64.cpp:
41         (JSC::DFG::SpeculativeJIT::compileObjectStrictEquality):
42         (JSC::DFG::SpeculativeJIT::compilePeepHoleObjectStrictEquality):
43         * ftl/FTLCapabilities.cpp:
44         (JSC::FTL::canCompile):
45         * ftl/FTLLowerDFGToLLVM.cpp:
46         (JSC::FTL::DFG::LowerDFGToLLVM::compileCompareStrictEq):
47         * jsc.cpp:
48         (GlobalObject::finishCreation):
49         (functionAddressOf):
50         * tests/stress/equality-type-checking.js: Added.
51         (Foo):
52         (checkStrictEq):
53         (checkStrictEqOther):
54
55 2015-06-24  Mark Lam  <mark.lam@apple.com>
56
57         Fixed assertion in JSStringJoiner::join() (regression from r185899).
58
59         Not reviewed.
60
61         JSStringJoiner did not account for the case where the array being joined can
62         have null or undefined elements.  As a result, its size may be less than
63         its initially reserved capacity (which was estimated based on the array length).
64
65         * runtime/JSStringJoiner.cpp:
66         (JSC::JSStringJoiner::join):
67
68 2015-06-24  Darin Adler  <darin@apple.com>
69
70         Fix Array.concat with RuntimeArray (regression from my last patch)
71
72         * runtime/ArrayPrototype.cpp:
73         (JSC::arrayProtoFuncConcat): Use getLength instead of JSArray::length.
74
75         * runtime/JSArray.cpp:
76         (JSC::JSArray::defineOwnProperty): Added comment about use of
77         JSArray::length here that is incorrect (in a really non-obvious way).
78         (JSC::JSArray::fillArgList): Ditto.
79         (JSC::JSArray::copyToArguments): Ditto.
80
81         * runtime/JSArray.h: Added a comment explaining that it is not always
82         safe to use JSArray::length.
83
84 2015-06-23  Mark Lam  <mark.lam@apple.com>
85
86         Gardening: Fixing 2 bad asserts from r185889.
87         https://bugs.webkit.org/show_bug.cgi?id=140575
88
89         Not reviewed.
90
91         * runtime/JSBoundSlotBaseFunction.cpp:
92         (JSC::JSBoundSlotBaseFunction::finishCreation):
93
94 2015-06-23  Dan Bernstein  <mitz@apple.com>
95
96         Fixed iOS production builds.
97
98         * JavaScriptCore.xcodeproj/project.pbxproj:
99
100 2015-06-22  Darin Adler  <darin@apple.com>
101
102         Make Array.join work directly on substrings without reifying them
103         https://bugs.webkit.org/show_bug.cgi?id=146191
104
105         Reviewed by Andreas Kling.
106
107         Besides the Array.join change, this has other optimizations based on
108         profiling the Peacekeeper array benchmark.
109
110         I measured a 14% speed improvement in the Peacekeeper array benchmark.
111
112         Still a lot of low hanging fruit in that test because so many of functions
113         on the array prototype are not optimizing for simple cases. For example,
114         the reverse function does individual get and put calls even when the array
115         is entirely made up of integers in contiguous storage.
116
117         * runtime/ArrayPrototype.cpp:
118         (JSC::getProperty): Use tryGetIndexQuickly first before getPropertySlot.
119         (JSC::argumentClampedIndexFromStartOrEnd): Marked inline.
120         (JSC::shift): Use the getProperty helper in this file instead of using
121         getPropertySlot. Use putByIndexInline instead of calling putByIndex directly.
122         In both cases this can yield a faster code path.
123         (JSC::unshift): Ditto.
124         (JSC::arrayProtoFuncToString): Updated to use the new JSStringJoiner
125         interface. Changed local variable name to thisArray since it's not a
126         JSObject*. Changed loop index to i instead of k.
127         (JSC::arrayProtoFuncToLocaleString): Updated to use the new JSStringJoiner
128         interface. Renamed thisObj to thisObject. Added a missing exception check
129         after the toLocaleString function is called, but before toString is called
130         the result of that function.
131         (JSC::arrayProtoFuncJoin): Updated to use the new JSStringJointer interface.
132         Added a missing exception check after calling toString on the separator
133         but before calling get to get the first element in the array-like object
134         being joined. Changed loop index to i instead of k. Added missing exception
135         check after calling toString on each string from the array before calling
136         get for the next element.
137         (JSC::arrayProtoFuncConcat): Use JSArray::length instead of using the
138         getLength function.
139         (JSC::arrayProtoFuncReverse): Ditto. Also use putByIndexInline.
140         (JSC::arrayProtoFuncShift): Ditto.
141         (JSC::arrayProtoFuncSplice): Use getIndex instead of get, which includes some
142         additional optimizations.
143         (JSC::getOrHole): Deleted. Unused function.
144         (JSC::arrayProtoFuncUnShift): Use putByIndexInline.
145
146         * runtime/ExceptionHelpers.cpp:
147         (JSC::errorDescriptionForValue): Removed the duplicate copy of the the logic
148         from JSValue::toString.
149
150         * runtime/JSCJSValue.cpp:
151         (JSC::JSValue::toStringSlowCase): Improved the performance when converting a
152         small integer to a single character string.
153         (JSC::JSValue::toWTFStringSlowCase): Moved the contents of the
154         inlineJSValueNotStringtoString function here.
155         * runtime/JSCJSValue.h: Removed no longer used toWTFStringInline and fixed
156         a comment with a typo.
157
158         * runtime/JSObject.h:
159         (JSC::JSObject::putByIndexInline): Marked ALWAYS_INLINE because this was not
160         getting inlined at some call sites.
161         (JSC::JSObject::indexingData): Deleted. Unused function.
162         (JSC::JSObject::currentIndexingData): Deleted. Unused function.
163         (JSC::JSObject::getHolyIndexQuickly): Deleted. Unused function.
164         (JSC::JSObject::relevantLength): Deleted. Unused function.
165         (JSC::JSObject::currentRelevantLength): Deleted. Unused function.
166
167         * runtime/JSString.h: Added the StringViewWithUnderlyingString struct and
168         the viewWithUnderlyingString function. Removed the inlineJSValueNotStringtoString
169         and toWTFStringInline functions.
170
171         * runtime/JSStringJoiner.cpp:
172         (JSC::appendStringToData): Changed this to be a template instead of writing
173         it out, since StringView::getCharactersWithUpconvert does almsot exactly what
174         this function was trying to do.
175         (JSC::joinStrings): Rewrote this to use StringView.
176         (JSC::JSStringJoiner::joinedLength): Added. Factored out from the join function.
177         (JSC::JSStringJoiner::join): Rewrote to make it a bit simpler. Added an assertion
178         that we entirely filled capacity, since we are now reserving capacity and using
179         uncheckedAppend. Use String instead of RefPtr<StringImpl> because there was no
180         particular value to using the impl directly.
181
182         * runtime/JSStringJoiner.h: Changed the interface to the class to use StringView.
183         Also changed this class so it now has the responsibility to convert each JSValue
184         into a string. This let us share more code between toString and join, and also
185         lets us use the new viewWithUnderlyingString function, which could be confusing at
186         all the call sites, but is easier to understand here.
187
188 2015-06-23  Matthew Mirman  <mmirman@apple.com>
189
190         Completes native binding descriptors with native getters and potentially setters.
191         https://bugs.webkit.org/show_bug.cgi?id=140575
192         rdar://problem/19506502
193
194         Reviewed by Mark Lam.
195
196         * CMakeLists.txt:  Added JSBoundSlotBaseFunction.cpp
197         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
198         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
199         * JavaScriptCore.xcodeproj/project.pbxproj:
200         * inspector/InjectedScriptSource.js: Added case for descriptor having a native getter.
201         * runtime/JSBoundSlotBaseFunction.cpp: Added.
202         (JSC::boundSlotBaseFunctionCall):
203         (JSC::JSBoundSlotBaseFunction::JSBoundSlotBaseFunction):  
204         Necessary wrapper for custom getters and setters as objects.
205         (JSC::JSBoundSlotBaseFunction::create):
206         (JSC::JSBoundSlotBaseFunction::visitChildren):
207         (JSC::JSBoundSlotBaseFunction::finishCreation):
208         * runtime/JSBoundSlotBaseFunction.h: Added.
209         (JSC::JSBoundSlotBaseFunction::createStructure):
210         (JSC::JSBoundSlotBaseFunction::boundSlotBase):
211         (JSC::JSBoundSlotBaseFunction::customGetterSetter):
212         (JSC::JSBoundSlotBaseFunction::isGetter):
213         * runtime/JSGlobalObject.cpp:
214         (JSC::JSGlobalObject::init): Added a globally initialized structure for JSBoundSlotBaseFunction
215         (JSC::JSGlobalObject::visitChildren): visits that structure
216         * runtime/JSGlobalObject.h:
217         (JSC::JSGlobalObject::boundSlotBaseFunctionStructure): added a getter for that structure
218         * runtime/JSObject.cpp:
219         (JSC::JSObject::getOwnPropertyDescriptor): extends the case for CustomGetterSetter to 
220         actually include GetterSetter as a JSBoundSlotBaseFunction
221         * runtime/VM.cpp: Added initializer for customGetterSetterFunctionMap
222         * runtime/VM.h: Added cache for JSBoundSlotBaseFunction
223
224 2015-06-22  Yusuke Suzuki  <utatane.tea@gmail.com>
225
226         [ES6] Allow trailing comma in ArrayBindingPattern and ObjectBindingPattern
227         https://bugs.webkit.org/show_bug.cgi?id=146192
228
229         Reviewed by Darin Adler.
230
231         According to the ES6 spec, trailing comma in ArrayBindingPattern and ObjectBindingPattern is allowed.
232         And empty ArrayBindingPattern and ObjectBindingPattern is also allowed.
233
234         This patch allows trailing comma and empty binding patterns.
235
236         * bytecompiler/NodesCodegen.cpp:
237         (JSC::ArrayPatternNode::bindValue):
238         * parser/Parser.cpp:
239         (JSC::Parser<LexerType>::parseDeconstructionPattern):
240         * tests/stress/trailing-comma-in-patterns.js: Added.
241         (shouldBe):
242         (iterator):
243
244 2015-06-20  Yusuke Suzuki  <utatane.tea@gmail.com>
245
246         [ES6] Destructuring assignment need to accept iterables
247         https://bugs.webkit.org/show_bug.cgi?id=144111
248
249         Reviewed by Darin Adler.
250
251         This patch makes that destructuring assignments to array binding patterns accept iterables.
252         Previously, it just access the indexed properties.
253         After this patch, it iterates the given value by using ES6 iterator protocol.
254
255         The iteration becomes different from the for-of case.
256         1. Since there's no break/continue case, finally scope is not necessary.
257         2. When the error is raised, the close status of the iterator becomes true. So IteratorClose is not called for that.
258         3. Since the array binding patterns requires a limited count of iterations (if there is no rest(...rest) case), IteratorClose is called when the iteration does not consume the all values of the iterator.
259         4. Since the array binding patterns requires a specified count of iterations, iterator's next call is skipped when iterator becomes closed.
260
261         * bytecompiler/BytecodeGenerator.cpp:
262         (JSC::BytecodeGenerator::emitIteratorClose):
263         * bytecompiler/BytecodeGenerator.h:
264         * bytecompiler/NodesCodegen.cpp:
265         (JSC::ArrayPatternNode::bindValue):
266         * parser/ASTBuilder.h:
267         (JSC::ASTBuilder::finishArrayPattern):
268         * parser/Nodes.h:
269         * parser/Parser.cpp:
270         (JSC::Parser<LexerType>::parseDeconstructionPattern):
271         * parser/SyntaxChecker.h:
272         (JSC::SyntaxChecker::operatorStackPop):
273         * tests/stress/destructuring-assignment-accepts-iterables.js: Added.
274         (shouldBe):
275         (shouldThrow):
276         (.set shouldThrow):
277
278 2015-06-19  Devin Rousso  <drousso@apple.com>
279
280         Web Inspector: Highlight currently edited CSS selector
281         https://bugs.webkit.org/show_bug.cgi?id=145658
282
283         Reviewed by Joseph Pecoraro.
284
285         * inspector/protocol/DOM.json: Added highlightSelector to show highlight over multiple nodes.
286
287 2015-06-19  Mark Lam  <mark.lam@apple.com>
288
289         Gardening: fix build for EWS bots.
290
291         Not reviewed.
292
293         * runtime/JSArray.cpp:
294         (JSC::JSArray::setLengthWithArrayStorage):
295
296 2015-06-19  Michael Saboff  <msaboff@apple.com>
297
298         Crash in com.apple.WebKit.WebContent at com.apple.JavaScriptCore: JSC::FTL::fixFunctionBasedOnStackMaps + 17225
299         https://bugs.webkit.org/show_bug.cgi?id=146133
300
301         Reviewed by Geoffrey Garen.
302
303         When generating code to put in inline caching areas, if there isn't enough space,
304         then create and link to an out of line area.  We connect the inline code to this
305         out of line code area by planting a jump from the inline area to the out of line
306         code and appending a jump at the end of the out of line code bck to the instruction
307         following the inline area.  We fill the unused inline area with nops, primarily to 
308         ensure the disassembler doesn't get confused.
309
310         * ftl/FTLCompile.cpp:
311         (generateInlineIfPossibleOutOfLineIfNot): New function that determines if there is enough space
312         in the inline code area for the code to link.  If so, it links inline, otherwise it links the
313         code out of line and plants appropriate jumps to/from the out of line code.
314         (generateICFastPath):
315         (generateCheckInICFastPath):
316         (fixFunctionBasedOnStackMaps):
317         Use generateInlineIfPossibleOutOfLineIfNot() to link code intended for inline cache space.
318
319         * ftl/FTLJITFinalizer.cpp:
320         (JSC::FTL::JITFinalizer::finalizeFunction):
321         * ftl/FTLJITFinalizer.h:
322         (JSC::FTL::OutOfLineCodeInfo::OutOfLineCodeInfo):
323         Added code to finalize any out of line LinkBuffer created by generateInlineIfPossibleOutOfLineIfNot().
324
325 2015-06-19  Geoffrey Garen  <ggaren@apple.com>
326
327         WebKit crash while loading nytimes at JavaScriptCore: JSC::ExecutableAllocator::allocate + 276
328         https://bugs.webkit.org/show_bug.cgi?id=146163
329         <rdar://problem/20392986>
330
331         Reviewed by Michael Saboff.
332
333         There's no good way to test this in our test harness because we don't
334         have a way to simulate executable memory pressure, and doing so would
335         cause the cases that still use JITCompilationMustSucceed to crash.
336
337         Instead, I tested by manually forcing all regexp JIT compilation to
338         fail and running the JavaScriptCore tests.
339
340         * yarr/YarrJIT.cpp:
341         (JSC::Yarr::YarrGenerator::compile): Allow compilation to fail. We can
342         fall back to the regexp interpreter if we need to.
343
344 2015-06-19  Mark Lam  <mark.lam@apple.com>
345
346         Employ explicit operator bool() instead of using the UnspecifiedBoolType workaround.
347         https://bugs.webkit.org/show_bug.cgi?id=146154
348
349         Reviewed by Darin Adler.
350
351         * assembler/MacroAssemblerCodeRef.h:
352         (JSC::MacroAssemblerCodePtr::dataLocation):
353         (JSC::MacroAssemblerCodePtr::operator bool):
354         (JSC::MacroAssemblerCodePtr::operator==):
355         (JSC::MacroAssemblerCodeRef::tryToDisassemble):
356         (JSC::MacroAssemblerCodeRef::operator bool):
357         (JSC::MacroAssemblerCodeRef::dump):
358         (JSC::MacroAssemblerCodePtr::operator UnspecifiedBoolType*): Deleted.
359         (JSC::MacroAssemblerCodeRef::operator UnspecifiedBoolType*): Deleted.
360
361         * bytecode/CodeOrigin.cpp:
362         (JSC::CodeOrigin::isApproximatelyEqualTo):
363         - Fixed a bug here where we were expecting to compare Executable pointers, but
364           ended up comparing a (UnspecifiedBoolType*)1 with another
365           (UnspecifiedBoolType*)1.
366
367         * bytecode/LLIntCallLinkInfo.h:
368         (JSC::LLIntCallLinkInfo::~LLIntCallLinkInfo):
369         (JSC::LLIntCallLinkInfo::isLinked):
370         (JSC::LLIntCallLinkInfo::unlink):
371         * dfg/DFGBlockWorklist.h:
372         (JSC::DFG::BlockWith::BlockWith):
373         (JSC::DFG::BlockWith::operator bool):
374         (JSC::DFG::BlockWithOrder::BlockWithOrder):
375         (JSC::DFG::BlockWithOrder::operator bool):
376         (JSC::DFG::BlockWith::operator UnspecifiedBoolType*): Deleted.
377         (JSC::DFG::BlockWithOrder::operator UnspecifiedBoolType*): Deleted.
378         * dfg/DFGIntegerRangeOptimizationPhase.cpp:
379         * dfg/DFGLazyNode.h:
380         (JSC::DFG::LazyNode::operator!):
381         (JSC::DFG::LazyNode::operator bool):
382         (JSC::DFG::LazyNode::operator UnspecifiedBoolType*): Deleted.
383         * heap/CopyWriteBarrier.h:
384         (JSC::CopyWriteBarrier::operator!):
385         (JSC::CopyWriteBarrier::operator bool):
386         (JSC::CopyWriteBarrier::get):
387         (JSC::CopyWriteBarrier::operator UnspecifiedBoolType*): Deleted.
388         * heap/Handle.h:
389         (JSC::HandleBase::operator!):
390         (JSC::HandleBase::operator bool):
391         (JSC::HandleBase::slot):
392         (JSC::HandleBase::operator UnspecifiedBoolType*): Deleted.
393         * heap/Strong.h:
394         (JSC::Strong::operator!):
395         (JSC::Strong::operator bool):
396         (JSC::Strong::swap):
397         (JSC::Strong::operator UnspecifiedBoolType*): Deleted.
398         * jit/JITWriteBarrier.h:
399         (JSC::JITWriteBarrierBase::operator bool):
400         (JSC::JITWriteBarrierBase::operator!):
401         (JSC::JITWriteBarrierBase::setFlagOnBarrier):
402         (JSC::JITWriteBarrierBase::operator UnspecifiedBoolType*): Deleted.
403         * runtime/JSArray.cpp:
404         (JSC::JSArray::setLengthWithArrayStorage):
405         * runtime/JSCJSValue.h:
406         * runtime/JSCJSValueInlines.h:
407         (JSC::JSValue::JSValue):
408         (JSC::JSValue::operator bool):
409         (JSC::JSValue::operator==):
410         (JSC::JSValue::operator UnspecifiedBoolType*): Deleted.
411         * runtime/JSObject.h:
412         (JSC::JSObject::hasSparseMap):
413         * runtime/PropertyDescriptor.h:
414         (JSC::PropertyDescriptor::writablePresent):
415         (JSC::PropertyDescriptor::enumerablePresent):
416         (JSC::PropertyDescriptor::configurablePresent):
417         (JSC::PropertyDescriptor::setterPresent):
418         (JSC::PropertyDescriptor::getterPresent):
419         * runtime/WriteBarrier.h:
420         (JSC::WriteBarrierBase::slot):
421         (JSC::WriteBarrierBase::operator bool):
422         (JSC::WriteBarrierBase::operator!):
423         (JSC::WriteBarrierBase<Unknown>::tagPointer):
424         (JSC::WriteBarrierBase<Unknown>::payloadPointer):
425         (JSC::WriteBarrierBase<Unknown>::operator bool):
426         (JSC::WriteBarrierBase<Unknown>::operator!):
427         (JSC::WriteBarrierBase::operator UnspecifiedBoolType*): Deleted.
428         (JSC::WriteBarrierBase<Unknown>::operator UnspecifiedBoolType*): Deleted.
429
430 2015-06-19  Anders Carlsson  <andersca@apple.com>
431
432         Add a JSC symlink in /System/Library/PrivateFrameworks
433         https://bugs.webkit.org/show_bug.cgi?id=146158
434         rdar://problem/21465968
435
436         Reviewed by Dan Bernstein.
437
438         * JavaScriptCore.xcodeproj/project.pbxproj:
439
440 2015-06-19  Joseph Pecoraro  <pecoraro@apple.com>
441
442         Web Inspector: Avoid getOwnPropertyNames/Symbols on very large lists
443         https://bugs.webkit.org/show_bug.cgi?id=146141
444
445         Reviewed by Timothy Hatcher.
446
447         * inspector/InjectedScriptSource.js:
448         (InjectedScript.prototype._propertyDescriptors):
449         Avoid calling getOwnPropertyNames/Symbols on very large lists. Instead
450         just generate property descriptors for the first 100 indexes. Note
451         this would behave poorly for sparse arrays with a length > 100, but
452         general support for lists with more than 100 elements is poor. See:
453         <https://webkit.org/b/143589> Web Inspector: Better handling for large collections in Object Trees
454
455 2015-06-18  Yusuke Suzuki  <utatane.tea@gmail.com>
456
457         [DFG] Avoid OSR exit in the middle of string concatenation
458         https://bugs.webkit.org/show_bug.cgi?id=145820
459
460         Reviewed by Filip Pizlo.
461
462         DFG attempt to compile ValueAdd with String type into MakeRope(left, ToString(ToPrimitive(right))).
463
464         So when right is speculated as SpecObject, ToPrimitive(SpecObject) is speculated as SpecString.
465         It leads ToString to become Identity with a speculated type check.
466
467         However, ToPrimitive and ToString are originated from the same bytecode. And ToPrimitive may have
468         an observable side effect when the given parameter is an object (calling object.{toString,valueOf}).
469
470         So when object.toString() returns a number (it is allowed in the ES spec), ToPrimitive performs
471         observable `object.toString()` calling. But ToString is converted into a speculated type check for
472         SpecString and it raises OSR exit. And we exit to the original ValueAdd's bytecode position and
473         it redundantly performs an observable ToPrimitive execution.
474
475         To fix this, this patch avoid fixing up for newly introduced ToString node.
476         Since fix up phase is not iterated repeatedly, by avoiding fixing up when generating the node,
477         we can avoid conversion from ToString to Check.
478
479         * dfg/DFGFixupPhase.cpp:
480         (JSC::DFG::FixupPhase::attemptToMakeFastStringAdd):
481         * tests/stress/toprimitive-speculated-types.js: Added.
482         (shouldBe):
483         (raw):
484         (Counter):
485
486 2015-06-18  Brian J. Burg  <burg@cs.washington.edu>
487
488         Web Inspector: improve generated types for objects passed to backend commands
489         https://bugs.webkit.org/show_bug.cgi?id=146091
490
491         Reviewed by Joseph Pecoraro.
492
493         The main change is that objects passed in will have a type like const T& or const T*,
494         rather than const RefPtr<T>&&. These protocol objects are owned by the generated dispatcher
495         methods and only exist to pass data to backend command implementations. So, there is no
496         reason for callees to add a reference or take ownership of these inputs.
497
498         Some small improvements were made in the code generator to standardize how these
499         expressions are generated for parameters. Optional in parameters are now prefixed with
500         'opt_in_' to make the generated method signatures and implementations clearer.
501
502         * inspector/InspectorValues.cpp:
503         (Inspector::InspectorArrayBase::get): Add const qualifier.
504         * inspector/InspectorValues.h:
505         * inspector/agents/InspectorDebuggerAgent.cpp:
506         (Inspector::InspectorDebuggerAgent::setBreakpointByUrl):
507         (Inspector::parseLocation):
508         (Inspector::InspectorDebuggerAgent::setBreakpoint):
509         (Inspector::InspectorDebuggerAgent::continueToLocation):
510         * inspector/agents/InspectorDebuggerAgent.h:
511         * inspector/agents/InspectorRuntimeAgent.cpp:
512         (Inspector::InspectorRuntimeAgent::callFunctionOn):
513         (Inspector::InspectorRuntimeAgent::saveResult):
514         (Inspector::InspectorRuntimeAgent::getRuntimeTypesForVariablesAtOffsets):
515         * inspector/agents/InspectorRuntimeAgent.h:
516
517         * inspector/scripts/codegen/cpp_generator.py: Always generate PrimitiveType('array').
518         (CppGenerator.cpp_type_for_unchecked_formal_in_parameter): Alter the type signature
519         for an unchecked input to use pointers or references.
520
521         * inspector/scripts/codegen/generate_cpp_backend_dispatcher_header.py:
522         (CppBackendDispatcherHeaderGenerator._generate_handler_declaration_for_command):
523         (CppBackendDispatcherHeaderGenerator._generate_async_handler_declaration_for_command):
524         Local variables for optional parameters now have the 'opt_' prefix.
525
526         * inspector/scripts/codegen/generate_cpp_backend_dispatcher_implementation.py:
527         (CppBackendDispatcherImplementationGenerator._generate_async_dispatcher_class_for_domain):
528         (CppBackendDispatcherImplementationGenerator._generate_dispatcher_implementation_for_command):
529         Local variables for optional parameters now have the 'opt_' prefix.
530         Split parameterName and parameterKey into two separate template variables to avoid mixups.
531
532         * inspector/scripts/tests/expected/commands-with-optional-call-return-parameters.json-result:
533
534 2015-06-18  Joseph Pecoraro  <pecoraro@apple.com>
535
536         Unreviewed. Rollout r185670 as it caused some tests to be flakey.
537
538         * debugger/Debugger.cpp:
539
540 2015-06-17  Alex Christensen  <achristensen@webkit.org>
541
542         [Content Extensions] Log blocked loads to the WebInspector console
543         https://bugs.webkit.org/show_bug.cgi?id=146089
544
545         Reviewed by Joseph Pecoraro.
546
547         * inspector/ConsoleMessage.cpp:
548         (Inspector::messageSourceValue):
549         * inspector/protocol/Console.json:
550         * runtime/ConsoleTypes.h:
551         Add content blocker message source.
552
553 2015-06-18  Saam Barati  <saambarati1@gmail.com>
554
555         [ES6] support default values in deconstruction parameter nodes
556         https://bugs.webkit.org/show_bug.cgi?id=142679
557
558         Reviewed by Darin Adler.
559
560         ES6 destructuring allows destructuring properties to assign 
561         default values. A link to the spec: 
562         https://people.mozilla.org/~jorendorff/es6-draft.html#sec-destructuring-binding-patterns
563
564         This patch implements default values for all places where deconstruction
565         is allowed besides function parameters. This is because function
566         parameters are parsed in a separate parser arena than the function
567         body itself and ExpresionNode's which are default values for
568         deconstruction parameters will be deallocated by the time we parse the body
569         of the function. I have opened a bug to address this problem:
570         https://bugs.webkit.org/show_bug.cgi?id=145995
571
572         * bytecompiler/NodesCodegen.cpp:
573         (JSC::DeconstructionPatternNode::~DeconstructionPatternNode):
574         (JSC::assignDefaultValueIfUndefined):
575         (JSC::ArrayPatternNode::bindValue):
576         (JSC::ArrayPatternNode::emitDirectBinding):
577         (JSC::ArrayPatternNode::toString):
578         (JSC::ArrayPatternNode::collectBoundIdentifiers):
579         (JSC::ObjectPatternNode::bindValue):
580         * parser/ASTBuilder.h:
581         (JSC::ASTBuilder::appendArrayPatternSkipEntry):
582         (JSC::ASTBuilder::appendArrayPatternEntry):
583         (JSC::ASTBuilder::createObjectPattern):
584         (JSC::ASTBuilder::appendObjectPatternEntry):
585         (JSC::ASTBuilder::createBindingLocation):
586         * parser/Nodes.h:
587         (JSC::ArrayPatternNode::appendIndex):
588         (JSC::ObjectPatternNode::appendEntry):
589         (JSC::ObjectPatternNode::Entry::Entry): Deleted.
590         * parser/Parser.cpp:
591         (JSC::Parser<LexerType>::parseDeconstructionPattern):
592         (JSC::Parser<LexerType>::parseDefaultValueForDeconstructionPattern):
593         (JSC::Parser<LexerType>::parseConstDeclarationList):
594         * parser/Parser.h:
595         * parser/SyntaxChecker.h:
596         (JSC::SyntaxChecker::operatorStackPop):
597
598 2015-06-17  Joseph Pecoraro  <pecoraro@apple.com>
599
600         Web Inspector: Do not show JavaScriptCore builtins in inspector
601         https://bugs.webkit.org/show_bug.cgi?id=146049
602
603         Reviewed by Timothy Hatcher.
604
605         * debugger/Debugger.cpp:
606
607 2015-06-17  Andreas Kling  <akling@apple.com>
608
609         [JSC] jsSubstring() should have a fast path for 0..baseLength "substrings."
610         <https://webkit.org/b/146051>
611
612         Reviewed by Anders Carlsson.
613
614         If asked to make a substring that actually spans the entire base string,
615         have jsSubstring() just return the base instead of allocating a new JSString.
616
617         3% speed-up on Octane/regexp.
618
619         * runtime/JSString.h:
620         (JSC::jsSubstring):
621
622 2015-06-16  Alex Christensen  <achristensen@webkit.org>
623
624         32-bit build fix after r185640.
625
626         * dfg/DFGIntegerRangeOptimizationPhase.cpp:
627         Explicitly cast clamped int64_t to an int.
628
629 2015-06-09  Filip Pizlo  <fpizlo@apple.com>
630
631         FTL should eliminate array bounds checks in loops
632         https://bugs.webkit.org/show_bug.cgi?id=145768
633
634         Reviewed by Benjamin Poulain.
635         
636         This adds a phase that does forward propagation of integer inequalities. This allows us
637         to do the algebraic reasoning we need to eliminate array bounds checks in loops. It
638         also eliminates overflow checks on ArithAdd with a constant.
639         
640         The phase's analysis produces results that are powerful enough to do speculative bounds
641         check hoisting, but this phase currently only does elimination. We can implement
642         hoisting later.
643         
644         On programs that just loop over an array like:
645         
646             for (var i = 0; i < array.length; ++i)
647                 thingy += array[i]
648         
649         This change is a 60% speed-up.
650         
651         This is also a ~3% speed-up on Kraken, and it shows various speed-ups on individual
652         tests in Octane.
653
654         * CMakeLists.txt:
655         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
656         * JavaScriptCore.xcodeproj/project.pbxproj:
657         * dfg/DFGIntegerRangeOptimizationPhase.cpp: Added.
658         (JSC::DFG::performIntegerRangeOptimization):
659         * dfg/DFGIntegerRangeOptimizationPhase.h: Added.
660         * dfg/DFGPlan.cpp:
661         (JSC::DFG::Plan::compileInThreadImpl):
662         * tests/stress/add-overflows-after-not-equal.js: Added.
663         * tests/stress/no-abc-skippy-loop.js: Added.
664         * tests/stress/no-abc-skippy-paired-loop.js: Added.
665         * tests/stress/sub-overflows-after-not-equal.js: Added.
666
667 2015-06-16  Andreas Kling  <akling@apple.com>
668
669         Remove unused template parameter InlineCapacity from SegmentedVector.
670         <https://webkit.org/b/146044>
671
672         Reviewed by Anders Carlsson.
673
674         * bytecode/ArrayProfile.h:
675         * dfg/DFGCommonData.h:
676
677 2015-06-16  Michael Saboff  <msaboff@apple.com>
678
679         Inlining in the DFG trashes ByteCodeParser::m_currentInstruction for the calling function
680         https://bugs.webkit.org/show_bug.cgi?id=146029
681
682         Reviewed by Benjamin Poulain.
683
684         Save and restore m_currentInstruction around call to ByteCodeParser::inlineCall() as it will
685         use m_currentInstruction during its own parsing.  This happens because inlineCall() parses the
686         inlined callee's bytecodes by calling parseCodeBlock() which calls parseBlock() on each block.
687         It is in parseBlock() that we set m_currentInstruction to an instruction before we parse it.
688
689         * dfg/DFGByteCodeParser.cpp:
690         (JSC::DFG::ByteCodeParser::attemptToInlineCall):
691         (JSC::DFG::ByteCodeParser::parseBlock): Added an ASSERT to catch this issue.
692
693 2015-06-16  Filip Pizlo  <fpizlo@apple.com>
694
695         Unreviewed, roll out unintended JSC change from https://trac.webkit.org/changeset/185425.
696
697         * bytecode/CodeBlock.h:
698         (JSC::CodeBlock::hasExitSite):
699         (JSC::CodeBlock::exitProfile):
700         (JSC::CodeBlock::numberOfExitSites): Deleted.
701         * bytecode/DFGExitProfile.cpp:
702         (JSC::DFG::ExitProfile::add):
703         * bytecode/DFGExitProfile.h:
704         (JSC::DFG::ExitProfile::hasExitSite):
705         (JSC::DFG::ExitProfile::size): Deleted.
706         * dfg/DFGByteCodeParser.cpp:
707         (JSC::DFG::ByteCodeParser::inliningCost):
708         * runtime/Options.h:
709
710 2015-06-16  Mark Lam  <mark.lam@apple.com>
711
712         Use NakedPtr<Exception>& to return exception results.
713         https://bugs.webkit.org/show_bug.cgi?id=145870
714
715         Reviewed by Anders Carlsson and Filip Pizlo.
716
717         Before r185259, calls into the VM takes a JSValue* exception result argument for
718         returning any uncaught exception that may have been thrown while executing JS code.
719         As a result, clients of the VM functions will declare a local JSValue exception
720         result which is automatically initialized to a null value (i.e. the empty value,
721         not the JS null value).
722
723         With r185259, the VM functions were changed to take an Exception*& exception result
724         instead, and the VM functions are responsible for initializing the exception result
725         to null if no exception is thrown.
726
727         This introduces 2 issues:
728
729         1. the VM functions are vulnerable to modifications that may add early returns
730            before the exception result is nullified.  This can result in the exception
731            result being used without initialization.
732
733         2. Previously, a client could technically use the same exception result for more
734            than one calls into the VM functions.  If an earlier call sets it to a thrown
735            value, the thrown value will stick unless a subsequent call throws a different
736            exception.
737
738            With the new Exception*& exception result, the VM functions will always clear
739            the exception result before proceeding.  As a result, the client's exception
740            result will be null after the second call even though the first call saw an
741            exception thrown.  This is a change in the expected behavior.
742
743         To fix these issues, we'll introduce a NakedPtr smart pointer whose sole purpose
744         is to guarantee that the pointer is initialized.  The VM functions will now take
745         a NakedPtr<Exception>& instead of the Exception*&.  This ensures that the
746         exception result is initialized.
747
748         The VM functions be also reverted to only set the exception result if a new
749         exception is thrown.
750
751         * API/JSBase.cpp:
752         (JSEvaluateScript):
753         * API/JSScriptRef.cpp:
754         * bindings/ScriptFunctionCall.cpp:
755         (Deprecated::ScriptFunctionCall::call):
756         * bindings/ScriptFunctionCall.h:
757         * debugger/Debugger.cpp:
758         (JSC::Debugger::hasBreakpoint):
759         * debugger/Debugger.h:
760         * debugger/DebuggerCallFrame.cpp:
761         (JSC::DebuggerCallFrame::thisValue):
762         (JSC::DebuggerCallFrame::evaluate):
763         * debugger/DebuggerCallFrame.h:
764         (JSC::DebuggerCallFrame::isValid):
765         * inspector/InjectedScriptManager.cpp:
766         (Inspector::InjectedScriptManager::createInjectedScript):
767         * inspector/InspectorEnvironment.h:
768         * inspector/JSJavaScriptCallFrame.cpp:
769         (Inspector::JSJavaScriptCallFrame::evaluate):
770         * inspector/JavaScriptCallFrame.h:
771         (Inspector::JavaScriptCallFrame::vmEntryGlobalObject):
772         (Inspector::JavaScriptCallFrame::thisValue):
773         (Inspector::JavaScriptCallFrame::evaluate):
774         * inspector/ScriptDebugServer.cpp:
775         (Inspector::ScriptDebugServer::evaluateBreakpointAction):
776         * jsc.cpp:
777         (functionRun):
778         (functionLoad):
779         (runWithScripts):
780         (runInteractive):
781         * runtime/CallData.cpp:
782         (JSC::call):
783         * runtime/CallData.h:
784         * runtime/Completion.cpp:
785         (JSC::checkSyntax):
786         (JSC::evaluate):
787         * runtime/Completion.h:
788         (JSC::evaluate):
789
790 2015-06-15  Filip Pizlo  <fpizlo@apple.com>
791
792         FTL boolify() UntypedUse is wrong in the masquerades-as-undefined case
793         https://bugs.webkit.org/show_bug.cgi?id=146002
794
795         Reviewed by Darin Adler.
796
797         * ftl/FTLLowerDFGToLLVM.cpp: Put this in an anonymous namespace. We should have done that all along. It makes it easier to add debug code.
798         (JSC::FTL::DFG::LowerDFGToLLVM::boolify): Fix the bug.
799         * tests/stress/logical-not-masquerades.js: Added. This test creates a masquerader so that the watchpoint is invalid. Previously this would fail for the normal object cases.
800         (foo):
801
802 2015-06-16  Andreas Kling  <akling@apple.com>
803
804         [JSC] Pre-bake final Structure for RegExp matches arrays.
805         <https://webkit.org/b/146006>
806
807         Reviewed by Darin Adler.
808
809         Since we always add the "index" and "input" fields to RegExp matches arrays,
810         cache a finished structure on the global object so we can create these arrays without
811         starting from scratch with a bare array every time.
812
813         10% progression on Octane/regexp (on my MBP.)
814
815         * runtime/JSArray.h:
816         (JSC::JSArray::create):
817         (JSC::JSArray::tryCreateUninitialized):
818         (JSC::JSArray::createWithButterfly): Factored out JSArray construction into a helper
819         so we can call this from RegExpMatchesArray.cpp.
820
821         * runtime/JSGlobalObject.cpp:
822         (JSC::JSGlobalObject::init):
823         (JSC::JSGlobalObject::visitChildren):
824         * runtime/JSGlobalObject.h:
825         (JSC::JSGlobalObject::regExpMatchesArrayStructure): Add a cached Structure for RegExp
826         subpattern matches arrays.
827
828         * runtime/JSObject.h:
829         (JSC::JSNonFinalObject::finishCreation): Tweak assertion that used to check that
830         JSNonFinalObjects always start out with zero capacity. Since RegExp matches arrays now
831         start out with capacity for 2 properties, that won't work. Change it to check that we
832         don't have inline storage instead, since that should only be used by final objects.
833
834         * runtime/RegExpMatchesArray.h:
835         * runtime/RegExpMatchesArray.cpp:
836         (JSC::tryCreateUninitializedRegExpMatchesArray): Helper to construct a JSArray with
837         the cached Structure and a Butterfly with 2 slots of property storage.
838
839         (JSC::createRegExpMatchesArray):
840         (JSC::createRegExpMatchesArrayStructure): Creates the array Structure that gets cached
841         by the JSGlobalObject.
842
843 2015-06-16  Saam Barati  <saambarati1@gmail.com>
844
845         LLInt's code path for get_from_scope with case GlobalVarWithVarInjectionChecks has dead code
846         https://bugs.webkit.org/show_bug.cgi?id=144268
847
848         Reviewed by Darin Adler.
849
850         The call to loadVariable(.) both for 32bit and 64bit is unnecessary. 
851         It grabs a value that is immediately overwritten by a call to getGlobalVar(). 
852
853         * llint/LowLevelInterpreter32_64.asm:
854         * llint/LowLevelInterpreter64.asm:
855
856 2015-06-14  Yusuke Suzuki  <utatane.tea@gmail.com>
857
858         [ES6] Introduce %IteratorPrototype% and drop all XXXIteratorConstructor
859         https://bugs.webkit.org/show_bug.cgi?id=145963
860
861         Reviewed by Darin Adler.
862
863         ES6 iterators inherit %IteratorPrototype%.
864         And these prototype objects of derived iterators don't have @@iterator methods.
865         Instead they use the %IteratorPrototype%[@@iterator] method.
866
867         To encourage inlining in for-of statement, we define this method in JS builtins.
868
869         And these iterator prototype objects don't have any constructor function.
870         This patch drops them (like StringIteratorConstructor).
871
872         * CMakeLists.txt:
873         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
874         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
875         * JavaScriptCore.xcodeproj/project.pbxproj:
876         * builtins/Iterator.prototype.js: Renamed from Source/JavaScriptCore/runtime/StringIteratorConstructor.cpp.
877         (SymbolIterator):
878         * runtime/ArrayIteratorConstructor.cpp:
879         (JSC::ArrayIteratorConstructor::finishCreation): Deleted.
880         * runtime/ArrayIteratorConstructor.h: Removed.
881         (JSC::ArrayIteratorConstructor::create): Deleted.
882         (JSC::ArrayIteratorConstructor::createStructure): Deleted.
883         (JSC::ArrayIteratorConstructor::ArrayIteratorConstructor): Deleted.
884         * runtime/ArrayIteratorPrototype.cpp:
885         (JSC::ArrayIteratorPrototype::finishCreation):
886         (JSC::arrayIteratorProtoFuncIterator): Deleted.
887         * runtime/IteratorPrototype.cpp: Renamed from Source/JavaScriptCore/runtime/ArrayIteratorConstructor.cpp.
888         (JSC::IteratorPrototype::finishCreation):
889         * runtime/IteratorPrototype.h: Renamed from Source/JavaScriptCore/runtime/SetIteratorConstructor.h.
890         (JSC::IteratorPrototype::create):
891         (JSC::IteratorPrototype::createStructure):
892         (JSC::IteratorPrototype::IteratorPrototype):
893         * runtime/JSFunction.cpp:
894         (JSC::JSFunction::createBuiltinFunction):
895         * runtime/JSFunction.h:
896         * runtime/JSGlobalObject.cpp:
897         (JSC::JSGlobalObject::init):
898         (JSC::JSGlobalObject::visitChildren):
899         * runtime/JSGlobalObject.h:
900         (JSC::JSGlobalObject::iteratorPrototype):
901         * runtime/MapIteratorConstructor.cpp: Removed.
902         (JSC::MapIteratorConstructor::finishCreation): Deleted.
903         * runtime/MapIteratorConstructor.h: Removed.
904         (JSC::MapIteratorConstructor::create): Deleted.
905         (JSC::MapIteratorConstructor::createStructure): Deleted.
906         (JSC::MapIteratorConstructor::MapIteratorConstructor): Deleted.
907         * runtime/MapIteratorPrototype.cpp:
908         (JSC::MapIteratorPrototype::finishCreation): Deleted.
909         (JSC::MapIteratorPrototypeFuncIterator): Deleted.
910         * runtime/SetIteratorConstructor.cpp: Removed.
911         (JSC::SetIteratorConstructor::finishCreation): Deleted.
912         * runtime/SetIteratorConstructor.h:
913         (JSC::SetIteratorConstructor::create): Deleted.
914         (JSC::SetIteratorConstructor::createStructure): Deleted.
915         (JSC::SetIteratorConstructor::SetIteratorConstructor): Deleted.
916         * runtime/SetIteratorPrototype.cpp:
917         (JSC::SetIteratorPrototype::finishCreation): Deleted.
918         (JSC::SetIteratorPrototypeFuncIterator): Deleted.
919         * runtime/StringIteratorConstructor.cpp:
920         (JSC::StringIteratorConstructor::finishCreation): Deleted.
921         * runtime/StringIteratorConstructor.h: Removed.
922         (JSC::StringIteratorConstructor::create): Deleted.
923         (JSC::StringIteratorConstructor::createStructure): Deleted.
924         (JSC::StringIteratorConstructor::StringIteratorConstructor): Deleted.
925         * runtime/StringIteratorPrototype.cpp:
926         (JSC::StringIteratorPrototype::finishCreation):
927         (JSC::stringIteratorPrototypeIterator): Deleted.
928         * tests/stress/iterator-prototype.js: Added.
929         (shouldBe):
930         (inheritIteratorPrototype):
931         (testChain):
932
933 2015-06-15  Michael Saboff  <msaboff@apple.com>
934
935         JIT bug - fails when inspector closed, works when open
936         https://bugs.webkit.org/show_bug.cgi?id=145243
937
938         Reviewed by Oliver Hunt.
939
940         We need to provide the Arguments object as the base when creating the HeapLocation for
941         GetFromArguments and PutToArguments.  Otherwise we endup creating a HeapLocation for
942         any arguments object, not the one we need.
943
944         * dfg/DFGClobberize.h:
945         (JSC::DFG::clobberize):
946
947 2015-06-13  Joseph Pecoraro  <pecoraro@apple.com>
948
949         Web Inspector: console.table() with a list of objects no longer works
950         https://bugs.webkit.org/show_bug.cgi?id=145952
951
952         Reviewed by Timothy Hatcher.
953
954         * inspector/InjectedScriptSource.js:
955         (InjectedScript.RemoteObject.prototype._generatePreview):
956         Calling generatePreview again was actually starting with a preview
957         of the current object instead of the sub-value. Go down the other
958         path that correctly generates sub-previews. Leave filtering on the
959         backend unimplemented, which we were already ignoring.
960
961 2015-06-13  Youenn Fablet  <youenn.fablet@crf.canon.fr>
962
963         [Streams API] ReadableJSStream should handle promises returned by JS source start callback
964         https://bugs.webkit.org/show_bug.cgi?id=145792
965
966         Reviewed by Darin Adler.
967
968         Added support for JSFunction implemented by std::function.
969
970         * runtime/JSFunction.cpp:
971         (JSC::getNativeExecutable): Refactored code to share it with the two JSFunction::create
972         (JSC::JSFunction::create):
973         (JSC::runStdFunction):
974         * runtime/JSFunction.h: Added std::function based JSFunction::create prototype.
975         * runtime.JSPromise.h:
976
977 2015-06-12  Gyuyoung Kim  <gyuyoung.kim@webkit.org>
978
979         Purge PassRefPtr in JavaScriptCore - 2
980         https://bugs.webkit.org/show_bug.cgi?id=145834
981
982         Reviewed by Darin Adler.
983
984         As a step to remove PassRefPtr, this patch cleans up PassRefPtr as much as possible
985         in JavaScriptCore.
986
987         * API/JSClassRef.cpp:
988         (OpaqueJSClass::create):
989         * API/JSClassRef.h:
990         * debugger/DebuggerCallFrame.cpp:
991         (JSC::DebuggerCallFrame::callerFrame):
992         * debugger/DebuggerCallFrame.h:
993         * dfg/DFGJITCompiler.h:
994         (JSC::DFG::JITCompiler::jitCode):
995         * inspector/ScriptCallStackFactory.cpp:
996         (Inspector::createScriptCallStack):
997         (Inspector::createScriptCallStackForConsole):
998         (Inspector::createScriptCallStackFromException):
999         (Inspector::createScriptArguments):
1000         * inspector/ScriptCallStackFactory.h:
1001         * jit/ExecutableAllocator.cpp:
1002         (JSC::ExecutableAllocator::allocate):
1003         * jit/ExecutableAllocator.h:
1004         * jit/ExecutableAllocatorFixedVMPool.cpp:
1005         (JSC::ExecutableAllocator::allocate):
1006         * profiler/LegacyProfiler.cpp:
1007         (JSC::LegacyProfiler::stopProfiling):
1008         * profiler/LegacyProfiler.h:
1009         * runtime/DateInstanceCache.h:
1010         * runtime/Executable.cpp:
1011         (JSC::ScriptExecutable::newCodeBlockFor):
1012         * runtime/Executable.h:
1013         * runtime/GenericTypedArrayView.h:
1014         * runtime/GenericTypedArrayViewInlines.h:
1015         (JSC::GenericTypedArrayView<Adaptor>::create):
1016         (JSC::GenericTypedArrayView<Adaptor>::createUninitialized):
1017
1018 2015-06-12  Darin Adler  <darin@apple.com>
1019
1020         Fix minor ES6 compliance issue in RegExp.prototype.toString and optimize performance a little
1021         https://bugs.webkit.org/show_bug.cgi?id=145935
1022
1023         Reviewed by Anders Carlsson.
1024
1025         Test: js/regexp-toString.html
1026
1027         * runtime/RegExpPrototype.cpp:
1028         (JSC::getFlags): Avoid memory allocation for the flags string by returning it in a character
1029         buffer instead of constructing a WTF::String for it.
1030         (JSC::regExpProtoFuncToString): Require only that the this value be an object; don't require
1031         that it is actually a regular expression object. This is covered in the ES6 specification.
1032         Also removed comment about the "/(?:)/" trick since that is now the repsonsibility of the
1033         getter for the "source" property. Updated to use getFlags so we do one less memory allocation.
1034         (JSC::regExpProtoGetterFlags): Chagned to use getFlags instead of the old flagsString.
1035
1036 2015-06-12  Basile Clement  <basile_clement@apple.com>
1037
1038         DFG Object Allocation Sinking should not consider GetClosureVar as escapes
1039         https://bugs.webkit.org/show_bug.cgi?id=145904
1040
1041         Reviewed by Filip Pizlo.
1042
1043         The object allocation sinking phase is currently able to sink
1044         CreateActivation nodes, but will consider any GetClosureVar node as
1045         escaping.
1046
1047         This is not problematic in general as most of the GetClosureVar nodes
1048         we would have been able to sink over will have been eliminated by CSE
1049         anyway. Still, this is an oversight that we should fix since the
1050         machinery is already in place.
1051
1052         * dfg/DFGObjectAllocationSinkingPhase.cpp:
1053         (JSC::DFG::ObjectAllocationSinkingPhase::handleNode):
1054         * dfg/DFGPromoteHeapAccess.h:
1055         (JSC::DFG::promoteHeapAccess):
1056
1057 2015-06-11  Mark Lam  <mark.lam@apple.com>
1058
1059         WebCore::reportException() needs to be able to accept a raw thrown value in addition to Exception objects.
1060         https://bugs.webkit.org/show_bug.cgi?id=145872
1061
1062         Reviewed by Michael Saboff.
1063
1064         In r185259, we changed exception handling code inside the VM to work with
1065         Exception objects instead of the thrown JSValue.  The handling code will get the
1066         exception stack trace from the Exception object.
1067
1068         However, there is some code that cannot be updated to pass the Exception object.
1069         An example of this are the ObjC API functions.  Those functions are specified to
1070         return any thrown exception JSValue in a JSValueRef.  Since these APIs are
1071         public, we cannot arbitrarily change them to use the Exception object.
1072
1073         There are client code that calls these APIs and then passes the returned exception
1074         JSValue to WebCore::reportException() to be reported.  WebCore::reportException()
1075         previously relied on the VM::exceptionStackTrace() to provide a cache of the
1076         stack trace of the last thrown exception.  VM::exceptionStackTrace() no longer
1077         exists in the current code.
1078
1079         To restore this functionality, we will introduce VM::lastException() which
1080         caches the last thrown Exception object.  With this, if the exception passed to
1081         WebCore::reportException() to be reported isn't an Exception object (which has its
1082         own stack trace), reportException() can again use the cached exception stack trace
1083         which is available from VM::lastException().
1084
1085         * heap/Heap.cpp:
1086         (JSC::Heap::visitException):
1087         - visit VM::m_lastException on GCs.
1088
1089         * interpreter/CallFrame.h:
1090         (JSC::ExecState::lastException):
1091         (JSC::ExecState::clearLastException):
1092         - convenience functions to get and clear the last exception.
1093
1094         * runtime/Exception.cpp:
1095         (JSC::Exception::create):
1096         (JSC::Exception::finishCreation):
1097         - add support to create an Exception object without capturing the JS stack trace.
1098           This is needed for making an Exception object to wrap a thrown value that does
1099           not have a stack trace.
1100           Currently, this is only used by WebCore::reportException() when there is no
1101           Exception object and no last exception available to provide a stack trace.
1102
1103         * runtime/Exception.h:
1104         (JSC::Exception::cast): Deleted.  No longer needed.
1105
1106         * runtime/VM.h:
1107         (JSC::VM::clearLastException):
1108         (JSC::VM::setException):
1109         (JSC::VM::lastException):
1110         (JSC::VM::addressOfLastException):
1111         - Added support for VM::m_lastException.
1112           VM::m_lastException serves to cache the exception stack of the most recently
1113           thrown exception like VM::exceptionStackTrace() used to before r185259.
1114
1115         * runtime/VMEntryScope.cpp:
1116         (JSC::VMEntryScope::VMEntryScope):
1117         - Clear VM::m_lastException when we re-enter the VM.  Exceptions should have been
1118           handled before we re-enter the VM anyway.  So, this is a good place to release
1119           the cached last exception.
1120
1121           NOTE: this is also where the old code before r185259 clears the last exception
1122           stack trace.  So, we're just restoring the previous behavior here in terms of
1123           the lifecycle of the last exception stack.
1124
1125 2015-06-11  Andreas Kling  <akling@apple.com>
1126
1127         jsSubstring() should support creating substrings from substrings.
1128         <https://webkit.org/b/145427>
1129
1130         Reviewed by Geoffrey Garen
1131
1132         Tweak jsSubstring() to support base strings that are themselves substrings.
1133         They will now share the same grandparent base. This avoids creating a new StringImpl.
1134
1135         * runtime/JSString.h:
1136         (JSC::jsSubstring): Don't force rope resolution here. Instead do that in finishCreation()
1137         if the base string is a non-substring rope. Note that resolveRope() is the very last thing
1138         called, since it may allocate and the JSRopeString needs to be ready for marking.
1139
1140         (JSC::JSString::isSubstring): Added a helper to find out if a JSString is
1141         a substring. This is just for internal use, so you don't have to cast to
1142         JSRopeString for the real substringness flag.
1143
1144 2015-06-11  Commit Queue  <commit-queue@webkit.org>
1145
1146         Unreviewed, rolling out r185465.
1147         https://bugs.webkit.org/show_bug.cgi?id=145893
1148
1149         "This patch is breaking 32bit mac build" (Requested by youenn
1150         on #webkit).
1151
1152         Reverted changeset:
1153
1154         "[Streams API] ReadableJSStream should handle promises
1155         returned by JS source start callback"
1156         https://bugs.webkit.org/show_bug.cgi?id=145792
1157         http://trac.webkit.org/changeset/185465
1158
1159 2015-06-11  Youenn Fablet  <youenn.fablet@crf.canon.fr>
1160
1161         [Streams API] ReadableJSStream should handle promises returned by JS source start callback
1162         https://bugs.webkit.org/show_bug.cgi?id=145792
1163
1164         Reviewed by Darin Adler.
1165
1166         Added support for JSFunction implemented by std::function.
1167
1168         * runtime/JSFunction.cpp:
1169         (JSC::getNativeExecutable): Refactored code to share it with the two JSFunction::create
1170         (JSC::JSFunction::create):
1171         (JSC::runStdFunction):
1172         * runtime/JSFunction.h: Added std::function based JSFunction::create prototype.
1173         * runtime.JSPromise.h:
1174
1175 2015-06-10  Yusuke Suzuki  <utatane.tea@gmail.com>
1176
1177         ASSERTION FAILED: s.length() > 1 on LayoutTests/js/regexp-flags.html
1178         https://bugs.webkit.org/show_bug.cgi?id=145599
1179
1180         Unreviewed, simple follow up patch.
1181
1182         use jsString instead of jsMakeNontrivialString
1183         since the flag string may be trivial (0 or 1 length).
1184
1185         * runtime/RegExpPrototype.cpp:
1186         (JSC::regExpProtoGetterFlags):
1187
1188 2015-06-10  Yusuke Suzuki  <utatane.tea@gmail.com>
1189
1190         JavaScript: Drop the “escaped reserved words as identifiers” compatibility measure
1191         https://bugs.webkit.org/show_bug.cgi?id=90678
1192
1193         Reviewed by Darin Adler.
1194
1195         After ES6, escaped reserved words in identifiers are prohibited.
1196         After parsing Identifier, we should perform `m_buffer16.shrink(0)`.
1197
1198         * parser/Lexer.cpp:
1199         (JSC::Lexer<CharacterType>::parseIdentifierSlowCase):
1200         * tests/mozilla/ecma_3/Unicode/uc-003.js:
1201         (test): Deleted.
1202         * tests/stress/reserved-word-with-escape.js: Added.
1203         (testSyntax):
1204         (testSyntaxError):
1205
1206 2015-06-10  Jordan Harband  <ljharb@gmail.com>
1207
1208         Implement RegExp.prototype.flags
1209         https://bugs.webkit.org/show_bug.cgi?id=145599
1210
1211         Reviewed by Geoffrey Garen.
1212         Per https://people.mozilla.org/~jorendorff/es6-draft.html#sec-get-regexp.prototype.flags
1213
1214         * runtime/CommonIdentifiers.h:
1215         * runtime/RegExpPrototype.cpp:
1216         (JSC::flagsString):
1217         (JSC::regExpProtoFuncToString):
1218         (JSC::regExpProtoGetterFlags):
1219         * tests/stress/static-getter-in-names.js:
1220
1221 2015-06-10  Filip Pizlo  <fpizlo@apple.com>
1222
1223         DFG ASSERTION FAILED: !iterate() on stress/singleton-scope-then-overwrite.js.ftl-eager
1224         https://bugs.webkit.org/show_bug.cgi?id=145853
1225
1226         Unreviewed, remove the assertion.
1227
1228         * dfg/DFGCSEPhase.cpp:
1229
1230 2015-06-10  Commit Queue  <commit-queue@webkit.org>
1231
1232         Unreviewed, rolling out r185414.
1233         https://bugs.webkit.org/show_bug.cgi?id=145844
1234
1235         broke debug and jsc tests (Requested by alexchristensen on
1236         #webkit).
1237
1238         Reverted changeset:
1239
1240         "JavaScript: Drop the “escaped reserved words as identifiers”
1241         compatibility measure"
1242         https://bugs.webkit.org/show_bug.cgi?id=90678
1243         http://trac.webkit.org/changeset/185414
1244
1245 2015-06-10  Yusuke Suzuki  <utatane.tea@gmail.com>
1246
1247         JavaScript: Drop the “escaped reserved words as identifiers” compatibility measure
1248         https://bugs.webkit.org/show_bug.cgi?id=90678
1249
1250         Reviewed by Darin Adler.
1251
1252         After ES6, escaped reserved words in identifiers are prohibited.
1253
1254         * parser/Lexer.cpp:
1255         (JSC::Lexer<CharacterType>::parseIdentifierSlowCase):
1256         * tests/stress/reserved-word-with-escape.js: Added.
1257         (testSyntax):
1258         (testSyntaxError):
1259
1260 2015-06-10  Andreas Kling  <akling@apple.com>
1261
1262         [JSC] InlineCallFrame::arguments should be sized-to-fit.
1263         <https://webkit.org/b/145782>
1264
1265         Reviewed by Darin Adler.
1266
1267         I spotted this Vector<ValueRecovery> looking a bit chubby in Instruments,
1268         with 354 kB of memory allocated on cnet.com.
1269
1270         Use resizeToFit() instead of resize() since we know the final size up front.
1271
1272         * dfg/DFGByteCodeParser.cpp:
1273         (JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
1274
1275 2015-06-09  Chris Dumez  <cdumez@apple.com>
1276
1277         Allow one sync GC per gcTimer interval on critical memory pressure warning
1278         https://bugs.webkit.org/show_bug.cgi?id=145773
1279
1280         Reviewed by Geoffrey Garen.
1281
1282         On critical memory pressure warning, we were calling GCController::garbageCollectSoon(),
1283         which does not offer any guarantee on when the garbage collection will actually take
1284         place.
1285
1286         On critical memory pressure, we need to free up memory as soon as possible to avoid
1287         getting killed so this is an issue. Also, the fact that we clear the PageCache on
1288         critical memory pressure means a GC would likely be useful, even if the last
1289         collection did not free much memory.
1290
1291         This patch adds a new GCController::garbageCollectNowIfNotDoneRecently() API that allows
1292         one synchronous GC per gcTimer interval on critical memory pressure warning. This makes
1293         us more responsive to critical memory pressure and avoids doing synchronous GCs too
1294         often.
1295
1296         * heap/FullGCActivityCallback.cpp:
1297         (JSC::FullGCActivityCallback::doCollection):
1298         * heap/FullGCActivityCallback.h:
1299         (JSC::GCActivityCallback::createFullTimer):
1300         * heap/GCActivityCallback.h:
1301         * heap/Heap.cpp:
1302         (JSC::Heap::collectAllGarbageIfNotDoneRecently):
1303         * heap/Heap.h:
1304
1305         * heap/IncrementalSweeper.cpp:
1306         (JSC::IncrementalSweeper::doWork): Deleted.
1307         * heap/IncrementalSweeper.h:
1308
1309         Drop fullSweep() API as it no longer seems useful. garbageCollectNow()
1310         already does a sweep after the full collection.
1311
1312 2015-06-09  Andreas Kling  <akling@apple.com>
1313
1314         [JSC] CodeBlock::m_constantRegisters should be sized-to-fit.
1315         <https://webkit.org/b/145784>
1316
1317         Reviewed by Darin Adler.
1318
1319         Spotted this Vector looking chubby on cnet.com, with 1.23 MB of memory
1320         allocated below CodeBlock::setConstantRegisters().
1321
1322         Use resizeToFit() instead since we know the final size up front.
1323         Also removed some unused functions that operated on this constants vector
1324         and the corresponding one in UnlinkedCodeBlock.
1325
1326         * bytecode/CodeBlock.cpp:
1327         (JSC::CodeBlock::addOrFindConstant): Deleted.
1328         (JSC::CodeBlock::findConstant): Deleted.
1329         * bytecode/CodeBlock.h:
1330         (JSC::CodeBlock::setConstantRegisters):
1331         (JSC::CodeBlock::numberOfConstantRegisters): Deleted.
1332         * bytecode/UnlinkedCodeBlock.cpp:
1333         (JSC::UnlinkedCodeBlock::addOrFindConstant): Deleted.
1334         * bytecode/UnlinkedCodeBlock.h:
1335         (JSC::UnlinkedCodeBlock::numberOfConstantRegisters): Deleted.
1336         (JSC::UnlinkedCodeBlock::getConstant): Deleted.
1337
1338 2015-06-09  Andreas Kling  <akling@apple.com>
1339
1340         [JSC] Polymorphic{Get,Put}ByIdList::addAccess() should optimize for size, not speed.
1341         <https://webkit.org/b/145786>
1342
1343         Reviewed by Darin Adler.
1344
1345         These functions already contained comments saying they optimize for size over speed,
1346         but they were using Vector::resize() which adds the usual slack for faster append().
1347
1348         Switch them over to using Vector::resizeToFit() instead, which makes the Vector
1349         allocate a perfectly sized backing store.
1350
1351         Spotted 670 kB of the GetById ones, and 165 kB of PutById on cnet.com, so these
1352         Vectors are definitely worth shrink-wrapping.
1353
1354         * bytecode/PolymorphicGetByIdList.cpp:
1355         (JSC::PolymorphicGetByIdList::addAccess):
1356         * bytecode/PolymorphicPutByIdList.cpp:
1357         (JSC::PolymorphicPutByIdList::addAccess):
1358
1359 2015-06-09  Andreas Kling  <akling@apple.com>
1360
1361         [JSC] JSPropertyNameEnumerator's property name vector should be sized-to-fit.
1362         <https://webkit.org/b/145787>
1363
1364         Reviewed by Darin Adler.
1365
1366         Saw 108 kB worth of JSPropertyNameEnumerator backing store Vectors on cnet.com.
1367         Use Vector::resizeToFit() since we know the perfect size up front.
1368
1369         * runtime/JSPropertyNameEnumerator.cpp:
1370         (JSC::JSPropertyNameEnumerator::finishCreation):
1371
1372 2015-06-09  Andreas Kling  <akling@apple.com>
1373
1374         FunctionExecutable::isCompiling() is weird and wrong.
1375         <https://webkit.org/b/145689>
1376
1377         Reviewed by Geoffrey Garen.
1378
1379         Remove FunctionExecutable::isCompiling() and the clearCodeIfNotCompiling() style
1380         functions that called it before throwing away code.
1381
1382         isCompiling() would consider the executable to be "compiling" if it had a CodeBlock
1383         but no JITCode. In practice, every executable gets a JITCode at the same time as it
1384         gets a CodeBlock, by way of prepareForExecutionImpl().
1385
1386         * debugger/Debugger.cpp:
1387         * heap/Heap.cpp:
1388         (JSC::Heap::deleteAllCompiledCode):
1389         (JSC::Heap::deleteAllUnlinkedFunctionCode):
1390         * inspector/agents/InspectorRuntimeAgent.cpp:
1391         (Inspector::TypeRecompiler::visit):
1392         * runtime/Executable.cpp:
1393         (JSC::FunctionExecutable::clearUnlinkedCodeForRecompilation):
1394         (JSC::FunctionExecutable::clearCodeIfNotCompiling): Deleted.
1395         (JSC::FunctionExecutable::clearUnlinkedCodeForRecompilationIfNotCompiling): Deleted.
1396         * runtime/Executable.h:
1397         * runtime/VM.cpp:
1398         (JSC::StackPreservingRecompiler::visit):
1399
1400 2015-06-09  Yusuke Suzuki  <utatane.tea@gmail.com>
1401
1402         Introduce getter definition into static hash tables and use it for getters in RegExp.prototype.
1403         https://bugs.webkit.org/show_bug.cgi?id=145705
1404
1405         Reviewed by Darin Adler.
1406
1407         In this patch, we introduce Accessor type into property tables.
1408         With Accessor type, create_hash_table creates a static getter property.
1409         This getter property is reified as the same to the static functions.
1410
1411         In the mean time, we only support getter because `putEntry` and `lookupPut`
1412         only work with null setter currently. However, in the spec, there's
1413         no need to add static setter properties. So we will add it if it becomes
1414         necessary in the future.
1415
1416         And at the same time, this patch fixes the issue 145738. Before this patch,
1417         `putEntry` in `JSObject::deleteProperty` adds `undefined` property if
1418         `isValidOffset(...)` is false (deleted). As the result, deleting twice
1419         revives the property with `undefined` value.
1420
1421         If the static functions are reified and the entry is
1422         `BuiltinOrFunctionOrAccessor`, there's no need to execute `putEntry` with
1423         static hash table entry. They should be handled in the normal structure's
1424         looking up because they should be already reified. So added guard for this.
1425
1426         * CMakeLists.txt:
1427         * DerivedSources.make:
1428         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
1429         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
1430         * JavaScriptCore.xcodeproj/project.pbxproj:
1431         * create_hash_table:
1432         * runtime/JSObject.cpp:
1433         (JSC::getClassPropertyNames):
1434         (JSC::JSObject::put):
1435         (JSC::JSObject::deleteProperty):
1436         (JSC::JSObject::reifyStaticFunctionsForDelete):
1437         * runtime/Lookup.cpp:
1438         (JSC::reifyStaticAccessor):
1439         (JSC::setUpStaticFunctionSlot):
1440         * runtime/Lookup.h:
1441         (JSC::HashTableValue::propertyGetter):
1442         (JSC::HashTableValue::propertyPutter):
1443         (JSC::HashTableValue::accessorGetter):
1444         (JSC::HashTableValue::accessorSetter):
1445         (JSC::getStaticPropertySlot):
1446         (JSC::getStaticValueSlot):
1447         (JSC::putEntry):
1448         (JSC::reifyStaticProperties):
1449         * runtime/PropertySlot.h:
1450         * runtime/RegExpObject.cpp:
1451         (JSC::RegExpObject::getOwnPropertySlot):
1452         (JSC::regExpObjectGlobal): Deleted.
1453         (JSC::regExpObjectIgnoreCase): Deleted.
1454         (JSC::regExpObjectMultiline): Deleted.
1455         (JSC::appendLineTerminatorEscape<LChar>): Deleted.
1456         (JSC::appendLineTerminatorEscape<UChar>): Deleted.
1457         (JSC::regExpObjectSourceInternal): Deleted.
1458         (JSC::regExpObjectSource): Deleted.
1459         * runtime/RegExpPrototype.cpp:
1460         (JSC::RegExpPrototype::getOwnPropertySlot):
1461         (JSC::regExpProtoGetterGlobal):
1462         (JSC::regExpProtoGetterIgnoreCase):
1463         (JSC::regExpProtoGetterMultiline):
1464         (JSC::appendLineTerminatorEscape<LChar>):
1465         (JSC::appendLineTerminatorEscape<UChar>):
1466         (JSC::regExpProtoGetterSourceInternal):
1467         (JSC::regExpProtoGetterSource):
1468         * tests/stress/static-function-delete.js: Added.
1469         (shouldBe):
1470         * tests/stress/static-function-put.js: Added.
1471         (shouldBe):
1472         * tests/stress/static-getter-delete.js: Added.
1473         (shouldBe):
1474         (shouldThrow):
1475         * tests/stress/static-getter-descriptors.js: Added.
1476         (shouldBe):
1477         * tests/stress/static-getter-enumeration.js: Added.
1478         (shouldBe):
1479         * tests/stress/static-getter-get.js: Added.
1480         (shouldBe):
1481         * tests/stress/static-getter-in-names.js: Added.
1482         (shouldBe):
1483         * tests/stress/static-getter-names.js: Added.
1484         (shouldBe):
1485         * tests/stress/static-getter-put.js: Added.
1486         (shouldBe):
1487         (shouldThrow):
1488
1489 2015-06-09  Andreas Kling  <akling@apple.com>
1490
1491         [JSC] JSString::getIndex() should avoid reifying substrings.
1492         <https://webkit.org/b/145803>
1493
1494         Reviewed by Darin Adler.
1495
1496         Implement getIndex() using JSString::view(), which cuts it down to a one-liner
1497         and also avoids reifying substrings.
1498
1499         I saw 178 kB of reified substrings below operationGetByVal -> getIndex()
1500         on cnet.com, so this should help.
1501
1502         * runtime/JSString.cpp:
1503         (JSC::JSRopeString::getIndexSlowCase): Deleted.
1504         * runtime/JSString.h:
1505         (JSC::JSString::getIndex):
1506
1507 2015-06-09  Andreas Kling  <akling@apple.com>
1508
1509         [JSC] String.prototype.indexOf() should use StringView.
1510         <https://webkit.org/b/145351>
1511
1512         Reviewed by Darin Adler.
1513
1514         Use StringView::find() to implement String.prototype.indexOf().
1515         This avoids reifying the needle and haystack JSStrings in case they
1516         are substrings.
1517
1518         Reduces malloc memory by ~190 kB on cnet.com.
1519
1520         * runtime/StringPrototype.cpp:
1521         (JSC::stringProtoFuncIndexOf):
1522
1523 2015-06-09  Csaba Osztrogonác  <ossy@webkit.org>
1524
1525         [cmake] Fix the style issues in cmake project files
1526         https://bugs.webkit.org/show_bug.cgi?id=145755
1527
1528         Reviewed by Darin Adler.
1529
1530         * CMakeLists.txt:
1531
1532 2015-06-08  Gyuyoung Kim  <gyuyoung.kim@webkit.org>
1533
1534         Purge PassRefPtr in JavaScriptCore
1535         https://bugs.webkit.org/show_bug.cgi?id=145750
1536
1537         As a step to purge PassRefPtr, this patch replaces PassRefPtr with Ref or RefPtr.
1538
1539         Reviewed by Darin Adler.
1540
1541         * API/JSClassRef.cpp:
1542         (OpaqueJSClass::createNoAutomaticPrototype):
1543         * API/JSClassRef.h:
1544         * API/JSContextRef.cpp:
1545         * API/JSScriptRef.cpp:
1546         (OpaqueJSScript::create):
1547         * API/JSStringRef.cpp:
1548         (JSStringCreateWithCharacters):
1549         (JSStringCreateWithUTF8CString):
1550         * API/OpaqueJSString.cpp:
1551         (OpaqueJSString::create):
1552         * API/OpaqueJSString.h:
1553         (OpaqueJSString::create):
1554         * bytecompiler/StaticPropertyAnalysis.h:
1555         (JSC::StaticPropertyAnalysis::create):
1556         * debugger/DebuggerCallFrame.h:
1557         (JSC::DebuggerCallFrame::create):
1558         * dfg/DFGToFTLDeferredCompilationCallback.cpp:
1559         (JSC::DFG::ToFTLDeferredCompilationCallback::create):
1560         * dfg/DFGToFTLDeferredCompilationCallback.h:
1561         * dfg/DFGToFTLForOSREntryDeferredCompilationCallback.cpp:
1562         (JSC::DFG::Ref<ToFTLForOSREntryDeferredCompilationCallback>ToFTLForOSREntryDeferredCompilationCallback::create):
1563         (JSC::DFG::ToFTLForOSREntryDeferredCompilationCallback::create): Deleted.
1564         * dfg/DFGToFTLForOSREntryDeferredCompilationCallback.h:
1565         * dfg/DFGWorklist.cpp:
1566         (JSC::DFG::Worklist::create):
1567         (JSC::DFG::ensureGlobalDFGWorklist):
1568         (JSC::DFG::ensureGlobalFTLWorklist):
1569         * dfg/DFGWorklist.h:
1570         * heap/EdenGCActivityCallback.h:
1571         (JSC::GCActivityCallback::createEdenTimer):
1572         * heap/FullGCActivityCallback.h:
1573         (JSC::GCActivityCallback::createFullTimer):
1574         * heap/GCActivityCallback.h:
1575         * inspector/InjectedScriptHost.h:
1576         * inspector/JavaScriptCallFrame.h:
1577         (Inspector::JavaScriptCallFrame::create):
1578         * inspector/ScriptArguments.cpp:
1579         (Inspector::ScriptArguments::create):
1580         * inspector/ScriptArguments.h:
1581         * jit/JITStubRoutine.h:
1582         (JSC::JITStubRoutine::createSelfManagedRoutine):
1583         * jit/JITToDFGDeferredCompilationCallback.cpp:
1584         (JSC::JITToDFGDeferredCompilationCallback::create):
1585         * jit/JITToDFGDeferredCompilationCallback.h:
1586         * jsc.cpp:
1587         (jscmain):
1588         * parser/NodeConstructors.h:
1589         (JSC::ArrayPatternNode::create):
1590         (JSC::ObjectPatternNode::create):
1591         (JSC::BindingNode::create):
1592         * parser/Nodes.cpp:
1593         (JSC::FunctionParameters::create):
1594         * parser/Nodes.h:
1595         * parser/SourceProvider.h:
1596         (JSC::StringSourceProvider::create):
1597         * profiler/Profile.cpp:
1598         (JSC::Profile::create):
1599         * profiler/Profile.h:
1600         * profiler/ProfileGenerator.cpp:
1601         (JSC::ProfileGenerator::create):
1602         * profiler/ProfileGenerator.h:
1603         * profiler/ProfileNode.h:
1604         (JSC::ProfileNode::create):
1605         * runtime/DataView.cpp:
1606         (JSC::DataView::create):
1607         * runtime/DataView.h:
1608         * runtime/DateInstanceCache.h:
1609         (JSC::DateInstanceData::create):
1610         * runtime/JSPromiseReaction.cpp:
1611         (JSC::createExecutePromiseReactionMicrotask):
1612         * runtime/JSPromiseReaction.h:
1613         * runtime/PropertyNameArray.h:
1614         (JSC::PropertyNameArrayData::create):
1615         * runtime/TypeSet.h:
1616         (JSC::StructureShape::create):
1617         (JSC::TypeSet::create):
1618         * runtime/TypedArrayBase.h:
1619         (JSC::TypedArrayBase::create):
1620         (JSC::TypedArrayBase::createUninitialized):
1621         (JSC::TypedArrayBase::subarrayImpl):
1622         * runtime/VM.cpp:
1623         (JSC::VM::createContextGroup):
1624         (JSC::VM::create):
1625         (JSC::VM::createLeaked):
1626         * runtime/VM.h:
1627         * yarr/RegularExpression.cpp:
1628         (JSC::Yarr::RegularExpression::Private::create):
1629
1630 2015-06-08  Filip Pizlo  <fpizlo@apple.com>
1631
1632         It should be possible to hoist all constants in DFG SSA
1633         https://bugs.webkit.org/show_bug.cgi?id=145769
1634
1635         Reviewed by Geoffrey Garen.
1636         
1637         It's sometimes somewhat more efficient, and convenient, to have all constants at the
1638         top of the root block. We don't require this as an IR invariant because too many phases
1639         want to be able to insert constants in weird places. But, this phase will be great for
1640         preparing for https://bugs.webkit.org/show_bug.cgi?id=145768.
1641
1642         * CMakeLists.txt:
1643         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
1644         * JavaScriptCore.xcodeproj/project.pbxproj:
1645         * dfg/DFGConstantHoistingPhase.cpp: Added.
1646         (JSC::DFG::performConstantHoisting):
1647         * dfg/DFGConstantHoistingPhase.h: Added.
1648         * dfg/DFGPlan.cpp:
1649         (JSC::DFG::Plan::compileInThreadImpl):
1650
1651 2015-06-07  Filip Pizlo  <fpizlo@apple.com>
1652
1653         The tiny set magic in StructureSet should be available in WTF
1654         https://bugs.webkit.org/show_bug.cgi?id=145722
1655
1656         Reviewed by Geoffrey Garen.
1657         
1658         I moved the generic logic of small sets of pointers and moved it into WTF. Now,
1659         StructureSet is a subclass of TinyPtrSet<Structure*>. There shouldn't be any functional
1660         change.
1661
1662         * bytecode/StructureSet.cpp:
1663         (JSC::StructureSet::filter):
1664         (JSC::StructureSet::filterArrayModes):
1665         (JSC::StructureSet::speculationFromStructures):
1666         (JSC::StructureSet::arrayModesFromStructures):
1667         (JSC::StructureSet::dumpInContext):
1668         (JSC::StructureSet::dump):
1669         (JSC::StructureSet::clear): Deleted.
1670         (JSC::StructureSet::add): Deleted.
1671         (JSC::StructureSet::remove): Deleted.
1672         (JSC::StructureSet::contains): Deleted.
1673         (JSC::StructureSet::merge): Deleted.
1674         (JSC::StructureSet::exclude): Deleted.
1675         (JSC::StructureSet::isSubsetOf): Deleted.
1676         (JSC::StructureSet::overlaps): Deleted.
1677         (JSC::StructureSet::operator==): Deleted.
1678         (JSC::StructureSet::addOutOfLine): Deleted.
1679         (JSC::StructureSet::containsOutOfLine): Deleted.
1680         (JSC::StructureSet::copyFromOutOfLine): Deleted.
1681         (JSC::StructureSet::OutOfLineList::create): Deleted.
1682         (JSC::StructureSet::OutOfLineList::destroy): Deleted.
1683         * bytecode/StructureSet.h:
1684         (JSC::StructureSet::onlyStructure):
1685         (JSC::StructureSet::StructureSet): Deleted.
1686         (JSC::StructureSet::operator=): Deleted.
1687         (JSC::StructureSet::~StructureSet): Deleted.
1688         (JSC::StructureSet::isEmpty): Deleted.
1689         (JSC::StructureSet::genericFilter): Deleted.
1690         (JSC::StructureSet::isSupersetOf): Deleted.
1691         (JSC::StructureSet::size): Deleted.
1692         (JSC::StructureSet::at): Deleted.
1693         (JSC::StructureSet::operator[]): Deleted.
1694         (JSC::StructureSet::last): Deleted.
1695         (JSC::StructureSet::iterator::iterator): Deleted.
1696         (JSC::StructureSet::iterator::operator*): Deleted.
1697         (JSC::StructureSet::iterator::operator++): Deleted.
1698         (JSC::StructureSet::iterator::operator==): Deleted.
1699         (JSC::StructureSet::iterator::operator!=): Deleted.
1700         (JSC::StructureSet::begin): Deleted.
1701         (JSC::StructureSet::end): Deleted.
1702         (JSC::StructureSet::ContainsOutOfLine::ContainsOutOfLine): Deleted.
1703         (JSC::StructureSet::ContainsOutOfLine::operator()): Deleted.
1704         (JSC::StructureSet::copyFrom): Deleted.
1705         (JSC::StructureSet::OutOfLineList::list): Deleted.
1706         (JSC::StructureSet::OutOfLineList::OutOfLineList): Deleted.
1707         (JSC::StructureSet::deleteStructureListIfNecessary): Deleted.
1708         (JSC::StructureSet::isThin): Deleted.
1709         (JSC::StructureSet::pointer): Deleted.
1710         (JSC::StructureSet::singleStructure): Deleted.
1711         (JSC::StructureSet::structureList): Deleted.
1712         (JSC::StructureSet::set): Deleted.
1713         (JSC::StructureSet::setEmpty): Deleted.
1714         (JSC::StructureSet::getReservedFlag): Deleted.
1715         (JSC::StructureSet::setReservedFlag): Deleted.
1716         * dfg/DFGStructureAbstractValue.cpp:
1717         (JSC::DFG::StructureAbstractValue::clobber):
1718         (JSC::DFG::StructureAbstractValue::filter):
1719         (JSC::DFG::StructureAbstractValue::filterSlow):
1720         (JSC::DFG::StructureAbstractValue::contains):
1721         * dfg/DFGStructureAbstractValue.h:
1722         (JSC::DFG::StructureAbstractValue::makeTop):
1723
1724 2015-06-08  Csaba Osztrogonác  <ossy@webkit.org>
1725
1726         [ARM] Add the missing setupArgumentsWithExecState functions after r185240
1727         https://bugs.webkit.org/show_bug.cgi?id=145754
1728
1729         Reviewed by Benjamin Poulain.
1730
1731         * jit/CCallHelpers.h:
1732         (JSC::CCallHelpers::setupArgumentsWithExecState):
1733
1734 2015-06-08  Brady Eidson  <beidson@apple.com>
1735
1736         Completely remove all IDB properties/constructors when it is disabled at runtime.
1737         rdar://problem/18429374 and https://bugs.webkit.org/show_bug.cgi?id=137034
1738
1739         Reviewed by Geoffrey Garen.
1740
1741         * runtime/CommonIdentifiers.h:
1742
1743 2015-06-06  Mark Lam  <mark.lam@apple.com>
1744
1745         Returned Exception* values need to be initialized to nullptr when no exceptions are thrown.
1746         https://bugs.webkit.org/show_bug.cgi?id=145720
1747
1748         Reviewed by Dan Bernstein.
1749
1750         * debugger/DebuggerCallFrame.cpp:
1751         (JSC::DebuggerCallFrame::evaluate):
1752
1753 2015-06-05  Mark Lam  <mark.lam@apple.com>
1754
1755         Subclasses of JSNonFinalObject with gc'able children need to implement visitChildren().
1756         https://bugs.webkit.org/show_bug.cgi?id=145709
1757
1758         Reviewed by Geoffrey Garen.
1759
1760         * jsc.cpp:
1761         (functionSetElementRoot):
1762         - The Element class has a member of type Root which extends JSDestructibleObject.
1763           It should be stored in a WriteBarrier, and visited by visitChildren().  
1764
1765         * runtime/ClonedArguments.cpp:
1766         (JSC::ClonedArguments::materializeSpecialsIfNecessary):
1767         (JSC::ClonedArguments::visitChildren):
1768         * runtime/ClonedArguments.h:
1769         - Add missing visitChildren().
1770
1771         * tests/stress/cloned-arguments-should-visit-callee-during-gc.js: Added.
1772         (makeTransientFunction.transientFunc):
1773         (makeTransientFunction):
1774
1775 2015-06-05  Geoffrey Garen  <ggaren@apple.com>
1776
1777         DropAllLocks RELEASE_ASSERT on iOS
1778         https://bugs.webkit.org/show_bug.cgi?id=139654
1779
1780         Reviewed by Mark Lam.
1781
1782         * runtime/JSLock.cpp:
1783         (JSC::JSLock::dropAllLocks): Removed a comment because it duplicated
1784         the code beneath it. Removed a FIXME because we can't ASSERT that
1785         we're holding the lock. WebKit1 on iOS drops the lock before calling to
1786         delegates, not knowing whether it holds the lock or not.
1787
1788         (JSC::JSLock::DropAllLocks::DropAllLocks): Only ASSERT that we are not
1789         GC'ing if we hold the lock. If we do not hold the lock, it is perfectly
1790         valid for some other thread, which does hold the lock, to be GC'ing.
1791         What is not valid is to drop the lock in the middle of GC, since GC
1792         must be atomic.
1793
1794 2015-06-05  Filip Pizlo  <fpizlo@apple.com>
1795
1796         speculateRealNumber() should early exit if you're already a real number, not if you're already a real double.
1797
1798         Rubber stamped by Mark Lam.
1799         
1800         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
1801
1802         * dfg/DFGSpeculativeJIT.cpp:
1803         (JSC::DFG::SpeculativeJIT::speculateRealNumber):
1804
1805 2015-06-05  Mark Lam  <mark.lam@apple.com>
1806
1807         finally blocks should not set the exception stack trace when re-throwing the exception.
1808         https://bugs.webkit.org/show_bug.cgi?id=145525
1809
1810         Reviewed by Geoffrey Garen.
1811
1812         How exceptions presently work:
1813         =============================
1814         1. op_throw can throw any JSValue.
1815         2. the VM tries to capture the stack at the throw point and propagate that as needed.
1816         3. finally blocks are implemented using op_catch to catch the thrown value, and throws it again using op_throw.
1817
1818         What's wrong with how it presently works:
1819         ========================================
1820         1. finally's makes for bad exception throw line numbers in the Inspector console.
1821
1822            The op_throw in finally will throw the value anew i.e. it captures a stack from the re-throw point.
1823            As a result, the Inspector sees the finally block as the throw point.  The original stack is lost.
1824
1825         2. finally's breaks the Inspector's "Breaks on Uncaught Exception"
1826
1827            This is because finally blocks are indistinguishable from catch blocks.  As a result, a try-finally,
1828            which should break in the Inspector on the throw, does not because the Inspector thought the
1829            exception was "caught".
1830
1831         3. finally's yields confusing break points when the Inspector "Breaks on All Exceptions"
1832
1833            a. In a try-finally scenario, the Inspector breaks 2 times: 1 at the throw, 1 at the finally.
1834            b. In a for-of loop (which has synthesized finallys), the Inspector will do another break.
1835               Similarly for other cases of JS code which synthesize finallys.
1836            c. At VM re-entry boundaries (e.g. js throws & returns to native code, which returns to js),
1837               the Inspector will do another break if there's an uncaught exception.
1838
1839         How this patch fixes the issues:
1840         ===============================
1841         1. We introduce an Exception object that wraps the thrown value and the exception stack.
1842
1843            When throwing an exception, the VM will check if the thrown value is an Exception
1844            object or not.  If it is not an Exception object, then we must be throwing a new
1845            exception.  The VM will create an Exception object to wrap the thrown value and
1846            capture the current stack for it.
1847
1848            If the thrown value is already an Exception object, then the requested throw operation
1849            must be a re-throw.  The VM will not capture a new stack for it.
1850
1851         2. op_catch will now populate 2 locals: 1 for the Exception, 1 for the thrown JSValue.
1852
1853            The VM is aware of the Exception object and uses it for rethrows in finally blocks.
1854            JS source code is never aware of the Exception object.
1855
1856            JS code is aware of the thrown value.  If it throws the caught thrown value, that
1857            constitutes a new throw, and a new Exception object will be created for it.
1858
1859         3. The VM no longer tracks the thrown JSValue and the exception stack.  It will only
1860            track a m_exception field which is an Exception*.
1861
1862         4. The BytecodeGenerator has already been updated in a prior patch to distinguish
1863            between Catch, Finally, and SynthesizedFinally blocks.  The interpreter runtime will
1864            now report to the debugger whether we have a Catch handler, not just any handlers.
1865
1866            The debugger will use this detail to determine whether to break or not.  "Break on
1867            uncaught exceptions" will only break if no Catch handler was found.
1868
1869            This solves the issue of the debugger breaking at finally blocks, and for-of statements.
1870
1871         5. The Exception object will also have a flag to indicate whether the debugger has been
1872            notified of the Exception being thrown.  Once the Interpreter notifies the debugger
1873            of the Exception object, it will mark this flag and not repeat the notify the debugger
1874            again of the same Exception.
1875
1876            This solves the issue of the debugger breaking at VM re-entry points due to uncaught
1877            exceptions.
1878
1879         6. The life-cycle of the captured exception stack trace will now follow the life-cycle
1880            of the Exception object.
1881
1882         Other changes:
1883         7. Change all clients of the VM::exception() to expect an Exception* instead of JSValue.
1884
1885         8. Fixed a few bugs where thrown exceptions are not cleared before exiting the VM.
1886
1887         9. Also renamed some variables and classes to better describe what they are.
1888
1889         * API/JSBase.cpp:
1890         (JSEvaluateScript):
1891         (JSCheckScriptSyntax):
1892
1893         * API/JSObjectRef.cpp:
1894         (handleExceptionIfNeeded):
1895         - The functions below all do the same exception check.  Added this helper
1896           to simplify the code.
1897         (JSClassCreate):
1898         (JSObjectMakeFunction):
1899         (JSObjectMakeArray):
1900         (JSObjectMakeDate):
1901         (JSObjectMakeError):
1902         (JSObjectMakeRegExp):
1903         (JSObjectGetProperty):
1904         (JSObjectSetProperty):
1905         (JSObjectGetPropertyAtIndex):
1906         (JSObjectSetPropertyAtIndex):
1907         (JSObjectDeleteProperty):
1908         (JSObjectCallAsFunction):
1909         (JSObjectCallAsConstructor):
1910
1911         * API/JSScriptRef.cpp:
1912         * API/JSValue.mm:
1913         (JSContainerConvertor::take):
1914         (reportExceptionToInspector):
1915
1916         * API/JSValueRef.cpp:
1917         (handleExceptionIfNeeded):
1918         - The functions below all do the same exception check.  Added this helper
1919           to simplify the code.
1920         (evernoteHackNeeded):
1921         (JSValueIsEqual):
1922         (JSValueIsInstanceOfConstructor):
1923         (JSValueCreateJSONString):
1924         (JSValueToNumber):
1925         (JSValueToStringCopy):
1926         (JSValueToObject):
1927
1928         * CMakeLists.txt:
1929         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
1930         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
1931         * JavaScriptCore.xcodeproj/project.pbxproj:
1932         - Added new files Exception.h and Exception.cpp.
1933
1934         * bindings/ScriptFunctionCall.cpp:
1935         (Deprecated::ScriptFunctionCall::call):
1936         * bindings/ScriptFunctionCall.h:
1937
1938         * bytecode/BytecodeList.json:
1939         - op_catch now had 2 operands: the exception register, and the thrown value register.
1940
1941         * bytecode/BytecodeUseDef.h:
1942         (JSC::computeDefsForBytecodeOffset):
1943         * bytecode/CodeBlock.cpp:
1944         (JSC::CodeBlock::dumpBytecode):
1945         (JSC::CodeBlock::handlerForBytecodeOffset):
1946         * bytecode/CodeBlock.h:
1947         - handlerForBytecodeOffset() now can look for just Catch handlers only.
1948
1949         * bytecode/HandlerInfo.h:
1950         - Cleaned up some white space I accidentally added in a previous patch.
1951
1952         * bytecompiler/BytecodeGenerator.cpp:
1953         (JSC::BytecodeGenerator::pushTry):
1954         (JSC::BytecodeGenerator::popTryAndEmitCatch):
1955         (JSC::BytecodeGenerator::emitThrowReferenceError):
1956         (JSC::BytecodeGenerator::emitEnumeration):
1957         * bytecompiler/BytecodeGenerator.h:
1958         (JSC::BytecodeGenerator::emitThrow):
1959         * bytecompiler/NodesCodegen.cpp:
1960         (JSC::TryNode::emitBytecode):
1961         - Adding support for op_catch's 2 operands.
1962
1963         * debugger/Debugger.cpp:
1964         (JSC::Debugger::hasBreakpoint):
1965         (JSC::Debugger::pauseIfNeeded):
1966         (JSC::Debugger::exception):
1967         * debugger/Debugger.h:
1968         * debugger/DebuggerCallFrame.cpp:
1969         (JSC::DebuggerCallFrame::thisValue):
1970         (JSC::DebuggerCallFrame::evaluate):
1971         * debugger/DebuggerCallFrame.h:
1972         (JSC::DebuggerCallFrame::isValid):
1973         * inspector/InjectedScriptManager.cpp:
1974         (Inspector::InjectedScriptManager::createInjectedScript):
1975         * inspector/InspectorEnvironment.h:
1976         * inspector/JSGlobalObjectInspectorController.cpp:
1977         (Inspector::JSGlobalObjectInspectorController::appendAPIBacktrace):
1978         (Inspector::JSGlobalObjectInspectorController::reportAPIException):
1979         * inspector/JSGlobalObjectInspectorController.h:
1980         * inspector/JSGlobalObjectScriptDebugServer.h:
1981         * inspector/JSJavaScriptCallFrame.cpp:
1982         (Inspector::JSJavaScriptCallFrame::evaluate):
1983         * inspector/JavaScriptCallFrame.h:
1984         (Inspector::JavaScriptCallFrame::vmEntryGlobalObject):
1985         (Inspector::JavaScriptCallFrame::thisValue):
1986         (Inspector::JavaScriptCallFrame::evaluate):
1987         * inspector/ScriptCallStackFactory.cpp:
1988         (Inspector::extractSourceInformationFromException):
1989         (Inspector::createScriptCallStackFromException):
1990         * inspector/ScriptCallStackFactory.h:
1991         * inspector/ScriptDebugServer.cpp:
1992         (Inspector::ScriptDebugServer::evaluateBreakpointAction):
1993         (Inspector::ScriptDebugServer::handleBreakpointHit):
1994         (Inspector::ScriptDebugServer::handleExceptionInBreakpointCondition):
1995         * inspector/ScriptDebugServer.h:
1996         * interpreter/CallFrame.h:
1997         (JSC::ExecState::clearException):
1998         (JSC::ExecState::exception):
1999         (JSC::ExecState::hadException):
2000         (JSC::ExecState::atomicStringTable):
2001         (JSC::ExecState::propertyNames):
2002         (JSC::ExecState::clearSupplementaryExceptionInfo): Deleted.
2003
2004         * interpreter/Interpreter.cpp:
2005         (JSC::unwindCallFrame):
2006         (JSC::Interpreter::stackTraceAsString):
2007         (JSC::GetCatchHandlerFunctor::GetCatchHandlerFunctor):
2008         (JSC::GetCatchHandlerFunctor::operator()):
2009         (JSC::Interpreter::unwind):
2010         - Added a check for didNotifyInspectorOfThrow() here to prevent duplicate reports
2011           of the same Exception to the debugger.
2012
2013         (JSC::GetExceptionHandlerFunctor::GetExceptionHandlerFunctor): Deleted.
2014         (JSC::GetExceptionHandlerFunctor::operator()): Deleted.
2015         - Renamed GetExceptionHandlerFunctor to GetCatchHandlerFunctor since the debugger
2016           is only interested in knowing whether we have Catch handlers.
2017
2018         * interpreter/Interpreter.h:
2019         (JSC::SuspendExceptionScope::SuspendExceptionScope):
2020         (JSC::SuspendExceptionScope::~SuspendExceptionScope):
2021         (JSC::Interpreter::sampler):
2022         (JSC::ClearExceptionScope::ClearExceptionScope): Deleted.
2023         (JSC::ClearExceptionScope::~ClearExceptionScope): Deleted.
2024         - Renamed ClearExceptionScope to SuspendExceptionScope because "clear" implies that
2025           we're purging the exception.  Instead, we're merely suspending any handling of
2026           that exception for a period defined by the scope.
2027
2028         * jit/AssemblyHelpers.cpp:
2029         (JSC::AssemblyHelpers::emitExceptionCheck):
2030
2031         * jit/JITExceptions.cpp:
2032         (JSC::genericUnwind):
2033         - Removed the exception argument.  It is always the value in VM::exception() anyway.
2034           genericUnwind() can just get it from the VM, and save everyone some work.
2035
2036         * jit/JITExceptions.h:
2037         * jit/JITOpcodes.cpp:
2038         (JSC::JIT::emit_op_catch):
2039         * jit/JITOpcodes32_64.cpp:
2040         (JSC::JIT::privateCompileCTINativeCall):
2041         (JSC::JIT::emit_op_catch):
2042         - Add support for the new op_catch operands.
2043
2044         * jit/JITOperations.cpp:
2045         * jit/ThunkGenerators.cpp:
2046         (JSC::nativeForGenerator):
2047         * jsc.cpp:
2048         (functionRun):
2049         (functionLoad):
2050         (runWithScripts):
2051         (runInteractive):
2052         * llint/LLIntOffsetsExtractor.cpp:
2053         * llint/LLIntSlowPaths.cpp:
2054         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
2055
2056         * llint/LowLevelInterpreter32_64.asm:
2057         * llint/LowLevelInterpreter64.asm:
2058         - Add support for the new op_catch operands.  Also update the code to handle
2059           VM::m_exception being an Exception pointer, not a JSValue.
2060
2061         * parser/NodeConstructors.h:
2062         (JSC::TryNode::TryNode):
2063         * parser/Nodes.h:
2064         * runtime/CallData.cpp:
2065         (JSC::call):
2066         * runtime/CallData.h:
2067
2068         * runtime/Completion.cpp:
2069         (JSC::evaluate):
2070         * runtime/Completion.h:
2071         (JSC::evaluate):
2072         - Change evaluate() to take a reference to the returned exception value instead
2073           of a pointer.  In all but 2 or 3 cases, we want the returned exception anyway.
2074           Might as well simplify the code by requiring the reference.
2075
2076         * runtime/Error.h:
2077         (JSC::throwVMError):
2078         (JSC::throwVMTypeError):
2079
2080         * runtime/Exception.cpp: Added.
2081         (JSC::Exception::create):
2082         (JSC::Exception::destroy):
2083         (JSC::Exception::createStructure):
2084         (JSC::Exception::visitChildren):
2085         (JSC::Exception::Exception):
2086         (JSC::Exception::~Exception):
2087         * runtime/Exception.h: Added.
2088         (JSC::Exception::valueOffset):
2089         (JSC::Exception::cast):
2090         (JSC::Exception::value):
2091         (JSC::Exception::stack):
2092         (JSC::Exception::didNotifyInspectorOfThrow):
2093         (JSC::Exception::setDidNotifyInspectorOfThrow):
2094
2095         * runtime/ExceptionHelpers.cpp:
2096         (JSC::createTerminatedExecutionException):
2097         (JSC::isTerminatedExecutionException):
2098         (JSC::createStackOverflowError):
2099         * runtime/ExceptionHelpers.h:
2100         * runtime/GetterSetter.cpp:
2101         (JSC::callGetter):
2102         * runtime/IteratorOperations.cpp:
2103         (JSC::iteratorClose):
2104         * runtime/JSObject.cpp:
2105         * runtime/JSPromiseConstructor.cpp:
2106         (JSC::constructPromise):
2107         * runtime/JSPromiseDeferred.cpp:
2108         (JSC::updateDeferredFromPotentialThenable):
2109         (JSC::abruptRejection):
2110         * runtime/JSPromiseReaction.cpp:
2111         (JSC::ExecutePromiseReactionMicrotask::run):
2112
2113         * runtime/VM.cpp:
2114         (JSC::VM::VM):
2115         (JSC::VM::releaseExecutableMemory):
2116         (JSC::VM::throwException):
2117         (JSC::VM::setStackPointerAtVMEntry):
2118         (JSC::VM::getExceptionInfo): Deleted.
2119         (JSC::VM::setExceptionInfo): Deleted.
2120         (JSC::VM::clearException): Deleted.
2121         (JSC::clearExceptionStack): Deleted.
2122         * runtime/VM.h:
2123         (JSC::VM::targetMachinePCForThrowOffset):
2124         (JSC::VM::clearException):
2125         (JSC::VM::setException):
2126         (JSC::VM::exception):
2127         (JSC::VM::addressOfException):
2128         (JSC::VM::exceptionStack): Deleted.
2129         * runtime/VMEntryScope.cpp:
2130         (JSC::VMEntryScope::VMEntryScope):
2131         (JSC::VMEntryScope::setEntryScopeDidPopListener):
2132
2133 2015-06-04  Benjamin Poulain  <bpoulain@apple.com>
2134
2135         [JSC] Always track out-of-bounds array access explicitly instead of relying on the slow case
2136         https://bugs.webkit.org/show_bug.cgi?id=145673
2137
2138         Reviewed by Geoffrey Garen.
2139
2140         Previously, we were deciding to use out-of-bounds speculation based on two informations:
2141         -Explicitly detected out-of-bounds accesses tracked on ArrayProfile.
2142         -The number of time we took the slow cases in the baseline JIT.
2143
2144         The heuristic based on slow cases was a little too fragile.
2145
2146         In some cases, we were running into that limit just because the indexing type changes between
2147         two values (typically Int32Array and DoubleArray). Sometimes we were just unlucky on what
2148         we used for the inline cache.
2149
2150         In Kraken, this was hurting us on "audio-beat-detection" and "audio-fft". The array types we see
2151         change between Int32 and Double. We run into the slow path a bit but never hit
2152         out-of-bounds.
2153
2154         By the time we compile in DFG, we have stable Double Arrays but we speculate out-of-bounds based
2155         on the number of slow cases we took. Because of that, we start boxing the double on GetByVal,
2156         using DoubleRep, etc. adding a ton of overhead over otherwise very simple operations.
2157
2158         WebXPRT was also suffering from this problem but the other way arround: we were missing
2159         the out-of-bounds accesses due to changes in indexing types, we were below the threshold
2160         of slow-path access, thus we predicted in-bounds accesses for code that was doing plenty
2161         of out-of-bands.
2162
2163
2164         This patch fixes the problem by tracking the out-of-bounds access explicitly any time we go
2165         into the slow path in baseline JIT. Since we no longer miss any out-of-bounds, we can remove
2166         the slow-path heuristic.
2167
2168         There is new additional special case in the C code regarding out-of-bounds: Arguments access.
2169         Mispredicting out-of-bounds accesses on arguments is a disaster for performance, so those are
2170         tracked in the way DFG expect it.
2171
2172
2173         There are a few important cases that are still not covered optimally:
2174         -PutByVal on Arguments.
2175         -Get/Put ByVal on TypedArray.
2176         Those are simply not used by DFG in any way. TypedArrays should probably be looked at in the future.
2177
2178         * bytecode/ArrayProfile.cpp:
2179         (JSC::ArrayProfile::computeUpdatedPrediction):
2180         The inline-cache repatch cases now update the ArrayProfile information. This has no value in baseline
2181         JIT but it helps avoiding one recompile in DFG for the missing ArrayProfile information.
2182
2183         * bytecode/ArrayProfile.h:
2184         (JSC::ArrayProfile::setOutOfBounds):
2185         * dfg/DFGByteCodeParser.cpp:
2186         (JSC::DFG::ByteCodeParser::getArrayMode):
2187         (JSC::DFG::ByteCodeParser::parseBlock):
2188         (JSC::DFG::ByteCodeParser::getArrayModeConsideringSlowPath): Deleted.
2189         * jit/CCallHelpers.h:
2190         (JSC::CCallHelpers::setupArgumentsWithExecState):
2191         * jit/JIT.h:
2192         * jit/JITInlines.h:
2193         (JSC::JIT::callOperation):
2194         * jit/JITOpcodes.cpp:
2195         (JSC::JIT::emitSlow_op_has_indexed_property):
2196         * jit/JITOpcodes32_64.cpp:
2197         (JSC::JIT::emitSlow_op_has_indexed_property):
2198         * jit/JITOperations.cpp:
2199         (JSC::canUseFastArgumentAccess):
2200         This is not my favorite part of this patch.
2201
2202         I tried having JSObject::canGetIndexQuickly() handle arguments which would put everything
2203         on the generic path. Unfortunately, that code is very performance sensitive and some benchmarks were
2204         impacted by over 10%
2205
2206         I left JSObject::canGetIndexQuickly() alone, and I added the canUseFastArgumentAccess() mirroring
2207         how DFG uses out-of-bounds for Arguments.
2208
2209         (JSC::getByVal):
2210         * jit/JITOperations.h:
2211         * jit/JITPropertyAccess.cpp:
2212         (JSC::JIT::emitSlow_op_get_by_val):
2213         (JSC::JIT::emitSlow_op_put_by_val):
2214         * jit/JITPropertyAccess32_64.cpp:
2215         (JSC::JIT::emitSlow_op_get_by_val):
2216         (JSC::JIT::emitSlow_op_put_by_val):
2217         * runtime/JSPromiseFunctions.cpp:
2218         * tests/stress/get-by-val-out-of-bounds-basics.js: Added.
2219         (opaqueGetByValOnInt32ArrayEarlyOutOfBounds):
2220         (testInt32ArrayEarlyOutOfBounds):
2221         (testIndexingTypeChangesOnInt32Array):
2222         (opaqueGetByValOnStringArrayHotOutOfBounds):
2223         (testStringArrayHotOutOfBounds):
2224         (testIndexingTypeChangesOnStringArray):
2225         (opaqueGetByValOnStringAndInt32ArrayHotOutOfBounds):
2226         (testStringAndInt32ArrayHotOutOfBounds):
2227         (opaqueGetByValOnDoubleArrayHotOutOfBounds):
2228         * tests/stress/put-by-val-out-of-bounds-basics.js: Added.
2229         (opaquePutByValOnInt32ArrayEarlyOutOfBounds):
2230         (testInt32ArrayEarlyOutOfBounds):
2231         (opaquePutByValOnStringArrayHotOutOfBounds):
2232         (testStringArrayHotOutOfBounds):
2233
2234 2015-06-03  Filip Pizlo  <fpizlo@apple.com>
2235
2236         Simplify unboxing of double JSValues known to be not NaN and not Int32
2237         https://bugs.webkit.org/show_bug.cgi?id=145618
2238
2239         Reviewed by Geoffrey Garen.
2240         
2241         In many cases we know that we most likely loaded a non-NaN double value from the heap.
2242         Prior to this patch, we would do two branches before unboxing the double. This patch
2243         reduces this to one branch in the common case. Before:
2244         
2245             if (is int32)
2246                 unbox int32 and convert to double
2247             else if (is number)
2248                 unbox double
2249             else
2250                 exit
2251         
2252         After:
2253
2254             tmp = unbox double
2255             if (tmp == tmp)
2256                 done
2257             else if (is int32)
2258                 unbox int32 and convert to double
2259             else
2260                 exit
2261         
2262         We only use the new style if we have profiling that tells us that we are unlikely to see
2263         either Int32 or NaN - since we will now exit on NaN and int32 requires an extra branch.
2264         
2265         This is a 8% speed-up on Octane/box2d. On one microbenchmark this is a 25% speed-up.
2266         
2267         Rolling this back in after I made DFG::SpeculativeJIT call a new version of unboxDouble()
2268         that doesn't assert that the JSValue is a double, since we are intentionally using it
2269         before doing the "is a double" test. This wasn't a problem on 32-bit since unboxDouble()
2270         does no such assertion on 32-bit.
2271
2272         * dfg/DFGAbstractInterpreterInlines.h:
2273         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
2274         * dfg/DFGFixupPhase.cpp:
2275         (JSC::DFG::FixupPhase::observeUseKindOnNode):
2276         (JSC::DFG::FixupPhase::fixEdgeRepresentation):
2277         (JSC::DFG::FixupPhase::injectTypeConversionsForEdge):
2278         * dfg/DFGNode.h:
2279         (JSC::DFG::Node::shouldSpeculateDouble):
2280         (JSC::DFG::Node::shouldSpeculateDoubleReal):
2281         (JSC::DFG::Node::shouldSpeculateNumber):
2282         * dfg/DFGSafeToExecute.h:
2283         (JSC::DFG::SafeToExecuteEdge::operator()):
2284         * dfg/DFGSpeculativeJIT.cpp:
2285         (JSC::DFG::SpeculativeJIT::compileDoubleRep):
2286         (JSC::DFG::SpeculativeJIT::speculateNumber):
2287         (JSC::DFG::SpeculativeJIT::speculateRealNumber):
2288         (JSC::DFG::SpeculativeJIT::speculateDoubleRepReal):
2289         (JSC::DFG::SpeculativeJIT::speculate):
2290         (JSC::DFG::SpeculativeJIT::speculateDoubleReal): Deleted.
2291         * dfg/DFGSpeculativeJIT.h:
2292         * dfg/DFGUseKind.cpp:
2293         (WTF::printInternal):
2294         * dfg/DFGUseKind.h:
2295         (JSC::DFG::typeFilterFor):
2296         (JSC::DFG::isNumerical):
2297         * ftl/FTLCapabilities.cpp:
2298         (JSC::FTL::canCompile):
2299         * ftl/FTLLowerDFGToLLVM.cpp:
2300         (JSC::FTL::LowerDFGToLLVM::compileDoubleRep):
2301         (JSC::FTL::LowerDFGToLLVM::boxDouble):
2302         (JSC::FTL::LowerDFGToLLVM::jsValueToStrictInt52):
2303         (JSC::FTL::LowerDFGToLLVM::speculate):
2304         (JSC::FTL::LowerDFGToLLVM::speculateNumber):
2305         (JSC::FTL::LowerDFGToLLVM::speculateRealNumber):
2306         (JSC::FTL::LowerDFGToLLVM::speculateDoubleRepReal):
2307         (JSC::FTL::LowerDFGToLLVM::jsValueToDouble): Deleted.
2308         (JSC::FTL::LowerDFGToLLVM::speculateDoubleReal): Deleted.
2309         * jit/AssemblyHelpers.h:
2310         (JSC::AssemblyHelpers::branchIfNotOther):
2311         (JSC::AssemblyHelpers::branchIfInt32):
2312         (JSC::AssemblyHelpers::branchIfNotInt32):
2313         (JSC::AssemblyHelpers::branchIfNumber):
2314
2315 2015-06-04  Joseph Pecoraro  <pecoraro@apple.com>
2316
2317         Web Inspector: Class constructor appearing as Object Tree property does not include parameters
2318         https://bugs.webkit.org/show_bug.cgi?id=145661
2319
2320         Reviewed by Timothy Hatcher.
2321
2322         * inspector/InjectedScriptSource.js:
2323         (InjectedScript.prototype._classPreview):
2324         (InjectedScript.RemoteObject.prototype._appendPropertyPreviews):
2325         The string we will return for previews of class constructor functions.
2326
2327         (InjectedScript.RemoteObject):
2328         (InjectedScript.RemoteObject.prototype._describe):
2329         No longer return the class name as the description string.
2330         Instead return the class name for the RemoteObject.className.
2331
2332 2015-06-04  Commit Queue  <commit-queue@webkit.org>
2333
2334         Unreviewed, rolling out r185216.
2335         https://bugs.webkit.org/show_bug.cgi?id=145666
2336
2337         it caused a bunch of debug crashes (Requested by pizlo on
2338         #webkit).
2339
2340         Reverted changeset:
2341
2342         "Simplify unboxing of double JSValues known to be not NaN and
2343         not Int32"
2344         https://bugs.webkit.org/show_bug.cgi?id=145618
2345         http://trac.webkit.org/changeset/185216
2346
2347 2015-06-03  Filip Pizlo  <fpizlo@apple.com>
2348
2349         Simplify unboxing of double JSValues known to be not NaN and not Int32
2350         https://bugs.webkit.org/show_bug.cgi?id=145618
2351
2352         Reviewed by Geoffrey Garen.
2353         
2354         In many cases we know that we most likely loaded a non-NaN double value from the heap.
2355         Prior to this patch, we would do two branches before unboxing the double. This patch
2356         reduces this to one branch in the common case. Before:
2357         
2358             if (is int32)
2359                 unbox int32 and convert to double
2360             else if (is number)
2361                 unbox double
2362             else
2363                 exit
2364         
2365         After:
2366
2367             tmp = unbox double
2368             if (tmp == tmp)
2369                 done
2370             else if (is int32)
2371                 unbox int32 and convert to double
2372             else
2373                 exit
2374         
2375         We only use the new style if we have profiling that tells us that we are unlikely to see
2376         either Int32 or NaN - since we will now exit on NaN and int32 requires an extra branch.
2377         
2378         This is a 8% speed-up on Octane/box2d. On one microbenchmark this is a 25% speed-up.
2379
2380         * dfg/DFGAbstractInterpreterInlines.h:
2381         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
2382         * dfg/DFGFixupPhase.cpp:
2383         (JSC::DFG::FixupPhase::observeUseKindOnNode):
2384         (JSC::DFG::FixupPhase::fixEdgeRepresentation):
2385         (JSC::DFG::FixupPhase::injectTypeConversionsForEdge):
2386         * dfg/DFGNode.h:
2387         (JSC::DFG::Node::shouldSpeculateDouble):
2388         (JSC::DFG::Node::shouldSpeculateDoubleReal):
2389         (JSC::DFG::Node::shouldSpeculateNumber):
2390         * dfg/DFGSafeToExecute.h:
2391         (JSC::DFG::SafeToExecuteEdge::operator()):
2392         * dfg/DFGSpeculativeJIT.cpp:
2393         (JSC::DFG::SpeculativeJIT::compileDoubleRep):
2394         (JSC::DFG::SpeculativeJIT::speculateNumber):
2395         (JSC::DFG::SpeculativeJIT::speculateRealNumber):
2396         (JSC::DFG::SpeculativeJIT::speculateDoubleRepReal):
2397         (JSC::DFG::SpeculativeJIT::speculate):
2398         (JSC::DFG::SpeculativeJIT::speculateDoubleReal): Deleted.
2399         * dfg/DFGSpeculativeJIT.h:
2400         * dfg/DFGUseKind.cpp:
2401         (WTF::printInternal):
2402         * dfg/DFGUseKind.h:
2403         (JSC::DFG::typeFilterFor):
2404         (JSC::DFG::isNumerical):
2405         * ftl/FTLCapabilities.cpp:
2406         (JSC::FTL::canCompile):
2407         * ftl/FTLLowerDFGToLLVM.cpp:
2408         (JSC::FTL::LowerDFGToLLVM::compileDoubleRep):
2409         (JSC::FTL::LowerDFGToLLVM::boxDouble):
2410         (JSC::FTL::LowerDFGToLLVM::jsValueToStrictInt52):
2411         (JSC::FTL::LowerDFGToLLVM::speculate):
2412         (JSC::FTL::LowerDFGToLLVM::speculateNumber):
2413         (JSC::FTL::LowerDFGToLLVM::speculateRealNumber):
2414         (JSC::FTL::LowerDFGToLLVM::speculateDoubleRepReal):
2415         (JSC::FTL::LowerDFGToLLVM::jsValueToDouble): Deleted.
2416         (JSC::FTL::LowerDFGToLLVM::speculateDoubleReal): Deleted.
2417         * jit/AssemblyHelpers.h:
2418         (JSC::AssemblyHelpers::branchIfNotOther):
2419         (JSC::AssemblyHelpers::branchIfInt32):
2420         (JSC::AssemblyHelpers::branchIfNotInt32):
2421         (JSC::AssemblyHelpers::branchIfNumber):
2422
2423 2015-06-04  Filip Pizlo  <fpizlo@apple.com>
2424
2425         SideState should be a distinct abstract heap from Heap and Stack
2426         https://bugs.webkit.org/show_bug.cgi?id=145653
2427
2428         Reviewed by Geoffrey Garen.
2429         
2430         Before, SideState fit into the hierarchy like so:
2431         
2432         World
2433            |
2434            +-- Stack
2435            |
2436            +-- Heap
2437                  |
2438                  +-- SideState
2439         
2440         Now we will have:
2441         
2442         World
2443            |
2444            +-- Stack
2445            |
2446            +-- Heap
2447            |
2448            +-- SideState
2449         
2450         This makes it easy to ask if a writing operation wrote to anything that is observable even
2451         if we don't exit. SideState is only observable if we exit.
2452
2453         * dfg/DFGAbstractHeap.h:
2454         (JSC::DFG::AbstractHeap::AbstractHeap):
2455         (JSC::DFG::AbstractHeap::supertype):
2456
2457 2015-06-04  Chris Dumez  <cdumez@apple.com>
2458
2459         [WK2] Prune more resources from the MemoryCache before process suspension
2460         https://bugs.webkit.org/show_bug.cgi?id=145633
2461
2462         Reviewed by Andreas Kling.
2463
2464         No longer move protect IncrementalSweeper::fullSweep() behind
2465         USE(CF) so we don't need #ifdefs at call sites, similarly to what is
2466         done for the rest of the IncrementalSweeper API.
2467
2468         * heap/IncrementalSweeper.cpp:
2469         (JSC::IncrementalSweeper::fullSweep):
2470         * heap/IncrementalSweeper.h:
2471
2472 2015-06-01  Filip Pizlo  <fpizlo@apple.com>
2473
2474         CallLinkStatus should return takesSlowPath if the GC often cleared the IC
2475         https://bugs.webkit.org/show_bug.cgi?id=145502
2476
2477         Reviewed by Geoffrey Garen.
2478         
2479         CallLinkInfo now remembers when it has been cleared by GC. This has some safeguards for when
2480         a call gets cleared by GC only because we hadn't converted it into a closure call; in that
2481         case the GC will just tell us that it should be a closure call. The DFG will not optimize
2482         a call that was cleared by GC, and the DFG will always prefer a closure call if the GC told
2483         us that the specific callee was dead but the executable wasn't.
2484         
2485         This guards us from some scenarios that came up in Speedometer. It's neutral on the pure JS
2486         benchmarks, most likely just because those benchmarks aren't real enough to have interesting
2487         GC of code.
2488
2489         * bytecode/CallLinkInfo.cpp:
2490         (JSC::CallLinkInfo::visitWeak):
2491         (JSC::CallLinkInfo::dummy):
2492         * bytecode/CallLinkInfo.h:
2493         (JSC::CallLinkInfo::CallLinkInfo):
2494         * bytecode/CallLinkStatus.cpp:
2495         (JSC::CallLinkStatus::computeFromCallLinkInfo):
2496
2497 2015-06-02  Filip Pizlo  <fpizlo@apple.com>
2498
2499         GetById and PutById profiling should be more precise about it takes slow path
2500         https://bugs.webkit.org/show_bug.cgi?id=145590
2501
2502         Reviewed by Geoffrey Garen.
2503         
2504         If a ById access ever takes slow path, we want the DFG and FTL to know this. Previously we
2505         were relying on slow path counts, which conflate slow paths taken due to a megamorphic
2506         access and slow paths taken due to IC building.
2507
2508         * bytecode/GetByIdStatus.cpp:
2509         (JSC::GetByIdStatus::computeFor):
2510         (JSC::GetByIdStatus::computeForStubInfo):
2511         * bytecode/PutByIdStatus.cpp:
2512         (JSC::PutByIdStatus::computeFor):
2513         (JSC::PutByIdStatus::computeForStubInfo):
2514         * bytecode/StructureStubInfo.h:
2515         (JSC::StructureStubInfo::StructureStubInfo):
2516         * ftl/FTLIntrinsicRepository.h:
2517         * ftl/FTLLowerDFGToLLVM.cpp:
2518         (JSC::FTL::LowerDFGToLLVM::compileGetById):
2519         * jit/JITOperations.cpp:
2520         * jit/JITOperations.h:
2521
2522 2015-06-03  Michael Saboff  <msaboff@apple.com>
2523
2524         Improve test coverage for changes made in 145527
2525         https://bugs.webkit.org/show_bug.cgi?id=145578
2526
2527         Reviewed by Geoffrey Garen.
2528
2529         Added more complexity to poly-setter-combo.js stress test to create more turmoil in the
2530         polymorphic get-by-id / put-by-id with getters and setters to exercise the code change in
2531         https://bugs.webkit.org/show_bug.cgi?id=145527.  By changing the objects that the main test
2532         function sees, we are able to test those paths.  Verified with temporary logging code.
2533
2534         * tests/stress/poly-setter-combo.js:
2535         (Cons2):
2536         (Cons3):
2537         (Cons4):
2538         (foo):
2539         (test):
2540         (runTestWithConstructors):
2541
2542 2015-06-02  Mark Lam  <mark.lam@apple.com>
2543
2544         Gardening: fix broken CLoop build.
2545
2546         Not reviewed.
2547
2548         * bytecode/CallLinkStatus.cpp:
2549         (JSC::CallLinkStatus::computeExitSiteData):
2550
2551 2015-06-02  Keith Miller  <keith_miller@apple.com>
2552
2553         JavaScriptCore: JSExport protocol with an NSInteger property converts negative values to 18446744073709552000
2554         https://bugs.webkit.org/show_bug.cgi?id=145563
2555
2556         Reviewed by Darin Adler.
2557
2558         The Objective-C bindings were improperly converting negative
2559         long long/NSIntegers to 18446744073709552000 because they
2560         were converted to unsigned numbers.
2561
2562         * API/ObjcRuntimeExtras.h:
2563         (parseObjCType):
2564         * API/tests/testapi.mm:
2565         (testObjectiveCAPIMain):
2566         (checkNegativeNSIntegers):
2567         (testObjectiveCAPI):
2568
2569 2015-06-02  Yusuke Suzuki  <utatane.tea@gmail.com>
2570
2571         Heap-use-after-free read of size 4 in JavaScriptCore: WTF::StringImpl::isSymbol() (StringImpl.h:496)
2572         https://bugs.webkit.org/show_bug.cgi?id=145532
2573
2574         Reviewed by Geoffrey Garen.
2575
2576         AtomicStringImpl::lookUp returns AtomicStringImpl*,
2577         it doesn't give any ownership to the caller.
2578         Originally, this is ok because the ownership is taken
2579         by AtomicStringImpl's table (& the register side).
2580
2581         But if we would like to use this returned AtomicStringImpl*,
2582         we should take its ownership immediately.
2583         Because if the register side releases its ownership (ref count),
2584         it will be destroyed.
2585
2586         In JSString::toExistingAtomicString, it returns AtomicStringImpl*.
2587         But it's not appropriate.
2588         If the owner of AtomicStringImpl* is always JSString*, it is ok.
2589         But it looks up the table-registered AtomicStringImpl* from
2590         the AtomicStringImpl table. So JSString* may not have the ownership
2591         of the returned AtomicStringImpl*.
2592
2593         The failure situation is the following.
2594
2595         1. A creates AtomicStringImpl. A has its ownership.
2596            And A registers it to AtomicStringImpl table.
2597         2. JSString looks up the AtomicStringImpl from the table.
2598            It gets AtomicStringImpl*. And JSString doesn't have its ownership.
2599            It returns the raw pointer immediately to the users
2600         3. A is released. There's no owner for AtomicStringImpl*.
2601            So it's also destroyed.
2602         4. Use looked up AtomicStringImpl in (2). It becomes use-after-free.
2603
2604         This patch fixes it by the following changes.
2605
2606         1. Change the signature of `AtomicStringImpl* AtomicStringImpl::lookUp(...)`
2607            to `RefPtr<AtomicStringImpl> AtomicStringImpl::lookUp(..)`.
2608            Use `RefPtr` because it may return `nullptr`.
2609         2. Change the signature of `AtomicStringImpl* JSString::toExistingAtomicString(...)`
2610            to `RefPtr<AtomicStringImpl> JSString::toExistingAtomicString(...)`.
2611            Using `RefPtr` is the same reason.
2612         3. Receive the result with `RefPtr<AtomicStringImpl>` in the caller side.
2613
2614         * dfg/DFGOperations.cpp:
2615         * jit/JITOperations.cpp:
2616         (JSC::getByVal):
2617         * llint/LLIntSlowPaths.cpp:
2618         (JSC::LLInt::getByVal):
2619         * runtime/JSString.cpp:
2620         (JSC::JSRopeString::resolveRopeToExistingAtomicString):
2621         * runtime/JSString.h:
2622         (JSC::JSString::toExistingAtomicString):
2623
2624 2015-05-30  Filip Pizlo  <fpizlo@apple.com>
2625
2626         Any exit from any JIT due to profiling for an inline cache should force all future compilations to be wary
2627         https://bugs.webkit.org/show_bug.cgi?id=145496
2628
2629         Reviewed by Geoffrey Garen.
2630         
2631         This pessimizes compilation a bit, but it reduces the likelihood of exiting from FTL. I
2632         couldn't find any convincing reason not to do this, and we know from Speedometer that this
2633         change is necessary for weirder code.
2634
2635         * bytecode/CallLinkStatus.cpp:
2636         (JSC::CallLinkStatus::computeFor):
2637         (JSC::CallLinkStatus::computeExitSiteData):
2638         (JSC::CallLinkStatus::computeDFGStatuses):
2639         * bytecode/CallLinkStatus.h:
2640         * bytecode/GetByIdStatus.cpp:
2641         (JSC::GetByIdStatus::appendVariant):
2642         (JSC::GetByIdStatus::hasExitSite):
2643         (JSC::GetByIdStatus::computeFor):
2644         * bytecode/GetByIdStatus.h:
2645         * bytecode/PutByIdStatus.cpp:
2646         (JSC::PutByIdStatus::appendVariant):
2647         (JSC::PutByIdStatus::hasExitSite):
2648         (JSC::PutByIdStatus::computeFor):
2649         * bytecode/PutByIdStatus.h:
2650
2651 2015-05-31  Filip Pizlo  <fpizlo@apple.com>
2652
2653         If a call has ever taken the virtual slow path, make sure that the DFG knows this
2654         https://bugs.webkit.org/show_bug.cgi?id=145501
2655
2656         Reviewed by Geoffrey Garen.
2657         
2658         Now now return higher fidelity information in the case of no polymorphic call stub. If the
2659         virtual slow path was ever taken, we note this, and we note either zero or one call variant
2660         based on the IC's last callee.
2661
2662         * bytecode/CallLinkStatus.cpp:
2663         (JSC::CallLinkStatus::computeFromCallLinkInfo):
2664         (JSC::CallLinkStatus::computeFor):
2665
2666 2015-06-01  Michael Saboff  <msaboff@apple.com>
2667
2668         Crash in com.apple.WebKit.WebContent at com.apple.JavaScriptCore: JSC::revertCall + 24
2669         https://bugs.webkit.org/show_bug.cgi?id=145527
2670
2671         Reviewed by Filip Pizlo.
2672
2673         If a CallLinkInfo is GC'ed, we need to notify any PolymorphicCallNode's that reference it.
2674         Added plumbling to clear the m_callLinkInfo of a PolymorphicCallNode when that CallLinkInfo
2675         is going away.
2676
2677         * bytecode/CallLinkInfo.h:
2678         (JSC::CallLinkInfo::~CallLinkInfo):
2679         * jit/PolymorphicCallStubRoutine.cpp:
2680         (JSC::PolymorphicCallNode::unlink):
2681         (JSC::PolymorphicCallNode::clearCallLinkInfo):
2682         (JSC::PolymorphicCallCase::dump):
2683         (JSC::PolymorphicCallStubRoutine::edges):
2684         (JSC::PolymorphicCallStubRoutine::clearCallNodesFor):
2685         (JSC::PolymorphicCallStubRoutine::visitWeak):
2686         * jit/PolymorphicCallStubRoutine.h:
2687         (JSC::PolymorphicCallNode::hasCallLinkInfo):
2688
2689 2015-06-01  Mark Lam  <mark.lam@apple.com>
2690
2691         Add the ability to tell between Catch and Finally blocks.
2692         https://bugs.webkit.org/show_bug.cgi?id=145524 
2693
2694         Reviewed by Michael Saboff.
2695
2696         ... and also SynthesizedFinally blocks too.  A SynthesizedFinally block
2697         is a finally block that is synthesized by the bytecode generator but
2698         does not actually correspond to any exception handling construct at the
2699         JS source code level.  An example of this is the "for ... of" statement
2700         where it needs to do some "final" clean up before passing on the
2701         exception.
2702
2703         Manually tested by inspecting the bytecode dump of functions with
2704         try-catch-finally blocks as well as for of statements which have
2705         synthesized finally blocks.  The bytecode dumps contains the exception
2706         handlers table which has these blocks labelled with their newly added
2707         types.  No automatic test because this type info is not visible to JS
2708         code.
2709
2710         * bytecode/CodeBlock.cpp:
2711         (JSC::CodeBlock::dumpBytecode):
2712         * bytecode/HandlerInfo.h:
2713         (JSC::HandlerInfoBase::type):
2714         (JSC::HandlerInfoBase::setType):
2715         (JSC::HandlerInfoBase::typeName):
2716         (JSC::HandlerInfoBase::isCatchHandler):
2717         (JSC::UnlinkedHandlerInfo::UnlinkedHandlerInfo):
2718         (JSC::HandlerInfo::initialize):
2719         * bytecompiler/BytecodeGenerator.cpp:
2720         (JSC::BytecodeGenerator::generate):
2721         (JSC::BytecodeGenerator::pushTry):
2722         (JSC::BytecodeGenerator::popTryAndEmitCatch):
2723         (JSC::BytecodeGenerator::emitEnumeration):
2724         * bytecompiler/BytecodeGenerator.h:
2725         (JSC::BytecodeGenerator::emitThrow):
2726         * bytecompiler/NodesCodegen.cpp:
2727         (JSC::TryNode::emitBytecode):
2728
2729 2015-05-29  Geoffrey Garen  <ggaren@apple.com>
2730
2731         REGRESSION: These sorting idioms used by Peacekeeper and Browsermark are ~20X slower
2732         https://bugs.webkit.org/show_bug.cgi?id=145412
2733
2734         Reviewed by Darin Adler.
2735
2736         Moar speedup.
2737
2738         Added a bucket sort for string sorting.
2739
2740         * builtins/Array.prototype.js:
2741         (sort.compactSparse):
2742         (sort.compactSlow):
2743         (sort.compact): Split out a compaction fast path for dense arrays. Without
2744         it, compaction can increase sort time by 2X for simple sorts.
2745
2746         (sort.bucketSort):
2747         (sort.stringSort): Use a bucket sorting algorithm if we know we're sorting
2748         strings. This makes average case string sorting O(N) with O(N) additional
2749         memory use.
2750
2751         The worst case bucket sort can require O(M * N) additional
2752         space. We avoid this by falling back to merge sort when things are
2753         simple or overly duplicative. These are the two cases that accumulate
2754         excessive -- and potentially pathological -- bucketing overhead.
2755
2756 2015-06-01  Mark Lam  <mark.lam@apple.com>
2757
2758         HandlerInfo::initialize() should not assume that CodeLocationLabel is available.
2759         https://bugs.webkit.org/show_bug.cgi?id=145515
2760
2761         Reviewed by Csaba Osztrogonác.
2762
2763         CodeLocationLabel is only defined for ENABLE(ASSEMBLER) builds.  r185022's
2764         attempt at simplifying code to increase readability failed to take this into
2765         account.  This patch fixes it.
2766
2767         * bytecode/CodeBlock.cpp:
2768         (JSC::CodeBlock::CodeBlock):
2769         * bytecode/HandlerInfo.h:
2770         (JSC::HandlerInfo::initialize):
2771
2772 2015-05-31  Filip Pizlo  <fpizlo@apple.com>
2773
2774         Unreviewed, add a FIXME referencing https://bugs.webkit.org/show_bug.cgi?id=145503.
2775
2776         * dfg/DFGByteCodeParser.cpp:
2777         (JSC::DFG::ByteCodeParser::inliningCost):
2778
2779 2015-05-31  Yusuke Suzuki  <utatane.tea@gmail.com>
2780
2781         [ES6] Drop WeakMap#clear
2782         https://bugs.webkit.org/show_bug.cgi?id=145489
2783
2784         Reviewed by Mark Lam.
2785
2786         ES6 spec intentionally drops the WeakMap#clear
2787         to allow engine to implement WeakMap as a per-object table.
2788
2789         This patch drops WeakMap.prototype.clear.
2790
2791         * runtime/WeakMapPrototype.cpp:
2792         (JSC::WeakMapPrototype::finishCreation): Deleted.
2793         (JSC::protoFuncWeakMapClear): Deleted.
2794
2795 2015-05-31  Jordan Harband  <ljharb@gmail.com>
2796
2797         Array#reduce and reduceRight don't follow ToLength
2798         https://bugs.webkit.org/show_bug.cgi?id=145364
2799         Per https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength
2800
2801         Reviewed by Yusuke Suzuki.
2802
2803         * builtins/Array.prototype.js:
2804         (reduce):
2805         (reduceRight):
2806         * runtime/ArrayPrototype.cpp:
2807         (JSC::ArrayPrototype::finishCreation):
2808         (JSC::arrayProtoFuncReduce): Deleted.
2809         (JSC::arrayProtoFuncReduceRight): Deleted.
2810
2811 2015-05-29  Filip Pizlo  <fpizlo@apple.com>
2812
2813         FTL codegen for MultiGetByOffset and MultiPutByOffset where the structure set is already proved should have an unreachable default case instead of an exit
2814         https://bugs.webkit.org/show_bug.cgi?id=145469
2815
2816         Reviewed by Geoffrey Garen.
2817         
2818         Omitting the speculation on the fail path when the speculation is guaranteed not to be
2819         taken hints to LLVM that the default case is impossible. This enables some useful
2820         optimizations.
2821
2822         * ftl/FTLLowerDFGToLLVM.cpp:
2823         (JSC::FTL::LowerDFGToLLVM::compileMultiGetByOffset):
2824         (JSC::FTL::LowerDFGToLLVM::compileMultiPutByOffset):
2825
2826 2015-05-29  Mark Lam  <mark.lam@apple.com>
2827
2828         Refactoring HandlerInfo and UnlinkedHandlerInfo.
2829         https://bugs.webkit.org/show_bug.cgi?id=145480
2830
2831         Reviewed by Benjamin Poulain.
2832
2833         HandlerInfo and UnlinkedHandlerInfo have common parts, but are not currently
2834         expressed as 2 unrelated structs that happen to have near identical fields.
2835         We can refactor them to better express their relationship.  We can also add
2836         some convenience functions to make the code that uses them a little more
2837         readable.
2838
2839         * bytecode/CodeBlock.cpp:
2840         (JSC::CodeBlock::dumpBytecode):
2841         (JSC::CodeBlock::CodeBlock):
2842         (JSC::CodeBlock::handlerForBytecodeOffset):
2843         * bytecode/HandlerInfo.h:
2844         (JSC::UnlinkedHandlerInfo::UnlinkedHandlerInfo):
2845         (JSC::HandlerInfo::initialize):
2846         - I chose to include CodeLocationLabel arg even though it is unused by
2847           by non-JIT builds.  This makes the call site cleaner to read.
2848
2849         * bytecode/UnlinkedCodeBlock.h:
2850         (JSC::UnlinkedSimpleJumpTable::add):
2851         (JSC::UnlinkedInstruction::UnlinkedInstruction):
2852         (JSC::UnlinkedCodeBlock::numberOfExceptionHandlers):
2853         (JSC::UnlinkedCodeBlock::addExceptionHandler):
2854         (JSC::UnlinkedCodeBlock::exceptionHandler):
2855         (JSC::UnlinkedCodeBlock::symbolTable):
2856         * bytecompiler/BytecodeGenerator.cpp:
2857         (JSC::BytecodeGenerator::generate):
2858
2859 2015-05-28  Filip Pizlo  <fpizlo@apple.com>
2860
2861         Non-speculative Branch should be fast in the FTL
2862         https://bugs.webkit.org/show_bug.cgi?id=145452
2863
2864         Reviewed by Andreas Kling.
2865         
2866         Inlines the code for convertJSValueToBoolean into the FTL. This also includes some other
2867         clean-ups that I found along the way.
2868         
2869         I found this by looking at the hottest functions in DeltaBlue. Despite having so many
2870         Branch specializations, apparently there was still a hot one that we missed that was going
2871         down the untyped path. It was either Int32 or Other. Maybe we could specialize for that
2872         combo, but it makes so much sense to just make all of this nonsense fast.
2873
2874         * dfg/DFGWatchpointCollectionPhase.cpp:
2875         (JSC::DFG::WatchpointCollectionPhase::handle): Need to watch the masquerades watchpoint on UntypedUse: forms of Branch now.
2876         * ftl/FTLLowerDFGToLLVM.cpp:
2877         (JSC::FTL::LowerDFGToLLVM::boolify): The actual fix.
2878         (JSC::FTL::LowerDFGToLLVM::int52ToStrictInt52):
2879         (JSC::FTL::LowerDFGToLLVM::isInt32):
2880         (JSC::FTL::LowerDFGToLLVM::isNotInt32):
2881         (JSC::FTL::LowerDFGToLLVM::unboxInt32):
2882         * runtime/JSCellInlines.h:
2883         (JSC::JSCell::toBoolean): Symbol is always true.
2884         (JSC::JSCell::pureToBoolean): Symbol is always true.
2885         * runtime/JSString.cpp:
2886         (JSC::JSString::getPrimitiveNumber):
2887         (JSC::JSString::toNumber):
2888         (JSC::JSString::toBoolean): Deleted. This is a tiny method. It doesn't need to be out-of-line.
2889         * runtime/JSString.h:
2890         (JSC::JSString::length):
2891         (JSC::JSString::toBoolean): This method shouldbe inline.
2892         * runtime/Symbol.cpp:
2893         (JSC::Symbol::toPrimitive):
2894         (JSC::Symbol::getPrimitiveNumber):
2895         (JSC::Symbol::toBoolean): Deleted. A Symbol is always true, so we don't need a method for this.
2896         * runtime/Symbol.h:
2897
2898 2015-05-29  Commit Queue  <commit-queue@webkit.org>
2899
2900         Unreviewed, rolling out r184860.
2901         https://bugs.webkit.org/show_bug.cgi?id=145456
2902
2903         May have caused ~1% Octane regression (Requested by kling on
2904         #webkit).
2905
2906         Reverted changeset:
2907
2908         "Try to use StringView when comparing JSStrings for equality."
2909         https://bugs.webkit.org/show_bug.cgi?id=145379
2910         http://trac.webkit.org/changeset/184860
2911
2912 2015-05-28  Michael Saboff  <msaboff@apple.com>
2913
2914         mozilla/js1_5/Array/regress-154338.js test causes ARM 32 bit iOS devices to run out of memory
2915         https://bugs.webkit.org/show_bug.cgi?id=145444
2916
2917         Reviewed by Geoffrey Garen.
2918
2919         Disabled mozilla/js1_5/Array/regress-154338.js when run on iOS ARM 32 bit devices and
2920         the --memory-limited option is passed to run-jsc-stress-tests.
2921
2922         * tests/mozilla/mozilla-tests.yaml:
2923
2924 2015-05-28  Benjamin Poulain  <benjamin@webkit.org>
2925
2926         [iOS8][ARMv7(s)] Optimized Object.create in 'use strict' context sometimes breaks.
2927         https://bugs.webkit.org/show_bug.cgi?id=138038
2928
2929         Reviewed by Michael Saboff.
2930
2931         TL;DR: sometimes the baseline JIT could accidentally nuke the tag before calling
2932                to C++, making put_by_id behave erratically.
2933
2934         The bug was that put_by_id would randomly not work correctly in 32bits. It happened
2935         in the baseline JIT if we were unlucky enough:
2936         -The code get hot enough and the structure is stable so we get a fast path for
2937          put_by_id.
2938         -We repatch the fast-path branch with a stub generated by
2939          emitPutTransitionStubAndGetOldStructure().
2940         -In emitPutTransitionStubAndGetOldStructure(), we only preserve the payload of the base
2941          register, the tag register is ignored.
2942         -emitPutTransitionStubAndGetOldStructure() allocate 2 to 3 registers. Any of those
2943          could be the one used for the base's tag before the fast path and the value is trashed.
2944         -If we hit one of the failure case, we fallback to the slow path, but we destroyed
2945          the tag pointer.
2946         -We now have unrelated bits in the tag, the most likely value type is now "double"
2947          and we fail the put_by_id because we try to set a property on a number.
2948
2949         The most obvious solution would be to change emitPutTransitionStubAndGetOldStructure()
2950         to preserve the tag register in addition to the value register.
2951         I decided against that option because of the added complexity. The DFG does not need
2952         that case, so I would have to add branches everywhere to distinguish the cases
2953         were we need to preserve the tag or not.
2954
2955         Instead, I just load the tag back from memory in the slow path. The function in the slow
2956         path is several order of magnitude slower than a load, it is not worth eliminating it,
2957         especially in baseline JIT.
2958
2959         I also discovered 4 useless loads in the fast path, so even with my extra load, this patch
2960         makes the baseline faster :)
2961
2962         * jit/JITPropertyAccess32_64.cpp:
2963         (JSC::JIT::emitSlow_op_put_by_id):
2964         (JSC::JIT::emit_op_put_by_id): Deleted.
2965         * tests/stress/put-by-id-on-new-object-after-prototype-transition-non-strict.js: Added.
2966         (opaqueNewObject):
2967         (putValueOnNewObject):
2968         * tests/stress/put-by-id-on-new-object-after-prototype-transition-strict.js: Added.
2969         (string_appeared_here.opaqueNewObject):
2970         (putValueOnNewObject):
2971
2972 2015-05-28  Benjamin Poulain  <benjamin@webkit.org>
2973
2974         [JSC] reduction the iteration count of the DoubleRep stress tests
2975
2976         Once again, I used big numbers for manual testing and I forgot to fix them before landing.
2977
2978         * tests/stress/double-rep-with-non-cell.js:
2979         * tests/stress/double-rep-with-null.js:
2980         * tests/stress/double-rep-with-undefined.js:
2981
2982 2015-05-28  Basile Clement  <basile_clement@apple.com>
2983
2984         Add debug mode assertions for accessors casting JSC::DFG::Node.m_opInfo
2985         https://bugs.webkit.org/show_bug.cgi?id=145441
2986
2987         Reviewed by Filip Pizlo.
2988
2989         Most accessor functions casting m_opInfo in JSC::DFG::Node are
2990         performing debug checks that they are only accessed for node types that
2991         should have them. This patch adds similar checks for the accessors that
2992         were missing them.
2993
2994         * dfg/DFGNode.h:
2995         (JSC::DFG::Node::watchpointSet):
2996         (JSC::DFG::Node::storagePointer):
2997         (JSC::DFG::Node::multiGetByOffsetData):
2998         (JSC::DFG::Node::multiPutByOffsetData):
2999         (JSC::DFG::Node::hasTypeLocation):
3000         (JSC::DFG::Node::typeLocation):
3001         (JSC::DFG::Node::hasBasicBlockLocation):
3002         (JSC::DFG::Node::basicBlockLocation):
3003
3004 2015-05-28  Matt Rajca  <mrajca@apple.com>
3005
3006         Add ENABLE_MEDIA_SESSION feature flag (which is off by default).
3007         https://bugs.webkit.org/show_bug.cgi?id=145415
3008
3009         Reviewed by Eric Carlson.
3010
3011         * Configurations/FeatureDefines.xcconfig:
3012
3013 2015-05-27  Jordan Harband  <ljharb@gmail.com>
3014
3015         Array.of should work with other constructors
3016         https://bugs.webkit.org/show_bug.cgi?id=145365
3017         Per https://people.mozilla.org/~jorendorff/es6-draft.html#sec-array.of
3018         step 4
3019
3020         Reviewed by Yusuke Suzuki.
3021
3022         * builtins/ArrayConstructor.js:
3023         (of):
3024         * runtime/ArrayConstructor.cpp:
3025         (JSC::arrayConstructorOf): Deleted.
3026
3027 2015-05-27  Benjamin Poulain  <bpoulain@apple.com>
3028
3029         [JSC] Add undefined->double conversion to DoubleRep
3030         https://bugs.webkit.org/show_bug.cgi?id=145293
3031
3032         Reviewed by Filip Pizlo.
3033
3034         This patch adds undefined to double conversion to the DoubleRep
3035         node for the cases were we speculate "undefined" as part of the types
3036         processed.
3037
3038         The use case is doing math with accidental out-of-bounds access. For example,
3039         something like:
3040             for (var i = 0; i <= length; ++i)
3041                 ouptput += array[i];
3042
3043         would cause us to OSR exit every time i === length.
3044
3045         When hitting one of those cases, we would already speculate double math,
3046         but the DoubleRep node was unable to convert the undefined and would exit.
3047
3048         With this patch the use kind NotCellUse cover this conversion for DoubleRep.
3049         I have been quite conservative so in general we will not find "undefined"
3050         until a few recompile but being optimistic seems better since this is a corner case.
3051
3052         This patch is a 80% progression on WebXPRT's DNA Sequencing test.
3053
3054         * dfg/DFGAbstractInterpreterInlines.h:
3055         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
3056         * dfg/DFGFixupPhase.cpp:
3057         (JSC::DFG::FixupPhase::injectTypeConversionsForEdge):
3058         * dfg/DFGNode.h:
3059         (JSC::DFG::Node::sawUndefined):
3060         * dfg/DFGPredictionPropagationPhase.cpp:
3061         (JSC::DFG::PredictionPropagationPhase::propagate):
3062         * dfg/DFGSafeToExecute.h:
3063         (JSC::DFG::SafeToExecuteEdge::operator()):
3064         * dfg/DFGSpeculativeJIT.cpp:
3065         (JSC::DFG::SpeculativeJIT::compileDoubleRep):
3066         * dfg/DFGUseKind.cpp:
3067         (WTF::printInternal):
3068         * dfg/DFGUseKind.h:
3069         (JSC::DFG::typeFilterFor):
3070         * ftl/FTLCapabilities.cpp:
3071         (JSC::FTL::canCompile):
3072         * ftl/FTLLowerDFGToLLVM.cpp:
3073         (JSC::FTL::LowerDFGToLLVM::compileDoubleRep):
3074         (JSC::FTL::LowerDFGToLLVM::jsValueToDouble):
3075         * tests/stress/double-rep-with-undefined.js: Added.
3076         (addArgsNumberAndUndefined):
3077         (addArgsInt32AndUndefined):
3078         (testFallbackWithDouble):
3079         (addArgsDoubleAndUndefined):
3080         (testFallbackWithObject.):
3081         (testFallbackWithObject):
3082         (addArgsOnlyUndefined):
3083         (testFallbackWithString):
3084
3085 2015-05-27  Dean Jackson  <dino@apple.com>
3086
3087         img.currentSrc problem in strict mode with old picturefill
3088         https://bugs.webkit.org/show_bug.cgi?id=144095
3089         <rdar://problem/21087013>
3090
3091         Reviewed by Simon Fraser.
3092
3093         Add a PICTURE_SIZES flag.
3094
3095         * Configurations/FeatureDefines.xcconfig:
3096
3097 2015-05-27  Basile Clement  <basile_clement@apple.com>
3098
3099         LazyNode comparison can return incorrect results when comparing an empty value
3100         https://bugs.webkit.org/show_bug.cgi?id=145421
3101
3102         Reviewed by Geoffrey Garen.
3103
3104         When comparing a LazyNode to another, we compare the value pointers if
3105         we have one, and otherwise compare the nodes.
3106         We should be comparing value pointers if the other LazyNode has one as
3107         well, otherwise we risk an incoherency when we are a empty LazyNode
3108         being compared to a FrozenValue without node.
3109
3110         Note that this is not a problem in any other case because if we don't
3111         have a FrozenValue and we are not an empty LazyNode, we are a
3112         non-constant node, and comparing the node pointers is correct.
3113
3114         * dfg/DFGLazyNode.h:
3115         (JSC::DFG::LazyNode::operator==):
3116
3117 2015-05-27  Geoffrey Garen  <ggaren@apple.com>
3118
3119         REGRESSION: These sorting idioms used by Peacekeeper and Browsermark are ~20X slower
3120         https://bugs.webkit.org/show_bug.cgi?id=145412
3121
3122         Reviewed by Benjamin Poulain.
3123
3124         Cache strings when doing a string-converting sort.
3125
3126         This is a 21% speedup.
3127
3128         * builtins/Array.prototype.js:
3129         (sort.stringComparator): Use subtraction instead of branching because
3130         it's slightly faster.
3131
3132         (sort.comparatorSort):
3133         (sort.stringSort):
3134         (sort): Add a special case for string sorting to avoid redundant string
3135         conversion.
3136
3137         * parser/Parser.cpp:
3138         (JSC::Parser<LexerType>::createBindingPattern): Names can be empty if
3139         they are private names.
3140
3141 2015-05-26  Filip Pizlo  <fpizlo@apple.com>
3142
3143         JIT-generated store barrier code should assume the buffer pointer and capacity to be compile-time constants
3144         https://bugs.webkit.org/show_bug.cgi?id=145404
3145
3146         Reviewed by Andreas Kling.
3147         
3148         We never change the capacity of a write barrier buffer. We never repoint the buffer
3149         pointer. So, the JIT shouldn't load those from memory; it should take advantage of the
3150         fact that these are compile-time constants.
3151
3152         * dfg/DFGSpeculativeJIT.cpp:
3153         (JSC::DFG::SpeculativeJIT::storeToWriteBarrierBuffer):
3154         * ftl/FTLLowerDFGToLLVM.cpp:
3155         (JSC::FTL::LowerDFGToLLVM::emitStoreBarrier):
3156         * heap/WriteBarrierBuffer.h:
3157         (JSC::WriteBarrierBuffer::currentIndexAddress):
3158         (JSC::WriteBarrierBuffer::capacity):
3159         (JSC::WriteBarrierBuffer::buffer):
3160         (JSC::WriteBarrierBuffer::currentIndexOffset): Deleted.
3161         (JSC::WriteBarrierBuffer::capacityOffset): Deleted.
3162         (JSC::WriteBarrierBuffer::bufferOffset): Deleted.
3163         * jit/Repatch.cpp:
3164         (JSC::emitPutTransitionStubAndGetOldStructure):
3165
3166 2015-05-27  Geoffrey Garen  <ggaren@apple.com>
3167
3168         REGRESSION: These sorting idioms used by Peacekeeper and Browsermark are ~20X slower
3169         https://bugs.webkit.org/show_bug.cgi?id=145412
3170
3171         Reviewed by Darin Adler.
3172
3173         Use @toString instead of the String constructor because calls to the
3174         String constructor are never optimized. (See
3175         https://bugs.webkit.org/show_bug.cgi?id=144458.)
3176
3177         This is a ~2X speedup.
3178
3179         * builtins/Array.prototype.js:
3180         (sort.stringComparator):
3181
3182 2015-05-27  Dan Bernstein  <mitz@apple.com>
3183
3184         Remove JSC_OBJC_API_AVAILABLE_MAC_OS_X_1080
3185         https://bugs.webkit.org/show_bug.cgi?id=145403
3186
3187         Reviewed by Anders Carlsson.
3188
3189         JSC_OBJC_API_AVAILABLE_MAC_OS_X_1080 was used to enable the JavaScriptCore Objective-C API
3190         for WebKit and Safari projects building with JavaScriptCore targeting OS X 10.8. We don’t
3191         need it anymore.
3192
3193         * API/JSBase.h:
3194         * API/JSContext.h:
3195         * API/JSManagedValue.h:
3196         * API/JSValue.h:
3197         * API/JSVirtualMachine.h:
3198         * Configurations/Base.xcconfig:
3199         * postprocess-headers.sh:
3200
3201 2015-05-26  Geoffrey Garen  <ggaren@apple.com>
3202
3203         Photo Booth hangs under JSC::MachineThreads::tryCopyOtherThreadStacks
3204         https://bugs.webkit.org/show_bug.cgi?id=145395
3205
3206         Reviewed by Mark Hahnenberg.
3207
3208         No test case because we already have --threaded mode, which runs lots of
3209         parallel GC, but it (and the original in-app test case) can't reproduce
3210         this bug.
3211
3212         * heap/MachineStackMarker.cpp:
3213         (JSC::MachineThreads::tryCopyOtherThreadStacks): Use a lock to prevent
3214         two threads from mutually suspending each other.
3215
3216 2015-05-26  Yusuke Suzuki  <utatane.tea@gmail.com>
3217
3218         Add Array.prototype.copyWithin to JSC features.json
3219         https://bugs.webkit.org/show_bug.cgi?id=145387
3220
3221         Reviewed by Darin Adler.
3222
3223         * features.json:
3224
3225 2015-05-26  Yusuke Suzuki  <utatane.tea@gmail.com>
3226
3227         Reflect nits for r184863
3228         https://bugs.webkit.org/show_bug.cgi?id=145107
3229
3230         Reviewed by Darin Adler.
3231
3232         1. Added the copyright line.
3233         2. Added an optional argument (/*, end */). To do so, fixed generate-js-builtins.
3234         3. Dropped the unnecessary variable `thisValue`.
3235         4. Fix the type error messages. This is also found in StringIterator.prototype.js.
3236         5. Added tests for 0 arguments.
3237
3238         * builtins/Array.prototype.js:
3239         (copyWithin):
3240         * builtins/StringIterator.prototype.js:
3241         (next):
3242         * generate-js-builtins:
3243         * tests/stress/array-copywithin.js:
3244         * tests/stress/string-iterators.js:
3245
3246 2015-05-26  Yusuke Suzuki  <utatane.tea@gmail.com>
3247
3248         Inline @Array / @Object callsites
3249         https://bugs.webkit.org/show_bug.cgi?id=145382
3250
3251         Reviewed by Geoffrey Garen.
3252
3253         As the same to Array/Object callsite inlining, @Array/@Object also
3254         should be inlined in bytecode level.
3255         While `new @Object` style is not encouraged in the builtins,
3256         `@Array(len)` is already used at least in Array.from code.
3257
3258         * bytecompiler/BytecodeGenerator.cpp:
3259         (JSC::BytecodeGenerator::expectedFunctionForIdentifier):
3260
3261 2015-05-26  Andreas Kling  <akling@apple.com>
3262
3263         String.prototype.charCodeAt() should use StringView.
3264         <https://webkit.org/b/145353>
3265
3266         Reviewed by Darin Adler.
3267
3268         Use JSString::view() in charCodeAt() to avoid reifying the JSString if it's
3269         a substring. This avoids StringImpl allocation in some cases and ref churn
3270         in all cases.
3271
3272         * runtime/StringPrototype.cpp:
3273         (JSC::stringProtoFuncCharCodeAt):
3274
3275 2015-05-26  Andreas Kling  <akling@apple.com>
3276
3277         String.prototype.charAt() should use StringView.
3278         <https://webkit.org/b/145352>
3279
3280         Reviewed by Darin Adler.
3281
3282         Remove the jsSingleCharacterSubstring() function since it's actually completely
3283         counter-productive: it could create a single-character string that would retain
3284         a much larger string for the duration of its lifetime.
3285
3286         This made sense before StringImpl learned to put its characters at the tail end
3287         of its own allocation. Now that it does, it's far better to just create a new
3288         single-character StringImpl.
3289
3290         With that out of the way, we can make String.prototype.charAt() use StringView
3291         to avoid reifying substring JSStrings (and avoid some ref churn too.)
3292
3293         * runtime/JSString.cpp:
3294         (JSC::JSRopeString::getIndexSlowCase):
3295         * runtime/JSString.h:
3296         (JSC::JSString::getIndex):
3297         (JSC::jsSingleCharacterSubstring): Deleted.
3298         * runtime/StringPrototype.cpp:
3299         (JSC::stringProtoFuncCharAt):
3300         (JSC::stringProtoFuncSplit):
3301
3302 2015-05-26  Yusuke Suzuki  <utatane.tea@gmail.com>
3303
3304         [ES6] Implement Array.prototype.copyWithin
3305         https://bugs.webkit.org/show_bug.cgi?id=145107
3306
3307         Reviewed by Darin Adler.
3308
3309         This patch implements ES6 Array.prototype.copyWithin.
3310         It is intended to be used for copying the region to the other region
3311         in the callee array itself safely (like memmove, not memcpy).
3312         This function is proposed in the context of WebGL.
3313
3314         * builtins/Array.prototype.js:
3315         (.maxWithPositives):
3316         (.minWithMaybeNegativeZeroAndPositive):
3317         (copyWithin):
3318         * runtime/ArrayPrototype.cpp:
3319         (JSC::ArrayPrototype::finishCreation):
3320         * tests/stress/array-copywithin.js: Added.
3321         (shouldBe):
3322         (shouldBeArray):
3323         (shouldThrow):
3324         (arrayToObject):
3325         (valueOf):
3326
3327 2015-05-26  Dan Bernstein  <mitz@apple.com>
3328
3329         <rdar://problem/21104551> Update build settings
3330
3331         Reviewed by Anders Carlsson.
3332
3333         * Configurations/DebugRelease.xcconfig:
3334         * Configurations/FeatureDefines.xcconfig:
3335         * Configurations/Version.xcconfig:
3336
3337 2015-05-26  Andreas Kling  <akling@apple.com>
3338
3339         Try to use StringView when comparing JSStrings for equality.
3340         <https://webkit.org/b/145379>
3341
3342         Reviewed by Darin Adler.
3343
3344         Use JSString::view() when sending two JSStrings to WTF::equal()
3345         for comparison. This avoids creating new objects in the case where
3346         the strings are actually substrings.
3347
3348         * jit/JITOperations.cpp:
3349         * runtime/JSCJSValueInlines.h:
3350         (JSC::JSValue::equalSlowCaseInline):
3351         (JSC::JSValue::strictEqualSlowCaseInline):
3352
3353 2015-05-26  Yusuke Suzuki  <utatane.tea@gmail.com>
3354
3355         [JSC] Generate put_by_val_direct for indexed identifiers instead of put_by_id with direct postfix
3356         https://bugs.webkit.org/show_bug.cgi?id=145360
3357
3358         Reviewed by Darin Adler.
3359
3360         JSObject::putDirect only accepts non-indexed properties.
3361         So when generating put_by_id (with direct postfix) for indexed property,