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