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