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