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