?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
testsuite, threads: fix LD_LIBRARY_PATH in 'tls-sepdebug.exp'
[binutils-gdb.git] / opcodes / rl78-decode.c
blobf3e8269e4d2368ab94e776ec9234db78a8299dc9
1 /* DO NOT EDIT! -*- buffer-read-only: t -*- vi:set ro: */
2 #line 1 "rl78-decode.opc"
3 /* -*- c -*- */
4 /* Copyright (C) 2012-2024 Free Software Foundation, Inc.
5 Contributed by Red Hat.
6 Written by DJ Delorie.
7
8 This file is part of the GNU opcodes library.
9
10 This library is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
13 any later version.
14
15 It is distributed in the hope that it will be useful, but WITHOUT
16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
17 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
18 License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
23 MA 02110-1301, USA. */
24
25 #include "sysdep.h"
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include "bfd.h"
30 #include "opintl.h"
31 #include "opcode/rl78.h"
32
33 static int trace = 0;
34
35 typedef struct
36 {
37 RL78_Opcode_Decoded * rl78;
38 int (* getbyte)(void *);
39 void * ptr;
40 unsigned char * op;
41 } LocalData;
42
43 #define ID(x) rl78->id = RLO_##x, rl78->lineno = __LINE__
44 #define OP(n,t,r,a) (rl78->op[n].type = t, \
45 rl78->op[n].reg = r, \
46 rl78->op[n].addend = a )
47 #define OPX(n,t,r1,r2,a) \
48 (rl78->op[n].type = t, \
49 rl78->op[n].reg = r1, \
50 rl78->op[n].reg2 = r2, \
51 rl78->op[n].addend = a )
52
53 #define W() rl78->size = RL78_Word
54
55 #define AU ATTRIBUTE_UNUSED
56
57 #define OP_BUF_LEN 20
58 #define GETBYTE() (ld->rl78->n_bytes < (OP_BUF_LEN - 1) ? ld->op [ld->rl78->n_bytes++] = ld->getbyte (ld->ptr): 0)
59 #define B ((unsigned long) GETBYTE())
60
61 #define SYNTAX(x) rl78->syntax = x
62
63 #define UNSUPPORTED() \
64 rl78->syntax = "*unknown*"
65
66 #define RB(x) ((x)+RL78_Reg_X)
67 #define RW(x) ((x)+RL78_Reg_AX)
68
69 #define Fz rl78->flags = RL78_PSW_Z
70 #define Fza rl78->flags = RL78_PSW_Z | RL78_PSW_AC
71 #define Fzc rl78->flags = RL78_PSW_Z | RL78_PSW_CY
72 #define Fzac rl78->flags = RL78_PSW_Z | RL78_PSW_AC | RL78_PSW_CY
73 #define Fa rl78->flags = RL78_PSW_AC
74 #define Fc rl78->flags = RL78_PSW_CY
75 #define Fac rl78->flags = RL78_PSW_AC | RL78_PSW_CY
76
77 #define IMMU(bytes) immediate (bytes, 0, ld)
78 #define IMMS(bytes) immediate (bytes, 1, ld)
79
80 static int
81 immediate (int bytes, int sign_extend, LocalData * ld)
82 {
83 unsigned long i = 0;
84
85 switch (bytes)
86 {
87 case 1:
88 i |= B;
89 if (sign_extend && (i & 0x80))
90 i -= 0x100;
91 break;
92 case 2:
93 i |= B;
94 i |= B << 8;
95 if (sign_extend && (i & 0x8000))
96 i -= 0x10000;
97 break;
98 case 3:
99 i |= B;
100 i |= B << 8;
101 i |= B << 16;
102 if (sign_extend && (i & 0x800000))
103 i -= 0x1000000;
104 break;
105 default:
106 opcodes_error_handler
107 /* xgettext:c-format */
108 (_("internal error: immediate() called with invalid byte count %d"),
109 bytes);
110 abort();
111 }
112 return i;
113 }
114
115 #define DC(c) OP (0, RL78_Operand_Immediate, 0, c)
116 #define DR(r) OP (0, RL78_Operand_Register, RL78_Reg_##r, 0)
117 #define DRB(r) OP (0, RL78_Operand_Register, RB(r), 0)
118 #define DRW(r) OP (0, RL78_Operand_Register, RW(r), 0)
119 #define DM(r,a) OP (0, RL78_Operand_Indirect, RL78_Reg_##r, a)
120 #define DM2(r1,r2,a) OPX (0, RL78_Operand_Indirect, RL78_Reg_##r1, RL78_Reg_##r2, a)
121 #define DE() rl78->op[0].use_es = 1
122 #define DB(b) set_bit (rl78->op, b)
123 #define DCY() DR(PSW); DB(0)
124 #define DPUSH() OP (0, RL78_Operand_PreDec, RL78_Reg_SP, 0);
125
126 #define SC(c) OP (1, RL78_Operand_Immediate, 0, c)
127 #define SR(r) OP (1, RL78_Operand_Register, RL78_Reg_##r, 0)
128 #define SRB(r) OP (1, RL78_Operand_Register, RB(r), 0)
129 #define SRW(r) OP (1, RL78_Operand_Register, RW(r), 0)
130 #define SM(r,a) OP (1, RL78_Operand_Indirect, RL78_Reg_##r, a)
131 #define SM2(r1,r2,a) OPX (1, RL78_Operand_Indirect, RL78_Reg_##r1, RL78_Reg_##r2, a)
132 #define SE() rl78->op[1].use_es = 1
133 #define SB(b) set_bit (rl78->op+1, b)
134 #define SCY() SR(PSW); SB(0)
135 #define COND(c) rl78->op[1].condition = RL78_Condition_##c
136 #define SPOP() OP (1, RL78_Operand_PostInc, RL78_Reg_SP, 0);
137
138 static void
139 set_bit (RL78_Opcode_Operand *op, int bit)
140 {
141 op->bit_number = bit;
142 switch (op->type) {
143 case RL78_Operand_Register:
144 op->type = RL78_Operand_Bit;
145 break;
146 case RL78_Operand_Indirect:
147 op->type = RL78_Operand_BitIndirect;
148 break;
149 default:
150 break;
151 }
152 }
153
154 static int
155 saddr (int x)
156 {
157 if (x < 0x20)
158 return 0xfff00 + x;
159 return 0xffe00 + x;
160 }
161
162 static int
163 sfr (int x)
164 {
165 return 0xfff00 + x;
166 }
167
168 #define SADDR saddr (IMMU (1))
169 #define SFR sfr (IMMU (1))
170
171 int
172 rl78_decode_opcode (unsigned long pc AU,
173 RL78_Opcode_Decoded * rl78,
174 int (* getbyte)(void *),
175 void * ptr,
176 RL78_Dis_Isa isa)
177 {
178 LocalData lds, * ld = &lds;
179 unsigned char op_buf[OP_BUF_LEN] = {0};
180 unsigned char *op = op_buf;
181 int op0, op1;
182
183 lds.rl78 = rl78;
184 lds.getbyte = getbyte;
185 lds.ptr = ptr;
186 lds.op = op;
187
188 memset (rl78, 0, sizeof (*rl78));
189
190 start_again:
191
192 /* Byte registers, not including A. */
193 /* Word registers, not including AX. */
194
195 /*----------------------------------------------------------------------*/
196 /* ES: prefix */
197
198 GETBYTE ();
199 switch (op[0] & 0xff)
200 {
201 case 0x00:
202 {
203 /** 0000 0000 nop */
204 if (trace)
205 {
206 printf ("\033[33m%s\033[0m %02x\n",
207 "/** 0000 0000 nop */",
208 op[0]);
209 }
210 SYNTAX("nop");
211 #line 917 "rl78-decode.opc"
212 ID(nop);
213
214 /*----------------------------------------------------------------------*/
215
216 }
217 break;
218 case 0x01:
219 case 0x03:
220 case 0x05:
221 case 0x07:
222 {
223 /** 0000 0rw1 addw %0, %1 */
224 #line 280 "rl78-decode.opc"
225 int rw AU = (op[0] >> 1) & 0x03;
226 if (trace)
227 {
228 printf ("\033[33m%s\033[0m %02x\n",
229 "/** 0000 0rw1 addw %0, %1 */",
230 op[0]);
231 printf (" rw = 0x%x\n", rw);
232 }
233 SYNTAX("addw %0, %1");
234 #line 280 "rl78-decode.opc"
235 ID(add); W(); DR(AX); SRW(rw); Fzac;
236
237 }
238 break;
239 case 0x02:
240 {
241 /** 0000 0010 addw %0, %e!1 */
242 if (trace)
243 {
244 printf ("\033[33m%s\033[0m %02x\n",
245 "/** 0000 0010 addw %0, %e!1 */",
246 op[0]);
247 }
248 SYNTAX("addw %0, %e!1");
249 #line 271 "rl78-decode.opc"
250 ID(add); W(); DR(AX); SM(None, IMMU(2)); Fzac;
251
252 }
253 break;
254 case 0x04:
255 {
256 /** 0000 0100 addw %0, #%1 */
257 if (trace)
258 {
259 printf ("\033[33m%s\033[0m %02x\n",
260 "/** 0000 0100 addw %0, #%1 */",
261 op[0]);
262 }
263 SYNTAX("addw %0, #%1");
264 #line 277 "rl78-decode.opc"
265 ID(add); W(); DR(AX); SC(IMMU(2)); Fzac;
266
267 }
268 break;
269 case 0x06:
270 {
271 /** 0000 0110 addw %0, %1 */
272 if (trace)
273 {
274 printf ("\033[33m%s\033[0m %02x\n",
275 "/** 0000 0110 addw %0, %1 */",
276 op[0]);
277 }
278 SYNTAX("addw %0, %1");
279 #line 283 "rl78-decode.opc"
280 ID(add); W(); DR(AX); SM(None, SADDR); Fzac;
281
282 }
283 break;
284 case 0x08:
285 {
286 /** 0000 1000 xch a, x */
287 if (trace)
288 {
289 printf ("\033[33m%s\033[0m %02x\n",
290 "/** 0000 1000 xch a, x */",
291 op[0]);
292 }
293 SYNTAX("xch a, x");
294 #line 1240 "rl78-decode.opc"
295 ID(xch); DR(A); SR(X);
296
297 /*----------------------------------------------------------------------*/
298
299 }
300 break;
301 case 0x09:
302 {
303 /** 0000 1001 mov %0, %e1 */
304 if (trace)
305 {
306 printf ("\033[33m%s\033[0m %02x\n",
307 "/** 0000 1001 mov %0, %e1 */",
308 op[0]);
309 }
310 SYNTAX("mov %0, %e1");
311 #line 684 "rl78-decode.opc"
312 ID(mov); DR(A); SM(B, IMMU(2));
313
314 }
315 break;
316 case 0x0a:
317 {
318 /** 0000 1010 add %0, #%1 */
319 if (trace)
320 {
321 printf ("\033[33m%s\033[0m %02x\n",
322 "/** 0000 1010 add %0, #%1 */",
323 op[0]);
324 }
325 SYNTAX("add %0, #%1");
326 #line 234 "rl78-decode.opc"
327 ID(add); DM(None, SADDR); SC(IMMU(1)); Fzac;
328
329 /*----------------------------------------------------------------------*/
330
331 }
332 break;
333 case 0x0b:
334 {
335 /** 0000 1011 add %0, %1 */
336 if (trace)
337 {
338 printf ("\033[33m%s\033[0m %02x\n",
339 "/** 0000 1011 add %0, %1 */",
340 op[0]);
341 }
342 SYNTAX("add %0, %1");
343 #line 228 "rl78-decode.opc"
344 ID(add); DR(A); SM(None, SADDR); Fzac;
345
346 }
347 break;
348 case 0x0c:
349 {
350 /** 0000 1100 add %0, #%1 */
351 if (trace)
352 {
353 printf ("\033[33m%s\033[0m %02x\n",
354 "/** 0000 1100 add %0, #%1 */",
355 op[0]);
356 }
357 SYNTAX("add %0, #%1");
358 #line 222 "rl78-decode.opc"
359 ID(add); DR(A); SC(IMMU(1)); Fzac;
360
361 }
362 break;
363 case 0x0d:
364 {
365 /** 0000 1101 add %0, %e1 */
366 if (trace)
367 {
368 printf ("\033[33m%s\033[0m %02x\n",
369 "/** 0000 1101 add %0, %e1 */",
370 op[0]);
371 }
372 SYNTAX("add %0, %e1");
373 #line 210 "rl78-decode.opc"
374 ID(add); DR(A); SM(HL, 0); Fzac;
375
376 }
377 break;
378 case 0x0e:
379 {
380 /** 0000 1110 add %0, %ea1 */
381 if (trace)
382 {
383 printf ("\033[33m%s\033[0m %02x\n",
384 "/** 0000 1110 add %0, %ea1 */",
385 op[0]);
386 }
387 SYNTAX("add %0, %ea1");
388 #line 216 "rl78-decode.opc"
389 ID(add); DR(A); SM(HL, IMMU(1)); Fzac;
390
391 }
392 break;
393 case 0x0f:
394 {
395 /** 0000 1111 add %0, %e!1 */
396 if (trace)
397 {
398 printf ("\033[33m%s\033[0m %02x\n",
399 "/** 0000 1111 add %0, %e!1 */",
400 op[0]);
401 }
402 SYNTAX("add %0, %e!1");
403 #line 207 "rl78-decode.opc"
404 ID(add); DR(A); SM(None, IMMU(2)); Fzac;
405
406 }
407 break;
408 case 0x10:
409 {
410 /** 0001 0000 addw %0, #%1 */
411 if (trace)
412 {
413 printf ("\033[33m%s\033[0m %02x\n",
414 "/** 0001 0000 addw %0, #%1 */",
415 op[0]);
416 }
417 SYNTAX("addw %0, #%1");
418 #line 286 "rl78-decode.opc"
419 ID(add); W(); DR(SP); SC(IMMU(1)); Fzac;
420
421 /*----------------------------------------------------------------------*/
422
423 }
424 break;
425 case 0x11:
426 {
427 /** 0001 0001 es: */
428 if (trace)
429 {
430 printf ("\033[33m%s\033[0m %02x\n",
431 "/** 0001 0001 es: */",
432 op[0]);
433 }
434 SYNTAX("es:");
435 #line 199 "rl78-decode.opc"
436 DE(); SE();
437 op ++;
438 pc ++;
439 goto start_again;
440
441 /*----------------------------------------------------------------------*/
442
443 }
444 break;
445 case 0x12:
446 case 0x14:
447 case 0x16:
448 {
449 /** 0001 0ra0 movw %0, %1 */
450 #line 865 "rl78-decode.opc"
451 int ra AU = (op[0] >> 1) & 0x03;
452 if (trace)
453 {
454 printf ("\033[33m%s\033[0m %02x\n",
455 "/** 0001 0ra0 movw %0, %1 */",
456 op[0]);
457 printf (" ra = 0x%x\n", ra);
458 }
459 SYNTAX("movw %0, %1");
460 #line 865 "rl78-decode.opc"
461 ID(mov); W(); DRW(ra); SR(AX);
462
463 }
464 break;
465 case 0x13:
466 case 0x15:
467 case 0x17:
468 {
469 /** 0001 0ra1 movw %0, %1 */
470 #line 862 "rl78-decode.opc"
471 int ra AU = (op[0] >> 1) & 0x03;
472 if (trace)
473 {
474 printf ("\033[33m%s\033[0m %02x\n",
475 "/** 0001 0ra1 movw %0, %1 */",
476 op[0]);
477 printf (" ra = 0x%x\n", ra);
478 }
479 SYNTAX("movw %0, %1");
480 #line 862 "rl78-decode.opc"
481 ID(mov); W(); DR(AX); SRW(ra);
482
483 }
484 break;
485 case 0x18:
486 {
487 /** 0001 1000 mov %e0, %1 */
488 if (trace)
489 {
490 printf ("\033[33m%s\033[0m %02x\n",
491 "/** 0001 1000 mov %e0, %1 */",
492 op[0]);
493 }
494 SYNTAX("mov %e0, %1");
495 #line 735 "rl78-decode.opc"
496 ID(mov); DM(B, IMMU(2)); SR(A);
497
498 }
499 break;
500 case 0x19:
501 {
502 /** 0001 1001 mov %e0, #%1 */
503 if (trace)
504 {
505 printf ("\033[33m%s\033[0m %02x\n",
506 "/** 0001 1001 mov %e0, #%1 */",
507 op[0]);
508 }
509 SYNTAX("mov %e0, #%1");
510 #line 732 "rl78-decode.opc"
511 ID(mov); DM(B, IMMU(2)); SC(IMMU(1));
512
513 }
514 break;
515 case 0x1a:
516 {
517 /** 0001 1010 addc %0, #%1 */
518 if (trace)
519 {
520 printf ("\033[33m%s\033[0m %02x\n",
521 "/** 0001 1010 addc %0, #%1 */",
522 op[0]);
523 }
524 SYNTAX("addc %0, #%1");
525 #line 266 "rl78-decode.opc"
526 ID(addc); DM(None, SADDR); SC(IMMU(1)); Fzac;
527
528 /*----------------------------------------------------------------------*/
529
530 }
531 break;
532 case 0x1b:
533 {
534 /** 0001 1011 addc %0, %1 */
535 if (trace)
536 {
537 printf ("\033[33m%s\033[0m %02x\n",
538 "/** 0001 1011 addc %0, %1 */",
539 op[0]);
540 }
541 SYNTAX("addc %0, %1");
542 #line 263 "rl78-decode.opc"
543 ID(addc); DR(A); SM(None, SADDR); Fzac;
544
545 }
546 break;
547 case 0x1c:
548 {
549 /** 0001 1100 addc %0, #%1 */
550 if (trace)
551 {
552 printf ("\033[33m%s\033[0m %02x\n",
553 "/** 0001 1100 addc %0, #%1 */",
554 op[0]);
555 }
556 SYNTAX("addc %0, #%1");
557 #line 254 "rl78-decode.opc"
558 ID(addc); DR(A); SC(IMMU(1)); Fzac;
559
560 }
561 break;
562 case 0x1d:
563 {
564 /** 0001 1101 addc %0, %e1 */
565 if (trace)
566 {
567 printf ("\033[33m%s\033[0m %02x\n",
568 "/** 0001 1101 addc %0, %e1 */",
569 op[0]);
570 }
571 SYNTAX("addc %0, %e1");
572 #line 242 "rl78-decode.opc"
573 ID(addc); DR(A); SM(HL, 0); Fzac;
574
575 }
576 break;
577 case 0x1e:
578 {
579 /** 0001 1110 addc %0, %ea1 */
580 if (trace)
581 {
582 printf ("\033[33m%s\033[0m %02x\n",
583 "/** 0001 1110 addc %0, %ea1 */",
584 op[0]);
585 }
586 SYNTAX("addc %0, %ea1");
587 #line 251 "rl78-decode.opc"
588 ID(addc); DR(A); SM(HL, IMMU(1)); Fzac;
589
590 }
591 break;
592 case 0x1f:
593 {
594 /** 0001 1111 addc %0, %e!1 */
595 if (trace)
596 {
597 printf ("\033[33m%s\033[0m %02x\n",
598 "/** 0001 1111 addc %0, %e!1 */",
599 op[0]);
600 }
601 SYNTAX("addc %0, %e!1");
602 #line 239 "rl78-decode.opc"
603 ID(addc); DR(A); SM(None, IMMU(2)); Fzac;
604
605 }
606 break;
607 case 0x20:
608 {
609 /** 0010 0000 subw %0, #%1 */
610 if (trace)
611 {
612 printf ("\033[33m%s\033[0m %02x\n",
613 "/** 0010 0000 subw %0, #%1 */",
614 op[0]);
615 }
616 SYNTAX("subw %0, #%1");
617 #line 1204 "rl78-decode.opc"
618 ID(sub); W(); DR(SP); SC(IMMU(1)); Fzac;
619
620 /*----------------------------------------------------------------------*/
621
622 }
623 break;
624 case 0x21:
625 case 0x23:
626 case 0x25:
627 case 0x27:
628 {
629 /** 0010 0rw1 subw %0, %1 */
630 #line 1198 "rl78-decode.opc"
631 int rw AU = (op[0] >> 1) & 0x03;
632 if (trace)
633 {
634 printf ("\033[33m%s\033[0m %02x\n",
635 "/** 0010 0rw1 subw %0, %1 */",
636 op[0]);
637 printf (" rw = 0x%x\n", rw);
638 }
639 SYNTAX("subw %0, %1");
640 #line 1198 "rl78-decode.opc"
641 ID(sub); W(); DR(AX); SRW(rw); Fzac;
642
643 }
644 break;
645 case 0x22:
646 {
647 /** 0010 0010 subw %0, %e!1 */
648 if (trace)
649 {
650 printf ("\033[33m%s\033[0m %02x\n",
651 "/** 0010 0010 subw %0, %e!1 */",
652 op[0]);
653 }
654 SYNTAX("subw %0, %e!1");
655 #line 1189 "rl78-decode.opc"
656 ID(sub); W(); DR(AX); SM(None, IMMU(2)); Fzac;
657
658 }
659 break;
660 case 0x24:
661 {
662 /** 0010 0100 subw %0, #%1 */
663 if (trace)
664 {
665 printf ("\033[33m%s\033[0m %02x\n",
666 "/** 0010 0100 subw %0, #%1 */",
667 op[0]);
668 }
669 SYNTAX("subw %0, #%1");
670 #line 1195 "rl78-decode.opc"
671 ID(sub); W(); DR(AX); SC(IMMU(2)); Fzac;
672
673 }
674 break;
675 case 0x26:
676 {
677 /** 0010 0110 subw %0, %1 */
678 if (trace)
679 {
680 printf ("\033[33m%s\033[0m %02x\n",
681 "/** 0010 0110 subw %0, %1 */",
682 op[0]);
683 }
684 SYNTAX("subw %0, %1");
685 #line 1201 "rl78-decode.opc"
686 ID(sub); W(); DR(AX); SM(None, SADDR); Fzac;
687
688 }
689 break;
690 case 0x28:
691 {
692 /** 0010 1000 mov %e0, %1 */
693 if (trace)
694 {
695 printf ("\033[33m%s\033[0m %02x\n",
696 "/** 0010 1000 mov %e0, %1 */",
697 op[0]);
698 }
699 SYNTAX("mov %e0, %1");
700 #line 747 "rl78-decode.opc"
701 ID(mov); DM(C, IMMU(2)); SR(A);
702
703 }
704 break;
705 case 0x29:
706 {
707 /** 0010 1001 mov %0, %e1 */
708 if (trace)
709 {
710 printf ("\033[33m%s\033[0m %02x\n",
711 "/** 0010 1001 mov %0, %e1 */",
712 op[0]);
713 }
714 SYNTAX("mov %0, %e1");
715 #line 690 "rl78-decode.opc"
716 ID(mov); DR(A); SM(C, IMMU(2));
717
718 }
719 break;
720 case 0x2a:
721 {
722 /** 0010 1010 sub %0, #%1 */
723 if (trace)
724 {
725 printf ("\033[33m%s\033[0m %02x\n",
726 "/** 0010 1010 sub %0, #%1 */",
727 op[0]);
728 }
729 SYNTAX("sub %0, #%1");
730 #line 1152 "rl78-decode.opc"
731 ID(sub); DM(None, SADDR); SC(IMMU(1)); Fzac;
732
733 /*----------------------------------------------------------------------*/
734
735 }
736 break;
737 case 0x2b:
738 {
739 /** 0010 1011 sub %0, %1 */
740 if (trace)
741 {
742 printf ("\033[33m%s\033[0m %02x\n",
743 "/** 0010 1011 sub %0, %1 */",
744 op[0]);
745 }
746 SYNTAX("sub %0, %1");
747 #line 1146 "rl78-decode.opc"
748 ID(sub); DR(A); SM(None, SADDR); Fzac;
749
750 }
751 break;
752 case 0x2c:
753 {
754 /** 0010 1100 sub %0, #%1 */
755 if (trace)
756 {
757 printf ("\033[33m%s\033[0m %02x\n",
758 "/** 0010 1100 sub %0, #%1 */",
759 op[0]);
760 }
761 SYNTAX("sub %0, #%1");
762 #line 1140 "rl78-decode.opc"
763 ID(sub); DR(A); SC(IMMU(1)); Fzac;
764
765 }
766 break;
767 case 0x2d:
768 {
769 /** 0010 1101 sub %0, %e1 */
770 if (trace)
771 {
772 printf ("\033[33m%s\033[0m %02x\n",
773 "/** 0010 1101 sub %0, %e1 */",
774 op[0]);
775 }
776 SYNTAX("sub %0, %e1");
777 #line 1128 "rl78-decode.opc"
778 ID(sub); DR(A); SM(HL, 0); Fzac;
779
780 }
781 break;
782 case 0x2e:
783 {
784 /** 0010 1110 sub %0, %ea1 */
785 if (trace)
786 {
787 printf ("\033[33m%s\033[0m %02x\n",
788 "/** 0010 1110 sub %0, %ea1 */",
789 op[0]);
790 }
791 SYNTAX("sub %0, %ea1");
792 #line 1134 "rl78-decode.opc"
793 ID(sub); DR(A); SM(HL, IMMU(1)); Fzac;
794
795 }
796 break;
797 case 0x2f:
798 {
799 /** 0010 1111 sub %0, %e!1 */
800 if (trace)
801 {
802 printf ("\033[33m%s\033[0m %02x\n",
803 "/** 0010 1111 sub %0, %e!1 */",
804 op[0]);
805 }
806 SYNTAX("sub %0, %e!1");
807 #line 1125 "rl78-decode.opc"
808 ID(sub); DR(A); SM(None, IMMU(2)); Fzac;
809
810 }
811 break;
812 case 0x30:
813 case 0x32:
814 case 0x34:
815 case 0x36:
816 {
817 /** 0011 0rg0 movw %0, #%1 */
818 #line 859 "rl78-decode.opc"
819 int rg AU = (op[0] >> 1) & 0x03;
820 if (trace)
821 {
822 printf ("\033[33m%s\033[0m %02x\n",
823 "/** 0011 0rg0 movw %0, #%1 */",
824 op[0]);
825 printf (" rg = 0x%x\n", rg);
826 }
827 SYNTAX("movw %0, #%1");
828 #line 859 "rl78-decode.opc"
829 ID(mov); W(); DRW(rg); SC(IMMU(2));
830
831 }
832 break;
833 case 0x31:
834 GETBYTE ();
835 switch (op[1] & 0x8f)
836 {
837 case 0x00:
838 {
839 /** 0011 0001 0bit 0000 btclr %s1, $%a0 */
840 #line 422 "rl78-decode.opc"
841 int bit AU = (op[1] >> 4) & 0x07;
842 if (trace)
843 {
844 printf ("\033[33m%s\033[0m %02x %02x\n",
845 "/** 0011 0001 0bit 0000 btclr %s1, $%a0 */",
846 op[0], op[1]);
847 printf (" bit = 0x%x\n", bit);
848 }
849 SYNTAX("btclr %s1, $%a0");
850 #line 422 "rl78-decode.opc"
851 ID(branch_cond_clear); SM(None, SADDR); SB(bit); DC(pc+IMMS(1)+4); COND(T);
852
853 /*----------------------------------------------------------------------*/
854
855 }
856 break;
857 case 0x01:
858 {
859 /** 0011 0001 0bit 0001 btclr %1, $%a0 */
860 #line 416 "rl78-decode.opc"
861 int bit AU = (op[1] >> 4) & 0x07;
862 if (trace)
863 {
864 printf ("\033[33m%s\033[0m %02x %02x\n",
865 "/** 0011 0001 0bit 0001 btclr %1, $%a0 */",
866 op[0], op[1]);
867 printf (" bit = 0x%x\n", bit);
868 }
869 SYNTAX("btclr %1, $%a0");
870 #line 416 "rl78-decode.opc"
871 ID(branch_cond_clear); DC(pc+IMMS(1)+3); SR(A); SB(bit); COND(T);
872
873 }
874 break;
875 case 0x02:
876 {
877 /** 0011 0001 0bit 0010 bt %s1, $%a0 */
878 #line 408 "rl78-decode.opc"
879 int bit AU = (op[1] >> 4) & 0x07;
880 if (trace)
881 {
882 printf ("\033[33m%s\033[0m %02x %02x\n",
883 "/** 0011 0001 0bit 0010 bt %s1, $%a0 */",
884 op[0], op[1]);
885 printf (" bit = 0x%x\n", bit);
886 }
887 SYNTAX("bt %s1, $%a0");
888 #line 408 "rl78-decode.opc"
889 ID(branch_cond); SM(None, SADDR); SB(bit); DC(pc+IMMS(1)+4); COND(T);
890
891 /*----------------------------------------------------------------------*/
892
893 }
894 break;
895 case 0x03:
896 {
897 /** 0011 0001 0bit 0011 bt %1, $%a0 */
898 #line 402 "rl78-decode.opc"
899 int bit AU = (op[1] >> 4) & 0x07;
900 if (trace)
901 {
902 printf ("\033[33m%s\033[0m %02x %02x\n",
903 "/** 0011 0001 0bit 0011 bt %1, $%a0 */",
904 op[0], op[1]);
905 printf (" bit = 0x%x\n", bit);
906 }
907 SYNTAX("bt %1, $%a0");
908 #line 402 "rl78-decode.opc"
909 ID(branch_cond); DC(pc+IMMS(1)+3); SR(A); SB(bit); COND(T);
910
911 }
912 break;
913 case 0x04:
914 {
915 /** 0011 0001 0bit 0100 bf %s1, $%a0 */
916 #line 369 "rl78-decode.opc"
917 int bit AU = (op[1] >> 4) & 0x07;
918 if (trace)
919 {
920 printf ("\033[33m%s\033[0m %02x %02x\n",
921 "/** 0011 0001 0bit 0100 bf %s1, $%a0 */",
922 op[0], op[1]);
923 printf (" bit = 0x%x\n", bit);
924 }
925 SYNTAX("bf %s1, $%a0");
926 #line 369 "rl78-decode.opc"
927 ID(branch_cond); SM(None, SADDR); SB(bit); DC(pc+IMMS(1)+4); COND(F);
928
929 /*----------------------------------------------------------------------*/
930
931 }
932 break;
933 case 0x05:
934 {
935 /** 0011 0001 0bit 0101 bf %1, $%a0 */
936 #line 363 "rl78-decode.opc"
937 int bit AU = (op[1] >> 4) & 0x07;
938 if (trace)
939 {
940 printf ("\033[33m%s\033[0m %02x %02x\n",
941 "/** 0011 0001 0bit 0101 bf %1, $%a0 */",
942 op[0], op[1]);
943 printf (" bit = 0x%x\n", bit);
944 }
945 SYNTAX("bf %1, $%a0");
946 #line 363 "rl78-decode.opc"
947 ID(branch_cond); DC(pc+IMMS(1)+3); SR(A); SB(bit); COND(F);
948
949 }
950 break;
951 case 0x07:
952 {
953 /** 0011 0001 0cnt 0111 shl %0, %1 */
954 #line 1081 "rl78-decode.opc"
955 int cnt AU = (op[1] >> 4) & 0x07;
956 if (trace)
957 {
958 printf ("\033[33m%s\033[0m %02x %02x\n",
959 "/** 0011 0001 0cnt 0111 shl %0, %1 */",
960 op[0], op[1]);
961 printf (" cnt = 0x%x\n", cnt);
962 }
963 SYNTAX("shl %0, %1");
964 #line 1081 "rl78-decode.opc"
965 ID(shl); DR(C); SC(cnt);
966
967 }
968 break;
969 case 0x08:
970 {
971 /** 0011 0001 0cnt 1000 shl %0, %1 */
972 #line 1078 "rl78-decode.opc"
973 int cnt AU = (op[1] >> 4) & 0x07;
974 if (trace)
975 {
976 printf ("\033[33m%s\033[0m %02x %02x\n",
977 "/** 0011 0001 0cnt 1000 shl %0, %1 */",
978 op[0], op[1]);
979 printf (" cnt = 0x%x\n", cnt);
980 }
981 SYNTAX("shl %0, %1");
982 #line 1078 "rl78-decode.opc"
983 ID(shl); DR(B); SC(cnt);
984
985 }
986 break;
987 case 0x09:
988 {
989 /** 0011 0001 0cnt 1001 shl %0, %1 */
990 #line 1075 "rl78-decode.opc"
991 int cnt AU = (op[1] >> 4) & 0x07;
992 if (trace)
993 {
994 printf ("\033[33m%s\033[0m %02x %02x\n",
995 "/** 0011 0001 0cnt 1001 shl %0, %1 */",
996 op[0], op[1]);
997 printf (" cnt = 0x%x\n", cnt);
998 }
999 SYNTAX("shl %0, %1");
1000 #line 1075 "rl78-decode.opc"
1001 ID(shl); DR(A); SC(cnt);
1002
1003 }
1004 break;
1005 case 0x0a:
1006 {
1007 /** 0011 0001 0cnt 1010 shr %0, %1 */
1008 #line 1092 "rl78-decode.opc"
1009 int cnt AU = (op[1] >> 4) & 0x07;
1010 if (trace)
1011 {
1012 printf ("\033[33m%s\033[0m %02x %02x\n",
1013 "/** 0011 0001 0cnt 1010 shr %0, %1 */",
1014 op[0], op[1]);
1015 printf (" cnt = 0x%x\n", cnt);
1016 }
1017 SYNTAX("shr %0, %1");
1018 #line 1092 "rl78-decode.opc"
1019 ID(shr); DR(A); SC(cnt);
1020
1021 }
1022 break;
1023 case 0x0b:
1024 {
1025 /** 0011 0001 0cnt 1011 sar %0, %1 */
1026 #line 1039 "rl78-decode.opc"
1027 int cnt AU = (op[1] >> 4) & 0x07;
1028 if (trace)
1029 {
1030 printf ("\033[33m%s\033[0m %02x %02x\n",
1031 "/** 0011 0001 0cnt 1011 sar %0, %1 */",
1032 op[0], op[1]);
1033 printf (" cnt = 0x%x\n", cnt);
1034 }
1035 SYNTAX("sar %0, %1");
1036 #line 1039 "rl78-decode.opc"
1037 ID(sar); DR(A); SC(cnt);
1038
1039 }
1040 break;
1041 case 0x0c:
1042 case 0x8c:
1043 {
1044 /** 0011 0001 wcnt 1100 shlw %0, %1 */
1045 #line 1087 "rl78-decode.opc"
1046 int wcnt AU = (op[1] >> 4) & 0x0f;
1047 if (trace)
1048 {
1049 printf ("\033[33m%s\033[0m %02x %02x\n",
1050 "/** 0011 0001 wcnt 1100 shlw %0, %1 */",
1051 op[0], op[1]);
1052 printf (" wcnt = 0x%x\n", wcnt);
1053 }
1054 SYNTAX("shlw %0, %1");
1055 #line 1087 "rl78-decode.opc"
1056 ID(shl); W(); DR(BC); SC(wcnt);
1057
1058 /*----------------------------------------------------------------------*/
1059
1060 }
1061 break;
1062 case 0x0d:
1063 case 0x8d:
1064 {
1065 /** 0011 0001 wcnt 1101 shlw %0, %1 */
1066 #line 1084 "rl78-decode.opc"
1067 int wcnt AU = (op[1] >> 4) & 0x0f;
1068 if (trace)
1069 {
1070 printf ("\033[33m%s\033[0m %02x %02x\n",
1071 "/** 0011 0001 wcnt 1101 shlw %0, %1 */",
1072 op[0], op[1]);
1073 printf (" wcnt = 0x%x\n", wcnt);
1074 }
1075 SYNTAX("shlw %0, %1");
1076 #line 1084 "rl78-decode.opc"
1077 ID(shl); W(); DR(AX); SC(wcnt);
1078
1079 }
1080 break;
1081 case 0x0e:
1082 case 0x8e:
1083 {
1084 /** 0011 0001 wcnt 1110 shrw %0, %1 */
1085 #line 1095 "rl78-decode.opc"
1086 int wcnt AU = (op[1] >> 4) & 0x0f;
1087 if (trace)
1088 {
1089 printf ("\033[33m%s\033[0m %02x %02x\n",
1090 "/** 0011 0001 wcnt 1110 shrw %0, %1 */",
1091 op[0], op[1]);
1092 printf (" wcnt = 0x%x\n", wcnt);
1093 }
1094 SYNTAX("shrw %0, %1");
1095 #line 1095 "rl78-decode.opc"
1096 ID(shr); W(); DR(AX); SC(wcnt);
1097
1098 /*----------------------------------------------------------------------*/
1099
1100 }
1101 break;
1102 case 0x0f:
1103 case 0x8f:
1104 {
1105 /** 0011 0001 wcnt 1111 sarw %0, %1 */
1106 #line 1042 "rl78-decode.opc"
1107 int wcnt AU = (op[1] >> 4) & 0x0f;
1108 if (trace)
1109 {
1110 printf ("\033[33m%s\033[0m %02x %02x\n",
1111 "/** 0011 0001 wcnt 1111 sarw %0, %1 */",
1112 op[0], op[1]);
1113 printf (" wcnt = 0x%x\n", wcnt);
1114 }
1115 SYNTAX("sarw %0, %1");
1116 #line 1042 "rl78-decode.opc"
1117 ID(sar); W(); DR(AX); SC(wcnt);
1118
1119 /*----------------------------------------------------------------------*/
1120
1121 }
1122 break;
1123 case 0x80:
1124 {
1125 /** 0011 0001 1bit 0000 btclr %s1, $%a0 */
1126 #line 419 "rl78-decode.opc"
1127 int bit AU = (op[1] >> 4) & 0x07;
1128 if (trace)
1129 {
1130 printf ("\033[33m%s\033[0m %02x %02x\n",
1131 "/** 0011 0001 1bit 0000 btclr %s1, $%a0 */",
1132 op[0], op[1]);
1133 printf (" bit = 0x%x\n", bit);
1134 }
1135 SYNTAX("btclr %s1, $%a0");
1136 #line 419 "rl78-decode.opc"
1137 ID(branch_cond_clear); SM(None, SFR); SB(bit); DC(pc+IMMS(1)+4); COND(T);
1138
1139 }
1140 break;
1141 case 0x81:
1142 {
1143 /** 0011 0001 1bit 0001 btclr %e1, $%a0 */
1144 #line 413 "rl78-decode.opc"
1145 int bit AU = (op[1] >> 4) & 0x07;
1146 if (trace)
1147 {
1148 printf ("\033[33m%s\033[0m %02x %02x\n",
1149 "/** 0011 0001 1bit 0001 btclr %e1, $%a0 */",
1150 op[0], op[1]);
1151 printf (" bit = 0x%x\n", bit);
1152 }
1153 SYNTAX("btclr %e1, $%a0");
1154 #line 413 "rl78-decode.opc"
1155 ID(branch_cond_clear); DC(pc+IMMS(1)+3); SM(HL,0); SB(bit); COND(T);
1156
1157 }
1158 break;
1159 case 0x82:
1160 {
1161 /** 0011 0001 1bit 0010 bt %s1, $%a0 */
1162 #line 405 "rl78-decode.opc"
1163 int bit AU = (op[1] >> 4) & 0x07;
1164 if (trace)
1165 {
1166 printf ("\033[33m%s\033[0m %02x %02x\n",
1167 "/** 0011 0001 1bit 0010 bt %s1, $%a0 */",
1168 op[0], op[1]);
1169 printf (" bit = 0x%x\n", bit);
1170 }
1171 SYNTAX("bt %s1, $%a0");
1172 #line 405 "rl78-decode.opc"
1173 ID(branch_cond); SM(None, SFR); SB(bit); DC(pc+IMMS(1)+4); COND(T);
1174
1175 }
1176 break;
1177 case 0x83:
1178 {
1179 /** 0011 0001 1bit 0011 bt %e1, $%a0 */
1180 #line 399 "rl78-decode.opc"
1181 int bit AU = (op[1] >> 4) & 0x07;
1182 if (trace)
1183 {
1184 printf ("\033[33m%s\033[0m %02x %02x\n",
1185 "/** 0011 0001 1bit 0011 bt %e1, $%a0 */",
1186 op[0], op[1]);
1187 printf (" bit = 0x%x\n", bit);
1188 }
1189 SYNTAX("bt %e1, $%a0");
1190 #line 399 "rl78-decode.opc"
1191 ID(branch_cond); DC(pc+IMMS(1)+3); SM(HL,0); SB(bit); COND(T);
1192
1193 }
1194 break;
1195 case 0x84:
1196 {
1197 /** 0011 0001 1bit 0100 bf %s1, $%a0 */
1198 #line 366 "rl78-decode.opc"
1199 int bit AU = (op[1] >> 4) & 0x07;
1200 if (trace)
1201 {
1202 printf ("\033[33m%s\033[0m %02x %02x\n",
1203 "/** 0011 0001 1bit 0100 bf %s1, $%a0 */",
1204 op[0], op[1]);
1205 printf (" bit = 0x%x\n", bit);
1206 }
1207 SYNTAX("bf %s1, $%a0");
1208 #line 366 "rl78-decode.opc"
1209 ID(branch_cond); SM(None, SFR); SB(bit); DC(pc+IMMS(1)+4); COND(F);
1210
1211 }
1212 break;
1213 case 0x85:
1214 {
1215 /** 0011 0001 1bit 0101 bf %e1, $%a0 */
1216 #line 360 "rl78-decode.opc"
1217 int bit AU = (op[1] >> 4) & 0x07;
1218 if (trace)
1219 {
1220 printf ("\033[33m%s\033[0m %02x %02x\n",
1221 "/** 0011 0001 1bit 0101 bf %e1, $%a0 */",
1222 op[0], op[1]);
1223 printf (" bit = 0x%x\n", bit);
1224 }
1225 SYNTAX("bf %e1, $%a0");
1226 #line 360 "rl78-decode.opc"
1227 ID(branch_cond); DC(pc+IMMS(1)+3); SM(HL,0); SB(bit); COND(F);
1228
1229 }
1230 break;
1231 default: UNSUPPORTED(); break;
1232 }
1233 break;
1234 case 0x33:
1235 case 0x35:
1236 case 0x37:
1237 {
1238 /** 0011 0ra1 xchw %0, %1 */
1239 #line 1245 "rl78-decode.opc"
1240 int ra AU = (op[0] >> 1) & 0x03;
1241 if (trace)
1242 {
1243 printf ("\033[33m%s\033[0m %02x\n",
1244 "/** 0011 0ra1 xchw %0, %1 */",
1245 op[0]);
1246 printf (" ra = 0x%x\n", ra);
1247 }
1248 SYNTAX("xchw %0, %1");
1249 #line 1245 "rl78-decode.opc"
1250 ID(xch); W(); DR(AX); SRW(ra);
1251
1252 /*----------------------------------------------------------------------*/
1253
1254 }
1255 break;
1256 case 0x38:
1257 {
1258 /** 0011 1000 mov %e0, #%1 */
1259 if (trace)
1260 {
1261 printf ("\033[33m%s\033[0m %02x\n",
1262 "/** 0011 1000 mov %e0, #%1 */",
1263 op[0]);
1264 }
1265 SYNTAX("mov %e0, #%1");
1266 #line 744 "rl78-decode.opc"
1267 ID(mov); DM(C, IMMU(2)); SC(IMMU(1));
1268
1269 }
1270 break;
1271 case 0x39:
1272 {
1273 /** 0011 1001 mov %e0, #%1 */
1274 if (trace)
1275 {
1276 printf ("\033[33m%s\033[0m %02x\n",
1277 "/** 0011 1001 mov %e0, #%1 */",
1278 op[0]);
1279 }
1280 SYNTAX("mov %e0, #%1");
1281 #line 738 "rl78-decode.opc"
1282 ID(mov); DM(BC, IMMU(2)); SC(IMMU(1));
1283
1284 }
1285 break;
1286 case 0x3a:
1287 {
1288 /** 0011 1010 subc %0, #%1 */
1289 if (trace)
1290 {
1291 printf ("\033[33m%s\033[0m %02x\n",
1292 "/** 0011 1010 subc %0, #%1 */",
1293 op[0]);
1294 }
1295 SYNTAX("subc %0, #%1");
1296 #line 1184 "rl78-decode.opc"
1297 ID(subc); DM(None, SADDR); SC(IMMU(1)); Fzac;
1298
1299 /*----------------------------------------------------------------------*/
1300
1301 }
1302 break;
1303 case 0x3b:
1304 {
1305 /** 0011 1011 subc %0, %1 */
1306 if (trace)
1307 {
1308 printf ("\033[33m%s\033[0m %02x\n",
1309 "/** 0011 1011 subc %0, %1 */",
1310 op[0]);
1311 }
1312 SYNTAX("subc %0, %1");
1313 #line 1181 "rl78-decode.opc"
1314 ID(subc); DR(A); SM(None, SADDR); Fzac;
1315
1316 }
1317 break;
1318 case 0x3c:
1319 {
1320 /** 0011 1100 subc %0, #%1 */
1321 if (trace)
1322 {
1323 printf ("\033[33m%s\033[0m %02x\n",
1324 "/** 0011 1100 subc %0, #%1 */",
1325 op[0]);
1326 }
1327 SYNTAX("subc %0, #%1");
1328 #line 1172 "rl78-decode.opc"
1329 ID(subc); DR(A); SC(IMMU(1)); Fzac;
1330
1331 }
1332 break;
1333 case 0x3d:
1334 {
1335 /** 0011 1101 subc %0, %e1 */
1336 if (trace)
1337 {
1338 printf ("\033[33m%s\033[0m %02x\n",
1339 "/** 0011 1101 subc %0, %e1 */",
1340 op[0]);
1341 }
1342 SYNTAX("subc %0, %e1");
1343 #line 1160 "rl78-decode.opc"
1344 ID(subc); DR(A); SM(HL, 0); Fzac;
1345
1346 }
1347 break;
1348 case 0x3e:
1349 {
1350 /** 0011 1110 subc %0, %ea1 */
1351 if (trace)
1352 {
1353 printf ("\033[33m%s\033[0m %02x\n",
1354 "/** 0011 1110 subc %0, %ea1 */",
1355 op[0]);
1356 }
1357 SYNTAX("subc %0, %ea1");
1358 #line 1169 "rl78-decode.opc"
1359 ID(subc); DR(A); SM(HL, IMMU(1)); Fzac;
1360
1361 }
1362 break;
1363 case 0x3f:
1364 {
1365 /** 0011 1111 subc %0, %e!1 */
1366 if (trace)
1367 {
1368 printf ("\033[33m%s\033[0m %02x\n",
1369 "/** 0011 1111 subc %0, %e!1 */",
1370 op[0]);
1371 }
1372 SYNTAX("subc %0, %e!1");
1373 #line 1157 "rl78-decode.opc"
1374 ID(subc); DR(A); SM(None, IMMU(2)); Fzac;
1375
1376 }
1377 break;
1378 case 0x40:
1379 {
1380 /** 0100 0000 cmp %e!0, #%1 */
1381 if (trace)
1382 {
1383 printf ("\033[33m%s\033[0m %02x\n",
1384 "/** 0100 0000 cmp %e!0, #%1 */",
1385 op[0]);
1386 }
1387 SYNTAX("cmp %e!0, #%1");
1388 #line 486 "rl78-decode.opc"
1389 ID(cmp); DM(None, IMMU(2)); SC(IMMU(1)); Fzac;
1390
1391 }
1392 break;
1393 case 0x41:
1394 {
1395 /** 0100 0001 mov %0, #%1 */
1396 if (trace)
1397 {
1398 printf ("\033[33m%s\033[0m %02x\n",
1399 "/** 0100 0001 mov %0, #%1 */",
1400 op[0]);
1401 }
1402 SYNTAX("mov %0, #%1");
1403 #line 723 "rl78-decode.opc"
1404 ID(mov); DR(ES); SC(IMMU(1));
1405
1406 }
1407 break;
1408 case 0x42:
1409 {
1410 /** 0100 0010 cmpw %0, %e!1 */
1411 if (trace)
1412 {
1413 printf ("\033[33m%s\033[0m %02x\n",
1414 "/** 0100 0010 cmpw %0, %e!1 */",
1415 op[0]);
1416 }
1417 SYNTAX("cmpw %0, %e!1");
1418 #line 537 "rl78-decode.opc"
1419 ID(cmp); W(); DR(AX); SM(None, IMMU(2)); Fzac;
1420
1421 }
1422 break;
1423 case 0x43:
1424 case 0x45:
1425 case 0x47:
1426 {
1427 /** 0100 0ra1 cmpw %0, %1 */
1428 #line 546 "rl78-decode.opc"
1429 int ra AU = (op[0] >> 1) & 0x03;
1430 if (trace)
1431 {
1432 printf ("\033[33m%s\033[0m %02x\n",
1433 "/** 0100 0ra1 cmpw %0, %1 */",
1434 op[0]);
1435 printf (" ra = 0x%x\n", ra);
1436 }
1437 SYNTAX("cmpw %0, %1");
1438 #line 546 "rl78-decode.opc"
1439 ID(cmp); W(); DR(AX); SRW(ra); Fzac;
1440
1441 }
1442 break;
1443 case 0x44:
1444 {
1445 /** 0100 0100 cmpw %0, #%1 */
1446 if (trace)
1447 {
1448 printf ("\033[33m%s\033[0m %02x\n",
1449 "/** 0100 0100 cmpw %0, #%1 */",
1450 op[0]);
1451 }
1452 SYNTAX("cmpw %0, #%1");
1453 #line 543 "rl78-decode.opc"
1454 ID(cmp); W(); DR(AX); SC(IMMU(2)); Fzac;
1455
1456 }
1457 break;
1458 case 0x46:
1459 {
1460 /** 0100 0110 cmpw %0, %1 */
1461 if (trace)
1462 {
1463 printf ("\033[33m%s\033[0m %02x\n",
1464 "/** 0100 0110 cmpw %0, %1 */",
1465 op[0]);
1466 }
1467 SYNTAX("cmpw %0, %1");
1468 #line 549 "rl78-decode.opc"
1469 ID(cmp); W(); DR(AX); SM(None, SADDR); Fzac;
1470
1471 /*----------------------------------------------------------------------*/
1472
1473 }
1474 break;
1475 case 0x48:
1476 {
1477 /** 0100 1000 mov %e0, %1 */
1478 if (trace)
1479 {
1480 printf ("\033[33m%s\033[0m %02x\n",
1481 "/** 0100 1000 mov %e0, %1 */",
1482 op[0]);
1483 }
1484 SYNTAX("mov %e0, %1");
1485 #line 741 "rl78-decode.opc"
1486 ID(mov); DM(BC, IMMU(2)); SR(A);
1487
1488 }
1489 break;
1490 case 0x49:
1491 {
1492 /** 0100 1001 mov %0, %e1 */
1493 if (trace)
1494 {
1495 printf ("\033[33m%s\033[0m %02x\n",
1496 "/** 0100 1001 mov %0, %e1 */",
1497 op[0]);
1498 }
1499 SYNTAX("mov %0, %e1");
1500 #line 687 "rl78-decode.opc"
1501 ID(mov); DR(A); SM(BC, IMMU(2));
1502
1503 }
1504 break;
1505 case 0x4a:
1506 {
1507 /** 0100 1010 cmp %0, #%1 */
1508 if (trace)
1509 {
1510 printf ("\033[33m%s\033[0m %02x\n",
1511 "/** 0100 1010 cmp %0, #%1 */",
1512 op[0]);
1513 }
1514 SYNTAX("cmp %0, #%1");
1515 #line 489 "rl78-decode.opc"
1516 ID(cmp); DM(None, SADDR); SC(IMMU(1)); Fzac;
1517
1518 }
1519 break;
1520 case 0x4b:
1521 {
1522 /** 0100 1011 cmp %0, %1 */
1523 if (trace)
1524 {
1525 printf ("\033[33m%s\033[0m %02x\n",
1526 "/** 0100 1011 cmp %0, %1 */",
1527 op[0]);
1528 }
1529 SYNTAX("cmp %0, %1");
1530 #line 516 "rl78-decode.opc"
1531 ID(cmp); DR(A); SM(None, SADDR); Fzac;
1532
1533 /*----------------------------------------------------------------------*/
1534
1535 }
1536 break;
1537 case 0x4c:
1538 {
1539 /** 0100 1100 cmp %0, #%1 */
1540 if (trace)
1541 {
1542 printf ("\033[33m%s\033[0m %02x\n",
1543 "/** 0100 1100 cmp %0, #%1 */",
1544 op[0]);
1545 }
1546 SYNTAX("cmp %0, #%1");
1547 #line 507 "rl78-decode.opc"
1548 ID(cmp); DR(A); SC(IMMU(1)); Fzac;
1549
1550 }
1551 break;
1552 case 0x4d:
1553 {
1554 /** 0100 1101 cmp %0, %e1 */
1555 if (trace)
1556 {
1557 printf ("\033[33m%s\033[0m %02x\n",
1558 "/** 0100 1101 cmp %0, %e1 */",
1559 op[0]);
1560 }
1561 SYNTAX("cmp %0, %e1");
1562 #line 495 "rl78-decode.opc"
1563 ID(cmp); DR(A); SM(HL, 0); Fzac;
1564
1565 }
1566 break;
1567 case 0x4e:
1568 {
1569 /** 0100 1110 cmp %0, %ea1 */
1570 if (trace)
1571 {
1572 printf ("\033[33m%s\033[0m %02x\n",
1573 "/** 0100 1110 cmp %0, %ea1 */",
1574 op[0]);
1575 }
1576 SYNTAX("cmp %0, %ea1");
1577 #line 504 "rl78-decode.opc"
1578 ID(cmp); DR(A); SM(HL, IMMU(1)); Fzac;
1579
1580 }
1581 break;
1582 case 0x4f:
1583 {
1584 /** 0100 1111 cmp %0, %e!1 */
1585 if (trace)
1586 {
1587 printf ("\033[33m%s\033[0m %02x\n",
1588 "/** 0100 1111 cmp %0, %e!1 */",
1589 op[0]);
1590 }
1591 SYNTAX("cmp %0, %e!1");
1592 #line 492 "rl78-decode.opc"
1593 ID(cmp); DR(A); SM(None, IMMU(2)); Fzac;
1594
1595 }
1596 break;
1597 case 0x50:
1598 case 0x51:
1599 case 0x52:
1600 case 0x53:
1601 case 0x54:
1602 case 0x55:
1603 case 0x56:
1604 case 0x57:
1605 {
1606 /** 0101 0reg mov %0, #%1 */
1607 #line 675 "rl78-decode.opc"
1608 int reg AU = op[0] & 0x07;
1609 if (trace)
1610 {
1611 printf ("\033[33m%s\033[0m %02x\n",
1612 "/** 0101 0reg mov %0, #%1 */",
1613 op[0]);
1614 printf (" reg = 0x%x\n", reg);
1615 }
1616 SYNTAX("mov %0, #%1");
1617 #line 675 "rl78-decode.opc"
1618 ID(mov); DRB(reg); SC(IMMU(1));
1619
1620 }
1621 break;
1622 case 0x58:
1623 {
1624 /** 0101 1000 movw %e0, %1 */
1625 if (trace)
1626 {
1627 printf ("\033[33m%s\033[0m %02x\n",
1628 "/** 0101 1000 movw %e0, %1 */",
1629 op[0]);
1630 }
1631 SYNTAX("movw %e0, %1");
1632 #line 877 "rl78-decode.opc"
1633 ID(mov); W(); DM(B, IMMU(2)); SR(AX);
1634
1635 }
1636 break;
1637 case 0x59:
1638 {
1639 /** 0101 1001 movw %0, %e1 */
1640 if (trace)
1641 {
1642 printf ("\033[33m%s\033[0m %02x\n",
1643 "/** 0101 1001 movw %0, %e1 */",
1644 op[0]);
1645 }
1646 SYNTAX("movw %0, %e1");
1647 #line 868 "rl78-decode.opc"
1648 ID(mov); W(); DR(AX); SM(B, IMMU(2));
1649
1650 }
1651 break;
1652 case 0x5a:
1653 {
1654 /** 0101 1010 and %0, #%1 */
1655 if (trace)
1656 {
1657 printf ("\033[33m%s\033[0m %02x\n",
1658 "/** 0101 1010 and %0, #%1 */",
1659 op[0]);
1660 }
1661 SYNTAX("and %0, #%1");
1662 #line 318 "rl78-decode.opc"
1663 ID(and); DM(None, SADDR); SC(IMMU(1)); Fz;
1664
1665 /*----------------------------------------------------------------------*/
1666
1667 }
1668 break;
1669 case 0x5b:
1670 {
1671 /** 0101 1011 and %0, %1 */
1672 if (trace)
1673 {
1674 printf ("\033[33m%s\033[0m %02x\n",
1675 "/** 0101 1011 and %0, %1 */",
1676 op[0]);
1677 }
1678 SYNTAX("and %0, %1");
1679 #line 315 "rl78-decode.opc"
1680 ID(and); DR(A); SM(None, SADDR); Fz;
1681
1682 }
1683 break;
1684 case 0x5c:
1685 {
1686 /** 0101 1100 and %0, #%1 */
1687 if (trace)
1688 {
1689 printf ("\033[33m%s\033[0m %02x\n",
1690 "/** 0101 1100 and %0, #%1 */",
1691 op[0]);
1692 }
1693 SYNTAX("and %0, #%1");
1694 #line 306 "rl78-decode.opc"
1695 ID(and); DR(A); SC(IMMU(1)); Fz;
1696
1697 }
1698 break;
1699 case 0x5d:
1700 {
1701 /** 0101 1101 and %0, %e1 */
1702 if (trace)
1703 {
1704 printf ("\033[33m%s\033[0m %02x\n",
1705 "/** 0101 1101 and %0, %e1 */",
1706 op[0]);
1707 }
1708 SYNTAX("and %0, %e1");
1709 #line 294 "rl78-decode.opc"
1710 ID(and); DR(A); SM(HL, 0); Fz;
1711
1712 }
1713 break;
1714 case 0x5e:
1715 {
1716 /** 0101 1110 and %0, %ea1 */
1717 if (trace)
1718 {
1719 printf ("\033[33m%s\033[0m %02x\n",
1720 "/** 0101 1110 and %0, %ea1 */",
1721 op[0]);
1722 }
1723 SYNTAX("and %0, %ea1");
1724 #line 300 "rl78-decode.opc"
1725 ID(and); DR(A); SM(HL, IMMU(1)); Fz;
1726
1727 }
1728 break;
1729 case 0x5f:
1730 {
1731 /** 0101 1111 and %0, %e!1 */
1732 if (trace)
1733 {
1734 printf ("\033[33m%s\033[0m %02x\n",
1735 "/** 0101 1111 and %0, %e!1 */",
1736 op[0]);
1737 }
1738 SYNTAX("and %0, %e!1");
1739 #line 291 "rl78-decode.opc"
1740 ID(and); DR(A); SM(None, IMMU(2)); Fz;
1741
1742 }
1743 break;
1744 case 0x60:
1745 case 0x62:
1746 case 0x63:
1747 case 0x64:
1748 case 0x65:
1749 case 0x66:
1750 case 0x67:
1751 {
1752 /** 0110 0rba mov %0, %1 */
1753 #line 678 "rl78-decode.opc"
1754 int rba AU = op[0] & 0x07;
1755 if (trace)
1756 {
1757 printf ("\033[33m%s\033[0m %02x\n",
1758 "/** 0110 0rba mov %0, %1 */",
1759 op[0]);
1760 printf (" rba = 0x%x\n", rba);
1761 }
1762 SYNTAX("mov %0, %1");
1763 #line 678 "rl78-decode.opc"
1764 ID(mov); DR(A); SRB(rba);
1765
1766 }
1767 break;
1768 case 0x61:
1769 GETBYTE ();
1770 switch (op[1] & 0xff)
1771 {
1772 case 0x00:
1773 case 0x01:
1774 case 0x02:
1775 case 0x03:
1776 case 0x04:
1777 case 0x05:
1778 case 0x06:
1779 case 0x07:
1780 {
1781 /** 0110 0001 0000 0reg add %0, %1 */
1782 #line 231 "rl78-decode.opc"
1783 int reg AU = op[1] & 0x07;
1784 if (trace)
1785 {
1786 printf ("\033[33m%s\033[0m %02x %02x\n",
1787 "/** 0110 0001 0000 0reg add %0, %1 */",
1788 op[0], op[1]);
1789 printf (" reg = 0x%x\n", reg);
1790 }
1791 SYNTAX("add %0, %1");
1792 #line 231 "rl78-decode.opc"
1793 ID(add); DRB(reg); SR(A); Fzac;
1794
1795 }
1796 break;
1797 case 0x08:
1798 case 0x0a:
1799 case 0x0b:
1800 case 0x0c:
1801 case 0x0d:
1802 case 0x0e:
1803 case 0x0f:
1804 {
1805 /** 0110 0001 0000 1rba add %0, %1 */
1806 #line 225 "rl78-decode.opc"
1807 int rba AU = op[1] & 0x07;
1808 if (trace)
1809 {
1810 printf ("\033[33m%s\033[0m %02x %02x\n",
1811 "/** 0110 0001 0000 1rba add %0, %1 */",
1812 op[0], op[1]);
1813 printf (" rba = 0x%x\n", rba);
1814 }
1815 SYNTAX("add %0, %1");
1816 #line 225 "rl78-decode.opc"
1817 ID(add); DR(A); SRB(rba); Fzac;
1818
1819 }
1820 break;
1821 case 0x09:
1822 {
1823 /** 0110 0001 0000 1001 addw %0, %ea1 */
1824 if (trace)
1825 {
1826 printf ("\033[33m%s\033[0m %02x %02x\n",
1827 "/** 0110 0001 0000 1001 addw %0, %ea1 */",
1828 op[0], op[1]);
1829 }
1830 SYNTAX("addw %0, %ea1");
1831 #line 274 "rl78-decode.opc"
1832 ID(add); W(); DR(AX); SM(HL, IMMU(1)); Fzac;
1833
1834 }
1835 break;
1836 case 0x10:
1837 case 0x11:
1838 case 0x12:
1839 case 0x13:
1840 case 0x14:
1841 case 0x15:
1842 case 0x16:
1843 case 0x17:
1844 {
1845 /** 0110 0001 0001 0reg addc %0, %1 */
1846 #line 260 "rl78-decode.opc"
1847 int reg AU = op[1] & 0x07;
1848 if (trace)
1849 {
1850 printf ("\033[33m%s\033[0m %02x %02x\n",
1851 "/** 0110 0001 0001 0reg addc %0, %1 */",
1852 op[0], op[1]);
1853 printf (" reg = 0x%x\n", reg);
1854 }
1855 SYNTAX("addc %0, %1");
1856 #line 260 "rl78-decode.opc"
1857 ID(addc); DRB(reg); SR(A); Fzac;
1858
1859 }
1860 break;
1861 case 0x18:
1862 case 0x1a:
1863 case 0x1b:
1864 case 0x1c:
1865 case 0x1d:
1866 case 0x1e:
1867 case 0x1f:
1868 {
1869 /** 0110 0001 0001 1rba addc %0, %1 */
1870 #line 257 "rl78-decode.opc"
1871 int rba AU = op[1] & 0x07;
1872 if (trace)
1873 {
1874 printf ("\033[33m%s\033[0m %02x %02x\n",
1875 "/** 0110 0001 0001 1rba addc %0, %1 */",
1876 op[0], op[1]);
1877 printf (" rba = 0x%x\n", rba);
1878 }
1879 SYNTAX("addc %0, %1");
1880 #line 257 "rl78-decode.opc"
1881 ID(addc); DR(A); SRB(rba); Fzac;
1882
1883 }
1884 break;
1885 case 0x20:
1886 case 0x21:
1887 case 0x22:
1888 case 0x23:
1889 case 0x24:
1890 case 0x25:
1891 case 0x26:
1892 case 0x27:
1893 {
1894 /** 0110 0001 0010 0reg sub %0, %1 */
1895 #line 1149 "rl78-decode.opc"
1896 int reg AU = op[1] & 0x07;
1897 if (trace)
1898 {
1899 printf ("\033[33m%s\033[0m %02x %02x\n",
1900 "/** 0110 0001 0010 0reg sub %0, %1 */",
1901 op[0], op[1]);
1902 printf (" reg = 0x%x\n", reg);
1903 }
1904 SYNTAX("sub %0, %1");
1905 #line 1149 "rl78-decode.opc"
1906 ID(sub); DRB(reg); SR(A); Fzac;
1907
1908 }
1909 break;
1910 case 0x28:
1911 case 0x2a:
1912 case 0x2b:
1913 case 0x2c:
1914 case 0x2d:
1915 case 0x2e:
1916 case 0x2f:
1917 {
1918 /** 0110 0001 0010 1rba sub %0, %1 */
1919 #line 1143 "rl78-decode.opc"
1920 int rba AU = op[1] & 0x07;
1921 if (trace)
1922 {
1923 printf ("\033[33m%s\033[0m %02x %02x\n",
1924 "/** 0110 0001 0010 1rba sub %0, %1 */",
1925 op[0], op[1]);
1926 printf (" rba = 0x%x\n", rba);
1927 }
1928 SYNTAX("sub %0, %1");
1929 #line 1143 "rl78-decode.opc"
1930 ID(sub); DR(A); SRB(rba); Fzac;
1931
1932 }
1933 break;
1934 case 0x29:
1935 {
1936 /** 0110 0001 0010 1001 subw %0, %ea1 */
1937 if (trace)
1938 {
1939 printf ("\033[33m%s\033[0m %02x %02x\n",
1940 "/** 0110 0001 0010 1001 subw %0, %ea1 */",
1941 op[0], op[1]);
1942 }
1943 SYNTAX("subw %0, %ea1");
1944 #line 1192 "rl78-decode.opc"
1945 ID(sub); W(); DR(AX); SM(HL, IMMU(1)); Fzac;
1946
1947 }
1948 break;
1949 case 0x30:
1950 case 0x31:
1951 case 0x32:
1952 case 0x33:
1953 case 0x34:
1954 case 0x35:
1955 case 0x36:
1956 case 0x37:
1957 {
1958 /** 0110 0001 0011 0reg subc %0, %1 */
1959 #line 1178 "rl78-decode.opc"
1960 int reg AU = op[1] & 0x07;
1961 if (trace)
1962 {
1963 printf ("\033[33m%s\033[0m %02x %02x\n",
1964 "/** 0110 0001 0011 0reg subc %0, %1 */",
1965 op[0], op[1]);
1966 printf (" reg = 0x%x\n", reg);
1967 }
1968 SYNTAX("subc %0, %1");
1969 #line 1178 "rl78-decode.opc"
1970 ID(subc); DRB(reg); SR(A); Fzac;
1971
1972 }
1973 break;
1974 case 0x38:
1975 case 0x3a:
1976 case 0x3b:
1977 case 0x3c:
1978 case 0x3d:
1979 case 0x3e:
1980 case 0x3f:
1981 {
1982 /** 0110 0001 0011 1rba subc %0, %1 */
1983 #line 1175 "rl78-decode.opc"
1984 int rba AU = op[1] & 0x07;
1985 if (trace)
1986 {
1987 printf ("\033[33m%s\033[0m %02x %02x\n",
1988 "/** 0110 0001 0011 1rba subc %0, %1 */",
1989 op[0], op[1]);
1990 printf (" rba = 0x%x\n", rba);
1991 }
1992 SYNTAX("subc %0, %1");
1993 #line 1175 "rl78-decode.opc"
1994 ID(subc); DR(A); SRB(rba); Fzac;
1995
1996 }
1997 break;
1998 case 0x40:
1999 case 0x41:
2000 case 0x42:
2001 case 0x43:
2002 case 0x44:
2003 case 0x45:
2004 case 0x46:
2005 case 0x47:
2006 {
2007 /** 0110 0001 0100 0reg cmp %0, %1 */
2008 #line 513 "rl78-decode.opc"
2009 int reg AU = op[1] & 0x07;
2010 if (trace)
2011 {
2012 printf ("\033[33m%s\033[0m %02x %02x\n",
2013 "/** 0110 0001 0100 0reg cmp %0, %1 */",
2014 op[0], op[1]);
2015 printf (" reg = 0x%x\n", reg);
2016 }
2017 SYNTAX("cmp %0, %1");
2018 #line 513 "rl78-decode.opc"
2019 ID(cmp); DRB(reg); SR(A); Fzac;
2020
2021 }
2022 break;
2023 case 0x48:
2024 case 0x4a:
2025 case 0x4b:
2026 case 0x4c:
2027 case 0x4d:
2028 case 0x4e:
2029 case 0x4f:
2030 {
2031 /** 0110 0001 0100 1rba cmp %0, %1 */
2032 #line 510 "rl78-decode.opc"
2033 int rba AU = op[1] & 0x07;
2034 if (trace)
2035 {
2036 printf ("\033[33m%s\033[0m %02x %02x\n",
2037 "/** 0110 0001 0100 1rba cmp %0, %1 */",
2038 op[0], op[1]);
2039 printf (" rba = 0x%x\n", rba);
2040 }
2041 SYNTAX("cmp %0, %1");
2042 #line 510 "rl78-decode.opc"
2043 ID(cmp); DR(A); SRB(rba); Fzac;
2044
2045 }
2046 break;
2047 case 0x49:
2048 {
2049 /** 0110 0001 0100 1001 cmpw %0, %ea1 */
2050 if (trace)
2051 {
2052 printf ("\033[33m%s\033[0m %02x %02x\n",
2053 "/** 0110 0001 0100 1001 cmpw %0, %ea1 */",
2054 op[0], op[1]);
2055 }
2056 SYNTAX("cmpw %0, %ea1");
2057 #line 540 "rl78-decode.opc"
2058 ID(cmp); W(); DR(AX); SM(HL, IMMU(1)); Fzac;
2059
2060 }
2061 break;
2062 case 0x50:
2063 case 0x51:
2064 case 0x52:
2065 case 0x53:
2066 case 0x54:
2067 case 0x55:
2068 case 0x56:
2069 case 0x57:
2070 {
2071 /** 0110 0001 0101 0reg and %0, %1 */
2072 #line 312 "rl78-decode.opc"
2073 int reg AU = op[1] & 0x07;
2074 if (trace)
2075 {
2076 printf ("\033[33m%s\033[0m %02x %02x\n",
2077 "/** 0110 0001 0101 0reg and %0, %1 */",
2078 op[0], op[1]);
2079 printf (" reg = 0x%x\n", reg);
2080 }
2081 SYNTAX("and %0, %1");
2082 #line 312 "rl78-decode.opc"
2083 ID(and); DRB(reg); SR(A); Fz;
2084
2085 }
2086 break;
2087 case 0x58:
2088 case 0x5a:
2089 case 0x5b:
2090 case 0x5c:
2091 case 0x5d:
2092 case 0x5e:
2093 case 0x5f:
2094 {
2095 /** 0110 0001 0101 1rba and %0, %1 */
2096 #line 309 "rl78-decode.opc"
2097 int rba AU = op[1] & 0x07;
2098 if (trace)
2099 {
2100 printf ("\033[33m%s\033[0m %02x %02x\n",
2101 "/** 0110 0001 0101 1rba and %0, %1 */",
2102 op[0], op[1]);
2103 printf (" rba = 0x%x\n", rba);
2104 }
2105 SYNTAX("and %0, %1");
2106 #line 309 "rl78-decode.opc"
2107 ID(and); DR(A); SRB(rba); Fz;
2108
2109 }
2110 break;
2111 case 0x59:
2112 {
2113 /** 0110 0001 0101 1001 inc %ea0 */
2114 if (trace)
2115 {
2116 printf ("\033[33m%s\033[0m %02x %02x\n",
2117 "/** 0110 0001 0101 1001 inc %ea0 */",
2118 op[0], op[1]);
2119 }
2120 SYNTAX("inc %ea0");
2121 #line 590 "rl78-decode.opc"
2122 ID(add); DM(HL, IMMU(1)); SC(1); Fza;
2123
2124 }
2125 break;
2126 case 0x60:
2127 case 0x61:
2128 case 0x62:
2129 case 0x63:
2130 case 0x64:
2131 case 0x65:
2132 case 0x66:
2133 case 0x67:
2134 {
2135 /** 0110 0001 0110 0reg or %0, %1 */
2136 #line 967 "rl78-decode.opc"
2137 int reg AU = op[1] & 0x07;
2138 if (trace)
2139 {
2140 printf ("\033[33m%s\033[0m %02x %02x\n",
2141 "/** 0110 0001 0110 0reg or %0, %1 */",
2142 op[0], op[1]);
2143 printf (" reg = 0x%x\n", reg);
2144 }
2145 SYNTAX("or %0, %1");
2146 #line 967 "rl78-decode.opc"
2147 ID(or); DRB(reg); SR(A); Fz;
2148
2149 }
2150 break;
2151 case 0x68:
2152 case 0x6a:
2153 case 0x6b:
2154 case 0x6c:
2155 case 0x6d:
2156 case 0x6e:
2157 case 0x6f:
2158 {
2159 /** 0110 0001 0110 1rba or %0, %1 */
2160 #line 964 "rl78-decode.opc"
2161 int rba AU = op[1] & 0x07;
2162 if (trace)
2163 {
2164 printf ("\033[33m%s\033[0m %02x %02x\n",
2165 "/** 0110 0001 0110 1rba or %0, %1 */",
2166 op[0], op[1]);
2167 printf (" rba = 0x%x\n", rba);
2168 }
2169 SYNTAX("or %0, %1");
2170 #line 964 "rl78-decode.opc"
2171 ID(or); DR(A); SRB(rba); Fz;
2172
2173 }
2174 break;
2175 case 0x69:
2176 {
2177 /** 0110 0001 0110 1001 dec %ea0 */
2178 if (trace)
2179 {
2180 printf ("\033[33m%s\033[0m %02x %02x\n",
2181 "/** 0110 0001 0110 1001 dec %ea0 */",
2182 op[0], op[1]);
2183 }
2184 SYNTAX("dec %ea0");
2185 #line 557 "rl78-decode.opc"
2186 ID(sub); DM(HL, IMMU(1)); SC(1); Fza;
2187
2188 }
2189 break;
2190 case 0x70:
2191 case 0x71:
2192 case 0x72:
2193 case 0x73:
2194 case 0x74:
2195 case 0x75:
2196 case 0x76:
2197 case 0x77:
2198 {
2199 /** 0110 0001 0111 0reg xor %0, %1 */
2200 #line 1271 "rl78-decode.opc"
2201 int reg AU = op[1] & 0x07;
2202 if (trace)
2203 {
2204 printf ("\033[33m%s\033[0m %02x %02x\n",
2205 "/** 0110 0001 0111 0reg xor %0, %1 */",
2206 op[0], op[1]);
2207 printf (" reg = 0x%x\n", reg);
2208 }
2209 SYNTAX("xor %0, %1");
2210 #line 1271 "rl78-decode.opc"
2211 ID(xor); DRB(reg); SR(A); Fz;
2212
2213 }
2214 break;
2215 case 0x78:
2216 case 0x7a:
2217 case 0x7b:
2218 case 0x7c:
2219 case 0x7d:
2220 case 0x7e:
2221 case 0x7f:
2222 {
2223 /** 0110 0001 0111 1rba xor %0, %1 */
2224 #line 1268 "rl78-decode.opc"
2225 int rba AU = op[1] & 0x07;
2226 if (trace)
2227 {
2228 printf ("\033[33m%s\033[0m %02x %02x\n",
2229 "/** 0110 0001 0111 1rba xor %0, %1 */",
2230 op[0], op[1]);
2231 printf (" rba = 0x%x\n", rba);
2232 }
2233 SYNTAX("xor %0, %1");
2234 #line 1268 "rl78-decode.opc"
2235 ID(xor); DR(A); SRB(rba); Fz;
2236
2237 }
2238 break;
2239 case 0x79:
2240 {
2241 /** 0110 0001 0111 1001 incw %ea0 */
2242 if (trace)
2243 {
2244 printf ("\033[33m%s\033[0m %02x %02x\n",
2245 "/** 0110 0001 0111 1001 incw %ea0 */",
2246 op[0], op[1]);
2247 }
2248 SYNTAX("incw %ea0");
2249 #line 604 "rl78-decode.opc"
2250 ID(add); W(); DM(HL, IMMU(1)); SC(1);
2251
2252 }
2253 break;
2254 case 0x80:
2255 case 0x81:
2256 {
2257 /** 0110 0001 1000 000 add %0, %e1 */
2258 if (trace)
2259 {
2260 printf ("\033[33m%s\033[0m %02x %02x\n",
2261 "/** 0110 0001 1000 000 add %0, %e1 */",
2262 op[0], op[1]);
2263 }
2264 SYNTAX("add %0, %e1");
2265 #line 213 "rl78-decode.opc"
2266 ID(add); DR(A); SM2(HL, B, 0); Fzac;
2267
2268 }
2269 break;
2270 case 0x82:
2271 {
2272 /** 0110 0001 1000 0010 add %0, %e1 */
2273 if (trace)
2274 {
2275 printf ("\033[33m%s\033[0m %02x %02x\n",
2276 "/** 0110 0001 1000 0010 add %0, %e1 */",
2277 op[0], op[1]);
2278 }
2279 SYNTAX("add %0, %e1");
2280 #line 219 "rl78-decode.opc"
2281 ID(add); DR(A); SM2(HL, C, 0); Fzac;
2282
2283 }
2284 break;
2285 case 0x84:
2286 case 0x85:
2287 case 0x86:
2288 case 0x87:
2289 case 0x94:
2290 case 0x95:
2291 case 0x96:
2292 case 0x97:
2293 case 0xa4:
2294 case 0xa5:
2295 case 0xa6:
2296 case 0xa7:
2297 case 0xb4:
2298 case 0xb5:
2299 case 0xb6:
2300 case 0xb7:
2301 case 0xc4:
2302 case 0xc5:
2303 case 0xc6:
2304 case 0xc7:
2305 case 0xd4:
2306 case 0xd5:
2307 case 0xd6:
2308 case 0xd7:
2309 case 0xe4:
2310 case 0xe5:
2311 case 0xe6:
2312 case 0xe7:
2313 case 0xf4:
2314 case 0xf5:
2315 case 0xf6:
2316 case 0xf7:
2317 {
2318 /** 0110 0001 1nnn 01mm callt [%x0] */
2319 #line 439 "rl78-decode.opc"
2320 int nnn AU = (op[1] >> 4) & 0x07;
2321 #line 439 "rl78-decode.opc"
2322 int mm AU = op[1] & 0x03;
2323 if (trace)
2324 {
2325 printf ("\033[33m%s\033[0m %02x %02x\n",
2326 "/** 0110 0001 1nnn 01mm callt [%x0] */",
2327 op[0], op[1]);
2328 printf (" nnn = 0x%x,", nnn);
2329 printf (" mm = 0x%x\n", mm);
2330 }
2331 SYNTAX("callt [%x0]");
2332 #line 439 "rl78-decode.opc"
2333 ID(call); DM(None, 0x80 + mm*16 + nnn*2);
2334
2335 /*----------------------------------------------------------------------*/
2336
2337 }
2338 break;
2339 case 0x88:
2340 case 0x8a:
2341 case 0x8b:
2342 case 0x8c:
2343 case 0x8d:
2344 case 0x8e:
2345 case 0x8f:
2346 {
2347 /** 0110 0001 1000 1reg xch %0, %1 */
2348 #line 1230 "rl78-decode.opc"
2349 int reg AU = op[1] & 0x07;
2350 if (trace)
2351 {
2352 printf ("\033[33m%s\033[0m %02x %02x\n",
2353 "/** 0110 0001 1000 1reg xch %0, %1 */",
2354 op[0], op[1]);
2355 printf (" reg = 0x%x\n", reg);
2356 }
2357 SYNTAX("xch %0, %1");
2358 #line 1230 "rl78-decode.opc"
2359 /* Note: DECW uses reg == X, so this must follow DECW */
2360 ID(xch); DR(A); SRB(reg);
2361
2362 }
2363 break;
2364 case 0x89:
2365 {
2366 /** 0110 0001 1000 1001 decw %ea0 */
2367 if (trace)
2368 {
2369 printf ("\033[33m%s\033[0m %02x %02x\n",
2370 "/** 0110 0001 1000 1001 decw %ea0 */",
2371 op[0], op[1]);
2372 }
2373 SYNTAX("decw %ea0");
2374 #line 571 "rl78-decode.opc"
2375 ID(sub); W(); DM(HL, IMMU(1)); SC(1);
2376
2377 }
2378 break;
2379 case 0x90:
2380 {
2381 /** 0110 0001 1001 0000 addc %0, %e1 */
2382 if (trace)
2383 {
2384 printf ("\033[33m%s\033[0m %02x %02x\n",
2385 "/** 0110 0001 1001 0000 addc %0, %e1 */",
2386 op[0], op[1]);
2387 }
2388 SYNTAX("addc %0, %e1");
2389 #line 245 "rl78-decode.opc"
2390 ID(addc); DR(A); SM2(HL, B, 0); Fzac;
2391
2392 }
2393 break;
2394 case 0x92:
2395 {
2396 /** 0110 0001 1001 0010 addc %0, %e1 */
2397 if (trace)
2398 {
2399 printf ("\033[33m%s\033[0m %02x %02x\n",
2400 "/** 0110 0001 1001 0010 addc %0, %e1 */",
2401 op[0], op[1]);
2402 }
2403 SYNTAX("addc %0, %e1");
2404 #line 248 "rl78-decode.opc"
2405 ID(addc); DR(A); SM2(HL, C, 0); Fzac;
2406
2407 }
2408 break;
2409 case 0xa0:
2410 case 0xa1:
2411 {
2412 /** 0110 0001 1010 000 sub %0, %e1 */
2413 if (trace)
2414 {
2415 printf ("\033[33m%s\033[0m %02x %02x\n",
2416 "/** 0110 0001 1010 000 sub %0, %e1 */",
2417 op[0], op[1]);
2418 }
2419 SYNTAX("sub %0, %e1");
2420 #line 1131 "rl78-decode.opc"
2421 ID(sub); DR(A); SM2(HL, B, 0); Fzac;
2422
2423 }
2424 break;
2425 case 0xa2:
2426 {
2427 /** 0110 0001 1010 0010 sub %0, %e1 */
2428 if (trace)
2429 {
2430 printf ("\033[33m%s\033[0m %02x %02x\n",
2431 "/** 0110 0001 1010 0010 sub %0, %e1 */",
2432 op[0], op[1]);
2433 }
2434 SYNTAX("sub %0, %e1");
2435 #line 1137 "rl78-decode.opc"
2436 ID(sub); DR(A); SM2(HL, C, 0); Fzac;
2437
2438 }
2439 break;
2440 case 0xa8:
2441 {
2442 /** 0110 0001 1010 1000 xch %0, %1 */
2443 if (trace)
2444 {
2445 printf ("\033[33m%s\033[0m %02x %02x\n",
2446 "/** 0110 0001 1010 1000 xch %0, %1 */",
2447 op[0], op[1]);
2448 }
2449 SYNTAX("xch %0, %1");
2450 #line 1234 "rl78-decode.opc"
2451 ID(xch); DR(A); SM(None, SADDR);
2452
2453 }
2454 break;
2455 case 0xa9:
2456 {
2457 /** 0110 0001 1010 1001 xch %0, %e1 */
2458 if (trace)
2459 {
2460 printf ("\033[33m%s\033[0m %02x %02x\n",
2461 "/** 0110 0001 1010 1001 xch %0, %e1 */",
2462 op[0], op[1]);
2463 }
2464 SYNTAX("xch %0, %e1");
2465 #line 1227 "rl78-decode.opc"
2466 ID(xch); DR(A); SM2(HL, C, 0);
2467
2468 }
2469 break;
2470 case 0xaa:
2471 {
2472 /** 0110 0001 1010 1010 xch %0, %e!1 */
2473 if (trace)
2474 {
2475 printf ("\033[33m%s\033[0m %02x %02x\n",
2476 "/** 0110 0001 1010 1010 xch %0, %e!1 */",
2477 op[0], op[1]);
2478 }
2479 SYNTAX("xch %0, %e!1");
2480 #line 1209 "rl78-decode.opc"
2481 ID(xch); DR(A); SM(None, IMMU(2));
2482
2483 }
2484 break;
2485 case 0xab:
2486 {
2487 /** 0110 0001 1010 1011 xch %0, %s1 */
2488 if (trace)
2489 {
2490 printf ("\033[33m%s\033[0m %02x %02x\n",
2491 "/** 0110 0001 1010 1011 xch %0, %s1 */",
2492 op[0], op[1]);
2493 }
2494 SYNTAX("xch %0, %s1");
2495 #line 1237 "rl78-decode.opc"
2496 ID(xch); DR(A); SM(None, SFR);
2497
2498 }
2499 break;
2500 case 0xac:
2501 {
2502 /** 0110 0001 1010 1100 xch %0, %e1 */
2503 if (trace)
2504 {
2505 printf ("\033[33m%s\033[0m %02x %02x\n",
2506 "/** 0110 0001 1010 1100 xch %0, %e1 */",
2507 op[0], op[1]);
2508 }
2509 SYNTAX("xch %0, %e1");
2510 #line 1218 "rl78-decode.opc"
2511 ID(xch); DR(A); SM(HL, 0);
2512
2513 }
2514 break;
2515 case 0xad:
2516 {
2517 /** 0110 0001 1010 1101 xch %0, %ea1 */
2518 if (trace)
2519 {
2520 printf ("\033[33m%s\033[0m %02x %02x\n",
2521 "/** 0110 0001 1010 1101 xch %0, %ea1 */",
2522 op[0], op[1]);
2523 }
2524 SYNTAX("xch %0, %ea1");
2525 #line 1224 "rl78-decode.opc"
2526 ID(xch); DR(A); SM(HL, IMMU(1));
2527
2528 }
2529 break;
2530 case 0xae:
2531 {
2532 /** 0110 0001 1010 1110 xch %0, %e1 */
2533 if (trace)
2534 {
2535 printf ("\033[33m%s\033[0m %02x %02x\n",
2536 "/** 0110 0001 1010 1110 xch %0, %e1 */",
2537 op[0], op[1]);
2538 }
2539 SYNTAX("xch %0, %e1");
2540 #line 1212 "rl78-decode.opc"
2541 ID(xch); DR(A); SM(DE, 0);
2542
2543 }
2544 break;
2545 case 0xaf:
2546 {
2547 /** 0110 0001 1010 1111 xch %0, %ea1 */
2548 if (trace)
2549 {
2550 printf ("\033[33m%s\033[0m %02x %02x\n",
2551 "/** 0110 0001 1010 1111 xch %0, %ea1 */",
2552 op[0], op[1]);
2553 }
2554 SYNTAX("xch %0, %ea1");
2555 #line 1215 "rl78-decode.opc"
2556 ID(xch); DR(A); SM(DE, IMMU(1));
2557
2558 }
2559 break;
2560 case 0xb0:
2561 {
2562 /** 0110 0001 1011 0000 subc %0, %e1 */
2563 if (trace)
2564 {
2565 printf ("\033[33m%s\033[0m %02x %02x\n",
2566 "/** 0110 0001 1011 0000 subc %0, %e1 */",
2567 op[0], op[1]);
2568 }
2569 SYNTAX("subc %0, %e1");
2570 #line 1163 "rl78-decode.opc"
2571 ID(subc); DR(A); SM2(HL, B, 0); Fzac;
2572
2573 }
2574 break;
2575 case 0xb2:
2576 {
2577 /** 0110 0001 1011 0010 subc %0, %e1 */
2578 if (trace)
2579 {
2580 printf ("\033[33m%s\033[0m %02x %02x\n",
2581 "/** 0110 0001 1011 0010 subc %0, %e1 */",
2582 op[0], op[1]);
2583 }
2584 SYNTAX("subc %0, %e1");
2585 #line 1166 "rl78-decode.opc"
2586 ID(subc); DR(A); SM2(HL, C, 0); Fzac;
2587
2588 }
2589 break;
2590 case 0xb8:
2591 {
2592 /** 0110 0001 1011 1000 mov %0, %1 */
2593 if (trace)
2594 {
2595 printf ("\033[33m%s\033[0m %02x %02x\n",
2596 "/** 0110 0001 1011 1000 mov %0, %1 */",
2597 op[0], op[1]);
2598 }
2599 SYNTAX("mov %0, %1");
2600 #line 729 "rl78-decode.opc"
2601 ID(mov); DR(ES); SM(None, SADDR);
2602
2603 }
2604 break;
2605 case 0xb9:
2606 {
2607 /** 0110 0001 1011 1001 xch %0, %e1 */
2608 if (trace)
2609 {
2610 printf ("\033[33m%s\033[0m %02x %02x\n",
2611 "/** 0110 0001 1011 1001 xch %0, %e1 */",
2612 op[0], op[1]);
2613 }
2614 SYNTAX("xch %0, %e1");
2615 #line 1221 "rl78-decode.opc"
2616 ID(xch); DR(A); SM2(HL, B, 0);
2617
2618 }
2619 break;
2620 case 0xc0:
2621 {
2622 /** 0110 0001 1100 0000 cmp %0, %e1 */
2623 if (trace)
2624 {
2625 printf ("\033[33m%s\033[0m %02x %02x\n",
2626 "/** 0110 0001 1100 0000 cmp %0, %e1 */",
2627 op[0], op[1]);
2628 }
2629 SYNTAX("cmp %0, %e1");
2630 #line 498 "rl78-decode.opc"
2631 ID(cmp); DR(A); SM2(HL, B, 0); Fzac;
2632
2633 }
2634 break;
2635 case 0xc2:
2636 {
2637 /** 0110 0001 1100 0010 cmp %0, %e1 */
2638 if (trace)
2639 {
2640 printf ("\033[33m%s\033[0m %02x %02x\n",
2641 "/** 0110 0001 1100 0010 cmp %0, %e1 */",
2642 op[0], op[1]);
2643 }
2644 SYNTAX("cmp %0, %e1");
2645 #line 501 "rl78-decode.opc"
2646 ID(cmp); DR(A); SM2(HL, C, 0); Fzac;
2647
2648 }
2649 break;
2650 case 0xc3:
2651 {
2652 /** 0110 0001 1100 0011 bh $%a0 */
2653 if (trace)
2654 {
2655 printf ("\033[33m%s\033[0m %02x %02x\n",
2656 "/** 0110 0001 1100 0011 bh $%a0 */",
2657 op[0], op[1]);
2658 }
2659 SYNTAX("bh $%a0");
2660 #line 346 "rl78-decode.opc"
2661 ID(branch_cond); DC(pc+IMMS(1)+3); SR(None); COND(H);
2662
2663 }
2664 break;
2665 case 0xc8:
2666 {
2667 /** 0110 0001 1100 1000 sk%c1 */
2668 if (trace)
2669 {
2670 printf ("\033[33m%s\033[0m %02x %02x\n",
2671 "/** 0110 0001 1100 1000 sk%c1 */",
2672 op[0], op[1]);
2673 }
2674 SYNTAX("sk%c1");
2675 #line 1100 "rl78-decode.opc"
2676 ID(skip); COND(C);
2677
2678 }
2679 break;
2680 case 0xc9:
2681 {
2682 /** 0110 0001 1100 1001 mov %0, %e1 */
2683 if (trace)
2684 {
2685 printf ("\033[33m%s\033[0m %02x %02x\n",
2686 "/** 0110 0001 1100 1001 mov %0, %e1 */",
2687 op[0], op[1]);
2688 }
2689 SYNTAX("mov %0, %e1");
2690 #line 666 "rl78-decode.opc"
2691 ID(mov); DR(A); SM2(HL, B, 0);
2692
2693 }
2694 break;
2695 case 0xca:
2696 case 0xda:
2697 case 0xea:
2698 case 0xfa:
2699 {
2700 /** 0110 0001 11rg 1010 call %0 */
2701 #line 436 "rl78-decode.opc"
2702 int rg AU = (op[1] >> 4) & 0x03;
2703 if (trace)
2704 {
2705 printf ("\033[33m%s\033[0m %02x %02x\n",
2706 "/** 0110 0001 11rg 1010 call %0 */",
2707 op[0], op[1]);
2708 printf (" rg = 0x%x\n", rg);
2709 }
2710 SYNTAX("call %0");
2711 #line 436 "rl78-decode.opc"
2712 ID(call); DRW(rg);
2713
2714 }
2715 break;
2716 case 0xcb:
2717 {
2718 /** 0110 0001 1100 1011 br ax */
2719 if (trace)
2720 {
2721 printf ("\033[33m%s\033[0m %02x %02x\n",
2722 "/** 0110 0001 1100 1011 br ax */",
2723 op[0], op[1]);
2724 }
2725 SYNTAX("br ax");
2726 #line 386 "rl78-decode.opc"
2727 ID(branch); DR(AX);
2728
2729 /*----------------------------------------------------------------------*/
2730
2731 }
2732 break;
2733 case 0xcc:
2734 {
2735 /** 0110 0001 1100 1100 brk */
2736 if (trace)
2737 {
2738 printf ("\033[33m%s\033[0m %02x %02x\n",
2739 "/** 0110 0001 1100 1100 brk */",
2740 op[0], op[1]);
2741 }
2742 SYNTAX("brk");
2743 #line 394 "rl78-decode.opc"
2744 ID(break);
2745
2746 /*----------------------------------------------------------------------*/
2747
2748 }
2749 break;
2750 case 0xcd:
2751 {
2752 /** 0110 0001 1100 1101 pop %s0 */
2753 if (trace)
2754 {
2755 printf ("\033[33m%s\033[0m %02x %02x\n",
2756 "/** 0110 0001 1100 1101 pop %s0 */",
2757 op[0], op[1]);
2758 }
2759 SYNTAX("pop %s0");
2760 #line 995 "rl78-decode.opc"
2761 ID(mov); W(); DR(PSW); SPOP();
2762
2763 /*----------------------------------------------------------------------*/
2764
2765 }
2766 break;
2767 case 0xce:
2768 {
2769 /** 0110 0001 1100 1110 movs %ea0, %1 */
2770 if (trace)
2771 {
2772 printf ("\033[33m%s\033[0m %02x %02x\n",
2773 "/** 0110 0001 1100 1110 movs %ea0, %1 */",
2774 op[0], op[1]);
2775 }
2776 SYNTAX("movs %ea0, %1");
2777 #line 817 "rl78-decode.opc"
2778 ID(mov); DM(HL, IMMU(1)); SR(X); Fzc;
2779
2780 /*----------------------------------------------------------------------*/
2781
2782 }
2783 break;
2784 case 0xcf:
2785 case 0xdf:
2786 case 0xef:
2787 case 0xff:
2788 {
2789 /** 0110 0001 11rb 1111 sel rb%1 */
2790 #line 1047 "rl78-decode.opc"
2791 int rb AU = (op[1] >> 4) & 0x03;
2792 if (trace)
2793 {
2794 printf ("\033[33m%s\033[0m %02x %02x\n",
2795 "/** 0110 0001 11rb 1111 sel rb%1 */",
2796 op[0], op[1]);
2797 printf (" rb = 0x%x\n", rb);
2798 }
2799 SYNTAX("sel rb%1");
2800 #line 1047 "rl78-decode.opc"
2801 ID(sel); SC(rb);
2802
2803 /*----------------------------------------------------------------------*/
2804
2805 }
2806 break;
2807 case 0xd0:
2808 {
2809 /** 0110 0001 1101 0000 and %0, %e1 */
2810 if (trace)
2811 {
2812 printf ("\033[33m%s\033[0m %02x %02x\n",
2813 "/** 0110 0001 1101 0000 and %0, %e1 */",
2814 op[0], op[1]);
2815 }
2816 SYNTAX("and %0, %e1");
2817 #line 297 "rl78-decode.opc"
2818 ID(and); DR(A); SM2(HL, B, 0); Fz;
2819
2820 }
2821 break;
2822 case 0xd2:
2823 {
2824 /** 0110 0001 1101 0010 and %0, %e1 */
2825 if (trace)
2826 {
2827 printf ("\033[33m%s\033[0m %02x %02x\n",
2828 "/** 0110 0001 1101 0010 and %0, %e1 */",
2829 op[0], op[1]);
2830 }
2831 SYNTAX("and %0, %e1");
2832 #line 303 "rl78-decode.opc"
2833 ID(and); DR(A); SM2(HL, C, 0); Fz;
2834
2835 }
2836 break;
2837 case 0xd3:
2838 {
2839 /** 0110 0001 1101 0011 bnh $%a0 */
2840 if (trace)
2841 {
2842 printf ("\033[33m%s\033[0m %02x %02x\n",
2843 "/** 0110 0001 1101 0011 bnh $%a0 */",
2844 op[0], op[1]);
2845 }
2846 SYNTAX("bnh $%a0");
2847 #line 349 "rl78-decode.opc"
2848 ID(branch_cond); DC(pc+IMMS(1)+3); SR(None); COND(NH);
2849
2850 }
2851 break;
2852 case 0xd8:
2853 {
2854 /** 0110 0001 1101 1000 sk%c1 */
2855 if (trace)
2856 {
2857 printf ("\033[33m%s\033[0m %02x %02x\n",
2858 "/** 0110 0001 1101 1000 sk%c1 */",
2859 op[0], op[1]);
2860 }
2861 SYNTAX("sk%c1");
2862 #line 1106 "rl78-decode.opc"
2863 ID(skip); COND(NC);
2864
2865 }
2866 break;
2867 case 0xd9:
2868 {
2869 /** 0110 0001 1101 1001 mov %e0, %1 */
2870 if (trace)
2871 {
2872 printf ("\033[33m%s\033[0m %02x %02x\n",
2873 "/** 0110 0001 1101 1001 mov %e0, %1 */",
2874 op[0], op[1]);
2875 }
2876 SYNTAX("mov %e0, %1");
2877 #line 633 "rl78-decode.opc"
2878 ID(mov); DM2(HL, B, 0); SR(A);
2879
2880 }
2881 break;
2882 case 0xdb:
2883 {
2884 /** 0110 0001 1101 1011 ror %0, %1 */
2885 if (trace)
2886 {
2887 printf ("\033[33m%s\033[0m %02x %02x\n",
2888 "/** 0110 0001 1101 1011 ror %0, %1 */",
2889 op[0], op[1]);
2890 }
2891 SYNTAX("ror %0, %1");
2892 #line 1028 "rl78-decode.opc"
2893 ID(ror); DR(A); SC(1);
2894
2895 }
2896 break;
2897 case 0xdc:
2898 {
2899 /** 0110 0001 1101 1100 rolc %0, %1 */
2900 if (trace)
2901 {
2902 printf ("\033[33m%s\033[0m %02x %02x\n",
2903 "/** 0110 0001 1101 1100 rolc %0, %1 */",
2904 op[0], op[1]);
2905 }
2906 SYNTAX("rolc %0, %1");
2907 #line 1022 "rl78-decode.opc"
2908 ID(rolc); DR(A); SC(1);
2909
2910 }
2911 break;
2912 case 0xdd:
2913 {
2914 /** 0110 0001 1101 1101 push %s1 */
2915 if (trace)
2916 {
2917 printf ("\033[33m%s\033[0m %02x %02x\n",
2918 "/** 0110 0001 1101 1101 push %s1 */",
2919 op[0], op[1]);
2920 }
2921 SYNTAX("push %s1");
2922 #line 1003 "rl78-decode.opc"
2923 ID(mov); W(); DPUSH(); SR(PSW);
2924
2925 /*----------------------------------------------------------------------*/
2926
2927 }
2928 break;
2929 case 0xde:
2930 {
2931 /** 0110 0001 1101 1110 cmps %0, %ea1 */
2932 if (trace)
2933 {
2934 printf ("\033[33m%s\033[0m %02x %02x\n",
2935 "/** 0110 0001 1101 1110 cmps %0, %ea1 */",
2936 op[0], op[1]);
2937 }
2938 SYNTAX("cmps %0, %ea1");
2939 #line 532 "rl78-decode.opc"
2940 ID(cmp); DR(X); SM(HL, IMMU(1)); Fzac;
2941
2942 /*----------------------------------------------------------------------*/
2943
2944 }
2945 break;
2946 case 0xe0:
2947 {
2948 /** 0110 0001 1110 0000 or %0, %e1 */
2949 if (trace)
2950 {
2951 printf ("\033[33m%s\033[0m %02x %02x\n",
2952 "/** 0110 0001 1110 0000 or %0, %e1 */",
2953 op[0], op[1]);
2954 }
2955 SYNTAX("or %0, %e1");
2956 #line 952 "rl78-decode.opc"
2957 ID(or); DR(A); SM2(HL, B, 0); Fz;
2958
2959 }
2960 break;
2961 case 0xe2:
2962 {
2963 /** 0110 0001 1110 0010 or %0, %e1 */
2964 if (trace)
2965 {
2966 printf ("\033[33m%s\033[0m %02x %02x\n",
2967 "/** 0110 0001 1110 0010 or %0, %e1 */",
2968 op[0], op[1]);
2969 }
2970 SYNTAX("or %0, %e1");
2971 #line 958 "rl78-decode.opc"
2972 ID(or); DR(A); SM2(HL, C, 0); Fz;
2973
2974 }
2975 break;
2976 case 0xe3:
2977 {
2978 /** 0110 0001 1110 0011 sk%c1 */
2979 if (trace)
2980 {
2981 printf ("\033[33m%s\033[0m %02x %02x\n",
2982 "/** 0110 0001 1110 0011 sk%c1 */",
2983 op[0], op[1]);
2984 }
2985 SYNTAX("sk%c1");
2986 #line 1103 "rl78-decode.opc"
2987 ID(skip); COND(H);
2988
2989 }
2990 break;
2991 case 0xe8:
2992 {
2993 /** 0110 0001 1110 1000 sk%c1 */
2994 if (trace)
2995 {
2996 printf ("\033[33m%s\033[0m %02x %02x\n",
2997 "/** 0110 0001 1110 1000 sk%c1 */",
2998 op[0], op[1]);
2999 }
3000 SYNTAX("sk%c1");
3001 #line 1115 "rl78-decode.opc"
3002 ID(skip); COND(Z);
3003
3004 /*----------------------------------------------------------------------*/
3005
3006 }
3007 break;
3008 case 0xe9:
3009 {
3010 /** 0110 0001 1110 1001 mov %0, %e1 */
3011 if (trace)
3012 {
3013 printf ("\033[33m%s\033[0m %02x %02x\n",
3014 "/** 0110 0001 1110 1001 mov %0, %e1 */",
3015 op[0], op[1]);
3016 }
3017 SYNTAX("mov %0, %e1");
3018 #line 669 "rl78-decode.opc"
3019 ID(mov); DR(A); SM2(HL, C, 0);
3020
3021 }
3022 break;
3023 case 0xeb:
3024 {
3025 /** 0110 0001 1110 1011 rol %0, %1 */
3026 if (trace)
3027 {
3028 printf ("\033[33m%s\033[0m %02x %02x\n",
3029 "/** 0110 0001 1110 1011 rol %0, %1 */",
3030 op[0], op[1]);
3031 }
3032 SYNTAX("rol %0, %1");
3033 #line 1019 "rl78-decode.opc"
3034 ID(rol); DR(A); SC(1);
3035
3036 }
3037 break;
3038 case 0xec:
3039 {
3040 /** 0110 0001 1110 1100 retb */
3041 if (trace)
3042 {
3043 printf ("\033[33m%s\033[0m %02x %02x\n",
3044 "/** 0110 0001 1110 1100 retb */",
3045 op[0], op[1]);
3046 }
3047 SYNTAX("retb");
3048 #line 1014 "rl78-decode.opc"
3049 ID(reti);
3050
3051 /*----------------------------------------------------------------------*/
3052
3053 }
3054 break;
3055 case 0xed:
3056 {
3057 /** 0110 0001 1110 1101 halt */
3058 if (trace)
3059 {
3060 printf ("\033[33m%s\033[0m %02x %02x\n",
3061 "/** 0110 0001 1110 1101 halt */",
3062 op[0], op[1]);
3063 }
3064 SYNTAX("halt");
3065 #line 582 "rl78-decode.opc"
3066 ID(halt);
3067
3068 /*----------------------------------------------------------------------*/
3069
3070 }
3071 break;
3072 case 0xee:
3073 case 0xfe:
3074 {
3075 /** 0110 0001 111r 1110 rolwc %0, %1 */
3076 #line 1025 "rl78-decode.opc"
3077 int r AU = (op[1] >> 4) & 0x01;
3078 if (trace)
3079 {
3080 printf ("\033[33m%s\033[0m %02x %02x\n",
3081 "/** 0110 0001 111r 1110 rolwc %0, %1 */",
3082 op[0], op[1]);
3083 printf (" r = 0x%x\n", r);
3084 }
3085 SYNTAX("rolwc %0, %1");
3086 #line 1025 "rl78-decode.opc"
3087 ID(rolc); W(); DRW(r); SC(1);
3088
3089 }
3090 break;
3091 case 0xf0:
3092 {
3093 /** 0110 0001 1111 0000 xor %0, %e1 */
3094 if (trace)
3095 {
3096 printf ("\033[33m%s\033[0m %02x %02x\n",
3097 "/** 0110 0001 1111 0000 xor %0, %e1 */",
3098 op[0], op[1]);
3099 }
3100 SYNTAX("xor %0, %e1");
3101 #line 1256 "rl78-decode.opc"
3102 ID(xor); DR(A); SM2(HL, B, 0); Fz;
3103
3104 }
3105 break;
3106 case 0xf2:
3107 {
3108 /** 0110 0001 1111 0010 xor %0, %e1 */
3109 if (trace)
3110 {
3111 printf ("\033[33m%s\033[0m %02x %02x\n",
3112 "/** 0110 0001 1111 0010 xor %0, %e1 */",
3113 op[0], op[1]);
3114 }
3115 SYNTAX("xor %0, %e1");
3116 #line 1262 "rl78-decode.opc"
3117 ID(xor); DR(A); SM2(HL, C, 0); Fz;
3118
3119 }
3120 break;
3121 case 0xf3:
3122 {
3123 /** 0110 0001 1111 0011 sk%c1 */
3124 if (trace)
3125 {
3126 printf ("\033[33m%s\033[0m %02x %02x\n",
3127 "/** 0110 0001 1111 0011 sk%c1 */",
3128 op[0], op[1]);
3129 }
3130 SYNTAX("sk%c1");
3131 #line 1109 "rl78-decode.opc"
3132 ID(skip); COND(NH);
3133
3134 }
3135 break;
3136 case 0xf8:
3137 {
3138 /** 0110 0001 1111 1000 sk%c1 */
3139 if (trace)
3140 {
3141 printf ("\033[33m%s\033[0m %02x %02x\n",
3142 "/** 0110 0001 1111 1000 sk%c1 */",
3143 op[0], op[1]);
3144 }
3145 SYNTAX("sk%c1");
3146 #line 1112 "rl78-decode.opc"
3147 ID(skip); COND(NZ);
3148
3149 }
3150 break;
3151 case 0xf9:
3152 {
3153 /** 0110 0001 1111 1001 mov %e0, %1 */
3154 if (trace)
3155 {
3156 printf ("\033[33m%s\033[0m %02x %02x\n",
3157 "/** 0110 0001 1111 1001 mov %e0, %1 */",
3158 op[0], op[1]);
3159 }
3160 SYNTAX("mov %e0, %1");
3161 #line 642 "rl78-decode.opc"
3162 ID(mov); DM2(HL, C, 0); SR(A);
3163
3164 }
3165 break;
3166 case 0xfb:
3167 {
3168 /** 0110 0001 1111 1011 rorc %0, %1 */
3169 if (trace)
3170 {
3171 printf ("\033[33m%s\033[0m %02x %02x\n",
3172 "/** 0110 0001 1111 1011 rorc %0, %1 */",
3173 op[0], op[1]);
3174 }
3175 SYNTAX("rorc %0, %1");
3176 #line 1031 "rl78-decode.opc"
3177 ID(rorc); DR(A); SC(1);
3178
3179 /*----------------------------------------------------------------------*/
3180
3181 /* Note that the branch insns need to be listed before the shift
3182 ones, as "shift count of zero" means "branch insn" */
3183
3184 }
3185 break;
3186 case 0xfc:
3187 {
3188 /** 0110 0001 1111 1100 reti */
3189 if (trace)
3190 {
3191 printf ("\033[33m%s\033[0m %02x %02x\n",
3192 "/** 0110 0001 1111 1100 reti */",
3193 op[0], op[1]);
3194 }
3195 SYNTAX("reti");
3196 #line 1011 "rl78-decode.opc"
3197 ID(reti);
3198
3199 }
3200 break;
3201 case 0xfd:
3202 {
3203 /** 0110 0001 1111 1101 stop */
3204 if (trace)
3205 {
3206 printf ("\033[33m%s\033[0m %02x %02x\n",
3207 "/** 0110 0001 1111 1101 stop */",
3208 op[0], op[1]);
3209 }
3210 SYNTAX("stop");
3211 #line 1120 "rl78-decode.opc"
3212 ID(stop);
3213
3214 /*----------------------------------------------------------------------*/
3215
3216 }
3217 break;
3218 default: UNSUPPORTED(); break;
3219 }
3220 break;
3221 case 0x68:
3222 {
3223 /** 0110 1000 movw %e0, %1 */
3224 if (trace)
3225 {
3226 printf ("\033[33m%s\033[0m %02x\n",
3227 "/** 0110 1000 movw %e0, %1 */",
3228 op[0]);
3229 }
3230 SYNTAX("movw %e0, %1");
3231 #line 880 "rl78-decode.opc"
3232 ID(mov); W(); DM(C, IMMU(2)); SR(AX);
3233
3234 }
3235 break;
3236 case 0x69:
3237 {
3238 /** 0110 1001 movw %0, %e1 */
3239 if (trace)
3240 {
3241 printf ("\033[33m%s\033[0m %02x\n",
3242 "/** 0110 1001 movw %0, %e1 */",
3243 op[0]);
3244 }
3245 SYNTAX("movw %0, %e1");
3246 #line 871 "rl78-decode.opc"
3247 ID(mov); W(); DR(AX); SM(C, IMMU(2));
3248
3249 }
3250 break;
3251 case 0x6a:
3252 {
3253 /** 0110 1010 or %0, #%1 */
3254 if (trace)
3255 {
3256 printf ("\033[33m%s\033[0m %02x\n",
3257 "/** 0110 1010 or %0, #%1 */",
3258 op[0]);
3259 }
3260 SYNTAX("or %0, #%1");
3261 #line 973 "rl78-decode.opc"
3262 ID(or); DM(None, SADDR); SC(IMMU(1)); Fz;
3263
3264 /*----------------------------------------------------------------------*/
3265
3266 }
3267 break;
3268 case 0x6b:
3269 {
3270 /** 0110 1011 or %0, %1 */
3271 if (trace)
3272 {
3273 printf ("\033[33m%s\033[0m %02x\n",
3274 "/** 0110 1011 or %0, %1 */",
3275 op[0]);
3276 }
3277 SYNTAX("or %0, %1");
3278 #line 970 "rl78-decode.opc"
3279 ID(or); DR(A); SM(None, SADDR); Fz;
3280
3281 }
3282 break;
3283 case 0x6c:
3284 {
3285 /** 0110 1100 or %0, #%1 */
3286 if (trace)
3287 {
3288 printf ("\033[33m%s\033[0m %02x\n",
3289 "/** 0110 1100 or %0, #%1 */",
3290 op[0]);
3291 }
3292 SYNTAX("or %0, #%1");
3293 #line 961 "rl78-decode.opc"
3294 ID(or); DR(A); SC(IMMU(1)); Fz;
3295
3296 }
3297 break;
3298 case 0x6d:
3299 {
3300 /** 0110 1101 or %0, %e1 */
3301 if (trace)
3302 {
3303 printf ("\033[33m%s\033[0m %02x\n",
3304 "/** 0110 1101 or %0, %e1 */",
3305 op[0]);
3306 }
3307 SYNTAX("or %0, %e1");
3308 #line 949 "rl78-decode.opc"
3309 ID(or); DR(A); SM(HL, 0); Fz;
3310
3311 }
3312 break;
3313 case 0x6e:
3314 {
3315 /** 0110 1110 or %0, %ea1 */
3316 if (trace)
3317 {
3318 printf ("\033[33m%s\033[0m %02x\n",
3319 "/** 0110 1110 or %0, %ea1 */",
3320 op[0]);
3321 }
3322 SYNTAX("or %0, %ea1");
3323 #line 955 "rl78-decode.opc"
3324 ID(or); DR(A); SM(HL, IMMU(1)); Fz;
3325
3326 }
3327 break;
3328 case 0x6f:
3329 {
3330 /** 0110 1111 or %0, %e!1 */
3331 if (trace)
3332 {
3333 printf ("\033[33m%s\033[0m %02x\n",
3334 "/** 0110 1111 or %0, %e!1 */",
3335 op[0]);
3336 }
3337 SYNTAX("or %0, %e!1");
3338 #line 946 "rl78-decode.opc"
3339 ID(or); DR(A); SM(None, IMMU(2)); Fz;
3340
3341 }
3342 break;
3343 case 0x70:
3344 case 0x72:
3345 case 0x73:
3346 case 0x74:
3347 case 0x75:
3348 case 0x76:
3349 case 0x77:
3350 {
3351 /** 0111 0rba mov %0, %1 */
3352 #line 702 "rl78-decode.opc"
3353 int rba AU = op[0] & 0x07;
3354 if (trace)
3355 {
3356 printf ("\033[33m%s\033[0m %02x\n",
3357 "/** 0111 0rba mov %0, %1 */",
3358 op[0]);
3359 printf (" rba = 0x%x\n", rba);
3360 }
3361 SYNTAX("mov %0, %1");
3362 #line 702 "rl78-decode.opc"
3363 ID(mov); DRB(rba); SR(A);
3364
3365 }
3366 break;
3367 case 0x71:
3368 GETBYTE ();
3369 switch (op[1] & 0xff)
3370 {
3371 case 0x00:
3372 case 0x10:
3373 case 0x20:
3374 case 0x30:
3375 case 0x40:
3376 case 0x50:
3377 case 0x60:
3378 case 0x70:
3379 {
3380 /** 0111 0001 0bit 0000 set1 %e!0 */
3381 #line 1052 "rl78-decode.opc"
3382 int bit AU = (op[1] >> 4) & 0x07;
3383 if (trace)
3384 {
3385 printf ("\033[33m%s\033[0m %02x %02x\n",
3386 "/** 0111 0001 0bit 0000 set1 %e!0 */",
3387 op[0], op[1]);
3388 printf (" bit = 0x%x\n", bit);
3389 }
3390 SYNTAX("set1 %e!0");
3391 #line 1052 "rl78-decode.opc"
3392 ID(mov); DM(None, IMMU(2)); DB(bit); SC(1);
3393
3394 }
3395 break;
3396 case 0x01:
3397 case 0x11:
3398 case 0x21:
3399 case 0x31:
3400 case 0x41:
3401 case 0x51:
3402 case 0x61:
3403 case 0x71:
3404 {
3405 /** 0111 0001 0bit 0001 mov1 %0, cy */
3406 #line 809 "rl78-decode.opc"
3407 int bit AU = (op[1] >> 4) & 0x07;
3408 if (trace)
3409 {
3410 printf ("\033[33m%s\033[0m %02x %02x\n",
3411 "/** 0111 0001 0bit 0001 mov1 %0, cy */",
3412 op[0], op[1]);
3413 printf (" bit = 0x%x\n", bit);
3414 }
3415 SYNTAX("mov1 %0, cy");
3416 #line 809 "rl78-decode.opc"
3417 ID(mov); DM(None, SADDR); DB(bit); SCY();
3418
3419 }
3420 break;
3421 case 0x02:
3422 case 0x12:
3423 case 0x22:
3424 case 0x32:
3425 case 0x42:
3426 case 0x52:
3427 case 0x62:
3428 case 0x72:
3429 {
3430 /** 0111 0001 0bit 0010 set1 %0 */
3431 #line 1070 "rl78-decode.opc"
3432 int bit AU = (op[1] >> 4) & 0x07;
3433 if (trace)
3434 {
3435 printf ("\033[33m%s\033[0m %02x %02x\n",
3436 "/** 0111 0001 0bit 0010 set1 %0 */",
3437 op[0], op[1]);
3438 printf (" bit = 0x%x\n", bit);
3439 }
3440 SYNTAX("set1 %0");
3441 #line 1070 "rl78-decode.opc"
3442 ID(mov); DM(None, SADDR); DB(bit); SC(1);
3443
3444 /*----------------------------------------------------------------------*/
3445
3446 }
3447 break;
3448 case 0x03:
3449 case 0x13:
3450 case 0x23:
3451 case 0x33:
3452 case 0x43:
3453 case 0x53:
3454 case 0x63:
3455 case 0x73:
3456 {
3457 /** 0111 0001 0bit 0011 clr1 %0 */
3458 #line 462 "rl78-decode.opc"
3459 int bit AU = (op[1] >> 4) & 0x07;
3460 if (trace)
3461 {
3462 printf ("\033[33m%s\033[0m %02x %02x\n",
3463 "/** 0111 0001 0bit 0011 clr1 %0 */",
3464 op[0], op[1]);
3465 printf (" bit = 0x%x\n", bit);
3466 }
3467 SYNTAX("clr1 %0");
3468 #line 462 "rl78-decode.opc"
3469 ID(mov); DM(None, SADDR); DB(bit); SC(0);
3470
3471 /*----------------------------------------------------------------------*/
3472
3473 }
3474 break;
3475 case 0x04:
3476 case 0x14:
3477 case 0x24:
3478 case 0x34:
3479 case 0x44:
3480 case 0x54:
3481 case 0x64:
3482 case 0x74:
3483 {
3484 /** 0111 0001 0bit 0100 mov1 cy, %1 */
3485 #line 803 "rl78-decode.opc"
3486 int bit AU = (op[1] >> 4) & 0x07;
3487 if (trace)
3488 {
3489 printf ("\033[33m%s\033[0m %02x %02x\n",
3490 "/** 0111 0001 0bit 0100 mov1 cy, %1 */",
3491 op[0], op[1]);
3492 printf (" bit = 0x%x\n", bit);
3493 }
3494 SYNTAX("mov1 cy, %1");
3495 #line 803 "rl78-decode.opc"
3496 ID(mov); DCY(); SM(None, SADDR); SB(bit);
3497
3498 }
3499 break;
3500 case 0x05:
3501 case 0x15:
3502 case 0x25:
3503 case 0x35:
3504 case 0x45:
3505 case 0x55:
3506 case 0x65:
3507 case 0x75:
3508 {
3509 /** 0111 0001 0bit 0101 and1 cy, %s1 */
3510 #line 332 "rl78-decode.opc"
3511 int bit AU = (op[1] >> 4) & 0x07;
3512 if (trace)
3513 {
3514 printf ("\033[33m%s\033[0m %02x %02x\n",
3515 "/** 0111 0001 0bit 0101 and1 cy, %s1 */",
3516 op[0], op[1]);
3517 printf (" bit = 0x%x\n", bit);
3518 }
3519 SYNTAX("and1 cy, %s1");
3520 #line 332 "rl78-decode.opc"
3521 ID(and); DCY(); SM(None, SADDR); SB(bit);
3522
3523 /*----------------------------------------------------------------------*/
3524
3525 /* Note that the branch insns need to be listed before the shift
3526 ones, as "shift count of zero" means "branch insn" */
3527
3528 }
3529 break;
3530 case 0x06:
3531 case 0x16:
3532 case 0x26:
3533 case 0x36:
3534 case 0x46:
3535 case 0x56:
3536 case 0x66:
3537 case 0x76:
3538 {
3539 /** 0111 0001 0bit 0110 or1 cy, %s1 */
3540 #line 987 "rl78-decode.opc"
3541 int bit AU = (op[1] >> 4) & 0x07;
3542 if (trace)
3543 {
3544 printf ("\033[33m%s\033[0m %02x %02x\n",
3545 "/** 0111 0001 0bit 0110 or1 cy, %s1 */",
3546 op[0], op[1]);
3547 printf (" bit = 0x%x\n", bit);
3548 }
3549 SYNTAX("or1 cy, %s1");
3550 #line 987 "rl78-decode.opc"
3551 ID(or); DCY(); SM(None, SADDR); SB(bit);
3552
3553 /*----------------------------------------------------------------------*/
3554
3555 }
3556 break;
3557 case 0x07:
3558 case 0x17:
3559 case 0x27:
3560 case 0x37:
3561 case 0x47:
3562 case 0x57:
3563 case 0x67:
3564 case 0x77:
3565 {
3566 /** 0111 0001 0bit 0111 xor1 cy, %s1 */
3567 #line 1291 "rl78-decode.opc"
3568 int bit AU = (op[1] >> 4) & 0x07;
3569 if (trace)
3570 {
3571 printf ("\033[33m%s\033[0m %02x %02x\n",
3572 "/** 0111 0001 0bit 0111 xor1 cy, %s1 */",
3573 op[0], op[1]);
3574 printf (" bit = 0x%x\n", bit);
3575 }
3576 SYNTAX("xor1 cy, %s1");
3577 #line 1291 "rl78-decode.opc"
3578 ID(xor); DCY(); SM(None, SADDR); SB(bit);
3579
3580 /*----------------------------------------------------------------------*/
3581
3582 }
3583 break;
3584 case 0x08:
3585 case 0x18:
3586 case 0x28:
3587 case 0x38:
3588 case 0x48:
3589 case 0x58:
3590 case 0x68:
3591 case 0x78:
3592 {
3593 /** 0111 0001 0bit 1000 clr1 %e!0 */
3594 #line 444 "rl78-decode.opc"
3595 int bit AU = (op[1] >> 4) & 0x07;
3596 if (trace)
3597 {
3598 printf ("\033[33m%s\033[0m %02x %02x\n",
3599 "/** 0111 0001 0bit 1000 clr1 %e!0 */",
3600 op[0], op[1]);
3601 printf (" bit = 0x%x\n", bit);
3602 }
3603 SYNTAX("clr1 %e!0");
3604 #line 444 "rl78-decode.opc"
3605 ID(mov); DM(None, IMMU(2)); DB(bit); SC(0);
3606
3607 }
3608 break;
3609 case 0x09:
3610 case 0x19:
3611 case 0x29:
3612 case 0x39:
3613 case 0x49:
3614 case 0x59:
3615 case 0x69:
3616 case 0x79:
3617 {
3618 /** 0111 0001 0bit 1001 mov1 %s0, cy */
3619 #line 812 "rl78-decode.opc"
3620 int bit AU = (op[1] >> 4) & 0x07;
3621 if (trace)
3622 {
3623 printf ("\033[33m%s\033[0m %02x %02x\n",
3624 "/** 0111 0001 0bit 1001 mov1 %s0, cy */",
3625 op[0], op[1]);
3626 printf (" bit = 0x%x\n", bit);
3627 }
3628 SYNTAX("mov1 %s0, cy");
3629 #line 812 "rl78-decode.opc"
3630 ID(mov); DM(None, SFR); DB(bit); SCY();
3631
3632 /*----------------------------------------------------------------------*/
3633
3634 }
3635 break;
3636 case 0x0a:
3637 case 0x1a:
3638 case 0x2a:
3639 case 0x3a:
3640 case 0x4a:
3641 case 0x5a:
3642 case 0x6a:
3643 case 0x7a:
3644 {
3645 /** 0111 0001 0bit 1010 set1 %s0 */
3646 #line 1064 "rl78-decode.opc"
3647 int bit AU = (op[1] >> 4) & 0x07;
3648 if (trace)
3649 {
3650 printf ("\033[33m%s\033[0m %02x %02x\n",
3651 "/** 0111 0001 0bit 1010 set1 %s0 */",
3652 op[0], op[1]);
3653 printf (" bit = 0x%x\n", bit);
3654 }
3655 SYNTAX("set1 %s0");
3656 #line 1064 "rl78-decode.opc"
3657 op0 = SFR;
3658 ID(mov); DM(None, op0); DB(bit); SC(1);
3659 if (op0 == RL78_SFR_PSW && bit == 7)
3660 rl78->syntax = "ei";
3661
3662 }
3663 break;
3664 case 0x0b:
3665 case 0x1b:
3666 case 0x2b:
3667 case 0x3b:
3668 case 0x4b:
3669 case 0x5b:
3670 case 0x6b:
3671 case 0x7b:
3672 {
3673 /** 0111 0001 0bit 1011 clr1 %s0 */
3674 #line 456 "rl78-decode.opc"
3675 int bit AU = (op[1] >> 4) & 0x07;
3676 if (trace)
3677 {
3678 printf ("\033[33m%s\033[0m %02x %02x\n",
3679 "/** 0111 0001 0bit 1011 clr1 %s0 */",
3680 op[0], op[1]);
3681 printf (" bit = 0x%x\n", bit);
3682 }
3683 SYNTAX("clr1 %s0");
3684 #line 456 "rl78-decode.opc"
3685 op0 = SFR;
3686 ID(mov); DM(None, op0); DB(bit); SC(0);
3687 if (op0 == RL78_SFR_PSW && bit == 7)
3688 rl78->syntax = "di";
3689
3690 }
3691 break;
3692 case 0x0c:
3693 case 0x1c:
3694 case 0x2c:
3695 case 0x3c:
3696 case 0x4c:
3697 case 0x5c:
3698 case 0x6c:
3699 case 0x7c:
3700 {
3701 /** 0111 0001 0bit 1100 mov1 cy, %s1 */
3702 #line 806 "rl78-decode.opc"
3703 int bit AU = (op[1] >> 4) & 0x07;
3704 if (trace)
3705 {
3706 printf ("\033[33m%s\033[0m %02x %02x\n",
3707 "/** 0111 0001 0bit 1100 mov1 cy, %s1 */",
3708 op[0], op[1]);
3709 printf (" bit = 0x%x\n", bit);
3710 }
3711 SYNTAX("mov1 cy, %s1");
3712 #line 806 "rl78-decode.opc"
3713 ID(mov); DCY(); SM(None, SFR); SB(bit);
3714
3715 }
3716 break;
3717 case 0x0d:
3718 case 0x1d:
3719 case 0x2d:
3720 case 0x3d:
3721 case 0x4d:
3722 case 0x5d:
3723 case 0x6d:
3724 case 0x7d:
3725 {
3726 /** 0111 0001 0bit 1101 and1 cy, %s1 */
3727 #line 329 "rl78-decode.opc"
3728 int bit AU = (op[1] >> 4) & 0x07;
3729 if (trace)
3730 {
3731 printf ("\033[33m%s\033[0m %02x %02x\n",
3732 "/** 0111 0001 0bit 1101 and1 cy, %s1 */",
3733 op[0], op[1]);
3734 printf (" bit = 0x%x\n", bit);
3735 }
3736 SYNTAX("and1 cy, %s1");
3737 #line 329 "rl78-decode.opc"
3738 ID(and); DCY(); SM(None, SFR); SB(bit);
3739
3740 }
3741 break;
3742 case 0x0e:
3743 case 0x1e:
3744 case 0x2e:
3745 case 0x3e:
3746 case 0x4e:
3747 case 0x5e:
3748 case 0x6e:
3749 case 0x7e:
3750 {
3751 /** 0111 0001 0bit 1110 or1 cy, %s1 */
3752 #line 984 "rl78-decode.opc"
3753 int bit AU = (op[1] >> 4) & 0x07;
3754 if (trace)
3755 {
3756 printf ("\033[33m%s\033[0m %02x %02x\n",
3757 "/** 0111 0001 0bit 1110 or1 cy, %s1 */",
3758 op[0], op[1]);
3759 printf (" bit = 0x%x\n", bit);
3760 }
3761 SYNTAX("or1 cy, %s1");
3762 #line 984 "rl78-decode.opc"
3763 ID(or); DCY(); SM(None, SFR); SB(bit);
3764
3765 }
3766 break;
3767 case 0x0f:
3768 case 0x1f:
3769 case 0x2f:
3770 case 0x3f:
3771 case 0x4f:
3772 case 0x5f:
3773 case 0x6f:
3774 case 0x7f:
3775 {
3776 /** 0111 0001 0bit 1111 xor1 cy, %s1 */
3777 #line 1288 "rl78-decode.opc"
3778 int bit AU = (op[1] >> 4) & 0x07;
3779 if (trace)
3780 {
3781 printf ("\033[33m%s\033[0m %02x %02x\n",
3782 "/** 0111 0001 0bit 1111 xor1 cy, %s1 */",
3783 op[0], op[1]);
3784 printf (" bit = 0x%x\n", bit);
3785 }
3786 SYNTAX("xor1 cy, %s1");
3787 #line 1288 "rl78-decode.opc"
3788 ID(xor); DCY(); SM(None, SFR); SB(bit);
3789
3790 }
3791 break;
3792 case 0x80:
3793 {
3794 /** 0111 0001 1000 0000 set1 cy */
3795 if (trace)
3796 {
3797 printf ("\033[33m%s\033[0m %02x %02x\n",
3798 "/** 0111 0001 1000 0000 set1 cy */",
3799 op[0], op[1]);
3800 }
3801 SYNTAX("set1 cy");
3802 #line 1061 "rl78-decode.opc"
3803 ID(mov); DCY(); SC(1);
3804
3805 }
3806 break;
3807 case 0x81:
3808 case 0x91:
3809 case 0xa1:
3810 case 0xb1:
3811 case 0xc1:
3812 case 0xd1:
3813 case 0xe1:
3814 case 0xf1:
3815 {
3816 /** 0111 0001 1bit 0001 mov1 %e0, cy */
3817 #line 791 "rl78-decode.opc"
3818 int bit AU = (op[1] >> 4) & 0x07;
3819 if (trace)
3820 {
3821 printf ("\033[33m%s\033[0m %02x %02x\n",
3822 "/** 0111 0001 1bit 0001 mov1 %e0, cy */",
3823 op[0], op[1]);
3824 printf (" bit = 0x%x\n", bit);
3825 }
3826 SYNTAX("mov1 %e0, cy");
3827 #line 791 "rl78-decode.opc"
3828 ID(mov); DM(HL, 0); DB(bit); SCY();
3829
3830 }
3831 break;
3832 case 0x82:
3833 case 0x92:
3834 case 0xa2:
3835 case 0xb2:
3836 case 0xc2:
3837 case 0xd2:
3838 case 0xe2:
3839 case 0xf2:
3840 {
3841 /** 0111 0001 1bit 0010 set1 %e0 */
3842 #line 1055 "rl78-decode.opc"
3843 int bit AU = (op[1] >> 4) & 0x07;
3844 if (trace)
3845 {
3846 printf ("\033[33m%s\033[0m %02x %02x\n",
3847 "/** 0111 0001 1bit 0010 set1 %e0 */",
3848 op[0], op[1]);
3849 printf (" bit = 0x%x\n", bit);
3850 }
3851 SYNTAX("set1 %e0");
3852 #line 1055 "rl78-decode.opc"
3853 ID(mov); DM(HL, 0); DB(bit); SC(1);
3854
3855 }
3856 break;
3857 case 0x83:
3858 case 0x93:
3859 case 0xa3:
3860 case 0xb3:
3861 case 0xc3:
3862 case 0xd3:
3863 case 0xe3:
3864 case 0xf3:
3865 {
3866 /** 0111 0001 1bit 0011 clr1 %e0 */
3867 #line 447 "rl78-decode.opc"
3868 int bit AU = (op[1] >> 4) & 0x07;
3869 if (trace)
3870 {
3871 printf ("\033[33m%s\033[0m %02x %02x\n",
3872 "/** 0111 0001 1bit 0011 clr1 %e0 */",
3873 op[0], op[1]);
3874 printf (" bit = 0x%x\n", bit);
3875 }
3876 SYNTAX("clr1 %e0");
3877 #line 447 "rl78-decode.opc"
3878 ID(mov); DM(HL, 0); DB(bit); SC(0);
3879
3880 }
3881 break;
3882 case 0x84:
3883 case 0x94:
3884 case 0xa4:
3885 case 0xb4:
3886 case 0xc4:
3887 case 0xd4:
3888 case 0xe4:
3889 case 0xf4:
3890 {
3891 /** 0111 0001 1bit 0100 mov1 cy, %e1 */
3892 #line 797 "rl78-decode.opc"
3893 int bit AU = (op[1] >> 4) & 0x07;
3894 if (trace)
3895 {
3896 printf ("\033[33m%s\033[0m %02x %02x\n",
3897 "/** 0111 0001 1bit 0100 mov1 cy, %e1 */",
3898 op[0], op[1]);
3899 printf (" bit = 0x%x\n", bit);
3900 }
3901 SYNTAX("mov1 cy, %e1");
3902 #line 797 "rl78-decode.opc"
3903 ID(mov); DCY(); SM(HL, 0); SB(bit);
3904
3905 }
3906 break;
3907 case 0x85:
3908 case 0x95:
3909 case 0xa5:
3910 case 0xb5:
3911 case 0xc5:
3912 case 0xd5:
3913 case 0xe5:
3914 case 0xf5:
3915 {
3916 /** 0111 0001 1bit 0101 and1 cy, %e1 */
3917 #line 323 "rl78-decode.opc"
3918 int bit AU = (op[1] >> 4) & 0x07;
3919 if (trace)
3920 {
3921 printf ("\033[33m%s\033[0m %02x %02x\n",
3922 "/** 0111 0001 1bit 0101 and1 cy, %e1 */",
3923 op[0], op[1]);
3924 printf (" bit = 0x%x\n", bit);
3925 }
3926 SYNTAX("and1 cy, %e1");
3927 #line 323 "rl78-decode.opc"
3928 ID(and); DCY(); SM(HL, 0); SB(bit);
3929
3930 }
3931 break;
3932 case 0x86:
3933 case 0x96:
3934 case 0xa6:
3935 case 0xb6:
3936 case 0xc6:
3937 case 0xd6:
3938 case 0xe6:
3939 case 0xf6:
3940 {
3941 /** 0111 0001 1bit 0110 or1 cy, %e1 */
3942 #line 978 "rl78-decode.opc"
3943 int bit AU = (op[1] >> 4) & 0x07;
3944 if (trace)
3945 {
3946 printf ("\033[33m%s\033[0m %02x %02x\n",
3947 "/** 0111 0001 1bit 0110 or1 cy, %e1 */",
3948 op[0], op[1]);
3949 printf (" bit = 0x%x\n", bit);
3950 }
3951 SYNTAX("or1 cy, %e1");
3952 #line 978 "rl78-decode.opc"
3953 ID(or); DCY(); SM(HL, 0); SB(bit);
3954
3955 }
3956 break;
3957 case 0x87:
3958 case 0x97:
3959 case 0xa7:
3960 case 0xb7:
3961 case 0xc7:
3962 case 0xd7:
3963 case 0xe7:
3964 case 0xf7:
3965 {
3966 /** 0111 0001 1bit 0111 xor1 cy, %e1 */
3967 #line 1282 "rl78-decode.opc"
3968 int bit AU = (op[1] >> 4) & 0x07;
3969 if (trace)
3970 {
3971 printf ("\033[33m%s\033[0m %02x %02x\n",
3972 "/** 0111 0001 1bit 0111 xor1 cy, %e1 */",
3973 op[0], op[1]);
3974 printf (" bit = 0x%x\n", bit);
3975 }
3976 SYNTAX("xor1 cy, %e1");
3977 #line 1282 "rl78-decode.opc"
3978 ID(xor); DCY(); SM(HL, 0); SB(bit);
3979
3980 }
3981 break;
3982 case 0x88:
3983 {
3984 /** 0111 0001 1000 1000 clr1 cy */
3985 if (trace)
3986 {
3987 printf ("\033[33m%s\033[0m %02x %02x\n",
3988 "/** 0111 0001 1000 1000 clr1 cy */",
3989 op[0], op[1]);
3990 }
3991 SYNTAX("clr1 cy");
3992 #line 453 "rl78-decode.opc"
3993 ID(mov); DCY(); SC(0);
3994
3995 }
3996 break;
3997 case 0x89:
3998 case 0x99:
3999 case 0xa9:
4000 case 0xb9:
4001 case 0xc9:
4002 case 0xd9:
4003 case 0xe9:
4004 case 0xf9:
4005 {
4006 /** 0111 0001 1bit 1001 mov1 %e0, cy */
4007 #line 794 "rl78-decode.opc"
4008 int bit AU = (op[1] >> 4) & 0x07;
4009 if (trace)
4010 {
4011 printf ("\033[33m%s\033[0m %02x %02x\n",
4012 "/** 0111 0001 1bit 1001 mov1 %e0, cy */",
4013 op[0], op[1]);
4014 printf (" bit = 0x%x\n", bit);
4015 }
4016 SYNTAX("mov1 %e0, cy");
4017 #line 794 "rl78-decode.opc"
4018 ID(mov); DR(A); DB(bit); SCY();
4019
4020 }
4021 break;
4022 case 0x8a:
4023 case 0x9a:
4024 case 0xaa:
4025 case 0xba:
4026 case 0xca:
4027 case 0xda:
4028 case 0xea:
4029 case 0xfa:
4030 {
4031 /** 0111 0001 1bit 1010 set1 %0 */
4032 #line 1058 "rl78-decode.opc"
4033 int bit AU = (op[1] >> 4) & 0x07;
4034 if (trace)
4035 {
4036 printf ("\033[33m%s\033[0m %02x %02x\n",
4037 "/** 0111 0001 1bit 1010 set1 %0 */",
4038 op[0], op[1]);
4039 printf (" bit = 0x%x\n", bit);
4040 }
4041 SYNTAX("set1 %0");
4042 #line 1058 "rl78-decode.opc"
4043 ID(mov); DR(A); DB(bit); SC(1);
4044
4045 }
4046 break;
4047 case 0x8b:
4048 case 0x9b:
4049 case 0xab:
4050 case 0xbb:
4051 case 0xcb:
4052 case 0xdb:
4053 case 0xeb:
4054 case 0xfb:
4055 {
4056 /** 0111 0001 1bit 1011 clr1 %0 */
4057 #line 450 "rl78-decode.opc"
4058 int bit AU = (op[1] >> 4) & 0x07;
4059 if (trace)
4060 {
4061 printf ("\033[33m%s\033[0m %02x %02x\n",
4062 "/** 0111 0001 1bit 1011 clr1 %0 */",
4063 op[0], op[1]);
4064 printf (" bit = 0x%x\n", bit);
4065 }
4066 SYNTAX("clr1 %0");
4067 #line 450 "rl78-decode.opc"
4068 ID(mov); DR(A); DB(bit); SC(0);
4069
4070 }
4071 break;
4072 case 0x8c:
4073 case 0x9c:
4074 case 0xac:
4075 case 0xbc:
4076 case 0xcc:
4077 case 0xdc:
4078 case 0xec:
4079 case 0xfc:
4080 {
4081 /** 0111 0001 1bit 1100 mov1 cy, %e1 */
4082 #line 800 "rl78-decode.opc"
4083 int bit AU = (op[1] >> 4) & 0x07;
4084 if (trace)
4085 {
4086 printf ("\033[33m%s\033[0m %02x %02x\n",
4087 "/** 0111 0001 1bit 1100 mov1 cy, %e1 */",
4088 op[0], op[1]);
4089 printf (" bit = 0x%x\n", bit);
4090 }
4091 SYNTAX("mov1 cy, %e1");
4092 #line 800 "rl78-decode.opc"
4093 ID(mov); DCY(); SR(A); SB(bit);
4094
4095 }
4096 break;
4097 case 0x8d:
4098 case 0x9d:
4099 case 0xad:
4100 case 0xbd:
4101 case 0xcd:
4102 case 0xdd:
4103 case 0xed:
4104 case 0xfd:
4105 {
4106 /** 0111 0001 1bit 1101 and1 cy, %1 */
4107 #line 326 "rl78-decode.opc"
4108 int bit AU = (op[1] >> 4) & 0x07;
4109 if (trace)
4110 {
4111 printf ("\033[33m%s\033[0m %02x %02x\n",
4112 "/** 0111 0001 1bit 1101 and1 cy, %1 */",
4113 op[0], op[1]);
4114 printf (" bit = 0x%x\n", bit);
4115 }
4116 SYNTAX("and1 cy, %1");
4117 #line 326 "rl78-decode.opc"
4118 ID(and); DCY(); SR(A); SB(bit);
4119
4120 }
4121 break;
4122 case 0x8e:
4123 case 0x9e:
4124 case 0xae:
4125 case 0xbe:
4126 case 0xce:
4127 case 0xde:
4128 case 0xee:
4129 case 0xfe:
4130 {
4131 /** 0111 0001 1bit 1110 or1 cy, %1 */
4132 #line 981 "rl78-decode.opc"
4133 int bit AU = (op[1] >> 4) & 0x07;
4134 if (trace)
4135 {
4136 printf ("\033[33m%s\033[0m %02x %02x\n",
4137 "/** 0111 0001 1bit 1110 or1 cy, %1 */",
4138 op[0], op[1]);
4139 printf (" bit = 0x%x\n", bit);
4140 }
4141 SYNTAX("or1 cy, %1");
4142 #line 981 "rl78-decode.opc"
4143 ID(or); DCY(); SR(A); SB(bit);
4144
4145 }
4146 break;
4147 case 0x8f:
4148 case 0x9f:
4149 case 0xaf:
4150 case 0xbf:
4151 case 0xcf:
4152 case 0xdf:
4153 case 0xef:
4154 case 0xff:
4155 {
4156 /** 0111 0001 1bit 1111 xor1 cy, %1 */
4157 #line 1285 "rl78-decode.opc"
4158 int bit AU = (op[1] >> 4) & 0x07;
4159 if (trace)
4160 {
4161 printf ("\033[33m%s\033[0m %02x %02x\n",
4162 "/** 0111 0001 1bit 1111 xor1 cy, %1 */",
4163 op[0], op[1]);
4164 printf (" bit = 0x%x\n", bit);
4165 }
4166 SYNTAX("xor1 cy, %1");
4167 #line 1285 "rl78-decode.opc"
4168 ID(xor); DCY(); SR(A); SB(bit);
4169
4170 }
4171 break;
4172 case 0xc0:
4173 {
4174 /** 0111 0001 1100 0000 not1 cy */
4175 if (trace)
4176 {
4177 printf ("\033[33m%s\033[0m %02x %02x\n",
4178 "/** 0111 0001 1100 0000 not1 cy */",
4179 op[0], op[1]);
4180 }
4181 SYNTAX("not1 cy");
4182 #line 922 "rl78-decode.opc"
4183 ID(xor); DCY(); SC(1);
4184
4185 /*----------------------------------------------------------------------*/
4186
4187 }
4188 break;
4189 default: UNSUPPORTED(); break;
4190 }
4191 break;
4192 case 0x78:
4193 {
4194 /** 0111 1000 movw %e0, %1 */
4195 if (trace)
4196 {
4197 printf ("\033[33m%s\033[0m %02x\n",
4198 "/** 0111 1000 movw %e0, %1 */",
4199 op[0]);
4200 }
4201 SYNTAX("movw %e0, %1");
4202 #line 883 "rl78-decode.opc"
4203 ID(mov); W(); DM(BC, IMMU(2)); SR(AX);
4204
4205 }
4206 break;
4207 case 0x79:
4208 {
4209 /** 0111 1001 movw %0, %e1 */
4210 if (trace)
4211 {
4212 printf ("\033[33m%s\033[0m %02x\n",
4213 "/** 0111 1001 movw %0, %e1 */",
4214 op[0]);
4215 }
4216 SYNTAX("movw %0, %e1");
4217 #line 874 "rl78-decode.opc"
4218 ID(mov); W(); DR(AX); SM(BC, IMMU(2));
4219
4220 }
4221 break;
4222 case 0x7a:
4223 {
4224 /** 0111 1010 xor %0, #%1 */
4225 if (trace)
4226 {
4227 printf ("\033[33m%s\033[0m %02x\n",
4228 "/** 0111 1010 xor %0, #%1 */",
4229 op[0]);
4230 }
4231 SYNTAX("xor %0, #%1");
4232 #line 1277 "rl78-decode.opc"
4233 ID(xor); DM(None, SADDR); SC(IMMU(1)); Fz;
4234
4235 /*----------------------------------------------------------------------*/
4236
4237 }
4238 break;
4239 case 0x7b:
4240 {
4241 /** 0111 1011 xor %0, %1 */
4242 if (trace)
4243 {
4244 printf ("\033[33m%s\033[0m %02x\n",
4245 "/** 0111 1011 xor %0, %1 */",
4246 op[0]);
4247 }
4248 SYNTAX("xor %0, %1");
4249 #line 1274 "rl78-decode.opc"
4250 ID(xor); DR(A); SM(None, SADDR); Fz;
4251
4252 }
4253 break;
4254 case 0x7c:
4255 {
4256 /** 0111 1100 xor %0, #%1 */
4257 if (trace)
4258 {
4259 printf ("\033[33m%s\033[0m %02x\n",
4260 "/** 0111 1100 xor %0, #%1 */",
4261 op[0]);
4262 }
4263 SYNTAX("xor %0, #%1");
4264 #line 1265 "rl78-decode.opc"
4265 ID(xor); DR(A); SC(IMMU(1)); Fz;
4266
4267 }
4268 break;
4269 case 0x7d:
4270 {
4271 /** 0111 1101 xor %0, %e1 */
4272 if (trace)
4273 {
4274 printf ("\033[33m%s\033[0m %02x\n",
4275 "/** 0111 1101 xor %0, %e1 */",
4276 op[0]);
4277 }
4278 SYNTAX("xor %0, %e1");
4279 #line 1253 "rl78-decode.opc"
4280 ID(xor); DR(A); SM(HL, 0); Fz;
4281
4282 }
4283 break;
4284 case 0x7e:
4285 {
4286 /** 0111 1110 xor %0, %ea1 */
4287 if (trace)
4288 {
4289 printf ("\033[33m%s\033[0m %02x\n",
4290 "/** 0111 1110 xor %0, %ea1 */",
4291 op[0]);
4292 }
4293 SYNTAX("xor %0, %ea1");
4294 #line 1259 "rl78-decode.opc"
4295 ID(xor); DR(A); SM(HL, IMMU(1)); Fz;
4296
4297 }
4298 break;
4299 case 0x7f:
4300 {
4301 /** 0111 1111 xor %0, %e!1 */
4302 if (trace)
4303 {
4304 printf ("\033[33m%s\033[0m %02x\n",
4305 "/** 0111 1111 xor %0, %e!1 */",
4306 op[0]);
4307 }
4308 SYNTAX("xor %0, %e!1");
4309 #line 1250 "rl78-decode.opc"
4310 ID(xor); DR(A); SM(None, IMMU(2)); Fz;
4311
4312 }
4313 break;
4314 case 0x80:
4315 case 0x81:
4316 case 0x82:
4317 case 0x83:
4318 case 0x84:
4319 case 0x85:
4320 case 0x86:
4321 case 0x87:
4322 {
4323 /** 1000 0reg inc %0 */
4324 #line 593 "rl78-decode.opc"
4325 int reg AU = op[0] & 0x07;
4326 if (trace)
4327 {
4328 printf ("\033[33m%s\033[0m %02x\n",
4329 "/** 1000 0reg inc %0 */",
4330 op[0]);
4331 printf (" reg = 0x%x\n", reg);
4332 }
4333 SYNTAX("inc %0");
4334 #line 593 "rl78-decode.opc"
4335 ID(add); DRB(reg); SC(1); Fza;
4336
4337 }
4338 break;
4339 case 0x88:
4340 {
4341 /** 1000 1000 mov %0, %ea1 */
4342 if (trace)
4343 {
4344 printf ("\033[33m%s\033[0m %02x\n",
4345 "/** 1000 1000 mov %0, %ea1 */",
4346 op[0]);
4347 }
4348 SYNTAX("mov %0, %ea1");
4349 #line 672 "rl78-decode.opc"
4350 ID(mov); DR(A); SM(SP, IMMU(1));
4351
4352 }
4353 break;
4354 case 0x89:
4355 {
4356 /** 1000 1001 mov %0, %e1 */
4357 if (trace)
4358 {
4359 printf ("\033[33m%s\033[0m %02x\n",
4360 "/** 1000 1001 mov %0, %e1 */",
4361 op[0]);
4362 }
4363 SYNTAX("mov %0, %e1");
4364 #line 654 "rl78-decode.opc"
4365 ID(mov); DR(A); SM(DE, 0);
4366
4367 }
4368 break;
4369 case 0x8a:
4370 {
4371 /** 1000 1010 mov %0, %ea1 */
4372 if (trace)
4373 {
4374 printf ("\033[33m%s\033[0m %02x\n",
4375 "/** 1000 1010 mov %0, %ea1 */",
4376 op[0]);
4377 }
4378 SYNTAX("mov %0, %ea1");
4379 #line 657 "rl78-decode.opc"
4380 ID(mov); DR(A); SM(DE, IMMU(1));
4381
4382 }
4383 break;
4384 case 0x8b:
4385 {
4386 /** 1000 1011 mov %0, %e1 */
4387 if (trace)
4388 {
4389 printf ("\033[33m%s\033[0m %02x\n",
4390 "/** 1000 1011 mov %0, %e1 */",
4391 op[0]);
4392 }
4393 SYNTAX("mov %0, %e1");
4394 #line 660 "rl78-decode.opc"
4395 ID(mov); DR(A); SM(HL, 0);
4396
4397 }
4398 break;
4399 case 0x8c:
4400 {
4401 /** 1000 1100 mov %0, %ea1 */
4402 if (trace)
4403 {
4404 printf ("\033[33m%s\033[0m %02x\n",
4405 "/** 1000 1100 mov %0, %ea1 */",
4406 op[0]);
4407 }
4408 SYNTAX("mov %0, %ea1");
4409 #line 663 "rl78-decode.opc"
4410 ID(mov); DR(A); SM(HL, IMMU(1));
4411
4412 }
4413 break;
4414 case 0x8d:
4415 {
4416 /** 1000 1101 mov %0, %1 */
4417 if (trace)
4418 {
4419 printf ("\033[33m%s\033[0m %02x\n",
4420 "/** 1000 1101 mov %0, %1 */",
4421 op[0]);
4422 }
4423 SYNTAX("mov %0, %1");
4424 #line 696 "rl78-decode.opc"
4425 ID(mov); DR(A); SM(None, SADDR);
4426
4427 }
4428 break;
4429 case 0x8e:
4430 {
4431 /** 1000 1110 mov %0, %s1 */
4432 if (trace)
4433 {
4434 printf ("\033[33m%s\033[0m %02x\n",
4435 "/** 1000 1110 mov %0, %s1 */",
4436 op[0]);
4437 }
4438 SYNTAX("mov %0, %s1");
4439 #line 693 "rl78-decode.opc"
4440 ID(mov); DR(A); SM(None, SFR);
4441
4442 }
4443 break;
4444 case 0x8f:
4445 {
4446 /** 1000 1111 mov %0, %e!1 */
4447 if (trace)
4448 {
4449 printf ("\033[33m%s\033[0m %02x\n",
4450 "/** 1000 1111 mov %0, %e!1 */",
4451 op[0]);
4452 }
4453 SYNTAX("mov %0, %e!1");
4454 #line 651 "rl78-decode.opc"
4455 ID(mov); DR(A); SM(None, IMMU(2));
4456
4457 }
4458 break;
4459 case 0x90:
4460 case 0x91:
4461 case 0x92:
4462 case 0x93:
4463 case 0x94:
4464 case 0x95:
4465 case 0x96:
4466 case 0x97:
4467 {
4468 /** 1001 0reg dec %0 */
4469 #line 560 "rl78-decode.opc"
4470 int reg AU = op[0] & 0x07;
4471 if (trace)
4472 {
4473 printf ("\033[33m%s\033[0m %02x\n",
4474 "/** 1001 0reg dec %0 */",
4475 op[0]);
4476 printf (" reg = 0x%x\n", reg);
4477 }
4478 SYNTAX("dec %0");
4479 #line 560 "rl78-decode.opc"
4480 ID(sub); DRB(reg); SC(1); Fza;
4481
4482 }
4483 break;
4484 case 0x98:
4485 {
4486 /** 1001 1000 mov %a0, %1 */
4487 if (trace)
4488 {
4489 printf ("\033[33m%s\033[0m %02x\n",
4490 "/** 1001 1000 mov %a0, %1 */",
4491 op[0]);
4492 }
4493 SYNTAX("mov %a0, %1");
4494 #line 648 "rl78-decode.opc"
4495 ID(mov); DM(SP, IMMU(1)); SR(A);
4496
4497 }
4498 break;
4499 case 0x99:
4500 {
4501 /** 1001 1001 mov %e0, %1 */
4502 if (trace)
4503 {
4504 printf ("\033[33m%s\033[0m %02x\n",
4505 "/** 1001 1001 mov %e0, %1 */",
4506 op[0]);
4507 }
4508 SYNTAX("mov %e0, %1");
4509 #line 621 "rl78-decode.opc"
4510 ID(mov); DM(DE, 0); SR(A);
4511
4512 }
4513 break;
4514 case 0x9a:
4515 {
4516 /** 1001 1010 mov %ea0, %1 */
4517 if (trace)
4518 {
4519 printf ("\033[33m%s\033[0m %02x\n",
4520 "/** 1001 1010 mov %ea0, %1 */",
4521 op[0]);
4522 }
4523 SYNTAX("mov %ea0, %1");
4524 #line 627 "rl78-decode.opc"
4525 ID(mov); DM(DE, IMMU(1)); SR(A);
4526
4527 }
4528 break;
4529 case 0x9b:
4530 {
4531 /** 1001 1011 mov %e0, %1 */
4532 if (trace)
4533 {
4534 printf ("\033[33m%s\033[0m %02x\n",
4535 "/** 1001 1011 mov %e0, %1 */",
4536 op[0]);
4537 }
4538 SYNTAX("mov %e0, %1");
4539 #line 630 "rl78-decode.opc"
4540 ID(mov); DM(HL, 0); SR(A);
4541
4542 }
4543 break;
4544 case 0x9c:
4545 {
4546 /** 1001 1100 mov %ea0, %1 */
4547 if (trace)
4548 {
4549 printf ("\033[33m%s\033[0m %02x\n",
4550 "/** 1001 1100 mov %ea0, %1 */",
4551 op[0]);
4552 }
4553 SYNTAX("mov %ea0, %1");
4554 #line 639 "rl78-decode.opc"
4555 ID(mov); DM(HL, IMMU(1)); SR(A);
4556
4557 }
4558 break;
4559 case 0x9d:
4560 {
4561 /** 1001 1101 mov %0, %1 */
4562 if (trace)
4563 {
4564 printf ("\033[33m%s\033[0m %02x\n",
4565 "/** 1001 1101 mov %0, %1 */",
4566 op[0]);
4567 }
4568 SYNTAX("mov %0, %1");
4569 #line 753 "rl78-decode.opc"
4570 ID(mov); DM(None, SADDR); SR(A);
4571
4572 }
4573 break;
4574 case 0x9e:
4575 {
4576 /** 1001 1110 mov %s0, %1 */
4577 if (trace)
4578 {
4579 printf ("\033[33m%s\033[0m %02x\n",
4580 "/** 1001 1110 mov %s0, %1 */",
4581 op[0]);
4582 }
4583 SYNTAX("mov %s0, %1");
4584 #line 786 "rl78-decode.opc"
4585 ID(mov); DM(None, SFR); SR(A);
4586
4587 /*----------------------------------------------------------------------*/
4588
4589 }
4590 break;
4591 case 0x9f:
4592 {
4593 /** 1001 1111 mov %e!0, %1 */
4594 if (trace)
4595 {
4596 printf ("\033[33m%s\033[0m %02x\n",
4597 "/** 1001 1111 mov %e!0, %1 */",
4598 op[0]);
4599 }
4600 SYNTAX("mov %e!0, %1");
4601 #line 618 "rl78-decode.opc"
4602 ID(mov); DM(None, IMMU(2)); SR(A);
4603
4604 }
4605 break;
4606 case 0xa0:
4607 {
4608 /** 1010 0000 inc %e!0 */
4609 if (trace)
4610 {
4611 printf ("\033[33m%s\033[0m %02x\n",
4612 "/** 1010 0000 inc %e!0 */",
4613 op[0]);
4614 }
4615 SYNTAX("inc %e!0");
4616 #line 587 "rl78-decode.opc"
4617 ID(add); DM(None, IMMU(2)); SC(1); Fza;
4618
4619 }
4620 break;
4621 case 0xa1:
4622 case 0xa3:
4623 case 0xa5:
4624 case 0xa7:
4625 {
4626 /** 1010 0rg1 incw %0 */
4627 #line 607 "rl78-decode.opc"
4628 int rg AU = (op[0] >> 1) & 0x03;
4629 if (trace)
4630 {
4631 printf ("\033[33m%s\033[0m %02x\n",
4632 "/** 1010 0rg1 incw %0 */",
4633 op[0]);
4634 printf (" rg = 0x%x\n", rg);
4635 }
4636 SYNTAX("incw %0");
4637 #line 607 "rl78-decode.opc"
4638 ID(add); W(); DRW(rg); SC(1);
4639
4640 }
4641 break;
4642 case 0xa2:
4643 {
4644 /** 1010 0010 incw %e!0 */
4645 if (trace)
4646 {
4647 printf ("\033[33m%s\033[0m %02x\n",
4648 "/** 1010 0010 incw %e!0 */",
4649 op[0]);
4650 }
4651 SYNTAX("incw %e!0");
4652 #line 601 "rl78-decode.opc"
4653 ID(add); W(); DM(None, IMMU(2)); SC(1);
4654
4655 }
4656 break;
4657 case 0xa4:
4658 {
4659 /** 1010 0100 inc %0 */
4660 if (trace)
4661 {
4662 printf ("\033[33m%s\033[0m %02x\n",
4663 "/** 1010 0100 inc %0 */",
4664 op[0]);
4665 }
4666 SYNTAX("inc %0");
4667 #line 596 "rl78-decode.opc"
4668 ID(add); DM(None, SADDR); SC(1); Fza;
4669
4670 /*----------------------------------------------------------------------*/
4671
4672 }
4673 break;
4674 case 0xa6:
4675 {
4676 /** 1010 0110 incw %0 */
4677 if (trace)
4678 {
4679 printf ("\033[33m%s\033[0m %02x\n",
4680 "/** 1010 0110 incw %0 */",
4681 op[0]);
4682 }
4683 SYNTAX("incw %0");
4684 #line 610 "rl78-decode.opc"
4685 ID(add); W(); DM(None, SADDR); SC(1);
4686
4687 /*----------------------------------------------------------------------*/
4688
4689 }
4690 break;
4691 case 0xa8:
4692 {
4693 /** 1010 1000 movw %0, %a1 */
4694 if (trace)
4695 {
4696 printf ("\033[33m%s\033[0m %02x\n",
4697 "/** 1010 1000 movw %0, %a1 */",
4698 op[0]);
4699 }
4700 SYNTAX("movw %0, %a1");
4701 #line 856 "rl78-decode.opc"
4702 ID(mov); W(); DR(AX); SM(SP, IMMU(1));
4703
4704 }
4705 break;
4706 case 0xa9:
4707 {
4708 /** 1010 1001 movw %0, %e1 */
4709 if (trace)
4710 {
4711 printf ("\033[33m%s\033[0m %02x\n",
4712 "/** 1010 1001 movw %0, %e1 */",
4713 op[0]);
4714 }
4715 SYNTAX("movw %0, %e1");
4716 #line 844 "rl78-decode.opc"
4717 ID(mov); W(); DR(AX); SM(DE, 0);
4718
4719 }
4720 break;
4721 case 0xaa:
4722 {
4723 /** 1010 1010 movw %0, %ea1 */
4724 if (trace)
4725 {
4726 printf ("\033[33m%s\033[0m %02x\n",
4727 "/** 1010 1010 movw %0, %ea1 */",
4728 op[0]);
4729 }
4730 SYNTAX("movw %0, %ea1");
4731 #line 847 "rl78-decode.opc"
4732 ID(mov); W(); DR(AX); SM(DE, IMMU(1));
4733
4734 }
4735 break;
4736 case 0xab:
4737 {
4738 /** 1010 1011 movw %0, %e1 */
4739 if (trace)
4740 {
4741 printf ("\033[33m%s\033[0m %02x\n",
4742 "/** 1010 1011 movw %0, %e1 */",
4743 op[0]);
4744 }
4745 SYNTAX("movw %0, %e1");
4746 #line 850 "rl78-decode.opc"
4747 ID(mov); W(); DR(AX); SM(HL, 0);
4748
4749 }
4750 break;
4751 case 0xac:
4752 {
4753 /** 1010 1100 movw %0, %ea1 */
4754 if (trace)
4755 {
4756 printf ("\033[33m%s\033[0m %02x\n",
4757 "/** 1010 1100 movw %0, %ea1 */",
4758 op[0]);
4759 }
4760 SYNTAX("movw %0, %ea1");
4761 #line 853 "rl78-decode.opc"
4762 ID(mov); W(); DR(AX); SM(HL, IMMU(1));
4763
4764 }
4765 break;
4766 case 0xad:
4767 {
4768 /** 1010 1101 movw %0, %1 */
4769 if (trace)
4770 {
4771 printf ("\033[33m%s\033[0m %02x\n",
4772 "/** 1010 1101 movw %0, %1 */",
4773 op[0]);
4774 }
4775 SYNTAX("movw %0, %1");
4776 #line 886 "rl78-decode.opc"
4777 ID(mov); W(); DR(AX); SM(None, SADDR);
4778
4779 }
4780 break;
4781 case 0xae:
4782 {
4783 /** 1010 1110 movw %0, %s1 */
4784 if (trace)
4785 {
4786 printf ("\033[33m%s\033[0m %02x\n",
4787 "/** 1010 1110 movw %0, %s1 */",
4788 op[0]);
4789 }
4790 SYNTAX("movw %0, %s1");
4791 #line 889 "rl78-decode.opc"
4792 ID(mov); W(); DR(AX); SM(None, SFR);
4793
4794 }
4795 break;
4796 case 0xaf:
4797 {
4798 /** 1010 1111 movw %0, %e!1 */
4799 if (trace)
4800 {
4801 printf ("\033[33m%s\033[0m %02x\n",
4802 "/** 1010 1111 movw %0, %e!1 */",
4803 op[0]);
4804 }
4805 SYNTAX("movw %0, %e!1");
4806 #line 840 "rl78-decode.opc"
4807 ID(mov); W(); DR(AX); SM(None, IMMU(2));
4808
4809
4810 }
4811 break;
4812 case 0xb0:
4813 {
4814 /** 1011 0000 dec %e!0 */
4815 if (trace)
4816 {
4817 printf ("\033[33m%s\033[0m %02x\n",
4818 "/** 1011 0000 dec %e!0 */",
4819 op[0]);
4820 }
4821 SYNTAX("dec %e!0");
4822 #line 554 "rl78-decode.opc"
4823 ID(sub); DM(None, IMMU(2)); SC(1); Fza;
4824
4825 }
4826 break;
4827 case 0xb1:
4828 case 0xb3:
4829 case 0xb5:
4830 case 0xb7:
4831 {
4832 /** 1011 0rg1 decw %0 */
4833 #line 574 "rl78-decode.opc"
4834 int rg AU = (op[0] >> 1) & 0x03;
4835 if (trace)
4836 {
4837 printf ("\033[33m%s\033[0m %02x\n",
4838 "/** 1011 0rg1 decw %0 */",
4839 op[0]);
4840 printf (" rg = 0x%x\n", rg);
4841 }
4842 SYNTAX("decw %0");
4843 #line 574 "rl78-decode.opc"
4844 ID(sub); W(); DRW(rg); SC(1);
4845
4846 }
4847 break;
4848 case 0xb2:
4849 {
4850 /** 1011 0010 decw %e!0 */
4851 if (trace)
4852 {
4853 printf ("\033[33m%s\033[0m %02x\n",
4854 "/** 1011 0010 decw %e!0 */",
4855 op[0]);
4856 }
4857 SYNTAX("decw %e!0");
4858 #line 568 "rl78-decode.opc"
4859 ID(sub); W(); DM(None, IMMU(2)); SC(1);
4860
4861 }
4862 break;
4863 case 0xb4:
4864 {
4865 /** 1011 0100 dec %0 */
4866 if (trace)
4867 {
4868 printf ("\033[33m%s\033[0m %02x\n",
4869 "/** 1011 0100 dec %0 */",
4870 op[0]);
4871 }
4872 SYNTAX("dec %0");
4873 #line 563 "rl78-decode.opc"
4874 ID(sub); DM(None, SADDR); SC(1); Fza;
4875
4876 /*----------------------------------------------------------------------*/
4877
4878 }
4879 break;
4880 case 0xb6:
4881 {
4882 /** 1011 0110 decw %0 */
4883 if (trace)
4884 {
4885 printf ("\033[33m%s\033[0m %02x\n",
4886 "/** 1011 0110 decw %0 */",
4887 op[0]);
4888 }
4889 SYNTAX("decw %0");
4890 #line 577 "rl78-decode.opc"
4891 ID(sub); W(); DM(None, SADDR); SC(1);
4892
4893 /*----------------------------------------------------------------------*/
4894
4895 }
4896 break;
4897 case 0xb8:
4898 {
4899 /** 1011 1000 movw %a0, %1 */
4900 if (trace)
4901 {
4902 printf ("\033[33m%s\033[0m %02x\n",
4903 "/** 1011 1000 movw %a0, %1 */",
4904 op[0]);
4905 }
4906 SYNTAX("movw %a0, %1");
4907 #line 837 "rl78-decode.opc"
4908 ID(mov); W(); DM(SP, IMMU(1)); SR(AX);
4909
4910 }
4911 break;
4912 case 0xb9:
4913 {
4914 /** 1011 1001 movw %e0, %1 */
4915 if (trace)
4916 {
4917 printf ("\033[33m%s\033[0m %02x\n",
4918 "/** 1011 1001 movw %e0, %1 */",
4919 op[0]);
4920 }
4921 SYNTAX("movw %e0, %1");
4922 #line 825 "rl78-decode.opc"
4923 ID(mov); W(); DM(DE, 0); SR(AX);
4924
4925 }
4926 break;
4927 case 0xba:
4928 {
4929 /** 1011 1010 movw %ea0, %1 */
4930 if (trace)
4931 {
4932 printf ("\033[33m%s\033[0m %02x\n",
4933 "/** 1011 1010 movw %ea0, %1 */",
4934 op[0]);
4935 }
4936 SYNTAX("movw %ea0, %1");
4937 #line 828 "rl78-decode.opc"
4938 ID(mov); W(); DM(DE, IMMU(1)); SR(AX);
4939
4940 }
4941 break;
4942 case 0xbb:
4943 {
4944 /** 1011 1011 movw %e0, %1 */
4945 if (trace)
4946 {
4947 printf ("\033[33m%s\033[0m %02x\n",
4948 "/** 1011 1011 movw %e0, %1 */",
4949 op[0]);
4950 }
4951 SYNTAX("movw %e0, %1");
4952 #line 831 "rl78-decode.opc"
4953 ID(mov); W(); DM(HL, 0); SR(AX);
4954
4955 }
4956 break;
4957 case 0xbc:
4958 {
4959 /** 1011 1100 movw %ea0, %1 */
4960 if (trace)
4961 {
4962 printf ("\033[33m%s\033[0m %02x\n",
4963 "/** 1011 1100 movw %ea0, %1 */",
4964 op[0]);
4965 }
4966 SYNTAX("movw %ea0, %1");
4967 #line 834 "rl78-decode.opc"
4968 ID(mov); W(); DM(HL, IMMU(1)); SR(AX);
4969
4970 }
4971 break;
4972 case 0xbd:
4973 {
4974 /** 1011 1101 movw %0, %1 */
4975 if (trace)
4976 {
4977 printf ("\033[33m%s\033[0m %02x\n",
4978 "/** 1011 1101 movw %0, %1 */",
4979 op[0]);
4980 }
4981 SYNTAX("movw %0, %1");
4982 #line 901 "rl78-decode.opc"
4983 ID(mov); W(); DM(None, SADDR); SR(AX);
4984
4985 }
4986 break;
4987 case 0xbe:
4988 {
4989 /** 1011 1110 movw %s0, %1 */
4990 if (trace)
4991 {
4992 printf ("\033[33m%s\033[0m %02x\n",
4993 "/** 1011 1110 movw %s0, %1 */",
4994 op[0]);
4995 }
4996 SYNTAX("movw %s0, %1");
4997 #line 907 "rl78-decode.opc"
4998 ID(mov); W(); DM(None, SFR); SR(AX);
4999
5000 /*----------------------------------------------------------------------*/
5001
5002 }
5003 break;
5004 case 0xbf:
5005 {
5006 /** 1011 1111 movw %e!0, %1 */
5007 if (trace)
5008 {
5009 printf ("\033[33m%s\033[0m %02x\n",
5010 "/** 1011 1111 movw %e!0, %1 */",
5011 op[0]);
5012 }
5013 SYNTAX("movw %e!0, %1");
5014 #line 822 "rl78-decode.opc"
5015 ID(mov); W(); DM(None, IMMU(2)); SR(AX);
5016
5017 }
5018 break;
5019 case 0xc0:
5020 case 0xc2:
5021 case 0xc4:
5022 case 0xc6:
5023 {
5024 /** 1100 0rg0 pop %0 */
5025 #line 992 "rl78-decode.opc"
5026 int rg AU = (op[0] >> 1) & 0x03;
5027 if (trace)
5028 {
5029 printf ("\033[33m%s\033[0m %02x\n",
5030 "/** 1100 0rg0 pop %0 */",
5031 op[0]);
5032 printf (" rg = 0x%x\n", rg);
5033 }
5034 SYNTAX("pop %0");
5035 #line 992 "rl78-decode.opc"
5036 ID(mov); W(); DRW(rg); SPOP();
5037
5038 }
5039 break;
5040 case 0xc1:
5041 case 0xc3:
5042 case 0xc5:
5043 case 0xc7:
5044 {
5045 /** 1100 0rg1 push %1 */
5046 #line 1000 "rl78-decode.opc"
5047 int rg AU = (op[0] >> 1) & 0x03;
5048 if (trace)
5049 {
5050 printf ("\033[33m%s\033[0m %02x\n",
5051 "/** 1100 0rg1 push %1 */",
5052 op[0]);
5053 printf (" rg = 0x%x\n", rg);
5054 }
5055 SYNTAX("push %1");
5056 #line 1000 "rl78-decode.opc"
5057 ID(mov); W(); DPUSH(); SRW(rg);
5058
5059 }
5060 break;
5061 case 0xc8:
5062 {
5063 /** 1100 1000 mov %a0, #%1 */
5064 if (trace)
5065 {
5066 printf ("\033[33m%s\033[0m %02x\n",
5067 "/** 1100 1000 mov %a0, #%1 */",
5068 op[0]);
5069 }
5070 SYNTAX("mov %a0, #%1");
5071 #line 645 "rl78-decode.opc"
5072 ID(mov); DM(SP, IMMU(1)); SC(IMMU(1));
5073
5074 }
5075 break;
5076 case 0xc9:
5077 {
5078 /** 1100 1001 movw %0, #%1 */
5079 if (trace)
5080 {
5081 printf ("\033[33m%s\033[0m %02x\n",
5082 "/** 1100 1001 movw %0, #%1 */",
5083 op[0]);
5084 }
5085 SYNTAX("movw %0, #%1");
5086 #line 898 "rl78-decode.opc"
5087 ID(mov); W(); DM(None, SADDR); SC(IMMU(2));
5088
5089 }
5090 break;
5091 case 0xca:
5092 {
5093 /** 1100 1010 mov %ea0, #%1 */
5094 if (trace)
5095 {
5096 printf ("\033[33m%s\033[0m %02x\n",
5097 "/** 1100 1010 mov %ea0, #%1 */",
5098 op[0]);
5099 }
5100 SYNTAX("mov %ea0, #%1");
5101 #line 624 "rl78-decode.opc"
5102 ID(mov); DM(DE, IMMU(1)); SC(IMMU(1));
5103
5104 }
5105 break;
5106 case 0xcb:
5107 {
5108 /** 1100 1011 movw %s0, #%1 */
5109 if (trace)
5110 {
5111 printf ("\033[33m%s\033[0m %02x\n",
5112 "/** 1100 1011 movw %s0, #%1 */",
5113 op[0]);
5114 }
5115 SYNTAX("movw %s0, #%1");
5116 #line 904 "rl78-decode.opc"
5117 ID(mov); W(); DM(None, SFR); SC(IMMU(2));
5118
5119 }
5120 break;
5121 case 0xcc:
5122 {
5123 /** 1100 1100 mov %ea0, #%1 */
5124 if (trace)
5125 {
5126 printf ("\033[33m%s\033[0m %02x\n",
5127 "/** 1100 1100 mov %ea0, #%1 */",
5128 op[0]);
5129 }
5130 SYNTAX("mov %ea0, #%1");
5131 #line 636 "rl78-decode.opc"
5132 ID(mov); DM(HL, IMMU(1)); SC(IMMU(1));
5133
5134 }
5135 break;
5136 case 0xcd:
5137 {
5138 /** 1100 1101 mov %0, #%1 */
5139 if (trace)
5140 {
5141 printf ("\033[33m%s\033[0m %02x\n",
5142 "/** 1100 1101 mov %0, #%1 */",
5143 op[0]);
5144 }
5145 SYNTAX("mov %0, #%1");
5146 #line 750 "rl78-decode.opc"
5147 ID(mov); DM(None, SADDR); SC(IMMU(1));
5148
5149 }
5150 break;
5151 case 0xce:
5152 {
5153 /** 1100 1110 mov %s0, #%1 */
5154 if (trace)
5155 {
5156 printf ("\033[33m%s\033[0m %02x\n",
5157 "/** 1100 1110 mov %s0, #%1 */",
5158 op[0]);
5159 }
5160 SYNTAX("mov %s0, #%1");
5161 #line 756 "rl78-decode.opc"
5162 op0 = SFR;
5163 op1 = IMMU(1);
5164 ID(mov); DM(None, op0); SC(op1);
5165 if (op0 == 0xffffb && isa == RL78_ISA_G14)
5166 switch (op1)
5167 {
5168 case 0x01:
5169 rl78->syntax = "mulhu"; ID(mulhu);
5170 break;
5171 case 0x02:
5172 rl78->syntax = "mulh"; ID(mulh);
5173 break;
5174 case 0x03:
5175 rl78->syntax = "divhu"; ID(divhu);
5176 break;
5177 case 0x04:
5178 rl78->syntax = "divwu <old-encoding>"; ID(divwu);
5179 break;
5180 case 0x05:
5181 rl78->syntax = "machu"; ID(machu);
5182 break;
5183 case 0x06:
5184 rl78->syntax = "mach"; ID(mach);
5185 break;
5186 case 0x0b:
5187 rl78->syntax = "divwu"; ID(divwu);
5188 break;
5189 }
5190
5191 }
5192 break;
5193 case 0xcf:
5194 {
5195 /** 1100 1111 mov %e!0, #%1 */
5196 if (trace)
5197 {
5198 printf ("\033[33m%s\033[0m %02x\n",
5199 "/** 1100 1111 mov %e!0, #%1 */",
5200 op[0]);
5201 }
5202 SYNTAX("mov %e!0, #%1");
5203 #line 615 "rl78-decode.opc"
5204 ID(mov); DM(None, IMMU(2)); SC(IMMU(1));
5205
5206 }
5207 break;
5208 case 0xd0:
5209 case 0xd1:
5210 case 0xd2:
5211 case 0xd3:
5212 {
5213 /** 1101 00rg cmp0 %0 */
5214 #line 524 "rl78-decode.opc"
5215 int rg AU = op[0] & 0x03;
5216 if (trace)
5217 {
5218 printf ("\033[33m%s\033[0m %02x\n",
5219 "/** 1101 00rg cmp0 %0 */",
5220 op[0]);
5221 printf (" rg = 0x%x\n", rg);
5222 }
5223 SYNTAX("cmp0 %0");
5224 #line 524 "rl78-decode.opc"
5225 ID(cmp); DRB(rg); SC(0); Fzac;
5226
5227 }
5228 break;
5229 case 0xd4:
5230 {
5231 /** 1101 0100 cmp0 %0 */
5232 if (trace)
5233 {
5234 printf ("\033[33m%s\033[0m %02x\n",
5235 "/** 1101 0100 cmp0 %0 */",
5236 op[0]);
5237 }
5238 SYNTAX("cmp0 %0");
5239 #line 527 "rl78-decode.opc"
5240 ID(cmp); DM(None, SADDR); SC(0); Fzac;
5241
5242 /*----------------------------------------------------------------------*/
5243
5244 }
5245 break;
5246 case 0xd5:
5247 {
5248 /** 1101 0101 cmp0 %e!0 */
5249 if (trace)
5250 {
5251 printf ("\033[33m%s\033[0m %02x\n",
5252 "/** 1101 0101 cmp0 %e!0 */",
5253 op[0]);
5254 }
5255 SYNTAX("cmp0 %e!0");
5256 #line 521 "rl78-decode.opc"
5257 ID(cmp); DM(None, IMMU(2)); SC(0); Fzac;
5258
5259 }
5260 break;
5261 case 0xd6:
5262 {
5263 /** 1101 0110 mulu x */
5264 if (trace)
5265 {
5266 printf ("\033[33m%s\033[0m %02x\n",
5267 "/** 1101 0110 mulu x */",
5268 op[0]);
5269 }
5270 SYNTAX("mulu x");
5271 #line 912 "rl78-decode.opc"
5272 ID(mulu);
5273
5274 /*----------------------------------------------------------------------*/
5275
5276 }
5277 break;
5278 case 0xd7:
5279 {
5280 /** 1101 0111 ret */
5281 if (trace)
5282 {
5283 printf ("\033[33m%s\033[0m %02x\n",
5284 "/** 1101 0111 ret */",
5285 op[0]);
5286 }
5287 SYNTAX("ret");
5288 #line 1008 "rl78-decode.opc"
5289 ID(ret);
5290
5291 }
5292 break;
5293 case 0xd8:
5294 {
5295 /** 1101 1000 mov %0, %1 */
5296 if (trace)
5297 {
5298 printf ("\033[33m%s\033[0m %02x\n",
5299 "/** 1101 1000 mov %0, %1 */",
5300 op[0]);
5301 }
5302 SYNTAX("mov %0, %1");
5303 #line 717 "rl78-decode.opc"
5304 ID(mov); DR(X); SM(None, SADDR);
5305
5306 }
5307 break;
5308 case 0xd9:
5309 {
5310 /** 1101 1001 mov %0, %e!1 */
5311 if (trace)
5312 {
5313 printf ("\033[33m%s\033[0m %02x\n",
5314 "/** 1101 1001 mov %0, %e!1 */",
5315 op[0]);
5316 }
5317 SYNTAX("mov %0, %e!1");
5318 #line 714 "rl78-decode.opc"
5319 ID(mov); DR(X); SM(None, IMMU(2));
5320
5321 }
5322 break;
5323 case 0xda:
5324 case 0xea:
5325 case 0xfa:
5326 {
5327 /** 11ra 1010 movw %0, %1 */
5328 #line 895 "rl78-decode.opc"
5329 int ra AU = (op[0] >> 4) & 0x03;
5330 if (trace)
5331 {
5332 printf ("\033[33m%s\033[0m %02x\n",
5333 "/** 11ra 1010 movw %0, %1 */",
5334 op[0]);
5335 printf (" ra = 0x%x\n", ra);
5336 }
5337 SYNTAX("movw %0, %1");
5338 #line 895 "rl78-decode.opc"
5339 ID(mov); W(); DRW(ra); SM(None, SADDR);
5340
5341 }
5342 break;
5343 case 0xdb:
5344 case 0xeb:
5345 case 0xfb:
5346 {
5347 /** 11ra 1011 movw %0, %es!1 */
5348 #line 892 "rl78-decode.opc"
5349 int ra AU = (op[0] >> 4) & 0x03;
5350 if (trace)
5351 {
5352 printf ("\033[33m%s\033[0m %02x\n",
5353 "/** 11ra 1011 movw %0, %es!1 */",
5354 op[0]);
5355 printf (" ra = 0x%x\n", ra);
5356 }
5357 SYNTAX("movw %0, %es!1");
5358 #line 892 "rl78-decode.opc"
5359 ID(mov); W(); DRW(ra); SM(None, IMMU(2));
5360
5361 }
5362 break;
5363 case 0xdc:
5364 {
5365 /** 1101 1100 bc $%a0 */
5366 if (trace)
5367 {
5368 printf ("\033[33m%s\033[0m %02x\n",
5369 "/** 1101 1100 bc $%a0 */",
5370 op[0]);
5371 }
5372 SYNTAX("bc $%a0");
5373 #line 340 "rl78-decode.opc"
5374 ID(branch_cond); DC(pc+IMMS(1)+2); SR(None); COND(C);
5375
5376 }
5377 break;
5378 case 0xdd:
5379 {
5380 /** 1101 1101 bz $%a0 */
5381 if (trace)
5382 {
5383 printf ("\033[33m%s\033[0m %02x\n",
5384 "/** 1101 1101 bz $%a0 */",
5385 op[0]);
5386 }
5387 SYNTAX("bz $%a0");
5388 #line 352 "rl78-decode.opc"
5389 ID(branch_cond); DC(pc+IMMS(1)+2); SR(None); COND(Z);
5390
5391 }
5392 break;
5393 case 0xde:
5394 {
5395 /** 1101 1110 bnc $%a0 */
5396 if (trace)
5397 {
5398 printf ("\033[33m%s\033[0m %02x\n",
5399 "/** 1101 1110 bnc $%a0 */",
5400 op[0]);
5401 }
5402 SYNTAX("bnc $%a0");
5403 #line 343 "rl78-decode.opc"
5404 ID(branch_cond); DC(pc+IMMS(1)+2); SR(None); COND(NC);
5405
5406 }
5407 break;
5408 case 0xdf:
5409 {
5410 /** 1101 1111 bnz $%a0 */
5411 if (trace)
5412 {
5413 printf ("\033[33m%s\033[0m %02x\n",
5414 "/** 1101 1111 bnz $%a0 */",
5415 op[0]);
5416 }
5417 SYNTAX("bnz $%a0");
5418 #line 355 "rl78-decode.opc"
5419 ID(branch_cond); DC(pc+IMMS(1)+2); SR(None); COND(NZ);
5420
5421 /*----------------------------------------------------------------------*/
5422
5423 }
5424 break;
5425 case 0xe0:
5426 case 0xe1:
5427 case 0xe2:
5428 case 0xe3:
5429 {
5430 /** 1110 00rg oneb %0 */
5431 #line 930 "rl78-decode.opc"
5432 int rg AU = op[0] & 0x03;
5433 if (trace)
5434 {
5435 printf ("\033[33m%s\033[0m %02x\n",
5436 "/** 1110 00rg oneb %0 */",
5437 op[0]);
5438 printf (" rg = 0x%x\n", rg);
5439 }
5440 SYNTAX("oneb %0");
5441 #line 930 "rl78-decode.opc"
5442 ID(mov); DRB(rg); SC(1);
5443
5444 }
5445 break;
5446 case 0xe4:
5447 {
5448 /** 1110 0100 oneb %0 */
5449 if (trace)
5450 {
5451 printf ("\033[33m%s\033[0m %02x\n",
5452 "/** 1110 0100 oneb %0 */",
5453 op[0]);
5454 }
5455 SYNTAX("oneb %0");
5456 #line 933 "rl78-decode.opc"
5457 ID(mov); DM(None, SADDR); SC(1);
5458
5459 /*----------------------------------------------------------------------*/
5460
5461 }
5462 break;
5463 case 0xe5:
5464 {
5465 /** 1110 0101 oneb %e!0 */
5466 if (trace)
5467 {
5468 printf ("\033[33m%s\033[0m %02x\n",
5469 "/** 1110 0101 oneb %e!0 */",
5470 op[0]);
5471 }
5472 SYNTAX("oneb %e!0");
5473 #line 927 "rl78-decode.opc"
5474 ID(mov); DM(None, IMMU(2)); SC(1);
5475
5476 }
5477 break;
5478 case 0xe6:
5479 {
5480 /** 1110 0110 onew %0 */
5481 if (trace)
5482 {
5483 printf ("\033[33m%s\033[0m %02x\n",
5484 "/** 1110 0110 onew %0 */",
5485 op[0]);
5486 }
5487 SYNTAX("onew %0");
5488 #line 938 "rl78-decode.opc"
5489 ID(mov); DR(AX); SC(1);
5490
5491 }
5492 break;
5493 case 0xe7:
5494 {
5495 /** 1110 0111 onew %0 */
5496 if (trace)
5497 {
5498 printf ("\033[33m%s\033[0m %02x\n",
5499 "/** 1110 0111 onew %0 */",
5500 op[0]);
5501 }
5502 SYNTAX("onew %0");
5503 #line 941 "rl78-decode.opc"
5504 ID(mov); DR(BC); SC(1);
5505
5506 /*----------------------------------------------------------------------*/
5507
5508 }
5509 break;
5510 case 0xe8:
5511 {
5512 /** 1110 1000 mov %0, %1 */
5513 if (trace)
5514 {
5515 printf ("\033[33m%s\033[0m %02x\n",
5516 "/** 1110 1000 mov %0, %1 */",
5517 op[0]);
5518 }
5519 SYNTAX("mov %0, %1");
5520 #line 705 "rl78-decode.opc"
5521 ID(mov); DR(B); SM(None, SADDR);
5522
5523 }
5524 break;
5525 case 0xe9:
5526 {
5527 /** 1110 1001 mov %0, %e!1 */
5528 if (trace)
5529 {
5530 printf ("\033[33m%s\033[0m %02x\n",
5531 "/** 1110 1001 mov %0, %e!1 */",
5532 op[0]);
5533 }
5534 SYNTAX("mov %0, %e!1");
5535 #line 699 "rl78-decode.opc"
5536 ID(mov); DR(B); SM(None, IMMU(2));
5537
5538 }
5539 break;
5540 case 0xec:
5541 {
5542 /** 1110 1100 br !%!a0 */
5543 if (trace)
5544 {
5545 printf ("\033[33m%s\033[0m %02x\n",
5546 "/** 1110 1100 br !%!a0 */",
5547 op[0]);
5548 }
5549 SYNTAX("br !%!a0");
5550 #line 374 "rl78-decode.opc"
5551 ID(branch); DC(IMMU(3));
5552
5553 }
5554 break;
5555 case 0xed:
5556 {
5557 /** 1110 1101 br %!a0 */
5558 if (trace)
5559 {
5560 printf ("\033[33m%s\033[0m %02x\n",
5561 "/** 1110 1101 br %!a0 */",
5562 op[0]);
5563 }
5564 SYNTAX("br %!a0");
5565 #line 377 "rl78-decode.opc"
5566 ID(branch); DC(IMMU(2));
5567
5568 }
5569 break;
5570 case 0xee:
5571 {
5572 /** 1110 1110 br $%!a0 */
5573 if (trace)
5574 {
5575 printf ("\033[33m%s\033[0m %02x\n",
5576 "/** 1110 1110 br $%!a0 */",
5577 op[0]);
5578 }
5579 SYNTAX("br $%!a0");
5580 #line 380 "rl78-decode.opc"
5581 ID(branch); DC(pc+IMMS(2)+3);
5582
5583 }
5584 break;
5585 case 0xef:
5586 {
5587 /** 1110 1111 br $%a0 */
5588 if (trace)
5589 {
5590 printf ("\033[33m%s\033[0m %02x\n",
5591 "/** 1110 1111 br $%a0 */",
5592 op[0]);
5593 }
5594 SYNTAX("br $%a0");
5595 #line 383 "rl78-decode.opc"
5596 ID(branch); DC(pc+IMMS(1)+2);
5597
5598 }
5599 break;
5600 case 0xf0:
5601 case 0xf1:
5602 case 0xf2:
5603 case 0xf3:
5604 {
5605 /** 1111 00rg clrb %0 */
5606 #line 470 "rl78-decode.opc"
5607 int rg AU = op[0] & 0x03;
5608 if (trace)
5609 {
5610 printf ("\033[33m%s\033[0m %02x\n",
5611 "/** 1111 00rg clrb %0 */",
5612 op[0]);
5613 printf (" rg = 0x%x\n", rg);
5614 }
5615 SYNTAX("clrb %0");
5616 #line 470 "rl78-decode.opc"
5617 ID(mov); DRB(rg); SC(0);
5618
5619 }
5620 break;
5621 case 0xf4:
5622 {
5623 /** 1111 0100 clrb %0 */
5624 if (trace)
5625 {
5626 printf ("\033[33m%s\033[0m %02x\n",
5627 "/** 1111 0100 clrb %0 */",
5628 op[0]);
5629 }
5630 SYNTAX("clrb %0");
5631 #line 473 "rl78-decode.opc"
5632 ID(mov); DM(None, SADDR); SC(0);
5633
5634 /*----------------------------------------------------------------------*/
5635
5636 }
5637 break;
5638 case 0xf5:
5639 {
5640 /** 1111 0101 clrb %e!0 */
5641 if (trace)
5642 {
5643 printf ("\033[33m%s\033[0m %02x\n",
5644 "/** 1111 0101 clrb %e!0 */",
5645 op[0]);
5646 }
5647 SYNTAX("clrb %e!0");
5648 #line 467 "rl78-decode.opc"
5649 ID(mov); DM(None, IMMU(2)); SC(0);
5650
5651 }
5652 break;
5653 case 0xf6:
5654 {
5655 /** 1111 0110 clrw %0 */
5656 if (trace)
5657 {
5658 printf ("\033[33m%s\033[0m %02x\n",
5659 "/** 1111 0110 clrw %0 */",
5660 op[0]);
5661 }
5662 SYNTAX("clrw %0");
5663 #line 478 "rl78-decode.opc"
5664 ID(mov); DR(AX); SC(0);
5665
5666 }
5667 break;
5668 case 0xf7:
5669 {
5670 /** 1111 0111 clrw %0 */
5671 if (trace)
5672 {
5673 printf ("\033[33m%s\033[0m %02x\n",
5674 "/** 1111 0111 clrw %0 */",
5675 op[0]);
5676 }
5677 SYNTAX("clrw %0");
5678 #line 481 "rl78-decode.opc"
5679 ID(mov); DR(BC); SC(0);
5680
5681 /*----------------------------------------------------------------------*/
5682
5683 }
5684 break;
5685 case 0xf8:
5686 {
5687 /** 1111 1000 mov %0, %1 */
5688 if (trace)
5689 {
5690 printf ("\033[33m%s\033[0m %02x\n",
5691 "/** 1111 1000 mov %0, %1 */",
5692 op[0]);
5693 }
5694 SYNTAX("mov %0, %1");
5695 #line 711 "rl78-decode.opc"
5696 ID(mov); DR(C); SM(None, SADDR);
5697
5698 }
5699 break;
5700 case 0xf9:
5701 {
5702 /** 1111 1001 mov %0, %e!1 */
5703 if (trace)
5704 {
5705 printf ("\033[33m%s\033[0m %02x\n",
5706 "/** 1111 1001 mov %0, %e!1 */",
5707 op[0]);
5708 }
5709 SYNTAX("mov %0, %e!1");
5710 #line 708 "rl78-decode.opc"
5711 ID(mov); DR(C); SM(None, IMMU(2));
5712
5713 }
5714 break;
5715 case 0xfc:
5716 {
5717 /** 1111 1100 call !%!a0 */
5718 if (trace)
5719 {
5720 printf ("\033[33m%s\033[0m %02x\n",
5721 "/** 1111 1100 call !%!a0 */",
5722 op[0]);
5723 }
5724 SYNTAX("call !%!a0");
5725 #line 427 "rl78-decode.opc"
5726 ID(call); DC(IMMU(3));
5727
5728 }
5729 break;
5730 case 0xfd:
5731 {
5732 /** 1111 1101 call %!a0 */
5733 if (trace)
5734 {
5735 printf ("\033[33m%s\033[0m %02x\n",
5736 "/** 1111 1101 call %!a0 */",
5737 op[0]);
5738 }
5739 SYNTAX("call %!a0");
5740 #line 430 "rl78-decode.opc"
5741 ID(call); DC(IMMU(2));
5742
5743 }
5744 break;
5745 case 0xfe:
5746 {
5747 /** 1111 1110 call $%!a0 */
5748 if (trace)
5749 {
5750 printf ("\033[33m%s\033[0m %02x\n",
5751 "/** 1111 1110 call $%!a0 */",
5752 op[0]);
5753 }
5754 SYNTAX("call $%!a0");
5755 #line 433 "rl78-decode.opc"
5756 ID(call); DC(pc+IMMS(2)+3);
5757
5758 }
5759 break;
5760 case 0xff:
5761 {
5762 /** 1111 1111 brk1 */
5763 if (trace)
5764 {
5765 printf ("\033[33m%s\033[0m %02x\n",
5766 "/** 1111 1111 brk1 */",
5767 op[0]);
5768 }
5769 SYNTAX("brk1");
5770 #line 391 "rl78-decode.opc"
5771 ID(break);
5772
5773 }
5774 break;
5775 }
5776 #line 1296 "rl78-decode.opc"
5777
5778 return rl78->n_bytes;
5779 }
The GNU Binutils are a collection of binary tools.