sim/m32c/srcdest.c

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