home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / D / GDB / GDB-4.13 / GDB-4 / gdb-4.13 / sim / sh / interp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-26  |  17.7 KB  |  945 lines
  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 "../../newlib/libc/sys/sh/sys/syscall.h"
  28. #define O_RECOMPILE 85
  29. #define DEFINE_TABLE
  30.  
  31. #define DISASSEMBLER_TABLE
  32.  
  33. #define SBIT(x) ((x)&sbit)
  34. #define R0     saved_state.asregs.regs[0]
  35. #define Rn     saved_state.asregs.regs[n]
  36. #define Rm     saved_state.asregs.regs[m]
  37. #define UR0     (unsigned int)(saved_state.asregs.regs[0])
  38. #define UR     (unsigned int)R
  39. #define UR     (unsigned int)R
  40. #define SR0     saved_state.asregs.regs[0]
  41. #define GBR     saved_state.asregs.gbr
  42. #define VBR     saved_state.asregs.vbr
  43. #define MACH     saved_state.asregs.mach
  44. #define MACL     saved_state.asregs.macl
  45. #define M     saved_state.asregs.sr.bits.m
  46. #define Q     saved_state.asregs.sr.bits.q
  47.  
  48. #define GET_SR() (saved_state.asregs.sr.bits.t = T, saved_state.asregs.sr.word)
  49. #define SET_SR(x) {saved_state.asregs.sr.word = (x); T =saved_state.asregs.sr.bits.t;}
  50.  
  51. #define PC pc
  52. #define C cycles
  53.  
  54. char *fail()
  55. {
  56.  
  57.  
  58. }
  59.  
  60.  
  61.  
  62. /* Define this to enable register lifetime checking.
  63.    The compiler generates "add #0,rn" insns to mark registers as invalid, 
  64.    the simulator uses this info to call fail if it finds a ref to an invalid
  65.    register before a def
  66.    
  67.    #define PARANOID
  68. */
  69.  
  70. #ifdef PARANOID
  71. int valid[16];
  72. #define CREF(x)  if(!valid[x]) fail();
  73. #define CDEF(x)  valid[x] = 1;
  74. #define UNDEF(x) valid[x] = 0;
  75. #else
  76. #define CREF(x)
  77. #define CDEF(x)
  78. #define UNDEF(x)
  79. #endif
  80.  
  81.  
  82. #ifdef TARGET_BIG_ENDIAN
  83. #if 0
  84. #define LMEM(x)     *((long *)(memory+((x)&maskl)))
  85. #define BMEM(x)     *((char *)(memory+((x)&maskb)))
  86. #define UWMEM(x)     *((unsigned short *)(memory+((x)&maskw)))
  87. #define SWMEM(x)     *((short *)(memory+((x)&maskw)))
  88. #define WLAT(x,value)      (LMEM(x) = value)
  89. #define RLAT(x)      (LMEM(x))
  90. #define WWAT(x,value)      (UWMEM(x) = value)
  91. #define RSWAT(x)      (SWMEM(x))
  92. #define RUWAT(x)      (UWMEM(x))
  93. #define WBAT(x,value)      (BMEM(x) = value)
  94. #define RBAT(x)      (BMEM(x))
  95. #else
  96. #define LMEM(x)     ((x)&maskl ? fail() :  *((long *)(memory+((x)&maskl))))
  97. #define BMEM(x)     ((x) &maskb ? fail() : *((char *)(memory+((x)&maskb))))
  98. #define UWMEM(x)     ((x)&maskw ? fail() : *((unsigned short *)(memory+((x)&maskw))))
  99. #define SWMEM(x)     ((x)&maskw ? fail() : *((short *)(memory+((x)&maskw))))
  100. #define WLAT(x,value)      (LMEM(x) = value)
  101. #define RLAT(x)      (LMEM(x))
  102. #define WWAT(x,value)      (UWMEM(x) = value)
  103. #define RSWAT(x)      (SWMEM(x))
  104. #define RUWAT(x)      (UWMEM(x))
  105. #define WBAT(x,value)      (BMEM(x) = value)
  106. #define RBAT(x)      (BMEM(x))
  107. #endif
  108. #else
  109. /* For little endian or unknown host machines */
  110. #define WLAT(x,value)\
  111. { int v = value; unsigned char *p = memory + ((x) & maskl);\
  112.   p[0] =v>>24;p[1] = v>>16;p[2]=v>>8;p[3]=v; }
  113.  
  114. #define WWAT(x,value)\
  115. { int v = value; unsigned char *p = memory + (x & maskw);p[0] =v>>8;p[1] = v ;}
  116.  
  117. #define WBAT(x,value)\
  118. { unsigned char *p = memory + (x & maskb);p[0] =value;}
  119.  
  120. #define RLAT(x)\
  121.   ((memory[x&maskl]<<24)|(memory[(x&maskl)+1]<<16)|(memory[(x&maskl)+2]<<8)| (memory[(x&maskl)+3]))
  122.  
  123. #define RWAT(x)\
  124.   ((memory[x&maskw]<<8)|(memory[(x&maskw)+1]))
  125.  
  126. #define RBAT(x)\
  127.   ((memory[x&maskb]))
  128.  
  129. #define RUWAT(x)  (RWAT(x) & 0xffff)
  130. #define RSWAT(x)  ((short)(RWAT(x)))
  131. #define RSBAT(x)  (SEXT(RBAT(x)))
  132.  
  133. #endif
  134.  
  135.  
  136.  
  137. #define SEXT(x)         (((x&0xff) ^ (~0x7f))+0x80)
  138. #define SEXTW(y)        ((int)((short)y))
  139.  
  140. #define SL(TEMPPC)      iword= RUWAT(TEMPPC); goto top;
  141.  
  142.  
  143. int empty[16];
  144.  
  145. #define L(x)   thislock = x;
  146. #define TL(x)  if ((x) == prevlock) stalls++;
  147. #define TB(x,y)  if ((x) == prevlock || (y)==prevlock) stalls++;
  148.  
  149. #ifdef __GO32__
  150. int sim_memory_size = 19;
  151. #else
  152. int sim_memory_size = 24;
  153. #endif
  154.  
  155. static int sim_profile_size = 17;
  156. static int nsamples;
  157. static int sim_timeout;
  158.  
  159. typedef union
  160. {
  161.  
  162.   struct
  163.     {
  164.  
  165.       int regs[16];
  166.       int pc;
  167.       int pr;
  168.  
  169.       int gbr;
  170.       int vbr;
  171.       int mach;
  172.       int macl;
  173.  
  174.  
  175.       union
  176.     {
  177.       struct
  178.         {
  179.           unsigned int d0:22;
  180.           unsigned int m:1;
  181.           unsigned int q:1;
  182.           unsigned int i:4;
  183.           unsigned int d1:2;
  184.           unsigned int s:1;
  185.           unsigned int t:1;
  186.         }
  187.       bits;
  188.       int word;
  189.     }
  190.       sr;
  191.       int ticks;
  192.       int stalls;
  193.       int cycles;
  194.       int insts;
  195.  
  196.  
  197.       int prevlock;
  198.       int thislock;
  199.       int exception;
  200.       int msize;
  201. #define PROFILE_FREQ 1
  202. #define PROFILE_SHIFT 2
  203.       int profile;
  204.       unsigned short *profile_hist;
  205.       unsigned char *memory;
  206.  
  207.     }
  208.   asregs;
  209.   int asints[28];
  210.  
  211. }
  212.  
  213. saved_state_type;
  214. saved_state_type saved_state;
  215.  
  216. static int
  217. get_now ()
  218. {
  219.   return time((long*)0);
  220. }
  221.  
  222. static int
  223. now_persec ()
  224. {
  225.   return 1;
  226. }
  227.  
  228.  
  229.  
  230. static FILE *profile_file;
  231.  
  232. static void 
  233. swap (b, n)
  234.      unsigned char *b;
  235.      int n;
  236. {
  237.   b[0] = n >> 24;
  238.   b[1] = n >> 16;
  239.   b[2] = n >> 8;
  240.   b[3] = n >> 0;
  241. }
  242. static void 
  243. swap16 (b, n)
  244.      unsigned char *b;
  245.      int n;
  246. {
  247.   b[0] = n >> 8;
  248.   b[1] = n >> 0;
  249. }
  250.  
  251. static void
  252. swapout (n)
  253.      int n;
  254. {
  255.   if (profile_file)
  256.     {
  257.       char b[4];
  258.       swap (b, n);
  259.       fwrite (b, 4, 1, profile_file);
  260.     }
  261. }
  262.  
  263. static void
  264. swapout16 (n)
  265.      int n;
  266. {
  267.   char b[4];
  268.   swap16 (b, n);
  269.   fwrite (b, 2, 1, profile_file);
  270. }
  271.  
  272.  
  273. /* Turn a pointer in a register into a pointer into real memory. */
  274.  
  275. static char *
  276. ptr (x)
  277.      int x;
  278. {
  279.   return (char *) (x + saved_state.asregs.memory);
  280. }
  281.  
  282. static char *wwat(ptr, val)
  283. char *ptr;
  284. int val;
  285. {
  286.   ptr[0] = val >> 8;
  287.   ptr[1] = val;
  288.   return ptr+2;
  289. }
  290.  
  291. static char *wlat(ptr,val)
  292. char *ptr;
  293. int val;
  294. {
  295.   ptr[0] = val>> 24;
  296.   ptr[1] = val >> 16;
  297.   ptr[2] = val >>8;
  298.   ptr[3] = val;
  299.   return ptr+4;
  300. }
  301.  
  302. /* Simulate a monitor trap, put the result into r0 and errno into r1 */
  303.  
  304. static void
  305. trap (i, regs)
  306.      int i;
  307.      int *regs;
  308. {
  309.   switch (i)
  310.     {
  311.     case 1:
  312.       printf ("%c", regs[0]);
  313.       break;
  314.     case 2:
  315.       saved_state.asregs.exception = SIGQUIT;
  316.       break;
  317.     case 3:
  318.       {
  319.     extern int errno;
  320.     int perrno = errno;
  321.     errno = 0;
  322.  
  323.     switch (regs[4])
  324.       {
  325.  
  326. #ifndef __GO32__
  327.  
  328.       case SYS_fork: 
  329.         regs[0] = fork();
  330.         break;
  331.       case SYS_execve:
  332.         regs[0] = execve(ptr(regs[5]), ptr(regs[6]), ptr(regs[7]));
  333.         break;
  334.       case SYS_execv:
  335.         regs[0] = execv(ptr(regs[5]), ptr(regs[6]));
  336.         break;
  337.       case SYS_pipe:
  338.         {
  339.           char* buf;
  340.           int host_fd[2];
  341.  
  342.           buf = ptr(regs[5]);
  343.  
  344.           regs[0] = pipe(host_fd); 
  345.  
  346.           buf = wlat(buf, host_fd[0]);
  347.           buf = wlat(buf, host_fd[1]);
  348.         }
  349.         break;
  350.  
  351.       case SYS_wait: 
  352.             regs[0] = wait(ptr(regs[5]));    
  353.         break;
  354. #endif
  355.  
  356.       case SYS_read:
  357.         regs[0] = read (regs[5], ptr (regs[6]), regs[7]);
  358.         break;
  359.       case SYS_write:
  360.         regs[0] = write (regs[5], ptr (regs[6]), regs[7]);
  361.         break;
  362.       case SYS_lseek:
  363.         regs[0] = lseek (regs[5], regs[6], regs[7]);
  364.         break;
  365.       case SYS_close:
  366.         regs[0] = close (regs[5]);
  367.         break;
  368.       case SYS_open:
  369.         regs[0] = open (ptr (regs[5]), regs[6]);
  370.         break;
  371.       case SYS_exit:
  372.         /* EXIT */
  373.         saved_state.asregs.exception = SIGQUIT;
  374.         errno = regs[5];
  375.         break;
  376.         
  377.       case SYS_stat:     /* added at hmsi */
  378.         /* stat system call */
  379.         {      
  380.           struct stat host_stat;
  381.           char *buf;
  382.  
  383.           regs[0] = stat( ptr(regs[5]), &host_stat);
  384.  
  385.           buf = ptr(regs[6]); 
  386.  
  387.           buf = wwat(buf, host_stat.st_dev);
  388.           buf = wwat(buf, host_stat.st_ino);
  389.  
  390.           buf = wlat(buf, host_stat.st_mode);
  391.  
  392.           buf = wwat(buf, host_stat.st_nlink);
  393.           buf = wwat(buf, host_stat.st_uid);
  394.           buf = wwat(buf, host_stat.st_gid);
  395.           buf = wwat(buf, host_stat.st_rdev);
  396.  
  397.           buf = wlat(buf, host_stat.st_size);
  398.           buf = wlat(buf, host_stat.st_atime);
  399.           buf = wlat(buf, 0);
  400.           buf = wlat(buf, host_stat.st_mtime);
  401.           buf = wlat(buf, 0);
  402.           buf = wlat(buf, host_stat.st_ctime);
  403.  
  404.           buf = wlat(buf, 0);
  405.           buf = wlat(buf, 0);
  406.           buf = wlat(buf, 0);
  407.         }   
  408.             break;    
  409.  
  410.           case SYS_chown:
  411.         regs[0] =  chown( ptr(regs[5]), regs[6], regs[7] );
  412.         break;
  413.       case SYS_chmod:
  414.         regs[0] = chmod( ptr(regs[5]), regs[6]);
  415.             break;
  416.           case SYS_utime:
  417.         regs[0] = utime (ptr(regs[5]), ptr(regs[6]));
  418.         break;
  419.       default:
  420.         abort ();
  421.       }
  422.     regs[1] = errno;
  423.     errno = perrno;
  424.       }
  425.  
  426.       break;
  427.  
  428.     case 255:
  429.       saved_state.asregs.exception = SIGTRAP;
  430.       saved_state.asregs.exception = 5;
  431.       break;
  432.     }
  433.  
  434. }
  435. void
  436. control_c (sig, code, scp, addr)
  437.      int sig;
  438.      int code;
  439.      char *scp;
  440.      char *addr;
  441. {
  442.   saved_state.asregs.exception = SIGINT;
  443. }
  444.  
  445.  
  446. static int
  447. div1 (R, iRn2, iRn1, T)
  448.      int *R;
  449.      int iRn1;
  450.      int iRn2;
  451.      int T;
  452. {
  453.   unsigned long tmp0;
  454.   unsigned char old_q, tmp1;
  455.  
  456.   old_q = Q;
  457.   Q = (unsigned char) ((0x80000000 & R[iRn1]) != 0);
  458.   R[iRn1] <<= 1;
  459.   R[iRn1] |= (unsigned long) T;
  460.  
  461.   switch (old_q)
  462.     {
  463.     case 0:
  464.       switch (M)
  465.     {
  466.     case 0:
  467.       tmp0 = R[iRn1];
  468.       R[iRn1] -= R[iRn2];
  469.       tmp1 = (R[iRn1] > tmp0);
  470.       switch (Q)
  471.         {
  472.         case 0:
  473.           Q = tmp1;
  474.           break;
  475.         case 1:
  476.           Q = (unsigned char) (tmp1 == 0);
  477.           break;
  478.         }
  479.       break;
  480.     case 1:
  481.       tmp0 = R[iRn1];
  482.       R[iRn1] += R[iRn2];
  483.       tmp1 = (R[iRn1] < tmp0);
  484.       switch (Q)
  485.         {
  486.         case 0:
  487.           Q = (unsigned char) (tmp1 == 0);
  488.           break;
  489.         case 1:
  490.           Q = tmp1;
  491.           break;
  492.         }
  493.       break;
  494.     }
  495.       break;
  496.     case 1:
  497.       switch (M)
  498.     {
  499.     case 0:
  500.       tmp0 = R[iRn1];
  501.       R[iRn1] += R[iRn2];
  502.       tmp1 = (R[iRn1] < tmp0);
  503.       switch (Q)
  504.         {
  505.         case 0:
  506.           Q = tmp1;
  507.           break;
  508.         case 1:
  509.           Q = (unsigned char) (tmp1 == 0);
  510.           break;
  511.         }
  512.       break;
  513.     case 1:
  514.       tmp0 = R[iRn1];
  515.       R[iRn1] -= R[iRn2];
  516.       tmp1 = (R[iRn1] > tmp0);
  517.       switch (Q)
  518.         {
  519.         case 0:
  520.           Q = (unsigned char) (tmp1 == 0);
  521.           break;
  522.         case 1:
  523.           Q = tmp1;
  524.           break;
  525.         }
  526.       break;
  527.     }
  528.       break;
  529.     }
  530.   T = (Q == M);
  531.   return T;
  532. }
  533.  
  534.  
  535. static void 
  536. dmul (sign, rm, rn)
  537.      int sign;
  538.      unsigned int rm;
  539.      unsigned int rn;
  540. {
  541.   unsigned long RnL, RnH;
  542.   unsigned long RmL, RmH;
  543.   unsigned long temp0, temp1, temp2, temp3;
  544.   unsigned long Res2, Res1, Res0;
  545.  
  546.  
  547.   if (!sign)
  548.     {
  549.  
  550.       RnL = rn & 0xffff;
  551.       RnH = (rn >> 16) & 0xffff;
  552.       RmL = rm & 0xffff;
  553.       RmH = (rm >> 16) & 0xffff;
  554.       temp0 = RmL * RnL;
  555.       temp1 = RmH * RnL;
  556.       temp2 = RmL * RnH;
  557.       temp3 = RmH * RnH;
  558.       Res2 = 0;
  559.       Res1 = temp1 + temp2;
  560.       if (Res1 < temp1)
  561.     Res2 += 0x00010000;
  562.       temp1 = (Res1 << 16) & 0xffff0000;
  563.       Res0 = temp0 + temp1;
  564.       if (Res0 < temp0)
  565.     Res2 += 1;
  566.       Res2 += ((Res1 >> 16) & 0xffff) + temp3;
  567.       MACH = Res2;
  568.       MACL = Res0;
  569.  
  570.     }
  571.  
  572.   else
  573.     {
  574.       abort ();
  575.     }
  576.  
  577. }
  578.  
  579.  
  580. /* Set the memory size to the power of two provided. */
  581.  
  582. void
  583. sim_size (power)
  584.      int power;
  585.  
  586. {
  587.   saved_state.asregs.msize = 1 << power;
  588.  
  589.   sim_memory_size = power;
  590.  
  591.  
  592.   if (saved_state.asregs.memory)
  593.     {
  594.       free (saved_state.asregs.memory);
  595.     }
  596.  
  597.   saved_state.asregs.memory =
  598.     (unsigned char *) calloc (64, saved_state.asregs.msize / 64);
  599.  
  600.   if (!saved_state.asregs.memory)
  601.     {
  602.       fprintf (stderr,
  603.            "Not enough VM for simuation of %d bytes of RAM\n",
  604.            saved_state.asregs.msize);
  605.  
  606.       saved_state.asregs.msize = 1;
  607.       saved_state.asregs.memory = (unsigned char *) calloc (1, 1);
  608.     }
  609. }
  610.  
  611.  
  612.  
  613. static
  614. void
  615. init_pointers ()
  616. {
  617.   if (saved_state.asregs.msize != 1 << sim_memory_size)
  618.     {
  619.       sim_size (sim_memory_size);
  620.     }
  621.  
  622.   if (saved_state.asregs.profile && !profile_file)
  623.     {
  624.       profile_file = fopen ("gmon.out", "wb");
  625.       /* Seek to where to put the call arc data */
  626.       nsamples = (1 << sim_profile_size);
  627.  
  628.       fseek (profile_file, nsamples * 2 + 12, 0);
  629.  
  630.       if (!profile_file)
  631.     {
  632.       fprintf (stderr, "Can't open gmon.out\n");
  633.     }
  634.       else
  635.     {
  636.       saved_state.asregs.profile_hist =
  637.         (unsigned short *) calloc (64, (nsamples * sizeof (short) / 64));
  638.     }
  639.     }
  640. }
  641.  
  642. static void
  643. dump_profile ()
  644. {
  645.   unsigned int minpc;
  646.   unsigned int maxpc;
  647.   unsigned short *p;
  648.  
  649.   int thisshift;
  650.  
  651.   unsigned short *first;
  652.  
  653.   int i;
  654.   p = saved_state.asregs.profile_hist;
  655.   minpc = 0;
  656.   maxpc = (1 << sim_profile_size);
  657.  
  658.   fseek (profile_file, 0L, 0);
  659.   swapout (minpc << PROFILE_SHIFT);
  660.   swapout (maxpc << PROFILE_SHIFT);
  661.   swapout (nsamples * 2 + 12);
  662.   for (i = 0; i < nsamples; i++)
  663.     swapout16 (saved_state.asregs.profile_hist[i]);
  664.  
  665. }
  666.  
  667. static int 
  668. gotcall (from, to)
  669.      int from;
  670.      int to;
  671. {
  672.   swapout (from);
  673.   swapout (to);
  674.   swapout (1);
  675. }
  676.  
  677. #define MMASKB ((saved_state.asregs.msize -1) & ~0)
  678.  
  679. void
  680. sim_resume (step, siggnal)
  681.      int step, siggnal;
  682. {
  683.   register unsigned int pc;
  684.   register int cycles = 0;
  685.   register int stalls = 0;
  686.   register int insts = 0;
  687.   register int prevlock;
  688.   register int thislock;
  689.   register unsigned int doprofile;
  690.  
  691.   int tick_start = get_now ();
  692.   void (*prev) ();
  693.   extern unsigned char sh_jump_table0[];
  694.  
  695.   register unsigned char *jump_table = sh_jump_table0;
  696.  
  697.   register int *R = &(saved_state.asregs.regs[0]);
  698.   register int T;
  699.   register int PR;
  700.  
  701.   register int maskb = ((saved_state.asregs.msize - 1) & ~0);
  702.   register int maskw = ((saved_state.asregs.msize - 1) & ~1);
  703.   register int maskl = ((saved_state.asregs.msize - 1) & ~3);
  704.   register unsigned char *memory ;
  705.   register unsigned int sbit = (1 << 31);
  706.  
  707.   prev = signal (SIGINT, control_c);
  708.  
  709.   init_pointers ();
  710.  
  711.   memory = saved_state.asregs.memory;
  712.  
  713.   if (step)
  714.     {
  715.       saved_state.asregs.exception = SIGTRAP;
  716.     }
  717.   else
  718.     {
  719.       saved_state.asregs.exception = 0;
  720.     }
  721.  
  722.   pc = saved_state.asregs.pc;
  723.   PR = saved_state.asregs.pr;
  724.   T = saved_state.asregs.sr.bits.t;
  725.   prevlock = saved_state.asregs.prevlock;
  726.   thislock = saved_state.asregs.thislock;
  727.   doprofile = saved_state.asregs.profile;
  728.  
  729.   /* If profiling not enabled, disable it by asking for
  730.      profiles infrequently. */
  731.   if (doprofile == 0)
  732.     doprofile = ~0;
  733.  
  734.   do
  735.     {
  736.       register unsigned int iword = RUWAT (pc);
  737.       register unsigned int ult;
  738.  
  739.       insts++;
  740.     top:
  741.  
  742. #include "code.c"
  743.  
  744.  
  745.       pc += 2;
  746.       prevlock = thislock;
  747.       thislock = 30;
  748.       cycles++;
  749.  
  750.       if (cycles >= doprofile)
  751.     {
  752.       if (cycles > sim_timeout)
  753.         saved_state.asregs.exception = SIGQUIT;
  754.       
  755.       saved_state.asregs.cycles += doprofile;
  756.       cycles -= doprofile;
  757.       if (saved_state.asregs.profile_hist)
  758.         {
  759.           int n = pc >> PROFILE_SHIFT;
  760.           if (n < nsamples)
  761.         {
  762.           int i = saved_state.asregs.profile_hist[n];
  763.           if (i < 65000)
  764.             saved_state.asregs.profile_hist[n] = i + 1;
  765.         }
  766.  
  767.         }
  768.     }
  769.     }
  770.   while (!saved_state.asregs.exception);
  771.  
  772.   if (saved_state.asregs.exception == SIGILL)
  773.     {
  774.       pc -= 2;
  775.     }
  776.  
  777.   saved_state.asregs.ticks += get_now () - tick_start;
  778.   saved_state.asregs.cycles += cycles;
  779.   saved_state.asregs.stalls += stalls;
  780.   saved_state.asregs.insts += insts;
  781.   saved_state.asregs.pc = pc;
  782.   saved_state.asregs.sr.bits.t = T;
  783.   saved_state.asregs.pr = PR;
  784.  
  785.   saved_state.asregs.prevlock = prevlock;
  786.   saved_state.asregs.thislock = thislock;
  787.  
  788.  
  789.   if (profile_file)
  790.     {
  791.       dump_profile ();
  792.     }
  793.  
  794.   signal (SIGINT, prev);
  795. }
  796.  
  797.  
  798.  
  799.  
  800. int
  801. sim_write (addr, buffer, size)
  802.      SIM_ADDR addr;
  803.      unsigned char *buffer;
  804.      int size;
  805. {
  806.   int i;
  807.   init_pointers ();
  808.  
  809.   for (i = 0; i < size; i++)
  810.     {
  811.       saved_state.asregs.memory[MMASKB & (addr + i)] = buffer[i];
  812.     }
  813.   return size;
  814. }
  815.  
  816. int
  817. sim_read (addr, buffer, size)
  818.      SIM_ADDR addr;
  819.      unsigned char *buffer;
  820.      int size;
  821. {
  822.   int i;
  823.  
  824.   init_pointers ();
  825.  
  826.   for (i = 0; i < size; i++)
  827.     {
  828.       buffer[i] = saved_state.asregs.memory[MMASKB & (addr + i)];
  829.     }
  830.   return size;
  831. }
  832.  
  833.  
  834. void
  835. sim_store_register (rn, value)
  836.      int rn;
  837.      unsigned char *value;
  838. {
  839.   saved_state.asregs.regs[rn] = (value[0] << 24) | (value[1] << 16) | (value[2] << 8) | (value[3]);
  840. }
  841.  
  842. void
  843. sim_fetch_register (rn, buf)
  844.      int rn;
  845.      unsigned char *buf;
  846. {
  847.   int value = ((int *) (&saved_state))[rn];
  848.  
  849.   swap (buf, value);
  850. }
  851.  
  852.  
  853. int
  854. sim_trace ()
  855. {
  856.   return 0;
  857. }
  858.  
  859. void
  860. sim_stop_reason (reason, sigrc)
  861.      enum sim_stop *reason;
  862.      int *sigrc;
  863. {
  864.   *reason = sim_stopped;
  865.   *sigrc = saved_state.asregs.exception;
  866. }
  867.  
  868.  
  869. void
  870. sim_info (verbose)
  871.      int verbose;
  872. {
  873.   double timetaken = (double) saved_state.asregs.ticks / (double) now_persec ();
  874.   double virttime = saved_state.asregs.cycles / 36.0e6;
  875.  
  876.   printf_filtered ("\n\n# instructions executed  %10d\n", saved_state.asregs.insts);
  877.   printf_filtered ("# cycles                 %10d\n", saved_state.asregs.cycles);
  878.   printf_filtered ("# pipeline stalls        %10d\n", saved_state.asregs.stalls);
  879.   printf_filtered ("# real time taken        %10.4f\n", timetaken);
  880.   printf_filtered ("# virtual time taken     %10.4f\n", virttime);
  881.   printf_filtered ("# profiling size         %10d\n", sim_profile_size);
  882.   printf_filtered ("# profiling frequency    %10d\n", saved_state.asregs.profile);
  883.   printf_filtered ("# profile maxpc          %10x\n", (1 << sim_profile_size) << PROFILE_SHIFT);
  884.  
  885.   if (timetaken != 0)
  886.     {
  887.       printf_filtered ("# cycles/second          %10d\n", (int) (saved_state.asregs.cycles / timetaken));
  888.       printf_filtered ("# simulation ratio       %10.4f\n", virttime / timetaken);
  889.     }
  890. }
  891.  
  892.  
  893. void
  894. sim_set_profile (n)
  895.      int n;
  896. {
  897.   saved_state.asregs.profile = n;
  898. }
  899.  
  900. void
  901. sim_set_profile_size (n)
  902.      int n;
  903. {
  904.   sim_profile_size = n;
  905. }
  906.  
  907.  
  908. void
  909. sim_open (name)
  910.      char *name;
  911. {
  912.   /* nothing to do */
  913. }
  914.  
  915. void
  916. sim_close (quitting)
  917.      int quitting;
  918. {
  919.   /* nothing to do */
  920. }
  921.  
  922. int
  923. sim_load (prog, from_tty)
  924.      char *prog;
  925.      int from_tty;
  926. {
  927.   /* Return nonzero so GDB will handle it.  */
  928.   return 1;
  929. }
  930.  
  931. void
  932. sim_create_inferior (start_address, argv, env)
  933.      SIM_ADDR start_address;
  934.      char **argv;
  935.      char **env;
  936. {
  937.   saved_state.asregs.pc = start_address;
  938. }
  939.  
  940. void
  941. sim_kill ()
  942. {
  943.   /* nothing to do */
  944. }
  945.