gdb/remote-sim.c

   1 /* Generic remote debugging interface for simulators.
   2
   3    Copyright (C) 1993-2002, 2004-2012 Free Software Foundation, Inc.
   4
   5    Contributed by Cygnus Support.
   6    Steve Chamberlain (sac@cygnus.com).
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 #include "defs.h"
  24 #include "inferior.h"
  25 #include "value.h"
  26 #include "gdb_string.h"
  27 #include <ctype.h>
  28 #include <fcntl.h>
  29 #include <signal.h>
  30 #include <setjmp.h>
  31 #include <errno.h>
  32 #include "terminal.h"
  33 #include "target.h"
  34 #include "gdbcore.h"
  35 #include "gdb/callback.h"
  36 #include "gdb/remote-sim.h"
  37 #include "command.h"
  38 #include "regcache.h"
  39 #include "gdb_assert.h"
  40 #include "sim-regno.h"
  41 #include "arch-utils.h"
  42 #include "readline/readline.h"
  43 #include "gdbthread.h"
  44
  45 /* Prototypes */
  46
  47 extern void _initialize_remote_sim (void);
  48
  49 static void dump_mem (char *buf, int len);
  50
  51 static void init_callbacks (void);
  52
  53 static void end_callbacks (void);
  54
  55 static int gdb_os_write_stdout (host_callback *, const char *, int);
  56
  57 static void gdb_os_flush_stdout (host_callback *);
  58
  59 static int gdb_os_write_stderr (host_callback *, const char *, int);
  60
  61 static void gdb_os_flush_stderr (host_callback *);
  62
  63 static int gdb_os_poll_quit (host_callback *);
  64
  65 /* printf_filtered is depreciated.  */
  66 static void gdb_os_printf_filtered (host_callback *, const char *, ...);
  67
  68 static void gdb_os_vprintf_filtered (host_callback *, const char *, va_list);
  69
  70 static void gdb_os_evprintf_filtered (host_callback *, const char *, va_list);
  71
  72 static void gdb_os_error (host_callback *, const char *, ...)
  73      ATTRIBUTE_NORETURN;
  74
  75 static void gdbsim_kill (struct target_ops *);
  76
  77 static void gdbsim_load (char *prog, int fromtty);
  78
  79 static void gdbsim_open (char *args, int from_tty);
  80
  81 static void gdbsim_close (int quitting);
  82
  83 static void gdbsim_detach (struct target_ops *ops, char *args, int from_tty);
  84
  85 static void gdbsim_prepare_to_store (struct regcache *regcache);
  86
  87 static void gdbsim_files_info (struct target_ops *target);
  88
  89 static void gdbsim_mourn_inferior (struct target_ops *target);
  90
  91 static void gdbsim_stop (ptid_t ptid);
  92
  93 void simulator_command (char *args, int from_tty);
  94
  95 /* Naming convention:
  96
  97    sim_* are the interface to the simulator (see remote-sim.h).
  98    gdbsim_* are stuff which is internal to gdb.  */
  99
 100 /* Forward data declarations */
 101 extern struct target_ops gdbsim_ops;
 102
 103 static const struct inferior_data *sim_inferior_data_key;
 104
 105 /* Simulator-specific, per-inferior state.  */
 106 struct sim_inferior_data {
 107   /* Flag which indicates whether or not the program has been loaded.  */
 108   int program_loaded;
 109
 110   /* Simulator descriptor for this inferior.  */
 111   SIM_DESC gdbsim_desc;
 112
 113   /* This is the ptid we use for this particular simulator instance.  Its
 114      value is somewhat arbitrary, as the simulator target don't have a
 115      notion of tasks or threads, but we need something non-null to place
 116      in inferior_ptid.  For simulators which permit multiple instances,
 117      we also need a unique identifier to use for each inferior.  */
 118   ptid_t remote_sim_ptid;
 119
 120   /* Signal with which to resume.  */
 121   enum target_signal resume_siggnal;
 122
 123   /* Flag which indicates whether resume should step or not.  */
 124   int resume_step;
 125 };
 126
 127 /* Flag indicating the "open" status of this module.  It's set to 1
 128    in gdbsim_open() and 0 in gdbsim_close().  */
 129 static int gdbsim_is_open = 0;
 130
 131 /* Value of the next pid to allocate for an inferior.  As indicated
 132    elsewhere, its initial value is somewhat arbitrary; it's critical
 133    though that it's not zero or negative.  */
 134 static int next_pid;
 135 #define INITIAL_PID 42000
 136
 137 /* Argument list to pass to sim_open().  It is allocated in gdbsim_open()
 138    and deallocated in gdbsim_close().  The lifetime needs to extend beyond
 139    the call to gdbsim_open() due to the fact that other sim instances other
 140    than the first will be allocated after the gdbsim_open() call.  */
 141 static char **sim_argv = NULL;
 142
 143 /* OS-level callback functions for write, flush, etc.  */
 144 static host_callback gdb_callback;
 145 static int callbacks_initialized = 0;
 146
 147 /* Callback for iterate_over_inferiors.  It checks to see if the sim
 148    descriptor passed via ARG is the same as that for the inferior
 149    designated by INF.  Return true if so; false otherwise.  */
 150
 151 static int
 152 check_for_duplicate_sim_descriptor (struct inferior *inf, void *arg)
 153 {
 154   struct sim_inferior_data *sim_data;
 155   SIM_DESC new_sim_desc = arg;
 156
 157   sim_data = inferior_data (inf, sim_inferior_data_key);
 158
 159   return (sim_data != NULL && sim_data->gdbsim_desc == new_sim_desc);
 160 }
 161
 162 /* Flags indicating whether or not a sim instance is needed.  One of these
 163    flags should be passed to get_sim_inferior_data().  */
 164
 165 enum {SIM_INSTANCE_NOT_NEEDED = 0, SIM_INSTANCE_NEEDED = 1};
 166
 167 /* Obtain pointer to per-inferior simulator data, allocating it if necessary.
 168    Attempt to open the sim if SIM_INSTANCE_NEEDED is true.  */
 169
 170 static struct sim_inferior_data *
 171 get_sim_inferior_data (struct inferior *inf, int sim_instance_needed)
 172 {
 173   SIM_DESC sim_desc = NULL;
 174   struct sim_inferior_data *sim_data
 175     = inferior_data (inf, sim_inferior_data_key);
 176
 177   /* Try to allocate a new sim instance, if needed.  We do this ahead of
 178      a potential allocation of a sim_inferior_data struct in order to
 179      avoid needlessly allocating that struct in the event that the sim
 180      instance allocation fails.  */
 181   if (sim_instance_needed == SIM_INSTANCE_NEEDED
 182       && (sim_data == NULL || sim_data->gdbsim_desc == NULL))
 183     {
 184       struct inferior *idup;
 185       sim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, sim_argv);
 186       if (sim_desc == NULL)
 187         error (_("Unable to create simulator instance for inferior %d."),
 188                inf->num);
 189
 190       idup = iterate_over_inferiors (check_for_duplicate_sim_descriptor,
 191                                      sim_desc);
 192       if (idup != NULL)
 193         {
 194           /* We don't close the descriptor due to the fact that it's
 195              shared with some other inferior.  If we were to close it,
 196              that might needlessly muck up the other inferior.  Of
 197              course, it's possible that the damage has already been
 198              done...  Note that it *will* ultimately be closed during
 199              cleanup of the other inferior.  */
 200           sim_desc = NULL;
 201           error (
 202  _("Inferior %d and inferior %d would have identical simulator state.\n"
 203    "(This simulator does not support the running of more than one inferior.)"),
 204                  inf->num, idup->num);
 205         }
 206     }
 207
 208   if (sim_data == NULL)
 209     {
 210       sim_data = XZALLOC(struct sim_inferior_data);
 211       set_inferior_data (inf, sim_inferior_data_key, sim_data);
 212
 213       /* Allocate a ptid for this inferior.  */
 214       sim_data->remote_sim_ptid = ptid_build (next_pid, 0, next_pid);
 215       next_pid++;
 216
 217       /* Initialize the other instance variables.  */
 218       sim_data->program_loaded = 0;
 219       sim_data->gdbsim_desc = sim_desc;
 220       sim_data->resume_siggnal = TARGET_SIGNAL_0;
 221       sim_data->resume_step = 0;
 222     }
 223   else if (sim_desc)
 224     {
 225       /* This handles the case where sim_data was allocated prior to
 226          needing a sim instance.  */
 227       sim_data->gdbsim_desc = sim_desc;
 228     }
 229
 230
 231   return sim_data;
 232 }
 233
 234 /* Return pointer to per-inferior simulator data using PTID to find the
 235    inferior in question.  Return NULL when no inferior is found or
 236    when ptid has a zero or negative pid component.  */
 237
 238 static struct sim_inferior_data *
 239 get_sim_inferior_data_by_ptid (ptid_t ptid, int sim_instance_needed)
 240 {
 241   struct inferior *inf;
 242   int pid = ptid_get_pid (ptid);
 243
 244   if (pid <= 0)
 245     return NULL;
 246
 247   inf = find_inferior_pid (pid);
 248
 249   if (inf)
 250     return get_sim_inferior_data (inf, sim_instance_needed);
 251   else
 252     return NULL;
 253 }
 254
 255 /* Free the per-inferior simulator data.  */
 256
 257 static void
 258 sim_inferior_data_cleanup (struct inferior *inf, void *data)
 259 {
 260   struct sim_inferior_data *sim_data = data;
 261
 262   if (sim_data != NULL)
 263     {
 264       if (sim_data->gdbsim_desc)
 265         {
 266           sim_close (sim_data->gdbsim_desc, 0);
 267           sim_data->gdbsim_desc = NULL;
 268         }
 269       xfree (sim_data);
 270     }
 271 }
 272
 273 static void
 274 dump_mem (char *buf, int len)
 275 {
 276   if (len <= 8)
 277     {
 278       if (len == 8 || len == 4)
 279         {
 280           long l[2];
 281
 282           memcpy (l, buf, len);
 283           printf_filtered ("\t0x%lx", l[0]);
 284           if (len == 8)
 285             printf_filtered (" 0x%lx", l[1]);
 286           printf_filtered ("\n");
 287         }
 288       else
 289         {
 290           int i;
 291
 292           printf_filtered ("\t");
 293           for (i = 0; i < len; i++)
 294             printf_filtered ("0x%x ", buf[i]);
 295           printf_filtered ("\n");
 296         }
 297     }
 298 }
 299
 300 /* Initialize gdb_callback.  */
 301
 302 static void
 303 init_callbacks (void)
 304 {
 305   if (!callbacks_initialized)
 306     {
 307       gdb_callback = default_callback;
 308       gdb_callback.init (&gdb_callback);
 309       gdb_callback.write_stdout = gdb_os_write_stdout;
 310       gdb_callback.flush_stdout = gdb_os_flush_stdout;
 311       gdb_callback.write_stderr = gdb_os_write_stderr;
 312       gdb_callback.flush_stderr = gdb_os_flush_stderr;
 313       gdb_callback.printf_filtered = gdb_os_printf_filtered;
 314       gdb_callback.vprintf_filtered = gdb_os_vprintf_filtered;
 315       gdb_callback.evprintf_filtered = gdb_os_evprintf_filtered;
 316       gdb_callback.error = gdb_os_error;
 317       gdb_callback.poll_quit = gdb_os_poll_quit;
 318       gdb_callback.magic = HOST_CALLBACK_MAGIC;
 319       callbacks_initialized = 1;
 320     }
 321 }
 322
 323 /* Release callbacks (free resources used by them).  */
 324
 325 static void
 326 end_callbacks (void)
 327 {
 328   if (callbacks_initialized)
 329     {
 330       gdb_callback.shutdown (&gdb_callback);
 331       callbacks_initialized = 0;
 332     }
 333 }
 334
 335 /* GDB version of os_write_stdout callback.  */
 336
 337 static int
 338 gdb_os_write_stdout (host_callback *p, const char *buf, int len)
 339 {
 340   int i;
 341   char b[2];
 342
 343   ui_file_write (gdb_stdtarg, buf, len);
 344   return len;
 345 }
 346
 347 /* GDB version of os_flush_stdout callback.  */
 348
 349 static void
 350 gdb_os_flush_stdout (host_callback *p)
 351 {
 352   gdb_flush (gdb_stdtarg);
 353 }
 354
 355 /* GDB version of os_write_stderr callback.  */
 356
 357 static int
 358 gdb_os_write_stderr (host_callback *p, const char *buf, int len)
 359 {
 360   int i;
 361   char b[2];
 362
 363   for (i = 0; i < len; i++)
 364     {
 365       b[0] = buf[i];
 366       b[1] = 0;
 367       fputs_unfiltered (b, gdb_stdtargerr);
 368     }
 369   return len;
 370 }
 371
 372 /* GDB version of os_flush_stderr callback.  */
 373
 374 static void
 375 gdb_os_flush_stderr (host_callback *p)
 376 {
 377   gdb_flush (gdb_stdtargerr);
 378 }
 379
 380 /* GDB version of printf_filtered callback.  */
 381
 382 static void
 383 gdb_os_printf_filtered (host_callback * p, const char *format,...)
 384 {
 385   va_list args;
 386
 387   va_start (args, format);
 388   vfprintf_filtered (gdb_stdout, format, args);
 389   va_end (args);
 390 }
 391
 392 /* GDB version of error vprintf_filtered.  */
 393
 394 static void
 395 gdb_os_vprintf_filtered (host_callback * p, const char *format, va_list ap)
 396 {
 397   vfprintf_filtered (gdb_stdout, format, ap);
 398 }
 399
 400 /* GDB version of error evprintf_filtered.  */
 401
 402 static void
 403 gdb_os_evprintf_filtered (host_callback * p, const char *format, va_list ap)
 404 {
 405   vfprintf_filtered (gdb_stderr, format, ap);
 406 }
 407
 408 /* GDB version of error callback.  */
 409
 410 static void
 411 gdb_os_error (host_callback * p, const char *format, ...)
 412 {
 413   va_list args;
 414
 415   va_start (args, format);
 416   verror (format, args);
 417   va_end (args);
 418 }
 419
 420 int
 421 one2one_register_sim_regno (struct gdbarch *gdbarch, int regnum)
 422 {
 423   /* Only makes sense to supply raw registers.  */
 424   gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
 425   return regnum;
 426 }
 427
 428 static void
 429 gdbsim_fetch_register (struct target_ops *ops,
 430                        struct regcache *regcache, int regno)
 431 {
 432   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 433   struct sim_inferior_data *sim_data
 434     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
 435
 436   if (regno == -1)
 437     {
 438       for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
 439         gdbsim_fetch_register (ops, regcache, regno);
 440       return;
 441     }
 442
 443   switch (gdbarch_register_sim_regno (gdbarch, regno))
 444     {
 445     case LEGACY_SIM_REGNO_IGNORE:
 446       break;
 447     case SIM_REGNO_DOES_NOT_EXIST:
 448       {
 449         /* For moment treat a `does not exist' register the same way
 450            as an ``unavailable'' register.  */
 451         char buf[MAX_REGISTER_SIZE];
 452         int nr_bytes;
 453
 454         memset (buf, 0, MAX_REGISTER_SIZE);
 455         regcache_raw_supply (regcache, regno, buf);
 456         break;
 457       }
 458
 459     default:
 460       {
 461         static int warn_user = 1;
 462         char buf[MAX_REGISTER_SIZE];
 463         int nr_bytes;
 464
 465         gdb_assert (regno >= 0 && regno < gdbarch_num_regs (gdbarch));
 466         memset (buf, 0, MAX_REGISTER_SIZE);
 467         nr_bytes = sim_fetch_register (sim_data->gdbsim_desc,
 468                                        gdbarch_register_sim_regno
 469                                          (gdbarch, regno),
 470                                        buf,
 471                                        register_size (gdbarch, regno));
 472         if (nr_bytes > 0
 473             && nr_bytes != register_size (gdbarch, regno) && warn_user)
 474           {
 475             fprintf_unfiltered (gdb_stderr,
 476                                 "Size of register %s (%d/%d) "
 477                                 "incorrect (%d instead of %d))",
 478                                 gdbarch_register_name (gdbarch, regno),
 479                                 regno,
 480                                 gdbarch_register_sim_regno
 481                                   (gdbarch, regno),
 482                                 nr_bytes, register_size (gdbarch, regno));
 483             warn_user = 0;
 484           }
 485         /* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0'
 486            indicating that GDB and the SIM have different ideas about
 487            which registers are fetchable.  */
 488         /* Else if (nr_bytes < 0): an old simulator, that doesn't
 489            think to return the register size.  Just assume all is ok.  */
 490         regcache_raw_supply (regcache, regno, buf);
 491         if (remote_debug)
 492           {
 493             printf_filtered ("gdbsim_fetch_register: %d", regno);
 494             /* FIXME: We could print something more intelligible.  */
 495             dump_mem (buf, register_size (gdbarch, regno));
 496           }
 497         break;
 498       }
 499     }
 500 }
 501
 502
 503 static void
 504 gdbsim_store_register (struct target_ops *ops,
 505                        struct regcache *regcache, int regno)
 506 {
 507   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 508   struct sim_inferior_data *sim_data
 509     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
 510
 511   if (regno == -1)
 512     {
 513       for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
 514         gdbsim_store_register (ops, regcache, regno);
 515       return;
 516     }
 517   else if (gdbarch_register_sim_regno (gdbarch, regno) >= 0)
 518     {
 519       char tmp[MAX_REGISTER_SIZE];
 520       int nr_bytes;
 521
 522       regcache_cooked_read (regcache, regno, tmp);
 523       nr_bytes = sim_store_register (sim_data->gdbsim_desc,
 524                                      gdbarch_register_sim_regno
 525                                        (gdbarch, regno),
 526                                      tmp, register_size (gdbarch, regno));
 527       if (nr_bytes > 0 && nr_bytes != register_size (gdbarch, regno))
 528         internal_error (__FILE__, __LINE__,
 529                         _("Register size different to expected"));
 530       if (nr_bytes < 0)
 531         internal_error (__FILE__, __LINE__,
 532                         _("Register %d not updated"), regno);
 533       if (nr_bytes == 0)
 534         warning (_("Register %s not updated"),
 535                  gdbarch_register_name (gdbarch, regno));
 536
 537       if (remote_debug)
 538         {
 539           printf_filtered ("gdbsim_store_register: %d", regno);
 540           /* FIXME: We could print something more intelligible.  */
 541           dump_mem (tmp, register_size (gdbarch, regno));
 542         }
 543     }
 544 }
 545
 546 /* Kill the running program.  This may involve closing any open files
 547    and releasing other resources acquired by the simulated program.  */
 548
 549 static void
 550 gdbsim_kill (struct target_ops *ops)
 551 {
 552   if (remote_debug)
 553     printf_filtered ("gdbsim_kill\n");
 554
 555   /* There is no need to `kill' running simulator - the simulator is
 556      not running.  Mourning it is enough.  */
 557   target_mourn_inferior ();
 558 }
 559
 560 /* Load an executable file into the target process.  This is expected to
 561    not only bring new code into the target process, but also to update
 562    GDB's symbol tables to match.  */
 563
 564 static void
 565 gdbsim_load (char *args, int fromtty)
 566 {
 567   char **argv;
 568   char *prog;
 569   struct sim_inferior_data *sim_data
 570     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
 571
 572   if (args == NULL)
 573       error_no_arg (_("program to load"));
 574
 575   argv = gdb_buildargv (args);
 576   make_cleanup_freeargv (argv);
 577
 578   prog = tilde_expand (argv[0]);
 579
 580   if (argv[1] != NULL)
 581     error (_("GDB sim does not yet support a load offset."));
 582
 583   if (remote_debug)
 584     printf_filtered ("gdbsim_load: prog \"%s\"\n", prog);
 585
 586   /* FIXME: We will print two messages on error.
 587      Need error to either not print anything if passed NULL or need
 588      another routine that doesn't take any arguments.  */
 589   if (sim_load (sim_data->gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL)
 590     error (_("unable to load program"));
 591
 592   /* FIXME: If a load command should reset the targets registers then
 593      a call to sim_create_inferior() should go here.  */
 594
 595   sim_data->program_loaded = 1;
 596 }
 597
 598
 599 /* Start an inferior process and set inferior_ptid to its pid.
 600    EXEC_FILE is the file to run.
 601    ARGS is a string containing the arguments to the program.
 602    ENV is the environment vector to pass.  Errors reported with error().
 603    On VxWorks and various standalone systems, we ignore exec_file.  */
 604 /* This is called not only when we first attach, but also when the
 605    user types "run" after having attached.  */
 606
 607 static void
 608 gdbsim_create_inferior (struct target_ops *target, char *exec_file, char *args,
 609                         char **env, int from_tty)
 610 {
 611   struct sim_inferior_data *sim_data
 612     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
 613   int len;
 614   char *arg_buf, **argv;
 615
 616   if (exec_file == 0 || exec_bfd == 0)
 617     warning (_("No executable file specified."));
 618   if (!sim_data->program_loaded)
 619     warning (_("No program loaded."));
 620
 621   if (remote_debug)
 622     printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
 623                      (exec_file ? exec_file : "(NULL)"),
 624                      args);
 625
 626   if (ptid_equal (inferior_ptid, sim_data->remote_sim_ptid))
 627     gdbsim_kill (target);
 628   remove_breakpoints ();
 629   init_wait_for_inferior ();
 630
 631   if (exec_file != NULL)
 632     {
 633       len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop */ 10;
 634       arg_buf = (char *) alloca (len);
 635       arg_buf[0] = '\0';
 636       strcat (arg_buf, exec_file);
 637       strcat (arg_buf, " ");
 638       strcat (arg_buf, args);
 639       argv = gdb_buildargv (arg_buf);
 640       make_cleanup_freeargv (argv);
 641     }
 642   else
 643     argv = NULL;
 644   sim_create_inferior (sim_data->gdbsim_desc, exec_bfd, argv, env);
 645
 646   inferior_ptid = sim_data->remote_sim_ptid;
 647   inferior_appeared (current_inferior (), ptid_get_pid (inferior_ptid));
 648   add_thread_silent (inferior_ptid);
 649
 650   insert_breakpoints ();        /* Needed to get correct instruction
 651                                    in cache.  */
 652
 653   clear_proceed_status ();
 654 }
 655
 656 /* The open routine takes the rest of the parameters from the command,
 657    and (if successful) pushes a new target onto the stack.
 658    Targets should supply this routine, if only to provide an error message.  */
 659 /* Called when selecting the simulator.  E.g. (gdb) target sim name.  */
 660
 661 static void
 662 gdbsim_open (char *args, int from_tty)
 663 {
 664   int len;
 665   char *arg_buf;
 666   struct sim_inferior_data *sim_data;
 667   SIM_DESC gdbsim_desc;
 668
 669   if (remote_debug)
 670     printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
 671
 672   /* Ensure that the sim target is not on the target stack.  This is
 673      necessary, because if it is on the target stack, the call to
 674      push_target below will invoke sim_close(), thus freeing various
 675      state (including a sim instance) that we allocate prior to
 676      invoking push_target().  We want to delay the push_target()
 677      operation until after we complete those operations which could
 678      error out.  */
 679   if (gdbsim_is_open)
 680     unpush_target (&gdbsim_ops);
 681
 682   len = (7 + 1                  /* gdbsim */
 683          + strlen (" -E little")
 684          + strlen (" --architecture=xxxxxxxxxx")
 685          + strlen (" --sysroot=") + strlen (gdb_sysroot) +
 686          + (args ? strlen (args) : 0)
 687          + 50) /* slack */ ;
 688   arg_buf = (char *) alloca (len);
 689   strcpy (arg_buf, "gdbsim");   /* 7 */
 690   /* Specify the byte order for the target when it is explicitly
 691      specified by the user (not auto detected).  */
 692   switch (selected_byte_order ())
 693     {
 694     case BFD_ENDIAN_BIG:
 695       strcat (arg_buf, " -E big");
 696       break;
 697     case BFD_ENDIAN_LITTLE:
 698       strcat (arg_buf, " -E little");
 699       break;
 700     case BFD_ENDIAN_UNKNOWN:
 701       break;
 702     }
 703   /* Specify the architecture of the target when it has been
 704      explicitly specified */
 705   if (selected_architecture_name () != NULL)
 706     {
 707       strcat (arg_buf, " --architecture=");
 708       strcat (arg_buf, selected_architecture_name ());
 709     }
 710   /* Pass along gdb's concept of the sysroot.  */
 711   strcat (arg_buf, " --sysroot=");
 712   strcat (arg_buf, gdb_sysroot);
 713   /* finally, any explicit args */
 714   if (args)
 715     {
 716       strcat (arg_buf, " ");    /* 1 */
 717       strcat (arg_buf, args);
 718     }
 719   sim_argv = gdb_buildargv (arg_buf);
 720
 721   init_callbacks ();
 722   gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, sim_argv);
 723
 724   if (gdbsim_desc == 0)
 725     {
 726       freeargv (sim_argv);
 727       sim_argv = NULL;
 728       error (_("unable to create simulator instance"));
 729     }
 730
 731   /* Reset the pid numberings for this batch of sim instances.  */
 732   next_pid = INITIAL_PID;
 733
 734   /* Allocate the inferior data, but do not allocate a sim instance
 735      since we've already just done that.  */
 736   sim_data = get_sim_inferior_data (current_inferior (),
 737                                     SIM_INSTANCE_NOT_NEEDED);
 738
 739   sim_data->gdbsim_desc = gdbsim_desc;
 740
 741   push_target (&gdbsim_ops);
 742   printf_filtered ("Connected to the simulator.\n");
 743
 744   /* There's nothing running after "target sim" or "load"; not until
 745      "run".  */
 746   inferior_ptid = null_ptid;
 747
 748   gdbsim_is_open = 1;
 749 }
 750
 751 /* Callback for iterate_over_inferiors.  Called (indirectly) by
 752    gdbsim_close().  */
 753
 754 static int
 755 gdbsim_close_inferior (struct inferior *inf, void *arg)
 756 {
 757   struct sim_inferior_data *sim_data = inferior_data (inf,
 758                                                       sim_inferior_data_key);
 759   if (sim_data != NULL)
 760     {
 761       ptid_t ptid = sim_data->remote_sim_ptid;
 762
 763       sim_inferior_data_cleanup (inf, sim_data);
 764       set_inferior_data (inf, sim_inferior_data_key, NULL);
 765
 766       /* Having a ptid allocated and stored in remote_sim_ptid does
 767          not mean that a corresponding inferior was ever created.
 768          Thus we need to verify the existence of an inferior using the
 769          pid in question before setting inferior_ptid via
 770          switch_to_thread() or mourning the inferior.  */
 771       if (find_inferior_pid (ptid_get_pid (ptid)) != NULL)
 772         {
 773           switch_to_thread (ptid);
 774           generic_mourn_inferior ();
 775         }
 776     }
 777
 778   return 0;
 779 }
 780
 781 /* Does whatever cleanup is required for a target that we are no longer
 782    going to be calling.  Argument says whether we are quitting gdb and
 783    should not get hung in case of errors, or whether we want a clean
 784    termination even if it takes a while.  This routine is automatically
 785    always called just before a routine is popped off the target stack.
 786    Closing file descriptors and freeing memory are typical things it should
 787    do.  */
 788 /* Close out all files and local state before this target loses control.  */
 789
 790 static void
 791 gdbsim_close (int quitting)
 792 {
 793   struct sim_inferior_data *sim_data
 794     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
 795
 796   if (remote_debug)
 797     printf_filtered ("gdbsim_close: quitting %d\n", quitting);
 798
 799   iterate_over_inferiors (gdbsim_close_inferior, NULL);
 800
 801   if (sim_argv != NULL)
 802     {
 803       freeargv (sim_argv);
 804       sim_argv = NULL;
 805     }
 806
 807   end_callbacks ();
 808
 809   gdbsim_is_open = 0;
 810 }
 811
 812 /* Takes a program previously attached to and detaches it.
 813    The program may resume execution (some targets do, some don't) and will
 814    no longer stop on signals, etc.  We better not have left any breakpoints
 815    in the program or it'll die when it hits one.  ARGS is arguments
 816    typed by the user (e.g. a signal to send the process).  FROM_TTY
 817    says whether to be verbose or not.  */
 818 /* Terminate the open connection to the remote debugger.
 819    Use this when you want to detach and do something else with your gdb.  */
 820
 821 static void
 822 gdbsim_detach (struct target_ops *ops, char *args, int from_tty)
 823 {
 824   if (remote_debug)
 825     printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
 826
 827   pop_target ();                /* calls gdbsim_close to do the real work */
 828   if (from_tty)
 829     printf_filtered ("Ending simulator %s debugging\n", target_shortname);
 830 }
 831
 832 /* Resume execution of the target process.  STEP says whether to single-step
 833    or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
 834    to the target, or zero for no signal.  */
 835
 836 struct resume_data
 837 {
 838   enum target_signal siggnal;
 839   int step;
 840 };
 841
 842 static int
 843 gdbsim_resume_inferior (struct inferior *inf, void *arg)
 844 {
 845   struct sim_inferior_data *sim_data
 846     = get_sim_inferior_data (inf, SIM_INSTANCE_NOT_NEEDED);
 847   struct resume_data *rd = arg;
 848
 849   if (sim_data)
 850     {
 851       sim_data->resume_siggnal = rd->siggnal;
 852       sim_data->resume_step = rd->step;
 853
 854       if (remote_debug)
 855         printf_filtered (_("gdbsim_resume: pid %d, step %d, signal %d\n"),
 856                          inf->pid, rd->step, rd->siggnal);
 857     }
 858
 859   /* When called from iterate_over_inferiors, a zero return causes the
 860      iteration process to proceed until there are no more inferiors to
 861      consider.  */
 862   return 0;
 863 }
 864
 865 static void
 866 gdbsim_resume (struct target_ops *ops,
 867                ptid_t ptid, int step, enum target_signal siggnal)
 868 {
 869   struct resume_data rd;
 870   struct sim_inferior_data *sim_data
 871     = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NOT_NEEDED);
 872
 873   rd.siggnal = siggnal;
 874   rd.step = step;
 875
 876   /* We don't access any sim_data members within this function.
 877      What's of interest is whether or not the call to
 878      get_sim_inferior_data_by_ptid(), above, is able to obtain a
 879      non-NULL pointer.  If it managed to obtain a non-NULL pointer, we
 880      know we have a single inferior to consider.  If it's NULL, we
 881      either have multiple inferiors to resume or an error condition.  */
 882
 883   if (sim_data)
 884     gdbsim_resume_inferior (find_inferior_pid (ptid_get_pid (ptid)), &rd);
 885   else if (ptid_equal (ptid, minus_one_ptid))
 886     iterate_over_inferiors (gdbsim_resume_inferior, &rd);
 887   else
 888     error (_("The program is not being run."));
 889 }
 890
 891 /* Notify the simulator of an asynchronous request to stop.
 892
 893    The simulator shall ensure that the stop request is eventually
 894    delivered to the simulator.  If the call is made while the
 895    simulator is not running then the stop request is processed when
 896    the simulator is next resumed.
 897
 898    For simulators that do not support this operation, just abort.  */
 899
 900 static int
 901 gdbsim_stop_inferior (struct inferior *inf, void *arg)
 902 {
 903   struct sim_inferior_data *sim_data
 904     = get_sim_inferior_data (inf, SIM_INSTANCE_NEEDED);
 905
 906   if (sim_data)
 907     {
 908       if (!sim_stop (sim_data->gdbsim_desc))
 909         {
 910           quit ();
 911         }
 912     }
 913
 914   /* When called from iterate_over_inferiors, a zero return causes the
 915      iteration process to proceed until there are no more inferiors to
 916      consider.  */
 917   return 0;
 918 }
 919
 920 static void
 921 gdbsim_stop (ptid_t ptid)
 922 {
 923   struct sim_inferior_data *sim_data;
 924
 925   if (ptid_equal (ptid, minus_one_ptid))
 926     {
 927       iterate_over_inferiors (gdbsim_stop_inferior, NULL);
 928     }
 929   else
 930     {
 931       struct inferior *inf = find_inferior_pid (ptid_get_pid (ptid));
 932
 933       if (inf == NULL)
 934         error (_("Can't stop pid %d.  No inferior found."),
 935                ptid_get_pid (ptid));
 936
 937       gdbsim_stop_inferior (inf, NULL);
 938     }
 939 }
 940
 941 /* GDB version of os_poll_quit callback.
 942    Taken from gdb/util.c - should be in a library.  */
 943
 944 static int
 945 gdb_os_poll_quit (host_callback *p)
 946 {
 947   if (deprecated_ui_loop_hook != NULL)
 948     deprecated_ui_loop_hook (0);
 949
 950   if (quit_flag)                /* gdb's idea of quit */
 951     {
 952       quit_flag = 0;            /* we've stolen it */
 953       return 1;
 954     }
 955   else if (immediate_quit)
 956     {
 957       return 1;
 958     }
 959   return 0;
 960 }
 961
 962 /* Wait for inferior process to do something.  Return pid of child,
 963    or -1 in case of error; store status through argument pointer STATUS,
 964    just as `wait' would.  */
 965
 966 static void
 967 gdbsim_cntrl_c (int signo)
 968 {
 969   gdbsim_stop (minus_one_ptid);
 970 }
 971
 972 static ptid_t
 973 gdbsim_wait (struct target_ops *ops,
 974              ptid_t ptid, struct target_waitstatus *status, int options)
 975 {
 976   struct sim_inferior_data *sim_data;
 977   static RETSIGTYPE (*prev_sigint) ();
 978   int sigrc = 0;
 979   enum sim_stop reason = sim_running;
 980
 981   /* This target isn't able to (yet) resume more than one inferior at a time.
 982      When ptid is minus_one_ptid, just use the current inferior.  If we're
 983      given an explicit pid, we'll try to find it and use that instead.  */
 984   if (ptid_equal (ptid, minus_one_ptid))
 985     sim_data = get_sim_inferior_data (current_inferior (),
 986                                       SIM_INSTANCE_NEEDED);
 987   else
 988     {
 989       sim_data = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NEEDED);
 990       if (sim_data == NULL)
 991         error (_("Unable to wait for pid %d.  Inferior not found."),
 992                ptid_get_pid (ptid));
 993       inferior_ptid = ptid;
 994     }
 995
 996   if (remote_debug)
 997     printf_filtered ("gdbsim_wait\n");
 998
 999 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1000   {
1001     struct sigaction sa, osa;
1002     sa.sa_handler = gdbsim_cntrl_c;
1003     sigemptyset (&sa.sa_mask);
1004     sa.sa_flags = 0;
1005     sigaction (SIGINT, &sa, &osa);
1006     prev_sigint = osa.sa_handler;
1007   }
1008 #else
1009   prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
1010 #endif
1011   sim_resume (sim_data->gdbsim_desc, sim_data->resume_step,
1012               sim_data->resume_siggnal);
1013
1014   signal (SIGINT, prev_sigint);
1015   sim_data->resume_step = 0;
1016
1017   sim_stop_reason (sim_data->gdbsim_desc, &reason, &sigrc);
1018
1019   switch (reason)
1020     {
1021     case sim_exited:
1022       status->kind = TARGET_WAITKIND_EXITED;
1023       status->value.integer = sigrc;
1024       break;
1025     case sim_stopped:
1026       switch (sigrc)
1027         {
1028         case TARGET_SIGNAL_ABRT:
1029           quit ();
1030           break;
1031         case TARGET_SIGNAL_INT:
1032         case TARGET_SIGNAL_TRAP:
1033         default:
1034           status->kind = TARGET_WAITKIND_STOPPED;
1035           status->value.sig = sigrc;
1036           break;
1037         }
1038       break;
1039     case sim_signalled:
1040       status->kind = TARGET_WAITKIND_SIGNALLED;
1041       status->value.sig = sigrc;
1042       break;
1043     case sim_running:
1044     case sim_polling:
1045       /* FIXME: Is this correct?  */
1046       break;
1047     }
1048
1049   return inferior_ptid;
1050 }
1051
1052 /* Get ready to modify the registers array.  On machines which store
1053    individual registers, this doesn't need to do anything.  On machines
1054    which store all the registers in one fell swoop, this makes sure
1055    that registers contains all the registers from the program being
1056    debugged.  */
1057
1058 static void
1059 gdbsim_prepare_to_store (struct regcache *regcache)
1060 {
1061   /* Do nothing, since we can store individual regs.  */
1062 }
1063
1064 /* Transfer LEN bytes between GDB address MYADDR and target address
1065    MEMADDR.  If WRITE is non-zero, transfer them to the target,
1066    otherwise transfer them from the target.  TARGET is unused.
1067
1068    Returns the number of bytes transferred.  */
1069
1070 static int
1071 gdbsim_xfer_inferior_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
1072                              int write, struct mem_attrib *attrib,
1073                              struct target_ops *target)
1074 {
1075   struct sim_inferior_data *sim_data
1076     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1077
1078   /* If this target doesn't have memory yet, return 0 causing the
1079      request to be passed to a lower target, hopefully an exec
1080      file.  */
1081   if (!target->to_has_memory (target))
1082     return 0;
1083
1084   if (!sim_data->program_loaded)
1085     error (_("No program loaded."));
1086
1087   /* Note that we obtained the sim_data pointer above using
1088      SIM_INSTANCE_NOT_NEEDED.  We do this so that we don't needlessly
1089      allocate a sim instance prior to loading a program.   If we
1090      get to this point in the code though, gdbsim_desc should be
1091      non-NULL.  (Note that a sim instance is needed in order to load
1092      the program...)  */
1093   gdb_assert (sim_data->gdbsim_desc != NULL);
1094
1095   if (remote_debug)
1096     {
1097       /* FIXME: Send to something other than STDOUT?  */
1098       printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x");
1099       gdb_print_host_address (myaddr, gdb_stdout);
1100       printf_filtered (", memaddr %s, len %d, write %d\n",
1101                        paddress (target_gdbarch, memaddr), len, write);
1102       if (remote_debug && write)
1103         dump_mem (myaddr, len);
1104     }
1105
1106   if (write)
1107     {
1108       len = sim_write (sim_data->gdbsim_desc, memaddr, myaddr, len);
1109     }
1110   else
1111     {
1112       len = sim_read (sim_data->gdbsim_desc, memaddr, myaddr, len);
1113       if (remote_debug && len > 0)
1114         dump_mem (myaddr, len);
1115     }
1116   return len;
1117 }
1118
1119 static void
1120 gdbsim_files_info (struct target_ops *target)
1121 {
1122   struct sim_inferior_data *sim_data
1123     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
1124   const char *file = "nothing";
1125
1126   if (exec_bfd)
1127     file = bfd_get_filename (exec_bfd);
1128
1129   if (remote_debug)
1130     printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
1131
1132   if (exec_bfd)
1133     {
1134       printf_filtered ("\tAttached to %s running program %s\n",
1135                        target_shortname, file);
1136       sim_info (sim_data->gdbsim_desc, 0);
1137     }
1138 }
1139
1140 /* Clear the simulator's notion of what the break points are.  */
1141
1142 static void
1143 gdbsim_mourn_inferior (struct target_ops *target)
1144 {
1145   struct sim_inferior_data *sim_data
1146     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1147
1148   if (remote_debug)
1149     printf_filtered ("gdbsim_mourn_inferior:\n");
1150
1151   remove_breakpoints ();
1152   generic_mourn_inferior ();
1153   delete_thread_silent (sim_data->remote_sim_ptid);
1154 }
1155
1156 /* Pass the command argument through to the simulator verbatim.  The
1157    simulator must do any command interpretation work.  */
1158
1159 void
1160 simulator_command (char *args, int from_tty)
1161 {
1162   struct sim_inferior_data *sim_data;
1163
1164   /* We use inferior_data() instead of get_sim_inferior_data() here in
1165      order to avoid attaching a sim_inferior_data struct to an
1166      inferior unnecessarily.  The reason we take such care here is due
1167      to the fact that this function, simulator_command(), may be called
1168      even when the sim target is not active.  If we were to use
1169      get_sim_inferior_data() here, it is possible that this call would
1170      be made either prior to gdbsim_open() or after gdbsim_close(),
1171      thus allocating memory that would not be garbage collected until
1172      the ultimate destruction of the associated inferior.  */
1173
1174   sim_data  = inferior_data (current_inferior (), sim_inferior_data_key);
1175   if (sim_data == NULL || sim_data->gdbsim_desc == NULL)
1176     {
1177
1178       /* PREVIOUSLY: The user may give a command before the simulator
1179          is opened. [...] (??? assuming of course one wishes to
1180          continue to allow commands to be sent to unopened simulators,
1181          which isn't entirely unreasonable).  */
1182
1183       /* The simulator is a builtin abstraction of a remote target.
1184          Consistent with that model, access to the simulator, via sim
1185          commands, is restricted to the period when the channel to the
1186          simulator is open.  */
1187
1188       error (_("Not connected to the simulator target"));
1189     }
1190
1191   sim_do_command (sim_data->gdbsim_desc, args);
1192
1193   /* Invalidate the register cache, in case the simulator command does
1194      something funny.  */
1195   registers_changed ();
1196 }
1197
1198 static char **
1199 sim_command_completer (struct cmd_list_element *ignore, char *text, char *word)
1200 {
1201   struct sim_inferior_data *sim_data;
1202
1203   sim_data = inferior_data (current_inferior (), sim_inferior_data_key);
1204   if (sim_data == NULL || sim_data->gdbsim_desc == NULL)
1205     return NULL;
1206
1207   return sim_complete_command (sim_data->gdbsim_desc, text, word);
1208 }
1209
1210 /* Check to see if a thread is still alive.  */
1211
1212 static int
1213 gdbsim_thread_alive (struct target_ops *ops, ptid_t ptid)
1214 {
1215   struct sim_inferior_data *sim_data
1216     = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NOT_NEEDED);
1217
1218   if (sim_data == NULL)
1219     return 0;
1220
1221   if (ptid_equal (ptid, sim_data->remote_sim_ptid))
1222     /* The simulators' task is always alive.  */
1223     return 1;
1224
1225   return 0;
1226 }
1227
1228 /* Convert a thread ID to a string.  Returns the string in a static
1229    buffer.  */
1230
1231 static char *
1232 gdbsim_pid_to_str (struct target_ops *ops, ptid_t ptid)
1233 {
1234   return normal_pid_to_str (ptid);
1235 }
1236
1237 /* Simulator memory may be accessed after the program has been loaded.  */
1238
1239 int
1240 gdbsim_has_all_memory (struct target_ops *ops)
1241 {
1242   struct sim_inferior_data *sim_data
1243     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1244
1245   if (!sim_data->program_loaded)
1246     return 0;
1247
1248   return 1;
1249 }
1250
1251 int
1252 gdbsim_has_memory (struct target_ops *ops)
1253 {
1254   struct sim_inferior_data *sim_data
1255     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1256
1257   if (!sim_data->program_loaded)
1258     return 0;
1259
1260   return 1;
1261 }
1262
1263 /* Define the target subroutine names.  */
1264
1265 struct target_ops gdbsim_ops;
1266
1267 static void
1268 init_gdbsim_ops (void)
1269 {
1270   gdbsim_ops.to_shortname = "sim";
1271   gdbsim_ops.to_longname = "simulator";
1272   gdbsim_ops.to_doc = "Use the compiled-in simulator.";
1273   gdbsim_ops.to_open = gdbsim_open;
1274   gdbsim_ops.to_close = gdbsim_close;
1275   gdbsim_ops.to_detach = gdbsim_detach;
1276   gdbsim_ops.to_resume = gdbsim_resume;
1277   gdbsim_ops.to_wait = gdbsim_wait;
1278   gdbsim_ops.to_fetch_registers = gdbsim_fetch_register;
1279   gdbsim_ops.to_store_registers = gdbsim_store_register;
1280   gdbsim_ops.to_prepare_to_store = gdbsim_prepare_to_store;
1281   gdbsim_ops.deprecated_xfer_memory = gdbsim_xfer_inferior_memory;
1282   gdbsim_ops.to_files_info = gdbsim_files_info;
1283   gdbsim_ops.to_insert_breakpoint = memory_insert_breakpoint;
1284   gdbsim_ops.to_remove_breakpoint = memory_remove_breakpoint;
1285   gdbsim_ops.to_kill = gdbsim_kill;
1286   gdbsim_ops.to_load = gdbsim_load;
1287   gdbsim_ops.to_create_inferior = gdbsim_create_inferior;
1288   gdbsim_ops.to_mourn_inferior = gdbsim_mourn_inferior;
1289   gdbsim_ops.to_stop = gdbsim_stop;
1290   gdbsim_ops.to_thread_alive = gdbsim_thread_alive;
1291   gdbsim_ops.to_pid_to_str = gdbsim_pid_to_str;
1292   gdbsim_ops.to_stratum = process_stratum;
1293   gdbsim_ops.to_has_all_memory = gdbsim_has_all_memory;
1294   gdbsim_ops.to_has_memory = gdbsim_has_memory;
1295   gdbsim_ops.to_has_stack = default_child_has_stack;
1296   gdbsim_ops.to_has_registers = default_child_has_registers;
1297   gdbsim_ops.to_has_execution = default_child_has_execution;
1298   gdbsim_ops.to_magic = OPS_MAGIC;
1299 }
1300
1301 void
1302 _initialize_remote_sim (void)
1303 {
1304   struct cmd_list_element *c;
1305
1306   init_gdbsim_ops ();
1307   add_target (&gdbsim_ops);
1308
1309   c = add_com ("sim", class_obscure, simulator_command,
1310                _("Send a command to the simulator."));
1311   set_cmd_completer (c, sim_command_completer);
1312
1313   sim_inferior_data_key
1314     = register_inferior_data_with_cleanup (sim_inferior_data_cleanup);
1315 }