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