Coverage Report

Created: 2024-05-21 06:29

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