sim/cr16/interp.c

   1 /* Simulation code for the CR16 processor.
   2    Copyright (C) 2008-2015 Free Software Foundation, Inc.
   3    Contributed by M Ranga Swami Reddy <MR.Swami.Reddy@nsc.com>
   4
   5    This file is part of GDB, the GNU debugger.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3, or (at your option)
  10    any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program. If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "config.h"
  21 #include <inttypes.h>
  22 #include <signal.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include "bfd.h"
  26 #include "gdb/callback.h"
  27 #include "gdb/remote-sim.h"
  28
  29 #include "sim-main.h"
  30 #include "sim-options.h"
  31
  32 #include "gdb/sim-cr16.h"
  33 #include "gdb/signals.h"
  34 #include "opcode/cr16.h"
  35
  36 int cr16_debug;
  37
  38 host_callback *cr16_callback;
  39
  40 uint32 OP[4];
  41 uint32 sign_flag;
  42
  43 static struct hash_entry *lookup_hash (uint64 ins, int size);
  44 static void get_operands (operand_desc *s, uint64 mcode, int isize, int nops);
  45 static INLINE uint8 *map_memory (unsigned phys_addr);
  46
  47 #define MAX_HASH  16
  48
  49 struct hash_entry
  50 {
  51   struct hash_entry *next;
  52   uint32 opcode;
  53   uint32 mask;
  54   int format;
  55   int size;
  56   struct simops *ops;
  57 };
  58
  59 struct hash_entry hash_table[MAX_HASH+1];
  60
  61 INLINE static long
  62 hash(unsigned long long insn, int format)
  63 {
  64   unsigned int i = 4, tmp;
  65   if (format)
  66     {
  67       while ((insn >> i) != 0) i +=4;
  68
  69       return ((insn >> (i-4)) & 0xf); /* Use last 4 bits as hask key.  */
  70     }
  71   return ((insn & 0xF)); /* Use last 4 bits as hask key.  */
  72 }
  73
  74
  75 INLINE static struct hash_entry *
  76 lookup_hash (uint64 ins, int size)
  77 {
  78   uint32 mask;
  79   struct hash_entry *h;
  80
  81   h = &hash_table[hash(ins,1)];
  82
  83
  84   mask = (((1 << (32 - h->mask)) -1) << h->mask);
  85
  86  /* Adjuest mask for branch with 2 word instructions.  */
  87   if ((h->ops->mnimonic != NULL) &&
  88       ((streq(h->ops->mnimonic,"b") && h->size == 2)))
  89     mask = 0xff0f0000;
  90
  91
  92   while ((ins & mask) != (BIN(h->opcode, h->mask)))
  93     {
  94       if (h->next == NULL)
  95         {
  96           State.exception = SIGILL;
  97           State.pc_changed = 1; /* Don't increment the PC. */
  98           return NULL;
  99         }
 100       h = h->next;
 101
 102       mask = (((1 << (32 - h->mask)) -1) << h->mask);
 103      /* Adjuest mask for branch with 2 word instructions.  */
 104      if ((streq(h->ops->mnimonic,"b")) && h->size == 2)
 105        mask = 0xff0f0000;
 106
 107      }
 108    return (h);
 109 }
 110
 111 INLINE static void
 112 get_operands (operand_desc *s, uint64 ins, int isize, int nops)
 113 {
 114   uint32 i, opn = 0, start_bit = 0, op_type = 0;
 115   int32 op_size = 0, mask = 0;
 116
 117   if (isize == 1) /* Trunkcate the extra 16 bits of INS.  */
 118     ins = ins >> 16;
 119
 120   for (i=0; i < 4; ++i,++opn)
 121     {
 122       if (s[opn].op_type == dummy) break;
 123
 124       op_type = s[opn].op_type;
 125       start_bit = s[opn].shift;
 126       op_size = cr16_optab[op_type].bit_size;
 127
 128       switch (op_type)
 129         {
 130           case imm3: case imm4: case imm5: case imm6:
 131             {
 132              if (isize == 1)
 133                OP[i] = ((ins >> 4) & ((1 << op_size) -1));
 134              else
 135                OP[i] = ((ins >> (32 - start_bit)) & ((1 << op_size) -1));
 136
 137              if (OP[i] & ((long)1 << (op_size -1)))
 138                {
 139                  sign_flag = 1;
 140                  OP[i] = ~(OP[i]) + 1;
 141                }
 142              OP[i] = (unsigned long int)(OP[i] & (((long)1 << op_size) -1));
 143             }
 144             break;
 145
 146           case uimm3: case uimm3_1: case uimm4_1:
 147              switch (isize)
 148                {
 149               case 1:
 150                OP[i] = ((ins >> 4) & ((1 << op_size) -1)); break;
 151               case 2:
 152                OP[i] = ((ins >> (32 - start_bit)) & ((1 << op_size) -1));break;
 153               default: /* for case 3.  */
 154                OP[i] = ((ins >> (16 + start_bit)) & ((1 << op_size) -1)); break;
 155                break;
 156                }
 157             break;
 158
 159           case uimm4:
 160             switch (isize)
 161               {
 162               case 1:
 163                  if (start_bit == 20)
 164                    OP[i] = ((ins >> 4) & ((1 << op_size) -1));
 165                  else
 166                    OP[i] = (ins & ((1 << op_size) -1));
 167                  break;
 168               case 2:
 169                  OP[i] = ((ins >> start_bit) & ((1 << op_size) -1));
 170                  break;
 171               case 3:
 172                  OP[i] = ((ins >> (start_bit + 16)) & ((1 << op_size) -1));
 173                  break;
 174               default:
 175                  OP[i] = ((ins >> start_bit) & ((1 << op_size) -1));
 176                  break;
 177               }
 178             break;
 179
 180           case imm16: case uimm16:
 181             OP[i] = ins & 0xFFFF;
 182             break;
 183
 184           case uimm20: case imm20:
 185             OP[i] = ins & (((long)1 << op_size) - 1);
 186             break;
 187
 188           case imm32: case uimm32:
 189             OP[i] = ins & 0xFFFFFFFF;
 190             break;
 191
 192           case uimm5: break; /*NOT USED.  */
 193             OP[i] = ins & ((1 << op_size) - 1); break;
 194
 195           case disps5:
 196             OP[i] = (ins >> 4) & ((1 << 4) - 1);
 197             OP[i] = (OP[i] * 2) + 2;
 198             if (OP[i] & ((long)1 << 5))
 199               {
 200                 sign_flag = 1;
 201                 OP[i] = ~(OP[i]) + 1;
 202                 OP[i] = (unsigned long int)(OP[i] & 0x1F);
 203               }
 204             break;
 205
 206           case dispe9:
 207             OP[i] = ((((ins >> 8) & 0xf) << 4) | (ins & 0xf));
 208             OP[i] <<= 1;
 209             if (OP[i] & ((long)1 << 8))
 210               {
 211                 sign_flag = 1;
 212                 OP[i] = ~(OP[i]) + 1;
 213                 OP[i] = (unsigned long int)(OP[i] & 0xFF);
 214               }
 215             break;
 216
 217           case disps17:
 218             OP[i] = (ins & 0xFFFF);
 219             if (OP[i] & 1)
 220               {
 221                 OP[i] = (OP[i] & 0xFFFE);
 222                 sign_flag = 1;
 223                 OP[i] = ~(OP[i]) + 1;
 224                 OP[i] = (unsigned long int)(OP[i] & 0xFFFF);
 225               }
 226             break;
 227
 228           case disps25:
 229             if (isize == 2)
 230               OP[i] = (ins & 0xFFFFFF);
 231             else
 232               OP[i] = (ins & 0xFFFF) | (((ins >> 24) & 0xf) << 16) |
 233                       (((ins >> 16) & 0xf) << 20);
 234
 235             if (OP[i] & 1)
 236               {
 237                 OP[i] = (OP[i] & 0xFFFFFE);
 238                 sign_flag = 1;
 239                 OP[i] = ~(OP[i]) + 1;
 240                 OP[i] = (unsigned long int)(OP[i] & 0xFFFFFF);
 241               }
 242             break;
 243
 244           case abs20:
 245             if (isize == 3)
 246               OP[i] = (ins) & 0xFFFFF;
 247             else
 248               OP[i] = (ins >> start_bit) & 0xFFFFF;
 249             break;
 250           case abs24:
 251             if (isize == 3)
 252               OP[i] = ((ins & 0xFFFF) | (((ins >> 16) & 0xf) << 20)
 253                        | (((ins >> 24) & 0xf) << 16));
 254             else
 255               OP[i] = (ins >> 16) & 0xFFFFFF;
 256             break;
 257
 258           case rra:
 259           case rbase: break; /* NOT USED.  */
 260           case rbase_disps20:  case rbase_dispe20:
 261           case rpbase_disps20: case rpindex_disps20:
 262             OP[i] = ((((ins >> 24)&0xf) << 16)|((ins) & 0xFFFF));
 263             OP[++i] = (ins >> 16) & 0xF;     /* get 4 bit for reg.  */
 264             break;
 265           case rpbase_disps0:
 266             OP[i] = 0;                       /* 4 bit disp const.  */
 267             OP[++i] = (ins) & 0xF;           /* get 4 bit for reg.  */
 268             break;
 269           case rpbase_dispe4:
 270             OP[i] = ((ins >> 8) & 0xF) * 2;  /* 4 bit disp const.   */
 271             OP[++i] = (ins) & 0xF;           /* get 4 bit for reg.  */
 272             break;
 273           case rpbase_disps4:
 274             OP[i] = ((ins >> 8) & 0xF);      /* 4 bit disp const.  */
 275             OP[++i] = (ins) & 0xF;           /* get 4 bit for reg.  */
 276             break;
 277           case rpbase_disps16:
 278             OP[i] = (ins) & 0xFFFF;
 279             OP[++i] = (ins >> 16) & 0xF;     /* get 4 bit for reg.  */
 280             break;
 281           case rpindex_disps0:
 282             OP[i] = 0;
 283             OP[++i] = (ins >> 4) & 0xF;      /* get 4 bit for reg.  */
 284             OP[++i] = (ins >> 8) & 0x1;      /* get 1 bit for index-reg.  */
 285             break;
 286           case rpindex_disps14:
 287             OP[i] = (ins) & 0x3FFF;
 288             OP[++i] = (ins >> 14) & 0x1;     /* get 1 bit for index-reg.  */
 289             OP[++i] = (ins >> 16) & 0xF;     /* get 4 bit for reg.  */
 290           case rindex7_abs20:
 291           case rindex8_abs20:
 292             OP[i] = (ins) & 0xFFFFF;
 293             OP[++i] = (ins >> 24) & 0x1;     /* get 1 bit for index-reg.  */
 294             OP[++i] = (ins >> 20) & 0xF;     /* get 4 bit for reg.  */
 295             break;
 296           case regr: case regp: case pregr: case pregrp:
 297               switch(isize)
 298                 {
 299                   case 1:
 300                     if (start_bit == 20) OP[i] = (ins >> 4) & 0xF;
 301                     else if (start_bit == 16) OP[i] = ins & 0xF;
 302                     break;
 303                   case 2: OP[i] = (ins >>  start_bit) & 0xF; break;
 304                   case 3: OP[i] = (ins >> (start_bit + 16)) & 0xF; break;
 305                 }
 306                break;
 307           case cc:
 308             {
 309               if (isize == 1) OP[i] = (ins >> 4) & 0xF;
 310               else if (isize == 2)  OP[i] = (ins >> start_bit)  & 0xF;
 311               else  OP[i] = (ins >> (start_bit + 16)) & 0xF;
 312               break;
 313             }
 314           default: break;
 315         }
 316
 317       /* For ESC on uimm4_1 operand.  */
 318       if (op_type == uimm4_1)
 319         if (OP[i] == 9)
 320            OP[i] = -1;
 321
 322       /* For increment by 1.  */
 323       if ((op_type == pregr) || (op_type == pregrp))
 324           OP[i] += 1;
 325    }
 326   /* FIXME: for tracing, update values that need to be updated each
 327             instruction decode cycle */
 328   State.trace.psw = PSR;
 329 }
 330
 331 static int
 332 do_run (SIM_DESC sd, uint64 mcode)
 333 {
 334   host_callback *cr16_callback = STATE_CALLBACK (sd);
 335   struct simops *s= Simops;
 336   struct hash_entry *h;
 337   char func[12]="\0";
 338   uint8 *iaddr;
 339 #ifdef DEBUG
 340   if ((cr16_debug & DEBUG_INSTRUCTION) != 0)
 341     (*cr16_callback->printf_filtered) (cr16_callback, "do_long 0x%x\n", mcode);
 342 #endif
 343
 344    h =  lookup_hash(mcode, 1);
 345
 346   if ((h == NULL) || (h->opcode == 0))
 347     return 0;
 348
 349    if (h->size == 3)
 350     {
 351       iaddr = imem_addr ((uint32)PC + 2);
 352        mcode = (mcode << 16) | get_longword( iaddr );
 353     }
 354
 355   /* Re-set OP list.  */
 356   OP[0] = OP[1] = OP[2] = OP[3] = sign_flag = 0;
 357
 358   /* for push/pop/pushrtn with RA instructions. */
 359   if ((h->format & REG_LIST) && (mcode & 0x800000))
 360     OP[2] = 1; /* Set 1 for RA operand.  */
 361
 362   /* numops == 0 means, no operands.  */
 363   if (((h->ops) != NULL) && (((h->ops)->numops) != 0))
 364     get_operands ((h->ops)->operands, mcode, h->size, (h->ops)->numops);
 365
 366   //State.ins_type = h->flags;
 367
 368   (h->ops->func)();
 369
 370   return h->size;
 371 }
 372
 373 static void
 374 sim_size (int power)
 375 {
 376   int i;
 377   for (i = 0; i < IMEM_SEGMENTS; i++)
 378     {
 379       if (State.mem.insn[i])
 380         free (State.mem.insn[i]);
 381     }
 382   for (i = 0; i < DMEM_SEGMENTS; i++)
 383     {
 384       if (State.mem.data[i])
 385         free (State.mem.data[i]);
 386     }
 387   for (i = 0; i < UMEM_SEGMENTS; i++)
 388     {
 389       if (State.mem.unif[i])
 390         free (State.mem.unif[i]);
 391     }
 392   /* Always allocate dmem segment 0.  This contains the IMAP and DMAP
 393      registers. */
 394   State.mem.data[0] = calloc (1, SEGMENT_SIZE);
 395 }
 396
 397 /* For tracing - leave info on last access around. */
 398 static char *last_segname = "invalid";
 399 static char *last_from = "invalid";
 400 static char *last_to = "invalid";
 401
 402 enum
 403   {
 404     IMAP0_OFFSET = 0xff00,
 405     DMAP0_OFFSET = 0xff08,
 406     DMAP2_SHADDOW = 0xff04,
 407     DMAP2_OFFSET = 0xff0c
 408   };
 409
 410 static unsigned long
 411 dmap_register (void *regcache, int reg_nr)
 412 {
 413   uint8 *raw = map_memory (SIM_CR16_MEMORY_DATA
 414                            + DMAP0_OFFSET + 2 * reg_nr);
 415   return READ_16 (raw);
 416 }
 417
 418 static unsigned long
 419 imap_register (void *regcache, int reg_nr)
 420 {
 421   uint8 *raw = map_memory (SIM_CR16_MEMORY_DATA
 422                            + IMAP0_OFFSET + 2 * reg_nr);
 423   return READ_16 (raw);
 424 }
 425
 426 /* Given a virtual address in the DMAP address space, translate it
 427    into a physical address. */
 428
 429 unsigned long
 430 sim_cr16_translate_dmap_addr (unsigned long offset,
 431                               int nr_bytes,
 432                               unsigned long *phys,
 433                               void *regcache,
 434                               unsigned long (*dmap_register) (void *regcache,
 435                                                               int reg_nr))
 436 {
 437   short map;
 438   int regno;
 439   last_from = "logical-data";
 440   if (offset >= DMAP_BLOCK_SIZE * SIM_CR16_NR_DMAP_REGS)
 441     {
 442       /* Logical address out side of data segments, not supported */
 443       return 0;
 444     }
 445   regno = (offset / DMAP_BLOCK_SIZE);
 446   offset = (offset % DMAP_BLOCK_SIZE);
 447
 448 #if 1
 449   if ((offset % DMAP_BLOCK_SIZE) + nr_bytes > DMAP_BLOCK_SIZE)
 450     {
 451       /* Don't cross a BLOCK boundary */
 452       nr_bytes = DMAP_BLOCK_SIZE - (offset % DMAP_BLOCK_SIZE);
 453     }
 454   map = dmap_register (regcache, regno);
 455   if (regno == 3)
 456     {
 457       /* Always maps to data memory */
 458       int iospi = (offset / 0x1000) % 4;
 459       int iosp = (map >> (4 * (3 - iospi))) % 0x10;
 460       last_to = "io-space";
 461       *phys = (SIM_CR16_MEMORY_DATA + (iosp * 0x10000) + 0xc000 + offset);
 462     }
 463   else
 464     {
 465       int sp = ((map & 0x3000) >> 12);
 466       int segno = (map & 0x3ff);
 467       switch (sp)
 468         {
 469         case 0: /* 00: Unified memory */
 470           *phys = SIM_CR16_MEMORY_UNIFIED + (segno * DMAP_BLOCK_SIZE) + offset;
 471           last_to = "unified";
 472           break;
 473         case 1: /* 01: Instruction Memory */
 474           *phys = SIM_CR16_MEMORY_INSN + (segno * DMAP_BLOCK_SIZE) + offset;
 475           last_to = "chip-insn";
 476           break;
 477         case 2: /* 10: Internal data memory */
 478           *phys = SIM_CR16_MEMORY_DATA + (segno << 16) + (regno * DMAP_BLOCK_SIZE) + offset;
 479           last_to = "chip-data";
 480           break;
 481         case 3: /* 11: Reserved */
 482           return 0;
 483         }
 484     }
 485 #endif
 486   return nr_bytes;
 487 }
 488
 489 /* Given a virtual address in the IMAP address space, translate it
 490    into a physical address. */
 491
 492 unsigned long
 493 sim_cr16_translate_imap_addr (unsigned long offset,
 494                               int nr_bytes,
 495                               unsigned long *phys,
 496                               void *regcache,
 497                               unsigned long (*imap_register) (void *regcache,
 498                                                               int reg_nr))
 499 {
 500   short map;
 501   int regno;
 502   int sp;
 503   int segno;
 504   last_from = "logical-insn";
 505   if (offset >= (IMAP_BLOCK_SIZE * SIM_CR16_NR_IMAP_REGS))
 506     {
 507       /* Logical address outside of IMAP segments, not supported */
 508       return 0;
 509     }
 510   regno = (offset / IMAP_BLOCK_SIZE);
 511   offset = (offset % IMAP_BLOCK_SIZE);
 512   if (offset + nr_bytes > IMAP_BLOCK_SIZE)
 513     {
 514       /* Don't cross a BLOCK boundary */
 515       nr_bytes = IMAP_BLOCK_SIZE - offset;
 516     }
 517   map = imap_register (regcache, regno);
 518   sp = (map & 0x3000) >> 12;
 519   segno = (map & 0x007f);
 520   switch (sp)
 521     {
 522     case 0: /* 00: unified memory */
 523       *phys = SIM_CR16_MEMORY_UNIFIED + (segno << 17) + offset;
 524       last_to = "unified";
 525       break;
 526     case 1: /* 01: instruction memory */
 527       *phys = SIM_CR16_MEMORY_INSN + (IMAP_BLOCK_SIZE * regno) + offset;
 528       last_to = "chip-insn";
 529       break;
 530     case 2: /*10*/
 531       /* Reserved. */
 532       return 0;
 533     case 3: /* 11: for testing  - instruction memory */
 534       offset = (offset % 0x800);
 535       *phys = SIM_CR16_MEMORY_INSN + offset;
 536       if (offset + nr_bytes > 0x800)
 537         /* don't cross VM boundary */
 538         nr_bytes = 0x800 - offset;
 539       last_to = "test-insn";
 540       break;
 541     }
 542   return nr_bytes;
 543 }
 544
 545 unsigned long
 546 sim_cr16_translate_addr (unsigned long memaddr, int nr_bytes,
 547                          unsigned long *targ_addr, void *regcache,
 548                          unsigned long (*dmap_register) (void *regcache,
 549                                                          int reg_nr),
 550                          unsigned long (*imap_register) (void *regcache,
 551                                                          int reg_nr))
 552 {
 553   unsigned long phys;
 554   unsigned long seg;
 555   unsigned long off;
 556
 557   last_from = "unknown";
 558   last_to = "unknown";
 559
 560   seg = (memaddr >> 24);
 561   off = (memaddr & 0xffffffL);
 562
 563   switch (seg)
 564     {
 565     case 0x00:                        /* Physical unified memory */
 566       last_from = "phys-unified";
 567       last_to = "unified";
 568       phys = SIM_CR16_MEMORY_UNIFIED + off;
 569       if ((off % SEGMENT_SIZE) + nr_bytes > SEGMENT_SIZE)
 570         nr_bytes = SEGMENT_SIZE - (off % SEGMENT_SIZE);
 571       break;
 572
 573     case 0x01:                        /* Physical instruction memory */
 574       last_from = "phys-insn";
 575       last_to = "chip-insn";
 576       phys = SIM_CR16_MEMORY_INSN + off;
 577       if ((off % SEGMENT_SIZE) + nr_bytes > SEGMENT_SIZE)
 578         nr_bytes = SEGMENT_SIZE - (off % SEGMENT_SIZE);
 579       break;
 580
 581     case 0x02:                        /* Physical data memory segment */
 582       last_from = "phys-data";
 583       last_to = "chip-data";
 584       phys = SIM_CR16_MEMORY_DATA + off;
 585       if ((off % SEGMENT_SIZE) + nr_bytes > SEGMENT_SIZE)
 586         nr_bytes = SEGMENT_SIZE - (off % SEGMENT_SIZE);
 587       break;
 588
 589     case 0x10:                        /* in logical data address segment */
 590       nr_bytes = sim_cr16_translate_dmap_addr (off, nr_bytes, &phys, regcache,
 591                                                dmap_register);
 592       break;
 593
 594     case 0x11:                        /* in logical instruction address segment */
 595       nr_bytes = sim_cr16_translate_imap_addr (off, nr_bytes, &phys, regcache,
 596                                                imap_register);
 597       break;
 598
 599     default:
 600       return 0;
 601     }
 602
 603   *targ_addr = phys;
 604   return nr_bytes;
 605 }
 606
 607 /* Return a pointer into the raw buffer designated by phys_addr.  It
 608    is assumed that the client has already ensured that the access
 609    isn't going to cross a segment boundary. */
 610
 611 uint8 *
 612 map_memory (unsigned phys_addr)
 613 {
 614   uint8 **memory;
 615   uint8 *raw;
 616   unsigned offset;
 617   int segment = ((phys_addr >> 24) & 0xff);
 618
 619   switch (segment)
 620     {
 621
 622     case 0x00: /* Unified memory */
 623       {
 624         memory = &State.mem.unif[(phys_addr / SEGMENT_SIZE) % UMEM_SEGMENTS];
 625         last_segname = "umem";
 626         break;
 627       }
 628
 629     case 0x01: /* On-chip insn memory */
 630       {
 631         memory = &State.mem.insn[(phys_addr / SEGMENT_SIZE) % IMEM_SEGMENTS];
 632         last_segname = "imem";
 633         break;
 634       }
 635
 636     case 0x02: /* On-chip data memory */
 637       {
 638         if ((phys_addr & 0xff00) == 0xff00)
 639           {
 640             phys_addr = (phys_addr & 0xffff);
 641             if (phys_addr == DMAP2_SHADDOW)
 642               {
 643                 phys_addr = DMAP2_OFFSET;
 644                 last_segname = "dmap";
 645               }
 646             else
 647               last_segname = "reg";
 648           }
 649         else
 650           last_segname = "dmem";
 651         memory = &State.mem.data[(phys_addr / SEGMENT_SIZE) % DMEM_SEGMENTS];
 652         break;
 653       }
 654
 655     default:
 656       /* OOPS! */
 657       last_segname = "scrap";
 658       return State.mem.fault;
 659     }
 660
 661   if (*memory == NULL)
 662     {
 663       *memory = calloc (1, SEGMENT_SIZE);
 664       if (*memory == NULL)
 665         {
 666           (*cr16_callback->printf_filtered) (cr16_callback, "Malloc failed.\n");
 667           return State.mem.fault;
 668         }
 669     }
 670
 671   offset = (phys_addr % SEGMENT_SIZE);
 672   raw = *memory + offset;
 673   return raw;
 674 }
 675
 676 /* Transfer data to/from simulated memory.  Since a bug in either the
 677    simulated program or in gdb or the simulator itself may cause a
 678    bogus address to be passed in, we need to do some sanity checking
 679    on addresses to make sure they are within bounds.  When an address
 680    fails the bounds check, treat it as a zero length read/write rather
 681    than aborting the entire run. */
 682
 683 static int
 684 xfer_mem (SIM_DESC sd, SIM_ADDR virt,
 685           unsigned char *buffer,
 686           int size,
 687           int write_p)
 688 {
 689   host_callback *cr16_callback = STATE_CALLBACK (sd);
 690   uint8 *memory;
 691   unsigned long phys;
 692   int phys_size;
 693   phys_size = sim_cr16_translate_addr (virt, size, &phys, NULL,
 694                                        dmap_register, imap_register);
 695   if (phys_size == 0)
 696     return 0;
 697
 698   memory = map_memory (phys);
 699
 700 #ifdef DEBUG
 701   if ((cr16_debug & DEBUG_INSTRUCTION) != 0)
 702     {
 703       (*cr16_callback->printf_filtered)
 704         (cr16_callback,
 705          "sim_%s %d bytes: 0x%08lx (%s) -> 0x%08lx (%s) -> 0x%08lx (%s)\n",
 706              (write_p ? "write" : "read"),
 707          phys_size, virt, last_from,
 708          phys, last_to,
 709          (long) memory, last_segname);
 710     }
 711 #endif
 712
 713   if (write_p)
 714     {
 715       memcpy (memory, buffer, phys_size);
 716     }
 717   else
 718     {
 719       memcpy (buffer, memory, phys_size);
 720     }
 721
 722   return phys_size;
 723 }
 724
 725
 726 int
 727 sim_write (SIM_DESC sd, SIM_ADDR addr, const unsigned char *buffer, int size)
 728 {
 729   /* FIXME: this should be performing a virtual transfer */
 730   return xfer_mem (sd, addr, buffer, size, 1);
 731 }
 732
 733 int
 734 sim_read (SIM_DESC sd, SIM_ADDR addr, unsigned char *buffer, int size)
 735 {
 736   /* FIXME: this should be performing a virtual transfer */
 737   return xfer_mem (sd, addr, buffer, size, 0);
 738 }
 739
 740 static void
 741 free_state (SIM_DESC sd)
 742 {
 743   if (STATE_MODULES (sd) != NULL)
 744     sim_module_uninstall (sd);
 745   sim_cpu_free_all (sd);
 746   sim_state_free (sd);
 747 }
 748
 749 SIM_DESC trace_sd = NULL;
 750
 751 SIM_DESC
 752 sim_open (SIM_OPEN_KIND kind, struct host_callback_struct *cb, struct bfd *abfd, char **argv)
 753 {
 754   struct simops *s;
 755   struct hash_entry *h;
 756   static int init_p = 0;
 757   char **p;
 758   int i;
 759   SIM_DESC sd = sim_state_alloc (kind, cb);
 760   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 761
 762   /* The cpu data is kept in a separately allocated chunk of memory.  */
 763   if (sim_cpu_alloc_all (sd, 1, /*cgen_cpu_max_extra_bytes ()*/0) != SIM_RC_OK)
 764     {
 765       free_state (sd);
 766       return 0;
 767     }
 768
 769   if (sim_pre_argv_init (sd, argv[0]) != SIM_RC_OK)
 770     {
 771       free_state (sd);
 772       return 0;
 773     }
 774
 775   /* getopt will print the error message so we just have to exit if this fails.
 776      FIXME: Hmmm...  in the case of gdb we need getopt to call
 777      print_filtered.  */
 778   if (sim_parse_args (sd, argv) != SIM_RC_OK)
 779     {
 780       free_state (sd);
 781       return 0;
 782     }
 783
 784   /* Check for/establish the a reference program image.  */
 785   if (sim_analyze_program (sd,
 786                            (STATE_PROG_ARGV (sd) != NULL
 787                             ? *STATE_PROG_ARGV (sd)
 788                             : NULL), abfd) != SIM_RC_OK)
 789     {
 790       free_state (sd);
 791       return 0;
 792     }
 793
 794   /* Configure/verify the target byte order and other runtime
 795      configuration options.  */
 796   if (sim_config (sd) != SIM_RC_OK)
 797     {
 798       sim_module_uninstall (sd);
 799       return 0;
 800     }
 801
 802   if (sim_post_argv_init (sd) != SIM_RC_OK)
 803     {
 804       /* Uninstall the modules to avoid memory leaks,
 805          file descriptor leaks, etc.  */
 806       sim_module_uninstall (sd);
 807       return 0;
 808     }
 809
 810   trace_sd = sd;
 811   cr16_callback = cb;
 812
 813   /* put all the opcodes in the hash table.  */
 814   if (!init_p++)
 815     {
 816       for (s = Simops; s->func; s++)
 817         {
 818           switch(32 - s->mask)
 819             {
 820             case 0x4:
 821                h = &hash_table[hash(s->opcode, 0)];
 822                break;
 823
 824             case 0x7:
 825                if (((s->opcode << 1) >> 4) != 0)
 826                   h = &hash_table[hash((s->opcode << 1) >> 4, 0)];
 827                else
 828                   h = &hash_table[hash((s->opcode << 1), 0)];
 829                break;
 830
 831             case 0x8:
 832                if ((s->opcode >> 4) != 0)
 833                   h = &hash_table[hash(s->opcode >> 4, 0)];
 834                else
 835                   h = &hash_table[hash(s->opcode, 0)];
 836                break;
 837
 838             case 0x9:
 839                if (((s->opcode  >> 1) >> 4) != 0)
 840                  h = &hash_table[hash((s->opcode >>1) >> 4, 0)];
 841                else
 842                  h = &hash_table[hash((s->opcode >> 1), 0)];
 843                break;
 844
 845             case 0xa:
 846                if ((s->opcode >> 8) != 0)
 847                  h = &hash_table[hash(s->opcode >> 8, 0)];
 848                else if ((s->opcode >> 4) != 0)
 849                  h = &hash_table[hash(s->opcode >> 4, 0)];
 850                else
 851                  h = &hash_table[hash(s->opcode, 0)];
 852                break;
 853
 854             case 0xc:
 855                if ((s->opcode >> 8) != 0)
 856                  h = &hash_table[hash(s->opcode >> 8, 0)];
 857                else if ((s->opcode >> 4) != 0)
 858                  h = &hash_table[hash(s->opcode >> 4, 0)];
 859                else
 860                  h = &hash_table[hash(s->opcode, 0)];
 861                break;
 862
 863             case 0xd:
 864                if (((s->opcode >> 1) >> 8) != 0)
 865                  h = &hash_table[hash((s->opcode >>1) >> 8, 0)];
 866                else if (((s->opcode >> 1) >> 4) != 0)
 867                  h = &hash_table[hash((s->opcode >>1) >> 4, 0)];
 868                else
 869                  h = &hash_table[hash((s->opcode >>1), 0)];
 870                break;
 871
 872             case 0x10:
 873                if ((s->opcode >> 0xc) != 0)
 874                  h = &hash_table[hash(s->opcode >> 12, 0)];
 875                else if ((s->opcode >> 8) != 0)
 876                  h = &hash_table[hash(s->opcode >> 8, 0)];
 877                else if ((s->opcode >> 4) != 0)
 878                  h = &hash_table[hash(s->opcode >> 4, 0)];
 879                else
 880                  h = &hash_table[hash(s->opcode, 0)];
 881                break;
 882
 883             case 0x14:
 884                if ((s->opcode >> 16) != 0)
 885                  h = &hash_table[hash(s->opcode >> 16, 0)];
 886                else if ((s->opcode >> 12) != 0)
 887                  h = &hash_table[hash(s->opcode >> 12, 0)];
 888                else if ((s->opcode >> 8) != 0)
 889                  h = &hash_table[hash(s->opcode >> 8, 0)];
 890                else if ((s->opcode >> 4) != 0)
 891                  h = &hash_table[hash(s->opcode >> 4, 0)];
 892                else
 893                  h = &hash_table[hash(s->opcode, 0)];
 894                break;
 895             default:
 896               break;
 897             }
 898
 899           /* go to the last entry in the chain.  */
 900           while (h->next)
 901             h = h->next;
 902
 903           if (h->ops)
 904             {
 905               h->next = (struct hash_entry *) calloc(1,sizeof(struct hash_entry));
 906               if (!h->next)
 907                 perror ("malloc failure");
 908
 909               h = h->next;
 910             }
 911           h->ops = s;
 912           h->mask = s->mask;
 913           h->opcode = s->opcode;
 914           h->format = s->format;
 915           h->size = s->size;
 916         }
 917     }
 918
 919   /* reset the processor state */
 920   if (!State.mem.data[0])
 921     sim_size (1);
 922   sim_create_inferior ((SIM_DESC) 1, NULL, NULL, NULL);
 923
 924   return sd;
 925 }
 926
 927
 928 void
 929 sim_close (SIM_DESC sd, int quitting)
 930 {
 931   /* Nothing to do.  */
 932 }
 933
 934 uint8 *
 935 dmem_addr (uint32 offset)
 936 {
 937   unsigned long phys;
 938   uint8 *mem;
 939   int phys_size;
 940
 941   /* Note: DMEM address range is 0..0x10000. Calling code can compute
 942      things like ``0xfffe + 0x0e60 == 0x10e5d''.  Since offset's type
 943      is uint16 this is modulo'ed onto 0x0e5d. */
 944
 945   phys_size = sim_cr16_translate_dmap_addr (offset, 1, &phys, NULL,
 946                                             dmap_register);
 947   if (phys_size == 0)
 948     {
 949       mem = State.mem.fault;
 950     }
 951   else
 952     mem = map_memory (phys);
 953 #ifdef DEBUG
 954   if ((cr16_debug & DEBUG_MEMORY))
 955     {
 956       (*cr16_callback->printf_filtered)
 957         (cr16_callback,
 958          "mem: 0x%08x (%s) -> 0x%08lx %d (%s) -> 0x%08lx (%s)\n",
 959          offset, last_from,
 960          phys, phys_size, last_to,
 961          (long) mem, last_segname);
 962     }
 963 #endif
 964   return mem;
 965 }
 966
 967 uint8 *
 968 imem_addr (uint32 offset)
 969 {
 970   unsigned long phys;
 971   uint8 *mem;
 972   int phys_size = sim_cr16_translate_imap_addr (offset, 1, &phys, NULL,
 973                                                 imap_register);
 974   if (phys_size == 0)
 975     {
 976       return State.mem.fault;
 977     }
 978   mem = map_memory (phys);
 979 #ifdef DEBUG
 980   if ((cr16_debug & DEBUG_MEMORY))
 981     {
 982       (*cr16_callback->printf_filtered)
 983         (cr16_callback,
 984          "mem: 0x%08x (%s) -> 0x%08lx %d (%s) -> 0x%08lx (%s)\n",
 985          offset, last_from,
 986          phys, phys_size, last_to,
 987          (long) mem, last_segname);
 988     }
 989 #endif
 990   return mem;
 991 }
 992
 993 static int stop_simulator = 0;
 994
 995 int
 996 sim_stop (SIM_DESC sd)
 997 {
 998   stop_simulator = 1;
 999   return 1;
1000 }
1001
1002
1003 /* Run (or resume) the program.  */
1004 void
1005 sim_resume (SIM_DESC sd, int step, int siggnal)
1006 {
1007   uint32 curr_ins_size = 0;
1008   uint64 mcode = 0;
1009   uint8 *iaddr;
1010
1011 #ifdef DEBUG
1012 //  (*cr16_callback->printf_filtered) (cr16_callback, "sim_resume (%d,%d)  PC=0x%x\n",step,siggnal,PC);
1013 #endif
1014
1015   State.exception = 0;
1016   if (step)
1017     sim_stop (sd);
1018
1019   switch (siggnal)
1020     {
1021     case 0:
1022       break;
1023 #ifdef SIGBUS
1024     case SIGBUS:
1025 #endif
1026     case SIGSEGV:
1027       SET_PC (PC);
1028       SET_PSR (PSR);
1029       JMP (AE_VECTOR_START);
1030       SLOT_FLUSH ();
1031       break;
1032     case SIGILL:
1033       SET_PC (PC);
1034       SET_PSR (PSR);
1035       SET_HW_PSR ((PSR & (PSR_C_BIT)));
1036       JMP (RIE_VECTOR_START);
1037       SLOT_FLUSH ();
1038       break;
1039     default:
1040       /* just ignore it */
1041       break;
1042     }
1043
1044   do
1045     {
1046       iaddr = imem_addr ((uint32)PC);
1047       if (iaddr == State.mem.fault)
1048         {
1049 #ifdef SIGBUS
1050           State.exception = SIGBUS;
1051 #else
1052           State.exception = SIGSEGV;
1053 #endif
1054           break;
1055         }
1056
1057       mcode = get_longword( iaddr );
1058
1059       State.pc_changed = 0;
1060
1061       curr_ins_size = do_run(sd, mcode);
1062
1063 #if CR16_DEBUG
1064  (*cr16_callback->printf_filtered) (cr16_callback, "INS: PC=0x%X, mcode=0x%X\n",PC,mcode);
1065 #endif
1066
1067       if (!State.pc_changed)
1068         {
1069           if (curr_ins_size == 0)
1070            {
1071              State.exception = SIG_CR16_EXIT; /* exit trap */
1072              break;
1073            }
1074           else
1075            SET_PC (PC + (curr_ins_size * 2)); /* For word instructions.  */
1076         }
1077
1078 #if 0
1079       /* Check for a breakpoint trap on this instruction.  This
1080          overrides any pending branches or loops */
1081       if (PSR_DB && PC == DBS)
1082         {
1083           SET_BPC (PC);
1084           SET_BPSR (PSR);
1085           SET_PC (SDBT_VECTOR_START);
1086         }
1087 #endif
1088
1089       /* Writeback all the DATA / PC changes */
1090       SLOT_FLUSH ();
1091     }
1092   while ( !State.exception && !stop_simulator);
1093
1094   if (step && !State.exception)
1095     State.exception = SIGTRAP;
1096 }
1097
1098 SIM_RC
1099 sim_create_inferior (SIM_DESC sd, struct bfd *abfd, char **argv, char **env)
1100 {
1101   bfd_vma start_address;
1102
1103   /* reset all state information */
1104   memset (&State.regs, 0, (uintptr_t)&State.mem - (uintptr_t)&State.regs);
1105
1106   /* There was a hack here to copy the values of argc and argv into r0
1107      and r1.  The values were also saved into some high memory that
1108      won't be overwritten by the stack (0x7C00).  The reason for doing
1109      this was to allow the 'run' program to accept arguments.  Without
1110      the hack, this is not possible anymore.  If the simulator is run
1111      from the debugger, arguments cannot be passed in, so this makes
1112      no difference.  */
1113
1114   /* set PC */
1115   if (abfd != NULL)
1116     start_address = bfd_get_start_address (abfd);
1117   else
1118     start_address = 0x0;
1119 #ifdef DEBUG
1120   if (cr16_debug)
1121     (*cr16_callback->printf_filtered) (cr16_callback, "sim_create_inferior:  PC=0x%lx\n", (long) start_address);
1122 #endif
1123   SET_CREG (PC_CR, start_address);
1124
1125   SLOT_FLUSH ();
1126   return SIM_RC_OK;
1127 }
1128
1129 void
1130 sim_stop_reason (SIM_DESC sd, enum sim_stop *reason, int *sigrc)
1131 {
1132 /*   (*cr16_callback->printf_filtered) (cr16_callback, "sim_stop_reason:  PC=0x%x\n",PC<<2); */
1133
1134   switch (State.exception)
1135     {
1136     case SIG_CR16_STOP:                        /* stop instruction */
1137       *reason = sim_stopped;
1138       *sigrc = 0;
1139       break;
1140
1141     case SIG_CR16_EXIT:                        /* exit trap */
1142       *reason = sim_exited;
1143       *sigrc = GPR (2);
1144       break;
1145
1146     case SIG_CR16_BUS:
1147       *reason = sim_stopped;
1148       *sigrc = GDB_SIGNAL_BUS;
1149       break;
1150 //
1151 //    case SIG_CR16_IAD:
1152 //      *reason = sim_stopped;
1153 //      *sigrc = GDB_SIGNAL_IAD;
1154 //      break;
1155
1156     default:                                /* some signal */
1157       *reason = sim_stopped;
1158       if (stop_simulator && !State.exception)
1159         *sigrc = GDB_SIGNAL_INT;
1160       else
1161         *sigrc = State.exception;
1162       break;
1163     }
1164
1165   stop_simulator = 0;
1166 }
1167
1168 int
1169 sim_fetch_register (SIM_DESC sd, int rn, unsigned char *memory, int length)
1170 {
1171   int size;
1172   switch ((enum sim_cr16_regs) rn)
1173     {
1174     case SIM_CR16_R0_REGNUM:
1175     case SIM_CR16_R1_REGNUM:
1176     case SIM_CR16_R2_REGNUM:
1177     case SIM_CR16_R3_REGNUM:
1178     case SIM_CR16_R4_REGNUM:
1179     case SIM_CR16_R5_REGNUM:
1180     case SIM_CR16_R6_REGNUM:
1181     case SIM_CR16_R7_REGNUM:
1182     case SIM_CR16_R8_REGNUM:
1183     case SIM_CR16_R9_REGNUM:
1184     case SIM_CR16_R10_REGNUM:
1185     case SIM_CR16_R11_REGNUM:
1186       WRITE_16 (memory, GPR (rn - SIM_CR16_R0_REGNUM));
1187       size = 2;
1188       break;
1189     case SIM_CR16_R12_REGNUM:
1190     case SIM_CR16_R13_REGNUM:
1191     case SIM_CR16_R14_REGNUM:
1192     case SIM_CR16_R15_REGNUM:
1193       //WRITE_32 (memory, GPR (rn - SIM_CR16_R0_REGNUM));
1194       write_longword (memory, GPR (rn - SIM_CR16_R0_REGNUM));
1195       size = 4;
1196       break;
1197     case SIM_CR16_PC_REGNUM:
1198     case SIM_CR16_ISP_REGNUM:
1199     case SIM_CR16_USP_REGNUM:
1200     case SIM_CR16_INTBASE_REGNUM:
1201     case SIM_CR16_PSR_REGNUM:
1202     case SIM_CR16_CFG_REGNUM:
1203     case SIM_CR16_DBS_REGNUM:
1204     case SIM_CR16_DCR_REGNUM:
1205     case SIM_CR16_DSR_REGNUM:
1206     case SIM_CR16_CAR0_REGNUM:
1207     case SIM_CR16_CAR1_REGNUM:
1208       //WRITE_32 (memory, CREG (rn - SIM_CR16_PC_REGNUM));
1209       write_longword (memory, CREG (rn - SIM_CR16_PC_REGNUM));
1210       size = 4;
1211       break;
1212     default:
1213       size = 0;
1214       break;
1215     }
1216   return size;
1217 }
1218
1219 int
1220 sim_store_register (SIM_DESC sd, int rn, unsigned char *memory, int length)
1221 {
1222   int size;
1223   switch ((enum sim_cr16_regs) rn)
1224     {
1225     case SIM_CR16_R0_REGNUM:
1226     case SIM_CR16_R1_REGNUM:
1227     case SIM_CR16_R2_REGNUM:
1228     case SIM_CR16_R3_REGNUM:
1229     case SIM_CR16_R4_REGNUM:
1230     case SIM_CR16_R5_REGNUM:
1231     case SIM_CR16_R6_REGNUM:
1232     case SIM_CR16_R7_REGNUM:
1233     case SIM_CR16_R8_REGNUM:
1234     case SIM_CR16_R9_REGNUM:
1235     case SIM_CR16_R10_REGNUM:
1236     case SIM_CR16_R11_REGNUM:
1237       SET_GPR (rn - SIM_CR16_R0_REGNUM, READ_16 (memory));
1238       size = 2;
1239       break;
1240     case SIM_CR16_R12_REGNUM:
1241     case SIM_CR16_R13_REGNUM:
1242     case SIM_CR16_R14_REGNUM:
1243     case SIM_CR16_R15_REGNUM:
1244       SET_GPR32 (rn - SIM_CR16_R0_REGNUM, get_longword (memory));
1245       size = 4;
1246       break;
1247     case SIM_CR16_PC_REGNUM:
1248     case SIM_CR16_ISP_REGNUM:
1249     case SIM_CR16_USP_REGNUM:
1250     case SIM_CR16_INTBASE_REGNUM:
1251     case SIM_CR16_PSR_REGNUM:
1252     case SIM_CR16_CFG_REGNUM:
1253     case SIM_CR16_DBS_REGNUM:
1254     case SIM_CR16_DCR_REGNUM:
1255     case SIM_CR16_DSR_REGNUM:
1256     case SIM_CR16_CAR0_REGNUM:
1257     case SIM_CR16_CAR1_REGNUM:
1258       SET_CREG (rn - SIM_CR16_PC_REGNUM, get_longword (memory));
1259       size = 4;
1260       break;
1261     default:
1262       size = 0;
1263       break;
1264     }
1265   SLOT_FLUSH ();
1266   return size;
1267 }