gdb/remote-sim.c

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