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