home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / D / GDB / GDB-4.13 / GDB-4 / gdb-4.13 / gdb / remote-z8k.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-01-06  |  7.6 KB  |  361 lines
  1. /* Remote debugging interface for Zilog Z8000 simulator
  2.    Copyright 1992,1993 Free Software Foundation, Inc.
  3.    Contributed by Cygnus Support.  Written by Steve Chamberlain
  4.    (sac@cygnus.com).
  5.  
  6. This file is part of GDB.
  7.  
  8. This program is free software; you can redistribute it and/or modify
  9. it under the terms of the GNU General Public License as published by
  10. the Free Software Foundation; either version 2 of the License, or
  11. (at your option) any later version.
  12.  
  13. This program is distributed in the hope that it will be useful,
  14. but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. GNU General Public License for more details.
  17.  
  18. You should have received a copy of the GNU General Public License
  19. along with this program; if not, write to the Free Software
  20. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  21.  
  22. #include "defs.h"
  23. #include "inferior.h"
  24. #include "wait.h"
  25. #include "value.h"
  26. #include <string.h>
  27. #include <ctype.h>
  28. #include <fcntl.h>
  29. #include <signal.h>
  30. #include <setjmp.h>
  31. #include <errno.h>
  32. #include "terminal.h"
  33. #include "target.h"
  34. #include "gdbcore.h"
  35. #include "../sim/z8k/sim.h"
  36.  
  37. /* External data declarations */
  38. extern int stop_soon_quietly;    /* for wait_for_inferior */
  39.  
  40. /* Forward data declarations */
  41. /*extern struct target_ops sim_ops;    /* Forward declaration */
  42.  
  43. void sim_store_register ();
  44. void sim_set_oc ();
  45.  
  46. int inferior_pid;
  47. int
  48. sim_write_inferior_memory (memaddr, myaddr, len)
  49.      CORE_ADDR memaddr;
  50.      unsigned char *myaddr;
  51.      int len;
  52. {
  53.   sim_write (memaddr, myaddr, len);
  54.   return 1;
  55. }
  56.  
  57. static void
  58. store_register (regno)
  59.      int regno;
  60. {
  61.   if (regno == -1)
  62.     {
  63.       for (regno = 0; regno < 16; regno++)
  64.     {
  65.       store_register (regno);
  66.     }
  67.     }
  68.   else
  69.     {
  70.       sim_store_register (regno, read_register (regno));
  71.     }
  72. }
  73.  
  74. void
  75. sim_kill (arg, from_tty)
  76.      char *arg;
  77.      int from_tty;
  78. {
  79. }
  80.  
  81. /*
  82.  * Download a file specified in 'args', to the sim.
  83.  */
  84. static void
  85. sasassim_load (args, fromtty)
  86.      char *args;
  87.      int fromtty;
  88. {
  89.   bfd *abfd;
  90.   asection *s;
  91.  
  92.   inferior_pid = 0;
  93.   abfd = bfd_openr (args, "coff-z8k");
  94.  
  95.   if (!abfd)
  96.     {
  97.       printf_filtered ("Unable to open file %s\n", args);
  98.       return;
  99.     }
  100.  
  101.   if (bfd_check_format (abfd, bfd_object) == 0)
  102.     {
  103.       printf_filtered ("File is not an object file\n");
  104.       return;
  105.     }
  106.  
  107.   s = abfd->sections;
  108.   while (s != (asection *) NULL)
  109.     {
  110.       if (s->flags & SEC_LOAD)
  111.     {
  112.       int i;
  113.       int delta = 4096;
  114.       char *buffer = xmalloc (delta);
  115.  
  116.       printf_filtered ("%s\t: 0x%4x .. 0x%4x  ",
  117.                s->name, s->vma, s->vma + s->_raw_size);
  118.       for (i = 0; i < s->_raw_size; i += delta)
  119.         {
  120.           int sub_delta = delta;
  121.  
  122.           if (sub_delta > s->_raw_size - i)
  123.         sub_delta = s->_raw_size - i;
  124.  
  125.           bfd_get_section_contents (abfd, s, buffer, i, sub_delta);
  126.           sim_write_inferior_memory (s->vma + i, buffer, sub_delta);
  127.           printf_filtered ("*");
  128.           gdb_flush (gdb_stdout);
  129.         }
  130.       printf_filtered ("\n");
  131.       free (buffer);
  132.     }
  133.       s = s->next;
  134.     }
  135.  
  136.   sim_set_pc (abfd->start_address);
  137. }
  138.  
  139. /* This is called not only when we first attach, but also when the
  140.    user types "run" after having attached.  */
  141. static void
  142. sim_create_inferior (execfile, args, env)
  143.      char *execfile;
  144.      char *args;
  145.      char **env;
  146. {
  147.   int entry_pt;
  148.  
  149.   if (args && *args)
  150.     error ("Can't pass arguments to remote sim process.");
  151.  
  152.   if (execfile == 0 || exec_bfd == 0)
  153.     error ("No exec file specified");
  154.  
  155.   entry_pt = (int) bfd_get_start_address (exec_bfd);
  156.  
  157.   sim_kill (NULL, NULL);
  158.   sim_clear_breakpoints ();
  159.   init_wait_for_inferior ();
  160.   insert_breakpoints ();
  161.   proceed (entry_pt, TARGET_SIGNAL_DEFAULT, 0);
  162. }
  163. #if 0
  164. static void
  165. sim_open (name, from_tty)
  166.      char *name;
  167.      int from_tty;
  168. {
  169.   if (name == 0)
  170.     {
  171.       name = "";
  172.     }
  173.  
  174.   /* Clear any break points */
  175.   sim_clear_breakpoints ();
  176.  
  177.   push_target (&sim_ops);
  178.   target_fetch_registers (-1);
  179.  
  180.   printf_filtered ("Connected to the Z8000 Simulator.\n");
  181. }
  182.  
  183. /* Close out all files and local state before this target loses control. */
  184.  
  185. static void
  186. sim_close (quitting)
  187.      int quitting;
  188. {
  189.   sim_clear_breakpoints ();
  190. }
  191.  
  192. /* Terminate the open connection to the remote debugger.
  193.    Use this when you want to detach and do something else
  194.    with your gdb.  */
  195. static void
  196. sim_detach (args, from_tty)
  197.      char *args;
  198.      int from_tty;
  199. {
  200.   sim_clear_breakpoints ();
  201.  
  202.   pop_target ();        /* calls sim_close to do the real work */
  203.   if (from_tty)
  204.     printf_filtered ("Ending remote %s debugging\n", target_shortname);
  205. }
  206. #endif
  207. /* Tell the remote machine to resume.  */
  208.  
  209. /* Wait until the remote machine stops, then return,
  210.    storing status in STATUS just as `wait' would.  */
  211. #if 0
  212. /* See remote-sim.c for how this is done now.  */
  213. int
  214. sim_wait (pid, status)
  215.      int pid;
  216.      WAITTYPE *status;
  217. {
  218.   sim_stop_reason (&reason, &sigrc);
  219.   return inferior_pid;
  220. }
  221. #endif
  222. /* Get ready to modify the registers array.  On machines which store
  223.    individual registers, this doesn't need to do anything.  On machines
  224.    which store all the registers in one fell swoop, this makes sure
  225.    that registers contains all the registers from the program being
  226.    debugged.  */
  227.  
  228. static void
  229. sim_prepare_to_store ()
  230. {
  231.   /* Do nothing, since we can store individual regs */
  232. }
  233.  
  234. static void
  235. fetch_register (regno)
  236.      int regno;
  237. {
  238.   if (regno == -1)
  239.     {
  240.       for (regno = 0; regno < 16; regno++)
  241.     fetch_register (regno);
  242.     }
  243.   else
  244.     {
  245.       char buf[MAX_REGISTER_RAW_SIZE];
  246.  
  247.       sim_fetch_register (regno, buf);
  248.       supply_register (regno, buf);
  249.     }
  250. }
  251.  
  252. /* Write a word WORD into remote address ADDR.
  253.    This goes through the data cache.  */
  254.  
  255. void
  256. sim_store_word (addr, word)
  257.      CORE_ADDR addr;
  258.      int word;
  259. {
  260. /*    dcache_poke (addr, word);*/
  261. }
  262.  
  263. int
  264. sim_xfer_inferior_memory (memaddr, myaddr, len, write, target)
  265.      CORE_ADDR memaddr;
  266.      char *myaddr;
  267.      int len;
  268.      int write;
  269.      struct target_ops *target;    /* ignored */
  270. {
  271.   if (write)
  272.     {
  273.       sim_write (memaddr, myaddr, len);
  274.  
  275.     }
  276.   else
  277.     {
  278.       sim_read (memaddr, myaddr, len);
  279.     }
  280.   return len;
  281. }
  282.  
  283. void
  284. sim_files_info ()
  285. {
  286.   char *file = "nothing";
  287.  
  288.   if (exec_bfd)
  289.     file = bfd_get_filename (exec_bfd);
  290.  
  291.   printf_filtered ("\tAttached to %s running on the z8k simulator\n", file);
  292. }
  293.  
  294. /* This routine is run as a hook, just before the main command loop is
  295.    entered.  If gdb is configured for the H8, but has not had its
  296.    target specified yet, this will loop prompting the user to do so.
  297. */
  298.  
  299. #if 0
  300. void
  301. sim_before_main_loop ()
  302. {
  303.   push_target (&sim_ops);
  304. }
  305.  
  306.  
  307. /* Clear the sims notion of what the break points are */
  308. static void
  309. sim_mourn ()
  310. {
  311.   sim_clear_breakpoints ();
  312.   unpush_target (&sim_ops);
  313.   generic_mourn_inferior ();
  314. }
  315. #endif
  316. static void 
  317. rem_resume (pid, a, b)
  318.      int pid;
  319.      int a;
  320.      enum target_signal siggnal;
  321. {
  322.   sim_resume (a, target_signal_to_host (siggnal));
  323. }
  324.  
  325.  
  326. /* Define the target subroutine names */
  327. #if 0
  328. struct target_ops sim_ops =
  329. {
  330.   "sim", "Remote SIM monitor",
  331.   "Use the Z8000 simulator",
  332.   sim_open, sim_close,
  333.   0, sim_detach, rem_resume, sim_wait,    /* attach */
  334.   fetch_register, store_register,
  335.   sim_prepare_to_store,
  336.   sim_xfer_inferior_memory,
  337.   sim_files_info,
  338.   0, 0,                /* Breakpoints */
  339.   0, 0, 0, 0, 0,        /* Terminal handling */
  340.   sim_kill,            /* FIXME, kill */
  341.   sim_load,
  342.   0,                /* lookup_symbol */
  343.   sim_create_inferior,        /* create_inferior */
  344.   sim_mourn,            /* mourn_inferior FIXME */
  345.   0,                /* can_run */
  346.   0,                /* notice_signals */
  347.   process_stratum, 0,        /* next */
  348.   1, 1, 1, 1, 1,        /* all mem, mem, stack, regs, exec */
  349.   0, 0,                /* Section pointers */
  350.   OPS_MAGIC,            /* Always the last thing */
  351. };
  352.  
  353. /***********************************************************************/
  354.  
  355. void
  356. _initialize_remote_sim ()
  357. {
  358.   add_target (&sim_ops);
  359. }
  360. #endif
  361.