gdb/remote-sim.c

   1 /* Generic remote debugging interface for simulators.
   2
   3    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
   4    2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
   5
   6    Contributed by Cygnus Support.
   7    Steve Chamberlain (sac@cygnus.com).
   8
   9    This file is part of GDB.
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  23
  24 #include "defs.h"
  25 #include "inferior.h"
  26 #include "value.h"
  27 #include "gdb_string.h"
  28 #include <ctype.h>
  29 #include <fcntl.h>
  30 #include <signal.h>
  31 #include <setjmp.h>
  32 #include <errno.h>
  33 #include "terminal.h"
  34 #include "target.h"
  35 #include "gdbcore.h"
  36 #include "gdb/callback.h"
  37 #include "gdb/remote-sim.h"
  38 #include "command.h"
  39 #include "regcache.h"
  40 #include "gdb_assert.h"
  41 #include "sim-regno.h"
  42 #include "arch-utils.h"
  43 #include "readline/readline.h"
  44 #include "gdbthread.h"
  45
  46 /* Prototypes */
  47
  48 extern void _initialize_remote_sim (void);
  49
  50 static void dump_mem (char *buf, int len);
  51
  52 static void init_callbacks (void);
  53
  54 static void end_callbacks (void);
  55
  56 static int gdb_os_write_stdout (host_callback *, const char *, int);
  57
  58 static void gdb_os_flush_stdout (host_callback *);
  59
  60 static int gdb_os_write_stderr (host_callback *, const char *, int);
  61
  62 static void gdb_os_flush_stderr (host_callback *);
  63
  64 static int gdb_os_poll_quit (host_callback *);
  65
  66 /* printf_filtered is depreciated */
  67 static void gdb_os_printf_filtered (host_callback *, const char *, ...);
  68
  69 static void gdb_os_vprintf_filtered (host_callback *, const char *, va_list);
  70
  71 static void gdb_os_evprintf_filtered (host_callback *, const char *, va_list);
  72
  73 static void gdb_os_error (host_callback *, const char *, ...) ATTR_NORETURN;
  74
  75 static void gdbsim_fetch_register (struct regcache *regcache, int regno);
  76
  77 static void gdbsim_store_register (struct regcache *regcache, int regno);
  78
  79 static void gdbsim_kill (void);
  80
  81 static void gdbsim_load (char *prog, int fromtty);
  82
  83 static void gdbsim_open (char *args, int from_tty);
  84
  85 static void gdbsim_close (int quitting);
  86
  87 static void gdbsim_detach (struct target_ops *ops, char *args, int from_tty);
  88
  89 static void gdbsim_resume (ptid_t ptid, int step, enum target_signal siggnal);
  90
  91 static ptid_t gdbsim_wait (ptid_t ptid, struct target_waitstatus *status);
  92
  93 static void gdbsim_prepare_to_store (struct regcache *regcache);
  94
  95 static void gdbsim_files_info (struct target_ops *target);
  96
  97 static void gdbsim_mourn_inferior (struct target_ops *target);
  98
  99 static void gdbsim_stop (ptid_t ptid);
 100
 101 void simulator_command (char *args, int from_tty);
 102
 103 /* Naming convention:
 104
 105    sim_* are the interface to the simulator (see remote-sim.h).
 106    gdbsim_* are stuff which is internal to gdb.  */
 107
 108 /* Forward data declarations */
 109 extern struct target_ops gdbsim_ops;
 110
 111 static int program_loaded = 0;
 112
 113 /* We must keep track of whether the simulator has been opened or not because
 114    GDB can call a target's close routine twice, but sim_close doesn't allow
 115    this.  We also need to record the result of sim_open so we can pass it
 116    back to the other sim_foo routines.  */
 117 static SIM_DESC gdbsim_desc = 0;
 118
 119 /* This is the ptid we use while we're connected to the simulator.
 120    Its value is arbitrary, as the simulator target don't have a notion
 121    or processes or threads, but we need something non-null to place in
 122    inferior_ptid.  */
 123 static ptid_t remote_sim_ptid;
 124
 125 static void
 126 dump_mem (char *buf, int len)
 127 {
 128   if (len <= 8)
 129     {
 130       if (len == 8 || len == 4)
 131         {
 132           long l[2];
 133           memcpy (l, buf, len);
 134           printf_filtered ("\t0x%lx", l[0]);
 135           if (len == 8)
 136             printf_filtered (" 0x%lx", l[1]);
 137           printf_filtered ("\n");
 138         }
 139       else
 140         {
 141           int i;
 142           printf_filtered ("\t");
 143           for (i = 0; i < len; i++)
 144             printf_filtered ("0x%x ", buf[i]);
 145           printf_filtered ("\n");
 146         }
 147     }
 148 }
 149
 150 static host_callback gdb_callback;
 151 static int callbacks_initialized = 0;
 152
 153 /* Initialize gdb_callback.  */
 154
 155 static void
 156 init_callbacks (void)
 157 {
 158   if (!callbacks_initialized)
 159     {
 160       gdb_callback = default_callback;
 161       gdb_callback.init (&gdb_callback);
 162       gdb_callback.write_stdout = gdb_os_write_stdout;
 163       gdb_callback.flush_stdout = gdb_os_flush_stdout;
 164       gdb_callback.write_stderr = gdb_os_write_stderr;
 165       gdb_callback.flush_stderr = gdb_os_flush_stderr;
 166       gdb_callback.printf_filtered = gdb_os_printf_filtered;
 167       gdb_callback.vprintf_filtered = gdb_os_vprintf_filtered;
 168       gdb_callback.evprintf_filtered = gdb_os_evprintf_filtered;
 169       gdb_callback.error = gdb_os_error;
 170       gdb_callback.poll_quit = gdb_os_poll_quit;
 171       gdb_callback.magic = HOST_CALLBACK_MAGIC;
 172       callbacks_initialized = 1;
 173     }
 174 }
 175
 176 /* Release callbacks (free resources used by them).  */
 177
 178 static void
 179 end_callbacks (void)
 180 {
 181   if (callbacks_initialized)
 182     {
 183       gdb_callback.shutdown (&gdb_callback);
 184       callbacks_initialized = 0;
 185     }
 186 }
 187
 188 /* GDB version of os_write_stdout callback.  */
 189
 190 static int
 191 gdb_os_write_stdout (host_callback *p, const char *buf, int len)
 192 {
 193   int i;
 194   char b[2];
 195
 196   ui_file_write (gdb_stdtarg, buf, len);
 197   return len;
 198 }
 199
 200 /* GDB version of os_flush_stdout callback.  */
 201
 202 static void
 203 gdb_os_flush_stdout (host_callback *p)
 204 {
 205   gdb_flush (gdb_stdtarg);
 206 }
 207
 208 /* GDB version of os_write_stderr callback.  */
 209
 210 static int
 211 gdb_os_write_stderr (host_callback *p, const char *buf, int len)
 212 {
 213   int i;
 214   char b[2];
 215
 216   for (i = 0; i < len; i++)
 217     {
 218       b[0] = buf[i];
 219       b[1] = 0;
 220       fputs_unfiltered (b, gdb_stdtargerr);
 221     }
 222   return len;
 223 }
 224
 225 /* GDB version of os_flush_stderr callback.  */
 226
 227 static void
 228 gdb_os_flush_stderr (host_callback *p)
 229 {
 230   gdb_flush (gdb_stdtargerr);
 231 }
 232
 233 /* GDB version of printf_filtered callback.  */
 234
 235 static void
 236 gdb_os_printf_filtered (host_callback * p, const char *format,...)
 237 {
 238   va_list args;
 239   va_start (args, format);
 240
 241   vfprintf_filtered (gdb_stdout, format, args);
 242
 243   va_end (args);
 244 }
 245
 246 /* GDB version of error vprintf_filtered.  */
 247
 248 static void
 249 gdb_os_vprintf_filtered (host_callback * p, const char *format, va_list ap)
 250 {
 251   vfprintf_filtered (gdb_stdout, format, ap);
 252 }
 253
 254 /* GDB version of error evprintf_filtered.  */
 255
 256 static void
 257 gdb_os_evprintf_filtered (host_callback * p, const char *format, va_list ap)
 258 {
 259   vfprintf_filtered (gdb_stderr, format, ap);
 260 }
 261
 262 /* GDB version of error callback.  */
 263
 264 static void
 265 gdb_os_error (host_callback * p, const char *format, ...)
 266 {
 267   va_list args;
 268   va_start (args, format);
 269   verror (format, args);
 270   va_end (args);
 271 }
 272
 273 int
 274 one2one_register_sim_regno (struct gdbarch *gdbarch, int regnum)
 275 {
 276   /* Only makes sense to supply raw registers.  */
 277   gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
 278   return regnum;
 279 }
 280
 281 static void
 282 gdbsim_fetch_register (struct regcache *regcache, int regno)
 283 {
 284   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 285   if (regno == -1)
 286     {
 287       for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
 288         gdbsim_fetch_register (regcache, regno);
 289       return;
 290     }
 291
 292   switch (gdbarch_register_sim_regno (gdbarch, regno))
 293     {
 294     case LEGACY_SIM_REGNO_IGNORE:
 295       break;
 296     case SIM_REGNO_DOES_NOT_EXIST:
 297       {
 298         /* For moment treat a `does not exist' register the same way
 299            as an ``unavailable'' register.  */
 300         char buf[MAX_REGISTER_SIZE];
 301         int nr_bytes;
 302         memset (buf, 0, MAX_REGISTER_SIZE);
 303         regcache_raw_supply (regcache, regno, buf);
 304         break;
 305       }
 306
 307     default:
 308       {
 309         static int warn_user = 1;
 310         char buf[MAX_REGISTER_SIZE];
 311         int nr_bytes;
 312         gdb_assert (regno >= 0 && regno < gdbarch_num_regs (gdbarch));
 313         memset (buf, 0, MAX_REGISTER_SIZE);
 314         nr_bytes = sim_fetch_register (gdbsim_desc,
 315                                        gdbarch_register_sim_regno
 316                                          (gdbarch, regno),
 317                                        buf,
 318                                        register_size (gdbarch, regno));
 319         if (nr_bytes > 0
 320             && nr_bytes != register_size (gdbarch, regno) && warn_user)
 321           {
 322             fprintf_unfiltered (gdb_stderr,
 323                                 "Size of register %s (%d/%d) incorrect (%d instead of %d))",
 324                                 gdbarch_register_name (gdbarch, regno),
 325                                 regno,
 326                                 gdbarch_register_sim_regno
 327                                   (gdbarch, regno),
 328                                 nr_bytes, register_size (gdbarch, regno));
 329             warn_user = 0;
 330           }
 331         /* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0'
 332            indicating that GDB and the SIM have different ideas about
 333            which registers are fetchable.  */
 334         /* Else if (nr_bytes < 0): an old simulator, that doesn't
 335            think to return the register size.  Just assume all is ok.  */
 336         regcache_raw_supply (regcache, regno, buf);
 337         if (remote_debug)
 338           {
 339             printf_filtered ("gdbsim_fetch_register: %d", regno);
 340             /* FIXME: We could print something more intelligible.  */
 341             dump_mem (buf, register_size (gdbarch, regno));
 342           }
 343         break;
 344       }
 345     }
 346 }
 347
 348
 349 static void
 350 gdbsim_store_register (struct regcache *regcache, int regno)
 351 {
 352   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 353   if (regno == -1)
 354     {
 355       for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
 356         gdbsim_store_register (regcache, regno);
 357       return;
 358     }
 359   else if (gdbarch_register_sim_regno (gdbarch, regno) >= 0)
 360     {
 361       char tmp[MAX_REGISTER_SIZE];
 362       int nr_bytes;
 363       regcache_cooked_read (regcache, regno, tmp);
 364       nr_bytes = sim_store_register (gdbsim_desc,
 365                                      gdbarch_register_sim_regno
 366                                        (gdbarch, regno),
 367                                      tmp, register_size (gdbarch, regno));
 368       if (nr_bytes > 0 && nr_bytes != register_size (gdbarch, regno))
 369         internal_error (__FILE__, __LINE__,
 370                         _("Register size different to expected"));
 371       /* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0'
 372          indicating that GDB and the SIM have different ideas about
 373          which registers are fetchable.  */
 374       if (remote_debug)
 375         {
 376           printf_filtered ("gdbsim_store_register: %d", regno);
 377           /* FIXME: We could print something more intelligible.  */
 378           dump_mem (tmp, register_size (gdbarch, regno));
 379         }
 380     }
 381 }
 382
 383 /* Kill the running program.  This may involve closing any open files
 384    and releasing other resources acquired by the simulated program.  */
 385
 386 static void
 387 gdbsim_kill (void)
 388 {
 389   if (remote_debug)
 390     printf_filtered ("gdbsim_kill\n");
 391
 392   /* There is no need to `kill' running simulator - the simulator is
 393      not running.  Mourning it is enough.  */
 394   target_mourn_inferior ();
 395 }
 396
 397 /* Load an executable file into the target process.  This is expected to
 398    not only bring new code into the target process, but also to update
 399    GDB's symbol tables to match.  */
 400
 401 static void
 402 gdbsim_load (char *args, int fromtty)
 403 {
 404   char **argv;
 405   char *prog;
 406
 407   if (args == NULL)
 408       error_no_arg (_("program to load"));
 409
 410   argv = gdb_buildargv (args);
 411   make_cleanup_freeargv (argv);
 412
 413   prog = tilde_expand (argv[0]);
 414
 415   if (argv[1] != NULL)
 416     error (_("GDB sim does not yet support a load offset."));
 417
 418   if (remote_debug)
 419     printf_filtered ("gdbsim_load: prog \"%s\"\n", prog);
 420
 421   /* FIXME: We will print two messages on error.
 422      Need error to either not print anything if passed NULL or need
 423      another routine that doesn't take any arguments.  */
 424   if (sim_load (gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL)
 425     error (_("unable to load program"));
 426
 427   /* FIXME: If a load command should reset the targets registers then
 428      a call to sim_create_inferior() should go here. */
 429
 430   program_loaded = 1;
 431 }
 432
 433
 434 /* Start an inferior process and set inferior_ptid to its pid.
 435    EXEC_FILE is the file to run.
 436    ARGS is a string containing the arguments to the program.
 437    ENV is the environment vector to pass.  Errors reported with error().
 438    On VxWorks and various standalone systems, we ignore exec_file.  */
 439 /* This is called not only when we first attach, but also when the
 440    user types "run" after having attached.  */
 441
 442 static void
 443 gdbsim_create_inferior (struct target_ops *target, char *exec_file, char *args,
 444                         char **env, int from_tty)
 445 {
 446   int len;
 447   char *arg_buf, **argv;
 448
 449   if (exec_file == 0 || exec_bfd == 0)
 450     warning (_("No executable file specified."));
 451   if (!program_loaded)
 452     warning (_("No program loaded."));
 453
 454   if (remote_debug)
 455     printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
 456                      (exec_file ? exec_file : "(NULL)"),
 457                      args);
 458
 459   if (ptid_equal (inferior_ptid, remote_sim_ptid))
 460     gdbsim_kill ();
 461   remove_breakpoints ();
 462   init_wait_for_inferior ();
 463
 464   if (exec_file != NULL)
 465     {
 466       len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop */ 10;
 467       arg_buf = (char *) alloca (len);
 468       arg_buf[0] = '\0';
 469       strcat (arg_buf, exec_file);
 470       strcat (arg_buf, " ");
 471       strcat (arg_buf, args);
 472       argv = gdb_buildargv (arg_buf);
 473       make_cleanup_freeargv (argv);
 474     }
 475   else
 476     argv = NULL;
 477   sim_create_inferior (gdbsim_desc, exec_bfd, argv, env);
 478
 479   inferior_ptid = remote_sim_ptid;
 480   add_inferior_silent (ptid_get_pid (inferior_ptid));
 481   add_thread_silent (inferior_ptid);
 482
 483   target_mark_running (&gdbsim_ops);
 484   insert_breakpoints ();        /* Needed to get correct instruction in cache */
 485
 486   clear_proceed_status ();
 487 }
 488
 489 /* The open routine takes the rest of the parameters from the command,
 490    and (if successful) pushes a new target onto the stack.
 491    Targets should supply this routine, if only to provide an error message.  */
 492 /* Called when selecting the simulator. EG: (gdb) target sim name.  */
 493
 494 static void
 495 gdbsim_open (char *args, int from_tty)
 496 {
 497   int len;
 498   char *arg_buf;
 499   char **argv;
 500
 501   if (remote_debug)
 502     printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
 503
 504   /* Remove current simulator if one exists.  Only do this if the simulator
 505      has been opened because sim_close requires it.
 506      This is important because the call to push_target below will cause
 507      sim_close to be called if the simulator is already open, but push_target
 508      is called after sim_open!  We can't move the call to push_target before
 509      the call to sim_open because sim_open may invoke `error'.  */
 510   if (gdbsim_desc != NULL)
 511     unpush_target (&gdbsim_ops);
 512
 513   len = (7 + 1                  /* gdbsim */
 514          + strlen (" -E little")
 515          + strlen (" --architecture=xxxxxxxxxx")
 516          + (args ? strlen (args) : 0)
 517          + 50) /* slack */ ;
 518   arg_buf = (char *) alloca (len);
 519   strcpy (arg_buf, "gdbsim");   /* 7 */
 520   /* Specify the byte order for the target when it is explicitly
 521      specified by the user (not auto detected). */
 522   switch (selected_byte_order ())
 523     {
 524     case BFD_ENDIAN_BIG:
 525       strcat (arg_buf, " -E big");
 526       break;
 527     case BFD_ENDIAN_LITTLE:
 528       strcat (arg_buf, " -E little");
 529       break;
 530     case BFD_ENDIAN_UNKNOWN:
 531       break;
 532     }
 533   /* Specify the architecture of the target when it has been
 534      explicitly specified */
 535   if (selected_architecture_name () != NULL)
 536     {
 537       strcat (arg_buf, " --architecture=");
 538       strcat (arg_buf, selected_architecture_name ());
 539     }
 540   /* finally, any explicit args */
 541   if (args)
 542     {
 543       strcat (arg_buf, " ");    /* 1 */
 544       strcat (arg_buf, args);
 545     }
 546   argv = gdb_buildargv (arg_buf);
 547   make_cleanup_freeargv (argv);
 548
 549   init_callbacks ();
 550   gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, argv);
 551
 552   if (gdbsim_desc == 0)
 553     error (_("unable to create simulator instance"));
 554
 555   push_target (&gdbsim_ops);
 556   printf_filtered ("Connected to the simulator.\n");
 557
 558   /* There's nothing running after "target sim" or "load"; not until
 559      "run".  */
 560   inferior_ptid = null_ptid;
 561   target_mark_exited (&gdbsim_ops);
 562 }
 563
 564 /* Does whatever cleanup is required for a target that we are no longer
 565    going to be calling.  Argument says whether we are quitting gdb and
 566    should not get hung in case of errors, or whether we want a clean
 567    termination even if it takes a while.  This routine is automatically
 568    always called just before a routine is popped off the target stack.
 569    Closing file descriptors and freeing memory are typical things it should
 570    do.  */
 571 /* Close out all files and local state before this target loses control. */
 572
 573 static void
 574 gdbsim_close (int quitting)
 575 {
 576   if (remote_debug)
 577     printf_filtered ("gdbsim_close: quitting %d\n", quitting);
 578
 579   program_loaded = 0;
 580
 581   if (gdbsim_desc != NULL)
 582     {
 583       sim_close (gdbsim_desc, quitting);
 584       gdbsim_desc = NULL;
 585     }
 586
 587   end_callbacks ();
 588   generic_mourn_inferior ();
 589   delete_thread_silent (remote_sim_ptid);
 590   delete_inferior_silent (ptid_get_pid (remote_sim_ptid));
 591 }
 592
 593 /* Takes a program previously attached to and detaches it.
 594    The program may resume execution (some targets do, some don't) and will
 595    no longer stop on signals, etc.  We better not have left any breakpoints
 596    in the program or it'll die when it hits one.  ARGS is arguments
 597    typed by the user (e.g. a signal to send the process).  FROM_TTY
 598    says whether to be verbose or not.  */
 599 /* Terminate the open connection to the remote debugger.
 600    Use this when you want to detach and do something else with your gdb.  */
 601
 602 static void
 603 gdbsim_detach (struct target_ops *ops, char *args, int from_tty)
 604 {
 605   if (remote_debug)
 606     printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
 607
 608   pop_target ();                /* calls gdbsim_close to do the real work */
 609   if (from_tty)
 610     printf_filtered ("Ending simulator %s debugging\n", target_shortname);
 611 }
 612
 613 /* Resume execution of the target process.  STEP says whether to single-step
 614    or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
 615    to the target, or zero for no signal.  */
 616
 617 static enum target_signal resume_siggnal;
 618 static int resume_step;
 619
 620 static void
 621 gdbsim_resume (ptid_t ptid, int step, enum target_signal siggnal)
 622 {
 623   if (!ptid_equal (inferior_ptid, remote_sim_ptid))
 624     error (_("The program is not being run."));
 625
 626   if (remote_debug)
 627     printf_filtered ("gdbsim_resume: step %d, signal %d\n", step, siggnal);
 628
 629   resume_siggnal = siggnal;
 630   resume_step = step;
 631 }
 632
 633 /* Notify the simulator of an asynchronous request to stop.
 634
 635    The simulator shall ensure that the stop request is eventually
 636    delivered to the simulator.  If the call is made while the
 637    simulator is not running then the stop request is processed when
 638    the simulator is next resumed.
 639
 640    For simulators that do not support this operation, just abort */
 641
 642 static void
 643 gdbsim_stop (ptid_t ptid)
 644 {
 645   if (!sim_stop (gdbsim_desc))
 646     {
 647       quit ();
 648     }
 649 }
 650
 651 /* GDB version of os_poll_quit callback.
 652    Taken from gdb/util.c - should be in a library.  */
 653
 654 static int
 655 gdb_os_poll_quit (host_callback *p)
 656 {
 657   if (deprecated_ui_loop_hook != NULL)
 658     deprecated_ui_loop_hook (0);
 659
 660   if (quit_flag)                /* gdb's idea of quit */
 661     {
 662       quit_flag = 0;            /* we've stolen it */
 663       return 1;
 664     }
 665   else if (immediate_quit)
 666     {
 667       return 1;
 668     }
 669   return 0;
 670 }
 671
 672 /* Wait for inferior process to do something.  Return pid of child,
 673    or -1 in case of error; store status through argument pointer STATUS,
 674    just as `wait' would. */
 675
 676 static void
 677 gdbsim_cntrl_c (int signo)
 678 {
 679   gdbsim_stop (remote_sim_ptid);
 680 }
 681
 682 static ptid_t
 683 gdbsim_wait (ptid_t ptid, struct target_waitstatus *status)
 684 {
 685   static RETSIGTYPE (*prev_sigint) ();
 686   int sigrc = 0;
 687   enum sim_stop reason = sim_running;
 688
 689   if (remote_debug)
 690     printf_filtered ("gdbsim_wait\n");
 691
 692 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
 693   {
 694     struct sigaction sa, osa;
 695     sa.sa_handler = gdbsim_cntrl_c;
 696     sigemptyset (&sa.sa_mask);
 697     sa.sa_flags = 0;
 698     sigaction (SIGINT, &sa, &osa);
 699     prev_sigint = osa.sa_handler;
 700   }
 701 #else
 702   prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
 703 #endif
 704   sim_resume (gdbsim_desc, resume_step, resume_siggnal);
 705   signal (SIGINT, prev_sigint);
 706   resume_step = 0;
 707
 708   sim_stop_reason (gdbsim_desc, &reason, &sigrc);
 709
 710   switch (reason)
 711     {
 712     case sim_exited:
 713       status->kind = TARGET_WAITKIND_EXITED;
 714       status->value.integer = sigrc;
 715       break;
 716     case sim_stopped:
 717       switch (sigrc)
 718         {
 719         case TARGET_SIGNAL_ABRT:
 720           quit ();
 721           break;
 722         case TARGET_SIGNAL_INT:
 723         case TARGET_SIGNAL_TRAP:
 724         default:
 725           status->kind = TARGET_WAITKIND_STOPPED;
 726           status->value.sig = sigrc;
 727           break;
 728         }
 729       break;
 730     case sim_signalled:
 731       status->kind = TARGET_WAITKIND_SIGNALLED;
 732       status->value.sig = sigrc;
 733       break;
 734     case sim_running:
 735     case sim_polling:
 736       /* FIXME: Is this correct? */
 737       break;
 738     }
 739
 740   return inferior_ptid;
 741 }
 742
 743 /* Get ready to modify the registers array.  On machines which store
 744    individual registers, this doesn't need to do anything.  On machines
 745    which store all the registers in one fell swoop, this makes sure
 746    that registers contains all the registers from the program being
 747    debugged.  */
 748
 749 static void
 750 gdbsim_prepare_to_store (struct regcache *regcache)
 751 {
 752   /* Do nothing, since we can store individual regs */
 753 }
 754
 755 /* Transfer LEN bytes between GDB address MYADDR and target address
 756    MEMADDR.  If WRITE is non-zero, transfer them to the target,
 757    otherwise transfer them from the target.  TARGET is unused.
 758
 759    Returns the number of bytes transferred. */
 760
 761 static int
 762 gdbsim_xfer_inferior_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
 763                              int write, struct mem_attrib *attrib,
 764                              struct target_ops *target)
 765 {
 766   /* If no program is running yet, then ignore the simulator for
 767      memory.  Pass the request down to the next target, hopefully
 768      an exec file.  */
 769   if (!target_has_execution)
 770     return 0;
 771
 772   if (!program_loaded)
 773     error (_("No program loaded."));
 774
 775   if (remote_debug)
 776     {
 777       /* FIXME: Send to something other than STDOUT? */
 778       printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x");
 779       gdb_print_host_address (myaddr, gdb_stdout);
 780       printf_filtered (", memaddr 0x%s, len %d, write %d\n",
 781                        paddr_nz (memaddr), len, write);
 782       if (remote_debug && write)
 783         dump_mem (myaddr, len);
 784     }
 785
 786   if (write)
 787     {
 788       len = sim_write (gdbsim_desc, memaddr, myaddr, len);
 789     }
 790   else
 791     {
 792       len = sim_read (gdbsim_desc, memaddr, myaddr, len);
 793       if (remote_debug && len > 0)
 794         dump_mem (myaddr, len);
 795     }
 796   return len;
 797 }
 798
 799 static void
 800 gdbsim_files_info (struct target_ops *target)
 801 {
 802   char *file = "nothing";
 803
 804   if (exec_bfd)
 805     file = bfd_get_filename (exec_bfd);
 806
 807   if (remote_debug)
 808     printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
 809
 810   if (exec_bfd)
 811     {
 812       printf_filtered ("\tAttached to %s running program %s\n",
 813                        target_shortname, file);
 814       sim_info (gdbsim_desc, 0);
 815     }
 816 }
 817
 818 /* Clear the simulator's notion of what the break points are.  */
 819
 820 static void
 821 gdbsim_mourn_inferior (struct target_ops *target)
 822 {
 823   if (remote_debug)
 824     printf_filtered ("gdbsim_mourn_inferior:\n");
 825
 826   remove_breakpoints ();
 827   target_mark_exited (target);
 828   generic_mourn_inferior ();
 829   delete_thread_silent (remote_sim_ptid);
 830 }
 831
 832 /* Pass the command argument through to the simulator verbatim.  The
 833    simulator must do any command interpretation work.  */
 834
 835 void
 836 simulator_command (char *args, int from_tty)
 837 {
 838   if (gdbsim_desc == NULL)
 839     {
 840
 841       /* PREVIOUSLY: The user may give a command before the simulator
 842          is opened. [...] (??? assuming of course one wishes to
 843          continue to allow commands to be sent to unopened simulators,
 844          which isn't entirely unreasonable). */
 845
 846       /* The simulator is a builtin abstraction of a remote target.
 847          Consistent with that model, access to the simulator, via sim
 848          commands, is restricted to the period when the channel to the
 849          simulator is open. */
 850
 851       error (_("Not connected to the simulator target"));
 852     }
 853
 854   sim_do_command (gdbsim_desc, args);
 855
 856   /* Invalidate the register cache, in case the simulator command does
 857      something funny. */
 858   registers_changed ();
 859 }
 860
 861 /* Check to see if a thread is still alive.  */
 862
 863 static int
 864 gdbsim_thread_alive (ptid_t ptid)
 865 {
 866   if (ptid_equal (ptid, remote_sim_ptid))
 867     /* The simulators' task is always alive.  */
 868     return 1;
 869
 870   return 0;
 871 }
 872
 873 /* Convert a thread ID to a string.  Returns the string in a static
 874    buffer.  */
 875
 876 static char *
 877 gdbsim_pid_to_str (ptid_t ptid)
 878 {
 879   static char buf[64];
 880
 881   if (ptid_equal (remote_sim_ptid, ptid))
 882     {
 883       xsnprintf (buf, sizeof buf, "Thread <main>");
 884       return buf;
 885     }
 886
 887   return normal_pid_to_str (ptid);
 888 }
 889
 890 /* Define the target subroutine names */
 891
 892 struct target_ops gdbsim_ops;
 893
 894 static void
 895 init_gdbsim_ops (void)
 896 {
 897   gdbsim_ops.to_shortname = "sim";
 898   gdbsim_ops.to_longname = "simulator";
 899   gdbsim_ops.to_doc = "Use the compiled-in simulator.";
 900   gdbsim_ops.to_open = gdbsim_open;
 901   gdbsim_ops.to_close = gdbsim_close;
 902   gdbsim_ops.to_detach = gdbsim_detach;
 903   gdbsim_ops.to_resume = gdbsim_resume;
 904   gdbsim_ops.to_wait = gdbsim_wait;
 905   gdbsim_ops.to_fetch_registers = gdbsim_fetch_register;
 906   gdbsim_ops.to_store_registers = gdbsim_store_register;
 907   gdbsim_ops.to_prepare_to_store = gdbsim_prepare_to_store;
 908   gdbsim_ops.deprecated_xfer_memory = gdbsim_xfer_inferior_memory;
 909   gdbsim_ops.to_files_info = gdbsim_files_info;
 910   gdbsim_ops.to_insert_breakpoint = memory_insert_breakpoint;
 911   gdbsim_ops.to_remove_breakpoint = memory_remove_breakpoint;
 912   gdbsim_ops.to_kill = gdbsim_kill;
 913   gdbsim_ops.to_load = gdbsim_load;
 914   gdbsim_ops.to_create_inferior = gdbsim_create_inferior;
 915   gdbsim_ops.to_mourn_inferior = gdbsim_mourn_inferior;
 916   gdbsim_ops.to_stop = gdbsim_stop;
 917   gdbsim_ops.to_thread_alive = gdbsim_thread_alive;
 918   gdbsim_ops.to_pid_to_str = gdbsim_pid_to_str;
 919   gdbsim_ops.to_stratum = process_stratum;
 920   gdbsim_ops.to_has_all_memory = 1;
 921   gdbsim_ops.to_has_memory = 1;
 922   gdbsim_ops.to_has_stack = 1;
 923   gdbsim_ops.to_has_registers = 1;
 924   gdbsim_ops.to_has_execution = 1;
 925   gdbsim_ops.to_magic = OPS_MAGIC;
 926 }
 927
 928 void
 929 _initialize_remote_sim (void)
 930 {
 931   init_gdbsim_ops ();
 932   add_target (&gdbsim_ops);
 933
 934   add_com ("sim", class_obscure, simulator_command,
 935            _("Send a command to the simulator."));
 936
 937   /* Yes, 42000 is arbitrary.  The only sense out of it, is that it
 938      isn't 0.  */
 939   remote_sim_ptid = ptid_build (42000, 0, 42000);
 940 }