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