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