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