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