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