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