[JSC] StructureStubInfo::bufferedStructures should not ref/deref UniquedStringImpl
[WebKit-https.git] / Source / JavaScriptCore / ChangeLog
1 2020-03-19  Yusuke Suzuki  <ysuzuki@apple.com>
2
3         [JSC] StructureStubInfo::bufferedStructures should not ref/deref UniquedStringImpl
4         https://bugs.webkit.org/show_bug.cgi?id=209266
5         <rdar://problem/60508312>
6
7         Reviewed by Saam Barati.
8
9         StructureStubInfo::bufferedStructures includes RefPtr<UniquedStringImpl>. So destroying StructureStubInfo in
10         CodeBlock::finalizeUnconditionally can access to AtomStringTable, and get nullptr AtomStringTable since
11         CodeBlock::finalizeUnconditionally can be executed in heap-thread.
12
13         Temporarily setting AtomStringTable in the heap-thread when executing GC End phase is dangerous: Web worker's
14         JSC VM is releasing heapAccess when waiting for the next message in the RunLoop. This potentially means that
15         Web worker's main thread can run concurrently with Web worker's JSC VM's End phase heap-thread until the web
16         worker takes JSLock. (This is not a problem in WebCore since WebCore JSC VM never releases heapAccess. We cannot
17         take the same design since we would like to run End phase even if web worker is not getting any messages).
18
19         And removing resetJITData in CodeBlock::finalizeUnconditionally does not fix as well since CodeBlock::finalizeUnconditionally
20         calls StructureStubInfo::visitWeakReferences, and it removes some of entries of StructureStubInfo::bufferedStructures after
21         ByVal extension is introduced into StructureStubInfo.
22
23         This patch uses CacheableIdentifier for bufferedStructures. We make BufferedStructure class which holds Structure and CacheableIdentifier.
24         And StructureStubInfo holds HashSet<BufferedStructure>. We also visit CacheableIdentifier in StructureStubInfo::visitAggregate. To allow
25         concurrent collector to run this, we introduce m_bufferedStructuresLock in StructureStubInfo to guard m_bufferedStructures.
26
27         * bytecode/StructureStubInfo.cpp:
28         (JSC::StructureStubInfo::StructureStubInfo):
29         (JSC::StructureStubInfo::addAccessCase):
30         (JSC::StructureStubInfo::reset):
31         (JSC::StructureStubInfo::visitAggregate):
32         (JSC::StructureStubInfo::visitWeakReferences):
33         * bytecode/StructureStubInfo.h:
34         (JSC::StructureStubInfo::considerCaching):
35         (JSC::StructureStubInfo::getByIdSelfIdentifier):
36         (JSC::StructureStubInfo::cacheType const):
37         (JSC::StructureStubInfo::clearBufferedStructures):
38         (JSC::StructureStubInfo::BufferedStructure::BufferedStructure):
39         (JSC::StructureStubInfo::BufferedStructure::isHashTableDeletedValue const):
40         (JSC::StructureStubInfo::BufferedStructure::hash const):
41         (JSC::StructureStubInfo::BufferedStructure::operator==):
42         (JSC::StructureStubInfo::BufferedStructure::operator!=):
43         (JSC::StructureStubInfo::BufferedStructure::Hash::hash):
44         (JSC::StructureStubInfo::BufferedStructure::Hash::equal):
45         (JSC::StructureStubInfo::BufferedStructure::structure const):
46         (JSC::StructureStubInfo::BufferedStructure::byValId const):
47         * jit/JITOperations.cpp:
48         * runtime/CacheableIdentifier.h:
49         (JSC::CacheableIdentifier::hash const):
50
51 2020-03-19  Yusuke Suzuki  <ysuzuki@apple.com>
52
53         Unreviewed, build fix after r258717
54         https://bugs.webkit.org/show_bug.cgi?id=199295
55
56         * llint/LowLevelInterpreter.asm:
57
58 2020-03-18  Yusuke Suzuki  <ysuzuki@apple.com>
59
60         sanitizeStackForVMImpl writes below stack pointer, triggers huge warning spam from valgrind
61         https://bugs.webkit.org/show_bug.cgi?id=199295
62
63         Reviewed by Mark Lam.
64
65         During sanitizeStackForVMImpl, we should not access to the region beyond the stack-pointer.
66         This patch changes stack-pointer while sanitizeStackForVMImpl is zero-filling the old stack region.
67
68         * llint/LowLevelInterpreter.asm:
69
70 2020-03-19  Charlie Turner  <cturner@igalia.com>
71
72         Fix many warnings with Clang 7.0 on GTK x86-64 in Debug.
73         https://bugs.webkit.org/show_bug.cgi?id=209146
74
75         Reviewed by Darin Adler.
76
77         * runtime/JSCellInlines.h:
78         (JSC::CallFrame::deprecatedVM const): A reference may not be NULL, so
79         this ASSERT() can never trip.
80
81 2020-03-18  Yusuke Suzuki  <ysuzuki@apple.com>
82
83         Add a way to mark a rejected promise as handled
84         https://bugs.webkit.org/show_bug.cgi?id=209241
85
86         Reviewed by Michael Saboff.
87
88         Some of WebCore promise implementations (WebAnimation etc.) want to reject promise
89         as handled state to suppress UnhandledPromiseRejection tracking. For example, a
90         lot of WebCore implementations expose Promise DOM attributes which will be rejected
91         at some conditions. But we do not want to force users setting a handler for each such an
92         attribute.
93
94         This patch adds `JSPromise::rejectAsHandled` C++ function. This simply sets isHandledFlag
95         before executing `JSPromise::reject` if we are not calling a reject function yet.
96
97         * runtime/JSPromise.cpp:
98         (JSC::JSPromise::rejectAsHandled):
99         * runtime/JSPromise.h:
100         * tools/JSDollarVM.cpp:
101         (JSC::functionRejectPromiseAsHandled):
102         (JSC::JSDollarVM::finishCreation):
103
104 2020-03-17  Yusuke Suzuki  <ysuzuki@apple.com>
105
106         [JSC] DeleteIC patchpoint in FTL should require tag and mask registers
107         https://bugs.webkit.org/show_bug.cgi?id=209197
108         <rdar://problem/60531308>
109
110         Reviewed by Tadeu Zagallo and Saam Barati.
111
112         DeleteIC patchpoint is emitting `branchIfNotCell` machine code. This requires a mask register
113         while we are not reserving them when creating a patchpoint.
114
115         In general, our IC code is assuming usual CCallHelpers environment which provides macro-assembler
116         scratch, tag, and mask registers. We should offer them even if IC is emitted from FTL. In this
117         patch, we offer tag and mask registers for Delete IC even if this IC is not currently using tag
118         register.
119
120         * ftl/FTLLowerDFGToB3.cpp:
121         (JSC::FTL::DFG::LowerDFGToB3::compileDelBy):
122
123 2020-03-17  Tadeu Zagallo  <tzagallo@apple.com>
124
125         AccessCase::canReplace should allow a Getter to replace an IntrinsicGetter
126         https://bugs.webkit.org/show_bug.cgi?id=209158
127         <rdar://problem/59222012>
128
129         Reviewed by Saam Barati.
130
131         When we override an intrinsic getter with a user defined getter, we might end up with the
132         same offset and attributes. In which case, an inline cache that contained an entry for the
133         intrisic getter will believe that it is still valid, and add a new getter access case,
134         leading to duplicate entries for the same structure.
135
136         * bytecode/AccessCase.cpp:
137         (JSC::AccessCase::canReplace const):
138
139 2020-03-16  Yusuke Suzuki  <ysuzuki@apple.com>
140
141         [JSC] JSMapIterator and JSSetIterator are CellType
142         https://bugs.webkit.org/show_bug.cgi?id=209168
143         <rdar://problem/59705631>
144
145         Reviewed by Saam Barati.
146
147         They are JSCell, not JSObject since they are not used as a user-observable set/map iterators in JSC.
148         However, their JSType is ObjectType. They should use CellType instead.
149
150         * runtime/JSMapIterator.h:
151         * runtime/JSSetIterator.h:
152
153 2020-03-16  Keith Miller  <keith_miller@apple.com>
154
155         JavaScript identifier grammar supports unescaped astral symbols, but JSC doesn’t
156         https://bugs.webkit.org/show_bug.cgi?id=208998
157
158         Reviewed by Michael Saboff.
159
160         This patch fixes a bug in the parser that allows for surrogate pairs when parsing identifiers.
161         It also makes a few other changes to the parser:
162
163         1) When looking for keywords we just need to check that subsequent
164         character cannot be a identifier part or an escape start.
165
166         2) The only time we call parseIdentifierSlowCase is when we hit an
167         escape start or a surrogate pair so we can optimize that to just
168         copy everything up slow character into our buffer.
169
170         3) We shouldn't allow for asking if a UChar is an identifier start/part.
171
172         * KeywordLookupGenerator.py:
173         (Trie.printSubTreeAsC):
174         (Trie.printAsC):
175         * parser/Lexer.cpp:
176         (JSC::isNonLatin1IdentStart):
177         (JSC::isIdentStart):
178         (JSC::isSingleCharacterIdentStart):
179         (JSC::cannotBeIdentStart):
180         (JSC::isIdentPart):
181         (JSC::isSingleCharacterIdentPart):
182         (JSC::cannotBeIdentPartOrEscapeStart):
183         (JSC::Lexer<LChar>::currentCodePoint const):
184         (JSC::Lexer<UChar>::currentCodePoint const):
185         (JSC::Lexer<LChar>::parseIdentifier):
186         (JSC::Lexer<UChar>::parseIdentifier):
187         (JSC::Lexer<CharacterType>::parseIdentifierSlowCase):
188         (JSC::Lexer<T>::lexWithoutClearingLineTerminator):
189         (JSC::Lexer<T>::scanRegExp):
190         (JSC::isIdentPartIncludingEscapeTemplate): Deleted.
191         (JSC::isIdentPartIncludingEscape): Deleted.
192         * parser/Lexer.h:
193         (JSC::Lexer::setOffsetFromSourcePtr): Deleted.
194         * parser/Parser.cpp:
195         (JSC::Parser<LexerType>::printUnexpectedTokenText):
196         * parser/ParserTokens.h:
197
198 2020-03-13  Sergio Villar Senin  <svillar@igalia.com>
199
200         [WebXR] IDLs, stubs and build configuration for WPE
201         https://bugs.webkit.org/show_bug.cgi?id=208702
202
203         Reviewed by Dean Jackson.
204
205         * Configurations/FeatureDefines.xcconfig: Added ENABLE_WEBXR, off by default.
206
207 2020-03-15  Yusuke Suzuki  <ysuzuki@apple.com>
208
209         reportZappedCellAndCrash should handle PreciseAllocation in IsoSubspace
210         https://bugs.webkit.org/show_bug.cgi?id=209042
211
212         Reviewed by Mark Lam.
213
214         This patch adds support of PreciseAllocation cells to reportZappedCellAndCrash, since now it is frequently used
215         as a lower-tier cells in IsoSubspace.
216
217         * heap/IsoSubspace.h:
218         * heap/IsoSubspaceInlines.h:
219         (JSC::IsoSubspace::forEachLowerTierFreeListedPreciseAllocation):
220         * runtime/JSCell.cpp:
221         (JSC::reportZappedCellAndCrash):
222
223 2020-03-15  Yusuke Suzuki  <ysuzuki@apple.com>
224
225         Should not use variable-length-array (VLA)
226         https://bugs.webkit.org/show_bug.cgi?id=209043
227
228         Reviewed by Mark Lam.
229
230         This patch disables variable-length-array (VLA). If this feature uses user-input, user can
231         control the stack height consumed by C++ code. This patch avoids using VLA. To achieve that,
232
233             1. We set `-Wvla` warning option to trigger warnings if it is used.
234             2. Introduce MarkedJSValueRefArray for API. This replaces `JSValueRef arguments[variableLength]` use case.
235                MarkedJSValueRefArray registers itself to JSC GC so that GC can mark it as a strong root.
236
237         * API/JSContext.mm:
238         (+[JSContext currentArguments]):
239         * API/JSValue.mm:
240         (-[JSValue callWithArguments:]):
241         (-[JSValue constructWithArguments:]):
242         (-[JSValue invokeMethod:withArguments:]):
243         * API/MarkedJSValueRefArray.cpp: Added.
244         (JSC::MarkedJSValueRefArray::MarkedJSValueRefArray):
245         (JSC::MarkedJSValueRefArray::~MarkedJSValueRefArray):
246         (JSC::MarkedJSValueRefArray::visitAggregate):
247         * API/MarkedJSValueRefArray.h: Added.
248         * API/tests/minidom.c:
249         (print):
250         * API/tests/testapi.cpp:
251         (TestAPI::markedJSValueArrayAndGC):
252         (testCAPIViaCpp):
253         * Configurations/Base.xcconfig:
254         * JavaScriptCore.xcodeproj/project.pbxproj:
255         * Sources.txt:
256         * heap/Heap.cpp:
257         (JSC::Heap::addCoreConstraints):
258         (JSC::Heap::addMarkedJSValueRefArray):
259         * heap/Heap.h:
260         * heap/MarkedSpace.h:
261         (JSC::MarkedSpace::activeWeakSetsBegin): Deleted.
262         (JSC::MarkedSpace::activeWeakSetsEnd): Deleted.
263         (JSC::MarkedSpace::newActiveWeakSetsBegin): Deleted.
264         (JSC::MarkedSpace::newActiveWeakSetsEnd): Deleted.
265         * runtime/ArgList.h:
266
267 2020-03-14  Saam Barati  <sbarati@apple.com>
268
269         Unreviewed. Fix windows build by making configSizeToProtect stay 4KB.
270
271         * runtime/JSCConfig.h:
272
273 2020-03-13  Saam Barati  <sbarati@apple.com>
274
275         configSizeToProtect should be 16KB
276         https://bugs.webkit.org/show_bug.cgi?id=209068
277
278         Reviewed by Keith Miller.
279
280         * runtime/JSCConfig.h:
281
282 2020-03-13  Yusuke Suzuki  <ysuzuki@apple.com>
283
284         Unreviewed, fix JSC / test262 tests
285         https://bugs.webkit.org/show_bug.cgi?id=209033
286         <rdar://problem/58946936>
287
288         Follow-up change for DisallowGC causes crash because CodeBlock is nullptr when function call is non JS calls.
289
290         * interpreter/Interpreter.cpp:
291         (JSC::Interpreter::executeCall):
292         (JSC::Interpreter::executeConstruct):
293
294 2020-03-13  Tadeu Zagallo  <tzagallo@apple.com>
295
296         Missing arithMode for ArithAbs and ArithNegate in DFGClobberize
297         https://bugs.webkit.org/show_bug.cgi?id=208685
298         <rdar://problem/60115088>
299
300         Reviewed by Saam Barati.
301
302         In the pure case of ArithNegate and ArithAbs in DFGClobberize, their PureValues did not include their
303         respective ArithMode. That means that e.g. a CheckOverflow ArithNegate/Abs could be considered equivalent
304         to an Unchecked version of the same node.
305
306         Thanks to Samuel Groß of Google Project Zero for identifying this bug.
307
308         * dfg/DFGClobberize.h:
309         (JSC::DFG::clobberize):
310
311 2020-03-13  Myles C. Maxfield  <mmaxfield@apple.com>
312
313         [Cocoa] Push applicationSDKVersion() down from WebCore into WTF
314         https://bugs.webkit.org/show_bug.cgi?id=209030
315
316         Reviewed by Simon Fraser.
317
318         dyld_get_program_sdk_version() gives you the wrong answer in the Web Process (or at least
319         not the answer you actually want). There are already facilities for the UI Process to tell
320         the Web Process what the real value is, but those functions are currently in WebCore,
321         which is inaccessible to WTF. This patch is in preparation for
322         https://bugs.webkit.org/show_bug.cgi?id=208969 which needs to know this information in WTF.
323
324         I also found a few places which were calling dyld_get_program_sdk_version() in JavaScriptCore
325         and WebCore (which is wrong because those libraries exist in the Web Process), and have fixed
326         them up to use applicationSDKVersion() instead.
327
328         * API/JSWrapperMap.mm:
329         (supportsInitMethodConstructors):
330
331 2020-03-13  Yusuke Suzuki  <ysuzuki@apple.com>
332
333         [JSC] Reload CodeBlock or suppress GC while setting up calls
334         https://bugs.webkit.org/show_bug.cgi?id=209033
335         <rdar://problem/58946936>
336
337         Reviewed by Saam Barati.
338
339         The sequence of Interpreter::execute is the following.
340
341             1. Getting CodeBlock from Executable
342             2. Doing a lot of setups
343             3. Setting (1)'s CodeBlock to ProtoFrame
344             4. Calling code through Executable
345
346         During (2), it would be possible that GC happens and it replaces CodeBlock in Executable.
347         Then, when executing JITCode with CodeBlock in (4), we use new JITCode with old CodeBlock.
348
349         In this patch,
350
351         For ProgramExecutable, FunctionExecutable, ModuleProgramExecutable, we ensure that no GC happens
352         after getting CodeBlock by placing DisallowGC. For EvalExecutable, we reload CodeBlock after setting
353         up environment. It is possible that FunctionExecutable* stored in CodeBlock can be different when
354         executing a new CodeBlock, but this is OK since this different does not appear and we do not rely on
355         this: we are touching `name` of FunctionExecutable* which is retrieved from CodeBlock. But this name
356         will not be changed since this is derived from UnlinkedFunctionExecutable which is shared by multiple
357         CodeBlocks. And FunctionExecutable* generation ordering must be the same for every CodeBlock generation
358         from the same UnlinkedCodeBlock.
359
360         * bytecode/CodeBlock.h:
361         (JSC::ScriptExecutable::prepareForExecution):
362         * interpreter/Interpreter.cpp:
363         (JSC::Interpreter::executeProgram):
364         (JSC::Interpreter::executeCall):
365         (JSC::Interpreter::executeConstruct):
366         (JSC::Interpreter::execute):
367         (JSC::Interpreter::executeModuleProgram):
368         * interpreter/InterpreterInlines.h:
369         (JSC::Interpreter::execute):
370         * runtime/DisallowScope.h:
371         (JSC::DisallowScope::disable):
372         * runtime/StringPrototype.cpp:
373
374 2020-03-12  Yusuke Suzuki  <ysuzuki@apple.com>
375
376         [JSC] Delete IC creation should check mayNeedToCheckCell/canCacheDeleteIC regardless of Structure::outOfLineCapacity
377         https://bugs.webkit.org/show_bug.cgi?id=209027
378
379         Reviewed by Saam Barati.
380
381         Delete IC code generation assumes that mayNeedToCheckCell (it is replaced with canCacheDeleteIC) is false
382         while we are looking into this status only if Structure::outOfLineCapacity meets a certain condition. We should avoid
383         create Delete IC when mayNeedToCheckCell/canCacheDeleteIC is true regardless of Structure::outOfLineCapacity
384
385         * bytecode/AccessCase.cpp:
386         (JSC::AccessCase::createDelete):
387         (JSC::AccessCase::generateImpl):
388         * runtime/Structure.h:
389         * runtime/StructureInlines.h:
390         (JSC::Structure::mayHaveIndexingHeader const):
391         (JSC::Structure::canCacheDeleteIC const):
392
393 2020-03-13  Alexey Shvayka  <shvaikalesh@gmail.com>
394
395         Bound functions should pass correct NewTarget value
396         https://bugs.webkit.org/show_bug.cgi?id=209057
397
398         Reviewed by Keith Miller.
399
400         This change implements steps 5-6 of bound function's [[Construct]] method [1],
401         fixing bound function subclasses and aligning JSC with V8 and SpiderMonkey.
402
403         [1]: https://tc39.es/ecma262/#sec-bound-function-exotic-objects-construct-argumentslist-newtarget
404
405         * runtime/JSBoundFunction.cpp:
406         (JSC::boundThisNoArgsFunctionConstruct):
407         (JSC::boundFunctionConstruct):
408
409 2020-03-13  Yusuke Suzuki  <ysuzuki@apple.com>
410
411         Unreviewed, change ASSERT to ASSERT_WITH_SECURITY_IMPLICATION since it is now enabled under ENABLE(SECURITY_ASSERTIONS)
412         https://bugs.webkit.org/show_bug.cgi?id=209041
413         <rdar://problem/59705631>
414
415         * runtime/JSCast.h:
416         (JSC::jsCast):
417
418 2020-03-12  Yusuke Suzuki  <ysuzuki@apple.com>
419
420         Report crashed cell in jsCast in debug builds
421         https://bugs.webkit.org/show_bug.cgi?id=209041
422         <rdar://problem/59705631>
423
424         Reviewed by Mark Lam.
425
426         To collect more information when crashing with jsCast, we attempt to use reportZappedCellAndCrash.
427         If it succeeds, we can get more information in registers. We enable this only for ASSERT_ENABLED
428         build. For non ASSERT_ENABLED, we keep the original assertion since this assertion can be enabled
429         via ENABLE(SECURITY_ASSERTIONS).
430
431         * heap/SlotVisitor.cpp:
432         (JSC::SlotVisitor::appendToMarkStack):
433         (JSC::SlotVisitor::visitChildren):
434         (JSC::SlotVisitor::reportZappedCellAndCrash): Deleted.
435         * heap/SlotVisitor.h:
436         * runtime/JSCast.h:
437         (JSC::jsCast):
438         * runtime/JSCell.cpp:
439         (JSC::reportZappedCellAndCrash):
440         * runtime/JSCell.h:
441
442 2020-03-12  Keith Miller  <keith_miller@apple.com>
443
444         DFG nodes that take a TypedArray's storage need to keepAlive the TypedArray
445         https://bugs.webkit.org/show_bug.cgi?id=209035
446
447         Reviewed by Saam Barati.
448
449         It might be possible to produce a graph where the last reference to a TypedArray
450         is via a GetByVal or PutByVal. Since those nodes don't create any reference to the
451         TypedArray in B3 we may end up not keeping the TypedArray alive until after the
452         storage access.
453
454         * ftl/FTLLowerDFGToB3.cpp:
455         (JSC::FTL::DFG::LowerDFGToB3::compileAtomicsReadModifyWrite):
456         (JSC::FTL::DFG::LowerDFGToB3::compileGetByVal):
457         (JSC::FTL::DFG::LowerDFGToB3::compilePutByVal):
458
459 2020-03-12  Yusuke Suzuki  <ysuzuki@apple.com>
460
461         [JSC] Use CacheableIdentifier in ByValInfo
462         https://bugs.webkit.org/show_bug.cgi?id=208978
463
464         Reviewed by Saam Barati.
465
466         CodeBlock::finalizeUnconditionally discards JITData. And this includes ByValInfo, which holds Identifier.
467         However, finalizeUnconditionally is only guaranteeing that the main thread is not working. It can be invoked
468         in the heap thread, and it is not not setting the AtomStringTable for this heap thread. If Identifier destroys
469         AtomStringImpl, which fails to unregister itself from the table.
470
471         In this patch,
472
473             1. We explicitly set nullptr for the current AtomStringTable to catch the bug as soon as possible in GC end phase.
474             2. We use CacheableIdentifier in ByValInfo to avoid destroying Identifier in CodeBlock::finalizeUnconditionally.
475
476         * CMakeLists.txt:
477         * JavaScriptCore.xcodeproj/project.pbxproj:
478         * Sources.txt:
479         * bytecode/ByValInfo.cpp: Added.
480         (JSC::ByValInfo::visitAggregate):
481         * bytecode/ByValInfo.h:
482         * bytecode/CodeBlock.cpp:
483         (JSC::CodeBlock::stronglyVisitStrongReferences):
484         * bytecode/CodeBlock.h:
485         * dfg/DFGByteCodeParser.cpp:
486         (JSC::DFG::ByteCodeParser::handlePutByVal):
487         * heap/Heap.cpp:
488         (JSC::Heap::runEndPhase):
489         * jit/JIT.h:
490         * jit/JITOperations.cpp:
491         * jit/JITPropertyAccess.cpp:
492         (JSC::JIT::emitByValIdentifierCheck):
493         * runtime/CacheableIdentifier.h:
494
495 2020-03-11  Keith Miller  <keith_miller@apple.com>
496
497         Test262-runner should always consider crashes as new failures
498         https://bugs.webkit.org/show_bug.cgi?id=208943
499
500         Reviewed by Yusuke Suzuki.
501
502         BigInt.asUintN() / BigInt.asIntN() should not crash when called even if we have
503         not implemented them yet...
504
505         * runtime/BigIntConstructor.cpp:
506         (JSC::bigIntConstructorFuncAsUintN):
507         (JSC::bigIntConstructorFuncAsIntN):
508
509 2020-03-11  Keith Miller  <keith_miller@apple.com>
510
511         Throws incorrectly a syntax error when declaring a top level catch variable the same as a parameter
512         https://bugs.webkit.org/show_bug.cgi?id=189914
513
514         Reviewed by Saam Barati.
515
516         When we are parsing catch block parameters we should increment the statement depth so we don't think
517         we are trying to shadow top level lexical variables in the same statement depth.
518
519         * parser/Parser.cpp:
520         (JSC::Parser<LexerType>::parseTryStatement):
521
522 2020-03-10  Yusuke Suzuki  <ysuzuki@apple.com>
523
524         [JSC] Fix iso-subspace static_assert for JSJavaScriptCallFramePrototype
525         https://bugs.webkit.org/show_bug.cgi?id=208874
526
527         Reviewed by Saam Barati.
528
529         This static_assert should ensure the condition for JSJavaScriptCallFramePrototype, not for JSInjectedScriptHostPrototype.
530
531         * inspector/JSJavaScriptCallFramePrototype.h:
532
533 2020-03-09  Don Olmstead  <don.olmstead@sony.com>
534
535         Remove obsolete feature flags
536         https://bugs.webkit.org/show_bug.cgi?id=208830
537
538         Reviewed by Alex Christensen.
539
540         Remove ENABLE_CUSTOM_SCHEME_HANDLER and ENABLE_MAC_VIDEO_TOOLBOX since they
541         are no longer used.
542
543         * Configurations/FeatureDefines.xcconfig:
544
545 2020-03-09  Alexey Shvayka  <shvaikalesh@gmail.com>
546
547         @putByValDirect does not perform [[DefineOwnProperty]] correctly
548         https://bugs.webkit.org/show_bug.cgi?id=208708
549
550         Reviewed by Yusuke Suzuki.
551
552         This change adds inSparseIndexingMode() check to canDoFastPutDirectIndex(), fixing slow path
553         of @putByValDirect() to perform [[DefineOwnProperty]] according to spec [1] and aligning JSC
554         with V8 and SpiderMonkey.
555
556         This patch preserves existing behavior for Arguments exotic objects (thus the checks order)
557         and aligns slow path checks in JSObject::putDirectIndexSlowOrBeyondVectorLength
558         with JSObject::defineOwnIndexedProperty.
559
560         JetStream2 benchmark is neutral.
561
562         [1]: https://tc39.es/ecma262/#sec-validateandapplypropertydescriptor
563
564         * runtime/JSObject.cpp:
565         (JSC::canDoFastPutDirectIndex):
566
567 2020-03-09  Antoine Quint  <graouts@apple.com>
568
569         Remove the compile-time flag for Pointer Events
570         https://bugs.webkit.org/show_bug.cgi?id=208821
571         <rdar://problem/60223471>
572
573         Reviewed by Dean Jackson.
574
575         * Configurations/FeatureDefines.xcconfig:
576
577 2020-03-09  Caio Lima  <ticaiolima@gmail.com>
578
579         Tail calls are broken on ARM_THUMB2 and MIPS
580         https://bugs.webkit.org/show_bug.cgi?id=197797
581
582         Reviewed by Yusuke Suzuki.
583
584         `prepareForTailCall` operation expects that header size + parameters
585         size is aligned with stack (alignment is 16-bytes for every architecture).
586         This means that headerSizeInBytes + argumentsIncludingThisInBytes needs
587         to be multiple of 16. This was not being preserved during getter IC code
588         for 32-bits. The code generated was taking in account only
589         headerSizeInRegisters (it is 4 on 32-bits) and argumentsIncludingThis
590         (that is always 1 for getters) and allocating 32-bytes when applying
591         operation `(headerSize + argumentsIncludingThis) * 8 - sizeof(CallerFrameAndPC)`.
592         This results in a stack frame with size of 40 bytes (after we push
593         `lr` and `sp`). Since `prepareForTailCall` expects frames to be
594         16-bytes aligned, it will then calculate the top of such frame
595         considering it is 48 bytes, cloberring values of previous frame and
596         causing unexpected behavior. This patch is fixing how this IC code
597         calculates the stack frame using `roundArgumentCountToAlignFrame(numberOfParameters)`
598         aligning with what we do on code without IC installed.
599         This was not a problem for getter and setter IC on 64-bits because
600         `roundArgumentCountToAlignFrame(1) == 1` and `roundArgumentCountToAlignFrame(2) == 3`
601         while it is `roundArgumentCountToAlignFrame(1) == 2` and
602         `roundArgumentCountToAlignFrame(2) == 2` for MIPS and ARMv7.
603
604         * bytecode/AccessCase.cpp:
605         (JSC::AccessCase::generateImpl):
606
607 2020-03-08  Brady Eidson  <beidson@apple.com>
608
609         Remember completed subranges during incremental PDF loading.
610         https://bugs.webkit.org/show_bug.cgi?id=208785
611
612         Reviewed by Tim Horton.
613
614         Move 'using WTF::Range' from the WTF/Range.h header to these JSC users.
615         
616         The alternative to making these 3 changes was to make over 20 changes up in the WebCore/WebKits
617         to resolve the conflict with WebCore::Range.
618         
619         * b3/B3HeapRange.h:
620         * b3/air/AirAllocateRegistersAndStackByLinearScan.cpp:
621         * heap/JITStubRoutineSet.h:
622
623 2020-03-07  Alexey Shvayka  <shvaikalesh@gmail.com>
624
625         REGRESSION (r258049): Unchecked JS exception in jsc::Stringifier::toJSON
626         https://bugs.webkit.org/show_bug.cgi?id=208766
627
628         Reviewed by Yusuke Suzuki.
629
630         * runtime/JSONObject.cpp:
631         (JSC::Stringifier::toJSON): Add missing RELEASE_AND_RETURN.
632
633 2020-03-07  Mark Lam  <mark.lam@apple.com>
634
635         Remove bad assertion in FTLLowerDFGToB3's compileDelBy().
636         https://bugs.webkit.org/show_bug.cgi?id=208764
637         <rdar://problem/59940095>
638
639         Reviewed by Keith Miller.
640
641         The assertion ASSERT(base.gpr() != params[2].gpr()) is wrong because it is legal
642         JS to pass in the same value as the base and subscript.  The runtime will handle
643         it properly.
644
645         * ftl/FTLLowerDFGToB3.cpp:
646         (JSC::FTL::DFG::LowerDFGToB3::compileDelBy):
647
648 2020-03-05  Sam Weinig  <weinig@apple.com>
649
650         Move JavaScriptCore related feature defines from FeatureDefines.xcconfig to PlatformEnableCocoa.h
651         https://bugs.webkit.org/show_bug.cgi?id=207436
652         <rdar://problem/59296762>
653
654         Reviewed by Darin Adler.
655
656         * Configurations/FeatureDefines.xcconfig:
657         Remove JSC related defines.
658
659 2020-03-06  Yusuke Suzuki  <ysuzuki@apple.com>
660
661         [JSC] Enable public class fields
662         https://bugs.webkit.org/show_bug.cgi?id=208756
663
664         Reviewed by Mark Lam.
665
666         This patch turns public-class-fields feature on, implemented in r254653.
667         To separate from private-class-fields, this patch renames the flag from useClassFields to usePublicClassFields,
668         and first enable public-class-fields feature.
669
670         * bytecompiler/BytecodeGenerator.cpp:
671         (JSC::BytecodeGenerator::BytecodeGenerator):
672         * bytecompiler/NodesCodegen.cpp:
673         (JSC::FunctionCallValueNode::emitBytecode):
674         * parser/Parser.cpp:
675         (JSC::Parser<LexerType>::parseClass):
676         * runtime/OptionsList.h:
677
678 2020-03-06  Mark Lam  <mark.lam@apple.com>
679
680         Add "AndOrdered" to the names of ordered DoubleConditions.
681         https://bugs.webkit.org/show_bug.cgi?id=208736
682
683         Reviewed by Keith Miller.
684
685         Renamed the following:
686             DoubleEqual ==> DoubleEqualAndOrdered
687             DoubleNotEqual ==> DoubleNotEqualAndOrdered
688             DoubleGreaterThan ==> DoubleGreaterThanAndOrdered
689             DoubleGreaterThanOrEqual ==> DoubleGreaterThanOrEqualAndOrdered
690             DoubleLessThan ==> DoubleLessThanAndOrdered
691             DoubleLessThanOrEqual ==> DoubleLessThanOrEqualAndOrdered
692
693         The comment for these enums in MacroAssemblerARM64.h says:
694             // These conditions will only evaluate to true if the comparison is ordered - i.e. neither operand is NaN.
695
696         Adding "AndOrdered" to their names makes this property explicit.
697
698         From reading the original names, one might intuitively think that these conditions
699         map directly to the C++ double comparisons.  This intuition is incorrect.
700         Consider the DoubleNotEqual case: let's compare 2 doubles, a and b:
701
702             result = (a != b);
703
704         For C++, if either a or b are NaNs, then a != b will actually return true.
705         This is contrary to the behavior documented in the MacroAssemblerARM64.h comment
706         above about how DoubleNotEqual should behave.  In our code, DoubleNotEqual actually
707         means DoubleNotEqualAndOrdered.  The C++ != behavior actually matches our
708         DoubleNotEqualOrUnordered condition instead.
709
710         The tendency to want to associate DoubleNotEqual with the behavior of the C++
711         != operator is precisely why we should give these conditions better names.
712         Adding the "AndOperand" name make the expected behavior explicit in the name, and
713         leave no room for confusion with C++ double comparison semantics.
714
715         * assembler/MacroAssembler.cpp:
716         (WTF::printInternal):
717         * assembler/MacroAssembler.h:
718         (JSC::MacroAssembler::invert):
719         * assembler/MacroAssemblerARM64.h:
720         (JSC::MacroAssemblerARM64::moveConditionallyAfterFloatingPointCompare):
721         (JSC::MacroAssemblerARM64::moveDoubleConditionallyAfterFloatingPointCompare):
722         (JSC::MacroAssemblerARM64::jumpAfterFloatingPointCompare):
723         (JSC::MacroAssemblerARM64::floatingPointCompare):
724         * assembler/MacroAssemblerARMv7.h:
725         (JSC::MacroAssemblerARMv7::branchDouble):
726         * assembler/MacroAssemblerMIPS.h:
727         (JSC::MacroAssemblerMIPS::branchDouble):
728         (JSC::MacroAssemblerMIPS::branchDoubleNonZero):
729         * assembler/MacroAssemblerX86Common.h:
730         (JSC::MacroAssemblerX86Common::branchDoubleNonZero):
731         (JSC::MacroAssemblerX86Common::moveConditionallyDouble):
732         (JSC::MacroAssemblerX86Common::invert):
733         (JSC::MacroAssemblerX86Common::floatingPointCompare):
734         (JSC::MacroAssemblerX86Common::jumpAfterFloatingPointCompare):
735         (JSC::MacroAssemblerX86Common::moveConditionallyAfterFloatingPointCompare):
736         * assembler/MacroAssemblerX86_64.h:
737         (JSC::MacroAssemblerX86_64::truncateDoubleToUint64):
738         (JSC::MacroAssemblerX86_64::truncateFloatToUint64):
739         * assembler/testmasm.cpp:
740         (JSC::testCompareDouble):
741         (JSC::testCompareDoubleSameArg):
742         (JSC::testMoveConditionallyFloatingPoint):
743         (JSC::testMoveDoubleConditionallyDouble):
744         (JSC::testMoveDoubleConditionallyDoubleDestSameAsThenCase):
745         (JSC::testMoveDoubleConditionallyDoubleDestSameAsElseCase):
746         (JSC::testMoveDoubleConditionallyFloat):
747         (JSC::testMoveDoubleConditionallyFloatDestSameAsThenCase):
748         (JSC::testMoveDoubleConditionallyFloatDestSameAsElseCase):
749         (JSC::testMoveConditionallyFloatingPointSameArg):
750         (JSC::run):
751         * b3/B3LowerToAir.cpp:
752         * dfg/DFGSpeculativeJIT.cpp:
753         (JSC::DFG::compileClampDoubleToByte):
754         (JSC::DFG::SpeculativeJIT::compileArithRounding):
755         (JSC::DFG::SpeculativeJIT::compileArithMinMax):
756         (JSC::DFG::SpeculativeJIT::compileArithPow):
757         (JSC::DFG::SpeculativeJIT::compileStrictEq):
758         (JSC::DFG::SpeculativeJIT::compileArrayIndexOf):
759         (JSC::DFG::SpeculativeJIT::compileNormalizeMapKey):
760         * dfg/DFGSpeculativeJIT32_64.cpp:
761         (JSC::DFG::SpeculativeJIT::compile):
762         * dfg/DFGSpeculativeJIT64.cpp:
763         (JSC::DFG::SpeculativeJIT::compile):
764         * ftl/FTLLowerDFGToB3.cpp:
765         (JSC::FTL::DFG::LowerDFGToB3::compileNumberIsInteger):
766         * jit/AssemblyHelpers.h:
767         (JSC::AssemblyHelpers::branchIfNotNaN):
768         * jit/JITArithmetic.cpp:
769         (JSC::JIT::emitSlow_op_jless):
770         (JSC::JIT::emitSlow_op_jlesseq):
771         (JSC::JIT::emitSlow_op_jgreater):
772         (JSC::JIT::emitSlow_op_jgreatereq):
773         * jit/JITArithmetic32_64.cpp:
774         (JSC::JIT::emitBinaryDoubleOp):
775         * jit/ThunkGenerators.cpp:
776         (JSC::floorThunkGenerator):
777         (JSC::roundThunkGenerator):
778         * wasm/WasmAirIRGenerator.cpp:
779         (JSC::Wasm::AirIRGenerator::addOp<OpType::F64Le>):
780         (JSC::Wasm::AirIRGenerator::addOp<OpType::F64Lt>):
781         (JSC::Wasm::AirIRGenerator::addFloatingPointMinOrMax):
782         (JSC::Wasm::AirIRGenerator::addOp<OpType::F64Gt>):
783         (JSC::Wasm::AirIRGenerator::addOp<OpType::F64Ge>):
784         (JSC::Wasm::AirIRGenerator::addOp<OpType::F32Lt>):
785         (JSC::Wasm::AirIRGenerator::addOp<OpType::F64Eq>):
786         (JSC::Wasm::AirIRGenerator::addOp<OpType::F32Le>):
787         (JSC::Wasm::AirIRGenerator::addOp<OpType::F32Ge>):
788         (JSC::Wasm::AirIRGenerator::addOp<OpType::F32Eq>):
789         (JSC::Wasm::AirIRGenerator::addOp<OpType::F32Gt>):
790
791 2020-03-06  David Kilzer  <ddkilzer@apple.com>
792
793         REGRESSION (r258038): Build failure on Windows 10 bots
794         <https://bugs.webkit.org/show_bug.cgi?id=208731>
795         <rdar://problem/59222568>
796
797         * assembler/testmasm.cpp:
798         (JSC::testCompareDouble):
799         (JSC::testCompareDoubleSameArg):
800         (JSC::testMoveConditionallyFloatingPoint):
801         (JSC::testMoveConditionallyFloatingPointSameArg):
802         - Add RELEASE_ASSERT_NOT_REACHED() statements to try to fix the
803           bots.
804
805 2020-03-06  Yusuke Suzuki  <ysuzuki@apple.com>
806
807         Put remaining fixed-sized cells into IsoSubspace
808         https://bugs.webkit.org/show_bug.cgi?id=208754
809
810         Reviewed by Keith Miller.
811
812         Put remaining fixed-sized cells into IsoSubspace. Now all the fixed-sized cells have their own IsoSubspaces.
813
814         1. JSArray (We need to care about RAMification number, or compensate RAMification regression with improvements).
815         2. Inspector's objects
816         3. All prototype objects have one IsoSubspace since they are plain objects.
817
818         * inspector/JSInjectedScriptHost.cpp:
819         (Inspector::JSInjectedScriptHost::JSInjectedScriptHost):
820         * inspector/JSInjectedScriptHost.h:
821         * inspector/JSInjectedScriptHostPrototype.h:
822         * inspector/JSJavaScriptCallFrame.cpp:
823         (Inspector::JSJavaScriptCallFrame::JSJavaScriptCallFrame):
824         * inspector/JSJavaScriptCallFrame.h:
825         * inspector/JSJavaScriptCallFramePrototype.h:
826         * jsc.cpp:
827         (JSC::Masquerader::subspaceFor):
828         (JSCMemoryFootprint::subspaceFor):
829         * runtime/ArrayIteratorPrototype.h:
830         * runtime/ArrayPrototype.h:
831         * runtime/AsyncFromSyncIteratorPrototype.h:
832         * runtime/AsyncFunctionPrototype.h:
833         * runtime/AsyncGeneratorFunctionPrototype.h:
834         * runtime/AsyncGeneratorPrototype.h:
835         * runtime/AsyncIteratorPrototype.h:
836         * runtime/AtomicsObject.h:
837         * runtime/BigIntPrototype.h:
838         * runtime/ConsoleObject.h:
839         * runtime/DatePrototype.h:
840         * runtime/ErrorPrototype.h:
841         * runtime/ExceptionHelpers.h:
842         * runtime/GeneratorFunctionPrototype.h:
843         * runtime/GeneratorPrototype.h:
844         * runtime/InspectorInstrumentationObject.h:
845         * runtime/IntlCollatorPrototype.h:
846         * runtime/IntlDateTimeFormatPrototype.h:
847         * runtime/IntlNumberFormatPrototype.h:
848         * runtime/IntlObject.h:
849         * runtime/IntlPluralRulesPrototype.h:
850         * runtime/IteratorPrototype.h:
851         * runtime/JSArray.h:
852         (JSC::JSArray::subspaceFor):
853         * runtime/JSArrayBufferPrototype.h:
854         * runtime/JSDataViewPrototype.h:
855         * runtime/JSDestructibleObject.h:
856         (JSC::JSDestructibleObject::subspaceFor): Deleted.
857         * runtime/JSGenericTypedArrayViewPrototype.h:
858         * runtime/JSModuleLoader.h:
859         * runtime/JSONObject.h:
860         * runtime/JSObject.h:
861         * runtime/JSObjectInlines.h:
862         (JSC::JSFinalObject::subspaceFor):
863         (JSC::JSObject::subspaceFor): Deleted.
864         * runtime/JSPromisePrototype.h:
865         (JSC::JSPromisePrototype::subspaceFor):
866         * runtime/JSTypedArrayViewPrototype.h:
867         * runtime/MapIteratorPrototype.h:
868         * runtime/MapPrototype.h:
869         * runtime/MathObject.h:
870         * runtime/NativeErrorPrototype.h:
871         * runtime/ObjectPrototype.h:
872         * runtime/ReflectObject.h:
873         * runtime/RegExpPrototype.h:
874         * runtime/RegExpStringIteratorPrototype.h:
875         * runtime/SetIteratorPrototype.h:
876         * runtime/SetPrototype.h:
877         * runtime/StringIteratorPrototype.h:
878         * runtime/SymbolPrototype.h:
879         * runtime/VM.cpp:
880         (JSC::VM::VM):
881         * runtime/VM.h:
882         * runtime/WeakMapPrototype.h:
883         * runtime/WeakObjectRefPrototype.h:
884         * runtime/WeakSetPrototype.h:
885         * tools/JSDollarVM.cpp:
886         * tools/JSDollarVM.h:
887         * wasm/js/JSWebAssembly.h:
888         * wasm/js/WebAssemblyCompileErrorPrototype.h:
889         * wasm/js/WebAssemblyGlobalPrototype.h:
890         * wasm/js/WebAssemblyInstancePrototype.h:
891         * wasm/js/WebAssemblyLinkErrorPrototype.h:
892         * wasm/js/WebAssemblyMemoryPrototype.h:
893         * wasm/js/WebAssemblyModulePrototype.h:
894         * wasm/js/WebAssemblyRuntimeErrorPrototype.h:
895         * wasm/js/WebAssemblyTablePrototype.h:
896
897 2020-03-06  Alexey Shvayka  <shvaikalesh@gmail.com>
898
899         JSON.stringify should call replacer on deleted properties
900         https://bugs.webkit.org/show_bug.cgi?id=208725
901
902         Reviewed by Ross Kirsling.
903
904         This change removes extra `hasProperty` check from `appendNextProperty` as
905         it does not exist in the spec [1], aligning JSC with V8 and SpiderMonkey.
906
907         This patch also replaces 3 usages of `getPropertySlot` with semantically
908         equivalent (yet more concise) `get` and inlines `toJSONImpl` (this change
909         is performance-neutral).
910
911         [1]: https://tc39.es/ecma262/#sec-serializejsonobject (steps 6, 8.a)
912
913         * runtime/JSONObject.cpp:
914         (JSC::Stringifier::toJSON):
915         (JSC::Stringifier::Holder::appendNextProperty):
916         (JSC::Stringifier::toJSONImpl): Deleted.
917
918 2020-03-06  Mark Lam  <mark.lam@apple.com>
919
920         Fix some issues in the ARM64 moveConditionallyAfterFloatingPointCompare() and moveDoubleConditionallyAfterFloatingPointCompare().
921         https://bugs.webkit.org/show_bug.cgi?id=208731
922         <rdar://problem/59222568>
923
924         Reviewed by Saam Barati.
925
926         Both the ARM64 moveConditionallyAfterFloatingPointCompare() and
927         moveDoubleConditionallyAfterFloatingPointCompare() had the following issues:
928
929         1. For the DoubleNotEqual condition, they fail to set the result register if
930            one or both of the comparison operands is a NaN.
931
932         2. For the DoubleEqualOrUnordered condition, they can clobber the else case
933            input register if one of the comparison operands is a NaN.
934
935         This patch fixes both of these, and exhaustive testmasm test cases for affected
936         MacroAssembler instruction emitters using these functions.
937
938         * assembler/MacroAssemblerARM64.h:
939         (JSC::MacroAssemblerARM64::moveConditionallyAfterFloatingPointCompare):
940         (JSC::MacroAssemblerARM64::moveDoubleConditionallyAfterFloatingPointCompare):
941         * assembler/testmasm.cpp:
942         (JSC::testCompareDouble):
943         (JSC::testCompareDoubleSameArg):
944         (JSC::testMoveConditionallyFloatingPoint):
945         (JSC::testMoveConditionallyDouble2):
946         (JSC::testMoveConditionallyDouble3):
947         (JSC::testMoveConditionallyDouble3DestSameAsThenCase):
948         (JSC::testMoveConditionallyDouble3DestSameAsElseCase):
949         (JSC::testMoveConditionallyFloat2):
950         (JSC::testMoveConditionallyFloat3):
951         (JSC::testMoveConditionallyFloat3DestSameAsThenCase):
952         (JSC::testMoveConditionallyFloat3DestSameAsElseCase):
953         (JSC::testMoveDoubleConditionallyDouble):
954         (JSC::testMoveDoubleConditionallyDoubleDestSameAsThenCase):
955         (JSC::testMoveDoubleConditionallyDoubleDestSameAsElseCase):
956         (JSC::testMoveDoubleConditionallyFloat):
957         (JSC::testMoveDoubleConditionallyFloatDestSameAsThenCase):
958         (JSC::testMoveDoubleConditionallyFloatDestSameAsElseCase):
959         (JSC::testMoveConditionallyFloatingPointSameArg):
960         (JSC::testMoveConditionallyDouble2SameArg):
961         (JSC::testMoveConditionallyDouble3SameArg):
962         (JSC::testMoveConditionallyFloat2SameArg):
963         (JSC::testMoveConditionallyFloat3SameArg):
964         (JSC::testMoveDoubleConditionallyDoubleSameArg):
965         (JSC::testMoveDoubleConditionallyFloatSameArg):
966         (JSC::run):
967
968 2020-03-05  Paulo Matos  <pmatos@igalia.com>
969
970         [JSCOnly] 32-bits warning on memset of JSValue
971         https://bugs.webkit.org/show_bug.cgi?id=204411
972
973         Reviewed by Mark Lam.
974
975         Fixes warning on 32bit builds. This is required because GCC knows
976         it is not safe to use memset on non-POD types and warns against its use.
977
978         * heap/GCMemoryOperations.h:
979         (JSC::gcSafeZeroMemory):
980
981 2020-03-04  Mark Lam  <mark.lam@apple.com>
982
983         Handle an out of memory error while constructing the BytecodeGenerator.
984         https://bugs.webkit.org/show_bug.cgi?id=208622
985         <rdar://problem/59341136>
986
987         Reviewed by Saam Barati.
988
989         Added the ability to handle out of memory errors encountered during the
990         construction of the BytecodeGenerator.  Currently, we only use this for the
991         case where we fail to instantiate a ScopedArgumentsTable.
992
993         * bytecompiler/BytecodeGenerator.cpp:
994         (JSC::BytecodeGenerator::generate):
995         (JSC::BytecodeGenerator::BytecodeGenerator):
996         * bytecompiler/BytecodeGeneratorBase.h:
997         * runtime/ScopedArgumentsTable.cpp:
998         (JSC::ScopedArgumentsTable::tryCreate):
999         * runtime/ScopedArgumentsTable.h:
1000         * runtime/SymbolTable.h:
1001
1002 2020-03-04  Paulo Matos  <pmatos@igalia.com>
1003
1004         JSC 32bits broken in debug mode by r257399
1005         https://bugs.webkit.org/show_bug.cgi?id=208439
1006
1007         Reviewed by Carlos Alberto Lopez Perez.
1008
1009         Use uses() method call instead of gpr() on assert to that it
1010         works for both 64 and 32 bits.
1011
1012         * bytecode/AccessCase.cpp:
1013         (JSC::AccessCase::generateImpl):
1014
1015 2020-03-03  Saam Barati  <sbarati@apple.com>
1016
1017         Refactor FixedVMPoolExecutableAllocator to not have member functions which are really just helper functions
1018         https://bugs.webkit.org/show_bug.cgi?id=208537
1019
1020         Reviewed by Mark Lam.
1021
1022         There were a few member functions in FixedVMPoolExecutableAllocator that were
1023         essentially helper functions. I've factored them out, and made FixedVMPoolExecutableAllocator
1024         call them directly. This refactoring is needed when I implement the 1GB
1025         executable pool on arm64 since the implementation of that will create split
1026         implementations of something like FixedVMPoolExecutableAllocator.
1027
1028         * jit/ExecutableAllocator.cpp:
1029         (JSC::jitWriteThunkGenerator):
1030         (JSC::genericWriteToJITRegion):
1031         (JSC::initializeSeparatedWXHeaps):
1032         (JSC::initializeJITPageReservation):
1033         (JSC::ExecutableAllocator::isValid const):
1034         (JSC::ExecutableAllocator::underMemoryPressure):
1035         (JSC::ExecutableAllocator::memoryPressureMultiplier):
1036         (JSC::ExecutableAllocator::allocate):
1037         (JSC::ExecutableAllocator::isValidExecutableMemory):
1038         (JSC::ExecutableAllocator::getLock const):
1039         (JSC::ExecutableAllocator::committedByteCount):
1040         (JSC::ExecutableAllocator::dumpProfile):
1041         (JSC::startOfFixedExecutableMemoryPoolImpl):
1042         (JSC::endOfFixedExecutableMemoryPoolImpl):
1043         (JSC::isJITPC):
1044
1045 2020-03-03  Ross Kirsling  <ross.kirsling@sony.com>
1046
1047         Introduce JSRemoteInspectorServerStart API for socket-based RWI.
1048         https://bugs.webkit.org/show_bug.cgi?id=208349
1049
1050         Reviewed by Joseph Pecoraro.
1051
1052         * API/JSRemoteInspectorServer.cpp: Added.
1053         (JSRemoteInspectorServerStart):
1054         * API/JSRemoteInspectorServer.h: Added.
1055         * CMakeLists.txt:
1056
1057 2020-03-03  Basuke Suzuki  <basuke.suzuki@sony.com>
1058
1059         [WinCairo][PlayStation] Add interface to get listening port of RemoteInspectorServer
1060         https://bugs.webkit.org/show_bug.cgi?id=208391
1061
1062         Reviewed by Don Olmstead.
1063
1064         When passing zero as a port argument, system will pick an available port for it.
1065         Without this method, client cannot get which port is listening.
1066
1067         * inspector/remote/socket/RemoteInspectorServer.cpp:
1068         (Inspector::RemoteInspectorServer::start):
1069         (Inspector::RemoteInspectorServer::getPort):
1070         * inspector/remote/socket/RemoteInspectorServer.h:
1071
1072 2020-03-03  Yusuke Suzuki  <ysuzuki@apple.com>
1073
1074         [JSC] @hasOwnLengthProperty returns wrong value if "length" is attempted to be modified
1075         https://bugs.webkit.org/show_bug.cgi?id=208497
1076         <rdar://problem/59913544>
1077
1078         Reviewed by Mark Lam.
1079
1080         When "length" of JSFunction is attempted to be modified, we put a flag. And @hasOwnLengthProperty
1081         does not correctly use this flag to return a value for the fast path. This affects on "length"
1082         property of bound functions. For example,
1083
1084             function userFunction(a) { }
1085             userFunction.length = 20; // This field is read-only. So, it is not changed.
1086             userFunction.bind().length; // Should be 1, but it returns 0.
1087
1088         1. We rename m_hasModifiedLength to m_hasModifiedLengthForNonHostFunction and m_hasModifiedName
1089            to m_hasModifiedNameForNonHostFunction since we are not tracking these states for host-functions
1090            which can eagerly initialize them.
1091         2. We rename areNameAndLengthOriginal to canAssumeNameAndLengthAreOriginal to allow it to return
1092            "false" for host functions. If it returns true, we go to the fast path.
1093         3. Correctly use canAssumeNameAndLengthAreOriginal information in @hasOwnLengthProperty.
1094
1095         * runtime/FunctionRareData.cpp:
1096         (JSC::FunctionRareData::FunctionRareData):
1097         * runtime/FunctionRareData.h:
1098         * runtime/JSFunction.cpp:
1099         (JSC::JSFunction::put):
1100         (JSC::JSFunction::deleteProperty):
1101         (JSC::JSFunction::defineOwnProperty):
1102         * runtime/JSFunction.h:
1103         * runtime/JSFunctionInlines.h:
1104         (JSC::JSFunction::canAssumeNameAndLengthAreOriginal):
1105         (JSC::JSFunction::areNameAndLengthOriginal): Deleted.
1106         * runtime/JSGlobalObject.cpp:
1107         (JSC::hasOwnLengthProperty):
1108         * tools/JSDollarVM.cpp:
1109         (JSC::functionHasOwnLengthProperty):
1110
1111 2020-03-02  Alan Coon  <alancoon@apple.com>
1112
1113         Add new Mac target numbers
1114         https://bugs.webkit.org/show_bug.cgi?id=208398
1115
1116         Reviewed by Alexey Proskuryakov.
1117
1118         * Configurations/Base.xcconfig:
1119         * Configurations/DebugRelease.xcconfig:
1120         * Configurations/Version.xcconfig:
1121         * Configurations/WebKitTargetConditionals.xcconfig:
1122
1123 2020-03-02  Justin Michaud  <justin_michaud@apple.com>
1124
1125         Delete by val caching does not keep the subscript alive
1126         https://bugs.webkit.org/show_bug.cgi?id=208393
1127
1128         Reviewed by Yusuke Suzuki.
1129
1130         Before, the provided test case crashed with asan because we did not keep deleteByVal
1131         subscripts alive. This patch changes CacheableIdentifier to make this mistake harder
1132         to make again, by making the constructor calls more explicit when CacheableIdentifier
1133         will not keep an Identifier alive.
1134
1135         * jit/JITOperations.cpp:
1136         * jit/Repatch.cpp:
1137         (JSC::tryCachePutByID):
1138         (JSC::tryCacheDeleteBy):
1139         (JSC::repatchDeleteBy):
1140         (JSC::tryCacheInByID):
1141         (JSC::tryCacheInstanceOf):
1142         (JSC::tryCacheDelBy): Deleted.
1143         (JSC::repatchDelBy): Deleted.
1144         * jit/Repatch.h:
1145         * runtime/CacheableIdentifier.h:
1146         * runtime/CacheableIdentifierInlines.h:
1147         (JSC::CacheableIdentifier::createFromIdentifierOwnedByCodeBlock):
1148         (JSC::CacheableIdentifier::createFromCell):
1149
1150 2020-03-02  Paulo Matos  <pmatos@igalia.com>
1151
1152         Fix JSC 32bit alignment increase gcc warning
1153         https://bugs.webkit.org/show_bug.cgi?id=208445
1154
1155         Reviewed by Yusuke Suzuki.
1156
1157         Use reinterpret_cast_ptr<>() instead of reinterpret_cast<>() to
1158         avoid GCC warning about increase in alignment requirement for cast
1159         target type.
1160
1161         * dfg/DFGOSRExit.cpp:
1162         (JSC::DFG::OSRExit::compileExit):
1163
1164 2020-03-02  Yusuke Suzuki  <ysuzuki@apple.com>
1165
1166         Unreviewed, fix wrong assertion
1167         https://bugs.webkit.org/show_bug.cgi?id=208404
1168         <rdar://problem/59956592>
1169
1170         * runtime/CachedTypes.cpp:
1171         (JSC::CachedUniquedStringImplBase::decode const):
1172
1173 2020-03-01  Charles Turner  <cturner@igalia.com>
1174
1175         undefined reference to `JSC::ExecutableBase::hasJITCodeForCall() const'
1176         https://bugs.webkit.org/show_bug.cgi?id=207890
1177
1178         Reviewed by Yusuke Suzuki.
1179
1180         Encountered on arm-buildroot-linux-gnueabihf with GCC 9.2.0.
1181
1182         * runtime/NativeExecutable.cpp: Inclusion of
1183         ExecutableBaseInlines.h resolves the issue for me.
1184
1185 2020-02-29  Yusuke Suzuki  <ysuzuki@apple.com>
1186
1187         Remove std::lock_guard
1188         https://bugs.webkit.org/show_bug.cgi?id=206451
1189
1190         Reviewed by Anders Carlsson.
1191
1192         * API/JSVirtualMachine.mm:
1193         (+[JSVMWrapperCache addWrapper:forJSContextGroupRef:]):
1194         (+[JSVMWrapperCache wrapperForJSContextGroupRef:]):
1195         * API/glib/JSCVirtualMachine.cpp:
1196         (addWrapper):
1197         (removeWrapper):
1198         * heap/HeapSnapshotBuilder.cpp:
1199         (JSC::HeapSnapshotBuilder::analyzeNode):
1200         (JSC::HeapSnapshotBuilder::analyzeEdge):
1201         (JSC::HeapSnapshotBuilder::analyzePropertyNameEdge):
1202         (JSC::HeapSnapshotBuilder::analyzeVariableNameEdge):
1203         (JSC::HeapSnapshotBuilder::analyzeIndexEdge):
1204         (JSC::HeapSnapshotBuilder::setOpaqueRootReachabilityReasonForCell):
1205         * heap/MachineStackMarker.cpp:
1206         (JSC::MachineThreads::tryCopyOtherThreadStacks):
1207         * runtime/JSRunLoopTimer.cpp:
1208         (JSC::JSRunLoopTimer::timerDidFire):
1209
1210 2020-02-28  Yusuke Suzuki  <ysuzuki@apple.com>
1211
1212         [JSC] BuiltinNames' HashMap should be small
1213         https://bugs.webkit.org/show_bug.cgi?id=208404
1214
1215         Reviewed by Mark Lam.
1216
1217         This patch converts public-to-private-name-map from HashMap<RefPtr<UniquedStringImpl>, SymbolImpl*> to HashSet<String> to save half of memory.
1218         The key is that private names have the same string content to the public names. We can just query with string content to the HashSet of
1219         private names, and we can get private names.
1220
1221         The problem is that we also have a hack inserting string <-> non-private well-known Symbol mappings into this table. These symbols do not have
1222         the same content to the public string. So the above assumption is broken.
1223
1224         To make the above assumption valid, we have a separate small HashMap which holds string <-> non-private well-known Symbol mappings. Since # of
1225         well-known Symbols are only 13, this new HashMap is taking at most 512B for entries, which is much smaller compared to the saved memory by
1226         converting HashMap to HashSet for private names (32KB).
1227
1228         To allow it, we introduce new well-known Symbol identifier syntax to builtin JS, which is "@@iterator" format. If there is two "@", we parse this
1229         identifier as a well-known Symbol.
1230
1231         * builtins/ArrayConstructor.js:
1232         (from.wrapper.iterator):
1233         (from):
1234         (from.wrapper.iteratorSymbol): Deleted.
1235         * builtins/ArrayPrototype.js:
1236         (globalPrivate.concatSlowPath):
1237         (concat):
1238         * builtins/BuiltinNames.cpp:
1239         (JSC::BuiltinNames::BuiltinNames):
1240         (JSC::CharBufferSeacher::hash):
1241         (JSC::CharBufferSeacher::equal):
1242         (JSC::lookUpPrivateNameImpl):
1243         (JSC::lookUpWellKnownSymbolImpl):
1244         (JSC::BuiltinNames::lookUpPrivateName const):
1245         (JSC::BuiltinNames::lookUpWellKnownSymbol const):
1246         * builtins/BuiltinNames.h:
1247         (JSC::BuiltinNames::lookUpPrivateName const):
1248         (JSC::BuiltinNames::lookUpWellKnownSymbol const):
1249         (JSC::BuiltinNames::checkPublicToPrivateMapConsistency):
1250         (JSC::BuiltinNames::appendExternalName):
1251         (JSC::BuiltinNames::getPublicName const): Deleted.
1252         * builtins/GlobalOperations.js:
1253         (globalPrivate.speciesConstructor):
1254         * builtins/IteratorHelpers.js:
1255         (performIteration):
1256         * builtins/StringPrototype.js:
1257         (match):
1258         (matchAll):
1259         (intrinsic.StringPrototypeReplaceIntrinsic.replace):
1260         (replaceAll):
1261         (search):
1262         (split):
1263         * builtins/TypedArrayConstructor.js:
1264         (from.wrapper.iterator):
1265         (from):
1266         (from.wrapper.iteratorSymbol): Deleted.
1267         * builtins/TypedArrayPrototype.js:
1268         (globalPrivate.typedArraySpeciesConstructor):
1269         (map):
1270         (filter):
1271         * bytecompiler/NodesCodegen.cpp:
1272         (JSC::BytecodeIntrinsicNode::emit_intrinsic_getByIdDirectPrivate):
1273         (JSC::BytecodeIntrinsicNode::emit_intrinsic_putByIdDirectPrivate):
1274         * parser/Lexer.cpp:
1275         (JSC::Lexer<LChar>::parseIdentifier):
1276         (JSC::Lexer<UChar>::parseIdentifier):
1277         * runtime/CachedTypes.cpp:
1278         (JSC::CachedUniquedStringImplBase::encode):
1279         (JSC::CachedUniquedStringImplBase::decode const):
1280         * runtime/CommonIdentifiers.cpp:
1281         (JSC::CommonIdentifiers::CommonIdentifiers):
1282         (JSC::CommonIdentifiers::lookUpPrivateName const): Deleted.
1283         (JSC::CommonIdentifiers::getPublicName const): Deleted.
1284         * runtime/CommonIdentifiers.h:
1285         * tools/JSDollarVM.cpp:
1286         (JSC::functionGetPrivateProperty):
1287
1288 2020-02-28  Saam Barati  <sbarati@apple.com>
1289
1290         Clean up code with how we choose Gigacage sizes and whether or not to use Wasm fast memory
1291         https://bugs.webkit.org/show_bug.cgi?id=208392
1292
1293         Reviewed by Yusuke Suzuki.
1294
1295         * runtime/OptionsList.h:
1296
1297 2020-02-27  Saam Barati  <sbarati@apple.com>
1298
1299         Fix debug arm64 Wasm tests
1300         https://bugs.webkit.org/show_bug.cgi?id=208362
1301
1302         Reviewed by Yusuke Suzuki.
1303
1304         * wasm/WasmAirIRGenerator.cpp:
1305         (JSC::Wasm::AirIRGenerator::emitChecksForModOrDiv):
1306
1307         We were assuming that "-1" is a valid imm on arm64, but it's not, we need
1308         to use big imm.
1309
1310 2020-02-27  Justin Michaud  <justin_michaud@apple.com>
1311
1312         Poly proto should work with property delete transitions
1313         https://bugs.webkit.org/show_bug.cgi?id=208261
1314
1315         Reviewed by Saam Barati.
1316
1317         This patch fixes a bug where the combination of inline caching
1318         and poly proto cause us to cache a setter call along a prototype chain that 
1319         is no longer the correct setter to call. This is exposed as a result of
1320         https://bugs.webkit.org/show_bug.cgi?id=206430 since DefineOwnProperty used 
1321         to transition to uncacheable dictionary.
1322
1323         The case looks like this:
1324         A - setter for x redefines x
1325         |
1326         B
1327         |
1328         C
1329
1330         We set (new C).x
1331
1332         Right now, we first call A's setter, then we try to figure out what the state of things
1333         were before it was called in order to cache it. We just assume that A's setter still exists, and we cache it
1334         without ever checking, In this patch, we ensure that the property exists and the attributes match in order to prevent crashing. 
1335
1336         In the code, A = target, C = base.
1337
1338         Get is correct because it collects caching information before any calls.
1339
1340         The bug https://bugs.webkit.org/show_bug.cgi?id=208337 tracks the remaining semantic bugs around this code.
1341
1342         * jit/Repatch.cpp:
1343         (JSC::tryCachePutByID):
1344
1345 2020-02-27  Basuke Suzuki  <basuke.suzuki@sony.com>
1346
1347         [WinCairo] Fix RemoteInspector reconnect issue
1348         https://bugs.webkit.org/show_bug.cgi?id=208256
1349
1350         Reviewed by Devin Rousso.
1351
1352         Call target's disconnection sequence asynchronously to avoid deadlock.
1353
1354         * inspector/remote/RemoteConnectionToTarget.cpp:
1355         (Inspector::RemoteConnectionToTarget::close):
1356         * inspector/remote/socket/RemoteInspectorSocketEndpoint.cpp:
1357         (Inspector::RemoteInspectorSocketEndpoint::workerThread):
1358
1359 2020-02-26  Mark Lam  <mark.lam@apple.com>
1360
1361         Enhance JSObjectGetProperty() to mitigate against null object pointers.
1362         https://bugs.webkit.org/show_bug.cgi?id=208275
1363         <rdar://problem/59826325>
1364
1365         Reviewed by Robin Morisset.
1366
1367         * API/JSObjectRef.cpp:
1368         (JSObjectGetProperty):
1369
1370 2020-02-26  Saam Barati  <sbarati@apple.com>
1371
1372         Make testair pass on arm64
1373         https://bugs.webkit.org/show_bug.cgi?id=208258
1374
1375         Reviewed by Tadeu Zagallo.
1376
1377         testElideMoveThenRealloc and testElideSimpleMove were never tested
1378         on arm64. This patch makes those tests work. 
1379         - testElideMoveThenRealloc was using a BitImm that is invalid on arm64
1380         - testElideSimpleMove was testing for the wrong disassembly
1381
1382         * b3/air/testair.cpp:
1383
1384 2020-02-26  Don Olmstead  <don.olmstead@sony.com>
1385
1386         Allow setting of stack sizes for threads
1387         https://bugs.webkit.org/show_bug.cgi?id=208223
1388
1389         Reviewed by Yusuke Suzuki.
1390
1391         Specify ThreadType at the Thread::create callsite.
1392
1393         * heap/Heap.cpp:
1394         (JSC::Heap::notifyIsSafeToCollect):
1395
1396 2020-02-26  Caio Lima  <ticaiolima@gmail.com>
1397
1398         [JSC][MIPS] Adding support to Checkpoints
1399         https://bugs.webkit.org/show_bug.cgi?id=208196
1400
1401         Reviewed by Yusuke Suzuki.
1402
1403         This patch is adding changes to properly support OSR to
1404         checkpoints on MIPS. It required fixes on JIT probe and some
1405         adjustment on Offlineasm to correct generate `$gp` load when executing 
1406         `checkpoint_osr_exit_from_inlined_call_trampoline`.
1407
1408         * assembler/MacroAssemblerMIPS.cpp:
1409
1410         Probe trampoline needs to allocate 16 bytes for 4 arguments to
1411         properly follow C calling conventions. This space is used by callee
1412         when the JSC is compiled with `-O0` flags
1413         (Check "DEFAULT C CALLING CONVENTION (O32)" section on
1414         https://www.mips.com/downloads/mips32-instruction-set-quick-reference-v1-01).
1415
1416         * llint/LowLevelInterpreter.asm:
1417
1418         As we need to do on ARMv7, 64-bits arguments needs to be passed in
1419         register pairs `$a1:$a0` or `$a3:$a2` (little-endian mode). Since `$a0`
1420         contais `CallFrame*`, we need to pass `EncodedJSValue` on `$a3:$a2`
1421         pair.
1422
1423         * offlineasm/mips.rb:
1424
1425         Following the same reason for return locations on OSR to LLInt, we
1426         need to adjust `$gp` using `$ra` instead of `$t9` on
1427         `checkpoint_osr_exit_from_inlined_call_trampoline`, given it is only
1428         reachable through `ret` operations. For detailed explanation, check
1429         ChangeLog of https://trac.webkit.org/changeset/252713.
1430
1431 2020-02-25  Devin Rousso  <drousso@apple.com>
1432
1433         Web Inspector: safari app extension isolated worlds and injected files use the extension's identifier instead of its name
1434         https://bugs.webkit.org/show_bug.cgi?id=206911
1435         <rdar://problem/58026635>
1436
1437         Reviewed by Brian Burg.
1438
1439         * inspector/protocol/Browser.json: Added.
1440         Add a `Browser` agent that can communicate with the inspected page's containing browser. It
1441         lives in the UIProcess alongside the `Target` agent (meaning there should only be one per
1442         debuggable rather than one per target) and as such is not routed through the `Target` agent.
1443
1444         * CMakeLists.txt:
1445         * DerivedSources-input.xcfilelist:
1446         * DerivedSources.make:
1447
1448 2020-02-25  Justin Michaud  <justin_michaud@apple.com>
1449
1450         Inline Cache delete by id/val
1451         https://bugs.webkit.org/show_bug.cgi?id=207522
1452
1453         Reviewed by Keith Miller and Filip Pizlo.
1454
1455         We add inline caching for deleteById/val for baseline only. We also fix a concurrency bug in ICStats used for testing.
1456         We add three new access cases (no inline code is emitted at this time): 
1457         - Delete is a cached delete of an existing property
1458         - DeleteMiss is a delete of a property that does not exist
1459         - DeleteNonConfigurable is a delete of a property that exists, but should not be deleted.
1460         There are no conditions required for these caches, since the structure id must change and the prototype does not matter.
1461         This gives the following microbenchmark results:
1462
1463         delete-property-keeps-cacheable-structure (neutral)
1464         delete-property-inline-cache              definitely 3.9096x faster
1465         delete-property-inline-cache-polymorphic  definitely 1.5239x faster
1466         delete-property-from-prototype-chain      (neutral)
1467
1468         * API/JSCallbackObject.h:
1469         * API/JSCallbackObjectFunctions.h:
1470         (JSC::JSCallbackObject<Parent>::deleteProperty):
1471         (JSC::JSCallbackObject<Parent>::deletePropertyByIndex):
1472         * API/JSObjectRef.cpp:
1473         (JSObjectDeletePropertyForKey):
1474         (JSObjectDeleteProperty):
1475         * CMakeLists.txt:
1476         * JavaScriptCore.xcodeproj/project.pbxproj:
1477         * bytecode/AccessCase.cpp:
1478         (JSC::AccessCase::create):
1479         (JSC::AccessCase::createTransition):
1480         (JSC::AccessCase::createDelete):
1481         (JSC::AccessCase::requiresIdentifierNameMatch const):
1482         (JSC::AccessCase::requiresInt32PropertyCheck const):
1483         (JSC::AccessCase::needsScratchFPR const):
1484         (JSC::AccessCase::forEachDependentCell const):
1485         (JSC::AccessCase::doesCalls const):
1486         (JSC::AccessCase::canReplace const):
1487         (JSC::AccessCase::dump const):
1488         (JSC::AccessCase::propagateTransitions const):
1489         (JSC::AccessCase::generateImpl):
1490         * bytecode/AccessCase.h:
1491         (JSC::AccessCase::structure const):
1492         (JSC::AccessCase::newStructure const):
1493         * bytecode/PolymorphicAccess.cpp:
1494         (WTF::printInternal):
1495         * bytecode/StructureStubInfo.cpp:
1496         (JSC::StructureStubInfo::reset):
1497         * bytecode/StructureStubInfo.h:
1498         * debugger/DebuggerScope.cpp:
1499         (JSC::DebuggerScope::deleteProperty):
1500         * debugger/DebuggerScope.h:
1501         * dfg/DFGFixupPhase.cpp:
1502         (JSC::DFG::FixupPhase::fixupNode):
1503         * dfg/DFGJITCompiler.cpp:
1504         (JSC::DFG::JITCompiler::link):
1505         * dfg/DFGJITCompiler.h:
1506         (JSC::DFG::JITCompiler::addDelById):
1507         (JSC::DFG::JITCompiler::addDelByVal):
1508         * dfg/DFGSpeculativeJIT.cpp:
1509         (JSC::DFG::SpeculativeJIT::compileDeleteById): Deleted.
1510         (JSC::DFG::SpeculativeJIT::compileDeleteByVal): Deleted.
1511         * dfg/DFGSpeculativeJIT32_64.cpp:
1512         (JSC::DFG::SpeculativeJIT::compileDeleteById):
1513         (JSC::DFG::SpeculativeJIT::compileDeleteByVal):
1514         * dfg/DFGSpeculativeJIT64.cpp:
1515         (JSC::DFG::SpeculativeJIT::compileDeleteById):
1516         (JSC::DFG::SpeculativeJIT::compileDeleteByVal):
1517         * ftl/FTLLowerDFGToB3.cpp:
1518         (JSC::FTL::DFG::LowerDFGToB3::compileDelBy):
1519         (JSC::FTL::DFG::LowerDFGToB3::compileDeleteById):
1520         (JSC::FTL::DFG::LowerDFGToB3::compileDeleteByVal):
1521         * jit/ICStats.h:
1522         * jit/JIT.cpp:
1523         (JSC::JIT::privateCompileSlowCases):
1524         (JSC::JIT::link):
1525         * jit/JIT.h:
1526         * jit/JITInlineCacheGenerator.cpp:
1527         (JSC::JITDelByValGenerator::JITDelByValGenerator):
1528         (JSC::JITDelByValGenerator::generateFastPath):
1529         (JSC::JITDelByValGenerator::finalize):
1530         (JSC::JITDelByIdGenerator::JITDelByIdGenerator):
1531         (JSC::JITDelByIdGenerator::generateFastPath):
1532         (JSC::JITDelByIdGenerator::finalize):
1533         * jit/JITInlineCacheGenerator.h:
1534         (JSC::JITDelByValGenerator::JITDelByValGenerator):
1535         (JSC::JITDelByValGenerator::slowPathJump const):
1536         (JSC::JITDelByIdGenerator::JITDelByIdGenerator):
1537         (JSC::JITDelByIdGenerator::slowPathJump const):
1538         * jit/JITOperations.cpp:
1539         * jit/JITOperations.h:
1540         * jit/JITPropertyAccess.cpp:
1541         (JSC::JIT::emit_op_del_by_id):
1542         (JSC::JIT::emitSlow_op_del_by_id):
1543         (JSC::JIT::emit_op_del_by_val):
1544         (JSC::JIT::emitSlow_op_del_by_val):
1545         * jit/JITPropertyAccess32_64.cpp:
1546         (JSC::JIT::emit_op_del_by_id):
1547         (JSC::JIT::emit_op_del_by_val):
1548         (JSC::JIT::emitSlow_op_del_by_val):
1549         (JSC::JIT::emitSlow_op_del_by_id):
1550         * jit/Repatch.cpp:
1551         (JSC::tryCachePutByID):
1552         (JSC::tryCacheDelBy):
1553         (JSC::repatchDelBy):
1554         (JSC::resetPutByID):
1555         (JSC::resetDelBy):
1556         * jit/Repatch.h:
1557         * llint/LLIntSlowPaths.cpp:
1558         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
1559         * runtime/CacheableIdentifierInlines.h:
1560         (JSC::CacheableIdentifier::CacheableIdentifier):
1561         * runtime/ClassInfo.h:
1562         * runtime/ClonedArguments.cpp:
1563         (JSC::ClonedArguments::deleteProperty):
1564         * runtime/ClonedArguments.h:
1565         * runtime/CommonSlowPaths.cpp:
1566         (JSC::SLOW_PATH_DECL):
1567         * runtime/DeletePropertySlot.h: Added.
1568         (JSC::DeletePropertySlot::DeletePropertySlot):
1569         (JSC::DeletePropertySlot::setConfigurableMiss):
1570         (JSC::DeletePropertySlot::setNonconfigurable):
1571         (JSC::DeletePropertySlot::setHit):
1572         (JSC::DeletePropertySlot::isCacheableDelete const):
1573         (JSC::DeletePropertySlot::isDeleteHit const):
1574         (JSC::DeletePropertySlot::isConfigurableDeleteMiss const):
1575         (JSC::DeletePropertySlot::isNonconfigurable const):
1576         (JSC::DeletePropertySlot::cachedOffset const):
1577         (JSC::DeletePropertySlot::disableCaching):
1578         (JSC::DeletePropertySlot::isCacheable const):
1579         * runtime/ErrorConstructor.cpp:
1580         (JSC::ErrorConstructor::deleteProperty):
1581         * runtime/ErrorConstructor.h:
1582         * runtime/ErrorInstance.cpp:
1583         (JSC::ErrorInstance::deleteProperty):
1584         * runtime/ErrorInstance.h:
1585         * runtime/GenericArguments.h:
1586         * runtime/GenericArgumentsInlines.h:
1587         (JSC::GenericArguments<Type>::put):
1588         (JSC::GenericArguments<Type>::deleteProperty):
1589         * runtime/GetterSetter.h:
1590         * runtime/JSArray.cpp:
1591         (JSC::JSArray::deleteProperty):
1592         * runtime/JSArray.h:
1593         * runtime/JSCJSValue.h:
1594         * runtime/JSCell.cpp:
1595         (JSC::JSCell::deleteProperty):
1596         * runtime/JSCell.h:
1597         * runtime/JSDataView.cpp:
1598         (JSC::JSDataView::deleteProperty):
1599         * runtime/JSDataView.h:
1600         * runtime/JSFunction.cpp:
1601         (JSC::JSFunction::deleteProperty):
1602         * runtime/JSFunction.h:
1603         * runtime/JSGenericTypedArrayView.h:
1604         * runtime/JSGenericTypedArrayViewInlines.h:
1605         (JSC::JSGenericTypedArrayView<Adaptor>::deleteProperty):
1606         (JSC::JSGenericTypedArrayView<Adaptor>::deletePropertyByIndex):
1607         * runtime/JSGlobalObject.cpp:
1608         (JSC::JSGlobalObject::addFunction):
1609         * runtime/JSLexicalEnvironment.cpp:
1610         (JSC::JSLexicalEnvironment::deleteProperty):
1611         * runtime/JSLexicalEnvironment.h:
1612         * runtime/JSModuleEnvironment.cpp:
1613         (JSC::JSModuleEnvironment::deleteProperty):
1614         * runtime/JSModuleEnvironment.h:
1615         * runtime/JSModuleNamespaceObject.cpp:
1616         (JSC::JSModuleNamespaceObject::deleteProperty):
1617         * runtime/JSModuleNamespaceObject.h:
1618         * runtime/JSONObject.cpp:
1619         (JSC::Walker::walk):
1620         * runtime/JSObject.cpp:
1621         (JSC::JSObject::deleteProperty):
1622         (JSC::JSObject::deletePropertyByIndex):
1623         (JSC::validateAndApplyPropertyDescriptor):
1624         * runtime/JSObject.h:
1625         * runtime/JSProxy.cpp:
1626         (JSC::JSProxy::deleteProperty):
1627         * runtime/JSProxy.h:
1628         * runtime/JSSymbolTableObject.cpp:
1629         (JSC::JSSymbolTableObject::deleteProperty):
1630         * runtime/JSSymbolTableObject.h:
1631         * runtime/ProxyObject.cpp:
1632         (JSC::ProxyObject::deleteProperty):
1633         * runtime/ProxyObject.h:
1634         * runtime/RegExpObject.cpp:
1635         (JSC::RegExpObject::deleteProperty):
1636         * runtime/RegExpObject.h:
1637         * runtime/StrictEvalActivation.cpp:
1638         (JSC::StrictEvalActivation::deleteProperty):
1639         * runtime/StrictEvalActivation.h:
1640         * runtime/StringObject.cpp:
1641         (JSC::StringObject::deleteProperty):
1642         * runtime/StringObject.h:
1643         * runtime/Structure.cpp:
1644         (JSC::Structure::removePropertyTransition):
1645         (JSC::Structure::removePropertyTransitionFromExistingStructureImpl):
1646         (JSC::Structure::removePropertyTransitionFromExistingStructure):
1647         (JSC::Structure::removePropertyTransitionFromExistingStructureConcurrently):
1648         (JSC::Structure::removeNewPropertyTransition):
1649         (JSC::Structure::dump const):
1650         * runtime/Structure.h:
1651         * runtime/StructureInlines.h:
1652         (JSC::Structure::hasIndexingHeader const):
1653         (JSC::Structure::mayHaveIndexingHeader const):
1654         * tools/JSDollarVM.cpp:
1655         (JSC::functionHasOwnLengthProperty):
1656         (JSC::JSDollarVM::finishCreation):
1657
1658 2020-02-24  Yusuke Suzuki  <ysuzuki@apple.com>
1659
1660         [WTF] Attach WARN_UNUSED_RETURN to makeScopeExit and fix existing wrong usage
1661         https://bugs.webkit.org/show_bug.cgi?id=208162
1662
1663         Reviewed by Robin Morisset.
1664
1665         * parser/Parser.cpp:
1666         (JSC::Parser<LexerType>::parseUnaryExpression):
1667
1668 2020-02-24  Keith Miller  <keith_miller@apple.com>
1669
1670         LLInt should fast path for jtrue/false on Symbols and Objects
1671         https://bugs.webkit.org/show_bug.cgi?id=208151
1672
1673         Reviewed by Yusuke Suzuki.
1674
1675         64-bit interpreter can fast path the case where an object or symbol
1676         is passed to a jtrue or jfalse opcode. This is because these values
1677         are always truthy.
1678
1679         Also, fix some weird indentation in LowLevelInterpreter.asm.
1680
1681         * llint/LowLevelInterpreter.asm:
1682         * llint/LowLevelInterpreter32_64.asm:
1683         * llint/LowLevelInterpreter64.asm:
1684         * runtime/JSType.h:
1685
1686 2020-02-24  Caio Lima  <ticaiolima@gmail.com>
1687
1688         [JSC] 32-bits debug build broken after r257212
1689         https://bugs.webkit.org/show_bug.cgi?id=208149
1690
1691         Reviewed by Yusuke Suzuki.
1692
1693         Changing `Structure::setCachedPrototypeChain` to use
1694         `m_cachedPrototypeChainOrRareData.setMayBeNull`, since `chain` may be
1695         null.
1696
1697         * runtime/StructureInlines.h:
1698         (JSC::Structure::setCachedPrototypeChain):
1699
1700 2020-02-24  Yusuke Suzuki  <ysuzuki@apple.com>
1701
1702         Unreviewed, fix watchOS build
1703         https://bugs.webkit.org/show_bug.cgi?id=207827
1704
1705         While watchOS does not use FTL at all, it still compiles.
1706
1707         * ftl/FTLLowerDFGToB3.cpp:
1708         (JSC::FTL::DFG::LowerDFGToB3::compileObjectKeys):
1709         (JSC::FTL::DFG::LowerDFGToB3::compileCreatePromise):
1710         (JSC::FTL::DFG::LowerDFGToB3::compileCreateInternalFieldObject):
1711         (JSC::FTL::DFG::LowerDFGToB3::compileCheckSubClass):
1712         (JSC::FTL::DFG::LowerDFGToB3::loadStructureClassInfo):
1713         (JSC::FTL::DFG::LowerDFGToB3::loadStructureCachedPrototypeChainOrRareData):
1714
1715 2020-02-24  Yusuke Suzuki  <ysuzuki@apple.com>
1716
1717         Unreviewed, build fix for 32bit pointer architectures
1718         https://bugs.webkit.org/show_bug.cgi?id=207827
1719
1720         * runtime/Structure.h:
1721
1722 2020-02-23  Yusuke Suzuki  <ysuzuki@apple.com>
1723
1724         [JSC] Shrink Structure
1725         https://bugs.webkit.org/show_bug.cgi?id=207827
1726
1727         Reviewed by Saam Barati.
1728
1729         This patch shrinks sizeof(Structure) from 112 to 96 (16 bytes) in architectures using 64 bit pointers.
1730         Structure is one of the most frequently allocated JSCell in JSC. So it is worth doing
1731         all the sort of bit hacks to make it compact as much as possible.
1732
1733             1. Put outOfLineTypeFlags, maxOffset and transitionOffset into highest bits of m_propertyTableUnsafe,
1734                m_cachedPrototypeChain, m_classInfo, and m_transitionPropertyName. Do not use PackedPtr here since
1735                some of them are concurrently accessed by GC.
1736             2. Put m_inlineCapacity into lower 8 bits of m_propertyHash.
1737             3. Remove m_lock, and use Structure::cellLock() instead.
1738             4. Remove m_cachedPrototypeChain clearing from the concurrent collector since it is dead code, it was old code.
1739                We were setting m_cachedPrototypeChain only if Structure is for JSObject. Clearing happened only if it was not
1740                a Structure for JSObject.
1741             5. Previous Structure is held as StructureID m_previous. And m_previousOrRareData becomes m_cachedPrototypeChainOrRareData.
1742
1743         Many pairs are using CompactPointerTuple to make code clean.
1744         Combining all of the above techniques saves us 16 bytes.
1745
1746         * bytecode/AccessCase.cpp:
1747         (JSC::AccessCase::create):
1748         (JSC::AccessCase::propagateTransitions const):
1749         * bytecode/AccessCase.h:
1750         (JSC::AccessCase::structure const):
1751         * dfg/DFGSpeculativeJIT.cpp:
1752         (JSC::DFG::SpeculativeJIT::compileCheckSubClass):
1753         (JSC::DFG::SpeculativeJIT::compileObjectKeys):
1754         (JSC::DFG::SpeculativeJIT::compileCreateThis):
1755         (JSC::DFG::SpeculativeJIT::compileCreatePromise):
1756         (JSC::DFG::SpeculativeJIT::compileCreateInternalFieldObject):
1757         * ftl/FTLAbstractHeapRepository.h:
1758         * ftl/FTLLowerDFGToB3.cpp:
1759         (JSC::FTL::DFG::LowerDFGToB3::compileObjectKeys):
1760         (JSC::FTL::DFG::LowerDFGToB3::compileCreatePromise):
1761         (JSC::FTL::DFG::LowerDFGToB3::compileCreateInternalFieldObject):
1762         (JSC::FTL::DFG::LowerDFGToB3::compileCheckSubClass):
1763         * jit/AssemblyHelpers.h:
1764         (JSC::AssemblyHelpers::emitLoadClassInfoFromStructure):
1765         * jit/JITOpcodes.cpp:
1766         (JSC::JIT::emit_op_create_this):
1767         * jit/JITOpcodes32_64.cpp:
1768         (JSC::JIT::emit_op_create_this):
1769         * jit/Repatch.cpp:
1770         (JSC::tryCachePutByID):
1771         * llint/LLIntSlowPaths.cpp:
1772         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
1773         * runtime/ClonedArguments.cpp:
1774         (JSC::ClonedArguments::createStructure):
1775         * runtime/ConcurrentJSLock.h:
1776         (JSC::ConcurrentJSLockerBase::ConcurrentJSLockerBase):
1777         (JSC::GCSafeConcurrentJSLockerImpl::GCSafeConcurrentJSLockerImpl):
1778         (JSC::GCSafeConcurrentJSLockerImpl::~GCSafeConcurrentJSLockerImpl):
1779         (JSC::ConcurrentJSLockerImpl::ConcurrentJSLockerImpl):
1780         (JSC::GCSafeConcurrentJSLocker::GCSafeConcurrentJSLocker): Deleted.
1781         (JSC::GCSafeConcurrentJSLocker::~GCSafeConcurrentJSLocker): Deleted.
1782         (JSC::ConcurrentJSLocker::ConcurrentJSLocker): Deleted.
1783         * runtime/JSCell.h:
1784         * runtime/JSObject.cpp:
1785         (JSC::JSObject::deleteProperty):
1786         (JSC::JSObject::shiftButterflyAfterFlattening):
1787         * runtime/JSObject.h:
1788         (JSC::JSObject::getDirectConcurrently const):
1789         * runtime/JSObjectInlines.h:
1790         (JSC::JSObject::prepareToPutDirectWithoutTransition):
1791         * runtime/JSType.cpp:
1792         (WTF::printInternal):
1793         * runtime/JSType.h:
1794         * runtime/Structure.cpp:
1795         (JSC::StructureTransitionTable::contains const):
1796         (JSC::StructureTransitionTable::get const):
1797         (JSC::StructureTransitionTable::add):
1798         (JSC::Structure::dumpStatistics):
1799         (JSC::Structure::Structure):
1800         (JSC::Structure::create):
1801         (JSC::Structure::findStructuresAndMapForMaterialization):
1802         (JSC::Structure::materializePropertyTable):
1803         (JSC::Structure::addPropertyTransitionToExistingStructureImpl):
1804         (JSC::Structure::addPropertyTransitionToExistingStructureConcurrently):
1805         (JSC::Structure::addNewPropertyTransition):
1806         (JSC::Structure::removeNewPropertyTransition):
1807         (JSC::Structure::changePrototypeTransition):
1808         (JSC::Structure::attributeChangeTransition):
1809         (JSC::Structure::toDictionaryTransition):
1810         (JSC::Structure::takePropertyTableOrCloneIfPinned):
1811         (JSC::Structure::nonPropertyTransitionSlow):
1812         (JSC::Structure::flattenDictionaryStructure):
1813         (JSC::Structure::pin):
1814         (JSC::Structure::pinForCaching):
1815         (JSC::Structure::allocateRareData):
1816         (JSC::Structure::ensurePropertyReplacementWatchpointSet):
1817         (JSC::Structure::copyPropertyTableForPinning):
1818         (JSC::Structure::add):
1819         (JSC::Structure::remove):
1820         (JSC::Structure::visitChildren):
1821         (JSC::Structure::canCachePropertyNameEnumerator const):
1822         * runtime/Structure.h:
1823         * runtime/StructureInlines.h:
1824         (JSC::Structure::get):
1825         (JSC::Structure::ruleOutUnseenProperty const):
1826         (JSC::Structure::seenProperties const):
1827         (JSC::Structure::addPropertyHashAndSeenProperty):
1828         (JSC::Structure::forEachPropertyConcurrently):
1829         (JSC::Structure::transitivelyTransitionedFrom):
1830         (JSC::Structure::cachedPrototypeChain const):
1831         (JSC::Structure::setCachedPrototypeChain):
1832         (JSC::Structure::prototypeChain const):
1833         (JSC::Structure::propertyReplacementWatchpointSet):
1834         (JSC::Structure::checkOffsetConsistency const):
1835         (JSC::Structure::add):
1836         (JSC::Structure::remove):
1837         (JSC::Structure::removePropertyWithoutTransition):
1838         (JSC::Structure::setPropertyTable):
1839         (JSC::Structure::clearPropertyTable):
1840         (JSC::Structure::setOutOfLineTypeFlags):
1841         (JSC::Structure::setInlineCapacity):
1842         (JSC::Structure::setClassInfo):
1843         (JSC::Structure::setPreviousID):
1844         (JSC::Structure::clearPreviousID):
1845         * runtime/StructureRareData.cpp:
1846         (JSC::StructureRareData::createStructure):
1847         (JSC::StructureRareData::create):
1848         (JSC::StructureRareData::StructureRareData):
1849         (JSC::StructureRareData::visitChildren):
1850         * runtime/StructureRareData.h:
1851         * runtime/StructureRareDataInlines.h:
1852         (JSC::StructureRareData::setCachedPrototypeChain):
1853         (JSC::StructureRareData::setPreviousID): Deleted.
1854         (JSC::StructureRareData::clearPreviousID): Deleted.
1855         * tools/JSDollarVM.cpp:
1856         (JSC::JSDollarVMHelper::functionGetStructureTransitionList):
1857         * wasm/js/WebAssemblyFunction.cpp:
1858         (JSC::WebAssemblyFunction::jsCallEntrypointSlow):
1859
1860 2020-02-20  Mark Lam  <mark.lam@apple.com>
1861
1862         Make support for bytecode caching more robust against file corruption.
1863         https://bugs.webkit.org/show_bug.cgi?id=207972
1864         <rdar://problem/59260595>
1865
1866         Reviewed by Yusuke Suzuki.
1867
1868         If a bytecode cache file is corrupted, we currently will always crash every time
1869         we try to read it (in perpetuity as long as the corrupted cache file continues to
1870         exist on disk).  To guard against this, we'll harden the bytecode caching mechanism
1871         as follows:
1872
1873         1. Modify the writeCache operation to always write the cache file in a transactional
1874            manner i.e. we'll first write to a .tmp file, and then rename the .tmp file to
1875            the cache file only if the entire file has been written in completeness.
1876
1877            This ensures that we won't get corrupted cache files due to interrupted writes.
1878
1879         2. Modify the writeCache operation to also compute a SHA1 hash of the cache file
1880            and append the hash at end of the file.  Modify the readCache operation to
1881            first authenticate the SHA1 hash before allowing the cache file to be used.
1882            If the hash does not match, the file is bad, and we'll just delete it.
1883
1884            This ensures that we won't be crashing while decoding a corrupted cache file.
1885
1886         Manually tested with the following scenarios and ensuring that the client recovers
1887         with no crashes:
1888
1889         1. no cache file on disk.
1890         2. a 0-sized cache file on a disk.
1891         3. a truncated cache file on disk.
1892         4. a corrupted cache file on disk.
1893         5. an uncorrupted cache file on disk.
1894
1895         Also added some static_asserts in CachedTypes.cpp to document some invariants that
1896         the pre-existing code is dependent on.
1897
1898         * API/JSScript.mm:
1899         (-[JSScript readCache]):
1900         (-[JSScript writeCache:]):
1901         * runtime/CachedTypes.cpp:
1902
1903 2020-02-19  Ross Kirsling  <ross.kirsling@sony.com>
1904
1905         Computed Properties with increment sometimes produces incorrect results
1906         https://bugs.webkit.org/show_bug.cgi?id=170934
1907
1908         Reviewed by Yusuke Suzuki.
1909
1910         When the key and value of a computed property each have side effects, the eval order should be key-before-value.
1911         Not only have we had this backwards, we've also been giving them both the same target register.
1912
1913         * bytecompiler/NodesCodegen.cpp:
1914         (JSC::PropertyListNode::emitPutConstantProperty):
1915
1916 2020-02-19  Keith Miller  <keith_miller@apple.com>
1917
1918         Disable Wasm reference types by default
1919         https://bugs.webkit.org/show_bug.cgi?id=207952
1920
1921         Reviewed by Mark Lam.
1922
1923         * runtime/OptionsList.h:
1924
1925 2020-02-19  Stephan Szabo  <stephan.szabo@sony.com>
1926
1927         [PlayStation] Get jsc test wrappers using find_package
1928         https://bugs.webkit.org/show_bug.cgi?id=207914
1929
1930         Reviewed by Ross Kirsling.
1931
1932         * shell/PlatformPlayStation.cmake:
1933
1934 2020-02-18  Keith Miller  <keith_miller@apple.com>
1935
1936         Add an os_log PrintStream
1937         https://bugs.webkit.org/show_bug.cgi?id=207898
1938
1939         Reviewed by Mark Lam.
1940
1941         Add jsc option to write dataLogs to os_log.
1942
1943         * runtime/Options.cpp:
1944         (JSC::Options::initialize):
1945         * runtime/OptionsList.h:
1946
1947 2020-02-18  Paulo Matos  <pmatos@igalia.com>
1948
1949         Fix order (in MIPS) under which CS-registers are saved/restored
1950         https://bugs.webkit.org/show_bug.cgi?id=207752
1951
1952         Reviewed by Keith Miller.
1953
1954         This has been causing several segfaults on MIPS with JIT enabled
1955         because during an OSR to baseline, the order in which LLInt was
1956         saving the registers was not in sync with the way baseline was
1957         restoring them.
1958
1959         * llint/LowLevelInterpreter.asm:
1960
1961 2020-02-18  Ross Kirsling  <ross.kirsling@sony.com>
1962
1963         [JSC] Computed function properties compute their keys twice
1964         https://bugs.webkit.org/show_bug.cgi?id=207297
1965
1966         Reviewed by Keith Miller.
1967
1968         If a pseudo-String is used as the key of a computed function property,
1969         any side effects from resolving the string value occur in duplicate.
1970
1971         The cause has two parts:
1972           - We aren't ensuring that the string value is resolved before doing SetFunctionName and PutByVal.
1973           - Our implementation of SetFunctionName (https://tc39.es/ecma262/#sec-setfunctionname)
1974             calls toString on a non-symbol argument, instead of assuming the type is a string.
1975
1976         * bytecompiler/BytecodeGenerator.cpp:
1977         (JSC::BytecodeGenerator::shouldSetFunctionName): Added.
1978         (JSC::BytecodeGenerator::emitSetFunctionName): Added.
1979         (JSC::BytecodeGenerator::emitSetFunctionNameIfNeededImpl): Deleted.
1980         (JSC::BytecodeGenerator::emitSetFunctionNameIfNeeded): Deleted.
1981         * bytecompiler/BytecodeGenerator.h:
1982         Split the "if needed" logic out into its own function.
1983
1984         * bytecompiler/NodesCodegen.cpp:
1985         (JSC::PropertyListNode::emitBytecode):
1986         (JSC::PropertyListNode::emitPutConstantProperty):
1987         (JSC::DefineFieldNode::emitBytecode):
1988         Never emit OpSetFunctionName for a name of unknown type.
1989         (But also, don't perform a needless ToPropertyKey for non-function computed property keys.)
1990
1991         * runtime/JSFunction.cpp:
1992         (JSC::JSFunction::setFunctionName):
1993         Don't call toString, assert isString.
1994
1995 2020-02-17  Yusuke Suzuki  <ysuzuki@apple.com>
1996
1997         [JSC] JITThunk should be HashSet<Weak<NativeExecutable>> with appropriate GC weakness handling
1998         https://bugs.webkit.org/show_bug.cgi?id=207715
1999
2000         Reviewed by Darin Adler.
2001
2002         This patch refines JITThunks GC-aware Weak hash map for NativeExecutable. Previously, we have
2003         HashMap<std::tuple<TaggedNativeFunction, TaggedNativeFunction, String>, Weak<NativeExecutable>> table.
2004         But this is not good because the first tuple's information is already in NativeExecutable.
2005         But we were using this design since Weak<NativeExecutable> can be nullified because of Weak<>. If this
2006         happens, we could have invalid Entry in HashMap which does not have corresponding values. This will
2007         cause crash when rehasing requires hash code for this entry.
2008
2009         But this HashMap is very bad in terms of memory usage. Each entry has 32 bytes, and this table gets enough
2010         large. We identified that this table is consuming much memory in Membuster. So it is worth designing
2011         carefully crafted data structure which only holds Weak<NativeExecutable> by leveraging the deep interaction
2012         with our GC implementation.
2013
2014         This patch implements new design of JITThunks, which uses HashSet<Weak<NativeExecutable>> and carefully crafted
2015         HashTraits / KeyTraits to handle Weak<> well.
2016
2017         1. Each Weak should have finalizer, and this finalizer should remove dead Weak<NativeExecutable> from HashSet.
2018
2019             This is ensuring that all the keys in HashSet is, even if Weak<> is saying it is Dead, it still has an way
2020             to access content of NativeExecutable if the content is not a JS objects. For example, we can get function
2021             pointer from dead Weak<NativeExecutable> if it is not yet finalized. Since we remove all finalized Weak<>
2022             from the table, this finalizer mechanism allows us to access function pointers etc. from Weak<NativeExecutable>
2023             so long as it is held in this table.
2024
2025         2. Getting NativeExecutable* from JITThunks should have special protocol.
2026
2027             When getting NativeExecutable* from JITThunks, we do the following,
2028
2029             1. First, we check we have an Entry in JITThunks. If it does not exist, we should insert it anyway.
2030                 1.1. If it exists, we should check whether this Weak<NativeExecutable> is dead or not. It is possible that
2031                      dead one is still in the table because "dead" does not mean that it is "finalized". Until finalizing happens (and
2032                      it can be delayed by incremental-sweeper), Weak<NativeExecutable> can be dead but still accessible. So the table
2033                      is still holding dead one. If we get dead one, we should insert a new one.
2034                 1.2. If it is not dead, we return it.
2035             2. Second, we create a new NativeExecutable and insert it. In that case, it is possible that the table already has Weak<NativeExecutable>,
2036                but it is dead. In that case, we need to explicitly replace it with newly created one since old one is holding old content. If we
2037                replaced, finalizer of Weak<> will not be invoked since it immediately deallocates Weak<>. So, it does not happen that this newly
2038                inserted NativeExecutable* is removed by the finalizer registered by the old Weak<>.
2039
2040         This change makes memory usage of JITThunks table 1/4.
2041
2042         * heap/Weak.cpp:
2043         (JSC::weakClearSlowCase):
2044         * heap/Weak.h:
2045         (JSC::Weak::Weak):
2046         (JSC::Weak::isHashTableEmptyValue const):
2047         (JSC::Weak::unsafeImpl const):
2048         (WTF::HashTraits<JSC::Weak<T>>::isEmptyValue):
2049         * heap/WeakInlines.h:
2050         (JSC::Weak<T>::Weak):
2051         * jit/JITThunks.cpp:
2052         (JSC::JITThunks::JITThunks):
2053         (JSC::JITThunks::WeakNativeExecutableHash::hash):
2054         (JSC::JITThunks::WeakNativeExecutableHash::equal):
2055         (JSC::JITThunks::HostKeySearcher::hash):
2056         (JSC::JITThunks::HostKeySearcher::equal):
2057         (JSC::JITThunks::NativeExecutableTranslator::hash):
2058         (JSC::JITThunks::NativeExecutableTranslator::equal):
2059         (JSC::JITThunks::NativeExecutableTranslator::translate):
2060         (JSC::JITThunks::finalize):
2061         (JSC::JITThunks::hostFunctionStub):
2062         (JSC::JITThunks::clearHostFunctionStubs): Deleted.
2063         * jit/JITThunks.h:
2064         * runtime/NativeExecutable.h:
2065         * tools/JSDollarVM.cpp:
2066         (JSC::functionGCSweepAsynchronously):
2067         (JSC::functionCreateEmptyFunctionWithName):
2068         (JSC::JSDollarVM::finishCreation):
2069
2070 2020-02-17  Tadeu Zagallo  <tzagallo@apple.com>
2071
2072         [Wasm] REGRESSION(r256665): Wasm->JS call IC needs to save memory size register
2073         https://bugs.webkit.org/show_bug.cgi?id=207849
2074
2075         Reviewed by Mark Lam.
2076
2077         When generating the call IC, we should select the callee saves using BoundsChecking mode in order
2078         to obey to the calling conventions described in r256665. Currently, we won't restore the memory size
2079         register when calling the Wasm LLInt through the call IC.
2080
2081         * wasm/js/WebAssemblyFunction.cpp:
2082         (JSC::WebAssemblyFunction::calleeSaves const):
2083
2084 2020-02-17  Per Arne Vollan  <pvollan@apple.com>
2085
2086         Mach lookup to com.apple.webinspector should not be allowed in WebKit's WebContent process
2087         https://bugs.webkit.org/show_bug.cgi?id=203214
2088
2089         Reviewed by Brent Fulgham.
2090
2091         Add static flag in RemoteInspector to indicate whether a sandbox extension is needed. The remote inspector will only be
2092         started if the sandbox extension is not needed. Only the WebContent process will need a sandbox extension, since this
2093         patch removes mach access to 'com.apple.webinspector' for this process. Also add name and domain for the
2094         'Enable Remote Inspector' setting, since this will be used in the UI process.
2095
2096         * inspector/remote/RemoteInspector.cpp:
2097         * inspector/remote/RemoteInspector.h:
2098         * inspector/remote/RemoteInspectorConstants.h:
2099         * inspector/remote/cocoa/RemoteInspectorCocoa.mm:
2100         (Inspector::RemoteInspector::singleton):
2101
2102 2020-02-16  Fujii Hironori  <Hironori.Fujii@sony.com>
2103
2104         Remove remaining WTF_EXPORT and WTF_IMPORT by replacing them with WTF_EXPORT_DECLARATION and WTF_IMPORT_DECLARATION
2105         https://bugs.webkit.org/show_bug.cgi?id=207746
2106
2107         Reviewed by Don Olmstead.
2108
2109         * runtime/JSExportMacros.h:
2110
2111 2020-02-16  Paulo Matos  <pmatos@igalia.com>
2112
2113         Remove nonArgGPR1 for ARMv7 and ARM64 (unused)
2114         https://bugs.webkit.org/show_bug.cgi?id=207753
2115
2116         Reviewed by Darin Adler.
2117
2118         Cleanup commit - nonArgGPR1 is unused for both ARMv7
2119         and ARM64.
2120
2121         * jit/GPRInfo.h:
2122
2123 2020-02-14  Tadeu Zagallo  <tzagallo@apple.com> and Michael Saboff  <msaboff@apple.com>
2124
2125         [WASM] Wasm interpreter's calling convention doesn't match Wasm JIT's convention.
2126         https://bugs.webkit.org/show_bug.cgi?id=207727
2127
2128         Reviewed by Mark Lam.
2129
2130         The Wasm JIT has unusual calling conventions, which were further complicated by the addition
2131         of the interpreter, and the interpreter did not correctly follow these conventions (by incorrectly
2132         saving and restoring the callee save registers used for the memory base and size). Here's a summary
2133         of the calling convention:
2134
2135         - When entering Wasm from JS, the wrapper must:
2136             - Preserve the base and size when entering LLInt regardless of the mode. (Prior to this
2137               patch we only preserved the base in Signaling mode)
2138             - Preserve the memory base in either mode, and the size for BoundsChecking.
2139         - Both tiers must preserve every *other* register they use. e.g. the LLInt must preserve PB
2140           and wasmInstance, but must *not* preserve memoryBase and memorySize.
2141         - Changes to memoryBase and memorySize are visible to the caller. This means that:
2142             - Intra-module calls can assume these registers are up-to-date even if the memory was
2143               resized. The only exception here is if the LLInt calls a signaling JIT, in which case
2144               the JIT will not update the size register, since it won't be using it.
2145             - Inter-module and JS calls require the caller to reload these registers. These calls may
2146               result in memory changes (e.g. the callee may call memory.grow).
2147             - A Signaling JIT caller must be aware that the LLInt may trash the size register, since
2148               it always bounds checks.
2149
2150         * llint/WebAssembly.asm:
2151         * wasm/WasmAirIRGenerator.cpp:
2152         (JSC::Wasm::AirIRGenerator::addCall):
2153         * wasm/WasmB3IRGenerator.cpp:
2154         (JSC::Wasm::B3IRGenerator::addCall):
2155         * wasm/WasmCallee.cpp:
2156         (JSC::Wasm::LLIntCallee::calleeSaveRegisters):
2157         * wasm/WasmCallingConvention.h:
2158         * wasm/WasmLLIntPlan.cpp:
2159         (JSC::Wasm::LLIntPlan::didCompleteCompilation):
2160         * wasm/WasmMemoryInformation.cpp:
2161         (JSC::Wasm::PinnedRegisterInfo::get):
2162         (JSC::Wasm::getPinnedRegisters): Deleted.
2163
2164 2020-02-13  Stephan Szabo  <stephan.szabo@sony.com>
2165
2166         [PlayStation] Make special udis86 C file handling only happen for Visual Studio
2167         https://bugs.webkit.org/show_bug.cgi?id=207729
2168
2169         Reviewed by Don Olmstead.
2170
2171         * PlatformPlayStation.cmake:
2172
2173 2020-02-13  Caio Lima  <ticaiolima@gmail.com>
2174
2175         [ESNext][BigInt] We don't support BigInt literal as PropertyName
2176         https://bugs.webkit.org/show_bug.cgi?id=206888
2177
2178         Reviewed by Ross Kirsling.
2179
2180         According to spec (https://tc39.es/ecma262/#prod-PropertyName),
2181         BigInt literals are valid property names. Given that, we should not
2182         throw a SyntaxError when using BigInt literals on destructuring
2183         pattern, method declaration, object literals, etc.
2184         This patch is adding BigInt literal as a valid syntax to PropertyName.
2185
2186         * parser/Parser.cpp:
2187         (JSC::Parser<LexerType>::parseDestructuringPattern):
2188         (JSC::Parser<LexerType>::parseClass):
2189         (JSC::Parser<LexerType>::parseInstanceFieldInitializerSourceElements):
2190         (JSC::Parser<LexerType>::parseProperty):
2191         (JSC::Parser<LexerType>::parseGetterSetter):
2192         * parser/ParserArena.cpp:
2193         (JSC::IdentifierArena::makeBigIntDecimalIdentifier):
2194         * parser/ParserArena.h:
2195
2196 2020-02-12  Mark Lam  <mark.lam@apple.com>
2197
2198         Add options for debugging WASM code.
2199         https://bugs.webkit.org/show_bug.cgi?id=207677
2200         <rdar://problem/59411390>
2201
2202         Reviewed by Yusuke Suzuki.
2203
2204         Specifically ...
2205
2206             JSC_useBBQJIT                            - allows the BBQ JIT to be used if true
2207             JSC_useOMGJIT                            - allows the OMG JIT to be used if true
2208             JSC_useWasmLLIntPrologueOSR              - allows prologue OSR from Wasm LLInt if true
2209             JSC_useWasmLLIntLoopOSR                  - allows loop OSR from Wasm LLInt if true
2210             JSC_useWasmLLIntEpilogueOSR              - allows epilogue OSR from Wasm LLInt if true
2211             JSC_wasmFunctionIndexRangeToCompile=N:M  - wasm function index range to allow compilation on, e.g. 1:100
2212
2213         * JavaScriptCore.xcodeproj/project.pbxproj:
2214         * runtime/Options.cpp:
2215         (JSC::Options::ensureOptionsAreCoherent):
2216         * runtime/OptionsList.h:
2217         * wasm/WasmBBQPlan.cpp:
2218         (JSC::Wasm::BBQPlan::BBQPlan):
2219         * wasm/WasmOMGForOSREntryPlan.cpp:
2220         (JSC::Wasm::OMGForOSREntryPlan::OMGForOSREntryPlan):
2221         * wasm/WasmOMGPlan.cpp:
2222         (JSC::Wasm::OMGPlan::OMGPlan):
2223         * wasm/WasmOperations.cpp:
2224         (JSC::Wasm::shouldJIT):
2225         (JSC::Wasm::operationWasmTriggerOSREntryNow):
2226         (JSC::Wasm::operationWasmTriggerTierUpNow):
2227         * wasm/WasmSlowPaths.cpp:
2228         (JSC::LLInt::shouldJIT):
2229         (JSC::LLInt::WASM_SLOW_PATH_DECL):
2230
2231 2020-02-12  Yusuke Suzuki  <ysuzuki@apple.com>
2232
2233         [JSC] Compact JITCodeMap by storing BytecodeIndex and CodeLocation separately
2234         https://bugs.webkit.org/show_bug.cgi?id=207673
2235
2236         Reviewed by Mark Lam.
2237
2238         While BytecodeIndex is 4 bytes, CodeLocation is 8 bytes. So the tuple of them "JITCodeMap::Entry"
2239         becomes 16 bytes because it adds 4 bytes padding. We should store BytecodeIndex and CodeLocation separately
2240         to avoid this padding.
2241
2242         This patch introduces JITCodeMapBuilder. We use this to build JITCodeMap data structure as a immutable final result.
2243
2244         * jit/JIT.cpp:
2245         (JSC::JIT::link):
2246         * jit/JITCodeMap.h:
2247         (JSC::JITCodeMap::JITCodeMap):
2248         (JSC::JITCodeMap::find const):
2249         (JSC::JITCodeMap::operator bool const):
2250         (JSC::JITCodeMap::codeLocations const):
2251         (JSC::JITCodeMap::indexes const):
2252         (JSC::JITCodeMapBuilder::append):
2253         (JSC::JITCodeMapBuilder::finalize):
2254         (JSC::JITCodeMap::Entry::Entry): Deleted.
2255         (JSC::JITCodeMap::Entry::bytecodeIndex const): Deleted.
2256         (JSC::JITCodeMap::Entry::codeLocation): Deleted.
2257         (JSC::JITCodeMap::append): Deleted.
2258         (JSC::JITCodeMap::finish): Deleted.
2259
2260 2020-02-12  Pavel Feldman  <pavel.feldman@gmail.com>
2261
2262         Web Inspector: encode binary web socket frames using base64
2263         https://bugs.webkit.org/show_bug.cgi?id=207448
2264         
2265         Previous representation of binary frames is lossy using fromUTF8WithLatin1Fallback,
2266         this patch consistently encodes binary data using base64.
2267
2268         Reviewed by Timothy Hatcher.
2269
2270         * inspector/protocol/Network.json:
2271
2272 2020-02-12  Simon Fraser  <simon.fraser@apple.com>
2273
2274         Remove CSS_DEVICE_ADAPTATION
2275         https://bugs.webkit.org/show_bug.cgi?id=203479
2276
2277         Reviewed by Tim Horton.
2278
2279         CSS Working Group resolved to remove @viewport <https://github.com/w3c/csswg-drafts/issues/4766>,
2280         so remove the code.
2281
2282         * Configurations/FeatureDefines.xcconfig:
2283
2284 2020-02-12  Yusuke Suzuki  <ysuzuki@apple.com>
2285
2286         [JSC] Compact StructureTransitionTable
2287         https://bugs.webkit.org/show_bug.cgi?id=207616
2288
2289         Reviewed by Mark Lam.
2290
2291         Some of StructureTransitionTable are shown as very large HashMap and we can compact it by encoding key.
2292         We leverage 48bit pointers and 8byte alignment of UniquedStringImpl* to encode other parameters into it.
2293
2294         * runtime/Structure.cpp:
2295         (JSC::StructureTransitionTable::contains const):
2296         (JSC::StructureTransitionTable::get const):
2297         (JSC::StructureTransitionTable::add):
2298         * runtime/Structure.h:
2299         * runtime/StructureTransitionTable.h:
2300         (JSC::StructureTransitionTable::Hash::Key::Key):
2301         (JSC::StructureTransitionTable::Hash::Key::isHashTableDeletedValue const):
2302         (JSC::StructureTransitionTable::Hash::Key::impl const):
2303         (JSC::StructureTransitionTable::Hash::Key::isAddition const):
2304         (JSC::StructureTransitionTable::Hash::Key::attributes const):
2305         (JSC::StructureTransitionTable::Hash::Key::operator==):
2306         (JSC::StructureTransitionTable::Hash::Key::operator!=):
2307         (JSC::StructureTransitionTable::Hash::hash):
2308         (JSC::StructureTransitionTable::Hash::equal):
2309
2310 2020-02-12  Yusuke Suzuki  <ysuzuki@apple.com>
2311
2312         [JSC] Make RegExpCache small
2313         https://bugs.webkit.org/show_bug.cgi?id=207619
2314
2315         Reviewed by Mark Lam.
2316
2317         We can compact RegExpKey by using PackedRefPtr, so that we can shrink memory consumption of RegExpCache.
2318
2319         * runtime/RegExpKey.h:
2320
2321 2020-02-10  Mark Lam  <mark.lam@apple.com>
2322
2323         Placate exception check validator in GenericArguments<Type>::put().
2324         https://bugs.webkit.org/show_bug.cgi?id=207485
2325         <rdar://problem/59302535>
2326
2327         Reviewed by Robin Morisset.
2328
2329         * runtime/GenericArgumentsInlines.h:
2330         (JSC::GenericArguments<Type>::put):
2331
2332 2020-02-10  Mark Lam  <mark.lam@apple.com>
2333
2334         Missing exception check in GenericArguments<Type>::deletePropertyByIndex().
2335         https://bugs.webkit.org/show_bug.cgi?id=207483
2336         <rdar://problem/59302616>
2337
2338         Reviewed by Yusuke Suzuki.
2339
2340         * runtime/GenericArgumentsInlines.h:
2341         (JSC::GenericArguments<Type>::deletePropertyByIndex):
2342
2343 2020-02-10  Truitt Savell  <tsavell@apple.com>
2344
2345         Unreviewed, rolling out r256091.
2346
2347         Broke internal builds
2348
2349         Reverted changeset:
2350
2351         "Move trivial definitions from FeatureDefines.xcconfig to
2352         PlatformEnableCocoa.h"
2353         https://bugs.webkit.org/show_bug.cgi?id=207155
2354         https://trac.webkit.org/changeset/256091
2355
2356 2020-02-10  Truitt Savell  <tsavell@apple.com>
2357
2358         Unreviewed, rolling out r256103.
2359
2360         This patch is blocking the rollout of r256091
2361
2362         Reverted changeset:
2363
2364         "Move JavaScriptCore related feature defines from
2365         FeatureDefines.xcconfig to PlatformEnableCocoa.h"
2366         https://bugs.webkit.org/show_bug.cgi?id=207436
2367         https://trac.webkit.org/changeset/256103
2368
2369 2020-02-09  Keith Rollin  <krollin@apple.com>
2370
2371         Re-enable LTO for ARM builds
2372         https://bugs.webkit.org/show_bug.cgi?id=207402
2373         <rdar://problem/49190767>
2374
2375         Reviewed by Sam Weinig.
2376
2377         Bug 190758 re-enabled LTO for Production builds for x86-family CPUs.
2378         Enabling it for ARM was left out due to a compiler issue. That issue
2379         has been fixed, and so now we can re-enable LTO for ARM.
2380
2381         * Configurations/Base.xcconfig:
2382
2383 2020-02-08  Sam Weinig  <weinig@apple.com>
2384
2385         Move JavaScriptCore related feature defines from FeatureDefines.xcconfig to PlatformEnableCocoa.h
2386         https://bugs.webkit.org/show_bug.cgi?id=207436
2387
2388         Reviewed by Tim Horton.
2389
2390         * Configurations/FeatureDefines.xcconfig:
2391         Remove ENABLE_FAST_JIT_PERMISSIONS and ENABLE_FTL_JIT.
2392
2393 2020-02-08  Sam Weinig  <weinig@apple.com>
2394
2395         Move trivial definitions from FeatureDefines.xcconfig to PlatformEnableCocoa.h
2396         https://bugs.webkit.org/show_bug.cgi?id=207155
2397
2398         Reviewed by Tim Horton.
2399         
2400         Move all trivial definitions (just ENABLE_FOO = ENABLE_FOO; or ENABLE_BAR = ;)
2401         from the FeatureDefines.xcconfigs to PlatformEnableCocoa.h, ensuring each one
2402         also has a default value in PlatformEnable.h
2403
2404         To support the move, DerivedSources.make has been updated to generate the list
2405         of ENABLE_* features by directly from preprocessing Platform.h, rather than 
2406         just getting the partial list from the xcconfig file.
2407
2408         * Configurations/FeatureDefines.xcconfig:
2409         * DerivedSources.make:
2410
2411 2020-02-07  Robin Morisset  <rmorisset@apple.com>
2412
2413         Throw OutOfMemory exception instead of crashing if DirectArguments/ScopedArguments can't be created
2414         https://bugs.webkit.org/show_bug.cgi?id=207423
2415
2416         Reviewed by Mark Lam.
2417
2418         AllocationFailureMode::Assert is problematic because fuzzers keep producing spurious error reports when they generate code that tries allocating infinite amount of memory.
2419         The right approach is to use AllocationFailureMode::ReturnNull, and throw a JS exception upon receiving null.
2420
2421         In this patch I fixed two functions that were using AllocationFailureMode::Assert:
2422             DirectArguments::DirectArguments::overrideThings
2423             GenericArguments<Type>::initModifiedArgumentsDescriptor
2424
2425         No test added, because the only test we have is highly non-deterministic/flaky (only triggers about 10 to 20% of the time even before the fix).
2426
2427         * runtime/DirectArguments.h:
2428         * runtime/GenericArguments.h:
2429         * runtime/GenericArgumentsInlines.h:
2430         (JSC::GenericArguments<Type>::deletePropertyByIndex):
2431         (JSC::GenericArguments<Type>::defineOwnProperty):
2432         (JSC::GenericArguments<Type>::initModifiedArgumentsDescriptor):
2433         (JSC::GenericArguments<Type>::initModifiedArgumentsDescriptorIfNecessary):
2434         (JSC::GenericArguments<Type>::setModifiedArgumentDescriptor):
2435         * runtime/ScopedArguments.h:
2436
2437 2020-02-07  Ryan Haddad  <ryanhaddad@apple.com>
2438
2439         Unreviewed, rolling out r256051.
2440
2441         Broke internal builds.
2442
2443         Reverted changeset:
2444
2445         "Move trivial definitions from FeatureDefines.xcconfig to
2446         PlatformEnableCocoa.h"
2447         https://bugs.webkit.org/show_bug.cgi?id=207155
2448         https://trac.webkit.org/changeset/256051
2449
2450 2020-02-07  Sam Weinig  <weinig@apple.com>
2451
2452         Move trivial definitions from FeatureDefines.xcconfig to PlatformEnableCocoa.h
2453         https://bugs.webkit.org/show_bug.cgi?id=207155
2454
2455         Reviewed by Tim Horton.
2456         
2457         Move all trivial definitions (just ENABLE_FOO = ENABLE_FOO; or ENABLE_BAR = ;)
2458         from the FeatureDefines.xcconfigs to PlatformEnableCocoa.h, ensuring each one
2459         also has a default value in PlatformEnable.h
2460
2461         To support the move, DerivedSources.make has been updated to generate the list
2462         of ENABLE_* features by directly from preprocessing Platform.h, rather than 
2463         just getting the partial list from the xcconfig file.
2464
2465         * Configurations/FeatureDefines.xcconfig:
2466         * DerivedSources.make:
2467
2468 2020-02-07  Yusuke Suzuki  <ysuzuki@apple.com>
2469
2470         [JSC] CodeBlock::shrinkToFit should shrink m_constantRegisters and m_constantsSourceCodeRepresentation in 64bit architectures
2471         https://bugs.webkit.org/show_bug.cgi?id=207356
2472
2473         Reviewed by Mark Lam.
2474
2475         Only 32bit architectures are using m_constantRegisters's address. 64bit architectures are not relying on m_constantRegisters's address.
2476         This patches fixes the thing so that CodeBlock::shrinkToFit will shrink m_constantRegisters and m_constantsSourceCodeRepresentation
2477         regardless of whether this is EarlyShrink or not. We also move DFG/FTL's LateShrink call to the place after calling DFGCommon reallyAdd
2478         since they can add more constant registers.
2479
2480         Relanding it by fixing dead-lock.
2481
2482         * bytecode/CodeBlock.cpp:
2483         (JSC::CodeBlock::shrinkToFit):
2484         * bytecode/CodeBlock.h:
2485         * dfg/DFGJITCompiler.cpp:
2486         (JSC::DFG::JITCompiler::compile):
2487         (JSC::DFG::JITCompiler::compileFunction):
2488         * dfg/DFGJITFinalizer.cpp:
2489         (JSC::DFG::JITFinalizer::finalizeCommon):
2490         * dfg/DFGPlan.cpp:
2491         (JSC::DFG::Plan::compileInThreadImpl):
2492         (JSC::DFG::Plan::finalizeWithoutNotifyingCallback):
2493         * jit/JIT.cpp:
2494         (JSC::JIT::link):
2495         * jit/JIT.h:
2496         * jit/JITInlines.h:
2497         (JSC::JIT::emitLoadDouble):
2498         (JSC::JIT::emitLoadInt32ToDouble): Deleted.
2499
2500 2020-02-06  Robin Morisset  <rmorisset@apple.com>
2501
2502         Most of B3 and Air does not need to include CCallHelpers.h
2503         https://bugs.webkit.org/show_bug.cgi?id=206975
2504
2505         Reviewed by Mark Lam.
2506
2507         They only do to use CCallHelpers::Jump or CCallHelpers::Label.
2508         But CCallHelpers inherit those from MacroAssembler. And MacroAssembler.h is dramatically cheaper to include (since CCallHelpers includes AssemblyHelpers which includes CodeBlock.h which includes roughly the entire runtime).
2509
2510         * b3/B3CheckSpecial.cpp:
2511         * b3/B3CheckSpecial.h:
2512         * b3/B3LowerMacros.cpp:
2513         * b3/B3PatchpointSpecial.cpp:
2514         (JSC::B3::PatchpointSpecial::generate):
2515         * b3/B3PatchpointSpecial.h:
2516         * b3/B3StackmapGenerationParams.cpp:
2517         (JSC::B3::StackmapGenerationParams::successorLabels const):
2518         * b3/B3StackmapGenerationParams.h:
2519         * b3/air/AirAllocateRegistersAndStackAndGenerateCode.h:
2520         * b3/air/AirCCallSpecial.cpp:
2521         * b3/air/AirCCallSpecial.h:
2522         * b3/air/AirCode.cpp:
2523         * b3/air/AirCode.h:
2524         (JSC::B3::Air::Code::entrypointLabel const):
2525         * b3/air/AirCustom.cpp:
2526         (JSC::B3::Air::CCallCustom::generate):
2527         (JSC::B3::Air::ShuffleCustom::generate):
2528         (JSC::B3::Air::WasmBoundsCheckCustom::generate):
2529         * b3/air/AirCustom.h:
2530         (JSC::B3::Air::PatchCustom::generate):
2531         (JSC::B3::Air::EntrySwitchCustom::generate):
2532         * b3/air/AirDisassembler.cpp:
2533         (JSC::B3::Air::Disassembler::addInst):
2534         * b3/air/AirDisassembler.h:
2535         * b3/air/AirGenerationContext.h:
2536         * b3/air/AirInst.h:
2537         * b3/air/AirPrintSpecial.cpp:
2538         (JSC::B3::Air::PrintSpecial::generate):
2539         * b3/air/AirPrintSpecial.h:
2540         * b3/air/AirSpecial.h:
2541         * b3/air/AirValidate.cpp:
2542         * b3/air/opcode_generator.rb:
2543
2544 2020-02-06  Commit Queue  <commit-queue@webkit.org>
2545
2546         Unreviewed, rolling out r255987.
2547         https://bugs.webkit.org/show_bug.cgi?id=207369
2548
2549         JSTests failures (Requested by yusukesuzuki on #webkit).
2550
2551         Reverted changeset:
2552
2553         "[JSC] CodeBlock::shrinkToFit should shrink
2554         m_constantRegisters and m_constantsSourceCodeRepresentation in
2555         64bit architectures"
2556         https://bugs.webkit.org/show_bug.cgi?id=207356
2557         https://trac.webkit.org/changeset/255987
2558
2559 2020-02-06  Yusuke Suzuki  <ysuzuki@apple.com>
2560
2561         [JSC] CodeBlock::shrinkToFit should shrink m_constantRegisters and m_constantsSourceCodeRepresentation in 64bit architectures
2562         https://bugs.webkit.org/show_bug.cgi?id=207356
2563
2564         Reviewed by Mark Lam.
2565
2566         Only 32bit architectures are using m_constantRegisters's address. 64bit architectures are not relying on m_constantRegisters's address.
2567         This patches fixes the thing so that CodeBlock::shrinkToFit will shrink m_constantRegisters and m_constantsSourceCodeRepresentation
2568         regardless of whether this is EarlyShrink or not. We also move DFG/FTL's LateShrink call to the place after calling DFGCommon reallyAdd
2569         since they can add more constant registers.
2570
2571         * bytecode/CodeBlock.cpp:
2572         (JSC::CodeBlock::shrinkToFit):
2573         * bytecode/CodeBlock.h:
2574         * dfg/DFGJITCompiler.cpp:
2575         (JSC::DFG::JITCompiler::compile):
2576         (JSC::DFG::JITCompiler::compileFunction):
2577         * dfg/DFGJITFinalizer.cpp:
2578         (JSC::DFG::JITFinalizer::finalizeCommon):
2579         * dfg/DFGPlan.cpp:
2580         (JSC::DFG::Plan::compileInThreadImpl):
2581         (JSC::DFG::Plan::finalizeWithoutNotifyingCallback):
2582         * jit/JIT.cpp:
2583         (JSC::JIT::link):
2584         * jit/JIT.h:
2585         * jit/JITInlines.h:
2586         (JSC::JIT::emitLoadDouble):
2587         (JSC::JIT::emitLoadInt32ToDouble): Deleted.
2588
2589 2020-02-05  Don Olmstead  <don.olmstead@sony.com>
2590
2591         [PlayStation] Build a shared JavaScriptCore
2592         https://bugs.webkit.org/show_bug.cgi?id=198446
2593
2594         Reviewed by Fujii Hironori.
2595
2596         Add TARGET_OBJECTS for bmalloc and WTF so JavaScriptCore links. Add bmalloc and
2597         WTF compile definitions so exports are exposed.
2598
2599         * PlatformPlayStation.cmake:
2600
2601 2020-02-05  Justin Michaud  <justin_michaud@apple.com>
2602
2603         Deleting a property should not turn structures into uncacheable dictionaries
2604         https://bugs.webkit.org/show_bug.cgi?id=206430
2605
2606         Reviewed by Yusuke Suzuki.
2607
2608         Right now, deleteProperty/removePropertyTransition causes a structure transition to uncacheable dictionary. Instead, we should allow it to transition to a new regular structure like adding a property does. This means that we have to:
2609
2610         1) Break the assumption that structure transition offsets increase monotonically
2611
2612         We add a new flag to tell that a structure has deleted its property, and update materializePropertyTable to use it.
2613
2614         2) Add a new transition map and transition kind for deletes
2615
2616         We cache the delete transition. We will not transition back to a previous structure if you add then immediately remove a property.
2617
2618         3) Find some heuristic for when we should actually transition to uncacheable dictionary.
2619
2620         Since deleting properties is expected to be rare, we just walk the structure list and count its size on removal. 
2621
2622         This patch also fixes a related bug in addProperty, where we did not use a GCSafeConcurrentJSLocker, and adds an option to trigger the bug. Finally, we add some helper methods to dollarVM to test.
2623
2624         This gives a 24x speedup on delete-property-keeps-cacheable-structure.js, and is neutral on delete-property-from-prototype-chain.js (which was already generating code using the inline cache).
2625
2626         * heap/HeapInlines.h:
2627         (JSC::Heap::decrementDeferralDepthAndGCIfNeeded):
2628         * runtime/JSObject.cpp:
2629         (JSC::JSObject::deleteProperty):
2630         * runtime/OptionsList.h:
2631         * runtime/PropertyMapHashTable.h:
2632         (JSC::PropertyTable::get):
2633         (JSC::PropertyTable::add):
2634         (JSC::PropertyTable::addDeletedOffset):
2635         (JSC::PropertyTable::reinsert):
2636         * runtime/Structure.cpp:
2637         (JSC::StructureTransitionTable::contains const):
2638         (JSC::StructureTransitionTable::get const):
2639         (JSC::StructureTransitionTable::add):
2640         (JSC::Structure::Structure):
2641         (JSC::Structure::materializePropertyTable):
2642         (JSC::Structure::addNewPropertyTransition):
2643         (JSC::Structure::removePropertyTransition):
2644         (JSC::Structure::removePropertyTransitionFromExistingStructure):
2645         (JSC::Structure::removeNewPropertyTransition):
2646         (JSC::Structure::toUncacheableDictionaryTransition):
2647         (JSC::Structure::remove):
2648         (JSC::Structure::visitChildren):
2649         * runtime/Structure.h:
2650         * runtime/StructureInlines.h:
2651         (JSC::Structure::forEachPropertyConcurrently):
2652         (JSC::Structure::add):
2653         (JSC::Structure::remove):
2654         (JSC::Structure::removePropertyWithoutTransition):
2655         * runtime/StructureTransitionTable.h:
2656         (JSC::StructureTransitionTable::Hash::hash):
2657         * tools/JSDollarVM.cpp:
2658         (JSC::JSDollarVMHelper::functionGetStructureTransitionList):
2659         (JSC::functionGetConcurrently):
2660         (JSC::JSDollarVM::finishCreation):
2661
2662 2020-02-05  Devin Rousso  <drousso@apple.com>
2663
2664         Web Inspector: Sources: add a special breakpoint for controlling whether `debugger` statements pause
2665         https://bugs.webkit.org/show_bug.cgi?id=206818
2666
2667         Reviewed by Timothy Hatcher.
2668
2669         * inspector/protocol/Debugger.json:
2670         * inspector/agents/InspectorDebuggerAgent.h:
2671         * inspector/agents/InspectorDebuggerAgent.cpp:
2672         (Inspector::InspectorDebuggerAgent::setPauseOnDebuggerStatements): Added.
2673
2674         * bytecompiler/NodesCodegen.cpp:
2675         (JSC::DebuggerStatementNode::emitBytecode):
2676         * bytecode/CodeBlock.cpp:
2677         (JSC::CodeBlock::finishCreation):
2678         * bytecode/UnlinkedCodeBlock.cpp:
2679         (JSC::dumpLineColumnEntry):
2680         * interpreter/Interpreter.h:
2681         * interpreter/Interpreter.cpp:
2682         (JSC::Interpreter::debug):
2683         (WTF::printInternal):
2684         * debugger/Debugger.h:
2685         (JSC::Debugger::setPauseOnDebuggerStatements): Added.
2686         * debugger/Debugger.cpp:
2687         (JSC::Debugger::didReachDebuggerStatement): Added.
2688         (JSC::Debugger::didReachBreakpoint): Deleted.
2689         Replace `DebugHookType::DidReachBreakpoint` with `DebugHookType::DidReachDebuggerStatement`,
2690         as it is only actually used for `debugger;` statements, not breakpoints.
2691
2692 2020-02-04  Yusuke Suzuki  <ysuzuki@apple.com>
2693
2694         [JSC] Structure::setMaxOffset and setTransitionOffset are racy
2695         https://bugs.webkit.org/show_bug.cgi?id=207249
2696
2697         Reviewed by Mark Lam.
2698
2699         We hit crash in JSTests/stress/array-slice-osr-exit-2.js. The situation is following.
2700
2701             1. The mutator thread (A) is working.
2702             2. The concurrent collector (B) is working.
2703             3. A attempts to set m_maxOffset in StructureRareData by allocating it. First, A sets Structure::m_maxOffset to useRareDataFlag.
2704             3. B is in JSObject::visitButterflyImpl, and executing Structure::maxOffset().
2705             4. B detects that m_maxOffset is useRareDataFlag.
2706             5. B attempts to load rareData, but this is not a StructureRareData since A is just now setting up StructureRareData.
2707             6. B crashes.
2708
2709         Set useRareDataFlag after StructureRareData is set. Ensuring this store-order by using storeStoreFence.
2710
2711         * runtime/Structure.h:
2712
2713 2020-02-04  Adrian Perez de Castro  <aperez@igalia.com>
2714
2715         Non-unified build fixes early February 2020 edition
2716         https://bugs.webkit.org/show_bug.cgi?id=207227
2717
2718         Reviewed by Don Olmstead.
2719
2720         * bytecode/PolyProtoAccessChain.h: Add missing inclusions of StructureIDTable.h and VM.h
2721
2722 2020-02-04  Alex Christensen  <achristensen@webkit.org>
2723
2724         Fix Mac CMake build
2725         https://bugs.webkit.org/show_bug.cgi?id=207231
2726
2727         * PlatformMac.cmake:
2728
2729 2020-02-04  Yusuke Suzuki  <ysuzuki@apple.com>
2730
2731         [JSC] Use PackedRefPtr in UnlinkedCodeBlock
2732         https://bugs.webkit.org/show_bug.cgi?id=207229
2733
2734         Reviewed by Mark Lam.
2735
2736         Use PackedRefPtr in UnlinkedCodeBlock to compact it from 168 to 160, which saves 16 bytes (10%) per UnlinkedCodeBlock since
2737         we have 16 bytes alignment for GC cells.
2738
2739         * bytecode/UnlinkedCodeBlock.h:
2740         (JSC::UnlinkedCodeBlock::sourceURLDirective const):
2741         (JSC::UnlinkedCodeBlock::sourceMappingURLDirective const):
2742         (JSC::UnlinkedCodeBlock::setSourceURLDirective):
2743         (JSC::UnlinkedCodeBlock::setSourceMappingURLDirective):
2744         * runtime/CachedTypes.cpp:
2745         (JSC::CachedCodeBlock::sourceURLDirective const):
2746         (JSC::CachedCodeBlock::sourceMappingURLDirective const):
2747         (JSC::CachedCodeBlock<CodeBlockType>::encode):
2748         * runtime/CodeCache.cpp:
2749         (JSC::CodeCache::getUnlinkedGlobalCodeBlock):
2750
2751 2020-02-04  Alexey Shvayka  <shvaikalesh@gmail.com>
2752
2753         Quantifiers after lookahead assertions should be syntax errors in Unicode patterns only
2754         https://bugs.webkit.org/show_bug.cgi?id=206988
2755
2756         Reviewed by Darin Adler and Ross Kirsling.
2757
2758         This change adds SyntaxError for quantifiable assertions in Unicode patterns,
2759         aligning JSC with V8 and SpiderMonkey.
2760
2761         Grammar: https://tc39.es/ecma262/#prod-annexB-Term
2762         (/u flag precludes the use of QuantifiableAssertion)
2763
2764         Return value of parseParenthesesEnd() now matches with parseEscape() and
2765         parseAtomEscape().
2766
2767         * yarr/YarrParser.h:
2768         (JSC::Yarr::Parser::parseParenthesesBegin):
2769         (JSC::Yarr::Parser::parseParenthesesEnd):
2770         (JSC::Yarr::Parser::parseTokens):
2771
2772 2020-02-04  Yusuke Suzuki  <ysuzuki@apple.com>
2773
2774         [JSC] Introduce UnlinkedCodeBlockGenerator and reduce sizeof(UnlinkedCodeBlock)
2775         https://bugs.webkit.org/show_bug.cgi?id=207087
2776
2777         Reviewed by Tadeu Zagallo.
2778
2779         While UnlinkedCodeBlock is immutable once it is created from BytecodeGenerator, it has many mutable Vectors.
2780         This is because we are using UnlinkedCodeBlock as a builder of UnlinkedCodeBlock itself too in BytecodeGenerator.
2781         Since Vector takes 16 bytes to allow efficient expansions, it is nice if we can use RefCountedArray instead when
2782         we know this Vector is immutable.
2783
2784         In this patch, we introduce UnlinkedCodeBlockGenerator wrapper. BytecodeGenerator, BytecodeRewriter, BytecodeDumper,
2785         and BytecodeGeneratorification interact with UnlinkedCodeBlockGenerator instead of UnlinkedCodeBlock. And UnlinkedCodeBlockGenerator
2786         will generate the finalized UnlinkedCodeBlock. This design allows us to use RefCountedArray for data in UnlinkedCodeBlock,
2787         which is (1) smaller and (2) doing shrinkToFit operation when creating it from Vector.
2788
2789         This patch reduces sizeof(UnlinkedCodeBlock) from 256 to 168, 88 bytes reduction.
2790
2791         * JavaScriptCore.xcodeproj/project.pbxproj:
2792         * Sources.txt:
2793         * bytecode/BytecodeBasicBlock.cpp:
2794         (JSC::BytecodeBasicBlock::compute):
2795         * bytecode/BytecodeBasicBlock.h:
2796         * bytecode/BytecodeDumper.cpp:
2797         * bytecode/BytecodeGeneratorification.cpp:
2798         (JSC::BytecodeGeneratorification::BytecodeGeneratorification):
2799         (JSC::GeneratorLivenessAnalysis::run):
2800         (JSC::BytecodeGeneratorification::run):
2801         (JSC::performGeneratorification):
2802         * bytecode/BytecodeGeneratorification.h:
2803         * bytecode/BytecodeRewriter.h:
2804         (JSC::BytecodeRewriter::BytecodeRewriter):
2805         * bytecode/CodeBlock.cpp:
2806         (JSC::CodeBlock::finishCreation):
2807         (JSC::CodeBlock::setConstantIdentifierSetRegisters):
2808         (JSC::CodeBlock::setConstantRegisters):
2809         (JSC::CodeBlock::handlerForIndex):
2810         (JSC::CodeBlock::insertBasicBlockBoundariesForControlFlowProfiler):
2811         * bytecode/CodeBlock.h:
2812         (JSC::CodeBlock::numberOfSwitchJumpTables const):
2813         (JSC::CodeBlock::numberOfStringSwitchJumpTables const):
2814         (JSC::CodeBlock::addSwitchJumpTable): Deleted.
2815         (JSC::CodeBlock::addStringSwitchJumpTable): Deleted.
2816         * bytecode/HandlerInfo.h:
2817         (JSC::HandlerInfoBase::handlerForIndex):
2818         * bytecode/JumpTable.h:
2819         (JSC::SimpleJumpTable::add): Deleted.
2820         * bytecode/PreciseJumpTargets.cpp:
2821         (JSC::computePreciseJumpTargets):
2822         (JSC::recomputePreciseJumpTargets):
2823         (JSC::findJumpTargetsForInstruction):
2824         * bytecode/PreciseJumpTargets.h:
2825         * bytecode/UnlinkedCodeBlock.cpp:
2826         (JSC::UnlinkedCodeBlock::UnlinkedCodeBlock):
2827         (JSC::UnlinkedCodeBlock::visitChildren):
2828         (JSC::UnlinkedCodeBlock::dumpExpressionRangeInfo):
2829         (JSC::UnlinkedCodeBlock::expressionRangeForBytecodeIndex const):
2830         (JSC::UnlinkedCodeBlock::handlerForIndex):
2831         (JSC::UnlinkedCodeBlock::addExpressionInfo): Deleted.
2832         (JSC::UnlinkedCodeBlock::addTypeProfilerExpressionInfo): Deleted.
2833         (JSC::UnlinkedCodeBlock::setInstructions): Deleted.
2834         (JSC::UnlinkedCodeBlock::applyModification): Deleted.
2835         (JSC::UnlinkedCodeBlock::shrinkToFit): Deleted.
2836         (JSC::UnlinkedCodeBlock::addOutOfLineJumpTarget): Deleted.
2837         * bytecode/UnlinkedCodeBlock.h:
2838         (JSC::UnlinkedCodeBlock::expressionInfo):
2839         (JSC::UnlinkedCodeBlock::setNumParameters):
2840         (JSC::UnlinkedCodeBlock::numberOfIdentifiers const):
2841         (JSC::UnlinkedCodeBlock::identifiers const):
2842         (JSC::UnlinkedCodeBlock::bitVector):
2843         (JSC::UnlinkedCodeBlock::constantRegisters):
2844         (JSC::UnlinkedCodeBlock::constantsSourceCodeRepresentation):
2845         (JSC::UnlinkedCodeBlock::constantIdentifierSets):
2846         (JSC::UnlinkedCodeBlock::numberOfJumpTargets const):
2847         (JSC::UnlinkedCodeBlock::numberOfSwitchJumpTables const):
2848         (JSC::UnlinkedCodeBlock::numberOfStringSwitchJumpTables const):
2849         (JSC::UnlinkedCodeBlock::numberOfFunctionDecls):
2850         (JSC::UnlinkedCodeBlock::numberOfExceptionHandlers const):
2851         (JSC::UnlinkedCodeBlock::opProfileControlFlowBytecodeOffsets const):
2852         (JSC::UnlinkedCodeBlock::createRareDataIfNecessary):
2853         (JSC::UnlinkedCodeBlock::addParameter): Deleted.
2854         (JSC::UnlinkedCodeBlock::addIdentifier): Deleted.
2855         (JSC::UnlinkedCodeBlock::addBitVector): Deleted.
2856         (JSC::UnlinkedCodeBlock::addSetConstant): Deleted.
2857         (JSC::UnlinkedCodeBlock::addConstant): Deleted.
2858         (JSC::UnlinkedCodeBlock::addJumpTarget): Deleted.
2859         (JSC::UnlinkedCodeBlock::addSwitchJumpTable): Deleted.
2860         (JSC::UnlinkedCodeBlock::addStringSwitchJumpTable): Deleted.
2861         (JSC::UnlinkedCodeBlock::addFunctionDecl): Deleted.
2862         (JSC::UnlinkedCodeBlock::addFunctionExpr): Deleted.
2863         (JSC::UnlinkedCodeBlock::addExceptionHandler): Deleted.
2864         (JSC::UnlinkedCodeBlock::addOpProfileControlFlowBytecodeOffset): Deleted.
2865         (JSC::UnlinkedCodeBlock::replaceOutOfLineJumpTargets): Deleted.
2866         * bytecode/UnlinkedCodeBlockGenerator.cpp: Added.
2867         (JSC::UnlinkedCodeBlockGenerator::getLineAndColumn const):
2868         (JSC::UnlinkedCodeBlockGenerator::addExpressionInfo):
2869         (JSC::UnlinkedCodeBlockGenerator::addTypeProfilerExpressionInfo):
2870         (JSC::UnlinkedCodeBlockGenerator::finalize):
2871         (JSC::UnlinkedCodeBlockGenerator::handlerForBytecodeIndex):
2872         (JSC::UnlinkedCodeBlockGenerator::handlerForIndex):
2873         (JSC::UnlinkedCodeBlockGenerator::applyModification):
2874         (JSC::UnlinkedCodeBlockGenerator::addOutOfLineJumpTarget):
2875         (JSC::UnlinkedCodeBlockGenerator::outOfLineJumpOffset):
2876         (JSC::UnlinkedCodeBlockGenerator::dump const):
2877         * bytecode/UnlinkedCodeBlockGenerator.h: Added.
2878         (JSC::UnlinkedCodeBlockGenerator::UnlinkedCodeBlockGenerator):
2879         (JSC::UnlinkedCodeBlockGenerator::vm):
2880         (JSC::UnlinkedCodeBlockGenerator::isConstructor const):
2881         (JSC::UnlinkedCodeBlockGenerator::constructorKind const):
2882         (JSC::UnlinkedCodeBlockGenerator::superBinding const):
2883         (JSC::UnlinkedCodeBlockGenerator::scriptMode const):
2884         (JSC::UnlinkedCodeBlockGenerator::needsClassFieldInitializer const):
2885         (JSC::UnlinkedCodeBlockGenerator::isStrictMode const):
2886         (JSC::UnlinkedCodeBlockGenerator::usesEval const):
2887         (JSC::UnlinkedCodeBlockGenerator::parseMode const):
2888         (JSC::UnlinkedCodeBlockGenerator::isArrowFunction):
2889         (JSC::UnlinkedCodeBlockGenerator::derivedContextType const):
2890         (JSC::UnlinkedCodeBlockGenerator::evalContextType const):
2891         (JSC::UnlinkedCodeBlockGenerator::isArrowFunctionContext const):
2892         (JSC::UnlinkedCodeBlockGenerator::isClassContext const):
2893         (JSC::UnlinkedCodeBlockGenerator::numCalleeLocals const):
2894         (JSC::UnlinkedCodeBlockGenerator::numVars const):
2895         (JSC::UnlinkedCodeBlockGenerator::numParameters const):
2896         (JSC::UnlinkedCodeBlockGenerator::thisRegister const):
2897         (JSC::UnlinkedCodeBlockGenerator::scopeRegister const):
2898         (JSC::UnlinkedCodeBlockGenerator::wasCompiledWithDebuggingOpcodes const):
2899         (JSC::UnlinkedCodeBlockGenerator::hasCheckpoints const):
2900         (JSC::UnlinkedCodeBlockGenerator::hasTailCalls const):
2901         (JSC::UnlinkedCodeBlockGenerator::setHasCheckpoints):
2902         (JSC::UnlinkedCodeBlockGenerator::setHasTailCalls):
2903         (JSC::UnlinkedCodeBlockGenerator::setNumCalleeLocals):
2904         (JSC::UnlinkedCodeBlockGenerator::setNumVars):
2905         (JSC::UnlinkedCodeBlockGenerator::setThisRegister):
2906         (JSC::UnlinkedCodeBlockGenerator::setScopeRegister):
2907         (JSC::UnlinkedCodeBlockGenerator::setNumParameters):
2908         (JSC::UnlinkedCodeBlockGenerator::metadata):
2909         (JSC::UnlinkedCodeBlockGenerator::addOpProfileControlFlowBytecodeOffset):
2910         (JSC::UnlinkedCodeBlockGenerator::numberOfJumpTargets const):
2911         (JSC::UnlinkedCodeBlockGenerator::addJumpTarget):
2912         (JSC::UnlinkedCodeBlockGenerator::jumpTarget const):
2913         (JSC::UnlinkedCodeBlockGenerator::lastJumpTarget const):
2914         (JSC::UnlinkedCodeBlockGenerator::numberOfSwitchJumpTables const):
2915         (JSC::UnlinkedCodeBlockGenerator::addSwitchJumpTable):
2916         (JSC::UnlinkedCodeBlockGenerator::switchJumpTable):
2917         (JSC::UnlinkedCodeBlockGenerator::numberOfStringSwitchJumpTables const):
2918         (JSC::UnlinkedCodeBlockGenerator::addStringSwitchJumpTable):
2919         (JSC::UnlinkedCodeBlockGenerator::stringSwitchJumpTable):
2920         (JSC::UnlinkedCodeBlockGenerator::numberOfExceptionHandlers const):
2921         (JSC::UnlinkedCodeBlockGenerator::exceptionHandler):
2922         (JSC::UnlinkedCodeBlockGenerator::addExceptionHandler):
2923         (JSC::UnlinkedCodeBlockGenerator::bitVector):
2924         (JSC::UnlinkedCodeBlockGenerator::addBitVector):
2925         (JSC::UnlinkedCodeBlockGenerator::numberOfConstantIdentifierSets const):
2926         (JSC::UnlinkedCodeBlockGenerator::constantIdentifierSets):
2927         (JSC::UnlinkedCodeBlockGenerator::addSetConstant):
2928         (JSC::UnlinkedCodeBlockGenerator::constantRegister const):
2929         (JSC::UnlinkedCodeBlockGenerator::constantRegisters):
2930         (JSC::UnlinkedCodeBlockGenerator::getConstant const):
2931         (JSC::UnlinkedCodeBlockGenerator::constantsSourceCodeRepresentation):
2932         (JSC::UnlinkedCodeBlockGenerator::addConstant):
2933         (JSC::UnlinkedCodeBlockGenerator::addFunctionDecl):
2934         (JSC::UnlinkedCodeBlockGenerator::addFunctionExpr):
2935         (JSC::UnlinkedCodeBlockGenerator::numberOfIdentifiers const):
2936         (JSC::UnlinkedCodeBlockGenerator::identifier const):
2937         (JSC::UnlinkedCodeBlockGenerator::addIdentifier):
2938         (JSC::UnlinkedCodeBlockGenerator::outOfLineJumpOffset):
2939         (JSC::UnlinkedCodeBlockGenerator::replaceOutOfLineJumpTargets):
2940         (JSC::UnlinkedCodeBlockGenerator::metadataSizeInBytes):
2941         * bytecompiler/BytecodeGenerator.cpp:
2942         (JSC::BytecodeGenerator::generate):
2943         (JSC::BytecodeGenerator::BytecodeGenerator):
2944         (JSC::BytecodeGenerator::initializeNextParameter):
2945         (JSC::BytecodeGenerator::emitPushFunctionNameScope):
2946         (JSC::prepareJumpTableForSwitch):
2947         (JSC::ForInContext::finalize):
2948         (JSC::StructureForInContext::finalize):
2949         (JSC::IndexedForInContext::finalize):
2950         * bytecompiler/BytecodeGenerator.h:
2951         * bytecompiler/BytecodeGeneratorBaseInlines.h:
2952         (JSC::BytecodeGeneratorBase<Traits>::newRegister):
2953         (JSC::BytecodeGeneratorBase<Traits>::addVar):
2954         * runtime/CachedTypes.cpp:
2955         (JSC::CachedVector::encode):
2956         (JSC::CachedVector::decode const):
2957         * wasm/WasmFunctionCodeBlock.h:
2958         (JSC::Wasm::FunctionCodeBlock::setNumVars):
2959         (JSC::Wasm::FunctionCodeBlock::setNumCalleeLocals):
2960
2961 2020-02-04  Devin Rousso  <drousso@apple.com>
2962
2963         Web Inspector: REGRESSION(r248287): Console: function objects saved to a $n will be invoked instead of just referenced when evaluating in the Console
2964         https://bugs.webkit.org/show_bug.cgi?id=207180
2965         <rdar://problem/58860268>
2966
2967         Reviewed by Joseph Pecoraro.
2968
2969         * inspector/InjectedScriptSource.js:
2970         (CommandLineAPI):
2971         Instead of deciding whether to wrap the value given for a `$n` getter based on if the value
2972         is already a function, always wrap getter values in a function so that if the value being
2973         stored in the getter is already a function, it isn't used as the callback for the getter and
2974         therefore invoked when the getter is referenced.
2975
2976 2020-02-03  Yusuke Suzuki  <ysuzuki@apple.com>
2977
2978         [JSC] Use PackedPtr for VariableEnvironment
2979         https://bugs.webkit.org/show_bug.cgi?id=207172
2980
2981         Reviewed by Mark Lam.
2982
2983         Since VariableEnvironment's KeyValue is key: pointer + value: 2 byte, using PackedPtr can make it 8 bytes, 50% reduction.
2984
2985         * parser/VariableEnvironment.h:
2986         * runtime/CachedTypes.cpp:
2987         (JSC::CachedRefPtr::encode):
2988         (JSC::CachedRefPtr::decode const): CachedTypes should handle PackedPtr too since VariableEnvironment starts using it.
2989
2990 2020-02-03  Alexey Shvayka  <shvaikalesh@gmail.com>
2991
2992         \0 identity escapes should be syntax errors in Unicode patterns only
2993         https://bugs.webkit.org/show_bug.cgi?id=207114
2994
2995         Reviewed by Darin Adler.
2996
2997         This change adds a separate check for null character because `strchr`
2998         always returns a non-null pointer when called with '\0' as second argument.
2999
3000         Grammar: https://tc39.es/ecma262/#prod-annexB-IdentityEscape
3001         (/u flag precludes the use of SourceCharacterIdentityEscape)
3002
3003         * yarr/YarrParser.h:
3004         (JSC::Yarr::Parser::isIdentityEscapeAnError):
3005
3006 2020-02-01  Alexey Shvayka  <shvaikalesh@gmail.com>
3007
3008         Non-alphabetical \c escapes should be syntax errors in Unicode patterns only
3009         https://bugs.webkit.org/show_bug.cgi?id=207091
3010
3011         Reviewed by Darin Adler.
3012
3013         This change adds SyntaxError for non-alphabetical and identity \c escapes
3014         in Unicode patterns, aligning JSC with V8 and SpiderMonkey.
3015
3016         Grammar: https://tc39.es/ecma262/#prod-annexB-ClassEscape
3017         (/u flag precludes the use of ClassControlLetter)
3018
3019         * yarr/YarrErrorCode.cpp:
3020         (JSC::Yarr::errorMessage):
3021         (JSC::Yarr::errorToThrow):
3022         * yarr/YarrErrorCode.h:
3023         * yarr/YarrParser.h:
3024         (JSC::Yarr::Parser::parseEscape):
3025
3026 2020-01-31  Yusuke Suzuki  <ysuzuki@apple.com>
3027
3028         [JSC] Hold StructureID instead of Structure* in PolyProtoAccessChain and DFG::CommonData
3029         https://bugs.webkit.org/show_bug.cgi?id=207086
3030
3031         Reviewed by Mark Lam.
3032
3033         PolyProtoAccessChain and DFG::CommonData are kept alive so long as associated AccessCase / DFG/FTL CodeBlock
3034         is alive. They hold Vector<Structure*> / Vector<WriteBarrier<Structure*>>, but access frequency is low. And
3035         We should hold Vector<StructureID> instead to cut 50% of the size.
3036
3037         * bytecode/AccessCase.cpp:
3038         (JSC::AccessCase::commit):
3039         (JSC::AccessCase::forEachDependentCell const):
3040         (JSC::AccessCase::doesCalls const):
3041         (JSC::AccessCase::visitWeak const):
3042         (JSC::AccessCase::propagateTransitions const):
3043         (JSC::AccessCase::generateWithGuard):
3044         * bytecode/AccessCase.h:
3045         * bytecode/CodeBlock.cpp:
3046         (JSC::CodeBlock::propagateTransitions):
3047         (JSC::CodeBlock::determineLiveness):
3048         (JSC::CodeBlock::stronglyVisitWeakReferences):
3049         * bytecode/GetByStatus.cpp:
3050         (JSC::GetByStatus::computeForStubInfoWithoutExitSiteFeedback):
3051         * bytecode/InByIdStatus.cpp:
3052         (JSC::InByIdStatus::computeFor):
3053         (JSC::InByIdStatus::computeForStubInfo):
3054         (JSC::InByIdStatus::computeForStubInfoWithoutExitSiteFeedback):
3055         * bytecode/InByIdStatus.h:
3056         * bytecode/InstanceOfStatus.cpp:
3057         (JSC::InstanceOfStatus::computeFor):
3058         (JSC::InstanceOfStatus::computeForStubInfo):
3059         * bytecode/InstanceOfStatus.h:
3060         * bytecode/PolyProtoAccessChain.cpp:
3061         (JSC::PolyProtoAccessChain::create):
3062         (JSC::PolyProtoAccessChain::needImpurePropertyWatchpoint const):
3063         (JSC::PolyProtoAccessChain::dump const):
3064         * bytecode/PolyProtoAccessChain.h:
3065         (JSC::PolyProtoAccessChain::chain const):
3066         (JSC::PolyProtoAccessChain::forEach const):
3067         (JSC::PolyProtoAccessChain::slotBaseStructure const):
3068         (JSC::PolyProtoAccessChain:: const): Deleted.
3069         * bytecode/PolymorphicAccess.cpp:
3070         (JSC::PolymorphicAccess::regenerate):
3071         * bytecode/PutByIdStatus.cpp:
3072         (JSC::PutByIdStatus::computeForStubInfo):
3073         * bytecode/StructureStubInfo.cpp:
3074         (JSC::StructureStubInfo::summary const):
3075         (JSC::StructureStubInfo::summary):
3076         * bytecode/StructureStubInfo.h:
3077         * dfg/DFGCommonData.h:
3078         * dfg/DFGDesiredWeakReferences.cpp:
3079         (JSC::DFG::DesiredWeakReferences::reallyAdd):
3080         * dfg/DFGPlan.cpp:
3081         (JSC::DFG::Plan::finalizeWithoutNotifyingCallback):
3082         * jit/Repatch.cpp:
3083         (JSC::tryCacheGetBy):
3084         (JSC::tryCachePutByID):
3085         (JSC::tryCacheInByID):
3086
3087 2020-01-31  Yusuke Suzuki  <ysuzuki@apple.com>
3088
3089         [JSC] ShrinkToFit some vectors kept by JIT data structures
3090         https://bugs.webkit.org/show_bug.cgi?id=207085
3091
3092         Reviewed by Mark Lam.
3093
3094         1. We are allocating RareCaseProfile by using SegmentedVector since JIT code is directly accessing to RareCaseProfile*. But when creating RareCaseProfile, we can know
3095            how many RareCaseProfiles should we create: RareCaseProfile is created per slow paths of Baseline JIT bytecode. Since we already scan bytecode for the main paths,
3096            we can count it and use this number when creating RareCaseProfile.
3097         2. Vectors held by PolymorphicAccess and PolymorphicCallStubRoutine should be kept small by calling shrinkToFit.
3098
3099         * bytecode/CodeBlock.cpp:
3100         (JSC::CodeBlock::setRareCaseProfiles):
3101         (JSC::CodeBlock::shrinkToFit):
3102         (JSC::CodeBlock::addRareCaseProfile): Deleted.
3103         * bytecode/CodeBlock.h:
3104         * bytecode/PolyProtoAccessChain.cpp:
3105         (JSC::PolyProtoAccessChain::create):
3106         * bytecode/PolymorphicAccess.cpp:
3107         (JSC::PolymorphicAccess::regenerate):
3108         * bytecode/ValueProfile.h:
3109         (JSC::RareCaseProfile::RareCaseProfile):
3110         * jit/JIT.cpp:
3111         (JSC::JIT::privateCompileMainPass):
3112         (JSC::JIT::privateCompileSlowCases):
3113         * jit/JIT.h:
3114         * jit/PolymorphicCallStubRoutine.cpp:
3115         (JSC::PolymorphicCallStubRoutine::PolymorphicCallStubRoutine):
3116
3117 2020-01-31  Yusuke Suzuki  <ysuzuki@apple.com>
3118
3119         [JSC] DFG::CommonData::shrinkToFit called before DFG::Plan::reallyAdd is called
3120         https://bugs.webkit.org/show_bug.cgi?id=207083
3121
3122         Reviewed by Mark Lam.
3123
3124         We are calling DFG::CommonData::shrinkToFit, but calling this too early: we execute
3125         DFG::Plan::reallyAdd(DFG::CommonData*) after that, and this adds many entries to
3126         DFG::CommonData*. We should call DFG::CommonData::shrinkToFit after calling DFG::Plan::reallyAdd.
3127
3128         To implement it, we make DFG::JITCode::shrinkToFit virtual function in JSC::JITCode. Then, we
3129         can also implement FTL::JITCode::shrinkToFit which was previously not implemented.
3130
3131         * dfg/DFGJITCode.cpp:
3132         (JSC::DFG::JITCode::shrinkToFit):
3133         * dfg/DFGJITCode.h:
3134         * dfg/DFGJITCompiler.cpp:
3135         (JSC::DFG::JITCompiler::compile):
3136         (JSC::DFG::JITCompiler::compileFunction):
3137         * dfg/DFGPlan.cpp:
3138         (JSC::DFG::Plan::finalizeWithoutNotifyingCallback):
3139         * ftl/FTLJITCode.cpp:
3140         (JSC::FTL::JITCode::shrinkToFit):
3141         * ftl/FTLJITCode.h:
3142         * jit/JITCode.cpp:
3143         (JSC::JITCode::shrinkToFit):
3144         * jit/JITCode.h:
3145
3146 2020-01-31  Saam Barati  <sbarati@apple.com>
3147
3148         GetButterfly should check if the input value is an object in safe to execute
3149         https://bugs.webkit.org/show_bug.cgi?id=207082
3150
3151         Reviewed by Mark Lam.
3152
3153         We can only hoist GetButterfly when we know the incoming value is an object.
3154         We might want to reconsider making GetButterfly use ObjectUse as its edge
3155         kind, but that's out of the scope of this patch. Currently, we use CellUse
3156         for GetButterfly node's child1.
3157
3158         * dfg/DFGSafeToExecute.h:
3159         (JSC::DFG::safeToExecute):
3160
3161 2020-01-31  Saam Barati  <sbarati@apple.com>
3162
3163         safe to execute should return false when we know code won't be moved
3164         https://bugs.webkit.org/show_bug.cgi?id=207074
3165
3166         Reviewed by Yusuke Suzuki.
3167
3168         We use safeToExecute to determine inside LICM whether it's safe to execute
3169         a node somewhere else in the program. We were returning true for nodes
3170         we knew would never be moved, because they were effectful. Things like Call
3171         and GetById. This patch makes those nodes return false now, since we want
3172         to make it easier to audit the nodes that return true. This makes that audit
3173         easier, since it gets rid of the obvious things that will never be hoisted.
3174
3175         * dfg/DFGSafeToExecute.h:
3176         (JSC::DFG::safeToExecute):
3177
3178 2020-01-31  Saam Barati  <sbarati@apple.com>
3179
3180         GetGetterSetterByOffset and GetGetter/GetSetter are not always safe to execute
3181         https://bugs.webkit.org/show_bug.cgi?id=206805
3182         <rdar://problem/58898161>
3183
3184         Reviewed by Yusuke Suzuki.
3185
3186         This patch fixes two bugs. The first is GetGetterSetterByOffset. Previously,
3187         we were just checking that we could load the value safely. However, because
3188         GetGetterSetterByOffset returns a GetterSetter object, we can only safely
3189         move this node into a context where it's guaranteed that the offset loaded
3190         will return a GetterSetter.
3191         
3192         The second fix is GetGetter/GetSetter were both always marked as safe to execute.
3193         However, they're only safe to execute when the incoming value to load from
3194         is a GetterSetter object.
3195
3196         * dfg/DFGSafeToExecute.h:
3197         (JSC::DFG::safeToExecute):
3198
3199 2020-01-31  Alexey Shvayka  <shvaikalesh@gmail.com>
3200
3201         Unmatched ] or } brackets should be syntax errors in Unicode patterns only
3202         https://bugs.webkit.org/show_bug.cgi?id=207023
3203
3204         Reviewed by Darin Adler.
3205
3206         This change adds SyntaxError for Unicode patterns, aligning JSC with
3207         V8 and SpiderMonkey.
3208
3209         Grammar: https://tc39.es/ecma262/#prod-annexB-Term
3210         (/u flag precludes the use of ExtendedAtom and thus ExtendedPatternCharacter)
3211
3212         * yarr/YarrErrorCode.cpp:
3213         (JSC::Yarr::errorMessage):
3214         (JSC::Yarr::errorToThrow):
3215         * yarr/YarrErrorCode.h:
3216         * yarr/YarrParser.h:
3217         (JSC::Yarr::Parser::parseTokens):
3218
3219 2020-01-31  Don Olmstead  <don.olmstead@sony.com>
3220
3221         [CMake] Add _PRIVATE_LIBRARIES to framework
3222         https://bugs.webkit.org/show_bug.cgi?id=207004
3223
3224         Reviewed by Konstantin Tokarev.
3225
3226         Move uses of PRIVATE within _LIBRARIES to _PRIVATE_LIBRARIES. Any _LIBRARIES appended
3227         afterwards will have that visibility set erroneously.
3228
3229         * PlatformFTW.cmake:
3230
3231 2020-01-30  Mark Lam  <mark.lam@apple.com>
3232
3233         Some improvements to DFG and FTL dumps to improve readability and searchability.
3234         https://bugs.webkit.org/show_bug.cgi?id=207024
3235
3236         Reviewed by Saam Barati.
3237
3238         This patch applies the following changes:
3239
3240         1. Prefix Air and B2 dumps with a tierName prefix.
3241            The tierName prefix strings are as follows:
3242
3243                "FTL ", "DFG ", "b3  ", "Air ", "asm "
3244
3245            The choice to use a lowercase "b3" and "asm" with upper case "Air" is
3246            deliberate because I found this combination to be easier to read and scan as
3247            prefixes of the dump lines.  See dump samples below.
3248
3249         2. Make DFG node IDs consistently expressed as D@<node index> e.g. D@104.
3250            The definition of the node will be the id followed by a colon e.g. D@104:
3251            This makes it easy to search references to this node anywhere in the dump.
3252
3253            Make B3 nodes expressed as b@<node index> e.g. b@542.
3254            This also makes it searchable since there's now no ambiguity between b@542 and
3255            D@542.
3256
3257            The choice to use a lowercase "b" and an uppercase "D" is intentional because
3258            "b@542" and "d@542" looks too similar, and I prefer to not use too much
3259            uppercase.  Plus this makes the node consistent in capitalization with the
3260            tierName prefixes above of "b3  " and "DFG " respectively.
3261
3262         Here's a sample of what the dumps now look like:
3263
3264         DFG graph dump:
3265         <code>
3266             ...
3267                  6 55:   <-- foo#DFndCW:<0x62d0000b8140, bc#65, Call, known callee: Object: 0x62d000035920 with butterfly 0x0 (Structure %AN:Function), StructureID: 12711, numArgs+this = 1, numFixup = 0, stackOffset = -16 (loc0 maps to loc16)>
3268               3  6 55:   D@79:< 3:->    ArithAdd(Int32:Kill:D@95, Int32:D@42, Int32|PureNum|UseAsOther, Int32, CheckOverflow, Exits, bc#71, ExitValid)
3269               4  6 55:    D@3:<!0:->    KillStack(MustGen, loc7, W:Stack(loc7), ClobbersExit, bc#71, ExitInvalid)
3270               5  6 55:   D@85:<!0:->    MovHint(Check:Untyped:D@79, MustGen, loc7, W:SideState, ClobbersExit, bc#71, ExitInvalid)
3271               6  6 55:  D@102:< 1:->    CompareLess(Int32:D@79, Int32:D@89, Boolean|UseAsOther, Bool, Exits, bc#74, ExitValid)
3272               7  6 55:  D@104:<!0:->    Branch(KnownBoolean:Kill:D@102, MustGen, T:#1/w:10.000000, F:#7/w:1.000000, W:SideState, bc#74, ExitInvalid)
3273             ...
3274         </code>
3275
3276         B3 graph dump:
3277         <code>
3278             ...
3279             b3  BB#14: ; frequency = 10.000000
3280             b3    Predecessors: #13
3281             b3      Int32 b@531 = CheckAdd(b@10:WarmAny, $1(b@1):WarmAny, b@64:ColdAny, b@10:ColdAny, generator = 0x606000022e80, earlyClobbered = [], lateClobbered = [], usedRegisters = [], ExitsSideways|Reads:Top, D@79)
3282             b3      Int32 b@539 = LessThan(b@531, $100(b@578), D@102)
3283             b3      Void b@542 = Branch(b@539, Terminal, D@104)
3284             b3    Successors: Then:#2, Else:#15
3285             ...
3286         </code>
3287
3288         Air graph dump:
3289         <code>
3290             ...
3291             Air BB#5: ; frequency = 10.000000
3292             Air   Predecessors: #4
3293             Air     Move -96(%rbp), %rax, b@531
3294             Air     Patch &BranchAdd32(3,ForceLateUseUnlessRecoverable)3, Overflow, $1, %rax, -104(%rbp), -96(%rbp), b@531
3295             Air     Branch32 LessThan, %rax, $100, b@542
3296             Air   Successors: #1, #6
3297             ...
3298         </code>
3299
3300         FTL disassembly dump:
3301         <code>
3302             ...
3303             Air BB#5: ; frequency = 10.000000
3304             Air   Predecessors: #4
3305             DFG       D@42:< 2:->   JSConstant(JS|PureInt, Int32, Int32: 1, bc#0, ExitInvalid)
3306             DFG       D@79:< 3:->   ArithAdd(Int32:Kill:D@95, Int32:D@42, Int32|PureNum|UseAsOther, Int32, CheckOverflow, Exits, bc#71, ExitValid)
3307             b3            Int32 b@1 = Const32(1)
3308             b3            Int32 b@531 = CheckAdd(b@10:WarmAny, $1(b@1):WarmAny, b@64:ColdAny, b@10:ColdAny, generator = 0x606000022e80, earlyClobbered = [], lateClobbered = [], usedRegisters = [%rax, %rbx, %rbp, %r12], ExitsSideways|Reads:Top, D@79)
3309             Air               Move -96(%rbp), %rax, b@531
3310             asm                   0x4576b9c04712: mov -0x60(%rbp), %rax
3311             Air               Patch &BranchAdd32(3,ForceLateUseUnlessRecoverable)3, Overflow, $1, %rax, -104(%rbp), -96(%rbp), b@531
3312             asm                   0x4576b9c04716: inc %eax
3313             asm                   0x4576b9c04718: jo 0x4576b9c04861
3314             DFG       D@89:< 1:->   JSConstant(JS|PureNum|UseAsOther, NonBoolInt32, Int32: 100, bc#0, ExitInvalid)
3315             DFG      D@102:< 1:->   CompareLess(Int32:D@79, Int32:D@89, Boolean|UseAsOther, Bool, Exits, bc#74, ExitValid)
3316             DFG      D@104:<!0:->   Branch(KnownBoolean:Kill:D@102, MustGen, T:#1/w:10.000000, F:#7/w:1.000000, W:SideState, bc#74, ExitInvalid)
3317             b3            Int32 b@578 = Const32(100, D@89)
3318             b3            Int32 b@539 = LessThan(b@531, $100(b@578), D@102)
3319             b3            Void b@542 = Branch(b@539, Terminal, D@104)
3320             Air               Branch32 LessThan, %rax, $100, b@542
3321             asm                   0x4576b9c0471e: cmp $0x64, %eax
3322             asm                   0x4576b9c04721: jl 0x4576b9c0462f
3323             Air   Successors: #1, #6
3324             ...
3325         </code>
3326
3327         * b3/B3BasicBlock.cpp:
3328         (JSC::B3::BasicBlock::deepDump const):
3329         * b3/B3Common.cpp:
3330         * b3/B3Common.h:
3331         * b3/B3Generate.cpp:
3332         (JSC::B3::generateToAir):
3333         * b3/B3Procedure.cpp:
3334         (JSC::B3::Procedure::dump const):
3335         * b3/B3Value.cpp:
3336         * b3/air/AirBasicBlock.cpp:
3337         (JSC::B3::Air::BasicBlock::deepDump const):
3338         (JSC::B3::Air::BasicBlock::dumpHeader const):
3339         (JSC::B3::Air::BasicBlock::dumpFooter const):
3340         * b3/air/AirCode.cpp:
3341         (JSC::B3::Air::Code::dump const):
3342         * b3/air/AirCode.h:
3343         * b3/air/AirDisassembler.cpp:
3344         (JSC::B3::Air::Disassembler::dump):
3345         * b3/air/AirGenerate.cpp:
3346         (JSC::B3::Air::prepareForGeneration):
3347