1/* r8c.opc --- semantics for r8c opcodes. -*- mode: c -*- 2 3Copyright (C) 2005, 2007, 2008, 2009, 2010, 2011 4Free Software Foundation, Inc. 5Contributed by Red Hat, Inc. 6 7This file is part of the GNU simulators. 8 9This program is free software; you can redistribute it and/or modify 10it under the terms of the GNU General Public License as published by 11the Free Software Foundation; either version 3 of the License, or 12(at your option) any later version. 13 14This program is distributed in the hope that it will be useful, 15but WITHOUT ANY WARRANTY; without even the implied warranty of 16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17GNU General Public License for more details. 18 19You should have received a copy of the GNU General Public License 20along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 23#include <stdio.h> 24#include <stdlib.h> 25 26#include "cpu.h" 27#include "mem.h" 28#include "misc.h" 29#include "int.h" 30 31#define AU __attribute__((unused)) 32 33#define tprintf if (trace) printf 34 35static unsigned char 36getbyte () 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(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() 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 int src = i ? IMM(w) : get_reg (w ? r1 : r0h); 594 int dest = get_reg (w ? r0 : r0l); 595 int res; 596 597 src = bcd2int(src, w); 598 dest = bcd2int(dest, w); 599 600 tprintf("decimal: %d %s %d", dest, s?"-":"+", src); 601 if (c) 602 tprintf(" c=%d", carry); 603 604 if (!s) 605 { 606 res = dest + src; 607 if (c) 608 res += carry; 609 c = res > (w ? 9999 : 99); 610 } 611 else 612 { 613 res = dest - src; 614 if (c) 615 res -= (1-carry); 616 c = res >= 0; 617 if (res < 0) 618 res += w ? 10000 : 100; 619 } 620 621 res = int2bcd (res, w); 622 tprintf(" = %x\n", res); 623 624 set_szc (res, w+1, c); 625 626 put_reg (w ? r0 : r0l, res); 627 628 /** 1010 1dst DEC.B dest */ 629 630 dc = decode_dest3 (dst, 0); 631 v = get_src (dc); 632 tprintf("%x -- = %x\n", v, v-1); 633 v --; 634 set_sz (v, 1); 635 put_dest (dc, v); 636 637 /** 1111 d010 DEC.W dest */ 638 639 v = get_reg (d ? a1 : a0); 640 tprintf("%x -- = %x\n", v, v-1); 641 v --; 642 set_sz (v, 2); 643 put_reg (d ? a1 : a0, v); 644 645 /** 0111 110w 1110 0001 DIV.size #IMM */ 646 647 div_op (-1, 0, 0, w); 648 649 /** 0111 011w 1101 srcx DIV.size src */ 650 651 div_op (srcx, 0, 0, w); 652 653 /** 0111 110w 1110 0000 DIVU.size #IMM */ 654 655 div_op (-1, 1, 0, w); 656 657 /** 0111 011w 1100 srcx DIVU.size src */ 658 659 div_op (srcx, 1, 0, w); 660 661 /** 0111 110w 1110 0011 DIVX.size #IMM */ 662 663 div_op (-1, 0, 1, w); 664 665 /** 0111 011w 1001 srcx DIVX.size src */ 666 667 div_op (srcx, 0, 1, w); 668 669 /** 0111 1100 1111 0010 ENTER #IMM8 */ 670 671 imm = IMM(0); 672 put_reg (sp, get_reg (sp) - 2); 673 mem_put_hi (get_reg (sp), get_reg (fb)); 674 put_reg (fb, get_reg (sp)); 675 put_reg (sp, get_reg (sp) - imm); 676 677 /** 0111 1101 1111 0010 EXITD */ 678 679 put_reg (sp, get_reg (fb)); 680 put_reg (fb, mem_get_hi (get_reg (sp))); 681 put_reg (sp, get_reg (sp) + 2); 682 put_reg (pc, mem_get_psi (get_reg (sp))); 683 put_reg (sp, get_reg (sp) + 3); 684 685 /** 0111 1100 0110 dest EXTS.B dest */ 686 687 dc = decode_srcdest4 (dest, 0); 688 v = sign_ext (get_src (dc), 8); 689 dc = widen_sd (dc); 690 put_dest (dc, v); 691 set_sz (v, 1); 692 693 /** 0111 1100 1111 0011 EXTS.W R0 */ 694 695 v = sign_ext (get_reg (r0), 16); 696 put_reg (r2r0, v); 697 set_sz (v, 2); 698 699 /** 1110 1011 0flg 0101 FCLR dest */ 700 701 set_flags (1 << flg, 0); 702 703 /** 1110 1011 0flg 0100 FSET dest */ 704 705 set_flags (1 << flg, 1 << flg); 706 707 /** 1010 0dst INC.B dest */ 708 709 dc = decode_dest3 (dst, 0); 710 v = get_src (dc); 711 tprintf("%x ++ = %x\n", v, v+1); 712 v ++; 713 set_sz (v, 1); 714 put_dest (dc, v); 715 716 /** 1011 d010 INC.W dest */ 717 718 v = get_reg (d ? a1 : a0); 719 tprintf("%x ++ = %x\n", v, v+1); 720 v ++; 721 set_sz (v, 2); 722 put_reg (d ? a1 : a0, v); 723 724 /** 1110 1011 11vector INT #imm */ 725 726 trigger_based_interrupt (vector); 727 728 /** 1111 0110 INTO */ 729 730 if (FLAG_O) 731 trigger_fixed_interrupt (0xffe0); 732 733 /** 0110 1cnd Jcnd label */ 734 735 v = sign_ext (IMM(0), 8); 736 if (condition_true (cnd)) 737 put_reg (pc, orig_pc + 1 + v); 738 739 /** 0111 1101 1100 cond Jcnd label */ 740 741 v = sign_ext (IMM(0), 8); 742 if (condition_true (cond)) 743 put_reg (pc, orig_pc + 2 + v); 744 745 /** 0110 0dsp JMP.S label */ 746 747 put_reg (pc, orig_pc + 2 + dsp); 748 749 /** 1111 1110 JMP.B label */ 750 751 imm = sign_ext (IMM(0), 8); 752 if (imm == -1) 753 { 754 if (verbose) 755 printf("[jmp-to-self detected as exit]\n"); 756 return M32C_MAKE_HIT_BREAK (); 757 } 758 put_reg (pc, orig_pc + 1 + imm); 759 760 /** 1111 0100 JMP.W label */ 761 762 imm = sign_ext (IMM(1), 16); 763 put_reg (pc, orig_pc + 1 + imm); 764 765 /** 1111 1100 JMP.A label */ 766 767 imm = IMM(2); 768 put_reg (pc, imm); 769 770 /** 0111 1101 0010 srcx JMPI.W src */ 771 772 sc = decode_jumpdest (srcx, 1); 773 a = get_src (sc); 774 a = sign_ext (a, 16); 775 put_reg (pc, orig_pc + a); 776 777 /** 0111 1101 0000 srcx JMPI.A src */ 778 779 sc = decode_jumpdest (srcx, 0); 780 a = get_src (sc); 781 put_reg (pc, a); 782 783 /** 1110 1110 JMPS #IMM8 */ 784 785 M16C_ONLY(); 786 787 imm = IMM(0); 788 a = 0xf0000 + mem_get_hi (0xffffe - imm * 2); 789 put_reg (pc, a); 790 791 /** 1111 0101 JSR.W label */ 792 793 imm = sign_ext (IMM(1), 16); 794 put_reg (sp, get_reg (sp) - 3); 795 mem_put_psi (get_reg (sp), get_reg (pc)); 796 put_reg (pc, orig_pc + imm + 1); 797 798 /** 1111 1101 JSR.A label */ 799 800 imm = IMM(2); 801 put_reg (sp, get_reg (sp) - 3); 802 mem_put_psi (get_reg (sp), get_reg (pc)); 803 put_reg (pc, imm); 804 805 /** 0111 1101 0011 srcx JSRI.W src */ 806 807 sc = decode_jumpdest (srcx, 1); 808 a = get_src (sc); 809 a = sign_ext (a, 16); 810 811 put_reg (sp, get_reg (sp) - 3); 812 mem_put_psi (get_reg (sp), get_reg (pc)); 813 put_reg (pc, orig_pc + a); 814 815 /** 0111 1101 0001 srcx JSRI.A src */ 816 817 sc = decode_jumpdest (srcx, 0); 818 a = get_src (sc); 819 820 put_reg (sp, get_reg (sp) - 3); 821 mem_put_psi (get_reg (sp), get_reg (pc)); 822 put_reg (pc, a); 823 824 /** 1110 1111 JSRS #IMM8 */ 825 826 M16C_ONLY(); 827 828 imm = IMM(0); 829 a = 0xf0000 + mem_get_hi (0xffffe - imm * 2); 830 831 put_reg (sp, get_reg (sp) - 3); 832 mem_put_psi (get_reg (sp), get_reg (pc)); 833 put_reg (pc, a); 834 835 /** 1110 1011 0reg 0000 LDC #IMM16,dest */ 836 837 dc = decode_cr (reg); 838 imm = IMM(1); 839 put_dest (dc, imm); 840 841 /** 0111 1010 1reg srcx LDC src,dest */ 842 843 dc = decode_cr (reg); 844 sc = decode_srcdest4 (srcx,1); 845 put_dest (dc, get_src (sc)); 846 847 /** 0111 1100 1111 0000 LDCTX abs16,abs20 */ 848 849 NOTYET(); 850 851 /** 0111 010w 1000 dest LDE.size abs20,dest */ 852 853 dc = decode_srcdest4 (dest, w); 854 imm = IMM(2); 855 if (w) 856 v = mem_get_hi (imm); 857 else 858 v = mem_get_qi (imm); 859 put_dest (dc, v); 860 861 /** 0111 010w 1001 dest LDE.size dsp:20[a0], dest */ 862 863 dc = decode_srcdest4 (dest, w); 864 imm = IMM(2) + get_reg (a0); 865 if (w) 866 v = mem_get_hi (imm); 867 else 868 v = mem_get_qi (imm); 869 put_dest (dc, v); 870 871 /** 0111 010w 1010 dest LDE.size [a1a0],dest */ 872 873 dc = decode_srcdest4 (dest, w); 874 imm = get_reg (a1a0); 875 if (w) 876 v = mem_get_hi (imm); 877 else 878 v = mem_get_qi (imm); 879 put_dest (dc, v); 880 881 /** 0111 1101 1010 0imm LDIPL #IMM */ 882 883 set_flags (0x700, imm*0x100); 884 885 /** 0111 010w 1100 dest MOV.size:G #IMM,dest */ 886 887 dc = decode_srcdest4 (dest, w); 888 imm = IMM(w); 889 v = imm; 890 tprintf("%x = %x\n", v, v); 891 set_sz(v, w+1); 892 put_dest (dc, v); 893 894 /** 1101 100w immm dest MOV.size:Q #IMM,dest */ 895 896 dc = decode_srcdest4 (dest, w); 897 v = sign_ext (immm, 4); 898 tprintf ("%x = %x\n", v, v); 899 set_sz (v, w+1); 900 put_dest (dc, v); 901 902 /** 1100 0dst MOV.B:S #IMM8,dest */ 903 904 imm = IMM(0); 905 dc = decode_dest3 (dst, 0); 906 v = imm; 907 tprintf("%x = %x\n", v, v); 908 set_sz (v, 1); 909 put_dest (dc, v); 910 911 /** 1w10 d010 MOV.size:S #IMM,dest */ 912 913 /* Note that for w, 0=W and 1=B unlike the usual meaning. */ 914 v = IMM(1-w); 915 tprintf("%x = %x\n", v, v); 916 set_sz (v, 2-w); 917 put_reg (d ? a1 : a0, v); 918 919 /** 1011 0dst MOV.B:Z #0,dest */ 920 921 dc = decode_dest3 (dst, 0); 922 v = 0; 923 set_sz (v, 1); 924 put_dest (dc, v); 925 926 /** 0111 001w srcx dest MOV.size:G src,dest */ 927 928 sc = decode_srcdest4 (srcx, w); 929 dc = decode_srcdest4 (dest, w); 930 v = get_src (sc); 931 set_sz (v, w+1); 932 put_dest (dc, v); 933 934 /** 0011 0d sr MOV.B:S src,dest */ 935 936 sc = decode_src2 (sr, 0, d); 937 v = get_src (sc); 938 set_sz (v, 1); 939 put_reg (d ? a1 : a0, v); 940 941 /** 0000 0s ds MOV.B:S R0L/R0H,dest */ 942 943 if (ds == 0) 944 UNSUPPORTED(); 945 dc = decode_src2 (ds, 0, s); 946 v = get_reg (s ? r0h : r0l); 947 set_sz (v, 1); 948 put_dest (dc, v); 949 950 /** 0000 1d sr MOV.B:S src,R0L/R0H */ 951 952 sc = decode_src2 (sr, 0, d); 953 v = get_src (sc); 954 set_sz (v, 1); 955 put_reg (d ? r0h : r0l, v); 956 957 /** 0111 010w 1011 dest MOV.size:G dsp:8[SP], dest */ 958 959 dc = decode_srcdest4 (dest, w); 960 imm = IMM(0); 961 a = get_reg (sp) + sign_ext (imm, 8); 962 a &= addr_mask; 963 if (w) 964 v = mem_get_hi (a); 965 else 966 v = mem_get_qi (a); 967 set_sz (v, w+1); 968 put_dest (dc, v); 969 970 /** 0111 010w 0011 srcx MOV.size:G src, disp8[SP] */ 971 972 sc = decode_srcdest4 (srcx, w); 973 imm = IMM(0); 974 a = get_reg (sp) + sign_ext (imm, 8); 975 a &= addr_mask; 976 v = get_src (sc); 977 if (w) 978 mem_put_hi (a, v); 979 else 980 mem_put_qi (a, v); 981 set_sz (v, w+1); 982 983 /** 1110 1011 0reg 1src MOVA src,dest */ 984 985 static reg_id map[] = { r0, r1, r2, r3, a0, a1, 0, 0 }; 986 sc = decode_srcdest4 (8 + src, 0); 987 put_reg (map[reg], sc.u.addr); 988 989 /** 0111 1100 10hl dest MOVdir R0L,dest */ 990 991 if (dest == 0 || dest == 4 || dest == 5) 992 UNSUPPORTED(); 993 dc = decode_srcdest4 (dest, 0); 994 a = get_src (dc); 995 b = get_reg (r0l); 996 switch (hl) 997 { 998 case 0: a = (a & 0xf0) | (b & 0x0f); break; 999 case 1: a = (a & 0xf0) | ((b>>4) & 0x0f); break; 1000 case 2: a = (a & 0x0f) | ((b & 0x0f)<<4); break; 1001 case 3: a = (a & 0x0f) | (b & 0xf0); break; 1002 } 1003 put_dest (dc, a); 1004 1005 /** 0111 1100 00hl srcx MOVdir src,R0L */ 1006 1007 if (srcx == 0 || srcx == 4 || srcx == 5) 1008 UNSUPPORTED(); 1009 sc = decode_srcdest4 (srcx, 0); 1010 a = get_reg (r0l); 1011 b = get_src (sc); 1012 switch (hl) 1013 { 1014 case 0: a = (a & 0xf0) | (b & 0x0f); break; 1015 case 1: a = (a & 0xf0) | ((b>>4) & 0x0f); break; 1016 case 2: a = (a & 0x0f) | ((b & 0x0f)<<4); break; 1017 case 3: a = (a & 0x0f) | (b & 0xf0); break; 1018 } 1019 put_reg (r0l, a); 1020 1021 /** 0111 110w 0101 dest MUL.size #IMM,dest */ 1022 1023 UNARY_SOP; 1024 imm = sign_ext (IMM(w), w?16:8); 1025 tprintf("%d * %d = %d\n", v, imm, v*imm); 1026 v *= imm; 1027 dc = widen_sd (dc); 1028 put_dest (dc, v); 1029 1030 /** 0111 100w srcx dest MUL.size src,dest */ 1031 1032 BINARY_SOP; 1033 v = a * b; 1034 tprintf("%d * %d = %d\n", a, b, v); 1035 dc = widen_sd (dc); 1036 put_dest (dc, v); 1037 1038 /** 0111 110w 0100 dest MULU.size #IMM,dest */ 1039 1040 UNARY_UOP; 1041 imm = IMM(w); 1042 tprintf("%u * %u = %u\n", v, imm, v*imm); 1043 v *= imm; 1044 dc = widen_sd (dc); 1045 put_dest (dc, v); 1046 1047 /** 0111 000w srcx dest MULU.size src,dest */ 1048 1049 BINARY_UOP; 1050 v = a * b; 1051 tprintf("%u * %u = %u\n", a, b, v); 1052 dc = widen_sd (dc); 1053 put_dest (dc, v); 1054 1055 /** 0111 010w 0101 dest NEG.size dest */ 1056 1057 UNARY_SOP; 1058 tprintf("%d * -1 = %d\n", v, -v); 1059 v = -v; 1060 set_oszc (v, w+1, v == 0); 1061 put_dest (dc, v); 1062 1063 /** 0000 0100 NOP */ 1064 1065 tprintf("nop\n"); 1066 1067 /** 0111 010w 0111 dest NOT.size:G */ 1068 1069 UNARY_UOP; 1070 tprintf("~ %x = %x\n", v, ~v); 1071 v = ~v; 1072 set_sz (v, w+1); 1073 put_dest (dc, v); 1074 1075 /** 1011 1dst NOT.B:S dest */ 1076 1077 dc = decode_dest3 (dst, 0); 1078 v = get_src (dc); 1079 tprintf("~ %x = %x\n", v, ~v); 1080 v = ~v; 1081 set_sz (v, 1); 1082 put_dest (dc, v); 1083 1084 /** 0111 011w 0011 dest OR.size:G #IMM,dest */ 1085 1086 UNARY_UOP; 1087 imm = IMM(w); 1088 tprintf ("%x | %x = %x\n", v, imm, v | imm); 1089 v |= imm; 1090 set_sz (v, w+1); 1091 put_dest (dc, v); 1092 1093 /** 1001 1dst OR.B:S #IMM8,dest */ 1094 1095 imm = IMM(0); 1096 dc = decode_dest3 (dst, 0); 1097 v = get_src (dc); 1098 tprintf("%x | %x = %x\n", v, imm, v|imm); 1099 v |= imm; 1100 set_sz (v, 1); 1101 put_dest (dc, v); 1102 1103 /** 1001 100w srcx dest OR.size:G src,dest */ 1104 1105 BINARY_UOP; 1106 tprintf ("%x | %x = %x\n", a, b, a | b); 1107 v = a | b; 1108 set_sz (v, w+1); 1109 put_dest (dc, v); 1110 1111 /** 0001 1d sr OR.B:S src,R0L/R0H */ 1112 1113 sc = decode_src2 (sr, 0, d); 1114 dc = decode_dest1 (d, 0); 1115 a = get_src (sc); 1116 b = get_src (dc); 1117 v = a | b; 1118 tprintf("%x | %x = %x\n", a, b, v); 1119 set_sz (v, 1); 1120 put_dest (dc, v); 1121 1122 /** 0111 010w 1101 dest POP.size:G dest */ 1123 1124 dc = decode_srcdest4 (dest, w); 1125 if (w) 1126 { 1127 v = mem_get_hi (get_reg (sp)); 1128 put_reg (sp, get_reg (sp) + 2); 1129 tprintf("pophi: %x\n", v); 1130 } 1131 else 1132 { 1133 v = mem_get_qi (get_reg (sp)); 1134 put_reg (sp, get_reg (sp) + 1); 1135 tprintf("popqi: %x\n", v); 1136 } 1137 put_dest (dc, v); 1138 1139 /** 1001 d010 POP.B:S dest */ 1140 1141 v = mem_get_qi (get_reg (sp)); 1142 put_reg (d ? r0h : r0l, v); 1143 put_reg (sp, get_reg (sp) + 1); 1144 tprintf("popqi: %x\n", v); 1145 1146 /** 1101 d010 POP.W:S dest */ 1147 1148 v = mem_get_hi (get_reg (sp)); 1149 put_reg (d ? a1 : a0, v); 1150 put_reg (sp, get_reg (sp) + 2); 1151 tprintf("pophi: %x\n", v); 1152 1153 /** 1110 1011 0reg 0011 POPC dest */ 1154 1155 dc = decode_cr (reg); 1156 v = mem_get_hi (get_reg (sp)); 1157 put_dest (dc, v); 1158 put_reg (sp, get_reg (sp) + 2); 1159 tprintf("popc: %x\n", v); 1160 1161 /** 1110 1101 POPM dest */ 1162 1163 static int map[] = { r0, r1, r2, r3, a0, a1, sb, fb }; 1164 imm = IMM(0); 1165 tprintf("popm: %x\n", imm); 1166 for (a=0; a<8; a++) 1167 if (imm & (1<<a)) 1168 { 1169 v = mem_get_hi (get_reg (sp)); 1170 put_reg (map[a], v); 1171 put_reg (sp, get_reg (sp) + 2); 1172 } 1173 1174 /** 0111 110w 1110 0010 PUSH.size:G #IMM */ 1175 1176 imm = IMM(w); 1177 if (w) 1178 { 1179 put_reg (sp, get_reg (sp) - 2); 1180 mem_put_hi (get_reg (sp), imm); 1181 tprintf("pushhi %04x\n", imm); 1182 } 1183 else 1184 { 1185 put_reg (sp, get_reg (sp) - 1); 1186 mem_put_qi (get_reg (sp), imm); 1187 tprintf("pushqi %02x\n", imm); 1188 } 1189 1190 /** 0111 010w 0100 srcx PUSH.size:G src */ 1191 1192 sc = decode_srcdest4 (srcx, w); 1193 v = get_src (sc); 1194 if (w) 1195 { 1196 put_reg (sp, get_reg (sp) - 2); 1197 mem_put_hi (get_reg (sp), v); 1198 tprintf("pushhi: %x\n", v); 1199 } 1200 else 1201 { 1202 put_reg (sp, get_reg (sp) - 1); 1203 mem_put_qi (get_reg (sp), v); 1204 tprintf("pushqi: %x\n", v); 1205 } 1206 1207 /** 1000 s010 PUSH.B:S src */ 1208 1209 v = get_reg (s ? r0h : r0l); 1210 put_reg (sp, get_reg (sp) - 1); 1211 mem_put_qi (get_reg (sp), v); 1212 tprintf("pushqi: %x\n", v); 1213 1214 /** 1100 s010 PUSH.W:S src */ 1215 1216 v = get_reg (s ? a1 : a0); 1217 put_reg (sp, get_reg (sp) - 2); 1218 mem_put_hi (get_reg (sp), v); 1219 tprintf("pushhi: %x\n", v); 1220 1221 /** 0111 1101 1001 srcx PUSHA src */ 1222 1223 sc = decode_srcdest4 (srcx, 0); 1224 put_reg (sp, get_reg (sp) - 2); 1225 mem_put_hi (get_reg (sp), sc.u.addr); 1226 tprintf("pushhi: %x\n", sc.u.addr); 1227 1228 /** 1110 1011 0src 0010 PUSHC src */ 1229 1230 sc = decode_cr (src); 1231 put_reg (sp, get_reg (sp) - 2); 1232 v = get_src (sc); 1233 mem_put_hi (get_reg (sp), v); 1234 tprintf("pushc: %x\n", v); 1235 1236 /** 1110 1100 PUSHM src */ 1237 1238 static int map[] = { fb, sb, a1, a0, r3, r2, r1, r0 }; 1239 imm = IMM(0); 1240 tprintf("pushm: %x\n", imm); 1241 for (a=0; a<8; a++) 1242 if (imm & (1<<a)) 1243 { 1244 put_reg (sp, get_reg (sp) - 2); 1245 v = get_reg (map[a]); 1246 mem_put_hi (get_reg (sp), v); 1247 } 1248 1249 /** 1111 1011 REIT */ 1250 1251 a = get_reg (sp); 1252 v = (mem_get_hi (a) 1253 + 4096 * (mem_get_qi (a+3) & 0xf0)); 1254 b = (mem_get_qi (a+2) 1255 + 256 * (mem_get_qi (a+3) & 0xff)); 1256 put_reg (pc, v); 1257 put_reg (flags, b); 1258 put_reg (sp, get_reg (sp) + 4); 1259 1260 /** 0111 110w 1111 0001 RMPA.size */ 1261 1262 int count = get_reg (r3); 1263 int list1 = get_reg (a0); 1264 int list2 = get_reg (a1); 1265 int sum = get_reg (w ? r2r0 : r0); 1266 1267 while (count) 1268 { 1269 if (w) 1270 { 1271 a = sign_ext (mem_get_hi (list1), 16); 1272 b = sign_ext (mem_get_hi (list2), 16); 1273 } 1274 else 1275 { 1276 a = sign_ext (mem_get_qi (list1), 8); 1277 b = sign_ext (mem_get_qi (list2), 8); 1278 } 1279 tprintf("%d + %d * %d = ", sum, a, b); 1280 sum += a * b; 1281 tprintf("%d\n", sum); 1282 list1 += w ? 2 : 1; 1283 list2 += w ? 2 : 1; 1284 count --; 1285 } 1286 put_reg (r3, count); 1287 put_reg (a0, list1); 1288 put_reg (a1, list2); 1289 put_reg (w ? r2r0 : r0, sum); 1290 1291 /** 0111 011w 1010 dest ROLC.size dest */ 1292 1293 dc = decode_srcdest4 (dest, w); 1294 rot_op (dc, 1, 1); 1295 1296 /** 0111 011w 1011 dest RORC.size dest */ 1297 1298 dc = decode_srcdest4 (dest, w); 1299 rot_op (dc, 1, -1); 1300 1301 /** 1110 000w immm dest ROT.size #IMM,dest */ 1302 1303 dc = decode_srcdest4 (dest, w); 1304 rot_op (dc, 0, IMM4()); 1305 1306 /** 0111 010w 0110 dest ROT.size R1H,dest */ 1307 1308 dc = decode_srcdest4 (dest, w); 1309 rot_op (dc, 0, sign_ext (get_reg (r1h), 8)); 1310 1311 /** 1111 0011 RTS */ 1312 1313 put_reg (pc, mem_get_psi (get_reg (sp))); 1314 put_reg (sp, get_reg (sp) + 3); 1315 1316 /** 0111 011w 0111 dest SBB.size #IMM,dest */ 1317 1318 dc = decode_srcdest4 (dest, w); 1319 imm = IMM(w); 1320 MATH_OP (dc, imm, !carry, -, >= 0); 1321 1322 /** 1011 100w srcx dest SBB.size src,dest */ 1323 1324 sc = decode_srcdest4(srcx, w); 1325 dc = decode_srcdest4(dest, w); 1326 b = get_src (sc); 1327 MATH_OP (dc, b, !carry, -, >= 0); 1328 1329 /** 1111 000w immm dest SHA.size #IMM, dest */ 1330 1331 dc = decode_srcdest4(dest, w); 1332 shift_op (dc, 1, IMM4()); 1333 1334 /** 0111 010w 1111 dest SHA.size R1H,dest */ 1335 1336 dc = decode_srcdest4(dest, w); 1337 a = sign_ext (get_reg (r1h), 8); 1338 shift_op (dc, 1, a); 1339 1340 /** 1110 1011 101d immm SHA.L #IMM, dest */ 1341 1342 dc = reg_sd (d ? r3r1 : r2r0); 1343 shift_op (dc, 1, IMM4()); 1344 1345 /** 1110 1011 001d 0001 SHA.L R1H,dest */ 1346 1347 dc = reg_sd (d ? r3r1 : r2r0); 1348 a = sign_ext (get_reg (r1h), 8); 1349 shift_op (dc, 1, a); 1350 1351 /** 1110 100w immm dest SHL.size #IMM, dest */ 1352 1353 dc = decode_srcdest4(dest, w); 1354 shift_op (dc, 0, IMM4()); 1355 1356 /** 0111 010w 1110 dest SHL.size R1H,dest */ 1357 1358 dc = decode_srcdest4(dest, w); 1359 a = sign_ext (get_reg (r1h), 8); 1360 shift_op (dc, 0, a); 1361 1362 /** 1110 1011 100d immm SHL.L #IMM,dest */ 1363 1364 dc = reg_sd (d ? r3r1 : r2r0); 1365 shift_op (dc, 0, IMM4()); 1366 1367 /** 1110 1011 000d 0001 SHL.L R1H,dest */ 1368 1369 dc = reg_sd (d ? r3r1 : r2r0); 1370 a = sign_ext (get_reg (r1h), 8); 1371 shift_op (dc, 0, a); 1372 1373 /** 0111 110w 1110 100b SMOVB.size */ 1374 1375 int count = get_reg (r3); 1376 int s1 = get_reg (a0) + (get_reg (r1h) << 16); 1377 int s2 = get_reg (a1); 1378 int inc = (w ? 2 : 1) * (b ? -1 : 1); 1379 1380 while (count) 1381 { 1382 if (w) 1383 { 1384 v = mem_get_hi (s1); 1385 mem_put_hi (s2, v); 1386 } 1387 else 1388 { 1389 v = mem_get_qi (s1); 1390 mem_put_qi (s2, v); 1391 } 1392 s1 += inc; 1393 s2 += inc; 1394 count --; 1395 } 1396 put_reg (r3, count); 1397 put_reg (a0, s1 & 0xffff); 1398 put_reg (a1, s2); 1399 put_reg (r1h, s1 >> 16); 1400 1401 /** 0111 110w 1110 1010 SSTR.size */ 1402 1403 int count = get_reg (r3); 1404 int s1 = get_reg (a1); 1405 v = get_reg (w ? r0 : r0l); 1406 1407 while (count) 1408 { 1409 if (w) 1410 { 1411 mem_put_hi (s1, v); 1412 s1 += 2; 1413 } 1414 else 1415 { 1416 mem_put_qi (s1, v); 1417 s1 += 1; 1418 } 1419 count --; 1420 } 1421 put_reg (r3, count); 1422 put_reg (a1, s1); 1423 1424 /** 0111 1011 1src dest STC src,dest */ 1425 1426 dc = decode_srcdest4 (dest, 1); 1427 sc = decode_cr (src); 1428 put_dest (dc, get_src(sc)); 1429 1430 /** 0111 1100 1100 dest STC PC,dest */ 1431 1432 dc = decode_srcdest4 (dest, 1); 1433 dc.bytes = 3; 1434 put_dest (dc, orig_pc); 1435 1436 /** 0111 1101 1111 0000 STCTX abs16,abs20 */ 1437 1438 NOTYET(); 1439 1440 /** 0111 010w 0000 srcx STE.size src,abs20 */ 1441 1442 sc = decode_srcdest4 (srcx, w); 1443 a = IMM(2); 1444 v = get_src (sc); 1445 if (w) 1446 mem_put_hi (a, v); 1447 else 1448 mem_put_qi (a, v); 1449 if (srcx == 4 || srcx == 5) 1450 { 1451 v = get_reg (sc.u.reg); 1452 set_sz (v, 2); 1453 } 1454 else 1455 set_sz (v, w+1); 1456 1457 /** 0111 010w 0001 srcx STE.size src,disp20[a0] */ 1458 1459 sc = decode_srcdest4 (srcx, w); 1460 a = get_reg(a0) + IMM(2); 1461 v = get_src (sc); 1462 if (w) 1463 mem_put_hi (a, v); 1464 else 1465 mem_put_qi (a, v); 1466 if (srcx == 4 || srcx == 5) 1467 { 1468 v = get_reg (sc.u.reg); 1469 set_sz (v, 2); 1470 } 1471 else 1472 set_sz (v, w+1); 1473 1474 /** 0111 010w 0010 srcx STE.size src,[a1a0] */ 1475 1476 sc = decode_srcdest4 (srcx, w); 1477 a = get_reg(a1a0); 1478 v = get_src (sc); 1479 if (w) 1480 mem_put_hi (a, v); 1481 else 1482 mem_put_qi (a, v); 1483 if (srcx == 4 || srcx == 5) 1484 { 1485 v = get_reg (sc.u.reg); 1486 set_sz (v, 2); 1487 } 1488 else 1489 set_sz (v, w+1); 1490 1491 /** 1101 0dst STNZ #IMM8,dest */ 1492 1493 imm = IMM(0); 1494 dc = decode_dest3(dst, 0); 1495 if (!FLAG_Z) 1496 put_dest (dc, imm); 1497 1498 /** 1100 1dst STZ #IMM8,dest */ 1499 1500 imm = IMM(0); 1501 dc = decode_dest3(dst, 0); 1502 if (FLAG_Z) 1503 put_dest (dc, imm); 1504 1505 /** 1101 1dst STZX #IMM81,#IMM82,dest */ 1506 1507 a = IMM(0); 1508 dc = decode_dest3(dst, 0); 1509 b = IMM(0); 1510 if (FLAG_Z) 1511 put_dest (dc, a); 1512 else 1513 put_dest (dc, b); 1514 1515 /** 0111 011w 0101 dest SUB.size:G #IMM,dest */ 1516 1517 dc = decode_srcdest4 (dest, w); 1518 imm = IMM(w); 1519 MATH_OP (dc, imm, 0, -, >= 0); 1520 1521 /** 1000 1dst SUB.B:S #IMM8,dest */ 1522 1523 imm = IMM(0); 1524 dc = decode_dest3 (dst, 0); 1525 MATH_OP (dc, imm, 0, -, >= 0); 1526 1527 /** 1010 100w srcx dest SUB.size:G src,dest */ 1528 1529 sc = decode_srcdest4(srcx, w); 1530 dc = decode_srcdest4(dest, w); 1531 b = get_src (sc); 1532 MATH_OP (dc, b, 0, -, >= 0); 1533 1534 /** 0010 1d sr SUB.B:S src,R0L/R0H */ 1535 1536 sc = decode_src2 (sr, 0, d); 1537 dc = decode_dest1 (d, 0); 1538 b = get_src (sc); 1539 MATH_OP (dc, b, 0, -, >= 0); 1540 1541 /** 0111 011w 0000 dest TST.size #IMM, dest */ 1542 1543 UNARY_UOP; 1544 imm = IMM(w); 1545 tprintf ("%x & %x = %x\n", v, imm, v & imm); 1546 v &= imm; 1547 set_sz (v, w+1); 1548 1549 /** 1000 000w srcx dest TST.size src,dest */ 1550 1551 BINARY_UOP; 1552 tprintf ("%x & %x = %x\n", a, b, a & b); 1553 v = a & b; 1554 set_sz (v, w+1); 1555 1556 /** 1111 1111 UND */ 1557 1558 trigger_fixed_interrupt (0xffdc); 1559 1560 /** 0111 1101 1111 0011 WAIT */ 1561 1562 tprintf("waiting...\n"); 1563 1564 /** 0111 101w 00sr dest XCHG.size src,dest */ 1565 1566 sc = decode_srcdest4 (sr, w); 1567 dc = decode_srcdest4 (dest, w); 1568 a = get_src (sc); 1569 b = get_src (dc); 1570 put_dest (dc, a); 1571 put_dest (sc, b); 1572 1573 /** 0111 011w 0001 dest XOR.size #IMM,dest */ 1574 1575 UNARY_UOP; 1576 imm = IMM(w); 1577 tprintf ("%x ^ %x = %x\n", v, imm, v ^ imm); 1578 v ^= imm; 1579 set_sz (v, w+1); 1580 put_dest (dc, v); 1581 1582 /** 1000 100w srcx dest XOR.size src,dest */ 1583 1584 BINARY_UOP; 1585 tprintf ("%x ^ %x = %x\n", a, b, a ^ b); 1586 v = a ^ b; 1587 set_sz (v, w+1); 1588 put_dest (dc, v); 1589 1590 /** OP */ 1591/** */ 1592 1593 return step_result; 1594} 1595