gdb/remote-sim.c

   1 /* Generic remote debugging interface for simulators.
   2    Copyright 1993, 1994, 1996, 1997 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support.
   4    Steve Chamberlain (sac@cygnus.com).
   5
   6 This file is part of GDB.
   7
   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.
  12
  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.
  17
  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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "inferior.h"
  24 #include "wait.h"
  25 #include "value.h"
  26 #include "gdb_string.h"
  27 #include <ctype.h>
  28 #include <fcntl.h>
  29 #include <signal.h>
  30 #include <setjmp.h>
  31 #include <errno.h>
  32 #include "terminal.h"
  33 #include "target.h"
  34 #include "gdbcore.h"
  35 #include "callback.h"
  36 #include "remote-sim.h"
  37 #include "remote-utils.h"
  38 #include "command.h"
  39
  40 /* Prototypes */
  41
  42 static void dump_mem PARAMS ((char *buf, int len));
  43
  44 static void init_callbacks PARAMS ((void));
  45
  46 static void end_callbacks PARAMS ((void));
  47
  48 static int gdb_os_write_stdout PARAMS ((host_callback *, const char *, int));
  49
  50 static void gdb_os_flush_stdout PARAMS ((host_callback *));
  51
  52 static int gdb_os_write_stderr PARAMS ((host_callback *, const char *, int));
  53
  54 static void gdb_os_flush_stderr PARAMS ((host_callback *));
  55
  56 static int gdb_os_poll_quit PARAMS ((host_callback *));
  57
  58 /* printf_filtered is depreciated */
  59 static void gdb_os_printf_filtered PARAMS ((host_callback *, const char *, ...));
  60
  61 static void gdb_os_vprintf_filtered PARAMS ((host_callback *, const char *, va_list));
  62
  63 static void gdb_os_evprintf_filtered PARAMS ((host_callback *, const char *, va_list));
  64
  65 static void gdb_os_error PARAMS ((host_callback *, const char *, ...));
  66
  67 static void gdbsim_fetch_register PARAMS ((int regno));
  68
  69 static void gdbsim_store_register PARAMS ((int regno));
  70
  71 static void gdbsim_kill PARAMS ((void));
  72
  73 static void gdbsim_load PARAMS ((char *prog, int fromtty));
  74
  75 static void gdbsim_create_inferior PARAMS ((char *exec_file, char *args, char **env));
  76
  77 static void gdbsim_open PARAMS ((char *args, int from_tty));
  78
  79 static void gdbsim_close PARAMS ((int quitting));
  80
  81 static void gdbsim_detach PARAMS ((char *args, int from_tty));
  82
  83 static void gdbsim_resume PARAMS ((int pid, int step, enum target_signal siggnal));
  84
  85 static int gdbsim_wait PARAMS ((int pid, struct target_waitstatus *status));
  86
  87 static void gdbsim_prepare_to_store PARAMS ((void));
  88
  89 static int gdbsim_xfer_inferior_memory PARAMS ((CORE_ADDR memaddr,
  90                                                 char *myaddr, int len,
  91                                                 int write,
  92                                                 struct target_ops *target));
  93
  94 static void gdbsim_files_info PARAMS ((struct target_ops *target));
  95
  96 static void gdbsim_mourn_inferior PARAMS ((void));
  97
  98 static void gdbsim_stop PARAMS ((void));
  99
 100 static void simulator_command PARAMS ((char *args, int from_tty));
 101
 102 /* Naming convention:
 103
 104    sim_* are the interface to the simulator (see remote-sim.h).
 105    gdbsim_* are stuff which is internal to gdb.  */
 106
 107 /* Forward data declarations */
 108 extern struct target_ops gdbsim_ops;
 109
 110 static int program_loaded = 0;
 111
 112 /* We must keep track of whether the simulator has been opened or not because
 113    GDB can call a target's close routine twice, but sim_close doesn't allow
 114    this.  We also need to record the result of sim_open so we can pass it
 115    back to the other sim_foo routines.  */
 116 static SIM_DESC gdbsim_desc = 0;
 117
 118 static void
 119 dump_mem (buf, len)
 120      char *buf;
 121      int len;
 122 {
 123   if (len <= 8)
 124     {
 125       if (len == 8 || len == 4)
 126         {
 127           long l[2];
 128           memcpy (l, buf, len);
 129           printf_filtered ("\t0x%x", l[0]);
 130           printf_filtered (len == 8 ? " 0x%x\n" : "\n", l[1]);
 131         }
 132       else
 133         {
 134           int i;
 135           printf_filtered ("\t");
 136           for (i = 0; i < len; i++)
 137             printf_filtered ("0x%x ", buf[i]);
 138           printf_filtered ("\n");
 139         }
 140     }
 141 }
 142
 143 static host_callback gdb_callback;
 144 static int callbacks_initialized = 0;
 145
 146 /* Initialize gdb_callback.  */
 147
 148 static void
 149 init_callbacks ()
 150 {
 151   if (! callbacks_initialized)
 152     {
 153       gdb_callback = default_callback;
 154       gdb_callback.init (&gdb_callback);
 155       gdb_callback.write_stdout = gdb_os_write_stdout;
 156       gdb_callback.flush_stdout = gdb_os_flush_stdout;
 157       gdb_callback.write_stderr = gdb_os_write_stderr;
 158       gdb_callback.flush_stderr = gdb_os_flush_stderr;
 159       gdb_callback.printf_filtered = gdb_os_printf_filtered;
 160       gdb_callback.vprintf_filtered = gdb_os_vprintf_filtered;
 161       gdb_callback.evprintf_filtered = gdb_os_evprintf_filtered;
 162       gdb_callback.error = gdb_os_error;
 163       gdb_callback.poll_quit = gdb_os_poll_quit;
 164       gdb_callback.magic = HOST_CALLBACK_MAGIC;
 165       callbacks_initialized = 1;
 166     }
 167 }
 168
 169 /* Release callbacks (free resources used by them).  */
 170
 171 static void
 172 end_callbacks ()
 173 {
 174   if (callbacks_initialized)
 175     {
 176       gdb_callback.shutdown (&gdb_callback);
 177       callbacks_initialized = 0;
 178     }
 179 }
 180
 181 /* GDB version of os_write_stdout callback.  */
 182
 183 static int
 184 gdb_os_write_stdout (p, buf, len)
 185      host_callback *p;
 186      const char *buf;
 187      int len;
 188 {
 189   int i;
 190   char b[2];
 191
 192   for (i = 0; i < len; i++)
 193     {
 194       b[0] = buf[i];
 195       b[1] = 0;
 196       if (target_output_hook)
 197         target_output_hook (b);
 198       else
 199         fputs_filtered (b, gdb_stdout);
 200     }
 201   return len;
 202 }
 203
 204 /* GDB version of os_flush_stdout callback.  */
 205
 206 static void
 207 gdb_os_flush_stdout (p)
 208      host_callback *p;
 209 {
 210   gdb_flush (gdb_stdout);
 211 }
 212
 213 /* GDB version of os_write_stderr callback.  */
 214
 215 static int
 216 gdb_os_write_stderr (p, buf, len)
 217      host_callback *p;
 218      const char *buf;
 219      int len;
 220 {
 221   int i;
 222   char b[2];
 223
 224   for (i = 0; i < len; i++)
 225     {
 226       b[0] = buf[i];
 227       b[1] = 0;
 228       if (target_output_hook)
 229         target_output_hook (b);
 230       else
 231         fputs_filtered (b, gdb_stderr);
 232     }
 233   return len;
 234 }
 235
 236 /* GDB version of os_flush_stderr callback.  */
 237
 238 static void
 239 gdb_os_flush_stderr (p)
 240      host_callback *p;
 241 {
 242   gdb_flush (gdb_stderr);
 243 }
 244
 245 /* GDB version of printf_filtered callback.  */
 246
 247 /* VARARGS */
 248 static void
 249 #ifdef ANSI_PROTOTYPES
 250 gdb_os_printf_filtered (host_callback *p, const char *format, ...)
 251 #else
 252 gdb_os_printf_filtered (p, va_alist)
 253      host_callback *p;
 254      va_dcl
 255 #endif
 256 {
 257   va_list args;
 258 #ifdef ANSI_PROTOTYPES
 259   va_start (args, format);
 260 #else
 261   char *format;
 262
 263   va_start (args);
 264   format = va_arg (args, char *);
 265 #endif
 266
 267   vfprintf_filtered (gdb_stdout, format, args);
 268
 269   va_end (args);
 270 }
 271
 272 /* GDB version of error vprintf_filtered.  */
 273
 274 /* VARARGS */
 275 static void
 276 #ifdef ANSI_PROTOTYPES
 277 gdb_os_vprintf_filtered (host_callback *p, const char *format, va_list ap)
 278 #else
 279 gdb_os_vprintf_filtered (p, format, ap)
 280      host_callback *p;
 281      char *format;
 282      va_list ap;
 283 #endif
 284 {
 285   vfprintf_filtered (gdb_stdout, format, ap);
 286 }
 287
 288 /* GDB version of error evprintf_filtered.  */
 289
 290 /* VARARGS */
 291 static void
 292 #ifdef ANSI_PROTOTYPES
 293 gdb_os_evprintf_filtered (host_callback *p, const char *format, va_list ap)
 294 #else
 295 gdb_os_evprintf_filtered (p, format, ap)
 296      host_callback *p;
 297      char *format;
 298      va_list ap;
 299 #endif
 300 {
 301   vfprintf_filtered (gdb_stderr, format, ap);
 302 }
 303
 304 /* GDB version of error callback.  */
 305
 306 /* VARARGS */
 307 static void
 308 #ifdef ANSI_PROTOTYPES
 309 gdb_os_error (host_callback *p, const char *format, ...)
 310 #else
 311 gdb_os_error (p, va_alist)
 312      host_callback *p;
 313      va_dcl
 314 #endif
 315 {
 316   if (error_hook)
 317     (*error_hook) ();
 318   else
 319     {
 320       va_list args;
 321 #ifdef ANSI_PROTOTYPES
 322       va_start (args, format);
 323 #else
 324       char *format;
 325
 326       va_start (args);
 327       format = va_arg (args, char *);
 328 #endif
 329
 330       error_begin ();
 331       vfprintf_filtered (gdb_stderr, format, args);
 332       fprintf_filtered (gdb_stderr, "\n");
 333       va_end (args);
 334       return_to_top_level (RETURN_ERROR);
 335     }
 336 }
 337
 338 static void
 339 gdbsim_fetch_register (regno)
 340 int regno;
 341 {
 342   if (regno == -1)
 343     {
 344       for (regno = 0; regno < NUM_REGS; regno++)
 345         gdbsim_fetch_register (regno);
 346     }
 347   else if (reg_names[regno] != NULL && *reg_names[regno] != '\0')
 348     {
 349       char buf[MAX_REGISTER_RAW_SIZE];
 350
 351       sim_fetch_register (gdbsim_desc, regno, buf);
 352       supply_register (regno, buf);
 353       if (sr_get_debug ())
 354         {
 355           printf_filtered ("gdbsim_fetch_register: %d", regno);
 356           /* FIXME: We could print something more intelligible.  */
 357           dump_mem (buf, REGISTER_RAW_SIZE (regno));
 358         }
 359     }
 360 }
 361
 362
 363 static void
 364 gdbsim_store_register (regno)
 365 int regno;
 366 {
 367   if (regno  == -1)
 368     {
 369       for (regno = 0; regno < NUM_REGS; regno++)
 370         gdbsim_store_register (regno);
 371     }
 372   else if (reg_names[regno] != NULL && *reg_names[regno] != '\0')
 373     {
 374       /* FIXME: Until read_register() returns LONGEST, we have this.  */
 375       char tmp[MAX_REGISTER_RAW_SIZE];
 376       read_register_gen (regno, tmp);
 377       sim_store_register (gdbsim_desc, regno, tmp);
 378       if (sr_get_debug ())
 379         {
 380           printf_filtered ("gdbsim_store_register: %d", regno);
 381           /* FIXME: We could print something more intelligible.  */
 382           dump_mem (tmp, REGISTER_RAW_SIZE (regno));
 383         }
 384     }
 385 }
 386
 387 /* Kill the running program.  This may involve closing any open files
 388    and releasing other resources acquired by the simulated program.  */
 389
 390 static void
 391 gdbsim_kill ()
 392 {
 393   if (sr_get_debug ())
 394     printf_filtered ("gdbsim_kill\n");
 395
 396   /* There is no need to `kill' running simulator - the simulator is
 397      not running */
 398   inferior_pid = 0;
 399 }
 400
 401 /* Load an executable file into the target process.  This is expected to
 402    not only bring new code into the target process, but also to update
 403    GDB's symbol tables to match.  */
 404
 405 static void
 406 gdbsim_load (prog, fromtty)
 407      char *prog;
 408      int fromtty;
 409 {
 410   if (sr_get_debug ())
 411     printf_filtered ("gdbsim_load: prog \"%s\"\n", prog);
 412
 413   inferior_pid = 0;
 414
 415   /* FIXME: We will print two messages on error.
 416      Need error to either not print anything if passed NULL or need
 417      another routine that doesn't take any arguments.  */
 418   if (sim_load (gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL)
 419     error ("unable to load program");
 420
 421   /* FIXME: If a load command should reset the targets registers then
 422      a call to sim_create_inferior() should go here. */
 423
 424   program_loaded = 1;
 425 }
 426
 427
 428 /* Start an inferior process and set inferior_pid to its pid.
 429    EXEC_FILE is the file to run.
 430    ARGS is a string containing the arguments to the program.
 431    ENV is the environment vector to pass.  Errors reported with error().
 432    On VxWorks and various standalone systems, we ignore exec_file.  */
 433 /* This is called not only when we first attach, but also when the
 434    user types "run" after having attached.  */
 435
 436 static void
 437 gdbsim_create_inferior (exec_file, args, env)
 438      char *exec_file;
 439      char *args;
 440      char **env;
 441 {
 442   int len;
 443   char *arg_buf,**argv;
 444
 445   if (exec_file == 0 || exec_bfd == 0)
 446     warning ("No exec file specified.");
 447   if (! program_loaded)
 448     warning ("No program loaded.");
 449
 450   if (sr_get_debug ())
 451     printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
 452                      (exec_file ? exec_file: "(NULL)"),
 453                      args);
 454
 455   gdbsim_kill ();
 456   remove_breakpoints ();
 457   init_wait_for_inferior ();
 458
 459   if (exec_file != NULL)
 460     {
 461       len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop*/ 10;
 462       arg_buf = (char *) alloca (len);
 463       arg_buf[0] = '\0';
 464       strcat (arg_buf, exec_file);
 465       strcat (arg_buf, " ");
 466       strcat (arg_buf, args);
 467       argv = buildargv (arg_buf);
 468       make_cleanup (freeargv, (char *) argv);
 469     }
 470   else
 471     argv = NULL;
 472   sim_create_inferior (gdbsim_desc, exec_bfd, argv, env);
 473
 474   inferior_pid = 42;
 475   insert_breakpoints (); /* Needed to get correct instruction in cache */
 476
 477   clear_proceed_status ();
 478
 479   /* NB: Entry point already set by sim_create_inferior. */
 480   proceed ((CORE_ADDR)-1, TARGET_SIGNAL_DEFAULT, 0);
 481 }
 482
 483 /* The open routine takes the rest of the parameters from the command,
 484    and (if successful) pushes a new target onto the stack.
 485    Targets should supply this routine, if only to provide an error message.  */
 486 /* Called when selecting the simulator. EG: (gdb) target sim name.  */
 487
 488 static void
 489 gdbsim_open (args, from_tty)
 490      char *args;
 491      int from_tty;
 492 {
 493   int len;
 494   char *arg_buf;
 495   char **argv;
 496
 497   if (sr_get_debug ())
 498     printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
 499
 500   /* Remove current simulator if one exists.  Only do this if the simulator
 501      has been opened because sim_close requires it.
 502      This is important because the call to push_target below will cause
 503      sim_close to be called if the simulator is already open, but push_target
 504      is called after sim_open!  We can't move the call to push_target before
 505      the call to sim_open because sim_open may invoke `error'.  */
 506   if (gdbsim_desc != NULL)
 507     unpush_target (&gdbsim_ops);
 508
 509   len = (7 + 1 /* gdbsim */
 510          + strlen (" -E little")
 511          + strlen (" --architecture=xxxxxxxxxx")
 512          + (args ? strlen (args) : 0)
 513          + 50) /* slack */;
 514   arg_buf = (char *) alloca (len);
 515   strcpy (arg_buf, "gdbsim"); /* 7 */
 516   /* Specify the byte order for the target when it is both selectable
 517      and explicitly specified by the user (not auto detected). */
 518 #ifdef TARGET_BYTE_ORDER_SELECTABLE
 519   if (!target_byte_order_auto)
 520     {
 521       switch (TARGET_BYTE_ORDER)
 522         {
 523         case BIG_ENDIAN:
 524           strcat (arg_buf, " -E big");
 525           break;
 526         case LITTLE_ENDIAN:
 527           strcat (arg_buf, " -E little");
 528           break;
 529         default:
 530           fatal ("Value of TARGET_BYTE_ORDER unknown");
 531         }
 532     }
 533 #endif
 534   /* Specify the architecture of the target when it has been
 535      explicitly specified */
 536   if (!target_architecture_auto)
 537     {
 538       strcat (arg_buf, " --architecture=");
 539       strcat (arg_buf, target_architecture->printable_name);
 540     }
 541   /* finally, any explicit args */
 542   if (args)
 543     {
 544       strcat (arg_buf, " "); /* 1 */
 545       strcat (arg_buf, args);
 546     }
 547   argv = buildargv (arg_buf);
 548   if (argv == NULL)
 549     error ("Insufficient memory available to allocate simulator arg list.");
 550   make_cleanup (freeargv, (char *) argv);
 551
 552   init_callbacks ();
 553   gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, argv);
 554
 555   if (gdbsim_desc == 0)
 556     error ("unable to create simulator instance");
 557
 558   push_target (&gdbsim_ops);
 559   target_fetch_registers (-1);
 560   printf_filtered ("Connected to the simulator.\n");
 561 }
 562
 563 /* Does whatever cleanup is required for a target that we are no longer
 564    going to be calling.  Argument says whether we are quitting gdb and
 565    should not get hung in case of errors, or whether we want a clean
 566    termination even if it takes a while.  This routine is automatically
 567    always called just before a routine is popped off the target stack.
 568    Closing file descriptors and freeing memory are typical things it should
 569    do.  */
 570 /* Close out all files and local state before this target loses control. */
 571
 572 static void
 573 gdbsim_close (quitting)
 574      int quitting;
 575 {
 576   if (sr_get_debug ())
 577     printf_filtered ("gdbsim_close: quitting %d\n", quitting);
 578
 579   program_loaded = 0;
 580
 581   if (gdbsim_desc != NULL)
 582     {
 583       sim_close (gdbsim_desc, quitting);
 584       gdbsim_desc = NULL;
 585     }
 586
 587   end_callbacks ();
 588 }
 589
 590 /* Takes a program previously attached to and detaches it.
 591    The program may resume execution (some targets do, some don't) and will
 592    no longer stop on signals, etc.  We better not have left any breakpoints
 593    in the program or it'll die when it hits one.  ARGS is arguments
 594    typed by the user (e.g. a signal to send the process).  FROM_TTY
 595    says whether to be verbose or not.  */
 596 /* Terminate the open connection to the remote debugger.
 597    Use this when you want to detach and do something else with your gdb.  */
 598
 599 static void
 600 gdbsim_detach (args,from_tty)
 601      char *args;
 602      int from_tty;
 603 {
 604   if (sr_get_debug ())
 605     printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
 606
 607   pop_target ();                /* calls gdbsim_close to do the real work */
 608   if (from_tty)
 609     printf_filtered ("Ending simulator %s debugging\n", target_shortname);
 610 }
 611
 612 /* Resume execution of the target process.  STEP says whether to single-step
 613    or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
 614    to the target, or zero for no signal.  */
 615
 616 static enum target_signal resume_siggnal;
 617 static int resume_step;
 618
 619 static void
 620 gdbsim_resume (pid, step, siggnal)
 621      int pid, step;
 622      enum target_signal siggnal;
 623 {
 624   if (inferior_pid != 42)
 625     error ("The program is not being run.");
 626
 627   if (sr_get_debug ())
 628     printf_filtered ("gdbsim_resume: step %d, signal %d\n", step, siggnal);
 629
 630   resume_siggnal = siggnal;
 631   resume_step = step;
 632 }
 633
 634 /* Notify the simulator of an asynchronous request to stop.
 635
 636    The simulator shall ensure that the stop request is eventually
 637    delivered to the simulator.  If the call is made while the
 638    simulator is not running then the stop request is processed when
 639    the simulator is next resumed.
 640
 641    For simulators that do not support this operation, just abort */
 642
 643 static void
 644 gdbsim_stop ()
 645 {
 646   if (! sim_stop (gdbsim_desc))
 647     {
 648       quit ();
 649     }
 650 }
 651
 652 /* GDB version of os_poll_quit callback.
 653    Taken from gdb/util.c - should be in a library */
 654
 655 static int
 656 gdb_os_poll_quit (p)
 657      host_callback *p;
 658 {
 659   notice_quit ();
 660   if (quit_flag) /* gdb's idea of quit */
 661     {
 662       quit_flag = 0; /* we've stolen it */
 663       return 1;
 664     }
 665   else if (immediate_quit)
 666     {
 667       return 1;
 668     }
 669   return 0;
 670 }
 671
 672 /* Wait for inferior process to do something.  Return pid of child,
 673    or -1 in case of error; store status through argument pointer STATUS,
 674    just as `wait' would. */
 675
 676 static void
 677 gdbsim_cntrl_c (signo)
 678      int signo;
 679 {
 680   gdbsim_stop ();
 681 }
 682
 683 static int
 684 gdbsim_wait (pid, status)
 685      int pid;
 686      struct target_waitstatus *status;
 687 {
 688   static RETSIGTYPE (*prev_sigint) ();
 689   int sigrc = 0;
 690   enum sim_stop reason = sim_running;
 691
 692   if (sr_get_debug ())
 693     printf_filtered ("gdbsim_wait\n");
 694
 695 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
 696   {
 697     struct sigaction sa, osa;
 698     sa.sa_handler = gdbsim_cntrl_c;
 699     sigemptyset (&sa.sa_mask);
 700     sa.sa_flags = 0;
 701     sigaction (SIGINT, &sa, &osa);
 702     prev_sigint = osa.sa_handler;
 703   }
 704 #else
 705   prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
 706 #endif
 707   sim_resume (gdbsim_desc, resume_step,
 708               target_signal_to_host (resume_siggnal));
 709   signal (SIGINT, prev_sigint);
 710   resume_step = 0;
 711
 712   sim_stop_reason (gdbsim_desc, &reason, &sigrc);
 713
 714   switch (reason)
 715     {
 716     case sim_exited:
 717       status->kind = TARGET_WAITKIND_EXITED;
 718       status->value.integer = sigrc;
 719       break;
 720     case sim_stopped:
 721       switch (sigrc)
 722         {
 723         case SIGABRT:
 724           quit ();
 725           break;
 726         case SIGINT:
 727         case SIGTRAP:
 728         default:
 729           status->kind = TARGET_WAITKIND_STOPPED;
 730           /* The signal in sigrc is a host signal.  That probably
 731              should be fixed.  */
 732           status->value.sig = target_signal_from_host (sigrc);
 733           break;
 734         }
 735       break;
 736     case sim_signalled:
 737       status->kind = TARGET_WAITKIND_SIGNALLED;
 738       /* The signal in sigrc is a host signal.  That probably
 739          should be fixed.  */
 740       status->value.sig = target_signal_from_host (sigrc);
 741       break;
 742     case sim_running:
 743     case sim_polling:
 744       /* FIXME: Is this correct? */
 745       break;
 746     }
 747
 748   return inferior_pid;
 749 }
 750
 751 /* Get ready to modify the registers array.  On machines which store
 752    individual registers, this doesn't need to do anything.  On machines
 753    which store all the registers in one fell swoop, this makes sure
 754    that registers contains all the registers from the program being
 755    debugged.  */
 756
 757 static void
 758 gdbsim_prepare_to_store ()
 759 {
 760   /* Do nothing, since we can store individual regs */
 761 }
 762
 763 static int
 764 gdbsim_xfer_inferior_memory (memaddr, myaddr, len, write, target)
 765      CORE_ADDR memaddr;
 766      char *myaddr;
 767      int len;
 768      int write;
 769      struct target_ops *target;                 /* ignored */
 770 {
 771   if (! program_loaded)
 772     error ("No program loaded.");
 773
 774   if (sr_get_debug ())
 775     {
 776       printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x%x, memaddr 0x%x, len %d, write %d\n",
 777                        myaddr, memaddr, len, write);
 778       if (sr_get_debug () && write)
 779         dump_mem(myaddr, len);
 780     }
 781
 782   if (write)
 783     {
 784       len = sim_write (gdbsim_desc, memaddr, myaddr, len);
 785     }
 786   else
 787     {
 788       len = sim_read (gdbsim_desc, memaddr, myaddr, len);
 789       if (sr_get_debug () && len > 0)
 790         dump_mem(myaddr, len);
 791     }
 792   return len;
 793 }
 794
 795 static void
 796 gdbsim_files_info (target)
 797      struct target_ops *target;
 798 {
 799   char *file = "nothing";
 800
 801   if (exec_bfd)
 802     file = bfd_get_filename (exec_bfd);
 803
 804   if (sr_get_debug ())
 805     printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
 806
 807   if (exec_bfd)
 808     {
 809       printf_filtered ("\tAttached to %s running program %s\n",
 810                        target_shortname, file);
 811       sim_info (gdbsim_desc, 0);
 812     }
 813 }
 814
 815 /* Clear the simulator's notion of what the break points are.  */
 816
 817 static void
 818 gdbsim_mourn_inferior ()
 819 {
 820   if (sr_get_debug ())
 821     printf_filtered ("gdbsim_mourn_inferior:\n");
 822
 823   remove_breakpoints ();
 824   generic_mourn_inferior ();
 825 }
 826
 827 static int
 828 gdbsim_insert_breakpoint (addr, contents_cache)
 829      CORE_ADDR addr;
 830      char *contents_cache;
 831 {
 832 #ifdef SIM_HAS_BREAKPOINTS
 833   SIM_RC retcode;
 834
 835   retcode = sim_set_breakpoint (gdbsim_desc, addr);
 836
 837   switch (retcode)
 838     {
 839     case SIM_RC_OK:
 840       return 0;
 841     case SIM_RC_INSUFFICIENT_RESOURCES:
 842       return ENOMEM;
 843     default:
 844       return EIO;
 845     }
 846 #else
 847   return memory_insert_breakpoint (addr, contents_cache);
 848 #endif
 849 }
 850
 851 static int
 852 gdbsim_remove_breakpoint (addr, contents_cache)
 853      CORE_ADDR addr;
 854      char *contents_cache;
 855 {
 856 #ifdef SIM_HAS_BREAKPOINTS
 857   SIM_RC retcode;
 858
 859   retcode = sim_clear_breakpoint (gdbsim_desc, addr);
 860
 861   switch (retcode)
 862     {
 863     case SIM_RC_OK:
 864     case SIM_RC_UNKNOWN_BREAKPOINT:
 865       return 0;
 866     case SIM_RC_INSUFFICIENT_RESOURCES:
 867       return ENOMEM;
 868     default:
 869       return EIO;
 870     }
 871 #else
 872   return memory_remove_breakpoint (addr, contents_cache);
 873 #endif
 874 }
 875
 876 /* Pass the command argument through to the simulator verbatim.  The
 877    simulator must do any command interpretation work.  */
 878
 879 static void
 880 simulator_command (args, from_tty)
 881      char *args;
 882      int from_tty;
 883 {
 884   if (gdbsim_desc == NULL)
 885     {
 886
 887       /* PREVIOUSLY: The user may give a command before the simulator
 888          is opened. [...] (??? assuming of course one wishes to
 889          continue to allow commands to be sent to unopened simulators,
 890          which isn't entirely unreasonable). */
 891
 892       /* The simulator is a builtin abstraction of a remote target.
 893          Consistent with that model, access to the simulator, via sim
 894          commands, is restricted to the period when the channel to the
 895          simulator is open. */
 896
 897       error ("Not connected to the simulator target");
 898     }
 899
 900   sim_do_command (gdbsim_desc, args);
 901 }
 902
 903 /* Define the target subroutine names */
 904
 905 struct target_ops gdbsim_ops = {
 906   "sim",                        /* to_shortname */
 907   "simulator",                  /* to_longname */
 908   "Use the compiled-in simulator.",  /* to_doc */
 909   gdbsim_open,                  /* to_open */
 910   gdbsim_close,                 /* to_close */
 911   NULL,                         /* to_attach */
 912   gdbsim_detach,                /* to_detach */
 913   gdbsim_resume,                /* to_resume */
 914   gdbsim_wait,                  /* to_wait */
 915   gdbsim_fetch_register,        /* to_fetch_registers */
 916   gdbsim_store_register,        /* to_store_registers */
 917   gdbsim_prepare_to_store,      /* to_prepare_to_store */
 918   gdbsim_xfer_inferior_memory,  /* to_xfer_memory */
 919   gdbsim_files_info,            /* to_files_info */
 920   gdbsim_insert_breakpoint,     /* to_insert_breakpoint */
 921   gdbsim_remove_breakpoint,     /* to_remove_breakpoint */
 922   NULL,                         /* to_terminal_init */
 923   NULL,                         /* to_terminal_inferior */
 924   NULL,                         /* to_terminal_ours_for_output */
 925   NULL,                         /* to_terminal_ours */
 926   NULL,                         /* to_terminal_info */
 927   gdbsim_kill,                  /* to_kill */
 928   gdbsim_load,                  /* to_load */
 929   NULL,                         /* to_lookup_symbol */
 930   gdbsim_create_inferior,       /* to_create_inferior */
 931   gdbsim_mourn_inferior,        /* to_mourn_inferior */
 932   0,                            /* to_can_run */
 933   0,                            /* to_notice_signals */
 934   0,                            /* to_thread_alive */
 935   gdbsim_stop,                  /* to_stop */
 936   process_stratum,              /* to_stratum */
 937   NULL,                         /* to_next */
 938   1,                            /* to_has_all_memory */
 939   1,                            /* to_has_memory */
 940   1,                            /* to_has_stack */
 941   1,                            /* to_has_registers */
 942   1,                            /* to_has_execution */
 943   NULL,                         /* sections */
 944   NULL,                         /* sections_end */
 945   OPS_MAGIC,                    /* to_magic */
 946 };
 947
 948 void
 949 _initialize_remote_sim ()
 950 {
 951   add_target (&gdbsim_ops);
 952
 953   add_com ("sim <command>", class_obscure, simulator_command,
 954            "Send a command to the simulator.");
 955 }