| OLD | NEW |
|---|
| (Empty) | |
| 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->fla
gs_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 c
ount %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 u
se |
| 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 } |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 124383005:
GDB 7.6.50 (Closed)
Base URL: http://git.chromium.org/native_client/nacl-gdb.git@upstream