gdb/remote-sim.c

   1 /* Generic remote debugging interface for simulators.
   2
   3    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
   4    2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   5
   6    Contributed by Cygnus Support.
   7    Steve Chamberlain (sac@cygnus.com).
   8
   9    This file is part of GDB.
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  23
  24 #include "defs.h"
  25 #include "inferior.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 "gdb/callback.h"
  37 #include "gdb/remote-sim.h"
  38 #include "command.h"
  39 #include "regcache.h"
  40 #include "gdb_assert.h"
  41 #include "sim-regno.h"
  42 #include "arch-utils.h"
  43 #include "readline/readline.h"
  44 #include "gdbthread.h"
  45
  46 /* Prototypes */
  47
  48 extern void _initialize_remote_sim (void);
  49
  50 static void dump_mem (char *buf, int len);
  51
  52 static void init_callbacks (void);
  53
  54 static void end_callbacks (void);
  55
  56 static int gdb_os_write_stdout (host_callback *, const char *, int);
  57
  58 static void gdb_os_flush_stdout (host_callback *);
  59
  60 static int gdb_os_write_stderr (host_callback *, const char *, int);
  61
  62 static void gdb_os_flush_stderr (host_callback *);
  63
  64 static int gdb_os_poll_quit (host_callback *);
  65
  66 /* printf_filtered is depreciated */
  67 static void gdb_os_printf_filtered (host_callback *, const char *, ...);
  68
  69 static void gdb_os_vprintf_filtered (host_callback *, const char *, va_list);
  70
  71 static void gdb_os_evprintf_filtered (host_callback *, const char *, va_list);
  72
  73 static void gdb_os_error (host_callback *, const char *, ...)
  74      ATTRIBUTE_NORETURN;
  75
  76 static void gdbsim_kill (struct target_ops *);
  77
  78 static void gdbsim_load (char *prog, int fromtty);
  79
  80 static void gdbsim_open (char *args, int from_tty);
  81
  82 static void gdbsim_close (int quitting);
  83
  84 static void gdbsim_detach (struct target_ops *ops, char *args, int from_tty);
  85
  86 static void gdbsim_prepare_to_store (struct regcache *regcache);
  87
  88 static void gdbsim_files_info (struct target_ops *target);
  89
  90 static void gdbsim_mourn_inferior (struct target_ops *target);
  91
  92 static void gdbsim_stop (ptid_t ptid);
  93
  94 void simulator_command (char *args, int from_tty);
  95
  96 /* Naming convention:
  97
  98    sim_* are the interface to the simulator (see remote-sim.h).
  99    gdbsim_* are stuff which is internal to gdb.  */
 100
 101 /* Forward data declarations */
 102 extern struct target_ops gdbsim_ops;
 103
 104 static int program_loaded = 0;
 105
 106 /* We must keep track of whether the simulator has been opened or not because
 107    GDB can call a target's close routine twice, but sim_close doesn't allow
 108    this.  We also need to record the result of sim_open so we can pass it
 109    back to the other sim_foo routines.  */
 110 static SIM_DESC gdbsim_desc = 0;
 111
 112 /* This is the ptid we use while we're connected to the simulator.
 113    Its value is arbitrary, as the simulator target don't have a notion
 114    or processes or threads, but we need something non-null to place in
 115    inferior_ptid.  */
 116 static ptid_t remote_sim_ptid;
 117
 118 static void
 119 dump_mem (char *buf, int len)
 120 {
 121   if (len <= 8)
 122     {
 123       if (len == 8 || len == 4)
 124         {
 125           long l[2];
 126           memcpy (l, buf, len);
 127           printf_filtered ("\t0x%lx", l[0]);
 128           if (len == 8)
 129             printf_filtered (" 0x%lx", l[1]);
 130           printf_filtered ("\n");
 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 (void)
 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 (void)
 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 (host_callback *p, const char *buf, int len)
 185 {
 186   int i;
 187   char b[2];
 188
 189   ui_file_write (gdb_stdtarg, buf, len);
 190   return len;
 191 }
 192
 193 /* GDB version of os_flush_stdout callback.  */
 194
 195 static void
 196 gdb_os_flush_stdout (host_callback *p)
 197 {
 198   gdb_flush (gdb_stdtarg);
 199 }
 200
 201 /* GDB version of os_write_stderr callback.  */
 202
 203 static int
 204 gdb_os_write_stderr (host_callback *p, const char *buf, int len)
 205 {
 206   int i;
 207   char b[2];
 208
 209   for (i = 0; i < len; i++)
 210     {
 211       b[0] = buf[i];
 212       b[1] = 0;
 213       fputs_unfiltered (b, gdb_stdtargerr);
 214     }
 215   return len;
 216 }
 217
 218 /* GDB version of os_flush_stderr callback.  */
 219
 220 static void
 221 gdb_os_flush_stderr (host_callback *p)
 222 {
 223   gdb_flush (gdb_stdtargerr);
 224 }
 225
 226 /* GDB version of printf_filtered callback.  */
 227
 228 static void
 229 gdb_os_printf_filtered (host_callback * p, const char *format,...)
 230 {
 231   va_list args;
 232   va_start (args, format);
 233
 234   vfprintf_filtered (gdb_stdout, format, args);
 235
 236   va_end (args);
 237 }
 238
 239 /* GDB version of error vprintf_filtered.  */
 240
 241 static void
 242 gdb_os_vprintf_filtered (host_callback * p, const char *format, va_list ap)
 243 {
 244   vfprintf_filtered (gdb_stdout, format, ap);
 245 }
 246
 247 /* GDB version of error evprintf_filtered.  */
 248
 249 static void
 250 gdb_os_evprintf_filtered (host_callback * p, const char *format, va_list ap)
 251 {
 252   vfprintf_filtered (gdb_stderr, format, ap);
 253 }
 254
 255 /* GDB version of error callback.  */
 256
 257 static void
 258 gdb_os_error (host_callback * p, const char *format, ...)
 259 {
 260   va_list args;
 261   va_start (args, format);
 262   verror (format, args);
 263   va_end (args);
 264 }
 265
 266 int
 267 one2one_register_sim_regno (struct gdbarch *gdbarch, int regnum)
 268 {
 269   /* Only makes sense to supply raw registers.  */
 270   gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
 271   return regnum;
 272 }
 273
 274 static void
 275 gdbsim_fetch_register (struct target_ops *ops,
 276                        struct regcache *regcache, int regno)
 277 {
 278   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 279   if (regno == -1)
 280     {
 281       for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
 282         gdbsim_fetch_register (ops, regcache, regno);
 283       return;
 284     }
 285
 286   switch (gdbarch_register_sim_regno (gdbarch, regno))
 287     {
 288     case LEGACY_SIM_REGNO_IGNORE:
 289       break;
 290     case SIM_REGNO_DOES_NOT_EXIST:
 291       {
 292         /* For moment treat a `does not exist' register the same way
 293            as an ``unavailable'' register.  */
 294         char buf[MAX_REGISTER_SIZE];
 295         int nr_bytes;
 296         memset (buf, 0, MAX_REGISTER_SIZE);
 297         regcache_raw_supply (regcache, regno, buf);
 298         break;
 299       }
 300
 301     default:
 302       {
 303         static int warn_user = 1;
 304         char buf[MAX_REGISTER_SIZE];
 305         int nr_bytes;
 306         gdb_assert (regno >= 0 && regno < gdbarch_num_regs (gdbarch));
 307         memset (buf, 0, MAX_REGISTER_SIZE);
 308         nr_bytes = sim_fetch_register (gdbsim_desc,
 309                                        gdbarch_register_sim_regno
 310                                          (gdbarch, regno),
 311                                        buf,
 312                                        register_size (gdbarch, regno));
 313         if (nr_bytes > 0
 314             && nr_bytes != register_size (gdbarch, regno) && warn_user)
 315           {
 316             fprintf_unfiltered (gdb_stderr,
 317                                 "Size of register %s (%d/%d) incorrect (%d instead of %d))",
 318                                 gdbarch_register_name (gdbarch, regno),
 319                                 regno,
 320                                 gdbarch_register_sim_regno
 321                                   (gdbarch, regno),
 322                                 nr_bytes, register_size (gdbarch, regno));
 323             warn_user = 0;
 324           }
 325         /* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0'
 326            indicating that GDB and the SIM have different ideas about
 327            which registers are fetchable.  */
 328         /* Else if (nr_bytes < 0): an old simulator, that doesn't
 329            think to return the register size.  Just assume all is ok.  */
 330         regcache_raw_supply (regcache, regno, buf);
 331         if (remote_debug)
 332           {
 333             printf_filtered ("gdbsim_fetch_register: %d", regno);
 334             /* FIXME: We could print something more intelligible.  */
 335             dump_mem (buf, register_size (gdbarch, regno));
 336           }
 337         break;
 338       }
 339     }
 340 }
 341
 342
 343 static void
 344 gdbsim_store_register (struct target_ops *ops,
 345                        struct regcache *regcache, int regno)
 346 {
 347   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 348   if (regno == -1)
 349     {
 350       for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
 351         gdbsim_store_register (ops, regcache, regno);
 352       return;
 353     }
 354   else if (gdbarch_register_sim_regno (gdbarch, regno) >= 0)
 355     {
 356       char tmp[MAX_REGISTER_SIZE];
 357       int nr_bytes;
 358       regcache_cooked_read (regcache, regno, tmp);
 359       nr_bytes = sim_store_register (gdbsim_desc,
 360                                      gdbarch_register_sim_regno
 361                                        (gdbarch, regno),
 362                                      tmp, register_size (gdbarch, regno));
 363       if (nr_bytes > 0 && nr_bytes != register_size (gdbarch, regno))
 364         internal_error (__FILE__, __LINE__,
 365                         _("Register size different to expected"));
 366       /* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0'
 367          indicating that GDB and the SIM have different ideas about
 368          which registers are fetchable.  */
 369       if (remote_debug)
 370         {
 371           printf_filtered ("gdbsim_store_register: %d", regno);
 372           /* FIXME: We could print something more intelligible.  */
 373           dump_mem (tmp, register_size (gdbarch, regno));
 374         }
 375     }
 376 }
 377
 378 /* Kill the running program.  This may involve closing any open files
 379    and releasing other resources acquired by the simulated program.  */
 380
 381 static void
 382 gdbsim_kill (struct target_ops *ops)
 383 {
 384   if (remote_debug)
 385     printf_filtered ("gdbsim_kill\n");
 386
 387   /* There is no need to `kill' running simulator - the simulator is
 388      not running.  Mourning it is enough.  */
 389   target_mourn_inferior ();
 390 }
 391
 392 /* Load an executable file into the target process.  This is expected to
 393    not only bring new code into the target process, but also to update
 394    GDB's symbol tables to match.  */
 395
 396 static void
 397 gdbsim_load (char *args, int fromtty)
 398 {
 399   char **argv;
 400   char *prog;
 401
 402   if (args == NULL)
 403       error_no_arg (_("program to load"));
 404
 405   argv = gdb_buildargv (args);
 406   make_cleanup_freeargv (argv);
 407
 408   prog = tilde_expand (argv[0]);
 409
 410   if (argv[1] != NULL)
 411     error (_("GDB sim does not yet support a load offset."));
 412
 413   if (remote_debug)
 414     printf_filtered ("gdbsim_load: prog \"%s\"\n", prog);
 415
 416   /* FIXME: We will print two messages on error.
 417      Need error to either not print anything if passed NULL or need
 418      another routine that doesn't take any arguments.  */
 419   if (sim_load (gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL)
 420     error (_("unable to load program"));
 421
 422   /* FIXME: If a load command should reset the targets registers then
 423      a call to sim_create_inferior() should go here. */
 424
 425   program_loaded = 1;
 426 }
 427
 428
 429 /* Start an inferior process and set inferior_ptid to its pid.
 430    EXEC_FILE is the file to run.
 431    ARGS is a string containing the arguments to the program.
 432    ENV is the environment vector to pass.  Errors reported with error().
 433    On VxWorks and various standalone systems, we ignore exec_file.  */
 434 /* This is called not only when we first attach, but also when the
 435    user types "run" after having attached.  */
 436
 437 static void
 438 gdbsim_create_inferior (struct target_ops *target, char *exec_file, char *args,
 439                         char **env, int from_tty)
 440 {
 441   int len;
 442   char *arg_buf, **argv;
 443
 444   if (exec_file == 0 || exec_bfd == 0)
 445     warning (_("No executable file specified."));
 446   if (!program_loaded)
 447     warning (_("No program loaded."));
 448
 449   if (remote_debug)
 450     printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
 451                      (exec_file ? exec_file : "(NULL)"),
 452                      args);
 453
 454   if (ptid_equal (inferior_ptid, remote_sim_ptid))
 455     gdbsim_kill (target);
 456   remove_breakpoints ();
 457   init_wait_for_inferior ();
 458
 459   if (exec_file != NULL)
 460     {
 461       len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop */ 10;
 462       arg_buf = (char *) alloca (len);
 463       arg_buf[0] = '\0';
 464       strcat (arg_buf, exec_file);
 465       strcat (arg_buf, " ");
 466       strcat (arg_buf, args);
 467       argv = gdb_buildargv (arg_buf);
 468       make_cleanup_freeargv (argv);
 469     }
 470   else
 471     argv = NULL;
 472   sim_create_inferior (gdbsim_desc, exec_bfd, argv, env);
 473
 474   inferior_ptid = remote_sim_ptid;
 475   inferior_appeared (current_inferior (), ptid_get_pid (inferior_ptid));
 476   add_thread_silent (inferior_ptid);
 477
 478   insert_breakpoints ();        /* Needed to get correct instruction in cache */
 479
 480   clear_proceed_status ();
 481 }
 482
 483 /* The open routine takes the rest of the parameters from the command,
 484    and (if successful) pushes a new target onto the stack.
 485    Targets should supply this routine, if only to provide an error message.  */
 486 /* Called when selecting the simulator. EG: (gdb) target sim name.  */
 487
 488 static void
 489 gdbsim_open (char *args, int from_tty)
 490 {
 491   int len;
 492   char *arg_buf;
 493   char **argv;
 494
 495   if (remote_debug)
 496     printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
 497
 498   /* Remove current simulator if one exists.  Only do this if the simulator
 499      has been opened because sim_close requires it.
 500      This is important because the call to push_target below will cause
 501      sim_close to be called if the simulator is already open, but push_target
 502      is called after sim_open!  We can't move the call to push_target before
 503      the call to sim_open because sim_open may invoke `error'.  */
 504   if (gdbsim_desc != NULL)
 505     unpush_target (&gdbsim_ops);
 506
 507   len = (7 + 1                  /* gdbsim */
 508          + strlen (" -E little")
 509          + strlen (" --architecture=xxxxxxxxxx")
 510          + (args ? strlen (args) : 0)
 511          + 50) /* slack */ ;
 512   arg_buf = (char *) alloca (len);
 513   strcpy (arg_buf, "gdbsim");   /* 7 */
 514   /* Specify the byte order for the target when it is explicitly
 515      specified by the user (not auto detected). */
 516   switch (selected_byte_order ())
 517     {
 518     case BFD_ENDIAN_BIG:
 519       strcat (arg_buf, " -E big");
 520       break;
 521     case BFD_ENDIAN_LITTLE:
 522       strcat (arg_buf, " -E little");
 523       break;
 524     case BFD_ENDIAN_UNKNOWN:
 525       break;
 526     }
 527   /* Specify the architecture of the target when it has been
 528      explicitly specified */
 529   if (selected_architecture_name () != NULL)
 530     {
 531       strcat (arg_buf, " --architecture=");
 532       strcat (arg_buf, selected_architecture_name ());
 533     }
 534   /* finally, any explicit args */
 535   if (args)
 536     {
 537       strcat (arg_buf, " ");    /* 1 */
 538       strcat (arg_buf, args);
 539     }
 540   argv = gdb_buildargv (arg_buf);
 541   make_cleanup_freeargv (argv);
 542
 543   init_callbacks ();
 544   gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, argv);
 545
 546   if (gdbsim_desc == 0)
 547     error (_("unable to create simulator instance"));
 548
 549   push_target (&gdbsim_ops);
 550   printf_filtered ("Connected to the simulator.\n");
 551
 552   /* There's nothing running after "target sim" or "load"; not until
 553      "run".  */
 554   inferior_ptid = null_ptid;
 555 }
 556
 557 /* Does whatever cleanup is required for a target that we are no longer
 558    going to be calling.  Argument says whether we are quitting gdb and
 559    should not get hung in case of errors, or whether we want a clean
 560    termination even if it takes a while.  This routine is automatically
 561    always called just before a routine is popped off the target stack.
 562    Closing file descriptors and freeing memory are typical things it should
 563    do.  */
 564 /* Close out all files and local state before this target loses control. */
 565
 566 static void
 567 gdbsim_close (int quitting)
 568 {
 569   if (remote_debug)
 570     printf_filtered ("gdbsim_close: quitting %d\n", quitting);
 571
 572   program_loaded = 0;
 573
 574   if (gdbsim_desc != NULL)
 575     {
 576       sim_close (gdbsim_desc, quitting);
 577       gdbsim_desc = NULL;
 578     }
 579
 580   end_callbacks ();
 581   generic_mourn_inferior ();
 582   delete_thread_silent (remote_sim_ptid);
 583   delete_inferior_silent (ptid_get_pid (remote_sim_ptid));
 584 }
 585
 586 /* Takes a program previously attached to and detaches it.
 587    The program may resume execution (some targets do, some don't) and will
 588    no longer stop on signals, etc.  We better not have left any breakpoints
 589    in the program or it'll die when it hits one.  ARGS is arguments
 590    typed by the user (e.g. a signal to send the process).  FROM_TTY
 591    says whether to be verbose or not.  */
 592 /* Terminate the open connection to the remote debugger.
 593    Use this when you want to detach and do something else with your gdb.  */
 594
 595 static void
 596 gdbsim_detach (struct target_ops *ops, char *args, int from_tty)
 597 {
 598   if (remote_debug)
 599     printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
 600
 601   pop_target ();                /* calls gdbsim_close to do the real work */
 602   if (from_tty)
 603     printf_filtered ("Ending simulator %s debugging\n", target_shortname);
 604 }
 605
 606 /* Resume execution of the target process.  STEP says whether to single-step
 607    or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
 608    to the target, or zero for no signal.  */
 609
 610 static enum target_signal resume_siggnal;
 611 static int resume_step;
 612
 613 static void
 614 gdbsim_resume (struct target_ops *ops,
 615                ptid_t ptid, int step, enum target_signal siggnal)
 616 {
 617   if (!ptid_equal (inferior_ptid, remote_sim_ptid))
 618     error (_("The program is not being run."));
 619
 620   if (remote_debug)
 621     printf_filtered ("gdbsim_resume: step %d, signal %d\n", step, siggnal);
 622
 623   resume_siggnal = siggnal;
 624   resume_step = step;
 625 }
 626
 627 /* Notify the simulator of an asynchronous request to stop.
 628
 629    The simulator shall ensure that the stop request is eventually
 630    delivered to the simulator.  If the call is made while the
 631    simulator is not running then the stop request is processed when
 632    the simulator is next resumed.
 633
 634    For simulators that do not support this operation, just abort */
 635
 636 static void
 637 gdbsim_stop (ptid_t ptid)
 638 {
 639   if (!sim_stop (gdbsim_desc))
 640     {
 641       quit ();
 642     }
 643 }
 644
 645 /* GDB version of os_poll_quit callback.
 646    Taken from gdb/util.c - should be in a library.  */
 647
 648 static int
 649 gdb_os_poll_quit (host_callback *p)
 650 {
 651   if (deprecated_ui_loop_hook != NULL)
 652     deprecated_ui_loop_hook (0);
 653
 654   if (quit_flag)                /* gdb's idea of quit */
 655     {
 656       quit_flag = 0;            /* we've stolen it */
 657       return 1;
 658     }
 659   else if (immediate_quit)
 660     {
 661       return 1;
 662     }
 663   return 0;
 664 }
 665
 666 /* Wait for inferior process to do something.  Return pid of child,
 667    or -1 in case of error; store status through argument pointer STATUS,
 668    just as `wait' would. */
 669
 670 static void
 671 gdbsim_cntrl_c (int signo)
 672 {
 673   gdbsim_stop (remote_sim_ptid);
 674 }
 675
 676 static ptid_t
 677 gdbsim_wait (struct target_ops *ops,
 678              ptid_t ptid, struct target_waitstatus *status, int options)
 679 {
 680   static RETSIGTYPE (*prev_sigint) ();
 681   int sigrc = 0;
 682   enum sim_stop reason = sim_running;
 683
 684   if (remote_debug)
 685     printf_filtered ("gdbsim_wait\n");
 686
 687 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
 688   {
 689     struct sigaction sa, osa;
 690     sa.sa_handler = gdbsim_cntrl_c;
 691     sigemptyset (&sa.sa_mask);
 692     sa.sa_flags = 0;
 693     sigaction (SIGINT, &sa, &osa);
 694     prev_sigint = osa.sa_handler;
 695   }
 696 #else
 697   prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
 698 #endif
 699   sim_resume (gdbsim_desc, resume_step, resume_siggnal);
 700   signal (SIGINT, prev_sigint);
 701   resume_step = 0;
 702
 703   sim_stop_reason (gdbsim_desc, &reason, &sigrc);
 704
 705   switch (reason)
 706     {
 707     case sim_exited:
 708       status->kind = TARGET_WAITKIND_EXITED;
 709       status->value.integer = sigrc;
 710       break;
 711     case sim_stopped:
 712       switch (sigrc)
 713         {
 714         case TARGET_SIGNAL_ABRT:
 715           quit ();
 716           break;
 717         case TARGET_SIGNAL_INT:
 718         case TARGET_SIGNAL_TRAP:
 719         default:
 720           status->kind = TARGET_WAITKIND_STOPPED;
 721           status->value.sig = sigrc;
 722           break;
 723         }
 724       break;
 725     case sim_signalled:
 726       status->kind = TARGET_WAITKIND_SIGNALLED;
 727       status->value.sig = sigrc;
 728       break;
 729     case sim_running:
 730     case sim_polling:
 731       /* FIXME: Is this correct? */
 732       break;
 733     }
 734
 735   return inferior_ptid;
 736 }
 737
 738 /* Get ready to modify the registers array.  On machines which store
 739    individual registers, this doesn't need to do anything.  On machines
 740    which store all the registers in one fell swoop, this makes sure
 741    that registers contains all the registers from the program being
 742    debugged.  */
 743
 744 static void
 745 gdbsim_prepare_to_store (struct regcache *regcache)
 746 {
 747   /* Do nothing, since we can store individual regs */
 748 }
 749
 750 /* Transfer LEN bytes between GDB address MYADDR and target address
 751    MEMADDR.  If WRITE is non-zero, transfer them to the target,
 752    otherwise transfer them from the target.  TARGET is unused.
 753
 754    Returns the number of bytes transferred. */
 755
 756 static int
 757 gdbsim_xfer_inferior_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
 758                              int write, struct mem_attrib *attrib,
 759                              struct target_ops *target)
 760 {
 761   /* If no program is running yet, then ignore the simulator for
 762      memory.  Pass the request down to the next target, hopefully
 763      an exec file.  */
 764   if (!target_has_execution)
 765     return 0;
 766
 767   if (!program_loaded)
 768     error (_("No program loaded."));
 769
 770   if (remote_debug)
 771     {
 772       /* FIXME: Send to something other than STDOUT? */
 773       printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x");
 774       gdb_print_host_address (myaddr, gdb_stdout);
 775       printf_filtered (", memaddr %s, len %d, write %d\n",
 776                        paddress (target_gdbarch, memaddr), len, write);
 777       if (remote_debug && write)
 778         dump_mem (myaddr, len);
 779     }
 780
 781   if (write)
 782     {
 783       len = sim_write (gdbsim_desc, memaddr, myaddr, len);
 784     }
 785   else
 786     {
 787       len = sim_read (gdbsim_desc, memaddr, myaddr, len);
 788       if (remote_debug && len > 0)
 789         dump_mem (myaddr, len);
 790     }
 791   return len;
 792 }
 793
 794 static void
 795 gdbsim_files_info (struct target_ops *target)
 796 {
 797   const char *file = "nothing";
 798
 799   if (exec_bfd)
 800     file = bfd_get_filename (exec_bfd);
 801
 802   if (remote_debug)
 803     printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
 804
 805   if (exec_bfd)
 806     {
 807       printf_filtered ("\tAttached to %s running program %s\n",
 808                        target_shortname, file);
 809       sim_info (gdbsim_desc, 0);
 810     }
 811 }
 812
 813 /* Clear the simulator's notion of what the break points are.  */
 814
 815 static void
 816 gdbsim_mourn_inferior (struct target_ops *target)
 817 {
 818   if (remote_debug)
 819     printf_filtered ("gdbsim_mourn_inferior:\n");
 820
 821   remove_breakpoints ();
 822   generic_mourn_inferior ();
 823   delete_thread_silent (remote_sim_ptid);
 824 }
 825
 826 /* Pass the command argument through to the simulator verbatim.  The
 827    simulator must do any command interpretation work.  */
 828
 829 void
 830 simulator_command (char *args, int from_tty)
 831 {
 832   if (gdbsim_desc == NULL)
 833     {
 834
 835       /* PREVIOUSLY: The user may give a command before the simulator
 836          is opened. [...] (??? assuming of course one wishes to
 837          continue to allow commands to be sent to unopened simulators,
 838          which isn't entirely unreasonable). */
 839
 840       /* The simulator is a builtin abstraction of a remote target.
 841          Consistent with that model, access to the simulator, via sim
 842          commands, is restricted to the period when the channel to the
 843          simulator is open. */
 844
 845       error (_("Not connected to the simulator target"));
 846     }
 847
 848   sim_do_command (gdbsim_desc, args);
 849
 850   /* Invalidate the register cache, in case the simulator command does
 851      something funny. */
 852   registers_changed ();
 853 }
 854
 855 /* Check to see if a thread is still alive.  */
 856
 857 static int
 858 gdbsim_thread_alive (struct target_ops *ops, ptid_t ptid)
 859 {
 860   if (ptid_equal (ptid, remote_sim_ptid))
 861     /* The simulators' task is always alive.  */
 862     return 1;
 863
 864   return 0;
 865 }
 866
 867 /* Convert a thread ID to a string.  Returns the string in a static
 868    buffer.  */
 869
 870 static char *
 871 gdbsim_pid_to_str (struct target_ops *ops, ptid_t ptid)
 872 {
 873   static char buf[64];
 874
 875   if (ptid_equal (remote_sim_ptid, ptid))
 876     {
 877       xsnprintf (buf, sizeof buf, "Thread <main>");
 878       return buf;
 879     }
 880
 881   return normal_pid_to_str (ptid);
 882 }
 883
 884 /* Define the target subroutine names */
 885
 886 struct target_ops gdbsim_ops;
 887
 888 static void
 889 init_gdbsim_ops (void)
 890 {
 891   gdbsim_ops.to_shortname = "sim";
 892   gdbsim_ops.to_longname = "simulator";
 893   gdbsim_ops.to_doc = "Use the compiled-in simulator.";
 894   gdbsim_ops.to_open = gdbsim_open;
 895   gdbsim_ops.to_close = gdbsim_close;
 896   gdbsim_ops.to_detach = gdbsim_detach;
 897   gdbsim_ops.to_resume = gdbsim_resume;
 898   gdbsim_ops.to_wait = gdbsim_wait;
 899   gdbsim_ops.to_fetch_registers = gdbsim_fetch_register;
 900   gdbsim_ops.to_store_registers = gdbsim_store_register;
 901   gdbsim_ops.to_prepare_to_store = gdbsim_prepare_to_store;
 902   gdbsim_ops.deprecated_xfer_memory = gdbsim_xfer_inferior_memory;
 903   gdbsim_ops.to_files_info = gdbsim_files_info;
 904   gdbsim_ops.to_insert_breakpoint = memory_insert_breakpoint;
 905   gdbsim_ops.to_remove_breakpoint = memory_remove_breakpoint;
 906   gdbsim_ops.to_kill = gdbsim_kill;
 907   gdbsim_ops.to_load = gdbsim_load;
 908   gdbsim_ops.to_create_inferior = gdbsim_create_inferior;
 909   gdbsim_ops.to_mourn_inferior = gdbsim_mourn_inferior;
 910   gdbsim_ops.to_stop = gdbsim_stop;
 911   gdbsim_ops.to_thread_alive = gdbsim_thread_alive;
 912   gdbsim_ops.to_pid_to_str = gdbsim_pid_to_str;
 913   gdbsim_ops.to_stratum = process_stratum;
 914   gdbsim_ops.to_has_all_memory = default_child_has_all_memory;
 915   gdbsim_ops.to_has_memory = default_child_has_memory;
 916   gdbsim_ops.to_has_stack = default_child_has_stack;
 917   gdbsim_ops.to_has_registers = default_child_has_registers;
 918   gdbsim_ops.to_has_execution = default_child_has_execution;
 919   gdbsim_ops.to_magic = OPS_MAGIC;
 920 }
 921
 922 void
 923 _initialize_remote_sim (void)
 924 {
 925   init_gdbsim_ops ();
 926   add_target (&gdbsim_ops);
 927
 928   add_com ("sim", class_obscure, simulator_command,
 929            _("Send a command to the simulator."));
 930
 931   /* Yes, 42000 is arbitrary.  The only sense out of it, is that it
 932      isn't 0.  */
 933   remote_sim_ptid = ptid_build (42000, 0, 42000);
 934 }