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