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