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