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