home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / gdb-4.9 / sim / sh / interp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-12  |  8.2 KB  |  456 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. #include "sysdep.h"
  21. #include <sys/times.h>
  22. #include <sys/param.h>
  23.  
  24. #define O_RECOMPILE 85
  25. #define DEFINE_TABLE
  26.  
  27. #define DISASSEMBLER_TABLE
  28.  
  29. #define SBIT(x) ((x)&sbit)
  30. #define R0     saved_state.asregs.regs[0]
  31. #define Rn     saved_state.asregs.regs[n]
  32. #define Rm     saved_state.asregs.regs[m]
  33. #define UR0     (unsigned long)(saved_state.asregs.regs[0])
  34. #define UR     (unsigned long)R
  35. #define UR     (unsigned long)R
  36. #define SR0     saved_state.asregs.regs[0]
  37. #define GBR     saved_state.asregs.gbr
  38. #define VBR     saved_state.asregs.vbr
  39. #define MACH     saved_state.asregs.mach
  40. #define MACL     saved_state.asregs.macl
  41. #define M     saved_state.asregs.sr.bits.m
  42. #define Q     saved_state.asregs.sr.bits.q
  43.  
  44. #define GET_SR() (saved_state.asregs.sr.bits.t = T, saved_state.asregs.sr.word)
  45. #define SET_SR(x) {saved_state.asregs.sr.word = (x); T =saved_state.asregs.sr.bits.t;}
  46.  
  47. #define PC pc
  48. #define C cycles
  49.  
  50. #define LMEM(x)     *((long *)(memory+((x)&maskl)))
  51. #define BMEM(x)     *((char *)(memory+((x)&maskb)))
  52. #define UWMEM(x)     *((unsigned short *)(memory+((x)&maskw)))
  53. #define SWMEM(x)     *((short *)(memory+((x)&maskw)))
  54. #define WLAT(x,value)      (LMEM(x) = value)
  55. #define RLAT(x)      (LMEM(x))
  56.  
  57. #define WWAT(x,value)      (UWMEM(x) = value)
  58. #define RSWAT(x)      (SWMEM(x))
  59. #define RUWAT(x)      (UWMEM(x))
  60.  
  61. #define WBAT(x,value)      (BMEM(x) = value)
  62. #define RBAT(x)      (BMEM(x))
  63.  
  64. #define SEXT(x)         (((x&0xff) ^ (~0x7f))+0x80)
  65. #define SEXTW(y)        ((int)((short)y))
  66. #define SL(TEMPPC)      iword= RUWAT(TEMPPC); goto top;
  67.  
  68.  
  69. int sim_memory_size = 16;
  70.  
  71. typedef union
  72. {
  73.  
  74.   struct
  75.     {
  76.  
  77.       int regs[16];
  78.       int pc;
  79.       int pr;
  80.  
  81.       int gbr;
  82.       int vbr;
  83.       int mach;
  84.       int macl;
  85.  
  86.  
  87.       union
  88.     {
  89.       struct
  90.         {
  91.           unsigned int d0:22;
  92.           unsigned int m:1;
  93.           unsigned int q:1;
  94.           unsigned int i:4;
  95.           unsigned int d1:2;
  96.           unsigned int s:1;
  97.           unsigned int t:1;
  98.         }
  99.       bits;
  100.       int word;
  101.     }
  102.       sr;
  103.       int ticks;
  104.       int cycles;
  105.       int insts;
  106.       unsigned char *memory;
  107.       int exception;
  108.       int msize;
  109.  
  110.     }
  111.   asregs;
  112.   int asints[25];
  113.  
  114. }
  115.  
  116. saved_state_type;
  117. saved_state_type saved_state;
  118.  
  119. static int
  120. get_now ()
  121. {
  122.   struct tms b;
  123.   times (&b);
  124.   return b.tms_utime + b.tms_stime;
  125. }
  126.  
  127. static int
  128. now_persec ()
  129. {
  130.   return HZ;
  131. }
  132.  
  133. /* Turn a pointer in a register into a pointer into real memory. */
  134.  
  135. static char *
  136. ptr (x)
  137.      int x;
  138. {
  139.   return (char *)(x + saved_state.asregs.memory);
  140. }
  141.  
  142. /* Simulate a monitor trap.  */
  143.  
  144. static void
  145. trap (i, regs)
  146.      int i;
  147.      int *regs;
  148. {
  149.   switch (i)
  150.     {
  151.     case 1:
  152.       printf ("%c", regs[0]);
  153.       break;
  154.     case 2:
  155.       saved_state.asregs.exception = SIGQUIT;
  156.       break;
  157.     case 3:
  158.       {
  159.     extern int errno;
  160.     int perrno = errno;
  161.     errno = 0;
  162.  
  163.     switch (regs[4])
  164.       {
  165.       case 3:
  166.         regs[4] = read (regs[5], ptr (regs[6]), regs[7]);
  167.         break;
  168.       case 4:
  169.         regs[4] = write (regs[5], ptr (regs[6]), regs[7]);
  170.         break;
  171.       case 19:
  172.         regs[4] = lseek (regs[5], regs[6], regs[7]);
  173.         break;
  174.       case 6:
  175.         regs[4] = close (regs[5]);
  176.         break;
  177.       case 5:
  178.         regs[4] = open (ptr (regs[5]), regs[6]);
  179.         break;
  180.       default:
  181.         abort ();
  182.       }
  183.     regs[0] = errno;
  184.     errno = perrno;
  185.       }
  186.  
  187.       break;
  188.  
  189.     case 255:
  190.       saved_state.asregs.exception = SIGILL;
  191.       break;
  192.     }
  193.  
  194. }
  195. void
  196. control_c (sig, code, scp, addr)
  197.      int sig;
  198.      int code;
  199.      char *scp;
  200.      char *addr;
  201. {
  202.   saved_state.asregs.exception = SIGINT;
  203. }
  204.  
  205.  
  206. int 
  207. div1 (R, m, n, T)
  208.      int *R;
  209.      int m;
  210.      int n;
  211.      int T;
  212. {
  213.   unsigned long tmp0;
  214.   unsigned char old_q, tmp1;
  215.  
  216.   old_q = Q;
  217.   Q = R[n] < 0;
  218.  
  219.   R[n] <<= 1;
  220.   R[n] |= T;
  221.  
  222.   switch (old_q)
  223.     {
  224.     case 0:
  225.       switch (M)
  226.     {
  227.     case 0:
  228.       tmp0 = R[n];
  229.       R[n] -= R[m];
  230.       tmp1 = (R[n] > tmp0) != Q;
  231.       break;
  232.     case 1:
  233.       tmp0 = R[n];
  234.       R[n] += R[m];
  235.       tmp1 = (R[n] < tmp0) == Q;
  236.       break;
  237.     }
  238.       break;
  239.     case 1:
  240.       switch (M)
  241.     {
  242.     case 0:
  243.       tmp0 = R[n];
  244.       R[n] += R[m];
  245.       tmp1 = (R[n] < tmp0) != Q;
  246.       break;
  247.     case 1:
  248.       tmp0 = R[n];
  249.       R[n] -= R[m];
  250.       tmp1 = (R[n] > tmp0) == Q;
  251.       break;
  252.     }
  253.       break;
  254.  
  255.     }
  256.  
  257.   T = (Q == M);
  258.   return T;
  259.  
  260. }
  261.  
  262. #define MMASKB ((saved_state.asregs.msize -1) & ~0)
  263. void
  264. sim_resume (step)
  265.      int step;
  266. {
  267.   int pc;
  268.   register int cycles = 0;
  269.   register int insts = 0;
  270.   int tick_start = get_now ();
  271.   void (*prev) ();
  272.   extern unsigned char sh_jump_table0[];
  273.  
  274.   register unsigned char *jump_table = sh_jump_table0;
  275.  
  276.   register int *R = &(saved_state.asregs.regs[0]);
  277.   register int T;
  278.   register int PR;
  279.  
  280.   register int maskb = ((saved_state.asregs.msize - 1) & ~0);
  281.   register int maskw = ((saved_state.asregs.msize - 1) & ~1);
  282.   register int maskl = ((saved_state.asregs.msize - 1) & ~3);
  283.   register unsigned char *memory = saved_state.asregs.memory;
  284.   register int sbit = (1 << 31);
  285.  
  286.   prev = signal (SIGINT, control_c);
  287.  
  288.   if (step)
  289.     {
  290.       saved_state.asregs.exception = SIGTRAP;
  291.     }
  292.   else
  293.     {
  294.       saved_state.asregs.exception = 0;
  295.     }
  296.  
  297.   pc = saved_state.asregs.pc;
  298.   PR = saved_state.asregs.pr;
  299.   T = saved_state.asregs.sr.bits.t;
  300.  
  301.   do
  302.     {
  303.       unsigned int iword = RUWAT (pc);
  304.       unsigned long ult;
  305.  
  306.       insts++;
  307.     top:
  308.  
  309. #include "code.c"
  310.  
  311.       pc += 2;
  312.       cycles++;
  313.     }
  314.   while (!saved_state.asregs.exception);
  315.  
  316.   if (saved_state.asregs.exception == SIGILL)
  317.     {
  318.       pc -= 2;
  319.     }
  320.  
  321.   saved_state.asregs.ticks += get_now () - tick_start;
  322.   saved_state.asregs.cycles += cycles;
  323.   saved_state.asregs.insts += insts;
  324.   saved_state.asregs.pc = pc;
  325.   saved_state.asregs.sr.bits.t = T;
  326.   saved_state.asregs.pr = PR;
  327.  
  328.   signal (SIGINT, prev);
  329. }
  330.  
  331. /* Set the memory size to the power of two provided. */
  332.  
  333. void
  334. sim_size (power)
  335.      int power;
  336.  
  337. {
  338.   saved_state.asregs.msize = 1 << power;
  339.   if (saved_state.asregs.memory)
  340.     {
  341.       free (saved_state.asregs.memory);
  342.     }
  343.  
  344.   saved_state.asregs.memory =
  345.     (unsigned char *) calloc (64, saved_state.asregs.msize / 64);
  346.  
  347.   if (!saved_state.asregs.memory)
  348.     {
  349.       fprintf (stderr,
  350.            "Not enough VM for simuation of %d bytes of RAM\n",
  351.            saved_state.asregs.msize);
  352.  
  353.       saved_state.asregs.msize = 1;
  354.       saved_state.asregs.memory = (unsigned char *)calloc(1,1);
  355.     }
  356. }
  357.  
  358. static 
  359. void
  360. init_pointers ()
  361. {
  362.   if (saved_state.asregs.msize != 1 << sim_memory_size)
  363.     {
  364.       sim_size (sim_memory_size);
  365.     }
  366. }
  367.  
  368. void
  369. sim_write (addr, buffer, size)
  370.      long int addr;
  371.      unsigned char *buffer;
  372.      int size;
  373. {
  374.   int i;
  375.   init_pointers ();
  376.  
  377.   for (i = 0; i < size; i++)
  378.     {
  379.       saved_state.asregs.memory[MMASKB & (addr + i)] = buffer[i];
  380.     }
  381. }
  382.  
  383. void
  384. sim_read (addr, buffer, size)
  385.      long int addr;
  386.      char *buffer;
  387.      int size;
  388. {
  389.   int i;
  390.  
  391.   init_pointers ();
  392.  
  393.   for (i = 0; i < size; i++)
  394.     {
  395.       buffer[i] = saved_state.asregs.memory[MMASKB & (addr + i)];
  396.     }
  397. }
  398.  
  399.  
  400. void
  401. sim_store_register (rn, value)
  402.      int rn;
  403.      int value;
  404. {
  405.   saved_state.asregs.regs[rn] = value;
  406. }
  407.  
  408. void
  409. sim_fetch_register (rn, buf)
  410.      int rn;
  411.      char *buf;
  412. {
  413.   int value = ((int *) (&saved_state))[rn];
  414.  
  415.   buf[0] = value >> 24;
  416.   buf[1] = value >> 16;
  417.   buf[2] = value >> 8;
  418.   buf[3] = value >> 0;
  419. }
  420.  
  421.  
  422. int
  423. sim_trace ()
  424. {
  425.   return 0;
  426. }
  427.  
  428. int
  429. sim_stop_signal ()
  430. {
  431.   return saved_state.asregs.exception;
  432. }
  433.  
  434. void
  435. sim_set_pc (x)
  436.      int x;
  437. {
  438.   saved_state.asregs.pc = x;
  439. }
  440.  
  441.  
  442. void
  443. sim_info ()
  444. {
  445.   double timetaken = (double) saved_state.asregs.ticks / (double) now_persec ();
  446.   double virttime = saved_state.asregs.cycles / 10.0e6;
  447.  
  448.   printf ("\n\n# instructions executed  %10d\n", saved_state.asregs.insts);
  449.   printf ("# cycles                 %10d\n", saved_state.asregs.cycles);
  450.   printf ("# real time taken        %10.4f\n", timetaken);
  451.   printf ("# cycles/second          %10d\n", (int) (saved_state.asregs.cycles / timetaken));
  452.   printf ("# virtual time taked     %10.4f\n", virttime);
  453.   printf ("# simulation ratio       %10.4f\n", virttime / timetaken);
  454. }
  455.  
  456.