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 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 (REGISTER_NAME (regno) != NULL && *REGISTER_NAME (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                              REGISTER_NAME (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 (REGISTER_NAME (regno) != NULL && *REGISTER_NAME (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 executable 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 ((make_cleanup_func) freeargv, 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   if (TARGET_BYTE_ORDER_SELECTABLE_P
 532       && !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   /* Specify the architecture of the target when it has been
 547      explicitly specified */
 548   if (!TARGET_ARCHITECTURE_AUTO)
 549     {
 550       strcat (arg_buf, " --architecture=");
 551       strcat (arg_buf, TARGET_ARCHITECTURE->printable_name);
 552     }
 553   /* finally, any explicit args */
 554   if (args)
 555     {
 556       strcat (arg_buf, " "); /* 1 */
 557       strcat (arg_buf, args);
 558     }
 559   argv = buildargv (arg_buf);
 560   if (argv == NULL)
 561     error ("Insufficient memory available to allocate simulator arg list.");
 562   make_cleanup ((make_cleanup_func) freeargv, argv);
 563
 564   init_callbacks ();
 565   gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, argv);
 566
 567   if (gdbsim_desc == 0)
 568     error ("unable to create simulator instance");
 569
 570   push_target (&gdbsim_ops);
 571   target_fetch_registers (-1);
 572   printf_filtered ("Connected to the simulator.\n");
 573 }
 574
 575 /* Does whatever cleanup is required for a target that we are no longer
 576    going to be calling.  Argument says whether we are quitting gdb and
 577    should not get hung in case of errors, or whether we want a clean
 578    termination even if it takes a while.  This routine is automatically
 579    always called just before a routine is popped off the target stack.
 580    Closing file descriptors and freeing memory are typical things it should
 581    do.  */
 582 /* Close out all files and local state before this target loses control. */
 583
 584 static void
 585 gdbsim_close (quitting)
 586      int quitting;
 587 {
 588   if (sr_get_debug ())
 589     printf_filtered ("gdbsim_close: quitting %d\n", quitting);
 590
 591   program_loaded = 0;
 592
 593   if (gdbsim_desc != NULL)
 594     {
 595       sim_close (gdbsim_desc, quitting);
 596       gdbsim_desc = NULL;
 597     }
 598
 599   end_callbacks ();
 600 }
 601
 602 /* Takes a program previously attached to and detaches it.
 603    The program may resume execution (some targets do, some don't) and will
 604    no longer stop on signals, etc.  We better not have left any breakpoints
 605    in the program or it'll die when it hits one.  ARGS is arguments
 606    typed by the user (e.g. a signal to send the process).  FROM_TTY
 607    says whether to be verbose or not.  */
 608 /* Terminate the open connection to the remote debugger.
 609    Use this when you want to detach and do something else with your gdb.  */
 610
 611 static void
 612 gdbsim_detach (args,from_tty)
 613      char *args;
 614      int from_tty;
 615 {
 616   if (sr_get_debug ())
 617     printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
 618
 619   pop_target ();                /* calls gdbsim_close to do the real work */
 620   if (from_tty)
 621     printf_filtered ("Ending simulator %s debugging\n", target_shortname);
 622 }
 623
 624 /* Resume execution of the target process.  STEP says whether to single-step
 625    or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
 626    to the target, or zero for no signal.  */
 627
 628 static enum target_signal resume_siggnal;
 629 static int resume_step;
 630
 631 static void
 632 gdbsim_resume (pid, step, siggnal)
 633      int pid, step;
 634      enum target_signal siggnal;
 635 {
 636   if (inferior_pid != 42)
 637     error ("The program is not being run.");
 638
 639   if (sr_get_debug ())
 640     printf_filtered ("gdbsim_resume: step %d, signal %d\n", step, siggnal);
 641
 642   resume_siggnal = siggnal;
 643   resume_step = step;
 644 }
 645
 646 /* Notify the simulator of an asynchronous request to stop.
 647
 648    The simulator shall ensure that the stop request is eventually
 649    delivered to the simulator.  If the call is made while the
 650    simulator is not running then the stop request is processed when
 651    the simulator is next resumed.
 652
 653    For simulators that do not support this operation, just abort */
 654
 655 static void
 656 gdbsim_stop ()
 657 {
 658   if (! sim_stop (gdbsim_desc))
 659     {
 660       quit ();
 661     }
 662 }
 663
 664 /* GDB version of os_poll_quit callback.
 665    Taken from gdb/util.c - should be in a library */
 666
 667 static int
 668 gdb_os_poll_quit (p)
 669      host_callback *p;
 670 {
 671   notice_quit ();
 672   if (quit_flag) /* gdb's idea of quit */
 673     {
 674       quit_flag = 0; /* we've stolen it */
 675       return 1;
 676     }
 677   else if (immediate_quit)
 678     {
 679       return 1;
 680     }
 681   return 0;
 682 }
 683
 684 /* Wait for inferior process to do something.  Return pid of child,
 685    or -1 in case of error; store status through argument pointer STATUS,
 686    just as `wait' would. */
 687
 688 static void
 689 gdbsim_cntrl_c (signo)
 690      int signo;
 691 {
 692   gdbsim_stop ();
 693 }
 694
 695 static int
 696 gdbsim_wait (pid, status)
 697      int pid;
 698      struct target_waitstatus *status;
 699 {
 700   static RETSIGTYPE (*prev_sigint) ();
 701   int sigrc = 0;
 702   enum sim_stop reason = sim_running;
 703
 704   if (sr_get_debug ())
 705     printf_filtered ("gdbsim_wait\n");
 706
 707 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
 708   {
 709     struct sigaction sa, osa;
 710     sa.sa_handler = gdbsim_cntrl_c;
 711     sigemptyset (&sa.sa_mask);
 712     sa.sa_flags = 0;
 713     sigaction (SIGINT, &sa, &osa);
 714     prev_sigint = osa.sa_handler;
 715   }
 716 #else
 717   prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
 718 #endif
 719   sim_resume (gdbsim_desc, resume_step,
 720               target_signal_to_host (resume_siggnal));
 721   signal (SIGINT, prev_sigint);
 722   resume_step = 0;
 723
 724   sim_stop_reason (gdbsim_desc, &reason, &sigrc);
 725
 726   switch (reason)
 727     {
 728     case sim_exited:
 729       status->kind = TARGET_WAITKIND_EXITED;
 730       status->value.integer = sigrc;
 731       break;
 732     case sim_stopped:
 733       switch (sigrc)
 734         {
 735         case SIGABRT:
 736           quit ();
 737           break;
 738         case SIGINT:
 739         case SIGTRAP:
 740         default:
 741           status->kind = TARGET_WAITKIND_STOPPED;
 742           /* The signal in sigrc is a host signal.  That probably
 743              should be fixed.  */
 744           status->value.sig = target_signal_from_host (sigrc);
 745           break;
 746         }
 747       break;
 748     case sim_signalled:
 749       status->kind = TARGET_WAITKIND_SIGNALLED;
 750       /* The signal in sigrc is a host signal.  That probably
 751          should be fixed.  */
 752       status->value.sig = target_signal_from_host (sigrc);
 753       break;
 754     case sim_running:
 755     case sim_polling:
 756       /* FIXME: Is this correct? */
 757       break;
 758     }
 759
 760   return inferior_pid;
 761 }
 762
 763 /* Get ready to modify the registers array.  On machines which store
 764    individual registers, this doesn't need to do anything.  On machines
 765    which store all the registers in one fell swoop, this makes sure
 766    that registers contains all the registers from the program being
 767    debugged.  */
 768
 769 static void
 770 gdbsim_prepare_to_store ()
 771 {
 772   /* Do nothing, since we can store individual regs */
 773 }
 774
 775 static int
 776 gdbsim_xfer_inferior_memory (memaddr, myaddr, len, write, target)
 777      CORE_ADDR memaddr;
 778      char *myaddr;
 779      int len;
 780      int write;
 781      struct target_ops *target;                 /* ignored */
 782 {
 783   if (! program_loaded)
 784     error ("No program loaded.");
 785
 786   if (sr_get_debug ())
 787     {
 788       printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x%x, memaddr 0x%x, len %d, write %d\n",
 789                        myaddr, memaddr, len, write);
 790       if (sr_get_debug () && write)
 791         dump_mem(myaddr, len);
 792     }
 793
 794   if (write)
 795     {
 796       len = sim_write (gdbsim_desc, memaddr, myaddr, len);
 797     }
 798   else
 799     {
 800       len = sim_read (gdbsim_desc, memaddr, myaddr, len);
 801       if (sr_get_debug () && len > 0)
 802         dump_mem(myaddr, len);
 803     }
 804   return len;
 805 }
 806
 807 static void
 808 gdbsim_files_info (target)
 809      struct target_ops *target;
 810 {
 811   char *file = "nothing";
 812
 813   if (exec_bfd)
 814     file = bfd_get_filename (exec_bfd);
 815
 816   if (sr_get_debug ())
 817     printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
 818
 819   if (exec_bfd)
 820     {
 821       printf_filtered ("\tAttached to %s running program %s\n",
 822                        target_shortname, file);
 823       sim_info (gdbsim_desc, 0);
 824     }
 825 }
 826
 827 /* Clear the simulator's notion of what the break points are.  */
 828
 829 static void
 830 gdbsim_mourn_inferior ()
 831 {
 832   if (sr_get_debug ())
 833     printf_filtered ("gdbsim_mourn_inferior:\n");
 834
 835   remove_breakpoints ();
 836   generic_mourn_inferior ();
 837 }
 838
 839 static int
 840 gdbsim_insert_breakpoint (addr, contents_cache)
 841      CORE_ADDR addr;
 842      char *contents_cache;
 843 {
 844 #ifdef SIM_HAS_BREAKPOINTS
 845   SIM_RC retcode;
 846
 847   retcode = sim_set_breakpoint (gdbsim_desc, addr);
 848
 849   switch (retcode)
 850     {
 851     case SIM_RC_OK:
 852       return 0;
 853     case SIM_RC_INSUFFICIENT_RESOURCES:
 854       return ENOMEM;
 855     default:
 856       return EIO;
 857     }
 858 #else
 859   return memory_insert_breakpoint (addr, contents_cache);
 860 #endif
 861 }
 862
 863 static int
 864 gdbsim_remove_breakpoint (addr, contents_cache)
 865      CORE_ADDR addr;
 866      char *contents_cache;
 867 {
 868 #ifdef SIM_HAS_BREAKPOINTS
 869   SIM_RC retcode;
 870
 871   retcode = sim_clear_breakpoint (gdbsim_desc, addr);
 872
 873   switch (retcode)
 874     {
 875     case SIM_RC_OK:
 876     case SIM_RC_UNKNOWN_BREAKPOINT:
 877       return 0;
 878     case SIM_RC_INSUFFICIENT_RESOURCES:
 879       return ENOMEM;
 880     default:
 881       return EIO;
 882     }
 883 #else
 884   return memory_remove_breakpoint (addr, contents_cache);
 885 #endif
 886 }
 887
 888 /* Pass the command argument through to the simulator verbatim.  The
 889    simulator must do any command interpretation work.  */
 890
 891 void
 892 simulator_command (args, from_tty)
 893      char *args;
 894      int from_tty;
 895 {
 896   if (gdbsim_desc == NULL)
 897     {
 898
 899       /* PREVIOUSLY: The user may give a command before the simulator
 900          is opened. [...] (??? assuming of course one wishes to
 901          continue to allow commands to be sent to unopened simulators,
 902          which isn't entirely unreasonable). */
 903
 904       /* The simulator is a builtin abstraction of a remote target.
 905          Consistent with that model, access to the simulator, via sim
 906          commands, is restricted to the period when the channel to the
 907          simulator is open. */
 908
 909       error ("Not connected to the simulator target");
 910     }
 911
 912   sim_do_command (gdbsim_desc, args);
 913
 914   /* Invalidate the register cache, in case the simulator command does
 915      something funny. */
 916   registers_changed ();
 917 }
 918
 919 /* Define the target subroutine names */
 920
 921 struct target_ops gdbsim_ops ;
 922
 923 static void
 924 init_gdbsim_ops(void)
 925 {
 926   gdbsim_ops.to_shortname =   "sim";
 927   gdbsim_ops.to_longname =   "simulator";
 928   gdbsim_ops.to_doc =   "Use the compiled-in simulator.";
 929   gdbsim_ops.to_open =   gdbsim_open;
 930   gdbsim_ops.to_close =   gdbsim_close;
 931   gdbsim_ops.to_attach =   NULL;
 932   gdbsim_ops.to_post_attach = NULL;
 933   gdbsim_ops.to_require_attach = NULL;
 934   gdbsim_ops.to_detach =   gdbsim_detach;
 935   gdbsim_ops.to_require_detach = NULL;
 936   gdbsim_ops.to_resume =   gdbsim_resume;
 937   gdbsim_ops.to_wait  =   gdbsim_wait;
 938   gdbsim_ops.to_post_wait = NULL;
 939   gdbsim_ops.to_fetch_registers  =   gdbsim_fetch_register;
 940   gdbsim_ops.to_store_registers  =   gdbsim_store_register;
 941   gdbsim_ops.to_prepare_to_store =   gdbsim_prepare_to_store;
 942   gdbsim_ops.to_xfer_memory  =   gdbsim_xfer_inferior_memory;
 943   gdbsim_ops.to_files_info  =   gdbsim_files_info;
 944   gdbsim_ops.to_insert_breakpoint =   gdbsim_insert_breakpoint;
 945   gdbsim_ops.to_remove_breakpoint =   gdbsim_remove_breakpoint;
 946   gdbsim_ops.to_terminal_init  =   NULL;
 947   gdbsim_ops.to_terminal_inferior =   NULL;
 948   gdbsim_ops.to_terminal_ours_for_output =   NULL;
 949   gdbsim_ops.to_terminal_ours  =   NULL;
 950   gdbsim_ops.to_terminal_info  =   NULL;
 951   gdbsim_ops.to_kill  =   gdbsim_kill;
 952   gdbsim_ops.to_load  =   gdbsim_load;
 953   gdbsim_ops.to_lookup_symbol =   NULL;
 954   gdbsim_ops.to_create_inferior =   gdbsim_create_inferior;
 955   gdbsim_ops.to_post_startup_inferior = NULL;
 956   gdbsim_ops.to_acknowledge_created_inferior = NULL;
 957   gdbsim_ops.to_clone_and_follow_inferior = NULL;
 958   gdbsim_ops.to_post_follow_inferior_by_clone = NULL;
 959   gdbsim_ops.to_insert_fork_catchpoint = NULL;
 960   gdbsim_ops.to_remove_fork_catchpoint = NULL;
 961   gdbsim_ops.to_insert_vfork_catchpoint = NULL;
 962   gdbsim_ops.to_remove_vfork_catchpoint = NULL;
 963   gdbsim_ops.to_has_forked = NULL;
 964   gdbsim_ops.to_has_vforked = NULL;
 965   gdbsim_ops.to_can_follow_vfork_prior_to_exec = NULL;
 966   gdbsim_ops.to_post_follow_vfork = NULL;
 967   gdbsim_ops.to_insert_exec_catchpoint = NULL;
 968   gdbsim_ops.to_remove_exec_catchpoint = NULL;
 969   gdbsim_ops.to_has_execd = NULL;
 970   gdbsim_ops.to_reported_exec_events_per_exec_call = NULL;
 971   gdbsim_ops.to_has_exited = NULL;
 972   gdbsim_ops.to_mourn_inferior =   gdbsim_mourn_inferior;
 973   gdbsim_ops.to_can_run  =   0;
 974   gdbsim_ops.to_notice_signals =   0;
 975   gdbsim_ops.to_thread_alive  =   0;
 976   gdbsim_ops.to_stop  =   gdbsim_stop;
 977   gdbsim_ops.to_pid_to_exec_file = NULL;
 978   gdbsim_ops.to_core_file_to_sym_file = NULL;
 979   gdbsim_ops.to_stratum =   process_stratum;
 980   gdbsim_ops.DONT_USE =   NULL;
 981   gdbsim_ops.to_has_all_memory =   1;
 982   gdbsim_ops.to_has_memory =   1;
 983   gdbsim_ops.to_has_stack =   1;
 984   gdbsim_ops.to_has_registers =   1;
 985   gdbsim_ops.to_has_execution =   1;
 986   gdbsim_ops.to_sections =   NULL;
 987   gdbsim_ops.to_sections_end =   NULL;
 988   gdbsim_ops.to_magic =   OPS_MAGIC;
 989
 990 #ifdef TARGET_REDEFINE_DEFAULT_OPS
 991   TARGET_REDEFINE_DEFAULT_OPS (&gdbsim_ops);
 992 #endif
 993 }
 994
 995 void
 996 _initialize_remote_sim ()
 997 {
 998   init_gdbsim_ops() ;
 999   add_target (&gdbsim_ops);
1000
1001   add_com ("sim <command>", class_obscure, simulator_command,
1002            "Send a command to the simulator.");
1003 }