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