Make JetStream 2
[WebKit-https.git] / PerformanceTests / JetStream2 / ARES-6 / Air / opcode.js
1 "use strict";
2 // Generated by opcode_generator.rb from JavaScriptCore/b3/air/AirOpcode.opcodes -- do not edit!
3 const Nop = Symbol("Nop");
4 const Add32 = Symbol("Add32");
5 const Add8 = Symbol("Add8");
6 const Add16 = Symbol("Add16");
7 const Add64 = Symbol("Add64");
8 const AddDouble = Symbol("AddDouble");
9 const AddFloat = Symbol("AddFloat");
10 const Sub32 = Symbol("Sub32");
11 const Sub64 = Symbol("Sub64");
12 const SubDouble = Symbol("SubDouble");
13 const SubFloat = Symbol("SubFloat");
14 const Neg32 = Symbol("Neg32");
15 const Neg64 = Symbol("Neg64");
16 const NegateDouble = Symbol("NegateDouble");
17 const Mul32 = Symbol("Mul32");
18 const Mul64 = Symbol("Mul64");
19 const MultiplyAdd32 = Symbol("MultiplyAdd32");
20 const MultiplyAdd64 = Symbol("MultiplyAdd64");
21 const MultiplySub32 = Symbol("MultiplySub32");
22 const MultiplySub64 = Symbol("MultiplySub64");
23 const MultiplyNeg32 = Symbol("MultiplyNeg32");
24 const MultiplyNeg64 = Symbol("MultiplyNeg64");
25 const Div32 = Symbol("Div32");
26 const Div64 = Symbol("Div64");
27 const MulDouble = Symbol("MulDouble");
28 const MulFloat = Symbol("MulFloat");
29 const DivDouble = Symbol("DivDouble");
30 const DivFloat = Symbol("DivFloat");
31 const X86ConvertToDoubleWord32 = Symbol("X86ConvertToDoubleWord32");
32 const X86ConvertToQuadWord64 = Symbol("X86ConvertToQuadWord64");
33 const X86Div32 = Symbol("X86Div32");
34 const X86Div64 = Symbol("X86Div64");
35 const Lea = Symbol("Lea");
36 const And32 = Symbol("And32");
37 const And64 = Symbol("And64");
38 const AndDouble = Symbol("AndDouble");
39 const AndFloat = Symbol("AndFloat");
40 const XorDouble = Symbol("XorDouble");
41 const XorFloat = Symbol("XorFloat");
42 const Lshift32 = Symbol("Lshift32");
43 const Lshift64 = Symbol("Lshift64");
44 const Rshift32 = Symbol("Rshift32");
45 const Rshift64 = Symbol("Rshift64");
46 const Urshift32 = Symbol("Urshift32");
47 const Urshift64 = Symbol("Urshift64");
48 const Or32 = Symbol("Or32");
49 const Or64 = Symbol("Or64");
50 const Xor32 = Symbol("Xor32");
51 const Xor64 = Symbol("Xor64");
52 const Not32 = Symbol("Not32");
53 const Not64 = Symbol("Not64");
54 const AbsDouble = Symbol("AbsDouble");
55 const AbsFloat = Symbol("AbsFloat");
56 const CeilDouble = Symbol("CeilDouble");
57 const CeilFloat = Symbol("CeilFloat");
58 const FloorDouble = Symbol("FloorDouble");
59 const FloorFloat = Symbol("FloorFloat");
60 const SqrtDouble = Symbol("SqrtDouble");
61 const SqrtFloat = Symbol("SqrtFloat");
62 const ConvertInt32ToDouble = Symbol("ConvertInt32ToDouble");
63 const ConvertInt64ToDouble = Symbol("ConvertInt64ToDouble");
64 const ConvertInt32ToFloat = Symbol("ConvertInt32ToFloat");
65 const ConvertInt64ToFloat = Symbol("ConvertInt64ToFloat");
66 const CountLeadingZeros32 = Symbol("CountLeadingZeros32");
67 const CountLeadingZeros64 = Symbol("CountLeadingZeros64");
68 const ConvertDoubleToFloat = Symbol("ConvertDoubleToFloat");
69 const ConvertFloatToDouble = Symbol("ConvertFloatToDouble");
70 const Move = Symbol("Move");
71 const Swap32 = Symbol("Swap32");
72 const Swap64 = Symbol("Swap64");
73 const Move32 = Symbol("Move32");
74 const StoreZero32 = Symbol("StoreZero32");
75 const SignExtend32ToPtr = Symbol("SignExtend32ToPtr");
76 const ZeroExtend8To32 = Symbol("ZeroExtend8To32");
77 const SignExtend8To32 = Symbol("SignExtend8To32");
78 const ZeroExtend16To32 = Symbol("ZeroExtend16To32");
79 const SignExtend16To32 = Symbol("SignExtend16To32");
80 const MoveFloat = Symbol("MoveFloat");
81 const MoveDouble = Symbol("MoveDouble");
82 const MoveZeroToDouble = Symbol("MoveZeroToDouble");
83 const Move64ToDouble = Symbol("Move64ToDouble");
84 const Move32ToFloat = Symbol("Move32ToFloat");
85 const MoveDoubleTo64 = Symbol("MoveDoubleTo64");
86 const MoveFloatTo32 = Symbol("MoveFloatTo32");
87 const Load8 = Symbol("Load8");
88 const Store8 = Symbol("Store8");
89 const Load8SignedExtendTo32 = Symbol("Load8SignedExtendTo32");
90 const Load16 = Symbol("Load16");
91 const Load16SignedExtendTo32 = Symbol("Load16SignedExtendTo32");
92 const Store16 = Symbol("Store16");
93 const Compare32 = Symbol("Compare32");
94 const Compare64 = Symbol("Compare64");
95 const Test32 = Symbol("Test32");
96 const Test64 = Symbol("Test64");
97 const CompareDouble = Symbol("CompareDouble");
98 const CompareFloat = Symbol("CompareFloat");
99 const Branch8 = Symbol("Branch8");
100 const Branch32 = Symbol("Branch32");
101 const Branch64 = Symbol("Branch64");
102 const BranchTest8 = Symbol("BranchTest8");
103 const BranchTest32 = Symbol("BranchTest32");
104 const BranchTest64 = Symbol("BranchTest64");
105 const BranchDouble = Symbol("BranchDouble");
106 const BranchFloat = Symbol("BranchFloat");
107 const BranchAdd32 = Symbol("BranchAdd32");
108 const BranchAdd64 = Symbol("BranchAdd64");
109 const BranchMul32 = Symbol("BranchMul32");
110 const BranchMul64 = Symbol("BranchMul64");
111 const BranchSub32 = Symbol("BranchSub32");
112 const BranchSub64 = Symbol("BranchSub64");
113 const BranchNeg32 = Symbol("BranchNeg32");
114 const BranchNeg64 = Symbol("BranchNeg64");
115 const MoveConditionally32 = Symbol("MoveConditionally32");
116 const MoveConditionally64 = Symbol("MoveConditionally64");
117 const MoveConditionallyTest32 = Symbol("MoveConditionallyTest32");
118 const MoveConditionallyTest64 = Symbol("MoveConditionallyTest64");
119 const MoveConditionallyDouble = Symbol("MoveConditionallyDouble");
120 const MoveConditionallyFloat = Symbol("MoveConditionallyFloat");
121 const MoveDoubleConditionally32 = Symbol("MoveDoubleConditionally32");
122 const MoveDoubleConditionally64 = Symbol("MoveDoubleConditionally64");
123 const MoveDoubleConditionallyTest32 = Symbol("MoveDoubleConditionallyTest32");
124 const MoveDoubleConditionallyTest64 = Symbol("MoveDoubleConditionallyTest64");
125 const MoveDoubleConditionallyDouble = Symbol("MoveDoubleConditionallyDouble");
126 const MoveDoubleConditionallyFloat = Symbol("MoveDoubleConditionallyFloat");
127 const Jump = Symbol("Jump");
128 const Ret32 = Symbol("Ret32");
129 const Ret64 = Symbol("Ret64");
130 const RetFloat = Symbol("RetFloat");
131 const RetDouble = Symbol("RetDouble");
132 const Oops = Symbol("Oops");
133 const Shuffle = Symbol("Shuffle");
134 const Patch = Symbol("Patch");
135 const CCall = Symbol("CCall");
136 const ColdCCall = Symbol("ColdCCall");
137 function Inst_forEachArg(inst, func)
138 {
139     let replacement;
140     switch (inst.opcode) {
141     case Nop:
142         break;
143         break;
144     case Add32:
145         switch (inst.args.length) {
146         case 3:
147             inst.visitArg(0, func, Arg.Use, GP, 32);
148             inst.visitArg(1, func, Arg.Use, GP, 32);
149             inst.visitArg(2, func, Arg.ZDef, GP, 32);
150             break;
151         case 2:
152             inst.visitArg(0, func, Arg.Use, GP, 32);
153             inst.visitArg(1, func, Arg.UseZDef, GP, 32);
154             break;
155         default:
156             throw new Error("Bad overload");
157             break;
158         }
159         break;
160     case Add8:
161         inst.visitArg(0, func, Arg.Use, GP, 8);
162         inst.visitArg(1, func, Arg.UseDef, GP, 8);
163         break;
164         break;
165     case Add16:
166         inst.visitArg(0, func, Arg.Use, GP, 16);
167         inst.visitArg(1, func, Arg.UseDef, GP, 16);
168         break;
169         break;
170     case Add64:
171         switch (inst.args.length) {
172         case 2:
173             inst.visitArg(0, func, Arg.Use, GP, 64);
174             inst.visitArg(1, func, Arg.UseDef, GP, 64);
175             break;
176         case 3:
177             inst.visitArg(0, func, Arg.Use, GP, 64);
178             inst.visitArg(1, func, Arg.Use, GP, 64);
179             inst.visitArg(2, func, Arg.Def, GP, 64);
180             break;
181         default:
182             throw new Error("Bad overload");
183             break;
184         }
185         break;
186     case AddDouble:
187         switch (inst.args.length) {
188         case 3:
189             inst.visitArg(0, func, Arg.Use, FP, 64);
190             inst.visitArg(1, func, Arg.Use, FP, 64);
191             inst.visitArg(2, func, Arg.Def, FP, 64);
192             break;
193         case 2:
194             inst.visitArg(0, func, Arg.Use, FP, 64);
195             inst.visitArg(1, func, Arg.UseDef, FP, 64);
196             break;
197         default:
198             throw new Error("Bad overload");
199             break;
200         }
201         break;
202     case AddFloat:
203         switch (inst.args.length) {
204         case 3:
205             inst.visitArg(0, func, Arg.Use, FP, 32);
206             inst.visitArg(1, func, Arg.Use, FP, 32);
207             inst.visitArg(2, func, Arg.Def, FP, 32);
208             break;
209         case 2:
210             inst.visitArg(0, func, Arg.Use, FP, 32);
211             inst.visitArg(1, func, Arg.UseDef, FP, 32);
212             break;
213         default:
214             throw new Error("Bad overload");
215             break;
216         }
217         break;
218     case Sub32:
219         inst.visitArg(0, func, Arg.Use, GP, 32);
220         inst.visitArg(1, func, Arg.UseZDef, GP, 32);
221         break;
222         break;
223     case Sub64:
224         inst.visitArg(0, func, Arg.Use, GP, 64);
225         inst.visitArg(1, func, Arg.UseDef, GP, 64);
226         break;
227         break;
228     case SubDouble:
229         switch (inst.args.length) {
230         case 3:
231             inst.visitArg(0, func, Arg.Use, FP, 64);
232             inst.visitArg(1, func, Arg.Use, FP, 64);
233             inst.visitArg(2, func, Arg.Def, FP, 64);
234             break;
235         case 2:
236             inst.visitArg(0, func, Arg.Use, FP, 64);
237             inst.visitArg(1, func, Arg.UseDef, FP, 64);
238             break;
239         default:
240             throw new Error("Bad overload");
241             break;
242         }
243         break;
244     case SubFloat:
245         switch (inst.args.length) {
246         case 3:
247             inst.visitArg(0, func, Arg.Use, FP, 32);
248             inst.visitArg(1, func, Arg.Use, FP, 32);
249             inst.visitArg(2, func, Arg.Def, FP, 32);
250             break;
251         case 2:
252             inst.visitArg(0, func, Arg.Use, FP, 32);
253             inst.visitArg(1, func, Arg.UseDef, FP, 32);
254             break;
255         default:
256             throw new Error("Bad overload");
257             break;
258         }
259         break;
260     case Neg32:
261         inst.visitArg(0, func, Arg.UseZDef, GP, 32);
262         break;
263         break;
264     case Neg64:
265         inst.visitArg(0, func, Arg.UseDef, GP, 64);
266         break;
267         break;
268     case NegateDouble:
269         inst.visitArg(0, func, Arg.Use, FP, 64);
270         inst.visitArg(1, func, Arg.Def, FP, 64);
271         break;
272         break;
273     case Mul32:
274         switch (inst.args.length) {
275         case 2:
276             inst.visitArg(0, func, Arg.Use, GP, 32);
277             inst.visitArg(1, func, Arg.UseZDef, GP, 32);
278             break;
279         case 3:
280             inst.visitArg(0, func, Arg.Use, GP, 32);
281             inst.visitArg(1, func, Arg.Use, GP, 32);
282             inst.visitArg(2, func, Arg.ZDef, GP, 32);
283             break;
284         default:
285             throw new Error("Bad overload");
286             break;
287         }
288         break;
289     case Mul64:
290         switch (inst.args.length) {
291         case 2:
292             inst.visitArg(0, func, Arg.Use, GP, 64);
293             inst.visitArg(1, func, Arg.UseDef, GP, 64);
294             break;
295         case 3:
296             inst.visitArg(0, func, Arg.Use, GP, 64);
297             inst.visitArg(1, func, Arg.Use, GP, 64);
298             inst.visitArg(2, func, Arg.Def, GP, 64);
299             break;
300         default:
301             throw new Error("Bad overload");
302             break;
303         }
304         break;
305     case MultiplyAdd32:
306         inst.visitArg(0, func, Arg.Use, GP, 32);
307         inst.visitArg(1, func, Arg.Use, GP, 32);
308         inst.visitArg(2, func, Arg.Use, GP, 32);
309         inst.visitArg(3, func, Arg.ZDef, GP, 32);
310         break;
311         break;
312     case MultiplyAdd64:
313         inst.visitArg(0, func, Arg.Use, GP, 64);
314         inst.visitArg(1, func, Arg.Use, GP, 64);
315         inst.visitArg(2, func, Arg.Use, GP, 64);
316         inst.visitArg(3, func, Arg.Def, GP, 64);
317         break;
318         break;
319     case MultiplySub32:
320         inst.visitArg(0, func, Arg.Use, GP, 32);
321         inst.visitArg(1, func, Arg.Use, GP, 32);
322         inst.visitArg(2, func, Arg.Use, GP, 32);
323         inst.visitArg(3, func, Arg.ZDef, GP, 32);
324         break;
325         break;
326     case MultiplySub64:
327         inst.visitArg(0, func, Arg.Use, GP, 64);
328         inst.visitArg(1, func, Arg.Use, GP, 64);
329         inst.visitArg(2, func, Arg.Use, GP, 64);
330         inst.visitArg(3, func, Arg.Def, GP, 64);
331         break;
332         break;
333     case MultiplyNeg32:
334         inst.visitArg(0, func, Arg.Use, GP, 32);
335         inst.visitArg(1, func, Arg.Use, GP, 32);
336         inst.visitArg(2, func, Arg.ZDef, GP, 32);
337         break;
338         break;
339     case MultiplyNeg64:
340         inst.visitArg(0, func, Arg.Use, GP, 64);
341         inst.visitArg(1, func, Arg.Use, GP, 64);
342         inst.visitArg(2, func, Arg.ZDef, GP, 64);
343         break;
344         break;
345     case Div32:
346         inst.visitArg(0, func, Arg.Use, GP, 32);
347         inst.visitArg(1, func, Arg.Use, GP, 32);
348         inst.visitArg(2, func, Arg.ZDef, GP, 32);
349         break;
350         break;
351     case Div64:
352         inst.visitArg(0, func, Arg.Use, GP, 64);
353         inst.visitArg(1, func, Arg.Use, GP, 64);
354         inst.visitArg(2, func, Arg.Def, GP, 64);
355         break;
356         break;
357     case MulDouble:
358         switch (inst.args.length) {
359         case 3:
360             inst.visitArg(0, func, Arg.Use, FP, 64);
361             inst.visitArg(1, func, Arg.Use, FP, 64);
362             inst.visitArg(2, func, Arg.Def, FP, 64);
363             break;
364         case 2:
365             inst.visitArg(0, func, Arg.Use, FP, 64);
366             inst.visitArg(1, func, Arg.UseDef, FP, 64);
367             break;
368         default:
369             throw new Error("Bad overload");
370             break;
371         }
372         break;
373     case MulFloat:
374         switch (inst.args.length) {
375         case 3:
376             inst.visitArg(0, func, Arg.Use, FP, 32);
377             inst.visitArg(1, func, Arg.Use, FP, 32);
378             inst.visitArg(2, func, Arg.Def, FP, 32);
379             break;
380         case 2:
381             inst.visitArg(0, func, Arg.Use, FP, 32);
382             inst.visitArg(1, func, Arg.UseDef, FP, 32);
383             break;
384         default:
385             throw new Error("Bad overload");
386             break;
387         }
388         break;
389     case DivDouble:
390         switch (inst.args.length) {
391         case 3:
392             inst.visitArg(0, func, Arg.Use, FP, 64);
393             inst.visitArg(1, func, Arg.Use, FP, 32);
394             inst.visitArg(2, func, Arg.Def, FP, 64);
395             break;
396         case 2:
397             inst.visitArg(0, func, Arg.Use, FP, 64);
398             inst.visitArg(1, func, Arg.UseDef, FP, 64);
399             break;
400         default:
401             throw new Error("Bad overload");
402             break;
403         }
404         break;
405     case DivFloat:
406         switch (inst.args.length) {
407         case 3:
408             inst.visitArg(0, func, Arg.Use, FP, 32);
409             inst.visitArg(1, func, Arg.Use, FP, 32);
410             inst.visitArg(2, func, Arg.Def, FP, 32);
411             break;
412         case 2:
413             inst.visitArg(0, func, Arg.Use, FP, 32);
414             inst.visitArg(1, func, Arg.UseDef, FP, 32);
415             break;
416         default:
417             throw new Error("Bad overload");
418             break;
419         }
420         break;
421     case X86ConvertToDoubleWord32:
422         inst.visitArg(0, func, Arg.Use, GP, 32);
423         inst.visitArg(1, func, Arg.ZDef, GP, 32);
424         break;
425         break;
426     case X86ConvertToQuadWord64:
427         inst.visitArg(0, func, Arg.Use, GP, 64);
428         inst.visitArg(1, func, Arg.Def, GP, 64);
429         break;
430         break;
431     case X86Div32:
432         inst.visitArg(0, func, Arg.UseZDef, GP, 32);
433         inst.visitArg(1, func, Arg.UseZDef, GP, 32);
434         inst.visitArg(2, func, Arg.Use, GP, 32);
435         break;
436         break;
437     case X86Div64:
438         inst.visitArg(0, func, Arg.UseZDef, GP, 64);
439         inst.visitArg(1, func, Arg.UseZDef, GP, 64);
440         inst.visitArg(2, func, Arg.Use, GP, 64);
441         break;
442         break;
443     case Lea:
444         inst.visitArg(0, func, Arg.UseAddr, GP, Ptr);
445         inst.visitArg(1, func, Arg.Def, GP, Ptr);
446         break;
447         break;
448     case And32:
449         switch (inst.args.length) {
450         case 3:
451             inst.visitArg(0, func, Arg.Use, GP, 32);
452             inst.visitArg(1, func, Arg.Use, GP, 32);
453             inst.visitArg(2, func, Arg.ZDef, GP, 32);
454             break;
455         case 2:
456             inst.visitArg(0, func, Arg.Use, GP, 32);
457             inst.visitArg(1, func, Arg.UseZDef, GP, 32);
458             break;
459         default:
460             throw new Error("Bad overload");
461             break;
462         }
463         break;
464     case And64:
465         switch (inst.args.length) {
466         case 3:
467             inst.visitArg(0, func, Arg.Use, GP, 64);
468             inst.visitArg(1, func, Arg.Use, GP, 64);
469             inst.visitArg(2, func, Arg.Def, GP, 64);
470             break;
471         case 2:
472             inst.visitArg(0, func, Arg.Use, GP, 64);
473             inst.visitArg(1, func, Arg.UseDef, GP, 64);
474             break;
475         default:
476             throw new Error("Bad overload");
477             break;
478         }
479         break;
480     case AndDouble:
481         switch (inst.args.length) {
482         case 3:
483             inst.visitArg(0, func, Arg.Use, FP, 64);
484             inst.visitArg(1, func, Arg.Use, FP, 64);
485             inst.visitArg(2, func, Arg.Def, FP, 64);
486             break;
487         case 2:
488             inst.visitArg(0, func, Arg.Use, FP, 64);
489             inst.visitArg(1, func, Arg.UseDef, FP, 64);
490             break;
491         default:
492             throw new Error("Bad overload");
493             break;
494         }
495         break;
496     case AndFloat:
497         switch (inst.args.length) {
498         case 3:
499             inst.visitArg(0, func, Arg.Use, FP, 32);
500             inst.visitArg(1, func, Arg.Use, FP, 32);
501             inst.visitArg(2, func, Arg.Def, FP, 32);
502             break;
503         case 2:
504             inst.visitArg(0, func, Arg.Use, FP, 32);
505             inst.visitArg(1, func, Arg.UseDef, FP, 32);
506             break;
507         default:
508             throw new Error("Bad overload");
509             break;
510         }
511         break;
512     case XorDouble:
513         switch (inst.args.length) {
514         case 3:
515             inst.visitArg(0, func, Arg.Use, FP, 64);
516             inst.visitArg(1, func, Arg.Use, FP, 64);
517             inst.visitArg(2, func, Arg.Def, FP, 64);
518             break;
519         case 2:
520             inst.visitArg(0, func, Arg.Use, FP, 64);
521             inst.visitArg(1, func, Arg.UseDef, FP, 64);
522             break;
523         default:
524             throw new Error("Bad overload");
525             break;
526         }
527         break;
528     case XorFloat:
529         switch (inst.args.length) {
530         case 3:
531             inst.visitArg(0, func, Arg.Use, FP, 32);
532             inst.visitArg(1, func, Arg.Use, FP, 32);
533             inst.visitArg(2, func, Arg.Def, FP, 32);
534             break;
535         case 2:
536             inst.visitArg(0, func, Arg.Use, FP, 32);
537             inst.visitArg(1, func, Arg.UseDef, FP, 32);
538             break;
539         default:
540             throw new Error("Bad overload");
541             break;
542         }
543         break;
544     case Lshift32:
545         switch (inst.args.length) {
546         case 3:
547             inst.visitArg(0, func, Arg.Use, GP, 32);
548             inst.visitArg(1, func, Arg.Use, GP, 32);
549             inst.visitArg(2, func, Arg.ZDef, GP, 32);
550             break;
551         case 2:
552             inst.visitArg(0, func, Arg.Use, GP, 32);
553             inst.visitArg(1, func, Arg.UseZDef, GP, 32);
554             break;
555         default:
556             throw new Error("Bad overload");
557             break;
558         }
559         break;
560     case Lshift64:
561         switch (inst.args.length) {
562         case 3:
563             inst.visitArg(0, func, Arg.Use, GP, 64);
564             inst.visitArg(1, func, Arg.Use, GP, 64);
565             inst.visitArg(2, func, Arg.ZDef, GP, 64);
566             break;
567         case 2:
568             inst.visitArg(0, func, Arg.Use, GP, 64);
569             inst.visitArg(1, func, Arg.UseDef, GP, 64);
570             break;
571         default:
572             throw new Error("Bad overload");
573             break;
574         }
575         break;
576     case Rshift32:
577         switch (inst.args.length) {
578         case 3:
579             inst.visitArg(0, func, Arg.Use, GP, 32);
580             inst.visitArg(1, func, Arg.Use, GP, 32);
581             inst.visitArg(2, func, Arg.ZDef, GP, 32);
582             break;
583         case 2:
584             inst.visitArg(0, func, Arg.Use, GP, 32);
585             inst.visitArg(1, func, Arg.UseZDef, GP, 32);
586             break;
587         default:
588             throw new Error("Bad overload");
589             break;
590         }
591         break;
592     case Rshift64:
593         switch (inst.args.length) {
594         case 3:
595             inst.visitArg(0, func, Arg.Use, GP, 64);
596             inst.visitArg(1, func, Arg.Use, GP, 64);
597             inst.visitArg(2, func, Arg.ZDef, GP, 64);
598             break;
599         case 2:
600             inst.visitArg(0, func, Arg.Use, GP, 64);
601             inst.visitArg(1, func, Arg.UseDef, GP, 64);
602             break;
603         default:
604             throw new Error("Bad overload");
605             break;
606         }
607         break;
608     case Urshift32:
609         switch (inst.args.length) {
610         case 3:
611             inst.visitArg(0, func, Arg.Use, GP, 32);
612             inst.visitArg(1, func, Arg.Use, GP, 32);
613             inst.visitArg(2, func, Arg.ZDef, GP, 32);
614             break;
615         case 2:
616             inst.visitArg(0, func, Arg.Use, GP, 32);
617             inst.visitArg(1, func, Arg.UseZDef, GP, 32);
618             break;
619         default:
620             throw new Error("Bad overload");
621             break;
622         }
623         break;
624     case Urshift64:
625         switch (inst.args.length) {
626         case 3:
627             inst.visitArg(0, func, Arg.Use, GP, 64);
628             inst.visitArg(1, func, Arg.Use, GP, 64);
629             inst.visitArg(2, func, Arg.ZDef, GP, 64);
630             break;
631         case 2:
632             inst.visitArg(0, func, Arg.Use, GP, 64);
633             inst.visitArg(1, func, Arg.UseDef, GP, 64);
634             break;
635         default:
636             throw new Error("Bad overload");
637             break;
638         }
639         break;
640     case Or32:
641         switch (inst.args.length) {
642         case 3:
643             inst.visitArg(0, func, Arg.Use, GP, 32);
644             inst.visitArg(1, func, Arg.Use, GP, 32);
645             inst.visitArg(2, func, Arg.ZDef, GP, 32);
646             break;
647         case 2:
648             inst.visitArg(0, func, Arg.Use, GP, 32);
649             inst.visitArg(1, func, Arg.UseZDef, GP, 32);
650             break;
651         default:
652             throw new Error("Bad overload");
653             break;
654         }
655         break;
656     case Or64:
657         switch (inst.args.length) {
658         case 3:
659             inst.visitArg(0, func, Arg.Use, GP, 64);
660             inst.visitArg(1, func, Arg.Use, GP, 64);
661             inst.visitArg(2, func, Arg.Def, GP, 64);
662             break;
663         case 2:
664             inst.visitArg(0, func, Arg.Use, GP, 64);
665             inst.visitArg(1, func, Arg.UseDef, GP, 64);
666             break;
667         default:
668             throw new Error("Bad overload");
669             break;
670         }
671         break;
672     case Xor32:
673         switch (inst.args.length) {
674         case 3:
675             inst.visitArg(0, func, Arg.Use, GP, 32);
676             inst.visitArg(1, func, Arg.Use, GP, 32);
677             inst.visitArg(2, func, Arg.ZDef, GP, 32);
678             break;
679         case 2:
680             inst.visitArg(0, func, Arg.Use, GP, 32);
681             inst.visitArg(1, func, Arg.UseZDef, GP, 32);
682             break;
683         default:
684             throw new Error("Bad overload");
685             break;
686         }
687         break;
688     case Xor64:
689         switch (inst.args.length) {
690         case 3:
691             inst.visitArg(0, func, Arg.Use, GP, 64);
692             inst.visitArg(1, func, Arg.Use, GP, 64);
693             inst.visitArg(2, func, Arg.Def, GP, 64);
694             break;
695         case 2:
696             inst.visitArg(0, func, Arg.Use, GP, 64);
697             inst.visitArg(1, func, Arg.UseDef, GP, 64);
698             break;
699         default:
700             throw new Error("Bad overload");
701             break;
702         }
703         break;
704     case Not32:
705         switch (inst.args.length) {
706         case 2:
707             inst.visitArg(0, func, Arg.Use, GP, 32);
708             inst.visitArg(1, func, Arg.ZDef, GP, 32);
709             break;
710         case 1:
711             inst.visitArg(0, func, Arg.UseZDef, GP, 32);
712             break;
713         default:
714             throw new Error("Bad overload");
715             break;
716         }
717         break;
718     case Not64:
719         switch (inst.args.length) {
720         case 2:
721             inst.visitArg(0, func, Arg.Use, GP, 64);
722             inst.visitArg(1, func, Arg.Def, GP, 64);
723             break;
724         case 1:
725             inst.visitArg(0, func, Arg.UseDef, GP, 64);
726             break;
727         default:
728             throw new Error("Bad overload");
729             break;
730         }
731         break;
732     case AbsDouble:
733         inst.visitArg(0, func, Arg.Use, FP, 64);
734         inst.visitArg(1, func, Arg.Def, FP, 64);
735         break;
736         break;
737     case AbsFloat:
738         inst.visitArg(0, func, Arg.Use, FP, 32);
739         inst.visitArg(1, func, Arg.Def, FP, 32);
740         break;
741         break;
742     case CeilDouble:
743         inst.visitArg(0, func, Arg.Use, FP, 64);
744         inst.visitArg(1, func, Arg.Def, FP, 64);
745         break;
746         break;
747     case CeilFloat:
748         inst.visitArg(0, func, Arg.Use, FP, 32);
749         inst.visitArg(1, func, Arg.Def, FP, 32);
750         break;
751         break;
752     case FloorDouble:
753         inst.visitArg(0, func, Arg.Use, FP, 64);
754         inst.visitArg(1, func, Arg.Def, FP, 64);
755         break;
756         break;
757     case FloorFloat:
758         inst.visitArg(0, func, Arg.Use, FP, 32);
759         inst.visitArg(1, func, Arg.Def, FP, 32);
760         break;
761         break;
762     case SqrtDouble:
763         inst.visitArg(0, func, Arg.Use, FP, 64);
764         inst.visitArg(1, func, Arg.Def, FP, 64);
765         break;
766         break;
767     case SqrtFloat:
768         inst.visitArg(0, func, Arg.Use, FP, 32);
769         inst.visitArg(1, func, Arg.Def, FP, 32);
770         break;
771         break;
772     case ConvertInt32ToDouble:
773         inst.visitArg(0, func, Arg.Use, GP, 32);
774         inst.visitArg(1, func, Arg.Def, FP, 64);
775         break;
776         break;
777     case ConvertInt64ToDouble:
778         inst.visitArg(0, func, Arg.Use, GP, 64);
779         inst.visitArg(1, func, Arg.Def, FP, 64);
780         break;
781         break;
782     case ConvertInt32ToFloat:
783         inst.visitArg(0, func, Arg.Use, GP, 32);
784         inst.visitArg(1, func, Arg.Def, FP, 32);
785         break;
786         break;
787     case ConvertInt64ToFloat:
788         inst.visitArg(0, func, Arg.Use, GP, 64);
789         inst.visitArg(1, func, Arg.Def, FP, 32);
790         break;
791         break;
792     case CountLeadingZeros32:
793         inst.visitArg(0, func, Arg.Use, GP, 32);
794         inst.visitArg(1, func, Arg.ZDef, GP, 32);
795         break;
796         break;
797     case CountLeadingZeros64:
798         inst.visitArg(0, func, Arg.Use, GP, 64);
799         inst.visitArg(1, func, Arg.Def, GP, 64);
800         break;
801         break;
802     case ConvertDoubleToFloat:
803         inst.visitArg(0, func, Arg.Use, FP, 64);
804         inst.visitArg(1, func, Arg.Def, FP, 32);
805         break;
806         break;
807     case ConvertFloatToDouble:
808         inst.visitArg(0, func, Arg.Use, FP, 32);
809         inst.visitArg(1, func, Arg.Def, FP, 64);
810         break;
811         break;
812     case Move:
813         inst.visitArg(0, func, Arg.Use, GP, Ptr);
814         inst.visitArg(1, func, Arg.Def, GP, Ptr);
815         break;
816         break;
817     case Swap32:
818         inst.visitArg(0, func, Arg.UseDef, GP, 32);
819         inst.visitArg(1, func, Arg.UseDef, GP, 32);
820         break;
821         break;
822     case Swap64:
823         inst.visitArg(0, func, Arg.UseDef, GP, 64);
824         inst.visitArg(1, func, Arg.UseDef, GP, 64);
825         break;
826         break;
827     case Move32:
828         inst.visitArg(0, func, Arg.Use, GP, 32);
829         inst.visitArg(1, func, Arg.ZDef, GP, 32);
830         break;
831         break;
832     case StoreZero32:
833         inst.visitArg(0, func, Arg.Use, GP, 32);
834         break;
835         break;
836     case SignExtend32ToPtr:
837         inst.visitArg(0, func, Arg.Use, GP, 32);
838         inst.visitArg(1, func, Arg.Def, GP, Ptr);
839         break;
840         break;
841     case ZeroExtend8To32:
842         inst.visitArg(0, func, Arg.Use, GP, 8);
843         inst.visitArg(1, func, Arg.ZDef, GP, 32);
844         break;
845         break;
846     case SignExtend8To32:
847         inst.visitArg(0, func, Arg.Use, GP, 8);
848         inst.visitArg(1, func, Arg.ZDef, GP, 32);
849         break;
850         break;
851     case ZeroExtend16To32:
852         inst.visitArg(0, func, Arg.Use, GP, 16);
853         inst.visitArg(1, func, Arg.ZDef, GP, 32);
854         break;
855         break;
856     case SignExtend16To32:
857         inst.visitArg(0, func, Arg.Use, GP, 16);
858         inst.visitArg(1, func, Arg.ZDef, GP, 32);
859         break;
860         break;
861     case MoveFloat:
862         inst.visitArg(0, func, Arg.Use, FP, 32);
863         inst.visitArg(1, func, Arg.Def, FP, 32);
864         break;
865         break;
866     case MoveDouble:
867         inst.visitArg(0, func, Arg.Use, FP, 64);
868         inst.visitArg(1, func, Arg.Def, FP, 64);
869         break;
870         break;
871     case MoveZeroToDouble:
872         inst.visitArg(0, func, Arg.Def, FP, 64);
873         break;
874         break;
875     case Move64ToDouble:
876         inst.visitArg(0, func, Arg.Use, GP, 64);
877         inst.visitArg(1, func, Arg.Def, FP, 64);
878         break;
879         break;
880     case Move32ToFloat:
881         inst.visitArg(0, func, Arg.Use, GP, 32);
882         inst.visitArg(1, func, Arg.Def, FP, 32);
883         break;
884         break;
885     case MoveDoubleTo64:
886         inst.visitArg(0, func, Arg.Use, FP, 64);
887         inst.visitArg(1, func, Arg.Def, GP, 64);
888         break;
889         break;
890     case MoveFloatTo32:
891         inst.visitArg(0, func, Arg.Use, FP, 32);
892         inst.visitArg(1, func, Arg.Def, GP, 32);
893         break;
894         break;
895     case Load8:
896         inst.visitArg(0, func, Arg.Use, GP, 8);
897         inst.visitArg(1, func, Arg.ZDef, GP, 32);
898         break;
899         break;
900     case Store8:
901         inst.visitArg(0, func, Arg.Use, GP, 8);
902         inst.visitArg(1, func, Arg.Def, GP, 8);
903         break;
904         break;
905     case Load8SignedExtendTo32:
906         inst.visitArg(0, func, Arg.Use, GP, 8);
907         inst.visitArg(1, func, Arg.ZDef, GP, 32);
908         break;
909         break;
910     case Load16:
911         inst.visitArg(0, func, Arg.Use, GP, 16);
912         inst.visitArg(1, func, Arg.ZDef, GP, 32);
913         break;
914         break;
915     case Load16SignedExtendTo32:
916         inst.visitArg(0, func, Arg.Use, GP, 16);
917         inst.visitArg(1, func, Arg.ZDef, GP, 32);
918         break;
919         break;
920     case Store16:
921         inst.visitArg(0, func, Arg.Use, GP, 16);
922         inst.visitArg(1, func, Arg.Def, GP, 16);
923         break;
924         break;
925     case Compare32:
926         inst.visitArg(0, func, Arg.Use, GP, 32);
927         inst.visitArg(1, func, Arg.Use, GP, 32);
928         inst.visitArg(2, func, Arg.Use, GP, 32);
929         inst.visitArg(3, func, Arg.ZDef, GP, 32);
930         break;
931         break;
932     case Compare64:
933         inst.visitArg(0, func, Arg.Use, GP, 32);
934         inst.visitArg(1, func, Arg.Use, GP, 64);
935         inst.visitArg(2, func, Arg.Use, GP, 64);
936         inst.visitArg(3, func, Arg.ZDef, GP, 32);
937         break;
938         break;
939     case Test32:
940         inst.visitArg(0, func, Arg.Use, GP, 32);
941         inst.visitArg(1, func, Arg.Use, GP, 32);
942         inst.visitArg(2, func, Arg.Use, GP, 32);
943         inst.visitArg(3, func, Arg.ZDef, GP, 32);
944         break;
945         break;
946     case Test64:
947         inst.visitArg(0, func, Arg.Use, GP, 32);
948         inst.visitArg(1, func, Arg.Use, GP, 64);
949         inst.visitArg(2, func, Arg.Use, GP, 64);
950         inst.visitArg(3, func, Arg.ZDef, GP, 32);
951         break;
952         break;
953     case CompareDouble:
954         inst.visitArg(0, func, Arg.Use, GP, 32);
955         inst.visitArg(1, func, Arg.Use, FP, 64);
956         inst.visitArg(2, func, Arg.Use, FP, 64);
957         inst.visitArg(3, func, Arg.ZDef, GP, 32);
958         break;
959         break;
960     case CompareFloat:
961         inst.visitArg(0, func, Arg.Use, GP, 32);
962         inst.visitArg(1, func, Arg.Use, FP, 32);
963         inst.visitArg(2, func, Arg.Use, FP, 32);
964         inst.visitArg(3, func, Arg.ZDef, GP, 32);
965         break;
966         break;
967     case Branch8:
968         inst.visitArg(0, func, Arg.Use, GP, 32);
969         inst.visitArg(1, func, Arg.Use, GP, 8);
970         inst.visitArg(2, func, Arg.Use, GP, 8);
971         break;
972         break;
973     case Branch32:
974         inst.visitArg(0, func, Arg.Use, GP, 32);
975         inst.visitArg(1, func, Arg.Use, GP, 32);
976         inst.visitArg(2, func, Arg.Use, GP, 32);
977         break;
978         break;
979     case Branch64:
980         inst.visitArg(0, func, Arg.Use, GP, 32);
981         inst.visitArg(1, func, Arg.Use, GP, 64);
982         inst.visitArg(2, func, Arg.Use, GP, 64);
983         break;
984         break;
985     case BranchTest8:
986         inst.visitArg(0, func, Arg.Use, GP, 32);
987         inst.visitArg(1, func, Arg.Use, GP, 8);
988         inst.visitArg(2, func, Arg.Use, GP, 8);
989         break;
990         break;
991     case BranchTest32:
992         inst.visitArg(0, func, Arg.Use, GP, 32);
993         inst.visitArg(1, func, Arg.Use, GP, 32);
994         inst.visitArg(2, func, Arg.Use, GP, 32);
995         break;
996         break;
997     case BranchTest64:
998         inst.visitArg(0, func, Arg.Use, GP, 32);
999         inst.visitArg(1, func, Arg.Use, GP, 64);
1000         inst.visitArg(2, func, Arg.Use, GP, 64);
1001         break;
1002         break;
1003     case BranchDouble:
1004         inst.visitArg(0, func, Arg.Use, GP, 32);
1005         inst.visitArg(1, func, Arg.Use, FP, 64);
1006         inst.visitArg(2, func, Arg.Use, FP, 64);
1007         break;
1008         break;
1009     case BranchFloat:
1010         inst.visitArg(0, func, Arg.Use, GP, 32);
1011         inst.visitArg(1, func, Arg.Use, FP, 32);
1012         inst.visitArg(2, func, Arg.Use, FP, 32);
1013         break;
1014         break;
1015     case BranchAdd32:
1016         switch (inst.args.length) {
1017         case 4:
1018             inst.visitArg(0, func, Arg.Use, GP, 32);
1019             inst.visitArg(1, func, Arg.Use, GP, 32);
1020             inst.visitArg(2, func, Arg.Use, GP, 32);
1021             inst.visitArg(3, func, Arg.ZDef, GP, 32);
1022             break;
1023         case 3:
1024             inst.visitArg(0, func, Arg.Use, GP, 32);
1025             inst.visitArg(1, func, Arg.Use, GP, 32);
1026             inst.visitArg(2, func, Arg.UseZDef, GP, 32);
1027             break;
1028         default:
1029             throw new Error("Bad overload");
1030             break;
1031         }
1032         break;
1033     case BranchAdd64:
1034         switch (inst.args.length) {
1035         case 4:
1036             inst.visitArg(0, func, Arg.Use, GP, 32);
1037             inst.visitArg(1, func, Arg.Use, GP, 64);
1038             inst.visitArg(2, func, Arg.Use, GP, 64);
1039             inst.visitArg(3, func, Arg.ZDef, GP, 64);
1040             break;
1041         case 3:
1042             inst.visitArg(0, func, Arg.Use, GP, 32);
1043             inst.visitArg(1, func, Arg.Use, GP, 64);
1044             inst.visitArg(2, func, Arg.UseDef, GP, 64);
1045             break;
1046         default:
1047             throw new Error("Bad overload");
1048             break;
1049         }
1050         break;
1051     case BranchMul32:
1052         switch (inst.args.length) {
1053         case 3:
1054             inst.visitArg(0, func, Arg.Use, GP, 32);
1055             inst.visitArg(1, func, Arg.Use, GP, 32);
1056             inst.visitArg(2, func, Arg.UseZDef, GP, 32);
1057             break;
1058         case 4:
1059             inst.visitArg(0, func, Arg.Use, GP, 32);
1060             inst.visitArg(1, func, Arg.Use, GP, 32);
1061             inst.visitArg(2, func, Arg.Use, GP, 32);
1062             inst.visitArg(3, func, Arg.ZDef, GP, 32);
1063             break;
1064         case 6:
1065             inst.visitArg(0, func, Arg.Use, GP, 32);
1066             inst.visitArg(1, func, Arg.Use, GP, 32);
1067             inst.visitArg(2, func, Arg.Use, GP, 32);
1068             inst.visitArg(3, func, Arg.Scratch, GP, 32);
1069             inst.visitArg(4, func, Arg.Scratch, GP, 32);
1070             inst.visitArg(5, func, Arg.ZDef, GP, 32);
1071             break;
1072         default:
1073             throw new Error("Bad overload");
1074             break;
1075         }
1076         break;
1077     case BranchMul64:
1078         switch (inst.args.length) {
1079         case 3:
1080             inst.visitArg(0, func, Arg.Use, GP, 32);
1081             inst.visitArg(1, func, Arg.Use, GP, 64);
1082             inst.visitArg(2, func, Arg.UseZDef, GP, 64);
1083             break;
1084         case 6:
1085             inst.visitArg(0, func, Arg.Use, GP, 32);
1086             inst.visitArg(1, func, Arg.Use, GP, 64);
1087             inst.visitArg(2, func, Arg.Use, GP, 64);
1088             inst.visitArg(3, func, Arg.Scratch, GP, 64);
1089             inst.visitArg(4, func, Arg.Scratch, GP, 64);
1090             inst.visitArg(5, func, Arg.ZDef, GP, 64);
1091             break;
1092         default:
1093             throw new Error("Bad overload");
1094             break;
1095         }
1096         break;
1097     case BranchSub32:
1098         inst.visitArg(0, func, Arg.Use, GP, 32);
1099         inst.visitArg(1, func, Arg.Use, GP, 32);
1100         inst.visitArg(2, func, Arg.UseZDef, GP, 32);
1101         break;
1102         break;
1103     case BranchSub64:
1104         inst.visitArg(0, func, Arg.Use, GP, 32);
1105         inst.visitArg(1, func, Arg.Use, GP, 64);
1106         inst.visitArg(2, func, Arg.UseDef, GP, 64);
1107         break;
1108         break;
1109     case BranchNeg32:
1110         inst.visitArg(0, func, Arg.Use, GP, 32);
1111         inst.visitArg(1, func, Arg.UseZDef, GP, 32);
1112         break;
1113         break;
1114     case BranchNeg64:
1115         inst.visitArg(0, func, Arg.Use, GP, 32);
1116         inst.visitArg(1, func, Arg.UseZDef, GP, 64);
1117         break;
1118         break;
1119     case MoveConditionally32:
1120         switch (inst.args.length) {
1121         case 5:
1122             inst.visitArg(0, func, Arg.Use, GP, 32);
1123             inst.visitArg(1, func, Arg.Use, GP, 32);
1124             inst.visitArg(2, func, Arg.Use, GP, 32);
1125             inst.visitArg(3, func, Arg.Use, GP, Ptr);
1126             inst.visitArg(4, func, Arg.UseDef, GP, Ptr);
1127             break;
1128         case 6:
1129             inst.visitArg(0, func, Arg.Use, GP, 32);
1130             inst.visitArg(1, func, Arg.Use, GP, 32);
1131             inst.visitArg(2, func, Arg.Use, GP, 32);
1132             inst.visitArg(3, func, Arg.Use, GP, Ptr);
1133             inst.visitArg(4, func, Arg.Use, GP, Ptr);
1134             inst.visitArg(5, func, Arg.Def, GP, Ptr);
1135             break;
1136         default:
1137             throw new Error("Bad overload");
1138             break;
1139         }
1140         break;
1141     case MoveConditionally64:
1142         switch (inst.args.length) {
1143         case 5:
1144             inst.visitArg(0, func, Arg.Use, GP, 32);
1145             inst.visitArg(1, func, Arg.Use, GP, 64);
1146             inst.visitArg(2, func, Arg.Use, GP, 64);
1147             inst.visitArg(3, func, Arg.Use, GP, Ptr);
1148             inst.visitArg(4, func, Arg.UseDef, GP, Ptr);
1149             break;
1150         case 6:
1151             inst.visitArg(0, func, Arg.Use, GP, 32);
1152             inst.visitArg(1, func, Arg.Use, GP, 64);
1153             inst.visitArg(2, func, Arg.Use, GP, 64);
1154             inst.visitArg(3, func, Arg.Use, GP, Ptr);
1155             inst.visitArg(4, func, Arg.Use, GP, Ptr);
1156             inst.visitArg(5, func, Arg.Def, GP, Ptr);
1157             break;
1158         default:
1159             throw new Error("Bad overload");
1160             break;
1161         }
1162         break;
1163     case MoveConditionallyTest32:
1164         switch (inst.args.length) {
1165         case 5:
1166             inst.visitArg(0, func, Arg.Use, GP, 32);
1167             inst.visitArg(1, func, Arg.Use, GP, 32);
1168             inst.visitArg(2, func, Arg.Use, GP, 32);
1169             inst.visitArg(3, func, Arg.Use, GP, Ptr);
1170             inst.visitArg(4, func, Arg.UseDef, GP, Ptr);
1171             break;
1172         case 6:
1173             inst.visitArg(0, func, Arg.Use, GP, 32);
1174             inst.visitArg(1, func, Arg.Use, GP, 32);
1175             inst.visitArg(2, func, Arg.Use, GP, 32);
1176             inst.visitArg(3, func, Arg.Use, GP, Ptr);
1177             inst.visitArg(4, func, Arg.Use, GP, Ptr);
1178             inst.visitArg(5, func, Arg.Def, GP, Ptr);
1179             break;
1180         default:
1181             throw new Error("Bad overload");
1182             break;
1183         }
1184         break;
1185     case MoveConditionallyTest64:
1186         switch (inst.args.length) {
1187         case 5:
1188             inst.visitArg(0, func, Arg.Use, GP, 32);
1189             inst.visitArg(1, func, Arg.Use, GP, 64);
1190             inst.visitArg(2, func, Arg.Use, GP, 64);
1191             inst.visitArg(3, func, Arg.Use, GP, Ptr);
1192             inst.visitArg(4, func, Arg.UseDef, GP, Ptr);
1193             break;
1194         case 6:
1195             inst.visitArg(0, func, Arg.Use, GP, 32);
1196             inst.visitArg(1, func, Arg.Use, GP, 32);
1197             inst.visitArg(2, func, Arg.Use, GP, 32);
1198             inst.visitArg(3, func, Arg.Use, GP, Ptr);
1199             inst.visitArg(4, func, Arg.Use, GP, Ptr);
1200             inst.visitArg(5, func, Arg.Def, GP, Ptr);
1201             break;
1202         default:
1203             throw new Error("Bad overload");
1204             break;
1205         }
1206         break;
1207     case MoveConditionallyDouble:
1208         switch (inst.args.length) {
1209         case 6:
1210             inst.visitArg(0, func, Arg.Use, GP, 32);
1211             inst.visitArg(1, func, Arg.Use, FP, 64);
1212             inst.visitArg(2, func, Arg.Use, FP, 64);
1213             inst.visitArg(3, func, Arg.Use, GP, Ptr);
1214             inst.visitArg(4, func, Arg.Use, GP, Ptr);
1215             inst.visitArg(5, func, Arg.Def, GP, Ptr);
1216             break;
1217         case 5:
1218             inst.visitArg(0, func, Arg.Use, GP, 32);
1219             inst.visitArg(1, func, Arg.Use, FP, 64);
1220             inst.visitArg(2, func, Arg.Use, FP, 64);
1221             inst.visitArg(3, func, Arg.Use, GP, Ptr);
1222             inst.visitArg(4, func, Arg.UseDef, GP, Ptr);
1223             break;
1224         default:
1225             throw new Error("Bad overload");
1226             break;
1227         }
1228         break;
1229     case MoveConditionallyFloat:
1230         switch (inst.args.length) {
1231         case 6:
1232             inst.visitArg(0, func, Arg.Use, GP, 32);
1233             inst.visitArg(1, func, Arg.Use, FP, 32);
1234             inst.visitArg(2, func, Arg.Use, FP, 32);
1235             inst.visitArg(3, func, Arg.Use, GP, Ptr);
1236             inst.visitArg(4, func, Arg.Use, GP, Ptr);
1237             inst.visitArg(5, func, Arg.Def, GP, Ptr);
1238             break;
1239         case 5:
1240             inst.visitArg(0, func, Arg.Use, GP, 32);
1241             inst.visitArg(1, func, Arg.Use, FP, 32);
1242             inst.visitArg(2, func, Arg.Use, FP, 32);
1243             inst.visitArg(3, func, Arg.Use, GP, Ptr);
1244             inst.visitArg(4, func, Arg.UseDef, GP, Ptr);
1245             break;
1246         default:
1247             throw new Error("Bad overload");
1248             break;
1249         }
1250         break;
1251     case MoveDoubleConditionally32:
1252         inst.visitArg(0, func, Arg.Use, GP, 32);
1253         inst.visitArg(1, func, Arg.Use, GP, 32);
1254         inst.visitArg(2, func, Arg.Use, GP, 32);
1255         inst.visitArg(3, func, Arg.Use, FP, 64);
1256         inst.visitArg(4, func, Arg.Use, FP, 64);
1257         inst.visitArg(5, func, Arg.Def, FP, 64);
1258         break;
1259         break;
1260     case MoveDoubleConditionally64:
1261         inst.visitArg(0, func, Arg.Use, GP, 32);
1262         inst.visitArg(1, func, Arg.Use, GP, 64);
1263         inst.visitArg(2, func, Arg.Use, GP, 64);
1264         inst.visitArg(3, func, Arg.Use, FP, 64);
1265         inst.visitArg(4, func, Arg.Use, FP, 64);
1266         inst.visitArg(5, func, Arg.Def, FP, 64);
1267         break;
1268         break;
1269     case MoveDoubleConditionallyTest32:
1270         inst.visitArg(0, func, Arg.Use, GP, 32);
1271         inst.visitArg(1, func, Arg.Use, GP, 32);
1272         inst.visitArg(2, func, Arg.Use, GP, 32);
1273         inst.visitArg(3, func, Arg.Use, FP, 64);
1274         inst.visitArg(4, func, Arg.Use, FP, 64);
1275         inst.visitArg(5, func, Arg.Def, FP, 64);
1276         break;
1277         break;
1278     case MoveDoubleConditionallyTest64:
1279         inst.visitArg(0, func, Arg.Use, GP, 32);
1280         inst.visitArg(1, func, Arg.Use, GP, 64);
1281         inst.visitArg(2, func, Arg.Use, GP, 64);
1282         inst.visitArg(3, func, Arg.Use, FP, 64);
1283         inst.visitArg(4, func, Arg.Use, FP, 64);
1284         inst.visitArg(5, func, Arg.Def, FP, 64);
1285         break;
1286         break;
1287     case MoveDoubleConditionallyDouble:
1288         inst.visitArg(0, func, Arg.Use, GP, 32);
1289         inst.visitArg(1, func, Arg.Use, FP, 64);
1290         inst.visitArg(2, func, Arg.Use, FP, 64);
1291         inst.visitArg(3, func, Arg.Use, FP, 64);
1292         inst.visitArg(4, func, Arg.Use, FP, 64);
1293         inst.visitArg(5, func, Arg.Def, FP, 64);
1294         break;
1295         break;
1296     case MoveDoubleConditionallyFloat:
1297         inst.visitArg(0, func, Arg.Use, GP, 32);
1298         inst.visitArg(1, func, Arg.Use, FP, 32);
1299         inst.visitArg(2, func, Arg.Use, FP, 32);
1300         inst.visitArg(3, func, Arg.Use, FP, 64);
1301         inst.visitArg(4, func, Arg.Use, FP, 64);
1302         inst.visitArg(5, func, Arg.Def, FP, 64);
1303         break;
1304         break;
1305     case Jump:
1306         break;
1307         break;
1308     case Ret32:
1309         inst.visitArg(0, func, Arg.Use, GP, 32);
1310         break;
1311         break;
1312     case Ret64:
1313         inst.visitArg(0, func, Arg.Use, GP, 64);
1314         break;
1315         break;
1316     case RetFloat:
1317         inst.visitArg(0, func, Arg.Use, FP, 32);
1318         break;
1319         break;
1320     case RetDouble:
1321         inst.visitArg(0, func, Arg.Use, FP, 64);
1322         break;
1323         break;
1324     case Oops:
1325         break;
1326         break;
1327     case Shuffle:
1328         ShuffleCustom.forEachArg(inst, func);
1329         break;
1330     case Patch:
1331         PatchCustom.forEachArg(inst, func);
1332         break;
1333     case CCall:
1334         CCallCustom.forEachArg(inst, func);
1335         break;
1336     case ColdCCall:
1337         ColdCCallCustom.forEachArg(inst, func);
1338         break;
1339     default:
1340         throw "Bad opcode";
1341     }
1342 }
1343 function Inst_hasNonArgEffects(inst)
1344 {
1345     switch (inst.opcode) {
1346     case Branch8:
1347     case Branch32:
1348     case Branch64:
1349     case BranchTest8:
1350     case BranchTest32:
1351     case BranchTest64:
1352     case BranchDouble:
1353     case BranchFloat:
1354     case BranchAdd32:
1355     case BranchAdd64:
1356     case BranchMul32:
1357     case BranchMul64:
1358     case BranchSub32:
1359     case BranchSub64:
1360     case BranchNeg32:
1361     case BranchNeg64:
1362     case Jump:
1363     case Ret32:
1364     case Ret64:
1365     case RetFloat:
1366     case RetDouble:
1367     case Oops:
1368         return true;
1369     case Shuffle:
1370         return ShuffleCustom.hasNonArgNonControlEffects(inst);
1371     case Patch:
1372         return PatchCustom.hasNonArgNonControlEffects(inst);
1373     case CCall:
1374         return CCallCustom.hasNonArgNonControlEffects(inst);
1375     case ColdCCall:
1376         return ColdCCallCustom.hasNonArgNonControlEffects(inst);
1377     default:
1378         return false;
1379     }
1380 }
1381 function opcodeCode(opcode)
1382 {
1383     switch (opcode) {
1384     case AbsDouble:
1385         return 0
1386     case AbsFloat:
1387         return 1
1388     case Add16:
1389         return 2
1390     case Add32:
1391         return 3
1392     case Add64:
1393         return 4
1394     case Add8:
1395         return 5
1396     case AddDouble:
1397         return 6
1398     case AddFloat:
1399         return 7
1400     case And32:
1401         return 8
1402     case And64:
1403         return 9
1404     case AndDouble:
1405         return 10
1406     case AndFloat:
1407         return 11
1408     case Branch32:
1409         return 12
1410     case Branch64:
1411         return 13
1412     case Branch8:
1413         return 14
1414     case BranchAdd32:
1415         return 15
1416     case BranchAdd64:
1417         return 16
1418     case BranchDouble:
1419         return 17
1420     case BranchFloat:
1421         return 18
1422     case BranchMul32:
1423         return 19
1424     case BranchMul64:
1425         return 20
1426     case BranchNeg32:
1427         return 21
1428     case BranchNeg64:
1429         return 22
1430     case BranchSub32:
1431         return 23
1432     case BranchSub64:
1433         return 24
1434     case BranchTest32:
1435         return 25
1436     case BranchTest64:
1437         return 26
1438     case BranchTest8:
1439         return 27
1440     case CCall:
1441         return 28
1442     case CeilDouble:
1443         return 29
1444     case CeilFloat:
1445         return 30
1446     case ColdCCall:
1447         return 31
1448     case Compare32:
1449         return 32
1450     case Compare64:
1451         return 33
1452     case CompareDouble:
1453         return 34
1454     case CompareFloat:
1455         return 35
1456     case ConvertDoubleToFloat:
1457         return 36
1458     case ConvertFloatToDouble:
1459         return 37
1460     case ConvertInt32ToDouble:
1461         return 38
1462     case ConvertInt32ToFloat:
1463         return 39
1464     case ConvertInt64ToDouble:
1465         return 40
1466     case ConvertInt64ToFloat:
1467         return 41
1468     case CountLeadingZeros32:
1469         return 42
1470     case CountLeadingZeros64:
1471         return 43
1472     case Div32:
1473         return 44
1474     case Div64:
1475         return 45
1476     case DivDouble:
1477         return 46
1478     case DivFloat:
1479         return 47
1480     case FloorDouble:
1481         return 48
1482     case FloorFloat:
1483         return 49
1484     case Jump:
1485         return 50
1486     case Lea:
1487         return 51
1488     case Load16:
1489         return 52
1490     case Load16SignedExtendTo32:
1491         return 53
1492     case Load8:
1493         return 54
1494     case Load8SignedExtendTo32:
1495         return 55
1496     case Lshift32:
1497         return 56
1498     case Lshift64:
1499         return 57
1500     case Move:
1501         return 58
1502     case Move32:
1503         return 59
1504     case Move32ToFloat:
1505         return 60
1506     case Move64ToDouble:
1507         return 61
1508     case MoveConditionally32:
1509         return 62
1510     case MoveConditionally64:
1511         return 63
1512     case MoveConditionallyDouble:
1513         return 64
1514     case MoveConditionallyFloat:
1515         return 65
1516     case MoveConditionallyTest32:
1517         return 66
1518     case MoveConditionallyTest64:
1519         return 67
1520     case MoveDouble:
1521         return 68
1522     case MoveDoubleConditionally32:
1523         return 69
1524     case MoveDoubleConditionally64:
1525         return 70
1526     case MoveDoubleConditionallyDouble:
1527         return 71
1528     case MoveDoubleConditionallyFloat:
1529         return 72
1530     case MoveDoubleConditionallyTest32:
1531         return 73
1532     case MoveDoubleConditionallyTest64:
1533         return 74
1534     case MoveDoubleTo64:
1535         return 75
1536     case MoveFloat:
1537         return 76
1538     case MoveFloatTo32:
1539         return 77
1540     case MoveZeroToDouble:
1541         return 78
1542     case Mul32:
1543         return 79
1544     case Mul64:
1545         return 80
1546     case MulDouble:
1547         return 81
1548     case MulFloat:
1549         return 82
1550     case MultiplyAdd32:
1551         return 83
1552     case MultiplyAdd64:
1553         return 84
1554     case MultiplyNeg32:
1555         return 85
1556     case MultiplyNeg64:
1557         return 86
1558     case MultiplySub32:
1559         return 87
1560     case MultiplySub64:
1561         return 88
1562     case Neg32:
1563         return 89
1564     case Neg64:
1565         return 90
1566     case NegateDouble:
1567         return 91
1568     case Nop:
1569         return 92
1570     case Not32:
1571         return 93
1572     case Not64:
1573         return 94
1574     case Oops:
1575         return 95
1576     case Or32:
1577         return 96
1578     case Or64:
1579         return 97
1580     case Patch:
1581         return 98
1582     case Ret32:
1583         return 99
1584     case Ret64:
1585         return 100
1586     case RetDouble:
1587         return 101
1588     case RetFloat:
1589         return 102
1590     case Rshift32:
1591         return 103
1592     case Rshift64:
1593         return 104
1594     case Shuffle:
1595         return 105
1596     case SignExtend16To32:
1597         return 106
1598     case SignExtend32ToPtr:
1599         return 107
1600     case SignExtend8To32:
1601         return 108
1602     case SqrtDouble:
1603         return 109
1604     case SqrtFloat:
1605         return 110
1606     case Store16:
1607         return 111
1608     case Store8:
1609         return 112
1610     case StoreZero32:
1611         return 113
1612     case Sub32:
1613         return 114
1614     case Sub64:
1615         return 115
1616     case SubDouble:
1617         return 116
1618     case SubFloat:
1619         return 117
1620     case Swap32:
1621         return 118
1622     case Swap64:
1623         return 119
1624     case Test32:
1625         return 120
1626     case Test64:
1627         return 121
1628     case Urshift32:
1629         return 122
1630     case Urshift64:
1631         return 123
1632     case X86ConvertToDoubleWord32:
1633         return 124
1634     case X86ConvertToQuadWord64:
1635         return 125
1636     case X86Div32:
1637         return 126
1638     case X86Div64:
1639         return 127
1640     case Xor32:
1641         return 128
1642     case Xor64:
1643         return 129
1644     case XorDouble:
1645         return 130
1646     case XorFloat:
1647         return 131
1648     case ZeroExtend16To32:
1649         return 132
1650     case ZeroExtend8To32:
1651         return 133
1652     default:
1653         throw new Error("bad opcode");
1654     }
1655 }