a0ec8599dec8c55404f1e494e37b4bd36c9ddd00
[WebKit-https.git] / Source / JavaScriptCore / dfg / DFGSpeculativeJIT.h
1 /*
2  * Copyright (C) 2011-2016 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 "DFGAbstractInterpreter.h"
31 #include "DFGGenerationInfo.h"
32 #include "DFGInPlaceAbstractState.h"
33 #include "DFGJITCompiler.h"
34 #include "DFGOSRExit.h"
35 #include "DFGOSRExitJumpPlaceholder.h"
36 #include "DFGSilentRegisterSavePlan.h"
37 #include "DFGValueSource.h"
38 #include "JITMathIC.h"
39 #include "JITOperations.h"
40 #include "MarkedAllocator.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<HeapCell, 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         // This is only here so that TrustedImmPtr(0) does not confuse the C++
132         // overload handling rules.
133         explicit TrustedImmPtr(int value)
134             : m_value(value)
135         {
136             ASSERT(!value);
137         }
138
139         explicit TrustedImmPtr(std::nullptr_t)
140             : m_value(0)
141         { }
142
143         explicit TrustedImmPtr(FrozenValue* value)
144         {
145             RELEASE_ASSERT(value->value().isCell());
146             m_value = MacroAssembler::TrustedImmPtr(value->cell());
147         }
148
149         explicit TrustedImmPtr(size_t value)
150             : m_value(bitwise_cast<void*>(value))
151         {
152         }
153
154         static TrustedImmPtr weakPointer(Graph& graph, JSCell* cell)
155         {     
156             // There are weird relationships in how optimized CodeBlocks
157             // point to other CodeBlocks. We don't want to have them be
158             // part of the weak pointer set. For example, an optimized CodeBlock
159             // having a weak pointer to itself will cause it to get collected.
160             ASSERT(!jsDynamicCast<CodeBlock*>(graph.m_vm, cell));
161
162             graph.m_plan.weakReferences.addLazily(cell);
163             return TrustedImmPtr(bitwise_cast<size_t>(cell));
164         }
165
166         operator MacroAssembler::TrustedImmPtr() const { return m_value; }
167
168         intptr_t asIntptr()
169         {
170             return m_value.asIntptr();
171         }
172
173     private:
174         MacroAssembler::TrustedImmPtr m_value;
175     };
176
177     bool compile();
178     
179     void createOSREntries();
180     void linkOSREntries(LinkBuffer&);
181
182     BasicBlock* nextBlock()
183     {
184         for (BlockIndex resultIndex = m_block->index + 1; ; resultIndex++) {
185             if (resultIndex >= m_jit.graph().numBlocks())
186                 return 0;
187             if (BasicBlock* result = m_jit.graph().block(resultIndex))
188                 return result;
189         }
190     }
191     
192 #if USE(JSVALUE64)
193     GPRReg fillJSValue(Edge);
194 #elif USE(JSVALUE32_64)
195     bool fillJSValue(Edge, GPRReg&, GPRReg&, FPRReg&);
196 #endif
197     GPRReg fillStorage(Edge);
198
199     // lock and unlock GPR & FPR registers.
200     void lock(GPRReg reg)
201     {
202         m_gprs.lock(reg);
203     }
204     void lock(FPRReg reg)
205     {
206         m_fprs.lock(reg);
207     }
208     void unlock(GPRReg reg)
209     {
210         m_gprs.unlock(reg);
211     }
212     void unlock(FPRReg reg)
213     {
214         m_fprs.unlock(reg);
215     }
216
217     // Used to check whether a child node is on its last use,
218     // and its machine registers may be reused.
219     bool canReuse(Node* node)
220     {
221         return generationInfo(node).useCount() == 1;
222     }
223     bool canReuse(Node* nodeA, Node* nodeB)
224     {
225         return nodeA == nodeB && generationInfo(nodeA).useCount() == 2;
226     }
227     bool canReuse(Edge nodeUse)
228     {
229         return canReuse(nodeUse.node());
230     }
231     GPRReg reuse(GPRReg reg)
232     {
233         m_gprs.lock(reg);
234         return reg;
235     }
236     FPRReg reuse(FPRReg reg)
237     {
238         m_fprs.lock(reg);
239         return reg;
240     }
241
242     // Allocate a gpr/fpr.
243     GPRReg allocate()
244     {
245 #if ENABLE(DFG_REGISTER_ALLOCATION_VALIDATION)
246         m_jit.addRegisterAllocationAtOffset(m_jit.debugOffset());
247 #endif
248         VirtualRegister spillMe;
249         GPRReg gpr = m_gprs.allocate(spillMe);
250         if (spillMe.isValid()) {
251 #if USE(JSVALUE32_64)
252             GenerationInfo& info = generationInfoFromVirtualRegister(spillMe);
253             if ((info.registerFormat() & DataFormatJS))
254                 m_gprs.release(info.tagGPR() == gpr ? info.payloadGPR() : info.tagGPR());
255 #endif
256             spill(spillMe);
257         }
258         return gpr;
259     }
260     GPRReg allocate(GPRReg specific)
261     {
262 #if ENABLE(DFG_REGISTER_ALLOCATION_VALIDATION)
263         m_jit.addRegisterAllocationAtOffset(m_jit.debugOffset());
264 #endif
265         VirtualRegister spillMe = m_gprs.allocateSpecific(specific);
266         if (spillMe.isValid()) {
267 #if USE(JSVALUE32_64)
268             GenerationInfo& info = generationInfoFromVirtualRegister(spillMe);
269             RELEASE_ASSERT(info.registerFormat() != DataFormatJSDouble);
270             if ((info.registerFormat() & DataFormatJS))
271                 m_gprs.release(info.tagGPR() == specific ? info.payloadGPR() : info.tagGPR());
272 #endif
273             spill(spillMe);
274         }
275         return specific;
276     }
277     GPRReg tryAllocate()
278     {
279         return m_gprs.tryAllocate();
280     }
281     FPRReg fprAllocate()
282     {
283 #if ENABLE(DFG_REGISTER_ALLOCATION_VALIDATION)
284         m_jit.addRegisterAllocationAtOffset(m_jit.debugOffset());
285 #endif
286         VirtualRegister spillMe;
287         FPRReg fpr = m_fprs.allocate(spillMe);
288         if (spillMe.isValid())
289             spill(spillMe);
290         return fpr;
291     }
292
293     // Check whether a VirtualRegsiter is currently in a machine register.
294     // We use this when filling operands to fill those that are already in
295     // machine registers first (by locking VirtualRegsiters that are already
296     // in machine register before filling those that are not we attempt to
297     // avoid spilling values we will need immediately).
298     bool isFilled(Node* node)
299     {
300         return generationInfo(node).registerFormat() != DataFormatNone;
301     }
302     bool isFilledDouble(Node* node)
303     {
304         return generationInfo(node).registerFormat() == DataFormatDouble;
305     }
306
307     // Called on an operand once it has been consumed by a parent node.
308     void use(Node* node)
309     {
310         if (!node->hasResult())
311             return;
312         GenerationInfo& info = generationInfo(node);
313
314         // use() returns true when the value becomes dead, and any
315         // associated resources may be freed.
316         if (!info.use(*m_stream))
317             return;
318
319         // Release the associated machine registers.
320         DataFormat registerFormat = info.registerFormat();
321 #if USE(JSVALUE64)
322         if (registerFormat == DataFormatDouble)
323             m_fprs.release(info.fpr());
324         else if (registerFormat != DataFormatNone)
325             m_gprs.release(info.gpr());
326 #elif USE(JSVALUE32_64)
327         if (registerFormat == DataFormatDouble)
328             m_fprs.release(info.fpr());
329         else if (registerFormat & DataFormatJS) {
330             m_gprs.release(info.tagGPR());
331             m_gprs.release(info.payloadGPR());
332         } else if (registerFormat != DataFormatNone)
333             m_gprs.release(info.gpr());
334 #endif
335     }
336     void use(Edge nodeUse)
337     {
338         use(nodeUse.node());
339     }
340     
341     RegisterSet usedRegisters();
342     
343     bool masqueradesAsUndefinedWatchpointIsStillValid(const CodeOrigin& codeOrigin)
344     {
345         return m_jit.graph().masqueradesAsUndefinedWatchpointIsStillValid(codeOrigin);
346     }
347     bool masqueradesAsUndefinedWatchpointIsStillValid()
348     {
349         return masqueradesAsUndefinedWatchpointIsStillValid(m_currentNode->origin.semantic);
350     }
351
352     void compileStoreBarrier(Node*);
353
354     static GPRReg selectScratchGPR(GPRReg preserve1 = InvalidGPRReg, GPRReg preserve2 = InvalidGPRReg, GPRReg preserve3 = InvalidGPRReg, GPRReg preserve4 = InvalidGPRReg)
355     {
356         return AssemblyHelpers::selectScratchGPR(preserve1, preserve2, preserve3, preserve4);
357     }
358
359     // Called by the speculative operand types, below, to fill operand to
360     // machine registers, implicitly generating speculation checks as needed.
361     GPRReg fillSpeculateInt32(Edge, DataFormat& returnFormat);
362     GPRReg fillSpeculateInt32Strict(Edge);
363     GPRReg fillSpeculateInt52(Edge, DataFormat desiredFormat);
364     FPRReg fillSpeculateDouble(Edge);
365     GPRReg fillSpeculateCell(Edge);
366     GPRReg fillSpeculateBoolean(Edge);
367     GeneratedOperandType checkGeneratedTypeForToInt32(Node*);
368
369     void addSlowPathGenerator(std::unique_ptr<SlowPathGenerator>);
370     void addSlowPathGenerator(std::function<void()>);
371     void runSlowPathGenerators(PCToCodeOriginMapBuilder&);
372     
373     void compile(Node*);
374     void noticeOSRBirth(Node*);
375     void bail(AbortReason);
376     void compileCurrentBlock();
377
378     void checkArgumentTypes();
379
380     void clearGenerationInfo();
381
382     // These methods are used when generating 'unexpected'
383     // calls out from JIT code to C++ helper routines -
384     // they spill all live values to the appropriate
385     // slots in the JSStack without changing any state
386     // in the GenerationInfo.
387     SilentRegisterSavePlan silentSavePlanForGPR(VirtualRegister spillMe, GPRReg source);
388     SilentRegisterSavePlan silentSavePlanForFPR(VirtualRegister spillMe, FPRReg source);
389     void silentSpill(const SilentRegisterSavePlan&);
390     void silentFill(const SilentRegisterSavePlan&, GPRReg canTrample);
391
392     template<typename CollectionType>
393     void silentSpill(const CollectionType& savePlans)
394     {
395         for (unsigned i = 0; i < savePlans.size(); ++i)
396             silentSpill(savePlans[i]);
397     }
398
399     template<typename CollectionType>
400     void silentFill(const CollectionType& savePlans, GPRReg exclude = InvalidGPRReg)
401     {
402         GPRReg canTrample = SpeculativeJIT::pickCanTrample(exclude);
403         for (unsigned i = savePlans.size(); i--;)
404             silentFill(savePlans[i], canTrample);
405     }
406
407     template<typename CollectionType>
408     void silentSpillAllRegistersImpl(bool doSpill, CollectionType& plans, GPRReg exclude, GPRReg exclude2 = InvalidGPRReg, FPRReg fprExclude = InvalidFPRReg)
409     {
410         ASSERT(plans.isEmpty());
411         for (gpr_iterator iter = m_gprs.begin(); iter != m_gprs.end(); ++iter) {
412             GPRReg gpr = iter.regID();
413             if (iter.name().isValid() && gpr != exclude && gpr != exclude2) {
414                 SilentRegisterSavePlan plan = silentSavePlanForGPR(iter.name(), gpr);
415                 if (doSpill)
416                     silentSpill(plan);
417                 plans.append(plan);
418             }
419         }
420         for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
421             if (iter.name().isValid() && iter.regID() != fprExclude) {
422                 SilentRegisterSavePlan plan = silentSavePlanForFPR(iter.name(), iter.regID());
423                 if (doSpill)
424                     silentSpill(plan);
425                 plans.append(plan);
426             }
427         }
428     }
429     template<typename CollectionType>
430     void silentSpillAllRegistersImpl(bool doSpill, CollectionType& plans, NoResultTag)
431     {
432         silentSpillAllRegistersImpl(doSpill, plans, InvalidGPRReg, InvalidGPRReg, InvalidFPRReg);
433     }
434     template<typename CollectionType>
435     void silentSpillAllRegistersImpl(bool doSpill, CollectionType& plans, FPRReg exclude)
436     {
437         silentSpillAllRegistersImpl(doSpill, plans, InvalidGPRReg, InvalidGPRReg, exclude);
438     }
439     template<typename CollectionType>
440     void silentSpillAllRegistersImpl(bool doSpill, CollectionType& plans, JSValueRegs exclude)
441     {
442 #if USE(JSVALUE32_64)
443         silentSpillAllRegistersImpl(doSpill, plans, exclude.tagGPR(), exclude.payloadGPR());
444 #else
445         silentSpillAllRegistersImpl(doSpill, plans, exclude.gpr());
446 #endif
447     }
448     
449     void silentSpillAllRegisters(GPRReg exclude, GPRReg exclude2 = InvalidGPRReg, FPRReg fprExclude = InvalidFPRReg)
450     {
451         silentSpillAllRegistersImpl(true, m_plans, exclude, exclude2, fprExclude);
452     }
453     void silentSpillAllRegisters(FPRReg exclude)
454     {
455         silentSpillAllRegisters(InvalidGPRReg, InvalidGPRReg, exclude);
456     }
457     void silentSpillAllRegisters(JSValueRegs exclude)
458     {
459 #if USE(JSVALUE64)
460         silentSpillAllRegisters(exclude.payloadGPR());
461 #else
462         silentSpillAllRegisters(exclude.payloadGPR(), exclude.tagGPR());
463 #endif
464     }
465     
466     static GPRReg pickCanTrample(GPRReg exclude)
467     {
468         GPRReg result = GPRInfo::regT0;
469         if (result == exclude)
470             result = GPRInfo::regT1;
471         return result;
472     }
473     static GPRReg pickCanTrample(FPRReg)
474     {
475         return GPRInfo::regT0;
476     }
477     static GPRReg pickCanTrample(NoResultTag)
478     {
479         return GPRInfo::regT0;
480     }
481
482 #if USE(JSVALUE64)
483     static GPRReg pickCanTrample(JSValueRegs exclude)
484     {
485         return pickCanTrample(exclude.payloadGPR());
486     }
487 #else
488     static GPRReg pickCanTrample(JSValueRegs exclude)
489     {
490         GPRReg result = GPRInfo::regT0;
491         if (result == exclude.tagGPR()) {
492             result = GPRInfo::regT1;
493             if (result == exclude.payloadGPR())
494                 result = GPRInfo::regT2;
495         } else if (result == exclude.payloadGPR()) {
496             result = GPRInfo::regT1;
497             if (result == exclude.tagGPR())
498                 result = GPRInfo::regT2;
499         }
500         return result;
501     }
502 #endif
503     
504     template<typename RegisterType>
505     void silentFillAllRegisters(RegisterType exclude)
506     {
507         GPRReg canTrample = pickCanTrample(exclude);
508         
509         while (!m_plans.isEmpty()) {
510             SilentRegisterSavePlan& plan = m_plans.last();
511             silentFill(plan, canTrample);
512             m_plans.removeLast();
513         }
514     }
515
516     // These methods convert between doubles, and doubles boxed and JSValues.
517 #if USE(JSVALUE64)
518     GPRReg boxDouble(FPRReg fpr, GPRReg gpr)
519     {
520         return m_jit.boxDouble(fpr, gpr);
521     }
522     FPRReg unboxDouble(GPRReg gpr, GPRReg resultGPR, FPRReg fpr)
523     {
524         return m_jit.unboxDouble(gpr, resultGPR, fpr);
525     }
526     GPRReg boxDouble(FPRReg fpr)
527     {
528         return boxDouble(fpr, allocate());
529     }
530     
531     void boxInt52(GPRReg sourceGPR, GPRReg targetGPR, DataFormat);
532 #elif USE(JSVALUE32_64)
533     void boxDouble(FPRReg fpr, GPRReg tagGPR, GPRReg payloadGPR)
534     {
535         m_jit.boxDouble(fpr, tagGPR, payloadGPR);
536     }
537     void unboxDouble(GPRReg tagGPR, GPRReg payloadGPR, FPRReg fpr, FPRReg scratchFPR)
538     {
539         m_jit.unboxDouble(tagGPR, payloadGPR, fpr, scratchFPR);
540     }
541 #endif
542     void boxDouble(FPRReg fpr, JSValueRegs regs)
543     {
544         m_jit.boxDouble(fpr, regs);
545     }
546
547     // Spill a VirtualRegister to the JSStack.
548     void spill(VirtualRegister spillMe)
549     {
550         GenerationInfo& info = generationInfoFromVirtualRegister(spillMe);
551
552 #if USE(JSVALUE32_64)
553         if (info.registerFormat() == DataFormatNone) // it has been spilled. JS values which have two GPRs can reach here
554             return;
555 #endif
556         // Check the GenerationInfo to see if this value need writing
557         // to the JSStack - if not, mark it as spilled & return.
558         if (!info.needsSpill()) {
559             info.setSpilled(*m_stream, spillMe);
560             return;
561         }
562
563         DataFormat spillFormat = info.registerFormat();
564         switch (spillFormat) {
565         case DataFormatStorage: {
566             // This is special, since it's not a JS value - as in it's not visible to JS
567             // code.
568             m_jit.storePtr(info.gpr(), JITCompiler::addressFor(spillMe));
569             info.spill(*m_stream, spillMe, DataFormatStorage);
570             return;
571         }
572
573         case DataFormatInt32: {
574             m_jit.store32(info.gpr(), JITCompiler::payloadFor(spillMe));
575             info.spill(*m_stream, spillMe, DataFormatInt32);
576             return;
577         }
578
579 #if USE(JSVALUE64)
580         case DataFormatDouble: {
581             m_jit.storeDouble(info.fpr(), JITCompiler::addressFor(spillMe));
582             info.spill(*m_stream, spillMe, DataFormatDouble);
583             return;
584         }
585
586         case DataFormatInt52:
587         case DataFormatStrictInt52: {
588             m_jit.store64(info.gpr(), JITCompiler::addressFor(spillMe));
589             info.spill(*m_stream, spillMe, spillFormat);
590             return;
591         }
592             
593         default:
594             // The following code handles JSValues, int32s, and cells.
595             RELEASE_ASSERT(spillFormat == DataFormatCell || spillFormat & DataFormatJS);
596             
597             GPRReg reg = info.gpr();
598             // We need to box int32 and cell values ...
599             // but on JSVALUE64 boxing a cell is a no-op!
600             if (spillFormat == DataFormatInt32)
601                 m_jit.or64(GPRInfo::tagTypeNumberRegister, reg);
602             
603             // Spill the value, and record it as spilled in its boxed form.
604             m_jit.store64(reg, JITCompiler::addressFor(spillMe));
605             info.spill(*m_stream, spillMe, (DataFormat)(spillFormat | DataFormatJS));
606             return;
607 #elif USE(JSVALUE32_64)
608         case DataFormatCell:
609         case DataFormatBoolean: {
610             m_jit.store32(info.gpr(), JITCompiler::payloadFor(spillMe));
611             info.spill(*m_stream, spillMe, spillFormat);
612             return;
613         }
614
615         case DataFormatDouble: {
616             // On JSVALUE32_64 boxing a double is a no-op.
617             m_jit.storeDouble(info.fpr(), JITCompiler::addressFor(spillMe));
618             info.spill(*m_stream, spillMe, DataFormatDouble);
619             return;
620         }
621
622         default:
623             // The following code handles JSValues.
624             RELEASE_ASSERT(spillFormat & DataFormatJS);
625             m_jit.store32(info.tagGPR(), JITCompiler::tagFor(spillMe));
626             m_jit.store32(info.payloadGPR(), JITCompiler::payloadFor(spillMe));
627             info.spill(*m_stream, spillMe, spillFormat);
628             return;
629 #endif
630         }
631     }
632     
633     bool isKnownInteger(Node* node) { return m_state.forNode(node).isType(SpecInt32Only); }
634     bool isKnownCell(Node* node) { return m_state.forNode(node).isType(SpecCell); }
635     
636     bool isKnownNotInteger(Node* node) { return !(m_state.forNode(node).m_type & SpecInt32Only); }
637     bool isKnownNotNumber(Node* node) { return !(m_state.forNode(node).m_type & SpecFullNumber); }
638     bool isKnownNotCell(Node* node) { return !(m_state.forNode(node).m_type & SpecCell); }
639     bool isKnownNotOther(Node* node) { return !(m_state.forNode(node).m_type & SpecOther); }
640     
641     UniquedStringImpl* identifierUID(unsigned index)
642     {
643         return m_jit.graph().identifiers()[index];
644     }
645
646     // Spill all VirtualRegisters back to the JSStack.
647     void flushRegisters()
648     {
649         for (gpr_iterator iter = m_gprs.begin(); iter != m_gprs.end(); ++iter) {
650             if (iter.name().isValid()) {
651                 spill(iter.name());
652                 iter.release();
653             }
654         }
655         for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
656             if (iter.name().isValid()) {
657                 spill(iter.name());
658                 iter.release();
659             }
660         }
661     }
662
663     // Used to ASSERT flushRegisters() has been called prior to
664     // calling out from JIT code to a C helper function.
665     bool isFlushed()
666     {
667         for (gpr_iterator iter = m_gprs.begin(); iter != m_gprs.end(); ++iter) {
668             if (iter.name().isValid())
669                 return false;
670         }
671         for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
672             if (iter.name().isValid())
673                 return false;
674         }
675         return true;
676     }
677
678 #if USE(JSVALUE64)
679     static MacroAssembler::Imm64 valueOfJSConstantAsImm64(Node* node)
680     {
681         return MacroAssembler::Imm64(JSValue::encode(node->asJSValue()));
682     }
683 #endif
684
685     // Helper functions to enable code sharing in implementations of bit/shift ops.
686     void bitOp(NodeType op, int32_t imm, GPRReg op1, GPRReg result)
687     {
688         switch (op) {
689         case BitAnd:
690             m_jit.and32(Imm32(imm), op1, result);
691             break;
692         case BitOr:
693             m_jit.or32(Imm32(imm), op1, result);
694             break;
695         case BitXor:
696             m_jit.xor32(Imm32(imm), op1, result);
697             break;
698         default:
699             RELEASE_ASSERT_NOT_REACHED();
700         }
701     }
702     void bitOp(NodeType op, GPRReg op1, GPRReg op2, GPRReg result)
703     {
704         switch (op) {
705         case BitAnd:
706             m_jit.and32(op1, op2, result);
707             break;
708         case BitOr:
709             m_jit.or32(op1, op2, result);
710             break;
711         case BitXor:
712             m_jit.xor32(op1, op2, result);
713             break;
714         default:
715             RELEASE_ASSERT_NOT_REACHED();
716         }
717     }
718     void shiftOp(NodeType op, GPRReg op1, int32_t shiftAmount, GPRReg result)
719     {
720         switch (op) {
721         case BitRShift:
722             m_jit.rshift32(op1, Imm32(shiftAmount), result);
723             break;
724         case BitLShift:
725             m_jit.lshift32(op1, Imm32(shiftAmount), result);
726             break;
727         case BitURShift:
728             m_jit.urshift32(op1, Imm32(shiftAmount), result);
729             break;
730         default:
731             RELEASE_ASSERT_NOT_REACHED();
732         }
733     }
734     void shiftOp(NodeType op, GPRReg op1, GPRReg shiftAmount, GPRReg result)
735     {
736         switch (op) {
737         case BitRShift:
738             m_jit.rshift32(op1, shiftAmount, result);
739             break;
740         case BitLShift:
741             m_jit.lshift32(op1, shiftAmount, result);
742             break;
743         case BitURShift:
744             m_jit.urshift32(op1, shiftAmount, result);
745             break;
746         default:
747             RELEASE_ASSERT_NOT_REACHED();
748         }
749     }
750     
751     // Returns the index of the branch node if peephole is okay, UINT_MAX otherwise.
752     unsigned detectPeepHoleBranch()
753     {
754         // Check that no intervening nodes will be generated.
755         for (unsigned index = m_indexInBlock + 1; index < m_block->size() - 1; ++index) {
756             Node* node = m_block->at(index);
757             if (!node->shouldGenerate())
758                 continue;
759             // Check if it's a Phantom that can be safely ignored.
760             if (node->op() == Phantom && !node->child1())
761                 continue;
762             return UINT_MAX;
763         }
764
765         // Check if the lastNode is a branch on this node.
766         Node* lastNode = m_block->terminal();
767         return lastNode->op() == Branch && lastNode->child1() == m_currentNode ? m_block->size() - 1 : UINT_MAX;
768     }
769     
770     void compileCheckTraps(Node*);
771
772     void compileMovHint(Node*);
773     void compileMovHintAndCheck(Node*);
774
775     void cachedGetById(CodeOrigin, JSValueRegs base, JSValueRegs result, unsigned identifierNumber, JITCompiler::Jump slowPathTarget = JITCompiler::Jump(), SpillRegistersMode = NeedToSpill, AccessType = AccessType::Get);
776
777 #if USE(JSVALUE64)
778     void cachedGetById(CodeOrigin, GPRReg baseGPR, GPRReg resultGPR, unsigned identifierNumber, JITCompiler::Jump slowPathTarget = JITCompiler::Jump(), SpillRegistersMode = NeedToSpill, AccessType = AccessType::Get);
779     void cachedPutById(CodeOrigin, GPRReg base, GPRReg value, GPRReg scratchGPR, unsigned identifierNumber, PutKind, JITCompiler::Jump slowPathTarget = JITCompiler::Jump(), SpillRegistersMode = NeedToSpill);
780     void cachedGetByIdWithThis(CodeOrigin, GPRReg baseGPR, GPRReg thisGPR, GPRReg resultGPR, unsigned identifierNumber, JITCompiler::JumpList slowPathTarget = JITCompiler::JumpList());
781 #elif USE(JSVALUE32_64)
782     void cachedGetById(CodeOrigin, GPRReg baseTagGPROrNone, GPRReg basePayloadGPR, GPRReg resultTagGPR, GPRReg resultPayloadGPR, unsigned identifierNumber, JITCompiler::Jump slowPathTarget = JITCompiler::Jump(), SpillRegistersMode = NeedToSpill, AccessType = AccessType::Get);
783     void cachedPutById(CodeOrigin, GPRReg basePayloadGPR, GPRReg valueTagGPR, GPRReg valuePayloadGPR, GPRReg scratchGPR, unsigned identifierNumber, PutKind, JITCompiler::Jump slowPathTarget = JITCompiler::Jump(), SpillRegistersMode = NeedToSpill);
784     void cachedGetByIdWithThis(CodeOrigin, GPRReg baseTagGPROrNone, GPRReg basePayloadGPR, GPRReg thisTagGPROrNone, GPRReg thisPayloadGPR, GPRReg resultTagGPR, GPRReg resultPayloadGPR, unsigned identifierNumber, JITCompiler::JumpList slowPathTarget = JITCompiler::JumpList());
785 #endif
786
787     void compileDeleteById(Node*);
788     void compileDeleteByVal(Node*);
789     void compileTryGetById(Node*);
790     void compileIn(Node*);
791     
792     void nonSpeculativeNonPeepholeCompareNullOrUndefined(Edge operand);
793     void nonSpeculativePeepholeBranchNullOrUndefined(Edge operand, Node* branchNode);
794     
795     void nonSpeculativePeepholeBranch(Node*, Node* branchNode, MacroAssembler::RelationalCondition, S_JITOperation_EJJ helperFunction);
796     void nonSpeculativeNonPeepholeCompare(Node*, MacroAssembler::RelationalCondition, S_JITOperation_EJJ helperFunction);
797     bool nonSpeculativeCompare(Node*, MacroAssembler::RelationalCondition, S_JITOperation_EJJ helperFunction);
798     
799     void nonSpeculativePeepholeStrictEq(Node*, Node* branchNode, bool invert = false);
800     void nonSpeculativeNonPeepholeStrictEq(Node*, bool invert = false);
801     bool nonSpeculativeStrictEq(Node*, bool invert = false);
802     
803     void compileInstanceOfForObject(Node*, GPRReg valueReg, GPRReg prototypeReg, GPRReg scratchAndResultReg, GPRReg scratch2Reg);
804     void compileInstanceOf(Node*);
805     void compileInstanceOfCustom(Node*);
806
807     void compileIsCellWithType(Node*);
808     void compileIsTypedArrayView(Node*);
809
810     void emitCall(Node*);
811
812     void emitAllocateButterfly(GPRReg storageGPR, GPRReg sizeGPR, GPRReg scratch1, GPRReg scratch2, GPRReg scratch3, MacroAssembler::JumpList& slowCases);
813     void emitInitializeButterfly(GPRReg storageGPR, GPRReg sizeGPR, JSValueRegs emptyValueRegs, GPRReg scratchGPR);
814     void compileAllocateNewArrayWithSize(JSGlobalObject*, GPRReg resultGPR, GPRReg sizeGPR, IndexingType, bool shouldConvertLargeSizeToArrayStorage = true);
815     
816     // Called once a node has completed code generation but prior to setting
817     // its result, to free up its children. (This must happen prior to setting
818     // the nodes result, since the node may have the same VirtualRegister as
819     // a child, and as such will use the same GeneratioInfo).
820     void useChildren(Node*);
821
822     // These method called to initialize the the GenerationInfo
823     // to describe the result of an operation.
824     void int32Result(GPRReg reg, Node* node, DataFormat format = DataFormatInt32, UseChildrenMode mode = CallUseChildren)
825     {
826         if (mode == CallUseChildren)
827             useChildren(node);
828
829         VirtualRegister virtualRegister = node->virtualRegister();
830         GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
831
832         if (format == DataFormatInt32) {
833             m_jit.jitAssertIsInt32(reg);
834             m_gprs.retain(reg, virtualRegister, SpillOrderInteger);
835             info.initInt32(node, node->refCount(), reg);
836         } else {
837 #if USE(JSVALUE64)
838             RELEASE_ASSERT(format == DataFormatJSInt32);
839             m_jit.jitAssertIsJSInt32(reg);
840             m_gprs.retain(reg, virtualRegister, SpillOrderJS);
841             info.initJSValue(node, node->refCount(), reg, format);
842 #elif USE(JSVALUE32_64)
843             RELEASE_ASSERT_NOT_REACHED();
844 #endif
845         }
846     }
847     void int32Result(GPRReg reg, Node* node, UseChildrenMode mode)
848     {
849         int32Result(reg, node, DataFormatInt32, mode);
850     }
851     void int52Result(GPRReg reg, Node* node, DataFormat format, UseChildrenMode mode = CallUseChildren)
852     {
853         if (mode == CallUseChildren)
854             useChildren(node);
855
856         VirtualRegister virtualRegister = node->virtualRegister();
857         GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
858
859         m_gprs.retain(reg, virtualRegister, SpillOrderJS);
860         info.initInt52(node, node->refCount(), reg, format);
861     }
862     void int52Result(GPRReg reg, Node* node, UseChildrenMode mode = CallUseChildren)
863     {
864         int52Result(reg, node, DataFormatInt52, mode);
865     }
866     void strictInt52Result(GPRReg reg, Node* node, UseChildrenMode mode = CallUseChildren)
867     {
868         int52Result(reg, node, DataFormatStrictInt52, mode);
869     }
870     void noResult(Node* node, UseChildrenMode mode = CallUseChildren)
871     {
872         if (mode == UseChildrenCalledExplicitly)
873             return;
874         useChildren(node);
875     }
876     void cellResult(GPRReg reg, Node* node, UseChildrenMode mode = CallUseChildren)
877     {
878         if (mode == CallUseChildren)
879             useChildren(node);
880
881         VirtualRegister virtualRegister = node->virtualRegister();
882         m_gprs.retain(reg, virtualRegister, SpillOrderCell);
883         GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
884         info.initCell(node, node->refCount(), reg);
885     }
886     void blessedBooleanResult(GPRReg reg, Node* node, UseChildrenMode mode = CallUseChildren)
887     {
888 #if USE(JSVALUE64)
889         jsValueResult(reg, node, DataFormatJSBoolean, mode);
890 #else
891         booleanResult(reg, node, mode);
892 #endif
893     }
894     void unblessedBooleanResult(GPRReg reg, Node* node, UseChildrenMode mode = CallUseChildren)
895     {
896 #if USE(JSVALUE64)
897         blessBoolean(reg);
898 #endif
899         blessedBooleanResult(reg, node, mode);
900     }
901 #if USE(JSVALUE64)
902     void jsValueResult(GPRReg reg, Node* node, DataFormat format = DataFormatJS, UseChildrenMode mode = CallUseChildren)
903     {
904         if (format == DataFormatJSInt32)
905             m_jit.jitAssertIsJSInt32(reg);
906         
907         if (mode == CallUseChildren)
908             useChildren(node);
909
910         VirtualRegister virtualRegister = node->virtualRegister();
911         m_gprs.retain(reg, virtualRegister, SpillOrderJS);
912         GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
913         info.initJSValue(node, node->refCount(), reg, format);
914     }
915     void jsValueResult(GPRReg reg, Node* node, UseChildrenMode mode)
916     {
917         jsValueResult(reg, node, DataFormatJS, mode);
918     }
919 #elif USE(JSVALUE32_64)
920     void booleanResult(GPRReg reg, Node* node, UseChildrenMode mode = CallUseChildren)
921     {
922         if (mode == CallUseChildren)
923             useChildren(node);
924
925         VirtualRegister virtualRegister = node->virtualRegister();
926         m_gprs.retain(reg, virtualRegister, SpillOrderBoolean);
927         GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
928         info.initBoolean(node, node->refCount(), reg);
929     }
930     void jsValueResult(GPRReg tag, GPRReg payload, Node* node, DataFormat format = DataFormatJS, UseChildrenMode mode = CallUseChildren)
931     {
932         if (mode == CallUseChildren)
933             useChildren(node);
934
935         VirtualRegister virtualRegister = node->virtualRegister();
936         m_gprs.retain(tag, virtualRegister, SpillOrderJS);
937         m_gprs.retain(payload, virtualRegister, SpillOrderJS);
938         GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
939         info.initJSValue(node, node->refCount(), tag, payload, format);
940     }
941     void jsValueResult(GPRReg tag, GPRReg payload, Node* node, UseChildrenMode mode)
942     {
943         jsValueResult(tag, payload, node, DataFormatJS, mode);
944     }
945 #endif
946     void jsValueResult(JSValueRegs regs, Node* node, DataFormat format = DataFormatJS, UseChildrenMode mode = CallUseChildren)
947     {
948 #if USE(JSVALUE64)
949         jsValueResult(regs.gpr(), node, format, mode);
950 #else
951         jsValueResult(regs.tagGPR(), regs.payloadGPR(), node, format, mode);
952 #endif
953     }
954     void storageResult(GPRReg reg, Node* node, UseChildrenMode mode = CallUseChildren)
955     {
956         if (mode == CallUseChildren)
957             useChildren(node);
958         
959         VirtualRegister virtualRegister = node->virtualRegister();
960         m_gprs.retain(reg, virtualRegister, SpillOrderStorage);
961         GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
962         info.initStorage(node, node->refCount(), reg);
963     }
964     void doubleResult(FPRReg reg, Node* node, UseChildrenMode mode = CallUseChildren)
965     {
966         if (mode == CallUseChildren)
967             useChildren(node);
968
969         VirtualRegister virtualRegister = node->virtualRegister();
970         m_fprs.retain(reg, virtualRegister, SpillOrderDouble);
971         GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
972         info.initDouble(node, node->refCount(), reg);
973     }
974     void initConstantInfo(Node* node)
975     {
976         ASSERT(node->hasConstant());
977         generationInfo(node).initConstant(node, node->refCount());
978     }
979     
980     // These methods add calls to C++ helper functions.
981     // These methods are broadly value representation specific (i.e.
982     // deal with the fact that a JSValue may be passed in one or two
983     // machine registers, and delegate the calling convention specific
984     // decision as to how to fill the regsiters to setupArguments* methods.
985
986     JITCompiler::Call callOperation(V_JITOperation_E operation)
987     {
988         m_jit.setupArgumentsExecState();
989         return appendCall(operation);
990     }
991     JITCompiler::Call callOperation(P_JITOperation_E operation, GPRReg result)
992     {
993         m_jit.setupArgumentsExecState();
994         return appendCallSetResult(operation, result);
995     }
996     JITCompiler::Call callOperation(P_JITOperation_EC operation, GPRReg result, GPRReg cell)
997     {
998         m_jit.setupArgumentsWithExecState(cell);
999         return appendCallSetResult(operation, result);
1000     }
1001     JITCompiler::Call callOperation(Jss_JITOperation_EJssUi operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1002     {
1003         m_jit.setupArgumentsWithExecState(arg1, arg2);
1004         return appendCallSetResult(operation, result);
1005     }
1006     JITCompiler::Call callOperation(P_JITOperation_EO operation, GPRReg result, GPRReg object)
1007     {
1008         m_jit.setupArgumentsWithExecState(object);
1009         return appendCallSetResult(operation, result);
1010     }
1011     JITCompiler::Call callOperation(P_JITOperation_EOS operation, GPRReg result, GPRReg object, size_t size)
1012     {
1013         m_jit.setupArgumentsWithExecState(object, TrustedImmPtr(size));
1014         return appendCallSetResult(operation, result);
1015     }
1016     JITCompiler::Call callOperation(P_JITOperation_EOZ operation, GPRReg result, GPRReg object, int32_t size)
1017     {
1018         m_jit.setupArgumentsWithExecState(object, TrustedImmPtr(size));
1019         return appendCallSetResult(operation, result);
1020     }
1021     JITCompiler::Call callOperation(C_JITOperation_EOZ operation, GPRReg result, GPRReg object, int32_t size)
1022     {
1023         m_jit.setupArgumentsWithExecState(object, TrustedImmPtr(static_cast<size_t>(size)));
1024         return appendCallSetResult(operation, result);
1025     }
1026     JITCompiler::Call callOperation(P_JITOperation_EPS operation, GPRReg result, GPRReg old, size_t size)
1027     {
1028         m_jit.setupArgumentsWithExecState(old, TrustedImmPtr(size));
1029         return appendCallSetResult(operation, result);
1030     }
1031     JITCompiler::Call callOperation(C_JITOperation_EPUi operation, GPRReg result, void* arg1, uint32_t arg2)
1032     {
1033         m_jit.setupArgumentsWithExecState(TrustedImmPtr(arg1), TrustedImm32(arg2));
1034         return appendCallSetResult(operation, result);
1035     }
1036     JITCompiler::Call callOperation(P_JITOperation_ES operation, GPRReg result, size_t size)
1037     {
1038         m_jit.setupArgumentsWithExecState(TrustedImmPtr(size));
1039         return appendCallSetResult(operation, result);
1040     }
1041     JITCompiler::Call callOperation(P_JITOperation_ESJss operation, GPRReg result, size_t index, GPRReg arg1)
1042     {
1043         m_jit.setupArgumentsWithExecState(TrustedImmPtr(index), arg1);
1044         return appendCallSetResult(operation, result);
1045     }
1046     JITCompiler::Call callOperation(Z_JITOperation_EOI operation, GPRReg result, GPRReg obj, GPRReg impl)
1047     {
1048         m_jit.setupArgumentsWithExecState(obj, impl);
1049         return appendCallSetResult(operation, result);
1050     }
1051     JITCompiler::Call callOperation(P_JITOperation_ESt operation, GPRReg result, RegisteredStructure structure)
1052     {
1053         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure));
1054         return appendCallSetResult(operation, result);
1055     }
1056     JITCompiler::Call callOperation(P_JITOperation_EStZP operation, GPRReg result, RegisteredStructure structure, GPRReg arg2, GPRReg arg3)
1057     {
1058         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), arg2, arg3);
1059         return appendCallSetResult(operation, result);
1060     }
1061     JITCompiler::Call callOperation(P_JITOperation_EStZP operation, GPRReg result, RegisteredStructure structure, size_t arg2, GPRReg arg3)
1062     {
1063         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), TrustedImm32(arg2), arg3);
1064         return appendCallSetResult(operation, result);
1065     }
1066     JITCompiler::Call callOperation(P_JITOperation_EStZP operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1067     {
1068         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1069         return appendCallSetResult(operation, result);
1070     }
1071     JITCompiler::Call callOperation(P_JITOperation_EStZB operation, GPRReg result, RegisteredStructure structure, GPRReg arg2, GPRReg butterfly)
1072     {
1073         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), arg2, butterfly);
1074         return appendCallSetResult(operation, result);
1075     }
1076     JITCompiler::Call callOperation(P_JITOperation_EStZB operation, GPRReg result, RegisteredStructure structure, size_t arg2, GPRReg butterfly)
1077     {
1078         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), TrustedImm32(arg2), butterfly);
1079         return appendCallSetResult(operation, result);
1080     }
1081     JITCompiler::Call callOperation(P_JITOperation_EStZB operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg butterfly)
1082     {
1083         m_jit.setupArgumentsWithExecState(arg1, arg2, butterfly);
1084         return appendCallSetResult(operation, result);
1085     }
1086     JITCompiler::Call callOperation(P_JITOperation_EStZB operation, GPRReg result, GPRReg arg1, GPRReg arg2, Butterfly* butterfly)
1087     {
1088         m_jit.setupArgumentsWithExecState(arg1, arg2, TrustedImmPtr(butterfly));
1089         return appendCallSetResult(operation, result);
1090     }
1091     JITCompiler::Call callOperation(P_JITOperation_EStPS operation, GPRReg result, RegisteredStructure structure, void* pointer, size_t size)
1092     {
1093         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), TrustedImmPtr(pointer), TrustedImmPtr(size));
1094         return appendCallSetResult(operation, result);
1095     }
1096     JITCompiler::Call callOperation(P_JITOperation_EStSS operation, GPRReg result, RegisteredStructure structure, size_t index, size_t size)
1097     {
1098         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), TrustedImmPtr(index), TrustedImmPtr(size));
1099         return appendCallSetResult(operation, result);
1100     }
1101     JITCompiler::Call callOperation(C_JITOperation_E operation, GPRReg result)
1102     {
1103         m_jit.setupArgumentsExecState();
1104         return appendCallSetResult(operation, result);
1105     }
1106     JITCompiler::Call callOperation(C_JITOperation_EC operation, GPRReg result, GPRReg arg1)
1107     {
1108         m_jit.setupArgumentsWithExecState(arg1);
1109         return appendCallSetResult(operation, result);
1110     }
1111     JITCompiler::Call callOperation(C_JITOperation_EC operation, GPRReg result, JSCell* cell)
1112     {
1113         m_jit.setupArgumentsWithExecState(TrustedImmPtr::weakPointer(m_jit.graph(), cell));
1114         return appendCallSetResult(operation, result);
1115     }
1116     JITCompiler::Call callOperation(C_JITOperation_ECZ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1117     {
1118         m_jit.setupArgumentsWithExecState(arg1, arg2);
1119         return appendCallSetResult(operation, result);
1120     }
1121     JITCompiler::Call callOperation(C_JITOperation_ECZC operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1122     {
1123         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1124         return appendCallSetResult(operation, result);
1125     }
1126     JITCompiler::Call callOperation(C_JITOperation_EJscC operation, GPRReg result, GPRReg arg1, JSCell* cell)
1127     {
1128         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr::weakPointer(m_jit.graph(), cell));
1129         return appendCallSetResult(operation, result);
1130     }
1131     JITCompiler::Call callOperation(C_JITOperation_EIcf operation, GPRReg result, InlineCallFrame* inlineCallFrame)
1132     {
1133         m_jit.setupArgumentsWithExecState(TrustedImmPtr(inlineCallFrame));
1134         return appendCallSetResult(operation, result);
1135     }
1136     JITCompiler::Call callOperation(C_JITOperation_ESt operation, GPRReg result, RegisteredStructure structure)
1137     {
1138         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure));
1139         return appendCallSetResult(operation, result);
1140     }
1141
1142 #if USE(JSVALUE64)
1143     JITCompiler::Call callOperation(C_JITOperation_EStJscSymtabJ operation, GPRReg result, RegisteredStructure structure, GPRReg scope, SymbolTable* table, TrustedImm64 initialValue)
1144     {
1145         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), scope, TrustedImmPtr::weakPointer(m_jit.graph(), table), initialValue);
1146         return appendCallSetResult(operation, result);
1147     }
1148 #else
1149     JITCompiler::Call callOperation(C_JITOperation_EStJscSymtabJ operation, GPRReg result, RegisteredStructure structure, GPRReg scope, SymbolTable* table, TrustedImm32 tag, TrustedImm32 payload)
1150     {
1151         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), scope, TrustedImmPtr::weakPointer(m_jit.graph(), table), payload, tag);
1152         return appendCallSetResult(operation, result);
1153     }
1154 #endif
1155     JITCompiler::Call callOperation(C_JITOperation_EStZ operation, GPRReg result, RegisteredStructure structure, unsigned knownLength)
1156     {
1157         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), TrustedImm32(knownLength));
1158         return appendCallSetResult(operation, result);
1159     }
1160     JITCompiler::Call callOperation(C_JITOperation_EStZZ operation, GPRReg result, RegisteredStructure structure, unsigned knownLength, unsigned minCapacity)
1161     {
1162         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), TrustedImm32(knownLength), TrustedImm32(minCapacity));
1163         return appendCallSetResult(operation, result);
1164     }
1165     JITCompiler::Call callOperation(C_JITOperation_EStZ operation, GPRReg result, RegisteredStructure structure, GPRReg length)
1166     {
1167         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), length);
1168         return appendCallSetResult(operation, result);
1169     }
1170     JITCompiler::Call callOperation(C_JITOperation_EStZZ operation, GPRReg result, RegisteredStructure structure, GPRReg length, unsigned minCapacity)
1171     {
1172         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), length, TrustedImm32(minCapacity));
1173         return appendCallSetResult(operation, result);
1174     }
1175     JITCompiler::Call callOperation(C_JITOperation_EJssSt operation, GPRReg result, GPRReg arg1, RegisteredStructure structure)
1176     {
1177         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr(structure));
1178         return appendCallSetResult(operation, result);
1179     }
1180     JITCompiler::Call callOperation(C_JITOperation_EJssJss operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1181     {
1182         m_jit.setupArgumentsWithExecState(arg1, arg2);
1183         return appendCallSetResult(operation, result);
1184     }
1185     JITCompiler::Call callOperation(C_JITOperation_B_EJssJss operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1186     {
1187         m_jit.setupArgumentsWithExecState(arg1, arg2);
1188         return appendCallSetResult(operation, result);
1189     }
1190     JITCompiler::Call callOperation(C_JITOperation_TT operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1191     {
1192         m_jit.setupArguments(arg1, arg2);
1193         return appendCallSetResult(operation, result);
1194     }
1195     JITCompiler::Call callOperation(C_JITOperation_EJssJssJss operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1196     {
1197         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1198         return appendCallSetResult(operation, result);
1199     }
1200
1201     JITCompiler::Call callOperation(S_JITOperation_ECC operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1202     {
1203         m_jit.setupArgumentsWithExecState(arg1, arg2);
1204         return appendCallSetResult(operation, result);
1205     }
1206
1207     JITCompiler::Call callOperation(S_JITOperation_EGC operation, GPRReg result, JSGlobalObject* globalObject, GPRReg arg2)
1208     {
1209         m_jit.setupArgumentsWithExecState(TrustedImmPtr::weakPointer(m_jit.graph(), globalObject), arg2);
1210         return appendCallSetResult(operation, result);
1211     }
1212
1213     JITCompiler::Call callOperation(C_JITOperation_EGC operation, GPRReg result, JSGlobalObject* globalObject, GPRReg arg2)
1214     {
1215         m_jit.setupArgumentsWithExecState(TrustedImmPtr::weakPointer(m_jit.graph(), globalObject), arg2);
1216         return appendCallSetResult(operation, result);
1217     }
1218
1219     JITCompiler::Call callOperation(Jss_JITOperation_EZ operation, GPRReg result, GPRReg arg1)
1220     {
1221         m_jit.setupArgumentsWithExecState(arg1);
1222         return appendCallSetResult(operation, result);
1223     }
1224
1225     JITCompiler::Call callOperation(V_JITOperation_EC operation, GPRReg arg1)
1226     {
1227         m_jit.setupArgumentsWithExecState(arg1);
1228         return appendCall(operation);
1229     }
1230
1231     JITCompiler::Call callOperation(V_JITOperation_ECliJsf operation, CallLinkInfo* callLinkInfo, GPRReg arg1)
1232     {
1233         m_jit.setupArgumentsWithExecState(TrustedImmPtr(callLinkInfo), arg1);
1234         return appendCall(operation);
1235     }
1236
1237     JITCompiler::Call callOperation(V_JITOperation_EC operation, JSCell* arg1)
1238     {
1239         m_jit.setupArgumentsWithExecState(TrustedImmPtr::weakPointer(m_jit.graph(), arg1));
1240         return appendCall(operation);
1241     }
1242
1243     JITCompiler::Call callOperation(V_JITOperation_ECIcf operation, GPRReg arg1, InlineCallFrame* inlineCallFrame)
1244     {
1245         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr(inlineCallFrame));
1246         return appendCall(operation);
1247     }
1248     JITCompiler::Call callOperation(V_JITOperation_ECCIcf operation, GPRReg arg1, GPRReg arg2, InlineCallFrame* inlineCallFrame)
1249     {
1250         m_jit.setupArgumentsWithExecState(arg1, arg2, TrustedImmPtr(inlineCallFrame));
1251         return appendCall(operation);
1252     }
1253
1254     JITCompiler::Call callOperation(V_JITOperation_ECZ operation, GPRReg arg1, int arg2)
1255     {
1256         m_jit.setupArgumentsWithExecState(arg1, TrustedImm32(arg2));
1257         return appendCall(operation);
1258     }
1259     JITCompiler::Call callOperation(V_JITOperation_ECC operation, GPRReg arg1, GPRReg arg2)
1260     {
1261         m_jit.setupArgumentsWithExecState(arg1, arg2);
1262         return appendCall(operation);
1263     }
1264     JITCompiler::Call callOperation(V_JITOperation_ECC operation, GPRReg arg1, JSCell* arg2)
1265     {
1266         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr::weakPointer(m_jit.graph(), arg2));
1267         return appendCall(operation);
1268     }
1269     JITCompiler::Call callOperation(V_JITOperation_ECC operation, JSCell* arg1, GPRReg arg2)
1270     {
1271         m_jit.setupArgumentsWithExecState(TrustedImmPtr::weakPointer(m_jit.graph(), arg1), arg2);
1272         return appendCall(operation);
1273     }
1274
1275     JITCompiler::Call callOperationWithCallFrameRollbackOnException(V_JITOperation_ECb operation, void* pointer)
1276     {
1277         m_jit.setupArgumentsWithExecState(TrustedImmPtr(pointer));
1278         return appendCallWithCallFrameRollbackOnException(operation);
1279     }
1280
1281     JITCompiler::Call callOperationWithCallFrameRollbackOnException(Z_JITOperation_E operation, GPRReg result)
1282     {
1283         m_jit.setupArgumentsExecState();
1284         return appendCallWithCallFrameRollbackOnExceptionSetResult(operation, result);
1285     }
1286     JITCompiler::Call callOperation(Z_JITOperation_EC operation, GPRReg result, GPRReg arg1)
1287     {
1288         m_jit.setupArgumentsWithExecState(arg1);
1289         return appendCallSetResult(operation, result);
1290     }
1291
1292     JITCompiler::Call callOperation(V_JITOperation_ECIZC operation, GPRReg regOp1, UniquedStringImpl* identOp2, int32_t op3, GPRReg regOp4)
1293     {
1294         m_jit.setupArgumentsWithExecState(regOp1, TrustedImmPtr(identOp2), TrustedImm32(op3), regOp4);
1295         return appendCall(operation);
1296     }
1297
1298     template<typename FunctionType, typename... Args>
1299     JITCompiler::Call callOperation(FunctionType operation, NoResultTag, Args... args)
1300     {
1301         return callOperation(operation, args...);
1302     }
1303
1304     JITCompiler::Call callOperation(D_JITOperation_ZZ operation, FPRReg result, GPRReg arg1, GPRReg arg2)
1305     {
1306         m_jit.setupArguments(arg1, arg2);
1307         return appendCallSetResult(operation, result);
1308     }
1309     JITCompiler::Call callOperation(D_JITOperation_D operation, FPRReg result, FPRReg arg1)
1310     {
1311         m_jit.setupArguments(arg1);
1312         return appendCallSetResult(operation, result);
1313     }
1314     JITCompiler::Call callOperation(D_JITOperation_DD operation, FPRReg result, FPRReg arg1, FPRReg arg2)
1315     {
1316         m_jit.setupArguments(arg1, arg2);
1317         return appendCallSetResult(operation, result);
1318     }
1319
1320     JITCompiler::Call callOperation(J_JITOperation_EJss operation, JSValueRegs result, GPRReg arg1)
1321     {
1322         m_jit.setupArgumentsWithExecState(arg1);
1323         return appendCallSetResult(operation, result);
1324     }
1325
1326     JITCompiler::Call callOperation(T_JITOperation_EJss operation, GPRReg result, GPRReg arg1)
1327     {
1328         m_jit.setupArgumentsWithExecState(arg1);
1329         return appendCallSetResult(operation, result);
1330     }
1331     JITCompiler::Call callOperation(C_JITOperation_EJscZ operation, GPRReg result, GPRReg arg1, int32_t arg2)
1332     {
1333         m_jit.setupArgumentsWithExecState(arg1, TrustedImm32(arg2));
1334         return appendCallSetResult(operation, result);
1335     }
1336     JITCompiler::Call callOperation(C_JITOperation_EZ operation, GPRReg result, GPRReg arg1)
1337     {
1338         m_jit.setupArgumentsWithExecState(arg1);
1339         return appendCallSetResult(operation, result);
1340     }
1341     JITCompiler::Call callOperation(C_JITOperation_EZ operation, GPRReg result, int32_t arg1)
1342     {
1343         m_jit.setupArgumentsWithExecState(TrustedImm32(arg1));
1344         return appendCallSetResult(operation, result);
1345     }
1346
1347     JITCompiler::Call callOperation(J_JITOperation_EJscC operation, GPRReg result, GPRReg arg1, JSCell* cell)
1348     {
1349         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr::weakPointer(m_jit.graph(), cell));
1350         return appendCallSetResult(operation, result);
1351     }
1352     
1353     JITCompiler::Call callOperation(J_JITOperation_EJscCJ operation, GPRReg result, GPRReg arg1, JSCell* cell, GPRReg arg2)
1354     {
1355         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr::weakPointer(m_jit.graph(), cell), arg2);
1356         return appendCallSetResult(operation, result);
1357     }
1358
1359     JITCompiler::Call callOperation(J_JITOperation_EGReoJ operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1360     {
1361         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1362         return appendCallSetResult(operation, result);
1363     }
1364
1365     JITCompiler::Call callOperation(J_JITOperation_EGReoJss operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1366     {
1367         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1368         return appendCallSetResult(operation, result);
1369     }
1370
1371     JITCompiler::Call callOperation(V_JITOperation_EWs operation, WatchpointSet* watchpointSet)
1372     {
1373         m_jit.setupArgumentsWithExecState(TrustedImmPtr(watchpointSet));
1374         return appendCall(operation);
1375     }
1376
1377     JITCompiler::Call callOperation(C_JITOperation_ERUiUi operation, GPRReg result, GPRReg arg1, Imm32 arg2, GPRReg arg3)
1378     {
1379         m_jit.setupArgumentsWithExecState(arg1, arg2.asTrustedImm32(), arg3);
1380         return appendCallSetResult(operation, result);
1381     }
1382
1383     JITCompiler::Call callOperation(S_JITOperation_EO operation, GPRReg result, GPRReg arg1)
1384     {
1385         m_jit.setupArgumentsWithExecState(arg1);
1386         return appendCallSetResult(operation, result);
1387     }
1388
1389     JITCompiler::Call callOperation(C_JITOperation_EJscI operation, GPRReg result, GPRReg arg1, UniquedStringImpl* impl)
1390     {
1391         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr(impl));
1392         return appendCallSetResult(operation, result);
1393     }
1394
1395     JITCompiler::Call callOperation(P_JITOperation_EZZ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1396     {
1397         m_jit.setupArgumentsWithExecState(arg1, arg2);
1398         return appendCallSetResult(operation, result);
1399     }
1400
1401     JITCompiler::Call callOperation(P_JITOperation_EZZ operation, GPRReg result, GPRReg arg1, TrustedImm32 arg2)
1402     {
1403         m_jit.setupArgumentsWithExecState(arg1, arg2);
1404         return appendCallSetResult(operation, result);
1405     }
1406
1407     JITCompiler::Call callOperation(P_JITOperation_EDZ operation, GPRReg result, FPRReg arg1, GPRReg arg2)
1408     {
1409         m_jit.setupArgumentsWithExecState(arg1, arg2);
1410         return appendCallSetResult(operation, result);
1411     }
1412
1413     JITCompiler::Call callOperation(P_JITOperation_EDZ operation, GPRReg result, FPRReg arg1, TrustedImm32 arg2)
1414     {
1415         m_jit.setupArgumentsWithExecState(arg1, arg2);
1416         return appendCallSetResult(operation, result);
1417     }
1418
1419 #if USE(JSVALUE64)
1420     JITCompiler::Call callOperation(Z_JITOperation_EOJ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1421     {
1422         m_jit.setupArgumentsWithExecState(arg1, arg2);
1423         return appendCallSetResult(operation, result);
1424     }
1425     JITCompiler::Call callOperation(C_JITOperation_ECJZ operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1426     {
1427         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1428         return appendCallSetResult(operation, result);
1429     }
1430     JITCompiler::Call callOperation(J_JITOperation_EJMic operation, JSValueRegs result, JSValueRegs arg, TrustedImmPtr mathIC)
1431     {
1432         m_jit.setupArgumentsWithExecState(arg.gpr(), mathIC);
1433         return appendCallSetResult(operation, result.gpr());
1434     }
1435     JITCompiler::Call callOperation(J_JITOperation_EJJMic operation, JSValueRegs result, JSValueRegs arg1, JSValueRegs arg2, TrustedImmPtr mathIC)
1436     {
1437         m_jit.setupArgumentsWithExecState(arg1.gpr(), arg2.gpr(), mathIC);
1438         return appendCallSetResult(operation, result.gpr());
1439     }
1440     JITCompiler::Call callOperation(J_JITOperation_EJJI operation, GPRReg result, GPRReg arg1, GPRReg arg2, UniquedStringImpl* uid)
1441     {
1442         m_jit.setupArgumentsWithExecState(arg1, arg2, TrustedImmPtr(uid));
1443         return appendCallSetResult(operation, result);
1444     }
1445     JITCompiler::Call callOperation(J_JITOperation_EJscI operation, GPRReg result, GPRReg arg1, UniquedStringImpl* impl)
1446     {
1447         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr(impl));
1448         return appendCallSetResult(operation, result);
1449     }
1450     JITCompiler::Call callOperation(V_JITOperation_EJJJI operation, GPRReg arg1, GPRReg arg2, GPRReg arg3, UniquedStringImpl* uid)
1451     {
1452         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3, TrustedImmPtr(uid));
1453         return appendCall(operation);
1454     }
1455     JITCompiler::Call callOperation(V_JITOperation_EJJJJ operation, GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4)
1456     {
1457         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3, arg4);
1458         return appendCall(operation);
1459     }
1460     JITCompiler::Call callOperation(V_JITOperation_EOJJZ operation, GPRReg arg1, JSValueRegs arg2, JSValueRegs arg3, GPRReg arg4)
1461     {
1462         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg3.payloadGPR(), arg4);
1463         return appendCall(operation);
1464     }
1465     JITCompiler::Call callOperation(V_JITOperation_EOJssJZ operation, GPRReg arg1, GPRReg arg2, JSValueRegs arg3, GPRReg arg4)
1466     {
1467         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3.payloadGPR(), arg4);
1468         return appendCall(operation);
1469     }
1470     JITCompiler::Call callOperation(V_JITOperation_EOIJZ operation, GPRReg arg1, GPRReg arg2, JSValueRegs arg3, GPRReg arg4)
1471     {
1472         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3.payloadGPR(), arg4);
1473         return appendCall(operation);
1474     }
1475     JITCompiler::Call callOperation(V_JITOperation_EOSymJZ operation, GPRReg arg1, GPRReg arg2, JSValueRegs arg3, GPRReg arg4)
1476     {
1477         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3.payloadGPR(), arg4);
1478         return appendCall(operation);
1479     }
1480     JITCompiler::Call callOperation(V_JITOperation_EOJOOZ operation, GPRReg arg1, JSValueRegs arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
1481     {
1482         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg3, arg4, arg5);
1483         return appendCall(operation);
1484     }
1485     JITCompiler::Call callOperation(V_JITOperation_EOJssOOZ operation, GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
1486     {
1487         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3, arg4, arg5);
1488         return appendCall(operation);
1489     }
1490     JITCompiler::Call callOperation(V_JITOperation_EOIOOZ operation, GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
1491     {
1492         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3, arg4, arg5);
1493         return appendCall(operation);
1494     }
1495     JITCompiler::Call callOperation(V_JITOperation_EOSymOOZ operation, GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
1496     {
1497         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3, arg4, arg5);
1498         return appendCall(operation);
1499     }
1500     JITCompiler::Call callOperation(V_JITOperation_EOJIUi operation, GPRReg arg1, GPRReg arg2, UniquedStringImpl* impl, unsigned value)
1501     {
1502         m_jit.setupArgumentsWithExecState(arg1, arg2, TrustedImmPtr(impl), TrustedImm32(value));
1503         return appendCall(operation);
1504     }
1505     JITCompiler::Call callOperation(J_JITOperation_EOIUi operation, GPRReg result, GPRReg arg1, UniquedStringImpl* impl, unsigned value)
1506     {
1507         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr(impl), TrustedImm32(value));
1508         return appendCallSetResult(operation, result);
1509     }
1510     JITCompiler::Call callOperation(J_JITOperation_E operation, GPRReg result)
1511     {
1512         m_jit.setupArgumentsExecState();
1513         return appendCallSetResult(operation, result);
1514     }
1515     JITCompiler::Call callOperation(J_JITOperation_EP operation, GPRReg result, void* pointer)
1516     {
1517         m_jit.setupArgumentsWithExecState(TrustedImmPtr(pointer));
1518         return appendCallSetResult(operation, result);
1519     }
1520     JITCompiler::Call callOperation(Z_JITOperation_D operation, GPRReg result, FPRReg arg1)
1521     {
1522         m_jit.setupArguments(arg1);
1523         JITCompiler::Call call = m_jit.appendCall(operation);
1524         m_jit.zeroExtend32ToPtr(GPRInfo::returnValueGPR, result);
1525         return call;
1526     }
1527     JITCompiler::Call callOperation(Q_JITOperation_J operation, GPRReg result, GPRReg value)
1528     {
1529         m_jit.setupArguments(value);
1530         return appendCallSetResult(operation, result);
1531     }
1532     JITCompiler::Call callOperation(Q_JITOperation_D operation, GPRReg result, FPRReg value)
1533     {
1534         m_jit.setupArguments(value);
1535         return appendCallSetResult(operation, result);
1536     }
1537     JITCompiler::Call callOperation(J_JITOperation_EI operation, GPRReg result, UniquedStringImpl* uid)
1538     {
1539         m_jit.setupArgumentsWithExecState(TrustedImmPtr(uid));
1540         return appendCallSetResult(operation, result);
1541     }
1542     JITCompiler::Call callOperation(J_JITOperation_EA operation, GPRReg result, GPRReg arg1)
1543     {
1544         m_jit.setupArgumentsWithExecState(arg1);
1545         return appendCallSetResult(operation, result);
1546     }
1547     JITCompiler::Call callOperation(J_JITOperation_EAZ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1548     {
1549         m_jit.setupArgumentsWithExecState(arg1, arg2);
1550         return appendCallSetResult(operation, result);
1551     }
1552     JITCompiler::Call callOperation(J_JITOperation_EJssReo operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1553     {
1554         m_jit.setupArgumentsWithExecState(arg1, arg2);
1555         return appendCallSetResult(operation, result);
1556     }
1557     JITCompiler::Call callOperation(J_JITOperation_EJssReoJss operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1558     {
1559         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1560         return appendCallSetResult(operation, result);
1561     }
1562     JITCompiler::Call callOperation(J_JITOperation_EJssZ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1563     {
1564         m_jit.setupArgumentsWithExecState(arg1, arg2);
1565         return appendCallSetResult(operation, result);
1566     }
1567     JITCompiler::Call callOperation(J_JITOperation_EPS operation, GPRReg result, void* pointer, size_t size)
1568     {
1569         m_jit.setupArgumentsWithExecState(TrustedImmPtr(pointer), TrustedImmPtr(size));
1570         return appendCallSetResult(operation, result);
1571     }
1572     JITCompiler::Call callOperation(J_JITOperation_ESS operation, GPRReg result, int startConstant, int numConstants)
1573     {
1574         m_jit.setupArgumentsWithExecState(TrustedImm32(startConstant), TrustedImm32(numConstants));
1575         return appendCallSetResult(operation, result);
1576     }
1577     JITCompiler::Call callOperation(J_JITOperation_EPP operation, GPRReg result, GPRReg arg1, void* pointer)
1578     {
1579         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr(pointer));
1580         return appendCallSetResult(operation, result);
1581     }
1582     JITCompiler::Call callOperation(J_JITOperation_EC operation, GPRReg result, JSCell* cell)
1583     {
1584         m_jit.setupArgumentsWithExecState(TrustedImmPtr::weakPointer(m_jit.graph(), cell));
1585         return appendCallSetResult(operation, result);
1586     }
1587     JITCompiler::Call callOperation(J_JITOperation_ECZ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1588     {
1589         m_jit.setupArgumentsWithExecState(arg1, arg2);
1590         return appendCallSetResult(operation, result);
1591     }
1592     JITCompiler::Call callOperation(J_JITOperation_ECZZ operation, GPRReg result, GPRReg arg1, GPRReg arg2, int32_t constant)
1593     {
1594         m_jit.setupArgumentsWithExecState(arg1, arg2, TrustedImm32(constant));
1595         return appendCallSetResult(operation, result);
1596     }
1597     JITCompiler::Call callOperation(J_JITOperation_ESsiCI operation, GPRReg result, StructureStubInfo* stubInfo, GPRReg arg1, const UniquedStringImpl* uid)
1598     {
1599         m_jit.setupArgumentsWithExecState(TrustedImmPtr(stubInfo), arg1, TrustedImmPtr(uid));
1600         return appendCallSetResult(operation, result);
1601     }
1602     JITCompiler::Call callOperation(J_JITOperation_ESsiJI operation, GPRReg result, StructureStubInfo* stubInfo, GPRReg arg1, UniquedStringImpl* uid)
1603     {
1604         m_jit.setupArgumentsWithExecState(TrustedImmPtr(stubInfo), arg1, TrustedImmPtr(uid));
1605         return appendCallSetResult(operation, result);
1606     }
1607     JITCompiler::Call callOperation(J_JITOperation_ESsiJJI operation, GPRReg result, StructureStubInfo* stubInfo, GPRReg arg1, GPRReg arg2, UniquedStringImpl* uid)
1608     {
1609         m_jit.setupArgumentsWithExecState(TrustedImmPtr(stubInfo), arg1, arg2, TrustedImmPtr(uid));
1610         return appendCallSetResult(operation, result);
1611     }
1612     JITCompiler::Call callOperation(J_JITOperation_EDA operation, GPRReg result, FPRReg arg1, GPRReg arg2)
1613     {
1614         m_jit.setupArgumentsWithExecState(arg1, arg2);
1615         return appendCallSetResult(operation, result);
1616     }
1617     JITCompiler::Call callOperation(J_JITOperation_EJC operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1618     {
1619         m_jit.setupArgumentsWithExecState(arg1, arg2);
1620         return appendCallSetResult(operation, result);
1621     }
1622     JITCompiler::Call callOperation(J_JITOperation_EJZ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1623     {
1624         m_jit.setupArgumentsWithExecState(arg1, arg2);
1625         return appendCallSetResult(operation, result);
1626     }
1627     JITCompiler::Call callOperation(J_JITOperation_EJA operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1628     {
1629         m_jit.setupArgumentsWithExecState(arg1, arg2);
1630         return appendCallSetResult(operation, result);
1631     }
1632     JITCompiler::Call callOperation(J_JITOperation_EP operation, GPRReg result, GPRReg arg1)
1633     {
1634         m_jit.setupArgumentsWithExecState(arg1);
1635         return appendCallSetResult(operation, result);
1636     }
1637     JITCompiler::Call callOperation(J_JITOperation_EZ operation, GPRReg result, GPRReg arg1)
1638     {
1639         m_jit.setupArgumentsWithExecState(arg1);
1640         return appendCallSetResult(operation, result);
1641     }
1642     JITCompiler::Call callOperation(J_JITOperation_EZ operation, GPRReg result, int32_t arg1)
1643     {
1644         m_jit.setupArgumentsWithExecState(TrustedImm32(arg1));
1645         return appendCallSetResult(operation, result);
1646     }
1647     JITCompiler::Call callOperation(J_JITOperation_EZZ operation, GPRReg result, int32_t arg1, GPRReg arg2)
1648     {
1649         m_jit.setupArgumentsWithExecState(TrustedImm32(arg1), arg2);
1650         return appendCallSetResult(operation, result);
1651     }
1652     JITCompiler::Call callOperation(P_JITOperation_EQZ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1653     {
1654         m_jit.setupArgumentsWithExecState(arg1, arg2);
1655         return appendCallSetResult(operation, result);
1656     }
1657     JITCompiler::Call callOperation(P_JITOperation_EQZ operation, GPRReg result, GPRReg arg1, TrustedImm32 arg2)
1658     {
1659         m_jit.setupArgumentsWithExecState(arg1, arg2);
1660         return appendCallSetResult(operation, result);
1661     }
1662
1663     JITCompiler::Call callOperation(J_JITOperation_EZIcfZ operation, GPRReg result, int32_t arg1, InlineCallFrame* inlineCallFrame, GPRReg arg2)
1664     {
1665         m_jit.setupArgumentsWithExecState(TrustedImm32(arg1), TrustedImmPtr(inlineCallFrame), arg2);
1666         return appendCallSetResult(operation, result);
1667     }
1668
1669     JITCompiler::Call callOperation(P_JITOperation_EJS operation, GPRReg result, GPRReg value, size_t index)
1670     {
1671         m_jit.setupArgumentsWithExecState(value, TrustedImmPtr(index));
1672         return appendCallSetResult(operation, result);
1673     }
1674
1675     JITCompiler::Call callOperation(P_JITOperation_EStJ operation, GPRReg result, RegisteredStructure structure, GPRReg arg2)
1676     {
1677         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), arg2);
1678         return appendCallSetResult(operation, result);
1679     }
1680
1681     JITCompiler::Call callOperation(C_JITOperation_EGJ operation, GPRReg result, JSGlobalObject* globalObject, GPRReg arg1)
1682     {
1683         m_jit.setupArgumentsWithExecState(TrustedImmPtr::weakPointer(m_jit.graph(), globalObject), arg1);
1684         return appendCallSetResult(operation, result);
1685     }
1686
1687     JITCompiler::Call callOperation(C_JITOperation_EGJ operation, GPRReg result, JSGlobalObject* globalObject, JSValueRegs arg1)
1688     {
1689         return callOperation(operation, result, globalObject, arg1.gpr());
1690     }
1691
1692     JITCompiler::Call callOperation(C_JITOperation_EJ operation, GPRReg result, GPRReg arg1)
1693     {
1694         m_jit.setupArgumentsWithExecState(arg1);
1695         return appendCallSetResult(operation, result);
1696     }
1697     JITCompiler::Call callOperation(C_JITOperation_EJ operation, GPRReg result, JSValueRegs arg1)
1698     {
1699         m_jit.setupArgumentsWithExecState(arg1.gpr());
1700         return appendCallSetResult(operation, result);
1701     }
1702     JITCompiler::Call callOperation(C_JITOperation_EJJ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1703     {
1704         m_jit.setupArgumentsWithExecState(arg1, arg2);
1705         return appendCallSetResult(operation, result);
1706     }
1707     JITCompiler::Call callOperation(C_JITOperation_EJJC operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1708     {
1709         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1710         return appendCallSetResult(operation, result);
1711     }
1712     JITCompiler::Call callOperation(C_JITOperation_EJJJ operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1713     {
1714         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1715         return appendCallSetResult(operation, result);
1716     }
1717     JITCompiler::Call callOperation(C_JITOperation_EJZ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1718     {
1719         m_jit.setupArgumentsWithExecState(arg1, arg2);
1720         return appendCallSetResult(operation, result);
1721     }
1722     JITCompiler::Call callOperation(C_JITOperation_EJZC operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1723     {
1724         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1725         return appendCallSetResult(operation, result);
1726     }
1727     JITCompiler::Call callOperation(S_JITOperation_J operation, GPRReg result, GPRReg arg1)
1728     {
1729         m_jit.setupArguments(arg1);
1730         return appendCallSetResult(operation, result);
1731     }
1732     JITCompiler::Call callOperation(S_JITOperation_EJ operation, GPRReg result, GPRReg arg1)
1733     {
1734         m_jit.setupArgumentsWithExecState(arg1);
1735         return appendCallSetResult(operation, result);
1736     }
1737     JITCompiler::Call callOperation(S_JITOperation_EJ operation, GPRReg result, JSValueRegs arg1)
1738     {
1739         return callOperation(operation, result, arg1.gpr());
1740     }
1741     JITCompiler::Call callOperation(J_JITOperation_EJ operation, JSValueRegs result, JSValueRegs arg1)
1742     {
1743         return callOperation(operation, result.payloadGPR(), arg1.payloadGPR());
1744     }
1745     JITCompiler::Call callOperation(J_JITOperation_EJ operation, GPRReg result, JSValueRegs arg1)
1746     {
1747         return callOperation(operation, result, arg1.payloadGPR());
1748     }
1749     JITCompiler::Call callOperation(J_JITOperation_EJ operation, GPRReg result, GPRReg arg1)
1750     {
1751         m_jit.setupArgumentsWithExecState(arg1);
1752         return appendCallSetResult(operation, result);
1753     }
1754     JITCompiler::Call callOperation(S_JITOperation_EJI operation, GPRReg result, GPRReg arg1, UniquedStringImpl* uid)
1755     {
1756         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr(uid));
1757         return appendCallSetResult(operation, result);
1758     }
1759     JITCompiler::Call callOperation(S_JITOperation_EJI operation, GPRReg result, JSValueRegs arg1, UniquedStringImpl* uid)
1760     {
1761         return callOperation(operation, result, arg1.gpr(), uid);
1762     }
1763     JITCompiler::Call callOperation(S_JITOperation_EJJ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1764     {
1765         m_jit.setupArgumentsWithExecState(arg1, arg2);
1766         return appendCallSetResult(operation, result);
1767     }
1768     JITCompiler::Call callOperation(S_JITOperation_EJJ operation, GPRReg result,  JSValueRegs arg1, JSValueRegs arg2)
1769     {
1770         return callOperation(operation, result, arg1.gpr(), arg2.gpr());
1771     }
1772     JITCompiler::Call callOperation(S_JITOperation_EGJJ operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1773     {
1774         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1775         return appendCallSetResult(operation, result);
1776     }
1777     JITCompiler::Call callOperation(S_JITOperation_EGReoJ operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1778     {
1779         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1780         return appendCallSetResult(operation, result);
1781     }
1782     JITCompiler::Call callOperation(S_JITOperation_EGReoJss operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1783     {
1784         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1785         return appendCallSetResult(operation, result);
1786     }
1787
1788     JITCompiler::Call callOperation(J_JITOperation_EPP operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1789     {
1790         m_jit.setupArgumentsWithExecState(arg1, arg2);
1791         return appendCallSetResult(operation, result);
1792     }
1793     JITCompiler::Call callOperation(J_JITOperation_EPPP operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1794     {
1795         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1796         return appendCallSetResult(operation, result);
1797     }
1798     JITCompiler::Call callOperation(J_JITOperation_EGP operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1799     {
1800         m_jit.setupArgumentsWithExecState(arg1, arg2);
1801         return appendCallSetResult(operation, result);
1802     }
1803     JITCompiler::Call callOperation(J_JITOperation_EJJ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1804     {
1805         m_jit.setupArgumentsWithExecState(arg1, arg2);
1806         return appendCallSetResult(operation, result);
1807     }
1808     JITCompiler::Call callOperation(J_JITOperation_EGJJ operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1809     {
1810         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1811         return appendCallSetResult(operation, result);
1812     }
1813     JITCompiler::Call callOperation(J_JITOperation_EJJ operation, GPRReg result, GPRReg arg1, int32_t imm)
1814     {
1815         m_jit.setupArgumentsWithExecState(arg1, MacroAssembler::TrustedImm64(JSValue::encode(jsNumber(imm))));
1816         return appendCallSetResult(operation, result);
1817     }
1818     JITCompiler::Call callOperation(J_JITOperation_EJJ operation, GPRReg result, int32_t imm, GPRReg arg2)
1819     {
1820         m_jit.setupArgumentsWithExecState(MacroAssembler::TrustedImm64(JSValue::encode(jsNumber(imm))), arg2);
1821         return appendCallSetResult(operation, result);
1822     }
1823     JITCompiler::Call callOperation(J_JITOperation_EJJ operation, JSValueRegs result, JSValueRegs arg1, JSValueRegs arg2)
1824     {
1825         return callOperation(operation, result.payloadGPR(), arg1.payloadGPR(), arg2.payloadGPR());
1826     }
1827     JITCompiler::Call callOperation(J_JITOperation_EJJJ operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1828     {
1829         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1830         return appendCallSetResult(operation, result);
1831     }
1832     JITCompiler::Call callOperation(J_JITOperation_EJJJJ operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4)
1833     {
1834         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3, arg4);
1835         return appendCallSetResult(operation, result);
1836     }
1837     JITCompiler::Call callOperation(J_JITOperation_ECC operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1838     {
1839         m_jit.setupArgumentsWithExecState(arg1, arg2);
1840         return appendCallSetResult(operation, result);
1841     }
1842     JITCompiler::Call callOperation(J_JITOperation_ECJ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1843     {
1844         m_jit.setupArgumentsWithExecState(arg1, arg2);
1845         return appendCallSetResult(operation, result);
1846     }
1847     JITCompiler::Call callOperation(J_JITOperation_ECJ operation, GPRReg result, GPRReg arg1, JSValueRegs arg2)
1848     {
1849         m_jit.setupArgumentsWithExecState(arg1, arg2.gpr());
1850         return appendCallSetResult(operation, result);
1851     }
1852
1853     JITCompiler::Call callOperation(V_JITOperation_EOZD operation, GPRReg arg1, GPRReg arg2, FPRReg arg3)
1854     {
1855         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1856         return appendCall(operation);
1857     }
1858     JITCompiler::Call callOperation(V_JITOperation_EJ operation, GPRReg arg1)
1859     {
1860         m_jit.setupArgumentsWithExecState(arg1);
1861         return appendCall(operation);
1862     }
1863     JITCompiler::Call callOperation(V_JITOperation_EJPP operation, GPRReg arg1, GPRReg arg2, void* pointer)
1864     {
1865         m_jit.setupArgumentsWithExecState(arg1, arg2, TrustedImmPtr(pointer));
1866         return appendCall(operation);
1867     }
1868     JITCompiler::Call callOperation(V_JITOperation_ESsiJJI operation, StructureStubInfo* stubInfo, GPRReg arg1, GPRReg arg2, UniquedStringImpl* uid)
1869     {
1870         m_jit.setupArgumentsWithExecState(TrustedImmPtr(stubInfo), arg1, arg2, TrustedImmPtr(uid));
1871         return appendCall(operation);
1872     }
1873     JITCompiler::Call callOperation(V_JITOperation_EJJJ operation, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1874     {
1875         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1876         return appendCall(operation);
1877     }
1878     JITCompiler::Call callOperation(V_JITOperation_EPZJ operation, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1879     {
1880         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1881         return appendCall(operation);
1882     }
1883
1884     JITCompiler::Call callOperation(V_JITOperation_EOZJ operation, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1885     {
1886         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1887         return appendCall(operation);
1888     }
1889     JITCompiler::Call callOperation(V_JITOperation_ECJ operation, GPRReg arg1, JSValueRegs arg2)
1890     {
1891         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR());
1892         return appendCall(operation);
1893     }
1894     JITCompiler::Call callOperation(V_JITOperation_ECJJ operation, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1895     {
1896         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1897         return appendCall(operation);
1898     }
1899
1900     JITCompiler::Call callOperation(Z_JITOperation_EJ operation, GPRReg result, JSValueRegs arg1)
1901     {
1902         m_jit.setupArgumentsWithExecState(arg1.payloadGPR());
1903         return appendCallSetResult(operation, result);
1904     }
1905
1906     JITCompiler::Call callOperation(Z_JITOperation_EJZZ operation, GPRReg result, GPRReg arg1, unsigned arg2, unsigned arg3)
1907     {
1908         m_jit.setupArgumentsWithExecState(arg1, TrustedImm32(arg2), TrustedImm32(arg3));
1909         return appendCallSetResult(operation, result);
1910     }
1911     JITCompiler::Call callOperation(F_JITOperation_EFJZZ operation, GPRReg result, GPRReg arg1, GPRReg arg2, unsigned arg3, GPRReg arg4)
1912     {
1913         m_jit.setupArgumentsWithExecState(arg1, arg2, TrustedImm32(arg3), arg4);
1914         return appendCallSetResult(operation, result);
1915     }
1916
1917     JITCompiler::Call callOperation(Z_JITOperation_EJOJ operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1918     {
1919         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1920         return appendCallSetResult(operation, result);
1921     }
1922     JITCompiler::Call callOperation(Z_JITOperation_EJOJ operation, GPRReg result, JSValueRegs arg1, GPRReg arg2, JSValueRegs arg3)
1923     {
1924         return callOperation(operation, result, arg1.payloadGPR(), arg2, arg3.payloadGPR());
1925     }
1926
1927     JITCompiler::Call callOperation(Z_JITOperation_EJZ operation, GPRReg result, GPRReg arg1, unsigned arg2)
1928     {
1929         m_jit.setupArgumentsWithExecState(arg1, TrustedImm32(arg2));
1930         return appendCallSetResult(operation, result);
1931     }
1932     JITCompiler::Call callOperation(V_JITOperation_EZJZZZ operation, unsigned arg1, GPRReg arg2, unsigned arg3, GPRReg arg4, unsigned arg5)
1933     {
1934         m_jit.setupArgumentsWithExecState(TrustedImm32(arg1), arg2, TrustedImm32(arg3), arg4, TrustedImm32(arg5));
1935         return appendCall(operation);
1936     }
1937     JITCompiler::Call callOperation(V_JITOperation_ECJZC operation, GPRReg regOp1, GPRReg regOp2, int32_t op3, GPRReg regOp4)
1938     {
1939         m_jit.setupArgumentsWithExecState(regOp1, regOp2, TrustedImm32(op3), regOp4);
1940         return appendCall(operation);
1941     }
1942     JITCompiler::Call callOperation(V_JITOperation_ECIZJJ operation, GPRReg regOp1, UniquedStringImpl* identOp2, int32_t op3, GPRReg regOp4, GPRReg regOp5)
1943     {
1944         m_jit.setupArgumentsWithExecState(regOp1, TrustedImmPtr(identOp2), TrustedImm32(op3), regOp4, regOp5);
1945         return appendCall(operation);
1946     }
1947     JITCompiler::Call callOperation(D_JITOperation_EJ operation, FPRReg result, JSValueRegs arg1)
1948     {
1949         m_jit.setupArgumentsWithExecState(arg1.gpr());
1950         return appendCallSetResult(operation, result);
1951     }
1952 #else // USE(JSVALUE32_64)
1953     JITCompiler::Call callOperation(Z_JITOperation_EOJ operation, GPRReg result, GPRReg arg1, JSValueRegs arg2)
1954     {
1955         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg2.tagGPR());
1956         return appendCallSetResult(operation, result);
1957     }
1958     JITCompiler::Call callOperation(C_JITOperation_ECJZ operation, GPRReg result, GPRReg arg1, JSValueRegs arg2, GPRReg arg3)
1959     {
1960         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg2.tagGPR(), arg3);
1961         return appendCallSetResult(operation, result);
1962     }
1963     JITCompiler::Call callOperation(J_JITOperation_EJMic operation, JSValueRegs result, JSValueRegs arg, TrustedImmPtr mathIC)
1964     {
1965         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg.payloadGPR(), arg.tagGPR(), mathIC);
1966         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
1967     }
1968     JITCompiler::Call callOperation(J_JITOperation_EJZ operation, JSValueRegs result, JSValueRegs arg1, GPRReg arg2)
1969     {
1970         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2);
1971         return appendCallSetResult(operation, result);
1972     }
1973     JITCompiler::Call callOperation(J_JITOperation_EJJMic operation, JSValueRegs result, JSValueRegs arg1, JSValueRegs arg2, TrustedImmPtr mathIC)
1974     {
1975         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2.payloadGPR(), arg2.tagGPR(), mathIC);
1976         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
1977     }
1978
1979     JITCompiler::Call callOperation(J_JITOperation_EJJI operation, JSValueRegs result, JSValueRegs arg1, JSValueRegs arg2, UniquedStringImpl* uid)
1980     {
1981         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2.payloadGPR(), arg2.tagGPR(), TrustedImmPtr(uid));
1982         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
1983     }
1984     JITCompiler::Call callOperation(V_JITOperation_EJJJI operation, JSValueRegs arg1, JSValueRegs arg2, JSValueRegs arg3, UniquedStringImpl* uid)
1985     {
1986         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2.payloadGPR(), arg2.tagGPR(), arg3.payloadGPR(), arg3.tagGPR(), TrustedImmPtr(uid));
1987         return appendCall(operation);
1988     }
1989     JITCompiler::Call callOperation(V_JITOperation_EJJJJ operation, JSValueRegs arg1, JSValueRegs arg2, JSValueRegs arg3, JSValueRegs arg4)
1990     {
1991         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2.payloadGPR(), arg2.tagGPR(), arg3.payloadGPR(), arg3.tagGPR(), arg4.payloadGPR(), arg4.tagGPR());
1992         return appendCall(operation);
1993     }
1994     JITCompiler::Call callOperation(J_JITOperation_EJscI operation, JSValueRegs result, GPRReg arg1, UniquedStringImpl* impl)
1995     {
1996         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr(impl));
1997         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
1998     }
1999     JITCompiler::Call callOperation(V_JITOperation_EOJJZ operation, GPRReg arg1, JSValueRegs arg2, JSValueRegs arg3, GPRReg arg4)
2000     {
2001         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg2.tagGPR(), arg3.payloadGPR(), arg3.tagGPR(), arg4);
2002         return appendCall(operation);
2003     }
2004     JITCompiler::Call callOperation(V_JITOperation_EOJssJZ operation, GPRReg arg1, GPRReg arg2, JSValueRegs arg3, GPRReg arg4)
2005     {
2006         m_jit.setupArgumentsWithExecState(arg1, arg2, EABI_32BIT_DUMMY_ARG arg3.payloadGPR(), arg3.tagGPR(), arg4);
2007         return appendCall(operation);
2008     }
2009     JITCompiler::Call callOperation(V_JITOperation_EOIJZ operation, GPRReg arg1, GPRReg arg2, JSValueRegs arg3, GPRReg arg4)
2010     {
2011         m_jit.setupArgumentsWithExecState(arg1, arg2, EABI_32BIT_DUMMY_ARG arg3.payloadGPR(), arg3.tagGPR(), arg4);
2012         return appendCall(operation);
2013     }
2014     JITCompiler::Call callOperation(V_JITOperation_EOSymJZ operation, GPRReg arg1, GPRReg arg2, JSValueRegs arg3, GPRReg arg4)
2015     {
2016         m_jit.setupArgumentsWithExecState(arg1, arg2, EABI_32BIT_DUMMY_ARG arg3.payloadGPR(), arg3.tagGPR(), arg4);
2017         return appendCall(operation);
2018     }
2019     JITCompiler::Call callOperation(V_JITOperation_EOJOOZ operation, GPRReg arg1, JSValueRegs arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
2020     {
2021         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg2.tagGPR(), arg3, arg4, arg5);
2022         return appendCall(operation);
2023     }
2024     JITCompiler::Call callOperation(V_JITOperation_EOJssOOZ operation, GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
2025     {
2026         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3, arg4, arg5);
2027         return appendCall(operation);
2028     }
2029     JITCompiler::Call callOperation(V_JITOperation_EOIOOZ operation, GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
2030     {
2031         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3, arg4, arg5);
2032         return appendCall(operation);
2033     }
2034     JITCompiler::Call callOperation(V_JITOperation_EOSymOOZ operation, GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
2035     {
2036         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3, arg4, arg5);
2037         return appendCall(operation);
2038     }
2039     JITCompiler::Call callOperation(V_JITOperation_EOJIUi operation, GPRReg arg1, JSValueRegs arg2, UniquedStringImpl* impl, unsigned value)
2040     {
2041         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg2.tagGPR(), TrustedImmPtr(impl), TrustedImm32(value));
2042         return appendCall(operation);
2043     }
2044     JITCompiler::Call callOperation(J_JITOperation_EOIUi operation, JSValueRegs result, GPRReg arg1, UniquedStringImpl* impl, unsigned value)
2045     {
2046         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr(impl), TrustedImm32(value));
2047         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2048     }
2049     JITCompiler::Call callOperation(D_JITOperation_G operation, FPRReg result, JSGlobalObject* globalObject)
2050     {
2051         m_jit.setupArguments(TrustedImmPtr::weakPointer(m_jit.graph(), globalObject));
2052         return appendCallSetResult(operation, result);
2053     }
2054     JITCompiler::Call callOperation(Z_JITOperation_D operation, GPRReg result, FPRReg arg1)
2055     {
2056         prepareForExternalCall();
2057         m_jit.setupArguments(arg1);
2058         JITCompiler::Call call = m_jit.appendCall(operation);
2059         m_jit.zeroExtend32ToPtr(GPRInfo::returnValueGPR, result);
2060         return call;
2061     }
2062     JITCompiler::Call callOperation(J_JITOperation_E operation, JSValueRegs result)
2063     {
2064         m_jit.setupArgumentsExecState();
2065         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2066     }
2067     JITCompiler::Call callOperation(J_JITOperation_EP operation, JSValueRegs result, void* pointer)
2068     {
2069         m_jit.setupArgumentsWithExecState(TrustedImmPtr(pointer));
2070         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2071     }
2072     JITCompiler::Call callOperation(J_JITOperation_EPP operation, JSValueRegs result, GPRReg arg1, void* pointer)
2073     {
2074         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr(pointer));
2075         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2076     }
2077     JITCompiler::Call callOperation(J_JITOperation_EPP operation, JSValueRegs result, GPRReg arg1, GPRReg arg2)
2078     {
2079         m_jit.setupArgumentsWithExecState(arg1, arg2);
2080         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2081     }
2082     JITCompiler::Call callOperation(J_JITOperation_EPPP operation, JSValueRegs result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
2083     {
2084         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
2085         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2086     }
2087     JITCompiler::Call callOperation(J_JITOperation_EGP operation, JSValueRegs result, GPRReg arg1, GPRReg arg2)
2088     {
2089         m_jit.setupArgumentsWithExecState(arg1, arg2);
2090         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2091     }
2092     JITCompiler::Call callOperation(J_JITOperation_EP operation, JSValueRegs result, GPRReg arg1)
2093     {
2094         m_jit.setupArgumentsWithExecState(arg1);
2095         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2096     }
2097     JITCompiler::Call callOperation(J_JITOperation_EI operation, JSValueRegs result, UniquedStringImpl* uid)
2098     {
2099         m_jit.setupArgumentsWithExecState(TrustedImmPtr(uid));
2100         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2101     }
2102     JITCompiler::Call callOperation(J_JITOperation_EA operation, JSValueRegs result, GPRReg arg1)
2103     {
2104         m_jit.setupArgumentsWithExecState(arg1);
2105         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2106     }
2107     JITCompiler::Call callOperation(J_JITOperation_EAZ operation, JSValueRegs result, GPRReg arg1, GPRReg arg2)
2108     {
2109         m_jit.setupArgumentsWithExecState(arg1, arg2);
2110         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2111     }
2112     JITCompiler::Call callOperation(J_JITOperation_EJ operation, JSValueRegs result, GPRReg arg1)
2113     {
2114         m_jit.setupArgumentsWithExecState(arg1);
2115         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2116     }
2117     JITCompiler::Call callOperation(J_JITOperation_EJC operation, JSValueRegs result, JSValueRegs arg1, GPRReg arg2)
2118     {
2119         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2);
2120         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2121     }
2122     JITCompiler::Call callOperation(J_JITOperation_EJssZ operation, JSValueRegs result, GPRReg arg1, GPRReg arg2)
2123     {
2124         m_jit.setupArgumentsWithExecState(arg1, arg2);
2125         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2126     }
2127     JITCompiler::Call callOperation(J_JITOperation_EJssReo operation, JSValueRegs result, GPRReg arg1, GPRReg arg2)
2128     {
2129         m_jit.setupArgumentsWithExecState(arg1, arg2);
2130         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2131     }
2132     JITCompiler::Call callOperation(J_JITOperation_EJssReoJss operation, JSValueRegs result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
2133     {
2134         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
2135         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2136     }
2137     JITCompiler::Call callOperation(J_JITOperation_EPS operation, JSValueRegs result, void* pointer, size_t size)
2138     {
2139         m_jit.setupArgumentsWithExecState(TrustedImmPtr(pointer), TrustedImmPtr(size));
2140         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2141     }
2142     JITCompiler::Call callOperation(J_JITOperation_ESS operation, JSValueRegs result, int startConstant, int numConstants)
2143     {
2144         m_jit.setupArgumentsWithExecState(TrustedImm32(startConstant), TrustedImm32(numConstants));
2145         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2146     }
2147     JITCompiler::Call callOperation(J_JITOperation_EJP operation, JSValueRegs result, JSValueRegs arg1, void* pointer)
2148     {
2149         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), TrustedImmPtr(pointer));
2150         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2151     }
2152     JITCompiler::Call callOperation(J_JITOperation_EJP operation, JSValueRegs result, JSValueRegs arg1, GPRReg arg2)
2153     {
2154         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2);
2155         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2156     }
2157
2158     JITCompiler::Call callOperation(J_JITOperation_EC operation, JSValueRegs result, JSCell* cell)
2159     {
2160         m_jit.setupArgumentsWithExecState(TrustedImmPtr::weakPointer(m_jit.graph(), cell));
2161         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2162     }
2163     JITCompiler::Call callOperation(J_JITOperation_ECZ operation, JSValueRegs result, GPRReg arg1, GPRReg arg2)
2164     {
2165         m_jit.setupArgumentsWithExecState(arg1, arg2);
2166         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2167     }
2168     JITCompiler::Call callOperation(J_JITOperation_ECZZ operation, JSValueRegs result, GPRReg arg1, GPRReg arg2, int32_t constant)
2169     {
2170         m_jit.setupArgumentsWithExecState(arg1, arg2, TrustedImm32(constant));
2171         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2172     }
2173     JITCompiler::Call callOperation(J_JITOperation_EJscC operation, JSValueRegs result, GPRReg arg1, JSCell* cell)
2174     {
2175         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr::weakPointer(m_jit.graph(), cell));
2176         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2177     }
2178     JITCompiler::Call callOperation(J_JITOperation_EJscCJ operation, GPRReg result, GPRReg arg1, JSCell* cell, JSValueRegs arg2)
2179     {
2180         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr::weakPointer(m_jit.graph(), cell), EABI_32BIT_DUMMY_ARG arg2.payloadGPR(), arg2.tagGPR());
2181         return appendCallSetResult(operation, result);
2182     }
2183     JITCompiler::Call callOperation(J_JITOperation_EGReoJ operation, JSValueRegs result, GPRReg arg1, GPRReg arg2, JSValueRegs arg3)
2184     {
2185         m_jit.setupArgumentsWithExecState(arg1, arg2, EABI_32BIT_DUMMY_ARG arg3.payloadGPR(), arg3.tagGPR());
2186         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2187     }
2188     JITCompiler::Call callOperation(J_JITOperation_EGReoJss operation, JSValueRegs result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
2189     {
2190         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
2191         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2192     }
2193     JITCompiler::Call callOperation(J_JITOperation_ESsiCI operation, JSValueRegs result, StructureStubInfo* stubInfo, GPRReg arg1, const UniquedStringImpl* uid)
2194     {
2195         m_jit.setupArgumentsWithExecState(TrustedImmPtr(stubInfo), arg1, TrustedImmPtr(uid));
2196         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2197     }
2198     JITCompiler::Call callOperation(J_JITOperation_ESsiJI operation, JSValueRegs result, StructureStubInfo* stubInfo, JSValueRegs arg1, UniquedStringImpl* uid)
2199     {
2200         m_jit.setupArgumentsWithExecState(TrustedImmPtr(stubInfo), arg1.payloadGPR(), arg1.tagGPR(), TrustedImmPtr(uid));
2201         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2202     }
2203     JITCompiler::Call callOperation(J_JITOperation_ESsiJJI operation, JSValueRegs result, StructureStubInfo* stubInfo, JSValueRegs arg1, JSValueRegs arg2, UniquedStringImpl* uid)
2204     {
2205         m_jit.setupArgumentsWithExecState(TrustedImmPtr(stubInfo), arg1.payloadGPR(), arg1.tagGPR(), arg2.payloadGPR(), arg2.tagGPR(), TrustedImmPtr(uid));
2206         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2207     }
2208     JITCompiler::Call callOperation(J_JITOperation_ESsiJJI operation, JSValueRegs result, StructureStubInfo* stubInfo, int32_t arg1Tag, GPRReg arg1Payload, GPRReg arg2Tag, GPRReg arg2Payload, UniquedStringImpl* uid)
2209     {
2210         m_jit.setupArgumentsWithExecState(TrustedImmPtr(stubInfo), arg1Payload, TrustedImm32(arg1Tag), arg2Payload, arg2Tag, TrustedImmPtr(uid));
2211         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2212     }
2213     JITCompiler::Call callOperation(J_JITOperation_ESsiJI operation, JSValueRegs result, StructureStubInfo* stubInfo, int32_t arg1Tag, GPRReg arg1Payload, UniquedStringImpl* uid)
2214     {
2215         m_jit.setupArgumentsWithExecState(TrustedImmPtr(stubInfo), arg1Payload, TrustedImm32(arg1Tag), TrustedImmPtr(uid));
2216         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2217     }
2218     JITCompiler::Call callOperation(J_JITOperation_ESsiJJI operation, JSValueRegs result, StructureStubInfo* stubInfo, int32_t arg1Tag, GPRReg arg1Payload, int32_t arg2Tag, GPRReg arg2Payload, UniquedStringImpl* uid)
2219     {
2220         m_jit.setupArgumentsWithExecState(TrustedImmPtr(stubInfo), arg1Payload, TrustedImm32(arg1Tag), arg2Payload, TrustedImm32(arg2Tag), TrustedImmPtr(uid));
2221         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2222     }
2223     JITCompiler::Call callOperation(J_JITOperation_ESsiJI operation, JSValueRegs result, StructureStubInfo* stubInfo, GPRReg arg1Tag, GPRReg arg1Payload, UniquedStringImpl* uid)
2224     {
2225         m_jit.setupArgumentsWithExecState(TrustedImmPtr(stubInfo), arg1Payload, arg1Tag, TrustedImmPtr(uid));
2226         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2227     }
2228     JITCompiler::Call callOperation(J_JITOperation_EDA operation, JSValueRegs result, FPRReg arg1, GPRReg arg2)
2229     {
2230         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1, arg2);
2231         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2232     }
2233     JITCompiler::Call callOperation(J_JITOperation_EJA operation, JSValueRegs result, JSValueRegs arg1, GPRReg arg2)
2234     {
2235         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2);
2236         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2237     }
2238     JITCompiler::Call callOperation(J_JITOperation_EJA operation, JSValueRegs result, TrustedImm32 arg1Tag, GPRReg arg1Payload, GPRReg arg2)
2239     {
2240         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1Payload, arg1Tag, arg2);
2241         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2242     }
2243     JITCompiler::Call callOperation(J_JITOperation_EJA operation, JSValueRegs result, GPRReg arg1Tag, GPRReg arg1Payload, GPRReg arg2)
2244     {
2245         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1Payload, arg1Tag, arg2);
2246         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2247     }
2248     JITCompiler::Call callOperation(J_JITOperation_EJ operation, JSValueRegs result, JSValueRegs arg1)
2249     {
2250         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR());
2251         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2252     }
2253     JITCompiler::Call callOperation(J_JITOperation_EZ operation, JSValueRegs result, GPRReg arg1)
2254     {
2255         m_jit.setupArgumentsWithExecState(arg1);
2256         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2257     }
2258     JITCompiler::Call callOperation(J_JITOperation_EZ operation, JSValueRegs result, int32_t arg1)
2259     {
2260         m_jit.setupArgumentsWithExecState(TrustedImm32(arg1));
2261         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2262     }
2263     JITCompiler::Call callOperation(J_JITOperation_EZIcfZ operation, JSValueRegs result, int32_t arg1, InlineCallFrame* inlineCallFrame, GPRReg arg2)
2264     {
2265         m_jit.setupArgumentsWithExecState(TrustedImm32(arg1), TrustedImmPtr(inlineCallFrame), arg2);
2266         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2267     }
2268     JITCompiler::Call callOperation(J_JITOperation_EZZ operation, JSValueRegs result, int32_t arg1, GPRReg arg2)
2269     {
2270         m_jit.setupArgumentsWithExecState(TrustedImm32(arg1), arg2);
2271         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2272     }
2273
2274     JITCompiler::Call callOperation(P_JITOperation_EJS operation, GPRReg result, JSValueRegs value, size_t index)
2275     {
2276         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG value.payloadGPR(), value.tagGPR(), TrustedImmPtr(index));
2277         return appendCallSetResult(operation, result);
2278     }
2279
2280     JITCompiler::Call callOperation(P_JITOperation_EStJ operation, GPRReg result, RegisteredStructure structure, JSValueRegs arg2)
2281     {
2282         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), arg2.payloadGPR(), arg2.tagGPR());
2283         return appendCallSetResult(operation, result);
2284     }
2285
2286     JITCompiler::Call callOperation(C_JITOperation_EGJ operation, GPRReg result, JSGlobalObject* globalObject, JSValueRegs arg1)
2287     {
2288         m_jit.setupArgumentsWithExecState(TrustedImmPtr::weakPointer(m_jit.graph(), globalObject), arg1.payloadGPR(), arg1.tagGPR());
2289         return appendCallSetResult(operation, result);
2290     }
2291
2292     JITCompiler::Call callOperation(C_JITOperation_EJ operation, GPRReg result, JSValueRegs arg1)
2293     {
2294         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR());
2295         return appendCallSetResult(operation, result);
2296     }
2297
2298     JITCompiler::Call callOperation(C_JITOperation_EJJ operation, GPRReg result, JSValueRegs arg1, JSValueRegs arg2)
2299     {
2300         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2.payloadGPR(), arg2.tagGPR());
2301         return appendCallSetResult(operation, result);
2302     }
2303
2304     JITCompiler::Call callOperation(C_JITOperation_EJJJ operation, GPRReg result, JSValueRegs arg1, JSValueRegs arg2, JSValueRegs arg3)
2305     {
2306         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2.payloadGPR(), arg2.tagGPR(), arg3.payloadGPR(), arg3.tagGPR());
2307         return appendCallSetResult(operation, result);
2308     }
2309
2310     JITCompiler::Call callOperation(S_JITOperation_EJ operation, GPRReg result, JSValueRegs arg1)
2311     {
2312         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR());
2313         return appendCallSetResult(operation, result);
2314     }
2315
2316     JITCompiler::Call callOperation(S_JITOperation_EJI operation, GPRReg result, JSValueRegs arg1, UniquedStringImpl* uid)
2317     {
2318         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), TrustedImmPtr(uid));
2319         return appendCallSetResult(operation, result);
2320     }
2321
2322     JITCompiler::Call callOperation(S_JITOperation_EJJ operation, GPRReg result, JSValueRegs arg1, JSValueRegs arg2)
2323     {
2324         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2.payloadGPR(), arg2.tagGPR());
2325         return appendCallSetResult(operation, result);
2326     }
2327
2328     JITCompiler::Call callOperation(S_JITOperation_EGJJ operation, GPRReg result, GPRReg arg1, JSValueRegs arg2, JSValueRegs arg3)
2329     {
2330         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg2.tagGPR(), arg3.payloadGPR(), arg3.tagGPR());
2331         return appendCallSetResult(operation, result);
2332     }
2333     JITCompiler::Call callOperation(S_JITOperation_EGReoJ operation, GPRReg result, GPRReg arg1, GPRReg arg2, JSValueRegs arg3)
2334     {
2335         m_jit.setupArgumentsWithExecState(arg1, arg2, EABI_32BIT_DUMMY_ARG arg3.payloadGPR(), arg3.tagGPR());
2336         return appendCallSetResult(operation, result);
2337     }
2338     JITCompiler::Call callOperation(S_JITOperation_EGReoJss operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
2339     {
2340         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
2341         return appendCallSetResult(operation, result);
2342     }
2343     JITCompiler::Call callOperation(J_JITOperation_EJJ operation, JSValueRegs result, JSValueRegs arg1, JSValueRegs arg2)
2344     {
2345         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2.payloadGPR(), arg2.tagGPR());
2346         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2347     }
2348     JITCompiler::Call callOperation(J_JITOperation_EGJJ operation, JSValueRegs result, GPRReg arg1, JSValueRegs arg2, JSValueRegs arg3)
2349     {
2350         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg2.tagGPR(), arg3.payloadGPR(), arg3.tagGPR());
2351         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2352     }
2353     JITCompiler::Call callOperation(J_JITOperation_EJJ operation, JSValueRegs result, JSValueRegs arg1, MacroAssembler::TrustedImm32 imm)
2354     {
2355         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), imm, TrustedImm32(JSValue::Int32Tag));
2356         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2357     }
2358     JITCompiler::Call callOperation(J_JITOperation_EJJ operation, JSValueRegs result, MacroAssembler::TrustedImm32 imm, JSValueRegs arg2)
2359     {
2360         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG imm, TrustedImm32(JSValue::Int32Tag), arg2.payloadGPR(), arg2.tagGPR());
2361         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2362     }
2363     JITCompiler::Call callOperation(J_JITOperation_EJJJ operation, JSValueRegs result, JSValueRegs arg1, JSValueRegs arg2, JSValueRegs arg3)
2364     {
2365         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2.payloadGPR(), arg2.tagGPR(), arg3.payloadGPR(), arg3.tagGPR());
2366         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2367     }
2368
2369     JITCompiler::Call callOperation(J_JITOperation_ECJ operation, JSValueRegs result, GPRReg arg1, JSValueRegs arg2)
2370     {
2371         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg2.tagGPR());
2372         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2373     }
2374     JITCompiler::Call callOperation(J_JITOperation_ECJ operation, JSValueRegs result, GPRReg arg1, GPRReg arg2Payload)
2375     {
2376         m_jit.setupArgumentsWithExecState(arg1, arg2Payload, MacroAssembler::TrustedImm32(JSValue::CellTag));
2377         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2378     }
2379     JITCompiler::Call callOperation(J_JITOperation_ECC operation, JSValueRegs result, GPRReg arg1, GPRReg arg2)
2380     {
2381         m_jit.setupArgumentsWithExecState(arg1, arg2);
2382         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2383     }
2384
2385     JITCompiler::Call callOperation(V_JITOperation_EOZD operation, GPRReg arg1, GPRReg arg2, FPRReg arg3)
2386     {
2387         m_jit.setupArgumentsWithExecState(arg1, arg2, EABI_32BIT_DUMMY_ARG arg3);
2388         return appendCall(operation);
2389     }
2390
2391     JITCompiler::Call callOperation(V_JITOperation_EJ operation, JSValueRegs arg1)
2392     {
2393         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR());
2394         return appendCall(operation);
2395     }
2396
2397     JITCompiler::Call callOperation(V_JITOperation_EJPP operation, JSValueRegs arg1, GPRReg arg2, void* pointer)
2398     {
2399         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2, TrustedImmPtr(pointer));
2400         return appendCall(operation);
2401     }
2402     JITCompiler::Call callOperation(V_JITOperation_ESsiJJI operation, StructureStubInfo* stubInfo, JSValueRegs arg1, GPRReg arg2Payload, UniquedStringImpl* uid)
2403     {
2404         m_jit.setupArgumentsWithExecState(TrustedImmPtr(stubInfo), arg1.payloadGPR(), arg1.tagGPR(), arg2Payload, TrustedImm32(JSValue::CellTag), TrustedImmPtr(uid));
2405         return appendCall(operation);
2406     }
2407     JITCompiler::Call callOperation(V_JITOperation_ECJ operation, GPRReg arg1, JSValueRegs arg2)
2408     {
2409         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg2.tagGPR());
2410         return appendCall(operation);
2411     }
2412     JITCompiler::Call callOperation(V_JITOperation_ECJJ operation, GPRReg arg1, JSValueRegs arg2, JSValueRegs arg3)
2413     {
2414         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg2.tagGPR(), arg3.payloadGPR(), arg3.tagGPR());
2415         return appendCall(operation);
2416     }
2417
2418     JITCompiler::Call callOperation(V_JITOperation_EPZJ operation, GPRReg arg1, GPRReg arg2, JSValueRegs arg3)
2419     {
2420         m_jit.setupArgumentsWithExecState(arg1, arg2, EABI_32BIT_DUMMY_ARG arg3.payloadGPR(), arg3.tagGPR());
2421         return appendCall(operation);
2422     }
2423
2424     JITCompiler::Call callOperation(V_JITOperation_EOZJ operation, GPRReg arg1, GPRReg arg2, JSValueRegs arg3)
2425     {
2426         m_jit.setupArgumentsWithExecState(arg1, arg2, EABI_32BIT_DUMMY_ARG arg3.payloadGPR(), arg3.tagGPR());
2427         return appendCall(operation);
2428     }
2429     JITCompiler::Call callOperation(V_JITOperation_EOZJ operation, GPRReg arg1, GPRReg arg2, TrustedImm32 arg3Tag, GPRReg arg3Payload)
2430     {
2431         m_jit.setupArgumentsWithExecState(arg1, arg2, EABI_32BIT_DUMMY_ARG arg3Payload, arg3Tag);
2432         return appendCall(operation);
2433     }
2434     JITCompiler::Call callOperation(V_JITOperation_EOZJ operation, GPRReg arg1, GPRReg arg2, GPRReg arg3Tag, GPRReg arg3Payload)
2435     {
2436         m_jit.setupArgumentsWithExecState(arg1, arg2, EABI_32BIT_DUMMY_ARG arg3Payload, arg3Tag);
2437         return appendCall(operation);
2438     }
2439
2440     JITCompiler::Call callOperation(Z_JITOperation_EJOJ operation, GPRReg result, JSValueRegs arg1, GPRReg arg2, JSValueRegs arg3)
2441     {
2442         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2, EABI_32BIT_DUMMY_ARG arg3.payloadGPR(), arg3.tagGPR());
2443         return appendCallSetResult(operation, result);
2444     }
2445     JITCompiler::Call callOperation(Z_JITOperation_EJ operation, GPRReg result, JSValueRegs arg1)
2446     {
2447         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG  arg1.payloadGPR(), arg1.tagGPR());
2448         return appendCallSetResult(operation, result);
2449     }
2450     JITCompiler::Call callOperation(Z_JITOperation_EJZZ operation, GPRReg result, JSValueRegs arg1, unsigned arg2, unsigned arg3)
2451     {
2452         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG  arg1.payloadGPR(), arg1.tagGPR(), TrustedImm32(arg2), TrustedImm32(arg3));
2453         return appendCallSetResult(operation, result);
2454     }
2455     JITCompiler::Call callOperation(F_JITOperation_EFJZZ operation, GPRReg result, GPRReg arg1, JSValueRegs arg2, unsigned arg3, GPRReg arg4)
2456     {
2457         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg2.tagGPR(), TrustedImm32(arg3), arg4);
2458         return appendCallSetResult(operation, result);
2459     }
2460     JITCompiler::Call callOperation(Z_JITOperation_EJZ operation, GPRReg result, JSValueRegs arg1, unsigned arg2)
2461     {
2462         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), TrustedImm32(arg2));
2463         return appendCallSetResult(operation, result);
2464     }
2465     JITCompiler::Call callOperation(V_JITOperation_EZJZZZ operation, unsigned arg1, JSValueRegs arg2, unsigned arg3, GPRReg arg4, unsigned arg5)
2466     {
2467         m_jit.setupArgumentsWithExecState(TrustedImm32(arg1), arg2.payloadGPR(), arg2.tagGPR(), TrustedImm32(arg3), arg4, TrustedImm32(arg5));
2468         return appendCall(operation);
2469     }
2470     JITCompiler::Call callOperation(V_JITOperation_ECJZC operation, GPRReg arg1, JSValueRegs arg2, int32_t arg3, GPRReg arg4)
2471     {
2472         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg2.tagGPR(), TrustedImm32(arg3), arg4);
2473         return appendCall(operation);
2474     }
2475     JITCompiler::Call callOperation(V_JITOperation_ECIZCC operation, GPRReg arg1, UniquedStringImpl* identOp2, int32_t op3, GPRReg arg4, GPRReg arg5)
2476     {
2477         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr(identOp2), TrustedImm32(op3), arg4, arg5);
2478         return appendCall(operation);
2479     }
2480     JITCompiler::Call callOperation(D_JITOperation_EJ operation, FPRReg result, JSValueRegs arg1)
2481     {
2482         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR());
2483         return appendCallSetResult(operation, result);
2484     }
2485 #endif // USE(JSVALUE32_64)
2486     
2487 #if !defined(NDEBUG) && !CPU(ARM) && !CPU(MIPS)
2488     void prepareForExternalCall()
2489     {
2490         // We're about to call out to a "native" helper function. The helper
2491         // function is expected to set topCallFrame itself with the ExecState
2492         // that is passed to it.
2493         //
2494         // We explicitly trash topCallFrame here so that we'll know if some of
2495         // the helper functions are not setting topCallFrame when they should
2496         // be doing so. Note: the previous value in topcallFrame was not valid
2497         // anyway since it was not being updated by JIT'ed code by design.
2498
2499         for (unsigned i = 0; i < sizeof(void*) / 4; i++)
2500             m_jit.store32(TrustedImm32(0xbadbeef), reinterpret_cast<char*>(&m_jit.vm()->topCallFrame) + i * 4);
2501     }
2502 #else
2503     void prepareForExternalCall() { }
2504 #endif
2505
2506     // These methods add call instructions, optionally setting results, and optionally rolling back the call frame on an exception.
2507     JITCompiler::Call appendCall(const FunctionPtr& function)
2508     {
2509         prepareForExternalCall();
2510         m_jit.emitStoreCodeOrigin(m_currentNode->origin.semantic);
2511         return m_jit.appendCall(function);
2512     }
2513     JITCompiler::Call appendCallWithCallFrameRollbackOnException(const FunctionPtr& function)
2514     {
2515         JITCompiler::Call call = appendCall(function);
2516         m_jit.exceptionCheckWithCallFrameRollback();
2517         return call;
2518     }
2519     JITCompiler::Call appendCallWithCallFrameRollbackOnExceptionSetResult(const FunctionPtr& function, GPRReg result)
2520     {
2521         JITCompiler::Call call = appendCallWithCallFrameRollbackOnException(function);
2522         if ((result != InvalidGPRReg) && (result != GPRInfo::returnValueGPR))
2523             m_jit.move(GPRInfo::returnValueGPR, result);
2524         return call;
2525     }
2526     JITCompiler::Call appendCallSetResult(const FunctionPtr& function, GPRReg result)
2527     {
2528         JITCompiler::Call call = appendCall(function);
2529         if (result != InvalidGPRReg)
2530             m_jit.move(GPRInfo::returnValueGPR, result);
2531         return call;
2532     }
2533     JITCompiler::Call appendCallSetResult(const FunctionPtr& function, GPRReg result1, GPRReg result2)
2534     {
2535         JITCompiler::Call call = appendCall(function);
2536         m_jit.setupResults(result1, result2);
2537         return call;
2538     }
2539     JITCompiler::Call appendCallSetResult(const FunctionPtr& function, JSValueRegs resultRegs)
2540     {
2541 #if USE(JSVALUE64)
2542         return appendCallSetResult(function, resultRegs.gpr());
2543 #else
2544         return appendCallSetResult(function, resultRegs.payloadGPR(), resultRegs.tagGPR());
2545 #endif
2546     }
2547 #if CPU(X86)
2548     JITCompiler::Call appendCallSetResult(const FunctionPtr& function, FPRReg result)
2549     {
2550         JITCompiler::Call call = appendCall(function);
2551         if (result != InvalidFPRReg) {
2552             m_jit.assembler().fstpl(0, JITCompiler::stackPointerRegister);
2553             m_jit.loadDouble(JITCompiler::stackPointerRegister, result);
2554         }
2555         return call;
2556     }
2557 #elif CPU(ARM) && !CPU(ARM_HARDFP)
2558     JITCompiler::Call appendCallSetResult(const FunctionPtr& function, FPRReg result)
2559     {
2560         JITCompiler::Call call = appendCall(function);
2561         if (result != InvalidFPRReg)
2562             m_jit.assembler().vmov(result, GPRInfo::returnValueGPR, GPRInfo::returnValueGPR2);
2563         return call;
2564     }
2565 #else // CPU(X86_64) || (CPU(ARM) && CPU(ARM_HARDFP)) || CPU(ARM64) || CPU(MIPS)
2566     JITCompiler::Call appendCallSetResult(const FunctionPtr& function, FPRReg result)
2567     {
2568         JITCompiler::Call call = appendCall(function);
2569         if (result != InvalidFPRReg)
2570             m_jit.moveDouble(FPRInfo::returnValueFPR, result);
2571         return call;
2572     }
2573 #endif
2574     
2575     void branchDouble(JITCompiler::DoubleCondition cond, FPRReg left, FPRReg right, BasicBlock* destination)
2576     {
2577         return addBranch(m_jit.branchDouble(cond, left, right), destination);
2578     }
2579     
2580     void branchDoubleNonZero(FPRReg value, FPRReg scratch, BasicBlock* destination)
2581     {
2582         return addBranch(m_jit.branchDoubleNonZero(value, scratch), destination);
2583     }
2584     
2585     template<typename T, typename U>
2586     void branch32(JITCompiler::RelationalCondition cond, T left, U right, BasicBlock* destination)
2587     {
2588         return addBranch(m_jit.branch32(cond, left, right), destination);
2589     }
2590     
2591     template<typename T, typename U>
2592     void branchTest32(JITCompiler::ResultCondition cond, T value, U mask, BasicBlock* destination)
2593     {
2594         return addBranch(m_jit.branchTest32(cond, value, mask), destination);
2595     }
2596     
2597     template<typename T>
2598     void branchTest32(JITCompiler::ResultCondition cond, T value, BasicBlock* destination)
2599     {
2600         return addBranch(m_jit.branchTest32(cond, value), destination);
2601     }
2602     
2603 #if USE(JSVALUE64)
2604     template<typename T, typename U>
2605     void branch64(JITCompiler::RelationalCondition cond, T left, U right, BasicBlock* destination)
2606     {
2607         return addBranch(m_jit.branch64(cond, left, right), destination);
2608     }
2609 #endif
2610     
2611     template<typename T, typename U>
2612     void branch8(JITCompiler::RelationalCondition cond, T left, U right, BasicBlock* destination)
2613     {
2614         return addBranch(m_jit.branch8(cond, left, right), destination);
2615     }
2616     
2617     template<typename T, typename U>
2618     void branchPtr(JITCompiler::RelationalCondition cond, T left, U right, BasicBlock* destination)
2619     {
2620         return addBranch(m_jit.branchPtr(cond, left, right), destination);
2621     }
2622     
2623     template<typename T, typename U>
2624     void branchTestPtr(JITCompiler::ResultCondition cond, T value, U mask, BasicBlock* destination)
2625     {
2626         return addBranch(m_jit.branchTestPtr(cond, value, mask), destination);
2627     }
2628     
2629     template<typename T>
2630     void branchTestPtr(JITCompiler::ResultCondition cond, T value, BasicBlock* destination)
2631     {
2632         return addBranch(m_jit.branchTestPtr(cond, value), destination);
2633     }
2634     
2635     template<typename T, typename U>
2636     void branchTest8(JITCompiler::ResultCondition cond, T value, U mask, BasicBlock* destination)
2637     {
2638         return addBranch(m_jit.branchTest8(cond, value, mask), destination);
2639     }
2640     
2641     template<typename T>
2642     void branchTest8(JITCompiler::ResultCondition cond, T value, BasicBlock* destination)
2643     {
2644         return addBranch(m_jit.branchTest8(cond, value), destination);
2645     }
2646     
2647     enum FallThroughMode {
2648         AtFallThroughPoint,
2649         ForceJump
2650     };
2651     void jump(BasicBlock* destination, FallThroughMode fallThroughMode = AtFallThroughPoint)
2652     {
2653         if (destination == nextBlock()
2654             && fallThroughMode == AtFallThroughPoint)
2655             return;
2656         addBranch(m_jit.jump(), destination);
2657     }
2658     
2659     void addBranch(const MacroAssembler::Jump& jump, BasicBlock* destination)
2660     {
2661         m_branches.append(BranchRecord(jump, destination));
2662     }
2663     void addBranch(const MacroAssembler::JumpList& jump, BasicBlock* destination);
2664
2665     void linkBranches();
2666
2667     void dump(const char* label = 0);
2668
2669     bool betterUseStrictInt52(Node* node)
2670     {
2671         return !generationInfo(node).isInt52();
2672     }
2673     bool betterUseStrictInt52(Edge edge)
2674     {
2675         return betterUseStrictInt52(edge.node());
2676     }
2677     
2678     bool compare(Node*, MacroAssembler::RelationalCondition, MacroAssembler::DoubleCondition, S_JITOperation_EJJ);
2679     bool compilePeepHoleBranch(Node*, MacroAssembler::RelationalCondition, MacroAssembler::DoubleCondition, S_JITOperation_EJJ);
2680     void compilePeepHoleInt32Branch(Node*, Node* branchNode, JITCompiler::RelationalCondition);
2681     void compilePeepHoleInt52Branch(Node*, Node* branchNode, JITCompiler::RelationalCondition);
2682     void compilePeepHoleBooleanBranch(Node*, Node* branchNode, JITCompiler::RelationalCondition);
2683     void compilePeepHoleDoubleBranch(Node*, Node* branchNode, JITCompiler::DoubleCondition);
2684     void compilePeepHoleObjectEquality(Node*, Node* branchNode);
2685     void compilePeepHoleObjectStrictEquality(Edge objectChild, Edge otherChild, Node* branchNode);
2686     void compilePeepHoleObjectToObjectOrOtherEquality(Edge leftChild, Edge rightChild, Node* branchNode);
2687     void compileObjectEquality(Node*);
2688     void compileObjectStrictEquality(Edge objectChild, Edge otherChild);
2689     void compileObjectToObjectOrOtherEquality(Edge leftChild, Edge rightChild);
2690     void compileObjectOrOtherLogicalNot(Edge value);
2691     void compileLogicalNot(Node*);
2692     void compileLogicalNotStringOrOther(Node*);
2693     void compileStringEquality(
2694         Node*, GPRReg leftGPR, GPRReg rightGPR, GPRReg lengthGPR,
2695         GPRReg leftTempGPR, GPRReg rightTempGPR, GPRReg leftTemp2GPR,
2696         GPRReg rightTemp2GPR, JITCompiler::JumpList fastTrue,
2697         JITCompiler::JumpList fastSlow);
2698     void compileStringEquality(Node*);
2699     void compileStringIdentEquality(Node*);
2700     void compileStringToUntypedEquality(Node*, Edge stringEdge, Edge untypedEdge);
2701     void compileStringIdentToNotStringVarEquality(Node*, Edge stringEdge, Edge notStringVarEdge);
2702     void compileStringZeroLength(Node*);
2703     void compileMiscStrictEq(Node*);
2704
2705     void compileSymbolEquality(Node*);
2706     void compilePeepHoleSymbolEquality(Node*, Node* branchNode);
2707     void compileSymbolUntypedEquality(Node*, Edge symbolEdge, Edge untypedEdge);
2708
2709     void emitObjectOrOtherBranch(Edge value, BasicBlock* taken, BasicBlock* notTaken);
2710     void emitStringBranch(Edge value, BasicBlock* taken, BasicBlock* notTaken);
2711     void emitStringOrOtherBranch(Edge value, BasicBlock* taken, BasicBlock* notTaken);
2712     void emitBranch(Node*);
2713     
2714     struct StringSwitchCase {
2715         StringSwitchCase() { }
2716         
2717         StringSwitchCase(StringImpl* string, BasicBlock* target)
2718             : string(string)
2719             , target(target)
2720         {
2721         }
2722         
2723         bool operator<(const StringSwitchCase& other) const
2724         {
2725             return stringLessThan(*string, *other.string);
2726         }
2727         
2728         StringImpl* string;
2729         BasicBlock* target;
2730     };
2731     
2732     void emitSwitchIntJump(SwitchData*, GPRReg value, GPRReg scratch);
2733     void emitSwitchImm(Node*, SwitchData*);
2734     void emitSwitchCharStringJump(SwitchData*, GPRReg value, GPRReg scratch);
2735     void emitSwitchChar(Node*, SwitchData*);
2736     void emitBinarySwitchStringRecurse(
2737         SwitchData*, const Vector<StringSwitchCase>&, unsigned numChecked,
2738         unsigned begin, unsigned end, GPRReg buffer, GPRReg length, GPRReg temp,
2739         unsigned alreadyCheckedLength, bool checkedExactLength);
2740     void emitSwitchStringOnString(SwitchData*, GPRReg string);
2741     void emitSwitchString(Node*, SwitchData*);
2742     void emitSwitch(Node*);
2743     
2744     void compileToStringOrCallStringConstructor(Node*);
2745     void compileToStringOrCallStringConstructorOnNumber(Node*);
2746     void compileNumberToStringWithRadix(Node*);
2747     void compileNewStringObject(Node*);
2748     
2749     void compileNewTypedArray(Node*);
2750     
2751     void compileInt32Compare(Node*, MacroAssembler::RelationalCondition);
2752     void compileInt52Compare(Node*, MacroAssembler::RelationalCondition);
2753     void compileBooleanCompare(Node*, MacroAssembler::RelationalCondition);
2754     void compileDoubleCompare(Node*, MacroAssembler::DoubleCondition);
2755     void compileStringCompare(Node*, MacroAssembler::RelationalCondition);
2756     void compileStringIdentCompare(Node*, MacroAssembler::RelationalCondition);
2757     
2758     bool compileStrictEq(Node*);
2759     
2760     void compileAllocatePropertyStorage(Node*);
2761     void compileReallocatePropertyStorage(Node*);
2762     void compileNukeStructureAndSetButterfly(Node*);
2763     void compileGetButterfly(Node*);
2764     void compileCallDOMGetter(Node*);
2765     void compileCallDOM(Node*);
2766     void compileCheckSubClass(Node*);
2767     
2768 #if USE(JSVALUE32_64)
2769     template<typename BaseOperandType, typename PropertyOperandType, typename ValueOperandType, typename TagType>
2770     void compileContiguousPutByVal(Node*, BaseOperandType&, PropertyOperandType&, ValueOperandType&, GPRReg valuePayloadReg, TagType valueTag);
2771 #endif
2772     void compileDoublePutByVal(Node*, SpeculateCellOperand& base, SpeculateStrictInt32Operand& property);
2773     bool putByValWillNeedExtraRegister(ArrayMode arrayMode)
2774     {
2775         return arrayMode.mayStoreToHole();
2776     }
2777     GPRReg temporaryRegisterForPutByVal(GPRTemporary&, ArrayMode);
2778     GPRReg temporaryRegisterForPutByVal(GPRTemporary& temporary, Node* node)
2779     {
2780         return temporaryRegisterForPutByVal(temporary, node->arrayMode());
2781     }
2782     
2783     void compileGetCharCodeAt(Node*);
2784     void compileGetByValOnString(Node*);
2785     void compileFromCharCode(Node*); 
2786
2787     void compileGetByValOnDirectArguments(Node*);
2788     void compileGetByValOnScopedArguments(Node*);
2789     
2790     void compileGetScope(Node*);
2791     void compileSkipScope(Node*);
2792     void compileGetGlobalObject(Node*);
2793
2794     void compileGetArrayLength(Node*);
2795
2796     void compileCheckTypeInfoFlags(Node*);
2797     void compileCheckStringIdent(Node*);
2798
2799     void compileParseInt(Node*);
2800     
2801     void compileValueRep(Node*);
2802     void compileDoubleRep(Node*);
2803     
2804     void compileValueToInt32(Node*);
2805     void compileUInt32ToNumber(Node*);
2806     void compileDoubleAsInt32(Node*);
2807
2808     template<typename SnippetGenerator, J_JITOperation_EJJ slowPathFunction>
2809     void emitUntypedBitOp(Node*);
2810     void compileBitwiseOp(Node*);
2811
2812     void emitUntypedRightShiftBitOp(Node*);
2813     void compileShiftOp(Node*);
2814
2815     template <typename Generator, typename RepatchingFunction, typename NonRepatchingFunction>
2816     void compileMathIC(Node*, JITBinaryMathIC<Generator>*, bool needsScratchGPRReg, bool needsScratchFPRReg, RepatchingFunction, NonRepatchingFunction);
2817     template <typename Generator, typename RepatchingFunction, typename NonRepatchingFunction>
2818     void compileMathIC(Node*, JITUnaryMathIC<Generator>*, bool needsScratchGPRReg, RepatchingFunction, NonRepatchingFunction);
2819
2820     void compileArithDoubleUnaryOp(Node*, double (*doubleFunction)(double), double (*operation)(ExecState*, EncodedJSValue));
2821     void compileValueAdd(Node*);
2822     void compileArithAdd(Node*);
2823     void compileMakeRope(Node*);
2824     void compileArithAbs(Node*);
2825     void compileArithClz32(Node*);
2826     void compileArithSub(Node*);
2827     void compileArithNegate(Node*);
2828     void compileArithMul(Node*);
2829     void compileArithDiv(Node*);
2830     void compileArithFRound(Node*);
2831     void compileArithMod(Node*);
2832     void compileArithPow(Node*);
2833     void compileArithRounding(Node*);
2834     void compileArithRandom(Node*);
2835     void compileArithUnary(Node*);
2836     void compileArithSqrt(Node*);
2837     void compileConstantStoragePointer(Node*);
2838     void compileGetIndexedPropertyStorage(Node*);
2839     JITCompiler::Jump jumpForTypedArrayOutOfBounds(Node*, GPRReg baseGPR, GPRReg indexGPR);
2840     JITCompiler::Jump jumpForTypedArrayIsNeuteredIfOutOfBounds(Node*, GPRReg baseGPR, JITCompiler::Jump outOfBounds);
2841     void emitTypedArrayBoundsCheck(Node*, GPRReg baseGPR, GPRReg indexGPR);
2842     void compileGetTypedArrayByteOffset(Node*);
2843     void compileGetByValOnIntTypedArray(Node*, TypedArrayType);
2844     void compilePutByValForIntTypedArray(GPRReg base, GPRReg property, Node*, TypedArrayType);
2845     void compileGetByValOnFloatTypedArray(Node*, TypedArrayType);
2846     void compilePutByValForFloatTypedArray(GPRReg base, GPRReg property, Node*, TypedArrayType);
2847     // If this returns false it means that we terminated speculative execution.
2848     bool getIntTypedArrayStoreOperand(
2849         GPRTemporary& value,
2850         GPRReg property,
2851 #if USE(JSVALUE32_64)
2852         GPRTemporary& propertyTag,
2853         GPRTemporary& valueTag,
2854 #endif
2855         Edge valueUse, JITCompiler::JumpList& slowPathCases, bool isClamped = false);
2856     void loadFromIntTypedArray(GPRReg storageReg, GPRReg propertyReg, GPRReg resultReg, TypedArrayType);
2857     void setIntTypedArrayLoadResult(Node*, GPRReg resultReg, TypedArrayType, bool canSpeculate = false);
2858     template <typename ClassType> void compileNewFunctionCommon(GPRReg, RegisteredStructure, GPRReg, GPRReg, GPRReg, MacroAssembler::JumpList&, size_t, FunctionExecutable*, ptrdiff_t, ptrdiff_t, ptrdiff_t);
2859     void compileNewFunction(Node*);
2860     void compileSetFunctionName(Node*);
2861     void compileForwardVarargs(Node*);
2862     void compileCreateActivation(Node*);
2863     void compileCreateDirectArguments(Node*);
2864     void compileGetFromArguments(Node*);
2865     void compilePutToArguments(Node*);
2866     void compileGetArgument(Node*);
2867     void compileCreateScopedArguments(Node*);
2868     void compileCreateClonedArguments(Node*);
2869     void compileCreateRest(Node*);
2870     void compileSpread(Node*);
2871     void compileNewArrayWithSpread(Node*);
2872     void compileGetRestLength(Node*);
2873     void compileArraySlice(Node*);
2874     void compileNotifyWrite(Node*);
2875     bool compileRegExpExec(Node*);
2876     void compileIsObjectOrNull(Node*);
2877     void compileIsFunction(Node*);
2878     void compileTypeOf(Node*);
2879     void compileCheckStructure(Node*, GPRReg cellGPR, GPRReg tempGPR);
2880     void compileCheckStructure(Node*);
2881     void compilePutAccessorById(Node*);
2882     void compilePutGetterSetterById(Node*);
2883     void compilePutAccessorByVal(Node*);
2884     void compileGetRegExpObjectLastIndex(Node*);
2885     void compileSetRegExpObjectLastIndex(Node*);
2886     void compileLazyJSConstant(Node*);
2887     void compileMaterializeNewObject(Node*);
2888     void compileRecordRegExpCachedResult(Node*);
2889     void compileCallObjectConstructor(Node*);
2890     void compileResolveScope(Node*);
2891     void compileResolveScopeForHoistingFuncDeclInEval(Node*);
2892     void compileGetDynamicVar(Node*);
2893     void compilePutDynamicVar(Node*);
2894     void compileCompareEqPtr(Node*);
2895     void compileDefineDataProperty(Node*);
2896     void compileDefineAccessorProperty(Node*);
2897     void compileToLowerCase(Node*);
2898
2899     void moveTrueTo(GPRReg);
2900     void moveFalseTo(GPRReg);
2901     void blessBoolean(GPRReg);
2902     
2903     // Allocator for a cell of a specific size.
2904     template <typename StructureType> // StructureType can be GPR or ImmPtr.
2905     void emitAllocateJSCell(
2906         GPRReg resultGPR, MarkedAllocator* allocator, GPRReg allocatorGPR, StructureType structure,
2907         GPRReg scratchGPR, MacroAssembler::JumpList& slowPath)
2908     {
2909         m_jit.emitAllocateJSCell(resultGPR, allocator, allocatorGPR, structure, scratchGPR, slowPath);
2910     }
2911
2912     // Allocator for an object of a specific size.
2913     template <typename StructureType, typename StorageType> // StructureType and StorageType can be GPR or ImmPtr.
2914     void emitAllocateJSObject(
2915         GPRReg resultGPR, MarkedAllocator* allocator, GPRReg allocatorGPR, StructureType structure,
2916         StorageType storage, GPRReg scratchGPR, MacroAssembler::JumpList& slowPath)
2917     {
2918         m_jit.emitAllocateJSObject(
2919             resultGPR, allocator, allocatorGPR, structure, storage, scratchGPR, slowPath);
2920     }
2921
2922     template <typename ClassType, typename StructureType, typename StorageType> // StructureType and StorageType can be GPR or ImmPtr.
2923     void emitAllocateJSObjectWithKnownSize(
2924         GPRReg resultGPR, StructureType structure, StorageType storage, GPRReg scratchGPR1,
2925         GPRReg scratchGPR2, MacroAssembler::JumpList& slowPath, size_t size)
2926     {
2927         m_jit.emitAllocateJSObjectWithKnownSize<ClassType>(*m_jit.vm(), resultGPR, structure, storage, scratchGPR1, scratchGPR2, slowPath, size);
2928     }
2929
2930     // Convenience allocator for a built-in object.
2931     template <typename ClassType, typename StructureType, typename StorageType> // StructureType and StorageType can be GPR or ImmPtr.
2932     void emitAllocateJSObject(GPRReg resultGPR, StructureType structure, StorageType storage,
2933         GPRReg scratchGPR1, GPRReg scratchGPR2, MacroAssembler::JumpList& slowPath)
2934     {
2935         m_jit.emitAllocateJSObject<ClassType>(*m_jit.vm(), resultGPR, structure, storage, scratchGPR1, scratchGPR2, slowPath);
2936     }
2937
2938     template <typename ClassType, typename StructureType> // StructureType and StorageType can be GPR or ImmPtr.
2939     void emitAllocateVariableSizedJSObject(GPRReg resultGPR, StructureType structure, GPRReg allocationSize, GPRReg scratchGPR1, GPRReg scratchGPR2, MacroAssembler::JumpList& slowPath)
2940     {
2941         m_jit.emitAllocateVariableSizedJSObject<ClassType>(*m_jit.vm(), resultGPR, structure, allocationSize, scratchGPR1, scratchGPR2, slowPath);
2942     }
2943
2944     template<typename ClassType>
2945     void emitAllocateDestructibleObject(GPRReg resultGPR, RegisteredStructure structure, 
2946         GPRReg scratchGPR1, GPRReg scratchGPR2, MacroAssembler::JumpList& slowPath)
2947     {
2948         m_jit.emitAllocateDestructibleObject<ClassType>(*m_jit.vm(), resultGPR, structure.get(), scratchGPR1, scratchGPR2, slowPath);
2949     }
2950
2951     void emitAllocateRawObject(GPRReg resultGPR, RegisteredStructure, GPRReg storageGPR, unsigned numElements, unsigned vectorLength);
2952     
2953     void emitGetLength(InlineCallFrame*, GPRReg lengthGPR, bool includeThis = false);
2954     void emitGetLength(CodeOrigin, GPRReg lengthGPR, bool includeThis = false);
2955     void emitGetCallee(CodeOrigin, GPRReg calleeGPR);
2956     void emitGetArgumentStart(CodeOrigin, GPRReg startGPR);
2957     
2958     // Generate an OSR exit fuzz check. Returns Jump() if OSR exit fuzz is not enabled, or if
2959     // it's in training mode.
2960     MacroAssembler::Jump emitOSRExitFuzzCheck();
2961     
2962     // Add a speculation check.
2963     void speculationCheck(ExitKind, JSValueSource, Node*, MacroAssembler::Jump jumpToFail);
2964     void speculationCheck(ExitKind, JSValueSource, Node*, const MacroAssembler::JumpList& jumpsToFail);
2965
2966     // Add a speculation check without additional recovery, and with a promise to supply a jump later.
2967     OSRExitJumpPlaceholder speculationCheck(ExitKind, JSValueSource, Node*);
2968     OSRExitJumpPlaceholder speculationCheck(ExitKind, JSValueSource, Edge);
2969     void speculationCheck(ExitKind, JSValueSource, Edge, MacroAssembler::Jump jumpToFail);
2970     void speculationCheck(ExitKind, JSValueSource, Edge, const MacroAssembler::JumpList& jumpsToFail);
2971     // Add a speculation check with additional recovery.
2972     void speculationCheck(ExitKind, JSValueSource, Node*, MacroAssembler::Jump jumpToFail, const SpeculationRecovery&);
2973     void speculationCheck(ExitKind, JSValueSource, Edge, MacroAssembler::Jump jumpToFail, const SpeculationRecovery&);
2974     
2975     void emitInvalidationPoint(Node*);
2976     
2977     void unreachable(Node*);
2978     
2979     // Called when we statically determine that a speculation will fail.
2980     void terminateSpeculativeExecution(ExitKind, JSValueRegs, Node*);
2981     void terminateSpeculativeExecution(ExitKind, JSValueRegs, Edge);
2982     
2983     // Helpers for performing type checks on an edge stored in the given registers.
2984     bool needsTypeCheck(Edge edge, SpeculatedType typesPassedThrough) { return m_interpreter.needsTypeCheck(edge, typesPassedThrough); }
2985     void typeCheck(JSValueSource, Edge, SpeculatedType typesPassedThrough, MacroAssembler::Jump jumpToFail, ExitKind = BadType);
2986     
2987     void speculateCellTypeWithoutTypeFiltering(Edge, GPRReg cellGPR, JSType);
2988     void speculateCellType(Edge, GPRReg cellGPR, SpeculatedType, JSType);
2989     
2990     void speculateInt32(Edge);
2991 #if USE(JSVALUE64)
2992     void convertAnyInt(Edge, GPRReg resultGPR);
2993     void speculateAnyInt(Edge);
2994     void speculateDoubleRepAnyInt(Edge);
2995 #endif // USE(JSVALUE64)
2996     void speculateNumber(Edge);
2997     void speculateRealNumber(Edge);
2998     void speculateDoubleRepReal(Edge);
2999     void speculateBoolean(Edge);
3000     void speculateCell(Edge);
3001     void speculateCellOrOther(Edge);
3002     void speculateObject(Edge);
3003     void speculateArray(Edge, GPRReg cell);
3004     void speculateArray(Edge);
3005     void speculateFunction(Edge);
3006     void speculateFinalObject(Edge);
3007     void speculateRegExpObject(Edge, GPRReg cell);
3008     void speculateRegExpObject(Edge);
3009     void speculateProxyObject(Edge, GPRReg cell);
3010     void speculateProxyObject(Edge);
3011     void speculateDerivedArray(Edge, GPRReg cell);
3012     void speculateDerivedArray(Edge);
3013     void speculateMapObject(Edge);
3014     void speculateMapObject(Edge, GPRReg cell);
3015     void speculateSetObject(Edge);
3016     void speculateSetObject(Edge, GPRReg cell);
3017     void speculateObjectOrOther(Edge);
3018     void speculateString(Edge edge, GPRReg cell);
3019     void speculateStringIdentAndLoadStorage(Edge edge, GPRReg string, GPRReg storage);
3020     void speculateStringIdent(Edge edge, GPRReg string);
3021     void speculateStringIdent(Edge);
3022     void speculateString(Edge);
3023     void speculateStringOrOther(Edge, JSValueRegs, GPRReg scratch);
3024     void speculateStringOrOther(Edge);
3025     void speculateNotStringVar(Edge);
3026     template<typename StructureLocationType>
3027     void speculateStringObjectForStructure(Edge, StructureLocationType);
3028     void speculateStringObject(Edge, GPRReg);
3029     void speculateStringObject(Edge);
3030     void speculateStringOrStringObject(Edge);
3031     void speculateSymbol(Edge, GPRReg cell);
3032     void speculateSymbol(Edge);
3033     void speculateNotCell(Edge, JSValueRegs);
3034     void speculateNotCell(Edge);
3035     void speculateOther(Edge);
3036     void speculateMisc(Edge, JSValueRegs);
3037     void speculateMisc(Edge);
3038     void speculate(Node*, Edge);
3039     
3040     JITCompiler::Jump jumpSlowForUnwantedArrayMode(GPRReg tempWithIndexingTypeReg, ArrayMode, IndexingType);
3041     JITCompiler::JumpList jumpSlowForUnwantedArrayMode(GPRReg tempWithIndexingTypeReg, ArrayMode);
3042     void checkArray(Node*);
3043     void arrayify(Node*, GPRReg baseReg, GPRReg propertyReg);
3044     void arrayify(Node*);
3045     
3046     template<bool strict>
3047     GPRReg fillSpeculateInt32Internal(Edge, DataFormat& returnFormat);
3048     
3049     // It is possible, during speculative generation, to reach a situation in which we
3050     // can statically determine a speculation will fail (for example, when two nodes
3051     // will make conflicting speculations about the same operand). In such cases this
3052     // flag is cleared, indicating no further code generation should take place.
3053     bool m_compileOkay;
3054     
3055     void recordSetLocal(
3056         VirtualRegister bytecodeReg, VirtualRegister machineReg, DataFormat format)
3057     {
3058         m_stream->appendAndLog(VariableEvent::setLocal(bytecodeReg, machineReg, format));
3059     }
3060     
3061     void recordSetLocal(DataFormat format)
3062     {
3063         VariableAccessData* variable = m_currentNode->variableAccessData();
3064         recordSetLocal(variable->local(), variable->machineLocal(), format);
3065     }
3066
3067     GenerationInfo& generationInfoFromVirtualRegister(VirtualRegister virtualRegister)
3068     {
3069         return m_generationInfo[virtualRegister.toLocal()];
3070     }
3071     
3072     GenerationInfo& generationInfo(Node* node)
3073     {
3074         return generationInfoFromVirtualRegister(node->virtualRegister());
3075     }
3076     
3077     GenerationInfo& generationInfo(Edge edge)
3078     {
3079         return generationInfo(edge.node());
3080     }
3081
3082     // The JIT, while also provides MacroAssembler functionality.
3083     JITCompiler& m_jit;
3084
3085     // The current node being generated.
3086     BasicBlock* m_block;
3087     Node* m_currentNode;
3088     NodeType m_lastGeneratedNode;
3089     unsigned m_indexInBlock;
3090     // Virtual and physical register maps.
3091     Vector<GenerationInfo, 32> m_generationInfo;
3092     RegisterBank<GPRInfo> m_gprs;
3093     RegisterBank<FPRInfo> m_fprs;
3094
3095     Vector<MacroAssembler::Label> m_osrEntryHeads;
3096     
3097     struct BranchRecord {
3098         BranchRecord(MacroAssembler::Jump jump, BasicBlock* destination)
3099             : jump(jump)
3100             , destination(destination)
3101         {
3102         }
3103
3104         MacroAssembler::Jump jump;
3105         BasicBlock* destination;
3106     };
3107     Vector<BranchRecord, 8> m_branches;
3108
3109     NodeOrigin m_origin;
3110     
3111     InPlaceAbstractState m_state;
3112     AbstractInterpreter<InPlaceAbstractState> m_interpreter;
3113     
3114     VariableEventStream* m_stream;
3115     MinifiedGraph* m_minifiedGraph;
3116     
3117     Vector<std::unique_ptr<SlowPathGenerator>, 8> m_slowPathGenerators;
3118     struct SlowPathLambda {
3119         std::function<void()> generator;
3120         Node* currentNode;
3121         unsigned streamIndex;
3122     };
3123     Vector<SlowPathLambda> m_slowPathLambdas;
3124     Vector<SilentRegisterSavePlan> m_plans;
3125     std::optional<unsigned> m_outOfLineStreamIndex;
3126 };
3127
3128
3129 // === Operand types ===
3130 //
3131 // These classes are used to lock the operands to a node into machine
3132 // registers. These classes implement of pattern of locking a value
3133 // into register at the point of construction only if it is already in
3134 // registers, and otherwise loading it lazily at the point it is first
3135 // used. We do so in order to attempt to avoid spilling one operand
3136 // in order to make space available for another.
3137
3138 class JSValueOperand {
3139 public:
3140     explicit JSValueOperand(SpeculativeJIT* jit, Edge edge, OperandSpeculationMode mode = AutomaticOperandSpeculation)
3141         : m_jit(jit)
3142         , m_edge(edge)
3143 #if USE(JSVALUE64)
3144         , m_gprOrInvalid(InvalidGPRReg)
3145 #elif USE(JSVALUE32_64)
3146         , m_isDouble(false)
3147 #endif
3148     {
3149         ASSERT(m_jit);
3150         if (!edge)
3151             return;
3152         ASSERT_UNUSED(mode, mode == ManualOperandSpeculation || edge.useKind() == UntypedUse);
3153 #if USE(JSVALUE64)
3154         if (jit->isFilled(node()))
3155             gpr();
3156 #elif USE(JSVALUE32_64)
3157         m_register.pair.tagGPR = InvalidGPRReg;
3158         m_register.pair.payloadGPR = InvalidGPRReg;
3159         if (jit->isFilled(node()))
3160             fill();
3161 #endif
3162     }
3163
3164     explicit JSValueOperand(JSValueOperand&& other)
3165         : m_jit(other.m_jit)
3166         , m_edge(other.m_edge)
3167     {
3168 #if USE(JSVALUE64)
3169         m_gprOrInvalid = other.m_gprOrInvalid;
3170 #elif USE(JSVALUE32_64)
3171         m_register.pair.tagGPR = InvalidGPRReg;
3172         m_register.pair.payloadGPR = InvalidGPRReg;
3173         m_isDouble = other.m_isDouble;
3174
3175         if (m_edge) {
3176             if (m_isDouble)
3177                 m_register.fpr = other.m_register.fpr;
3178             else
3179                 m_register.pair = other.m_register.pair;
3180         }
3181 #endif
3182         other.m_edge = Edge();
3183 #if USE(JSVALUE64)
3184         other.m_gprOrInvalid = InvalidGPRReg;
3185 #elif USE(JSVALUE32_64)
3186         other.m_isDouble = false;
3187 #endif
3188     }
3189
3190     ~JSValueOperand()
3191     {
3192         if (!m_edge)
3193             return;
3194 #if USE(JSVALUE64)
3195         ASSERT(m_gprOrInvalid != InvalidGPRReg);
3196         m_jit->unlock(m_gprOrInvalid);
3197 #elif USE(JSVALUE32_64)
3198         if (m_isDouble) {
3199             ASSERT(m_register.fpr != InvalidFPRReg);
3200             m_jit->unlock(m_register.fpr);
3201         } else {
3202             ASSERT(m_register.pair.tagGPR != InvalidGPRReg && m_register.pair.payloadGPR != InvalidGPRReg);
3203             m_jit->unlock(m_register.pair.tagGPR);
3204             m_jit->unlock(m_register.pair.payloadGPR);
3205         }
3206 #endif
3207     }
3208     
3209     Edge edge() const
3210     {
3211         return m_edge;
3212     }
3213
3214     Node* node() const
3215     {
3216         return edge().node();
3217     }
3218
3219 #if USE(JSVALUE64)
3220     GPRReg gpr()
3221     {
3222         if (m_gprOrInvalid == InvalidGPRReg)
3223             m_gprOrInvalid = m_jit->fillJSValue(m_edge);
3224         return m_gprOrInvalid;
3225     }
3226     JSValueRegs jsValueRegs()
3227     {
3228         return JSValueRegs(gpr());
3229     }
3230 #elif USE(JSVALUE32_64)
3231     bool isDouble() { return m_isDouble; }
3232
3233     void fill()
3234     {
3235         if (m_register.pair.tagGPR == InvalidGPRReg && m_register.pair.payloadGPR == InvalidGPRReg)
3236             m_isDouble = !m_jit->fillJSValue(m_edge, m_register.pair.tagGPR, m_register.pair.payloadGPR, m_register.fpr);
3237     }
3238
3239     GPRReg tagGPR()
3240     {
3241         fill();
3242         ASSERT(!m_isDouble);
3243         return m_register.pair.tagGPR;
3244     } 
3245
3246     GPRReg payloadGPR()
3247     {
3248         fill();
3249         ASSERT(!m_isDouble);
3250         return m_register.pair.payloadGPR;
3251     }
3252     
3253     JSValueRegs jsValueRegs()
3254     {
3255         return JSValueRegs(tagGPR(), payloadGPR());
3256     }
3257
3258     GPRReg gpr(WhichValueWord which)
3259     {
3260         return jsValueRegs().gpr(which);
3261     }
3262
3263     FPRReg fpr()
3264     {
3265         fill();
3266         ASSERT(m_isDouble);
3267         return m_register.fpr;
3268     }
3269 #endif
3270
3271     void use()
3272     {
3273         m_jit->use(node());
3274     }
3275
3276 private:
3277     SpeculativeJIT* m_jit;
3278     Edge m_edge;
3279 #if USE(JSVALUE64)
3280     GPRReg m_gprOrInvalid;
3281 #elif USE(JSVALUE32_64)
3282     union {
3283         struct {
3284             GPRReg tagGPR;
3285             GPRReg payloadGPR;
3286         } pair;
3287         FPRReg fpr;
3288     } m_register;
3289     bool m_isDouble;
3290 #endif
3291 };
3292
3293 class StorageOperand {
3294 public:
3295     explicit StorageOperand(SpeculativeJIT* jit, Edge edge)
3296         : m_jit(jit)
3297         , m_edge(edge)
3298         , m_gprOrInvalid(InvalidGPRReg)
3299     {
3300         ASSERT(m_jit);
3301         ASSERT(edge.useKind() == UntypedUse || edge.useKind() == KnownCellUse);
3302         if (jit->isFilled(node()))
3303             gpr();
3304     }
3305     
3306     ~StorageOperand()
3307     {
3308         ASSERT(m_gprOrInvalid != InvalidGPRReg);
3309         m_jit->unlock(m_gprOrInvalid);
3310     }
3311     
3312     Edge edge() const
3313     {
3314         return m_edge;
3315     }
3316     
3317     Node* node() const
3318     {
3319         return edge().node();
3320     }
3321     
3322     GPRReg gpr()
3323     {
3324         if (m_gprOrInvalid == InvalidGPRReg)
3325             m_gprOrInvalid = m_jit->fillStorage(edge());
3326         return m_gprOrInvalid;
3327     }
3328     
3329     void use()
3330     {
3331         m_jit->use(node());
3332     }
3333     
3334 private:
3335     SpeculativeJIT* m_jit;
3336     Edge m_edge;
3337     GPRReg m_gprOrInvalid;
3338 };
3339
3340
3341 // === Temporaries ===
3342 //
3343 // These classes are used to allocate temporary registers.
3344 // A mechanism is provided to attempt to reuse the registers
3345 // currently allocated to child nodes whose value is consumed
3346 // by, and not live after, this operation.
3347
3348 enum ReuseTag { Reuse };
3349
3350 class GPRTemporary {
3351 public:
3352     GPRTemporary();
3353     GPRTemporary(SpeculativeJIT*);
3354     GPRTemporary(SpeculativeJIT*, GPRReg specific);
3355     template<typename T>
3356     GPRTemporary(SpeculativeJIT* jit, ReuseTag, T& operand)
3357         : m_jit(jit)
3358         , m_gpr(InvalidGPRReg)
3359     {
3360         if (m_jit->canReuse(operand.node()))
3361             m_gpr = m_jit->reuse(operand.gpr());
3362         else
3363             m_gpr = m_jit->allocate();
3364     }
3365     template<typename T1, typename T2>
3366     GPRTemporary(SpeculativeJIT* jit, ReuseTag, T1& op1, T2& op2)
3367         : m_jit(jit)
3368         , m_gpr(InvalidGPRReg)
3369     {
3370         if (m_jit->canReuse(op1.node()))
3371             m_gpr = m_jit->reuse(op1.gpr());
3372         else if (m_jit->canReuse(op2.node()))
3373             m_gpr = m_jit->reuse(op2.gpr());
3374         else if (m_jit->canReuse(op1.node(), op2.node()) && op1.gpr() == op2.gpr())
3375             m_gpr = m_jit->reuse(op1.gpr());
3376         else
3377             m_gpr = m_jit->allocate();
3378     }
3379 #if USE(JSVALUE32_64)
3380     GPRTemporary(SpeculativeJIT*, ReuseTag, JSValueOperand&, WhichValueWord);
3381 #endif
3382
3383     GPRTemporary(GPRTemporary& other) = delete;
3384
3385     GPRTemporary(GPRTemporary&& other)
3386     {
3387         ASSERT(other.m_jit);
3388         ASSERT(other.m_gpr != InvalidGPRReg);
3389         m_jit = other.m_jit;
3390         m_gpr = other.m_gpr;
3391         other.m_jit = nullptr;
3392         other.m_gpr = InvalidGPRReg;
3393     }
3394
3395     GPRTemporary& operator=(GPRTemporary&& other)
3396     {
3397         ASSERT(!m_jit);
3398         ASSERT(m_gpr == InvalidGPRReg);
3399         std::swap(m_jit, other.m_jit);
3400         std::swap(m_gpr, other.m_gpr);
3401         return *this;
3402     }
3403
3404     void adopt(GPRTemporary&);
3405
3406     ~GPRTemporary()
3407     {
3408         if (m_jit && m_gpr != InvalidGPRReg)
3409             m_jit->unlock(gpr());
3410     }
3411
3412     GPRReg gpr()
3413     {
3414         return m_gpr;
3415     }
3416
3417 private:
3418     SpeculativeJIT* m_jit;
3419     GPRReg m_gpr;
3420 };
3421
3422 class JSValueRegsTemporary {
3423 public:
3424     JSValueRegsTemporary();
3425     JSValueRegsTemporary(SpeculativeJIT*);
3426     template<typename T>
3427     JSValueRegsTemporary(SpeculativeJIT*, ReuseTag, T& operand, WhichValueWord resultRegWord = PayloadWord);
3428     JSValueRegsTemporary(SpeculativeJIT*, ReuseTag, JSValueOperand&);
3429     ~JSValueRegsTemporary();
3430     
3431     JSValueRegs regs();
3432
3433 private:
3434 #if USE(JSVALUE64)
3435     GPRTemporary m_gpr;
3436 #else
3437     GPRTemporary m_payloadGPR;
3438     GPRTemporary m_tagGPR;
3439 #endif
3440 };
3441
3442 class FPRTemporary {
3443     WTF_MAKE_NONCOPYABLE(FPRTemporary);
3444 public:
3445     FPRTemporary(FPRTemporary&&);
3446     FPRTemporary(SpeculativeJIT*);
3447     FPRTemporary(SpeculativeJIT*, SpeculateDoubleOperand&);
3448     FPRTemporary(SpeculativeJIT*, SpeculateDoubleOperand&, SpeculateDoubleOperand&);
3449 #if USE(JSVALUE32_64)
3450     FPRTemporary(SpeculativeJIT*, JSValueOperand&);
3451 #endif
3452
3453     ~FPRTemporary()
3454     {
3455         if (LIKELY(m_jit))
3456             m_jit->unlock(fpr());
3457     }
3458
3459     FPRReg fpr() const
3460     {
3461         ASSERT(m_jit);
3462         ASSERT(m_fpr != InvalidFPRReg);
3463         return m_fpr;
3464     }
3465
3466 protected:
3467     FPRTemporary(SpeculativeJIT* jit, FPRReg lockedFPR)
3468         : m_jit(jit)
3469         , m_fpr(lockedFPR)
3470     {
3471     }
3472
3473 private:
3474     SpeculativeJIT* m_jit;
3475     FPRReg m_fpr;
3476 };
3477
3478
3479 // === Results ===
3480 //
3481 // These classes lock the result of a call to a C++ helper function.
3482
3483 class GPRFlushedCallResult : public GPRTemporary {
3484 public:
3485     GPRFlushedCallResult(SpeculativeJIT* jit)
3486         : GPRTemporary(jit, GPRInfo::returnValueGPR)
3487     {
3488     }
3489 };
3490
3491 #if USE(JSVALUE32_64)
3492 class GPRFlushedCallResult2 : public GPRTemporary {
3493 public:
3494     GPRFlushedCallResult2(SpeculativeJIT* jit)
3495         : GPRTemporary(jit, GPRInfo::returnValueGPR2)
3496     {
3497     }
3498 };
3499 #endif
3500
3501 class FPRResult : public FPRTemporary {
3502 public:
3503     FPRResult(SpeculativeJIT* jit)
3504         : FPRTemporary(jit, lockedResult(jit))
3505     {
3506     }
3507
3508 private:
3509     static FPRReg lockedResult(SpeculativeJIT* jit)
3510     {
3511         jit->lock(FPRInfo::returnValueFPR);
3512         return FPRInfo::returnValueFPR;
3513     }
3514 };
3515
3516
3517 // === Speculative Operand types ===
3518 //
3519 // SpeculateInt32Operand, SpeculateStrictInt32Operand and SpeculateCellOperand.
3520 //
3521 // These are used to lock the operands to a node into machine registers within the
3522 // SpeculativeJIT. The classes operate like those above, however these will
3523 // perform a speculative check for a more restrictive type than we can statically
3524 // determine the operand to have. If the operand does not have the requested type,
3525 // a bail-out to the non-speculative path will be taken.
3526
3527 class SpeculateInt32Operand {
3528 public:
3529     explicit SpeculateInt32Operand(SpeculativeJIT* jit, Edge edge, OperandSpeculationMode mode = AutomaticOperandSpeculation)
3530         : m_jit(jit)
3531         , m_edge(edge)
3532         , m_gprOrInvalid(InvalidGPRReg)
3533 #ifndef NDEBUG
3534         , m_format(DataFormatNone)
3535 #endif
3536     {
3537         ASSERT(m_jit);
3538         ASSERT_UNUSED(mode, mode == ManualOperandSpeculation || (edge.useKind() == Int32Use || edge.useKind() == KnownInt32Use));
3539         if (jit->isFilled(node()))
3540             gpr();
3541     }
3542
3543     ~SpeculateInt32Operand()
3544     {
3545         ASSERT(m_gprOrInvalid != InvalidGPRReg);
3546         m_jit->unlock(m_gprOrInvalid);
3547     }
3548     
3549     Edge edge() const
3550     {
3551         return m_edge;
3552     }
3553
3554     Node* node() const
3555     {
3556         return edge().node();
3557     }
3558
3559     DataFormat format()
3560     {
3561         gpr(); // m_format is set when m_gpr is locked.
3562         ASSERT(m_format == DataFormatInt32 || m_format == DataFormatJSInt32);
3563         return m_format;
3564     }
3565
3566     GPRReg gpr()
3567     {
3568         if (m_gprOrInvalid == InvalidGPRReg)
3569             m_gprOrInvalid = m_jit->fillSpeculateInt32(edge(), m_format);
3570         return m_gprOrInvalid;
3571     }
3572     
3573     void use()
3574     {
3575         m_jit->use(node());
3576     }
3577
3578 private:
3579     SpeculativeJIT* m_jit;
3580     Edge m_edge;
3581     GPRReg m_gprOrInvalid;
3582     DataFormat m_format;
3583 };
3584
3585 class SpeculateStrictInt32Operand {
3586 public:
3587     explicit SpeculateStrictInt32Operand(SpeculativeJIT* jit, Edge edge, OperandSpeculationMode mode = AutomaticOperandSpeculation)
3588         : m_jit(jit)
3589         , m_edge(edge)
3590         , m_gprOrInvalid(InvalidGPRReg)
3591     {
3592         ASSERT(m_jit);
3593         ASSERT_UNUSED(mode, mode == ManualOperandSpeculation || (edge.useKind() == Int32Use || edge.useKind() == KnownInt32Use));
3594         if (jit->isFilled(node()))
3595             gpr();
3596     }
3597
3598     ~SpeculateStrictInt32Operand()
3599     {
3600         ASSERT(m_gprOrInvalid != InvalidGPRReg);
3601         m_jit->unlock(m_gprOrInvalid);
3602     }
3603     
3604     Edge edge() const
3605     {
3606         return m_edge;
3607     }
3608
3609     Node* node() const
3610     {
3611         return edge().node();
3612     }
3613
3614     GPRReg gpr()
3615     {
3616         if (m_gprOrInvalid == InvalidGPRReg)
3617             m_gprOrInvalid = m_jit->fillSpeculateInt32Strict(edge());
3618         return m_gprOrInvalid;
3619     }
3620     
3621     void use()
3622     {
3623         m_jit->use(node());
3624     }
3625
3626 private:
3627     SpeculativeJIT* m_jit;
3628     Edge m_edge;
3629     GPRReg m_gprOrInvalid;
3630 };
3631
3632 // Gives you a canonical Int52 (i.e. it's left-shifted by 16, low bits zero).
3633 class SpeculateInt52Operand {
3634 public:
3635     explicit SpeculateInt52Operand(SpeculativeJIT* jit, Edge edge)
3636         : m_jit(jit)
3637         , m_edge(edge)
3638         , m_gprOrInvalid(InvalidGPRReg)
3639     {
3640         RELEASE_ASSERT(edge.useKind() == Int52RepUse);
3641         if (jit->isFilled(node()))
3642             gpr();
3643     }
3644     
3645     ~SpeculateInt52Operand()
3646     {
3647         ASSERT(m_gprOrInvalid != InvalidGPRReg);
3648         m_jit->unlock(m_gprOrInvalid);
3649     }
3650     
3651     Edge edge() const
3652     {
3653         return m_edge;
3654     }
3655     
3656     Node* node() const
3657     {
3658         return edge().node();
3659     }
3660     
3661     GPRReg gpr()
3662     {
3663         if (m_gprOrInvalid == InvalidGPRReg)
3664             m_gprOrInvalid = m_jit->fillSpeculateInt52(edge(), DataFormatInt52);
3665         return m_gprOrInvalid;
3666     }
3667     
3668     void use()
3669     {
3670         m_jit->use(node());
3671     }
3672     
3673 private:
3674     SpeculativeJIT* m_jit;
3675     Edge m_edge;
3676     GPRReg m_gprOrInvalid;
3677 };
3678
3679 // Gives you a strict Int52 (i.e. the payload is in the low 48 bits, high 16 bits are sign-extended).
3680 class SpeculateStrictInt52Operand {
3681 public:
3682     explicit SpeculateStrictInt52Operand(SpeculativeJIT* jit, Edge edge)
3683         : m_jit(jit)
3684         , m_edge(edge)
3685         , m_gprOrInvalid(InvalidGPRReg)
3686     {
3687         RELEASE_ASSERT(edge.useKind() == Int52RepUse);
3688         if (jit->isFilled(node()))
3689             gpr();
3690     }
3691     
3692     ~SpeculateStrictInt52Operand()
3693     {
3694         ASSERT(m_gprOrInvalid != InvalidGPRReg);
3695         m_jit->unlock(m_gprOrInvalid);
3696     }
3697     
3698     Edge edge() const
3699     {
3700         return m_edge;
3701     }
3702     
3703     Node* node() const
3704     {
3705         return edge().node();
3706     }
3707     
3708     GPRReg gpr()
3709     {
3710         if (m_gprOrInvalid == InvalidGPRReg)
3711             m_gprOrInvalid = m_jit->fillSpeculateInt52(edge(), DataFormatStrictInt52);
3712         return m_gprOrInvalid;
3713     }
3714     
3715     void use()
3716     {
3717         m_jit->use(node());
3718     }
3719     
3720 private:
3721     SpeculativeJIT* m_jit;
3722     Edge m_edge;
3723     GPRReg m_gprOrInvalid;
3724 };
3725
3726 enum OppositeShiftTag { OppositeShift };
3727
3728 class SpeculateWhicheverInt52Operand {
3729 public:
3730     explicit SpeculateWhicheverInt52Operand(SpeculativeJIT* jit, Edge edge)
3731         : m_jit(jit)
3732         , m_edge(edge)
3733         , m_gprOrInvalid(InvalidGPRReg)
3734         , m_strict(jit->betterUseStrictInt52(edge))
3735     {
3736         RELEASE_ASSERT(edge.useKind() == Int52RepUse);
3737         if (jit->isFilled(node()))
3738             gpr();
3739     }
3740     
3741     explicit SpeculateWhicheverInt52Operand(SpeculativeJIT* jit, Edge edge, const SpeculateWhicheverInt52Operand& other)
3742         : m_jit(jit)
3743         , m_edge(edge)
3744         , m_gprOrInvalid(InvalidGPRReg)
3745         , m_strict(other.m_strict)
3746     {
3747         RELEASE_ASSERT(edge.useKind() == Int52RepUse);
3748         if (jit->isFilled(node()))
3749             gpr();
3750     }
3751     
3752     explicit SpeculateWhicheverInt52Operand(SpeculativeJIT* jit, Edge edge, OppositeShiftTag, const SpeculateWhicheverInt52Operand& other)
3753         : m_jit(jit)
3754         , m_edge(edge)
3755         , m_gprOrInvalid(InvalidGPRReg)
3756         , m_strict(!other.m_strict)
3757     {
3758         RELEASE_ASSERT(edge.useKind() == Int52RepUse);
3759         if (jit->isFilled(node()))
3760             gpr();
3761     }
3762     
3763     ~SpeculateWhicheverInt52Operand()
3764     {
3765         ASSERT(m_gprOrInvalid != InvalidGPRReg);
3766         m_jit->unlock(m_gprOrInvalid);
3767     }
3768     
3769     Edge edge() const
3770     {
3771         return m_edge;
3772     }
3773     
3774     Node* node() const
3775     {
3776         return edge().node();
3777     }
3778     
3779     GPRReg gpr()
3780     {
3781         if (m_gprOrInvalid == InvalidGPRReg) {
3782             m_gprOrInvalid = m_jit->fillSpeculateInt52(
3783                 edge(), m_strict ? DataFormatStrictInt52 : DataFormatInt52);
3784         }
3785         return m_gprOrInvalid;
3786     }
3787     
3788     void use()
3789     {
3790         m_jit->use(node());
3791     }
3792     
3793     DataFormat format() const
3794     {
3795         return m_strict ? DataFormatStrictInt52 : DataFormatInt52;
3796     }
3797
3798 private:
3799     SpeculativeJIT* m_jit;
3800     Edge m_edge;
3801     GPRReg m_gprOrInvalid;
3802     bool m_strict;
3803 };
3804
3805 class SpeculateDoubleOperand {
3806 public:
3807     explicit SpeculateDoubleOperand(SpeculativeJIT* jit, Edge edge)
3808         : m_jit(jit)
3809         , m_edge(edge)
3810         , m_fprOrInvalid(InvalidFPRReg)
3811     {
3812         ASSERT(m_jit);
3813         RELEASE_ASSERT(isDouble(edge.useKind()));
3814         if (jit->isFilled(node()))
3815             fpr();
3816     }
3817
3818     ~SpeculateDoubleOperand()
3819     {
3820         ASSERT(m_fprOrInvalid != InvalidFPRReg);
3821         m_jit->unlock(m_fprOrInvalid);
3822     }
3823     
3824     Edge edge() const
3825     {
3826         return m_edge;
3827     }
3828
3829     Node* node() const
3830     {
3831         return edge().node();
3832     }
3833
3834     FPRReg fpr()
3835     {
3836         if (m_fprOrInvalid == InvalidFPRReg)
3837             m_fprOrInvalid = m_jit->fillSpeculateDouble(edge());
3838         return m_fprOrInvalid;
3839     }
3840     
3841     void use()
3842     {
3843         m_jit->use(node());
3844     }
3845
3846 private:
3847     SpeculativeJIT* m_jit;
3848     Edge m_edge;
3849     FPRReg m_fprOrInvalid;
3850 };
3851
3852 class SpeculateCellOperand {
3853     WTF_MAKE_NONCOPYABLE(SpeculateCellOperand);
3854
3855 public:
3856     explicit SpeculateCellOperand(SpeculativeJIT* jit, Edge edge, OperandSpeculationMode mode = AutomaticOperandSpeculation)
3857         : m_jit(jit)
3858         , m_edge(edge)
3859         , m_gprOrInvalid(InvalidGPRReg)
3860     {
3861         ASSERT(m_jit);
3862         if (!edge)
3863             return;
3864         ASSERT_UNUSED(mode, mode == ManualOperandSpeculation || isCell(edge.useKind()));