gdb/remote-sim.c

   1 /* Generic remote debugging interface for simulators.
   2
   3    Copyright (C) 1993-2014 Free Software Foundation, Inc.
   4
   5    Contributed by Cygnus Support.
   6    Steve Chamberlain (sac@cygnus.com).
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 #include "defs.h"
  24 #include "inferior.h"
  25 #include "infrun.h"
  26 #include "value.h"
  27 #include <ctype.h>
  28 #include <fcntl.h>
  29 #include <signal.h>
  30 #include <setjmp.h>
  31 #include "terminal.h"
  32 #include "target.h"
  33 #include "gdbcore.h"
  34 #include "gdb/callback.h"
  35 #include "gdb/remote-sim.h"
  36 #include "command.h"
  37 #include "regcache.h"
  38 #include "sim-regno.h"
  39 #include "arch-utils.h"
  40 #include "readline/readline.h"
  41 #include "gdbthread.h"
  42
  43 /* Prototypes */
  44
  45 extern void _initialize_remote_sim (void);
  46
  47 static void init_callbacks (void);
  48
  49 static void end_callbacks (void);
  50
  51 static int gdb_os_write_stdout (host_callback *, const char *, int);
  52
  53 static void gdb_os_flush_stdout (host_callback *);
  54
  55 static int gdb_os_write_stderr (host_callback *, const char *, int);
  56
  57 static void gdb_os_flush_stderr (host_callback *);
  58
  59 static int gdb_os_poll_quit (host_callback *);
  60
  61 /* printf_filtered is depreciated.  */
  62 static void gdb_os_printf_filtered (host_callback *, const char *, ...);
  63
  64 static void gdb_os_vprintf_filtered (host_callback *, const char *, va_list);
  65
  66 static void gdb_os_evprintf_filtered (host_callback *, const char *, va_list);
  67
  68 static void gdb_os_error (host_callback *, const char *, ...)
  69      ATTRIBUTE_NORETURN;
  70
  71 static void gdbsim_kill (struct target_ops *);
  72
  73 static void gdbsim_load (struct target_ops *self, const char *prog,
  74                          int fromtty);
  75
  76 static void gdbsim_open (const char *args, int from_tty);
  77
  78 static void gdbsim_close (struct target_ops *self);
  79
  80 static void gdbsim_detach (struct target_ops *ops, const char *args,
  81                            int from_tty);
  82
  83 static void gdbsim_prepare_to_store (struct target_ops *self,
  84                                      struct regcache *regcache);
  85
  86 static void gdbsim_files_info (struct target_ops *target);
  87
  88 static void gdbsim_mourn_inferior (struct target_ops *target);
  89
  90 static void gdbsim_stop (struct target_ops *self, ptid_t ptid);
  91
  92 void simulator_command (char *args, int from_tty);
  93
  94 /* Naming convention:
  95
  96    sim_* are the interface to the simulator (see remote-sim.h).
  97    gdbsim_* are stuff which is internal to gdb.  */
  98
  99 /* Forward data declarations */
 100 extern struct target_ops gdbsim_ops;
 101
 102 static const struct inferior_data *sim_inferior_data_key;
 103
 104 /* Simulator-specific, per-inferior state.  */
 105 struct sim_inferior_data {
 106   /* Flag which indicates whether or not the program has been loaded.  */
 107   int program_loaded;
 108
 109   /* Simulator descriptor for this inferior.  */
 110   SIM_DESC gdbsim_desc;
 111
 112   /* This is the ptid we use for this particular simulator instance.  Its
 113      value is somewhat arbitrary, as the simulator target don't have a
 114      notion of tasks or threads, but we need something non-null to place
 115      in inferior_ptid.  For simulators which permit multiple instances,
 116      we also need a unique identifier to use for each inferior.  */
 117   ptid_t remote_sim_ptid;
 118
 119   /* Signal with which to resume.  */
 120   enum gdb_signal resume_siggnal;
 121
 122   /* Flag which indicates whether resume should step or not.  */
 123   int resume_step;
 124 };
 125
 126 /* Flag indicating the "open" status of this module.  It's set to 1
 127    in gdbsim_open() and 0 in gdbsim_close().  */
 128 static int gdbsim_is_open = 0;
 129
 130 /* Value of the next pid to allocate for an inferior.  As indicated
 131    elsewhere, its initial value is somewhat arbitrary; it's critical
 132    though that it's not zero or negative.  */
 133 static int next_pid;
 134 #define INITIAL_PID 42000
 135
 136 /* Argument list to pass to sim_open().  It is allocated in gdbsim_open()
 137    and deallocated in gdbsim_close().  The lifetime needs to extend beyond
 138    the call to gdbsim_open() due to the fact that other sim instances other
 139    than the first will be allocated after the gdbsim_open() call.  */
 140 static char **sim_argv = NULL;
 141
 142 /* OS-level callback functions for write, flush, etc.  */
 143 static host_callback gdb_callback;
 144 static int callbacks_initialized = 0;
 145
 146 /* Callback for iterate_over_inferiors.  It checks to see if the sim
 147    descriptor passed via ARG is the same as that for the inferior
 148    designated by INF.  Return true if so; false otherwise.  */
 149
 150 static int
 151 check_for_duplicate_sim_descriptor (struct inferior *inf, void *arg)
 152 {
 153   struct sim_inferior_data *sim_data;
 154   SIM_DESC new_sim_desc = arg;
 155
 156   sim_data = inferior_data (inf, sim_inferior_data_key);
 157
 158   return (sim_data != NULL && sim_data->gdbsim_desc == new_sim_desc);
 159 }
 160
 161 /* Flags indicating whether or not a sim instance is needed.  One of these
 162    flags should be passed to get_sim_inferior_data().  */
 163
 164 enum {SIM_INSTANCE_NOT_NEEDED = 0, SIM_INSTANCE_NEEDED = 1};
 165
 166 /* Obtain pointer to per-inferior simulator data, allocating it if necessary.
 167    Attempt to open the sim if SIM_INSTANCE_NEEDED is true.  */
 168
 169 static struct sim_inferior_data *
 170 get_sim_inferior_data (struct inferior *inf, int sim_instance_needed)
 171 {
 172   SIM_DESC sim_desc = NULL;
 173   struct sim_inferior_data *sim_data
 174     = inferior_data (inf, sim_inferior_data_key);
 175
 176   /* Try to allocate a new sim instance, if needed.  We do this ahead of
 177      a potential allocation of a sim_inferior_data struct in order to
 178      avoid needlessly allocating that struct in the event that the sim
 179      instance allocation fails.  */
 180   if (sim_instance_needed == SIM_INSTANCE_NEEDED
 181       && (sim_data == NULL || sim_data->gdbsim_desc == NULL))
 182     {
 183       struct inferior *idup;
 184       sim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, sim_argv);
 185       if (sim_desc == NULL)
 186         error (_("Unable to create simulator instance for inferior %d."),
 187                inf->num);
 188
 189       idup = iterate_over_inferiors (check_for_duplicate_sim_descriptor,
 190                                      sim_desc);
 191       if (idup != NULL)
 192         {
 193           /* We don't close the descriptor due to the fact that it's
 194              shared with some other inferior.  If we were to close it,
 195              that might needlessly muck up the other inferior.  Of
 196              course, it's possible that the damage has already been
 197              done...  Note that it *will* ultimately be closed during
 198              cleanup of the other inferior.  */
 199           sim_desc = NULL;
 200           error (
 201  _("Inferior %d and inferior %d would have identical simulator state.\n"
 202    "(This simulator does not support the running of more than one inferior.)"),
 203                  inf->num, idup->num);
 204         }
 205     }
 206
 207   if (sim_data == NULL)
 208     {
 209       sim_data = XCNEW(struct sim_inferior_data);
 210       set_inferior_data (inf, sim_inferior_data_key, sim_data);
 211
 212       /* Allocate a ptid for this inferior.  */
 213       sim_data->remote_sim_ptid = ptid_build (next_pid, 0, next_pid);
 214       next_pid++;
 215
 216       /* Initialize the other instance variables.  */
 217       sim_data->program_loaded = 0;
 218       sim_data->gdbsim_desc = sim_desc;
 219       sim_data->resume_siggnal = GDB_SIGNAL_0;
 220       sim_data->resume_step = 0;
 221     }
 222   else if (sim_desc)
 223     {
 224       /* This handles the case where sim_data was allocated prior to
 225          needing a sim instance.  */
 226       sim_data->gdbsim_desc = sim_desc;
 227     }
 228
 229
 230   return sim_data;
 231 }
 232
 233 /* Return pointer to per-inferior simulator data using PTID to find the
 234    inferior in question.  Return NULL when no inferior is found or
 235    when ptid has a zero or negative pid component.  */
 236
 237 static struct sim_inferior_data *
 238 get_sim_inferior_data_by_ptid (ptid_t ptid, int sim_instance_needed)
 239 {
 240   struct inferior *inf;
 241   int pid = ptid_get_pid (ptid);
 242
 243   if (pid <= 0)
 244     return NULL;
 245
 246   inf = find_inferior_pid (pid);
 247
 248   if (inf)
 249     return get_sim_inferior_data (inf, sim_instance_needed);
 250   else
 251     return NULL;
 252 }
 253
 254 /* Free the per-inferior simulator data.  */
 255
 256 static void
 257 sim_inferior_data_cleanup (struct inferior *inf, void *data)
 258 {
 259   struct sim_inferior_data *sim_data = data;
 260
 261   if (sim_data != NULL)
 262     {
 263       if (sim_data->gdbsim_desc)
 264         {
 265           sim_close (sim_data->gdbsim_desc, 0);
 266           sim_data->gdbsim_desc = NULL;
 267         }
 268       xfree (sim_data);
 269     }
 270 }
 271
 272 static void
 273 dump_mem (const gdb_byte *buf, int len)
 274 {
 275   fputs_unfiltered ("\t", gdb_stdlog);
 276
 277   if (len == 8 || len == 4)
 278     {
 279       uint32_t l[2];
 280
 281       memcpy (l, buf, len);
 282       fprintf_unfiltered (gdb_stdlog, "0x%08x", l[0]);
 283       if (len == 8)
 284         fprintf_unfiltered (gdb_stdlog, " 0x%08x", l[1]);
 285     }
 286   else
 287     {
 288       int i;
 289
 290       for (i = 0; i < len; i++)
 291         fprintf_unfiltered (gdb_stdlog, "0x%02x ", buf[i]);
 292     }
 293
 294   fputs_unfiltered ("\n", gdb_stdlog);
 295 }
 296
 297 /* Initialize gdb_callback.  */
 298
 299 static void
 300 init_callbacks (void)
 301 {
 302   if (!callbacks_initialized)
 303     {
 304       gdb_callback = default_callback;
 305       gdb_callback.init (&gdb_callback);
 306       gdb_callback.write_stdout = gdb_os_write_stdout;
 307       gdb_callback.flush_stdout = gdb_os_flush_stdout;
 308       gdb_callback.write_stderr = gdb_os_write_stderr;
 309       gdb_callback.flush_stderr = gdb_os_flush_stderr;
 310       gdb_callback.printf_filtered = gdb_os_printf_filtered;
 311       gdb_callback.vprintf_filtered = gdb_os_vprintf_filtered;
 312       gdb_callback.evprintf_filtered = gdb_os_evprintf_filtered;
 313       gdb_callback.error = gdb_os_error;
 314       gdb_callback.poll_quit = gdb_os_poll_quit;
 315       gdb_callback.magic = HOST_CALLBACK_MAGIC;
 316       callbacks_initialized = 1;
 317     }
 318 }
 319
 320 /* Release callbacks (free resources used by them).  */
 321
 322 static void
 323 end_callbacks (void)
 324 {
 325   if (callbacks_initialized)
 326     {
 327       gdb_callback.shutdown (&gdb_callback);
 328       callbacks_initialized = 0;
 329     }
 330 }
 331
 332 /* GDB version of os_write_stdout callback.  */
 333
 334 static int
 335 gdb_os_write_stdout (host_callback *p, const char *buf, int len)
 336 {
 337   int i;
 338   char b[2];
 339
 340   ui_file_write (gdb_stdtarg, buf, len);
 341   return len;
 342 }
 343
 344 /* GDB version of os_flush_stdout callback.  */
 345
 346 static void
 347 gdb_os_flush_stdout (host_callback *p)
 348 {
 349   gdb_flush (gdb_stdtarg);
 350 }
 351
 352 /* GDB version of os_write_stderr callback.  */
 353
 354 static int
 355 gdb_os_write_stderr (host_callback *p, const char *buf, int len)
 356 {
 357   int i;
 358   char b[2];
 359
 360   for (i = 0; i < len; i++)
 361     {
 362       b[0] = buf[i];
 363       b[1] = 0;
 364       fputs_unfiltered (b, gdb_stdtargerr);
 365     }
 366   return len;
 367 }
 368
 369 /* GDB version of os_flush_stderr callback.  */
 370
 371 static void
 372 gdb_os_flush_stderr (host_callback *p)
 373 {
 374   gdb_flush (gdb_stdtargerr);
 375 }
 376
 377 /* GDB version of printf_filtered callback.  */
 378
 379 static void
 380 gdb_os_printf_filtered (host_callback * p, const char *format,...)
 381 {
 382   va_list args;
 383
 384   va_start (args, format);
 385   vfprintf_filtered (gdb_stdout, format, args);
 386   va_end (args);
 387 }
 388
 389 /* GDB version of error vprintf_filtered.  */
 390
 391 static void
 392 gdb_os_vprintf_filtered (host_callback * p, const char *format, va_list ap)
 393 {
 394   vfprintf_filtered (gdb_stdout, format, ap);
 395 }
 396
 397 /* GDB version of error evprintf_filtered.  */
 398
 399 static void
 400 gdb_os_evprintf_filtered (host_callback * p, const char *format, va_list ap)
 401 {
 402   vfprintf_filtered (gdb_stderr, format, ap);
 403 }
 404
 405 /* GDB version of error callback.  */
 406
 407 static void
 408 gdb_os_error (host_callback * p, const char *format, ...)
 409 {
 410   va_list args;
 411
 412   va_start (args, format);
 413   verror (format, args);
 414   va_end (args);
 415 }
 416
 417 int
 418 one2one_register_sim_regno (struct gdbarch *gdbarch, int regnum)
 419 {
 420   /* Only makes sense to supply raw registers.  */
 421   gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
 422   return regnum;
 423 }
 424
 425 static void
 426 gdbsim_fetch_register (struct target_ops *ops,
 427                        struct regcache *regcache, int regno)
 428 {
 429   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 430   struct sim_inferior_data *sim_data
 431     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
 432
 433   if (regno == -1)
 434     {
 435       for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
 436         gdbsim_fetch_register (ops, regcache, regno);
 437       return;
 438     }
 439
 440   switch (gdbarch_register_sim_regno (gdbarch, regno))
 441     {
 442     case LEGACY_SIM_REGNO_IGNORE:
 443       break;
 444     case SIM_REGNO_DOES_NOT_EXIST:
 445       {
 446         /* For moment treat a `does not exist' register the same way
 447            as an ``unavailable'' register.  */
 448         gdb_byte buf[MAX_REGISTER_SIZE];
 449         int nr_bytes;
 450
 451         memset (buf, 0, MAX_REGISTER_SIZE);
 452         regcache_raw_supply (regcache, regno, buf);
 453         break;
 454       }
 455
 456     default:
 457       {
 458         static int warn_user = 1;
 459         gdb_byte buf[MAX_REGISTER_SIZE];
 460         int nr_bytes;
 461
 462         gdb_assert (regno >= 0 && regno < gdbarch_num_regs (gdbarch));
 463         memset (buf, 0, MAX_REGISTER_SIZE);
 464         nr_bytes = sim_fetch_register (sim_data->gdbsim_desc,
 465                                        gdbarch_register_sim_regno
 466                                          (gdbarch, regno),
 467                                        buf,
 468                                        register_size (gdbarch, regno));
 469         if (nr_bytes > 0
 470             && nr_bytes != register_size (gdbarch, regno) && warn_user)
 471           {
 472             fprintf_unfiltered (gdb_stderr,
 473                                 "Size of register %s (%d/%d) "
 474                                 "incorrect (%d instead of %d))",
 475                                 gdbarch_register_name (gdbarch, regno),
 476                                 regno,
 477                                 gdbarch_register_sim_regno
 478                                   (gdbarch, regno),
 479                                 nr_bytes, register_size (gdbarch, regno));
 480             warn_user = 0;
 481           }
 482         /* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0'
 483            indicating that GDB and the SIM have different ideas about
 484            which registers are fetchable.  */
 485         /* Else if (nr_bytes < 0): an old simulator, that doesn't
 486            think to return the register size.  Just assume all is ok.  */
 487         regcache_raw_supply (regcache, regno, buf);
 488         if (remote_debug)
 489           {
 490             fprintf_unfiltered (gdb_stdlog,
 491                                 "gdbsim_fetch_register: %d", regno);
 492             /* FIXME: We could print something more intelligible.  */
 493             dump_mem (buf, register_size (gdbarch, regno));
 494           }
 495         break;
 496       }
 497     }
 498 }
 499
 500
 501 static void
 502 gdbsim_store_register (struct target_ops *ops,
 503                        struct regcache *regcache, int regno)
 504 {
 505   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 506   struct sim_inferior_data *sim_data
 507     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
 508
 509   if (regno == -1)
 510     {
 511       for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
 512         gdbsim_store_register (ops, regcache, regno);
 513       return;
 514     }
 515   else if (gdbarch_register_sim_regno (gdbarch, regno) >= 0)
 516     {
 517       gdb_byte tmp[MAX_REGISTER_SIZE];
 518       int nr_bytes;
 519
 520       regcache_cooked_read (regcache, regno, tmp);
 521       nr_bytes = sim_store_register (sim_data->gdbsim_desc,
 522                                      gdbarch_register_sim_regno
 523                                        (gdbarch, regno),
 524                                      tmp, register_size (gdbarch, regno));
 525       if (nr_bytes > 0 && nr_bytes != register_size (gdbarch, regno))
 526         internal_error (__FILE__, __LINE__,
 527                         _("Register size different to expected"));
 528       if (nr_bytes < 0)
 529         internal_error (__FILE__, __LINE__,
 530                         _("Register %d not updated"), regno);
 531       if (nr_bytes == 0)
 532         warning (_("Register %s not updated"),
 533                  gdbarch_register_name (gdbarch, regno));
 534
 535       if (remote_debug)
 536         {
 537           fprintf_unfiltered (gdb_stdlog, "gdbsim_store_register: %d", regno);
 538           /* FIXME: We could print something more intelligible.  */
 539           dump_mem (tmp, register_size (gdbarch, regno));
 540         }
 541     }
 542 }
 543
 544 /* Kill the running program.  This may involve closing any open files
 545    and releasing other resources acquired by the simulated program.  */
 546
 547 static void
 548 gdbsim_kill (struct target_ops *ops)
 549 {
 550   if (remote_debug)
 551     fprintf_unfiltered (gdb_stdlog, "gdbsim_kill\n");
 552
 553   /* There is no need to `kill' running simulator - the simulator is
 554      not running.  Mourning it is enough.  */
 555   target_mourn_inferior ();
 556 }
 557
 558 /* Load an executable file into the target process.  This is expected to
 559    not only bring new code into the target process, but also to update
 560    GDB's symbol tables to match.  */
 561
 562 static void
 563 gdbsim_load (struct target_ops *self, const char *args, int fromtty)
 564 {
 565   char **argv;
 566   const char *prog;
 567   struct sim_inferior_data *sim_data
 568     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
 569
 570   if (args == NULL)
 571       error_no_arg (_("program to load"));
 572
 573   argv = gdb_buildargv (args);
 574   make_cleanup_freeargv (argv);
 575
 576   prog = tilde_expand (argv[0]);
 577
 578   if (argv[1] != NULL)
 579     error (_("GDB sim does not yet support a load offset."));
 580
 581   if (remote_debug)
 582     fprintf_unfiltered (gdb_stdlog, "gdbsim_load: prog \"%s\"\n", prog);
 583
 584   /* FIXME: We will print two messages on error.
 585      Need error to either not print anything if passed NULL or need
 586      another routine that doesn't take any arguments.  */
 587   if (sim_load (sim_data->gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL)
 588     error (_("unable to load program"));
 589
 590   /* FIXME: If a load command should reset the targets registers then
 591      a call to sim_create_inferior() should go here.  */
 592
 593   sim_data->program_loaded = 1;
 594 }
 595
 596
 597 /* Start an inferior process and set inferior_ptid to its pid.
 598    EXEC_FILE is the file to run.
 599    ARGS is a string containing the arguments to the program.
 600    ENV is the environment vector to pass.  Errors reported with error().
 601    On VxWorks and various standalone systems, we ignore exec_file.  */
 602 /* This is called not only when we first attach, but also when the
 603    user types "run" after having attached.  */
 604
 605 static void
 606 gdbsim_create_inferior (struct target_ops *target, char *exec_file, char *args,
 607                         char **env, int from_tty)
 608 {
 609   struct sim_inferior_data *sim_data
 610     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
 611   int len;
 612   char *arg_buf, **argv;
 613
 614   if (exec_file == 0 || exec_bfd == 0)
 615     warning (_("No executable file specified."));
 616   if (!sim_data->program_loaded)
 617     warning (_("No program loaded."));
 618
 619   if (remote_debug)
 620     fprintf_unfiltered (gdb_stdlog,
 621                         "gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
 622                         (exec_file ? exec_file : "(NULL)"),
 623                         args);
 624
 625   if (ptid_equal (inferior_ptid, sim_data->remote_sim_ptid))
 626     gdbsim_kill (target);
 627   remove_breakpoints ();
 628   init_wait_for_inferior ();
 629
 630   if (exec_file != NULL)
 631     {
 632       len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop */ 10;
 633       arg_buf = (char *) alloca (len);
 634       arg_buf[0] = '\0';
 635       strcat (arg_buf, exec_file);
 636       strcat (arg_buf, " ");
 637       strcat (arg_buf, args);
 638       argv = gdb_buildargv (arg_buf);
 639       make_cleanup_freeargv (argv);
 640     }
 641   else
 642     argv = NULL;
 643
 644   if (!have_inferiors ())
 645     init_thread_list ();
 646
 647   if (sim_create_inferior (sim_data->gdbsim_desc, exec_bfd, argv, env)
 648       != SIM_RC_OK)
 649     error (_("Unable to create sim inferior."));
 650
 651   inferior_ptid = sim_data->remote_sim_ptid;
 652   inferior_appeared (current_inferior (), ptid_get_pid (inferior_ptid));
 653   add_thread_silent (inferior_ptid);
 654
 655   insert_breakpoints ();        /* Needed to get correct instruction
 656                                    in cache.  */
 657
 658   clear_proceed_status (0);
 659 }
 660
 661 /* The open routine takes the rest of the parameters from the command,
 662    and (if successful) pushes a new target onto the stack.
 663    Targets should supply this routine, if only to provide an error message.  */
 664 /* Called when selecting the simulator.  E.g. (gdb) target sim name.  */
 665
 666 static void
 667 gdbsim_open (const char *args, int from_tty)
 668 {
 669   int len;
 670   char *arg_buf;
 671   struct sim_inferior_data *sim_data;
 672   SIM_DESC gdbsim_desc;
 673
 674   if (remote_debug)
 675     fprintf_unfiltered (gdb_stdlog,
 676                         "gdbsim_open: args \"%s\"\n", args ? args : "(null)");
 677
 678   /* Ensure that the sim target is not on the target stack.  This is
 679      necessary, because if it is on the target stack, the call to
 680      push_target below will invoke sim_close(), thus freeing various
 681      state (including a sim instance) that we allocate prior to
 682      invoking push_target().  We want to delay the push_target()
 683      operation until after we complete those operations which could
 684      error out.  */
 685   if (gdbsim_is_open)
 686     unpush_target (&gdbsim_ops);
 687
 688   len = (7 + 1                  /* gdbsim */
 689          + strlen (" -E little")
 690          + strlen (" --architecture=xxxxxxxxxx")
 691          + strlen (" --sysroot=") + strlen (gdb_sysroot) +
 692          + (args ? strlen (args) : 0)
 693          + 50) /* slack */ ;
 694   arg_buf = (char *) alloca (len);
 695   strcpy (arg_buf, "gdbsim");   /* 7 */
 696   /* Specify the byte order for the target when it is explicitly
 697      specified by the user (not auto detected).  */
 698   switch (selected_byte_order ())
 699     {
 700     case BFD_ENDIAN_BIG:
 701       strcat (arg_buf, " -E big");
 702       break;
 703     case BFD_ENDIAN_LITTLE:
 704       strcat (arg_buf, " -E little");
 705       break;
 706     case BFD_ENDIAN_UNKNOWN:
 707       break;
 708     }
 709   /* Specify the architecture of the target when it has been
 710      explicitly specified */
 711   if (selected_architecture_name () != NULL)
 712     {
 713       strcat (arg_buf, " --architecture=");
 714       strcat (arg_buf, selected_architecture_name ());
 715     }
 716   /* Pass along gdb's concept of the sysroot.  */
 717   strcat (arg_buf, " --sysroot=");
 718   strcat (arg_buf, gdb_sysroot);
 719   /* finally, any explicit args */
 720   if (args)
 721     {
 722       strcat (arg_buf, " ");    /* 1 */
 723       strcat (arg_buf, args);
 724     }
 725   sim_argv = gdb_buildargv (arg_buf);
 726
 727   init_callbacks ();
 728   gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, sim_argv);
 729
 730   if (gdbsim_desc == 0)
 731     {
 732       freeargv (sim_argv);
 733       sim_argv = NULL;
 734       error (_("unable to create simulator instance"));
 735     }
 736
 737   /* Reset the pid numberings for this batch of sim instances.  */
 738   next_pid = INITIAL_PID;
 739
 740   /* Allocate the inferior data, but do not allocate a sim instance
 741      since we've already just done that.  */
 742   sim_data = get_sim_inferior_data (current_inferior (),
 743                                     SIM_INSTANCE_NOT_NEEDED);
 744
 745   sim_data->gdbsim_desc = gdbsim_desc;
 746
 747   push_target (&gdbsim_ops);
 748   printf_filtered ("Connected to the simulator.\n");
 749
 750   /* There's nothing running after "target sim" or "load"; not until
 751      "run".  */
 752   inferior_ptid = null_ptid;
 753
 754   gdbsim_is_open = 1;
 755 }
 756
 757 /* Callback for iterate_over_inferiors.  Called (indirectly) by
 758    gdbsim_close().  */
 759
 760 static int
 761 gdbsim_close_inferior (struct inferior *inf, void *arg)
 762 {
 763   struct sim_inferior_data *sim_data = inferior_data (inf,
 764                                                       sim_inferior_data_key);
 765   if (sim_data != NULL)
 766     {
 767       ptid_t ptid = sim_data->remote_sim_ptid;
 768
 769       sim_inferior_data_cleanup (inf, sim_data);
 770       set_inferior_data (inf, sim_inferior_data_key, NULL);
 771
 772       /* Having a ptid allocated and stored in remote_sim_ptid does
 773          not mean that a corresponding inferior was ever created.
 774          Thus we need to verify the existence of an inferior using the
 775          pid in question before setting inferior_ptid via
 776          switch_to_thread() or mourning the inferior.  */
 777       if (find_inferior_pid (ptid_get_pid (ptid)) != NULL)
 778         {
 779           switch_to_thread (ptid);
 780           generic_mourn_inferior ();
 781         }
 782     }
 783
 784   return 0;
 785 }
 786
 787 /* Close out all files and local state before this target loses control.  */
 788
 789 static void
 790 gdbsim_close (struct target_ops *self)
 791 {
 792   struct sim_inferior_data *sim_data
 793     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
 794
 795   if (remote_debug)
 796     fprintf_unfiltered (gdb_stdlog, "gdbsim_close\n");
 797
 798   iterate_over_inferiors (gdbsim_close_inferior, NULL);
 799
 800   if (sim_argv != NULL)
 801     {
 802       freeargv (sim_argv);
 803       sim_argv = NULL;
 804     }
 805
 806   end_callbacks ();
 807
 808   gdbsim_is_open = 0;
 809 }
 810
 811 /* Takes a program previously attached to and detaches it.
 812    The program may resume execution (some targets do, some don't) and will
 813    no longer stop on signals, etc.  We better not have left any breakpoints
 814    in the program or it'll die when it hits one.  ARGS is arguments
 815    typed by the user (e.g. a signal to send the process).  FROM_TTY
 816    says whether to be verbose or not.  */
 817 /* Terminate the open connection to the remote debugger.
 818    Use this when you want to detach and do something else with your gdb.  */
 819
 820 static void
 821 gdbsim_detach (struct target_ops *ops, const char *args, int from_tty)
 822 {
 823   if (remote_debug)
 824     fprintf_unfiltered (gdb_stdlog, "gdbsim_detach: args \"%s\"\n", args);
 825
 826   unpush_target (ops);          /* calls gdbsim_close to do the real work */
 827   if (from_tty)
 828     printf_filtered ("Ending simulator %s debugging\n", target_shortname);
 829 }
 830
 831 /* Resume execution of the target process.  STEP says whether to single-step
 832    or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
 833    to the target, or zero for no signal.  */
 834
 835 struct resume_data
 836 {
 837   enum gdb_signal siggnal;
 838   int step;
 839 };
 840
 841 static int
 842 gdbsim_resume_inferior (struct inferior *inf, void *arg)
 843 {
 844   struct sim_inferior_data *sim_data
 845     = get_sim_inferior_data (inf, SIM_INSTANCE_NOT_NEEDED);
 846   struct resume_data *rd = arg;
 847
 848   if (sim_data)
 849     {
 850       sim_data->resume_siggnal = rd->siggnal;
 851       sim_data->resume_step = rd->step;
 852
 853       if (remote_debug)
 854         fprintf_unfiltered (gdb_stdlog,
 855                             _("gdbsim_resume: pid %d, step %d, signal %d\n"),
 856                             inf->pid, rd->step, rd->siggnal);
 857     }
 858
 859   /* When called from iterate_over_inferiors, a zero return causes the
 860      iteration process to proceed until there are no more inferiors to
 861      consider.  */
 862   return 0;
 863 }
 864
 865 static void
 866 gdbsim_resume (struct target_ops *ops,
 867                ptid_t ptid, int step, enum gdb_signal siggnal)
 868 {
 869   struct resume_data rd;
 870   struct sim_inferior_data *sim_data
 871     = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NOT_NEEDED);
 872
 873   rd.siggnal = siggnal;
 874   rd.step = step;
 875
 876   /* We don't access any sim_data members within this function.
 877      What's of interest is whether or not the call to
 878      get_sim_inferior_data_by_ptid(), above, is able to obtain a
 879      non-NULL pointer.  If it managed to obtain a non-NULL pointer, we
 880      know we have a single inferior to consider.  If it's NULL, we
 881      either have multiple inferiors to resume or an error condition.  */
 882
 883   if (sim_data)
 884     gdbsim_resume_inferior (find_inferior_pid (ptid_get_pid (ptid)), &rd);
 885   else if (ptid_equal (ptid, minus_one_ptid))
 886     iterate_over_inferiors (gdbsim_resume_inferior, &rd);
 887   else
 888     error (_("The program is not being run."));
 889 }
 890
 891 /* Notify the simulator of an asynchronous request to stop.
 892
 893    The simulator shall ensure that the stop request is eventually
 894    delivered to the simulator.  If the call is made while the
 895    simulator is not running then the stop request is processed when
 896    the simulator is next resumed.
 897
 898    For simulators that do not support this operation, just abort.  */
 899
 900 static int
 901 gdbsim_stop_inferior (struct inferior *inf, void *arg)
 902 {
 903   struct sim_inferior_data *sim_data
 904     = get_sim_inferior_data (inf, SIM_INSTANCE_NEEDED);
 905
 906   if (sim_data)
 907     {
 908       if (!sim_stop (sim_data->gdbsim_desc))
 909         {
 910           quit ();
 911         }
 912     }
 913
 914   /* When called from iterate_over_inferiors, a zero return causes the
 915      iteration process to proceed until there are no more inferiors to
 916      consider.  */
 917   return 0;
 918 }
 919
 920 static void
 921 gdbsim_stop (struct target_ops *self, ptid_t ptid)
 922 {
 923   struct sim_inferior_data *sim_data;
 924
 925   if (ptid_equal (ptid, minus_one_ptid))
 926     {
 927       iterate_over_inferiors (gdbsim_stop_inferior, NULL);
 928     }
 929   else
 930     {
 931       struct inferior *inf = find_inferior_pid (ptid_get_pid (ptid));
 932
 933       if (inf == NULL)
 934         error (_("Can't stop pid %d.  No inferior found."),
 935                ptid_get_pid (ptid));
 936
 937       gdbsim_stop_inferior (inf, NULL);
 938     }
 939 }
 940
 941 /* GDB version of os_poll_quit callback.
 942    Taken from gdb/util.c - should be in a library.  */
 943
 944 static int
 945 gdb_os_poll_quit (host_callback *p)
 946 {
 947   if (deprecated_ui_loop_hook != NULL)
 948     deprecated_ui_loop_hook (0);
 949
 950   if (check_quit_flag ())       /* gdb's idea of quit */
 951     {
 952       clear_quit_flag ();       /* we've stolen it */
 953       return 1;
 954     }
 955   return 0;
 956 }
 957
 958 /* Wait for inferior process to do something.  Return pid of child,
 959    or -1 in case of error; store status through argument pointer STATUS,
 960    just as `wait' would.  */
 961
 962 static void
 963 gdbsim_cntrl_c (int signo)
 964 {
 965   gdbsim_stop (NULL, minus_one_ptid);
 966 }
 967
 968 static ptid_t
 969 gdbsim_wait (struct target_ops *ops,
 970              ptid_t ptid, struct target_waitstatus *status, int options)
 971 {
 972   struct sim_inferior_data *sim_data;
 973   static RETSIGTYPE (*prev_sigint) ();
 974   int sigrc = 0;
 975   enum sim_stop reason = sim_running;
 976
 977   /* This target isn't able to (yet) resume more than one inferior at a time.
 978      When ptid is minus_one_ptid, just use the current inferior.  If we're
 979      given an explicit pid, we'll try to find it and use that instead.  */
 980   if (ptid_equal (ptid, minus_one_ptid))
 981     sim_data = get_sim_inferior_data (current_inferior (),
 982                                       SIM_INSTANCE_NEEDED);
 983   else
 984     {
 985       sim_data = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NEEDED);
 986       if (sim_data == NULL)
 987         error (_("Unable to wait for pid %d.  Inferior not found."),
 988                ptid_get_pid (ptid));
 989       inferior_ptid = ptid;
 990     }
 991
 992   if (remote_debug)
 993     fprintf_unfiltered (gdb_stdlog, "gdbsim_wait\n");
 994
 995 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
 996   {
 997     struct sigaction sa, osa;
 998     sa.sa_handler = gdbsim_cntrl_c;
 999     sigemptyset (&sa.sa_mask);
1000     sa.sa_flags = 0;
1001     sigaction (SIGINT, &sa, &osa);
1002     prev_sigint = osa.sa_handler;
1003   }
1004 #else
1005   prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
1006 #endif
1007   sim_resume (sim_data->gdbsim_desc, sim_data->resume_step,
1008               sim_data->resume_siggnal);
1009
1010   signal (SIGINT, prev_sigint);
1011   sim_data->resume_step = 0;
1012
1013   sim_stop_reason (sim_data->gdbsim_desc, &reason, &sigrc);
1014
1015   switch (reason)
1016     {
1017     case sim_exited:
1018       status->kind = TARGET_WAITKIND_EXITED;
1019       status->value.integer = sigrc;
1020       break;
1021     case sim_stopped:
1022       switch (sigrc)
1023         {
1024         case GDB_SIGNAL_ABRT:
1025           quit ();
1026           break;
1027         case GDB_SIGNAL_INT:
1028         case GDB_SIGNAL_TRAP:
1029         default:
1030           status->kind = TARGET_WAITKIND_STOPPED;
1031           status->value.sig = sigrc;
1032           break;
1033         }
1034       break;
1035     case sim_signalled:
1036       status->kind = TARGET_WAITKIND_SIGNALLED;
1037       status->value.sig = sigrc;
1038       break;
1039     case sim_running:
1040     case sim_polling:
1041       /* FIXME: Is this correct?  */
1042       break;
1043     }
1044
1045   return inferior_ptid;
1046 }
1047
1048 /* Get ready to modify the registers array.  On machines which store
1049    individual registers, this doesn't need to do anything.  On machines
1050    which store all the registers in one fell swoop, this makes sure
1051    that registers contains all the registers from the program being
1052    debugged.  */
1053
1054 static void
1055 gdbsim_prepare_to_store (struct target_ops *self, struct regcache *regcache)
1056 {
1057   /* Do nothing, since we can store individual regs.  */
1058 }
1059
1060 /* Helper for gdbsim_xfer_partial that handles memory transfers.
1061    Arguments are like target_xfer_partial.  */
1062
1063 static enum target_xfer_status
1064 gdbsim_xfer_memory (struct target_ops *target,
1065                     gdb_byte *readbuf, const gdb_byte *writebuf,
1066                     ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
1067 {
1068   struct sim_inferior_data *sim_data
1069     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1070   int l;
1071
1072   /* If this target doesn't have memory yet, return 0 causing the
1073      request to be passed to a lower target, hopefully an exec
1074      file.  */
1075   if (!target->to_has_memory (target))
1076     return TARGET_XFER_EOF;
1077
1078   if (!sim_data->program_loaded)
1079     error (_("No program loaded."));
1080
1081   /* Note that we obtained the sim_data pointer above using
1082      SIM_INSTANCE_NOT_NEEDED.  We do this so that we don't needlessly
1083      allocate a sim instance prior to loading a program.   If we
1084      get to this point in the code though, gdbsim_desc should be
1085      non-NULL.  (Note that a sim instance is needed in order to load
1086      the program...)  */
1087   gdb_assert (sim_data->gdbsim_desc != NULL);
1088
1089   if (remote_debug)
1090     fprintf_unfiltered (gdb_stdlog,
1091                         "gdbsim_xfer_memory: readbuf %s, writebuf %s, "
1092                         "memaddr %s, len %s\n",
1093                         host_address_to_string (readbuf),
1094                         host_address_to_string (writebuf),
1095                         paddress (target_gdbarch (), memaddr),
1096                         pulongest (len));
1097
1098   if (writebuf)
1099     {
1100       if (remote_debug && len > 0)
1101         dump_mem (writebuf, len);
1102       l = sim_write (sim_data->gdbsim_desc, memaddr, writebuf, len);
1103     }
1104   else
1105     {
1106       l = sim_read (sim_data->gdbsim_desc, memaddr, readbuf, len);
1107       if (remote_debug && len > 0)
1108         dump_mem (readbuf, len);
1109     }
1110   if (l > 0)
1111     {
1112       *xfered_len = (ULONGEST) l;
1113       return TARGET_XFER_OK;
1114     }
1115   else if (l == 0)
1116     return TARGET_XFER_EOF;
1117   else
1118     return TARGET_XFER_E_IO;
1119 }
1120
1121 /* Target to_xfer_partial implementation.  */
1122
1123 static enum target_xfer_status
1124 gdbsim_xfer_partial (struct target_ops *ops, enum target_object object,
1125                      const char *annex, gdb_byte *readbuf,
1126                      const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
1127                      ULONGEST *xfered_len)
1128 {
1129   switch (object)
1130     {
1131     case TARGET_OBJECT_MEMORY:
1132       return gdbsim_xfer_memory (ops, readbuf, writebuf, offset, len,
1133                                  xfered_len);
1134
1135     default:
1136       return TARGET_XFER_E_IO;
1137     }
1138 }
1139
1140 static void
1141 gdbsim_files_info (struct target_ops *target)
1142 {
1143   struct sim_inferior_data *sim_data
1144     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
1145   const char *file = "nothing";
1146
1147   if (exec_bfd)
1148     file = bfd_get_filename (exec_bfd);
1149
1150   if (remote_debug)
1151     fprintf_unfiltered (gdb_stdlog, "gdbsim_files_info: file \"%s\"\n", file);
1152
1153   if (exec_bfd)
1154     {
1155       fprintf_unfiltered (gdb_stdlog, "\tAttached to %s running program %s\n",
1156                           target_shortname, file);
1157       sim_info (sim_data->gdbsim_desc, 0);
1158     }
1159 }
1160
1161 /* Clear the simulator's notion of what the break points are.  */
1162
1163 static void
1164 gdbsim_mourn_inferior (struct target_ops *target)
1165 {
1166   struct sim_inferior_data *sim_data
1167     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1168
1169   if (remote_debug)
1170     fprintf_unfiltered (gdb_stdlog, "gdbsim_mourn_inferior:\n");
1171
1172   remove_breakpoints ();
1173   generic_mourn_inferior ();
1174   delete_thread_silent (sim_data->remote_sim_ptid);
1175 }
1176
1177 /* Pass the command argument through to the simulator verbatim.  The
1178    simulator must do any command interpretation work.  */
1179
1180 void
1181 simulator_command (char *args, int from_tty)
1182 {
1183   struct sim_inferior_data *sim_data;
1184
1185   /* We use inferior_data() instead of get_sim_inferior_data() here in
1186      order to avoid attaching a sim_inferior_data struct to an
1187      inferior unnecessarily.  The reason we take such care here is due
1188      to the fact that this function, simulator_command(), may be called
1189      even when the sim target is not active.  If we were to use
1190      get_sim_inferior_data() here, it is possible that this call would
1191      be made either prior to gdbsim_open() or after gdbsim_close(),
1192      thus allocating memory that would not be garbage collected until
1193      the ultimate destruction of the associated inferior.  */
1194
1195   sim_data  = inferior_data (current_inferior (), sim_inferior_data_key);
1196   if (sim_data == NULL || sim_data->gdbsim_desc == NULL)
1197     {
1198
1199       /* PREVIOUSLY: The user may give a command before the simulator
1200          is opened. [...] (??? assuming of course one wishes to
1201          continue to allow commands to be sent to unopened simulators,
1202          which isn't entirely unreasonable).  */
1203
1204       /* The simulator is a builtin abstraction of a remote target.
1205          Consistent with that model, access to the simulator, via sim
1206          commands, is restricted to the period when the channel to the
1207          simulator is open.  */
1208
1209       error (_("Not connected to the simulator target"));
1210     }
1211
1212   sim_do_command (sim_data->gdbsim_desc, args);
1213
1214   /* Invalidate the register cache, in case the simulator command does
1215      something funny.  */
1216   registers_changed ();
1217 }
1218
1219 static VEC (char_ptr) *
1220 sim_command_completer (struct cmd_list_element *ignore, const char *text,
1221                        const char *word)
1222 {
1223   struct sim_inferior_data *sim_data;
1224   char **tmp;
1225   int i;
1226   VEC (char_ptr) *result = NULL;
1227
1228   sim_data = inferior_data (current_inferior (), sim_inferior_data_key);
1229   if (sim_data == NULL || sim_data->gdbsim_desc == NULL)
1230     return NULL;
1231
1232   tmp = sim_complete_command (sim_data->gdbsim_desc, text, word);
1233   if (tmp == NULL)
1234     return NULL;
1235
1236   /* Transform the array into a VEC, and then free the array.  */
1237   for (i = 0; tmp[i] != NULL; i++)
1238     VEC_safe_push (char_ptr, result, tmp[i]);
1239   xfree (tmp);
1240
1241   return result;
1242 }
1243
1244 /* Check to see if a thread is still alive.  */
1245
1246 static int
1247 gdbsim_thread_alive (struct target_ops *ops, ptid_t ptid)
1248 {
1249   struct sim_inferior_data *sim_data
1250     = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NOT_NEEDED);
1251
1252   if (sim_data == NULL)
1253     return 0;
1254
1255   if (ptid_equal (ptid, sim_data->remote_sim_ptid))
1256     /* The simulators' task is always alive.  */
1257     return 1;
1258
1259   return 0;
1260 }
1261
1262 /* Convert a thread ID to a string.  Returns the string in a static
1263    buffer.  */
1264
1265 static char *
1266 gdbsim_pid_to_str (struct target_ops *ops, ptid_t ptid)
1267 {
1268   return normal_pid_to_str (ptid);
1269 }
1270
1271 /* Simulator memory may be accessed after the program has been loaded.  */
1272
1273 static int
1274 gdbsim_has_all_memory (struct target_ops *ops)
1275 {
1276   struct sim_inferior_data *sim_data
1277     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1278
1279   if (!sim_data->program_loaded)
1280     return 0;
1281
1282   return 1;
1283 }
1284
1285 static int
1286 gdbsim_has_memory (struct target_ops *ops)
1287 {
1288   struct sim_inferior_data *sim_data
1289     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1290
1291   if (!sim_data->program_loaded)
1292     return 0;
1293
1294   return 1;
1295 }
1296
1297 /* Define the target subroutine names.  */
1298
1299 struct target_ops gdbsim_ops;
1300
1301 static void
1302 init_gdbsim_ops (void)
1303 {
1304   gdbsim_ops.to_shortname = "sim";
1305   gdbsim_ops.to_longname = "simulator";
1306   gdbsim_ops.to_doc = "Use the compiled-in simulator.";
1307   gdbsim_ops.to_open = gdbsim_open;
1308   gdbsim_ops.to_close = gdbsim_close;
1309   gdbsim_ops.to_detach = gdbsim_detach;
1310   gdbsim_ops.to_resume = gdbsim_resume;
1311   gdbsim_ops.to_wait = gdbsim_wait;
1312   gdbsim_ops.to_fetch_registers = gdbsim_fetch_register;
1313   gdbsim_ops.to_store_registers = gdbsim_store_register;
1314   gdbsim_ops.to_prepare_to_store = gdbsim_prepare_to_store;
1315   gdbsim_ops.to_xfer_partial = gdbsim_xfer_partial;
1316   gdbsim_ops.to_files_info = gdbsim_files_info;
1317   gdbsim_ops.to_insert_breakpoint = memory_insert_breakpoint;
1318   gdbsim_ops.to_remove_breakpoint = memory_remove_breakpoint;
1319   gdbsim_ops.to_kill = gdbsim_kill;
1320   gdbsim_ops.to_load = gdbsim_load;
1321   gdbsim_ops.to_create_inferior = gdbsim_create_inferior;
1322   gdbsim_ops.to_mourn_inferior = gdbsim_mourn_inferior;
1323   gdbsim_ops.to_stop = gdbsim_stop;
1324   gdbsim_ops.to_thread_alive = gdbsim_thread_alive;
1325   gdbsim_ops.to_pid_to_str = gdbsim_pid_to_str;
1326   gdbsim_ops.to_stratum = process_stratum;
1327   gdbsim_ops.to_has_all_memory = gdbsim_has_all_memory;
1328   gdbsim_ops.to_has_memory = gdbsim_has_memory;
1329   gdbsim_ops.to_has_stack = default_child_has_stack;
1330   gdbsim_ops.to_has_registers = default_child_has_registers;
1331   gdbsim_ops.to_has_execution = default_child_has_execution;
1332   gdbsim_ops.to_magic = OPS_MAGIC;
1333 }
1334
1335 void
1336 _initialize_remote_sim (void)
1337 {
1338   struct cmd_list_element *c;
1339
1340   init_gdbsim_ops ();
1341   add_target (&gdbsim_ops);
1342
1343   c = add_com ("sim", class_obscure, simulator_command,
1344                _("Send a command to the simulator."));
1345   set_cmd_completer (c, sim_command_completer);
1346
1347   sim_inferior_data_key
1348     = register_inferior_data_with_cleanup (NULL, sim_inferior_data_cleanup);
1349 }