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, Boston, MA 02111-1307, USA. */
26 #include "gdb_string.h"
36 #include "remote-sim.h"
37 #include "remote-utils.h"
41 static void dump_mem PARAMS ((char *buf, int len));
43 static void init_callbacks PARAMS ((void));
45 static void end_callbacks PARAMS ((void));
47 static int gdb_os_write_stdout PARAMS ((host_callback *, const char *, int));
49 static void gdb_os_printf_filtered PARAMS ((host_callback *, const char *, ...));
51 static void gdb_os_error PARAMS ((host_callback *, const char *, ...));
53 static void gdbsim_fetch_register PARAMS ((int regno));
55 static void gdbsim_store_register PARAMS ((int regno));
57 static void gdbsim_kill PARAMS ((void));
59 static void gdbsim_load PARAMS ((char *prog, int fromtty));
61 static void gdbsim_create_inferior PARAMS ((char *exec_file, char *args, char **env));
63 static void gdbsim_open PARAMS ((char *args, int from_tty));
65 static void gdbsim_close PARAMS ((int quitting));
67 static void gdbsim_detach PARAMS ((char *args, int from_tty));
69 static void gdbsim_resume PARAMS ((int pid, int step, enum target_signal siggnal));
71 static int gdbsim_wait PARAMS ((int pid, struct target_waitstatus *status));
73 static void gdbsim_prepare_to_store PARAMS ((void));
75 static int gdbsim_xfer_inferior_memory PARAMS ((CORE_ADDR memaddr,
76 char *myaddr, int len,
78 struct target_ops *target));
80 static void gdbsim_files_info PARAMS ((struct target_ops *target));
82 static void gdbsim_mourn_inferior PARAMS ((void));
84 static void simulator_command PARAMS ((char *args, int from_tty));
88 sim_* are the interface to the simulator (see remote-sim.h).
89 gdbsim_* are stuff which is internal to gdb. */
91 /* Forward data declarations */
92 extern struct target_ops gdbsim_ops;
94 static int program_loaded = 0;
96 /* We must keep track of whether the simulator has been opened or not because
97 GDB can call a target's close routine twice, but sim_close doesn't allow
98 this. We also need to record the result of sim_open so we can pass it
99 back to the other sim_foo routines. */
100 static SIM_DESC gdbsim_desc = 0;
109 if (len == 8 || len == 4)
112 memcpy (l, buf, len);
113 printf_filtered ("\t0x%x", l[0]);
114 printf_filtered (len == 8 ? " 0x%x\n" : "\n", l[1]);
119 printf_filtered ("\t");
120 for (i = 0; i < len; i++)
121 printf_filtered ("0x%x ", buf[i]);
122 printf_filtered ("\n");
127 static host_callback gdb_callback;
128 static int callbacks_initialized = 0;
130 /* Initialize gdb_callback. */
135 if (! callbacks_initialized)
137 gdb_callback = default_callback;
138 gdb_callback.init (&gdb_callback);
139 gdb_callback.write_stdout = gdb_os_write_stdout;
140 gdb_callback.printf_filtered = gdb_os_printf_filtered;
141 gdb_callback.error = gdb_os_error;
142 sim_set_callbacks (gdbsim_desc, &gdb_callback);
143 callbacks_initialized = 1;
147 /* Release callbacks (free resources used by them). */
152 if (callbacks_initialized)
154 gdb_callback.shutdown (&gdb_callback);
155 callbacks_initialized = 0;
159 /* GDB version of os_write_stdout callback. */
162 gdb_os_write_stdout (p, buf, len)
170 for (i = 0; i < len; i++)
174 if (target_output_hook)
175 target_output_hook (b);
177 fputs_filtered (b, gdb_stdout);
182 /* GDB version of printf_filtered callback. */
186 #ifdef ANSI_PROTOTYPES
187 gdb_os_printf_filtered (host_callback *p, const char *format, ...)
189 gdb_os_printf_filtered (p, va_alist)
195 #ifdef ANSI_PROTOTYPES
196 va_start (args, format);
201 format = va_arg (args, char *);
204 vfprintf_filtered (gdb_stdout, format, args);
209 /* GDB version of error callback. */
213 #ifdef ANSI_PROTOTYPES
214 gdb_os_error (host_callback *p, const char *format, ...)
216 gdb_os_error (p, va_alist)
226 #ifdef ANSI_PROTOTYPES
227 va_start (args, format);
232 format = va_arg (args, char *);
236 vfprintf_filtered (gdb_stderr, format, args);
237 fprintf_filtered (gdb_stderr, "\n");
239 return_to_top_level (RETURN_ERROR);
244 gdbsim_fetch_register (regno)
249 for (regno = 0; regno < NUM_REGS; regno++)
250 gdbsim_fetch_register (regno);
254 char buf[MAX_REGISTER_RAW_SIZE];
256 sim_fetch_register (gdbsim_desc, regno, buf);
257 supply_register (regno, buf);
260 printf_filtered ("gdbsim_fetch_register: %d", regno);
261 /* FIXME: We could print something more intelligible. */
262 dump_mem (buf, REGISTER_RAW_SIZE (regno));
269 gdbsim_store_register (regno)
274 for (regno = 0; regno < NUM_REGS; regno++)
275 gdbsim_store_register (regno);
279 /* FIXME: Until read_register() returns LONGEST, we have this. */
280 char tmp[MAX_REGISTER_RAW_SIZE];
281 read_register_gen (regno, tmp);
282 sim_store_register (gdbsim_desc, regno, tmp);
285 printf_filtered ("gdbsim_store_register: %d", regno);
286 /* FIXME: We could print something more intelligible. */
287 dump_mem (tmp, REGISTER_RAW_SIZE (regno));
292 /* Kill the running program. This may involve closing any open files
293 and releasing other resources acquired by the simulated program. */
299 printf_filtered ("gdbsim_kill\n");
301 sim_kill (gdbsim_desc); /* close fd's, remove mappings, etc. */
305 /* Load an executable file into the target process. This is expected to
306 not only bring new code into the target process, but also to update
307 GDB's symbol tables to match. */
310 gdbsim_load (prog, fromtty)
315 printf_filtered ("gdbsim_load: prog \"%s\"\n", prog);
319 /* This must be done before calling gr_load_image. */
322 if (sim_load (gdbsim_desc, prog, fromtty) != 0)
323 generic_load (prog, fromtty);
327 /* Start an inferior process and set inferior_pid to its pid.
328 EXEC_FILE is the file to run.
329 ARGS is a string containing the arguments to the program.
330 ENV is the environment vector to pass. Errors reported with error().
331 On VxWorks and various standalone systems, we ignore exec_file. */
332 /* This is called not only when we first attach, but also when the
333 user types "run" after having attached. */
336 gdbsim_create_inferior (exec_file, args, env)
342 char *arg_buf,**argv;
345 if (! program_loaded)
346 error ("No program loaded.");
349 printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
352 if (exec_file == 0 || exec_bfd == 0)
353 error ("No exec file specified.");
355 entry_pt = (CORE_ADDR) bfd_get_start_address (exec_bfd);
358 remove_breakpoints ();
359 init_wait_for_inferior ();
361 len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop*/ 10;
362 arg_buf = (char *) alloca (len);
364 strcat (arg_buf, exec_file);
365 strcat (arg_buf, " ");
366 strcat (arg_buf, args);
367 argv = buildargv (arg_buf);
368 make_cleanup (freeargv, (char *) argv);
369 sim_create_inferior (gdbsim_desc, entry_pt, argv, env);
372 insert_breakpoints (); /* Needed to get correct instruction in cache */
373 proceed (entry_pt, TARGET_SIGNAL_DEFAULT, 0);
376 /* The open routine takes the rest of the parameters from the command,
377 and (if successful) pushes a new target onto the stack.
378 Targets should supply this routine, if only to provide an error message. */
379 /* Called when selecting the simulator. EG: (gdb) target sim name. */
382 gdbsim_open (args, from_tty)
391 printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
393 /* Remove current simulator if one exists. Only do this if the simulator
394 has been opened because sim_close requires it.
395 This is important because the call to push_target below will cause
396 sim_close to be called if the simulator is already open, but push_target
397 is called after sim_open! We can't move the call to push_target before
398 the call to sim_open because sim_open may invoke `error'. */
399 if (gdbsim_desc != NULL)
400 unpush_target (&gdbsim_ops);
404 len = 7 + 1 + (args ? strlen (args) : 0) + 1 + /*slop*/ 10;
405 arg_buf = (char *) alloca (len);
406 strcpy (arg_buf, "gdbsim");
409 strcat (arg_buf, " ");
410 strcat (arg_buf, args);
412 argv = buildargv (arg_buf);
414 error ("Insufficient memory available to allocate simulator arg list.");
415 make_cleanup (freeargv, (char *) argv);
417 /* FIXME: sim_open may call `error' if it fails, but perhaps it should
418 just return an error indicator and let us call `error'. */
419 gdbsim_desc = sim_open (argv);
421 push_target (&gdbsim_ops);
422 target_fetch_registers (-1);
423 printf_filtered ("Connected to the simulator.\n");
426 /* Does whatever cleanup is required for a target that we are no longer
427 going to be calling. Argument says whether we are quitting gdb and
428 should not get hung in case of errors, or whether we want a clean
429 termination even if it takes a while. This routine is automatically
430 always called just before a routine is popped off the target stack.
431 Closing file descriptors and freeing memory are typical things it should
433 /* Close out all files and local state before this target loses control. */
436 gdbsim_close (quitting)
440 printf_filtered ("gdbsim_close: quitting %d\n", quitting);
444 if (gdbsim_desc != NULL)
446 sim_close (gdbsim_desc, quitting);
453 /* Takes a program previously attached to and detaches it.
454 The program may resume execution (some targets do, some don't) and will
455 no longer stop on signals, etc. We better not have left any breakpoints
456 in the program or it'll die when it hits one. ARGS is arguments
457 typed by the user (e.g. a signal to send the process). FROM_TTY
458 says whether to be verbose or not. */
459 /* Terminate the open connection to the remote debugger.
460 Use this when you want to detach and do something else with your gdb. */
463 gdbsim_detach (args,from_tty)
468 printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
470 pop_target (); /* calls gdbsim_close to do the real work */
472 printf_filtered ("Ending simulator %s debugging\n", target_shortname);
475 /* Resume execution of the target process. STEP says whether to single-step
476 or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
477 to the target, or zero for no signal. */
480 gdbsim_resume (pid, step, siggnal)
482 enum target_signal siggnal;
484 if (inferior_pid != 42)
485 error ("The program is not being run.");
488 printf_filtered ("gdbsim_resume: step %d, signal %d\n", step, siggnal);
490 sim_resume (gdbsim_desc, step, target_signal_to_host (siggnal));
493 /* Wait for inferior process to do something. Return pid of child,
494 or -1 in case of error; store status through argument pointer STATUS,
495 just as `wait' would. */
498 gdbsim_wait (pid, status)
500 struct target_waitstatus *status;
503 enum sim_stop reason;
506 printf_filtered ("gdbsim_wait\n");
508 sim_stop_reason (gdbsim_desc, &reason, &sigrc);
512 status->kind = TARGET_WAITKIND_EXITED;
513 status->value.integer = sigrc;
516 status->kind = TARGET_WAITKIND_STOPPED;
517 /* The signal in sigrc is a host signal. That probably
519 status->value.sig = target_signal_from_host (sigrc);
522 status->kind = TARGET_WAITKIND_SIGNALLED;
523 /* The signal in sigrc is a host signal. That probably
525 status->value.sig = target_signal_from_host (sigrc);
532 /* Get ready to modify the registers array. On machines which store
533 individual registers, this doesn't need to do anything. On machines
534 which store all the registers in one fell swoop, this makes sure
535 that registers contains all the registers from the program being
539 gdbsim_prepare_to_store ()
541 /* Do nothing, since we can store individual regs */
545 gdbsim_xfer_inferior_memory (memaddr, myaddr, len, write, target)
550 struct target_ops *target; /* ignored */
552 if (! program_loaded)
553 error ("No program loaded.");
557 printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x%x, memaddr 0x%x, len %d, write %d\n",
558 myaddr, memaddr, len, write);
559 if (sr_get_debug () && write)
560 dump_mem(myaddr, len);
565 len = sim_write (gdbsim_desc, memaddr, myaddr, len);
569 len = sim_read (gdbsim_desc, memaddr, myaddr, len);
570 if (sr_get_debug () && len > 0)
571 dump_mem(myaddr, len);
577 gdbsim_files_info (target)
578 struct target_ops *target;
580 char *file = "nothing";
583 file = bfd_get_filename (exec_bfd);
586 printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
590 printf_filtered ("\tAttached to %s running program %s\n",
591 target_shortname, file);
592 sim_info (gdbsim_desc, 0);
596 /* Clear the simulator's notion of what the break points are. */
599 gdbsim_mourn_inferior ()
602 printf_filtered ("gdbsim_mourn_inferior:\n");
604 remove_breakpoints ();
605 generic_mourn_inferior ();
608 /* Pass the command argument through to the simulator verbatim. The
609 simulator must do any command interpretation work. */
612 simulator_command (args, from_tty)
616 /* The user may give a command before the simulator is opened, so
617 ensure that the callbacks have been set up. */
620 /* Note that if the simulator hasn't been opened, gdbsim_desc == NULL
621 which is correct (??? assuming of course one wishes to continue to
622 allow commands to be sent to unopened simulators, which isn't entirely
624 sim_do_command (gdbsim_desc, args);
627 /* Define the target subroutine names */
629 struct target_ops gdbsim_ops = {
630 "sim", /* to_shortname */
631 "simulator", /* to_longname */
632 "Use the compiled-in simulator.", /* to_doc */
633 gdbsim_open, /* to_open */
634 gdbsim_close, /* to_close */
635 NULL, /* to_attach */
636 gdbsim_detach, /* to_detach */
637 gdbsim_resume, /* to_resume */
638 gdbsim_wait, /* to_wait */
639 gdbsim_fetch_register, /* to_fetch_registers */
640 gdbsim_store_register, /* to_store_registers */
641 gdbsim_prepare_to_store, /* to_prepare_to_store */
642 gdbsim_xfer_inferior_memory, /* to_xfer_memory */
643 gdbsim_files_info, /* to_files_info */
644 memory_insert_breakpoint, /* to_insert_breakpoint */
645 memory_remove_breakpoint, /* to_remove_breakpoint */
646 NULL, /* to_terminal_init */
647 NULL, /* to_terminal_inferior */
648 NULL, /* to_terminal_ours_for_output */
649 NULL, /* to_terminal_ours */
650 NULL, /* to_terminal_info */
651 gdbsim_kill, /* to_kill */
652 gdbsim_load, /* to_load */
653 NULL, /* to_lookup_symbol */
654 gdbsim_create_inferior, /* to_create_inferior */
655 gdbsim_mourn_inferior, /* to_mourn_inferior */
657 0, /* to_notice_signals */
658 0, /* to_thread_alive */
660 process_stratum, /* to_stratum */
662 1, /* to_has_all_memory */
663 1, /* to_has_memory */
664 1, /* to_has_stack */
665 1, /* to_has_registers */
666 1, /* to_has_execution */
668 NULL, /* sections_end */
669 OPS_MAGIC, /* to_magic */
673 _initialize_remote_sim ()
675 add_target (&gdbsim_ops);
677 add_com ("sim <command>", class_obscure, simulator_command,
678 "Send a command to the simulator.");