1 #include <iomanip>
2 #include <sstream>
3 #include <type_traits>
4 #include <vector>
5 #include "common_types.h"
6 #include "crash.h"
7 #include "decoder.h"
8 #include "operand.h"
9 #include "teakra/disassembler.h"
10 
11 namespace Teakra::Disassembler {
12 
13 template <typename T>
ToHex(T i)14 std::string ToHex(T i) {
15     u64 v = i;
16     std::stringstream stream;
17     stream << "0x" << std::setfill('0') << std::setw(sizeof(T) * 2) << std::hex << v;
18     return stream.str();
19 }
20 
21 template <unsigned bits>
Dsm(Imm<bits> a)22 std::string Dsm(Imm<bits> a) {
23     std::string eight_mark = bits == 8 ? "u8" : "";
24     return ToHex(a.Unsigned16()) + eight_mark;
25 }
26 
27 template <unsigned bits>
Dsm(Imms<bits> a)28 std::string Dsm(Imms<bits> a) {
29     u16 value = a.Signed16();
30     bool negative = (value >> 15) != 0;
31     if (negative) {
32         value = (~value) + 1;
33     }
34     return (negative ? "-" : "+") + ToHex(value);
35 }
36 
Dsm(MemImm8 a)37 std::string Dsm(MemImm8 a) {
38     return "[page:" + Dsm((Imm8)a) + "]";
39 }
40 
Dsm(MemImm16 a)41 std::string Dsm(MemImm16 a) {
42     return "[" + Dsm((Imm16)a) + "]";
43 }
44 
Dsm(MemR7Imm16 a)45 std::string Dsm(MemR7Imm16 a) {
46     return "[r7+" + Dsm((Imm16)a) + "]";
47 }
Dsm(MemR7Imm7s a)48 std::string Dsm(MemR7Imm7s a) {
49     return "[r7" + Dsm((Imm7s)a) + "s7]";
50 }
51 
DsmReg(RegName a)52 std::string DsmReg(RegName a) {
53     switch (a) {
54     case RegName::a0:
55         return "a0";
56     case RegName::a0l:
57         return "a0l";
58     case RegName::a0h:
59         return "a0h";
60     case RegName::a0e:
61         return "a0e";
62     case RegName::a1:
63         return "a1";
64     case RegName::a1l:
65         return "a1l";
66     case RegName::a1h:
67         return "a1h";
68     case RegName::a1e:
69         return "a1e";
70     case RegName::b0:
71         return "b0";
72     case RegName::b0l:
73         return "b0l";
74     case RegName::b0h:
75         return "b0h";
76     case RegName::b0e:
77         return "b0e";
78     case RegName::b1:
79         return "b1";
80     case RegName::b1l:
81         return "b1l";
82     case RegName::b1h:
83         return "b1h";
84     case RegName::b1e:
85         return "b1e";
86 
87     case RegName::r0:
88         return "r0";
89     case RegName::r1:
90         return "r1";
91     case RegName::r2:
92         return "r2";
93     case RegName::r3:
94         return "r3";
95     case RegName::r4:
96         return "r4";
97     case RegName::r5:
98         return "r5";
99     case RegName::r6:
100         return "r6";
101     case RegName::r7:
102         return "r7";
103 
104     case RegName::ar0:
105         return "ar0";
106     case RegName::ar1:
107         return "ar1";
108     case RegName::arp0:
109         return "arp0";
110     case RegName::arp1:
111         return "arp1";
112     case RegName::arp2:
113         return "arp2";
114     case RegName::arp3:
115         return "arp3";
116     case RegName::stt0:
117         return "stt0";
118     case RegName::stt1:
119         return "stt1";
120     case RegName::stt2:
121         return "stt2";
122     case RegName::mod0:
123         return "mod0";
124     case RegName::mod1:
125         return "mod1";
126     case RegName::mod2:
127         return "mod2";
128     case RegName::mod3:
129         return "mod3";
130     case RegName::cfgi:
131         return "cfgi";
132     case RegName::cfgj:
133         return "cfgj";
134 
135     case RegName::y0:
136         return "y0";
137     case RegName::p:
138         return "p*";
139     case RegName::pc:
140         return "pc";
141     case RegName::sp:
142         return "sp";
143     case RegName::sv:
144         return "sv";
145     case RegName::lc:
146         return "lc";
147 
148     case RegName::st0:
149         return "st0";
150     case RegName::st1:
151         return "st1";
152     case RegName::st2:
153         return "st2";
154     default:
155         return "[ERROR]" + std::to_string((int)a);
156     }
157 }
158 
159 template <typename RegT>
R(RegT a)160 std::string R(RegT a) {
161     return DsmReg(a.GetName());
162 }
163 
164 template <>
R(Px a)165 std::string R(Px a) {
166     return "p" + std::to_string(a.Index());
167 }
168 
Dsm(Alm alm)169 std::string Dsm(Alm alm) {
170     switch (alm.GetName()) {
171     case AlmOp::Or:
172         return "or";
173     case AlmOp::And:
174         return "and";
175     case AlmOp::Xor:
176         return "xor";
177     case AlmOp::Add:
178         return "add";
179     case AlmOp::Tst0:
180         return "tst0";
181     case AlmOp::Tst1:
182         return "tst1";
183     case AlmOp::Cmp:
184         return "cmp";
185     case AlmOp::Sub:
186         return "sub";
187     case AlmOp::Msu:
188         return "msu";
189     case AlmOp::Addh:
190         return "addh";
191     case AlmOp::Addl:
192         return "addl";
193     case AlmOp::Subh:
194         return "subh";
195     case AlmOp::Subl:
196         return "subl";
197     case AlmOp::Sqr:
198         return "sqr";
199     case AlmOp::Sqra:
200         return "sqra";
201     case AlmOp::Cmpu:
202         return "cmpu";
203     default:
204         return "[ERROR]";
205     }
206 }
207 
Dsm(Alu alu)208 std::string Dsm(Alu alu) {
209     switch (alu.GetName()) {
210     case AlmOp::Or:
211         return "or";
212     case AlmOp::And:
213         return "and";
214     case AlmOp::Xor:
215         return "xor";
216     case AlmOp::Add:
217         return "add";
218     case AlmOp::Cmp:
219         return "cmp";
220     case AlmOp::Sub:
221         return "sub";
222     default:
223         return "[ERROR]";
224     }
225 }
226 
Dsm(Alb alb)227 std::string Dsm(Alb alb) {
228     switch (alb.GetName()) {
229     case AlbOp::Set:
230         return "set";
231     case AlbOp::Rst:
232         return "rst";
233     case AlbOp::Chng:
234         return "chng";
235     case AlbOp::Addv:
236         return "addv";
237     case AlbOp::Tst0:
238         return "tst0";
239     case AlbOp::Tst1:
240         return "tst1";
241     case AlbOp::Cmpv:
242         return "cmpv";
243     case AlbOp::Subv:
244         return "subv";
245     default:
246         return "[ERROR]";
247     }
248 }
249 
Dsm(Moda4 moda4)250 std::string Dsm(Moda4 moda4) {
251     switch (moda4.GetName()) {
252     case ModaOp::Shr:
253         return "shr";
254     case ModaOp::Shr4:
255         return "shr4";
256     case ModaOp::Shl:
257         return "shl";
258     case ModaOp::Shl4:
259         return "shl4";
260     case ModaOp::Ror:
261         return "ror";
262     case ModaOp::Rol:
263         return "rol";
264     case ModaOp::Clr:
265         return "clr";
266     case ModaOp::Not:
267         return "not";
268     case ModaOp::Neg:
269         return "neg";
270     case ModaOp::Rnd:
271         return "rnd";
272     case ModaOp::Pacr:
273         return "pacr";
274     case ModaOp::Clrr:
275         return "clrr";
276     case ModaOp::Inc:
277         return "inc";
278     case ModaOp::Dec:
279         return "dec";
280     case ModaOp::Copy:
281         return "copy";
282     default:
283         return "[ERROR]";
284     }
285 }
286 
Dsm(Moda3 moda3)287 std::string Dsm(Moda3 moda3) {
288     switch (moda3.GetName()) {
289     case ModaOp::Shr:
290         return "shr";
291     case ModaOp::Shr4:
292         return "shr4";
293     case ModaOp::Shl:
294         return "shl";
295     case ModaOp::Shl4:
296         return "shl4";
297     case ModaOp::Ror:
298         return "ror";
299     case ModaOp::Rol:
300         return "rol";
301     case ModaOp::Clr:
302         return "clr";
303     case ModaOp::Clrr:
304         return "clrr";
305     default:
306         return "[ERROR]";
307     }
308 }
309 
Dsm(Mul3 mul)310 std::string Dsm(Mul3 mul) {
311     switch (mul.GetName()) {
312     case MulOp::Mpy:
313         return "mpy";
314     case MulOp::Mpysu:
315         return "mpysu";
316     case MulOp::Mac:
317         return "mac";
318     case MulOp::Macus:
319         return "macus";
320     case MulOp::Maa:
321         return "maa";
322     case MulOp::Macuu:
323         return "macuu";
324     case MulOp::Macsu:
325         return "macsu";
326     case MulOp::Maasu:
327         return "maasu";
328     default:
329         return "[ERROR]";
330     }
331 }
332 
Dsm(Mul2 mul)333 std::string Dsm(Mul2 mul) {
334     switch (mul.GetName()) {
335     case MulOp::Mpy:
336         return "mpy";
337     case MulOp::Mac:
338         return "mac";
339     case MulOp::Maa:
340         return "maa";
341     case MulOp::Macsu:
342         return "macsu";
343     default:
344         return "[ERROR]";
345     }
346 }
347 
Dsm(Cond cond)348 std::string Dsm(Cond cond) {
349     switch (cond.GetName()) {
350     case CondValue::True:
351         return "always";
352     case CondValue::Eq:
353         return "eq";
354     case CondValue::Neq:
355         return "neq";
356     case CondValue::Gt:
357         return "gt";
358     case CondValue::Ge:
359         return "ge";
360     case CondValue::Lt:
361         return "lt";
362     case CondValue::Le:
363         return "le";
364     case CondValue::Nn:
365         return "mn";
366     case CondValue::C:
367         return "c";
368     case CondValue::V:
369         return "v";
370     case CondValue::E:
371         return "e";
372     case CondValue::L:
373         return "l";
374     case CondValue::Nr:
375         return "nr";
376     case CondValue::Niu0:
377         return "niu0";
378     case CondValue::Iu0:
379         return "iu0";
380     case CondValue::Iu1:
381         return "iu1";
382     default:
383         return "[ERROR]";
384     }
385 }
386 
Dsm(Address16 addr)387 std::string Dsm(Address16 addr) {
388     return ToHex(addr.Address32());
389 }
390 
A18(Address18_16 addr_low,Address18_2 addr_high)391 std::string A18(Address18_16 addr_low, Address18_2 addr_high) {
392     return ToHex(Address32(addr_low, addr_high));
393 }
394 
Dsm(StepZIDS step)395 std::string Dsm(StepZIDS step) {
396     switch (step.GetName()) {
397     case StepValue::Zero:
398         return "";
399     case StepValue::Increase:
400         return "++";
401     case StepValue::Decrease:
402         return "--";
403     case StepValue::PlusStep:
404         return "++s";
405     default:
406         return "[ERROR]";
407     }
408 }
409 
Dsm(std::string t)410 std::string Dsm(std::string t) {
411     return t;
412 }
413 
414 template <typename RegT>
MemR(RegT reg,StepZIDS step)415 std::string MemR(RegT reg, StepZIDS step) {
416     return "[" + R(reg) + Dsm(step) + "]";
417 }
418 
419 template <typename Reg>
MemG(Reg reg)420 std::string MemG(Reg reg) {
421     return "[" + R(reg) + "]";
422 }
423 
Dsm(CbsCond c)424 std::string Dsm(CbsCond c) {
425     switch (c.GetName()) {
426     case CbsCondValue::Ge:
427         return "ge";
428     case CbsCondValue::Gt:
429         return "gt";
430     default:
431         return "[ERROR]";
432     }
433 }
434 
435 template <typename... T>
D(T...t)436 std::vector<std::string> D(T... t) {
437     return std::vector<std::string>{Dsm(t)...};
438 }
439 
Mul(bool x_sign,bool y_sign)440 std::string Mul(bool x_sign, bool y_sign) {
441     return std::string("mpy") + (x_sign ? "sx" : "ux") + (y_sign ? "sy" : "uy");
442 }
443 
PA(SumBase base,bool sub_p0,bool p0_align,bool sub_p1,bool p1_align)444 std::string PA(SumBase base, bool sub_p0, bool p0_align, bool sub_p1, bool p1_align) {
445     std::string result;
446     switch (base) {
447     case SumBase::Zero:
448         result = "0";
449         break;
450     case SumBase::Acc:
451         result = "acc";
452         break;
453     case SumBase::Sv:
454         result = "sv";
455         break;
456     case SumBase::SvRnd:
457         result = "svr";
458         break;
459     }
460     result += sub_p0 ? "-" : "+";
461     result += "p0";
462     result += p0_align ? "a" : "";
463     result += sub_p1 ? "-" : "+";
464     result += "p1";
465     result += p1_align ? "a" : "";
466     return result;
467 }
468 
469 class Disassembler {
470 public:
471     using instruction_return_type = std::vector<std::string>;
472 
undefined(u16 opcode)473     std::vector<std::string> undefined(u16 opcode) {
474         return D("[ERROR]");
475     }
476 
nop()477     std::vector<std::string> nop() {
478         return D("nop");
479     }
480 
norm(Ax a,Rn b,StepZIDS bs)481     std::vector<std::string> norm(Ax a, Rn b, StepZIDS bs) {
482         return D("norm", R(a), MemR(b, bs));
483     }
swap(SwapType swap)484     std::vector<std::string> swap(SwapType swap) {
485         std::string desc;
486         switch (swap.GetName()) {
487         case SwapTypeValue::a0b0:
488             desc = "a0<->b0";
489             break;
490         case SwapTypeValue::a0b1:
491             desc = "a0<->b1";
492             break;
493         case SwapTypeValue::a1b0:
494             desc = "a1<->b0";
495             break;
496         case SwapTypeValue::a1b1:
497             desc = "a1<->b1";
498             break;
499         case SwapTypeValue::a0b0a1b1:
500             desc = "a<->b";
501             break;
502         case SwapTypeValue::a0b1a1b0:
503             desc = "a-x-b";
504             break;
505         case SwapTypeValue::a0b0a1:
506             desc = "a0->b0->a1";
507             break;
508         case SwapTypeValue::a0b1a1:
509             desc = "a0->b1->a1";
510             break;
511         case SwapTypeValue::a1b0a0:
512             desc = "a1->b0->a0";
513             break;
514         case SwapTypeValue::a1b1a0:
515             desc = "a1->b1->a0";
516             break;
517         case SwapTypeValue::b0a0b1:
518             desc = "b0->a0->b1";
519             break;
520         case SwapTypeValue::b0a1b1:
521             desc = "b0->a1->b1";
522             break;
523         case SwapTypeValue::b1a0b0:
524             desc = "b1->a0->b0";
525             break;
526         case SwapTypeValue::b1a1b0:
527             desc = "b1->a1->b0";
528             break;
529         default:
530             desc = "[ERROR]";
531         }
532         return D("swap", desc);
533     }
trap()534     std::vector<std::string> trap() {
535         return D("trap");
536     }
537 
alm(Alm op,MemImm8 a,Ax b)538     std::vector<std::string> alm(Alm op, MemImm8 a, Ax b) {
539         return D(op, a, R(b));
540     }
alm(Alm op,Rn a,StepZIDS as,Ax b)541     std::vector<std::string> alm(Alm op, Rn a, StepZIDS as, Ax b) {
542         return D(op, MemR(a, as), R(b));
543     }
alm(Alm op,Register a,Ax b)544     std::vector<std::string> alm(Alm op, Register a, Ax b) {
545         return D(op, R(a), R(b));
546     }
alm_r6(Alm op,Ax b)547     std::vector<std::string> alm_r6(Alm op, Ax b) {
548         return D(op, "r6", R(b));
549     }
550 
alu(Alu op,MemImm16 a,Ax b)551     std::vector<std::string> alu(Alu op, MemImm16 a, Ax b) {
552         return D(op, a, R(b));
553     }
alu(Alu op,MemR7Imm16 a,Ax b)554     std::vector<std::string> alu(Alu op, MemR7Imm16 a, Ax b) {
555         return D(op, a, R(b));
556     }
alu(Alu op,Imm16 a,Ax b)557     std::vector<std::string> alu(Alu op, Imm16 a, Ax b) {
558         return D(op, a, R(b));
559     }
alu(Alu op,Imm8 a,Ax b)560     std::vector<std::string> alu(Alu op, Imm8 a, Ax b) {
561         return D(op, a, R(b));
562     }
alu(Alu op,MemR7Imm7s a,Ax b)563     std::vector<std::string> alu(Alu op, MemR7Imm7s a, Ax b) {
564         return D(op, a, R(b));
565     }
566 
or_(Ab a,Ax b,Ax c)567     std::vector<std::string> or_(Ab a, Ax b, Ax c) {
568         return D("or", R(a), R(b), R(c));
569     }
or_(Ax a,Bx b,Ax c)570     std::vector<std::string> or_(Ax a, Bx b, Ax c) {
571         return D("or", R(a), R(b), R(c));
572     }
or_(Bx a,Bx b,Ax c)573     std::vector<std::string> or_(Bx a, Bx b, Ax c) {
574         return D("or", R(a), R(b), R(c));
575     }
576 
alb(Alb op,Imm16 a,MemImm8 b)577     std::vector<std::string> alb(Alb op, Imm16 a, MemImm8 b) {
578         return D(op, a, b);
579     }
alb(Alb op,Imm16 a,Rn b,StepZIDS bs)580     std::vector<std::string> alb(Alb op, Imm16 a, Rn b, StepZIDS bs) {
581         return D(op, a, MemR(b, bs));
582     }
alb(Alb op,Imm16 a,Register b)583     std::vector<std::string> alb(Alb op, Imm16 a, Register b) {
584         return D(op, a, R(b));
585     }
alb_r6(Alb op,Imm16 a)586     std::vector<std::string> alb_r6(Alb op, Imm16 a) {
587         return D(op, a, "r6");
588     }
alb(Alb op,Imm16 a,SttMod b)589     std::vector<std::string> alb(Alb op, Imm16 a, SttMod b) {
590         return D(op, a, R(b));
591     }
592 
add(Ab a,Bx b)593     std::vector<std::string> add(Ab a, Bx b) {
594         return D("add", R(a), R(b));
595     }
add(Bx a,Ax b)596     std::vector<std::string> add(Bx a, Ax b) {
597         return D("add", R(a), R(b));
598     }
add_p1(Ax b)599     std::vector<std::string> add_p1(Ax b) {
600         return D("add", "p1", R(b));
601     }
add(Px a,Bx b)602     std::vector<std::string> add(Px a, Bx b) {
603         return D("add", R(a), R(b));
604     }
605 
sub(Ab a,Bx b)606     std::vector<std::string> sub(Ab a, Bx b) {
607         return D("sub", R(a), R(b));
608     }
sub(Bx a,Ax b)609     std::vector<std::string> sub(Bx a, Ax b) {
610         return D("sub", R(a), R(b));
611     }
sub_p1(Ax b)612     std::vector<std::string> sub_p1(Ax b) {
613         return D("sub", "p1", R(b));
614     }
sub(Px a,Bx b)615     std::vector<std::string> sub(Px a, Bx b) {
616         return D("sub", R(a), R(b));
617     }
618 
app(Ab c,SumBase base,bool sub_p0,bool p0_align,bool sub_p1,bool p1_align)619     std::vector<std::string> app(Ab c, SumBase base, bool sub_p0, bool p0_align, bool sub_p1,
620                                  bool p1_align) {
621         return D(PA(base, sub_p0, p0_align, sub_p1, p1_align), R(c));
622     }
623 
add_add(ArpRn1 a,ArpStep1 asi,ArpStep1 asj,Ab b)624     std::vector<std::string> add_add(ArpRn1 a, ArpStep1 asi, ArpStep1 asj, Ab b) {
625         return D("add||add", MemARPSJ(a, asj), MemARPSI(a, asi), R(b));
626     }
add_sub(ArpRn1 a,ArpStep1 asi,ArpStep1 asj,Ab b)627     std::vector<std::string> add_sub(ArpRn1 a, ArpStep1 asi, ArpStep1 asj, Ab b) {
628         return D("add||sub", MemARPSJ(a, asj), MemARPSI(a, asi), R(b));
629     }
sub_add(ArpRn1 a,ArpStep1 asi,ArpStep1 asj,Ab b)630     std::vector<std::string> sub_add(ArpRn1 a, ArpStep1 asi, ArpStep1 asj, Ab b) {
631         return D("sub||add", MemARPSJ(a, asj), MemARPSI(a, asi), R(b));
632     }
sub_sub(ArpRn1 a,ArpStep1 asi,ArpStep1 asj,Ab b)633     std::vector<std::string> sub_sub(ArpRn1 a, ArpStep1 asi, ArpStep1 asj, Ab b) {
634         return D("sub||sub", MemARPSJ(a, asj), MemARPSI(a, asi), R(b));
635     }
636 
add_sub_sv(ArRn1 a,ArStep1 as,Ab b)637     std::vector<std::string> add_sub_sv(ArRn1 a, ArStep1 as, Ab b) {
638         return D("add||sub", MemARS(a, as), "sv", R(b));
639     }
sub_add_sv(ArRn1 a,ArStep1 as,Ab b)640     std::vector<std::string> sub_add_sv(ArRn1 a, ArStep1 as, Ab b) {
641         return D("sub||add", MemARS(a, as), "sv", R(b));
642     }
643 
sub_add_i_mov_j_sv(ArpRn1 a,ArpStep1 asi,ArpStep1 asj,Ab b)644     std::vector<std::string> sub_add_i_mov_j_sv(ArpRn1 a, ArpStep1 asi, ArpStep1 asj, Ab b) {
645         return D("sub||add", MemARPSI(a, asi), R(b), "||mov", MemARPSJ(a, asj), "sv");
646     }
sub_add_j_mov_i_sv(ArpRn1 a,ArpStep1 asi,ArpStep1 asj,Ab b)647     std::vector<std::string> sub_add_j_mov_i_sv(ArpRn1 a, ArpStep1 asi, ArpStep1 asj, Ab b) {
648         return D("sub||add", MemARPSJ(a, asj), R(b), "||mov", MemARPSI(a, asi), "sv");
649     }
add_sub_i_mov_j(ArpRn1 a,ArpStep1 asi,ArpStep1 asj,Ab b)650     std::vector<std::string> add_sub_i_mov_j(ArpRn1 a, ArpStep1 asi, ArpStep1 asj, Ab b) {
651         return D("add_sub", MemARPSI(a, asi), R(b), "||mov", R(b), MemARPSJ(a, asj));
652     }
add_sub_j_mov_i(ArpRn1 a,ArpStep1 asi,ArpStep1 asj,Ab b)653     std::vector<std::string> add_sub_j_mov_i(ArpRn1 a, ArpStep1 asi, ArpStep1 asj, Ab b) {
654         return D("add_sub", MemARPSJ(a, asj), R(b), "||mov", R(b), MemARPSI(a, asi));
655     }
656 
moda4(Moda4 op,Ax a,Cond cond)657     std::vector<std::string> moda4(Moda4 op, Ax a, Cond cond) {
658         return D(op, R(a), cond);
659     }
660 
moda3(Moda3 op,Bx a,Cond cond)661     std::vector<std::string> moda3(Moda3 op, Bx a, Cond cond) {
662         return D(op, R(a), cond);
663     }
664 
pacr1(Ax a)665     std::vector<std::string> pacr1(Ax a) {
666         return D("pacr p1", R(a));
667     }
clr(Ab a,Ab b)668     std::vector<std::string> clr(Ab a, Ab b) {
669         return D("clr", R(a), R(b));
670     }
clrr(Ab a,Ab b)671     std::vector<std::string> clrr(Ab a, Ab b) {
672         return D("clrr", R(a), R(b));
673     }
674 
bkrep(Imm8 a,Address16 addr)675     std::vector<std::string> bkrep(Imm8 a, Address16 addr) {
676         return D("bkrep", a, addr);
677     }
bkrep(Register a,Address18_16 addr_low,Address18_2 addr_high)678     std::vector<std::string> bkrep(Register a, Address18_16 addr_low, Address18_2 addr_high) {
679         return D("bkrep", R(a), A18(addr_low, addr_high));
680     }
bkrep_r6(Address18_16 addr_low,Address18_2 addr_high)681     std::vector<std::string> bkrep_r6(Address18_16 addr_low, Address18_2 addr_high) {
682         return D("bkrep", "r6", A18(addr_low, addr_high));
683     }
bkreprst(ArRn2 a)684     std::vector<std::string> bkreprst(ArRn2 a) {
685         return D("bkreprst", MemAR(a));
686     }
bkreprst_memsp()687     std::vector<std::string> bkreprst_memsp() {
688         return D("bkreprst", "[sp]");
689     }
bkrepsto(ArRn2 a)690     std::vector<std::string> bkrepsto(ArRn2 a) {
691         return D("bkrepsto", MemAR(a));
692     }
bkrepsto_memsp()693     std::vector<std::string> bkrepsto_memsp() {
694         return D("bkrepsto", "[sp]");
695     }
696 
banke(BankFlags flags)697     std::vector<std::string> banke(BankFlags flags) {
698         std::vector<std::string> s{"banke"};
699         if (flags.R0())
700             s.push_back("r0");
701         if (flags.R1())
702             s.push_back("r1");
703         if (flags.R4())
704             s.push_back("r4");
705         if (flags.Cfgi())
706             s.push_back("cfgi");
707         if (flags.R7())
708             s.push_back("r7");
709         if (flags.Cfgj())
710             s.push_back("cfgj");
711         return s;
712     }
bankr()713     std::vector<std::string> bankr() {
714         return D("bankr");
715     }
bankr(Ar a)716     std::vector<std::string> bankr(Ar a) {
717         return D("bankr", R(a));
718     }
bankr(Ar a,Arp b)719     std::vector<std::string> bankr(Ar a, Arp b) {
720         return D("bankr", R(a), R(b));
721     }
bankr(Arp a)722     std::vector<std::string> bankr(Arp a) {
723         return D("bankr", R(a));
724     }
725 
bitrev(Rn a)726     std::vector<std::string> bitrev(Rn a) {
727         return D("bitrev", R(a));
728     }
bitrev_dbrv(Rn a)729     std::vector<std::string> bitrev_dbrv(Rn a) {
730         return D("bitrev", R(a), "dbrv");
731     }
bitrev_ebrv(Rn a)732     std::vector<std::string> bitrev_ebrv(Rn a) {
733         return D("bitrev", R(a), "ebrv");
734     }
735 
br(Address18_16 addr_low,Address18_2 addr_high,Cond cond)736     std::vector<std::string> br(Address18_16 addr_low, Address18_2 addr_high, Cond cond) {
737         return D("br", A18(addr_low, addr_high), cond);
738     }
739 
brr(RelAddr7 addr,Cond cond)740     std::vector<std::string> brr(RelAddr7 addr, Cond cond) {
741         return D("brr", ToHex((u16)addr.Relative32()), cond);
742     }
743 
break_()744     std::vector<std::string> break_() {
745         return D("break");
746     }
747 
call(Address18_16 addr_low,Address18_2 addr_high,Cond cond)748     std::vector<std::string> call(Address18_16 addr_low, Address18_2 addr_high, Cond cond) {
749         return D("call", A18(addr_low, addr_high), cond);
750     }
calla(Axl a)751     std::vector<std::string> calla(Axl a) {
752         return D("calla", R(a));
753     }
calla(Ax a)754     std::vector<std::string> calla(Ax a) {
755         return D("calla", R(a));
756     }
callr(RelAddr7 addr,Cond cond)757     std::vector<std::string> callr(RelAddr7 addr, Cond cond) {
758         return D("callr", ToHex((u16)addr.Relative32()), cond);
759     }
760 
cntx_s()761     std::vector<std::string> cntx_s() {
762         return D("cntx", "s");
763     }
cntx_r()764     std::vector<std::string> cntx_r() {
765         return D("cntx", "r");
766     }
767 
ret(Cond c)768     std::vector<std::string> ret(Cond c) {
769         return D("ret", c);
770     }
retd()771     std::vector<std::string> retd() {
772         return D("retd");
773     }
reti(Cond c)774     std::vector<std::string> reti(Cond c) {
775         return D("reti", c);
776     }
retic(Cond c)777     std::vector<std::string> retic(Cond c) {
778         return D("retic", c);
779     }
retid()780     std::vector<std::string> retid() {
781         return D("retid");
782     }
retidc()783     std::vector<std::string> retidc() {
784         return D("retidc");
785     }
rets(Imm8 a)786     std::vector<std::string> rets(Imm8 a) {
787         return D("rets", a);
788     }
789 
load_ps(Imm2 a)790     std::vector<std::string> load_ps(Imm2 a) {
791         return D("load", a, "ps");
792     }
load_stepi(Imm7s a)793     std::vector<std::string> load_stepi(Imm7s a) {
794         return D("load", a, "stepi");
795     }
load_stepj(Imm7s a)796     std::vector<std::string> load_stepj(Imm7s a) {
797         return D("load", a, "stepj");
798     }
load_page(Imm8 a)799     std::vector<std::string> load_page(Imm8 a) {
800         return D("load", a, "page");
801     }
load_modi(Imm9 a)802     std::vector<std::string> load_modi(Imm9 a) {
803         return D("load", a, "modi");
804     }
load_modj(Imm9 a)805     std::vector<std::string> load_modj(Imm9 a) {
806         return D("load", a, "modj");
807     }
load_movpd(Imm2 a)808     std::vector<std::string> load_movpd(Imm2 a) {
809         return D("load", a, "movpd");
810     }
load_ps01(Imm4 a)811     std::vector<std::string> load_ps01(Imm4 a) {
812         return D("load", a, "ps01");
813     }
814 
push(Imm16 a)815     std::vector<std::string> push(Imm16 a) {
816         return D("push", a);
817     }
push(Register a)818     std::vector<std::string> push(Register a) {
819         return D("push", R(a));
820     }
push(Abe a)821     std::vector<std::string> push(Abe a) {
822         return D("push", R(a));
823     }
push(ArArpSttMod a)824     std::vector<std::string> push(ArArpSttMod a) {
825         return D("push", R(a));
826     }
push_prpage()827     std::vector<std::string> push_prpage() {
828         return D("push", "prpage");
829     }
push(Px a)830     std::vector<std::string> push(Px a) {
831         return D("push", R(a));
832     }
push_r6()833     std::vector<std::string> push_r6() {
834         return D("push", "r6");
835     }
push_repc()836     std::vector<std::string> push_repc() {
837         return D("push", "repc");
838     }
push_x0()839     std::vector<std::string> push_x0() {
840         return D("push", "x0");
841     }
push_x1()842     std::vector<std::string> push_x1() {
843         return D("push", "x1");
844     }
push_y1()845     std::vector<std::string> push_y1() {
846         return D("push", "y1");
847     }
pusha(Ax a)848     std::vector<std::string> pusha(Ax a) {
849         return D("pusha", R(a));
850     }
pusha(Bx a)851     std::vector<std::string> pusha(Bx a) {
852         return D("pusha", R(a));
853     }
854 
pop(Register a)855     std::vector<std::string> pop(Register a) {
856         return D("pop", R(a));
857     }
pop(Abe a)858     std::vector<std::string> pop(Abe a) {
859         return D("pop", R(a));
860     }
pop(ArArpSttMod a)861     std::vector<std::string> pop(ArArpSttMod a) {
862         return D("pop", R(a));
863     }
pop(Bx a)864     std::vector<std::string> pop(Bx a) {
865         return D("pop", R(a));
866     }
pop_prpage()867     std::vector<std::string> pop_prpage() {
868         return D("pop", "prpage");
869     }
pop(Px a)870     std::vector<std::string> pop(Px a) {
871         return D("pop", R(a));
872     }
pop_r6()873     std::vector<std::string> pop_r6() {
874         return D("pop", "r6");
875     }
pop_repc()876     std::vector<std::string> pop_repc() {
877         return D("pop", "repc");
878     }
pop_x0()879     std::vector<std::string> pop_x0() {
880         return D("pop", "x0");
881     }
pop_x1()882     std::vector<std::string> pop_x1() {
883         return D("pop", "x1");
884     }
pop_y1()885     std::vector<std::string> pop_y1() {
886         return D("pop", "y1");
887     }
popa(Ab a)888     std::vector<std::string> popa(Ab a) {
889         return D("popa", R(a));
890     }
891 
rep(Imm8 a)892     std::vector<std::string> rep(Imm8 a) {
893         return D("rep", a);
894     }
rep(Register a)895     std::vector<std::string> rep(Register a) {
896         return D("rep", R(a));
897     }
rep_r6()898     std::vector<std::string> rep_r6() {
899         return D("rep", "r6");
900     }
901 
shfc(Ab a,Ab b,Cond cond)902     std::vector<std::string> shfc(Ab a, Ab b, Cond cond) {
903         return D("shfc", R(a), R(b), cond);
904     }
shfi(Ab a,Ab b,Imm6s s)905     std::vector<std::string> shfi(Ab a, Ab b, Imm6s s) {
906         return D("shfi", R(a), R(b), s);
907     }
908 
tst4b(ArRn2 b,ArStep2 bs)909     std::vector<std::string> tst4b(ArRn2 b, ArStep2 bs) {
910         return D("tst4b", "a0l", MemARS(b, bs));
911     }
tst4b(ArRn2 b,ArStep2 bs,Ax c)912     std::vector<std::string> tst4b(ArRn2 b, ArStep2 bs, Ax c) {
913         return D("tst4b", "a0l", MemARS(b, bs), R(c));
914     }
tstb(MemImm8 a,Imm4 b)915     std::vector<std::string> tstb(MemImm8 a, Imm4 b) {
916         return D("tstb", a, b);
917     }
tstb(Rn a,StepZIDS as,Imm4 b)918     std::vector<std::string> tstb(Rn a, StepZIDS as, Imm4 b) {
919         return D("tstb", MemR(a, as), b);
920     }
tstb(Register a,Imm4 b)921     std::vector<std::string> tstb(Register a, Imm4 b) {
922         return D("tstb", R(a), b);
923     }
tstb_r6(Imm4 b)924     std::vector<std::string> tstb_r6(Imm4 b) {
925         return D("tstb", "r6", b);
926     }
tstb(SttMod a,Imm16 b)927     std::vector<std::string> tstb(SttMod a, Imm16 b) {
928         return D("tstb", R(a), b);
929     }
930 
and_(Ab a,Ab b,Ax c)931     std::vector<std::string> and_(Ab a, Ab b, Ax c) {
932         return D("and", R(a), R(b), R(c));
933     }
934 
dint()935     std::vector<std::string> dint() {
936         return D("dint");
937     }
eint()938     std::vector<std::string> eint() {
939         return D("eint");
940     }
941 
mul(Mul3 op,Rn y,StepZIDS ys,Imm16 x,Ax a)942     std::vector<std::string> mul(Mul3 op, Rn y, StepZIDS ys, Imm16 x, Ax a) {
943         return D(op, MemR(y, ys), x, R(a));
944     }
mul_y0(Mul3 op,Rn x,StepZIDS xs,Ax a)945     std::vector<std::string> mul_y0(Mul3 op, Rn x, StepZIDS xs, Ax a) {
946         return D(op, "y0", MemR(x, xs), R(a));
947     }
mul_y0(Mul3 op,Register x,Ax a)948     std::vector<std::string> mul_y0(Mul3 op, Register x, Ax a) {
949         return D(op, "y0", R(x), R(a));
950     }
mul(Mul3 op,R45 y,StepZIDS ys,R0123 x,StepZIDS xs,Ax a)951     std::vector<std::string> mul(Mul3 op, R45 y, StepZIDS ys, R0123 x, StepZIDS xs, Ax a) {
952         return D(op, MemR(y, ys), MemR(x, xs), R(a));
953     }
mul_y0_r6(Mul3 op,Ax a)954     std::vector<std::string> mul_y0_r6(Mul3 op, Ax a) {
955         return D(op, "y0", "r6", R(a));
956     }
mul_y0(Mul2 op,MemImm8 x,Ax a)957     std::vector<std::string> mul_y0(Mul2 op, MemImm8 x, Ax a) {
958         return D(op, "y0", x, R(a));
959     }
960 
mpyi(Imm8s x)961     std::vector<std::string> mpyi(Imm8s x) {
962         return D("mpyi", "y0", x);
963     }
964 
msu(R45 y,StepZIDS ys,R0123 x,StepZIDS xs,Ax a)965     std::vector<std::string> msu(R45 y, StepZIDS ys, R0123 x, StepZIDS xs, Ax a) {
966         return D("msu", MemR(y, ys), MemR(x, xs), R(a));
967     }
msu(Rn y,StepZIDS ys,Imm16 x,Ax a)968     std::vector<std::string> msu(Rn y, StepZIDS ys, Imm16 x, Ax a) {
969         return D("msu", MemR(y, ys), x, R(a));
970     }
msusu(ArRn2 x,ArStep2 xs,Ax a)971     std::vector<std::string> msusu(ArRn2 x, ArStep2 xs, Ax a) {
972         return D("msusu", "y0", MemARS(x, xs), R(a));
973     }
mac_x1to0(Ax a)974     std::vector<std::string> mac_x1to0(Ax a) {
975         return D("mac", "y0", "x1->x0", R(a));
976     }
mac1(ArpRn1 xy,ArpStep1 xis,ArpStep1 yjs,Ax a)977     std::vector<std::string> mac1(ArpRn1 xy, ArpStep1 xis, ArpStep1 yjs, Ax a) {
978         return D("mac1", MemARPSJ(xy, yjs), MemARPSI(xy, xis), R(a));
979     }
980 
modr(Rn a,StepZIDS as)981     std::vector<std::string> modr(Rn a, StepZIDS as) {
982         return D("modr", MemR(a, as));
983     }
modr_dmod(Rn a,StepZIDS as)984     std::vector<std::string> modr_dmod(Rn a, StepZIDS as) {
985         return D("modr", MemR(a, as), "dmod");
986     }
modr_i2(Rn a)987     std::vector<std::string> modr_i2(Rn a) {
988         return D("modr", R(a), "+2");
989     }
modr_i2_dmod(Rn a)990     std::vector<std::string> modr_i2_dmod(Rn a) {
991         return D("modr", R(a), "+2", "dmod");
992     }
modr_d2(Rn a)993     std::vector<std::string> modr_d2(Rn a) {
994         return D("modr", R(a), "-2");
995     }
modr_d2_dmod(Rn a)996     std::vector<std::string> modr_d2_dmod(Rn a) {
997         return D("modr", R(a), "-2", "dmod");
998     }
modr_eemod(ArpRn2 a,ArpStep2 asi,ArpStep2 asj)999     std::vector<std::string> modr_eemod(ArpRn2 a, ArpStep2 asi, ArpStep2 asj) {
1000         return D("modr", MemARPSI(a, asi), MemARPSJ(a, asj), "eemod");
1001     }
modr_edmod(ArpRn2 a,ArpStep2 asi,ArpStep2 asj)1002     std::vector<std::string> modr_edmod(ArpRn2 a, ArpStep2 asi, ArpStep2 asj) {
1003         return D("modr", MemARPSI(a, asi), MemARPSJ(a, asj), "edmod");
1004     }
modr_demod(ArpRn2 a,ArpStep2 asi,ArpStep2 asj)1005     std::vector<std::string> modr_demod(ArpRn2 a, ArpStep2 asi, ArpStep2 asj) {
1006         return D("modr", MemARPSI(a, asi), MemARPSJ(a, asj), "demod");
1007     }
modr_ddmod(ArpRn2 a,ArpStep2 asi,ArpStep2 asj)1008     std::vector<std::string> modr_ddmod(ArpRn2 a, ArpStep2 asi, ArpStep2 asj) {
1009         return D("modr", MemARPSI(a, asi), MemARPSJ(a, asj), "ddmod");
1010     }
1011 
movd(R0123 a,StepZIDS as,R45 b,StepZIDS bs)1012     std::vector<std::string> movd(R0123 a, StepZIDS as, R45 b, StepZIDS bs) {
1013         return D("mov d->p", MemR(a, as), MemR(b, bs));
1014     }
movp(Axl a,Register b)1015     std::vector<std::string> movp(Axl a, Register b) {
1016         return D("mov p->r", MemG(a), R(b));
1017     }
movp(Ax a,Register b)1018     std::vector<std::string> movp(Ax a, Register b) {
1019         return D("mov p->r", MemG(a), R(b));
1020     }
movp(Rn a,StepZIDS as,R0123 b,StepZIDS bs)1021     std::vector<std::string> movp(Rn a, StepZIDS as, R0123 b, StepZIDS bs) {
1022         return D("mov p->d", MemR(a, as), MemR(b, bs));
1023     }
movpdw(Ax a)1024     std::vector<std::string> movpdw(Ax a) {
1025         return D("mov p->pc", MemG(a));
1026     }
1027 
mov(Ab a,Ab b)1028     std::vector<std::string> mov(Ab a, Ab b) {
1029         return D("mov", R(a), R(b));
1030     }
mov_dvm(Abl a)1031     std::vector<std::string> mov_dvm(Abl a) {
1032         return D("mov", R(a), "dvm");
1033     }
mov_x0(Abl a)1034     std::vector<std::string> mov_x0(Abl a) {
1035         return D("mov", R(a), "x0");
1036     }
mov_x1(Abl a)1037     std::vector<std::string> mov_x1(Abl a) {
1038         return D("mov", R(a), "x1");
1039     }
mov_y1(Abl a)1040     std::vector<std::string> mov_y1(Abl a) {
1041         return D("mov", R(a), "y1");
1042     }
mov(Ablh a,MemImm8 b)1043     std::vector<std::string> mov(Ablh a, MemImm8 b) {
1044         return D("mov", R(a), b);
1045     }
mov(Axl a,MemImm16 b)1046     std::vector<std::string> mov(Axl a, MemImm16 b) {
1047         return D("mov", R(a), b);
1048     }
mov(Axl a,MemR7Imm16 b)1049     std::vector<std::string> mov(Axl a, MemR7Imm16 b) {
1050         return D("mov", R(a), b);
1051     }
mov(Axl a,MemR7Imm7s b)1052     std::vector<std::string> mov(Axl a, MemR7Imm7s b) {
1053         return D("mov", R(a), b);
1054     }
mov(MemImm16 a,Ax b)1055     std::vector<std::string> mov(MemImm16 a, Ax b) {
1056         return D("mov", a, R(b));
1057     }
mov(MemImm8 a,Ab b)1058     std::vector<std::string> mov(MemImm8 a, Ab b) {
1059         return D("mov", a, R(b));
1060     }
mov(MemImm8 a,Ablh b)1061     std::vector<std::string> mov(MemImm8 a, Ablh b) {
1062         return D("mov", a, R(b));
1063     }
mov_eu(MemImm8 a,Axh b)1064     std::vector<std::string> mov_eu(MemImm8 a, Axh b) {
1065         return D("mov", a, R(b), "eu");
1066     }
mov(MemImm8 a,RnOld b)1067     std::vector<std::string> mov(MemImm8 a, RnOld b) {
1068         return D("mov", a, R(b));
1069     }
mov_sv(MemImm8 a)1070     std::vector<std::string> mov_sv(MemImm8 a) {
1071         return D("mov", a, "sv");
1072     }
mov_dvm_to(Ab b)1073     std::vector<std::string> mov_dvm_to(Ab b) {
1074         return D("mov", "dvm", R(b));
1075     }
mov_icr_to(Ab b)1076     std::vector<std::string> mov_icr_to(Ab b) {
1077         return D("mov", "icr", R(b));
1078     }
mov(Imm16 a,Bx b)1079     std::vector<std::string> mov(Imm16 a, Bx b) {
1080         return D("mov", a, R(b));
1081     }
mov(Imm16 a,Register b)1082     std::vector<std::string> mov(Imm16 a, Register b) {
1083         return D("mov", a, R(b));
1084     }
mov_icr(Imm5 a)1085     std::vector<std::string> mov_icr(Imm5 a) {
1086         return D("mov", a, "icr");
1087     }
mov(Imm8s a,Axh b)1088     std::vector<std::string> mov(Imm8s a, Axh b) {
1089         return D("mov", a, R(b));
1090     }
mov(Imm8s a,RnOld b)1091     std::vector<std::string> mov(Imm8s a, RnOld b) {
1092         return D("mov", a, R(b));
1093     }
mov_sv(Imm8s a)1094     std::vector<std::string> mov_sv(Imm8s a) {
1095         return D("mov", a, "sv");
1096     }
mov(Imm8 a,Axl b)1097     std::vector<std::string> mov(Imm8 a, Axl b) {
1098         return D("mov", a, R(b));
1099     }
mov(MemR7Imm16 a,Ax b)1100     std::vector<std::string> mov(MemR7Imm16 a, Ax b) {
1101         return D("mov", a, R(b));
1102     }
mov(MemR7Imm7s a,Ax b)1103     std::vector<std::string> mov(MemR7Imm7s a, Ax b) {
1104         return D("mov", a, R(b));
1105     }
mov(Rn a,StepZIDS as,Bx b)1106     std::vector<std::string> mov(Rn a, StepZIDS as, Bx b) {
1107         return D("mov", MemR(a, as), R(b));
1108     }
mov(Rn a,StepZIDS as,Register b)1109     std::vector<std::string> mov(Rn a, StepZIDS as, Register b) {
1110         return D("mov", MemR(a, as), R(b));
1111     }
mov_memsp_to(Register b)1112     std::vector<std::string> mov_memsp_to(Register b) {
1113         return D("mov", "[sp]", R(b));
1114     }
mov_mixp_to(Register b)1115     std::vector<std::string> mov_mixp_to(Register b) {
1116         return D("mov", "mixp", R(b));
1117     }
mov(RnOld a,MemImm8 b)1118     std::vector<std::string> mov(RnOld a, MemImm8 b) {
1119         return D("mov", R(a), b);
1120     }
mov_icr(Register a)1121     std::vector<std::string> mov_icr(Register a) {
1122         return D("mov", R(a), "icr");
1123     }
mov_mixp(Register a)1124     std::vector<std::string> mov_mixp(Register a) {
1125         return D("mov", R(a), "mixp");
1126     }
mov(Register a,Rn b,StepZIDS bs)1127     std::vector<std::string> mov(Register a, Rn b, StepZIDS bs) {
1128         return D("mov", R(a), MemR(b, bs));
1129     }
mov(Register a,Bx b)1130     std::vector<std::string> mov(Register a, Bx b) {
1131         std::string a_mark;
1132         if (a.GetName() == RegName::a0 || a.GetName() == RegName::a1) {
1133             a_mark = "?";
1134         }
1135         return D("mov" + a_mark, R(a), R(b));
1136     }
mov(Register a,Register b)1137     std::vector<std::string> mov(Register a, Register b) {
1138         return D("mov", R(a), R(b));
1139     }
mov_repc_to(Ab b)1140     std::vector<std::string> mov_repc_to(Ab b) {
1141         return D("mov", "repc", R(b));
1142     }
mov_sv_to(MemImm8 b)1143     std::vector<std::string> mov_sv_to(MemImm8 b) {
1144         return D("mov", "sv", b);
1145     }
mov_x0_to(Ab b)1146     std::vector<std::string> mov_x0_to(Ab b) {
1147         return D("mov", "x0", R(b));
1148     }
mov_x1_to(Ab b)1149     std::vector<std::string> mov_x1_to(Ab b) {
1150         return D("mov", "x1", R(b));
1151     }
mov_y1_to(Ab b)1152     std::vector<std::string> mov_y1_to(Ab b) {
1153         return D("mov", "y1", R(b));
1154     }
mov(Imm16 a,ArArp b)1155     std::vector<std::string> mov(Imm16 a, ArArp b) {
1156         return D("mov", a, R(b));
1157     }
mov_r6(Imm16 a)1158     std::vector<std::string> mov_r6(Imm16 a) {
1159         return D("mov", a, "r6");
1160     }
mov_repc(Imm16 a)1161     std::vector<std::string> mov_repc(Imm16 a) {
1162         return D("mov", a, "repc");
1163     }
mov_stepi0(Imm16 a)1164     std::vector<std::string> mov_stepi0(Imm16 a) {
1165         return D("mov", a, "stepi0");
1166     }
mov_stepj0(Imm16 a)1167     std::vector<std::string> mov_stepj0(Imm16 a) {
1168         return D("mov", a, "stepj0");
1169     }
mov(Imm16 a,SttMod b)1170     std::vector<std::string> mov(Imm16 a, SttMod b) {
1171         return D("mov", a, R(b));
1172     }
mov_prpage(Imm4 a)1173     std::vector<std::string> mov_prpage(Imm4 a) {
1174         return D("mov", a, "prpage");
1175     }
1176 
mov_a0h_stepi0()1177     std::vector<std::string> mov_a0h_stepi0() {
1178         return D("mov", "a0h", "stepi0");
1179     }
mov_a0h_stepj0()1180     std::vector<std::string> mov_a0h_stepj0() {
1181         return D("mov", "a0h", "stepj0");
1182     }
mov_stepi0_a0h()1183     std::vector<std::string> mov_stepi0_a0h() {
1184         return D("mov", "stepi0", "a0h");
1185     }
mov_stepj0_a0h()1186     std::vector<std::string> mov_stepj0_a0h() {
1187         return D("mov", "stepj0", "a0h");
1188     }
1189 
mov_prpage(Abl a)1190     std::vector<std::string> mov_prpage(Abl a) {
1191         return D("mov", R(a), "prpage");
1192     }
mov_repc(Abl a)1193     std::vector<std::string> mov_repc(Abl a) {
1194         return D("mov", R(a), "repc");
1195     }
mov(Abl a,ArArp b)1196     std::vector<std::string> mov(Abl a, ArArp b) {
1197         return D("mov", R(a), R(b));
1198     }
mov(Abl a,SttMod b)1199     std::vector<std::string> mov(Abl a, SttMod b) {
1200         return D("mov", R(a), R(b));
1201     }
1202 
mov_prpage_to(Abl b)1203     std::vector<std::string> mov_prpage_to(Abl b) {
1204         return D("mov", "prpage", R(b));
1205     }
mov_repc_to(Abl b)1206     std::vector<std::string> mov_repc_to(Abl b) {
1207         return D("mov", "repc", R(b));
1208     }
mov(ArArp a,Abl b)1209     std::vector<std::string> mov(ArArp a, Abl b) {
1210         return D("mov", R(a), R(b));
1211     }
mov(SttMod a,Abl b)1212     std::vector<std::string> mov(SttMod a, Abl b) {
1213         return D("mov", R(a), R(b));
1214     }
1215 
mov_repc_to(ArRn1 b,ArStep1 bs)1216     std::vector<std::string> mov_repc_to(ArRn1 b, ArStep1 bs) {
1217         return D("mov", "repc", MemARS(b, bs));
1218     }
mov(ArArp a,ArRn1 b,ArStep1 bs)1219     std::vector<std::string> mov(ArArp a, ArRn1 b, ArStep1 bs) {
1220         return D("mov", R(a), MemARS(b, bs));
1221     }
mov(SttMod a,ArRn1 b,ArStep1 bs)1222     std::vector<std::string> mov(SttMod a, ArRn1 b, ArStep1 bs) {
1223         return D("mov", R(a), MemARS(b, bs));
1224     }
1225 
mov_repc(ArRn1 a,ArStep1 as)1226     std::vector<std::string> mov_repc(ArRn1 a, ArStep1 as) {
1227         return D("mov", MemARS(a, as), "repc");
1228     }
mov(ArRn1 a,ArStep1 as,ArArp b)1229     std::vector<std::string> mov(ArRn1 a, ArStep1 as, ArArp b) {
1230         return D("mov", MemARS(a, as), R(b));
1231     }
mov(ArRn1 a,ArStep1 as,SttMod b)1232     std::vector<std::string> mov(ArRn1 a, ArStep1 as, SttMod b) {
1233         return D("mov", MemARS(a, as), R(b));
1234     }
1235 
mov_repc_to(MemR7Imm16 b)1236     std::vector<std::string> mov_repc_to(MemR7Imm16 b) {
1237         return D("mov", "repc", b);
1238     }
mov(ArArpSttMod a,MemR7Imm16 b)1239     std::vector<std::string> mov(ArArpSttMod a, MemR7Imm16 b) {
1240         return D("mov", R(a), b);
1241     }
1242 
mov_repc(MemR7Imm16 a)1243     std::vector<std::string> mov_repc(MemR7Imm16 a) {
1244         return D("mov", a, "repc");
1245     }
mov(MemR7Imm16 a,ArArpSttMod b)1246     std::vector<std::string> mov(MemR7Imm16 a, ArArpSttMod b) {
1247         return D("mov", a, R(b));
1248     }
1249 
mov_pc(Ax a)1250     std::vector<std::string> mov_pc(Ax a) {
1251         return D("mov", R(a), "pc");
1252     }
mov_pc(Bx a)1253     std::vector<std::string> mov_pc(Bx a) {
1254         return D("mov", R(a), "pc");
1255     }
1256 
mov_mixp_to(Bx b)1257     std::vector<std::string> mov_mixp_to(Bx b) {
1258         return D("mov", "mixp", R(b));
1259     }
mov_mixp_r6()1260     std::vector<std::string> mov_mixp_r6() {
1261         return D("mov", "mixp", "r6");
1262     }
mov_p0h_to(Bx b)1263     std::vector<std::string> mov_p0h_to(Bx b) {
1264         return D("mov", "p0h", R(b));
1265     }
mov_p0h_r6()1266     std::vector<std::string> mov_p0h_r6() {
1267         return D("mov", "p0h", "r6");
1268     }
mov_p0h_to(Register b)1269     std::vector<std::string> mov_p0h_to(Register b) {
1270         return D("mov", "p0h", R(b));
1271     }
mov_p0(Ab a)1272     std::vector<std::string> mov_p0(Ab a) {
1273         return D("mov", R(a), "p0");
1274     }
mov_p1_to(Ab b)1275     std::vector<std::string> mov_p1_to(Ab b) {
1276         return D("mov", "p1", R(b));
1277     }
1278 
mov2(Px a,ArRn2 b,ArStep2 bs)1279     std::vector<std::string> mov2(Px a, ArRn2 b, ArStep2 bs) {
1280         return D("mov", R(a), MemARS(b, bs));
1281     }
mov2s(Px a,ArRn2 b,ArStep2 bs)1282     std::vector<std::string> mov2s(Px a, ArRn2 b, ArStep2 bs) {
1283         return D("mov s", R(a), MemARS(b, bs));
1284     }
mov2(ArRn2 a,ArStep2 as,Px b)1285     std::vector<std::string> mov2(ArRn2 a, ArStep2 as, Px b) {
1286         return D("mov", MemARS(a, as), R(b));
1287     }
mova(Ab a,ArRn2 b,ArStep2 bs)1288     std::vector<std::string> mova(Ab a, ArRn2 b, ArStep2 bs) {
1289         return D("mov", R(a), MemARS(b, bs));
1290     }
mova(ArRn2 a,ArStep2 as,Ab b)1291     std::vector<std::string> mova(ArRn2 a, ArStep2 as, Ab b) {
1292         return D("mov", MemARS(a, as), R(b));
1293     }
1294 
mov_r6_to(Bx b)1295     std::vector<std::string> mov_r6_to(Bx b) {
1296         return D("mov", "r6", R(b));
1297     }
mov_r6_mixp()1298     std::vector<std::string> mov_r6_mixp() {
1299         return D("mov", "r6", "mixp");
1300     }
mov_r6_to(Register b)1301     std::vector<std::string> mov_r6_to(Register b) {
1302         return D("mov", "r6", R(b));
1303     }
mov_r6(Register a)1304     std::vector<std::string> mov_r6(Register a) {
1305         return D("mov", R(a), "r6");
1306     }
mov_memsp_r6()1307     std::vector<std::string> mov_memsp_r6() {
1308         return D("mov", "[sp]", "r6");
1309     }
mov_r6_to(Rn b,StepZIDS bs)1310     std::vector<std::string> mov_r6_to(Rn b, StepZIDS bs) {
1311         return D("mov", "r6", MemR(b, bs));
1312     }
mov_r6(Rn a,StepZIDS as)1313     std::vector<std::string> mov_r6(Rn a, StepZIDS as) {
1314         return D("mov", MemR(a, as), "r6");
1315     }
1316 
movs(MemImm8 a,Ab b)1317     std::vector<std::string> movs(MemImm8 a, Ab b) {
1318         return D("movs", a, R(b));
1319     }
movs(Rn a,StepZIDS as,Ab b)1320     std::vector<std::string> movs(Rn a, StepZIDS as, Ab b) {
1321         return D("movs", MemR(a, as), R(b));
1322     }
movs(Register a,Ab b)1323     std::vector<std::string> movs(Register a, Ab b) {
1324         return D("movs", R(a), R(b));
1325     }
movs_r6_to(Ax b)1326     std::vector<std::string> movs_r6_to(Ax b) {
1327         return D("movs", "r6", R(b));
1328     }
movsi(RnOld a,Ab b,Imm5s s)1329     std::vector<std::string> movsi(RnOld a, Ab b, Imm5s s) {
1330         return D("movsi", R(a), R(b), s);
1331     }
1332 
mov2_axh_m_y0_m(Axh a,ArRn2 b,ArStep2 bs)1333     std::vector<std::string> mov2_axh_m_y0_m(Axh a, ArRn2 b, ArStep2 bs) {
1334         return D("mov||mov", R(a), "y0", MemARS(b, bs));
1335     }
mov2_ax_mij(Ab a,ArpRn1 b,ArpStep1 bsi,ArpStep1 bsj)1336     std::vector<std::string> mov2_ax_mij(Ab a, ArpRn1 b, ArpStep1 bsi, ArpStep1 bsj) {
1337         return D("mov hilj", R(a), MemARPSI(b, bsi), MemARPSJ(b, bsj));
1338     }
mov2_ax_mji(Ab a,ArpRn1 b,ArpStep1 bsi,ArpStep1 bsj)1339     std::vector<std::string> mov2_ax_mji(Ab a, ArpRn1 b, ArpStep1 bsi, ArpStep1 bsj) {
1340         return D("mov lihj", R(a), MemARPSI(b, bsi), MemARPSJ(b, bsj));
1341     }
mov2_mij_ax(ArpRn1 a,ArpStep1 asi,ArpStep1 asj,Ab b)1342     std::vector<std::string> mov2_mij_ax(ArpRn1 a, ArpStep1 asi, ArpStep1 asj, Ab b) {
1343         return D("mov hilj", MemARPSI(a, asi), MemARPSJ(a, asj), R(b));
1344     }
mov2_mji_ax(ArpRn1 a,ArpStep1 asi,ArpStep1 asj,Ab b)1345     std::vector<std::string> mov2_mji_ax(ArpRn1 a, ArpStep1 asi, ArpStep1 asj, Ab b) {
1346         return D("mov lihj", MemARPSI(a, asi), MemARPSJ(a, asj), R(b));
1347     }
mov2_abh_m(Abh ax,Abh ay,ArRn1 b,ArStep1 bs)1348     std::vector<std::string> mov2_abh_m(Abh ax, Abh ay, ArRn1 b, ArStep1 bs) {
1349         return D("mov||mov", R(ax), R(ay), MemARS(b, bs));
1350     }
exchange_iaj(Axh a,ArpRn2 b,ArpStep2 bsi,ArpStep2 bsj)1351     std::vector<std::string> exchange_iaj(Axh a, ArpRn2 b, ArpStep2 bsi, ArpStep2 bsj) {
1352         return D("exchange i->a->j", R(a), MemARPSI(b, bsi), MemARPSJ(b, bsj));
1353     }
exchange_riaj(Axh a,ArpRn2 b,ArpStep2 bsi,ArpStep2 bsj)1354     std::vector<std::string> exchange_riaj(Axh a, ArpRn2 b, ArpStep2 bsi, ArpStep2 bsj) {
1355         return D("exchange ri->a->j", R(a), MemARPSI(b, bsi), MemARPSJ(b, bsj));
1356     }
exchange_jai(Axh a,ArpRn2 b,ArpStep2 bsi,ArpStep2 bsj)1357     std::vector<std::string> exchange_jai(Axh a, ArpRn2 b, ArpStep2 bsi, ArpStep2 bsj) {
1358         return D("exchange j->a->i", R(a), MemARPSI(b, bsi), MemARPSJ(b, bsj));
1359     }
exchange_rjai(Axh a,ArpRn2 b,ArpStep2 bsi,ArpStep2 bsj)1360     std::vector<std::string> exchange_rjai(Axh a, ArpRn2 b, ArpStep2 bsi, ArpStep2 bsj) {
1361         return D("exchange rj->a->i", R(a), MemARPSI(b, bsi), MemARPSJ(b, bsj));
1362     }
1363 
movr(ArRn2 a,ArStep2 as,Abh b)1364     std::vector<std::string> movr(ArRn2 a, ArStep2 as, Abh b) {
1365         return D("movr", MemARS(a, as), R(b));
1366     }
movr(Rn a,StepZIDS as,Ax b)1367     std::vector<std::string> movr(Rn a, StepZIDS as, Ax b) {
1368         return D("movr", MemR(a, as), R(b));
1369     }
movr(Register a,Ax b)1370     std::vector<std::string> movr(Register a, Ax b) {
1371         return D("movr", R(a), R(b));
1372     }
movr(Bx a,Ax b)1373     std::vector<std::string> movr(Bx a, Ax b) {
1374         return D("movr", R(a), R(b));
1375     }
movr_r6_to(Ax b)1376     std::vector<std::string> movr_r6_to(Ax b) {
1377         return D("movr", "r6", R(b));
1378     }
1379 
exp(Bx a)1380     std::vector<std::string> exp(Bx a) {
1381         return D("exp", R(a));
1382     }
exp(Bx a,Ax b)1383     std::vector<std::string> exp(Bx a, Ax b) {
1384         return D("exp", R(a), R(b));
1385     }
exp(Rn a,StepZIDS as)1386     std::vector<std::string> exp(Rn a, StepZIDS as) {
1387         return D("exp", MemR(a, as));
1388     }
exp(Rn a,StepZIDS as,Ax b)1389     std::vector<std::string> exp(Rn a, StepZIDS as, Ax b) {
1390         return D("exp", MemR(a, as), R(b));
1391     }
exp(Register a)1392     std::vector<std::string> exp(Register a) {
1393         return D("exp", R(a));
1394     }
exp(Register a,Ax b)1395     std::vector<std::string> exp(Register a, Ax b) {
1396         return D("exp", R(a), R(b));
1397     }
exp_r6()1398     std::vector<std::string> exp_r6() {
1399         return D("exp", "r6");
1400     }
exp_r6(Ax b)1401     std::vector<std::string> exp_r6(Ax b) {
1402         return D("exp", "r6", R(b));
1403     }
1404 
lim(Ax a,Ax b)1405     std::vector<std::string> lim(Ax a, Ax b) {
1406         return D("lim", R(a), R(b));
1407     }
1408 
vtrclr0()1409     std::vector<std::string> vtrclr0() {
1410         return D("vtrclr0");
1411     }
vtrclr1()1412     std::vector<std::string> vtrclr1() {
1413         return D("vtrclr1");
1414     }
vtrclr()1415     std::vector<std::string> vtrclr() {
1416         return D("vtrclr");
1417     }
vtrmov0(Axl a)1418     std::vector<std::string> vtrmov0(Axl a) {
1419         return D("vtrmov0", R(a));
1420     }
vtrmov1(Axl a)1421     std::vector<std::string> vtrmov1(Axl a) {
1422         return D("vtrmov1", R(a));
1423     }
vtrmov(Axl a)1424     std::vector<std::string> vtrmov(Axl a) {
1425         return D("vtrmov", R(a));
1426     }
vtrshr()1427     std::vector<std::string> vtrshr() {
1428         return D("vtrshr");
1429     }
1430 
clrp0()1431     std::vector<std::string> clrp0() {
1432         return D("clr0");
1433     }
clrp1()1434     std::vector<std::string> clrp1() {
1435         return D("clr1");
1436     }
clrp()1437     std::vector<std::string> clrp() {
1438         return D("clr");
1439     }
1440 
max_ge(Ax a,StepZIDS bs)1441     std::vector<std::string> max_ge(Ax a, StepZIDS bs) {
1442         return D("max_ge", R(a), "^", "r0", bs);
1443     }
max_gt(Ax a,StepZIDS bs)1444     std::vector<std::string> max_gt(Ax a, StepZIDS bs) {
1445         return D("max_gt", R(a), "^", "r0", bs);
1446     }
min_le(Ax a,StepZIDS bs)1447     std::vector<std::string> min_le(Ax a, StepZIDS bs) {
1448         return D("min_le", R(a), "^", "r0", bs);
1449     }
min_lt(Ax a,StepZIDS bs)1450     std::vector<std::string> min_lt(Ax a, StepZIDS bs) {
1451         return D("min_lt", R(a), "^", "r0", bs);
1452     }
1453 
max_ge_r0(Ax a,StepZIDS bs)1454     std::vector<std::string> max_ge_r0(Ax a, StepZIDS bs) {
1455         return D("max_ge", R(a), "[r0]", bs);
1456     }
max_gt_r0(Ax a,StepZIDS bs)1457     std::vector<std::string> max_gt_r0(Ax a, StepZIDS bs) {
1458         return D("max_gt", R(a), "[r0]", bs);
1459     }
min_le_r0(Ax a,StepZIDS bs)1460     std::vector<std::string> min_le_r0(Ax a, StepZIDS bs) {
1461         return D("min_le", R(a), "[r0]", bs);
1462     }
min_lt_r0(Ax a,StepZIDS bs)1463     std::vector<std::string> min_lt_r0(Ax a, StepZIDS bs) {
1464         return D("min_lt", R(a), "[r0]", bs);
1465     }
divs(MemImm8 a,Ax b)1466     std::vector<std::string> divs(MemImm8 a, Ax b) {
1467         return D("divs", a, R(b));
1468     }
1469 
sqr_sqr_add3(Ab a,Ab b)1470     std::vector<std::string> sqr_sqr_add3(Ab a, Ab b) {
1471         return D("sqr h||l", R(a), "||add3", R(b));
1472     }
sqr_sqr_add3(ArRn2 a,ArStep2 as,Ab b)1473     std::vector<std::string> sqr_sqr_add3(ArRn2 a, ArStep2 as, Ab b) {
1474         return D("sqr h||l", MemARS(a, as), "||add3", R(b));
1475     }
sqr_mpysu_add3a(Ab a,Ab b)1476     std::vector<std::string> sqr_mpysu_add3a(Ab a, Ab b) {
1477         return D("sqr h||mpysu hl", R(a), "||add3a", R(b));
1478     }
1479 
cmp(Ax a,Bx b)1480     std::vector<std::string> cmp(Ax a, Bx b) {
1481         return D("cmp", R(a), R(b));
1482     }
cmp_b0_b1()1483     std::vector<std::string> cmp_b0_b1() {
1484         return D("cmp", "b0", "b1");
1485     }
cmp_b1_b0()1486     std::vector<std::string> cmp_b1_b0() {
1487         return D("cmp", "b1", "b0");
1488     }
cmp(Bx a,Ax b)1489     std::vector<std::string> cmp(Bx a, Ax b) {
1490         return D("cmp", R(a), R(b));
1491     }
cmp_p1_to(Ax b)1492     std::vector<std::string> cmp_p1_to(Ax b) {
1493         return D("cmp", "p1", R(b));
1494     }
1495 
max2_vtr(Ax a)1496     std::vector<std::string> max2_vtr(Ax a) {
1497         return D("max h||l", R(a), "||vtrshr");
1498     }
min2_vtr(Ax a)1499     std::vector<std::string> min2_vtr(Ax a) {
1500         return D("min h||l", R(a), "||vtrshr");
1501     }
max2_vtr(Ax a,Bx b)1502     std::vector<std::string> max2_vtr(Ax a, Bx b) {
1503         return D("max h||l", R(a), R(b), "||vtrshr");
1504     }
min2_vtr(Ax a,Bx b)1505     std::vector<std::string> min2_vtr(Ax a, Bx b) {
1506         return D("min h||l", R(a), R(b), "||vtrshr");
1507     }
max2_vtr_movl(Ax a,Bx b,ArRn1 c,ArStep1 cs)1508     std::vector<std::string> max2_vtr_movl(Ax a, Bx b, ArRn1 c, ArStep1 cs) {
1509         return D("max h||l", R(a), R(b), "||vtrshr", "||mov^l", R(a), MemARS(c, cs));
1510     }
max2_vtr_movh(Ax a,Bx b,ArRn1 c,ArStep1 cs)1511     std::vector<std::string> max2_vtr_movh(Ax a, Bx b, ArRn1 c, ArStep1 cs) {
1512         return D("max h||l", R(a), R(b), "||vtrshr", "||mov^h", R(a), MemARS(c, cs));
1513     }
max2_vtr_movl(Bx a,Ax b,ArRn1 c,ArStep1 cs)1514     std::vector<std::string> max2_vtr_movl(Bx a, Ax b, ArRn1 c, ArStep1 cs) {
1515         return D("max h||l", R(a), R(b), "||vtrshr", "||mov^l", R(a), MemARS(c, cs));
1516     }
max2_vtr_movh(Bx a,Ax b,ArRn1 c,ArStep1 cs)1517     std::vector<std::string> max2_vtr_movh(Bx a, Ax b, ArRn1 c, ArStep1 cs) {
1518         return D("max h||l", R(a), R(b), "||vtrshr", "||mov^h", R(a), MemARS(c, cs));
1519     }
min2_vtr_movl(Ax a,Bx b,ArRn1 c,ArStep1 cs)1520     std::vector<std::string> min2_vtr_movl(Ax a, Bx b, ArRn1 c, ArStep1 cs) {
1521         return D("min h||l", R(a), R(b), "||vtrshr", "||mov^l", R(a), MemARS(c, cs));
1522     }
min2_vtr_movh(Ax a,Bx b,ArRn1 c,ArStep1 cs)1523     std::vector<std::string> min2_vtr_movh(Ax a, Bx b, ArRn1 c, ArStep1 cs) {
1524         return D("min h||l", R(a), R(b), "||vtrshr", "||mov^h", R(a), MemARS(c, cs));
1525     }
min2_vtr_movl(Bx a,Ax b,ArRn1 c,ArStep1 cs)1526     std::vector<std::string> min2_vtr_movl(Bx a, Ax b, ArRn1 c, ArStep1 cs) {
1527         return D("min h||l", R(a), R(b), "||vtrshr", "||mov^l", R(a), MemARS(c, cs));
1528     }
min2_vtr_movh(Bx a,Ax b,ArRn1 c,ArStep1 cs)1529     std::vector<std::string> min2_vtr_movh(Bx a, Ax b, ArRn1 c, ArStep1 cs) {
1530         return D("min h||l", R(a), R(b), "||vtrshr", "||mov^h", R(a), MemARS(c, cs));
1531     }
max2_vtr_movij(Ax a,Bx b,ArpRn1 c,ArpStep1 csi,ArpStep1 csj)1532     std::vector<std::string> max2_vtr_movij(Ax a, Bx b, ArpRn1 c, ArpStep1 csi, ArpStep1 csj) {
1533         return D("max h||l", R(a), R(b), "||vtrshr", "||mov^hilj", R(a), MemARPSI(c, csi),
1534                  MemARPSJ(c, csj));
1535     }
max2_vtr_movji(Ax a,Bx b,ArpRn1 c,ArpStep1 csi,ArpStep1 csj)1536     std::vector<std::string> max2_vtr_movji(Ax a, Bx b, ArpRn1 c, ArpStep1 csi, ArpStep1 csj) {
1537         return D("max h||l", R(a), R(b), "||vtrshr", "||mov^hjli", R(a), MemARPSI(c, csi),
1538                  MemARPSJ(c, csj));
1539     }
min2_vtr_movij(Ax a,Bx b,ArpRn1 c,ArpStep1 csi,ArpStep1 csj)1540     std::vector<std::string> min2_vtr_movij(Ax a, Bx b, ArpRn1 c, ArpStep1 csi, ArpStep1 csj) {
1541         return D("min h||l", R(a), R(b), "||vtrshr", "||mov^hilj", R(a), MemARPSI(c, csi),
1542                  MemARPSJ(c, csj));
1543     }
min2_vtr_movji(Ax a,Bx b,ArpRn1 c,ArpStep1 csi,ArpStep1 csj)1544     std::vector<std::string> min2_vtr_movji(Ax a, Bx b, ArpRn1 c, ArpStep1 csi, ArpStep1 csj) {
1545         return D("min h||l", R(a), R(b), "||vtrshr", "||mov^hjli", R(a), MemARPSI(c, csi),
1546                  MemARPSJ(c, csj));
1547     }
1548 
1549     template <typename ArpStepX>
mov_sv_app(ArRn1 a,ArpStepX as,Bx b,SumBase base,bool sub_p0,bool p0_align,bool sub_p1,bool p1_align)1550     std::vector<std::string> mov_sv_app(ArRn1 a, ArpStepX as, Bx b, SumBase base, bool sub_p0,
1551                                         bool p0_align, bool sub_p1, bool p1_align) {
1552         return D("mov", MemARS(a, as), "sv", PA(base, sub_p0, p0_align, sub_p1, p1_align), R(b));
1553     }
1554 
cbs(Axh a,CbsCond c)1555     std::vector<std::string> cbs(Axh a, CbsCond c) {
1556         return D("cbs", R(a), "r0", c);
1557     }
cbs(Axh a,Bxh b,CbsCond c)1558     std::vector<std::string> cbs(Axh a, Bxh b, CbsCond c) {
1559         return D("cbs", R(a), R(b), "r0", c);
1560     }
cbs(ArpRn1 a,ArpStep1 asi,ArpStep1 asj,CbsCond c)1561     std::vector<std::string> cbs(ArpRn1 a, ArpStep1 asi, ArpStep1 asj, CbsCond c) {
1562         return D("cbs", MemARPSI(a, asi), MemARPSJ(a, asj), c);
1563     }
1564 
mma(RegName a,bool x0_sign,bool y0_sign,bool x1_sign,bool y1_sign,SumBase base,bool sub_p0,bool p0_align,bool sub_p1,bool p1_align)1565     std::vector<std::string> mma(RegName a, bool x0_sign, bool y0_sign, bool x1_sign, bool y1_sign,
1566                                  SumBase base, bool sub_p0, bool p0_align, bool sub_p1,
1567                                  bool p1_align) {
1568         return D("x0<->x1", PA(base, sub_p0, p0_align, sub_p1, p1_align), DsmReg(a),
1569                  Mul(x0_sign, y0_sign), Mul(x1_sign, y1_sign));
1570     }
1571 
1572     template <typename ArpRnX, typename ArpStepX>
mma(ArpRnX xy,ArpStepX i,ArpStepX j,bool dmodi,bool dmodj,RegName a,bool x0_sign,bool y0_sign,bool x1_sign,bool y1_sign,SumBase base,bool sub_p0,bool p0_align,bool sub_p1,bool p1_align)1573     std::vector<std::string> mma(ArpRnX xy, ArpStepX i, ArpStepX j, bool dmodi, bool dmodj,
1574                                  RegName a, bool x0_sign, bool y0_sign, bool x1_sign, bool y1_sign,
1575                                  SumBase base, bool sub_p0, bool p0_align, bool sub_p1,
1576                                  bool p1_align) {
1577         return D("xy<-", MemARPSI(xy, i), MemARPSJ(xy, j),
1578                  PA(base, sub_p0, p0_align, sub_p1, p1_align), DsmReg(a), Mul(x0_sign, y0_sign),
1579                  Mul(x1_sign, y1_sign), dmodi ? "dmodi" : "", dmodj ? "dmodj" : "");
1580     }
1581 
mma_mx_xy(ArRn1 y,ArStep1 ys,RegName a,bool x0_sign,bool y0_sign,bool x1_sign,bool y1_sign,SumBase base,bool sub_p0,bool p0_align,bool sub_p1,bool p1_align)1582     std::vector<std::string> mma_mx_xy(ArRn1 y, ArStep1 ys, RegName a, bool x0_sign, bool y0_sign,
1583                                        bool x1_sign, bool y1_sign, SumBase base, bool sub_p0,
1584                                        bool p0_align, bool sub_p1, bool p1_align) {
1585         return D("x0<->x1, y0<-", MemARS(y, ys), PA(base, sub_p0, p0_align, sub_p1, p1_align),
1586                  DsmReg(a), Mul(x0_sign, y0_sign), Mul(x1_sign, y1_sign));
1587     }
1588 
mma_xy_mx(ArRn1 y,ArStep1 ys,RegName a,bool x0_sign,bool y0_sign,bool x1_sign,bool y1_sign,SumBase base,bool sub_p0,bool p0_align,bool sub_p1,bool p1_align)1589     std::vector<std::string> mma_xy_mx(ArRn1 y, ArStep1 ys, RegName a, bool x0_sign, bool y0_sign,
1590                                        bool x1_sign, bool y1_sign, SumBase base, bool sub_p0,
1591                                        bool p0_align, bool sub_p1, bool p1_align) {
1592         return D("x0<->x1, y1<-", MemARS(y, ys), PA(base, sub_p0, p0_align, sub_p1, p1_align),
1593                  DsmReg(a), Mul(x0_sign, y0_sign), Mul(x1_sign, y1_sign));
1594     }
1595 
mma_my_my(ArRn1 x,ArStep1 xs,RegName a,bool x0_sign,bool y0_sign,bool x1_sign,bool y1_sign,SumBase base,bool sub_p0,bool p0_align,bool sub_p1,bool p1_align)1596     std::vector<std::string> mma_my_my(ArRn1 x, ArStep1 xs, RegName a, bool x0_sign, bool y0_sign,
1597                                        bool x1_sign, bool y1_sign, SumBase base, bool sub_p0,
1598                                        bool p0_align, bool sub_p1, bool p1_align) {
1599         return D("x<-", MemARS(x, xs), PA(base, sub_p0, p0_align, sub_p1, p1_align), DsmReg(a),
1600                  Mul(x0_sign, y0_sign), Mul(x1_sign, y1_sign));
1601     }
1602 
mma_mov(Axh u,Bxh v,ArRn1 w,ArStep1 ws,RegName a,bool x0_sign,bool y0_sign,bool x1_sign,bool y1_sign,SumBase base,bool sub_p0,bool p0_align,bool sub_p1,bool p1_align)1603     std::vector<std::string> mma_mov(Axh u, Bxh v, ArRn1 w, ArStep1 ws, RegName a, bool x0_sign,
1604                                      bool y0_sign, bool x1_sign, bool y1_sign, SumBase base,
1605                                      bool sub_p0, bool p0_align, bool sub_p1, bool p1_align) {
1606         return D("mov", R(u), R(v), MemARS(w, ws), "x0<->x1",
1607                  PA(base, sub_p0, p0_align, sub_p1, p1_align), DsmReg(a), Mul(x0_sign, y0_sign),
1608                  Mul(x1_sign, y1_sign));
1609     }
1610 
mma_mov(ArRn2 w,ArStep1 ws,RegName a,bool x0_sign,bool y0_sign,bool x1_sign,bool y1_sign,SumBase base,bool sub_p0,bool p0_align,bool sub_p1,bool p1_align)1611     std::vector<std::string> mma_mov(ArRn2 w, ArStep1 ws, RegName a, bool x0_sign, bool y0_sign,
1612                                      bool x1_sign, bool y1_sign, SumBase base, bool sub_p0,
1613                                      bool p0_align, bool sub_p1, bool p1_align) {
1614         return D("mov,^", DsmReg(a), MemARS(w, ws), "x0<->x1",
1615                  PA(base, sub_p0, p0_align, sub_p1, p1_align), DsmReg(a), Mul(x0_sign, y0_sign),
1616                  Mul(x1_sign, y1_sign));
1617     }
1618 
addhp(ArRn2 a,ArStep2 as,Px b,Ax c)1619     std::vector<std::string> addhp(ArRn2 a, ArStep2 as, Px b, Ax c) {
1620         return D("addhp", MemARS(a, as), R(b), R(c));
1621     }
1622 
mov_ext0(Imm8s a)1623     std::vector<std::string> mov_ext0(Imm8s a) {
1624         return D("mov", a, "ext0");
1625     }
mov_ext1(Imm8s a)1626     std::vector<std::string> mov_ext1(Imm8s a) {
1627         return D("mov", a, "ext1");
1628     }
mov_ext2(Imm8s a)1629     std::vector<std::string> mov_ext2(Imm8s a) {
1630         return D("mov", a, "ext2");
1631     }
mov_ext3(Imm8s a)1632     std::vector<std::string> mov_ext3(Imm8s a) {
1633         return D("mov", a, "ext3");
1634     }
1635 
SetArArp(std::optional<ArArpSettings> ar_arp)1636     void SetArArp(std::optional<ArArpSettings> ar_arp) {
1637         this->ar_arp = ar_arp;
1638     }
1639 
1640 private:
1641     template <typename ArRn>
DsmArRn(ArRn a)1642     std::string DsmArRn(ArRn a) {
1643         if (ar_arp) {
1644             return "%r" +
1645                    std::to_string((ar_arp->ar[a.Index() / 2] >> (13 - 3 * (a.Index() % 2))) & 7);
1646         }
1647         return "arrn" + std::to_string(a.Index());
1648     }
1649 
ConvertArStepAndOffset(u16 v)1650     std::string ConvertArStepAndOffset(u16 v) {
1651         static const std::array<std::string, 8> step_names{{
1652             "++0",
1653             "++1",
1654             "--1",
1655             "++s",
1656             "++2",
1657             "--2",
1658             "++2*",
1659             "--2*",
1660         }};
1661 
1662         static const std::array<std::string, 4> offset_names{{
1663             "+0",
1664             "+1",
1665             "-1",
1666             "-1*",
1667         }};
1668 
1669         return offset_names[v >> 3] + step_names[v & 7];
1670     }
1671 
1672     template <typename ArStep>
DsmArStep(ArStep a)1673     std::string DsmArStep(ArStep a) {
1674         if (ar_arp) {
1675             u16 s = (ar_arp->ar[a.Index() / 2] >> (5 - 5 * (a.Index() % 2))) & 31;
1676             return ConvertArStepAndOffset(s);
1677         }
1678         return "+ars" + std::to_string(a.Index());
1679     }
1680 
1681     template <typename ArpRn>
DsmArpRni(ArpRn a)1682     std::string DsmArpRni(ArpRn a) {
1683         if (ar_arp) {
1684             return "%r" + std::to_string((ar_arp->arp[a.Index()] >> 10) & 3);
1685         }
1686         return "arprni" + std::to_string(a.Index());
1687     }
1688 
1689     template <typename ArpStep>
DsmArpStepi(ArpStep a)1690     std::string DsmArpStepi(ArpStep a) {
1691         if (ar_arp) {
1692             u16 s = ar_arp->arp[a.Index()] & 31;
1693             return ConvertArStepAndOffset(s);
1694         }
1695         return "+arpsi" + std::to_string(a.Index());
1696     }
1697 
1698     template <typename ArpRn>
DsmArpRnj(ArpRn a)1699     std::string DsmArpRnj(ArpRn a) {
1700         if (ar_arp) {
1701             return "%r" + std::to_string(((ar_arp->arp[a.Index()] >> 13) & 3) + 4);
1702         }
1703         return "arprnj" + std::to_string(a.Index());
1704     }
1705 
1706     template <typename ArpStep>
DsmArpStepj(ArpStep a)1707     std::string DsmArpStepj(ArpStep a) {
1708         if (ar_arp) {
1709             u16 s = (ar_arp->arp[a.Index()] >> 5) & 31;
1710             return ConvertArStepAndOffset(s);
1711         }
1712         return "+arpsj" + std::to_string(a.Index());
1713     }
1714 
1715     template <typename ArRn, typename ArStep>
MemARS(ArRn reg,ArStep step)1716     std::string MemARS(ArRn reg, ArStep step) {
1717         return "[" + DsmArRn(reg) + DsmArStep(step) + "]";
1718     }
1719 
1720     template <typename ArpRn, typename ArpStep>
MemARPSI(ArpRn reg,ArpStep step)1721     std::string MemARPSI(ArpRn reg, ArpStep step) {
1722         return "[" + DsmArpRni(reg) + DsmArpStepi(step) + "]";
1723     }
1724 
1725     template <typename ArpRn, typename ArpStep>
MemARPSJ(ArpRn reg,ArpStep step)1726     std::string MemARPSJ(ArpRn reg, ArpStep step) {
1727         return "[" + DsmArpRnj(reg) + DsmArpStepj(step) + "]";
1728     }
1729 
1730     template <typename ArRn>
MemAR(ArRn reg)1731     std::string MemAR(ArRn reg) {
1732         return "[" + DsmArRn(reg) + "]";
1733     }
1734 
1735     std::optional<ArArpSettings> ar_arp;
1736 };
1737 
NeedExpansion(std::uint16_t opcode)1738 bool NeedExpansion(std::uint16_t opcode) {
1739     auto decoder = Decode<Disassembler>(opcode);
1740     return decoder.NeedExpansion();
1741 }
1742 
GetTokenList(std::uint16_t opcode,std::uint16_t expansion,std::optional<ArArpSettings> ar_arp)1743 std::vector<std::string> GetTokenList(std::uint16_t opcode, std::uint16_t expansion,
1744                                       std::optional<ArArpSettings> ar_arp) {
1745     Disassembler dsm;
1746     dsm.SetArArp(ar_arp);
1747     auto decoder = Decode<Disassembler>(opcode);
1748     auto v = decoder.call(dsm, opcode, expansion);
1749     return v;
1750 }
1751 
Do(std::uint16_t opcode,std::uint16_t expansion,std::optional<ArArpSettings> ar_arp)1752 std::string Do(std::uint16_t opcode, std::uint16_t expansion, std::optional<ArArpSettings> ar_arp) {
1753     auto v = GetTokenList(opcode, expansion, ar_arp);
1754     std::string last = v.back();
1755     std::string result;
1756     v.pop_back();
1757     for (const auto& s : v) {
1758         result += s + "    ";
1759     }
1760     return result + last;
1761 }
1762 
1763 } // namespace Teakra::Disassembler
1764