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