1 /* Generic remote debugging interface for simulators.
2 Copyright 1993 Free Software Foundation, Inc.
3 Contributed by Cygnus Support.
4 Steve Chamberlain (sac@cygnus.com) and Doug Evans (dje@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., 675 Mass Ave, Cambridge, MA 02139, USA. */
35 #include "remote-sim.h"
37 /* Naming conventions:
39 simif_xxx are internal objects that describe top level interfaces to the
40 simulator (simif for SIMulator InterFace, duh...).
42 sim_xxx are external counterparts to the simif_xxx objects that must be
43 provided by the simulator.
45 See simif.h for a description. */
47 /* Forward data declarations */
48 extern struct target_ops simif_ops
;
50 int sim_verbose
= 0; /* available to the simulator to use */
52 static int program_loaded
= 0;
54 static void dump_mem ();
57 simif_fetch_register (regno
)
62 for (regno
= 0; regno
< NUM_REGS
; regno
++)
63 simif_fetch_register (regno
);
67 char buf
[MAX_REGISTER_RAW_SIZE
];
69 sim_fetch_register (regno
, buf
);
70 supply_register (regno
, buf
);
73 printf_filtered ("simif_fetch_register: %d", regno
);
74 /* FIXME: We could print something more intelligible. */
75 dump_mem (buf
, REGISTER_RAW_SIZE (regno
));
81 simif_store_register (regno
)
86 for (regno
= 0; regno
< NUM_REGS
; regno
++)
87 simif_store_register (regno
);
91 /* FIXME: Until read_register() returns LONGEST, we have this. */
92 char value
[MAX_REGISTER_RAW_SIZE
];
94 read_register_gen (regno
, value
);
95 SWAP_TARGET_AND_HOST (value
, REGISTER_RAW_SIZE (regno
));
96 sim_store_register (regno
, value
);
99 printf_filtered ("simif_store_register: %d", regno
);
100 /* FIXME: We could print something more intelligible. */
101 dump_mem (value
, REGISTER_RAW_SIZE (regno
));
110 printf_filtered ("simif_kill\n");
112 sim_kill (); /* close fd's, remove mappings */
116 /* Load an executable file into the target process. This is expected to
117 not only bring new code into the target process, but also to update
118 GDB's symbol tables to match. */
121 simif_load (prog
, fromtty
)
128 printf_filtered ("simif_load: prog \"%s\"\n", prog
);
132 abfd
= bfd_openr (prog
, (char *) 0);
135 error ("Unable to open file %s.", prog
);
137 if (bfd_check_format (abfd
, bfd_object
) == 0)
138 error ("File is not an object file.");
140 if (sim_load (abfd
, prog
) != 0)
145 sim_set_pc (abfd
->start_address
);
149 * This is a utility routine that sim_load() can call to do the work.
150 * The result is 0 for success, non-zero for failure.
152 * Eg: int sim_load (bfd *bfd, char *prog) { return sim_load_standard (bfd); }
155 sim_load_standard (abfd
)
161 while (s
!= (asection
*)NULL
)
163 if (s
->flags
& SEC_LOAD
)
167 char *buffer
= xmalloc (delta
);
168 printf_filtered ("%s\t: 0x%4x .. 0x%4x ",
169 s
->name
, s
->vma
, s
->vma
+ s
->_raw_size
);
170 for (i
= 0; i
< s
->_raw_size
; i
+= delta
)
172 int sub_delta
= delta
;
173 if (sub_delta
> s
->_raw_size
- i
)
174 sub_delta
= s
->_raw_size
- i
;
176 bfd_get_section_contents (abfd
, s
, buffer
, i
, sub_delta
);
177 sim_write (s
->vma
+ i
, buffer
, sub_delta
);
178 printf_filtered ("*");
181 printf_filtered ("\n");
190 /* Start an inferior process and set inferior_pid to its pid.
191 EXEC_FILE is the file to run.
192 ALLARGS is a string containing the arguments to the program.
193 ENV is the environment vector to pass. Errors reported with error().
194 On VxWorks and various standalone systems, we ignore exec_file. */
195 /* This is called not only when we first attach, but also when the
196 user types "run" after having attached. */
199 simif_create_inferior (exec_file
, args
, env
)
205 char *arg_buf
,**argv
;
207 if (! program_loaded
)
208 error ("No program loaded.");
211 printf_filtered ("simif_create_inferior: exec_file \"%s\", args \"%s\"\n",
214 if (exec_file
== 0 || exec_bfd
== 0)
215 error ("No exec file specified.");
217 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
219 simif_kill (NULL
, NULL
);
220 remove_breakpoints ();
221 init_wait_for_inferior ();
223 len
= 5 + strlen (exec_file
) + 1 + strlen (args
) + 1 + /*slop*/ 10;
224 arg_buf
= (char *) alloca (len
);
226 strcat (arg_buf
, exec_file
);
227 strcat (arg_buf
, " ");
228 strcat (arg_buf
, args
);
229 argv
= buildargv (arg_buf
);
230 make_cleanup (freeargv
, (char *) argv
);
231 /* FIXME: remote-sim.h says targets that don't support this return
232 non-zero. Perhaps distinguish between "not supported" and other errors?
233 Or maybe that can be the only error. */
234 if (sim_set_args (argv
, env
) != 0)
238 insert_breakpoints (); /* Needed to get correct instruction in cache */
239 proceed (entry_pt
, -1, 0);
242 /* The open routine takes the rest of the parameters from the command,
243 and (if successful) pushes a new target onto the stack.
244 Targets should supply this routine, if only to provide an error message. */
245 /* Called when selecting the simulator. EG: (gdb) target sim name. */
248 simif_open (args
, from_tty
)
253 printf_filtered ("simif_open: args \"%s\"\n", args
);
255 if (sim_open (args
) != 0)
257 error ("Unable to initialize simulator (insufficient memory?).");
261 push_target (&simif_ops
);
262 target_fetch_registers (-1);
264 /* FIXME: check from_tty here? */
265 printf_filtered ("Connected to the simulator.\n");
268 /* Does whatever cleanup is required for a target that we are no longer
269 going to be calling. Argument says whether we are quitting gdb and
270 should not get hung in case of errors, or whether we want a clean
271 termination even if it takes a while. This routine is automatically
272 always called just before a routine is popped off the target stack.
273 Closing file descriptors and freeing memory are typical things it should
275 /* Close out all files and local state before this target loses control. */
278 simif_close (quitting
)
282 printf_filtered ("simif_close: quitting %d\n", quitting
);
286 /* FIXME: Need to call sim_close() to close all files and
287 delete all mappings. */
290 /* Takes a program previously attached to and detaches it.
291 The program may resume execution (some targets do, some don't) and will
292 no longer stop on signals, etc. We better not have left any breakpoints
293 in the program or it'll die when it hits one. ARGS is arguments
294 typed by the user (e.g. a signal to send the process). FROM_TTY
295 says whether to be verbose or not. */
296 /* Terminate the open connection to the remote debugger.
297 Use this when you want to detach and do something else with your gdb. */
300 simif_detach (args
,from_tty
)
305 printf_filtered ("simif_detach: args \"%s\"\n", args
);
307 pop_target (); /* calls simif_close to do the real work */
309 printf_filtered ("Ending simulator %s debugging\n", target_shortname
);
312 /* Resume execution of the target process. STEP says whether to single-step
313 or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
314 to the target, or zero for no signal. */
317 simif_resume (pid
, step
, siggnal
)
318 int pid
, step
, siggnal
;
321 printf_filtered ("simif_resume: step %d, signal %d\n", step
, siggnal
);
323 sim_resume (step
, siggnal
);
326 /* Wait for inferior process to do something. Return pid of child,
327 or -1 in case of error; store status through argument pointer STATUS,
328 just as `wait' would. */
335 printf_filtered ("simif_wait: ");
337 *status
= sim_stop_signal ();
339 WSETSTOP (*status
, sim_stop_signal ());
342 printf_filtered ("status %d\n", *status
);
346 /* Get ready to modify the registers array. On machines which store
347 individual registers, this doesn't need to do anything. On machines
348 which store all the registers in one fell swoop, this makes sure
349 that registers contains all the registers from the program being
353 simif_prepare_to_store ()
355 /* Do nothing, since we can store individual regs */
359 simif_xfer_inferior_memory (memaddr
, myaddr
, len
, write
, target
)
364 struct target_ops
*target
; /* ignored */
366 if (! program_loaded
)
367 error ("No program loaded.");
371 printf_filtered ("simif_xfer_inferior_memory: myaddr 0x%x, memaddr 0x%x, len %d, write %d\n",
372 myaddr
, memaddr
, len
, write
);
373 if (sim_verbose
&& write
)
374 dump_mem(myaddr
, len
);
379 len
= sim_write (memaddr
, myaddr
, len
);
383 len
= sim_read (memaddr
, myaddr
, len
);
384 if (sim_verbose
&& len
> 0)
385 dump_mem(myaddr
, len
);
391 simif_files_info (target
)
392 struct target_ops
*target
;
394 char *file
= "nothing";
397 file
= bfd_get_filename (exec_bfd
);
400 printf_filtered ("simif_files_info: file \"%s\"\n", file
);
404 printf_filtered ("\tAttached to %s running program %s\n",
405 target_shortname
, file
);
410 /* Clear the sims notion of what the break points are. */
413 simif_mourn_inferior ()
416 printf_filtered ("simif_mourn_inferior:\n");
418 remove_breakpoints ();
419 generic_mourn_inferior ();
422 /* Define the target subroutine names */
424 struct target_ops simif_ops
=
428 simif_open
, simif_close
,
429 0, simif_detach
, simif_resume
, simif_wait
, /* attach */
430 simif_fetch_register
, simif_store_register
,
431 simif_prepare_to_store
,
432 simif_xfer_inferior_memory
,
434 0, 0, /* Breakpoints */
435 0, 0, 0, 0, 0, /* Terminal handling */
436 simif_kill
, /* FIXME, kill */
438 0, /* lookup_symbol */
439 simif_create_inferior
, /* create_inferior */
440 simif_mourn_inferior
, /* mourn_inferior FIXME */
442 0, /* notice_signals */
443 process_stratum
, 0, /* next */
444 1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
445 0, 0, /* Section pointers */
446 OPS_MAGIC
, /* Always the last thing */
452 sim_verbose
= ! sim_verbose
;
454 printf_filtered ("Snoop enabled\n");
456 printf_filtered ("Snoop disabled\n");
460 /***********************************************************************/
463 _initialize_remote_sim ()
465 add_target (&simif_ops
);
466 add_com ("snoop", class_obscure
, simif_snoop
,
467 "Show what commands are going to the simulator");
477 if (len
== 8 || len
== 4)
480 memcpy (l
, buf
, len
);
481 printf_filtered ("\t0x%x", l
[0]);
482 printf_filtered (len
== 8 ? " 0x%x\n" : "\n", l
[1]);
487 printf_filtered ("\t");
488 for (i
= 0; i
< len
; i
++)
489 printf_filtered ("0x%x ", buf
[i
]);
490 printf_filtered ("\n");