opcodes/msp430-decode.c

   1 #line 1 "msp430-decode.opc"
   2 /* -*- c -*- */
   3 #include "sysdep.h"
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include "ansidecl.h"
   8 #include "opcode/msp430-decode.h"
   9
  10 static int trace = 0;
  11
  12 typedef struct
  13 {
  14   MSP430_Opcode_Decoded * msp430;
  15   int (* getbyte)(void *);
  16   void * ptr;
  17   unsigned char * op;
  18   int op_ptr;
  19   int pc;
  20 } LocalData;
  21
  22 #define AU ATTRIBUTE_UNUSED
  23 #define GETBYTE() getbyte_swapped (ld)
  24 #define B ((unsigned long) GETBYTE ())
  25
  26 static int
  27 getbyte_swapped (LocalData *ld)
  28 {
  29   int b;
  30   if (ld->op_ptr == ld->msp430->n_bytes)
  31     {
  32       do {
  33         b = ld->getbyte (ld->ptr);
  34         /*fprintf(stderr, "[\033[32m%02x\033[0m]", b & 0xff);*/
  35         ld->op [(ld->msp430->n_bytes++)^1] = b;
  36       } while (ld->msp430->n_bytes & 1);
  37     }
  38   return ld->op[ld->op_ptr++];
  39 }
  40
  41 #define ID(x)           msp430->id = x
  42 #define OP(n, t, r, a) (msp430->op[n].type = t, \
  43                         msp430->op[n].reg = r,       \
  44                         msp430->op[n].addend = a)
  45 #define OPX(n, t, r1, r2, a) \
  46         (msp430->op[n].type = t, \
  47         msp430->op[n].reg = r1, \
  48         msp430->op[n].reg2 = r2, \
  49         msp430->op[n].addend = a)
  50
  51 #define SYNTAX(x)       msp430->syntax = x
  52 #define UNSUPPORTED() \
  53   msp430->syntax = "*unknown*"
  54
  55 #define DC(c)           OP (0, MSP430_Operand_Immediate, 0, c)
  56 #define DR(r)           OP (0, MSP430_Operand_Register, r, 0)
  57 #define DM(r, a)        OP (0, MSP430_Operand_Indirect, r, a)
  58 #define DA(a)           OP (0, MSP430_Operand_Indirect, MSR_None, a)
  59 #define AD(r, ad)       encode_ad (r, ad, ld, 0)
  60 #define ADX(r, ad, x)   encode_ad (r, ad, ld, x)
  61
  62 #define SC(c)           OP (1, MSP430_Operand_Immediate, 0, c)
  63 #define SR(r)           OP (1, MSP430_Operand_Register, r, 0)
  64 #define SM(r, a)        OP (1, MSP430_Operand_Indirect, r, a)
  65 #define SA(a)           OP (1, MSP430_Operand_Indirect, MSR_None, a)
  66 #define SI(r)           OP (1, MSP430_Operand_Indirect_Postinc, r, 0)
  67 #define AS(r, as)       encode_as (r, as, ld, 0)
  68 #define ASX(r, as, x)   encode_as (r, as, ld, x)
  69
  70 #define BW(x)           msp430->size = (x ? 8 : 16)
  71 /* The last 20 is for SWPBX.Z and SXTX.A */
  72 #define ABW(a, x)       msp430->size = (a ? ((x ? 8 : 16)) : (x ? 20 : 20))
  73
  74 #define IMMU(bytes)     immediate (bytes, 0, ld)
  75 #define IMMS(bytes)     immediate (bytes, 1, ld)
  76
  77 /* Helper macros for known status bits settings */
  78 #define F_____          msp430->flags_1 = msp430->flags_0 = 0; msp430->flags_set = 0
  79 #define F_VNZC          msp430->flags_1 = msp430->flags_0 = 0; msp430->flags_set = 0x87
  80 #define F_0NZC          msp430->flags_1 = 0; msp430->flags_0 = 0x80; msp430->flags_set = 0x07
  81
  82
  83 /* The chip is little-endian, but GETBYTE byte-swaps words because the
  84    decoder is based on 16-bit "words" so *this* logic is big-endian.  */
  85 static int
  86 immediate (int bytes, int sign_extend, LocalData * ld)
  87 {
  88   unsigned long i = 0;
  89
  90   switch (bytes)
  91     {
  92     case 1:
  93       i |= B;
  94       if (sign_extend && (i & 0x80))
  95         i -= 0x100;
  96       break;
  97     case 2:
  98       i |= B << 8;
  99       i |= B;
 100       if (sign_extend && (i & 0x8000))
 101         i -= 0x10000;
 102       break;
 103     case 3:
 104       i |= B << 16;
 105       i |= B << 8;
 106       i |= B;
 107       if (sign_extend && (i & 0x800000))
 108         i -= 0x1000000;
 109       break;
 110     case 4:
 111       i |= B << 24;
 112       i |= B << 16;
 113       i |= B << 8;
 114       i |= B;
 115       if (sign_extend && (i & 0x80000000ULL))
 116         i -= 0x100000000ULL;
 117       break;
 118     default:
 119       fprintf (stderr, "Programmer error: immediate() called with invalid byte count %d\n", bytes);
 120       abort();
 121     }
 122   /*fprintf(stderr, "\033[35mIMM(%d,%d,%#lx)\033[0m", bytes, sign_extend, i);*/
 123   return i;
 124 }
 125
 126 /*
 127                 PC      SP      SR      CG
 128   As
 129   00    Rn      -       -       R2      #0
 130   01    X(Rn)   Sym     -       X(abs)  #1
 131   10    (Rn)    -       -       #4      #2
 132   11    (Rn++)  #imm    -       #8      #-1
 133
 134   Ad
 135   0     Rn      -       -       -       -
 136   1     X(Rn)   Sym     -       X(abs)  -
 137  */
 138
 139 static void
 140 encode_ad (int reg, int ad, LocalData *ld, int ext)
 141 {
 142   MSP430_Opcode_Decoded * msp430 = ld->msp430;
 143
 144   /*fprintf(stderr, "[\033[31mAD %d R%d\033[0m]", ad, reg);*/
 145   if (ad)
 146     {
 147       int x = IMMU(2) | (ext << 16);
 148       switch (reg)
 149         {
 150         case 0: /* (PC) -> Symbolic */
 151           DA (x + ld->pc + ld->op_ptr - 2);
 152           break;
 153         case 2: /* (SR) -> Absolute */
 154           DA (x);
 155           break;
 156         default:
 157           DM (reg, x);
 158           break;
 159         }
 160     }
 161   else
 162     {
 163       DR (reg);
 164     }
 165 }
 166
 167 static void
 168 encode_as (int reg, int as, LocalData *ld, int ext)
 169 {
 170   MSP430_Opcode_Decoded * msp430 = ld->msp430;
 171   int x;
 172
 173   /*fprintf(stderr, "[\033[31mAS %d R%d\033[0m]", as, reg);*/
 174   switch (as)
 175     {
 176     case 0:
 177       switch (reg)
 178         {
 179         case 3:
 180           SC (0);
 181           break;
 182         default:
 183           SR (reg);
 184           break;
 185         }
 186       break;
 187     case 1:
 188       switch (reg)
 189         {
 190         case 0: /* PC -> Symbolic */
 191           x = IMMU(2) | (ext << 16);
 192           SA (x + ld->pc + ld->op_ptr - 2);
 193           break;
 194         case 2: /* SR -> Absolute */
 195           x = IMMU(2) | (ext << 16);
 196           SA (x);
 197           break;
 198         case 3:
 199           SC (1);
 200           break;
 201         default:
 202           x = IMMU(2) | (ext << 16);
 203           SM (reg, x);
 204           break;
 205         }
 206       break;
 207     case 2:
 208       switch (reg)
 209         {
 210         case 2:
 211           SC (4);
 212           break;
 213         case 3:
 214           SC (2);
 215           break;
 216         case MSR_None:
 217           SA (0);
 218         default:
 219           SM (reg, 0);
 220           break;
 221         }
 222       break;
 223     case 3:
 224       switch (reg)
 225         {
 226         case 0:
 227           {
 228             /* This fetch *is* the *PC++ that the opcode encodes :-)  */
 229             x = IMMU(2) | (ext << 16);
 230             SC (x);
 231           }
 232           break;
 233         case 2:
 234           SC (8);
 235           break;
 236         case 3:
 237           SC (-1);
 238           break;
 239         default:
 240           SI (reg);
 241           break;
 242         }
 243       break;
 244     }
 245 }
 246
 247 static void
 248 encode_rep_zc (int srxt, int dsxt, LocalData *ld)
 249 {
 250   MSP430_Opcode_Decoded * msp430 = ld->msp430;
 251
 252   msp430->repeat_reg = srxt & 1;
 253   msp430->repeats = dsxt;
 254   msp430->zc = (srxt & 2) ? 1 : 0;
 255 }
 256
 257 #define REPZC(s,d) encode_rep_zc (s, d, ld)
 258
 259 static int
 260 dopc_to_id (int dopc)
 261 {
 262   switch (dopc)
 263     {
 264     case 4: return MSO_mov;
 265     case 5: return MSO_add;
 266     case 6: return MSO_addc;
 267     case 7: return MSO_subc;
 268     case 8: return MSO_sub;
 269     case 9: return MSO_cmp;
 270     case 10: return MSO_dadd;
 271     case 11: return MSO_bit;
 272     case 12: return MSO_bic;
 273     case 13: return MSO_bis;
 274     case 14: return MSO_xor;
 275     case 15: return MSO_and;
 276     default:
 277       return MSO_unknown;
 278     }
 279 }
 280
 281 static int
 282 sopc_to_id (int sop,int c)
 283 {
 284   switch (sop*2+c)
 285     {
 286     case 0: return MSO_rrc;
 287     case 1: return MSO_swpb;
 288     case 2: return MSO_rra;
 289     case 3: return MSO_sxt;
 290     case 4: return MSO_push;
 291     case 5: return MSO_call;
 292     case 6: return MSO_reti;
 293     default:
 294       return MSO_unknown;
 295     }
 296 }
 297
 298 int
 299 msp430_decode_opcode (unsigned long pc,
 300                       MSP430_Opcode_Decoded * msp430,
 301                       int (* getbyte)(void *),
 302                       void * ptr)
 303 {
 304   LocalData lds, * ld = &lds;
 305   unsigned char op_buf[20] = {0};
 306   unsigned char *op = op_buf;
 307   int raddr;
 308   int al_bit;
 309   int srxt_bits, dsxt_bits;
 310
 311   lds.msp430 = msp430;
 312   lds.getbyte = getbyte;
 313   lds.ptr = ptr;
 314   lds.op = op;
 315   lds.op_ptr = 0;
 316   lds.pc = pc;
 317
 318   memset (msp430, 0, sizeof (*msp430));
 319
 320   /* These are overridden by an extension word.  */
 321   al_bit = 1;
 322   srxt_bits = 0;
 323   dsxt_bits = 0;
 324
 325  post_extension_word:
 326   ;
 327
 328   /* 430X extention word.  */
 329   GETBYTE ();
 330   switch (op[0] & 0xff)
 331   {
 332     case 0x00:
 333         GETBYTE ();
 334         switch (op[1] & 0xf0)
 335         {
 336           case 0x00:
 337             op_semantics_1:
 338               {
 339                 /** 0000 srcr 0000 dstr         MOVA @%1, %0 */
 340 #line 419 "msp430-decode.opc"
 341                 int srcr AU = op[0] & 0x0f;
 342 #line 419 "msp430-decode.opc"
 343                 int dstr AU = op[1] & 0x0f;
 344                 if (trace)
 345                   {
 346                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 347                            "/** 0000 srcr 0000 dstr             MOVA @%1, %0 */",
 348                            op[0], op[1]);
 349                     printf ("  srcr = 0x%x,", srcr);
 350                     printf ("  dstr = 0x%x\n", dstr);
 351                   }
 352                 SYNTAX("MOVA @%1, %0");
 353 #line 419 "msp430-decode.opc"
 354                 ID (MSO_mov); SM (srcr, 0); DR (dstr);
 355                 msp430->size = 20;
 356                 msp430->ofs_430x = 1;
 357
 358               }
 359             break;
 360           case 0x10:
 361             op_semantics_2:
 362               {
 363                 /** 0000 srcr 0001 dstr         MOVA @%1+, %0 */
 364 #line 424 "msp430-decode.opc"
 365                 int srcr AU = op[0] & 0x0f;
 366 #line 424 "msp430-decode.opc"
 367                 int dstr AU = op[1] & 0x0f;
 368                 if (trace)
 369                   {
 370                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 371                            "/** 0000 srcr 0001 dstr             MOVA @%1+, %0 */",
 372                            op[0], op[1]);
 373                     printf ("  srcr = 0x%x,", srcr);
 374                     printf ("  dstr = 0x%x\n", dstr);
 375                   }
 376                 SYNTAX("MOVA @%1+, %0");
 377 #line 424 "msp430-decode.opc"
 378                 ID (MSO_mov); SI (srcr); DR (dstr);
 379                 msp430->size = 20;
 380                 msp430->ofs_430x = 1;
 381
 382               }
 383             break;
 384           case 0x20:
 385             op_semantics_3:
 386               {
 387                 /** 0000 srcr 0010 dstr         MOVA &%1, %0 */
 388 #line 429 "msp430-decode.opc"
 389                 int srcr AU = op[0] & 0x0f;
 390 #line 429 "msp430-decode.opc"
 391                 int dstr AU = op[1] & 0x0f;
 392                 if (trace)
 393                   {
 394                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 395                            "/** 0000 srcr 0010 dstr             MOVA &%1, %0 */",
 396                            op[0], op[1]);
 397                     printf ("  srcr = 0x%x,", srcr);
 398                     printf ("  dstr = 0x%x\n", dstr);
 399                   }
 400                 SYNTAX("MOVA &%1, %0");
 401 #line 429 "msp430-decode.opc"
 402                 ID (MSO_mov); SA ((srcr << 16) + IMMU(2)); DR (dstr);
 403                 msp430->size = 20;
 404                 msp430->ofs_430x = 1;
 405
 406               }
 407             break;
 408           case 0x30:
 409             op_semantics_4:
 410               {
 411                 /** 0000 srcr 0011 dstr         MOVA %1, %0 */
 412 #line 434 "msp430-decode.opc"
 413                 int srcr AU = op[0] & 0x0f;
 414 #line 434 "msp430-decode.opc"
 415                 int dstr AU = op[1] & 0x0f;
 416                 if (trace)
 417                   {
 418                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 419                            "/** 0000 srcr 0011 dstr             MOVA %1, %0 */",
 420                            op[0], op[1]);
 421                     printf ("  srcr = 0x%x,", srcr);
 422                     printf ("  dstr = 0x%x\n", dstr);
 423                   }
 424                 SYNTAX("MOVA %1, %0");
 425 #line 434 "msp430-decode.opc"
 426                 ID (MSO_mov); SM (srcr, IMMS(2)); DR (dstr);
 427                 msp430->size = 20;
 428                 msp430->ofs_430x = 1;
 429
 430               }
 431             break;
 432           case 0x40:
 433           case 0x50:
 434             op_semantics_5:
 435               {
 436                 /** 0000 bt00 010w dstr         RRCM.A %c, %0 */
 437 #line 501 "msp430-decode.opc"
 438                 int bt AU = (op[0] >> 2) & 0x03;
 439 #line 501 "msp430-decode.opc"
 440                 int w AU = (op[1] >> 4) & 0x01;
 441 #line 501 "msp430-decode.opc"
 442                 int dstr AU = op[1] & 0x0f;
 443                 if (trace)
 444                   {
 445                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 446                            "/** 0000 bt00 010w dstr             RRCM.A %c, %0 */",
 447                            op[0], op[1]);
 448                     printf ("  bt = 0x%x,", bt);
 449                     printf ("  w = 0x%x,", w);
 450                     printf ("  dstr = 0x%x\n", dstr);
 451                   }
 452                 SYNTAX("RRCM.A %c, %0");
 453 #line 501 "msp430-decode.opc"
 454                 ID (MSO_rrc); DR (dstr); SR (dstr);
 455                 msp430->repeats = bt;
 456                 msp430->size = w ? 16 : 20;
 457                 msp430->ofs_430x = 1;
 458                 F_0NZC;
 459
 460               }
 461             break;
 462           case 0x60:
 463             op_semantics_6:
 464               {
 465                 /** 0000 srcr 0110 dstr         MOVA %1, &%0 */
 466 #line 439 "msp430-decode.opc"
 467                 int srcr AU = op[0] & 0x0f;
 468 #line 439 "msp430-decode.opc"
 469                 int dstr AU = op[1] & 0x0f;
 470                 if (trace)
 471                   {
 472                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 473                            "/** 0000 srcr 0110 dstr             MOVA %1, &%0 */",
 474                            op[0], op[1]);
 475                     printf ("  srcr = 0x%x,", srcr);
 476                     printf ("  dstr = 0x%x\n", dstr);
 477                   }
 478                 SYNTAX("MOVA %1, &%0");
 479 #line 439 "msp430-decode.opc"
 480                 ID (MSO_mov); SR (srcr); DA ((dstr << 16) + IMMU(2));
 481                 msp430->size = 20;
 482                 msp430->ofs_430x = 1;
 483
 484               }
 485             break;
 486           case 0x70:
 487             op_semantics_7:
 488               {
 489                 /** 0000 srcr 0111 dstr         MOVA %1, &%0 */
 490 #line 444 "msp430-decode.opc"
 491                 int srcr AU = op[0] & 0x0f;
 492 #line 444 "msp430-decode.opc"
 493                 int dstr AU = op[1] & 0x0f;
 494                 if (trace)
 495                   {
 496                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 497                            "/** 0000 srcr 0111 dstr             MOVA %1, &%0 */",
 498                            op[0], op[1]);
 499                     printf ("  srcr = 0x%x,", srcr);
 500                     printf ("  dstr = 0x%x\n", dstr);
 501                   }
 502                 SYNTAX("MOVA %1, &%0");
 503 #line 444 "msp430-decode.opc"
 504                 ID (MSO_mov); SR (srcr); DM (dstr, IMMS(2));
 505                 msp430->size = 20;
 506                 msp430->ofs_430x = 1;
 507
 508               }
 509             break;
 510           case 0x80:
 511             op_semantics_8:
 512               {
 513                 /** 0000 srcr 1000 dstr         MOVA %1, %0 */
 514 #line 449 "msp430-decode.opc"
 515                 int srcr AU = op[0] & 0x0f;
 516 #line 449 "msp430-decode.opc"
 517                 int dstr AU = op[1] & 0x0f;
 518                 if (trace)
 519                   {
 520                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 521                            "/** 0000 srcr 1000 dstr             MOVA %1, %0 */",
 522                            op[0], op[1]);
 523                     printf ("  srcr = 0x%x,", srcr);
 524                     printf ("  dstr = 0x%x\n", dstr);
 525                   }
 526                 SYNTAX("MOVA %1, %0");
 527 #line 449 "msp430-decode.opc"
 528                 ID (MSO_mov); SC ((srcr << 16) + IMMU(2)); DR (dstr);
 529                 msp430->size = 20;
 530                 msp430->ofs_430x = 1;
 531
 532               }
 533             break;
 534           case 0x90:
 535             op_semantics_9:
 536               {
 537                 /** 0000 srcr 1001 dstr         CMPA %1, %0 */
 538 #line 454 "msp430-decode.opc"
 539                 int srcr AU = op[0] & 0x0f;
 540 #line 454 "msp430-decode.opc"
 541                 int dstr AU = op[1] & 0x0f;
 542                 if (trace)
 543                   {
 544                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 545                            "/** 0000 srcr 1001 dstr             CMPA %1, %0 */",
 546                            op[0], op[1]);
 547                     printf ("  srcr = 0x%x,", srcr);
 548                     printf ("  dstr = 0x%x\n", dstr);
 549                   }
 550                 SYNTAX("CMPA %1, %0");
 551 #line 454 "msp430-decode.opc"
 552                 ID (MSO_cmp); SC ((srcr << 16) + IMMU(2)); DR (dstr);
 553                 msp430->size = 20;
 554                 msp430->ofs_430x = 1;
 555                 F_VNZC;
 556
 557               }
 558             break;
 559           case 0xa0:
 560             op_semantics_10:
 561               {
 562                 /** 0000 srcr 1010 dstr         ADDA %1, %0 */
 563 #line 460 "msp430-decode.opc"
 564                 int srcr AU = op[0] & 0x0f;
 565 #line 460 "msp430-decode.opc"
 566                 int dstr AU = op[1] & 0x0f;
 567                 if (trace)
 568                   {
 569                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 570                            "/** 0000 srcr 1010 dstr             ADDA %1, %0 */",
 571                            op[0], op[1]);
 572                     printf ("  srcr = 0x%x,", srcr);
 573                     printf ("  dstr = 0x%x\n", dstr);
 574                   }
 575                 SYNTAX("ADDA %1, %0");
 576 #line 460 "msp430-decode.opc"
 577                 ID (MSO_add); SC ((srcr << 16) + IMMU(2)); DR (dstr);
 578                 msp430->size = 20;
 579                 msp430->ofs_430x = 1;
 580                 F_VNZC;
 581
 582               }
 583             break;
 584           case 0xb0:
 585             op_semantics_11:
 586               {
 587                 /** 0000 srcr 1011 dstr         SUBA %1, %0 */
 588 #line 466 "msp430-decode.opc"
 589                 int srcr AU = op[0] & 0x0f;
 590 #line 466 "msp430-decode.opc"
 591                 int dstr AU = op[1] & 0x0f;
 592                 if (trace)
 593                   {
 594                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 595                            "/** 0000 srcr 1011 dstr             SUBA %1, %0 */",
 596                            op[0], op[1]);
 597                     printf ("  srcr = 0x%x,", srcr);
 598                     printf ("  dstr = 0x%x\n", dstr);
 599                   }
 600                 SYNTAX("SUBA %1, %0");
 601 #line 466 "msp430-decode.opc"
 602                 ID (MSO_sub); SC ((srcr << 16) + IMMU(2)); DR (dstr);
 603                 msp430->size = 20;
 604                 msp430->ofs_430x = 1;
 605                 F_VNZC;
 606
 607               }
 608             break;
 609           case 0xc0:
 610             op_semantics_12:
 611               {
 612                 /** 0000 srcr 1100 dstr         MOVA %1, %0 */
 613 #line 478 "msp430-decode.opc"
 614                 int srcr AU = op[0] & 0x0f;
 615 #line 478 "msp430-decode.opc"
 616                 int dstr AU = op[1] & 0x0f;
 617                 if (trace)
 618                   {
 619                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 620                            "/** 0000 srcr 1100 dstr             MOVA %1, %0 */",
 621                            op[0], op[1]);
 622                     printf ("  srcr = 0x%x,", srcr);
 623                     printf ("  dstr = 0x%x\n", dstr);
 624                   }
 625                 SYNTAX("MOVA %1, %0");
 626 #line 478 "msp430-decode.opc"
 627                 ID (MSO_mov); SR (srcr); DR (dstr);
 628                 msp430->size = 20;
 629                 msp430->ofs_430x = 1;
 630
 631               }
 632             break;
 633           case 0xd0:
 634             op_semantics_13:
 635               {
 636                 /** 0000 srcr 1101 dstr         CMPA %1, %0 */
 637 #line 483 "msp430-decode.opc"
 638                 int srcr AU = op[0] & 0x0f;
 639 #line 483 "msp430-decode.opc"
 640                 int dstr AU = op[1] & 0x0f;
 641                 if (trace)
 642                   {
 643                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 644                            "/** 0000 srcr 1101 dstr             CMPA %1, %0 */",
 645                            op[0], op[1]);
 646                     printf ("  srcr = 0x%x,", srcr);
 647                     printf ("  dstr = 0x%x\n", dstr);
 648                   }
 649                 SYNTAX("CMPA %1, %0");
 650 #line 483 "msp430-decode.opc"
 651                 ID (MSO_cmp); SR (srcr); DR (dstr);
 652                 msp430->size = 20;
 653                 msp430->ofs_430x = 1;
 654                 F_VNZC;
 655
 656               }
 657             break;
 658           case 0xe0:
 659             op_semantics_14:
 660               {
 661                 /** 0000 srcr 1110 dstr         ADDA %1, %0 */
 662 #line 489 "msp430-decode.opc"
 663                 int srcr AU = op[0] & 0x0f;
 664 #line 489 "msp430-decode.opc"
 665                 int dstr AU = op[1] & 0x0f;
 666                 if (trace)
 667                   {
 668                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 669                            "/** 0000 srcr 1110 dstr             ADDA %1, %0 */",
 670                            op[0], op[1]);
 671                     printf ("  srcr = 0x%x,", srcr);
 672                     printf ("  dstr = 0x%x\n", dstr);
 673                   }
 674                 SYNTAX("ADDA %1, %0");
 675 #line 489 "msp430-decode.opc"
 676                 ID (MSO_add); SR (srcr); DR (dstr);
 677                 msp430->size = 20;
 678                 msp430->ofs_430x = 1;
 679                 F_VNZC;
 680
 681               }
 682             break;
 683           case 0xf0:
 684             op_semantics_15:
 685               {
 686                 /** 0000 srcr 1111 dstr         SUBA %1, %0 */
 687 #line 495 "msp430-decode.opc"
 688                 int srcr AU = op[0] & 0x0f;
 689 #line 495 "msp430-decode.opc"
 690                 int dstr AU = op[1] & 0x0f;
 691                 if (trace)
 692                   {
 693                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 694                            "/** 0000 srcr 1111 dstr             SUBA %1, %0 */",
 695                            op[0], op[1]);
 696                     printf ("  srcr = 0x%x,", srcr);
 697                     printf ("  dstr = 0x%x\n", dstr);
 698                   }
 699                 SYNTAX("SUBA %1, %0");
 700 #line 495 "msp430-decode.opc"
 701                 ID (MSO_sub); SR (srcr); DR (dstr);
 702                 msp430->size = 20;
 703                 msp430->ofs_430x = 1;
 704                 F_VNZC;
 705
 706               }
 707             break;
 708         }
 709       break;
 710     case 0x01:
 711         GETBYTE ();
 712         switch (op[1] & 0xf0)
 713         {
 714           case 0x00:
 715             goto op_semantics_1;
 716             break;
 717           case 0x10:
 718             goto op_semantics_2;
 719             break;
 720           case 0x20:
 721             goto op_semantics_3;
 722             break;
 723           case 0x30:
 724             goto op_semantics_4;
 725             break;
 726           case 0x40:
 727           case 0x50:
 728             op_semantics_16:
 729               {
 730                 /** 0000 bt01 010w dstr         RRAM.A %c, %0 */
 731 #line 508 "msp430-decode.opc"
 732                 int bt AU = (op[0] >> 2) & 0x03;
 733 #line 508 "msp430-decode.opc"
 734                 int w AU = (op[1] >> 4) & 0x01;
 735 #line 508 "msp430-decode.opc"
 736                 int dstr AU = op[1] & 0x0f;
 737                 if (trace)
 738                   {
 739                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 740                            "/** 0000 bt01 010w dstr             RRAM.A %c, %0 */",
 741                            op[0], op[1]);
 742                     printf ("  bt = 0x%x,", bt);
 743                     printf ("  w = 0x%x,", w);
 744                     printf ("  dstr = 0x%x\n", dstr);
 745                   }
 746                 SYNTAX("RRAM.A %c, %0");
 747 #line 508 "msp430-decode.opc"
 748                 ID (MSO_rra); DR (dstr); SR (dstr);
 749                 msp430->repeats = bt;
 750                 msp430->size = w ? 16 : 20;
 751                 msp430->ofs_430x = 1;
 752                 F_0NZC;
 753
 754               }
 755             break;
 756           case 0x60:
 757             goto op_semantics_6;
 758             break;
 759           case 0x70:
 760             goto op_semantics_7;
 761             break;
 762           case 0x80:
 763             goto op_semantics_8;
 764             break;
 765           case 0x90:
 766             goto op_semantics_9;
 767             break;
 768           case 0xa0:
 769             goto op_semantics_10;
 770             break;
 771           case 0xb0:
 772             goto op_semantics_11;
 773             break;
 774           case 0xc0:
 775             goto op_semantics_12;
 776             break;
 777           case 0xd0:
 778             goto op_semantics_13;
 779             break;
 780           case 0xe0:
 781             goto op_semantics_14;
 782             break;
 783           case 0xf0:
 784             goto op_semantics_15;
 785             break;
 786         }
 787       break;
 788     case 0x02:
 789         GETBYTE ();
 790         switch (op[1] & 0xf0)
 791         {
 792           case 0x00:
 793             goto op_semantics_1;
 794             break;
 795           case 0x10:
 796             goto op_semantics_2;
 797             break;
 798           case 0x20:
 799             goto op_semantics_3;
 800             break;
 801           case 0x30:
 802             goto op_semantics_4;
 803             break;
 804           case 0x40:
 805           case 0x50:
 806             op_semantics_17:
 807               {
 808                 /** 0000 bt10 010w dstr         RLAM.A %c, %0 */
 809 #line 515 "msp430-decode.opc"
 810                 int bt AU = (op[0] >> 2) & 0x03;
 811 #line 515 "msp430-decode.opc"
 812                 int w AU = (op[1] >> 4) & 0x01;
 813 #line 515 "msp430-decode.opc"
 814                 int dstr AU = op[1] & 0x0f;
 815                 if (trace)
 816                   {
 817                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 818                            "/** 0000 bt10 010w dstr             RLAM.A %c, %0 */",
 819                            op[0], op[1]);
 820                     printf ("  bt = 0x%x,", bt);
 821                     printf ("  w = 0x%x,", w);
 822                     printf ("  dstr = 0x%x\n", dstr);
 823                   }
 824                 SYNTAX("RLAM.A %c, %0");
 825 #line 515 "msp430-decode.opc"
 826                 ID (MSO_add); DR (dstr); SR (dstr);
 827                 msp430->repeats = bt;
 828                 msp430->size = w ? 16 : 20;
 829                 msp430->ofs_430x = 1;
 830                 F_0NZC;
 831
 832               }
 833             break;
 834           case 0x60:
 835             goto op_semantics_6;
 836             break;
 837           case 0x70:
 838             goto op_semantics_7;
 839             break;
 840           case 0x80:
 841             goto op_semantics_8;
 842             break;
 843           case 0x90:
 844             goto op_semantics_9;
 845             break;
 846           case 0xa0:
 847             goto op_semantics_10;
 848             break;
 849           case 0xb0:
 850             goto op_semantics_11;
 851             break;
 852           case 0xc0:
 853             goto op_semantics_12;
 854             break;
 855           case 0xd0:
 856             goto op_semantics_13;
 857             break;
 858           case 0xe0:
 859             goto op_semantics_14;
 860             break;
 861           case 0xf0:
 862             goto op_semantics_15;
 863             break;
 864         }
 865       break;
 866     case 0x03:
 867         GETBYTE ();
 868         switch (op[1] & 0xf0)
 869         {
 870           case 0x00:
 871             goto op_semantics_1;
 872             break;
 873           case 0x10:
 874             goto op_semantics_2;
 875             break;
 876           case 0x20:
 877             goto op_semantics_3;
 878             break;
 879           case 0x30:
 880             goto op_semantics_4;
 881             break;
 882           case 0x40:
 883           case 0x50:
 884             op_semantics_18:
 885               {
 886                 /** 0000 bt11 010w dstr         RRUM.A %c, %0 */
 887 #line 522 "msp430-decode.opc"
 888                 int bt AU = (op[0] >> 2) & 0x03;
 889 #line 522 "msp430-decode.opc"
 890                 int w AU = (op[1] >> 4) & 0x01;
 891 #line 522 "msp430-decode.opc"
 892                 int dstr AU = op[1] & 0x0f;
 893                 if (trace)
 894                   {
 895                     printf ("\033[33m%s\033[0m  %02x %02x\n",
 896                            "/** 0000 bt11 010w dstr             RRUM.A %c, %0 */",
 897                            op[0], op[1]);
 898                     printf ("  bt = 0x%x,", bt);
 899                     printf ("  w = 0x%x,", w);
 900                     printf ("  dstr = 0x%x\n", dstr);
 901                   }
 902                 SYNTAX("RRUM.A %c, %0");
 903 #line 522 "msp430-decode.opc"
 904                 ID (MSO_rru); DR (dstr); SR (dstr);
 905                 msp430->repeats = bt;
 906                 msp430->size = w ? 16 : 20;
 907                 msp430->ofs_430x = 1;
 908                 F_0NZC;
 909
 910               }
 911             break;
 912           case 0x60:
 913             goto op_semantics_6;
 914             break;
 915           case 0x70:
 916             goto op_semantics_7;
 917             break;
 918           case 0x80:
 919             goto op_semantics_8;
 920             break;
 921           case 0x90:
 922             goto op_semantics_9;
 923             break;
 924           case 0xa0:
 925             goto op_semantics_10;
 926             break;
 927           case 0xb0:
 928             goto op_semantics_11;
 929             break;
 930           case 0xc0:
 931             goto op_semantics_12;
 932             break;
 933           case 0xd0:
 934             goto op_semantics_13;
 935             break;
 936           case 0xe0:
 937             goto op_semantics_14;
 938             break;
 939           case 0xf0:
 940             goto op_semantics_15;
 941             break;
 942         }
 943       break;
 944     case 0x04:
 945         GETBYTE ();
 946         switch (op[1] & 0xf0)
 947         {
 948           case 0x00:
 949             goto op_semantics_1;
 950             break;
 951           case 0x10:
 952             goto op_semantics_2;
 953             break;
 954           case 0x20:
 955             goto op_semantics_3;
 956             break;
 957           case 0x30:
 958             goto op_semantics_4;
 959             break;
 960           case 0x40:
 961           case 0x50:
 962             goto op_semantics_5;
 963             break;
 964           case 0x60:
 965             goto op_semantics_6;
 966             break;
 967           case 0x70:
 968             goto op_semantics_7;
 969             break;
 970           case 0x80:
 971             goto op_semantics_8;
 972             break;
 973           case 0x90:
 974             goto op_semantics_9;
 975             break;
 976           case 0xa0:
 977             goto op_semantics_10;
 978             break;
 979           case 0xb0:
 980             goto op_semantics_11;
 981             break;
 982           case 0xc0:
 983             goto op_semantics_12;
 984             break;
 985           case 0xd0:
 986             goto op_semantics_13;
 987             break;
 988           case 0xe0:
 989             goto op_semantics_14;
 990             break;
 991           case 0xf0:
 992             goto op_semantics_15;
 993             break;
 994         }
 995       break;
 996     case 0x05:
 997         GETBYTE ();
 998         switch (op[1] & 0xf0)
 999         {
1000           case 0x00:
1001             goto op_semantics_1;
1002             break;
1003           case 0x10:
1004             goto op_semantics_2;
1005             break;
1006           case 0x20:
1007             goto op_semantics_3;
1008             break;
1009           case 0x30:
1010             goto op_semantics_4;
1011             break;
1012           case 0x40:
1013           case 0x50:
1014             goto op_semantics_16;
1015             break;
1016           case 0x60:
1017             goto op_semantics_6;
1018             break;
1019           case 0x70:
1020             goto op_semantics_7;
1021             break;
1022           case 0x80:
1023             goto op_semantics_8;
1024             break;
1025           case 0x90:
1026             goto op_semantics_9;
1027             break;
1028           case 0xa0:
1029             goto op_semantics_10;
1030             break;
1031           case 0xb0:
1032             goto op_semantics_11;
1033             break;
1034           case 0xc0:
1035             goto op_semantics_12;
1036             break;
1037           case 0xd0:
1038             goto op_semantics_13;
1039             break;
1040           case 0xe0:
1041             goto op_semantics_14;
1042             break;
1043           case 0xf0:
1044             goto op_semantics_15;
1045             break;
1046         }
1047       break;
1048     case 0x06:
1049         GETBYTE ();
1050         switch (op[1] & 0xf0)
1051         {
1052           case 0x00:
1053             goto op_semantics_1;
1054             break;
1055           case 0x10:
1056             goto op_semantics_2;
1057             break;
1058           case 0x20:
1059             goto op_semantics_3;
1060             break;
1061           case 0x30:
1062             goto op_semantics_4;
1063             break;
1064           case 0x40:
1065           case 0x50:
1066             goto op_semantics_17;
1067             break;
1068           case 0x60:
1069             goto op_semantics_6;
1070             break;
1071           case 0x70:
1072             goto op_semantics_7;
1073             break;
1074           case 0x80:
1075             goto op_semantics_8;
1076             break;
1077           case 0x90:
1078             goto op_semantics_9;
1079             break;
1080           case 0xa0:
1081             goto op_semantics_10;
1082             break;
1083           case 0xb0:
1084             goto op_semantics_11;
1085             break;
1086           case 0xc0:
1087             goto op_semantics_12;
1088             break;
1089           case 0xd0:
1090             goto op_semantics_13;
1091             break;
1092           case 0xe0:
1093             goto op_semantics_14;
1094             break;
1095           case 0xf0:
1096             goto op_semantics_15;
1097             break;
1098         }
1099       break;
1100     case 0x07:
1101         GETBYTE ();
1102         switch (op[1] & 0xf0)
1103         {
1104           case 0x00:
1105             goto op_semantics_1;
1106             break;
1107           case 0x10:
1108             goto op_semantics_2;
1109             break;
1110           case 0x20:
1111             goto op_semantics_3;
1112             break;
1113           case 0x30:
1114             goto op_semantics_4;
1115             break;
1116           case 0x40:
1117           case 0x50:
1118             goto op_semantics_18;
1119             break;
1120           case 0x60:
1121             goto op_semantics_6;
1122             break;
1123           case 0x70:
1124             goto op_semantics_7;
1125             break;
1126           case 0x80:
1127             goto op_semantics_8;
1128             break;
1129           case 0x90:
1130             goto op_semantics_9;
1131             break;
1132           case 0xa0:
1133             goto op_semantics_10;
1134             break;
1135           case 0xb0:
1136             goto op_semantics_11;
1137             break;
1138           case 0xc0:
1139             goto op_semantics_12;
1140             break;
1141           case 0xd0:
1142             goto op_semantics_13;
1143             break;
1144           case 0xe0:
1145             goto op_semantics_14;
1146             break;
1147           case 0xf0:
1148             goto op_semantics_15;
1149             break;
1150         }
1151       break;
1152     case 0x08:
1153         GETBYTE ();
1154         switch (op[1] & 0xf0)
1155         {
1156           case 0x00:
1157             goto op_semantics_1;
1158             break;
1159           case 0x10:
1160             goto op_semantics_2;
1161             break;
1162           case 0x20:
1163             goto op_semantics_3;
1164             break;
1165           case 0x30:
1166             goto op_semantics_4;
1167             break;
1168           case 0x40:
1169           case 0x50:
1170             goto op_semantics_5;
1171             break;
1172           case 0x60:
1173             goto op_semantics_6;
1174             break;
1175           case 0x70:
1176             goto op_semantics_7;
1177             break;
1178           case 0x80:
1179             goto op_semantics_8;
1180             break;
1181           case 0x90:
1182             goto op_semantics_9;
1183             break;
1184           case 0xa0:
1185             goto op_semantics_10;
1186             break;
1187           case 0xb0:
1188             goto op_semantics_11;
1189             break;
1190           case 0xc0:
1191             goto op_semantics_12;
1192             break;
1193           case 0xd0:
1194             goto op_semantics_13;
1195             break;
1196           case 0xe0:
1197             goto op_semantics_14;
1198             break;
1199           case 0xf0:
1200             goto op_semantics_15;
1201             break;
1202         }
1203       break;
1204     case 0x09:
1205         GETBYTE ();
1206         switch (op[1] & 0xf0)
1207         {
1208           case 0x00:
1209             goto op_semantics_1;
1210             break;
1211           case 0x10:
1212             goto op_semantics_2;
1213             break;
1214           case 0x20:
1215             goto op_semantics_3;
1216             break;
1217           case 0x30:
1218             goto op_semantics_4;
1219             break;
1220           case 0x40:
1221           case 0x50:
1222             goto op_semantics_16;
1223             break;
1224           case 0x60:
1225             goto op_semantics_6;
1226             break;
1227           case 0x70:
1228             goto op_semantics_7;
1229             break;
1230           case 0x80:
1231             goto op_semantics_8;
1232             break;
1233           case 0x90:
1234             goto op_semantics_9;
1235             break;
1236           case 0xa0:
1237             goto op_semantics_10;
1238             break;
1239           case 0xb0:
1240             goto op_semantics_11;
1241             break;
1242           case 0xc0:
1243             goto op_semantics_12;
1244             break;
1245           case 0xd0:
1246             goto op_semantics_13;
1247             break;
1248           case 0xe0:
1249             goto op_semantics_14;
1250             break;
1251           case 0xf0:
1252             goto op_semantics_15;
1253             break;
1254         }
1255       break;
1256     case 0x0a:
1257         GETBYTE ();
1258         switch (op[1] & 0xf0)
1259         {
1260           case 0x00:
1261             goto op_semantics_1;
1262             break;
1263           case 0x10:
1264             goto op_semantics_2;
1265             break;
1266           case 0x20:
1267             goto op_semantics_3;
1268             break;
1269           case 0x30:
1270             goto op_semantics_4;
1271             break;
1272           case 0x40:
1273           case 0x50:
1274             goto op_semantics_17;
1275             break;
1276           case 0x60:
1277             goto op_semantics_6;
1278             break;
1279           case 0x70:
1280             goto op_semantics_7;
1281             break;
1282           case 0x80:
1283             goto op_semantics_8;
1284             break;
1285           case 0x90:
1286             goto op_semantics_9;
1287             break;
1288           case 0xa0:
1289             goto op_semantics_10;
1290             break;
1291           case 0xb0:
1292             goto op_semantics_11;
1293             break;
1294           case 0xc0:
1295             goto op_semantics_12;
1296             break;
1297           case 0xd0:
1298             goto op_semantics_13;
1299             break;
1300           case 0xe0:
1301             goto op_semantics_14;
1302             break;
1303           case 0xf0:
1304             goto op_semantics_15;
1305             break;
1306         }
1307       break;
1308     case 0x0b:
1309         GETBYTE ();
1310         switch (op[1] & 0xf0)
1311         {
1312           case 0x00:
1313             goto op_semantics_1;
1314             break;
1315           case 0x10:
1316             goto op_semantics_2;
1317             break;
1318           case 0x20:
1319             goto op_semantics_3;
1320             break;
1321           case 0x30:
1322             goto op_semantics_4;
1323             break;
1324           case 0x40:
1325           case 0x50:
1326             goto op_semantics_18;
1327             break;
1328           case 0x60:
1329             goto op_semantics_6;
1330             break;
1331           case 0x70:
1332             goto op_semantics_7;
1333             break;
1334           case 0x80:
1335             goto op_semantics_8;
1336             break;
1337           case 0x90:
1338             goto op_semantics_9;
1339             break;
1340           case 0xa0:
1341             goto op_semantics_10;
1342             break;
1343           case 0xb0:
1344             goto op_semantics_11;
1345             break;
1346           case 0xc0:
1347             goto op_semantics_12;
1348             break;
1349           case 0xd0:
1350             goto op_semantics_13;
1351             break;
1352           case 0xe0:
1353             goto op_semantics_14;
1354             break;
1355           case 0xf0:
1356             goto op_semantics_15;
1357             break;
1358         }
1359       break;
1360     case 0x0c:
1361         GETBYTE ();
1362         switch (op[1] & 0xf0)
1363         {
1364           case 0x00:
1365             goto op_semantics_1;
1366             break;
1367           case 0x10:
1368             goto op_semantics_2;
1369             break;
1370           case 0x20:
1371             goto op_semantics_3;
1372             break;
1373           case 0x30:
1374             goto op_semantics_4;
1375             break;
1376           case 0x40:
1377           case 0x50:
1378             goto op_semantics_5;
1379             break;
1380           case 0x60:
1381             goto op_semantics_6;
1382             break;
1383           case 0x70:
1384             goto op_semantics_7;
1385             break;
1386           case 0x80:
1387             goto op_semantics_8;
1388             break;
1389           case 0x90:
1390             goto op_semantics_9;
1391             break;
1392           case 0xa0:
1393             goto op_semantics_10;
1394             break;
1395           case 0xb0:
1396             goto op_semantics_11;
1397             break;
1398           case 0xc0:
1399             goto op_semantics_12;
1400             break;
1401           case 0xd0:
1402             goto op_semantics_13;
1403             break;
1404           case 0xe0:
1405             goto op_semantics_14;
1406             break;
1407           case 0xf0:
1408             goto op_semantics_15;
1409             break;
1410         }
1411       break;
1412     case 0x0d:
1413         GETBYTE ();
1414         switch (op[1] & 0xf0)
1415         {
1416           case 0x00:
1417             goto op_semantics_1;
1418             break;
1419           case 0x10:
1420             goto op_semantics_2;
1421             break;
1422           case 0x20:
1423             goto op_semantics_3;
1424             break;
1425           case 0x30:
1426             goto op_semantics_4;
1427             break;
1428           case 0x40:
1429           case 0x50:
1430             goto op_semantics_16;
1431             break;
1432           case 0x60:
1433             goto op_semantics_6;
1434             break;
1435           case 0x70:
1436             goto op_semantics_7;
1437             break;
1438           case 0x80:
1439             goto op_semantics_8;
1440             break;
1441           case 0x90:
1442             goto op_semantics_9;
1443             break;
1444           case 0xa0:
1445             goto op_semantics_10;
1446             break;
1447           case 0xb0:
1448             goto op_semantics_11;
1449             break;
1450           case 0xc0:
1451             goto op_semantics_12;
1452             break;
1453           case 0xd0:
1454             goto op_semantics_13;
1455             break;
1456           case 0xe0:
1457             goto op_semantics_14;
1458             break;
1459           case 0xf0:
1460             goto op_semantics_15;
1461             break;
1462         }
1463       break;
1464     case 0x0e:
1465         GETBYTE ();
1466         switch (op[1] & 0xf0)
1467         {
1468           case 0x00:
1469             goto op_semantics_1;
1470             break;
1471           case 0x10:
1472             goto op_semantics_2;
1473             break;
1474           case 0x20:
1475             goto op_semantics_3;
1476             break;
1477           case 0x30:
1478             goto op_semantics_4;
1479             break;
1480           case 0x40:
1481           case 0x50:
1482             goto op_semantics_17;
1483             break;
1484           case 0x60:
1485             goto op_semantics_6;
1486             break;
1487           case 0x70:
1488             goto op_semantics_7;
1489             break;
1490           case 0x80:
1491             goto op_semantics_8;
1492             break;
1493           case 0x90:
1494             goto op_semantics_9;
1495             break;
1496           case 0xa0:
1497             goto op_semantics_10;
1498             break;
1499           case 0xb0:
1500             goto op_semantics_11;
1501             break;
1502           case 0xc0:
1503             goto op_semantics_12;
1504             break;
1505           case 0xd0:
1506             goto op_semantics_13;
1507             break;
1508           case 0xe0:
1509             goto op_semantics_14;
1510             break;
1511           case 0xf0:
1512             goto op_semantics_15;
1513             break;
1514         }
1515       break;
1516     case 0x0f:
1517         GETBYTE ();
1518         switch (op[1] & 0xf0)
1519         {
1520           case 0x00:
1521             goto op_semantics_1;
1522             break;
1523           case 0x10:
1524             goto op_semantics_2;
1525             break;
1526           case 0x20:
1527             goto op_semantics_3;
1528             break;
1529           case 0x30:
1530             goto op_semantics_4;
1531             break;
1532           case 0x40:
1533           case 0x50:
1534             goto op_semantics_18;
1535             break;
1536           case 0x60:
1537             goto op_semantics_6;
1538             break;
1539           case 0x70:
1540             goto op_semantics_7;
1541             break;
1542           case 0x80:
1543             goto op_semantics_8;
1544             break;
1545           case 0x90:
1546             goto op_semantics_9;
1547             break;
1548           case 0xa0:
1549             goto op_semantics_10;
1550             break;
1551           case 0xb0:
1552             goto op_semantics_11;
1553             break;
1554           case 0xc0:
1555             goto op_semantics_12;
1556             break;
1557           case 0xd0:
1558             goto op_semantics_13;
1559             break;
1560           case 0xe0:
1561             goto op_semantics_14;
1562             break;
1563           case 0xf0:
1564             goto op_semantics_15;
1565             break;
1566         }
1567       break;
1568     case 0x10:
1569         GETBYTE ();
1570         switch (op[1] & 0x00)
1571         {
1572           case 0x00:
1573             op_semantics_19:
1574               {
1575                 /** 0001 00so c b ad dreg       %S%b    %1                              */
1576 #line 375 "msp430-decode.opc"
1577                 int so AU = op[0] & 0x03;
1578 #line 375 "msp430-decode.opc"
1579                 int c AU = (op[1] >> 7) & 0x01;
1580 #line 375 "msp430-decode.opc"
1581                 int b AU = (op[1] >> 6) & 0x01;
1582 #line 375 "msp430-decode.opc"
1583                 int ad AU = (op[1] >> 4) & 0x03;
1584 #line 375 "msp430-decode.opc"
1585                 int dreg AU = op[1] & 0x0f;
1586                 if (trace)
1587                   {
1588                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1589                            "/** 0001 00so c b ad dreg   %S%b    %1                              */",
1590                            op[0], op[1]);
1591                     printf ("  so = 0x%x,", so);
1592                     printf ("  c = 0x%x,", c);
1593                     printf ("  b = 0x%x,", b);
1594                     printf ("  ad = 0x%x,", ad);
1595                     printf ("  dreg = 0x%x\n", dreg);
1596                   }
1597                 SYNTAX("%S%b    %1");
1598 #line 375 "msp430-decode.opc"
1599
1600                 ID (sopc_to_id (so,c)); ASX (dreg, ad, srxt_bits); ABW (al_bit, b);
1601
1602                 if (ad == 0)
1603                   REPZC (srxt_bits, dsxt_bits);
1604
1605                 /* the helper functions encode for source, but it's both source and
1606                    dest, with a few documented exceptions.  */
1607                 msp430->op[0] = msp430->op[1];
1608
1609                 /* RETI ignores the operand */
1610                 if (msp430->id == MSO_reti)
1611                   msp430->syntax = "%S";
1612
1613                 switch (msp430->id)
1614                   {
1615                   case MSO_rrc: F_VNZC; break;
1616                   case MSO_swpb:        F_____; break;
1617                   case MSO_rra: F_0NZC; break;
1618                   case MSO_sxt: F_0NZC; break;
1619                   case MSO_push:        F_____; break;
1620                   case MSO_call:        F_____; break;
1621                   case MSO_reti:        F_VNZC; break;
1622                   default: break;
1623                   }
1624
1625                 /* 20xx 0010 0000 ---- ----
1626                    3cxx 0011 1100 ---- ----
1627                         001j mp-- ---- ---- */
1628               }
1629             break;
1630         }
1631       break;
1632     case 0x11:
1633         GETBYTE ();
1634         switch (op[1] & 0x00)
1635         {
1636           case 0x00:
1637             goto op_semantics_19;
1638             break;
1639         }
1640       break;
1641     case 0x12:
1642         GETBYTE ();
1643         switch (op[1] & 0x00)
1644         {
1645           case 0x00:
1646             goto op_semantics_19;
1647             break;
1648         }
1649       break;
1650     case 0x13:
1651         GETBYTE ();
1652         switch (op[1] & 0xff)
1653         {
1654           case 0x00:
1655               {
1656                 /** 0001 0011 0000 0000         RETI */
1657                 if (trace)
1658                   {
1659                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1660                            "/** 0001 0011 0000 0000             RETI */",
1661                            op[0], op[1]);
1662                   }
1663                 SYNTAX("RETI");
1664 #line 529 "msp430-decode.opc"
1665                 ID (MSO_reti);
1666                 msp430->size = 20;
1667                 msp430->ofs_430x = 1;
1668
1669               }
1670             break;
1671           case 0x01:
1672           case 0x02:
1673           case 0x03:
1674           case 0x04:
1675           case 0x05:
1676           case 0x06:
1677           case 0x07:
1678           case 0x08:
1679           case 0x09:
1680           case 0x0a:
1681           case 0x0b:
1682           case 0x0c:
1683           case 0x0d:
1684           case 0x0e:
1685           case 0x0f:
1686           case 0x10:
1687           case 0x11:
1688           case 0x12:
1689           case 0x13:
1690           case 0x14:
1691           case 0x15:
1692           case 0x16:
1693           case 0x17:
1694           case 0x18:
1695           case 0x19:
1696           case 0x1a:
1697           case 0x1b:
1698           case 0x1c:
1699           case 0x1d:
1700           case 0x1e:
1701           case 0x1f:
1702           case 0x20:
1703           case 0x21:
1704           case 0x22:
1705           case 0x23:
1706           case 0x24:
1707           case 0x25:
1708           case 0x26:
1709           case 0x27:
1710           case 0x28:
1711           case 0x29:
1712           case 0x2a:
1713           case 0x2b:
1714           case 0x2c:
1715           case 0x2d:
1716           case 0x2e:
1717           case 0x2f:
1718           case 0x30:
1719           case 0x31:
1720           case 0x32:
1721           case 0x33:
1722           case 0x34:
1723           case 0x35:
1724           case 0x36:
1725           case 0x37:
1726           case 0x38:
1727           case 0x39:
1728           case 0x3a:
1729           case 0x3b:
1730           case 0x3c:
1731           case 0x3d:
1732           case 0x3e:
1733           case 0x3f:
1734           case 0xa0:
1735           case 0xa1:
1736           case 0xa2:
1737           case 0xa3:
1738           case 0xa4:
1739           case 0xa5:
1740           case 0xa6:
1741           case 0xa7:
1742           case 0xa8:
1743           case 0xa9:
1744           case 0xaa:
1745           case 0xab:
1746           case 0xac:
1747           case 0xad:
1748           case 0xae:
1749           case 0xaf:
1750           case 0xc0:
1751           case 0xc1:
1752           case 0xc2:
1753           case 0xc3:
1754           case 0xc4:
1755           case 0xc5:
1756           case 0xc6:
1757           case 0xc7:
1758           case 0xc8:
1759           case 0xc9:
1760           case 0xca:
1761           case 0xcb:
1762           case 0xcc:
1763           case 0xcd:
1764           case 0xce:
1765           case 0xcf:
1766           case 0xd0:
1767           case 0xd1:
1768           case 0xd2:
1769           case 0xd3:
1770           case 0xd4:
1771           case 0xd5:
1772           case 0xd6:
1773           case 0xd7:
1774           case 0xd8:
1775           case 0xd9:
1776           case 0xda:
1777           case 0xdb:
1778           case 0xdc:
1779           case 0xdd:
1780           case 0xde:
1781           case 0xdf:
1782           case 0xe0:
1783           case 0xe1:
1784           case 0xe2:
1785           case 0xe3:
1786           case 0xe4:
1787           case 0xe5:
1788           case 0xe6:
1789           case 0xe7:
1790           case 0xe8:
1791           case 0xe9:
1792           case 0xea:
1793           case 0xeb:
1794           case 0xec:
1795           case 0xed:
1796           case 0xee:
1797           case 0xef:
1798           case 0xf0:
1799           case 0xf1:
1800           case 0xf2:
1801           case 0xf3:
1802           case 0xf4:
1803           case 0xf5:
1804           case 0xf6:
1805           case 0xf7:
1806           case 0xf8:
1807           case 0xf9:
1808           case 0xfa:
1809           case 0xfb:
1810           case 0xfc:
1811           case 0xfd:
1812           case 0xfe:
1813           case 0xff:
1814             goto op_semantics_19;
1815             break;
1816           case 0x40:
1817           case 0x41:
1818           case 0x42:
1819           case 0x43:
1820           case 0x44:
1821           case 0x45:
1822           case 0x46:
1823           case 0x47:
1824           case 0x48:
1825           case 0x49:
1826           case 0x4a:
1827           case 0x4b:
1828           case 0x4c:
1829           case 0x4d:
1830           case 0x4e:
1831           case 0x4f:
1832           case 0x50:
1833           case 0x51:
1834           case 0x52:
1835           case 0x53:
1836           case 0x54:
1837           case 0x55:
1838           case 0x56:
1839           case 0x57:
1840           case 0x58:
1841           case 0x59:
1842           case 0x5a:
1843           case 0x5b:
1844           case 0x5c:
1845           case 0x5d:
1846           case 0x5e:
1847           case 0x5f:
1848           case 0x60:
1849           case 0x61:
1850           case 0x62:
1851           case 0x63:
1852           case 0x64:
1853           case 0x65:
1854           case 0x66:
1855           case 0x67:
1856           case 0x68:
1857           case 0x69:
1858           case 0x6a:
1859           case 0x6b:
1860           case 0x6c:
1861           case 0x6d:
1862           case 0x6e:
1863           case 0x6f:
1864           case 0x70:
1865           case 0x71:
1866           case 0x72:
1867           case 0x73:
1868           case 0x74:
1869           case 0x75:
1870           case 0x76:
1871           case 0x77:
1872           case 0x78:
1873           case 0x79:
1874           case 0x7a:
1875           case 0x7b:
1876           case 0x7c:
1877           case 0x7d:
1878           case 0x7e:
1879           case 0x7f:
1880               {
1881                 /** 0001 0011 01as dstr         CALLA %0 */
1882 #line 534 "msp430-decode.opc"
1883                 int as AU = (op[1] >> 4) & 0x03;
1884 #line 534 "msp430-decode.opc"
1885                 int dstr AU = op[1] & 0x0f;
1886                 if (trace)
1887                   {
1888                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1889                            "/** 0001 0011 01as dstr             CALLA %0 */",
1890                            op[0], op[1]);
1891                     printf ("  as = 0x%x,", as);
1892                     printf ("  dstr = 0x%x\n", dstr);
1893                   }
1894                 SYNTAX("CALLA %0");
1895 #line 534 "msp430-decode.opc"
1896                 ID (MSO_call); AS (dstr, as);
1897                 msp430->size = 20;
1898                 msp430->ofs_430x = 1;
1899
1900               }
1901             break;
1902           case 0x80:
1903           case 0x81:
1904           case 0x82:
1905           case 0x83:
1906           case 0x84:
1907           case 0x85:
1908           case 0x86:
1909           case 0x87:
1910           case 0x88:
1911           case 0x89:
1912           case 0x8a:
1913           case 0x8b:
1914           case 0x8c:
1915           case 0x8d:
1916           case 0x8e:
1917           case 0x8f:
1918               {
1919                 /** 0001 0011 1000 extb         CALLA %0 */
1920 #line 539 "msp430-decode.opc"
1921                 int extb AU = op[1] & 0x0f;
1922                 if (trace)
1923                   {
1924                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1925                            "/** 0001 0011 1000 extb             CALLA %0 */",
1926                            op[0], op[1]);
1927                     printf ("  extb = 0x%x\n", extb);
1928                   }
1929                 SYNTAX("CALLA %0");
1930 #line 539 "msp430-decode.opc"
1931                 ID (MSO_call); SA (IMMU(2) | (extb << 16));
1932                 msp430->size = 20;
1933                 msp430->ofs_430x = 1;
1934
1935               }
1936             break;
1937           case 0x90:
1938           case 0x91:
1939           case 0x92:
1940           case 0x93:
1941           case 0x94:
1942           case 0x95:
1943           case 0x96:
1944           case 0x97:
1945           case 0x98:
1946           case 0x99:
1947           case 0x9a:
1948           case 0x9b:
1949           case 0x9c:
1950           case 0x9d:
1951           case 0x9e:
1952           case 0x9f:
1953               {
1954                 /** 0001 0011 1001 extb         CALLA %0 */
1955 #line 544 "msp430-decode.opc"
1956                 int extb AU = op[1] & 0x0f;
1957                 if (trace)
1958                   {
1959                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1960                            "/** 0001 0011 1001 extb             CALLA %0 */",
1961                            op[0], op[1]);
1962                     printf ("  extb = 0x%x\n", extb);
1963                   }
1964                 SYNTAX("CALLA %0");
1965 #line 544 "msp430-decode.opc"
1966                 raddr = IMMU(2) | (extb << 16);
1967                 if (raddr & 0x80000)
1968                   raddr -= 0x100000;
1969                 ID (MSO_call); SA (pc + raddr + msp430->n_bytes);
1970                 msp430->size = 20;
1971                 msp430->ofs_430x = 1;
1972
1973               }
1974             break;
1975           case 0xb0:
1976           case 0xb1:
1977           case 0xb2:
1978           case 0xb3:
1979           case 0xb4:
1980           case 0xb5:
1981           case 0xb6:
1982           case 0xb7:
1983           case 0xb8:
1984           case 0xb9:
1985           case 0xba:
1986           case 0xbb:
1987           case 0xbc:
1988           case 0xbd:
1989           case 0xbe:
1990           case 0xbf:
1991               {
1992                 /** 0001 0011 1011 extb         CALLA %0 */
1993 #line 552 "msp430-decode.opc"
1994                 int extb AU = op[1] & 0x0f;
1995                 if (trace)
1996                   {
1997                     printf ("\033[33m%s\033[0m  %02x %02x\n",
1998                            "/** 0001 0011 1011 extb             CALLA %0 */",
1999                            op[0], op[1]);
2000                     printf ("  extb = 0x%x\n", extb);
2001                   }
2002                 SYNTAX("CALLA %0");
2003 #line 552 "msp430-decode.opc"
2004                 ID (MSO_call); SC (IMMU(2) | (extb << 16));
2005                 msp430->size = 20;
2006                 msp430->ofs_430x = 1;
2007
2008               }
2009             break;
2010         }
2011       break;
2012     case 0x14:
2013         GETBYTE ();
2014         switch (op[1] & 0x00)
2015         {
2016           case 0x00:
2017             op_semantics_20:
2018               {
2019                 /** 0001 010w bits srcr         PUSHM.A %0 */
2020 #line 557 "msp430-decode.opc"
2021                 int w AU = op[0] & 0x01;
2022 #line 557 "msp430-decode.opc"
2023                 int bits AU = (op[1] >> 4) & 0x0f;
2024 #line 557 "msp430-decode.opc"
2025                 int srcr AU = op[1] & 0x0f;
2026                 if (trace)
2027                   {
2028                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2029                            "/** 0001 010w bits srcr             PUSHM.A %0 */",
2030                            op[0], op[1]);
2031                     printf ("  w = 0x%x,", w);
2032                     printf ("  bits = 0x%x,", bits);
2033                     printf ("  srcr = 0x%x\n", srcr);
2034                   }
2035                 SYNTAX("PUSHM.A %0");
2036 #line 557 "msp430-decode.opc"
2037                 ID (MSO_push); SR (srcr);
2038                 msp430->size = w ? 16 : 20;
2039                 msp430->repeats = bits;
2040                 msp430->ofs_430x = 1;
2041
2042               }
2043             break;
2044         }
2045       break;
2046     case 0x15:
2047         GETBYTE ();
2048         switch (op[1] & 0x00)
2049         {
2050           case 0x00:
2051             goto op_semantics_20;
2052             break;
2053         }
2054       break;
2055     case 0x16:
2056         GETBYTE ();
2057         switch (op[1] & 0x00)
2058         {
2059           case 0x00:
2060             op_semantics_21:
2061               {
2062                 /** 0001 011w bits dstr         POPM.A %0 */
2063 #line 563 "msp430-decode.opc"
2064                 int w AU = op[0] & 0x01;
2065 #line 563 "msp430-decode.opc"
2066                 int bits AU = (op[1] >> 4) & 0x0f;
2067 #line 563 "msp430-decode.opc"
2068                 int dstr AU = op[1] & 0x0f;
2069                 if (trace)
2070                   {
2071                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2072                            "/** 0001 011w bits dstr             POPM.A %0 */",
2073                            op[0], op[1]);
2074                     printf ("  w = 0x%x,", w);
2075                     printf ("  bits = 0x%x,", bits);
2076                     printf ("  dstr = 0x%x\n", dstr);
2077                   }
2078                 SYNTAX("POPM.A %0");
2079 #line 563 "msp430-decode.opc"
2080                 ID (MSO_pop); DR (dstr);
2081                 msp430->size = w ? 16 : 20;
2082                 msp430->repeats = bits;
2083                 msp430->ofs_430x = 1;
2084
2085               }
2086             break;
2087         }
2088       break;
2089     case 0x17:
2090         GETBYTE ();
2091         switch (op[1] & 0x00)
2092         {
2093           case 0x00:
2094             goto op_semantics_21;
2095             break;
2096         }
2097       break;
2098     case 0x18:
2099         GETBYTE ();
2100         switch (op[1] & 0x30)
2101         {
2102           case 0x00:
2103             op_semantics_22:
2104               {
2105                 /** 0001 1srx t l 00 dsxt       430x */
2106 #line 329 "msp430-decode.opc"
2107                 int srx AU = op[0] & 0x07;
2108 #line 329 "msp430-decode.opc"
2109                 int t AU = (op[1] >> 7) & 0x01;
2110 #line 329 "msp430-decode.opc"
2111                 int l AU = (op[1] >> 6) & 0x01;
2112 #line 329 "msp430-decode.opc"
2113                 int dsxt AU = op[1] & 0x0f;
2114                 if (trace)
2115                   {
2116                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2117                            "/** 0001 1srx t l 00 dsxt   430x */",
2118                            op[0], op[1]);
2119                     printf ("  srx = 0x%x,", srx);
2120                     printf ("  t = 0x%x,", t);
2121                     printf ("  l = 0x%x,", l);
2122                     printf ("  dsxt = 0x%x\n", dsxt);
2123                   }
2124                 SYNTAX("430x");
2125 #line 329 "msp430-decode.opc"
2126
2127                 al_bit = l;
2128                 srxt_bits = srx * 2 + t;
2129                 dsxt_bits = dsxt;
2130                 op = op_buf + lds.op_ptr;
2131                 msp430->ofs_430x = 1;
2132                 goto post_extension_word;
2133
2134               /* double-op insns:
2135                  opcode:4 sreg:4 Ad:1 BW:1 As:2 Dreg:4
2136
2137                  single-op insn:
2138                  opcode:9 BW:1 Ad:2 DSreg:4
2139
2140                  jumps:
2141                  opcode:3 Cond:3  pcrel:10
2142
2143                  */
2144
2145               /* Double-Operand "opcode" fields  */
2146
2147               }
2148             break;
2149           default: UNSUPPORTED(); break;
2150         }
2151       break;
2152     case 0x19:
2153         GETBYTE ();
2154         switch (op[1] & 0x30)
2155         {
2156           case 0x00:
2157             goto op_semantics_22;
2158             break;
2159           default: UNSUPPORTED(); break;
2160         }
2161       break;
2162     case 0x1a:
2163         GETBYTE ();
2164         switch (op[1] & 0x30)
2165         {
2166           case 0x00:
2167             goto op_semantics_22;
2168             break;
2169           default: UNSUPPORTED(); break;
2170         }
2171       break;
2172     case 0x1b:
2173         GETBYTE ();
2174         switch (op[1] & 0x30)
2175         {
2176           case 0x00:
2177             goto op_semantics_22;
2178             break;
2179           default: UNSUPPORTED(); break;
2180         }
2181       break;
2182     case 0x1c:
2183         GETBYTE ();
2184         switch (op[1] & 0x30)
2185         {
2186           case 0x00:
2187             goto op_semantics_22;
2188             break;
2189           default: UNSUPPORTED(); break;
2190         }
2191       break;
2192     case 0x1d:
2193         GETBYTE ();
2194         switch (op[1] & 0x30)
2195         {
2196           case 0x00:
2197             goto op_semantics_22;
2198             break;
2199           default: UNSUPPORTED(); break;
2200         }
2201       break;
2202     case 0x1e:
2203         GETBYTE ();
2204         switch (op[1] & 0x30)
2205         {
2206           case 0x00:
2207             goto op_semantics_22;
2208             break;
2209           default: UNSUPPORTED(); break;
2210         }
2211       break;
2212     case 0x1f:
2213         GETBYTE ();
2214         switch (op[1] & 0x30)
2215         {
2216           case 0x00:
2217             goto op_semantics_22;
2218             break;
2219           default: UNSUPPORTED(); break;
2220         }
2221       break;
2222     case 0x20:
2223         GETBYTE ();
2224         switch (op[1] & 0x00)
2225         {
2226           case 0x00:
2227             op_semantics_23:
2228               {
2229                 /** 001jmp aa addrlsbs          %J      %1                              */
2230 #line 405 "msp430-decode.opc"
2231                 int jmp AU = (op[0] >> 2) & 0x07;
2232 #line 405 "msp430-decode.opc"
2233                 int aa AU = op[0] & 0x03;
2234 #line 405 "msp430-decode.opc"
2235                 int addrlsbs AU = op[1];
2236                 if (trace)
2237                   {
2238                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2239                            "/** 001jmp aa addrlsbs              %J      %1                              */",
2240                            op[0], op[1]);
2241                     printf ("  jmp = 0x%x,", jmp);
2242                     printf ("  aa = 0x%x,", aa);
2243                     printf ("  addrlsbs = 0x%x\n", addrlsbs);
2244                   }
2245                 SYNTAX("%J      %1");
2246 #line 405 "msp430-decode.opc"
2247
2248                 raddr = (aa << 9) | (addrlsbs << 1);
2249                 if (raddr & 0x400)
2250                   raddr = raddr - 0x800;
2251                 /* This is a pc-relative jump, but we don't use SM because that
2252                    would load the target address from the memory at X(PC), not use
2253                    PC+X *as* the address.  So we use SC to use the address, not the
2254                    data at that address.  */
2255                 ID (MSO_jmp); SC (pc + raddr + msp430->n_bytes);
2256                 msp430->cond = jmp;
2257
2258               /* Extended instructions */
2259
2260               }
2261             break;
2262         }
2263       break;
2264     case 0x21:
2265         GETBYTE ();
2266         switch (op[1] & 0x00)
2267         {
2268           case 0x00:
2269             goto op_semantics_23;
2270             break;
2271         }
2272       break;
2273     case 0x22:
2274         GETBYTE ();
2275         switch (op[1] & 0x00)
2276         {
2277           case 0x00:
2278             goto op_semantics_23;
2279             break;
2280         }
2281       break;
2282     case 0x23:
2283         GETBYTE ();
2284         switch (op[1] & 0x00)
2285         {
2286           case 0x00:
2287             goto op_semantics_23;
2288             break;
2289         }
2290       break;
2291     case 0x24:
2292         GETBYTE ();
2293         switch (op[1] & 0x00)
2294         {
2295           case 0x00:
2296             goto op_semantics_23;
2297             break;
2298         }
2299       break;
2300     case 0x25:
2301         GETBYTE ();
2302         switch (op[1] & 0x00)
2303         {
2304           case 0x00:
2305             goto op_semantics_23;
2306             break;
2307         }
2308       break;
2309     case 0x26:
2310         GETBYTE ();
2311         switch (op[1] & 0x00)
2312         {
2313           case 0x00:
2314             goto op_semantics_23;
2315             break;
2316         }
2317       break;
2318     case 0x27:
2319         GETBYTE ();
2320         switch (op[1] & 0x00)
2321         {
2322           case 0x00:
2323             goto op_semantics_23;
2324             break;
2325         }
2326       break;
2327     case 0x28:
2328         GETBYTE ();
2329         switch (op[1] & 0x00)
2330         {
2331           case 0x00:
2332             goto op_semantics_23;
2333             break;
2334         }
2335       break;
2336     case 0x29:
2337         GETBYTE ();
2338         switch (op[1] & 0x00)
2339         {
2340           case 0x00:
2341             goto op_semantics_23;
2342             break;
2343         }
2344       break;
2345     case 0x2a:
2346         GETBYTE ();
2347         switch (op[1] & 0x00)
2348         {
2349           case 0x00:
2350             goto op_semantics_23;
2351             break;
2352         }
2353       break;
2354     case 0x2b:
2355         GETBYTE ();
2356         switch (op[1] & 0x00)
2357         {
2358           case 0x00:
2359             goto op_semantics_23;
2360             break;
2361         }
2362       break;
2363     case 0x2c:
2364         GETBYTE ();
2365         switch (op[1] & 0x00)
2366         {
2367           case 0x00:
2368             goto op_semantics_23;
2369             break;
2370         }
2371       break;
2372     case 0x2d:
2373         GETBYTE ();
2374         switch (op[1] & 0x00)
2375         {
2376           case 0x00:
2377             goto op_semantics_23;
2378             break;
2379         }
2380       break;
2381     case 0x2e:
2382         GETBYTE ();
2383         switch (op[1] & 0x00)
2384         {
2385           case 0x00:
2386             goto op_semantics_23;
2387             break;
2388         }
2389       break;
2390     case 0x2f:
2391         GETBYTE ();
2392         switch (op[1] & 0x00)
2393         {
2394           case 0x00:
2395             goto op_semantics_23;
2396             break;
2397         }
2398       break;
2399     case 0x30:
2400         GETBYTE ();
2401         switch (op[1] & 0x00)
2402         {
2403           case 0x00:
2404             goto op_semantics_23;
2405             break;
2406         }
2407       break;
2408     case 0x31:
2409         GETBYTE ();
2410         switch (op[1] & 0x00)
2411         {
2412           case 0x00:
2413             goto op_semantics_23;
2414             break;
2415         }
2416       break;
2417     case 0x32:
2418         GETBYTE ();
2419         switch (op[1] & 0x00)
2420         {
2421           case 0x00:
2422             goto op_semantics_23;
2423             break;
2424         }
2425       break;
2426     case 0x33:
2427         GETBYTE ();
2428         switch (op[1] & 0x00)
2429         {
2430           case 0x00:
2431             goto op_semantics_23;
2432             break;
2433         }
2434       break;
2435     case 0x34:
2436         GETBYTE ();
2437         switch (op[1] & 0x00)
2438         {
2439           case 0x00:
2440             goto op_semantics_23;
2441             break;
2442         }
2443       break;
2444     case 0x35:
2445         GETBYTE ();
2446         switch (op[1] & 0x00)
2447         {
2448           case 0x00:
2449             goto op_semantics_23;
2450             break;
2451         }
2452       break;
2453     case 0x36:
2454         GETBYTE ();
2455         switch (op[1] & 0x00)
2456         {
2457           case 0x00:
2458             goto op_semantics_23;
2459             break;
2460         }
2461       break;
2462     case 0x37:
2463         GETBYTE ();
2464         switch (op[1] & 0x00)
2465         {
2466           case 0x00:
2467             goto op_semantics_23;
2468             break;
2469         }
2470       break;
2471     case 0x38:
2472         GETBYTE ();
2473         switch (op[1] & 0x00)
2474         {
2475           case 0x00:
2476             goto op_semantics_23;
2477             break;
2478         }
2479       break;
2480     case 0x39:
2481         GETBYTE ();
2482         switch (op[1] & 0x00)
2483         {
2484           case 0x00:
2485             goto op_semantics_23;
2486             break;
2487         }
2488       break;
2489     case 0x3a:
2490         GETBYTE ();
2491         switch (op[1] & 0x00)
2492         {
2493           case 0x00:
2494             goto op_semantics_23;
2495             break;
2496         }
2497       break;
2498     case 0x3b:
2499         GETBYTE ();
2500         switch (op[1] & 0x00)
2501         {
2502           case 0x00:
2503             goto op_semantics_23;
2504             break;
2505         }
2506       break;
2507     case 0x3c:
2508         GETBYTE ();
2509         switch (op[1] & 0x00)
2510         {
2511           case 0x00:
2512             goto op_semantics_23;
2513             break;
2514         }
2515       break;
2516     case 0x3d:
2517         GETBYTE ();
2518         switch (op[1] & 0x00)
2519         {
2520           case 0x00:
2521             goto op_semantics_23;
2522             break;
2523         }
2524       break;
2525     case 0x3e:
2526         GETBYTE ();
2527         switch (op[1] & 0x00)
2528         {
2529           case 0x00:
2530             goto op_semantics_23;
2531             break;
2532         }
2533       break;
2534     case 0x3f:
2535         GETBYTE ();
2536         switch (op[1] & 0x00)
2537         {
2538           case 0x00:
2539             goto op_semantics_23;
2540             break;
2541         }
2542       break;
2543     case 0x40:
2544         GETBYTE ();
2545         switch (op[1] & 0x00)
2546         {
2547           case 0x00:
2548             op_semantics_24:
2549               {
2550                 /** dopc sreg a b as dreg       %D%b    %1,%0                           */
2551 #line 352 "msp430-decode.opc"
2552                 int dopc AU = (op[0] >> 4) & 0x0f;
2553 #line 352 "msp430-decode.opc"
2554                 int sreg AU = op[0] & 0x0f;
2555 #line 352 "msp430-decode.opc"
2556                 int a AU = (op[1] >> 7) & 0x01;
2557 #line 352 "msp430-decode.opc"
2558                 int b AU = (op[1] >> 6) & 0x01;
2559 #line 352 "msp430-decode.opc"
2560                 int as AU = (op[1] >> 4) & 0x03;
2561 #line 352 "msp430-decode.opc"
2562                 int dreg AU = op[1] & 0x0f;
2563                 if (trace)
2564                   {
2565                     printf ("\033[33m%s\033[0m  %02x %02x\n",
2566                            "/** dopc sreg a b as dreg   %D%b    %1,%0                           */",
2567                            op[0], op[1]);
2568                     printf ("  dopc = 0x%x,", dopc);
2569                     printf ("  sreg = 0x%x,", sreg);
2570                     printf ("  a = 0x%x,", a);
2571                     printf ("  b = 0x%x,", b);
2572                     printf ("  as = 0x%x,", as);
2573                     printf ("  dreg = 0x%x\n", dreg);
2574                   }
2575                 SYNTAX("%D%b    %1,%0");
2576 #line 352 "msp430-decode.opc"
2577
2578                 ID (dopc_to_id (dopc)); ASX (sreg, as, srxt_bits); ADX (dreg, a, dsxt_bits); ABW (al_bit, b);
2579                 if (a == 0 && as == 0)
2580                   REPZC (srxt_bits, dsxt_bits);
2581
2582                 switch (msp430->id)
2583                   {
2584                   case MSO_mov: F_____; break;
2585                   case MSO_add: F_VNZC; break;
2586                   case MSO_addc:        F_VNZC; break;
2587                   case MSO_subc:        F_VNZC; break;
2588                   case MSO_sub: F_VNZC; break;
2589                   case MSO_cmp: F_VNZC; break;
2590                   case MSO_dadd:        F_VNZC; break;
2591                   case MSO_bit: F_0NZC; break;
2592                   case MSO_bic: F_____; break;
2593                   case MSO_bis: F_____; break;
2594                   case MSO_xor: F_VNZC; break;
2595                   case MSO_and: F_0NZC; break;
2596                   default: break;
2597                   }
2598
2599               }
2600             break;
2601         }
2602       break;
2603     case 0x41:
2604         GETBYTE ();
2605         switch (op[1] & 0x00)
2606         {
2607           case 0x00:
2608             goto op_semantics_24;
2609             break;
2610         }
2611       break;
2612     case 0x42:
2613         GETBYTE ();
2614         switch (op[1] & 0x00)
2615         {
2616           case 0x00:
2617             goto op_semantics_24;
2618             break;
2619         }
2620       break;
2621     case 0x43:
2622         GETBYTE ();
2623         switch (op[1] & 0x00)
2624         {
2625           case 0x00:
2626             goto op_semantics_24;
2627             break;
2628         }
2629       break;
2630     case 0x44:
2631         GETBYTE ();
2632         switch (op[1] & 0x00)
2633         {
2634           case 0x00:
2635             goto op_semantics_24;
2636             break;
2637         }
2638       break;
2639     case 0x45:
2640         GETBYTE ();
2641         switch (op[1] & 0x00)
2642         {
2643           case 0x00:
2644             goto op_semantics_24;
2645             break;
2646         }
2647       break;
2648     case 0x46:
2649         GETBYTE ();
2650         switch (op[1] & 0x00)
2651         {
2652           case 0x00:
2653             goto op_semantics_24;
2654             break;
2655         }
2656       break;
2657     case 0x47:
2658         GETBYTE ();
2659         switch (op[1] & 0x00)
2660         {
2661           case 0x00:
2662             goto op_semantics_24;
2663             break;
2664         }
2665       break;
2666     case 0x48:
2667         GETBYTE ();
2668         switch (op[1] & 0x00)
2669         {
2670           case 0x00:
2671             goto op_semantics_24;
2672             break;
2673         }
2674       break;
2675     case 0x49:
2676         GETBYTE ();
2677         switch (op[1] & 0x00)
2678         {
2679           case 0x00:
2680             goto op_semantics_24;
2681             break;
2682         }
2683       break;
2684     case 0x4a:
2685         GETBYTE ();
2686         switch (op[1] & 0x00)
2687         {
2688           case 0x00:
2689             goto op_semantics_24;
2690             break;
2691         }
2692       break;
2693     case 0x4b:
2694         GETBYTE ();
2695         switch (op[1] & 0x00)
2696         {
2697           case 0x00:
2698             goto op_semantics_24;
2699             break;
2700         }
2701       break;
2702     case 0x4c:
2703         GETBYTE ();
2704         switch (op[1] & 0x00)
2705         {
2706           case 0x00:
2707             goto op_semantics_24;
2708             break;
2709         }
2710       break;
2711     case 0x4d:
2712         GETBYTE ();
2713         switch (op[1] & 0x00)
2714         {
2715           case 0x00:
2716             goto op_semantics_24;
2717             break;
2718         }
2719       break;
2720     case 0x4e:
2721         GETBYTE ();
2722         switch (op[1] & 0x00)
2723         {
2724           case 0x00:
2725             goto op_semantics_24;
2726             break;
2727         }
2728       break;
2729     case 0x4f:
2730         GETBYTE ();
2731         switch (op[1] & 0x00)
2732         {
2733           case 0x00:
2734             goto op_semantics_24;
2735             break;
2736         }
2737       break;
2738     case 0x50:
2739         GETBYTE ();
2740         switch (op[1] & 0x00)
2741         {
2742           case 0x00:
2743             goto op_semantics_24;
2744             break;
2745         }
2746       break;
2747     case 0x51:
2748         GETBYTE ();
2749         switch (op[1] & 0x00)
2750         {
2751           case 0x00:
2752             goto op_semantics_24;
2753             break;
2754         }
2755       break;
2756     case 0x52:
2757         GETBYTE ();
2758         switch (op[1] & 0x00)
2759         {
2760           case 0x00:
2761             goto op_semantics_24;
2762             break;
2763         }
2764       break;
2765     case 0x53:
2766         GETBYTE ();
2767         switch (op[1] & 0x00)
2768         {
2769           case 0x00:
2770             goto op_semantics_24;
2771             break;
2772         }
2773       break;
2774     case 0x54:
2775         GETBYTE ();
2776         switch (op[1] & 0x00)
2777         {
2778           case 0x00:
2779             goto op_semantics_24;
2780             break;
2781         }
2782       break;
2783     case 0x55:
2784         GETBYTE ();
2785         switch (op[1] & 0x00)
2786         {
2787           case 0x00:
2788             goto op_semantics_24;
2789             break;
2790         }
2791       break;
2792     case 0x56:
2793         GETBYTE ();
2794         switch (op[1] & 0x00)
2795         {
2796           case 0x00:
2797             goto op_semantics_24;
2798             break;
2799         }
2800       break;
2801     case 0x57:
2802         GETBYTE ();
2803         switch (op[1] & 0x00)
2804         {
2805           case 0x00:
2806             goto op_semantics_24;
2807             break;
2808         }
2809       break;
2810     case 0x58:
2811         GETBYTE ();
2812         switch (op[1] & 0x00)
2813         {
2814           case 0x00:
2815             goto op_semantics_24;
2816             break;
2817         }
2818       break;
2819     case 0x59:
2820         GETBYTE ();
2821         switch (op[1] & 0x00)
2822         {
2823           case 0x00:
2824             goto op_semantics_24;
2825             break;
2826         }
2827       break;
2828     case 0x5a:
2829         GETBYTE ();
2830         switch (op[1] & 0x00)
2831         {
2832           case 0x00:
2833             goto op_semantics_24;
2834             break;
2835         }
2836       break;
2837     case 0x5b:
2838         GETBYTE ();
2839         switch (op[1] & 0x00)
2840         {
2841           case 0x00:
2842             goto op_semantics_24;
2843             break;
2844         }
2845       break;
2846     case 0x5c:
2847         GETBYTE ();
2848         switch (op[1] & 0x00)
2849         {
2850           case 0x00:
2851             goto op_semantics_24;
2852             break;
2853         }
2854       break;
2855     case 0x5d:
2856         GETBYTE ();
2857         switch (op[1] & 0x00)
2858         {
2859           case 0x00:
2860             goto op_semantics_24;
2861             break;
2862         }
2863       break;
2864     case 0x5e:
2865         GETBYTE ();
2866         switch (op[1] & 0x00)
2867         {
2868           case 0x00:
2869             goto op_semantics_24;
2870             break;
2871         }
2872       break;
2873     case 0x5f:
2874         GETBYTE ();
2875         switch (op[1] & 0x00)
2876         {
2877           case 0x00:
2878             goto op_semantics_24;
2879             break;
2880         }
2881       break;
2882     case 0x60:
2883         GETBYTE ();
2884         switch (op[1] & 0x00)
2885         {
2886           case 0x00:
2887             goto op_semantics_24;
2888             break;
2889         }
2890       break;
2891     case 0x61:
2892         GETBYTE ();
2893         switch (op[1] & 0x00)
2894         {
2895           case 0x00:
2896             goto op_semantics_24;
2897             break;
2898         }
2899       break;
2900     case 0x62:
2901         GETBYTE ();
2902         switch (op[1] & 0x00)
2903         {
2904           case 0x00:
2905             goto op_semantics_24;
2906             break;
2907         }
2908       break;
2909     case 0x63:
2910         GETBYTE ();
2911         switch (op[1] & 0x00)
2912         {
2913           case 0x00:
2914             goto op_semantics_24;
2915             break;
2916         }
2917       break;
2918     case 0x64:
2919         GETBYTE ();
2920         switch (op[1] & 0x00)
2921         {
2922           case 0x00:
2923             goto op_semantics_24;
2924             break;
2925         }
2926       break;
2927     case 0x65:
2928         GETBYTE ();
2929         switch (op[1] & 0x00)
2930         {
2931           case 0x00:
2932             goto op_semantics_24;
2933             break;
2934         }
2935       break;
2936     case 0x66:
2937         GETBYTE ();
2938         switch (op[1] & 0x00)
2939         {
2940           case 0x00:
2941             goto op_semantics_24;
2942             break;
2943         }
2944       break;
2945     case 0x67:
2946         GETBYTE ();
2947         switch (op[1] & 0x00)
2948         {
2949           case 0x00:
2950             goto op_semantics_24;
2951             break;
2952         }
2953       break;
2954     case 0x68:
2955         GETBYTE ();
2956         switch (op[1] & 0x00)
2957         {
2958           case 0x00:
2959             goto op_semantics_24;
2960             break;
2961         }
2962       break;
2963     case 0x69:
2964         GETBYTE ();
2965         switch (op[1] & 0x00)
2966         {
2967           case 0x00:
2968             goto op_semantics_24;
2969             break;
2970         }
2971       break;
2972     case 0x6a:
2973         GETBYTE ();
2974         switch (op[1] & 0x00)
2975         {
2976           case 0x00:
2977             goto op_semantics_24;
2978             break;
2979         }
2980       break;
2981     case 0x6b:
2982         GETBYTE ();
2983         switch (op[1] & 0x00)
2984         {
2985           case 0x00:
2986             goto op_semantics_24;
2987             break;
2988         }
2989       break;
2990     case 0x6c:
2991         GETBYTE ();
2992         switch (op[1] & 0x00)
2993         {
2994           case 0x00:
2995             goto op_semantics_24;
2996             break;
2997         }
2998       break;
2999     case 0x6d:
3000         GETBYTE ();
3001         switch (op[1] & 0x00)
3002         {
3003           case 0x00:
3004             goto op_semantics_24;
3005             break;
3006         }
3007       break;
3008     case 0x6e:
3009         GETBYTE ();
3010         switch (op[1] & 0x00)
3011         {
3012           case 0x00:
3013             goto op_semantics_24;
3014             break;
3015         }
3016       break;
3017     case 0x6f:
3018         GETBYTE ();
3019         switch (op[1] & 0x00)
3020         {
3021           case 0x00:
3022             goto op_semantics_24;
3023             break;
3024         }
3025       break;
3026     case 0x70:
3027         GETBYTE ();
3028         switch (op[1] & 0x00)
3029         {
3030           case 0x00:
3031             goto op_semantics_24;
3032             break;
3033         }
3034       break;
3035     case 0x71:
3036         GETBYTE ();
3037         switch (op[1] & 0x00)
3038         {
3039           case 0x00:
3040             goto op_semantics_24;
3041             break;
3042         }
3043       break;
3044     case 0x72:
3045         GETBYTE ();
3046         switch (op[1] & 0x00)
3047         {
3048           case 0x00:
3049             goto op_semantics_24;
3050             break;
3051         }
3052       break;
3053     case 0x73:
3054         GETBYTE ();
3055         switch (op[1] & 0x00)
3056         {
3057           case 0x00:
3058             goto op_semantics_24;
3059             break;
3060         }
3061       break;
3062     case 0x74:
3063         GETBYTE ();
3064         switch (op[1] & 0x00)
3065         {
3066           case 0x00:
3067             goto op_semantics_24;
3068             break;
3069         }
3070       break;
3071     case 0x75:
3072         GETBYTE ();
3073         switch (op[1] & 0x00)
3074         {
3075           case 0x00:
3076             goto op_semantics_24;
3077             break;
3078         }
3079       break;
3080     case 0x76:
3081         GETBYTE ();
3082         switch (op[1] & 0x00)
3083         {
3084           case 0x00:
3085             goto op_semantics_24;
3086             break;
3087         }
3088       break;
3089     case 0x77:
3090         GETBYTE ();
3091         switch (op[1] & 0x00)
3092         {
3093           case 0x00:
3094             goto op_semantics_24;
3095             break;
3096         }
3097       break;
3098     case 0x78:
3099         GETBYTE ();
3100         switch (op[1] & 0x00)
3101         {
3102           case 0x00:
3103             goto op_semantics_24;
3104             break;
3105         }
3106       break;
3107     case 0x79:
3108         GETBYTE ();
3109         switch (op[1] & 0x00)
3110         {
3111           case 0x00:
3112             goto op_semantics_24;
3113             break;
3114         }
3115       break;
3116     case 0x7a:
3117         GETBYTE ();
3118         switch (op[1] & 0x00)
3119         {
3120           case 0x00:
3121             goto op_semantics_24;
3122             break;
3123         }
3124       break;
3125     case 0x7b:
3126         GETBYTE ();
3127         switch (op[1] & 0x00)
3128         {
3129           case 0x00:
3130             goto op_semantics_24;
3131             break;
3132         }
3133       break;
3134     case 0x7c:
3135         GETBYTE ();
3136         switch (op[1] & 0x00)
3137         {
3138           case 0x00:
3139             goto op_semantics_24;
3140             break;
3141         }
3142       break;
3143     case 0x7d:
3144         GETBYTE ();
3145         switch (op[1] & 0x00)
3146         {
3147           case 0x00:
3148             goto op_semantics_24;
3149             break;
3150         }
3151       break;
3152     case 0x7e:
3153         GETBYTE ();
3154         switch (op[1] & 0x00)
3155         {
3156           case 0x00:
3157             goto op_semantics_24;
3158             break;
3159         }
3160       break;
3161     case 0x7f:
3162         GETBYTE ();
3163         switch (op[1] & 0x00)
3164         {
3165           case 0x00:
3166             goto op_semantics_24;
3167             break;
3168         }
3169       break;
3170     case 0x80:
3171         GETBYTE ();
3172         switch (op[1] & 0x00)
3173         {
3174           case 0x00:
3175             goto op_semantics_24;
3176             break;
3177         }
3178       break;
3179     case 0x81:
3180         GETBYTE ();
3181         switch (op[1] & 0x00)
3182         {
3183           case 0x00:
3184             goto op_semantics_24;
3185             break;
3186         }
3187       break;
3188     case 0x82:
3189         GETBYTE ();
3190         switch (op[1] & 0x00)
3191         {
3192           case 0x00:
3193             goto op_semantics_24;
3194             break;
3195         }
3196       break;
3197     case 0x83:
3198         GETBYTE ();
3199         switch (op[1] & 0x00)
3200         {
3201           case 0x00:
3202             goto op_semantics_24;
3203             break;
3204         }
3205       break;
3206     case 0x84:
3207         GETBYTE ();
3208         switch (op[1] & 0x00)
3209         {
3210           case 0x00:
3211             goto op_semantics_24;
3212             break;
3213         }
3214       break;
3215     case 0x85:
3216         GETBYTE ();
3217         switch (op[1] & 0x00)
3218         {
3219           case 0x00:
3220             goto op_semantics_24;
3221             break;
3222         }
3223       break;
3224     case 0x86:
3225         GETBYTE ();
3226         switch (op[1] & 0x00)
3227         {
3228           case 0x00:
3229             goto op_semantics_24;
3230             break;
3231         }
3232       break;
3233     case 0x87:
3234         GETBYTE ();
3235         switch (op[1] & 0x00)
3236         {
3237           case 0x00:
3238             goto op_semantics_24;
3239             break;
3240         }
3241       break;
3242     case 0x88:
3243         GETBYTE ();
3244         switch (op[1] & 0x00)
3245         {
3246           case 0x00:
3247             goto op_semantics_24;
3248             break;
3249         }
3250       break;
3251     case 0x89:
3252         GETBYTE ();
3253         switch (op[1] & 0x00)
3254         {
3255           case 0x00:
3256             goto op_semantics_24;
3257             break;
3258         }
3259       break;
3260     case 0x8a:
3261         GETBYTE ();
3262         switch (op[1] & 0x00)
3263         {
3264           case 0x00:
3265             goto op_semantics_24;
3266             break;
3267         }
3268       break;
3269     case 0x8b:
3270         GETBYTE ();
3271         switch (op[1] & 0x00)
3272         {
3273           case 0x00:
3274             goto op_semantics_24;
3275             break;
3276         }
3277       break;
3278     case 0x8c:
3279         GETBYTE ();
3280         switch (op[1] & 0x00)
3281         {
3282           case 0x00:
3283             goto op_semantics_24;
3284             break;
3285         }
3286       break;
3287     case 0x8d:
3288         GETBYTE ();
3289         switch (op[1] & 0x00)
3290         {
3291           case 0x00:
3292             goto op_semantics_24;
3293             break;
3294         }
3295       break;
3296     case 0x8e:
3297         GETBYTE ();
3298         switch (op[1] & 0x00)
3299         {
3300           case 0x00:
3301             goto op_semantics_24;
3302             break;
3303         }
3304       break;
3305     case 0x8f:
3306         GETBYTE ();
3307         switch (op[1] & 0x00)
3308         {
3309           case 0x00:
3310             goto op_semantics_24;
3311             break;
3312         }
3313       break;
3314     case 0x90:
3315         GETBYTE ();
3316         switch (op[1] & 0x00)
3317         {
3318           case 0x00:
3319             goto op_semantics_24;
3320             break;
3321         }
3322       break;
3323     case 0x91:
3324         GETBYTE ();
3325         switch (op[1] & 0x00)
3326         {
3327           case 0x00:
3328             goto op_semantics_24;
3329             break;
3330         }
3331       break;
3332     case 0x92:
3333         GETBYTE ();
3334         switch (op[1] & 0x00)
3335         {
3336           case 0x00:
3337             goto op_semantics_24;
3338             break;
3339         }
3340       break;
3341     case 0x93:
3342         GETBYTE ();
3343         switch (op[1] & 0x00)
3344         {
3345           case 0x00:
3346             goto op_semantics_24;
3347             break;
3348         }
3349       break;
3350     case 0x94:
3351         GETBYTE ();
3352         switch (op[1] & 0x00)
3353         {
3354           case 0x00:
3355             goto op_semantics_24;
3356             break;
3357         }
3358       break;
3359     case 0x95:
3360         GETBYTE ();
3361         switch (op[1] & 0x00)
3362         {
3363           case 0x00:
3364             goto op_semantics_24;
3365             break;
3366         }
3367       break;
3368     case 0x96:
3369         GETBYTE ();
3370         switch (op[1] & 0x00)
3371         {
3372           case 0x00:
3373             goto op_semantics_24;
3374             break;
3375         }
3376       break;
3377     case 0x97:
3378         GETBYTE ();
3379         switch (op[1] & 0x00)
3380         {
3381           case 0x00:
3382             goto op_semantics_24;
3383             break;
3384         }
3385       break;
3386     case 0x98:
3387         GETBYTE ();
3388         switch (op[1] & 0x00)
3389         {
3390           case 0x00:
3391             goto op_semantics_24;
3392             break;
3393         }
3394       break;
3395     case 0x99:
3396         GETBYTE ();
3397         switch (op[1] & 0x00)
3398         {
3399           case 0x00:
3400             goto op_semantics_24;
3401             break;
3402         }
3403       break;
3404     case 0x9a:
3405         GETBYTE ();
3406         switch (op[1] & 0x00)
3407         {
3408           case 0x00:
3409             goto op_semantics_24;
3410             break;
3411         }
3412       break;
3413     case 0x9b:
3414         GETBYTE ();
3415         switch (op[1] & 0x00)
3416         {
3417           case 0x00:
3418             goto op_semantics_24;
3419             break;
3420         }
3421       break;
3422     case 0x9c:
3423         GETBYTE ();
3424         switch (op[1] & 0x00)
3425         {
3426           case 0x00:
3427             goto op_semantics_24;
3428             break;
3429         }
3430       break;
3431     case 0x9d:
3432         GETBYTE ();
3433         switch (op[1] & 0x00)
3434         {
3435           case 0x00:
3436             goto op_semantics_24;
3437             break;
3438         }
3439       break;
3440     case 0x9e:
3441         GETBYTE ();
3442         switch (op[1] & 0x00)
3443         {
3444           case 0x00:
3445             goto op_semantics_24;
3446             break;
3447         }
3448       break;
3449     case 0x9f:
3450         GETBYTE ();
3451         switch (op[1] & 0x00)
3452         {
3453           case 0x00:
3454             goto op_semantics_24;
3455             break;
3456         }
3457       break;
3458     case 0xa0:
3459         GETBYTE ();
3460         switch (op[1] & 0x00)
3461         {
3462           case 0x00:
3463             goto op_semantics_24;
3464             break;
3465         }
3466       break;
3467     case 0xa1:
3468         GETBYTE ();
3469         switch (op[1] & 0x00)
3470         {
3471           case 0x00:
3472             goto op_semantics_24;
3473             break;
3474         }
3475       break;
3476     case 0xa2:
3477         GETBYTE ();
3478         switch (op[1] & 0x00)
3479         {
3480           case 0x00:
3481             goto op_semantics_24;
3482             break;
3483         }
3484       break;
3485     case 0xa3:
3486         GETBYTE ();
3487         switch (op[1] & 0x00)
3488         {
3489           case 0x00:
3490             goto op_semantics_24;
3491             break;
3492         }
3493       break;
3494     case 0xa4:
3495         GETBYTE ();
3496         switch (op[1] & 0x00)
3497         {
3498           case 0x00:
3499             goto op_semantics_24;
3500             break;
3501         }
3502       break;
3503     case 0xa5:
3504         GETBYTE ();
3505         switch (op[1] & 0x00)
3506         {
3507           case 0x00:
3508             goto op_semantics_24;
3509             break;
3510         }
3511       break;
3512     case 0xa6:
3513         GETBYTE ();
3514         switch (op[1] & 0x00)
3515         {
3516           case 0x00:
3517             goto op_semantics_24;
3518             break;
3519         }
3520       break;
3521     case 0xa7:
3522         GETBYTE ();
3523         switch (op[1] & 0x00)
3524         {
3525           case 0x00:
3526             goto op_semantics_24;
3527             break;
3528         }
3529       break;
3530     case 0xa8:
3531         GETBYTE ();
3532         switch (op[1] & 0x00)
3533         {
3534           case 0x00:
3535             goto op_semantics_24;
3536             break;
3537         }
3538       break;
3539     case 0xa9:
3540         GETBYTE ();
3541         switch (op[1] & 0x00)
3542         {
3543           case 0x00:
3544             goto op_semantics_24;
3545             break;
3546         }
3547       break;
3548     case 0xaa:
3549         GETBYTE ();
3550         switch (op[1] & 0x00)
3551         {
3552           case 0x00:
3553             goto op_semantics_24;
3554             break;
3555         }
3556       break;
3557     case 0xab:
3558         GETBYTE ();
3559         switch (op[1] & 0x00)
3560         {
3561           case 0x00:
3562             goto op_semantics_24;
3563             break;
3564         }
3565       break;
3566     case 0xac:
3567         GETBYTE ();
3568         switch (op[1] & 0x00)
3569         {
3570           case 0x00:
3571             goto op_semantics_24;
3572             break;
3573         }
3574       break;
3575     case 0xad:
3576         GETBYTE ();
3577         switch (op[1] & 0x00)
3578         {
3579           case 0x00:
3580             goto op_semantics_24;
3581             break;
3582         }
3583       break;
3584     case 0xae:
3585         GETBYTE ();
3586         switch (op[1] & 0x00)
3587         {
3588           case 0x00:
3589             goto op_semantics_24;
3590             break;
3591         }
3592       break;
3593     case 0xaf:
3594         GETBYTE ();
3595         switch (op[1] & 0x00)
3596         {
3597           case 0x00:
3598             goto op_semantics_24;
3599             break;
3600         }
3601       break;
3602     case 0xb0:
3603         GETBYTE ();
3604         switch (op[1] & 0x00)
3605         {
3606           case 0x00:
3607             goto op_semantics_24;
3608             break;
3609         }
3610       break;
3611     case 0xb1:
3612         GETBYTE ();
3613         switch (op[1] & 0x00)
3614         {
3615           case 0x00:
3616             goto op_semantics_24;
3617             break;
3618         }
3619       break;
3620     case 0xb2:
3621         GETBYTE ();
3622         switch (op[1] & 0x00)
3623         {
3624           case 0x00:
3625             goto op_semantics_24;
3626             break;
3627         }
3628       break;
3629     case 0xb3:
3630         GETBYTE ();
3631         switch (op[1] & 0x00)
3632         {
3633           case 0x00:
3634             goto op_semantics_24;
3635             break;
3636         }
3637       break;
3638     case 0xb4:
3639         GETBYTE ();
3640         switch (op[1] & 0x00)
3641         {
3642           case 0x00:
3643             goto op_semantics_24;
3644             break;
3645         }
3646       break;
3647     case 0xb5:
3648         GETBYTE ();
3649         switch (op[1] & 0x00)
3650         {
3651           case 0x00:
3652             goto op_semantics_24;
3653             break;
3654         }
3655       break;
3656     case 0xb6:
3657         GETBYTE ();
3658         switch (op[1] & 0x00)
3659         {
3660           case 0x00:
3661             goto op_semantics_24;
3662             break;
3663         }
3664       break;
3665     case 0xb7:
3666         GETBYTE ();
3667         switch (op[1] & 0x00)
3668         {
3669           case 0x00:
3670             goto op_semantics_24;
3671             break;
3672         }
3673       break;
3674     case 0xb8:
3675         GETBYTE ();
3676         switch (op[1] & 0x00)
3677         {
3678           case 0x00:
3679             goto op_semantics_24;
3680             break;
3681         }
3682       break;
3683     case 0xb9:
3684         GETBYTE ();
3685         switch (op[1] & 0x00)
3686         {
3687           case 0x00:
3688             goto op_semantics_24;
3689             break;
3690         }
3691       break;
3692     case 0xba:
3693         GETBYTE ();
3694         switch (op[1] & 0x00)
3695         {
3696           case 0x00:
3697             goto op_semantics_24;
3698             break;
3699         }
3700       break;
3701     case 0xbb:
3702         GETBYTE ();
3703         switch (op[1] & 0x00)
3704         {
3705           case 0x00:
3706             goto op_semantics_24;
3707             break;
3708         }
3709       break;
3710     case 0xbc:
3711         GETBYTE ();
3712         switch (op[1] & 0x00)
3713         {
3714           case 0x00:
3715             goto op_semantics_24;
3716             break;
3717         }
3718       break;
3719     case 0xbd:
3720         GETBYTE ();
3721         switch (op[1] & 0x00)
3722         {
3723           case 0x00:
3724             goto op_semantics_24;
3725             break;
3726         }
3727       break;
3728     case 0xbe:
3729         GETBYTE ();
3730         switch (op[1] & 0x00)
3731         {
3732           case 0x00:
3733             goto op_semantics_24;
3734             break;
3735         }
3736       break;
3737     case 0xbf:
3738         GETBYTE ();
3739         switch (op[1] & 0x00)
3740         {
3741           case 0x00:
3742             goto op_semantics_24;
3743             break;
3744         }
3745       break;
3746     case 0xc0:
3747         GETBYTE ();
3748         switch (op[1] & 0x00)
3749         {
3750           case 0x00:
3751             goto op_semantics_24;
3752             break;
3753         }
3754       break;
3755     case 0xc1:
3756         GETBYTE ();
3757         switch (op[1] & 0x00)
3758         {
3759           case 0x00:
3760             goto op_semantics_24;
3761             break;
3762         }
3763       break;
3764     case 0xc2:
3765         GETBYTE ();
3766         switch (op[1] & 0x00)
3767         {
3768           case 0x00:
3769             goto op_semantics_24;
3770             break;
3771         }
3772       break;
3773     case 0xc3:
3774         GETBYTE ();
3775         switch (op[1] & 0x00)
3776         {
3777           case 0x00:
3778             goto op_semantics_24;
3779             break;
3780         }
3781       break;
3782     case 0xc4:
3783         GETBYTE ();
3784         switch (op[1] & 0x00)
3785         {
3786           case 0x00:
3787             goto op_semantics_24;
3788             break;
3789         }
3790       break;
3791     case 0xc5:
3792         GETBYTE ();
3793         switch (op[1] & 0x00)
3794         {
3795           case 0x00:
3796             goto op_semantics_24;
3797             break;
3798         }
3799       break;
3800     case 0xc6:
3801         GETBYTE ();
3802         switch (op[1] & 0x00)
3803         {
3804           case 0x00:
3805             goto op_semantics_24;
3806             break;
3807         }
3808       break;
3809     case 0xc7:
3810         GETBYTE ();
3811         switch (op[1] & 0x00)
3812         {
3813           case 0x00:
3814             goto op_semantics_24;
3815             break;
3816         }
3817       break;
3818     case 0xc8:
3819         GETBYTE ();
3820         switch (op[1] & 0x00)
3821         {
3822           case 0x00:
3823             goto op_semantics_24;
3824             break;
3825         }
3826       break;
3827     case 0xc9:
3828         GETBYTE ();
3829         switch (op[1] & 0x00)
3830         {
3831           case 0x00:
3832             goto op_semantics_24;
3833             break;
3834         }
3835       break;
3836     case 0xca:
3837         GETBYTE ();
3838         switch (op[1] & 0x00)
3839         {
3840           case 0x00:
3841             goto op_semantics_24;
3842             break;
3843         }
3844       break;
3845     case 0xcb:
3846         GETBYTE ();
3847         switch (op[1] & 0x00)
3848         {
3849           case 0x00:
3850             goto op_semantics_24;
3851             break;
3852         }
3853       break;
3854     case 0xcc:
3855         GETBYTE ();
3856         switch (op[1] & 0x00)
3857         {
3858           case 0x00:
3859             goto op_semantics_24;
3860             break;
3861         }
3862       break;
3863     case 0xcd:
3864         GETBYTE ();
3865         switch (op[1] & 0x00)
3866         {
3867           case 0x00:
3868             goto op_semantics_24;
3869             break;
3870         }
3871       break;
3872     case 0xce:
3873         GETBYTE ();
3874         switch (op[1] & 0x00)
3875         {
3876           case 0x00:
3877             goto op_semantics_24;
3878             break;
3879         }
3880       break;
3881     case 0xcf:
3882         GETBYTE ();
3883         switch (op[1] & 0x00)
3884         {
3885           case 0x00:
3886             goto op_semantics_24;
3887             break;
3888         }
3889       break;
3890     case 0xd0:
3891         GETBYTE ();
3892         switch (op[1] & 0x00)
3893         {
3894           case 0x00:
3895             goto op_semantics_24;
3896             break;
3897         }
3898       break;
3899     case 0xd1:
3900         GETBYTE ();
3901         switch (op[1] & 0x00)
3902         {
3903           case 0x00:
3904             goto op_semantics_24;
3905             break;
3906         }
3907       break;
3908     case 0xd2:
3909         GETBYTE ();
3910         switch (op[1] & 0x00)
3911         {
3912           case 0x00:
3913             goto op_semantics_24;
3914             break;
3915         }
3916       break;
3917     case 0xd3:
3918         GETBYTE ();
3919         switch (op[1] & 0x00)
3920         {
3921           case 0x00:
3922             goto op_semantics_24;
3923             break;
3924         }
3925       break;
3926     case 0xd4:
3927         GETBYTE ();
3928         switch (op[1] & 0x00)
3929         {
3930           case 0x00:
3931             goto op_semantics_24;
3932             break;
3933         }
3934       break;
3935     case 0xd5:
3936         GETBYTE ();
3937         switch (op[1] & 0x00)
3938         {
3939           case 0x00:
3940             goto op_semantics_24;
3941             break;
3942         }
3943       break;
3944     case 0xd6:
3945         GETBYTE ();
3946         switch (op[1] & 0x00)
3947         {
3948           case 0x00:
3949             goto op_semantics_24;
3950             break;
3951         }
3952       break;
3953     case 0xd7:
3954         GETBYTE ();
3955         switch (op[1] & 0x00)
3956         {
3957           case 0x00:
3958             goto op_semantics_24;
3959             break;
3960         }
3961       break;
3962     case 0xd8:
3963         GETBYTE ();
3964         switch (op[1] & 0x00)
3965         {
3966           case 0x00:
3967             goto op_semantics_24;
3968             break;
3969         }
3970       break;
3971     case 0xd9:
3972         GETBYTE ();
3973         switch (op[1] & 0x00)
3974         {
3975           case 0x00:
3976             goto op_semantics_24;
3977             break;
3978         }
3979       break;
3980     case 0xda:
3981         GETBYTE ();
3982         switch (op[1] & 0x00)
3983         {
3984           case 0x00:
3985             goto op_semantics_24;
3986             break;
3987         }
3988       break;
3989     case 0xdb:
3990         GETBYTE ();
3991         switch (op[1] & 0x00)
3992         {
3993           case 0x00:
3994             goto op_semantics_24;
3995             break;
3996         }
3997       break;
3998     case 0xdc:
3999         GETBYTE ();
4000         switch (op[1] & 0x00)
4001         {
4002           case 0x00:
4003             goto op_semantics_24;
4004             break;
4005         }
4006       break;
4007     case 0xdd:
4008         GETBYTE ();
4009         switch (op[1] & 0x00)
4010         {
4011           case 0x00:
4012             goto op_semantics_24;
4013             break;
4014         }
4015       break;
4016     case 0xde:
4017         GETBYTE ();
4018         switch (op[1] & 0x00)
4019         {
4020           case 0x00:
4021             goto op_semantics_24;
4022             break;
4023         }
4024       break;
4025     case 0xdf:
4026         GETBYTE ();
4027         switch (op[1] & 0x00)
4028         {
4029           case 0x00:
4030             goto op_semantics_24;
4031             break;
4032         }
4033       break;
4034     case 0xe0:
4035         GETBYTE ();
4036         switch (op[1] & 0x00)
4037         {
4038           case 0x00:
4039             goto op_semantics_24;
4040             break;
4041         }
4042       break;
4043     case 0xe1:
4044         GETBYTE ();
4045         switch (op[1] & 0x00)
4046         {
4047           case 0x00:
4048             goto op_semantics_24;
4049             break;
4050         }
4051       break;
4052     case 0xe2:
4053         GETBYTE ();
4054         switch (op[1] & 0x00)
4055         {
4056           case 0x00:
4057             goto op_semantics_24;
4058             break;
4059         }
4060       break;
4061     case 0xe3:
4062         GETBYTE ();
4063         switch (op[1] & 0x00)
4064         {
4065           case 0x00:
4066             goto op_semantics_24;
4067             break;
4068         }
4069       break;
4070     case 0xe4:
4071         GETBYTE ();
4072         switch (op[1] & 0x00)
4073         {
4074           case 0x00:
4075             goto op_semantics_24;
4076             break;
4077         }
4078       break;
4079     case 0xe5:
4080         GETBYTE ();
4081         switch (op[1] & 0x00)
4082         {
4083           case 0x00:
4084             goto op_semantics_24;
4085             break;
4086         }
4087       break;
4088     case 0xe6:
4089         GETBYTE ();
4090         switch (op[1] & 0x00)
4091         {
4092           case 0x00:
4093             goto op_semantics_24;
4094             break;
4095         }
4096       break;
4097     case 0xe7:
4098         GETBYTE ();
4099         switch (op[1] & 0x00)
4100         {
4101           case 0x00:
4102             goto op_semantics_24;
4103             break;
4104         }
4105       break;
4106     case 0xe8:
4107         GETBYTE ();
4108         switch (op[1] & 0x00)
4109         {
4110           case 0x00:
4111             goto op_semantics_24;
4112             break;
4113         }
4114       break;
4115     case 0xe9:
4116         GETBYTE ();
4117         switch (op[1] & 0x00)
4118         {
4119           case 0x00:
4120             goto op_semantics_24;
4121             break;
4122         }
4123       break;
4124     case 0xea:
4125         GETBYTE ();
4126         switch (op[1] & 0x00)
4127         {
4128           case 0x00:
4129             goto op_semantics_24;
4130             break;
4131         }
4132       break;
4133     case 0xeb:
4134         GETBYTE ();
4135         switch (op[1] & 0x00)
4136         {
4137           case 0x00:
4138             goto op_semantics_24;
4139             break;
4140         }
4141       break;
4142     case 0xec:
4143         GETBYTE ();
4144         switch (op[1] & 0x00)
4145         {
4146           case 0x00:
4147             goto op_semantics_24;
4148             break;
4149         }
4150       break;
4151     case 0xed:
4152         GETBYTE ();
4153         switch (op[1] & 0x00)
4154         {
4155           case 0x00:
4156             goto op_semantics_24;
4157             break;
4158         }
4159       break;
4160     case 0xee:
4161         GETBYTE ();
4162         switch (op[1] & 0x00)
4163         {
4164           case 0x00:
4165             goto op_semantics_24;
4166             break;
4167         }
4168       break;
4169     case 0xef:
4170         GETBYTE ();
4171         switch (op[1] & 0x00)
4172         {
4173           case 0x00:
4174             goto op_semantics_24;
4175             break;
4176         }
4177       break;
4178     case 0xf0:
4179         GETBYTE ();
4180         switch (op[1] & 0x00)
4181         {
4182           case 0x00:
4183             goto op_semantics_24;
4184             break;
4185         }
4186       break;
4187     case 0xf1:
4188         GETBYTE ();
4189         switch (op[1] & 0x00)
4190         {
4191           case 0x00:
4192             goto op_semantics_24;
4193             break;
4194         }
4195       break;
4196     case 0xf2:
4197         GETBYTE ();
4198         switch (op[1] & 0x00)
4199         {
4200           case 0x00:
4201             goto op_semantics_24;
4202             break;
4203         }
4204       break;
4205     case 0xf3:
4206         GETBYTE ();
4207         switch (op[1] & 0x00)
4208         {
4209           case 0x00:
4210             goto op_semantics_24;
4211             break;
4212         }
4213       break;
4214     case 0xf4:
4215         GETBYTE ();
4216         switch (op[1] & 0x00)
4217         {
4218           case 0x00:
4219             goto op_semantics_24;
4220             break;
4221         }
4222       break;
4223     case 0xf5:
4224         GETBYTE ();
4225         switch (op[1] & 0x00)
4226         {
4227           case 0x00:
4228             goto op_semantics_24;
4229             break;
4230         }
4231       break;
4232     case 0xf6:
4233         GETBYTE ();
4234         switch (op[1] & 0x00)
4235         {
4236           case 0x00:
4237             goto op_semantics_24;
4238             break;
4239         }
4240       break;
4241     case 0xf7:
4242         GETBYTE ();
4243         switch (op[1] & 0x00)
4244         {
4245           case 0x00:
4246             goto op_semantics_24;
4247             break;
4248         }
4249       break;
4250     case 0xf8:
4251         GETBYTE ();
4252         switch (op[1] & 0x00)
4253         {
4254           case 0x00:
4255             goto op_semantics_24;
4256             break;
4257         }
4258       break;
4259     case 0xf9:
4260         GETBYTE ();
4261         switch (op[1] & 0x00)
4262         {
4263           case 0x00:
4264             goto op_semantics_24;
4265             break;
4266         }
4267       break;
4268     case 0xfa:
4269         GETBYTE ();
4270         switch (op[1] & 0x00)
4271         {
4272           case 0x00:
4273             goto op_semantics_24;
4274             break;
4275         }
4276       break;
4277     case 0xfb:
4278         GETBYTE ();
4279         switch (op[1] & 0x00)
4280         {
4281           case 0x00:
4282             goto op_semantics_24;
4283             break;
4284         }
4285       break;
4286     case 0xfc:
4287         GETBYTE ();
4288         switch (op[1] & 0x00)
4289         {
4290           case 0x00:
4291             goto op_semantics_24;
4292             break;
4293         }
4294       break;
4295     case 0xfd:
4296         GETBYTE ();
4297         switch (op[1] & 0x00)
4298         {
4299           case 0x00:
4300             goto op_semantics_24;
4301             break;
4302         }
4303       break;
4304     case 0xfe:
4305         GETBYTE ();
4306         switch (op[1] & 0x00)
4307         {
4308           case 0x00:
4309             goto op_semantics_24;
4310             break;
4311         }
4312       break;
4313     case 0xff:
4314         GETBYTE ();
4315         switch (op[1] & 0x00)
4316         {
4317           case 0x00:
4318             goto op_semantics_24;
4319             break;
4320         }
4321       break;
4322   }
4323 #line 569 "msp430-decode.opc"
4324
4325   /*printf("<\033[34m%d\033[0m>", msp430->n_bytes);*/
4326   return msp430->n_bytes;
4327 }