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