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