OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [opcodes/] [rl78-decode.c] - Diff between revs 163 and 166

Show entire file | Details | Blame | View Log

Rev 163 Rev 166
Line 261... Line 261...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0000 1000                     xch     a, x                            */",
                     "/** 0000 1000                     xch     a, x                            */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("xch   a, x");
          SYNTAX("xch   a, x");
#line 1205 "rl78-decode.opc"
#line 1210 "rl78-decode.opc"
          ID(xch); DR(A); SR(X);
          ID(xch); DR(A); SR(X);
 
 
        /*----------------------------------------------------------------------*/
        /*----------------------------------------------------------------------*/
 
 
        }
        }
Line 584... Line 584...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0010 0000                     subw    %0, #%1                         */",
                     "/** 0010 0000                     subw    %0, #%1                         */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("subw  %0, #%1");
          SYNTAX("subw  %0, #%1");
#line 1169 "rl78-decode.opc"
#line 1174 "rl78-decode.opc"
          ID(sub); W(); DR(SP); SC(IMMU(1)); Fzac;
          ID(sub); W(); DR(SP); SC(IMMU(1)); Fzac;
 
 
        /*----------------------------------------------------------------------*/
        /*----------------------------------------------------------------------*/
 
 
        }
        }
Line 597... Line 597...
    case 0x23:
    case 0x23:
    case 0x25:
    case 0x25:
    case 0x27:
    case 0x27:
        {
        {
          /** 0010 0rw1                 subw    %0, %1                          */
          /** 0010 0rw1                 subw    %0, %1                          */
#line 1163 "rl78-decode.opc"
#line 1168 "rl78-decode.opc"
          int rw AU = (op[0] >> 1) & 0x03;
          int rw AU = (op[0] >> 1) & 0x03;
          if (trace)
          if (trace)
            {
            {
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0010 0rw1                     subw    %0, %1                          */",
                     "/** 0010 0rw1                     subw    %0, %1                          */",
                     op[0]);
                     op[0]);
              printf ("  rw = 0x%x\n", rw);
              printf ("  rw = 0x%x\n", rw);
            }
            }
          SYNTAX("subw  %0, %1");
          SYNTAX("subw  %0, %1");
#line 1163 "rl78-decode.opc"
#line 1168 "rl78-decode.opc"
          ID(sub); W(); DR(AX); SRW(rw); Fzac;
          ID(sub); W(); DR(AX); SRW(rw); Fzac;
 
 
        }
        }
      break;
      break;
    case 0x22:
    case 0x22:
Line 622... Line 622...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0010 0010                     subw    %0, %e1%!1                      */",
                     "/** 0010 0010                     subw    %0, %e1%!1                      */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("subw  %0, %e1%!1");
          SYNTAX("subw  %0, %e1%!1");
#line 1154 "rl78-decode.opc"
#line 1159 "rl78-decode.opc"
          ID(sub); W(); DR(AX); SM(None, IMMU(2)); Fzac;
          ID(sub); W(); DR(AX); SM(None, IMMU(2)); Fzac;
 
 
        }
        }
      break;
      break;
    case 0x24:
    case 0x24:
Line 637... Line 637...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0010 0100                     subw    %0, #%1                         */",
                     "/** 0010 0100                     subw    %0, #%1                         */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("subw  %0, #%1");
          SYNTAX("subw  %0, #%1");
#line 1160 "rl78-decode.opc"
#line 1165 "rl78-decode.opc"
          ID(sub); W(); DR(AX); SC(IMMU(2)); Fzac;
          ID(sub); W(); DR(AX); SC(IMMU(2)); Fzac;
 
 
        }
        }
      break;
      break;
    case 0x26:
    case 0x26:
Line 652... Line 652...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0010 0110                     subw    %0, %1                          */",
                     "/** 0010 0110                     subw    %0, %1                          */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("subw  %0, %1");
          SYNTAX("subw  %0, %1");
#line 1166 "rl78-decode.opc"
#line 1171 "rl78-decode.opc"
          ID(sub); W(); DR(AX); SM(None, SADDR); Fzac;
          ID(sub); W(); DR(AX); SM(None, SADDR); Fzac;
 
 
        }
        }
      break;
      break;
    case 0x28:
    case 0x28:
Line 697... Line 697...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0010 1010                     sub     %0, #%1                         */",
                     "/** 0010 1010                     sub     %0, #%1                         */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("sub   %0, #%1");
          SYNTAX("sub   %0, #%1");
#line 1117 "rl78-decode.opc"
#line 1122 "rl78-decode.opc"
          ID(sub); DM(None, SADDR); SC(IMMU(1)); Fzac;
          ID(sub); DM(None, SADDR); SC(IMMU(1)); Fzac;
 
 
        /*----------------------------------------------------------------------*/
        /*----------------------------------------------------------------------*/
 
 
        }
        }
Line 714... Line 714...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0010 1011                     sub     %0, %1                          */",
                     "/** 0010 1011                     sub     %0, %1                          */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("sub   %0, %1");
          SYNTAX("sub   %0, %1");
#line 1111 "rl78-decode.opc"
#line 1116 "rl78-decode.opc"
          ID(sub); DR(A); SM(None, SADDR); Fzac;
          ID(sub); DR(A); SM(None, SADDR); Fzac;
 
 
        }
        }
      break;
      break;
    case 0x2c:
    case 0x2c:
Line 729... Line 729...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0010 1100                     sub     %0, #%1                         */",
                     "/** 0010 1100                     sub     %0, #%1                         */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("sub   %0, #%1");
          SYNTAX("sub   %0, #%1");
#line 1105 "rl78-decode.opc"
#line 1110 "rl78-decode.opc"
          ID(sub); DR(A); SC(IMMU(1)); Fzac;
          ID(sub); DR(A); SC(IMMU(1)); Fzac;
 
 
        }
        }
      break;
      break;
    case 0x2d:
    case 0x2d:
Line 744... Line 744...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0010 1101                     sub     %0, %e1%1                       */",
                     "/** 0010 1101                     sub     %0, %e1%1                       */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("sub   %0, %e1%1");
          SYNTAX("sub   %0, %e1%1");
#line 1093 "rl78-decode.opc"
#line 1098 "rl78-decode.opc"
          ID(sub); DR(A); SM(HL, 0); Fzac;
          ID(sub); DR(A); SM(HL, 0); Fzac;
 
 
        }
        }
      break;
      break;
    case 0x2e:
    case 0x2e:
Line 759... Line 759...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0010 1110                     sub     %0, %e1%1                       */",
                     "/** 0010 1110                     sub     %0, %e1%1                       */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("sub   %0, %e1%1");
          SYNTAX("sub   %0, %e1%1");
#line 1099 "rl78-decode.opc"
#line 1104 "rl78-decode.opc"
          ID(sub); DR(A); SM(HL, IMMU(1)); Fzac;
          ID(sub); DR(A); SM(HL, IMMU(1)); Fzac;
 
 
        }
        }
      break;
      break;
    case 0x2f:
    case 0x2f:
Line 774... Line 774...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0010 1111                     sub     %0, %e1%!1                      */",
                     "/** 0010 1111                     sub     %0, %e1%!1                      */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("sub   %0, %e1%!1");
          SYNTAX("sub   %0, %e1%!1");
#line 1090 "rl78-decode.opc"
#line 1095 "rl78-decode.opc"
          ID(sub); DR(A); SM(None, IMMU(2)); Fzac;
          ID(sub); DR(A); SM(None, IMMU(2)); Fzac;
 
 
        }
        }
      break;
      break;
    case 0x30:
    case 0x30:
Line 921... Line 921...
              }
              }
            break;
            break;
          case 0x07:
          case 0x07:
              {
              {
                /** 0011 0001 0cnt 0111         shl     %0, %1                          */
                /** 0011 0001 0cnt 0111         shl     %0, %1                          */
#line 1046 "rl78-decode.opc"
#line 1051 "rl78-decode.opc"
                int cnt AU = (op[1] >> 4) & 0x07;
                int cnt AU = (op[1] >> 4) & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0011 0001 0cnt 0111             shl     %0, %1                          */",
                           "/** 0011 0001 0cnt 0111             shl     %0, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  cnt = 0x%x\n", cnt);
                    printf ("  cnt = 0x%x\n", cnt);
                  }
                  }
                SYNTAX("shl     %0, %1");
                SYNTAX("shl     %0, %1");
#line 1046 "rl78-decode.opc"
#line 1051 "rl78-decode.opc"
                ID(shl); DR(C); SC(cnt);
                ID(shl); DR(C); SC(cnt);
 
 
              }
              }
            break;
            break;
          case 0x08:
          case 0x08:
              {
              {
                /** 0011 0001 0cnt 1000         shl     %0, %1                          */
                /** 0011 0001 0cnt 1000         shl     %0, %1                          */
#line 1043 "rl78-decode.opc"
#line 1048 "rl78-decode.opc"
                int cnt AU = (op[1] >> 4) & 0x07;
                int cnt AU = (op[1] >> 4) & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0011 0001 0cnt 1000             shl     %0, %1                          */",
                           "/** 0011 0001 0cnt 1000             shl     %0, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  cnt = 0x%x\n", cnt);
                    printf ("  cnt = 0x%x\n", cnt);
                  }
                  }
                SYNTAX("shl     %0, %1");
                SYNTAX("shl     %0, %1");
#line 1043 "rl78-decode.opc"
#line 1048 "rl78-decode.opc"
                ID(shl); DR(B); SC(cnt);
                ID(shl); DR(B); SC(cnt);
 
 
              }
              }
            break;
            break;
          case 0x09:
          case 0x09:
              {
              {
                /** 0011 0001 0cnt 1001         shl     %0, %1                          */
                /** 0011 0001 0cnt 1001         shl     %0, %1                          */
#line 1040 "rl78-decode.opc"
#line 1045 "rl78-decode.opc"
                int cnt AU = (op[1] >> 4) & 0x07;
                int cnt AU = (op[1] >> 4) & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0011 0001 0cnt 1001             shl     %0, %1                          */",
                           "/** 0011 0001 0cnt 1001             shl     %0, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  cnt = 0x%x\n", cnt);
                    printf ("  cnt = 0x%x\n", cnt);
                  }
                  }
                SYNTAX("shl     %0, %1");
                SYNTAX("shl     %0, %1");
#line 1040 "rl78-decode.opc"
#line 1045 "rl78-decode.opc"
                ID(shl); DR(A); SC(cnt);
                ID(shl); DR(A); SC(cnt);
 
 
              }
              }
            break;
            break;
          case 0x0a:
          case 0x0a:
              {
              {
                /** 0011 0001 0cnt 1010         shr     %0, %1                          */
                /** 0011 0001 0cnt 1010         shr     %0, %1                          */
#line 1057 "rl78-decode.opc"
#line 1062 "rl78-decode.opc"
                int cnt AU = (op[1] >> 4) & 0x07;
                int cnt AU = (op[1] >> 4) & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0011 0001 0cnt 1010             shr     %0, %1                          */",
                           "/** 0011 0001 0cnt 1010             shr     %0, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  cnt = 0x%x\n", cnt);
                    printf ("  cnt = 0x%x\n", cnt);
                  }
                  }
                SYNTAX("shr     %0, %1");
                SYNTAX("shr     %0, %1");
#line 1057 "rl78-decode.opc"
#line 1062 "rl78-decode.opc"
                ID(shr); DR(A); SC(cnt);
                ID(shr); DR(A); SC(cnt);
 
 
              }
              }
            break;
            break;
          case 0x0b:
          case 0x0b:
              {
              {
                /** 0011 0001 0cnt 1011         sar     %0, %1                          */
                /** 0011 0001 0cnt 1011         sar     %0, %1                          */
#line 1004 "rl78-decode.opc"
#line 1009 "rl78-decode.opc"
                int cnt AU = (op[1] >> 4) & 0x07;
                int cnt AU = (op[1] >> 4) & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0011 0001 0cnt 1011             sar     %0, %1                          */",
                           "/** 0011 0001 0cnt 1011             sar     %0, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  cnt = 0x%x\n", cnt);
                    printf ("  cnt = 0x%x\n", cnt);
                  }
                  }
                SYNTAX("sar     %0, %1");
                SYNTAX("sar     %0, %1");
#line 1004 "rl78-decode.opc"
#line 1009 "rl78-decode.opc"
                ID(sar); DR(A); SC(cnt);
                ID(sar); DR(A); SC(cnt);
 
 
              }
              }
            break;
            break;
          case 0x0c:
          case 0x0c:
          case 0x8c:
          case 0x8c:
              {
              {
                /** 0011 0001 wcnt 1100         shlw    %0, %1                          */
                /** 0011 0001 wcnt 1100         shlw    %0, %1                          */
#line 1052 "rl78-decode.opc"
#line 1057 "rl78-decode.opc"
                int wcnt AU = (op[1] >> 4) & 0x0f;
                int wcnt AU = (op[1] >> 4) & 0x0f;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0011 0001 wcnt 1100             shlw    %0, %1                          */",
                           "/** 0011 0001 wcnt 1100             shlw    %0, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  wcnt = 0x%x\n", wcnt);
                    printf ("  wcnt = 0x%x\n", wcnt);
                  }
                  }
                SYNTAX("shlw    %0, %1");
                SYNTAX("shlw    %0, %1");
#line 1052 "rl78-decode.opc"
#line 1057 "rl78-decode.opc"
                ID(shl); W(); DR(BC); SC(wcnt);
                ID(shl); W(); DR(BC); SC(wcnt);
 
 
              /*----------------------------------------------------------------------*/
              /*----------------------------------------------------------------------*/
 
 
              }
              }
            break;
            break;
          case 0x0d:
          case 0x0d:
          case 0x8d:
          case 0x8d:
              {
              {
                /** 0011 0001 wcnt 1101         shlw    %0, %1                          */
                /** 0011 0001 wcnt 1101         shlw    %0, %1                          */
#line 1049 "rl78-decode.opc"
#line 1054 "rl78-decode.opc"
                int wcnt AU = (op[1] >> 4) & 0x0f;
                int wcnt AU = (op[1] >> 4) & 0x0f;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0011 0001 wcnt 1101             shlw    %0, %1                          */",
                           "/** 0011 0001 wcnt 1101             shlw    %0, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  wcnt = 0x%x\n", wcnt);
                    printf ("  wcnt = 0x%x\n", wcnt);
                  }
                  }
                SYNTAX("shlw    %0, %1");
                SYNTAX("shlw    %0, %1");
#line 1049 "rl78-decode.opc"
#line 1054 "rl78-decode.opc"
                ID(shl); W(); DR(AX); SC(wcnt);
                ID(shl); W(); DR(AX); SC(wcnt);
 
 
              }
              }
            break;
            break;
          case 0x0e:
          case 0x0e:
          case 0x8e:
          case 0x8e:
              {
              {
                /** 0011 0001 wcnt 1110         shrw    %0, %1                          */
                /** 0011 0001 wcnt 1110         shrw    %0, %1                          */
#line 1060 "rl78-decode.opc"
#line 1065 "rl78-decode.opc"
                int wcnt AU = (op[1] >> 4) & 0x0f;
                int wcnt AU = (op[1] >> 4) & 0x0f;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0011 0001 wcnt 1110             shrw    %0, %1                          */",
                           "/** 0011 0001 wcnt 1110             shrw    %0, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  wcnt = 0x%x\n", wcnt);
                    printf ("  wcnt = 0x%x\n", wcnt);
                  }
                  }
                SYNTAX("shrw    %0, %1");
                SYNTAX("shrw    %0, %1");
#line 1060 "rl78-decode.opc"
#line 1065 "rl78-decode.opc"
                ID(shr); W(); DR(AX); SC(wcnt);
                ID(shr); W(); DR(AX); SC(wcnt);
 
 
              /*----------------------------------------------------------------------*/
              /*----------------------------------------------------------------------*/
 
 
              }
              }
            break;
            break;
          case 0x0f:
          case 0x0f:
          case 0x8f:
          case 0x8f:
              {
              {
                /** 0011 0001 wcnt 1111         sarw    %0, %1                          */
                /** 0011 0001 wcnt 1111         sarw    %0, %1                          */
#line 1007 "rl78-decode.opc"
#line 1012 "rl78-decode.opc"
                int wcnt AU = (op[1] >> 4) & 0x0f;
                int wcnt AU = (op[1] >> 4) & 0x0f;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0011 0001 wcnt 1111             sarw    %0, %1                          */",
                           "/** 0011 0001 wcnt 1111             sarw    %0, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  wcnt = 0x%x\n", wcnt);
                    printf ("  wcnt = 0x%x\n", wcnt);
                  }
                  }
                SYNTAX("sarw    %0, %1");
                SYNTAX("sarw    %0, %1");
#line 1007 "rl78-decode.opc"
#line 1012 "rl78-decode.opc"
                ID(sar); W(); DR(AX); SC(wcnt);
                ID(sar); W(); DR(AX); SC(wcnt);
 
 
              /*----------------------------------------------------------------------*/
              /*----------------------------------------------------------------------*/
 
 
              }
              }
Line 1206... Line 1206...
    case 0x33:
    case 0x33:
    case 0x35:
    case 0x35:
    case 0x37:
    case 0x37:
        {
        {
          /** 0011 0ra1                 xchw    %0, %1                          */
          /** 0011 0ra1                 xchw    %0, %1                          */
#line 1210 "rl78-decode.opc"
#line 1215 "rl78-decode.opc"
          int ra AU = (op[0] >> 1) & 0x03;
          int ra AU = (op[0] >> 1) & 0x03;
          if (trace)
          if (trace)
            {
            {
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0011 0ra1                     xchw    %0, %1                          */",
                     "/** 0011 0ra1                     xchw    %0, %1                          */",
                     op[0]);
                     op[0]);
              printf ("  ra = 0x%x\n", ra);
              printf ("  ra = 0x%x\n", ra);
            }
            }
          SYNTAX("xchw  %0, %1");
          SYNTAX("xchw  %0, %1");
#line 1210 "rl78-decode.opc"
#line 1215 "rl78-decode.opc"
          ID(xch); W(); DR(AX); SRW(ra);
          ID(xch); W(); DR(AX); SRW(ra);
 
 
        /*----------------------------------------------------------------------*/
        /*----------------------------------------------------------------------*/
 
 
        }
        }
Line 1263... Line 1263...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0011 1010                     subc    %0, #%1                         */",
                     "/** 0011 1010                     subc    %0, #%1                         */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("subc  %0, #%1");
          SYNTAX("subc  %0, #%1");
#line 1149 "rl78-decode.opc"
#line 1154 "rl78-decode.opc"
          ID(subc); DM(None, SADDR); SC(IMMU(1)); Fzac;
          ID(subc); DM(None, SADDR); SC(IMMU(1)); Fzac;
 
 
        /*----------------------------------------------------------------------*/
        /*----------------------------------------------------------------------*/
 
 
        }
        }
Line 1280... Line 1280...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0011 1011                     subc    %0, %1                          */",
                     "/** 0011 1011                     subc    %0, %1                          */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("subc  %0, %1");
          SYNTAX("subc  %0, %1");
#line 1146 "rl78-decode.opc"
#line 1151 "rl78-decode.opc"
          ID(subc); DR(A); SM(None, SADDR); Fzac;
          ID(subc); DR(A); SM(None, SADDR); Fzac;
 
 
        }
        }
      break;
      break;
    case 0x3c:
    case 0x3c:
Line 1295... Line 1295...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0011 1100                     subc    %0, #%1                         */",
                     "/** 0011 1100                     subc    %0, #%1                         */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("subc  %0, #%1");
          SYNTAX("subc  %0, #%1");
#line 1137 "rl78-decode.opc"
#line 1142 "rl78-decode.opc"
          ID(subc); DR(A); SC(IMMU(1)); Fzac;
          ID(subc); DR(A); SC(IMMU(1)); Fzac;
 
 
        }
        }
      break;
      break;
    case 0x3d:
    case 0x3d:
Line 1310... Line 1310...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0011 1101                     subc    %0, %e1%1                       */",
                     "/** 0011 1101                     subc    %0, %e1%1                       */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("subc  %0, %e1%1");
          SYNTAX("subc  %0, %e1%1");
#line 1125 "rl78-decode.opc"
#line 1130 "rl78-decode.opc"
          ID(subc); DR(A); SM(HL, 0); Fzac;
          ID(subc); DR(A); SM(HL, 0); Fzac;
 
 
        }
        }
      break;
      break;
    case 0x3e:
    case 0x3e:
Line 1325... Line 1325...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0011 1110                     subc    %0, %e1%1                       */",
                     "/** 0011 1110                     subc    %0, %e1%1                       */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("subc  %0, %e1%1");
          SYNTAX("subc  %0, %e1%1");
#line 1134 "rl78-decode.opc"
#line 1139 "rl78-decode.opc"
          ID(subc); DR(A); SM(HL, IMMU(1)); Fzac;
          ID(subc); DR(A); SM(HL, IMMU(1)); Fzac;
 
 
        }
        }
      break;
      break;
    case 0x3f:
    case 0x3f:
Line 1340... Line 1340...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0011 1111                     subc    %0, %e1%!1                      */",
                     "/** 0011 1111                     subc    %0, %e1%!1                      */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("subc  %0, %e1%!1");
          SYNTAX("subc  %0, %e1%!1");
#line 1122 "rl78-decode.opc"
#line 1127 "rl78-decode.opc"
          ID(subc); DR(A); SM(None, IMMU(2)); Fzac;
          ID(subc); DR(A); SM(None, IMMU(2)); Fzac;
 
 
        }
        }
      break;
      break;
    case 0x40:
    case 0x40:
Line 1862... Line 1862...
          case 0x25:
          case 0x25:
          case 0x26:
          case 0x26:
          case 0x27:
          case 0x27:
              {
              {
                /** 0110 0001 0010 0reg         sub     %0, %1                          */
                /** 0110 0001 0010 0reg         sub     %0, %1                          */
#line 1114 "rl78-decode.opc"
#line 1119 "rl78-decode.opc"
                int reg AU = op[1] & 0x07;
                int reg AU = op[1] & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 0010 0reg             sub     %0, %1                          */",
                           "/** 0110 0001 0010 0reg             sub     %0, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  reg = 0x%x\n", reg);
                    printf ("  reg = 0x%x\n", reg);
                  }
                  }
                SYNTAX("sub     %0, %1");
                SYNTAX("sub     %0, %1");
#line 1114 "rl78-decode.opc"
#line 1119 "rl78-decode.opc"
                ID(sub); DRB(reg); SR(A); Fzac;
                ID(sub); DRB(reg); SR(A); Fzac;
 
 
              }
              }
            break;
            break;
          case 0x28:
          case 0x28:
Line 1886... Line 1886...
          case 0x2d:
          case 0x2d:
          case 0x2e:
          case 0x2e:
          case 0x2f:
          case 0x2f:
              {
              {
                /** 0110 0001 0010 1rba         sub     %0, %1                          */
                /** 0110 0001 0010 1rba         sub     %0, %1                          */
#line 1108 "rl78-decode.opc"
#line 1113 "rl78-decode.opc"
                int rba AU = op[1] & 0x07;
                int rba AU = op[1] & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 0010 1rba             sub     %0, %1                          */",
                           "/** 0110 0001 0010 1rba             sub     %0, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  rba = 0x%x\n", rba);
                    printf ("  rba = 0x%x\n", rba);
                  }
                  }
                SYNTAX("sub     %0, %1");
                SYNTAX("sub     %0, %1");
#line 1108 "rl78-decode.opc"
#line 1113 "rl78-decode.opc"
                ID(sub); DR(A); SRB(rba); Fzac;
                ID(sub); DR(A); SRB(rba); Fzac;
 
 
              }
              }
            break;
            break;
          case 0x29:
          case 0x29:
Line 1911... Line 1911...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 0010 1001             subw    %0, %e1%1                       */",
                           "/** 0110 0001 0010 1001             subw    %0, %e1%1                       */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("subw    %0, %e1%1");
                SYNTAX("subw    %0, %e1%1");
#line 1157 "rl78-decode.opc"
#line 1162 "rl78-decode.opc"
                ID(sub); W(); DR(AX); SM(HL, IMMU(1)); Fzac;
                ID(sub); W(); DR(AX); SM(HL, IMMU(1)); Fzac;
 
 
              }
              }
            break;
            break;
          case 0x30:
          case 0x30:
Line 1926... Line 1926...
          case 0x35:
          case 0x35:
          case 0x36:
          case 0x36:
          case 0x37:
          case 0x37:
              {
              {
                /** 0110 0001 0011 0reg         subc    %0, %1                          */
                /** 0110 0001 0011 0reg         subc    %0, %1                          */
#line 1143 "rl78-decode.opc"
#line 1148 "rl78-decode.opc"
                int reg AU = op[1] & 0x07;
                int reg AU = op[1] & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 0011 0reg             subc    %0, %1                          */",
                           "/** 0110 0001 0011 0reg             subc    %0, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  reg = 0x%x\n", reg);
                    printf ("  reg = 0x%x\n", reg);
                  }
                  }
                SYNTAX("subc    %0, %1");
                SYNTAX("subc    %0, %1");
#line 1143 "rl78-decode.opc"
#line 1148 "rl78-decode.opc"
                ID(subc); DRB(reg); SR(A); Fzac;
                ID(subc); DRB(reg); SR(A); Fzac;
 
 
              }
              }
            break;
            break;
          case 0x38:
          case 0x38:
Line 1950... Line 1950...
          case 0x3d:
          case 0x3d:
          case 0x3e:
          case 0x3e:
          case 0x3f:
          case 0x3f:
              {
              {
                /** 0110 0001 0011 1rba         subc    %0, %1                          */
                /** 0110 0001 0011 1rba         subc    %0, %1                          */
#line 1140 "rl78-decode.opc"
#line 1145 "rl78-decode.opc"
                int rba AU = op[1] & 0x07;
                int rba AU = op[1] & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 0011 1rba             subc    %0, %1                          */",
                           "/** 0110 0001 0011 1rba             subc    %0, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  rba = 0x%x\n", rba);
                    printf ("  rba = 0x%x\n", rba);
                  }
                  }
                SYNTAX("subc    %0, %1");
                SYNTAX("subc    %0, %1");
#line 1140 "rl78-decode.opc"
#line 1145 "rl78-decode.opc"
                ID(subc); DR(A); SRB(rba); Fzac;
                ID(subc); DR(A); SRB(rba); Fzac;
 
 
              }
              }
            break;
            break;
          case 0x40:
          case 0x40:
Line 2103... Line 2103...
          case 0x65:
          case 0x65:
          case 0x66:
          case 0x66:
          case 0x67:
          case 0x67:
              {
              {
                /** 0110 0001 0110 0reg         or      %0, %1                          */
                /** 0110 0001 0110 0reg         or      %0, %1                          */
#line 932 "rl78-decode.opc"
#line 937 "rl78-decode.opc"
                int reg AU = op[1] & 0x07;
                int reg AU = op[1] & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 0110 0reg             or      %0, %1                          */",
                           "/** 0110 0001 0110 0reg             or      %0, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  reg = 0x%x\n", reg);
                    printf ("  reg = 0x%x\n", reg);
                  }
                  }
                SYNTAX("or      %0, %1");
                SYNTAX("or      %0, %1");
#line 932 "rl78-decode.opc"
#line 937 "rl78-decode.opc"
                ID(or); DRB(reg); SR(A); Fz;
                ID(or); DRB(reg); SR(A); Fz;
 
 
              }
              }
            break;
            break;
          case 0x68:
          case 0x68:
Line 2127... Line 2127...
          case 0x6d:
          case 0x6d:
          case 0x6e:
          case 0x6e:
          case 0x6f:
          case 0x6f:
              {
              {
                /** 0110 0001 0110 1rba         or      %0, %1                          */
                /** 0110 0001 0110 1rba         or      %0, %1                          */
#line 929 "rl78-decode.opc"
#line 934 "rl78-decode.opc"
                int rba AU = op[1] & 0x07;
                int rba AU = op[1] & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 0110 1rba             or      %0, %1                          */",
                           "/** 0110 0001 0110 1rba             or      %0, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  rba = 0x%x\n", rba);
                    printf ("  rba = 0x%x\n", rba);
                  }
                  }
                SYNTAX("or      %0, %1");
                SYNTAX("or      %0, %1");
#line 929 "rl78-decode.opc"
#line 934 "rl78-decode.opc"
                ID(or); DR(A); SRB(rba); Fz;
                ID(or); DR(A); SRB(rba); Fz;
 
 
              }
              }
            break;
            break;
          case 0x69:
          case 0x69:
Line 2167... Line 2167...
          case 0x75:
          case 0x75:
          case 0x76:
          case 0x76:
          case 0x77:
          case 0x77:
              {
              {
                /** 0110 0001 0111 0reg         xor     %0, %1                          */
                /** 0110 0001 0111 0reg         xor     %0, %1                          */
#line 1236 "rl78-decode.opc"
#line 1241 "rl78-decode.opc"
                int reg AU = op[1] & 0x07;
                int reg AU = op[1] & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 0111 0reg             xor     %0, %1                          */",
                           "/** 0110 0001 0111 0reg             xor     %0, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  reg = 0x%x\n", reg);
                    printf ("  reg = 0x%x\n", reg);
                  }
                  }
                SYNTAX("xor     %0, %1");
                SYNTAX("xor     %0, %1");
#line 1236 "rl78-decode.opc"
#line 1241 "rl78-decode.opc"
                ID(xor); DRB(reg); SR(A); Fz;
                ID(xor); DRB(reg); SR(A); Fz;
 
 
              }
              }
            break;
            break;
          case 0x78:
          case 0x78:
Line 2191... Line 2191...
          case 0x7d:
          case 0x7d:
          case 0x7e:
          case 0x7e:
          case 0x7f:
          case 0x7f:
              {
              {
                /** 0110 0001 0111 1rba         xor     %0, %1                          */
                /** 0110 0001 0111 1rba         xor     %0, %1                          */
#line 1233 "rl78-decode.opc"
#line 1238 "rl78-decode.opc"
                int rba AU = op[1] & 0x07;
                int rba AU = op[1] & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 0111 1rba             xor     %0, %1                          */",
                           "/** 0110 0001 0111 1rba             xor     %0, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  rba = 0x%x\n", rba);
                    printf ("  rba = 0x%x\n", rba);
                  }
                  }
                SYNTAX("xor     %0, %1");
                SYNTAX("xor     %0, %1");
#line 1233 "rl78-decode.opc"
#line 1238 "rl78-decode.opc"
                ID(xor); DR(A); SRB(rba); Fz;
                ID(xor); DR(A); SRB(rba); Fz;
 
 
              }
              }
            break;
            break;
          case 0x79:
          case 0x79:
Line 2315... Line 2315...
          case 0x8d:
          case 0x8d:
          case 0x8e:
          case 0x8e:
          case 0x8f:
          case 0x8f:
              {
              {
                /** 0110 0001 1000 1reg         xch     %0, %1                          */
                /** 0110 0001 1000 1reg         xch     %0, %1                          */
#line 1195 "rl78-decode.opc"
#line 1200 "rl78-decode.opc"
                int reg AU = op[1] & 0x07;
                int reg AU = op[1] & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1000 1reg             xch     %0, %1                          */",
                           "/** 0110 0001 1000 1reg             xch     %0, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  reg = 0x%x\n", reg);
                    printf ("  reg = 0x%x\n", reg);
                  }
                  }
                SYNTAX("xch     %0, %1");
                SYNTAX("xch     %0, %1");
#line 1195 "rl78-decode.opc"
#line 1200 "rl78-decode.opc"
                /* Note: DECW uses reg == X, so this must follow DECW */
                /* Note: DECW uses reg == X, so this must follow DECW */
                ID(xch); DR(A); SRB(reg);
                ID(xch); DR(A); SRB(reg);
 
 
              }
              }
            break;
            break;
Line 2387... Line 2387...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1010 000              sub     %0, %e1%1                       */",
                           "/** 0110 0001 1010 000              sub     %0, %e1%1                       */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("sub     %0, %e1%1");
                SYNTAX("sub     %0, %e1%1");
#line 1096 "rl78-decode.opc"
#line 1101 "rl78-decode.opc"
                ID(sub); DR(A); SM2(HL, B, 0); Fzac;
                ID(sub); DR(A); SM2(HL, B, 0); Fzac;
 
 
              }
              }
            break;
            break;
          case 0xa2:
          case 0xa2:
Line 2402... Line 2402...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1010 0010             sub     %0, %e1%1                       */",
                           "/** 0110 0001 1010 0010             sub     %0, %e1%1                       */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("sub     %0, %e1%1");
                SYNTAX("sub     %0, %e1%1");
#line 1102 "rl78-decode.opc"
#line 1107 "rl78-decode.opc"
                ID(sub); DR(A); SM2(HL, C, 0); Fzac;
                ID(sub); DR(A); SM2(HL, C, 0); Fzac;
 
 
              }
              }
            break;
            break;
          case 0xa8:
          case 0xa8:
Line 2417... Line 2417...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1010 1000             xch     %0, %1                          */",
                           "/** 0110 0001 1010 1000             xch     %0, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("xch     %0, %1");
                SYNTAX("xch     %0, %1");
#line 1199 "rl78-decode.opc"
#line 1204 "rl78-decode.opc"
                ID(xch); DR(A); SM(None, SADDR);
                ID(xch); DR(A); SM(None, SADDR);
 
 
              }
              }
            break;
            break;
          case 0xa9:
          case 0xa9:
Line 2432... Line 2432...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1010 1001             xch     %0, %e1%1                       */",
                           "/** 0110 0001 1010 1001             xch     %0, %e1%1                       */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("xch     %0, %e1%1");
                SYNTAX("xch     %0, %e1%1");
#line 1192 "rl78-decode.opc"
#line 1197 "rl78-decode.opc"
                ID(xch); DR(A); SM2(HL, C, 0);
                ID(xch); DR(A); SM2(HL, C, 0);
 
 
              }
              }
            break;
            break;
          case 0xaa:
          case 0xaa:
Line 2447... Line 2447...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1010 1010             xch     %0, %e1%!1                      */",
                           "/** 0110 0001 1010 1010             xch     %0, %e1%!1                      */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("xch     %0, %e1%!1");
                SYNTAX("xch     %0, %e1%!1");
#line 1174 "rl78-decode.opc"
#line 1179 "rl78-decode.opc"
                ID(xch); DR(A); SM(None, IMMU(2));
                ID(xch); DR(A); SM(None, IMMU(2));
 
 
              }
              }
            break;
            break;
          case 0xab:
          case 0xab:
Line 2462... Line 2462...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1010 1011             xch     %0, %1                          */",
                           "/** 0110 0001 1010 1011             xch     %0, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("xch     %0, %1");
                SYNTAX("xch     %0, %1");
#line 1202 "rl78-decode.opc"
#line 1207 "rl78-decode.opc"
                ID(xch); DR(A); SM(None, SFR);
                ID(xch); DR(A); SM(None, SFR);
 
 
              }
              }
            break;
            break;
          case 0xac:
          case 0xac:
Line 2477... Line 2477...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1010 1100             xch     %0, %e1%1                       */",
                           "/** 0110 0001 1010 1100             xch     %0, %e1%1                       */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("xch     %0, %e1%1");
                SYNTAX("xch     %0, %e1%1");
#line 1183 "rl78-decode.opc"
#line 1188 "rl78-decode.opc"
                ID(xch); DR(A); SM(HL, 0);
                ID(xch); DR(A); SM(HL, 0);
 
 
              }
              }
            break;
            break;
          case 0xad:
          case 0xad:
Line 2492... Line 2492...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1010 1101             xch     %0, %e1%1                       */",
                           "/** 0110 0001 1010 1101             xch     %0, %e1%1                       */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("xch     %0, %e1%1");
                SYNTAX("xch     %0, %e1%1");
#line 1189 "rl78-decode.opc"
#line 1194 "rl78-decode.opc"
                ID(xch); DR(A); SM(HL, IMMU(1));
                ID(xch); DR(A); SM(HL, IMMU(1));
 
 
              }
              }
            break;
            break;
          case 0xae:
          case 0xae:
Line 2507... Line 2507...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1010 1110             xch     %0, %e1%1                       */",
                           "/** 0110 0001 1010 1110             xch     %0, %e1%1                       */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("xch     %0, %e1%1");
                SYNTAX("xch     %0, %e1%1");
#line 1177 "rl78-decode.opc"
#line 1182 "rl78-decode.opc"
                ID(xch); DR(A); SM(DE, 0);
                ID(xch); DR(A); SM(DE, 0);
 
 
              }
              }
            break;
            break;
          case 0xaf:
          case 0xaf:
Line 2522... Line 2522...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1010 1111             xch     %0, %e1%1                       */",
                           "/** 0110 0001 1010 1111             xch     %0, %e1%1                       */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("xch     %0, %e1%1");
                SYNTAX("xch     %0, %e1%1");
#line 1180 "rl78-decode.opc"
#line 1185 "rl78-decode.opc"
                ID(xch); DR(A); SM(DE, IMMU(1));
                ID(xch); DR(A); SM(DE, IMMU(1));
 
 
              }
              }
            break;
            break;
          case 0xb0:
          case 0xb0:
Line 2537... Line 2537...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1011 0000             subc    %0, %e1%1                       */",
                           "/** 0110 0001 1011 0000             subc    %0, %e1%1                       */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("subc    %0, %e1%1");
                SYNTAX("subc    %0, %e1%1");
#line 1128 "rl78-decode.opc"
#line 1133 "rl78-decode.opc"
                ID(subc); DR(A); SM2(HL, B, 0); Fzac;
                ID(subc); DR(A); SM2(HL, B, 0); Fzac;
 
 
              }
              }
            break;
            break;
          case 0xb2:
          case 0xb2:
Line 2552... Line 2552...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1011 0010             subc    %0, %e1%1                       */",
                           "/** 0110 0001 1011 0010             subc    %0, %e1%1                       */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("subc    %0, %e1%1");
                SYNTAX("subc    %0, %e1%1");
#line 1131 "rl78-decode.opc"
#line 1136 "rl78-decode.opc"
                ID(subc); DR(A); SM2(HL, C, 0); Fzac;
                ID(subc); DR(A); SM2(HL, C, 0); Fzac;
 
 
              }
              }
            break;
            break;
          case 0xb8:
          case 0xb8:
Line 2582... Line 2582...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1011 1001             xch     %0, %e1%1                       */",
                           "/** 0110 0001 1011 1001             xch     %0, %e1%1                       */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("xch     %0, %e1%1");
                SYNTAX("xch     %0, %e1%1");
#line 1186 "rl78-decode.opc"
#line 1191 "rl78-decode.opc"
                ID(xch); DR(A); SM2(HL, B, 0);
                ID(xch); DR(A); SM2(HL, B, 0);
 
 
              }
              }
            break;
            break;
          case 0xc0:
          case 0xc0:
Line 2642... Line 2642...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1100 1000             sk%c1                                   */",
                           "/** 0110 0001 1100 1000             sk%c1                                   */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("sk%c1");
                SYNTAX("sk%c1");
#line 1065 "rl78-decode.opc"
#line 1070 "rl78-decode.opc"
                ID(skip); COND(C);
                ID(skip); COND(C);
 
 
              }
              }
            break;
            break;
          case 0xc9:
          case 0xc9:
Line 2727... Line 2727...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1100 1101             pop     %s0                             */",
                           "/** 0110 0001 1100 1101             pop     %s0                             */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("pop     %s0");
                SYNTAX("pop     %s0");
#line 960 "rl78-decode.opc"
#line 965 "rl78-decode.opc"
                ID(mov); W(); DR(PSW); SPOP();
                ID(mov); W(); DR(PSW); SPOP();
 
 
              /*----------------------------------------------------------------------*/
              /*----------------------------------------------------------------------*/
 
 
              }
              }
Line 2757... Line 2757...
          case 0xdf:
          case 0xdf:
          case 0xef:
          case 0xef:
          case 0xff:
          case 0xff:
              {
              {
                /** 0110 0001 11rb 1111         sel     rb%1                            */
                /** 0110 0001 11rb 1111         sel     rb%1                            */
#line 1012 "rl78-decode.opc"
#line 1017 "rl78-decode.opc"
                int rb AU = (op[1] >> 4) & 0x03;
                int rb AU = (op[1] >> 4) & 0x03;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 11rb 1111             sel     rb%1                            */",
                           "/** 0110 0001 11rb 1111             sel     rb%1                            */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  rb = 0x%x\n", rb);
                    printf ("  rb = 0x%x\n", rb);
                  }
                  }
                SYNTAX("sel     rb%1");
                SYNTAX("sel     rb%1");
#line 1012 "rl78-decode.opc"
#line 1017 "rl78-decode.opc"
                ID(sel); SC(rb);
                ID(sel); SC(rb);
 
 
              /*----------------------------------------------------------------------*/
              /*----------------------------------------------------------------------*/
 
 
              }
              }
Line 2829... Line 2829...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1101 1000             sk%c1                                   */",
                           "/** 0110 0001 1101 1000             sk%c1                                   */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("sk%c1");
                SYNTAX("sk%c1");
#line 1071 "rl78-decode.opc"
#line 1076 "rl78-decode.opc"
                ID(skip); COND(NC);
                ID(skip); COND(NC);
 
 
              }
              }
            break;
            break;
          case 0xd9:
          case 0xd9:
Line 2859... Line 2859...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1101 1011             ror     %0, %1                          */",
                           "/** 0110 0001 1101 1011             ror     %0, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("ror     %0, %1");
                SYNTAX("ror     %0, %1");
#line 993 "rl78-decode.opc"
#line 998 "rl78-decode.opc"
                ID(ror); DR(A); SC(1);
                ID(ror); DR(A); SC(1);
 
 
              }
              }
            break;
            break;
          case 0xdc:
          case 0xdc:
Line 2874... Line 2874...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1101 1100             rolc    %0, %1                          */",
                           "/** 0110 0001 1101 1100             rolc    %0, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("rolc    %0, %1");
                SYNTAX("rolc    %0, %1");
#line 987 "rl78-decode.opc"
#line 992 "rl78-decode.opc"
                ID(rolc); DR(A); SC(1);
                ID(rolc); DR(A); SC(1);
 
 
              }
              }
            break;
            break;
          case 0xdd:
          case 0xdd:
Line 2889... Line 2889...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1101 1101             push    %s1                             */",
                           "/** 0110 0001 1101 1101             push    %s1                             */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("push    %s1");
                SYNTAX("push    %s1");
#line 968 "rl78-decode.opc"
#line 973 "rl78-decode.opc"
                ID(mov); W(); DPUSH(); SR(PSW);
                ID(mov); W(); DPUSH(); SR(PSW);
 
 
              /*----------------------------------------------------------------------*/
              /*----------------------------------------------------------------------*/
 
 
              }
              }
Line 2923... Line 2923...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1110 0000             or      %0, %e1%1                       */",
                           "/** 0110 0001 1110 0000             or      %0, %e1%1                       */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("or      %0, %e1%1");
                SYNTAX("or      %0, %e1%1");
#line 917 "rl78-decode.opc"
#line 922 "rl78-decode.opc"
                ID(or); DR(A); SM2(HL, B, 0); Fz;
                ID(or); DR(A); SM2(HL, B, 0); Fz;
 
 
              }
              }
            break;
            break;
          case 0xe2:
          case 0xe2:
Line 2938... Line 2938...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1110 0010             or      %0, %e1%1                       */",
                           "/** 0110 0001 1110 0010             or      %0, %e1%1                       */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("or      %0, %e1%1");
                SYNTAX("or      %0, %e1%1");
#line 923 "rl78-decode.opc"
#line 928 "rl78-decode.opc"
                ID(or); DR(A); SM2(HL, C, 0); Fz;
                ID(or); DR(A); SM2(HL, C, 0); Fz;
 
 
              }
              }
            break;
            break;
          case 0xe3:
          case 0xe3:
Line 2953... Line 2953...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1110 0011             sk%c1                                   */",
                           "/** 0110 0001 1110 0011             sk%c1                                   */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("sk%c1");
                SYNTAX("sk%c1");
#line 1068 "rl78-decode.opc"
#line 1073 "rl78-decode.opc"
                ID(skip); COND(H);
                ID(skip); COND(H);
 
 
              }
              }
            break;
            break;
          case 0xe8:
          case 0xe8:
Line 2968... Line 2968...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1110 1000             sk%c1                                   */",
                           "/** 0110 0001 1110 1000             sk%c1                                   */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("sk%c1");
                SYNTAX("sk%c1");
#line 1080 "rl78-decode.opc"
#line 1085 "rl78-decode.opc"
                ID(skip); COND(Z);
                ID(skip); COND(Z);
 
 
              /*----------------------------------------------------------------------*/
              /*----------------------------------------------------------------------*/
 
 
              }
              }
Line 3000... Line 3000...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1110 1011             rol     %0, %1                          */",
                           "/** 0110 0001 1110 1011             rol     %0, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("rol     %0, %1");
                SYNTAX("rol     %0, %1");
#line 984 "rl78-decode.opc"
#line 989 "rl78-decode.opc"
                ID(rol); DR(A); SC(1);
                ID(rol); DR(A); SC(1);
 
 
              }
              }
            break;
            break;
          case 0xec:
          case 0xec:
Line 3015... Line 3015...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1110 1100             retb                                    */",
                           "/** 0110 0001 1110 1100             retb                                    */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("retb");
                SYNTAX("retb");
#line 979 "rl78-decode.opc"
#line 984 "rl78-decode.opc"
                ID(reti);
                ID(reti);
 
 
              /*----------------------------------------------------------------------*/
              /*----------------------------------------------------------------------*/
 
 
              }
              }
Line 3043... Line 3043...
            break;
            break;
          case 0xee:
          case 0xee:
          case 0xfe:
          case 0xfe:
              {
              {
                /** 0110 0001 111r 1110         rolwc   %0, %1                          */
                /** 0110 0001 111r 1110         rolwc   %0, %1                          */
#line 990 "rl78-decode.opc"
#line 995 "rl78-decode.opc"
                int r AU = (op[1] >> 4) & 0x01;
                int r AU = (op[1] >> 4) & 0x01;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 111r 1110             rolwc   %0, %1                          */",
                           "/** 0110 0001 111r 1110             rolwc   %0, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  r = 0x%x\n", r);
                    printf ("  r = 0x%x\n", r);
                  }
                  }
                SYNTAX("rolwc   %0, %1");
                SYNTAX("rolwc   %0, %1");
#line 990 "rl78-decode.opc"
#line 995 "rl78-decode.opc"
                ID(rolc); W(); DRW(r); SC(1);
                ID(rolc); W(); DRW(r); SC(1);
 
 
              }
              }
            break;
            break;
          case 0xf0:
          case 0xf0:
Line 3068... Line 3068...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1111 0000             xor     %0, %e1%1                       */",
                           "/** 0110 0001 1111 0000             xor     %0, %e1%1                       */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("xor     %0, %e1%1");
                SYNTAX("xor     %0, %e1%1");
#line 1221 "rl78-decode.opc"
#line 1226 "rl78-decode.opc"
                ID(xor); DR(A); SM2(HL, B, 0); Fz;
                ID(xor); DR(A); SM2(HL, B, 0); Fz;
 
 
              }
              }
            break;
            break;
          case 0xf2:
          case 0xf2:
Line 3083... Line 3083...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1111 0010             xor     %0, %e1%1                       */",
                           "/** 0110 0001 1111 0010             xor     %0, %e1%1                       */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("xor     %0, %e1%1");
                SYNTAX("xor     %0, %e1%1");
#line 1227 "rl78-decode.opc"
#line 1232 "rl78-decode.opc"
                ID(xor); DR(A); SM2(HL, C, 0); Fz;
                ID(xor); DR(A); SM2(HL, C, 0); Fz;
 
 
              }
              }
            break;
            break;
          case 0xf3:
          case 0xf3:
Line 3098... Line 3098...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1111 0011             sk%c1                                   */",
                           "/** 0110 0001 1111 0011             sk%c1                                   */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("sk%c1");
                SYNTAX("sk%c1");
#line 1074 "rl78-decode.opc"
#line 1079 "rl78-decode.opc"
                ID(skip); COND(NH);
                ID(skip); COND(NH);
 
 
              }
              }
            break;
            break;
          case 0xf8:
          case 0xf8:
Line 3113... Line 3113...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1111 1000             sk%c1                                   */",
                           "/** 0110 0001 1111 1000             sk%c1                                   */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("sk%c1");
                SYNTAX("sk%c1");
#line 1077 "rl78-decode.opc"
#line 1082 "rl78-decode.opc"
                ID(skip); COND(NZ);
                ID(skip); COND(NZ);
 
 
              }
              }
            break;
            break;
          case 0xf9:
          case 0xf9:
Line 3143... Line 3143...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1111 1011             rorc    %0, %1                          */",
                           "/** 0110 0001 1111 1011             rorc    %0, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("rorc    %0, %1");
                SYNTAX("rorc    %0, %1");
#line 996 "rl78-decode.opc"
#line 1001 "rl78-decode.opc"
                ID(rorc); DR(A); SC(1);
                ID(rorc); DR(A); SC(1);
 
 
              /*----------------------------------------------------------------------*/
              /*----------------------------------------------------------------------*/
 
 
              /* Note that the branch insns need to be listed before the shift
              /* Note that the branch insns need to be listed before the shift
Line 3163... Line 3163...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1111 1100             reti                                    */",
                           "/** 0110 0001 1111 1100             reti                                    */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("reti");
                SYNTAX("reti");
#line 976 "rl78-decode.opc"
#line 981 "rl78-decode.opc"
                ID(reti);
                ID(reti);
 
 
              }
              }
            break;
            break;
          case 0xfd:
          case 0xfd:
Line 3178... Line 3178...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0110 0001 1111 1101     stop                                    */",
                           "/** 0110 0001 1111 1101     stop                                    */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("stop");
                SYNTAX("stop");
#line 1085 "rl78-decode.opc"
#line 1090 "rl78-decode.opc"
                ID(stop);
                ID(stop);
 
 
              /*----------------------------------------------------------------------*/
              /*----------------------------------------------------------------------*/
 
 
              }
              }
Line 3228... Line 3228...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0110 1010                     or      %0, #%1                         */",
                     "/** 0110 1010                     or      %0, #%1                         */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("or    %0, #%1");
          SYNTAX("or    %0, #%1");
#line 938 "rl78-decode.opc"
#line 943 "rl78-decode.opc"
          ID(or); DM(None, SADDR); SC(IMMU(1)); Fz;
          ID(or); DM(None, SADDR); SC(IMMU(1)); Fz;
 
 
        /*----------------------------------------------------------------------*/
        /*----------------------------------------------------------------------*/
 
 
        }
        }
Line 3245... Line 3245...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0110 1011                     or      %0, %1                          */",
                     "/** 0110 1011                     or      %0, %1                          */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("or    %0, %1");
          SYNTAX("or    %0, %1");
#line 935 "rl78-decode.opc"
#line 940 "rl78-decode.opc"
          ID(or); DR(A); SM(None, SADDR); Fz;
          ID(or); DR(A); SM(None, SADDR); Fz;
 
 
        }
        }
      break;
      break;
    case 0x6c:
    case 0x6c:
Line 3260... Line 3260...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0110 1100                     or      %0, #%1                         */",
                     "/** 0110 1100                     or      %0, #%1                         */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("or    %0, #%1");
          SYNTAX("or    %0, #%1");
#line 926 "rl78-decode.opc"
#line 931 "rl78-decode.opc"
          ID(or); DR(A); SC(IMMU(1)); Fz;
          ID(or); DR(A); SC(IMMU(1)); Fz;
 
 
        }
        }
      break;
      break;
    case 0x6d:
    case 0x6d:
Line 3275... Line 3275...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0110 1101                     or      %0, %e1%1                       */",
                     "/** 0110 1101                     or      %0, %e1%1                       */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("or    %0, %e1%1");
          SYNTAX("or    %0, %e1%1");
#line 914 "rl78-decode.opc"
#line 919 "rl78-decode.opc"
          ID(or); DR(A); SM(HL, 0); Fz;
          ID(or); DR(A); SM(HL, 0); Fz;
 
 
        }
        }
      break;
      break;
    case 0x6e:
    case 0x6e:
Line 3290... Line 3290...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0110 1110                     or      %0, %e1%1                       */",
                     "/** 0110 1110                     or      %0, %e1%1                       */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("or    %0, %e1%1");
          SYNTAX("or    %0, %e1%1");
#line 920 "rl78-decode.opc"
#line 925 "rl78-decode.opc"
          ID(or); DR(A); SM(HL, IMMU(1)); Fz;
          ID(or); DR(A); SM(HL, IMMU(1)); Fz;
 
 
        }
        }
      break;
      break;
    case 0x6f:
    case 0x6f:
Line 3305... Line 3305...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0110 1111                     or      %0, %e1%!1                      */",
                     "/** 0110 1111                     or      %0, %e1%!1                      */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("or    %0, %e1%!1");
          SYNTAX("or    %0, %e1%!1");
#line 911 "rl78-decode.opc"
#line 916 "rl78-decode.opc"
          ID(or); DR(A); SM(None, IMMU(2)); Fz;
          ID(or); DR(A); SM(None, IMMU(2)); Fz;
 
 
        }
        }
      break;
      break;
    case 0x70:
    case 0x70:
Line 3348... Line 3348...
          case 0x50:
          case 0x50:
          case 0x60:
          case 0x60:
          case 0x70:
          case 0x70:
              {
              {
                /** 0111 0001 0bit 0000         set1    %e0%!0                          */
                /** 0111 0001 0bit 0000         set1    %e0%!0                          */
#line 1017 "rl78-decode.opc"
#line 1022 "rl78-decode.opc"
                int bit AU = (op[1] >> 4) & 0x07;
                int bit AU = (op[1] >> 4) & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0111 0001 0bit 0000             set1    %e0%!0                          */",
                           "/** 0111 0001 0bit 0000             set1    %e0%!0                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  bit = 0x%x\n", bit);
                    printf ("  bit = 0x%x\n", bit);
                  }
                  }
                SYNTAX("set1    %e0%!0");
                SYNTAX("set1    %e0%!0");
#line 1017 "rl78-decode.opc"
#line 1022 "rl78-decode.opc"
                ID(mov); DM(None, IMMU(2)); DB(bit); SC(1);
                ID(mov); DM(None, IMMU(2)); DB(bit); SC(1);
 
 
              }
              }
            break;
            break;
          case 0x01:
          case 0x01:
Line 3398... Line 3398...
          case 0x52:
          case 0x52:
          case 0x62:
          case 0x62:
          case 0x72:
          case 0x72:
              {
              {
                /** 0111 0001 0bit 0010         set1    %0                              */
                /** 0111 0001 0bit 0010         set1    %0                              */
#line 1035 "rl78-decode.opc"
#line 1040 "rl78-decode.opc"
                int bit AU = (op[1] >> 4) & 0x07;
                int bit AU = (op[1] >> 4) & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0111 0001 0bit 0010             set1    %0                              */",
                           "/** 0111 0001 0bit 0010             set1    %0                              */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  bit = 0x%x\n", bit);
                    printf ("  bit = 0x%x\n", bit);
                  }
                  }
                SYNTAX("set1    %0");
                SYNTAX("set1    %0");
#line 1035 "rl78-decode.opc"
#line 1040 "rl78-decode.opc"
                ID(mov); DM(None, SADDR); DB(bit); SC(1);
                ID(mov); DM(None, SADDR); DB(bit); SC(1);
 
 
              /*----------------------------------------------------------------------*/
              /*----------------------------------------------------------------------*/
 
 
              }
              }
Line 3507... Line 3507...
          case 0x56:
          case 0x56:
          case 0x66:
          case 0x66:
          case 0x76:
          case 0x76:
              {
              {
                /** 0111 0001 0bit 0110         or1     cy, %s1                         */
                /** 0111 0001 0bit 0110         or1     cy, %s1                         */
#line 952 "rl78-decode.opc"
#line 957 "rl78-decode.opc"
                int bit AU = (op[1] >> 4) & 0x07;
                int bit AU = (op[1] >> 4) & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0111 0001 0bit 0110             or1     cy, %s1                         */",
                           "/** 0111 0001 0bit 0110             or1     cy, %s1                         */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  bit = 0x%x\n", bit);
                    printf ("  bit = 0x%x\n", bit);
                  }
                  }
                SYNTAX("or1     cy, %s1");
                SYNTAX("or1     cy, %s1");
#line 952 "rl78-decode.opc"
#line 957 "rl78-decode.opc"
                ID(or); DCY(); SM(None, SADDR); SB(bit);
                ID(or); DCY(); SM(None, SADDR); SB(bit);
 
 
              /*----------------------------------------------------------------------*/
              /*----------------------------------------------------------------------*/
 
 
              }
              }
Line 3534... Line 3534...
          case 0x57:
          case 0x57:
          case 0x67:
          case 0x67:
          case 0x77:
          case 0x77:
              {
              {
                /** 0111 0001 0bit 0111         xor1    cy, %s1                         */
                /** 0111 0001 0bit 0111         xor1    cy, %s1                         */
#line 1256 "rl78-decode.opc"
#line 1261 "rl78-decode.opc"
                int bit AU = (op[1] >> 4) & 0x07;
                int bit AU = (op[1] >> 4) & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0111 0001 0bit 0111             xor1    cy, %s1                         */",
                           "/** 0111 0001 0bit 0111             xor1    cy, %s1                         */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  bit = 0x%x\n", bit);
                    printf ("  bit = 0x%x\n", bit);
                  }
                  }
                SYNTAX("xor1    cy, %s1");
                SYNTAX("xor1    cy, %s1");
#line 1256 "rl78-decode.opc"
#line 1261 "rl78-decode.opc"
                ID(xor); DCY(); SM(None, SADDR); SB(bit);
                ID(xor); DCY(); SM(None, SADDR); SB(bit);
 
 
              /*----------------------------------------------------------------------*/
              /*----------------------------------------------------------------------*/
 
 
              }
              }
Line 3613... Line 3613...
          case 0x5a:
          case 0x5a:
          case 0x6a:
          case 0x6a:
          case 0x7a:
          case 0x7a:
              {
              {
                /** 0111 0001 0bit 1010         set1    %s0                             */
                /** 0111 0001 0bit 1010         set1    %s0                             */
#line 1029 "rl78-decode.opc"
#line 1034 "rl78-decode.opc"
                int bit AU = (op[1] >> 4) & 0x07;
                int bit AU = (op[1] >> 4) & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0111 0001 0bit 1010             set1    %s0                             */",
                           "/** 0111 0001 0bit 1010             set1    %s0                             */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  bit = 0x%x\n", bit);
                    printf ("  bit = 0x%x\n", bit);
                  }
                  }
                SYNTAX("set1    %s0");
                SYNTAX("set1    %s0");
#line 1029 "rl78-decode.opc"
#line 1034 "rl78-decode.opc"
                op0 = SFR;
                op0 = SFR;
                ID(mov); DM(None, op0); DB(bit); SC(1);
                ID(mov); DM(None, op0); DB(bit); SC(1);
                if (op0 == RL78_SFR_PSW && bit == 7)
                if (op0 == RL78_SFR_PSW && bit == 7)
                  rl78->syntax = "ei";
                  rl78->syntax = "ei";
 
 
Line 3719... Line 3719...
          case 0x5e:
          case 0x5e:
          case 0x6e:
          case 0x6e:
          case 0x7e:
          case 0x7e:
              {
              {
                /** 0111 0001 0bit 1110         or1     cy, %s1                         */
                /** 0111 0001 0bit 1110         or1     cy, %s1                         */
#line 949 "rl78-decode.opc"
#line 954 "rl78-decode.opc"
                int bit AU = (op[1] >> 4) & 0x07;
                int bit AU = (op[1] >> 4) & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0111 0001 0bit 1110             or1     cy, %s1                         */",
                           "/** 0111 0001 0bit 1110             or1     cy, %s1                         */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  bit = 0x%x\n", bit);
                    printf ("  bit = 0x%x\n", bit);
                  }
                  }
                SYNTAX("or1     cy, %s1");
                SYNTAX("or1     cy, %s1");
#line 949 "rl78-decode.opc"
#line 954 "rl78-decode.opc"
                ID(or); DCY(); SM(None, SFR); SB(bit);
                ID(or); DCY(); SM(None, SFR); SB(bit);
 
 
              }
              }
            break;
            break;
          case 0x0f:
          case 0x0f:
Line 3744... Line 3744...
          case 0x5f:
          case 0x5f:
          case 0x6f:
          case 0x6f:
          case 0x7f:
          case 0x7f:
              {
              {
                /** 0111 0001 0bit 1111         xor1    cy, %s1                         */
                /** 0111 0001 0bit 1111         xor1    cy, %s1                         */
#line 1253 "rl78-decode.opc"
#line 1258 "rl78-decode.opc"
                int bit AU = (op[1] >> 4) & 0x07;
                int bit AU = (op[1] >> 4) & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0111 0001 0bit 1111             xor1    cy, %s1                         */",
                           "/** 0111 0001 0bit 1111             xor1    cy, %s1                         */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  bit = 0x%x\n", bit);
                    printf ("  bit = 0x%x\n", bit);
                  }
                  }
                SYNTAX("xor1    cy, %s1");
                SYNTAX("xor1    cy, %s1");
#line 1253 "rl78-decode.opc"
#line 1258 "rl78-decode.opc"
                ID(xor); DCY(); SM(None, SFR); SB(bit);
                ID(xor); DCY(); SM(None, SFR); SB(bit);
 
 
              }
              }
            break;
            break;
          case 0x80:
          case 0x80:
Line 3769... Line 3769...
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0111 0001 1000 0000             set1    cy                              */",
                           "/** 0111 0001 1000 0000             set1    cy                              */",
                           op[0], op[1]);
                           op[0], op[1]);
                  }
                  }
                SYNTAX("set1    cy");
                SYNTAX("set1    cy");
#line 1026 "rl78-decode.opc"
#line 1031 "rl78-decode.opc"
                ID(mov); DCY(); SC(1);
                ID(mov); DCY(); SC(1);
 
 
              }
              }
            break;
            break;
          case 0x81:
          case 0x81:
Line 3809... Line 3809...
          case 0xd2:
          case 0xd2:
          case 0xe2:
          case 0xe2:
          case 0xf2:
          case 0xf2:
              {
              {
                /** 0111 0001 1bit 0010         set1    %e0%0                           */
                /** 0111 0001 1bit 0010         set1    %e0%0                           */
#line 1020 "rl78-decode.opc"
#line 1025 "rl78-decode.opc"
                int bit AU = (op[1] >> 4) & 0x07;
                int bit AU = (op[1] >> 4) & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0111 0001 1bit 0010             set1    %e0%0                           */",
                           "/** 0111 0001 1bit 0010             set1    %e0%0                           */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  bit = 0x%x\n", bit);
                    printf ("  bit = 0x%x\n", bit);
                  }
                  }
                SYNTAX("set1    %e0%0");
                SYNTAX("set1    %e0%0");
#line 1020 "rl78-decode.opc"
#line 1025 "rl78-decode.opc"
                ID(mov); DM(HL, 0); DB(bit); SC(1);
                ID(mov); DM(HL, 0); DB(bit); SC(1);
 
 
              }
              }
            break;
            break;
          case 0x83:
          case 0x83:
Line 3909... Line 3909...
          case 0xd6:
          case 0xd6:
          case 0xe6:
          case 0xe6:
          case 0xf6:
          case 0xf6:
              {
              {
                /** 0111 0001 1bit 0110         or1     cy, %e1%1                       */
                /** 0111 0001 1bit 0110         or1     cy, %e1%1                       */
#line 943 "rl78-decode.opc"
#line 948 "rl78-decode.opc"
                int bit AU = (op[1] >> 4) & 0x07;
                int bit AU = (op[1] >> 4) & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0111 0001 1bit 0110             or1     cy, %e1%1                       */",
                           "/** 0111 0001 1bit 0110             or1     cy, %e1%1                       */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  bit = 0x%x\n", bit);
                    printf ("  bit = 0x%x\n", bit);
                  }
                  }
                SYNTAX("or1     cy, %e1%1");
                SYNTAX("or1     cy, %e1%1");
#line 943 "rl78-decode.opc"
#line 948 "rl78-decode.opc"
                ID(or); DCY(); SM(HL, 0); SB(bit);
                ID(or); DCY(); SM(HL, 0); SB(bit);
 
 
              }
              }
            break;
            break;
          case 0x87:
          case 0x87:
Line 3934... Line 3934...
          case 0xd7:
          case 0xd7:
          case 0xe7:
          case 0xe7:
          case 0xf7:
          case 0xf7:
              {
              {
                /** 0111 0001 1bit 0111         xor1    cy, %e1%1                       */
                /** 0111 0001 1bit 0111         xor1    cy, %e1%1                       */
#line 1247 "rl78-decode.opc"
#line 1252 "rl78-decode.opc"
                int bit AU = (op[1] >> 4) & 0x07;
                int bit AU = (op[1] >> 4) & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0111 0001 1bit 0111             xor1    cy, %e1%1                       */",
                           "/** 0111 0001 1bit 0111             xor1    cy, %e1%1                       */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  bit = 0x%x\n", bit);
                    printf ("  bit = 0x%x\n", bit);
                  }
                  }
                SYNTAX("xor1    cy, %e1%1");
                SYNTAX("xor1    cy, %e1%1");
#line 1247 "rl78-decode.opc"
#line 1252 "rl78-decode.opc"
                ID(xor); DCY(); SM(HL, 0); SB(bit);
                ID(xor); DCY(); SM(HL, 0); SB(bit);
 
 
              }
              }
            break;
            break;
          case 0x88:
          case 0x88:
Line 3999... Line 3999...
          case 0xda:
          case 0xda:
          case 0xea:
          case 0xea:
          case 0xfa:
          case 0xfa:
              {
              {
                /** 0111 0001 1bit 1010         set1    %0                              */
                /** 0111 0001 1bit 1010         set1    %0                              */
#line 1023 "rl78-decode.opc"
#line 1028 "rl78-decode.opc"
                int bit AU = (op[1] >> 4) & 0x07;
                int bit AU = (op[1] >> 4) & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0111 0001 1bit 1010             set1    %0                              */",
                           "/** 0111 0001 1bit 1010             set1    %0                              */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  bit = 0x%x\n", bit);
                    printf ("  bit = 0x%x\n", bit);
                  }
                  }
                SYNTAX("set1    %0");
                SYNTAX("set1    %0");
#line 1023 "rl78-decode.opc"
#line 1028 "rl78-decode.opc"
                ID(mov); DR(A); DB(bit); SC(1);
                ID(mov); DR(A); DB(bit); SC(1);
 
 
              }
              }
            break;
            break;
          case 0x8b:
          case 0x8b:
Line 4099... Line 4099...
          case 0xde:
          case 0xde:
          case 0xee:
          case 0xee:
          case 0xfe:
          case 0xfe:
              {
              {
                /** 0111 0001 1bit 1110         or1     cy, %1                          */
                /** 0111 0001 1bit 1110         or1     cy, %1                          */
#line 946 "rl78-decode.opc"
#line 951 "rl78-decode.opc"
                int bit AU = (op[1] >> 4) & 0x07;
                int bit AU = (op[1] >> 4) & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0111 0001 1bit 1110             or1     cy, %1                          */",
                           "/** 0111 0001 1bit 1110             or1     cy, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  bit = 0x%x\n", bit);
                    printf ("  bit = 0x%x\n", bit);
                  }
                  }
                SYNTAX("or1     cy, %1");
                SYNTAX("or1     cy, %1");
#line 946 "rl78-decode.opc"
#line 951 "rl78-decode.opc"
                ID(or); DCY(); SR(A); SB(bit);
                ID(or); DCY(); SR(A); SB(bit);
 
 
              }
              }
            break;
            break;
          case 0x8f:
          case 0x8f:
Line 4124... Line 4124...
          case 0xdf:
          case 0xdf:
          case 0xef:
          case 0xef:
          case 0xff:
          case 0xff:
              {
              {
                /** 0111 0001 1bit 1111         xor1    cy, %1                          */
                /** 0111 0001 1bit 1111         xor1    cy, %1                          */
#line 1250 "rl78-decode.opc"
#line 1255 "rl78-decode.opc"
                int bit AU = (op[1] >> 4) & 0x07;
                int bit AU = (op[1] >> 4) & 0x07;
                if (trace)
                if (trace)
                  {
                  {
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
                           "/** 0111 0001 1bit 1111             xor1    cy, %1                          */",
                           "/** 0111 0001 1bit 1111             xor1    cy, %1                          */",
                           op[0], op[1]);
                           op[0], op[1]);
                    printf ("  bit = 0x%x\n", bit);
                    printf ("  bit = 0x%x\n", bit);
                  }
                  }
                SYNTAX("xor1    cy, %1");
                SYNTAX("xor1    cy, %1");
#line 1250 "rl78-decode.opc"
#line 1255 "rl78-decode.opc"
                ID(xor); DCY(); SR(A); SB(bit);
                ID(xor); DCY(); SR(A); SB(bit);
 
 
              }
              }
            break;
            break;
 
          case 0xc0:
 
              {
 
                /** 0111 0001 1100 0000         not1    cy                              */
 
                if (trace)
 
                  {
 
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
 
                           "/** 0111 0001 1100 0000             not1    cy                              */",
 
                           op[0], op[1]);
 
                  }
 
                SYNTAX("not1    cy");
 
#line 892 "rl78-decode.opc"
 
                ID(xor); DCY(); SC(1);
 
 
 
              /*----------------------------------------------------------------------*/
 
 
 
              }
 
            break;
          default: UNSUPPORTED(); break;
          default: UNSUPPORTED(); break;
        }
        }
      break;
      break;
    case 0x78:
    case 0x78:
        {
        {
Line 4182... Line 4199...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0111 1010                     xor     %0, #%1                         */",
                     "/** 0111 1010                     xor     %0, #%1                         */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("xor   %0, #%1");
          SYNTAX("xor   %0, #%1");
#line 1242 "rl78-decode.opc"
#line 1247 "rl78-decode.opc"
          ID(xor); DM(None, SADDR); SC(IMMU(1)); Fz;
          ID(xor); DM(None, SADDR); SC(IMMU(1)); Fz;
 
 
        /*----------------------------------------------------------------------*/
        /*----------------------------------------------------------------------*/
 
 
        }
        }
Line 4199... Line 4216...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0111 1011                     xor     %0, %1                          */",
                     "/** 0111 1011                     xor     %0, %1                          */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("xor   %0, %1");
          SYNTAX("xor   %0, %1");
#line 1239 "rl78-decode.opc"
#line 1244 "rl78-decode.opc"
          ID(xor); DR(A); SM(None, SADDR); Fz;
          ID(xor); DR(A); SM(None, SADDR); Fz;
 
 
        }
        }
      break;
      break;
    case 0x7c:
    case 0x7c:
Line 4214... Line 4231...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0111 1100                     xor     %0, #%1                         */",
                     "/** 0111 1100                     xor     %0, #%1                         */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("xor   %0, #%1");
          SYNTAX("xor   %0, #%1");
#line 1230 "rl78-decode.opc"
#line 1235 "rl78-decode.opc"
          ID(xor); DR(A); SC(IMMU(1)); Fz;
          ID(xor); DR(A); SC(IMMU(1)); Fz;
 
 
        }
        }
      break;
      break;
    case 0x7d:
    case 0x7d:
Line 4229... Line 4246...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0111 1101                     xor     %0, %e1%1                       */",
                     "/** 0111 1101                     xor     %0, %e1%1                       */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("xor   %0, %e1%1");
          SYNTAX("xor   %0, %e1%1");
#line 1218 "rl78-decode.opc"
#line 1223 "rl78-decode.opc"
          ID(xor); DR(A); SM(HL, 0); Fz;
          ID(xor); DR(A); SM(HL, 0); Fz;
 
 
        }
        }
      break;
      break;
    case 0x7e:
    case 0x7e:
Line 4244... Line 4261...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0111 1110                     xor     %0, %e1%1                       */",
                     "/** 0111 1110                     xor     %0, %e1%1                       */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("xor   %0, %e1%1");
          SYNTAX("xor   %0, %e1%1");
#line 1224 "rl78-decode.opc"
#line 1229 "rl78-decode.opc"
          ID(xor); DR(A); SM(HL, IMMU(1)); Fz;
          ID(xor); DR(A); SM(HL, IMMU(1)); Fz;
 
 
        }
        }
      break;
      break;
    case 0x7f:
    case 0x7f:
Line 4259... Line 4276...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 0111 1111                     xor     %0, %e1%!1                      */",
                     "/** 0111 1111                     xor     %0, %e1%!1                      */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("xor   %0, %e1%!1");
          SYNTAX("xor   %0, %e1%!1");
#line 1215 "rl78-decode.opc"
#line 1220 "rl78-decode.opc"
          ID(xor); DR(A); SM(None, IMMU(2)); Fz;
          ID(xor); DR(A); SM(None, IMMU(2)); Fz;
 
 
        }
        }
      break;
      break;
    case 0x80:
    case 0x80:
Line 4975... Line 4992...
    case 0xc2:
    case 0xc2:
    case 0xc4:
    case 0xc4:
    case 0xc6:
    case 0xc6:
        {
        {
          /** 1100 0rg0                 pop     %0                              */
          /** 1100 0rg0                 pop     %0                              */
#line 957 "rl78-decode.opc"
#line 962 "rl78-decode.opc"
          int rg AU = (op[0] >> 1) & 0x03;
          int rg AU = (op[0] >> 1) & 0x03;
          if (trace)
          if (trace)
            {
            {
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 1100 0rg0                     pop     %0                              */",
                     "/** 1100 0rg0                     pop     %0                              */",
                     op[0]);
                     op[0]);
              printf ("  rg = 0x%x\n", rg);
              printf ("  rg = 0x%x\n", rg);
            }
            }
          SYNTAX("pop   %0");
          SYNTAX("pop   %0");
#line 957 "rl78-decode.opc"
#line 962 "rl78-decode.opc"
          ID(mov); W(); DRW(rg); SPOP();
          ID(mov); W(); DRW(rg); SPOP();
 
 
        }
        }
      break;
      break;
    case 0xc1:
    case 0xc1:
    case 0xc3:
    case 0xc3:
    case 0xc5:
    case 0xc5:
    case 0xc7:
    case 0xc7:
        {
        {
          /** 1100 0rg1                 push    %1                              */
          /** 1100 0rg1                 push    %1                              */
#line 965 "rl78-decode.opc"
#line 970 "rl78-decode.opc"
          int rg AU = (op[0] >> 1) & 0x03;
          int rg AU = (op[0] >> 1) & 0x03;
          if (trace)
          if (trace)
            {
            {
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 1100 0rg1                     push    %1                              */",
                     "/** 1100 0rg1                     push    %1                              */",
                     op[0]);
                     op[0]);
              printf ("  rg = 0x%x\n", rg);
              printf ("  rg = 0x%x\n", rg);
            }
            }
          SYNTAX("push  %1");
          SYNTAX("push  %1");
#line 965 "rl78-decode.opc"
#line 970 "rl78-decode.opc"
          ID(mov); W(); DPUSH(); SRW(rg);
          ID(mov); W(); DPUSH(); SRW(rg);
 
 
        }
        }
      break;
      break;
    case 0xc8:
    case 0xc8:
Line 5235... Line 5252...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 1101 0111                     ret                                     */",
                     "/** 1101 0111                     ret                                     */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("ret");
          SYNTAX("ret");
#line 973 "rl78-decode.opc"
#line 978 "rl78-decode.opc"
          ID(ret);
          ID(ret);
 
 
        }
        }
      break;
      break;
    case 0xd8:
    case 0xd8:
Line 5378... Line 5395...
    case 0xe1:
    case 0xe1:
    case 0xe2:
    case 0xe2:
    case 0xe3:
    case 0xe3:
        {
        {
          /** 1110 00rg                 oneb    %0                              */
          /** 1110 00rg                 oneb    %0                              */
#line 895 "rl78-decode.opc"
#line 900 "rl78-decode.opc"
          int rg AU = op[0] & 0x03;
          int rg AU = op[0] & 0x03;
          if (trace)
          if (trace)
            {
            {
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 1110 00rg                     oneb    %0                              */",
                     "/** 1110 00rg                     oneb    %0                              */",
                     op[0]);
                     op[0]);
              printf ("  rg = 0x%x\n", rg);
              printf ("  rg = 0x%x\n", rg);
            }
            }
          SYNTAX("oneb  %0");
          SYNTAX("oneb  %0");
#line 895 "rl78-decode.opc"
#line 900 "rl78-decode.opc"
          ID(mov); DRB(rg); SC(1);
          ID(mov); DRB(rg); SC(1);
 
 
        }
        }
      break;
      break;
    case 0xe4:
    case 0xe4:
Line 5403... Line 5420...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 1110 0100                     oneb    %0                              */",
                     "/** 1110 0100                     oneb    %0                              */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("oneb  %0");
          SYNTAX("oneb  %0");
#line 898 "rl78-decode.opc"
#line 903 "rl78-decode.opc"
          ID(mov); DM(None, SADDR); SC(1);
          ID(mov); DM(None, SADDR); SC(1);
 
 
        /*----------------------------------------------------------------------*/
        /*----------------------------------------------------------------------*/
 
 
        }
        }
Line 5420... Line 5437...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 1110 0101                     oneb    %e0%!0                          */",
                     "/** 1110 0101                     oneb    %e0%!0                          */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("oneb  %e0%!0");
          SYNTAX("oneb  %e0%!0");
#line 892 "rl78-decode.opc"
#line 897 "rl78-decode.opc"
          ID(mov); DM(None, IMMU(2)); SC(1);
          ID(mov); DM(None, IMMU(2)); SC(1);
 
 
        }
        }
      break;
      break;
    case 0xe6:
    case 0xe6:
Line 5435... Line 5452...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 1110 0110                     onew    %0                              */",
                     "/** 1110 0110                     onew    %0                              */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("onew  %0");
          SYNTAX("onew  %0");
#line 903 "rl78-decode.opc"
#line 908 "rl78-decode.opc"
          ID(mov); DR(AX); SC(1);
          ID(mov); DR(AX); SC(1);
 
 
        }
        }
      break;
      break;
    case 0xe7:
    case 0xe7:
Line 5450... Line 5467...
              printf ("\033[33m%s\033[0m  %02x\n",
              printf ("\033[33m%s\033[0m  %02x\n",
                     "/** 1110 0111                     onew    %0                              */",
                     "/** 1110 0111                     onew    %0                              */",
                     op[0]);
                     op[0]);
            }
            }
          SYNTAX("onew  %0");
          SYNTAX("onew  %0");
#line 906 "rl78-decode.opc"
#line 911 "rl78-decode.opc"
          ID(mov); DR(BC); SC(1);
          ID(mov); DR(BC); SC(1);
 
 
        /*----------------------------------------------------------------------*/
        /*----------------------------------------------------------------------*/
 
 
        }
        }
Line 5723... Line 5740...
          ID(break);
          ID(break);
 
 
        }
        }
      break;
      break;
  }
  }
#line 1261 "rl78-decode.opc"
#line 1266 "rl78-decode.opc"
 
 
  return rl78->n_bytes;
  return rl78->n_bytes;
}
}
 
 
 No newline at end of file
 No newline at end of file

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.