sim/m32c/srcdest.c

   1 /* srcdest.c --- decoding M32C addressing modes.
   2
   3 Copyright (C) 2005, 2007 Free Software Foundation, Inc.
   4 Contributed by Red Hat, Inc.
   5
   6 This file is part of the GNU simulators.
   7
   8 The GNU simulators are free software; you can redistribute them and/or
   9 modify them under the terms of the GNU General Public License as
  10 published by the Free Software Foundation; either version 2 of the
  11 License, or (at your option) any later version.
  12
  13 The GNU simulators are distributed in the hope that they will be
  14 useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16 General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with the GNU simulators; if not, write to the Free Software
  20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21 02110-1301, USA  */
  22
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26
  27 #include "cpu.h"
  28 #include "mem.h"
  29
  30 static int src_indirect = 0;
  31 static int dest_indirect = 0;
  32 static int src_addend = 0;
  33 static int dest_addend = 0;
  34
  35 static int
  36 disp8 ()
  37 {
  38   int rv;
  39   int tsave = trace;
  40
  41   if (trace == 1)
  42     trace = 0;
  43   rv = mem_get_qi (get_reg (pc));
  44   regs.r_pc++;
  45   trace = tsave;
  46   return rv;
  47 }
  48
  49 static int
  50 disp16 ()
  51 {
  52   int rv;
  53   int tsave = trace;
  54
  55   if (trace == 1)
  56     trace = 0;
  57   rv = mem_get_hi (get_reg (pc));
  58   regs.r_pc += 2;
  59   trace = tsave;
  60   return rv;
  61 }
  62
  63 static int
  64 disp24 ()
  65 {
  66   int rv;
  67   int tsave = trace;
  68
  69   if (trace == 1)
  70     trace = 0;
  71   rv = mem_get_psi (get_reg (pc));
  72   regs.r_pc += 3;
  73   trace = tsave;
  74   return rv;
  75 }
  76
  77 static int
  78 disp20 ()
  79 {
  80   return disp24 () & 0x000fffff;
  81 }
  82
  83 const char *
  84 bits (int v, int b)
  85 {
  86   static char buf[17];
  87   char *bp = buf + 16;
  88   *bp = 0;
  89   while (b)
  90     {
  91       *--bp = (v & 1) ? '1' : '0';
  92       v >>= 1;
  93       b--;
  94     }
  95   return bp;
  96 }
  97
  98 static const char *the_bits = 0;
  99
 100 void
 101 decode_indirect (int si, int di)
 102 {
 103   src_indirect = si;
 104   dest_indirect = di;
 105   if (trace && (si || di))
 106     printf ("indirect: s:%d d:%d\n", si, di);
 107 }
 108
 109 void
 110 decode_index (int sa, int da)
 111 {
 112   src_addend = sa;
 113   dest_addend = da;
 114   if (trace && (sa || da))
 115     printf ("index: s:%d d:%d\n", sa, da);
 116 }
 117
 118 srcdest
 119 decode_srcdest4 (int destcode, int bw)
 120 {
 121   srcdest sd;
 122   sd.bytes = bw ? 2 : 1;
 123   sd.mem = (destcode >= 6) ? 1 : 0;
 124   static const char *dc_wnames[16] = { "r0", "r1", "r2", "r3",
 125     "a0", "a1", "[a0]", "[a1]",
 126     "disp8[a0]", "disp8[a1]", "disp8[sb]", "disp8[fb]",
 127     "disp16[a0]", "disp16[a1]", "disp16[sb]", "disp16"
 128   };
 129   static const char *dc_bnames[4] = { "r0l", "r0h", "r1l", "r1h" };;
 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   sd.bytes = w ? 2 : 3;
 205   sd.mem = (destcode >= 6) ? 1 : 0;
 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   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 }