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