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

Go to most recent revision | 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.