Support Pointer Events on macOS
[WebKit-https.git] / Source / JavaScriptCore / ChangeLog
1 2019-02-27  Antoine Quint  <graouts@apple.com>
2
3         Support Pointer Events on macOS
4         https://bugs.webkit.org/show_bug.cgi?id=195008
5         <rdar://problem/47454419>
6
7         Reviewed by Dean Jackson.
8
9         * Configurations/FeatureDefines.xcconfig:
10
11 2019-02-26  Mark Lam  <mark.lam@apple.com>
12
13         Remove poisons in JSCPoison and uses of them.
14         https://bugs.webkit.org/show_bug.cgi?id=195082
15
16         Reviewed by Yusuke Suzuki.
17
18         Also removed unused poisoning code in WriteBarrier, AssemblyHelpers,
19         DFG::SpeculativeJIT, FTLLowerDFGToB3, and FTL::Output.
20
21         * API/JSAPIWrapperObject.h:
22         (JSC::JSAPIWrapperObject::wrappedObject):
23         * API/JSCallbackFunction.h:
24         * API/JSCallbackObject.h:
25         * API/glib/JSAPIWrapperGlobalObject.h:
26         * CMakeLists.txt:
27         * JavaScriptCore.xcodeproj/project.pbxproj:
28         * Sources.txt:
29         * bytecode/AccessCase.cpp:
30         (JSC::AccessCase::generateWithGuard):
31         * dfg/DFGSpeculativeJIT.cpp:
32         (JSC::DFG::SpeculativeJIT::compileGetByValOnScopedArguments):
33         (JSC::DFG::SpeculativeJIT::compileGetArrayLength):
34         (JSC::DFG::SpeculativeJIT::compileNewFunctionCommon):
35         (JSC::DFG::SpeculativeJIT::compileGetExecutable):
36         (JSC::DFG::SpeculativeJIT::compileCreateThis):
37         * dfg/DFGSpeculativeJIT.h:
38         (JSC::DFG::SpeculativeJIT::TrustedImmPtr::weakPoisonedPointer): Deleted.
39         * ftl/FTLLowerDFGToB3.cpp:
40         (JSC::FTL::DFG::LowerDFGToB3::compileGetExecutable):
41         (JSC::FTL::DFG::LowerDFGToB3::compileGetArrayLength):
42         (JSC::FTL::DFG::LowerDFGToB3::compileGetByVal):
43         (JSC::FTL::DFG::LowerDFGToB3::compileNewFunction):
44         (JSC::FTL::DFG::LowerDFGToB3::weakPointer):
45         (JSC::FTL::DFG::LowerDFGToB3::dynamicPoison): Deleted.
46         (JSC::FTL::DFG::LowerDFGToB3::dynamicPoisonOnLoadedType): Deleted.
47         (JSC::FTL::DFG::LowerDFGToB3::dynamicPoisonOnType): Deleted.
48         (JSC::FTL::DFG::LowerDFGToB3::weakPoisonedPointer): Deleted.
49         * ftl/FTLOutput.h:
50         (JSC::FTL::Output::weakPoisonedPointer): Deleted.
51         * jit/AssemblyHelpers.cpp:
52         (JSC::AssemblyHelpers::emitDynamicPoison): Deleted.
53         (JSC::AssemblyHelpers::emitDynamicPoisonOnLoadedType): Deleted.
54         (JSC::AssemblyHelpers::emitDynamicPoisonOnType): Deleted.
55         * jit/AssemblyHelpers.h:
56         * jit/JITOpcodes.cpp:
57         (JSC::JIT::emit_op_create_this):
58         * jit/JITPropertyAccess.cpp:
59         (JSC::JIT::emitScopedArgumentsGetByVal):
60         * jit/Repatch.cpp:
61         (JSC::linkPolymorphicCall):
62         * jit/ThunkGenerators.cpp:
63         (JSC::virtualThunkFor):
64         (JSC::nativeForGenerator):
65         (JSC::boundThisNoArgsFunctionCallGenerator):
66         * parser/UnlinkedSourceCode.h:
67         * runtime/ArrayPrototype.h:
68         * runtime/CustomGetterSetter.h:
69         (JSC::CustomGetterSetter::getter const):
70         (JSC::CustomGetterSetter::setter const):
71         * runtime/InitializeThreading.cpp:
72         (JSC::initializeThreading):
73         * runtime/InternalFunction.cpp:
74         (JSC::InternalFunction::getCallData):
75         (JSC::InternalFunction::getConstructData):
76         * runtime/InternalFunction.h:
77         (JSC::InternalFunction::nativeFunctionFor):
78         * runtime/JSArrayBuffer.h:
79         * runtime/JSBoundFunction.h:
80         * runtime/JSCPoison.cpp: Removed.
81         * runtime/JSCPoison.h: Removed.
82         * runtime/JSFunction.h:
83         * runtime/JSGlobalObject.h:
84         * runtime/JSScriptFetchParameters.h:
85         * runtime/JSScriptFetcher.h:
86         * runtime/JSString.h:
87         * runtime/NativeExecutable.cpp:
88         (JSC::NativeExecutable::hashFor const):
89         * runtime/NativeExecutable.h:
90         * runtime/Options.h:
91         * runtime/ScopedArguments.h:
92         * runtime/Structure.cpp:
93         (JSC::StructureTransitionTable::setSingleTransition):
94         * runtime/StructureTransitionTable.h:
95         (JSC::StructureTransitionTable::map const):
96         (JSC::StructureTransitionTable::weakImpl const):
97         (JSC::StructureTransitionTable::setMap):
98         * runtime/WriteBarrier.h:
99         * wasm/WasmB3IRGenerator.cpp:
100         * wasm/WasmInstance.h:
101         * wasm/js/JSToWasm.cpp:
102         (JSC::Wasm::createJSToWasmWrapper):
103         * wasm/js/JSWebAssemblyCodeBlock.h:
104         * wasm/js/JSWebAssemblyInstance.cpp:
105         (JSC::JSWebAssemblyInstance::JSWebAssemblyInstance):
106         (JSC::JSWebAssemblyInstance::visitChildren):
107         * wasm/js/JSWebAssemblyInstance.h:
108         * wasm/js/JSWebAssemblyMemory.h:
109         * wasm/js/JSWebAssemblyModule.h:
110         * wasm/js/JSWebAssemblyTable.cpp:
111         (JSC::JSWebAssemblyTable::JSWebAssemblyTable):
112         (JSC::JSWebAssemblyTable::grow):
113         (JSC::JSWebAssemblyTable::clearFunction):
114         * wasm/js/JSWebAssemblyTable.h:
115         * wasm/js/WasmToJS.cpp:
116         (JSC::Wasm::materializeImportJSCell):
117         (JSC::Wasm::handleBadI64Use):
118         (JSC::Wasm::wasmToJS):
119         * wasm/js/WebAssemblyFunctionBase.h:
120         * wasm/js/WebAssemblyModuleRecord.cpp:
121         (JSC::WebAssemblyModuleRecord::link):
122         (JSC::WebAssemblyModuleRecord::evaluate):
123         * wasm/js/WebAssemblyModuleRecord.h:
124         * wasm/js/WebAssemblyToJSCallee.h:
125         * wasm/js/WebAssemblyWrapperFunction.h:
126
127 2019-02-26  Mark Lam  <mark.lam@apple.com>
128
129         wasmToJS() should purify incoming NaNs.
130         https://bugs.webkit.org/show_bug.cgi?id=194807
131         <rdar://problem/48189132>
132
133         Reviewed by Saam Barati.
134
135         * runtime/JSCJSValue.h:
136         (JSC::jsNumber):
137         * runtime/TypedArrayAdaptors.h:
138         (JSC::IntegralTypedArrayAdaptor::toJSValue):
139         * wasm/js/WasmToJS.cpp:
140         (JSC::Wasm::wasmToJS):
141
142 2019-02-26  Dominik Infuehr  <dinfuehr@igalia.com>
143
144         Fix warnings on ARM and MIPS
145         https://bugs.webkit.org/show_bug.cgi?id=195049
146
147         Reviewed by Mark Lam.
148
149         Fix all warnings on ARM and MIPS.
150
151         * assembler/MacroAssemblerPrinter.cpp:
152         (JSC::Printer::printMemory):
153         * assembler/testmasm.cpp:
154         (JSC::testProbeModifiesStackValues):
155         * bytecode/InByIdStatus.cpp:
156         (JSC::InByIdStatus::computeFor):
157         * runtime/CachedTypes.cpp:
158         (JSC::VariableLengthObject::buffer const):
159         * runtime/JSBigInt.h:
160         * tools/JSDollarVM.cpp:
161         (JSC::codeBlockFromArg):
162
163 2019-02-26  Mark Lam  <mark.lam@apple.com>
164
165         Misc cleanup in StructureIDTable after r242096.
166         https://bugs.webkit.org/show_bug.cgi?id=195063
167
168         Reviewed by Saam Barati.
169
170         * runtime/StructureIDTable.cpp:
171         (JSC::StructureIDTable::allocateID):
172         - RELEASE_ASSERT that the StructureID allocation will succeed.
173
174         * runtime/StructureIDTable.h:
175         (JSC::StructureIDTable::decode):
176         (JSC::StructureIDTable::encode):
177         - Add back a comment that Yusuke requested but was lost when the patch was rolled
178           out and relanded.
179         - Applied bitwise_casts that Saam requested.
180
181 2019-02-26  Mark Lam  <mark.lam@apple.com>
182
183         Gardening: 32-bit build fix after r242096.
184         https://bugs.webkit.org/show_bug.cgi?id=194989
185
186         Not reviewed.
187
188         * jit/AssemblyHelpers.cpp:
189         (JSC::AssemblyHelpers::emitLoadStructure):
190
191 2019-02-26  Mark Lam  <mark.lam@apple.com>
192
193         Unpoison MacroAssemblerCodePtr, ClassInfo pointers, and a few other things.
194         https://bugs.webkit.org/show_bug.cgi?id=195039
195
196         Reviewed by Saam Barati.
197
198         1. Unpoison MacroAssemblerCodePtrs, ReturnAddressPtr.
199         2. Replace PoisonedClassInfoPtr with ClassInfo*.
200         3. Replace PoisonedMasmPtr with const void*.
201         4. Remove all references to CodeBlockPoison, JITCodePoison, and GlobalDataPoison.
202
203         * API/JSCallbackObject.h:
204         * API/JSObjectRef.cpp:
205         (classInfoPrivate):
206         * assembler/MacroAssemblerCodeRef.h:
207         (JSC::FunctionPtr::FunctionPtr):
208         (JSC::FunctionPtr::executableAddress const):
209         (JSC::FunctionPtr::retaggedExecutableAddress const):
210         (JSC::ReturnAddressPtr::ReturnAddressPtr):
211         (JSC::ReturnAddressPtr::value const):
212         (JSC::MacroAssemblerCodePtr::MacroAssemblerCodePtr):
213         (JSC::MacroAssemblerCodePtr::createFromExecutableAddress):
214         (JSC::MacroAssemblerCodePtr:: const):
215         (JSC::MacroAssemblerCodePtr::operator! const):
216         (JSC::MacroAssemblerCodePtr::operator== const):
217         (JSC::MacroAssemblerCodePtr::hash const):
218         (JSC::MacroAssemblerCodePtr::emptyValue):
219         (JSC::MacroAssemblerCodePtr::deletedValue):
220         (JSC::FunctionPtr<tag>::FunctionPtr):
221         (JSC::MacroAssemblerCodePtr::poisonedPtr const): Deleted.
222         * b3/B3LowerMacros.cpp:
223         * b3/testb3.cpp:
224         (JSC::B3::testInterpreter):
225         * dfg/DFGOSRExitCompilerCommon.h:
226         (JSC::DFG::adjustFrameAndStackInOSRExitCompilerThunk):
227         * dfg/DFGSpeculativeJIT.cpp:
228         (JSC::DFG::SpeculativeJIT::compileCheckSubClass):
229         (JSC::DFG::SpeculativeJIT::compileNewStringObject):
230         (JSC::DFG::SpeculativeJIT::emitSwitchIntJump):
231         (JSC::DFG::SpeculativeJIT::emitSwitchImm):
232         (JSC::DFG::SpeculativeJIT::emitSwitchCharStringJump):
233         (JSC::DFG::SpeculativeJIT::emitSwitchChar):
234         * dfg/DFGSpeculativeJIT.h:
235         * ftl/FTLLowerDFGToB3.cpp:
236         (JSC::FTL::DFG::LowerDFGToB3::compileNewStringObject):
237         (JSC::FTL::DFG::LowerDFGToB3::compileCheckSubClass):
238         * jit/AssemblyHelpers.h:
239         (JSC::AssemblyHelpers::emitAllocateDestructibleObject):
240         * jit/ThunkGenerators.cpp:
241         (JSC::virtualThunkFor):
242         (JSC::boundThisNoArgsFunctionCallGenerator):
243         * runtime/JSCPoison.h:
244         * runtime/JSDestructibleObject.h:
245         (JSC::JSDestructibleObject::classInfo const):
246         * runtime/JSSegmentedVariableObject.h:
247         (JSC::JSSegmentedVariableObject::classInfo const):
248         * runtime/Structure.h:
249         * runtime/VM.h:
250         * wasm/WasmB3IRGenerator.cpp:
251         (JSC::Wasm::B3IRGenerator::addCall):
252         (JSC::Wasm::B3IRGenerator::addCallIndirect):
253         * wasm/WasmBinding.cpp:
254         (JSC::Wasm::wasmToWasm):
255
256 2019-02-26  Mark Lam  <mark.lam@apple.com>
257
258         [Re-landing] Add some randomness into the StructureID.
259         https://bugs.webkit.org/show_bug.cgi?id=194989
260         <rdar://problem/47975563>
261
262         Reviewed by Yusuke Suzuki.
263
264         1. On 64-bit, the StructureID will now be encoded as:
265
266             ----------------------------------------------------------------
267             | 1 Nuke Bit | 24 StructureIDTable index bits | 7 entropy bits |
268             ----------------------------------------------------------------
269
270            The entropy bits are chosen at random and assigned when a StructureID is
271            allocated.
272
273         2. Instead of Structure pointers, the StructureIDTable will now contain
274            encodedStructureBits, which is encoded as such:
275
276             ----------------------------------------------------------------
277             | 7 entropy bits |                   57 structure pointer bits |
278             ----------------------------------------------------------------
279
280            The entropy bits here are the same 7 bits used in the encoding of the
281            StructureID for this structure entry in the StructureIDTable.
282
283         3. Retrieval of the structure pointer given a StructureID is now computed as
284            follows:
285
286                 index = structureID >> 7; // with arithmetic shift.
287                 encodedStructureBits = structureIDTable[index];
288                 structure = encodedStructureBits ^ (structureID << 57);
289
290             We use an arithmetic shift for the right shift because that will preserve
291             the nuke bit in the high bit of the index if the StructureID was not
292             decontaminated before use as expected.
293
294         4. Remove unused function loadArgumentWithSpecificClass() in SpecializedThunkJIT.
295
296         5. Define StructureIDTable::m_size to be the number of allocated StructureIDs
297            instead of always being the same as m_capacity.
298
299         6. Change StructureIDTable::s_unusedID's value to 0.
300
301            Its previous value of unusedPointer i.e. 0xd1e7beef, does not make sense for
302            StructureID on 64-bit.  Also, there was never any code that initializes unused
303            IDs to the s_unusedID.  The only meaningful value for s_unusedID is 0, which
304            is the ID we'll get when the freelist is empty, prompting a resize of the
305            structureIDTable.
306
307         This patch appears to be perf neutral on JetStream 2 run via the cli on a
308         11" MacBook Air, 13" MacBook Pro, iPhone 6S, and iPhone XR.
309
310         * ftl/FTLLowerDFGToB3.cpp:
311         (JSC::FTL::DFG::LowerDFGToB3::loadStructure):
312         * heap/SlotVisitor.cpp:
313         (JSC::SlotVisitor::appendJSCellOrAuxiliary):
314         * jit/AssemblyHelpers.cpp:
315         (JSC::AssemblyHelpers::emitLoadStructure):
316         * jit/AssemblyHelpers.h:
317         * jit/SpecializedThunkJIT.h:
318         (JSC::SpecializedThunkJIT::loadArgumentWithSpecificClass): Deleted.
319         * llint/LowLevelInterpreter.asm:
320         * llint/LowLevelInterpreter64.asm:
321         * runtime/StructureIDTable.cpp:
322         (JSC::StructureIDTable::StructureIDTable):
323         (JSC::StructureIDTable::makeFreeListFromRange):
324         (JSC::StructureIDTable::resize):
325         (JSC::StructureIDTable::allocateID):
326         (JSC::StructureIDTable::deallocateID):
327         * runtime/StructureIDTable.h:
328         (JSC::StructureIDTable::decode):
329         (JSC::StructureIDTable::encode):
330         (JSC::StructureIDTable::get):
331         (JSC::StructureIDTable::isValid):
332
333 2019-02-26  Ryan Haddad  <ryanhaddad@apple.com>
334
335         Unreviewed, rolling out r242071.
336
337         Breaks internal builds.
338
339         Reverted changeset:
340
341         "Add some randomness into the StructureID."
342         https://bugs.webkit.org/show_bug.cgi?id=194989
343         https://trac.webkit.org/changeset/242071
344
345 2019-02-26  Guillaume Emont  <guijemont@igalia.com>
346
347         [JSC] Fix compilation on 32-bit platforms after r242071
348         https://bugs.webkit.org/show_bug.cgi?id=195042
349
350         Reviewed by Carlos Garcia Campos.
351
352         * jit/AssemblyHelpers.cpp:
353         (JSC::AssemblyHelpers::emitLoadStructure):
354
355 2019-02-26  Guillaume Emont  <guijemont@igalia.com>
356
357         [JSC] Repeat string created from Array.prototype.join() take too much memory
358         https://bugs.webkit.org/show_bug.cgi?id=193912
359
360         Reviewed by Saam Barati.
361
362         Added a fast case in Array.prototype.join when the array is
363         uninitialized.
364
365         * runtime/ArrayPrototype.cpp:
366         (JSC::canUseFastJoin):
367         (JSC::fastJoin):
368         * runtime/JSStringInlines.h:
369         (JSC::repeatCharacter): moved from StringPrototype.cpp
370         * runtime/StringPrototype.cpp:
371
372 2019-02-25  Mark Lam  <mark.lam@apple.com>
373
374         Add some randomness into the StructureID.
375         https://bugs.webkit.org/show_bug.cgi?id=194989
376         <rdar://problem/47975563>
377
378         Reviewed by Yusuke Suzuki.
379
380         1. On 64-bit, the StructureID will now be encoded as:
381
382             ----------------------------------------------------------------
383             | 1 Nuke Bit | 24 StructureIDTable index bits | 7 entropy bits |
384             ----------------------------------------------------------------
385
386            The entropy bits are chosen at random and assigned when a StructureID is
387            allocated.
388
389         2. Instead of Structure pointers, the StructureIDTable will now contain
390            encodedStructureBits, which is encoded as such:
391
392             ----------------------------------------------------------------
393             | 7 entropy bits |                   57 structure pointer bits |
394             ----------------------------------------------------------------
395
396            The entropy bits here are the same 7 bits used in the encoding of the
397            StructureID for this structure entry in the StructureIDTable.
398
399         3. Retrieval of the structure pointer given a StructureID is now computed as
400            follows:
401
402                 index = structureID >> 7; // with arithmetic shift.
403                 encodedStructureBits = structureIDTable[index];
404                 structure = encodedStructureBits ^ (structureID << 57);
405
406             We use an arithmetic shift for the right shift because that will preserve
407             the nuke bit in the high bit of the index if the StructureID was not
408             decontaminated before use as expected.
409
410         4. Remove unused function loadArgumentWithSpecificClass() in SpecializedThunkJIT.
411
412         5. Define StructureIDTable::m_size to be the number of allocated StructureIDs
413            instead of always being the same as m_capacity.
414
415         6. Change StructureIDTable::s_unusedID's value to 0.
416
417            Its previous value of unusedPointer i.e. 0xd1e7beef, does not make sense for
418            StructureID on 64-bit.  Also, there was never any code that initializes unused
419            IDs to the s_unusedID.  The only meaningful value for s_unusedID is 0, which
420            is the ID we'll get when the freelist is empty, prompting a resize of the
421            structureIDTable.
422
423         This patch appears to be perf neutral on JetStream 2 run via the cli on a
424         11" MacBook Air, 13" MacBook Pro, iPhone 6S, and iPhone XR.
425
426         * ftl/FTLLowerDFGToB3.cpp:
427         (JSC::FTL::DFG::LowerDFGToB3::loadStructure):
428         * heap/SlotVisitor.cpp:
429         (JSC::SlotVisitor::appendJSCellOrAuxiliary):
430         * jit/AssemblyHelpers.cpp:
431         (JSC::AssemblyHelpers::emitLoadStructure):
432         * jit/AssemblyHelpers.h:
433         * jit/SpecializedThunkJIT.h:
434         (JSC::SpecializedThunkJIT::loadArgumentWithSpecificClass): Deleted.
435         * llint/LowLevelInterpreter.asm:
436         * llint/LowLevelInterpreter64.asm:
437         * runtime/StructureIDTable.cpp:
438         (JSC::StructureIDTable::StructureIDTable):
439         (JSC::StructureIDTable::makeFreeListFromRange):
440         (JSC::StructureIDTable::resize):
441         (JSC::StructureIDTable::allocateID):
442         (JSC::StructureIDTable::deallocateID):
443         * runtime/StructureIDTable.h:
444         (JSC::StructureIDTable::decode):
445         (JSC::StructureIDTable::encode):
446         (JSC::StructureIDTable::get):
447         (JSC::StructureIDTable::isValid):
448
449 2019-02-25  Yusuke Suzuki  <ysuzuki@apple.com>
450
451         [JSC] Revert r226885 to make SlotVisitor creation lazy
452         https://bugs.webkit.org/show_bug.cgi?id=195013
453
454         Reviewed by Saam Barati.
455
456         We once changed SlotVisitor creation apriori to drop the lock. Also, it turns out that SlotVisitor is memory-consuming.
457         We should defer SlotVisitor creation until it is actually required. This patch reverts r226885. Even with this patch,
458         we still hold many SlotVisitors after we execute many parallel markers at least once. But recovering the feature of
459         dynamically allocating SlotVisitors helps further memory optimizations in this area.
460
461         * heap/Heap.cpp:
462         (JSC::Heap::Heap):
463         (JSC::Heap::runBeginPhase):
464         * heap/Heap.h:
465         * heap/HeapInlines.h:
466         (JSC::Heap::forEachSlotVisitor):
467         (JSC::Heap::numberOfSlotVisitors):
468         * heap/MarkingConstraintSolver.cpp:
469         (JSC::MarkingConstraintSolver::didVisitSomething const):
470         * heap/SlotVisitor.h:
471
472 2019-02-25  Saam Barati  <sbarati@apple.com>
473
474         testb3 and testair should test O0/O1/O2
475         https://bugs.webkit.org/show_bug.cgi?id=194637
476
477         Reviewed by Mark Lam.
478
479         This patch makes it so that we run all tests in testair and testb3
480         in O0, O1, and O2. However, some tests are invalid for O0 and O1.
481         This patch makes it so we only run those tests in O2. These are
482         often tests that assert certain optimizations have occurred. There
483         are also a class of tests that rely on using patchpoints to stress 
484         the register allocator into only a single valid allocation. The
485         O0, and sometimes O1, register allocators are not always good enough
486         to allocate such programs. To make these valid allocators to use, we rely
487         on the FTL and Wasm to not emit such patchpoints.
488
489         * b3/air/testair.cpp:
490         (main):
491         * b3/testb3.cpp:
492         (JSC::B3::compileProc):
493         (JSC::B3::testAddLoadTwice):
494         (JSC::B3::testMulLoadTwice):
495         (JSC::B3::testSimplePatchpointWithOuputClobbersGPArgs):
496         (JSC::B3::testSimplePatchpointWithOuputClobbersFPArgs):
497         (JSC::B3::testPatchpointWithEarlyClobber):
498         (JSC::B3::testSimpleCheck):
499         (JSC::B3::testCheckFalse):
500         (JSC::B3::testCheckTrue):
501         (JSC::B3::testCheckLessThan):
502         (JSC::B3::testCheckMegaCombo):
503         (JSC::B3::testCheckTrickyMegaCombo):
504         (JSC::B3::testCheckTwoMegaCombos):
505         (JSC::B3::testCheckTwoNonRedundantMegaCombos):
506         (JSC::B3::testCheckAddImm):
507         (JSC::B3::testCheckAddImmCommute):
508         (JSC::B3::testCheckAddImmSomeRegister):
509         (JSC::B3::testCheckAdd):
510         (JSC::B3::testCheckAdd64):
511         (JSC::B3::testCheckAddFold):
512         (JSC::B3::testCheckAddFoldFail):
513         (JSC::B3::testCheckAddSelfOverflow64):
514         (JSC::B3::testCheckAddSelfOverflow32):
515         (JSC::B3::testCheckSubImm):
516         (JSC::B3::testCheckSubBadImm):
517         (JSC::B3::testCheckSub):
518         (JSC::B3::testCheckSub64):
519         (JSC::B3::testCheckSubFold):
520         (JSC::B3::testCheckSubFoldFail):
521         (JSC::B3::testCheckNeg):
522         (JSC::B3::testCheckNeg64):
523         (JSC::B3::testCheckMul):
524         (JSC::B3::testCheckMulMemory):
525         (JSC::B3::testCheckMul2):
526         (JSC::B3::testCheckMul64):
527         (JSC::B3::testCheckMulFold):
528         (JSC::B3::testCheckMulFoldFail):
529         (JSC::B3::testCheckMul64SShr):
530         (JSC::B3::testLinearScanWithCalleeOnStack):
531         (JSC::B3::testCheckSelect):
532         (JSC::B3::testCheckSelectCheckSelect):
533         (JSC::B3::testCheckSelectAndCSE):
534         (JSC::B3::testLateRegister):
535         (JSC::B3::testReduceStrengthCheckBottomUseInAnotherBlock):
536         (JSC::B3::testSomeEarlyRegister):
537         (JSC::B3::testTerminalPatchpointThatNeedsToBeSpilled2):
538         (JSC::B3::testPinRegisters):
539         (JSC::B3::testX86LeaAddAddShlLeft):
540         (JSC::B3::testX86LeaAddAddShlRight):
541         (JSC::B3::testX86LeaAddAdd):
542         (JSC::B3::testX86LeaAddShlRight):
543         (JSC::B3::testX86LeaAddShlLeftScale1):
544         (JSC::B3::testX86LeaAddShlLeftScale2):
545         (JSC::B3::testX86LeaAddShlLeftScale4):
546         (JSC::B3::testX86LeaAddShlLeftScale8):
547         (JSC::B3::testLoadBaseIndexShift2):
548         (JSC::B3::testOptimizeMaterialization):
549         (JSC::B3::testLICMPure):
550         (JSC::B3::testLICMPureSideExits):
551         (JSC::B3::testLICMPureWritesPinned):
552         (JSC::B3::testLICMPureWrites):
553         (JSC::B3::testLICMReadsPinned):
554         (JSC::B3::testLICMReads):
555         (JSC::B3::testLICMPureNotBackwardsDominant):
556         (JSC::B3::testLICMPureNotBackwardsDominantFoiledByChild):
557         (JSC::B3::testLICMControlDependent):
558         (JSC::B3::testLICMControlDependentNotBackwardsDominant):
559         (JSC::B3::testLICMReadsWritesDifferentHeaps):
560         (JSC::B3::testWasmBoundsCheck):
561         (JSC::B3::run):
562         (main):
563
564 2019-02-25  Yusuke Suzuki  <ysuzuki@apple.com>
565
566         [JSC] stress/function-constructor-reading-from-global-lexical-environment.js fails in 32bit arch
567         https://bugs.webkit.org/show_bug.cgi?id=195030
568         <rdar://problem/48385088>
569
570         Reviewed by Saam Barati.
571
572         While LLInt64 has checkTDZInGlobalPutToScopeIfNecessary for op_put_to_scope GlobalLexicalVar to check the value in the variable slot is not empty,
573         this check is missing in LLInt32_64. Previously, this check was subsumed accidentally by the WatchpointSet check in GlobalLexicalVar in `notifyWrite`:
574         because no "put" attempt succeeds here, the status WatchpointSet was ClearWatchpoint, we always go to the slow path, and we always throw the TDZ error
575         before configuring the WatchpointSet in the slow path. But after r241862, WatchpointSet is not used under non-JIT configuration. This skips WatchpointSet
576         check and LLInt32_64 starts failing tests because of lack of checkTDZInGlobalPutToScopeIfNecessary. This patch adds checkTDZInGlobalPutToScopeIfNecessary
577         in LLInt32_64 too. This patch fixes the following four failing tests.
578
579             stress/function-constructor-reading-from-global-lexical-environment.js.bytecode-cache
580             stress/function-constructor-reading-from-global-lexical-environment.js.default
581             stress/global-lexical-variable-tdz.js.bytecode-cache
582             stress/global-lexical-variable-tdz.js.default
583
584         * llint/LowLevelInterpreter32_64.asm:
585
586 2019-02-25  Yusuke Suzuki  <ysuzuki@apple.com>
587
588         [JSC] Make Intl fields lazily-allocated
589         https://bugs.webkit.org/show_bug.cgi?id=195022
590
591         Reviewed by Mark Lam.
592
593         This patch makes the following memory footprint optimization in IntlObject.
594
595         1. Make IntlObject fields including Intl.Collator lazily-allocated because we already removed direct references from JS builtins to these constructors (@Collator etc.).
596
597         2. Move LazyProperty<IntlObject, Structure> structures from IntlObject to JSGlobalObject. This makes sizeof(IntlObject) the same to the other ones of usual runtime Objects,
598            and drop one MarkedBlock.
599
600         * runtime/IntlCollatorConstructor.h:
601         * runtime/IntlDateTimeFormatConstructor.h:
602         * runtime/IntlNumberFormatConstructor.h:
603         * runtime/IntlObject.cpp:
604         (JSC::createCollatorConstructor):
605         (JSC::createNumberFormatConstructor):
606         (JSC::createDateTimeFormatConstructor):
607         (JSC::createPluralRulesConstructor):
608         (JSC::IntlObject::finishCreation):
609         (JSC::IntlObject::visitChildren): Deleted.
610         * runtime/IntlObject.h:
611         * runtime/IntlPluralRulesConstructor.h:
612         * runtime/JSGlobalObject.cpp:
613         (JSC::JSGlobalObject::init):
614         (JSC::JSGlobalObject::visitChildren):
615         (JSC::JSGlobalObject::defaultCollator):
616         * runtime/JSGlobalObject.h:
617         (JSC::JSGlobalObject::collatorStructure):
618         (JSC::JSGlobalObject::numberFormatStructure):
619         (JSC::JSGlobalObject::dateTimeFormatStructure):
620         (JSC::JSGlobalObject::pluralRulesStructure):
621         (JSC::JSGlobalObject::intlObject const): Deleted.
622         * runtime/JSGlobalObjectFunctions.cpp:
623         (JSC::globalFuncDateTimeFormat):
624         * runtime/NumberPrototype.cpp:
625         (JSC::numberProtoFuncToLocaleString):
626         * runtime/StringPrototype.cpp:
627         (JSC::stringProtoFuncLocaleCompare):
628
629 2019-02-25  Tadeu Zagallo  <tzagallo@apple.com>
630
631         Avoid hashing CompactVariableEnvironment when decoding CompactVariableMap::Handle
632         https://bugs.webkit.org/show_bug.cgi?id=194937
633
634         Reviewed by Saam Barati.
635
636         Hashing the CompactVariableEnvironment is expensive and we could avoid it
637         when decoding multiple handles to the same environment. This is sound because
638         a pointer to the same CompactVariableEnvironment will hash the same.
639
640         * runtime/CachedTypes.cpp:
641         (JSC::Decoder::handleForEnvironment const):
642         (JSC::Decoder::setHandleForEnvironment):
643         (JSC::CachedCompactVariableMapHandle::decode const):
644
645 2019-02-25  Tadeu Zagallo  <tzagallo@apple.com>
646
647         Remove unnecessary WTF:: prefixes in CachedTypes
648         https://bugs.webkit.org/show_bug.cgi?id=194936
649
650         Reviewed by Saam Barati.
651
652         Cleanup unnecessary prefixes from Optional, roundUpToMultipleOf and
653         pageSize.
654
655         * runtime/CachedTypes.cpp:
656         (JSC::Encoder::cachedOffsetForPtr):
657         (JSC::Encoder::Page::malloc):
658         (JSC::Encoder::allocateNewPage):
659         (JSC::CachedPtr::encode):
660         (JSC::CachedPtr::decode const):
661         (JSC::CachedOptional::encode):
662         (JSC::CachedOptional::decode const):
663
664 2019-02-25  Yusuke Suzuki  <ysuzuki@apple.com>
665
666         [JSC] Drop direct references to Intl constructors by rewriting Intl JS builtins in C++
667         https://bugs.webkit.org/show_bug.cgi?id=194976
668
669         Reviewed by Michael Saboff.
670
671         This patch paves the way to making IntlObject allocation lazy by removing direct references
672         to Intl constructors (Intl.Collator etc.) from builtin JS. To achieve that,
673
674         1. We implement String.prototype.toLocaleCompare and Number.prototype.toLocaleString in C++
675            instead of JS builtins. Since these functions end up calling ICU C++ runtime, writing them in
676            JS does not offer performance improvement.
677
678         2. We remove @DateTimeFormat constructor reference, and instead, exposing @dateTimeFormat function,
679            which returns formatted string directly. We still have JS builtins for DateTimeFormat things
680            because the initialization of its "options" JSObject involves many get_by_id / put_by_id things,
681            which are efficient in JS. But we avoid exposing @DateTimeFormat directly, so that Intl constructors
682            can be lazily allocated.
683
684         * CMakeLists.txt:
685         * DerivedSources-input.xcfilelist:
686         * DerivedSources.make:
687         * JavaScriptCore.xcodeproj/project.pbxproj:
688         * builtins/BuiltinNames.h:
689         * builtins/DatePrototype.js:
690         (toLocaleString):
691         (toLocaleDateString):
692         (toLocaleTimeString):
693         * builtins/NumberPrototype.js: Removed.
694         * builtins/StringPrototype.js:
695         (intrinsic.StringPrototypeReplaceIntrinsic.replace):
696         (globalPrivate.getDefaultCollator): Deleted.
697         * runtime/JSGlobalObject.cpp:
698         (JSC::JSGlobalObject::init):
699         (JSC::JSGlobalObject::visitChildren):
700         (JSC::JSGlobalObject::defaultCollator):
701         * runtime/JSGlobalObject.h:
702         * runtime/JSGlobalObjectFunctions.cpp:
703         (JSC::globalFuncDateTimeFormat):
704         * runtime/JSGlobalObjectFunctions.h:
705         * runtime/NumberPrototype.cpp:
706         (JSC::NumberPrototype::finishCreation):
707         (JSC::throwVMToThisNumberError):
708         (JSC::numberProtoFuncToExponential):
709         (JSC::numberProtoFuncToFixed):
710         (JSC::numberProtoFuncToPrecision):
711         (JSC::numberProtoFuncToString):
712         (JSC::numberProtoFuncToLocaleString):
713         (JSC::numberProtoFuncValueOf):
714         * runtime/StringPrototype.cpp:
715         (JSC::StringPrototype::finishCreation):
716         (JSC::stringProtoFuncLocaleCompare):
717
718 2019-02-24  Devin Rousso  <drousso@apple.com>
719
720         Web Inspector: Change the InspectorOverlay to use native rather than canvas
721         https://bugs.webkit.org/show_bug.cgi?id=105023
722         <rdar://problem/13443692>
723
724         Reviewed by Brian Burg.
725
726         * inspector/protocol/OverlayTypes.json: Removed.
727         Now that the overlay is entirely generated in C++, we no longer need the special prototol
728         types for transferring data to a JavaScript context.
729
730         * inspector/protocol/Debugger.json:
731         * inspector/agents/InspectorDebuggerAgent.h:
732         * inspector/agents/InspectorDebuggerAgent.cpp:
733         (Inspector::InspectorDebuggerAgent::setOverlayMessage): Deleted.
734         Remove `Debugger.setOverlayMessage` command as it hasn't been used and is no longer supported.
735
736         * CMakeLists.txt:
737         * DerivedSources-input.xcfilelist:
738         * DerivedSources.make:
739
740 2019-02-24  Yusuke Suzuki  <ysuzuki@apple.com>
741
742         [JSC] Lazily create sentinel Map and Set buckets
743         https://bugs.webkit.org/show_bug.cgi?id=194975
744
745         Reviewed by Saam Barati.
746
747         If VM::canUseJIT() returns false, we can lazily initialize sentinel Map and Set buckets.
748         This patch adds getters to VM which lazily allocate these buckets. We eagerly initialize
749         them if VM::canUseJIT() returns true since they can be touched from DFG and FTL.
750
751         * bytecode/BytecodeIntrinsicRegistry.cpp:
752         (JSC::BytecodeIntrinsicRegistry::BytecodeIntrinsicRegistry):
753         (JSC::BytecodeIntrinsicRegistry::sentinelMapBucketValue):
754         (JSC::BytecodeIntrinsicRegistry::sentinelSetBucketValue):
755         * bytecode/BytecodeIntrinsicRegistry.h:
756         * dfg/DFGByteCodeParser.cpp:
757         (JSC::DFG::ByteCodeParser::handleIntrinsicCall):
758         * dfg/DFGOperations.cpp:
759         * dfg/DFGSpeculativeJIT.cpp:
760         (JSC::DFG::SpeculativeJIT::compileGetMapBucketNext):
761         * dfg/DFGSpeculativeJIT64.cpp:
762         (JSC::DFG::SpeculativeJIT::compile):
763         * ftl/FTLLowerDFGToB3.cpp:
764         (JSC::FTL::DFG::LowerDFGToB3::compileGetMapBucket):
765         (JSC::FTL::DFG::LowerDFGToB3::compileGetMapBucketNext):
766         * runtime/MapConstructor.cpp:
767         (JSC::mapPrivateFuncMapBucketNext):
768         * runtime/SetConstructor.cpp:
769         (JSC::setPrivateFuncSetBucketNext):
770         * runtime/VM.cpp:
771         (JSC::VM::VM):
772         (JSC::VM::sentinelSetBucketSlow):
773         (JSC::VM::sentinelMapBucketSlow):
774         * runtime/VM.h:
775         (JSC::VM::sentinelSetBucket):
776         (JSC::VM::sentinelMapBucket):
777
778 2019-02-20  Darin Adler  <darin@apple.com>
779
780         Finish removing String::format
781         https://bugs.webkit.org/show_bug.cgi?id=194893
782
783         Reviewed by Daniel Bates.
784
785         * bytecode/CodeBlock.cpp:
786         (JSC::CodeBlock::nameForRegister): Use makeString instead of String::format,
787         using the new "pad" function.
788
789 2019-02-23  Robin Morisset  <rmorisset@apple.com>
790
791         Remove dead code: AdjacencyList::justOneChild()
792         https://bugs.webkit.org/show_bug.cgi?id=194965
793
794         Reviewed by Sam Weinig.
795
796         * dfg/DFGAdjacencyList.h:
797         (JSC::DFG::AdjacencyList::justOneChild const): Deleted.
798
799 2019-02-23  Michael Catanzaro  <mcatanzaro@igalia.com>
800
801         Unreviewed, fix -Wunused-param warning
802
803         * jsc.cpp:
804
805 2019-02-23  Mark Lam  <mark.lam@apple.com>
806
807         Add an exception check and some assertions in StringPrototype.cpp.
808         https://bugs.webkit.org/show_bug.cgi?id=194962
809         <rdar://problem/48013416>
810
811         Reviewed by Yusuke Suzuki and Saam Barati.
812
813         * runtime/StringPrototype.cpp:
814         (JSC::jsSpliceSubstrings):
815         (JSC::jsSpliceSubstringsWithSeparators):
816         (JSC::operationStringProtoFuncReplaceRegExpEmptyStr):
817
818 2019-02-23  Keith Miller  <keith_miller@apple.com>
819
820         Add new mac target numbers
821         https://bugs.webkit.org/show_bug.cgi?id=194955
822
823         Reviewed by Tim Horton.
824
825         * Configurations/Base.xcconfig:
826         * Configurations/DebugRelease.xcconfig:
827
828 2019-02-22  Robin Morisset  <rmorisset@apple.com>
829
830         DFGBytecodeParser should not declare that a node won't clobberExit if DFGFixupPhase can later declare it does clobberExit
831         https://bugs.webkit.org/show_bug.cgi?id=194953
832         <rdar://problem/47595253>
833
834         Reviewed by Saam Barati.
835
836         For each node that
837         (a) may or may not clobberExit depending on their arrayMode
838         (b) and get their arrayMode from profiling information in DFGBytecodeParser
839         (c) and can have their arrayMode refined by DFGFixupPhase,
840         We must make sure to be conservative in the DFGBytecodeParser and treat it as if it unconditionnally clobbered the exit.
841         Otherwise we will hit a validation failure after fixup if the next node was marked ExitValid and exits to the same semantic origin.
842
843         The list of nodes that fit (a) is:
844         - StringCharAt
845         - HasIndexProperty
846         - GetByVal
847         - PutByValDirect
848         - PutByVal
849         - PutByValAlias
850         - GetIndexedPropertyStorage
851
852         Out of these, the following also fit (b) and (c):
853         - HasIndexedProperty
854         - GetByVal
855         - PutByValDirect
856         - PutByVal
857
858         GetByVal already had "m_exitOK = false; // GetByVal must be treated as if it clobbers exit state, since FixupPhase may make it generic."
859         So we just have to fix the other three the same way.
860
861         * dfg/DFGByteCodeParser.cpp:
862         (JSC::DFG::ByteCodeParser::parseBlock):
863         (JSC::DFG::ByteCodeParser::handlePutByVal):
864
865 2019-02-22  Robin Morisset  <rmorisset@apple.com>
866
867         B3ReduceStrength: missing peephole optimizations for binary operations
868         https://bugs.webkit.org/show_bug.cgi?id=194252
869
870         Reviewed by Saam Barati.
871
872         Adds several sets of optimizations for BitAnd, BitOr and BitXor.
873         Using BitAnd distributivity over BitOr and BitXor:
874           Turn any of these (for Op == BitOr || Op == BitXor):
875                 Op(BitAnd(x1, x2), BitAnd(x1, x3))
876                 Op(BitAnd(x2, x1), BitAnd(x1, x3))
877                 Op(BitAnd(x1, x2), BitAnd(x3, x1))
878                 Op(BitAnd(x2, x1), BitAnd(x3, x1))
879            Into this: BitAnd(Op(x2, x3), x1)
880            And any of these:
881                 Op(BitAnd(x1, x2), x1)
882                 Op(BitAnd(x2, x1), x1)
883                 Op(x1, BitAnd(x1, x2))
884                 Op(x1, BitAnd(x2, x1))
885            Into this: BitAnd(Op(x2, x1), x1)
886            This second set is equivalent to doing x1 => BitAnd(x1, x1), and then applying the first set.
887         Using de Morgan laws (we represent not as BitXor with allOnes):
888           BitAnd(BitXor(x1, allOnes), BitXor(x2, allOnes)) => BitXor(BitOr(x1, x2), allOnes)
889           BitOr(BitXor(x1, allOnes), BitXor(x2, allOnes) => BitXor(BitAnd(x1, x2), allOnes)
890           BitOr(BitXor(x, allOnes), c) => BitXor(BitAnd(x, ~c), allOnes)
891           BitAnd(BitXor(x, allOnes), c) => BitXor(BitOr(x, ~c), allOnes)
892         The latter two are equivalent to doing c => BitXor(~c, allOnes), and then applying the former two.
893
894         All of these transformations either reduce the number of operations (which we always do when possible), or bring the expression closer to having:
895           - BitXor with all ones at the outermost
896           - then BitAnd
897           - then other BitXor
898           - then BitOr at the innermost.
899         These transformations that don't directly reduce the number of operations are still useful for normalization (helping things like CSE), and also can enable
900         more optimizations (for example BitXor with all ones can easily cancel each other once they are all at the outermost level).
901
902         * b3/B3ReduceStrength.cpp:
903         * b3/testb3.cpp:
904         (JSC::B3::testBitAndNotNot):
905         (JSC::B3::testBitAndNotImm):
906         (JSC::B3::testBitOrAndAndArgs):
907         (JSC::B3::testBitOrAndSameArgs):
908         (JSC::B3::testBitOrNotNot):
909         (JSC::B3::testBitOrNotImm):
910         (JSC::B3::testBitXorAndAndArgs):
911         (JSC::B3::testBitXorAndSameArgs):
912         (JSC::B3::run):
913
914 2019-02-22  Yusuke Suzuki  <ysuzuki@apple.com>
915
916         [JSC] putNonEnumerable in JSWrapperMap is too costly
917         https://bugs.webkit.org/show_bug.cgi?id=194935
918
919         Reviewed by Mark Lam.
920
921         When we convert Objective-C blocks to JS objects, we need to set up a corresponding function object correctly.
922         During this allocation, we call [JSValue defineProperty:descriptor] to connect a "prototype" object and "constructor" object.
923         The problem is that this API has a particularly costly implementation:
924
925             [[_context globalObject][@"Object"] invokeMethod:@"defineProperty" withArguments:@[ self, key, descriptor ]];
926
927         This wraps each JS objects appear in this code with Objective-C wrapper. And we convert a NSDictionary to JSObject, which
928         has "writable", "enumerable", "configurable", "value" fields, and call the "defineProperty" JS function through Objective-C wrapper.
929         This allocates many Objective-C wrappers and JS objects for descriptors. Since JSC has a direct C++ API "defineOwnProperty", we should
930         bypass these Objective-C APIs and call JSC's code directly.
931
932         This patch changes `putNonEnumerable` implementation, from calling [JSValue defineProperty:descriptor] to calling JSC C++ code directly.
933         We do not change [JSValue defineProperty:descriptor] implementation for now because of two reasons. (1) This is not used in our benchmarks
934         except for this (converting an Objective-C block to a JS object) one path. And (2) even if we were to re-write [JSValue defineProperty:descriptor]
935         to be more optimized, we would still want to call the JSC C++ version of defineProperty directly here to avoid NSDictionary allocation for a descriptor.
936
937         * API/APIUtils.h:
938         (setException):
939         * API/JSWrapperMap.mm:
940         (putNonEnumerable):
941         (copyMethodsToObject):
942         (-[JSObjCClassInfo allocateConstructorAndPrototypeInContext:]):
943         (-[JSObjCClassInfo wrapperForObject:inContext:]):
944
945 2019-02-22  Yusuke Suzuki  <ysuzuki@apple.com>
946
947         Unreviewed, build fix after r241954
948         https://bugs.webkit.org/show_bug.cgi?id=194939
949
950         Renaming setCanAccessHeap was incomplete.
951
952         * runtime/SmallStrings.cpp:
953         (JSC::SmallStrings::initializeCommonStrings):
954         * runtime/VM.cpp:
955         (JSC::VM::~VM):
956
957 2019-02-22  Yusuke Suzuki  <ysuzuki@apple.com>
958
959         [JSC] SmallStringsStorage is unnecessary
960         https://bugs.webkit.org/show_bug.cgi?id=194939
961
962         Reviewed by Mark Lam.
963
964         SmallStrings hold common small JSStrings. Their underlying StringImpl is also held by SmallStringsStorage.
965         But it is duplicate since we can get StringImpl from small JSStrings. This patch removes SmallStringsStorage,
966         and get StringImpls from JSStrings if necessary.
967
968         We also add m_canAccessHeap flag to SmallStrings. At the time of VM destruction, JSStrings are destroyed when
969         VM's Heap is finalized. We must not touch JSStrings before VM's heap (and JSStrings in SmallStrings) is initialized,
970         and after VM's Heap is destroyed. We add this m_canAccessHeap flag to allow users to get StringImpl during the
971         this sensitive period. If m_canAccessHeap is false, we get StringImpl from AtomicStringImpl::add.
972
973         * runtime/SmallStrings.cpp:
974         (JSC::SmallStrings::initializeCommonStrings):
975         (JSC::SmallStrings::singleCharacterStringRep):
976         (JSC::SmallStringsStorage::rep): Deleted.
977         (JSC::SmallStringsStorage::SmallStringsStorage): Deleted.
978         (JSC::SmallStrings::createSingleCharacterString): Deleted.
979         * runtime/SmallStrings.h:
980         (JSC::SmallStrings::setCanAccessHeap):
981         * runtime/VM.cpp:
982         (JSC::VM::VM):
983         (JSC::VM::~VM):
984
985 2019-02-22  Tadeu Zagallo  <tzagallo@apple.com>
986
987         Cache CompactVariableMap::Handle instead of VariableEnvironment for UnlinkedFunctionExecutable
988         https://bugs.webkit.org/show_bug.cgi?id=194706
989
990         Reviewed by Saam Barati.
991
992         In https://bugs.webkit.org/show_bug.cgi?id=194583 we started using a
993         CompactVariableMap::Handle instead of VariableEnvironment for
994         UnlinkedFunctionExecutables, but we were creating the full environment
995         to encode the executable in the bytecode cache. This patch changes it so
996         that we cache the handle instead of the environment. This avoids duplicating
997         the VariableEnvironment whenever we have to cache two handles that point
998         to the environment.
999
1000         * bytecode/UnlinkedFunctionExecutable.h:
1001         * parser/VariableEnvironment.cpp:
1002         (JSC::CompactVariableMap::get):
1003         * parser/VariableEnvironment.h:
1004         * runtime/CachedTypes.cpp:
1005         (JSC::CachedCompactVariableEnvironment::encode):
1006         (JSC::CachedCompactVariableEnvironment::decode const):
1007         (JSC::CachedCompactVariableMapHandle::encode):
1008         (JSC::CachedCompactVariableMapHandle::decode const):
1009         (JSC::CachedFunctionExecutable::encode):
1010         (JSC::CachedFunctionExecutable::decode const):
1011         (JSC::UnlinkedFunctionExecutable::UnlinkedFunctionExecutable):
1012
1013 2019-02-21  Saam Barati  <sbarati@apple.com>
1014
1015         Update JSScript SPI based on feedback
1016         https://bugs.webkit.org/show_bug.cgi?id=194517
1017
1018         Reviewed by Keith Miller.
1019
1020         This patch updates the JSScript SPI in the following ways:
1021         - JSScript can now represent both modules and programs. This is a property
1022         of the script determined during creation.
1023         - JSScript now takes a sourceURL during construction. For modules, this acts
1024         as the module identifier.
1025         - JSScript now has SPI for writing the cache out to disk. We don't do this
1026         automatically.
1027         - JSScript will load the bytecode cache on creation if it exists.
1028         - We retrofit these new requirements on the prior JSScript SPI that
1029         we're going to remove as soon as we can: https://bugs.webkit.org/show_bug.cgi?id=194909.
1030         Previous SPI assumes all JSScripts are modules. Previous SPI also assigns
1031         a sourceURL to the JSScript based on what the module loader decided the
1032         identifier should be. We'll remove this once we remove the old SPI.
1033         
1034         This patch also adds SPI to JSContext to evaluate a JSScript. For modules,
1035         this is like returning the result of doing dynamic import. For programs,
1036         this does normal program evaluation.
1037         
1038         This patch also fixes a bug in generateBytecode/generateModuleBytecode where
1039         we would try to cache the bytecode even if recursivelyGenerateUnlinkedCodeBlock
1040         returned null. E.g, if the script had a syntax error.
1041         
1042         When writing tests, I also discovered that someone previously broke
1043         testapi. This patch also fixes those failures. They were broken when
1044         we switched to using a testapiScripts directory to hold our test .js
1045         scripts. 
1046
1047         * API/JSAPIGlobalObject.h:
1048         * API/JSAPIGlobalObject.mm:
1049         (JSC::JSAPIGlobalObject::moduleLoaderResolve):
1050         (JSC::JSAPIGlobalObject::moduleLoaderFetch):
1051         (JSC::JSAPIGlobalObject::loadAndEvaluateJSScriptModule):
1052         * API/JSBase.cpp:
1053         (JSEvaluateScriptInternal):
1054         (JSEvaluateScript):
1055         * API/JSBaseInternal.h: Added.
1056         * API/JSContext.mm:
1057         (-[JSContext evaluateScript:withSourceURL:]):
1058         (-[JSContext evaluateJSScript:]):
1059         * API/JSContextPrivate.h:
1060         * API/JSScript.h:
1061         * API/JSScript.mm:
1062         (+[JSScript scriptWithSource:inVirtualMachine:]):
1063         (+[JSScript scriptFromASCIIFile:inVirtualMachine:withCodeSigning:andBytecodeCache:]):
1064         (createError):
1065         (+[JSScript scriptOfType:inVirtualMachine:withSourceURL:andSource:andBytecodeCache:error:]):
1066         (+[JSScript scriptOfType:inVirtualMachine:memoryMappedFromASCIIFile:withSourceURL:andBytecodeCache:error:]):
1067         (-[JSScript cacheBytecodeWithError:]):
1068         (-[JSScript sourceURL]):
1069         (-[JSScript type]):
1070         (-[JSScript jsSourceCode]):
1071         (-[JSScript writeCache:]):
1072         (-[JSScript setSourceURL:]):
1073         (-[JSScript forceRecreateJSSourceCode]):
1074         (-[JSScript writeCache]): Deleted.
1075         (-[JSScript jsSourceCode:]): Deleted.
1076         * API/JSScriptInternal.h:
1077         * API/tests/FunctionOverridesTest.cpp:
1078         (testFunctionOverrides):
1079         * API/tests/testapi.c:
1080         (main):
1081         * API/tests/testapi.mm:
1082         (tempFile):
1083         (testModuleBytecodeCache):
1084         (testProgramBytecodeCache):
1085         (testBytecodeCacheWithSyntaxError):
1086         (testProgramJSScriptException):
1087         (testLoadBasicFileLegacySPI):
1088         (+[JSContextMemoryMappedLoaderDelegate newContext]):
1089         (-[JSContextMemoryMappedLoaderDelegate context:fetchModuleForIdentifier:withResolveHandler:andRejectHandler:]):
1090         (testLoadBasicFile):
1091         (+[JSContextAugmentedLoaderDelegate newContext]):
1092         (-[JSContextAugmentedLoaderDelegate context:fetchModuleForIdentifier:withResolveHandler:andRejectHandler:]):
1093         (testJSScriptURL):
1094         (testObjectiveCAPI):
1095         (testBytecodeCache): Deleted.
1096         * API/tests/testapiScripts/foo.js: Added.
1097         * JavaScriptCore.xcodeproj/project.pbxproj:
1098         * runtime/Completion.cpp:
1099         (JSC::generateBytecode):
1100         (JSC::generateModuleBytecode):
1101
1102 2019-02-21  Mark Lam  <mark.lam@apple.com>
1103
1104         Add more doesGC() assertions.
1105         https://bugs.webkit.org/show_bug.cgi?id=194911
1106         <rdar://problem/48285723>
1107
1108         Reviewed by Saam Barati and Yusuke Suzuki.
1109
1110         * dfg/DFGOSRExit.cpp:
1111         (JSC::DFG::OSRExit::compileOSRExit):
1112         - Set expectDoesGC here because we no longer have to worry about missing store
1113           barriers in optimized code after this point.  This will prevent false positive
1114           assertion failures arising from functions called beneath compileOSRExit().
1115
1116         (JSC::DFG::OSRExit::compileExit):
1117         - Add a comment to explain why the generated ramp needs to set expectDoesGC even
1118           though compileOSRExit() also sets it.  Reason: compileOSRExit() is only called
1119           for the first OSR from this code origin, the generated ramp is called for many
1120           subsequents OSR exits from this code origin.
1121
1122         * ftl/FTLOSRExitCompiler.cpp:
1123         (JSC::FTL::compileStub):
1124         - Added a comment for the equivalent reason to the one above.
1125
1126         (JSC::FTL::compileFTLOSRExit):
1127         - Set expectDoesGC here because we no longer have to worry about missing store
1128           barriers in optimized code after this point.  This will prevent false positive
1129           assertion failures arising from functions called beneath compileFTLOSRExit().
1130
1131         * heap/CompleteSubspace.cpp:
1132         (JSC::CompleteSubspace::tryAllocateSlow):
1133         * heap/CompleteSubspaceInlines.h:
1134         (JSC::CompleteSubspace::allocateNonVirtual):
1135         - assert expectDoesGC.
1136
1137         * heap/DeferGC.h:
1138         (JSC::DeferGC::~DeferGC):
1139         - assert expectDoesGC.
1140         - Also added WTF_FORBID_HEAP_ALLOCATION to DeferGC, DeferGCForAWhile, and DisallowGC
1141           because all 3 should be stack allocated RAII objects.
1142
1143         * heap/GCDeferralContext.h:
1144         * heap/GCDeferralContextInlines.h:
1145         (JSC::GCDeferralContext::~GCDeferralContext):
1146         - Added WTF_FORBID_HEAP_ALLOCATION.
1147         - assert expectDoesGC.
1148
1149         * heap/Heap.cpp:
1150         (JSC::Heap::collectNow):
1151         (JSC::Heap::collectAsync):
1152         (JSC::Heap::collectSync):
1153         (JSC::Heap::stopIfNecessarySlow):
1154         (JSC::Heap::collectIfNecessaryOrDefer):
1155         * heap/HeapInlines.h:
1156         (JSC::Heap::acquireAccess):
1157         (JSC::Heap::stopIfNecessary):
1158         * heap/LargeAllocation.cpp:
1159         (JSC::LargeAllocation::tryCreate):
1160         * heap/LocalAllocatorInlines.h:
1161         (JSC::LocalAllocator::allocate):
1162         - conservatively assert expectDoesGC on these functions that may trigger a GC
1163           though they don't always do.
1164
1165         * runtime/DisallowScope.h:
1166         - DisallowScope should be stack allocated because it's an RAII object.
1167
1168         * runtime/JSCellInlines.h:
1169         (JSC::tryAllocateCellHelper):
1170         - Remove the expectDoesGC assertion because it is now covered by assertions in
1171           CompleteSubspace, LargeAllocation, and LocalAllocator.
1172
1173         * runtime/RegExpMatchesArray.h:
1174         (JSC::createRegExpMatchesArray):
1175         - assert expectDoesGC.
1176
1177 2019-02-21  Yusuke Suzuki  <ysuzuki@apple.com>
1178
1179         [JSC] Use Fast Malloc as much as possible
1180         https://bugs.webkit.org/show_bug.cgi?id=194316
1181
1182         Reviewed by Mark Lam.
1183
1184         We should use Fast Malloc as much as possible to offer the whole memory view to bmalloc.
1185
1186         * inspector/scripts/codegen/cpp_generator_templates.py:
1187         * inspector/scripts/tests/all/expected/definitions-with-mac-platform.json-result:
1188         * inspector/scripts/tests/generic/expected/enum-values.json-result:
1189         * inspector/scripts/tests/generic/expected/events-with-optional-parameters.json-result:
1190         * inspector/scripts/tests/generic/expected/generate-domains-with-feature-guards.json-result:
1191         * inspector/scripts/tests/mac/expected/definitions-with-mac-platform.json-result:
1192         * jit/ExecutableAllocator.h:
1193         * jsc.cpp:
1194         * runtime/JSRunLoopTimer.h:
1195         * tools/VMInspector.h:
1196         * wasm/WasmThunks.h:
1197
1198 2019-02-20  Yusuke Suzuki  <ysuzuki@apple.com>
1199
1200         [JSC] Remove WatchpointSet creation for SymbolTable entries if VM::canUseJIT() returns false
1201         https://bugs.webkit.org/show_bug.cgi?id=194891
1202
1203         Reviewed by Geoffrey Garen.
1204
1205         WatchpointSet in SymbolTable is used to fold the value into a constant in JIT tiers. And it is
1206         not useful under the non-JIT mode. This patch avoids creation of WatchpointSet in SymbolTable
1207         if VM::canUseJIT() returns false.
1208
1209         * llint/LowLevelInterpreter32_64.asm:
1210         * llint/LowLevelInterpreter64.asm:
1211         * runtime/SymbolTable.cpp:
1212         (JSC::SymbolTableEntry::addWatchpoint): Deleted.
1213         * runtime/SymbolTable.h:
1214         (JSC::SymbolTableEntry::isWatchable const):
1215         (JSC::SymbolTableEntry::watchpointSet):
1216
1217 2019-02-20  Mark Lam  <mark.lam@apple.com>
1218
1219         Add code to validate expected GC activity modelled by doesGC() against what the runtime encounters.
1220         https://bugs.webkit.org/show_bug.cgi?id=193938
1221         <rdar://problem/47616277>
1222
1223         Reviewed by Michael Saboff, Saam Barati, and Robin Morisset.
1224
1225         In DFG::SpeculativeJIT::compile() and FTL::LowerDFGToB3::compileNode(), before
1226         emitting code / B3IR for each DFG node, we emit a write to set Heap::m_expectDoesGC
1227         to the value returned by doesGC() for that node.  In the runtime (i.e. in allocateCell()
1228         and functions that can resolve a rope), we assert that Heap::m_expectDoesGC is
1229         true.
1230
1231         This validation code is currently only enabled for debug builds.  It is disabled
1232         for release builds by default, but it can easily be made to run on release builds
1233         as well by forcing ENABLE_DFG_DOES_GC_VALIDATION to 1 in Heap.h.
1234
1235         To allow this validation code to run on release builds as well, the validation uses
1236         RELEASE_ASSERT instead of ASSERT.
1237
1238         To ensure that Heap.h is #include'd for all files that needs to do this validation
1239         (so that the validation code is accidentally disabled), we guard the validation
1240         code with an if conditional on constexpr bool validateDFGDoesGC (instead of using
1241         a #if ENABLE(DFG_DOES_GC_VALIDATION)).  This way, if Heap.h isn't #include'd, the
1242         validation code will fail to build (no silent failures).
1243
1244         Currently, all JSC tests and Layout tests should pass with this validation enabled
1245         in debug builds.  We'll only see new failures if there's a regression or if new
1246         tests reveal a previously untested code path that has an undetected issue.
1247
1248         * dfg/DFGOSRExit.cpp:
1249         (JSC::DFG::OSRExit::executeOSRExit):
1250         (JSC::DFG::OSRExit::compileExit):
1251         * dfg/DFGSpeculativeJIT64.cpp:
1252         (JSC::DFG::SpeculativeJIT::compile):
1253         * ftl/FTLLowerDFGToB3.cpp:
1254         (JSC::FTL::DFG::LowerDFGToB3::compileNode):
1255         * ftl/FTLOSRExitCompiler.cpp:
1256         (JSC::FTL::compileStub):
1257         * heap/Heap.h:
1258         (JSC::Heap::expectDoesGC const):
1259         (JSC::Heap::setExpectDoesGC):
1260         (JSC::Heap::addressOfExpectDoesGC):
1261         * jit/JITArithmetic.cpp:
1262         (JSC::JIT::emit_compareAndJump):
1263         * runtime/JSCellInlines.h:
1264         (JSC::tryAllocateCellHelper):
1265         * runtime/JSString.h:
1266         (JSC::jsSingleCharacterString):
1267         (JSC::JSString::toAtomicString const):
1268         (JSC::JSString::toExistingAtomicString const):
1269         (JSC::JSString::value const):
1270         (JSC::JSString::tryGetValue const):
1271         (JSC::JSRopeString::unsafeView const):
1272         (JSC::JSRopeString::viewWithUnderlyingString const):
1273         (JSC::JSString::unsafeView const):
1274
1275 2019-02-20  Andy Estes  <aestes@apple.com>
1276
1277         [Xcode] Add SDKVariant.xcconfig to various Xcode projects
1278         https://bugs.webkit.org/show_bug.cgi?id=194869
1279
1280         Rubber-stamped by Jer Noble.
1281
1282         * JavaScriptCore.xcodeproj/project.pbxproj:
1283
1284 2019-02-19  Joseph Pecoraro  <pecoraro@apple.com>
1285
1286         Web Inspector: Improve ES6 Class instances in Heap Snapshot instances view
1287         https://bugs.webkit.org/show_bug.cgi?id=172848
1288         <rdar://problem/25709212>
1289
1290         Reviewed by Mark Lam.
1291
1292         * heap/HeapSnapshotBuilder.h:
1293         * heap/HeapSnapshotBuilder.cpp:
1294         Update the snapshot version. Change the node's 0 | 1 internal value
1295         to be a 32bit bit flag. This is nice in that it is both compatible
1296         with the previous snapshot version and the same size. We can use more
1297         flags in the future.
1298
1299         (JSC::HeapSnapshotBuilder::json):
1300         In cases where the classInfo gives us "Object" check for a better
1301         class name by checking (o).__proto__.constructor.name. We avoid this
1302         check in cases where (o).hasOwnProperty("constructor") which is the
1303         case for most Foo.prototype objects. Otherwise this would get the
1304         name of the Foo superclass for the Foo.prototype object.
1305
1306         * runtime/JSObject.cpp:
1307         (JSC::JSObject::calculatedClassName):
1308         Handle some possible edge cases that were not handled before, such as
1309         a JSObject without a GlobalObject or an object which doesn't
1310         have a default getPrototype. Try to make the code a little clearer.
1311
1312 2019-02-19  Truitt Savell  <tsavell@apple.com>
1313
1314         Unreviewed, rolling out r241784.
1315
1316         Broke all OpenSource builds.
1317
1318         Reverted changeset:
1319
1320         "Web Inspector: Improve ES6 Class instances in Heap Snapshot
1321         instances view"
1322         https://bugs.webkit.org/show_bug.cgi?id=172848
1323         https://trac.webkit.org/changeset/241784
1324
1325 2019-02-19  Joseph Pecoraro  <pecoraro@apple.com>
1326
1327         Web Inspector: Improve ES6 Class instances in Heap Snapshot instances view
1328         https://bugs.webkit.org/show_bug.cgi?id=172848
1329         <rdar://problem/25709212>
1330
1331         Reviewed by Mark Lam.
1332
1333         * heap/HeapSnapshotBuilder.h:
1334         * heap/HeapSnapshotBuilder.cpp:
1335         Update the snapshot version. Change the node's 0 | 1 internal value
1336         to be a 32bit bit flag. This is nice in that it is both compatible
1337         with the previous snapshot version and the same size. We can use more
1338         flags in the future.
1339
1340         (JSC::HeapSnapshotBuilder::json):
1341         In cases where the classInfo gives us "Object" check for a better
1342         class name by checking (o).__proto__.constructor.name. We avoid this
1343         check in cases where (o).hasOwnProperty("constructor") which is the
1344         case for most Foo.prototype objects. Otherwise this would get the
1345         name of the Foo superclass for the Foo.prototype object.
1346
1347         * runtime/JSObject.cpp:
1348         (JSC::JSObject::calculatedClassName):
1349         Handle some possible edge cases that were not handled before, such as
1350         a JSObject without a GlobalObject or an object which doesn't
1351         have a default getPrototype. Try to make the code a little clearer.
1352
1353 2019-02-19  Robin Morisset  <rmorisset@apple.com>
1354
1355         B3-O2 incorrectly optimizes this subtest
1356         https://bugs.webkit.org/show_bug.cgi?id=194625
1357
1358         Reviewed by Saam Barati.
1359
1360         Trivial fix. Instead of doing
1361             if (!cond) foo else bar => if (cond) bar else foo
1362         B3LowerToAir was doing
1363             if (x^C) foo else bar => if (cond) bar else foo whenever C&1, even if C was for example 3.
1364
1365         * b3/B3LowerToAir.cpp:
1366         * b3/testb3.cpp:
1367         (JSC::B3::testBitNotOnBooleanAndBranch32):
1368         (JSC::B3::testNotOnBooleanAndBranch32): Added.
1369
1370 2019-02-19  Robin Morisset  <rmorisset@apple.com>
1371
1372         CachedCall should not consider it UNLIKELY that it will not stack overflow
1373         https://bugs.webkit.org/show_bug.cgi?id=194831
1374
1375         Reviewed by Mark Lam.
1376
1377         * interpreter/CachedCall.h:
1378         (JSC::CachedCall::CachedCall):
1379
1380 2019-02-19  Mark Lam  <mark.lam@apple.com>
1381
1382         Fix DFG doesGC() for TryGetById and ProfileType nodes.
1383         https://bugs.webkit.org/show_bug.cgi?id=194821
1384         <rdar://problem/48206690>
1385
1386         Reviewed by Saam Barati.
1387
1388         Fix doesGC() for the following nodes:
1389
1390             ProfileType:
1391                 calls operationProcessTypeProfilerLogDFG(), which can calculatedClassName(),
1392                 which can call JSString::tryGetValue(), which can resolve a rope.
1393
1394             TryGetById:
1395                 calls operationTryGetByIdOptimize(), which can startWatchingPropertyForReplacements()
1396                 on a structure, which can allocate StructureRareData.
1397
1398         * dfg/DFGDoesGC.cpp:
1399         (JSC::DFG::doesGC):
1400
1401 2019-02-18  Yusuke Suzuki  <ysuzuki@apple.com>
1402
1403         [JSC] Introduce JSNonDestructibleProxy for JavaScriptCore.framework's GlobalThis
1404         https://bugs.webkit.org/show_bug.cgi?id=194799
1405
1406         Reviewed by Saam Barati.
1407
1408         JSProxy is destructible one because we have JSWindowProxy which has ref counted object.
1409         However, JavaScriptCore.framework's JSProxy for GlobalThis does not need to be destructible.
1410         This is important since we need to separate Heap subspaces between destructible and non-destructible objects.
1411         If we can put more and more objects in non-destructible status, we can get rid of low-usage MarkedBlock.
1412         This patch adds JSNonDestructibleProxy, which is not destructible JSProxy. While it inherits JSDestructibleObject,
1413         we can make the subclass still non-destructible thanks to Subspace mechanism. This drops one more low-usage MarkedBlock.
1414
1415         * CMakeLists.txt:
1416         * JavaScriptCore.xcodeproj/project.pbxproj:
1417         * Sources.txt:
1418         * runtime/JSGlobalObject.cpp:
1419         (JSC::JSGlobalObject::resetPrototype):
1420         (JSC::JSGlobalObject::finishCreation):
1421         * runtime/JSNonDestructibleProxy.cpp: Added.
1422         * runtime/JSNonDestructibleProxy.h: Added.
1423         (JSC::JSNonDestructibleProxy::subspaceFor):
1424         (JSC::JSNonDestructibleProxy::create):
1425         (JSC::JSNonDestructibleProxy::createStructure):
1426         (JSC::JSNonDestructibleProxy::JSNonDestructibleProxy):
1427         * runtime/JSProxy.h:
1428         (JSC::JSProxy::JSProxy):
1429
1430 2019-02-19  Robin Morisset  <rmorisset@apple.com>
1431
1432         B3ReduceStrength::simplifyCFG() could do a lot more on each iteration
1433         https://bugs.webkit.org/show_bug.cgi?id=194475
1434
1435         Reviewed by Saam Barati.
1436
1437         B3ReduceStrength::simplifyCFG() does three optimizations (which I will call A, B and C):
1438         - A makes any terminal that points to a block that is empty except for a jump point to that jump's target instead.
1439         - B transforms any branch or switch that points to a single block into a jump
1440         - C finds blocks ending with jumps, whose successor has a single predecessor, and inline that successor block in place of the jump
1441
1442         It currently is limited in the following way:
1443         - A and C can only fire once per block per iteration
1444         - B can create jumps that would trigger A, but they may not be seen until the next iteration
1445
1446         Both problems are mitigated by going through the blocks in post-order, so that when a block is optimized most of its successors have already been optimized.
1447         In a sense it is the symmetric of the peephole optimizer that goes in pre-order so that when an instruction is optimized most of its children have already been optimized.
1448
1449         On JetStream2 it reduces the average number of iterations from 3.35 to 3.24.
1450
1451         * b3/B3ReduceStrength.cpp:
1452
1453 2019-02-19  Tadeu Zagallo  <tzagallo@apple.com>
1454
1455         Move bytecode cache-related filesystem code out of CodeCache
1456         https://bugs.webkit.org/show_bug.cgi?id=194675
1457
1458         Reviewed by Saam Barati.
1459
1460         The code is only used for the bytecode-cache tests, so it should live in
1461         jsc.cpp rather than in the CodeCache. The logic now lives in ShellSourceProvider,
1462         which overrides the a virtual method in SourceProvider, `cacheBytecode`,
1463         in order to write the cache to disk.
1464
1465         * jsc.cpp:
1466         (ShellSourceProvider::create):
1467         (ShellSourceProvider::~ShellSourceProvider):
1468         (ShellSourceProvider::cachePath const):
1469         (ShellSourceProvider::loadBytecode):
1470         (ShellSourceProvider::ShellSourceProvider):
1471         (jscSource):
1472         (GlobalObject::moduleLoaderFetch):
1473         (functionDollarEvalScript):
1474         (runWithOptions):
1475         * parser/SourceProvider.h:
1476         (JSC::SourceProvider::cacheBytecode const):
1477         * runtime/CodeCache.cpp:
1478         (JSC::writeCodeBlock):
1479         * runtime/CodeCache.h:
1480         (JSC::CodeCacheMap::fetchFromDiskImpl):
1481
1482 2019-02-18  Dominik Infuehr  <dinfuehr@igalia.com>
1483
1484         [ARM] Fix crash with sampling profiler
1485         https://bugs.webkit.org/show_bug.cgi?id=194772
1486
1487         Reviewed by Mark Lam.
1488
1489         sampling-profiler-richards.js was crashing with an enabled sampling profiler. add32
1490         did not update the stack pointer in a single instruction. The src register was first
1491         moved into the stack pointer, the immediate imm was added in a subsequent instruction.
1492
1493         This was problematic when a signal handler was invoked before applying the immediate,
1494         when the stack pointer is still set to the temporary value. Avoid this by calculating src+imm in
1495         a temporary register and then move it in one go into the stack pointer.
1496
1497         * assembler/MacroAssemblerARMv7.h:
1498         (JSC::MacroAssemblerARMv7::add32):
1499
1500 2019-02-18  Mark Lam  <mark.lam@apple.com>
1501
1502         Fix DFG doesGC() for CompareEq/Less/LessEq/Greater/GreaterEq and CompareStrictEq nodes.
1503         https://bugs.webkit.org/show_bug.cgi?id=194800
1504         <rdar://problem/48183773>
1505
1506         Reviewed by Yusuke Suzuki.
1507
1508         Fix doesGC() for the following nodes:
1509
1510             CompareEq:
1511             CompareLess:
1512             CompareLessEq:
1513             CompareGreater:
1514             CompareGreaterEq:
1515             CompareStrictEq:
1516                 Only return false (i.e. does not GC) for child node use kinds that have
1517                 been vetted to not do anything that can GC.  For all other use kinds
1518                 (including StringUse and BigIntUse), we return true (i.e. does GC).
1519
1520         * dfg/DFGDoesGC.cpp:
1521         (JSC::DFG::doesGC):
1522
1523 2019-02-16  Darin Adler  <darin@apple.com>
1524
1525         Continue reducing use of String::format, now focusing on hex: "%p", "%x", etc.
1526         https://bugs.webkit.org/show_bug.cgi?id=194752
1527
1528         Reviewed by Daniel Bates.
1529
1530         * heap/HeapSnapshotBuilder.cpp:
1531         (JSC::HeapSnapshotBuilder::json): Added back the "0x" that was removed when changing
1532         this file to use appendUnsignedAsHex instead of "%p". The intent at that time was to
1533         keep behavior the same, so let's do that.
1534
1535         * parser/Lexer.cpp:
1536         (JSC::Lexer<T>::invalidCharacterMessage const): Use makeString and hex instead of
1537         String::format and "%04x".
1538
1539 2019-02-18  Yusuke Suzuki  <ysuzuki@apple.com>
1540
1541         [JSC] Add LazyClassStructure::getInitializedOnMainThread
1542         https://bugs.webkit.org/show_bug.cgi?id=194784
1543         <rdar://problem/48154820>
1544
1545         Reviewed by Mark Lam.
1546
1547         LazyClassStructure::get and LazyProperty::get functions do not allow compiler threads to call them. But for booleanPrototype, numberPrototype and symbolPrototype cases,
1548         we would like to call them from compiler threads. We eagerly initialize them if VM::canUseJIT() is true, so that compiler threads can safely call LazyClassStructure::get
1549         and LazyProperty::get for booleanPrototype, numberPrototype and symbolPrototype. But still assertion hits because the assertion requires that these functions need to be
1550         called in non compiler threads. Calling `getConcurrently()` is not possible since symbolPrototype() function is called from both the main thread and compiler threads,
1551         and we would like to lazily initialize SymbolPrototype object if it is called from the main thread, which can happen with non-JIT configuration.
1552
1553         This patch adds `getInitializedOnMainThread()`. Compiler threads can call it only when we know that the value is already initialized on the main thread. The main thread
1554         can call it at anytime and this function lazily initializes the value. This is useful to make some of prototypes lazy with non-JIT configuration: With non-JIT configuration,
1555         this function is always called from the main thread and it initializes the value lazily. Non-JIT configuration does not care about compiler threads since they do not exist.
1556         With JIT configuration, we eagerly initialize them in JSGlobalObject::init so that `getInitializedOnMainThread()` always succeeds.
1557
1558         Basically, `getInitializedOnMainThread()` is `get` with different assertion location: While `get` always crashes if it is called from compiler threads, `getInitializedOnMainThread()`
1559         crashes only when actual initialization happens on compiler threads. We do not merge them since `get` is still useful to find accidental initialization from compiler threads.
1560
1561         * runtime/JSGlobalObject.h:
1562         (JSC::JSGlobalObject::booleanPrototype const):
1563         (JSC::JSGlobalObject::numberPrototype const):
1564         (JSC::JSGlobalObject::symbolPrototype const):
1565         * runtime/LazyClassStructure.h:
1566         (JSC::LazyClassStructure::getInitializedOnMainThread const):
1567         (JSC::LazyClassStructure::prototypeInitializedOnMainThread const):
1568         (JSC::LazyClassStructure::constructorInitializedOnMainThread const):
1569         * runtime/LazyProperty.h:
1570         (JSC::LazyProperty::get const):
1571         (JSC::LazyProperty::getInitializedOnMainThread const):
1572
1573 2019-02-18  Joseph Pecoraro  <pecoraro@apple.com>
1574
1575         Web Inspector: Better categorize CPU usage per-thread / worker
1576         https://bugs.webkit.org/show_bug.cgi?id=194564
1577
1578         Reviewed by Devin Rousso.
1579
1580         * inspector/protocol/CPUProfiler.json:
1581         Add additional properties per-Event, and new per-Thread object info.
1582
1583 2019-02-18  Tadeu Zagallo  <tzagallo@apple.com>
1584
1585         Bytecode cache should a have a boot-specific validation
1586         https://bugs.webkit.org/show_bug.cgi?id=194769
1587         <rdar://problem/48149509>
1588
1589         Reviewed by Keith Miller.
1590
1591         Add the boot UUID to the cached bytecode to enforce that it is not reused
1592         across reboots.
1593
1594         * runtime/CachedTypes.cpp:
1595         (JSC::Encoder::malloc):
1596         (JSC::GenericCacheEntry::GenericCacheEntry):
1597         (JSC::GenericCacheEntry::tag const):
1598         (JSC::CacheEntry::CacheEntry):
1599         (JSC::CacheEntry::decode const):
1600         (JSC::GenericCacheEntry::decode const):
1601         (JSC::encodeCodeBlock):
1602
1603 2019-02-18  Eric Carlson  <eric.carlson@apple.com>
1604
1605         Add MSE logging configuration
1606         https://bugs.webkit.org/show_bug.cgi?id=194719
1607         <rdar://problem/48122151>
1608
1609         Reviewed by Joseph Pecoraro.
1610
1611         * inspector/ConsoleMessage.cpp:
1612         (Inspector::messageSourceValue):
1613         * inspector/protocol/Console.json:
1614         * inspector/scripts/codegen/generator.py:
1615         * runtime/ConsoleTypes.h:
1616
1617 2019-02-18  Tadeu Zagallo  <tzagallo@apple.com>
1618
1619         Add version number to cached bytecode
1620         https://bugs.webkit.org/show_bug.cgi?id=194768
1621         <rdar://problem/48147968>
1622
1623         Reviewed by Saam Barati.
1624
1625         Add a version number to the bytecode cache that should be unique per build.
1626
1627         * CMakeLists.txt:
1628         * DerivedSources-output.xcfilelist:
1629         * DerivedSources.make:
1630         * runtime/CachedTypes.cpp:
1631         (JSC::Encoder::malloc):
1632         (JSC::GenericCacheEntry::GenericCacheEntry):
1633         (JSC::CacheEntry::CacheEntry):
1634         (JSC::CacheEntry::encode):
1635         (JSC::CacheEntry::decode const):
1636         (JSC::GenericCacheEntry::decode const):
1637         (JSC::decodeCodeBlockImpl):
1638         * runtime/CodeCache.h:
1639         (JSC::CodeCacheMap::fetchFromDiskImpl):
1640
1641 2019-02-17  Saam Barati  <sbarati@apple.com>
1642
1643         WasmB3IRGenerator models some effects incorrectly
1644         https://bugs.webkit.org/show_bug.cgi?id=194038
1645
1646         Reviewed by Keith Miller.
1647
1648         * wasm/WasmB3IRGenerator.cpp:
1649         (JSC::Wasm::B3IRGenerator::restoreWasmContextInstance):
1650         (JSC::Wasm::B3IRGenerator::restoreWebAssemblyGlobalState):
1651         These two functions were using global state instead of the
1652         arguments passed into the function.
1653
1654         (JSC::Wasm::B3IRGenerator::addOp<F64ConvertUI64>):
1655         (JSC::Wasm::B3IRGenerator::addOp<OpType::F32ConvertUI64>):
1656         (JSC::Wasm::B3IRGenerator::addOp<OpType::I64TruncUF64>):
1657         (JSC::Wasm::B3IRGenerator::addOp<OpType::I64TruncUF32>):
1658         Any patchpoint that allows scratch register usage must
1659         also say that it clobbers the scratch registers.
1660
1661 2019-02-17  Saam Barati  <sbarati@apple.com>
1662
1663         Deadlock when adding a Structure property transition and then doing incremental marking
1664         https://bugs.webkit.org/show_bug.cgi?id=194767
1665
1666         Reviewed by Mark Lam.
1667
1668         This can happen in the following scenario:
1669         
1670         You have a Structure S. S is on the mark stack. Then:
1671         1. S grabs its lock
1672         2. S adds a new property transition
1673         3. We find out we need to do some incremental marking
1674         4. We mark S
1675         5. visitChildren on S will try to grab its lock
1676         6. We are now in a deadlock
1677
1678         * heap/Heap.cpp:
1679         (JSC::Heap::performIncrement):
1680         * runtime/Structure.cpp:
1681         (JSC::Structure::addNewPropertyTransition):
1682
1683 2019-02-17  David Kilzer  <ddkilzer@apple.com>
1684
1685         Unreviewed, rolling out r241620.
1686
1687         "Causes use-after-free crashes running layout tests with ASan and GuardMalloc."
1688         (Requested by ddkilzer on #webkit.)
1689
1690         Reverted changeset:
1691
1692         "[WTF] Add environment variable helpers"
1693         https://bugs.webkit.org/show_bug.cgi?id=192405
1694         https://trac.webkit.org/changeset/241620
1695
1696 2019-02-17  Commit Queue  <commit-queue@webkit.org>
1697
1698         Unreviewed, rolling out r241612.
1699         https://bugs.webkit.org/show_bug.cgi?id=194762
1700
1701         "It regressed JetStream2 parsing tests by ~40%" (Requested by
1702         saamyjoon on #webkit).
1703
1704         Reverted changeset:
1705
1706         "Move bytecode cache-related filesystem code out of CodeCache"
1707         https://bugs.webkit.org/show_bug.cgi?id=194675
1708         https://trac.webkit.org/changeset/241612
1709
1710 2019-02-16  Yusuke Suzuki  <ysuzuki@apple.com>
1711
1712         [JSC] JSWrapperObject should not be destructible
1713         https://bugs.webkit.org/show_bug.cgi?id=194743
1714
1715         Reviewed by Saam Barati.
1716
1717         JSWrapperObject should be just a wrapper object for JSValue, thus, it should not be a JSDestructibleObject.
1718         Currently it is destructible object because DateInstance uses it. This patch changes Base of DateInstance from
1719         JSWrapperObject to JSDestructibleObject, and makes JSWrapperObject non-destructible.
1720
1721         * runtime/BigIntObject.cpp:
1722         (JSC::BigIntObject::BigIntObject):
1723         * runtime/BooleanConstructor.cpp:
1724         (JSC::BooleanConstructor::finishCreation):
1725         * runtime/BooleanObject.cpp:
1726         (JSC::BooleanObject::BooleanObject):
1727         * runtime/BooleanObject.h:
1728         * runtime/DateInstance.cpp:
1729         (JSC::DateInstance::DateInstance):
1730         (JSC::DateInstance::finishCreation):
1731         * runtime/DateInstance.h:
1732         * runtime/DatePrototype.cpp:
1733         (JSC::dateProtoFuncGetTime):
1734         (JSC::dateProtoFuncSetTime):
1735         (JSC::setNewValueFromTimeArgs):
1736         (JSC::setNewValueFromDateArgs):
1737         (JSC::dateProtoFuncSetYear):
1738         * runtime/JSCPoison.h:
1739         * runtime/JSWrapperObject.h:
1740         (JSC::JSWrapperObject::JSWrapperObject):
1741         * runtime/NumberObject.cpp:
1742         (JSC::NumberObject::NumberObject):
1743         * runtime/NumberObject.h:
1744         * runtime/StringConstructor.cpp:
1745         (JSC::StringConstructor::finishCreation):
1746         * runtime/StringObject.cpp:
1747         (JSC::StringObject::StringObject):
1748         * runtime/StringObject.h:
1749         (JSC::StringObject::internalValue const):
1750         * runtime/SymbolObject.cpp:
1751         (JSC::SymbolObject::SymbolObject):
1752         * runtime/SymbolObject.h:
1753
1754 2019-02-16  Yusuke Suzuki  <ysuzuki@apple.com>
1755
1756         [JSC] Shrink UnlinkedFunctionExecutable
1757         https://bugs.webkit.org/show_bug.cgi?id=194733
1758
1759         Reviewed by Mark Lam.
1760
1761         UnlinkedFunctionExecutable has sourceURLDirective and sourceMappingURLDirective. These
1762         directives can be found in the comment of non typical function's source code (Program,
1763         Eval code, and Global function from function constructor etc.), and tricky thing is that
1764         SourceProvider's directives are updated by Parser. The reason why we have these fields in
1765         UnlinkedFunctionExecutable is that we need to update the SourceProvider's directives even
1766         if we skip parsing by using CodeCache. These fields are effective only if (1)
1767         UnlinkedFunctionExecutable is for non typical function things, and (2) it has sourceURLDirective
1768         or sourceMappingURLDirective. This is rare enough to purge them to a separated
1769         UnlinkedFunctionExecutable::RareData to make UnlinkedFunctionExecutable small.
1770         sizeof(UnlinkedFunctionExecutable) is very important since it is super frequently allocated
1771         cell. Furthermore, the current JSC allocates two MarkedBlocks for UnlinkedFunctionExecutable
1772         in JSGlobalObject initialization, but the usage of the second MarkedBlock is quite low (8%).
1773         If we can reduce the size of UnlinkedFunctionExecutable, we can make them one MarkedBlock.
1774         Since UnlinkedFunctionExecutable is allocated from IsoSubspace, we do not need to fit it to
1775         one of size class.
1776
1777         This patch adds RareData to UnlinkedFunctionExecutable and move some rare datas into RareData.
1778         And kill one MarkedBlock allocation in JSC initialization phase.
1779
1780         * bytecode/UnlinkedFunctionExecutable.cpp:
1781         (JSC::UnlinkedFunctionExecutable::UnlinkedFunctionExecutable):
1782         (JSC::UnlinkedFunctionExecutable::ensureRareDataSlow):
1783         * bytecode/UnlinkedFunctionExecutable.h:
1784         * debugger/DebuggerLocation.cpp:
1785         (JSC::DebuggerLocation::DebuggerLocation):
1786         * inspector/ScriptDebugServer.cpp:
1787         (Inspector::ScriptDebugServer::dispatchDidParseSource):
1788         * parser/Lexer.h:
1789         (JSC::Lexer::sourceURLDirective const):
1790         (JSC::Lexer::sourceMappingURLDirective const):
1791         (JSC::Lexer::sourceURL const): Deleted.
1792         (JSC::Lexer::sourceMappingURL const): Deleted.
1793         * parser/Parser.h:
1794         (JSC::Parser<LexerType>::parse):
1795         * parser/SourceProvider.h:
1796         (JSC::SourceProvider::sourceURLDirective const):
1797         (JSC::SourceProvider::sourceMappingURLDirective const):
1798         (JSC::SourceProvider::setSourceURLDirective):
1799         (JSC::SourceProvider::setSourceMappingURLDirective):
1800         (JSC::SourceProvider::sourceURL const): Deleted. We rename it from sourceURL to sourceURLDirective
1801         since it is the correct name.
1802         (JSC::SourceProvider::sourceMappingURL const): Deleted. We rename it from sourceMappingURL to
1803         sourceMappingURLDirective since it is the correct name.
1804         * runtime/CachedTypes.cpp:
1805         (JSC::CachedSourceProviderShape::encode):
1806         (JSC::CachedFunctionExecutableRareData::encode):
1807         (JSC::CachedFunctionExecutableRareData::decode const): CachedFunctionExecutable did not have
1808         sourceMappingURL to sourceMappingURLDirective. So this patch keeps the same logic.
1809         (JSC::CachedFunctionExecutable::rareData const):
1810         (JSC::CachedFunctionExecutable::encode):
1811         (JSC::CachedFunctionExecutable::decode const):
1812         (JSC::UnlinkedFunctionExecutable::UnlinkedFunctionExecutable):
1813         * runtime/CodeCache.cpp:
1814         (JSC::CodeCache::getUnlinkedGlobalCodeBlock):
1815         (JSC::CodeCache::getUnlinkedGlobalFunctionExecutable):
1816         * runtime/CodeCache.h:
1817         (JSC::generateUnlinkedCodeBlockImpl):
1818         * runtime/FunctionExecutable.h:
1819         * runtime/SamplingProfiler.cpp:
1820         (JSC::SamplingProfiler::StackFrame::url):
1821
1822 2019-02-15  Yusuke Suzuki  <ysuzuki@apple.com>
1823
1824         [JSC] Remove unused global private variables
1825         https://bugs.webkit.org/show_bug.cgi?id=194741
1826
1827         Reviewed by Joseph Pecoraro.
1828
1829         There are some private functions and constants that are no longer referenced from builtin JS code.
1830         This patch cleans up them.
1831
1832         * builtins/BuiltinNames.h:
1833         * builtins/ObjectConstructor.js:
1834         (entries):
1835         * runtime/JSGlobalObject.cpp:
1836         (JSC::JSGlobalObject::init):
1837
1838 2019-02-15  Yusuke Suzuki  <ysuzuki@apple.com>
1839
1840         [JSC] Lazily create empty RegExp
1841         https://bugs.webkit.org/show_bug.cgi?id=194735
1842
1843         Reviewed by Keith Miller.
1844
1845         Some scripts do not have any RegExp. In that case, allocating MarkedBlock for RegExp is costly.
1846         Previously, there was always one RegExp, "empty RegExp". This patch lazily creates it and drop
1847         one MarkedBlock.
1848
1849         * runtime/JSGlobalObject.cpp:
1850         (JSC::JSGlobalObject::init):
1851         * runtime/RegExpCache.cpp:
1852         (JSC::RegExpCache::ensureEmptyRegExpSlow):
1853         (JSC::RegExpCache::initialize): Deleted.
1854         * runtime/RegExpCache.h:
1855         (JSC::RegExpCache::ensureEmptyRegExp):
1856         (JSC::RegExpCache::emptyRegExp const): Deleted.
1857         * runtime/RegExpCachedResult.cpp:
1858         (JSC::RegExpCachedResult::lastResult):
1859         * runtime/RegExpCachedResult.h:
1860         * runtime/VM.cpp:
1861         (JSC::VM::VM):
1862
1863 2019-02-15  Yusuke Suzuki  <ysuzuki@apple.com>
1864
1865         [JSC] Make builtin objects more lazily initialized under non-JIT mode
1866         https://bugs.webkit.org/show_bug.cgi?id=194727
1867
1868         Reviewed by Saam Barati.
1869
1870         Boolean, Symbol, and Number constructors and prototypes are initialized eagerly, but this is largely
1871         because concurrent compiler can touch NumberPrototype etc. when traversing object's prototypes. This
1872         means that eager initialization is not necessary under non-JIT mode. While we can investigate all the
1873         accesses to these prototypes from the concurrent compiler threads, this "lazily initialize under non-JIT"
1874         is safe and beneficial to non-JIT mode. This patch lazily initializes them under non-JIT mode, and
1875         drop some @Number references to avoid eager initialization. This removes some object allocations and 1
1876         MarkedBlock allocation just for Symbols.
1877
1878         * runtime/JSGlobalObject.cpp:
1879         (JSC::JSGlobalObject::init):
1880         (JSC::JSGlobalObject::visitChildren):
1881         * runtime/JSGlobalObject.h:
1882         (JSC::JSGlobalObject::numberToStringWatchpoint):
1883         (JSC::JSGlobalObject::booleanPrototype const):
1884         (JSC::JSGlobalObject::numberPrototype const):
1885         (JSC::JSGlobalObject::symbolPrototype const):
1886         (JSC::JSGlobalObject::booleanObjectStructure const):
1887         (JSC::JSGlobalObject::symbolObjectStructure const):
1888         (JSC::JSGlobalObject::numberObjectStructure const):
1889         (JSC::JSGlobalObject::stringObjectStructure const):
1890
1891 2019-02-15  Michael Saboff  <msaboff@apple.com>
1892
1893         RELEASE_ASSERT at com.apple.JavaScriptCore: JSC::jsSubstringOfResolved
1894         https://bugs.webkit.org/show_bug.cgi?id=194558
1895
1896         Reviewed by Saam Barati.
1897
1898         Added an in bounds check before the read of the next character for Unicode regular expressions
1899         for pattern generation that didn't already have such checks.
1900
1901         * yarr/YarrJIT.cpp:
1902         (JSC::Yarr::YarrGenerator::generatePatternCharacterOnce):
1903         (JSC::Yarr::YarrGenerator::generatePatternCharacterFixed):
1904         (JSC::Yarr::YarrGenerator::generateCharacterClassOnce):
1905         (JSC::Yarr::YarrGenerator::generateCharacterClassFixed):
1906
1907 2019-02-15  Dean Jackson  <dino@apple.com>
1908
1909         Allow emulation of user gestures from Web Inspector console
1910         https://bugs.webkit.org/show_bug.cgi?id=194725
1911         <rdar://problem/48126604>
1912
1913         Reviewed by Joseph Pecoraro and Devin Rousso.
1914
1915         * inspector/agents/InspectorRuntimeAgent.cpp: Add a new optional parameter, emulateUserGesture,
1916         to the evaluate function, and mark the function as override so that PageRuntimeAgent
1917         can change the behaviour.
1918         (Inspector::InspectorRuntimeAgent::evaluate):
1919         * inspector/agents/InspectorRuntimeAgent.h:
1920         * inspector/protocol/Runtime.json:
1921
1922 2019-02-15  Yusuke Suzuki  <ysuzuki@apple.com>
1923
1924         [JSC] Do not initialize Wasm related data if Wasm is not enabled
1925         https://bugs.webkit.org/show_bug.cgi?id=194728
1926
1927         Reviewed by Mark Lam.
1928
1929         Under non-JIT mode, these data structures are unnecessary. Should not allocate extra memory for that.
1930
1931         * runtime/InitializeThreading.cpp:
1932         (JSC::initializeThreading):
1933         * runtime/JSLock.cpp:
1934         (JSC::JSLock::didAcquireLock):
1935
1936 2019-02-15  Ross Kirsling  <ross.kirsling@sony.com>
1937
1938         [WTF] Add environment variable helpers
1939         https://bugs.webkit.org/show_bug.cgi?id=192405
1940
1941         Reviewed by Michael Catanzaro.
1942
1943         * inspector/remote/glib/RemoteInspectorGlib.cpp:
1944         (Inspector::RemoteInspector::RemoteInspector):
1945         (Inspector::RemoteInspector::start):
1946         * jsc.cpp:
1947         (startTimeoutThreadIfNeeded):
1948         * runtime/Options.cpp:
1949         (JSC::overrideOptionWithHeuristic):
1950         (JSC::Options::overrideAliasedOptionWithHeuristic):
1951         (JSC::Options::initialize):
1952         * runtime/VM.cpp:
1953         (JSC::enableAssembler):
1954         (JSC::VM::VM):
1955         * tools/CodeProfiling.cpp:
1956         (JSC::CodeProfiling::notifyAllocator):
1957         Utilize WTF::Environment where possible.
1958
1959 2019-02-15  Mark Lam  <mark.lam@apple.com>
1960
1961         SamplingProfiler::stackTracesAsJSON() should escape strings.
1962         https://bugs.webkit.org/show_bug.cgi?id=194649
1963         <rdar://problem/48072386>
1964
1965         Reviewed by Saam Barati.
1966
1967         Ditto for TypeSet::toJSONString() and TypeSet::toJSONString().
1968
1969         * runtime/SamplingProfiler.cpp:
1970         (JSC::SamplingProfiler::stackTracesAsJSON):
1971         * runtime/TypeSet.cpp:
1972         (JSC::TypeSet::toJSONString const):
1973         (JSC::StructureShape::toJSONString const):
1974
1975 2019-02-15  Robin Morisset  <rmorisset@apple.com>
1976
1977         CodeBlock::jettison should clear related watchpoints
1978         https://bugs.webkit.org/show_bug.cgi?id=194544
1979
1980         Reviewed by Mark Lam.
1981
1982         * bytecode/CodeBlock.cpp:
1983         (JSC::CodeBlock::jettison):
1984         * dfg/DFGCommonData.h:
1985         (JSC::DFG::CommonData::clearWatchpoints): Added.
1986         * dfg/CommonData.cpp:
1987         (JSC::DFG::CommonData::clearWatchpoints): Added.
1988
1989 2019-02-15  Tadeu Zagallo  <tzagallo@apple.com>
1990
1991         Move bytecode cache-related filesystem code out of CodeCache
1992         https://bugs.webkit.org/show_bug.cgi?id=194675
1993
1994         Reviewed by Saam Barati.
1995
1996         That code is only used for the bytecode-cache tests, so it should live in
1997         jsc.cpp rather than in the CodeCache.
1998
1999         * jsc.cpp:
2000         (CliSourceProvider::create):
2001         (CliSourceProvider::~CliSourceProvider):
2002         (CliSourceProvider::cachePath const):
2003         (CliSourceProvider::loadBytecode):
2004         (CliSourceProvider::CliSourceProvider):
2005         (jscSource):
2006         (GlobalObject::moduleLoaderFetch):
2007         (functionDollarEvalScript):
2008         (runWithOptions):
2009         * parser/SourceProvider.h:
2010         (JSC::SourceProvider::cacheBytecode const):
2011         * runtime/CodeCache.cpp:
2012         (JSC::writeCodeBlock):
2013         * runtime/CodeCache.h:
2014         (JSC::CodeCacheMap::fetchFromDiskImpl):
2015
2016 2019-02-15  Yusuke Suzuki  <ysuzuki@apple.com>
2017
2018         [JSC] DFG, FTL, and Wasm worklist creation should be fenced
2019         https://bugs.webkit.org/show_bug.cgi?id=194714
2020
2021         Reviewed by Mark Lam.
2022
2023         Let's consider about the following extreme case.
2024
2025         1. VM (A) is created.
2026         2. Another VM (B) is created on a different thread.
2027         3. (A) is being destroyed. It calls DFG::existingWorklistForIndexOrNull in a destructor.
2028         4. At the same time, (B) starts using DFG Worklist and it is instantiated in call_once.
2029         5. But (A) reads the pointer directly through DFG::existingWorklistForIndexOrNull.
2030         6. (A) sees the half-baked worklist, which may be in the middle of creation.
2031
2032         This patch puts store-store fence just before putting a pointer to a global variable.
2033         This fence is executed only three times at most, for DFG, FTL, and Wasm worklist initializations.
2034
2035         * dfg/DFGWorklist.cpp:
2036         (JSC::DFG::ensureGlobalDFGWorklist):
2037         (JSC::DFG::ensureGlobalFTLWorklist):
2038         * wasm/WasmWorklist.cpp:
2039         (JSC::Wasm::ensureWorklist):
2040
2041 2019-02-15  Commit Queue  <commit-queue@webkit.org>
2042
2043         Unreviewed, rolling out r241559 and r241566.
2044         https://bugs.webkit.org/show_bug.cgi?id=194710
2045
2046         Causes layout test crashes under GuardMalloc (Requested by
2047         ryanhaddad on #webkit).
2048
2049         Reverted changesets:
2050
2051         "[WTF] Add environment variable helpers"
2052         https://bugs.webkit.org/show_bug.cgi?id=192405
2053         https://trac.webkit.org/changeset/241559
2054
2055         "Unreviewed build fix for WinCairo Debug after r241559."
2056         https://trac.webkit.org/changeset/241566
2057
2058 2019-02-15  Yusuke Suzuki  <ysuzuki@apple.com>
2059
2060         [JSC] Do not even allocate JIT worklists in non-JIT mode
2061         https://bugs.webkit.org/show_bug.cgi?id=194693
2062
2063         Reviewed by Mark Lam.
2064
2065         Heap always allocates JIT worklists for Baseline, DFG, and FTL. While they do not have actual threads, Worklist itself already allocates some memory.
2066         And we do not perform any GC operations that are only meaningful in JIT environment.
2067
2068         1. We add VM::canUseJIT() check in Heap's ensureXXXWorklist things to prevent them from being allocated.
2069         2. We remove DFG marking constraint in non-JIT mode.
2070         3. We do not gather conservative roots from scratch buffers under the non-JIT mode (BTW, # of scratch buffers are always zero in non-JIT mode)
2071         4. We do not visit JITStubRoutineSet.
2072         5. Align JITWorklist function names to the other worklists.
2073
2074         * dfg/DFGOSRExitPreparation.cpp:
2075         (JSC::DFG::prepareCodeOriginForOSRExit):
2076         * dfg/DFGPlan.h:
2077         * dfg/DFGWorklist.cpp:
2078         (JSC::DFG::markCodeBlocks): Deleted.
2079         * dfg/DFGWorklist.h:
2080         * heap/Heap.cpp:
2081         (JSC::Heap::completeAllJITPlans):
2082         (JSC::Heap::iterateExecutingAndCompilingCodeBlocks):
2083         (JSC::Heap::gatherScratchBufferRoots):
2084         (JSC::Heap::removeDeadCompilerWorklistEntries):
2085         (JSC::Heap::stopThePeriphery):
2086         (JSC::Heap::suspendCompilerThreads):
2087         (JSC::Heap::resumeCompilerThreads):
2088         (JSC::Heap::addCoreConstraints):
2089         * jit/JITWorklist.cpp:
2090         (JSC::JITWorklist::existingGlobalWorklistOrNull):
2091         (JSC::JITWorklist::ensureGlobalWorklist):
2092         (JSC::JITWorklist::instance): Deleted.
2093         * jit/JITWorklist.h:
2094         * llint/LLIntSlowPaths.cpp:
2095         (JSC::LLInt::jitCompileAndSetHeuristics):
2096         * runtime/VM.cpp:
2097         (JSC::VM::~VM):
2098         (JSC::VM::gatherScratchBufferRoots):
2099         (JSC::VM::gatherConservativeRoots): Deleted.
2100         * runtime/VM.h:
2101
2102 2019-02-15  Saam barati  <sbarati@apple.com>
2103
2104         [WebAssembly] Write a new register allocator for Air O0 and make BBQ use it
2105         https://bugs.webkit.org/show_bug.cgi?id=194036
2106
2107         Reviewed by Yusuke Suzuki.
2108
2109         This patch adds a new Air-O0 backend. Air-O0 runs fewer passes and doesn't
2110         use linear scan for register allocation. Instead of linear scan, Air-O0 does
2111         mostly block-local register allocation, and it does this as it's emitting
2112         code directly. The register allocator uses liveness analysis to reduce
2113         the number of spills. Doing register allocation as we're emitting code
2114         allows us to skip editing the IR to insert spills, which saves a non trivial
2115         amount of compile time. For stack allocation, we give each Tmp its own slot.
2116         This is less than ideal. We probably want to do some trivial live range analysis
2117         in the future. The reason this isn't a deal breaker for Wasm is that this patch
2118         makes it so that we reuse Tmps as we're generating Air IR in the AirIRGenerator.
2119         Because Wasm is a stack machine, we trivially know when we kill a stack value (its last use).
2120         
2121         This patch is another 25% Wasm startup time speedup. It seems to be worth
2122         another 1% on JetStream2.
2123
2124         * JavaScriptCore.xcodeproj/project.pbxproj:
2125         * Sources.txt:
2126         * b3/air/AirAllocateRegistersAndStackAndGenerateCode.cpp: Added.
2127         (JSC::B3::Air::GenerateAndAllocateRegisters::GenerateAndAllocateRegisters):
2128         (JSC::B3::Air::GenerateAndAllocateRegisters::buildLiveRanges):
2129         (JSC::B3::Air::GenerateAndAllocateRegisters::insertBlocksForFlushAfterTerminalPatchpoints):
2130         (JSC::B3::Air::callFrameAddr):
2131         (JSC::B3::Air::GenerateAndAllocateRegisters::flush):
2132         (JSC::B3::Air::GenerateAndAllocateRegisters::spill):
2133         (JSC::B3::Air::GenerateAndAllocateRegisters::alloc):
2134         (JSC::B3::Air::GenerateAndAllocateRegisters::freeDeadTmpsIfNeeded):
2135         (JSC::B3::Air::GenerateAndAllocateRegisters::assignTmp):
2136         (JSC::B3::Air::GenerateAndAllocateRegisters::isDisallowedRegister):
2137         (JSC::B3::Air::GenerateAndAllocateRegisters::prepareForGeneration):
2138         (JSC::B3::Air::GenerateAndAllocateRegisters::generate):
2139         * b3/air/AirAllocateRegistersAndStackAndGenerateCode.h: Added.
2140         * b3/air/AirCode.cpp:
2141         * b3/air/AirCode.h:
2142         * b3/air/AirGenerate.cpp:
2143         (JSC::B3::Air::prepareForGeneration):
2144         (JSC::B3::Air::generateWithAlreadyAllocatedRegisters):
2145         (JSC::B3::Air::generate):
2146         * b3/air/AirHandleCalleeSaves.cpp:
2147         (JSC::B3::Air::handleCalleeSaves):
2148         * b3/air/AirHandleCalleeSaves.h:
2149         * b3/air/AirTmpMap.h:
2150         * runtime/Options.h:
2151         * wasm/WasmAirIRGenerator.cpp:
2152         (JSC::Wasm::AirIRGenerator::didKill):
2153         (JSC::Wasm::AirIRGenerator::newTmp):
2154         (JSC::Wasm::AirIRGenerator::AirIRGenerator):
2155         (JSC::Wasm::parseAndCompileAir):
2156         (JSC::Wasm::AirIRGenerator::addOp<OpType::I64TruncUF64>):
2157         (JSC::Wasm::AirIRGenerator::addOp<OpType::I64TruncUF32>):
2158         * wasm/WasmAirIRGenerator.h:
2159         * wasm/WasmB3IRGenerator.cpp:
2160         (JSC::Wasm::B3IRGenerator::didKill):
2161         * wasm/WasmBBQPlan.cpp:
2162         (JSC::Wasm::BBQPlan::compileFunctions):
2163         * wasm/WasmFunctionParser.h:
2164         (JSC::Wasm::FunctionParser<Context>::parseBody):
2165         (JSC::Wasm::FunctionParser<Context>::parseExpression):
2166         * wasm/WasmValidate.cpp:
2167         (JSC::Wasm::Validate::didKill):
2168
2169 2019-02-14  Saam barati  <sbarati@apple.com>
2170
2171         lowerStackArgs should lower Lea32/64 on ARM64 to Add
2172         https://bugs.webkit.org/show_bug.cgi?id=194656
2173
2174         Reviewed by Yusuke Suzuki.
2175
2176         On arm64, Lea is just implemented as an add. However, Air treats it as an
2177         address with a given width. Because of this width, we were incorrectly
2178         computing whether or not this immediate could fit into the instruction itself
2179         or it needed to be explicitly put into a register. This patch makes
2180         AirLowerStackArgs lower Lea to Add on arm64.
2181
2182         * b3/air/AirLowerStackArgs.cpp:
2183         (JSC::B3::Air::lowerStackArgs):
2184         * b3/air/AirOpcode.opcodes:
2185         * b3/air/testair.cpp:
2186
2187 2019-02-14  Saam Barati  <sbarati@apple.com>
2188
2189         Cache the results of BytecodeGenerator::getVariablesUnderTDZ
2190         https://bugs.webkit.org/show_bug.cgi?id=194583
2191         <rdar://problem/48028140>
2192
2193         Reviewed by Yusuke Suzuki.
2194
2195         This patch makes it so that getVariablesUnderTDZ caches a result of
2196         CompactVariableMap::Handle. getVariablesUnderTDZ is costly when
2197         it's called in an environment where there are a lot of variables.
2198         This patch makes it so we cache its results. This is profitable when
2199         getVariablesUnderTDZ is called repeatedly with the same environment
2200         state. This is common since we call this every time we encounter a
2201         function definition/expression node.
2202
2203         * builtins/BuiltinExecutables.cpp:
2204         (JSC::BuiltinExecutables::createExecutable):
2205         * bytecode/UnlinkedFunctionExecutable.cpp:
2206         (JSC::UnlinkedFunctionExecutable::UnlinkedFunctionExecutable):
2207         * bytecode/UnlinkedFunctionExecutable.h:
2208         * bytecompiler/BytecodeGenerator.cpp:
2209         (JSC::BytecodeGenerator::popLexicalScopeInternal):
2210         (JSC::BytecodeGenerator::liftTDZCheckIfPossible):
2211         (JSC::BytecodeGenerator::pushTDZVariables):
2212         (JSC::BytecodeGenerator::getVariablesUnderTDZ):
2213         (JSC::BytecodeGenerator::restoreTDZStack):
2214         * bytecompiler/BytecodeGenerator.h:
2215         (JSC::BytecodeGenerator::makeFunction):
2216         * parser/VariableEnvironment.cpp:
2217         (JSC::CompactVariableMap::Handle::Handle):
2218         (JSC::CompactVariableMap::Handle::operator=):
2219         * parser/VariableEnvironment.h:
2220         (JSC::CompactVariableMap::Handle::operator bool const):
2221         * runtime/CodeCache.cpp:
2222         (JSC::CodeCache::getUnlinkedGlobalFunctionExecutable):
2223
2224 2019-02-14  Yusuke Suzuki  <ysuzuki@apple.com>
2225
2226         [JSC] Non-JIT entrypoints should share NativeJITCode per entrypoint type
2227         https://bugs.webkit.org/show_bug.cgi?id=194659
2228
2229         Reviewed by Mark Lam.
2230
2231         Non-JIT entrypoints create NativeJITCode every time it is called. But it is meaningless since these entry point code are identical.
2232         We should create one per entrypoint type (for function, we should have CodeForCall and CodeForConstruct) and continue to use them.
2233         And we use NativeJITCode instead of DirectJITCode if it does not have difference between usual entrypoint and arity check entrypoint.
2234
2235         * dfg/DFGJITCode.h:
2236         * dfg/DFGJITFinalizer.cpp:
2237         (JSC::DFG::JITFinalizer::finalize):
2238         (JSC::DFG::JITFinalizer::finalizeFunction):
2239         * jit/JITCode.cpp:
2240         (JSC::DirectJITCode::initializeCodeRefForDFG):
2241         (JSC::DirectJITCode::initializeCodeRef): Deleted.
2242         (JSC::NativeJITCode::initializeCodeRef): Deleted.
2243         * jit/JITCode.h:
2244         * llint/LLIntEntrypoint.cpp:
2245         (JSC::LLInt::setFunctionEntrypoint):
2246         (JSC::LLInt::setEvalEntrypoint):
2247         (JSC::LLInt::setProgramEntrypoint):
2248         (JSC::LLInt::setModuleProgramEntrypoint): Retagged is removed since the tag is the same.
2249
2250 2019-02-14  Ross Kirsling  <ross.kirsling@sony.com>
2251
2252         [WTF] Add environment variable helpers
2253         https://bugs.webkit.org/show_bug.cgi?id=192405
2254
2255         Reviewed by Michael Catanzaro.
2256
2257         * inspector/remote/glib/RemoteInspectorGlib.cpp:
2258         (Inspector::RemoteInspector::RemoteInspector):
2259         (Inspector::RemoteInspector::start):
2260         * jsc.cpp:
2261         (startTimeoutThreadIfNeeded):
2262         * runtime/Options.cpp:
2263         (JSC::overrideOptionWithHeuristic):
2264         (JSC::Options::overrideAliasedOptionWithHeuristic):
2265         (JSC::Options::initialize):
2266         * runtime/VM.cpp:
2267         (JSC::enableAssembler):
2268         (JSC::VM::VM):
2269         * tools/CodeProfiling.cpp:
2270         (JSC::CodeProfiling::notifyAllocator):
2271         Utilize WTF::Environment where possible.
2272
2273 2019-02-14  Yusuke Suzuki  <ysuzuki@apple.com>
2274
2275         [JSC] Should have default NativeJITCode
2276         https://bugs.webkit.org/show_bug.cgi?id=194634
2277
2278         Reviewed by Mark Lam.
2279
2280         In JSC_useJIT=false mode, we always create identical NativeJITCode for call and construct when we create NativeExecutable.
2281         This is meaningless since we do not modify NativeJITCode after the creation. This patch adds singleton used as a default one.
2282         Since NativeJITCode (& JITCode) is ThreadSafeRefCounted, we can just share it in a whole process level. This removes 446 NativeJITCode
2283         allocations, which takes 14KB.
2284
2285         * runtime/VM.cpp:
2286         (JSC::jitCodeForCallTrampoline):
2287         (JSC::jitCodeForConstructTrampoline):
2288         (JSC::VM::getHostFunction):
2289
2290 2019-02-14  Tadeu Zagallo  <tzagallo@apple.com>
2291
2292         generateUnlinkedCodeBlockForFunctions shouldn't need to create a FunctionExecutable just to get its source code
2293         https://bugs.webkit.org/show_bug.cgi?id=194576
2294
2295         Reviewed by Saam Barati.
2296
2297         Extract a new function, `linkedSourceCode` from UnlinkedFunctionExecutable::link
2298         and use it in `generateUnlinkedCodeBlockForFunctions` instead.
2299
2300         * bytecode/UnlinkedFunctionExecutable.cpp:
2301         (JSC::UnlinkedFunctionExecutable::linkedSourceCode const):
2302         (JSC::UnlinkedFunctionExecutable::link):
2303         * bytecode/UnlinkedFunctionExecutable.h:
2304         * runtime/CodeCache.cpp:
2305         (JSC::generateUnlinkedCodeBlockForFunctions):
2306
2307 2019-02-14  Tadeu Zagallo  <tzagallo@apple.com>
2308
2309         CachedBitVector's size must be converted from bits to bytes
2310         https://bugs.webkit.org/show_bug.cgi?id=194441
2311
2312         Reviewed by Saam Barati.
2313
2314         CachedBitVector used its size in bits for memcpy. That didn't cause any
2315         issues when encoding, since the size in bits was also used in the allocation,
2316         but would overflow the actual BitVector buffer when decoding.
2317
2318         * runtime/CachedTypes.cpp:
2319         (JSC::CachedBitVector::encode):
2320         (JSC::CachedBitVector::decode const):
2321
2322 2019-02-13  Brian Burg  <bburg@apple.com>
2323
2324         Web Inspector: don't include accessibility role in DOM.Node object payloads
2325         https://bugs.webkit.org/show_bug.cgi?id=194623
2326         <rdar://problem/36384037>
2327
2328         Reviewed by Devin Rousso.
2329
2330         Remove property of DOM.Node that is no longer being sent.
2331
2332         * inspector/protocol/DOM.json:
2333
2334 2019-02-13  Keith Miller  <keith_miller@apple.com> and Yusuke Suzuki  <ysuzuki@apple.com>
2335
2336         We should only make rope strings when concatenating strings long enough.
2337         https://bugs.webkit.org/show_bug.cgi?id=194465
2338
2339         Reviewed by Mark Lam.
2340
2341         This patch stops us from allocating a rope string if the resulting
2342         rope would be smaller than the size of the JSRopeString object we
2343         would need to allocate.
2344
2345         This patch also adds paths so that we don't unnecessarily allocate
2346         JSString cells for primitives we are going to concatenate with a
2347         string anyway.
2348
2349         The important change from the previous one is that we do not apply
2350         the above rule to JSRopeStrings generated by JSStrings. If we convert
2351         it to JSString, comparison of memory consumption becomes the following,
2352         because JSRopeString does not have StringImpl until it is resolved.
2353
2354             sizeof(JSRopeString) v.s. sizeof(JSString) + sizeof(StringImpl) + content
2355
2356         Since sizeof(JSString) + sizeof(StringImpl) is larger than sizeof(JSRopeString),
2357         resolving eagerly increases memory footprint. The point is that we need to
2358         account newly created JSString and JSRopeString from the operands. This is the
2359         reason why this patch adds different thresholds for each jsString functions.
2360
2361         This patch also avoids concatenation for ropes conservatively. Many ropes are
2362         temporary cells. So we do not resolve eagerly if one of operands is already a
2363         rope.
2364
2365         In CLI execution, this change is performance neutral in JetStream2 (run 6 times, 1 for warming up and average in latter 5.).
2366
2367             Before: 159.3778
2368             After:  160.72340000000003
2369
2370         * dfg/DFGOperations.cpp:
2371         * runtime/CommonSlowPaths.cpp:
2372         (JSC::SLOW_PATH_DECL):
2373         * runtime/JSString.h:
2374         (JSC::JSString::isRope const):
2375         * runtime/Operations.cpp:
2376         (JSC::jsAddSlowCase):
2377         * runtime/Operations.h:
2378         (JSC::jsString):
2379         (JSC::jsAddNonNumber):
2380         (JSC::jsAdd):
2381
2382 2019-02-13  Saam Barati  <sbarati@apple.com>
2383
2384         AirIRGenerator::addSwitch switch patchpoint needs to model clobbering the scratch register
2385         https://bugs.webkit.org/show_bug.cgi?id=194610
2386
2387         Reviewed by Michael Saboff.
2388
2389         BinarySwitch might use the scratch register. We must model the
2390         effects of that properly. This is already caught by our br-table
2391         tests on arm64.
2392
2393         * wasm/WasmAirIRGenerator.cpp:
2394         (JSC::Wasm::AirIRGenerator::addSwitch):
2395
2396 2019-02-13  Mark Lam  <mark.lam@apple.com>
2397
2398         Create a randomized free list for new StructureIDs on StructureIDTable resize.
2399         https://bugs.webkit.org/show_bug.cgi?id=194566
2400         <rdar://problem/47975502>
2401
2402         Reviewed by Michael Saboff.
2403
2404         Also isolate 32-bit implementation of StructureIDTable out more so the 64-bit
2405         implementation is a little easier to read.
2406
2407         This patch appears to be perf neutral on JetStream2 (as run from the command line).
2408
2409         * runtime/StructureIDTable.cpp:
2410         (JSC::StructureIDTable::StructureIDTable):
2411         (JSC::StructureIDTable::makeFreeListFromRange):
2412         (JSC::StructureIDTable::resize):
2413         (JSC::StructureIDTable::allocateID):
2414         (JSC::StructureIDTable::deallocateID):
2415         * runtime/StructureIDTable.h:
2416         (JSC::StructureIDTable::get):
2417         (JSC::StructureIDTable::deallocateID):
2418         (JSC::StructureIDTable::allocateID):
2419         (JSC::StructureIDTable::flushOldTables):
2420
2421 2019-02-13  Tadeu Zagallo  <tzagallo@apple.com>
2422
2423         VariableLengthObject::allocate<T> should initialize objects
2424         https://bugs.webkit.org/show_bug.cgi?id=194534
2425
2426         Reviewed by Michael Saboff.
2427
2428         `buffer()` should not be called for empty VariableLengthObjects, but
2429         these cases were not being caught due to the objects not being properly
2430         initialized. Fix it so that allocate calls the constructor and fix the
2431         assertion failues.
2432
2433         * runtime/CachedTypes.cpp:
2434         (JSC::CachedObject::operator new):
2435         (JSC::VariableLengthObject::allocate):
2436         (JSC::CachedVector::encode):
2437         (JSC::CachedVector::decode const):
2438         (JSC::CachedUniquedStringImpl::decode const):
2439         (JSC::CachedBitVector::encode):
2440         (JSC::CachedBitVector::decode const):
2441         (JSC::CachedArray::encode):
2442         (JSC::CachedArray::decode const):
2443         (JSC::CachedImmutableButterfly::CachedImmutableButterfly):
2444         (JSC::CachedBigInt::decode const):
2445
2446 2019-02-13  Tadeu Zagallo  <tzagallo@apple.com>
2447
2448         CodeBlocks read from disk should not be re-written
2449         https://bugs.webkit.org/show_bug.cgi?id=194535
2450
2451         Reviewed by Michael Saboff.
2452
2453         Keep track of which CodeBlocks have been read from disk or have already
2454         been serialized in CodeCache.
2455
2456         * runtime/CodeCache.cpp:
2457         (JSC::CodeCache::write):
2458         * runtime/CodeCache.h:
2459         (JSC::SourceCodeValue::SourceCodeValue):
2460         (JSC::CodeCacheMap::fetchFromDiskImpl):
2461
2462 2019-02-13  Tadeu Zagallo  <tzagallo@apple.com>
2463
2464         SourceCode should be copied when generating bytecode for functions
2465         https://bugs.webkit.org/show_bug.cgi?id=194536
2466
2467         Reviewed by Saam Barati.
2468
2469         The FunctionExecutable might be collected while generating the bytecode
2470         for nested functions, in which case the SourceCode reference would no
2471         longer be valid.
2472
2473         * runtime/CodeCache.cpp:
2474         (JSC::generateUnlinkedCodeBlockForFunctions):
2475
2476 2019-02-12  Saam barati  <sbarati@apple.com>
2477
2478         JSScript needs to retain its cache path NSURL*
2479         https://bugs.webkit.org/show_bug.cgi?id=194577
2480
2481         Reviewed by Tim Horton.
2482
2483         * API/JSScript.mm:
2484         (+[JSScript scriptFromASCIIFile:inVirtualMachine:withCodeSigning:andBytecodeCache:]):
2485         (-[JSScript dealloc]):
2486
2487 2019-02-12  Robin Morisset  <rmorisset@apple.com>
2488
2489         Make B3Value::returnsBool() more precise
2490         https://bugs.webkit.org/show_bug.cgi?id=194457
2491
2492         Reviewed by Saam Barati.
2493
2494         It is currently used repeatedly in B3ReduceStrength, as well as once in B3LowerToAir.
2495         It has a needlessly complex rule for BitAnd, and has no rule for other easy cases such as BitOr or Select.
2496         No new tests added as this should be indirectly tested by the already existing tests.
2497
2498         * b3/B3Value.cpp:
2499         (JSC::B3::Value::returnsBool const):
2500
2501 2019-02-12  Michael Catanzaro  <mcatanzaro@igalia.com>
2502
2503         Unreviewed, fix -Wimplicit-fallthrough warning after r241140
2504         https://bugs.webkit.org/show_bug.cgi?id=194399
2505         <rdar://problem/47889777>
2506
2507         * dfg/DFGDoesGC.cpp:
2508         (JSC::DFG::doesGC):
2509
2510 2019-02-12  Michael Catanzaro  <mcatanzaro@igalia.com>
2511
2512         [WPE][GTK] Unsafe g_unsetenv() use in WebProcessPool::platformInitialize
2513         https://bugs.webkit.org/show_bug.cgi?id=194370
2514
2515         Reviewed by Darin Adler.
2516
2517         Change a couple WTFLogAlways to use g_warning, for good measure. Of course this isn't
2518         necessary, but it will make errors more visible.
2519
2520         * inspector/remote/glib/RemoteInspectorGlib.cpp:
2521         (Inspector::RemoteInspector::start):
2522         (Inspector::dbusConnectionCallAsyncReadyCallback):
2523         * inspector/remote/glib/RemoteInspectorServer.cpp:
2524         (Inspector::RemoteInspectorServer::start):
2525
2526 2019-02-12  Andy Estes  <aestes@apple.com>
2527
2528         [iOSMac] Enable Parental Controls Content Filtering
2529         https://bugs.webkit.org/show_bug.cgi?id=194521
2530         <rdar://39732376>
2531
2532         Reviewed by Tim Horton.
2533
2534         * Configurations/FeatureDefines.xcconfig:
2535
2536 2019-02-11  Mark Lam  <mark.lam@apple.com>
2537
2538         Randomize insertion of deallocated StructureIDs into the StructureIDTable's free list.
2539         https://bugs.webkit.org/show_bug.cgi?id=194512
2540         <rdar://problem/47975465>
2541
2542         Reviewed by Yusuke Suzuki.
2543
2544         * runtime/StructureIDTable.cpp:
2545         (JSC::StructureIDTable::StructureIDTable):
2546         (JSC::StructureIDTable::allocateID):
2547         (JSC::StructureIDTable::deallocateID):
2548         * runtime/StructureIDTable.h:
2549
2550 2019-02-10  Mark Lam  <mark.lam@apple.com>
2551
2552         Remove the RELEASE_ASSERT check for duplicate cases in the BinarySwitch constructor.
2553         https://bugs.webkit.org/show_bug.cgi?id=194493
2554         <rdar://problem/36380852>
2555
2556         Reviewed by Yusuke Suzuki.
2557
2558         Having duplicate cases in the BinarySwitch is not a correctness issue.  It is
2559         however not good for performance and memory usage.  As such, a debug ASSERT will
2560         do.  We'll also do an audit of the clients of BinarySwitch to see if it's
2561         possible to be instantiated with duplicate cases in
2562         https://bugs.webkit.org/show_bug.cgi?id=194492 later.
2563
2564         Also added some value dumps to the RELEASE_ASSERT to help debug the issue when we
2565         see duplicate cases.
2566
2567         * jit/BinarySwitch.cpp:
2568         (JSC::BinarySwitch::BinarySwitch):
2569
2570 2019-02-10  Darin Adler  <darin@apple.com>
2571
2572         Switch uses of StringBuilder with String::format for hex numbers to use HexNumber.h instead
2573         https://bugs.webkit.org/show_bug.cgi?id=194485
2574
2575         Reviewed by Daniel Bates.
2576
2577         * heap/HeapSnapshotBuilder.cpp:
2578         (JSC::HeapSnapshotBuilder::json): Use appendUnsignedAsHex along with
2579         reinterpret_cast<uintptr_t> to replace uses of String::format with "%p".
2580
2581         * runtime/JSGlobalObjectFunctions.cpp:
2582         (JSC::encode): Removed some unneeded casts in StringBuilder code,
2583         including one in a call to appendByteAsHex.
2584         (JSC::globalFuncEscape): Ditto.
2585
2586 2019-02-10  Commit Queue  <commit-queue@webkit.org>
2587
2588         Unreviewed, rolling out r241230.
2589         https://bugs.webkit.org/show_bug.cgi?id=194488
2590
2591         "It regressed JetStream2 by ~6%" (Requested by saamyjoon on
2592         #webkit).
2593
2594         Reverted changeset:
2595
2596         "We should only make rope strings when concatenating strings
2597         long enough."
2598         https://bugs.webkit.org/show_bug.cgi?id=194465
2599         https://trac.webkit.org/changeset/241230
2600
2601 2019-02-10  Saam barati  <sbarati@apple.com>
2602
2603         BBQ-Air: Emit better code for switch
2604         https://bugs.webkit.org/show_bug.cgi?id=194053
2605
2606         Reviewed by Yusuke Suzuki.
2607
2608         Instead of emitting a linear set of jumps for Switch, this patch
2609         makes the BBQ-Air backend emit a binary switch.
2610
2611         * wasm/WasmAirIRGenerator.cpp:
2612         (JSC::Wasm::AirIRGenerator::addSwitch):
2613
2614 2019-02-09  Yusuke Suzuki  <ysuzuki@apple.com>
2615
2616         Unreviewed, Lexer should use isLatin1 implementation in WTF
2617         https://bugs.webkit.org/show_bug.cgi?id=194466
2618
2619         Follow-up after r241233 pointed by Darin.
2620
2621         * parser/Lexer.cpp:
2622         (JSC::isLatin1): Deleted.
2623
2624 2019-02-09  Darin Adler  <darin@apple.com>
2625
2626         Eliminate unnecessary String temporaries by using StringConcatenateNumbers
2627         https://bugs.webkit.org/show_bug.cgi?id=194021
2628
2629         Reviewed by Geoffrey Garen.
2630
2631         * inspector/agents/InspectorConsoleAgent.cpp:
2632         (Inspector::InspectorConsoleAgent::count): Remove String::number and let
2633         makeString do the conversion without allocating/destroying a String.
2634         * inspector/agents/InspectorDebuggerAgent.cpp:
2635         (Inspector::objectGroupForBreakpointAction): Ditto.
2636         (Inspector::InspectorDebuggerAgent::setBreakpointByUrl): Ditto.
2637         (Inspector::InspectorDebuggerAgent::setBreakpoint): Ditto.
2638         * runtime/JSGenericTypedArrayViewInlines.h:
2639         (JSC::JSGenericTypedArrayView<Adaptor>::defineOwnProperty): Ditto.
2640         * runtime/NumberPrototype.cpp:
2641         (JSC::numberProtoFuncToFixed): Use String::numberToStringFixedWidth instead
2642         of calling numberToFixedWidthString to do the same thing.
2643         (JSC::numberProtoFuncToPrecision): Use String::number instead of calling
2644         numberToFixedPrecisionString to do the same thing.
2645         * runtime/SamplingProfiler.cpp:
2646         (JSC::SamplingProfiler::reportTopFunctions): Ditto.
2647
2648 2019-02-09  Yusuke Suzuki  <ysuzuki@apple.com>
2649
2650         Unreviewed, rolling in r241237 again
2651         https://bugs.webkit.org/show_bug.cgi?id=194469
2652
2653         * runtime/JSString.h:
2654         (JSC::jsSubstring):
2655
2656 2019-02-09  Commit Queue  <commit-queue@webkit.org>
2657
2658         Unreviewed, rolling out r241237.
2659         https://bugs.webkit.org/show_bug.cgi?id=194474
2660
2661         Shows significant memory increase in WSL (Requested by
2662         yusukesuzuki on #webkit).
2663
2664         Reverted changeset:
2665
2666         "[WTF] Use BufferInternal StringImpl if substring StringImpl
2667         takes more memory"
2668         https://bugs.webkit.org/show_bug.cgi?id=194469
2669         https://trac.webkit.org/changeset/241237
2670
2671 2019-02-08  Yusuke Suzuki  <ysuzuki@apple.com>
2672
2673         [WTF] Use BufferInternal StringImpl if substring StringImpl takes more memory
2674         https://bugs.webkit.org/show_bug.cgi?id=194469
2675
2676         Reviewed by Geoffrey Garen.
2677
2678         * runtime/JSString.h:
2679         (JSC::jsSubstring):
2680
2681 2019-02-08  Yusuke Suzuki  <ysuzuki@apple.com>
2682
2683         [JSC] CachedTypes should use jsString instead of JSString::create
2684         https://bugs.webkit.org/show_bug.cgi?id=194471
2685
2686         Reviewed by Mark Lam.
2687
2688         Use jsString() here because JSString::create is a bit low-level API and it requires some invariant like "length is not zero".
2689
2690         * runtime/CachedTypes.cpp:
2691         (JSC::CachedJSValue::decode const):
2692
2693 2019-02-08  Yusuke Suzuki  <ysuzuki@apple.com>
2694
2695         [JSC] Increase StructureIDTable initial capacity
2696         https://bugs.webkit.org/show_bug.cgi?id=194468
2697
2698         Reviewed by Mark Lam.
2699
2700         Currently, # of structures just after initializing JSGlobalObject (precisely, initializing GlobalObject in
2701         JSC shell), 281, already exceeds the current initial value 256. We should increase the capacity since
2702         unnecessary resizing requires more operations, keeps old StructureID array until GC happens, and makes
2703         more memory dirty. We also remove some structures that are no longer used.
2704
2705         * runtime/JSGlobalObject.h:
2706         (JSC::JSGlobalObject::callbackObjectStructure const):
2707         (JSC::JSGlobalObject::propertyNameIteratorStructure const): Deleted.
2708         * runtime/StructureIDTable.h:
2709         * runtime/VM.h:
2710
2711 2019-02-08  Yusuke Suzuki  <ysuzuki@apple.com>
2712
2713         [JSC] String.fromCharCode's slow path always generates 16bit string
2714         https://bugs.webkit.org/show_bug.cgi?id=194466
2715
2716         Reviewed by Keith Miller.
2717
2718         String.fromCharCode(a1) has a fast path and the most frequently used. And String.fromCharCode(a1, a2, ...)
2719         goes to the slow path. However, in the slow path, we always create 16bit string. 16bit string takes 2x memory,
2720         and even worse, taints ropes 16bit if 16bit string is included in the given rope. We find that acorn-wtb
2721         creates very large strings multiple times with String.fromCharCode, and String.fromCharCode always produces
2722         16bit string. However, only few strings are actually 16bit strings. This patch attempts to make 8bit string
2723         as much as possible.
2724
2725         It improves non JIT acorn-wtb's peak and current memory footprint by 6% and 3% respectively.
2726
2727         * runtime/StringConstructor.cpp:
2728         (JSC::stringFromCharCode):
2729
2730 2019-02-08  Keith Miller  <keith_miller@apple.com>
2731
2732         We should only make rope strings when concatenating strings long enough.
2733         https://bugs.webkit.org/show_bug.cgi?id=194465
2734
2735         Reviewed by Saam Barati.
2736
2737         This patch stops us from allocating a rope string if the resulting
2738         rope would be smaller than the size of the JSRopeString object we
2739         would need to allocate.
2740
2741         This patch also adds paths so that we don't unnecessarily allocate
2742         JSString cells for primitives we are going to concatenate with a
2743         string anyway.
2744
2745         * dfg/DFGOperations.cpp:
2746         * runtime/CommonSlowPaths.cpp:
2747         (JSC::SLOW_PATH_DECL):
2748         * runtime/JSString.h:
2749         * runtime/Operations.cpp:
2750         (JSC::jsAddSlowCase):
2751         * runtime/Operations.h:
2752         (JSC::jsString):
2753         (JSC::jsAdd):
2754
2755 2019-02-08  Saam barati  <sbarati@apple.com>
2756
2757         Nodes that rely on being dominated by CheckInBounds should have a child edge to it
2758         https://bugs.webkit.org/show_bug.cgi?id=194334
2759         <rdar://problem/47844327>
2760
2761         Reviewed by Mark Lam.
2762
2763         * dfg/DFGAbstractInterpreterInlines.h:
2764         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
2765         * dfg/DFGArgumentsEliminationPhase.cpp:
2766         * dfg/DFGByteCodeParser.cpp:
2767         (JSC::DFG::ByteCodeParser::parseBlock):
2768         * dfg/DFGClobberize.h:
2769         (JSC::DFG::clobberize):
2770         * dfg/DFGConstantFoldingPhase.cpp:
2771         (JSC::DFG::ConstantFoldingPhase::foldConstants):
2772         * dfg/DFGFixupPhase.cpp:
2773         (JSC::DFG::FixupPhase::fixupNode):
2774         (JSC::DFG::FixupPhase::convertToHasIndexedProperty):
2775         * dfg/DFGIntegerCheckCombiningPhase.cpp:
2776         (JSC::DFG::IntegerCheckCombiningPhase::handleBlock):
2777         * dfg/DFGIntegerRangeOptimizationPhase.cpp:
2778         * dfg/DFGNodeType.h:
2779         * dfg/DFGSSALoweringPhase.cpp:
2780         (JSC::DFG::SSALoweringPhase::lowerBoundsCheck):
2781         * dfg/DFGSpeculativeJIT.cpp:
2782         (JSC::DFG::SpeculativeJIT::compileHasIndexedProperty):
2783         * ftl/FTLLowerDFGToB3.cpp:
2784         (JSC::FTL::DFG::LowerDFGToB3::compileCheckInBounds):
2785         (JSC::FTL::DFG::LowerDFGToB3::compileHasIndexedProperty):
2786
2787 2019-02-08  Yusuke Suzuki  <ysuzuki@apple.com>
2788
2789         [JSC] Shrink sizeof(CodeBlock) more
2790         https://bugs.webkit.org/show_bug.cgi?id=194419
2791
2792         Reviewed by Mark Lam.
2793
2794         This patch further shrinks the size of CodeBlock, from 352 to 296 (304).
2795
2796         1. CodeBlock copies so many data from ScriptExecutable even if ScriptExecutable
2797         has the same information. These data is not touched in CodeBlock::~CodeBlock,
2798         so we can just use the data in ScriptExecutable instead of holding it in CodeBlock.
2799
2800         2. We remove m_instructions pointer since the ownership is managed by UnlinkedCodeBlock.
2801         And we do not touch it in CodeBlock::~CodeBlock.
2802
2803         3. We move m_calleeSaveRegisters from CodeBlock to CodeBlock::JITData. For baseline and LLInt
2804         cases, this patch offers RegisterAtOffsetList::llintBaselineCalleeSaveRegisters() which returns
2805         singleton to `const RegisterAtOffsetList*` usable for LLInt and Baseline JIT CodeBlocks.
2806
2807         4. Move m_catchProfiles to RareData and materialize only when op_catch's slow path is called.
2808
2809         5. Drop ownerScriptExecutable. ownerExecutable() returns ScriptExecutable*.
2810
2811         * bytecode/CodeBlock.cpp:
2812         (JSC::CodeBlock::hash const):
2813         (JSC::CodeBlock::sourceCodeForTools const):
2814         (JSC::CodeBlock::dumpAssumingJITType const):
2815         (JSC::CodeBlock::dumpSource):
2816         (JSC::CodeBlock::CodeBlock):
2817         (JSC::CodeBlock::finishCreation):
2818         (JSC::CodeBlock::propagateTransitions):
2819         (JSC::CodeBlock::finalizeLLIntInlineCaches):
2820         (JSC::CodeBlock::setCalleeSaveRegisters):
2821         (JSC::CodeBlock::ensureCatchLivenessIsComputedForBytecodeOffset):
2822         (JSC::CodeBlock::ensureCatchLivenessIsComputedForBytecodeOffsetSlow):
2823         (JSC::CodeBlock::lineNumberForBytecodeOffset):
2824         (JSC::CodeBlock::expressionRangeForBytecodeOffset const):
2825         (JSC::CodeBlock::hasOpDebugForLineAndColumn):
2826         (JSC::CodeBlock::newReplacement):
2827         (JSC::CodeBlock::replacement):
2828         (JSC::CodeBlock::computeCapabilityLevel):
2829         (JSC::CodeBlock::jettison):
2830         (JSC::CodeBlock::calleeSaveRegisters const):
2831         (JSC::CodeBlock::calleeSaveSpaceAsVirtualRegisters):
2832         (JSC::CodeBlock::updateOSRExitCounterAndCheckIfNeedToReoptimize):
2833         (JSC::CodeBlock::getArrayProfile):
2834         (JSC::CodeBlock::updateAllPredictionsAndCountLiveness):
2835         (JSC::CodeBlock::notifyLexicalBindingUpdate):
2836         (JSC::CodeBlock::tryGetValueProfileForBytecodeOffset):
2837         (JSC::CodeBlock::validate):
2838         (JSC::CodeBlock::outOfLineJumpTarget):
2839         (JSC::CodeBlock::arithProfileForBytecodeOffset):
2840         (JSC::CodeBlock::insertBasicBlockBoundariesForControlFlowProfiler):
2841         * bytecode/CodeBlock.h:
2842         (JSC::CodeBlock::specializationKind const):
2843         (JSC::CodeBlock::isStrictMode const):
2844         (JSC::CodeBlock::isConstructor const):
2845         (JSC::CodeBlock::codeType const):
2846         (JSC::CodeBlock::isKnownNotImmediate):
2847         (JSC::CodeBlock::instructions const):
2848         (JSC::CodeBlock::ownerExecutable const):
2849         (JSC::CodeBlock::thisRegister const):
2850         (JSC::CodeBlock::source const):
2851         (JSC::CodeBlock::sourceOffset const):
2852         (JSC::CodeBlock::firstLineColumnOffset const):
2853         (JSC::CodeBlock::createRareDataIfNecessary):
2854         (JSC::CodeBlock::ownerScriptExecutable const): Deleted.
2855         (JSC::CodeBlock::setThisRegister): Deleted.
2856         (JSC::CodeBlock::calleeSaveRegisters const): Deleted.
2857         * bytecode/EvalCodeBlock.h:
2858         * bytecode/FunctionCodeBlock.h:
2859         * bytecode/GlobalCodeBlock.h:
2860         (JSC::GlobalCodeBlock::GlobalCodeBlock):
2861         * bytecode/ModuleProgramCodeBlock.h:
2862         * bytecode/ProgramCodeBlock.h:
2863         * debugger/Debugger.cpp:
2864         (JSC::Debugger::toggleBreakpoint):
2865         * debugger/DebuggerCallFrame.cpp:
2866         (JSC::DebuggerCallFrame::sourceID const):
2867         (JSC::DebuggerCallFrame::sourceIDForCallFrame):
2868         * debugger/DebuggerScope.cpp:
2869         (JSC::DebuggerScope::location const):
2870         * dfg/DFGByteCodeParser.cpp:
2871         (JSC::DFG::ByteCodeParser::InlineStackEntry::executable):
2872         (JSC::DFG::ByteCodeParser::inliningCost):
2873         (JSC::DFG::ByteCodeParser::parseCodeBlock):
2874         * dfg/DFGCapabilities.cpp:
2875         (JSC::DFG::isSupportedForInlining):
2876         (JSC::DFG::mightCompileEval):
2877         (JSC::DFG::mightCompileProgram):
2878         (JSC::DFG::mightCompileFunctionForCall):
2879         (JSC::DFG::mightCompileFunctionForConstruct):
2880         (JSC::DFG::canUseOSRExitFuzzing):
2881         * dfg/DFGGraph.h:
2882         (JSC::DFG::Graph::executableFor):
2883         * dfg/DFGJITCompiler.cpp:
2884         (JSC::DFG::JITCompiler::compileFunction):
2885         * dfg/DFGOSREntry.cpp:
2886         (JSC::DFG::prepareOSREntry):
2887         * dfg/DFGOSRExit.cpp:
2888         (JSC::DFG::restoreCalleeSavesFor):
2889         (JSC::DFG::saveCalleeSavesFor):
2890         (JSC::DFG::saveOrCopyCalleeSavesFor):
2891         * dfg/DFGOSRExitCompilerCommon.cpp:
2892         (JSC::DFG::handleExitCounts):
2893         * dfg/DFGOperations.cpp:
2894         * dfg/DFGToFTLDeferredCompilationCallback.cpp:
2895         (JSC::DFG::ToFTLDeferredCompilationCallback::compilationDidComplete):
2896         * ftl/FTLCapabilities.cpp:
2897         (JSC::FTL::canCompile):
2898         * ftl/FTLLink.cpp:
2899         (JSC::FTL::link):
2900         * ftl/FTLOSRExitCompiler.cpp:
2901         (JSC::FTL::compileStub):
2902         * interpreter/CallFrame.cpp:
2903         (JSC::CallFrame::callerSourceOrigin):
2904         * interpreter/Interpreter.cpp:
2905         (JSC::eval):
2906         (JSC::UnwindFunctor::copyCalleeSavesToEntryFrameCalleeSavesBuffer const):
2907         * interpreter/StackVisitor.cpp:
2908         (JSC::StackVisitor::Frame::calleeSaveRegisters):
2909         (JSC::StackVisitor::Frame::sourceURL const):
2910         (JSC::StackVisitor::Frame::sourceID):
2911         (JSC::StackVisitor::Frame::computeLineAndColumn const):
2912         * interpreter/StackVisitor.h:
2913         * jit/AssemblyHelpers.h:
2914         (JSC::AssemblyHelpers::emitSaveCalleeSavesFor):
2915         (JSC::AssemblyHelpers::emitSaveOrCopyCalleeSavesFor):
2916         (JSC::AssemblyHelpers::emitRestoreCalleeSavesFor):
2917         * jit/CallFrameShuffleData.cpp:
2918         (JSC::CallFrameShuffleData::setupCalleeSaveRegisters):
2919         * jit/JIT.cpp:
2920         (JSC::JIT::compileWithoutLinking):
2921         * jit/JITToDFGDeferredCompilationCallback.cpp:
2922         (JSC::JITToDFGDeferredCompilationCallback::compilationDidComplete):
2923         * jit/JITWorklist.cpp:
2924         (JSC::JITWorklist::Plan::finalize):
2925         (JSC::JITWorklist::compileNow):
2926         * jit/RegisterAtOffsetList.cpp:
2927         (JSC::RegisterAtOffsetList::llintBaselineCalleeSaveRegisters):
2928         * jit/RegisterAtOffsetList.h:
2929         (JSC::RegisterAtOffsetList::at const):
2930         * runtime/ErrorInstance.cpp:
2931         (JSC::appendSourceToError):
2932         * runtime/ScriptExecutable.cpp:
2933         (JSC::ScriptExecutable::newCodeBlockFor):
2934         * runtime/StackFrame.cpp:
2935         (JSC::StackFrame::sourceID const):
2936         (JSC::StackFrame::sourceURL const):
2937         (JSC::StackFrame::computeLineAndColumn const):
2938
2939 2019-02-08  Robin Morisset  <rmorisset@apple.com>
2940
2941         B3LowerMacros wrongly sets m_changed to true in the case of AtomicWeakCAS on x86
2942         https://bugs.webkit.org/show_bug.cgi?id=194460
2943
2944         Reviewed by Mark Lam.
2945
2946         Trivial fix, should already be covered by testAtomicWeakCAS in testb3.cpp.
2947
2948         * b3/B3LowerMacros.cpp:
2949
2950 2019-02-08  Mark Lam  <mark.lam@apple.com>
2951
2952         Use maxSingleCharacterString in comparisons instead of literal constants.
2953         https://bugs.webkit.org/show_bug.cgi?id=194452
2954
2955         Reviewed by Yusuke Suzuki.
2956
2957         This way, if we ever change maxSingleCharacterString, it won't break all this code
2958         that relies on it being 0xff implicitly.
2959
2960         * dfg/DFGSpeculativeJIT.cpp:
2961         (JSC::DFG::SpeculativeJIT::compileStringSlice):
2962         (JSC::DFG::SpeculativeJIT::compileGetByValOnString):
2963         * ftl/FTLLowerDFGToB3.cpp:
2964         (JSC::FTL::DFG::LowerDFGToB3::compileStringCharAt):
2965         (JSC::FTL::DFG::LowerDFGToB3::compileStringSlice):
2966         * jit/ThunkGenerators.cpp:
2967         (JSC::stringGetByValGenerator):
2968         (JSC::charToString):
2969
2970 2019-02-08  Mark Lam  <mark.lam@apple.com>
2971
2972         Fix DFG's doesGC() for CheckTierUp*, GetByVal, PutByVal*, and StringCharAt nodes.
2973         https://bugs.webkit.org/show_bug.cgi?id=194446
2974         <rdar://problem/47926792>
2975
2976         Reviewed by Saam Barati.
2977
2978         Fix doesGC() for the following nodes:
2979
2980             CheckTierUpAtReturn:
2981                 Calls triggerTierUpNow(), which calls triggerFTLReplacementCompile(),
2982                 which calls Worklist::completeAllReadyPlansForVM(), which uses DeferGC.
2983
2984             CheckTierUpInLoop:
2985                 Calls triggerTierUpNowInLoop(), which calls tierUpCommon(), which calls
2986                 Worklist::completeAllReadyPlansForVM(), which uses DeferGC.
2987
2988             CheckTierUpAndOSREnter:
2989                 Calls triggerOSREntryNow(), which calls tierUpCommon(), which calls
2990                 Worklist::completeAllReadyPlansForVM(), which uses DeferGC.
2991
2992             GetByVal:
2993                 case Array::String calls operationSingleCharacterString(), which calls
2994                 jsSingleCharacterString(), which can allocate a string.
2995
2996             PutByValDirect:
2997             PutByVal:
2998             PutByValAlias:
2999                 For the DFG only, the integer TypeArrays calls compilePutByValForIntTypedArray(),
3000                 which may call slow paths operationPutByValDirectStrict(), operationPutByValDirectNonStrict(),
3001                 operationPutByValStrict(), or operationPutByValNonStrict().  All of these
3002                 slow paths call putByValInternal(), which may create exception objects, or
3003                 call the generic JSValue::put() which may execute arbitrary code.
3004
3005             StringCharAt:
3006                 Can call operationSingleCharacterString(), which calls jsSingleCharacterString(),
3007                 which can allocate a string.
3008
3009         Also fix DFG::SpeculativeJIT::compileGetByValOnString() and FTL's compileStringCharAt()
3010         to use the maxSingleCharacterString constant instead of a literal constant.
3011
3012         * dfg/DFGDoesGC.cpp:
3013         (JSC::DFG::doesGC):
3014         * dfg/DFGSpeculativeJIT.cpp:
3015         (JSC::DFG::SpeculativeJIT::compileGetByValOnString):
3016         * dfg/DFGSpeculativeJIT64.cpp:
3017         (JSC::DFG::SpeculativeJIT::compile):
3018         * ftl/FTLLowerDFGToB3.cpp:
3019         (JSC::FTL::DFG::LowerDFGToB3::compileGetByVal):
3020         (JSC::FTL::DFG::LowerDFGToB3::compilePutByVal):
3021         (JSC::FTL::DFG::LowerDFGToB3::compileStringCharAt):
3022
3023 2019-02-08  Yusuke Suzuki  <ysuzuki@apple.com>
3024
3025         [JSC] SourceProviderCacheItem should be small
3026         https://bugs.webkit.org/show_bug.cgi?id=194432
3027
3028         Reviewed by Saam Barati.
3029
3030         Some JetStream2 tests stress the JS parser. At that time, so many SourceProviderCacheItems are created.
3031         While they are removed when full-GC happens, it significantly increases the peak memory usage.
3032         This patch reduces the size of SourceProviderCacheItem from 56 to 32.
3033
3034         * parser/Parser.cpp:
3035         (JSC::Parser<LexerType>::parseFunctionInfo):
3036         * parser/ParserModes.h:
3037         * parser/ParserTokens.h:
3038         * parser/SourceProviderCacheItem.h:
3039         (JSC::SourceProviderCacheItem::endFunctionToken const):
3040         (JSC::SourceProviderCacheItem::SourceProviderCacheItem):
3041
3042 2019-02-07  Robin Morisset  <rmorisset@apple.com>
3043
3044         Fix Abs(Neg(x)) -> Abs(x) optimization in B3ReduceStrength
3045         https://bugs.webkit.org/show_bug.cgi?id=194420
3046
3047         Reviewed by Saam Barati.
3048
3049         In https://bugs.webkit.org/show_bug.cgi?id=194250, I added an optimization: Abs(Neg(x)) -> Abs(x).
3050         But I introduced two bugs, one is that I actually implemented Abs(Neg(x)) -> x, and the other is that the test is looking at Abs(Abs(x)) instead (both were stupid copy-paste mistakes).
3051         This trivial patch fixes both.
3052
3053         * b3/B3ReduceStrength.cpp:
3054         * b3/testb3.cpp:
3055         (JSC::B3::testAbsNegArg):
3056
3057 2019-02-07  Keith Miller  <keith_miller@apple.com>
3058
3059         Better error messages for module loader SPI
3060         https://bugs.webkit.org/show_bug.cgi?id=194421
3061
3062         Reviewed by Saam Barati.
3063
3064         * API/JSAPIGlobalObject.mm:
3065         (JSC::JSAPIGlobalObject::moduleLoaderImportModule):
3066
3067 2019-02-07  Mark Lam  <mark.lam@apple.com>
3068
3069         Fix more doesGC() for CheckTraps, GetMapBucket, and Switch nodes.
3070         https://bugs.webkit.org/show_bug.cgi?id=194399
3071         <rdar://problem/47889777>
3072
3073         Reviewed by Yusuke Suzuki.
3074
3075         Fix doesGC() for the following nodes:
3076
3077             CheckTraps:
3078                 We normally will not emit this node because Options::usePollingTraps() is
3079                 false by default.  However, as it is implemented now, CheckTraps can GC
3080                 because it can allocate a TerminatedExecutionException.  If we make the
3081                 TerminatedExecutionException a singleton allocated at initialization time,
3082                 doesGC() can return false for CheckTraps.
3083                 https://bugs.webkit.org/show_bug.cgi?id=194323
3084
3085             GetMapBucket:
3086                 Can call operationJSMapFindBucket() or operationJSSetFindBucket(),
3087                 which calls HashMapImpl::findBucket(), which calls jsMapHash(), which
3088                 can resolve a rope.
3089
3090             Switch:
3091                 If switchData kind is SwitchChar, can call operationResolveRope() .
3092                 If switchData kind is SwitchString and the child use kind is not StringIdentUse,
3093                     can call operationSwitchString() which resolves ropes.
3094
3095             DirectTailCall:
3096             ForceOSRExit:
3097             Return:
3098             TailCallForwardVarargs:
3099             TailCallVarargs:
3100             Throw:
3101                 These are terminal nodes.  It shouldn't really matter what doesGC() returns
3102                 for them, but following our conservative practice, unless we have a good
3103                 reason for doesGC() to return false, we should just return true.
3104
3105         * dfg/DFGDoesGC.cpp:
3106         (JSC::DFG::doesGC):
3107
3108 2019-02-07  Robin Morisset  <rmorisset@apple.com>
3109
3110         B3ReduceStrength: missing peephole optimizations for Neg and Sub
3111         https://bugs.webkit.org/show_bug.cgi?id=194250
3112
3113         Reviewed by Saam Barati.
3114
3115         Adds the following optimizations for integers:
3116         - Sub(x, x) => 0
3117             Already covered by the test testSubArg
3118         - Sub(x1, Neg(x2)) => Add (x1, x2)
3119             Added test: testSubNeg
3120         - Neg(Sub(x1, x2)) => Sub(x2, x1)
3121             Added test: testNegSub
3122         - Add(Neg(x1), x2) => Sub(x2, x1)
3123             Added test: testAddNeg1
3124         - Add(x1, Neg(x2)) => Sub(x1, x2)
3125             Added test: testAddNeg2
3126         Adds the following optimization for floating point values:
3127         - Abs(Neg(x)) => Abs(x)
3128             Added test: testAbsNegArg
3129             Adds the following optimization:
3130
3131         Also did some trivial refactoring, using m_value->isInteger() everywhere instead of isInt(m_value->type()), and using replaceWithNew<Value> instead of replaceWithNewValue(m_proc.add<Value(..))
3132
3133         * b3/B3ReduceStrength.cpp:
3134         * b3/testb3.cpp:
3135         (JSC::B3::testAddNeg1):
3136         (JSC::B3::testAddNeg2):
3137         (JSC::B3::testSubNeg):
3138         (JSC::B3::testNegSub):
3139         (JSC::B3::testAbsAbsArg):
3140         (JSC::B3::testAbsNegArg):
3141         (JSC::B3::run):
3142
3143 2019-02-06  Yusuke Suzuki  <ysuzuki@apple.com>
3144
3145         [JSC] Use BufferInternal single character StringImpl for SmallStrings
3146         https://bugs.webkit.org/show_bug.cgi?id=194374
3147
3148         Reviewed by Geoffrey Garen.
3149
3150         Currently, we first create a large StringImpl, and create bunch of substrings with length = 1.
3151         But pointer is larger than single character. BufferInternal StringImpl with single character
3152         is more memory efficient.
3153
3154         * runtime/SmallStrings.cpp:
3155         (JSC::SmallStringsStorage::SmallStringsStorage):
3156         (JSC::SmallStrings::SmallStrings):
3157         * runtime/SmallStrings.h:
3158
3159 2019-02-06  Yusuke Suzuki  <ysuzuki@apple.com>
3160
3161         [JSC] InitializeEntrypointArguments should produce SpecCellCheck if FlushFormat is FlushedCell
3162         https://bugs.webkit.org/show_bug.cgi?id=194369
3163         <rdar://problem/47813087>
3164
3165         Reviewed by Saam Barati.
3166
3167         InitializeEntrypointArguments says SpecCell if the FlushFormat is FlushedCell. But this actually has
3168         JSEmpty if it is TDZ. This incorrectly proved type information removes necessary CheckNotEmpty in
3169         constant folding phase.
3170
3171         * dfg/DFGAbstractInterpreterInlines.h:
3172         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
3173
3174 2019-02-06  Devin Rousso  <drousso@apple.com>
3175
3176         Web Inspector: DOM: don't send the entire function string with each event listener
3177         https://bugs.webkit.org/show_bug.cgi?id=194293
3178         <rdar://problem/47822809>
3179
3180         Reviewed by Joseph Pecoraro.
3181
3182         * inspector/protocol/DOM.json:
3183
3184         * runtime/JSFunction.h:
3185         Export `calculatedDisplayName`.
3186
3187 2019-02-06  Yusuke Suzuki  <ysuzuki@apple.com>
3188
3189         [JSC] PrivateName to PublicName hash table is wasteful
3190         https://bugs.webkit.org/show_bug.cgi?id=194277
3191
3192         Reviewed by Michael Saboff.
3193
3194         PrivateNames account for a lot of memory in the initial JSC footprint. BuiltinNames have Identifier fields corresponding to these PrivateNames
3195         which makes the sizeof(BuiltinNames) about 6KB. It also maintains hash tables for "PublicName to PrivateName" and "PrivateName to PublicName",
3196         each of which takes 16KB memory. While "PublicName to PrivateName" functionality is used in builtin JS (parsing "@xxx" and get a private
3197         name for "xxx"), "PrivateName to PublicName" is rarely used. Holding 16KB hash table for rarely used feature is costly.
3198
3199         In this patch, we add some rules to remove "PrivateName to PublicName" hash table.
3200
3201         1. PrivateName's content should be the same to PublicName.
3202         2. If PrivateName is not actually a private name (we introduced hacky mapping like "@iteratorSymbol" => Symbol.iterator),
3203            the public name should be easily crafted from the given PrivateName.
3204
3205         We modify the content of private names to ensure (1). And for (2), we can meet this requirement by ensuring that the "@xxxSymbol"
3206         is converted to "Symbol.xxx". (1) and (2) allow us to convert a private name to a public name without a large hash table.
3207
3208         We also remove unused identifiers in CommonIdentifiers. And we also move some of them to WebCore's WebCoreBuiltinNames if it is only used in
3209         WebCore.
3210
3211         * builtins/BuiltinNames.cpp:
3212         (JSC::BuiltinNames::BuiltinNames):
3213         * builtins/BuiltinNames.h:
3214         (JSC::BuiltinNames::lookUpPrivateName const):
3215         (JSC::BuiltinNames::getPublicName const):
3216         (JSC::BuiltinNames::checkPublicToPrivateMapConsistency):
3217         (JSC::BuiltinNames::appendExternalName):
3218         (JSC::BuiltinNames::lookUpPublicName const): Deleted.
3219         * builtins/BuiltinUtils.h:
3220         * bytecode/BytecodeDumper.cpp:
3221         (JSC::BytecodeDumper<Block>::dumpIdentifiers):
3222         * bytecompiler/NodesCodegen.cpp:
3223         (JSC::BytecodeIntrinsicNode::emit_intrinsic_getByIdDirectPrivate):
3224         (JSC::BytecodeIntrinsicNode::emit_intrinsic_putByIdDirectPrivate):
3225         * parser/Lexer.cpp:
3226         (JSC::Lexer<LChar>::parseIdentifier):
3227         (JSC::Lexer<UChar>::parseIdentifier):
3228         * parser/Parser.cpp:
3229         (JSC::Parser<LexerType>::createGeneratorParameters):
3230         (JSC::Parser<LexerType>::parseFunctionDeclaration):
3231         (JSC::Parser<LexerType>::parseAsyncFunctionDeclaration):
3232         (JSC::Parser<LexerType>::parseClassDeclaration):
3233         (JSC::Parser<LexerType>::parseExportDeclaration):
3234         (JSC::Parser<LexerType>::parseMemberExpression):
3235         * parser/ParserArena.h:
3236         (JSC::IdentifierArena::makeIdentifier):
3237         * runtime/CachedTypes.cpp:
3238         (JSC::CachedUniquedStringImpl::encode):
3239         (JSC::CachedUniquedStringImpl::decode const):
3240         * runtime/CommonIdentifiers.cpp:
3241         (JSC::CommonIdentifiers::CommonIdentifiers):
3242         (JSC::CommonIdentifiers::lookUpPrivateName const):
3243         (JSC::CommonIdentifiers::getPublicName const):
3244         (JSC::CommonIdentifiers::lookUpPublicName const): Deleted.
3245         * runtime/CommonIdentifiers.h:
3246         * runtime/ExceptionHelpers.cpp:
3247         (JSC::createUndefinedVariableError):
3248         * runtime/Identifier.cpp:
3249         (JSC::Identifier::dump const):
3250         * runtime/Identifier.h:
3251         * runtime/IdentifierInlines.h:
3252         (JSC::Identifier::fromUid):
3253         * runtime/JSTypedArrayViewPrototype.cpp:
3254         (JSC::JSTypedArrayViewPrototype::finishCreation):
3255         * tools/JSDollarVM.cpp:
3256         (JSC::functionGetPrivateProperty):
3257
3258 2019-02-06  Keith Rollin  <krollin@apple.com>
3259
3260         Really enable the automatic checking and regenerations of .xcfilelists during builds
3261         https://bugs.webkit.org/show_bug.cgi?id=194357
3262         <rdar://problem/47861231>
3263
3264         Reviewed by Chris Dumez.
3265
3266         Bug 194124 was supposed to enable the automatic checking and
3267         regenerating of .xcfilelist files during the build. While related
3268         changes were included in that patch, the change to actually enable the
3269         operation somehow was omitted. This patch actually enables the
3270         operation. The check-xcfilelist.sh scripts now check
3271         WK_DISABLE_CHECK_XCFILELISTS, and if it's "1", opts-out the developer
3272         from the checking.
3273
3274         * Scripts/check-xcfilelists.sh:
3275
3276 2019-02-06  Yusuke Suzuki  <ysuzuki@apple.com>
3277
3278         [JSC] Unify indirectEvalExecutableSpace and directEvalExecutableSpace
3279         https://bugs.webkit.org/show_bug.cgi?id=194339
3280
3281         Reviewed by Michael Saboff.
3282
3283         DirectEvalExecutable and IndirectEvalExecutable have completely same memory layout.
3284         They have even the same structure. This patch unifies the subspaces for them.
3285
3286         * runtime/DirectEvalExecutable.h:
3287         * runtime/EvalExecutable.h:
3288         (JSC::EvalExecutable::subspaceFor):
3289         * runtime/IndirectEvalExecutable.h:
3290         * runtime/VM.cpp:
3291         * runtime/VM.h:
3292         (JSC::VM::forEachScriptExecutableSpace):
3293
3294 2019-02-06  Yusuke Suzuki  <ysuzuki@apple.com>
3295
3296         [JSC] NativeExecutable should be smaller
3297         https://bugs.webkit.org/show_bug.cgi?id=194331
3298
3299         Reviewed by Michael Saboff.
3300
3301         NativeExecutable takes 88 bytes now. Since our GC rounds the size with 16, it actually takes 96 bytes in IsoSubspaces.
3302         Since a lot of NativeExecutable are allocated, we already has two MarkedBlocks even just after JSGlobalObject initialization.
3303         This patch makes sizeof(NativeExecutable) 64 bytes, which is 32 bytes smaller than 96 bytes. Now our JSGlobalObject initialization
3304         only takes one MarkedBlock for NativeExecutable.
3305
3306         To make NativeExecutable smaller,
3307
3308         1. m_numParametersForCall and m_numParametersForConstruct in ExecutableBase are only meaningful in ScriptExecutable subclasses. Since
3309            they are not touched from JIT, we can remove them from ExecutableBase and move them to ScriptExecutable.
3310
3311         2. DOMJIT::Signature* is rarely used. Rather than having it in NativeExecutable, we should put it in NativeJITCode. Since NativeExecutable
3312            always has JITCode, we can safely query the value from NativeExecutable. This patch creates NativeDOMJITCode, which is a subclass of
3313            NativeJITCode, and instantiated only when DOMJIT::Signature* is given.
3314
3315         3. Move Intrinsic to a member of ScriptExecutable or JITCode. Since JITCode has some paddings to put things, we can leverage this to put
3316            Intrinsic for NativeExecutable.
3317
3318         We also move "clearCode" code from ExecutableBase to ScriptExecutable since it is only valid for ScriptExecutable subclasses.
3319
3320         * CMakeLists.txt:
3321         * JavaScriptCore.xcodeproj/project.pbxproj:
3322         * bytecode/CallVariant.h:
3323         * interpreter/Interpreter.cpp:
3324         * jit/JITCode.cpp:
3325         (JSC::DirectJITCode::DirectJITCode):
3326         (JSC::NativeJITCode::NativeJITCode):
3327         (JSC::NativeDOMJITCode::NativeDOMJITCode):
3328         * jit/JITCode.h:
3329         (JSC::JITCode::signature const):
3330         (JSC::JITCode::intrinsic):
3331         * jit/JITOperations.cpp:
3332         * jit/JITThunks.cpp:
3333         (JSC::JITThunks::hostFunctionStub):
3334         * jit/Repatch.cpp:
3335         * llint/LLIntSlowPaths.cpp:
3336         * runtime/ExecutableBase.cpp:
3337         (JSC::ExecutableBase::dump const):
3338         (JSC::ExecutableBase::hashFor const):
3339         (JSC::ExecutableBase::hasClearableCode const): Deleted.
3340         (JSC::ExecutableBase::clearCode): Deleted.
3341         * runtime/ExecutableBase.h:
3342         (JSC::ExecutableBase::ExecutableBase):
3343         (JSC::ExecutableBase::isModuleProgramExecutable):
3344         (JSC::ExecutableBase::isHostFunction const):
3345         (JSC::ExecutableBase::generatedJITCodeForCall const):
3346         (JSC::ExecutableBase::generatedJITCodeForConstruct const):
3347         (JSC::ExecutableBase::generatedJITCodeFor const):
3348         (JSC::ExecutableBase::generatedJITCodeForCall): Deleted.
3349         (JSC::ExecutableBase::generatedJITCodeForConstruct): Deleted.
3350         (JSC::ExecutableBase::generatedJITCodeFor): Deleted.
3351         (JSC::ExecutableBase::offsetOfNumParametersFor): Deleted.
3352         (JSC::ExecutableBase::hasJITCodeForCall const): Deleted.
3353         (JSC::ExecutableBase::hasJITCodeForConstruct const): Deleted.
3354         (JSC::ExecutableBase::intrinsic const): Deleted.
3355         * runtime/ExecutableBaseInlines.h: Added.
3356         (JSC::ExecutableBase::intrinsic const):
3357         (JSC::ExecutableBase::hasJITCodeForCall const):
3358         (JSC::ExecutableBase::hasJITCodeForConstruct const):
3359         * runtime/JSBoundFunction.cpp:
3360         * runtime/JSType.cpp:
3361         (WTF::printInternal):
3362         * runtime/JSType.h:
3363         * runtime/NativeExecutable.cpp:
3364         (JSC::NativeExecutable::create):
3365         (JSC::NativeExecutable::createStructure):
3366         (JSC::NativeExecutable::NativeExecutable):
3367         (JSC::NativeExecutable::signatureFor const):
3368         (JSC::NativeExecutable::intrinsic const):
3369         * runtime/NativeExecutable.h:
3370         * runtime/ScriptExecutable.cpp:
3371         (JSC::ScriptExecutable::ScriptExecutable):
3372         (JSC::ScriptExecutable::clearCode):
3373         (JSC::ScriptExecutable::installCode):
3374         (JSC::ScriptExecutable::hasClearableCode const):
3375         * runtime/ScriptExecutable.h:
3376         (JSC::ScriptExecutable::intrinsic const):
3377         (JSC::ScriptExecutable::hasJITCodeForCall const):
3378         (JSC::ScriptExecutable::hasJITCodeForConstruct const):
3379         * runtime/VM.cpp:
3380         (JSC::VM::getHostFunction):
3381
3382 2019-02-06  Pablo Saavedra  <psaavedra@igalia.com>
3383
3384         Build failure after r240431
3385         https://bugs.webkit.org/show_bug.cgi?id=194330
3386
3387         Reviewed by Žan Doberšek.
3388
3389         * API/glib/JSCOptions.cpp:
3390
3391 2019-02-05  Mark Lam  <mark.lam@apple.com>
3392
3393         Fix DFG's doesGC() for a few more nodes.
3394         https://bugs.webkit.org/show_bug.cgi?id=194307
3395         <rdar://problem/47832956>
3396
3397         Reviewed by Yusuke Suzuki.
3398
3399         Fix doesGC() for the following nodes:
3400
3401             NumberToStringWithValidRadixConstant:
3402                 Calls operationInt32ToStringWithValidRadix(), which calls int32ToString(),
3403                 which can allocate a string.
3404                 Calls operationInt52ToStringWithValidRadix(), which calls int52ToString(),
3405                 which can allocate a string.
3406                 Calls operationDoubleToStringWithValidRadix(), which calls numberToString(),
3407                 which can allocate a string.
3408
3409             RegExpExecNonGlobalOrSticky: calls createRegExpMatchesArray() which allocates
3410                 memory for all kinds of objects.
3411             RegExpMatchFast: calls operationRegExpMatchFastString(), which calls
3412                 RegExpObject::execInline() and RegExpObject::matchGlobal().  Both of
3413                 these allocates memory for the match result.
3414             RegExpMatchFastGlobal: calls operationRegExpMatchFastGlobalString(), which
3415                 calls RegExpObject's collectMatches(), which allocates an array amongst
3416                 other objects.
3417
3418             StringFromCharCode:
3419                 If the uint32 code to convert is greater than maxSingleCharacterString,
3420                 we'll call operationStringFromCharCode(), which calls jsSingleCharacterString(),
3421                 which allocates a new string if the code is greater than maxSingleCharacterString.
3422
3423         Also fix SpeculativeJIT::compileFromCharCode() and FTL's compileStringFromCharCode()
3424         to use maxSingleCharacterString instead of a literal constant.
3425
3426         * dfg/DFGDoesGC.cpp:
3427         (JSC::DFG::doesGC):
3428         * dfg/DFGSpeculativeJIT.cpp:
3429         (JSC::DFG::SpeculativeJIT::compileFromCharCode):
3430         * ftl/FTLLowerDFGToB3.cpp:
3431         (JSC::FTL::DFG::LowerDFGToB3::compileStringFromCharCode):
3432
3433 2019-02-05  Keith Rollin  <krollin@apple.com>
3434
3435         Enable the automatic checking and regenerations of .xcfilelists during builds
3436         https://bugs.webkit.org/show_bug.cgi?id=194124
3437         <rdar://problem/47721277>
3438
3439         Reviewed by Tim Horton.
3440
3441         Bug 193790 add a facility for checking -- during build time -- that
3442         any needed .xcfilelist files are up-to-date and for updating them if
3443         they are not. This facility was initially opt-in by setting
3444         WK_ENABLE_CHECK_XCFILELISTS until other pieces were in place and until
3445         the process seemed robust. Its now time to enable this facility and
3446         make it opt-out. If there is a need to disable this facility, set and
3447         export WK_DISABLE_CHECK_XCFILELISTS=1 in your environment before
3448         running `make` or `build-webkit`, or before running Xcode from the
3449         command line.
3450
3451         Additionally, remove the step that generates a list of source files
3452         going into the UnifiedSources build step. It's only necessarily to
3453         specify Sources.txt and SourcesCocoa.txt as inputs.
3454
3455         * JavaScriptCore.xcodeproj/project.pbxproj:
3456         * UnifiedSources-input.xcfilelist: Removed.
3457
3458 2019-02-05  Keith Rollin  <krollin@apple.com>
3459
3460         Update .xcfilelist files
3461         https://bugs.webkit.org/show_bug.cgi?id=194121
3462         <rdar://problem/47720863>
3463
3464         Reviewed by Tim Horton.
3465
3466         Preparatory to enabling the facility for automatically updating the
3467         .xcfilelist files, check in a freshly-updated set so that not everyone
3468         runs up against having to regenerate them themselves.
3469
3470         * DerivedSources-input.xcfilelist:
3471         * DerivedSources-output.xcfilelist:
3472
3473 2019-02-05  Andy VanWagoner  <andy@vanwagoner.family>
3474
3475         [INTL] improve efficiency of Intl.NumberFormat formatToParts
3476         https://bugs.webkit.org/show_bug.cgi?id=185557
3477
3478         Reviewed by Mark Lam.
3479
3480         Since field nesting depth is minimal, this algorithm should be effectively O(n),
3481         where n is the number of characters in the formatted string.
3482         It may be less memory efficient than the previous impl, since the intermediate Vector
3483         is the length of the string, instead of the count of the fields.
3484
3485         * runtime/IntlNumberFormat.cpp:
3486         (JSC::IntlNumberFormat::formatToParts):
3487         * runtime/IntlNumberFormat.h:
3488
3489 2019-02-05  Mark Lam  <mark.lam@apple.com>
3490
3491         Move DFG nodes that clobberize() says will write(Heap) to the doesGC() list that returns true.
3492         https://bugs.webkit.org/show_bug.cgi?id=194298
3493         <rdar://problem/47827555>
3494
3495         Reviewed by Saam Barati.
3496
3497         We do this for 3 reasons:
3498         1. It's clearer when reading doesGC()'s code that these nodes will return true.
3499         2. If things change in the future where clobberize() no longer reports these nodes
3500            as write(Heap), each node should be vetted first to make sure that it can never
3501            GC before being moved back to the doesGC() list that returns false.
3502         3. This reduces the list of nodes that we need to audit to make sure doesGC() is
3503            correct in its claims about the nodes' GCing possibility.
3504
3505         The list of nodes moved are:
3506
3507             ArrayPush
3508             ArrayPop
3509             Call
3510             CallEval
3511             CallForwardVarargs
3512             CallVarargs
3513             Construct
3514             ConstructForwardVarargs
3515             ConstructVarargs
3516             DefineDataProperty
3517             DefineAccessorProperty
3518             DeleteById
3519             DeleteByVal
3520             DirectCall
3521             DirectConstruct
3522             DirectTailCallInlinedCaller
3523             GetById
3524             GetByIdDirect
3525             GetByIdDirectFlush
3526             GetByIdFlush
3527             GetByIdWithThis
3528             GetByValWithThis
3529             GetDirectPname
3530             GetDynamicVar
3531             HasGenericProperty
3532             HasOwnProperty
3533             HasStructureProperty
3534             InById
3535             InByVal
3536             InstanceOf
3537             InstanceOfCustom
3538             LoadVarargs
3539             NumberToStringWithRadix
3540             PutById
3541             PutByIdDirect
3542             PutByIdFlush
3543             PutByIdWithThis
3544             PutByOffset
3545             PutByValWithThis
3546             PutDynamicVar
3547             PutGetterById
3548             PutGetterByVal
3549             PutGetterSetterById
3550             PutSetterById
3551             PutSetterByVal
3552             PutStack
3553             PutToArguments
3554             RegExpExec
3555             RegExpTest
3556             ResolveScope
3557             ResolveScopeForHoistingFuncDeclInEval
3558             TailCall
3559             TailCallForwardVarargsInlinedCaller
3560             TailCallInlinedCaller
3561             TailCallVarargsInlinedCaller
3562             ToNumber
3563             ToPrimitive
3564             ValueNegate
3565
3566         * dfg/DFGDoesGC.cpp:
3567         (JSC::DFG::doesGC):
3568
3569 2019-02-05  Yusuke Suzuki  <ysuzuki@apple.com>
3570
3571         [JSC] Shrink sizeof(UnlinkedCodeBlock)
3572         https://bugs.webkit.org/show_bug.cgi?id=194281
3573
3574         Reviewed by Michael Saboff.
3575
3576         This patch first attempts to reduce the size of UnlinkedCodeBlock in a relatively simpler way. Reordering members, remove unused member, and
3577         move rarely used members to RareData. This changes sizeof(UnlinkedCodeBlock) from 312 to 256.
3578
3579         Still we have several chances to reduce sizeof(UnlinkedCodeBlock). Making more Vectors to RefCountedArrays can be done with some restructuring
3580         of generatorification phase. It would be possible to remove m_sourceURLDirective and m_sourceMappingURLDirective from UnlinkedCodeBlock since
3581         they should be in SourceProvider and that should be enough. These changes require some intrusive modifications and we make them as a future work.
3582
3583         * bytecode/CodeBlock.cpp:
3584         (JSC::CodeBlock::finishCreation):
3585         * bytecode/CodeBlock.h:
3586         (JSC::CodeBlock::bitVectors const): Deleted.
3587         * bytecode/CodeType.h:
3588         * bytecode/UnlinkedCodeBlock.cpp:
3589         (JSC::UnlinkedCodeBlock::UnlinkedCodeBlock):
3590         (JSC::UnlinkedCodeBlock::shrinkToFit):
3591         * bytecode/UnlinkedCodeBlock.h:
3592         (JSC::UnlinkedCodeBlock::bitVector):
3593         (JSC::UnlinkedCodeBlock::addBitVector):
3594         (JSC::UnlinkedCodeBlock::addSetConstant):
3595         (JSC::UnlinkedCodeBlock::constantRegisters):
3596         (JSC::UnlinkedCodeBlock::numberOfConstantIdentifierSets const):
3597         (JSC::UnlinkedCodeBlock::constantIdentifierSets):
3598         (JSC::UnlinkedCodeBlock::codeType const):
3599         (JSC::UnlinkedCodeBlock::didOptimize const):
3600         (JSC::UnlinkedCodeBlock::setDidOptimize):
3601         (JSC::UnlinkedCodeBlock::usesGlobalObject const): Deleted.
3602         (JSC::UnlinkedCodeBlock::setGlobalObjectRegister): Deleted.
3603         (JSC::UnlinkedCodeBlock::globalObjectRegister const): Deleted.
3604         (JSC::UnlinkedCodeBlock::bitVectors const): Deleted.
3605         * bytecompiler/BytecodeGenerator.cpp:
3606         (JSC::BytecodeGenerator::emitLoad):
3607         (JSC::BytecodeGenerator::emitLoadGlobalObject): Deleted.
3608         * bytecompiler/BytecodeGenerator.h:
3609         * runtime/CachedTypes.cpp:
3610         (JSC::CachedCodeBlockRareData::encode):
3611         (JSC::CachedCodeBlockRareData::decode const):
3612         (JSC::CachedCodeBlock::scopeRegister const):
3613         (JSC::CachedCodeBlock::codeType const):
3614         (JSC::UnlinkedCodeBlock::UnlinkedCodeBlock):
3615         (JSC::CachedCodeBlock<CodeBlockType>::decode const):
3616         (JSC::CachedCodeBlock<CodeBlockType>::encode):
3617         (JSC::CachedCodeBlock::globalObjectRegister const): Deleted.
3618
3619 2019-02-04  Yusuke Suzuki  <ysuzuki@apple.com>
3620
3621         Unreviewed, add missing exception checks after r240637
3622         https://bugs.webkit.org/show_bug.cgi?id=193546
3623
3624         * tools/JSDollarVM.cpp:
3625         (JSC::functionShadowChickenFunctionsOnStack):
3626
3627 2019-02-04  Yusuke Suzuki  <ysuzuki@apple.com>
3628
3629         [JSC] Shrink size of VM by lazily allocating IsoSubspaces for non-common types
3630         https://bugs.webkit.org/show_bug.cgi?id=193993
3631
3632         Reviewed by Keith Miller.
3633
3634         JSC::VM has a lot of IsoSubspaces, and each takes 504B. This unnecessarily makes VM so large.
3635         And some of them are rarely used. We should allocate it lazily.
3636
3637         In this patch, we make some `IsoSubspaces` `std::unique_ptr<IsoSubspace>`. And we add ensureXXXSpace
3638         functions which allocate IsoSubspaces lazily. This function is used by subspaceFor<> in each class.
3639         And we also add subspaceForConcurrently<> function, which is called from concurrent JIT tiers. This
3640         returns nullptr if the subspace is not allocated yet. JSCell::subspaceFor now takes second template
3641         parameter which tells the function whether subspaceFor is concurrently done. If the IsoSubspace is
3642         lazily created, we may return nullptr for the concurrent access. We ensure the space's initialization
3643         by using WTF::storeStoreFence when lazily allocating it.
3644
3645         In GC's constraint solving, we may touch these lazily allocated spaces. At that time, we check the
3646         existence of the space before touching this. This is not racy because the main thread is stopped when
3647         the constraint solving is working.
3648
3649         This changes sizeof(VM) from 64736 to 56472.
3650
3651         Another interesting thing is that we removed `PreventCollectionScope preventCollectionScope(heap);` in
3652         `Subspace::initialize`. This is really dangerous API since it easily causes dead-lock between the
3653         collector and the mutator if IsoSubspace is dynamically created. We do want to make IsoSubspaces
3654         dynamically-created ones since the requirement of the pre-allocation poses a scalability problem
3655         of IsoSubspace adoption because IsoSubspace is large. Registered Subspace is only touched in the
3656         EndPhase, and the peripheries should be stopped when running EndPhase. Thus, as long as the main thread
3657         can run this IsoSubspace code, the collector is never EndPhase. So this is safe.
3658
3659         * API/JSCallbackFunction.h:
3660         * API/ObjCCallbackFunction.h:
3661         (JSC::ObjCCallbackFunction::subspaceFor):
3662         * API/glib/JSCCallbackFunction.h:
3663         * CMakeLists.txt:
3664         * JavaScriptCore.xcodeproj/project.pbxproj:
3665         * bytecode/CodeBlock.cpp:
3666         (JSC::CodeBlock::visitChildren):
3667         (JSC::CodeBlock::finalizeUnconditionally):
3668         * bytecode/CodeBlock.h:
3669         * bytecode/EvalCodeBlock.h:
3670         * bytecode/ExecutableToCodeBlockEdge.h:
3671         * bytecode/FunctionCodeBlock.h:
3672         * bytecode/ModuleProgramCodeBlock.h:
3673         * bytecode/ProgramCodeBlock.h:
3674         * bytecode/UnlinkedFunctionExecutable.cpp:
3675         (JSC::UnlinkedFunctionExecutable::unlinkedCodeBlockFor):
3676         * bytecode/UnlinkedFunctionExecutable.h:
3677         * dfg/DFGSpeculativeJIT.cpp:
3678         (JSC::DFG::SpeculativeJIT::emitAllocateRawObject):
3679         (JSC::DFG::SpeculativeJIT::compileMakeRope):
3680         (JSC::DFG::SpeculativeJIT::compileNewObject):
3681         * ftl/FTLLowerDFGToB3.cpp:
3682         (JSC::FTL::DFG::LowerDFGToB3::compileMakeRope):
3683         (JSC::FTL::DFG::LowerDFGToB3::compileMaterializeNewObject):
3684         (JSC::FTL::DFG::LowerDFGToB3::allocateObject):
3685         (JSC::FTL::DFG::LowerDFGToB3::allocateVariableSizedObject):
3686         (JSC::FTL::DFG::LowerDFGToB3::allocateVariableSizedCell):
3687         * heap/Heap.cpp:
3688         (JSC::Heap::finalizeUnconditionalFinalizers):
3689         (JSC::Heap::deleteAllCodeBlocks):
3690         (JSC::Heap::deleteAllUnlinkedCodeBlocks):
3691         (JSC::Heap::addCoreConstraints):
3692         * heap/Subspace.cpp:
3693         (JSC::Subspace::initialize):
3694         * jit/AssemblyHelpers.h:
3695         (JSC::AssemblyHelpers::emitAllocateJSObjectWithKnownSize):
3696         (JSC::AssemblyHelpers::emitAllocateVariableSizedCell):
3697         * jit/JITOpcodes.cpp:
3698         (JSC::JIT::emit_op_new_object):
3699         * jit/JITOpcodes32_64.cpp:
3700         (JSC::JIT::emit_op_new_object):
3701         * runtime/DirectArguments.h:
3702         * runtime/DirectEvalExecutable.h:
3703         * runtime/ErrorInstance.h:
3704         (JSC::ErrorInstance::subspaceFor):
3705         * runtime/ExecutableBase.h:
3706         * runtime/FunctionExecutable.h:
3707         * runtime/IndirectEvalExecutable.h:
3708         * runtime/InferredValue.cpp:
3709         (JSC::InferredValue::visitChildren):
3710         * runtime/InferredValue.h:
3711         * runtime/InferredValueInlines.h:
3712         (JSC::InferredValue::finalizeUnconditionally):
3713         * runtime/InternalFunction.h:
3714         * runtime/JSAsyncFunction.h:
3715         * runtime/JSAsyncGeneratorFunction.h:
3716         * runtime/JSBoundFunction.h:
3717         * runtime/JSCell.h:
3718         (JSC::subspaceFor):
3719         (JSC::subspaceForConcurrently):
3720         * runtime/JSCellInlines.h:
3721         (JSC::allocatorForNonVirtualConcurrently):
3722         * runtime/JSCustomGetterSetterFunction.h:
3723         * runtime/JSDestructibleObject.h:
3724         * runtime/JSFunction.h:
3725         * runtime/JSGeneratorFunction.h:
3726         * runtime/JSImmutableButterfly.h:
3727         * runtime/JSLexicalEnvironment.h:
3728         (JSC::JSLexicalEnvironment::subspaceFor):
3729         * runtime/JSNativeStdFunction.h:
3730         * runtime/JSSegmentedVariableObject.h:
3731         * runtime/JSString.h:
3732         * runtime/ModuleProgramExecutable.h:
3733         * runtime/NativeExecutable.h:
3734         * runtime/ProgramExecutable.h:
3735         * runtime/PropertyMapHashTable.h:
3736         * runtime/ProxyRevoke.h:
3737         * runtime/ScopedArguments.h:
3738         * runtime/ScriptExecutable.cpp:
3739         (JSC::ScriptExecutable::clearCode):
3740         (JSC::ScriptExecutable::installCode):
3741         * runtime/Structure.h:
3742         * runtime/StructureRareData.h:
3743         * runtime/SubspaceAccess.h: Copied from Source/JavaScriptCore/runtime/InferredValueInlines.h.
3744         * runtime/VM.cpp:
3745         (JSC::VM::VM):
3746         * runtime/VM.h:
3747         (JSC::VM::SpaceAndSet::SpaceAndSet):
3748         (JSC::VM::SpaceAndSet::setFor):
3749         (JSC::VM::forEachScriptExecutableSpace):
3750         (JSC::VM::SpaceAndFinalizerSet::SpaceAndFinalizerSet): Deleted.
3751         (JSC::VM::SpaceAndFinalizerSet::finalizerSetFor): Deleted.
3752         (JSC::VM::ScriptExecutableSpaceAndSet::ScriptExecutableSpaceAndSet): Deleted.
3753         (JSC::VM::ScriptExecutableSpaceAndSet::clearableCodeSetFor): Deleted.
3754         (JSC::VM::UnlinkedFunctionExecutableSpaceAndSet::UnlinkedFunctionExecutableSpaceAndSet): Deleted.
3755         (JSC::VM::UnlinkedFunctionExecutableSpaceAndSet::clearableCodeSetFor): Deleted.
3756         * runtime/WeakMapImpl.h:
3757         (JSC::WeakMapImpl::subspaceFor):
3758         * wasm/js/JSWebAssemblyCodeBlock.h:
3759         * wasm/js/JSWebAssemblyMemory.h:
3760         * wasm/js/WebAssemblyFunction.h:
3761         * wasm/js/WebAssemblyWrapperFunction.h:
3762
3763 2019-02-04  Keith Miller  <keith_miller@apple.com>
3764
3765         Change llint operand macros to inline functions
3766         https://bugs.webkit.org/show_bug.cgi?id=194248
3767
3768         Reviewed by Mark Lam.
3769
3770         * llint/LLIntSlowPaths.cpp:
3771         (JSC::LLInt::getNonConstantOperand):
3772         (JSC::LLInt::getOperand):
3773         (JSC::LLInt::llint_trace_value):
3774         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
3775         (JSC::LLInt::getByVal):
3776         (JSC::LLInt::genericCall):
3777         (JSC::LLInt::varargsSetup):
3778         (JSC::LLInt::commonCallEval):
3779
3780 2019-02-04  Robin Morisset  <rmorisset@apple.com>
3781
3782         when lowering AssertNotEmpty, create the value before creating the patchpoint
3783         https://bugs.webkit.org/show_bug.cgi?id=194231
3784
3785         Reviewed by Saam Barati.
3786
3787         This is a very simple change: we should never generate B3 IR where an instruction depends on a value that comes later in the instruction stream.
3788         AssertNotEmpty was generating some such IR, it probably slipped through until now because it is a rather rare and tricky instruction to generate.
3789
3790         * ftl/FTLLowerDFGToB3.cpp:
3791         (JSC::FTL::DFG::LowerDFGToB3::compileAssertNotEmpty):
3792
3793 2019-02-04  Yusuke Suzuki  <ysuzuki@apple.com>
3794
3795         [JSC] ExecutableToCodeBlockEdge should be smaller
3796         https://bugs.webkit.org/show_bug.cgi?id=194244
3797
3798         Reviewed by Michael Saboff.
3799
3800         ExecutableToCodeBlockEdge is allocated so many times. However its memory layout is not efficient.
3801         sizeof(ExecutableToCodeBlockEdge) is 24bytes, but it discards 7bytes due to one bool m_isActive flag.
3802         Because our size classes are rounded by 16bytes, ExecutableToCodeBlockEdge takes 32bytes. So, half of
3803         it is wasted. We should fit it into 16bytes so that we can efficiently allocate it.
3804
3805         In this patch, we leverages TypeInfoMayBePrototype bit in JSTypeInfo. It is a bit special TypeInfo bit
3806         since this is per-cell bit. We rename this to TypeInfoPerCellBit, and use it as a `m_isActive` mark in
3807         ExecutableToCodeBlockEdge. In JSObject subclasses, we use it as MayBePrototype flag.
3808
3809         Since this flag is not changed in CAS style, we must not change this in concurrent threads. This is OK
3810         for ExecutableToCodeBlockEdge's m_isActive flag since this is touched on the main thread (ScriptExecutable::installCode
3811         does not touch it if it is called in non-main threads).
3812
3813         * bytecode/ExecutableToCodeBlockEdge.cpp:
3814         (JSC::ExecutableToCodeBlockEdge::finishCreation):
3815         (JSC::ExecutableToCodeBlockEdge::visitChildren):
3816         (JSC::ExecutableToCodeBlockEdge::activate):
3817         (JSC::ExecutableToCodeBlockEdge::deactivate):
3818         (JSC::ExecutableToCodeBlockEdge::isActive const):
3819         * bytecode/ExecutableToCodeBlockEdge.h:
3820         * runtime/JSCell.h:
3821         * runtime/JSCellInlines.h:
3822         (JSC::JSCell::perCellBit const):
3823         (JSC::JSCell::setPerCellBit):
3824         (JSC::JSCell::mayBePrototype const): Deleted.
3825         (JSC::JSCell::didBecomePrototype): Deleted.
3826         * runtime/JSObject.cpp:
3827         (JSC::JSObject::setPrototypeDirect):
3828         * runtime/JSObject.h:
3829         * runtime/JSObjectInlines.h:
3830         (JSC::JSObject::mayBePrototype const):
3831         (JSC::JSObject::didBecomePrototype):
3832         * runtime/JSTypeInfo.h:
3833         (JSC::TypeInfo::perCellBit):
3834         (JSC::TypeInfo::mergeInlineTypeFlags):
3835         (JSC::TypeInfo::mayBePrototype): Deleted.
3836
3837 2019-02-04  Yusuke Suzuki  <ysuzuki@apple.com>
3838
3839         [JSC] Shrink size of FunctionExecutable
3840         https://bugs.webkit.org/show_bug.cgi?id=194191
3841
3842         Reviewed by Michael Saboff.
3843
3844         This patch reduces the size of FunctionExecutable. Since it is allocated in IsoSubspace, reducing the size directly
3845         improves the allocation efficiency.
3846
3847         1. ScriptExecutable (base class of FunctionExecutable) has several members, but it is meaningful only in FunctionExecutable.
3848            We remove this from ScriptExecutable, and move it to FunctionExecutable.
3849
3850         2. FunctionExecutable has several data which are rarely used. One for FunctionOverrides functionality, which is typically
3851            used for JSC debugging purpose, and another is TypeSet and offsets for type profiler. We move them to RareData and reduce
3852            the size of FunctionExecutable in the common case.
3853
3854         This patch changes the size of FunctionExecutable from 176 to 144.
3855
3856         * bytecode/CodeBlock.cpp:
3857         (JSC::CodeBlock::dumpSource):
3858         (JSC::CodeBlock::finishCreation):
3859         * dfg/DFGNode.h:
3860         (JSC::DFG::Node::OpInfoWrapper::as const):
3861         * interpreter/StackVisitor.cpp:
3862         (JSC::StackVisitor::Frame::computeLineAndColumn const):
3863         * runtime/ExecutableBase.h:
3864         * runtime/FunctionExecutable.cpp:
3865         (JSC::FunctionExecutable::FunctionExecutable):
3866         (JSC::FunctionExecutable::ensureRareDataSlow):
3867         * runtime/FunctionExecutable.h:
3868         * runtime/Intrinsic.h:
3869         * runtime/ModuleProgramExecutable.cpp:
3870         (JSC::ModuleProgramExecutable::ModuleProgramExecutable):
3871         * runtime/ProgramExecutable.cpp:
3872         (JSC::ProgramExecutable::ProgramExecutable):
3873         * runtime/ScriptExecutable.cpp:
3874         (JSC::ScriptExecutable::ScriptExecutable):
3875         (JSC::ScriptExecutable::overrideLineNumber const):
3876         (JSC::ScriptExecutable::typeProfilingStartOffset const):
3877         (JSC::ScriptExecutable::typeProfilingEndOffset const):
3878         * runtime/ScriptExecutable.h:
3879         (JSC::ScriptExecutable::firstLine const):
3880         (JSC::ScriptExecutable::setOverrideLineNumber): Deleted.
3881         (JSC::ScriptExecutable::hasOverrideLineNumber const): Deleted.
3882         (JSC::ScriptExecutable::overrideLineNumber const): Deleted.
3883         (JSC::ScriptExecutable::typeProfilingStartOffset const): Deleted.
3884         (JSC::ScriptExecutable::typeProfilingEndOffset const): Deleted.
3885         * runtime/St