1/* r8c.opc --- semantics for r8c 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 M16C_ONLY() /* FIXME: add something here */ 50 51#define GETBYTE() (op[opi++] = getbyte()) 52 53#define UNSUPPORTED() unsupported("unsupported", orig_pc) 54#define NOTYET() unsupported("unimplemented", orig_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 bw) 82{ 83 int rv = getbyte (); 84 if (bw) 85 rv = rv + 256 * getbyte(); 86 if (bw == 2) 87 rv = rv + 65536 * getbyte(); 88 return rv; 89} 90 91#define IMM4() (immm >= 8 ? 7 - immm : immm + 1) 92 93#define UNARY_SOP \ 94 dc = decode_srcdest4 (dest, w); \ 95 v = sign_ext (get_src (dc), w?16:8); 96 97#define UNARY_UOP \ 98 dc = decode_srcdest4 (dest, w); \ 99 v = get_src (dc); 100 101#define BINARY_SOP \ 102 sc = decode_srcdest4 (srcx, w); \ 103 dc = decode_srcdest4 (dest, w); \ 104 a = sign_ext (get_src (sc), w?16:8); \ 105 b = sign_ext (get_src (dc), w?16:8); 106 107#define BINARY_UOP \ 108 sc = decode_srcdest4 (srcx, w); \ 109 dc = decode_srcdest4 (dest, w); \ 110 a = get_src (sc); \ 111 b = get_src (dc); 112 113#define carry (FLAG_C ? 1 : 0) 114 115static void 116cmp (int d, int s, int w) 117{ 118 int a, b, f=0; 119 int mask = w ? 0xffff : 0xff; 120 a = d - s; 121 b = sign_ext (d, w?16:8) - sign_ext (s, w?16:8); 122 tprintf ("cmp: %x - %x = %08x, %x - %x = %d\n", 123 d, s, a, 124 sign_ext(d,w?16:8), sign_ext(s,w?16:8), b); 125 126 if (b == 0) 127 f |= FLAGBIT_Z; 128 if (b & (w ? 0x8000 : 0x80)) 129 f |= FLAGBIT_S; 130 if ((d & mask) >= (s & mask)) 131 f |= FLAGBIT_C; 132 if (b < (w ? -32768 : -128) || b > (w ? 32767 : 127)) 133 f |= FLAGBIT_O; 134 135 set_flags (FLAGBIT_Z | FLAGBIT_S | FLAGBIT_O | FLAGBIT_C, f); 136} 137 138static void 139div_op (int s, int u, int x, int w) 140{ 141 srcdest sc; 142 int v, a, b; 143 144 if (s == -1) 145 s = IMM(w); 146 else 147 { 148 sc = decode_srcdest4 (s, w); 149 s = get_src (sc); 150 } 151 152 v = get_reg (w ? r2r0 : r0); 153 154 if (!u) 155 { 156 s = sign_ext (s, w ? 16 : 8); 157 v = sign_ext (v, w ? 16 : 8); 158 } 159 160 if (s == 0) 161 { 162 set_flags (FLAGBIT_O, FLAGBIT_O); 163 return; 164 } 165 166 if (u) 167 { 168 a = (unsigned int)v / (unsigned int)s; 169 b = (unsigned int)v % (unsigned int)s; 170 } 171 else 172 { 173 a = v / s; 174 b = v % s; 175 } 176 if (x) 177 { 178 if ((s > 0 && b < 0) 179 || (s < 0 && b > 0)) 180 { 181 a --; 182 b += s; 183 } 184 } 185 tprintf ("%d / %d = %d rem %d\n", v, s, a, b); 186 if ((!u && (a > (w ? 32767 : 127) 187 || a < (w ? -32768 : -129))) 188 || (u && (a > (w ? 65536 : 255)))) 189 set_flags (FLAGBIT_O, FLAGBIT_O); 190 else 191 set_flags (FLAGBIT_O, 0); 192 193 put_reg (w ? r0 : r0l, a); 194 put_reg (w ? r2 : r0h, b); 195} 196 197static void 198rot_op (srcdest sd, int rotc, int count) 199{ 200 int mask = (sd.bytes == 2) ? 0xffff : 0xff; 201 int msb = (sd.bytes == 2) ? 0x8000 : 0x80; 202 int v = get_src (sd); 203 int c = carry, ct; 204 205 tprintf("%s %x by %d\n", rotc ? "rotc" : "rot", v, count); 206 tprintf (": %s %d\n", bits(v, 8*sd.bytes), c); 207 while (count > 0) 208 { 209 ct = (v & msb) ? 1 : 0; 210 v <<= 1; 211 v |= rotc ? c : ct; 212 v &= mask; 213 c = ct; 214 tprintf (": %s %d\n", bits(v, 8*sd.bytes), c); 215 count --; 216 } 217 while (count < 0) 218 { 219 ct = v & 1; 220 v >>= 1; 221 v |= (rotc ? c : ct) * msb; 222 c = ct; 223 tprintf (": %s %d\n", bits(v, 8*sd.bytes), c); 224 count ++; 225 } 226 put_dest (sd, v); 227 set_szc (v, sd.bytes, c); 228} 229 230static void 231shift_op (srcdest sd, int arith, int count) 232{ 233 int mask = (sd.bytes == 2) ? 0xffff : 0xff; 234 int msb = (sd.bytes == 2) ? 0x8000 : 0x80; 235 int v = get_src (sd); 236 int c = 0; 237 238 if (sd.bytes == 4) 239 { 240 mask = 0xffffffffU; 241 msb = 0x80000000U; 242 if (count > 16 || count < -16) 243 { 244 fprintf(stderr, "Error: SI shift of %d undefined\n", count); 245 exit(1); 246 } 247 if (count > 16) 248 count = (count - 1) % 16 + 1; 249 if (count < -16) 250 count = -((-count - 1) % 16 + 1); 251 } 252 253 tprintf("%s %x by %d\n", arith ? "sha" : "shl", v, count); 254 tprintf (": %s %d\n", bits(v, 8*sd.bytes), c); 255 while (count > 0) 256 { 257 c = (v & msb) ? 1 : 0; 258 v <<= 1; 259 v &= mask; 260 tprintf (": %s %d\n", bits(v, 8*sd.bytes), c); 261 count --; 262 } 263 while (count < 0) 264 { 265 c = v & 1; 266 if (arith) 267 v = (v & msb) | (v >> 1); 268 else 269 v = (v >> 1) & (msb - 1); 270 tprintf (": %s %d\n", bits(v, 8*sd.bytes), c); 271 count ++; 272 } 273 put_dest (sd, v); 274 set_szc (v, sd.bytes, c); 275} 276 277#define MATH_OP(dc,s,c,op,carryrel) \ 278 a = get_src(dc); \ 279 b = s & b2mask[dc.bytes]; \ 280 v2 = a op b op c; \ 281 tprintf("0x%x " #op " 0x%x " #op " 0x%x = 0x%x\n", a, b, c, v2); \ 282 a = sign_ext (a, dc.bytes * 8); \ 283 b = sign_ext (s, dc.bytes * 8); \ 284 v = a op b op c; \ 285 tprintf("%d " #op " %d " #op " %d = %d\n", a, b, c, v); \ 286 set_oszc (v, dc.bytes, v2 carryrel); \ 287 put_dest (dc, v2); 288 289#define BIT_OP(field,expr) \ 290 dc = decode_bit (field); \ 291 b = get_bit (dc); \ 292 v = expr; \ 293 tprintf ("b=%d, carry=%d, %s = %d\n", b, carry, #expr, v); \ 294 put_bit (dc, v); 295 296#define BIT_OPC(field,expr) \ 297 dc = decode_bit (field); \ 298 b = get_bit (dc); \ 299 v = expr; \ 300 tprintf ("b=%d, carry=%d, %s = %d\n", b, carry, #expr, v); \ 301 set_c (v); 302 303/* The "BMcnd dest" opcode uses a different encoding for the */ 304/* condition than other opcodes. */ 305static int bmcnd_cond_map[] = { 306 0, 1, 2, 3, 8, 9, 10, 11, 4, 5, 6, 7, 12, 13, 14, 15 307}; 308 309int 310decode_r8c (void) 311{ 312 unsigned char op[40]; 313 int opi = 0; 314 int v, v2, a, b; 315 int orig_pc = get_reg (pc); 316 srcdest sc, dc; 317 int imm; 318 319 step_result = M32C_MAKE_STEPPED (); 320 321 tprintf("trace: decode pc = %05x\n", orig_pc); 322 323 /** VARY dst 011 100 101 110 111 */ 324 325 /** 0111 011w 1111 dest ABS.size dest */ 326 327 UNARY_SOP; 328 a = v<0 ? -v : v; 329 tprintf("abs(%d) = %d\n", v, a); 330 set_osz(a, w+1); 331 put_dest (dc, a); 332 333 /** 0111 011w 0110 dest ADC.size #IMM,dest */ 334 335 dc = decode_srcdest4(dest, w); 336 imm = IMM(w); 337 MATH_OP (dc, imm, carry, +, > (w?0xffff:0xff)); 338 339 /** 1011 000w srcx dest ADC.size src,dest */ 340 341 sc = decode_srcdest4(srcx, w); 342 dc = decode_srcdest4(dest, w); 343 b = get_src (sc); 344 MATH_OP (dc, b, carry, +, > (w?0xffff:0xff)); 345 346 /** 0111 011w 1110 dest ADCF.size dest */ 347 348 dc = decode_srcdest4(dest, w); 349 MATH_OP (dc, 0, carry, +, > (w?0xffff:0xff)); 350 351 /** 0111 011w 0100 dest ADD.size:G #imm,dest */ 352 353 dc = decode_srcdest4(dest, w); 354 imm = IMM(w); 355 MATH_OP (dc, imm, 0, +, > (w?0xffff:0xff)); 356 357 /** 1100 100w immm dest ADD.size:Q #IMM,dest */ 358 359 dc = decode_srcdest4(dest, w); 360 imm = sign_ext (immm, 4); 361 MATH_OP (dc, imm, 0, +, > (w?0xffff:0xff)); 362 363 /** 1000 0dst ADD.B:S #IMM8,dst */ 364 365 imm = IMM(0); 366 dc = decode_dest3 (dst, 0); 367 MATH_OP (dc, imm, 0, +, > 0xff); 368 369 /** 1010 000w srcx dest ADD.size:G src,dest */ 370 371 sc = decode_srcdest4(srcx, w); 372 dc = decode_srcdest4(dest, w); 373 b = get_src (sc); 374 MATH_OP (dc, b, 0, +, > (w?0xffff:0xff)); 375 376 /** 0010 0d sr ADD.B:S src,R0L/R0H */ 377 378 sc = decode_src2 (sr, 0, d); 379 dc = decode_dest1 (d, 0); 380 b = get_src (sc); 381 MATH_OP (dc, b, 0, +, > 0xff); 382 383 /** 0111 110w 1110 1011 ADD.size:G #IMM,sp */ 384 385 dc = reg_sd (sp); 386 imm = sign_ext (IMM(w), w?16:8); 387 MATH_OP (dc, imm, 0, +, > 0xffff); 388 389 /** 0111 1101 1011 immm ADD.size:Q #IMM,sp */ 390 391 dc = reg_sd (sp); 392 imm = sign_ext (immm, 4); 393 MATH_OP (dc, imm, 0, +, > 0xffff); 394 395 /** 1111 100w immm dest ADJNZ.size #IMM,dest,label */ 396 397 UNARY_UOP; 398 imm = sign_ext(immm, 4); 399 tprintf("%x + %d = %x\n", v, imm, v+imm); 400 v += imm; 401 put_dest (dc, v); 402 a = sign_ext (IMM(0), 8); 403 if ((v & (w ? 0xffff : 0xff)) != 0) 404 { 405 tprintf("jmp: %x + 2 + %d = ", get_reg (pc), a); 406 put_reg (pc, orig_pc + 2 + a); 407 tprintf("%x\n", get_reg (pc)); 408 } 409 410 /** 0111 011w 0010 dest AND.size:G #IMM,dest */ 411 412 UNARY_UOP; 413 imm = IMM(w); 414 tprintf ("%x & %x = %x\n", v, imm, v & imm); 415 v &= imm; 416 set_sz (v, w+1); 417 put_dest (dc, v); 418 419 /** 1001 0dst AND.B:S #IMM8,dest */ 420 421 imm = IMM(0); 422 dc = decode_dest3 (dst, 0); 423 v = get_src (dc); 424 tprintf("%x & %x = %x\n", v, imm, v & imm); 425 v &= imm; 426 set_sz (v, 1); 427 put_dest (dc, v); 428 429 /** 1001 000w srcx dest AND.size:G src.dest */ 430 431 BINARY_UOP; 432 tprintf ("%x & %x = %x\n", a, b, a & b); 433 v = a & b; 434 set_sz (v, w+1); 435 put_dest (dc, v); 436 437 /** 0001 0d sr AND.B:S src,R0L/R0H */ 438 439 sc = decode_src2 (sr, 0, d); 440 dc = decode_dest1 (d, 0); 441 a = get_src (sc); 442 b = get_src (dc); 443 v = a & b; 444 tprintf("%x & %x = %x\n", a, b, v); 445 set_sz (v, 1); 446 put_dest (dc, v); 447 448 /** 0111 1110 0100 srcx BAND src */ 449 450 BIT_OPC (srcx, b & carry); 451 452 /** 0111 1110 1000 dest BCLR:G dest */ 453 454 dc = decode_bit (dest); 455 put_bit (dc, 0); 456 457 /** 0100 0bit BCLR:S bit,base:11[SB] */ 458 459 dc = decode_bit11 (bit); 460 put_bit (dc, 0); 461 462 /** 0111 1110 0010 dest BMcnd dest */ 463 464 dc = decode_bit (dest); 465 if (condition_true (bmcnd_cond_map [IMM (0) & 15])) 466 put_bit (dc, 1); 467 else 468 put_bit (dc, 0); 469 470 /** 0111 1101 1101 cond BMcnd C */ 471 472 if (condition_true (cond)) 473 set_c (1); 474 else 475 set_c (0); 476 477 /** 0111 1110 0101 srcx BNAND src */ 478 479 BIT_OPC (srcx, (!b) & carry); 480 481 /** 0111 1110 0111 srcx BNOR src */ 482 483 BIT_OPC (srcx, (!b) | carry); 484 485 /** 0111 1110 1010 dest BNOT:G dest */ 486 487 BIT_OP (dest, !b); 488 489 /** 0101 0bit BNOT:S bit,base:11[SB] */ 490 491 dc = decode_bit11 (bit); 492 put_bit (dc, !get_bit (dc)); 493 494 /** 0111 1110 0011 srcx BNTST src */ 495 496 dc = decode_bit (srcx); 497 b = get_bit (dc); 498 set_zc (!b, !b); 499 500 /** 0111 1110 1101 srcx BNXOR src */ 501 502 BIT_OPC (srcx, !b ^ carry); 503 504 /** 0111 1110 0110 srcx BOR src */ 505 506 BIT_OPC (srcx, b | carry); 507 508 /** 0000 0000 BRK */ 509 510 /* We report the break to our caller with the PC still pointing at the 511 breakpoint instruction. */ 512 put_reg (pc, orig_pc); 513 if (verbose) 514 printf("[break]\n"); 515 return M32C_MAKE_HIT_BREAK (); 516 517 /** 0111 1110 1001 dest BSET:G dest */ 518 519 dc = decode_bit (dest); 520 put_bit (dc, 1); 521 522 /** 0100 1bit BSET:S bit,base:11[SB] */ 523 524 dc = decode_bit11 (bit); 525 put_bit (dc, 1); 526 527 /** 0111 1110 1011 srcx BTST:G src */ 528 529 dc = decode_bit (srcx); 530 b = get_bit (dc); 531 set_zc (!b, b); 532 533 /** 0101 1bit BTST:S bit,base:11[SB] */ 534 535 dc = decode_bit11 (bit); 536 b = get_bit (dc); 537 set_zc (!b, b); 538 539 /** 0111 1110 0000 dest BTSTC dest */ 540 541 dc = decode_bit (dest); 542 b = get_bit (dc); 543 set_zc (!b, b); 544 put_bit (dc, 0); 545 546 /** 0111 1110 0001 dest BTSTS dest */ 547 548 dc = decode_bit (dest); 549 b = get_bit (dc); 550 set_zc (!b, b); 551 put_bit (dc, 1); 552 553 /** 0111 1110 1100 srcx BXOR src */ 554 555 BIT_OPC (srcx, b ^ carry); 556 557 /** 0111 011w 1000 dest CMP.size:G #IMM,dest */ 558 559 UNARY_UOP; 560 imm = IMM(w); 561 cmp (v, imm, w); 562 563 /** 1101 000w immm dest CMP.size:Q #IMM,dest */ 564 565 UNARY_UOP; 566 immm = sign_ext (immm, 4); 567 cmp (v, immm, w); 568 569 /** 1110 0dst CMP.B:S #IMM8,dest */ 570 571 imm = IMM(0); 572 dc = decode_dest3 (dst, 0); 573 v = get_src (dc); 574 cmp (v, imm, 0); 575 576 /** 1100 000w srcx dest CMP.size:G src,dest */ 577 578 BINARY_UOP; 579 cmp(b, a, w); 580 581 /** 0011 1d sr CMP.B:S src,R0L/R0H */ 582 583 sc = decode_src2 (sr, 0, d); 584 dc = decode_dest1 (d, 0); 585 a = get_src (sc); 586 b = get_src (dc); 587 cmp (b, a, 0); 588 589 /** 0111 110w 1110 i1c s DADC,DADD,DSBB,DSUB */ 590 591 /* w = width, i = immediate, c = carry, s = subtract */ 592 593 { 594 int src = i ? IMM(w) : get_reg (w ? r1 : r0h); 595 int dest = get_reg (w ? r0 : r0l); 596 int res; 597 598 src = bcd2int(src, w); 599 dest = bcd2int(dest, w); 600 601 tprintf("decimal: %d %s %d", dest, s?"-":"+", src); 602 if (c) 603 tprintf(" c=%d", carry); 604 605 if (!s) 606 { 607 res = dest + src; 608 if (c) 609 res += carry; 610 c = res > (w ? 9999 : 99); 611 } 612 else 613 { 614 res = dest - src; 615 if (c) 616 res -= (1-carry); 617 c = res >= 0; 618 if (res < 0) 619 res += w ? 10000 : 100; 620 } 621 622 res = int2bcd (res, w); 623 tprintf(" = %x\n", res); 624 625 set_szc (res, w+1, c); 626 627 put_reg (w ? r0 : r0l, res); 628 } 629 630 /** 1010 1dst DEC.B dest */ 631 632 dc = decode_dest3 (dst, 0); 633 v = get_src (dc); 634 tprintf("%x -- = %x\n", v, v-1); 635 v --; 636 set_sz (v, 1); 637 put_dest (dc, v); 638 639 /** 1111 d010 DEC.W dest */ 640 641 v = get_reg (d ? a1 : a0); 642 tprintf("%x -- = %x\n", v, v-1); 643 v --; 644 set_sz (v, 2); 645 put_reg (d ? a1 : a0, v); 646 647 /** 0111 110w 1110 0001 DIV.size #IMM */ 648 649 div_op (-1, 0, 0, w); 650 651 /** 0111 011w 1101 srcx DIV.size src */ 652 653 div_op (srcx, 0, 0, w); 654 655 /** 0111 110w 1110 0000 DIVU.size #IMM */ 656 657 div_op (-1, 1, 0, w); 658 659 /** 0111 011w 1100 srcx DIVU.size src */ 660 661 div_op (srcx, 1, 0, w); 662 663 /** 0111 110w 1110 0011 DIVX.size #IMM */ 664 665 div_op (-1, 0, 1, w); 666 667 /** 0111 011w 1001 srcx DIVX.size src */ 668 669 div_op (srcx, 0, 1, w); 670 671 /** 0111 1100 1111 0010 ENTER #IMM8 */ 672 673 imm = IMM(0); 674 put_reg (sp, get_reg (sp) - 2); 675 mem_put_hi (get_reg (sp), get_reg (fb)); 676 put_reg (fb, get_reg (sp)); 677 put_reg (sp, get_reg (sp) - imm); 678 679 /** 0111 1101 1111 0010 EXITD */ 680 681 put_reg (sp, get_reg (fb)); 682 put_reg (fb, mem_get_hi (get_reg (sp))); 683 put_reg (sp, get_reg (sp) + 2); 684 put_reg (pc, mem_get_psi (get_reg (sp))); 685 put_reg (sp, get_reg (sp) + 3); 686 687 /** 0111 1100 0110 dest EXTS.B dest */ 688 689 dc = decode_srcdest4 (dest, 0); 690 v = sign_ext (get_src (dc), 8); 691 dc = widen_sd (dc); 692 put_dest (dc, v); 693 set_sz (v, 1); 694 695 /** 0111 1100 1111 0011 EXTS.W R0 */ 696 697 v = sign_ext (get_reg (r0), 16); 698 put_reg (r2r0, v); 699 set_sz (v, 2); 700 701 /** 1110 1011 0flg 0101 FCLR dest */ 702 703 set_flags (1 << flg, 0); 704 705 /** 1110 1011 0flg 0100 FSET dest */ 706 707 set_flags (1 << flg, 1 << flg); 708 709 /** 1010 0dst INC.B dest */ 710 711 dc = decode_dest3 (dst, 0); 712 v = get_src (dc); 713 tprintf("%x ++ = %x\n", v, v+1); 714 v ++; 715 set_sz (v, 1); 716 put_dest (dc, v); 717 718 /** 1011 d010 INC.W dest */ 719 720 v = get_reg (d ? a1 : a0); 721 tprintf("%x ++ = %x\n", v, v+1); 722 v ++; 723 set_sz (v, 2); 724 put_reg (d ? a1 : a0, v); 725 726 /** 1110 1011 11vector INT #imm */ 727 728 trigger_based_interrupt (vector); 729 730 /** 1111 0110 INTO */ 731 732 if (FLAG_O) 733 trigger_fixed_interrupt (0xffe0); 734 735 /** 0110 1cnd Jcnd label */ 736 737 v = sign_ext (IMM(0), 8); 738 if (condition_true (cnd)) 739 put_reg (pc, orig_pc + 1 + v); 740 741 /** 0111 1101 1100 cond Jcnd label */ 742 743 v = sign_ext (IMM(0), 8); 744 if (condition_true (cond)) 745 put_reg (pc, orig_pc + 2 + v); 746 747 /** 0110 0dsp JMP.S label */ 748 749 put_reg (pc, orig_pc + 2 + dsp); 750 751 /** 1111 1110 JMP.B label */ 752 753 imm = sign_ext (IMM(0), 8); 754 if (imm == -1) 755 { 756 if (verbose) 757 printf("[jmp-to-self detected as exit]\n"); 758 return M32C_MAKE_HIT_BREAK (); 759 } 760 put_reg (pc, orig_pc + 1 + imm); 761 762 /** 1111 0100 JMP.W label */ 763 764 imm = sign_ext (IMM(1), 16); 765 put_reg (pc, orig_pc + 1 + imm); 766 767 /** 1111 1100 JMP.A label */ 768 769 imm = IMM(2); 770 put_reg (pc, imm); 771 772 /** 0111 1101 0010 srcx JMPI.W src */ 773 774 sc = decode_jumpdest (srcx, 1); 775 a = get_src (sc); 776 a = sign_ext (a, 16); 777 put_reg (pc, orig_pc + a); 778 779 /** 0111 1101 0000 srcx JMPI.A src */ 780 781 sc = decode_jumpdest (srcx, 0); 782 a = get_src (sc); 783 put_reg (pc, a); 784 785 /** 1110 1110 JMPS #IMM8 */ 786 787 M16C_ONLY(); 788 789 imm = IMM(0); 790 a = 0xf0000 + mem_get_hi (0xffffe - imm * 2); 791 put_reg (pc, a); 792 793 /** 1111 0101 JSR.W label */ 794 795 imm = sign_ext (IMM(1), 16); 796 put_reg (sp, get_reg (sp) - 3); 797 mem_put_psi (get_reg (sp), get_reg (pc)); 798 put_reg (pc, orig_pc + imm + 1); 799 800 /** 1111 1101 JSR.A label */ 801 802 imm = IMM(2); 803 put_reg (sp, get_reg (sp) - 3); 804 mem_put_psi (get_reg (sp), get_reg (pc)); 805 put_reg (pc, imm); 806 807 /** 0111 1101 0011 srcx JSRI.W src */ 808 809 sc = decode_jumpdest (srcx, 1); 810 a = get_src (sc); 811 a = sign_ext (a, 16); 812 813 put_reg (sp, get_reg (sp) - 3); 814 mem_put_psi (get_reg (sp), get_reg (pc)); 815 put_reg (pc, orig_pc + a); 816 817 /** 0111 1101 0001 srcx JSRI.A src */ 818 819 sc = decode_jumpdest (srcx, 0); 820 a = get_src (sc); 821 822 put_reg (sp, get_reg (sp) - 3); 823 mem_put_psi (get_reg (sp), get_reg (pc)); 824 put_reg (pc, a); 825 826 /** 1110 1111 JSRS #IMM8 */ 827 828 M16C_ONLY(); 829 830 imm = IMM(0); 831 a = 0xf0000 + mem_get_hi (0xffffe - imm * 2); 832 833 put_reg (sp, get_reg (sp) - 3); 834 mem_put_psi (get_reg (sp), get_reg (pc)); 835 put_reg (pc, a); 836 837 /** 1110 1011 0reg 0000 LDC #IMM16,dest */ 838 839 dc = decode_cr (reg); 840 imm = IMM(1); 841 put_dest (dc, imm); 842 843 /** 0111 1010 1reg srcx LDC src,dest */ 844 845 dc = decode_cr (reg); 846 sc = decode_srcdest4 (srcx,1); 847 put_dest (dc, get_src (sc)); 848 849 /** 0111 1100 1111 0000 LDCTX abs16,abs20 */ 850 851 NOTYET(); 852 853 /** 0111 010w 1000 dest LDE.size abs20,dest */ 854 855 dc = decode_srcdest4 (dest, w); 856 imm = IMM(2); 857 if (w) 858 v = mem_get_hi (imm); 859 else 860 v = mem_get_qi (imm); 861 put_dest (dc, v); 862 863 /** 0111 010w 1001 dest LDE.size dsp:20[a0], dest */ 864 865 dc = decode_srcdest4 (dest, w); 866 imm = IMM(2) + get_reg (a0); 867 if (w) 868 v = mem_get_hi (imm); 869 else 870 v = mem_get_qi (imm); 871 put_dest (dc, v); 872 873 /** 0111 010w 1010 dest LDE.size [a1a0],dest */ 874 875 dc = decode_srcdest4 (dest, w); 876 imm = get_reg (a1a0); 877 if (w) 878 v = mem_get_hi (imm); 879 else 880 v = mem_get_qi (imm); 881 put_dest (dc, v); 882 883 /** 0111 1101 1010 0imm LDIPL #IMM */ 884 885 set_flags (0x700, imm*0x100); 886 887 /** 0111 010w 1100 dest MOV.size:G #IMM,dest */ 888 889 dc = decode_srcdest4 (dest, w); 890 imm = IMM(w); 891 v = imm; 892 tprintf("%x = %x\n", v, v); 893 set_sz(v, w+1); 894 put_dest (dc, v); 895 896 /** 1101 100w immm dest MOV.size:Q #IMM,dest */ 897 898 dc = decode_srcdest4 (dest, w); 899 v = sign_ext (immm, 4); 900 tprintf ("%x = %x\n", v, v); 901 set_sz (v, w+1); 902 put_dest (dc, v); 903 904 /** 1100 0dst MOV.B:S #IMM8,dest */ 905 906 imm = IMM(0); 907 dc = decode_dest3 (dst, 0); 908 v = imm; 909 tprintf("%x = %x\n", v, v); 910 set_sz (v, 1); 911 put_dest (dc, v); 912 913 /** 1w10 d010 MOV.size:S #IMM,dest */ 914 915 /* Note that for w, 0=W and 1=B unlike the usual meaning. */ 916 v = IMM(1-w); 917 tprintf("%x = %x\n", v, v); 918 set_sz (v, 2-w); 919 put_reg (d ? a1 : a0, v); 920 921 /** 1011 0dst MOV.B:Z #0,dest */ 922 923 dc = decode_dest3 (dst, 0); 924 v = 0; 925 set_sz (v, 1); 926 put_dest (dc, v); 927 928 /** 0111 001w srcx dest MOV.size:G src,dest */ 929 930 sc = decode_srcdest4 (srcx, w); 931 dc = decode_srcdest4 (dest, w); 932 v = get_src (sc); 933 set_sz (v, w+1); 934 put_dest (dc, v); 935 936 /** 0011 0d sr MOV.B:S src,dest */ 937 938 sc = decode_src2 (sr, 0, d); 939 v = get_src (sc); 940 set_sz (v, 1); 941 put_reg (d ? a1 : a0, v); 942 943 /** 0000 0s ds MOV.B:S R0L/R0H,dest */ 944 945 if (ds == 0) 946 UNSUPPORTED(); 947 dc = decode_src2 (ds, 0, s); 948 v = get_reg (s ? r0h : r0l); 949 set_sz (v, 1); 950 put_dest (dc, v); 951 952 /** 0000 1d sr MOV.B:S src,R0L/R0H */ 953 954 sc = decode_src2 (sr, 0, d); 955 v = get_src (sc); 956 set_sz (v, 1); 957 put_reg (d ? r0h : r0l, v); 958 959 /** 0111 010w 1011 dest MOV.size:G dsp:8[SP], dest */ 960 961 dc = decode_srcdest4 (dest, w); 962 imm = IMM(0); 963 a = get_reg (sp) + sign_ext (imm, 8); 964 a &= addr_mask; 965 if (w) 966 v = mem_get_hi (a); 967 else 968 v = mem_get_qi (a); 969 set_sz (v, w+1); 970 put_dest (dc, v); 971 972 /** 0111 010w 0011 srcx MOV.size:G src, disp8[SP] */ 973 974 sc = decode_srcdest4 (srcx, w); 975 imm = IMM(0); 976 a = get_reg (sp) + sign_ext (imm, 8); 977 a &= addr_mask; 978 v = get_src (sc); 979 if (w) 980 mem_put_hi (a, v); 981 else 982 mem_put_qi (a, v); 983 set_sz (v, w+1); 984 985 /** 1110 1011 0reg 1src MOVA src,dest */ 986 987 { 988 static reg_id map[] = { r0, r1, r2, r3, a0, a1, 0, 0 }; 989 sc = decode_srcdest4 (8 + src, 0); 990 put_reg (map[reg], sc.u.addr); 991 } 992 993 /** 0111 1100 10hl dest MOVdir R0L,dest */ 994 995 if (dest == 0 || dest == 4 || dest == 5) 996 UNSUPPORTED(); 997 dc = decode_srcdest4 (dest, 0); 998 a = get_src (dc); 999 b = get_reg (r0l); 1000 switch (hl) 1001 { 1002 case 0: a = (a & 0xf0) | (b & 0x0f); break; 1003 case 1: a = (a & 0xf0) | ((b>>4) & 0x0f); break; 1004 case 2: a = (a & 0x0f) | ((b & 0x0f)<<4); break; 1005 case 3: a = (a & 0x0f) | (b & 0xf0); break; 1006 } 1007 put_dest (dc, a); 1008 1009 /** 0111 1100 00hl srcx MOVdir src,R0L */ 1010 1011 if (srcx == 0 || srcx == 4 || srcx == 5) 1012 UNSUPPORTED(); 1013 sc = decode_srcdest4 (srcx, 0); 1014 a = get_reg (r0l); 1015 b = get_src (sc); 1016 switch (hl) 1017 { 1018 case 0: a = (a & 0xf0) | (b & 0x0f); break; 1019 case 1: a = (a & 0xf0) | ((b>>4) & 0x0f); break; 1020 case 2: a = (a & 0x0f) | ((b & 0x0f)<<4); break; 1021 case 3: a = (a & 0x0f) | (b & 0xf0); break; 1022 } 1023 put_reg (r0l, a); 1024 1025 /** 0111 110w 0101 dest MUL.size #IMM,dest */ 1026 1027 UNARY_SOP; 1028 imm = sign_ext (IMM(w), w?16:8); 1029 tprintf("%d * %d = %d\n", v, imm, v*imm); 1030 v *= imm; 1031 dc = widen_sd (dc); 1032 put_dest (dc, v); 1033 1034 /** 0111 100w srcx dest MUL.size src,dest */ 1035 1036 BINARY_SOP; 1037 v = a * b; 1038 tprintf("%d * %d = %d\n", a, b, v); 1039 dc = widen_sd (dc); 1040 put_dest (dc, v); 1041 1042 /** 0111 110w 0100 dest MULU.size #IMM,dest */ 1043 1044 UNARY_UOP; 1045 imm = IMM(w); 1046 tprintf("%u * %u = %u\n", v, imm, v*imm); 1047 v *= imm; 1048 dc = widen_sd (dc); 1049 put_dest (dc, v); 1050 1051 /** 0111 000w srcx dest MULU.size src,dest */ 1052 1053 BINARY_UOP; 1054 v = a * b; 1055 tprintf("%u * %u = %u\n", a, b, v); 1056 dc = widen_sd (dc); 1057 put_dest (dc, v); 1058 1059 /** 0111 010w 0101 dest NEG.size dest */ 1060 1061 UNARY_SOP; 1062 tprintf("%d * -1 = %d\n", v, -v); 1063 v = -v; 1064 set_oszc (v, w+1, v == 0); 1065 put_dest (dc, v); 1066 1067 /** 0000 0100 NOP */ 1068 1069 tprintf("nop\n"); 1070 1071 /** 0111 010w 0111 dest NOT.size:G */ 1072 1073 UNARY_UOP; 1074 tprintf("~ %x = %x\n", v, ~v); 1075 v = ~v; 1076 set_sz (v, w+1); 1077 put_dest (dc, v); 1078 1079 /** 1011 1dst NOT.B:S dest */ 1080 1081 dc = decode_dest3 (dst, 0); 1082 v = get_src (dc); 1083 tprintf("~ %x = %x\n", v, ~v); 1084 v = ~v; 1085 set_sz (v, 1); 1086 put_dest (dc, v); 1087 1088 /** 0111 011w 0011 dest OR.size:G #IMM,dest */ 1089 1090 UNARY_UOP; 1091 imm = IMM(w); 1092 tprintf ("%x | %x = %x\n", v, imm, v | imm); 1093 v |= imm; 1094 set_sz (v, w+1); 1095 put_dest (dc, v); 1096 1097 /** 1001 1dst OR.B:S #IMM8,dest */ 1098 1099 imm = IMM(0); 1100 dc = decode_dest3 (dst, 0); 1101 v = get_src (dc); 1102 tprintf("%x | %x = %x\n", v, imm, v|imm); 1103 v |= imm; 1104 set_sz (v, 1); 1105 put_dest (dc, v); 1106 1107 /** 1001 100w srcx dest OR.size:G src,dest */ 1108 1109 BINARY_UOP; 1110 tprintf ("%x | %x = %x\n", a, b, a | b); 1111 v = a | b; 1112 set_sz (v, w+1); 1113 put_dest (dc, v); 1114 1115 /** 0001 1d sr OR.B:S src,R0L/R0H */ 1116 1117 sc = decode_src2 (sr, 0, d); 1118 dc = decode_dest1 (d, 0); 1119 a = get_src (sc); 1120 b = get_src (dc); 1121 v = a | b; 1122 tprintf("%x | %x = %x\n", a, b, v); 1123 set_sz (v, 1); 1124 put_dest (dc, v); 1125 1126 /** 0111 010w 1101 dest POP.size:G dest */ 1127 1128 dc = decode_srcdest4 (dest, w); 1129 if (w) 1130 { 1131 v = mem_get_hi (get_reg (sp)); 1132 put_reg (sp, get_reg (sp) + 2); 1133 tprintf("pophi: %x\n", v); 1134 } 1135 else 1136 { 1137 v = mem_get_qi (get_reg (sp)); 1138 put_reg (sp, get_reg (sp) + 1); 1139 tprintf("popqi: %x\n", v); 1140 } 1141 put_dest (dc, v); 1142 1143 /** 1001 d010 POP.B:S dest */ 1144 1145 v = mem_get_qi (get_reg (sp)); 1146 put_reg (d ? r0h : r0l, v); 1147 put_reg (sp, get_reg (sp) + 1); 1148 tprintf("popqi: %x\n", v); 1149 1150 /** 1101 d010 POP.W:S dest */ 1151 1152 v = mem_get_hi (get_reg (sp)); 1153 put_reg (d ? a1 : a0, v); 1154 put_reg (sp, get_reg (sp) + 2); 1155 tprintf("pophi: %x\n", v); 1156 1157 /** 1110 1011 0reg 0011 POPC dest */ 1158 1159 dc = decode_cr (reg); 1160 v = mem_get_hi (get_reg (sp)); 1161 put_dest (dc, v); 1162 put_reg (sp, get_reg (sp) + 2); 1163 tprintf("popc: %x\n", v); 1164 1165 /** 1110 1101 POPM dest */ 1166 1167 { 1168 static int map[] = { r0, r1, r2, r3, a0, a1, sb, fb }; 1169 imm = IMM(0); 1170 tprintf("popm: %x\n", imm); 1171 for (a=0; a<8; a++) 1172 if (imm & (1<<a)) 1173 { 1174 v = mem_get_hi (get_reg (sp)); 1175 put_reg (map[a], v); 1176 put_reg (sp, get_reg (sp) + 2); 1177 } 1178 } 1179 1180 /** 0111 110w 1110 0010 PUSH.size:G #IMM */ 1181 1182 imm = IMM(w); 1183 if (w) 1184 { 1185 put_reg (sp, get_reg (sp) - 2); 1186 mem_put_hi (get_reg (sp), imm); 1187 tprintf("pushhi %04x\n", imm); 1188 } 1189 else 1190 { 1191 put_reg (sp, get_reg (sp) - 1); 1192 mem_put_qi (get_reg (sp), imm); 1193 tprintf("pushqi %02x\n", imm); 1194 } 1195 1196 /** 0111 010w 0100 srcx PUSH.size:G src */ 1197 1198 sc = decode_srcdest4 (srcx, w); 1199 v = get_src (sc); 1200 if (w) 1201 { 1202 put_reg (sp, get_reg (sp) - 2); 1203 mem_put_hi (get_reg (sp), v); 1204 tprintf("pushhi: %x\n", v); 1205 } 1206 else 1207 { 1208 put_reg (sp, get_reg (sp) - 1); 1209 mem_put_qi (get_reg (sp), v); 1210 tprintf("pushqi: %x\n", v); 1211 } 1212 1213 /** 1000 s010 PUSH.B:S src */ 1214 1215 v = get_reg (s ? r0h : r0l); 1216 put_reg (sp, get_reg (sp) - 1); 1217 mem_put_qi (get_reg (sp), v); 1218 tprintf("pushqi: %x\n", v); 1219 1220 /** 1100 s010 PUSH.W:S src */ 1221 1222 v = get_reg (s ? a1 : a0); 1223 put_reg (sp, get_reg (sp) - 2); 1224 mem_put_hi (get_reg (sp), v); 1225 tprintf("pushhi: %x\n", v); 1226 1227 /** 0111 1101 1001 srcx PUSHA src */ 1228 1229 sc = decode_srcdest4 (srcx, 0); 1230 put_reg (sp, get_reg (sp) - 2); 1231 mem_put_hi (get_reg (sp), sc.u.addr); 1232 tprintf("pushhi: %x\n", sc.u.addr); 1233 1234 /** 1110 1011 0src 0010 PUSHC src */ 1235 1236 sc = decode_cr (src); 1237 put_reg (sp, get_reg (sp) - 2); 1238 v = get_src (sc); 1239 mem_put_hi (get_reg (sp), v); 1240 tprintf("pushc: %x\n", v); 1241 1242 /** 1110 1100 PUSHM src */ 1243 1244 { 1245 static int map[] = { fb, sb, a1, a0, r3, r2, r1, r0 }; 1246 imm = IMM(0); 1247 tprintf("pushm: %x\n", imm); 1248 for (a=0; a<8; a++) 1249 if (imm & (1<<a)) 1250 { 1251 put_reg (sp, get_reg (sp) - 2); 1252 v = get_reg (map[a]); 1253 mem_put_hi (get_reg (sp), v); 1254 } 1255 } 1256 1257 /** 1111 1011 REIT */ 1258 1259 a = get_reg (sp); 1260 v = (mem_get_hi (a) 1261 + 4096 * (mem_get_qi (a+3) & 0xf0)); 1262 b = (mem_get_qi (a+2) 1263 + 256 * (mem_get_qi (a+3) & 0xff)); 1264 put_reg (pc, v); 1265 put_reg (flags, b); 1266 put_reg (sp, get_reg (sp) + 4); 1267 1268 /** 0111 110w 1111 0001 RMPA.size */ 1269 1270 { 1271 int count = get_reg (r3); 1272 int list1 = get_reg (a0); 1273 int list2 = get_reg (a1); 1274 int sum = get_reg (w ? r2r0 : r0); 1275 1276 while (count) 1277 { 1278 if (w) 1279 { 1280 a = sign_ext (mem_get_hi (list1), 16); 1281 b = sign_ext (mem_get_hi (list2), 16); 1282 } 1283 else 1284 { 1285 a = sign_ext (mem_get_qi (list1), 8); 1286 b = sign_ext (mem_get_qi (list2), 8); 1287 } 1288 tprintf("%d + %d * %d = ", sum, a, b); 1289 sum += a * b; 1290 tprintf("%d\n", sum); 1291 list1 += w ? 2 : 1; 1292 list2 += w ? 2 : 1; 1293 count --; 1294 } 1295 put_reg (r3, count); 1296 put_reg (a0, list1); 1297 put_reg (a1, list2); 1298 put_reg (w ? r2r0 : r0, sum); 1299 } 1300 1301 /** 0111 011w 1010 dest ROLC.size dest */ 1302 1303 dc = decode_srcdest4 (dest, w); 1304 rot_op (dc, 1, 1); 1305 1306 /** 0111 011w 1011 dest RORC.size dest */ 1307 1308 dc = decode_srcdest4 (dest, w); 1309 rot_op (dc, 1, -1); 1310 1311 /** 1110 000w immm dest ROT.size #IMM,dest */ 1312 1313 dc = decode_srcdest4 (dest, w); 1314 rot_op (dc, 0, IMM4()); 1315 1316 /** 0111 010w 0110 dest ROT.size R1H,dest */ 1317 1318 dc = decode_srcdest4 (dest, w); 1319 rot_op (dc, 0, sign_ext (get_reg (r1h), 8)); 1320 1321 /** 1111 0011 RTS */ 1322 1323 put_reg (pc, mem_get_psi (get_reg (sp))); 1324 put_reg (sp, get_reg (sp) + 3); 1325 1326 /** 0111 011w 0111 dest SBB.size #IMM,dest */ 1327 1328 dc = decode_srcdest4 (dest, w); 1329 imm = IMM(w); 1330 MATH_OP (dc, imm, !carry, -, >= 0); 1331 1332 /** 1011 100w srcx dest SBB.size src,dest */ 1333 1334 sc = decode_srcdest4(srcx, w); 1335 dc = decode_srcdest4(dest, w); 1336 b = get_src (sc); 1337 MATH_OP (dc, b, !carry, -, >= 0); 1338 1339 /** 1111 000w immm dest SHA.size #IMM, dest */ 1340 1341 dc = decode_srcdest4(dest, w); 1342 shift_op (dc, 1, IMM4()); 1343 1344 /** 0111 010w 1111 dest SHA.size R1H,dest */ 1345 1346 dc = decode_srcdest4(dest, w); 1347 a = sign_ext (get_reg (r1h), 8); 1348 shift_op (dc, 1, a); 1349 1350 /** 1110 1011 101d immm SHA.L #IMM, dest */ 1351 1352 dc = reg_sd (d ? r3r1 : r2r0); 1353 shift_op (dc, 1, IMM4()); 1354 1355 /** 1110 1011 001d 0001 SHA.L R1H,dest */ 1356 1357 dc = reg_sd (d ? r3r1 : r2r0); 1358 a = sign_ext (get_reg (r1h), 8); 1359 shift_op (dc, 1, a); 1360 1361 /** 1110 100w immm dest SHL.size #IMM, dest */ 1362 1363 dc = decode_srcdest4(dest, w); 1364 shift_op (dc, 0, IMM4()); 1365 1366 /** 0111 010w 1110 dest SHL.size R1H,dest */ 1367 1368 dc = decode_srcdest4(dest, w); 1369 a = sign_ext (get_reg (r1h), 8); 1370 shift_op (dc, 0, a); 1371 1372 /** 1110 1011 100d immm SHL.L #IMM,dest */ 1373 1374 dc = reg_sd (d ? r3r1 : r2r0); 1375 shift_op (dc, 0, IMM4()); 1376 1377 /** 1110 1011 000d 0001 SHL.L R1H,dest */ 1378 1379 dc = reg_sd (d ? r3r1 : r2r0); 1380 a = sign_ext (get_reg (r1h), 8); 1381 shift_op (dc, 0, a); 1382 1383 /** 0111 110w 1110 100b SMOVB.size */ 1384 1385 { 1386 int count = get_reg (r3); 1387 int s1 = get_reg (a0) + (get_reg (r1h) << 16); 1388 int s2 = get_reg (a1); 1389 int inc = (w ? 2 : 1) * (b ? -1 : 1); 1390 1391 while (count) 1392 { 1393 if (w) 1394 { 1395 v = mem_get_hi (s1); 1396 mem_put_hi (s2, v); 1397 } 1398 else 1399 { 1400 v = mem_get_qi (s1); 1401 mem_put_qi (s2, v); 1402 } 1403 s1 += inc; 1404 s2 += inc; 1405 count --; 1406 } 1407 put_reg (r3, count); 1408 put_reg (a0, s1 & 0xffff); 1409 put_reg (a1, s2); 1410 put_reg (r1h, s1 >> 16); 1411 } 1412 1413 /** 0111 110w 1110 1010 SSTR.size */ 1414 1415 { 1416 int count = get_reg (r3); 1417 int s1 = get_reg (a1); 1418 v = get_reg (w ? r0 : r0l); 1419 1420 while (count) 1421 { 1422 if (w) 1423 { 1424 mem_put_hi (s1, v); 1425 s1 += 2; 1426 } 1427 else 1428 { 1429 mem_put_qi (s1, v); 1430 s1 += 1; 1431 } 1432 count --; 1433 } 1434 put_reg (r3, count); 1435 put_reg (a1, s1); 1436 } 1437 1438 /** 0111 1011 1src dest STC src,dest */ 1439 1440 dc = decode_srcdest4 (dest, 1); 1441 sc = decode_cr (src); 1442 put_dest (dc, get_src(sc)); 1443 1444 /** 0111 1100 1100 dest STC PC,dest */ 1445 1446 dc = decode_srcdest4 (dest, 1); 1447 dc.bytes = 3; 1448 put_dest (dc, orig_pc); 1449 1450 /** 0111 1101 1111 0000 STCTX abs16,abs20 */ 1451 1452 NOTYET(); 1453 1454 /** 0111 010w 0000 srcx STE.size src,abs20 */ 1455 1456 sc = decode_srcdest4 (srcx, w); 1457 a = IMM(2); 1458 v = get_src (sc); 1459 if (w) 1460 mem_put_hi (a, v); 1461 else 1462 mem_put_qi (a, v); 1463 if (srcx == 4 || srcx == 5) 1464 { 1465 v = get_reg (sc.u.reg); 1466 set_sz (v, 2); 1467 } 1468 else 1469 set_sz (v, w+1); 1470 1471 /** 0111 010w 0001 srcx STE.size src,disp20[a0] */ 1472 1473 sc = decode_srcdest4 (srcx, w); 1474 a = get_reg(a0) + IMM(2); 1475 v = get_src (sc); 1476 if (w) 1477 mem_put_hi (a, v); 1478 else 1479 mem_put_qi (a, v); 1480 if (srcx == 4 || srcx == 5) 1481 { 1482 v = get_reg (sc.u.reg); 1483 set_sz (v, 2); 1484 } 1485 else 1486 set_sz (v, w+1); 1487 1488 /** 0111 010w 0010 srcx STE.size src,[a1a0] */ 1489 1490 sc = decode_srcdest4 (srcx, w); 1491 a = get_reg(a1a0); 1492 v = get_src (sc); 1493 if (w) 1494 mem_put_hi (a, v); 1495 else 1496 mem_put_qi (a, v); 1497 if (srcx == 4 || srcx == 5) 1498 { 1499 v = get_reg (sc.u.reg); 1500 set_sz (v, 2); 1501 } 1502 else 1503 set_sz (v, w+1); 1504 1505 /** 1101 0dst STNZ #IMM8,dest */ 1506 1507 imm = IMM(0); 1508 dc = decode_dest3(dst, 0); 1509 if (!FLAG_Z) 1510 put_dest (dc, imm); 1511 1512 /** 1100 1dst STZ #IMM8,dest */ 1513 1514 imm = IMM(0); 1515 dc = decode_dest3(dst, 0); 1516 if (FLAG_Z) 1517 put_dest (dc, imm); 1518 1519 /** 1101 1dst STZX #IMM81,#IMM82,dest */ 1520 1521 a = IMM(0); 1522 dc = decode_dest3(dst, 0); 1523 b = IMM(0); 1524 if (FLAG_Z) 1525 put_dest (dc, a); 1526 else 1527 put_dest (dc, b); 1528 1529 /** 0111 011w 0101 dest SUB.size:G #IMM,dest */ 1530 1531 dc = decode_srcdest4 (dest, w); 1532 imm = IMM(w); 1533 MATH_OP (dc, imm, 0, -, >= 0); 1534 1535 /** 1000 1dst SUB.B:S #IMM8,dest */ 1536 1537 imm = IMM(0); 1538 dc = decode_dest3 (dst, 0); 1539 MATH_OP (dc, imm, 0, -, >= 0); 1540 1541 /** 1010 100w srcx dest SUB.size:G src,dest */ 1542 1543 sc = decode_srcdest4(srcx, w); 1544 dc = decode_srcdest4(dest, w); 1545 b = get_src (sc); 1546 MATH_OP (dc, b, 0, -, >= 0); 1547 1548 /** 0010 1d sr SUB.B:S src,R0L/R0H */ 1549 1550 sc = decode_src2 (sr, 0, d); 1551 dc = decode_dest1 (d, 0); 1552 b = get_src (sc); 1553 MATH_OP (dc, b, 0, -, >= 0); 1554 1555 /** 0111 011w 0000 dest TST.size #IMM, dest */ 1556 1557 UNARY_UOP; 1558 imm = IMM(w); 1559 tprintf ("%x & %x = %x\n", v, imm, v & imm); 1560 v &= imm; 1561 set_sz (v, w+1); 1562 1563 /** 1000 000w srcx dest TST.size src,dest */ 1564 1565 BINARY_UOP; 1566 tprintf ("%x & %x = %x\n", a, b, a & b); 1567 v = a & b; 1568 set_sz (v, w+1); 1569 1570 /** 1111 1111 UND */ 1571 1572 trigger_fixed_interrupt (0xffdc); 1573 1574 /** 0111 1101 1111 0011 WAIT */ 1575 1576 tprintf("waiting...\n"); 1577 1578 /** 0111 101w 00sr dest XCHG.size src,dest */ 1579 1580 sc = decode_srcdest4 (sr, w); 1581 dc = decode_srcdest4 (dest, w); 1582 a = get_src (sc); 1583 b = get_src (dc); 1584 put_dest (dc, a); 1585 put_dest (sc, b); 1586 1587 /** 0111 011w 0001 dest XOR.size #IMM,dest */ 1588 1589 UNARY_UOP; 1590 imm = IMM(w); 1591 tprintf ("%x ^ %x = %x\n", v, imm, v ^ imm); 1592 v ^= imm; 1593 set_sz (v, w+1); 1594 put_dest (dc, v); 1595 1596 /** 1000 100w srcx dest XOR.size src,dest */ 1597 1598 BINARY_UOP; 1599 tprintf ("%x ^ %x = %x\n", a, b, a ^ b); 1600 v = a ^ b; 1601 set_sz (v, w+1); 1602 put_dest (dc, v); 1603 1604 /** OP */ 1605/** */ 1606 1607 return step_result; 1608} 1609