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
  39 /* Prototypes */
  40
  41 static void dump_mem PARAMS ((char *buf, int len));
  42
  43 static void init_callbacks PARAMS ((void));
  44
  45 static void end_callbacks PARAMS ((void));
  46
  47 static int gdb_os_write_stdout PARAMS ((host_callback *, const char *, int));
  48
  49 static void gdb_os_flush_stdout PARAMS ((host_callback *));
  50
  51 static int gdb_os_write_stderr PARAMS ((host_callback *, const char *, int));
  52
  53 static void gdb_os_flush_stderr PARAMS ((host_callback *));
  54
  55 /* printf_filtered is depreciated */
  56 static void gdb_os_printf_filtered PARAMS ((host_callback *, const char *, ...));
  57
  58 static void gdb_os_vprintf_filtered PARAMS ((host_callback *, const char *, va_list));
  59
  60 static void gdb_os_evprintf_filtered PARAMS ((host_callback *, const char *, va_list));
  61
  62 static void gdb_os_error PARAMS ((host_callback *, const char *, ...));
  63
  64 static void gdbsim_fetch_register PARAMS ((int regno));
  65
  66 static void gdbsim_store_register PARAMS ((int regno));
  67
  68 static void gdbsim_kill PARAMS ((void));
  69
  70 static void gdbsim_load PARAMS ((char *prog, int fromtty));
  71
  72 static void gdbsim_create_inferior PARAMS ((char *exec_file, char *args, char **env));
  73
  74 static void gdbsim_open PARAMS ((char *args, int from_tty));
  75
  76 static void gdbsim_close PARAMS ((int quitting));
  77
  78 static void gdbsim_detach PARAMS ((char *args, int from_tty));
  79
  80 static void gdbsim_resume PARAMS ((int pid, int step, enum target_signal siggnal));
  81
  82 static int gdbsim_wait PARAMS ((int pid, struct target_waitstatus *status));
  83
  84 static void gdbsim_prepare_to_store PARAMS ((void));
  85
  86 static int gdbsim_xfer_inferior_memory PARAMS ((CORE_ADDR memaddr,
  87                                                 char *myaddr, int len,
  88                                                 int write,
  89                                                 struct target_ops *target));
  90
  91 static void gdbsim_files_info PARAMS ((struct target_ops *target));
  92
  93 static void gdbsim_mourn_inferior PARAMS ((void));
  94
  95 static void simulator_command PARAMS ((char *args, int from_tty));
  96
  97 /* Naming convention:
  98
  99    sim_* are the interface to the simulator (see remote-sim.h).
 100    gdbsim_* are stuff which is internal to gdb.  */
 101
 102 /* Forward data declarations */
 103 extern struct target_ops gdbsim_ops;
 104
 105 static int program_loaded = 0;
 106
 107 /* We must keep track of whether the simulator has been opened or not because
 108    GDB can call a target's close routine twice, but sim_close doesn't allow
 109    this.  We also need to record the result of sim_open so we can pass it
 110    back to the other sim_foo routines.  */
 111 static SIM_DESC gdbsim_desc = 0;
 112
 113 static void
 114 dump_mem (buf, len)
 115      char *buf;
 116      int len;
 117 {
 118   if (len <= 8)
 119     {
 120       if (len == 8 || len == 4)
 121         {
 122           long l[2];
 123           memcpy (l, buf, len);
 124           printf_filtered ("\t0x%x", l[0]);
 125           printf_filtered (len == 8 ? " 0x%x\n" : "\n", l[1]);
 126         }
 127       else
 128         {
 129           int i;
 130           printf_filtered ("\t");
 131           for (i = 0; i < len; i++)
 132             printf_filtered ("0x%x ", buf[i]);
 133           printf_filtered ("\n");
 134         }
 135     }
 136 }
 137
 138 static host_callback gdb_callback;
 139 static int callbacks_initialized = 0;
 140
 141 /* Initialize gdb_callback.  */
 142
 143 static void
 144 init_callbacks ()
 145 {
 146   if (! callbacks_initialized)
 147     {
 148       gdb_callback = default_callback;
 149       gdb_callback.init (&gdb_callback);
 150       gdb_callback.write_stdout = gdb_os_write_stdout;
 151       gdb_callback.flush_stdout = gdb_os_flush_stdout;
 152       gdb_callback.write_stderr = gdb_os_write_stderr;
 153       gdb_callback.flush_stderr = gdb_os_flush_stderr;
 154       gdb_callback.printf_filtered = gdb_os_printf_filtered;
 155       gdb_callback.vprintf_filtered = gdb_os_vprintf_filtered;
 156       gdb_callback.evprintf_filtered = gdb_os_evprintf_filtered;
 157       gdb_callback.error = gdb_os_error;
 158       sim_set_callbacks (gdbsim_desc, &gdb_callback);
 159       callbacks_initialized = 1;
 160     }
 161 }
 162
 163 /* Release callbacks (free resources used by them).  */
 164
 165 static void
 166 end_callbacks ()
 167 {
 168   if (callbacks_initialized)
 169     {
 170       gdb_callback.shutdown (&gdb_callback);
 171       callbacks_initialized = 0;
 172     }
 173 }
 174
 175 /* GDB version of os_write_stdout callback.  */
 176
 177 static int
 178 gdb_os_write_stdout (p, buf, len)
 179      host_callback *p;
 180      const char *buf;
 181      int len;
 182 {
 183   int i;
 184   char b[2];
 185
 186   for (i = 0; i < len; i++)
 187     {
 188       b[0] = buf[i];
 189       b[1] = 0;
 190       if (target_output_hook)
 191         target_output_hook (b);
 192       else
 193         fputs_filtered (b, gdb_stdout);
 194     }
 195   return len;
 196 }
 197
 198 /* GDB version of os_flush_stdout callback.  */
 199
 200 static void
 201 gdb_os_flush_stdout (p)
 202      host_callback *p;
 203 {
 204   gdb_flush (gdb_stdout);
 205 }
 206
 207 /* GDB version of os_write_stderr callback.  */
 208
 209 static int
 210 gdb_os_write_stderr (p, buf, len)
 211      host_callback *p;
 212      const char *buf;
 213      int len;
 214 {
 215   int i;
 216   char b[2];
 217
 218   for (i = 0; i < len; i++)
 219     {
 220       b[0] = buf[i];
 221       b[1] = 0;
 222       if (target_output_hook)
 223         target_output_hook (b);
 224       else
 225         fputs_filtered (b, gdb_stderr);
 226     }
 227   return len;
 228 }
 229
 230 /* GDB version of os_flush_stderr callback.  */
 231
 232 static void
 233 gdb_os_flush_stderr (p)
 234      host_callback *p;
 235 {
 236   gdb_flush (gdb_stderr);
 237 }
 238
 239 /* GDB version of printf_filtered callback.  */
 240
 241 /* VARARGS */
 242 static void
 243 #ifdef ANSI_PROTOTYPES
 244 gdb_os_printf_filtered (host_callback *p, const char *format, ...)
 245 #else
 246 gdb_os_printf_filtered (p, va_alist)
 247      host_callback *p;
 248      va_dcl
 249 #endif
 250 {
 251   va_list args;
 252 #ifdef ANSI_PROTOTYPES
 253   va_start (args, format);
 254 #else
 255   char *format;
 256
 257   va_start (args);
 258   format = va_arg (args, char *);
 259 #endif
 260
 261   vfprintf_filtered (gdb_stdout, format, args);
 262
 263   va_end (args);
 264 }
 265
 266 /* GDB version of error vprintf_filtered.  */
 267
 268 /* VARARGS */
 269 static void
 270 #ifdef ANSI_PROTOTYPES
 271 gdb_os_vprintf_filtered (host_callback *p, const char *format, va_list ap)
 272 #else
 273 gdb_os_vprintf_filtered (p, format, ap)
 274      host_callback *p;
 275      char *format;
 276      va_list ap;
 277 #endif
 278 {
 279   vfprintf_filtered (gdb_stdout, format, ap);
 280 }
 281
 282 /* GDB version of error evprintf_filtered.  */
 283
 284 /* VARARGS */
 285 static void
 286 #ifdef ANSI_PROTOTYPES
 287 gdb_os_evprintf_filtered (host_callback *p, const char *format, va_list ap)
 288 #else
 289 gdb_os_evprintf_filtered (p, format, ap)
 290      host_callback *p;
 291      char *format;
 292      va_list ap;
 293 #endif
 294 {
 295   vfprintf_filtered (gdb_stderr, format, ap);
 296 }
 297
 298 /* GDB version of error callback.  */
 299
 300 /* VARARGS */
 301 static void
 302 #ifdef ANSI_PROTOTYPES
 303 gdb_os_error (host_callback *p, const char *format, ...)
 304 #else
 305 gdb_os_error (p, va_alist)
 306      host_callback *p;
 307      va_dcl
 308 #endif
 309 {
 310   if (error_hook)
 311     (*error_hook) ();
 312   else
 313     {
 314       va_list args;
 315 #ifdef ANSI_PROTOTYPES
 316       va_start (args, format);
 317 #else
 318       char *format;
 319
 320       va_start (args);
 321       format = va_arg (args, char *);
 322 #endif
 323
 324       error_begin ();
 325       vfprintf_filtered (gdb_stderr, format, args);
 326       fprintf_filtered (gdb_stderr, "\n");
 327       va_end (args);
 328       return_to_top_level (RETURN_ERROR);
 329     }
 330 }
 331
 332 static void
 333 gdbsim_fetch_register (regno)
 334 int regno;
 335 {
 336   if (regno == -1)
 337     {
 338       for (regno = 0; regno < NUM_REGS; regno++)
 339         gdbsim_fetch_register (regno);
 340     }
 341   else
 342     {
 343       char buf[MAX_REGISTER_RAW_SIZE];
 344
 345       sim_fetch_register (gdbsim_desc, regno, buf);
 346       supply_register (regno, buf);
 347       if (sr_get_debug ())
 348         {
 349           printf_filtered ("gdbsim_fetch_register: %d", regno);
 350           /* FIXME: We could print something more intelligible.  */
 351           dump_mem (buf, REGISTER_RAW_SIZE (regno));
 352         }
 353     }
 354 }
 355
 356
 357 static void
 358 gdbsim_store_register (regno)
 359 int regno;
 360 {
 361   if (regno  == -1)
 362     {
 363       for (regno = 0; regno < NUM_REGS; regno++)
 364         gdbsim_store_register (regno);
 365     }
 366   else
 367     {
 368       /* FIXME: Until read_register() returns LONGEST, we have this.  */
 369       char tmp[MAX_REGISTER_RAW_SIZE];
 370       read_register_gen (regno, tmp);
 371       sim_store_register (gdbsim_desc, regno, tmp);
 372       if (sr_get_debug ())
 373         {
 374           printf_filtered ("gdbsim_store_register: %d", regno);
 375           /* FIXME: We could print something more intelligible.  */
 376           dump_mem (tmp, REGISTER_RAW_SIZE (regno));
 377         }
 378     }
 379 }
 380
 381 /* Kill the running program.  This may involve closing any open files
 382    and releasing other resources acquired by the simulated program.  */
 383
 384 static void
 385 gdbsim_kill ()
 386 {
 387   if (sr_get_debug ())
 388     printf_filtered ("gdbsim_kill\n");
 389
 390   sim_kill (gdbsim_desc);       /* close fd's, remove mappings, etc. */
 391   inferior_pid = 0;
 392 }
 393
 394 /* Load an executable file into the target process.  This is expected to
 395    not only bring new code into the target process, but also to update
 396    GDB's symbol tables to match.  */
 397
 398 static void
 399 gdbsim_load (prog, fromtty)
 400      char *prog;
 401      int fromtty;
 402 {
 403   if (sr_get_debug ())
 404     printf_filtered ("gdbsim_load: prog \"%s\"\n", prog);
 405
 406   inferior_pid = 0;
 407
 408   /* FIXME: We will print two messages on error.
 409      Need error to either not print anything if passed NULL or need
 410      another routine that doesn't take any arguments.  */
 411   if (sim_load (gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL)
 412     error ("unable to load program");
 413
 414   program_loaded = 1;
 415 }
 416
 417
 418 /* Start an inferior process and set inferior_pid to its pid.
 419    EXEC_FILE is the file to run.
 420    ARGS is a string containing the arguments to the program.
 421    ENV is the environment vector to pass.  Errors reported with error().
 422    On VxWorks and various standalone systems, we ignore exec_file.  */
 423 /* This is called not only when we first attach, but also when the
 424    user types "run" after having attached.  */
 425
 426 static void
 427 gdbsim_create_inferior (exec_file, args, env)
 428      char *exec_file;
 429      char *args;
 430      char **env;
 431 {
 432   int len;
 433   char *arg_buf,**argv;
 434   CORE_ADDR entry_pt;
 435
 436   if (! program_loaded)
 437     error ("No program loaded.");
 438
 439   if (sr_get_debug ())
 440     printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
 441       exec_file, args);
 442
 443   if (exec_file == 0 || exec_bfd == 0)
 444    error ("No exec file specified.");
 445
 446   entry_pt = (CORE_ADDR) bfd_get_start_address (exec_bfd);
 447
 448   gdbsim_kill ();
 449   remove_breakpoints ();
 450   init_wait_for_inferior ();
 451
 452   len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop*/ 10;
 453   arg_buf = (char *) alloca (len);
 454   arg_buf[0] = '\0';
 455   strcat (arg_buf, exec_file);
 456   strcat (arg_buf, " ");
 457   strcat (arg_buf, args);
 458   argv = buildargv (arg_buf);
 459   make_cleanup (freeargv, (char *) argv);
 460   sim_create_inferior (gdbsim_desc, argv, env);
 461
 462   inferior_pid = 42;
 463   insert_breakpoints ();        /* Needed to get correct instruction in cache */
 464   proceed (entry_pt, TARGET_SIGNAL_DEFAULT, 0);
 465 }
 466
 467 /* The open routine takes the rest of the parameters from the command,
 468    and (if successful) pushes a new target onto the stack.
 469    Targets should supply this routine, if only to provide an error message.  */
 470 /* Called when selecting the simulator. EG: (gdb) target sim name.  */
 471
 472 static void
 473 gdbsim_open (args, from_tty)
 474      char *args;
 475      int from_tty;
 476 {
 477   int len;
 478   char *arg_buf;
 479   char **argv;
 480
 481   if (sr_get_debug ())
 482     printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
 483
 484   /* Remove current simulator if one exists.  Only do this if the simulator
 485      has been opened because sim_close requires it.
 486      This is important because the call to push_target below will cause
 487      sim_close to be called if the simulator is already open, but push_target
 488      is called after sim_open!  We can't move the call to push_target before
 489      the call to sim_open because sim_open may invoke `error'.  */
 490   if (gdbsim_desc != NULL)
 491     unpush_target (&gdbsim_ops);
 492
 493   init_callbacks ();
 494
 495   len = 7 + 1 + (args ? strlen (args) : 0) + 50;
 496   arg_buf = (char *) alloca (len);
 497   sprintf (arg_buf, "gdbsim%s%s -E %s",
 498            args ? " " : "", args ? args : "",
 499            TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
 500   argv = buildargv (arg_buf);
 501   if (argv == NULL)
 502     error ("Insufficient memory available to allocate simulator arg list.");
 503   make_cleanup (freeargv, (char *) argv);
 504
 505   gdbsim_desc = sim_open (SIM_OPEN_DEBUG, argv);
 506   if (gdbsim_desc == 0)
 507     error ("unable to create simulator instance");
 508
 509   push_target (&gdbsim_ops);
 510   target_fetch_registers (-1);
 511   printf_filtered ("Connected to the simulator.\n");
 512 }
 513
 514 /* Does whatever cleanup is required for a target that we are no longer
 515    going to be calling.  Argument says whether we are quitting gdb and
 516    should not get hung in case of errors, or whether we want a clean
 517    termination even if it takes a while.  This routine is automatically
 518    always called just before a routine is popped off the target stack.
 519    Closing file descriptors and freeing memory are typical things it should
 520    do.  */
 521 /* Close out all files and local state before this target loses control. */
 522
 523 static void
 524 gdbsim_close (quitting)
 525      int quitting;
 526 {
 527   if (sr_get_debug ())
 528     printf_filtered ("gdbsim_close: quitting %d\n", quitting);
 529
 530   program_loaded = 0;
 531
 532   if (gdbsim_desc != NULL)
 533     {
 534       sim_close (gdbsim_desc, quitting);
 535       gdbsim_desc = NULL;
 536     }
 537
 538   end_callbacks ();
 539 }
 540
 541 /* Takes a program previously attached to and detaches it.
 542    The program may resume execution (some targets do, some don't) and will
 543    no longer stop on signals, etc.  We better not have left any breakpoints
 544    in the program or it'll die when it hits one.  ARGS is arguments
 545    typed by the user (e.g. a signal to send the process).  FROM_TTY
 546    says whether to be verbose or not.  */
 547 /* Terminate the open connection to the remote debugger.
 548    Use this when you want to detach and do something else with your gdb.  */
 549
 550 static void
 551 gdbsim_detach (args,from_tty)
 552      char *args;
 553      int from_tty;
 554 {
 555   if (sr_get_debug ())
 556     printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
 557
 558   pop_target ();                /* calls gdbsim_close to do the real work */
 559   if (from_tty)
 560     printf_filtered ("Ending simulator %s debugging\n", target_shortname);
 561 }
 562
 563 /* Resume execution of the target process.  STEP says whether to single-step
 564    or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
 565    to the target, or zero for no signal.  */
 566
 567 static void
 568 gdbsim_resume (pid, step, siggnal)
 569      int pid, step;
 570      enum target_signal siggnal;
 571 {
 572   if (inferior_pid != 42)
 573     error ("The program is not being run.");
 574
 575   if (sr_get_debug ())
 576     printf_filtered ("gdbsim_resume: step %d, signal %d\n", step, siggnal);
 577
 578   sim_resume (gdbsim_desc, step, target_signal_to_host (siggnal));
 579 }
 580
 581 /* Wait for inferior process to do something.  Return pid of child,
 582    or -1 in case of error; store status through argument pointer STATUS,
 583    just as `wait' would.  */
 584
 585 static int
 586 gdbsim_wait (pid, status)
 587      int pid;
 588      struct target_waitstatus *status;
 589 {
 590   int sigrc;
 591   enum sim_stop reason;
 592
 593   if (sr_get_debug ())
 594     printf_filtered ("gdbsim_wait\n");
 595
 596   sim_stop_reason (gdbsim_desc, &reason, &sigrc);
 597   switch (reason)
 598     {
 599     case sim_exited:
 600       status->kind = TARGET_WAITKIND_EXITED;
 601       status->value.integer = sigrc;
 602       break;
 603     case sim_stopped:
 604       status->kind = TARGET_WAITKIND_STOPPED;
 605       /* The signal in sigrc is a host signal.  That probably
 606          should be fixed.  */
 607       status->value.sig = target_signal_from_host (sigrc);
 608       break;
 609     case sim_signalled:
 610       status->kind = TARGET_WAITKIND_SIGNALLED;
 611       /* The signal in sigrc is a host signal.  That probably
 612          should be fixed.  */
 613       status->value.sig = target_signal_from_host (sigrc);
 614       break;
 615     }
 616
 617   return inferior_pid;
 618 }
 619
 620 /* Get ready to modify the registers array.  On machines which store
 621    individual registers, this doesn't need to do anything.  On machines
 622    which store all the registers in one fell swoop, this makes sure
 623    that registers contains all the registers from the program being
 624    debugged.  */
 625
 626 static void
 627 gdbsim_prepare_to_store ()
 628 {
 629   /* Do nothing, since we can store individual regs */
 630 }
 631
 632 static int
 633 gdbsim_xfer_inferior_memory (memaddr, myaddr, len, write, target)
 634      CORE_ADDR memaddr;
 635      char *myaddr;
 636      int len;
 637      int write;
 638      struct target_ops *target;                 /* ignored */
 639 {
 640   if (! program_loaded)
 641     error ("No program loaded.");
 642
 643   if (sr_get_debug ())
 644     {
 645       printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x%x, memaddr 0x%x, len %d, write %d\n",
 646                        myaddr, memaddr, len, write);
 647       if (sr_get_debug () && write)
 648         dump_mem(myaddr, len);
 649     }
 650
 651   if (write)
 652     {
 653       len = sim_write (gdbsim_desc, memaddr, myaddr, len);
 654     }
 655   else
 656     {
 657       len = sim_read (gdbsim_desc, memaddr, myaddr, len);
 658       if (sr_get_debug () && len > 0)
 659         dump_mem(myaddr, len);
 660     }
 661   return len;
 662 }
 663
 664 static void
 665 gdbsim_files_info (target)
 666      struct target_ops *target;
 667 {
 668   char *file = "nothing";
 669
 670   if (exec_bfd)
 671     file = bfd_get_filename (exec_bfd);
 672
 673   if (sr_get_debug ())
 674     printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
 675
 676   if (exec_bfd)
 677     {
 678       printf_filtered ("\tAttached to %s running program %s\n",
 679                        target_shortname, file);
 680       sim_info (gdbsim_desc, 0);
 681     }
 682 }
 683
 684 /* Clear the simulator's notion of what the break points are.  */
 685
 686 static void
 687 gdbsim_mourn_inferior ()
 688 {
 689   if (sr_get_debug ())
 690     printf_filtered ("gdbsim_mourn_inferior:\n");
 691
 692   remove_breakpoints ();
 693   generic_mourn_inferior ();
 694 }
 695
 696 /* Pass the command argument through to the simulator verbatim.  The
 697    simulator must do any command interpretation work.  */
 698
 699 static void
 700 simulator_command (args, from_tty)
 701      char *args;
 702      int from_tty;
 703 {
 704   /* The user may give a command before the simulator is opened, so
 705      ensure that the callbacks have been set up.  */
 706   init_callbacks ();
 707
 708   /* Note that if the simulator hasn't been opened, gdbsim_desc == NULL
 709      which is correct (??? assuming of course one wishes to continue to
 710      allow commands to be sent to unopened simulators, which isn't entirely
 711      unreasonable).  Simulators should be prepared to deal with any
 712      combination of NULL or empty args. */
 713   sim_do_command (gdbsim_desc, args);
 714 }
 715
 716 /* Define the target subroutine names */
 717
 718 struct target_ops gdbsim_ops = {
 719   "sim",                        /* to_shortname */
 720   "simulator",                  /* to_longname */
 721   "Use the compiled-in simulator.",  /* to_doc */
 722   gdbsim_open,                  /* to_open */
 723   gdbsim_close,                 /* to_close */
 724   NULL,                         /* to_attach */
 725   gdbsim_detach,                /* to_detach */
 726   gdbsim_resume,                /* to_resume */
 727   gdbsim_wait,                  /* to_wait */
 728   gdbsim_fetch_register,        /* to_fetch_registers */
 729   gdbsim_store_register,        /* to_store_registers */
 730   gdbsim_prepare_to_store,      /* to_prepare_to_store */
 731   gdbsim_xfer_inferior_memory,  /* to_xfer_memory */
 732   gdbsim_files_info,            /* to_files_info */
 733   memory_insert_breakpoint,     /* to_insert_breakpoint */
 734   memory_remove_breakpoint,     /* to_remove_breakpoint */
 735   NULL,                         /* to_terminal_init */
 736   NULL,                         /* to_terminal_inferior */
 737   NULL,                         /* to_terminal_ours_for_output */
 738   NULL,                         /* to_terminal_ours */
 739   NULL,                         /* to_terminal_info */
 740   gdbsim_kill,                  /* to_kill */
 741   gdbsim_load,                  /* to_load */
 742   NULL,                         /* to_lookup_symbol */
 743   gdbsim_create_inferior,       /* to_create_inferior */
 744   gdbsim_mourn_inferior,        /* to_mourn_inferior */
 745   0,                            /* to_can_run */
 746   0,                            /* to_notice_signals */
 747   0,                            /* to_thread_alive */
 748   0,                            /* to_stop */
 749   process_stratum,              /* to_stratum */
 750   NULL,                         /* to_next */
 751   1,                            /* to_has_all_memory */
 752   1,                            /* to_has_memory */
 753   1,                            /* to_has_stack */
 754   1,                            /* to_has_registers */
 755   1,                            /* to_has_execution */
 756   NULL,                         /* sections */
 757   NULL,                         /* sections_end */
 758   OPS_MAGIC,                    /* to_magic */
 759 };
 760
 761 void
 762 _initialize_remote_sim ()
 763 {
 764   add_target (&gdbsim_ops);
 765
 766   add_com ("sim <command>", class_obscure, simulator_command,
 767            "Send a command to the simulator.");
 768 }