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