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 */
46 #include "remote-sim.h"
49 /* Structures used by the simulator, for gdb just have static structures */
51 static psim *simulator;
52 static device *root_device;
53 static host_callback *callbacks;
55 /* We use GDB's reg_names array to map GDB register numbers onto
56 names, which we can then look up in the register table.
58 We used to just use the REGISTER_NAMES macro, from GDB's
59 target-dependent header files. That was kind of nice, because it
60 meant that libsim.a had only a compile-time dependency on GDB;
61 using reg_names directly means that there are now link-time and
62 run-time dependencies too.
64 However, the GDB PPC back-end now modifies the reg_names array when
65 the user runs the `set processor' command, which affects the
66 meanings of the register numbers. So the sim needs to see the
67 register names GDB is actually using.
69 Perhaps the host_callback structure could contain a pointer to the
70 register name table; that would be cleaner. */
73 sim_open (SIM_OPEN_KIND kind,
74 host_callback *callback,
80 /* Note: The simulation is not created by sim_open() because
81 complete information is not yet available */
83 TRACE(trace_gdb, ("sim_open called\n"));
85 if (root_device != NULL)
86 sim_io_printf_filtered("Warning - re-open of simulator leaks memory\n");
87 root_device = psim_tree();
90 psim_options(root_device, argv + 1);
92 if (ppc_trace[trace_opts])
95 /* fudge our descriptor for now */
101 sim_close (SIM_DESC sd, int quitting)
103 TRACE(trace_gdb, ("sim_close(quitting=%d) called\n", quitting));
104 if (ppc_trace[trace_print_info] && simulator != NULL)
105 psim_print_info (simulator, ppc_trace[trace_print_info]);
110 sim_load (SIM_DESC sd, char *prog, bfd *abfd, int from_tty)
112 TRACE(trace_gdb, ("sim_load(prog=%s, from_tty=%d) called\n",
114 ASSERT(prog != NULL);
116 /* create the simulator */
117 TRACE(trace_gdb, ("sim_load() - first time, create the simulator\n"));
118 simulator = psim_create(prog, root_device);
120 /* bring in all the data section */
121 psim_init(simulator);
123 /* get the start address */
126 abfd = bfd_openr (prog, 0);
128 error ("psim: can't open \"%s\": %s\n",
129 prog, bfd_errmsg (bfd_get_error ()));
130 if (!bfd_check_format (abfd, bfd_object))
132 const char *errmsg = bfd_errmsg (bfd_get_error ());
134 error ("psim: \"%s\" is not an object file: %s\n",
145 sim_read (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf, int length)
147 int result = psim_read_memory(simulator, MAX_NR_PROCESSORS,
149 TRACE(trace_gdb, ("sim_read(mem=0x%lx, buf=0x%lx, length=%d) = %d\n",
150 (long)mem, (long)buf, length, result));
156 sim_write (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf, int length)
158 int result = psim_write_memory(simulator, MAX_NR_PROCESSORS,
161 TRACE(trace_gdb, ("sim_write(mem=0x%lx, buf=0x%lx, length=%d) = %d\n",
162 (long)mem, (long)buf, length, result));
168 sim_fetch_register (SIM_DESC sd, int regno, unsigned char *buf, int length)
172 if (simulator == NULL) {
176 /* GDB will sometimes ask for the contents of a register named "";
177 we ignore such requests, and leave garbage in *BUF. In
178 REG_NAMES, the empty string means "the register with this
179 number is not present in the currently selected architecture
180 variant." That's following the kludge we're using for the MIPS
181 processors. But there are loops that just walk through the
182 entire list of names and try to get everything. */
183 regname = REGISTER_NAME (regno);
184 if (! regname || regname[0] == '\0')
187 TRACE(trace_gdb, ("sim_fetch_register(regno=%d(%s), buf=0x%lx)\n",
188 regno, regname, (long)buf));
189 psim_read_register(simulator, MAX_NR_PROCESSORS,
190 buf, regname, raw_transfer);
196 sim_store_register (SIM_DESC sd, int regno, unsigned char *buf, int length)
200 if (simulator == NULL)
203 /* See comments in sim_fetch_register, above. */
204 regname = REGISTER_NAME (regno);
205 if (! regname || regname[0] == '\0')
208 TRACE(trace_gdb, ("sim_store_register(regno=%d(%s), buf=0x%lx)\n",
209 regno, regname, (long)buf));
210 psim_write_register(simulator, MAX_NR_PROCESSORS,
211 buf, regname, raw_transfer);
217 sim_info (SIM_DESC sd, int verbose)
219 TRACE(trace_gdb, ("sim_info(verbose=%d) called\n", verbose));
220 psim_print_info (simulator, verbose);
225 sim_create_inferior (SIM_DESC sd,
230 unsigned_word entry_point;
231 TRACE(trace_gdb, ("sim_create_inferior(start_address=0x%x, ...)\n",
234 if (simulator == NULL)
235 error ("No program loaded");
238 entry_point = bfd_get_start_address (abfd);
240 entry_point = 0xfff00000; /* ??? */
242 psim_init(simulator);
243 psim_stack(simulator, argv, envp);
245 psim_write_register(simulator, -1 /* all start at same PC */,
246 &entry_point, "pc", cooked_transfer);
252 sim_stop_reason (SIM_DESC sd, enum sim_stop *reason, int *sigrc)
254 psim_status status = psim_get_status(simulator);
256 switch (status.reason) {
258 *reason = sim_stopped;
259 if (status.signal == 0)
262 *sigrc = status.signal;
265 *reason = sim_stopped;
269 *reason = sim_exited;
270 *sigrc = status.signal;
273 *reason = sim_signalled;
274 *sigrc = status.signal;
278 TRACE(trace_gdb, ("sim_stop_reason(reason=0x%lx(%ld), sigrc=0x%lx(%ld))\n",
279 (long)reason, (long)*reason, (long)sigrc, (long)*sigrc));
284 /* Run (or resume) the program. */
287 sim_stop (SIM_DESC sd)
289 psim_stop (simulator);
294 sim_resume (SIM_DESC sd, int step, int siggnal)
296 TRACE(trace_gdb, ("sim_resume(step=%d, siggnal=%d)\n",
301 psim_step (simulator);
305 psim_run (simulator);
310 sim_do_command (SIM_DESC sd, char *cmd)
312 TRACE(trace_gdb, ("sim_do_commands(cmd=%s) called\n",
313 cmd ? cmd : "(null)"));
315 char **argv = buildargv(cmd);
316 psim_command(root_device, argv);
322 /* Polling, if required */
325 sim_io_poll_quit (void)
327 if (callbacks->poll_quit != NULL)
329 if (callbacks->poll_quit (callbacks))
330 psim_stop (simulator);
336 /* Map simulator IO operations onto the corresponding GDB I/O
339 NB: Only a limited subset of operations are mapped across. More
340 advanced operations (such as dup or write) must either be mapped to
341 one of the below calls or handled internally */
344 sim_io_read_stdin(char *buf,
347 switch (CURRENT_STDIO) {
349 return callbacks->read_stdin(callbacks, buf, sizeof_buf);
352 return callbacks->read(callbacks, 0, buf, sizeof_buf);
355 error("sim_io_read_stdin: unaccounted switch\n");
362 sim_io_write_stdout(const char *buf,
365 switch (CURRENT_STDIO) {
367 return callbacks->write_stdout(callbacks, buf, sizeof_buf);
370 return callbacks->write(callbacks, 1, buf, sizeof_buf);
373 error("sim_io_write_stdout: unaccounted switch\n");
380 sim_io_write_stderr(const char *buf,
383 switch (CURRENT_STDIO) {
385 /* NB: I think there should be an explicit write_stderr callback */
386 return callbacks->write(callbacks, 3, buf, sizeof_buf);
389 return callbacks->write(callbacks, 3, buf, sizeof_buf);
392 error("sim_io_write_stderr: unaccounted switch\n");
400 sim_io_printf_filtered(const char *fmt,
405 /* format the message */
407 vsprintf(message, fmt, ap);
410 if (strlen(message) >= sizeof(message))
411 error("sim_io_printf_filtered: buffer overflow\n");
412 callbacks->printf_filtered(callbacks, "%s", message);
416 sim_io_flush_stdoutput(void)
418 switch (CURRENT_STDIO) {
420 callbacks->flush_stdout (callbacks);
425 error("sim_io_read_stdin: unaccounted switch\n");
435 void *memory = (void*)xmalloc(size);
437 error("xmalloc failed\n");
438 memset(memory, 0, size);
442 void zfree(void *data)