1/* m32c.opc --- semantics for m32c opcodes. -*- mode: c -*- 2 3Copyright (C) 2005, 2007 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 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 34static unsigned char 35getbyte () 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", orig_pc) 53#define NOTYET() unsupported("unimplemented", orig_pc) 54 55static void 56unsupported (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 79static int 80IMM(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. */ 108void 109prefix (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, ll > ((1 op 1) ? b2mask[dc.bytes] : 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 159static void 160cmp (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 181static void 182dadd_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 233static void 234div_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 305static void 306index_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 316static void 317rot_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 349static void 350shift_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 393int 394decode_m32c() 395{ 396 unsigned char op[40]; 397 int opi; 398 int orig_pc; 399 int v, a, b; 400 long long ll; 401 srcdest sc, dc; 402 int imm; 403 int bitindex = -1; 404 int t0, t1=0, t2, t3=0; 405 int ta0, ta1, dif; 406 407 step_result = M32C_MAKE_STEPPED (); 408 409 decode_indirect (0, 0); 410 decode_index (0, 0); 411 412next_opcode: 413 opi = 0; 414 orig_pc = get_reg (pc); 415 416 tprintf("trace: decode pc = %06x\n", orig_pc); 417 418 /** VARY sss 000 001 010 011 100 */ 419 /** VARY ddd 000 001 010 011 100 */ 420 421 /** 0000 1001 indirect dest */ 422 423 decode_indirect (0, 1); 424 goto next_opcode; 425 426 /** 0100 0001 indirect src */ 427 428 decode_indirect (1, 0); 429 goto next_opcode; 430 431 /** 0100 1001 indirect src and dest */ 432 433 decode_indirect (1, 1); 434 goto next_opcode; 435 436 /** 1010 ddd w dd01 1111 ABS.size dest */ 437 438 prefix (0, 1, 0); 439 dc = decode_dest23 (ddd, dd, w+1); 440 v = sign_ext (get_src (dc), w?16:8); 441 a = v<0 ? -v : v; 442 tprintf("abs(%d) = %d\n", v, a); 443 set_osz(a, w+1); 444 put_dest (dc, a); 445 446 /** 0000 0001 1000 ddd w dd10 1110 ADC.size #IMM,dest */ 447 448 prefix (0, 0, 0); 449 dc = decode_dest23 (ddd, dd, w+1); 450 imm = IMM (w+1); 451 MATH_OP (dc, imm, carry, +); 452 453 /** 0000 0001 1sss ddd w dd ss 0100 ADC.size src,dest */ 454 455 prefix (0, 0, 0); 456 sc = decode_src23 (sss, ss, w+1); 457 dc = decode_dest23 (ddd, dd, w+1); 458 b = get_src (sc); 459 MATH_OP (dc, b, carry, +); 460 461 /** 1011 ddd w dd01 1110 ADCF.size dest */ 462 463 prefix (0, 1, 0); 464 dc = decode_dest23 (ddd, dd, w+1); 465 MATH_OP (dc, 0, carry, +); 466 467 /** 1000 ddd w dd10 1110 ADD.size:G #IMM,dest */ 468 469 prefix (0, 1, 0); 470 dc = decode_dest23(ddd, dd, w+1); 471 imm = IMM(w+1); 472 MATH_OP (dc, imm, 0, +); 473 474 /** 1000 ddd0 dd11 0001 ADD.L:G #IMM,dest */ 475 476 prefix (0, 1, 0); 477 dc = decode_dest23(ddd, dd, 4); 478 imm = IMM(4); 479 MATH_OP (dc, imm, 0, +); 480 481 /** 111L ddd w dd11 immm ADD.size:Q #IMM,dest */ 482 483 prefix (0, 1, 0); 484 dc = decode_dest23(ddd, dd, L ? 4 : (w+1)); 485 imm = sign_ext (immm, 4); 486 MATH_OP (dc, imm, 0, +); 487 488 /** 00dd 011w ADD.size:S #IMM,dest */ 489 490 prefix (0, 1, 0); 491 dc = decode_dest2(dd, w+1); 492 imm = IMM (w+1); 493 MATH_OP (dc, imm, 0, +); 494 495 /** 10i0 110d ADD.L:S #IMM,A0/A1 */ 496 497 prefix (0, 0, 0); 498 dc = reg_sd (d ? a1 : a0); 499 imm = i ? 2 : 1; 500 MATH_OP (dc, imm, 0, +); 501 502 /** 1sss ddd w dd ss 1000 ADD.size:G src,dest */ 503 504 prefix (1, 1, 0); 505 sc = decode_src23(sss, ss, w+1); 506 dc = decode_dest23(ddd, dd, w+1); 507 b = get_src (sc); 508 MATH_OP (dc, b, 0, +); 509 510 /** 1sss ddd1 dd ss 0010 ADD.L:G src,dest */ 511 512 prefix (1, 1, 0); 513 sc = decode_src23(sss, ss, 4); 514 dc = decode_dest23(ddd, dd, 4); 515 b = get_src (sc); 516 MATH_OP (dc, b, 0, +); 517 518 /** 1011 0110 0001 0011 ADD.L:G #IMM16,SP */ 519 520 prefix (0, 0, 0); 521 dc = reg_sd (sp); 522 b = sign_ext (IMM(2), 16); 523 MATH_OP (dc, b, 0, +); 524 525 /** 01ii 001i ADD.L:Q #IMM3,SP */ 526 527 prefix (0, 0, 0); 528 dc = reg_sd (sp); 529 b = ii * 2 + i + 1; 530 MATH_OP (dc, b, 0, +); 531 532 /** 1011 0110 0000 0011 ADD.L:S #IMM8,SP */ 533 534 prefix (0, 0, 0); 535 dc = reg_sd (sp); 536 b = sign_ext (IMM(1), 8); 537 MATH_OP (dc, b, 0, +); 538 539 /** 1000 ddd0 dd01 0001 ADDX #IMM,dest */ 540 541 prefix (0, 1, 0); 542 dc = decode_dest23(ddd, dd, 4); 543 imm = sign_ext (IMM(1), 8); 544 MATH_OP (dc, imm, 0, +); 545 546 /** 1sss ddd0 dd ss 0010 ADDX src,dest */ 547 548 prefix (1, 1, 0); 549 sc = decode_src23(sss, ss, 1); 550 dc = decode_dest23(ddd, dd, 4); 551 b = sign_ext (get_src (sc), 8); 552 MATH_OP (dc, b, 0, +); 553 554 /** 1111 ddd w dd01 immm ADJNZ.size #IMM,dest,label */ 555 556 prefix (0, 0, 0); 557 dc = decode_dest23 (ddd, dd, w+1); 558 v = get_src (dc); 559 imm = sign_ext(immm, 4); 560 tprintf("%d + %d = %d\n", v, imm, v+imm); 561 v += imm; 562 put_dest (dc, v); 563 a = sign_ext (IMM(1), 8); 564 if ((v & (w ? 0xffff : 0xff)) != 0) 565 { 566 tprintf("jmp: %x + 2 + %d = ", get_reg (pc), a); 567 put_reg (pc, orig_pc + 2 + a); 568 tprintf("%x\n", get_reg (pc)); 569 } 570 571 /** 1000 ddd w dd11 1111 AND.size:G #IMM,dest */ 572 573 prefix (0, 1, 0); 574 dc = decode_dest23(ddd, dd, w+1); 575 imm = IMM(w+1); 576 LOGIC_OP (dc, imm, &); 577 578 /** 01dd 110w AND.size:S #IMM,dest */ 579 580 prefix (0, 1, 0); 581 dc = decode_dest2(dd, w+1); 582 imm = IMM (w+1); 583 LOGIC_OP (dc, imm, &); 584 585 /** 1sss ddd w dd ss 1101 AND.size:G src,dest */ 586 587 prefix (1, 1, 0); 588 sc = decode_src23(sss, ss, w+1); 589 dc = decode_dest23(ddd, dd, w+1); 590 b = get_src (sc); 591 LOGIC_OP (dc, b, &); 592 593 /** 0000 0001 1101 sss0 ss00 1bit BAND src */ 594 595 sc = decode_src23 (sss, ss, 1); 596 BIT_OPC (sc, bit, b & carry); 597 598 /** 1101 ddd0 dd11 0bit BCLR dest */ 599 600 dc = decode_dest23 (ddd, dd, 1); 601 BIT_OP (dc, bit, 0); 602 603 /** 1100 ddd w dd10 1110 BITINDEX.size src */ 604 605 prefix (0, 0, 0); 606 dc = decode_dest23 (ddd, dd, w+1); 607 bitindex = get_src (dc); 608 tprintf ("bitindex set to %d\n", bitindex); 609 goto next_opcode; 610 611 /** 1101 ddd0 dd01 0bit BMcnd dest */ 612 613 prefix (0, 0, 0); 614 dc = decode_dest23 (ddd, dd, 1); 615 if (condition_true (IMM (1))) 616 put_bit2 (dc, bit, 1); 617 else 618 put_bit2 (dc, bit, 0); 619 620 /** 1101 1001 0c10 1cnd BMcnd C */ 621 622 prefix (0, 0, 0); 623 if (condition_true (c * 8 + cnd)) 624 set_c (1); 625 else 626 set_c (0); 627 628 /** 0000 0001 1101 sss0 ss01 1bit BNAND src */ 629 630 prefix (0, 0, 0); 631 sc = decode_src23 (sss, ss, 1); 632 BIT_OPC (sc, bit, !b & carry); 633 634 /** 0000 0001 1101 sss0 ss11 0bit BNOR src */ 635 636 prefix (0, 0, 0); 637 sc = decode_src23 (sss, ss, 1); 638 BIT_OPC (sc, bit, !b | carry); 639 640 /** 1101 ddd0 dd01 1bit BNOT dest */ 641 642 prefix (0, 0, 0); 643 dc = decode_dest23 (ddd, dd, 1); 644 BIT_OP (dc, bit, !b); 645 646 /** 0000 0001 1101 sss0 ss00 0bit BNTST src */ 647 648 prefix (0, 0, 0); 649 sc = decode_dest23 (sss, ss, 1); 650 b = get_bit2 (sc, bit); 651 set_zc (!b, !b); 652 653 /** 0000 0001 1101 sss0 ss11 1bit BNXOR src */ 654 655 prefix (0, 0, 0); 656 sc = decode_src23 (sss, ss, 1); 657 BIT_OPC (sc, bit, !b ^ carry); 658 659 /** 0000 0001 1101 sss0 ss10 0bit BOR src */ 660 661 prefix (0, 0, 0); 662 sc = decode_src23 (sss, ss, 1); 663 BIT_OPC (sc, bit, b | carry); 664 665 /** 0000 0000 BRK */ 666 667 /* We report the break to our caller with the PC still pointing at the 668 breakpoint instruction. */ 669 put_reg (pc, orig_pc); 670 if (verbose) 671 printf("[break]\n"); 672 return M32C_MAKE_HIT_BREAK (); 673 674 /** 0000 1000 BRK */ 675 676 if (verbose) 677 printf("[break2]\n"); 678 return M32C_MAKE_HIT_BREAK (); 679 680 /** 1101 ddd0 dd11 1bit BSET dest */ 681 682 dc = decode_dest23 (ddd, dd, 1); 683 BIT_OP (dc, bit, 1); 684 685 /** 1101 sss0 ss00 0bit BTST:G src */ 686 687 prefix (0, 0, 0); 688 sc = decode_src23 (sss, ss, 1); 689 b = get_bit2 (sc, bit); 690 set_zc (!b, b); 691 692 /** 00bb 101b BTST:S src */ 693 694 sc = decode_src23 (3, 3, 1); /* bit,base:19 */ 695 b = get_bit2 (sc, bb*2 + b); 696 set_zc (!b, b); 697 698 /** 1101 ddd0 dd10 0bit BTSTC dest */ 699 700 prefix (0, 0, 0); 701 sc = decode_dest23 (ddd, dd, 1); 702 b = get_bit2 (sc, bit); 703 set_zc (!b, b); 704 put_bit2 (sc, bit, 0); 705 706 /** 1101 ddd0 dd10 1bit BTSTS dest */ 707 708 prefix (0, 0, 0); 709 sc = decode_dest23 (ddd, dd, 1); 710 b = get_bit2 (sc, bit); 711 set_zc (!b, b); 712 put_bit2 (sc, bit, 1); 713 714 /** 0000 0001 1101 sss0 ss10 1bit BXOR src */ 715 716 prefix (0, 0, 0); 717 sc = decode_src23 (sss, ss, 1); 718 BIT_OPC (sc, bit, b ^ carry); 719 720 /** 0000 0001 1000 ddd w dd11 1110 CLIP.size #IMM1,#IMM2,dest */ 721 722 prefix (0, 0, 0); 723 dc = decode_dest23 (ddd, dd, w+1); 724 a = sign_ext (IMM(w+1), w*8+8); 725 b = sign_ext (IMM(w+1), w*8+8); 726 v = sign_ext (get_src (dc), w*8+8); 727 tprintf("clip %d <= %d <= %d : ", a, v, b); 728 if (a > v) 729 v = a; 730 if (v > b) 731 v = b; 732 tprintf("%d\n", v); 733 put_dest (dc, v); 734 735 /** 1001 ddd w dd10 1110 CMP.size:G #IMM,dest */ 736 737 prefix (0, 1, 0); 738 dc = decode_dest23 (ddd, dd, w+1); 739 v = get_src (dc); 740 imm = IMM(w+1); 741 cmp (v, imm, w+1); 742 743 /** 1010 ddd0 dd11 0001 CMP.L:G #IMM32,dest */ 744 745 prefix (0, 1, 0); 746 dc = decode_dest23 (ddd, dd, 4); 747 v = get_src (dc); 748 imm = IMM(4); 749 cmp (v, imm, 4); 750 751 /** 1110 ddd w dd01 immm CMP.size:Q #IMM,dest */ 752 753 prefix (0, 1, 0); 754 dc = decode_dest23 (ddd, dd, w+1); 755 v = get_src (dc); 756 immm = sign_ext (immm, 4); 757 cmp (v, immm, w+1); 758 759 /** 01dd 011w CMP.size:S #IMM,dest */ 760 761 prefix (0, 1, 0); 762 dc = decode_dest2 (dd, w+1); 763 v = get_src (dc); 764 imm = sign_ext (IMM(w+1),w*8+8); 765 cmp (v, imm, w+1); 766 767 /** 1sss ddd w dd ss 0110 CMP.size:G src,dest */ 768 769 prefix (1, 1, 0); 770 sc = decode_src23 (sss, ss, w+1); 771 dc = decode_dest23 (ddd, dd, w+1); 772 a = get_src (dc); 773 b = get_src (sc); 774 cmp (a, b, w+1); 775 776 /** 1sss ddd1 dd ss 0001 CMP.L:G src,dest */ 777 778 prefix (1, 1, 0); 779 sc = decode_src23 (sss, ss, 4); 780 dc = decode_dest23 (ddd, dd, 4); 781 a = get_src (dc); 782 b = get_src (sc); 783 cmp (a, b, 4); 784 785 /** 01dd 000w CMP.size:S src,R0/R0L */ 786 787 prefix (0, 1, 0); 788 dc = decode_dest2 (dd, w+1); 789 a = get_reg (w ? r0 : r0l); 790 b = get_src (dc); 791 cmp (a, b, w+1); 792 793 /** 1010 ddd0 dd01 0001 CMPX #IMM,dest */ 794 795 prefix (0, 1, 0); 796 dc = decode_dest23 (ddd, dd, 4); 797 v = get_src (dc); 798 imm = sign_ext (IMM(1), 8); 799 cmp (v, imm, 4); 800 801 /** 0000 0001 1000 ddd w dd00 1110 DADC.size #IMM,dest */ 802 803 DADDI(1,1); 804 805 /** 0000 0001 1sss ddd w dd ss 1000 DADC.size src,dest */ 806 807 DADDV(1,1); 808 809 /** 0000 0001 1000 ddd w dd01 1110 DADD.size #IMM,dest */ 810 811 DADDI(1,0); 812 813 /** 0000 0001 1sss ddd w dd ss 0000 DADD.size src,dest */ 814 815 DADDV(1,0); 816 817 /** 1011 ddd w dd00 1110 DEC.size dest */ 818 819 prefix (0, 1, 0); 820 dc = decode_dest23 (ddd, dd, w+1); 821 a = get_src (dc); 822 v = a-1; 823 tprintf ("%x -- = %x\n", a, v); 824 set_sz (v, w+1); 825 put_dest (dc, v); 826 827 /** 1011 0000 010w 0011 DIV.size #IMM */ 828 829 prefix (0, 0, 0); 830 div_op (-1, 0, 0, 0, w+1); 831 832 /** 1000 sss w ss01 1110 DIV.size src */ 833 834 prefix (0, 1, 0); 835 div_op (sss, ss, 0, 0, w+1); 836 837 /** 0000 0001 1010 sss1 ss01 1111 DIV.L src */ 838 839 M32C_ONLY(); 840 prefix (0, 0, 0); 841 div_op (sss, ss, 0, 0, 4); 842 843 /** 1011 0000 000w 0011 DIVU.size #IMM */ 844 845 prefix (0, 0, 0); 846 div_op (-1, 0, 1, 0, w+1); 847 848 /** 1000 sss w ss00 1110 DIVU.size src */ 849 850 prefix (0, 1, 0); 851 div_op (sss, ss, 1, 0, w+1); 852 853 /** 0000 0001 1010 sss1 ss00 1111 DIVU.L src */ 854 855 M32C_ONLY(); 856 prefix (0, 0, 0); 857 div_op (sss, ss, 1, 0, 4); 858 859 /** 1011 0010 010w 0011 DIVX.size #IMM */ 860 861 prefix (0, 0, 0); 862 div_op (-1, 0, 0, 1, w+1); 863 864 /** 1001 sss w ss01 1110 DIVX.size src */ 865 866 prefix (0, 1, 0); 867 div_op (sss, ss, 0, 1, w+1); 868 869 /** 0000 0001 1010 sss1 ss10 1111 DIVX.L src */ 870 871 M32C_ONLY(); 872 prefix (0, 0, 0); 873 div_op (sss, ss, 0, 1, 4); 874 875 /** 0000 0001 1001 ddd w dd00 1110 DSBB.size #IMM,dest */ 876 877 DADDI(0,1); 878 879 /** 0000 0001 1sss ddd w dd ss 1010 DSBB.size src,dest */ 880 881 DADDV(0,1); 882 883 /** 0000 0001 1001 ddd w dd01 1110 DSUB.size #IMM,dest */ 884 885 DADDI(0,0); 886 887 /** 0000 0001 1sss ddd w dd ss 0010 DSUB.size src,dest */ 888 889 DADDV(0,0); 890 891 /** 1110 1100 ENTER #IMM */ 892 893 imm = IMM(1); 894 put_reg (sp, get_reg (sp) - 4); 895 mem_put_si (get_reg (sp), get_reg (fb)); 896 put_reg (fb, get_reg (sp)); 897 put_reg (sp, get_reg (sp) - imm); 898 899 /** 1111 1100 EXITD */ 900 901 put_reg (sp, get_reg (fb)); 902 put_reg (fb, mem_get_si (get_reg (sp))); 903 put_reg (sp, get_reg (sp) + 4); 904 put_reg (pc, mem_get_si (get_reg (sp))); 905 put_reg (sp, get_reg (sp) + 4); 906 907 /** 1100 ddd w dd01 1110 EXTS.size dest */ 908 909 prefix (0, 0, 0); 910 dc = decode_dest23 (ddd, dd, w+1); 911 v = sign_ext (get_src (dc), (w+1)*8); 912 dc = widen_sd (dc); 913 put_dest (dc, v); 914 set_sz (v, (w+1)*2); 915 916 /** 0000 0001 1sss ddd0 dd ss 0111 EXTS.B src,dest */ 917 918 prefix (0, 0, 0); 919 sc = decode_src23 (sss, ss, 1); 920 dc = decode_dest23 (ddd, dd, 2); 921 v = sign_ext (get_src (sc), 8); 922 put_dest (dc, v); 923 set_sz (v, 16); 924 925 /** 0000 0001 1sss ddd0 dd ss 1011 EXTZ src,dest */ 926 927 prefix (0, 0, 0); 928 sc = decode_src23 (sss, ss, 1); 929 dc = decode_dest23 (ddd, dd, 2); 930 v = get_src (sc); 931 put_dest (dc, v); 932 set_sz (v, 16); 933 934 /** 1101 0011 1110 1dst FCLR dest */ 935 936 set_flags (1 << dst, 0); 937 938 /** 1001 1111 FREIT */ 939 940 NOTYET(); 941 942 /** 1101 0001 1110 1dst FSET dest */ 943 944 set_flags (1 << dst, 1 << dst); 945 946 /** 1010 ddd w dd00 1110 INC.size dest */ 947 948 prefix (0, 1, 0); 949 dc = decode_dest23 (ddd, dd, w+1); 950 a = get_src (dc); 951 v = a+1; 952 tprintf ("%x ++ = %x\n", a, v); 953 set_sz (v, w+1); 954 put_dest (dc, v); 955 956 /** 1000 sss0 ss0w 0011 INDEXB.size src */ 957 INDEXOP(1, 1, 1); 958 /** 1010 sss0 ss0w 0011 INDEXBD.size src */ 959 INDEXOP(1, 0, 1); 960 /** 1100 sss0 ss0w 0011 INDEXBS.size src */ 961 INDEXOP(1, 1, 0); 962 /** 1001 sss0 ss1w 0011 INDEXL.size src */ 963 INDEXOP(4, 1, 1); 964 /** 1011 sss0 ss1w 0011 INDEXLD.size src */ 965 INDEXOP(4, 0, 1); 966 /** 1001 sss0 ss0w 0011 INDEXLS.size src */ 967 INDEXOP(4, 1, 0); 968 /** 1000 sss0 ss1w 0011 INDEXW.size src */ 969 INDEXOP(2, 1, 1); 970 /** 1010 sss0 ss1w 0011 INDEXWD.size src */ 971 INDEXOP(2, 0, 1); 972 /** 1100 sss0 ss1w 0011 INDEXWS.size src */ 973 INDEXOP(2, 1, 0); 974 975 /** 1011 1110 vector00 INT #IMM */ 976 977 prefix (0, 0, 0); 978 trigger_based_interrupt (vector); 979 980 /** 1011 1111 INTO */ 981 982 prefix (0, 0, 0); 983 if (FLAG_O) 984 trigger_fixed_interrupt (0xffffe0); 985 986 /** 1ccc 101c Jcnd label */ 987 988 prefix (0, 0, 0); 989 v = sign_ext (IMM(1), 8); 990 if (condition_true (ccc*2+c)) 991 put_reg (pc, orig_pc + 1 + v); 992 993 /** 01dd 101d JMP.S label */ 994 995 prefix (0, 0, 0); 996 put_reg (pc, orig_pc + (dd*2+d) + 2); 997 998 /** 1011 1011 JMP.B label */ 999 1000 prefix (0, 0, 0); 1001 imm = sign_ext (IMM(1), 8); 1002 if (imm == -1) 1003 { 1004 if (verbose) 1005 printf("[jmp-to-self detected as exit]\n"); 1006 return M32C_MAKE_HIT_BREAK (); 1007 } 1008 put_reg (pc, orig_pc + 1 + imm); 1009 1010 /** 1100 1110 JMP.W label */ 1011 1012 prefix (0, 0, 0); 1013 imm = sign_ext (IMM(2), 16); 1014 put_reg (pc, orig_pc + 1 + imm); 1015 1016 /** 1100 1100 JMP.A label */ 1017 1018 prefix (0, 0, 0); 1019 imm = IMM(3); 1020 put_reg (pc, imm); 1021 1022 /** 1100 sss1 ss00 1111 JMPI.W src */ 1023 1024 prefix (0, 0, 0); 1025 sc = decode_src23 (sss, ss, 2); 1026 a = get_src (sc); 1027 a = sign_ext (a, 16); 1028 put_reg (pc, orig_pc + a); 1029 1030 /** 1000 sss0 ss00 0001 JMPI.A src */ 1031 1032 prefix (0, 0, 0); 1033 sc = decode_src23 (sss, ss, 3); 1034 a = get_src (sc); 1035 put_reg (pc, a); 1036 1037 /** 1101 1100 JMPS #IMM8 */ 1038 1039 prefix (0, 0, 0); 1040 imm = IMM(1); 1041 a = 0xff0000 + mem_get_hi (0xfffe00 - imm * 2); 1042 put_reg (pc, a); 1043 1044 /** 1100 1111 JSR.W label */ 1045 1046 prefix (0, 0, 0); 1047 imm = sign_ext (IMM(2), 16); 1048 put_reg (sp, get_reg (sp) - 4); 1049 mem_put_si (get_reg (sp), get_reg (pc)); 1050 put_reg (pc, orig_pc + imm + 1); 1051 1052 /** 1100 1101 JSR.A label */ 1053 1054 prefix (0, 0, 0); 1055 imm = IMM(3); 1056 put_reg (sp, get_reg (sp) - 4); 1057 mem_put_si (get_reg (sp), get_reg (pc)); 1058 put_reg (pc, imm); 1059 1060 /** 1100 sss1 ss01 1111 JSRI.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 (sp, get_reg (sp) - 4); 1067 mem_put_si (get_reg (sp), get_reg (pc)); 1068 put_reg (pc, orig_pc + a); 1069 1070 /** 1001 sss0 ss00 0001 JSRI.A src */ 1071 1072 prefix (0, 0, 0); 1073 sc = decode_src23 (sss, ss, 3); 1074 a = get_src (sc); 1075 put_reg (sp, get_reg (sp) - 4); 1076 mem_put_si (get_reg (sp), get_reg (pc)); 1077 put_reg (pc, a); 1078 1079 /** 1101 1101 JSRS #IMM8 */ 1080 1081 prefix (0, 0, 0); 1082 imm = IMM(1); 1083 a = 0xff0000 + mem_get_hi (0xfffe00 - imm * 2); 1084 put_reg (sp, get_reg (sp) - 4); 1085 mem_put_si (get_reg (sp), get_reg (pc)); 1086 put_reg (pc, a); 1087 1088 /** 1101 0101 1010 1dst LDC #IMM16,dest */ 1089 1090 imm = IMM(2); 1091 dc = decode_cr_b (dst, CR_B_DCT0); 1092 put_dest (dc, imm); 1093 1094 /** 1101 0101 0010 1dst LDC #IMM24,dest */ 1095 1096 imm = IMM(3); 1097 dc = decode_cr_b (dst, CR_B_INTB); 1098 put_dest (dc, imm); 1099 1100 /** 1101 0101 0110 1dst LDC #IMM24,dest */ 1101 1102 imm = IMM(3); 1103 dc = decode_cr_b (dst, CR_B_DMA0); 1104 put_dest (dc, imm); 1105 1106 /** 0000 0001 1101 sss1 ss00 1dst LDC src,dest */ 1107 1108 prefix (0, 0, 0); 1109 sc = decode_src23 (sss, ss, 2); 1110 dc = decode_cr_b (dst, CR_B_DCT0); 1111 a = get_src (sc); 1112 put_dest (dc, a); 1113 1114 /** 1101 sss1 ss00 0dst LDC src,dest */ 1115 1116 prefix (0, 0, 0); 1117 sc = decode_src23 (sss, ss, 3); 1118 dc = decode_cr_b (dst, CR_B_INTB); 1119 a = get_src (sc); 1120 put_dest (dc, a); 1121 1122 /** 0000 0001 1101 sss1 ss00 0dst LDC src,dest */ 1123 1124 prefix (0, 0, 0); 1125 sc = decode_src23 (sss, ss, 3); 1126 dc = decode_cr_b (dst, CR_B_DMA0); 1127 a = get_src (sc); 1128 put_dest (dc, a); 1129 1130 /** 1011 0110 1100 0011 LDCTX */ 1131 1132 NOTYET(); 1133 1134 /** 1101 0101 1110 1imm LDIPL #IMM */ 1135 1136 set_flags (0x7000, imm*0x1000); 1137 1138 /** 0000 0001 1000 ddd w dd11 1111 MAX.size #IMM,dest */ 1139 1140 prefix (0, 0, 0); 1141 w++; 1142 dc = decode_dest23 (ddd, dd, w); 1143 imm = sign_ext (IMM(w), w*8); 1144 a = sign_ext (get_src (dc), w*8); 1145 tprintf ("max %d %d\n", imm, a); 1146 if (imm > a) 1147 put_dest (dc, imm); 1148 1149 /** 0000 0001 1sss ddd w dd ss 1101 MAX.size src,dest */ 1150 1151 prefix (0, 0, 0); 1152 w++; 1153 sc = decode_src23 (sss, ss, w); 1154 dc = decode_dest23 (ddd, dd, w); 1155 b = sign_ext (get_src (sc), w*8); 1156 a = sign_ext (get_src (dc), w*8); 1157 tprintf ("max %d %d\n", b, a); 1158 if (b > a) 1159 put_dest (dc, b); 1160 1161 /** 0000 0001 1000 ddd w dd10 1111 MIN.size #IMM,dest */ 1162 1163 prefix (0, 0, 0); 1164 w++; 1165 dc = decode_dest23 (ddd, dd, w); 1166 imm = sign_ext (IMM(w), w*8); 1167 a = sign_ext (get_src (dc), w*8); 1168 tprintf ("min %d %d\n", imm, a); 1169 if (imm < a) 1170 put_dest (dc, imm); 1171 1172 /** 0000 0001 1sss ddd w dd ss 1100 MIN.size src,dest */ 1173 1174 prefix (0, 0, 0); 1175 w++; 1176 sc = decode_src23 (sss, ss, w); 1177 dc = decode_dest23 (ddd, dd, w); 1178 b = sign_ext (get_src (sc), w*8); 1179 a = sign_ext (get_src (dc), w*8); 1180 tprintf ("min %d %d\n", b, a); 1181 if (b < a) 1182 put_dest (dc, b); 1183 1184 /** 1001 ddd w dd10 1111 MOV.size:G #IMM,dest */ 1185 1186 dc = decode_dest23 (ddd, dd, w+1); 1187 imm = IMM(w+1); 1188 v = imm; 1189 tprintf("%x = %x\n", v, v); 1190 set_sz(v, w+1); 1191 put_dest (dc, v); 1192 1193 /** 1011 ddd0 dd11 0001 MOV.L:G #IMM,dest */ 1194 1195 dc = decode_dest23 (ddd, dd, 4); 1196 imm = IMM(4); 1197 v = imm; 1198 tprintf("%x = %x\n", v, v); 1199 set_sz(v, 4); 1200 put_dest (dc, v); 1201 1202 /** 1111 ddd w dd10 immm MOV.size:Q #IMM4,dest */ 1203 1204 dc = decode_dest23 (ddd, dd, w+1); 1205 imm = sign_ext (immm, 4); 1206 v = imm; 1207 tprintf("%x = %d\n", v, v); 1208 set_sz(v, w+1); 1209 put_dest (dc, v); 1210 1211 /** 00dd 010w MOV.size:S #IMM,dest */ 1212 1213 prefix (0, 1, 0); 1214 dc = decode_dest2 (dd, w+1); 1215 imm = IMM(w+1); 1216 put_dest (dc, imm); 1217 set_sz (imm, w+1); 1218 1219 /** 10w1 110d MOV.size:S #IMM,a0/a1 */ 1220 1221 imm = IMM(w ? 3 : 2); 1222 put_reg (d ? a1 : a0, imm); 1223 set_sz (imm & addr_mask, w+1); 1224 1225 /** 00dd 001w MOV.size:Z #0,dest */ 1226 1227 prefix (0, 1, 0); 1228 dc = decode_dest2 (dd, w+1); 1229 put_dest (dc, 0); 1230 set_sz (0, w+1); 1231 1232 /** 1sss ddd w dd ss 1011 MOV.size:G src,dest */ 1233 1234 prefix (1, 1, 0); 1235 sc = decode_src23 (sss, ss, w+1); 1236 dc = decode_dest23 (ddd, dd, w+1); 1237 v = get_src (sc); 1238 put_dest (dc, v); 1239 set_sz (v, w+1); 1240 1241 /** 1sss ddd1 dd ss 0011 MOV.L:G src,dest */ 1242 1243 prefix (1, 1, 0); 1244 sc = decode_src23 (sss, ss, 4); 1245 dc = decode_dest23 (ddd, dd, 4); 1246 v = get_src (sc); 1247 put_dest (dc, v); 1248 set_sz (v, 4); 1249 1250 /** VARY SS 01 10 11 */ 1251 /** 00SS 100w MOV.size:S src,R0L/R0 */ 1252 1253 prefix (0, 1, 0); 1254 sc = decode_dest2 (SS, w+1); 1255 v = get_src (sc); 1256 put_reg (w ? r0 : r0l, v); 1257 set_sz (v, w+1); 1258 1259 /** 01ss 111w MOV.size:S src,R1L/R1 */ 1260 1261 prefix (0, 1, 0); 1262 sc = decode_dest2 (ss, w+1); 1263 v = get_src (sc); 1264 put_reg (w ? r1 : r1l, v); 1265 set_sz (v, w+1); 1266 1267 /** VARY DD 01 10 11 */ 1268 /** 00DD 000w MOV.size:S R0L/R0,dest */ 1269 1270 prefix (0, 1, 0); 1271 dc = decode_dest2 (DD, w+1); 1272 v = get_reg (w ? r0 : r0l); 1273 put_dest (dc, v); 1274 set_sz (v, w+1); 1275 1276 /** 01ss 100d MOV.L:S src,A0/A1 */ 1277 1278 prefix (0, 1, 0); 1279 sc = decode_dest2 (ss, 4); 1280 v = get_src (sc); 1281 put_reg (d ? a1 : a0, v); 1282 set_sz (v, 4); 1283 1284 /** 1011 ddd w dd00 1111 MOV.size:G dsp:8[SP], dest */ 1285 1286 prefix (0, 0, 0); 1287 imm = IMM(1); 1288 dc = decode_dest23 (ddd, dd, w+1); 1289 a = get_reg (sp) + sign_ext (imm, 8); 1290 a &= addr_mask; 1291 if (w) 1292 v = mem_get_hi (a); 1293 else 1294 v = mem_get_qi (a); 1295 put_dest (dc, v); 1296 set_sz (v, w+1); 1297 1298 /** 1010 sss w ss00 1111 MOV.size:G src,dsp:8[SP] */ 1299 1300 prefix (0, 0, 0); 1301 sc = decode_dest23 (sss, ss, w+1); 1302 imm = IMM(1); 1303 a = get_reg (sp) + sign_ext (imm, 8); 1304 a &= addr_mask; 1305 v = get_src (sc); 1306 if (w) 1307 mem_put_hi (a, v); 1308 else 1309 mem_put_qi (a, v); 1310 set_sz (v, w+1); 1311 1312 /** 1101 sss1 ss01 1dst MOVA src,dest */ 1313 1314 static reg_id map[8] = { r2r0, r3r1, a0, a1 }; 1315 prefix (0, 0, 0); 1316 sc = decode_src23 (sss, ss, 1); 1317 if (!sc.mem || !map[dst]) 1318 UNSUPPORTED(); 1319 put_reg (map[dst], sc.u.addr); 1320 1321 /** 0000 0001 1011 ddd0 dd hl 1110 MOVdir R0L,dest */ 1322 1323 prefix (0, 0, 0); 1324 dc = decode_dest23 (ddd, dd, 1); 1325 a = get_src (dc); 1326 b = get_reg (r0l); 1327 switch (hl) 1328 { 1329 case 0: a = (a & 0xf0) | (b & 0x0f); break; 1330 case 1: a = (a & 0xf0) | ((b>>4) & 0x0f); break; 1331 case 2: a = (a & 0x0f) | ((b & 0x0f)<<4); break; 1332 case 3: a = (a & 0x0f) | (b & 0xf0); break; 1333 } 1334 put_dest (dc, a); 1335 1336 /** 0000 0001 1010 sss0 ss hl 1110 MOVdir src,R0L */ 1337 1338 prefix (0, 0, 0); 1339 sc = decode_dest23 (sss, ss, 1); 1340 a = get_reg (r0l); 1341 b = get_src (dc); 1342 switch (hl) 1343 { 1344 case 0: a = (a & 0xf0) | (b & 0x0f); break; 1345 case 1: a = (a & 0xf0) | ((b>>4) & 0x0f); break; 1346 case 2: a = (a & 0x0f) | ((b & 0x0f)<<4); break; 1347 case 3: a = (a & 0x0f) | (b & 0xf0); break; 1348 } 1349 put_reg (r0l, a); 1350 1351 /** 1011 ddd0 dd01 0001 MOVX #IMM,dest */ 1352 1353 prefix (0, 1, 0); 1354 dc = decode_dest23 (ddd, dd, 4); 1355 imm = sign_ext (IMM(1), 8); 1356 put_dest (dc, imm); 1357 set_sz (imm, 1); 1358 1359 /** 1000 ddd w dd01 1111 MUL.size #IMM,dest */ 1360 1361 prefix (0, 1, 0); 1362 w ++; 1363 dc = decode_dest23 (ddd, dd, w); 1364 v = sign_ext (get_src (dc), w*8); 1365 imm = sign_ext (IMM(w), w*8); 1366 tprintf("%d * %d = %d\n", v, imm, v*imm); 1367 v *= imm; 1368 dc = widen_sd (dc); 1369 put_dest (dc, v); 1370 1371 /** 1sss ddd w dd ss 1100 MUL.size src,dest */ 1372 1373 prefix (1, 1, 0); 1374 w ++; 1375 sc = decode_src23 (sss, ss, w); 1376 dc = decode_dest23 (ddd, dd, w); 1377 a = sign_ext (get_src (sc), w*8); 1378 b = sign_ext (get_src (dc), w*8); 1379 tprintf("%d * %d = %d\n", a, b, a*b); 1380 v = a * b; 1381 dc = widen_sd (dc); 1382 put_dest (dc, v); 1383 1384 /** 0000 0001 1000 sss1 ss01 1111 MUL.L src,R2R0 */ 1385 1386 M32C_ONLY(); 1387 prefix (0, 0, 0); 1388 sc = decode_src23 (sss, ss, 4); 1389 a = sign_ext (get_src (sc), 32); 1390 b = sign_ext (get_reg (r2r0), 32); 1391 ll = (long long)a * (long long)b; 1392 tprintf("%d * %d = %lld (%llx)\n", a, b, ll, ll); 1393 if (ll < b2minsigned[4] || ll > b2maxsigned[4]) 1394 set_flags (FLAGBIT_O, FLAGBIT_O); 1395 else 1396 set_flags (FLAGBIT_O, 0); 1397 put_reg (r2r0, (int)ll); 1398 1399 /** 1100 sss1 ss11 1110 MULEX src */ 1400 1401 prefix (0, 1, 0); 1402 sc = decode_dest23 (sss, ss, 2); 1403 a = sign_ext (get_src (sc), 16); 1404 b = sign_ext (get_reg (r2r0), 32); 1405 ll = (long long)a * (long long)b; 1406 tprintf("%d * %d = %lld (%llx)\n", a, b, ll, ll); 1407 put_reg (r2r0, (int)ll); 1408 put_reg (r1, (int)(ll >> 32)); 1409 1410 /** 1000 ddd w dd00 1111 MULU.size #IMM,dest */ 1411 1412 prefix (0, 1, 0); 1413 w ++; 1414 dc = decode_dest23 (ddd, dd, w); 1415 v = get_src (dc); 1416 imm = IMM(w); 1417 tprintf("%d * %d = %d\n", v, imm, v*imm); 1418 v *= imm; 1419 dc = widen_sd (dc); 1420 put_dest (dc, v); 1421 1422 /** 1sss ddd w dd ss 0100 MULU.size src,dest */ 1423 1424 prefix (1, 1, 0); 1425 w ++; 1426 sc = decode_src23 (sss, ss, w); 1427 dc = decode_dest23 (ddd, dd, w); 1428 a = get_src (sc); 1429 b = get_src (dc); 1430 tprintf("%d * %d = %d\n", a, b, a*b); 1431 v = a * b; 1432 dc = widen_sd (dc); 1433 put_dest (dc, v); 1434 1435 /** 0000 0001 1000 sss1 ss00 1111 MULU.L src,R2R0 */ 1436 1437 M32C_ONLY(); 1438 prefix (0, 0, 0); 1439 sc = decode_src23 (sss, ss, 4); 1440 a = get_src (sc); 1441 b = get_reg (r2r0); 1442 ll = (long long)a * (long long)b; 1443 tprintf("%d * %d = %lld (%llx)\n", a, b, ll, ll); 1444 if (ll < b2minsigned[4] || ll > b2maxsigned[4]) 1445 set_flags (FLAGBIT_O, FLAGBIT_O); 1446 else 1447 set_flags (FLAGBIT_O, 0); 1448 put_reg (r2r0, (int)ll); 1449 1450 /** 1010 ddd w dd10 1111 NEG.size dest */ 1451 1452 prefix (0, 1, 0); 1453 dc = decode_dest23 (ddd, dd, w+1); 1454 a = sign_ext (get_src (dc), (w+1)*8); 1455 v = -a; 1456 tprintf("%d * -1 = %d\n", a, v); 1457 set_oszc(v, w+1, v==0); 1458 put_dest (dc, v); 1459 1460 /** 1101 1110 NOP */ 1461 1462 tprintf("nop\n"); 1463 1464 /** 1010 ddd w dd01 1110 NOT.size dest */ 1465 1466 prefix (0, 1, 0); 1467 dc = decode_dest23 (ddd, dd, w+1); 1468 a = get_src (dc); 1469 v = ~a; 1470 tprintf("~ %x = %x\n", a, v); 1471 set_sz(v, w+1); 1472 put_dest (dc, v); 1473 1474 /** 1000 ddd w dd10 1111 OR.size:G #IMM,dest */ 1475 1476 prefix (0, 1, 0); 1477 dc = decode_dest23(ddd, dd, w+1); 1478 imm = IMM(w+1); 1479 LOGIC_OP (dc, imm, |); 1480 1481 /** 01dd 010w OR.size:S #IMM,dest */ 1482 1483 prefix (0, 1, 0); 1484 dc = decode_dest2(dd, w+1); 1485 imm = IMM (w+1); 1486 LOGIC_OP (dc, imm, |); 1487 1488 /** 1sss ddd w dd ss 0101 OR.size:G src,dest */ 1489 1490 prefix (1, 1, 0); 1491 sc = decode_src23(sss, ss, w+1); 1492 dc = decode_dest23(ddd, dd, w+1); 1493 b = get_src (sc); 1494 LOGIC_OP (dc, b, |); 1495 1496 /** 1011 ddd w dd10 1111 POP.size dest */ 1497 1498 prefix (0, 1, 0); 1499 dc = decode_dest23 (ddd, dd, w+1); 1500 if (w) 1501 a = mem_get_hi (get_reg (sp)); 1502 else 1503 a = mem_get_qi (get_reg (sp)); 1504 put_reg (sp, get_reg (sp) + 2); 1505 tprintf("pop%s: %x\n", w ? "hi" : "qi", a); 1506 put_dest (dc, a); 1507 1508 /** 1101 0011 1010 1dst POPC dest */ 1509 1510 prefix (0, 0, 0); 1511 dc = decode_cr_b (dst, CR_B_DCT0); 1512 a = mem_get_hi (get_reg (sp)); 1513 put_reg (sp, get_reg (sp) + 2); 1514 tprintf("pophi: %x\n", a); 1515 put_dest (dc, a); 1516 1517 /** 1101 0011 0010 1dst POPC dest */ 1518 1519 prefix (0, 0, 0); 1520 dc = decode_cr_b (dst, CR_B_INTB); 1521 a = mem_get_si (get_reg (sp)); 1522 put_reg (sp, get_reg (sp) + 4); 1523 tprintf("popsi: %x\n", a); 1524 put_dest (dc, a); 1525 1526 /** 1000 1110 POPM dest */ 1527 1528 static int map[] = { r0, r1, r2, r3, a0, a1, sb, fb }; 1529 prefix (0, 0, 0); 1530 imm = IMM(1); 1531 tprintf("popm: %x\n", imm); 1532 for (a=0; a<4; a++) 1533 if (imm & (1<<a)) 1534 { 1535 v = mem_get_hi (get_reg (sp)); 1536 put_reg (map[a], v); 1537 put_reg (sp, get_reg (sp) + 2); 1538 } 1539 for (; a<8; a++) 1540 if (imm & (1<<a)) 1541 { 1542 v = mem_get_si (get_reg (sp)); 1543 put_reg (map[a], v); 1544 put_reg (sp, get_reg (sp) + 4); 1545 } 1546 1547 /** 1010 111w PUSH.size #IMM */ 1548 1549 prefix (0, 0, 0); 1550 imm = IMM(w+1); 1551 tprintf("push%s: %x\n", w ? "hi" : "qi", imm); 1552 int a = get_reg (sp) - 2; 1553 if (w) 1554 mem_put_hi (a, imm); 1555 else 1556 mem_put_qi (a, imm); 1557 put_reg (sp, a); 1558 1559 /** 1100 sss w ss00 1110 PUSH.size src */ 1560 1561 prefix (0, 1, 0); 1562 sc = decode_dest23 (sss, ss, w+1); 1563 a = get_src (sc); 1564 put_reg (sp, get_reg (sp) - 2); 1565 if (w) 1566 mem_put_hi (get_reg (sp), a); 1567 else 1568 mem_put_qi (get_reg (sp), a); 1569 tprintf("push%s: %x\n", w ? "hi" : "qi", a); 1570 1571 /** 1011 0110 0101 0011 PUSH.L #IMM32 */ 1572 1573 imm = IMM(4); 1574 put_reg (sp, get_reg (sp) - 4); 1575 mem_put_si (get_reg (sp), imm); 1576 1577 /** 1010 sss0 ss00 0001 PUSH.L src */ 1578 1579 prefix (0, 1, 0); 1580 sc = decode_dest23 (sss, ss, 4); 1581 a = get_src (sc); 1582 put_reg (sp, get_reg (sp) - 4); 1583 mem_put_si (get_reg (sp), a); 1584 1585 /** 1011 0sa0 ss00 0001 PUSHA src */ 1586 1587 prefix (0, 0, 0); 1588 sc = decode_dest23 (sa, ss, 1); 1589 put_reg (sp, get_reg (sp) - 4); 1590 mem_put_hi (get_reg (sp), sc.u.addr); 1591 tprintf("pushsi: %x\n", sc.u.addr); 1592 1593 /** 1101 0001 1010 1src PUSHC src */ 1594 1595 prefix (0, 0, 0); 1596 sc = decode_cr_b (src, CR_B_DCT0); 1597 a = get_src (sc); 1598 put_reg (sp, get_reg (sp) - 2); 1599 mem_put_hi (get_reg (sp), a); 1600 tprintf("pushhi: %x\n", a); 1601 1602 /** 1101 0001 0010 1src PUSHC src */ 1603 1604 prefix (0, 0, 0); 1605 sc = decode_cr_b (src, CR_B_INTB); 1606 a = get_src (sc); 1607 put_reg (sp, get_reg (sp) - 4); 1608 mem_put_si (get_reg (sp), a); 1609 tprintf("pushsi: %x\n", a); 1610 1611 /** 1000 1111 PUSHM src */ 1612 1613 static int map[] = { fb, sb, a1, a0, r3, r2, r1, r0 }; 1614 imm = IMM(1); 1615 tprintf("pushm: %x\n", imm); 1616 for (a=0; a<4; a++) 1617 if (imm & (1<<a)) 1618 { 1619 put_reg (sp, get_reg (sp) - 4); 1620 v = get_reg (map[a]); 1621 mem_put_si (get_reg (sp), v); 1622 } 1623 for (; a<8; a++) 1624 if (imm & (1<<a)) 1625 { 1626 put_reg (sp, get_reg (sp) - 2); 1627 v = get_reg (map[a]); 1628 mem_put_hi (get_reg (sp), v); 1629 } 1630 1631 /** 1001 1110 REIT */ 1632 1633 a = get_reg (sp); 1634 put_reg (pc, mem_get_si (a)); 1635 a += 4; 1636 put_reg (flags, mem_get_hi (a)); 1637 a += 2; 1638 put_reg (sp, a); 1639 1640 /** 1011 1000 010w 0011 RMPA.size */ 1641 1642 int count = get_reg (r3); 1643 int list1 = get_reg (a0); 1644 int list2 = get_reg (a1); 1645 long long sum = get_reg_ll (r3r1r2r0) & 0xffffff; 1646 1647 while (count) 1648 { 1649 if (w) 1650 { 1651 a = sign_ext (mem_get_hi (list1), 16); 1652 b = sign_ext (mem_get_hi (list2), 16); 1653 } 1654 else 1655 { 1656 a = sign_ext (mem_get_qi (list1), 8); 1657 b = sign_ext (mem_get_qi (list2), 8); 1658 } 1659 tprintf("%lld + %d * %d = ", sum, a, b); 1660 sum += a * b; 1661 tprintf("%lld\n", sum); 1662 list1 += w ? 2 : 1; 1663 list2 += w ? 2 : 1; 1664 count --; 1665 } 1666 put_reg (r3, count); 1667 put_reg (a0, list1); 1668 put_reg (a1, list2); 1669 put_reg (r2r0, (int)(sum & 0xffffffffU)); 1670 put_reg (r1, (int)(sum >> 32)); 1671 1672 /** 1011 ddd w dd10 1110 ROLC.size dest */ 1673 1674 prefix (0, 1, 0); 1675 dc = decode_dest23 (ddd, dd, w+1); 1676 rot_op (dc, 1, 1); 1677 1678 /** 1010 ddd w dd10 1110 RORC.size dest */ 1679 1680 prefix (0, 1, 0); 1681 dc = decode_dest23 (ddd, dd, w+1); 1682 rot_op (dc, 1, -1); 1683 1684 /** 1110 ddd w dd10 immm ROT.size #IMM, dest */ 1685 1686 prefix (0, 1, 0); 1687 dc = decode_dest23 (ddd, dd, w+1); 1688 rot_op (dc, IMM4(), -1); 1689 1690 /** 1010 ddd w dd11 1111 ROT.size R1H,dest */ 1691 1692 prefix (0, 1, 0); 1693 dc = decode_dest23 (ddd, dd, w+1); 1694 a = sign_ext (get_reg (r1h), 8); 1695 rot_op (dc, a, -1); 1696 1697 /** 1101 1111 RTS */ 1698 1699 put_reg (pc, mem_get_si (get_reg (sp))); 1700 put_reg (sp, get_reg (sp) + 4); 1701 1702 /** 0000 0001 1001 ddd w dd10 1110 SBB.size #IMM, dest */ 1703 1704 prefix (0, 0, 0); 1705 dc = decode_dest23 (ddd, dd, w+1); 1706 imm = IMM (w+1); 1707 MATH_OP (dc, imm, !carry, -); 1708 1709 /** 0000 0001 1sss ddd w dd ss 0110 SBB.size src,dest */ 1710 1711 prefix (0, 0, 0); 1712 sc = decode_src23 (sss, ss, w+1); 1713 dc = decode_dest23 (ddd, dd, w+1); 1714 MATH_OP (dc, get_src (sc), !carry, -); 1715 1716 /** 1101 ddd1 dd11 cond SCcond dest */ 1717 1718 prefix (0, 1, 0); 1719 dc = decode_dest23 (ddd, dd, 2); 1720 if (condition_true (cond)) 1721 put_dest (dc, 1); 1722 else 1723 put_dest (dc, 0); 1724 1725 /** 1011 1000 110w 0011 SCMPU.size */ 1726 1727 ta0 = get_reg (a0); 1728 ta1 = get_reg (a1); 1729 1730 for (;;) 1731 { 1732 t0 = mem_get_qi (ta0); 1733 t2 = mem_get_qi (ta1); 1734 if (w) 1735 { 1736 t1 = mem_get_qi (ta0 + 1); 1737 t3 = mem_get_qi (ta1 + 1); 1738 } 1739 dif = t0 - t2; 1740 if (dif == 0 && t0 != 0 && w) 1741 dif = t1 - t3; 1742 set_oszc (dif, 1, dif > 0); 1743 1744 ta0 += w ? 2 : 1; 1745 ta1 += w ? 2 : 1; 1746 1747 if (t0 == 0 || t0 != t2) 1748 break; 1749 if (w && (t1 == 0 || t1 != t3)) 1750 break; 1751 } 1752 1753 /** 1111 ddd w dd00 immm SHA.size #IMM,dest */ 1754 1755 prefix (0, 1, 0); 1756 dc = decode_dest23 (ddd, dd, w+1); 1757 shift_op (dc, 1, IMM4(), 1); 1758 1759 /** 1010 ddd0 dd10 0001 SHA.L #IMM,dest */ 1760 1761 prefix (0, 1, 0); 1762 dc = decode_dest23 (ddd, dd, 4); 1763 imm = sign_ext (IMM(1), 8); 1764 shift_op (dc, 1, imm, 1); 1765 1766 /** 1011 ddd w dd11 1110 SHA.size R1H,dest */ 1767 1768 prefix (0, 1, 0); 1769 dc = decode_dest23 (ddd, dd, w+1); 1770 a = sign_ext (get_reg (r1h), 8); 1771 shift_op (dc, 1, a, 1); 1772 1773 /** 1100 ddd0 dd01 0001 SHA.L R1H,dest */ 1774 1775 prefix (0, 1, 0); 1776 dc = decode_dest23 (ddd, dd, 4); 1777 a = sign_ext (get_reg (r1h), 8); 1778 shift_op (dc, 1, a, 1); 1779 1780 /** 1100 ddd0 dd10 0001 SHANC.L #IMM,dest */ 1781 1782 M32C_ONLY(); 1783 prefix (0, 1, 0); 1784 dc = decode_dest23 (ddd, dd, 4); 1785 imm = sign_ext (IMM(1), 8); 1786 shift_op (dc, 1, imm, 0); 1787 1788 /** 1110 ddd w dd00 immm SHL.size #IMM, dest */ 1789 1790 prefix (0, 1, 0); 1791 dc = decode_dest23 (ddd, dd, w+1); 1792 shift_op (dc, 0, IMM4(), 1); 1793 1794 /** 1001 ddd0 dd10 0001 SHL.L #IMM, dest */ 1795 1796 prefix (0, 1, 0); 1797 dc = decode_dest23 (ddd, dd, 4); 1798 imm = sign_ext (IMM(1), 8); 1799 shift_op (dc, 0, imm, 1); 1800 1801 /** 1010 ddd w dd11 1110 SHL.size R1H,dest */ 1802 1803 prefix (0, 1, 0); 1804 dc = decode_dest23 (ddd, dd, w+1); 1805 a = sign_ext (get_reg (r1h), 8); 1806 shift_op (dc, 0, a, 1); 1807 1808 /** 1100 ddd0 dd00 0001 SHL.L R1H,dest */ 1809 1810 prefix (0, 1, 0); 1811 dc = decode_dest23 (ddd, dd, 4); 1812 a = sign_ext (get_reg (r1h), 8); 1813 shift_op (dc, 0, a, 1); 1814 1815 /** 1000 ddd0 dd10 0001 SHLNC.L #IMM,dest */ 1816 1817 M32C_ONLY(); 1818 prefix (0, 1, 0); 1819 dc = decode_dest23 (ddd, dd, 4); 1820 imm = sign_ext (IMM(1), 8); 1821 shift_op (dc, 0, imm, 0); 1822 1823 /** 1011 0010 100w 0011 SIN.size */ 1824 1825 v = get_reg (a0); 1826 a = get_reg (a1); 1827 b = get_reg (r3); 1828 if (b) for (;b;) 1829 { 1830 if (w) 1831 mem_put_hi(a, mem_get_hi (v)); 1832 else 1833 mem_put_qi(a, mem_get_qi (v)); 1834 a += w ? 2 : 1; 1835 b --; 1836 } 1837 put_reg (a0, v); 1838 put_reg (a1, a); 1839 put_reg (r3, b); 1840 1841 /** 1011 0110 100w 0011 SMOVB.size */ 1842 1843 v = get_reg (a0); 1844 a = get_reg (a1); 1845 b = get_reg (r3); 1846 if (b) for (;b;) 1847 { 1848 if (w) 1849 mem_put_hi(a, mem_get_hi (v)); 1850 else 1851 mem_put_qi(a, mem_get_qi (v)); 1852 v -= w ? 2 : 1; 1853 a -= w ? 2 : 1; 1854 b --; 1855 } 1856 put_reg (a0, v); 1857 put_reg (a1, a); 1858 put_reg (r3, b); 1859 1860 /** 1011 0000 100w 0011 SMOVF.size */ 1861 1862 v = get_reg (a0); 1863 a = get_reg (a1); 1864 b = get_reg (r3); 1865 if (b) for (;b;) 1866 { 1867 if (w) 1868 mem_put_hi(a, mem_get_hi (v)); 1869 else 1870 mem_put_qi(a, mem_get_qi (v)); 1871 v += w ? 2 : 1; 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 1000 100w 0011 SMOVU.size */ 1880 1881 v = get_reg (a0); 1882 a = get_reg (a1); 1883 do 1884 { 1885 if (w) 1886 mem_put_hi(a, (t0 = mem_get_hi (v))); 1887 else 1888 mem_put_qi(a, (t0 = mem_get_qi (v))); 1889 v += w ? 2 : 1; 1890 a += w ? 2 : 1; 1891 if (t0 == 0 1892 || (w && ((t0 & 0xff) == 0 || (t0 & 0xff00) == 0))) 1893 break; 1894 } while (1); 1895 put_reg (a0, v); 1896 put_reg (a1, a); 1897 1898 /** 1011 0100 100w 0011 SOUT.size */ 1899 1900 v = get_reg (a0); 1901 a = get_reg (a1); 1902 b = get_reg (r3); 1903 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 b --; 1911 } 1912 put_reg (a0, v); 1913 put_reg (a1, a); 1914 put_reg (r3, b); 1915 1916 /** 1011 1000 000w 0011 SSTR.size */ 1917 1918 a = get_reg (a1); 1919 b = get_reg (r3); 1920 for (;b;) 1921 { 1922 if (w) 1923 mem_put_hi(a, r0); 1924 else 1925 mem_put_qi(a, r0 & 0xff); 1926 a += w ? 2 : 1; 1927 b --; 1928 } 1929 put_reg (a1, a); 1930 put_reg (r3, b); 1931 1932 /** 0000 0001 1101 ddd1 dd01 0src STC src,dest */ 1933 1934 prefix (0, 0, 0); 1935 dc = decode_dest23 (ddd, dd, 4); 1936 sc = decode_cr_b (src, CR_B_DMA0); 1937 a = get_src (sc); 1938 put_dest (dc, a); 1939 1940 /** 0000 0001 1101 ddd1 dd01 1src STC src,dest */ 1941 1942 prefix (0, 0, 0); 1943 dc = decode_dest23 (ddd, dd, 2); 1944 sc = decode_cr_b (src, CR_B_DCT0); 1945 a = get_src (sc); 1946 put_dest (dc, a); 1947 1948 /** 1101 ddd1 dd01 0src STC src,dest */ 1949 1950 prefix (0, 0, 0); 1951 dc = decode_dest23 (ddd, dd, 4); 1952 sc = decode_cr_b (src, CR_B_INTB); 1953 a = get_src (sc); 1954 put_dest (dc, a); 1955 1956 /** 1011 0110 1101 0011 STCX abs16,abs24 */ 1957 1958 NOTYET(); 1959 1960 /** 1001 ddd w dd01 1111 STNZ.size #IMM,dest */ 1961 1962 prefix (0, 1, 0); 1963 dc = decode_dest23 (ddd, dd, w+1); 1964 imm = IMM(w+1); 1965 if (! FLAG_Z) 1966 put_dest (dc, imm); 1967 1968 /** 1001 ddd w dd00 1111 STZ.size #IMM,dest */ 1969 1970 prefix (0, 1, 0); 1971 dc = decode_dest23 (ddd, dd, w+1); 1972 imm = IMM(w+1); 1973 if (FLAG_Z) 1974 put_dest (dc, imm); 1975 1976 /** 1001 ddd w dd11 1111 STZX.size #IMM1,#IMM2,dest */ 1977 1978 prefix (0, 1, 0); 1979 dc = decode_dest23 (ddd, dd, w+1); 1980 a = IMM(w+1); 1981 b = IMM(w+1); 1982 if (FLAG_Z) 1983 put_dest (dc, a); 1984 else 1985 put_dest (dc, b); 1986 1987 /** 1000 ddd w dd11 1110 SUB.size:G #IMM,dest */ 1988 1989 prefix (0, 1, 0); 1990 dc = decode_dest23(ddd, dd, w+1); 1991 imm = IMM(w+1); 1992 MATH_OP (dc, imm, 0, -); 1993 1994 /** 1001 ddd0 dd11 0001 SUB.L:G #IMM,dest */ 1995 1996 prefix (0, 1, 0); 1997 dc = decode_dest23(ddd, dd, 4); 1998 imm = IMM(4); 1999 MATH_OP (dc, imm, 0, -); 2000 2001 /** 00dd 111w SUB.size:S #IMM,dest */ 2002 2003 prefix (0, 1, 0); 2004 dc = decode_dest2(dd, w+1); 2005 imm = IMM (w+1); 2006 MATH_OP (dc, imm, 0, -); 2007 2008 /** 1sss ddd w dd ss 1010 SUB.size:G src,dest */ 2009 2010 prefix (1, 1, 0); 2011 sc = decode_src23(sss, ss, w+1); 2012 dc = decode_dest23(ddd, dd, w+1); 2013 b = get_src (sc); 2014 MATH_OP (dc, b, 0, -); 2015 2016 /** 1sss ddd1 dd ss 0000 SUB.L:G src,dest */ 2017 2018 prefix (1, 1, 0); 2019 sc = decode_src23(sss, ss, 4); 2020 dc = decode_dest23(ddd, dd, 4); 2021 b = get_src (sc); 2022 MATH_OP (dc, b, 0, -); 2023 2024 /** 1001 ddd0 dd01 0001 SUBX #IMM,dest */ 2025 2026 prefix (0, 1, 0); 2027 dc = decode_dest23(ddd, dd, 4); 2028 imm = sign_ext (IMM(1), 8); 2029 MATH_OP (dc, imm, 0, -); 2030 2031 /** 1sss ddd0 dd ss 0000 SUBX src,dest */ 2032 2033 prefix (1, 1, 0); 2034 sc = decode_src23(sss, ss, 1); 2035 dc = decode_dest23(ddd, dd, 4); 2036 b = sign_ext (get_src (sc), 8); 2037 MATH_OP (dc, b, 0, -); 2038 2039 /** 1001 ddd w dd11 1110 TST.size:G #IMM,dest */ 2040 2041 prefix (0, 0, 0); 2042 dc = decode_dest23 (ddd, dd, w+1); 2043 imm = IMM(w+1); 2044 a = get_src (dc); 2045 v = a & imm; 2046 set_sz (v, w+1); 2047 2048 /** 00dd 110w TST.size:S #IMM,dest */ 2049 2050 prefix (0, 0, 0); 2051 dc = decode_dest2 (dd, w+1); 2052 imm = IMM(w+1); 2053 a = get_src (dc); 2054 v = a & imm; 2055 set_sz (v, w+1); 2056 2057 /** 0000 0001 1sss ddd w dd ss 1001 TST.size:G src,dest */ 2058 2059 prefix (0, 0, 0); 2060 sc = decode_src23 (sss, ss, w+1); 2061 dc = decode_dest23 (ddd, dd, w+1); 2062 b = get_src (sc); 2063 a = get_src (dc); 2064 v = a & b; 2065 set_sz (v, w+1); 2066 2067 /** 1111 1111 UND */ 2068 2069 trigger_fixed_interrupt (0xffffdc); 2070 2071 /** 1011 0010 0000 0011 WAIT */ 2072 2073 ; 2074 2075 /** 1101 ddd w dd00 1src XCHG.size src,dest */ 2076 2077 dc = decode_dest23 (ddd, dd, w+1); 2078 sc = decode_src3 (src, w+1); 2079 a = get_src (dc); 2080 b = get_src (sc); 2081 put_dest (dc, b); 2082 put_dest (sc, a); 2083 2084 /** 1001 ddd w dd00 1110 XOR.size #IMM,dest */ 2085 2086 prefix (0, 1, 0); 2087 dc = decode_dest23(ddd, dd, w+1); 2088 imm = IMM(w+1); 2089 LOGIC_OP (dc, imm, ^); 2090 2091 /** 1sss ddd w dd ss 1001 XOR.size src,dest */ 2092 2093 prefix (1, 1, 0); 2094 sc = decode_src23(sss, ss, w+1); 2095 dc = decode_dest23(ddd, dd, w+1); 2096 b = get_src (sc); 2097 LOGIC_OP (dc, b, ^); 2098 2099/** */ 2100 2101 return step_result; 2102} 2103