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