sim/sh/interp.c

   1 /* Simulator for the Renesas (formerly Hitachi) / SuperH Inc. SH architecture.
   2
   3    Written by Steve Chamberlain of Cygnus Support.
   4    sac@cygnus.com
   5
   6    This file is part of SH sim
   7
   8
   9                 THIS SOFTWARE IS NOT COPYRIGHTED
  10
  11    Cygnus offers the following for use in the public domain.  Cygnus
  12    makes no warranty with regard to the software or it's performance
  13    and the user accepts the software "AS IS" with all faults.
  14
  15    CYGNUS DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD TO
  16    THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17    MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  18
  19 */
  20
  21 #include "config.h"
  22
  23 #include <ctype.h>
  24 #include <stdio.h>
  25 #include <errno.h>
  26 #include <signal.h>
  27 #ifdef HAVE_UNISTD_H
  28 #include <unistd.h>
  29 #endif
  30 #ifdef HAVE_MMAP
  31 #include <sys/mman.h>
  32 # ifndef MAP_FAILED
  33 #  define MAP_FAILED -1
  34 # endif
  35 # if !defined (MAP_ANONYMOUS) && defined (MAP_ANON)
  36 #  define MAP_ANONYMOUS MAP_ANON
  37 # endif
  38 #endif
  39
  40 #ifdef HAVE_STRING_H
  41 #include <string.h>
  42 #else
  43 #ifdef HAVE_STRINGS_H
  44 #include <strings.h>
  45 #endif
  46 #endif
  47
  48 #ifdef HAVE_STDLIB_H
  49 #include <stdlib.h>
  50 #endif
  51
  52 #ifdef HAVE_SYS_STAT_H
  53 #include <sys/stat.h>
  54 #endif
  55 #ifdef HAVE_TIME_H
  56 #include <time.h>
  57 #endif
  58 #ifdef HAVE_SYS_TIME_H
  59 #include <sys/time.h>
  60 #endif
  61 #ifndef _WIN32
  62 #include <utime.h>
  63 #include <sys/wait.h>
  64 #endif
  65
  66 #include "bfd.h"
  67 #include "gdb/callback.h"
  68 #include "gdb/remote-sim.h"
  69 #include "gdb/sim-sh.h"
  70
  71 #include "sim-main.h"
  72 #include "sim-base.h"
  73 #include "sim-options.h"
  74
  75 /* This file is local - if newlib changes, then so should this.  */
  76 #include "syscall.h"
  77
  78 #include <math.h>
  79
  80 #ifdef _WIN32
  81 #include <float.h>              /* Needed for _isnan() */
  82 #define isnan _isnan
  83 #endif
  84
  85 #ifndef SIGBUS
  86 #define SIGBUS SIGSEGV
  87 #endif
  88
  89 #ifndef SIGQUIT
  90 #define SIGQUIT SIGTERM
  91 #endif
  92
  93 #ifndef SIGTRAP
  94 #define SIGTRAP 5
  95 #endif
  96
  97 /* TODO: Stop using these names.  */
  98 #undef SEXT
  99 #undef SEXT32
 100
 101 extern unsigned short sh_jump_table[], sh_dsp_table[0x1000], ppi_table[];
 102
 103 #define O_RECOMPILE 85
 104 #define DEFINE_TABLE
 105 #define DISASSEMBLER_TABLE
 106
 107 /* Define the rate at which the simulator should poll the host
 108    for a quit. */
 109 #define POLL_QUIT_INTERVAL 0x60000
 110
 111 /* TODO: Move into sim_cpu.  */
 112 saved_state_type saved_state;
 113
 114 struct loop_bounds { unsigned char *start, *end; };
 115
 116 /* These variables are at file scope so that functions other than
 117    sim_resume can use the fetch/store macros */
 118
 119 #define target_little_endian (CURRENT_TARGET_BYTE_ORDER == LITTLE_ENDIAN)
 120 static int global_endianw, endianb;
 121 static int target_dsp;
 122 #define host_little_endian (CURRENT_HOST_BYTE_ORDER == LITTLE_ENDIAN)
 123 static char **prog_argv;
 124
 125 static int maskw = 0;
 126 static int maskl = 0;
 127
 128 /* Short hand definitions of the registers */
 129
 130 #define SBIT(x) ((x)&sbit)
 131 #define R0      saved_state.asregs.regs[0]
 132 #define Rn      saved_state.asregs.regs[n]
 133 #define Rm      saved_state.asregs.regs[m]
 134 #define UR0     (unsigned int) (saved_state.asregs.regs[0])
 135 #define UR      (unsigned int) R
 136 #define UR      (unsigned int) R
 137 #define SR0     saved_state.asregs.regs[0]
 138 #define CREG(n) (saved_state.asregs.cregs.i[(n)])
 139 #define GBR     saved_state.asregs.cregs.named.gbr
 140 #define VBR     saved_state.asregs.cregs.named.vbr
 141 #define DBR     saved_state.asregs.cregs.named.dbr
 142 #define TBR     saved_state.asregs.cregs.named.tbr
 143 #define IBCR    saved_state.asregs.cregs.named.ibcr
 144 #define IBNR    saved_state.asregs.cregs.named.ibnr
 145 #define BANKN   (saved_state.asregs.cregs.named.ibnr & 0x1ff)
 146 #define ME      ((saved_state.asregs.cregs.named.ibnr >> 14) & 0x3)
 147 #define SSR     saved_state.asregs.cregs.named.ssr
 148 #define SPC     saved_state.asregs.cregs.named.spc
 149 #define SGR     saved_state.asregs.cregs.named.sgr
 150 #define SREG(n) (saved_state.asregs.sregs.i[(n)])
 151 #define MACH    saved_state.asregs.sregs.named.mach
 152 #define MACL    saved_state.asregs.sregs.named.macl
 153 #define PR      saved_state.asregs.sregs.named.pr
 154 #define FPUL    saved_state.asregs.sregs.named.fpul
 155
 156 #define PC insn_ptr
 157
 158
 159
 160 /* Alternate bank of registers r0-r7 */
 161
 162 /* Note: code controling SR handles flips between BANK0 and BANK1 */
 163 #define Rn_BANK(n) (saved_state.asregs.cregs.named.bank[(n)])
 164 #define SET_Rn_BANK(n, EXP) do { saved_state.asregs.cregs.named.bank[(n)] = (EXP); } while (0)
 165
 166
 167 /* Manipulate SR */
 168
 169 #define SR_MASK_BO  (1 << 14)
 170 #define SR_MASK_CS  (1 << 13)
 171 #define SR_MASK_DMY (1 << 11)
 172 #define SR_MASK_DMX (1 << 10)
 173 #define SR_MASK_M (1 << 9)
 174 #define SR_MASK_Q (1 << 8)
 175 #define SR_MASK_I (0xf << 4)
 176 #define SR_MASK_S (1 << 1)
 177 #define SR_MASK_T (1 << 0)
 178
 179 #define SR_MASK_BL (1 << 28)
 180 #define SR_MASK_RB (1 << 29)
 181 #define SR_MASK_MD (1 << 30)
 182 #define SR_MASK_RC 0x0fff0000
 183 #define SR_RC_INCREMENT -0x00010000
 184
 185 #define BO      ((saved_state.asregs.cregs.named.sr & SR_MASK_BO) != 0)
 186 #define CS      ((saved_state.asregs.cregs.named.sr & SR_MASK_CS) != 0)
 187 #define M       ((saved_state.asregs.cregs.named.sr & SR_MASK_M) != 0)
 188 #define Q       ((saved_state.asregs.cregs.named.sr & SR_MASK_Q) != 0)
 189 #define S       ((saved_state.asregs.cregs.named.sr & SR_MASK_S) != 0)
 190 #define T       ((saved_state.asregs.cregs.named.sr & SR_MASK_T) != 0)
 191 #define LDST    ((saved_state.asregs.cregs.named.ldst) != 0)
 192
 193 #define SR_BL ((saved_state.asregs.cregs.named.sr & SR_MASK_BL) != 0)
 194 #define SR_RB ((saved_state.asregs.cregs.named.sr & SR_MASK_RB) != 0)
 195 #define SR_MD ((saved_state.asregs.cregs.named.sr & SR_MASK_MD) != 0)
 196 #define SR_DMY ((saved_state.asregs.cregs.named.sr & SR_MASK_DMY) != 0)
 197 #define SR_DMX ((saved_state.asregs.cregs.named.sr & SR_MASK_DMX) != 0)
 198 #define SR_RC ((saved_state.asregs.cregs.named.sr & SR_MASK_RC))
 199
 200 /* Note: don't use this for privileged bits */
 201 #define SET_SR_BIT(EXP, BIT) \
 202 do { \
 203   if ((EXP) & 1) \
 204     saved_state.asregs.cregs.named.sr |= (BIT); \
 205   else \
 206     saved_state.asregs.cregs.named.sr &= ~(BIT); \
 207 } while (0)
 208
 209 #define SET_SR_BO(EXP) SET_SR_BIT ((EXP), SR_MASK_BO)
 210 #define SET_SR_CS(EXP) SET_SR_BIT ((EXP), SR_MASK_CS)
 211 #define SET_BANKN(EXP) \
 212 do { \
 213   IBNR = (IBNR & 0xfe00) | (EXP & 0x1f); \
 214 } while (0)
 215 #define SET_ME(EXP) \
 216 do { \
 217   IBNR = (IBNR & 0x3fff) | ((EXP & 0x3) << 14); \
 218 } while (0)
 219 #define SET_SR_M(EXP) SET_SR_BIT ((EXP), SR_MASK_M)
 220 #define SET_SR_Q(EXP) SET_SR_BIT ((EXP), SR_MASK_Q)
 221 #define SET_SR_S(EXP) SET_SR_BIT ((EXP), SR_MASK_S)
 222 #define SET_SR_T(EXP) SET_SR_BIT ((EXP), SR_MASK_T)
 223 #define SET_LDST(EXP) (saved_state.asregs.cregs.named.ldst = ((EXP) != 0))
 224
 225 /* stc currently relies on being able to read SR without modifications.  */
 226 #define GET_SR() (saved_state.asregs.cregs.named.sr - 0)
 227
 228 #define SET_SR(x) set_sr (x)
 229
 230 #define SET_RC(x) \
 231   (saved_state.asregs.cregs.named.sr \
 232    = saved_state.asregs.cregs.named.sr & 0xf000ffff | ((x) & 0xfff) << 16)
 233
 234 /* Manipulate FPSCR */
 235
 236 #define FPSCR_MASK_FR (1 << 21)
 237 #define FPSCR_MASK_SZ (1 << 20)
 238 #define FPSCR_MASK_PR (1 << 19)
 239
 240 #define FPSCR_FR  ((GET_FPSCR () & FPSCR_MASK_FR) != 0)
 241 #define FPSCR_SZ  ((GET_FPSCR () & FPSCR_MASK_SZ) != 0)
 242 #define FPSCR_PR  ((GET_FPSCR () & FPSCR_MASK_PR) != 0)
 243
 244 /* Count the number of arguments in an argv.  */
 245 static int
 246 count_argc (char **argv)
 247 {
 248   int i;
 249
 250   if (! argv)
 251     return -1;
 252
 253   for (i = 0; argv[i] != NULL; ++i)
 254     continue;
 255   return i;
 256 }
 257
 258 static void
 259 set_fpscr1 (int x)
 260 {
 261   int old = saved_state.asregs.sregs.named.fpscr;
 262   saved_state.asregs.sregs.named.fpscr = (x);
 263   /* swap the floating point register banks */
 264   if ((saved_state.asregs.sregs.named.fpscr ^ old) & FPSCR_MASK_FR
 265       /* Ignore bit change if simulating sh-dsp.  */
 266       && ! target_dsp)
 267     {
 268       union fregs_u tmpf = saved_state.asregs.fregs[0];
 269       saved_state.asregs.fregs[0] = saved_state.asregs.fregs[1];
 270       saved_state.asregs.fregs[1] = tmpf;
 271     }
 272 }
 273
 274 /* sts relies on being able to read fpscr directly.  */
 275 #define GET_FPSCR()  (saved_state.asregs.sregs.named.fpscr)
 276 #define SET_FPSCR(x) \
 277 do { \
 278   set_fpscr1 (x); \
 279 } while (0)
 280
 281 #define DSR  (saved_state.asregs.sregs.named.fpscr)
 282
 283 #define RAISE_EXCEPTION(x) \
 284   (saved_state.asregs.exception = x, saved_state.asregs.insn_end = 0)
 285
 286 #define RAISE_EXCEPTION_IF_IN_DELAY_SLOT() \
 287   if (in_delay_slot) RAISE_EXCEPTION (SIGILL)
 288
 289 /* This function exists mainly for the purpose of setting a breakpoint to
 290    catch simulated bus errors when running the simulator under GDB.  */
 291
 292 static void
 293 raise_exception (int x)
 294 {
 295   RAISE_EXCEPTION (x);
 296 }
 297
 298 static void
 299 raise_buserror (void)
 300 {
 301   raise_exception (SIGBUS);
 302 }
 303
 304 #define PROCESS_SPECIAL_ADDRESS(addr, endian, ptr, bits_written, \
 305                                 forbidden_addr_bits, data, retval) \
 306 do { \
 307   if (addr & forbidden_addr_bits) \
 308     { \
 309       raise_buserror (); \
 310       return retval; \
 311     } \
 312   else if ((addr & saved_state.asregs.xyram_select) \
 313            == saved_state.asregs.xram_start) \
 314     ptr = (void *) &saved_state.asregs.xmem_offset[addr ^ endian]; \
 315   else if ((addr & saved_state.asregs.xyram_select) \
 316            == saved_state.asregs.yram_start) \
 317     ptr = (void *) &saved_state.asregs.ymem_offset[addr ^ endian]; \
 318   else if ((unsigned) addr >> 24 == 0xf0 \
 319            && bits_written == 32 && (data & 1) == 0) \
 320     /* This invalidates (if not associative) or might invalidate \
 321        (if associative) an instruction cache line.  This is used for \
 322        trampolines.  Since we don't simulate the cache, this is a no-op \
 323        as far as the simulator is concerned.  */ \
 324     return retval; \
 325   else \
 326     { \
 327       if (bits_written == 8 && addr > 0x5000000) \
 328         IOMEM (addr, 1, data); \
 329       /* We can't do anything useful with the other stuff, so fail.  */ \
 330       raise_buserror (); \
 331       return retval; \
 332     } \
 333 } while (0)
 334
 335 /* FIXME: sim_resume should be renamed to sim_engine_run.  sim_resume
 336    being implemented by ../common/sim_resume.c and the below should
 337    make a call to sim_engine_halt */
 338
 339 #define BUSERROR(addr, mask) ((addr) & (mask))
 340
 341 #define WRITE_BUSERROR(addr, mask, data, addr_func) \
 342   do \
 343     { \
 344       if (addr & mask) \
 345         { \
 346           addr_func (addr, data); \
 347           return; \
 348         } \
 349     } \
 350   while (0)
 351
 352 #define READ_BUSERROR(addr, mask, addr_func) \
 353   do \
 354     { \
 355       if (addr & mask) \
 356         return addr_func (addr); \
 357     } \
 358   while (0)
 359
 360 /* Define this to enable register lifetime checking.
 361    The compiler generates "add #0,rn" insns to mark registers as invalid,
 362    the simulator uses this info to call fail if it finds a ref to an invalid
 363    register before a def
 364
 365    #define PARANOID
 366 */
 367
 368 #ifdef PARANOID
 369 int valid[16];
 370 #define CREF(x)  if (!valid[x]) fail ();
 371 #define CDEF(x)  valid[x] = 1;
 372 #define UNDEF(x) valid[x] = 0;
 373 #else
 374 #define CREF(x)
 375 #define CDEF(x)
 376 #define UNDEF(x)
 377 #endif
 378
 379 static void parse_and_set_memory_size (const char *str);
 380 static int IOMEM (int addr, int write, int value);
 381 static struct loop_bounds get_loop_bounds (int, int, unsigned char *,
 382                                            unsigned char *, int, int);
 383 static void process_wlat_addr (int, int);
 384 static void process_wwat_addr (int, int);
 385 static void process_wbat_addr (int, int);
 386 static int process_rlat_addr (int);
 387 static int process_rwat_addr (int);
 388 static int process_rbat_addr (int);
 389
 390 static host_callback *callback;
 391
 392
 393
 394 /* Floating point registers */
 395
 396 #define DR(n) (get_dr (n))
 397 static double
 398 get_dr (int n)
 399 {
 400   n = (n & ~1);
 401   if (host_little_endian)
 402     {
 403       union
 404       {
 405         int i[2];
 406         double d;
 407       } dr;
 408       dr.i[1] = saved_state.asregs.fregs[0].i[n + 0];
 409       dr.i[0] = saved_state.asregs.fregs[0].i[n + 1];
 410       return dr.d;
 411     }
 412   else
 413     return (saved_state.asregs.fregs[0].d[n >> 1]);
 414 }
 415
 416 #define SET_DR(n, EXP) set_dr ((n), (EXP))
 417 static void
 418 set_dr (int n, double exp)
 419 {
 420   n = (n & ~1);
 421   if (host_little_endian)
 422     {
 423       union
 424       {
 425         int i[2];
 426         double d;
 427       } dr;
 428       dr.d = exp;
 429       saved_state.asregs.fregs[0].i[n + 0] = dr.i[1];
 430       saved_state.asregs.fregs[0].i[n + 1] = dr.i[0];
 431     }
 432   else
 433     saved_state.asregs.fregs[0].d[n >> 1] = exp;
 434 }
 435
 436 #define SET_FI(n,EXP) (saved_state.asregs.fregs[0].i[(n)] = (EXP))
 437 #define FI(n) (saved_state.asregs.fregs[0].i[(n)])
 438
 439 #define FR(n) (saved_state.asregs.fregs[0].f[(n)])
 440 #define SET_FR(n,EXP) (saved_state.asregs.fregs[0].f[(n)] = (EXP))
 441
 442 #define XD_TO_XF(n) ((((n) & 1) << 5) | ((n) & 0x1e))
 443 #define XF(n) (saved_state.asregs.fregs[(n) >> 5].i[(n) & 0x1f])
 444 #define SET_XF(n,EXP) (saved_state.asregs.fregs[(n) >> 5].i[(n) & 0x1f] = (EXP))
 445
 446 #define RS saved_state.asregs.cregs.named.rs
 447 #define RE saved_state.asregs.cregs.named.re
 448 #define MOD (saved_state.asregs.cregs.named.mod)
 449 #define SET_MOD(i) \
 450 (MOD = (i), \
 451  MOD_ME = (unsigned) MOD >> 16 | (SR_DMY ? ~0xffff : (SR_DMX ? 0 : 0x10000)), \
 452  MOD_DELTA = (MOD & 0xffff) - ((unsigned) MOD >> 16))
 453
 454 #define DSP_R(n) saved_state.asregs.sregs.i[(n)]
 455 #define DSP_GRD(n) DSP_R ((n) + 8)
 456 #define GET_DSP_GRD(n) ((n | 2) == 7 ? SEXT (DSP_GRD (n)) : SIGN32 (DSP_R (n)))
 457 #define A1 DSP_R (5)
 458 #define A0 DSP_R (7)
 459 #define X0 DSP_R (8)
 460 #define X1 DSP_R (9)
 461 #define Y0 DSP_R (10)
 462 #define Y1 DSP_R (11)
 463 #define M0 DSP_R (12)
 464 #define A1G DSP_R (13)
 465 #define M1 DSP_R (14)
 466 #define A0G DSP_R (15)
 467 /* DSP_R (16) / DSP_GRD (16) are used as a fake destination for pcmp.  */
 468 #define MOD_ME DSP_GRD (17)
 469 #define MOD_DELTA DSP_GRD (18)
 470
 471 #define FP_OP(n, OP, m) \
 472 { \
 473   if (FPSCR_PR) \
 474     { \
 475       if (((n) & 1) || ((m) & 1)) \
 476         RAISE_EXCEPTION (SIGILL); \
 477       else \
 478         SET_DR (n, (DR (n) OP DR (m))); \
 479     } \
 480   else \
 481     SET_FR (n, (FR (n) OP FR (m))); \
 482 } while (0)
 483
 484 #define FP_UNARY(n, OP) \
 485 { \
 486   if (FPSCR_PR) \
 487     { \
 488       if ((n) & 1) \
 489         RAISE_EXCEPTION (SIGILL); \
 490       else \
 491         SET_DR (n, (OP (DR (n)))); \
 492     } \
 493   else \
 494     SET_FR (n, (OP (FR (n)))); \
 495 } while (0)
 496
 497 #define FP_CMP(n, OP, m) \
 498 { \
 499   if (FPSCR_PR) \
 500     { \
 501       if (((n) & 1) || ((m) & 1)) \
 502         RAISE_EXCEPTION (SIGILL); \
 503       else \
 504         SET_SR_T (DR (n) OP DR (m)); \
 505     } \
 506   else \
 507     SET_SR_T (FR (n) OP FR (m)); \
 508 } while (0)
 509
 510 static void
 511 set_sr (int new_sr)
 512 {
 513   /* do we need to swap banks */
 514   int old_gpr = SR_MD && SR_RB;
 515   int new_gpr = (new_sr & SR_MASK_MD) && (new_sr & SR_MASK_RB);
 516   if (old_gpr != new_gpr)
 517     {
 518       int i, tmp;
 519       for (i = 0; i < 8; i++)
 520         {
 521           tmp = saved_state.asregs.cregs.named.bank[i];
 522           saved_state.asregs.cregs.named.bank[i] = saved_state.asregs.regs[i];
 523           saved_state.asregs.regs[i] = tmp;
 524         }
 525     }
 526   saved_state.asregs.cregs.named.sr = new_sr;
 527   SET_MOD (MOD);
 528 }
 529
 530 static INLINE void
 531 wlat_fast (unsigned char *memory, int x, int value, int maskl)
 532 {
 533   int v = value;
 534   unsigned int *p = (unsigned int *) (memory + x);
 535   WRITE_BUSERROR (x, maskl, v, process_wlat_addr);
 536   *p = v;
 537 }
 538
 539 static INLINE void
 540 wwat_fast (unsigned char *memory, int x, int value, int maskw, int endianw)
 541 {
 542   int v = value;
 543   unsigned short *p = (unsigned short *) (memory + (x ^ endianw));
 544   WRITE_BUSERROR (x, maskw, v, process_wwat_addr);
 545   *p = v;
 546 }
 547
 548 static INLINE void
 549 wbat_fast (unsigned char *memory, int x, int value, int maskb)
 550 {
 551   unsigned char *p = memory + (x ^ endianb);
 552   WRITE_BUSERROR (x, maskb, value, process_wbat_addr);
 553
 554   p[0] = value;
 555 }
 556
 557 /* Read functions */
 558
 559 static INLINE int
 560 rlat_fast (unsigned char *memory, int x, int maskl)
 561 {
 562   unsigned int *p = (unsigned int *) (memory + x);
 563   READ_BUSERROR (x, maskl, process_rlat_addr);
 564
 565   return *p;
 566 }
 567
 568 static INLINE int
 569 rwat_fast (unsigned char *memory, int x, int maskw, int endianw)
 570 {
 571   unsigned short *p = (unsigned short *) (memory + (x ^ endianw));
 572   READ_BUSERROR (x, maskw, process_rwat_addr);
 573
 574   return *p;
 575 }
 576
 577 static INLINE int
 578 riat_fast (unsigned char *insn_ptr, int endianw)
 579 {
 580   unsigned short *p = (unsigned short *) ((size_t) insn_ptr ^ endianw);
 581
 582   return *p;
 583 }
 584
 585 static INLINE int
 586 rbat_fast (unsigned char *memory, int x, int maskb)
 587 {
 588   unsigned char *p = memory + (x ^ endianb);
 589   READ_BUSERROR (x, maskb, process_rbat_addr);
 590
 591   return *p;
 592 }
 593
 594 #define RWAT(x)         (rwat_fast (memory, x, maskw, endianw))
 595 #define RLAT(x)         (rlat_fast (memory, x, maskl))
 596 #define RBAT(x)         (rbat_fast (memory, x, maskb))
 597 #define RIAT(p)         (riat_fast ((p), endianw))
 598 #define WWAT(x,v)       (wwat_fast (memory, x, v, maskw, endianw))
 599 #define WLAT(x,v)       (wlat_fast (memory, x, v, maskl))
 600 #define WBAT(x,v)       (wbat_fast (memory, x, v, maskb))
 601
 602 #define RUWAT(x)  (RWAT (x) & 0xffff)
 603 #define RSWAT(x)  ((short) (RWAT (x)))
 604 #define RSLAT(x)  ((long) (RLAT (x)))
 605 #define RSBAT(x)  (SEXT (RBAT (x)))
 606
 607 #define RDAT(x, n) (do_rdat (memory, (x), (n), (maskl)))
 608 static int
 609 do_rdat (unsigned char *memory, int x, int n, int maskl)
 610 {
 611   int f0;
 612   int f1;
 613   int i = (n & 1);
 614   int j = (n & ~1);
 615   f0 = rlat_fast (memory, x + 0, maskl);
 616   f1 = rlat_fast (memory, x + 4, maskl);
 617   saved_state.asregs.fregs[i].i[(j + 0)] = f0;
 618   saved_state.asregs.fregs[i].i[(j + 1)] = f1;
 619   return 0;
 620 }
 621
 622 #define WDAT(x, n) (do_wdat (memory, (x), (n), (maskl)))
 623 static int
 624 do_wdat (unsigned char *memory, int x, int n, int maskl)
 625 {
 626   int f0;
 627   int f1;
 628   int i = (n & 1);
 629   int j = (n & ~1);
 630   f0 = saved_state.asregs.fregs[i].i[(j + 0)];
 631   f1 = saved_state.asregs.fregs[i].i[(j + 1)];
 632   wlat_fast (memory, (x + 0), f0, maskl);
 633   wlat_fast (memory, (x + 4), f1, maskl);
 634   return 0;
 635 }
 636
 637 static void
 638 process_wlat_addr (int addr, int value)
 639 {
 640   unsigned int *ptr;
 641
 642   PROCESS_SPECIAL_ADDRESS (addr, endianb, ptr, 32, 3, value, );
 643   *ptr = value;
 644 }
 645
 646 static void
 647 process_wwat_addr (int addr, int value)
 648 {
 649   unsigned short *ptr;
 650
 651   PROCESS_SPECIAL_ADDRESS (addr, endianb, ptr, 16, 1, value, );
 652   *ptr = value;
 653 }
 654
 655 static void
 656 process_wbat_addr (int addr, int value)
 657 {
 658   unsigned char *ptr;
 659
 660   PROCESS_SPECIAL_ADDRESS (addr, endianb, ptr, 8, 0, value, );
 661   *ptr = value;
 662 }
 663
 664 static int
 665 process_rlat_addr (int addr)
 666 {
 667   unsigned char *ptr;
 668
 669   PROCESS_SPECIAL_ADDRESS (addr, endianb, ptr, -32, 3, -1, 0);
 670   return *ptr;
 671 }
 672
 673 static int
 674 process_rwat_addr (int addr)
 675 {
 676   unsigned char *ptr;
 677
 678   PROCESS_SPECIAL_ADDRESS (addr, endianb, ptr, -16, 1, -1, 0);
 679   return *ptr;
 680 }
 681
 682 static int
 683 process_rbat_addr (int addr)
 684 {
 685   unsigned char *ptr;
 686
 687   PROCESS_SPECIAL_ADDRESS (addr, endianb, ptr, -8, 0, -1, 0);
 688   return *ptr;
 689 }
 690
 691 #define SEXT(x)         (((x &  0xff) ^ (~0x7f))+0x80)
 692 #define SEXT12(x)       (((x & 0xfff) ^ 0x800) - 0x800)
 693 #define SEXTW(y)        ((int) ((short) y))
 694 #if 0
 695 #define SEXT32(x)       ((int) ((x & 0xffffffff) ^ 0x80000000U) - 0x7fffffff - 1)
 696 #else
 697 #define SEXT32(x)       ((int) (x))
 698 #endif
 699 #define SIGN32(x)       (SEXT32 (x) >> 31)
 700
 701 /* convert pointer from target to host value.  */
 702 #define PT2H(x) ((x) + memory)
 703 /* convert pointer from host to target value.  */
 704 #define PH2T(x) ((x) - memory)
 705
 706 #define SKIP_INSN(p) ((p) += ((RIAT (p) & 0xfc00) == 0xf800 ? 4 : 2))
 707
 708 #define SET_NIP(x) nip = (x); CHECK_INSN_PTR (nip);
 709
 710 static int in_delay_slot = 0;
 711 #define Delay_Slot(TEMPPC)      iword = RIAT (TEMPPC); in_delay_slot = 1; goto top;
 712
 713 #define CHECK_INSN_PTR(p) \
 714 do { \
 715   if (saved_state.asregs.exception || PH2T (p) & maskw) \
 716     saved_state.asregs.insn_end = 0; \
 717   else if (p < loop.end) \
 718     saved_state.asregs.insn_end = loop.end; \
 719   else \
 720     saved_state.asregs.insn_end = mem_end; \
 721 } while (0)
 722
 723 #ifdef ACE_FAST
 724
 725 #define MA(n)
 726 #define L(x)
 727 #define TL(x)
 728 #define TB(x)
 729
 730 #else
 731
 732 #define MA(n) \
 733   do { memstalls += ((((long) PC & 3) != 0) ? (n) : ((n) - 1)); } while (0)
 734
 735 #define L(x)   thislock = x;
 736 #define TL(x)  if ((x) == prevlock) stalls++;
 737 #define TB(x,y)  if ((x) == prevlock || (y) == prevlock) stalls++;
 738
 739 #endif
 740
 741 #if defined(__GO32__)
 742 int sim_memory_size = 19;
 743 #else
 744 int sim_memory_size = 24;
 745 #endif
 746
 747 static int sim_profile_size = 17;
 748 static int nsamples;
 749
 750 #undef TB
 751 #define TB(x,y)
 752
 753 #define SMR1 (0x05FFFEC8)       /* Channel 1  serial mode register */
 754 #define BRR1 (0x05FFFEC9)       /* Channel 1  bit rate register */
 755 #define SCR1 (0x05FFFECA)       /* Channel 1  serial control register */
 756 #define TDR1 (0x05FFFECB)       /* Channel 1  transmit data register */
 757 #define SSR1 (0x05FFFECC)       /* Channel 1  serial status register */
 758 #define RDR1 (0x05FFFECD)       /* Channel 1  receive data register */
 759
 760 #define SCI_RDRF         0x40   /* Recieve data register full */
 761 #define SCI_TDRE        0x80    /* Transmit data register empty */
 762
 763 static int
 764 IOMEM (int addr, int write, int value)
 765 {
 766   if (write)
 767     {
 768       switch (addr)
 769         {
 770         case TDR1:
 771           if (value != '\r')
 772             {
 773               putchar (value);
 774               fflush (stdout);
 775             }
 776           break;
 777         }
 778     }
 779   else
 780     {
 781       switch (addr)
 782         {
 783         case RDR1:
 784           return getchar ();
 785         }
 786     }
 787   return 0;
 788 }
 789
 790 static int
 791 get_now (void)
 792 {
 793   return time ((long *) 0);
 794 }
 795
 796 static int
 797 now_persec (void)
 798 {
 799   return 1;
 800 }
 801
 802 static FILE *profile_file;
 803
 804 static INLINE unsigned
 805 swap (unsigned n)
 806 {
 807   if (endianb)
 808     n = (n << 24 | (n & 0xff00) << 8
 809          | (n & 0xff0000) >> 8 | (n & 0xff000000) >> 24);
 810   return n;
 811 }
 812
 813 static INLINE unsigned short
 814 swap16 (unsigned short n)
 815 {
 816   if (endianb)
 817     n = n << 8 | (n & 0xff00) >> 8;
 818   return n;
 819 }
 820
 821 static void
 822 swapout (int n)
 823 {
 824   if (profile_file)
 825     {
 826       union { char b[4]; int n; } u;
 827       u.n = swap (n);
 828       fwrite (u.b, 4, 1, profile_file);
 829     }
 830 }
 831
 832 static void
 833 swapout16 (int n)
 834 {
 835   union { char b[4]; int n; } u;
 836   u.n = swap16 (n);
 837   fwrite (u.b, 2, 1, profile_file);
 838 }
 839
 840 /* Turn a pointer in a register into a pointer into real memory. */
 841
 842 static char *
 843 ptr (int x)
 844 {
 845   return (char *) (x + saved_state.asregs.memory);
 846 }
 847
 848 /* STR points to a zero-terminated string in target byte order.  Return
 849    the number of bytes that need to be converted to host byte order in order
 850    to use this string as a zero-terminated string on the host.
 851    (Not counting the rounding up needed to operate on entire words.)  */
 852 static int
 853 strswaplen (int str)
 854 {
 855   unsigned char *memory = saved_state.asregs.memory;
 856   int start, end;
 857   int endian = endianb;
 858
 859   if (! endian)
 860     return 0;
 861   end = str;
 862   for (end = str; memory[end ^ endian]; end++) ;
 863   return end - str + 1;
 864 }
 865
 866 static void
 867 strnswap (int str, int len)
 868 {
 869   int *start, *end;
 870
 871   if (! endianb || ! len)
 872     return;
 873   start = (int *) ptr (str & ~3);
 874   end = (int *) ptr (str + len);
 875   do
 876     {
 877       int old = *start;
 878       *start = (old << 24 | (old & 0xff00) << 8
 879                 | (old & 0xff0000) >> 8 | (old & 0xff000000) >> 24);
 880       start++;
 881     }
 882   while (start < end);
 883 }
 884
 885 /* Simulate a monitor trap, put the result into r0 and errno into r1
 886    return offset by which to adjust pc.  */
 887
 888 static int
 889 trap (int i, int *regs, unsigned char *insn_ptr, unsigned char *memory,
 890       int maskl, int maskw, int endianw)
 891 {
 892   switch (i)
 893     {
 894     case 1:
 895       printf ("%c", regs[0]);
 896       break;
 897     case 2:
 898       raise_exception (SIGQUIT);
 899       break;
 900     case 3:                     /* FIXME: for backwards compat, should be removed */
 901     case 33:
 902       {
 903         unsigned int countp = * (unsigned int *) (insn_ptr + 4);
 904
 905         WLAT (countp, RLAT (countp) + 1);
 906         return 6;
 907       }
 908     case 34:
 909       {
 910         extern int errno;
 911         int perrno = errno;
 912         errno = 0;
 913
 914         switch (regs[4])
 915           {
 916
 917 #if !defined(__GO32__) && !defined(_WIN32)
 918           case SYS_fork:
 919             regs[0] = fork ();
 920             break;
 921 /* This would work only if endianness matched between host and target.
 922    Besides, it's quite dangerous.  */
 923 #if 0
 924           case SYS_execve:
 925             regs[0] = execve (ptr (regs[5]), (char **) ptr (regs[6]),
 926                               (char **) ptr (regs[7]));
 927             break;
 928           case SYS_execv:
 929             regs[0] = execve (ptr (regs[5]), (char **) ptr (regs[6]), 0);
 930             break;
 931 #endif
 932           case SYS_pipe:
 933             {
 934               regs[0] = (BUSERROR (regs[5], maskl)
 935                          ? -EINVAL
 936                          : pipe ((int *) ptr (regs[5])));
 937             }
 938             break;
 939
 940           case SYS_wait:
 941             regs[0] = wait ((int *) ptr (regs[5]));
 942             break;
 943 #endif /* !defined(__GO32__) && !defined(_WIN32) */
 944
 945           case SYS_read:
 946             strnswap (regs[6], regs[7]);
 947             regs[0]
 948               = callback->read (callback, regs[5], ptr (regs[6]), regs[7]);
 949             strnswap (regs[6], regs[7]);
 950             break;
 951           case SYS_write:
 952             strnswap (regs[6], regs[7]);
 953             if (regs[5] == 1)
 954               regs[0] = (int) callback->write_stdout (callback,
 955                                                       ptr (regs[6]), regs[7]);
 956             else
 957               regs[0] = (int) callback->write (callback, regs[5],
 958                                                ptr (regs[6]), regs[7]);
 959             strnswap (regs[6], regs[7]);
 960             break;
 961           case SYS_lseek:
 962             regs[0] = callback->lseek (callback,regs[5], regs[6], regs[7]);
 963             break;
 964           case SYS_close:
 965             regs[0] = callback->close (callback,regs[5]);
 966             break;
 967           case SYS_open:
 968             {
 969               int len = strswaplen (regs[5]);
 970               strnswap (regs[5], len);
 971               regs[0] = callback->open (callback, ptr (regs[5]), regs[6]);
 972               strnswap (regs[5], len);
 973               break;
 974             }
 975           case SYS_exit:
 976             /* EXIT - caller can look in r5 to work out the reason */
 977             raise_exception (SIGQUIT);
 978             regs[0] = regs[5];
 979             break;
 980
 981           case SYS_stat:        /* added at hmsi */
 982             /* stat system call */
 983             {
 984               struct stat host_stat;
 985               int buf;
 986               int len = strswaplen (regs[5]);
 987
 988               strnswap (regs[5], len);
 989               regs[0] = stat (ptr (regs[5]), &host_stat);
 990               strnswap (regs[5], len);
 991
 992               buf = regs[6];
 993
 994               WWAT (buf, host_stat.st_dev);
 995               buf += 2;
 996               WWAT (buf, host_stat.st_ino);
 997               buf += 2;
 998               WLAT (buf, host_stat.st_mode);
 999               buf += 4;
1000               WWAT (buf, host_stat.st_nlink);
1001               buf += 2;
1002               WWAT (buf, host_stat.st_uid);
1003               buf += 2;
1004               WWAT (buf, host_stat.st_gid);
1005               buf += 2;
1006               WWAT (buf, host_stat.st_rdev);
1007               buf += 2;
1008               WLAT (buf, host_stat.st_size);
1009               buf += 4;
1010               WLAT (buf, host_stat.st_atime);
1011               buf += 4;
1012               WLAT (buf, 0);
1013               buf += 4;
1014               WLAT (buf, host_stat.st_mtime);
1015               buf += 4;
1016               WLAT (buf, 0);
1017               buf += 4;
1018               WLAT (buf, host_stat.st_ctime);
1019               buf += 4;
1020               WLAT (buf, 0);
1021               buf += 4;
1022               WLAT (buf, 0);
1023               buf += 4;
1024               WLAT (buf, 0);
1025               buf += 4;
1026             }
1027             break;
1028
1029 #ifndef _WIN32
1030           case SYS_chown:
1031             {
1032               int len = strswaplen (regs[5]);
1033
1034               strnswap (regs[5], len);
1035               regs[0] = chown (ptr (regs[5]), regs[6], regs[7]);
1036               strnswap (regs[5], len);
1037               break;
1038             }
1039 #endif /* _WIN32 */
1040           case SYS_chmod:
1041             {
1042               int len = strswaplen (regs[5]);
1043
1044               strnswap (regs[5], len);
1045               regs[0] = chmod (ptr (regs[5]), regs[6]);
1046               strnswap (regs[5], len);
1047               break;
1048             }
1049           case SYS_utime:
1050             {
1051               /* Cast the second argument to void *, to avoid type mismatch
1052                  if a prototype is present.  */
1053               int len = strswaplen (regs[5]);
1054
1055               strnswap (regs[5], len);
1056               regs[0] = utime (ptr (regs[5]), (void *) ptr (regs[6]));
1057               strnswap (regs[5], len);
1058               break;
1059             }
1060           case SYS_argc:
1061             regs[0] = count_argc (prog_argv);
1062             break;
1063           case SYS_argnlen:
1064             if (regs[5] < count_argc (prog_argv))
1065               regs[0] = strlen (prog_argv[regs[5]]);
1066             else
1067               regs[0] = -1;
1068             break;
1069           case SYS_argn:
1070             if (regs[5] < count_argc (prog_argv))
1071               {
1072                 /* Include the termination byte.  */
1073                 int i = strlen (prog_argv[regs[5]]) + 1;
1074                 regs[0] = sim_write (0, regs[6], (void *) prog_argv[regs[5]], i);
1075               }
1076             else
1077               regs[0] = -1;
1078             break;
1079           case SYS_time:
1080             regs[0] = get_now ();
1081             break;
1082           case SYS_ftruncate:
1083             regs[0] = callback->ftruncate (callback, regs[5], regs[6]);
1084             break;
1085           case SYS_truncate:
1086             {
1087               int len = strswaplen (regs[5]);
1088               strnswap (regs[5], len);
1089               regs[0] = callback->truncate (callback, ptr (regs[5]), regs[6]);
1090               strnswap (regs[5], len);
1091               break;
1092             }
1093           default:
1094             regs[0] = -1;
1095             break;
1096           }
1097         regs[1] = callback->get_errno (callback);
1098         errno = perrno;
1099       }
1100       break;
1101
1102     case 13:    /* Set IBNR */
1103       IBNR = regs[0] & 0xffff;
1104       break;
1105     case 14:    /* Set IBCR */
1106       IBCR = regs[0] & 0xffff;
1107       break;
1108     case 0xc3:
1109     case 255:
1110       raise_exception (SIGTRAP);
1111       if (i == 0xc3)
1112         return -2;
1113       break;
1114     }
1115   return 0;
1116 }
1117
1118 static void
1119 div1 (int *R, int iRn2, int iRn1/*, int T*/)
1120 {
1121   unsigned long tmp0;
1122   unsigned char old_q, tmp1;
1123
1124   old_q = Q;
1125   SET_SR_Q ((unsigned char) ((0x80000000 & R[iRn1]) != 0));
1126   R[iRn1] <<= 1;
1127   R[iRn1] |= (unsigned long) T;
1128
1129   switch (old_q)
1130     {
1131     case 0:
1132       switch (M)
1133         {
1134         case 0:
1135           tmp0 = R[iRn1];
1136           R[iRn1] -= R[iRn2];
1137           tmp1 = (R[iRn1] > tmp0);
1138           switch (Q)
1139             {
1140             case 0:
1141               SET_SR_Q (tmp1);
1142               break;
1143             case 1:
1144               SET_SR_Q ((unsigned char) (tmp1 == 0));
1145               break;
1146             }
1147           break;
1148         case 1:
1149           tmp0 = R[iRn1];
1150           R[iRn1] += R[iRn2];
1151           tmp1 = (R[iRn1] < tmp0);
1152           switch (Q)
1153             {
1154             case 0:
1155               SET_SR_Q ((unsigned char) (tmp1 == 0));
1156               break;
1157             case 1:
1158               SET_SR_Q (tmp1);
1159               break;
1160             }
1161           break;
1162         }
1163       break;
1164     case 1:
1165       switch (M)
1166         {
1167         case 0:
1168           tmp0 = R[iRn1];
1169           R[iRn1] += R[iRn2];
1170           tmp1 = (R[iRn1] < tmp0);
1171           switch (Q)
1172             {
1173             case 0:
1174               SET_SR_Q (tmp1);
1175               break;
1176             case 1:
1177               SET_SR_Q ((unsigned char) (tmp1 == 0));
1178               break;
1179             }
1180           break;
1181         case 1:
1182           tmp0 = R[iRn1];
1183           R[iRn1] -= R[iRn2];
1184           tmp1 = (R[iRn1] > tmp0);
1185           switch (Q)
1186             {
1187             case 0:
1188               SET_SR_Q ((unsigned char) (tmp1 == 0));
1189               break;
1190             case 1:
1191               SET_SR_Q (tmp1);
1192               break;
1193             }
1194           break;
1195         }
1196       break;
1197     }
1198   /*T = (Q == M);*/
1199   SET_SR_T (Q == M);
1200   /*return T;*/
1201 }
1202
1203 static void
1204 dmul (int sign, unsigned int rm, unsigned int rn)
1205 {
1206   unsigned long RnL, RnH;
1207   unsigned long RmL, RmH;
1208   unsigned long temp0, temp1, temp2, temp3;
1209   unsigned long Res2, Res1, Res0;
1210
1211   RnL = rn & 0xffff;
1212   RnH = (rn >> 16) & 0xffff;
1213   RmL = rm & 0xffff;
1214   RmH = (rm >> 16) & 0xffff;
1215   temp0 = RmL * RnL;
1216   temp1 = RmH * RnL;
1217   temp2 = RmL * RnH;
1218   temp3 = RmH * RnH;
1219   Res2 = 0;
1220   Res1 = temp1 + temp2;
1221   if (Res1 < temp1)
1222     Res2 += 0x00010000;
1223   temp1 = (Res1 << 16) & 0xffff0000;
1224   Res0 = temp0 + temp1;
1225   if (Res0 < temp0)
1226     Res2 += 1;
1227   Res2 += ((Res1 >> 16) & 0xffff) + temp3;
1228
1229   if (sign)
1230     {
1231       if (rn & 0x80000000)
1232         Res2 -= rm;
1233       if (rm & 0x80000000)
1234         Res2 -= rn;
1235     }
1236
1237   MACH = Res2;
1238   MACL = Res0;
1239 }
1240
1241 static void
1242 macw (int *regs, unsigned char *memory, int n, int m, int endianw)
1243 {
1244   long tempm, tempn;
1245   long prod, macl, sum;
1246
1247   tempm=RSWAT (regs[m]); regs[m]+=2;
1248   tempn=RSWAT (regs[n]); regs[n]+=2;
1249
1250   macl = MACL;
1251   prod = (long) (short) tempm * (long) (short) tempn;
1252   sum = prod + macl;
1253   if (S)
1254     {
1255       if ((~(prod ^ macl) & (sum ^ prod)) < 0)
1256         {
1257           /* MACH's lsb is a sticky overflow bit.  */
1258           MACH |= 1;
1259           /* Store the smallest negative number in MACL if prod is
1260              negative, and the largest positive number otherwise.  */
1261           sum = 0x7fffffff + (prod < 0);
1262         }
1263     }
1264   else
1265     {
1266       long mach;
1267       /* Add to MACH the sign extended product, and carry from low sum.  */
1268       mach = MACH + (-(prod < 0)) + ((unsigned long) sum < prod);
1269       /* Sign extend at 10:th bit in MACH.  */
1270       MACH = (mach & 0x1ff) | -(mach & 0x200);
1271     }
1272   MACL = sum;
1273 }
1274
1275 static void
1276 macl (int *regs, unsigned char *memory, int n, int m)
1277 {
1278   long tempm, tempn;
1279   long macl, mach;
1280   long long ans;
1281   long long mac64;
1282
1283   tempm = RSLAT (regs[m]);
1284   regs[m] += 4;
1285
1286   tempn = RSLAT (regs[n]);
1287   regs[n] += 4;
1288
1289   mach = MACH;
1290   macl = MACL;
1291
1292   mac64 = ((long long) macl & 0xffffffff) |
1293           ((long long) mach & 0xffffffff) << 32;
1294
1295   ans = (long long) tempm * (long long) tempn; /* Multiply 32bit * 32bit */
1296
1297   mac64 += ans; /* Accumulate 64bit + 64 bit */
1298
1299   macl = (long) (mac64 & 0xffffffff);
1300   mach = (long) ((mac64 >> 32) & 0xffffffff);
1301
1302   if (S)  /* Store only 48 bits of the result */
1303     {
1304       if (mach < 0) /* Result is negative */
1305         {
1306           mach = mach & 0x0000ffff; /* Mask higher 16 bits */
1307           mach |= 0xffff8000; /* Sign extend higher 16 bits */
1308         }
1309       else
1310         mach = mach & 0x00007fff; /* Postive Result */
1311     }
1312
1313   MACL = macl;
1314   MACH = mach;
1315 }
1316
1317 enum {
1318   B_BCLR = 0,
1319   B_BSET = 1,
1320   B_BST  = 2,
1321   B_BLD  = 3,
1322   B_BAND = 4,
1323   B_BOR  = 5,
1324   B_BXOR = 6,
1325   B_BLDNOT = 11,
1326   B_BANDNOT = 12,
1327   B_BORNOT = 13,
1328
1329   MOVB_RM = 0x0000,
1330   MOVW_RM = 0x1000,
1331   MOVL_RM = 0x2000,
1332   FMOV_RM = 0x3000,
1333   MOVB_MR = 0x4000,
1334   MOVW_MR = 0x5000,
1335   MOVL_MR = 0x6000,
1336   FMOV_MR = 0x7000,
1337   MOVU_BMR = 0x8000,
1338   MOVU_WMR = 0x9000,
1339 };
1340
1341 /* Do extended displacement move instructions.  */
1342 static void
1343 do_long_move_insn (int op, int disp12, int m, int n, int *thatlock)
1344 {
1345   int memstalls = 0;
1346   int thislock = *thatlock;
1347   int endianw = global_endianw;
1348   int *R = &(saved_state.asregs.regs[0]);
1349   unsigned char *memory = saved_state.asregs.memory;
1350   int maskb = ~((saved_state.asregs.msize - 1) & ~0);
1351   unsigned char *insn_ptr = PT2H (saved_state.asregs.pc);
1352
1353   switch (op) {
1354   case MOVB_RM:         /* signed */
1355     WBAT (disp12 * 1 + R[n], R[m]);
1356     break;
1357   case MOVW_RM:
1358     WWAT (disp12 * 2 + R[n], R[m]);
1359     break;
1360   case MOVL_RM:
1361     WLAT (disp12 * 4 + R[n], R[m]);
1362     break;
1363   case FMOV_RM:         /* floating point */
1364     if (FPSCR_SZ)
1365       {
1366         MA (1);
1367         WDAT (R[n] + 8 * disp12, m);
1368       }
1369     else
1370       WLAT (R[n] + 4 * disp12, FI (m));
1371     break;
1372   case MOVB_MR:
1373     R[n] = RSBAT (disp12 * 1 + R[m]);
1374     L (n);
1375     break;
1376   case MOVW_MR:
1377     R[n] = RSWAT (disp12 * 2 + R[m]);
1378     L (n);
1379     break;
1380   case MOVL_MR:
1381     R[n] = RLAT (disp12 * 4 + R[m]);
1382     L (n);
1383     break;
1384   case FMOV_MR:
1385     if (FPSCR_SZ) {
1386       MA (1);
1387       RDAT (R[m] + 8 * disp12, n);
1388     }
1389     else
1390       SET_FI (n, RLAT (R[m] + 4 * disp12));
1391     break;
1392   case MOVU_BMR:        /* unsigned */
1393     R[n] = RBAT (disp12 * 1 + R[m]);
1394     L (n);
1395     break;
1396   case MOVU_WMR:
1397     R[n] = RWAT (disp12 * 2 + R[m]);
1398     L (n);
1399     break;
1400   default:
1401     RAISE_EXCEPTION (SIGINT);
1402     exit (1);
1403   }
1404   saved_state.asregs.memstalls += memstalls;
1405   *thatlock = thislock;
1406 }
1407
1408 /* Do binary logical bit-manipulation insns.  */
1409 static void
1410 do_blog_insn (int imm, int addr, int binop,
1411               unsigned char *memory, int maskb)
1412 {
1413   int oldval = RBAT (addr);
1414
1415   switch (binop) {
1416   case B_BCLR:  /* bclr.b */
1417     WBAT (addr, oldval & ~imm);
1418     break;
1419   case B_BSET:  /* bset.b */
1420     WBAT (addr, oldval | imm);
1421     break;
1422   case B_BST:   /* bst.b */
1423     if (T)
1424       WBAT (addr, oldval | imm);
1425     else
1426       WBAT (addr, oldval & ~imm);
1427     break;
1428   case B_BLD:   /* bld.b */
1429     SET_SR_T ((oldval & imm) != 0);
1430     break;
1431   case B_BAND:  /* band.b */
1432     SET_SR_T (T && ((oldval & imm) != 0));
1433     break;
1434   case B_BOR:   /* bor.b */
1435     SET_SR_T (T || ((oldval & imm) != 0));
1436     break;
1437   case B_BXOR:  /* bxor.b */
1438     SET_SR_T (T ^ ((oldval & imm) != 0));
1439     break;
1440   case B_BLDNOT:        /* bldnot.b */
1441     SET_SR_T ((oldval & imm) == 0);
1442     break;
1443   case B_BANDNOT:       /* bandnot.b */
1444     SET_SR_T (T && ((oldval & imm) == 0));
1445     break;
1446   case B_BORNOT:        /* bornot.b */
1447     SET_SR_T (T || ((oldval & imm) == 0));
1448     break;
1449   }
1450 }
1451
1452 static float
1453 fsca_s (int in, double (*f) (double))
1454 {
1455   double rad = ldexp ((in & 0xffff), -15) * 3.141592653589793238462643383;
1456   double result = (*f) (rad);
1457   double error, upper, lower, frac;
1458   int exp;
1459
1460   /* Search the value with the maximum error that is still within the
1461      architectural spec.  */
1462   error = ldexp (1., -21);
1463   /* compensate for calculation inaccuracy by reducing error.  */
1464   error = error - ldexp (1., -50);
1465   upper = result + error;
1466   frac = frexp (upper, &exp);
1467   upper = ldexp (floor (ldexp (frac, 24)), exp - 24);
1468   lower = result - error;
1469   frac = frexp (lower, &exp);
1470   lower = ldexp (ceil (ldexp (frac, 24)), exp - 24);
1471   return abs (upper - result) >= abs (lower - result) ? upper : lower;
1472 }
1473
1474 static float
1475 fsrra_s (float in)
1476 {
1477   double result = 1. / sqrt (in);
1478   int exp;
1479   double frac, upper, lower, error, eps;
1480
1481   /* refine result */
1482   result = result - (result * result * in - 1) * 0.5 * result;
1483   /* Search the value with the maximum error that is still within the
1484      architectural spec.  */
1485   frac = frexp (result, &exp);
1486   frac = ldexp (frac, 24);
1487   error = 4.0; /* 1 << 24-1-21 */
1488   /* use eps to compensate for possible 1 ulp error in our 'exact' result.  */
1489   eps = ldexp (1., -29);
1490   upper = floor (frac + error - eps);
1491   if (upper > 16777216.)
1492     upper = floor ((frac + error - eps) * 0.5) * 2.;
1493   lower = ceil ((frac - error + eps) * 2) * .5;
1494   if (lower > 8388608.)
1495     lower = ceil (frac - error + eps);
1496   upper = ldexp (upper, exp - 24);
1497   lower = ldexp (lower, exp - 24);
1498   return upper - result >= result - lower ? upper : lower;
1499 }
1500
1501
1502 /* GET_LOOP_BOUNDS {EXTENDED}
1503    These two functions compute the actual starting and ending point
1504    of the repeat loop, based on the RS and RE registers (repeat start,
1505    repeat stop).  The extended version is called for LDRC, and the
1506    regular version is called for SETRC.  The difference is that for
1507    LDRC, the loop start and end instructions are literally the ones
1508    pointed to by RS and RE -- for SETRC, they're not (see docs).  */
1509
1510 static struct loop_bounds
1511 get_loop_bounds_ext (int rs, int re, unsigned char *memory,
1512                      unsigned char *mem_end, int maskw, int endianw)
1513 {
1514   struct loop_bounds loop;
1515
1516   /* FIXME: should I verify RS < RE?  */
1517   loop.start = PT2H (RS);       /* FIXME not using the params?  */
1518   loop.end   = PT2H (RE & ~1);  /* Ignore bit 0 of RE.  */
1519   SKIP_INSN (loop.end);
1520   if (loop.end >= mem_end)
1521     loop.end = PT2H (0);
1522   return loop;
1523 }
1524
1525 static struct loop_bounds
1526 get_loop_bounds (int rs, int re, unsigned char *memory, unsigned char *mem_end,
1527                  int maskw, int endianw)
1528 {
1529   struct loop_bounds loop;
1530
1531   if (SR_RC)
1532     {
1533       if (RS >= RE)
1534         {
1535           loop.start = PT2H (RE - 4);
1536           SKIP_INSN (loop.start);
1537           loop.end = loop.start;
1538           if (RS - RE == 0)
1539             SKIP_INSN (loop.end);
1540           if (RS - RE <= 2)
1541             SKIP_INSN (loop.end);
1542           SKIP_INSN (loop.end);
1543         }
1544       else
1545         {
1546           loop.start = PT2H (RS);
1547           loop.end = PT2H (RE - 4);
1548           SKIP_INSN (loop.end);
1549           SKIP_INSN (loop.end);
1550           SKIP_INSN (loop.end);
1551           SKIP_INSN (loop.end);
1552         }
1553       if (loop.end >= mem_end)
1554         loop.end = PT2H (0);
1555     }
1556   else
1557     loop.end = PT2H (0);
1558
1559   return loop;
1560 }
1561
1562 static void ppi_insn ();
1563
1564 #include "ppi.c"
1565
1566 /* Provide calloc / free versions that use an anonymous mmap.  This can
1567    significantly cut the start-up time when a large simulator memory is
1568    required, because pages are only zeroed on demand.  */
1569 #ifdef MAP_ANONYMOUS
1570 static void *
1571 mcalloc (size_t nmemb, size_t size)
1572 {
1573   void *page;
1574
1575   if (nmemb != 1)
1576     size *= nmemb;
1577   return mmap (0, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS,
1578                -1, 0);
1579 }
1580
1581 #define mfree(start,length) munmap ((start), (length))
1582 #else
1583 #define mcalloc calloc
1584 #define mfree(start,length) free(start)
1585 #endif
1586
1587 /* Set the memory size to the power of two provided. */
1588
1589 static void
1590 sim_size (int power)
1591 {
1592   sim_memory_size = power;
1593
1594   if (saved_state.asregs.memory)
1595     {
1596       mfree (saved_state.asregs.memory, saved_state.asregs.msize);
1597     }
1598
1599   saved_state.asregs.msize = 1 << power;
1600
1601   saved_state.asregs.memory =
1602     (unsigned char *) mcalloc (1, saved_state.asregs.msize);
1603
1604   if (!saved_state.asregs.memory)
1605     {
1606       fprintf (stderr,
1607                "Not enough VM for simulation of %d bytes of RAM\n",
1608                saved_state.asregs.msize);
1609
1610       saved_state.asregs.msize = 1;
1611       saved_state.asregs.memory = (unsigned char *) mcalloc (1, 1);
1612     }
1613 }
1614
1615 static void
1616 init_dsp (struct bfd *abfd)
1617 {
1618   int was_dsp = target_dsp;
1619   unsigned long mach = bfd_get_mach (abfd);
1620
1621   if (mach == bfd_mach_sh_dsp  ||
1622       mach == bfd_mach_sh4al_dsp ||
1623       mach == bfd_mach_sh3_dsp)
1624     {
1625       int ram_area_size, xram_start, yram_start;
1626       int new_select;
1627
1628       target_dsp = 1;
1629       if (mach == bfd_mach_sh_dsp)
1630         {
1631           /* SH7410 (orig. sh-sdp):
1632              4KB each for X & Y memory;
1633              On-chip X RAM 0x0800f000-0x0800ffff
1634              On-chip Y RAM 0x0801f000-0x0801ffff  */
1635           xram_start = 0x0800f000;
1636           ram_area_size = 0x1000;
1637         }
1638       if (mach == bfd_mach_sh3_dsp || mach == bfd_mach_sh4al_dsp)
1639         {
1640           /* SH7612:
1641              8KB each for X & Y memory;
1642              On-chip X RAM 0x1000e000-0x1000ffff
1643              On-chip Y RAM 0x1001e000-0x1001ffff  */
1644           xram_start = 0x1000e000;
1645           ram_area_size = 0x2000;
1646         }
1647       yram_start = xram_start + 0x10000;
1648       new_select = ~(ram_area_size - 1);
1649       if (saved_state.asregs.xyram_select != new_select)
1650         {
1651           saved_state.asregs.xyram_select = new_select;
1652           free (saved_state.asregs.xmem);
1653           free (saved_state.asregs.ymem);
1654           saved_state.asregs.xmem =
1655             (unsigned char *) calloc (1, ram_area_size);
1656           saved_state.asregs.ymem =
1657             (unsigned char *) calloc (1, ram_area_size);
1658
1659           /* Disable use of X / Y mmeory if not allocated.  */
1660           if (! saved_state.asregs.xmem || ! saved_state.asregs.ymem)
1661             {
1662               saved_state.asregs.xyram_select = 0;
1663               if (saved_state.asregs.xmem)
1664                 free (saved_state.asregs.xmem);
1665               if (saved_state.asregs.ymem)
1666                 free (saved_state.asregs.ymem);
1667             }
1668         }
1669       saved_state.asregs.xram_start = xram_start;
1670       saved_state.asregs.yram_start = yram_start;
1671       saved_state.asregs.xmem_offset = saved_state.asregs.xmem - xram_start;
1672       saved_state.asregs.ymem_offset = saved_state.asregs.ymem - yram_start;
1673     }
1674   else
1675     {
1676       target_dsp = 0;
1677       if (saved_state.asregs.xyram_select)
1678         {
1679           saved_state.asregs.xyram_select = 0;
1680           free (saved_state.asregs.xmem);
1681           free (saved_state.asregs.ymem);
1682         }
1683     }
1684
1685   if (! saved_state.asregs.xyram_select)
1686     {
1687       saved_state.asregs.xram_start = 1;
1688       saved_state.asregs.yram_start = 1;
1689     }
1690
1691   if (saved_state.asregs.regstack == NULL)
1692     saved_state.asregs.regstack =
1693       calloc (512, sizeof *saved_state.asregs.regstack);
1694
1695   if (target_dsp != was_dsp)
1696     {
1697       int i, tmp;
1698
1699       for (i = (sizeof sh_dsp_table / sizeof sh_dsp_table[0]) - 1; i >= 0; i--)
1700         {
1701           tmp = sh_jump_table[0xf000 + i];
1702           sh_jump_table[0xf000 + i] = sh_dsp_table[i];
1703           sh_dsp_table[i] = tmp;
1704         }
1705     }
1706 }
1707
1708 static void
1709 init_pointers (void)
1710 {
1711   if (saved_state.asregs.msize != 1 << sim_memory_size)
1712     {
1713       sim_size (sim_memory_size);
1714     }
1715
1716   if (saved_state.asregs.profile && !profile_file)
1717     {
1718       profile_file = fopen ("gmon.out", "wb");
1719       /* Seek to where to put the call arc data */
1720       nsamples = (1 << sim_profile_size);
1721
1722       fseek (profile_file, nsamples * 2 + 12, 0);
1723
1724       if (!profile_file)
1725         {
1726           fprintf (stderr, "Can't open gmon.out\n");
1727         }
1728       else
1729         {
1730           saved_state.asregs.profile_hist =
1731             (unsigned short *) calloc (64, (nsamples * sizeof (short) / 64));
1732         }
1733     }
1734 }
1735
1736 static void
1737 dump_profile (void)
1738 {
1739   unsigned int minpc;
1740   unsigned int maxpc;
1741   unsigned short *p;
1742   int i;
1743
1744   p = saved_state.asregs.profile_hist;
1745   minpc = 0;
1746   maxpc = (1 << sim_profile_size);
1747
1748   fseek (profile_file, 0L, 0);
1749   swapout (minpc << PROFILE_SHIFT);
1750   swapout (maxpc << PROFILE_SHIFT);
1751   swapout (nsamples * 2 + 12);
1752   for (i = 0; i < nsamples; i++)
1753     swapout16 (saved_state.asregs.profile_hist[i]);
1754
1755 }
1756
1757 static void
1758 gotcall (int from, int to)
1759 {
1760   swapout (from);
1761   swapout (to);
1762   swapout (1);
1763 }
1764
1765 #define MMASKB ((saved_state.asregs.msize -1) & ~0)
1766
1767 void
1768 sim_resume (SIM_DESC sd, int step, int siggnal)
1769 {
1770   register unsigned char *insn_ptr;
1771   unsigned char *mem_end;
1772   struct loop_bounds loop;
1773   register int cycles = 0;
1774   register int stalls = 0;
1775   register int memstalls = 0;
1776   register int insts = 0;
1777   register int prevlock;
1778 #if 1
1779   int thislock;
1780 #else
1781   register int thislock;
1782 #endif
1783   register unsigned int doprofile;
1784   register int pollcount = 0;
1785   /* endianw is used for every insn fetch, hence it makes sense to cache it.
1786      endianb is used less often.  */
1787   register int endianw = global_endianw;
1788
1789   int tick_start = get_now ();
1790   void (*prev_fpe) ();
1791
1792   register unsigned short *jump_table = sh_jump_table;
1793
1794   register int *R = &(saved_state.asregs.regs[0]);
1795   /*register int T;*/
1796 #ifndef PR
1797   register int PR;
1798 #endif
1799
1800   register int maskb = ~((saved_state.asregs.msize - 1) & ~0);
1801   register int maskw = ~((saved_state.asregs.msize - 1) & ~1);
1802   register int maskl = ~((saved_state.asregs.msize - 1) & ~3);
1803   register unsigned char *memory;
1804   register unsigned int sbit = ((unsigned int) 1 << 31);
1805
1806   prev_fpe = signal (SIGFPE, SIG_IGN);
1807
1808   init_pointers ();
1809   saved_state.asregs.exception = 0;
1810
1811   memory = saved_state.asregs.memory;
1812   mem_end = memory + saved_state.asregs.msize;
1813
1814   if (RE & 1)
1815     loop = get_loop_bounds_ext (RS, RE, memory, mem_end, maskw, endianw);
1816   else
1817     loop = get_loop_bounds     (RS, RE, memory, mem_end, maskw, endianw);
1818
1819   insn_ptr = PT2H (saved_state.asregs.pc);
1820   CHECK_INSN_PTR (insn_ptr);
1821
1822 #ifndef PR
1823   PR = saved_state.asregs.sregs.named.pr;
1824 #endif
1825   /*T = GET_SR () & SR_MASK_T;*/
1826   prevlock = saved_state.asregs.prevlock;
1827   thislock = saved_state.asregs.thislock;
1828   doprofile = saved_state.asregs.profile;
1829
1830   /* If profiling not enabled, disable it by asking for
1831      profiles infrequently. */
1832   if (doprofile == 0)
1833     doprofile = ~0;
1834
1835  loop:
1836   if (step && insn_ptr < saved_state.asregs.insn_end)
1837     {
1838       if (saved_state.asregs.exception)
1839         /* This can happen if we've already been single-stepping and
1840            encountered a loop end.  */
1841         saved_state.asregs.insn_end = insn_ptr;
1842       else
1843         {
1844           saved_state.asregs.exception = SIGTRAP;
1845           saved_state.asregs.insn_end = insn_ptr + 2;
1846         }
1847     }
1848
1849   while (insn_ptr < saved_state.asregs.insn_end)
1850     {
1851       register unsigned int iword = RIAT (insn_ptr);
1852       register unsigned int ult;
1853       register unsigned char *nip = insn_ptr + 2;
1854
1855 #ifndef ACE_FAST
1856       insts++;
1857 #endif
1858     top:
1859
1860 #include "code.c"
1861
1862
1863       in_delay_slot = 0;
1864       insn_ptr = nip;
1865
1866       if (--pollcount < 0)
1867         {
1868           pollcount = POLL_QUIT_INTERVAL;
1869           if ((*callback->poll_quit) != NULL
1870               && (*callback->poll_quit) (callback))
1871             {
1872               sim_stop (sd);
1873             }
1874         }
1875
1876 #ifndef ACE_FAST
1877       prevlock = thislock;
1878       thislock = 30;
1879       cycles++;
1880
1881       if (cycles >= doprofile)
1882         {
1883
1884           saved_state.asregs.cycles += doprofile;
1885           cycles -= doprofile;
1886           if (saved_state.asregs.profile_hist)
1887             {
1888               int n = PH2T (insn_ptr) >> PROFILE_SHIFT;
1889               if (n < nsamples)
1890                 {
1891                   int i = saved_state.asregs.profile_hist[n];
1892                   if (i < 65000)
1893                     saved_state.asregs.profile_hist[n] = i + 1;
1894                 }
1895
1896             }
1897         }
1898 #endif
1899     }
1900   if (saved_state.asregs.insn_end == loop.end)
1901     {
1902       saved_state.asregs.cregs.named.sr += SR_RC_INCREMENT;
1903       if (SR_RC)
1904         insn_ptr = loop.start;
1905       else
1906         {
1907           saved_state.asregs.insn_end = mem_end;
1908           loop.end = PT2H (0);
1909         }
1910       goto loop;
1911     }
1912
1913   if (saved_state.asregs.exception == SIGILL
1914       || saved_state.asregs.exception == SIGBUS)
1915     {
1916       insn_ptr -= 2;
1917     }
1918   /* Check for SIGBUS due to insn fetch.  */
1919   else if (! saved_state.asregs.exception)
1920     saved_state.asregs.exception = SIGBUS;
1921
1922   saved_state.asregs.ticks += get_now () - tick_start;
1923   saved_state.asregs.cycles += cycles;
1924   saved_state.asregs.stalls += stalls;
1925   saved_state.asregs.memstalls += memstalls;
1926   saved_state.asregs.insts += insts;
1927   saved_state.asregs.pc = PH2T (insn_ptr);
1928 #ifndef PR
1929   saved_state.asregs.sregs.named.pr = PR;
1930 #endif
1931
1932   saved_state.asregs.prevlock = prevlock;
1933   saved_state.asregs.thislock = thislock;
1934
1935   if (profile_file)
1936     {
1937       dump_profile ();
1938     }
1939
1940   signal (SIGFPE, prev_fpe);
1941 }
1942
1943 int
1944 sim_write (SIM_DESC sd, SIM_ADDR addr, const unsigned char *buffer, int size)
1945 {
1946   int i;
1947
1948   init_pointers ();
1949
1950   for (i = 0; i < size; i++)
1951     {
1952       saved_state.asregs.memory[(MMASKB & (addr + i)) ^ endianb] = buffer[i];
1953     }
1954   return size;
1955 }
1956
1957 int
1958 sim_read (SIM_DESC sd, SIM_ADDR addr, unsigned char *buffer, int size)
1959 {
1960   int i;
1961
1962   init_pointers ();
1963
1964   for (i = 0; i < size; i++)
1965     {
1966       buffer[i] = saved_state.asregs.memory[(MMASKB & (addr + i)) ^ endianb];
1967     }
1968   return size;
1969 }
1970
1971 static int gdb_bank_number;
1972 enum {
1973   REGBANK_MACH = 15,
1974   REGBANK_IVN  = 16,
1975   REGBANK_PR   = 17,
1976   REGBANK_GBR  = 18,
1977   REGBANK_MACL = 19
1978 };
1979
1980 int
1981 sim_store_register (SIM_DESC sd, int rn, unsigned char *memory, int length)
1982 {
1983   unsigned val;
1984
1985   init_pointers ();
1986   val = swap (* (int *) memory);
1987   switch (rn)
1988     {
1989     case SIM_SH_R0_REGNUM: case SIM_SH_R1_REGNUM: case SIM_SH_R2_REGNUM:
1990     case SIM_SH_R3_REGNUM: case SIM_SH_R4_REGNUM: case SIM_SH_R5_REGNUM:
1991     case SIM_SH_R6_REGNUM: case SIM_SH_R7_REGNUM: case SIM_SH_R8_REGNUM:
1992     case SIM_SH_R9_REGNUM: case SIM_SH_R10_REGNUM: case SIM_SH_R11_REGNUM:
1993     case SIM_SH_R12_REGNUM: case SIM_SH_R13_REGNUM: case SIM_SH_R14_REGNUM:
1994     case SIM_SH_R15_REGNUM:
1995       saved_state.asregs.regs[rn] = val;
1996       break;
1997     case SIM_SH_PC_REGNUM:
1998       saved_state.asregs.pc = val;
1999       break;
2000     case SIM_SH_PR_REGNUM:
2001       PR = val;
2002       break;
2003     case SIM_SH_GBR_REGNUM:
2004       GBR = val;
2005       break;
2006     case SIM_SH_VBR_REGNUM:
2007       VBR = val;
2008       break;
2009     case SIM_SH_MACH_REGNUM:
2010       MACH = val;
2011       break;
2012     case SIM_SH_MACL_REGNUM:
2013       MACL = val;
2014       break;
2015     case SIM_SH_SR_REGNUM:
2016       SET_SR (val);
2017       break;
2018     case SIM_SH_FPUL_REGNUM:
2019       FPUL = val;
2020       break;
2021     case SIM_SH_FPSCR_REGNUM:
2022       SET_FPSCR (val);
2023       break;
2024     case SIM_SH_FR0_REGNUM: case SIM_SH_FR1_REGNUM: case SIM_SH_FR2_REGNUM:
2025     case SIM_SH_FR3_REGNUM: case SIM_SH_FR4_REGNUM: case SIM_SH_FR5_REGNUM:
2026     case SIM_SH_FR6_REGNUM: case SIM_SH_FR7_REGNUM: case SIM_SH_FR8_REGNUM:
2027     case SIM_SH_FR9_REGNUM: case SIM_SH_FR10_REGNUM: case SIM_SH_FR11_REGNUM:
2028     case SIM_SH_FR12_REGNUM: case SIM_SH_FR13_REGNUM: case SIM_SH_FR14_REGNUM:
2029     case SIM_SH_FR15_REGNUM:
2030       SET_FI (rn - SIM_SH_FR0_REGNUM, val);
2031       break;
2032     case SIM_SH_DSR_REGNUM:
2033       DSR = val;
2034       break;
2035     case SIM_SH_A0G_REGNUM:
2036       A0G = val;
2037       break;
2038     case SIM_SH_A0_REGNUM:
2039       A0 = val;
2040       break;
2041     case SIM_SH_A1G_REGNUM:
2042       A1G = val;
2043       break;
2044     case SIM_SH_A1_REGNUM:
2045       A1 = val;
2046       break;
2047     case SIM_SH_M0_REGNUM:
2048       M0 = val;
2049       break;
2050     case SIM_SH_M1_REGNUM:
2051       M1 = val;
2052       break;
2053     case SIM_SH_X0_REGNUM:
2054       X0 = val;
2055       break;
2056     case SIM_SH_X1_REGNUM:
2057       X1 = val;
2058       break;
2059     case SIM_SH_Y0_REGNUM:
2060       Y0 = val;
2061       break;
2062     case SIM_SH_Y1_REGNUM:
2063       Y1 = val;
2064       break;
2065     case SIM_SH_MOD_REGNUM:
2066       SET_MOD (val);
2067       break;
2068     case SIM_SH_RS_REGNUM:
2069       RS = val;
2070       break;
2071     case SIM_SH_RE_REGNUM:
2072       RE = val;
2073       break;
2074     case SIM_SH_SSR_REGNUM:
2075       SSR = val;
2076       break;
2077     case SIM_SH_SPC_REGNUM:
2078       SPC = val;
2079       break;
2080     /* The rn_bank idiosyncracies are not due to hardware differences, but to
2081        a weird aliasing naming scheme for sh3 / sh3e / sh4.  */
2082     case SIM_SH_R0_BANK0_REGNUM: case SIM_SH_R1_BANK0_REGNUM:
2083     case SIM_SH_R2_BANK0_REGNUM: case SIM_SH_R3_BANK0_REGNUM:
2084     case SIM_SH_R4_BANK0_REGNUM: case SIM_SH_R5_BANK0_REGNUM:
2085     case SIM_SH_R6_BANK0_REGNUM: case SIM_SH_R7_BANK0_REGNUM:
2086       if (saved_state.asregs.bfd_mach == bfd_mach_sh2a)
2087         {
2088           rn -= SIM_SH_R0_BANK0_REGNUM;
2089           saved_state.asregs.regstack[gdb_bank_number].regs[rn] = val;
2090         }
2091       else
2092       if (SR_MD && SR_RB)
2093         Rn_BANK (rn - SIM_SH_R0_BANK0_REGNUM) = val;
2094       else
2095         saved_state.asregs.regs[rn - SIM_SH_R0_BANK0_REGNUM] = val;
2096       break;
2097     case SIM_SH_R0_BANK1_REGNUM: case SIM_SH_R1_BANK1_REGNUM:
2098     case SIM_SH_R2_BANK1_REGNUM: case SIM_SH_R3_BANK1_REGNUM:
2099     case SIM_SH_R4_BANK1_REGNUM: case SIM_SH_R5_BANK1_REGNUM:
2100     case SIM_SH_R6_BANK1_REGNUM: case SIM_SH_R7_BANK1_REGNUM:
2101       if (saved_state.asregs.bfd_mach == bfd_mach_sh2a)
2102         {
2103           rn -= SIM_SH_R0_BANK1_REGNUM;
2104           saved_state.asregs.regstack[gdb_bank_number].regs[rn + 8] = val;
2105         }
2106       else
2107       if (SR_MD && SR_RB)
2108         saved_state.asregs.regs[rn - SIM_SH_R0_BANK1_REGNUM] = val;
2109       else
2110         Rn_BANK (rn - SIM_SH_R0_BANK1_REGNUM) = val;
2111       break;
2112     case SIM_SH_R0_BANK_REGNUM: case SIM_SH_R1_BANK_REGNUM:
2113     case SIM_SH_R2_BANK_REGNUM: case SIM_SH_R3_BANK_REGNUM:
2114     case SIM_SH_R4_BANK_REGNUM: case SIM_SH_R5_BANK_REGNUM:
2115     case SIM_SH_R6_BANK_REGNUM: case SIM_SH_R7_BANK_REGNUM:
2116       SET_Rn_BANK (rn - SIM_SH_R0_BANK_REGNUM, val);
2117       break;
2118     case SIM_SH_TBR_REGNUM:
2119       TBR = val;
2120       break;
2121     case SIM_SH_IBNR_REGNUM:
2122       IBNR = val;
2123       break;
2124     case SIM_SH_IBCR_REGNUM:
2125       IBCR = val;
2126       break;
2127     case SIM_SH_BANK_REGNUM:
2128       /* This is a pseudo-register maintained just for gdb.
2129          It tells us what register bank gdb would like to read/write.  */
2130       gdb_bank_number = val;
2131       break;
2132     case SIM_SH_BANK_MACL_REGNUM:
2133       saved_state.asregs.regstack[gdb_bank_number].regs[REGBANK_MACL] = val;
2134       break;
2135     case SIM_SH_BANK_GBR_REGNUM:
2136       saved_state.asregs.regstack[gdb_bank_number].regs[REGBANK_GBR] = val;
2137       break;
2138     case SIM_SH_BANK_PR_REGNUM:
2139       saved_state.asregs.regstack[gdb_bank_number].regs[REGBANK_PR] = val;
2140       break;
2141     case SIM_SH_BANK_IVN_REGNUM:
2142       saved_state.asregs.regstack[gdb_bank_number].regs[REGBANK_IVN] = val;
2143       break;
2144     case SIM_SH_BANK_MACH_REGNUM:
2145       saved_state.asregs.regstack[gdb_bank_number].regs[REGBANK_MACH] = val;
2146       break;
2147     default:
2148       return 0;
2149     }
2150   return length;
2151 }
2152
2153 int
2154 sim_fetch_register (SIM_DESC sd, int rn, unsigned char *memory, int length)
2155 {
2156   int val;
2157
2158   init_pointers ();
2159   switch (rn)
2160     {
2161     case SIM_SH_R0_REGNUM: case SIM_SH_R1_REGNUM: case SIM_SH_R2_REGNUM:
2162     case SIM_SH_R3_REGNUM: case SIM_SH_R4_REGNUM: case SIM_SH_R5_REGNUM:
2163     case SIM_SH_R6_REGNUM: case SIM_SH_R7_REGNUM: case SIM_SH_R8_REGNUM:
2164     case SIM_SH_R9_REGNUM: case SIM_SH_R10_REGNUM: case SIM_SH_R11_REGNUM:
2165     case SIM_SH_R12_REGNUM: case SIM_SH_R13_REGNUM: case SIM_SH_R14_REGNUM:
2166     case SIM_SH_R15_REGNUM:
2167       val = saved_state.asregs.regs[rn];
2168       break;
2169     case SIM_SH_PC_REGNUM:
2170       val = saved_state.asregs.pc;
2171       break;
2172     case SIM_SH_PR_REGNUM:
2173       val = PR;
2174       break;
2175     case SIM_SH_GBR_REGNUM:
2176       val = GBR;
2177       break;
2178     case SIM_SH_VBR_REGNUM:
2179       val = VBR;
2180       break;
2181     case SIM_SH_MACH_REGNUM:
2182       val = MACH;
2183       break;
2184     case SIM_SH_MACL_REGNUM:
2185       val = MACL;
2186       break;
2187     case SIM_SH_SR_REGNUM:
2188       val = GET_SR ();
2189       break;
2190     case SIM_SH_FPUL_REGNUM:
2191       val = FPUL;
2192       break;
2193     case SIM_SH_FPSCR_REGNUM:
2194       val = GET_FPSCR ();
2195       break;
2196     case SIM_SH_FR0_REGNUM: case SIM_SH_FR1_REGNUM: case SIM_SH_FR2_REGNUM:
2197     case SIM_SH_FR3_REGNUM: case SIM_SH_FR4_REGNUM: case SIM_SH_FR5_REGNUM:
2198     case SIM_SH_FR6_REGNUM: case SIM_SH_FR7_REGNUM: case SIM_SH_FR8_REGNUM:
2199     case SIM_SH_FR9_REGNUM: case SIM_SH_FR10_REGNUM: case SIM_SH_FR11_REGNUM:
2200     case SIM_SH_FR12_REGNUM: case SIM_SH_FR13_REGNUM: case SIM_SH_FR14_REGNUM:
2201     case SIM_SH_FR15_REGNUM:
2202       val = FI (rn - SIM_SH_FR0_REGNUM);
2203       break;
2204     case SIM_SH_DSR_REGNUM:
2205       val = DSR;
2206       break;
2207     case SIM_SH_A0G_REGNUM:
2208       val = SEXT (A0G);
2209       break;
2210     case SIM_SH_A0_REGNUM:
2211       val = A0;
2212       break;
2213     case SIM_SH_A1G_REGNUM:
2214       val = SEXT (A1G);
2215       break;
2216     case SIM_SH_A1_REGNUM:
2217       val = A1;
2218       break;
2219     case SIM_SH_M0_REGNUM:
2220       val = M0;
2221       break;
2222     case SIM_SH_M1_REGNUM:
2223       val = M1;
2224       break;
2225     case SIM_SH_X0_REGNUM:
2226       val = X0;
2227       break;
2228     case SIM_SH_X1_REGNUM:
2229       val = X1;
2230       break;
2231     case SIM_SH_Y0_REGNUM:
2232       val = Y0;
2233       break;
2234     case SIM_SH_Y1_REGNUM:
2235       val = Y1;
2236       break;
2237     case SIM_SH_MOD_REGNUM:
2238       val = MOD;
2239       break;
2240     case SIM_SH_RS_REGNUM:
2241       val = RS;
2242       break;
2243     case SIM_SH_RE_REGNUM:
2244       val = RE;
2245       break;
2246     case SIM_SH_SSR_REGNUM:
2247       val = SSR;
2248       break;
2249     case SIM_SH_SPC_REGNUM:
2250       val = SPC;
2251       break;
2252     /* The rn_bank idiosyncracies are not due to hardware differences, but to
2253        a weird aliasing naming scheme for sh3 / sh3e / sh4.  */
2254     case SIM_SH_R0_BANK0_REGNUM: case SIM_SH_R1_BANK0_REGNUM:
2255     case SIM_SH_R2_BANK0_REGNUM: case SIM_SH_R3_BANK0_REGNUM:
2256     case SIM_SH_R4_BANK0_REGNUM: case SIM_SH_R5_BANK0_REGNUM:
2257     case SIM_SH_R6_BANK0_REGNUM: case SIM_SH_R7_BANK0_REGNUM:
2258       if (saved_state.asregs.bfd_mach == bfd_mach_sh2a)
2259         {
2260           rn -= SIM_SH_R0_BANK0_REGNUM;
2261           val = saved_state.asregs.regstack[gdb_bank_number].regs[rn];
2262         }
2263       else
2264       val = (SR_MD && SR_RB
2265              ? Rn_BANK (rn - SIM_SH_R0_BANK0_REGNUM)
2266              : saved_state.asregs.regs[rn - SIM_SH_R0_BANK0_REGNUM]);
2267       break;
2268     case SIM_SH_R0_BANK1_REGNUM: case SIM_SH_R1_BANK1_REGNUM:
2269     case SIM_SH_R2_BANK1_REGNUM: case SIM_SH_R3_BANK1_REGNUM:
2270     case SIM_SH_R4_BANK1_REGNUM: case SIM_SH_R5_BANK1_REGNUM:
2271     case SIM_SH_R6_BANK1_REGNUM: case SIM_SH_R7_BANK1_REGNUM:
2272       if (saved_state.asregs.bfd_mach == bfd_mach_sh2a)
2273         {
2274           rn -= SIM_SH_R0_BANK1_REGNUM;
2275           val = saved_state.asregs.regstack[gdb_bank_number].regs[rn + 8];
2276         }
2277       else
2278       val = (! SR_MD || ! SR_RB
2279              ? Rn_BANK (rn - SIM_SH_R0_BANK1_REGNUM)
2280              : saved_state.asregs.regs[rn - SIM_SH_R0_BANK1_REGNUM]);
2281       break;
2282     case SIM_SH_R0_BANK_REGNUM: case SIM_SH_R1_BANK_REGNUM:
2283     case SIM_SH_R2_BANK_REGNUM: case SIM_SH_R3_BANK_REGNUM:
2284     case SIM_SH_R4_BANK_REGNUM: case SIM_SH_R5_BANK_REGNUM:
2285     case SIM_SH_R6_BANK_REGNUM: case SIM_SH_R7_BANK_REGNUM:
2286       val = Rn_BANK (rn - SIM_SH_R0_BANK_REGNUM);
2287       break;
2288     case SIM_SH_TBR_REGNUM:
2289       val = TBR;
2290       break;
2291     case SIM_SH_IBNR_REGNUM:
2292       val = IBNR;
2293       break;
2294     case SIM_SH_IBCR_REGNUM:
2295       val = IBCR;
2296       break;
2297     case SIM_SH_BANK_REGNUM:
2298       /* This is a pseudo-register maintained just for gdb.
2299          It tells us what register bank gdb would like to read/write.  */
2300       val = gdb_bank_number;
2301       break;
2302     case SIM_SH_BANK_MACL_REGNUM:
2303       val = saved_state.asregs.regstack[gdb_bank_number].regs[REGBANK_MACL];
2304       break;
2305     case SIM_SH_BANK_GBR_REGNUM:
2306       val = saved_state.asregs.regstack[gdb_bank_number].regs[REGBANK_GBR];
2307       break;
2308     case SIM_SH_BANK_PR_REGNUM:
2309       val = saved_state.asregs.regstack[gdb_bank_number].regs[REGBANK_PR];
2310       break;
2311     case SIM_SH_BANK_IVN_REGNUM:
2312       val = saved_state.asregs.regstack[gdb_bank_number].regs[REGBANK_IVN];
2313       break;
2314     case SIM_SH_BANK_MACH_REGNUM:
2315       val = saved_state.asregs.regstack[gdb_bank_number].regs[REGBANK_MACH];
2316       break;
2317     default:
2318       return 0;
2319     }
2320   * (int *) memory = swap (val);
2321   return length;
2322 }
2323
2324 void
2325 sim_stop_reason (SIM_DESC sd, enum sim_stop *reason, int *sigrc)
2326 {
2327   /* The SH simulator uses SIGQUIT to indicate that the program has
2328      exited, so we must check for it here and translate it to exit.  */
2329   if (saved_state.asregs.exception == SIGQUIT)
2330     {
2331       *reason = sim_exited;
2332       *sigrc = saved_state.asregs.regs[5];
2333     }
2334   else
2335     {
2336       *reason = sim_stopped;
2337       *sigrc = saved_state.asregs.exception;
2338     }
2339 }
2340
2341 void
2342 sim_info (SIM_DESC sd, int verbose)
2343 {
2344   double timetaken =
2345     (double) saved_state.asregs.ticks / (double) now_persec ();
2346   double virttime = saved_state.asregs.cycles / 36.0e6;
2347
2348   callback->printf_filtered (callback, "\n\n# instructions executed  %10d\n",
2349                              saved_state.asregs.insts);
2350   callback->printf_filtered (callback, "# cycles                 %10d\n",
2351                              saved_state.asregs.cycles);
2352   callback->printf_filtered (callback, "# pipeline stalls        %10d\n",
2353                              saved_state.asregs.stalls);
2354   callback->printf_filtered (callback, "# misaligned load/store  %10d\n",
2355                              saved_state.asregs.memstalls);
2356   callback->printf_filtered (callback, "# real time taken        %10.4f\n",
2357                              timetaken);
2358   callback->printf_filtered (callback, "# virtual time taken     %10.4f\n",
2359                              virttime);
2360   callback->printf_filtered (callback, "# profiling size         %10d\n",
2361                              sim_profile_size);
2362   callback->printf_filtered (callback, "# profiling frequency    %10d\n",
2363                              saved_state.asregs.profile);
2364   callback->printf_filtered (callback, "# profile maxpc          %10x\n",
2365                              (1 << sim_profile_size) << PROFILE_SHIFT);
2366
2367   if (timetaken != 0)
2368     {
2369       callback->printf_filtered (callback, "# cycles/second          %10d\n",
2370                                  (int) (saved_state.asregs.cycles / timetaken));
2371       callback->printf_filtered (callback, "# simulation ratio       %10.4f\n",
2372                                  virttime / timetaken);
2373     }
2374 }
2375
2376 static sim_cia
2377 sh_pc_get (sim_cpu *cpu)
2378 {
2379   return saved_state.asregs.pc;
2380 }
2381
2382 static void
2383 sh_pc_set (sim_cpu *cpu, sim_cia pc)
2384 {
2385   saved_state.asregs.pc = pc;
2386 }
2387
2388 static void
2389 free_state (SIM_DESC sd)
2390 {
2391   if (STATE_MODULES (sd) != NULL)
2392     sim_module_uninstall (sd);
2393   sim_cpu_free_all (sd);
2394   sim_state_free (sd);
2395 }
2396
2397 SIM_DESC
2398 sim_open (SIM_OPEN_KIND kind, host_callback *cb, struct bfd *abfd, char **argv)
2399 {
2400   char **p;
2401   int i;
2402   union
2403     {
2404       int i;
2405       short s[2];
2406       char c[4];
2407     }
2408   mem_word;
2409
2410   SIM_DESC sd = sim_state_alloc (kind, cb);
2411   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
2412
2413   callback = cb;
2414
2415   /* The cpu data is kept in a separately allocated chunk of memory.  */
2416   if (sim_cpu_alloc_all (sd, 1, /*cgen_cpu_max_extra_bytes ()*/0) != SIM_RC_OK)
2417     {
2418       free_state (sd);
2419       return 0;
2420     }
2421
2422   if (sim_pre_argv_init (sd, argv[0]) != SIM_RC_OK)
2423     {
2424       free_state (sd);
2425       return 0;
2426     }
2427
2428   /* getopt will print the error message so we just have to exit if this fails.
2429      FIXME: Hmmm...  in the case of gdb we need getopt to call
2430      print_filtered.  */
2431   if (sim_parse_args (sd, argv) != SIM_RC_OK)
2432     {
2433       free_state (sd);
2434       return 0;
2435     }
2436
2437   /* Check for/establish the a reference program image.  */
2438   if (sim_analyze_program (sd,
2439                            (STATE_PROG_ARGV (sd) != NULL
2440                             ? *STATE_PROG_ARGV (sd)
2441                             : NULL), abfd) != SIM_RC_OK)
2442     {
2443       free_state (sd);
2444       return 0;
2445     }
2446
2447   /* Configure/verify the target byte order and other runtime
2448      configuration options.  */
2449   if (sim_config (sd) != SIM_RC_OK)
2450     {
2451       sim_module_uninstall (sd);
2452       return 0;
2453     }
2454
2455   if (sim_post_argv_init (sd) != SIM_RC_OK)
2456     {
2457       /* Uninstall the modules to avoid memory leaks,
2458          file descriptor leaks, etc.  */
2459       sim_module_uninstall (sd);
2460       return 0;
2461     }
2462
2463   /* CPU specific initialization.  */
2464   for (i = 0; i < MAX_NR_PROCESSORS; ++i)
2465     {
2466       SIM_CPU *cpu = STATE_CPU (sd, i);
2467
2468       CPU_PC_FETCH (cpu) = sh_pc_get;
2469       CPU_PC_STORE (cpu) = sh_pc_set;
2470     }
2471
2472   for (p = argv + 1; *p != NULL; ++p)
2473     {
2474       if (isdigit (**p))
2475         parse_and_set_memory_size (*p);
2476     }
2477
2478   if (abfd)
2479     init_dsp (abfd);
2480
2481   for (i = 4; (i -= 2) >= 0; )
2482     mem_word.s[i >> 1] = i;
2483   global_endianw = mem_word.i >> (target_little_endian ? 0 : 16) & 0xffff;
2484
2485   for (i = 4; --i >= 0; )
2486     mem_word.c[i] = i;
2487   endianb = mem_word.i >> (target_little_endian ? 0 : 24) & 0xff;
2488
2489   return sd;
2490 }
2491
2492 static void
2493 parse_and_set_memory_size (const char *str)
2494 {
2495   int n;
2496
2497   n = strtol (str, NULL, 10);
2498   if (n > 0 && n <= 24)
2499     sim_memory_size = n;
2500   else
2501     callback->printf_filtered (callback, "Bad memory size %d; must be 1 to 24, inclusive\n", n);
2502 }
2503
2504 SIM_RC
2505 sim_create_inferior (SIM_DESC sd, struct bfd *prog_bfd, char **argv, char **env)
2506 {
2507   /* Clear the registers. */
2508   memset (&saved_state, 0,
2509           (char*) &saved_state.asregs.end_of_registers - (char*) &saved_state);
2510
2511   /* Set the PC.  */
2512   if (prog_bfd != NULL)
2513     saved_state.asregs.pc = bfd_get_start_address (prog_bfd);
2514
2515   /* Set the bfd machine type.  */
2516   if (prog_bfd != NULL)
2517     saved_state.asregs.bfd_mach = bfd_get_mach (prog_bfd);
2518
2519   if (prog_bfd != NULL)
2520     init_dsp (prog_bfd);
2521
2522   /* Record the program's arguments. */
2523   prog_argv = argv;
2524
2525   return SIM_RC_OK;
2526 }
2527
2528 void
2529 sim_do_command (SIM_DESC sd, const char *cmd)
2530 {
2531   const char *sms_cmd = "set-memory-size";
2532   int cmdsize;
2533
2534   if (cmd == NULL || *cmd == '\0')
2535     {
2536       cmd = "help";
2537     }
2538
2539   cmdsize = strlen (sms_cmd);
2540   if (strncmp (cmd, sms_cmd, cmdsize) == 0
2541       && strchr (" \t", cmd[cmdsize]) != NULL)
2542     {
2543       parse_and_set_memory_size (cmd + cmdsize + 1);
2544     }
2545   else if (strcmp (cmd, "help") == 0)
2546     {
2547       (callback->printf_filtered) (callback,
2548                                    "List of SH simulator commands:\n\n");
2549       (callback->printf_filtered) (callback, "set-memory-size <n> -- Set the number of address bits to use\n");
2550       (callback->printf_filtered) (callback, "\n");
2551     }
2552   else
2553     {
2554       (callback->printf_filtered) (callback, "Error: \"%s\" is not a valid SH simulator command.\n", cmd);
2555     }
2556 }