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