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