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