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