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