gdb/remote-sim.c

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