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