m32c.opc revision 1.1.1.4
1 /* m32c.opc --- semantics for m32c opcodes. -*- mode: c -*- 2 3 Copyright (C) 2005-2015 Free Software Foundation, Inc. 4 Contributed by Red Hat, Inc. 5 6 This file is part of the GNU simulators. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21 22 #include <stdio.h> 23 #include <stdlib.h> 24 25 #include "cpu.h" 26 #include "mem.h" 27 #include "misc.h" 28 #include "int.h" 29 30 #define AU __attribute__((unused)) 31 32 #define tprintf if (trace) printf 33 34 static unsigned char 35 getbyte () 36 { 37 int tsave = trace; 38 unsigned char b; 39 40 if (trace == 1) 41 trace = 0; 42 b = mem_get_pc (); 43 regs.r_pc ++; 44 trace = tsave; 45 return b; 46 } 47 48 #define M32C_ONLY() /* FIXME: add something here */ 49 50 #define GETBYTE() (op[opi++] = getbyte()) 51 52 #define UNSUPPORTED() unsupported("unsupported", m32c_opcode_pc) 53 #define NOTYET() unsupported("unimplemented", m32c_opcode_pc) 54 55 static void 56 unsupported (char *tag, int orig_pc) 57 { 58 int i; 59 printf("%s opcode at %08x\n", tag, orig_pc); 60 regs.r_pc = orig_pc; 61 for (i=0; i<2; i++) 62 { 63 int b = mem_get_pc(); 64 printf(" %s", bits(b>>4, 4)); 65 printf(" %s", bits(b, 4)); 66 regs.r_pc ++; 67 } 68 printf("\n"); 69 regs.r_pc = orig_pc; 70 for (i=0; i<6; i++) 71 { 72 printf(" %02x", mem_get_pc ()); 73 regs.r_pc ++; 74 } 75 printf("\n"); 76 exit(1); 77 } 78 79 static int 80 IMM(int bytes) 81 { 82 int rv = 0; 83 switch (bytes) 84 { 85 case 1: 86 rv = mem_get_qi (get_reg(pc)); 87 break; 88 case 2: 89 rv = mem_get_hi (get_reg(pc)); 90 break; 91 case 3: 92 rv = mem_get_psi (get_reg(pc)); 93 break; 94 case 4: 95 rv = mem_get_si (get_reg(pc)); 96 break; 97 } 98 regs.r_pc += bytes; 99 return rv; 100 } 101 102 #define IMM4() (immm >= 8 ? 7 - immm : immm + 1) 103 104 #define NO_PREFIX() PREFIX(0,0,0) 105 106 /* Indicate which sorts of prefixes are allowed for the current 107 opcode. */ 108 void 109 prefix (src_allowed, dest_allowed, index_bytewidth) 110 { 111 /* At the moment, we don't do anything with this information. We 112 just wanted to get the information entered in some 113 machine-readable form while we were going through all the 114 opcodes. */ 115 } 116 117 #define MATH_OP(dc,s,c,op) \ 118 { \ 119 int ma, mb; \ 120 ma = get_src(dc); \ 121 mb = s & b2mask[dc.bytes]; \ 122 ll = (long long)ma op (long long)mb op c; \ 123 tprintf("0x%x " #op " 0x%x " #op " 0x%x = 0x%llx\n", ma, mb, c, ll); \ 124 ma = sign_ext (ma, dc.bytes * 8); \ 125 mb = sign_ext (s, dc.bytes * 8); \ 126 v = ma op mb op c; \ 127 tprintf("%d " #op " %d " #op " %d = %d\n", ma, mb, c, v); \ 128 set_oszc (v, dc.bytes, (1 op 1) ? (ll > b2mask[dc.bytes]) : (ll >= 0)); \ 129 put_dest (dc, v); \ 130 } 131 132 #define LOGIC_OP(dc,s,op) \ 133 { \ 134 int ma, mb; \ 135 ma = get_src(dc); \ 136 mb = s & b2mask[dc.bytes]; \ 137 v = ma op mb; \ 138 tprintf("0x%x " #op " 0x%x = 0x%x\n", ma, mb, v); \ 139 set_sz (v, dc.bytes); \ 140 put_dest (dc, v); \ 141 } 142 143 #define BIT_OP(dc,bit,expr) \ 144 b = get_bit2 (dc, bitindex == -1 ? bit : bitindex); \ 145 v = expr; \ 146 tprintf ("b=%d, bit=%d, carry=%d, %s = %d\n", \ 147 b, bitindex == -1 ? bit : bitindex, carry, #expr, v); \ 148 put_bit2 (dc, bitindex == -1 ? bit : bitindex, v); 149 150 #define BIT_OPC(dc,bit,expr) \ 151 b = get_bit2 (dc, bitindex == -1 ? bit : bitindex); \ 152 v = expr; \ 153 tprintf ("b=%d, bit=%d, carry=%d, %s = %d\n", \ 154 b, bitindex == -1 ? bit : bitindex, carry, #expr, v); \ 155 set_c (v); 156 157 #define carry (FLAG_C ? 1 : 0) 158 159 static void 160 cmp (int d, int s, int bytes) 161 { 162 int a, b, f=0; 163 a = d - s; 164 b = sign_ext (d, bytes*8) - sign_ext (s, bytes*8); 165 tprintf ("cmp: %x - %x = %08x, %x - %x = %d\n", 166 d, s, a, 167 sign_ext(d,bytes*8), sign_ext(s,bytes*8), b); 168 169 if (b == 0) 170 f |= FLAGBIT_Z; 171 if (b & b2signbit[bytes]) 172 f |= FLAGBIT_S; 173 if ((d & b2mask[bytes]) >= (s & b2mask[bytes])) 174 f |= FLAGBIT_C; 175 if (b < b2minsigned[bytes] || b > b2maxsigned[bytes]) 176 f |= FLAGBIT_O; 177 178 set_flags (FLAGBIT_Z | FLAGBIT_S | FLAGBIT_O | FLAGBIT_C, f); 179 } 180 181 static void 182 dadd_op (int ddd, int dd, int sss, int ss, int imm, int add, int cy, int w) 183 { 184 srcdest sc, dc; 185 int a, b=0, res; 186 187 prefix (0, 0, 0); 188 189 if (!imm) 190 { 191 sc = decode_src23 (sss, ss, w+1); 192 b = get_src (sc); 193 } 194 dc = decode_dest23 (ddd, dd, w+1); 195 a = get_src (dc); 196 if (imm) 197 b = IMM(w+1); 198 199 a = bcd2int(a, w); 200 b = bcd2int(b, w); 201 202 tprintf("decimal: %d %s %d", a, add?"+":"-", b); 203 if (cy) 204 tprintf(" c=%d", carry); 205 206 if (add) 207 { 208 res = a + b; 209 if (cy) 210 res += carry; 211 cy = res > (w ? 9999 : 99); 212 } 213 else 214 { 215 res = a - b; 216 if (cy) 217 res -= (1-carry); 218 cy = res >= 0; 219 if (res < 0) 220 res += w ? 10000 : 100; 221 } 222 223 res = int2bcd (res, w); 224 tprintf(" = %x\n", res); 225 226 set_szc (res, w+1, cy); 227 228 put_dest (dc, res); 229 } 230 #define DADDV(A,C) dadd_op(ddd, dd, sss, ss, 0, A, C, w) 231 #define DADDI(A,C) dadd_op(ddd, dd, 0, 0, 1, A, C, w) 232 233 static void 234 div_op (int sss, int ss, int u, int x, int bytes) 235 { 236 srcdest sc; 237 int s, v, a, b; 238 239 if (sss == -1) 240 s = IMM(bytes); 241 else 242 { 243 sc = decode_dest23 (sss, ss, bytes); 244 s = get_src (sc); 245 } 246 247 v = get_reg (bytes > 1 ? r2r0 : r0); 248 249 if (!u) 250 { 251 /* FIXME? do we sign extend a0/a1 to .L? Docs say zero extend. */ 252 s = sign_ext (s, bytes*8); 253 v = sign_ext (v, bytes*8); 254 } 255 256 if (s == 0) 257 { 258 set_flags (FLAGBIT_O, FLAGBIT_O); 259 return; 260 } 261 262 if (u) 263 { 264 a = (unsigned int)v / (unsigned int)s; 265 b = (unsigned int)v % (unsigned int)s; 266 } 267 else 268 { 269 a = v / s; 270 b = v % s; 271 } 272 if (x) 273 { 274 if ((s > 0 && b < 0) 275 || (s < 0 && b > 0)) 276 { 277 a --; 278 b += s; 279 } 280 } 281 tprintf ("%d / %d = %d rem %d\n", v, s, a, b); 282 if ((!u && (a > b2maxsigned[bytes] 283 || a < b2minsigned[bytes])) 284 || (u && (a > b2mask[bytes]))) 285 set_flags (FLAGBIT_O, FLAGBIT_O); 286 else 287 set_flags (FLAGBIT_O, 0); 288 289 switch (bytes) 290 { 291 case 1: 292 put_reg (r0l, a); 293 put_reg (r0h, b); 294 break; 295 case 2: 296 put_reg (r0, a); 297 put_reg (r2, b); 298 break; 299 case 4: 300 put_reg (r2r0, a); 301 break; 302 } 303 } 304 305 static void 306 index_op (int sss, int ss, int do_s, int do_d, int scale, int w) 307 { 308 srcdest sc = decode_src23 (sss, ss, w+1); 309 int v = get_src (sc) * scale; 310 tprintf("%d = %d * %d, %d %d\n", v, get_src(sc), scale, do_s, do_d); 311 decode_index (do_s * v, do_d * v); 312 } 313 #define INDEXOP(scale,do_s,do_d) \ 314 index_op (sss, ss, do_s, do_d, scale, w); goto next_opcode 315 316 static void 317 rot_op (srcdest sd, int rotc, int count) 318 { 319 int mask = (sd.bytes == 2) ? 0xffff : 0xff; 320 int msb = (sd.bytes == 2) ? 0x8000 : 0x80; 321 int v = get_src (sd); 322 int c = carry, ct; 323 324 tprintf("%s %x by %d\n", rotc ? "rotc" : "rot", v, count); 325 tprintf (": %s %d\n", bits(v, 8*sd.bytes), c); 326 while (count > 0) 327 { 328 ct = (v & msb) ? 1 : 0; 329 v <<= 1; 330 v |= rotc ? c : ct; 331 v &= mask; 332 c = ct; 333 tprintf (": %s %d\n", bits(v, 8*sd.bytes), c); 334 count --; 335 } 336 while (count < 0) 337 { 338 ct = v & 1; 339 v >>= 1; 340 v |= (rotc ? c : ct) * msb; 341 c = ct; 342 tprintf (": %s %d\n", bits(v, 8*sd.bytes), c); 343 count ++; 344 } 345 put_dest (sd, v); 346 set_szc (v, sd.bytes, c); 347 } 348 349 static void 350 shift_op (srcdest sd, int arith, int count, int setc) 351 { 352 int mask = (sd.bytes == 2) ? 0xffff : 0xff; 353 int msb = (sd.bytes == 2) ? 0x8000 : 0x80; 354 int v = get_src (sd); 355 int c = 0; 356 int o = 0; 357 358 if (sd.bytes == 4) 359 { 360 mask = 0xffffffffU; 361 msb = 0x80000000U; 362 } 363 364 tprintf("%s %x by %d\n", arith ? "sha" : "shl", v, count); 365 tprintf (": %s %d %d\n", bits(v, 8*sd.bytes), c, o); 366 while (count > 0) 367 { 368 c = (v & msb) ? 1 : 0; 369 v <<= 1; 370 v &= mask; 371 if (c != ((v & msb) ? 1 : 0)) 372 o = 1; 373 tprintf (": %s %d %d\n", bits(v, 8*sd.bytes), c, o); 374 count --; 375 } 376 while (count < 0) 377 { 378 c = v & 1; 379 if (arith) 380 v = (v & msb) | (v >> 1); 381 else 382 v = (v >> 1) & (msb - 1); 383 tprintf (": %s %d %d\n", bits(v, 8*sd.bytes), c, o); 384 count ++; 385 } 386 put_dest (sd, v); 387 set_sz (v, sd.bytes); 388 if (setc) 389 set_c (c); 390 set_flags (FLAGBIT_O, o ? FLAGBIT_O : 0); 391 } 392 393 static int pcs[16]; 394 static int ipcs = 0; 395 396 int 397 decode_m32c() 398 { 399 unsigned char op[40]; 400 int opi; 401 int v, a, b; 402 long long ll; 403 srcdest sc, dc; 404 int imm; 405 int bitindex = -1; 406 int t0, t1=0, t2, t3=0; 407 int ta0, ta1, dif; 408 409 step_result = M32C_MAKE_STEPPED (); 410 411 decode_indirect (0, 0); 412 decode_index (0, 0); 413 414 next_opcode: 415 opi = 0; 416 m32c_opcode_pc = get_reg (pc); 417 418 tprintf("trace: decode pc = %06x\n", m32c_opcode_pc); 419 420 if (m32c_opcode_pc == 0) 421 { 422 int i; 423 printf("Abort: PC is zero, here from:\n"); 424 for (i=0; i<4; i++) 425 printf(" 0x%06x\n", pcs[(ipcs+15-i)%16]); 426 return M32C_MAKE_HIT_BREAK (); 427 } 428 pcs[ipcs++] = m32c_opcode_pc; 429 ipcs %= 16; 430 431 /** VARY sss 000 001 010 011 100 */ 432 /** VARY ddd 000 001 010 011 100 */ 433 434 /** 0000 1001 indirect dest */ 435 436 decode_indirect (0, 1); 437 goto next_opcode; 438 439 /** 0100 0001 indirect src */ 440 441 decode_indirect (1, 0); 442 goto next_opcode; 443 444 /** 0100 1001 indirect src and dest */ 445 446 decode_indirect (1, 1); 447 goto next_opcode; 448 449 /** 1010 ddd w dd01 1111 ABS.size dest */ 450 451 prefix (0, 1, 0); 452 dc = decode_dest23 (ddd, dd, w+1); 453 v = sign_ext (get_src (dc), w?16:8); 454 a = v<0 ? -v : v; 455 tprintf("abs(%d) = %d\n", v, a); 456 set_osz(a, w+1); 457 put_dest (dc, a); 458 459 /** 0000 0001 1000 ddd w dd10 1110 ADC.size #IMM,dest */ 460 461 prefix (0, 0, 0); 462 dc = decode_dest23 (ddd, dd, w+1); 463 imm = IMM (w+1); 464 MATH_OP (dc, imm, carry, +); 465 466 /** 0000 0001 1sss ddd w dd ss 0100 ADC.size src,dest */ 467 468 prefix (0, 0, 0); 469 sc = decode_src23 (sss, ss, w+1); 470 dc = decode_dest23 (ddd, dd, w+1); 471 b = get_src (sc); 472 MATH_OP (dc, b, carry, +); 473 474 /** 1011 ddd w dd01 1110 ADCF.size dest */ 475 476 prefix (0, 1, 0); 477 dc = decode_dest23 (ddd, dd, w+1); 478 MATH_OP (dc, 0, carry, +); 479 480 /** 1000 ddd w dd10 1110 ADD.size:G #IMM,dest */ 481 482 prefix (0, 1, 0); 483 dc = decode_dest23(ddd, dd, w+1); 484 imm = IMM(w+1); 485 MATH_OP (dc, imm, 0, +); 486 487 /** 1000 ddd0 dd11 0001 ADD.L:G #IMM,dest */ 488 489 prefix (0, 1, 0); 490 dc = decode_dest23(ddd, dd, 4); 491 imm = IMM(4); 492 MATH_OP (dc, imm, 0, +); 493 494 /** 111L ddd w dd11 immm ADD.size:Q #IMM,dest */ 495 496 prefix (0, 1, 0); 497 dc = decode_dest23(ddd, dd, L ? 4 : (w+1)); 498 imm = sign_ext (immm, 4); 499 MATH_OP (dc, imm, 0, +); 500 501 /** 00dd 011w ADD.size:S #IMM,dest */ 502 503 prefix (0, 1, 0); 504 dc = decode_dest2(dd, w+1); 505 imm = IMM (w+1); 506 MATH_OP (dc, imm, 0, +); 507 508 /** 10i0 110d ADD.L:S #IMM,A0/A1 */ 509 510 prefix (0, 0, 0); 511 dc = reg_sd (d ? a1 : a0); 512 imm = i ? 2 : 1; 513 MATH_OP (dc, imm, 0, +); 514 515 /** 1sss ddd w dd ss 1000 ADD.size:G src,dest */ 516 517 prefix (1, 1, 0); 518 sc = decode_src23(sss, ss, w+1); 519 dc = decode_dest23(ddd, dd, w+1); 520 b = get_src (sc); 521 MATH_OP (dc, b, 0, +); 522 523 /** 1sss ddd1 dd ss 0010 ADD.L:G src,dest */ 524 525 prefix (1, 1, 0); 526 sc = decode_src23(sss, ss, 4); 527 dc = decode_dest23(ddd, dd, 4); 528 b = get_src (sc); 529 MATH_OP (dc, b, 0, +); 530 531 /** 1011 0110 0001 0011 ADD.L:G #IMM16,SP */ 532 533 prefix (0, 0, 0); 534 dc = reg_sd (sp); 535 b = sign_ext (IMM(2), 16); 536 MATH_OP (dc, b, 0, +); 537 538 /** 01ii 001i ADD.L:Q #IMM3,SP */ 539 540 prefix (0, 0, 0); 541 dc = reg_sd (sp); 542 b = ii * 2 + i + 1; 543 MATH_OP (dc, b, 0, +); 544 545 /** 1011 0110 0000 0011 ADD.L:S #IMM8,SP */ 546 547 prefix (0, 0, 0); 548 dc = reg_sd (sp); 549 b = sign_ext (IMM(1), 8); 550 MATH_OP (dc, b, 0, +); 551 552 /** 1000 ddd0 dd01 0001 ADDX #IMM,dest */ 553 554 prefix (0, 1, 0); 555 dc = decode_dest23(ddd, dd, 4); 556 imm = sign_ext (IMM(1), 8); 557 MATH_OP (dc, imm, 0, +); 558 559 /** 1sss ddd0 dd ss 0010 ADDX src,dest */ 560 561 prefix (1, 1, 0); 562 sc = decode_src23(sss, ss, 1); 563 dc = decode_dest23(ddd, dd, 4); 564 b = sign_ext (get_src (sc), 8); 565 MATH_OP (dc, b, 0, +); 566 567 /** 1111 ddd w dd01 immm ADJNZ.size #IMM,dest,label */ 568 569 prefix (0, 0, 0); 570 dc = decode_dest23 (ddd, dd, w+1); 571 v = get_src (dc); 572 imm = sign_ext(immm, 4); 573 tprintf("%d + %d = %d\n", v, imm, v+imm); 574 v += imm; 575 put_dest (dc, v); 576 a = sign_ext (IMM(1), 8); 577 if ((v & (w ? 0xffff : 0xff)) != 0) 578 { 579 tprintf("jmp: %x + 2 + %d = ", get_reg (pc), a); 580 put_reg (pc, m32c_opcode_pc + 2 + a); 581 tprintf("%x\n", get_reg (pc)); 582 } 583 584 /** 1000 ddd w dd11 1111 AND.size:G #IMM,dest */ 585 586 prefix (0, 1, 0); 587 dc = decode_dest23(ddd, dd, w+1); 588 imm = IMM(w+1); 589 LOGIC_OP (dc, imm, &); 590 591 /** 01dd 110w AND.size:S #IMM,dest */ 592 593 prefix (0, 1, 0); 594 dc = decode_dest2(dd, w+1); 595 imm = IMM (w+1); 596 LOGIC_OP (dc, imm, &); 597 598 /** 1sss ddd w dd ss 1101 AND.size:G src,dest */ 599 600 prefix (1, 1, 0); 601 sc = decode_src23(sss, ss, w+1); 602 dc = decode_dest23(ddd, dd, w+1); 603 b = get_src (sc); 604 LOGIC_OP (dc, b, &); 605 606 /** 0000 0001 1101 sss0 ss00 1bit BAND src */ 607 608 sc = decode_src23 (sss, ss, 1); 609 BIT_OPC (sc, bit, b & carry); 610 611 /** 1101 ddd0 dd11 0bit BCLR dest */ 612 613 dc = decode_dest23 (ddd, dd, 1); 614 BIT_OP (dc, bit, 0); 615 616 /** 1100 ddd w dd10 1110 BITINDEX.size src */ 617 618 prefix (0, 0, 0); 619 dc = decode_dest23 (ddd, dd, w+1); 620 bitindex = get_src (dc); 621 tprintf ("bitindex set to %d\n", bitindex); 622 goto next_opcode; 623 624 /** 1101 ddd0 dd01 0bit BMcnd dest */ 625 626 prefix (0, 0, 0); 627 dc = decode_dest23 (ddd, dd, 1); 628 if (condition_true (IMM (1))) 629 put_bit2 (dc, bit, 1); 630 else 631 put_bit2 (dc, bit, 0); 632 633 /** 1101 1001 0c10 1cnd BMcnd C */ 634 635 prefix (0, 0, 0); 636 if (condition_true (c * 8 + cnd)) 637 set_c (1); 638 else 639 set_c (0); 640 641 /** 0000 0001 1101 sss0 ss01 1bit BNAND src */ 642 643 prefix (0, 0, 0); 644 sc = decode_src23 (sss, ss, 1); 645 BIT_OPC (sc, bit, (!b) & carry); 646 647 /** 0000 0001 1101 sss0 ss11 0bit BNOR src */ 648 649 prefix (0, 0, 0); 650 sc = decode_src23 (sss, ss, 1); 651 BIT_OPC (sc, bit, (!b) | carry); 652 653 /** 1101 ddd0 dd01 1bit BNOT dest */ 654 655 prefix (0, 0, 0); 656 dc = decode_dest23 (ddd, dd, 1); 657 BIT_OP (dc, bit, !b); 658 659 /** 0000 0001 1101 sss0 ss00 0bit BNTST src */ 660 661 prefix (0, 0, 0); 662 sc = decode_dest23 (sss, ss, 1); 663 b = get_bit2 (sc, bit); 664 set_zc (!b, !b); 665 666 /** 0000 0001 1101 sss0 ss11 1bit BNXOR src */ 667 668 prefix (0, 0, 0); 669 sc = decode_src23 (sss, ss, 1); 670 BIT_OPC (sc, bit, !b ^ carry); 671 672 /** 0000 0001 1101 sss0 ss10 0bit BOR src */ 673 674 prefix (0, 0, 0); 675 sc = decode_src23 (sss, ss, 1); 676 BIT_OPC (sc, bit, b | carry); 677 678 /** 0000 0000 BRK */ 679 680 /* We report the break to our caller with the PC still pointing at the 681 breakpoint instruction. */ 682 put_reg (pc, m32c_opcode_pc); 683 if (verbose) 684 printf("[break]\n"); 685 if (in_gdb || (regs.r_intbl == 0 && regs.r_intbh == 0)) 686 return M32C_MAKE_HIT_BREAK (); 687 if (mem_get_qi (0xFFFFE7) == 0xff) 688 trigger_based_interrupt (0); 689 else 690 trigger_fixed_interrupt (0xFFFFE4); 691 692 /** 1111 1110 GBRK */ 693 694 /* This alternate break, which is not part of the chip's opcode set, 695 is here in case you need to debug a program that itself uses the 696 chip's BRK opcode. You'll need to modify your copy of GDB to use 697 this opcode instead of the real BRK. */ 698 699 /* GDB Break. */ 700 /* We report the break to our caller with the PC still pointing at the 701 breakpoint instruction. */ 702 put_reg (pc, m32c_opcode_pc); 703 if (verbose) 704 printf("[gdb break]\n"); 705 return M32C_MAKE_HIT_BREAK (); 706 707 /** 0000 1000 BRK2 */ 708 709 if (verbose) 710 printf("[break2]\n"); 711 if (in_gdb) 712 return M32C_MAKE_HIT_BREAK (); 713 if (mem_get_qi (0xFFFFE7) == 0xff) 714 trigger_based_interrupt (0); 715 else 716 trigger_fixed_interrupt (0xFFFFE4); 717 718 /** 1101 ddd0 dd11 1bit BSET dest */ 719 720 dc = decode_dest23 (ddd, dd, 1); 721 BIT_OP (dc, bit, 1); 722 723 /** 1101 sss0 ss00 0bit BTST:G src */ 724 725 prefix (0, 0, 0); 726 sc = decode_src23 (sss, ss, 1); 727 b = get_bit2 (sc, bit); 728 set_zc (!b, b); 729 730 /** 00bb 101b BTST:S src */ 731 732 sc = decode_src23 (3, 3, 1); /* bit,base:19 */ 733 b = get_bit2 (sc, bb*2 + b); 734 set_zc (!b, b); 735 736 /** 1101 ddd0 dd10 0bit BTSTC dest */ 737 738 prefix (0, 0, 0); 739 sc = decode_dest23 (ddd, dd, 1); 740 b = get_bit2 (sc, bit); 741 set_zc (!b, b); 742 put_bit2 (sc, bit, 0); 743 744 /** 1101 ddd0 dd10 1bit BTSTS dest */ 745 746 prefix (0, 0, 0); 747 sc = decode_dest23 (ddd, dd, 1); 748 b = get_bit2 (sc, bit); 749 set_zc (!b, b); 750 put_bit2 (sc, bit, 1); 751 752 /** 0000 0001 1101 sss0 ss10 1bit BXOR src */ 753 754 prefix (0, 0, 0); 755 sc = decode_src23 (sss, ss, 1); 756 BIT_OPC (sc, bit, b ^ carry); 757 758 /** 0000 0001 1000 ddd w dd11 1110 CLIP.size #IMM1,#IMM2,dest */ 759 760 prefix (0, 0, 0); 761 dc = decode_dest23 (ddd, dd, w+1); 762 a = sign_ext (IMM(w+1), w*8+8); 763 b = sign_ext (IMM(w+1), w*8+8); 764 v = sign_ext (get_src (dc), w*8+8); 765 tprintf("clip %d <= %d <= %d : ", a, v, b); 766 if (a > v) 767 v = a; 768 if (v > b) 769 v = b; 770 tprintf("%d\n", v); 771 put_dest (dc, v); 772 773 /** 1001 ddd w dd10 1110 CMP.size:G #IMM,dest */ 774 775 prefix (0, 1, 0); 776 dc = decode_dest23 (ddd, dd, w+1); 777 v = get_src (dc); 778 imm = IMM(w+1); 779 cmp (v, imm, w+1); 780 781 /** 1010 ddd0 dd11 0001 CMP.L:G #IMM32,dest */ 782 783 prefix (0, 1, 0); 784 dc = decode_dest23 (ddd, dd, 4); 785 v = get_src (dc); 786 imm = IMM(4); 787 cmp (v, imm, 4); 788 789 /** 1110 ddd w dd01 immm CMP.size:Q #IMM,dest */ 790 791 prefix (0, 1, 0); 792 dc = decode_dest23 (ddd, dd, w+1); 793 v = get_src (dc); 794 immm = sign_ext (immm, 4); 795 cmp (v, immm, w+1); 796 797 /** 01dd 011w CMP.size:S #IMM,dest */ 798 799 prefix (0, 1, 0); 800 dc = decode_dest2 (dd, w+1); 801 v = get_src (dc); 802 imm = sign_ext (IMM(w+1),w*8+8); 803 cmp (v, imm, w+1); 804 805 /** 1sss ddd w dd ss 0110 CMP.size:G src,dest */ 806 807 prefix (1, 1, 0); 808 sc = decode_src23 (sss, ss, w+1); 809 dc = decode_dest23 (ddd, dd, w+1); 810 a = get_src (dc); 811 b = get_src (sc); 812 cmp (a, b, w+1); 813 814 /** 1sss ddd1 dd ss 0001 CMP.L:G src,dest */ 815 816 prefix (1, 1, 0); 817 sc = decode_src23 (sss, ss, 4); 818 dc = decode_dest23 (ddd, dd, 4); 819 a = get_src (dc); 820 b = get_src (sc); 821 cmp (a, b, 4); 822 823 /** 01dd 000w CMP.size:S src,R0/R0L */ 824 825 prefix (0, 1, 0); 826 dc = decode_dest2 (dd, w+1); 827 a = get_reg (w ? r0 : r0l); 828 b = get_src (dc); 829 cmp (a, b, w+1); 830 831 /** 1010 ddd0 dd01 0001 CMPX #IMM,dest */ 832 833 prefix (0, 1, 0); 834 dc = decode_dest23 (ddd, dd, 4); 835 v = get_src (dc); 836 imm = sign_ext (IMM(1), 8); 837 cmp (v, imm, 4); 838 839 /** 0000 0001 1000 ddd w dd00 1110 DADC.size #IMM,dest */ 840 841 DADDI(1,1); 842 843 /** 0000 0001 1sss ddd w dd ss 1000 DADC.size src,dest */ 844 845 DADDV(1,1); 846 847 /** 0000 0001 1000 ddd w dd01 1110 DADD.size #IMM,dest */ 848 849 DADDI(1,0); 850 851 /** 0000 0001 1sss ddd w dd ss 0000 DADD.size src,dest */ 852 853 DADDV(1,0); 854 855 /** 1011 ddd w dd00 1110 DEC.size dest */ 856 857 prefix (0, 1, 0); 858 dc = decode_dest23 (ddd, dd, w+1); 859 a = get_src (dc); 860 v = a-1; 861 tprintf ("%x -- = %x\n", a, v); 862 set_sz (v, w+1); 863 put_dest (dc, v); 864 865 /** 1011 0000 010w 0011 DIV.size #IMM */ 866 867 prefix (0, 0, 0); 868 div_op (-1, 0, 0, 0, w+1); 869 870 /** 1000 sss w ss01 1110 DIV.size src */ 871 872 prefix (0, 1, 0); 873 div_op (sss, ss, 0, 0, w+1); 874 875 /** 0000 0001 1010 sss1 ss01 1111 DIV.L src */ 876 877 M32C_ONLY(); 878 prefix (0, 0, 0); 879 div_op (sss, ss, 0, 0, 4); 880 881 /** 1011 0000 000w 0011 DIVU.size #IMM */ 882 883 prefix (0, 0, 0); 884 div_op (-1, 0, 1, 0, w+1); 885 886 /** 1000 sss w ss00 1110 DIVU.size src */ 887 888 prefix (0, 1, 0); 889 div_op (sss, ss, 1, 0, w+1); 890 891 /** 0000 0001 1010 sss1 ss00 1111 DIVU.L src */ 892 893 M32C_ONLY(); 894 prefix (0, 0, 0); 895 div_op (sss, ss, 1, 0, 4); 896 897 /** 1011 0010 010w 0011 DIVX.size #IMM */ 898 899 prefix (0, 0, 0); 900 div_op (-1, 0, 0, 1, w+1); 901 902 /** 1001 sss w ss01 1110 DIVX.size src */ 903 904 prefix (0, 1, 0); 905 div_op (sss, ss, 0, 1, w+1); 906 907 /** 0000 0001 1010 sss1 ss10 1111 DIVX.L src */ 908 909 M32C_ONLY(); 910 prefix (0, 0, 0); 911 div_op (sss, ss, 0, 1, 4); 912 913 /** 0000 0001 1001 ddd w dd00 1110 DSBB.size #IMM,dest */ 914 915 DADDI(0,1); 916 917 /** 0000 0001 1sss ddd w dd ss 1010 DSBB.size src,dest */ 918 919 DADDV(0,1); 920 921 /** 0000 0001 1001 ddd w dd01 1110 DSUB.size #IMM,dest */ 922 923 DADDI(0,0); 924 925 /** 0000 0001 1sss ddd w dd ss 0010 DSUB.size src,dest */ 926 927 DADDV(0,0); 928 929 /** 1110 1100 ENTER #IMM */ 930 931 imm = IMM(1); 932 put_reg (sp, get_reg (sp) - 4); 933 mem_put_si (get_reg (sp), get_reg (fb)); 934 put_reg (fb, get_reg (sp)); 935 put_reg (sp, get_reg (sp) - imm); 936 937 /** 1111 1100 EXITD */ 938 939 put_reg (sp, get_reg (fb)); 940 put_reg (fb, mem_get_si (get_reg (sp))); 941 put_reg (sp, get_reg (sp) + 4); 942 put_reg (pc, mem_get_si (get_reg (sp))); 943 put_reg (sp, get_reg (sp) + 4); 944 945 /** 1100 ddd w dd01 1110 EXTS.size dest */ 946 947 prefix (0, 0, 0); 948 dc = decode_dest23 (ddd, dd, w+1); 949 v = sign_ext (get_src (dc), (w+1)*8); 950 dc = widen_sd (dc); 951 put_dest (dc, v); 952 set_sz (v, (w+1)*2); 953 954 /** 0000 0001 1sss ddd0 dd ss 0111 EXTS.B src,dest */ 955 956 prefix (0, 0, 0); 957 sc = decode_src23 (sss, ss, 1); 958 dc = decode_dest23 (ddd, dd, 2); 959 v = sign_ext (get_src (sc), 8); 960 put_dest (dc, v); 961 set_sz (v, 16); 962 963 /** 0000 0001 1sss ddd0 dd ss 1011 EXTZ src,dest */ 964 965 prefix (0, 0, 0); 966 sc = decode_src23 (sss, ss, 1); 967 dc = decode_dest23 (ddd, dd, 2); 968 v = get_src (sc); 969 put_dest (dc, v); 970 set_sz (v, 16); 971 972 /** 1101 0011 1110 1dst FCLR dest */ 973 974 set_flags (1 << dst, 0); 975 976 /** 1001 1111 FREIT */ 977 978 NOTYET(); 979 980 /** 1101 0001 1110 1dst FSET dest */ 981 982 set_flags (1 << dst, 1 << dst); 983 984 /** 1010 ddd w dd00 1110 INC.size dest */ 985 986 prefix (0, 1, 0); 987 dc = decode_dest23 (ddd, dd, w+1); 988 a = get_src (dc); 989 v = a+1; 990 tprintf ("%x ++ = %x\n", a, v); 991 set_sz (v, w+1); 992 put_dest (dc, v); 993 994 /** 1000 sss0 ss0w 0011 INDEXB.size src */ 995 INDEXOP(1, 1, 1); 996 /** 1010 sss0 ss0w 0011 INDEXBD.size src */ 997 INDEXOP(1, 0, 1); 998 /** 1100 sss0 ss0w 0011 INDEXBS.size src */ 999 INDEXOP(1, 1, 0); 1000 /** 1001 sss0 ss1w 0011 INDEXL.size src */ 1001 INDEXOP(4, 1, 1); 1002 /** 1011 sss0 ss1w 0011 INDEXLD.size src */ 1003 INDEXOP(4, 0, 1); 1004 /** 1001 sss0 ss0w 0011 INDEXLS.size src */ 1005 INDEXOP(4, 1, 0); 1006 /** 1000 sss0 ss1w 0011 INDEXW.size src */ 1007 INDEXOP(2, 1, 1); 1008 /** 1010 sss0 ss1w 0011 INDEXWD.size src */ 1009 INDEXOP(2, 0, 1); 1010 /** 1100 sss0 ss1w 0011 INDEXWS.size src */ 1011 INDEXOP(2, 1, 0); 1012 1013 /** 1011 1110 vector00 INT #IMM */ 1014 1015 prefix (0, 0, 0); 1016 trigger_based_interrupt (vector); 1017 1018 /** 1011 1111 INTO */ 1019 1020 prefix (0, 0, 0); 1021 if (FLAG_O) 1022 trigger_fixed_interrupt (0xffffe0); 1023 1024 /** 1ccc 101c Jcnd label */ 1025 1026 prefix (0, 0, 0); 1027 v = sign_ext (IMM(1), 8); 1028 if (condition_true (ccc*2+c)) 1029 put_reg (pc, m32c_opcode_pc + 1 + v); 1030 1031 /** 01dd 101d JMP.S label */ 1032 1033 prefix (0, 0, 0); 1034 put_reg (pc, m32c_opcode_pc + (dd*2+d) + 2); 1035 1036 /** 1011 1011 JMP.B label */ 1037 1038 prefix (0, 0, 0); 1039 imm = sign_ext (IMM(1), 8); 1040 if (imm == -1) 1041 { 1042 if (verbose) 1043 printf("[jmp-to-self detected as exit]\n"); 1044 return M32C_MAKE_HIT_BREAK (); 1045 } 1046 put_reg (pc, m32c_opcode_pc + 1 + imm); 1047 1048 /** 1100 1110 JMP.W label */ 1049 1050 prefix (0, 0, 0); 1051 imm = sign_ext (IMM(2), 16); 1052 put_reg (pc, m32c_opcode_pc + 1 + imm); 1053 1054 /** 1100 1100 JMP.A label */ 1055 1056 prefix (0, 0, 0); 1057 imm = IMM(3); 1058 put_reg (pc, imm); 1059 1060 /** 1100 sss1 ss00 1111 JMPI.W src */ 1061 1062 prefix (0, 0, 0); 1063 sc = decode_src23 (sss, ss, 2); 1064 a = get_src (sc); 1065 a = sign_ext (a, 16); 1066 put_reg (pc, m32c_opcode_pc + a); 1067 1068 /** 1000 sss0 ss00 0001 JMPI.A src */ 1069 1070 prefix (0, 0, 0); 1071 sc = decode_src23 (sss, ss, 3); 1072 a = get_src (sc); 1073 put_reg (pc, a); 1074 1075 /** 1101 1100 JMPS #IMM8 */ 1076 1077 prefix (0, 0, 0); 1078 imm = IMM(1); 1079 a = 0xff0000 + mem_get_hi (0xfffe00 - imm * 2); 1080 put_reg (pc, a); 1081 1082 /** 1100 1111 JSR.W label */ 1083 1084 prefix (0, 0, 0); 1085 imm = sign_ext (IMM(2), 16); 1086 put_reg (sp, get_reg (sp) - 4); 1087 mem_put_si (get_reg (sp), get_reg (pc)); 1088 put_reg (pc, m32c_opcode_pc + imm + 1); 1089 1090 /** 1100 1101 JSR.A label */ 1091 1092 prefix (0, 0, 0); 1093 imm = IMM(3); 1094 put_reg (sp, get_reg (sp) - 4); 1095 mem_put_si (get_reg (sp), get_reg (pc)); 1096 put_reg (pc, imm); 1097 1098 /** 1100 sss1 ss01 1111 JSRI.W src */ 1099 1100 prefix (0, 0, 0); 1101 sc = decode_src23 (sss, ss, 2); 1102 a = get_src (sc); 1103 a = sign_ext (a, 16); 1104 put_reg (sp, get_reg (sp) - 4); 1105 mem_put_si (get_reg (sp), get_reg (pc)); 1106 put_reg (pc, m32c_opcode_pc + a); 1107 1108 /** 1001 sss0 ss00 0001 JSRI.A src */ 1109 1110 prefix (0, 0, 0); 1111 sc = decode_src23 (sss, ss, 3); 1112 a = get_src (sc); 1113 put_reg (sp, get_reg (sp) - 4); 1114 mem_put_si (get_reg (sp), get_reg (pc)); 1115 put_reg (pc, a); 1116 1117 /** 1101 1101 JSRS #IMM8 */ 1118 1119 prefix (0, 0, 0); 1120 imm = IMM(1); 1121 a = 0xff0000 + mem_get_hi (0xfffe00 - imm * 2); 1122 put_reg (sp, get_reg (sp) - 4); 1123 mem_put_si (get_reg (sp), get_reg (pc)); 1124 put_reg (pc, a); 1125 1126 /** 1101 0101 1010 1dst LDC #IMM16,dest */ 1127 1128 imm = IMM(2); 1129 dc = decode_cr_b (dst, CR_B_DCT0); 1130 put_dest (dc, imm); 1131 1132 /** 1101 0101 0010 1dst LDC #IMM24,dest */ 1133 1134 imm = IMM(3); 1135 dc = decode_cr_b (dst, CR_B_INTB); 1136 put_dest (dc, imm); 1137 1138 /** 1101 0101 0110 1dst LDC #IMM24,dest */ 1139 1140 imm = IMM(3); 1141 dc = decode_cr_b (dst, CR_B_DMA0); 1142 put_dest (dc, imm); 1143 1144 /** 0000 0001 1101 sss1 ss00 1dst LDC src,dest */ 1145 1146 prefix (0, 0, 0); 1147 sc = decode_src23 (sss, ss, 2); 1148 dc = decode_cr_b (dst, CR_B_DCT0); 1149 a = get_src (sc); 1150 put_dest (dc, a); 1151 1152 /** 1101 sss1 ss00 0dst LDC src,dest */ 1153 1154 prefix (0, 0, 0); 1155 sc = decode_src23 (sss, ss, 3); 1156 dc = decode_cr_b (dst, CR_B_INTB); 1157 a = get_src (sc); 1158 put_dest (dc, a); 1159 1160 /** 0000 0001 1101 sss1 ss00 0dst LDC src,dest */ 1161 1162 prefix (0, 0, 0); 1163 sc = decode_src23 (sss, ss, 3); 1164 dc = decode_cr_b (dst, CR_B_DMA0); 1165 a = get_src (sc); 1166 put_dest (dc, a); 1167 1168 /** 1011 0110 1100 0011 LDCTX */ 1169 1170 NOTYET(); 1171 1172 /** 1101 0101 1110 1imm LDIPL #IMM */ 1173 1174 set_flags (0x7000, imm*0x1000); 1175 1176 /** 0000 0001 1000 ddd w dd11 1111 MAX.size #IMM,dest */ 1177 1178 prefix (0, 0, 0); 1179 w++; 1180 dc = decode_dest23 (ddd, dd, w); 1181 imm = sign_ext (IMM(w), w*8); 1182 a = sign_ext (get_src (dc), w*8); 1183 tprintf ("max %d %d\n", imm, a); 1184 if (imm > a) 1185 put_dest (dc, imm); 1186 1187 /** 0000 0001 1sss ddd w dd ss 1101 MAX.size src,dest */ 1188 1189 prefix (0, 0, 0); 1190 w++; 1191 sc = decode_src23 (sss, ss, w); 1192 dc = decode_dest23 (ddd, dd, w); 1193 b = sign_ext (get_src (sc), w*8); 1194 a = sign_ext (get_src (dc), w*8); 1195 tprintf ("max %d %d\n", b, a); 1196 if (b > a) 1197 put_dest (dc, b); 1198 1199 /** 0000 0001 1000 ddd w dd10 1111 MIN.size #IMM,dest */ 1200 1201 prefix (0, 0, 0); 1202 w++; 1203 dc = decode_dest23 (ddd, dd, w); 1204 imm = sign_ext (IMM(w), w*8); 1205 a = sign_ext (get_src (dc), w*8); 1206 tprintf ("min %d %d\n", imm, a); 1207 if (imm < a) 1208 put_dest (dc, imm); 1209 1210 /** 0000 0001 1sss ddd w dd ss 1100 MIN.size src,dest */ 1211 1212 prefix (0, 0, 0); 1213 w++; 1214 sc = decode_src23 (sss, ss, w); 1215 dc = decode_dest23 (ddd, dd, w); 1216 b = sign_ext (get_src (sc), w*8); 1217 a = sign_ext (get_src (dc), w*8); 1218 tprintf ("min %d %d\n", b, a); 1219 if (b < a) 1220 put_dest (dc, b); 1221 1222 /** 1001 ddd w dd10 1111 MOV.size:G #IMM,dest */ 1223 1224 dc = decode_dest23 (ddd, dd, w+1); 1225 imm = IMM(w+1); 1226 v = imm; 1227 tprintf("%x = %x\n", v, v); 1228 set_sz(v, w+1); 1229 put_dest (dc, v); 1230 1231 /** 1011 ddd0 dd11 0001 MOV.L:G #IMM,dest */ 1232 1233 dc = decode_dest23 (ddd, dd, 4); 1234 imm = IMM(4); 1235 v = imm; 1236 tprintf("%x = %x\n", v, v); 1237 set_sz(v, 4); 1238 put_dest (dc, v); 1239 1240 /** 1111 ddd w dd10 immm MOV.size:Q #IMM4,dest */ 1241 1242 dc = decode_dest23 (ddd, dd, w+1); 1243 imm = sign_ext (immm, 4); 1244 v = imm; 1245 tprintf("%x = %d\n", v, v); 1246 set_sz(v, w+1); 1247 put_dest (dc, v); 1248 1249 /** 00dd 010w MOV.size:S #IMM,dest */ 1250 1251 prefix (0, 1, 0); 1252 dc = decode_dest2 (dd, w+1); 1253 imm = IMM(w+1); 1254 put_dest (dc, imm); 1255 set_sz (imm, w+1); 1256 1257 /** 10w1 110d MOV.size:S #IMM,a0/a1 */ 1258 1259 imm = IMM(w ? 3 : 2); 1260 put_reg (d ? a1 : a0, imm); 1261 set_sz (imm & addr_mask, w+1); 1262 1263 /** 00dd 001w MOV.size:Z #0,dest */ 1264 1265 prefix (0, 1, 0); 1266 dc = decode_dest2 (dd, w+1); 1267 put_dest (dc, 0); 1268 set_sz (0, w+1); 1269 1270 /** 1sss ddd w dd ss 1011 MOV.size:G src,dest */ 1271 1272 prefix (1, 1, 0); 1273 sc = decode_src23 (sss, ss, w+1); 1274 dc = decode_dest23 (ddd, dd, w+1); 1275 v = get_src (sc); 1276 put_dest (dc, v); 1277 set_sz (v, w+1); 1278 1279 /** 1sss ddd1 dd ss 0011 MOV.L:G src,dest */ 1280 1281 prefix (1, 1, 0); 1282 sc = decode_src23 (sss, ss, 4); 1283 dc = decode_dest23 (ddd, dd, 4); 1284 v = get_src (sc); 1285 put_dest (dc, v); 1286 set_sz (v, 4); 1287 1288 /** VARY SS 01 10 11 */ 1289 /** 00SS 100w MOV.size:S src,R0L/R0 */ 1290 1291 prefix (0, 1, 0); 1292 sc = decode_dest2 (SS, w+1); 1293 v = get_src (sc); 1294 put_reg (w ? r0 : r0l, v); 1295 set_sz (v, w+1); 1296 1297 /** 01ss 111w MOV.size:S src,R1L/R1 */ 1298 1299 prefix (0, 1, 0); 1300 sc = decode_dest2 (ss, w+1); 1301 v = get_src (sc); 1302 put_reg (w ? r1 : r1l, v); 1303 set_sz (v, w+1); 1304 1305 /** VARY DD 01 10 11 */ 1306 /** 00DD 000w MOV.size:S R0L/R0,dest */ 1307 1308 prefix (0, 1, 0); 1309 dc = decode_dest2 (DD, w+1); 1310 v = get_reg (w ? r0 : r0l); 1311 put_dest (dc, v); 1312 set_sz (v, w+1); 1313 1314 /** 01ss 100d MOV.L:S src,A0/A1 */ 1315 1316 prefix (0, 1, 0); 1317 sc = decode_dest2 (ss, 4); 1318 v = get_src (sc); 1319 put_reg (d ? a1 : a0, v); 1320 set_sz (v, 4); 1321 1322 /** 1011 ddd w dd00 1111 MOV.size:G dsp:8[SP], dest */ 1323 1324 prefix (0, 0, 0); 1325 imm = IMM(1); 1326 dc = decode_dest23 (ddd, dd, w+1); 1327 a = get_reg (sp) + sign_ext (imm, 8); 1328 a &= addr_mask; 1329 if (w) 1330 v = mem_get_hi (a); 1331 else 1332 v = mem_get_qi (a); 1333 put_dest (dc, v); 1334 set_sz (v, w+1); 1335 1336 /** 1010 sss w ss00 1111 MOV.size:G src,dsp:8[SP] */ 1337 1338 prefix (0, 0, 0); 1339 sc = decode_dest23 (sss, ss, w+1); 1340 imm = IMM(1); 1341 a = get_reg (sp) + sign_ext (imm, 8); 1342 a &= addr_mask; 1343 v = get_src (sc); 1344 if (w) 1345 mem_put_hi (a, v); 1346 else 1347 mem_put_qi (a, v); 1348 set_sz (v, w+1); 1349 1350 /** 1101 sss1 ss01 1dst MOVA src,dest */ 1351 1352 static reg_id map[8] = { r2r0, r3r1, a0, a1 }; 1353 prefix (0, 0, 0); 1354 sc = decode_src23 (sss, ss, 1); 1355 if (!sc.mem || !map[dst]) 1356 UNSUPPORTED(); 1357 put_reg (map[dst], sc.u.addr); 1358 1359 /** 0000 0001 1011 ddd0 dd hl 1110 MOVdir R0L,dest */ 1360 1361 prefix (0, 0, 0); 1362 dc = decode_dest23 (ddd, dd, 1); 1363 a = get_src (dc); 1364 b = get_reg (r0l); 1365 switch (hl) 1366 { 1367 case 0: a = (a & 0xf0) | (b & 0x0f); break; 1368 case 1: a = (a & 0xf0) | ((b>>4) & 0x0f); break; 1369 case 2: a = (a & 0x0f) | ((b & 0x0f)<<4); break; 1370 case 3: a = (a & 0x0f) | (b & 0xf0); break; 1371 } 1372 put_dest (dc, a); 1373 1374 /** 0000 0001 1010 sss0 ss hl 1110 MOVdir src,R0L */ 1375 1376 prefix (0, 0, 0); 1377 sc = decode_dest23 (sss, ss, 1); 1378 a = get_reg (r0l); 1379 b = get_src (dc); 1380 switch (hl) 1381 { 1382 case 0: a = (a & 0xf0) | (b & 0x0f); break; 1383 case 1: a = (a & 0xf0) | ((b>>4) & 0x0f); break; 1384 case 2: a = (a & 0x0f) | ((b & 0x0f)<<4); break; 1385 case 3: a = (a & 0x0f) | (b & 0xf0); break; 1386 } 1387 put_reg (r0l, a); 1388 1389 /** 1011 ddd0 dd01 0001 MOVX #IMM,dest */ 1390 1391 prefix (0, 1, 0); 1392 dc = decode_dest23 (ddd, dd, 4); 1393 imm = sign_ext (IMM(1), 8); 1394 put_dest (dc, imm); 1395 set_sz (imm, 1); 1396 1397 /** 1000 ddd w dd01 1111 MUL.size #IMM,dest */ 1398 1399 prefix (0, 1, 0); 1400 w ++; 1401 dc = decode_dest23 (ddd, dd, w); 1402 v = sign_ext (get_src (dc), w*8); 1403 imm = sign_ext (IMM(w), w*8); 1404 tprintf("%d * %d = %d\n", v, imm, v*imm); 1405 v *= imm; 1406 dc = widen_sd (dc); 1407 put_dest (dc, v); 1408 1409 /** 1sss ddd w dd ss 1100 MUL.size src,dest */ 1410 1411 prefix (1, 1, 0); 1412 w ++; 1413 sc = decode_src23 (sss, ss, w); 1414 dc = decode_dest23 (ddd, dd, w); 1415 a = sign_ext (get_src (sc), w*8); 1416 b = sign_ext (get_src (dc), w*8); 1417 tprintf("%d * %d = %d\n", a, b, a*b); 1418 v = a * b; 1419 dc = widen_sd (dc); 1420 put_dest (dc, v); 1421 1422 /** 0000 0001 1000 sss1 ss01 1111 MUL.L src,R2R0 */ 1423 1424 M32C_ONLY(); 1425 prefix (0, 0, 0); 1426 sc = decode_src23 (sss, ss, 4); 1427 a = sign_ext (get_src (sc), 32); 1428 b = sign_ext (get_reg (r2r0), 32); 1429 ll = (long long)a * (long long)b; 1430 tprintf("%d * %d = %lld (%llx)\n", a, b, ll, ll); 1431 if (ll < b2minsigned[4] || ll > b2maxsigned[4]) 1432 set_flags (FLAGBIT_O, FLAGBIT_O); 1433 else 1434 set_flags (FLAGBIT_O, 0); 1435 put_reg (r2r0, (int)ll); 1436 1437 /** 1100 sss1 ss11 1110 MULEX src */ 1438 1439 prefix (0, 1, 0); 1440 sc = decode_dest23 (sss, ss, 2); 1441 a = sign_ext (get_src (sc), 16); 1442 b = sign_ext (get_reg (r2r0), 32); 1443 ll = (long long)a * (long long)b; 1444 tprintf("%d * %d = %lld (%llx)\n", a, b, ll, ll); 1445 put_reg (r2r0, (int)ll); 1446 put_reg (r1, (int)(ll >> 32)); 1447 1448 /** 1000 ddd w dd00 1111 MULU.size #IMM,dest */ 1449 1450 prefix (0, 1, 0); 1451 w ++; 1452 dc = decode_dest23 (ddd, dd, w); 1453 v = get_src (dc); 1454 imm = IMM(w); 1455 tprintf("%d * %d = %d\n", v, imm, v*imm); 1456 v *= imm; 1457 dc = widen_sd (dc); 1458 put_dest (dc, v); 1459 1460 /** 1sss ddd w dd ss 0100 MULU.size src,dest */ 1461 1462 prefix (1, 1, 0); 1463 w ++; 1464 sc = decode_src23 (sss, ss, w); 1465 dc = decode_dest23 (ddd, dd, w); 1466 a = get_src (sc); 1467 b = get_src (dc); 1468 tprintf("%d * %d = %d\n", a, b, a*b); 1469 v = a * b; 1470 dc = widen_sd (dc); 1471 put_dest (dc, v); 1472 1473 /** 0000 0001 1000 sss1 ss00 1111 MULU.L src,R2R0 */ 1474 1475 M32C_ONLY(); 1476 prefix (0, 0, 0); 1477 sc = decode_src23 (sss, ss, 4); 1478 a = get_src (sc); 1479 b = get_reg (r2r0); 1480 ll = (long long)a * (long long)b; 1481 tprintf("%d * %d = %lld (%llx)\n", a, b, ll, ll); 1482 if (ll < b2minsigned[4] || ll > b2maxsigned[4]) 1483 set_flags (FLAGBIT_O, FLAGBIT_O); 1484 else 1485 set_flags (FLAGBIT_O, 0); 1486 put_reg (r2r0, (int)ll); 1487 1488 /** 1010 ddd w dd10 1111 NEG.size dest */ 1489 1490 prefix (0, 1, 0); 1491 dc = decode_dest23 (ddd, dd, w+1); 1492 a = sign_ext (get_src (dc), (w+1)*8); 1493 v = -a; 1494 tprintf("%d * -1 = %d\n", a, v); 1495 set_oszc(v, w+1, v==0); 1496 put_dest (dc, v); 1497 1498 /** 1101 1110 NOP */ 1499 1500 tprintf("nop\n"); 1501 1502 /** 1010 ddd w dd01 1110 NOT.size dest */ 1503 1504 prefix (0, 1, 0); 1505 dc = decode_dest23 (ddd, dd, w+1); 1506 a = get_src (dc); 1507 v = ~a; 1508 tprintf("~ %x = %x\n", a, v); 1509 set_sz(v, w+1); 1510 put_dest (dc, v); 1511 1512 /** 1000 ddd w dd10 1111 OR.size:G #IMM,dest */ 1513 1514 prefix (0, 1, 0); 1515 dc = decode_dest23(ddd, dd, w+1); 1516 imm = IMM(w+1); 1517 LOGIC_OP (dc, imm, |); 1518 1519 /** 01dd 010w OR.size:S #IMM,dest */ 1520 1521 prefix (0, 1, 0); 1522 dc = decode_dest2(dd, w+1); 1523 imm = IMM (w+1); 1524 LOGIC_OP (dc, imm, |); 1525 1526 /** 1sss ddd w dd ss 0101 OR.size:G src,dest */ 1527 1528 prefix (1, 1, 0); 1529 sc = decode_src23(sss, ss, w+1); 1530 dc = decode_dest23(ddd, dd, w+1); 1531 b = get_src (sc); 1532 LOGIC_OP (dc, b, |); 1533 1534 /** 1011 ddd w dd10 1111 POP.size dest */ 1535 1536 prefix (0, 1, 0); 1537 dc = decode_dest23 (ddd, dd, w+1); 1538 if (w) 1539 a = mem_get_hi (get_reg (sp)); 1540 else 1541 a = mem_get_qi (get_reg (sp)); 1542 put_reg (sp, get_reg (sp) + 2); 1543 tprintf("pop%s: %x\n", w ? "hi" : "qi", a); 1544 put_dest (dc, a); 1545 1546 /** 1101 0011 1010 1dst POPC dest */ 1547 1548 prefix (0, 0, 0); 1549 dc = decode_cr_b (dst, CR_B_DCT0); 1550 a = mem_get_hi (get_reg (sp)); 1551 put_reg (sp, get_reg (sp) + 2); 1552 tprintf("pophi: %x\n", a); 1553 put_dest (dc, a); 1554 1555 /** 1101 0011 0010 1dst POPC dest */ 1556 1557 prefix (0, 0, 0); 1558 dc = decode_cr_b (dst, CR_B_INTB); 1559 a = mem_get_si (get_reg (sp)); 1560 put_reg (sp, get_reg (sp) + 4); 1561 tprintf("popsi: %x\n", a); 1562 put_dest (dc, a); 1563 1564 /** 1000 1110 POPM dest */ 1565 1566 static int map[] = { r0, r1, r2, r3, a0, a1, sb, fb }; 1567 prefix (0, 0, 0); 1568 imm = IMM(1); 1569 tprintf("popm: %x\n", imm); 1570 for (a=0; a<4; a++) 1571 if (imm & (1<<a)) 1572 { 1573 v = mem_get_hi (get_reg (sp)); 1574 put_reg (map[a], v); 1575 put_reg (sp, get_reg (sp) + 2); 1576 } 1577 for (; a<8; a++) 1578 if (imm & (1<<a)) 1579 { 1580 v = mem_get_si (get_reg (sp)); 1581 put_reg (map[a], v); 1582 put_reg (sp, get_reg (sp) + 4); 1583 } 1584 1585 /** 1010 111w PUSH.size #IMM */ 1586 1587 prefix (0, 0, 0); 1588 imm = IMM(w+1); 1589 tprintf("push%s: %x\n", w ? "hi" : "qi", imm); 1590 int a = get_reg (sp) - 2; 1591 if (w) 1592 mem_put_hi (a, imm); 1593 else 1594 mem_put_qi (a, imm); 1595 put_reg (sp, a); 1596 1597 /** 1100 sss w ss00 1110 PUSH.size src */ 1598 1599 prefix (0, 1, 0); 1600 sc = decode_dest23 (sss, ss, w+1); 1601 a = get_src (sc); 1602 put_reg (sp, get_reg (sp) - 2); 1603 if (w) 1604 mem_put_hi (get_reg (sp), a); 1605 else 1606 mem_put_qi (get_reg (sp), a); 1607 tprintf("push%s: %x\n", w ? "hi" : "qi", a); 1608 1609 /** 1011 0110 0101 0011 PUSH.L #IMM32 */ 1610 1611 imm = IMM(4); 1612 put_reg (sp, get_reg (sp) - 4); 1613 mem_put_si (get_reg (sp), imm); 1614 1615 /** 1010 sss0 ss00 0001 PUSH.L src */ 1616 1617 prefix (0, 1, 0); 1618 sc = decode_dest23 (sss, ss, 4); 1619 a = get_src (sc); 1620 put_reg (sp, get_reg (sp) - 4); 1621 mem_put_si (get_reg (sp), a); 1622 1623 /** 1011 0sa0 ss00 0001 PUSHA src */ 1624 1625 prefix (0, 0, 0); 1626 sc = decode_dest23 (sa, ss, 1); 1627 put_reg (sp, get_reg (sp) - 4); 1628 mem_put_hi (get_reg (sp), sc.u.addr); 1629 tprintf("pushsi: %x\n", sc.u.addr); 1630 1631 /** 1101 0001 1010 1src PUSHC src */ 1632 1633 prefix (0, 0, 0); 1634 sc = decode_cr_b (src, CR_B_DCT0); 1635 a = get_src (sc); 1636 put_reg (sp, get_reg (sp) - 2); 1637 mem_put_hi (get_reg (sp), a); 1638 tprintf("pushhi: %x\n", a); 1639 1640 /** 1101 0001 0010 1src PUSHC src */ 1641 1642 prefix (0, 0, 0); 1643 sc = decode_cr_b (src, CR_B_INTB); 1644 a = get_src (sc); 1645 put_reg (sp, get_reg (sp) - 4); 1646 mem_put_si (get_reg (sp), a); 1647 tprintf("pushsi: %x\n", a); 1648 1649 /** 1000 1111 PUSHM src */ 1650 1651 static int map[] = { fb, sb, a1, a0, r3, r2, r1, r0 }; 1652 imm = IMM(1); 1653 tprintf("pushm: %x\n", imm); 1654 for (a=0; a<4; a++) 1655 if (imm & (1<<a)) 1656 { 1657 put_reg (sp, get_reg (sp) - 4); 1658 v = get_reg (map[a]); 1659 mem_put_si (get_reg (sp), v); 1660 } 1661 for (; a<8; a++) 1662 if (imm & (1<<a)) 1663 { 1664 put_reg (sp, get_reg (sp) - 2); 1665 v = get_reg (map[a]); 1666 mem_put_hi (get_reg (sp), v); 1667 } 1668 1669 /** 1001 1110 REIT */ 1670 1671 a = get_reg (sp); 1672 put_reg (pc, mem_get_si (a)); 1673 a += 4; 1674 put_reg (flags, mem_get_hi (a)); 1675 a += 2; 1676 put_reg (sp, a); 1677 1678 /** 1011 1000 010w 0011 RMPA.size */ 1679 1680 int count = get_reg (r3); 1681 int list1 = get_reg (a0); 1682 int list2 = get_reg (a1); 1683 long long sum = get_reg_ll (r3r1r2r0) & 0xffffff; 1684 1685 while (count) 1686 { 1687 if (w) 1688 { 1689 a = sign_ext (mem_get_hi (list1), 16); 1690 b = sign_ext (mem_get_hi (list2), 16); 1691 } 1692 else 1693 { 1694 a = sign_ext (mem_get_qi (list1), 8); 1695 b = sign_ext (mem_get_qi (list2), 8); 1696 } 1697 tprintf("%lld + %d * %d = ", sum, a, b); 1698 sum += a * b; 1699 tprintf("%lld\n", sum); 1700 list1 += w ? 2 : 1; 1701 list2 += w ? 2 : 1; 1702 count --; 1703 } 1704 put_reg (r3, count); 1705 put_reg (a0, list1); 1706 put_reg (a1, list2); 1707 put_reg (r2r0, (int)(sum & 0xffffffffU)); 1708 put_reg (r1, (int)(sum >> 32)); 1709 1710 /** 1011 ddd w dd10 1110 ROLC.size dest */ 1711 1712 prefix (0, 1, 0); 1713 dc = decode_dest23 (ddd, dd, w+1); 1714 rot_op (dc, 1, 1); 1715 1716 /** 1010 ddd w dd10 1110 RORC.size dest */ 1717 1718 prefix (0, 1, 0); 1719 dc = decode_dest23 (ddd, dd, w+1); 1720 rot_op (dc, 1, -1); 1721 1722 /** 1110 ddd w dd10 immm ROT.size #IMM, dest */ 1723 1724 prefix (0, 1, 0); 1725 dc = decode_dest23 (ddd, dd, w+1); 1726 rot_op (dc, IMM4(), -1); 1727 1728 /** 1010 ddd w dd11 1111 ROT.size R1H,dest */ 1729 1730 prefix (0, 1, 0); 1731 dc = decode_dest23 (ddd, dd, w+1); 1732 a = sign_ext (get_reg (r1h), 8); 1733 rot_op (dc, a, -1); 1734 1735 /** 1101 1111 RTS */ 1736 1737 put_reg (pc, mem_get_si (get_reg (sp))); 1738 put_reg (sp, get_reg (sp) + 4); 1739 1740 /** 0000 0001 1001 ddd w dd10 1110 SBB.size #IMM, dest */ 1741 1742 prefix (0, 0, 0); 1743 dc = decode_dest23 (ddd, dd, w+1); 1744 imm = IMM (w+1); 1745 MATH_OP (dc, imm, !carry, -); 1746 1747 /** 0000 0001 1sss ddd w dd ss 0110 SBB.size src,dest */ 1748 1749 prefix (0, 0, 0); 1750 sc = decode_src23 (sss, ss, w+1); 1751 dc = decode_dest23 (ddd, dd, w+1); 1752 MATH_OP (dc, get_src (sc), !carry, -); 1753 1754 /** 1101 ddd1 dd11 cond SCcond dest */ 1755 1756 prefix (0, 1, 0); 1757 dc = decode_dest23 (ddd, dd, 2); 1758 if (condition_true (cond)) 1759 put_dest (dc, 1); 1760 else 1761 put_dest (dc, 0); 1762 1763 /** 1011 1000 110w 0011 SCMPU.size */ 1764 1765 ta0 = get_reg (a0); 1766 ta1 = get_reg (a1); 1767 1768 for (;;) 1769 { 1770 t0 = mem_get_qi (ta0); 1771 t2 = mem_get_qi (ta1); 1772 if (w) 1773 { 1774 t1 = mem_get_qi (ta0 + 1); 1775 t3 = mem_get_qi (ta1 + 1); 1776 } 1777 dif = t0 - t2; 1778 if (dif == 0 && t0 != 0 && w) 1779 dif = t1 - t3; 1780 set_oszc (dif, 1, dif > 0); 1781 1782 ta0 += w ? 2 : 1; 1783 ta1 += w ? 2 : 1; 1784 1785 if (t0 == 0 || t0 != t2) 1786 break; 1787 if (w && (t1 == 0 || t1 != t3)) 1788 break; 1789 } 1790 1791 /** 1111 ddd w dd00 immm SHA.size #IMM,dest */ 1792 1793 prefix (0, 1, 0); 1794 dc = decode_dest23 (ddd, dd, w+1); 1795 shift_op (dc, 1, IMM4(), 1); 1796 1797 /** 1010 ddd0 dd10 0001 SHA.L #IMM,dest */ 1798 1799 prefix (0, 1, 0); 1800 dc = decode_dest23 (ddd, dd, 4); 1801 imm = sign_ext (IMM(1), 8); 1802 shift_op (dc, 1, imm, 1); 1803 1804 /** 1011 ddd w dd11 1110 SHA.size R1H,dest */ 1805 1806 prefix (0, 1, 0); 1807 dc = decode_dest23 (ddd, dd, w+1); 1808 a = sign_ext (get_reg (r1h), 8); 1809 shift_op (dc, 1, a, 1); 1810 1811 /** 1100 ddd0 dd01 0001 SHA.L R1H,dest */ 1812 1813 prefix (0, 1, 0); 1814 dc = decode_dest23 (ddd, dd, 4); 1815 a = sign_ext (get_reg (r1h), 8); 1816 shift_op (dc, 1, a, 1); 1817 1818 /** 1100 ddd0 dd10 0001 SHANC.L #IMM,dest */ 1819 1820 M32C_ONLY(); 1821 prefix (0, 1, 0); 1822 dc = decode_dest23 (ddd, dd, 4); 1823 imm = sign_ext (IMM(1), 8); 1824 shift_op (dc, 1, imm, 0); 1825 1826 /** 1110 ddd w dd00 immm SHL.size #IMM, dest */ 1827 1828 prefix (0, 1, 0); 1829 dc = decode_dest23 (ddd, dd, w+1); 1830 shift_op (dc, 0, IMM4(), 1); 1831 1832 /** 1001 ddd0 dd10 0001 SHL.L #IMM, dest */ 1833 1834 prefix (0, 1, 0); 1835 dc = decode_dest23 (ddd, dd, 4); 1836 imm = sign_ext (IMM(1), 8); 1837 shift_op (dc, 0, imm, 1); 1838 1839 /** 1010 ddd w dd11 1110 SHL.size R1H,dest */ 1840 1841 prefix (0, 1, 0); 1842 dc = decode_dest23 (ddd, dd, w+1); 1843 a = sign_ext (get_reg (r1h), 8); 1844 shift_op (dc, 0, a, 1); 1845 1846 /** 1100 ddd0 dd00 0001 SHL.L R1H,dest */ 1847 1848 prefix (0, 1, 0); 1849 dc = decode_dest23 (ddd, dd, 4); 1850 a = sign_ext (get_reg (r1h), 8); 1851 shift_op (dc, 0, a, 1); 1852 1853 /** 1000 ddd0 dd10 0001 SHLNC.L #IMM,dest */ 1854 1855 M32C_ONLY(); 1856 prefix (0, 1, 0); 1857 dc = decode_dest23 (ddd, dd, 4); 1858 imm = sign_ext (IMM(1), 8); 1859 shift_op (dc, 0, imm, 0); 1860 1861 /** 1011 0010 100w 0011 SIN.size */ 1862 1863 v = get_reg (a0); 1864 a = get_reg (a1); 1865 b = get_reg (r3); 1866 if (b) for (;b;) 1867 { 1868 if (w) 1869 mem_put_hi(a, mem_get_hi (v)); 1870 else 1871 mem_put_qi(a, mem_get_qi (v)); 1872 a += w ? 2 : 1; 1873 b --; 1874 } 1875 put_reg (a0, v); 1876 put_reg (a1, a); 1877 put_reg (r3, b); 1878 1879 /** 1011 0110 100w 0011 SMOVB.size */ 1880 1881 v = get_reg (a0); 1882 a = get_reg (a1); 1883 b = get_reg (r3); 1884 if (b) for (;b;) 1885 { 1886 if (w) 1887 mem_put_hi(a, mem_get_hi (v)); 1888 else 1889 mem_put_qi(a, mem_get_qi (v)); 1890 v -= w ? 2 : 1; 1891 a -= w ? 2 : 1; 1892 b --; 1893 } 1894 put_reg (a0, v); 1895 put_reg (a1, a); 1896 put_reg (r3, b); 1897 1898 /** 1011 0000 100w 0011 SMOVF.size */ 1899 1900 v = get_reg (a0); 1901 a = get_reg (a1); 1902 b = get_reg (r3); 1903 if (b) for (;b;) 1904 { 1905 if (w) 1906 mem_put_hi(a, mem_get_hi (v)); 1907 else 1908 mem_put_qi(a, mem_get_qi (v)); 1909 v += w ? 2 : 1; 1910 a += w ? 2 : 1; 1911 b --; 1912 } 1913 put_reg (a0, v); 1914 put_reg (a1, a); 1915 put_reg (r3, b); 1916 1917 /** 1011 1000 100w 0011 SMOVU.size */ 1918 1919 v = get_reg (a0); 1920 a = get_reg (a1); 1921 do 1922 { 1923 if (w) 1924 mem_put_hi(a, (t0 = mem_get_hi (v))); 1925 else 1926 mem_put_qi(a, (t0 = mem_get_qi (v))); 1927 v += w ? 2 : 1; 1928 a += w ? 2 : 1; 1929 if (t0 == 0 1930 || (w && ((t0 & 0xff) == 0 || (t0 & 0xff00) == 0))) 1931 break; 1932 } while (1); 1933 put_reg (a0, v); 1934 put_reg (a1, a); 1935 1936 /** 1011 0100 100w 0011 SOUT.size */ 1937 1938 v = get_reg (a0); 1939 a = get_reg (a1); 1940 b = get_reg (r3); 1941 for (;b;) 1942 { 1943 if (w) 1944 mem_put_hi(a, mem_get_hi (v)); 1945 else 1946 mem_put_qi(a, mem_get_qi (v)); 1947 v += w ? 2 : 1; 1948 b --; 1949 } 1950 put_reg (a0, v); 1951 put_reg (a1, a); 1952 put_reg (r3, b); 1953 1954 /** 1011 1000 000w 0011 SSTR.size */ 1955 1956 a = get_reg (a1); 1957 b = get_reg (r3); 1958 v = get_reg (w ? r0 : r0l); 1959 for (;b;) 1960 { 1961 if (w) 1962 mem_put_hi(a, v); 1963 else 1964 mem_put_qi(a, v); 1965 a += w ? 2 : 1; 1966 b --; 1967 } 1968 put_reg (a1, a); 1969 put_reg (r3, b); 1970 1971 /** 0000 0001 1101 ddd1 dd01 0src STC src,dest */ 1972 1973 prefix (0, 0, 0); 1974 dc = decode_dest23 (ddd, dd, 4); 1975 sc = decode_cr_b (src, CR_B_DMA0); 1976 a = get_src (sc); 1977 put_dest (dc, a); 1978 1979 /** 0000 0001 1101 ddd1 dd01 1src STC src,dest */ 1980 1981 prefix (0, 0, 0); 1982 dc = decode_dest23 (ddd, dd, 2); 1983 sc = decode_cr_b (src, CR_B_DCT0); 1984 a = get_src (sc); 1985 put_dest (dc, a); 1986 1987 /** 1101 ddd1 dd01 0src STC src,dest */ 1988 1989 prefix (0, 0, 0); 1990 dc = decode_dest23 (ddd, dd, 4); 1991 sc = decode_cr_b (src, CR_B_INTB); 1992 a = get_src (sc); 1993 put_dest (dc, a); 1994 1995 /** 1011 0110 1101 0011 STCX abs16,abs24 */ 1996 1997 NOTYET(); 1998 1999 /** 1001 ddd w dd01 1111 STNZ.size #IMM,dest */ 2000 2001 prefix (0, 1, 0); 2002 dc = decode_dest23 (ddd, dd, w+1); 2003 imm = IMM(w+1); 2004 if (! FLAG_Z) 2005 put_dest (dc, imm); 2006 2007 /** 1001 ddd w dd00 1111 STZ.size #IMM,dest */ 2008 2009 prefix (0, 1, 0); 2010 dc = decode_dest23 (ddd, dd, w+1); 2011 imm = IMM(w+1); 2012 if (FLAG_Z) 2013 put_dest (dc, imm); 2014 2015 /** 1001 ddd w dd11 1111 STZX.size #IMM1,#IMM2,dest */ 2016 2017 prefix (0, 1, 0); 2018 dc = decode_dest23 (ddd, dd, w+1); 2019 a = IMM(w+1); 2020 b = IMM(w+1); 2021 if (FLAG_Z) 2022 put_dest (dc, a); 2023 else 2024 put_dest (dc, b); 2025 2026 /** 1000 ddd w dd11 1110 SUB.size:G #IMM,dest */ 2027 2028 prefix (0, 1, 0); 2029 dc = decode_dest23(ddd, dd, w+1); 2030 imm = IMM(w+1); 2031 MATH_OP (dc, imm, 0, -); 2032 2033 /** 1001 ddd0 dd11 0001 SUB.L:G #IMM,dest */ 2034 2035 prefix (0, 1, 0); 2036 dc = decode_dest23(ddd, dd, 4); 2037 imm = IMM(4); 2038 MATH_OP (dc, imm, 0, -); 2039 2040 /** 00dd 111w SUB.size:S #IMM,dest */ 2041 2042 prefix (0, 1, 0); 2043 dc = decode_dest2(dd, w+1); 2044 imm = IMM (w+1); 2045 MATH_OP (dc, imm, 0, -); 2046 2047 /** 1sss ddd w dd ss 1010 SUB.size:G src,dest */ 2048 2049 prefix (1, 1, 0); 2050 sc = decode_src23(sss, ss, w+1); 2051 dc = decode_dest23(ddd, dd, w+1); 2052 b = get_src (sc); 2053 MATH_OP (dc, b, 0, -); 2054 2055 /** 1sss ddd1 dd ss 0000 SUB.L:G src,dest */ 2056 2057 prefix (1, 1, 0); 2058 sc = decode_src23(sss, ss, 4); 2059 dc = decode_dest23(ddd, dd, 4); 2060 b = get_src (sc); 2061 MATH_OP (dc, b, 0, -); 2062 2063 /** 1001 ddd0 dd01 0001 SUBX #IMM,dest */ 2064 2065 prefix (0, 1, 0); 2066 dc = decode_dest23(ddd, dd, 4); 2067 imm = sign_ext (IMM(1), 8); 2068 MATH_OP (dc, imm, 0, -); 2069 2070 /** 1sss ddd0 dd ss 0000 SUBX src,dest */ 2071 2072 prefix (1, 1, 0); 2073 sc = decode_src23(sss, ss, 1); 2074 dc = decode_dest23(ddd, dd, 4); 2075 b = sign_ext (get_src (sc), 8); 2076 MATH_OP (dc, b, 0, -); 2077 2078 /** 1001 ddd w dd11 1110 TST.size:G #IMM,dest */ 2079 2080 prefix (0, 0, 0); 2081 dc = decode_dest23 (ddd, dd, w+1); 2082 imm = IMM(w+1); 2083 a = get_src (dc); 2084 v = a & imm; 2085 set_sz (v, w+1); 2086 2087 /** 00dd 110w TST.size:S #IMM,dest */ 2088 2089 prefix (0, 0, 0); 2090 dc = decode_dest2 (dd, w+1); 2091 imm = IMM(w+1); 2092 a = get_src (dc); 2093 v = a & imm; 2094 set_sz (v, w+1); 2095 2096 /** 0000 0001 1sss ddd w dd ss 1001 TST.size:G src,dest */ 2097 2098 prefix (0, 0, 0); 2099 sc = decode_src23 (sss, ss, w+1); 2100 dc = decode_dest23 (ddd, dd, w+1); 2101 b = get_src (sc); 2102 a = get_src (dc); 2103 v = a & b; 2104 set_sz (v, w+1); 2105 2106 /** 1111 1111 UND */ 2107 2108 trigger_fixed_interrupt (0xffffdc); 2109 2110 /** 1011 0010 0000 0011 WAIT */ 2111 2112 ; 2113 2114 /** 1101 ddd w dd00 1src XCHG.size src,dest */ 2115 2116 dc = decode_dest23 (ddd, dd, w+1); 2117 sc = decode_src3 (src, w+1); 2118 a = get_src (dc); 2119 b = get_src (sc); 2120 put_dest (dc, b); 2121 put_dest (sc, a); 2122 2123 /** 1001 ddd w dd00 1110 XOR.size #IMM,dest */ 2124 2125 prefix (0, 1, 0); 2126 dc = decode_dest23(ddd, dd, w+1); 2127 imm = IMM(w+1); 2128 LOGIC_OP (dc, imm, ^); 2129 2130 /** 1sss ddd w dd ss 1001 XOR.size src,dest */ 2131 2132 prefix (1, 1, 0); 2133 sc = decode_src23(sss, ss, w+1); 2134 dc = decode_dest23(ddd, dd, w+1); 2135 b = get_src (sc); 2136 LOGIC_OP (dc, b, ^); 2137 2138 /** */ 2139 2140 return step_result; 2141 } 2142
Indexes created Mon May 18 00:24:49 UTC 2026