sim/m32c/srcdest.c

   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 }