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