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