home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 9 / FreshFishVol9-CD2.bin / bbs / gnu / gdb-4.14-src.lha / gdb-4.14 / sim / w65 / interp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-16  |  5.7 KB  |  366 lines
  1. /* Simulator for the WDC 65816 architecture.
  2.  
  3.    Written by Steve Chamberlain of Cygnus Support.
  4.    sac@cygnus.com
  5.  
  6.    This file is part of W65 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/w65/sys/syscall.h"
  28.  
  29. #include "interp.h"
  30.  
  31. saved_state_type saved_state;
  32.  
  33. int
  34. get_now ()
  35. {
  36.   return time ((long *) 0);
  37. }
  38. void
  39. control_c (sig, code, scp, addr)
  40.      int sig;
  41.      int code;
  42.      char *scp;
  43.      char *addr;
  44. {
  45.   saved_state.exception = SIGINT;
  46. }
  47.  
  48. wai ()
  49. {
  50.   saved_state.exception = SIGTRAP;
  51. }
  52.  
  53.  
  54.  
  55. wdm (acc, x)
  56.      int acc;
  57.      int x;
  58.  
  59. {
  60. int cycles;
  61.   /* The x points to where the registers live, acc has code */
  62.  
  63. #define R(arg)  (x +  arg * 2)
  64. unsigned  R0 = R(0);
  65. unsigned  R4 = R(4);
  66. unsigned  R5 = R(5);
  67. unsigned  R6 = R(6);
  68. unsigned  R7 = R(7);
  69. unsigned  R8 = R(8);
  70. unsigned char *memory = saved_state.memory;
  71.   int a1 = fetch16 (R (4));
  72.   switch (a1)
  73.     {
  74.     case SYS_write:
  75.       {
  76.     int file = fetch16 (R5);
  77.     unsigned char *buf = fetch24 (R6) + memory;
  78.     int len = fetch16 (R8);
  79.     int res = write (file, buf, len);
  80.     store16 (R0, res);
  81.     break;
  82.       }
  83.     case 0:
  84.       printf ("%c", acc);
  85.       fflush (stdout);
  86.       break;
  87.     case 1:
  88.       saved_state.exception = SIGTRAP;
  89.       break;
  90.     default:
  91.       saved_state.exception = SIGILL;
  92.       break;
  93.     }
  94. }
  95.  
  96.  
  97. void
  98. sim_resume (step, insignal)
  99.      int step;
  100.      int insignal;
  101. {
  102.   void (*prev) ();
  103.   register unsigned char *memory;
  104.   if (step)
  105.     {
  106.       saved_state.exception = SIGTRAP;
  107.     }
  108.   else
  109.     {
  110.       saved_state.exception = 0;
  111.     }
  112.  
  113.  
  114.   prev = signal (SIGINT, control_c);
  115.   do
  116.     {
  117.       int x = (saved_state.p >> 4) & 1;
  118.       int m = (saved_state.p >> 5) & 1;
  119.       if (x == 0 && m == 0)
  120.     {
  121.       ifunc_X0_M0 ();
  122.     }
  123.       else if (x == 0 && m == 1)
  124.     {
  125.       ifunc_X0_M1 ();
  126.     }
  127.       else if (x == 1 && m == 0)
  128.     {
  129.       ifunc_X1_M0 ();
  130.     }
  131.       else if (x == 1 && m == 1)
  132.     {
  133.       ifunc_X1_M1 ();
  134.     }
  135.     }
  136.   while (saved_state.exception == 0);
  137.  
  138.   signal (SIGINT, prev);
  139. }
  140.  
  141.  
  142.  
  143.  
  144. init_pointers ()
  145. {
  146.   if (!saved_state.memory)
  147.     {
  148.       saved_state.memory = calloc (64 * 1024, NUMSEGS);
  149.     }
  150. }
  151.  
  152. int
  153. sim_write (addr, buffer, size)
  154.      SIM_ADDR addr;
  155.      unsigned char *buffer;
  156.      int size;
  157. {
  158.   int i;
  159.   init_pointers ();
  160.  
  161.   for (i = 0; i < size; i++)
  162.     {
  163.       saved_state.memory[(addr + i) & MMASK] = buffer[i];
  164.     }
  165.   return size;
  166. }
  167.  
  168. int
  169. sim_read (addr, buffer, size)
  170.      SIM_ADDR addr;
  171.      unsigned char *buffer;
  172.      int size;
  173. {
  174.   int i;
  175.  
  176.   init_pointers ();
  177.  
  178.   for (i = 0; i < size; i++)
  179.     {
  180.       buffer[i] = saved_state.memory[(addr + i) & MMASK];
  181.     }
  182.   return size;
  183. }
  184.  
  185.  
  186.  
  187. struct
  188. {
  189.   unsigned int *ptr;
  190.   int size;
  191. }
  192. rinfo[] =
  193.  
  194. {
  195.   &saved_state.r[0], 2,
  196.   &saved_state.r[1], 2,
  197.   &saved_state.r[2], 2,
  198.   &saved_state.r[3], 2,
  199.   &saved_state.r[4], 2,
  200.   &saved_state.r[5], 2,
  201.   &saved_state.r[6], 2,
  202.   &saved_state.r[7], 2,
  203.   &saved_state.r[8], 2,
  204.   &saved_state.r[9], 2,
  205.   &saved_state.r[10], 2,
  206.   &saved_state.r[11], 2,
  207.   &saved_state.r[12], 2,
  208.   &saved_state.r[13], 2,
  209.   &saved_state.r[14], 2,
  210.   &saved_state.r[15], 4,
  211.   &saved_state.pc, 4,
  212.   &saved_state.a, 4,
  213.   &saved_state.x, 4,
  214.   &saved_state.y, 4,
  215.   &saved_state.dbr, 4,
  216.   &saved_state.d, 4,
  217.   &saved_state.s, 4,
  218.   &saved_state.p, 4,
  219.   &saved_state.ticks, 4,
  220.   &saved_state.cycles, 4,
  221.   &saved_state.insts, 4,
  222.   0
  223. };
  224.  
  225. void
  226. sim_store_register (rn, value)
  227.      int rn;
  228.      unsigned char *value;
  229. {
  230.   unsigned int val;
  231.   int i;
  232.   val = 0;
  233.   for (i = 0; i < rinfo[rn].size; i++)
  234.     {
  235.       val |= (*value++) << (i * 8);
  236.     }
  237.  
  238.   *(rinfo[rn].ptr) = val;
  239. }
  240.  
  241. void
  242. sim_fetch_register (rn, buf)
  243.      int rn;
  244.      unsigned char *buf;
  245. {
  246.   unsigned int val = *(rinfo[rn].ptr);
  247.   int i;
  248.  
  249.   for (i = 0; i < rinfo[rn].size; i++)
  250.     {
  251.       *buf++ = val;
  252.       val = val >> 8;
  253.     }
  254. }
  255.  
  256.  
  257. sim_reg_size (n)
  258. {
  259.   return rinfo[n].size;
  260. }
  261. int
  262. sim_trace ()
  263. {
  264.   return 0;
  265. }
  266.  
  267. void
  268. sim_stop_reason (reason, sigrc)
  269.      enum sim_stop *reason;
  270.      int *sigrc;
  271. {
  272.   *reason = sim_stopped;
  273.   *sigrc = saved_state.exception;
  274. }
  275.  
  276. int
  277. sim_set_pc (x)
  278.      SIM_ADDR x;
  279. {
  280.   saved_state.pc = x;
  281.   return 0;
  282. }
  283.  
  284.  
  285. void
  286. sim_info (verbose)
  287.      int verbose;
  288. {
  289.   double timetaken = (double) saved_state.ticks;
  290.   double virttime = saved_state.cycles / 2.0e6;
  291.  
  292.   printf ("\n\n# instructions executed  %10d\n", saved_state.insts);
  293.   printf ("# cycles                 %10d\n", saved_state.cycles);
  294.   printf ("# real time taken        %10.4f\n", timetaken);
  295.   printf ("# virtual time taken     %10.4f\n", virttime);
  296.  
  297.   if (timetaken != 0)
  298.     {
  299.       printf ("# cycles/second          %10d\n", (int) (saved_state.cycles / timetaken));
  300.       printf ("# simulation ratio       %10.4f\n", virttime / timetaken);
  301.     }
  302.  
  303. }
  304.  
  305.  
  306.  
  307. void
  308. sim_kill ()
  309. {
  310.  
  311. }
  312.  
  313. void
  314. sim_open (name)
  315.      char *name;
  316. {
  317. }
  318.  
  319.  
  320.  
  321. #undef fetch8
  322. fetch8func (x)
  323. {
  324.   if (x & ~MMASK)
  325.     {
  326.       saved_state.exception = SIGBUS;
  327.       return 0;
  328.     }
  329.   return saved_state.memory[x];
  330. }
  331.  
  332. fetch8 (x)
  333. {
  334. return fetch8func(x);
  335. }
  336.  
  337. void
  338. sim_close (quitting)
  339.      int quitting;
  340. {
  341.   /* nothing to do */
  342. }
  343.  
  344. int
  345. sim_load (prog, from_tty)
  346.      char *prog;
  347.      int from_tty;
  348. {
  349.   /* Return nonzero so gdb will handle it.  */
  350.   return 1;
  351. }
  352.  
  353.  
  354. void
  355. sim_create_inferior (start_address, argv, env)
  356.      SIM_ADDR start_address;
  357.      char **argv;
  358.      char **env;
  359. {
  360.   /* ??? We assume this is a 4 byte quantity.  */
  361.   int pc;
  362.  
  363.   pc = start_address;
  364.   sim_store_register (16, (unsigned char *) &pc);
  365. }
  366.