gdb/remote-sim.c

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