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. */
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);
294 gdbsim_fetch_register (regno)
297 static int warn_user = 1;
300 for (regno = 0; regno < NUM_REGS; regno++)
301 gdbsim_fetch_register (regno);
303 else if (REGISTER_NAME (regno) != NULL && *REGISTER_NAME (regno) != '\0')
305 char buf[MAX_REGISTER_RAW_SIZE];
306 int nr_bytes = sim_fetch_register (gdbsim_desc, regno, buf, REGISTER_RAW_SIZE (regno));
308 /* register not applicable, supply zero's */
309 memset (buf, 0, MAX_REGISTER_RAW_SIZE);
310 else if (nr_bytes > 0 && nr_bytes != REGISTER_RAW_SIZE (regno)
313 printf_unfiltered ("Size of register %s (%d) incorrect (%d instead of %d))",
314 REGISTER_NAME (regno), regno,
315 nr_bytes, REGISTER_RAW_SIZE (regno));
318 supply_register (regno, buf);
321 printf_filtered ("gdbsim_fetch_register: %d", regno);
322 /* FIXME: We could print something more intelligible. */
323 dump_mem (buf, REGISTER_RAW_SIZE (regno));
330 gdbsim_store_register (regno)
335 for (regno = 0; regno < NUM_REGS; regno++)
336 gdbsim_store_register (regno);
338 else if (REGISTER_NAME (regno) != NULL && *REGISTER_NAME (regno) != '\0')
340 char tmp[MAX_REGISTER_RAW_SIZE];
342 read_register_gen (regno, tmp);
343 nr_bytes = sim_store_register (gdbsim_desc, regno, tmp, REGISTER_RAW_SIZE (regno));
344 if (nr_bytes > 0 && nr_bytes != REGISTER_RAW_SIZE (regno))
345 internal_error ("Register size different to expected");
348 printf_filtered ("gdbsim_store_register: %d", regno);
349 /* FIXME: We could print something more intelligible. */
350 dump_mem (tmp, REGISTER_RAW_SIZE (regno));
355 /* Kill the running program. This may involve closing any open files
356 and releasing other resources acquired by the simulated program. */
362 printf_filtered ("gdbsim_kill\n");
364 /* There is no need to `kill' running simulator - the simulator is
369 /* Load an executable file into the target process. This is expected to
370 not only bring new code into the target process, but also to update
371 GDB's symbol tables to match. */
374 gdbsim_load (prog, fromtty)
379 printf_filtered ("gdbsim_load: prog \"%s\"\n", prog);
383 /* FIXME: We will print two messages on error.
384 Need error to either not print anything if passed NULL or need
385 another routine that doesn't take any arguments. */
386 if (sim_load (gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL)
387 error ("unable to load program");
389 /* FIXME: If a load command should reset the targets registers then
390 a call to sim_create_inferior() should go here. */
396 /* Start an inferior process and set inferior_pid to its pid.
397 EXEC_FILE is the file to run.
398 ARGS is a string containing the arguments to the program.
399 ENV is the environment vector to pass. Errors reported with error().
400 On VxWorks and various standalone systems, we ignore exec_file. */
401 /* This is called not only when we first attach, but also when the
402 user types "run" after having attached. */
405 gdbsim_create_inferior (exec_file, args, env)
411 char *arg_buf, **argv;
413 if (exec_file == 0 || exec_bfd == 0)
414 warning ("No executable file specified.");
416 warning ("No program loaded.");
419 printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
420 (exec_file ? exec_file : "(NULL)"),
424 remove_breakpoints ();
425 init_wait_for_inferior ();
427 if (exec_file != NULL)
429 len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop */ 10;
430 arg_buf = (char *) alloca (len);
432 strcat (arg_buf, exec_file);
433 strcat (arg_buf, " ");
434 strcat (arg_buf, args);
435 argv = buildargv (arg_buf);
436 make_cleanup_freeargv (argv);
440 sim_create_inferior (gdbsim_desc, exec_bfd, argv, env);
443 insert_breakpoints (); /* Needed to get correct instruction in cache */
445 clear_proceed_status ();
447 /* NB: Entry point already set by sim_create_inferior. */
448 proceed ((CORE_ADDR) - 1, TARGET_SIGNAL_DEFAULT, 0);
451 /* The open routine takes the rest of the parameters from the command,
452 and (if successful) pushes a new target onto the stack.
453 Targets should supply this routine, if only to provide an error message. */
454 /* Called when selecting the simulator. EG: (gdb) target sim name. */
457 gdbsim_open (args, from_tty)
466 printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
468 /* Remove current simulator if one exists. Only do this if the simulator
469 has been opened because sim_close requires it.
470 This is important because the call to push_target below will cause
471 sim_close to be called if the simulator is already open, but push_target
472 is called after sim_open! We can't move the call to push_target before
473 the call to sim_open because sim_open may invoke `error'. */
474 if (gdbsim_desc != NULL)
475 unpush_target (&gdbsim_ops);
477 len = (7 + 1 /* gdbsim */
478 + strlen (" -E little")
479 + strlen (" --architecture=xxxxxxxxxx")
480 + (args ? strlen (args) : 0)
482 arg_buf = (char *) alloca (len);
483 strcpy (arg_buf, "gdbsim"); /* 7 */
484 /* Specify the byte order for the target when it is both selectable
485 and explicitly specified by the user (not auto detected). */
486 if (TARGET_BYTE_ORDER_SELECTABLE_P
487 && !TARGET_BYTE_ORDER_AUTO)
489 switch (TARGET_BYTE_ORDER)
492 strcat (arg_buf, " -E big");
495 strcat (arg_buf, " -E little");
498 internal_error ("Value of TARGET_BYTE_ORDER unknown");
501 /* Specify the architecture of the target when it has been
502 explicitly specified */
503 if (!TARGET_ARCHITECTURE_AUTO)
505 strcat (arg_buf, " --architecture=");
506 strcat (arg_buf, TARGET_ARCHITECTURE->printable_name);
508 /* finally, any explicit args */
511 strcat (arg_buf, " "); /* 1 */
512 strcat (arg_buf, args);
514 argv = buildargv (arg_buf);
516 error ("Insufficient memory available to allocate simulator arg list.");
517 make_cleanup_freeargv (argv);
520 gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, argv);
522 if (gdbsim_desc == 0)
523 error ("unable to create simulator instance");
525 push_target (&gdbsim_ops);
526 target_fetch_registers (-1);
527 printf_filtered ("Connected to the simulator.\n");
530 /* Does whatever cleanup is required for a target that we are no longer
531 going to be calling. Argument says whether we are quitting gdb and
532 should not get hung in case of errors, or whether we want a clean
533 termination even if it takes a while. This routine is automatically
534 always called just before a routine is popped off the target stack.
535 Closing file descriptors and freeing memory are typical things it should
537 /* Close out all files and local state before this target loses control. */
540 gdbsim_close (quitting)
544 printf_filtered ("gdbsim_close: quitting %d\n", quitting);
548 if (gdbsim_desc != NULL)
550 sim_close (gdbsim_desc, quitting);
557 /* Takes a program previously attached to and detaches it.
558 The program may resume execution (some targets do, some don't) and will
559 no longer stop on signals, etc. We better not have left any breakpoints
560 in the program or it'll die when it hits one. ARGS is arguments
561 typed by the user (e.g. a signal to send the process). FROM_TTY
562 says whether to be verbose or not. */
563 /* Terminate the open connection to the remote debugger.
564 Use this when you want to detach and do something else with your gdb. */
567 gdbsim_detach (args, from_tty)
572 printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
574 pop_target (); /* calls gdbsim_close to do the real work */
576 printf_filtered ("Ending simulator %s debugging\n", target_shortname);
579 /* Resume execution of the target process. STEP says whether to single-step
580 or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
581 to the target, or zero for no signal. */
583 static enum target_signal resume_siggnal;
584 static int resume_step;
587 gdbsim_resume (pid, step, siggnal)
589 enum target_signal siggnal;
591 if (inferior_pid != 42)
592 error ("The program is not being run.");
595 printf_filtered ("gdbsim_resume: step %d, signal %d\n", step, siggnal);
597 resume_siggnal = siggnal;
601 /* Notify the simulator of an asynchronous request to stop.
603 The simulator shall ensure that the stop request is eventually
604 delivered to the simulator. If the call is made while the
605 simulator is not running then the stop request is processed when
606 the simulator is next resumed.
608 For simulators that do not support this operation, just abort */
613 if (!sim_stop (gdbsim_desc))
619 /* GDB version of os_poll_quit callback.
620 Taken from gdb/util.c - should be in a library */
626 if (ui_loop_hook != NULL)
630 if (quit_flag) /* gdb's idea of quit */
632 quit_flag = 0; /* we've stolen it */
635 else if (immediate_quit)
642 /* Wait for inferior process to do something. Return pid of child,
643 or -1 in case of error; store status through argument pointer STATUS,
644 just as `wait' would. */
647 gdbsim_cntrl_c (signo)
654 gdbsim_wait (pid, status)
656 struct target_waitstatus *status;
658 static RETSIGTYPE (*prev_sigint) ();
660 enum sim_stop reason = sim_running;
663 printf_filtered ("gdbsim_wait\n");
665 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
667 struct sigaction sa, osa;
668 sa.sa_handler = gdbsim_cntrl_c;
669 sigemptyset (&sa.sa_mask);
671 sigaction (SIGINT, &sa, &osa);
672 prev_sigint = osa.sa_handler;
675 prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
677 sim_resume (gdbsim_desc, resume_step,
678 target_signal_to_host (resume_siggnal));
679 signal (SIGINT, prev_sigint);
682 sim_stop_reason (gdbsim_desc, &reason, &sigrc);
687 status->kind = TARGET_WAITKIND_EXITED;
688 status->value.integer = sigrc;
699 status->kind = TARGET_WAITKIND_STOPPED;
700 /* The signal in sigrc is a host signal. That probably
702 status->value.sig = target_signal_from_host (sigrc);
707 status->kind = TARGET_WAITKIND_SIGNALLED;
708 /* The signal in sigrc is a host signal. That probably
710 status->value.sig = target_signal_from_host (sigrc);
714 /* FIXME: Is this correct? */
721 /* Get ready to modify the registers array. On machines which store
722 individual registers, this doesn't need to do anything. On machines
723 which store all the registers in one fell swoop, this makes sure
724 that registers contains all the registers from the program being
728 gdbsim_prepare_to_store ()
730 /* Do nothing, since we can store individual regs */
734 gdbsim_xfer_inferior_memory (memaddr, myaddr, len, write, target)
739 struct target_ops *target; /* ignored */
742 error ("No program loaded.");
746 printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x%x, memaddr 0x%x, len %d, write %d\n",
747 myaddr, memaddr, len, write);
748 if (sr_get_debug () && write)
749 dump_mem (myaddr, len);
754 len = sim_write (gdbsim_desc, memaddr, myaddr, len);
758 len = sim_read (gdbsim_desc, memaddr, myaddr, len);
759 if (sr_get_debug () && len > 0)
760 dump_mem (myaddr, len);
766 gdbsim_files_info (target)
767 struct target_ops *target;
769 char *file = "nothing";
772 file = bfd_get_filename (exec_bfd);
775 printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
779 printf_filtered ("\tAttached to %s running program %s\n",
780 target_shortname, file);
781 sim_info (gdbsim_desc, 0);
785 /* Clear the simulator's notion of what the break points are. */
788 gdbsim_mourn_inferior ()
791 printf_filtered ("gdbsim_mourn_inferior:\n");
793 remove_breakpoints ();
794 generic_mourn_inferior ();
798 gdbsim_insert_breakpoint (addr, contents_cache)
800 char *contents_cache;
802 #ifdef SIM_HAS_BREAKPOINTS
805 retcode = sim_set_breakpoint (gdbsim_desc, addr);
811 case SIM_RC_INSUFFICIENT_RESOURCES:
817 return memory_insert_breakpoint (addr, contents_cache);
822 gdbsim_remove_breakpoint (addr, contents_cache)
824 char *contents_cache;
826 #ifdef SIM_HAS_BREAKPOINTS
829 retcode = sim_clear_breakpoint (gdbsim_desc, addr);
834 case SIM_RC_UNKNOWN_BREAKPOINT:
836 case SIM_RC_INSUFFICIENT_RESOURCES:
842 return memory_remove_breakpoint (addr, contents_cache);
846 /* Pass the command argument through to the simulator verbatim. The
847 simulator must do any command interpretation work. */
850 simulator_command (args, from_tty)
854 if (gdbsim_desc == NULL)
857 /* PREVIOUSLY: The user may give a command before the simulator
858 is opened. [...] (??? assuming of course one wishes to
859 continue to allow commands to be sent to unopened simulators,
860 which isn't entirely unreasonable). */
862 /* The simulator is a builtin abstraction of a remote target.
863 Consistent with that model, access to the simulator, via sim
864 commands, is restricted to the period when the channel to the
865 simulator is open. */
867 error ("Not connected to the simulator target");
870 sim_do_command (gdbsim_desc, args);
872 /* Invalidate the register cache, in case the simulator command does
874 registers_changed ();
877 /* Define the target subroutine names */
879 struct target_ops gdbsim_ops;
882 init_gdbsim_ops (void)
884 gdbsim_ops.to_shortname = "sim";
885 gdbsim_ops.to_longname = "simulator";
886 gdbsim_ops.to_doc = "Use the compiled-in simulator.";
887 gdbsim_ops.to_open = gdbsim_open;
888 gdbsim_ops.to_close = gdbsim_close;
889 gdbsim_ops.to_attach = NULL;
890 gdbsim_ops.to_post_attach = NULL;
891 gdbsim_ops.to_require_attach = NULL;
892 gdbsim_ops.to_detach = gdbsim_detach;
893 gdbsim_ops.to_require_detach = NULL;
894 gdbsim_ops.to_resume = gdbsim_resume;
895 gdbsim_ops.to_wait = gdbsim_wait;
896 gdbsim_ops.to_post_wait = NULL;
897 gdbsim_ops.to_fetch_registers = gdbsim_fetch_register;
898 gdbsim_ops.to_store_registers = gdbsim_store_register;
899 gdbsim_ops.to_prepare_to_store = gdbsim_prepare_to_store;
900 gdbsim_ops.to_xfer_memory = gdbsim_xfer_inferior_memory;
901 gdbsim_ops.to_files_info = gdbsim_files_info;
902 gdbsim_ops.to_insert_breakpoint = gdbsim_insert_breakpoint;
903 gdbsim_ops.to_remove_breakpoint = gdbsim_remove_breakpoint;
904 gdbsim_ops.to_terminal_init = NULL;
905 gdbsim_ops.to_terminal_inferior = NULL;
906 gdbsim_ops.to_terminal_ours_for_output = NULL;
907 gdbsim_ops.to_terminal_ours = NULL;
908 gdbsim_ops.to_terminal_info = NULL;
909 gdbsim_ops.to_kill = gdbsim_kill;
910 gdbsim_ops.to_load = gdbsim_load;
911 gdbsim_ops.to_lookup_symbol = NULL;
912 gdbsim_ops.to_create_inferior = gdbsim_create_inferior;
913 gdbsim_ops.to_post_startup_inferior = NULL;
914 gdbsim_ops.to_acknowledge_created_inferior = NULL;
915 gdbsim_ops.to_clone_and_follow_inferior = NULL;
916 gdbsim_ops.to_post_follow_inferior_by_clone = NULL;
917 gdbsim_ops.to_insert_fork_catchpoint = NULL;
918 gdbsim_ops.to_remove_fork_catchpoint = NULL;
919 gdbsim_ops.to_insert_vfork_catchpoint = NULL;
920 gdbsim_ops.to_remove_vfork_catchpoint = NULL;
921 gdbsim_ops.to_has_forked = NULL;
922 gdbsim_ops.to_has_vforked = NULL;
923 gdbsim_ops.to_can_follow_vfork_prior_to_exec = NULL;
924 gdbsim_ops.to_post_follow_vfork = NULL;
925 gdbsim_ops.to_insert_exec_catchpoint = NULL;
926 gdbsim_ops.to_remove_exec_catchpoint = NULL;
927 gdbsim_ops.to_has_execd = NULL;
928 gdbsim_ops.to_reported_exec_events_per_exec_call = NULL;
929 gdbsim_ops.to_has_exited = NULL;
930 gdbsim_ops.to_mourn_inferior = gdbsim_mourn_inferior;
931 gdbsim_ops.to_can_run = 0;
932 gdbsim_ops.to_notice_signals = 0;
933 gdbsim_ops.to_thread_alive = 0;
934 gdbsim_ops.to_stop = gdbsim_stop;
935 gdbsim_ops.to_pid_to_exec_file = NULL;
936 gdbsim_ops.to_core_file_to_sym_file = NULL;
937 gdbsim_ops.to_stratum = process_stratum;
938 gdbsim_ops.DONT_USE = NULL;
939 gdbsim_ops.to_has_all_memory = 1;
940 gdbsim_ops.to_has_memory = 1;
941 gdbsim_ops.to_has_stack = 1;
942 gdbsim_ops.to_has_registers = 1;
943 gdbsim_ops.to_has_execution = 1;
944 gdbsim_ops.to_sections = NULL;
945 gdbsim_ops.to_sections_end = NULL;
946 gdbsim_ops.to_magic = OPS_MAGIC;
948 #ifdef TARGET_REDEFINE_DEFAULT_OPS
949 TARGET_REDEFINE_DEFAULT_OPS (&gdbsim_ops);
954 _initialize_remote_sim ()
957 add_target (&gdbsim_ops);
959 add_com ("sim <command>", class_obscure, simulator_command,
960 "Send a command to the simulator.");