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