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