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