[BACK]Return to msp430-decode.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / external / gpl3 / binutils / dist / opcodes

Annotation of src/external/gpl3/binutils/dist/opcodes/msp430-decode.c, Revision 1.1.1.3.2.2

1.1.1.3.2.1  christos    1: /* DO NOT EDIT!  -*- buffer-read-only: t -*- vi:set ro:  */
1.1       christos    2: #line 1 "msp430-decode.opc"
                      3: /* -*- c -*- */
1.1.1.3.2.2! martin      4: /* Copyright (C) 2013-2020 Free Software Foundation, Inc.
1.1       christos    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>
1.1.1.3.2.1  christos   29: #include "bfd.h"
                     30: #include "opintl.h"
1.1       christos   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:
1.1.1.3.2.1  christos  146:       opcodes_error_handler
                    147:        (_("internal error: immediate() called with invalid byte count %d"),
                    148:           bytes);
1.1       christos  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);
1.1.1.3   christos  243:          break;
1.1       christos  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 */
1.1.1.3.2.1  christos  364: #line 440 "msp430-decode.opc"
1.1       christos  365:                 int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1  christos  366: #line 440 "msp430-decode.opc"
1.1       christos  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");
1.1.1.3.2.1  christos  377: #line 440 "msp430-decode.opc"
1.1       christos  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 */
1.1.1.3.2.1  christos  388: #line 445 "msp430-decode.opc"
1.1       christos  389:                 int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1  christos  390: #line 445 "msp430-decode.opc"
1.1       christos  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");
1.1.1.3.2.1  christos  401: #line 445 "msp430-decode.opc"
1.1       christos  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 */
1.1.1.3.2.1  christos  412: #line 450 "msp430-decode.opc"
1.1       christos  413:                 int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1  christos  414: #line 450 "msp430-decode.opc"
1.1       christos  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");
1.1.1.3.2.1  christos  425: #line 450 "msp430-decode.opc"
1.1       christos  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 */
1.1.1.3.2.1  christos  436: #line 455 "msp430-decode.opc"
1.1       christos  437:                 int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1  christos  438: #line 455 "msp430-decode.opc"
1.1       christos  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");
1.1.1.3.2.1  christos  449: #line 455 "msp430-decode.opc"
1.1       christos  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 */
1.1.1.3.2.1  christos  461: #line 522 "msp430-decode.opc"
1.1       christos  462:                 int bt AU = (op[0] >> 2) & 0x03;
1.1.1.3.2.1  christos  463: #line 522 "msp430-decode.opc"
1.1       christos  464:                 int w AU = (op[1] >> 4) & 0x01;
1.1.1.3.2.1  christos  465: #line 522 "msp430-decode.opc"
1.1       christos  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");
1.1.1.3.2.1  christos  477: #line 522 "msp430-decode.opc"
1.1       christos  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 */
1.1.1.3.2.1  christos  490: #line 460 "msp430-decode.opc"
1.1       christos  491:                 int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1  christos  492: #line 460 "msp430-decode.opc"
1.1       christos  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");
1.1.1.3.2.1  christos  503: #line 460 "msp430-decode.opc"
1.1       christos  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 */
1.1.1.3.2.1  christos  514: #line 465 "msp430-decode.opc"
1.1       christos  515:                 int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1  christos  516: #line 465 "msp430-decode.opc"
1.1       christos  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");
1.1.1.3.2.1  christos  527: #line 465 "msp430-decode.opc"
1.1       christos  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 */
1.1.1.3.2.1  christos  538: #line 470 "msp430-decode.opc"
1.1       christos  539:                 int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1  christos  540: #line 470 "msp430-decode.opc"
1.1       christos  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");
1.1.1.3.2.1  christos  551: #line 470 "msp430-decode.opc"
1.1       christos  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 */
1.1.1.3.2.1  christos  562: #line 475 "msp430-decode.opc"
1.1       christos  563:                 int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1  christos  564: #line 475 "msp430-decode.opc"
1.1       christos  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");
1.1.1.3.2.1  christos  575: #line 475 "msp430-decode.opc"
1.1       christos  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 */
1.1.1.3.2.1  christos  587: #line 481 "msp430-decode.opc"
1.1       christos  588:                 int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1  christos  589: #line 481 "msp430-decode.opc"
1.1       christos  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");
1.1.1.3.2.1  christos  600: #line 481 "msp430-decode.opc"
1.1       christos  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 */
1.1.1.3.2.1  christos  612: #line 487 "msp430-decode.opc"
1.1       christos  613:                 int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1  christos  614: #line 487 "msp430-decode.opc"
1.1       christos  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");
1.1.1.3.2.1  christos  625: #line 487 "msp430-decode.opc"
1.1       christos  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 */
1.1.1.3.2.1  christos  637: #line 499 "msp430-decode.opc"
1.1       christos  638:                 int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1  christos  639: #line 499 "msp430-decode.opc"
1.1       christos  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");
1.1.1.3.2.1  christos  650: #line 499 "msp430-decode.opc"
1.1       christos  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 */
1.1.1.3.2.1  christos  661: #line 504 "msp430-decode.opc"
1.1       christos  662:                 int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1  christos  663: #line 504 "msp430-decode.opc"
1.1       christos  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");
1.1.1.3.2.1  christos  674: #line 504 "msp430-decode.opc"
1.1       christos  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 */
1.1.1.3.2.1  christos  686: #line 510 "msp430-decode.opc"
1.1       christos  687:                 int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1  christos  688: #line 510 "msp430-decode.opc"
1.1       christos  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");
1.1.1.3.2.1  christos  699: #line 510 "msp430-decode.opc"
1.1       christos  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 */
1.1.1.3.2.1  christos  711: #line 516 "msp430-decode.opc"
1.1       christos  712:                 int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1  christos  713: #line 516 "msp430-decode.opc"
1.1       christos  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");
1.1.1.3.2.1  christos  724: #line 516 "msp430-decode.opc"
1.1       christos  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 */
1.1.1.3.2.1  christos  755: #line 529 "msp430-decode.opc"
1.1       christos  756:                 int bt AU = (op[0] >> 2) & 0x03;
1.1.1.3.2.1  christos  757: #line 529 "msp430-decode.opc"
1.1       christos  758:                 int w AU = (op[1] >> 4) & 0x01;
1.1.1.3.2.1  christos  759: #line 529 "msp430-decode.opc"
1.1       christos  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");
1.1.1.3.2.1  christos  771: #line 529 "msp430-decode.opc"
1.1       christos  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 */
1.1.1.3.2.1  christos  833: #line 536 "msp430-decode.opc"
1.1       christos  834:                 int bt AU = (op[0] >> 2) & 0x03;
1.1.1.3.2.1  christos  835: #line 536 "msp430-decode.opc"
1.1       christos  836:                 int w AU = (op[1] >> 4) & 0x01;
1.1.1.3.2.1  christos  837: #line 536 "msp430-decode.opc"
1.1       christos  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");
1.1.1.3.2.1  christos  849: #line 536 "msp430-decode.opc"
1.1       christos  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 */
1.1.1.3.2.1  christos  911: #line 543 "msp430-decode.opc"
1.1       christos  912:                 int bt AU = (op[0] >> 2) & 0x03;
1.1.1.3.2.1  christos  913: #line 543 "msp430-decode.opc"
1.1       christos  914:                 int w AU = (op[1] >> 4) & 0x01;
1.1.1.3.2.1  christos  915: #line 543 "msp430-decode.opc"
1.1       christos  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");
1.1.1.3.2.1  christos  927: #line 543 "msp430-decode.opc"
1.1       christos  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                              */
1.1.1.3.2.1  christos 1600: #line 396 "msp430-decode.opc"
1.1       christos 1601:                 int so AU = op[0] & 0x03;
1.1.1.3.2.1  christos 1602: #line 396 "msp430-decode.opc"
1.1       christos 1603:                 int c AU = (op[1] >> 7) & 0x01;
1.1.1.3.2.1  christos 1604: #line 396 "msp430-decode.opc"
1.1       christos 1605:                 int b AU = (op[1] >> 6) & 0x01;
1.1.1.3.2.1  christos 1606: #line 396 "msp430-decode.opc"
1.1       christos 1607:                 int ad AU = (op[1] >> 4) & 0x03;
1.1.1.3.2.1  christos 1608: #line 396 "msp430-decode.opc"
1.1       christos 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");
1.1.1.3.2.1  christos 1622: #line 396 "msp430-decode.opc"
1.1       christos 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");
1.1.1.3.2.1  christos 1688: #line 550 "msp430-decode.opc"
1.1       christos 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 */
1.1.1.3.2.1  christos 1906: #line 555 "msp430-decode.opc"
1.1       christos 1907:                 int as AU = (op[1] >> 4) & 0x03;
1.1.1.3.2.1  christos 1908: #line 555 "msp430-decode.opc"
1.1       christos 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");
1.1.1.3.2.1  christos 1919: #line 555 "msp430-decode.opc"
1.1       christos 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 */
1.1.1.3.2.1  christos 1944: #line 560 "msp430-decode.opc"
1.1       christos 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");
1.1.1.3.2.1  christos 1954: #line 560 "msp430-decode.opc"
1.1       christos 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 */
1.1.1.3.2.1  christos 1979: #line 565 "msp430-decode.opc"
1.1       christos 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");
1.1.1.3.2.1  christos 1989: #line 565 "msp430-decode.opc"
1.1       christos 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 */
1.1.1.3.2.1  christos 2017: #line 573 "msp430-decode.opc"
1.1       christos 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");
1.1.1.3.2.1  christos 2027: #line 573 "msp430-decode.opc"
1.1       christos 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 */
1.1.1.3.2.1  christos 2044: #line 578 "msp430-decode.opc"
1.1       christos 2045:                 int w AU = op[0] & 0x01;
1.1.1.3.2.1  christos 2046: #line 578 "msp430-decode.opc"
1.1       christos 2047:                 int bits AU = (op[1] >> 4) & 0x0f;
1.1.1.3.2.1  christos 2048: #line 578 "msp430-decode.opc"
1.1       christos 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");
1.1.1.3.2.1  christos 2060: #line 578 "msp430-decode.opc"
1.1       christos 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 */
1.1.1.3.2.1  christos 2087: #line 584 "msp430-decode.opc"
1.1       christos 2088:                 int w AU = op[0] & 0x01;
1.1.1.3.2.1  christos 2089: #line 584 "msp430-decode.opc"
1.1       christos 2090:                 int bits AU = (op[1] >> 4) & 0x0f;
1.1.1.3.2.1  christos 2091: #line 584 "msp430-decode.opc"
1.1       christos 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");
1.1.1.3.2.1  christos 2103: #line 584 "msp430-decode.opc"
1.1       christos 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 */
1.1.1.3.2.1  christos 2130: #line 352 "msp430-decode.opc"
1.1       christos 2131:                 int srx AU = op[0] & 0x07;
1.1.1.3.2.1  christos 2132: #line 352 "msp430-decode.opc"
1.1       christos 2133:                 int t AU = (op[1] >> 7) & 0x01;
1.1.1.3.2.1  christos 2134: #line 352 "msp430-decode.opc"
1.1       christos 2135:                 int l AU = (op[1] >> 6) & 0x01;
1.1.1.3.2.1  christos 2136: #line 352 "msp430-decode.opc"
1.1       christos 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");
1.1.1.3.2.1  christos 2149: #line 352 "msp430-decode.opc"
1.1       christos 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                              */
1.1.1.3.2.1  christos 2252: #line 426 "msp430-decode.opc"
1.1       christos 2253:                 int jmp AU = (op[0] >> 2) & 0x07;
1.1.1.3.2.1  christos 2254: #line 426 "msp430-decode.opc"
1.1       christos 2255:                 int aa AU = op[0] & 0x03;
1.1.1.3.2.1  christos 2256: #line 426 "msp430-decode.opc"
1.1       christos 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");
1.1.1.3.2.1  christos 2268: #line 426 "msp430-decode.opc"
1.1       christos 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                           */
1.1.1.3.2.1  christos 2573: #line 373 "msp430-decode.opc"
1.1       christos 2574:                 int dopc AU = (op[0] >> 4) & 0x0f;
1.1.1.3.2.1  christos 2575: #line 373 "msp430-decode.opc"
1.1       christos 2576:                 int sreg AU = op[0] & 0x0f;
1.1.1.3.2.1  christos 2577: #line 373 "msp430-decode.opc"
1.1       christos 2578:                 int a AU = (op[1] >> 7) & 0x01;
1.1.1.3.2.1  christos 2579: #line 373 "msp430-decode.opc"
1.1       christos 2580:                 int b AU = (op[1] >> 6) & 0x01;
1.1.1.3.2.1  christos 2581: #line 373 "msp430-decode.opc"
1.1       christos 2582:                 int as AU = (op[1] >> 4) & 0x03;
1.1.1.3.2.1  christos 2583: #line 373 "msp430-decode.opc"
1.1       christos 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");
1.1.1.3.2.1  christos 2598: #line 373 "msp430-decode.opc"
1.1       christos 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:   }
1.1.1.3.2.1  christos 4345: #line 590 "msp430-decode.opc"
1.1       christos 4346:
                   4347:   return msp430->n_bytes;
                   4348: }

CVSweb <webmaster@jp.NetBSD.org>