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 ([email protected]).
   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 *, void *));
  59
  60 static void gdb_os_evprintf_filtered PARAMS ((host_callback *, const char *, void *));
  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, void *ap)
 272 #else
 273 gdb_os_vprintf_filtered (p, format, ap)
 274      host_callback *p;
 275      char *format;
 276      void *ap;
 277 #endif
 278 {
 279   vfprintf_filtered (gdb_stdout, format, (va_list)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, void *ap)
 288 #else
 289 gdb_os_evprintf_filtered (p, format, ap)
 290      host_callback *p;
 291      char *format;
 292      void *ap;
 293 #endif
 294 {
 295   vfprintf_filtered (gdb_stderr, format, (va_list)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   /* This must be done before calling gr_load_image.  */
 409   program_loaded = 1;
 410
 411   if (sim_load (gdbsim_desc, prog, fromtty) != 0)
 412     generic_load (prog, fromtty);
 413 }
 414
 415
 416 /* Start an inferior process and set inferior_pid to its pid.
 417    EXEC_FILE is the file to run.
 418    ARGS is a string containing the arguments to the program.
 419    ENV is the environment vector to pass.  Errors reported with error().
 420    On VxWorks and various standalone systems, we ignore exec_file.  */
 421 /* This is called not only when we first attach, but also when the
 422    user types "run" after having attached.  */
 423
 424 static void
 425 gdbsim_create_inferior (exec_file, args, env)
 426      char *exec_file;
 427      char *args;
 428      char **env;
 429 {
 430   int len;
 431   char *arg_buf,**argv;
 432   CORE_ADDR entry_pt;
 433
 434   if (! program_loaded)
 435     error ("No program loaded.");
 436
 437   if (sr_get_debug ())
 438     printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
 439       exec_file, args);
 440
 441   if (exec_file == 0 || exec_bfd == 0)
 442    error ("No exec file specified.");
 443
 444   entry_pt = (CORE_ADDR) bfd_get_start_address (exec_bfd);
 445
 446   gdbsim_kill ();
 447   remove_breakpoints ();
 448   init_wait_for_inferior ();
 449
 450   len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop*/ 10;
 451   arg_buf = (char *) alloca (len);
 452   arg_buf[0] = '\0';
 453   strcat (arg_buf, exec_file);
 454   strcat (arg_buf, " ");
 455   strcat (arg_buf, args);
 456   argv = buildargv (arg_buf);
 457   make_cleanup (freeargv, (char *) argv);
 458   sim_create_inferior (gdbsim_desc, entry_pt, argv, env);
 459
 460   inferior_pid = 42;
 461   insert_breakpoints ();        /* Needed to get correct instruction in cache */
 462   proceed (entry_pt, TARGET_SIGNAL_DEFAULT, 0);
 463 }
 464
 465 /* The open routine takes the rest of the parameters from the command,
 466    and (if successful) pushes a new target onto the stack.
 467    Targets should supply this routine, if only to provide an error message.  */
 468 /* Called when selecting the simulator. EG: (gdb) target sim name.  */
 469
 470 static void
 471 gdbsim_open (args, from_tty)
 472      char *args;
 473      int from_tty;
 474 {
 475   int len;
 476   char *arg_buf;
 477   char **argv;
 478
 479   if (sr_get_debug ())
 480     printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
 481
 482   /* Remove current simulator if one exists.  Only do this if the simulator
 483      has been opened because sim_close requires it.
 484      This is important because the call to push_target below will cause
 485      sim_close to be called if the simulator is already open, but push_target
 486      is called after sim_open!  We can't move the call to push_target before
 487      the call to sim_open because sim_open may invoke `error'.  */
 488   if (gdbsim_desc != NULL)
 489     unpush_target (&gdbsim_ops);
 490
 491   init_callbacks ();
 492
 493   len = 7 + 1 + (args ? strlen (args) : 0) + 1 + /*slop*/ 10;
 494   arg_buf = (char *) alloca (len);
 495   strcpy (arg_buf, "gdbsim");
 496   if (args)
 497     {
 498       strcat (arg_buf, " ");
 499       strcat (arg_buf, args);
 500     }
 501   argv = buildargv (arg_buf);
 502   if (argv == NULL)
 503     error ("Insufficient memory available to allocate simulator arg list.");
 504   make_cleanup (freeargv, (char *) argv);
 505
 506   /* FIXME: sim_open may call `error' if it fails, but perhaps it should
 507      just return an error indicator and let us call `error'.  */
 508   gdbsim_desc = sim_open (argv);
 509
 510   push_target (&gdbsim_ops);
 511   target_fetch_registers (-1);
 512   printf_filtered ("Connected to the simulator.\n");
 513 }
 514
 515 /* Does whatever cleanup is required for a target that we are no longer
 516    going to be calling.  Argument says whether we are quitting gdb and
 517    should not get hung in case of errors, or whether we want a clean
 518    termination even if it takes a while.  This routine is automatically
 519    always called just before a routine is popped off the target stack.
 520    Closing file descriptors and freeing memory are typical things it should
 521    do.  */
 522 /* Close out all files and local state before this target loses control. */
 523
 524 static void
 525 gdbsim_close (quitting)
 526      int quitting;
 527 {
 528   if (sr_get_debug ())
 529     printf_filtered ("gdbsim_close: quitting %d\n", quitting);
 530
 531   program_loaded = 0;
 532
 533   if (gdbsim_desc != NULL)
 534     {
 535       sim_close (gdbsim_desc, quitting);
 536       gdbsim_desc = NULL;
 537     }
 538
 539   end_callbacks ();
 540 }
 541
 542 /* Takes a program previously attached to and detaches it.
 543    The program may resume execution (some targets do, some don't) and will
 544    no longer stop on signals, etc.  We better not have left any breakpoints
 545    in the program or it'll die when it hits one.  ARGS is arguments
 546    typed by the user (e.g. a signal to send the process).  FROM_TTY
 547    says whether to be verbose or not.  */
 548 /* Terminate the open connection to the remote debugger.
 549    Use this when you want to detach and do something else with your gdb.  */
 550
 551 static void
 552 gdbsim_detach (args,from_tty)
 553      char *args;
 554      int from_tty;
 555 {
 556   if (sr_get_debug ())
 557     printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
 558
 559   pop_target ();                /* calls gdbsim_close to do the real work */
 560   if (from_tty)
 561     printf_filtered ("Ending simulator %s debugging\n", target_shortname);
 562 }
 563
 564 /* Resume execution of the target process.  STEP says whether to single-step
 565    or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
 566    to the target, or zero for no signal.  */
 567
 568 static void
 569 gdbsim_resume (pid, step, siggnal)
 570      int pid, step;
 571      enum target_signal siggnal;
 572 {
 573   if (inferior_pid != 42)
 574     error ("The program is not being run.");
 575
 576   if (sr_get_debug ())
 577     printf_filtered ("gdbsim_resume: step %d, signal %d\n", step, siggnal);
 578
 579   sim_resume (gdbsim_desc, step, target_signal_to_host (siggnal));
 580 }
 581
 582 /* Wait for inferior process to do something.  Return pid of child,
 583    or -1 in case of error; store status through argument pointer STATUS,
 584    just as `wait' would.  */
 585
 586 static int
 587 gdbsim_wait (pid, status)
 588      int pid;
 589      struct target_waitstatus *status;
 590 {
 591   int sigrc;
 592   enum sim_stop reason;
 593
 594   if (sr_get_debug ())
 595     printf_filtered ("gdbsim_wait\n");
 596
 597   sim_stop_reason (gdbsim_desc, &reason, &sigrc);
 598   switch (reason)
 599     {
 600     case sim_exited:
 601       status->kind = TARGET_WAITKIND_EXITED;
 602       status->value.integer = sigrc;
 603       break;
 604     case sim_stopped:
 605       status->kind = TARGET_WAITKIND_STOPPED;
 606       /* The signal in sigrc is a host signal.  That probably
 607          should be fixed.  */
 608       status->value.sig = target_signal_from_host (sigrc);
 609       break;
 610     case sim_signalled:
 611       status->kind = TARGET_WAITKIND_SIGNALLED;
 612       /* The signal in sigrc is a host signal.  That probably
 613          should be fixed.  */
 614       status->value.sig = target_signal_from_host (sigrc);
 615       break;
 616     }
 617
 618   return inferior_pid;
 619 }
 620
 621 /* Get ready to modify the registers array.  On machines which store
 622    individual registers, this doesn't need to do anything.  On machines
 623    which store all the registers in one fell swoop, this makes sure
 624    that registers contains all the registers from the program being
 625    debugged.  */
 626
 627 static void
 628 gdbsim_prepare_to_store ()
 629 {
 630   /* Do nothing, since we can store individual regs */
 631 }
 632
 633 static int
 634 gdbsim_xfer_inferior_memory (memaddr, myaddr, len, write, target)
 635      CORE_ADDR memaddr;
 636      char *myaddr;
 637      int len;
 638      int write;
 639      struct target_ops *target;                 /* ignored */
 640 {
 641   if (! program_loaded)
 642     error ("No program loaded.");
 643
 644   if (sr_get_debug ())
 645     {
 646       printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x%x, memaddr 0x%x, len %d, write %d\n",
 647                        myaddr, memaddr, len, write);
 648       if (sr_get_debug () && write)
 649         dump_mem(myaddr, len);
 650     }
 651
 652   if (write)
 653     {
 654       len = sim_write (gdbsim_desc, memaddr, myaddr, len);
 655     }
 656   else
 657     {
 658       len = sim_read (gdbsim_desc, memaddr, myaddr, len);
 659       if (sr_get_debug () && len > 0)
 660         dump_mem(myaddr, len);
 661     }
 662   return len;
 663 }
 664
 665 static void
 666 gdbsim_files_info (target)
 667      struct target_ops *target;
 668 {
 669   char *file = "nothing";
 670
 671   if (exec_bfd)
 672     file = bfd_get_filename (exec_bfd);
 673
 674   if (sr_get_debug ())
 675     printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
 676
 677   if (exec_bfd)
 678     {
 679       printf_filtered ("\tAttached to %s running program %s\n",
 680                        target_shortname, file);
 681       sim_info (gdbsim_desc, 0);
 682     }
 683 }
 684
 685 /* Clear the simulator's notion of what the break points are.  */
 686
 687 static void
 688 gdbsim_mourn_inferior ()
 689 {
 690   if (sr_get_debug ())
 691     printf_filtered ("gdbsim_mourn_inferior:\n");
 692
 693   remove_breakpoints ();
 694   generic_mourn_inferior ();
 695 }
 696
 697 /* Pass the command argument through to the simulator verbatim.  The
 698    simulator must do any command interpretation work.  */
 699
 700 static void
 701 simulator_command (args, from_tty)
 702      char *args;
 703      int from_tty;
 704 {
 705   /* The user may give a command before the simulator is opened, so
 706      ensure that the callbacks have been set up.  */
 707   init_callbacks ();
 708
 709   /* Note that if the simulator hasn't been opened, gdbsim_desc == NULL
 710      which is correct (??? assuming of course one wishes to continue to
 711      allow commands to be sent to unopened simulators, which isn't entirely
 712      unreasonable).  Simulators should be prepared to deal with any
 713      combination of NULL or empty args. */
 714   sim_do_command (gdbsim_desc, args);
 715 }
 716
 717 /* Define the target subroutine names */
 718
 719 struct target_ops gdbsim_ops = {
 720   "sim",                        /* to_shortname */
 721   "simulator",                  /* to_longname */
 722   "Use the compiled-in simulator.",  /* to_doc */
 723   gdbsim_open,                  /* to_open */
 724   gdbsim_close,                 /* to_close */
 725   NULL,                         /* to_attach */
 726   gdbsim_detach,                /* to_detach */
 727   gdbsim_resume,                /* to_resume */
 728   gdbsim_wait,                  /* to_wait */
 729   gdbsim_fetch_register,        /* to_fetch_registers */
 730   gdbsim_store_register,        /* to_store_registers */
 731   gdbsim_prepare_to_store,      /* to_prepare_to_store */
 732   gdbsim_xfer_inferior_memory,  /* to_xfer_memory */
 733   gdbsim_files_info,            /* to_files_info */
 734   memory_insert_breakpoint,     /* to_insert_breakpoint */
 735   memory_remove_breakpoint,     /* to_remove_breakpoint */
 736   NULL,                         /* to_terminal_init */
 737   NULL,                         /* to_terminal_inferior */
 738   NULL,                         /* to_terminal_ours_for_output */
 739   NULL,                         /* to_terminal_ours */
 740   NULL,                         /* to_terminal_info */
 741   gdbsim_kill,                  /* to_kill */
 742   gdbsim_load,                  /* to_load */
 743   NULL,                         /* to_lookup_symbol */
 744   gdbsim_create_inferior,       /* to_create_inferior */
 745   gdbsim_mourn_inferior,        /* to_mourn_inferior */
 746   0,                            /* to_can_run */
 747   0,                            /* to_notice_signals */
 748   0,                            /* to_thread_alive */
 749   0,                            /* to_stop */
 750   process_stratum,              /* to_stratum */
 751   NULL,                         /* to_next */
 752   1,                            /* to_has_all_memory */
 753   1,                            /* to_has_memory */
 754   1,                            /* to_has_stack */
 755   1,                            /* to_has_registers */
 756   1,                            /* to_has_execution */
 757   NULL,                         /* sections */
 758   NULL,                         /* sections_end */
 759   OPS_MAGIC,                    /* to_magic */
 760 };
 761
 762 void
 763 _initialize_remote_sim ()
 764 {
 765   add_target (&gdbsim_ops);
 766
 767   add_com ("sim <command>", class_obscure, simulator_command,
 768            "Send a command to the simulator.");
 769 }