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