gdb/remote-sim.c

   1 /* Generic remote debugging interface for simulators.
   2    Copyright 1993, 1994, 1996, 1997 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support.
   4    Steve Chamberlain (sac@cygnus.com).
   5
   6 This file is part of GDB.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "inferior.h"
  24 #include "wait.h"
  25 #include "value.h"
  26 #include "gdb_string.h"
  27 #include <ctype.h>
  28 #include <fcntl.h>
  29 #include <signal.h>
  30 #include <setjmp.h>
  31 #include <errno.h>
  32 #include "terminal.h"
  33 #include "target.h"
  34 #include "gdbcore.h"
  35 #include "callback.h"
  36 #include "remote-sim.h"
  37 #include "remote-utils.h"
  38 #include "command.h"
  39
  40 /* Prototypes */
  41
  42 extern void _initialize_remote_sim PARAMS ((void));
  43
  44 extern int (*ui_loop_hook) PARAMS ((int signo));
  45
  46 static void dump_mem PARAMS ((char *buf, int len));
  47
  48 static void init_callbacks PARAMS ((void));
  49
  50 static void end_callbacks PARAMS ((void));
  51
  52 static int gdb_os_write_stdout PARAMS ((host_callback *, const char *, int));
  53
  54 static void gdb_os_flush_stdout PARAMS ((host_callback *));
  55
  56 static int gdb_os_write_stderr PARAMS ((host_callback *, const char *, int));
  57
  58 static void gdb_os_flush_stderr PARAMS ((host_callback *));
  59
  60 static int gdb_os_poll_quit PARAMS ((host_callback *));
  61
  62 /* printf_filtered is depreciated */
  63 static void gdb_os_printf_filtered PARAMS ((host_callback *, const char *, ...));
  64
  65 static void gdb_os_vprintf_filtered PARAMS ((host_callback *, const char *, va_list));
  66
  67 static void gdb_os_evprintf_filtered PARAMS ((host_callback *, const char *, va_list));
  68
  69 static void gdb_os_error PARAMS ((host_callback *, const char *, ...));
  70
  71 static void gdbsim_fetch_register PARAMS ((int regno));
  72
  73 static void gdbsim_store_register PARAMS ((int regno));
  74
  75 static void gdbsim_kill PARAMS ((void));
  76
  77 static void gdbsim_load PARAMS ((char *prog, int fromtty));
  78
  79 static void gdbsim_create_inferior PARAMS ((char *exec_file, char *args, char **env));
  80
  81 static void gdbsim_open PARAMS ((char *args, int from_tty));
  82
  83 static void gdbsim_close PARAMS ((int quitting));
  84
  85 static void gdbsim_detach PARAMS ((char *args, int from_tty));
  86
  87 static void gdbsim_resume PARAMS ((int pid, int step, enum target_signal siggnal));
  88
  89 static int gdbsim_wait PARAMS ((int pid, struct target_waitstatus *status));
  90
  91 static void gdbsim_prepare_to_store PARAMS ((void));
  92
  93 static int gdbsim_xfer_inferior_memory PARAMS ((CORE_ADDR memaddr,
  94                                                 char *myaddr, int len,
  95                                                 int write,
  96                                                 struct target_ops *target));
  97
  98 static void gdbsim_files_info PARAMS ((struct target_ops *target));
  99
 100 static void gdbsim_mourn_inferior PARAMS ((void));
 101
 102 static void gdbsim_stop PARAMS ((void));
 103
 104 void simulator_command PARAMS ((char *args, int from_tty));
 105
 106 /* Naming convention:
 107
 108    sim_* are the interface to the simulator (see remote-sim.h).
 109    gdbsim_* are stuff which is internal to gdb.  */
 110
 111 /* Forward data declarations */
 112 extern struct target_ops gdbsim_ops;
 113
 114 static int program_loaded = 0;
 115
 116 /* We must keep track of whether the simulator has been opened or not because
 117    GDB can call a target's close routine twice, but sim_close doesn't allow
 118    this.  We also need to record the result of sim_open so we can pass it
 119    back to the other sim_foo routines.  */
 120 static SIM_DESC gdbsim_desc = 0;
 121
 122 static void
 123 dump_mem (buf, len)
 124      char *buf;
 125      int len;
 126 {
 127   if (len <= 8)
 128     {
 129       if (len == 8 || len == 4)
 130         {
 131           long l[2];
 132           memcpy (l, buf, len);
 133           printf_filtered ("\t0x%x", l[0]);
 134           printf_filtered (len == 8 ? " 0x%x\n" : "\n", l[1]);
 135         }
 136       else
 137         {
 138           int i;
 139           printf_filtered ("\t");
 140           for (i = 0; i < len; i++)
 141             printf_filtered ("0x%x ", buf[i]);
 142           printf_filtered ("\n");
 143         }
 144     }
 145 }
 146
 147 static host_callback gdb_callback;
 148 static int callbacks_initialized = 0;
 149
 150 /* Initialize gdb_callback.  */
 151
 152 static void
 153 init_callbacks ()
 154 {
 155   if (! callbacks_initialized)
 156     {
 157       gdb_callback = default_callback;
 158       gdb_callback.init (&gdb_callback);
 159       gdb_callback.write_stdout = gdb_os_write_stdout;
 160       gdb_callback.flush_stdout = gdb_os_flush_stdout;
 161       gdb_callback.write_stderr = gdb_os_write_stderr;
 162       gdb_callback.flush_stderr = gdb_os_flush_stderr;
 163       gdb_callback.printf_filtered = gdb_os_printf_filtered;
 164       gdb_callback.vprintf_filtered = gdb_os_vprintf_filtered;
 165       gdb_callback.evprintf_filtered = gdb_os_evprintf_filtered;
 166       gdb_callback.error = gdb_os_error;
 167       gdb_callback.poll_quit = gdb_os_poll_quit;
 168       gdb_callback.magic = HOST_CALLBACK_MAGIC;
 169       callbacks_initialized = 1;
 170     }
 171 }
 172
 173 /* Release callbacks (free resources used by them).  */
 174
 175 static void
 176 end_callbacks ()
 177 {
 178   if (callbacks_initialized)
 179     {
 180       gdb_callback.shutdown (&gdb_callback);
 181       callbacks_initialized = 0;
 182     }
 183 }
 184
 185 /* GDB version of os_write_stdout callback.  */
 186
 187 static int
 188 gdb_os_write_stdout (p, buf, len)
 189      host_callback *p;
 190      const char *buf;
 191      int len;
 192 {
 193   int i;
 194   char b[2];
 195
 196   for (i = 0; i < len; i++)
 197     {
 198       b[0] = buf[i];
 199       b[1] = 0;
 200       if (target_output_hook)
 201         target_output_hook (b);
 202       else
 203         fputs_filtered (b, gdb_stdout);
 204     }
 205   return len;
 206 }
 207
 208 /* GDB version of os_flush_stdout callback.  */
 209
 210 static void
 211 gdb_os_flush_stdout (p)
 212      host_callback *p;
 213 {
 214   gdb_flush (gdb_stdout);
 215 }
 216
 217 /* GDB version of os_write_stderr callback.  */
 218
 219 static int
 220 gdb_os_write_stderr (p, buf, len)
 221      host_callback *p;
 222      const char *buf;
 223      int len;
 224 {
 225   int i;
 226   char b[2];
 227
 228   for (i = 0; i < len; i++)
 229     {
 230       b[0] = buf[i];
 231       b[1] = 0;
 232       if (target_output_hook)
 233         target_output_hook (b);
 234       else
 235         fputs_filtered (b, gdb_stderr);
 236     }
 237   return len;
 238 }
 239
 240 /* GDB version of os_flush_stderr callback.  */
 241
 242 static void
 243 gdb_os_flush_stderr (p)
 244      host_callback *p;
 245 {
 246   gdb_flush (gdb_stderr);
 247 }
 248
 249 /* GDB version of printf_filtered callback.  */
 250
 251 /* VARARGS */
 252 static void
 253 #ifdef ANSI_PROTOTYPES
 254 gdb_os_printf_filtered (host_callback *p, const char *format, ...)
 255 #else
 256 gdb_os_printf_filtered (p, va_alist)
 257      host_callback *p;
 258      va_dcl
 259 #endif
 260 {
 261   va_list args;
 262 #ifdef ANSI_PROTOTYPES
 263   va_start (args, format);
 264 #else
 265   char *format;
 266
 267   va_start (args);
 268   format = va_arg (args, char *);
 269 #endif
 270
 271   vfprintf_filtered (gdb_stdout, format, args);
 272
 273   va_end (args);
 274 }
 275
 276 /* GDB version of error vprintf_filtered.  */
 277
 278 /* VARARGS */
 279 static void
 280 #ifdef ANSI_PROTOTYPES
 281 gdb_os_vprintf_filtered (host_callback *p, const char *format, va_list ap)
 282 #else
 283 gdb_os_vprintf_filtered (p, format, ap)
 284      host_callback *p;
 285      char *format;
 286      va_list ap;
 287 #endif
 288 {
 289   vfprintf_filtered (gdb_stdout, format, ap);
 290 }
 291
 292 /* GDB version of error evprintf_filtered.  */
 293
 294 /* VARARGS */
 295 static void
 296 #ifdef ANSI_PROTOTYPES
 297 gdb_os_evprintf_filtered (host_callback *p, const char *format, va_list ap)
 298 #else
 299 gdb_os_evprintf_filtered (p, format, ap)
 300      host_callback *p;
 301      char *format;
 302      va_list ap;
 303 #endif
 304 {
 305   vfprintf_filtered (gdb_stderr, format, ap);
 306 }
 307
 308 /* GDB version of error callback.  */
 309
 310 /* VARARGS */
 311 static void
 312 #ifdef ANSI_PROTOTYPES
 313 gdb_os_error (host_callback *p, const char *format, ...)
 314 #else
 315 gdb_os_error (p, va_alist)
 316      host_callback *p;
 317      va_dcl
 318 #endif
 319 {
 320   if (error_hook)
 321     (*error_hook) ();
 322   else
 323     {
 324       va_list args;
 325 #ifdef ANSI_PROTOTYPES
 326       va_start (args, format);
 327 #else
 328       char *format;
 329
 330       va_start (args);
 331       format = va_arg (args, char *);
 332 #endif
 333
 334       error_begin ();
 335       vfprintf_filtered (gdb_stderr, format, args);
 336       fprintf_filtered (gdb_stderr, "\n");
 337       va_end (args);
 338       return_to_top_level (RETURN_ERROR);
 339     }
 340 }
 341
 342 static void
 343 gdbsim_fetch_register (regno)
 344      int regno;
 345 {
 346   static int warn_user = 1;
 347   if (regno == -1)
 348     {
 349       for (regno = 0; regno < NUM_REGS; regno++)
 350         gdbsim_fetch_register (regno);
 351     }
 352   else if (REGISTER_NAME (regno) != NULL && *REGISTER_NAME (regno) != '\0')
 353     {
 354       char buf[MAX_REGISTER_RAW_SIZE];
 355       int nr_bytes = sim_fetch_register (gdbsim_desc, regno, buf, REGISTER_RAW_SIZE (regno));
 356       if (nr_bytes == 0)
 357         /* register not applicable, supply zero's */
 358         memset (buf, 0, MAX_REGISTER_RAW_SIZE);
 359       else if (nr_bytes > 0 && nr_bytes != REGISTER_RAW_SIZE (regno)
 360                && warn_user)
 361         {
 362           printf_unfiltered ("Size of register %s (%d) incorrect (%d instead of %d))",
 363                              REGISTER_NAME (regno), regno,
 364                              nr_bytes, REGISTER_RAW_SIZE (regno));
 365           warn_user = 0;
 366         }
 367       supply_register (regno, buf);
 368       if (sr_get_debug ())
 369         {
 370           printf_filtered ("gdbsim_fetch_register: %d", regno);
 371           /* FIXME: We could print something more intelligible.  */
 372           dump_mem (buf, REGISTER_RAW_SIZE (regno));
 373         }
 374     }
 375 }
 376
 377
 378 static void
 379 gdbsim_store_register (regno)
 380      int regno;
 381 {
 382   if (regno  == -1)
 383     {
 384       for (regno = 0; regno < NUM_REGS; regno++)
 385         gdbsim_store_register (regno);
 386     }
 387   else if (REGISTER_NAME (regno) != NULL && *REGISTER_NAME (regno) != '\0')
 388     {
 389       char tmp[MAX_REGISTER_RAW_SIZE];
 390       int nr_bytes;
 391       read_register_gen (regno, tmp);
 392       nr_bytes = sim_store_register (gdbsim_desc, regno, tmp, REGISTER_RAW_SIZE (regno));
 393       if (nr_bytes > 0 && nr_bytes != REGISTER_RAW_SIZE (regno))
 394         fatal ("Register size different to expected");
 395       if (sr_get_debug ())
 396         {
 397           printf_filtered ("gdbsim_store_register: %d", regno);
 398           /* FIXME: We could print something more intelligible.  */
 399           dump_mem (tmp, REGISTER_RAW_SIZE (regno));
 400         }
 401     }
 402 }
 403
 404 /* Kill the running program.  This may involve closing any open files
 405    and releasing other resources acquired by the simulated program.  */
 406
 407 static void
 408 gdbsim_kill ()
 409 {
 410   if (sr_get_debug ())
 411     printf_filtered ("gdbsim_kill\n");
 412
 413   /* There is no need to `kill' running simulator - the simulator is
 414      not running */
 415   inferior_pid = 0;
 416 }
 417
 418 /* Load an executable file into the target process.  This is expected to
 419    not only bring new code into the target process, but also to update
 420    GDB's symbol tables to match.  */
 421
 422 static void
 423 gdbsim_load (prog, fromtty)
 424      char *prog;
 425      int fromtty;
 426 {
 427   if (sr_get_debug ())
 428     printf_filtered ("gdbsim_load: prog \"%s\"\n", prog);
 429
 430   inferior_pid = 0;
 431
 432   /* FIXME: We will print two messages on error.
 433      Need error to either not print anything if passed NULL or need
 434      another routine that doesn't take any arguments.  */
 435   if (sim_load (gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL)
 436     error ("unable to load program");
 437
 438   /* FIXME: If a load command should reset the targets registers then
 439      a call to sim_create_inferior() should go here. */
 440
 441   program_loaded = 1;
 442 }
 443
 444
 445 /* Start an inferior process and set inferior_pid to its pid.
 446    EXEC_FILE is the file to run.
 447    ARGS is a string containing the arguments to the program.
 448    ENV is the environment vector to pass.  Errors reported with error().
 449    On VxWorks and various standalone systems, we ignore exec_file.  */
 450 /* This is called not only when we first attach, but also when the
 451    user types "run" after having attached.  */
 452
 453 static void
 454 gdbsim_create_inferior (exec_file, args, env)
 455      char *exec_file;
 456      char *args;
 457      char **env;
 458 {
 459   int len;
 460   char *arg_buf,**argv;
 461
 462   if (exec_file == 0 || exec_bfd == 0)
 463     warning ("No executable file specified.");
 464   if (! program_loaded)
 465     warning ("No program loaded.");
 466
 467   if (sr_get_debug ())
 468     printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
 469                      (exec_file ? exec_file: "(NULL)"),
 470                      args);
 471
 472   gdbsim_kill ();
 473   remove_breakpoints ();
 474   init_wait_for_inferior ();
 475
 476   if (exec_file != NULL)
 477     {
 478       len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop*/ 10;
 479       arg_buf = (char *) alloca (len);
 480       arg_buf[0] = '\0';
 481       strcat (arg_buf, exec_file);
 482       strcat (arg_buf, " ");
 483       strcat (arg_buf, args);
 484       argv = buildargv (arg_buf);
 485       make_cleanup_freeargv (argv);
 486     }
 487   else
 488     argv = NULL;
 489   sim_create_inferior (gdbsim_desc, exec_bfd, argv, env);
 490
 491   inferior_pid = 42;
 492   insert_breakpoints (); /* Needed to get correct instruction in cache */
 493
 494   clear_proceed_status ();
 495
 496   /* NB: Entry point already set by sim_create_inferior. */
 497   proceed ((CORE_ADDR)-1, TARGET_SIGNAL_DEFAULT, 0);
 498 }
 499
 500 /* The open routine takes the rest of the parameters from the command,
 501    and (if successful) pushes a new target onto the stack.
 502    Targets should supply this routine, if only to provide an error message.  */
 503 /* Called when selecting the simulator. EG: (gdb) target sim name.  */
 504
 505 static void
 506 gdbsim_open (args, from_tty)
 507      char *args;
 508      int from_tty;
 509 {
 510   int len;
 511   char *arg_buf;
 512   char **argv;
 513
 514   if (sr_get_debug ())
 515     printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
 516
 517   /* Remove current simulator if one exists.  Only do this if the simulator
 518      has been opened because sim_close requires it.
 519      This is important because the call to push_target below will cause
 520      sim_close to be called if the simulator is already open, but push_target
 521      is called after sim_open!  We can't move the call to push_target before
 522      the call to sim_open because sim_open may invoke `error'.  */
 523   if (gdbsim_desc != NULL)
 524     unpush_target (&gdbsim_ops);
 525
 526   len = (7 + 1 /* gdbsim */
 527          + strlen (" -E little")
 528          + strlen (" --architecture=xxxxxxxxxx")
 529          + (args ? strlen (args) : 0)
 530          + 50) /* slack */;
 531   arg_buf = (char *) alloca (len);
 532   strcpy (arg_buf, "gdbsim"); /* 7 */
 533   /* Specify the byte order for the target when it is both selectable
 534      and explicitly specified by the user (not auto detected). */
 535   if (TARGET_BYTE_ORDER_SELECTABLE_P
 536       && !TARGET_BYTE_ORDER_AUTO)
 537     {
 538       switch (TARGET_BYTE_ORDER)
 539         {
 540         case BIG_ENDIAN:
 541           strcat (arg_buf, " -E big");
 542           break;
 543         case LITTLE_ENDIAN:
 544           strcat (arg_buf, " -E little");
 545           break;
 546         default:
 547           fatal ("Value of TARGET_BYTE_ORDER unknown");
 548         }
 549     }
 550   /* Specify the architecture of the target when it has been
 551      explicitly specified */
 552   if (!TARGET_ARCHITECTURE_AUTO)
 553     {
 554       strcat (arg_buf, " --architecture=");
 555       strcat (arg_buf, TARGET_ARCHITECTURE->printable_name);
 556     }
 557   /* finally, any explicit args */
 558   if (args)
 559     {
 560       strcat (arg_buf, " "); /* 1 */
 561       strcat (arg_buf, args);
 562     }
 563   argv = buildargv (arg_buf);
 564   if (argv == NULL)
 565     error ("Insufficient memory available to allocate simulator arg list.");
 566   make_cleanup_freeargv (argv);
 567
 568   init_callbacks ();
 569   gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, argv);
 570
 571   if (gdbsim_desc == 0)
 572     error ("unable to create simulator instance");
 573
 574   push_target (&gdbsim_ops);
 575   target_fetch_registers (-1);
 576   printf_filtered ("Connected to the simulator.\n");
 577 }
 578
 579 /* Does whatever cleanup is required for a target that we are no longer
 580    going to be calling.  Argument says whether we are quitting gdb and
 581    should not get hung in case of errors, or whether we want a clean
 582    termination even if it takes a while.  This routine is automatically
 583    always called just before a routine is popped off the target stack.
 584    Closing file descriptors and freeing memory are typical things it should
 585    do.  */
 586 /* Close out all files and local state before this target loses control. */
 587
 588 static void
 589 gdbsim_close (quitting)
 590      int quitting;
 591 {
 592   if (sr_get_debug ())
 593     printf_filtered ("gdbsim_close: quitting %d\n", quitting);
 594
 595   program_loaded = 0;
 596
 597   if (gdbsim_desc != NULL)
 598     {
 599       sim_close (gdbsim_desc, quitting);
 600       gdbsim_desc = NULL;
 601     }
 602
 603   end_callbacks ();
 604 }
 605
 606 /* Takes a program previously attached to and detaches it.
 607    The program may resume execution (some targets do, some don't) and will
 608    no longer stop on signals, etc.  We better not have left any breakpoints
 609    in the program or it'll die when it hits one.  ARGS is arguments
 610    typed by the user (e.g. a signal to send the process).  FROM_TTY
 611    says whether to be verbose or not.  */
 612 /* Terminate the open connection to the remote debugger.
 613    Use this when you want to detach and do something else with your gdb.  */
 614
 615 static void
 616 gdbsim_detach (args,from_tty)
 617      char *args;
 618      int from_tty;
 619 {
 620   if (sr_get_debug ())
 621     printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
 622
 623   pop_target ();                /* calls gdbsim_close to do the real work */
 624   if (from_tty)
 625     printf_filtered ("Ending simulator %s debugging\n", target_shortname);
 626 }
 627
 628 /* Resume execution of the target process.  STEP says whether to single-step
 629    or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
 630    to the target, or zero for no signal.  */
 631
 632 static enum target_signal resume_siggnal;
 633 static int resume_step;
 634
 635 static void
 636 gdbsim_resume (pid, step, siggnal)
 637      int pid, step;
 638      enum target_signal siggnal;
 639 {
 640   if (inferior_pid != 42)
 641     error ("The program is not being run.");
 642
 643   if (sr_get_debug ())
 644     printf_filtered ("gdbsim_resume: step %d, signal %d\n", step, siggnal);
 645
 646   resume_siggnal = siggnal;
 647   resume_step = step;
 648 }
 649
 650 /* Notify the simulator of an asynchronous request to stop.
 651
 652    The simulator shall ensure that the stop request is eventually
 653    delivered to the simulator.  If the call is made while the
 654    simulator is not running then the stop request is processed when
 655    the simulator is next resumed.
 656
 657    For simulators that do not support this operation, just abort */
 658
 659 static void
 660 gdbsim_stop ()
 661 {
 662   if (! sim_stop (gdbsim_desc))
 663     {
 664       quit ();
 665     }
 666 }
 667
 668 /* GDB version of os_poll_quit callback.
 669    Taken from gdb/util.c - should be in a library */
 670
 671 static int
 672 gdb_os_poll_quit (p)
 673      host_callback *p;
 674 {
 675   if (ui_loop_hook != NULL)
 676     ui_loop_hook (0);
 677
 678   notice_quit ();
 679   if (quit_flag) /* gdb's idea of quit */
 680     {
 681       quit_flag = 0; /* we've stolen it */
 682       return 1;
 683     }
 684   else if (immediate_quit)
 685     {
 686       return 1;
 687     }
 688   return 0;
 689 }
 690
 691 /* Wait for inferior process to do something.  Return pid of child,
 692    or -1 in case of error; store status through argument pointer STATUS,
 693    just as `wait' would. */
 694
 695 static void
 696 gdbsim_cntrl_c (signo)
 697      int signo;
 698 {
 699   gdbsim_stop ();
 700 }
 701
 702 static int
 703 gdbsim_wait (pid, status)
 704      int pid;
 705      struct target_waitstatus *status;
 706 {
 707   static RETSIGTYPE (*prev_sigint) ();
 708   int sigrc = 0;
 709   enum sim_stop reason = sim_running;
 710
 711   if (sr_get_debug ())
 712     printf_filtered ("gdbsim_wait\n");
 713
 714 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
 715   {
 716     struct sigaction sa, osa;
 717     sa.sa_handler = gdbsim_cntrl_c;
 718     sigemptyset (&sa.sa_mask);
 719     sa.sa_flags = 0;
 720     sigaction (SIGINT, &sa, &osa);
 721     prev_sigint = osa.sa_handler;
 722   }
 723 #else
 724   prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
 725 #endif
 726   sim_resume (gdbsim_desc, resume_step,
 727               target_signal_to_host (resume_siggnal));
 728   signal (SIGINT, prev_sigint);
 729   resume_step = 0;
 730
 731   sim_stop_reason (gdbsim_desc, &reason, &sigrc);
 732
 733   switch (reason)
 734     {
 735     case sim_exited:
 736       status->kind = TARGET_WAITKIND_EXITED;
 737       status->value.integer = sigrc;
 738       break;
 739     case sim_stopped:
 740       switch (sigrc)
 741         {
 742         case SIGABRT:
 743           quit ();
 744           break;
 745         case SIGINT:
 746         case SIGTRAP:
 747         default:
 748           status->kind = TARGET_WAITKIND_STOPPED;
 749           /* The signal in sigrc is a host signal.  That probably
 750              should be fixed.  */
 751           status->value.sig = target_signal_from_host (sigrc);
 752           break;
 753         }
 754       break;
 755     case sim_signalled:
 756       status->kind = TARGET_WAITKIND_SIGNALLED;
 757       /* The signal in sigrc is a host signal.  That probably
 758          should be fixed.  */
 759       status->value.sig = target_signal_from_host (sigrc);
 760       break;
 761     case sim_running:
 762     case sim_polling:
 763       /* FIXME: Is this correct? */
 764       break;
 765     }
 766
 767   return inferior_pid;
 768 }
 769
 770 /* Get ready to modify the registers array.  On machines which store
 771    individual registers, this doesn't need to do anything.  On machines
 772    which store all the registers in one fell swoop, this makes sure
 773    that registers contains all the registers from the program being
 774    debugged.  */
 775
 776 static void
 777 gdbsim_prepare_to_store ()
 778 {
 779   /* Do nothing, since we can store individual regs */
 780 }
 781
 782 static int
 783 gdbsim_xfer_inferior_memory (memaddr, myaddr, len, write, target)
 784      CORE_ADDR memaddr;
 785      char *myaddr;
 786      int len;
 787      int write;
 788      struct target_ops *target;                 /* ignored */
 789 {
 790   if (! program_loaded)
 791     error ("No program loaded.");
 792
 793   if (sr_get_debug ())
 794     {
 795       printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x%x, memaddr 0x%x, len %d, write %d\n",
 796                        myaddr, memaddr, len, write);
 797       if (sr_get_debug () && write)
 798         dump_mem(myaddr, len);
 799     }
 800
 801   if (write)
 802     {
 803       len = sim_write (gdbsim_desc, memaddr, myaddr, len);
 804     }
 805   else
 806     {
 807       len = sim_read (gdbsim_desc, memaddr, myaddr, len);
 808       if (sr_get_debug () && len > 0)
 809         dump_mem(myaddr, len);
 810     }
 811   return len;
 812 }
 813
 814 static void
 815 gdbsim_files_info (target)
 816      struct target_ops *target;
 817 {
 818   char *file = "nothing";
 819
 820   if (exec_bfd)
 821     file = bfd_get_filename (exec_bfd);
 822
 823   if (sr_get_debug ())
 824     printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
 825
 826   if (exec_bfd)
 827     {
 828       printf_filtered ("\tAttached to %s running program %s\n",
 829                        target_shortname, file);
 830       sim_info (gdbsim_desc, 0);
 831     }
 832 }
 833
 834 /* Clear the simulator's notion of what the break points are.  */
 835
 836 static void
 837 gdbsim_mourn_inferior ()
 838 {
 839   if (sr_get_debug ())
 840     printf_filtered ("gdbsim_mourn_inferior:\n");
 841
 842   remove_breakpoints ();
 843   generic_mourn_inferior ();
 844 }
 845
 846 static int
 847 gdbsim_insert_breakpoint (addr, contents_cache)
 848      CORE_ADDR addr;
 849      char *contents_cache;
 850 {
 851 #ifdef SIM_HAS_BREAKPOINTS
 852   SIM_RC retcode;
 853
 854   retcode = sim_set_breakpoint (gdbsim_desc, addr);
 855
 856   switch (retcode)
 857     {
 858     case SIM_RC_OK:
 859       return 0;
 860     case SIM_RC_INSUFFICIENT_RESOURCES:
 861       return ENOMEM;
 862     default:
 863       return EIO;
 864     }
 865 #else
 866   return memory_insert_breakpoint (addr, contents_cache);
 867 #endif
 868 }
 869
 870 static int
 871 gdbsim_remove_breakpoint (addr, contents_cache)
 872      CORE_ADDR addr;
 873      char *contents_cache;
 874 {
 875 #ifdef SIM_HAS_BREAKPOINTS
 876   SIM_RC retcode;
 877
 878   retcode = sim_clear_breakpoint (gdbsim_desc, addr);
 879
 880   switch (retcode)
 881     {
 882     case SIM_RC_OK:
 883     case SIM_RC_UNKNOWN_BREAKPOINT:
 884       return 0;
 885     case SIM_RC_INSUFFICIENT_RESOURCES:
 886       return ENOMEM;
 887     default:
 888       return EIO;
 889     }
 890 #else
 891   return memory_remove_breakpoint (addr, contents_cache);
 892 #endif
 893 }
 894
 895 /* Pass the command argument through to the simulator verbatim.  The
 896    simulator must do any command interpretation work.  */
 897
 898 void
 899 simulator_command (args, from_tty)
 900      char *args;
 901      int from_tty;
 902 {
 903   if (gdbsim_desc == NULL)
 904     {
 905
 906       /* PREVIOUSLY: The user may give a command before the simulator
 907          is opened. [...] (??? assuming of course one wishes to
 908          continue to allow commands to be sent to unopened simulators,
 909          which isn't entirely unreasonable). */
 910
 911       /* The simulator is a builtin abstraction of a remote target.
 912          Consistent with that model, access to the simulator, via sim
 913          commands, is restricted to the period when the channel to the
 914          simulator is open. */
 915
 916       error ("Not connected to the simulator target");
 917     }
 918
 919   sim_do_command (gdbsim_desc, args);
 920
 921   /* Invalidate the register cache, in case the simulator command does
 922      something funny. */
 923   registers_changed ();
 924 }
 925
 926 /* Define the target subroutine names */
 927
 928 struct target_ops gdbsim_ops ;
 929
 930 static void
 931 init_gdbsim_ops(void)
 932 {
 933   gdbsim_ops.to_shortname =   "sim";
 934   gdbsim_ops.to_longname =   "simulator";
 935   gdbsim_ops.to_doc =   "Use the compiled-in simulator.";
 936   gdbsim_ops.to_open =   gdbsim_open;
 937   gdbsim_ops.to_close =   gdbsim_close;
 938   gdbsim_ops.to_attach =   NULL;
 939   gdbsim_ops.to_post_attach = NULL;
 940   gdbsim_ops.to_require_attach = NULL;
 941   gdbsim_ops.to_detach =   gdbsim_detach;
 942   gdbsim_ops.to_require_detach = NULL;
 943   gdbsim_ops.to_resume =   gdbsim_resume;
 944   gdbsim_ops.to_wait  =   gdbsim_wait;
 945   gdbsim_ops.to_post_wait = NULL;
 946   gdbsim_ops.to_fetch_registers  =   gdbsim_fetch_register;
 947   gdbsim_ops.to_store_registers  =   gdbsim_store_register;
 948   gdbsim_ops.to_prepare_to_store =   gdbsim_prepare_to_store;
 949   gdbsim_ops.to_xfer_memory  =   gdbsim_xfer_inferior_memory;
 950   gdbsim_ops.to_files_info  =   gdbsim_files_info;
 951   gdbsim_ops.to_insert_breakpoint =   gdbsim_insert_breakpoint;
 952   gdbsim_ops.to_remove_breakpoint =   gdbsim_remove_breakpoint;
 953   gdbsim_ops.to_terminal_init  =   NULL;
 954   gdbsim_ops.to_terminal_inferior =   NULL;
 955   gdbsim_ops.to_terminal_ours_for_output =   NULL;
 956   gdbsim_ops.to_terminal_ours  =   NULL;
 957   gdbsim_ops.to_terminal_info  =   NULL;
 958   gdbsim_ops.to_kill  =   gdbsim_kill;
 959   gdbsim_ops.to_load  =   gdbsim_load;
 960   gdbsim_ops.to_lookup_symbol =   NULL;
 961   gdbsim_ops.to_create_inferior =   gdbsim_create_inferior;
 962   gdbsim_ops.to_post_startup_inferior = NULL;
 963   gdbsim_ops.to_acknowledge_created_inferior = NULL;
 964   gdbsim_ops.to_clone_and_follow_inferior = NULL;
 965   gdbsim_ops.to_post_follow_inferior_by_clone = NULL;
 966   gdbsim_ops.to_insert_fork_catchpoint = NULL;
 967   gdbsim_ops.to_remove_fork_catchpoint = NULL;
 968   gdbsim_ops.to_insert_vfork_catchpoint = NULL;
 969   gdbsim_ops.to_remove_vfork_catchpoint = NULL;
 970   gdbsim_ops.to_has_forked = NULL;
 971   gdbsim_ops.to_has_vforked = NULL;
 972   gdbsim_ops.to_can_follow_vfork_prior_to_exec = NULL;
 973   gdbsim_ops.to_post_follow_vfork = NULL;
 974   gdbsim_ops.to_insert_exec_catchpoint = NULL;
 975   gdbsim_ops.to_remove_exec_catchpoint = NULL;
 976   gdbsim_ops.to_has_execd = NULL;
 977   gdbsim_ops.to_reported_exec_events_per_exec_call = NULL;
 978   gdbsim_ops.to_has_exited = NULL;
 979   gdbsim_ops.to_mourn_inferior =   gdbsim_mourn_inferior;
 980   gdbsim_ops.to_can_run  =   0;
 981   gdbsim_ops.to_notice_signals =   0;
 982   gdbsim_ops.to_thread_alive  =   0;
 983   gdbsim_ops.to_stop  =   gdbsim_stop;
 984   gdbsim_ops.to_pid_to_exec_file = NULL;
 985   gdbsim_ops.to_core_file_to_sym_file = NULL;
 986   gdbsim_ops.to_stratum =   process_stratum;
 987   gdbsim_ops.DONT_USE =   NULL;
 988   gdbsim_ops.to_has_all_memory =   1;
 989   gdbsim_ops.to_has_memory =   1;
 990   gdbsim_ops.to_has_stack =   1;
 991   gdbsim_ops.to_has_registers =   1;
 992   gdbsim_ops.to_has_execution =   1;
 993   gdbsim_ops.to_sections =   NULL;
 994   gdbsim_ops.to_sections_end =   NULL;
 995   gdbsim_ops.to_magic =   OPS_MAGIC;
 996
 997 #ifdef TARGET_REDEFINE_DEFAULT_OPS
 998   TARGET_REDEFINE_DEFAULT_OPS (&gdbsim_ops);
 999 #endif
1000 }
1001
1002 void
1003 _initialize_remote_sim ()
1004 {
1005   init_gdbsim_ops() ;
1006   add_target (&gdbsim_ops);
1007
1008   add_com ("sim <command>", class_obscure, simulator_command,
1009            "Send a command to the simulator.");
1010 }