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