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