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