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