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