1 /* Generic remote debugging interface for simulators.
2 Copyright 1993, 1994, 1996, 1997 Free Software Foundation, Inc.
3 Contributed by Cygnus Support.
4 Steve Chamberlain (sac@cygnus.com).
6 This file is part of GDB.
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.
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.
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. */
27 #include "gdb_string.h"
37 #include "remote-sim.h"
38 #include "remote-utils.h"
43 extern void _initialize_remote_sim
PARAMS ((void));
45 extern int (*ui_loop_hook
) PARAMS ((int signo
));
47 static void dump_mem
PARAMS ((char *buf
, int len
));
49 static void init_callbacks
PARAMS ((void));
51 static void end_callbacks
PARAMS ((void));
53 static int gdb_os_write_stdout
PARAMS ((host_callback
*, const char *, int));
55 static void gdb_os_flush_stdout
PARAMS ((host_callback
*));
57 static int gdb_os_write_stderr
PARAMS ((host_callback
*, const char *, int));
59 static void gdb_os_flush_stderr
PARAMS ((host_callback
*));
61 static int gdb_os_poll_quit
PARAMS ((host_callback
*));
63 /* printf_filtered is depreciated */
64 static void gdb_os_printf_filtered
PARAMS ((host_callback
*, const char *,...));
66 static void gdb_os_vprintf_filtered
PARAMS ((host_callback
*, const char *, va_list));
68 static void gdb_os_evprintf_filtered
PARAMS ((host_callback
*, const char *, va_list));
70 static void gdb_os_error
PARAMS ((host_callback
*, const char *,...));
72 static void gdbsim_fetch_register
PARAMS ((int regno
));
74 static void gdbsim_store_register
PARAMS ((int regno
));
76 static void gdbsim_kill
PARAMS ((void));
78 static void gdbsim_load
PARAMS ((char *prog
, int fromtty
));
80 static void gdbsim_create_inferior
PARAMS ((char *exec_file
, char *args
, char **env
));
82 static void gdbsim_open
PARAMS ((char *args
, int from_tty
));
84 static void gdbsim_close
PARAMS ((int quitting
));
86 static void gdbsim_detach
PARAMS ((char *args
, int from_tty
));
88 static void gdbsim_resume
PARAMS ((int pid
, int step
, enum target_signal siggnal
));
90 static int gdbsim_wait
PARAMS ((int pid
, struct target_waitstatus
* status
));
92 static void gdbsim_prepare_to_store
PARAMS ((void));
94 static int gdbsim_xfer_inferior_memory
PARAMS ((CORE_ADDR memaddr
,
95 char *myaddr
, int len
,
97 struct target_ops
* target
));
99 static void gdbsim_files_info
PARAMS ((struct target_ops
* target
));
101 static void gdbsim_mourn_inferior
PARAMS ((void));
103 static void gdbsim_stop
PARAMS ((void));
105 void simulator_command
PARAMS ((char *args
, int from_tty
));
107 /* Naming convention:
109 sim_* are the interface to the simulator (see remote-sim.h).
110 gdbsim_* are stuff which is internal to gdb. */
112 /* Forward data declarations */
113 extern struct target_ops gdbsim_ops
;
115 static int program_loaded
= 0;
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;
130 if (len
== 8 || len
== 4)
133 memcpy (l
, buf
, len
);
134 printf_filtered ("\t0x%lx", l
[0]);
135 printf_filtered (len
== 8 ? " 0x%x\n" : "\n", l
[1]);
140 printf_filtered ("\t");
141 for (i
= 0; i
< len
; i
++)
142 printf_filtered ("0x%x ", buf
[i
]);
143 printf_filtered ("\n");
148 static host_callback gdb_callback
;
149 static int callbacks_initialized
= 0;
151 /* Initialize gdb_callback. */
156 if (!callbacks_initialized
)
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;
174 /* Release callbacks (free resources used by them). */
179 if (callbacks_initialized
)
181 gdb_callback
.shutdown (&gdb_callback
);
182 callbacks_initialized
= 0;
186 /* GDB version of os_write_stdout callback. */
189 gdb_os_write_stdout (p
, buf
, len
)
197 for (i
= 0; i
< len
; i
++)
201 fputs_unfiltered (b
, gdb_stdtarg
);
206 /* GDB version of os_flush_stdout callback. */
209 gdb_os_flush_stdout (p
)
212 gdb_flush (gdb_stdout
);
215 /* GDB version of os_write_stderr callback. */
218 gdb_os_write_stderr (p
, buf
, len
)
226 for (i
= 0; i
< len
; i
++)
230 fputs_unfiltered (b
, gdb_stdtarg
);
235 /* GDB version of os_flush_stderr callback. */
238 gdb_os_flush_stderr (p
)
241 gdb_flush (gdb_stderr
);
244 /* GDB version of printf_filtered callback. */
247 gdb_os_printf_filtered (host_callback
* p
, const char *format
,...)
250 va_start (args
, format
);
252 vfprintf_filtered (gdb_stdout
, format
, args
);
257 /* GDB version of error vprintf_filtered. */
260 gdb_os_vprintf_filtered (host_callback
* p
, const char *format
, va_list ap
)
262 vfprintf_filtered (gdb_stdout
, format
, ap
);
265 /* GDB version of error evprintf_filtered. */
268 gdb_os_evprintf_filtered (host_callback
* p
, const char *format
, va_list ap
)
270 vfprintf_filtered (gdb_stderr
, format
, ap
);
273 /* GDB version of error callback. */
276 gdb_os_error (host_callback
* p
, const char *format
,...)
283 va_start (args
, format
);
286 vfprintf_filtered (gdb_stderr
, format
, args
);
287 fprintf_filtered (gdb_stderr
, "\n");
289 return_to_top_level (RETURN_ERROR
);
293 #ifndef REGISTER_SIM_REGNO
294 #define REGISTER_SIM_REGNO(N) (N)
298 gdbsim_fetch_register (regno
)
301 static int warn_user
= 1;
304 for (regno
= 0; regno
< NUM_REGS
; regno
++)
305 gdbsim_fetch_register (regno
);
307 else if (REGISTER_NAME (regno
) != NULL
308 && *REGISTER_NAME (regno
) != '\0')
310 char buf
[MAX_REGISTER_RAW_SIZE
];
312 if (REGISTER_SIM_REGNO (regno
) >= 0)
313 nr_bytes
= sim_fetch_register (gdbsim_desc
,
314 REGISTER_SIM_REGNO (regno
),
315 buf
, REGISTER_RAW_SIZE (regno
));
319 /* register not applicable, supply zero's */
320 memset (buf
, 0, MAX_REGISTER_RAW_SIZE
);
321 else if (nr_bytes
> 0 && nr_bytes
!= REGISTER_RAW_SIZE (regno
)
324 fprintf_unfiltered (gdb_stderr
,
325 "Size of register %s (%d/%d) incorrect (%d instead of %d))",
326 REGISTER_NAME (regno
),
327 regno
, REGISTER_SIM_REGNO (regno
),
328 nr_bytes
, REGISTER_RAW_SIZE (regno
));
331 supply_register (regno
, buf
);
334 printf_filtered ("gdbsim_fetch_register: %d", regno
);
335 /* FIXME: We could print something more intelligible. */
336 dump_mem (buf
, REGISTER_RAW_SIZE (regno
));
343 gdbsim_store_register (regno
)
348 for (regno
= 0; regno
< NUM_REGS
; regno
++)
349 gdbsim_store_register (regno
);
351 else if (REGISTER_NAME (regno
) != NULL
352 && *REGISTER_NAME (regno
) != '\0'
353 && REGISTER_SIM_REGNO (regno
) >= 0)
355 char tmp
[MAX_REGISTER_RAW_SIZE
];
357 read_register_gen (regno
, tmp
);
358 nr_bytes
= sim_store_register (gdbsim_desc
,
359 REGISTER_SIM_REGNO (regno
),
360 tmp
, REGISTER_RAW_SIZE (regno
));
361 if (nr_bytes
> 0 && nr_bytes
!= REGISTER_RAW_SIZE (regno
))
362 internal_error ("Register size different to expected");
365 printf_filtered ("gdbsim_store_register: %d", regno
);
366 /* FIXME: We could print something more intelligible. */
367 dump_mem (tmp
, REGISTER_RAW_SIZE (regno
));
372 /* Kill the running program. This may involve closing any open files
373 and releasing other resources acquired by the simulated program. */
379 printf_filtered ("gdbsim_kill\n");
381 /* There is no need to `kill' running simulator - the simulator is
386 /* Load an executable file into the target process. This is expected to
387 not only bring new code into the target process, but also to update
388 GDB's symbol tables to match. */
391 gdbsim_load (prog
, fromtty
)
396 printf_filtered ("gdbsim_load: prog \"%s\"\n", prog
);
400 /* FIXME: We will print two messages on error.
401 Need error to either not print anything if passed NULL or need
402 another routine that doesn't take any arguments. */
403 if (sim_load (gdbsim_desc
, prog
, NULL
, fromtty
) == SIM_RC_FAIL
)
404 error ("unable to load program");
406 /* FIXME: If a load command should reset the targets registers then
407 a call to sim_create_inferior() should go here. */
413 /* Start an inferior process and set inferior_pid to its pid.
414 EXEC_FILE is the file to run.
415 ARGS is a string containing the arguments to the program.
416 ENV is the environment vector to pass. Errors reported with error().
417 On VxWorks and various standalone systems, we ignore exec_file. */
418 /* This is called not only when we first attach, but also when the
419 user types "run" after having attached. */
422 gdbsim_create_inferior (exec_file
, args
, env
)
428 char *arg_buf
, **argv
;
430 if (exec_file
== 0 || exec_bfd
== 0)
431 warning ("No executable file specified.");
433 warning ("No program loaded.");
436 printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
437 (exec_file
? exec_file
: "(NULL)"),
441 remove_breakpoints ();
442 init_wait_for_inferior ();
444 if (exec_file
!= NULL
)
446 len
= strlen (exec_file
) + 1 + strlen (args
) + 1 + /*slop */ 10;
447 arg_buf
= (char *) alloca (len
);
449 strcat (arg_buf
, exec_file
);
450 strcat (arg_buf
, " ");
451 strcat (arg_buf
, args
);
452 argv
= buildargv (arg_buf
);
453 make_cleanup_freeargv (argv
);
457 sim_create_inferior (gdbsim_desc
, exec_bfd
, argv
, env
);
460 insert_breakpoints (); /* Needed to get correct instruction in cache */
462 clear_proceed_status ();
464 /* NB: Entry point already set by sim_create_inferior. */
465 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
468 /* The open routine takes the rest of the parameters from the command,
469 and (if successful) pushes a new target onto the stack.
470 Targets should supply this routine, if only to provide an error message. */
471 /* Called when selecting the simulator. EG: (gdb) target sim name. */
474 gdbsim_open (args
, from_tty
)
483 printf_filtered ("gdbsim_open: args \"%s\"\n", args
? args
: "(null)");
485 /* Remove current simulator if one exists. Only do this if the simulator
486 has been opened because sim_close requires it.
487 This is important because the call to push_target below will cause
488 sim_close to be called if the simulator is already open, but push_target
489 is called after sim_open! We can't move the call to push_target before
490 the call to sim_open because sim_open may invoke `error'. */
491 if (gdbsim_desc
!= NULL
)
492 unpush_target (&gdbsim_ops
);
494 len
= (7 + 1 /* gdbsim */
495 + strlen (" -E little")
496 + strlen (" --architecture=xxxxxxxxxx")
497 + (args
? strlen (args
) : 0)
499 arg_buf
= (char *) alloca (len
);
500 strcpy (arg_buf
, "gdbsim"); /* 7 */
501 /* Specify the byte order for the target when it is both selectable
502 and explicitly specified by the user (not auto detected). */
503 if (TARGET_BYTE_ORDER_SELECTABLE_P
504 && !TARGET_BYTE_ORDER_AUTO
)
506 switch (TARGET_BYTE_ORDER
)
509 strcat (arg_buf
, " -E big");
512 strcat (arg_buf
, " -E little");
515 internal_error ("Value of TARGET_BYTE_ORDER unknown");
518 /* Specify the architecture of the target when it has been
519 explicitly specified */
520 if (!TARGET_ARCHITECTURE_AUTO
)
522 strcat (arg_buf
, " --architecture=");
523 strcat (arg_buf
, TARGET_ARCHITECTURE
->printable_name
);
525 /* finally, any explicit args */
528 strcat (arg_buf
, " "); /* 1 */
529 strcat (arg_buf
, args
);
531 argv
= buildargv (arg_buf
);
533 error ("Insufficient memory available to allocate simulator arg list.");
534 make_cleanup_freeargv (argv
);
537 gdbsim_desc
= sim_open (SIM_OPEN_DEBUG
, &gdb_callback
, exec_bfd
, argv
);
539 if (gdbsim_desc
== 0)
540 error ("unable to create simulator instance");
542 push_target (&gdbsim_ops
);
543 target_fetch_registers (-1);
544 printf_filtered ("Connected to the simulator.\n");
547 /* Does whatever cleanup is required for a target that we are no longer
548 going to be calling. Argument says whether we are quitting gdb and
549 should not get hung in case of errors, or whether we want a clean
550 termination even if it takes a while. This routine is automatically
551 always called just before a routine is popped off the target stack.
552 Closing file descriptors and freeing memory are typical things it should
554 /* Close out all files and local state before this target loses control. */
557 gdbsim_close (quitting
)
561 printf_filtered ("gdbsim_close: quitting %d\n", quitting
);
565 if (gdbsim_desc
!= NULL
)
567 sim_close (gdbsim_desc
, quitting
);
574 /* Takes a program previously attached to and detaches it.
575 The program may resume execution (some targets do, some don't) and will
576 no longer stop on signals, etc. We better not have left any breakpoints
577 in the program or it'll die when it hits one. ARGS is arguments
578 typed by the user (e.g. a signal to send the process). FROM_TTY
579 says whether to be verbose or not. */
580 /* Terminate the open connection to the remote debugger.
581 Use this when you want to detach and do something else with your gdb. */
584 gdbsim_detach (args
, from_tty
)
589 printf_filtered ("gdbsim_detach: args \"%s\"\n", args
);
591 pop_target (); /* calls gdbsim_close to do the real work */
593 printf_filtered ("Ending simulator %s debugging\n", target_shortname
);
596 /* Resume execution of the target process. STEP says whether to single-step
597 or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
598 to the target, or zero for no signal. */
600 static enum target_signal resume_siggnal
;
601 static int resume_step
;
604 gdbsim_resume (pid
, step
, siggnal
)
606 enum target_signal siggnal
;
608 if (inferior_pid
!= 42)
609 error ("The program is not being run.");
612 printf_filtered ("gdbsim_resume: step %d, signal %d\n", step
, siggnal
);
614 resume_siggnal
= siggnal
;
618 /* Notify the simulator of an asynchronous request to stop.
620 The simulator shall ensure that the stop request is eventually
621 delivered to the simulator. If the call is made while the
622 simulator is not running then the stop request is processed when
623 the simulator is next resumed.
625 For simulators that do not support this operation, just abort */
630 if (!sim_stop (gdbsim_desc
))
636 /* GDB version of os_poll_quit callback.
637 Taken from gdb/util.c - should be in a library */
643 if (ui_loop_hook
!= NULL
)
647 if (quit_flag
) /* gdb's idea of quit */
649 quit_flag
= 0; /* we've stolen it */
652 else if (immediate_quit
)
659 /* Wait for inferior process to do something. Return pid of child,
660 or -1 in case of error; store status through argument pointer STATUS,
661 just as `wait' would. */
664 gdbsim_cntrl_c (signo
)
671 gdbsim_wait (pid
, status
)
673 struct target_waitstatus
*status
;
675 static RETSIGTYPE (*prev_sigint
) ();
677 enum sim_stop reason
= sim_running
;
680 printf_filtered ("gdbsim_wait\n");
682 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
684 struct sigaction sa
, osa
;
685 sa
.sa_handler
= gdbsim_cntrl_c
;
686 sigemptyset (&sa
.sa_mask
);
688 sigaction (SIGINT
, &sa
, &osa
);
689 prev_sigint
= osa
.sa_handler
;
692 prev_sigint
= signal (SIGINT
, gdbsim_cntrl_c
);
694 sim_resume (gdbsim_desc
, resume_step
,
695 target_signal_to_host (resume_siggnal
));
696 signal (SIGINT
, prev_sigint
);
699 sim_stop_reason (gdbsim_desc
, &reason
, &sigrc
);
704 status
->kind
= TARGET_WAITKIND_EXITED
;
705 status
->value
.integer
= sigrc
;
716 status
->kind
= TARGET_WAITKIND_STOPPED
;
717 /* The signal in sigrc is a host signal. That probably
719 status
->value
.sig
= target_signal_from_host (sigrc
);
724 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
725 /* The signal in sigrc is a host signal. That probably
727 status
->value
.sig
= target_signal_from_host (sigrc
);
731 /* FIXME: Is this correct? */
738 /* Get ready to modify the registers array. On machines which store
739 individual registers, this doesn't need to do anything. On machines
740 which store all the registers in one fell swoop, this makes sure
741 that registers contains all the registers from the program being
745 gdbsim_prepare_to_store ()
747 /* Do nothing, since we can store individual regs */
751 gdbsim_xfer_inferior_memory (memaddr
, myaddr
, len
, write
, target
)
756 struct target_ops
*target
; /* ignored */
759 error ("No program loaded.");
763 /* FIXME: Send to something other than STDOUT? */
764 printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x");
765 gdb_print_host_address (myaddr
, gdb_stdout
);
766 printf_filtered (", memaddr 0x%s, len %d, write %d\n",
767 paddr_nz (memaddr
), len
, write
);
768 if (sr_get_debug () && write
)
769 dump_mem (myaddr
, len
);
774 len
= sim_write (gdbsim_desc
, memaddr
, myaddr
, len
);
778 len
= sim_read (gdbsim_desc
, memaddr
, myaddr
, len
);
779 if (sr_get_debug () && len
> 0)
780 dump_mem (myaddr
, len
);
786 gdbsim_files_info (target
)
787 struct target_ops
*target
;
789 char *file
= "nothing";
792 file
= bfd_get_filename (exec_bfd
);
795 printf_filtered ("gdbsim_files_info: file \"%s\"\n", file
);
799 printf_filtered ("\tAttached to %s running program %s\n",
800 target_shortname
, file
);
801 sim_info (gdbsim_desc
, 0);
805 /* Clear the simulator's notion of what the break points are. */
808 gdbsim_mourn_inferior ()
811 printf_filtered ("gdbsim_mourn_inferior:\n");
813 remove_breakpoints ();
814 generic_mourn_inferior ();
818 gdbsim_insert_breakpoint (addr
, contents_cache
)
820 char *contents_cache
;
822 #ifdef SIM_HAS_BREAKPOINTS
825 retcode
= sim_set_breakpoint (gdbsim_desc
, addr
);
831 case SIM_RC_INSUFFICIENT_RESOURCES
:
837 return memory_insert_breakpoint (addr
, contents_cache
);
842 gdbsim_remove_breakpoint (addr
, contents_cache
)
844 char *contents_cache
;
846 #ifdef SIM_HAS_BREAKPOINTS
849 retcode
= sim_clear_breakpoint (gdbsim_desc
, addr
);
854 case SIM_RC_UNKNOWN_BREAKPOINT
:
856 case SIM_RC_INSUFFICIENT_RESOURCES
:
862 return memory_remove_breakpoint (addr
, contents_cache
);
866 /* Pass the command argument through to the simulator verbatim. The
867 simulator must do any command interpretation work. */
870 simulator_command (args
, from_tty
)
874 if (gdbsim_desc
== NULL
)
877 /* PREVIOUSLY: The user may give a command before the simulator
878 is opened. [...] (??? assuming of course one wishes to
879 continue to allow commands to be sent to unopened simulators,
880 which isn't entirely unreasonable). */
882 /* The simulator is a builtin abstraction of a remote target.
883 Consistent with that model, access to the simulator, via sim
884 commands, is restricted to the period when the channel to the
885 simulator is open. */
887 error ("Not connected to the simulator target");
890 sim_do_command (gdbsim_desc
, args
);
892 /* Invalidate the register cache, in case the simulator command does
894 registers_changed ();
897 /* Define the target subroutine names */
899 struct target_ops gdbsim_ops
;
902 init_gdbsim_ops (void)
904 gdbsim_ops
.to_shortname
= "sim";
905 gdbsim_ops
.to_longname
= "simulator";
906 gdbsim_ops
.to_doc
= "Use the compiled-in simulator.";
907 gdbsim_ops
.to_open
= gdbsim_open
;
908 gdbsim_ops
.to_close
= gdbsim_close
;
909 gdbsim_ops
.to_attach
= NULL
;
910 gdbsim_ops
.to_post_attach
= NULL
;
911 gdbsim_ops
.to_require_attach
= NULL
;
912 gdbsim_ops
.to_detach
= gdbsim_detach
;
913 gdbsim_ops
.to_require_detach
= NULL
;
914 gdbsim_ops
.to_resume
= gdbsim_resume
;
915 gdbsim_ops
.to_wait
= gdbsim_wait
;
916 gdbsim_ops
.to_post_wait
= NULL
;
917 gdbsim_ops
.to_fetch_registers
= gdbsim_fetch_register
;
918 gdbsim_ops
.to_store_registers
= gdbsim_store_register
;
919 gdbsim_ops
.to_prepare_to_store
= gdbsim_prepare_to_store
;
920 gdbsim_ops
.to_xfer_memory
= gdbsim_xfer_inferior_memory
;
921 gdbsim_ops
.to_files_info
= gdbsim_files_info
;
922 gdbsim_ops
.to_insert_breakpoint
= gdbsim_insert_breakpoint
;
923 gdbsim_ops
.to_remove_breakpoint
= gdbsim_remove_breakpoint
;
924 gdbsim_ops
.to_terminal_init
= NULL
;
925 gdbsim_ops
.to_terminal_inferior
= NULL
;
926 gdbsim_ops
.to_terminal_ours_for_output
= NULL
;
927 gdbsim_ops
.to_terminal_ours
= NULL
;
928 gdbsim_ops
.to_terminal_info
= NULL
;
929 gdbsim_ops
.to_kill
= gdbsim_kill
;
930 gdbsim_ops
.to_load
= gdbsim_load
;
931 gdbsim_ops
.to_lookup_symbol
= NULL
;
932 gdbsim_ops
.to_create_inferior
= gdbsim_create_inferior
;
933 gdbsim_ops
.to_post_startup_inferior
= NULL
;
934 gdbsim_ops
.to_acknowledge_created_inferior
= NULL
;
935 gdbsim_ops
.to_clone_and_follow_inferior
= NULL
;
936 gdbsim_ops
.to_post_follow_inferior_by_clone
= NULL
;
937 gdbsim_ops
.to_insert_fork_catchpoint
= NULL
;
938 gdbsim_ops
.to_remove_fork_catchpoint
= NULL
;
939 gdbsim_ops
.to_insert_vfork_catchpoint
= NULL
;
940 gdbsim_ops
.to_remove_vfork_catchpoint
= NULL
;
941 gdbsim_ops
.to_has_forked
= NULL
;
942 gdbsim_ops
.to_has_vforked
= NULL
;
943 gdbsim_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
944 gdbsim_ops
.to_post_follow_vfork
= NULL
;
945 gdbsim_ops
.to_insert_exec_catchpoint
= NULL
;
946 gdbsim_ops
.to_remove_exec_catchpoint
= NULL
;
947 gdbsim_ops
.to_has_execd
= NULL
;
948 gdbsim_ops
.to_reported_exec_events_per_exec_call
= NULL
;
949 gdbsim_ops
.to_has_exited
= NULL
;
950 gdbsim_ops
.to_mourn_inferior
= gdbsim_mourn_inferior
;
951 gdbsim_ops
.to_can_run
= 0;
952 gdbsim_ops
.to_notice_signals
= 0;
953 gdbsim_ops
.to_thread_alive
= 0;
954 gdbsim_ops
.to_stop
= gdbsim_stop
;
955 gdbsim_ops
.to_pid_to_exec_file
= NULL
;
956 gdbsim_ops
.to_core_file_to_sym_file
= NULL
;
957 gdbsim_ops
.to_stratum
= process_stratum
;
958 gdbsim_ops
.DONT_USE
= NULL
;
959 gdbsim_ops
.to_has_all_memory
= 1;
960 gdbsim_ops
.to_has_memory
= 1;
961 gdbsim_ops
.to_has_stack
= 1;
962 gdbsim_ops
.to_has_registers
= 1;
963 gdbsim_ops
.to_has_execution
= 1;
964 gdbsim_ops
.to_sections
= NULL
;
965 gdbsim_ops
.to_sections_end
= NULL
;
966 gdbsim_ops
.to_magic
= OPS_MAGIC
;
968 #ifdef TARGET_REDEFINE_DEFAULT_OPS
969 TARGET_REDEFINE_DEFAULT_OPS (&gdbsim_ops
);
974 _initialize_remote_sim ()
977 add_target (&gdbsim_ops
);
979 add_com ("sim <command>", class_obscure
, simulator_command
,
980 "Send a command to the simulator.");