gdb/remote-sim.c

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