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