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