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