SDK_VARIANT build destinations should be separate from non-SDK_VARIANT builds
[WebKit-https.git] / Source / JavaScriptCore / ChangeLog
1 2019-01-18  Jer Noble  <jer.noble@apple.com>
2
3         SDK_VARIANT build destinations should be separate from non-SDK_VARIANT builds
4         https://bugs.webkit.org/show_bug.cgi?id=189553
5
6         Reviewed by Tim Horton.
7
8         * Configurations/Base.xcconfig:
9         * Configurations/SDKVariant.xcconfig: Added.
10
11 2019-01-18  Keith Miller  <keith_miller@apple.com>
12
13         Gigacages should start allocations from a slide
14         https://bugs.webkit.org/show_bug.cgi?id=193523
15
16         Reviewed by Mark Lam.
17
18         This patch changes some macros into constants since macros are the
19         devil.
20
21         * ftl/FTLLowerDFGToB3.cpp:
22         (JSC::FTL::DFG::LowerDFGToB3::caged):
23         * llint/LowLevelInterpreter64.asm:
24
25 2019-01-18  Matt Lewis  <jlewis3@apple.com>
26
27         Unreviewed, rolling out r240160.
28
29         This broke multiple internal builds.
30
31         Reverted changeset:
32
33         "Gigacages should start allocations from a slide"
34         https://bugs.webkit.org/show_bug.cgi?id=193523
35         https://trac.webkit.org/changeset/240160
36
37 2019-01-18  Keith Miller  <keith_miller@apple.com>
38
39         Gigacages should start allocations from a slide
40         https://bugs.webkit.org/show_bug.cgi?id=193523
41
42         Reviewed by Mark Lam.
43
44         This patch changes some macros into constants since macros are the
45         devil.
46
47         * llint/LowLevelInterpreter64.asm:
48
49 2019-01-17  Mark Lam  <mark.lam@apple.com>
50
51         Audit bytecode fields and ensure that LLInt instructions for accessing them are appropriate.
52         https://bugs.webkit.org/show_bug.cgi?id=193557
53         <rdar://problem/47369125>
54
55         Reviewed by Yusuke Suzuki.
56
57         1. Rename some bytecode fields so that it's easier to discern whether the LLInt
58            is accessing them the right way:
59            - distinguish between targetVirtualRegister and targetLabel.
60            - name all StructureID fields as structureID (oldStructureID, newStructureID)
61              instead of structure (oldStructure, newStructure).
62
63         2. Use bitwise_cast in struct Fits when sizeof(T) == size.
64            This prevents potential undefined behavior issues arising from doing
65            assignments with reinterpret_cast'ed pointers.
66
67         3. Make Special::Pointer an unsigned type (previously int).
68            Make ResolveType an unsigned type (previously int).
69
70         4. In LowLevelInterpreter*.asm:
71
72            - rename the op macro argument to opcodeName or opcodeStruct respectively.
73              This makes it clearer which argument type the macro is working with.
74
75            - rename the name macro argument to opcodeName.
76
77            - fix operator types to match the field type being accessed.  The following
78              may have resulted in bugs before:
79
80              1. The following should be read with getu() instead of get() because they
81                 are unsigned ints:
82                     OpSwitchImm::m_tableIndex
83                     OpSwitchChar::m_tableIndex
84                     OpGetFromArguments::m_index
85                     OpPutToArguments::m_index
86                     OpGetRestLength::m_numParametersToSkip
87
88                 OpJneqPtr::m_specialPointer should also be read with getu() though this
89                 wasn't a bug because it was previously an int by default, and is only
90                 changed to an unsigned int in this patch.
91
92              2.The following should be read with loadi (not loadp) because they are of
93                unsigned type (not a pointer):
94                     OpResolveScope::Metadata::m_resolveType
95                     CodeBlock::m_numParameters (see prepareForTailCall)
96
97              3. OpPutToScope::Metadata::m_operand should be read with loadp (not loadis)
98                 because it is a uintptr_t.
99
100              4. The following should be read with loadi (not loadis) because they are
101                 unsigned ints:
102                     OpNegate::Metadata::m_arithProfile + ArithProfile::m_bits
103                     OpPutById::Metadata::m_oldStructureID
104                     OpPutToScope::Metadata::m_getPutInfo + GetPutInfo::m_operand
105
106                 These may not have manifested in bugs because the operations that follow
107                 the load are 32-bit instructions which ignore the high word.
108
109         5. Give class GetPutInfo a default constructor so that we can use bitwise_cast
110            on it.  Also befriend LLIntOffsetsExtractor so that we can take the offset of
111            m_operand in it.
112
113         * bytecode/ArithProfile.h:
114         * bytecode/BytecodeList.rb:
115         * bytecode/BytecodeUseDef.h:
116         (JSC::computeUsesForBytecodeOffset):
117         (JSC::computeDefsForBytecodeOffset):
118         * bytecode/CodeBlock.cpp:
119         (JSC::CodeBlock::propagateTransitions):
120         (JSC::CodeBlock::finalizeLLIntInlineCaches):
121         * bytecode/Fits.h:
122         * bytecode/GetByIdMetadata.h:
123         * bytecode/GetByIdStatus.cpp:
124         (JSC::GetByIdStatus::computeFromLLInt):
125         * bytecode/LLIntPrototypeLoadAdaptiveStructureWatchpoint.cpp:
126         (JSC::LLIntPrototypeLoadAdaptiveStructureWatchpoint::clearLLIntGetByIdCache):
127         * bytecode/PreciseJumpTargetsInlines.h:
128         (JSC::jumpTargetForInstruction):
129         (JSC::updateStoredJumpTargetsForInstruction):
130         * bytecode/PutByIdStatus.cpp:
131         (JSC::PutByIdStatus::computeFromLLInt):
132         * bytecode/SpecialPointer.h:
133         * bytecompiler/BytecodeGenerator.cpp:
134         (JSC::Label::setLocation):
135         * dfg/DFGByteCodeParser.cpp:
136         (JSC::DFG::ByteCodeParser::parseBlock):
137         * jit/JITArithmetic.cpp:
138         (JSC::JIT::emit_compareAndJump):
139         (JSC::JIT::emit_compareUnsignedAndJump):
140         (JSC::JIT::emit_compareAndJumpSlow):
141         * jit/JITArithmetic32_64.cpp:
142         (JSC::JIT::emit_compareAndJump):
143         (JSC::JIT::emit_compareUnsignedAndJump):
144         (JSC::JIT::emit_compareAndJumpSlow):
145         (JSC::JIT::emitBinaryDoubleOp):
146         * jit/JITOpcodes.cpp:
147         (JSC::JIT::emit_op_jmp):
148         (JSC::JIT::emit_op_jfalse):
149         (JSC::JIT::emit_op_jeq_null):
150         (JSC::JIT::emit_op_jneq_null):
151         (JSC::JIT::emit_op_jneq_ptr):
152         (JSC::JIT::emit_op_jeq):
153         (JSC::JIT::emit_op_jtrue):
154         (JSC::JIT::emit_op_jneq):
155         (JSC::JIT::compileOpStrictEqJump):
156         (JSC::JIT::emitSlow_op_jstricteq):
157         (JSC::JIT::emitSlow_op_jnstricteq):
158         (JSC::JIT::emit_op_check_tdz):
159         (JSC::JIT::emitSlow_op_jeq):
160         (JSC::JIT::emitSlow_op_jneq):
161         (JSC::JIT::emit_op_profile_type):
162         * jit/JITOpcodes32_64.cpp:
163         (JSC::JIT::emit_op_jmp):
164         (JSC::JIT::emit_op_jfalse):
165         (JSC::JIT::emit_op_jtrue):
166         (JSC::JIT::emit_op_jeq_null):
167         (JSC::JIT::emit_op_jneq_null):
168         (JSC::JIT::emit_op_jneq_ptr):
169         (JSC::JIT::emit_op_jeq):
170         (JSC::JIT::emitSlow_op_jeq):
171         (JSC::JIT::emit_op_jneq):
172         (JSC::JIT::emitSlow_op_jneq):
173         (JSC::JIT::compileOpStrictEqJump):
174         (JSC::JIT::emitSlow_op_jstricteq):
175         (JSC::JIT::emitSlow_op_jnstricteq):
176         (JSC::JIT::emit_op_check_tdz):
177         (JSC::JIT::emit_op_profile_type):
178         * llint/LLIntSlowPaths.cpp:
179         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
180         (JSC::LLInt::setupGetByIdPrototypeCache):
181         * llint/LowLevelInterpreter.asm:
182         * llint/LowLevelInterpreter32_64.asm:
183         * llint/LowLevelInterpreter64.asm:
184         * runtime/CommonSlowPaths.cpp:
185         * runtime/GetPutInfo.h:
186
187 2019-01-17  Truitt Savell  <tsavell@apple.com>
188
189         Unreviewed, rolling out r240124.
190
191         This commit broke an internal build.
192
193         Reverted changeset:
194
195         "SDK_VARIANT build destinations should be separate from non-
196         SDK_VARIANT builds"
197         https://bugs.webkit.org/show_bug.cgi?id=189553
198         https://trac.webkit.org/changeset/240124
199
200 2019-01-17  Jer Noble  <jer.noble@apple.com>
201
202         SDK_VARIANT build destinations should be separate from non-SDK_VARIANT builds
203         https://bugs.webkit.org/show_bug.cgi?id=189553
204
205         Reviewed by Tim Horton.
206
207         * Configurations/Base.xcconfig:
208         * Configurations/SDKVariant.xcconfig: Added.
209
210 2019-01-17  Saam barati  <sbarati@apple.com>
211
212         StringObjectUse should not be a structure check for the original string object structure
213         https://bugs.webkit.org/show_bug.cgi?id=193483
214         <rdar://problem/47280522>
215
216         Reviewed by Yusuke Suzuki.
217
218         Prior to this patch, the use kind for StringObjectUse implied that we
219         do a StructureCheck on the input operand for the *original* StringObject
220         structure. This is generally not how we use UseKinds, so it's no surprise
221         that this is buggy. A UseKind should map to a set of SpeculatedTypes, not an
222         actual set of structures. This patch changes the meaning of StringObjectUse
223         to mean an object where jsDynamicCast<StringObject*> would succeed.
224         
225         This patch also fixes a bug that was caused by the old and weird usage of the
226         UseKind to mean StructureCheck. Consider a program like this:
227         ```
228         S1 = Original StringObject structure
229         S2 = Original StringObject structure with the field "f" added
230         
231         a: GetLocal()
232         b: CheckStructure(@a, {S2})
233         c: ToString(StringObject:@a)
234         ```
235         
236         According to AI, in the above program, we would exit at @c, since
237         StringObject:@a implies a structure check of {S1}, and the intersection
238         of {S1} and {S2} is {}. So, we'd convert the program to be:
239         ```
240         a: GetLocal()
241         b: CheckStructure(@a, {S2})
242         c: Check(StringObject:@a)
243         d: Unreachable
244         ```
245         
246         However, AI would set the proof status of the StringObject:@a edge
247         to be proven, since the SpeculatedType for @a is SpecStringObject.
248         This was incorrect of AI to do because the SpeculatedType itself
249         didn't capture the full power of StringObjectUse. However, having
250         a UseKind mean CheckStructure is weird precisely because what AI was
251         doing is a natural fit to how we typically we think about UseKinds.
252         
253         So the above program would then incorrectly be converted to this, and
254         we'd crash when reaching the Unreachable node:
255         ```
256         a: GetLocal()
257         b: CheckStructure(@a, {S2})
258         d: Unreachable
259         ```
260         
261         This patch makes it so that StringObjectUse just means that the object that
262         filters through a StringObjectUse check must !!jsDynamicCast<StringObject*>.
263         This is now in line with all other UseKinds. It also lets us simplify a bunch
264         of other code that had weird checks for the StringObjectUse UseKind.
265         
266         This patch also makes it so that anywhere where we used to rely on
267         StringObjectUse implying a structure check we actually emit an explicit
268         CheckStructure node.
269
270         * JavaScriptCore.xcodeproj/project.pbxproj:
271         * bytecode/ExitKind.cpp:
272         (JSC::exitKindToString):
273         * bytecode/ExitKind.h:
274         * dfg/DFGAbstractInterpreterInlines.h:
275         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
276         * dfg/DFGCSEPhase.cpp:
277         * dfg/DFGClobberize.h:
278         (JSC::DFG::clobberize):
279         * dfg/DFGEdgeUsesStructure.h: Removed.
280         * dfg/DFGFixupPhase.cpp:
281         (JSC::DFG::FixupPhase::attemptToForceStringArrayModeByToStringConversion):
282         (JSC::DFG::FixupPhase::addCheckStructureForOriginalStringObjectUse):
283         (JSC::DFG::FixupPhase::fixupToPrimitive):
284         (JSC::DFG::FixupPhase::fixupToStringOrCallStringConstructor):
285         (JSC::DFG::FixupPhase::attemptToMakeFastStringAdd):
286         (JSC::DFG::FixupPhase::isStringObjectUse): Deleted.
287         * dfg/DFGGraph.cpp:
288         (JSC::DFG::Graph::canOptimizeStringObjectAccess):
289         * dfg/DFGMayExit.cpp:
290         * dfg/DFGSpeculativeJIT.cpp:
291         (JSC::DFG::SpeculativeJIT::compileToStringOrCallStringConstructorOrStringValueOf):
292         (JSC::DFG::SpeculativeJIT::speculateStringObject):
293         (JSC::DFG::SpeculativeJIT::speculateStringOrStringObject):
294         * dfg/DFGSpeculativeJIT.h:
295         (JSC::DFG::SpeculativeJIT::speculateStringObjectForStructure): Deleted.
296         * dfg/DFGUseKind.h:
297         (JSC::DFG::alreadyChecked):
298         (JSC::DFG::usesStructure): Deleted.
299         * ftl/FTLLowerDFGToB3.cpp:
300         (JSC::FTL::DFG::LowerDFGToB3::compileToStringOrCallStringConstructorOrStringValueOf):
301         (JSC::FTL::DFG::LowerDFGToB3::speculateStringObject):
302         (JSC::FTL::DFG::LowerDFGToB3::speculateStringOrStringObject):
303         (JSC::FTL::DFG::LowerDFGToB3::speculateStringObjectForCell):
304         (JSC::FTL::DFG::LowerDFGToB3::speculateStringObjectForStructureID): Deleted.
305         * runtime/JSType.cpp:
306         (WTF::printInternal):
307         * runtime/JSType.h:
308         * runtime/StringObject.h:
309         (JSC::StringObject::createStructure):
310         * runtime/StringPrototype.h:
311
312 2019-01-17  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
313
314         [JSC] Add generateHeapSnapshotForGCDebugging function to dump GCDebugging data
315         https://bugs.webkit.org/show_bug.cgi?id=193526
316
317         Reviewed by Michael Saboff.
318
319         This patch adds generateHeapSnapshotForGCDebugging to JSC shell to dump heap snapshot JSON string with GCDebugging option.
320         GCDebuggingSnapshot mode is slightly different from InspectorSnapshot in terms of both the output data and the behavior.
321         It always takes full snapshot, and it reports internal data too. This is useful to view the live heap objects after running
322         the code. Also, generateHeapSnapshotForGCDebugging returns String instead of parsing it to JSObject internally by calling
323         JSON.parse. If we convert the String to bunch of objects by using JSON.parse, it is difficult to call generateHeapSnapshotForGCDebugging
324         multiple times for debugging. Currently, it only generates a large string, which is easily distinguishable in the heap inspector tool.
325
326         * jsc.cpp:
327         (GlobalObject::finishCreation):
328         (functionGenerateHeapSnapshotForGCDebugging):
329
330 2019-01-17  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
331
332         [JSC] ToThis omission in DFGByteCodeParser is wrong
333         https://bugs.webkit.org/show_bug.cgi?id=193513
334         <rdar://problem/45842236>
335
336         Reviewed by Saam Barati.
337
338         DFGByteCodeParser omitted ToThis node when we have `ToThis(ToThis(value))`. This semantics is wrong if ToThis has different semantics
339         in the sloppy mode and the strict mode. If we convert `ToThisInSloppyMode(ToThisInStrictMode(boolean))` to `ToThisInStrictMode(boolean)`,
340         we get boolean instead of BooleanObject.
341
342         This optimization is introduced more than 7 years ago, and from that, we have several optimizations that can remove such ToThis nodes
343         in BytecodeParser, AI, and Fixup. Furthermore, this optimization is simply wrong since `toThis()` function of JSCell can be defined
344         as they want. Before ensuring all the toThis function is safe, we should not fold `ToThis(ToThis(value))` => `ToThis(value)`.
345         This patch just removes the problematic optimization. The performance numbers look neutral.
346
347         * dfg/DFGAbstractInterpreterInlines.h:
348         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
349         * dfg/DFGByteCodeParser.cpp:
350         (JSC::DFG::ByteCodeParser::parseBlock):
351
352 2019-01-16  Mark Lam  <mark.lam@apple.com>
353
354         Refactor new bytecode structs so that the fields are prefixed with "m_".
355         https://bugs.webkit.org/show_bug.cgi?id=193467
356
357         Reviewed by Saam Barati and Tadeu Zagallo.
358
359         This makes it easier to do a manual audit of type correctness of the LLInt
360         instructions used to access these fields.  Without this change, it would be
361         difficult (and error prone) to distinguish the difference between field names and
362         macro variables.  This audit will be done after this patch lands.
363
364         * bytecode/BytecodeGeneratorification.cpp:
365         (JSC::BytecodeGeneratorification::BytecodeGeneratorification):
366         * bytecode/BytecodeUseDef.h:
367         (JSC::computeUsesForBytecodeOffset):
368         * bytecode/CallLinkStatus.cpp:
369         (JSC::CallLinkStatus::computeFromLLInt):
370         * bytecode/CodeBlock.cpp:
371         (JSC::CodeBlock::finishCreation):
372         (JSC::CodeBlock::propagateTransitions):
373         (JSC::CodeBlock::finalizeLLIntInlineCaches):
374         (JSC::CodeBlock::ensureCatchLivenessIsComputedForBytecodeOffset):
375         (JSC::CodeBlock::ensureCatchLivenessIsComputedForBytecodeOffsetSlow):
376         (JSC::CodeBlock::getArrayProfile):
377         (JSC::CodeBlock::notifyLexicalBindingShadowing):
378         (JSC::CodeBlock::tryGetValueProfileForBytecodeOffset):
379         (JSC::CodeBlock::arithProfileForPC):
380         (JSC::CodeBlock::insertBasicBlockBoundariesForControlFlowProfiler):
381         * bytecode/CodeBlockInlines.h:
382         (JSC::CodeBlock::forEachValueProfile):
383         (JSC::CodeBlock::forEachArrayProfile):
384         (JSC::CodeBlock::forEachArrayAllocationProfile):
385         (JSC::CodeBlock::forEachObjectAllocationProfile):
386         (JSC::CodeBlock::forEachLLIntCallLinkInfo):
387         * bytecode/GetByIdStatus.cpp:
388         (JSC::GetByIdStatus::computeFromLLInt):
389         * bytecode/LLIntPrototypeLoadAdaptiveStructureWatchpoint.cpp:
390         (JSC::LLIntPrototypeLoadAdaptiveStructureWatchpoint::clearLLIntGetByIdCache):
391         * bytecode/PreciseJumpTargetsInlines.h:
392         (JSC::jumpTargetForInstruction):
393         (JSC::extractStoredJumpTargetsForInstruction):
394         (JSC::updateStoredJumpTargetsForInstruction):
395         * bytecode/PutByIdStatus.cpp:
396         (JSC::PutByIdStatus::computeFromLLInt):
397         * bytecode/UnlinkedCodeBlock.cpp:
398         (JSC::dumpLineColumnEntry):
399         * bytecompiler/BytecodeGenerator.cpp:
400         (JSC::BytecodeGenerator::fuseCompareAndJump):
401         (JSC::BytecodeGenerator::fuseTestAndJmp):
402         (JSC::BytecodeGenerator::emitEqualityOp):
403         (JSC::BytecodeGenerator::endSwitch):
404         (JSC::StructureForInContext::finalize):
405         * dfg/DFGByteCodeParser.cpp:
406         (JSC::DFG::ByteCodeParser::handleCall):
407         (JSC::DFG::ByteCodeParser::handleVarargsCall):
408         (JSC::DFG::ByteCodeParser::parseGetById):
409         (JSC::DFG::ByteCodeParser::parseBlock):
410         (JSC::DFG::ByteCodeParser::handlePutByVal):
411         (JSC::DFG::ByteCodeParser::handlePutAccessorById):
412         (JSC::DFG::ByteCodeParser::handlePutAccessorByVal):
413         (JSC::DFG::ByteCodeParser::handleNewFunc):
414         (JSC::DFG::ByteCodeParser::handleNewFuncExp):
415         * dfg/DFGOSREntry.cpp:
416         (JSC::DFG::prepareCatchOSREntry):
417         * ftl/FTLOperations.cpp:
418         (JSC::FTL::operationMaterializeObjectInOSR):
419         * generator/Argument.rb:
420         * generator/Metadata.rb:
421         * generator/Opcode.rb:
422         * jit/JIT.h:
423         * jit/JITArithmetic.cpp:
424         (JSC::JIT::emit_op_unsigned):
425         (JSC::JIT::emit_compareAndJump):
426         (JSC::JIT::emit_compareUnsignedAndJump):
427         (JSC::JIT::emit_compareUnsigned):
428         (JSC::JIT::emit_compareAndJumpSlow):
429         (JSC::JIT::emit_op_inc):
430         (JSC::JIT::emit_op_dec):
431         (JSC::JIT::emit_op_mod):
432         (JSC::JIT::emit_op_negate):
433         (JSC::JIT::emitBitBinaryOpFastPath):
434         (JSC::JIT::emit_op_bitnot):
435         (JSC::JIT::emitRightShiftFastPath):
436         (JSC::JIT::emit_op_add):
437         (JSC::JIT::emitMathICFast):
438         (JSC::JIT::emitMathICSlow):
439         (JSC::JIT::emit_op_div):
440         (JSC::JIT::emit_op_mul):
441         (JSC::JIT::emit_op_sub):
442         * jit/JITArithmetic32_64.cpp:
443         (JSC::JIT::emit_compareAndJump):
444         (JSC::JIT::emit_compareUnsignedAndJump):
445         (JSC::JIT::emit_compareUnsigned):
446         (JSC::JIT::emit_compareAndJumpSlow):
447         (JSC::JIT::emit_op_unsigned):
448         (JSC::JIT::emit_op_inc):
449         (JSC::JIT::emit_op_dec):
450         (JSC::JIT::emitBinaryDoubleOp):
451         (JSC::JIT::emit_op_mod):
452         * jit/JITCall.cpp:
453         (JSC::JIT::emitPutCallResult):
454         (JSC::JIT::compileSetupFrame):
455         (JSC::JIT::compileCallEvalSlowCase):
456         (JSC::JIT::compileTailCall):
457         (JSC::JIT::compileOpCall):
458         * jit/JITCall32_64.cpp:
459         (JSC::JIT::emitPutCallResult):
460         (JSC::JIT::emit_op_ret):
461         (JSC::JIT::compileSetupFrame):
462         (JSC::JIT::compileCallEvalSlowCase):
463         (JSC::JIT::compileOpCall):
464         * jit/JITInlines.h:
465         (JSC::JIT::emitValueProfilingSiteIfProfiledOpcode):
466         (JSC::JIT::emitValueProfilingSite):
467         (JSC::JIT::copiedGetPutInfo):
468         (JSC::JIT::copiedArithProfile):
469         * jit/JITOpcodes.cpp:
470         (JSC::JIT::emit_op_mov):
471         (JSC::JIT::emit_op_end):
472         (JSC::JIT::emit_op_jmp):
473         (JSC::JIT::emit_op_new_object):
474         (JSC::JIT::emitSlow_op_new_object):
475         (JSC::JIT::emit_op_overrides_has_instance):
476         (JSC::JIT::emit_op_instanceof):
477         (JSC::JIT::emitSlow_op_instanceof):
478         (JSC::JIT::emit_op_is_empty):
479         (JSC::JIT::emit_op_is_undefined):
480         (JSC::JIT::emit_op_is_undefined_or_null):
481         (JSC::JIT::emit_op_is_boolean):
482         (JSC::JIT::emit_op_is_number):
483         (JSC::JIT::emit_op_is_cell_with_type):
484         (JSC::JIT::emit_op_is_object):
485         (JSC::JIT::emit_op_ret):
486         (JSC::JIT::emit_op_to_primitive):
487         (JSC::JIT::emit_op_set_function_name):
488         (JSC::JIT::emit_op_not):
489         (JSC::JIT::emit_op_jfalse):
490         (JSC::JIT::emit_op_jeq_null):
491         (JSC::JIT::emit_op_jneq_null):
492         (JSC::JIT::emit_op_jneq_ptr):
493         (JSC::JIT::emit_op_eq):
494         (JSC::JIT::emit_op_jeq):
495         (JSC::JIT::emit_op_jtrue):
496         (JSC::JIT::emit_op_neq):
497         (JSC::JIT::emit_op_jneq):
498         (JSC::JIT::emit_op_throw):
499         (JSC::JIT::compileOpStrictEq):
500         (JSC::JIT::compileOpStrictEqJump):
501         (JSC::JIT::emitSlow_op_jstricteq):
502         (JSC::JIT::emitSlow_op_jnstricteq):
503         (JSC::JIT::emit_op_to_number):
504         (JSC::JIT::emit_op_to_string):
505         (JSC::JIT::emit_op_to_object):
506         (JSC::JIT::emit_op_catch):
507         (JSC::JIT::emit_op_get_parent_scope):
508         (JSC::JIT::emit_op_switch_imm):
509         (JSC::JIT::emit_op_switch_char):
510         (JSC::JIT::emit_op_switch_string):
511         (JSC::JIT::emit_op_debug):
512         (JSC::JIT::emit_op_eq_null):
513         (JSC::JIT::emit_op_neq_null):
514         (JSC::JIT::emit_op_get_scope):
515         (JSC::JIT::emit_op_to_this):
516         (JSC::JIT::emit_op_create_this):
517         (JSC::JIT::emit_op_check_tdz):
518         (JSC::JIT::emitSlow_op_eq):
519         (JSC::JIT::emitSlow_op_neq):
520         (JSC::JIT::emitSlow_op_jeq):
521         (JSC::JIT::emitSlow_op_jneq):
522         (JSC::JIT::emitSlow_op_instanceof_custom):
523         (JSC::JIT::emit_op_new_regexp):
524         (JSC::JIT::emitNewFuncCommon):
525         (JSC::JIT::emitNewFuncExprCommon):
526         (JSC::JIT::emit_op_new_array):
527         (JSC::JIT::emit_op_new_array_with_size):
528         (JSC::JIT::emit_op_has_structure_property):
529         (JSC::JIT::emit_op_has_indexed_property):
530         (JSC::JIT::emitSlow_op_has_indexed_property):
531         (JSC::JIT::emit_op_get_direct_pname):
532         (JSC::JIT::emit_op_enumerator_structure_pname):
533         (JSC::JIT::emit_op_enumerator_generic_pname):
534         (JSC::JIT::emit_op_profile_type):
535         (JSC::JIT::emit_op_log_shadow_chicken_prologue):
536         (JSC::JIT::emit_op_log_shadow_chicken_tail):
537         (JSC::JIT::emit_op_profile_control_flow):
538         (JSC::JIT::emit_op_argument_count):
539         (JSC::JIT::emit_op_get_rest_length):
540         (JSC::JIT::emit_op_get_argument):
541         * jit/JITOpcodes32_64.cpp:
542         (JSC::JIT::emit_op_mov):
543         (JSC::JIT::emit_op_end):
544         (JSC::JIT::emit_op_jmp):
545         (JSC::JIT::emit_op_new_object):
546         (JSC::JIT::emitSlow_op_new_object):
547         (JSC::JIT::emit_op_overrides_has_instance):
548         (JSC::JIT::emit_op_instanceof):
549         (JSC::JIT::emitSlow_op_instanceof):
550         (JSC::JIT::emitSlow_op_instanceof_custom):
551         (JSC::JIT::emit_op_is_empty):
552         (JSC::JIT::emit_op_is_undefined):
553         (JSC::JIT::emit_op_is_undefined_or_null):
554         (JSC::JIT::emit_op_is_boolean):
555         (JSC::JIT::emit_op_is_number):
556         (JSC::JIT::emit_op_is_cell_with_type):
557         (JSC::JIT::emit_op_is_object):
558         (JSC::JIT::emit_op_to_primitive):
559         (JSC::JIT::emit_op_set_function_name):
560         (JSC::JIT::emit_op_not):
561         (JSC::JIT::emit_op_jfalse):
562         (JSC::JIT::emit_op_jtrue):
563         (JSC::JIT::emit_op_jeq_null):
564         (JSC::JIT::emit_op_jneq_null):
565         (JSC::JIT::emit_op_jneq_ptr):
566         (JSC::JIT::emit_op_eq):
567         (JSC::JIT::emitSlow_op_eq):
568         (JSC::JIT::emit_op_jeq):
569         (JSC::JIT::emitSlow_op_jeq):
570         (JSC::JIT::emit_op_neq):
571         (JSC::JIT::emitSlow_op_neq):
572         (JSC::JIT::emit_op_jneq):
573         (JSC::JIT::emitSlow_op_jneq):
574         (JSC::JIT::compileOpStrictEq):
575         (JSC::JIT::compileOpStrictEqJump):
576         (JSC::JIT::emitSlow_op_jstricteq):
577         (JSC::JIT::emitSlow_op_jnstricteq):
578         (JSC::JIT::emit_op_eq_null):
579         (JSC::JIT::emit_op_neq_null):
580         (JSC::JIT::emit_op_throw):
581         (JSC::JIT::emit_op_to_number):
582         (JSC::JIT::emit_op_to_string):
583         (JSC::JIT::emit_op_to_object):
584         (JSC::JIT::emit_op_catch):
585         (JSC::JIT::emit_op_get_parent_scope):
586         (JSC::JIT::emit_op_switch_imm):
587         (JSC::JIT::emit_op_switch_char):
588         (JSC::JIT::emit_op_switch_string):
589         (JSC::JIT::emit_op_debug):
590         (JSC::JIT::emit_op_get_scope):
591         (JSC::JIT::emit_op_create_this):
592         (JSC::JIT::emit_op_to_this):
593         (JSC::JIT::emit_op_check_tdz):
594         (JSC::JIT::emit_op_has_structure_property):
595         (JSC::JIT::emit_op_has_indexed_property):
596         (JSC::JIT::emitSlow_op_has_indexed_property):
597         (JSC::JIT::emit_op_get_direct_pname):
598         (JSC::JIT::emit_op_enumerator_structure_pname):
599         (JSC::JIT::emit_op_enumerator_generic_pname):
600         (JSC::JIT::emit_op_profile_type):
601         (JSC::JIT::emit_op_log_shadow_chicken_prologue):
602         (JSC::JIT::emit_op_log_shadow_chicken_tail):
603         * jit/JITOperations.cpp:
604         * jit/JITPropertyAccess.cpp:
605         (JSC::JIT::emit_op_get_by_val):
606         (JSC::JIT::emitGetByValWithCachedId):
607         (JSC::JIT::emitSlow_op_get_by_val):
608         (JSC::JIT::emit_op_put_by_val):
609         (JSC::JIT::emitGenericContiguousPutByVal):
610         (JSC::JIT::emitArrayStoragePutByVal):
611         (JSC::JIT::emitPutByValWithCachedId):
612         (JSC::JIT::emitSlow_op_put_by_val):
613         (JSC::JIT::emit_op_put_getter_by_id):
614         (JSC::JIT::emit_op_put_setter_by_id):
615         (JSC::JIT::emit_op_put_getter_setter_by_id):
616         (JSC::JIT::emit_op_put_getter_by_val):
617         (JSC::JIT::emit_op_put_setter_by_val):
618         (JSC::JIT::emit_op_del_by_id):
619         (JSC::JIT::emit_op_del_by_val):
620         (JSC::JIT::emit_op_try_get_by_id):
621         (JSC::JIT::emitSlow_op_try_get_by_id):
622         (JSC::JIT::emit_op_get_by_id_direct):
623         (JSC::JIT::emitSlow_op_get_by_id_direct):
624         (JSC::JIT::emit_op_get_by_id):
625         (JSC::JIT::emit_op_get_by_id_with_this):
626         (JSC::JIT::emitSlow_op_get_by_id):
627         (JSC::JIT::emitSlow_op_get_by_id_with_this):
628         (JSC::JIT::emit_op_put_by_id):
629         (JSC::JIT::emitSlow_op_put_by_id):
630         (JSC::JIT::emit_op_in_by_id):
631         (JSC::JIT::emitSlow_op_in_by_id):
632         (JSC::JIT::emit_op_resolve_scope):
633         (JSC::JIT::emit_op_get_from_scope):
634         (JSC::JIT::emitSlow_op_get_from_scope):
635         (JSC::JIT::emit_op_put_to_scope):
636         (JSC::JIT::emit_op_get_from_arguments):
637         (JSC::JIT::emit_op_put_to_arguments):
638         (JSC::JIT::emitIntTypedArrayPutByVal):
639         (JSC::JIT::emitFloatTypedArrayPutByVal):
640         * jit/JITPropertyAccess32_64.cpp:
641         (JSC::JIT::emit_op_put_getter_by_id):
642         (JSC::JIT::emit_op_put_setter_by_id):
643         (JSC::JIT::emit_op_put_getter_setter_by_id):
644         (JSC::JIT::emit_op_put_getter_by_val):
645         (JSC::JIT::emit_op_put_setter_by_val):
646         (JSC::JIT::emit_op_del_by_id):
647         (JSC::JIT::emit_op_del_by_val):
648         (JSC::JIT::emit_op_get_by_val):
649         (JSC::JIT::emitGetByValWithCachedId):
650         (JSC::JIT::emitSlow_op_get_by_val):
651         (JSC::JIT::emit_op_put_by_val):
652         (JSC::JIT::emitGenericContiguousPutByVal):
653         (JSC::JIT::emitArrayStoragePutByVal):
654         (JSC::JIT::emitPutByValWithCachedId):
655         (JSC::JIT::emitSlow_op_put_by_val):
656         (JSC::JIT::emit_op_try_get_by_id):
657         (JSC::JIT::emitSlow_op_try_get_by_id):
658         (JSC::JIT::emit_op_get_by_id_direct):
659         (JSC::JIT::emitSlow_op_get_by_id_direct):
660         (JSC::JIT::emit_op_get_by_id):
661         (JSC::JIT::emitSlow_op_get_by_id):
662         (JSC::JIT::emit_op_get_by_id_with_this):
663         (JSC::JIT::emitSlow_op_get_by_id_with_this):
664         (JSC::JIT::emit_op_put_by_id):
665         (JSC::JIT::emitSlow_op_put_by_id):
666         (JSC::JIT::emit_op_in_by_id):
667         (JSC::JIT::emitSlow_op_in_by_id):
668         (JSC::JIT::emit_op_resolve_scope):
669         (JSC::JIT::emit_op_get_from_scope):
670         (JSC::JIT::emitSlow_op_get_from_scope):
671         (JSC::JIT::emit_op_put_to_scope):
672         (JSC::JIT::emit_op_get_from_arguments):
673         (JSC::JIT::emit_op_put_to_arguments):
674         * llint/LLIntSlowPaths.cpp:
675         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
676         (JSC::LLInt::setupGetByIdPrototypeCache):
677         (JSC::LLInt::getByVal):
678         (JSC::LLInt::genericCall):
679         (JSC::LLInt::varargsSetup):
680         (JSC::LLInt::commonCallEval):
681         * llint/LowLevelInterpreter.asm:
682         * llint/LowLevelInterpreter32_64.asm:
683         * llint/LowLevelInterpreter64.asm:
684         * runtime/CommonSlowPaths.cpp:
685         (JSC::SLOW_PATH_DECL):
686         (JSC::updateArithProfileForUnaryArithOp):
687         * runtime/CommonSlowPaths.h:
688         (JSC::CommonSlowPaths::tryCachePutToScopeGlobal):
689         (JSC::CommonSlowPaths::tryCacheGetFromScopeGlobal):
690
691 2019-01-15  Mark Lam  <mark.lam@apple.com>
692
693         JSFunction::canUseAllocationProfile() should account for builtin functions with no own prototypes.
694         https://bugs.webkit.org/show_bug.cgi?id=193423
695         <rdar://problem/46209355>
696
697         Reviewed by Saam Barati.
698
699         JSFunction::canUseAllocationProfile() should return false for most builtins
700         because the majority of them have no prototype property.  The only exception to
701         this is the few builtin functions that are explicitly used as constructors.
702
703         For these builtin constructors, JSFunction::canUseAllocationProfile() should also
704         return false if the prototype property is a getter or custom getter because
705         getting the prototype would then be effectful.
706
707         * dfg/DFGOperations.cpp:
708         * runtime/CommonSlowPaths.cpp:
709         (JSC::SLOW_PATH_DECL):
710         * runtime/JSFunctionInlines.h:
711         (JSC::JSFunction::canUseAllocationProfile):
712         * runtime/PropertySlot.h:
713
714 2019-01-15  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
715
716         [JSC] Use KnownStringUse for GetByVal(Array::String) since AI would offer wider type information and offer non-string type after removing Check(String)
717         https://bugs.webkit.org/show_bug.cgi?id=193438
718         <rdar://problem/45581249>
719
720         Reviewed by Saam Barati and Keith Miller.
721
722         GetByVal(Array::String) emits Check(String) before that. But AI can broaden type constraint in the second run.
723         After the first run removes Check(String), it would happen that AI starts saying the type of 1st child is not String.
724         To claim that it *is* a String type, we should use KnownStringUse here.
725
726         * dfg/DFGFixupPhase.cpp:
727         (JSC::DFG::FixupPhase::fixupNode): StringCharAt and GetByVal(Array::String) share the underlying compiler code. We should
728         change StringUse => KnownStringUse for StringCharAt too. And StringCharAt and StringCharCodeAt potentially have the same
729         problem. This patch fixes it too.
730         * dfg/DFGSSALoweringPhase.cpp:
731         (JSC::DFG::SSALoweringPhase::lowerBoundsCheck):
732         * ftl/FTLLowerDFGToB3.cpp:
733         (JSC::FTL::DFG::LowerDFGToB3::compileStringCharAt):
734         (JSC::FTL::DFG::LowerDFGToB3::compileStringCharCodeAt):
735
736 2019-01-15  Saam Barati  <sbarati@apple.com>
737
738         Try ripping out inferred types because it might be a performance improvement
739         https://bugs.webkit.org/show_bug.cgi?id=190906
740
741         Reviewed by Yusuke Suzuki.
742
743         This patch removes inferred types from JSC. Initial evidence shows that
744         this might be around a ~1% speedup on Speedometer2 and JetStream2.
745
746         * JavaScriptCore.xcodeproj/project.pbxproj:
747         * Sources.txt:
748         * bytecode/AccessCase.cpp:
749         (JSC::AccessCase::generateImpl):
750         * bytecode/Fits.h:
751         * bytecode/PutByIdFlags.cpp:
752         (WTF::printInternal):
753         * bytecode/PutByIdFlags.h:
754         * bytecode/PutByIdStatus.cpp:
755         (JSC::PutByIdStatus::computeFromLLInt):
756         (JSC::PutByIdStatus::computeForStubInfo):
757         (JSC::PutByIdStatus::computeFor):
758         * bytecode/PutByIdVariant.cpp:
759         (JSC::PutByIdVariant::operator=):
760         (JSC::PutByIdVariant::replace):
761         (JSC::PutByIdVariant::transition):
762         (JSC::PutByIdVariant::setter):
763         (JSC::PutByIdVariant::attemptToMerge):
764         (JSC::PutByIdVariant::dumpInContext const):
765         * bytecode/PutByIdVariant.h:
766         (JSC::PutByIdVariant::requiredType const): Deleted.
767         * dfg/DFGAbstractInterpreterInlines.h:
768         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
769         * dfg/DFGAbstractValue.cpp:
770         (JSC::DFG::AbstractValue::isType const): Deleted.
771         * dfg/DFGAbstractValue.h:
772         * dfg/DFGByteCodeParser.cpp:
773         (JSC::DFG::ByteCodeParser::handleGetByOffset):
774         (JSC::DFG::ByteCodeParser::handlePutByOffset):
775         (JSC::DFG::ByteCodeParser::load):
776         (JSC::DFG::ByteCodeParser::store):
777         (JSC::DFG::ByteCodeParser::handlePutById):
778         (JSC::DFG::ByteCodeParser::parseBlock):
779         * dfg/DFGConstantFoldingPhase.cpp:
780         (JSC::DFG::ConstantFoldingPhase::foldConstants):
781         (JSC::DFG::ConstantFoldingPhase::emitGetByOffset):
782         (JSC::DFG::ConstantFoldingPhase::emitPutByOffset):
783         * dfg/DFGDesiredInferredType.h: Removed.
784         * dfg/DFGDesiredWatchpoints.cpp:
785         (JSC::DFG::DesiredWatchpoints::reallyAdd):
786         (JSC::DFG::DesiredWatchpoints::areStillValid const):
787         (JSC::DFG::DesiredWatchpoints::dumpInContext const):
788         (JSC::DFG::InferredTypeAdaptor::add): Deleted.
789         * dfg/DFGDesiredWatchpoints.h:
790         (JSC::DFG::DesiredWatchpoints::isWatched):
791         (JSC::DFG::InferredTypeAdaptor::hasBeenInvalidated): Deleted.
792         (JSC::DFG::InferredTypeAdaptor::dumpInContext): Deleted.
793         * dfg/DFGFixupPhase.cpp:
794         (JSC::DFG::FixupPhase::fixupNode):
795         * dfg/DFGGraph.cpp:
796         (JSC::DFG::Graph::dump):
797         (JSC::DFG::Graph::inferredValueForProperty):
798         (JSC::DFG::Graph::inferredTypeFor): Deleted.
799         * dfg/DFGGraph.h:
800         (JSC::DFG::Graph::registerInferredType): Deleted.
801         (JSC::DFG::Graph::inferredTypeForProperty): Deleted.
802         * dfg/DFGInferredTypeCheck.cpp: Removed.
803         * dfg/DFGInferredTypeCheck.h: Removed.
804         * dfg/DFGNode.h:
805         * dfg/DFGObjectAllocationSinkingPhase.cpp:
806         * dfg/DFGSafeToExecute.h:
807         (JSC::DFG::safeToExecute):
808         * ftl/FTLLowerDFGToB3.cpp:
809         (JSC::FTL::DFG::LowerDFGToB3::compileMultiPutByOffset):
810         (JSC::FTL::DFG::LowerDFGToB3::checkInferredType): Deleted.
811         * generator/DSL.rb:
812         * heap/Heap.cpp:
813         (JSC::Heap::finalizeUnconditionalFinalizers):
814         * jit/AssemblyHelpers.cpp:
815         (JSC::AssemblyHelpers::branchIfNotType): Deleted.
816         * jit/AssemblyHelpers.h:
817         * jit/Repatch.cpp:
818         (JSC::tryCachePutByID):
819         * llint/LLIntOffsetsExtractor.cpp:
820         * llint/LLIntSlowPaths.cpp:
821         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
822         * llint/LowLevelInterpreter.asm:
823         * llint/LowLevelInterpreter32_64.asm:
824         * llint/LowLevelInterpreter64.asm:
825         * runtime/InferredStructure.cpp:
826         (JSC::InferredStructure::InferredStructure): Deleted.
827         * runtime/InferredStructure.h:
828         (): Deleted.
829         * runtime/InferredStructureWatchpoint.cpp:
830         (JSC::InferredStructureWatchpoint::fireInternal): Deleted.
831         * runtime/InferredType.cpp: Removed.
832         * runtime/InferredType.h: Removed.
833         * runtime/InferredTypeInlines.h: Removed.
834         * runtime/InferredTypeTable.cpp: Removed.
835         * runtime/InferredTypeTable.h: Removed.
836         * runtime/JSObjectInlines.h:
837         (JSC::JSObject::putDirectInternal):
838         * runtime/Structure.cpp:
839         (JSC::Structure::materializePropertyTable):
840         (JSC::Structure::addNewPropertyTransition):
841         (JSC::Structure::removePropertyTransition):
842         (JSC::Structure::willStoreValueSlow):
843         (JSC::Structure::visitChildren):
844         * runtime/Structure.h:
845         (JSC::PropertyMapEntry::PropertyMapEntry):
846         * runtime/StructureInlines.h:
847         (JSC::Structure::get):
848         * runtime/VM.cpp:
849         (JSC::VM::VM):
850         * runtime/VM.h:
851
852 2019-01-15  Tomas Popela  <tpopela@redhat.com>
853
854         Unreviewed: Fix the -Wformat compiler warnings
855
856         * jsc.cpp:
857         (jscmain):
858
859 2019-01-15  Caio Lima  <ticaiolima@gmail.com>
860
861         DFGByteCodeParser rules for bitwise operations should consider type of their operands
862         https://bugs.webkit.org/show_bug.cgi?id=192966
863
864         Reviewed by Yusuke Suzuki.
865
866         This patch is changing the logic how we lower bitwise operations, to
867         consider only the type of input nodes and fix them during FixupPhase,
868         if necessary. We are also changing the prediction propagation rules
869         for ValueBitOp to use `getHeapPrediction()`. 
870
871         * dfg/DFGBackwardsPropagationPhase.cpp:
872         (JSC::DFG::BackwardsPropagationPhase::isWithinPowerOfTwo):
873         (JSC::DFG::BackwardsPropagationPhase::propagate):
874         * dfg/DFGByteCodeParser.cpp:
875         (JSC::DFG::ByteCodeParser::parseBlock):
876         * dfg/DFGFixupPhase.cpp:
877         (JSC::DFG::FixupPhase::fixupNode):
878         * dfg/DFGNode.h:
879         (JSC::DFG::Node::hasInt32Result):
880         (JSC::DFG::Node::hasNumberOrAnyIntResult):
881         (JSC::DFG::Node::hasHeapPrediction):
882         * dfg/DFGPredictionPropagationPhase.cpp:
883
884 2019-01-15  Joseph Pecoraro  <pecoraro@apple.com>
885
886         Web Inspector: Generate the DOMDebugger domain for Augmenting Agents (ObjC protocol)
887         https://bugs.webkit.org/show_bug.cgi?id=193409
888         <rdar://problem/44349411>
889
890         Reviewed by Devin Rousso.
891
892         * inspector/scripts/codegen/objc_generator.py:
893         (ObjCGenerator):
894         Generate DOMDebugger domain ObjC interfaces.
895
896 2019-01-15  Devin Rousso  <drousso@apple.com>
897
898         Web Inspector: Audit: create new IDL type for exposing special functionality in test context
899         https://bugs.webkit.org/show_bug.cgi?id=193149
900         <rdar://problem/46801218>
901
902         Reviewed by Joseph Pecoraro.
903
904         Create a new `AuditAgent` (and various subclasses for different inspection targets)
905
906         * inspector/protocol/Audit.json: Added.
907         Add a `run` command that is a simpler version of `Runtime.evaluate`, except that it expects
908         a function string instead of an arbitrary JavaScript expression.
909         Add `setup` and `teardown` commands that create a JavaScript object that will be passed in
910         to the test as an argument. Keep this object alive so that tests can add to the object and
911         have later tests use what was added.
912
913         * inspector/agents/InspectorAuditAgent.h: Added.
914         * inspector/agents/InspectorAuditAgent.cpp: Added.
915         (Inspector::InspectorAuditAgent::InspectorAuditAgent):
916         (Inspector::InspectorAuditAgent::didCreateFrontendAndBackend):
917         (Inspector::InspectorAuditAgent::willDestroyFrontendAndBackend):
918         (Inspector::InspectorAuditAgent::setup):
919         (Inspector::InspectorAuditAgent::run):
920         (Inspector::InspectorAuditAgent::teardown):
921         (Inspector::InspectorAuditAgent::hasActiveAudit):
922         (Inspector::InspectorAuditAgent::populateAuditObject):
923
924         * inspector/agents/JSGlobalObjectAuditAgent.h: Added.
925         * inspector/agents/JSGlobalObjectAuditAgent.cpp: Added.
926         (Inspector::JSGlobalObjectAuditAgent::JSGlobalObjectAuditAgent):
927         (Inspector::JSGlobalObjectAuditAgent::injectedScriptForEval):
928
929         * inspector/JSGlobalObjectInspectorController.h:
930         * inspector/JSGlobalObjectInspectorController.cpp:
931         (Inspector::JSGlobalObjectInspectorController::JSGlobalObjectInspectorController):
932         (Inspector::JSGlobalObjectInspectorController::connectFrontend):
933         (Inspector::JSGlobalObjectInspectorController::jsAgentContext): Added.
934         (Inspector::JSGlobalObjectInspectorController::createLazyAgents): Added.
935
936         * inspector/InjectedScript.h:
937         * inspector/InjectedScript.cpp:
938         (Inspector::InjectedScript::execute): Added.
939         (Inspector::InjectedScript::arrayFromVector): Added.
940         Create a version of `evaluate` that accepts a list of values to be passed in as arguments
941         to the function that was created by the `eval` of the given `functionString`.
942
943         * inspector/InjectedScriptSource.js:
944         (InjectedScript.prototype.execute): Added.
945         (InjectedScript.prototype.evaluate):
946         (InjectedScript.prototype.evaluateOnCallFrame):
947         (InjectedScript.prototype._evaluateAndWrap):
948         (InjectedScript.prototype._wrapAndSaveCall): Added.
949         (InjectedScript.prototype._wrapCall): Added.
950         (InjectedScript.prototype._evaluateOn):
951         Refactor the `eval` and `saveResult` logic to allow for more flexibility for other callers.
952
953         * CMakeLists.txt:
954         * DerivedSources-input.xcfilelist:
955         * DerivedSources.make:
956         * JavaScriptCore.xcodeproj/project.pbxproj:
957         * Sources.txt:
958         * UnifiedSources-input.xcfilelist:
959
960 2019-01-14  Michael Saboff  <msaboff@apple.com>
961
962         Add option to JSC to dump memory footprint on script completion
963         https://bugs.webkit.org/show_bug.cgi?id=193422
964
965         Reviewed by Mark Lam.
966
967         Added the --footprint option to dump peak and current memory usage.  This uses the same
968         OS calls added in r2362362.
969
970         * jsc.cpp:
971         (printUsageStatement):
972         (CommandLine::parseArguments):
973         (jscmain):
974
975 2019-01-14  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
976
977         [JSC] AI should check the given constant's array type when folding GetByVal into constant
978         https://bugs.webkit.org/show_bug.cgi?id=193413
979         <rdar://problem/46092389>
980
981         Reviewed by Keith Miller.
982
983         If GetByVal's DFG::ArrayMode's type is Array::Double, we expect that the result of GetByVal is Double, since we already performed CheckStructure or CheckArray
984         to ensure this array type. But this assumption on the given value becomes wrong in AI, since CheckStructure may not perform filtering. And the proven AbstractValue
985         in GetByVal would not be expected one.
986
987         We have the graph before performing constant folding.
988
989         53:<!0:->     GetLocal(Check:Untyped:@77, JS|MustGen|UseAsOther, Array, arg2(C<Array>/FlushedCell), R:Stack(7), bc#37, ExitValid)  predicting Array
990         54:< 1:->     JSConstant(JS|PureNum|UseAsOther|UseAsInt|ReallyWantsInt, BoolInt32, Int32: 0, bc#37, ExitValid)
991         93:<!0:->     CheckStructure(Cell:@53, MustGen, [%C7:Array], R:JSCell_structureID, Exits, bc#37, ExitValid)
992         94:< 1:->     GetButterfly(Check:Cell:@53, Storage|PureInt, R:JSObject_butterfly, Exits, bc#37, ExitValid)
993         55:<!0:->     GetByVal(Check:KnownCell:@53, Check:Int32:@54, Check:Untyped:@94, Double|MustGen|VarArgs|PureInt, AnyIntAsDouble|NonIntAsdouble, Double+OriginalCopyOnWriteArray+SaneChain+AsIs+Read, R:Butterfly_publicLength,IndexedDoubleProperties, Exits, bc#37, ExitValid)  predicting StringIdent|NonIntAsdouble
994
995         And 53 is converted to JSConstant in the constant folding. It leads to constant folding attempt in GetByVal.
996
997         53:< 1:->     JSConstant(JS|UseAsOther, Array, Weak:Object: 0x117fb4370 with butterfly 0x8000e4050 (Structure %BV:Array), StructureID: 104, bc#37, ExitValid)
998         54:< 1:->     JSConstant(JS|PureNum|UseAsOther|UseAsInt|ReallyWantsInt, BoolInt32, Int32: 0, bc#37, ExitValid)
999         93:<!0:->     CheckStructure(Cell:@53, MustGen, [%C7:Array], R:JSCell_structureID, Exits, bc#37, ExitValid)
1000         94:< 1:->     GetButterfly(Check:Cell:@53, Storage|PureInt, R:JSObject_butterfly, Exits, bc#37, ExitValid)
1001         55:<!0:->     GetByVal(Check:KnownCell:@53, Check:Int32:@54, Check:Untyped:@94, Double|MustGen|VarArgs|PureInt, AnyIntAsDouble|NonIntAsdouble, Double+OriginalCopyOnWriteArray+SaneChain+AsIs+Read, R:Butterfly_publicLength,IndexedDoubleProperties, Exits, bc#37, ExitValid)  predicting StringIdent|NonIntAsdouble
1002
1003         GetByVal gets constant Array from @53, and attempt to perform constant folding by leverating CoW state: if the given array's butterfly is CoW and we performed CoW array check for this GetByVal, the array would not be changed as long as the check works.
1004         However, CheckStructure for @53 does not filter anything at AI. So, if @53 is CopyOnWrite | Contiguous array (not CopyOnWrite | Double array!), GetByVal will get a JSValue. But it does not meet the requirement of GetByVal since it has Double Array mode, and says it returns Double.
1005         Here, CheckStructure is valid because structure of the constant object would be changed. What we should do is additional CoW & ArrayShape check in GetByVal when folding since this node leverages CoW's interesting feature,
1006         "If CoW array check (CheckStructure etc.) is emitted by GetByVal's DFG::ArrayMode, the content is not changed from the creation!".
1007
1008         This patch adds ArrayShape check in addition to CoW status check in GetByVal.
1009
1010         Unfortunately, this crash is very flaky. In the above case, if @53 stays GetLocal after the constant folding phase, this issue does not occur. We can see this crash in r238109, but it is really hard to reproduce it in the current ToT.
1011         I verified this fix works in r238109 with the attached test.
1012
1013         * dfg/DFGAbstractInterpreterInlines.h:
1014         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
1015         * dfg/DFGAbstractValue.cpp:
1016         (JSC::DFG::AbstractValue::fixTypeForRepresentation):
1017
1018 2019-01-14  Caio Lima  <ticaiolima@gmail.com>
1019
1020         [BigInt] Literal parsing is crashing when used inside a Object Literal
1021         https://bugs.webkit.org/show_bug.cgi?id=193404
1022
1023         Reviewed by Yusuke Suzuki.
1024
1025         Former implementation was relying into token.m_data.radix after the
1026         call of `next()` into Parser.cpp. This is not safe because next
1027         clobbers token.m_data.radix in some cases (e.g is CLOSEBRACE).
1028         Now we get radix value before calling `next()` into parser and store
1029         in a local variable.
1030
1031         * parser/Parser.cpp:
1032         (JSC::Parser<LexerType>::parsePrimaryExpression):
1033
1034 2019-01-14  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
1035
1036         [JSC] Do not use asArrayModes() with Structures because it discards TypedArray information
1037         https://bugs.webkit.org/show_bug.cgi?id=193372
1038
1039         Reviewed by Saam Barati.
1040
1041         When RegisteredStructureSet is filtered with AbstractValue, we use structure, SpeculationType, and ArrayModes.
1042         However, we use asArrayModes() function with IndexingMode to compute the ArrayModes in AbstractValue. This is
1043         wrong since this discards TypedArray ArrayModes. As a result, if RegisteredStructureSet with TypedArrays is
1044         filtered with ArrayModes of AbstractValue populated from TypedArrays, we filter all the structures out since
1045         AbstractValue's ArrayModes become NonArray, which is wrong with the TypedArrays' ArrayModes. This leads to
1046         incorrect FTL code generation with MultiGetByOffset etc. nodes because,
1047
1048         1. AI think that this MultiGetByOffset never succeeds since all the values of RegisteredStructureSet are filtered out by the AbstractValue.
1049         2. AI says the state of MultiGetByOffset is invalid since AI think it never succeeds.
1050         3. So subsequent code becomes FTL crash code since AI think the execution should do OSR exit.
1051         4. Then, FTL emits the code for MultiGetByOffset, and emits crash after that.
1052         5. But in reality, the incoming value can match to the one of the RegisteredStructureSet value since (1)'s structures are incorrectly filtered by the incorrect ArrayModes.
1053         6. Then, the execution goes on, and falls into the FTL crash.
1054
1055         This patch fixes the incorrect ArrayModes calculation by the following changes
1056
1057         1. Rename asArrayModes to asArrayModesIgnoringTypedArrays.
1058         2. Fix incorrect asArrayModesIgnoringTypedArrays use in our code. Use arrayModesFromStructure instead.
1059         3. Fix OSR exit code which stores incorrect ArrayModes to the profiles.
1060
1061         * bytecode/ArrayProfile.cpp:
1062         (JSC::dumpArrayModes):
1063         (JSC::ArrayProfile::computeUpdatedPrediction):
1064         * bytecode/ArrayProfile.h:
1065         (JSC::asArrayModesIgnoringTypedArrays):
1066         (JSC::arrayModesFromStructure):
1067         (JSC::arrayModesIncludeIgnoringTypedArrays):
1068         (JSC::shouldUseSlowPutArrayStorage):
1069         (JSC::shouldUseFastArrayStorage):
1070         (JSC::shouldUseContiguous):
1071         (JSC::shouldUseDouble):
1072         (JSC::shouldUseInt32):
1073         (JSC::asArrayModes): Deleted.
1074         (JSC::arrayModeFromStructure): Deleted.
1075         (JSC::arrayModesInclude): Deleted.
1076         * dfg/DFGAbstractValue.cpp:
1077         (JSC::DFG::AbstractValue::observeTransitions):
1078         (JSC::DFG::AbstractValue::set):
1079         (JSC::DFG::AbstractValue::mergeOSREntryValue):
1080         (JSC::DFG::AbstractValue::contains const):
1081         * dfg/DFGAbstractValue.h:
1082         (JSC::DFG::AbstractValue::observeTransition):
1083         (JSC::DFG::AbstractValue::validate const):
1084         (JSC::DFG::AbstractValue::observeIndexingTypeTransition):
1085         * dfg/DFGArrayMode.cpp:
1086         (JSC::DFG::ArrayMode::fromObserved):
1087         (JSC::DFG::ArrayMode::alreadyChecked const):
1088         * dfg/DFGArrayMode.h:
1089         (JSC::DFG::ArrayMode::structureWouldPassArrayModeFiltering):
1090         (JSC::DFG::ArrayMode::arrayModesThatPassFiltering const):
1091         (JSC::DFG::ArrayMode::arrayModesWithIndexingShape const):
1092         * dfg/DFGOSRExit.cpp:
1093         (JSC::DFG::OSRExit::executeOSRExit):
1094         (JSC::DFG::OSRExit::compileExit):
1095         * dfg/DFGRegisteredStructureSet.cpp:
1096         (JSC::DFG::RegisteredStructureSet::filterArrayModes):
1097         (JSC::DFG::RegisteredStructureSet::arrayModesFromStructures const):
1098         * ftl/FTLOSRExitCompiler.cpp:
1099         (JSC::FTL::compileStub):
1100         * jit/JITInlines.h:
1101         (JSC::JIT::chooseArrayMode):
1102         (JSC::arrayProfileSaw): Deleted.
1103         * runtime/JSType.h:
1104         (JSC::isTypedArrayType):
1105
1106 2019-01-14  Mark Lam  <mark.lam@apple.com>
1107
1108         Re-enable ability to build --cloop builds.
1109         https://bugs.webkit.org/show_bug.cgi?id=192955
1110         <rdar://problem/46882363>
1111
1112         Reviewed by Saam barati and Keith Miller.
1113
1114         * Configurations/FeatureDefines.xcconfig:
1115
1116 2019-01-14  Mark Lam  <mark.lam@apple.com>
1117
1118         Fix all CLoop JSC test failures (including some LLInt bugs due to recent bytecode format change).
1119         https://bugs.webkit.org/show_bug.cgi?id=193402
1120         <rdar://problem/46012309>
1121
1122         Reviewed by Keith Miller.
1123
1124         The CLoop builds via build-jsc were previously completely disabled after our
1125         change to enable ASM LLInt build without the JIT.  As a result, JSC tests have
1126         regressed on CLoop builds.  The CLoop builds and tests will be re-enabled when
1127         the fix for https://bugs.webkit.org/show_bug.cgi?id=192955 lands.  This patch
1128         fixes all the regressions (and some old bugs) so that the CLoop test bots won't
1129         be red when CLoop build gets re-enabled.
1130
1131         In this patch, we do the following:
1132
1133         1. Change CLoopStack::grow() to set the new CLoop stack top at the maximum
1134            allocated capacity (after discounting the reserved zone) as opposed to setting
1135            it only at the level that the client requested.
1136
1137            This fixes a small performance bug that I happened to noticed when I was
1138            debugging a stack issue.  It does not affect correctness.
1139
1140         2. In LowLevelInterpreter32_64.asm:
1141
1142            1. Fix loadConstantOrVariableTag() to use subi for computing the constant
1143               index because the VirtualRegister offset and FirstConstantRegisterIndex
1144               values it is operating on are both signed ints.  This is just to be
1145               pedantic.  The previous use of subu will still produce a correct value.
1146
1147            2. Fix llintOpWithReturn() to use getu (instead of get) for reading
1148               OpIsCellWithType::type because it is of type JSType, which is a uint8_t.
1149
1150            3. Fix llintOpWithMetadata() to use loadis for loading
1151               OpGetById::Metadata::modeMetadata.protoLoadMode.cachedOffset[t5] because it
1152               is of type PropertyOffset, which is a signed int.
1153
1154            4. Fix commonCallOp() to use getu for loading fields argv and argc because they
1155               are  of type unsigned for OpCall, OpConstruct, and OpTailCall, which are the
1156               clients of commonCallOp.
1157
1158            5. Fix llintOpWithMetadata() and getClosureVar() to use loadp for loading
1159               OpGetFromScope::Metadata::operand because it is of type uintptr_t.
1160
1161         3. In LowLevelInterpreter64.asm:
1162
1163            1. Fix llintOpWithReturn() to use getu for reading OpIsCellWithType::type
1164               because it is of type JSType, which is a uint8_t.
1165
1166            2. Fix llintOpWithMetadata() to use loadi for loading
1167               OpGetById::Metadata::modeMetadata.protoLoadMode.structure[t2] because it is
1168               of type StructureID, which is a uint32_t.
1169
1170               Fix llintOpWithMetadata() to use loadis for loading
1171               OpGetById::Metadata::modeMetadata.protoLoadMode.cachedOffset[t2] because it
1172               is of type PropertyOffset, which is a signed int.
1173
1174            3. commonOp() should reload the metadataTable for op_catch because unlike
1175               for the ASM LLInt, the exception unwinding code is not able to restore
1176               "callee saved registers" for the CLoop interpreter because the CLoop uses
1177               pseudo-registers (see the CLoopRegister class).
1178
1179               This was the source of many exotic Cloop failures after the bytecode format
1180               change (which introduced the metadataTable callee saved register).  Hence,
1181               we fix it by reloading metadataTable's value on re-entry via op_catch for
1182               exception handling.  We already take care of restoring it in op_ret.
1183
1184            4. Fix llintOpWithMetadata() and getClosureVar() to use loadp for loading
1185               OpGetFromScope::Metadata::operand because it is of type uintptr_t.
1186
1187         4. In LowLevelInterpreter.asm:
1188
1189            Fix metadata() to use loadi for loading metadataTable offsets because they are
1190            of type unsigned.  This was also a source of many exotic CLoop test failures.
1191
1192         5. Change CLoopRegister into a class with a uintptr_t as its storage element.
1193            Previously, we were using a union to convert between various value types that
1194            we would store in this pseudo-register.  This method of type conversion is
1195            undefined behavior according to the C++ spec.  As a result, the C++ compiler
1196            may choose to elide some CLoop statements, thereby resulting in some exotic
1197            bugs.
1198
1199            We fix this by now always using accessor methods and assignment operators to
1200            ensure that we use bitwise_cast to do the type conversions.  Since bitwise_cast
1201            uses a memcpy, this ensures that there's no undefined behavior, and that CLoop
1202            statements won't get elided willy-nilly by the compiler.
1203
1204            Ditto for the CloopDobleRegisters.
1205
1206            Similarly, use bitwise_cast for ints2Double() and double2Ints() utility
1207            functions.
1208
1209            Also use bitwise_cast (instead of reinterpret_cast) for the CLoop CAST macro.
1210
1211         6. Fix cloop.rb to use the new CLoopRegister and CLoopDoubleRegister classes.
1212
1213            Add a clLValue accessor for offlineasm operand types to distinguish
1214            LValue use of the operands from RValue uses.
1215
1216            Replace the use of clearHighWord() with simply casting to uint32_t.  This is
1217            more efficient for the C++ compiler (and help speed up debug build runs).
1218
1219            Also fix 32-bit arithmetic operations to only set the lower 32-bit value of
1220            the pseudo registers.  This fixes some CLoop JSC test failures.
1221
1222         This patch has been manually tested with the JSC tests on the following builds:
1223         64bit X86 ASM LLLint (without JIT), 64bit and 32bit X86 CLoop, and ARMv7 Cloop.
1224
1225         * interpreter/CLoopStack.cpp:
1226         (JSC::CLoopStack::grow):
1227         * llint/LowLevelInterpreter.asm:
1228         * llint/LowLevelInterpreter.cpp:
1229         (JSC::CLoopRegister::i const):
1230         (JSC::CLoopRegister::u const):
1231         (JSC::CLoopRegister::i32 const):
1232         (JSC::CLoopRegister::u32 const):
1233         (JSC::CLoopRegister::i8 const):
1234         (JSC::CLoopRegister::u8 const):
1235         (JSC::CLoopRegister::ip const):
1236         (JSC::CLoopRegister::i8p const):
1237         (JSC::CLoopRegister::vp const):
1238         (JSC::CLoopRegister::cvp const):
1239         (JSC::CLoopRegister::callFrame const):
1240         (JSC::CLoopRegister::execState const):
1241         (JSC::CLoopRegister::instruction const):
1242         (JSC::CLoopRegister::vm const):
1243         (JSC::CLoopRegister::cell const):
1244         (JSC::CLoopRegister::protoCallFrame const):
1245         (JSC::CLoopRegister::nativeFunc const):
1246         (JSC::CLoopRegister::i64 const):
1247         (JSC::CLoopRegister::u64 const):
1248         (JSC::CLoopRegister::encodedJSValue const):
1249         (JSC::CLoopRegister::opcode const):
1250         (JSC::CLoopRegister::operator ExecState*):
1251         (JSC::CLoopRegister::operator const Instruction*):
1252         (JSC::CLoopRegister::operator JSCell*):
1253         (JSC::CLoopRegister::operator ProtoCallFrame*):
1254         (JSC::CLoopRegister::operator Register*):
1255         (JSC::CLoopRegister::operator VM*):
1256         (JSC::CLoopRegister::operator=):
1257         (JSC::CLoopRegister::bitsAsDouble const):
1258         (JSC::CLoopRegister::bitsAsInt64 const):
1259         (JSC::CLoopDoubleRegister::operator T const):
1260         (JSC::CLoopDoubleRegister::d const):
1261         (JSC::CLoopDoubleRegister::bitsAsInt64 const):
1262         (JSC::CLoopDoubleRegister::operator=):
1263         (JSC::LLInt::ints2Double):
1264         (JSC::LLInt::double2Ints):
1265         (JSC::LLInt::decodeResult):
1266         (JSC::CLoop::execute):
1267         (JSC::LLInt::Ints2Double): Deleted.
1268         (JSC::LLInt::Double2Ints): Deleted.
1269         (JSC::CLoopRegister::CLoopRegister): Deleted.
1270         (JSC::CLoopRegister::clearHighWord): Deleted.
1271         * llint/LowLevelInterpreter32_64.asm:
1272         * llint/LowLevelInterpreter64.asm:
1273         * offlineasm/cloop.rb:
1274
1275 2019-01-14  Keith Miller  <keith_miller@apple.com>
1276
1277         JSC should have a module loader API
1278         https://bugs.webkit.org/show_bug.cgi?id=191121
1279
1280         Reviewed by Michael Saboff.
1281
1282         This patch adds a new delegate to JSContext that is called to fetch
1283         any resolved module. The resolution of a module identifier is computed
1284         as if it were a URL on the web with the caveat that it must be a file URL.
1285
1286         A new class JSScript has also been added that is similar to JSScriptRef.
1287         Right now all JSScripts are copied into memory. In the future we should
1288         mmap the provided file into memory so the OS can evict it to disk under
1289         pressure. Additionally, the API does not make use of the code signing path
1290         nor the bytecode caching path, which we will add in subsequent patches.
1291
1292         Lastly, a couple of new convenience methods have been added. C API
1293         conversion, can now toRef a JSValue with just a vm rather than
1294         requiring an ExecState. Secondly, there is now a call wrapper that
1295         does not require CallData and CallType since many places don't
1296         care about this.
1297
1298         * API/APICast.h:
1299         (toRef):
1300         * API/JSAPIGlobalObject.cpp: Copied from Source/JavaScriptCore/API/JSVirtualMachineInternal.h.
1301         * API/JSAPIGlobalObject.h: Added.
1302         (JSC::JSAPIGlobalObject::create):
1303         (JSC::JSAPIGlobalObject::createStructure):
1304         (JSC::JSAPIGlobalObject::JSAPIGlobalObject):
1305         * API/JSAPIGlobalObject.mm: Added.
1306         (JSC::JSAPIGlobalObject::moduleLoaderResolve):
1307         (JSC::JSAPIGlobalObject::moduleLoaderImportModule):
1308         (JSC::JSAPIGlobalObject::moduleLoaderFetch):
1309         (JSC::JSAPIGlobalObject::moduleLoaderCreateImportMetaProperties):
1310         * API/JSAPIValueWrapper.h:
1311         (JSC::jsAPIValueWrapper): Deleted.
1312         * API/JSContext.h:
1313         * API/JSContext.mm:
1314         (-[JSContext moduleLoaderDelegate]):
1315         (-[JSContext setModuleLoaderDelegate:]):
1316         * API/JSContextInternal.h:
1317         * API/JSContextPrivate.h:
1318         * API/JSContextRef.cpp:
1319         (JSGlobalContextCreateInGroup):
1320         * API/JSScript.h: Added.
1321         * API/JSScript.mm: Added.
1322         (+[JSScript scriptWithSource:inVirtualMachine:]):
1323         (fillBufferWithContentsOfFile):
1324         (+[JSScript scriptFromUTF8File:inVirtualMachine:withCodeSigning:andBytecodeCache:]):
1325         (getJSScriptSourceCode):
1326         * API/JSScriptInternal.h: Copied from Source/JavaScriptCore/API/JSVirtualMachineInternal.h.
1327         * API/JSValueInternal.h:
1328         * API/JSVirtualMachineInternal.h:
1329         * API/tests/testapi.mm:
1330         (+[JSContextFetchDelegate contextWithBlockForFetch:]):
1331         (-[JSContextFetchDelegate context:fetchModuleForIdentifier:withResolveHandler:andRejectHandler:]):
1332         (checkModuleCodeRan):
1333         (checkModuleWasRejected):
1334         (testFetch):
1335         (testFetchWithTwoCycle):
1336         (testFetchWithThreeCycle):
1337         (testLoaderResolvesAbsoluteScriptURL):
1338         (testLoaderRejectsNilScriptURL):
1339         (testLoaderRejectsFailedFetch):
1340         (testImportModuleTwice):
1341         (+[JSContextFileLoaderDelegate newContext]):
1342         (resolvePathToScripts):
1343         (-[JSContextFileLoaderDelegate context:fetchModuleForIdentifier:withResolveHandler:andRejectHandler:]):
1344         (testLoadBasicFile):
1345         (testObjectiveCAPI):
1346         * API/tests/testapiScripts/basic.js: Copied from Source/JavaScriptCore/API/JSVirtualMachineInternal.h.
1347         * JavaScriptCore.xcodeproj/project.pbxproj:
1348         * Sources.txt:
1349         * SourcesCocoa.txt:
1350         * config.h:
1351         * postprocess-headers.sh:
1352         * runtime/CallData.cpp:
1353         (JSC::call):
1354         * runtime/CallData.h:
1355         * runtime/Completion.cpp:
1356         (JSC::loadAndEvaluateModule):
1357         * runtime/Completion.h:
1358         * runtime/JSCast.h:
1359         (JSC::jsSecureCast):
1360         * runtime/JSGlobalObject.cpp:
1361         (JSC::createProxyProperty):
1362
1363 2019-01-14  Dominik Infuehr  <dinfuehr@igalia.com>
1364
1365         Fix property access on ARM with the baseline JIT
1366         https://bugs.webkit.org/show_bug.cgi?id=193393
1367
1368         Reviewed by Yusuke Suzuki.
1369
1370         Code was still using currentInstruction[4] to access the instruction's metadata.
1371         Updated to use metadata.getPutInfo and metadata.resolveType.
1372
1373         * jit/JITPropertyAccess32_64.cpp:
1374         (JSC::JIT::emit_op_resolve_scope):
1375         (JSC::JIT::emit_op_get_from_scope):
1376         (JSC::JIT::emit_op_put_to_scope):
1377
1378 2019-01-12  Timothy Hatcher  <timothy@apple.com>
1379
1380         Have prefers-color-scheme: light always match on macOS versions before Mojave.
1381         https://bugs.webkit.org/show_bug.cgi?id=191655
1382         rdar://problem/46074680
1383
1384         Reviewed by Megan Gardner.
1385
1386         * Configurations/FeatureDefines.xcconfig: ENABLE_DARK_MODE_CSS_macosx for all OS versions.
1387
1388 2019-01-12  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
1389
1390         Unreviewed, fix scope check assertions
1391         https://bugs.webkit.org/show_bug.cgi?id=193308
1392
1393         * bytecode/CodeBlock.cpp:
1394         (JSC::CodeBlock::notifyLexicalBindingShadowing):
1395         * runtime/JSGlobalObject.cpp:
1396         (JSC::JSGlobalObject::notifyLexicalBindingShadowing):
1397         * runtime/ProgramExecutable.cpp:
1398         (JSC::ProgramExecutable::initializeGlobalProperties):
1399
1400 2019-01-11  John Wilander  <wilander@apple.com>
1401
1402         Compile out Web API Statistics Collection
1403         https://bugs.webkit.org/show_bug.cgi?id=193370
1404         <rdar://problem/45388584>
1405
1406         Reviewed by Brent Fulgham.
1407
1408         * Configurations/FeatureDefines.xcconfig:
1409             Defined ENABLE_WEB_API_STATISTICS, off by default.
1410
1411 2019-01-11  Saam barati  <sbarati@apple.com>
1412
1413         DFG combined liveness can be wrong for terminal basic blocks
1414         https://bugs.webkit.org/show_bug.cgi?id=193304
1415         <rdar://problem/45268632>
1416
1417         Reviewed by Yusuke Suzuki.
1418
1419         If a block doesn't have any successors, it can't rely on the typical
1420         backwards liveness propagation that CombinedLiveness was doing. The phase
1421         first got what was live in bytecode and IR at the heads of each block. Then
1422         for each block, it made the live at tail the union of the live at head for
1423         each successor. For a terminal block though, this could be wrong. We could
1424         end up saying nothing is live even though many things may be live in bytecode.
1425         We must account for what's bytecode live at the end of the block. Consider a
1426         block that ends with:
1427         ```
1428         ForceOSRExit
1429         Unreachable
1430         ```
1431         
1432         Things may definitely be live in bytecode at the tail. However, we'll
1433         report nothing as being alive. This probably subtly breaks many analyses,
1434         but we have a test case of it breaking the interference analysis that
1435         the ArgumentsEliminationPhase performs.
1436
1437         * dfg/DFGBasicBlock.h:
1438         (JSC::DFG::BasicBlock::last const):
1439         * dfg/DFGCombinedLiveness.cpp:
1440         (JSC::DFG::addBytecodeLiveness):
1441         (JSC::DFG::liveNodesAtHead):
1442         (JSC::DFG::CombinedLiveness::CombinedLiveness):
1443         * dfg/DFGCombinedLiveness.h:
1444
1445 2019-01-11  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
1446
1447         [JSC] Global lexical bindings can shadow global variables if it is `configurable = true`
1448         https://bugs.webkit.org/show_bug.cgi?id=193308
1449         <rdar://problem/45546542>
1450
1451         Reviewed by Saam Barati.
1452
1453         Previously, we assumed that lexical bindings in JSGlobalLexicalEnvironment cannot shadow existing global properties.
1454         However, it is wrong. According to the spec, we can shadow global properties if a property's attribute is configurable = true.
1455         For example, we execute two scripts.
1456
1457         script1.js
1458
1459             bar = 42;
1460             function load() { return bar; }
1461             print(bar); // 42
1462             print(load()); // 42
1463
1464         script2.js
1465
1466             let bar = 0; // This lexical binding can shadow the global.bar defined in script1.js
1467             print(bar); // 0
1468             print(load()); // 0
1469
1470         In JSC, we cache GlobalProperty resolve type and its associated information in op_resolve_type, op_get_from_scope, and op_put_to_scope.
1471         They attempt to load a property from JSGlobalObject directly. However, once the newly added lexical binding starts shadowing this, our existing instructions
1472         become invalid since they do not respect JSGlobalLexicalEnvironment.
1473
1474         In this patch, we fix this issue by introducing the following mechanisms.
1475
1476         1. We have a HashMap<property name, watchpoint set> in JSGlobalObject. DFG and FTL create a watchpoint set with the property name if the generated code
1477         depends on GlobalProperty condition of op_resolve_scope etc. These watchpoint will be fired when the shadowing happens, so that our generated DFG and FTL
1478         code will be invalidated if it depends on the condition which is no longer valid.
1479
1480         2. When we detect shadowing, we iterate all the live CodeBlocks which globalObject is the target one. And we rewrite instructions in them from GlobalProperty
1481         to GlobalLexicalVar (or Dynamic precisely). So, the subsequent LLInt code just works well. "Dynamic" conversion happens when your op_put_to_scope attempts to
1482         put a value onto a const lexical binding. This fails and it should throw a type error.
1483
1484         3. GlobalProperty scope operations in Baseline JIT start checking ResolveType in metadata, and emit code for GlobalProperty and GlobalLexicalVar. Once the rewrite
1485         happens, baseline JIT continues working because it checks the rewritten metadata's ResolveType.
1486
1487         We use this mechanism (which is similar to haveABadTime() thing) because,
1488
1489         1. Shadowing should be super rare. Before r214145, we made these cases as SytaxError. Thus, before r214145, this type of code cannot be executed in WebKit.
1490         And the number of the live CodeBlocks for the given JSGlobalObject should be small. This supports introducing rather simple (but not so efficient) mechanism
1491         instead of the complicated one.
1492
1493         2. Rewriting instructions immediately forces GlobalProperty => GlobalLexicalVar / Dynamic conversion in all the possible CodeBlock. This allows us to avoid
1494         compilation failure loop in DFG and FTL: DFG and FTL codes are invalidated by the watchpoint, but we may attempt to compile the code with the invalidated watchpoint
1495         and GlobalProperty status if we do not rewrite it. One possible other implementation is having and checking a counter in instruction, and every time we introduce
1496         a new shadow binding, bump the counter. And eventually executed instruction will go to the slow path and rewrite itself. However, this way leaves the not-executed-again-yet
1497         instructions as is, and DFG and FTL repeatedly fail to compile if we just watch the invalidated watchpoint for that. Rewriting all the existing GlobalProperty immediately
1498         avoids this situation easily.
1499
1500         * JavaScriptCore.xcodeproj/project.pbxproj:
1501         * Sources.txt:
1502         * bytecode/CodeBlock.cpp:
1503         (JSC::CodeBlock::notifyLexicalBindingShadowing):
1504         * bytecode/CodeBlock.h:
1505         (JSC::CodeBlock::scriptMode const):
1506         * bytecode/Watchpoint.h:
1507         (JSC::WatchpointSet::create):
1508         * dfg/DFGByteCodeParser.cpp:
1509         (JSC::DFG::ByteCodeParser::parseBlock):
1510         * dfg/DFGDesiredGlobalProperties.cpp: Added.
1511         (JSC::DFG::DesiredGlobalProperties::isStillValidOnMainThread):
1512         (JSC::DFG::DesiredGlobalProperties::reallyAdd):
1513         * dfg/DFGDesiredGlobalProperties.h: Added.
1514         (JSC::DFG::DesiredGlobalProperties::addLazily):
1515         We need this DesiredGlobalProperties mechanism since we do not want to ref() the UniquedStringImpl in DFG and FTL thread.
1516         We keep JSGlobalObject* and identifierNumber, and materialize WatchpointSets for each JSGlobalObject's property referenced
1517         from DFG and FTL and inject CodeBlock jettison watchpoints in the main thread.
1518         * dfg/DFGDesiredGlobalProperty.h: Added.
1519         (JSC::DFG::DesiredGlobalProperty::DesiredGlobalProperty):
1520         (JSC::DFG::DesiredGlobalProperty::globalObject const):
1521         (JSC::DFG::DesiredGlobalProperty::identifierNumber const):
1522         (JSC::DFG::DesiredGlobalProperty::operator== const):
1523         (JSC::DFG::DesiredGlobalProperty::operator!= const):
1524         (JSC::DFG::DesiredGlobalProperty::isHashTableDeletedValue const):
1525         (JSC::DFG::DesiredGlobalProperty::hash const):
1526         (JSC::DFG::DesiredGlobalProperty::dumpInContext const):
1527         (JSC::DFG::DesiredGlobalProperty::dump const):
1528         (JSC::DFG::DesiredGlobalPropertyHash::hash):
1529         (JSC::DFG::DesiredGlobalPropertyHash::equal):
1530         * dfg/DFGGraph.h:
1531         (JSC::DFG::Graph::globalProperties):
1532         * dfg/DFGPlan.cpp:
1533         (JSC::DFG::Plan::reallyAdd):
1534         (JSC::DFG::Plan::isStillValidOnMainThread):
1535         (JSC::DFG::Plan::finalizeWithoutNotifyingCallback):
1536         (JSC::DFG::Plan::cancel):
1537         * dfg/DFGPlan.h:
1538         (JSC::DFG::Plan::globalProperties):
1539         * jit/JITPropertyAccess.cpp:
1540         (JSC::JIT::emit_op_resolve_scope):
1541         (JSC::JIT::emit_op_get_from_scope):
1542         (JSC::JIT::emit_op_put_to_scope):
1543         * jit/JITPropertyAccess32_64.cpp:
1544         (JSC::JIT::emit_op_resolve_scope):
1545         (JSC::JIT::emit_op_get_from_scope):
1546         (JSC::JIT::emit_op_put_to_scope):
1547         * runtime/JSGlobalObject.cpp:
1548         (JSC::JSGlobalObject::addStaticGlobals):
1549         (JSC::JSGlobalObject::notifyLexicalBindingShadowing):
1550         (JSC::JSGlobalObject::getReferencedPropertyWatchpointSet):
1551         (JSC::JSGlobalObject::ensureReferencedPropertyWatchpointSet):
1552         * runtime/JSGlobalObject.h:
1553         * runtime/ProgramExecutable.cpp:
1554         (JSC::hasRestrictedGlobalProperty):
1555         (JSC::ProgramExecutable::initializeGlobalProperties):
1556
1557 2019-01-11  Dominik Infuehr  <dinfuehr@igalia.com>
1558
1559         Enable DFG on ARM/Linux again
1560         https://bugs.webkit.org/show_bug.cgi?id=192496
1561
1562         Reviewed by Yusuke Suzuki.
1563
1564         After changing the bytecode format DFG was disabled on all 32-bit
1565         architectures. Enable DFG now again on ARM/Linux. Do not use register
1566         r11 in compiled DFG mode since it is already used in LLInt as metadataTable
1567         register. Also clean up code since ARM traditional isn't supported anymore.
1568
1569         * dfg/DFGOSRExit.cpp:
1570         (JSC::DFG::restoreCalleeSavesFromVMEntryFrameCalleeSavesBuffer):
1571         (JSC::DFG::copyCalleeSavesToVMEntryFrameCalleeSavesBuffer):
1572         * jit/CallFrameShuffler.cpp:
1573         (JSC::CallFrameShuffler::CallFrameShuffler):
1574         * jit/GPRInfo.h:
1575         (JSC::GPRInfo::toIndex):
1576         * llint/LowLevelInterpreter32_64.asm:
1577         * offlineasm/arm.rb:
1578
1579 2019-01-10  Brian Burg  <bburg@apple.com>
1580
1581         Web Inspector: incorrect type signature used for protocol enums in async command results
1582         https://bugs.webkit.org/show_bug.cgi?id=193331
1583
1584         Reviewed by Devin Rousso.
1585
1586         When an enum is returned by an async command, the type signature should be that of the
1587         Inspector::Protocol::* generated enum, rather than the underlying primitive type (i.e., String).
1588
1589         * inspector/scripts/codegen/cpp_generator.py:
1590         (CppGenerator.cpp_type_for_formal_async_parameter):
1591         * inspector/scripts/tests/generic/expected/commands-with-async-attribute.json-result:
1592         Rebaseline generator test results.
1593
1594 2019-01-10  Brian Burg  <bburg@apple.com>
1595
1596         Rebaseline inspector generator test results after recent changes.
1597
1598         Unreviewed test gardening.
1599
1600         * inspector/scripts/tests/generic/expected/commands-with-async-attribute.json-result:
1601         * inspector/scripts/tests/generic/expected/commands-with-optional-call-return-parameters.json-result:
1602         * inspector/scripts/tests/generic/expected/fail-on-domain-availability-value.json-error:
1603
1604 2019-01-10  Commit Queue  <commit-queue@webkit.org>
1605
1606         Unreviewed, rolling out r239825.
1607         https://bugs.webkit.org/show_bug.cgi?id=193330
1608
1609         Broke tests on armv7/linux bots (Requested by guijemont on
1610         #webkit).
1611
1612         Reverted changeset:
1613
1614         "Enable DFG on ARM/Linux again"
1615         https://bugs.webkit.org/show_bug.cgi?id=192496
1616         https://trac.webkit.org/changeset/239825
1617
1618 2019-01-10  Dominik Infuehr  <dinfuehr@igalia.com>
1619
1620         Enable DFG on ARM/Linux again
1621         https://bugs.webkit.org/show_bug.cgi?id=192496
1622
1623         Reviewed by Yusuke Suzuki.
1624
1625         After changing the bytecode format DFG was disabled on all 32-bit
1626         architectures. Enable DFG now again on ARM/Linux. Do not use register
1627         r11 in compiled DFG mode since it is already used in LLInt as metadataTable
1628         register. Also clean up code since ARM traditional isn't supported anymore.
1629
1630         * dfg/DFGOSRExit.cpp:
1631         (JSC::DFG::restoreCalleeSavesFromVMEntryFrameCalleeSavesBuffer):
1632         (JSC::DFG::copyCalleeSavesToVMEntryFrameCalleeSavesBuffer):
1633         * jit/CallFrameShuffler.cpp:
1634         (JSC::CallFrameShuffler::CallFrameShuffler):
1635         * jit/GPRInfo.h:
1636         (JSC::GPRInfo::toIndex):
1637         * llint/LowLevelInterpreter32_64.asm:
1638         * offlineasm/arm.rb:
1639
1640 2019-01-09  Mark Lam  <mark.lam@apple.com>
1641
1642         Restore bytecode dumper's ability to dump jump target as offset#(->targetBytecodeIndex#).
1643         https://bugs.webkit.org/show_bug.cgi?id=193300
1644
1645         Reviewed by Saam Barati.
1646
1647         For example, instead of:
1648             [  95] jtrue              loc11, 9
1649         We can now again (as before the bytecode format rewrite) have:
1650             [  95] jtrue              loc11, 9(->104)
1651
1652         * bytecode/BytecodeDumper.cpp:
1653         (JSC::BytecodeDumper<Block>::printLocationAndOp):
1654         * bytecode/BytecodeDumper.h:
1655         (JSC::BytecodeDumper::dumpValue):
1656
1657 2019-01-09  Mark Lam  <mark.lam@apple.com>
1658
1659         Gigacage disabling checks should handle the GIGACAGE_ALLOCATION_CAN_FAIL case properly.
1660         https://bugs.webkit.org/show_bug.cgi?id=193292
1661         <rdar://problem/46485450>
1662
1663         Reviewed by Yusuke Suzuki.
1664
1665         * runtime/VM.h:
1666         (JSC::VM::gigacageAuxiliarySpace):
1667
1668 2019-01-08  Keith Miller  <keith_miller@apple.com>
1669
1670         builtins should be able to use async/await
1671         https://bugs.webkit.org/show_bug.cgi?id=193263
1672
1673         Reviewed by Saam Barati.
1674
1675         This patch makes it possible to use async functions when writing builtin JS code.
1676
1677         * Scripts/wkbuiltins/builtins_generator.py:
1678         (BuiltinsGenerator.generate_embedded_code_string_section_for_function):
1679         * Scripts/wkbuiltins/builtins_model.py:
1680         (BuiltinFunction.__init__):
1681         (BuiltinFunction.fromString):
1682         (BuiltinFunction.__str__):
1683         * builtins/BuiltinExecutables.cpp:
1684         (JSC::BuiltinExecutables::createExecutable):
1685         * builtins/ModuleLoader.js:
1686         (requestInstantiate):
1687         (async.loadModule):
1688         (async.loadAndEvaluateModule):
1689         (async.requestImportModule):
1690         (loadModule): Deleted.
1691         (): Deleted.
1692         (loadAndEvaluateModule): Deleted.
1693         * bytecompiler/BytecodeGenerator.cpp:
1694         (JSC::BytecodeGenerator::BytecodeGenerator):
1695         * parser/Parser.cpp:
1696         (JSC::Parser<LexerType>::parseInner):
1697
1698 2019-01-08  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
1699
1700         Array.prototype.flat/flatMap have a minor bug in ArraySpeciesCreate
1701         https://bugs.webkit.org/show_bug.cgi?id=193127
1702
1703         Reviewed by Saam Barati.
1704
1705         `== null` is frequently used idiom to check `null` or `undefined` in JS.
1706         However, it has a problem in terms of the builtin JS implementation: it
1707         returns true if masquerade-as-undefined objects (e.g. document.all) come.
1708
1709         In this patch, we introduce a convenient builtin intrinsic @isUndefinedOrNull,
1710         which is equivalent to C++ `JSValue::isUndefinedOrNull`. It does not consider
1711         about masquerade-as-undefined objects, so that we can use it instead of
1712         `value === null || value === @undefined`. We introduce is_undefined_or_null
1713         bytecode, IsUndefinedOrNull DFG node and its DFG and FTL backends. Since
1714         Null and Undefined have some bit patterns, we can implement this query
1715         very efficiently.
1716
1717         * builtins/ArrayIteratorPrototype.js:
1718         (next):
1719         * builtins/ArrayPrototype.js:
1720         (globalPrivate.arraySpeciesCreate):
1721         * builtins/GlobalOperations.js:
1722         (globalPrivate.speciesConstructor):
1723         (globalPrivate.copyDataProperties):
1724         (globalPrivate.copyDataPropertiesNoExclusions):
1725         * builtins/MapIteratorPrototype.js:
1726         (next):
1727         * builtins/SetIteratorPrototype.js:
1728         (next):
1729         * builtins/StringIteratorPrototype.js:
1730         (next):
1731         * builtins/StringPrototype.js:
1732         (match):
1733         (repeat):
1734         (padStart):
1735         (padEnd):
1736         (intrinsic.StringPrototypeReplaceIntrinsic.replace):
1737         (search):
1738         (split):
1739         (concat):
1740         (globalPrivate.createHTML):
1741         * builtins/TypedArrayPrototype.js:
1742         (globalPrivate.typedArraySpeciesConstructor):
1743         (map):
1744         (filter):
1745         * bytecode/BytecodeIntrinsicRegistry.h:
1746         * bytecode/BytecodeList.rb:
1747         * bytecode/BytecodeUseDef.h:
1748         (JSC::computeUsesForBytecodeOffset):
1749         (JSC::computeDefsForBytecodeOffset):
1750         * bytecompiler/BytecodeGenerator.cpp:
1751         (JSC::BytecodeGenerator::emitIsUndefinedOrNull):
1752         * bytecompiler/BytecodeGenerator.h:
1753         * bytecompiler/NodesCodegen.cpp:
1754         (JSC::BytecodeIntrinsicNode::emit_intrinsic_isUndefinedOrNull):
1755         * dfg/DFGAbstractInterpreterInlines.h:
1756         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
1757         * dfg/DFGByteCodeParser.cpp:
1758         (JSC::DFG::ByteCodeParser::parseBlock):
1759         * dfg/DFGCapabilities.cpp:
1760         (JSC::DFG::capabilityLevel):
1761         * dfg/DFGClobberize.h:
1762         (JSC::DFG::clobberize):
1763         * dfg/DFGDoesGC.cpp:
1764         (JSC::DFG::doesGC):
1765         * dfg/DFGFixupPhase.cpp:
1766         (JSC::DFG::FixupPhase::fixupNode):
1767         * dfg/DFGNodeType.h:
1768         * dfg/DFGPredictionPropagationPhase.cpp:
1769         * dfg/DFGSafeToExecute.h:
1770         (JSC::DFG::safeToExecute):
1771         * dfg/DFGSpeculativeJIT32_64.cpp:
1772         (JSC::DFG::SpeculativeJIT::compile):
1773         * dfg/DFGSpeculativeJIT64.cpp:
1774         (JSC::DFG::SpeculativeJIT::compile):
1775         * ftl/FTLCapabilities.cpp:
1776         (JSC::FTL::canCompile):
1777         * ftl/FTLLowerDFGToB3.cpp:
1778         (JSC::FTL::DFG::LowerDFGToB3::compileNode):
1779         (JSC::FTL::DFG::LowerDFGToB3::compileIsUndefinedOrNull):
1780         * jit/JIT.cpp:
1781         (JSC::JIT::privateCompileMainPass):
1782         * jit/JIT.h:
1783         * jit/JITOpcodes.cpp:
1784         (JSC::JIT::emit_op_is_undefined_or_null):
1785         * jit/JITOpcodes32_64.cpp:
1786         (JSC::JIT::emit_op_is_undefined_or_null):
1787         * llint/LowLevelInterpreter32_64.asm:
1788         * llint/LowLevelInterpreter64.asm:
1789
1790 2019-01-08  David Kilzer  <ddkilzer@apple.com>
1791
1792         Leak of VectorBufferBase.m_buffer (16-64 bytes) under JSC::CompactVariableEnvironment in com.apple.WebKit.WebContent running layout tests
1793         <https://webkit.org/b/193264>
1794         <rdar://problem/46651026>
1795
1796         Reviewed by Yusuke Suzuki.
1797
1798         * parser/VariableEnvironment.cpp:
1799         (JSC::CompactVariableMap::Handle::~Handle): Call delete on
1800         m_environment instead of fastFree() to make sure the destructors
1801         for the Vector instance variables are run.  This fixes the leaks
1802         because calling fastFree() would only free the
1803         CompactVariableEnvironment object, but not the heap-based
1804         buffers allocated for the Vector instance variables.
1805
1806 2019-01-08  Joseph Pecoraro  <pecoraro@apple.com>
1807
1808         ASSERT when paused in debugger and console evaluation causes exception
1809         https://bugs.webkit.org/show_bug.cgi?id=193246
1810
1811         Reviewed by Mark Lam.
1812
1813         * runtime/VM.cpp:
1814         (JSC::VM::throwException):
1815         Improve assertion to allow for the debugger's evaluate on call frame condition.
1816
1817         * runtime/JSGlobalObject.h:
1818         (JSC::JSGlobalObject::callFrameAtDebuggerEntry const):
1819         (JSC::JSGlobalObject::setCallFrameAtDebuggerEntry):
1820         Debugger call frame only used by assertions.
1821
1822         * debugger/DebuggerCallFrame.cpp:
1823         (JSC::DebuggerCallFrame::evaluateWithScopeExtension):
1824         * debugger/DebuggerEvalEnabler.h:
1825         (JSC::DebuggerEvalEnabler::DebuggerEvalEnabler):
1826         (JSC::DebuggerEvalEnabler::~DebuggerEvalEnabler):
1827         When evaluating on a call frame, set a debug GlobalObject state.
1828
1829 2019-01-08  Keith Miller  <keith_miller@apple.com>
1830
1831         Move JSValueMakeSymbol to private header
1832         https://bugs.webkit.org/show_bug.cgi?id=193254
1833
1834         Reviewed by Saam Barati.
1835
1836         When moving other functions in JSValueRef I guess I forgot to move this one.
1837
1838         * API/JSObjectRefPrivate.h:
1839         * API/JSValueRef.h:
1840
1841 2019-01-08  Mark Lam  <mark.lam@apple.com>
1842
1843         Fix some typos in comments.
1844
1845         Not reviewed.
1846
1847         * dfg/DFGIntegerRangeOptimizationPhase.cpp:
1848
1849 2019-01-08  Tadeu Zagallo  <tzagallo@apple.com>
1850
1851         LLInt put_by_id uses the wrong load instruction for loading flags from the metadata
1852         https://bugs.webkit.org/show_bug.cgi?id=193221
1853
1854         Reviewed by Mark Lam.
1855
1856         The flags are only 4 bytes, but were loaded with loadp. It used to work,
1857         since the flags were followed by a 4-byte padding, but it broke after the
1858         struct was compacted in r239626.
1859
1860         * llint/LowLevelInterpreter64.asm:
1861
1862 2019-01-07  Devin Rousso  <drousso@apple.com>
1863
1864         Web Inspector: extend XHR breakpoints to work with fetch
1865         https://bugs.webkit.org/show_bug.cgi?id=185843
1866         <rdar://problem/40431027>
1867
1868         Reviewed by Matt Baker.
1869
1870         * inspector/protocol/DOMDebugger.json:
1871         Rename `XHR` to `URL`.
1872
1873         * inspector/protocol/Debugger.json:
1874         Add `Fetch` to `reason` enum for the `Debugger.paused` event.
1875
1876 2019-01-07  Devin Rousso  <drousso@apple.com>
1877
1878         Web Inspector: Network: show secure connection details per-request
1879         https://bugs.webkit.org/show_bug.cgi?id=191539
1880         <rdar://problem/45979891>
1881
1882         Reviewed by Joseph Pecoraro.
1883
1884         * inspector/protocol/Security.json:
1885         Add `Connection` type.
1886
1887         * inspector/protocol/Network.json:
1888         Send `Security.Connection` information when request metrics become available.
1889
1890 2019-01-04  Tadeu Zagallo  <tzagallo@apple.com>
1891
1892         Baseline version of get_by_id may corrupt metadata
1893         https://bugs.webkit.org/show_bug.cgi?id=193085
1894         <rdar://problem/23453006>
1895
1896         Reviewed by Saam Barati.
1897
1898         The Baseline version of get_by_id unconditionally calls `emitArrayProfilingSiteForBytecodeIndexWithCell`
1899         if the property is `length`. However, since the bytecode rewrite, get_by_id only has an ArrayProfile entry
1900         in the metadata if its mode is `GetByIdMode::ArrayLength`. That might result in one of two bad things:
1901         1) get_by_id's mode is not ArrayLength, and a duplicate, out-of-line ArrayProfile entry will be created by
1902         `CodeBlock::getOrAddArrayProfile`.
1903         2) get_by_id's mode *is* ArrayLength and we generate the array profiling code pointing to the ArrayProfile
1904         that lives in the metadata table. This works fine as long as get_by_id does not change modes. If that happens,
1905         the JIT code will write into the metadata table, overwriting the 'GetByIdModeMetadata` for another mode.
1906
1907         Add a check to the Baseline version of get_by_id so that we only do the ArrayProfiling if the get_by_id's
1908         mode is ArrayLength
1909
1910         * bytecode/BytecodeList.rb:
1911         * bytecode/CodeBlock.cpp:
1912         (JSC::CodeBlock::getArrayProfile):
1913         (JSC::CodeBlock::addArrayProfile): Deleted.
1914         (JSC::CodeBlock::getOrAddArrayProfile): Deleted.
1915         * bytecode/CodeBlock.h:
1916         (JSC::CodeBlock::numberOfArrayProfiles const): Deleted.
1917         (JSC::CodeBlock::arrayProfiles): Deleted.
1918         * bytecode/CodeBlockInlines.h:
1919         (JSC::CodeBlock::forEachArrayProfile):
1920         * jit/JIT.h:
1921         * jit/JITInlines.h:
1922         (JSC::JIT::emitArrayProfilingSiteForBytecodeIndexWithCell): Deleted.
1923         * jit/JITPropertyAccess.cpp:
1924         (JSC::JIT::emit_op_get_by_id):
1925         * jit/JITPropertyAccess32_64.cpp:
1926         (JSC::JIT::emit_op_get_by_id):
1927         * llint/LLIntSlowPaths.cpp:
1928         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
1929
1930 2019-01-02  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
1931
1932         [JSC] Optimize Object.prototype.toString
1933         https://bugs.webkit.org/show_bug.cgi?id=193031
1934
1935         Reviewed by Saam Barati.
1936
1937         Object.prototype.toString is frequently used for type checking.
1938         It is called many times in wtb-lebab.js. This patch optimizes
1939         Object.prototype.toString by the following two optimizations.
1940
1941         1. We should emit code looking up cached to string in DFG and FTL.
1942
1943         toString's result is cached in the Structure. We emit a fast path code
1944         in DFG and FTL to lookup this cache.
1945
1946         2. We should not create objects for primitive values in major cases.
1947
1948         When Object.prototype.toString(primitive) is called, this primitive is converted
1949         to an object by calling ToObject. But if the result is appropriately cached in
1950         the Structure, we should get it in the fast path without creating this object.
1951         When converting primitives to objects, Structures used in these newly created objects
1952         are known (Structure for StringObject etc.). So we can first query the cached string
1953         before actually converting primitives to objects.
1954
1955         This patch improves wtb-lebab.js by roughly 2%.
1956
1957             before:    lebab:  8.90 runs/s
1958             after :    lebab:  9.09 runs/s
1959
1960         * JavaScriptCore.xcodeproj/project.pbxproj:
1961         * dfg/DFGAbstractInterpreterInlines.h:
1962         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
1963         * dfg/DFGByteCodeParser.cpp:
1964         (JSC::DFG::ByteCodeParser::handleIntrinsicCall):
1965         * dfg/DFGClobberize.h:
1966         (JSC::DFG::clobberize):
1967         * dfg/DFGDoesGC.cpp:
1968         (JSC::DFG::doesGC):
1969         * dfg/DFGFixupPhase.cpp:
1970         (JSC::DFG::FixupPhase::fixupNode):
1971         (JSC::DFG::FixupPhase::fixupObjectToString):
1972         * dfg/DFGNodeType.h:
1973         * dfg/DFGOperations.cpp:
1974         * dfg/DFGOperations.h:
1975         * dfg/DFGPredictionPropagationPhase.cpp:
1976         * dfg/DFGSafeToExecute.h:
1977         (JSC::DFG::safeToExecute):
1978         * dfg/DFGSpeculativeJIT.cpp:
1979         (JSC::DFG::SpeculativeJIT::compileObjectToString):
1980         * dfg/DFGSpeculativeJIT.h:
1981         * dfg/DFGSpeculativeJIT32_64.cpp:
1982         (JSC::DFG::SpeculativeJIT::compile):
1983         * dfg/DFGSpeculativeJIT64.cpp:
1984         (JSC::DFG::SpeculativeJIT::compile):
1985         * ftl/FTLAbstractHeapRepository.h:
1986         * ftl/FTLCapabilities.cpp:
1987         (JSC::FTL::canCompile):
1988         * ftl/FTLLowerDFGToB3.cpp:
1989         (JSC::FTL::DFG::LowerDFGToB3::compileNode):
1990         (JSC::FTL::DFG::LowerDFGToB3::compileObjectToString):
1991         * runtime/Intrinsic.cpp:
1992         (JSC::intrinsicName):
1993         * runtime/Intrinsic.h:
1994         * runtime/ObjectPrototype.cpp:
1995         (JSC::ObjectPrototype::finishCreation):
1996         (JSC::objectProtoFuncToString):
1997         * runtime/ObjectPrototype.h:
1998         * runtime/ObjectPrototypeInlines.h: Added.
1999         (JSC::structureForPrimitiveValue):
2000         (JSC::objectToString):
2001         * runtime/StructureRareData.h:
2002
2003 2019-01-03  Michael Saboff  <msaboff@apple.com>
2004
2005         DFG IntegerRangeOptimization phase exceeding loop limit shouldn't ASSERT
2006         https://bugs.webkit.org/show_bug.cgi?id=193094
2007
2008         Reviewed by Saam Barati.
2009
2010         Removed this debug only ASSERT as one can construct test cases that will exceed the giveUpThreshold
2011         amount.   This can be done with a large switch statement with at least one const or variable case
2012         clause.  Such code bytecompiles to compare / jtrue sequences.  Increasing the giveUpThreshold count
2013         doesn't help with the eventual code generated as B3 has optimizations to coalesce compare / branch
2014         code sequences even when we don't run the IntegerRangeOptimization phase.
2015
2016         * dfg/DFGIntegerRangeOptimizationPhase.cpp:
2017
2018 2019-01-02  Devin Rousso  <webkit@devinrousso.com>
2019
2020         Web Inspector: Implement `queryObjects` Command Line API
2021         https://bugs.webkit.org/show_bug.cgi?id=176766
2022         <rdar://problem/34890689>
2023
2024         Reviewed by Joseph Pecoraro.
2025
2026         Introduces a new Command Line function called `queryObjects` that will return an array of
2027         object that have the given constructor/prototype argument in their prototype chain.
2028          - `queryObjects(Promise)` will return an array of all Promises.
2029          - `queryObjects(Foo)` will return all objects created with the constructor `Foo`.
2030
2031         Currently, an error is thrown if the first argument is one of the following:
2032          - Object
2033          - Object.prototype
2034          - Function
2035          - Function.prototype
2036          - Array
2037          - Array.prototype
2038          - Map
2039          - Map.prototype
2040          - Set
2041          - Set.prototype
2042          - Proxy
2043
2044         The reason for this is that we don't want to expose any internal/builtin objects, as some of
2045         them are highly sensitive and undefined behaviour can occur if they are modified.
2046
2047         * inspector/JSInjectedScriptHost.h:
2048         * inspector/JSInjectedScriptHost.cpp:
2049         (Inspector::checkForbiddenPrototype): Added.
2050         (Inspector::JSInjectedScriptHost::queryObjects): Added.
2051         Does a GC and then iterates over all live JSCell in the heap to find these objects.
2052
2053         * inspector/JSInjectedScriptHostPrototype.cpp:
2054         (Inspector::JSInjectedScriptHostPrototype::finishCreation):
2055         (Inspector::jsInjectedScriptHostPrototypeFunctionQueryObjects): Added.
2056
2057         * inspector/InjectedScriptSource.js:
2058         (queryObjects): Added.
2059
2060         * runtime/JSGlobalObject.h:
2061         (JSC::JSGlobalObject::promisePrototype): Added.
2062
2063 2018-12-31  Keith Miller  <keith_miller@apple.com>
2064
2065         SourceProviders should use an actual URL instead of a string
2066         https://bugs.webkit.org/show_bug.cgi?id=192734
2067
2068         Reviewed by Yusuke Suzuki.
2069
2070         This will be useful for the Module loader API in the future where
2071         by default it will use the relative path from the referring module
2072         to resolve dependencies.
2073
2074         I didn't change the JSC shell's urls to be absolute paths as it
2075         caused problems with the stack traces in our Chakra tests. Since
2076         the absolute paths included system directories the diff would
2077         appear incorrect.
2078         See: https://bugs.webkit.org/show_bug.cgi?id=193077
2079
2080         * API/JSBase.cpp:
2081         (JSEvaluateScript):
2082         (JSCheckScriptSyntax):
2083         * API/JSScriptRef.cpp:
2084         (OpaqueJSScript::create):
2085         (OpaqueJSScript::OpaqueJSScript):
2086         * API/glib/JSCContext.cpp:
2087         (jsc_context_check_syntax):
2088         * jsc.cpp:
2089         (jscSource):
2090         (GlobalObject::moduleLoaderFetch):
2091         (functionCheckModuleSyntax):
2092         (runWithOptions):
2093         * parser/SourceCode.h:
2094         (JSC::makeSource):
2095         * parser/SourceProvider.cpp:
2096         (JSC::SourceProvider::SourceProvider):
2097         * parser/SourceProvider.h:
2098         (JSC::SourceProvider::url const):
2099         (JSC::StringSourceProvider::create):
2100         (JSC::StringSourceProvider::StringSourceProvider):
2101         (JSC::WebAssemblySourceProvider::create):
2102         (JSC::WebAssemblySourceProvider::WebAssemblySourceProvider):
2103         * runtime/FunctionConstructor.cpp:
2104         (JSC::constructFunctionSkippingEvalEnabledCheck):
2105         * tools/CodeProfile.h:
2106         (JSC::CodeProfile::CodeProfile):
2107         * tools/FunctionOverrides.cpp:
2108         (JSC::initializeOverrideInfo):
2109
2110 2019-01-01  Jeff Miller  <jeffm@apple.com>
2111
2112         Update user-visible copyright strings to include 2019
2113         https://bugs.webkit.org/show_bug.cgi?id=192811
2114
2115         Reviewed by Mark Lam.
2116
2117         * Info.plist:
2118
2119 2018-12-30  Ross Kirsling  <ross.kirsling@sony.com>
2120
2121         [JSC] Identifier validity should be based on ID_Start / ID_Continue properties
2122         https://bugs.webkit.org/show_bug.cgi?id=193050
2123
2124         Reviewed by Yusuke Suzuki.
2125
2126         From https://tc39.github.io/ecma262/#sec-names-and-keywords:
2127             UnicodeIDStart::
2128                 any Unicode code point with the Unicode property "ID_Start"
2129             UnicodeIDContinue::
2130                 any Unicode code point with the Unicode property "ID_Continue"
2131
2132         * parser/Lexer.cpp:
2133         (JSC::Lexer<T>::Lexer):
2134         (JSC::isNonLatin1IdentStart):
2135         (JSC::isNonLatin1IdentPart):
2136         (JSC::isIdentPart):
2137         (JSC::Lexer<T>::lex):
2138         Ensure identifier start / part is based on ID_Start / ID_Continue.
2139         (Implies a special case for U+00B7, which is Latin-1 but Other_ID_Continue.)
2140
2141 2018-12-28  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
2142
2143         [JSC] Remove one indirection in JSObject::toStringName
2144         https://bugs.webkit.org/show_bug.cgi?id=193037
2145
2146         Reviewed by Keith Miller.
2147
2148         We should not have additional one-level indirection in JSObject::toStringName.
2149         JSObject::toStringName is dispatched through methodTable. Even after that, we
2150         need to call JSObject::className function through methodTable again. But className
2151         function is rarely defined. So instead of introducing this indirection here,
2152         classes having className functions should have toStringName function too. This can
2153         remove one-level indirection in toStringName in major cases.
2154
2155         * API/JSCallbackObject.h:
2156         * API/JSCallbackObjectFunctions.h:
2157         (JSC::JSCallbackObject<Parent>::toStringName):
2158         * debugger/DebuggerScope.cpp:
2159         (JSC::DebuggerScope::toStringName):
2160         * debugger/DebuggerScope.h:
2161         * runtime/JSObject.cpp:
2162         (JSC::JSObject::toStringName):
2163
2164 2018-12-27  Alex Christensen  <achristensen@webkit.org>
2165
2166         Resurrect Mac CMake build
2167         https://bugs.webkit.org/show_bug.cgi?id=192658
2168
2169         Reviewed by Yusuke Suzuki.
2170
2171         * PlatformMac.cmake:
2172
2173 2018-12-25  Fujii Hironori  <Hironori.Fujii@sony.com>
2174
2175         [JSC][Win][Clang] warning: implicit conversion from 'size_t' (aka 'unsigned long long') to 'int32_t' (aka 'int') changes value from 18446744073709551552 to -64 [-Wconstant-conversion]
2176         https://bugs.webkit.org/show_bug.cgi?id=193035
2177
2178         Reviewed by Yusuke Suzuki.
2179
2180         Clang-cl reports a compilation warning for implicit conversion
2181         from -64 size_t to int. Replaced '-maxFrameExtentForSlowPathCall'
2182         with '-static_cast<int32_t>(maxFrameExtentForSlowPathCall)'.
2183
2184         * dfg/DFGJITCompiler.cpp:
2185         (JSC::DFG::JITCompiler::compile):
2186         (JSC::DFG::JITCompiler::compileFunction):
2187         * jit/JIT.cpp:
2188         (JSC::JIT::compileWithoutLinking):
2189         * jit/ThunkGenerators.cpp:
2190         (JSC::slowPathFor):
2191
2192 2018-12-13  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
2193
2194         [BigInt] Support BigInt in JSON.stringify
2195         https://bugs.webkit.org/show_bug.cgi?id=192624
2196
2197         Reviewed by Saam Barati.
2198
2199         This patch adds BigInt support to JSON.stringify, specified in [1].
2200
2201         [1]: https://tc39.github.io/proposal-bigint/#sec-serializejsonproperty
2202
2203         * runtime/JSONObject.cpp:
2204         (JSC::unwrapBoxedPrimitive):
2205         (JSC::Stringifier::toJSON):
2206         (JSC::Stringifier::toJSONImpl):
2207         (JSC::Stringifier::appendStringifiedValue):
2208
2209 2018-12-21  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
2210
2211         [JSC] Use appendUnbarriered for cached own keys
2212         https://bugs.webkit.org/show_bug.cgi?id=192981
2213
2214         Reviewed by Saam Barati.
2215
2216         m_cachedOwnKeys would be changed to sentinel after checking `thisObject->m_cachedOwnKeys.unvalidatedGet() != cachedOwnKeysSentinel()`
2217         and before executing `visitor.append(thisObject->m_cachedOwnKeys)`. We never do this now, but might in the future.
2218         To make the code safe, we should use appendUnbarriered to mark non sentinel cell.
2219
2220         * runtime/StructureRareData.cpp:
2221         (JSC::StructureRareData::visitChildren):
2222
2223 2018-12-20  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
2224
2225         Use Ref<> as much as possible
2226         https://bugs.webkit.org/show_bug.cgi?id=192808
2227
2228         Reviewed by Alex Christensen.
2229
2230         * API/JSTypedArray.cpp:
2231         (JSObjectMakeTypedArrayWithBytesNoCopy):
2232         * API/JSWeakObjectMapRefPrivate.cpp:
2233         * bytecompiler/StaticPropertyAnalyzer.h:
2234         (JSC::StaticPropertyAnalyzer::newObject):
2235         * dfg/DFGDesiredWatchpoints.cpp:
2236         (JSC::DFG::ArrayBufferViewWatchpointAdaptor::add):
2237         * heap/Heap.cpp:
2238         (JSC::Heap::Heap):
2239         (JSC::Heap::sweeper):
2240         * heap/Heap.h:
2241         * heap/IsoCellSet.cpp:
2242         (JSC::IsoCellSet::parallelNotEmptyMarkedBlockSource):
2243         * heap/IsoCellSet.h:
2244         * heap/IsoCellSetInlines.h:
2245         (JSC::IsoCellSet::forEachMarkedCellInParallel):
2246         * heap/Subspace.cpp:
2247         (JSC::Subspace::parallelDirectorySource):
2248         (JSC::Subspace::parallelNotEmptyMarkedBlockSource):
2249         * heap/Subspace.h:
2250         * heap/SubspaceInlines.h:
2251         (JSC::Subspace::forEachMarkedCellInParallel):
2252         * jsc.cpp:
2253         (functionDollarAgentReceiveBroadcast):
2254         * runtime/ArrayBuffer.cpp:
2255         (JSC::ArrayBuffer::slice const):
2256         (JSC::ArrayBuffer::sliceImpl const):
2257         * runtime/ArrayBuffer.h:
2258         * runtime/ArrayBufferNeuteringWatchpoint.cpp:
2259         (JSC::ArrayBufferNeuteringWatchpoint::ArrayBufferNeuteringWatchpoint):
2260         (JSC::ArrayBufferNeuteringWatchpoint::fireAll):
2261         * runtime/ArrayBufferNeuteringWatchpoint.h:
2262         * runtime/JSArrayBufferPrototype.cpp:
2263         (JSC::arrayBufferProtoFuncSlice):
2264
2265 2018-12-21  Joseph Pecoraro  <pecoraro@apple.com>
2266
2267         Web Inspector: Crashes seen under Inspector::ScriptCallFrame::~ScriptCallFrame
2268         https://bugs.webkit.org/show_bug.cgi?id=180373
2269         <rdar://problem/33894170>
2270
2271         Rubber-stamped by Devin Rousso.
2272
2273         * inspector/AsyncStackTrace.cpp:
2274         (Inspector::AsyncStackTrace::truncate):
2275         The `lastUnlockedAncestor->remove()` may release the only reference to it's
2276         parent which we intend to use later but don't hold a RefPtr to. Keep the
2277         parent alive explicitly by protecting it.
2278
2279 2018-12-20  Chris Dumez  <cdumez@apple.com>
2280
2281         Use Optional::hasValue() instead of Optional::has_value()
2282         https://bugs.webkit.org/show_bug.cgi?id=192948
2283
2284         Reviewed by Tim Horton.
2285
2286         * inspector/scripts/codegen/generate_cpp_backend_dispatcher_implementation.py:
2287         (CppBackendDispatcherImplementationGenerator._generate_async_dispatcher_class_for_domain):
2288         (CppBackendDispatcherImplementationGenerator._generate_dispatcher_implementation_for_command):
2289
2290 2018-12-20  Keith Miller  <keith_miller@apple.com>
2291
2292         Add support for globalThis
2293         https://bugs.webkit.org/show_bug.cgi?id=165171
2294
2295         Reviewed by Mark Lam.
2296
2297         This patch adds support for the globalThis property on the global
2298         object. The globalThis property spec is in stage three and is
2299         quite simple. For reference: http://tc39.github.io/proposal-global/
2300
2301         * runtime/JSGlobalObject.cpp:
2302
2303 2018-12-20  Chris Dumez  <cdumez@apple.com>
2304
2305         Use Optional::valueOr() instead of Optional::value_or()
2306         https://bugs.webkit.org/show_bug.cgi?id=192933
2307
2308         Reviewed by Geoffrey Garen.
2309
2310         * inspector/remote/cocoa/RemoteConnectionToTargetCocoa.mm:
2311         (Inspector::RemoteConnectionToTarget::setup):
2312         * inspector/remote/glib/RemoteConnectionToTargetGlib.cpp:
2313         (Inspector::RemoteConnectionToTarget::setup):
2314         * parser/SourceCodeKey.h:
2315         (JSC::SourceCodeKey::SourceCodeKey):
2316         * wasm/js/WebAssemblyModuleRecord.cpp:
2317         (JSC::WebAssemblyModuleRecord::link):
2318
2319 2018-12-20  Joseph Pecoraro  <pecoraro@apple.com>
2320
2321         ITMLKit Inspector: Elements tab does not show DOM Tree
2322         https://bugs.webkit.org/show_bug.cgi?id=192910
2323         <rdar://problem/46680585>
2324
2325         Reviewed by Brian Burg.
2326
2327         * inspector/agents/InspectorAgent.h:
2328         * inspector/agents/InspectorAgent.cpp:
2329         (Inspector::InspectorAgent::enable):
2330         (Inspector::InspectorAgent::activateExtraDomain):
2331         (Inspector::InspectorAgent::activateExtraDomains):
2332         Send extra domains immediately instead of waiting until
2333         the Inspector domain is enabled. This will ensure the frontend
2334         hears about extra augmented domains before augmenting agents
2335         get a chance to send any messages.
2336
2337 2018-12-20  Mark Lam  <mark.lam@apple.com>
2338
2339         Fix a typo in slow_path_construct_arityCheck and operationConstructArityCheck.
2340         https://bugs.webkit.org/show_bug.cgi?id=192939
2341         <rdar://problem/46869516>
2342
2343         Reviewed by Keith Miller.
2344
2345         * jit/JITOperations.cpp:
2346         * runtime/CommonSlowPaths.cpp:
2347
2348 2018-12-20  Caio Lima  <ticaiolima@gmail.com>
2349
2350         [BigInt] We should enable CSE into arithmetic operations that speculate BigIntUse
2351         https://bugs.webkit.org/show_bug.cgi?id=192723
2352
2353         Reviewed by Yusuke Suzuki.
2354
2355         This patch is adjusting clobberize rules into ValueOp nodes to enable
2356         more optimizations when we speculate BigIntUse. In such case, DFG now
2357         is able to apply CSE, LICM and commutativity on nodes like
2358         ValueAdd(BigInt, BigInt), ValueSub(BigInt, BigInt), etc.
2359
2360         Here are the numbers we can observe with some microbenchmarks:
2361
2362                                   baseline                 changes
2363
2364         big-int-cse           108.2733+-0.8445    ^    80.9897+-4.9781   ^ definitely 1.3369x faster
2365         big-int-licm          75.6641+-0.3477     ^    57.8144+-1.6043   ^ definitely 1.3087x faster
2366         big-int-global-cse    145.3557+-1.0552    ^    86.5866+-0.3025   ^ definitely 1.6787x faster
2367
2368         * dfg/DFGAbstractInterpreterInlines.h:
2369         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
2370         * dfg/DFGClobberize.h:
2371         (JSC::DFG::clobberize):
2372         * dfg/DFGStrengthReductionPhase.cpp:
2373         (JSC::DFG::StrengthReductionPhase::handleNode):
2374
2375 2018-12-19  Commit Queue  <commit-queue@webkit.org>
2376
2377         Unreviewed, rolling out r239377.
2378         https://bugs.webkit.org/show_bug.cgi?id=192921
2379
2380         broke 32-bit JSC tests (Requested by keith_miller on #webkit).
2381
2382         Reverted changeset:
2383
2384         "[BigInt] We should enable CSE into arithmetic operations that
2385         speculate BigIntUse"
2386         https://bugs.webkit.org/show_bug.cgi?id=192723
2387         https://trac.webkit.org/changeset/239377
2388
2389 2018-12-19  Chris Dumez  <cdumez@apple.com>
2390
2391         wtf/Optional.h: move-constructor and move-assignment operator should disengage the value being moved from
2392         https://bugs.webkit.org/show_bug.cgi?id=192728
2393         <rdar://problem/46746779>
2394
2395         Reviewed by Geoff Garen.
2396
2397         * API/*:
2398         * Scripts/*:
2399         * assembler/*:
2400         * b3/*:
2401         * bytecode/*:
2402         * bytecompiler/*:
2403         * debugger/*:
2404         * dfg/*:
2405         * ftl/*:
2406         * heap/*:
2407         * inspector/*:
2408         * jit/*:
2409         * llint/*:
2410         * parser/*:
2411         * runtime/*:
2412         * tools/*:
2413         * wasm/*:
2414         * yarr/*:
2415
2416 2018-12-18  Simon Fraser  <simon.fraser@apple.com>
2417
2418         Web Inspector: Timelines: correctly label Intersection Observer callbacks
2419         https://bugs.webkit.org/show_bug.cgi?id=192669
2420         <rdar://problem/46702490>
2421
2422         Reviewed by Joseph Pecoraro.
2423
2424         Add InspectorInstrumentation::willFireObserverCallback() and use it to wrap calls
2425         to Intersection Observer, Performance Observer and Mutation Observer callbacks so 
2426         that they get correctly labeled in the Inspector timeline.
2427
2428         * inspector/protocol/Timeline.json:
2429
2430 2018-12-18  Mark Lam  <mark.lam@apple.com>
2431
2432         JSPropertyNameEnumerator should cache the iterated object's structure only after getting its property names.
2433         https://bugs.webkit.org/show_bug.cgi?id=192464
2434         <rdar://problem/46519455>
2435
2436         Reviewed by Saam Barati.
2437
2438         This is because the process of getting its property names may cause some lazy
2439         properties to be reified, and the structure will change.  This is needed in order
2440         for get_direct_pname to work correctly.
2441
2442         * runtime/JSPropertyNameEnumerator.h:
2443         (JSC::propertyNameEnumerator):
2444
2445 2018-12-19  Caio Lima  <ticaiolima@gmail.com>
2446
2447         [BigInt] We should enable CSE into arithmetic operations that speculate BigIntUse
2448         https://bugs.webkit.org/show_bug.cgi?id=192723
2449
2450         Reviewed by Saam Barati.
2451
2452         This patch is adjusting clobberize rules into ValueOp nodes to enable
2453         more optimizations when we speculate BigIntUse. In such case, DFG now
2454         is able to apply CSE, LICM and commutativity on nodes like
2455         ValueAdd(BigInt, BigInt), ValueSub(BigInt, BigInt), etc.
2456
2457         Here are the numbers we can observe with some microbenchmarks:
2458
2459                                   baseline                 changes
2460
2461         big-int-cse           108.2733+-0.8445    ^    80.9897+-4.9781   ^ definitely 1.3369x faster
2462         big-int-licm          75.6641+-0.3477     ^    57.8144+-1.6043   ^ definitely 1.3087x faster
2463         big-int-global-cse    145.3557+-1.0552    ^    86.5866+-0.3025   ^ definitely 1.6787x faster
2464
2465         * dfg/DFGAbstractInterpreterInlines.h:
2466         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
2467         * dfg/DFGClobberize.h:
2468         (JSC::DFG::clobberize):
2469         * dfg/DFGStrengthReductionPhase.cpp:
2470         (JSC::DFG::StrengthReductionPhase::handleNode):
2471
2472 2018-12-19  Tadeu Zagallo  <tzagallo@apple.com>
2473
2474         String overflow in JSC::createError results in ASSERT in WTF::makeString
2475         https://bugs.webkit.org/show_bug.cgi?id=192833
2476         <rdar://problem/45706868>
2477
2478         Reviewed by Mark Lam.
2479
2480         JSC::createError was calling WTF::makeString which would result in an
2481         assertion failure when the string was too big. Change it to call
2482         WTF::tryMakeString instead and return an OutOfMemory error if we fail
2483         to create the error string.
2484
2485         * runtime/ExceptionHelpers.cpp:
2486         (JSC::createError):
2487
2488 2018-12-18  Ross Kirsling  <ross.kirsling@sony.com>
2489
2490         Error message for `-x ** y` contains a typo.
2491         https://bugs.webkit.org/show_bug.cgi?id=192832
2492
2493         Reviewed by Saam Barati.
2494
2495         * parser/Parser.cpp:
2496         (JSC::Parser<LexerType>::parseBinaryExpression):
2497         Make corrections to error message: "amiguous" -> "ambiguous", "parenthesis" -> "parentheses"
2498
2499 2018-12-18  Saam Barati  <sbarati@apple.com>
2500
2501         Update ARM64EHash
2502         https://bugs.webkit.org/show_bug.cgi?id=192823
2503         <rdar://problem/45468257>
2504
2505         Reviewed by Mark Lam.
2506
2507         * assembler/ARM64Assembler.h:
2508         (JSC::ARM64Assembler::ARM64Assembler):
2509         * assembler/AbstractMacroAssembler.h:
2510         (JSC::AbstractMacroAssembler::AbstractMacroAssembler):
2511         * assembler/AssemblerBuffer.h:
2512         (JSC::ARM64EHash::update):
2513         (JSC::ARM64EHash::finalHash const):
2514         (JSC::AssemblerBuffer::AssemblerBuffer):
2515         (JSC::AssemblerBuffer::putIntegralUnchecked):
2516         (JSC::ARM64EHash::ARM64EHash): Deleted.
2517         (JSC::ARM64EHash::hash const): Deleted.
2518         (JSC::ARM64EHash::randomSeed const): Deleted.
2519         * assembler/LinkBuffer.cpp:
2520         (JSC::LinkBuffer::copyCompactAndLinkCode):
2521
2522 2018-12-18  Mark Lam  <mark.lam@apple.com>
2523
2524         JSON.stringify() should throw OOM on StringBuilder overflows.
2525         https://bugs.webkit.org/show_bug.cgi?id=192822
2526         <rdar://problem/46670577>
2527
2528         Reviewed by Saam Barati.
2529
2530         * runtime/JSONObject.cpp:
2531         (JSC::Stringifier::stringify):
2532         (JSC::Stringifier::appendStringifiedValue):
2533         (JSC::Stringifier::Holder::appendNextProperty):
2534
2535 2018-12-18  Ross Kirsling  <ross.kirsling@sony.com>
2536
2537         Redeclaration of var over let/const/class should be a syntax error.
2538         https://bugs.webkit.org/show_bug.cgi?id=192298
2539
2540         Reviewed by Keith Miller.
2541
2542         From https://tc39.github.io/ecma262/#sec-block-static-semantics-early-errors:
2543         It is a Syntax Error if any element of the LexicallyDeclaredNames of StatementList also occurs in the
2544         VarDeclaredNames of StatementList.
2545
2546         Accordingly, this patch ensures that { let x; { var x; } } and { { var x; } let x; } are syntax errors.
2547
2548         For the "var after" scenario:
2549         When checking for existing lexically-declared names, we can't simply check the current var scope;
2550         we need to check *all* enclosing scopes up to (and including) the current var scope. In so doing,
2551         we must also avoid violating the Annex B.3.5 condition that allows `try {} catch (e) { var e; }`.
2552
2553         For the "var before" scenario:
2554         We ensure that lexical scopes always keep track of the vars being hoisted over them; this gives us
2555         a simple way to check the current block's var-declared names prior to making a lexical declaration.
2556
2557         * parser/Parser.cpp:
2558         (JSC::Parser<LexerType>::parseTryStatement):
2559         * parser/Parser.h:
2560         (JSC::Scope::Scope):
2561         (JSC::Scope::setIsSimpleCatchParameterScope): Added.
2562         (JSC::Scope::isSimpleCatchParameterScope): Added.
2563         (JSC::Scope::declareVariable):
2564         (JSC::Scope::addVariableBeingHoisted): Added.
2565         (JSC::Scope::declareLexicalVariable):
2566         (JSC::Scope::hasDeclaredVariable):
2567         (JSC::Scope::hasLexicallyDeclaredVariable): Added.
2568         (JSC::Parser::declareHoistedVariable): Added.
2569         (JSC::Parser::declareVariable):
2570
2571 2018-12-18  David Kilzer  <ddkilzer@apple.com>
2572
2573         clang-tidy: Use const reference for MediaTime parameter to prevent object copy
2574         <https://webkit.org/b/192814>
2575
2576         Reviewed by Mark Lam.
2577
2578         * runtime/JSCJSValue.h:
2579         (JSC::jsNumber):
2580
2581 2018-12-18  Saam Barati  <sbarati@apple.com>
2582
2583         Unreviewed. Appease a build error where we weren't using a variable defined in an "if"
2584
2585         * dfg/DFGAbstractInterpreterInlines.h:
2586         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
2587
2588 2018-12-17  Mark Lam  <mark.lam@apple.com>
2589
2590         Array unshift/shift should not race against the AI in the compiler thread.
2591         https://bugs.webkit.org/show_bug.cgi?id=192795
2592         <rdar://problem/46724263>
2593
2594         Reviewed by Saam Barati.
2595
2596         The Array unshift and shift operations for ArrayStorage type arrays are protected
2597         using the cellLock.  The AbstractInterpreter's foldGetByValOnConstantProperty()
2598         function does grab the cellLock before reading a value from the array's ArrayStorage,
2599         but does not get the array butterfly under the protection of the cellLock.
2600
2601         This is insufficient and racy.  For ArrayStorage type arrays, the fetching of the
2602         butterfly also needs to be protected by the cellLock.  The unshift / shift
2603         operations can move values around in the butterfly.  Hence, the fact that AI has
2604         fetched a butterfly pointer (while ensuring no structure change) is insufficient
2605         to guarantee that the values in the butterfly haven't shifted.
2606
2607         Having AI hold the cellLock the whole time (from before fetching the butterfly
2608         till after reading the value from it) eliminates this race.  Note: we only need
2609         to do this for ArrayStorage type arrays.
2610
2611         Note also that though AI is holding the cellLock in this case, we still need to
2612         ensure that the array structure hasn't changed around the fetching of the butterfly.
2613         This is because operations other than unshift and shift are guarded by this
2614         protocol, and not the cellLock.
2615
2616         * dfg/DFGAbstractInterpreterInlines.h:
2617         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
2618         * runtime/JSArray.cpp:
2619         (JSC::JSArray::unshiftCountSlowCase):
2620
2621 2018-12-16  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
2622
2623         [JSC] Optimize Object.keys by caching own keys results in StructureRareData
2624         https://bugs.webkit.org/show_bug.cgi?id=190047
2625
2626         Reviewed by Saam Barati.
2627
2628         Object.keys is one of the most frequently used function in web-tooling-benchmarks (WTB).
2629         Object.keys is dominant in lebab of WTB, and frequently called in babel and others.
2630         Since our Structure knows the shape of JSObject, we can cache the result of Object.keys
2631         in Structure (StructureRareData) as we cache JSPropertyNameEnumerator in StructureRareData.
2632
2633         This patch caches the result of Object.keys in StructureRareData. The cached array is created
2634         as JSImmutableButterfly. And Object.keys creates CoW from this data. Currently, the lifetime
2635         strategy of this JSImmutableButterfly is the same to cached JSPropertyNameEnumerator. It is
2636         referenced from Structure, and collected when Structure is collected.
2637
2638         This improves several benchmarks in SixSpeed.
2639
2640                                         baseline                  patched
2641
2642             object-assign.es5      350.1710+-3.6303     ^    226.0368+-4.7558        ^ definitely 1.5492x faster
2643             for-of-object.es6      269.1941+-3.3430     ^    127.9317+-2.3875        ^ definitely 2.1042x faster
2644
2645         And it improves WTB lebab by 11.8%.
2646
2647             Before: lebab:  6.10 runs/s
2648             After:  lebab:  6.82 runs/s
2649
2650         * dfg/DFGAbstractInterpreterInlines.h:
2651         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
2652         * dfg/DFGByteCodeParser.cpp:
2653         (JSC::DFG::ByteCodeParser::handleIntrinsicCall):
2654         * dfg/DFGClobberize.h:
2655         (JSC::DFG::clobberize):
2656         * dfg/DFGConstantFoldingPhase.cpp:
2657         (JSC::DFG::ConstantFoldingPhase::foldConstants):
2658         * dfg/DFGDoesGC.cpp:
2659         (JSC::DFG::doesGC):
2660         * dfg/DFGFixupPhase.cpp:
2661         (JSC::DFG::FixupPhase::fixupNode):
2662         * dfg/DFGNode.cpp:
2663         (JSC::DFG::Node::convertToNewArrayBuffer):
2664         * dfg/DFGNode.h:
2665         * dfg/DFGNodeType.h:
2666         * dfg/DFGOperations.cpp:
2667         * dfg/DFGOperations.h:
2668         * dfg/DFGPredictionPropagationPhase.cpp:
2669         * dfg/DFGSafeToExecute.h:
2670         (JSC::DFG::safeToExecute):
2671         * dfg/DFGSpeculativeJIT.cpp:
2672         (JSC::DFG::SpeculativeJIT::compileObjectKeys):
2673         * dfg/DFGSpeculativeJIT.h:
2674         * dfg/DFGSpeculativeJIT32_64.cpp:
2675         (JSC::DFG::SpeculativeJIT::compile):
2676         * dfg/DFGSpeculativeJIT64.cpp:
2677         (JSC::DFG::SpeculativeJIT::compile):
2678         * ftl/FTLAbstractHeapRepository.h:
2679         * ftl/FTLCapabilities.cpp:
2680         (JSC::FTL::canCompile):
2681         * ftl/FTLLowerDFGToB3.cpp:
2682         (JSC::FTL::DFG::LowerDFGToB3::compileNode):
2683         (JSC::FTL::DFG::LowerDFGToB3::compileObjectKeys):
2684         * runtime/Butterfly.h:
2685         (JSC::ContiguousData::Data::setStartingValue):
2686         * runtime/Intrinsic.cpp:
2687         (JSC::intrinsicName):
2688         * runtime/Intrinsic.h:
2689         * runtime/JSImmutableButterfly.h:
2690         (JSC::JSImmutableButterfly::JSImmutableButterfly):
2691         We set JSEmpty to the underlying butterfly storage if indexing type is Contiguous.
2692         Otherwise, JSImmutableButterfly is half-baked one until all the storage is filled with some meaningful values, it leads to crash
2693         if half-baked JSImmutableButterfly is exposed to GC.
2694         * runtime/ObjectConstructor.cpp:
2695         (JSC::ownPropertyKeys):
2696         * runtime/Structure.cpp:
2697         (JSC::Structure::canCachePropertyNameEnumerator const):
2698         * runtime/Structure.h:
2699         * runtime/StructureInlines.h:
2700         (JSC::Structure::setCachedOwnKeys):
2701         (JSC::Structure::cachedOwnKeys const):
2702         (JSC::Structure::cachedOwnKeysIgnoringSentinel const):
2703         (JSC::Structure::canCacheOwnKeys const):
2704         * runtime/StructureRareData.cpp:
2705         (JSC::StructureRareData::visitChildren):
2706         (JSC::StructureRareData::cachedPropertyNameEnumerator const): Deleted.
2707         (JSC::StructureRareData::setCachedPropertyNameEnumerator): Deleted.
2708         * runtime/StructureRareData.h:
2709         * runtime/StructureRareDataInlines.h:
2710         (JSC::StructureRareData::cachedPropertyNameEnumerator const):
2711         (JSC::StructureRareData::setCachedPropertyNameEnumerator):
2712         (JSC::StructureRareData::cachedOwnKeys const):
2713         (JSC::StructureRareData::cachedOwnKeysIgnoringSentinel const):
2714         (JSC::StructureRareData::cachedOwnKeysConcurrently const):
2715         (JSC::StructureRareData::setCachedOwnKeys):
2716         (JSC::StructureRareData::previousID const): Deleted.
2717         * runtime/VM.cpp:
2718         (JSC::VM::VM):
2719
2720 2018-12-17  Mark Lam  <mark.lam@apple.com>
2721
2722         SamplingProfiler's isValidFramePointer() should reject address at stack origin.
2723         https://bugs.webkit.org/show_bug.cgi?id=192779
2724         <rdar://problem/46775869>
2725
2726         Reviewed by Saam Barati.
2727
2728         isValidFramePointer() was previously treating the address at StackBounds::origin()
2729         as valid stack memory.  This is not true.  StackBounds::origin() is actually the
2730         first address beyond valid stack memory. This is now fixed.
2731
2732         * runtime/SamplingProfiler.cpp:
2733         (JSC::FrameWalker::isValidFramePointer):
2734
2735 2018-12-17  Mark Lam  <mark.lam@apple.com>
2736
2737         Suppress ASAN on valid stack accesses in Probe-based OSRExit::executeOSRExit().
2738         https://bugs.webkit.org/show_bug.cgi?id=192776
2739         <rdar://problem/46772368>
2740
2741         Reviewed by Keith Miller.
2742
2743         1. Add some asanUnsafe methods to the Register class.
2744         2. Update the probe-based OSRExit::executeOSRExit() to use these asanUnsafe methods.
2745
2746         * dfg/DFGOSRExit.cpp:
2747         (JSC::DFG::OSRExit::executeOSRExit):
2748         * interpreter/Register.h:
2749         (JSC::Register::asanUnsafeUnboxedInt32 const):
2750         (JSC::Register::asanUnsafeUnboxedInt52 const):
2751         (JSC::Register::asanUnsafeUnboxedStrictInt52 const):
2752         (JSC::Register::asanUnsafeUnboxedDouble const):
2753         (JSC::Register::asanUnsafeUnboxedCell const):
2754
2755 2018-12-17  Mark Lam  <mark.lam@apple.com>
2756
2757         Fix stale assertion in attemptToForceStringArrayModeByToStringConversion().
2758         https://bugs.webkit.org/show_bug.cgi?id=192770
2759         <rdar://problem/46449037>
2760
2761         Reviewed by Keith Miller.
2762
2763         This assertion was added before Array::OriginalNonArray was introduced.  It just
2764         needs to be updated to allow for Array::OriginalNonArray.
2765
2766         * dfg/DFGFixupPhase.cpp:
2767         (JSC::DFG::FixupPhase::attemptToForceStringArrayModeByToStringConversion):
2768
2769 2018-12-17  Matt Lewis  <jlewis3@apple.com>
2770
2771         Unreviewed, rolling out r239254.
2772
2773         This broke the Windows 10 Debug build
2774
2775         Reverted changeset:
2776
2777         "Replace many uses of String::format with more type-safe
2778         alternatives"
2779         https://bugs.webkit.org/show_bug.cgi?id=192742
2780         https://trac.webkit.org/changeset/239254
2781
2782 2018-12-15  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
2783
2784         Unreviewed, suppress warnings in Linux
2785
2786         * jsc.cpp:
2787         (jscmain):
2788
2789 2018-12-15  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
2790
2791         Null pointer dereference in JSC::WriteBarrierBase()
2792         https://bugs.webkit.org/show_bug.cgi?id=191252
2793
2794         Reviewed by Keith Miller.
2795
2796         JSPromiseDeferred::create can return nullptr and an exception if stack overflow happens.
2797         We would like to make it RELEASE_ASSERT since the current module mechanism is not immune
2798         to stack overflow.
2799
2800         This patch renames JSPromiseDeferred::create to JSPromiseDeferred::tryCreate to tell that
2801         it can return nullptr. And we insert error checks or assertions after this call.
2802
2803         * jsc.cpp:
2804         (GlobalObject::moduleLoaderImportModule):
2805         (GlobalObject::moduleLoaderFetch):
2806         * runtime/Completion.cpp:
2807         (JSC::rejectPromise):
2808         * runtime/JSGlobalObjectFunctions.cpp:
2809         (JSC::globalFuncImportModule):
2810         * runtime/JSInternalPromiseDeferred.cpp:
2811         (JSC::JSInternalPromiseDeferred::tryCreate):
2812         (JSC::JSInternalPromiseDeferred::create): Deleted.
2813         * runtime/JSInternalPromiseDeferred.h:
2814         * runtime/JSModuleLoader.cpp:
2815         (JSC::JSModuleLoader::importModule):
2816         (JSC::JSModuleLoader::resolve):
2817         (JSC::JSModuleLoader::fetch):
2818         (JSC::moduleLoaderParseModule):
2819         * runtime/JSPromise.h:
2820         * runtime/JSPromiseDeferred.cpp:
2821         (JSC::JSPromiseDeferred::tryCreate):
2822         * runtime/JSPromiseDeferred.h:
2823         * wasm/js/WebAssemblyPrototype.cpp:
2824         (JSC::webAssemblyCompileFunc):
2825         (JSC::webAssemblyInstantiateFunc):
2826         (JSC::webAssemblyCompileStreamingInternal):
2827         (JSC::webAssemblyInstantiateStreamingInternal):
2828
2829 2018-12-15  Darin Adler  <darin@apple.com>
2830
2831         Use warning-ignoring macros more consistently and simply
2832         https://bugs.webkit.org/show_bug.cgi?id=192743
2833
2834         Reviewed by Mark Lam.
2835
2836         * dfg/DFGSpeculativeJIT64.cpp: Use IGNORE_WARNINGS_BEGIN/END instead of
2837         IGNORE_CLANG_WARNINGS_BEGIN/END. Other callsites are using the non-clang-specific
2838         one for this warning, "implicit-fallthrough", and it seems there is no special
2839         need to use the clang-specific one here.
2840         * llint/LLIntData.cpp: Ditto, but here it's "missing-noreturn"."
2841         * tools/CodeProfiling.cpp: Ditto.
2842
2843 2018-12-15  Darin Adler  <darin@apple.com>
2844
2845         Replace many uses of String::format with more type-safe alternatives
2846         https://bugs.webkit.org/show_bug.cgi?id=192742
2847
2848         Reviewed by Mark Lam.
2849
2850         * inspector/InjectedScriptBase.cpp:
2851         (Inspector::InjectedScriptBase::makeCall): Use makeString.
2852         (Inspector::InjectedScriptBase::makeAsyncCall): Ditto.
2853         * inspector/InspectorBackendDispatcher.cpp:
2854         (Inspector::BackendDispatcher::getPropertyValue): Ditto.
2855         * inspector/agents/InspectorConsoleAgent.cpp:
2856         (Inspector::InspectorConsoleAgent::enable): Ditto.
2857         * jsc.cpp:
2858         (FunctionJSCStackFunctor::operator() const): Ditto.
2859
2860         * runtime/IntlDateTimeFormat.cpp:
2861         (JSC::IntlDateTimeFormat::initializeDateTimeFormat): Use string concatenation.
2862         * runtime/IntlObject.cpp:
2863         (JSC::canonicalizeLocaleList): Ditto.
2864
2865 2018-12-14  Darin Adler  <darin@apple.com>
2866
2867         LiteralParser has a bunch of uses of String::format with untrusted data
2868         https://bugs.webkit.org/show_bug.cgi?id=108883
2869         rdar://problem/13666409
2870
2871         Reviewed by Mark Lam.
2872
2873         * runtime/LiteralParser.cpp:
2874         (JSC::LiteralParser<CharType>::Lexer::lex): Use makeString instead of String::format.
2875         (JSC::LiteralParser<CharType>::Lexer::lexStringSlow): Ditto.
2876         (JSC::LiteralParser<CharType>::parse): Ditto.
2877
2878         * runtime/LiteralParser.h:
2879         (JSC::LiteralParser::getErrorMessage): Use string concatenation instead of
2880         String::format.
2881
2882 2018-12-14  Mark Lam  <mark.lam@apple.com>
2883
2884         CallFrame::convertToStackOverflowFrame() needs to keep the top CodeBlock alive.
2885         https://bugs.webkit.org/show_bug.cgi?id=192717
2886         <rdar://problem/46660677>
2887
2888         Reviewed by Saam Barati.
2889
2890         When throwing a StackOverflowError, we convert the topCallFrame into a
2891         StackOverflowFrame.  Previously, we would nullify the codeBlock field in the frame
2892         because a StackOverflowFrame is only a sentinel and doesn't really correspond to
2893         any CodeBlocks.  However, this is a problem because the topCallFrame may be the
2894         only remaining place that references the CodeBlock that the stack overflow is
2895         triggered in.  The way we handle exceptions in JIT code is to return (from the
2896         runtime operation function throwing the exception) to the JIT code to check for
2897         the exception and if needed, do some clean up before jumping to the exception
2898         handling thunk.  As a result, we need to keep that JIT code alive, which means we
2899         need to keep its CodeBlock alive.  We only need to keep this CodeBlock alive until
2900         we've unwound (in terms of exception handling) out of it.
2901
2902         We fix this issue by storing the CodeBlock to keep alive in the StackOverflowFrame
2903         for the GC to scan while the frame is still on the stack.
2904
2905         We removed the call to convertToStackOverflowFrame() in
2906         lookupExceptionHandlerFromCallerFrame() because it is redundant.
2907         lookupExceptionHandlerFromCallerFrame() will only every be called after
2908         a StackOverFlowError has been thrown.  Hence, the top frame is already
2909         guaranteed to be a StackOverflowFrame, and there should always be a
2910         StackOverFlowError exception pending.  We added assertions for these
2911         instead.
2912
2913         * interpreter/CallFrame.cpp:
2914         (JSC::CallFrame::convertToStackOverflowFrame):
2915         * interpreter/CallFrame.h:
2916         * jit/JITOperations.cpp:
2917         * llint/LLIntSlowPaths.cpp:
2918         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
2919         * runtime/CommonSlowPaths.cpp:
2920         (JSC::SLOW_PATH_DECL):
2921         * runtime/CommonSlowPaths.h:
2922         (JSC::CommonSlowPaths::codeBlockFromCallFrameCallee):
2923         (JSC::CommonSlowPaths::arityCheckFor):
2924         * runtime/VM.h:
2925         (JSC::VM::exceptionForInspection const):
2926
2927 2018-12-14  David Kilzer  <ddkilzer@apple.com>
2928
2929         clang-tidy: Fix unnecessary copy of objects for operator==() methods
2930         <https://webkit.org/b/192712>
2931         <rdar://problem/46739332>
2932
2933         Reviewed by Andy Estes.
2934
2935         * b3/air/AirAllocateRegistersByGraphColoring.cpp:
2936         (JSC::B3::Air::(anonymous namespace)::AbstractColoringAllocator::InterferenceEdge::operator==):
2937         - Change argument from const to const reference to avoid a copy.
2938
2939 2018-12-14  Commit Queue  <commit-queue@webkit.org>
2940
2941         Unreviewed, rolling out r239153, r239154, and r239155.
2942         https://bugs.webkit.org/show_bug.cgi?id=192715
2943
2944         Caused flaky GC-related crashes seen with layout tests
2945         (Requested by ryanhaddad on #webkit).
2946
2947         Reverted changesets:
2948
2949         "[JSC] Optimize Object.keys by caching own keys results in
2950         StructureRareData"
2951         https://bugs.webkit.org/show_bug.cgi?id=190047
2952         https://trac.webkit.org/changeset/239153
2953
2954         "Unreviewed, build fix after r239153"
2955         https://bugs.webkit.org/show_bug.cgi?id=190047
2956         https://trac.webkit.org/changeset/239154
2957
2958         "Unreviewed, build fix after r239153, part 2"
2959         https://bugs.webkit.org/show_bug.cgi?id=190047
2960         https://trac.webkit.org/changeset/239155
2961
2962 2018-12-14  Keith Miller  <keith_miller@apple.com>
2963
2964         Callers of JSString::getIndex should check for OOM exceptions
2965         https://bugs.webkit.org/show_bug.cgi?id=192709
2966
2967         Reviewed by Mark Lam.
2968
2969         This patch also allows Strings to OOM when the StringObject wrapper
2970         attempts to look up an own property on the string.
2971
2972         Remove isExtensibleImpl because it's only used in one place and call
2973         isStructureExtensible instead.
2974
2975         * runtime/JSObject.cpp:
2976         (JSC::JSObject::isExtensible):
2977         * runtime/JSObject.h:
2978         (JSC::JSObject::isExtensibleImpl): Deleted.
2979         * runtime/JSString.h:
2980         (JSC::JSString::getStringPropertySlot):
2981         * runtime/StringObject.cpp:
2982         (JSC::StringObject::defineOwnProperty):
2983
2984 2018-12-13  Fujii Hironori  <Hironori.Fujii@sony.com>
2985
2986         [WinCairo][Clang] DLLLauncherMain.cpp: warning: unused function 'prependPath' and 'appleApplicationSupportDirectory'
2987         https://bugs.webkit.org/show_bug.cgi?id=192688
2988
2989         Reviewed by Ross Kirsling.
2990
2991         These functions are used only in AppleWin port.
2992
2993         * shell/DLLLauncherMain.cpp:
2994         (copyEnvironmentVariable): Moved.
2995         (getStringValue): Enclosed with #if !defined(WIN_CAIRO).
2996         (applePathFromRegistry): Ditto.
2997         (appleApplicationSupportDirectory): Ditto.
2998         (prependPath): Ditto.
2999
3000 2018-12-13  Dominik Infuehr  <dinfuehr@igalia.com>
3001
3002         Improve GDB output for LLInt on Linux
3003         https://bugs.webkit.org/show_bug.cgi?id=192660
3004
3005         Reviewed by Yusuke Suzuki.
3006
3007         Annotate assembly code generated for LLInt with the bytecode operation. When debugging
3008         LLInt assembly code GDB is then able to show which bytecode instruction is implemented by
3009         the current assembly code. This also works for linux-perf.
3010
3011         * llint/LowLevelInterpreter.cpp:
3012         * offlineasm/arm.rb:
3013
3014 2018-12-13  Mark Lam  <mark.lam@apple.com>
3015
3016         Add a missing exception check.
3017         https://bugs.webkit.org/show_bug.cgi?id=192626
3018         <rdar://problem/46662163>
3019
3020         Reviewed by Keith Miller.
3021
3022         * runtime/ScopedArguments.h:
3023
3024 2018-12-13  Saam Barati  <sbarati@apple.com>
3025
3026         The JSC shell should listen for memory pressure events and respond to them
3027         https://bugs.webkit.org/show_bug.cgi?id=192647
3028
3029         Reviewed by Keith Miller.
3030
3031         We want the JSC shell to behave more like the WebContent process when
3032         it comes to running performance tests. One way to make the shell
3033         more like this is to have it respond to memory pressure events in
3034         a similar way as the WebContent process. This makes it easier to run
3035         benchmarks like JetStream2 on the CLI on iOS.
3036
3037         * jsc.cpp:
3038         (jscmain):
3039         * runtime/VM.cpp:
3040         (JSC::VM::drainMicrotasks):
3041         * runtime/VM.h:
3042         (JSC::VM::setOnEachMicrotaskTick):
3043
3044 2018-12-13  Mark Lam  <mark.lam@apple.com>
3045
3046         Ensure that StructureFlags initialization always starts with Base::StructureFlags.
3047         https://bugs.webkit.org/show_bug.cgi?id=192686
3048
3049         Reviewed by Keith Miller.
3050
3051         This is purely a refactoring effort to make the code consistently start all
3052         StructureFlags initialization with Base::StructureFlags.  Previously, sometimes
3053         Base::StructureFlags is appended at the end, and sometimes, it is expressed using
3054         the name of the superclass.  This patch makes the code all consistent and easier
3055         to do a quick eye scan audit on to verify that no StructureFlags are forgetting
3056         to inherit Base::StructureFlags.
3057
3058         Also added a static_assert in JSCallbackObject.h and JSBoundFunction.h.  Both of
3059         these implement a customHasInstance() method, and rely on ImplementsHasInstance
3060         being included in the StructureFlags, and conversely, ImplementsDefaultHasInstance
3061         has to be excluded.
3062
3063         JSBoundFunction.h is the only case where a bit (ImplementsDefaultHasInstance)
3064         needs to be masked out of the inherited Base::StructureFlags.
3065
3066         * API/JSCallbackObject.h:
3067         * runtime/ArrayConstructor.h:
3068         * runtime/ArrayIteratorPrototype.h:
3069         * runtime/Exception.h:
3070         * runtime/FunctionRareData.h:
3071         * runtime/InferredType.h:
3072         * runtime/InferredTypeTable.h:
3073         * runtime/InferredValue.h:
3074         * runtime/JSBoundFunction.h:
3075         * runtime/MapPrototype.h:
3076         * runtime/SetPrototype.h:
3077         * runtime/StringPrototype.h:
3078         * runtime/SymbolConstructor.h:
3079
3080 2018-12-13  Mark Lam  <mark.lam@apple.com>
3081
3082         Add the JSC_traceBaselineJITExecution option for tracing baseline JIT execution.
3083         https://bugs.webkit.org/show_bug.cgi?id=192684
3084
3085         Reviewed by Saam Barati.
3086
3087         This dataLogs the bytecode execution order of baseline JIT code when the
3088         JSC_traceBaselineJITExecution option is true.
3089
3090         * jit/JIT.cpp:
3091         (JSC::JIT::privateCompileMainPass):
3092         (JSC::JIT::privateCompileSlowCases):
3093         * runtime/Options.h:
3094
3095 2018-12-13  David Kilzer  <ddkilzer@apple.com>
3096
3097         clang-tidy: Fix unnecessary object copies in JavaScriptCore
3098         <https://webkit.org/b/192680>
3099         <rdar://problem/46708767>
3100
3101         Reviewed by Mark Lam.
3102
3103         * assembler/testmasm.cpp:
3104         (JSC::invoke):
3105         - Make MacroAssemblerCodeRef<JSEntryPtrTag> argument a const
3106           reference.
3107
3108         * b3/testb3.cpp:
3109         (JSC::B3::checkDisassembly):
3110         - Make CString argument a const reference.
3111
3112         * dfg/DFGSpeculativeJIT.cpp:
3113         (JSC::DFG::SpeculativeJIT::compileStringEquality):
3114         * dfg/DFGSpeculativeJIT.h:
3115         * dfg/DFGSpeculativeJIT32_64.cpp:
3116         (JSC::DFG::SpeculativeJIT::cachedGetByIdWithThis):
3117         * dfg/DFGSpeculativeJIT64.cpp:
3118         (JSC::DFG::SpeculativeJIT::cachedGetByIdWithThis):
3119         - Make JITCompiler::JumpList arguments a const reference.
3120
3121         * ftl/FTLLowerDFGToB3.cpp:
3122         (JSC::FTL::DFG::LowerDFGToB3::checkStructure):
3123         - Make RegisteredStructureSet argument a const reference.
3124
3125         * jsc.cpp:
3126         (GlobalObject::moduleLoaderImportModule): Make local auto
3127         variables const references.
3128         (Workers::report): Make String argument a const reference.
3129         (addOption): Make Identifier argument a const reference.
3130         (runJSC): Make CString loop variable a const reference.
3131
3132 2018-12-13  Devin Rousso  <drousso@apple.com>
3133
3134         Web Inspector: remove DOM.BackendNodeId and associated commands/events
3135         https://bugs.webkit.org/show_bug.cgi?id=192478
3136
3137         Reviewed by Matt Baker.
3138
3139         * inspector/protocol/DOM.json:
3140
3141 2018-12-13  Caio Lima  <ticaiolima@gmail.com>
3142
3143         [BigInt] Add ValueDiv into DFG
3144         https://bugs.webkit.org/show_bug.cgi?id=186178
3145
3146         Reviewed by Yusuke Suzuki.
3147
3148         This patch is introducing a new node type called ValueDiv. This node
3149         is responsible to handle Untyped and Bigint specialization of division
3150         operator, while the ArithDiv variant handles Number/Boolean cases.
3151
3152         BigInt specialization generates following speedup into simple
3153         benchmark:
3154
3155                                   noSpec                 changes
3156
3157         big-int-simple-div    10.6013+-0.4682    ^    8.4518+-0.0943   ^ definitely 1.2543x faster
3158
3159         * dfg/DFGAbstractInterpreterInlines.h:
3160         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
3161         * dfg/DFGBackwardsPropagationPhase.cpp:
3162         (JSC::DFG::BackwardsPropagationPhase::propagate):
3163         * dfg/DFGByteCodeParser.cpp:
3164         (JSC::DFG::ByteCodeParser::makeDivSafe):
3165         (JSC::DFG::ByteCodeParser::parseBlock):
3166         * dfg/DFGClobberize.h:
3167         (JSC::DFG::clobberize):
3168         * dfg/DFGDoesGC.cpp:
3169         (JSC::DFG::doesGC):
3170         * dfg/DFGFixupPhase.cpp:
3171         (JSC::DFG::FixupPhase::fixupArithDiv):
3172         (JSC::DFG::FixupPhase::fixupNode):
3173         * dfg/DFGNode.h:
3174         (JSC::DFG::Node::arithNodeFlags):
3175         * dfg/DFGNodeType.h:
3176         * dfg/DFGOperations.cpp:
3177         * dfg/DFGOperations.h:
3178         * dfg/DFGPredictionPropagationPhase.cpp:
3179         * dfg/DFGSafeToExecute.h:
3180         (JSC::DFG::safeToExecute):
3181         * dfg/DFGSpeculativeJIT.cpp:
3182         (JSC::DFG::SpeculativeJIT::compileValueDiv):
3183         (JSC::DFG::SpeculativeJIT::compileArithDiv):
3184         * dfg/DFGSpeculativeJIT.h:
3185         * dfg/DFGSpeculativeJIT32_64.cpp:
3186         (JSC::DFG::SpeculativeJIT::compile):
3187         * dfg/DFGSpeculativeJIT64.cpp:
3188         (JSC::DFG::SpeculativeJIT::compile):
3189         * dfg/DFGValidate.cpp:
3190         * ftl/FTLCapabilities.cpp:
3191         (JSC::FTL::canCompile):
3192         * ftl/FTLLowerDFGToB3.cpp:
3193         (JSC::FTL::DFG::LowerDFGToB3::compileNode):
3194         (JSC::FTL::DFG::LowerDFGToB3::compileValueDiv):
3195         (JSC::FTL::DFG::LowerDFGToB3::compileArithDiv):
3196         (JSC::FTL::DFG::LowerDFGToB3::compileArithBitNot):
3197
3198 2018-12-13  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
3199
3200         Unreviewed, build fix after r239153, part 2
3201         https://bugs.webkit.org/show_bug.cgi?id=190047
3202
3203         * runtime/StructureRareDataInlines.h:
3204         (JSC::StructureRareData::cachedOwnKeys const):
3205
3206 2018-12-13  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
3207
3208         Unreviewed, build fix after r239153
3209         https://bugs.webkit.org/show_bug.cgi?id=190047
3210
3211         * runtime/StructureRareDataInlines.h:
3212         (JSC::StructureRareData::cachedOwnKeys const):
3213
3214 2018-12-10  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
3215
3216         [JSC] Optimize Object.keys by caching own keys results in StructureRareData
3217         https://bugs.webkit.org/show_bug.cgi?id=190047
3218
3219         Reviewed by Keith Miller.
3220
3221         Object.keys is one of the most frequently used function in web-tooling-benchmarks (WTB).
3222         Object.keys is dominant in lebab of WTB, and frequently called in babel and others.
3223         Since our Structure knows the shape of JSObject, we can cache the result of Object.keys
3224         in Structure (StructureRareData) as we cache JSPropertyNameEnumerator in StructureRareData.
3225
3226         This patch caches the result of Object.keys in StructureRareData. The cached array is created
3227         as JSImmutableButterfly. And Object.keys creates CoW from this data. Currently, the lifetime
3228         strategy of this JSImmutableButterfly is the same to cached JSPropertyNameEnumerator. It is
3229         referenced from Structure, and collected when Structure is collected.
3230
3231         This improves several benchmarks in SixSpeed.
3232
3233                                         baseline                  patched
3234
3235             object-assign.es5      350.1710+-3.6303     ^    226.0368+-4.7558        ^ definitely 1.5492x faster
3236             for-of-object.es6      269.1941+-3.3430     ^    127.9317+-2.3875        ^ definitely 2.1042x faster
3237
3238         And it improves WTB lebab by 11.8%.
3239
3240             Before: lebab:  6.10 runs/s
3241             After:  lebab:  6.82 runs/s
3242
3243         * dfg/DFGAbstractInterpreterInlines.h:
3244         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
3245         * dfg/DFGByteCodeParser.cpp:
3246         (JSC::DFG::ByteCodeParser::handleIntrinsicCall):
3247         * dfg/DFGClobberize.h:
3248         (JSC::DFG::clobberize):
3249         * dfg/DFGConstantFoldingPhase.cpp:
3250         (JSC::DFG::ConstantFoldingPhase::foldConstants):
3251         * dfg/DFGDoesGC.cpp:
3252         (JSC::DFG::doesGC):
3253         * dfg/DFGFixupPhase.cpp:
3254         (JSC::DFG::FixupPhase::fixupNode):
3255         * dfg/DFGNode.cpp:
3256         (JSC::DFG::Node::convertToNewArrayBuffer):
3257         * dfg/DFGNode.h:
3258         * dfg/DFGNodeType.h:
3259         * dfg/DFGOperations.cpp:
3260         * dfg/DFGOperations.h:
3261         * dfg/DFGPredictionPropagationPhase.cpp:
3262         * dfg/DFGSafeToExecute.h:
3263         (JSC::DFG::safeToExecute):
3264         * dfg/DFGSpeculativeJIT.cpp:
3265         (JSC::DFG::SpeculativeJIT::compileObjectKeys):
3266         * dfg/DFGSpeculativeJIT.h:
3267         * dfg/DFGSpeculativeJIT32_64.cpp:
3268         (JSC::DFG::SpeculativeJIT::compile):
3269         * dfg/DFGSpeculativeJIT64.cpp:
3270         (JSC::DFG::SpeculativeJIT::compile):
3271         * ftl/FTLAbstractHeapRepository.h:
3272         * ftl/FTLCapabilities.cpp:
3273         (JSC::FTL::canCompile):
3274         * ftl/FTLLowerDFGToB3.cpp:
3275         (JSC::FTL::DFG::LowerDFGToB3::compileNode):
3276         (JSC::FTL::DFG::LowerDFGToB3::compileObjectKeys):
3277         * runtime/Intrinsic.cpp:
3278         (JSC::intrinsicName):
3279         * runtime/Intrinsic.h:
3280         * runtime/JSImmutableButterfly.h:
3281         (JSC::JSImmutableButterfly::createSentinel):
3282         * runtime/ObjectConstructor.cpp:
3283         (JSC::ownPropertyKeys):
3284         * runtime/Structure.cpp:
3285         (JSC::Structure::canCachePropertyNameEnumerator const):
3286         * runtime/Structure.h:
3287         * runtime/StructureInlines.h:
3288         (JSC::Structure::setCachedOwnKeys):
3289         (JSC::Structure::cachedOwnKeys const):
3290         (JSC::Structure::canCacheOwnKeys const):
3291         * runtime/StructureRareData.cpp:
3292         (JSC::StructureRareData::visitChildren):
3293         (JSC::StructureRareData::cachedPropertyNameEnumerator const): Deleted.
3294         (JSC::StructureRareData::setCachedPropertyNameEnumerator): Deleted.
3295         * runtime/StructureRareData.h:
3296         * runtime/StructureRareDataInlines.h:
3297         (JSC::StructureRareData::cachedPropertyNameEnumerator const):
3298         (JSC::StructureRareData::setCachedPropertyNameEnumerator):
3299         (JSC::StructureRareData::cachedOwnKeys const):
3300         (JSC::StructureRareData::cachedOwnKeysConcurrently const):
3301         (JSC::StructureRareData::setCachedOwnKeys):
3302         (JSC::StructureRareData::previousID const): Deleted.
3303         * runtime/VM.cpp:
3304         (JSC::VM::VM):
3305         * runtime/VM.h:
3306
3307 2018-12-12  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
3308
3309         [DFG][FTL] Add NewSymbol
3310         https://bugs.webkit.org/show_bug.cgi?id=192620
3311
3312         Reviewed by Saam Barati.
3313
3314         This patch introduces NewSymbol DFG node into DFG and FTL tiers. The main goal of this patch is not optimize
3315         NewSymbol code faster. Rather than that, this patch intends to offer SpecSymbol type information into DFG's
3316         data flow to optimize generated code in FTL backend.
3317
3318         We add NewSymbol DFG node, which may take an argument. If an argument is not given, NewSymbol is for `Symbol()`.
3319         If an argument is given, ToString is emitted to this argument before passing it to NewSymbol. So NewSymbol node
3320         itself does not perform any type checks. ToString performs effects, but NewSymbol doesn't have any side observable
3321         effects. So we can decouple Symbol(description) call into NewSymbol(ToString(description)).
3322
3323         * dfg/DFGAbstractInterpreterInlines.h:
3324         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
3325         * dfg/DFGByteCodeParser.cpp:
3326         (JSC::DFG::ByteCodeParser::handleConstantInternalFunction):
3327         * dfg/DFGClobberize.h:
3328         (JSC::DFG::clobberize):
3329         * dfg/DFGClobbersExitState.cpp:
3330         (JSC::DFG::clobbersExitState):
3331         * dfg/DFGDoesGC.cpp:
3332         (JSC::DFG::doesGC):
3333         * dfg/DFGFixupPhase.cpp:
3334         (JSC::DFG::FixupPhase::fixupNode):
3335         * dfg/DFGMayExit.cpp:
3336         * dfg/DFGNodeType.h:
3337         * dfg/DFGOperations.cpp:
3338         * dfg/DFGOperations.h:
3339         * dfg/DFGPredictionPropagationPhase.cpp:
3340         * dfg/DFGSafeToExecute.h:
3341         (JSC::DFG::safeToExecute):
3342         * dfg/DFGSpeculativeJIT.cpp:
3343         (JSC::DFG::SpeculativeJIT::compileNewSymbol):
3344         * dfg/DFGSpeculativeJIT.h:
3345         * dfg/DFGSpeculativeJIT32_64.cpp:
3346         (JSC::DFG::SpeculativeJIT::compile):
3347         * dfg/DFGSpeculativeJIT64.cpp: