This commit was generated by cvs2svn to track changes on a CVS vendor
[external/binutils.git] / gdb / remote-sim.c
1 /* Generic remote debugging interface for simulators.
2    Copyright 1993, 1994, 1996, 1997, 2000 Free Software Foundation, Inc.
3    Contributed by Cygnus Support.
4    Steve Chamberlain (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., 59 Temple Place - Suite 330,
21    Boston, MA 02111-1307, USA.  */
22
23 #include "defs.h"
24 #include "inferior.h"
25 #include "gdb_wait.h"
26 #include "value.h"
27 #include "gdb_string.h"
28 #include <ctype.h>
29 #include <fcntl.h>
30 #include <signal.h>
31 #include <setjmp.h>
32 #include <errno.h>
33 #include "terminal.h"
34 #include "target.h"
35 #include "gdbcore.h"
36 #include "callback.h"
37 #include "remote-sim.h"
38 #include "remote-utils.h"
39 #include "command.h"
40
41 /* Prototypes */
42
43 extern void _initialize_remote_sim PARAMS ((void));
44
45 extern int (*ui_loop_hook) PARAMS ((int signo));
46
47 static void dump_mem PARAMS ((char *buf, int len));
48
49 static void init_callbacks PARAMS ((void));
50
51 static void end_callbacks PARAMS ((void));
52
53 static int gdb_os_write_stdout PARAMS ((host_callback *, const char *, int));
54
55 static void gdb_os_flush_stdout PARAMS ((host_callback *));
56
57 static int gdb_os_write_stderr PARAMS ((host_callback *, const char *, int));
58
59 static void gdb_os_flush_stderr PARAMS ((host_callback *));
60
61 static int gdb_os_poll_quit PARAMS ((host_callback *));
62
63 /* printf_filtered is depreciated */
64 static void gdb_os_printf_filtered PARAMS ((host_callback *, const char *,...));
65
66 static void gdb_os_vprintf_filtered PARAMS ((host_callback *, const char *, va_list));
67
68 static void gdb_os_evprintf_filtered PARAMS ((host_callback *, const char *, va_list));
69
70 static void gdb_os_error PARAMS ((host_callback *, const char *,...));
71
72 static void gdbsim_fetch_register PARAMS ((int regno));
73
74 static void gdbsim_store_register PARAMS ((int regno));
75
76 static void gdbsim_kill PARAMS ((void));
77
78 static void gdbsim_load PARAMS ((char *prog, int fromtty));
79
80 static void gdbsim_create_inferior PARAMS ((char *exec_file, char *args, char **env));
81
82 static void gdbsim_open PARAMS ((char *args, int from_tty));
83
84 static void gdbsim_close PARAMS ((int quitting));
85
86 static void gdbsim_detach PARAMS ((char *args, int from_tty));
87
88 static void gdbsim_resume PARAMS ((int pid, int step, enum target_signal siggnal));
89
90 static int gdbsim_wait PARAMS ((int pid, struct target_waitstatus * status));
91
92 static void gdbsim_prepare_to_store PARAMS ((void));
93
94 static int gdbsim_xfer_inferior_memory PARAMS ((CORE_ADDR memaddr,
95                                                 char *myaddr, int len,
96                                                 int write,
97                                                 struct target_ops * target));
98
99 static void gdbsim_files_info PARAMS ((struct target_ops * target));
100
101 static void gdbsim_mourn_inferior PARAMS ((void));
102
103 static void gdbsim_stop PARAMS ((void));
104
105 void simulator_command PARAMS ((char *args, int from_tty));
106
107 /* Naming convention:
108
109    sim_* are the interface to the simulator (see remote-sim.h).
110    gdbsim_* are stuff which is internal to gdb.  */
111
112 /* Forward data declarations */
113 extern struct target_ops gdbsim_ops;
114
115 static int program_loaded = 0;
116
117 /* We must keep track of whether the simulator has been opened or not because
118    GDB can call a target's close routine twice, but sim_close doesn't allow
119    this.  We also need to record the result of sim_open so we can pass it
120    back to the other sim_foo routines.  */
121 static SIM_DESC gdbsim_desc = 0;
122
123 static void
124 dump_mem (buf, len)
125      char *buf;
126      int len;
127 {
128   if (len <= 8)
129     {
130       if (len == 8 || len == 4)
131         {
132           long l[2];
133           memcpy (l, buf, len);
134           printf_filtered ("\t0x%lx", l[0]);
135           printf_filtered (len == 8 ? " 0x%x\n" : "\n", l[1]);
136         }
137       else
138         {
139           int i;
140           printf_filtered ("\t");
141           for (i = 0; i < len; i++)
142             printf_filtered ("0x%x ", buf[i]);
143           printf_filtered ("\n");
144         }
145     }
146 }
147
148 static host_callback gdb_callback;
149 static int callbacks_initialized = 0;
150
151 /* Initialize gdb_callback.  */
152
153 static void
154 init_callbacks ()
155 {
156   if (!callbacks_initialized)
157     {
158       gdb_callback = default_callback;
159       gdb_callback.init (&gdb_callback);
160       gdb_callback.write_stdout = gdb_os_write_stdout;
161       gdb_callback.flush_stdout = gdb_os_flush_stdout;
162       gdb_callback.write_stderr = gdb_os_write_stderr;
163       gdb_callback.flush_stderr = gdb_os_flush_stderr;
164       gdb_callback.printf_filtered = gdb_os_printf_filtered;
165       gdb_callback.vprintf_filtered = gdb_os_vprintf_filtered;
166       gdb_callback.evprintf_filtered = gdb_os_evprintf_filtered;
167       gdb_callback.error = gdb_os_error;
168       gdb_callback.poll_quit = gdb_os_poll_quit;
169       gdb_callback.magic = HOST_CALLBACK_MAGIC;
170       callbacks_initialized = 1;
171     }
172 }
173
174 /* Release callbacks (free resources used by them).  */
175
176 static void
177 end_callbacks ()
178 {
179   if (callbacks_initialized)
180     {
181       gdb_callback.shutdown (&gdb_callback);
182       callbacks_initialized = 0;
183     }
184 }
185
186 /* GDB version of os_write_stdout callback.  */
187
188 static int
189 gdb_os_write_stdout (p, buf, len)
190      host_callback *p;
191      const char *buf;
192      int len;
193 {
194   int i;
195   char b[2];
196
197   ui_file_write (gdb_stdtarg, buf, len);
198   return len;
199 }
200
201 /* GDB version of os_flush_stdout callback.  */
202
203 static void
204 gdb_os_flush_stdout (p)
205      host_callback *p;
206 {
207   gdb_flush (gdb_stdtarg);
208 }
209
210 /* GDB version of os_write_stderr callback.  */
211
212 static int
213 gdb_os_write_stderr (p, buf, len)
214      host_callback *p;
215      const char *buf;
216      int len;
217 {
218   int i;
219   char b[2];
220
221   for (i = 0; i < len; i++)
222     {
223       b[0] = buf[i];
224       b[1] = 0;
225       fputs_unfiltered (b, gdb_stdtarg);
226     }
227   return len;
228 }
229
230 /* GDB version of os_flush_stderr callback.  */
231
232 static void
233 gdb_os_flush_stderr (p)
234      host_callback *p;
235 {
236   gdb_flush (gdb_stderr);
237 }
238
239 /* GDB version of printf_filtered callback.  */
240
241 static void
242 gdb_os_printf_filtered (host_callback * p, const char *format,...)
243 {
244   va_list args;
245   va_start (args, format);
246
247   vfprintf_filtered (gdb_stdout, format, args);
248
249   va_end (args);
250 }
251
252 /* GDB version of error vprintf_filtered.  */
253
254 static void
255 gdb_os_vprintf_filtered (host_callback * p, const char *format, va_list ap)
256 {
257   vfprintf_filtered (gdb_stdout, format, ap);
258 }
259
260 /* GDB version of error evprintf_filtered.  */
261
262 static void
263 gdb_os_evprintf_filtered (host_callback * p, const char *format, va_list ap)
264 {
265   vfprintf_filtered (gdb_stderr, format, ap);
266 }
267
268 /* GDB version of error callback.  */
269
270 static void
271 gdb_os_error (host_callback * p, const char *format,...)
272 {
273   if (error_hook)
274     (*error_hook) ();
275   else
276     {
277       va_list args;
278       va_start (args, format);
279       verror (format, args);
280       va_end (args);
281     }
282 }
283
284 #ifndef REGISTER_SIM_REGNO
285 #define REGISTER_SIM_REGNO(N) (N)
286 #endif
287
288 static void
289 gdbsim_fetch_register (regno)
290      int regno;
291 {
292   static int warn_user = 1;
293   if (regno == -1)
294     {
295       for (regno = 0; regno < NUM_REGS; regno++)
296         gdbsim_fetch_register (regno);
297     }
298   else if (REGISTER_NAME (regno) != NULL
299            && *REGISTER_NAME (regno) != '\0')
300     {
301       char buf[MAX_REGISTER_RAW_SIZE];
302       int nr_bytes;
303       if (REGISTER_SIM_REGNO (regno) >= 0)
304         nr_bytes = sim_fetch_register (gdbsim_desc,
305                                        REGISTER_SIM_REGNO (regno),
306                                        buf, REGISTER_RAW_SIZE (regno));
307       else
308         nr_bytes = 0;
309       if (nr_bytes == 0)
310         /* register not applicable, supply zero's */
311         memset (buf, 0, MAX_REGISTER_RAW_SIZE);
312       else if (nr_bytes > 0 && nr_bytes != REGISTER_RAW_SIZE (regno)
313                && warn_user)
314         {
315           fprintf_unfiltered (gdb_stderr,
316                               "Size of register %s (%d/%d) incorrect (%d instead of %d))",
317                               REGISTER_NAME (regno),
318                               regno, REGISTER_SIM_REGNO (regno),
319                               nr_bytes, REGISTER_RAW_SIZE (regno));
320           warn_user = 0;
321         }
322       supply_register (regno, buf);
323       if (sr_get_debug ())
324         {
325           printf_filtered ("gdbsim_fetch_register: %d", regno);
326           /* FIXME: We could print something more intelligible.  */
327           dump_mem (buf, REGISTER_RAW_SIZE (regno));
328         }
329     }
330 }
331
332
333 static void
334 gdbsim_store_register (regno)
335      int regno;
336 {
337   if (regno == -1)
338     {
339       for (regno = 0; regno < NUM_REGS; regno++)
340         gdbsim_store_register (regno);
341     }
342   else if (REGISTER_NAME (regno) != NULL
343            && *REGISTER_NAME (regno) != '\0'
344            && REGISTER_SIM_REGNO (regno) >= 0)
345     {
346       char tmp[MAX_REGISTER_RAW_SIZE];
347       int nr_bytes;
348       read_register_gen (regno, tmp);
349       nr_bytes = sim_store_register (gdbsim_desc,
350                                      REGISTER_SIM_REGNO (regno),
351                                      tmp, REGISTER_RAW_SIZE (regno));
352       if (nr_bytes > 0 && nr_bytes != REGISTER_RAW_SIZE (regno))
353         internal_error ("Register size different to expected");
354       if (sr_get_debug ())
355         {
356           printf_filtered ("gdbsim_store_register: %d", regno);
357           /* FIXME: We could print something more intelligible.  */
358           dump_mem (tmp, REGISTER_RAW_SIZE (regno));
359         }
360     }
361 }
362
363 /* Kill the running program.  This may involve closing any open files
364    and releasing other resources acquired by the simulated program.  */
365
366 static void
367 gdbsim_kill ()
368 {
369   if (sr_get_debug ())
370     printf_filtered ("gdbsim_kill\n");
371
372   /* There is no need to `kill' running simulator - the simulator is
373      not running */
374   inferior_pid = 0;
375 }
376
377 /* Load an executable file into the target process.  This is expected to
378    not only bring new code into the target process, but also to update
379    GDB's symbol tables to match.  */
380
381 static void
382 gdbsim_load (prog, fromtty)
383      char *prog;
384      int fromtty;
385 {
386   if (sr_get_debug ())
387     printf_filtered ("gdbsim_load: prog \"%s\"\n", prog);
388
389   inferior_pid = 0;
390
391   /* FIXME: We will print two messages on error.
392      Need error to either not print anything if passed NULL or need
393      another routine that doesn't take any arguments.  */
394   if (sim_load (gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL)
395     error ("unable to load program");
396
397   /* FIXME: If a load command should reset the targets registers then
398      a call to sim_create_inferior() should go here. */
399
400   program_loaded = 1;
401 }
402
403
404 /* Start an inferior process and set inferior_pid to its pid.
405    EXEC_FILE is the file to run.
406    ARGS is a string containing the arguments to the program.
407    ENV is the environment vector to pass.  Errors reported with error().
408    On VxWorks and various standalone systems, we ignore exec_file.  */
409 /* This is called not only when we first attach, but also when the
410    user types "run" after having attached.  */
411
412 static void
413 gdbsim_create_inferior (exec_file, args, env)
414      char *exec_file;
415      char *args;
416      char **env;
417 {
418   int len;
419   char *arg_buf, **argv;
420
421   if (exec_file == 0 || exec_bfd == 0)
422     warning ("No executable file specified.");
423   if (!program_loaded)
424     warning ("No program loaded.");
425
426   if (sr_get_debug ())
427     printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
428                      (exec_file ? exec_file : "(NULL)"),
429                      args);
430
431   gdbsim_kill ();
432   remove_breakpoints ();
433   init_wait_for_inferior ();
434
435   if (exec_file != NULL)
436     {
437       len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop */ 10;
438       arg_buf = (char *) alloca (len);
439       arg_buf[0] = '\0';
440       strcat (arg_buf, exec_file);
441       strcat (arg_buf, " ");
442       strcat (arg_buf, args);
443       argv = buildargv (arg_buf);
444       make_cleanup_freeargv (argv);
445     }
446   else
447     argv = NULL;
448   sim_create_inferior (gdbsim_desc, exec_bfd, argv, env);
449
450   inferior_pid = 42;
451   insert_breakpoints ();        /* Needed to get correct instruction in cache */
452
453   clear_proceed_status ();
454
455   /* NB: Entry point already set by sim_create_inferior. */
456   proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
457 }
458
459 /* The open routine takes the rest of the parameters from the command,
460    and (if successful) pushes a new target onto the stack.
461    Targets should supply this routine, if only to provide an error message.  */
462 /* Called when selecting the simulator. EG: (gdb) target sim name.  */
463
464 static void
465 gdbsim_open (args, from_tty)
466      char *args;
467      int from_tty;
468 {
469   int len;
470   char *arg_buf;
471   char **argv;
472
473   if (sr_get_debug ())
474     printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
475
476   /* Remove current simulator if one exists.  Only do this if the simulator
477      has been opened because sim_close requires it.
478      This is important because the call to push_target below will cause
479      sim_close to be called if the simulator is already open, but push_target
480      is called after sim_open!  We can't move the call to push_target before
481      the call to sim_open because sim_open may invoke `error'.  */
482   if (gdbsim_desc != NULL)
483     unpush_target (&gdbsim_ops);
484
485   len = (7 + 1                  /* gdbsim */
486          + strlen (" -E little")
487          + strlen (" --architecture=xxxxxxxxxx")
488          + (args ? strlen (args) : 0)
489          + 50) /* slack */ ;
490   arg_buf = (char *) alloca (len);
491   strcpy (arg_buf, "gdbsim");   /* 7 */
492   /* Specify the byte order for the target when it is both selectable
493      and explicitly specified by the user (not auto detected). */
494   if (TARGET_BYTE_ORDER_SELECTABLE_P
495       && !TARGET_BYTE_ORDER_AUTO)
496     {
497       switch (TARGET_BYTE_ORDER)
498         {
499         case BIG_ENDIAN:
500           strcat (arg_buf, " -E big");
501           break;
502         case LITTLE_ENDIAN:
503           strcat (arg_buf, " -E little");
504           break;
505         default:
506           internal_error ("Value of TARGET_BYTE_ORDER unknown");
507         }
508     }
509   /* Specify the architecture of the target when it has been
510      explicitly specified */
511   if (!TARGET_ARCHITECTURE_AUTO)
512     {
513       strcat (arg_buf, " --architecture=");
514       strcat (arg_buf, TARGET_ARCHITECTURE->printable_name);
515     }
516   /* finally, any explicit args */
517   if (args)
518     {
519       strcat (arg_buf, " ");    /* 1 */
520       strcat (arg_buf, args);
521     }
522   argv = buildargv (arg_buf);
523   if (argv == NULL)
524     error ("Insufficient memory available to allocate simulator arg list.");
525   make_cleanup_freeargv (argv);
526
527   init_callbacks ();
528   gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, argv);
529
530   if (gdbsim_desc == 0)
531     error ("unable to create simulator instance");
532
533   push_target (&gdbsim_ops);
534   target_fetch_registers (-1);
535   printf_filtered ("Connected to the simulator.\n");
536 }
537
538 /* Does whatever cleanup is required for a target that we are no longer
539    going to be calling.  Argument says whether we are quitting gdb and
540    should not get hung in case of errors, or whether we want a clean
541    termination even if it takes a while.  This routine is automatically
542    always called just before a routine is popped off the target stack.
543    Closing file descriptors and freeing memory are typical things it should
544    do.  */
545 /* Close out all files and local state before this target loses control. */
546
547 static void
548 gdbsim_close (quitting)
549      int quitting;
550 {
551   if (sr_get_debug ())
552     printf_filtered ("gdbsim_close: quitting %d\n", quitting);
553
554   program_loaded = 0;
555
556   if (gdbsim_desc != NULL)
557     {
558       sim_close (gdbsim_desc, quitting);
559       gdbsim_desc = NULL;
560     }
561
562   end_callbacks ();
563 }
564
565 /* Takes a program previously attached to and detaches it.
566    The program may resume execution (some targets do, some don't) and will
567    no longer stop on signals, etc.  We better not have left any breakpoints
568    in the program or it'll die when it hits one.  ARGS is arguments
569    typed by the user (e.g. a signal to send the process).  FROM_TTY
570    says whether to be verbose or not.  */
571 /* Terminate the open connection to the remote debugger.
572    Use this when you want to detach and do something else with your gdb.  */
573
574 static void
575 gdbsim_detach (args, from_tty)
576      char *args;
577      int from_tty;
578 {
579   if (sr_get_debug ())
580     printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
581
582   pop_target ();                /* calls gdbsim_close to do the real work */
583   if (from_tty)
584     printf_filtered ("Ending simulator %s debugging\n", target_shortname);
585 }
586
587 /* Resume execution of the target process.  STEP says whether to single-step
588    or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
589    to the target, or zero for no signal.  */
590
591 static enum target_signal resume_siggnal;
592 static int resume_step;
593
594 static void
595 gdbsim_resume (pid, step, siggnal)
596      int pid, step;
597      enum target_signal siggnal;
598 {
599   if (inferior_pid != 42)
600     error ("The program is not being run.");
601
602   if (sr_get_debug ())
603     printf_filtered ("gdbsim_resume: step %d, signal %d\n", step, siggnal);
604
605   resume_siggnal = siggnal;
606   resume_step = step;
607 }
608
609 /* Notify the simulator of an asynchronous request to stop.
610
611    The simulator shall ensure that the stop request is eventually
612    delivered to the simulator.  If the call is made while the
613    simulator is not running then the stop request is processed when
614    the simulator is next resumed.
615
616    For simulators that do not support this operation, just abort */
617
618 static void
619 gdbsim_stop ()
620 {
621   if (!sim_stop (gdbsim_desc))
622     {
623       quit ();
624     }
625 }
626
627 /* GDB version of os_poll_quit callback.
628    Taken from gdb/util.c - should be in a library */
629
630 static int
631 gdb_os_poll_quit (p)
632      host_callback *p;
633 {
634   if (ui_loop_hook != NULL)
635     ui_loop_hook (0);
636
637   notice_quit ();
638   if (quit_flag)                /* gdb's idea of quit */
639     {
640       quit_flag = 0;            /* we've stolen it */
641       return 1;
642     }
643   else if (immediate_quit)
644     {
645       return 1;
646     }
647   return 0;
648 }
649
650 /* Wait for inferior process to do something.  Return pid of child,
651    or -1 in case of error; store status through argument pointer STATUS,
652    just as `wait' would. */
653
654 static void
655 gdbsim_cntrl_c (signo)
656      int signo;
657 {
658   gdbsim_stop ();
659 }
660
661 static int
662 gdbsim_wait (pid, status)
663      int pid;
664      struct target_waitstatus *status;
665 {
666   static RETSIGTYPE (*prev_sigint) ();
667   int sigrc = 0;
668   enum sim_stop reason = sim_running;
669
670   if (sr_get_debug ())
671     printf_filtered ("gdbsim_wait\n");
672
673 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
674   {
675     struct sigaction sa, osa;
676     sa.sa_handler = gdbsim_cntrl_c;
677     sigemptyset (&sa.sa_mask);
678     sa.sa_flags = 0;
679     sigaction (SIGINT, &sa, &osa);
680     prev_sigint = osa.sa_handler;
681   }
682 #else
683   prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
684 #endif
685   sim_resume (gdbsim_desc, resume_step,
686               target_signal_to_host (resume_siggnal));
687   signal (SIGINT, prev_sigint);
688   resume_step = 0;
689
690   sim_stop_reason (gdbsim_desc, &reason, &sigrc);
691
692   switch (reason)
693     {
694     case sim_exited:
695       status->kind = TARGET_WAITKIND_EXITED;
696       status->value.integer = sigrc;
697       break;
698     case sim_stopped:
699       switch (sigrc)
700         {
701         case SIGABRT:
702           quit ();
703           break;
704         case SIGINT:
705         case SIGTRAP:
706         default:
707           status->kind = TARGET_WAITKIND_STOPPED;
708           /* The signal in sigrc is a host signal.  That probably
709              should be fixed.  */
710           status->value.sig = target_signal_from_host (sigrc);
711           break;
712         }
713       break;
714     case sim_signalled:
715       status->kind = TARGET_WAITKIND_SIGNALLED;
716       /* The signal in sigrc is a host signal.  That probably
717          should be fixed.  */
718       status->value.sig = target_signal_from_host (sigrc);
719       break;
720     case sim_running:
721     case sim_polling:
722       /* FIXME: Is this correct? */
723       break;
724     }
725
726   return inferior_pid;
727 }
728
729 /* Get ready to modify the registers array.  On machines which store
730    individual registers, this doesn't need to do anything.  On machines
731    which store all the registers in one fell swoop, this makes sure
732    that registers contains all the registers from the program being
733    debugged.  */
734
735 static void
736 gdbsim_prepare_to_store ()
737 {
738   /* Do nothing, since we can store individual regs */
739 }
740
741 static int
742 gdbsim_xfer_inferior_memory (memaddr, myaddr, len, write, target)
743      CORE_ADDR memaddr;
744      char *myaddr;
745      int len;
746      int write;
747      struct target_ops *target; /* ignored */
748 {
749   if (!program_loaded)
750     error ("No program loaded.");
751
752   if (sr_get_debug ())
753     {
754       /* FIXME: Send to something other than STDOUT? */
755       printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x");
756       gdb_print_host_address (myaddr, gdb_stdout);
757       printf_filtered (", memaddr 0x%s, len %d, write %d\n",
758                        paddr_nz (memaddr), len, write);
759       if (sr_get_debug () && write)
760         dump_mem (myaddr, len);
761     }
762
763   if (write)
764     {
765       len = sim_write (gdbsim_desc, memaddr, myaddr, len);
766     }
767   else
768     {
769       len = sim_read (gdbsim_desc, memaddr, myaddr, len);
770       if (sr_get_debug () && len > 0)
771         dump_mem (myaddr, len);
772     }
773   return len;
774 }
775
776 static void
777 gdbsim_files_info (target)
778      struct target_ops *target;
779 {
780   char *file = "nothing";
781
782   if (exec_bfd)
783     file = bfd_get_filename (exec_bfd);
784
785   if (sr_get_debug ())
786     printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
787
788   if (exec_bfd)
789     {
790       printf_filtered ("\tAttached to %s running program %s\n",
791                        target_shortname, file);
792       sim_info (gdbsim_desc, 0);
793     }
794 }
795
796 /* Clear the simulator's notion of what the break points are.  */
797
798 static void
799 gdbsim_mourn_inferior ()
800 {
801   if (sr_get_debug ())
802     printf_filtered ("gdbsim_mourn_inferior:\n");
803
804   remove_breakpoints ();
805   generic_mourn_inferior ();
806 }
807
808 static int
809 gdbsim_insert_breakpoint (addr, contents_cache)
810      CORE_ADDR addr;
811      char *contents_cache;
812 {
813 #ifdef SIM_HAS_BREAKPOINTS
814   SIM_RC retcode;
815
816   retcode = sim_set_breakpoint (gdbsim_desc, addr);
817
818   switch (retcode)
819     {
820     case SIM_RC_OK:
821       return 0;
822     case SIM_RC_INSUFFICIENT_RESOURCES:
823       return ENOMEM;
824     default:
825       return EIO;
826     }
827 #else
828   return memory_insert_breakpoint (addr, contents_cache);
829 #endif
830 }
831
832 static int
833 gdbsim_remove_breakpoint (addr, contents_cache)
834      CORE_ADDR addr;
835      char *contents_cache;
836 {
837 #ifdef SIM_HAS_BREAKPOINTS
838   SIM_RC retcode;
839
840   retcode = sim_clear_breakpoint (gdbsim_desc, addr);
841
842   switch (retcode)
843     {
844     case SIM_RC_OK:
845     case SIM_RC_UNKNOWN_BREAKPOINT:
846       return 0;
847     case SIM_RC_INSUFFICIENT_RESOURCES:
848       return ENOMEM;
849     default:
850       return EIO;
851     }
852 #else
853   return memory_remove_breakpoint (addr, contents_cache);
854 #endif
855 }
856
857 /* Pass the command argument through to the simulator verbatim.  The
858    simulator must do any command interpretation work.  */
859
860 void
861 simulator_command (args, from_tty)
862      char *args;
863      int from_tty;
864 {
865   if (gdbsim_desc == NULL)
866     {
867
868       /* PREVIOUSLY: The user may give a command before the simulator
869          is opened. [...] (??? assuming of course one wishes to
870          continue to allow commands to be sent to unopened simulators,
871          which isn't entirely unreasonable). */
872
873       /* The simulator is a builtin abstraction of a remote target.
874          Consistent with that model, access to the simulator, via sim
875          commands, is restricted to the period when the channel to the
876          simulator is open. */
877
878       error ("Not connected to the simulator target");
879     }
880
881   sim_do_command (gdbsim_desc, args);
882
883   /* Invalidate the register cache, in case the simulator command does
884      something funny. */
885   registers_changed ();
886 }
887
888 /* Define the target subroutine names */
889
890 struct target_ops gdbsim_ops;
891
892 static void
893 init_gdbsim_ops (void)
894 {
895   gdbsim_ops.to_shortname = "sim";
896   gdbsim_ops.to_longname = "simulator";
897   gdbsim_ops.to_doc = "Use the compiled-in simulator.";
898   gdbsim_ops.to_open = gdbsim_open;
899   gdbsim_ops.to_close = gdbsim_close;
900   gdbsim_ops.to_attach = NULL;
901   gdbsim_ops.to_post_attach = NULL;
902   gdbsim_ops.to_require_attach = NULL;
903   gdbsim_ops.to_detach = gdbsim_detach;
904   gdbsim_ops.to_require_detach = NULL;
905   gdbsim_ops.to_resume = gdbsim_resume;
906   gdbsim_ops.to_wait = gdbsim_wait;
907   gdbsim_ops.to_post_wait = NULL;
908   gdbsim_ops.to_fetch_registers = gdbsim_fetch_register;
909   gdbsim_ops.to_store_registers = gdbsim_store_register;
910   gdbsim_ops.to_prepare_to_store = gdbsim_prepare_to_store;
911   gdbsim_ops.to_xfer_memory = gdbsim_xfer_inferior_memory;
912   gdbsim_ops.to_files_info = gdbsim_files_info;
913   gdbsim_ops.to_insert_breakpoint = gdbsim_insert_breakpoint;
914   gdbsim_ops.to_remove_breakpoint = gdbsim_remove_breakpoint;
915   gdbsim_ops.to_terminal_init = NULL;
916   gdbsim_ops.to_terminal_inferior = NULL;
917   gdbsim_ops.to_terminal_ours_for_output = NULL;
918   gdbsim_ops.to_terminal_ours = NULL;
919   gdbsim_ops.to_terminal_info = NULL;
920   gdbsim_ops.to_kill = gdbsim_kill;
921   gdbsim_ops.to_load = gdbsim_load;
922   gdbsim_ops.to_lookup_symbol = NULL;
923   gdbsim_ops.to_create_inferior = gdbsim_create_inferior;
924   gdbsim_ops.to_post_startup_inferior = NULL;
925   gdbsim_ops.to_acknowledge_created_inferior = NULL;
926   gdbsim_ops.to_clone_and_follow_inferior = NULL;
927   gdbsim_ops.to_post_follow_inferior_by_clone = NULL;
928   gdbsim_ops.to_insert_fork_catchpoint = NULL;
929   gdbsim_ops.to_remove_fork_catchpoint = NULL;
930   gdbsim_ops.to_insert_vfork_catchpoint = NULL;
931   gdbsim_ops.to_remove_vfork_catchpoint = NULL;
932   gdbsim_ops.to_has_forked = NULL;
933   gdbsim_ops.to_has_vforked = NULL;
934   gdbsim_ops.to_can_follow_vfork_prior_to_exec = NULL;
935   gdbsim_ops.to_post_follow_vfork = NULL;
936   gdbsim_ops.to_insert_exec_catchpoint = NULL;
937   gdbsim_ops.to_remove_exec_catchpoint = NULL;
938   gdbsim_ops.to_has_execd = NULL;
939   gdbsim_ops.to_reported_exec_events_per_exec_call = NULL;
940   gdbsim_ops.to_has_exited = NULL;
941   gdbsim_ops.to_mourn_inferior = gdbsim_mourn_inferior;
942   gdbsim_ops.to_can_run = 0;
943   gdbsim_ops.to_notice_signals = 0;
944   gdbsim_ops.to_thread_alive = 0;
945   gdbsim_ops.to_stop = gdbsim_stop;
946   gdbsim_ops.to_pid_to_exec_file = NULL;
947   gdbsim_ops.to_core_file_to_sym_file = NULL;
948   gdbsim_ops.to_stratum = process_stratum;
949   gdbsim_ops.DONT_USE = NULL;
950   gdbsim_ops.to_has_all_memory = 1;
951   gdbsim_ops.to_has_memory = 1;
952   gdbsim_ops.to_has_stack = 1;
953   gdbsim_ops.to_has_registers = 1;
954   gdbsim_ops.to_has_execution = 1;
955   gdbsim_ops.to_sections = NULL;
956   gdbsim_ops.to_sections_end = NULL;
957   gdbsim_ops.to_magic = OPS_MAGIC;
958
959 #ifdef TARGET_REDEFINE_DEFAULT_OPS
960   TARGET_REDEFINE_DEFAULT_OPS (&gdbsim_ops);
961 #endif
962 }
963
964 void
965 _initialize_remote_sim ()
966 {
967   init_gdbsim_ops ();
968   add_target (&gdbsim_ops);
969
970   add_com ("sim <command>", class_obscure, simulator_command,
971            "Send a command to the simulator.");
972 }