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