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