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