1 /* This file is part of the program psim.
3 Copyright (C) 1994-1996,1998, Andrew Cagney <cagney@highland.com.au>
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 #include <signal.h> /* FIXME - should be machine dependant version */
29 #undef printf_filtered /* blow away the mapping */
45 #include "gdb/callback.h"
46 #include "gdb/remote-sim.h"
48 /* Define the rate at which the simulator should poll the host
50 #ifndef POLL_QUIT_INTERVAL
51 #define POLL_QUIT_INTERVAL 0x20
54 static int poll_quit_count = POLL_QUIT_INTERVAL;
56 /* Structures used by the simulator, for gdb just have static structures */
58 static psim *simulator;
59 static device *root_device;
60 static host_callback *callbacks;
62 /* We use GDB's gdbarch_register_name function to map GDB register
63 numbers onto names, which we can then look up in the register
64 table. Since the `set architecture' command can select a new
65 processor variant at run-time, the meanings of the register numbers
66 can change, so we need to make sure the sim uses the same
67 name/number mapping that GDB uses.
69 (We don't use the REGISTER_NAME macro, which is a wrapper for
70 gdbarch_register_name. We #include GDB's "defs.h", which tries to
71 #include GDB's "config.h", but gets ours instead, and REGISTER_NAME
72 ends up not getting defined. Simpler to just use
73 gdbarch_register_name directly.)
75 We used to just use the REGISTER_NAMES macro from GDB's
76 target-dependent header files, which expanded into an initializer
77 for an array of strings. That was kind of nice, because it meant
78 that libsim.a had only a compile-time dependency on GDB; using
79 gdbarch_register_name directly means that there are now link-time
80 and run-time dependencies too.
82 Perhaps the host_callback structure could provide a function for
83 retrieving register names; that would be cleaner. */
86 sim_open (SIM_OPEN_KIND kind,
87 host_callback *callback,
93 /* Note: The simulation is not created by sim_open() because
94 complete information is not yet available */
96 TRACE(trace_gdb, ("sim_open called\n"));
98 if (root_device != NULL)
99 sim_io_printf_filtered("Warning - re-open of simulator leaks memory\n");
100 root_device = psim_tree();
103 psim_options(root_device, argv + 1);
105 if (ppc_trace[trace_opts])
108 /* fudge our descriptor for now */
114 sim_close (SIM_DESC sd, int quitting)
116 TRACE(trace_gdb, ("sim_close(quitting=%d) called\n", quitting));
117 if (ppc_trace[trace_print_info] && simulator != NULL)
118 psim_print_info (simulator, ppc_trace[trace_print_info]);
123 sim_load (SIM_DESC sd, char *prog, bfd *abfd, int from_tty)
125 TRACE(trace_gdb, ("sim_load(prog=%s, from_tty=%d) called\n",
127 ASSERT(prog != NULL);
129 /* create the simulator */
130 TRACE(trace_gdb, ("sim_load() - first time, create the simulator\n"));
131 simulator = psim_create(prog, root_device);
133 /* bring in all the data section */
134 psim_init(simulator);
136 /* get the start address */
139 abfd = bfd_openr (prog, 0);
141 error ("psim: can't open \"%s\": %s\n",
142 prog, bfd_errmsg (bfd_get_error ()));
143 if (!bfd_check_format (abfd, bfd_object))
145 const char *errmsg = bfd_errmsg (bfd_get_error ());
147 error ("psim: \"%s\" is not an object file: %s\n",
158 sim_read (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf, int length)
160 int result = psim_read_memory(simulator, MAX_NR_PROCESSORS,
162 TRACE(trace_gdb, ("sim_read(mem=0x%lx, buf=0x%lx, length=%d) = %d\n",
163 (long)mem, (long)buf, length, result));
169 sim_write (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf, int length)
171 int result = psim_write_memory(simulator, MAX_NR_PROCESSORS,
174 TRACE(trace_gdb, ("sim_write(mem=0x%lx, buf=0x%lx, length=%d) = %d\n",
175 (long)mem, (long)buf, length, result));
181 sim_fetch_register (SIM_DESC sd, int regno, unsigned char *buf, int length)
185 if (simulator == NULL) {
189 /* GDB will sometimes ask for the contents of a register named "";
190 we ignore such requests, and leave garbage in *BUF. In GDB
191 terms, the empty string means "the register with this number is
192 not present in the currently selected architecture variant."
193 That's following the kludge we're using for the MIPS processors.
194 But there are loops that just walk through the entire list of
195 names and try to get everything. */
196 regname = gdbarch_register_name (current_gdbarch, regno);
197 /* FIXME: ezannoni 2002/04/15 Remove the 'vr' and 'vscr' check
198 once AltiVec support is committed. */
199 if (! regname || regname[0] == '\0'
200 || (regname[0] == 'v' && regname[1] == 'r')
201 || (strcmp (regname, "vscr") == 0))
204 TRACE(trace_gdb, ("sim_fetch_register(regno=%d(%s), buf=0x%lx)\n",
205 regno, regname, (long)buf));
206 psim_read_register(simulator, MAX_NR_PROCESSORS,
207 buf, regname, raw_transfer);
213 sim_store_register (SIM_DESC sd, int regno, unsigned char *buf, int length)
217 if (simulator == NULL)
220 /* See comments in sim_fetch_register, above. */
221 regname = gdbarch_register_name (current_gdbarch, regno);
222 /* FIXME: ezannoni 2002/04/15 Remove the 'vr' and 'vscr' check
223 once AltiVec support is committed. */
224 if (! regname || regname[0] == '\0'
225 || (regname[0] == 'v' && regname[1] == 'r')
226 || (strcmp (regname, "vscr") == 0))
229 TRACE(trace_gdb, ("sim_store_register(regno=%d(%s), buf=0x%lx)\n",
230 regno, regname, (long)buf));
231 psim_write_register(simulator, MAX_NR_PROCESSORS,
232 buf, regname, raw_transfer);
238 sim_info (SIM_DESC sd, int verbose)
240 TRACE(trace_gdb, ("sim_info(verbose=%d) called\n", verbose));
241 psim_print_info (simulator, verbose);
246 sim_create_inferior (SIM_DESC sd,
251 unsigned_word entry_point;
252 TRACE(trace_gdb, ("sim_create_inferior(start_address=0x%x, ...)\n",
255 if (simulator == NULL)
256 error ("No program loaded");
259 entry_point = bfd_get_start_address (abfd);
261 entry_point = 0xfff00000; /* ??? */
263 psim_init(simulator);
264 psim_stack(simulator, argv, envp);
266 psim_write_register(simulator, -1 /* all start at same PC */,
267 &entry_point, "pc", cooked_transfer);
273 sim_stop_reason (SIM_DESC sd, enum sim_stop *reason, int *sigrc)
275 psim_status status = psim_get_status(simulator);
277 switch (status.reason) {
279 *reason = sim_stopped;
280 if (status.signal == 0)
283 *sigrc = status.signal;
286 *reason = sim_stopped;
290 *reason = sim_exited;
291 *sigrc = status.signal;
294 *reason = sim_signalled;
295 *sigrc = status.signal;
299 TRACE(trace_gdb, ("sim_stop_reason(reason=0x%lx(%ld), sigrc=0x%lx(%ld))\n",
300 (long)reason, (long)*reason, (long)sigrc, (long)*sigrc));
305 /* Run (or resume) the program. */
308 sim_stop (SIM_DESC sd)
310 psim_stop (simulator);
315 sim_resume (SIM_DESC sd, int step, int siggnal)
317 TRACE(trace_gdb, ("sim_resume(step=%d, siggnal=%d)\n",
322 psim_step (simulator);
326 psim_run (simulator);
331 sim_do_command (SIM_DESC sd, char *cmd)
333 TRACE(trace_gdb, ("sim_do_commands(cmd=%s) called\n",
334 cmd ? cmd : "(null)"));
336 char **argv = buildargv(cmd);
337 psim_command(root_device, argv);
343 /* Polling, if required */
346 sim_io_poll_quit (void)
348 if (callbacks->poll_quit != NULL && poll_quit_count-- < 0)
350 poll_quit_count = POLL_QUIT_INTERVAL;
351 if (callbacks->poll_quit (callbacks))
352 psim_stop (simulator);
358 /* Map simulator IO operations onto the corresponding GDB I/O
361 NB: Only a limited subset of operations are mapped across. More
362 advanced operations (such as dup or write) must either be mapped to
363 one of the below calls or handled internally */
366 sim_io_read_stdin(char *buf,
369 switch (CURRENT_STDIO) {
371 return callbacks->read_stdin(callbacks, buf, sizeof_buf);
374 return callbacks->read(callbacks, 0, buf, sizeof_buf);
377 error("sim_io_read_stdin: unaccounted switch\n");
384 sim_io_write_stdout(const char *buf,
387 switch (CURRENT_STDIO) {
389 return callbacks->write_stdout(callbacks, buf, sizeof_buf);
392 return callbacks->write(callbacks, 1, buf, sizeof_buf);
395 error("sim_io_write_stdout: unaccounted switch\n");
402 sim_io_write_stderr(const char *buf,
405 switch (CURRENT_STDIO) {
407 /* NB: I think there should be an explicit write_stderr callback */
408 return callbacks->write(callbacks, 3, buf, sizeof_buf);
411 return callbacks->write(callbacks, 3, buf, sizeof_buf);
414 error("sim_io_write_stderr: unaccounted switch\n");
422 sim_io_printf_filtered(const char *fmt,
427 /* format the message */
429 vsprintf(message, fmt, ap);
432 if (strlen(message) >= sizeof(message))
433 error("sim_io_printf_filtered: buffer overflow\n");
434 callbacks->printf_filtered(callbacks, "%s", message);
438 sim_io_flush_stdoutput(void)
440 switch (CURRENT_STDIO) {
442 callbacks->flush_stdout (callbacks);
447 error("sim_io_read_stdin: unaccounted switch\n");
453 sim_io_error (SIM_DESC sd, const char *fmt, ...)
457 callbacks->evprintf_filtered (callbacks, fmt, ap);
459 callbacks->error (callbacks, "");
467 void *memory = (void*)xmalloc(size);
469 error("xmalloc failed\n");
470 memset(memory, 0, size);
474 void zfree(void *data)