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