1 /* srcdest.c --- decoding M32C addressing modes. 2 3 Copyright (C) 2005, 2007, 2008, 2009, 2010, 2011 4 Free Software Foundation, Inc. 5 Contributed by Red Hat, Inc. 6 7 This file is part of the GNU simulators. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along 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 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 () 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 () 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 () 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 () 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 sd.bytes = bw ? 2 : 1; 122 sd.mem = (destcode >= 6) ? 1 : 0; 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 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 sd.bytes = w ? 2 : 3; 204 sd.mem = (destcode >= 6) ? 1 : 0; 205 static const char *dc_wnames[16] = { "r0", "r1", "r2", "r3", 206 "a0", "a1", "[a0]", "[a1]", 207 "disp8[a0]", "disp8[a1]", "disp8[sb]", "disp8[fb]", 208 "disp20[a0]", "disp20[a1]", "disp16[sb]", "abs16" 209 }; 210 static const char *dc_anames[4] = { "r0l", "r0h", "r1l", "r1h" }; 211 212 if (trace) 213 { 214 const char *n = dc_wnames[destcode]; 215 if (w == 0 && destcode <= 3) 216 n = dc_anames[destcode]; 217 if (!the_bits) 218 the_bits = bits (destcode, 4); 219 printf ("decode: %s : %s\n", the_bits, n); 220 the_bits = 0; 221 } 222 223 switch (destcode) 224 { 225 case 0x0: 226 sd.u.reg = w ? r0 : r2r0; 227 break; 228 case 0x1: 229 sd.u.reg = w ? r1 : r2r0; 230 break; 231 case 0x2: 232 sd.u.reg = w ? r2 : r3r1; 233 break; 234 case 0x3: 235 sd.u.reg = w ? r3 : r3r1; 236 break; 237 case 0x4: 238 sd.u.reg = w ? a0 : a1a0; 239 break; 240 case 0x5: 241 sd.u.reg = w ? a1 : a1a0; 242 break; 243 case 0x6: 244 sd.u.addr = get_reg (a0); 245 break; 246 case 0x7: 247 sd.u.addr = get_reg (a1); 248 break; 249 case 0x8: 250 sd.u.addr = get_reg (a0) + disp8 (); 251 break; 252 case 0x9: 253 sd.u.addr = get_reg (a1) + disp8 (); 254 break; 255 case 0xa: 256 sd.u.addr = get_reg (sb) + disp8 (); 257 break; 258 case 0xb: 259 sd.u.addr = get_reg (fb) + sign_ext (disp8 (), 8); 260 break; 261 case 0xc: 262 sd.u.addr = get_reg (a0) + disp20 (); 263 break; 264 case 0xd: 265 sd.u.addr = get_reg (a1) + disp20 (); 266 break; 267 case 0xe: 268 sd.u.addr = get_reg (sb) + disp16 (); 269 break; 270 case 0xf: 271 sd.u.addr = disp16 (); 272 break; 273 default: 274 abort (); 275 } 276 if (sd.mem) 277 sd.u.addr &= addr_mask; 278 return sd; 279 } 280 281 srcdest 282 decode_dest3 (int destcode, int bw) 283 { 284 static char map[8] = { -1, -1, -1, 1, 0, 10, 11, 15 }; 285 286 the_bits = bits (destcode, 3); 287 return decode_srcdest4 (map[destcode], bw); 288 } 289 290 srcdest 291 decode_src2 (int srccode, int bw, int d) 292 { 293 static char map[4] = { 0, 10, 11, 15 }; 294 295 the_bits = bits (srccode, 2); 296 return decode_srcdest4 (srccode ? map[srccode] : 1 - d, bw); 297 } 298 299 static struct 300 { 301 reg_id b_regno; 302 reg_id w_regno; 303 int is_memory; 304 int disp_bytes; 305 char *name; 306 } modes23[] = 307 { 308 { 309 a0, a0, 1, 0, "[A0]"}, /* 0 0 0 0 0 */ 310 { 311 a1, a1, 1, 0, "[A1]"}, /* 0 0 0 0 1 */ 312 { 313 a0, a0, 0, 0, "A0"}, /* 0 0 0 1 0 */ 314 { 315 a1, a1, 0, 0, "A1"}, /* 0 0 0 1 1 */ 316 { 317 a0, a0, 1, 1, "dsp:8[A0]"}, /* 0 0 1 0 0 */ 318 { 319 a1, a1, 1, 1, "dsp:8[A1]"}, /* 0 0 1 0 1 */ 320 { 321 sb, sb, 1, 1, "dsp:8[SB]"}, /* 0 0 1 1 0 */ 322 { 323 fb, fb, 1, -1, "dsp:8[FB]"}, /* 0 0 1 1 1 */ 324 { 325 a0, a0, 1, 2, "dsp:16[A0]"}, /* 0 1 0 0 0 */ 326 { 327 a1, a1, 1, 2, "dsp:16[A1]"}, /* 0 1 0 0 1 */ 328 { 329 sb, sb, 1, 2, "dsp:16[SB]"}, /* 0 1 0 1 0 */ 330 { 331 fb, fb, 1, -2, "dsp:16[FB]"}, /* 0 1 0 1 1 */ 332 { 333 a0, a0, 1, 3, "dsp:24[A0]"}, /* 0 1 1 0 0 */ 334 { 335 a1, a1, 1, 3, "dsp:24[A1]"}, /* 0 1 1 0 1 */ 336 { 337 mem, mem, 1, 3, "abs24"}, /* 0 1 1 1 0 */ 338 { 339 mem, mem, 1, 2, "abs16"}, /* 0 1 1 1 1 */ 340 { 341 r0h, r2, 0, 0, "R0H/R2"}, /* 1 0 0 0 0 */ 342 { 343 r1h, r3, 0, 0, "R1H/R3"}, /* 1 0 0 0 1 */ 344 { 345 r0l, r0, 0, 0, "R0L/R0"}, /* 1 0 0 1 0 */ 346 { 347 r1l, r1, 0, 0, "R1L/R1"}, /* 1 0 0 1 1 */ 348 }; 349 350 static srcdest 351 decode_sd23 (int bbb, int bb, int bytes, int ind, int add) 352 { 353 srcdest sd; 354 int code = (bbb << 2) | bb; 355 356 if (code >= sizeof (modes23) / sizeof (modes23[0])) 357 abort (); 358 359 if (trace) 360 { 361 char *b1 = ""; 362 char *b2 = ""; 363 char ad[30]; 364 if (ind) 365 { 366 b1 = "["; 367 b2 = "]"; 368 } 369 if (add) 370 sprintf (ad, "%+d", add); 371 else 372 ad[0] = 0; 373 if (!the_bits) 374 the_bits = bits (code, 4); 375 printf ("decode: %s (%d) : %s%s%s%s\n", the_bits, code, b1, 376 modes23[code].name, ad, b2); 377 the_bits = 0; 378 } 379 380 sd.bytes = bytes; 381 sd.mem = modes23[code].is_memory; 382 if (sd.mem) 383 { 384 if (modes23[code].w_regno == mem) 385 sd.u.addr = 0; 386 else 387 sd.u.addr = get_reg (modes23[code].w_regno); 388 switch (modes23[code].disp_bytes) 389 { 390 case 1: 391 sd.u.addr += disp8 (); 392 break; 393 case 2: 394 sd.u.addr += disp16 (); 395 break; 396 case -1: 397 sd.u.addr += sign_ext (disp8 (), 8); 398 break; 399 case -2: 400 sd.u.addr += sign_ext (disp16 (), 16); 401 break; 402 case 3: 403 sd.u.addr += disp24 (); 404 break; 405 default: 406 break; 407 } 408 if (add) 409 sd.u.addr += add; 410 if (ind) 411 sd.u.addr = mem_get_si (sd.u.addr & membus_mask); 412 sd.u.addr &= membus_mask; 413 } 414 else 415 { 416 sd.u.reg = (bytes > 1) ? modes23[code].w_regno : modes23[code].b_regno; 417 if (bytes == 3 || bytes == 4) 418 { 419 switch (sd.u.reg) 420 { 421 case r0: 422 sd.u.reg = r2r0; 423 break; 424 case r1: 425 sd.u.reg = r3r1; 426 break; 427 case r2: 428 abort (); 429 case r3: 430 abort (); 431 default:; 432 } 433 } 434 435 } 436 return sd; 437 } 438 439 srcdest 440 decode_dest23 (int ddd, int dd, int bytes) 441 { 442 return decode_sd23 (ddd, dd, bytes, dest_indirect, dest_addend); 443 } 444 445 srcdest 446 decode_src23 (int sss, int ss, int bytes) 447 { 448 return decode_sd23 (sss, ss, bytes, src_indirect, src_addend); 449 } 450 451 srcdest 452 decode_dest2 (int dd, int bytes) 453 { 454 /* r0l/r0, abs16, dsp:8[SB], dsp:8[FB] */ 455 static char map[4] = { 0x12, 0x0f, 0x06, 0x07 }; 456 457 the_bits = bits (dd, 2); 458 return decode_sd23 (map[dd] >> 2, map[dd] & 3, bytes, dest_indirect, 459 dest_addend); 460 } 461 462 srcdest 463 decode_src3 (int sss, int bytes) 464 { 465 /* r0, r1, a0, a1, r2, r3, N/A, N/A */ 466 static char map[8] = { 0x12, 0x13, 0x02, 0x03, 0x10, 0x11, 0, 0 }; 467 468 the_bits = bits (sss, 3); 469 return decode_sd23 (map[sss] >> 2, map[sss] & 3, bytes, src_indirect, 470 src_addend); 471 } 472 473 srcdest 474 decode_dest1 (int destcode, int bw) 475 { 476 the_bits = bits (destcode, 1); 477 return decode_srcdest4 (destcode, bw); 478 } 479 480 srcdest 481 decode_cr (int crcode) 482 { 483 static int regcode[] = { 0, intbl, intbh, flags, isp, sp, sb, fb }; 484 srcdest sd; 485 sd.mem = 0; 486 sd.bytes = 2; 487 sd.u.reg = regcode[crcode & 7]; 488 return sd; 489 } 490 491 srcdest 492 decode_cr_b (int crcode, int bank) 493 { 494 /* FIXME: intbl, intbh, isp */ 495 static int regcode[3][8] = { 496 {0, 0, flags, 0, 0, 0, 0, 0}, 497 {intb, sp, sb, fb, 0, 0, 0, isp}, 498 {0, 0, 0, 0, 0, 0, 0, 0} 499 }; 500 srcdest sd; 501 sd.mem = 0; 502 sd.bytes = bank ? 3 : 2; 503 sd.u.reg = regcode[bank][crcode & 7]; 504 return sd; 505 } 506 507 srcdest 508 widen_sd (srcdest sd) 509 { 510 sd.bytes *= 2; 511 if (!sd.mem) 512 switch (sd.u.reg) 513 { 514 case r0l: 515 sd.u.reg = r0; 516 break; 517 case r0: 518 sd.u.reg = r2r0; 519 break; 520 case r1l: 521 sd.u.reg = r1; 522 break; 523 case r1: 524 sd.u.reg = r3r1; 525 break; 526 case a0: 527 if (A16) 528 sd.u.reg = a1a0; 529 break; 530 default: 531 break; 532 } 533 return sd; 534 } 535 536 srcdest 537 reg_sd (reg_id reg) 538 { 539 srcdest rv; 540 rv.bytes = reg_bytes[reg]; 541 rv.mem = 0; 542 rv.u.reg = reg; 543 return rv; 544 } 545 546 int 547 get_src (srcdest sd) 548 { 549 int v; 550 if (sd.mem) 551 { 552 switch (sd.bytes) 553 { 554 case 1: 555 v = mem_get_qi (sd.u.addr); 556 break; 557 case 2: 558 v = mem_get_hi (sd.u.addr); 559 break; 560 case 3: 561 v = mem_get_psi (sd.u.addr); 562 break; 563 case 4: 564 v = mem_get_si (sd.u.addr); 565 break; 566 default: 567 abort (); 568 } 569 } 570 else 571 { 572 v = get_reg (sd.u.reg); 573 switch (sd.bytes) 574 { 575 case 1: 576 v &= 0xff; 577 break; 578 case 2: 579 v &= 0xffff; 580 break; 581 case 3: 582 v &= 0xffffff; 583 break; 584 } 585 } 586 return v; 587 } 588 589 void 590 put_dest (srcdest sd, int v) 591 { 592 if (sd.mem) 593 { 594 switch (sd.bytes) 595 { 596 case 1: 597 mem_put_qi (sd.u.addr, v); 598 break; 599 case 2: 600 mem_put_hi (sd.u.addr, v); 601 break; 602 case 3: 603 mem_put_psi (sd.u.addr, v); 604 break; 605 case 4: 606 mem_put_si (sd.u.addr, v); 607 break; 608 } 609 } 610 else 611 { 612 switch (sd.bytes) 613 { 614 case 1: 615 v &= 0xff; 616 break; 617 case 2: 618 v &= 0xffff; 619 break; 620 case 3: 621 v &= 0xffffff; 622 break; 623 } 624 put_reg (sd.u.reg, v); 625 } 626 } 627 628 srcdest 629 decode_bit (int destcode) 630 { 631 srcdest sd; 632 int addr = 0; 633 static const char *dc_names[] = { "r0", "r1", "r2", "r3", 634 "a0", "a1", "[a0]", "[a1]", 635 "disp8[a0]", "disp8[a1]", "disp8[sb]", "disp8[fb]", 636 "disp16[a0]", "disp16[a1]", "disp16[sb]", "abs16" 637 }; 638 639 if (trace) 640 { 641 const char *the_bits = bits (destcode, 4); 642 printf ("decode: %s : %s\n", the_bits, dc_names[destcode]); 643 } 644 645 switch (destcode) 646 { 647 case 0: 648 sd.u.reg = r0; 649 break; 650 case 1: 651 sd.u.reg = r1; 652 break; 653 case 2: 654 sd.u.reg = r2; 655 break; 656 case 3: 657 sd.u.reg = r3; 658 break; 659 case 4: 660 sd.u.reg = a0; 661 break; 662 case 5: 663 sd.u.reg = a1; 664 break; 665 case 6: 666 addr = get_reg (a0); 667 break; 668 case 7: 669 addr = get_reg (a1); 670 break; 671 case 8: 672 addr = get_reg (a0) + disp8 (); 673 break; 674 case 9: 675 addr = get_reg (a1) + disp8 (); 676 break; 677 case 10: 678 addr = get_reg (sb) * 8 + disp8 (); 679 break; 680 case 11: 681 addr = get_reg (fb) * 8 + sign_ext (disp8 (), 8); 682 break; 683 case 12: 684 addr = get_reg (a0) + disp16 (); 685 break; 686 case 13: 687 addr = get_reg (a1) + disp16 (); 688 break; 689 case 14: 690 addr = get_reg (sb) + disp16 (); 691 break; 692 case 15: 693 addr = disp16 (); 694 break; 695 } 696 697 if (destcode < 6) 698 { 699 int d = disp8 (); 700 sd.mem = 0; 701 sd.mask = 1 << (d & 0x0f); 702 } 703 else 704 { 705 addr &= addr_mask; 706 sd.mem = 1; 707 sd.mask = 1 << (addr & 7); 708 sd.u.addr = addr >> 3; 709 } 710 return sd; 711 } 712 713 srcdest 714 decode_bit11 (int op0) 715 { 716 srcdest sd; 717 sd.mask = 1 << (op0 & 7); 718 sd.mem = 1; 719 sd.u.addr = get_reg (sb) + disp8 (); 720 return sd; 721 } 722 723 int 724 get_bit (srcdest sd) 725 { 726 int b; 727 if (sd.mem) 728 b = mem_get_qi (sd.u.addr) & sd.mask; 729 else 730 b = get_reg (sd.u.reg) & sd.mask; 731 return b ? 1 : 0; 732 } 733 734 void 735 put_bit (srcdest sd, int val) 736 { 737 int b; 738 if (sd.mem) 739 b = mem_get_qi (sd.u.addr); 740 else 741 b = get_reg (sd.u.reg); 742 if (val) 743 b |= sd.mask; 744 else 745 b &= ~sd.mask; 746 if (sd.mem) 747 mem_put_qi (sd.u.addr, b); 748 else 749 put_reg (sd.u.reg, b); 750 } 751 752 int 753 get_bit2 (srcdest sd, int bit) 754 { 755 int b; 756 if (sd.mem) 757 b = mem_get_qi (sd.u.addr + (bit >> 3)) & (1 << (bit & 7)); 758 else 759 b = get_reg (sd.u.reg) & (1 << bit); 760 return b ? 1 : 0; 761 } 762 763 void 764 put_bit2 (srcdest sd, int bit, int val) 765 { 766 int b; 767 if (sd.mem) 768 b = mem_get_qi (sd.u.addr + (bit >> 3)); 769 else 770 b = get_reg (sd.u.reg); 771 if (val) 772 b |= (1 << (bit & 7)); 773 else 774 b &= ~(1 << (bit & 7)); 775 if (sd.mem) 776 mem_put_qi (sd.u.addr + (bit >> 3), b); 777 else 778 put_reg (sd.u.reg, b); 779 } 780