sim/m32c/srcdest.c

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