gdb/remote-sim.c

   1 /* Generic remote debugging interface for simulators.
   2    Copyright 1993, 1994, 1996, 1997, 2000 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 "gdb_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 (void);
  44
  45 extern int (*ui_loop_hook) (int signo);
  46
  47 static void dump_mem (char *buf, int len);
  48
  49 static void init_callbacks (void);
  50
  51 static void end_callbacks (void);
  52
  53 static int gdb_os_write_stdout (host_callback *, const char *, int);
  54
  55 static void gdb_os_flush_stdout (host_callback *);
  56
  57 static int gdb_os_write_stderr (host_callback *, const char *, int);
  58
  59 static void gdb_os_flush_stderr (host_callback *);
  60
  61 static int gdb_os_poll_quit (host_callback *);
  62
  63 /* printf_filtered is depreciated */
  64 static void gdb_os_printf_filtered (host_callback *, const char *, ...);
  65
  66 static void gdb_os_vprintf_filtered (host_callback *, const char *, va_list);
  67
  68 static void gdb_os_evprintf_filtered (host_callback *, const char *, va_list);
  69
  70 static void gdb_os_error (host_callback *, const char *, ...);
  71
  72 static void gdbsim_fetch_register (int regno);
  73
  74 static void gdbsim_store_register (int regno);
  75
  76 static void gdbsim_kill (void);
  77
  78 static void gdbsim_load (char *prog, int fromtty);
  79
  80 static void gdbsim_create_inferior (char *exec_file, char *args, char **env);
  81
  82 static void gdbsim_open (char *args, int from_tty);
  83
  84 static void gdbsim_close (int quitting);
  85
  86 static void gdbsim_detach (char *args, int from_tty);
  87
  88 static void gdbsim_resume (int pid, int step, enum target_signal siggnal);
  89
  90 static int gdbsim_wait (int pid, struct target_waitstatus *status);
  91
  92 static void gdbsim_prepare_to_store (void);
  93
  94 static int gdbsim_xfer_inferior_memory (CORE_ADDR memaddr,
  95                                         char *myaddr, int len,
  96                                         int write, struct target_ops *target);
  97
  98 static void gdbsim_files_info (struct target_ops *target);
  99
 100 static void gdbsim_mourn_inferior (void);
 101
 102 static void gdbsim_stop (void);
 103
 104 void simulator_command (char *args, int from_tty);
 105
 106 /* Naming convention:
 107
 108    sim_* are the interface to the simulator (see remote-sim.h).
 109    gdbsim_* are stuff which is internal to gdb.  */
 110
 111 /* Forward data declarations */
 112 extern struct target_ops gdbsim_ops;
 113
 114 static int program_loaded = 0;
 115
 116 /* We must keep track of whether the simulator has been opened or not because
 117    GDB can call a target's close routine twice, but sim_close doesn't allow
 118    this.  We also need to record the result of sim_open so we can pass it
 119    back to the other sim_foo routines.  */
 120 static SIM_DESC gdbsim_desc = 0;
 121
 122 static void
 123 dump_mem (buf, len)
 124      char *buf;
 125      int len;
 126 {
 127   if (len <= 8)
 128     {
 129       if (len == 8 || len == 4)
 130         {
 131           long l[2];
 132           memcpy (l, buf, len);
 133           printf_filtered ("\t0x%lx", l[0]);
 134           printf_filtered (len == 8 ? " 0x%x\n" : "\n", l[1]);
 135         }
 136       else
 137         {
 138           int i;
 139           printf_filtered ("\t");
 140           for (i = 0; i < len; i++)
 141             printf_filtered ("0x%x ", buf[i]);
 142           printf_filtered ("\n");
 143         }
 144     }
 145 }
 146
 147 static host_callback gdb_callback;
 148 static int callbacks_initialized = 0;
 149
 150 /* Initialize gdb_callback.  */
 151
 152 static void
 153 init_callbacks ()
 154 {
 155   if (!callbacks_initialized)
 156     {
 157       gdb_callback = default_callback;
 158       gdb_callback.init (&gdb_callback);
 159       gdb_callback.write_stdout = gdb_os_write_stdout;
 160       gdb_callback.flush_stdout = gdb_os_flush_stdout;
 161       gdb_callback.write_stderr = gdb_os_write_stderr;
 162       gdb_callback.flush_stderr = gdb_os_flush_stderr;
 163       gdb_callback.printf_filtered = gdb_os_printf_filtered;
 164       gdb_callback.vprintf_filtered = gdb_os_vprintf_filtered;
 165       gdb_callback.evprintf_filtered = gdb_os_evprintf_filtered;
 166       gdb_callback.error = gdb_os_error;
 167       gdb_callback.poll_quit = gdb_os_poll_quit;
 168       gdb_callback.magic = HOST_CALLBACK_MAGIC;
 169       callbacks_initialized = 1;
 170     }
 171 }
 172
 173 /* Release callbacks (free resources used by them).  */
 174
 175 static void
 176 end_callbacks ()
 177 {
 178   if (callbacks_initialized)
 179     {
 180       gdb_callback.shutdown (&gdb_callback);
 181       callbacks_initialized = 0;
 182     }
 183 }
 184
 185 /* GDB version of os_write_stdout callback.  */
 186
 187 static int
 188 gdb_os_write_stdout (p, buf, len)
 189      host_callback *p;
 190      const char *buf;
 191      int len;
 192 {
 193   int i;
 194   char b[2];
 195
 196   ui_file_write (gdb_stdtarg, buf, len);
 197   return len;
 198 }
 199
 200 /* GDB version of os_flush_stdout callback.  */
 201
 202 static void
 203 gdb_os_flush_stdout (p)
 204      host_callback *p;
 205 {
 206   gdb_flush (gdb_stdtarg);
 207 }
 208
 209 /* GDB version of os_write_stderr callback.  */
 210
 211 static int
 212 gdb_os_write_stderr (p, buf, len)
 213      host_callback *p;
 214      const char *buf;
 215      int len;
 216 {
 217   int i;
 218   char b[2];
 219
 220   for (i = 0; i < len; i++)
 221     {
 222       b[0] = buf[i];
 223       b[1] = 0;
 224       fputs_unfiltered (b, gdb_stdtarg);
 225     }
 226   return len;
 227 }
 228
 229 /* GDB version of os_flush_stderr callback.  */
 230
 231 static void
 232 gdb_os_flush_stderr (p)
 233      host_callback *p;
 234 {
 235   gdb_flush (gdb_stderr);
 236 }
 237
 238 /* GDB version of printf_filtered callback.  */
 239
 240 static void
 241 gdb_os_printf_filtered (host_callback * p, const char *format,...)
 242 {
 243   va_list args;
 244   va_start (args, format);
 245
 246   vfprintf_filtered (gdb_stdout, format, args);
 247
 248   va_end (args);
 249 }
 250
 251 /* GDB version of error vprintf_filtered.  */
 252
 253 static void
 254 gdb_os_vprintf_filtered (host_callback * p, const char *format, va_list ap)
 255 {
 256   vfprintf_filtered (gdb_stdout, format, ap);
 257 }
 258
 259 /* GDB version of error evprintf_filtered.  */
 260
 261 static void
 262 gdb_os_evprintf_filtered (host_callback * p, const char *format, va_list ap)
 263 {
 264   vfprintf_filtered (gdb_stderr, format, ap);
 265 }
 266
 267 /* GDB version of error callback.  */
 268
 269 static void
 270 gdb_os_error (host_callback * p, const char *format,...)
 271 {
 272   if (error_hook)
 273     (*error_hook) ();
 274   else
 275     {
 276       va_list args;
 277       va_start (args, format);
 278       verror (format, args);
 279       va_end (args);
 280     }
 281 }
 282
 283 #ifndef REGISTER_SIM_REGNO
 284 #define REGISTER_SIM_REGNO(N) (N)
 285 #endif
 286
 287 static void
 288 gdbsim_fetch_register (regno)
 289      int regno;
 290 {
 291   static int warn_user = 1;
 292   if (regno == -1)
 293     {
 294       for (regno = 0; regno < NUM_REGS; regno++)
 295         gdbsim_fetch_register (regno);
 296     }
 297   else if (REGISTER_NAME (regno) != NULL
 298            && *REGISTER_NAME (regno) != '\0')
 299     {
 300       char buf[MAX_REGISTER_RAW_SIZE];
 301       int nr_bytes;
 302       if (REGISTER_SIM_REGNO (regno) >= 0)
 303         nr_bytes = sim_fetch_register (gdbsim_desc,
 304                                        REGISTER_SIM_REGNO (regno),
 305                                        buf, REGISTER_RAW_SIZE (regno));
 306       else
 307         nr_bytes = 0;
 308       if (nr_bytes == 0)
 309         /* register not applicable, supply zero's */
 310         memset (buf, 0, MAX_REGISTER_RAW_SIZE);
 311       else if (nr_bytes > 0 && nr_bytes != REGISTER_RAW_SIZE (regno)
 312                && warn_user)
 313         {
 314           fprintf_unfiltered (gdb_stderr,
 315                               "Size of register %s (%d/%d) incorrect (%d instead of %d))",
 316                               REGISTER_NAME (regno),
 317                               regno, REGISTER_SIM_REGNO (regno),
 318                               nr_bytes, REGISTER_RAW_SIZE (regno));
 319           warn_user = 0;
 320         }
 321       supply_register (regno, buf);
 322       if (sr_get_debug ())
 323         {
 324           printf_filtered ("gdbsim_fetch_register: %d", regno);
 325           /* FIXME: We could print something more intelligible.  */
 326           dump_mem (buf, REGISTER_RAW_SIZE (regno));
 327         }
 328     }
 329 }
 330
 331
 332 static void
 333 gdbsim_store_register (regno)
 334      int regno;
 335 {
 336   if (regno == -1)
 337     {
 338       for (regno = 0; regno < NUM_REGS; regno++)
 339         gdbsim_store_register (regno);
 340     }
 341   else if (REGISTER_NAME (regno) != NULL
 342            && *REGISTER_NAME (regno) != '\0'
 343            && REGISTER_SIM_REGNO (regno) >= 0)
 344     {
 345       char tmp[MAX_REGISTER_RAW_SIZE];
 346       int nr_bytes;
 347       read_register_gen (regno, tmp);
 348       nr_bytes = sim_store_register (gdbsim_desc,
 349                                      REGISTER_SIM_REGNO (regno),
 350                                      tmp, REGISTER_RAW_SIZE (regno));
 351       if (nr_bytes > 0 && nr_bytes != REGISTER_RAW_SIZE (regno))
 352         internal_error ("Register size different to expected");
 353       if (sr_get_debug ())
 354         {
 355           printf_filtered ("gdbsim_store_register: %d", regno);
 356           /* FIXME: We could print something more intelligible.  */
 357           dump_mem (tmp, REGISTER_RAW_SIZE (regno));
 358         }
 359     }
 360 }
 361
 362 /* Kill the running program.  This may involve closing any open files
 363    and releasing other resources acquired by the simulated program.  */
 364
 365 static void
 366 gdbsim_kill ()
 367 {
 368   if (sr_get_debug ())
 369     printf_filtered ("gdbsim_kill\n");
 370
 371   /* There is no need to `kill' running simulator - the simulator is
 372      not running */
 373   inferior_pid = 0;
 374 }
 375
 376 /* Load an executable file into the target process.  This is expected to
 377    not only bring new code into the target process, but also to update
 378    GDB's symbol tables to match.  */
 379
 380 static void
 381 gdbsim_load (prog, fromtty)
 382      char *prog;
 383      int fromtty;
 384 {
 385   if (sr_get_debug ())
 386     printf_filtered ("gdbsim_load: prog \"%s\"\n", prog);
 387
 388   inferior_pid = 0;
 389
 390   /* FIXME: We will print two messages on error.
 391      Need error to either not print anything if passed NULL or need
 392      another routine that doesn't take any arguments.  */
 393   if (sim_load (gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL)
 394     error ("unable to load program");
 395
 396   /* FIXME: If a load command should reset the targets registers then
 397      a call to sim_create_inferior() should go here. */
 398
 399   program_loaded = 1;
 400 }
 401
 402
 403 /* Start an inferior process and set inferior_pid to its pid.
 404    EXEC_FILE is the file to run.
 405    ARGS is a string containing the arguments to the program.
 406    ENV is the environment vector to pass.  Errors reported with error().
 407    On VxWorks and various standalone systems, we ignore exec_file.  */
 408 /* This is called not only when we first attach, but also when the
 409    user types "run" after having attached.  */
 410
 411 static void
 412 gdbsim_create_inferior (exec_file, args, env)
 413      char *exec_file;
 414      char *args;
 415      char **env;
 416 {
 417   int len;
 418   char *arg_buf, **argv;
 419
 420   if (exec_file == 0 || exec_bfd == 0)
 421     warning ("No executable file specified.");
 422   if (!program_loaded)
 423     warning ("No program loaded.");
 424
 425   if (sr_get_debug ())
 426     printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
 427                      (exec_file ? exec_file : "(NULL)"),
 428                      args);
 429
 430   gdbsim_kill ();
 431   remove_breakpoints ();
 432   init_wait_for_inferior ();
 433
 434   if (exec_file != NULL)
 435     {
 436       len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop */ 10;
 437       arg_buf = (char *) alloca (len);
 438       arg_buf[0] = '\0';
 439       strcat (arg_buf, exec_file);
 440       strcat (arg_buf, " ");
 441       strcat (arg_buf, args);
 442       argv = buildargv (arg_buf);
 443       make_cleanup_freeargv (argv);
 444     }
 445   else
 446     argv = NULL;
 447   sim_create_inferior (gdbsim_desc, exec_bfd, argv, env);
 448
 449   inferior_pid = 42;
 450   insert_breakpoints ();        /* Needed to get correct instruction in cache */
 451
 452   clear_proceed_status ();
 453
 454   /* NB: Entry point already set by sim_create_inferior. */
 455   proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
 456 }
 457
 458 /* The open routine takes the rest of the parameters from the command,
 459    and (if successful) pushes a new target onto the stack.
 460    Targets should supply this routine, if only to provide an error message.  */
 461 /* Called when selecting the simulator. EG: (gdb) target sim name.  */
 462
 463 static void
 464 gdbsim_open (args, from_tty)
 465      char *args;
 466      int from_tty;
 467 {
 468   int len;
 469   char *arg_buf;
 470   char **argv;
 471
 472   if (sr_get_debug ())
 473     printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
 474
 475   /* Remove current simulator if one exists.  Only do this if the simulator
 476      has been opened because sim_close requires it.
 477      This is important because the call to push_target below will cause
 478      sim_close to be called if the simulator is already open, but push_target
 479      is called after sim_open!  We can't move the call to push_target before
 480      the call to sim_open because sim_open may invoke `error'.  */
 481   if (gdbsim_desc != NULL)
 482     unpush_target (&gdbsim_ops);
 483
 484   len = (7 + 1                  /* gdbsim */
 485          + strlen (" -E little")
 486          + strlen (" --architecture=xxxxxxxxxx")
 487          + (args ? strlen (args) : 0)
 488          + 50) /* slack */ ;
 489   arg_buf = (char *) alloca (len);
 490   strcpy (arg_buf, "gdbsim");   /* 7 */
 491   /* Specify the byte order for the target when it is both selectable
 492      and explicitly specified by the user (not auto detected). */
 493   if (TARGET_BYTE_ORDER_SELECTABLE_P
 494       && !TARGET_BYTE_ORDER_AUTO)
 495     {
 496       switch (TARGET_BYTE_ORDER)
 497         {
 498         case BIG_ENDIAN:
 499           strcat (arg_buf, " -E big");
 500           break;
 501         case LITTLE_ENDIAN:
 502           strcat (arg_buf, " -E little");
 503           break;
 504         default:
 505           internal_error ("Value of TARGET_BYTE_ORDER unknown");
 506         }
 507     }
 508   /* Specify the architecture of the target when it has been
 509      explicitly specified */
 510   if (!TARGET_ARCHITECTURE_AUTO)
 511     {
 512       strcat (arg_buf, " --architecture=");
 513       strcat (arg_buf, TARGET_ARCHITECTURE->printable_name);
 514     }
 515   /* finally, any explicit args */
 516   if (args)
 517     {
 518       strcat (arg_buf, " ");    /* 1 */
 519       strcat (arg_buf, args);
 520     }
 521   argv = buildargv (arg_buf);
 522   if (argv == NULL)
 523     error ("Insufficient memory available to allocate simulator arg list.");
 524   make_cleanup_freeargv (argv);
 525
 526   init_callbacks ();
 527   gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, argv);
 528
 529   if (gdbsim_desc == 0)
 530     error ("unable to create simulator instance");
 531
 532   push_target (&gdbsim_ops);
 533   target_fetch_registers (-1);
 534   printf_filtered ("Connected to the simulator.\n");
 535 }
 536
 537 /* Does whatever cleanup is required for a target that we are no longer
 538    going to be calling.  Argument says whether we are quitting gdb and
 539    should not get hung in case of errors, or whether we want a clean
 540    termination even if it takes a while.  This routine is automatically
 541    always called just before a routine is popped off the target stack.
 542    Closing file descriptors and freeing memory are typical things it should
 543    do.  */
 544 /* Close out all files and local state before this target loses control. */
 545
 546 static void
 547 gdbsim_close (quitting)
 548      int quitting;
 549 {
 550   if (sr_get_debug ())
 551     printf_filtered ("gdbsim_close: quitting %d\n", quitting);
 552
 553   program_loaded = 0;
 554
 555   if (gdbsim_desc != NULL)
 556     {
 557       sim_close (gdbsim_desc, quitting);
 558       gdbsim_desc = NULL;
 559     }
 560
 561   end_callbacks ();
 562   generic_mourn_inferior ();
 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 }