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"
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 reg_names array to map GDB register numbers onto
63 names, which we can then look up in the register table.
65 We used to just use the REGISTER_NAMES macro, from GDB's
66 target-dependent header files. That was kind of nice, because it
67 meant that libsim.a had only a compile-time dependency on GDB;
68 using reg_names directly means that there are now link-time and
69 run-time dependencies too.
71 However, the GDB PPC back-end now modifies the reg_names array when
72 the user runs the `set processor' command, which affects the
73 meanings of the register numbers. So the sim needs to see the
74 register names GDB is actually using.
76 Perhaps the host_callback structure could contain a pointer to the
77 register name table; that would be cleaner. */
80 sim_open (SIM_OPEN_KIND kind
,
81 host_callback
*callback
,
87 /* Note: The simulation is not created by sim_open() because
88 complete information is not yet available */
90 TRACE(trace_gdb
, ("sim_open called\n"));
92 if (root_device
!= NULL
)
93 sim_io_printf_filtered("Warning - re-open of simulator leaks memory\n");
94 root_device
= psim_tree();
97 psim_options(root_device
, argv
+ 1);
99 if (ppc_trace
[trace_opts
])
102 /* fudge our descriptor for now */
108 sim_close (SIM_DESC sd
, int quitting
)
110 TRACE(trace_gdb
, ("sim_close(quitting=%d) called\n", quitting
));
111 if (ppc_trace
[trace_print_info
] && simulator
!= NULL
)
112 psim_print_info (simulator
, ppc_trace
[trace_print_info
]);
117 sim_load (SIM_DESC sd
, char *prog
, bfd
*abfd
, int from_tty
)
119 TRACE(trace_gdb
, ("sim_load(prog=%s, from_tty=%d) called\n",
121 ASSERT(prog
!= NULL
);
123 /* create the simulator */
124 TRACE(trace_gdb
, ("sim_load() - first time, create the simulator\n"));
125 simulator
= psim_create(prog
, root_device
);
127 /* bring in all the data section */
128 psim_init(simulator
);
130 /* get the start address */
133 abfd
= bfd_openr (prog
, 0);
135 error ("psim: can't open \"%s\": %s\n",
136 prog
, bfd_errmsg (bfd_get_error ()));
137 if (!bfd_check_format (abfd
, bfd_object
))
139 const char *errmsg
= bfd_errmsg (bfd_get_error ());
141 error ("psim: \"%s\" is not an object file: %s\n",
152 sim_read (SIM_DESC sd
, SIM_ADDR mem
, unsigned char *buf
, int length
)
154 int result
= psim_read_memory(simulator
, MAX_NR_PROCESSORS
,
156 TRACE(trace_gdb
, ("sim_read(mem=0x%lx, buf=0x%lx, length=%d) = %d\n",
157 (long)mem
, (long)buf
, length
, result
));
163 sim_write (SIM_DESC sd
, SIM_ADDR mem
, unsigned char *buf
, int length
)
165 int result
= psim_write_memory(simulator
, MAX_NR_PROCESSORS
,
168 TRACE(trace_gdb
, ("sim_write(mem=0x%lx, buf=0x%lx, length=%d) = %d\n",
169 (long)mem
, (long)buf
, length
, result
));
175 sim_fetch_register (SIM_DESC sd
, int regno
, unsigned char *buf
, int length
)
179 if (simulator
== NULL
) {
183 /* GDB will sometimes ask for the contents of a register named "";
184 we ignore such requests, and leave garbage in *BUF. In
185 REG_NAMES, the empty string means "the register with this
186 number is not present in the currently selected architecture
187 variant." That's following the kludge we're using for the MIPS
188 processors. But there are loops that just walk through the
189 entire list of names and try to get everything. */
190 regname
= REGISTER_NAME (regno
);
191 if (! regname
|| regname
[0] == '\0')
194 TRACE(trace_gdb
, ("sim_fetch_register(regno=%d(%s), buf=0x%lx)\n",
195 regno
, regname
, (long)buf
));
196 psim_read_register(simulator
, MAX_NR_PROCESSORS
,
197 buf
, regname
, raw_transfer
);
203 sim_store_register (SIM_DESC sd
, int regno
, unsigned char *buf
, int length
)
207 if (simulator
== NULL
)
210 /* See comments in sim_fetch_register, above. */
211 regname
= REGISTER_NAME (regno
);
212 if (! regname
|| regname
[0] == '\0')
215 TRACE(trace_gdb
, ("sim_store_register(regno=%d(%s), buf=0x%lx)\n",
216 regno
, regname
, (long)buf
));
217 psim_write_register(simulator
, MAX_NR_PROCESSORS
,
218 buf
, regname
, raw_transfer
);
224 sim_info (SIM_DESC sd
, int verbose
)
226 TRACE(trace_gdb
, ("sim_info(verbose=%d) called\n", verbose
));
227 psim_print_info (simulator
, verbose
);
232 sim_create_inferior (SIM_DESC sd
,
237 unsigned_word entry_point
;
238 TRACE(trace_gdb
, ("sim_create_inferior(start_address=0x%x, ...)\n",
241 if (simulator
== NULL
)
242 error ("No program loaded");
245 entry_point
= bfd_get_start_address (abfd
);
247 entry_point
= 0xfff00000; /* ??? */
249 psim_init(simulator
);
250 psim_stack(simulator
, argv
, envp
);
252 psim_write_register(simulator
, -1 /* all start at same PC */,
253 &entry_point
, "pc", cooked_transfer
);
259 sim_stop_reason (SIM_DESC sd
, enum sim_stop
*reason
, int *sigrc
)
261 psim_status status
= psim_get_status(simulator
);
263 switch (status
.reason
) {
265 *reason
= sim_stopped
;
266 if (status
.signal
== 0)
269 *sigrc
= status
.signal
;
272 *reason
= sim_stopped
;
276 *reason
= sim_exited
;
277 *sigrc
= status
.signal
;
280 *reason
= sim_signalled
;
281 *sigrc
= status
.signal
;
285 TRACE(trace_gdb
, ("sim_stop_reason(reason=0x%lx(%ld), sigrc=0x%lx(%ld))\n",
286 (long)reason
, (long)*reason
, (long)sigrc
, (long)*sigrc
));
291 /* Run (or resume) the program. */
294 sim_stop (SIM_DESC sd
)
296 psim_stop (simulator
);
301 sim_resume (SIM_DESC sd
, int step
, int siggnal
)
303 TRACE(trace_gdb
, ("sim_resume(step=%d, siggnal=%d)\n",
308 psim_step (simulator
);
312 psim_run (simulator
);
317 sim_do_command (SIM_DESC sd
, char *cmd
)
319 TRACE(trace_gdb
, ("sim_do_commands(cmd=%s) called\n",
320 cmd
? cmd
: "(null)"));
322 char **argv
= buildargv(cmd
);
323 psim_command(root_device
, argv
);
329 /* Polling, if required */
332 sim_io_poll_quit (void)
334 if (callbacks
->poll_quit
!= NULL
&& poll_quit_count
-- < 0)
336 poll_quit_count
= POLL_QUIT_INTERVAL
;
337 if (callbacks
->poll_quit (callbacks
))
338 psim_stop (simulator
);
344 /* Map simulator IO operations onto the corresponding GDB I/O
347 NB: Only a limited subset of operations are mapped across. More
348 advanced operations (such as dup or write) must either be mapped to
349 one of the below calls or handled internally */
352 sim_io_read_stdin(char *buf
,
355 switch (CURRENT_STDIO
) {
357 return callbacks
->read_stdin(callbacks
, buf
, sizeof_buf
);
360 return callbacks
->read(callbacks
, 0, buf
, sizeof_buf
);
363 error("sim_io_read_stdin: unaccounted switch\n");
370 sim_io_write_stdout(const char *buf
,
373 switch (CURRENT_STDIO
) {
375 return callbacks
->write_stdout(callbacks
, buf
, sizeof_buf
);
378 return callbacks
->write(callbacks
, 1, buf
, sizeof_buf
);
381 error("sim_io_write_stdout: unaccounted switch\n");
388 sim_io_write_stderr(const char *buf
,
391 switch (CURRENT_STDIO
) {
393 /* NB: I think there should be an explicit write_stderr callback */
394 return callbacks
->write(callbacks
, 3, buf
, sizeof_buf
);
397 return callbacks
->write(callbacks
, 3, buf
, sizeof_buf
);
400 error("sim_io_write_stderr: unaccounted switch\n");
408 sim_io_printf_filtered(const char *fmt
,
413 /* format the message */
415 vsprintf(message
, fmt
, ap
);
418 if (strlen(message
) >= sizeof(message
))
419 error("sim_io_printf_filtered: buffer overflow\n");
420 callbacks
->printf_filtered(callbacks
, "%s", message
);
424 sim_io_flush_stdoutput(void)
426 switch (CURRENT_STDIO
) {
428 callbacks
->flush_stdout (callbacks
);
433 error("sim_io_read_stdin: unaccounted switch\n");
443 void *memory
= (void*)xmalloc(size
);
445 error("xmalloc failed\n");
446 memset(memory
, 0, size
);
450 void zfree(void *data
)