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