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