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 gdb_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 = GDB_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   printf_filtered ("\t");
 277
 278   if (len == 8 || len == 4)
 279     {
 280       uint32_t l[2];
 281
 282       memcpy (l, buf, len);
 283       printf_filtered ("0x%08x", l[0]);
 284       if (len == 8)
 285         printf_filtered (" 0x%08x", l[1]);
 286     }
 287   else
 288     {
 289       int i;
 290
 291       for (i = 0; i < len; i++)
 292         printf_filtered ("0x%02x ", buf[i]);
 293     }
 294
 295   printf_filtered ("\n");
 296 }
 297
 298 /* Initialize gdb_callback.  */
 299
 300 static void
 301 init_callbacks (void)
 302 {
 303   if (!callbacks_initialized)
 304     {
 305       gdb_callback = default_callback;
 306       gdb_callback.init (&gdb_callback);
 307       gdb_callback.write_stdout = gdb_os_write_stdout;
 308       gdb_callback.flush_stdout = gdb_os_flush_stdout;
 309       gdb_callback.write_stderr = gdb_os_write_stderr;
 310       gdb_callback.flush_stderr = gdb_os_flush_stderr;
 311       gdb_callback.printf_filtered = gdb_os_printf_filtered;
 312       gdb_callback.vprintf_filtered = gdb_os_vprintf_filtered;
 313       gdb_callback.evprintf_filtered = gdb_os_evprintf_filtered;
 314       gdb_callback.error = gdb_os_error;
 315       gdb_callback.poll_quit = gdb_os_poll_quit;
 316       gdb_callback.magic = HOST_CALLBACK_MAGIC;
 317       callbacks_initialized = 1;
 318     }
 319 }
 320
 321 /* Release callbacks (free resources used by them).  */
 322
 323 static void
 324 end_callbacks (void)
 325 {
 326   if (callbacks_initialized)
 327     {
 328       gdb_callback.shutdown (&gdb_callback);
 329       callbacks_initialized = 0;
 330     }
 331 }
 332
 333 /* GDB version of os_write_stdout callback.  */
 334
 335 static int
 336 gdb_os_write_stdout (host_callback *p, const char *buf, int len)
 337 {
 338   int i;
 339   char b[2];
 340
 341   ui_file_write (gdb_stdtarg, buf, len);
 342   return len;
 343 }
 344
 345 /* GDB version of os_flush_stdout callback.  */
 346
 347 static void
 348 gdb_os_flush_stdout (host_callback *p)
 349 {
 350   gdb_flush (gdb_stdtarg);
 351 }
 352
 353 /* GDB version of os_write_stderr callback.  */
 354
 355 static int
 356 gdb_os_write_stderr (host_callback *p, const char *buf, int len)
 357 {
 358   int i;
 359   char b[2];
 360
 361   for (i = 0; i < len; i++)
 362     {
 363       b[0] = buf[i];
 364       b[1] = 0;
 365       fputs_unfiltered (b, gdb_stdtargerr);
 366     }
 367   return len;
 368 }
 369
 370 /* GDB version of os_flush_stderr callback.  */
 371
 372 static void
 373 gdb_os_flush_stderr (host_callback *p)
 374 {
 375   gdb_flush (gdb_stdtargerr);
 376 }
 377
 378 /* GDB version of printf_filtered callback.  */
 379
 380 static void
 381 gdb_os_printf_filtered (host_callback * p, const char *format,...)
 382 {
 383   va_list args;
 384
 385   va_start (args, format);
 386   vfprintf_filtered (gdb_stdout, format, args);
 387   va_end (args);
 388 }
 389
 390 /* GDB version of error vprintf_filtered.  */
 391
 392 static void
 393 gdb_os_vprintf_filtered (host_callback * p, const char *format, va_list ap)
 394 {
 395   vfprintf_filtered (gdb_stdout, format, ap);
 396 }
 397
 398 /* GDB version of error evprintf_filtered.  */
 399
 400 static void
 401 gdb_os_evprintf_filtered (host_callback * p, const char *format, va_list ap)
 402 {
 403   vfprintf_filtered (gdb_stderr, format, ap);
 404 }
 405
 406 /* GDB version of error callback.  */
 407
 408 static void
 409 gdb_os_error (host_callback * p, const char *format, ...)
 410 {
 411   va_list args;
 412
 413   va_start (args, format);
 414   verror (format, args);
 415   va_end (args);
 416 }
 417
 418 int
 419 one2one_register_sim_regno (struct gdbarch *gdbarch, int regnum)
 420 {
 421   /* Only makes sense to supply raw registers.  */
 422   gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
 423   return regnum;
 424 }
 425
 426 static void
 427 gdbsim_fetch_register (struct target_ops *ops,
 428                        struct regcache *regcache, int regno)
 429 {
 430   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 431   struct sim_inferior_data *sim_data
 432     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
 433
 434   if (regno == -1)
 435     {
 436       for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
 437         gdbsim_fetch_register (ops, regcache, regno);
 438       return;
 439     }
 440
 441   switch (gdbarch_register_sim_regno (gdbarch, regno))
 442     {
 443     case LEGACY_SIM_REGNO_IGNORE:
 444       break;
 445     case SIM_REGNO_DOES_NOT_EXIST:
 446       {
 447         /* For moment treat a `does not exist' register the same way
 448            as an ``unavailable'' register.  */
 449         char buf[MAX_REGISTER_SIZE];
 450         int nr_bytes;
 451
 452         memset (buf, 0, MAX_REGISTER_SIZE);
 453         regcache_raw_supply (regcache, regno, buf);
 454         break;
 455       }
 456
 457     default:
 458       {
 459         static int warn_user = 1;
 460         char buf[MAX_REGISTER_SIZE];
 461         int nr_bytes;
 462
 463         gdb_assert (regno >= 0 && regno < gdbarch_num_regs (gdbarch));
 464         memset (buf, 0, MAX_REGISTER_SIZE);
 465         nr_bytes = sim_fetch_register (sim_data->gdbsim_desc,
 466                                        gdbarch_register_sim_regno
 467                                          (gdbarch, regno),
 468                                        buf,
 469                                        register_size (gdbarch, regno));
 470         if (nr_bytes > 0
 471             && nr_bytes != register_size (gdbarch, regno) && warn_user)
 472           {
 473             fprintf_unfiltered (gdb_stderr,
 474                                 "Size of register %s (%d/%d) "
 475                                 "incorrect (%d instead of %d))",
 476                                 gdbarch_register_name (gdbarch, regno),
 477                                 regno,
 478                                 gdbarch_register_sim_regno
 479                                   (gdbarch, regno),
 480                                 nr_bytes, register_size (gdbarch, regno));
 481             warn_user = 0;
 482           }
 483         /* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0'
 484            indicating that GDB and the SIM have different ideas about
 485            which registers are fetchable.  */
 486         /* Else if (nr_bytes < 0): an old simulator, that doesn't
 487            think to return the register size.  Just assume all is ok.  */
 488         regcache_raw_supply (regcache, regno, buf);
 489         if (remote_debug)
 490           {
 491             printf_filtered ("gdbsim_fetch_register: %d", regno);
 492             /* FIXME: We could print something more intelligible.  */
 493             dump_mem (buf, register_size (gdbarch, regno));
 494           }
 495         break;
 496       }
 497     }
 498 }
 499
 500
 501 static void
 502 gdbsim_store_register (struct target_ops *ops,
 503                        struct regcache *regcache, int regno)
 504 {
 505   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 506   struct sim_inferior_data *sim_data
 507     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
 508
 509   if (regno == -1)
 510     {
 511       for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
 512         gdbsim_store_register (ops, regcache, regno);
 513       return;
 514     }
 515   else if (gdbarch_register_sim_regno (gdbarch, regno) >= 0)
 516     {
 517       char tmp[MAX_REGISTER_SIZE];
 518       int nr_bytes;
 519
 520       regcache_cooked_read (regcache, regno, tmp);
 521       nr_bytes = sim_store_register (sim_data->gdbsim_desc,
 522                                      gdbarch_register_sim_regno
 523                                        (gdbarch, regno),
 524                                      tmp, register_size (gdbarch, regno));
 525       if (nr_bytes > 0 && nr_bytes != register_size (gdbarch, regno))
 526         internal_error (__FILE__, __LINE__,
 527                         _("Register size different to expected"));
 528       if (nr_bytes < 0)
 529         internal_error (__FILE__, __LINE__,
 530                         _("Register %d not updated"), regno);
 531       if (nr_bytes == 0)
 532         warning (_("Register %s not updated"),
 533                  gdbarch_register_name (gdbarch, regno));
 534
 535       if (remote_debug)
 536         {
 537           printf_filtered ("gdbsim_store_register: %d", regno);
 538           /* FIXME: We could print something more intelligible.  */
 539           dump_mem (tmp, register_size (gdbarch, regno));
 540         }
 541     }
 542 }
 543
 544 /* Kill the running program.  This may involve closing any open files
 545    and releasing other resources acquired by the simulated program.  */
 546
 547 static void
 548 gdbsim_kill (struct target_ops *ops)
 549 {
 550   if (remote_debug)
 551     printf_filtered ("gdbsim_kill\n");
 552
 553   /* There is no need to `kill' running simulator - the simulator is
 554      not running.  Mourning it is enough.  */
 555   target_mourn_inferior ();
 556 }
 557
 558 /* Load an executable file into the target process.  This is expected to
 559    not only bring new code into the target process, but also to update
 560    GDB's symbol tables to match.  */
 561
 562 static void
 563 gdbsim_load (char *args, int fromtty)
 564 {
 565   char **argv;
 566   char *prog;
 567   struct sim_inferior_data *sim_data
 568     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
 569
 570   if (args == NULL)
 571       error_no_arg (_("program to load"));
 572
 573   argv = gdb_buildargv (args);
 574   make_cleanup_freeargv (argv);
 575
 576   prog = tilde_expand (argv[0]);
 577
 578   if (argv[1] != NULL)
 579     error (_("GDB sim does not yet support a load offset."));
 580
 581   if (remote_debug)
 582     printf_filtered ("gdbsim_load: prog \"%s\"\n", prog);
 583
 584   /* FIXME: We will print two messages on error.
 585      Need error to either not print anything if passed NULL or need
 586      another routine that doesn't take any arguments.  */
 587   if (sim_load (sim_data->gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL)
 588     error (_("unable to load program"));
 589
 590   /* FIXME: If a load command should reset the targets registers then
 591      a call to sim_create_inferior() should go here.  */
 592
 593   sim_data->program_loaded = 1;
 594 }
 595
 596
 597 /* Start an inferior process and set inferior_ptid to its pid.
 598    EXEC_FILE is the file to run.
 599    ARGS is a string containing the arguments to the program.
 600    ENV is the environment vector to pass.  Errors reported with error().
 601    On VxWorks and various standalone systems, we ignore exec_file.  */
 602 /* This is called not only when we first attach, but also when the
 603    user types "run" after having attached.  */
 604
 605 static void
 606 gdbsim_create_inferior (struct target_ops *target, char *exec_file, char *args,
 607                         char **env, int from_tty)
 608 {
 609   struct sim_inferior_data *sim_data
 610     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
 611   int len;
 612   char *arg_buf, **argv;
 613
 614   if (exec_file == 0 || exec_bfd == 0)
 615     warning (_("No executable file specified."));
 616   if (!sim_data->program_loaded)
 617     warning (_("No program loaded."));
 618
 619   if (remote_debug)
 620     printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
 621                      (exec_file ? exec_file : "(NULL)"),
 622                      args);
 623
 624   if (ptid_equal (inferior_ptid, sim_data->remote_sim_ptid))
 625     gdbsim_kill (target);
 626   remove_breakpoints ();
 627   init_wait_for_inferior ();
 628
 629   if (exec_file != NULL)
 630     {
 631       len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop */ 10;
 632       arg_buf = (char *) alloca (len);
 633       arg_buf[0] = '\0';
 634       strcat (arg_buf, exec_file);
 635       strcat (arg_buf, " ");
 636       strcat (arg_buf, args);
 637       argv = gdb_buildargv (arg_buf);
 638       make_cleanup_freeargv (argv);
 639     }
 640   else
 641     argv = NULL;
 642
 643   if (sim_create_inferior (sim_data->gdbsim_desc, exec_bfd, argv, env)
 644       != SIM_RC_OK)
 645     error (_("Unable to create sim inferior."));
 646
 647   inferior_ptid = sim_data->remote_sim_ptid;
 648   inferior_appeared (current_inferior (), ptid_get_pid (inferior_ptid));
 649   add_thread_silent (inferior_ptid);
 650
 651   insert_breakpoints ();        /* Needed to get correct instruction
 652                                    in cache.  */
 653
 654   clear_proceed_status ();
 655 }
 656
 657 /* The open routine takes the rest of the parameters from the command,
 658    and (if successful) pushes a new target onto the stack.
 659    Targets should supply this routine, if only to provide an error message.  */
 660 /* Called when selecting the simulator.  E.g. (gdb) target sim name.  */
 661
 662 static void
 663 gdbsim_open (char *args, int from_tty)
 664 {
 665   int len;
 666   char *arg_buf;
 667   struct sim_inferior_data *sim_data;
 668   SIM_DESC gdbsim_desc;
 669
 670   if (remote_debug)
 671     printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
 672
 673   /* Ensure that the sim target is not on the target stack.  This is
 674      necessary, because if it is on the target stack, the call to
 675      push_target below will invoke sim_close(), thus freeing various
 676      state (including a sim instance) that we allocate prior to
 677      invoking push_target().  We want to delay the push_target()
 678      operation until after we complete those operations which could
 679      error out.  */
 680   if (gdbsim_is_open)
 681     unpush_target (&gdbsim_ops);
 682
 683   len = (7 + 1                  /* gdbsim */
 684          + strlen (" -E little")
 685          + strlen (" --architecture=xxxxxxxxxx")
 686          + strlen (" --sysroot=") + strlen (gdb_sysroot) +
 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   /* Pass along gdb's concept of the sysroot.  */
 712   strcat (arg_buf, " --sysroot=");
 713   strcat (arg_buf, gdb_sysroot);
 714   /* finally, any explicit args */
 715   if (args)
 716     {
 717       strcat (arg_buf, " ");    /* 1 */
 718       strcat (arg_buf, args);
 719     }
 720   sim_argv = gdb_buildargv (arg_buf);
 721
 722   init_callbacks ();
 723   gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, sim_argv);
 724
 725   if (gdbsim_desc == 0)
 726     {
 727       freeargv (sim_argv);
 728       sim_argv = NULL;
 729       error (_("unable to create simulator instance"));
 730     }
 731
 732   /* Reset the pid numberings for this batch of sim instances.  */
 733   next_pid = INITIAL_PID;
 734
 735   /* Allocate the inferior data, but do not allocate a sim instance
 736      since we've already just done that.  */
 737   sim_data = get_sim_inferior_data (current_inferior (),
 738                                     SIM_INSTANCE_NOT_NEEDED);
 739
 740   sim_data->gdbsim_desc = gdbsim_desc;
 741
 742   push_target (&gdbsim_ops);
 743   printf_filtered ("Connected to the simulator.\n");
 744
 745   /* There's nothing running after "target sim" or "load"; not until
 746      "run".  */
 747   inferior_ptid = null_ptid;
 748
 749   gdbsim_is_open = 1;
 750 }
 751
 752 /* Callback for iterate_over_inferiors.  Called (indirectly) by
 753    gdbsim_close().  */
 754
 755 static int
 756 gdbsim_close_inferior (struct inferior *inf, void *arg)
 757 {
 758   struct sim_inferior_data *sim_data = inferior_data (inf,
 759                                                       sim_inferior_data_key);
 760   if (sim_data != NULL)
 761     {
 762       ptid_t ptid = sim_data->remote_sim_ptid;
 763
 764       sim_inferior_data_cleanup (inf, sim_data);
 765       set_inferior_data (inf, sim_inferior_data_key, NULL);
 766
 767       /* Having a ptid allocated and stored in remote_sim_ptid does
 768          not mean that a corresponding inferior was ever created.
 769          Thus we need to verify the existence of an inferior using the
 770          pid in question before setting inferior_ptid via
 771          switch_to_thread() or mourning the inferior.  */
 772       if (find_inferior_pid (ptid_get_pid (ptid)) != NULL)
 773         {
 774           switch_to_thread (ptid);
 775           generic_mourn_inferior ();
 776         }
 777     }
 778
 779   return 0;
 780 }
 781
 782 /* Does whatever cleanup is required for a target that we are no longer
 783    going to be calling.  Argument says whether we are quitting gdb and
 784    should not get hung in case of errors, or whether we want a clean
 785    termination even if it takes a while.  This routine is automatically
 786    always called just before a routine is popped off the target stack.
 787    Closing file descriptors and freeing memory are typical things it should
 788    do.  */
 789 /* Close out all files and local state before this target loses control.  */
 790
 791 static void
 792 gdbsim_close (int quitting)
 793 {
 794   struct sim_inferior_data *sim_data
 795     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
 796
 797   if (remote_debug)
 798     printf_filtered ("gdbsim_close: quitting %d\n", quitting);
 799
 800   iterate_over_inferiors (gdbsim_close_inferior, NULL);
 801
 802   if (sim_argv != NULL)
 803     {
 804       freeargv (sim_argv);
 805       sim_argv = NULL;
 806     }
 807
 808   end_callbacks ();
 809
 810   gdbsim_is_open = 0;
 811 }
 812
 813 /* Takes a program previously attached to and detaches it.
 814    The program may resume execution (some targets do, some don't) and will
 815    no longer stop on signals, etc.  We better not have left any breakpoints
 816    in the program or it'll die when it hits one.  ARGS is arguments
 817    typed by the user (e.g. a signal to send the process).  FROM_TTY
 818    says whether to be verbose or not.  */
 819 /* Terminate the open connection to the remote debugger.
 820    Use this when you want to detach and do something else with your gdb.  */
 821
 822 static void
 823 gdbsim_detach (struct target_ops *ops, char *args, int from_tty)
 824 {
 825   if (remote_debug)
 826     printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
 827
 828   pop_target ();                /* calls gdbsim_close to do the real work */
 829   if (from_tty)
 830     printf_filtered ("Ending simulator %s debugging\n", target_shortname);
 831 }
 832
 833 /* Resume execution of the target process.  STEP says whether to single-step
 834    or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
 835    to the target, or zero for no signal.  */
 836
 837 struct resume_data
 838 {
 839   enum gdb_signal siggnal;
 840   int step;
 841 };
 842
 843 static int
 844 gdbsim_resume_inferior (struct inferior *inf, void *arg)
 845 {
 846   struct sim_inferior_data *sim_data
 847     = get_sim_inferior_data (inf, SIM_INSTANCE_NOT_NEEDED);
 848   struct resume_data *rd = arg;
 849
 850   if (sim_data)
 851     {
 852       sim_data->resume_siggnal = rd->siggnal;
 853       sim_data->resume_step = rd->step;
 854
 855       if (remote_debug)
 856         printf_filtered (_("gdbsim_resume: pid %d, step %d, signal %d\n"),
 857                          inf->pid, rd->step, rd->siggnal);
 858     }
 859
 860   /* When called from iterate_over_inferiors, a zero return causes the
 861      iteration process to proceed until there are no more inferiors to
 862      consider.  */
 863   return 0;
 864 }
 865
 866 static void
 867 gdbsim_resume (struct target_ops *ops,
 868                ptid_t ptid, int step, enum gdb_signal siggnal)
 869 {
 870   struct resume_data rd;
 871   struct sim_inferior_data *sim_data
 872     = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NOT_NEEDED);
 873
 874   rd.siggnal = siggnal;
 875   rd.step = step;
 876
 877   /* We don't access any sim_data members within this function.
 878      What's of interest is whether or not the call to
 879      get_sim_inferior_data_by_ptid(), above, is able to obtain a
 880      non-NULL pointer.  If it managed to obtain a non-NULL pointer, we
 881      know we have a single inferior to consider.  If it's NULL, we
 882      either have multiple inferiors to resume or an error condition.  */
 883
 884   if (sim_data)
 885     gdbsim_resume_inferior (find_inferior_pid (ptid_get_pid (ptid)), &rd);
 886   else if (ptid_equal (ptid, minus_one_ptid))
 887     iterate_over_inferiors (gdbsim_resume_inferior, &rd);
 888   else
 889     error (_("The program is not being run."));
 890 }
 891
 892 /* Notify the simulator of an asynchronous request to stop.
 893
 894    The simulator shall ensure that the stop request is eventually
 895    delivered to the simulator.  If the call is made while the
 896    simulator is not running then the stop request is processed when
 897    the simulator is next resumed.
 898
 899    For simulators that do not support this operation, just abort.  */
 900
 901 static int
 902 gdbsim_stop_inferior (struct inferior *inf, void *arg)
 903 {
 904   struct sim_inferior_data *sim_data
 905     = get_sim_inferior_data (inf, SIM_INSTANCE_NEEDED);
 906
 907   if (sim_data)
 908     {
 909       if (!sim_stop (sim_data->gdbsim_desc))
 910         {
 911           quit ();
 912         }
 913     }
 914
 915   /* When called from iterate_over_inferiors, a zero return causes the
 916      iteration process to proceed until there are no more inferiors to
 917      consider.  */
 918   return 0;
 919 }
 920
 921 static void
 922 gdbsim_stop (ptid_t ptid)
 923 {
 924   struct sim_inferior_data *sim_data;
 925
 926   if (ptid_equal (ptid, minus_one_ptid))
 927     {
 928       iterate_over_inferiors (gdbsim_stop_inferior, NULL);
 929     }
 930   else
 931     {
 932       struct inferior *inf = find_inferior_pid (ptid_get_pid (ptid));
 933
 934       if (inf == NULL)
 935         error (_("Can't stop pid %d.  No inferior found."),
 936                ptid_get_pid (ptid));
 937
 938       gdbsim_stop_inferior (inf, NULL);
 939     }
 940 }
 941
 942 /* GDB version of os_poll_quit callback.
 943    Taken from gdb/util.c - should be in a library.  */
 944
 945 static int
 946 gdb_os_poll_quit (host_callback *p)
 947 {
 948   if (deprecated_ui_loop_hook != NULL)
 949     deprecated_ui_loop_hook (0);
 950
 951   if (check_quit_flag ())       /* gdb's idea of quit */
 952     {
 953       clear_quit_flag ();       /* we've stolen it */
 954       return 1;
 955     }
 956   return 0;
 957 }
 958
 959 /* Wait for inferior process to do something.  Return pid of child,
 960    or -1 in case of error; store status through argument pointer STATUS,
 961    just as `wait' would.  */
 962
 963 static void
 964 gdbsim_cntrl_c (int signo)
 965 {
 966   gdbsim_stop (minus_one_ptid);
 967 }
 968
 969 static ptid_t
 970 gdbsim_wait (struct target_ops *ops,
 971              ptid_t ptid, struct target_waitstatus *status, int options)
 972 {
 973   struct sim_inferior_data *sim_data;
 974   static RETSIGTYPE (*prev_sigint) ();
 975   int sigrc = 0;
 976   enum sim_stop reason = sim_running;
 977
 978   /* This target isn't able to (yet) resume more than one inferior at a time.
 979      When ptid is minus_one_ptid, just use the current inferior.  If we're
 980      given an explicit pid, we'll try to find it and use that instead.  */
 981   if (ptid_equal (ptid, minus_one_ptid))
 982     sim_data = get_sim_inferior_data (current_inferior (),
 983                                       SIM_INSTANCE_NEEDED);
 984   else
 985     {
 986       sim_data = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NEEDED);
 987       if (sim_data == NULL)
 988         error (_("Unable to wait for pid %d.  Inferior not found."),
 989                ptid_get_pid (ptid));
 990       inferior_ptid = ptid;
 991     }
 992
 993   if (remote_debug)
 994     printf_filtered ("gdbsim_wait\n");
 995
 996 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
 997   {
 998     struct sigaction sa, osa;
 999     sa.sa_handler = gdbsim_cntrl_c;
1000     sigemptyset (&sa.sa_mask);
1001     sa.sa_flags = 0;
1002     sigaction (SIGINT, &sa, &osa);
1003     prev_sigint = osa.sa_handler;
1004   }
1005 #else
1006   prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
1007 #endif
1008   sim_resume (sim_data->gdbsim_desc, sim_data->resume_step,
1009               sim_data->resume_siggnal);
1010
1011   signal (SIGINT, prev_sigint);
1012   sim_data->resume_step = 0;
1013
1014   sim_stop_reason (sim_data->gdbsim_desc, &reason, &sigrc);
1015
1016   switch (reason)
1017     {
1018     case sim_exited:
1019       status->kind = TARGET_WAITKIND_EXITED;
1020       status->value.integer = sigrc;
1021       break;
1022     case sim_stopped:
1023       switch (sigrc)
1024         {
1025         case GDB_SIGNAL_ABRT:
1026           quit ();
1027           break;
1028         case GDB_SIGNAL_INT:
1029         case GDB_SIGNAL_TRAP:
1030         default:
1031           status->kind = TARGET_WAITKIND_STOPPED;
1032           status->value.sig = sigrc;
1033           break;
1034         }
1035       break;
1036     case sim_signalled:
1037       status->kind = TARGET_WAITKIND_SIGNALLED;
1038       status->value.sig = sigrc;
1039       break;
1040     case sim_running:
1041     case sim_polling:
1042       /* FIXME: Is this correct?  */
1043       break;
1044     }
1045
1046   return inferior_ptid;
1047 }
1048
1049 /* Get ready to modify the registers array.  On machines which store
1050    individual registers, this doesn't need to do anything.  On machines
1051    which store all the registers in one fell swoop, this makes sure
1052    that registers contains all the registers from the program being
1053    debugged.  */
1054
1055 static void
1056 gdbsim_prepare_to_store (struct regcache *regcache)
1057 {
1058   /* Do nothing, since we can store individual regs.  */
1059 }
1060
1061 /* Transfer LEN bytes between GDB address MYADDR and target address
1062    MEMADDR.  If WRITE is non-zero, transfer them to the target,
1063    otherwise transfer them from the target.  TARGET is unused.
1064
1065    Returns the number of bytes transferred.  */
1066
1067 static int
1068 gdbsim_xfer_inferior_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
1069                              int write, struct mem_attrib *attrib,
1070                              struct target_ops *target)
1071 {
1072   struct sim_inferior_data *sim_data
1073     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1074
1075   /* If this target doesn't have memory yet, return 0 causing the
1076      request to be passed to a lower target, hopefully an exec
1077      file.  */
1078   if (!target->to_has_memory (target))
1079     return 0;
1080
1081   if (!sim_data->program_loaded)
1082     error (_("No program loaded."));
1083
1084   /* Note that we obtained the sim_data pointer above using
1085      SIM_INSTANCE_NOT_NEEDED.  We do this so that we don't needlessly
1086      allocate a sim instance prior to loading a program.   If we
1087      get to this point in the code though, gdbsim_desc should be
1088      non-NULL.  (Note that a sim instance is needed in order to load
1089      the program...)  */
1090   gdb_assert (sim_data->gdbsim_desc != NULL);
1091
1092   if (remote_debug)
1093     {
1094       /* FIXME: Send to something other than STDOUT?  */
1095       printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x");
1096       gdb_print_host_address (myaddr, gdb_stdout);
1097       printf_filtered (", memaddr %s, len %d, write %d\n",
1098                        paddress (target_gdbarch, memaddr), len, write);
1099       if (remote_debug && write)
1100         dump_mem (myaddr, len);
1101     }
1102
1103   if (write)
1104     {
1105       len = sim_write (sim_data->gdbsim_desc, memaddr, myaddr, len);
1106     }
1107   else
1108     {
1109       len = sim_read (sim_data->gdbsim_desc, memaddr, myaddr, len);
1110       if (remote_debug && len > 0)
1111         dump_mem (myaddr, len);
1112     }
1113   return len;
1114 }
1115
1116 static void
1117 gdbsim_files_info (struct target_ops *target)
1118 {
1119   struct sim_inferior_data *sim_data
1120     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
1121   const char *file = "nothing";
1122
1123   if (exec_bfd)
1124     file = bfd_get_filename (exec_bfd);
1125
1126   if (remote_debug)
1127     printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
1128
1129   if (exec_bfd)
1130     {
1131       printf_filtered ("\tAttached to %s running program %s\n",
1132                        target_shortname, file);
1133       sim_info (sim_data->gdbsim_desc, 0);
1134     }
1135 }
1136
1137 /* Clear the simulator's notion of what the break points are.  */
1138
1139 static void
1140 gdbsim_mourn_inferior (struct target_ops *target)
1141 {
1142   struct sim_inferior_data *sim_data
1143     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1144
1145   if (remote_debug)
1146     printf_filtered ("gdbsim_mourn_inferior:\n");
1147
1148   remove_breakpoints ();
1149   generic_mourn_inferior ();
1150   delete_thread_silent (sim_data->remote_sim_ptid);
1151 }
1152
1153 /* Pass the command argument through to the simulator verbatim.  The
1154    simulator must do any command interpretation work.  */
1155
1156 void
1157 simulator_command (char *args, int from_tty)
1158 {
1159   struct sim_inferior_data *sim_data;
1160
1161   /* We use inferior_data() instead of get_sim_inferior_data() here in
1162      order to avoid attaching a sim_inferior_data struct to an
1163      inferior unnecessarily.  The reason we take such care here is due
1164      to the fact that this function, simulator_command(), may be called
1165      even when the sim target is not active.  If we were to use
1166      get_sim_inferior_data() here, it is possible that this call would
1167      be made either prior to gdbsim_open() or after gdbsim_close(),
1168      thus allocating memory that would not be garbage collected until
1169      the ultimate destruction of the associated inferior.  */
1170
1171   sim_data  = inferior_data (current_inferior (), sim_inferior_data_key);
1172   if (sim_data == NULL || sim_data->gdbsim_desc == NULL)
1173     {
1174
1175       /* PREVIOUSLY: The user may give a command before the simulator
1176          is opened. [...] (??? assuming of course one wishes to
1177          continue to allow commands to be sent to unopened simulators,
1178          which isn't entirely unreasonable).  */
1179
1180       /* The simulator is a builtin abstraction of a remote target.
1181          Consistent with that model, access to the simulator, via sim
1182          commands, is restricted to the period when the channel to the
1183          simulator is open.  */
1184
1185       error (_("Not connected to the simulator target"));
1186     }
1187
1188   sim_do_command (sim_data->gdbsim_desc, args);
1189
1190   /* Invalidate the register cache, in case the simulator command does
1191      something funny.  */
1192   registers_changed ();
1193 }
1194
1195 static VEC (char_ptr) *
1196 sim_command_completer (struct cmd_list_element *ignore, char *text, char *word)
1197 {
1198   struct sim_inferior_data *sim_data;
1199   char **tmp;
1200   int i;
1201   VEC (char_ptr) *result = NULL;
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   tmp = sim_complete_command (sim_data->gdbsim_desc, text, word);
1208   if (tmp == NULL)
1209     return NULL;
1210
1211   /* Transform the array into a VEC, and then free the array.  */
1212   for (i = 0; tmp[i] != NULL; i++)
1213     VEC_safe_push (char_ptr, result, tmp[i]);
1214   xfree (tmp);
1215
1216   return result;
1217 }
1218
1219 /* Check to see if a thread is still alive.  */
1220
1221 static int
1222 gdbsim_thread_alive (struct target_ops *ops, ptid_t ptid)
1223 {
1224   struct sim_inferior_data *sim_data
1225     = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NOT_NEEDED);
1226
1227   if (sim_data == NULL)
1228     return 0;
1229
1230   if (ptid_equal (ptid, sim_data->remote_sim_ptid))
1231     /* The simulators' task is always alive.  */
1232     return 1;
1233
1234   return 0;
1235 }
1236
1237 /* Convert a thread ID to a string.  Returns the string in a static
1238    buffer.  */
1239
1240 static char *
1241 gdbsim_pid_to_str (struct target_ops *ops, ptid_t ptid)
1242 {
1243   return normal_pid_to_str (ptid);
1244 }
1245
1246 /* Simulator memory may be accessed after the program has been loaded.  */
1247
1248 static int
1249 gdbsim_has_all_memory (struct target_ops *ops)
1250 {
1251   struct sim_inferior_data *sim_data
1252     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1253
1254   if (!sim_data->program_loaded)
1255     return 0;
1256
1257   return 1;
1258 }
1259
1260 static int
1261 gdbsim_has_memory (struct target_ops *ops)
1262 {
1263   struct sim_inferior_data *sim_data
1264     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1265
1266   if (!sim_data->program_loaded)
1267     return 0;
1268
1269   return 1;
1270 }
1271
1272 /* Define the target subroutine names.  */
1273
1274 struct target_ops gdbsim_ops;
1275
1276 static void
1277 init_gdbsim_ops (void)
1278 {
1279   gdbsim_ops.to_shortname = "sim";
1280   gdbsim_ops.to_longname = "simulator";
1281   gdbsim_ops.to_doc = "Use the compiled-in simulator.";
1282   gdbsim_ops.to_open = gdbsim_open;
1283   gdbsim_ops.to_close = gdbsim_close;
1284   gdbsim_ops.to_detach = gdbsim_detach;
1285   gdbsim_ops.to_resume = gdbsim_resume;
1286   gdbsim_ops.to_wait = gdbsim_wait;
1287   gdbsim_ops.to_fetch_registers = gdbsim_fetch_register;
1288   gdbsim_ops.to_store_registers = gdbsim_store_register;
1289   gdbsim_ops.to_prepare_to_store = gdbsim_prepare_to_store;
1290   gdbsim_ops.deprecated_xfer_memory = gdbsim_xfer_inferior_memory;
1291   gdbsim_ops.to_files_info = gdbsim_files_info;
1292   gdbsim_ops.to_insert_breakpoint = memory_insert_breakpoint;
1293   gdbsim_ops.to_remove_breakpoint = memory_remove_breakpoint;
1294   gdbsim_ops.to_kill = gdbsim_kill;
1295   gdbsim_ops.to_load = gdbsim_load;
1296   gdbsim_ops.to_create_inferior = gdbsim_create_inferior;
1297   gdbsim_ops.to_mourn_inferior = gdbsim_mourn_inferior;
1298   gdbsim_ops.to_stop = gdbsim_stop;
1299   gdbsim_ops.to_thread_alive = gdbsim_thread_alive;
1300   gdbsim_ops.to_pid_to_str = gdbsim_pid_to_str;
1301   gdbsim_ops.to_stratum = process_stratum;
1302   gdbsim_ops.to_has_all_memory = gdbsim_has_all_memory;
1303   gdbsim_ops.to_has_memory = gdbsim_has_memory;
1304   gdbsim_ops.to_has_stack = default_child_has_stack;
1305   gdbsim_ops.to_has_registers = default_child_has_registers;
1306   gdbsim_ops.to_has_execution = default_child_has_execution;
1307   gdbsim_ops.to_magic = OPS_MAGIC;
1308 }
1309
1310 void
1311 _initialize_remote_sim (void)
1312 {
1313   struct cmd_list_element *c;
1314
1315   init_gdbsim_ops ();
1316   add_target (&gdbsim_ops);
1317
1318   c = add_com ("sim", class_obscure, simulator_command,
1319                _("Send a command to the simulator."));
1320   set_cmd_completer (c, sim_command_completer);
1321
1322   sim_inferior_data_key
1323     = register_inferior_data_with_cleanup (NULL, sim_inferior_data_cleanup);
1324 }