GDB (xrefs)
/tmp/gdb-7.10/gdb/target.c
Go to the documentation of this file.
1 /* Select target systems and architectures at runtime for GDB.
2 
3  Copyright (C) 1990-2015 Free Software Foundation, Inc.
4 
5  Contributed by Cygnus Support.
6 
7  This file is part of GDB.
8 
9  This program is free software; you can redistribute it and/or modify
10  it under the terms of the GNU General Public License as published by
11  the Free Software Foundation; either version 3 of the License, or
12  (at your option) any later version.
13 
14  This program is distributed in the hope that it will be useful,
15  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  GNU General Public License for more details.
18 
19  You should have received a copy of the GNU General Public License
20  along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 
22 #include "defs.h"
23 #include "target.h"
24 #include "target-dcache.h"
25 #include "gdbcmd.h"
26 #include "symtab.h"
27 #include "inferior.h"
28 #include "infrun.h"
29 #include "bfd.h"
30 #include "symfile.h"
31 #include "objfiles.h"
32 #include "dcache.h"
33 #include <signal.h>
34 #include "regcache.h"
35 #include "gdbcore.h"
36 #include "target-descriptions.h"
37 #include "gdbthread.h"
38 #include "solib.h"
39 #include "exec.h"
40 #include "inline-frame.h"
41 #include "tracepoint.h"
42 #include "gdb/fileio.h"
43 #include "agent.h"
44 #include "auxv.h"
45 #include "target-debug.h"
46 
47 static void target_info (char *, int);
48 
49 static void generic_tls_error (void) ATTRIBUTE_NORETURN;
50 
51 static void default_terminal_info (struct target_ops *, const char *, int);
52 
53 static int default_watchpoint_addr_within_range (struct target_ops *,
54  CORE_ADDR, CORE_ADDR, int);
55 
56 static int default_region_ok_for_hw_watchpoint (struct target_ops *,
57  CORE_ADDR, int);
58 
59 static void default_rcmd (struct target_ops *, const char *, struct ui_file *);
60 
61 static ptid_t default_get_ada_task_ptid (struct target_ops *self,
62  long lwp, long tid);
63 
64 static int default_follow_fork (struct target_ops *self, int follow_child,
65  int detach_fork);
66 
67 static void default_mourn_inferior (struct target_ops *self);
68 
69 static int default_search_memory (struct target_ops *ops,
70  CORE_ADDR start_addr,
71  ULONGEST search_space_len,
72  const gdb_byte *pattern,
73  ULONGEST pattern_len,
74  CORE_ADDR *found_addrp);
75 
76 static int default_verify_memory (struct target_ops *self,
77  const gdb_byte *data,
78  CORE_ADDR memaddr, ULONGEST size);
79 
81  (struct target_ops *self, ptid_t ptid);
82 
83 static void tcomplain (void) ATTRIBUTE_NORETURN;
84 
85 static int return_zero (struct target_ops *);
86 
87 static int return_zero_has_execution (struct target_ops *, ptid_t);
88 
89 static void target_command (char *, int);
90 
91 static struct target_ops *find_default_run_target (char *);
92 
93 static struct gdbarch *default_thread_architecture (struct target_ops *ops,
94  ptid_t ptid);
95 
96 static int dummy_find_memory_regions (struct target_ops *self,
98  void *ignore2);
99 
100 static char *dummy_make_corefile_notes (struct target_ops *self,
101  bfd *ignore1, int *ignore2);
102 
103 static char *default_pid_to_str (struct target_ops *ops, ptid_t ptid);
104 
106  (struct target_ops *self);
107 
108 static struct target_ops debug_target;
109 
110 #include "target-delegates.c"
111 
112 static void init_dummy_target (void);
113 
114 static void update_current_target (void);
115 
116 /* Vector of existing target structures. */
117 typedef struct target_ops *target_ops_p;
118 DEF_VEC_P (target_ops_p);
119 static VEC (target_ops_p) *target_structs;
120 
121 /* The initial current target, so that there is always a semi-valid
122  current target. */
123 
124 static struct target_ops dummy_target;
125 
126 /* Top of target stack. */
127 
128 static struct target_ops *target_stack;
129 
130 /* The target structure we are currently using to talk to a process
131  or file or whatever "inferior" we have. */
132 
133 struct target_ops current_target;
134 
135 /* Command list for target. */
136 
137 static struct cmd_list_element *targetlist = NULL;
138 
139 /* Nonzero if we should trust readonly sections from the
140  executable when reading memory. */
141 
142 static int trust_readonly = 0;
143 
144 /* Nonzero if we should show true memory content including
145  memory breakpoint inserted by gdb. */
146 
147 static int show_memory_breakpoints = 0;
148 
149 /* These globals control whether GDB attempts to perform these
150  operations; they are useful for targets that need to prevent
151  inadvertant disruption, such as in non-stop mode. */
152 
153 int may_write_registers = 1;
154 
155 int may_write_memory = 1;
156 
157 int may_insert_breakpoints = 1;
158 
159 int may_insert_tracepoints = 1;
160 
161 int may_insert_fast_tracepoints = 1;
162 
163 int may_stop = 1;
164 
165 /* Non-zero if we want to see trace of target level stuff. */
166 
167 static unsigned int targetdebug = 0;
168 
169 static void
170 set_targetdebug (char *args, int from_tty, struct cmd_list_element *c)
171 {
173 }
174 
175 static void
176 show_targetdebug (struct ui_file *file, int from_tty,
177  struct cmd_list_element *c, const char *value)
178 {
179  fprintf_filtered (file, _("Target debugging is %s.\n"), value);
180 }
181 
182 static void setup_target_debug (void);
183 
184 /* The user just typed 'target' without the name of a target. */
185 
186 static void
187 target_command (char *arg, int from_tty)
188 {
189  fputs_filtered ("Argument required (target name). Try `help target'\n",
190  gdb_stdout);
191 }
192 
193 /* Default target_has_* methods for process_stratum targets. */
194 
195 int
196 default_child_has_all_memory (struct target_ops *ops)
197 {
198  /* If no inferior selected, then we can't read memory here. */
200  return 0;
201 
202  return 1;
203 }
204 
205 int
206 default_child_has_memory (struct target_ops *ops)
207 {
208  /* If no inferior selected, then we can't read memory here. */
210  return 0;
211 
212  return 1;
213 }
214 
215 int
216 default_child_has_stack (struct target_ops *ops)
217 {
218  /* If no inferior selected, there's no stack. */
220  return 0;
221 
222  return 1;
223 }
224 
225 int
226 default_child_has_registers (struct target_ops *ops)
227 {
228  /* Can't read registers from no inferior. */
230  return 0;
231 
232  return 1;
233 }
234 
235 int
236 default_child_has_execution (struct target_ops *ops, ptid_t the_ptid)
237 {
238  /* If there's no thread selected, then we can't make it run through
239  hoops. */
240  if (ptid_equal (the_ptid, null_ptid))
241  return 0;
242 
243  return 1;
244 }
245 
246 
247 int
249 {
250  struct target_ops *t;
251 
252  for (t = current_target.beneath; t != NULL; t = t->beneath)
253  if (t->to_has_all_memory (t))
254  return 1;
255 
256  return 0;
257 }
258 
259 int
261 {
262  struct target_ops *t;
263 
264  for (t = current_target.beneath; t != NULL; t = t->beneath)
265  if (t->to_has_memory (t))
266  return 1;
267 
268  return 0;
269 }
270 
271 int
273 {
274  struct target_ops *t;
275 
276  for (t = current_target.beneath; t != NULL; t = t->beneath)
277  if (t->to_has_stack (t))
278  return 1;
279 
280  return 0;
281 }
282 
283 int
285 {
286  struct target_ops *t;
287 
288  for (t = current_target.beneath; t != NULL; t = t->beneath)
289  if (t->to_has_registers (t))
290  return 1;
291 
292  return 0;
293 }
294 
295 int
296 target_has_execution_1 (ptid_t the_ptid)
297 {
298  struct target_ops *t;
299 
300  for (t = current_target.beneath; t != NULL; t = t->beneath)
301  if (t->to_has_execution (t, the_ptid))
302  return 1;
303 
304  return 0;
305 }
306 
307 int
309 {
311 }
312 
313 /* Complete initialization of T. This ensures that various fields in
314  T are set, if needed by the target implementation. */
315 
316 void
317 complete_target_initialization (struct target_ops *t)
318 {
319  /* Provide default values for all "must have" methods. */
320 
321  if (t->to_has_all_memory == NULL)
323 
324  if (t->to_has_memory == NULL)
326 
327  if (t->to_has_stack == NULL)
329 
330  if (t->to_has_registers == NULL)
332 
333  if (t->to_has_execution == NULL)
335 
336  /* These methods can be called on an unpushed target and so require
337  a default implementation if the target might plausibly be the
338  default run target. */
339  gdb_assert (t->to_can_run == NULL || (t->to_can_async_p != NULL
340  && t->to_supports_non_stop != NULL));
341 
342  install_delegators (t);
343 }
344 
345 /* This is used to implement the various target commands. */
346 
347 static void
348 open_target (char *args, int from_tty, struct cmd_list_element *command)
349 {
350  struct target_ops *ops = get_cmd_context (command);
351 
352  if (targetdebug)
353  fprintf_unfiltered (gdb_stdlog, "-> %s->to_open (...)\n",
354  ops->to_shortname);
355 
356  ops->to_open (args, from_tty);
357 
358  if (targetdebug)
359  fprintf_unfiltered (gdb_stdlog, "<- %s->to_open (%s, %d)\n",
360  ops->to_shortname, args, from_tty);
361 }
362 
363 /* Add possible target architecture T to the list and add a new
364  command 'target T->to_shortname'. Set COMPLETER as the command's
365  completer if not NULL. */
366 
367 void
368 add_target_with_completer (struct target_ops *t,
369  completer_ftype *completer)
370 {
371  struct cmd_list_element *c;
372 
374 
375  VEC_safe_push (target_ops_p, target_structs, t);
376 
377  if (targetlist == NULL)
378  add_prefix_cmd ("target", class_run, target_command, _("\
379 Connect to a target machine or process.\n\
380 The first argument is the type or protocol of the target machine.\n\
381 Remaining arguments are interpreted by the target protocol. For more\n\
382 information on the arguments for a particular protocol, type\n\
383 `help target ' followed by the protocol name."),
384  &targetlist, "target ", 0, &cmdlist);
385  c = add_cmd (t->to_shortname, no_class, NULL, t->to_doc, &targetlist);
387  set_cmd_context (c, t);
388  if (completer != NULL)
389  set_cmd_completer (c, completer);
390 }
391 
392 /* Add a possible target architecture to the list. */
393 
394 void
395 add_target (struct target_ops *t)
396 {
397  add_target_with_completer (t, NULL);
398 }
399 
400 /* See target.h. */
401 
402 void
403 add_deprecated_target_alias (struct target_ops *t, char *alias)
404 {
405  struct cmd_list_element *c;
406  char *alt;
407 
408  /* If we use add_alias_cmd, here, we do not get the deprecated warning,
409  see PR cli/15104. */
410  c = add_cmd (alias, no_class, NULL, t->to_doc, &targetlist);
412  set_cmd_context (c, t);
413  alt = xstrprintf ("target %s", t->to_shortname);
414  deprecate_cmd (c, alt);
415 }
416 
417 /* Stub functions */
418 
419 void
421 {
423 }
424 
425 void
426 target_load (const char *arg, int from_tty)
427 {
429  (*current_target.to_load) (&current_target, arg, from_tty);
430 }
431 
432 /* Possible terminal states. */
433 
434 enum terminal_state
435  {
436  /* The inferior's terminal settings are in effect. */
438 
439  /* Some of our terminal settings are in effect, enough to get
440  proper output. */
442 
443  /* Our terminal settings are in effect, for output and input. */
445  };
446 
447 static enum terminal_state terminal_state;
448 
449 /* See target.h. */
450 
451 void
453 {
455 
456  terminal_state = terminal_is_ours;
457 }
458 
459 /* See target.h. */
460 
461 int
463 {
464  return (terminal_state == terminal_is_inferior);
465 }
466 
467 /* See target.h. */
468 
469 void
471 {
472  /* A background resume (``run&'') should leave GDB in control of the
473  terminal. Use target_can_async_p, not target_is_async_p, since at
474  this point the target is not async yet. However, if sync_execution
475  is not set, we know it will become async prior to resume. */
477  return;
478 
479  if (terminal_state == terminal_is_inferior)
480  return;
481 
482  /* If GDB is resuming the inferior in the foreground, install
483  inferior's terminal modes. */
485  terminal_state = terminal_is_inferior;
486 }
487 
488 /* See target.h. */
489 
490 void
492 {
493  if (terminal_state == terminal_is_ours)
494  return;
495 
497  terminal_state = terminal_is_ours;
498 }
499 
500 /* See target.h. */
501 
502 void
504 {
505  if (terminal_state != terminal_is_inferior)
506  return;
508  terminal_state = terminal_is_ours_for_output;
509 }
510 
511 /* See target.h. */
512 
513 int
515 {
516  struct target_ops *t;
517 
518  for (t = current_target.beneath; t != NULL; t = t->beneath)
519  {
522  return 1;
523  }
524 
525  return 0;
526 }
527 
528 /* Restore the terminal to its previous state (helper for
529  make_cleanup_restore_target_terminal). */
530 
531 static void
533 {
534  enum terminal_state *previous_state = arg;
535 
536  switch (*previous_state)
537  {
538  case terminal_is_ours:
540  break;
543  break;
546  break;
547  }
548 }
549 
550 /* See target.h. */
551 
552 struct cleanup *
554 {
555  enum terminal_state *ts = xmalloc (sizeof (*ts));
556 
557  *ts = terminal_state;
558 
560 }
561 
562 static void
563 tcomplain (void)
564 {
565  error (_("You can't do that when your target is `%s'"),
567 }
568 
569 void
570 noprocess (void)
571 {
572  error (_("You can't do that without a process to debug."));
573 }
574 
575 static void
576 default_terminal_info (struct target_ops *self, const char *args, int from_tty)
577 {
578  printf_unfiltered (_("No saved terminal information.\n"));
579 }
580 
581 /* A default implementation for the to_get_ada_task_ptid target method.
582 
583  This function builds the PTID by using both LWP and TID as part of
584  the PTID lwp and tid elements. The pid used is the pid of the
585  inferior_ptid. */
586 
587 static ptid_t
588 default_get_ada_task_ptid (struct target_ops *self, long lwp, long tid)
589 {
590  return ptid_build (ptid_get_pid (inferior_ptid), lwp, tid);
591 }
592 
593 static enum exec_direction_kind
594 default_execution_direction (struct target_ops *self)
595 {
597  return EXEC_FORWARD;
598  else if (!target_can_async_p ())
599  return EXEC_FORWARD;
600  else
602 to_execution_direction must be implemented for reverse async");
603 }
604 
605 /* Go through the target stack from top to bottom, copying over zero
606  entries in current_target, then filling in still empty entries. In
607  effect, we are doing class inheritance through the pushed target
608  vectors.
609 
610  NOTE: cagney/2003-10-17: The problem with this inheritance, as it
611  is currently implemented, is that it discards any knowledge of
612  which target an inherited method originally belonged to.
613  Consequently, new new target methods should instead explicitly and
614  locally search the target stack for the target that can handle the
615  request. */
616 
617 static void
619 {
620  struct target_ops *t;
621 
622  /* First, reset current's contents. */
623  memset (&current_target, 0, sizeof (current_target));
624 
625  /* Install the delegators. */
627 
628  current_target.to_stratum = target_stack->to_stratum;
629 
630 #define INHERIT(FIELD, TARGET) \
631  if (!current_target.FIELD) \
632  current_target.FIELD = (TARGET)->FIELD
633 
634  /* Do not add any new INHERITs here. Instead, use the delegation
635  mechanism provided by make-target-delegates. */
636  for (t = target_stack; t; t = t->beneath)
637  {
638  INHERIT (to_shortname, t);
639  INHERIT (to_longname, t);
644  }
645 #undef INHERIT
646 
647  /* Finally, position the target-stack beneath the squashed
648  "current_target". That way code looking for a non-inherited
649  target method can quickly and simply find it. */
650  current_target.beneath = target_stack;
651 
652  if (targetdebug)
654 }
655 
656 /* Push a new target type into the stack of the existing target accessors,
657  possibly superseding some of the existing accessors.
658 
659  Rather than allow an empty stack, we always have the dummy target at
660  the bottom stratum, so we can call the function vectors without
661  checking them. */
662 
663 void
664 push_target (struct target_ops *t)
665 {
666  struct target_ops **cur;
667 
668  /* Check magic number. If wrong, it probably means someone changed
669  the struct definition, but not all the places that initialize one. */
670  if (t->to_magic != OPS_MAGIC)
671  {
673  "Magic number of %s target struct wrong\n",
674  t->to_shortname);
675  internal_error (__FILE__, __LINE__,
676  _("failed internal consistency check"));
677  }
678 
679  /* Find the proper stratum to install this target in. */
680  for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
681  {
682  if ((int) (t->to_stratum) >= (int) (*cur)->to_stratum)
683  break;
684  }
685 
686  /* If there's already targets at this stratum, remove them. */
687  /* FIXME: cagney/2003-10-15: I think this should be popping all
688  targets to CUR, and not just those at this stratum level. */
689  while ((*cur) != NULL && t->to_stratum == (*cur)->to_stratum)
690  {
691  /* There's already something at this stratum level. Close it,
692  and un-hook it from the stack. */
693  struct target_ops *tmp = (*cur);
694 
695  (*cur) = (*cur)->beneath;
696  tmp->beneath = NULL;
697  target_close (tmp);
698  }
699 
700  /* We have removed all targets in our stratum, now add the new one. */
701  t->beneath = (*cur);
702  (*cur) = t;
703 
705 }
706 
707 /* Remove a target_ops vector from the stack, wherever it may be.
708  Return how many times it was removed (0 or 1). */
709 
710 int
711 unpush_target (struct target_ops *t)
712 {
713  struct target_ops **cur;
714  struct target_ops *tmp;
715 
716  if (t->to_stratum == dummy_stratum)
717  internal_error (__FILE__, __LINE__,
718  _("Attempt to unpush the dummy target"));
719 
720  /* Look for the specified target. Note that we assume that a target
721  can only occur once in the target stack. */
722 
723  for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
724  {
725  if ((*cur) == t)
726  break;
727  }
728 
729  /* If we don't find target_ops, quit. Only open targets should be
730  closed. */
731  if ((*cur) == NULL)
732  return 0;
733 
734  /* Unchain the target. */
735  tmp = (*cur);
736  (*cur) = (*cur)->beneath;
737  tmp->beneath = NULL;
738 
740 
741  /* Finally close the target. Note we do this after unchaining, so
742  any target method calls from within the target_close
743  implementation don't end up in T anymore. */
744  target_close (t);
745 
746  return 1;
747 }
748 
749 void
750 pop_all_targets_above (enum strata above_stratum)
751 {
752  while ((int) (current_target.to_stratum) > (int) above_stratum)
753  {
754  if (!unpush_target (target_stack))
755  {
757  "pop_all_targets couldn't find target %s\n",
758  target_stack->to_shortname);
759  internal_error (__FILE__, __LINE__,
760  _("failed internal consistency check"));
761  break;
762  }
763  }
764 }
765 
766 void
768 {
770 }
771 
772 /* Return 1 if T is now pushed in the target stack. Return 0 otherwise. */
773 
774 int
775 target_is_pushed (struct target_ops *t)
776 {
777  struct target_ops *cur;
778 
779  /* Check magic number. If wrong, it probably means someone changed
780  the struct definition, but not all the places that initialize one. */
781  if (t->to_magic != OPS_MAGIC)
782  {
784  "Magic number of %s target struct wrong\n",
785  t->to_shortname);
786  internal_error (__FILE__, __LINE__,
787  _("failed internal consistency check"));
788  }
789 
790  for (cur = target_stack; cur != NULL; cur = cur->beneath)
791  if (cur == t)
792  return 1;
793 
794  return 0;
795 }
796 
797 /* Default implementation of to_get_thread_local_address. */
798 
799 static void
800 generic_tls_error (void)
801 {
803  _("Cannot find thread-local variables on this target"));
804 }
805 
806 /* Using the objfile specified in OBJFILE, find the address for the
807  current thread's thread-local storage with offset OFFSET. */
808 CORE_ADDR
809 target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
810 {
811  volatile CORE_ADDR addr = 0;
812  struct target_ops *target = &current_target;
813 
815  {
816  ptid_t ptid = inferior_ptid;
817 
818  TRY
819  {
820  CORE_ADDR lm_addr;
821 
822  /* Fetch the load module address for this objfile. */
824  objfile);
825 
826  addr = target->to_get_thread_local_address (target, ptid,
827  lm_addr, offset);
828  }
829  /* If an error occurred, print TLS related messages here. Otherwise,
830  throw the error to some higher catcher. */
831  CATCH (ex, RETURN_MASK_ALL)
832  {
833  int objfile_is_library = (objfile->flags & OBJF_SHARED);
834 
835  switch (ex.error)
836  {
838  error (_("Cannot find thread-local variables "
839  "in this thread library."));
840  break;
842  if (objfile_is_library)
843  error (_("Cannot find shared library `%s' in dynamic"
844  " linker's load module list"), objfile_name (objfile));
845  else
846  error (_("Cannot find executable file `%s' in dynamic"
847  " linker's load module list"), objfile_name (objfile));
848  break;
850  if (objfile_is_library)
851  error (_("The inferior has not yet allocated storage for"
852  " thread-local variables in\n"
853  "the shared library `%s'\n"
854  "for %s"),
855  objfile_name (objfile), target_pid_to_str (ptid));
856  else
857  error (_("The inferior has not yet allocated storage for"
858  " thread-local variables in\n"
859  "the executable `%s'\n"
860  "for %s"),
861  objfile_name (objfile), target_pid_to_str (ptid));
862  break;
863  case TLS_GENERIC_ERROR:
864  if (objfile_is_library)
865  error (_("Cannot find thread-local storage for %s, "
866  "shared library %s:\n%s"),
867  target_pid_to_str (ptid),
868  objfile_name (objfile), ex.message);
869  else
870  error (_("Cannot find thread-local storage for %s, "
871  "executable file %s:\n%s"),
872  target_pid_to_str (ptid),
873  objfile_name (objfile), ex.message);
874  break;
875  default:
876  throw_exception (ex);
877  break;
878  }
879  }
880  END_CATCH
881  }
882  /* It wouldn't be wrong here to try a gdbarch method, too; finding
883  TLS is an ABI-specific thing. But we don't do that yet. */
884  else
885  error (_("Cannot find thread-local variables on this target"));
886 
887  return addr;
888 }
889 
890 const char *
892 {
893 #define CASE(X) case X: return #X
894  switch (status)
895  {
898  default:
899  return "<unknown>";
900  }
901 #undef CASE
902 };
903 
904 
905 #undef MIN
906 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
907 
908 /* target_read_string -- read a null terminated string, up to LEN bytes,
909  from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
910  Set *STRING to a pointer to malloc'd memory containing the data; the caller
911  is responsible for freeing it. Return the number of bytes successfully
912  read. */
913 
914 int
915 target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop)
916 {
917  int tlen, offset, i;
918  gdb_byte buf[4];
919  int errcode = 0;
920  char *buffer;
921  int buffer_allocated;
922  char *bufptr;
923  unsigned int nbytes_read = 0;
924 
925  gdb_assert (string);
926 
927  /* Small for testing. */
928  buffer_allocated = 4;
929  buffer = xmalloc (buffer_allocated);
930  bufptr = buffer;
931 
932  while (len > 0)
933  {
934  tlen = MIN (len, 4 - (memaddr & 3));
935  offset = memaddr & 3;
936 
937  errcode = target_read_memory (memaddr & ~3, buf, sizeof buf);
938  if (errcode != 0)
939  {
940  /* The transfer request might have crossed the boundary to an
941  unallocated region of memory. Retry the transfer, requesting
942  a single byte. */
943  tlen = 1;
944  offset = 0;
945  errcode = target_read_memory (memaddr, buf, 1);
946  if (errcode != 0)
947  goto done;
948  }
949 
950  if (bufptr - buffer + tlen > buffer_allocated)
951  {
952  unsigned int bytes;
953 
954  bytes = bufptr - buffer;
955  buffer_allocated *= 2;
956  buffer = xrealloc (buffer, buffer_allocated);
957  bufptr = buffer + bytes;
958  }
959 
960  for (i = 0; i < tlen; i++)
961  {
962  *bufptr++ = buf[i + offset];
963  if (buf[i + offset] == '\000')
964  {
965  nbytes_read += i + 1;
966  goto done;
967  }
968  }
969 
970  memaddr += tlen;
971  len -= tlen;
972  nbytes_read += tlen;
973  }
974 done:
975  *string = buffer;
976  if (errnop != NULL)
977  *errnop = errcode;
978  return nbytes_read;
979 }
980 
981 struct target_section_table *
982 target_get_section_table (struct target_ops *target)
983 {
984  return (*target->to_get_section_table) (target);
985 }
986 
987 /* Find a section containing ADDR. */
988 
989 struct target_section *
990 target_section_by_addr (struct target_ops *target, CORE_ADDR addr)
991 {
992  struct target_section_table *table = target_get_section_table (target);
993  struct target_section *secp;
994 
995  if (table == NULL)
996  return NULL;
997 
998  for (secp = table->sections; secp < table->sections_end; secp++)
999  {
1000  if (addr >= secp->addr && addr < secp->endaddr)
1001  return secp;
1002  }
1003  return NULL;
1004 }
1005 
1006 
1007 /* Helper for the memory xfer routines. Checks the attributes of the
1008  memory region of MEMADDR against the read or write being attempted.
1009  If the access is permitted returns true, otherwise returns false.
1010  REGION_P is an optional output parameter. If not-NULL, it is
1011  filled with a pointer to the memory region of MEMADDR. REG_LEN
1012  returns LEN trimmed to the end of the region. This is how much the
1013  caller can continue requesting, if the access is permitted. A
1014  single xfer request must not straddle memory region boundaries. */
1015 
1016 static int
1017 memory_xfer_check_region (gdb_byte *readbuf, const gdb_byte *writebuf,
1018  ULONGEST memaddr, ULONGEST len, ULONGEST *reg_len,
1019  struct mem_region **region_p)
1020 {
1021  struct mem_region *region;
1022 
1023  region = lookup_mem_region (memaddr);
1024 
1025  if (region_p != NULL)
1026  *region_p = region;
1027 
1028  switch (region->attrib.mode)
1029  {
1030  case MEM_RO:
1031  if (writebuf != NULL)
1032  return 0;
1033  break;
1034 
1035  case MEM_WO:
1036  if (readbuf != NULL)
1037  return 0;
1038  break;
1039 
1040  case MEM_FLASH:
1041  /* We only support writing to flash during "load" for now. */
1042  if (writebuf != NULL)
1043  error (_("Writing to flash memory forbidden in this context"));
1044  break;
1045 
1046  case MEM_NONE:
1047  return 0;
1048  }
1049 
1050  /* region->hi == 0 means there's no upper bound. */
1051  if (memaddr + len < region->hi || region->hi == 0)
1052  *reg_len = len;
1053  else
1054  *reg_len = region->hi - memaddr;
1055 
1056  return 1;
1057 }
1058 
1059 /* Read memory from more than one valid target. A core file, for
1060  instance, could have some of memory but delegate other bits to
1061  the target below it. So, we must manually try all targets. */
1062 
1063 enum target_xfer_status
1064 raw_memory_xfer_partial (struct target_ops *ops, gdb_byte *readbuf,
1065  const gdb_byte *writebuf, ULONGEST memaddr, LONGEST len,
1066  ULONGEST *xfered_len)
1067 {
1068  enum target_xfer_status res;
1069 
1070  do
1071  {
1072  res = ops->to_xfer_partial (ops, TARGET_OBJECT_MEMORY, NULL,
1073  readbuf, writebuf, memaddr, len,
1074  xfered_len);
1075  if (res == TARGET_XFER_OK)
1076  break;
1077 
1078  /* Stop if the target reports that the memory is not available. */
1079  if (res == TARGET_XFER_UNAVAILABLE)
1080  break;
1081 
1082  /* We want to continue past core files to executables, but not
1083  past a running target's memory. */
1084  if (ops->to_has_all_memory (ops))
1085  break;
1086 
1087  ops = ops->beneath;
1088  }
1089  while (ops != NULL);
1090 
1091  /* The cache works at the raw memory level. Make sure the cache
1092  gets updated with raw contents no matter what kind of memory
1093  object was originally being written. Note we do write-through
1094  first, so that if it fails, we don't write to the cache contents
1095  that never made it to the target. */
1096  if (writebuf != NULL
1098  && target_dcache_init_p ()
1100  {
1101  DCACHE *dcache = target_dcache_get ();
1102 
1103  /* Note that writing to an area of memory which wasn't present
1104  in the cache doesn't cause it to be loaded in. */
1105  dcache_update (dcache, res, memaddr, writebuf, *xfered_len);
1106  }
1107 
1108  return res;
1109 }
1110 
1111 /* Perform a partial memory transfer.
1112  For docs see target.h, to_xfer_partial. */
1113 
1114 static enum target_xfer_status
1115 memory_xfer_partial_1 (struct target_ops *ops, enum target_object object,
1116  gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST memaddr,
1117  ULONGEST len, ULONGEST *xfered_len)
1118 {
1119  enum target_xfer_status res;
1120  ULONGEST reg_len;
1121  struct mem_region *region;
1122  struct inferior *inf;
1123 
1124  /* For accesses to unmapped overlay sections, read directly from
1125  files. Must do this first, as MEMADDR may need adjustment. */
1126  if (readbuf != NULL && overlay_debugging)
1127  {
1128  struct obj_section *section = find_pc_overlay (memaddr);
1129 
1130  if (pc_in_unmapped_range (memaddr, section))
1131  {
1132  struct target_section_table *table
1133  = target_get_section_table (ops);
1134  const char *section_name = section->the_bfd_section->name;
1135 
1136  memaddr = overlay_mapped_address (memaddr, section);
1137  return section_table_xfer_memory_partial (readbuf, writebuf,
1138  memaddr, len, xfered_len,
1139  table->sections,
1140  table->sections_end,
1141  section_name);
1142  }
1143  }
1144 
1145  /* Try the executable files, if "trust-readonly-sections" is set. */
1146  if (readbuf != NULL && trust_readonly)
1147  {
1148  struct target_section *secp;
1149  struct target_section_table *table;
1150 
1151  secp = target_section_by_addr (ops, memaddr);
1152  if (secp != NULL
1153  && (bfd_get_section_flags (secp->the_bfd_section->owner,
1154  secp->the_bfd_section)
1155  & SEC_READONLY))
1156  {
1157  table = target_get_section_table (ops);
1158  return section_table_xfer_memory_partial (readbuf, writebuf,
1159  memaddr, len, xfered_len,
1160  table->sections,
1161  table->sections_end,
1162  NULL);
1163  }
1164  }
1165 
1166  /* Try GDB's internal data cache. */
1167 
1168  if (!memory_xfer_check_region (readbuf, writebuf, memaddr, len, &reg_len,
1169  &region))
1170  return TARGET_XFER_E_IO;
1171 
1174  else
1175  inf = NULL;
1176 
1177  if (inf != NULL
1178  && readbuf != NULL
1179  /* The dcache reads whole cache lines; that doesn't play well
1180  with reading from a trace buffer, because reading outside of
1181  the collected memory range fails. */
1182  && get_traceframe_number () == -1
1183  && (region->attrib.cache
1185  || (code_cache_enabled_p () && object == TARGET_OBJECT_CODE_MEMORY)))
1186  {
1187  DCACHE *dcache = target_dcache_get_or_init ();
1188 
1189  return dcache_read_memory_partial (ops, dcache, memaddr, readbuf,
1190  reg_len, xfered_len);
1191  }
1192 
1193  /* If none of those methods found the memory we wanted, fall back
1194  to a target partial transfer. Normally a single call to
1195  to_xfer_partial is enough; if it doesn't recognize an object
1196  it will call the to_xfer_partial of the next target down.
1197  But for memory this won't do. Memory is the only target
1198  object which can be read from more than one valid target.
1199  A core file, for instance, could have some of memory but
1200  delegate other bits to the target below it. So, we must
1201  manually try all targets. */
1202 
1203  res = raw_memory_xfer_partial (ops, readbuf, writebuf, memaddr, reg_len,
1204  xfered_len);
1205 
1206  /* If we still haven't got anything, return the last error. We
1207  give up. */
1208  return res;
1209 }
1210 
1211 /* Perform a partial memory transfer. For docs see target.h,
1212  to_xfer_partial. */
1213 
1214 static enum target_xfer_status
1215 memory_xfer_partial (struct target_ops *ops, enum target_object object,
1216  gdb_byte *readbuf, const gdb_byte *writebuf,
1217  ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
1218 {
1219  enum target_xfer_status res;
1220 
1221  /* Zero length requests are ok and require no work. */
1222  if (len == 0)
1223  return TARGET_XFER_EOF;
1224 
1225  /* Fill in READBUF with breakpoint shadows, or WRITEBUF with
1226  breakpoint insns, thus hiding out from higher layers whether
1227  there are software breakpoints inserted in the code stream. */
1228  if (readbuf != NULL)
1229  {
1230  res = memory_xfer_partial_1 (ops, object, readbuf, NULL, memaddr, len,
1231  xfered_len);
1232 
1233  if (res == TARGET_XFER_OK && !show_memory_breakpoints)
1234  breakpoint_xfer_memory (readbuf, NULL, NULL, memaddr, *xfered_len);
1235  }
1236  else
1237  {
1238  void *buf;
1239  struct cleanup *old_chain;
1240 
1241  /* A large write request is likely to be partially satisfied
1242  by memory_xfer_partial_1. We will continually malloc
1243  and free a copy of the entire write request for breakpoint
1244  shadow handling even though we only end up writing a small
1245  subset of it. Cap writes to 4KB to mitigate this. */
1246  len = min (4096, len);
1247 
1248  buf = xmalloc (len);
1249  old_chain = make_cleanup (xfree, buf);
1250  memcpy (buf, writebuf, len);
1251 
1252  breakpoint_xfer_memory (NULL, buf, writebuf, memaddr, len);
1253  res = memory_xfer_partial_1 (ops, object, NULL, buf, memaddr, len,
1254  xfered_len);
1255 
1256  do_cleanups (old_chain);
1257  }
1258 
1259  return res;
1260 }
1261 
1262 static void
1264 {
1265  show_memory_breakpoints = (uintptr_t) arg;
1266 }
1267 
1268 struct cleanup *
1270 {
1271  int current = show_memory_breakpoints;
1272 
1273  show_memory_breakpoints = show;
1275  (void *) (uintptr_t) current);
1276 }
1277 
1278 /* For docs see target.h, to_xfer_partial. */
1279 
1280 enum target_xfer_status
1281 target_xfer_partial (struct target_ops *ops,
1282  enum target_object object, const char *annex,
1283  gdb_byte *readbuf, const gdb_byte *writebuf,
1284  ULONGEST offset, ULONGEST len,
1285  ULONGEST *xfered_len)
1286 {
1287  enum target_xfer_status retval;
1288 
1289  gdb_assert (ops->to_xfer_partial != NULL);
1290 
1291  /* Transfer is done when LEN is zero. */
1292  if (len == 0)
1293  return TARGET_XFER_EOF;
1294 
1295  if (writebuf && !may_write_memory)
1296  error (_("Writing to memory is not allowed (addr %s, len %s)"),
1297  core_addr_to_string_nz (offset), plongest (len));
1298 
1299  *xfered_len = 0;
1300 
1301  /* If this is a memory transfer, let the memory-specific code
1302  have a look at it instead. Memory transfers are more
1303  complicated. */
1304  if (object == TARGET_OBJECT_MEMORY || object == TARGET_OBJECT_STACK_MEMORY
1305  || object == TARGET_OBJECT_CODE_MEMORY)
1306  retval = memory_xfer_partial (ops, object, readbuf,
1307  writebuf, offset, len, xfered_len);
1308  else if (object == TARGET_OBJECT_RAW_MEMORY)
1309  {
1310  /* Skip/avoid accessing the target if the memory region
1311  attributes block the access. Check this here instead of in
1312  raw_memory_xfer_partial as otherwise we'd end up checking
1313  this twice in the case of the memory_xfer_partial path is
1314  taken; once before checking the dcache, and another in the
1315  tail call to raw_memory_xfer_partial. */
1316  if (!memory_xfer_check_region (readbuf, writebuf, offset, len, &len,
1317  NULL))
1318  return TARGET_XFER_E_IO;
1319 
1320  /* Request the normal memory object from other layers. */
1321  retval = raw_memory_xfer_partial (ops, readbuf, writebuf, offset, len,
1322  xfered_len);
1323  }
1324  else
1325  retval = ops->to_xfer_partial (ops, object, annex, readbuf,
1326  writebuf, offset, len, xfered_len);
1327 
1328  if (targetdebug)
1329  {
1330  const unsigned char *myaddr = NULL;
1331 
1333  "%s:target_xfer_partial "
1334  "(%d, %s, %s, %s, %s, %s) = %d, %s",
1335  ops->to_shortname,
1336  (int) object,
1337  (annex ? annex : "(null)"),
1338  host_address_to_string (readbuf),
1339  host_address_to_string (writebuf),
1340  core_addr_to_string_nz (offset),
1341  pulongest (len), retval,
1342  pulongest (*xfered_len));
1343 
1344  if (readbuf)
1345  myaddr = readbuf;
1346  if (writebuf)
1347  myaddr = writebuf;
1348  if (retval == TARGET_XFER_OK && myaddr != NULL)
1349  {
1350  int i;
1351 
1352  fputs_unfiltered (", bytes =", gdb_stdlog);
1353  for (i = 0; i < *xfered_len; i++)
1354  {
1355  if ((((intptr_t) &(myaddr[i])) & 0xf) == 0)
1356  {
1357  if (targetdebug < 2 && i > 0)
1358  {
1359  fprintf_unfiltered (gdb_stdlog, " ...");
1360  break;
1361  }
1363  }
1364 
1365  fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
1366  }
1367  }
1368 
1369  fputc_unfiltered ('\n', gdb_stdlog);
1370  }
1371 
1372  /* Check implementations of to_xfer_partial update *XFERED_LEN
1373  properly. Do assertion after printing debug messages, so that we
1374  can find more clues on assertion failure from debugging messages. */
1375  if (retval == TARGET_XFER_OK || retval == TARGET_XFER_UNAVAILABLE)
1376  gdb_assert (*xfered_len > 0);
1377 
1378  return retval;
1379 }
1380 
1381 /* Read LEN bytes of target memory at address MEMADDR, placing the
1382  results in GDB's memory at MYADDR. Returns either 0 for success or
1383  TARGET_XFER_E_IO if any error occurs.
1384 
1385  If an error occurs, no guarantee is made about the contents of the data at
1386  MYADDR. In particular, the caller should not depend upon partial reads
1387  filling the buffer with good data. There is no way for the caller to know
1388  how much good data might have been transfered anyway. Callers that can
1389  deal with partial reads should call target_read (which will retry until
1390  it makes no progress, and then return how much was transferred). */
1391 
1392 int
1393 target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
1394 {
1395  /* Dispatch to the topmost target, not the flattened current_target.
1396  Memory accesses check target->to_has_(all_)memory, and the
1397  flattened target doesn't inherit those. */
1399  myaddr, memaddr, len) == len)
1400  return 0;
1401  else
1402  return TARGET_XFER_E_IO;
1403 }
1404 
1405 /* See target/target.h. */
1406 
1407 int
1408 target_read_uint32 (CORE_ADDR memaddr, uint32_t *result)
1409 {
1410  gdb_byte buf[4];
1411  int r;
1412 
1413  r = target_read_memory (memaddr, buf, sizeof buf);
1414  if (r != 0)
1415  return r;
1416  *result = extract_unsigned_integer (buf, sizeof buf,
1418  return 0;
1419 }
1420 
1421 /* Like target_read_memory, but specify explicitly that this is a read
1422  from the target's raw memory. That is, this read bypasses the
1423  dcache, breakpoint shadowing, etc. */
1424 
1425 int
1426 target_read_raw_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
1427 {
1428  /* See comment in target_read_memory about why the request starts at
1429  current_target.beneath. */
1431  myaddr, memaddr, len) == len)
1432  return 0;
1433  else
1434  return TARGET_XFER_E_IO;
1435 }
1436 
1437 /* Like target_read_memory, but specify explicitly that this is a read from
1438  the target's stack. This may trigger different cache behavior. */
1439 
1440 int
1441 target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
1442 {
1443  /* See comment in target_read_memory about why the request starts at
1444  current_target.beneath. */
1446  myaddr, memaddr, len) == len)
1447  return 0;
1448  else
1449  return TARGET_XFER_E_IO;
1450 }
1451 
1452 /* Like target_read_memory, but specify explicitly that this is a read from
1453  the target's code. This may trigger different cache behavior. */
1454 
1455 int
1456 target_read_code (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
1457 {
1458  /* See comment in target_read_memory about why the request starts at
1459  current_target.beneath. */
1461  myaddr, memaddr, len) == len)
1462  return 0;
1463  else
1464  return TARGET_XFER_E_IO;
1465 }
1466 
1467 /* Write LEN bytes from MYADDR to target memory at address MEMADDR.
1468  Returns either 0 for success or TARGET_XFER_E_IO if any
1469  error occurs. If an error occurs, no guarantee is made about how
1470  much data got written. Callers that can deal with partial writes
1471  should call target_write. */
1472 
1473 int
1474 target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
1475 {
1476  /* See comment in target_read_memory about why the request starts at
1477  current_target.beneath. */
1479  myaddr, memaddr, len) == len)
1480  return 0;
1481  else
1482  return TARGET_XFER_E_IO;
1483 }
1484 
1485 /* Write LEN bytes from MYADDR to target raw memory at address
1486  MEMADDR. Returns either 0 for success or TARGET_XFER_E_IO
1487  if any error occurs. If an error occurs, no guarantee is made
1488  about how much data got written. Callers that can deal with
1489  partial writes should call target_write. */
1490 
1491 int
1492 target_write_raw_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
1493 {
1494  /* See comment in target_read_memory about why the request starts at
1495  current_target.beneath. */
1497  myaddr, memaddr, len) == len)
1498  return 0;
1499  else
1500  return TARGET_XFER_E_IO;
1501 }
1502 
1503 /* Fetch the target's memory map. */
1504 
1506 target_memory_map (void)
1507 {
1508  VEC(mem_region_s) *result;
1509  struct mem_region *last_one, *this_one;
1510  int ix;
1511  struct target_ops *t;
1512 
1513  result = current_target.to_memory_map (&current_target);
1514  if (result == NULL)
1515  return NULL;
1516 
1517  qsort (VEC_address (mem_region_s, result),
1518  VEC_length (mem_region_s, result),
1519  sizeof (struct mem_region), mem_region_cmp);
1520 
1521  /* Check that regions do not overlap. Simultaneously assign
1522  a numbering for the "mem" commands to use to refer to
1523  each region. */
1524  last_one = NULL;
1525  for (ix = 0; VEC_iterate (mem_region_s, result, ix, this_one); ix++)
1526  {
1527  this_one->number = ix;
1528 
1529  if (last_one && last_one->hi > this_one->lo)
1530  {
1531  warning (_("Overlapping regions in memory map: ignoring"));
1532  VEC_free (mem_region_s, result);
1533  return NULL;
1534  }
1535  last_one = this_one;
1536  }
1537 
1538  return result;
1539 }
1540 
1541 void
1543 {
1544  current_target.to_flash_erase (&current_target, address, length);
1545 }
1546 
1547 void
1549 {
1551 }
1552 
1553 static void
1554 show_trust_readonly (struct ui_file *file, int from_tty,
1555  struct cmd_list_element *c, const char *value)
1556 {
1557  fprintf_filtered (file,
1558  _("Mode for reading from readonly sections is %s.\n"),
1559  value);
1560 }
1561 
1562 /* Target vector read/write partial wrapper functions. */
1563 
1564 static enum target_xfer_status
1565 target_read_partial (struct target_ops *ops,
1566  enum target_object object,
1567  const char *annex, gdb_byte *buf,
1568  ULONGEST offset, ULONGEST len,
1569  ULONGEST *xfered_len)
1570 {
1571  return target_xfer_partial (ops, object, annex, buf, NULL, offset, len,
1572  xfered_len);
1573 }
1574 
1575 static enum target_xfer_status
1576 target_write_partial (struct target_ops *ops,
1577  enum target_object object,
1578  const char *annex, const gdb_byte *buf,
1579  ULONGEST offset, LONGEST len, ULONGEST *xfered_len)
1580 {
1581  return target_xfer_partial (ops, object, annex, NULL, buf, offset, len,
1582  xfered_len);
1583 }
1584 
1585 /* Wrappers to perform the full transfer. */
1586 
1587 /* For docs on target_read see target.h. */
1588 
1589 LONGEST
1590 target_read (struct target_ops *ops,
1591  enum target_object object,
1592  const char *annex, gdb_byte *buf,
1593  ULONGEST offset, LONGEST len)
1594 {
1595  LONGEST xfered_total = 0;
1596  int unit_size = 1;
1597 
1598  /* If we are reading from a memory object, find the length of an addressable
1599  unit for that architecture. */
1600  if (object == TARGET_OBJECT_MEMORY
1601  || object == TARGET_OBJECT_STACK_MEMORY
1602  || object == TARGET_OBJECT_CODE_MEMORY
1603  || object == TARGET_OBJECT_RAW_MEMORY)
1605 
1606  while (xfered_total < len)
1607  {
1608  ULONGEST xfered_partial;
1610 
1611  status = target_read_partial (ops, object, annex,
1612  buf + xfered_total * unit_size,
1613  offset + xfered_total, len - xfered_total,
1614  &xfered_partial);
1615 
1616  /* Call an observer, notifying them of the xfer progress? */
1617  if (status == TARGET_XFER_EOF)
1618  return xfered_total;
1619  else if (status == TARGET_XFER_OK)
1620  {
1621  xfered_total += xfered_partial;
1622  QUIT;
1623  }
1624  else
1625  return TARGET_XFER_E_IO;
1626 
1627  }
1628  return len;
1629 }
1630 
1631 /* Assuming that the entire [begin, end) range of memory cannot be
1632  read, try to read whatever subrange is possible to read.
1633 
1634  The function returns, in RESULT, either zero or one memory block.
1635  If there's a readable subrange at the beginning, it is completely
1636  read and returned. Any further readable subrange will not be read.
1637  Otherwise, if there's a readable subrange at the end, it will be
1638  completely read and returned. Any readable subranges before it
1639  (obviously, not starting at the beginning), will be ignored. In
1640  other cases -- either no readable subrange, or readable subrange(s)
1641  that is neither at the beginning, or end, nothing is returned.
1642 
1643  The purpose of this function is to handle a read across a boundary
1644  of accessible memory in a case when memory map is not available.
1645  The above restrictions are fine for this case, but will give
1646  incorrect results if the memory is 'patchy'. However, supporting
1647  'patchy' memory would require trying to read every single byte,
1648  and it seems unacceptable solution. Explicit memory map is
1649  recommended for this case -- and target_read_memory_robust will
1650  take care of reading multiple ranges then. */
1651 
1652 static void
1653 read_whatever_is_readable (struct target_ops *ops,
1654  const ULONGEST begin, const ULONGEST end,
1655  int unit_size,
1656  VEC(memory_read_result_s) **result)
1657 {
1658  gdb_byte *buf = xmalloc (end - begin);
1659  ULONGEST current_begin = begin;
1660  ULONGEST current_end = end;
1661  int forward;
1663  ULONGEST xfered_len;
1664 
1665  /* If we previously failed to read 1 byte, nothing can be done here. */
1666  if (end - begin <= 1)
1667  {
1668  xfree (buf);
1669  return;
1670  }
1671 
1672  /* Check that either first or the last byte is readable, and give up
1673  if not. This heuristic is meant to permit reading accessible memory
1674  at the boundary of accessible region. */
1675  if (target_read_partial (ops, TARGET_OBJECT_MEMORY, NULL,
1676  buf, begin, 1, &xfered_len) == TARGET_XFER_OK)
1677  {
1678  forward = 1;
1679  ++current_begin;
1680  }
1681  else if (target_read_partial (ops, TARGET_OBJECT_MEMORY, NULL,
1682  buf + (end - begin) - 1, end - 1, 1,
1683  &xfered_len) == TARGET_XFER_OK)
1684  {
1685  forward = 0;
1686  --current_end;
1687  }
1688  else
1689  {
1690  xfree (buf);
1691  return;
1692  }
1693 
1694  /* Loop invariant is that the [current_begin, current_end) was previously
1695  found to be not readable as a whole.
1696 
1697  Note loop condition -- if the range has 1 byte, we can't divide the range
1698  so there's no point trying further. */
1699  while (current_end - current_begin > 1)
1700  {
1701  ULONGEST first_half_begin, first_half_end;
1702  ULONGEST second_half_begin, second_half_end;
1703  LONGEST xfer;
1704  ULONGEST middle = current_begin + (current_end - current_begin) / 2;
1705 
1706  if (forward)
1707  {
1708  first_half_begin = current_begin;
1709  first_half_end = middle;
1710  second_half_begin = middle;
1711  second_half_end = current_end;
1712  }
1713  else
1714  {
1715  first_half_begin = middle;
1716  first_half_end = current_end;
1717  second_half_begin = current_begin;
1718  second_half_end = middle;
1719  }
1720 
1721  xfer = target_read (ops, TARGET_OBJECT_MEMORY, NULL,
1722  buf + (first_half_begin - begin) * unit_size,
1723  first_half_begin,
1724  first_half_end - first_half_begin);
1725 
1726  if (xfer == first_half_end - first_half_begin)
1727  {
1728  /* This half reads up fine. So, the error must be in the
1729  other half. */
1730  current_begin = second_half_begin;
1731  current_end = second_half_end;
1732  }
1733  else
1734  {
1735  /* This half is not readable. Because we've tried one byte, we
1736  know some part of this half if actually readable. Go to the next
1737  iteration to divide again and try to read.
1738 
1739  We don't handle the other half, because this function only tries
1740  to read a single readable subrange. */
1741  current_begin = first_half_begin;
1742  current_end = first_half_end;
1743  }
1744  }
1745 
1746  if (forward)
1747  {
1748  /* The [begin, current_begin) range has been read. */
1749  r.begin = begin;
1750  r.end = current_begin;
1751  r.data = buf;
1752  }
1753  else
1754  {
1755  /* The [current_end, end) range has been read. */
1756  LONGEST region_len = end - current_end;
1757 
1758  r.data = xmalloc (region_len * unit_size);
1759  memcpy (r.data, buf + (current_end - begin) * unit_size,
1760  region_len * unit_size);
1761  r.begin = current_end;
1762  r.end = end;
1763  xfree (buf);
1764  }
1765  VEC_safe_push(memory_read_result_s, (*result), &r);
1766 }
1767 
1768 void
1770 {
1771  VEC(memory_read_result_s) *v = x;
1772  memory_read_result_s *current;
1773  int ix;
1774 
1775  for (ix = 0; VEC_iterate (memory_read_result_s, v, ix, current); ++ix)
1776  {
1777  xfree (current->data);
1778  }
1780 }
1781 
1783 read_memory_robust (struct target_ops *ops,
1784  const ULONGEST offset, const LONGEST len)
1785 {
1786  VEC(memory_read_result_s) *result = 0;
1788 
1789  LONGEST xfered_total = 0;
1790  while (xfered_total < len)
1791  {
1792  struct mem_region *region = lookup_mem_region (offset + xfered_total);
1793  LONGEST region_len;
1794 
1795  /* If there is no explicit region, a fake one should be created. */
1796  gdb_assert (region);
1797 
1798  if (region->hi == 0)
1799  region_len = len - xfered_total;
1800  else
1801  region_len = region->hi - offset;
1802 
1803  if (region->attrib.mode == MEM_NONE || region->attrib.mode == MEM_WO)
1804  {
1805  /* Cannot read this region. Note that we can end up here only
1806  if the region is explicitly marked inaccessible, or
1807  'inaccessible-by-default' is in effect. */
1808  xfered_total += region_len;
1809  }
1810  else
1811  {
1812  LONGEST to_read = min (len - xfered_total, region_len);
1813  gdb_byte *buffer = (gdb_byte *) xmalloc (to_read * unit_size);
1814 
1815  LONGEST xfered_partial =
1816  target_read (ops, TARGET_OBJECT_MEMORY, NULL,
1817  (gdb_byte *) buffer,
1818  offset + xfered_total, to_read);
1819  /* Call an observer, notifying them of the xfer progress? */
1820  if (xfered_partial <= 0)
1821  {
1822  /* Got an error reading full chunk. See if maybe we can read
1823  some subrange. */
1824  xfree (buffer);
1825  read_whatever_is_readable (ops, offset + xfered_total, unit_size,
1826  offset + xfered_total + to_read, &result);
1827  xfered_total += to_read;
1828  }
1829  else
1830  {
1831  struct memory_read_result r;
1832  r.data = buffer;
1833  r.begin = offset + xfered_total;
1834  r.end = r.begin + xfered_partial;
1835  VEC_safe_push (memory_read_result_s, result, &r);
1836  xfered_total += xfered_partial;
1837  }
1838  QUIT;
1839  }
1840  }
1841  return result;
1842 }
1843 
1844 
1845 /* An alternative to target_write with progress callbacks. */
1846 
1847 LONGEST
1848 target_write_with_progress (struct target_ops *ops,
1849  enum target_object object,
1850  const char *annex, const gdb_byte *buf,
1851  ULONGEST offset, LONGEST len,
1852  void (*progress) (ULONGEST, void *), void *baton)
1853 {
1854  LONGEST xfered_total = 0;
1855  int unit_size = 1;
1856 
1857  /* If we are writing to a memory object, find the length of an addressable
1858  unit for that architecture. */
1859  if (object == TARGET_OBJECT_MEMORY
1860  || object == TARGET_OBJECT_STACK_MEMORY
1861  || object == TARGET_OBJECT_CODE_MEMORY
1862  || object == TARGET_OBJECT_RAW_MEMORY)
1864 
1865  /* Give the progress callback a chance to set up. */
1866  if (progress)
1867  (*progress) (0, baton);
1868 
1869  while (xfered_total < len)
1870  {
1871  ULONGEST xfered_partial;
1873 
1874  status = target_write_partial (ops, object, annex,
1875  buf + xfered_total * unit_size,
1876  offset + xfered_total, len - xfered_total,
1877  &xfered_partial);
1878 
1879  if (status != TARGET_XFER_OK)
1880  return status == TARGET_XFER_EOF ? xfered_total : TARGET_XFER_E_IO;
1881 
1882  if (progress)
1883  (*progress) (xfered_partial, baton);
1884 
1885  xfered_total += xfered_partial;
1886  QUIT;
1887  }
1888  return len;
1889 }
1890 
1891 /* For docs on target_write see target.h. */
1892 
1893 LONGEST
1894 target_write (struct target_ops *ops,
1895  enum target_object object,
1896  const char *annex, const gdb_byte *buf,
1897  ULONGEST offset, LONGEST len)
1898 {
1899  return target_write_with_progress (ops, object, annex, buf, offset, len,
1900  NULL, NULL);
1901 }
1902 
1903 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1904  the size of the transferred data. PADDING additional bytes are
1905  available in *BUF_P. This is a helper function for
1906  target_read_alloc; see the declaration of that function for more
1907  information. */
1908 
1909 static LONGEST
1910 target_read_alloc_1 (struct target_ops *ops, enum target_object object,
1911  const char *annex, gdb_byte **buf_p, int padding)
1912 {
1913  size_t buf_alloc, buf_pos;
1914  gdb_byte *buf;
1915 
1916  /* This function does not have a length parameter; it reads the
1917  entire OBJECT). Also, it doesn't support objects fetched partly
1918  from one target and partly from another (in a different stratum,
1919  e.g. a core file and an executable). Both reasons make it
1920  unsuitable for reading memory. */
1921  gdb_assert (object != TARGET_OBJECT_MEMORY);
1922 
1923  /* Start by reading up to 4K at a time. The target will throttle
1924  this number down if necessary. */
1925  buf_alloc = 4096;
1926  buf = xmalloc (buf_alloc);
1927  buf_pos = 0;
1928  while (1)
1929  {
1930  ULONGEST xfered_len;
1932 
1933  status = target_read_partial (ops, object, annex, &buf[buf_pos],
1934  buf_pos, buf_alloc - buf_pos - padding,
1935  &xfered_len);
1936 
1937  if (status == TARGET_XFER_EOF)
1938  {
1939  /* Read all there was. */
1940  if (buf_pos == 0)
1941  xfree (buf);
1942  else
1943  *buf_p = buf;
1944  return buf_pos;
1945  }
1946  else if (status != TARGET_XFER_OK)
1947  {
1948  /* An error occurred. */
1949  xfree (buf);
1950  return TARGET_XFER_E_IO;
1951  }
1952 
1953  buf_pos += xfered_len;
1954 
1955  /* If the buffer is filling up, expand it. */
1956  if (buf_alloc < buf_pos * 2)
1957  {
1958  buf_alloc *= 2;
1959  buf = xrealloc (buf, buf_alloc);
1960  }
1961 
1962  QUIT;
1963  }
1964 }
1965 
1966 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1967  the size of the transferred data. See the declaration in "target.h"
1968  function for more information about the return value. */
1969 
1970 LONGEST
1971 target_read_alloc (struct target_ops *ops, enum target_object object,
1972  const char *annex, gdb_byte **buf_p)
1973 {
1974  return target_read_alloc_1 (ops, object, annex, buf_p, 0);
1975 }
1976 
1977 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1978  returned as a string, allocated using xmalloc. If an error occurs
1979  or the transfer is unsupported, NULL is returned. Empty objects
1980  are returned as allocated but empty strings. A warning is issued
1981  if the result contains any embedded NUL bytes. */
1982 
1983 char *
1984 target_read_stralloc (struct target_ops *ops, enum target_object object,
1985  const char *annex)
1986 {
1987  gdb_byte *buffer;
1988  char *bufstr;
1989  LONGEST i, transferred;
1990 
1991  transferred = target_read_alloc_1 (ops, object, annex, &buffer, 1);
1992  bufstr = (char *) buffer;
1993 
1994  if (transferred < 0)
1995  return NULL;
1996 
1997  if (transferred == 0)
1998  return xstrdup ("");
1999 
2000  bufstr[transferred] = 0;
2001 
2002  /* Check for embedded NUL bytes; but allow trailing NULs. */
2003  for (i = strlen (bufstr); i < transferred; i++)
2004  if (bufstr[i] != 0)
2005  {
2006  warning (_("target object %d, annex %s, "
2007  "contained unexpected null characters"),
2008  (int) object, annex ? annex : "(none)");
2009  break;
2010  }
2011 
2012  return bufstr;
2013 }
2014 
2015 /* Memory transfer methods. */
2016 
2017 void
2018 get_target_memory (struct target_ops *ops, CORE_ADDR addr, gdb_byte *buf,
2019  LONGEST len)
2020 {
2021  /* This method is used to read from an alternate, non-current
2022  target. This read must bypass the overlay support (as symbols
2023  don't match this target), and GDB's internal cache (wrong cache
2024  for this target). */
2025  if (target_read (ops, TARGET_OBJECT_RAW_MEMORY, NULL, buf, addr, len)
2026  != len)
2028 }
2029 
2030 ULONGEST
2031 get_target_memory_unsigned (struct target_ops *ops, CORE_ADDR addr,
2032  int len, enum bfd_endian byte_order)
2033 {
2034  gdb_byte buf[sizeof (ULONGEST)];
2035 
2036  gdb_assert (len <= sizeof (buf));
2037  get_target_memory (ops, addr, buf, len);
2038  return extract_unsigned_integer (buf, len, byte_order);
2039 }
2040 
2041 /* See target.h. */
2042 
2043 int
2045  struct bp_target_info *bp_tgt)
2046 {
2047  if (!may_insert_breakpoints)
2048  {
2049  warning (_("May not insert breakpoints"));
2050  return 1;
2051  }
2052 
2054  gdbarch, bp_tgt);
2055 }
2056 
2057 /* See target.h. */
2058 
2059 int
2061  struct bp_target_info *bp_tgt)
2062 {
2063  /* This is kind of a weird case to handle, but the permission might
2064  have been changed after breakpoints were inserted - in which case
2065  we should just take the user literally and assume that any
2066  breakpoints should be left in place. */
2067  if (!may_insert_breakpoints)
2068  {
2069  warning (_("May not remove breakpoints"));
2070  return 1;
2071  }
2072 
2074  gdbarch, bp_tgt);
2075 }
2076 
2077 static void
2078 target_info (char *args, int from_tty)
2079 {
2080  struct target_ops *t;
2081  int has_all_mem = 0;
2082 
2083  if (symfile_objfile != NULL)
2084  printf_unfiltered (_("Symbols from \"%s\".\n"),
2086 
2087  for (t = target_stack; t != NULL; t = t->beneath)
2088  {
2089  if (!(*t->to_has_memory) (t))
2090  continue;
2091 
2092  if ((int) (t->to_stratum) <= (int) dummy_stratum)
2093  continue;
2094  if (has_all_mem)
2095  printf_unfiltered (_("\tWhile running this, "
2096  "GDB does not access memory from...\n"));
2097  printf_unfiltered ("%s:\n", t->to_longname);
2098  (t->to_files_info) (t);
2099  has_all_mem = (*t->to_has_all_memory) (t);
2100  }
2101 }
2102 
2103 /* This function is called before any new inferior is created, e.g.
2104  by running a program, attaching, or connecting to a target.
2105  It cleans up any state from previous invocations which might
2106  change between runs. This is a subset of what target_preopen
2107  resets (things which might change between targets). */
2108 
2109 void
2110 target_pre_inferior (int from_tty)
2111 {
2112  /* Clear out solib state. Otherwise the solib state of the previous
2113  inferior might have survived and is entirely wrong for the new
2114  target. This has been observed on GNU/Linux using glibc 2.3. How
2115  to reproduce:
2116 
2117  bash$ ./foo&
2118  [1] 4711
2119  bash$ ./foo&
2120  [1] 4712
2121  bash$ gdb ./foo
2122  [...]
2123  (gdb) attach 4711
2124  (gdb) detach
2125  (gdb) attach 4712
2126  Cannot access memory at address 0xdeadbeef
2127  */
2128 
2129  /* In some OSs, the shared library list is the same/global/shared
2130  across inferiors. If code is shared between processes, so are
2131  memory regions and features. */
2133  {
2134  no_shared_libraries (NULL, from_tty);
2135 
2137 
2139  }
2140 
2142 }
2143 
2144 /* Callback for iterate_over_inferiors. Gets rid of the given
2145  inferior. */
2146 
2147 static int
2148 dispose_inferior (struct inferior *inf, void *args)
2149 {
2150  struct thread_info *thread;
2151 
2152  thread = any_thread_of_process (inf->pid);
2153  if (thread)
2154  {
2155  switch_to_thread (thread->ptid);
2156 
2157  /* Core inferiors actually should be detached, not killed. */
2159  target_kill ();
2160  else
2161  target_detach (NULL, 0);
2162  }
2163 
2164  return 0;
2165 }
2166 
2167 /* This is to be called by the open routine before it does
2168  anything. */
2169 
2170 void
2171 target_preopen (int from_tty)
2172 {
2173  dont_repeat ();
2174 
2175  if (have_inferiors ())
2176  {
2177  if (!from_tty
2178  || !have_live_inferiors ()
2179  || query (_("A program is being debugged already. Kill it? ")))
2181  else
2182  error (_("Program not killed."));
2183  }
2184 
2185  /* Calling target_kill may remove the target from the stack. But if
2186  it doesn't (which seems like a win for UDI), remove it now. */
2187  /* Leave the exec target, though. The user may be switching from a
2188  live process to a core of the same program. */
2190 
2191  target_pre_inferior (from_tty);
2192 }
2193 
2194 /* Detach a target after doing deferred register stores. */
2195 
2196 void
2197 target_detach (const char *args, int from_tty)
2198 {
2199  struct target_ops* t;
2200 
2202  /* Don't remove global breakpoints here. They're removed on
2203  disconnection from the target. */
2204  ;
2205  else
2206  /* If we're in breakpoints-always-inserted mode, have to remove
2207  them before detaching. */
2209 
2210  prepare_for_detach ();
2211 
2212  current_target.to_detach (&current_target, args, from_tty);
2213 }
2214 
2215 void
2216 target_disconnect (const char *args, int from_tty)
2217 {
2218  /* If we're in breakpoints-always-inserted mode or if breakpoints
2219  are global across processes, we have to remove them before
2220  disconnecting. */
2221  remove_breakpoints ();
2222 
2223  current_target.to_disconnect (&current_target, args, from_tty);
2224 }
2225 
2226 ptid_t
2227 target_wait (ptid_t ptid, struct target_waitstatus *status, int options)
2228 {
2229  return (current_target.to_wait) (&current_target, ptid, status, options);
2230 }
2231 
2232 char *
2233 target_pid_to_str (ptid_t ptid)
2234 {
2235  return (*current_target.to_pid_to_str) (&current_target, ptid);
2236 }
2237 
2238 char *
2240 {
2242 }
2243 
2244 void
2245 target_resume (ptid_t ptid, int step, enum gdb_signal signal)
2246 {
2247  struct target_ops *t;
2248 
2250 
2251  current_target.to_resume (&current_target, ptid, step, signal);
2252 
2253  registers_changed_ptid (ptid);
2254  /* We only set the internal executing state here. The user/frontend
2255  running state is set at a higher level. */
2256  set_executing (ptid, 1);
2257  clear_inline_frame_state (ptid);
2258 }
2259 
2260 void
2261 target_pass_signals (int numsigs, unsigned char *pass_signals)
2262 {
2263  (*current_target.to_pass_signals) (&current_target, numsigs, pass_signals);
2264 }
2265 
2266 void
2267 target_program_signals (int numsigs, unsigned char *program_signals)
2268 {
2270  numsigs, program_signals);
2271 }
2272 
2273 static int
2274 default_follow_fork (struct target_ops *self, int follow_child,
2275  int detach_fork)
2276 {
2277  /* Some target returned a fork event, but did not know how to follow it. */
2278  internal_error (__FILE__, __LINE__,
2279  _("could not find a target to follow fork"));
2280 }
2281 
2282 /* Look through the list of possible targets for a target that can
2283  follow forks. */
2284 
2285 int
2286 target_follow_fork (int follow_child, int detach_fork)
2287 {
2289  follow_child, detach_fork);
2290 }
2291 
2292 static void
2293 default_mourn_inferior (struct target_ops *self)
2294 {
2295  internal_error (__FILE__, __LINE__,
2296  _("could not find a target to follow mourn inferior"));
2297 }
2298 
2299 void
2301 {
2303 
2304  /* We no longer need to keep handles on any of the object files.
2305  Make sure to release them to avoid unnecessarily locking any
2306  of them while we're not actually debugging. */
2307  bfd_cache_close_all ();
2308 }
2309 
2310 /* Look for a target which can describe architectural features, starting
2311  from TARGET. If we find one, return its description. */
2312 
2313 const struct target_desc *
2314 target_read_description (struct target_ops *target)
2315 {
2316  return target->to_read_description (target);
2317 }
2318 
2319 /* This implements a basic search of memory, reading target memory and
2320  performing the search here (as opposed to performing the search in on the
2321  target side with, for example, gdbserver). */
2322 
2323 int
2324 simple_search_memory (struct target_ops *ops,
2325  CORE_ADDR start_addr, ULONGEST search_space_len,
2326  const gdb_byte *pattern, ULONGEST pattern_len,
2327  CORE_ADDR *found_addrp)
2328 {
2329  /* NOTE: also defined in find.c testcase. */
2330 #define SEARCH_CHUNK_SIZE 16000
2331  const unsigned chunk_size = SEARCH_CHUNK_SIZE;
2332  /* Buffer to hold memory contents for searching. */
2333  gdb_byte *search_buf;
2334  unsigned search_buf_size;
2335  struct cleanup *old_cleanups;
2336 
2337  search_buf_size = chunk_size + pattern_len - 1;
2338 
2339  /* No point in trying to allocate a buffer larger than the search space. */
2340  if (search_space_len < search_buf_size)
2341  search_buf_size = search_space_len;
2342 
2343  search_buf = malloc (search_buf_size);
2344  if (search_buf == NULL)
2345  error (_("Unable to allocate memory to perform the search."));
2346  old_cleanups = make_cleanup (free_current_contents, &search_buf);
2347 
2348  /* Prime the search buffer. */
2349 
2350  if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2351  search_buf, start_addr, search_buf_size) != search_buf_size)
2352  {
2353  warning (_("Unable to access %s bytes of target "
2354  "memory at %s, halting search."),
2355  pulongest (search_buf_size), hex_string (start_addr));
2356  do_cleanups (old_cleanups);
2357  return -1;
2358  }
2359 
2360  /* Perform the search.
2361 
2362  The loop is kept simple by allocating [N + pattern-length - 1] bytes.
2363  When we've scanned N bytes we copy the trailing bytes to the start and
2364  read in another N bytes. */
2365 
2366  while (search_space_len >= pattern_len)
2367  {
2368  gdb_byte *found_ptr;
2369  unsigned nr_search_bytes = min (search_space_len, search_buf_size);
2370 
2371  found_ptr = memmem (search_buf, nr_search_bytes,
2372  pattern, pattern_len);
2373 
2374  if (found_ptr != NULL)
2375  {
2376  CORE_ADDR found_addr = start_addr + (found_ptr - search_buf);
2377 
2378  *found_addrp = found_addr;
2379  do_cleanups (old_cleanups);
2380  return 1;
2381  }
2382 
2383  /* Not found in this chunk, skip to next chunk. */
2384 
2385  /* Don't let search_space_len wrap here, it's unsigned. */
2386  if (search_space_len >= chunk_size)
2387  search_space_len -= chunk_size;
2388  else
2389  search_space_len = 0;
2390 
2391  if (search_space_len >= pattern_len)
2392  {
2393  unsigned keep_len = search_buf_size - chunk_size;
2394  CORE_ADDR read_addr = start_addr + chunk_size + keep_len;
2395  int nr_to_read;
2396 
2397  /* Copy the trailing part of the previous iteration to the front
2398  of the buffer for the next iteration. */
2399  gdb_assert (keep_len == pattern_len - 1);
2400  memcpy (search_buf, search_buf + chunk_size, keep_len);
2401 
2402  nr_to_read = min (search_space_len - keep_len, chunk_size);
2403 
2404  if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2405  search_buf + keep_len, read_addr,
2406  nr_to_read) != nr_to_read)
2407  {
2408  warning (_("Unable to access %s bytes of target "
2409  "memory at %s, halting search."),
2410  plongest (nr_to_read),
2411  hex_string (read_addr));
2412  do_cleanups (old_cleanups);
2413  return -1;
2414  }
2415 
2416  start_addr += chunk_size;
2417  }
2418  }
2419 
2420  /* Not found. */
2421 
2422  do_cleanups (old_cleanups);
2423  return 0;
2424 }
2425 
2426 /* Default implementation of memory-searching. */
2427 
2428 static int
2429 default_search_memory (struct target_ops *self,
2430  CORE_ADDR start_addr, ULONGEST search_space_len,
2431  const gdb_byte *pattern, ULONGEST pattern_len,
2432  CORE_ADDR *found_addrp)
2433 {
2434  /* Start over from the top of the target stack. */
2436  start_addr, search_space_len,
2437  pattern, pattern_len, found_addrp);
2438 }
2439 
2440 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
2441  sequence of bytes in PATTERN with length PATTERN_LEN.
2442 
2443  The result is 1 if found, 0 if not found, and -1 if there was an error
2444  requiring halting of the search (e.g. memory read error).
2445  If the pattern is found the address is recorded in FOUND_ADDRP. */
2446 
2447 int
2448 target_search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
2449  const gdb_byte *pattern, ULONGEST pattern_len,
2450  CORE_ADDR *found_addrp)
2451 {
2452  return current_target.to_search_memory (&current_target, start_addr,
2453  search_space_len,
2454  pattern, pattern_len, found_addrp);
2455 }
2456 
2457 /* Look through the currently pushed targets. If none of them will
2458  be able to restart the currently running process, issue an error
2459  message. */
2460 
2461 void
2463 {
2464  struct target_ops *t;
2465 
2466  for (t = target_stack; t != NULL; t = t->beneath)
2467  {
2468  /* If this target knows how to create a new program, then
2469  assume we will still be able to after killing the current
2470  one. Either killing and mourning will not pop T, or else
2471  find_default_run_target will find it again. */
2472  if (t->to_create_inferior != NULL)
2473  return;
2474 
2475  /* Do not worry about targets at certain strata that can not
2476  create inferiors. Assume they will be pushed again if
2477  necessary, and continue to the process_stratum. */
2478  if (t->to_stratum == thread_stratum
2479  || t->to_stratum == record_stratum
2480  || t->to_stratum == arch_stratum)
2481  continue;
2482 
2483  error (_("The \"%s\" target does not support \"run\". "
2484  "Try \"help target\" or \"continue\"."),
2485  t->to_shortname);
2486  }
2487 
2488  /* This function is only called if the target is running. In that
2489  case there should have been a process_stratum target and it
2490  should either know how to create inferiors, or not... */
2491  internal_error (__FILE__, __LINE__, _("No targets found"));
2492 }
2493 
2494 /* Whether GDB is allowed to fall back to the default run target for
2495  "run", "attach", etc. when no target is connected yet. */
2496 static int auto_connect_native_target = 1;
2497 
2498 static void
2499 show_auto_connect_native_target (struct ui_file *file, int from_tty,
2500  struct cmd_list_element *c, const char *value)
2501 {
2502  fprintf_filtered (file,
2503  _("Whether GDB may automatically connect to the "
2504  "native target is %s.\n"),
2505  value);
2506 }
2507 
2508 /* Look through the list of possible targets for a target that can
2509  execute a run or attach command without any other data. This is
2510  used to locate the default process stratum.
2511 
2512  If DO_MESG is not NULL, the result is always valid (error() is
2513  called for errors); else, return NULL on error. */
2514 
2515 static struct target_ops *
2517 {
2518  struct target_ops *runable = NULL;
2519 
2520  if (auto_connect_native_target)
2521  {
2522  struct target_ops *t;
2523  int count = 0;
2524  int i;
2525 
2526  for (i = 0; VEC_iterate (target_ops_p, target_structs, i, t); ++i)
2527  {
2528  if (t->to_can_run != delegate_can_run && target_can_run (t))
2529  {
2530  runable = t;
2531  ++count;
2532  }
2533  }
2534 
2535  if (count != 1)
2536  runable = NULL;
2537  }
2538 
2539  if (runable == NULL)
2540  {
2541  if (do_mesg)
2542  error (_("Don't know how to %s. Try \"help target\"."), do_mesg);
2543  else
2544  return NULL;
2545  }
2546 
2547  return runable;
2548 }
2549 
2550 /* See target.h. */
2551 
2552 struct target_ops *
2554 {
2555  struct target_ops *t;
2556 
2557  /* If a target on the current stack can attach, use it. */
2558  for (t = current_target.beneath; t != NULL; t = t->beneath)
2559  {
2560  if (t->to_attach != NULL)
2561  break;
2562  }
2563 
2564  /* Otherwise, use the default run target for attaching. */
2565  if (t == NULL)
2566  t = find_default_run_target ("attach");
2567 
2568  return t;
2569 }
2570 
2571 /* See target.h. */
2572 
2573 struct target_ops *
2575 {
2576  struct target_ops *t;
2577 
2578  /* If a target on the current stack can attach, use it. */
2579  for (t = current_target.beneath; t != NULL; t = t->beneath)
2580  {
2581  if (t->to_create_inferior != NULL)
2582  break;
2583  }
2584 
2585  /* Otherwise, use the default run target. */
2586  if (t == NULL)
2587  t = find_default_run_target ("run");
2588 
2589  return t;
2590 }
2591 
2592 /* Implement the "info proc" command. */
2593 
2594 int
2595 target_info_proc (const char *args, enum info_proc_what what)
2596 {
2597  struct target_ops *t;
2598 
2599  /* If we're already connected to something that can get us OS
2600  related data, use it. Otherwise, try using the native
2601  target. */
2603  t = current_target.beneath;
2604  else
2605  t = find_default_run_target (NULL);
2606 
2607  for (; t != NULL; t = t->beneath)
2608  {
2609  if (t->to_info_proc != NULL)
2610  {
2611  t->to_info_proc (t, args, what);
2612 
2613  if (targetdebug)
2615  "target_info_proc (\"%s\", %d)\n", args, what);
2616 
2617  return 1;
2618  }
2619  }
2620 
2621  return 0;
2622 }
2623 
2624 static int
2626 {
2627  struct target_ops *t;
2628 
2629  t = find_default_run_target (NULL);
2631  return (t->to_supports_disable_randomization) (t);
2632  return 0;
2633 }
2634 
2635 int
2637 {
2638  struct target_ops *t;
2639 
2640  for (t = &current_target; t != NULL; t = t->beneath)
2642  return t->to_supports_disable_randomization (t);
2643 
2644  return 0;
2645 }
2646 
2647 char *
2649 {
2650  struct target_ops *t;
2651 
2652  /* If we're already connected to something that can get us OS
2653  related data, use it. Otherwise, try using the native
2654  target. */
2656  t = current_target.beneath;
2657  else
2658  t = find_default_run_target ("get OS data");
2659 
2660  if (!t)
2661  return NULL;
2662 
2663  return target_read_stralloc (t, TARGET_OBJECT_OSDATA, type);
2664 }
2665 
2666 static struct address_space *
2667 default_thread_address_space (struct target_ops *self, ptid_t ptid)
2668 {
2669  struct inferior *inf;
2670 
2671  /* Fall-back to the "main" address space of the inferior. */
2672  inf = find_inferior_ptid (ptid);
2673 
2674  if (inf == NULL || inf->aspace == NULL)
2675  internal_error (__FILE__, __LINE__,
2676  _("Can't determine the current "
2677  "address space of thread %s\n"),
2678  target_pid_to_str (ptid));
2679 
2680  return inf->aspace;
2681 }
2682 
2683 /* Determine the current address space of thread PTID. */
2684 
2685 struct address_space *
2687 {
2688  struct address_space *aspace;
2689 
2691  gdb_assert (aspace != NULL);
2692 
2693  return aspace;
2694 }
2695 
2696 
2697 /* Target file operations. */
2698 
2699 static struct target_ops *
2701 {
2702  /* If we're already connected to something that can perform
2703  file I/O, use it. Otherwise, try using the native target. */
2705  return current_target.beneath;
2706  else
2707  return find_default_run_target ("file I/O");
2708 }
2709 
2710 /* File handle for target file operations. */
2711 
2712 typedef struct
2713 {
2714  /* The target on which this file is open. */
2715  struct target_ops *t;
2716 
2717  /* The file descriptor on the target. */
2718  int fd;
2719 } fileio_fh_t;
2720 
2722 
2723 /* Vector of currently open file handles. The value returned by
2724  target_fileio_open and passed as the FD argument to other
2725  target_fileio_* functions is an index into this vector. This
2726  vector's entries are never freed; instead, files are marked as
2727  closed, and the handle becomes available for reuse. */
2728 static VEC (fileio_fh_t) *fileio_fhandles;
2729 
2730 /* Macro to check whether a fileio_fh_t represents a closed file. */
2731 #define is_closed_fileio_fh(fd) ((fd) < 0)
2732 
2733 /* Index into fileio_fhandles of the lowest handle that might be
2734  closed. This permits handle reuse without searching the whole
2735  list each time a new file is opened. */
2736 static int lowest_closed_fd;
2737 
2738 /* Acquire a target fileio file descriptor. */
2739 
2740 static int
2741 acquire_fileio_fd (struct target_ops *t, int fd)
2742 {
2743  fileio_fh_t *fh, buf;
2744 
2746 
2747  /* Search for closed handles to reuse. */
2748  for (;
2749  VEC_iterate (fileio_fh_t, fileio_fhandles,
2750  lowest_closed_fd, fh);
2751  lowest_closed_fd++)
2752  if (is_closed_fileio_fh (fh->fd))
2753  break;
2754 
2755  /* Push a new handle if no closed handles were found. */
2756  if (lowest_closed_fd == VEC_length (fileio_fh_t, fileio_fhandles))
2757  fh = VEC_safe_push (fileio_fh_t, fileio_fhandles, NULL);
2758 
2759  /* Fill in the handle. */
2760  fh->t = t;
2761  fh->fd = fd;
2762 
2763  /* Return its index, and start the next lookup at
2764  the next index. */
2765  return lowest_closed_fd++;
2766 }
2767 
2768 /* Release a target fileio file descriptor. */
2769 
2770 static void
2772 {
2773  fh->fd = -1;
2774  lowest_closed_fd = min (lowest_closed_fd, fd);
2775 }
2776 
2777 /* Return a pointer to the fileio_fhandle_t corresponding to FD. */
2778 
2779 #define fileio_fd_to_fh(fd) \
2780  VEC_index (fileio_fh_t, fileio_fhandles, (fd))
2781 
2782 /* Helper for target_fileio_open and
2783  target_fileio_open_warn_if_slow. */
2784 
2785 static int
2786 target_fileio_open_1 (struct inferior *inf, const char *filename,
2787  int flags, int mode, int warn_if_slow,
2788  int *target_errno)
2789 {
2790  struct target_ops *t;
2791 
2792  for (t = default_fileio_target (); t != NULL; t = t->beneath)
2793  {
2794  if (t->to_fileio_open != NULL)
2795  {
2796  int fd = t->to_fileio_open (t, inf, filename, flags, mode,
2797  warn_if_slow, target_errno);
2798 
2799  if (fd < 0)
2800  fd = -1;
2801  else
2802  fd = acquire_fileio_fd (t, fd);
2803 
2804  if (targetdebug)
2806  "target_fileio_open (%d,%s,0x%x,0%o,%d)"
2807  " = %d (%d)\n",
2808  inf == NULL ? 0 : inf->num,
2809  filename, flags, mode,
2810  warn_if_slow, fd,
2811  fd != -1 ? 0 : *target_errno);
2812  return fd;
2813  }
2814  }
2815 
2816  *target_errno = FILEIO_ENOSYS;
2817  return -1;
2818 }
2819 
2820 /* See target.h. */
2821 
2822 int
2823 target_fileio_open (struct inferior *inf, const char *filename,
2824  int flags, int mode, int *target_errno)
2825 {
2826  return target_fileio_open_1 (inf, filename, flags, mode, 0,
2827  target_errno);
2828 }
2829 
2830 /* See target.h. */
2831 
2832 int
2834  const char *filename,
2835  int flags, int mode, int *target_errno)
2836 {
2837  return target_fileio_open_1 (inf, filename, flags, mode, 1,
2838  target_errno);
2839 }
2840 
2841 /* See target.h. */
2842 
2843 int
2844 target_fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
2845  ULONGEST offset, int *target_errno)
2846 {
2847  fileio_fh_t *fh = fileio_fd_to_fh (fd);
2848  int ret = -1;
2849 
2850  if (is_closed_fileio_fh (fh->fd))
2851  *target_errno = EBADF;
2852  else
2853  ret = fh->t->to_fileio_pwrite (fh->t, fh->fd, write_buf,
2854  len, offset, target_errno);
2855 
2856  if (targetdebug)
2858  "target_fileio_pwrite (%d,...,%d,%s) "
2859  "= %d (%d)\n",
2860  fd, len, pulongest (offset),
2861  ret, ret != -1 ? 0 : *target_errno);
2862  return ret;
2863 }
2864 
2865 /* See target.h. */
2866 
2867 int
2868 target_fileio_pread (int fd, gdb_byte *read_buf, int len,
2869  ULONGEST offset, int *target_errno)
2870 {
2871  fileio_fh_t *fh = fileio_fd_to_fh (fd);
2872  int ret = -1;
2873 
2874  if (is_closed_fileio_fh (fh->fd))
2875  *target_errno = EBADF;
2876  else
2877  ret = fh->t->to_fileio_pread (fh->t, fh->fd, read_buf,
2878  len, offset, target_errno);
2879 
2880  if (targetdebug)
2882  "target_fileio_pread (%d,...,%d,%s) "
2883  "= %d (%d)\n",
2884  fd, len, pulongest (offset),
2885  ret, ret != -1 ? 0 : *target_errno);
2886  return ret;
2887 }
2888 
2889 /* See target.h. */
2890 
2891 int
2892 target_fileio_fstat (int fd, struct stat *sb, int *target_errno)
2893 {
2894  fileio_fh_t *fh = fileio_fd_to_fh (fd);
2895  int ret = -1;
2896 
2897  if (is_closed_fileio_fh (fh->fd))
2898  *target_errno = EBADF;
2899  else
2900  ret = fh->t->to_fileio_fstat (fh->t, fh->fd, sb, target_errno);
2901 
2902  if (targetdebug)
2904  "target_fileio_fstat (%d) = %d (%d)\n",
2905  fd, ret, ret != -1 ? 0 : *target_errno);
2906  return ret;
2907 }
2908 
2909 /* See target.h. */
2910 
2911 int
2912 target_fileio_close (int fd, int *target_errno)
2913 {
2914  fileio_fh_t *fh = fileio_fd_to_fh (fd);
2915  int ret = -1;
2916 
2917  if (is_closed_fileio_fh (fh->fd))
2918  *target_errno = EBADF;
2919  else
2920  {
2921  ret = fh->t->to_fileio_close (fh->t, fh->fd, target_errno);
2922  release_fileio_fd (fd, fh);
2923  }
2924 
2925  if (targetdebug)
2927  "target_fileio_close (%d) = %d (%d)\n",
2928  fd, ret, ret != -1 ? 0 : *target_errno);
2929  return ret;
2930 }
2931 
2932 /* See target.h. */
2933 
2934 int
2935 target_fileio_unlink (struct inferior *inf, const char *filename,
2936  int *target_errno)
2937 {
2938  struct target_ops *t;
2939 
2940  for (t = default_fileio_target (); t != NULL; t = t->beneath)
2941  {
2942  if (t->to_fileio_unlink != NULL)
2943  {
2944  int ret = t->to_fileio_unlink (t, inf, filename,
2945  target_errno);
2946 
2947  if (targetdebug)
2949  "target_fileio_unlink (%d,%s)"
2950  " = %d (%d)\n",
2951  inf == NULL ? 0 : inf->num, filename,
2952  ret, ret != -1 ? 0 : *target_errno);
2953  return ret;
2954  }
2955  }
2956 
2957  *target_errno = FILEIO_ENOSYS;
2958  return -1;
2959 }
2960 
2961 /* See target.h. */
2962 
2963 char *
2964 target_fileio_readlink (struct inferior *inf, const char *filename,
2965  int *target_errno)
2966 {
2967  struct target_ops *t;
2968 
2969  for (t = default_fileio_target (); t != NULL; t = t->beneath)
2970  {
2971  if (t->to_fileio_readlink != NULL)
2972  {
2973  char *ret = t->to_fileio_readlink (t, inf, filename,
2974  target_errno);
2975 
2976  if (targetdebug)
2978  "target_fileio_readlink (%d,%s)"
2979  " = %s (%d)\n",
2980  inf == NULL ? 0 : inf->num,
2981  filename, ret? ret : "(nil)",
2982  ret? 0 : *target_errno);
2983  return ret;
2984  }
2985  }
2986 
2987  *target_errno = FILEIO_ENOSYS;
2988  return NULL;
2989 }
2990 
2991 static void
2993 {
2994  int fd = *(int *) opaque;
2995  int target_errno;
2996 
2997  target_fileio_close (fd, &target_errno);
2998 }
2999 
3000 /* Read target file FILENAME, in the filesystem as seen by INF. If
3001  INF is NULL, use the filesystem seen by the debugger (GDB or, for
3002  remote targets, the remote stub). Store the result in *BUF_P and
3003  return the size of the transferred data. PADDING additional bytes
3004  are available in *BUF_P. This is a helper function for
3005  target_fileio_read_alloc; see the declaration of that function for
3006  more information. */
3007 
3008 static LONGEST
3009 target_fileio_read_alloc_1 (struct inferior *inf, const char *filename,
3010  gdb_byte **buf_p, int padding)
3011 {
3012  struct cleanup *close_cleanup;
3013  size_t buf_alloc, buf_pos;
3014  gdb_byte *buf;
3015  LONGEST n;
3016  int fd;
3017  int target_errno;
3018 
3019  fd = target_fileio_open (inf, filename, FILEIO_O_RDONLY, 0700,
3020  &target_errno);
3021  if (fd == -1)
3022  return -1;
3023 
3024  close_cleanup = make_cleanup (target_fileio_close_cleanup, &fd);
3025 
3026  /* Start by reading up to 4K at a time. The target will throttle
3027  this number down if necessary. */
3028  buf_alloc = 4096;
3029  buf = xmalloc (buf_alloc);
3030  buf_pos = 0;
3031  while (1)
3032  {
3033  n = target_fileio_pread (fd, &buf[buf_pos],
3034  buf_alloc - buf_pos - padding, buf_pos,
3035  &target_errno);
3036  if (n < 0)
3037  {
3038  /* An error occurred. */
3039  do_cleanups (close_cleanup);
3040  xfree (buf);
3041  return -1;
3042  }
3043  else if (n == 0)
3044  {
3045  /* Read all there was. */
3046  do_cleanups (close_cleanup);
3047  if (buf_pos == 0)
3048  xfree (buf);
3049  else
3050  *buf_p = buf;
3051  return buf_pos;
3052  }
3053 
3054  buf_pos += n;
3055 
3056  /* If the buffer is filling up, expand it. */
3057  if (buf_alloc < buf_pos * 2)
3058  {
3059  buf_alloc *= 2;
3060  buf = xrealloc (buf, buf_alloc);
3061  }
3062 
3063  QUIT;
3064  }
3065 }
3066 
3067 /* See target.h. */
3068 
3069 LONGEST
3070 target_fileio_read_alloc (struct inferior *inf, const char *filename,
3071  gdb_byte **buf_p)
3072 {
3073  return target_fileio_read_alloc_1 (inf, filename, buf_p, 0);
3074 }
3075 
3076 /* See target.h. */
3077 
3078 char *
3079 target_fileio_read_stralloc (struct inferior *inf, const char *filename)
3080 {
3081  gdb_byte *buffer;
3082  char *bufstr;
3083  LONGEST i, transferred;
3084 
3085  transferred = target_fileio_read_alloc_1 (inf, filename, &buffer, 1);
3086  bufstr = (char *) buffer;
3087 
3088  if (transferred < 0)
3089  return NULL;
3090 
3091  if (transferred == 0)
3092  return xstrdup ("");
3093 
3094  bufstr[transferred] = 0;
3095 
3096  /* Check for embedded NUL bytes; but allow trailing NULs. */
3097  for (i = strlen (bufstr); i < transferred; i++)
3098  if (bufstr[i] != 0)
3099  {
3100  warning (_("target file %s "
3101  "contained unexpected null characters"),
3102  filename);
3103  break;
3104  }
3105 
3106  return bufstr;
3107 }
3108 
3109 
3110 static int
3111 default_region_ok_for_hw_watchpoint (struct target_ops *self,
3112  CORE_ADDR addr, int len)
3113 {
3114  return (len <= gdbarch_ptr_bit (target_gdbarch ()) / TARGET_CHAR_BIT);
3115 }
3116 
3117 static int
3118 default_watchpoint_addr_within_range (struct target_ops *target,
3119  CORE_ADDR addr,
3120  CORE_ADDR start, int length)
3121 {
3122  return addr >= start && addr < start + length;
3123 }
3124 
3125 static struct gdbarch *
3126 default_thread_architecture (struct target_ops *ops, ptid_t ptid)
3127 {
3128  return target_gdbarch ();
3129 }
3130 
3131 static int
3132 return_zero (struct target_ops *ignore)
3133 {
3134  return 0;
3135 }
3136 
3137 static int
3138 return_zero_has_execution (struct target_ops *ignore, ptid_t ignore2)
3139 {
3140  return 0;
3141 }
3142 
3143 /*
3144  * Find the next target down the stack from the specified target.
3145  */
3146 
3147 struct target_ops *
3148 find_target_beneath (struct target_ops *t)
3149 {
3150  return t->beneath;
3151 }
3152 
3153 /* See target.h. */
3154 
3155 struct target_ops *
3156 find_target_at (enum strata stratum)
3157 {
3158  struct target_ops *t;
3159 
3160  for (t = current_target.beneath; t != NULL; t = t->beneath)
3161  if (t->to_stratum == stratum)
3162  return t;
3163 
3164  return NULL;
3165 }
3166 
3167 
3168 /* The inferior process has died. Long live the inferior! */
3169 
3170 void
3172 {
3173  ptid_t ptid;
3174 
3175  ptid = inferior_ptid;
3177 
3178  /* Mark breakpoints uninserted in case something tries to delete a
3179  breakpoint while we delete the inferior's threads (which would
3180  fail, since the inferior is long gone). */
3182 
3183  if (!ptid_equal (ptid, null_ptid))
3184  {
3185  int pid = ptid_get_pid (ptid);
3186  exit_inferior (pid);
3187  }
3188 
3189  /* Note this wipes step-resume breakpoints, so needs to be done
3190  after exit_inferior, which ends up referencing the step-resume
3191  breakpoints through clear_thread_inferior_resources. */
3193 
3194  registers_changed ();
3195 
3196  reopen_exec_file ();
3197  reinit_frame_cache ();
3198 
3201 }
3202 
3203 /* Convert a normal process ID to a string. Returns the string in a
3204  static buffer. */
3205 
3206 char *
3207 normal_pid_to_str (ptid_t ptid)
3208 {
3209  static char buf[32];
3210 
3211  xsnprintf (buf, sizeof buf, "process %d", ptid_get_pid (ptid));
3212  return buf;
3213 }
3214 
3215 static char *
3216 default_pid_to_str (struct target_ops *ops, ptid_t ptid)
3217 {
3218  return normal_pid_to_str (ptid);
3219 }
3220 
3221 /* Error-catcher for target_find_memory_regions. */
3222 static int
3223 dummy_find_memory_regions (struct target_ops *self,
3224  find_memory_region_ftype ignore1, void *ignore2)
3225 {
3226  error (_("Command not implemented for this target."));
3227  return 0;
3228 }
3229 
3230 /* Error-catcher for target_make_corefile_notes. */
3231 static char *
3232 dummy_make_corefile_notes (struct target_ops *self,
3233  bfd *ignore1, int *ignore2)
3234 {
3235  error (_("Command not implemented for this target."));
3236  return NULL;
3237 }
3238 
3239 /* Set up the handful of non-empty slots needed by the dummy target
3240  vector. */
3241 
3242 static void
3244 {
3245  dummy_target.to_shortname = "None";
3246  dummy_target.to_longname = "None";
3247  dummy_target.to_doc = "";
3248  dummy_target.to_supports_disable_randomization
3250  dummy_target.to_stratum = dummy_stratum;
3251  dummy_target.to_has_all_memory = return_zero;
3252  dummy_target.to_has_memory = return_zero;
3253  dummy_target.to_has_stack = return_zero;
3254  dummy_target.to_has_registers = return_zero;
3255  dummy_target.to_has_execution = return_zero_has_execution;
3256  dummy_target.to_magic = OPS_MAGIC;
3257 
3258  install_dummy_methods (&dummy_target);
3259 }
3260 
3261 
3262 void
3263 target_close (struct target_ops *targ)
3264 {
3265  gdb_assert (!target_is_pushed (targ));
3266 
3267  if (targ->to_xclose != NULL)
3268  targ->to_xclose (targ);
3269  else if (targ->to_close != NULL)
3270  targ->to_close (targ);
3271 
3272  if (targetdebug)
3273  fprintf_unfiltered (gdb_stdlog, "target_close ()\n");
3274 }
3275 
3276 int
3277 target_thread_alive (ptid_t ptid)
3278 {
3280 }
3281 
3282 void
3284 {
3286 }
3287 
3288 void
3289 target_stop (ptid_t ptid)
3290 {
3291  if (!may_stop)
3292  {
3293  warning (_("May not interrupt or stop the target, ignoring attempt"));
3294  return;
3295  }
3296 
3298 }
3299 
3300 /* See target.h. */
3301 
3302 void
3304 {
3306 }
3307 
3308 /* See target/target.h. */
3309 
3310 void
3312 {
3313  struct target_waitstatus status;
3314  int was_non_stop = non_stop;
3315 
3316  non_stop = 1;
3317  target_stop (ptid);
3318 
3319  memset (&status, 0, sizeof (status));
3320  target_wait (ptid, &status, 0);
3321 
3322  non_stop = was_non_stop;
3323 }
3324 
3325 /* See target/target.h. */
3326 
3327 void
3329 {
3330  target_resume (ptid, 0, GDB_SIGNAL_0);
3331 }
3332 
3333 /* Concatenate ELEM to LIST, a comma separate list, and return the
3334  result. The LIST incoming argument is released. */
3335 
3336 static char *
3337 str_comma_list_concat_elem (char *list, const char *elem)
3338 {
3339  if (list == NULL)
3340  return xstrdup (elem);
3341  else
3342  return reconcat (list, list, ", ", elem, (char *) NULL);
3343 }
3344 
3345 /* Helper for target_options_to_string. If OPT is present in
3346  TARGET_OPTIONS, append the OPT_STR (string version of OPT) in RET.
3347  Returns the new resulting string. OPT is removed from
3348  TARGET_OPTIONS. */
3349 
3350 static char *
3351 do_option (int *target_options, char *ret,
3352  int opt, char *opt_str)
3353 {
3354  if ((*target_options & opt) != 0)
3355  {
3356  ret = str_comma_list_concat_elem (ret, opt_str);
3357  *target_options &= ~opt;
3358  }
3359 
3360  return ret;
3361 }
3362 
3363 char *
3364 target_options_to_string (int target_options)
3365 {
3366  char *ret = NULL;
3367 
3368 #define DO_TARG_OPTION(OPT) \
3369  ret = do_option (&target_options, ret, OPT, #OPT)
3370 
3372 
3373  if (target_options != 0)
3374  ret = str_comma_list_concat_elem (ret, "unknown???");
3375 
3376  if (ret == NULL)
3377  ret = xstrdup ("");
3378  return ret;
3379 }
3380 
3381 static void
3383  struct regcache *regcache, int regno)
3384 {
3385  struct gdbarch *gdbarch = get_regcache_arch (regcache);
3386 
3387  fprintf_unfiltered (gdb_stdlog, "%s ", func);
3388  if (regno >= 0 && regno < gdbarch_num_regs (gdbarch)
3389  && gdbarch_register_name (gdbarch, regno) != NULL
3390  && gdbarch_register_name (gdbarch, regno)[0] != '\0')
3391  fprintf_unfiltered (gdb_stdlog, "(%s)",
3392  gdbarch_register_name (gdbarch, regno));
3393  else
3394  fprintf_unfiltered (gdb_stdlog, "(%d)", regno);
3395  if (regno >= 0 && regno < gdbarch_num_regs (gdbarch))
3396  {
3397  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
3398  int i, size = register_size (gdbarch, regno);
3400 
3401  regcache_raw_collect (regcache, regno, buf);
3402  fprintf_unfiltered (gdb_stdlog, " = ");
3403  for (i = 0; i < size; i++)
3404  {
3405  fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
3406  }
3407  if (size <= sizeof (LONGEST))
3408  {
3409  ULONGEST val = extract_unsigned_integer (buf, size, byte_order);
3410 
3411  fprintf_unfiltered (gdb_stdlog, " %s %s",
3412  core_addr_to_string_nz (val), plongest (val));
3413  }
3414  }
3416 }
3417 
3418 void
3420 {
3421  current_target.to_fetch_registers (&current_target, regcache, regno);
3422  if (targetdebug)
3423  debug_print_register ("target_fetch_registers", regcache, regno);
3424 }
3425 
3426 void
3428 {
3429  struct target_ops *t;
3430 
3431  if (!may_write_registers)
3432  error (_("Writing to registers is not allowed (regno %d)"), regno);
3433 
3434  current_target.to_store_registers (&current_target, regcache, regno);
3435  if (targetdebug)
3436  {
3437  debug_print_register ("target_store_registers", regcache, regno);
3438  }
3439 }
3440 
3441 int
3443 {
3445 }
3446 
3447 int
3448 simple_verify_memory (struct target_ops *ops,
3449  const gdb_byte *data, CORE_ADDR lma, ULONGEST size)
3450 {
3451  LONGEST total_xfered = 0;
3452 
3453  while (total_xfered < size)
3454  {
3455  ULONGEST xfered_len;
3457  gdb_byte buf[1024];
3458  ULONGEST howmuch = min (sizeof (buf), size - total_xfered);
3459 
3460  status = target_xfer_partial (ops, TARGET_OBJECT_MEMORY, NULL,
3461  buf, NULL, lma + total_xfered, howmuch,
3462  &xfered_len);
3463  if (status == TARGET_XFER_OK
3464  && memcmp (data + total_xfered, buf, xfered_len) == 0)
3465  {
3466  total_xfered += xfered_len;
3467  QUIT;
3468  }
3469  else
3470  return 0;
3471  }
3472  return 1;
3473 }
3474 
3475 /* Default implementation of memory verification. */
3476 
3477 static int
3478 default_verify_memory (struct target_ops *self,
3479  const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
3480 {
3481  /* Start over from the top of the target stack. */
3483  data, memaddr, size);
3484 }
3485 
3486 int
3487 target_verify_memory (const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
3488 {
3490  data, memaddr, size);
3491 }
3492 
3493 /* The documentation for this function is in its prototype declaration in
3494  target.h. */
3495 
3496 int
3497 target_insert_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw)
3498 {
3500  addr, mask, rw);
3501 }
3502 
3503 /* The documentation for this function is in its prototype declaration in
3504  target.h. */
3505 
3506 int
3507 target_remove_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw)
3508 {
3510  addr, mask, rw);
3511 }
3512 
3513 /* The documentation for this function is in its prototype declaration
3514  in target.h. */
3515 
3516 int
3517 target_masked_watch_num_registers (CORE_ADDR addr, CORE_ADDR mask)
3518 {
3520  addr, mask);
3521 }
3522 
3523 /* The documentation for this function is in its prototype declaration
3524  in target.h. */
3525 
3526 int
3528 {
3530 }
3531 
3532 /* See target.h. */
3533 
3534 int
3536 {
3538 }
3539 
3540 /* See target.h. */
3541 
3542 struct btrace_target_info *
3543 target_enable_btrace (ptid_t ptid, const struct btrace_config *conf)
3544 {
3545  return current_target.to_enable_btrace (&current_target, ptid, conf);
3546 }
3547 
3548 /* See target.h. */
3549 
3550 void
3552 {
3554 }
3555 
3556 /* See target.h. */
3557 
3558 void
3560 {
3562 }
3563 
3564 /* See target.h. */
3565 
3566 enum btrace_error
3568  struct btrace_target_info *btinfo,
3569  enum btrace_read_type type)
3570 {
3571  return current_target.to_read_btrace (&current_target, btrace, btinfo, type);
3572 }
3573 
3574 /* See target.h. */
3575 
3576 const struct btrace_config *
3578 {
3579  return current_target.to_btrace_conf (&current_target, btinfo);
3580 }
3581 
3582 /* See target.h. */
3583 
3584 void
3586 {
3588 }
3589 
3590 /* See target.h. */
3591 
3592 void
3593 target_save_record (const char *filename)
3594 {
3596 }
3597 
3598 /* See target.h. */
3599 
3600 int
3602 {
3603  struct target_ops *t;
3604 
3605  for (t = current_target.beneath; t != NULL; t = t->beneath)
3608  return 1;
3609 
3610  return 0;
3611 }
3612 
3613 /* See target.h. */
3614 
3615 void
3617 {
3619 }
3620 
3621 /* See target.h. */
3622 
3623 int
3625 {
3627 }
3628 
3629 /* See target.h. */
3630 
3631 void
3633 {
3635 }
3636 
3637 /* See target.h. */
3638 
3639 void
3641 {
3643 }
3644 
3645 /* See target.h. */
3646 
3647 void
3649 {
3651 }
3652 
3653 /* See target.h. */
3654 
3655 void
3657 {
3659 }
3660 
3661 /* See target.h. */
3662 
3663 void
3665 {
3666  current_target.to_insn_history_from (&current_target, from, size, flags);
3667 }
3668 
3669 /* See target.h. */
3670 
3671 void
3673 {
3674  current_target.to_insn_history_range (&current_target, begin, end, flags);
3675 }
3676 
3677 /* See target.h. */
3678 
3679 void
3681 {
3683 }
3684 
3685 /* See target.h. */
3686 
3687 void
3689 {
3690  current_target.to_call_history_from (&current_target, begin, size, flags);
3691 }
3692 
3693 /* See target.h. */
3694 
3695 void
3697 {
3698  current_target.to_call_history_range (&current_target, begin, end, flags);
3699 }
3700 
3701 /* See target.h. */
3702 
3703 const struct frame_unwind *
3705 {
3707 }
3708 
3709 /* See target.h. */
3710 
3711 const struct frame_unwind *
3713 {
3715 }
3716 
3717 /* See target.h. */
3718 
3719 void
3721 {
3723 }
3724 
3725 /* See target.h. */
3726 
3727 void
3729 {
3731 }
3732 
3733 static void
3735 {
3736  memcpy (&debug_target, &current_target, sizeof debug_target);
3737 
3739 }
3740 
3741 
3742 static char targ_desc[] =
3743 "Names of targets and files being debugged.\nShows the entire \
3744 stack of targets currently in use (including the exec-file,\n\
3745 core-file, and process, if any), as well as the symbol file name.";
3746 
3747 static void
3748 default_rcmd (struct target_ops *self, const char *command,
3749  struct ui_file *output)
3750 {
3751  error (_("\"monitor\" command not supported by this target."));
3752 }
3753 
3754 static void
3756  int from_tty)
3757 {
3758  target_rcmd (cmd, gdb_stdtarg);
3759 }
3760 
3761 /* Print the name of each layers of our target stack. */
3762 
3763 static void
3764 maintenance_print_target_stack (char *cmd, int from_tty)
3765 {
3766  struct target_ops *t;
3767 
3768  printf_filtered (_("The current target stack is:\n"));
3769 
3770  for (t = target_stack; t != NULL; t = t->beneath)
3771  {
3772  printf_filtered (" - %s (%s)\n", t->to_shortname, t->to_longname);
3773  }
3774 }
3775 
3776 /* Controls if targets can report that they can/are async. This is
3777  just for maintainers to use when debugging gdb. */
3778 int target_async_permitted = 1;
3779 
3780 /* The set command writes to this variable. If the inferior is
3781  executing, target_async_permitted is *not* updated. */
3782 static int target_async_permitted_1 = 1;
3783 
3784 static void
3785 maint_set_target_async_command (char *args, int from_tty,
3786  struct cmd_list_element *c)
3787 {
3788  if (have_live_inferiors ())
3789  {
3790  target_async_permitted_1 = target_async_permitted;
3791  error (_("Cannot change this setting while the inferior is running."));
3792  }
3793 
3794  target_async_permitted = target_async_permitted_1;
3795 }
3796 
3797 static void
3798 maint_show_target_async_command (struct ui_file *file, int from_tty,
3799  struct cmd_list_element *c,
3800  const char *value)
3801 {
3802  fprintf_filtered (file,
3803  _("Controlling the inferior in "
3804  "asynchronous mode is %s.\n"), value);
3805 }
3806 
3807 /* Temporary copies of permission settings. */
3808 
3809 static int may_write_registers_1 = 1;
3810 static int may_write_memory_1 = 1;
3811 static int may_insert_breakpoints_1 = 1;
3812 static int may_insert_tracepoints_1 = 1;
3813 static int may_insert_fast_tracepoints_1 = 1;
3814 static int may_stop_1 = 1;
3815 
3816 /* Make the user-set values match the real values again. */
3817 
3818 void
3820 {
3821  may_write_registers_1 = may_write_registers;
3822  may_write_memory_1 = may_write_memory;
3823  may_insert_breakpoints_1 = may_insert_breakpoints;
3824  may_insert_tracepoints_1 = may_insert_tracepoints;
3825  may_insert_fast_tracepoints_1 = may_insert_fast_tracepoints;
3826  may_stop_1 = may_stop;
3827 }
3828 
3829 /* The one function handles (most of) the permission flags in the same
3830  way. */
3831 
3832 static void
3833 set_target_permissions (char *args, int from_tty,
3834  struct cmd_list_element *c)
3835 {
3837  {
3839  error (_("Cannot change this setting while the inferior is running."));
3840  }
3841 
3842  /* Make the real values match the user-changed values. */
3843  may_write_registers = may_write_registers_1;
3844  may_insert_breakpoints = may_insert_breakpoints_1;
3845  may_insert_tracepoints = may_insert_tracepoints_1;
3846  may_insert_fast_tracepoints = may_insert_fast_tracepoints_1;
3847  may_stop = may_stop_1;
3849 }
3850 
3851 /* Set memory write permission independently of observer mode. */
3852 
3853 static void
3854 set_write_memory_permission (char *args, int from_tty,
3855  struct cmd_list_element *c)
3856 {
3857  /* Make the real values match the user-changed values. */
3858  may_write_memory = may_write_memory_1;
3860 }
3861 
3862 
3863 void
3865 {
3866  init_dummy_target ();
3867  push_target (&dummy_target);
3868 
3869  add_info ("target", target_info, targ_desc);
3870  add_info ("files", target_info, targ_desc);
3871 
3872  add_setshow_zuinteger_cmd ("target", class_maintenance, &targetdebug, _("\
3873 Set target debugging."), _("\
3874 Show target debugging."), _("\
3875 When non-zero, target debugging is enabled. Higher numbers are more\n\
3876 verbose."),
3877  set_targetdebug,
3880 
3881  add_setshow_boolean_cmd ("trust-readonly-sections", class_support,
3882  &trust_readonly, _("\
3883 Set mode for reading from readonly sections."), _("\
3884 Show mode for reading from readonly sections."), _("\
3885 When this mode is on, memory reads from readonly sections (such as .text)\n\
3886 will be read from the object file instead of from the target. This will\n\
3887 result in significant performance improvement for remote targets."),
3888  NULL,
3890  &setlist, &showlist);
3891 
3893  _("Send a command to the remote monitor (remote targets only)."));
3894 
3896  _("Print the name of each layer of the internal target stack."),
3898 
3899  add_setshow_boolean_cmd ("target-async", no_class,
3900  &target_async_permitted_1, _("\
3901 Set whether gdb controls the inferior in asynchronous mode."), _("\
3902 Show whether gdb controls the inferior in asynchronous mode."), _("\
3903 Tells gdb whether to control the inferior in asynchronous mode."),
3908 
3909  add_setshow_boolean_cmd ("may-write-registers", class_support,
3910  &may_write_registers_1, _("\
3911 Set permission to write into registers."), _("\
3912 Show permission to write into registers."), _("\
3913 When this permission is on, GDB may write into the target's registers.\n\
3914 Otherwise, any sort of write attempt will result in an error."),
3915  set_target_permissions, NULL,
3916  &setlist, &showlist);
3917 
3918  add_setshow_boolean_cmd ("may-write-memory", class_support,
3919  &may_write_memory_1, _("\
3920 Set permission to write into target memory."), _("\
3921 Show permission to write into target memory."), _("\
3922 When this permission is on, GDB may write into the target's memory.\n\
3923 Otherwise, any sort of write attempt will result in an error."),
3925  &setlist, &showlist);
3926 
3927  add_setshow_boolean_cmd ("may-insert-breakpoints", class_support,
3928  &may_insert_breakpoints_1, _("\
3929 Set permission to insert breakpoints in the target."), _("\
3930 Show permission to insert breakpoints in the target."), _("\
3931 When this permission is on, GDB may insert breakpoints in the program.\n\
3932 Otherwise, any sort of insertion attempt will result in an error."),
3933  set_target_permissions, NULL,
3934  &setlist, &showlist);
3935 
3936  add_setshow_boolean_cmd ("may-insert-tracepoints", class_support,
3937  &may_insert_tracepoints_1, _("\
3938 Set permission to insert tracepoints in the target."), _("\
3939 Show permission to insert tracepoints in the target."), _("\
3940 When this permission is on, GDB may insert tracepoints in the program.\n\
3941 Otherwise, any sort of insertion attempt will result in an error."),
3942  set_target_permissions, NULL,
3943  &setlist, &showlist);
3944 
3945  add_setshow_boolean_cmd ("may-insert-fast-tracepoints", class_support,
3946  &may_insert_fast_tracepoints_1, _("\
3947 Set permission to insert fast tracepoints in the target."), _("\
3948 Show permission to insert fast tracepoints in the target."), _("\
3949 When this permission is on, GDB may insert fast tracepoints.\n\
3950 Otherwise, any sort of insertion attempt will result in an error."),
3951  set_target_permissions, NULL,
3952  &setlist, &showlist);
3953 
3954  add_setshow_boolean_cmd ("may-interrupt", class_support,
3955  &may_stop_1, _("\
3956 Set permission to interrupt or signal the target."), _("\
3957 Show permission to interrupt or signal the target."), _("\
3958 When this permission is on, GDB may interrupt/stop the target's execution.\n\
3959 Otherwise, any attempt to interrupt or stop will be ignored."),
3960  set_target_permissions, NULL,
3961  &setlist, &showlist);
3962 
3963  add_setshow_boolean_cmd ("auto-connect-native-target", class_support,
3964  &auto_connect_native_target, _("\
3965 Set whether GDB may automatically connect to the native target."), _("\
3966 Show whether GDB may automatically connect to the native target."), _("\
3967 When on, and GDB is not connected to a target yet, GDB\n\
3968 attempts \"run\" and other commands with the native target."),
3970  &setlist, &showlist);
3971 }
int target_supports_disable_randomization(void)
Definition: target.c:2636
int(* to_fileio_pread)(struct target_ops *, int fd, gdb_byte *read_buf, int len, ULONGEST offset, int *target_errno)
Definition: target.h:887
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5143
#define target_can_async_p()
Definition: target.h:1748
struct address_space *(* to_thread_address_space)(struct target_ops *, ptid_t) TARGET_DEFAULT_FUNC(default_thread_address_space)
Definition: target.h:854
enum target_xfer_status dcache_read_memory_partial(struct target_ops *ops, DCACHE *dcache, CORE_ADDR memaddr, gdb_byte *myaddr, ULONGEST len, ULONGEST *xfered_len)
Definition: dcache.c:471
void(* deprecated_detach_hook)(void)
Definition: top.c:217
void target_goto_record_begin(void)
Definition: target.c:3632
void set_cmd_context(struct cmd_list_element *cmd, void *context)
Definition: cli-decode.c:141
void add_target(struct target_ops *t)
Definition: target.c:395
terminal_state
Definition: target.c:434
int have_live_inferiors(void)
Definition: inferior.c:472
int default_child_has_stack(struct target_ops *ops)
Definition: target.c:216
void target_terminal_ours(void)
Definition: target.c:491
int target_thread_alive(ptid_t ptid)
Definition: target.c:3277
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
void get_target_memory(struct target_ops *ops, CORE_ADDR addr, gdb_byte *buf, LONGEST len)
Definition: target.c:2018
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:338
void target_disable_btrace(struct btrace_target_info *btinfo)
Definition: target.c:3551
struct cleanup * make_show_memory_breakpoints_cleanup(int show)
Definition: target.c:1269
#define OBJF_SHARED
Definition: objfiles.h:432
void reopen_exec_file(void)
Definition: corefile.c:132
int target_supports_terminal_ours(void)
Definition: target.c:514
#define target_can_execute_reverse
Definition: target.h:1960
void(* to_delete_record)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1142
Definition: memattr.h:29
gdb_byte * data
Definition: target.h:301
int(* to_supports_disable_randomization)(struct target_ops *)
Definition: target.h:821
const struct target_desc *(* to_read_description)(struct target_ops *ops) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:769
const char * to_longname
Definition: target.h:433
void(* to_program_signals)(struct target_ops *, int, unsigned char *TARGET_DEBUG_PRINTER(target_debug_print_signals)) TARGET_DEFAULT_IGNORE()
Definition: target.h:623
void target_stop(ptid_t ptid)
Definition: target.c:3289
static void install_dummy_methods(struct target_ops *ops)
void * get_cmd_context(struct cmd_list_element *cmd)
Definition: cli-decode.c:147
void(* to_goto_record_begin)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1150
void target_teardown_btrace(struct btrace_target_info *btinfo)
Definition: target.c:3559
static enum target_xfer_status memory_xfer_partial(struct target_ops *ops, enum target_object object, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
Definition: target.c:1215
int have_inferiors(void)
Definition: inferior.c:460
void add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:763
void(* to_save_record)(struct target_ops *, const char *filename) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1137
void clear_inline_frame_state(ptid_t ptid)
Definition: inline-frame.c:113
int ptid_equal(ptid_t ptid1, ptid_t ptid2)
Definition: ptid.c:76
const struct frame_unwind * target_get_tailcall_unwinder(void)
Definition: target.c:3712
static int return_zero_has_execution(struct target_ops *ignore, ptid_t ignore2)
Definition: target.c:3138
int(* to_fileio_close)(struct target_ops *, int fd, int *target_errno)
Definition: target.h:899
int target_remove_breakpoint(struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: target.c:2060
void fputs_unfiltered(const char *buf, struct ui_file *file)
Definition: ui-file.c:252
void target_require_runnable(void)
Definition: target.c:2462
void xfree(void *)
Definition: common-utils.c:97
int target_verify_memory(const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
Definition: target.c:3487
strata
Definition: target.h:76
int may_insert_fast_tracepoints
struct btrace_target_info * target_enable_btrace(ptid_t ptid, const struct btrace_config *conf)
Definition: target.c:3543
struct target_section * sections_end
Definition: target.h:2277
char * target_fileio_readlink(struct inferior *inf, const char *filename, int *target_errno)
Definition: target.c:2964
int gdbarch_has_global_solist(struct gdbarch *gdbarch)
Definition: gdbarch.c:4346
const struct frame_unwind * target_get_unwinder(void)
Definition: target.c:3704
void no_shared_libraries(char *ignored, int from_tty)
Definition: solib.c:1302
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
Definition: regcache.c:297
void(* func)(char *)
void(* to_xclose)(struct target_ops *targ)
Definition: target.h:447
struct bfd_section * the_bfd_section
Definition: objfiles.h:121
int(* to_has_memory)(struct target_ops *)
Definition: target.h:652
void warning(const char *fmt,...)
Definition: errors.c:26
struct cmd_list_element * deprecate_cmd(struct cmd_list_element *cmd, const char *replacement)
Definition: cli-decode.c:272
int target_supports_btrace(enum btrace_format format)
Definition: target.c:3535
char *(* to_pid_to_str)(struct target_ops *, ptid_t) TARGET_DEFAULT_FUNC(default_pid_to_str)
Definition: target.h:631
void(* to_flash_done)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:762
struct type ** const(pascal_builtin_types[])
static void set_target_permissions(char *args, int from_tty, struct cmd_list_element *c)
Definition: target.c:3833
int query(const char *ctlstr,...)
Definition: utils.c:1364
void(* to_stop_recording)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:1129
static int target_fileio_open_1(struct inferior *inf, const char *filename, int flags, int mode, int warn_if_slow, int *target_errno)
Definition: target.c:2786
LONGEST target_write(struct target_ops *ops, enum target_object object, const char *annex, const gdb_byte *buf, ULONGEST offset, LONGEST len)
Definition: target.c:1894
tuple inf
Definition: arm-linux.py:13
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1690
int(* to_has_stack)(struct target_ops *)
Definition: target.h:653
static ptid_t default_get_ada_task_ptid(struct target_ops *self, long lwp, long tid)
Definition: target.c:588
void(* to_terminal_init)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:565
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
LONGEST target_read_alloc(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte **buf_p)
Definition: target.c:1971
void generic_mourn_inferior(void)
Definition: target.c:3171
void target_detach(const char *args, int from_tty)
Definition: target.c:2197
struct ui_file * gdb_stdout
Definition: main.c:71
void(* to_insn_history_from)(struct target_ops *, ULONGEST from, int size, int flags) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1172
int(* to_core_of_thread)(struct target_ops *, ptid_t ptid) TARGET_DEFAULT_RETURN(-1)
Definition: target.h:1042
int pid
Definition: inferior.h:299
int unpush_target(struct target_ops *t)
Definition: target.c:711
int(* to_follow_fork)(struct target_ops *, int, int) TARGET_DEFAULT_FUNC(default_follow_fork)
Definition: target.h:596
int target_supports_delete_record(void)
Definition: target.c:3601
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
int num
Definition: inferior.h:295
void(* to_terminal_ours_for_output)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:569
void(* to_call_history)(struct target_ops *, int size, int flags) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1185
void target_pass_signals(int numsigs, unsigned char *pass_signals)
Definition: target.c:2261
#define target_can_run(t)
Definition: target.h:1624
static enum target_xfer_status target_read_partial(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *buf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
Definition: target.c:1565
struct address_space * target_thread_address_space(ptid_t ptid)
Definition: target.c:2686
void(* to_close)(struct target_ops *)
Definition: target.h:448
void switch_to_thread(ptid_t ptid)
Definition: thread.c:1185
void initialize_targets(void)
Definition: target.c:3864
char * target_thread_name(struct thread_info *info)
Definition: target.c:2239
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1393
static int may_stop_1
Definition: target.c:3814
static int memory_xfer_check_region(gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST memaddr, ULONGEST len, ULONGEST *reg_len, struct mem_region **region_p)
Definition: target.c:1017
DCACHE * target_dcache_get_or_init(void)
Definition: target-dcache.c:76
const struct frame_unwind *(* to_get_tailcall_unwinder)(struct target_ops *self) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:1213
#define VEC_safe_push(T, V, O)
Definition: vec.h:260
void set_cmd_sfunc(struct cmd_list_element *cmd, cmd_sfunc_ftype *sfunc)
Definition: cli-decode.c:125
struct inferior * find_inferior_ptid(ptid_t ptid)
Definition: inferior.c:373
struct cmd_list_element * cmdlist
Definition: cli-cmds.c:103
void(* to_check_pending_interrupt)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:639
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
void target_prepare_to_generate_core(void)
Definition: target.c:3720
void target_kill(void)
Definition: target.c:420
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
void target_fetch_registers(struct regcache *regcache, int regno)
Definition: target.c:3419
char * target_pid_to_str(ptid_t ptid)
Definition: target.c:2233
void target_insn_history_from(ULONGEST from, int size, int flags)
Definition: target.c:3664
void target_call_history_from(ULONGEST begin, int size, int flags)
Definition: target.c:3688
static CORE_ADDR lm_addr(struct so_list *so)
Definition: nto-tdep.c:262
static struct target_ops * find_default_run_target(char *do_mesg)
Definition: target.c:2516
#define _(String)
Definition: gdb_locale.h:40
int target_fileio_pwrite(int fd, const gdb_byte *write_buf, int len, ULONGEST offset, int *target_errno)
Definition: target.c:2844
static struct target_ops * default_fileio_target(void)
Definition: target.c:2700
#define fileio_fd_to_fh(fd)
Definition: target.c:2779
int default_child_has_execution(struct target_ops *ops, ptid_t the_ptid)
Definition: target.c:236
static int default_follow_fork(struct target_ops *self, int follow_child, int detach_fork)
Definition: target.c:2274
static char * default_pid_to_str(struct target_ops *ops, ptid_t ptid)
Definition: target.c:3216
btrace_format
Definition: btrace-common.h:54
enum target_xfer_status section_table_xfer_memory_partial(gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len, struct target_section *sections, struct target_section *sections_end, const char *section_name)
Definition: exec.c:754
#define END_CATCH
const char * target_xfer_status_to_string(enum target_xfer_status status)
Definition: target.c:891
int target_has_execution_1(ptid_t the_ptid)
Definition: target.c:296
void target_program_signals(int numsigs, unsigned char *program_signals)
Definition: target.c:2267
struct cmd_list_element * maintenance_set_cmdlist
Definition: maint.c:646
int target_fileio_close(int fd, int *target_errno)
Definition: target.c:2912
int may_insert_tracepoints
void printf_filtered(const char *format,...)
Definition: utils.c:2388
DEF_VEC_O(fileio_fh_t)
enum target_xfer_status target_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: target.c:1281
void(* to_insn_history_range)(struct target_ops *, ULONGEST begin, ULONGEST end, int flags) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1178
struct obj_section * find_pc_overlay(CORE_ADDR pc)
Definition: symfile.c:3287
CORE_ADDR lo
Definition: memattr.h:79
Definition: memattr.h:30
static void release_fileio_fd(int fd, fileio_fh_t *fh)
Definition: target.c:2771
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
int target_read_code(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1456
int gdbarch_addressable_memory_unit_size(struct gdbarch *gdbarch)
Definition: gdbarch.c:4740
mach_port_t kern_return_t mach_port_t msgports mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition: gnu-nat.c:1885
int target_record_is_replaying(void)
Definition: target.c:3624
#define TRY
int default_child_has_memory(struct target_ops *ops)
Definition: target.c:206
void memory_error(enum target_xfer_status err, CORE_ADDR memaddr)
Definition: corefile.c:217
struct cmd_list_element * setlist
Definition: cli-cmds.c:135
static int may_write_registers_1
Definition: target.c:3809
int * from
Definition: varobj.h:282
#define VEC_iterate(T, V, I, P)
Definition: vec.h:165
int target_has_all_memory_1(void)
Definition: target.c:248
static void default_terminal_info(struct target_ops *self, const char *args, int from_tty)
Definition: target.c:576
int cache
Definition: memattr.h:66
#define OPS_MAGIC
Definition: target.h:1233
static char * do_option(int *target_options, char *ret, int opt, char *opt_str)
Definition: target.c:3351
VEC(mem_region_s)
Definition: target.c:1505
static int delegate_can_run(struct target_ops *self)
void target_flash_erase(ULONGEST address, LONGEST length)
Definition: target.c:1542
int may_stop
void target_dcache_invalidate(void)
Definition: target-dcache.c:51
#define CATCH(EXCEPTION, MASK)
void(* to_prepare_to_generate_core)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:1217
char * target_options_to_string(int target_options)
Definition: target.c:3364
static void open_target(char *args, int from_tty, struct cmd_list_element *command)
Definition: target.c:348
#define DO_TARG_OPTION(OPT)
struct address_space * aspace
Definition: inferior.h:314
const struct target_desc * target_read_description(struct target_ops *target)
Definition: target.c:2314
ULONGEST get_target_memory_unsigned(struct target_ops *ops, CORE_ADDR addr, int len, enum bfd_endian byte_order)
Definition: target.c:2031
struct cleanup * make_cleanup_dtor(make_cleanup_ftype *function, void *arg, make_cleanup_dtor_ftype *dtor)
Definition: cleanups.c:126
void(* to_call_history_range)(struct target_ops *, ULONGEST begin, ULONGEST end, int flags) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1198
char *(* to_thread_name)(struct target_ops *, struct thread_info *) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:635
void target_load(const char *arg, int from_tty)
Definition: target.c:426
static void set_write_memory_permission(char *args, int from_tty, struct cmd_list_element *c)
Definition: target.c:3854
int fputc_unfiltered(int c, struct ui_file *stream)
Definition: utils.c:2169
struct target_ops current_target
static int default_region_ok_for_hw_watchpoint(struct target_ops *self, CORE_ADDR addr, int len)
Definition: target.c:3111
static int find_default_supports_disable_randomization(struct target_ops *self)
Definition: target.c:2625
void target_clear_description(void)
#define DEF_VEC_P(T)
Definition: vec.h:422
void complete_target_initialization(struct target_ops *t)
Definition: target.c:317
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
void target_check_pending_interrupt(void)
Definition: target.c:3303
static enum target_xfer_status memory_xfer_partial_1(struct target_ops *ops, enum target_object object, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
Definition: target.c:1115
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition: cli-decode.c:159
void update_target_permissions(void)
Definition: target.c:3819
char * target_get_osdata(const char *type)
Definition: target.c:2648
int target_dcache_init_p(void)
Definition: target-dcache.c:40
struct mem_region * lookup_mem_region(CORE_ADDR addr)
Definition: memattr.c:226
static void generic_tls_error(void)
Definition: target.c:49
struct mem_attrib attrib
Definition: memattr.h:92
int simple_verify_memory(struct target_ops *ops, const gdb_byte *data, CORE_ADDR lma, ULONGEST size)
Definition: target.c:3448
void target_terminal_inferior(void)
Definition: target.c:470
void target_resume(ptid_t ptid, int step, enum gdb_signal signal)
Definition: target.c:2245
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
static int may_insert_fast_tracepoints_1
Definition: target.c:3813
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 read_whatever_is_readable(struct target_ops *ops, const ULONGEST begin, const ULONGEST end, int unit_size, VEC(memory_read_result_s)**result)
Definition: target.c:1653
struct cmd_list_element * showlist
Definition: cli-cmds.c:143
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:2145
struct target_section_table *(* to_get_section_table)(struct target_ops *) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:648
static struct gdbarch * default_thread_architecture(struct target_ops *ops, ptid_t ptid)
Definition: target.c:3126
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:56
int target_has_stack_1(void)
Definition: target.c:272
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:192
#define TARGET_WNOHANG
Definition: wait.h:28
void free_current_contents(void *ptr)
Definition: utils.c:476
int(* to_can_run)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:612
void update_observer_mode(void)
Definition: infrun.c:262
static int default_watchpoint_addr_within_range(struct target_ops *target, CORE_ADDR addr, CORE_ADDR start, int length)
Definition: target.c:3118
btrace_read_type
CORE_ADDR(* to_get_thread_local_address)(struct target_ops *ops, ptid_t ptid, CORE_ADDR load_module_addr, CORE_ADDR offset) TARGET_DEFAULT_NORETURN(generic_tls_error())
Definition: target.h:689
int default_child_has_all_memory(struct target_ops *ops)
Definition: target.c:196
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
#define VEC_length(T, V)
Definition: vec.h:124
static void setup_target_debug(void)
Definition: target.c:3734
int get_traceframe_number(void)
Definition: tracepoint.c:3180
int target_write_raw_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
Definition: target.c:1492
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
int sync_execution
Definition: infrun.c:117
struct target_section * sections
Definition: target.h:2276
target_xfer_status
Definition: target.h:219
struct btrace_target_info *(* to_enable_btrace)(struct target_ops *, ptid_t ptid, const struct btrace_config *conf) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1097
int(* to_masked_watch_num_registers)(struct target_ops *, CORE_ADDR, CORE_ADDR) TARGET_DEFAULT_RETURN(-1)
Definition: target.h:562
void add_target_with_completer(struct target_ops *t, completer_ftype *completer)
Definition: target.c:368
int(* to_has_execution)(struct target_ops *, ptid_t)
Definition: target.h:655
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
static void do_monitor_command(char *cmd, int from_tty)
Definition: target.c:3755
int gdbarch_has_global_breakpoints(struct gdbarch *gdbarch)
Definition: gdbarch.c:4363
Definition: gdbtypes.h:749
static void delegate_terminal_ours(struct target_ops *self)
int target_remove_mask_watchpoint(CORE_ADDR addr, CORE_ADDR mask, int rw)
Definition: target.c:3507
static struct address_space * default_thread_address_space(struct target_ops *self, ptid_t ptid)
Definition: target.c:2667
char * target_read_stralloc(struct target_ops *ops, enum target_object object, const char *annex)
Definition: target.c:1984
int(* to_fileio_fstat)(struct target_ops *, int fd, struct stat *sb, int *target_errno)
Definition: target.h:894
struct cmd_list_element * add_info(const char *name, cmd_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:857
Definition: gnu-nat.c:163
exec_direction_kind
Definition: infrun.h:65
void pop_all_targets(void)
Definition: target.c:767
void target_mourn_inferior(void)
Definition: target.c:2300
#define gdb_assert(expr)
Definition: gdb_assert.h:33
#define MIN(A, B)
Definition: target.c:906
static int may_insert_tracepoints_1
Definition: target.c:3812
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
Definition: gdbarch.c:2117
#define min(a, b)
Definition: defs.h:106
void target_goto_record_end(void)
Definition: target.c:3640
const char * to_doc
Definition: target.h:434
#define symfile_objfile
Definition: progspace.h:216
int target_read_uint32(CORE_ADDR memaddr, uint32_t *result)
Definition: target.c:1408
void target_close(struct target_ops *targ)
Definition: target.c:3263
static void show_targetdebug(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: target.c:176
CORE_ADDR endaddr
Definition: target.h:2260
void target_continue_no_signal(ptid_t ptid)
Definition: target.c:3328
const struct btrace_config *(* to_btrace_conf)(struct target_ops *self, const struct btrace_target_info *) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:1124
btrace_error
#define target_has_execution
Definition: target.h:1726
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
struct btrace_config conf
Definition: linux-btrace.h:90
void target_goto_record(ULONGEST insn)
Definition: target.c:3648
void exit_inferior(int pid)
Definition: inferior.c:282
struct target_ops * find_target_beneath(struct target_ops *t)
Definition: target.c:3148
int(* to_search_memory)(struct target_ops *ops, CORE_ADDR start_addr, ULONGEST search_space_len, const gdb_byte *pattern, ULONGEST pattern_len, CORE_ADDR *found_addrp) TARGET_DEFAULT_FUNC(default_search_memory)
Definition: target.h:794
char * xstrprintf(const char *format,...)
Definition: common-utils.c:107
int target_has_execution_current(void)
Definition: target.c:308
static char * str_comma_list_concat_elem(char *list, const char *elem)
Definition: target.c:3337
void printf_unfiltered(const char *format,...)
Definition: utils.c:2399
struct cmd_list_element * setdebuglist
Definition: cli-cmds.c:173
ptid_t target_wait(ptid_t ptid, struct target_waitstatus *status, int options)
Definition: target.c:2227
info_proc_what
Definition: defs.h:431
LONGEST target_fileio_read_alloc(struct inferior *inf, const char *filename, gdb_byte **buf_p)
Definition: target.c:3070
void(* to_detach)(struct target_ops *ops, const char *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:460
char * target_fileio_read_stralloc(struct inferior *inf, const char *filename)
Definition: target.c:3079
struct bfd_section * the_bfd_section
Definition: target.h:2262
int number
Definition: memattr.h:85
const char * objfile_name(const struct objfile *objfile)
Definition: objfiles.c:1499
ULONGEST end
Definition: target.h:299
int target_fileio_unlink(struct inferior *inf, const char *filename, int *target_errno)
Definition: target.c:2935
void target_save_record(const char *filename)
Definition: target.c:3593
void * xmalloc(YYSIZE_T)
int target_has_memory_1(void)
Definition: target.c:260
static enum exec_direction_kind default_execution_direction(struct target_ops *self)
Definition: target.c:594
struct ui_file * gdb_stdlog
Definition: main.c:73
struct cmd_list_element * maintenanceprintlist
Definition: cli-cmds.c:167
target_object
Definition: target.h:136
enum btrace_error target_read_btrace(struct btrace_data *btrace, struct btrace_target_info *btinfo, enum btrace_read_type type)
Definition: target.c:3567
ULONGEST begin
Definition: target.h:297
static void delegate_delete_record(struct target_ops *self)
void agent_capability_invalidate(void)
Definition: agent.c:278
static void install_delegators(struct target_ops *ops)
void target_stop_recording(void)
Definition: target.c:3585
int target_is_pushed(struct target_ops *t)
Definition: target.c:775
CORE_ADDR addr
Definition: target.h:2259
char * normal_pid_to_str(ptid_t ptid)
Definition: target.c:3207
int(* to_remove_mask_watchpoint)(struct target_ops *, CORE_ADDR, CORE_ADDR, int) TARGET_DEFAULT_RETURN(1)
Definition: target.h:539
static int dummy_find_memory_regions(struct target_ops *self, find_memory_region_ftype ignore1, void *ignore2)
Definition: target.c:3223
void(* to_disconnect)(struct target_ops *, const char *, int) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:462
Definition: value.c:172
void breakpoint_xfer_memory(gdb_byte *readbuf, gdb_byte *writebuf, const gdb_byte *writebuf_org, ULONGEST memaddr, LONGEST len)
Definition: breakpoint.c:1581
void target_call_history_range(ULONGEST begin, ULONGEST end, int flags)
Definition: target.c:3696
int target_read_raw_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1426
int ptid_get_pid(ptid_t ptid)
Definition: ptid.c:52
enum btrace_error(* to_read_btrace)(struct target_ops *self, struct btrace_data *data, struct btrace_target_info *btinfo, enum btrace_read_type type) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1117
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:51
int(* to_verify_memory)(struct target_ops *, const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size) TARGET_DEFAULT_FUNC(default_verify_memory)
Definition: target.h:1049
int(* to_fileio_open)(struct target_ops *, struct inferior *inf, const char *filename, int flags, int mode, int warn_if_slow, int *target_errno)
Definition: target.h:872
#define is_closed_fileio_fh(fd)
void target_terminal_init(void)
Definition: target.c:452
void throw_exception(struct gdb_exception exception)
static void default_mourn_inferior(struct target_ops *self)
Definition: target.c:2293
bfd_byte gdb_byte
Definition: common-types.h:38
void target_update_thread_list(void)
Definition: target.c:3283
static enum target_xfer_status target_write_partial(struct target_ops *ops, enum target_object object, const char *annex, const gdb_byte *buf, ULONGEST offset, LONGEST len, ULONGEST *xfered_len)
Definition: target.c:1576
int simple_search_memory(struct target_ops *ops, CORE_ADDR start_addr, ULONGEST search_space_len, const gdb_byte *pattern, ULONGEST pattern_len, CORE_ADDR *found_addrp)
Definition: target.c:2324
int non_stop
Definition: infrun.c:180
int target_insert_breakpoint(struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: target.c:2044
struct target_ops * t
Definition: target.c:2715
void(* to_flash_erase)(struct target_ops *, ULONGEST address, LONGEST length) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:754
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
const struct frame_unwind *(* to_get_unwinder)(struct target_ops *self) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:1210
int target_info_proc(const char *args, enum info_proc_what what)
Definition: target.c:2595
static void cleanup_restore_target_terminal(void *arg)
Definition: target.c:532
void free_memory_read_result_vector(void *x)
Definition: target.c:1769
static int default_search_memory(struct target_ops *self, CORE_ADDR start_addr, ULONGEST search_space_len, const gdb_byte *pattern, ULONGEST pattern_len, CORE_ADDR *found_addrp)
Definition: target.c:2429
int default_child_has_registers(struct target_ops *ops)
Definition: target.c:226
CORE_ADDR target_translate_tls_address(struct objfile *objfile, CORE_ADDR offset)
Definition: target.c:809
int may_insert_breakpoints
void target_pre_inferior(int from_tty)
Definition: target.c:2110
int gdbarch_fetch_tls_load_module_address_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:2805
void(* to_pass_signals)(struct target_ops *, int, unsigned char *TARGET_DEBUG_PRINTER(target_debug_print_signals)) TARGET_DEFAULT_IGNORE()
Definition: target.h:617
void(* to_stop)(struct target_ops *, ptid_t) TARGET_DEFAULT_IGNORE()
Definition: target.h:637
static LONGEST target_fileio_read_alloc_1(struct inferior *inf, const char *filename, gdb_byte **buf_p, int padding)
Definition: target.c:3009
void(* to_teardown_btrace)(struct target_ops *, struct btrace_target_info *tinfo) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1111
void prepare_for_detach(void)
Definition: infrun.c:3087
ptid_t ptid
Definition: gdbthread.h:169
void registers_changed_ptid(ptid_t ptid)
Definition: regcache.c:586
int target_terminal_is_inferior(void)
Definition: target.c:462
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
int target_async_permitted
Definition: target.c:3778
int(* to_fileio_pwrite)(struct target_ops *, int fd, const gdb_byte *write_buf, int len, ULONGEST offset, int *target_errno)
Definition: target.h:880
#define INHERIT(FIELD, TARGET)
void(* to_kill)(struct target_ops *) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:575
static int dispose_inferior(struct inferior *inf, void *args)
Definition: target.c:2148
struct ui_file * gdb_stderr
Definition: main.c:72
void breakpoint_init_inferior(enum inf_context context)
Definition: breakpoint.c:4080
ptid_t inferior_ptid
Definition: infcmd.c:124
int target_search_memory(CORE_ADDR start_addr, ULONGEST search_space_len, const gdb_byte *pattern, ULONGEST pattern_len, CORE_ADDR *found_addrp)
Definition: target.c:2448
void target_stop_and_wait(ptid_t ptid)
Definition: target.c:3311
enum strata to_stratum
Definition: target.h:650
int remove_breakpoints(void)
Definition: breakpoint.c:3184
void(* to_goto_record_end)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1154
static char * dummy_make_corefile_notes(struct target_ops *self, bfd *ignore1, int *ignore2)
Definition: target.c:3232
void(* to_open)(const char *, int)
Definition: target.h:443
int offset
Definition: agent.c:65
void pop_all_targets_above(enum strata above_stratum)
Definition: target.c:750
int(* to_ranged_break_num_registers)(struct target_ops *) TARGET_DEFAULT_RETURN(-1)
Definition: target.h:518
void(* to_call_history_from)(struct target_ops *, ULONGEST begin, int size, int flags) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1192
int may_write_memory
void registers_changed(void)
Definition: regcache.c:624
int target_has_registers_1(void)
Definition: target.c:284
struct target_section * target_section_by_addr(struct target_ops *target, CORE_ADDR addr)
Definition: target.c:990
static void update_current_target(void)
Definition: target.c:618
Definition: buffer.h:23
int(* to_can_async_p)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:660
#define target_rcmd(command, outbuf)
Definition: target.h:1685
int may_write_registers
#define VEC_free(T, V)
Definition: vec.h:180
#define qsort
Definition: ada-exp.c:2747
void target_call_history(int size, int flags)
Definition: target.c:3680
void(* to_create_inferior)(struct target_ops *, char *, char *, char **, int)
Definition: target.h:584
#define VEC_address(T, V)
Definition: vec.h:369
int to_have_steppable_watchpoint
Definition: target.h:544
void target_done_generating_core(void)
Definition: target.c:3728
struct target_ops * find_run_target(void)
Definition: target.c:2574
static void tdefault_terminal_ours(struct target_ops *self)
struct ui_file * gdb_stdtarg
Definition: main.c:77
#define SEARCH_CHUNK_SIZE
CORE_ADDR hi
Definition: memattr.h:82
int target_core_of_thread(ptid_t ptid)
Definition: target.c:3442
int target_fileio_pread(int fd, gdb_byte *read_buf, int len, ULONGEST offset, int *target_errno)
Definition: target.c:2868
void(* to_terminal_ours)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:571
int target_ranged_break_num_registers(void)
Definition: target.c:3527
static void show_auto_connect_native_target(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: target.c:2499
static int default_verify_memory(struct target_ops *self, const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
Definition: target.c:3478
void(* to_terminal_inferior)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:567
static void default_rcmd(struct target_ops *self, const char *command, struct ui_file *output)
Definition: target.c:3748
const char * to_shortname
Definition: target.h:432
LONGEST target_write_with_progress(struct target_ops *ops, enum target_object object, const char *annex, const gdb_byte *buf, ULONGEST offset, LONGEST len, void(*progress)(ULONGEST, void *), void *baton)
Definition: target.c:1848
enum overlay_debugging_state overlay_debugging
Definition: symfile.c:3081
void target_delete_record(void)
Definition: target.c:3616
int to_have_continuable_watchpoint
Definition: target.h:545
static void maintenance_print_target_stack(char *cmd, int from_tty)
Definition: target.c:3764
struct target_section_table * target_get_section_table(struct target_ops *target)
Definition: target.c:982
unsigned long long ULONGEST
Definition: common-types.h:53
void target_store_registers(struct regcache *regcache, int regno)
Definition: target.c:3427
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 void init_dummy_target(void)
Definition: target.c:3243
int target_write_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
Definition: target.c:1474
int register_size(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:169
void(* to_insn_history)(struct target_ops *, int size, int flags) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1165
int(* to_record_is_replaying)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:1146
int(* to_supports_non_stop)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:668
void target_disconnect(const char *args, int from_tty)
Definition: target.c:2216
int target_insert_mask_watchpoint(CORE_ADDR addr, CORE_ADDR mask, int rw)
Definition: target.c:3497
int(* to_has_all_memory)(struct target_ops *)
Definition: target.h:651
LONGEST target_read(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *buf, ULONGEST offset, LONGEST len)
Definition: target.c:1590
struct target_ops * find_attach_target(void)
Definition: target.c:2553
void regcache_raw_collect(const struct regcache *regcache, int regnum, void *buf)
Definition: regcache.c:1071
struct cmd_list_element * showdebuglist
Definition: cli-cmds.c:175
int target_follow_fork(int follow_child, int detach_fork)
Definition: target.c:2286
void(* to_done_generating_core)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:1221
int(* to_fileio_unlink)(struct target_ops *, struct inferior *inf, const char *filename, int *target_errno)
Definition: target.h:905
void target_terminal_ours_for_output(void)
Definition: target.c:503
unsigned short flags
Definition: objfiles.h:282
int target_fileio_fstat(int fd, struct stat *sb, int *target_errno)
Definition: target.c:2892
CORE_ADDR overlay_mapped_address(CORE_ADDR pc, struct obj_section *section)
Definition: symfile.c:3238
int to_has_thread_control
Definition: target.h:656
int(* to_thread_alive)(struct target_ops *, ptid_t ptid) TARGET_DEFAULT_RETURN(0)
Definition: target.h:627
void(* to_info_proc)(struct target_ops *, const char *, enum info_proc_what)
Definition: target.h:922
int target_fileio_open(struct inferior *inf, const char *filename, int flags, int mode, int *target_errno)
Definition: target.c:2823
void * arg
Definition: cleanups.c:43
void(* to_attach)(struct target_ops *ops, const char *, int)
Definition: target.h:457
void target_preopen(int from_tty)
Definition: target.c:2171
void dont_repeat(void)
Definition: top.c:582
void reinit_frame_cache(void)
Definition: frame.c:1687
int code_cache_enabled_p(void)
int remove_breakpoints_pid(int pid)
Definition: breakpoint.c:3224
static void init_debug_target(struct target_ops *ops)
CORE_ADDR gdbarch_fetch_tls_load_module_address(struct gdbarch *gdbarch, struct objfile *objfile)
Definition: gdbarch.c:2812
int(* to_supports_btrace)(struct target_ops *, enum btrace_format) TARGET_DEFAULT_RETURN(0)
Definition: target.h:1091
static int return_zero(struct target_ops *ignore)
Definition: target.c:3132
#define QUIT
Definition: defs.h:160
static int target_async_permitted_1
Definition: target.c:3782
#define CASE(X)
void(* to_update_thread_list)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:629
static void restore_show_memory_breakpoints(void *arg)
Definition: target.c:1263
static void maint_show_target_async_command(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: target.c:3798
void(* to_store_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:474
int(* find_memory_region_ftype)(CORE_ADDR addr, unsigned long size, int read, int write, int exec, int modified, void *data)
Definition: defs.h:343
int(* to_has_registers)(struct target_ops *)
Definition: target.h:654
void noprocess(void)
Definition: target.c:570
CORE_ADDR pc_in_unmapped_range(CORE_ADDR pc, struct obj_section *section)
Definition: symfile.c:3165
struct cmd_list_element * maintenance_show_cmdlist
Definition: maint.c:647
enum bfd_endian byte_order
Definition: gdbarch.c:128
int stack_cache_enabled_p(void)
int target_read_string(CORE_ADDR memaddr, char **string, int len, int *errnop)
Definition: target.c:915
static void target_command(char *arg, int from_tty)
Definition: target.c:187
static void tdefault_delete_record(struct target_ops *self)
void invalidate_target_mem_regions(void)
Definition: memattr.c:295
void dcache_update(DCACHE *dcache, enum target_xfer_status status, CORE_ADDR memaddr, const gdb_byte *myaddr, ULONGEST len)
Definition: dcache.c:525
static void tcomplain(void)
Definition: target.c:563
void target_insn_history_range(ULONGEST begin, ULONGEST end, int flags)
Definition: target.c:3672
void target_insn_history(int size, int flags)
Definition: target.c:3656
const struct btrace_config * target_btrace_conf(const struct btrace_target_info *btinfo)
Definition: target.c:3577
static void show_trust_readonly(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: target.c:1554
DCACHE * target_dcache_get(void)
Definition: target-dcache.c:64
int(* to_insert_mask_watchpoint)(struct target_ops *, CORE_ADDR, CORE_ADDR, int) TARGET_DEFAULT_RETURN(1)
Definition: target.h:536
void(* to_disable_btrace)(struct target_ops *, struct btrace_target_info *tinfo) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1103
void set_executing(ptid_t ptid, int executing)
Definition: thread.c:850
struct thread_info * any_thread_of_process(int pid)
Definition: thread.c:510
int target_read_stack(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1441
void error(const char *fmt,...)
Definition: errors.c:38
static void debug_print_register(const char *func, struct regcache *regcache, int regno)
Definition: target.c:3382
size_t size
Definition: go32-nat.c:242
char *(* to_fileio_readlink)(struct target_ops *, struct inferior *inf, const char *filename, int *target_errno)
Definition: target.h:915
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
int target_fileio_open_warn_if_slow(struct inferior *inf, const char *filename, int flags, int mode, int *target_errno)
Definition: target.c:2833
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 throw_error(enum errors error, const char *fmt,...)
long long LONGEST
Definition: common-types.h:52
int target_masked_watch_num_registers(CORE_ADDR addr, CORE_ADDR mask)
Definition: target.c:3517
struct target_ops * beneath
Definition: target.h:431
static void target_info(char *, int)
Definition: target.c:2078
void(* to_load)(struct target_ops *, const char *, int) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:577
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:541
struct cleanup * make_cleanup_restore_target_terminal(void)
Definition: target.c:553
void target_flash_done(void)
Definition: target.c:1548
static int may_write_memory_1
Definition: target.c:3810
enum target_xfer_status raw_memory_xfer_partial(struct target_ops *ops, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST memaddr, LONGEST len, ULONGEST *xfered_len)
Definition: target.c:1064
static int may_insert_breakpoints_1
Definition: target.c:3811
static void target_fileio_close_cleanup(void *opaque)
Definition: target.c:2992
int mem_region_cmp(const void *untyped_lhs, const void *untyped_rhs)
Definition: memattr.c:99
static LONGEST target_read_alloc_1(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte **buf_p, int padding)
Definition: target.c:1910
void(* to_goto_record)(struct target_ops *, ULONGEST insn) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1158
enum mem_access_mode mode
Definition: memattr.h:58
void mark_breakpoints_out(void)
Definition: breakpoint.c:4058
static void maint_set_target_async_command(char *args, int from_tty, struct cmd_list_element *c)
Definition: target.c:3785
const ULONGEST const LONGEST len
Definition: target.h:309
struct target_ops * find_target_at(enum strata stratum)
Definition: target.c:3156
int to_attach_no_wait
Definition: target.h:657
void add_deprecated_target_alias(struct target_ops *t, char *alias)
Definition: target.c:403