opcodes/rl78-decode.c

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