opcodes/msp430-decode.c

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