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