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