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