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