* remote-sim.c (gdb_os_poll_quit): Don't check immediate_quit.
[external/binutils.git] / gdb / remote-sim.c
1 /* Generic remote debugging interface for simulators.
2
3    Copyright (C) 1993-2002, 2004-2012 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 "value.h"
26 #include "gdb_string.h"
27 #include <ctype.h>
28 #include <fcntl.h>
29 #include <signal.h>
30 #include <setjmp.h>
31 #include <errno.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 "gdb_assert.h"
40 #include "sim-regno.h"
41 #include "arch-utils.h"
42 #include "readline/readline.h"
43 #include "gdbthread.h"
44
45 /* Prototypes */
46
47 extern void _initialize_remote_sim (void);
48
49 static void dump_mem (char *buf, int len);
50
51 static void init_callbacks (void);
52
53 static void end_callbacks (void);
54
55 static int gdb_os_write_stdout (host_callback *, const char *, int);
56
57 static void gdb_os_flush_stdout (host_callback *);
58
59 static int gdb_os_write_stderr (host_callback *, const char *, int);
60
61 static void gdb_os_flush_stderr (host_callback *);
62
63 static int gdb_os_poll_quit (host_callback *);
64
65 /* printf_filtered is depreciated.  */
66 static void gdb_os_printf_filtered (host_callback *, const char *, ...);
67
68 static void gdb_os_vprintf_filtered (host_callback *, const char *, va_list);
69
70 static void gdb_os_evprintf_filtered (host_callback *, const char *, va_list);
71
72 static void gdb_os_error (host_callback *, const char *, ...)
73      ATTRIBUTE_NORETURN;
74
75 static void gdbsim_kill (struct target_ops *);
76
77 static void gdbsim_load (char *prog, int fromtty);
78
79 static void gdbsim_open (char *args, int from_tty);
80
81 static void gdbsim_close (int quitting);
82
83 static void gdbsim_detach (struct target_ops *ops, char *args, int from_tty);
84
85 static void gdbsim_prepare_to_store (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 (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 = XZALLOC(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 (char *buf, int len)
275 {
276   if (len <= 8)
277     {
278       if (len == 8 || len == 4)
279         {
280           long l[2];
281
282           memcpy (l, buf, len);
283           printf_filtered ("\t0x%lx", l[0]);
284           if (len == 8)
285             printf_filtered (" 0x%lx", l[1]);
286           printf_filtered ("\n");
287         }
288       else
289         {
290           int i;
291
292           printf_filtered ("\t");
293           for (i = 0; i < len; i++)
294             printf_filtered ("0x%x ", buf[i]);
295           printf_filtered ("\n");
296         }
297     }
298 }
299
300 /* Initialize gdb_callback.  */
301
302 static void
303 init_callbacks (void)
304 {
305   if (!callbacks_initialized)
306     {
307       gdb_callback = default_callback;
308       gdb_callback.init (&gdb_callback);
309       gdb_callback.write_stdout = gdb_os_write_stdout;
310       gdb_callback.flush_stdout = gdb_os_flush_stdout;
311       gdb_callback.write_stderr = gdb_os_write_stderr;
312       gdb_callback.flush_stderr = gdb_os_flush_stderr;
313       gdb_callback.printf_filtered = gdb_os_printf_filtered;
314       gdb_callback.vprintf_filtered = gdb_os_vprintf_filtered;
315       gdb_callback.evprintf_filtered = gdb_os_evprintf_filtered;
316       gdb_callback.error = gdb_os_error;
317       gdb_callback.poll_quit = gdb_os_poll_quit;
318       gdb_callback.magic = HOST_CALLBACK_MAGIC;
319       callbacks_initialized = 1;
320     }
321 }
322
323 /* Release callbacks (free resources used by them).  */
324
325 static void
326 end_callbacks (void)
327 {
328   if (callbacks_initialized)
329     {
330       gdb_callback.shutdown (&gdb_callback);
331       callbacks_initialized = 0;
332     }
333 }
334
335 /* GDB version of os_write_stdout callback.  */
336
337 static int
338 gdb_os_write_stdout (host_callback *p, const char *buf, int len)
339 {
340   int i;
341   char b[2];
342
343   ui_file_write (gdb_stdtarg, buf, len);
344   return len;
345 }
346
347 /* GDB version of os_flush_stdout callback.  */
348
349 static void
350 gdb_os_flush_stdout (host_callback *p)
351 {
352   gdb_flush (gdb_stdtarg);
353 }
354
355 /* GDB version of os_write_stderr callback.  */
356
357 static int
358 gdb_os_write_stderr (host_callback *p, const char *buf, int len)
359 {
360   int i;
361   char b[2];
362
363   for (i = 0; i < len; i++)
364     {
365       b[0] = buf[i];
366       b[1] = 0;
367       fputs_unfiltered (b, gdb_stdtargerr);
368     }
369   return len;
370 }
371
372 /* GDB version of os_flush_stderr callback.  */
373
374 static void
375 gdb_os_flush_stderr (host_callback *p)
376 {
377   gdb_flush (gdb_stdtargerr);
378 }
379
380 /* GDB version of printf_filtered callback.  */
381
382 static void
383 gdb_os_printf_filtered (host_callback * p, const char *format,...)
384 {
385   va_list args;
386
387   va_start (args, format);
388   vfprintf_filtered (gdb_stdout, format, args);
389   va_end (args);
390 }
391
392 /* GDB version of error vprintf_filtered.  */
393
394 static void
395 gdb_os_vprintf_filtered (host_callback * p, const char *format, va_list ap)
396 {
397   vfprintf_filtered (gdb_stdout, format, ap);
398 }
399
400 /* GDB version of error evprintf_filtered.  */
401
402 static void
403 gdb_os_evprintf_filtered (host_callback * p, const char *format, va_list ap)
404 {
405   vfprintf_filtered (gdb_stderr, format, ap);
406 }
407
408 /* GDB version of error callback.  */
409
410 static void
411 gdb_os_error (host_callback * p, const char *format, ...)
412 {
413   va_list args;
414
415   va_start (args, format);
416   verror (format, args);
417   va_end (args);
418 }
419
420 int
421 one2one_register_sim_regno (struct gdbarch *gdbarch, int regnum)
422 {
423   /* Only makes sense to supply raw registers.  */
424   gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
425   return regnum;
426 }
427
428 static void
429 gdbsim_fetch_register (struct target_ops *ops,
430                        struct regcache *regcache, int regno)
431 {
432   struct gdbarch *gdbarch = get_regcache_arch (regcache);
433   struct sim_inferior_data *sim_data
434     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
435
436   if (regno == -1)
437     {
438       for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
439         gdbsim_fetch_register (ops, regcache, regno);
440       return;
441     }
442
443   switch (gdbarch_register_sim_regno (gdbarch, regno))
444     {
445     case LEGACY_SIM_REGNO_IGNORE:
446       break;
447     case SIM_REGNO_DOES_NOT_EXIST:
448       {
449         /* For moment treat a `does not exist' register the same way
450            as an ``unavailable'' register.  */
451         char buf[MAX_REGISTER_SIZE];
452         int nr_bytes;
453
454         memset (buf, 0, MAX_REGISTER_SIZE);
455         regcache_raw_supply (regcache, regno, buf);
456         break;
457       }
458       
459     default:
460       {
461         static int warn_user = 1;
462         char buf[MAX_REGISTER_SIZE];
463         int nr_bytes;
464
465         gdb_assert (regno >= 0 && regno < gdbarch_num_regs (gdbarch));
466         memset (buf, 0, MAX_REGISTER_SIZE);
467         nr_bytes = sim_fetch_register (sim_data->gdbsim_desc,
468                                        gdbarch_register_sim_regno
469                                          (gdbarch, regno),
470                                        buf,
471                                        register_size (gdbarch, regno));
472         if (nr_bytes > 0
473             && nr_bytes != register_size (gdbarch, regno) && warn_user)
474           {
475             fprintf_unfiltered (gdb_stderr,
476                                 "Size of register %s (%d/%d) "
477                                 "incorrect (%d instead of %d))",
478                                 gdbarch_register_name (gdbarch, regno),
479                                 regno,
480                                 gdbarch_register_sim_regno
481                                   (gdbarch, regno),
482                                 nr_bytes, register_size (gdbarch, regno));
483             warn_user = 0;
484           }
485         /* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0'
486            indicating that GDB and the SIM have different ideas about
487            which registers are fetchable.  */
488         /* Else if (nr_bytes < 0): an old simulator, that doesn't
489            think to return the register size.  Just assume all is ok.  */
490         regcache_raw_supply (regcache, regno, buf);
491         if (remote_debug)
492           {
493             printf_filtered ("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       char 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           printf_filtered ("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     printf_filtered ("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 (char *args, int fromtty)
566 {
567   char **argv;
568   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     printf_filtered ("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     printf_filtered ("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 (sim_create_inferior (sim_data->gdbsim_desc, exec_bfd, argv, env)
646       != SIM_RC_OK)
647     error (_("Unable to create sim inferior."));
648
649   inferior_ptid = sim_data->remote_sim_ptid;
650   inferior_appeared (current_inferior (), ptid_get_pid (inferior_ptid));
651   add_thread_silent (inferior_ptid);
652
653   insert_breakpoints ();        /* Needed to get correct instruction
654                                    in cache.  */
655
656   clear_proceed_status ();
657 }
658
659 /* The open routine takes the rest of the parameters from the command,
660    and (if successful) pushes a new target onto the stack.
661    Targets should supply this routine, if only to provide an error message.  */
662 /* Called when selecting the simulator.  E.g. (gdb) target sim name.  */
663
664 static void
665 gdbsim_open (char *args, int from_tty)
666 {
667   int len;
668   char *arg_buf;
669   struct sim_inferior_data *sim_data;
670   SIM_DESC gdbsim_desc;
671
672   if (remote_debug)
673     printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
674
675   /* Ensure that the sim target is not on the target stack.  This is
676      necessary, because if it is on the target stack, the call to
677      push_target below will invoke sim_close(), thus freeing various
678      state (including a sim instance) that we allocate prior to
679      invoking push_target().  We want to delay the push_target()
680      operation until after we complete those operations which could
681      error out.  */
682   if (gdbsim_is_open)
683     unpush_target (&gdbsim_ops);
684
685   len = (7 + 1                  /* gdbsim */
686          + strlen (" -E little")
687          + strlen (" --architecture=xxxxxxxxxx")
688          + strlen (" --sysroot=") + strlen (gdb_sysroot) +
689          + (args ? strlen (args) : 0)
690          + 50) /* slack */ ;
691   arg_buf = (char *) alloca (len);
692   strcpy (arg_buf, "gdbsim");   /* 7 */
693   /* Specify the byte order for the target when it is explicitly
694      specified by the user (not auto detected).  */
695   switch (selected_byte_order ())
696     {
697     case BFD_ENDIAN_BIG:
698       strcat (arg_buf, " -E big");
699       break;
700     case BFD_ENDIAN_LITTLE:
701       strcat (arg_buf, " -E little");
702       break;
703     case BFD_ENDIAN_UNKNOWN:
704       break;
705     }
706   /* Specify the architecture of the target when it has been
707      explicitly specified */
708   if (selected_architecture_name () != NULL)
709     {
710       strcat (arg_buf, " --architecture=");
711       strcat (arg_buf, selected_architecture_name ());
712     }
713   /* Pass along gdb's concept of the sysroot.  */
714   strcat (arg_buf, " --sysroot=");
715   strcat (arg_buf, gdb_sysroot);
716   /* finally, any explicit args */
717   if (args)
718     {
719       strcat (arg_buf, " ");    /* 1 */
720       strcat (arg_buf, args);
721     }
722   sim_argv = gdb_buildargv (arg_buf);
723
724   init_callbacks ();
725   gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, sim_argv);
726
727   if (gdbsim_desc == 0)
728     {
729       freeargv (sim_argv);
730       sim_argv = NULL;
731       error (_("unable to create simulator instance"));
732     }
733
734   /* Reset the pid numberings for this batch of sim instances.  */
735   next_pid = INITIAL_PID;
736
737   /* Allocate the inferior data, but do not allocate a sim instance
738      since we've already just done that.  */
739   sim_data = get_sim_inferior_data (current_inferior (),
740                                     SIM_INSTANCE_NOT_NEEDED);
741
742   sim_data->gdbsim_desc = gdbsim_desc;
743
744   push_target (&gdbsim_ops);
745   printf_filtered ("Connected to the simulator.\n");
746
747   /* There's nothing running after "target sim" or "load"; not until
748      "run".  */
749   inferior_ptid = null_ptid;
750
751   gdbsim_is_open = 1;
752 }
753
754 /* Callback for iterate_over_inferiors.  Called (indirectly) by
755    gdbsim_close().  */
756
757 static int
758 gdbsim_close_inferior (struct inferior *inf, void *arg)
759 {
760   struct sim_inferior_data *sim_data = inferior_data (inf,
761                                                       sim_inferior_data_key);
762   if (sim_data != NULL)
763     {
764       ptid_t ptid = sim_data->remote_sim_ptid;
765
766       sim_inferior_data_cleanup (inf, sim_data);
767       set_inferior_data (inf, sim_inferior_data_key, NULL);
768
769       /* Having a ptid allocated and stored in remote_sim_ptid does
770          not mean that a corresponding inferior was ever created.
771          Thus we need to verify the existence of an inferior using the
772          pid in question before setting inferior_ptid via
773          switch_to_thread() or mourning the inferior.  */
774       if (find_inferior_pid (ptid_get_pid (ptid)) != NULL)
775         {
776           switch_to_thread (ptid);
777           generic_mourn_inferior ();
778         }
779     }
780
781   return 0;
782 }
783
784 /* Does whatever cleanup is required for a target that we are no longer
785    going to be calling.  Argument says whether we are quitting gdb and
786    should not get hung in case of errors, or whether we want a clean
787    termination even if it takes a while.  This routine is automatically
788    always called just before a routine is popped off the target stack.
789    Closing file descriptors and freeing memory are typical things it should
790    do.  */
791 /* Close out all files and local state before this target loses control.  */
792
793 static void
794 gdbsim_close (int quitting)
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     printf_filtered ("gdbsim_close: quitting %d\n", quitting);
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, char *args, int from_tty)
826 {
827   if (remote_debug)
828     printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
829
830   pop_target ();                /* 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         printf_filtered (_("gdbsim_resume: pid %d, step %d, signal %d\n"),
859                          inf->pid, rd->step, rd->siggnal);
860     }
861
862   /* When called from iterate_over_inferiors, a zero return causes the
863      iteration process to proceed until there are no more inferiors to
864      consider.  */
865   return 0;
866 }
867
868 static void
869 gdbsim_resume (struct target_ops *ops,
870                ptid_t ptid, int step, enum gdb_signal siggnal)
871 {
872   struct resume_data rd;
873   struct sim_inferior_data *sim_data
874     = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NOT_NEEDED);
875
876   rd.siggnal = siggnal;
877   rd.step = step;
878
879   /* We don't access any sim_data members within this function.
880      What's of interest is whether or not the call to
881      get_sim_inferior_data_by_ptid(), above, is able to obtain a
882      non-NULL pointer.  If it managed to obtain a non-NULL pointer, we
883      know we have a single inferior to consider.  If it's NULL, we
884      either have multiple inferiors to resume or an error condition.  */
885
886   if (sim_data)
887     gdbsim_resume_inferior (find_inferior_pid (ptid_get_pid (ptid)), &rd);
888   else if (ptid_equal (ptid, minus_one_ptid))
889     iterate_over_inferiors (gdbsim_resume_inferior, &rd);
890   else
891     error (_("The program is not being run."));
892 }
893
894 /* Notify the simulator of an asynchronous request to stop.
895
896    The simulator shall ensure that the stop request is eventually
897    delivered to the simulator.  If the call is made while the
898    simulator is not running then the stop request is processed when
899    the simulator is next resumed.
900
901    For simulators that do not support this operation, just abort.  */
902
903 static int
904 gdbsim_stop_inferior (struct inferior *inf, void *arg)
905 {
906   struct sim_inferior_data *sim_data
907     = get_sim_inferior_data (inf, SIM_INSTANCE_NEEDED);
908
909   if (sim_data)
910     {
911       if (!sim_stop (sim_data->gdbsim_desc))
912         {
913           quit ();
914         }
915     }
916
917   /* When called from iterate_over_inferiors, a zero return causes the
918      iteration process to proceed until there are no more inferiors to
919      consider.  */
920   return 0;
921 }
922
923 static void
924 gdbsim_stop (ptid_t ptid)
925 {
926   struct sim_inferior_data *sim_data;
927
928   if (ptid_equal (ptid, minus_one_ptid))
929     {
930       iterate_over_inferiors (gdbsim_stop_inferior, NULL);
931     }
932   else
933     {
934       struct inferior *inf = find_inferior_pid (ptid_get_pid (ptid));
935
936       if (inf == NULL)
937         error (_("Can't stop pid %d.  No inferior found."),
938                ptid_get_pid (ptid));
939
940       gdbsim_stop_inferior (inf, NULL);
941     }
942 }
943
944 /* GDB version of os_poll_quit callback.
945    Taken from gdb/util.c - should be in a library.  */
946
947 static int
948 gdb_os_poll_quit (host_callback *p)
949 {
950   if (deprecated_ui_loop_hook != NULL)
951     deprecated_ui_loop_hook (0);
952
953   if (quit_flag)                /* gdb's idea of quit */
954     {
955       quit_flag = 0;            /* we've stolen it */
956       return 1;
957     }
958   return 0;
959 }
960
961 /* Wait for inferior process to do something.  Return pid of child,
962    or -1 in case of error; store status through argument pointer STATUS,
963    just as `wait' would.  */
964
965 static void
966 gdbsim_cntrl_c (int signo)
967 {
968   gdbsim_stop (minus_one_ptid);
969 }
970
971 static ptid_t
972 gdbsim_wait (struct target_ops *ops,
973              ptid_t ptid, struct target_waitstatus *status, int options)
974 {
975   struct sim_inferior_data *sim_data;
976   static RETSIGTYPE (*prev_sigint) ();
977   int sigrc = 0;
978   enum sim_stop reason = sim_running;
979
980   /* This target isn't able to (yet) resume more than one inferior at a time.
981      When ptid is minus_one_ptid, just use the current inferior.  If we're
982      given an explicit pid, we'll try to find it and use that instead.  */
983   if (ptid_equal (ptid, minus_one_ptid))
984     sim_data = get_sim_inferior_data (current_inferior (),
985                                       SIM_INSTANCE_NEEDED);
986   else
987     {
988       sim_data = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NEEDED);
989       if (sim_data == NULL)
990         error (_("Unable to wait for pid %d.  Inferior not found."),
991                ptid_get_pid (ptid));
992       inferior_ptid = ptid;
993     }
994
995   if (remote_debug)
996     printf_filtered ("gdbsim_wait\n");
997
998 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
999   {
1000     struct sigaction sa, osa;
1001     sa.sa_handler = gdbsim_cntrl_c;
1002     sigemptyset (&sa.sa_mask);
1003     sa.sa_flags = 0;
1004     sigaction (SIGINT, &sa, &osa);
1005     prev_sigint = osa.sa_handler;
1006   }
1007 #else
1008   prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
1009 #endif
1010   sim_resume (sim_data->gdbsim_desc, sim_data->resume_step,
1011               sim_data->resume_siggnal);
1012
1013   signal (SIGINT, prev_sigint);
1014   sim_data->resume_step = 0;
1015
1016   sim_stop_reason (sim_data->gdbsim_desc, &reason, &sigrc);
1017
1018   switch (reason)
1019     {
1020     case sim_exited:
1021       status->kind = TARGET_WAITKIND_EXITED;
1022       status->value.integer = sigrc;
1023       break;
1024     case sim_stopped:
1025       switch (sigrc)
1026         {
1027         case GDB_SIGNAL_ABRT:
1028           quit ();
1029           break;
1030         case GDB_SIGNAL_INT:
1031         case GDB_SIGNAL_TRAP:
1032         default:
1033           status->kind = TARGET_WAITKIND_STOPPED;
1034           status->value.sig = sigrc;
1035           break;
1036         }
1037       break;
1038     case sim_signalled:
1039       status->kind = TARGET_WAITKIND_SIGNALLED;
1040       status->value.sig = sigrc;
1041       break;
1042     case sim_running:
1043     case sim_polling:
1044       /* FIXME: Is this correct?  */
1045       break;
1046     }
1047
1048   return inferior_ptid;
1049 }
1050
1051 /* Get ready to modify the registers array.  On machines which store
1052    individual registers, this doesn't need to do anything.  On machines
1053    which store all the registers in one fell swoop, this makes sure
1054    that registers contains all the registers from the program being
1055    debugged.  */
1056
1057 static void
1058 gdbsim_prepare_to_store (struct regcache *regcache)
1059 {
1060   /* Do nothing, since we can store individual regs.  */
1061 }
1062
1063 /* Transfer LEN bytes between GDB address MYADDR and target address
1064    MEMADDR.  If WRITE is non-zero, transfer them to the target,
1065    otherwise transfer them from the target.  TARGET is unused.
1066
1067    Returns the number of bytes transferred.  */
1068
1069 static int
1070 gdbsim_xfer_inferior_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
1071                              int write, struct mem_attrib *attrib,
1072                              struct target_ops *target)
1073 {
1074   struct sim_inferior_data *sim_data
1075     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1076
1077   /* If this target doesn't have memory yet, return 0 causing the
1078      request to be passed to a lower target, hopefully an exec
1079      file.  */
1080   if (!target->to_has_memory (target))
1081     return 0;
1082
1083   if (!sim_data->program_loaded)
1084     error (_("No program loaded."));
1085
1086   /* Note that we obtained the sim_data pointer above using
1087      SIM_INSTANCE_NOT_NEEDED.  We do this so that we don't needlessly
1088      allocate a sim instance prior to loading a program.   If we
1089      get to this point in the code though, gdbsim_desc should be
1090      non-NULL.  (Note that a sim instance is needed in order to load
1091      the program...)  */
1092   gdb_assert (sim_data->gdbsim_desc != NULL);
1093
1094   if (remote_debug)
1095     {
1096       /* FIXME: Send to something other than STDOUT?  */
1097       printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x");
1098       gdb_print_host_address (myaddr, gdb_stdout);
1099       printf_filtered (", memaddr %s, len %d, write %d\n",
1100                        paddress (target_gdbarch, memaddr), len, write);
1101       if (remote_debug && write)
1102         dump_mem (myaddr, len);
1103     }
1104
1105   if (write)
1106     {
1107       len = sim_write (sim_data->gdbsim_desc, memaddr, myaddr, len);
1108     }
1109   else
1110     {
1111       len = sim_read (sim_data->gdbsim_desc, memaddr, myaddr, len);
1112       if (remote_debug && len > 0)
1113         dump_mem (myaddr, len);
1114     }
1115   return len;
1116 }
1117
1118 static void
1119 gdbsim_files_info (struct target_ops *target)
1120 {
1121   struct sim_inferior_data *sim_data
1122     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
1123   const char *file = "nothing";
1124
1125   if (exec_bfd)
1126     file = bfd_get_filename (exec_bfd);
1127
1128   if (remote_debug)
1129     printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
1130
1131   if (exec_bfd)
1132     {
1133       printf_filtered ("\tAttached to %s running program %s\n",
1134                        target_shortname, file);
1135       sim_info (sim_data->gdbsim_desc, 0);
1136     }
1137 }
1138
1139 /* Clear the simulator's notion of what the break points are.  */
1140
1141 static void
1142 gdbsim_mourn_inferior (struct target_ops *target)
1143 {
1144   struct sim_inferior_data *sim_data
1145     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1146
1147   if (remote_debug)
1148     printf_filtered ("gdbsim_mourn_inferior:\n");
1149
1150   remove_breakpoints ();
1151   generic_mourn_inferior ();
1152   delete_thread_silent (sim_data->remote_sim_ptid);
1153 }
1154
1155 /* Pass the command argument through to the simulator verbatim.  The
1156    simulator must do any command interpretation work.  */
1157
1158 void
1159 simulator_command (char *args, int from_tty)
1160 {
1161   struct sim_inferior_data *sim_data;
1162
1163   /* We use inferior_data() instead of get_sim_inferior_data() here in
1164      order to avoid attaching a sim_inferior_data struct to an
1165      inferior unnecessarily.  The reason we take such care here is due
1166      to the fact that this function, simulator_command(), may be called
1167      even when the sim target is not active.  If we were to use
1168      get_sim_inferior_data() here, it is possible that this call would
1169      be made either prior to gdbsim_open() or after gdbsim_close(),
1170      thus allocating memory that would not be garbage collected until
1171      the ultimate destruction of the associated inferior.  */
1172
1173   sim_data  = inferior_data (current_inferior (), sim_inferior_data_key);
1174   if (sim_data == NULL || sim_data->gdbsim_desc == NULL)
1175     {
1176
1177       /* PREVIOUSLY: The user may give a command before the simulator
1178          is opened. [...] (??? assuming of course one wishes to
1179          continue to allow commands to be sent to unopened simulators,
1180          which isn't entirely unreasonable).  */
1181
1182       /* The simulator is a builtin abstraction of a remote target.
1183          Consistent with that model, access to the simulator, via sim
1184          commands, is restricted to the period when the channel to the
1185          simulator is open.  */
1186
1187       error (_("Not connected to the simulator target"));
1188     }
1189
1190   sim_do_command (sim_data->gdbsim_desc, args);
1191
1192   /* Invalidate the register cache, in case the simulator command does
1193      something funny.  */
1194   registers_changed ();
1195 }
1196
1197 static VEC (char_ptr) *
1198 sim_command_completer (struct cmd_list_element *ignore, char *text, char *word)
1199 {
1200   struct sim_inferior_data *sim_data;
1201   char **tmp;
1202   int i;
1203   VEC (char_ptr) *result = NULL;
1204
1205   sim_data = inferior_data (current_inferior (), sim_inferior_data_key);
1206   if (sim_data == NULL || sim_data->gdbsim_desc == NULL)
1207     return NULL;
1208
1209   tmp = sim_complete_command (sim_data->gdbsim_desc, text, word);
1210   if (tmp == NULL)
1211     return NULL;
1212
1213   /* Transform the array into a VEC, and then free the array.  */
1214   for (i = 0; tmp[i] != NULL; i++)
1215     VEC_safe_push (char_ptr, result, tmp[i]);
1216   xfree (tmp);
1217
1218   return result;
1219 }
1220
1221 /* Check to see if a thread is still alive.  */
1222
1223 static int
1224 gdbsim_thread_alive (struct target_ops *ops, ptid_t ptid)
1225 {
1226   struct sim_inferior_data *sim_data
1227     = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NOT_NEEDED);
1228
1229   if (sim_data == NULL)
1230     return 0;
1231
1232   if (ptid_equal (ptid, sim_data->remote_sim_ptid))
1233     /* The simulators' task is always alive.  */
1234     return 1;
1235
1236   return 0;
1237 }
1238
1239 /* Convert a thread ID to a string.  Returns the string in a static
1240    buffer.  */
1241
1242 static char *
1243 gdbsim_pid_to_str (struct target_ops *ops, ptid_t ptid)
1244 {
1245   return normal_pid_to_str (ptid);
1246 }
1247
1248 /* Simulator memory may be accessed after the program has been loaded.  */
1249
1250 static int
1251 gdbsim_has_all_memory (struct target_ops *ops)
1252 {
1253   struct sim_inferior_data *sim_data
1254     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1255
1256   if (!sim_data->program_loaded)
1257     return 0;
1258
1259   return 1;
1260 }
1261
1262 static int
1263 gdbsim_has_memory (struct target_ops *ops)
1264 {
1265   struct sim_inferior_data *sim_data
1266     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1267
1268   if (!sim_data->program_loaded)
1269     return 0;
1270
1271   return 1;
1272 }
1273
1274 /* Define the target subroutine names.  */
1275
1276 struct target_ops gdbsim_ops;
1277
1278 static void
1279 init_gdbsim_ops (void)
1280 {
1281   gdbsim_ops.to_shortname = "sim";
1282   gdbsim_ops.to_longname = "simulator";
1283   gdbsim_ops.to_doc = "Use the compiled-in simulator.";
1284   gdbsim_ops.to_open = gdbsim_open;
1285   gdbsim_ops.to_close = gdbsim_close;
1286   gdbsim_ops.to_detach = gdbsim_detach;
1287   gdbsim_ops.to_resume = gdbsim_resume;
1288   gdbsim_ops.to_wait = gdbsim_wait;
1289   gdbsim_ops.to_fetch_registers = gdbsim_fetch_register;
1290   gdbsim_ops.to_store_registers = gdbsim_store_register;
1291   gdbsim_ops.to_prepare_to_store = gdbsim_prepare_to_store;
1292   gdbsim_ops.deprecated_xfer_memory = gdbsim_xfer_inferior_memory;
1293   gdbsim_ops.to_files_info = gdbsim_files_info;
1294   gdbsim_ops.to_insert_breakpoint = memory_insert_breakpoint;
1295   gdbsim_ops.to_remove_breakpoint = memory_remove_breakpoint;
1296   gdbsim_ops.to_kill = gdbsim_kill;
1297   gdbsim_ops.to_load = gdbsim_load;
1298   gdbsim_ops.to_create_inferior = gdbsim_create_inferior;
1299   gdbsim_ops.to_mourn_inferior = gdbsim_mourn_inferior;
1300   gdbsim_ops.to_stop = gdbsim_stop;
1301   gdbsim_ops.to_thread_alive = gdbsim_thread_alive;
1302   gdbsim_ops.to_pid_to_str = gdbsim_pid_to_str;
1303   gdbsim_ops.to_stratum = process_stratum;
1304   gdbsim_ops.to_has_all_memory = gdbsim_has_all_memory;
1305   gdbsim_ops.to_has_memory = gdbsim_has_memory;
1306   gdbsim_ops.to_has_stack = default_child_has_stack;
1307   gdbsim_ops.to_has_registers = default_child_has_registers;
1308   gdbsim_ops.to_has_execution = default_child_has_execution;
1309   gdbsim_ops.to_magic = OPS_MAGIC;
1310 }
1311
1312 void
1313 _initialize_remote_sim (void)
1314 {
1315   struct cmd_list_element *c;
1316
1317   init_gdbsim_ops ();
1318   add_target (&gdbsim_ops);
1319
1320   c = add_com ("sim", class_obscure, simulator_command,
1321                _("Send a command to the simulator."));
1322   set_cmd_completer (c, sim_command_completer);
1323
1324   sim_inferior_data_key
1325     = register_inferior_data_with_cleanup (sim_inferior_data_cleanup);
1326 }