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