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