[BigInt] Add ValueBitLShift into DFG
[WebKit-https.git] / Source / JavaScriptCore / dfg / DFGSpeculativeJIT.h
1 /*
2  * Copyright (C) 2011-2019 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #pragma once
27
28 #if ENABLE(DFG_JIT)
29
30 #include "BlockDirectory.h"
31 #include "DFGAbstractInterpreter.h"
32 #include "DFGGenerationInfo.h"
33 #include "DFGInPlaceAbstractState.h"
34 #include "DFGJITCompiler.h"
35 #include "DFGOSRExit.h"
36 #include "DFGOSRExitJumpPlaceholder.h"
37 #include "DFGRegisterBank.h"
38 #include "DFGSilentRegisterSavePlan.h"
39 #include "JITMathIC.h"
40 #include "JITOperations.h"
41 #include "PutKind.h"
42 #include "SpillRegistersMode.h"
43 #include "StructureStubInfo.h"
44 #include "ValueRecovery.h"
45 #include "VirtualRegister.h"
46
47 namespace JSC { namespace DFG {
48
49 class GPRTemporary;
50 class JSValueOperand;
51 class SlowPathGenerator;
52 class SpeculativeJIT;
53 class SpeculateInt32Operand;
54 class SpeculateStrictInt32Operand;
55 class SpeculateDoubleOperand;
56 class SpeculateCellOperand;
57 class SpeculateBooleanOperand;
58
59 enum GeneratedOperandType { GeneratedOperandTypeUnknown, GeneratedOperandInteger, GeneratedOperandJSValue};
60
61 // === SpeculativeJIT ===
62 //
63 // The SpeculativeJIT is used to generate a fast, but potentially
64 // incomplete code path for the dataflow. When code generating
65 // we may make assumptions about operand types, dynamically check,
66 // and bail-out to an alternate code path if these checks fail.
67 // Importantly, the speculative code path cannot be reentered once
68 // a speculative check has failed. This allows the SpeculativeJIT
69 // to propagate type information (including information that has
70 // only speculatively been asserted) through the dataflow.
71 class SpeculativeJIT {
72     WTF_MAKE_FAST_ALLOCATED;
73
74     friend struct OSRExit;
75 private:
76     typedef JITCompiler::TrustedImm32 TrustedImm32;
77     typedef JITCompiler::Imm32 Imm32;
78     typedef JITCompiler::ImmPtr ImmPtr;
79     typedef JITCompiler::TrustedImm64 TrustedImm64;
80     typedef JITCompiler::Imm64 Imm64;
81
82     // These constants are used to set priorities for spill order for
83     // the register allocator.
84 #if USE(JSVALUE64)
85     enum SpillOrder {
86         SpillOrderConstant = 1, // no spill, and cheap fill
87         SpillOrderSpilled  = 2, // no spill
88         SpillOrderJS       = 4, // needs spill
89         SpillOrderCell     = 4, // needs spill
90         SpillOrderStorage  = 4, // needs spill
91         SpillOrderInteger  = 5, // needs spill and box
92         SpillOrderBoolean  = 5, // needs spill and box
93         SpillOrderDouble   = 6, // needs spill and convert
94     };
95 #elif USE(JSVALUE32_64)
96     enum SpillOrder {
97         SpillOrderConstant = 1, // no spill, and cheap fill
98         SpillOrderSpilled  = 2, // no spill
99         SpillOrderJS       = 4, // needs spill
100         SpillOrderStorage  = 4, // needs spill
101         SpillOrderDouble   = 4, // needs spill
102         SpillOrderInteger  = 5, // needs spill and box
103         SpillOrderCell     = 5, // needs spill and box
104         SpillOrderBoolean  = 5, // needs spill and box
105     };
106 #endif
107
108     enum UseChildrenMode { CallUseChildren, UseChildrenCalledExplicitly };
109     
110 public:
111     SpeculativeJIT(JITCompiler&);
112     ~SpeculativeJIT();
113
114     VM& vm()
115     {
116         return *m_jit.vm();
117     }
118
119     struct TrustedImmPtr {
120         template <typename T>
121         explicit TrustedImmPtr(T* value)
122             : m_value(value)
123         {
124             static_assert(!std::is_base_of<JSCell, T>::value, "To use a GC pointer, the graph must be aware of it. Use SpeculativeJIT::TrustedImmPtr::weakPointer instead.");
125         }
126
127         explicit TrustedImmPtr(RegisteredStructure structure)
128             : m_value(structure.get())
129         { }
130         
131         explicit TrustedImmPtr(std::nullptr_t)
132             : m_value(nullptr)
133         { }
134
135         explicit TrustedImmPtr(FrozenValue* value)
136             : m_value(value->cell())
137         {
138             RELEASE_ASSERT(value->value().isCell());
139         }
140
141         explicit TrustedImmPtr(size_t value)
142             : m_value(bitwise_cast<void*>(value))
143         {
144         }
145
146         static TrustedImmPtr weakPointer(Graph& graph, JSCell* cell)
147         {     
148             graph.m_plan.weakReferences().addLazily(cell);
149             return TrustedImmPtr(bitwise_cast<size_t>(cell));
150         }
151
152         operator MacroAssembler::TrustedImmPtr() const { return m_value; }
153         operator MacroAssembler::TrustedImm() const { return m_value; }
154
155         intptr_t asIntptr()
156         {
157             return m_value.asIntptr();
158         }
159
160     private:
161         MacroAssembler::TrustedImmPtr m_value;
162     };
163
164     bool compile();
165     
166     void createOSREntries();
167     void linkOSREntries(LinkBuffer&);
168
169     BasicBlock* nextBlock()
170     {
171         for (BlockIndex resultIndex = m_block->index + 1; ; resultIndex++) {
172             if (resultIndex >= m_jit.graph().numBlocks())
173                 return 0;
174             if (BasicBlock* result = m_jit.graph().block(resultIndex))
175                 return result;
176         }
177     }
178     
179 #if USE(JSVALUE64)
180     GPRReg fillJSValue(Edge);
181 #elif USE(JSVALUE32_64)
182     bool fillJSValue(Edge, GPRReg&, GPRReg&, FPRReg&);
183 #endif
184     GPRReg fillStorage(Edge);
185
186     // lock and unlock GPR & FPR registers.
187     void lock(GPRReg reg)
188     {
189         m_gprs.lock(reg);
190     }
191     void lock(FPRReg reg)
192     {
193         m_fprs.lock(reg);
194     }
195     void unlock(GPRReg reg)
196     {
197         m_gprs.unlock(reg);
198     }
199     void unlock(FPRReg reg)
200     {
201         m_fprs.unlock(reg);
202     }
203
204     // Used to check whether a child node is on its last use,
205     // and its machine registers may be reused.
206     bool canReuse(Node* node)
207     {
208         return generationInfo(node).useCount() == 1;
209     }
210     bool canReuse(Node* nodeA, Node* nodeB)
211     {
212         return nodeA == nodeB && generationInfo(nodeA).useCount() == 2;
213     }
214     bool canReuse(Edge nodeUse)
215     {
216         return canReuse(nodeUse.node());
217     }
218     GPRReg reuse(GPRReg reg)
219     {
220         m_gprs.lock(reg);
221         return reg;
222     }
223     FPRReg reuse(FPRReg reg)
224     {
225         m_fprs.lock(reg);
226         return reg;
227     }
228
229     // Allocate a gpr/fpr.
230     GPRReg allocate()
231     {
232 #if ENABLE(DFG_REGISTER_ALLOCATION_VALIDATION)
233         m_jit.addRegisterAllocationAtOffset(m_jit.debugOffset());
234 #endif
235         VirtualRegister spillMe;
236         GPRReg gpr = m_gprs.allocate(spillMe);
237         if (spillMe.isValid()) {
238 #if USE(JSVALUE32_64)
239             GenerationInfo& info = generationInfoFromVirtualRegister(spillMe);
240             if ((info.registerFormat() & DataFormatJS))
241                 m_gprs.release(info.tagGPR() == gpr ? info.payloadGPR() : info.tagGPR());
242 #endif
243             spill(spillMe);
244         }
245         return gpr;
246     }
247     GPRReg allocate(GPRReg specific)
248     {
249 #if ENABLE(DFG_REGISTER_ALLOCATION_VALIDATION)
250         m_jit.addRegisterAllocationAtOffset(m_jit.debugOffset());
251 #endif
252         VirtualRegister spillMe = m_gprs.allocateSpecific(specific);
253         if (spillMe.isValid()) {
254 #if USE(JSVALUE32_64)
255             GenerationInfo& info = generationInfoFromVirtualRegister(spillMe);
256             RELEASE_ASSERT(info.registerFormat() != DataFormatJSDouble);
257             if ((info.registerFormat() & DataFormatJS))
258                 m_gprs.release(info.tagGPR() == specific ? info.payloadGPR() : info.tagGPR());
259 #endif
260             spill(spillMe);
261         }
262         return specific;
263     }
264     GPRReg tryAllocate()
265     {
266         return m_gprs.tryAllocate();
267     }
268     FPRReg fprAllocate()
269     {
270 #if ENABLE(DFG_REGISTER_ALLOCATION_VALIDATION)
271         m_jit.addRegisterAllocationAtOffset(m_jit.debugOffset());
272 #endif
273         VirtualRegister spillMe;
274         FPRReg fpr = m_fprs.allocate(spillMe);
275         if (spillMe.isValid())
276             spill(spillMe);
277         return fpr;
278     }
279
280     // Check whether a VirtualRegsiter is currently in a machine register.
281     // We use this when filling operands to fill those that are already in
282     // machine registers first (by locking VirtualRegsiters that are already
283     // in machine register before filling those that are not we attempt to
284     // avoid spilling values we will need immediately).
285     bool isFilled(Node* node)
286     {
287         return generationInfo(node).registerFormat() != DataFormatNone;
288     }
289     bool isFilledDouble(Node* node)
290     {
291         return generationInfo(node).registerFormat() == DataFormatDouble;
292     }
293
294     // Called on an operand once it has been consumed by a parent node.
295     void use(Node* node)
296     {
297         if (!node->hasResult())
298             return;
299         GenerationInfo& info = generationInfo(node);
300
301         // use() returns true when the value becomes dead, and any
302         // associated resources may be freed.
303         if (!info.use(*m_stream))
304             return;
305
306         // Release the associated machine registers.
307         DataFormat registerFormat = info.registerFormat();
308 #if USE(JSVALUE64)
309         if (registerFormat == DataFormatDouble)
310             m_fprs.release(info.fpr());
311         else if (registerFormat != DataFormatNone)
312             m_gprs.release(info.gpr());
313 #elif USE(JSVALUE32_64)
314         if (registerFormat == DataFormatDouble)
315             m_fprs.release(info.fpr());
316         else if (registerFormat & DataFormatJS) {
317             m_gprs.release(info.tagGPR());
318             m_gprs.release(info.payloadGPR());
319         } else if (registerFormat != DataFormatNone)
320             m_gprs.release(info.gpr());
321 #endif
322     }
323     void use(Edge nodeUse)
324     {
325         use(nodeUse.node());
326     }
327     
328     RegisterSet usedRegisters();
329     
330     bool masqueradesAsUndefinedWatchpointIsStillValid(const CodeOrigin& codeOrigin)
331     {
332         return m_jit.graph().masqueradesAsUndefinedWatchpointIsStillValid(codeOrigin);
333     }
334     bool masqueradesAsUndefinedWatchpointIsStillValid()
335     {
336         return masqueradesAsUndefinedWatchpointIsStillValid(m_currentNode->origin.semantic);
337     }
338
339     void compileStoreBarrier(Node*);
340
341     // Called by the speculative operand types, below, to fill operand to
342     // machine registers, implicitly generating speculation checks as needed.
343     GPRReg fillSpeculateInt32(Edge, DataFormat& returnFormat);
344     GPRReg fillSpeculateInt32Strict(Edge);
345     GPRReg fillSpeculateInt52(Edge, DataFormat desiredFormat);
346     FPRReg fillSpeculateDouble(Edge);
347     GPRReg fillSpeculateCell(Edge);
348     GPRReg fillSpeculateBoolean(Edge);
349     GeneratedOperandType checkGeneratedTypeForToInt32(Node*);
350
351     void addSlowPathGenerator(std::unique_ptr<SlowPathGenerator>);
352     void addSlowPathGeneratorLambda(Function<void()>&&);
353     void runSlowPathGenerators(PCToCodeOriginMapBuilder&);
354     
355     void compile(Node*);
356     void noticeOSRBirth(Node*);
357     void bail(AbortReason);
358     void compileCurrentBlock();
359
360     void checkArgumentTypes();
361
362     void clearGenerationInfo();
363
364     // These methods are used when generating 'unexpected'
365     // calls out from JIT code to C++ helper routines -
366     // they spill all live values to the appropriate
367     // slots in the JSStack without changing any state
368     // in the GenerationInfo.
369     SilentRegisterSavePlan silentSavePlanForGPR(VirtualRegister spillMe, GPRReg source);
370     SilentRegisterSavePlan silentSavePlanForFPR(VirtualRegister spillMe, FPRReg source);
371     void silentSpill(const SilentRegisterSavePlan&);
372     void silentFill(const SilentRegisterSavePlan&);
373
374     template<typename CollectionType>
375     void silentSpill(const CollectionType& savePlans)
376     {
377         for (unsigned i = 0; i < savePlans.size(); ++i)
378             silentSpill(savePlans[i]);
379     }
380
381     template<typename CollectionType>
382     void silentFill(const CollectionType& savePlans)
383     {
384         for (unsigned i = savePlans.size(); i--;)
385             silentFill(savePlans[i]);
386     }
387
388     template<typename CollectionType>
389     void silentSpillAllRegistersImpl(bool doSpill, CollectionType& plans, GPRReg exclude, GPRReg exclude2 = InvalidGPRReg, FPRReg fprExclude = InvalidFPRReg)
390     {
391         ASSERT(plans.isEmpty());
392         for (gpr_iterator iter = m_gprs.begin(); iter != m_gprs.end(); ++iter) {
393             GPRReg gpr = iter.regID();
394             if (iter.name().isValid() && gpr != exclude && gpr != exclude2) {
395                 SilentRegisterSavePlan plan = silentSavePlanForGPR(iter.name(), gpr);
396                 if (doSpill)
397                     silentSpill(plan);
398                 plans.append(plan);
399             }
400         }
401         for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
402             if (iter.name().isValid() && iter.regID() != fprExclude) {
403                 SilentRegisterSavePlan plan = silentSavePlanForFPR(iter.name(), iter.regID());
404                 if (doSpill)
405                     silentSpill(plan);
406                 plans.append(plan);
407             }
408         }
409     }
410     template<typename CollectionType>
411     void silentSpillAllRegistersImpl(bool doSpill, CollectionType& plans, NoResultTag)
412     {
413         silentSpillAllRegistersImpl(doSpill, plans, InvalidGPRReg, InvalidGPRReg, InvalidFPRReg);
414     }
415     template<typename CollectionType>
416     void silentSpillAllRegistersImpl(bool doSpill, CollectionType& plans, FPRReg exclude)
417     {
418         silentSpillAllRegistersImpl(doSpill, plans, InvalidGPRReg, InvalidGPRReg, exclude);
419     }
420     template<typename CollectionType>
421     void silentSpillAllRegistersImpl(bool doSpill, CollectionType& plans, JSValueRegs exclude)
422     {
423 #if USE(JSVALUE32_64)
424         silentSpillAllRegistersImpl(doSpill, plans, exclude.tagGPR(), exclude.payloadGPR());
425 #else
426         silentSpillAllRegistersImpl(doSpill, plans, exclude.gpr());
427 #endif
428     }
429     
430     void silentSpillAllRegisters(GPRReg exclude, GPRReg exclude2 = InvalidGPRReg, FPRReg fprExclude = InvalidFPRReg)
431     {
432         silentSpillAllRegistersImpl(true, m_plans, exclude, exclude2, fprExclude);
433     }
434     void silentSpillAllRegisters(FPRReg exclude)
435     {
436         silentSpillAllRegisters(InvalidGPRReg, InvalidGPRReg, exclude);
437     }
438     void silentSpillAllRegisters(JSValueRegs exclude)
439     {
440 #if USE(JSVALUE64)
441         silentSpillAllRegisters(exclude.payloadGPR());
442 #else
443         silentSpillAllRegisters(exclude.payloadGPR(), exclude.tagGPR());
444 #endif
445     }
446
447     void silentFillAllRegisters()
448     {
449         while (!m_plans.isEmpty()) {
450             SilentRegisterSavePlan& plan = m_plans.last();
451             silentFill(plan);
452             m_plans.removeLast();
453         }
454     }
455
456     // These methods convert between doubles, and doubles boxed and JSValues.
457 #if USE(JSVALUE64)
458     GPRReg boxDouble(FPRReg fpr, GPRReg gpr)
459     {
460         return m_jit.boxDouble(fpr, gpr);
461     }
462     FPRReg unboxDouble(GPRReg gpr, GPRReg resultGPR, FPRReg fpr)
463     {
464         return m_jit.unboxDouble(gpr, resultGPR, fpr);
465     }
466     GPRReg boxDouble(FPRReg fpr)
467     {
468         return boxDouble(fpr, allocate());
469     }
470     
471     void boxInt52(GPRReg sourceGPR, GPRReg targetGPR, DataFormat);
472 #elif USE(JSVALUE32_64)
473     void boxDouble(FPRReg fpr, GPRReg tagGPR, GPRReg payloadGPR)
474     {
475         m_jit.boxDouble(fpr, tagGPR, payloadGPR);
476     }
477     void unboxDouble(GPRReg tagGPR, GPRReg payloadGPR, FPRReg fpr, FPRReg scratchFPR)
478     {
479         m_jit.unboxDouble(tagGPR, payloadGPR, fpr, scratchFPR);
480     }
481 #endif
482     void boxDouble(FPRReg fpr, JSValueRegs regs)
483     {
484         m_jit.boxDouble(fpr, regs);
485     }
486
487     // Spill a VirtualRegister to the JSStack.
488     void spill(VirtualRegister spillMe)
489     {
490         GenerationInfo& info = generationInfoFromVirtualRegister(spillMe);
491
492 #if USE(JSVALUE32_64)
493         if (info.registerFormat() == DataFormatNone) // it has been spilled. JS values which have two GPRs can reach here
494             return;
495 #endif
496         // Check the GenerationInfo to see if this value need writing
497         // to the JSStack - if not, mark it as spilled & return.
498         if (!info.needsSpill()) {
499             info.setSpilled(*m_stream, spillMe);
500             return;
501         }
502
503         DataFormat spillFormat = info.registerFormat();
504         switch (spillFormat) {
505         case DataFormatStorage: {
506             // This is special, since it's not a JS value - as in it's not visible to JS
507             // code.
508             m_jit.storePtr(info.gpr(), JITCompiler::addressFor(spillMe));
509             info.spill(*m_stream, spillMe, DataFormatStorage);
510             return;
511         }
512
513         case DataFormatInt32: {
514             m_jit.store32(info.gpr(), JITCompiler::payloadFor(spillMe));
515             info.spill(*m_stream, spillMe, DataFormatInt32);
516             return;
517         }
518
519 #if USE(JSVALUE64)
520         case DataFormatDouble: {
521             m_jit.storeDouble(info.fpr(), JITCompiler::addressFor(spillMe));
522             info.spill(*m_stream, spillMe, DataFormatDouble);
523             return;
524         }
525
526         case DataFormatInt52:
527         case DataFormatStrictInt52: {
528             m_jit.store64(info.gpr(), JITCompiler::addressFor(spillMe));
529             info.spill(*m_stream, spillMe, spillFormat);
530             return;
531         }
532             
533         default:
534             // The following code handles JSValues, int32s, and cells.
535             RELEASE_ASSERT(spillFormat == DataFormatCell || spillFormat & DataFormatJS);
536             
537             GPRReg reg = info.gpr();
538             // We need to box int32 and cell values ...
539             // but on JSVALUE64 boxing a cell is a no-op!
540             if (spillFormat == DataFormatInt32)
541                 m_jit.or64(GPRInfo::tagTypeNumberRegister, reg);
542             
543             // Spill the value, and record it as spilled in its boxed form.
544             m_jit.store64(reg, JITCompiler::addressFor(spillMe));
545             info.spill(*m_stream, spillMe, (DataFormat)(spillFormat | DataFormatJS));
546             return;
547 #elif USE(JSVALUE32_64)
548         case DataFormatCell:
549         case DataFormatBoolean: {
550             m_jit.store32(info.gpr(), JITCompiler::payloadFor(spillMe));
551             info.spill(*m_stream, spillMe, spillFormat);
552             return;
553         }
554
555         case DataFormatDouble: {
556             // On JSVALUE32_64 boxing a double is a no-op.
557             m_jit.storeDouble(info.fpr(), JITCompiler::addressFor(spillMe));
558             info.spill(*m_stream, spillMe, DataFormatDouble);
559             return;
560         }
561
562         default:
563             // The following code handles JSValues.
564             RELEASE_ASSERT(spillFormat & DataFormatJS);
565             m_jit.store32(info.tagGPR(), JITCompiler::tagFor(spillMe));
566             m_jit.store32(info.payloadGPR(), JITCompiler::payloadFor(spillMe));
567             info.spill(*m_stream, spillMe, spillFormat);
568             return;
569 #endif
570         }
571     }
572     
573     bool isKnownInteger(Node* node) { return m_state.forNode(node).isType(SpecInt32Only); }
574     bool isKnownCell(Node* node) { return m_state.forNode(node).isType(SpecCell); }
575     
576     bool isKnownNotInteger(Node* node) { return !(m_state.forNode(node).m_type & SpecInt32Only); }
577     bool isKnownNotNumber(Node* node) { return !(m_state.forNode(node).m_type & SpecFullNumber); }
578     bool isKnownNotCell(Node* node) { return !(m_state.forNode(node).m_type & SpecCell); }
579     bool isKnownNotOther(Node* node) { return !(m_state.forNode(node).m_type & SpecOther); }
580
581     bool canBeRope(Edge&);
582     
583     UniquedStringImpl* identifierUID(unsigned index)
584     {
585         return m_jit.graph().identifiers()[index];
586     }
587
588     // Spill all VirtualRegisters back to the JSStack.
589     void flushRegisters()
590     {
591         for (gpr_iterator iter = m_gprs.begin(); iter != m_gprs.end(); ++iter) {
592             if (iter.name().isValid()) {
593                 spill(iter.name());
594                 iter.release();
595             }
596         }
597         for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
598             if (iter.name().isValid()) {
599                 spill(iter.name());
600                 iter.release();
601             }
602         }
603     }
604
605     // Used to ASSERT flushRegisters() has been called prior to
606     // calling out from JIT code to a C helper function.
607     bool isFlushed()
608     {
609         for (gpr_iterator iter = m_gprs.begin(); iter != m_gprs.end(); ++iter) {
610             if (iter.name().isValid())
611                 return false;
612         }
613         for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
614             if (iter.name().isValid())
615                 return false;
616         }
617         return true;
618     }
619
620 #if USE(JSVALUE64)
621     static MacroAssembler::Imm64 valueOfJSConstantAsImm64(Node* node)
622     {
623         return MacroAssembler::Imm64(JSValue::encode(node->asJSValue()));
624     }
625 #endif
626
627     // Helper functions to enable code sharing in implementations of bit/shift ops.
628     void bitOp(NodeType op, int32_t imm, GPRReg op1, GPRReg result)
629     {
630         switch (op) {
631         case ArithBitAnd:
632             m_jit.and32(Imm32(imm), op1, result);
633             break;
634         case ArithBitOr:
635             m_jit.or32(Imm32(imm), op1, result);
636             break;
637         case ArithBitXor:
638             m_jit.xor32(Imm32(imm), op1, result);
639             break;
640         default:
641             RELEASE_ASSERT_NOT_REACHED();
642         }
643     }
644     void bitOp(NodeType op, GPRReg op1, GPRReg op2, GPRReg result)
645     {
646         switch (op) {
647         case ArithBitAnd:
648             m_jit.and32(op1, op2, result);
649             break;
650         case ArithBitOr:
651             m_jit.or32(op1, op2, result);
652             break;
653         case ArithBitXor:
654             m_jit.xor32(op1, op2, result);
655             break;
656         default:
657             RELEASE_ASSERT_NOT_REACHED();
658         }
659     }
660     void shiftOp(NodeType op, GPRReg op1, int32_t shiftAmount, GPRReg result)
661     {
662         switch (op) {
663         case BitRShift:
664             m_jit.rshift32(op1, Imm32(shiftAmount), result);
665             break;
666         case ArithBitLShift:
667             m_jit.lshift32(op1, Imm32(shiftAmount), result);
668             break;
669         case BitURShift:
670             m_jit.urshift32(op1, Imm32(shiftAmount), result);
671             break;
672         default:
673             RELEASE_ASSERT_NOT_REACHED();
674         }
675     }
676     void shiftOp(NodeType op, GPRReg op1, GPRReg shiftAmount, GPRReg result)
677     {
678         switch (op) {
679         case BitRShift:
680             m_jit.rshift32(op1, shiftAmount, result);
681             break;
682         case ArithBitLShift:
683             m_jit.lshift32(op1, shiftAmount, result);
684             break;
685         case BitURShift:
686             m_jit.urshift32(op1, shiftAmount, result);
687             break;
688         default:
689             RELEASE_ASSERT_NOT_REACHED();
690         }
691     }
692     
693     // Returns the index of the branch node if peephole is okay, UINT_MAX otherwise.
694     unsigned detectPeepHoleBranch()
695     {
696         // Check that no intervening nodes will be generated.
697         for (unsigned index = m_indexInBlock + 1; index < m_block->size() - 1; ++index) {
698             Node* node = m_block->at(index);
699             if (!node->shouldGenerate())
700                 continue;
701             // Check if it's a Phantom that can be safely ignored.
702             if (node->op() == Phantom && !node->child1())
703                 continue;
704             return UINT_MAX;
705         }
706
707         // Check if the lastNode is a branch on this node.
708         Node* lastNode = m_block->terminal();
709         return lastNode->op() == Branch && lastNode->child1() == m_currentNode ? m_block->size() - 1 : UINT_MAX;
710     }
711     
712     void compileCheckTraps(Node*);
713
714     void compileMovHint(Node*);
715     void compileMovHintAndCheck(Node*);
716
717     void cachedGetById(CodeOrigin, JSValueRegs base, JSValueRegs result, unsigned identifierNumber, JITCompiler::Jump slowPathTarget, SpillRegistersMode, AccessType);
718     void cachedPutById(CodeOrigin, GPRReg baseGPR, JSValueRegs valueRegs, GPRReg scratchGPR, unsigned identifierNumber, PutKind, JITCompiler::Jump slowPathTarget = JITCompiler::Jump(), SpillRegistersMode = NeedToSpill);
719
720 #if USE(JSVALUE64)
721     void cachedGetById(CodeOrigin, GPRReg baseGPR, GPRReg resultGPR, unsigned identifierNumber, JITCompiler::Jump slowPathTarget, SpillRegistersMode, AccessType);
722     void cachedGetByIdWithThis(CodeOrigin, GPRReg baseGPR, GPRReg thisGPR, GPRReg resultGPR, unsigned identifierNumber, const JITCompiler::JumpList& slowPathTarget = JITCompiler::JumpList());
723 #elif USE(JSVALUE32_64)
724     void cachedGetById(CodeOrigin, GPRReg baseTagGPROrNone, GPRReg basePayloadGPR, GPRReg resultTagGPR, GPRReg resultPayloadGPR, unsigned identifierNumber, JITCompiler::Jump slowPathTarget, SpillRegistersMode, AccessType);
725     void cachedGetByIdWithThis(CodeOrigin, GPRReg baseTagGPROrNone, GPRReg basePayloadGPR, GPRReg thisTagGPROrNone, GPRReg thisPayloadGPR, GPRReg resultTagGPR, GPRReg resultPayloadGPR, unsigned identifierNumber, const JITCompiler::JumpList& slowPathTarget = JITCompiler::JumpList());
726 #endif
727
728     void compileDeleteById(Node*);
729     void compileDeleteByVal(Node*);
730     void compilePushWithScope(Node*);
731     void compileGetById(Node*, AccessType);
732     void compileGetByIdFlush(Node*, AccessType);
733     void compileInById(Node*);
734     void compileInByVal(Node*);
735     
736     void nonSpeculativeNonPeepholeCompareNullOrUndefined(Edge operand);
737     void nonSpeculativePeepholeBranchNullOrUndefined(Edge operand, Node* branchNode);
738     
739     void nonSpeculativePeepholeBranch(Node*, Node* branchNode, MacroAssembler::RelationalCondition, S_JITOperation_EJJ helperFunction);
740     void nonSpeculativeNonPeepholeCompare(Node*, MacroAssembler::RelationalCondition, S_JITOperation_EJJ helperFunction);
741     
742     void nonSpeculativePeepholeStrictEq(Node*, Node* branchNode, bool invert = false);
743     void nonSpeculativeNonPeepholeStrictEq(Node*, bool invert = false);
744     bool nonSpeculativeStrictEq(Node*, bool invert = false);
745     
746     void compileInstanceOfForCells(Node*, JSValueRegs valueGPR, JSValueRegs prototypeGPR, GPRReg resultGPT, GPRReg scratchGPR, GPRReg scratch2GPR, JITCompiler::Jump slowCase = JITCompiler::Jump());
747     void compileInstanceOf(Node*);
748     void compileInstanceOfCustom(Node*);
749     void compileOverridesHasInstance(Node*);
750
751     void compileIsCellWithType(Node*);
752     void compileIsTypedArrayView(Node*);
753
754     void emitCall(Node*);
755
756     void emitAllocateButterfly(GPRReg storageGPR, GPRReg sizeGPR, GPRReg scratch1, GPRReg scratch2, GPRReg scratch3, MacroAssembler::JumpList& slowCases);
757     void emitInitializeButterfly(GPRReg storageGPR, GPRReg sizeGPR, JSValueRegs emptyValueRegs, GPRReg scratchGPR);
758     void compileAllocateNewArrayWithSize(JSGlobalObject*, GPRReg resultGPR, GPRReg sizeGPR, IndexingType, bool shouldConvertLargeSizeToArrayStorage = true);
759     
760     // Called once a node has completed code generation but prior to setting
761     // its result, to free up its children. (This must happen prior to setting
762     // the nodes result, since the node may have the same VirtualRegister as
763     // a child, and as such will use the same GeneratioInfo).
764     void useChildren(Node*);
765
766     // These method called to initialize the GenerationInfo
767     // to describe the result of an operation.
768     void int32Result(GPRReg reg, Node* node, DataFormat format = DataFormatInt32, UseChildrenMode mode = CallUseChildren)
769     {
770         if (mode == CallUseChildren)
771             useChildren(node);
772
773         VirtualRegister virtualRegister = node->virtualRegister();
774         GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
775
776         if (format == DataFormatInt32) {
777             m_jit.jitAssertIsInt32(reg);
778             m_gprs.retain(reg, virtualRegister, SpillOrderInteger);
779             info.initInt32(node, node->refCount(), reg);
780         } else {
781 #if USE(JSVALUE64)
782             RELEASE_ASSERT(format == DataFormatJSInt32);
783             m_jit.jitAssertIsJSInt32(reg);
784             m_gprs.retain(reg, virtualRegister, SpillOrderJS);
785             info.initJSValue(node, node->refCount(), reg, format);
786 #elif USE(JSVALUE32_64)
787             RELEASE_ASSERT_NOT_REACHED();
788 #endif
789         }
790     }
791     void int32Result(GPRReg reg, Node* node, UseChildrenMode mode)
792     {
793         int32Result(reg, node, DataFormatInt32, mode);
794     }
795     void int52Result(GPRReg reg, Node* node, DataFormat format, UseChildrenMode mode = CallUseChildren)
796     {
797         if (mode == CallUseChildren)
798             useChildren(node);
799
800         VirtualRegister virtualRegister = node->virtualRegister();
801         GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
802
803         m_gprs.retain(reg, virtualRegister, SpillOrderJS);
804         info.initInt52(node, node->refCount(), reg, format);
805     }
806     void int52Result(GPRReg reg, Node* node, UseChildrenMode mode = CallUseChildren)
807     {
808         int52Result(reg, node, DataFormatInt52, mode);
809     }
810     void strictInt52Result(GPRReg reg, Node* node, UseChildrenMode mode = CallUseChildren)
811     {
812         int52Result(reg, node, DataFormatStrictInt52, mode);
813     }
814     void noResult(Node* node, UseChildrenMode mode = CallUseChildren)
815     {
816         if (mode == UseChildrenCalledExplicitly)
817             return;
818         useChildren(node);
819     }
820     void cellResult(GPRReg reg, Node* node, UseChildrenMode mode = CallUseChildren)
821     {
822         if (mode == CallUseChildren)
823             useChildren(node);
824
825         VirtualRegister virtualRegister = node->virtualRegister();
826         m_gprs.retain(reg, virtualRegister, SpillOrderCell);
827         GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
828         info.initCell(node, node->refCount(), reg);
829     }
830     void blessedBooleanResult(GPRReg reg, Node* node, UseChildrenMode mode = CallUseChildren)
831     {
832 #if USE(JSVALUE64)
833         jsValueResult(reg, node, DataFormatJSBoolean, mode);
834 #else
835         booleanResult(reg, node, mode);
836 #endif
837     }
838     void unblessedBooleanResult(GPRReg reg, Node* node, UseChildrenMode mode = CallUseChildren)
839     {
840 #if USE(JSVALUE64)
841         blessBoolean(reg);
842 #endif
843         blessedBooleanResult(reg, node, mode);
844     }
845 #if USE(JSVALUE64)
846     void jsValueResult(GPRReg reg, Node* node, DataFormat format = DataFormatJS, UseChildrenMode mode = CallUseChildren)
847     {
848         if (format == DataFormatJSInt32)
849             m_jit.jitAssertIsJSInt32(reg);
850         
851         if (mode == CallUseChildren)
852             useChildren(node);
853
854         VirtualRegister virtualRegister = node->virtualRegister();
855         m_gprs.retain(reg, virtualRegister, SpillOrderJS);
856         GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
857         info.initJSValue(node, node->refCount(), reg, format);
858     }
859     void jsValueResult(GPRReg reg, Node* node, UseChildrenMode mode)
860     {
861         jsValueResult(reg, node, DataFormatJS, mode);
862     }
863 #elif USE(JSVALUE32_64)
864     void booleanResult(GPRReg reg, Node* node, UseChildrenMode mode = CallUseChildren)
865     {
866         if (mode == CallUseChildren)
867             useChildren(node);
868
869         VirtualRegister virtualRegister = node->virtualRegister();
870         m_gprs.retain(reg, virtualRegister, SpillOrderBoolean);
871         GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
872         info.initBoolean(node, node->refCount(), reg);
873     }
874     void jsValueResult(GPRReg tag, GPRReg payload, Node* node, DataFormat format = DataFormatJS, UseChildrenMode mode = CallUseChildren)
875     {
876         if (mode == CallUseChildren)
877             useChildren(node);
878
879         VirtualRegister virtualRegister = node->virtualRegister();
880         m_gprs.retain(tag, virtualRegister, SpillOrderJS);
881         m_gprs.retain(payload, virtualRegister, SpillOrderJS);
882         GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
883         info.initJSValue(node, node->refCount(), tag, payload, format);
884     }
885     void jsValueResult(GPRReg tag, GPRReg payload, Node* node, UseChildrenMode mode)
886     {
887         jsValueResult(tag, payload, node, DataFormatJS, mode);
888     }
889 #endif
890     void jsValueResult(JSValueRegs regs, Node* node, DataFormat format = DataFormatJS, UseChildrenMode mode = CallUseChildren)
891     {
892 #if USE(JSVALUE64)
893         jsValueResult(regs.gpr(), node, format, mode);
894 #else
895         jsValueResult(regs.tagGPR(), regs.payloadGPR(), node, format, mode);
896 #endif
897     }
898     void storageResult(GPRReg reg, Node* node, UseChildrenMode mode = CallUseChildren)
899     {
900         if (mode == CallUseChildren)
901             useChildren(node);
902         
903         VirtualRegister virtualRegister = node->virtualRegister();
904         m_gprs.retain(reg, virtualRegister, SpillOrderStorage);
905         GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
906         info.initStorage(node, node->refCount(), reg);
907     }
908     void doubleResult(FPRReg reg, Node* node, UseChildrenMode mode = CallUseChildren)
909     {
910         if (mode == CallUseChildren)
911             useChildren(node);
912
913         VirtualRegister virtualRegister = node->virtualRegister();
914         m_fprs.retain(reg, virtualRegister, SpillOrderDouble);
915         GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
916         info.initDouble(node, node->refCount(), reg);
917     }
918     void initConstantInfo(Node* node)
919     {
920         ASSERT(node->hasConstant());
921         generationInfo(node).initConstant(node, node->refCount());
922     }
923
924 #define FIRST_ARGUMENT_TYPE typename FunctionTraits<OperationType>::template ArgumentType<0>
925
926     template<typename OperationType, typename ResultRegType, typename... Args>
927     std::enable_if_t<
928         FunctionTraits<OperationType>::hasResult,
929     JITCompiler::Call>
930     callOperation(OperationType operation, ResultRegType result, Args... args)
931     {
932         m_jit.setupArguments<OperationType>(args...);
933         return appendCallSetResult(operation, result);
934     }
935
936     template<typename OperationType, typename Arg, typename... Args>
937     std::enable_if_t<
938         !FunctionTraits<OperationType>::hasResult
939         && !std::is_same<Arg, NoResultTag>::value,
940     JITCompiler::Call>
941     callOperation(OperationType operation, Arg arg, Args... args)
942     {
943         m_jit.setupArguments<OperationType>(arg, args...);
944         return appendCall(operation);
945     }
946
947     template<typename OperationType, typename... Args>
948     std::enable_if_t<
949         !FunctionTraits<OperationType>::hasResult,
950     JITCompiler::Call>
951     callOperation(OperationType operation, NoResultTag, Args... args)
952     {
953         m_jit.setupArguments<OperationType>(args...);
954         return appendCall(operation);
955     }
956
957     template<typename OperationType>
958     std::enable_if_t<
959         !FunctionTraits<OperationType>::hasResult,
960     JITCompiler::Call>
961     callOperation(OperationType operation)
962     {
963         m_jit.setupArguments<OperationType>();
964         return appendCall(operation);
965     }
966
967 #undef FIRST_ARGUMENT_TYPE
968
969     JITCompiler::Call callOperationWithCallFrameRollbackOnException(V_JITOperation_ECb operation, void* pointer)
970     {
971         m_jit.setupArguments<V_JITOperation_ECb>(TrustedImmPtr(pointer));
972         return appendCallWithCallFrameRollbackOnException(operation);
973     }
974
975     JITCompiler::Call callOperationWithCallFrameRollbackOnException(Z_JITOperation_E operation, GPRReg result)
976     {
977         m_jit.setupArguments<Z_JITOperation_E>();
978         return appendCallWithCallFrameRollbackOnExceptionSetResult(operation, result);
979     }
980     
981 #if !defined(NDEBUG) && !CPU(ARM_THUMB2) && !CPU(MIPS)
982     void prepareForExternalCall()
983     {
984         // We're about to call out to a "native" helper function. The helper
985         // function is expected to set topCallFrame itself with the ExecState
986         // that is passed to it.
987         //
988         // We explicitly trash topCallFrame here so that we'll know if some of
989         // the helper functions are not setting topCallFrame when they should
990         // be doing so. Note: the previous value in topcallFrame was not valid
991         // anyway since it was not being updated by JIT'ed code by design.
992
993         for (unsigned i = 0; i < sizeof(void*) / 4; i++)
994             m_jit.store32(TrustedImm32(0xbadbeef), reinterpret_cast<char*>(&m_jit.vm()->topCallFrame) + i * 4);
995     }
996 #else
997     void prepareForExternalCall() { }
998 #endif
999
1000     // These methods add call instructions, optionally setting results, and optionally rolling back the call frame on an exception.
1001     JITCompiler::Call appendCall(const FunctionPtr<CFunctionPtrTag> function)
1002     {
1003         prepareForExternalCall();
1004         m_jit.emitStoreCodeOrigin(m_currentNode->origin.semantic);
1005         return m_jit.appendCall(function);
1006     }
1007
1008     JITCompiler::Call appendCallWithCallFrameRollbackOnException(const FunctionPtr<CFunctionPtrTag> function)
1009     {
1010         JITCompiler::Call call = appendCall(function);
1011         m_jit.exceptionCheckWithCallFrameRollback();
1012         return call;
1013     }
1014
1015     JITCompiler::Call appendCallWithCallFrameRollbackOnExceptionSetResult(const FunctionPtr<CFunctionPtrTag> function, GPRReg result)
1016     {
1017         JITCompiler::Call call = appendCallWithCallFrameRollbackOnException(function);
1018         if ((result != InvalidGPRReg) && (result != GPRInfo::returnValueGPR))
1019             m_jit.move(GPRInfo::returnValueGPR, result);
1020         return call;
1021     }
1022
1023     JITCompiler::Call appendCallSetResult(const FunctionPtr<CFunctionPtrTag> function, GPRReg result)
1024     {
1025         JITCompiler::Call call = appendCall(function);
1026         if (result != InvalidGPRReg)
1027             m_jit.move(GPRInfo::returnValueGPR, result);
1028         return call;
1029     }
1030
1031     JITCompiler::Call appendCallSetResult(const FunctionPtr<CFunctionPtrTag> function, GPRReg result1, GPRReg result2)
1032     {
1033         JITCompiler::Call call = appendCall(function);
1034         m_jit.setupResults(result1, result2);
1035         return call;
1036     }
1037
1038     JITCompiler::Call appendCallSetResult(const FunctionPtr<CFunctionPtrTag> function, JSValueRegs resultRegs)
1039     {
1040 #if USE(JSVALUE64)
1041         return appendCallSetResult(function, resultRegs.gpr());
1042 #else
1043         return appendCallSetResult(function, resultRegs.payloadGPR(), resultRegs.tagGPR());
1044 #endif
1045     }
1046
1047 #if CPU(X86)
1048     JITCompiler::Call appendCallSetResult(const FunctionPtr<CFunctionPtrTag> function, FPRReg result)
1049     {
1050         JITCompiler::Call call = appendCall(function);
1051         if (result != InvalidFPRReg) {
1052             m_jit.assembler().fstpl(0, JITCompiler::stackPointerRegister);
1053             m_jit.loadDouble(JITCompiler::stackPointerRegister, result);
1054         }
1055         return call;
1056     }
1057 #elif CPU(ARM_THUMB2) && !CPU(ARM_HARDFP)
1058     JITCompiler::Call appendCallSetResult(const FunctionPtr<CFunctionPtrTag> function, FPRReg result)
1059     {
1060         JITCompiler::Call call = appendCall(function);
1061         if (result != InvalidFPRReg)
1062             m_jit.assembler().vmov(result, GPRInfo::returnValueGPR, GPRInfo::returnValueGPR2);
1063         return call;
1064     }
1065 #else // CPU(X86_64) || (CPU(ARM_THUMB2) && CPU(ARM_HARDFP)) || CPU(ARM64) || CPU(MIPS)
1066     JITCompiler::Call appendCallSetResult(const FunctionPtr<CFunctionPtrTag> function, FPRReg result)
1067     {
1068         JITCompiler::Call call = appendCall(function);
1069         if (result != InvalidFPRReg)
1070             m_jit.moveDouble(FPRInfo::returnValueFPR, result);
1071         return call;
1072     }
1073 #endif
1074
1075     void branchDouble(JITCompiler::DoubleCondition cond, FPRReg left, FPRReg right, BasicBlock* destination)
1076     {
1077         return addBranch(m_jit.branchDouble(cond, left, right), destination);
1078     }
1079     
1080     void branchDoubleNonZero(FPRReg value, FPRReg scratch, BasicBlock* destination)
1081     {
1082         return addBranch(m_jit.branchDoubleNonZero(value, scratch), destination);
1083     }
1084     
1085     template<typename T, typename U>
1086     void branch32(JITCompiler::RelationalCondition cond, T left, U right, BasicBlock* destination)
1087     {
1088         return addBranch(m_jit.branch32(cond, left, right), destination);
1089     }
1090     
1091     template<typename T, typename U>
1092     void branchTest32(JITCompiler::ResultCondition cond, T value, U mask, BasicBlock* destination)
1093     {
1094         return addBranch(m_jit.branchTest32(cond, value, mask), destination);
1095     }
1096     
1097     template<typename T>
1098     void branchTest32(JITCompiler::ResultCondition cond, T value, BasicBlock* destination)
1099     {
1100         return addBranch(m_jit.branchTest32(cond, value), destination);
1101     }
1102     
1103 #if USE(JSVALUE64)
1104     template<typename T, typename U>
1105     void branch64(JITCompiler::RelationalCondition cond, T left, U right, BasicBlock* destination)
1106     {
1107         return addBranch(m_jit.branch64(cond, left, right), destination);
1108     }
1109 #endif
1110     
1111     template<typename T, typename U>
1112     void branch8(JITCompiler::RelationalCondition cond, T left, U right, BasicBlock* destination)
1113     {
1114         return addBranch(m_jit.branch8(cond, left, right), destination);
1115     }
1116     
1117     template<typename T, typename U>
1118     void branchPtr(JITCompiler::RelationalCondition cond, T left, U right, BasicBlock* destination)
1119     {
1120         return addBranch(m_jit.branchPtr(cond, left, right), destination);
1121     }
1122     
1123     template<typename T, typename U>
1124     void branchTestPtr(JITCompiler::ResultCondition cond, T value, U mask, BasicBlock* destination)
1125     {
1126         return addBranch(m_jit.branchTestPtr(cond, value, mask), destination);
1127     }
1128     
1129     template<typename T>
1130     void branchTestPtr(JITCompiler::ResultCondition cond, T value, BasicBlock* destination)
1131     {
1132         return addBranch(m_jit.branchTestPtr(cond, value), destination);
1133     }
1134     
1135     template<typename T, typename U>
1136     void branchTest8(JITCompiler::ResultCondition cond, T value, U mask, BasicBlock* destination)
1137     {
1138         return addBranch(m_jit.branchTest8(cond, value, mask), destination);
1139     }
1140     
1141     template<typename T>
1142     void branchTest8(JITCompiler::ResultCondition cond, T value, BasicBlock* destination)
1143     {
1144         return addBranch(m_jit.branchTest8(cond, value), destination);
1145     }
1146     
1147     enum FallThroughMode {
1148         AtFallThroughPoint,
1149         ForceJump
1150     };
1151     void jump(BasicBlock* destination, FallThroughMode fallThroughMode = AtFallThroughPoint)
1152     {
1153         if (destination == nextBlock()
1154             && fallThroughMode == AtFallThroughPoint)
1155             return;
1156         addBranch(m_jit.jump(), destination);
1157     }
1158     
1159     void addBranch(const MacroAssembler::Jump& jump, BasicBlock* destination)
1160     {
1161         m_branches.append(BranchRecord(jump, destination));
1162     }
1163     void addBranch(const MacroAssembler::JumpList& jump, BasicBlock* destination);
1164
1165     void linkBranches();
1166
1167     void dump(const char* label = 0);
1168
1169     bool betterUseStrictInt52(Node* node)
1170     {
1171         return !generationInfo(node).isInt52();
1172     }
1173     bool betterUseStrictInt52(Edge edge)
1174     {
1175         return betterUseStrictInt52(edge.node());
1176     }
1177     
1178     bool compare(Node*, MacroAssembler::RelationalCondition, MacroAssembler::DoubleCondition, S_JITOperation_EJJ);
1179     void compileCompareUnsigned(Node*, MacroAssembler::RelationalCondition);
1180     bool compilePeepHoleBranch(Node*, MacroAssembler::RelationalCondition, MacroAssembler::DoubleCondition, S_JITOperation_EJJ);
1181     void compilePeepHoleInt32Branch(Node*, Node* branchNode, JITCompiler::RelationalCondition);
1182     void compilePeepHoleInt52Branch(Node*, Node* branchNode, JITCompiler::RelationalCondition);
1183     void compilePeepHoleBooleanBranch(Node*, Node* branchNode, JITCompiler::RelationalCondition);
1184     void compilePeepHoleDoubleBranch(Node*, Node* branchNode, JITCompiler::DoubleCondition);
1185     void compilePeepHoleObjectEquality(Node*, Node* branchNode);
1186     void compilePeepHoleObjectStrictEquality(Edge objectChild, Edge otherChild, Node* branchNode);
1187     void compilePeepHoleObjectToObjectOrOtherEquality(Edge leftChild, Edge rightChild, Node* branchNode);
1188     void compileObjectEquality(Node*);
1189     void compileObjectStrictEquality(Edge objectChild, Edge otherChild);
1190     void compileObjectToObjectOrOtherEquality(Edge leftChild, Edge rightChild);
1191     void compileObjectOrOtherLogicalNot(Edge value);
1192     void compileLogicalNot(Node*);
1193     void compileLogicalNotStringOrOther(Node*);
1194     void compileStringEquality(
1195         Node*, GPRReg leftGPR, GPRReg rightGPR, GPRReg lengthGPR,
1196         GPRReg leftTempGPR, GPRReg rightTempGPR, GPRReg leftTemp2GPR,
1197         GPRReg rightTemp2GPR, const JITCompiler::JumpList& fastTrue,
1198         const JITCompiler::JumpList& fastSlow);
1199     void compileStringEquality(Node*);
1200     void compileStringIdentEquality(Node*);
1201     void compileStringToUntypedEquality(Node*, Edge stringEdge, Edge untypedEdge);
1202     void compileStringIdentToNotStringVarEquality(Node*, Edge stringEdge, Edge notStringVarEdge);
1203     void compileStringZeroLength(Node*);
1204     void compileMiscStrictEq(Node*);
1205
1206     void compileSymbolEquality(Node*);
1207     void compileBigIntEquality(Node*);
1208     void compilePeepHoleSymbolEquality(Node*, Node* branchNode);
1209     void compileSymbolUntypedEquality(Node*, Edge symbolEdge, Edge untypedEdge);
1210
1211     void emitObjectOrOtherBranch(Edge value, BasicBlock* taken, BasicBlock* notTaken);
1212     void emitStringBranch(Edge value, BasicBlock* taken, BasicBlock* notTaken);
1213     void emitStringOrOtherBranch(Edge value, BasicBlock* taken, BasicBlock* notTaken);
1214     void emitBranch(Node*);
1215     
1216     struct StringSwitchCase {
1217         StringSwitchCase() { }
1218         
1219         StringSwitchCase(StringImpl* string, BasicBlock* target)
1220             : string(string)
1221             , target(target)
1222         {
1223         }
1224         
1225         bool operator<(const StringSwitchCase& other) const
1226         {
1227             return stringLessThan(*string, *other.string);
1228         }
1229         
1230         StringImpl* string;
1231         BasicBlock* target;
1232     };
1233     
1234     void emitSwitchIntJump(SwitchData*, GPRReg value, GPRReg scratch);
1235     void emitSwitchImm(Node*, SwitchData*);
1236     void emitSwitchCharStringJump(SwitchData*, GPRReg value, GPRReg scratch);
1237     void emitSwitchChar(Node*, SwitchData*);
1238     void emitBinarySwitchStringRecurse(
1239         SwitchData*, const Vector<StringSwitchCase>&, unsigned numChecked,
1240         unsigned begin, unsigned end, GPRReg buffer, GPRReg length, GPRReg temp,
1241         unsigned alreadyCheckedLength, bool checkedExactLength);
1242     void emitSwitchStringOnString(SwitchData*, GPRReg string);
1243     void emitSwitchString(Node*, SwitchData*);
1244     void emitSwitch(Node*);
1245     
1246     void compileToStringOrCallStringConstructorOrStringValueOf(Node*);
1247     void compileNumberToStringWithRadix(Node*);
1248     void compileNumberToStringWithValidRadixConstant(Node*);
1249     void compileNumberToStringWithValidRadixConstant(Node*, int32_t radix);
1250     void compileNewStringObject(Node*);
1251     void compileNewSymbol(Node*);
1252     
1253     void compileNewTypedArrayWithSize(Node*);
1254     
1255     void compileInt32Compare(Node*, MacroAssembler::RelationalCondition);
1256     void compileInt52Compare(Node*, MacroAssembler::RelationalCondition);
1257     void compileBooleanCompare(Node*, MacroAssembler::RelationalCondition);
1258     void compileDoubleCompare(Node*, MacroAssembler::DoubleCondition);
1259     void compileStringCompare(Node*, MacroAssembler::RelationalCondition);
1260     void compileStringIdentCompare(Node*, MacroAssembler::RelationalCondition);
1261     
1262     bool compileStrictEq(Node*);
1263
1264     void compileSameValue(Node*);
1265     
1266     void compileAllocatePropertyStorage(Node*);
1267     void compileReallocatePropertyStorage(Node*);
1268     void compileNukeStructureAndSetButterfly(Node*);
1269     void compileGetButterfly(Node*);
1270     void compileCallDOMGetter(Node*);
1271     void compileCallDOM(Node*);
1272     void compileCheckSubClass(Node*);
1273     void compileNormalizeMapKey(Node*);
1274     void compileGetMapBucketHead(Node*);
1275     void compileGetMapBucketNext(Node*);
1276     void compileSetAdd(Node*);
1277     void compileMapSet(Node*);
1278     void compileWeakMapGet(Node*);
1279     void compileWeakSetAdd(Node*);
1280     void compileWeakMapSet(Node*);
1281     void compileLoadKeyFromMapBucket(Node*);
1282     void compileLoadValueFromMapBucket(Node*);
1283     void compileExtractValueFromWeakMapGet(Node*);
1284     void compileGetPrototypeOf(Node*);
1285     void compileIdentity(Node*);
1286     
1287 #if USE(JSVALUE32_64)
1288     template<typename BaseOperandType, typename PropertyOperandType, typename ValueOperandType, typename TagType>
1289     void compileContiguousPutByVal(Node*, BaseOperandType&, PropertyOperandType&, ValueOperandType&, GPRReg valuePayloadReg, TagType valueTag);
1290 #endif
1291     void compileDoublePutByVal(Node*, SpeculateCellOperand& base, SpeculateStrictInt32Operand& property);
1292     bool putByValWillNeedExtraRegister(ArrayMode arrayMode)
1293     {
1294         return arrayMode.mayStoreToHole();
1295     }
1296     GPRReg temporaryRegisterForPutByVal(GPRTemporary&, ArrayMode);
1297     GPRReg temporaryRegisterForPutByVal(GPRTemporary& temporary, Node* node)
1298     {
1299         return temporaryRegisterForPutByVal(temporary, node->arrayMode());
1300     }
1301     
1302     void compileGetCharCodeAt(Node*);
1303     void compileGetByValOnString(Node*);
1304     void compileFromCharCode(Node*); 
1305
1306     void compileGetByValOnDirectArguments(Node*);
1307     void compileGetByValOnScopedArguments(Node*);
1308     
1309     void compileGetScope(Node*);
1310     void compileSkipScope(Node*);
1311     void compileGetGlobalObject(Node*);
1312     void compileGetGlobalThis(Node*);
1313
1314     void compileGetArrayLength(Node*);
1315
1316     void compileCheckTypeInfoFlags(Node*);
1317     void compileCheckStringIdent(Node*);
1318
1319     void compileParseInt(Node*);
1320     
1321     void compileValueRep(Node*);
1322     void compileDoubleRep(Node*);
1323     
1324     void compileValueToInt32(Node*);
1325     void compileUInt32ToNumber(Node*);
1326     void compileDoubleAsInt32(Node*);
1327
1328     void compileValueBitNot(Node*);
1329     void compileBitwiseNot(Node*);
1330
1331     template<typename SnippetGenerator, J_JITOperation_EJJ slowPathFunction>
1332     void emitUntypedBitOp(Node*);
1333     void compileBitwiseOp(Node*);
1334     void compileValueBitwiseOp(Node*);
1335
1336     void emitUntypedRightShiftBitOp(Node*);
1337     void compileValueLShiftOp(Node*);
1338     void compileShiftOp(Node*);
1339
1340     template <typename Generator, typename RepatchingFunction, typename NonRepatchingFunction>
1341     void compileMathIC(Node*, JITBinaryMathIC<Generator>*, bool needsScratchGPRReg, bool needsScratchFPRReg, RepatchingFunction, NonRepatchingFunction);
1342     template <typename Generator, typename RepatchingFunction, typename NonRepatchingFunction>
1343     void compileMathIC(Node*, JITUnaryMathIC<Generator>*, bool needsScratchGPRReg, RepatchingFunction, NonRepatchingFunction);
1344
1345     void compileArithDoubleUnaryOp(Node*, double (*doubleFunction)(double), double (*operation)(ExecState*, EncodedJSValue));
1346     void compileValueAdd(Node*);
1347     void compileValueSub(Node*);
1348     void compileArithAdd(Node*);
1349     void compileMakeRope(Node*);
1350     void compileArithAbs(Node*);
1351     void compileArithClz32(Node*);
1352     void compileArithSub(Node*);
1353     void compileValueNegate(Node*);
1354     void compileArithNegate(Node*);
1355     void compileValueMul(Node*);
1356     void compileArithMul(Node*);
1357     void compileValueDiv(Node*);
1358     void compileArithDiv(Node*);
1359     void compileArithFRound(Node*);
1360     void compileValueMod(Node*);
1361     void compileArithMod(Node*);
1362     void compileArithPow(Node*);
1363     void compileValuePow(Node*);
1364     void compileArithRounding(Node*);
1365     void compileArithRandom(Node*);
1366     void compileArithUnary(Node*);
1367     void compileArithSqrt(Node*);
1368     void compileArithMinMax(Node*);
1369     void compileConstantStoragePointer(Node*);
1370     void compileGetIndexedPropertyStorage(Node*);
1371     JITCompiler::Jump jumpForTypedArrayOutOfBounds(Node*, GPRReg baseGPR, GPRReg indexGPR);
1372     JITCompiler::Jump jumpForTypedArrayIsNeuteredIfOutOfBounds(Node*, GPRReg baseGPR, JITCompiler::Jump outOfBounds);
1373     void emitTypedArrayBoundsCheck(Node*, GPRReg baseGPR, GPRReg indexGPR);
1374     void compileGetTypedArrayByteOffset(Node*);
1375     void compileGetByValOnIntTypedArray(Node*, TypedArrayType);
1376     void compilePutByValForIntTypedArray(GPRReg base, GPRReg property, Node*, TypedArrayType);
1377     void compileGetByValOnFloatTypedArray(Node*, TypedArrayType);
1378     void compilePutByValForFloatTypedArray(GPRReg base, GPRReg property, Node*, TypedArrayType);
1379     void compileGetByValForObjectWithString(Node*);
1380     void compileGetByValForObjectWithSymbol(Node*);
1381     void compilePutByValForCellWithString(Node*, Edge& child1, Edge& child2, Edge& child3);
1382     void compilePutByValForCellWithSymbol(Node*, Edge& child1, Edge& child2, Edge& child3);
1383     void compileGetByValWithThis(Node*);
1384     void compileGetByOffset(Node*);
1385     void compilePutByOffset(Node*);
1386     void compileMatchStructure(Node*);
1387     // If this returns false it means that we terminated speculative execution.
1388     bool getIntTypedArrayStoreOperand(
1389         GPRTemporary& value,
1390         GPRReg property,
1391 #if USE(JSVALUE32_64)
1392         GPRTemporary& propertyTag,
1393         GPRTemporary& valueTag,
1394 #endif
1395         Edge valueUse, JITCompiler::JumpList& slowPathCases, bool isClamped = false);
1396     void loadFromIntTypedArray(GPRReg storageReg, GPRReg propertyReg, GPRReg resultReg, TypedArrayType);
1397     void setIntTypedArrayLoadResult(Node*, GPRReg resultReg, TypedArrayType, bool canSpeculate = false);
1398     template <typename ClassType> void compileNewFunctionCommon(GPRReg, RegisteredStructure, GPRReg, GPRReg, GPRReg, MacroAssembler::JumpList&, size_t, FunctionExecutable*);
1399     void compileNewFunction(Node*);
1400     void compileSetFunctionName(Node*);
1401     void compileNewRegexp(Node*);
1402     void compileForwardVarargs(Node*);
1403     void compileLoadVarargs(Node*);
1404     void compileCreateActivation(Node*);
1405     void compileCreateDirectArguments(Node*);
1406     void compileGetFromArguments(Node*);
1407     void compilePutToArguments(Node*);
1408     void compileGetArgument(Node*);
1409     void compileCreateScopedArguments(Node*);
1410     void compileCreateClonedArguments(Node*);
1411     void compileCreateRest(Node*);
1412     void compileSpread(Node*);
1413     void compileNewArray(Node*);
1414     void compileNewArrayWithSpread(Node*);
1415     void compileGetRestLength(Node*);
1416     void compileArraySlice(Node*);
1417     void compileArrayIndexOf(Node*);
1418     void compileArrayPush(Node*);
1419     void compileNotifyWrite(Node*);
1420     void compileRegExpExec(Node*);
1421     void compileRegExpExecNonGlobalOrSticky(Node*);
1422     void compileRegExpMatchFast(Node*);
1423     void compileRegExpMatchFastGlobal(Node*);
1424     void compileRegExpTest(Node*);
1425     void compileStringReplace(Node*);
1426     void compileIsObject(Node*);
1427     void compileIsObjectOrNull(Node*);
1428     void compileIsFunction(Node*);
1429     void compileTypeOf(Node*);
1430     void compileCheckCell(Node*);
1431     void compileCheckNotEmpty(Node*);
1432     void compileCheckStructure(Node*);
1433     void emitStructureCheck(Node*, GPRReg cellGPR, GPRReg tempGPR);
1434     void compilePutAccessorById(Node*);
1435     void compilePutGetterSetterById(Node*);
1436     void compilePutAccessorByVal(Node*);
1437     void compileGetRegExpObjectLastIndex(Node*);
1438     void compileSetRegExpObjectLastIndex(Node*);
1439     void compileLazyJSConstant(Node*);
1440     void compileMaterializeNewObject(Node*);
1441     void compileRecordRegExpCachedResult(Node*);
1442     void compileToObjectOrCallObjectConstructor(Node*);
1443     void compileResolveScope(Node*);
1444     void compileResolveScopeForHoistingFuncDeclInEval(Node*);
1445     void compileGetGlobalVariable(Node*);
1446     void compilePutGlobalVariable(Node*);
1447     void compileGetDynamicVar(Node*);
1448     void compilePutDynamicVar(Node*);
1449     void compileGetClosureVar(Node*);
1450     void compilePutClosureVar(Node*);
1451     void compileCompareEqPtr(Node*);
1452     void compileDefineDataProperty(Node*);
1453     void compileDefineAccessorProperty(Node*);
1454     void compileStringSlice(Node*);
1455     void compileToLowerCase(Node*);
1456     void compileThrow(Node*);
1457     void compileThrowStaticError(Node*);
1458     void compileGetEnumerableLength(Node*);
1459     void compileHasGenericProperty(Node*);
1460     void compileToIndexString(Node*);
1461     void compilePutByIdFlush(Node*);
1462     void compilePutById(Node*);
1463     void compilePutByIdDirect(Node*);
1464     void compilePutByIdWithThis(Node*);
1465     void compileHasStructureProperty(Node*);
1466     void compileGetDirectPname(Node*);
1467     void compileGetPropertyEnumerator(Node*);
1468     void compileGetEnumeratorPname(Node*);
1469     void compileGetExecutable(Node*);
1470     void compileGetGetter(Node*);
1471     void compileGetSetter(Node*);
1472     void compileGetCallee(Node*);
1473     void compileSetCallee(Node*);
1474     void compileGetArgumentCountIncludingThis(Node*);
1475     void compileSetArgumentCountIncludingThis(Node*);
1476     void compileStrCat(Node*);
1477     void compileNewArrayBuffer(Node*);
1478     void compileNewArrayWithSize(Node*);
1479     void compileNewTypedArray(Node*);
1480     void compileToThis(Node*);
1481     void compileObjectKeys(Node*);
1482     void compileObjectCreate(Node*);
1483     void compileCreateThis(Node*);
1484     void compileNewObject(Node*);
1485     void compileToPrimitive(Node*);
1486     void compileLogShadowChickenPrologue(Node*);
1487     void compileLogShadowChickenTail(Node*);
1488     void compileHasIndexedProperty(Node*);
1489     void compileExtractCatchLocal(Node*);
1490     void compileClearCatchLocals(Node*);
1491     void compileProfileType(Node*);
1492
1493     void moveTrueTo(GPRReg);
1494     void moveFalseTo(GPRReg);
1495     void blessBoolean(GPRReg);
1496     
1497     // Allocator for a cell of a specific size.
1498     template <typename StructureType> // StructureType can be GPR or ImmPtr.
1499     void emitAllocateJSCell(
1500         GPRReg resultGPR, const JITAllocator& allocator, GPRReg allocatorGPR, StructureType structure,
1501         GPRReg scratchGPR, MacroAssembler::JumpList& slowPath)
1502     {
1503         m_jit.emitAllocateJSCell(resultGPR, allocator, allocatorGPR, structure, scratchGPR, slowPath);
1504     }
1505
1506     // Allocator for an object of a specific size.
1507     template <typename StructureType, typename StorageType> // StructureType and StorageType can be GPR or ImmPtr.
1508     void emitAllocateJSObject(
1509         GPRReg resultGPR, const JITAllocator& allocator, GPRReg allocatorGPR, StructureType structure,
1510         StorageType storage, GPRReg scratchGPR, MacroAssembler::JumpList& slowPath)
1511     {
1512         m_jit.emitAllocateJSObject(
1513             resultGPR, allocator, allocatorGPR, structure, storage, scratchGPR, slowPath);
1514     }
1515
1516     template <typename ClassType, typename StructureType, typename StorageType> // StructureType and StorageType can be GPR or ImmPtr.
1517     void emitAllocateJSObjectWithKnownSize(
1518         GPRReg resultGPR, StructureType structure, StorageType storage, GPRReg scratchGPR1,
1519         GPRReg scratchGPR2, MacroAssembler::JumpList& slowPath, size_t size)
1520     {
1521         m_jit.emitAllocateJSObjectWithKnownSize<ClassType>(*m_jit.vm(), resultGPR, structure, storage, scratchGPR1, scratchGPR2, slowPath, size);
1522     }
1523
1524     // Convenience allocator for a built-in object.
1525     template <typename ClassType, typename StructureType, typename StorageType> // StructureType and StorageType can be GPR or ImmPtr.
1526     void emitAllocateJSObject(GPRReg resultGPR, StructureType structure, StorageType storage,
1527         GPRReg scratchGPR1, GPRReg scratchGPR2, MacroAssembler::JumpList& slowPath)
1528     {
1529         m_jit.emitAllocateJSObject<ClassType>(*m_jit.vm(), resultGPR, structure, storage, scratchGPR1, scratchGPR2, slowPath);
1530     }
1531
1532     template <typename ClassType, typename StructureType> // StructureType and StorageType can be GPR or ImmPtr.
1533     void emitAllocateVariableSizedJSObject(GPRReg resultGPR, StructureType structure, GPRReg allocationSize, GPRReg scratchGPR1, GPRReg scratchGPR2, MacroAssembler::JumpList& slowPath)
1534     {
1535         m_jit.emitAllocateVariableSizedJSObject<ClassType>(*m_jit.vm(), resultGPR, structure, allocationSize, scratchGPR1, scratchGPR2, slowPath);
1536     }
1537
1538     template<typename ClassType>
1539     void emitAllocateDestructibleObject(GPRReg resultGPR, RegisteredStructure structure, 
1540         GPRReg scratchGPR1, GPRReg scratchGPR2, MacroAssembler::JumpList& slowPath)
1541     {
1542         m_jit.emitAllocateDestructibleObject<ClassType>(*m_jit.vm(), resultGPR, structure.get(), scratchGPR1, scratchGPR2, slowPath);
1543     }
1544
1545     void emitAllocateRawObject(GPRReg resultGPR, RegisteredStructure, GPRReg storageGPR, unsigned numElements, unsigned vectorLength);
1546     
1547     void emitGetLength(InlineCallFrame*, GPRReg lengthGPR, bool includeThis = false);
1548     void emitGetLength(CodeOrigin, GPRReg lengthGPR, bool includeThis = false);
1549     void emitGetCallee(CodeOrigin, GPRReg calleeGPR);
1550     void emitGetArgumentStart(CodeOrigin, GPRReg startGPR);
1551     void emitPopulateSliceIndex(Edge&, Optional<GPRReg> indexGPR, GPRReg lengthGPR, GPRReg resultGPR);
1552     
1553     // Generate an OSR exit fuzz check. Returns Jump() if OSR exit fuzz is not enabled, or if
1554     // it's in training mode.
1555     MacroAssembler::Jump emitOSRExitFuzzCheck();
1556     
1557     // Add a speculation check.
1558     void speculationCheck(ExitKind, JSValueSource, Node*, MacroAssembler::Jump jumpToFail);
1559     void speculationCheck(ExitKind, JSValueSource, Node*, const MacroAssembler::JumpList& jumpsToFail);
1560
1561     // Add a speculation check without additional recovery, and with a promise to supply a jump later.
1562     OSRExitJumpPlaceholder speculationCheck(ExitKind, JSValueSource, Node*);
1563     OSRExitJumpPlaceholder speculationCheck(ExitKind, JSValueSource, Edge);
1564     void speculationCheck(ExitKind, JSValueSource, Edge, MacroAssembler::Jump jumpToFail);
1565     void speculationCheck(ExitKind, JSValueSource, Edge, const MacroAssembler::JumpList& jumpsToFail);
1566     // Add a speculation check with additional recovery.
1567     void speculationCheck(ExitKind, JSValueSource, Node*, MacroAssembler::Jump jumpToFail, const SpeculationRecovery&);
1568     void speculationCheck(ExitKind, JSValueSource, Edge, MacroAssembler::Jump jumpToFail, const SpeculationRecovery&);
1569     
1570     void emitInvalidationPoint(Node*);
1571     
1572     void unreachable(Node*);
1573     
1574     // Called when we statically determine that a speculation will fail.
1575     void terminateSpeculativeExecution(ExitKind, JSValueRegs, Node*);
1576     void terminateSpeculativeExecution(ExitKind, JSValueRegs, Edge);
1577     
1578     // Helpers for performing type checks on an edge stored in the given registers.
1579     bool needsTypeCheck(Edge edge, SpeculatedType typesPassedThrough) { return m_interpreter.needsTypeCheck(edge, typesPassedThrough); }
1580     void typeCheck(JSValueSource, Edge, SpeculatedType typesPassedThrough, MacroAssembler::Jump jumpToFail, ExitKind = BadType);
1581     
1582     void speculateCellTypeWithoutTypeFiltering(Edge, GPRReg cellGPR, JSType);
1583     void speculateCellType(Edge, GPRReg cellGPR, SpeculatedType, JSType);
1584     
1585     void speculateInt32(Edge);
1586 #if USE(JSVALUE64)
1587     void convertAnyInt(Edge, GPRReg resultGPR);
1588     void speculateAnyInt(Edge);
1589     void speculateInt32(Edge, JSValueRegs);
1590     void speculateDoubleRepAnyInt(Edge);
1591 #endif // USE(JSVALUE64)
1592     void speculateNumber(Edge);
1593     void speculateRealNumber(Edge);
1594     void speculateDoubleRepReal(Edge);
1595     void speculateBoolean(Edge);
1596     void speculateCell(Edge);
1597     void speculateCellOrOther(Edge);
1598     void speculateObject(Edge, GPRReg cell);
1599     void speculateObject(Edge);
1600     void speculateArray(Edge, GPRReg cell);
1601     void speculateArray(Edge);
1602     void speculateFunction(Edge, GPRReg cell);
1603     void speculateFunction(Edge);
1604     void speculateFinalObject(Edge, GPRReg cell);
1605     void speculateFinalObject(Edge);
1606     void speculateRegExpObject(Edge, GPRReg cell);
1607     void speculateRegExpObject(Edge);
1608     void speculateProxyObject(Edge, GPRReg cell);
1609     void speculateProxyObject(Edge);
1610     void speculateDerivedArray(Edge, GPRReg cell);
1611     void speculateDerivedArray(Edge);
1612     void speculateMapObject(Edge);
1613     void speculateMapObject(Edge, GPRReg cell);
1614     void speculateSetObject(Edge);
1615     void speculateSetObject(Edge, GPRReg cell);
1616     void speculateWeakMapObject(Edge);
1617     void speculateWeakMapObject(Edge, GPRReg cell);
1618     void speculateWeakSetObject(Edge);
1619     void speculateWeakSetObject(Edge, GPRReg cell);
1620     void speculateDataViewObject(Edge);
1621     void speculateDataViewObject(Edge, GPRReg cell);
1622     void speculateObjectOrOther(Edge);
1623     void speculateString(Edge edge, GPRReg cell);
1624     void speculateStringIdentAndLoadStorage(Edge edge, GPRReg string, GPRReg storage);
1625     void speculateStringIdent(Edge edge, GPRReg string);
1626     void speculateStringIdent(Edge);
1627     void speculateString(Edge);
1628     void speculateStringOrOther(Edge, JSValueRegs, GPRReg scratch);
1629     void speculateStringOrOther(Edge);
1630     void speculateNotStringVar(Edge);
1631     void speculateNotSymbol(Edge);
1632     void speculateStringObject(Edge, GPRReg);
1633     void speculateStringObject(Edge);
1634     void speculateStringOrStringObject(Edge);
1635     void speculateSymbol(Edge, GPRReg cell);
1636     void speculateSymbol(Edge);
1637     void speculateBigInt(Edge, GPRReg cell);
1638     void speculateBigInt(Edge);
1639     void speculateNotCell(Edge, JSValueRegs);
1640     void speculateNotCell(Edge);
1641     void speculateOther(Edge, JSValueRegs, GPRReg temp);
1642     void speculateOther(Edge, JSValueRegs);
1643     void speculateOther(Edge);
1644     void speculateMisc(Edge, JSValueRegs);
1645     void speculateMisc(Edge);
1646     void speculate(Node*, Edge);
1647     
1648     JITCompiler::JumpList jumpSlowForUnwantedArrayMode(GPRReg tempWithIndexingTypeReg, ArrayMode);
1649     void checkArray(Node*);
1650     void arrayify(Node*, GPRReg baseReg, GPRReg propertyReg);
1651     void arrayify(Node*);
1652     
1653     template<bool strict>
1654     GPRReg fillSpeculateInt32Internal(Edge, DataFormat& returnFormat);
1655     
1656     void cageTypedArrayStorage(GPRReg, GPRReg);
1657     
1658     void recordSetLocal(
1659         VirtualRegister bytecodeReg, VirtualRegister machineReg, DataFormat format)
1660     {
1661         m_stream->appendAndLog(VariableEvent::setLocal(bytecodeReg, machineReg, format));
1662     }
1663     
1664     void recordSetLocal(DataFormat format)
1665     {
1666         VariableAccessData* variable = m_currentNode->variableAccessData();
1667         recordSetLocal(variable->local(), variable->machineLocal(), format);
1668     }
1669
1670     GenerationInfo& generationInfoFromVirtualRegister(VirtualRegister virtualRegister)
1671     {
1672         return m_generationInfo[virtualRegister.toLocal()];
1673     }
1674     
1675     GenerationInfo& generationInfo(Node* node)
1676     {
1677         return generationInfoFromVirtualRegister(node->virtualRegister());
1678     }
1679     
1680     GenerationInfo& generationInfo(Edge edge)
1681     {
1682         return generationInfo(edge.node());
1683     }
1684
1685     // The JIT, while also provides MacroAssembler functionality.
1686     JITCompiler& m_jit;
1687     Graph& m_graph;
1688
1689     // The current node being generated.
1690     BasicBlock* m_block;
1691     Node* m_currentNode;
1692     NodeType m_lastGeneratedNode;
1693     unsigned m_indexInBlock;
1694
1695     // Virtual and physical register maps.
1696     Vector<GenerationInfo, 32> m_generationInfo;
1697     RegisterBank<GPRInfo> m_gprs;
1698     RegisterBank<FPRInfo> m_fprs;
1699
1700     // It is possible, during speculative generation, to reach a situation in which we
1701     // can statically determine a speculation will fail (for example, when two nodes
1702     // will make conflicting speculations about the same operand). In such cases this
1703     // flag is cleared, indicating no further code generation should take place.
1704     bool m_compileOkay;
1705
1706     Vector<MacroAssembler::Label> m_osrEntryHeads;
1707     
1708     struct BranchRecord {
1709         BranchRecord(MacroAssembler::Jump jump, BasicBlock* destination)
1710             : jump(jump)
1711             , destination(destination)
1712         {
1713         }
1714
1715         MacroAssembler::Jump jump;
1716         BasicBlock* destination;
1717     };
1718     Vector<BranchRecord, 8> m_branches;
1719
1720     NodeOrigin m_origin;
1721     
1722     InPlaceAbstractState m_state;
1723     AbstractInterpreter<InPlaceAbstractState> m_interpreter;
1724     
1725     VariableEventStream* m_stream;
1726     MinifiedGraph* m_minifiedGraph;
1727     
1728     Vector<std::unique_ptr<SlowPathGenerator>, 8> m_slowPathGenerators;
1729     struct SlowPathLambda {
1730         Function<void()> generator;
1731         Node* currentNode;
1732         unsigned streamIndex;
1733     };
1734     Vector<SlowPathLambda> m_slowPathLambdas;
1735     Vector<SilentRegisterSavePlan> m_plans;
1736     Optional<unsigned> m_outOfLineStreamIndex;
1737 };
1738
1739
1740 // === Operand types ===
1741 //
1742 // These classes are used to lock the operands to a node into machine
1743 // registers. These classes implement of pattern of locking a value
1744 // into register at the point of construction only if it is already in
1745 // registers, and otherwise loading it lazily at the point it is first
1746 // used. We do so in order to attempt to avoid spilling one operand
1747 // in order to make space available for another.
1748
1749 class JSValueOperand {
1750 public:
1751     explicit JSValueOperand(SpeculativeJIT* jit, Edge edge, OperandSpeculationMode mode = AutomaticOperandSpeculation)
1752         : m_jit(jit)
1753         , m_edge(edge)
1754 #if USE(JSVALUE64)
1755         , m_gprOrInvalid(InvalidGPRReg)
1756 #elif USE(JSVALUE32_64)
1757         , m_isDouble(false)
1758 #endif
1759     {
1760         ASSERT(m_jit);
1761         if (!edge)
1762             return;
1763         ASSERT_UNUSED(mode, mode == ManualOperandSpeculation || edge.useKind() == UntypedUse);
1764 #if USE(JSVALUE64)
1765         if (jit->isFilled(node()))
1766             gpr();
1767 #elif USE(JSVALUE32_64)
1768         m_register.pair.tagGPR = InvalidGPRReg;
1769         m_register.pair.payloadGPR = InvalidGPRReg;
1770         if (jit->isFilled(node()))
1771             fill();
1772 #endif
1773     }
1774
1775     explicit JSValueOperand(JSValueOperand&& other)
1776         : m_jit(other.m_jit)
1777         , m_edge(other.m_edge)
1778     {
1779 #if USE(JSVALUE64)
1780         m_gprOrInvalid = other.m_gprOrInvalid;
1781 #elif USE(JSVALUE32_64)
1782         m_register.pair.tagGPR = InvalidGPRReg;
1783         m_register.pair.payloadGPR = InvalidGPRReg;
1784         m_isDouble = other.m_isDouble;
1785
1786         if (m_edge) {
1787             if (m_isDouble)
1788                 m_register.fpr = other.m_register.fpr;
1789             else
1790                 m_register.pair = other.m_register.pair;
1791         }
1792 #endif
1793         other.m_edge = Edge();
1794 #if USE(JSVALUE64)
1795         other.m_gprOrInvalid = InvalidGPRReg;
1796 #elif USE(JSVALUE32_64)
1797         other.m_isDouble = false;
1798 #endif
1799     }
1800
1801     ~JSValueOperand()
1802     {
1803         if (!m_edge)
1804             return;
1805 #if USE(JSVALUE64)
1806         ASSERT(m_gprOrInvalid != InvalidGPRReg);
1807         m_jit->unlock(m_gprOrInvalid);
1808 #elif USE(JSVALUE32_64)
1809         if (m_isDouble) {
1810             ASSERT(m_register.fpr != InvalidFPRReg);
1811             m_jit->unlock(m_register.fpr);
1812         } else {
1813             ASSERT(m_register.pair.tagGPR != InvalidGPRReg && m_register.pair.payloadGPR != InvalidGPRReg);
1814             m_jit->unlock(m_register.pair.tagGPR);
1815             m_jit->unlock(m_register.pair.payloadGPR);
1816         }
1817 #endif
1818     }
1819     
1820     Edge edge() const
1821     {
1822         return m_edge;
1823     }
1824
1825     Node* node() const
1826     {
1827         return edge().node();
1828     }
1829
1830 #if USE(JSVALUE64)
1831     GPRReg gpr()
1832     {
1833         if (m_gprOrInvalid == InvalidGPRReg)
1834             m_gprOrInvalid = m_jit->fillJSValue(m_edge);
1835         return m_gprOrInvalid;
1836     }
1837     JSValueRegs jsValueRegs()
1838     {
1839         return JSValueRegs(gpr());
1840     }
1841 #elif USE(JSVALUE32_64)
1842     bool isDouble() { return m_isDouble; }
1843
1844     void fill()
1845     {
1846         if (m_register.pair.tagGPR == InvalidGPRReg && m_register.pair.payloadGPR == InvalidGPRReg)
1847             m_isDouble = !m_jit->fillJSValue(m_edge, m_register.pair.tagGPR, m_register.pair.payloadGPR, m_register.fpr);
1848     }
1849
1850     GPRReg tagGPR()
1851     {
1852         fill();
1853         ASSERT(!m_isDouble);
1854         return m_register.pair.tagGPR;
1855     } 
1856
1857     GPRReg payloadGPR()
1858     {
1859         fill();
1860         ASSERT(!m_isDouble);
1861         return m_register.pair.payloadGPR;
1862     }
1863     
1864     JSValueRegs jsValueRegs()
1865     {
1866         return JSValueRegs(tagGPR(), payloadGPR());
1867     }
1868
1869     GPRReg gpr(WhichValueWord which)
1870     {
1871         return jsValueRegs().gpr(which);
1872     }
1873
1874     FPRReg fpr()
1875     {
1876         fill();
1877         ASSERT(m_isDouble);
1878         return m_register.fpr;
1879     }
1880 #endif
1881
1882     void use()
1883     {
1884         m_jit->use(node());
1885     }
1886
1887 private:
1888     SpeculativeJIT* m_jit;
1889     Edge m_edge;
1890 #if USE(JSVALUE64)
1891     GPRReg m_gprOrInvalid;
1892 #elif USE(JSVALUE32_64)
1893     union {
1894         struct {
1895             GPRReg tagGPR;
1896             GPRReg payloadGPR;
1897         } pair;
1898         FPRReg fpr;
1899     } m_register;
1900     bool m_isDouble;
1901 #endif
1902 };
1903
1904 class StorageOperand {
1905 public:
1906     explicit StorageOperand(SpeculativeJIT* jit, Edge edge)
1907         : m_jit(jit)
1908         , m_edge(edge)
1909         , m_gprOrInvalid(InvalidGPRReg)
1910     {
1911         ASSERT(m_jit);
1912         ASSERT(edge.useKind() == UntypedUse || edge.useKind() == KnownCellUse);
1913         if (jit->isFilled(node()))
1914             gpr();
1915     }
1916     
1917     ~StorageOperand()
1918     {
1919         ASSERT(m_gprOrInvalid != InvalidGPRReg);
1920         m_jit->unlock(m_gprOrInvalid);
1921     }
1922     
1923     Edge edge() const
1924     {
1925         return m_edge;
1926     }
1927     
1928     Node* node() const
1929     {
1930         return edge().node();
1931     }
1932     
1933     GPRReg gpr()
1934     {
1935         if (m_gprOrInvalid == InvalidGPRReg)
1936             m_gprOrInvalid = m_jit->fillStorage(edge());
1937         return m_gprOrInvalid;
1938     }
1939     
1940     void use()
1941     {
1942         m_jit->use(node());
1943     }
1944     
1945 private:
1946     SpeculativeJIT* m_jit;
1947     Edge m_edge;
1948     GPRReg m_gprOrInvalid;
1949 };
1950
1951
1952 // === Temporaries ===
1953 //
1954 // These classes are used to allocate temporary registers.
1955 // A mechanism is provided to attempt to reuse the registers
1956 // currently allocated to child nodes whose value is consumed
1957 // by, and not live after, this operation.
1958
1959 enum ReuseTag { Reuse };
1960
1961 class GPRTemporary {
1962 public:
1963     GPRTemporary();
1964     GPRTemporary(SpeculativeJIT*);
1965     GPRTemporary(SpeculativeJIT*, GPRReg specific);
1966     template<typename T>
1967     GPRTemporary(SpeculativeJIT* jit, ReuseTag, T& operand)
1968         : m_jit(jit)
1969         , m_gpr(InvalidGPRReg)
1970     {
1971         if (m_jit->canReuse(operand.node()))
1972             m_gpr = m_jit->reuse(operand.gpr());
1973         else
1974             m_gpr = m_jit->allocate();
1975     }
1976     template<typename T1, typename T2>
1977     GPRTemporary(SpeculativeJIT* jit, ReuseTag, T1& op1, T2& op2)
1978         : m_jit(jit)
1979         , m_gpr(InvalidGPRReg)
1980     {
1981         if (m_jit->canReuse(op1.node()))
1982             m_gpr = m_jit->reuse(op1.gpr());
1983         else if (m_jit->canReuse(op2.node()))
1984             m_gpr = m_jit->reuse(op2.gpr());
1985         else if (m_jit->canReuse(op1.node(), op2.node()) && op1.gpr() == op2.gpr())
1986             m_gpr = m_jit->reuse(op1.gpr());
1987         else
1988             m_gpr = m_jit->allocate();
1989     }
1990     GPRTemporary(SpeculativeJIT*, ReuseTag, JSValueOperand&, WhichValueWord);
1991
1992     GPRTemporary(GPRTemporary& other) = delete;
1993
1994     GPRTemporary(GPRTemporary&& other)
1995     {
1996         ASSERT(other.m_jit);
1997         ASSERT(other.m_gpr != InvalidGPRReg);
1998         m_jit = other.m_jit;
1999         m_gpr = other.m_gpr;
2000         other.m_jit = nullptr;
2001         other.m_gpr = InvalidGPRReg;
2002     }
2003
2004     GPRTemporary& operator=(GPRTemporary&& other)
2005     {
2006         ASSERT(!m_jit);
2007         ASSERT(m_gpr == InvalidGPRReg);
2008         std::swap(m_jit, other.m_jit);
2009         std::swap(m_gpr, other.m_gpr);
2010         return *this;
2011     }
2012
2013     void adopt(GPRTemporary&);
2014
2015     ~GPRTemporary()
2016     {
2017         if (m_jit && m_gpr != InvalidGPRReg)
2018             m_jit->unlock(gpr());
2019     }
2020
2021     GPRReg gpr()
2022     {
2023         return m_gpr;
2024     }
2025
2026 private:
2027     SpeculativeJIT* m_jit;
2028     GPRReg m_gpr;
2029 };
2030
2031 class JSValueRegsTemporary {
2032 public:
2033     JSValueRegsTemporary();
2034     JSValueRegsTemporary(SpeculativeJIT*);
2035     template<typename T>
2036     JSValueRegsTemporary(SpeculativeJIT*, ReuseTag, T& operand, WhichValueWord resultRegWord = PayloadWord);
2037     JSValueRegsTemporary(SpeculativeJIT*, ReuseTag, JSValueOperand&);
2038     ~JSValueRegsTemporary();
2039     
2040     JSValueRegs regs();
2041
2042 private:
2043 #if USE(JSVALUE64)
2044     GPRTemporary m_gpr;
2045 #else
2046     GPRTemporary m_payloadGPR;
2047     GPRTemporary m_tagGPR;
2048 #endif
2049 };
2050
2051 class FPRTemporary {
2052     WTF_MAKE_NONCOPYABLE(FPRTemporary);
2053 public:
2054     FPRTemporary(FPRTemporary&&);
2055     FPRTemporary(SpeculativeJIT*);
2056     FPRTemporary(SpeculativeJIT*, SpeculateDoubleOperand&);
2057     FPRTemporary(SpeculativeJIT*, SpeculateDoubleOperand&, SpeculateDoubleOperand&);
2058 #if USE(JSVALUE32_64)
2059     FPRTemporary(SpeculativeJIT*, JSValueOperand&);
2060 #endif
2061
2062     ~FPRTemporary()
2063     {
2064         if (LIKELY(m_jit))
2065             m_jit->unlock(fpr());
2066     }
2067
2068     FPRReg fpr() const
2069     {
2070         ASSERT(m_jit);
2071         ASSERT(m_fpr != InvalidFPRReg);
2072         return m_fpr;
2073     }
2074
2075 protected:
2076     FPRTemporary(SpeculativeJIT* jit, FPRReg lockedFPR)
2077         : m_jit(jit)
2078         , m_fpr(lockedFPR)
2079     {
2080     }
2081
2082 private:
2083     SpeculativeJIT* m_jit;
2084     FPRReg m_fpr;
2085 };
2086
2087
2088 // === Results ===
2089 //
2090 // These classes lock the result of a call to a C++ helper function.
2091
2092 class GPRFlushedCallResult : public GPRTemporary {
2093 public:
2094     GPRFlushedCallResult(SpeculativeJIT* jit)
2095         : GPRTemporary(jit, GPRInfo::returnValueGPR)
2096     {
2097     }
2098 };
2099
2100 #if USE(JSVALUE32_64)
2101 class GPRFlushedCallResult2 : public GPRTemporary {
2102 public:
2103     GPRFlushedCallResult2(SpeculativeJIT* jit)
2104         : GPRTemporary(jit, GPRInfo::returnValueGPR2)
2105     {
2106     }
2107 };
2108 #endif
2109
2110 class FPRResult : public FPRTemporary {
2111 public:
2112     FPRResult(SpeculativeJIT* jit)
2113         : FPRTemporary(jit, lockedResult(jit))
2114     {
2115     }
2116
2117 private:
2118     static FPRReg lockedResult(SpeculativeJIT* jit)
2119     {
2120         jit->lock(FPRInfo::returnValueFPR);
2121         return FPRInfo::returnValueFPR;
2122     }
2123 };
2124
2125 class JSValueRegsFlushedCallResult {
2126 public:
2127     JSValueRegsFlushedCallResult(SpeculativeJIT* jit)
2128 #if USE(JSVALUE64)
2129         : m_gpr(jit)
2130 #else
2131         : m_payloadGPR(jit)
2132         , m_tagGPR(jit)
2133 #endif
2134     {
2135     }
2136
2137     JSValueRegs regs()
2138     {
2139 #if USE(JSVALUE64)
2140         return JSValueRegs { m_gpr.gpr() };
2141 #else
2142         return JSValueRegs { m_tagGPR.gpr(), m_payloadGPR.gpr() };
2143 #endif
2144     }
2145
2146 private:
2147 #if USE(JSVALUE64)
2148     GPRFlushedCallResult m_gpr;
2149 #else
2150     GPRFlushedCallResult m_payloadGPR;
2151     GPRFlushedCallResult2 m_tagGPR;
2152 #endif
2153 };
2154
2155
2156 // === Speculative Operand types ===
2157 //
2158 // SpeculateInt32Operand, SpeculateStrictInt32Operand and SpeculateCellOperand.
2159 //
2160 // These are used to lock the operands to a node into machine registers within the
2161 // SpeculativeJIT. The classes operate like those above, however these will
2162 // perform a speculative check for a more restrictive type than we can statically
2163 // determine the operand to have. If the operand does not have the requested type,
2164 // a bail-out to the non-speculative path will be taken.
2165
2166 class SpeculateInt32Operand {
2167 public:
2168     explicit SpeculateInt32Operand(SpeculativeJIT* jit, Edge edge, OperandSpeculationMode mode = AutomaticOperandSpeculation)
2169         : m_jit(jit)
2170         , m_edge(edge)
2171         , m_gprOrInvalid(InvalidGPRReg)
2172 #ifndef NDEBUG
2173         , m_format(DataFormatNone)
2174 #endif
2175     {
2176         ASSERT(m_jit);
2177         ASSERT_UNUSED(mode, mode == ManualOperandSpeculation || (edge.useKind() == Int32Use || edge.useKind() == KnownInt32Use));
2178         if (jit->isFilled(node()))
2179             gpr();
2180     }
2181
2182     ~SpeculateInt32Operand()
2183     {
2184         ASSERT(m_gprOrInvalid != InvalidGPRReg);
2185         m_jit->unlock(m_gprOrInvalid);
2186     }
2187     
2188     Edge edge() const
2189     {
2190         return m_edge;
2191     }
2192
2193     Node* node() const
2194     {
2195         return edge().node();
2196     }
2197
2198     DataFormat format()
2199     {
2200         gpr(); // m_format is set when m_gpr is locked.
2201         ASSERT(m_format == DataFormatInt32 || m_format == DataFormatJSInt32);
2202         return m_format;
2203     }
2204
2205     GPRReg gpr()
2206     {
2207         if (m_gprOrInvalid == InvalidGPRReg)
2208             m_gprOrInvalid = m_jit->fillSpeculateInt32(edge(), m_format);
2209         return m_gprOrInvalid;
2210     }
2211     
2212     void use()
2213     {
2214         m_jit->use(node());
2215     }
2216
2217 private:
2218     SpeculativeJIT* m_jit;
2219     Edge m_edge;
2220     GPRReg m_gprOrInvalid;
2221     DataFormat m_format;
2222 };
2223
2224 class SpeculateStrictInt32Operand {
2225 public:
2226     explicit SpeculateStrictInt32Operand(SpeculativeJIT* jit, Edge edge, OperandSpeculationMode mode = AutomaticOperandSpeculation)
2227         : m_jit(jit)
2228         , m_edge(edge)
2229         , m_gprOrInvalid(InvalidGPRReg)
2230     {
2231         ASSERT(m_jit);
2232         ASSERT_UNUSED(mode, mode == ManualOperandSpeculation || (edge.useKind() == Int32Use || edge.useKind() == KnownInt32Use));
2233         if (jit->isFilled(node()))
2234             gpr();
2235     }
2236
2237     ~SpeculateStrictInt32Operand()
2238     {
2239         ASSERT(m_gprOrInvalid != InvalidGPRReg);
2240         m_jit->unlock(m_gprOrInvalid);
2241     }
2242     
2243     Edge edge() const
2244     {
2245         return m_edge;
2246     }
2247
2248     Node* node() const
2249     {
2250         return edge().node();
2251     }
2252
2253     GPRReg gpr()
2254     {
2255         if (m_gprOrInvalid == InvalidGPRReg)
2256             m_gprOrInvalid = m_jit->fillSpeculateInt32Strict(edge());
2257         return m_gprOrInvalid;
2258     }
2259     
2260     void use()
2261     {
2262         m_jit->use(node());
2263     }
2264
2265 private:
2266     SpeculativeJIT* m_jit;
2267     Edge m_edge;
2268     GPRReg m_gprOrInvalid;
2269 };
2270
2271 // Gives you a canonical Int52 (i.e. it's left-shifted by 16, low bits zero).
2272 class SpeculateInt52Operand {
2273 public:
2274     explicit SpeculateInt52Operand(SpeculativeJIT* jit, Edge edge)
2275         : m_jit(jit)
2276         , m_edge(edge)
2277         , m_gprOrInvalid(InvalidGPRReg)
2278     {
2279         RELEASE_ASSERT(edge.useKind() == Int52RepUse);
2280         if (jit->isFilled(node()))
2281             gpr();
2282     }
2283     
2284     ~SpeculateInt52Operand()
2285     {
2286         ASSERT(m_gprOrInvalid != InvalidGPRReg);
2287         m_jit->unlock(m_gprOrInvalid);
2288     }
2289     
2290     Edge edge() const
2291     {
2292         return m_edge;
2293     }
2294     
2295     Node* node() const
2296     {
2297         return edge().node();
2298     }
2299     
2300     GPRReg gpr()
2301     {
2302         if (m_gprOrInvalid == InvalidGPRReg)
2303             m_gprOrInvalid = m_jit->fillSpeculateInt52(edge(), DataFormatInt52);
2304         return m_gprOrInvalid;
2305     }
2306     
2307     void use()
2308     {
2309         m_jit->use(node());
2310     }
2311     
2312 private:
2313     SpeculativeJIT* m_jit;
2314     Edge m_edge;
2315     GPRReg m_gprOrInvalid;
2316 };
2317
2318 // Gives you a strict Int52 (i.e. the payload is in the low 48 bits, high 16 bits are sign-extended).
2319 class SpeculateStrictInt52Operand {
2320 public:
2321     explicit SpeculateStrictInt52Operand(SpeculativeJIT* jit, Edge edge)
2322         : m_jit(jit)
2323         , m_edge(edge)
2324         , m_gprOrInvalid(InvalidGPRReg)
2325     {
2326         RELEASE_ASSERT(edge.useKind() == Int52RepUse);
2327         if (jit->isFilled(node()))
2328             gpr();
2329     }
2330     
2331     ~SpeculateStrictInt52Operand()
2332     {
2333         ASSERT(m_gprOrInvalid != InvalidGPRReg);
2334         m_jit->unlock(m_gprOrInvalid);
2335     }
2336     
2337     Edge edge() const
2338     {
2339         return m_edge;
2340     }
2341     
2342     Node* node() const
2343     {
2344         return edge().node();
2345     }
2346     
2347     GPRReg gpr()
2348     {
2349         if (m_gprOrInvalid == InvalidGPRReg)
2350             m_gprOrInvalid = m_jit->fillSpeculateInt52(edge(), DataFormatStrictInt52);
2351         return m_gprOrInvalid;
2352     }
2353     
2354     void use()
2355     {
2356         m_jit->use(node());
2357     }
2358     
2359 private:
2360     SpeculativeJIT* m_jit;
2361     Edge m_edge;
2362     GPRReg m_gprOrInvalid;
2363 };
2364
2365 enum OppositeShiftTag { OppositeShift };
2366
2367 class SpeculateWhicheverInt52Operand {
2368 public:
2369     explicit SpeculateWhicheverInt52Operand(SpeculativeJIT* jit, Edge edge)
2370         : m_jit(jit)
2371         , m_edge(edge)
2372         , m_gprOrInvalid(InvalidGPRReg)
2373         , m_strict(jit->betterUseStrictInt52(edge))
2374     {
2375         RELEASE_ASSERT(edge.useKind() == Int52RepUse);
2376         if (jit->isFilled(node()))
2377             gpr();
2378     }
2379     
2380     explicit SpeculateWhicheverInt52Operand(SpeculativeJIT* jit, Edge edge, const SpeculateWhicheverInt52Operand& other)
2381         : m_jit(jit)
2382         , m_edge(edge)
2383         , m_gprOrInvalid(InvalidGPRReg)
2384         , m_strict(other.m_strict)
2385     {
2386         RELEASE_ASSERT(edge.useKind() == Int52RepUse);
2387         if (jit->isFilled(node()))
2388             gpr();
2389     }
2390     
2391     explicit SpeculateWhicheverInt52Operand(SpeculativeJIT* jit, Edge edge, OppositeShiftTag, const SpeculateWhicheverInt52Operand& other)
2392         : m_jit(jit)
2393         , m_edge(edge)
2394         , m_gprOrInvalid(InvalidGPRReg)
2395         , m_strict(!other.m_strict)
2396     {
2397         RELEASE_ASSERT(edge.useKind() == Int52RepUse);
2398         if (jit->isFilled(node()))
2399             gpr();
2400     }
2401     
2402     ~SpeculateWhicheverInt52Operand()
2403     {
2404         ASSERT(m_gprOrInvalid != InvalidGPRReg);
2405         m_jit->unlock(m_gprOrInvalid);
2406     }
2407     
2408     Edge edge() const
2409     {
2410         return m_edge;
2411     }
2412     
2413     Node* node() const
2414     {
2415         return edge().node();
2416     }
2417     
2418     GPRReg gpr()
2419     {
2420         if (m_gprOrInvalid == InvalidGPRReg) {
2421             m_gprOrInvalid = m_jit->fillSpeculateInt52(
2422                 edge(), m_strict ? DataFormatStrictInt52 : DataFormatInt52);
2423         }
2424         return m_gprOrInvalid;
2425     }
2426     
2427     void use()
2428     {
2429         m_jit->use(node());
2430     }
2431     
2432     DataFormat format() const
2433     {
2434         return m_strict ? DataFormatStrictInt52 : DataFormatInt52;
2435     }
2436
2437 private:
2438     SpeculativeJIT* m_jit;
2439     Edge m_edge;
2440     GPRReg m_gprOrInvalid;
2441     bool m_strict;
2442 };
2443
2444 class SpeculateDoubleOperand {
2445 public:
2446     explicit SpeculateDoubleOperand(SpeculativeJIT* jit, Edge edge)
2447         : m_jit(jit)
2448         , m_edge(edge)
2449         , m_fprOrInvalid(InvalidFPRReg)
2450     {
2451         ASSERT(m_jit);
2452         RELEASE_ASSERT(isDouble(edge.useKind()));
2453         if (jit->isFilled(node()))
2454             fpr();
2455     }
2456
2457     ~SpeculateDoubleOperand()
2458     {
2459         ASSERT(m_fprOrInvalid != InvalidFPRReg);
2460         m_jit->unlock(m_fprOrInvalid);
2461     }
2462     
2463     Edge edge() const
2464     {
2465         return m_edge;
2466     }
2467
2468     Node* node() const
2469     {
2470         return edge().node();
2471     }
2472
2473     FPRReg fpr()
2474     {
2475         if (m_fprOrInvalid == InvalidFPRReg)
2476             m_fprOrInvalid = m_jit->fillSpeculateDouble(edge());
2477         return m_fprOrInvalid;
2478     }
2479     
2480     void use()
2481     {
2482         m_jit->use(node());
2483     }
2484
2485 private:
2486     SpeculativeJIT* m_jit;
2487     Edge m_edge;
2488     FPRReg m_fprOrInvalid;
2489 };
2490
2491 class SpeculateCellOperand {
2492     WTF_MAKE_NONCOPYABLE(SpeculateCellOperand);
2493
2494 public:
2495     explicit SpeculateCellOperand(SpeculativeJIT* jit, Edge edge, OperandSpeculationMode mode = AutomaticOperandSpeculation)
2496         : m_jit(jit)
2497         , m_edge(edge)
2498         , m_gprOrInvalid(InvalidGPRReg)
2499     {
2500         ASSERT(m_jit);
2501         if (!edge)
2502             return;
2503         ASSERT_UNUSED(mode, mode == ManualOperandSpeculation || isCell(edge.useKind()));
2504         if (jit->isFilled(node()))
2505             gpr();
2506     }
2507
2508     explicit SpeculateCellOperand(SpeculateCellOperand&& other)
2509     {
2510         m_jit = other.m_jit;
2511         m_edge = other.m_edge;
2512         m_gprOrInvalid = other.m_gprOrInvalid;
2513
2514         other.m_gprOrInvalid = InvalidGPRReg;
2515         other.m_edge = Edge();
2516     }
2517
2518     ~SpeculateCellOperand()
2519     {
2520         if (!m_edge)
2521             return;
2522         ASSERT(m_gprOrInvalid != InvalidGPRReg);
2523         m_jit->unlock(m_gprOrInvalid);
2524     }
2525     
2526     Edge edge() const
2527     {
2528         return m_edge;
2529     }
2530
2531     Node* node() const
2532     {
2533         return edge().node();
2534     }
2535
2536     GPRReg gpr()
2537     {
2538         ASSERT(m_edge);
2539         if (m_gprOrInvalid == InvalidGPRReg)
2540             m_gprOrInvalid = m_jit->fillSpeculateCell(edge());
2541         return m_gprOrInvalid;
2542     }
2543     
2544     void use()
2545     {
2546         ASSERT(m_edge);
2547         m_jit->use(node());
2548     }
2549
2550 private:
2551     SpeculativeJIT* m_jit;
2552     Edge m_edge;
2553     GPRReg m_gprOrInvalid;
2554 };
2555
2556 class SpeculateBooleanOperand {
2557 public:
2558     explicit SpeculateBooleanOperand(SpeculativeJIT* jit, Edge edge, OperandSpeculationMode mode = AutomaticOperandSpeculation)
2559         : m_jit(jit)
2560         , m_edge(edge)
2561         , m_gprOrInvalid(InvalidGPRReg)
2562     {
2563         ASSERT(m_jit);
2564         ASSERT_UNUSED(mode, mode == ManualOperandSpeculation || edge.useKind() == BooleanUse || edge.useKind() == KnownBooleanUse);
2565         if (jit->isFilled(node()))
2566             gpr();
2567     }
2568     
2569     ~SpeculateBooleanOperand()
2570     {
2571         ASSERT(m_gprOrInvalid != InvalidGPRReg);
2572         m_jit->unlock(m_gprOrInvalid);
2573     }
2574     
2575     Edge edge() const
2576     {
2577         return m_edge;
2578     }
2579     
2580     Node* node() const
2581     {
2582         return edge().node();
2583     }
2584     
2585     GPRReg gpr()
2586     {
2587         if (m_gprOrInvalid == InvalidGPRReg)
2588             m_gprOrInvalid = m_jit->fillSpeculateBoolean(edge());
2589         return m_gprOrInvalid;
2590     }
2591     
2592     void use()
2593     {
2594         m_jit->use(node());
2595     }
2596
2597 private:
2598     SpeculativeJIT* m_jit;
2599     Edge m_edge;
2600     GPRReg m_gprOrInvalid;
2601 };
2602
2603 #define DFG_TYPE_CHECK_WITH_EXIT_KIND(exitKind, source, edge, typesPassedThrough, jumpToFail) do { \
2604         JSValueSource _dtc_source = (source);                           \
2605         Edge _dtc_edge = (edge);                                        \
2606         SpeculatedType _dtc_typesPassedThrough = typesPassedThrough;    \
2607         if (!needsTypeCheck(_dtc_edge, _dtc_typesPassedThrough))        \
2608             break;                                                      \
2609         typeCheck(_dtc_source, _dtc_edge, _dtc_typesPassedThrough, (jumpToFail), exitKind); \
2610     } while (0)
2611
2612 #define DFG_TYPE_CHECK(source, edge, typesPassedThrough, jumpToFail) \
2613     DFG_TYPE_CHECK_WITH_EXIT_KIND(BadType, source, edge, typesPassedThrough, jumpToFail)
2614
2615 } } // namespace JSC::DFG
2616
2617 #endif