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