sim/d10v/interp.c

   1 #include "config.h"
   2 #include <inttypes.h>
   3 #include <signal.h>
   4 #include "bfd.h"
   5 #include "gdb/callback.h"
   6 #include "gdb/remote-sim.h"
   7
   8 #include "sim-main.h"
   9 #include "sim-options.h"
  10
  11 #include "gdb/sim-d10v.h"
  12 #include "gdb/signals.h"
  13
  14 #ifdef HAVE_STRING_H
  15 #include <string.h>
  16 #else
  17 #ifdef HAVE_STRINGS_H
  18 #include <strings.h>
  19 #endif /* HAVE_STRING_H */
  20 #endif /* HAVE_STRINGS_H */
  21
  22 #ifdef HAVE_STDLIB_H
  23 #include <stdlib.h>
  24 #endif
  25
  26 enum _leftright { LEFT_FIRST, RIGHT_FIRST };
  27
  28 int d10v_debug;
  29
  30 /* Set this to true to get the previous segment layout. */
  31
  32 int old_segment_mapping;
  33
  34 unsigned long ins_type_counters[ (int)INS_MAX ];
  35
  36 uint16 OP[4];
  37
  38 static long hash (long insn, int format);
  39 static struct hash_entry *lookup_hash (SIM_DESC, SIM_CPU *, uint32 ins, int size);
  40 static void get_operands (struct simops *s, uint32 ins);
  41 static void do_long (SIM_DESC, SIM_CPU *, uint32 ins);
  42 static void do_2_short (SIM_DESC, SIM_CPU *, uint16 ins1, uint16 ins2, enum _leftright leftright);
  43 static void do_parallel (SIM_DESC, SIM_CPU *, uint16 ins1, uint16 ins2);
  44 static char *add_commas (char *buf, int sizeof_buf, unsigned long value);
  45 static INLINE uint8 *map_memory (SIM_DESC, SIM_CPU *, unsigned phys_addr);
  46
  47 #define MAX_HASH  63
  48 struct hash_entry
  49 {
  50   struct hash_entry *next;
  51   uint32 opcode;
  52   uint32 mask;
  53   int size;
  54   struct simops *ops;
  55 };
  56
  57 struct hash_entry hash_table[MAX_HASH+1];
  58
  59 INLINE static long
  60 hash (long insn, int format)
  61 {
  62   if (format & LONG_OPCODE)
  63     return ((insn & 0x3F000000) >> 24);
  64   else
  65     return((insn & 0x7E00) >> 9);
  66 }
  67
  68 INLINE static struct hash_entry *
  69 lookup_hash (SIM_DESC sd, SIM_CPU *cpu, uint32 ins, int size)
  70 {
  71   struct hash_entry *h;
  72
  73   if (size)
  74     h = &hash_table[(ins & 0x3F000000) >> 24];
  75   else
  76     h = &hash_table[(ins & 0x7E00) >> 9];
  77
  78   while ((ins & h->mask) != h->opcode || h->size != size)
  79     {
  80       if (h->next == NULL)
  81         sim_engine_halt (sd, cpu, NULL, PC, sim_stopped, SIM_SIGILL);
  82       h = h->next;
  83     }
  84   return (h);
  85 }
  86
  87 INLINE static void
  88 get_operands (struct simops *s, uint32 ins)
  89 {
  90   int i, shift, bits, flags;
  91   uint32 mask;
  92   for (i=0; i < s->numops; i++)
  93     {
  94       shift = s->operands[3*i];
  95       bits = s->operands[3*i+1];
  96       flags = s->operands[3*i+2];
  97       mask = 0x7FFFFFFF >> (31 - bits);
  98       OP[i] = (ins >> shift) & mask;
  99     }
 100   /* FIXME: for tracing, update values that need to be updated each
 101      instruction decode cycle */
 102   State.trace.psw = PSW;
 103 }
 104
 105 static void
 106 do_long (SIM_DESC sd, SIM_CPU *cpu, uint32 ins)
 107 {
 108   struct hash_entry *h;
 109 #ifdef DEBUG
 110   if ((d10v_debug & DEBUG_INSTRUCTION) != 0)
 111     sim_io_printf (sd, "do_long 0x%x\n", ins);
 112 #endif
 113   h = lookup_hash (sd, cpu, ins, 1);
 114   if (h == NULL)
 115     return;
 116   get_operands (h->ops, ins);
 117   State.ins_type = INS_LONG;
 118   ins_type_counters[ (int)State.ins_type ]++;
 119   (h->ops->func) (sd, cpu);
 120 }
 121
 122 static void
 123 do_2_short (SIM_DESC sd, SIM_CPU *cpu, uint16 ins1, uint16 ins2, enum _leftright leftright)
 124 {
 125   struct hash_entry *h;
 126   enum _ins_type first, second;
 127
 128 #ifdef DEBUG
 129   if ((d10v_debug & DEBUG_INSTRUCTION) != 0)
 130     sim_io_printf (sd, "do_2_short 0x%x (%s) -> 0x%x\n", ins1,
 131                    leftright ? "left" : "right", ins2);
 132 #endif
 133
 134   if (leftright == LEFT_FIRST)
 135     {
 136       first = INS_LEFT;
 137       second = INS_RIGHT;
 138       ins_type_counters[ (int)INS_LEFTRIGHT ]++;
 139     }
 140   else
 141     {
 142       first = INS_RIGHT;
 143       second = INS_LEFT;
 144       ins_type_counters[ (int)INS_RIGHTLEFT ]++;
 145     }
 146
 147   /* Issue the first instruction */
 148   h = lookup_hash (sd, cpu, ins1, 0);
 149   if (h == NULL)
 150     return;
 151   get_operands (h->ops, ins1);
 152   State.ins_type = first;
 153   ins_type_counters[ (int)State.ins_type ]++;
 154   (h->ops->func) (sd, cpu);
 155
 156   /* Issue the second instruction (if the PC hasn't changed) */
 157   if (!State.pc_changed)
 158     {
 159       /* finish any existing instructions */
 160       SLOT_FLUSH ();
 161       h = lookup_hash (sd, cpu, ins2, 0);
 162       if (h == NULL)
 163         return;
 164       get_operands (h->ops, ins2);
 165       State.ins_type = second;
 166       ins_type_counters[ (int)State.ins_type ]++;
 167       ins_type_counters[ (int)INS_CYCLES ]++;
 168       (h->ops->func) (sd, cpu);
 169     }
 170   else
 171     ins_type_counters[ (int)INS_COND_JUMP ]++;
 172 }
 173
 174 static void
 175 do_parallel (SIM_DESC sd, SIM_CPU *cpu, uint16 ins1, uint16 ins2)
 176 {
 177   struct hash_entry *h1, *h2;
 178 #ifdef DEBUG
 179   if ((d10v_debug & DEBUG_INSTRUCTION) != 0)
 180     sim_io_printf (sd, "do_parallel 0x%x || 0x%x\n", ins1, ins2);
 181 #endif
 182   ins_type_counters[ (int)INS_PARALLEL ]++;
 183   h1 = lookup_hash (sd, cpu, ins1, 0);
 184   if (h1 == NULL)
 185     return;
 186   h2 = lookup_hash (sd, cpu, ins2, 0);
 187   if (h2 == NULL)
 188     return;
 189
 190   if (h1->ops->exec_type == PARONLY)
 191     {
 192       get_operands (h1->ops, ins1);
 193       State.ins_type = INS_LEFT_COND_TEST;
 194       ins_type_counters[ (int)State.ins_type ]++;
 195       (h1->ops->func) (sd, cpu);
 196       if (State.exe)
 197         {
 198           ins_type_counters[ (int)INS_COND_TRUE ]++;
 199           get_operands (h2->ops, ins2);
 200           State.ins_type = INS_RIGHT_COND_EXE;
 201           ins_type_counters[ (int)State.ins_type ]++;
 202           (h2->ops->func) (sd, cpu);
 203         }
 204       else
 205         ins_type_counters[ (int)INS_COND_FALSE ]++;
 206     }
 207   else if (h2->ops->exec_type == PARONLY)
 208     {
 209       get_operands (h2->ops, ins2);
 210       State.ins_type = INS_RIGHT_COND_TEST;
 211       ins_type_counters[ (int)State.ins_type ]++;
 212       (h2->ops->func) (sd, cpu);
 213       if (State.exe)
 214         {
 215           ins_type_counters[ (int)INS_COND_TRUE ]++;
 216           get_operands (h1->ops, ins1);
 217           State.ins_type = INS_LEFT_COND_EXE;
 218           ins_type_counters[ (int)State.ins_type ]++;
 219           (h1->ops->func) (sd, cpu);
 220         }
 221       else
 222         ins_type_counters[ (int)INS_COND_FALSE ]++;
 223     }
 224   else
 225     {
 226       get_operands (h1->ops, ins1);
 227       State.ins_type = INS_LEFT_PARALLEL;
 228       ins_type_counters[ (int)State.ins_type ]++;
 229       (h1->ops->func) (sd, cpu);
 230       get_operands (h2->ops, ins2);
 231       State.ins_type = INS_RIGHT_PARALLEL;
 232       ins_type_counters[ (int)State.ins_type ]++;
 233       (h2->ops->func) (sd, cpu);
 234     }
 235 }
 236
 237 static char *
 238 add_commas (char *buf, int sizeof_buf, unsigned long value)
 239 {
 240   int comma = 3;
 241   char *endbuf = buf + sizeof_buf - 1;
 242
 243   *--endbuf = '\0';
 244   do {
 245     if (comma-- == 0)
 246       {
 247         *--endbuf = ',';
 248         comma = 2;
 249       }
 250
 251     *--endbuf = (value % 10) + '0';
 252   } while ((value /= 10) != 0);
 253
 254   return endbuf;
 255 }
 256
 257 static void
 258 sim_size (int power)
 259 {
 260   int i;
 261   for (i = 0; i < IMEM_SEGMENTS; i++)
 262     {
 263       if (State.mem.insn[i])
 264         free (State.mem.insn[i]);
 265     }
 266   for (i = 0; i < DMEM_SEGMENTS; i++)
 267     {
 268       if (State.mem.data[i])
 269         free (State.mem.data[i]);
 270     }
 271   for (i = 0; i < UMEM_SEGMENTS; i++)
 272     {
 273       if (State.mem.unif[i])
 274         free (State.mem.unif[i]);
 275     }
 276   /* Always allocate dmem segment 0.  This contains the IMAP and DMAP
 277      registers. */
 278   State.mem.data[0] = calloc (1, SEGMENT_SIZE);
 279 }
 280
 281 /* For tracing - leave info on last access around. */
 282 static char *last_segname = "invalid";
 283 static char *last_from = "invalid";
 284 static char *last_to = "invalid";
 285
 286 enum
 287   {
 288     IMAP0_OFFSET = 0xff00,
 289     DMAP0_OFFSET = 0xff08,
 290     DMAP2_SHADDOW = 0xff04,
 291     DMAP2_OFFSET = 0xff0c
 292   };
 293
 294 static void
 295 set_dmap_register (SIM_DESC sd, int reg_nr, unsigned long value)
 296 {
 297   uint8 *raw = map_memory (sd, NULL, SIM_D10V_MEMORY_DATA
 298                            + DMAP0_OFFSET + 2 * reg_nr);
 299   WRITE_16 (raw, value);
 300 #ifdef DEBUG
 301   if ((d10v_debug & DEBUG_MEMORY))
 302     {
 303       sim_io_printf (sd, "mem: dmap%d=0x%04lx\n", reg_nr, value);
 304     }
 305 #endif
 306 }
 307
 308 static unsigned long
 309 dmap_register (SIM_DESC sd, SIM_CPU *cpu, void *regcache, int reg_nr)
 310 {
 311   uint8 *raw = map_memory (sd, cpu, SIM_D10V_MEMORY_DATA
 312                            + DMAP0_OFFSET + 2 * reg_nr);
 313   return READ_16 (raw);
 314 }
 315
 316 static void
 317 set_imap_register (SIM_DESC sd, int reg_nr, unsigned long value)
 318 {
 319   uint8 *raw = map_memory (sd, NULL, SIM_D10V_MEMORY_DATA
 320                            + IMAP0_OFFSET + 2 * reg_nr);
 321   WRITE_16 (raw, value);
 322 #ifdef DEBUG
 323   if ((d10v_debug & DEBUG_MEMORY))
 324     {
 325       sim_io_printf (sd, "mem: imap%d=0x%04lx\n", reg_nr, value);
 326     }
 327 #endif
 328 }
 329
 330 static unsigned long
 331 imap_register (SIM_DESC sd, SIM_CPU *cpu, void *regcache, int reg_nr)
 332 {
 333   uint8 *raw = map_memory (sd, cpu, SIM_D10V_MEMORY_DATA
 334                            + IMAP0_OFFSET + 2 * reg_nr);
 335   return READ_16 (raw);
 336 }
 337
 338 enum
 339   {
 340     HELD_SPI_IDX = 0,
 341     HELD_SPU_IDX = 1
 342   };
 343
 344 static unsigned long
 345 spu_register (void)
 346 {
 347   if (PSW_SM)
 348     return GPR (SP_IDX);
 349   else
 350     return HELD_SP (HELD_SPU_IDX);
 351 }
 352
 353 static unsigned long
 354 spi_register (void)
 355 {
 356   if (!PSW_SM)
 357     return GPR (SP_IDX);
 358   else
 359     return HELD_SP (HELD_SPI_IDX);
 360 }
 361
 362 static void
 363 set_spi_register (unsigned long value)
 364 {
 365   if (!PSW_SM)
 366     SET_GPR (SP_IDX, value);
 367   SET_HELD_SP (HELD_SPI_IDX, value);
 368 }
 369
 370 static void
 371 set_spu_register  (unsigned long value)
 372 {
 373   if (PSW_SM)
 374     SET_GPR (SP_IDX, value);
 375   SET_HELD_SP (HELD_SPU_IDX, value);
 376 }
 377
 378 /* Given a virtual address in the DMAP address space, translate it
 379    into a physical address. */
 380
 381 static unsigned long
 382 sim_d10v_translate_dmap_addr (SIM_DESC sd,
 383                               SIM_CPU *cpu,
 384                               unsigned long offset,
 385                               int nr_bytes,
 386                               unsigned long *phys,
 387                               void *regcache,
 388                               unsigned long (*dmap_register) (SIM_DESC,
 389                                                               SIM_CPU *,
 390                                                               void *regcache,
 391                                                               int reg_nr))
 392 {
 393   short map;
 394   int regno;
 395   last_from = "logical-data";
 396   if (offset >= DMAP_BLOCK_SIZE * SIM_D10V_NR_DMAP_REGS)
 397     {
 398       /* Logical address out side of data segments, not supported */
 399       return 0;
 400     }
 401   regno = (offset / DMAP_BLOCK_SIZE);
 402   offset = (offset % DMAP_BLOCK_SIZE);
 403   if ((offset % DMAP_BLOCK_SIZE) + nr_bytes > DMAP_BLOCK_SIZE)
 404     {
 405       /* Don't cross a BLOCK boundary */
 406       nr_bytes = DMAP_BLOCK_SIZE - (offset % DMAP_BLOCK_SIZE);
 407     }
 408   map = dmap_register (sd, cpu, regcache, regno);
 409   if (regno == 3)
 410     {
 411       /* Always maps to data memory */
 412       int iospi = (offset / 0x1000) % 4;
 413       int iosp = (map >> (4 * (3 - iospi))) % 0x10;
 414       last_to = "io-space";
 415       *phys = (SIM_D10V_MEMORY_DATA + (iosp * 0x10000) + 0xc000 + offset);
 416     }
 417   else
 418     {
 419       int sp = ((map & 0x3000) >> 12);
 420       int segno = (map & 0x3ff);
 421       switch (sp)
 422         {
 423         case 0: /* 00: Unified memory */
 424           *phys = SIM_D10V_MEMORY_UNIFIED + (segno * DMAP_BLOCK_SIZE) + offset;
 425           last_to = "unified";
 426           break;
 427         case 1: /* 01: Instruction Memory */
 428           *phys = SIM_D10V_MEMORY_INSN + (segno * DMAP_BLOCK_SIZE) + offset;
 429           last_to = "chip-insn";
 430           break;
 431         case 2: /* 10: Internal data memory */
 432           *phys = SIM_D10V_MEMORY_DATA + (segno << 16) + (regno * DMAP_BLOCK_SIZE) + offset;
 433           last_to = "chip-data";
 434           break;
 435         case 3: /* 11: Reserved */
 436           return 0;
 437         }
 438     }
 439   return nr_bytes;
 440 }
 441
 442 /* Given a virtual address in the IMAP address space, translate it
 443    into a physical address. */
 444
 445 static unsigned long
 446 sim_d10v_translate_imap_addr (SIM_DESC sd,
 447                               SIM_CPU *cpu,
 448                               unsigned long offset,
 449                               int nr_bytes,
 450                               unsigned long *phys,
 451                               void *regcache,
 452                               unsigned long (*imap_register) (SIM_DESC,
 453                                                               SIM_CPU *,
 454                                                               void *regcache,
 455                                                               int reg_nr))
 456 {
 457   short map;
 458   int regno;
 459   int sp;
 460   int segno;
 461   last_from = "logical-insn";
 462   if (offset >= (IMAP_BLOCK_SIZE * SIM_D10V_NR_IMAP_REGS))
 463     {
 464       /* Logical address outside of IMAP segments, not supported */
 465       return 0;
 466     }
 467   regno = (offset / IMAP_BLOCK_SIZE);
 468   offset = (offset % IMAP_BLOCK_SIZE);
 469   if (offset + nr_bytes > IMAP_BLOCK_SIZE)
 470     {
 471       /* Don't cross a BLOCK boundary */
 472       nr_bytes = IMAP_BLOCK_SIZE - offset;
 473     }
 474   map = imap_register (sd, cpu, regcache, regno);
 475   sp = (map & 0x3000) >> 12;
 476   segno = (map & 0x007f);
 477   switch (sp)
 478     {
 479     case 0: /* 00: unified memory */
 480       *phys = SIM_D10V_MEMORY_UNIFIED + (segno << 17) + offset;
 481       last_to = "unified";
 482       break;
 483     case 1: /* 01: instruction memory */
 484       *phys = SIM_D10V_MEMORY_INSN + (IMAP_BLOCK_SIZE * regno) + offset;
 485       last_to = "chip-insn";
 486       break;
 487     case 2: /*10*/
 488       /* Reserved. */
 489       return 0;
 490     case 3: /* 11: for testing  - instruction memory */
 491       offset = (offset % 0x800);
 492       *phys = SIM_D10V_MEMORY_INSN + offset;
 493       if (offset + nr_bytes > 0x800)
 494         /* don't cross VM boundary */
 495         nr_bytes = 0x800 - offset;
 496       last_to = "test-insn";
 497       break;
 498     }
 499   return nr_bytes;
 500 }
 501
 502 static unsigned long
 503 sim_d10v_translate_addr (SIM_DESC sd,
 504                          SIM_CPU *cpu,
 505                          unsigned long memaddr,
 506                          int nr_bytes,
 507                          unsigned long *targ_addr,
 508                          void *regcache,
 509                          unsigned long (*dmap_register) (SIM_DESC,
 510                                                          SIM_CPU *,
 511                                                          void *regcache,
 512                                                          int reg_nr),
 513                          unsigned long (*imap_register) (SIM_DESC,
 514                                                          SIM_CPU *,
 515                                                          void *regcache,
 516                                                          int reg_nr))
 517 {
 518   unsigned long phys;
 519   unsigned long seg;
 520   unsigned long off;
 521
 522   last_from = "unknown";
 523   last_to = "unknown";
 524
 525   seg = (memaddr >> 24);
 526   off = (memaddr & 0xffffffL);
 527
 528   /* However, if we've asked to use the previous generation of segment
 529      mapping, rearrange the segments as follows. */
 530
 531   if (old_segment_mapping)
 532     {
 533       switch (seg)
 534         {
 535         case 0x00: /* DMAP translated memory */
 536           seg = 0x10;
 537           break;
 538         case 0x01: /* IMAP translated memory */
 539           seg = 0x11;
 540           break;
 541         case 0x10: /* On-chip data memory */
 542           seg = 0x02;
 543           break;
 544         case 0x11: /* On-chip insn memory */
 545           seg = 0x01;
 546           break;
 547         case 0x12: /* Unified memory */
 548           seg = 0x00;
 549           break;
 550         }
 551     }
 552
 553   switch (seg)
 554     {
 555     case 0x00:                  /* Physical unified memory */
 556       last_from = "phys-unified";
 557       last_to = "unified";
 558       phys = SIM_D10V_MEMORY_UNIFIED + off;
 559       if ((off % SEGMENT_SIZE) + nr_bytes > SEGMENT_SIZE)
 560         nr_bytes = SEGMENT_SIZE - (off % SEGMENT_SIZE);
 561       break;
 562
 563     case 0x01:                  /* Physical instruction memory */
 564       last_from = "phys-insn";
 565       last_to = "chip-insn";
 566       phys = SIM_D10V_MEMORY_INSN + off;
 567       if ((off % SEGMENT_SIZE) + nr_bytes > SEGMENT_SIZE)
 568         nr_bytes = SEGMENT_SIZE - (off % SEGMENT_SIZE);
 569       break;
 570
 571     case 0x02:                  /* Physical data memory segment */
 572       last_from = "phys-data";
 573       last_to = "chip-data";
 574       phys = SIM_D10V_MEMORY_DATA + off;
 575       if ((off % SEGMENT_SIZE) + nr_bytes > SEGMENT_SIZE)
 576         nr_bytes = SEGMENT_SIZE - (off % SEGMENT_SIZE);
 577       break;
 578
 579     case 0x10:                  /* in logical data address segment */
 580       nr_bytes = sim_d10v_translate_dmap_addr (sd, cpu, off, nr_bytes, &phys,
 581                                                regcache, dmap_register);
 582       break;
 583
 584     case 0x11:                  /* in logical instruction address segment */
 585       nr_bytes = sim_d10v_translate_imap_addr (sd, cpu, off, nr_bytes, &phys,
 586                                                regcache, imap_register);
 587       break;
 588
 589     default:
 590       return 0;
 591     }
 592
 593   *targ_addr = phys;
 594   return nr_bytes;
 595 }
 596
 597 /* Return a pointer into the raw buffer designated by phys_addr.  It
 598    is assumed that the client has already ensured that the access
 599    isn't going to cross a segment boundary. */
 600
 601 uint8 *
 602 map_memory (SIM_DESC sd, SIM_CPU *cpu, unsigned phys_addr)
 603 {
 604   uint8 **memory;
 605   uint8 *raw;
 606   unsigned offset;
 607   int segment = ((phys_addr >> 24) & 0xff);
 608
 609   switch (segment)
 610     {
 611
 612     case 0x00: /* Unified memory */
 613       {
 614         memory = &State.mem.unif[(phys_addr / SEGMENT_SIZE) % UMEM_SEGMENTS];
 615         last_segname = "umem";
 616         break;
 617       }
 618
 619     case 0x01: /* On-chip insn memory */
 620       {
 621         memory = &State.mem.insn[(phys_addr / SEGMENT_SIZE) % IMEM_SEGMENTS];
 622         last_segname = "imem";
 623         break;
 624       }
 625
 626     case 0x02: /* On-chip data memory */
 627       {
 628         if ((phys_addr & 0xff00) == 0xff00)
 629           {
 630             phys_addr = (phys_addr & 0xffff);
 631             if (phys_addr == DMAP2_SHADDOW)
 632               {
 633                 phys_addr = DMAP2_OFFSET;
 634                 last_segname = "dmap";
 635               }
 636             else
 637               last_segname = "reg";
 638           }
 639         else
 640           last_segname = "dmem";
 641         memory = &State.mem.data[(phys_addr / SEGMENT_SIZE) % DMEM_SEGMENTS];
 642         break;
 643       }
 644
 645     default:
 646       /* OOPS! */
 647       last_segname = "scrap";
 648       sim_engine_halt (sd, cpu, NULL, PC, sim_stopped, SIM_SIGBUS);
 649     }
 650
 651   if (*memory == NULL)
 652     *memory = xcalloc (1, SEGMENT_SIZE);
 653
 654   offset = (phys_addr % SEGMENT_SIZE);
 655   raw = *memory + offset;
 656   return raw;
 657 }
 658
 659 /* Transfer data to/from simulated memory.  Since a bug in either the
 660    simulated program or in gdb or the simulator itself may cause a
 661    bogus address to be passed in, we need to do some sanity checking
 662    on addresses to make sure they are within bounds.  When an address
 663    fails the bounds check, treat it as a zero length read/write rather
 664    than aborting the entire run. */
 665
 666 static int
 667 xfer_mem (SIM_DESC sd,
 668           SIM_ADDR virt,
 669           unsigned char *buffer,
 670           int size,
 671           int write_p)
 672 {
 673   uint8 *memory;
 674   unsigned long phys;
 675   int phys_size;
 676   phys_size = sim_d10v_translate_addr (sd, NULL, virt, size, &phys, NULL,
 677                                        dmap_register, imap_register);
 678   if (phys_size == 0)
 679     return 0;
 680
 681   memory = map_memory (sd, NULL, phys);
 682
 683 #ifdef DEBUG
 684   if ((d10v_debug & DEBUG_INSTRUCTION) != 0)
 685     {
 686       sim_io_printf
 687         (sd,
 688          "sim_%s %d bytes: 0x%08lx (%s) -> 0x%08lx (%s) -> 0x%08lx (%s)\n",
 689          write_p ? "write" : "read",
 690          phys_size, virt, last_from,
 691          phys, last_to,
 692          (long) memory, last_segname);
 693     }
 694 #endif
 695
 696   if (write_p)
 697     {
 698       memcpy (memory, buffer, phys_size);
 699     }
 700   else
 701     {
 702       memcpy (buffer, memory, phys_size);
 703     }
 704
 705   return phys_size;
 706 }
 707
 708
 709 int
 710 sim_write (SIM_DESC sd, SIM_ADDR addr, const unsigned char *buffer, int size)
 711 {
 712   /* FIXME: this should be performing a virtual transfer */
 713   return xfer_mem (sd, addr, buffer, size, 1);
 714 }
 715
 716 int
 717 sim_read (SIM_DESC sd, SIM_ADDR addr, unsigned char *buffer, int size)
 718 {
 719   /* FIXME: this should be performing a virtual transfer */
 720   return xfer_mem (sd, addr, buffer, size, 0);
 721 }
 722
 723 static sim_cia
 724 d10v_pc_get (sim_cpu *cpu)
 725 {
 726   return PC;
 727 }
 728
 729 static void
 730 d10v_pc_set (sim_cpu *cpu, sim_cia pc)
 731 {
 732   SIM_DESC sd = CPU_STATE (cpu);
 733   SET_PC (pc);
 734 }
 735
 736 static void
 737 free_state (SIM_DESC sd)
 738 {
 739   if (STATE_MODULES (sd) != NULL)
 740     sim_module_uninstall (sd);
 741   sim_cpu_free_all (sd);
 742   sim_state_free (sd);
 743 }
 744
 745 SIM_DESC
 746 sim_open (SIM_OPEN_KIND kind, host_callback *cb, struct bfd *abfd, char **argv)
 747 {
 748   struct simops *s;
 749   struct hash_entry *h;
 750   static int init_p = 0;
 751   char **p;
 752   int i;
 753   SIM_DESC sd = sim_state_alloc (kind, cb);
 754   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 755
 756   /* The cpu data is kept in a separately allocated chunk of memory.  */
 757   if (sim_cpu_alloc_all (sd, 1, /*cgen_cpu_max_extra_bytes ()*/0) != SIM_RC_OK)
 758     {
 759       free_state (sd);
 760       return 0;
 761     }
 762
 763   if (sim_pre_argv_init (sd, argv[0]) != SIM_RC_OK)
 764     {
 765       free_state (sd);
 766       return 0;
 767     }
 768
 769   /* getopt will print the error message so we just have to exit if this fails.
 770      FIXME: Hmmm...  in the case of gdb we need getopt to call
 771      print_filtered.  */
 772   if (sim_parse_args (sd, argv) != SIM_RC_OK)
 773     {
 774       free_state (sd);
 775       return 0;
 776     }
 777
 778   /* Check for/establish the a reference program image.  */
 779   if (sim_analyze_program (sd,
 780                            (STATE_PROG_ARGV (sd) != NULL
 781                             ? *STATE_PROG_ARGV (sd)
 782                             : NULL), abfd) != SIM_RC_OK)
 783     {
 784       free_state (sd);
 785       return 0;
 786     }
 787
 788   /* Configure/verify the target byte order and other runtime
 789      configuration options.  */
 790   if (sim_config (sd) != SIM_RC_OK)
 791     {
 792       sim_module_uninstall (sd);
 793       return 0;
 794     }
 795
 796   if (sim_post_argv_init (sd) != SIM_RC_OK)
 797     {
 798       /* Uninstall the modules to avoid memory leaks,
 799          file descriptor leaks, etc.  */
 800       sim_module_uninstall (sd);
 801       return 0;
 802     }
 803
 804   /* CPU specific initialization.  */
 805   for (i = 0; i < MAX_NR_PROCESSORS; ++i)
 806     {
 807       SIM_CPU *cpu = STATE_CPU (sd, i);
 808
 809       CPU_PC_FETCH (cpu) = d10v_pc_get;
 810       CPU_PC_STORE (cpu) = d10v_pc_set;
 811     }
 812
 813   old_segment_mapping = 0;
 814
 815   /* NOTE: This argument parsing is only effective when this function
 816      is called by GDB. Standalone argument parsing is handled by
 817      sim/common/run.c. */
 818   for (p = argv + 1; *p; ++p)
 819     {
 820       if (strcmp (*p, "-oldseg") == 0)
 821         old_segment_mapping = 1;
 822 #ifdef DEBUG
 823       else if (strcmp (*p, "-t") == 0)
 824         d10v_debug = DEBUG;
 825       else if (strncmp (*p, "-t", 2) == 0)
 826         d10v_debug = atoi (*p + 2);
 827 #endif
 828     }
 829
 830   /* put all the opcodes in the hash table */
 831   if (!init_p++)
 832     {
 833       for (s = Simops; s->func; s++)
 834         {
 835           h = &hash_table[hash(s->opcode,s->format)];
 836
 837           /* go to the last entry in the chain */
 838           while (h->next)
 839             h = h->next;
 840
 841           if (h->ops)
 842             {
 843               h->next = (struct hash_entry *) calloc(1,sizeof(struct hash_entry));
 844               if (!h->next)
 845                 perror ("malloc failure");
 846
 847               h = h->next;
 848             }
 849           h->ops = s;
 850           h->mask = s->mask;
 851           h->opcode = s->opcode;
 852           h->size = s->is_long;
 853         }
 854     }
 855
 856   /* reset the processor state */
 857   if (!State.mem.data[0])
 858     sim_size (1);
 859
 860   return sd;
 861 }
 862
 863 uint8 *
 864 dmem_addr (SIM_DESC sd, SIM_CPU *cpu, uint16 offset)
 865 {
 866   unsigned long phys;
 867   uint8 *mem;
 868   int phys_size;
 869
 870   /* Note: DMEM address range is 0..0x10000. Calling code can compute
 871      things like ``0xfffe + 0x0e60 == 0x10e5d''.  Since offset's type
 872      is uint16 this is modulo'ed onto 0x0e5d. */
 873
 874   phys_size = sim_d10v_translate_dmap_addr (sd, cpu, offset, 1, &phys, NULL,
 875                                             dmap_register);
 876   if (phys_size == 0)
 877     sim_engine_halt (sd, cpu, NULL, PC, sim_stopped, SIM_SIGBUS);
 878   mem = map_memory (sd, cpu, phys);
 879 #ifdef DEBUG
 880   if ((d10v_debug & DEBUG_MEMORY))
 881     {
 882       sim_io_printf
 883         (sd,
 884          "mem: 0x%08x (%s) -> 0x%08lx %d (%s) -> 0x%08lx (%s)\n",
 885          offset, last_from,
 886          phys, phys_size, last_to,
 887          (long) mem, last_segname);
 888     }
 889 #endif
 890   return mem;
 891 }
 892
 893 uint8 *
 894 imem_addr (SIM_DESC sd, SIM_CPU *cpu, uint32 offset)
 895 {
 896   unsigned long phys;
 897   uint8 *mem;
 898   int phys_size = sim_d10v_translate_imap_addr (sd, cpu, offset, 1, &phys, NULL,
 899                                                 imap_register);
 900   if (phys_size == 0)
 901     sim_engine_halt (sd, cpu, NULL, PC, sim_stopped, SIM_SIGBUS);
 902   mem = map_memory (sd, cpu, phys);
 903 #ifdef DEBUG
 904   if ((d10v_debug & DEBUG_MEMORY))
 905     {
 906       sim_io_printf
 907         (sd,
 908          "mem: 0x%08x (%s) -> 0x%08lx %d (%s) -> 0x%08lx (%s)\n",
 909          offset, last_from,
 910          phys, phys_size, last_to,
 911          (long) mem, last_segname);
 912     }
 913 #endif
 914   return mem;
 915 }
 916
 917 static void
 918 step_once (SIM_DESC sd, SIM_CPU *cpu)
 919 {
 920   uint32 inst;
 921   uint8 *iaddr;
 922
 923   /* TODO: Unindent this block.  */
 924     {
 925       iaddr = imem_addr (sd, cpu, (uint32)PC << 2);
 926
 927       inst = get_longword( iaddr );
 928
 929       State.pc_changed = 0;
 930       ins_type_counters[ (int)INS_CYCLES ]++;
 931
 932       switch (inst & 0xC0000000)
 933         {
 934         case 0xC0000000:
 935           /* long instruction */
 936           do_long (sd, cpu, inst & 0x3FFFFFFF);
 937           break;
 938         case 0x80000000:
 939           /* R -> L */
 940           do_2_short (sd, cpu, inst & 0x7FFF, (inst & 0x3FFF8000) >> 15, RIGHT_FIRST);
 941           break;
 942         case 0x40000000:
 943           /* L -> R */
 944           do_2_short (sd, cpu, (inst & 0x3FFF8000) >> 15, inst & 0x7FFF, LEFT_FIRST);
 945           break;
 946         case 0:
 947           do_parallel (sd, cpu, (inst & 0x3FFF8000) >> 15, inst & 0x7FFF);
 948           break;
 949         }
 950
 951       /* If the PC of the current instruction matches RPT_E then
 952          schedule a branch to the loop start.  If one of those
 953          instructions happens to be a branch, than that instruction
 954          will be ignored */
 955       if (!State.pc_changed)
 956         {
 957           if (PSW_RP && PC == RPT_E)
 958             {
 959               /* Note: The behavour of a branch instruction at RPT_E
 960                  is implementation dependant, this simulator takes the
 961                  branch.  Branching to RPT_E is valid, the instruction
 962                  must be executed before the loop is taken.  */
 963               if (RPT_C == 1)
 964                 {
 965                   SET_PSW_RP (0);
 966                   SET_RPT_C (0);
 967                   SET_PC (PC + 1);
 968                 }
 969               else
 970                 {
 971                   SET_RPT_C (RPT_C - 1);
 972                   SET_PC (RPT_S);
 973                 }
 974             }
 975           else
 976             SET_PC (PC + 1);
 977         }
 978
 979       /* Check for a breakpoint trap on this instruction.  This
 980          overrides any pending branches or loops */
 981       if (PSW_DB && PC == IBA)
 982         {
 983           SET_BPC (PC);
 984           SET_BPSW (PSW);
 985           SET_PSW (PSW & PSW_SM_BIT);
 986           SET_PC (SDBT_VECTOR_START);
 987         }
 988
 989       /* Writeback all the DATA / PC changes */
 990       SLOT_FLUSH ();
 991     }
 992 }
 993
 994 void
 995 sim_engine_run (SIM_DESC sd,
 996                 int next_cpu_nr,  /* ignore  */
 997                 int nr_cpus,      /* ignore  */
 998                 int siggnal)
 999 {
1000   sim_cpu *cpu;
1001
1002   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
1003
1004   cpu = STATE_CPU (sd, 0);
1005
1006   switch (siggnal)
1007     {
1008     case 0:
1009       break;
1010     case GDB_SIGNAL_BUS:
1011       SET_BPC (PC);
1012       SET_BPSW (PSW);
1013       SET_HW_PSW ((PSW & (PSW_F0_BIT | PSW_F1_BIT | PSW_C_BIT)));
1014       JMP (AE_VECTOR_START);
1015       SLOT_FLUSH ();
1016       break;
1017     case GDB_SIGNAL_ILL:
1018       SET_BPC (PC);
1019       SET_BPSW (PSW);
1020       SET_HW_PSW ((PSW & (PSW_F0_BIT | PSW_F1_BIT | PSW_C_BIT)));
1021       JMP (RIE_VECTOR_START);
1022       SLOT_FLUSH ();
1023       break;
1024     default:
1025       /* just ignore it */
1026       break;
1027     }
1028
1029   while (1)
1030     {
1031       step_once (sd, cpu);
1032       if (sim_events_tick (sd))
1033         sim_events_process (sd);
1034     }
1035 }
1036
1037 void
1038 sim_info (SIM_DESC sd, int verbose)
1039 {
1040   char buf1[40];
1041   char buf2[40];
1042   char buf3[40];
1043   char buf4[40];
1044   char buf5[40];
1045   unsigned long left            = ins_type_counters[ (int)INS_LEFT ] + ins_type_counters[ (int)INS_LEFT_COND_EXE ];
1046   unsigned long left_nops       = ins_type_counters[ (int)INS_LEFT_NOPS ];
1047   unsigned long left_parallel   = ins_type_counters[ (int)INS_LEFT_PARALLEL ];
1048   unsigned long left_cond       = ins_type_counters[ (int)INS_LEFT_COND_TEST ];
1049   unsigned long left_total      = left + left_parallel + left_cond + left_nops;
1050
1051   unsigned long right           = ins_type_counters[ (int)INS_RIGHT ] + ins_type_counters[ (int)INS_RIGHT_COND_EXE ];
1052   unsigned long right_nops      = ins_type_counters[ (int)INS_RIGHT_NOPS ];
1053   unsigned long right_parallel  = ins_type_counters[ (int)INS_RIGHT_PARALLEL ];
1054   unsigned long right_cond      = ins_type_counters[ (int)INS_RIGHT_COND_TEST ];
1055   unsigned long right_total     = right + right_parallel + right_cond + right_nops;
1056
1057   unsigned long unknown         = ins_type_counters[ (int)INS_UNKNOWN ];
1058   unsigned long ins_long        = ins_type_counters[ (int)INS_LONG ];
1059   unsigned long parallel        = ins_type_counters[ (int)INS_PARALLEL ];
1060   unsigned long leftright       = ins_type_counters[ (int)INS_LEFTRIGHT ];
1061   unsigned long rightleft       = ins_type_counters[ (int)INS_RIGHTLEFT ];
1062   unsigned long cond_true       = ins_type_counters[ (int)INS_COND_TRUE ];
1063   unsigned long cond_false      = ins_type_counters[ (int)INS_COND_FALSE ];
1064   unsigned long cond_jump       = ins_type_counters[ (int)INS_COND_JUMP ];
1065   unsigned long cycles          = ins_type_counters[ (int)INS_CYCLES ];
1066   unsigned long total           = (unknown + left_total + right_total + ins_long);
1067
1068   int size                      = strlen (add_commas (buf1, sizeof (buf1), total));
1069   int parallel_size             = strlen (add_commas (buf1, sizeof (buf1),
1070                                                       (left_parallel > right_parallel) ? left_parallel : right_parallel));
1071   int cond_size                 = strlen (add_commas (buf1, sizeof (buf1), (left_cond > right_cond) ? left_cond : right_cond));
1072   int nop_size                  = strlen (add_commas (buf1, sizeof (buf1), (left_nops > right_nops) ? left_nops : right_nops));
1073   int normal_size               = strlen (add_commas (buf1, sizeof (buf1), (left > right) ? left : right));
1074
1075   sim_io_printf (sd,
1076                  "executed %*s left  instruction(s), %*s normal, %*s parallel, %*s EXExxx, %*s nops\n",
1077                  size, add_commas (buf1, sizeof (buf1), left_total),
1078                  normal_size, add_commas (buf2, sizeof (buf2), left),
1079                  parallel_size, add_commas (buf3, sizeof (buf3), left_parallel),
1080                  cond_size, add_commas (buf4, sizeof (buf4), left_cond),
1081                  nop_size, add_commas (buf5, sizeof (buf5), left_nops));
1082
1083   sim_io_printf (sd,
1084                  "executed %*s right instruction(s), %*s normal, %*s parallel, %*s EXExxx, %*s nops\n",
1085                  size, add_commas (buf1, sizeof (buf1), right_total),
1086                  normal_size, add_commas (buf2, sizeof (buf2), right),
1087                  parallel_size, add_commas (buf3, sizeof (buf3), right_parallel),
1088                  cond_size, add_commas (buf4, sizeof (buf4), right_cond),
1089                  nop_size, add_commas (buf5, sizeof (buf5), right_nops));
1090
1091   if (ins_long)
1092     sim_io_printf (sd,
1093                    "executed %*s long instruction(s)\n",
1094                    size, add_commas (buf1, sizeof (buf1), ins_long));
1095
1096   if (parallel)
1097     sim_io_printf (sd,
1098                    "executed %*s parallel instruction(s)\n",
1099                    size, add_commas (buf1, sizeof (buf1), parallel));
1100
1101   if (leftright)
1102     sim_io_printf (sd,
1103                    "executed %*s instruction(s) encoded L->R\n",
1104                    size, add_commas (buf1, sizeof (buf1), leftright));
1105
1106   if (rightleft)
1107     sim_io_printf (sd,
1108                    "executed %*s instruction(s) encoded R->L\n",
1109                    size, add_commas (buf1, sizeof (buf1), rightleft));
1110
1111   if (unknown)
1112     sim_io_printf (sd,
1113                    "executed %*s unknown instruction(s)\n",
1114                    size, add_commas (buf1, sizeof (buf1), unknown));
1115
1116   if (cond_true)
1117     sim_io_printf (sd,
1118                    "executed %*s instruction(s) due to EXExxx condition being true\n",
1119                    size, add_commas (buf1, sizeof (buf1), cond_true));
1120
1121   if (cond_false)
1122     sim_io_printf (sd,
1123                    "skipped  %*s instruction(s) due to EXExxx condition being false\n",
1124                    size, add_commas (buf1, sizeof (buf1), cond_false));
1125
1126   if (cond_jump)
1127     sim_io_printf (sd,
1128                    "skipped  %*s instruction(s) due to conditional branch succeeding\n",
1129                    size, add_commas (buf1, sizeof (buf1), cond_jump));
1130
1131   sim_io_printf (sd,
1132                  "executed %*s cycle(s)\n",
1133                  size, add_commas (buf1, sizeof (buf1), cycles));
1134
1135   sim_io_printf (sd,
1136                  "executed %*s total instructions\n",
1137                  size, add_commas (buf1, sizeof (buf1), total));
1138 }
1139
1140 SIM_RC
1141 sim_create_inferior (SIM_DESC sd, struct bfd *abfd, char **argv, char **env)
1142 {
1143   bfd_vma start_address;
1144
1145   /* reset all state information */
1146   memset (&State.regs, 0, (uintptr_t)&State.mem - (uintptr_t)&State.regs);
1147
1148   /* There was a hack here to copy the values of argc and argv into r0
1149      and r1.  The values were also saved into some high memory that
1150      won't be overwritten by the stack (0x7C00).  The reason for doing
1151      this was to allow the 'run' program to accept arguments.  Without
1152      the hack, this is not possible anymore.  If the simulator is run
1153      from the debugger, arguments cannot be passed in, so this makes
1154      no difference.  */
1155
1156   /* set PC */
1157   if (abfd != NULL)
1158     start_address = bfd_get_start_address (abfd);
1159   else
1160     start_address = 0xffc0 << 2;
1161 #ifdef DEBUG
1162   if (d10v_debug)
1163     sim_io_printf (sd, "sim_create_inferior:  PC=0x%lx\n", (long) start_address);
1164 #endif
1165   {
1166     SIM_CPU *cpu = STATE_CPU (sd, 0);
1167     SET_CREG (PC_CR, start_address >> 2);
1168   }
1169
1170   /* cpu resets imap0 to 0 and imap1 to 0x7f, but D10V-EVA board
1171      initializes imap0 and imap1 to 0x1000 as part of its ROM
1172      initialization. */
1173   if (old_segment_mapping)
1174     {
1175       /* External memory startup.  This is the HARD reset state. */
1176       set_imap_register (sd, 0, 0x0000);
1177       set_imap_register (sd, 1, 0x007f);
1178       set_dmap_register (sd, 0, 0x2000);
1179       set_dmap_register (sd, 1, 0x2000);
1180       set_dmap_register (sd, 2, 0x0000); /* Old DMAP */
1181       set_dmap_register (sd, 3, 0x0000);
1182     }
1183   else
1184     {
1185       /* Internal memory startup. This is the ROM intialized state. */
1186       set_imap_register (sd, 0, 0x1000);
1187       set_imap_register (sd, 1, 0x1000);
1188       set_dmap_register (sd, 0, 0x2000);
1189       set_dmap_register (sd, 1, 0x2000);
1190       set_dmap_register (sd, 2, 0x2000); /* DMAP2 initial internal value is
1191                                             0x2000 on the new board. */
1192       set_dmap_register (sd, 3, 0x0000);
1193     }
1194
1195   SLOT_FLUSH ();
1196   return SIM_RC_OK;
1197 }
1198
1199 int
1200 sim_fetch_register (SIM_DESC sd, int rn, unsigned char *memory, int length)
1201 {
1202   SIM_CPU *cpu = STATE_CPU (sd, 0);
1203   int size;
1204   switch ((enum sim_d10v_regs) rn)
1205     {
1206     case SIM_D10V_R0_REGNUM:
1207     case SIM_D10V_R1_REGNUM:
1208     case SIM_D10V_R2_REGNUM:
1209     case SIM_D10V_R3_REGNUM:
1210     case SIM_D10V_R4_REGNUM:
1211     case SIM_D10V_R5_REGNUM:
1212     case SIM_D10V_R6_REGNUM:
1213     case SIM_D10V_R7_REGNUM:
1214     case SIM_D10V_R8_REGNUM:
1215     case SIM_D10V_R9_REGNUM:
1216     case SIM_D10V_R10_REGNUM:
1217     case SIM_D10V_R11_REGNUM:
1218     case SIM_D10V_R12_REGNUM:
1219     case SIM_D10V_R13_REGNUM:
1220     case SIM_D10V_R14_REGNUM:
1221     case SIM_D10V_R15_REGNUM:
1222       WRITE_16 (memory, GPR (rn - SIM_D10V_R0_REGNUM));
1223       size = 2;
1224       break;
1225     case SIM_D10V_CR0_REGNUM:
1226     case SIM_D10V_CR1_REGNUM:
1227     case SIM_D10V_CR2_REGNUM:
1228     case SIM_D10V_CR3_REGNUM:
1229     case SIM_D10V_CR4_REGNUM:
1230     case SIM_D10V_CR5_REGNUM:
1231     case SIM_D10V_CR6_REGNUM:
1232     case SIM_D10V_CR7_REGNUM:
1233     case SIM_D10V_CR8_REGNUM:
1234     case SIM_D10V_CR9_REGNUM:
1235     case SIM_D10V_CR10_REGNUM:
1236     case SIM_D10V_CR11_REGNUM:
1237     case SIM_D10V_CR12_REGNUM:
1238     case SIM_D10V_CR13_REGNUM:
1239     case SIM_D10V_CR14_REGNUM:
1240     case SIM_D10V_CR15_REGNUM:
1241       WRITE_16 (memory, CREG (rn - SIM_D10V_CR0_REGNUM));
1242       size = 2;
1243       break;
1244     case SIM_D10V_A0_REGNUM:
1245     case SIM_D10V_A1_REGNUM:
1246       WRITE_64 (memory, ACC (rn - SIM_D10V_A0_REGNUM));
1247       size = 8;
1248       break;
1249     case SIM_D10V_SPI_REGNUM:
1250       /* PSW_SM indicates that the current SP is the USER
1251          stack-pointer. */
1252       WRITE_16 (memory, spi_register ());
1253       size = 2;
1254       break;
1255     case SIM_D10V_SPU_REGNUM:
1256       /* PSW_SM indicates that the current SP is the USER
1257          stack-pointer. */
1258       WRITE_16 (memory, spu_register ());
1259       size = 2;
1260       break;
1261     case SIM_D10V_IMAP0_REGNUM:
1262     case SIM_D10V_IMAP1_REGNUM:
1263       WRITE_16 (memory, imap_register (sd, cpu, NULL, rn - SIM_D10V_IMAP0_REGNUM));
1264       size = 2;
1265       break;
1266     case SIM_D10V_DMAP0_REGNUM:
1267     case SIM_D10V_DMAP1_REGNUM:
1268     case SIM_D10V_DMAP2_REGNUM:
1269     case SIM_D10V_DMAP3_REGNUM:
1270       WRITE_16 (memory, dmap_register (sd, cpu, NULL, rn - SIM_D10V_DMAP0_REGNUM));
1271       size = 2;
1272       break;
1273     case SIM_D10V_TS2_DMAP_REGNUM:
1274       size = 0;
1275       break;
1276     default:
1277       size = 0;
1278       break;
1279     }
1280   return size;
1281 }
1282
1283 int
1284 sim_store_register (SIM_DESC sd, int rn, unsigned char *memory, int length)
1285 {
1286   SIM_CPU *cpu = STATE_CPU (sd, 0);
1287   int size;
1288   switch ((enum sim_d10v_regs) rn)
1289     {
1290     case SIM_D10V_R0_REGNUM:
1291     case SIM_D10V_R1_REGNUM:
1292     case SIM_D10V_R2_REGNUM:
1293     case SIM_D10V_R3_REGNUM:
1294     case SIM_D10V_R4_REGNUM:
1295     case SIM_D10V_R5_REGNUM:
1296     case SIM_D10V_R6_REGNUM:
1297     case SIM_D10V_R7_REGNUM:
1298     case SIM_D10V_R8_REGNUM:
1299     case SIM_D10V_R9_REGNUM:
1300     case SIM_D10V_R10_REGNUM:
1301     case SIM_D10V_R11_REGNUM:
1302     case SIM_D10V_R12_REGNUM:
1303     case SIM_D10V_R13_REGNUM:
1304     case SIM_D10V_R14_REGNUM:
1305     case SIM_D10V_R15_REGNUM:
1306       SET_GPR (rn - SIM_D10V_R0_REGNUM, READ_16 (memory));
1307       size = 2;
1308       break;
1309     case SIM_D10V_CR0_REGNUM:
1310     case SIM_D10V_CR1_REGNUM:
1311     case SIM_D10V_CR2_REGNUM:
1312     case SIM_D10V_CR3_REGNUM:
1313     case SIM_D10V_CR4_REGNUM:
1314     case SIM_D10V_CR5_REGNUM:
1315     case SIM_D10V_CR6_REGNUM:
1316     case SIM_D10V_CR7_REGNUM:
1317     case SIM_D10V_CR8_REGNUM:
1318     case SIM_D10V_CR9_REGNUM:
1319     case SIM_D10V_CR10_REGNUM:
1320     case SIM_D10V_CR11_REGNUM:
1321     case SIM_D10V_CR12_REGNUM:
1322     case SIM_D10V_CR13_REGNUM:
1323     case SIM_D10V_CR14_REGNUM:
1324     case SIM_D10V_CR15_REGNUM:
1325       SET_CREG (rn - SIM_D10V_CR0_REGNUM, READ_16 (memory));
1326       size = 2;
1327       break;
1328     case SIM_D10V_A0_REGNUM:
1329     case SIM_D10V_A1_REGNUM:
1330       SET_ACC (rn - SIM_D10V_A0_REGNUM, READ_64 (memory) & MASK40);
1331       size = 8;
1332       break;
1333     case SIM_D10V_SPI_REGNUM:
1334       /* PSW_SM indicates that the current SP is the USER
1335          stack-pointer. */
1336       set_spi_register (READ_16 (memory));
1337       size = 2;
1338       break;
1339     case SIM_D10V_SPU_REGNUM:
1340       set_spu_register (READ_16 (memory));
1341       size = 2;
1342       break;
1343     case SIM_D10V_IMAP0_REGNUM:
1344     case SIM_D10V_IMAP1_REGNUM:
1345       set_imap_register (sd, rn - SIM_D10V_IMAP0_REGNUM, READ_16(memory));
1346       size = 2;
1347       break;
1348     case SIM_D10V_DMAP0_REGNUM:
1349     case SIM_D10V_DMAP1_REGNUM:
1350     case SIM_D10V_DMAP2_REGNUM:
1351     case SIM_D10V_DMAP3_REGNUM:
1352       set_dmap_register (sd, rn - SIM_D10V_DMAP0_REGNUM, READ_16(memory));
1353       size = 2;
1354       break;
1355     case SIM_D10V_TS2_DMAP_REGNUM:
1356       size = 0;
1357       break;
1358     default:
1359       size = 0;
1360       break;
1361     }
1362   SLOT_FLUSH ();
1363   return size;
1364 }