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%x", 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. */
248 #ifdef ANSI_PROTOTYPES
249 gdb_os_printf_filtered (host_callback * p, const char *format,...)
251 gdb_os_printf_filtered (p, va_alist)
257 #ifdef ANSI_PROTOTYPES
258 va_start (args, format);
263 format = va_arg (args, char *);
266 vfprintf_filtered (gdb_stdout, format, args);
271 /* GDB version of error vprintf_filtered. */
275 #ifdef ANSI_PROTOTYPES
276 gdb_os_vprintf_filtered (host_callback * p, const char *format, va_list ap)
278 gdb_os_vprintf_filtered (p, format, ap)
284 vfprintf_filtered (gdb_stdout, format, ap);
287 /* GDB version of error evprintf_filtered. */
291 #ifdef ANSI_PROTOTYPES
292 gdb_os_evprintf_filtered (host_callback * p, const char *format, va_list ap)
294 gdb_os_evprintf_filtered (p, format, ap)
300 vfprintf_filtered (gdb_stderr, format, ap);
303 /* GDB version of error callback. */
307 #ifdef ANSI_PROTOTYPES
308 gdb_os_error (host_callback * p, const char *format,...)
310 gdb_os_error (p, va_alist)
320 #ifdef ANSI_PROTOTYPES
321 va_start (args, format);
326 format = va_arg (args, char *);
330 vfprintf_filtered (gdb_stderr, format, args);
331 fprintf_filtered (gdb_stderr, "\n");
333 return_to_top_level (RETURN_ERROR);
338 gdbsim_fetch_register (regno)
341 static int warn_user = 1;
344 for (regno = 0; regno < NUM_REGS; regno++)
345 gdbsim_fetch_register (regno);
347 else if (REGISTER_NAME (regno) != NULL && *REGISTER_NAME (regno) != '\0')
349 char buf[MAX_REGISTER_RAW_SIZE];
350 int nr_bytes = sim_fetch_register (gdbsim_desc, regno, buf, REGISTER_RAW_SIZE (regno));
352 /* register not applicable, supply zero's */
353 memset (buf, 0, MAX_REGISTER_RAW_SIZE);
354 else if (nr_bytes > 0 && nr_bytes != REGISTER_RAW_SIZE (regno)
357 printf_unfiltered ("Size of register %s (%d) incorrect (%d instead of %d))",
358 REGISTER_NAME (regno), regno,
359 nr_bytes, REGISTER_RAW_SIZE (regno));
362 supply_register (regno, buf);
365 printf_filtered ("gdbsim_fetch_register: %d", regno);
366 /* FIXME: We could print something more intelligible. */
367 dump_mem (buf, REGISTER_RAW_SIZE (regno));
374 gdbsim_store_register (regno)
379 for (regno = 0; regno < NUM_REGS; regno++)
380 gdbsim_store_register (regno);
382 else if (REGISTER_NAME (regno) != NULL && *REGISTER_NAME (regno) != '\0')
384 char tmp[MAX_REGISTER_RAW_SIZE];
386 read_register_gen (regno, tmp);
387 nr_bytes = sim_store_register (gdbsim_desc, regno, tmp, REGISTER_RAW_SIZE (regno));
388 if (nr_bytes > 0 && nr_bytes != REGISTER_RAW_SIZE (regno))
389 fatal ("Register size different to expected");
392 printf_filtered ("gdbsim_store_register: %d", regno);
393 /* FIXME: We could print something more intelligible. */
394 dump_mem (tmp, REGISTER_RAW_SIZE (regno));
399 /* Kill the running program. This may involve closing any open files
400 and releasing other resources acquired by the simulated program. */
406 printf_filtered ("gdbsim_kill\n");
408 /* There is no need to `kill' running simulator - the simulator is
413 /* Load an executable file into the target process. This is expected to
414 not only bring new code into the target process, but also to update
415 GDB's symbol tables to match. */
418 gdbsim_load (prog, fromtty)
423 printf_filtered ("gdbsim_load: prog \"%s\"\n", prog);
427 /* FIXME: We will print two messages on error.
428 Need error to either not print anything if passed NULL or need
429 another routine that doesn't take any arguments. */
430 if (sim_load (gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL)
431 error ("unable to load program");
433 /* FIXME: If a load command should reset the targets registers then
434 a call to sim_create_inferior() should go here. */
440 /* Start an inferior process and set inferior_pid to its pid.
441 EXEC_FILE is the file to run.
442 ARGS is a string containing the arguments to the program.
443 ENV is the environment vector to pass. Errors reported with error().
444 On VxWorks and various standalone systems, we ignore exec_file. */
445 /* This is called not only when we first attach, but also when the
446 user types "run" after having attached. */
449 gdbsim_create_inferior (exec_file, args, env)
455 char *arg_buf, **argv;
457 if (exec_file == 0 || exec_bfd == 0)
458 warning ("No executable file specified.");
460 warning ("No program loaded.");
463 printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
464 (exec_file ? exec_file : "(NULL)"),
468 remove_breakpoints ();
469 init_wait_for_inferior ();
471 if (exec_file != NULL)
473 len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop */ 10;
474 arg_buf = (char *) alloca (len);
476 strcat (arg_buf, exec_file);
477 strcat (arg_buf, " ");
478 strcat (arg_buf, args);
479 argv = buildargv (arg_buf);
480 make_cleanup_freeargv (argv);
484 sim_create_inferior (gdbsim_desc, exec_bfd, argv, env);
487 insert_breakpoints (); /* Needed to get correct instruction in cache */
489 clear_proceed_status ();
491 /* NB: Entry point already set by sim_create_inferior. */
492 proceed ((CORE_ADDR) - 1, TARGET_SIGNAL_DEFAULT, 0);
495 /* The open routine takes the rest of the parameters from the command,
496 and (if successful) pushes a new target onto the stack.
497 Targets should supply this routine, if only to provide an error message. */
498 /* Called when selecting the simulator. EG: (gdb) target sim name. */
501 gdbsim_open (args, from_tty)
510 printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
512 /* Remove current simulator if one exists. Only do this if the simulator
513 has been opened because sim_close requires it.
514 This is important because the call to push_target below will cause
515 sim_close to be called if the simulator is already open, but push_target
516 is called after sim_open! We can't move the call to push_target before
517 the call to sim_open because sim_open may invoke `error'. */
518 if (gdbsim_desc != NULL)
519 unpush_target (&gdbsim_ops);
521 len = (7 + 1 /* gdbsim */
522 + strlen (" -E little")
523 + strlen (" --architecture=xxxxxxxxxx")
524 + (args ? strlen (args) : 0)
526 arg_buf = (char *) alloca (len);
527 strcpy (arg_buf, "gdbsim"); /* 7 */
528 /* Specify the byte order for the target when it is both selectable
529 and explicitly specified by the user (not auto detected). */
530 if (TARGET_BYTE_ORDER_SELECTABLE_P
531 && !TARGET_BYTE_ORDER_AUTO)
533 switch (TARGET_BYTE_ORDER)
536 strcat (arg_buf, " -E big");
539 strcat (arg_buf, " -E little");
542 fatal ("Value of TARGET_BYTE_ORDER unknown");
545 /* Specify the architecture of the target when it has been
546 explicitly specified */
547 if (!TARGET_ARCHITECTURE_AUTO)
549 strcat (arg_buf, " --architecture=");
550 strcat (arg_buf, TARGET_ARCHITECTURE->printable_name);
552 /* finally, any explicit args */
555 strcat (arg_buf, " "); /* 1 */
556 strcat (arg_buf, args);
558 argv = buildargv (arg_buf);
560 error ("Insufficient memory available to allocate simulator arg list.");
561 make_cleanup_freeargv (argv);
564 gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, argv);
566 if (gdbsim_desc == 0)
567 error ("unable to create simulator instance");
569 push_target (&gdbsim_ops);
570 target_fetch_registers (-1);
571 printf_filtered ("Connected to the simulator.\n");
574 /* Does whatever cleanup is required for a target that we are no longer
575 going to be calling. Argument says whether we are quitting gdb and
576 should not get hung in case of errors, or whether we want a clean
577 termination even if it takes a while. This routine is automatically
578 always called just before a routine is popped off the target stack.
579 Closing file descriptors and freeing memory are typical things it should
581 /* Close out all files and local state before this target loses control. */
584 gdbsim_close (quitting)
588 printf_filtered ("gdbsim_close: quitting %d\n", quitting);
592 if (gdbsim_desc != NULL)
594 sim_close (gdbsim_desc, quitting);
601 /* Takes a program previously attached to and detaches it.
602 The program may resume execution (some targets do, some don't) and will
603 no longer stop on signals, etc. We better not have left any breakpoints
604 in the program or it'll die when it hits one. ARGS is arguments
605 typed by the user (e.g. a signal to send the process). FROM_TTY
606 says whether to be verbose or not. */
607 /* Terminate the open connection to the remote debugger.
608 Use this when you want to detach and do something else with your gdb. */
611 gdbsim_detach (args, from_tty)
616 printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
618 pop_target (); /* calls gdbsim_close to do the real work */
620 printf_filtered ("Ending simulator %s debugging\n", target_shortname);
623 /* Resume execution of the target process. STEP says whether to single-step
624 or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
625 to the target, or zero for no signal. */
627 static enum target_signal resume_siggnal;
628 static int resume_step;
631 gdbsim_resume (pid, step, siggnal)
633 enum target_signal siggnal;
635 if (inferior_pid != 42)
636 error ("The program is not being run.");
639 printf_filtered ("gdbsim_resume: step %d, signal %d\n", step, siggnal);
641 resume_siggnal = siggnal;
645 /* Notify the simulator of an asynchronous request to stop.
647 The simulator shall ensure that the stop request is eventually
648 delivered to the simulator. If the call is made while the
649 simulator is not running then the stop request is processed when
650 the simulator is next resumed.
652 For simulators that do not support this operation, just abort */
657 if (!sim_stop (gdbsim_desc))
663 /* GDB version of os_poll_quit callback.
664 Taken from gdb/util.c - should be in a library */
670 if (ui_loop_hook != NULL)
674 if (quit_flag) /* gdb's idea of quit */
676 quit_flag = 0; /* we've stolen it */
679 else if (immediate_quit)
686 /* Wait for inferior process to do something. Return pid of child,
687 or -1 in case of error; store status through argument pointer STATUS,
688 just as `wait' would. */
691 gdbsim_cntrl_c (signo)
698 gdbsim_wait (pid, status)
700 struct target_waitstatus *status;
702 static RETSIGTYPE (*prev_sigint) ();
704 enum sim_stop reason = sim_running;
707 printf_filtered ("gdbsim_wait\n");
709 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
711 struct sigaction sa, osa;
712 sa.sa_handler = gdbsim_cntrl_c;
713 sigemptyset (&sa.sa_mask);
715 sigaction (SIGINT, &sa, &osa);
716 prev_sigint = osa.sa_handler;
719 prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
721 sim_resume (gdbsim_desc, resume_step,
722 target_signal_to_host (resume_siggnal));
723 signal (SIGINT, prev_sigint);
726 sim_stop_reason (gdbsim_desc, &reason, &sigrc);
731 status->kind = TARGET_WAITKIND_EXITED;
732 status->value.integer = sigrc;
743 status->kind = TARGET_WAITKIND_STOPPED;
744 /* The signal in sigrc is a host signal. That probably
746 status->value.sig = target_signal_from_host (sigrc);
751 status->kind = TARGET_WAITKIND_SIGNALLED;
752 /* The signal in sigrc is a host signal. That probably
754 status->value.sig = target_signal_from_host (sigrc);
758 /* FIXME: Is this correct? */
765 /* Get ready to modify the registers array. On machines which store
766 individual registers, this doesn't need to do anything. On machines
767 which store all the registers in one fell swoop, this makes sure
768 that registers contains all the registers from the program being
772 gdbsim_prepare_to_store ()
774 /* Do nothing, since we can store individual regs */
778 gdbsim_xfer_inferior_memory (memaddr, myaddr, len, write, target)
783 struct target_ops *target; /* ignored */
786 error ("No program loaded.");
790 printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x%x, memaddr 0x%x, len %d, write %d\n",
791 myaddr, memaddr, len, write);
792 if (sr_get_debug () && write)
793 dump_mem (myaddr, len);
798 len = sim_write (gdbsim_desc, memaddr, myaddr, len);
802 len = sim_read (gdbsim_desc, memaddr, myaddr, len);
803 if (sr_get_debug () && len > 0)
804 dump_mem (myaddr, len);
810 gdbsim_files_info (target)
811 struct target_ops *target;
813 char *file = "nothing";
816 file = bfd_get_filename (exec_bfd);
819 printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
823 printf_filtered ("\tAttached to %s running program %s\n",
824 target_shortname, file);
825 sim_info (gdbsim_desc, 0);
829 /* Clear the simulator's notion of what the break points are. */
832 gdbsim_mourn_inferior ()
835 printf_filtered ("gdbsim_mourn_inferior:\n");
837 remove_breakpoints ();
838 generic_mourn_inferior ();
842 gdbsim_insert_breakpoint (addr, contents_cache)
844 char *contents_cache;
846 #ifdef SIM_HAS_BREAKPOINTS
849 retcode = sim_set_breakpoint (gdbsim_desc, addr);
855 case SIM_RC_INSUFFICIENT_RESOURCES:
861 return memory_insert_breakpoint (addr, contents_cache);
866 gdbsim_remove_breakpoint (addr, contents_cache)
868 char *contents_cache;
870 #ifdef SIM_HAS_BREAKPOINTS
873 retcode = sim_clear_breakpoint (gdbsim_desc, addr);
878 case SIM_RC_UNKNOWN_BREAKPOINT:
880 case SIM_RC_INSUFFICIENT_RESOURCES:
886 return memory_remove_breakpoint (addr, contents_cache);
890 /* Pass the command argument through to the simulator verbatim. The
891 simulator must do any command interpretation work. */
894 simulator_command (args, from_tty)
898 if (gdbsim_desc == NULL)
901 /* PREVIOUSLY: The user may give a command before the simulator
902 is opened. [...] (??? assuming of course one wishes to
903 continue to allow commands to be sent to unopened simulators,
904 which isn't entirely unreasonable). */
906 /* The simulator is a builtin abstraction of a remote target.
907 Consistent with that model, access to the simulator, via sim
908 commands, is restricted to the period when the channel to the
909 simulator is open. */
911 error ("Not connected to the simulator target");
914 sim_do_command (gdbsim_desc, args);
916 /* Invalidate the register cache, in case the simulator command does
918 registers_changed ();
921 /* Define the target subroutine names */
923 struct target_ops gdbsim_ops;
926 init_gdbsim_ops (void)
928 gdbsim_ops.to_shortname = "sim";
929 gdbsim_ops.to_longname = "simulator";
930 gdbsim_ops.to_doc = "Use the compiled-in simulator.";
931 gdbsim_ops.to_open = gdbsim_open;
932 gdbsim_ops.to_close = gdbsim_close;
933 gdbsim_ops.to_attach = NULL;
934 gdbsim_ops.to_post_attach = NULL;
935 gdbsim_ops.to_require_attach = NULL;
936 gdbsim_ops.to_detach = gdbsim_detach;
937 gdbsim_ops.to_require_detach = NULL;
938 gdbsim_ops.to_resume = gdbsim_resume;
939 gdbsim_ops.to_wait = gdbsim_wait;
940 gdbsim_ops.to_post_wait = NULL;
941 gdbsim_ops.to_fetch_registers = gdbsim_fetch_register;
942 gdbsim_ops.to_store_registers = gdbsim_store_register;
943 gdbsim_ops.to_prepare_to_store = gdbsim_prepare_to_store;
944 gdbsim_ops.to_xfer_memory = gdbsim_xfer_inferior_memory;
945 gdbsim_ops.to_files_info = gdbsim_files_info;
946 gdbsim_ops.to_insert_breakpoint = gdbsim_insert_breakpoint;
947 gdbsim_ops.to_remove_breakpoint = gdbsim_remove_breakpoint;
948 gdbsim_ops.to_terminal_init = NULL;
949 gdbsim_ops.to_terminal_inferior = NULL;
950 gdbsim_ops.to_terminal_ours_for_output = NULL;
951 gdbsim_ops.to_terminal_ours = NULL;
952 gdbsim_ops.to_terminal_info = NULL;
953 gdbsim_ops.to_kill = gdbsim_kill;
954 gdbsim_ops.to_load = gdbsim_load;
955 gdbsim_ops.to_lookup_symbol = NULL;
956 gdbsim_ops.to_create_inferior = gdbsim_create_inferior;
957 gdbsim_ops.to_post_startup_inferior = NULL;
958 gdbsim_ops.to_acknowledge_created_inferior = NULL;
959 gdbsim_ops.to_clone_and_follow_inferior = NULL;
960 gdbsim_ops.to_post_follow_inferior_by_clone = NULL;
961 gdbsim_ops.to_insert_fork_catchpoint = NULL;
962 gdbsim_ops.to_remove_fork_catchpoint = NULL;
963 gdbsim_ops.to_insert_vfork_catchpoint = NULL;
964 gdbsim_ops.to_remove_vfork_catchpoint = NULL;
965 gdbsim_ops.to_has_forked = NULL;
966 gdbsim_ops.to_has_vforked = NULL;
967 gdbsim_ops.to_can_follow_vfork_prior_to_exec = NULL;
968 gdbsim_ops.to_post_follow_vfork = NULL;
969 gdbsim_ops.to_insert_exec_catchpoint = NULL;
970 gdbsim_ops.to_remove_exec_catchpoint = NULL;
971 gdbsim_ops.to_has_execd = NULL;
972 gdbsim_ops.to_reported_exec_events_per_exec_call = NULL;
973 gdbsim_ops.to_has_exited = NULL;
974 gdbsim_ops.to_mourn_inferior = gdbsim_mourn_inferior;
975 gdbsim_ops.to_can_run = 0;
976 gdbsim_ops.to_notice_signals = 0;
977 gdbsim_ops.to_thread_alive = 0;
978 gdbsim_ops.to_stop = gdbsim_stop;
979 gdbsim_ops.to_pid_to_exec_file = NULL;
980 gdbsim_ops.to_core_file_to_sym_file = NULL;
981 gdbsim_ops.to_stratum = process_stratum;
982 gdbsim_ops.DONT_USE = NULL;
983 gdbsim_ops.to_has_all_memory = 1;
984 gdbsim_ops.to_has_memory = 1;
985 gdbsim_ops.to_has_stack = 1;
986 gdbsim_ops.to_has_registers = 1;
987 gdbsim_ops.to_has_execution = 1;
988 gdbsim_ops.to_sections = NULL;
989 gdbsim_ops.to_sections_end = NULL;
990 gdbsim_ops.to_magic = OPS_MAGIC;
992 #ifdef TARGET_REDEFINE_DEFAULT_OPS
993 TARGET_REDEFINE_DEFAULT_OPS (&gdbsim_ops);
998 _initialize_remote_sim ()
1001 add_target (&gdbsim_ops);
1003 add_com ("sim <command>", class_obscure, simulator_command,
1004 "Send a command to the simulator.");