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 if (sim_set_args (argv
, env
) != 0)
235 insert_breakpoints (); /* Needed to get correct instruction in cache */
236 proceed (entry_pt
, -1, 0);
239 /* The open routine takes the rest of the parameters from the command,
240 and (if successful) pushes a new target onto the stack.
241 Targets should supply this routine, if only to provide an error message. */
242 /* Called when selecting the simulator. EG: (gdb) target sim name. */
245 simif_open (args
, from_tty
)
250 printf_filtered ("simif_open: args \"%s\"\n", args
);
252 if (sim_open (args
) != 0)
254 error ("Unable to initialize simulator (insufficient memory?).");
258 push_target (&simif_ops
);
259 target_fetch_registers (-1);
261 /* FIXME: check from_tty here? */
262 printf_filtered ("Connected to the simulator.\n");
265 /* Does whatever cleanup is required for a target that we are no longer
266 going to be calling. Argument says whether we are quitting gdb and
267 should not get hung in case of errors, or whether we want a clean
268 termination even if it takes a while. This routine is automatically
269 always called just before a routine is popped off the target stack.
270 Closing file descriptors and freeing memory are typical things it should
272 /* Close out all files and local state before this target loses control. */
275 simif_close (quitting
)
279 printf_filtered ("simif_close: quitting %d\n", quitting
);
283 /* FIXME: Need to call sim_close() to close all files and
284 delete all mappings. */
287 /* Takes a program previously attached to and detaches it.
288 The program may resume execution (some targets do, some don't) and will
289 no longer stop on signals, etc. We better not have left any breakpoints
290 in the program or it'll die when it hits one. ARGS is arguments
291 typed by the user (e.g. a signal to send the process). FROM_TTY
292 says whether to be verbose or not. */
293 /* Terminate the open connection to the remote debugger.
294 Use this when you want to detach and do something else with your gdb. */
297 simif_detach (args
,from_tty
)
302 printf_filtered ("simif_detach: args \"%s\"\n", args
);
304 pop_target (); /* calls simif_close to do the real work */
306 printf_filtered ("Ending simulator %s debugging\n", target_shortname
);
309 /* Resume execution of the target process. STEP says whether to single-step
310 or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
311 to the target, or zero for no signal. */
314 simif_resume (pid
, step
, siggnal
)
315 int pid
, step
, siggnal
;
318 printf_filtered ("simif_resume: step %d, signal %d\n", step
, siggnal
);
320 sim_resume (step
, siggnal
);
323 /* Wait for inferior process to do something. Return pid of child,
324 or -1 in case of error; store status through argument pointer STATUS,
325 just as `wait' would. */
332 printf_filtered ("simif_wait: ");
334 *status
= sim_stop_signal ();
336 WSETSTOP (*status
, sim_stop_signal ());
339 printf_filtered ("status %d\n", *status
);
343 /* Get ready to modify the registers array. On machines which store
344 individual registers, this doesn't need to do anything. On machines
345 which store all the registers in one fell swoop, this makes sure
346 that registers contains all the registers from the program being
350 simif_prepare_to_store ()
352 /* Do nothing, since we can store individual regs */
356 simif_xfer_inferior_memory (memaddr
, myaddr
, len
, write
, target
)
361 struct target_ops
*target
; /* ignored */
363 if (! program_loaded
)
364 error ("No program loaded.");
368 printf_filtered ("simif_xfer_inferior_memory: myaddr 0x%x, memaddr 0x%x, len %d, write %d\n",
369 myaddr
, memaddr
, len
, write
);
370 if (sim_verbose
&& write
)
371 dump_mem(myaddr
, len
);
376 len
= sim_write (memaddr
, myaddr
, len
);
380 len
= sim_read (memaddr
, myaddr
, len
);
381 if (sim_verbose
&& len
> 0)
382 dump_mem(myaddr
, len
);
388 simif_files_info (target
)
389 struct target_ops
*target
;
391 char *file
= "nothing";
394 file
= bfd_get_filename (exec_bfd
);
397 printf_filtered ("simif_files_info: file \"%s\"\n", file
);
401 printf_filtered ("\tAttached to %s running program %s\n",
402 target_shortname
, file
);
407 /* Clear the sims notion of what the break points are. */
410 simif_mourn_inferior ()
413 printf_filtered ("simif_mourn_inferior:\n");
415 remove_breakpoints ();
416 generic_mourn_inferior ();
419 /* Define the target subroutine names */
421 struct target_ops simif_ops
=
425 simif_open
, simif_close
,
426 0, simif_detach
, simif_resume
, simif_wait
, /* attach */
427 simif_fetch_register
, simif_store_register
,
428 simif_prepare_to_store
,
429 simif_xfer_inferior_memory
,
431 0, 0, /* Breakpoints */
432 0, 0, 0, 0, 0, /* Terminal handling */
433 simif_kill
, /* FIXME, kill */
435 0, /* lookup_symbol */
436 simif_create_inferior
, /* create_inferior */
437 simif_mourn_inferior
, /* mourn_inferior FIXME */
439 0, /* notice_signals */
440 process_stratum
, 0, /* next */
441 1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
442 0, 0, /* Section pointers */
443 OPS_MAGIC
, /* Always the last thing */
449 sim_verbose
= ! sim_verbose
;
451 printf_filtered ("Snoop enabled\n");
453 printf_filtered ("Snoop disabled\n");
457 /***********************************************************************/
460 _initialize_remote_sim ()
462 add_target (&simif_ops
);
463 add_com ("snoop", class_obscure
, simif_snoop
,
464 "Show what commands are going to the simulator");
474 if (len
== 8 || len
== 4)
477 memcpy (l
, buf
, len
);
478 printf_filtered ("\t0x%x", l
[0]);
479 printf_filtered (len
== 8 ? " 0x%x\n" : "\n", l
[1]);
484 printf_filtered ("\t");
485 for (i
= 0; i
< len
; i
++)
486 printf_filtered ("0x%x ", buf
[i
]);
487 printf_filtered ("\n");