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