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 *, ...) 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   inferior_appeared (current_inferior (), ptid_get_pid (inferior_ptid));
 475   add_thread_silent (inferior_ptid);
 476
 477   insert_breakpoints ();        /* Needed to get correct instruction in cache */
 478
 479   clear_proceed_status ();
 480 }
 481
 482 /* The open routine takes the rest of the parameters from the command,
 483    and (if successful) pushes a new target onto the stack.
 484    Targets should supply this routine, if only to provide an error message.  */
 485 /* Called when selecting the simulator. EG: (gdb) target sim name.  */
 486
 487 static void
 488 gdbsim_open (char *args, int from_tty)
 489 {
 490   int len;
 491   char *arg_buf;
 492   char **argv;
 493
 494   if (remote_debug)
 495     printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
 496
 497   /* Remove current simulator if one exists.  Only do this if the simulator
 498      has been opened because sim_close requires it.
 499      This is important because the call to push_target below will cause
 500      sim_close to be called if the simulator is already open, but push_target
 501      is called after sim_open!  We can't move the call to push_target before
 502      the call to sim_open because sim_open may invoke `error'.  */
 503   if (gdbsim_desc != NULL)
 504     unpush_target (&gdbsim_ops);
 505
 506   len = (7 + 1                  /* gdbsim */
 507          + strlen (" -E little")
 508          + strlen (" --architecture=xxxxxxxxxx")
 509          + (args ? strlen (args) : 0)
 510          + 50) /* slack */ ;
 511   arg_buf = (char *) alloca (len);
 512   strcpy (arg_buf, "gdbsim");   /* 7 */
 513   /* Specify the byte order for the target when it is explicitly
 514      specified by the user (not auto detected). */
 515   switch (selected_byte_order ())
 516     {
 517     case BFD_ENDIAN_BIG:
 518       strcat (arg_buf, " -E big");
 519       break;
 520     case BFD_ENDIAN_LITTLE:
 521       strcat (arg_buf, " -E little");
 522       break;
 523     case BFD_ENDIAN_UNKNOWN:
 524       break;
 525     }
 526   /* Specify the architecture of the target when it has been
 527      explicitly specified */
 528   if (selected_architecture_name () != NULL)
 529     {
 530       strcat (arg_buf, " --architecture=");
 531       strcat (arg_buf, selected_architecture_name ());
 532     }
 533   /* finally, any explicit args */
 534   if (args)
 535     {
 536       strcat (arg_buf, " ");    /* 1 */
 537       strcat (arg_buf, args);
 538     }
 539   argv = gdb_buildargv (arg_buf);
 540   make_cleanup_freeargv (argv);
 541
 542   init_callbacks ();
 543   gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, argv);
 544
 545   if (gdbsim_desc == 0)
 546     error (_("unable to create simulator instance"));
 547
 548   push_target (&gdbsim_ops);
 549   printf_filtered ("Connected to the simulator.\n");
 550
 551   /* There's nothing running after "target sim" or "load"; not until
 552      "run".  */
 553   inferior_ptid = null_ptid;
 554 }
 555
 556 /* Does whatever cleanup is required for a target that we are no longer
 557    going to be calling.  Argument says whether we are quitting gdb and
 558    should not get hung in case of errors, or whether we want a clean
 559    termination even if it takes a while.  This routine is automatically
 560    always called just before a routine is popped off the target stack.
 561    Closing file descriptors and freeing memory are typical things it should
 562    do.  */
 563 /* Close out all files and local state before this target loses control. */
 564
 565 static void
 566 gdbsim_close (int quitting)
 567 {
 568   if (remote_debug)
 569     printf_filtered ("gdbsim_close: quitting %d\n", quitting);
 570
 571   program_loaded = 0;
 572
 573   if (gdbsim_desc != NULL)
 574     {
 575       sim_close (gdbsim_desc, quitting);
 576       gdbsim_desc = NULL;
 577     }
 578
 579   end_callbacks ();
 580   generic_mourn_inferior ();
 581   delete_thread_silent (remote_sim_ptid);
 582   delete_inferior_silent (ptid_get_pid (remote_sim_ptid));
 583 }
 584
 585 /* Takes a program previously attached to and detaches it.
 586    The program may resume execution (some targets do, some don't) and will
 587    no longer stop on signals, etc.  We better not have left any breakpoints
 588    in the program or it'll die when it hits one.  ARGS is arguments
 589    typed by the user (e.g. a signal to send the process).  FROM_TTY
 590    says whether to be verbose or not.  */
 591 /* Terminate the open connection to the remote debugger.
 592    Use this when you want to detach and do something else with your gdb.  */
 593
 594 static void
 595 gdbsim_detach (struct target_ops *ops, char *args, int from_tty)
 596 {
 597   if (remote_debug)
 598     printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
 599
 600   pop_target ();                /* calls gdbsim_close to do the real work */
 601   if (from_tty)
 602     printf_filtered ("Ending simulator %s debugging\n", target_shortname);
 603 }
 604
 605 /* Resume execution of the target process.  STEP says whether to single-step
 606    or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
 607    to the target, or zero for no signal.  */
 608
 609 static enum target_signal resume_siggnal;
 610 static int resume_step;
 611
 612 static void
 613 gdbsim_resume (struct target_ops *ops,
 614                ptid_t ptid, int step, enum target_signal siggnal)
 615 {
 616   if (!ptid_equal (inferior_ptid, remote_sim_ptid))
 617     error (_("The program is not being run."));
 618
 619   if (remote_debug)
 620     printf_filtered ("gdbsim_resume: step %d, signal %d\n", step, siggnal);
 621
 622   resume_siggnal = siggnal;
 623   resume_step = step;
 624 }
 625
 626 /* Notify the simulator of an asynchronous request to stop.
 627
 628    The simulator shall ensure that the stop request is eventually
 629    delivered to the simulator.  If the call is made while the
 630    simulator is not running then the stop request is processed when
 631    the simulator is next resumed.
 632
 633    For simulators that do not support this operation, just abort */
 634
 635 static void
 636 gdbsim_stop (ptid_t ptid)
 637 {
 638   if (!sim_stop (gdbsim_desc))
 639     {
 640       quit ();
 641     }
 642 }
 643
 644 /* GDB version of os_poll_quit callback.
 645    Taken from gdb/util.c - should be in a library.  */
 646
 647 static int
 648 gdb_os_poll_quit (host_callback *p)
 649 {
 650   if (deprecated_ui_loop_hook != NULL)
 651     deprecated_ui_loop_hook (0);
 652
 653   if (quit_flag)                /* gdb's idea of quit */
 654     {
 655       quit_flag = 0;            /* we've stolen it */
 656       return 1;
 657     }
 658   else if (immediate_quit)
 659     {
 660       return 1;
 661     }
 662   return 0;
 663 }
 664
 665 /* Wait for inferior process to do something.  Return pid of child,
 666    or -1 in case of error; store status through argument pointer STATUS,
 667    just as `wait' would. */
 668
 669 static void
 670 gdbsim_cntrl_c (int signo)
 671 {
 672   gdbsim_stop (remote_sim_ptid);
 673 }
 674
 675 static ptid_t
 676 gdbsim_wait (struct target_ops *ops,
 677              ptid_t ptid, struct target_waitstatus *status, int options)
 678 {
 679   static RETSIGTYPE (*prev_sigint) ();
 680   int sigrc = 0;
 681   enum sim_stop reason = sim_running;
 682
 683   if (remote_debug)
 684     printf_filtered ("gdbsim_wait\n");
 685
 686 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
 687   {
 688     struct sigaction sa, osa;
 689     sa.sa_handler = gdbsim_cntrl_c;
 690     sigemptyset (&sa.sa_mask);
 691     sa.sa_flags = 0;
 692     sigaction (SIGINT, &sa, &osa);
 693     prev_sigint = osa.sa_handler;
 694   }
 695 #else
 696   prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
 697 #endif
 698   sim_resume (gdbsim_desc, resume_step, resume_siggnal);
 699   signal (SIGINT, prev_sigint);
 700   resume_step = 0;
 701
 702   sim_stop_reason (gdbsim_desc, &reason, &sigrc);
 703
 704   switch (reason)
 705     {
 706     case sim_exited:
 707       status->kind = TARGET_WAITKIND_EXITED;
 708       status->value.integer = sigrc;
 709       break;
 710     case sim_stopped:
 711       switch (sigrc)
 712         {
 713         case TARGET_SIGNAL_ABRT:
 714           quit ();
 715           break;
 716         case TARGET_SIGNAL_INT:
 717         case TARGET_SIGNAL_TRAP:
 718         default:
 719           status->kind = TARGET_WAITKIND_STOPPED;
 720           status->value.sig = sigrc;
 721           break;
 722         }
 723       break;
 724     case sim_signalled:
 725       status->kind = TARGET_WAITKIND_SIGNALLED;
 726       status->value.sig = sigrc;
 727       break;
 728     case sim_running:
 729     case sim_polling:
 730       /* FIXME: Is this correct? */
 731       break;
 732     }
 733
 734   return inferior_ptid;
 735 }
 736
 737 /* Get ready to modify the registers array.  On machines which store
 738    individual registers, this doesn't need to do anything.  On machines
 739    which store all the registers in one fell swoop, this makes sure
 740    that registers contains all the registers from the program being
 741    debugged.  */
 742
 743 static void
 744 gdbsim_prepare_to_store (struct regcache *regcache)
 745 {
 746   /* Do nothing, since we can store individual regs */
 747 }
 748
 749 /* Transfer LEN bytes between GDB address MYADDR and target address
 750    MEMADDR.  If WRITE is non-zero, transfer them to the target,
 751    otherwise transfer them from the target.  TARGET is unused.
 752
 753    Returns the number of bytes transferred. */
 754
 755 static int
 756 gdbsim_xfer_inferior_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
 757                              int write, struct mem_attrib *attrib,
 758                              struct target_ops *target)
 759 {
 760   /* If no program is running yet, then ignore the simulator for
 761      memory.  Pass the request down to the next target, hopefully
 762      an exec file.  */
 763   if (!target_has_execution)
 764     return 0;
 765
 766   if (!program_loaded)
 767     error (_("No program loaded."));
 768
 769   if (remote_debug)
 770     {
 771       /* FIXME: Send to something other than STDOUT? */
 772       printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x");
 773       gdb_print_host_address (myaddr, gdb_stdout);
 774       printf_filtered (", memaddr %s, len %d, write %d\n",
 775                        paddress (target_gdbarch, memaddr), len, write);
 776       if (remote_debug && write)
 777         dump_mem (myaddr, len);
 778     }
 779
 780   if (write)
 781     {
 782       len = sim_write (gdbsim_desc, memaddr, myaddr, len);
 783     }
 784   else
 785     {
 786       len = sim_read (gdbsim_desc, memaddr, myaddr, len);
 787       if (remote_debug && len > 0)
 788         dump_mem (myaddr, len);
 789     }
 790   return len;
 791 }
 792
 793 static void
 794 gdbsim_files_info (struct target_ops *target)
 795 {
 796   char *file = "nothing";
 797
 798   if (exec_bfd)
 799     file = bfd_get_filename (exec_bfd);
 800
 801   if (remote_debug)
 802     printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
 803
 804   if (exec_bfd)
 805     {
 806       printf_filtered ("\tAttached to %s running program %s\n",
 807                        target_shortname, file);
 808       sim_info (gdbsim_desc, 0);
 809     }
 810 }
 811
 812 /* Clear the simulator's notion of what the break points are.  */
 813
 814 static void
 815 gdbsim_mourn_inferior (struct target_ops *target)
 816 {
 817   if (remote_debug)
 818     printf_filtered ("gdbsim_mourn_inferior:\n");
 819
 820   remove_breakpoints ();
 821   generic_mourn_inferior ();
 822   delete_thread_silent (remote_sim_ptid);
 823 }
 824
 825 /* Pass the command argument through to the simulator verbatim.  The
 826    simulator must do any command interpretation work.  */
 827
 828 void
 829 simulator_command (char *args, int from_tty)
 830 {
 831   if (gdbsim_desc == NULL)
 832     {
 833
 834       /* PREVIOUSLY: The user may give a command before the simulator
 835          is opened. [...] (??? assuming of course one wishes to
 836          continue to allow commands to be sent to unopened simulators,
 837          which isn't entirely unreasonable). */
 838
 839       /* The simulator is a builtin abstraction of a remote target.
 840          Consistent with that model, access to the simulator, via sim
 841          commands, is restricted to the period when the channel to the
 842          simulator is open. */
 843
 844       error (_("Not connected to the simulator target"));
 845     }
 846
 847   sim_do_command (gdbsim_desc, args);
 848
 849   /* Invalidate the register cache, in case the simulator command does
 850      something funny. */
 851   registers_changed ();
 852 }
 853
 854 /* Check to see if a thread is still alive.  */
 855
 856 static int
 857 gdbsim_thread_alive (struct target_ops *ops, ptid_t ptid)
 858 {
 859   if (ptid_equal (ptid, remote_sim_ptid))
 860     /* The simulators' task is always alive.  */
 861     return 1;
 862
 863   return 0;
 864 }
 865
 866 /* Convert a thread ID to a string.  Returns the string in a static
 867    buffer.  */
 868
 869 static char *
 870 gdbsim_pid_to_str (struct target_ops *ops, ptid_t ptid)
 871 {
 872   static char buf[64];
 873
 874   if (ptid_equal (remote_sim_ptid, ptid))
 875     {
 876       xsnprintf (buf, sizeof buf, "Thread <main>");
 877       return buf;
 878     }
 879
 880   return normal_pid_to_str (ptid);
 881 }
 882
 883 /* Define the target subroutine names */
 884
 885 struct target_ops gdbsim_ops;
 886
 887 static void
 888 init_gdbsim_ops (void)
 889 {
 890   gdbsim_ops.to_shortname = "sim";
 891   gdbsim_ops.to_longname = "simulator";
 892   gdbsim_ops.to_doc = "Use the compiled-in simulator.";
 893   gdbsim_ops.to_open = gdbsim_open;
 894   gdbsim_ops.to_close = gdbsim_close;
 895   gdbsim_ops.to_detach = gdbsim_detach;
 896   gdbsim_ops.to_resume = gdbsim_resume;
 897   gdbsim_ops.to_wait = gdbsim_wait;
 898   gdbsim_ops.to_fetch_registers = gdbsim_fetch_register;
 899   gdbsim_ops.to_store_registers = gdbsim_store_register;
 900   gdbsim_ops.to_prepare_to_store = gdbsim_prepare_to_store;
 901   gdbsim_ops.deprecated_xfer_memory = gdbsim_xfer_inferior_memory;
 902   gdbsim_ops.to_files_info = gdbsim_files_info;
 903   gdbsim_ops.to_insert_breakpoint = memory_insert_breakpoint;
 904   gdbsim_ops.to_remove_breakpoint = memory_remove_breakpoint;
 905   gdbsim_ops.to_kill = gdbsim_kill;
 906   gdbsim_ops.to_load = gdbsim_load;
 907   gdbsim_ops.to_create_inferior = gdbsim_create_inferior;
 908   gdbsim_ops.to_mourn_inferior = gdbsim_mourn_inferior;
 909   gdbsim_ops.to_stop = gdbsim_stop;
 910   gdbsim_ops.to_thread_alive = gdbsim_thread_alive;
 911   gdbsim_ops.to_pid_to_str = gdbsim_pid_to_str;
 912   gdbsim_ops.to_stratum = process_stratum;
 913   gdbsim_ops.to_has_all_memory = default_child_has_all_memory;
 914   gdbsim_ops.to_has_memory = default_child_has_memory;
 915   gdbsim_ops.to_has_stack = default_child_has_stack;
 916   gdbsim_ops.to_has_registers = default_child_has_registers;
 917   gdbsim_ops.to_has_execution = default_child_has_execution;
 918   gdbsim_ops.to_magic = OPS_MAGIC;
 919 }
 920
 921 void
 922 _initialize_remote_sim (void)
 923 {
 924   init_gdbsim_ops ();
 925   add_target (&gdbsim_ops);
 926
 927   add_com ("sim", class_obscure, simulator_command,
 928            _("Send a command to the simulator."));
 929
 930   /* Yes, 42000 is arbitrary.  The only sense out of it, is that it
 931      isn't 0.  */
 932   remote_sim_ptid = ptid_build (42000, 0, 42000);
 933 }