gdb/remote-sim.c

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