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