gdb/remote-sim.c

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