opcodes/rl78-decode.c

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