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