gdb/remote-sim.c

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