opcodes/msp430-decode.c

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