gdb/remote-sim.c

   1 /* Generic remote debugging interface for simulators.
   2
   3    Copyright (C) 1993-2013 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 (gdb_byte *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 (void);
  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 (gdb_byte *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         gdb_byte 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         gdb_byte 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       gdb_byte 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 (!have_inferiors ())
 644     init_thread_list ();
 645
 646   if (sim_create_inferior (sim_data->gdbsim_desc, exec_bfd, argv, env)
 647       != SIM_RC_OK)
 648     error (_("Unable to create sim inferior."));
 649
 650   inferior_ptid = sim_data->remote_sim_ptid;
 651   inferior_appeared (current_inferior (), ptid_get_pid (inferior_ptid));
 652   add_thread_silent (inferior_ptid);
 653
 654   insert_breakpoints ();        /* Needed to get correct instruction
 655                                    in cache.  */
 656
 657   clear_proceed_status ();
 658 }
 659
 660 /* The open routine takes the rest of the parameters from the command,
 661    and (if successful) pushes a new target onto the stack.
 662    Targets should supply this routine, if only to provide an error message.  */
 663 /* Called when selecting the simulator.  E.g. (gdb) target sim name.  */
 664
 665 static void
 666 gdbsim_open (char *args, int from_tty)
 667 {
 668   int len;
 669   char *arg_buf;
 670   struct sim_inferior_data *sim_data;
 671   SIM_DESC gdbsim_desc;
 672
 673   if (remote_debug)
 674     printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
 675
 676   /* Ensure that the sim target is not on the target stack.  This is
 677      necessary, because if it is on the target stack, the call to
 678      push_target below will invoke sim_close(), thus freeing various
 679      state (including a sim instance) that we allocate prior to
 680      invoking push_target().  We want to delay the push_target()
 681      operation until after we complete those operations which could
 682      error out.  */
 683   if (gdbsim_is_open)
 684     unpush_target (&gdbsim_ops);
 685
 686   len = (7 + 1                  /* gdbsim */
 687          + strlen (" -E little")
 688          + strlen (" --architecture=xxxxxxxxxx")
 689          + strlen (" --sysroot=") + strlen (gdb_sysroot) +
 690          + (args ? strlen (args) : 0)
 691          + 50) /* slack */ ;
 692   arg_buf = (char *) alloca (len);
 693   strcpy (arg_buf, "gdbsim");   /* 7 */
 694   /* Specify the byte order for the target when it is explicitly
 695      specified by the user (not auto detected).  */
 696   switch (selected_byte_order ())
 697     {
 698     case BFD_ENDIAN_BIG:
 699       strcat (arg_buf, " -E big");
 700       break;
 701     case BFD_ENDIAN_LITTLE:
 702       strcat (arg_buf, " -E little");
 703       break;
 704     case BFD_ENDIAN_UNKNOWN:
 705       break;
 706     }
 707   /* Specify the architecture of the target when it has been
 708      explicitly specified */
 709   if (selected_architecture_name () != NULL)
 710     {
 711       strcat (arg_buf, " --architecture=");
 712       strcat (arg_buf, selected_architecture_name ());
 713     }
 714   /* Pass along gdb's concept of the sysroot.  */
 715   strcat (arg_buf, " --sysroot=");
 716   strcat (arg_buf, gdb_sysroot);
 717   /* finally, any explicit args */
 718   if (args)
 719     {
 720       strcat (arg_buf, " ");    /* 1 */
 721       strcat (arg_buf, args);
 722     }
 723   sim_argv = gdb_buildargv (arg_buf);
 724
 725   init_callbacks ();
 726   gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, sim_argv);
 727
 728   if (gdbsim_desc == 0)
 729     {
 730       freeargv (sim_argv);
 731       sim_argv = NULL;
 732       error (_("unable to create simulator instance"));
 733     }
 734
 735   /* Reset the pid numberings for this batch of sim instances.  */
 736   next_pid = INITIAL_PID;
 737
 738   /* Allocate the inferior data, but do not allocate a sim instance
 739      since we've already just done that.  */
 740   sim_data = get_sim_inferior_data (current_inferior (),
 741                                     SIM_INSTANCE_NOT_NEEDED);
 742
 743   sim_data->gdbsim_desc = gdbsim_desc;
 744
 745   push_target (&gdbsim_ops);
 746   printf_filtered ("Connected to the simulator.\n");
 747
 748   /* There's nothing running after "target sim" or "load"; not until
 749      "run".  */
 750   inferior_ptid = null_ptid;
 751
 752   gdbsim_is_open = 1;
 753 }
 754
 755 /* Callback for iterate_over_inferiors.  Called (indirectly) by
 756    gdbsim_close().  */
 757
 758 static int
 759 gdbsim_close_inferior (struct inferior *inf, void *arg)
 760 {
 761   struct sim_inferior_data *sim_data = inferior_data (inf,
 762                                                       sim_inferior_data_key);
 763   if (sim_data != NULL)
 764     {
 765       ptid_t ptid = sim_data->remote_sim_ptid;
 766
 767       sim_inferior_data_cleanup (inf, sim_data);
 768       set_inferior_data (inf, sim_inferior_data_key, NULL);
 769
 770       /* Having a ptid allocated and stored in remote_sim_ptid does
 771          not mean that a corresponding inferior was ever created.
 772          Thus we need to verify the existence of an inferior using the
 773          pid in question before setting inferior_ptid via
 774          switch_to_thread() or mourning the inferior.  */
 775       if (find_inferior_pid (ptid_get_pid (ptid)) != NULL)
 776         {
 777           switch_to_thread (ptid);
 778           generic_mourn_inferior ();
 779         }
 780     }
 781
 782   return 0;
 783 }
 784
 785 /* Close out all files and local state before this target loses control.  */
 786
 787 static void
 788 gdbsim_close (void)
 789 {
 790   struct sim_inferior_data *sim_data
 791     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
 792
 793   if (remote_debug)
 794     printf_filtered ("gdbsim_close\n");
 795
 796   iterate_over_inferiors (gdbsim_close_inferior, NULL);
 797
 798   if (sim_argv != NULL)
 799     {
 800       freeargv (sim_argv);
 801       sim_argv = NULL;
 802     }
 803
 804   end_callbacks ();
 805
 806   gdbsim_is_open = 0;
 807 }
 808
 809 /* Takes a program previously attached to and detaches it.
 810    The program may resume execution (some targets do, some don't) and will
 811    no longer stop on signals, etc.  We better not have left any breakpoints
 812    in the program or it'll die when it hits one.  ARGS is arguments
 813    typed by the user (e.g. a signal to send the process).  FROM_TTY
 814    says whether to be verbose or not.  */
 815 /* Terminate the open connection to the remote debugger.
 816    Use this when you want to detach and do something else with your gdb.  */
 817
 818 static void
 819 gdbsim_detach (struct target_ops *ops, char *args, int from_tty)
 820 {
 821   if (remote_debug)
 822     printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
 823
 824   pop_target ();                /* calls gdbsim_close to do the real work */
 825   if (from_tty)
 826     printf_filtered ("Ending simulator %s debugging\n", target_shortname);
 827 }
 828
 829 /* Resume execution of the target process.  STEP says whether to single-step
 830    or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
 831    to the target, or zero for no signal.  */
 832
 833 struct resume_data
 834 {
 835   enum gdb_signal siggnal;
 836   int step;
 837 };
 838
 839 static int
 840 gdbsim_resume_inferior (struct inferior *inf, void *arg)
 841 {
 842   struct sim_inferior_data *sim_data
 843     = get_sim_inferior_data (inf, SIM_INSTANCE_NOT_NEEDED);
 844   struct resume_data *rd = arg;
 845
 846   if (sim_data)
 847     {
 848       sim_data->resume_siggnal = rd->siggnal;
 849       sim_data->resume_step = rd->step;
 850
 851       if (remote_debug)
 852         printf_filtered (_("gdbsim_resume: pid %d, step %d, signal %d\n"),
 853                          inf->pid, rd->step, rd->siggnal);
 854     }
 855
 856   /* When called from iterate_over_inferiors, a zero return causes the
 857      iteration process to proceed until there are no more inferiors to
 858      consider.  */
 859   return 0;
 860 }
 861
 862 static void
 863 gdbsim_resume (struct target_ops *ops,
 864                ptid_t ptid, int step, enum gdb_signal siggnal)
 865 {
 866   struct resume_data rd;
 867   struct sim_inferior_data *sim_data
 868     = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NOT_NEEDED);
 869
 870   rd.siggnal = siggnal;
 871   rd.step = step;
 872
 873   /* We don't access any sim_data members within this function.
 874      What's of interest is whether or not the call to
 875      get_sim_inferior_data_by_ptid(), above, is able to obtain a
 876      non-NULL pointer.  If it managed to obtain a non-NULL pointer, we
 877      know we have a single inferior to consider.  If it's NULL, we
 878      either have multiple inferiors to resume or an error condition.  */
 879
 880   if (sim_data)
 881     gdbsim_resume_inferior (find_inferior_pid (ptid_get_pid (ptid)), &rd);
 882   else if (ptid_equal (ptid, minus_one_ptid))
 883     iterate_over_inferiors (gdbsim_resume_inferior, &rd);
 884   else
 885     error (_("The program is not being run."));
 886 }
 887
 888 /* Notify the simulator of an asynchronous request to stop.
 889
 890    The simulator shall ensure that the stop request is eventually
 891    delivered to the simulator.  If the call is made while the
 892    simulator is not running then the stop request is processed when
 893    the simulator is next resumed.
 894
 895    For simulators that do not support this operation, just abort.  */
 896
 897 static int
 898 gdbsim_stop_inferior (struct inferior *inf, void *arg)
 899 {
 900   struct sim_inferior_data *sim_data
 901     = get_sim_inferior_data (inf, SIM_INSTANCE_NEEDED);
 902
 903   if (sim_data)
 904     {
 905       if (!sim_stop (sim_data->gdbsim_desc))
 906         {
 907           quit ();
 908         }
 909     }
 910
 911   /* When called from iterate_over_inferiors, a zero return causes the
 912      iteration process to proceed until there are no more inferiors to
 913      consider.  */
 914   return 0;
 915 }
 916
 917 static void
 918 gdbsim_stop (ptid_t ptid)
 919 {
 920   struct sim_inferior_data *sim_data;
 921
 922   if (ptid_equal (ptid, minus_one_ptid))
 923     {
 924       iterate_over_inferiors (gdbsim_stop_inferior, NULL);
 925     }
 926   else
 927     {
 928       struct inferior *inf = find_inferior_pid (ptid_get_pid (ptid));
 929
 930       if (inf == NULL)
 931         error (_("Can't stop pid %d.  No inferior found."),
 932                ptid_get_pid (ptid));
 933
 934       gdbsim_stop_inferior (inf, NULL);
 935     }
 936 }
 937
 938 /* GDB version of os_poll_quit callback.
 939    Taken from gdb/util.c - should be in a library.  */
 940
 941 static int
 942 gdb_os_poll_quit (host_callback *p)
 943 {
 944   if (deprecated_ui_loop_hook != NULL)
 945     deprecated_ui_loop_hook (0);
 946
 947   if (check_quit_flag ())       /* gdb's idea of quit */
 948     {
 949       clear_quit_flag ();       /* we've stolen it */
 950       return 1;
 951     }
 952   return 0;
 953 }
 954
 955 /* Wait for inferior process to do something.  Return pid of child,
 956    or -1 in case of error; store status through argument pointer STATUS,
 957    just as `wait' would.  */
 958
 959 static void
 960 gdbsim_cntrl_c (int signo)
 961 {
 962   gdbsim_stop (minus_one_ptid);
 963 }
 964
 965 static ptid_t
 966 gdbsim_wait (struct target_ops *ops,
 967              ptid_t ptid, struct target_waitstatus *status, int options)
 968 {
 969   struct sim_inferior_data *sim_data;
 970   static RETSIGTYPE (*prev_sigint) ();
 971   int sigrc = 0;
 972   enum sim_stop reason = sim_running;
 973
 974   /* This target isn't able to (yet) resume more than one inferior at a time.
 975      When ptid is minus_one_ptid, just use the current inferior.  If we're
 976      given an explicit pid, we'll try to find it and use that instead.  */
 977   if (ptid_equal (ptid, minus_one_ptid))
 978     sim_data = get_sim_inferior_data (current_inferior (),
 979                                       SIM_INSTANCE_NEEDED);
 980   else
 981     {
 982       sim_data = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NEEDED);
 983       if (sim_data == NULL)
 984         error (_("Unable to wait for pid %d.  Inferior not found."),
 985                ptid_get_pid (ptid));
 986       inferior_ptid = ptid;
 987     }
 988
 989   if (remote_debug)
 990     printf_filtered ("gdbsim_wait\n");
 991
 992 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
 993   {
 994     struct sigaction sa, osa;
 995     sa.sa_handler = gdbsim_cntrl_c;
 996     sigemptyset (&sa.sa_mask);
 997     sa.sa_flags = 0;
 998     sigaction (SIGINT, &sa, &osa);
 999     prev_sigint = osa.sa_handler;
1000   }
1001 #else
1002   prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
1003 #endif
1004   sim_resume (sim_data->gdbsim_desc, sim_data->resume_step,
1005               sim_data->resume_siggnal);
1006
1007   signal (SIGINT, prev_sigint);
1008   sim_data->resume_step = 0;
1009
1010   sim_stop_reason (sim_data->gdbsim_desc, &reason, &sigrc);
1011
1012   switch (reason)
1013     {
1014     case sim_exited:
1015       status->kind = TARGET_WAITKIND_EXITED;
1016       status->value.integer = sigrc;
1017       break;
1018     case sim_stopped:
1019       switch (sigrc)
1020         {
1021         case GDB_SIGNAL_ABRT:
1022           quit ();
1023           break;
1024         case GDB_SIGNAL_INT:
1025         case GDB_SIGNAL_TRAP:
1026         default:
1027           status->kind = TARGET_WAITKIND_STOPPED;
1028           status->value.sig = sigrc;
1029           break;
1030         }
1031       break;
1032     case sim_signalled:
1033       status->kind = TARGET_WAITKIND_SIGNALLED;
1034       status->value.sig = sigrc;
1035       break;
1036     case sim_running:
1037     case sim_polling:
1038       /* FIXME: Is this correct?  */
1039       break;
1040     }
1041
1042   return inferior_ptid;
1043 }
1044
1045 /* Get ready to modify the registers array.  On machines which store
1046    individual registers, this doesn't need to do anything.  On machines
1047    which store all the registers in one fell swoop, this makes sure
1048    that registers contains all the registers from the program being
1049    debugged.  */
1050
1051 static void
1052 gdbsim_prepare_to_store (struct regcache *regcache)
1053 {
1054   /* Do nothing, since we can store individual regs.  */
1055 }
1056
1057 /* Transfer LEN bytes between GDB address MYADDR and target address
1058    MEMADDR.  If WRITE is non-zero, transfer them to the target,
1059    otherwise transfer them from the target.  TARGET is unused.
1060
1061    Returns the number of bytes transferred.  */
1062
1063 static int
1064 gdbsim_xfer_inferior_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
1065                              int write, struct mem_attrib *attrib,
1066                              struct target_ops *target)
1067 {
1068   struct sim_inferior_data *sim_data
1069     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1070
1071   /* If this target doesn't have memory yet, return 0 causing the
1072      request to be passed to a lower target, hopefully an exec
1073      file.  */
1074   if (!target->to_has_memory (target))
1075     return 0;
1076
1077   if (!sim_data->program_loaded)
1078     error (_("No program loaded."));
1079
1080   /* Note that we obtained the sim_data pointer above using
1081      SIM_INSTANCE_NOT_NEEDED.  We do this so that we don't needlessly
1082      allocate a sim instance prior to loading a program.   If we
1083      get to this point in the code though, gdbsim_desc should be
1084      non-NULL.  (Note that a sim instance is needed in order to load
1085      the program...)  */
1086   gdb_assert (sim_data->gdbsim_desc != NULL);
1087
1088   if (remote_debug)
1089     {
1090       /* FIXME: Send to something other than STDOUT?  */
1091       printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x");
1092       gdb_print_host_address (myaddr, gdb_stdout);
1093       printf_filtered (", memaddr %s, len %d, write %d\n",
1094                        paddress (target_gdbarch (), memaddr), len, write);
1095       if (remote_debug && write)
1096         dump_mem (myaddr, len);
1097     }
1098
1099   if (write)
1100     {
1101       len = sim_write (sim_data->gdbsim_desc, memaddr, myaddr, len);
1102     }
1103   else
1104     {
1105       len = sim_read (sim_data->gdbsim_desc, memaddr, myaddr, len);
1106       if (remote_debug && len > 0)
1107         dump_mem (myaddr, len);
1108     }
1109   return len;
1110 }
1111
1112 static void
1113 gdbsim_files_info (struct target_ops *target)
1114 {
1115   struct sim_inferior_data *sim_data
1116     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
1117   const char *file = "nothing";
1118
1119   if (exec_bfd)
1120     file = bfd_get_filename (exec_bfd);
1121
1122   if (remote_debug)
1123     printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
1124
1125   if (exec_bfd)
1126     {
1127       printf_filtered ("\tAttached to %s running program %s\n",
1128                        target_shortname, file);
1129       sim_info (sim_data->gdbsim_desc, 0);
1130     }
1131 }
1132
1133 /* Clear the simulator's notion of what the break points are.  */
1134
1135 static void
1136 gdbsim_mourn_inferior (struct target_ops *target)
1137 {
1138   struct sim_inferior_data *sim_data
1139     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1140
1141   if (remote_debug)
1142     printf_filtered ("gdbsim_mourn_inferior:\n");
1143
1144   remove_breakpoints ();
1145   generic_mourn_inferior ();
1146   delete_thread_silent (sim_data->remote_sim_ptid);
1147 }
1148
1149 /* Pass the command argument through to the simulator verbatim.  The
1150    simulator must do any command interpretation work.  */
1151
1152 void
1153 simulator_command (char *args, int from_tty)
1154 {
1155   struct sim_inferior_data *sim_data;
1156
1157   /* We use inferior_data() instead of get_sim_inferior_data() here in
1158      order to avoid attaching a sim_inferior_data struct to an
1159      inferior unnecessarily.  The reason we take such care here is due
1160      to the fact that this function, simulator_command(), may be called
1161      even when the sim target is not active.  If we were to use
1162      get_sim_inferior_data() here, it is possible that this call would
1163      be made either prior to gdbsim_open() or after gdbsim_close(),
1164      thus allocating memory that would not be garbage collected until
1165      the ultimate destruction of the associated inferior.  */
1166
1167   sim_data  = inferior_data (current_inferior (), sim_inferior_data_key);
1168   if (sim_data == NULL || sim_data->gdbsim_desc == NULL)
1169     {
1170
1171       /* PREVIOUSLY: The user may give a command before the simulator
1172          is opened. [...] (??? assuming of course one wishes to
1173          continue to allow commands to be sent to unopened simulators,
1174          which isn't entirely unreasonable).  */
1175
1176       /* The simulator is a builtin abstraction of a remote target.
1177          Consistent with that model, access to the simulator, via sim
1178          commands, is restricted to the period when the channel to the
1179          simulator is open.  */
1180
1181       error (_("Not connected to the simulator target"));
1182     }
1183
1184   sim_do_command (sim_data->gdbsim_desc, args);
1185
1186   /* Invalidate the register cache, in case the simulator command does
1187      something funny.  */
1188   registers_changed ();
1189 }
1190
1191 static VEC (char_ptr) *
1192 sim_command_completer (struct cmd_list_element *ignore, const char *text,
1193                        const char *word)
1194 {
1195   struct sim_inferior_data *sim_data;
1196   char **tmp;
1197   int i;
1198   VEC (char_ptr) *result = NULL;
1199
1200   sim_data = inferior_data (current_inferior (), sim_inferior_data_key);
1201   if (sim_data == NULL || sim_data->gdbsim_desc == NULL)
1202     return NULL;
1203
1204   tmp = sim_complete_command (sim_data->gdbsim_desc, text, word);
1205   if (tmp == NULL)
1206     return NULL;
1207
1208   /* Transform the array into a VEC, and then free the array.  */
1209   for (i = 0; tmp[i] != NULL; i++)
1210     VEC_safe_push (char_ptr, result, tmp[i]);
1211   xfree (tmp);
1212
1213   return result;
1214 }
1215
1216 /* Check to see if a thread is still alive.  */
1217
1218 static int
1219 gdbsim_thread_alive (struct target_ops *ops, ptid_t ptid)
1220 {
1221   struct sim_inferior_data *sim_data
1222     = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NOT_NEEDED);
1223
1224   if (sim_data == NULL)
1225     return 0;
1226
1227   if (ptid_equal (ptid, sim_data->remote_sim_ptid))
1228     /* The simulators' task is always alive.  */
1229     return 1;
1230
1231   return 0;
1232 }
1233
1234 /* Convert a thread ID to a string.  Returns the string in a static
1235    buffer.  */
1236
1237 static char *
1238 gdbsim_pid_to_str (struct target_ops *ops, ptid_t ptid)
1239 {
1240   return normal_pid_to_str (ptid);
1241 }
1242
1243 /* Simulator memory may be accessed after the program has been loaded.  */
1244
1245 static int
1246 gdbsim_has_all_memory (struct target_ops *ops)
1247 {
1248   struct sim_inferior_data *sim_data
1249     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1250
1251   if (!sim_data->program_loaded)
1252     return 0;
1253
1254   return 1;
1255 }
1256
1257 static int
1258 gdbsim_has_memory (struct target_ops *ops)
1259 {
1260   struct sim_inferior_data *sim_data
1261     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1262
1263   if (!sim_data->program_loaded)
1264     return 0;
1265
1266   return 1;
1267 }
1268
1269 /* Define the target subroutine names.  */
1270
1271 struct target_ops gdbsim_ops;
1272
1273 static void
1274 init_gdbsim_ops (void)
1275 {
1276   gdbsim_ops.to_shortname = "sim";
1277   gdbsim_ops.to_longname = "simulator";
1278   gdbsim_ops.to_doc = "Use the compiled-in simulator.";
1279   gdbsim_ops.to_open = gdbsim_open;
1280   gdbsim_ops.to_close = gdbsim_close;
1281   gdbsim_ops.to_detach = gdbsim_detach;
1282   gdbsim_ops.to_resume = gdbsim_resume;
1283   gdbsim_ops.to_wait = gdbsim_wait;
1284   gdbsim_ops.to_fetch_registers = gdbsim_fetch_register;
1285   gdbsim_ops.to_store_registers = gdbsim_store_register;
1286   gdbsim_ops.to_prepare_to_store = gdbsim_prepare_to_store;
1287   gdbsim_ops.deprecated_xfer_memory = gdbsim_xfer_inferior_memory;
1288   gdbsim_ops.to_files_info = gdbsim_files_info;
1289   gdbsim_ops.to_insert_breakpoint = memory_insert_breakpoint;
1290   gdbsim_ops.to_remove_breakpoint = memory_remove_breakpoint;
1291   gdbsim_ops.to_kill = gdbsim_kill;
1292   gdbsim_ops.to_load = gdbsim_load;
1293   gdbsim_ops.to_create_inferior = gdbsim_create_inferior;
1294   gdbsim_ops.to_mourn_inferior = gdbsim_mourn_inferior;
1295   gdbsim_ops.to_stop = gdbsim_stop;
1296   gdbsim_ops.to_thread_alive = gdbsim_thread_alive;
1297   gdbsim_ops.to_pid_to_str = gdbsim_pid_to_str;
1298   gdbsim_ops.to_stratum = process_stratum;
1299   gdbsim_ops.to_has_all_memory = gdbsim_has_all_memory;
1300   gdbsim_ops.to_has_memory = gdbsim_has_memory;
1301   gdbsim_ops.to_has_stack = default_child_has_stack;
1302   gdbsim_ops.to_has_registers = default_child_has_registers;
1303   gdbsim_ops.to_has_execution = default_child_has_execution;
1304   gdbsim_ops.to_magic = OPS_MAGIC;
1305 }
1306
1307 void
1308 _initialize_remote_sim (void)
1309 {
1310   struct cmd_list_element *c;
1311
1312   init_gdbsim_ops ();
1313   add_target (&gdbsim_ops);
1314
1315   c = add_com ("sim", class_obscure, simulator_command,
1316                _("Send a command to the simulator."));
1317   set_cmd_completer (c, sim_command_completer);
1318
1319   sim_inferior_data_key
1320     = register_inferior_data_with_cleanup (NULL, sim_inferior_data_cleanup);
1321 }