1 /* srcdest.c --- decoding M32C addressing modes. 2 3 Copyright (C) 2005-2016 Free Software Foundation, Inc. 4 Contributed by Red Hat, Inc. 5 6 This file is part of the GNU simulators. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21 22 #include <stdio.h> 23 #include <stdlib.h> 24 25 #include "cpu.h" 26 #include "mem.h" 27 28 static int src_indirect = 0; 29 static int dest_indirect = 0; 30 static int src_addend = 0; 31 static int dest_addend = 0; 32 33 static int 34 disp8 (void) 35 { 36 int rv; 37 int tsave = trace; 38 39 if (trace == 1) 40 trace = 0; 41 rv = mem_get_qi (get_reg (pc)); 42 regs.r_pc++; 43 trace = tsave; 44 return rv; 45 } 46 47 static int 48 disp16 (void) 49 { 50 int rv; 51 int tsave = trace; 52 53 if (trace == 1) 54 trace = 0; 55 rv = mem_get_hi (get_reg (pc)); 56 regs.r_pc += 2; 57 trace = tsave; 58 return rv; 59 } 60 61 static int 62 disp24 (void) 63 { 64 int rv; 65 int tsave = trace; 66 67 if (trace == 1) 68 trace = 0; 69 rv = mem_get_psi (get_reg (pc)); 70 regs.r_pc += 3; 71 trace = tsave; 72 return rv; 73 } 74 75 static int 76 disp20 (void) 77 { 78 return disp24 () & 0x000fffff; 79 } 80 81 const char * 82 bits (int v, int b) 83 { 84 static char buf[17]; 85 char *bp = buf + 16; 86 *bp = 0; 87 while (b) 88 { 89 *--bp = (v & 1) ? '1' : '0'; 90 v >>= 1; 91 b--; 92 } 93 return bp; 94 } 95 96 static const char *the_bits = 0; 97 98 void 99 decode_indirect (int si, int di) 100 { 101 src_indirect = si; 102 dest_indirect = di; 103 if (trace && (si || di)) 104 printf ("indirect: s:%d d:%d\n", si, di); 105 } 106 107 void 108 decode_index (int sa, int da) 109 { 110 src_addend = sa; 111 dest_addend = da; 112 if (trace && (sa || da)) 113 printf ("index: s:%d d:%d\n", sa, da); 114 } 115 116 srcdest 117 decode_srcdest4 (int destcode, int bw) 118 { 119 srcdest sd; 120 static const char *dc_wnames[16] = { "r0", "r1", "r2", "r3", 121 "a0", "a1", "[a0]", "[a1]", 122 "disp8[a0]", "disp8[a1]", "disp8[sb]", "disp8[fb]", 123 "disp16[a0]", "disp16[a1]", "disp16[sb]", "disp16" 124 }; 125 static const char *dc_bnames[4] = { "r0l", "r0h", "r1l", "r1h" };; 126 127 sd.bytes = bw ? 2 : 1; 128 sd.mem = (destcode >= 6) ? 1 : 0; 129 130 if (trace) 131 { 132 const char *n = dc_wnames[destcode]; 133 if (bw == 0 && destcode <= 3) 134 n = dc_bnames[destcode]; 135 if (!the_bits) 136 the_bits = bits (destcode, 4); 137 printf ("decode: %s (%d) : %s\n", the_bits, destcode, n); 138 the_bits = 0; 139 } 140 141 switch (destcode) 142 { 143 case 0x0: 144 sd.u.reg = bw ? r0 : r0l; 145 break; 146 case 0x1: 147 sd.u.reg = bw ? r1 : r0h; 148 break; 149 case 0x2: 150 sd.u.reg = bw ? r2 : r1l; 151 break; 152 case 0x3: 153 sd.u.reg = bw ? r3 : r1h; 154 break; 155 case 0x4: 156 sd.u.reg = a0; 157 break; 158 case 0x5: 159 sd.u.reg = a1; 160 break; 161 case 0x6: 162 sd.u.addr = get_reg (a0); 163 break; 164 case 0x7: 165 sd.u.addr = get_reg (a1); 166 break; 167 case 0x8: 168 sd.u.addr = get_reg (a0) + disp8 (); 169 break; 170 case 0x9: 171 sd.u.addr = get_reg (a1) + disp8 (); 172 break; 173 case 0xa: 174 sd.u.addr = get_reg (sb) + disp8 (); 175 break; 176 case 0xb: 177 sd.u.addr = get_reg (fb) + sign_ext (disp8 (), 8); 178 break; 179 case 0xc: 180 sd.u.addr = get_reg (a0) + disp16 (); 181 break; 182 case 0xd: 183 sd.u.addr = get_reg (a1) + disp16 (); 184 break; 185 case 0xe: 186 sd.u.addr = get_reg (sb) + disp16 (); 187 break; 188 case 0xf: 189 sd.u.addr = disp16 (); 190 break; 191 default: 192 abort (); 193 } 194 if (sd.mem) 195 sd.u.addr &= addr_mask; 196 return sd; 197 } 198 199 srcdest 200 decode_jumpdest (int destcode, int w) 201 { 202 srcdest sd; 203 static const char *dc_wnames[16] = { "r0", "r1", "r2", "r3", 204 "a0", "a1", "[a0]", "[a1]", 205 "disp8[a0]", "disp8[a1]", "disp8[sb]", "disp8[fb]", 206 "disp20[a0]", "disp20[a1]", "disp16[sb]", "abs16" 207 }; 208 static const char *dc_anames[4] = { "r0l", "r0h", "r1l", "r1h" }; 209 210 sd.bytes = w ? 2 : 3; 211 sd.mem = (destcode >= 6) ? 1 : 0; 212 213 if (trace) 214 { 215 const char *n = dc_wnames[destcode]; 216 if (w == 0 && destcode <= 3) 217 n = dc_anames[destcode]; 218 if (!the_bits) 219 the_bits = bits (destcode, 4); 220 printf ("decode: %s : %s\n", the_bits, n); 221 the_bits = 0; 222 } 223 224 switch (destcode) 225 { 226 case 0x0: 227 sd.u.reg = w ? r0 : r2r0; 228 break; 229 case 0x1: 230 sd.u.reg = w ? r1 : r2r0; 231 break; 232 case 0x2: 233 sd.u.reg = w ? r2 : r3r1; 234 break; 235 case 0x3: 236 sd.u.reg = w ? r3 : r3r1; 237 break; 238 case 0x4: 239 sd.u.reg = w ? a0 : a1a0; 240 break; 241 case 0x5: 242 sd.u.reg = w ? a1 : a1a0; 243 break; 244 case 0x6: 245 sd.u.addr = get_reg (a0); 246 break; 247 case 0x7: 248 sd.u.addr = get_reg (a1); 249 break; 250 case 0x8: 251 sd.u.addr = get_reg (a0) + disp8 (); 252 break; 253 case 0x9: 254 sd.u.addr = get_reg (a1) + disp8 (); 255 break; 256 case 0xa: 257 sd.u.addr = get_reg (sb) + disp8 (); 258 break; 259 case 0xb: 260 sd.u.addr = get_reg (fb) + sign_ext (disp8 (), 8); 261 break; 262 case 0xc: 263 sd.u.addr = get_reg (a0) + disp20 (); 264 break; 265 case 0xd: 266 sd.u.addr = get_reg (a1) + disp20 (); 267 break; 268 case 0xe: 269 sd.u.addr = get_reg (sb) + disp16 (); 270 break; 271 case 0xf: 272 sd.u.addr = disp16 (); 273 break; 274 default: 275 abort (); 276 } 277 if (sd.mem) 278 sd.u.addr &= addr_mask; 279 return sd; 280 } 281 282 srcdest 283 decode_dest3 (int destcode, int bw) 284 { 285 static char map[8] = { -1, -1, -1, 1, 0, 10, 11, 15 }; 286 287 the_bits = bits (destcode, 3); 288 return decode_srcdest4 (map[destcode], bw); 289 } 290 291 srcdest 292 decode_src2 (int srccode, int bw, int d) 293 { 294 static char map[4] = { 0, 10, 11, 15 }; 295 296 the_bits = bits (srccode, 2); 297 return decode_srcdest4 (srccode ? map[srccode] : 1 - d, bw); 298 } 299 300 static struct 301 { 302 reg_id b_regno; 303 reg_id w_regno; 304 int is_memory; 305 int disp_bytes; 306 char *name; 307 } modes23[] = 308 { 309 { 310 a0, a0, 1, 0, "[A0]"}, /* 0 0 0 0 0 */ 311 { 312 a1, a1, 1, 0, "[A1]"}, /* 0 0 0 0 1 */ 313 { 314 a0, a0, 0, 0, "A0"}, /* 0 0 0 1 0 */ 315 { 316 a1, a1, 0, 0, "A1"}, /* 0 0 0 1 1 */ 317 { 318 a0, a0, 1, 1, "dsp:8[A0]"}, /* 0 0 1 0 0 */ 319 { 320 a1, a1, 1, 1, "dsp:8[A1]"}, /* 0 0 1 0 1 */ 321 { 322 sb, sb, 1, 1, "dsp:8[SB]"}, /* 0 0 1 1 0 */ 323 { 324 fb, fb, 1, -1, "dsp:8[FB]"}, /* 0 0 1 1 1 */ 325 { 326 a0, a0, 1, 2, "dsp:16[A0]"}, /* 0 1 0 0 0 */ 327 { 328 a1, a1, 1, 2, "dsp:16[A1]"}, /* 0 1 0 0 1 */ 329 { 330 sb, sb, 1, 2, "dsp:16[SB]"}, /* 0 1 0 1 0 */ 331 { 332 fb, fb, 1, -2, "dsp:16[FB]"}, /* 0 1 0 1 1 */ 333 { 334 a0, a0, 1, 3, "dsp:24[A0]"}, /* 0 1 1 0 0 */ 335 { 336 a1, a1, 1, 3, "dsp:24[A1]"}, /* 0 1 1 0 1 */ 337 { 338 mem, mem, 1, 3, "abs24"}, /* 0 1 1 1 0 */ 339 { 340 mem, mem, 1, 2, "abs16"}, /* 0 1 1 1 1 */ 341 { 342 r0h, r2, 0, 0, "R0H/R2"}, /* 1 0 0 0 0 */ 343 { 344 r1h, r3, 0, 0, "R1H/R3"}, /* 1 0 0 0 1 */ 345 { 346 r0l, r0, 0, 0, "R0L/R0"}, /* 1 0 0 1 0 */ 347 { 348 r1l, r1, 0, 0, "R1L/R1"}, /* 1 0 0 1 1 */ 349 }; 350 351 static srcdest 352 decode_sd23 (int bbb, int bb, int bytes, int ind, int add) 353 { 354 srcdest sd; 355 int code = (bbb << 2) | bb; 356 357 if (code >= sizeof (modes23) / sizeof (modes23[0])) 358 abort (); 359 360 if (trace) 361 { 362 char *b1 = ""; 363 char *b2 = ""; 364 char ad[30]; 365 if (ind) 366 { 367 b1 = "["; 368 b2 = "]"; 369 } 370 if (add) 371 sprintf (ad, "%+d", add); 372 else 373 ad[0] = 0; 374 if (!the_bits) 375 the_bits = bits (code, 4); 376 printf ("decode: %s (%d) : %s%s%s%s\n", the_bits, code, b1, 377 modes23[code].name, ad, b2); 378 the_bits = 0; 379 } 380 381 sd.bytes = bytes; 382 sd.mem = modes23[code].is_memory; 383 if (sd.mem) 384 { 385 if (modes23[code].w_regno == mem) 386 sd.u.addr = 0; 387 else 388 sd.u.addr = get_reg (modes23[code].w_regno); 389 switch (modes23[code].disp_bytes) 390 { 391 case 1: 392 sd.u.addr += disp8 (); 393 break; 394 case 2: 395 sd.u.addr += disp16 (); 396 break; 397 case -1: 398 sd.u.addr += sign_ext (disp8 (), 8); 399 break; 400 case -2: 401 sd.u.addr += sign_ext (disp16 (), 16); 402 break; 403 case 3: 404 sd.u.addr += disp24 (); 405 break; 406 default: 407 break; 408 } 409 if (add) 410 sd.u.addr += add; 411 if (ind) 412 sd.u.addr = mem_get_si (sd.u.addr & membus_mask); 413 sd.u.addr &= membus_mask; 414 } 415 else 416 { 417 sd.u.reg = (bytes > 1) ? modes23[code].w_regno : modes23[code].b_regno; 418 if (bytes == 3 || bytes == 4) 419 { 420 switch (sd.u.reg) 421 { 422 case r0: 423 sd.u.reg = r2r0; 424 break; 425 case r1: 426 sd.u.reg = r3r1; 427 break; 428 case r2: 429 abort (); 430 case r3: 431 abort (); 432 default:; 433 } 434 } 435 436 } 437 return sd; 438 } 439 440 srcdest 441 decode_dest23 (int ddd, int dd, int bytes) 442 { 443 return decode_sd23 (ddd, dd, bytes, dest_indirect, dest_addend); 444 } 445 446 srcdest 447 decode_src23 (int sss, int ss, int bytes) 448 { 449 return decode_sd23 (sss, ss, bytes, src_indirect, src_addend); 450 } 451 452 srcdest 453 decode_dest2 (int dd, int bytes) 454 { 455 /* r0l/r0, abs16, dsp:8[SB], dsp:8[FB] */ 456 static char map[4] = { 0x12, 0x0f, 0x06, 0x07 }; 457 458 the_bits = bits (dd, 2); 459 return decode_sd23 (map[dd] >> 2, map[dd] & 3, bytes, dest_indirect, 460 dest_addend); 461 } 462 463 srcdest 464 decode_src3 (int sss, int bytes) 465 { 466 /* r0, r1, a0, a1, r2, r3, N/A, N/A */ 467 static char map[8] = { 0x12, 0x13, 0x02, 0x03, 0x10, 0x11, 0, 0 }; 468 469 the_bits = bits (sss, 3); 470 return decode_sd23 (map[sss] >> 2, map[sss] & 3, bytes, src_indirect, 471 src_addend); 472 } 473 474 srcdest 475 decode_dest1 (int destcode, int bw) 476 { 477 the_bits = bits (destcode, 1); 478 return decode_srcdest4 (destcode, bw); 479 } 480 481 srcdest 482 decode_cr (int crcode) 483 { 484 static int regcode[] = { 0, intbl, intbh, flags, isp, sp, sb, fb }; 485 srcdest sd; 486 sd.mem = 0; 487 sd.bytes = 2; 488 sd.u.reg = regcode[crcode & 7]; 489 return sd; 490 } 491 492 srcdest 493 decode_cr_b (int crcode, int bank) 494 { 495 /* FIXME: intbl, intbh, isp */ 496 static int regcode[3][8] = { 497 {0, 0, flags, 0, 0, 0, 0, 0}, 498 {intb, sp, sb, fb, 0, 0, 0, isp}, 499 {0, 0, 0, 0, 0, 0, 0, 0} 500 }; 501 srcdest sd; 502 sd.mem = 0; 503 sd.bytes = bank ? 3 : 2; 504 sd.u.reg = regcode[bank][crcode & 7]; 505 return sd; 506 } 507 508 srcdest 509 widen_sd (srcdest sd) 510 { 511 sd.bytes *= 2; 512 if (!sd.mem) 513 switch (sd.u.reg) 514 { 515 case r0l: 516 sd.u.reg = r0; 517 break; 518 case r0: 519 sd.u.reg = r2r0; 520 break; 521 case r1l: 522 sd.u.reg = r1; 523 break; 524 case r1: 525 sd.u.reg = r3r1; 526 break; 527 case a0: 528 if (A16) 529 sd.u.reg = a1a0; 530 break; 531 default: 532 break; 533 } 534 return sd; 535 } 536 537 srcdest 538 reg_sd (reg_id reg) 539 { 540 srcdest rv; 541 rv.bytes = reg_bytes[reg]; 542 rv.mem = 0; 543 rv.u.reg = reg; 544 return rv; 545 } 546 547 int 548 get_src (srcdest sd) 549 { 550 int v; 551 if (sd.mem) 552 { 553 switch (sd.bytes) 554 { 555 case 1: 556 v = mem_get_qi (sd.u.addr); 557 break; 558 case 2: 559 v = mem_get_hi (sd.u.addr); 560 break; 561 case 3: 562 v = mem_get_psi (sd.u.addr); 563 break; 564 case 4: 565 v = mem_get_si (sd.u.addr); 566 break; 567 default: 568 abort (); 569 } 570 } 571 else 572 { 573 v = get_reg (sd.u.reg); 574 switch (sd.bytes) 575 { 576 case 1: 577 v &= 0xff; 578 break; 579 case 2: 580 v &= 0xffff; 581 break; 582 case 3: 583 v &= 0xffffff; 584 break; 585 } 586 } 587 return v; 588 } 589 590 void 591 put_dest (srcdest sd, int v) 592 { 593 if (sd.mem) 594 { 595 switch (sd.bytes) 596 { 597 case 1: 598 mem_put_qi (sd.u.addr, v); 599 break; 600 case 2: 601 mem_put_hi (sd.u.addr, v); 602 break; 603 case 3: 604 mem_put_psi (sd.u.addr, v); 605 break; 606 case 4: 607 mem_put_si (sd.u.addr, v); 608 break; 609 } 610 } 611 else 612 { 613 switch (sd.bytes) 614 { 615 case 1: 616 v &= 0xff; 617 break; 618 case 2: 619 v &= 0xffff; 620 break; 621 case 3: 622 v &= 0xffffff; 623 break; 624 } 625 put_reg (sd.u.reg, v); 626 } 627 } 628 629 srcdest 630 decode_bit (int destcode) 631 { 632 srcdest sd; 633 int addr = 0; 634 static const char *dc_names[] = { "r0", "r1", "r2", "r3", 635 "a0", "a1", "[a0]", "[a1]", 636 "disp8[a0]", "disp8[a1]", "disp8[sb]", "disp8[fb]", 637 "disp16[a0]", "disp16[a1]", "disp16[sb]", "abs16" 638 }; 639 640 if (trace) 641 { 642 const char *the_bits = bits (destcode, 4); 643 printf ("decode: %s : %s\n", the_bits, dc_names[destcode]); 644 } 645 646 switch (destcode) 647 { 648 case 0: 649 sd.u.reg = r0; 650 break; 651 case 1: 652 sd.u.reg = r1; 653 break; 654 case 2: 655 sd.u.reg = r2; 656 break; 657 case 3: 658 sd.u.reg = r3; 659 break; 660 case 4: 661 sd.u.reg = a0; 662 break; 663 case 5: 664 sd.u.reg = a1; 665 break; 666 case 6: 667 addr = get_reg (a0); 668 break; 669 case 7: 670 addr = get_reg (a1); 671 break; 672 case 8: 673 addr = get_reg (a0) + disp8 (); 674 break; 675 case 9: 676 addr = get_reg (a1) + disp8 (); 677 break; 678 case 10: 679 addr = get_reg (sb) * 8 + disp8 (); 680 break; 681 case 11: 682 addr = get_reg (fb) * 8 + sign_ext (disp8 (), 8); 683 break; 684 case 12: 685 addr = get_reg (a0) + disp16 (); 686 break; 687 case 13: 688 addr = get_reg (a1) + disp16 (); 689 break; 690 case 14: 691 addr = get_reg (sb) + disp16 (); 692 break; 693 case 15: 694 addr = disp16 (); 695 break; 696 } 697 698 if (destcode < 6) 699 { 700 int d = disp8 (); 701 sd.mem = 0; 702 sd.mask = 1 << (d & 0x0f); 703 } 704 else 705 { 706 addr &= addr_mask; 707 sd.mem = 1; 708 sd.mask = 1 << (addr & 7); 709 sd.u.addr = addr >> 3; 710 } 711 return sd; 712 } 713 714 srcdest 715 decode_bit11 (int op0) 716 { 717 srcdest sd; 718 sd.mask = 1 << (op0 & 7); 719 sd.mem = 1; 720 sd.u.addr = get_reg (sb) + disp8 (); 721 return sd; 722 } 723 724 int 725 get_bit (srcdest sd) 726 { 727 int b; 728 if (sd.mem) 729 b = mem_get_qi (sd.u.addr) & sd.mask; 730 else 731 b = get_reg (sd.u.reg) & sd.mask; 732 return b ? 1 : 0; 733 } 734 735 void 736 put_bit (srcdest sd, int val) 737 { 738 int b; 739 if (sd.mem) 740 b = mem_get_qi (sd.u.addr); 741 else 742 b = get_reg (sd.u.reg); 743 if (val) 744 b |= sd.mask; 745 else 746 b &= ~sd.mask; 747 if (sd.mem) 748 mem_put_qi (sd.u.addr, b); 749 else 750 put_reg (sd.u.reg, b); 751 } 752 753 int 754 get_bit2 (srcdest sd, int bit) 755 { 756 int b; 757 if (sd.mem) 758 b = mem_get_qi (sd.u.addr + (bit >> 3)) & (1 << (bit & 7)); 759 else 760 b = get_reg (sd.u.reg) & (1 << bit); 761 return b ? 1 : 0; 762 } 763 764 void 765 put_bit2 (srcdest sd, int bit, int val) 766 { 767 int b; 768 if (sd.mem) 769 b = mem_get_qi (sd.u.addr + (bit >> 3)); 770 else 771 b = get_reg (sd.u.reg); 772 if (val) 773 b |= (1 << (bit & 7)); 774 else 775 b &= ~(1 << (bit & 7)); 776 if (sd.mem) 777 mem_put_qi (sd.u.addr + (bit >> 3), b); 778 else 779 put_reg (sd.u.reg, b); 780 } 781