1/* This file is part of the program psim. 2 3 Copyright 1994, 1995, 1996, 1998, 2003 Andrew Cagney 4 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. 9 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. 14 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. 18 19 */ 20 21 22#include <signal.h> /* FIXME - should be machine dependant version */ 23#include <stdarg.h> 24#include <ctype.h> 25 26#include "psim.h" 27#include "options.h" 28 29#undef printf_filtered /* blow away the mapping */ 30 31#ifdef HAVE_STDLIB_H 32#include <stdlib.h> 33#endif 34 35#ifdef HAVE_STRING_H 36#include <string.h> 37#else 38#ifdef HAVE_STRINGS_H 39#include <strings.h> 40#endif 41#endif 42 43#include "libiberty.h" 44#include "bfd.h" 45#include "gdb/callback.h" 46#include "gdb/remote-sim.h" 47#include "gdb/signals.h" 48 49/* Define the rate at which the simulator should poll the host 50 for a quit. */ 51#ifndef POLL_QUIT_INTERVAL 52#define POLL_QUIT_INTERVAL 0x20 53#endif 54 55static int poll_quit_count = POLL_QUIT_INTERVAL; 56 57/* Structures used by the simulator, for gdb just have static structures */ 58 59psim *simulator; 60static device *root_device; 61static host_callback *callbacks; 62 63SIM_DESC 64sim_open (SIM_OPEN_KIND kind, 65 host_callback *callback, 66 struct bfd *abfd, 67 char **argv) 68{ 69 callbacks = callback; 70 71 /* Note: The simulation is not created by sim_open() because 72 complete information is not yet available */ 73 /* trace the call */ 74 TRACE(trace_gdb, ("sim_open called\n")); 75 76 if (root_device != NULL) 77 sim_io_printf_filtered("Warning - re-open of simulator leaks memory\n"); 78 root_device = psim_tree(); 79 simulator = NULL; 80 81 psim_options(root_device, argv + 1); 82 83 if (ppc_trace[trace_opts]) 84 print_options (); 85 86 /* fudge our descriptor for now */ 87 return (SIM_DESC) 1; 88} 89 90 91void 92sim_close (SIM_DESC sd, int quitting) 93{ 94 TRACE(trace_gdb, ("sim_close(quitting=%d) called\n", quitting)); 95 if (ppc_trace[trace_print_info] && simulator != NULL) 96 psim_print_info (simulator, ppc_trace[trace_print_info]); 97} 98 99 100SIM_RC 101sim_load (SIM_DESC sd, char *prog, bfd *abfd, int from_tty) 102{ 103 TRACE(trace_gdb, ("sim_load(prog=%s, from_tty=%d) called\n", 104 prog, from_tty)); 105 ASSERT(prog != NULL); 106 107 /* create the simulator */ 108 TRACE(trace_gdb, ("sim_load() - first time, create the simulator\n")); 109 simulator = psim_create(prog, root_device); 110 111 /* bring in all the data section */ 112 psim_init(simulator); 113 114 /* get the start address */ 115 if (abfd == NULL) 116 { 117 abfd = bfd_openr (prog, 0); 118 if (abfd == NULL) 119 error ("psim: can't open \"%s\": %s\n", 120 prog, bfd_errmsg (bfd_get_error ())); 121 if (!bfd_check_format (abfd, bfd_object)) 122 { 123 const char *errmsg = bfd_errmsg (bfd_get_error ()); 124 bfd_close (abfd); 125 error ("psim: \"%s\" is not an object file: %s\n", 126 prog, errmsg); 127 } 128 bfd_close (abfd); 129 } 130 131 return SIM_RC_OK; 132} 133 134 135int 136sim_read (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf, int length) 137{ 138 int result = psim_read_memory(simulator, MAX_NR_PROCESSORS, 139 buf, mem, length); 140 TRACE(trace_gdb, ("sim_read(mem=0x%lx, buf=0x%lx, length=%d) = %d\n", 141 (long)mem, (long)buf, length, result)); 142 return result; 143} 144 145 146int 147sim_write (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf, int length) 148{ 149 int result = psim_write_memory(simulator, MAX_NR_PROCESSORS, 150 buf, mem, length, 151 1/*violate_ro*/); 152 TRACE(trace_gdb, ("sim_write(mem=0x%lx, buf=0x%lx, length=%d) = %d\n", 153 (long)mem, (long)buf, length, result)); 154 return result; 155} 156 157void 158sim_info (SIM_DESC sd, int verbose) 159{ 160 TRACE(trace_gdb, ("sim_info(verbose=%d) called\n", verbose)); 161 psim_print_info (simulator, verbose); 162} 163 164 165SIM_RC 166sim_create_inferior (SIM_DESC sd, 167 struct bfd *abfd, 168 char **argv, 169 char **envp) 170{ 171 unsigned_word entry_point; 172 TRACE(trace_gdb, ("sim_create_inferior(start_address=0x%x, ...)\n", 173 entry_point)); 174 175 if (simulator == NULL) 176 error ("No program loaded"); 177 178 if (abfd != NULL) 179 entry_point = bfd_get_start_address (abfd); 180 else 181 entry_point = 0xfff00000; /* ??? */ 182 183 psim_init(simulator); 184 psim_stack(simulator, argv, envp); 185 186 ASSERT (psim_write_register(simulator, -1 /* all start at same PC */, 187 &entry_point, "pc", cooked_transfer) > 0); 188 return SIM_RC_OK; 189} 190 191 192void 193sim_stop_reason (SIM_DESC sd, enum sim_stop *reason, int *sigrc) 194{ 195 psim_status status = psim_get_status(simulator); 196 197 switch (status.reason) { 198 case was_continuing: 199 *reason = sim_stopped; 200 if (status.signal == 0) 201 *sigrc = TARGET_SIGNAL_TRAP; 202 else 203 *sigrc = status.signal; 204 break; 205 case was_trap: 206 *reason = sim_stopped; 207 *sigrc = TARGET_SIGNAL_TRAP; 208 break; 209 case was_exited: 210 *reason = sim_exited; 211 *sigrc = status.signal; 212 break; 213 case was_signalled: 214 *reason = sim_signalled; 215 *sigrc = status.signal; 216 break; 217 } 218 219 TRACE(trace_gdb, ("sim_stop_reason(reason=0x%lx(%ld), sigrc=0x%lx(%ld))\n", 220 (long)reason, (long)*reason, (long)sigrc, (long)*sigrc)); 221} 222 223 224 225/* Run (or resume) the program. */ 226 227int 228sim_stop (SIM_DESC sd) 229{ 230 psim_stop (simulator); 231 return 1; 232} 233 234void 235sim_resume (SIM_DESC sd, int step, int siggnal) 236{ 237 TRACE(trace_gdb, ("sim_resume(step=%d, siggnal=%d)\n", 238 step, siggnal)); 239 240 if (step) 241 { 242 psim_step (simulator); 243 } 244 else 245 { 246 psim_run (simulator); 247 } 248} 249 250void 251sim_do_command (SIM_DESC sd, char *cmd) 252{ 253 TRACE(trace_gdb, ("sim_do_commands(cmd=%s) called\n", 254 cmd ? cmd : "(null)")); 255 if (cmd != NULL) { 256 char **argv = buildargv(cmd); 257 psim_command(root_device, argv); 258 freeargv(argv); 259 } 260} 261 262 263/* Polling, if required */ 264 265void 266sim_io_poll_quit (void) 267{ 268 if (callbacks->poll_quit != NULL && poll_quit_count-- < 0) 269 { 270 poll_quit_count = POLL_QUIT_INTERVAL; 271 if (callbacks->poll_quit (callbacks)) 272 psim_stop (simulator); 273 } 274} 275 276 277 278/* Map simulator IO operations onto the corresponding GDB I/O 279 functions. 280 281 NB: Only a limited subset of operations are mapped across. More 282 advanced operations (such as dup or write) must either be mapped to 283 one of the below calls or handled internally */ 284 285int 286sim_io_read_stdin(char *buf, 287 int sizeof_buf) 288{ 289 switch (CURRENT_STDIO) { 290 case DO_USE_STDIO: 291 return callbacks->read_stdin(callbacks, buf, sizeof_buf); 292 break; 293 case DONT_USE_STDIO: 294 return callbacks->read(callbacks, 0, buf, sizeof_buf); 295 break; 296 default: 297 error("sim_io_read_stdin: unaccounted switch\n"); 298 break; 299 } 300 return 0; 301} 302 303int 304sim_io_write_stdout(const char *buf, 305 int sizeof_buf) 306{ 307 switch (CURRENT_STDIO) { 308 case DO_USE_STDIO: 309 return callbacks->write_stdout(callbacks, buf, sizeof_buf); 310 break; 311 case DONT_USE_STDIO: 312 return callbacks->write(callbacks, 1, buf, sizeof_buf); 313 break; 314 default: 315 error("sim_io_write_stdout: unaccounted switch\n"); 316 break; 317 } 318 return 0; 319} 320 321int 322sim_io_write_stderr(const char *buf, 323 int sizeof_buf) 324{ 325 switch (CURRENT_STDIO) { 326 case DO_USE_STDIO: 327 /* NB: I think there should be an explicit write_stderr callback */ 328 return callbacks->write(callbacks, 3, buf, sizeof_buf); 329 break; 330 case DONT_USE_STDIO: 331 return callbacks->write(callbacks, 3, buf, sizeof_buf); 332 break; 333 default: 334 error("sim_io_write_stderr: unaccounted switch\n"); 335 break; 336 } 337 return 0; 338} 339 340 341void 342sim_io_printf_filtered(const char *fmt, 343 ...) 344{ 345 char message[1024]; 346 va_list ap; 347 /* format the message */ 348 va_start(ap, fmt); 349 vsprintf(message, fmt, ap); 350 va_end(ap); 351 /* sanity check */ 352 if (strlen(message) >= sizeof(message)) 353 error("sim_io_printf_filtered: buffer overflow\n"); 354 callbacks->printf_filtered(callbacks, "%s", message); 355} 356 357void 358sim_io_flush_stdoutput(void) 359{ 360 switch (CURRENT_STDIO) { 361 case DO_USE_STDIO: 362 callbacks->flush_stdout (callbacks); 363 break; 364 case DONT_USE_STDIO: 365 break; 366 default: 367 error("sim_io_read_stdin: unaccounted switch\n"); 368 break; 369 } 370} 371 372void 373sim_io_error (SIM_DESC sd, const char *fmt, ...) 374{ 375 va_list ap; 376 va_start(ap, fmt); 377 callbacks->evprintf_filtered (callbacks, fmt, ap); 378 va_end(ap); 379 callbacks->error (callbacks, ""); 380} 381 382/****/ 383 384void * 385zalloc(long size) 386{ 387 void *memory = (void*)xmalloc(size); 388 if (memory == NULL) 389 error("xmalloc failed\n"); 390 memset(memory, 0, size); 391 return memory; 392} 393 394void zfree(void *data) 395{ 396 free(data); 397} 398