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