GDB (xrefs)
/tmp/gdb-7.10/gdb/remote-sim.c
Go to the documentation of this file.
1 /* Generic remote debugging interface for simulators.
2 
3  Copyright (C) 1993-2015 Free Software Foundation, Inc.
4 
5  Contributed by Cygnus Support.
6  Steve Chamberlain (sac@cygnus.com).
7 
8  This file is part of GDB.
9 
10  This program is free software; you can redistribute it and/or modify
11  it under the terms of the GNU General Public License as published by
12  the Free Software Foundation; either version 3 of the License, or
13  (at your option) any later version.
14 
15  This program is distributed in the hope that it will be useful,
16  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  GNU General Public License for more details.
19 
20  You should have received a copy of the GNU General Public License
21  along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 
23 #include "defs.h"
24 #include "gdb_bfd.h"
25 #include "inferior.h"
26 #include "infrun.h"
27 #include "value.h"
28 #include <ctype.h>
29 #include <fcntl.h>
30 #include <signal.h>
31 #include <setjmp.h>
32 #include "terminal.h"
33 #include "target.h"
34 #include "gdbcore.h"
35 #include "gdb/callback.h"
36 #include "gdb/remote-sim.h"
37 #include "command.h"
38 #include "regcache.h"
39 #include "sim-regno.h"
40 #include "arch-utils.h"
41 #include "readline/readline.h"
42 #include "gdbthread.h"
43 
44 /* Prototypes */
45 
46 extern void _initialize_remote_sim (void);
47 
48 static void init_callbacks (void);
49 
50 static void end_callbacks (void);
51 
52 static int gdb_os_write_stdout (host_callback *, const char *, int);
53 
54 static void gdb_os_flush_stdout (host_callback *);
55 
56 static int gdb_os_write_stderr (host_callback *, const char *, int);
57 
58 static void gdb_os_flush_stderr (host_callback *);
59 
60 static int gdb_os_poll_quit (host_callback *);
61 
62 /* printf_filtered is depreciated. */
63 static void gdb_os_printf_filtered (host_callback *, const char *, ...);
64 
65 static void gdb_os_vprintf_filtered (host_callback *, const char *, va_list);
66 
67 static void gdb_os_evprintf_filtered (host_callback *, const char *, va_list);
68 
69 static void gdb_os_error (host_callback *, const char *, ...)
70  ATTRIBUTE_NORETURN;
71 
72 static void gdbsim_kill (struct target_ops *);
73 
74 static void gdbsim_load (struct target_ops *self, const char *prog,
75  int fromtty);
76 
77 static void gdbsim_open (const char *args, int from_tty);
78 
79 static void gdbsim_close (struct target_ops *self);
80 
81 static void gdbsim_detach (struct target_ops *ops, const char *args,
82  int from_tty);
83 
84 static void gdbsim_prepare_to_store (struct target_ops *self,
85  struct regcache *regcache);
86 
87 static void gdbsim_files_info (struct target_ops *target);
88 
89 static void gdbsim_mourn_inferior (struct target_ops *target);
90 
91 static void gdbsim_stop (struct target_ops *self, ptid_t ptid);
92 
93 void simulator_command (char *args, int from_tty);
94 
95 /* Naming convention:
96 
97  sim_* are the interface to the simulator (see remote-sim.h).
98  gdbsim_* are stuff which is internal to gdb. */
99 
100 /* Forward data declarations */
101 extern struct target_ops gdbsim_ops;
102 
103 static const struct inferior_data *sim_inferior_data_key;
104 
105 /* Simulator-specific, per-inferior state. */
106 struct sim_inferior_data {
107  /* Flag which indicates whether or not the program has been loaded. */
108  int program_loaded;
109 
110  /* Simulator descriptor for this inferior. */
111  SIM_DESC gdbsim_desc;
112 
113  /* This is the ptid we use for this particular simulator instance. Its
114  value is somewhat arbitrary, as the simulator target don't have a
115  notion of tasks or threads, but we need something non-null to place
116  in inferior_ptid. For simulators which permit multiple instances,
117  we also need a unique identifier to use for each inferior. */
118  ptid_t remote_sim_ptid;
119 
120  /* Signal with which to resume. */
121  enum gdb_signal resume_siggnal;
122 
123  /* Flag which indicates whether resume should step or not. */
124  int resume_step;
125 };
126 
127 /* Flag indicating the "open" status of this module. It's set to 1
128  in gdbsim_open() and 0 in gdbsim_close(). */
129 static int gdbsim_is_open = 0;
130 
131 /* Value of the next pid to allocate for an inferior. As indicated
132  elsewhere, its initial value is somewhat arbitrary; it's critical
133  though that it's not zero or negative. */
134 static int next_pid;
135 #define INITIAL_PID 42000
136 
137 /* Argument list to pass to sim_open(). It is allocated in gdbsim_open()
138  and deallocated in gdbsim_close(). The lifetime needs to extend beyond
139  the call to gdbsim_open() due to the fact that other sim instances other
140  than the first will be allocated after the gdbsim_open() call. */
141 static char **sim_argv = NULL;
142 
143 /* OS-level callback functions for write, flush, etc. */
144 static host_callback gdb_callback;
145 static int callbacks_initialized = 0;
146 
147 /* Callback for iterate_over_inferiors. It checks to see if the sim
148  descriptor passed via ARG is the same as that for the inferior
149  designated by INF. Return true if so; false otherwise. */
150 
151 static int
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 
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 
191  sim_desc);
192  if (idup != NULL)
193  {
194  /* We don't close the descriptor due to the fact that it's
195  shared with some other inferior. If we were to close it,
196  that might needlessly muck up the other inferior. Of
197  course, it's possible that the damage has already been
198  done... Note that it *will* ultimately be closed during
199  cleanup of the other inferior. */
200  sim_desc = NULL;
201  error (
202  _("Inferior %d and inferior %d would have identical simulator state.\n"
203  "(This simulator does not support the running of more than one inferior.)"),
204  inf->num, idup->num);
205  }
206  }
207 
208  if (sim_data == NULL)
209  {
210  sim_data = XCNEW(struct sim_inferior_data);
211  set_inferior_data (inf, sim_inferior_data_key, sim_data);
212 
213  /* Allocate a ptid for this inferior. */
214  sim_data->remote_sim_ptid = ptid_build (next_pid, 0, next_pid);
215  next_pid++;
216 
217  /* Initialize the other instance variables. */
218  sim_data->program_loaded = 0;
219  sim_data->gdbsim_desc = sim_desc;
220  sim_data->resume_siggnal = GDB_SIGNAL_0;
221  sim_data->resume_step = 0;
222  }
223  else if (sim_desc)
224  {
225  /* This handles the case where sim_data was allocated prior to
226  needing a sim instance. */
227  sim_data->gdbsim_desc = sim_desc;
228  }
229 
230 
231  return sim_data;
232 }
233 
234 /* Return pointer to per-inferior simulator data using PTID to find the
235  inferior in question. Return NULL when no inferior is found or
236  when ptid has a zero or negative pid component. */
237 
238 static struct sim_inferior_data *
239 get_sim_inferior_data_by_ptid (ptid_t ptid, int sim_instance_needed)
240 {
241  struct inferior *inf;
242  int pid = ptid_get_pid (ptid);
243 
244  if (pid <= 0)
245  return NULL;
246 
247  inf = find_inferior_pid (pid);
248 
249  if (inf)
250  return get_sim_inferior_data (inf, sim_instance_needed);
251  else
252  return NULL;
253 }
254 
255 /* Free the per-inferior simulator data. */
256 
257 static void
259 {
260  struct sim_inferior_data *sim_data = data;
261 
262  if (sim_data != NULL)
263  {
264  if (sim_data->gdbsim_desc)
265  {
266  sim_close (sim_data->gdbsim_desc, 0);
267  sim_data->gdbsim_desc = NULL;
268  }
269  xfree (sim_data);
270  }
271 }
272 
273 static void
274 dump_mem (const gdb_byte *buf, int len)
275 {
277 
278  if (len == 8 || len == 4)
279  {
280  uint32_t l[2];
281 
282  memcpy (l, buf, len);
283  fprintf_unfiltered (gdb_stdlog, "0x%08x", l[0]);
284  if (len == 8)
285  fprintf_unfiltered (gdb_stdlog, " 0x%08x", l[1]);
286  }
287  else
288  {
289  int i;
290 
291  for (i = 0; i < len; i++)
292  fprintf_unfiltered (gdb_stdlog, "0x%02x ", buf[i]);
293  }
294 
296 }
297 
298 /* Initialize gdb_callback. */
299 
300 static void
302 {
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;
318  }
319 }
320 
321 /* Release callbacks (free resources used by them). */
322 
323 static void
325 {
327  {
328  gdb_callback.shutdown (&gdb_callback);
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 {
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;
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 {
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
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
428  struct regcache *regcache, int regno)
429 {
430  struct gdbarch *gdbarch = get_regcache_arch (regcache);
431  struct sim_inferior_data *sim_data
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  {
444  break;
446  {
447  /* For moment treat a `does not exist' register the same way
448  as an ``unavailable'' register. */
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;
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,
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  {
474  "Size of register %s (%d/%d) "
475  "incorrect (%d instead of %d))",
476  gdbarch_register_name (gdbarch, regno),
477  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  {
492  "gdbsim_fetch_register: %d", regno);
493  /* FIXME: We could print something more intelligible. */
494  dump_mem (buf, register_size (gdbarch, regno));
495  }
496  break;
497  }
498  }
499 }
500 
501 
502 static void
504  struct regcache *regcache, int regno)
505 {
506  struct gdbarch *gdbarch = get_regcache_arch (regcache);
507  struct sim_inferior_data *sim_data
509 
510  if (regno == -1)
511  {
512  for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
513  gdbsim_store_register (ops, regcache, regno);
514  return;
515  }
516  else if (gdbarch_register_sim_regno (gdbarch, regno) >= 0)
517  {
519  int nr_bytes;
520 
521  regcache_cooked_read (regcache, regno, tmp);
522  nr_bytes = sim_store_register (sim_data->gdbsim_desc,
524  (gdbarch, regno),
525  tmp, register_size (gdbarch, regno));
526  if (nr_bytes > 0 && nr_bytes != register_size (gdbarch, regno))
527  internal_error (__FILE__, __LINE__,
528  _("Register size different to expected"));
529  if (nr_bytes < 0)
530  internal_error (__FILE__, __LINE__,
531  _("Register %d not updated"), regno);
532  if (nr_bytes == 0)
533  warning (_("Register %s not updated"),
534  gdbarch_register_name (gdbarch, regno));
535 
536  if (remote_debug)
537  {
538  fprintf_unfiltered (gdb_stdlog, "gdbsim_store_register: %d", regno);
539  /* FIXME: We could print something more intelligible. */
540  dump_mem (tmp, register_size (gdbarch, regno));
541  }
542  }
543 }
544 
545 /* Kill the running program. This may involve closing any open files
546  and releasing other resources acquired by the simulated program. */
547 
548 static void
549 gdbsim_kill (struct target_ops *ops)
550 {
551  if (remote_debug)
552  fprintf_unfiltered (gdb_stdlog, "gdbsim_kill\n");
553 
554  /* There is no need to `kill' running simulator - the simulator is
555  not running. Mourning it is enough. */
557 }
558 
559 /* Load an executable file into the target process. This is expected to
560  not only bring new code into the target process, but also to update
561  GDB's symbol tables to match. */
562 
563 static void
564 gdbsim_load (struct target_ops *self, const char *args, int fromtty)
565 {
566  char **argv;
567  const char *prog;
568  struct sim_inferior_data *sim_data
570 
571  if (args == NULL)
572  error_no_arg (_("program to load"));
573 
574  argv = gdb_buildargv (args);
575  make_cleanup_freeargv (argv);
576 
577  prog = tilde_expand (argv[0]);
578 
579  if (argv[1] != NULL)
580  error (_("GDB sim does not yet support a load offset."));
581 
582  if (remote_debug)
583  fprintf_unfiltered (gdb_stdlog, "gdbsim_load: prog \"%s\"\n", prog);
584 
585  /* FIXME: We will print two messages on error.
586  Need error to either not print anything if passed NULL or need
587  another routine that doesn't take any arguments. */
588  if (sim_load (sim_data->gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL)
589  error (_("unable to load program"));
590 
591  /* FIXME: If a load command should reset the targets registers then
592  a call to sim_create_inferior() should go here. */
593 
594  sim_data->program_loaded = 1;
595 }
596 
597 
598 /* Start an inferior process and set inferior_ptid to its pid.
599  EXEC_FILE is the file to run.
600  ARGS is a string containing the arguments to the program.
601  ENV is the environment vector to pass. Errors reported with error().
602  On VxWorks and various standalone systems, we ignore exec_file. */
603 /* This is called not only when we first attach, but also when the
604  user types "run" after having attached. */
605 
606 static void
607 gdbsim_create_inferior (struct target_ops *target, char *exec_file, char *args,
608  char **env, int from_tty)
609 {
610  struct sim_inferior_data *sim_data
612  int len;
613  char *arg_buf, **argv;
614 
615  if (exec_file == 0 || exec_bfd == 0)
616  warning (_("No executable file specified."));
617  if (!sim_data->program_loaded)
618  warning (_("No program loaded."));
619 
620  if (remote_debug)
622  "gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
623  (exec_file ? exec_file : "(NULL)"),
624  args);
625 
626  if (ptid_equal (inferior_ptid, sim_data->remote_sim_ptid))
627  gdbsim_kill (target);
630 
631  if (exec_file != NULL)
632  {
633  len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop */ 10;
634  arg_buf = (char *) alloca (len);
635  arg_buf[0] = '\0';
636  strcat (arg_buf, exec_file);
637  strcat (arg_buf, " ");
638  strcat (arg_buf, args);
639  argv = gdb_buildargv (arg_buf);
640  make_cleanup_freeargv (argv);
641  }
642  else
643  argv = NULL;
644 
645  if (!have_inferiors ())
646  init_thread_list ();
647 
648  if (sim_create_inferior (sim_data->gdbsim_desc, exec_bfd, argv, env)
649  != SIM_RC_OK)
650  error (_("Unable to create sim inferior."));
651 
652  inferior_ptid = sim_data->remote_sim_ptid;
655 
656  insert_breakpoints (); /* Needed to get correct instruction
657  in cache. */
658 
660 }
661 
662 /* The open routine takes the rest of the parameters from the command,
663  and (if successful) pushes a new target onto the stack.
664  Targets should supply this routine, if only to provide an error message. */
665 /* Called when selecting the simulator. E.g. (gdb) target sim name. */
666 
667 static void
668 gdbsim_open (const char *args, int from_tty)
669 {
670  int len;
671  char *arg_buf;
672  struct sim_inferior_data *sim_data;
673  const char *sysroot;
674  SIM_DESC gdbsim_desc;
675 
676  sysroot = gdb_sysroot;
677  if (is_target_filename (sysroot))
678  sysroot += strlen (TARGET_SYSROOT_PREFIX);
679 
680  if (remote_debug)
682  "gdbsim_open: args \"%s\"\n", args ? args : "(null)");
683 
684  /* Ensure that the sim target is not on the target stack. This is
685  necessary, because if it is on the target stack, the call to
686  push_target below will invoke sim_close(), thus freeing various
687  state (including a sim instance) that we allocate prior to
688  invoking push_target(). We want to delay the push_target()
689  operation until after we complete those operations which could
690  error out. */
691  if (gdbsim_is_open)
693 
694  len = (7 + 1 /* gdbsim */
695  + strlen (" -E little")
696  + strlen (" --architecture=xxxxxxxxxx")
697  + strlen (" --sysroot=") + strlen (sysroot) +
698  + (args ? strlen (args) : 0)
699  + 50) /* slack */ ;
700  arg_buf = (char *) alloca (len);
701  strcpy (arg_buf, "gdbsim"); /* 7 */
702  /* Specify the byte order for the target when it is explicitly
703  specified by the user (not auto detected). */
704  switch (selected_byte_order ())
705  {
706  case BFD_ENDIAN_BIG:
707  strcat (arg_buf, " -E big");
708  break;
709  case BFD_ENDIAN_LITTLE:
710  strcat (arg_buf, " -E little");
711  break;
712  case BFD_ENDIAN_UNKNOWN:
713  break;
714  }
715  /* Specify the architecture of the target when it has been
716  explicitly specified */
717  if (selected_architecture_name () != NULL)
718  {
719  strcat (arg_buf, " --architecture=");
720  strcat (arg_buf, selected_architecture_name ());
721  }
722  /* Pass along gdb's concept of the sysroot. */
723  strcat (arg_buf, " --sysroot=");
724  strcat (arg_buf, sysroot);
725  /* finally, any explicit args */
726  if (args)
727  {
728  strcat (arg_buf, " "); /* 1 */
729  strcat (arg_buf, args);
730  }
731  sim_argv = gdb_buildargv (arg_buf);
732 
733  init_callbacks ();
734  gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, sim_argv);
735 
736  if (gdbsim_desc == 0)
737  {
738  freeargv (sim_argv);
739  sim_argv = NULL;
740  error (_("unable to create simulator instance"));
741  }
742 
743  /* Reset the pid numberings for this batch of sim instances. */
745 
746  /* Allocate the inferior data, but do not allocate a sim instance
747  since we've already just done that. */
750 
751  sim_data->gdbsim_desc = gdbsim_desc;
752 
754  printf_filtered ("Connected to the simulator.\n");
755 
756  /* There's nothing running after "target sim" or "load"; not until
757  "run". */
759 
760  gdbsim_is_open = 1;
761 }
762 
763 /* Callback for iterate_over_inferiors. Called (indirectly) by
764  gdbsim_close(). */
765 
766 static int
767 gdbsim_close_inferior (struct inferior *inf, void *arg)
768 {
769  struct sim_inferior_data *sim_data = inferior_data (inf,
770  sim_inferior_data_key);
771  if (sim_data != NULL)
772  {
773  ptid_t ptid = sim_data->remote_sim_ptid;
774 
775  sim_inferior_data_cleanup (inf, sim_data);
776  set_inferior_data (inf, sim_inferior_data_key, NULL);
777 
778  /* Having a ptid allocated and stored in remote_sim_ptid does
779  not mean that a corresponding inferior was ever created.
780  Thus we need to verify the existence of an inferior using the
781  pid in question before setting inferior_ptid via
782  switch_to_thread() or mourning the inferior. */
783  if (find_inferior_ptid (ptid) != NULL)
784  {
785  switch_to_thread (ptid);
787  }
788  }
789 
790  return 0;
791 }
792 
793 /* Close out all files and local state before this target loses control. */
794 
795 static void
796 gdbsim_close (struct target_ops *self)
797 {
798  struct sim_inferior_data *sim_data
800 
801  if (remote_debug)
802  fprintf_unfiltered (gdb_stdlog, "gdbsim_close\n");
803 
805 
806  if (sim_argv != NULL)
807  {
808  freeargv (sim_argv);
809  sim_argv = NULL;
810  }
811 
812  end_callbacks ();
813 
814  gdbsim_is_open = 0;
815 }
816 
817 /* Takes a program previously attached to and detaches it.
818  The program may resume execution (some targets do, some don't) and will
819  no longer stop on signals, etc. We better not have left any breakpoints
820  in the program or it'll die when it hits one. ARGS is arguments
821  typed by the user (e.g. a signal to send the process). FROM_TTY
822  says whether to be verbose or not. */
823 /* Terminate the open connection to the remote debugger.
824  Use this when you want to detach and do something else with your gdb. */
825 
826 static void
827 gdbsim_detach (struct target_ops *ops, const char *args, int from_tty)
828 {
829  if (remote_debug)
830  fprintf_unfiltered (gdb_stdlog, "gdbsim_detach: args \"%s\"\n", args);
831 
832  unpush_target (ops); /* calls gdbsim_close to do the real work */
833  if (from_tty)
834  printf_filtered ("Ending simulator %s debugging\n", target_shortname);
835 }
836 
837 /* Resume execution of the target process. STEP says whether to single-step
838  or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
839  to the target, or zero for no signal. */
840 
842 {
843  enum gdb_signal siggnal;
844  int step;
845 };
846 
847 static int
848 gdbsim_resume_inferior (struct inferior *inf, void *arg)
849 {
850  struct sim_inferior_data *sim_data
852  struct resume_data *rd = arg;
853 
854  if (sim_data)
855  {
856  sim_data->resume_siggnal = rd->siggnal;
857  sim_data->resume_step = rd->step;
858 
859  if (remote_debug)
861  _("gdbsim_resume: pid %d, step %d, signal %d\n"),
862  inf->pid, rd->step, rd->siggnal);
863  }
864 
865  /* When called from iterate_over_inferiors, a zero return causes the
866  iteration process to proceed until there are no more inferiors to
867  consider. */
868  return 0;
869 }
870 
871 static void
873  ptid_t ptid, int step, enum gdb_signal siggnal)
874 {
875  struct resume_data rd;
876  struct sim_inferior_data *sim_data
878 
879  rd.siggnal = siggnal;
880  rd.step = step;
881 
882  /* We don't access any sim_data members within this function.
883  What's of interest is whether or not the call to
884  get_sim_inferior_data_by_ptid(), above, is able to obtain a
885  non-NULL pointer. If it managed to obtain a non-NULL pointer, we
886  know we have a single inferior to consider. If it's NULL, we
887  either have multiple inferiors to resume or an error condition. */
888 
889  if (sim_data)
891  else if (ptid_equal (ptid, minus_one_ptid))
893  else
894  error (_("The program is not being run."));
895 }
896 
897 /* Notify the simulator of an asynchronous request to stop.
898 
899  The simulator shall ensure that the stop request is eventually
900  delivered to the simulator. If the call is made while the
901  simulator is not running then the stop request is processed when
902  the simulator is next resumed.
903 
904  For simulators that do not support this operation, just abort. */
905 
906 static int
907 gdbsim_stop_inferior (struct inferior *inf, void *arg)
908 {
909  struct sim_inferior_data *sim_data
911 
912  if (sim_data)
913  {
914  if (!sim_stop (sim_data->gdbsim_desc))
915  {
916  quit ();
917  }
918  }
919 
920  /* When called from iterate_over_inferiors, a zero return causes the
921  iteration process to proceed until there are no more inferiors to
922  consider. */
923  return 0;
924 }
925 
926 static void
928 {
929  struct sim_inferior_data *sim_data;
930 
931  if (ptid_equal (ptid, minus_one_ptid))
932  {
934  }
935  else
936  {
937  struct inferior *inf = find_inferior_ptid (ptid);
938 
939  if (inf == NULL)
940  error (_("Can't stop pid %d. No inferior found."),
941  ptid_get_pid (ptid));
942 
943  gdbsim_stop_inferior (inf, NULL);
944  }
945 }
946 
947 /* GDB version of os_poll_quit callback.
948  Taken from gdb/util.c - should be in a library. */
949 
950 static int
951 gdb_os_poll_quit (host_callback *p)
952 {
953  if (deprecated_ui_loop_hook != NULL)
955 
956  if (check_quit_flag ()) /* gdb's idea of quit */
957  {
958  clear_quit_flag (); /* we've stolen it */
959  return 1;
960  }
961  return 0;
962 }
963 
964 /* Wait for inferior process to do something. Return pid of child,
965  or -1 in case of error; store status through argument pointer STATUS,
966  just as `wait' would. */
967 
968 static void
969 gdbsim_cntrl_c (int signo)
970 {
971  gdbsim_stop (NULL, minus_one_ptid);
972 }
973 
974 static ptid_t
975 gdbsim_wait (struct target_ops *ops,
976  ptid_t ptid, struct target_waitstatus *status, int options)
977 {
978  struct sim_inferior_data *sim_data;
979  static RETSIGTYPE (*prev_sigint) ();
980  int sigrc = 0;
981  enum sim_stop reason = sim_running;
982 
983  /* This target isn't able to (yet) resume more than one inferior at a time.
984  When ptid is minus_one_ptid, just use the current inferior. If we're
985  given an explicit pid, we'll try to find it and use that instead. */
986  if (ptid_equal (ptid, minus_one_ptid))
989  else
990  {
992  if (sim_data == NULL)
993  error (_("Unable to wait for pid %d. Inferior not found."),
994  ptid_get_pid (ptid));
995  inferior_ptid = ptid;
996  }
997 
998  if (remote_debug)
999  fprintf_unfiltered (gdb_stdlog, "gdbsim_wait\n");
1000 
1001 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1002  {
1003  struct sigaction sa, osa;
1004  sa.sa_handler = gdbsim_cntrl_c;
1005  sigemptyset (&sa.sa_mask);
1006  sa.sa_flags = 0;
1007  sigaction (SIGINT, &sa, &osa);
1008  prev_sigint = osa.sa_handler;
1009  }
1010 #else
1011  prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
1012 #endif
1013  sim_resume (sim_data->gdbsim_desc, sim_data->resume_step,
1014  sim_data->resume_siggnal);
1015 
1016  signal (SIGINT, prev_sigint);
1017  sim_data->resume_step = 0;
1018 
1019  sim_stop_reason (sim_data->gdbsim_desc, &reason, &sigrc);
1020 
1021  switch (reason)
1022  {
1023  case sim_exited:
1024  status->kind = TARGET_WAITKIND_EXITED;
1025  status->value.integer = sigrc;
1026  break;
1027  case sim_stopped:
1028  switch (sigrc)
1029  {
1030  case GDB_SIGNAL_ABRT:
1031  quit ();
1032  break;
1033  case GDB_SIGNAL_INT:
1034  case GDB_SIGNAL_TRAP:
1035  default:
1036  status->kind = TARGET_WAITKIND_STOPPED;
1037  status->value.sig = sigrc;
1038  break;
1039  }
1040  break;
1041  case sim_signalled:
1042  status->kind = TARGET_WAITKIND_SIGNALLED;
1043  status->value.sig = sigrc;
1044  break;
1045  case sim_running:
1046  case sim_polling:
1047  /* FIXME: Is this correct? */
1048  break;
1049  }
1050 
1051  return inferior_ptid;
1052 }
1053 
1054 /* Get ready to modify the registers array. On machines which store
1055  individual registers, this doesn't need to do anything. On machines
1056  which store all the registers in one fell swoop, this makes sure
1057  that registers contains all the registers from the program being
1058  debugged. */
1059 
1060 static void
1062 {
1063  /* Do nothing, since we can store individual regs. */
1064 }
1065 
1066 /* Helper for gdbsim_xfer_partial that handles memory transfers.
1067  Arguments are like target_xfer_partial. */
1068 
1069 static enum target_xfer_status
1071  gdb_byte *readbuf, const gdb_byte *writebuf,
1072  ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
1073 {
1074  struct sim_inferior_data *sim_data
1076  int l;
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 TARGET_XFER_EOF;
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)
1097  "gdbsim_xfer_memory: readbuf %s, writebuf %s, "
1098  "memaddr %s, len %s\n",
1099  host_address_to_string (readbuf),
1100  host_address_to_string (writebuf),
1101  paddress (target_gdbarch (), memaddr),
1102  pulongest (len));
1103 
1104  if (writebuf)
1105  {
1106  if (remote_debug && len > 0)
1107  dump_mem (writebuf, len);
1108  l = sim_write (sim_data->gdbsim_desc, memaddr, writebuf, len);
1109  }
1110  else
1111  {
1112  l = sim_read (sim_data->gdbsim_desc, memaddr, readbuf, len);
1113  if (remote_debug && len > 0)
1114  dump_mem (readbuf, len);
1115  }
1116  if (l > 0)
1117  {
1118  *xfered_len = (ULONGEST) l;
1119  return TARGET_XFER_OK;
1120  }
1121  else if (l == 0)
1122  return TARGET_XFER_EOF;
1123  else
1124  return TARGET_XFER_E_IO;
1125 }
1126 
1127 /* Target to_xfer_partial implementation. */
1128 
1129 static enum target_xfer_status
1131  const char *annex, gdb_byte *readbuf,
1132  const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
1133  ULONGEST *xfered_len)
1134 {
1135  switch (object)
1136  {
1137  case TARGET_OBJECT_MEMORY:
1138  return gdbsim_xfer_memory (ops, readbuf, writebuf, offset, len,
1139  xfered_len);
1140 
1141  default:
1142  return TARGET_XFER_E_IO;
1143  }
1144 }
1145 
1146 static void
1148 {
1149  struct sim_inferior_data *sim_data
1151  const char *file = "nothing";
1152 
1153  if (exec_bfd)
1154  file = bfd_get_filename (exec_bfd);
1155 
1156  if (remote_debug)
1157  fprintf_unfiltered (gdb_stdlog, "gdbsim_files_info: file \"%s\"\n", file);
1158 
1159  if (exec_bfd)
1160  {
1161  fprintf_unfiltered (gdb_stdlog, "\tAttached to %s running program %s\n",
1162  target_shortname, file);
1163  sim_info (sim_data->gdbsim_desc, 0);
1164  }
1165 }
1166 
1167 /* Clear the simulator's notion of what the break points are. */
1168 
1169 static void
1171 {
1172  struct sim_inferior_data *sim_data
1174 
1175  if (remote_debug)
1176  fprintf_unfiltered (gdb_stdlog, "gdbsim_mourn_inferior:\n");
1177 
1178  remove_breakpoints ();
1180  delete_thread_silent (sim_data->remote_sim_ptid);
1181 }
1182 
1183 /* Pass the command argument through to the simulator verbatim. The
1184  simulator must do any command interpretation work. */
1185 
1186 void
1187 simulator_command (char *args, int from_tty)
1188 {
1189  struct sim_inferior_data *sim_data;
1190 
1191  /* We use inferior_data() instead of get_sim_inferior_data() here in
1192  order to avoid attaching a sim_inferior_data struct to an
1193  inferior unnecessarily. The reason we take such care here is due
1194  to the fact that this function, simulator_command(), may be called
1195  even when the sim target is not active. If we were to use
1196  get_sim_inferior_data() here, it is possible that this call would
1197  be made either prior to gdbsim_open() or after gdbsim_close(),
1198  thus allocating memory that would not be garbage collected until
1199  the ultimate destruction of the associated inferior. */
1200 
1201  sim_data = inferior_data (current_inferior (), sim_inferior_data_key);
1202  if (sim_data == NULL || sim_data->gdbsim_desc == NULL)
1203  {
1204 
1205  /* PREVIOUSLY: The user may give a command before the simulator
1206  is opened. [...] (??? assuming of course one wishes to
1207  continue to allow commands to be sent to unopened simulators,
1208  which isn't entirely unreasonable). */
1209 
1210  /* The simulator is a builtin abstraction of a remote target.
1211  Consistent with that model, access to the simulator, via sim
1212  commands, is restricted to the period when the channel to the
1213  simulator is open. */
1214 
1215  error (_("Not connected to the simulator target"));
1216  }
1217 
1218  sim_do_command (sim_data->gdbsim_desc, args);
1219 
1220  /* Invalidate the register cache, in case the simulator command does
1221  something funny. */
1222  registers_changed ();
1223 }
1224 
1225 static VEC (char_ptr) *
1226 sim_command_completer (struct cmd_list_element *ignore, const char *text,
1227  const char *word)
1228 {
1229  struct sim_inferior_data *sim_data;
1230  char **tmp;
1231  int i;
1232  VEC (char_ptr) *result = NULL;
1233 
1234  sim_data = inferior_data (current_inferior (), sim_inferior_data_key);
1235  if (sim_data == NULL || sim_data->gdbsim_desc == NULL)
1236  return NULL;
1237 
1238  tmp = sim_complete_command (sim_data->gdbsim_desc, text, word);
1239  if (tmp == NULL)
1240  return NULL;
1241 
1242  /* Transform the array into a VEC, and then free the array. */
1243  for (i = 0; tmp[i] != NULL; i++)
1244  VEC_safe_push (char_ptr, result, tmp[i]);
1245  xfree (tmp);
1246 
1247  return result;
1248 }
1249 
1250 /* Check to see if a thread is still alive. */
1251 
1252 static int
1254 {
1255  struct sim_inferior_data *sim_data
1257 
1258  if (sim_data == NULL)
1259  return 0;
1260 
1261  if (ptid_equal (ptid, sim_data->remote_sim_ptid))
1262  /* The simulators' task is always alive. */
1263  return 1;
1264 
1265  return 0;
1266 }
1267 
1268 /* Convert a thread ID to a string. Returns the string in a static
1269  buffer. */
1270 
1271 static char *
1273 {
1274  return normal_pid_to_str (ptid);
1275 }
1276 
1277 /* Simulator memory may be accessed after the program has been loaded. */
1278 
1279 static int
1281 {
1282  struct sim_inferior_data *sim_data
1284 
1285  if (!sim_data->program_loaded)
1286  return 0;
1287 
1288  return 1;
1289 }
1290 
1291 static int
1293 {
1294  struct sim_inferior_data *sim_data
1296 
1297  if (!sim_data->program_loaded)
1298  return 0;
1299 
1300  return 1;
1301 }
1302 
1303 /* Define the target subroutine names. */
1304 
1306 
1307 static void
1309 {
1310  gdbsim_ops.to_shortname = "sim";
1311  gdbsim_ops.to_longname = "simulator";
1312  gdbsim_ops.to_doc = "Use the compiled-in simulator.";
1339 }
1340 
1341 void
1343 {
1344  struct cmd_list_element *c;
1345 
1346  init_gdbsim_ops ();
1348 
1350  _("Send a command to the simulator."));
1351  set_cmd_completer (c, sim_command_completer);
1352 
1353  sim_inferior_data_key
1354  = register_inferior_data_with_cleanup (NULL, sim_inferior_data_cleanup);
1355 }
void error_no_arg(const char *why)
Definition: cli-cmds.c:205
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5143
struct cleanup * make_cleanup_freeargv(char **arg)
Definition: utils.c:165
void add_target(struct target_ops *t)
Definition: target.c:395
int default_child_has_stack(struct target_ops *ops)
Definition: target.c:216
static void sim_inferior_data_cleanup(struct inferior *inf, void *data)
Definition: remote-sim.c:258
static void gdbsim_stop(struct target_ops *self, ptid_t ptid)
Definition: remote-sim.c:927
static void gdbsim_detach(struct target_ops *ops, const char *args, int from_tty)
Definition: remote-sim.c:827
const char * to_longname
Definition: target.h:433
static enum target_xfer_status gdbsim_xfer_memory(struct target_ops *target, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
Definition: remote-sim.c:1070
int have_inferiors(void)
Definition: inferior.c:460
int one2one_register_sim_regno(struct gdbarch *gdbarch, int regnum)
Definition: remote-sim.c:419
int ptid_equal(ptid_t ptid1, ptid_t ptid2)
Definition: ptid.c:76
#define target_shortname
Definition: target.h:1242
void insert_breakpoints(void)
Definition: breakpoint.c:2984
void fputs_unfiltered(const char *buf, struct ui_file *file)
Definition: ui-file.c:252
void xfree(void *)
Definition: common-utils.c:97
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
Definition: regcache.c:297
void clear_quit_flag(void)
Definition: extension.c:793
int(* to_has_memory)(struct target_ops *)
Definition: target.h:652
void warning(const char *fmt,...)
Definition: errors.c:26
char *(* to_pid_to_str)(struct target_ops *, ptid_t) TARGET_DEFAULT_FUNC(default_pid_to_str)
Definition: target.h:631
struct type ** const(pascal_builtin_types[])
void init_wait_for_inferior(void)
Definition: infrun.c:2802
tuple inf
Definition: arm-linux.py:13
int(* to_has_stack)(struct target_ops *)
Definition: target.h:653
void push_target(struct target_ops *t)
Definition: target.c:664
int(* to_insert_breakpoint)(struct target_ops *, struct gdbarch *, struct bp_target_info *) TARGET_DEFAULT_FUNC(memory_insert_breakpoint)
Definition: target.h:481
void delete_thread_silent(ptid_t)
Definition: thread.c:374
struct ui_file * gdb_stdout
Definition: main.c:71
int pid
Definition: inferior.h:299
int unpush_target(struct target_ops *t)
Definition: target.c:711
void simulator_command(char *args, int from_tty)
Definition: remote-sim.c:1187
enum bfd_endian selected_byte_order(void)
Definition: arch-utils.c:291
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
int num
Definition: inferior.h:295
void generic_mourn_inferior(void)
Definition: target.c:3171
void(* to_close)(struct target_ops *)
Definition: target.h:448
void switch_to_thread(ptid_t ptid)
Definition: thread.c:1185
static int gdbsim_stop_inferior(struct inferior *inf, void *arg)
Definition: remote-sim.c:907
static host_callback gdb_callback
Definition: remote-sim.c:144
#define VEC_safe_push(T, V, O)
Definition: vec.h:260
struct inferior * find_inferior_ptid(ptid_t ptid)
Definition: inferior.c:373
int(* to_remove_breakpoint)(struct target_ops *, struct gdbarch *, struct bp_target_info *) TARGET_DEFAULT_FUNC(memory_remove_breakpoint)
Definition: target.h:484
struct inferior * iterate_over_inferiors(int(*callback)(struct inferior *, void *), void *data)
Definition: inferior.c:398
int remote_debug
Definition: top.c:166
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:1898
ptid_t(* to_wait)(struct target_ops *, ptid_t, struct target_waitstatus *, int TARGET_DEBUG_PRINTER(target_debug_print_options)) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:468
static int next_pid
Definition: remote-sim.c:134
#define _(String)
Definition: gdb_locale.h:40
static int gdb_os_write_stderr(host_callback *, const char *, int)
Definition: remote-sim.c:356
static void gdbsim_files_info(struct target_ops *target)
Definition: remote-sim.c:1147
char * char_ptr
Definition: gdb_vecs.h:25
int default_child_has_execution(struct target_ops *ops, ptid_t the_ptid)
Definition: target.c:236
static void gdb_os_flush_stderr(host_callback *)
Definition: remote-sim.c:373
#define INITIAL_PID
Definition: remote-sim.c:135
static int gdbsim_resume_inferior(struct inferior *inf, void *arg)
Definition: remote-sim.c:848
void printf_filtered(const char *format,...)
Definition: utils.c:2388
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2743
Definition: ptid.h:35
void quit(void)
Definition: utils.c:1021
ptid_t ptid_build(int pid, long lwp, long tid)
Definition: ptid.c:31
void(* to_files_info)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:479
#define TARGET_SYSROOT_PREFIX
Definition: gdb_bfd.h:30
const char * selected_architecture_name(void)
Definition: arch-utils.c:448
static int gdbsim_has_all_memory(struct target_ops *ops)
Definition: remote-sim.c:1280
#define OPS_MAGIC
Definition: target.h:1233
static void gdbsim_cntrl_c(int signo)
Definition: remote-sim.c:969
#define exec_bfd
Definition: exec.h:32
char * gdb_sysroot
Definition: main.c:57
void void void void verror(const char *fmt, va_list args) ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF(1
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition: cli-decode.c:159
enum gdb_signal sig
Definition: waitstatus.h:108
static void init_gdbsim_ops(void)
Definition: remote-sim.c:1308
void vfprintf_filtered(struct ui_file *stream, const char *format, va_list args)
Definition: utils.c:2302
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
Definition: gnu-nat.c:1816
void(* to_resume)(struct target_ops *, ptid_t, int TARGET_DEBUG_PRINTER(target_debug_print_step), enum gdb_signal) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:464
static void gdbsim_fetch_register(struct target_ops *ops, struct regcache *regcache, int regno)
Definition: remote-sim.c:427
static void gdbsim_resume(struct target_ops *ops, ptid_t ptid, int step, enum gdb_signal siggnal)
Definition: remote-sim.c:872
union target_waitstatus::@161 value
target_xfer_status
Definition: target.h:219
int(* to_has_execution)(struct target_ops *, ptid_t)
Definition: target.h:655
int gdbarch_register_sim_regno(struct gdbarch *gdbarch, int reg_nr)
Definition: gdbarch.c:2322
struct inferior * find_inferior_pid(int pid)
Definition: inferior.c:354
const char * word
Definition: symtab.h:1448
static int gdb_os_poll_quit(host_callback *)
Definition: remote-sim.c:951
static void gdb_os_evprintf_filtered(host_callback *, const char *, va_list)
Definition: remote-sim.c:401
Definition: gnu-nat.c:163
void target_mourn_inferior(void)
Definition: target.c:2300
#define gdb_assert(expr)
Definition: gdb_assert.h:33
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
Definition: gdbarch.c:2117
const char * to_doc
Definition: target.h:434
struct thread_info * add_thread_silent(ptid_t ptid)
Definition: thread.c:240
static void gdbsim_prepare_to_store(struct target_ops *self, struct regcache *regcache)
Definition: remote-sim.c:1061
enum target_xfer_status(* to_xfer_partial)(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) TARGET_DEFAULT_RETURN(TARGET_XFER_E_IO)
Definition: target.h:724
static VEC(char_ptr)
Definition: remote-sim.c:1225
static char ** sim_argv
Definition: remote-sim.c:141
int regnum
Definition: aarch64-tdep.c:69
void(* to_detach)(struct target_ops *ops, const char *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:460
struct ui_file * gdb_stdlog
Definition: main.c:73
target_object
Definition: target.h:136
static int gdbsim_is_open
Definition: remote-sim.c:129
char * normal_pid_to_str(ptid_t ptid)
Definition: target.c:3207
static void init_callbacks(void)
Definition: remote-sim.c:301
static void gdbsim_close(struct target_ops *self)
Definition: remote-sim.c:796
int ptid_get_pid(ptid_t ptid)
Definition: ptid.c:52
static void gdb_os_flush_stdout(host_callback *)
Definition: remote-sim.c:348
bfd_byte gdb_byte
Definition: common-types.h:38
ptid_t null_ptid
Definition: ptid.c:25
void(* to_fetch_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:472
void(* to_mourn_inferior)(struct target_ops *) TARGET_DEFAULT_FUNC(default_mourn_inferior)
Definition: target.h:607
static int gdbsim_has_memory(struct target_ops *ops)
Definition: remote-sim.c:1292
int default_child_has_registers(struct target_ops *ops)
Definition: target.c:226
void(* to_stop)(struct target_ops *, ptid_t) TARGET_DEFAULT_IGNORE()
Definition: target.h:637
void clear_proceed_status(int step)
Definition: infrun.c:2463
int check_quit_flag(void)
Definition: extension.c:831
enum target_waitkind kind
Definition: waitstatus.h:100
void(* to_kill)(struct target_ops *) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:575
struct ui_file * gdb_stderr
Definition: main.c:72
ptid_t inferior_ptid
Definition: infcmd.c:124
enum strata to_stratum
Definition: target.h:650
static void gdb_os_printf_filtered(host_callback *, const char *,...)
Definition: remote-sim.c:381
int remove_breakpoints(void)
Definition: breakpoint.c:3184
static char * gdbsim_pid_to_str(struct target_ops *ops, ptid_t ptid)
Definition: remote-sim.c:1272
void(* to_open)(const char *, int)
Definition: target.h:443
void ui_file_write(struct ui_file *file, const char *buf, long length_buf)
Definition: ui-file.c:218
int offset
Definition: agent.c:65
void registers_changed(void)
Definition: regcache.c:624
static struct sim_inferior_data * get_sim_inferior_data(struct inferior *inf, int sim_instance_needed)
Definition: remote-sim.c:171
enum register_status regcache_cooked_read(struct regcache *regcache, int regnum, gdb_byte *buf)
Definition: regcache.c:737
void(* to_create_inferior)(struct target_ops *, char *, char *, char **, int)
Definition: target.h:584
char ** gdb_buildargv(const char *s)
Definition: utils.c:3036
static struct sim_inferior_data * get_sim_inferior_data_by_ptid(ptid_t ptid, int sim_instance_needed)
Definition: remote-sim.c:239
struct ui_file * gdb_stdtarg
Definition: main.c:77
static void end_callbacks(void)
Definition: remote-sim.c:324
struct inferior * current_inferior(void)
Definition: inferior.c:57
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
Definition: regcache.c:1041
const char * to_shortname
Definition: target.h:432
static void gdbsim_open(const char *args, int from_tty)
Definition: remote-sim.c:668
unsigned long long ULONGEST
Definition: common-types.h:53
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:917
int to_magic
Definition: target.h:1224
static int gdbsim_close_inferior(struct inferior *inf, void *arg)
Definition: remote-sim.c:767
int register_size(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:169
static void gdbsim_load(struct target_ops *self, const char *args, int fromtty)
Definition: remote-sim.c:564
static void gdb_os_error(host_callback *, const char *,...)
Definition: remote-sim.c:69
static void gdbsim_create_inferior(struct target_ops *target, char *exec_file, char *args, char **env, int from_tty)
Definition: remote-sim.c:607
int memory_insert_breakpoint(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: mem-break.c:88
static void gdbsim_store_register(struct target_ops *ops, struct regcache *regcache, int regno)
Definition: remote-sim.c:503
int(* to_has_all_memory)(struct target_ops *)
Definition: target.h:651
int memory_remove_breakpoint(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: mem-break.c:95
struct ui_file * gdb_stdtargerr
Definition: main.c:78
int(* to_thread_alive)(struct target_ops *, ptid_t ptid) TARGET_DEFAULT_RETURN(0)
Definition: target.h:627
static enum target_xfer_status gdbsim_xfer_partial(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
Definition: remote-sim.c:1130
static int callbacks_initialized
Definition: remote-sim.c:145
#define RETSIGTYPE
Definition: config.h:679
static int check_for_duplicate_sim_descriptor(struct inferior *inf, void *arg)
Definition: remote-sim.c:152
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:192
void _initialize_remote_sim(void)
Definition: remote-sim.c:1342
void(* to_prepare_to_store)(struct target_ops *, struct regcache *) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:476
void(* to_store_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:474
static void gdbsim_kill(struct target_ops *ops)
Definition: remote-sim.c:549
int(* to_has_registers)(struct target_ops *)
Definition: target.h:654
static void gdbsim_mourn_inferior(struct target_ops *target)
Definition: remote-sim.c:1170
int is_target_filename(const char *name)
Definition: gdb_bfd.c:145
struct target_ops gdbsim_ops
Definition: remote-sim.c:1305
static void dump_mem(const gdb_byte *buf, int len)
Definition: remote-sim.c:274
void error(const char *fmt,...)
Definition: errors.c:38
ptid_t minus_one_ptid
Definition: ptid.c:26
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:873
static ptid_t gdbsim_wait(struct target_ops *ops, ptid_t ptid, struct target_waitstatus *status, int options)
Definition: remote-sim.c:975
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int int rusage_t pid_t pid
Definition: gnu-nat.c:1818
void inferior_appeared(struct inferior *inf, int pid)
Definition: inferior.c:320
void(* to_load)(struct target_ops *, const char *, int) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:577
static int gdbsim_thread_alive(struct target_ops *ops, ptid_t ptid)
Definition: remote-sim.c:1253
int(* deprecated_ui_loop_hook)(int signo)
Definition: top.c:180
enum gdb_signal siggnal
Definition: remote-sim.c:843
void init_thread_list(void)
Definition: thread.c:198
static int gdb_os_write_stdout(host_callback *, const char *, int)
Definition: remote-sim.c:336
static void gdb_os_vprintf_filtered(host_callback *, const char *, va_list)
Definition: remote-sim.c:393
const ULONGEST const LONGEST len
Definition: target.h:309