gdb: sim: handle target sysroot prefix
[external/binutils.git] / gdb / remote-sim.c
1 /* Generic remote debugging interface for simulators.
2
3    Copyright (C) 1993-2015 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
44 /* Prototypes */
45
46 extern void _initialize_remote_sim (void);
47
48 static void init_callbacks (void);
49
50 static void end_callbacks (void);
51
52 static int gdb_os_write_stdout (host_callback *, const char *, int);
53
54 static void gdb_os_flush_stdout (host_callback *);
55
56 static int gdb_os_write_stderr (host_callback *, const char *, int);
57
58 static void gdb_os_flush_stderr (host_callback *);
59
60 static int gdb_os_poll_quit (host_callback *);
61
62 /* printf_filtered is depreciated.  */
63 static void gdb_os_printf_filtered (host_callback *, const char *, ...);
64
65 static void gdb_os_vprintf_filtered (host_callback *, const char *, va_list);
66
67 static void gdb_os_evprintf_filtered (host_callback *, const char *, va_list);
68
69 static void gdb_os_error (host_callback *, const char *, ...)
70      ATTRIBUTE_NORETURN;
71
72 static void gdbsim_kill (struct target_ops *);
73
74 static void gdbsim_load (struct target_ops *self, const char *prog,
75                          int fromtty);
76
77 static void gdbsim_open (const char *args, int from_tty);
78
79 static void gdbsim_close (struct target_ops *self);
80
81 static void gdbsim_detach (struct target_ops *ops, const char *args,
82                            int from_tty);
83
84 static void gdbsim_prepare_to_store (struct target_ops *self,
85                                      struct regcache *regcache);
86
87 static void gdbsim_files_info (struct target_ops *target);
88
89 static void gdbsim_mourn_inferior (struct target_ops *target);
90
91 static void gdbsim_stop (struct target_ops *self, ptid_t ptid);
92
93 void simulator_command (char *args, int from_tty);
94
95 /* Naming convention:
96
97    sim_* are the interface to the simulator (see remote-sim.h).
98    gdbsim_* are stuff which is internal to gdb.  */
99
100 /* Forward data declarations */
101 extern struct target_ops gdbsim_ops;
102
103 static const struct inferior_data *sim_inferior_data_key;
104
105 /* Simulator-specific, per-inferior state.  */
106 struct sim_inferior_data {
107   /* Flag which indicates whether or not the program has been loaded.  */
108   int program_loaded;
109
110   /* Simulator descriptor for this inferior.  */
111   SIM_DESC gdbsim_desc;
112
113   /* This is the ptid we use for this particular simulator instance.  Its
114      value is somewhat arbitrary, as the simulator target don't have a
115      notion of tasks or threads, but we need something non-null to place
116      in inferior_ptid.  For simulators which permit multiple instances,
117      we also need a unique identifier to use for each inferior.  */
118   ptid_t remote_sim_ptid;
119
120   /* Signal with which to resume.  */
121   enum gdb_signal resume_siggnal;
122
123   /* Flag which indicates whether resume should step or not.  */
124   int resume_step;
125 };
126
127 /* Flag indicating the "open" status of this module.  It's set to 1
128    in gdbsim_open() and 0 in gdbsim_close().  */
129 static int gdbsim_is_open = 0;
130
131 /* Value of the next pid to allocate for an inferior.  As indicated
132    elsewhere, its initial value is somewhat arbitrary; it's critical
133    though that it's not zero or negative.  */
134 static int next_pid;
135 #define INITIAL_PID 42000
136
137 /* Argument list to pass to sim_open().  It is allocated in gdbsim_open()
138    and deallocated in gdbsim_close().  The lifetime needs to extend beyond
139    the call to gdbsim_open() due to the fact that other sim instances other
140    than the first will be allocated after the gdbsim_open() call.  */
141 static char **sim_argv = NULL;
142
143 /* OS-level callback functions for write, flush, etc.  */
144 static host_callback gdb_callback;
145 static int callbacks_initialized = 0;
146
147 /* Callback for iterate_over_inferiors.  It checks to see if the sim
148    descriptor passed via ARG is the same as that for the inferior
149    designated by INF.  Return true if so; false otherwise.  */
150
151 static int
152 check_for_duplicate_sim_descriptor (struct inferior *inf, void *arg)
153 {
154   struct sim_inferior_data *sim_data;
155   SIM_DESC new_sim_desc = arg;
156
157   sim_data = inferior_data (inf, sim_inferior_data_key);
158
159   return (sim_data != NULL && sim_data->gdbsim_desc == new_sim_desc);
160 }
161
162 /* Flags indicating whether or not a sim instance is needed.  One of these
163    flags should be passed to get_sim_inferior_data().  */
164
165 enum {SIM_INSTANCE_NOT_NEEDED = 0, SIM_INSTANCE_NEEDED = 1};
166
167 /* Obtain pointer to per-inferior simulator data, allocating it if necessary.
168    Attempt to open the sim if SIM_INSTANCE_NEEDED is true.  */
169
170 static struct sim_inferior_data *
171 get_sim_inferior_data (struct inferior *inf, int sim_instance_needed)
172 {
173   SIM_DESC sim_desc = NULL;
174   struct sim_inferior_data *sim_data
175     = inferior_data (inf, sim_inferior_data_key);
176
177   /* Try to allocate a new sim instance, if needed.  We do this ahead of
178      a potential allocation of a sim_inferior_data struct in order to
179      avoid needlessly allocating that struct in the event that the sim
180      instance allocation fails.  */
181   if (sim_instance_needed == SIM_INSTANCE_NEEDED
182       && (sim_data == NULL || sim_data->gdbsim_desc == NULL))
183     {
184       struct inferior *idup;
185       sim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, sim_argv);
186       if (sim_desc == NULL)
187         error (_("Unable to create simulator instance for inferior %d."),
188                inf->num);
189
190       idup = iterate_over_inferiors (check_for_duplicate_sim_descriptor,
191                                      sim_desc);
192       if (idup != NULL)
193         {
194           /* We don't close the descriptor due to the fact that it's
195              shared with some other inferior.  If we were to close it,
196              that might needlessly muck up the other inferior.  Of
197              course, it's possible that the damage has already been
198              done...  Note that it *will* ultimately be closed during
199              cleanup of the other inferior.  */
200           sim_desc = NULL;
201           error (
202  _("Inferior %d and inferior %d would have identical simulator state.\n"
203    "(This simulator does not support the running of more than one inferior.)"),
204                  inf->num, idup->num);
205         }
206     }
207
208   if (sim_data == NULL)
209     {
210       sim_data = 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 = 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 = get_regcache_arch (regcache);
431   struct sim_inferior_data *sim_data
432     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
433
434   if (regno == -1)
435     {
436       for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
437         gdbsim_fetch_register (ops, regcache, regno);
438       return;
439     }
440
441   switch (gdbarch_register_sim_regno (gdbarch, regno))
442     {
443     case LEGACY_SIM_REGNO_IGNORE:
444       break;
445     case SIM_REGNO_DOES_NOT_EXIST:
446       {
447         /* For moment treat a `does not exist' register the same way
448            as an ``unavailable'' register.  */
449         gdb_byte buf[MAX_REGISTER_SIZE];
450         int nr_bytes;
451
452         memset (buf, 0, MAX_REGISTER_SIZE);
453         regcache_raw_supply (regcache, regno, buf);
454         break;
455       }
456
457     default:
458       {
459         static int warn_user = 1;
460         gdb_byte buf[MAX_REGISTER_SIZE];
461         int nr_bytes;
462
463         gdb_assert (regno >= 0 && regno < gdbarch_num_regs (gdbarch));
464         memset (buf, 0, MAX_REGISTER_SIZE);
465         nr_bytes = sim_fetch_register (sim_data->gdbsim_desc,
466                                        gdbarch_register_sim_regno
467                                          (gdbarch, regno),
468                                        buf,
469                                        register_size (gdbarch, regno));
470         if (nr_bytes > 0
471             && nr_bytes != register_size (gdbarch, regno) && warn_user)
472           {
473             fprintf_unfiltered (gdb_stderr,
474                                 "Size of register %s (%d/%d) "
475                                 "incorrect (%d instead of %d))",
476                                 gdbarch_register_name (gdbarch, regno),
477                                 regno,
478                                 gdbarch_register_sim_regno
479                                   (gdbarch, regno),
480                                 nr_bytes, register_size (gdbarch, regno));
481             warn_user = 0;
482           }
483         /* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0'
484            indicating that GDB and the SIM have different ideas about
485            which registers are fetchable.  */
486         /* Else if (nr_bytes < 0): an old simulator, that doesn't
487            think to return the register size.  Just assume all is ok.  */
488         regcache_raw_supply (regcache, regno, buf);
489         if (remote_debug)
490           {
491             fprintf_unfiltered (gdb_stdlog,
492                                 "gdbsim_fetch_register: %d", regno);
493             /* FIXME: We could print something more intelligible.  */
494             dump_mem (buf, register_size (gdbarch, regno));
495           }
496         break;
497       }
498     }
499 }
500
501
502 static void
503 gdbsim_store_register (struct target_ops *ops,
504                        struct regcache *regcache, int regno)
505 {
506   struct gdbarch *gdbarch = get_regcache_arch (regcache);
507   struct sim_inferior_data *sim_data
508     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
509
510   if (regno == -1)
511     {
512       for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
513         gdbsim_store_register (ops, regcache, regno);
514       return;
515     }
516   else if (gdbarch_register_sim_regno (gdbarch, regno) >= 0)
517     {
518       gdb_byte tmp[MAX_REGISTER_SIZE];
519       int nr_bytes;
520
521       regcache_cooked_read (regcache, regno, tmp);
522       nr_bytes = sim_store_register (sim_data->gdbsim_desc,
523                                      gdbarch_register_sim_regno
524                                        (gdbarch, regno),
525                                      tmp, register_size (gdbarch, regno));
526       if (nr_bytes > 0 && nr_bytes != register_size (gdbarch, regno))
527         internal_error (__FILE__, __LINE__,
528                         _("Register size different to expected"));
529       if (nr_bytes < 0)
530         internal_error (__FILE__, __LINE__,
531                         _("Register %d not updated"), regno);
532       if (nr_bytes == 0)
533         warning (_("Register %s not updated"),
534                  gdbarch_register_name (gdbarch, regno));
535
536       if (remote_debug)
537         {
538           fprintf_unfiltered (gdb_stdlog, "gdbsim_store_register: %d", regno);
539           /* FIXME: We could print something more intelligible.  */
540           dump_mem (tmp, register_size (gdbarch, regno));
541         }
542     }
543 }
544
545 /* Kill the running program.  This may involve closing any open files
546    and releasing other resources acquired by the simulated program.  */
547
548 static void
549 gdbsim_kill (struct target_ops *ops)
550 {
551   if (remote_debug)
552     fprintf_unfiltered (gdb_stdlog, "gdbsim_kill\n");
553
554   /* There is no need to `kill' running simulator - the simulator is
555      not running.  Mourning it is enough.  */
556   target_mourn_inferior ();
557 }
558
559 /* Load an executable file into the target process.  This is expected to
560    not only bring new code into the target process, but also to update
561    GDB's symbol tables to match.  */
562
563 static void
564 gdbsim_load (struct target_ops *self, const char *args, int fromtty)
565 {
566   char **argv;
567   const char *prog;
568   struct sim_inferior_data *sim_data
569     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
570
571   if (args == NULL)
572       error_no_arg (_("program to load"));
573
574   argv = gdb_buildargv (args);
575   make_cleanup_freeargv (argv);
576
577   prog = tilde_expand (argv[0]);
578
579   if (argv[1] != NULL)
580     error (_("GDB sim does not yet support a load offset."));
581
582   if (remote_debug)
583     fprintf_unfiltered (gdb_stdlog, "gdbsim_load: prog \"%s\"\n", prog);
584
585   /* FIXME: We will print two messages on error.
586      Need error to either not print anything if passed NULL or need
587      another routine that doesn't take any arguments.  */
588   if (sim_load (sim_data->gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL)
589     error (_("unable to load program"));
590
591   /* FIXME: If a load command should reset the targets registers then
592      a call to sim_create_inferior() should go here.  */
593
594   sim_data->program_loaded = 1;
595 }
596
597
598 /* Start an inferior process and set inferior_ptid to its pid.
599    EXEC_FILE is the file to run.
600    ARGS is a string containing the arguments to the program.
601    ENV is the environment vector to pass.  Errors reported with error().
602    On VxWorks and various standalone systems, we ignore exec_file.  */
603 /* This is called not only when we first attach, but also when the
604    user types "run" after having attached.  */
605
606 static void
607 gdbsim_create_inferior (struct target_ops *target, char *exec_file, char *args,
608                         char **env, int from_tty)
609 {
610   struct sim_inferior_data *sim_data
611     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
612   int len;
613   char *arg_buf, **argv;
614
615   if (exec_file == 0 || exec_bfd == 0)
616     warning (_("No executable file specified."));
617   if (!sim_data->program_loaded)
618     warning (_("No program loaded."));
619
620   if (remote_debug)
621     fprintf_unfiltered (gdb_stdlog,
622                         "gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
623                         (exec_file ? exec_file : "(NULL)"),
624                         args);
625
626   if (ptid_equal (inferior_ptid, sim_data->remote_sim_ptid))
627     gdbsim_kill (target);
628   remove_breakpoints ();
629   init_wait_for_inferior ();
630
631   if (exec_file != NULL)
632     {
633       len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop */ 10;
634       arg_buf = (char *) alloca (len);
635       arg_buf[0] = '\0';
636       strcat (arg_buf, exec_file);
637       strcat (arg_buf, " ");
638       strcat (arg_buf, args);
639       argv = gdb_buildargv (arg_buf);
640       make_cleanup_freeargv (argv);
641     }
642   else
643     argv = NULL;
644
645   if (!have_inferiors ())
646     init_thread_list ();
647
648   if (sim_create_inferior (sim_data->gdbsim_desc, exec_bfd, argv, env)
649       != SIM_RC_OK)
650     error (_("Unable to create sim inferior."));
651
652   inferior_ptid = sim_data->remote_sim_ptid;
653   inferior_appeared (current_inferior (), ptid_get_pid (inferior_ptid));
654   add_thread_silent (inferior_ptid);
655
656   insert_breakpoints ();        /* Needed to get correct instruction
657                                    in cache.  */
658
659   clear_proceed_status (0);
660 }
661
662 /* The open routine takes the rest of the parameters from the command,
663    and (if successful) pushes a new target onto the stack.
664    Targets should supply this routine, if only to provide an error message.  */
665 /* Called when selecting the simulator.  E.g. (gdb) target sim name.  */
666
667 static void
668 gdbsim_open (const char *args, int from_tty)
669 {
670   int len;
671   char *arg_buf;
672   struct sim_inferior_data *sim_data;
673   const char *sysroot = gdb_sysroot;
674   SIM_DESC gdbsim_desc;
675
676   if (remote_debug)
677     fprintf_unfiltered (gdb_stdlog,
678                         "gdbsim_open: args \"%s\"\n", args ? args : "(null)");
679
680   /* Ensure that the sim target is not on the target stack.  This is
681      necessary, because if it is on the target stack, the call to
682      push_target below will invoke sim_close(), thus freeing various
683      state (including a sim instance) that we allocate prior to
684      invoking push_target().  We want to delay the push_target()
685      operation until after we complete those operations which could
686      error out.  */
687   if (gdbsim_is_open)
688     unpush_target (&gdbsim_ops);
689
690   len = (7 + 1                  /* gdbsim */
691          + strlen (" -E little")
692          + strlen (" --architecture=xxxxxxxxxx")
693          + strlen (" --sysroot=") + strlen (sysroot) +
694          + (args ? strlen (args) : 0)
695          + 50) /* slack */ ;
696   arg_buf = (char *) alloca (len);
697   strcpy (arg_buf, "gdbsim");   /* 7 */
698   /* Specify the byte order for the target when it is explicitly
699      specified by the user (not auto detected).  */
700   switch (selected_byte_order ())
701     {
702     case BFD_ENDIAN_BIG:
703       strcat (arg_buf, " -E big");
704       break;
705     case BFD_ENDIAN_LITTLE:
706       strcat (arg_buf, " -E little");
707       break;
708     case BFD_ENDIAN_UNKNOWN:
709       break;
710     }
711   /* Specify the architecture of the target when it has been
712      explicitly specified */
713   if (selected_architecture_name () != NULL)
714     {
715       strcat (arg_buf, " --architecture=");
716       strcat (arg_buf, selected_architecture_name ());
717     }
718   /* Pass along gdb's concept of the sysroot.  */
719   strcat (arg_buf, " --sysroot=");
720   if (is_target_filename (sysroot))
721     sysroot += strlen (TARGET_SYSROOT_PREFIX);
722   strcat (arg_buf, sysroot);
723   /* finally, any explicit args */
724   if (args)
725     {
726       strcat (arg_buf, " ");    /* 1 */
727       strcat (arg_buf, args);
728     }
729   sim_argv = gdb_buildargv (arg_buf);
730
731   init_callbacks ();
732   gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, sim_argv);
733
734   if (gdbsim_desc == 0)
735     {
736       freeargv (sim_argv);
737       sim_argv = NULL;
738       error (_("unable to create simulator instance"));
739     }
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 = inferior_data (inf,
768                                                       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 = 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 stop.
896
897    The simulator shall ensure that the stop request is eventually
898    delivered to the simulator.  If the call is made while the
899    simulator is not running then the stop 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_stop_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_stop (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_stop_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_stop_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     {
956       clear_quit_flag ();       /* we've stolen it */
957       return 1;
958     }
959   return 0;
960 }
961
962 /* Wait for inferior process to do something.  Return pid of child,
963    or -1 in case of error; store status through argument pointer STATUS,
964    just as `wait' would.  */
965
966 static void
967 gdbsim_cntrl_c (int signo)
968 {
969   gdbsim_stop (NULL, minus_one_ptid);
970 }
971
972 static ptid_t
973 gdbsim_wait (struct target_ops *ops,
974              ptid_t ptid, struct target_waitstatus *status, int options)
975 {
976   struct sim_inferior_data *sim_data;
977   static RETSIGTYPE (*prev_sigint) ();
978   int sigrc = 0;
979   enum sim_stop reason = sim_running;
980
981   /* This target isn't able to (yet) resume more than one inferior at a time.
982      When ptid is minus_one_ptid, just use the current inferior.  If we're
983      given an explicit pid, we'll try to find it and use that instead.  */
984   if (ptid_equal (ptid, minus_one_ptid))
985     sim_data = get_sim_inferior_data (current_inferior (),
986                                       SIM_INSTANCE_NEEDED);
987   else
988     {
989       sim_data = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NEEDED);
990       if (sim_data == NULL)
991         error (_("Unable to wait for pid %d.  Inferior not found."),
992                ptid_get_pid (ptid));
993       inferior_ptid = ptid;
994     }
995
996   if (remote_debug)
997     fprintf_unfiltered (gdb_stdlog, "gdbsim_wait\n");
998
999 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1000   {
1001     struct sigaction sa, osa;
1002     sa.sa_handler = gdbsim_cntrl_c;
1003     sigemptyset (&sa.sa_mask);
1004     sa.sa_flags = 0;
1005     sigaction (SIGINT, &sa, &osa);
1006     prev_sigint = osa.sa_handler;
1007   }
1008 #else
1009   prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
1010 #endif
1011   sim_resume (sim_data->gdbsim_desc, sim_data->resume_step,
1012               sim_data->resume_siggnal);
1013
1014   signal (SIGINT, prev_sigint);
1015   sim_data->resume_step = 0;
1016
1017   sim_stop_reason (sim_data->gdbsim_desc, &reason, &sigrc);
1018
1019   switch (reason)
1020     {
1021     case sim_exited:
1022       status->kind = TARGET_WAITKIND_EXITED;
1023       status->value.integer = sigrc;
1024       break;
1025     case sim_stopped:
1026       switch (sigrc)
1027         {
1028         case GDB_SIGNAL_ABRT:
1029           quit ();
1030           break;
1031         case GDB_SIGNAL_INT:
1032         case GDB_SIGNAL_TRAP:
1033         default:
1034           status->kind = TARGET_WAITKIND_STOPPED;
1035           status->value.sig = sigrc;
1036           break;
1037         }
1038       break;
1039     case sim_signalled:
1040       status->kind = TARGET_WAITKIND_SIGNALLED;
1041       status->value.sig = sigrc;
1042       break;
1043     case sim_running:
1044     case sim_polling:
1045       /* FIXME: Is this correct?  */
1046       break;
1047     }
1048
1049   return inferior_ptid;
1050 }
1051
1052 /* Get ready to modify the registers array.  On machines which store
1053    individual registers, this doesn't need to do anything.  On machines
1054    which store all the registers in one fell swoop, this makes sure
1055    that registers contains all the registers from the program being
1056    debugged.  */
1057
1058 static void
1059 gdbsim_prepare_to_store (struct target_ops *self, struct regcache *regcache)
1060 {
1061   /* Do nothing, since we can store individual regs.  */
1062 }
1063
1064 /* Helper for gdbsim_xfer_partial that handles memory transfers.
1065    Arguments are like target_xfer_partial.  */
1066
1067 static enum target_xfer_status
1068 gdbsim_xfer_memory (struct target_ops *target,
1069                     gdb_byte *readbuf, const gdb_byte *writebuf,
1070                     ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
1071 {
1072   struct sim_inferior_data *sim_data
1073     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1074   int l;
1075
1076   /* If this target doesn't have memory yet, return 0 causing the
1077      request to be passed to a lower target, hopefully an exec
1078      file.  */
1079   if (!target->to_has_memory (target))
1080     return TARGET_XFER_EOF;
1081
1082   if (!sim_data->program_loaded)
1083     error (_("No program loaded."));
1084
1085   /* Note that we obtained the sim_data pointer above using
1086      SIM_INSTANCE_NOT_NEEDED.  We do this so that we don't needlessly
1087      allocate a sim instance prior to loading a program.   If we
1088      get to this point in the code though, gdbsim_desc should be
1089      non-NULL.  (Note that a sim instance is needed in order to load
1090      the program...)  */
1091   gdb_assert (sim_data->gdbsim_desc != NULL);
1092
1093   if (remote_debug)
1094     fprintf_unfiltered (gdb_stdlog,
1095                         "gdbsim_xfer_memory: readbuf %s, writebuf %s, "
1096                         "memaddr %s, len %s\n",
1097                         host_address_to_string (readbuf),
1098                         host_address_to_string (writebuf),
1099                         paddress (target_gdbarch (), memaddr),
1100                         pulongest (len));
1101
1102   if (writebuf)
1103     {
1104       if (remote_debug && len > 0)
1105         dump_mem (writebuf, len);
1106       l = sim_write (sim_data->gdbsim_desc, memaddr, writebuf, len);
1107     }
1108   else
1109     {
1110       l = sim_read (sim_data->gdbsim_desc, memaddr, readbuf, len);
1111       if (remote_debug && len > 0)
1112         dump_mem (readbuf, len);
1113     }
1114   if (l > 0)
1115     {
1116       *xfered_len = (ULONGEST) l;
1117       return TARGET_XFER_OK;
1118     }
1119   else if (l == 0)
1120     return TARGET_XFER_EOF;
1121   else
1122     return TARGET_XFER_E_IO;
1123 }
1124
1125 /* Target to_xfer_partial implementation.  */
1126
1127 static enum target_xfer_status
1128 gdbsim_xfer_partial (struct target_ops *ops, enum target_object object,
1129                      const char *annex, gdb_byte *readbuf,
1130                      const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
1131                      ULONGEST *xfered_len)
1132 {
1133   switch (object)
1134     {
1135     case TARGET_OBJECT_MEMORY:
1136       return gdbsim_xfer_memory (ops, readbuf, writebuf, offset, len,
1137                                  xfered_len);
1138
1139     default:
1140       return TARGET_XFER_E_IO;
1141     }
1142 }
1143
1144 static void
1145 gdbsim_files_info (struct target_ops *target)
1146 {
1147   struct sim_inferior_data *sim_data
1148     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
1149   const char *file = "nothing";
1150
1151   if (exec_bfd)
1152     file = bfd_get_filename (exec_bfd);
1153
1154   if (remote_debug)
1155     fprintf_unfiltered (gdb_stdlog, "gdbsim_files_info: file \"%s\"\n", file);
1156
1157   if (exec_bfd)
1158     {
1159       fprintf_unfiltered (gdb_stdlog, "\tAttached to %s running program %s\n",
1160                           target_shortname, file);
1161       sim_info (sim_data->gdbsim_desc, 0);
1162     }
1163 }
1164
1165 /* Clear the simulator's notion of what the break points are.  */
1166
1167 static void
1168 gdbsim_mourn_inferior (struct target_ops *target)
1169 {
1170   struct sim_inferior_data *sim_data
1171     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1172
1173   if (remote_debug)
1174     fprintf_unfiltered (gdb_stdlog, "gdbsim_mourn_inferior:\n");
1175
1176   remove_breakpoints ();
1177   generic_mourn_inferior ();
1178   delete_thread_silent (sim_data->remote_sim_ptid);
1179 }
1180
1181 /* Pass the command argument through to the simulator verbatim.  The
1182    simulator must do any command interpretation work.  */
1183
1184 void
1185 simulator_command (char *args, int from_tty)
1186 {
1187   struct sim_inferior_data *sim_data;
1188
1189   /* We use inferior_data() instead of get_sim_inferior_data() here in
1190      order to avoid attaching a sim_inferior_data struct to an
1191      inferior unnecessarily.  The reason we take such care here is due
1192      to the fact that this function, simulator_command(), may be called
1193      even when the sim target is not active.  If we were to use
1194      get_sim_inferior_data() here, it is possible that this call would
1195      be made either prior to gdbsim_open() or after gdbsim_close(),
1196      thus allocating memory that would not be garbage collected until
1197      the ultimate destruction of the associated inferior.  */
1198
1199   sim_data  = inferior_data (current_inferior (), sim_inferior_data_key);
1200   if (sim_data == NULL || sim_data->gdbsim_desc == NULL)
1201     {
1202
1203       /* PREVIOUSLY: The user may give a command before the simulator
1204          is opened. [...] (??? assuming of course one wishes to
1205          continue to allow commands to be sent to unopened simulators,
1206          which isn't entirely unreasonable).  */
1207
1208       /* The simulator is a builtin abstraction of a remote target.
1209          Consistent with that model, access to the simulator, via sim
1210          commands, is restricted to the period when the channel to the
1211          simulator is open.  */
1212
1213       error (_("Not connected to the simulator target"));
1214     }
1215
1216   sim_do_command (sim_data->gdbsim_desc, args);
1217
1218   /* Invalidate the register cache, in case the simulator command does
1219      something funny.  */
1220   registers_changed ();
1221 }
1222
1223 static VEC (char_ptr) *
1224 sim_command_completer (struct cmd_list_element *ignore, const char *text,
1225                        const char *word)
1226 {
1227   struct sim_inferior_data *sim_data;
1228   char **tmp;
1229   int i;
1230   VEC (char_ptr) *result = NULL;
1231
1232   sim_data = inferior_data (current_inferior (), sim_inferior_data_key);
1233   if (sim_data == NULL || sim_data->gdbsim_desc == NULL)
1234     return NULL;
1235
1236   tmp = sim_complete_command (sim_data->gdbsim_desc, text, word);
1237   if (tmp == NULL)
1238     return NULL;
1239
1240   /* Transform the array into a VEC, and then free the array.  */
1241   for (i = 0; tmp[i] != NULL; i++)
1242     VEC_safe_push (char_ptr, result, tmp[i]);
1243   xfree (tmp);
1244
1245   return result;
1246 }
1247
1248 /* Check to see if a thread is still alive.  */
1249
1250 static int
1251 gdbsim_thread_alive (struct target_ops *ops, ptid_t ptid)
1252 {
1253   struct sim_inferior_data *sim_data
1254     = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NOT_NEEDED);
1255
1256   if (sim_data == NULL)
1257     return 0;
1258
1259   if (ptid_equal (ptid, sim_data->remote_sim_ptid))
1260     /* The simulators' task is always alive.  */
1261     return 1;
1262
1263   return 0;
1264 }
1265
1266 /* Convert a thread ID to a string.  Returns the string in a static
1267    buffer.  */
1268
1269 static char *
1270 gdbsim_pid_to_str (struct target_ops *ops, ptid_t ptid)
1271 {
1272   return normal_pid_to_str (ptid);
1273 }
1274
1275 /* Simulator memory may be accessed after the program has been loaded.  */
1276
1277 static int
1278 gdbsim_has_all_memory (struct target_ops *ops)
1279 {
1280   struct sim_inferior_data *sim_data
1281     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1282
1283   if (!sim_data->program_loaded)
1284     return 0;
1285
1286   return 1;
1287 }
1288
1289 static int
1290 gdbsim_has_memory (struct target_ops *ops)
1291 {
1292   struct sim_inferior_data *sim_data
1293     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1294
1295   if (!sim_data->program_loaded)
1296     return 0;
1297
1298   return 1;
1299 }
1300
1301 /* Define the target subroutine names.  */
1302
1303 struct target_ops gdbsim_ops;
1304
1305 static void
1306 init_gdbsim_ops (void)
1307 {
1308   gdbsim_ops.to_shortname = "sim";
1309   gdbsim_ops.to_longname = "simulator";
1310   gdbsim_ops.to_doc = "Use the compiled-in simulator.";
1311   gdbsim_ops.to_open = gdbsim_open;
1312   gdbsim_ops.to_close = gdbsim_close;
1313   gdbsim_ops.to_detach = gdbsim_detach;
1314   gdbsim_ops.to_resume = gdbsim_resume;
1315   gdbsim_ops.to_wait = gdbsim_wait;
1316   gdbsim_ops.to_fetch_registers = gdbsim_fetch_register;
1317   gdbsim_ops.to_store_registers = gdbsim_store_register;
1318   gdbsim_ops.to_prepare_to_store = gdbsim_prepare_to_store;
1319   gdbsim_ops.to_xfer_partial = gdbsim_xfer_partial;
1320   gdbsim_ops.to_files_info = gdbsim_files_info;
1321   gdbsim_ops.to_insert_breakpoint = memory_insert_breakpoint;
1322   gdbsim_ops.to_remove_breakpoint = memory_remove_breakpoint;
1323   gdbsim_ops.to_kill = gdbsim_kill;
1324   gdbsim_ops.to_load = gdbsim_load;
1325   gdbsim_ops.to_create_inferior = gdbsim_create_inferior;
1326   gdbsim_ops.to_mourn_inferior = gdbsim_mourn_inferior;
1327   gdbsim_ops.to_stop = gdbsim_stop;
1328   gdbsim_ops.to_thread_alive = gdbsim_thread_alive;
1329   gdbsim_ops.to_pid_to_str = gdbsim_pid_to_str;
1330   gdbsim_ops.to_stratum = process_stratum;
1331   gdbsim_ops.to_has_all_memory = gdbsim_has_all_memory;
1332   gdbsim_ops.to_has_memory = gdbsim_has_memory;
1333   gdbsim_ops.to_has_stack = default_child_has_stack;
1334   gdbsim_ops.to_has_registers = default_child_has_registers;
1335   gdbsim_ops.to_has_execution = default_child_has_execution;
1336   gdbsim_ops.to_magic = OPS_MAGIC;
1337 }
1338
1339 void
1340 _initialize_remote_sim (void)
1341 {
1342   struct cmd_list_element *c;
1343
1344   init_gdbsim_ops ();
1345   add_target (&gdbsim_ops);
1346
1347   c = add_com ("sim", class_obscure, simulator_command,
1348                _("Send a command to the simulator."));
1349   set_cmd_completer (c, sim_command_completer);
1350
1351   sim_inferior_data_key
1352     = register_inferior_data_with_cleanup (NULL, sim_inferior_data_cleanup);
1353 }