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