gdb/remote-sim.c

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