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