45d92d22640fdd167ead06265363f0dc91c164ea
[WebKit.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*>(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 compileMovHint(Node*);
766     void compileMovHintAndCheck(Node*);
767
768     void cachedGetById(CodeOrigin, JSValueRegs base, JSValueRegs result, unsigned identifierNumber, JITCompiler::Jump slowPathTarget = JITCompiler::Jump(), SpillRegistersMode = NeedToSpill, AccessType = AccessType::Get);
769
770 #if USE(JSVALUE64)
771     void cachedGetById(CodeOrigin, GPRReg baseGPR, GPRReg resultGPR, unsigned identifierNumber, JITCompiler::Jump slowPathTarget = JITCompiler::Jump(), SpillRegistersMode = NeedToSpill, AccessType = AccessType::Get);
772     void cachedPutById(CodeOrigin, GPRReg base, GPRReg value, GPRReg scratchGPR, unsigned identifierNumber, PutKind, JITCompiler::Jump slowPathTarget = JITCompiler::Jump(), SpillRegistersMode = NeedToSpill);
773 #elif USE(JSVALUE32_64)
774     void cachedGetById(CodeOrigin, GPRReg baseTagGPROrNone, GPRReg basePayloadGPR, GPRReg resultTagGPR, GPRReg resultPayloadGPR, unsigned identifierNumber, JITCompiler::Jump slowPathTarget = JITCompiler::Jump(), SpillRegistersMode = NeedToSpill, AccessType = AccessType::Get);
775     void cachedPutById(CodeOrigin, GPRReg basePayloadGPR, GPRReg valueTagGPR, GPRReg valuePayloadGPR, GPRReg scratchGPR, unsigned identifierNumber, PutKind, JITCompiler::Jump slowPathTarget = JITCompiler::Jump(), SpillRegistersMode = NeedToSpill);
776 #endif
777
778     void compileDeleteById(Node*);
779     void compileDeleteByVal(Node*);
780     void compileTryGetById(Node*);
781     void compileIn(Node*);
782     
783     void nonSpeculativeNonPeepholeCompareNullOrUndefined(Edge operand);
784     void nonSpeculativePeepholeBranchNullOrUndefined(Edge operand, Node* branchNode);
785     
786     void nonSpeculativePeepholeBranch(Node*, Node* branchNode, MacroAssembler::RelationalCondition, S_JITOperation_EJJ helperFunction);
787     void nonSpeculativeNonPeepholeCompare(Node*, MacroAssembler::RelationalCondition, S_JITOperation_EJJ helperFunction);
788     bool nonSpeculativeCompare(Node*, MacroAssembler::RelationalCondition, S_JITOperation_EJJ helperFunction);
789     
790     void nonSpeculativePeepholeStrictEq(Node*, Node* branchNode, bool invert = false);
791     void nonSpeculativeNonPeepholeStrictEq(Node*, bool invert = false);
792     bool nonSpeculativeStrictEq(Node*, bool invert = false);
793     
794     void compileInstanceOfForObject(Node*, GPRReg valueReg, GPRReg prototypeReg, GPRReg scratchAndResultReg, GPRReg scratch2Reg);
795     void compileInstanceOf(Node*);
796     void compileInstanceOfCustom(Node*);
797
798     void compileIsCellWithType(Node*);
799     void compileIsTypedArrayView(Node*);
800
801     void emitCall(Node*);
802
803     void emitAllocateButterfly(GPRReg storageGPR, GPRReg sizeGPR, GPRReg scratch1, GPRReg scratch2, GPRReg scratch3, MacroAssembler::JumpList& slowCases);
804     void emitInitializeButterfly(GPRReg storageGPR, GPRReg sizeGPR, JSValueRegs emptyValueRegs, GPRReg scratchGPR);
805     void compileAllocateNewArrayWithSize(JSGlobalObject*, GPRReg resultGPR, GPRReg sizeGPR, IndexingType, bool shouldConvertLargeSizeToArrayStorage = true);
806     
807     // Called once a node has completed code generation but prior to setting
808     // its result, to free up its children. (This must happen prior to setting
809     // the nodes result, since the node may have the same VirtualRegister as
810     // a child, and as such will use the same GeneratioInfo).
811     void useChildren(Node*);
812
813     // These method called to initialize the the GenerationInfo
814     // to describe the result of an operation.
815     void int32Result(GPRReg reg, Node* node, DataFormat format = DataFormatInt32, UseChildrenMode mode = CallUseChildren)
816     {
817         if (mode == CallUseChildren)
818             useChildren(node);
819
820         VirtualRegister virtualRegister = node->virtualRegister();
821         GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
822
823         if (format == DataFormatInt32) {
824             m_jit.jitAssertIsInt32(reg);
825             m_gprs.retain(reg, virtualRegister, SpillOrderInteger);
826             info.initInt32(node, node->refCount(), reg);
827         } else {
828 #if USE(JSVALUE64)
829             RELEASE_ASSERT(format == DataFormatJSInt32);
830             m_jit.jitAssertIsJSInt32(reg);
831             m_gprs.retain(reg, virtualRegister, SpillOrderJS);
832             info.initJSValue(node, node->refCount(), reg, format);
833 #elif USE(JSVALUE32_64)
834             RELEASE_ASSERT_NOT_REACHED();
835 #endif
836         }
837     }
838     void int32Result(GPRReg reg, Node* node, UseChildrenMode mode)
839     {
840         int32Result(reg, node, DataFormatInt32, mode);
841     }
842     void int52Result(GPRReg reg, Node* node, DataFormat format, UseChildrenMode mode = CallUseChildren)
843     {
844         if (mode == CallUseChildren)
845             useChildren(node);
846
847         VirtualRegister virtualRegister = node->virtualRegister();
848         GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
849
850         m_gprs.retain(reg, virtualRegister, SpillOrderJS);
851         info.initInt52(node, node->refCount(), reg, format);
852     }
853     void int52Result(GPRReg reg, Node* node, UseChildrenMode mode = CallUseChildren)
854     {
855         int52Result(reg, node, DataFormatInt52, mode);
856     }
857     void strictInt52Result(GPRReg reg, Node* node, UseChildrenMode mode = CallUseChildren)
858     {
859         int52Result(reg, node, DataFormatStrictInt52, mode);
860     }
861     void noResult(Node* node, UseChildrenMode mode = CallUseChildren)
862     {
863         if (mode == UseChildrenCalledExplicitly)
864             return;
865         useChildren(node);
866     }
867     void cellResult(GPRReg reg, Node* node, UseChildrenMode mode = CallUseChildren)
868     {
869         if (mode == CallUseChildren)
870             useChildren(node);
871
872         VirtualRegister virtualRegister = node->virtualRegister();
873         m_gprs.retain(reg, virtualRegister, SpillOrderCell);
874         GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
875         info.initCell(node, node->refCount(), reg);
876     }
877     void blessedBooleanResult(GPRReg reg, Node* node, UseChildrenMode mode = CallUseChildren)
878     {
879 #if USE(JSVALUE64)
880         jsValueResult(reg, node, DataFormatJSBoolean, mode);
881 #else
882         booleanResult(reg, node, mode);
883 #endif
884     }
885     void unblessedBooleanResult(GPRReg reg, Node* node, UseChildrenMode mode = CallUseChildren)
886     {
887 #if USE(JSVALUE64)
888         blessBoolean(reg);
889 #endif
890         blessedBooleanResult(reg, node, mode);
891     }
892 #if USE(JSVALUE64)
893     void jsValueResult(GPRReg reg, Node* node, DataFormat format = DataFormatJS, UseChildrenMode mode = CallUseChildren)
894     {
895         if (format == DataFormatJSInt32)
896             m_jit.jitAssertIsJSInt32(reg);
897         
898         if (mode == CallUseChildren)
899             useChildren(node);
900
901         VirtualRegister virtualRegister = node->virtualRegister();
902         m_gprs.retain(reg, virtualRegister, SpillOrderJS);
903         GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
904         info.initJSValue(node, node->refCount(), reg, format);
905     }
906     void jsValueResult(GPRReg reg, Node* node, UseChildrenMode mode)
907     {
908         jsValueResult(reg, node, DataFormatJS, mode);
909     }
910 #elif USE(JSVALUE32_64)
911     void booleanResult(GPRReg reg, Node* node, UseChildrenMode mode = CallUseChildren)
912     {
913         if (mode == CallUseChildren)
914             useChildren(node);
915
916         VirtualRegister virtualRegister = node->virtualRegister();
917         m_gprs.retain(reg, virtualRegister, SpillOrderBoolean);
918         GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
919         info.initBoolean(node, node->refCount(), reg);
920     }
921     void jsValueResult(GPRReg tag, GPRReg payload, Node* node, DataFormat format = DataFormatJS, UseChildrenMode mode = CallUseChildren)
922     {
923         if (mode == CallUseChildren)
924             useChildren(node);
925
926         VirtualRegister virtualRegister = node->virtualRegister();
927         m_gprs.retain(tag, virtualRegister, SpillOrderJS);
928         m_gprs.retain(payload, virtualRegister, SpillOrderJS);
929         GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
930         info.initJSValue(node, node->refCount(), tag, payload, format);
931     }
932     void jsValueResult(GPRReg tag, GPRReg payload, Node* node, UseChildrenMode mode)
933     {
934         jsValueResult(tag, payload, node, DataFormatJS, mode);
935     }
936 #endif
937     void jsValueResult(JSValueRegs regs, Node* node, DataFormat format = DataFormatJS, UseChildrenMode mode = CallUseChildren)
938     {
939 #if USE(JSVALUE64)
940         jsValueResult(regs.gpr(), node, format, mode);
941 #else
942         jsValueResult(regs.tagGPR(), regs.payloadGPR(), node, format, mode);
943 #endif
944     }
945     void storageResult(GPRReg reg, Node* node, UseChildrenMode mode = CallUseChildren)
946     {
947         if (mode == CallUseChildren)
948             useChildren(node);
949         
950         VirtualRegister virtualRegister = node->virtualRegister();
951         m_gprs.retain(reg, virtualRegister, SpillOrderStorage);
952         GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
953         info.initStorage(node, node->refCount(), reg);
954     }
955     void doubleResult(FPRReg reg, Node* node, UseChildrenMode mode = CallUseChildren)
956     {
957         if (mode == CallUseChildren)
958             useChildren(node);
959
960         VirtualRegister virtualRegister = node->virtualRegister();
961         m_fprs.retain(reg, virtualRegister, SpillOrderDouble);
962         GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
963         info.initDouble(node, node->refCount(), reg);
964     }
965     void initConstantInfo(Node* node)
966     {
967         ASSERT(node->hasConstant());
968         generationInfo(node).initConstant(node, node->refCount());
969     }
970     
971     // These methods add calls to C++ helper functions.
972     // These methods are broadly value representation specific (i.e.
973     // deal with the fact that a JSValue may be passed in one or two
974     // machine registers, and delegate the calling convention specific
975     // decision as to how to fill the regsiters to setupArguments* methods.
976
977     JITCompiler::Call callOperation(V_JITOperation_E operation)
978     {
979         m_jit.setupArgumentsExecState();
980         return appendCall(operation);
981     }
982     JITCompiler::Call callOperation(P_JITOperation_E operation, GPRReg result)
983     {
984         m_jit.setupArgumentsExecState();
985         return appendCallSetResult(operation, result);
986     }
987     JITCompiler::Call callOperation(P_JITOperation_EC operation, GPRReg result, GPRReg cell)
988     {
989         m_jit.setupArgumentsWithExecState(cell);
990         return appendCallSetResult(operation, result);
991     }
992     JITCompiler::Call callOperation(Jss_JITOperation_EJssUi operation, GPRReg result, GPRReg arg1, GPRReg arg2)
993     {
994         m_jit.setupArgumentsWithExecState(arg1, arg2);
995         return appendCallSetResult(operation, result);
996     }
997     JITCompiler::Call callOperation(P_JITOperation_EO operation, GPRReg result, GPRReg object)
998     {
999         m_jit.setupArgumentsWithExecState(object);
1000         return appendCallSetResult(operation, result);
1001     }
1002     JITCompiler::Call callOperation(P_JITOperation_EOS operation, GPRReg result, GPRReg object, size_t size)
1003     {
1004         m_jit.setupArgumentsWithExecState(object, TrustedImmPtr(size));
1005         return appendCallSetResult(operation, result);
1006     }
1007     JITCompiler::Call callOperation(P_JITOperation_EOZ operation, GPRReg result, GPRReg object, int32_t size)
1008     {
1009         m_jit.setupArgumentsWithExecState(object, TrustedImmPtr(size));
1010         return appendCallSetResult(operation, result);
1011     }
1012     JITCompiler::Call callOperation(C_JITOperation_EOZ operation, GPRReg result, GPRReg object, int32_t size)
1013     {
1014         m_jit.setupArgumentsWithExecState(object, TrustedImmPtr(static_cast<size_t>(size)));
1015         return appendCallSetResult(operation, result);
1016     }
1017     JITCompiler::Call callOperation(P_JITOperation_EPS operation, GPRReg result, GPRReg old, size_t size)
1018     {
1019         m_jit.setupArgumentsWithExecState(old, TrustedImmPtr(size));
1020         return appendCallSetResult(operation, result);
1021     }
1022     JITCompiler::Call callOperation(C_JITOperation_EPUi operation, GPRReg result, void* arg1, uint32_t arg2)
1023     {
1024         m_jit.setupArgumentsWithExecState(TrustedImmPtr(arg1), TrustedImm32(arg2));
1025         return appendCallSetResult(operation, result);
1026     }
1027     JITCompiler::Call callOperation(P_JITOperation_ES operation, GPRReg result, size_t size)
1028     {
1029         m_jit.setupArgumentsWithExecState(TrustedImmPtr(size));
1030         return appendCallSetResult(operation, result);
1031     }
1032     JITCompiler::Call callOperation(P_JITOperation_ESJss operation, GPRReg result, size_t index, GPRReg arg1)
1033     {
1034         m_jit.setupArgumentsWithExecState(TrustedImmPtr(index), arg1);
1035         return appendCallSetResult(operation, result);
1036     }
1037     JITCompiler::Call callOperation(Z_JITOperation_EOI operation, GPRReg result, GPRReg obj, GPRReg impl)
1038     {
1039         m_jit.setupArgumentsWithExecState(obj, impl);
1040         return appendCallSetResult(operation, result);
1041     }
1042     JITCompiler::Call callOperation(P_JITOperation_ESt operation, GPRReg result, RegisteredStructure structure)
1043     {
1044         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure));
1045         return appendCallSetResult(operation, result);
1046     }
1047     JITCompiler::Call callOperation(P_JITOperation_EStZP operation, GPRReg result, RegisteredStructure structure, GPRReg arg2, GPRReg arg3)
1048     {
1049         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), arg2, arg3);
1050         return appendCallSetResult(operation, result);
1051     }
1052     JITCompiler::Call callOperation(P_JITOperation_EStZP operation, GPRReg result, RegisteredStructure structure, size_t arg2, GPRReg arg3)
1053     {
1054         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), TrustedImm32(arg2), arg3);
1055         return appendCallSetResult(operation, result);
1056     }
1057     JITCompiler::Call callOperation(P_JITOperation_EStZP operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1058     {
1059         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1060         return appendCallSetResult(operation, result);
1061     }
1062     JITCompiler::Call callOperation(P_JITOperation_EStZB operation, GPRReg result, RegisteredStructure structure, GPRReg arg2, GPRReg butterfly)
1063     {
1064         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), arg2, butterfly);
1065         return appendCallSetResult(operation, result);
1066     }
1067     JITCompiler::Call callOperation(P_JITOperation_EStZB operation, GPRReg result, RegisteredStructure structure, size_t arg2, GPRReg butterfly)
1068     {
1069         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), TrustedImm32(arg2), butterfly);
1070         return appendCallSetResult(operation, result);
1071     }
1072     JITCompiler::Call callOperation(P_JITOperation_EStZB operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg butterfly)
1073     {
1074         m_jit.setupArgumentsWithExecState(arg1, arg2, butterfly);
1075         return appendCallSetResult(operation, result);
1076     }
1077     JITCompiler::Call callOperation(P_JITOperation_EStZB operation, GPRReg result, GPRReg arg1, GPRReg arg2, Butterfly* butterfly)
1078     {
1079         m_jit.setupArgumentsWithExecState(arg1, arg2, TrustedImmPtr(butterfly));
1080         return appendCallSetResult(operation, result);
1081     }
1082     JITCompiler::Call callOperation(P_JITOperation_EStPS operation, GPRReg result, RegisteredStructure structure, void* pointer, size_t size)
1083     {
1084         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), TrustedImmPtr(pointer), TrustedImmPtr(size));
1085         return appendCallSetResult(operation, result);
1086     }
1087     JITCompiler::Call callOperation(P_JITOperation_EStSS operation, GPRReg result, RegisteredStructure structure, size_t index, size_t size)
1088     {
1089         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), TrustedImmPtr(index), TrustedImmPtr(size));
1090         return appendCallSetResult(operation, result);
1091     }
1092     JITCompiler::Call callOperation(C_JITOperation_E operation, GPRReg result)
1093     {
1094         m_jit.setupArgumentsExecState();
1095         return appendCallSetResult(operation, result);
1096     }
1097     JITCompiler::Call callOperation(C_JITOperation_EC operation, GPRReg result, GPRReg arg1)
1098     {
1099         m_jit.setupArgumentsWithExecState(arg1);
1100         return appendCallSetResult(operation, result);
1101     }
1102     JITCompiler::Call callOperation(C_JITOperation_EC operation, GPRReg result, JSCell* cell)
1103     {
1104         m_jit.setupArgumentsWithExecState(TrustedImmPtr::weakPointer(m_jit.graph(), cell));
1105         return appendCallSetResult(operation, result);
1106     }
1107     JITCompiler::Call callOperation(C_JITOperation_ECZ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1108     {
1109         m_jit.setupArgumentsWithExecState(arg1, arg2);
1110         return appendCallSetResult(operation, result);
1111     }
1112     JITCompiler::Call callOperation(C_JITOperation_ECZC operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1113     {
1114         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1115         return appendCallSetResult(operation, result);
1116     }
1117     JITCompiler::Call callOperation(C_JITOperation_EJscC operation, GPRReg result, GPRReg arg1, JSCell* cell)
1118     {
1119         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr::weakPointer(m_jit.graph(), cell));
1120         return appendCallSetResult(operation, result);
1121     }
1122     JITCompiler::Call callOperation(C_JITOperation_EIcf operation, GPRReg result, InlineCallFrame* inlineCallFrame)
1123     {
1124         m_jit.setupArgumentsWithExecState(TrustedImmPtr(inlineCallFrame));
1125         return appendCallSetResult(operation, result);
1126     }
1127     JITCompiler::Call callOperation(C_JITOperation_ESt operation, GPRReg result, RegisteredStructure structure)
1128     {
1129         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure));
1130         return appendCallSetResult(operation, result);
1131     }
1132
1133 #if USE(JSVALUE64)
1134     JITCompiler::Call callOperation(C_JITOperation_EStJscSymtabJ operation, GPRReg result, RegisteredStructure structure, GPRReg scope, SymbolTable* table, TrustedImm64 initialValue)
1135     {
1136         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), scope, TrustedImmPtr::weakPointer(m_jit.graph(), table), initialValue);
1137         return appendCallSetResult(operation, result);
1138     }
1139 #else
1140     JITCompiler::Call callOperation(C_JITOperation_EStJscSymtabJ operation, GPRReg result, RegisteredStructure structure, GPRReg scope, SymbolTable* table, TrustedImm32 tag, TrustedImm32 payload)
1141     {
1142         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), scope, TrustedImmPtr::weakPointer(m_jit.graph(), table), payload, tag);
1143         return appendCallSetResult(operation, result);
1144     }
1145 #endif
1146     JITCompiler::Call callOperation(C_JITOperation_EStZ operation, GPRReg result, RegisteredStructure structure, unsigned knownLength)
1147     {
1148         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), TrustedImm32(knownLength));
1149         return appendCallSetResult(operation, result);
1150     }
1151     JITCompiler::Call callOperation(C_JITOperation_EStZZ operation, GPRReg result, RegisteredStructure structure, unsigned knownLength, unsigned minCapacity)
1152     {
1153         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), TrustedImm32(knownLength), TrustedImm32(minCapacity));
1154         return appendCallSetResult(operation, result);
1155     }
1156     JITCompiler::Call callOperation(C_JITOperation_EStZ operation, GPRReg result, RegisteredStructure structure, GPRReg length)
1157     {
1158         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), length);
1159         return appendCallSetResult(operation, result);
1160     }
1161     JITCompiler::Call callOperation(C_JITOperation_EStZZ operation, GPRReg result, RegisteredStructure structure, GPRReg length, unsigned minCapacity)
1162     {
1163         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), length, TrustedImm32(minCapacity));
1164         return appendCallSetResult(operation, result);
1165     }
1166     JITCompiler::Call callOperation(C_JITOperation_EJssSt operation, GPRReg result, GPRReg arg1, RegisteredStructure structure)
1167     {
1168         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr(structure));
1169         return appendCallSetResult(operation, result);
1170     }
1171     JITCompiler::Call callOperation(C_JITOperation_EJssJss operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1172     {
1173         m_jit.setupArgumentsWithExecState(arg1, arg2);
1174         return appendCallSetResult(operation, result);
1175     }
1176     JITCompiler::Call callOperation(C_JITOperation_B_EJssJss operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1177     {
1178         m_jit.setupArgumentsWithExecState(arg1, arg2);
1179         return appendCallSetResult(operation, result);
1180     }
1181     JITCompiler::Call callOperation(C_JITOperation_TT operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1182     {
1183         m_jit.setupArguments(arg1, arg2);
1184         return appendCallSetResult(operation, result);
1185     }
1186     JITCompiler::Call callOperation(C_JITOperation_EJssJssJss operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1187     {
1188         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1189         return appendCallSetResult(operation, result);
1190     }
1191
1192     JITCompiler::Call callOperation(S_JITOperation_ECC operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1193     {
1194         m_jit.setupArgumentsWithExecState(arg1, arg2);
1195         return appendCallSetResult(operation, result);
1196     }
1197
1198     JITCompiler::Call callOperation(S_JITOperation_EGC operation, GPRReg result, JSGlobalObject* globalObject, GPRReg arg2)
1199     {
1200         m_jit.setupArgumentsWithExecState(TrustedImmPtr::weakPointer(m_jit.graph(), globalObject), arg2);
1201         return appendCallSetResult(operation, result);
1202     }
1203
1204     JITCompiler::Call callOperation(C_JITOperation_EGC operation, GPRReg result, JSGlobalObject* globalObject, GPRReg arg2)
1205     {
1206         m_jit.setupArgumentsWithExecState(TrustedImmPtr::weakPointer(m_jit.graph(), globalObject), arg2);
1207         return appendCallSetResult(operation, result);
1208     }
1209
1210     JITCompiler::Call callOperation(Jss_JITOperation_EZ operation, GPRReg result, GPRReg arg1)
1211     {
1212         m_jit.setupArgumentsWithExecState(arg1);
1213         return appendCallSetResult(operation, result);
1214     }
1215
1216     JITCompiler::Call callOperation(V_JITOperation_EC operation, GPRReg arg1)
1217     {
1218         m_jit.setupArgumentsWithExecState(arg1);
1219         return appendCall(operation);
1220     }
1221
1222     JITCompiler::Call callOperation(V_JITOperation_ECliJsf operation, CallLinkInfo* callLinkInfo, GPRReg arg1)
1223     {
1224         m_jit.setupArgumentsWithExecState(TrustedImmPtr(callLinkInfo), arg1);
1225         return appendCall(operation);
1226     }
1227
1228     JITCompiler::Call callOperation(V_JITOperation_EC operation, JSCell* arg1)
1229     {
1230         m_jit.setupArgumentsWithExecState(TrustedImmPtr::weakPointer(m_jit.graph(), arg1));
1231         return appendCall(operation);
1232     }
1233
1234     JITCompiler::Call callOperation(V_JITOperation_ECIcf operation, GPRReg arg1, InlineCallFrame* inlineCallFrame)
1235     {
1236         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr(inlineCallFrame));
1237         return appendCall(operation);
1238     }
1239     JITCompiler::Call callOperation(V_JITOperation_ECCIcf operation, GPRReg arg1, GPRReg arg2, InlineCallFrame* inlineCallFrame)
1240     {
1241         m_jit.setupArgumentsWithExecState(arg1, arg2, TrustedImmPtr(inlineCallFrame));
1242         return appendCall(operation);
1243     }
1244
1245     JITCompiler::Call callOperation(V_JITOperation_ECZ operation, GPRReg arg1, int arg2)
1246     {
1247         m_jit.setupArgumentsWithExecState(arg1, TrustedImm32(arg2));
1248         return appendCall(operation);
1249     }
1250     JITCompiler::Call callOperation(V_JITOperation_ECC operation, GPRReg arg1, GPRReg arg2)
1251     {
1252         m_jit.setupArgumentsWithExecState(arg1, arg2);
1253         return appendCall(operation);
1254     }
1255     JITCompiler::Call callOperation(V_JITOperation_ECC operation, GPRReg arg1, JSCell* arg2)
1256     {
1257         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr::weakPointer(m_jit.graph(), arg2));
1258         return appendCall(operation);
1259     }
1260     JITCompiler::Call callOperation(V_JITOperation_ECC operation, JSCell* arg1, GPRReg arg2)
1261     {
1262         m_jit.setupArgumentsWithExecState(TrustedImmPtr::weakPointer(m_jit.graph(), arg1), arg2);
1263         return appendCall(operation);
1264     }
1265
1266     JITCompiler::Call callOperationWithCallFrameRollbackOnException(V_JITOperation_ECb operation, void* pointer)
1267     {
1268         m_jit.setupArgumentsWithExecState(TrustedImmPtr(pointer));
1269         return appendCallWithCallFrameRollbackOnException(operation);
1270     }
1271
1272     JITCompiler::Call callOperationWithCallFrameRollbackOnException(Z_JITOperation_E operation, GPRReg result)
1273     {
1274         m_jit.setupArgumentsExecState();
1275         return appendCallWithCallFrameRollbackOnExceptionSetResult(operation, result);
1276     }
1277     JITCompiler::Call callOperation(Z_JITOperation_EC operation, GPRReg result, GPRReg arg1)
1278     {
1279         m_jit.setupArgumentsWithExecState(arg1);
1280         return appendCallSetResult(operation, result);
1281     }
1282
1283     JITCompiler::Call callOperation(V_JITOperation_ECIZC operation, GPRReg regOp1, UniquedStringImpl* identOp2, int32_t op3, GPRReg regOp4)
1284     {
1285         m_jit.setupArgumentsWithExecState(regOp1, TrustedImmPtr(identOp2), TrustedImm32(op3), regOp4);
1286         return appendCall(operation);
1287     }
1288
1289     template<typename FunctionType, typename... Args>
1290     JITCompiler::Call callOperation(FunctionType operation, NoResultTag, Args... args)
1291     {
1292         return callOperation(operation, args...);
1293     }
1294
1295     JITCompiler::Call callOperation(D_JITOperation_ZZ operation, FPRReg result, GPRReg arg1, GPRReg arg2)
1296     {
1297         m_jit.setupArguments(arg1, arg2);
1298         return appendCallSetResult(operation, result);
1299     }
1300     JITCompiler::Call callOperation(D_JITOperation_D operation, FPRReg result, FPRReg arg1)
1301     {
1302         m_jit.setupArguments(arg1);
1303         return appendCallSetResult(operation, result);
1304     }
1305     JITCompiler::Call callOperation(D_JITOperation_DD operation, FPRReg result, FPRReg arg1, FPRReg arg2)
1306     {
1307         m_jit.setupArguments(arg1, arg2);
1308         return appendCallSetResult(operation, result);
1309     }
1310     JITCompiler::Call callOperation(T_JITOperation_EJss operation, GPRReg result, GPRReg arg1)
1311     {
1312         m_jit.setupArgumentsWithExecState(arg1);
1313         return appendCallSetResult(operation, result);
1314     }
1315     JITCompiler::Call callOperation(C_JITOperation_EJscZ operation, GPRReg result, GPRReg arg1, int32_t arg2)
1316     {
1317         m_jit.setupArgumentsWithExecState(arg1, TrustedImm32(arg2));
1318         return appendCallSetResult(operation, result);
1319     }
1320     JITCompiler::Call callOperation(C_JITOperation_EZ operation, GPRReg result, GPRReg arg1)
1321     {
1322         m_jit.setupArgumentsWithExecState(arg1);
1323         return appendCallSetResult(operation, result);
1324     }
1325     JITCompiler::Call callOperation(C_JITOperation_EZ operation, GPRReg result, int32_t arg1)
1326     {
1327         m_jit.setupArgumentsWithExecState(TrustedImm32(arg1));
1328         return appendCallSetResult(operation, result);
1329     }
1330
1331     JITCompiler::Call callOperation(J_JITOperation_EJscC operation, GPRReg result, GPRReg arg1, JSCell* cell)
1332     {
1333         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr::weakPointer(m_jit.graph(), cell));
1334         return appendCallSetResult(operation, result);
1335     }
1336     
1337     JITCompiler::Call callOperation(J_JITOperation_EJscCJ operation, GPRReg result, GPRReg arg1, JSCell* cell, GPRReg arg2)
1338     {
1339         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr::weakPointer(m_jit.graph(), cell), arg2);
1340         return appendCallSetResult(operation, result);
1341     }
1342
1343     JITCompiler::Call callOperation(J_JITOperation_EGReoJ operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1344     {
1345         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1346         return appendCallSetResult(operation, result);
1347     }
1348
1349     JITCompiler::Call callOperation(J_JITOperation_EGReoJss operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1350     {
1351         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1352         return appendCallSetResult(operation, result);
1353     }
1354
1355     JITCompiler::Call callOperation(V_JITOperation_EWs operation, WatchpointSet* watchpointSet)
1356     {
1357         m_jit.setupArgumentsWithExecState(TrustedImmPtr(watchpointSet));
1358         return appendCall(operation);
1359     }
1360
1361     JITCompiler::Call callOperation(C_JITOperation_ERUiUi operation, GPRReg result, GPRReg arg1, Imm32 arg2, GPRReg arg3)
1362     {
1363         m_jit.setupArgumentsWithExecState(arg1, arg2.asTrustedImm32(), arg3);
1364         return appendCallSetResult(operation, result);
1365     }
1366
1367     JITCompiler::Call callOperation(C_JITOperation_EJscI operation, GPRReg result, GPRReg arg1, UniquedStringImpl* impl)
1368     {
1369         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr(impl));
1370         return appendCallSetResult(operation, result);
1371     }
1372
1373
1374 #if USE(JSVALUE64)
1375     JITCompiler::Call callOperation(Z_JITOperation_EOJ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1376     {
1377         m_jit.setupArgumentsWithExecState(arg1, arg2);
1378         return appendCallSetResult(operation, result);
1379     }
1380     JITCompiler::Call callOperation(C_JITOperation_ECJZ operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1381     {
1382         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1383         return appendCallSetResult(operation, result);
1384     }
1385     JITCompiler::Call callOperation(J_JITOperation_EJMic operation, JSValueRegs result, JSValueRegs arg, TrustedImmPtr mathIC)
1386     {
1387         m_jit.setupArgumentsWithExecState(arg.gpr(), mathIC);
1388         return appendCallSetResult(operation, result.gpr());
1389     }
1390     JITCompiler::Call callOperation(J_JITOperation_EJJMic operation, JSValueRegs result, JSValueRegs arg1, JSValueRegs arg2, TrustedImmPtr mathIC)
1391     {
1392         m_jit.setupArgumentsWithExecState(arg1.gpr(), arg2.gpr(), mathIC);
1393         return appendCallSetResult(operation, result.gpr());
1394     }
1395     JITCompiler::Call callOperation(J_JITOperation_EJJI operation, GPRReg result, GPRReg arg1, GPRReg arg2, UniquedStringImpl* uid)
1396     {
1397         m_jit.setupArgumentsWithExecState(arg1, arg2, TrustedImmPtr(uid));
1398         return appendCallSetResult(operation, result);
1399     }
1400     JITCompiler::Call callOperation(V_JITOperation_EJJJI operation, GPRReg arg1, GPRReg arg2, GPRReg arg3, UniquedStringImpl* uid)
1401     {
1402         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3, TrustedImmPtr(uid));
1403         return appendCall(operation);
1404     }
1405     JITCompiler::Call callOperation(V_JITOperation_EJJJJ operation, GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4)
1406     {
1407         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3, arg4);
1408         return appendCall(operation);
1409     }
1410     JITCompiler::Call callOperation(V_JITOperation_EOJJZ operation, GPRReg arg1, JSValueRegs arg2, JSValueRegs arg3, GPRReg arg4)
1411     {
1412         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg3.payloadGPR(), arg4);
1413         return appendCall(operation);
1414     }
1415     JITCompiler::Call callOperation(V_JITOperation_EOJssJZ operation, GPRReg arg1, GPRReg arg2, JSValueRegs arg3, GPRReg arg4)
1416     {
1417         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3.payloadGPR(), arg4);
1418         return appendCall(operation);
1419     }
1420     JITCompiler::Call callOperation(V_JITOperation_EOIJZ operation, GPRReg arg1, GPRReg arg2, JSValueRegs arg3, GPRReg arg4)
1421     {
1422         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3.payloadGPR(), arg4);
1423         return appendCall(operation);
1424     }
1425     JITCompiler::Call callOperation(V_JITOperation_EOSymJZ operation, GPRReg arg1, GPRReg arg2, JSValueRegs arg3, GPRReg arg4)
1426     {
1427         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3.payloadGPR(), arg4);
1428         return appendCall(operation);
1429     }
1430     JITCompiler::Call callOperation(V_JITOperation_EOJOOZ operation, GPRReg arg1, JSValueRegs arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
1431     {
1432         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg3, arg4, arg5);
1433         return appendCall(operation);
1434     }
1435     JITCompiler::Call callOperation(V_JITOperation_EOJssOOZ operation, GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
1436     {
1437         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3, arg4, arg5);
1438         return appendCall(operation);
1439     }
1440     JITCompiler::Call callOperation(V_JITOperation_EOIOOZ operation, GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
1441     {
1442         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3, arg4, arg5);
1443         return appendCall(operation);
1444     }
1445     JITCompiler::Call callOperation(V_JITOperation_EOSymOOZ operation, GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
1446     {
1447         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3, arg4, arg5);
1448         return appendCall(operation);
1449     }
1450     JITCompiler::Call callOperation(V_JITOperation_EOJIUi operation, GPRReg arg1, GPRReg arg2, UniquedStringImpl* impl, unsigned value)
1451     {
1452         m_jit.setupArgumentsWithExecState(arg1, arg2, TrustedImmPtr(impl), TrustedImm32(value));
1453         return appendCall(operation);
1454     }
1455     JITCompiler::Call callOperation(J_JITOperation_EOIUi operation, GPRReg result, GPRReg arg1, UniquedStringImpl* impl, unsigned value)
1456     {
1457         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr(impl), TrustedImm32(value));
1458         return appendCallSetResult(operation, result);
1459     }
1460     JITCompiler::Call callOperation(J_JITOperation_E operation, GPRReg result)
1461     {
1462         m_jit.setupArgumentsExecState();
1463         return appendCallSetResult(operation, result);
1464     }
1465     JITCompiler::Call callOperation(J_JITOperation_EP operation, GPRReg result, void* pointer)
1466     {
1467         m_jit.setupArgumentsWithExecState(TrustedImmPtr(pointer));
1468         return appendCallSetResult(operation, result);
1469     }
1470     JITCompiler::Call callOperation(Z_JITOperation_D operation, GPRReg result, FPRReg arg1)
1471     {
1472         m_jit.setupArguments(arg1);
1473         JITCompiler::Call call = m_jit.appendCall(operation);
1474         m_jit.zeroExtend32ToPtr(GPRInfo::returnValueGPR, result);
1475         return call;
1476     }
1477     JITCompiler::Call callOperation(Q_JITOperation_J operation, GPRReg result, GPRReg value)
1478     {
1479         m_jit.setupArguments(value);
1480         return appendCallSetResult(operation, result);
1481     }
1482     JITCompiler::Call callOperation(Q_JITOperation_D operation, GPRReg result, FPRReg value)
1483     {
1484         m_jit.setupArguments(value);
1485         return appendCallSetResult(operation, result);
1486     }
1487     JITCompiler::Call callOperation(J_JITOperation_EI operation, GPRReg result, UniquedStringImpl* uid)
1488     {
1489         m_jit.setupArgumentsWithExecState(TrustedImmPtr(uid));
1490         return appendCallSetResult(operation, result);
1491     }
1492     JITCompiler::Call callOperation(J_JITOperation_EA operation, GPRReg result, GPRReg arg1)
1493     {
1494         m_jit.setupArgumentsWithExecState(arg1);
1495         return appendCallSetResult(operation, result);
1496     }
1497     JITCompiler::Call callOperation(J_JITOperation_EAZ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1498     {
1499         m_jit.setupArgumentsWithExecState(arg1, arg2);
1500         return appendCallSetResult(operation, result);
1501     }
1502     JITCompiler::Call callOperation(J_JITOperation_EJssReo operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1503     {
1504         m_jit.setupArgumentsWithExecState(arg1, arg2);
1505         return appendCallSetResult(operation, result);
1506     }
1507     JITCompiler::Call callOperation(J_JITOperation_EJssReoJss operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1508     {
1509         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1510         return appendCallSetResult(operation, result);
1511     }
1512     JITCompiler::Call callOperation(J_JITOperation_EJssZ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1513     {
1514         m_jit.setupArgumentsWithExecState(arg1, arg2);
1515         return appendCallSetResult(operation, result);
1516     }
1517     JITCompiler::Call callOperation(J_JITOperation_EPS operation, GPRReg result, void* pointer, size_t size)
1518     {
1519         m_jit.setupArgumentsWithExecState(TrustedImmPtr(pointer), TrustedImmPtr(size));
1520         return appendCallSetResult(operation, result);
1521     }
1522     JITCompiler::Call callOperation(J_JITOperation_ESS operation, GPRReg result, int startConstant, int numConstants)
1523     {
1524         m_jit.setupArgumentsWithExecState(TrustedImm32(startConstant), TrustedImm32(numConstants));
1525         return appendCallSetResult(operation, result);
1526     }
1527     JITCompiler::Call callOperation(J_JITOperation_EPP operation, GPRReg result, GPRReg arg1, void* pointer)
1528     {
1529         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr(pointer));
1530         return appendCallSetResult(operation, result);
1531     }
1532     JITCompiler::Call callOperation(J_JITOperation_EC operation, GPRReg result, JSCell* cell)
1533     {
1534         m_jit.setupArgumentsWithExecState(TrustedImmPtr::weakPointer(m_jit.graph(), cell));
1535         return appendCallSetResult(operation, result);
1536     }
1537     JITCompiler::Call callOperation(J_JITOperation_ECZ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1538     {
1539         m_jit.setupArgumentsWithExecState(arg1, arg2);
1540         return appendCallSetResult(operation, result);
1541     }
1542     JITCompiler::Call callOperation(J_JITOperation_ESsiCI operation, GPRReg result, StructureStubInfo* stubInfo, GPRReg arg1, const UniquedStringImpl* uid)
1543     {
1544         m_jit.setupArgumentsWithExecState(TrustedImmPtr(stubInfo), arg1, TrustedImmPtr(uid));
1545         return appendCallSetResult(operation, result);
1546     }
1547     JITCompiler::Call callOperation(J_JITOperation_ESsiJI operation, GPRReg result, StructureStubInfo* stubInfo, GPRReg arg1, UniquedStringImpl* uid)
1548     {
1549         m_jit.setupArgumentsWithExecState(TrustedImmPtr(stubInfo), arg1, TrustedImmPtr(uid));
1550         return appendCallSetResult(operation, result);
1551     }
1552     JITCompiler::Call callOperation(J_JITOperation_EDA operation, GPRReg result, FPRReg arg1, GPRReg arg2)
1553     {
1554         m_jit.setupArgumentsWithExecState(arg1, arg2);
1555         return appendCallSetResult(operation, result);
1556     }
1557     JITCompiler::Call callOperation(J_JITOperation_EJC operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1558     {
1559         m_jit.setupArgumentsWithExecState(arg1, arg2);
1560         return appendCallSetResult(operation, result);
1561     }
1562     JITCompiler::Call callOperation(J_JITOperation_EJZ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1563     {
1564         m_jit.setupArgumentsWithExecState(arg1, arg2);
1565         return appendCallSetResult(operation, result);
1566     }
1567     JITCompiler::Call callOperation(J_JITOperation_EJA operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1568     {
1569         m_jit.setupArgumentsWithExecState(arg1, arg2);
1570         return appendCallSetResult(operation, result);
1571     }
1572     JITCompiler::Call callOperation(J_JITOperation_EP operation, GPRReg result, GPRReg arg1)
1573     {
1574         m_jit.setupArgumentsWithExecState(arg1);
1575         return appendCallSetResult(operation, result);
1576     }
1577     JITCompiler::Call callOperation(J_JITOperation_EZ operation, GPRReg result, GPRReg arg1)
1578     {
1579         m_jit.setupArgumentsWithExecState(arg1);
1580         return appendCallSetResult(operation, result);
1581     }
1582     JITCompiler::Call callOperation(J_JITOperation_EZ operation, GPRReg result, int32_t arg1)
1583     {
1584         m_jit.setupArgumentsWithExecState(TrustedImm32(arg1));
1585         return appendCallSetResult(operation, result);
1586     }
1587     JITCompiler::Call callOperation(J_JITOperation_EZZ operation, GPRReg result, int32_t arg1, GPRReg arg2)
1588     {
1589         m_jit.setupArgumentsWithExecState(TrustedImm32(arg1), arg2);
1590         return appendCallSetResult(operation, result);
1591     }
1592     JITCompiler::Call callOperation(J_JITOperation_EZIcfZ operation, GPRReg result, int32_t arg1, InlineCallFrame* inlineCallFrame, GPRReg arg2)
1593     {
1594         m_jit.setupArgumentsWithExecState(TrustedImm32(arg1), TrustedImmPtr(inlineCallFrame), arg2);
1595         return appendCallSetResult(operation, result);
1596     }
1597
1598     JITCompiler::Call callOperation(P_JITOperation_EJS operation, GPRReg result, GPRReg value, size_t index)
1599     {
1600         m_jit.setupArgumentsWithExecState(value, TrustedImmPtr(index));
1601         return appendCallSetResult(operation, result);
1602     }
1603
1604     JITCompiler::Call callOperation(P_JITOperation_EStJ operation, GPRReg result, RegisteredStructure structure, GPRReg arg2)
1605     {
1606         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), arg2);
1607         return appendCallSetResult(operation, result);
1608     }
1609
1610     JITCompiler::Call callOperation(C_JITOperation_EGJ operation, GPRReg result, JSGlobalObject* globalObject, GPRReg arg1)
1611     {
1612         m_jit.setupArgumentsWithExecState(TrustedImmPtr::weakPointer(m_jit.graph(), globalObject), arg1);
1613         return appendCallSetResult(operation, result);
1614     }
1615
1616     JITCompiler::Call callOperation(C_JITOperation_EGJ operation, GPRReg result, JSGlobalObject* globalObject, JSValueRegs arg1)
1617     {
1618         return callOperation(operation, result, globalObject, arg1.gpr());
1619     }
1620
1621     JITCompiler::Call callOperation(C_JITOperation_EJ operation, GPRReg result, GPRReg arg1)
1622     {
1623         m_jit.setupArgumentsWithExecState(arg1);
1624         return appendCallSetResult(operation, result);
1625     }
1626     JITCompiler::Call callOperation(C_JITOperation_EJJ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1627     {
1628         m_jit.setupArgumentsWithExecState(arg1, arg2);
1629         return appendCallSetResult(operation, result);
1630     }
1631     JITCompiler::Call callOperation(C_JITOperation_EJJC operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1632     {
1633         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1634         return appendCallSetResult(operation, result);
1635     }
1636     JITCompiler::Call callOperation(C_JITOperation_EJJJ operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1637     {
1638         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1639         return appendCallSetResult(operation, result);
1640     }
1641     JITCompiler::Call callOperation(C_JITOperation_EJZ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1642     {
1643         m_jit.setupArgumentsWithExecState(arg1, arg2);
1644         return appendCallSetResult(operation, result);
1645     }
1646     JITCompiler::Call callOperation(C_JITOperation_EJZC operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1647     {
1648         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1649         return appendCallSetResult(operation, result);
1650     }
1651     JITCompiler::Call callOperation(S_JITOperation_J operation, GPRReg result, GPRReg arg1)
1652     {
1653         m_jit.setupArguments(arg1);
1654         return appendCallSetResult(operation, result);
1655     }
1656     JITCompiler::Call callOperation(S_JITOperation_EJ operation, GPRReg result, GPRReg arg1)
1657     {
1658         m_jit.setupArgumentsWithExecState(arg1);
1659         return appendCallSetResult(operation, result);
1660     }
1661     JITCompiler::Call callOperation(S_JITOperation_EJ operation, GPRReg result, JSValueRegs arg1)
1662     {
1663         return callOperation(operation, result, arg1.gpr());
1664     }
1665     JITCompiler::Call callOperation(J_JITOperation_EJ operation, JSValueRegs result, JSValueRegs arg1)
1666     {
1667         return callOperation(operation, result.payloadGPR(), arg1.payloadGPR());
1668     }
1669     JITCompiler::Call callOperation(J_JITOperation_EJ operation, GPRReg result, JSValueRegs arg1)
1670     {
1671         return callOperation(operation, result, arg1.payloadGPR());
1672     }
1673     JITCompiler::Call callOperation(J_JITOperation_EJ operation, GPRReg result, GPRReg arg1)
1674     {
1675         m_jit.setupArgumentsWithExecState(arg1);
1676         return appendCallSetResult(operation, result);
1677     }
1678     JITCompiler::Call callOperation(S_JITOperation_EJI operation, GPRReg result, GPRReg arg1, UniquedStringImpl* uid)
1679     {
1680         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr(uid));
1681         return appendCallSetResult(operation, result);
1682     }
1683     JITCompiler::Call callOperation(S_JITOperation_EJI operation, GPRReg result, JSValueRegs arg1, UniquedStringImpl* uid)
1684     {
1685         return callOperation(operation, result, arg1.gpr(), uid);
1686     }
1687     JITCompiler::Call callOperation(S_JITOperation_EJJ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1688     {
1689         m_jit.setupArgumentsWithExecState(arg1, arg2);
1690         return appendCallSetResult(operation, result);
1691     }
1692     JITCompiler::Call callOperation(S_JITOperation_EJJ operation, GPRReg result,  JSValueRegs arg1, JSValueRegs arg2)
1693     {
1694         return callOperation(operation, result, arg1.gpr(), arg2.gpr());
1695     }
1696     JITCompiler::Call callOperation(S_JITOperation_EGJJ 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(S_JITOperation_EGReoJ operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1702     {
1703         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1704         return appendCallSetResult(operation, result);
1705     }
1706     JITCompiler::Call callOperation(S_JITOperation_EGReoJss operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1707     {
1708         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1709         return appendCallSetResult(operation, result);
1710     }
1711
1712     JITCompiler::Call callOperation(J_JITOperation_EPP operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1713     {
1714         m_jit.setupArgumentsWithExecState(arg1, arg2);
1715         return appendCallSetResult(operation, result);
1716     }
1717     JITCompiler::Call callOperation(J_JITOperation_EPPP operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1718     {
1719         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1720         return appendCallSetResult(operation, result);
1721     }
1722     JITCompiler::Call callOperation(J_JITOperation_EGP operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1723     {
1724         m_jit.setupArgumentsWithExecState(arg1, arg2);
1725         return appendCallSetResult(operation, result);
1726     }
1727     JITCompiler::Call callOperation(J_JITOperation_EJJ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1728     {
1729         m_jit.setupArgumentsWithExecState(arg1, arg2);
1730         return appendCallSetResult(operation, result);
1731     }
1732     JITCompiler::Call callOperation(J_JITOperation_EGJJ operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1733     {
1734         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1735         return appendCallSetResult(operation, result);
1736     }
1737     JITCompiler::Call callOperation(J_JITOperation_EJJ operation, GPRReg result, GPRReg arg1, int32_t imm)
1738     {
1739         m_jit.setupArgumentsWithExecState(arg1, MacroAssembler::TrustedImm64(JSValue::encode(jsNumber(imm))));
1740         return appendCallSetResult(operation, result);
1741     }
1742     JITCompiler::Call callOperation(J_JITOperation_EJJ operation, GPRReg result, int32_t imm, GPRReg arg2)
1743     {
1744         m_jit.setupArgumentsWithExecState(MacroAssembler::TrustedImm64(JSValue::encode(jsNumber(imm))), arg2);
1745         return appendCallSetResult(operation, result);
1746     }
1747     JITCompiler::Call callOperation(J_JITOperation_EJJ operation, JSValueRegs result, JSValueRegs arg1, JSValueRegs arg2)
1748     {
1749         return callOperation(operation, result.payloadGPR(), arg1.payloadGPR(), arg2.payloadGPR());
1750     }
1751     JITCompiler::Call callOperation(J_JITOperation_EJJJ operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1752     {
1753         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1754         return appendCallSetResult(operation, result);
1755     }
1756     JITCompiler::Call callOperation(J_JITOperation_ECC operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1757     {
1758         m_jit.setupArgumentsWithExecState(arg1, arg2);
1759         return appendCallSetResult(operation, result);
1760     }
1761     JITCompiler::Call callOperation(J_JITOperation_ECJ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
1762     {
1763         m_jit.setupArgumentsWithExecState(arg1, arg2);
1764         return appendCallSetResult(operation, result);
1765     }
1766     JITCompiler::Call callOperation(J_JITOperation_ECJ operation, GPRReg result, GPRReg arg1, JSValueRegs arg2)
1767     {
1768         m_jit.setupArgumentsWithExecState(arg1, arg2.gpr());
1769         return appendCallSetResult(operation, result);
1770     }
1771
1772     JITCompiler::Call callOperation(V_JITOperation_EOZD operation, GPRReg arg1, GPRReg arg2, FPRReg arg3)
1773     {
1774         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1775         return appendCall(operation);
1776     }
1777     JITCompiler::Call callOperation(V_JITOperation_EJ operation, GPRReg arg1)
1778     {
1779         m_jit.setupArgumentsWithExecState(arg1);
1780         return appendCall(operation);
1781     }
1782     JITCompiler::Call callOperation(V_JITOperation_EJPP operation, GPRReg arg1, GPRReg arg2, void* pointer)
1783     {
1784         m_jit.setupArgumentsWithExecState(arg1, arg2, TrustedImmPtr(pointer));
1785         return appendCall(operation);
1786     }
1787     JITCompiler::Call callOperation(V_JITOperation_ESsiJJI operation, StructureStubInfo* stubInfo, GPRReg arg1, GPRReg arg2, UniquedStringImpl* uid)
1788     {
1789         m_jit.setupArgumentsWithExecState(TrustedImmPtr(stubInfo), arg1, arg2, TrustedImmPtr(uid));
1790         return appendCall(operation);
1791     }
1792     JITCompiler::Call callOperation(V_JITOperation_EJJJ operation, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1793     {
1794         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1795         return appendCall(operation);
1796     }
1797     JITCompiler::Call callOperation(V_JITOperation_EPZJ operation, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1798     {
1799         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1800         return appendCall(operation);
1801     }
1802
1803     JITCompiler::Call callOperation(V_JITOperation_EOZJ operation, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1804     {
1805         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1806         return appendCall(operation);
1807     }
1808     JITCompiler::Call callOperation(V_JITOperation_ECJ operation, GPRReg arg1, JSValueRegs arg2)
1809     {
1810         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR());
1811         return appendCall(operation);
1812     }
1813     JITCompiler::Call callOperation(V_JITOperation_ECJJ operation, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1814     {
1815         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1816         return appendCall(operation);
1817     }
1818
1819     JITCompiler::Call callOperation(Z_JITOperation_EJ operation, GPRReg result, JSValueRegs arg1)
1820     {
1821         m_jit.setupArgumentsWithExecState(arg1.payloadGPR());
1822         return appendCallSetResult(operation, result);
1823     }
1824
1825     JITCompiler::Call callOperation(Z_JITOperation_EJZZ operation, GPRReg result, GPRReg arg1, unsigned arg2, unsigned arg3)
1826     {
1827         m_jit.setupArgumentsWithExecState(arg1, TrustedImm32(arg2), TrustedImm32(arg3));
1828         return appendCallSetResult(operation, result);
1829     }
1830     JITCompiler::Call callOperation(F_JITOperation_EFJZZ operation, GPRReg result, GPRReg arg1, GPRReg arg2, unsigned arg3, GPRReg arg4)
1831     {
1832         m_jit.setupArgumentsWithExecState(arg1, arg2, TrustedImm32(arg3), arg4);
1833         return appendCallSetResult(operation, result);
1834     }
1835
1836     JITCompiler::Call callOperation(Z_JITOperation_EJOJ operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1837     {
1838         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1839         return appendCallSetResult(operation, result);
1840     }
1841     JITCompiler::Call callOperation(Z_JITOperation_EJOJ operation, GPRReg result, JSValueRegs arg1, GPRReg arg2, JSValueRegs arg3)
1842     {
1843         return callOperation(operation, result, arg1.payloadGPR(), arg2, arg3.payloadGPR());
1844     }
1845
1846     JITCompiler::Call callOperation(Z_JITOperation_EJZ operation, GPRReg result, GPRReg arg1, unsigned arg2)
1847     {
1848         m_jit.setupArgumentsWithExecState(arg1, TrustedImm32(arg2));
1849         return appendCallSetResult(operation, result);
1850     }
1851     JITCompiler::Call callOperation(V_JITOperation_EZJZZZ operation, unsigned arg1, GPRReg arg2, unsigned arg3, GPRReg arg4, unsigned arg5)
1852     {
1853         m_jit.setupArgumentsWithExecState(TrustedImm32(arg1), arg2, TrustedImm32(arg3), arg4, TrustedImm32(arg5));
1854         return appendCall(operation);
1855     }
1856     JITCompiler::Call callOperation(V_JITOperation_ECJZC operation, GPRReg regOp1, GPRReg regOp2, int32_t op3, GPRReg regOp4)
1857     {
1858         m_jit.setupArgumentsWithExecState(regOp1, regOp2, TrustedImm32(op3), regOp4);
1859         return appendCall(operation);
1860     }
1861     JITCompiler::Call callOperation(V_JITOperation_ECIZJJ operation, GPRReg regOp1, UniquedStringImpl* identOp2, int32_t op3, GPRReg regOp4, GPRReg regOp5)
1862     {
1863         m_jit.setupArgumentsWithExecState(regOp1, TrustedImmPtr(identOp2), TrustedImm32(op3), regOp4, regOp5);
1864         return appendCall(operation);
1865     }
1866     JITCompiler::Call callOperation(D_JITOperation_EJ operation, FPRReg result, JSValueRegs arg1)
1867     {
1868         m_jit.setupArgumentsWithExecState(arg1.gpr());
1869         return appendCallSetResult(operation, result);
1870     }
1871 #else // USE(JSVALUE32_64)
1872     JITCompiler::Call callOperation(Z_JITOperation_EOJ operation, GPRReg result, GPRReg arg1, JSValueRegs arg2)
1873     {
1874         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg2.tagGPR());
1875         return appendCallSetResult(operation, result);
1876     }
1877     JITCompiler::Call callOperation(C_JITOperation_ECJZ operation, GPRReg result, GPRReg arg1, JSValueRegs arg2, GPRReg arg3)
1878     {
1879         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg2.tagGPR(), arg3);
1880         return appendCallSetResult(operation, result);
1881     }
1882     JITCompiler::Call callOperation(J_JITOperation_EJMic operation, JSValueRegs result, JSValueRegs arg, TrustedImmPtr mathIC)
1883     {
1884         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg.payloadGPR(), arg.tagGPR(), mathIC);
1885         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
1886     }
1887     JITCompiler::Call callOperation(J_JITOperation_EJJMic operation, JSValueRegs result, JSValueRegs arg1, JSValueRegs arg2, TrustedImmPtr mathIC)
1888     {
1889         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2.payloadGPR(), arg2.tagGPR(), mathIC);
1890         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
1891     }
1892
1893     JITCompiler::Call callOperation(J_JITOperation_EJJI operation, JSValueRegs result, JSValueRegs arg1, JSValueRegs arg2, UniquedStringImpl* uid)
1894     {
1895         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2.payloadGPR(), arg2.tagGPR(), TrustedImmPtr(uid));
1896         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
1897     }
1898     JITCompiler::Call callOperation(V_JITOperation_EJJJI operation, JSValueRegs arg1, JSValueRegs arg2, JSValueRegs arg3, UniquedStringImpl* uid)
1899     {
1900         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2.payloadGPR(), arg2.tagGPR(), arg3.payloadGPR(), arg3.tagGPR(), TrustedImmPtr(uid));
1901         return appendCall(operation);
1902     }
1903     JITCompiler::Call callOperation(V_JITOperation_EJJJJ operation, JSValueRegs arg1, JSValueRegs arg2, JSValueRegs arg3, JSValueRegs arg4)
1904     {
1905         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2.payloadGPR(), arg2.tagGPR(), arg3.payloadGPR(), arg3.tagGPR(), arg4.payloadGPR(), arg4.tagGPR());
1906         return appendCall(operation);
1907     }
1908     JITCompiler::Call callOperation(V_JITOperation_EOJJZ operation, GPRReg arg1, JSValueRegs arg2, JSValueRegs arg3, GPRReg arg4)
1909     {
1910         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg2.tagGPR(), arg3.payloadGPR(), arg3.tagGPR(), arg4);
1911         return appendCall(operation);
1912     }
1913     JITCompiler::Call callOperation(V_JITOperation_EOJssJZ operation, GPRReg arg1, GPRReg arg2, JSValueRegs arg3, GPRReg arg4)
1914     {
1915         m_jit.setupArgumentsWithExecState(arg1, arg2, EABI_32BIT_DUMMY_ARG arg3.payloadGPR(), arg3.tagGPR(), arg4);
1916         return appendCall(operation);
1917     }
1918     JITCompiler::Call callOperation(V_JITOperation_EOIJZ operation, GPRReg arg1, GPRReg arg2, JSValueRegs arg3, GPRReg arg4)
1919     {
1920         m_jit.setupArgumentsWithExecState(arg1, arg2, EABI_32BIT_DUMMY_ARG arg3.payloadGPR(), arg3.tagGPR(), arg4);
1921         return appendCall(operation);
1922     }
1923     JITCompiler::Call callOperation(V_JITOperation_EOSymJZ operation, GPRReg arg1, GPRReg arg2, JSValueRegs arg3, GPRReg arg4)
1924     {
1925         m_jit.setupArgumentsWithExecState(arg1, arg2, EABI_32BIT_DUMMY_ARG arg3.payloadGPR(), arg3.tagGPR(), arg4);
1926         return appendCall(operation);
1927     }
1928     JITCompiler::Call callOperation(V_JITOperation_EOJOOZ operation, GPRReg arg1, JSValueRegs arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
1929     {
1930         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg2.tagGPR(), arg3, arg4, arg5);
1931         return appendCall(operation);
1932     }
1933     JITCompiler::Call callOperation(V_JITOperation_EOJssOOZ operation, GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
1934     {
1935         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3, arg4, arg5);
1936         return appendCall(operation);
1937     }
1938     JITCompiler::Call callOperation(V_JITOperation_EOIOOZ operation, GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
1939     {
1940         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3, arg4, arg5);
1941         return appendCall(operation);
1942     }
1943     JITCompiler::Call callOperation(V_JITOperation_EOSymOOZ operation, GPRReg arg1, GPRReg arg2, GPRReg arg3, GPRReg arg4, GPRReg arg5)
1944     {
1945         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3, arg4, arg5);
1946         return appendCall(operation);
1947     }
1948     JITCompiler::Call callOperation(V_JITOperation_EOJIUi operation, GPRReg arg1, JSValueRegs arg2, UniquedStringImpl* impl, unsigned value)
1949     {
1950         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg2.tagGPR(), TrustedImmPtr(impl), TrustedImm32(value));
1951         return appendCall(operation);
1952     }
1953     JITCompiler::Call callOperation(J_JITOperation_EOIUi operation, JSValueRegs result, GPRReg arg1, UniquedStringImpl* impl, unsigned value)
1954     {
1955         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr(impl), TrustedImm32(value));
1956         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
1957     }
1958     JITCompiler::Call callOperation(D_JITOperation_G operation, FPRReg result, JSGlobalObject* globalObject)
1959     {
1960         m_jit.setupArguments(TrustedImmPtr::weakPointer(m_jit.graph(), globalObject));
1961         return appendCallSetResult(operation, result);
1962     }
1963     JITCompiler::Call callOperation(Z_JITOperation_D operation, GPRReg result, FPRReg arg1)
1964     {
1965         prepareForExternalCall();
1966         m_jit.setupArguments(arg1);
1967         JITCompiler::Call call = m_jit.appendCall(operation);
1968         m_jit.zeroExtend32ToPtr(GPRInfo::returnValueGPR, result);
1969         return call;
1970     }
1971     JITCompiler::Call callOperation(J_JITOperation_E operation, JSValueRegs result)
1972     {
1973         m_jit.setupArgumentsExecState();
1974         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
1975     }
1976     JITCompiler::Call callOperation(J_JITOperation_EP operation, JSValueRegs result, void* pointer)
1977     {
1978         m_jit.setupArgumentsWithExecState(TrustedImmPtr(pointer));
1979         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
1980     }
1981     JITCompiler::Call callOperation(J_JITOperation_EPP operation, JSValueRegs result, GPRReg arg1, void* pointer)
1982     {
1983         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr(pointer));
1984         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
1985     }
1986     JITCompiler::Call callOperation(J_JITOperation_EPP operation, JSValueRegs result, GPRReg arg1, GPRReg arg2)
1987     {
1988         m_jit.setupArgumentsWithExecState(arg1, arg2);
1989         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
1990     }
1991     JITCompiler::Call callOperation(J_JITOperation_EPPP operation, JSValueRegs result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
1992     {
1993         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
1994         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
1995     }
1996     JITCompiler::Call callOperation(J_JITOperation_EGP operation, JSValueRegs result, GPRReg arg1, GPRReg arg2)
1997     {
1998         m_jit.setupArgumentsWithExecState(arg1, arg2);
1999         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2000     }
2001     JITCompiler::Call callOperation(J_JITOperation_EP operation, JSValueRegs result, GPRReg arg1)
2002     {
2003         m_jit.setupArgumentsWithExecState(arg1);
2004         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2005     }
2006     JITCompiler::Call callOperation(J_JITOperation_EI operation, JSValueRegs result, UniquedStringImpl* uid)
2007     {
2008         m_jit.setupArgumentsWithExecState(TrustedImmPtr(uid));
2009         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2010     }
2011     JITCompiler::Call callOperation(J_JITOperation_EA operation, JSValueRegs result, GPRReg arg1)
2012     {
2013         m_jit.setupArgumentsWithExecState(arg1);
2014         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2015     }
2016     JITCompiler::Call callOperation(J_JITOperation_EAZ operation, JSValueRegs result, GPRReg arg1, GPRReg arg2)
2017     {
2018         m_jit.setupArgumentsWithExecState(arg1, arg2);
2019         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2020     }
2021     JITCompiler::Call callOperation(J_JITOperation_EJ operation, JSValueRegs result, GPRReg arg1)
2022     {
2023         m_jit.setupArgumentsWithExecState(arg1);
2024         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2025     }
2026     JITCompiler::Call callOperation(J_JITOperation_EJC operation, JSValueRegs result, JSValueRegs arg1, GPRReg arg2)
2027     {
2028         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2);
2029         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2030     }
2031     JITCompiler::Call callOperation(J_JITOperation_EJssZ operation, JSValueRegs result, GPRReg arg1, GPRReg arg2)
2032     {
2033         m_jit.setupArgumentsWithExecState(arg1, arg2);
2034         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2035     }
2036     JITCompiler::Call callOperation(J_JITOperation_EJssReo operation, JSValueRegs result, GPRReg arg1, GPRReg arg2)
2037     {
2038         m_jit.setupArgumentsWithExecState(arg1, arg2);
2039         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2040     }
2041     JITCompiler::Call callOperation(J_JITOperation_EJssReoJss operation, JSValueRegs result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
2042     {
2043         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
2044         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2045     }
2046     JITCompiler::Call callOperation(J_JITOperation_EPS operation, JSValueRegs result, void* pointer, size_t size)
2047     {
2048         m_jit.setupArgumentsWithExecState(TrustedImmPtr(pointer), TrustedImmPtr(size));
2049         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2050     }
2051     JITCompiler::Call callOperation(J_JITOperation_ESS operation, JSValueRegs result, int startConstant, int numConstants)
2052     {
2053         m_jit.setupArgumentsWithExecState(TrustedImm32(startConstant), TrustedImm32(numConstants));
2054         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2055     }
2056     JITCompiler::Call callOperation(J_JITOperation_EJP operation, JSValueRegs result, JSValueRegs arg1, void* pointer)
2057     {
2058         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), TrustedImmPtr(pointer));
2059         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2060     }
2061     JITCompiler::Call callOperation(J_JITOperation_EJP operation, JSValueRegs result, JSValueRegs arg1, GPRReg arg2)
2062     {
2063         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2);
2064         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2065     }
2066
2067     JITCompiler::Call callOperation(J_JITOperation_EC operation, JSValueRegs result, JSCell* cell)
2068     {
2069         m_jit.setupArgumentsWithExecState(TrustedImmPtr::weakPointer(m_jit.graph(), cell));
2070         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2071     }
2072     JITCompiler::Call callOperation(J_JITOperation_ECZ operation, JSValueRegs result, GPRReg arg1, GPRReg arg2)
2073     {
2074         m_jit.setupArgumentsWithExecState(arg1, arg2);
2075         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2076     }
2077     JITCompiler::Call callOperation(J_JITOperation_EJscC operation, JSValueRegs result, GPRReg arg1, JSCell* cell)
2078     {
2079         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr::weakPointer(m_jit.graph(), cell));
2080         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2081     }
2082     JITCompiler::Call callOperation(J_JITOperation_EJscCJ operation, GPRReg result, GPRReg arg1, JSCell* cell, JSValueRegs arg2)
2083     {
2084         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr::weakPointer(m_jit.graph(), cell), EABI_32BIT_DUMMY_ARG arg2.payloadGPR(), arg2.tagGPR());
2085         return appendCallSetResult(operation, result);
2086     }
2087     JITCompiler::Call callOperation(J_JITOperation_EGReoJ operation, JSValueRegs result, GPRReg arg1, GPRReg arg2, JSValueRegs arg3)
2088     {
2089         m_jit.setupArgumentsWithExecState(arg1, arg2, EABI_32BIT_DUMMY_ARG arg3.payloadGPR(), arg3.tagGPR());
2090         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2091     }
2092     JITCompiler::Call callOperation(J_JITOperation_EGReoJss operation, JSValueRegs result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
2093     {
2094         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
2095         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2096     }
2097     JITCompiler::Call callOperation(J_JITOperation_ESsiCI operation, JSValueRegs result, StructureStubInfo* stubInfo, GPRReg arg1, const UniquedStringImpl* uid)
2098     {
2099         m_jit.setupArgumentsWithExecState(TrustedImmPtr(stubInfo), arg1, TrustedImmPtr(uid));
2100         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2101     }
2102     JITCompiler::Call callOperation(J_JITOperation_ESsiJI operation, JSValueRegs result, StructureStubInfo* stubInfo, JSValueRegs arg1, UniquedStringImpl* uid)
2103     {
2104         m_jit.setupArgumentsWithExecState(TrustedImmPtr(stubInfo), arg1.payloadGPR(), arg1.tagGPR(), TrustedImmPtr(uid));
2105         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2106     }
2107     JITCompiler::Call callOperation(J_JITOperation_ESsiJI operation, JSValueRegs result, StructureStubInfo* stubInfo, int32_t arg1Tag, GPRReg arg1Payload, UniquedStringImpl* uid)
2108     {
2109         m_jit.setupArgumentsWithExecState(TrustedImmPtr(stubInfo), arg1Payload, TrustedImm32(arg1Tag), TrustedImmPtr(uid));
2110         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2111     }
2112     JITCompiler::Call callOperation(J_JITOperation_ESsiJI operation, JSValueRegs result, StructureStubInfo* stubInfo, GPRReg arg1Tag, GPRReg arg1Payload, UniquedStringImpl* uid)
2113     {
2114         m_jit.setupArgumentsWithExecState(TrustedImmPtr(stubInfo), arg1Payload, arg1Tag, TrustedImmPtr(uid));
2115         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2116     }
2117     JITCompiler::Call callOperation(J_JITOperation_EDA operation, JSValueRegs result, FPRReg arg1, GPRReg arg2)
2118     {
2119         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1, arg2);
2120         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2121     }
2122     JITCompiler::Call callOperation(J_JITOperation_EJA operation, JSValueRegs result, JSValueRegs arg1, GPRReg arg2)
2123     {
2124         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2);
2125         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2126     }
2127     JITCompiler::Call callOperation(J_JITOperation_EJA operation, JSValueRegs result, TrustedImm32 arg1Tag, GPRReg arg1Payload, GPRReg arg2)
2128     {
2129         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1Payload, arg1Tag, arg2);
2130         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2131     }
2132     JITCompiler::Call callOperation(J_JITOperation_EJA operation, JSValueRegs result, GPRReg arg1Tag, GPRReg arg1Payload, GPRReg arg2)
2133     {
2134         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1Payload, arg1Tag, arg2);
2135         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2136     }
2137     JITCompiler::Call callOperation(J_JITOperation_EJ operation, JSValueRegs result, JSValueRegs arg1)
2138     {
2139         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR());
2140         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2141     }
2142     JITCompiler::Call callOperation(J_JITOperation_EZ operation, JSValueRegs result, GPRReg arg1)
2143     {
2144         m_jit.setupArgumentsWithExecState(arg1);
2145         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2146     }
2147     JITCompiler::Call callOperation(J_JITOperation_EZ operation, JSValueRegs result, int32_t arg1)
2148     {
2149         m_jit.setupArgumentsWithExecState(TrustedImm32(arg1));
2150         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2151     }
2152     JITCompiler::Call callOperation(J_JITOperation_EZIcfZ operation, JSValueRegs result, int32_t arg1, InlineCallFrame* inlineCallFrame, GPRReg arg2)
2153     {
2154         m_jit.setupArgumentsWithExecState(TrustedImm32(arg1), TrustedImmPtr(inlineCallFrame), arg2);
2155         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2156     }
2157     JITCompiler::Call callOperation(J_JITOperation_EZZ operation, JSValueRegs result, int32_t arg1, GPRReg arg2)
2158     {
2159         m_jit.setupArgumentsWithExecState(TrustedImm32(arg1), arg2);
2160         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2161     }
2162
2163     JITCompiler::Call callOperation(P_JITOperation_EJS operation, GPRReg result, JSValueRegs value, size_t index)
2164     {
2165         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG value.payloadGPR(), value.tagGPR(), TrustedImmPtr(index));
2166         return appendCallSetResult(operation, result);
2167     }
2168
2169     JITCompiler::Call callOperation(P_JITOperation_EStJ operation, GPRReg result, RegisteredStructure structure, JSValueRegs arg2)
2170     {
2171         m_jit.setupArgumentsWithExecState(TrustedImmPtr(structure), arg2.payloadGPR(), arg2.tagGPR());
2172         return appendCallSetResult(operation, result);
2173     }
2174
2175     JITCompiler::Call callOperation(C_JITOperation_EGJ operation, GPRReg result, JSGlobalObject* globalObject, JSValueRegs arg1)
2176     {
2177         m_jit.setupArgumentsWithExecState(TrustedImmPtr::weakPointer(m_jit.graph(), globalObject), arg1.payloadGPR(), arg1.tagGPR());
2178         return appendCallSetResult(operation, result);
2179     }
2180
2181     JITCompiler::Call callOperation(C_JITOperation_EJ operation, GPRReg result, JSValueRegs arg1)
2182     {
2183         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR());
2184         return appendCallSetResult(operation, result);
2185     }
2186
2187     JITCompiler::Call callOperation(C_JITOperation_EJJ operation, GPRReg result, JSValueRegs arg1, JSValueRegs arg2)
2188     {
2189         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2.payloadGPR(), arg2.tagGPR());
2190         return appendCallSetResult(operation, result);
2191     }
2192
2193     JITCompiler::Call callOperation(C_JITOperation_EJJJ operation, GPRReg result, JSValueRegs arg1, JSValueRegs arg2, JSValueRegs arg3)
2194     {
2195         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2.payloadGPR(), arg2.tagGPR(), arg3.payloadGPR(), arg3.tagGPR());
2196         return appendCallSetResult(operation, result);
2197     }
2198
2199     JITCompiler::Call callOperation(S_JITOperation_EJ operation, GPRReg result, JSValueRegs arg1)
2200     {
2201         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR());
2202         return appendCallSetResult(operation, result);
2203     }
2204
2205     JITCompiler::Call callOperation(S_JITOperation_EJI operation, GPRReg result, JSValueRegs arg1, UniquedStringImpl* uid)
2206     {
2207         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), TrustedImmPtr(uid));
2208         return appendCallSetResult(operation, result);
2209     }
2210
2211     JITCompiler::Call callOperation(S_JITOperation_EJJ operation, GPRReg result, JSValueRegs arg1, JSValueRegs arg2)
2212     {
2213         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2.payloadGPR(), arg2.tagGPR());
2214         return appendCallSetResult(operation, result);
2215     }
2216
2217     JITCompiler::Call callOperation(S_JITOperation_EGJJ operation, GPRReg result, GPRReg arg1, JSValueRegs arg2, JSValueRegs arg3)
2218     {
2219         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg2.tagGPR(), arg3.payloadGPR(), arg3.tagGPR());
2220         return appendCallSetResult(operation, result);
2221     }
2222     JITCompiler::Call callOperation(S_JITOperation_EGReoJ operation, GPRReg result, GPRReg arg1, GPRReg arg2, JSValueRegs arg3)
2223     {
2224         m_jit.setupArgumentsWithExecState(arg1, arg2, EABI_32BIT_DUMMY_ARG arg3.payloadGPR(), arg3.tagGPR());
2225         return appendCallSetResult(operation, result);
2226     }
2227     JITCompiler::Call callOperation(S_JITOperation_EGReoJss operation, GPRReg result, GPRReg arg1, GPRReg arg2, GPRReg arg3)
2228     {
2229         m_jit.setupArgumentsWithExecState(arg1, arg2, arg3);
2230         return appendCallSetResult(operation, result);
2231     }
2232     JITCompiler::Call callOperation(J_JITOperation_EJJ operation, JSValueRegs result, JSValueRegs arg1, JSValueRegs arg2)
2233     {
2234         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2.payloadGPR(), arg2.tagGPR());
2235         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2236     }
2237     JITCompiler::Call callOperation(J_JITOperation_EGJJ operation, JSValueRegs result, GPRReg arg1, JSValueRegs arg2, JSValueRegs arg3)
2238     {
2239         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg2.tagGPR(), arg3.payloadGPR(), arg3.tagGPR());
2240         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2241     }
2242     JITCompiler::Call callOperation(J_JITOperation_EJJ operation, JSValueRegs result, JSValueRegs arg1, MacroAssembler::TrustedImm32 imm)
2243     {
2244         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), imm, TrustedImm32(JSValue::Int32Tag));
2245         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2246     }
2247     JITCompiler::Call callOperation(J_JITOperation_EJJ operation, JSValueRegs result, MacroAssembler::TrustedImm32 imm, JSValueRegs arg2)
2248     {
2249         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG imm, TrustedImm32(JSValue::Int32Tag), arg2.payloadGPR(), arg2.tagGPR());
2250         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2251     }
2252     JITCompiler::Call callOperation(J_JITOperation_EJJJ operation, JSValueRegs result, JSValueRegs arg1, JSValueRegs arg2, JSValueRegs arg3)
2253     {
2254         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2.payloadGPR(), arg2.tagGPR(), arg3.payloadGPR(), arg3.tagGPR());
2255         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2256     }
2257
2258     JITCompiler::Call callOperation(J_JITOperation_ECJ operation, JSValueRegs result, GPRReg arg1, JSValueRegs arg2)
2259     {
2260         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg2.tagGPR());
2261         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2262     }
2263     JITCompiler::Call callOperation(J_JITOperation_ECJ operation, JSValueRegs result, GPRReg arg1, GPRReg arg2Payload)
2264     {
2265         m_jit.setupArgumentsWithExecState(arg1, arg2Payload, MacroAssembler::TrustedImm32(JSValue::CellTag));
2266         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2267     }
2268     JITCompiler::Call callOperation(J_JITOperation_ECC operation, JSValueRegs result, GPRReg arg1, GPRReg arg2)
2269     {
2270         m_jit.setupArgumentsWithExecState(arg1, arg2);
2271         return appendCallSetResult(operation, result.payloadGPR(), result.tagGPR());
2272     }
2273
2274     JITCompiler::Call callOperation(V_JITOperation_EOZD operation, GPRReg arg1, GPRReg arg2, FPRReg arg3)
2275     {
2276         m_jit.setupArgumentsWithExecState(arg1, arg2, EABI_32BIT_DUMMY_ARG arg3);
2277         return appendCall(operation);
2278     }
2279
2280     JITCompiler::Call callOperation(V_JITOperation_EJ operation, JSValueRegs arg1)
2281     {
2282         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR());
2283         return appendCall(operation);
2284     }
2285
2286     JITCompiler::Call callOperation(V_JITOperation_EJPP operation, JSValueRegs arg1, GPRReg arg2, void* pointer)
2287     {
2288         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2, TrustedImmPtr(pointer));
2289         return appendCall(operation);
2290     }
2291     JITCompiler::Call callOperation(V_JITOperation_ESsiJJI operation, StructureStubInfo* stubInfo, JSValueRegs arg1, GPRReg arg2Payload, UniquedStringImpl* uid)
2292     {
2293         m_jit.setupArgumentsWithExecState(TrustedImmPtr(stubInfo), arg1.payloadGPR(), arg1.tagGPR(), arg2Payload, TrustedImm32(JSValue::CellTag), TrustedImmPtr(uid));
2294         return appendCall(operation);
2295     }
2296     JITCompiler::Call callOperation(V_JITOperation_ECJ operation, GPRReg arg1, JSValueRegs arg2)
2297     {
2298         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg2.tagGPR());
2299         return appendCall(operation);
2300     }
2301     JITCompiler::Call callOperation(V_JITOperation_ECJJ operation, GPRReg arg1, JSValueRegs arg2, JSValueRegs arg3)
2302     {
2303         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg2.tagGPR(), arg3.payloadGPR(), arg3.tagGPR());
2304         return appendCall(operation);
2305     }
2306
2307     JITCompiler::Call callOperation(V_JITOperation_EPZJ operation, GPRReg arg1, GPRReg arg2, JSValueRegs arg3)
2308     {
2309         m_jit.setupArgumentsWithExecState(arg1, arg2, EABI_32BIT_DUMMY_ARG arg3.payloadGPR(), arg3.tagGPR());
2310         return appendCall(operation);
2311     }
2312
2313     JITCompiler::Call callOperation(V_JITOperation_EOZJ operation, GPRReg arg1, GPRReg arg2, JSValueRegs arg3)
2314     {
2315         m_jit.setupArgumentsWithExecState(arg1, arg2, EABI_32BIT_DUMMY_ARG arg3.payloadGPR(), arg3.tagGPR());
2316         return appendCall(operation);
2317     }
2318     JITCompiler::Call callOperation(V_JITOperation_EOZJ operation, GPRReg arg1, GPRReg arg2, TrustedImm32 arg3Tag, GPRReg arg3Payload)
2319     {
2320         m_jit.setupArgumentsWithExecState(arg1, arg2, EABI_32BIT_DUMMY_ARG arg3Payload, arg3Tag);
2321         return appendCall(operation);
2322     }
2323     JITCompiler::Call callOperation(V_JITOperation_EOZJ operation, GPRReg arg1, GPRReg arg2, GPRReg arg3Tag, GPRReg arg3Payload)
2324     {
2325         m_jit.setupArgumentsWithExecState(arg1, arg2, EABI_32BIT_DUMMY_ARG arg3Payload, arg3Tag);
2326         return appendCall(operation);
2327     }
2328
2329     JITCompiler::Call callOperation(Z_JITOperation_EJOJ operation, GPRReg result, JSValueRegs arg1, GPRReg arg2, JSValueRegs arg3)
2330     {
2331         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), arg2, EABI_32BIT_DUMMY_ARG arg3.payloadGPR(), arg3.tagGPR());
2332         return appendCallSetResult(operation, result);
2333     }
2334     JITCompiler::Call callOperation(Z_JITOperation_EJ operation, GPRReg result, JSValueRegs arg1)
2335     {
2336         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG  arg1.payloadGPR(), arg1.tagGPR());
2337         return appendCallSetResult(operation, result);
2338     }
2339     JITCompiler::Call callOperation(Z_JITOperation_EJZZ operation, GPRReg result, JSValueRegs arg1, unsigned arg2, unsigned arg3)
2340     {
2341         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG  arg1.payloadGPR(), arg1.tagGPR(), TrustedImm32(arg2), TrustedImm32(arg3));
2342         return appendCallSetResult(operation, result);
2343     }
2344     JITCompiler::Call callOperation(F_JITOperation_EFJZZ operation, GPRReg result, GPRReg arg1, JSValueRegs arg2, unsigned arg3, GPRReg arg4)
2345     {
2346         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg2.tagGPR(), TrustedImm32(arg3), arg4);
2347         return appendCallSetResult(operation, result);
2348     }
2349     JITCompiler::Call callOperation(Z_JITOperation_EJZ operation, GPRReg result, JSValueRegs arg1, unsigned arg2)
2350     {
2351         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR(), TrustedImm32(arg2));
2352         return appendCallSetResult(operation, result);
2353     }
2354     JITCompiler::Call callOperation(V_JITOperation_EZJZZZ operation, unsigned arg1, JSValueRegs arg2, unsigned arg3, GPRReg arg4, unsigned arg5)
2355     {
2356         m_jit.setupArgumentsWithExecState(TrustedImm32(arg1), arg2.payloadGPR(), arg2.tagGPR(), TrustedImm32(arg3), arg4, TrustedImm32(arg5));
2357         return appendCall(operation);
2358     }
2359     JITCompiler::Call callOperation(V_JITOperation_ECJZC operation, GPRReg arg1, JSValueRegs arg2, int32_t arg3, GPRReg arg4)
2360     {
2361         m_jit.setupArgumentsWithExecState(arg1, arg2.payloadGPR(), arg2.tagGPR(), TrustedImm32(arg3), arg4);
2362         return appendCall(operation);
2363     }
2364     JITCompiler::Call callOperation(V_JITOperation_ECIZCC operation, GPRReg arg1, UniquedStringImpl* identOp2, int32_t op3, GPRReg arg4, GPRReg arg5)
2365     {
2366         m_jit.setupArgumentsWithExecState(arg1, TrustedImmPtr(identOp2), TrustedImm32(op3), arg4, arg5);
2367         return appendCall(operation);
2368     }
2369     JITCompiler::Call callOperation(D_JITOperation_EJ operation, FPRReg result, JSValueRegs arg1)
2370     {
2371         m_jit.setupArgumentsWithExecState(EABI_32BIT_DUMMY_ARG arg1.payloadGPR(), arg1.tagGPR());
2372         return appendCallSetResult(operation, result);
2373     }
2374 #endif // USE(JSVALUE32_64)
2375     
2376 #if !defined(NDEBUG) && !CPU(ARM) && !CPU(MIPS)
2377     void prepareForExternalCall()
2378     {
2379         // We're about to call out to a "native" helper function. The helper
2380         // function is expected to set topCallFrame itself with the ExecState
2381         // that is passed to it.
2382         //
2383         // We explicitly trash topCallFrame here so that we'll know if some of
2384         // the helper functions are not setting topCallFrame when they should
2385         // be doing so. Note: the previous value in topcallFrame was not valid
2386         // anyway since it was not being updated by JIT'ed code by design.
2387
2388         for (unsigned i = 0; i < sizeof(void*) / 4; i++)
2389             m_jit.store32(TrustedImm32(0xbadbeef), reinterpret_cast<char*>(&m_jit.vm()->topCallFrame) + i * 4);
2390     }
2391 #else
2392     void prepareForExternalCall() { }
2393 #endif
2394
2395     // These methods add call instructions, optionally setting results, and optionally rolling back the call frame on an exception.
2396     JITCompiler::Call appendCall(const FunctionPtr& function)
2397     {
2398         prepareForExternalCall();
2399         m_jit.emitStoreCodeOrigin(m_currentNode->origin.semantic);
2400         return m_jit.appendCall(function);
2401     }
2402     JITCompiler::Call appendCallWithCallFrameRollbackOnException(const FunctionPtr& function)
2403     {
2404         JITCompiler::Call call = appendCall(function);
2405         m_jit.exceptionCheckWithCallFrameRollback();
2406         return call;
2407     }
2408     JITCompiler::Call appendCallWithCallFrameRollbackOnExceptionSetResult(const FunctionPtr& function, GPRReg result)
2409     {
2410         JITCompiler::Call call = appendCallWithCallFrameRollbackOnException(function);
2411         if ((result != InvalidGPRReg) && (result != GPRInfo::returnValueGPR))
2412             m_jit.move(GPRInfo::returnValueGPR, result);
2413         return call;
2414     }
2415     JITCompiler::Call appendCallSetResult(const FunctionPtr& function, GPRReg result)
2416     {
2417         JITCompiler::Call call = appendCall(function);
2418         if (result != InvalidGPRReg)
2419             m_jit.move(GPRInfo::returnValueGPR, result);
2420         return call;
2421     }
2422     JITCompiler::Call appendCallSetResult(const FunctionPtr& function, GPRReg result1, GPRReg result2)
2423     {
2424         JITCompiler::Call call = appendCall(function);
2425         m_jit.setupResults(result1, result2);
2426         return call;
2427     }
2428 #if CPU(X86)
2429     JITCompiler::Call appendCallSetResult(const FunctionPtr& function, FPRReg result)
2430     {
2431         JITCompiler::Call call = appendCall(function);
2432         if (result != InvalidFPRReg) {
2433             m_jit.assembler().fstpl(0, JITCompiler::stackPointerRegister);
2434             m_jit.loadDouble(JITCompiler::stackPointerRegister, result);
2435         }
2436         return call;
2437     }
2438 #elif CPU(ARM) && !CPU(ARM_HARDFP)
2439     JITCompiler::Call appendCallSetResult(const FunctionPtr& function, FPRReg result)
2440     {
2441         JITCompiler::Call call = appendCall(function);
2442         if (result != InvalidFPRReg)
2443             m_jit.assembler().vmov(result, GPRInfo::returnValueGPR, GPRInfo::returnValueGPR2);
2444         return call;
2445     }
2446 #else // CPU(X86_64) || (CPU(ARM) && CPU(ARM_HARDFP)) || CPU(ARM64) || CPU(MIPS)
2447     JITCompiler::Call appendCallSetResult(const FunctionPtr& function, FPRReg result)
2448     {
2449         JITCompiler::Call call = appendCall(function);
2450         if (result != InvalidFPRReg)
2451             m_jit.moveDouble(FPRInfo::returnValueFPR, result);
2452         return call;
2453     }
2454 #endif
2455     
2456     void branchDouble(JITCompiler::DoubleCondition cond, FPRReg left, FPRReg right, BasicBlock* destination)
2457     {
2458         return addBranch(m_jit.branchDouble(cond, left, right), destination);
2459     }
2460     
2461     void branchDoubleNonZero(FPRReg value, FPRReg scratch, BasicBlock* destination)
2462     {
2463         return addBranch(m_jit.branchDoubleNonZero(value, scratch), destination);
2464     }
2465     
2466     template<typename T, typename U>
2467     void branch32(JITCompiler::RelationalCondition cond, T left, U right, BasicBlock* destination)
2468     {
2469         return addBranch(m_jit.branch32(cond, left, right), destination);
2470     }
2471     
2472     template<typename T, typename U>
2473     void branchTest32(JITCompiler::ResultCondition cond, T value, U mask, BasicBlock* destination)
2474     {
2475         return addBranch(m_jit.branchTest32(cond, value, mask), destination);
2476     }
2477     
2478     template<typename T>
2479     void branchTest32(JITCompiler::ResultCondition cond, T value, BasicBlock* destination)
2480     {
2481         return addBranch(m_jit.branchTest32(cond, value), destination);
2482     }
2483     
2484 #if USE(JSVALUE64)
2485     template<typename T, typename U>
2486     void branch64(JITCompiler::RelationalCondition cond, T left, U right, BasicBlock* destination)
2487     {
2488         return addBranch(m_jit.branch64(cond, left, right), destination);
2489     }
2490 #endif
2491     
2492     template<typename T, typename U>
2493     void branch8(JITCompiler::RelationalCondition cond, T left, U right, BasicBlock* destination)
2494     {
2495         return addBranch(m_jit.branch8(cond, left, right), destination);
2496     }
2497     
2498     template<typename T, typename U>
2499     void branchPtr(JITCompiler::RelationalCondition cond, T left, U right, BasicBlock* destination)
2500     {
2501         return addBranch(m_jit.branchPtr(cond, left, right), destination);
2502     }
2503     
2504     template<typename T, typename U>
2505     void branchTestPtr(JITCompiler::ResultCondition cond, T value, U mask, BasicBlock* destination)
2506     {
2507         return addBranch(m_jit.branchTestPtr(cond, value, mask), destination);
2508     }
2509     
2510     template<typename T>
2511     void branchTestPtr(JITCompiler::ResultCondition cond, T value, BasicBlock* destination)
2512     {
2513         return addBranch(m_jit.branchTestPtr(cond, value), destination);
2514     }
2515     
2516     template<typename T, typename U>
2517     void branchTest8(JITCompiler::ResultCondition cond, T value, U mask, BasicBlock* destination)
2518     {
2519         return addBranch(m_jit.branchTest8(cond, value, mask), destination);
2520     }
2521     
2522     template<typename T>
2523     void branchTest8(JITCompiler::ResultCondition cond, T value, BasicBlock* destination)
2524     {
2525         return addBranch(m_jit.branchTest8(cond, value), destination);
2526     }
2527     
2528     enum FallThroughMode {
2529         AtFallThroughPoint,
2530         ForceJump
2531     };
2532     void jump(BasicBlock* destination, FallThroughMode fallThroughMode = AtFallThroughPoint)
2533     {
2534         if (destination == nextBlock()
2535             && fallThroughMode == AtFallThroughPoint)
2536             return;
2537         addBranch(m_jit.jump(), destination);
2538     }
2539     
2540     void addBranch(const MacroAssembler::Jump& jump, BasicBlock* destination)
2541     {
2542         m_branches.append(BranchRecord(jump, destination));
2543     }
2544     void addBranch(const MacroAssembler::JumpList& jump, BasicBlock* destination);
2545
2546     void linkBranches();
2547
2548     void dump(const char* label = 0);
2549
2550     bool betterUseStrictInt52(Node* node)
2551     {
2552         return !generationInfo(node).isInt52();
2553     }
2554     bool betterUseStrictInt52(Edge edge)
2555     {
2556         return betterUseStrictInt52(edge.node());
2557     }
2558     
2559     bool compare(Node*, MacroAssembler::RelationalCondition, MacroAssembler::DoubleCondition, S_JITOperation_EJJ);
2560     bool compilePeepHoleBranch(Node*, MacroAssembler::RelationalCondition, MacroAssembler::DoubleCondition, S_JITOperation_EJJ);
2561     void compilePeepHoleInt32Branch(Node*, Node* branchNode, JITCompiler::RelationalCondition);
2562     void compilePeepHoleInt52Branch(Node*, Node* branchNode, JITCompiler::RelationalCondition);
2563     void compilePeepHoleBooleanBranch(Node*, Node* branchNode, JITCompiler::RelationalCondition);
2564     void compilePeepHoleDoubleBranch(Node*, Node* branchNode, JITCompiler::DoubleCondition);
2565     void compilePeepHoleObjectEquality(Node*, Node* branchNode);
2566     void compilePeepHoleObjectStrictEquality(Edge objectChild, Edge otherChild, Node* branchNode);
2567     void compilePeepHoleObjectToObjectOrOtherEquality(Edge leftChild, Edge rightChild, Node* branchNode);
2568     void compileObjectEquality(Node*);
2569     void compileObjectStrictEquality(Edge objectChild, Edge otherChild);
2570     void compileObjectToObjectOrOtherEquality(Edge leftChild, Edge rightChild);
2571     void compileObjectOrOtherLogicalNot(Edge value);
2572     void compileLogicalNot(Node*);
2573     void compileLogicalNotStringOrOther(Node*);
2574     void compileStringEquality(
2575         Node*, GPRReg leftGPR, GPRReg rightGPR, GPRReg lengthGPR,
2576         GPRReg leftTempGPR, GPRReg rightTempGPR, GPRReg leftTemp2GPR,
2577         GPRReg rightTemp2GPR, JITCompiler::JumpList fastTrue,
2578         JITCompiler::JumpList fastSlow);
2579     void compileStringEquality(Node*);
2580     void compileStringIdentEquality(Node*);
2581     void compileStringToUntypedEquality(Node*, Edge stringEdge, Edge untypedEdge);
2582     void compileStringIdentToNotStringVarEquality(Node*, Edge stringEdge, Edge notStringVarEdge);
2583     void compileStringZeroLength(Node*);
2584     void compileMiscStrictEq(Node*);
2585
2586     void compileSymbolEquality(Node*);
2587     void compilePeepHoleSymbolEquality(Node*, Node* branchNode);
2588     void compileSymbolUntypedEquality(Node*, Edge symbolEdge, Edge untypedEdge);
2589
2590     void emitObjectOrOtherBranch(Edge value, BasicBlock* taken, BasicBlock* notTaken);
2591     void emitStringBranch(Edge value, BasicBlock* taken, BasicBlock* notTaken);
2592     void emitStringOrOtherBranch(Edge value, BasicBlock* taken, BasicBlock* notTaken);
2593     void emitBranch(Node*);
2594     
2595     struct StringSwitchCase {
2596         StringSwitchCase() { }
2597         
2598         StringSwitchCase(StringImpl* string, BasicBlock* target)
2599             : string(string)
2600             , target(target)
2601         {
2602         }
2603         
2604         bool operator<(const StringSwitchCase& other) const
2605         {
2606             return stringLessThan(*string, *other.string);
2607         }
2608         
2609         StringImpl* string;
2610         BasicBlock* target;
2611     };
2612     
2613     void emitSwitchIntJump(SwitchData*, GPRReg value, GPRReg scratch);
2614     void emitSwitchImm(Node*, SwitchData*);
2615     void emitSwitchCharStringJump(SwitchData*, GPRReg value, GPRReg scratch);
2616     void emitSwitchChar(Node*, SwitchData*);
2617     void emitBinarySwitchStringRecurse(
2618         SwitchData*, const Vector<StringSwitchCase>&, unsigned numChecked,
2619         unsigned begin, unsigned end, GPRReg buffer, GPRReg length, GPRReg temp,
2620         unsigned alreadyCheckedLength, bool checkedExactLength);
2621     void emitSwitchStringOnString(SwitchData*, GPRReg string);
2622     void emitSwitchString(Node*, SwitchData*);
2623     void emitSwitch(Node*);
2624     
2625     void compileToStringOrCallStringConstructorOnCell(Node*);
2626     void compileNewStringObject(Node*);
2627     
2628     void compileNewTypedArray(Node*);
2629     
2630     void compileInt32Compare(Node*, MacroAssembler::RelationalCondition);
2631     void compileInt52Compare(Node*, MacroAssembler::RelationalCondition);
2632     void compileBooleanCompare(Node*, MacroAssembler::RelationalCondition);
2633     void compileDoubleCompare(Node*, MacroAssembler::DoubleCondition);
2634     void compileStringCompare(Node*, MacroAssembler::RelationalCondition);
2635     void compileStringIdentCompare(Node*, MacroAssembler::RelationalCondition);
2636     
2637     bool compileStrictEq(Node*);
2638     
2639     void compileAllocatePropertyStorage(Node*);
2640     void compileReallocatePropertyStorage(Node*);
2641     void compileNukeStructureAndSetButterfly(Node*);
2642     void compileGetButterfly(Node*);
2643     void compileCallDOMGetter(Node*);
2644     void compileCallDOM(Node*);
2645     void compileCheckDOM(Node*);
2646     
2647 #if USE(JSVALUE32_64)
2648     template<typename BaseOperandType, typename PropertyOperandType, typename ValueOperandType, typename TagType>
2649     void compileContiguousPutByVal(Node*, BaseOperandType&, PropertyOperandType&, ValueOperandType&, GPRReg valuePayloadReg, TagType valueTag);
2650 #endif
2651     void compileDoublePutByVal(Node*, SpeculateCellOperand& base, SpeculateStrictInt32Operand& property);
2652     bool putByValWillNeedExtraRegister(ArrayMode arrayMode)
2653     {
2654         return arrayMode.mayStoreToHole();
2655     }
2656     GPRReg temporaryRegisterForPutByVal(GPRTemporary&, ArrayMode);
2657     GPRReg temporaryRegisterForPutByVal(GPRTemporary& temporary, Node* node)
2658     {
2659         return temporaryRegisterForPutByVal(temporary, node->arrayMode());
2660     }
2661     
2662     void compileGetCharCodeAt(Node*);
2663     void compileGetByValOnString(Node*);
2664     void compileFromCharCode(Node*); 
2665
2666     void compileGetByValOnDirectArguments(Node*);
2667     void compileGetByValOnScopedArguments(Node*);
2668     
2669     void compileGetScope(Node*);
2670     void compileSkipScope(Node*);
2671     void compileGetGlobalObject(Node*);
2672
2673     void compileGetArrayLength(Node*);
2674
2675     void compileCheckTypeInfoFlags(Node*);
2676     void compileCheckStringIdent(Node*);
2677     
2678     void compileValueRep(Node*);
2679     void compileDoubleRep(Node*);
2680     
2681     void compileValueToInt32(Node*);
2682     void compileUInt32ToNumber(Node*);
2683     void compileDoubleAsInt32(Node*);
2684
2685     template<typename SnippetGenerator, J_JITOperation_EJJ slowPathFunction>
2686     void emitUntypedBitOp(Node*);
2687     void compileBitwiseOp(Node*);
2688
2689     void emitUntypedRightShiftBitOp(Node*);
2690     void compileShiftOp(Node*);
2691
2692     template <typename Generator, typename RepatchingFunction, typename NonRepatchingFunction>
2693     void compileMathIC(Node*, JITBinaryMathIC<Generator>*, bool needsScratchGPRReg, bool needsScratchFPRReg, RepatchingFunction, NonRepatchingFunction);
2694     template <typename Generator, typename RepatchingFunction, typename NonRepatchingFunction>
2695     void compileMathIC(Node*, JITUnaryMathIC<Generator>*, bool needsScratchGPRReg, RepatchingFunction, NonRepatchingFunction);
2696
2697     void compileArithDoubleUnaryOp(Node*, double (*doubleFunction)(double), double (*operation)(ExecState*, EncodedJSValue));
2698     void compileValueAdd(Node*);
2699     void compileArithAdd(Node*);
2700     void compileMakeRope(Node*);
2701     void compileArithAbs(Node*);
2702     void compileArithClz32(Node*);
2703     void compileArithCos(Node*);
2704     void compileArithTan(Node*);
2705     void compileArithSub(Node*);
2706     void compileArithNegate(Node*);
2707     void compileArithMul(Node*);
2708     void compileArithDiv(Node*);
2709     void compileArithFRound(Node*);
2710     void compileArithMod(Node*);
2711     void compileArithPow(Node*);
2712     void compileArithRounding(Node*);
2713     void compileArithRandom(Node*);
2714     void compileArithSin(Node*);
2715     void compileArithSqrt(Node*);
2716     void compileArithLog(Node*);
2717     void compileConstantStoragePointer(Node*);
2718     void compileGetIndexedPropertyStorage(Node*);
2719     JITCompiler::Jump jumpForTypedArrayOutOfBounds(Node*, GPRReg baseGPR, GPRReg indexGPR);
2720     JITCompiler::Jump jumpForTypedArrayIsNeuteredIfOutOfBounds(Node*, GPRReg baseGPR, JITCompiler::Jump outOfBounds);
2721     void emitTypedArrayBoundsCheck(Node*, GPRReg baseGPR, GPRReg indexGPR);
2722     void compileGetTypedArrayByteOffset(Node*);
2723     void compileGetByValOnIntTypedArray(Node*, TypedArrayType);
2724     void compilePutByValForIntTypedArray(GPRReg base, GPRReg property, Node*, TypedArrayType);
2725     void compileGetByValOnFloatTypedArray(Node*, TypedArrayType);
2726     void compilePutByValForFloatTypedArray(GPRReg base, GPRReg property, Node*, TypedArrayType);
2727     template <typename ClassType> void compileNewFunctionCommon(GPRReg, RegisteredStructure, GPRReg, GPRReg, GPRReg, MacroAssembler::JumpList&, size_t, FunctionExecutable*, ptrdiff_t, ptrdiff_t, ptrdiff_t);
2728     void compileNewFunction(Node*);
2729     void compileSetFunctionName(Node*);
2730     void compileForwardVarargs(Node*);
2731     void compileCreateActivation(Node*);
2732     void compileCreateDirectArguments(Node*);
2733     void compileGetFromArguments(Node*);
2734     void compilePutToArguments(Node*);
2735     void compileGetArgument(Node*);
2736     void compileCreateScopedArguments(Node*);
2737     void compileCreateClonedArguments(Node*);
2738     void compileCreateRest(Node*);
2739     void compileSpread(Node*);
2740     void compileNewArrayWithSpread(Node*);
2741     void compileGetRestLength(Node*);
2742     void compileArraySlice(Node*);
2743     void compileNotifyWrite(Node*);
2744     bool compileRegExpExec(Node*);
2745     void compileIsObjectOrNull(Node*);
2746     void compileIsFunction(Node*);
2747     void compileTypeOf(Node*);
2748     void compileCheckStructure(Node*, GPRReg cellGPR, GPRReg tempGPR);
2749     void compileCheckStructure(Node*);
2750     void compilePutAccessorById(Node*);
2751     void compilePutGetterSetterById(Node*);
2752     void compilePutAccessorByVal(Node*);
2753     void compileGetRegExpObjectLastIndex(Node*);
2754     void compileSetRegExpObjectLastIndex(Node*);
2755     void compileLazyJSConstant(Node*);
2756     void compileMaterializeNewObject(Node*);
2757     void compileRecordRegExpCachedResult(Node*);
2758     void compileCallObjectConstructor(Node*);
2759     void compileResolveScope(Node*);
2760     void compileGetDynamicVar(Node*);
2761     void compilePutDynamicVar(Node*);
2762     void compileCompareEqPtr(Node*);
2763     void compileDefineDataProperty(Node*);
2764     void compileDefineAccessorProperty(Node*);
2765     void compileToLowerCase(Node*);
2766
2767     void moveTrueTo(GPRReg);
2768     void moveFalseTo(GPRReg);
2769     void blessBoolean(GPRReg);
2770     
2771     // Allocator for a cell of a specific size.
2772     template <typename StructureType> // StructureType can be GPR or ImmPtr.
2773     void emitAllocateJSCell(
2774         GPRReg resultGPR, MarkedAllocator* allocator, GPRReg allocatorGPR, StructureType structure,
2775         GPRReg scratchGPR, MacroAssembler::JumpList& slowPath)
2776     {
2777         m_jit.emitAllocateJSCell(resultGPR, allocator, allocatorGPR, structure, scratchGPR, slowPath);
2778     }
2779
2780     // Allocator for an object of a specific size.
2781     template <typename StructureType, typename StorageType> // StructureType and StorageType can be GPR or ImmPtr.
2782     void emitAllocateJSObject(
2783         GPRReg resultGPR, MarkedAllocator* allocator, GPRReg allocatorGPR, StructureType structure,
2784         StorageType storage, GPRReg scratchGPR, MacroAssembler::JumpList& slowPath)
2785     {
2786         m_jit.emitAllocateJSObject(
2787             resultGPR, allocator, allocatorGPR, structure, storage, scratchGPR, slowPath);
2788     }
2789
2790     template <typename ClassType, typename StructureType, typename StorageType> // StructureType and StorageType can be GPR or ImmPtr.
2791     void emitAllocateJSObjectWithKnownSize(
2792         GPRReg resultGPR, StructureType structure, StorageType storage, GPRReg scratchGPR1,
2793         GPRReg scratchGPR2, MacroAssembler::JumpList& slowPath, size_t size)
2794     {
2795         m_jit.emitAllocateJSObjectWithKnownSize<ClassType>(resultGPR, structure, storage, scratchGPR1, scratchGPR2, slowPath, size);
2796     }
2797
2798     // Convenience allocator for a built-in object.
2799     template <typename ClassType, typename StructureType, typename StorageType> // StructureType and StorageType can be GPR or ImmPtr.
2800     void emitAllocateJSObject(GPRReg resultGPR, StructureType structure, StorageType storage,
2801         GPRReg scratchGPR1, GPRReg scratchGPR2, MacroAssembler::JumpList& slowPath)
2802     {
2803         m_jit.emitAllocateJSObject<ClassType>(resultGPR, structure, storage, scratchGPR1, scratchGPR2, slowPath);
2804     }
2805
2806     template <typename ClassType, typename StructureType> // StructureType and StorageType can be GPR or ImmPtr.
2807     void emitAllocateVariableSizedJSObject(GPRReg resultGPR, StructureType structure, GPRReg allocationSize, GPRReg scratchGPR1, GPRReg scratchGPR2, MacroAssembler::JumpList& slowPath)
2808     {
2809         m_jit.emitAllocateVariableSizedJSObject<ClassType>(resultGPR, structure, allocationSize, scratchGPR1, scratchGPR2, slowPath);
2810     }
2811
2812     template<typename ClassType>
2813     void emitAllocateDestructibleObject(GPRReg resultGPR, RegisteredStructure structure, 
2814         GPRReg scratchGPR1, GPRReg scratchGPR2, MacroAssembler::JumpList& slowPath)
2815     {
2816         m_jit.emitAllocateDestructibleObject<ClassType>(resultGPR, structure.get(), scratchGPR1, scratchGPR2, slowPath);
2817     }
2818
2819     void emitAllocateRawObject(GPRReg resultGPR, RegisteredStructure, GPRReg storageGPR, unsigned numElements, unsigned vectorLength);
2820     
2821     void emitGetLength(InlineCallFrame*, GPRReg lengthGPR, bool includeThis = false);
2822     void emitGetLength(CodeOrigin, GPRReg lengthGPR, bool includeThis = false);
2823     void emitGetCallee(CodeOrigin, GPRReg calleeGPR);
2824     void emitGetArgumentStart(CodeOrigin, GPRReg startGPR);
2825     
2826     // Generate an OSR exit fuzz check. Returns Jump() if OSR exit fuzz is not enabled, or if
2827     // it's in training mode.
2828     MacroAssembler::Jump emitOSRExitFuzzCheck();
2829     
2830     // Add a speculation check.
2831     void speculationCheck(ExitKind, JSValueSource, Node*, MacroAssembler::Jump jumpToFail);
2832     void speculationCheck(ExitKind, JSValueSource, Node*, const MacroAssembler::JumpList& jumpsToFail);
2833
2834     // Add a speculation check without additional recovery, and with a promise to supply a jump later.
2835     OSRExitJumpPlaceholder speculationCheck(ExitKind, JSValueSource, Node*);
2836     OSRExitJumpPlaceholder speculationCheck(ExitKind, JSValueSource, Edge);
2837     void speculationCheck(ExitKind, JSValueSource, Edge, MacroAssembler::Jump jumpToFail);
2838     void speculationCheck(ExitKind, JSValueSource, Edge, const MacroAssembler::JumpList& jumpsToFail);
2839     // Add a speculation check with additional recovery.
2840     void speculationCheck(ExitKind, JSValueSource, Node*, MacroAssembler::Jump jumpToFail, const SpeculationRecovery&);
2841     void speculationCheck(ExitKind, JSValueSource, Edge, MacroAssembler::Jump jumpToFail, const SpeculationRecovery&);
2842     
2843     void emitInvalidationPoint(Node*);
2844     
2845     void unreachable(Node*);
2846     
2847     // Called when we statically determine that a speculation will fail.
2848     void terminateSpeculativeExecution(ExitKind, JSValueRegs, Node*);
2849     void terminateSpeculativeExecution(ExitKind, JSValueRegs, Edge);
2850     
2851     // Helpers for performing type checks on an edge stored in the given registers.
2852     bool needsTypeCheck(Edge edge, SpeculatedType typesPassedThrough) { return m_interpreter.needsTypeCheck(edge, typesPassedThrough); }
2853     void typeCheck(JSValueSource, Edge, SpeculatedType typesPassedThrough, MacroAssembler::Jump jumpToFail, ExitKind = BadType);
2854     
2855     void speculateCellTypeWithoutTypeFiltering(Edge, GPRReg cellGPR, JSType);
2856     void speculateCellType(Edge, GPRReg cellGPR, SpeculatedType, JSType);
2857     
2858     void speculateInt32(Edge);
2859 #if USE(JSVALUE64)
2860     void convertAnyInt(Edge, GPRReg resultGPR);
2861     void speculateAnyInt(Edge);
2862     void speculateDoubleRepAnyInt(Edge);
2863 #endif // USE(JSVALUE64)
2864     void speculateNumber(Edge);
2865     void speculateRealNumber(Edge);
2866     void speculateDoubleRepReal(Edge);
2867     void speculateBoolean(Edge);
2868     void speculateCell(Edge);
2869     void speculateCellOrOther(Edge);
2870     void speculateObject(Edge);
2871     void speculateArray(Edge, GPRReg cell);
2872     void speculateArray(Edge);
2873     void speculateFunction(Edge);
2874     void speculateFinalObject(Edge);
2875     void speculateRegExpObject(Edge, GPRReg cell);
2876     void speculateRegExpObject(Edge);
2877     void speculateProxyObject(Edge, GPRReg cell);
2878     void speculateProxyObject(Edge);
2879     void speculateDerivedArray(Edge, GPRReg cell);
2880     void speculateDerivedArray(Edge);
2881     void speculateMapObject(Edge);
2882     void speculateMapObject(Edge, GPRReg cell);
2883     void speculateSetObject(Edge);
2884     void speculateSetObject(Edge, GPRReg cell);
2885     void speculateObjectOrOther(Edge);
2886     void speculateString(Edge edge, GPRReg cell);
2887     void speculateStringIdentAndLoadStorage(Edge edge, GPRReg string, GPRReg storage);
2888     void speculateStringIdent(Edge edge, GPRReg string);
2889     void speculateStringIdent(Edge);
2890     void speculateString(Edge);
2891     void speculateStringOrOther(Edge, JSValueRegs, GPRReg scratch);
2892     void speculateStringOrOther(Edge);
2893     void speculateNotStringVar(Edge);
2894     template<typename StructureLocationType>
2895     void speculateStringObjectForStructure(Edge, StructureLocationType);
2896     void speculateStringObject(Edge, GPRReg);
2897     void speculateStringObject(Edge);
2898     void speculateStringOrStringObject(Edge);
2899     void speculateSymbol(Edge, GPRReg cell);
2900     void speculateSymbol(Edge);
2901     void speculateNotCell(Edge);
2902     void speculateOther(Edge);
2903     void speculateMisc(Edge, JSValueRegs);
2904     void speculateMisc(Edge);
2905     void speculate(Node*, Edge);
2906     
2907     JITCompiler::Jump jumpSlowForUnwantedArrayMode(GPRReg tempWithIndexingTypeReg, ArrayMode, IndexingType);
2908     JITCompiler::JumpList jumpSlowForUnwantedArrayMode(GPRReg tempWithIndexingTypeReg, ArrayMode);
2909     void checkArray(Node*);
2910     void arrayify(Node*, GPRReg baseReg, GPRReg propertyReg);
2911     void arrayify(Node*);
2912     
2913     template<bool strict>
2914     GPRReg fillSpeculateInt32Internal(Edge, DataFormat& returnFormat);
2915     
2916     // It is possible, during speculative generation, to reach a situation in which we
2917     // can statically determine a speculation will fail (for example, when two nodes
2918     // will make conflicting speculations about the same operand). In such cases this
2919     // flag is cleared, indicating no further code generation should take place.
2920     bool m_compileOkay;
2921     
2922     void recordSetLocal(
2923         VirtualRegister bytecodeReg, VirtualRegister machineReg, DataFormat format)
2924     {
2925         m_stream->appendAndLog(VariableEvent::setLocal(bytecodeReg, machineReg, format));
2926     }
2927     
2928     void recordSetLocal(DataFormat format)
2929     {
2930         VariableAccessData* variable = m_currentNode->variableAccessData();
2931         recordSetLocal(variable->local(), variable->machineLocal(), format);
2932     }
2933
2934     GenerationInfo& generationInfoFromVirtualRegister(VirtualRegister virtualRegister)
2935     {
2936         return m_generationInfo[virtualRegister.toLocal()];
2937     }
2938     
2939     GenerationInfo& generationInfo(Node* node)
2940     {
2941         return generationInfoFromVirtualRegister(node->virtualRegister());
2942     }
2943     
2944     GenerationInfo& generationInfo(Edge edge)
2945     {
2946         return generationInfo(edge.node());
2947     }
2948
2949     // The JIT, while also provides MacroAssembler functionality.
2950     JITCompiler& m_jit;
2951
2952     // The current node being generated.
2953     BasicBlock* m_block;
2954     Node* m_currentNode;
2955     NodeType m_lastGeneratedNode;
2956     unsigned m_indexInBlock;
2957     // Virtual and physical register maps.
2958     Vector<GenerationInfo, 32> m_generationInfo;
2959     RegisterBank<GPRInfo> m_gprs;
2960     RegisterBank<FPRInfo> m_fprs;
2961
2962     Vector<MacroAssembler::Label> m_osrEntryHeads;
2963     
2964     struct BranchRecord {
2965         BranchRecord(MacroAssembler::Jump jump, BasicBlock* destination)
2966             : jump(jump)
2967             , destination(destination)
2968         {
2969         }
2970
2971         MacroAssembler::Jump jump;
2972         BasicBlock* destination;
2973     };
2974     Vector<BranchRecord, 8> m_branches;
2975
2976     NodeOrigin m_origin;
2977     
2978     InPlaceAbstractState m_state;
2979     AbstractInterpreter<InPlaceAbstractState> m_interpreter;
2980     
2981     VariableEventStream* m_stream;
2982     MinifiedGraph* m_minifiedGraph;
2983     
2984     Vector<std::unique_ptr<SlowPathGenerator>, 8> m_slowPathGenerators;
2985     struct SlowPathLambda {
2986         std::function<void()> generator;
2987         Node* currentNode;
2988         unsigned streamIndex;
2989     };
2990     Vector<SlowPathLambda> m_slowPathLambdas;
2991     Vector<SilentRegisterSavePlan> m_plans;
2992     std::optional<unsigned> m_outOfLineStreamIndex;
2993 };
2994
2995
2996 // === Operand types ===
2997 //
2998 // These classes are used to lock the operands to a node into machine
2999 // registers. These classes implement of pattern of locking a value
3000 // into register at the point of construction only if it is already in
3001 // registers, and otherwise loading it lazily at the point it is first
3002 // used. We do so in order to attempt to avoid spilling one operand
3003 // in order to make space available for another.
3004
3005 class JSValueOperand {
3006 public:
3007     explicit JSValueOperand(SpeculativeJIT* jit, Edge edge, OperandSpeculationMode mode = AutomaticOperandSpeculation)
3008         : m_jit(jit)
3009         , m_edge(edge)
3010 #if USE(JSVALUE64)
3011         , m_gprOrInvalid(InvalidGPRReg)
3012 #elif USE(JSVALUE32_64)
3013         , m_isDouble(false)
3014 #endif
3015     {
3016         ASSERT(m_jit);
3017         if (!edge)
3018             return;
3019         ASSERT_UNUSED(mode, mode == ManualOperandSpeculation || edge.useKind() == UntypedUse);
3020 #if USE(JSVALUE64)
3021         if (jit->isFilled(node()))
3022             gpr();
3023 #elif USE(JSVALUE32_64)
3024         m_register.pair.tagGPR = InvalidGPRReg;
3025         m_register.pair.payloadGPR = InvalidGPRReg;
3026         if (jit->isFilled(node()))
3027             fill();
3028 #endif
3029     }
3030
3031     explicit JSValueOperand(JSValueOperand&& other)
3032         : m_jit(other.m_jit)
3033         , m_edge(other.m_edge)
3034     {
3035 #if USE(JSVALUE64)
3036         m_gprOrInvalid = other.m_gprOrInvalid;
3037 #elif USE(JSVALUE32_64)
3038         m_register.pair.tagGPR = InvalidGPRReg;
3039         m_register.pair.payloadGPR = InvalidGPRReg;
3040         m_isDouble = other.m_isDouble;
3041
3042         if (m_edge) {
3043             if (m_isDouble)
3044                 m_register.fpr = other.m_register.fpr;
3045             else
3046                 m_register.pair = other.m_register.pair;
3047         }
3048 #endif
3049         other.m_edge = Edge();
3050 #if USE(JSVALUE64)
3051         other.m_gprOrInvalid = InvalidGPRReg;
3052 #elif USE(JSVALUE32_64)
3053         other.m_isDouble = false;
3054 #endif
3055     }
3056
3057     ~JSValueOperand()
3058     {
3059         if (!m_edge)
3060             return;
3061 #if USE(JSVALUE64)
3062         ASSERT(m_gprOrInvalid != InvalidGPRReg);
3063         m_jit->unlock(m_gprOrInvalid);
3064 #elif USE(JSVALUE32_64)
3065         if (m_isDouble) {
3066             ASSERT(m_register.fpr != InvalidFPRReg);
3067             m_jit->unlock(m_register.fpr);
3068         } else {
3069             ASSERT(m_register.pair.tagGPR != InvalidGPRReg && m_register.pair.payloadGPR != InvalidGPRReg);
3070             m_jit->unlock(m_register.pair.tagGPR);
3071             m_jit->unlock(m_register.pair.payloadGPR);
3072         }
3073 #endif
3074     }
3075     
3076     Edge edge() const
3077     {
3078         return m_edge;
3079     }
3080
3081     Node* node() const
3082     {
3083         return edge().node();
3084     }
3085
3086 #if USE(JSVALUE64)
3087     GPRReg gpr()
3088     {
3089         if (m_gprOrInvalid == InvalidGPRReg)
3090             m_gprOrInvalid = m_jit->fillJSValue(m_edge);
3091         return m_gprOrInvalid;
3092     }
3093     JSValueRegs jsValueRegs()
3094     {
3095         return JSValueRegs(gpr());
3096     }
3097 #elif USE(JSVALUE32_64)
3098     bool isDouble() { return m_isDouble; }
3099
3100     void fill()
3101     {
3102         if (m_register.pair.tagGPR == InvalidGPRReg && m_register.pair.payloadGPR == InvalidGPRReg)
3103             m_isDouble = !m_jit->fillJSValue(m_edge, m_register.pair.tagGPR, m_register.pair.payloadGPR, m_register.fpr);
3104     }
3105
3106     GPRReg tagGPR()
3107     {
3108         fill();
3109         ASSERT(!m_isDouble);
3110         return m_register.pair.tagGPR;
3111     } 
3112
3113     GPRReg payloadGPR()
3114     {
3115         fill();
3116         ASSERT(!m_isDouble);
3117         return m_register.pair.payloadGPR;
3118     }
3119     
3120     JSValueRegs jsValueRegs()
3121     {
3122         return JSValueRegs(tagGPR(), payloadGPR());
3123     }
3124
3125     GPRReg gpr(WhichValueWord which)
3126     {
3127         return jsValueRegs().gpr(which);
3128     }
3129
3130     FPRReg fpr()
3131     {
3132         fill();
3133         ASSERT(m_isDouble);
3134         return m_register.fpr;
3135     }
3136 #endif
3137
3138     void use()
3139     {
3140         m_jit->use(node());
3141     }
3142
3143 private:
3144     SpeculativeJIT* m_jit;
3145     Edge m_edge;
3146 #if USE(JSVALUE64)
3147     GPRReg m_gprOrInvalid;
3148 #elif USE(JSVALUE32_64)
3149     union {
3150         struct {
3151             GPRReg tagGPR;
3152             GPRReg payloadGPR;
3153         } pair;
3154         FPRReg fpr;
3155     } m_register;
3156     bool m_isDouble;
3157 #endif
3158 };
3159
3160 class StorageOperand {
3161 public:
3162     explicit StorageOperand(SpeculativeJIT* jit, Edge edge)
3163         : m_jit(jit)
3164         , m_edge(edge)
3165         , m_gprOrInvalid(InvalidGPRReg)
3166     {
3167         ASSERT(m_jit);
3168         ASSERT(edge.useKind() == UntypedUse || edge.useKind() == KnownCellUse);
3169         if (jit->isFilled(node()))
3170             gpr();
3171     }
3172     
3173     ~StorageOperand()
3174     {
3175         ASSERT(m_gprOrInvalid != InvalidGPRReg);
3176         m_jit->unlock(m_gprOrInvalid);
3177     }
3178     
3179     Edge edge() const
3180     {
3181         return m_edge;
3182     }
3183     
3184     Node* node() const
3185     {
3186         return edge().node();
3187     }
3188     
3189     GPRReg gpr()
3190     {
3191         if (m_gprOrInvalid == InvalidGPRReg)
3192             m_gprOrInvalid = m_jit->fillStorage(edge());
3193         return m_gprOrInvalid;
3194     }
3195     
3196     void use()
3197     {
3198         m_jit->use(node());
3199     }
3200     
3201 private:
3202     SpeculativeJIT* m_jit;
3203     Edge m_edge;
3204     GPRReg m_gprOrInvalid;
3205 };
3206
3207
3208 // === Temporaries ===
3209 //
3210 // These classes are used to allocate temporary registers.
3211 // A mechanism is provided to attempt to reuse the registers
3212 // currently allocated to child nodes whose value is consumed
3213 // by, and not live after, this operation.
3214
3215 enum ReuseTag { Reuse };
3216
3217 class GPRTemporary {
3218 public:
3219     GPRTemporary();
3220     GPRTemporary(SpeculativeJIT*);
3221     GPRTemporary(SpeculativeJIT*, GPRReg specific);
3222     template<typename T>
3223     GPRTemporary(SpeculativeJIT* jit, ReuseTag, T& operand)
3224         : m_jit(jit)
3225         , m_gpr(InvalidGPRReg)
3226     {
3227         if (m_jit->canReuse(operand.node()))
3228             m_gpr = m_jit->reuse(operand.gpr());
3229         else
3230             m_gpr = m_jit->allocate();
3231     }
3232     template<typename T1, typename T2>
3233     GPRTemporary(SpeculativeJIT* jit, ReuseTag, T1& op1, T2& op2)
3234         : m_jit(jit)
3235         , m_gpr(InvalidGPRReg)
3236     {
3237         if (m_jit->canReuse(op1.node()))
3238             m_gpr = m_jit->reuse(op1.gpr());
3239         else if (m_jit->canReuse(op2.node()))
3240             m_gpr = m_jit->reuse(op2.gpr());
3241         else if (m_jit->canReuse(op1.node(), op2.node()) && op1.gpr() == op2.gpr())
3242             m_gpr = m_jit->reuse(op1.gpr());
3243         else
3244             m_gpr = m_jit->allocate();
3245     }
3246 #if USE(JSVALUE32_64)
3247     GPRTemporary(SpeculativeJIT*, ReuseTag, JSValueOperand&, WhichValueWord);
3248 #endif
3249
3250     GPRTemporary(GPRTemporary& other) = delete;
3251
3252     GPRTemporary(GPRTemporary&& other)
3253     {
3254         ASSERT(other.m_jit);
3255         ASSERT(other.m_gpr != InvalidGPRReg);
3256         m_jit = other.m_jit;
3257         m_gpr = other.m_gpr;
3258         other.m_jit = nullptr;
3259         other.m_gpr = InvalidGPRReg;
3260     }
3261
3262     GPRTemporary& operator=(GPRTemporary&& other)
3263     {
3264         ASSERT(!m_jit);
3265         ASSERT(m_gpr == InvalidGPRReg);
3266         std::swap(m_jit, other.m_jit);
3267         std::swap(m_gpr, other.m_gpr);
3268         return *this;
3269     }
3270
3271     void adopt(GPRTemporary&);
3272
3273     ~GPRTemporary()
3274     {
3275         if (m_jit && m_gpr != InvalidGPRReg)
3276             m_jit->unlock(gpr());
3277     }
3278
3279     GPRReg gpr()
3280     {
3281         return m_gpr;
3282     }
3283
3284 private:
3285     SpeculativeJIT* m_jit;
3286     GPRReg m_gpr;
3287 };
3288
3289 class JSValueRegsTemporary {
3290 public:
3291     JSValueRegsTemporary();
3292     JSValueRegsTemporary(SpeculativeJIT*);
3293     template<typename T>
3294     JSValueRegsTemporary(SpeculativeJIT*, ReuseTag, T& operand, WhichValueWord resultRegWord = PayloadWord);
3295     JSValueRegsTemporary(SpeculativeJIT*, ReuseTag, JSValueOperand&);
3296     ~JSValueRegsTemporary();
3297     
3298     JSValueRegs regs();
3299
3300 private:
3301 #if USE(JSVALUE64)
3302     GPRTemporary m_gpr;
3303 #else
3304     GPRTemporary m_payloadGPR;
3305     GPRTemporary m_tagGPR;
3306 #endif
3307 };
3308
3309 class FPRTemporary {
3310     WTF_MAKE_NONCOPYABLE(FPRTemporary);
3311 public:
3312     FPRTemporary(FPRTemporary&&);
3313     FPRTemporary(SpeculativeJIT*);
3314     FPRTemporary(SpeculativeJIT*, SpeculateDoubleOperand&);
3315     FPRTemporary(SpeculativeJIT*, SpeculateDoubleOperand&, SpeculateDoubleOperand&);
3316 #if USE(JSVALUE32_64)
3317     FPRTemporary(SpeculativeJIT*, JSValueOperand&);
3318 #endif
3319
3320     ~FPRTemporary()
3321     {
3322         if (LIKELY(m_jit))
3323             m_jit->unlock(fpr());
3324     }
3325
3326     FPRReg fpr() const
3327     {
3328         ASSERT(m_jit);
3329         ASSERT(m_fpr != InvalidFPRReg);
3330         return m_fpr;
3331     }
3332
3333 protected:
3334     FPRTemporary(SpeculativeJIT* jit, FPRReg lockedFPR)
3335         : m_jit(jit)
3336         , m_fpr(lockedFPR)
3337     {
3338     }
3339
3340 private:
3341     SpeculativeJIT* m_jit;
3342     FPRReg m_fpr;
3343 };
3344
3345
3346 // === Results ===
3347 //
3348 // These classes lock the result of a call to a C++ helper function.
3349
3350 class GPRFlushedCallResult : public GPRTemporary {
3351 public:
3352     GPRFlushedCallResult(SpeculativeJIT* jit)
3353         : GPRTemporary(jit, GPRInfo::returnValueGPR)
3354     {
3355     }
3356 };
3357
3358 #if USE(JSVALUE32_64)
3359 class GPRFlushedCallResult2 : public GPRTemporary {
3360 public:
3361     GPRFlushedCallResult2(SpeculativeJIT* jit)
3362         : GPRTemporary(jit, GPRInfo::returnValueGPR2)
3363     {
3364     }