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