1 /* Generic remote debugging interface for simulators.
2 Copyright 1993, 1994, 1996 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 gdbsim_fetch_register
PARAMS ((int regno
));
53 static void gdbsim_store_register
PARAMS ((int regno
));
55 static void gdbsim_kill
PARAMS ((void));
57 static void gdbsim_load
PARAMS ((char *prog
, int fromtty
));
59 static void gdbsim_create_inferior
PARAMS ((char *exec_file
, char *args
, char **env
));
61 static void gdbsim_open
PARAMS ((char *args
, int from_tty
));
63 static void gdbsim_close
PARAMS ((int quitting
));
65 static void gdbsim_detach
PARAMS ((char *args
, int from_tty
));
67 static void gdbsim_resume
PARAMS ((int pid
, int step
, enum target_signal siggnal
));
69 static int gdbsim_wait
PARAMS ((int pid
, struct target_waitstatus
*status
));
71 static void gdbsim_prepare_to_store
PARAMS ((void));
73 static int gdbsim_xfer_inferior_memory
PARAMS ((CORE_ADDR memaddr
,
74 char *myaddr
, int len
,
76 struct target_ops
*target
));
78 static void gdbsim_files_info
PARAMS ((struct target_ops
*target
));
80 static void gdbsim_mourn_inferior
PARAMS ((void));
82 static void simulator_command
PARAMS ((char *args
, int from_tty
));
86 sim_* are the interface to the simulator (see remote-sim.h).
87 gdbsim_* are stuff which is internal to gdb. */
89 /* Forward data declarations */
90 extern struct target_ops gdbsim_ops
;
92 static int program_loaded
= 0;
101 if (len
== 8 || len
== 4)
104 memcpy (l
, buf
, len
);
105 printf_filtered ("\t0x%x", l
[0]);
106 printf_filtered (len
== 8 ? " 0x%x\n" : "\n", l
[1]);
111 printf_filtered ("\t");
112 for (i
= 0; i
< len
; i
++)
113 printf_filtered ("0x%x ", buf
[i
]);
114 printf_filtered ("\n");
119 static host_callback gdb_callback
;
120 static int callbacks_initialized
= 0;
122 /* Initialize gdb_callback. */
127 if (! callbacks_initialized
)
129 gdb_callback
= default_callback
;
130 default_callback
.init (&gdb_callback
);
131 default_callback
.write_stdout
= gdb_os_write_stdout
;
132 default_callback
.printf_filtered
= gdb_os_printf_filtered
;
133 sim_set_callbacks (&gdb_callback
);
134 callbacks_initialized
= 1;
138 /* Release callbacks (free resources used by them). */
143 if (callbacks_initialized
)
145 gdb_callback
.shutdown (&gdb_callback
);
146 callbacks_initialized
= 0;
150 /* GDB version of os_write_stdout callback. */
153 gdb_os_write_stdout (p
, buf
, len
)
161 for (i
= 0; i
< len
; i
++)
165 if (target_output_hook
)
166 target_output_hook (b
);
168 fputs_filtered (b
, gdb_stdout
);
173 /* GDB version of printf_filtered callback. */
177 #ifdef ANSI_PROTOTYPES
178 gdb_os_printf_filtered (host_callback
*p
, const char *format
, ...)
180 gdb_os_printf_filtered (p
, va_alist
)
186 #ifdef ANSI_PROTOTYPES
187 va_start (args
, format
);
192 format
= va_arg (args
, char *);
195 vfprintf_filtered (stdout
, format
, args
);
201 gdbsim_fetch_register (regno
)
206 for (regno
= 0; regno
< NUM_REGS
; regno
++)
207 gdbsim_fetch_register (regno
);
211 char buf
[MAX_REGISTER_RAW_SIZE
];
213 sim_fetch_register (regno
, buf
);
214 supply_register (regno
, buf
);
217 printf_filtered ("gdbsim_fetch_register: %d", regno
);
218 /* FIXME: We could print something more intelligible. */
219 dump_mem (buf
, REGISTER_RAW_SIZE (regno
));
226 gdbsim_store_register (regno
)
231 for (regno
= 0; regno
< NUM_REGS
; regno
++)
232 gdbsim_store_register (regno
);
236 /* FIXME: Until read_register() returns LONGEST, we have this. */
237 char tmp
[MAX_REGISTER_RAW_SIZE
];
238 read_register_gen (regno
, tmp
);
239 sim_store_register (regno
, tmp
);
242 printf_filtered ("gdbsim_store_register: %d", regno
);
243 /* FIXME: We could print something more intelligible. */
244 dump_mem (tmp
, REGISTER_RAW_SIZE (regno
));
249 /* Kill the running program. This may involve closing any open files
250 and releasing other resources acquired by the simulated program. */
256 printf_filtered ("gdbsim_kill\n");
258 sim_kill (); /* close fd's, remove mappings */
262 /* Load an executable file into the target process. This is expected to
263 not only bring new code into the target process, but also to update
264 GDB's symbol tables to match. */
267 gdbsim_load (prog
, fromtty
)
272 printf_filtered ("gdbsim_load: prog \"%s\"\n", prog
);
276 /* This must be done before calling gr_load_image. */
279 if (sim_load (prog
, fromtty
) != 0)
280 generic_load (prog
, fromtty
);
284 /* Start an inferior process and set inferior_pid to its pid.
285 EXEC_FILE is the file to run.
286 ALLARGS is a string containing the arguments to the program.
287 ENV is the environment vector to pass. Errors reported with error().
288 On VxWorks and various standalone systems, we ignore exec_file. */
289 /* This is called not only when we first attach, but also when the
290 user types "run" after having attached. */
293 gdbsim_create_inferior (exec_file
, args
, env
)
299 char *arg_buf
,**argv
;
302 if (! program_loaded
)
303 error ("No program loaded.");
306 printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
309 if (exec_file
== 0 || exec_bfd
== 0)
310 error ("No exec file specified.");
312 entry_pt
= (CORE_ADDR
) bfd_get_start_address (exec_bfd
);
315 remove_breakpoints ();
316 init_wait_for_inferior ();
318 len
= 5 + strlen (exec_file
) + 1 + strlen (args
) + 1 + /*slop*/ 10;
319 arg_buf
= (char *) alloca (len
);
321 strcat (arg_buf
, exec_file
);
322 strcat (arg_buf
, " ");
323 strcat (arg_buf
, args
);
324 argv
= buildargv (arg_buf
);
325 make_cleanup (freeargv
, (char *) argv
);
326 sim_create_inferior (entry_pt
, argv
, env
);
329 insert_breakpoints (); /* Needed to get correct instruction in cache */
330 proceed (entry_pt
, TARGET_SIGNAL_DEFAULT
, 0);
333 /* The open routine takes the rest of the parameters from the command,
334 and (if successful) pushes a new target onto the stack.
335 Targets should supply this routine, if only to provide an error message. */
336 /* Called when selecting the simulator. EG: (gdb) target sim name. */
339 gdbsim_open (args
, from_tty
)
344 printf_filtered ("gdbsim_open: args \"%s\"\n", args
? args
: "(null)");
350 push_target (&gdbsim_ops
);
351 target_fetch_registers (-1);
352 printf_filtered ("Connected to the simulator.\n");
355 /* Does whatever cleanup is required for a target that we are no longer
356 going to be calling. Argument says whether we are quitting gdb and
357 should not get hung in case of errors, or whether we want a clean
358 termination even if it takes a while. This routine is automatically
359 always called just before a routine is popped off the target stack.
360 Closing file descriptors and freeing memory are typical things it should
362 /* Close out all files and local state before this target loses control. */
365 gdbsim_close (quitting
)
369 printf_filtered ("gdbsim_close: quitting %d\n", quitting
);
373 sim_close (quitting
);
378 /* Takes a program previously attached to and detaches it.
379 The program may resume execution (some targets do, some don't) and will
380 no longer stop on signals, etc. We better not have left any breakpoints
381 in the program or it'll die when it hits one. ARGS is arguments
382 typed by the user (e.g. a signal to send the process). FROM_TTY
383 says whether to be verbose or not. */
384 /* Terminate the open connection to the remote debugger.
385 Use this when you want to detach and do something else with your gdb. */
388 gdbsim_detach (args
,from_tty
)
393 printf_filtered ("gdbsim_detach: args \"%s\"\n", args
);
395 pop_target (); /* calls gdbsim_close to do the real work */
397 printf_filtered ("Ending simulator %s debugging\n", target_shortname
);
400 /* Resume execution of the target process. STEP says whether to single-step
401 or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
402 to the target, or zero for no signal. */
405 gdbsim_resume (pid
, step
, siggnal
)
407 enum target_signal siggnal
;
409 if (inferior_pid
!= 42)
410 error ("The program is not being run.");
413 printf_filtered ("gdbsim_resume: step %d, signal %d\n", step
, siggnal
);
415 sim_resume (step
, target_signal_to_host (siggnal
));
418 /* Wait for inferior process to do something. Return pid of child,
419 or -1 in case of error; store status through argument pointer STATUS,
420 just as `wait' would. */
423 gdbsim_wait (pid
, status
)
425 struct target_waitstatus
*status
;
428 enum sim_stop reason
;
431 printf_filtered ("gdbsim_wait\n");
433 sim_stop_reason (&reason
, &sigrc
);
437 status
->kind
= TARGET_WAITKIND_EXITED
;
438 status
->value
.integer
= sigrc
;
441 status
->kind
= TARGET_WAITKIND_STOPPED
;
442 /* The signal in sigrc is a host signal. That probably
444 status
->value
.sig
= target_signal_from_host (sigrc
);
447 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
448 /* The signal in sigrc is a host signal. That probably
450 status
->value
.sig
= target_signal_from_host (sigrc
);
457 /* Get ready to modify the registers array. On machines which store
458 individual registers, this doesn't need to do anything. On machines
459 which store all the registers in one fell swoop, this makes sure
460 that registers contains all the registers from the program being
464 gdbsim_prepare_to_store ()
466 /* Do nothing, since we can store individual regs */
470 gdbsim_xfer_inferior_memory (memaddr
, myaddr
, len
, write
, target
)
475 struct target_ops
*target
; /* ignored */
477 if (! program_loaded
)
478 error ("No program loaded.");
482 printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x%x, memaddr 0x%x, len %d, write %d\n",
483 myaddr
, memaddr
, len
, write
);
484 if (sr_get_debug () && write
)
485 dump_mem(myaddr
, len
);
490 len
= sim_write (memaddr
, myaddr
, len
);
494 len
= sim_read (memaddr
, myaddr
, len
);
495 if (sr_get_debug () && len
> 0)
496 dump_mem(myaddr
, len
);
502 gdbsim_files_info (target
)
503 struct target_ops
*target
;
505 char *file
= "nothing";
508 file
= bfd_get_filename (exec_bfd
);
511 printf_filtered ("gdbsim_files_info: file \"%s\"\n", file
);
515 printf_filtered ("\tAttached to %s running program %s\n",
516 target_shortname
, file
);
521 /* Clear the simulator's notion of what the break points are. */
524 gdbsim_mourn_inferior ()
527 printf_filtered ("gdbsim_mourn_inferior:\n");
529 remove_breakpoints ();
530 generic_mourn_inferior ();
533 /* Pass the command argument through to the simulator verbatim. The
534 simulator must do any command interpretation work. */
537 simulator_command (args
, from_tty
)
541 /* The user may give a command before the simulator is opened, so
542 ensure that the callbacks have been set up. */
545 sim_do_command (args
);
548 /* Define the target subroutine names */
550 struct target_ops gdbsim_ops
= {
551 "sim", /* to_shortname */
552 "simulator", /* to_longname */
553 "Use the compiled-in simulator.", /* to_doc */
554 gdbsim_open
, /* to_open */
555 gdbsim_close
, /* to_close */
556 NULL
, /* to_attach */
557 gdbsim_detach
, /* to_detach */
558 gdbsim_resume
, /* to_resume */
559 gdbsim_wait
, /* to_wait */
560 gdbsim_fetch_register
, /* to_fetch_registers */
561 gdbsim_store_register
, /* to_store_registers */
562 gdbsim_prepare_to_store
, /* to_prepare_to_store */
563 gdbsim_xfer_inferior_memory
, /* to_xfer_memory */
564 gdbsim_files_info
, /* to_files_info */
565 memory_insert_breakpoint
, /* to_insert_breakpoint */
566 memory_remove_breakpoint
, /* to_remove_breakpoint */
567 NULL
, /* to_terminal_init */
568 NULL
, /* to_terminal_inferior */
569 NULL
, /* to_terminal_ours_for_output */
570 NULL
, /* to_terminal_ours */
571 NULL
, /* to_terminal_info */
572 gdbsim_kill
, /* to_kill */
573 gdbsim_load
, /* to_load */
574 NULL
, /* to_lookup_symbol */
575 gdbsim_create_inferior
, /* to_create_inferior */
576 gdbsim_mourn_inferior
, /* to_mourn_inferior */
578 0, /* to_notice_signals */
579 0, /* to_thread_alive */
581 process_stratum
, /* to_stratum */
583 1, /* to_has_all_memory */
584 1, /* to_has_memory */
585 1, /* to_has_stack */
586 1, /* to_has_registers */
587 1, /* to_has_execution */
589 NULL
, /* sections_end */
590 OPS_MAGIC
, /* to_magic */
594 _initialize_remote_sim ()
596 add_target (&gdbsim_ops
);
598 add_com ("sim <command>", class_obscure
, simulator_command
,
599 "Send a command to the simulator.");