sim/sh/interp.c

   1 /* Simulator for the Hitachi 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 <signal.h>
  22 #include "sysdep.h"
  23 //#include <sys/times.h>
  24 //#include <sys/param.h>
  25 #include "bfd.h"
  26 #include "remote-sim.h"
  27 #include <sys/syscall.h>
  28
  29 #ifndef SIGBUS
  30 #define SIGBUS SIGSEGV
  31 #endif
  32 #ifndef SIGQUIT
  33 #define SIGQUIT SIGTERM
  34 #endif
  35
  36 #define O_RECOMPILE 85
  37 #define DEFINE_TABLE
  38 #define DISASSEMBLER_TABLE
  39
  40
  41
  42 #define SBIT(x) ((x)&sbit)
  43 #define R0      saved_state.asregs.regs[0]
  44 #define Rn      saved_state.asregs.regs[n]
  45 #define Rm      saved_state.asregs.regs[m]
  46 #define UR0     (unsigned int)(saved_state.asregs.regs[0])
  47 #define UR      (unsigned int)R
  48 #define UR      (unsigned int)R
  49 #define SR0     saved_state.asregs.regs[0]
  50 #define GBR     saved_state.asregs.gbr
  51 #define VBR     saved_state.asregs.vbr
  52 #define MACH    saved_state.asregs.mach
  53 #define MACL    saved_state.asregs.macl
  54 #define M       saved_state.asregs.sr.bits.m
  55 #define Q       saved_state.asregs.sr.bits.q
  56 #define S       saved_state.asregs.sr.bits.s
  57
  58 #define GET_SR() (saved_state.asregs.sr.bits.t = T, saved_state.asregs.sr.word)
  59 #define SET_SR(x) {saved_state.asregs.sr.word = (x); T =saved_state.asregs.sr.bits.t;}
  60
  61 #define PC pc
  62 #define C cycles
  63
  64 int
  65 fail ()
  66 {
  67   abort ();
  68
  69 }
  70
  71 #define BUSERROR(addr, mask) \
  72   if (addr & ~mask)  { saved_state.asregs.exception = SIGBUS;}
  73
  74 /* Define this to enable register lifetime checking.
  75    The compiler generates "add #0,rn" insns to mark registers as invalid,
  76    the simulator uses this info to call fail if it finds a ref to an invalid
  77    register before a def
  78
  79    #define PARANOID
  80 */
  81
  82 #ifdef PARANOID
  83 int valid[16];
  84 #define CREF(x)  if(!valid[x]) fail();
  85 #define CDEF(x)  valid[x] = 1;
  86 #define UNDEF(x) valid[x] = 0;
  87 #else
  88 #define CREF(x)
  89 #define CDEF(x)
  90 #define UNDEF(x)
  91 #endif
  92
  93 static int IOMEM PARAMS ((int addr, int write, int value));
  94
  95 /* These variables are at file scope so that functions other than
  96    sim_resume can use the fetch/store macros */
  97
  98 static int  little_endian;
  99
 100 #if 1
 101 static int maskl = ~0;
 102 static int maskw = ~0;
 103 #endif
 104 typedef union
 105 {
 106
 107   struct
 108   {
 109
 110     int regs[16];
 111     int pc;
 112     int pr;
 113
 114     int gbr;
 115     int vbr;
 116     int mach;
 117     int macl;
 118
 119
 120     union
 121       {
 122         struct
 123           {
 124             unsigned int d0:22;
 125             unsigned int m:1;
 126             unsigned int q:1;
 127             unsigned int i:4;
 128             unsigned int d1:2;
 129             unsigned int s:1;
 130             unsigned int t:1;
 131           }
 132         bits;
 133         int word;
 134       }
 135     sr;
 136     int ticks;
 137     int stalls;
 138     int cycles;
 139     int insts;
 140
 141
 142     int prevlock;
 143     int thislock;
 144     int exception;
 145     int msize;
 146 #define PROFILE_FREQ 1
 147 #define PROFILE_SHIFT 2
 148     int profile;
 149     unsigned short *profile_hist;
 150     unsigned char *memory;
 151
 152   }
 153   asregs;
 154   int asints[28];
 155
 156 } saved_state_type;
 157 saved_state_type saved_state;
 158
 159 static void INLINE
 160 wlat_little (memory, x, value, maskl)
 161      unsigned char *memory;
 162 {
 163   int v = value;
 164   unsigned char *p = memory + ((x) & maskl);
 165   BUSERROR(x, maskl);
 166   p[3] = v >> 24;
 167   p[2] = v >> 16;
 168   p[1] = v >> 8;
 169   p[0] = v;
 170 }
 171
 172 static void INLINE
 173 wwat_little (memory, x, value, maskw)
 174      unsigned char *memory;
 175 {
 176   int v = value;
 177   unsigned char *p = memory + ((x) & maskw);
 178   BUSERROR(x, maskw);
 179
 180   p[1] = v >> 8;
 181   p[0] = v;
 182 }
 183
 184
 185 static void INLINE
 186 wbat_any (memory, x, value, maskb)
 187      unsigned char *memory;
 188 {
 189   unsigned char *p = memory + (x & maskb);
 190   if (x > 0x5000000)
 191     IOMEM (x, 1, value);
 192   BUSERROR(x, maskb);
 193
 194   p[0] = value;
 195 }
 196
 197
 198
 199 static void INLINE
 200 wlat_big (memory, x, value, maskl)
 201      unsigned char *memory;
 202 {
 203   int v = value;
 204   unsigned char *p = memory + ((x) & maskl);
 205   BUSERROR(x, maskl);
 206
 207   p[0] = v >> 24;
 208   p[1] = v >> 16;
 209   p[2] = v >> 8;
 210   p[3] = v;
 211 }
 212
 213 static void INLINE
 214 wwat_big (memory, x, value, maskw)
 215      unsigned char *memory;
 216 {
 217   int v = value;
 218   unsigned char *p = memory + ((x) & maskw);
 219   BUSERROR(x, maskw);
 220
 221   p[0] = v >> 8;
 222   p[1] = v;
 223 }
 224
 225
 226 static void INLINE
 227 wbat_big (memory, x, value, maskb)
 228      unsigned char *memory;
 229 {
 230   unsigned char *p = memory + (x & maskb);
 231   BUSERROR(x, maskb);
 232
 233   if (x > 0x5000000)
 234     IOMEM (x, 1, value);
 235   p[0] = value;
 236 }
 237
 238
 239
 240 /* Read functions */
 241 static int INLINE
 242 rlat_little (memory, x, maskl)
 243      unsigned char *memory;
 244 {
 245   unsigned char *p = memory + ((x) & maskl);
 246   BUSERROR(x, maskl);
 247
 248   return (p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0];
 249
 250 }
 251
 252 static int INLINE
 253 rwat_little (memory, x, maskw)
 254      unsigned char *memory;
 255 {
 256   unsigned char *p = memory + ((x) & maskw);
 257   BUSERROR(x, maskw);
 258
 259   return (p[1] << 8) | p[0];
 260 }
 261
 262 static int INLINE
 263 rbat_any (memory, x, maskb)
 264      unsigned char *memory;
 265 {
 266   unsigned char *p = memory + ((x) & maskb);
 267   BUSERROR(x, maskb);
 268
 269   return p[0];
 270 }
 271
 272 static int INLINE
 273 rlat_big (memory, x, maskl)
 274      unsigned char *memory;
 275 {
 276   unsigned char *p = memory + ((x) & maskl);
 277   BUSERROR(x, maskl);
 278
 279   return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
 280
 281 }
 282
 283 static int INLINE
 284 rwat_big (memory, x, maskw)
 285      unsigned char *memory;
 286 {
 287   unsigned char *p = memory + ((x) & maskw);
 288   BUSERROR(x, maskw);
 289
 290   return (p[0] << 8) | p[1];
 291 }
 292
 293
 294 #define RWAT(x)         (little_endian ? rwat_little(memory, x, maskw): rwat_big(memory, x, maskw))
 295 #define RLAT(x)         (little_endian ? rlat_little(memory, x, maskl): rlat_big(memory, x, maskl))
 296 #define RBAT(x)         (rbat_any (memory, x, maskb))
 297 #define WWAT(x,v)       (little_endian ? wwat_little(memory, x, v, maskw): wwat_big(memory, x, v, maskw))
 298 #define WLAT(x,v)       (little_endian ? wlat_little(memory, x, v, maskl): wlat_big(memory, x, v, maskl))
 299 #define WBAT(x,v)       (wbat_any (memory, x, v, maskb))
 300
 301 #define RUWAT(x)  (RWAT(x) & 0xffff)
 302 #define RSWAT(x)  ((short)(RWAT(x)))
 303 #define RSBAT(x)  (SEXT(RBAT(x)))
 304
 305 #define SEXT(x)         (((x&0xff) ^ (~0x7f))+0x80)
 306 #define SEXTW(y)        ((int)((short)y))
 307
 308 #define SL(TEMPPC)      iword= RUWAT(TEMPPC); goto top;
 309
 310
 311 int empty[16];
 312
 313 #define L(x)   thislock = x;
 314 #define TL(x)  if ((x) == prevlock) stalls++;
 315 #define TB(x,y)  if ((x) == prevlock || (y)==prevlock) stalls++;
 316
 317 #if defined(__GO32__) || defined(WIN32)
 318 int sim_memory_size = 19;
 319 #else
 320 int sim_memory_size = 24;
 321 #endif
 322
 323 static int sim_profile_size = 17;
 324 static int nsamples;
 325
 326 #undef TB
 327 #define TB(x,y)
 328
 329 #define SMR1 (0x05FFFEC8)       /* Channel 1  serial mode register */
 330 #define BRR1 (0x05FFFEC9)       /* Channel 1  bit rate register */
 331 #define SCR1 (0x05FFFECA)       /* Channel 1  serial control register */
 332 #define TDR1 (0x05FFFECB)       /* Channel 1  transmit data register */
 333 #define SSR1 (0x05FFFECC)       /* Channel 1  serial status register */
 334 #define RDR1 (0x05FFFECD)       /* Channel 1  receive data register */
 335
 336 #define SCI_RDRF         0x40   /* Recieve data register full */
 337 #define SCI_TDRE        0x80    /* Transmit data register empty */
 338
 339 static int
 340 IOMEM (addr, write, value)
 341      int addr;
 342      int write;
 343      int value;
 344 {
 345   static int io;
 346   static char ssr1;
 347   int x;
 348   static char lastchar;
 349
 350   if (write)
 351     {
 352       switch (addr)
 353         {
 354         case TDR1:
 355           if (value != '\r')
 356             {
 357               putchar (value);
 358               fflush (stdout);
 359             }
 360           break;
 361         }
 362     }
 363   else
 364     {
 365       switch (addr)
 366         {
 367         case RDR1:
 368           return getchar ();
 369         }
 370     }
 371 }
 372
 373
 374
 375 static int
 376 get_now ()
 377 {
 378   return time ((long *) 0);
 379 }
 380
 381 static int
 382 now_persec ()
 383 {
 384   return 1;
 385 }
 386
 387
 388
 389 static FILE *profile_file;
 390
 391 static void
 392 swap (memory, n)
 393      unsigned char *memory;
 394      int n;
 395 {
 396   WLAT (0, n);
 397 }
 398 static void
 399 swap16 (memory, n)
 400      unsigned char *memory;
 401      int n;
 402 {
 403   WWAT (0, n);
 404 }
 405
 406 static void
 407 swapout (n)
 408      int n;
 409 {
 410   if (profile_file)
 411     {
 412       char b[4];
 413       swap (b, n);
 414       fwrite (b, 4, 1, profile_file);
 415     }
 416 }
 417
 418 static void
 419 swapout16 (n)
 420      int n;
 421 {
 422   char b[4];
 423   swap16 (b, n);
 424   fwrite (b, 2, 1, profile_file);
 425 }
 426
 427
 428 /* Turn a pointer in a register into a pointer into real memory. */
 429
 430 static char *
 431 ptr (x)
 432      int x;
 433 {
 434   return (char *) (x + saved_state.asregs.memory);
 435 }
 436
 437
 438 /* Simulate a monitor trap, put the result into r0 and errno into r1 */
 439 static void
 440 trap (i, regs, memory, maskl, maskw, little_endian)
 441      int i;
 442      int *regs;
 443      unsigned char *memory;
 444 {
 445   switch (i)
 446     {
 447     case 1:
 448       printf ("%c", regs[0]);
 449       break;
 450     case 2:
 451       saved_state.asregs.exception = SIGQUIT;
 452       break;
 453 #if 0
 454     case 8:
 455       trap8 (ptr (regs[4]));
 456       break;
 457     case 9:
 458       trap9 (ptr (regs[4]));
 459       break;
 460     case 10:
 461       trap10 ();
 462       break;
 463     case 11:
 464       regs[0] = trap11 ();
 465       break;
 466     case 12:
 467       regs[0] = trap12 ();
 468       break;
 469 #endif
 470     case 3:
 471       {
 472         extern int errno;
 473         int perrno = errno;
 474         errno = 0;
 475
 476         switch (regs[4])
 477           {
 478
 479 #if !defined(__GO32__) && !defined(WIN32)
 480
 481           case SYS_fork:
 482             regs[0] = fork ();
 483             break;
 484           case SYS_execve:
 485             regs[0] = execve (ptr (regs[5]), ptr (regs[6]), ptr (regs[7]));
 486             break;
 487           case SYS_execv:
 488             regs[0] = execv (ptr (regs[5]), ptr (regs[6]));
 489             break;
 490           case SYS_pipe:
 491             {
 492               char *buf;
 493               int host_fd[2];
 494
 495               buf = ptr (regs[5]);
 496
 497               regs[0] = pipe (host_fd);
 498
 499               WLAT (buf, host_fd[0]);
 500               buf += 4;
 501               WLAT (buf, host_fd[1]);
 502             }
 503             break;
 504
 505           case SYS_wait:
 506             regs[0] = wait (ptr (regs[5]));
 507             break;
 508 #endif
 509
 510           case SYS_read:
 511             regs[0] = read (regs[5], ptr (regs[6]), regs[7]);
 512             break;
 513           case SYS_write:
 514             regs[0] = write (regs[5], ptr (regs[6]), regs[7]);
 515             break;
 516           case SYS_lseek:
 517             regs[0] = lseek (regs[5], regs[6], regs[7]);
 518             break;
 519           case SYS_close:
 520             regs[0] = close (regs[5]);
 521             break;
 522           case SYS_open:
 523             regs[0] = open (ptr (regs[5]), regs[6]);
 524             break;
 525           case SYS_exit:
 526             /* EXIT - caller can look in r5 to work out the
 527                reason */
 528             saved_state.asregs.exception = SIGQUIT;
 529             break;
 530
 531           case SYS_stat:        /* added at hmsi */
 532             /* stat system call */
 533             {
 534               struct stat host_stat;
 535               char *buf;
 536
 537               regs[0] = stat (ptr (regs[5]), &host_stat);
 538
 539               buf = ptr (regs[6]);
 540
 541               WWAT (buf, host_stat.st_dev);
 542               buf += 2;
 543               WWAT (buf, host_stat.st_ino);
 544               buf += 2;
 545               WLAT (buf, host_stat.st_mode);
 546               buf += 4;
 547               WWAT (buf, host_stat.st_nlink);
 548               buf += 2;
 549               WWAT (buf, host_stat.st_uid);
 550               buf += 2;
 551               WWAT (buf, host_stat.st_gid);
 552               buf += 2;
 553               WWAT (buf, host_stat.st_rdev);
 554               buf += 2;
 555               WLAT (buf, host_stat.st_size);
 556               buf += 4;
 557               WLAT (buf, host_stat.st_atime);
 558               buf += 4;
 559               WLAT (buf, 0);
 560               buf += 4;
 561               WLAT (buf, host_stat.st_mtime);
 562               buf += 4;
 563               WLAT (buf, 0);
 564               buf += 4;
 565               WLAT (buf, host_stat.st_ctime);
 566               buf += 4;
 567               WLAT (buf, 0);
 568               buf += 4;
 569               WLAT (buf, 0);
 570               buf += 4;
 571               WLAT (buf, 0);
 572               buf += 4;
 573             }
 574             break;
 575
 576           case SYS_chown:
 577             regs[0] = chown (ptr (regs[5]), regs[6], regs[7]);
 578             break;
 579           case SYS_chmod:
 580             regs[0] = chmod (ptr (regs[5]), regs[6]);
 581             break;
 582           case SYS_utime:
 583             regs[0] = utime (ptr (regs[5]), ptr (regs[6]));
 584             break;
 585           default:
 586             abort ();
 587           }
 588         regs[1] = errno;
 589         errno = perrno;
 590       }
 591
 592       break;
 593
 594     case 0xc3:
 595     case 255:
 596       saved_state.asregs.exception = SIGTRAP;
 597       break;
 598     }
 599
 600 }
 601 void
 602 control_c (sig, code, scp, addr)
 603      int sig;
 604      int code;
 605      char *scp;
 606      char *addr;
 607 {
 608   saved_state.asregs.exception = SIGINT;
 609 }
 610
 611
 612 static int
 613 div1 (R, iRn2, iRn1, T)
 614      int *R;
 615      int iRn1;
 616      int iRn2;
 617      int T;
 618 {
 619   unsigned long tmp0;
 620   unsigned char old_q, tmp1;
 621
 622   old_q = Q;
 623   Q = (unsigned char) ((0x80000000 & R[iRn1]) != 0);
 624   R[iRn1] <<= 1;
 625   R[iRn1] |= (unsigned long) T;
 626
 627   switch (old_q)
 628     {
 629     case 0:
 630       switch (M)
 631         {
 632         case 0:
 633           tmp0 = R[iRn1];
 634           R[iRn1] -= R[iRn2];
 635           tmp1 = (R[iRn1] > tmp0);
 636           switch (Q)
 637             {
 638             case 0:
 639               Q = tmp1;
 640               break;
 641             case 1:
 642               Q = (unsigned char) (tmp1 == 0);
 643               break;
 644             }
 645           break;
 646         case 1:
 647           tmp0 = R[iRn1];
 648           R[iRn1] += R[iRn2];
 649           tmp1 = (R[iRn1] < tmp0);
 650           switch (Q)
 651             {
 652             case 0:
 653               Q = (unsigned char) (tmp1 == 0);
 654               break;
 655             case 1:
 656               Q = tmp1;
 657               break;
 658             }
 659           break;
 660         }
 661       break;
 662     case 1:
 663       switch (M)
 664         {
 665         case 0:
 666           tmp0 = R[iRn1];
 667           R[iRn1] += R[iRn2];
 668           tmp1 = (R[iRn1] < tmp0);
 669           switch (Q)
 670             {
 671             case 0:
 672               Q = tmp1;
 673               break;
 674             case 1:
 675               Q = (unsigned char) (tmp1 == 0);
 676               break;
 677             }
 678           break;
 679         case 1:
 680           tmp0 = R[iRn1];
 681           R[iRn1] -= R[iRn2];
 682           tmp1 = (R[iRn1] > tmp0);
 683           switch (Q)
 684             {
 685             case 0:
 686               Q = (unsigned char) (tmp1 == 0);
 687               break;
 688             case 1:
 689               Q = tmp1;
 690               break;
 691             }
 692           break;
 693         }
 694       break;
 695     }
 696   T = (Q == M);
 697   return T;
 698 }
 699
 700
 701 static void
 702 dmul (sign, rm, rn)
 703      int sign;
 704      unsigned int rm;
 705      unsigned int rn;
 706 {
 707   unsigned long RnL, RnH;
 708   unsigned long RmL, RmH;
 709   unsigned long temp0, temp1, temp2, temp3;
 710   unsigned long Res2, Res1, Res0;
 711
 712   RnL = rn & 0xffff;
 713   RnH = (rn >> 16) & 0xffff;
 714   RmL = rm & 0xffff;
 715   RmH = (rm >> 16) & 0xffff;
 716   temp0 = RmL * RnL;
 717   temp1 = RmH * RnL;
 718   temp2 = RmL * RnH;
 719   temp3 = RmH * RnH;
 720   Res2 = 0;
 721   Res1 = temp1 + temp2;
 722   if (Res1 < temp1)
 723     Res2 += 0x00010000;
 724   temp1 = (Res1 << 16) & 0xffff0000;
 725   Res0 = temp0 + temp1;
 726   if (Res0 < temp0)
 727     Res2 += 1;
 728   Res2 += ((Res1 >> 16) & 0xffff) + temp3;
 729
 730   if (sign)
 731     {
 732       if (rn & 0x80000000)
 733         Res2 -= rm;
 734       if (rm & 0x80000000)
 735         Res2 -= rn;
 736     }
 737
 738   MACH = Res2;
 739   MACL = Res0;
 740 }
 741
 742 static void
 743 macw (regs, memory, n, m)
 744      int *regs;
 745      unsigned char *memory;
 746      int m, n;
 747 {
 748   long tempm, tempn;
 749   long prod, macl, sum;
 750
 751   tempm=RSWAT(regs[m]); regs[m]+=2;
 752   tempn=RSWAT(regs[n]); regs[n]+=2;
 753
 754   macl = MACL;
 755   prod = (long)(short) tempm * (long)(short) tempn;
 756   sum = prod + macl;
 757   if (S)
 758     {
 759       if ((~(prod ^ macl) & (sum ^ prod)) < 0)
 760         {
 761           /* MACH's lsb is a sticky overflow bit.  */
 762           MACH |= 1;
 763           /* Store the smallest negative number in MACL if prod is
 764              negative, and the largest positive number otherwise.  */
 765           sum = 0x7fffffff + (prod < 0);
 766         }
 767     }
 768   else
 769     {
 770       long mach;
 771       /* Add to MACH the sign extended product, and carry from low sum.  */
 772       mach = MACH + (-(prod < 0)) + ((unsigned long) sum < prod);
 773       /* Sign extend at 10:th bit in MACH.  */
 774       MACH = (mach & 0x1ff) | -(mach & 0x200);
 775     }
 776   MACL = sum;
 777 }
 778
 779 /* Set the memory size to the power of two provided. */
 780
 781 void
 782 sim_size (power)
 783      int power;
 784
 785 {
 786   saved_state.asregs.msize = 1 << power;
 787
 788   sim_memory_size = power;
 789
 790
 791   if (saved_state.asregs.memory)
 792     {
 793       free (saved_state.asregs.memory);
 794     }
 795
 796   saved_state.asregs.memory =
 797     (unsigned char *) calloc (64, saved_state.asregs.msize / 64);
 798
 799   if (!saved_state.asregs.memory)
 800     {
 801       fprintf (stderr,
 802                "Not enough VM for simulation of %d bytes of RAM\n",
 803                saved_state.asregs.msize);
 804
 805       saved_state.asregs.msize = 1;
 806       saved_state.asregs.memory = (unsigned char *) calloc (1, 1);
 807     }
 808 }
 809
 810
 811 int target_byte_order;
 812
 813 static void
 814 set_static_little_endian(x)
 815 int x;
 816 {
 817   little_endian = x;
 818 }
 819
 820 static
 821 void
 822 init_pointers ()
 823 {
 824   register int little_endian = target_byte_order == 1234;
 825   set_static_little_endian (little_endian);
 826   if (saved_state.asregs.msize != 1 << sim_memory_size)
 827     {
 828       sim_size (sim_memory_size);
 829     }
 830
 831   if (saved_state.asregs.profile && !profile_file)
 832     {
 833       profile_file = fopen ("gmon.out", "wb");
 834       /* Seek to where to put the call arc data */
 835       nsamples = (1 << sim_profile_size);
 836
 837       fseek (profile_file, nsamples * 2 + 12, 0);
 838
 839       if (!profile_file)
 840         {
 841           fprintf (stderr, "Can't open gmon.out\n");
 842         }
 843       else
 844         {
 845           saved_state.asregs.profile_hist =
 846             (unsigned short *) calloc (64, (nsamples * sizeof (short) / 64));
 847         }
 848     }
 849 }
 850
 851 static void
 852 dump_profile ()
 853 {
 854   unsigned int minpc;
 855   unsigned int maxpc;
 856   unsigned short *p;
 857
 858   int thisshift;
 859
 860   unsigned short *first;
 861
 862   int i;
 863   p = saved_state.asregs.profile_hist;
 864   minpc = 0;
 865   maxpc = (1 << sim_profile_size);
 866
 867   fseek (profile_file, 0L, 0);
 868   swapout (minpc << PROFILE_SHIFT);
 869   swapout (maxpc << PROFILE_SHIFT);
 870   swapout (nsamples * 2 + 12);
 871   for (i = 0; i < nsamples; i++)
 872     swapout16 (saved_state.asregs.profile_hist[i]);
 873
 874 }
 875
 876 static int
 877 gotcall (from, to)
 878      int from;
 879      int to;
 880 {
 881   swapout (from);
 882   swapout (to);
 883   swapout (1);
 884 }
 885
 886 #define MMASKB ((saved_state.asregs.msize -1) & ~0)
 887
 888
 889 void
 890 sim_resume (step, siggnal)
 891      int step, siggnal;
 892 {
 893   register unsigned int pc;
 894   register int cycles = 0;
 895   register int stalls = 0;
 896   register int insts = 0;
 897   register int prevlock;
 898   register int thislock;
 899   register unsigned int doprofile;
 900 #if defined(__GO32__) || defined(WIN32)
 901   register int pollcount = 0;
 902 #endif
 903   register int little_endian = target_byte_order == 1234;
 904
 905
 906   int tick_start = get_now ();
 907   void (*prev) ();
 908   extern unsigned char sh_jump_table0[];
 909
 910   register unsigned char *jump_table = sh_jump_table0;
 911
 912   register int *R = &(saved_state.asregs.regs[0]);
 913   register int T;
 914   register int PR;
 915
 916   register int maskb = ((saved_state.asregs.msize - 1) & ~0);
 917   register int maskw = ((saved_state.asregs.msize - 1) & ~1);
 918   register int maskl = ((saved_state.asregs.msize - 1) & ~3);
 919   register unsigned char *memory;
 920   register unsigned int sbit = (1 << 31);
 921
 922   prev = signal (SIGINT, control_c);
 923
 924   init_pointers ();
 925
 926   memory = saved_state.asregs.memory;
 927
 928   if (step)
 929     {
 930       saved_state.asregs.exception = SIGTRAP;
 931     }
 932   else
 933     {
 934       saved_state.asregs.exception = 0;
 935     }
 936
 937   pc = saved_state.asregs.pc;
 938   PR = saved_state.asregs.pr;
 939   T = saved_state.asregs.sr.bits.t;
 940   prevlock = saved_state.asregs.prevlock;
 941   thislock = saved_state.asregs.thislock;
 942   doprofile = saved_state.asregs.profile;
 943
 944   /* If profiling not enabled, disable it by asking for
 945      profiles infrequently. */
 946   if (doprofile == 0)
 947     doprofile = ~0;
 948
 949   do
 950     {
 951       register unsigned int iword = RUWAT (pc);
 952       register unsigned int ult;
 953 #ifndef ACE_FAST
 954       insts++;
 955 #endif
 956     top:
 957
 958 #include "code.c"
 959
 960
 961       pc += 2;
 962
 963 #ifdef __GO32__
 964       pollcount++;
 965       if (pollcount > 1000)
 966         {
 967           pollcount = 0;
 968           if (kbhit()) {
 969             int k = getkey();
 970             if (k == 1)
 971               saved_state.asregs.exception = SIGINT;
 972
 973           }
 974         }
 975 #endif
 976 #if defined (WIN32)
 977       pollcount++;
 978       if (pollcount > 1000)
 979         {
 980           pollcount = 0;
 981           if (win32pollquit())
 982             {
 983               control_c();
 984             }
 985         }
 986 #endif
 987
 988 #ifndef ACE_FAST
 989       prevlock = thislock;
 990       thislock = 30;
 991       cycles++;
 992
 993       if (cycles >= doprofile)
 994         {
 995
 996           saved_state.asregs.cycles += doprofile;
 997           cycles -= doprofile;
 998           if (saved_state.asregs.profile_hist)
 999             {
1000               int n = pc >> PROFILE_SHIFT;
1001               if (n < nsamples)
1002                 {
1003                   int i = saved_state.asregs.profile_hist[n];
1004                   if (i < 65000)
1005                     saved_state.asregs.profile_hist[n] = i + 1;
1006                 }
1007
1008             }
1009         }
1010 #endif
1011     }
1012   while (!saved_state.asregs.exception);
1013
1014   if (saved_state.asregs.exception == SIGILL
1015       || saved_state.asregs.exception == SIGBUS)
1016     {
1017       pc -= 2;
1018     }
1019
1020   saved_state.asregs.ticks += get_now () - tick_start;
1021   saved_state.asregs.cycles += cycles;
1022   saved_state.asregs.stalls += stalls;
1023   saved_state.asregs.insts += insts;
1024   saved_state.asregs.pc = pc;
1025   saved_state.asregs.sr.bits.t = T;
1026   saved_state.asregs.pr = PR;
1027
1028   saved_state.asregs.prevlock = prevlock;
1029   saved_state.asregs.thislock = thislock;
1030
1031
1032   if (profile_file)
1033     {
1034       dump_profile ();
1035     }
1036
1037   signal (SIGINT, prev);
1038 }
1039
1040
1041
1042
1043 int
1044 sim_write (addr, buffer, size)
1045      SIM_ADDR addr;
1046      unsigned char *buffer;
1047      int size;
1048 {
1049   int i;
1050   init_pointers ();
1051
1052   for (i = 0; i < size; i++)
1053     {
1054       saved_state.asregs.memory[MMASKB & (addr + i)] = buffer[i];
1055     }
1056   return size;
1057 }
1058
1059 int
1060 sim_read (addr, buffer, size)
1061      SIM_ADDR addr;
1062      unsigned char *buffer;
1063      int size;
1064 {
1065   int i;
1066
1067   init_pointers ();
1068
1069   for (i = 0; i < size; i++)
1070     {
1071       buffer[i] = saved_state.asregs.memory[MMASKB & (addr + i)];
1072     }
1073   return size;
1074 }
1075
1076
1077 void
1078 sim_store_register (rn, memory)
1079      int rn;
1080      unsigned char *memory;
1081 {
1082   init_pointers();
1083   saved_state.asregs.regs[rn]=RLAT(0);
1084 }
1085
1086 void
1087 sim_fetch_register (rn, memory)
1088      int rn;
1089      unsigned char *memory;
1090 {
1091   init_pointers();
1092   WLAT (0, saved_state.asregs.regs[rn]);
1093 }
1094
1095
1096 int
1097 sim_trace ()
1098 {
1099   return 0;
1100 }
1101
1102 void
1103 sim_stop_reason (reason, sigrc)
1104      enum sim_stop *reason;
1105      int *sigrc;
1106 {
1107   *reason = sim_stopped;
1108   *sigrc = saved_state.asregs.exception;
1109 }
1110
1111
1112 void
1113 sim_info (verbose)
1114      int verbose;
1115 {
1116   double timetaken = (double) saved_state.asregs.ticks / (double) now_persec ();
1117   double virttime = saved_state.asregs.cycles / 36.0e6;
1118
1119   printf_filtered ("\n\n# instructions executed  %10d\n", saved_state.asregs.insts);
1120   printf_filtered ("# cycles                 %10d\n", saved_state.asregs.cycles);
1121   printf_filtered ("# pipeline stalls        %10d\n", saved_state.asregs.stalls);
1122   printf_filtered ("# real time taken        %10.4f\n", timetaken);
1123   printf_filtered ("# virtual time taken     %10.4f\n", virttime);
1124   printf_filtered ("# profiling size         %10d\n", sim_profile_size);
1125   printf_filtered ("# profiling frequency    %10d\n", saved_state.asregs.profile);
1126   printf_filtered ("# profile maxpc          %10x\n", (1 << sim_profile_size) << PROFILE_SHIFT);
1127
1128   if (timetaken != 0)
1129     {
1130       printf_filtered ("# cycles/second          %10d\n", (int) (saved_state.asregs.cycles / timetaken));
1131       printf_filtered ("# simulation ratio       %10.4f\n", virttime / timetaken);
1132     }
1133 }
1134
1135
1136 void
1137 sim_set_profile (n)
1138      int n;
1139 {
1140   saved_state.asregs.profile = n;
1141 }
1142
1143 void
1144 sim_set_profile_size (n)
1145      int n;
1146 {
1147   sim_profile_size = n;
1148 }
1149
1150
1151 void
1152 sim_open (name)
1153      char *name;
1154 {
1155   /* nothing to do */
1156 }
1157
1158 void
1159 sim_close (quitting)
1160      int quitting;
1161 {
1162   /* nothing to do */
1163 }
1164
1165 int
1166 sim_load (prog, from_tty)
1167      char *prog;
1168      int from_tty;
1169 {
1170   /* Return nonzero so GDB will handle it.  */
1171   return 1;
1172 }
1173
1174 void
1175 sim_create_inferior (start_address, argv, env)
1176      SIM_ADDR start_address;
1177      char **argv;
1178      char **env;
1179 {
1180   saved_state.asregs.pc = start_address;
1181 }
1182
1183 void
1184 sim_kill ()
1185 {
1186   /* nothing to do */
1187 }
1188