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