GDB (xrefs)
/tmp/gdb-7.10/gdb/auxv.c
Go to the documentation of this file.
1 /* Auxiliary vector support for GDB, the GNU debugger.
2 
3  Copyright (C) 2004-2015 Free Software Foundation, Inc.
4 
5  This file is part of GDB.
6 
7  This program is free software; you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation; either version 3 of the License, or
10  (at your option) any later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 
20 #include "defs.h"
21 #include "target.h"
22 #include "gdbtypes.h"
23 #include "command.h"
24 #include "inferior.h"
25 #include "valprint.h"
26 #include "gdbcore.h"
27 #include "observer.h"
28 #include "filestuff.h"
29 #include "objfiles.h"
30 
31 #include "auxv.h"
32 #include "elf/common.h"
33 
34 #include <unistd.h>
35 #include <fcntl.h>
36 
37 
38 /* Implement the to_xfer_partial target_ops method. This function
39  handles access via /proc/PID/auxv, which is a common method for
40  native targets. */
41 
42 static enum target_xfer_status
44  const gdb_byte *writebuf,
46  ULONGEST len,
47  ULONGEST *xfered_len)
48 {
49  char *pathname;
50  int fd;
51  ssize_t l;
52 
53  pathname = xstrprintf ("/proc/%d/auxv", ptid_get_pid (inferior_ptid));
54  fd = gdb_open_cloexec (pathname, writebuf != NULL ? O_WRONLY : O_RDONLY, 0);
55  xfree (pathname);
56  if (fd < 0)
57  return TARGET_XFER_E_IO;
58 
59  if (offset != (ULONGEST) 0
60  && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
61  l = -1;
62  else if (readbuf != NULL)
63  l = read (fd, readbuf, (size_t) len);
64  else
65  l = write (fd, writebuf, (size_t) len);
66 
67  (void) close (fd);
68 
69  if (l < 0)
70  return TARGET_XFER_E_IO;
71  else if (l == 0)
72  return TARGET_XFER_EOF;
73  else
74  {
75  *xfered_len = (ULONGEST) l;
76  return TARGET_XFER_OK;
77  }
78 }
79 
80 /* This function handles access via ld.so's symbol `_dl_auxv'. */
81 
82 static enum target_xfer_status
84  const gdb_byte *writebuf,
86  ULONGEST len, ULONGEST *xfered_len)
87 {
88  struct bound_minimal_symbol msym;
89  CORE_ADDR data_address, pointer_address;
90  struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
91  size_t ptr_size = TYPE_LENGTH (ptr_type);
92  size_t auxv_pair_size = 2 * ptr_size;
93  gdb_byte *ptr_buf = alloca (ptr_size);
94  LONGEST retval;
95  size_t block;
96 
97  msym = lookup_minimal_symbol ("_dl_auxv", NULL, NULL);
98  if (msym.minsym == NULL)
99  return TARGET_XFER_E_IO;
100 
101  if (MSYMBOL_SIZE (msym.minsym) != ptr_size)
102  return TARGET_XFER_E_IO;
103 
104  /* POINTER_ADDRESS is a location where the `_dl_auxv' variable
105  resides. DATA_ADDRESS is the inferior value present in
106  `_dl_auxv', therefore the real inferior AUXV address. */
107 
108  pointer_address = BMSYMBOL_VALUE_ADDRESS (msym);
109 
110  /* The location of the _dl_auxv symbol may no longer be correct if
111  ld.so runs at a different address than the one present in the
112  file. This is very common case - for unprelinked ld.so or with a
113  PIE executable. PIE executable forces random address even for
114  libraries already being prelinked to some address. PIE
115  executables themselves are never prelinked even on prelinked
116  systems. Prelinking of a PIE executable would block their
117  purpose of randomizing load of everything including the
118  executable.
119 
120  If the memory read fails, return -1 to fallback on another
121  mechanism for retrieving the AUXV.
122 
123  In most cases of a PIE running under valgrind there is no way to
124  find out the base addresses of any of ld.so, executable or AUXV
125  as everything is randomized and /proc information is not relevant
126  for the virtual executable running under valgrind. We think that
127  we might need a valgrind extension to make it work. This is PR
128  11440. */
129 
130  if (target_read_memory (pointer_address, ptr_buf, ptr_size) != 0)
131  return TARGET_XFER_E_IO;
132 
133  data_address = extract_typed_address (ptr_buf, ptr_type);
134 
135  /* Possibly still not initialized such as during an inferior
136  startup. */
137  if (data_address == 0)
138  return TARGET_XFER_E_IO;
139 
140  data_address += offset;
141 
142  if (writebuf != NULL)
143  {
144  if (target_write_memory (data_address, writebuf, len) == 0)
145  {
146  *xfered_len = (ULONGEST) len;
147  return TARGET_XFER_OK;
148  }
149  else
150  return TARGET_XFER_E_IO;
151  }
152 
153  /* Stop if trying to read past the existing AUXV block. The final
154  AT_NULL was already returned before. */
155 
156  if (offset >= auxv_pair_size)
157  {
158  if (target_read_memory (data_address - auxv_pair_size, ptr_buf,
159  ptr_size) != 0)
160  return TARGET_XFER_E_IO;
161 
162  if (extract_typed_address (ptr_buf, ptr_type) == AT_NULL)
163  return TARGET_XFER_EOF;
164  }
165 
166  retval = 0;
167  block = 0x400;
168  gdb_assert (block % auxv_pair_size == 0);
169 
170  while (len > 0)
171  {
172  if (block > len)
173  block = len;
174 
175  /* Reading sizes smaller than AUXV_PAIR_SIZE is not supported.
176  Tails unaligned to AUXV_PAIR_SIZE will not be read during a
177  call (they should be completed during next read with
178  new/extended buffer). */
179 
180  block &= -auxv_pair_size;
181  if (block == 0)
182  break;
183 
184  if (target_read_memory (data_address, readbuf, block) != 0)
185  {
186  if (block <= auxv_pair_size)
187  break;
188 
189  block = auxv_pair_size;
190  continue;
191  }
192 
193  data_address += block;
194  len -= block;
195 
196  /* Check terminal AT_NULL. This function is being called
197  indefinitely being extended its READBUF until it returns EOF
198  (0). */
199 
200  while (block >= auxv_pair_size)
201  {
202  retval += auxv_pair_size;
203 
204  if (extract_typed_address (readbuf, ptr_type) == AT_NULL)
205  {
206  *xfered_len = (ULONGEST) retval;
207  return TARGET_XFER_OK;
208  }
209 
210  readbuf += auxv_pair_size;
211  block -= auxv_pair_size;
212  }
213  }
214 
215  *xfered_len = (ULONGEST) retval;
216  return TARGET_XFER_OK;
217 }
218 
219 /* Implement the to_xfer_partial target_ops method for
220  TARGET_OBJECT_AUXV. It handles access to AUXV. */
221 
224  enum target_object object,
225  const char *annex,
226  gdb_byte *readbuf,
227  const gdb_byte *writebuf,
229  ULONGEST len, ULONGEST *xfered_len)
230 {
231  gdb_assert (object == TARGET_OBJECT_AUXV);
232  gdb_assert (readbuf || writebuf);
233 
234  /* ld_so_xfer_auxv is the only function safe for virtual
235  executables being executed by valgrind's memcheck. Using
236  ld_so_xfer_auxv during inferior startup is problematic, because
237  ld.so symbol tables have not yet been relocated. So GDB uses
238  this function only when attaching to a process.
239  */
240 
241  if (current_inferior ()->attach_flag != 0)
242  {
243  enum target_xfer_status ret;
244 
245  ret = ld_so_xfer_auxv (readbuf, writebuf, offset, len, xfered_len);
246  if (ret != TARGET_XFER_E_IO)
247  return ret;
248  }
249 
250  return procfs_xfer_auxv (readbuf, writebuf, offset, len, xfered_len);
251 }
252 
253 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
254  Return 0 if *READPTR is already at the end of the buffer.
255  Return -1 if there is insufficient buffer for a whole entry.
256  Return 1 if an entry was read into *TYPEP and *VALP. */
257 int
258 default_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
259  gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
260 {
261  const int sizeof_auxv_field = gdbarch_ptr_bit (target_gdbarch ())
262  / TARGET_CHAR_BIT;
263  const enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
264  gdb_byte *ptr = *readptr;
265 
266  if (endptr == ptr)
267  return 0;
268 
269  if (endptr - ptr < sizeof_auxv_field * 2)
270  return -1;
271 
272  *typep = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
273  ptr += sizeof_auxv_field;
274  *valp = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
275  ptr += sizeof_auxv_field;
276 
277  *readptr = ptr;
278  return 1;
279 }
280 
281 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
282  Return 0 if *READPTR is already at the end of the buffer.
283  Return -1 if there is insufficient buffer for a whole entry.
284  Return 1 if an entry was read into *TYPEP and *VALP. */
285 int
286 target_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
287  gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
288 {
289  struct gdbarch *gdbarch = target_gdbarch();
290 
291  if (gdbarch_auxv_parse_p (gdbarch))
292  return gdbarch_auxv_parse (gdbarch, readptr, endptr, typep, valp);
293 
294  return current_target.to_auxv_parse (&current_target, readptr, endptr,
295  typep, valp);
296 }
297 
298 
299 /* Per-inferior data key for auxv. */
300 static const struct inferior_data *auxv_inferior_data;
301 
302 /* Auxiliary Vector information structure. This is used by GDB
303  for caching purposes for each inferior. This helps reduce the
304  overhead of transfering data from a remote target to the local host. */
305 struct auxv_info
306 {
309 };
310 
311 /* Handles the cleanup of the auxv cache for inferior INF. ARG is ignored.
312  Frees whatever allocated space there is to be freed and sets INF's auxv cache
313  data pointer to NULL.
314 
315  This function is called when the following events occur: inferior_appeared,
316  inferior_exit and executable_changed. */
317 
318 static void
320 {
321  struct auxv_info *info;
322 
323  info = inferior_data (inf, auxv_inferior_data);
324  if (info != NULL)
325  {
326  xfree (info->data);
327  xfree (info);
328  set_inferior_data (inf, auxv_inferior_data, NULL);
329  }
330 }
331 
332 /* Invalidate INF's auxv cache. */
333 
334 static void
336 {
337  auxv_inferior_data_cleanup (inf, NULL);
338 }
339 
340 /* Invalidate current inferior's auxv cache. */
341 
342 static void
344 {
346 }
347 
348 /* Fetch the auxv object from inferior INF. If auxv is cached already,
349  return a pointer to the cache. If not, fetch the auxv object from the
350  target and cache it. This function always returns a valid INFO pointer. */
351 
352 static struct auxv_info *
354 {
355  struct auxv_info *info;
356  struct inferior *inf = current_inferior ();
357 
358  info = inferior_data (inf, auxv_inferior_data);
359  if (info == NULL)
360  {
361  info = XCNEW (struct auxv_info);
363  NULL, &info->data);
364  set_inferior_data (inf, auxv_inferior_data, info);
365  }
366 
367  return info;
368 }
369 
370 /* Extract the auxiliary vector entry with a_type matching MATCH.
371  Return zero if no such entry was found, or -1 if there was
372  an error getting the information. On success, return 1 after
373  storing the entry's value field in *VALP. */
374 int
376 {
377  CORE_ADDR type, val;
378  gdb_byte *data;
379  gdb_byte *ptr;
380  struct auxv_info *info;
381 
382  info = get_auxv_inferior_data (ops);
383 
384  data = info->data;
385  ptr = data;
386 
387  if (info->length <= 0)
388  return info->length;
389 
390  while (1)
391  switch (target_auxv_parse (ops, &ptr, data + info->length, &type, &val))
392  {
393  case 1: /* Here's an entry, check it. */
394  if (type == match)
395  {
396  *valp = val;
397  return 1;
398  }
399  break;
400  case 0: /* End of the vector. */
401  return 0;
402  default: /* Bogosity. */
403  return -1;
404  }
405 
406  /*NOTREACHED*/
407 }
408 
409 
410 /* Print the contents of the target's AUXV on the specified file. */
411 int
412 fprint_target_auxv (struct ui_file *file, struct target_ops *ops)
413 {
414  CORE_ADDR type, val;
415  gdb_byte *data;
416  gdb_byte *ptr;
417  struct auxv_info *info;
418  int ents = 0;
419 
420  info = get_auxv_inferior_data (ops);
421 
422  data = info->data;
423  ptr = data;
424  if (info->length <= 0)
425  return info->length;
426 
427  while (target_auxv_parse (ops, &ptr, data + info->length, &type, &val) > 0)
428  {
429  const char *name = "???";
430  const char *description = "";
431  enum { dec, hex, str } flavor = hex;
432 
433  switch (type)
434  {
435 #define TAG(tag, text, kind) \
436  case tag: name = #tag; description = text; flavor = kind; break
437  TAG (AT_NULL, _("End of vector"), hex);
438  TAG (AT_IGNORE, _("Entry should be ignored"), hex);
439  TAG (AT_EXECFD, _("File descriptor of program"), dec);
440  TAG (AT_PHDR, _("Program headers for program"), hex);
441  TAG (AT_PHENT, _("Size of program header entry"), dec);
442  TAG (AT_PHNUM, _("Number of program headers"), dec);
443  TAG (AT_PAGESZ, _("System page size"), dec);
444  TAG (AT_BASE, _("Base address of interpreter"), hex);
445  TAG (AT_FLAGS, _("Flags"), hex);
446  TAG (AT_ENTRY, _("Entry point of program"), hex);
447  TAG (AT_NOTELF, _("Program is not ELF"), dec);
448  TAG (AT_UID, _("Real user ID"), dec);
449  TAG (AT_EUID, _("Effective user ID"), dec);
450  TAG (AT_GID, _("Real group ID"), dec);
451  TAG (AT_EGID, _("Effective group ID"), dec);
452  TAG (AT_CLKTCK, _("Frequency of times()"), dec);
453  TAG (AT_PLATFORM, _("String identifying platform"), str);
454  TAG (AT_HWCAP, _("Machine-dependent CPU capability hints"), hex);
455  TAG (AT_FPUCW, _("Used FPU control word"), dec);
456  TAG (AT_DCACHEBSIZE, _("Data cache block size"), dec);
457  TAG (AT_ICACHEBSIZE, _("Instruction cache block size"), dec);
458  TAG (AT_UCACHEBSIZE, _("Unified cache block size"), dec);
459  TAG (AT_IGNOREPPC, _("Entry should be ignored"), dec);
460  TAG (AT_BASE_PLATFORM, _("String identifying base platform"), str);
461  TAG (AT_RANDOM, _("Address of 16 random bytes"), hex);
462  TAG (AT_HWCAP2, _("Extension of AT_HWCAP"), hex);
463  TAG (AT_EXECFN, _("File name of executable"), str);
464  TAG (AT_SECURE, _("Boolean, was exec setuid-like?"), dec);
465  TAG (AT_SYSINFO, _("Special system info/entry points"), hex);
466  TAG (AT_SYSINFO_EHDR, _("System-supplied DSO's ELF header"), hex);
467  TAG (AT_L1I_CACHESHAPE, _("L1 Instruction cache information"), hex);
468  TAG (AT_L1D_CACHESHAPE, _("L1 Data cache information"), hex);
469  TAG (AT_L2_CACHESHAPE, _("L2 cache information"), hex);
470  TAG (AT_L3_CACHESHAPE, _("L3 cache information"), hex);
471  TAG (AT_SUN_UID, _("Effective user ID"), dec);
472  TAG (AT_SUN_RUID, _("Real user ID"), dec);
473  TAG (AT_SUN_GID, _("Effective group ID"), dec);
474  TAG (AT_SUN_RGID, _("Real group ID"), dec);
475  TAG (AT_SUN_LDELF, _("Dynamic linker's ELF header"), hex);
476  TAG (AT_SUN_LDSHDR, _("Dynamic linker's section headers"), hex);
477  TAG (AT_SUN_LDNAME, _("String giving name of dynamic linker"), str);
478  TAG (AT_SUN_LPAGESZ, _("Large pagesize"), dec);
479  TAG (AT_SUN_PLATFORM, _("Platform name string"), str);
480  TAG (AT_SUN_HWCAP, _("Machine-dependent CPU capability hints"), hex);
481  TAG (AT_SUN_IFLUSH, _("Should flush icache?"), dec);
482  TAG (AT_SUN_CPU, _("CPU name string"), str);
483  TAG (AT_SUN_EMUL_ENTRY, _("COFF entry point address"), hex);
484  TAG (AT_SUN_EMUL_EXECFD, _("COFF executable file descriptor"), dec);
485  TAG (AT_SUN_EXECNAME,
486  _("Canonicalized file name given to execve"), str);
487  TAG (AT_SUN_MMU, _("String for name of MMU module"), str);
488  TAG (AT_SUN_LDDATA, _("Dynamic linker's data segment address"), hex);
489  TAG (AT_SUN_AUXFLAGS,
490  _("AF_SUN_ flags passed from the kernel"), hex);
491  }
492 
493  fprintf_filtered (file, "%-4s %-20s %-30s ",
494  plongest (type), name, description);
495  switch (flavor)
496  {
497  case dec:
498  fprintf_filtered (file, "%s\n", plongest (val));
499  break;
500  case hex:
501  fprintf_filtered (file, "%s\n", paddress (target_gdbarch (), val));
502  break;
503  case str:
504  {
505  struct value_print_options opts;
506 
507  get_user_print_options (&opts);
508  if (opts.addressprint)
509  fprintf_filtered (file, "%s ", paddress (target_gdbarch (), val));
510  val_print_string (builtin_type (target_gdbarch ())->builtin_char,
511  NULL, val, -1, file, &opts);
512  fprintf_filtered (file, "\n");
513  }
514  break;
515  }
516  ++ents;
517  if (type == AT_NULL)
518  break;
519  }
520 
521  return ents;
522 }
523 
524 static void
525 info_auxv_command (char *cmd, int from_tty)
526 {
527  if (! target_has_stack)
528  error (_("The program has no auxiliary information now."));
529  else
530  {
532 
533  if (ents < 0)
534  error (_("No auxiliary vector found, or failed reading it."));
535  else if (ents == 0)
536  error (_("Auxiliary vector is empty."));
537  }
538 }
539 
540 
541 extern initialize_file_ftype _initialize_auxv; /* -Wmissing-prototypes; */
542 
543 void
545 {
546  add_info ("auxv", info_auxv_command,
547  _("Display the inferior's auxiliary vector.\n\
548 This is information provided by the operating system at program startup."));
549 
550  /* Set an auxv cache per-inferior. */
552  = register_inferior_data_with_cleanup (NULL, auxv_inferior_data_cleanup);
553 
554  /* Observers used to invalidate the auxv cache when needed. */
558 }
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5143
ssize_t read(int fd, void *buf, size_t count)
Definition: expect-read1.c:26
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
Definition: findvar.c:169
bfd_vma CORE_ADDR
Definition: common-types.h:41
int target_write_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
Definition: target.c:1474
void xfree(void *)
Definition: common-utils.c:97
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:393
static enum target_xfer_status procfs_xfer_auxv(gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
Definition: auxv.c:43
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1690
LONGEST target_read_alloc(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte **buf_p)
Definition: target.c:1971
struct ui_file * gdb_stdout
Definition: main.c:71
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:4766
struct observer * observer_attach_executable_changed(observer_executable_changed_ftype *f)
int fprint_target_auxv(struct ui_file *file, struct target_ops *ops)
Definition: auxv.c:412
struct observer * observer_attach_inferior_exit(observer_inferior_exit_ftype *f)
static void invalidate_auxv_cache(void)
Definition: auxv.c:343
#define _(String)
Definition: gdb_locale.h:40
int gdbarch_auxv_parse(struct gdbarch *gdbarch, gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
Definition: gdbarch.c:4638
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2743
initialize_file_ftype _initialize_auxv
int default_auxv_parse(struct target_ops *ops, gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
Definition: auxv.c:258
int gdbarch_auxv_parse_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:4631
const char *const name
Definition: aarch64-tdep.c:68
struct target_ops current_target
void initialize_file_ftype(void)
Definition: defs.h:281
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
static const struct inferior_data * auxv_inferior_data
Definition: auxv.c:300
LONGEST length
Definition: auxv.c:307
int target_auxv_search(struct target_ops *ops, CORE_ADDR match, CORE_ADDR *valp)
Definition: auxv.c:375
static struct auxv_info * get_auxv_inferior_data(struct target_ops *ops)
Definition: auxv.c:353
#define MSYMBOL_SIZE(msymbol)
Definition: symtab.h:374
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
target_xfer_status
Definition: target.h:219
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
Definition: gdbtypes.h:749
#define TAG(tag, text, kind)
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
static const char * type
Definition: language.c:103
static void invalidate_auxv_cache_inf(struct inferior *inf)
Definition: auxv.c:335
#define gdb_assert(expr)
Definition: gdb_assert.h:33
int target_auxv_parse(struct target_ops *ops, gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
Definition: auxv.c:286
char * xstrprintf(const char *format,...)
Definition: common-utils.c:107
struct observer * observer_attach_inferior_appeared(observer_inferior_appeared_ftype *f)
target_object
Definition: target.h:136
Definition: block.h:60
int ptid_get_pid(ptid_t ptid)
Definition: ptid.c:52
int(* to_auxv_parse)(struct target_ops *ops, gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp) TARGET_DEFAULT_FUNC(default_auxv_parse)
Definition: target.h:784
bfd_byte gdb_byte
Definition: common-types.h:38
#define target_has_stack
Definition: target.h:1705
#define SEEK_SET
Definition: defs.h:87
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1393
ptid_t inferior_ptid
Definition: infcmd.c:124
struct type * builtin_data_ptr
Definition: gdbtypes.h:1533
struct minimal_symbol * minsym
Definition: minsyms.h:32
void get_user_print_options(struct value_print_options *opts)
Definition: valprint.c:129
int offset
Definition: agent.c:65
static void info_auxv_command(char *cmd, int from_tty)
Definition: auxv.c:525
int gdb_open_cloexec(const char *filename, int flags, unsigned long mode)
Definition: filestuff.c:291
static enum target_xfer_status ld_so_xfer_auxv(gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
Definition: auxv.c:83
struct inferior * current_inferior(void)
Definition: inferior.c:57
unsigned long long ULONGEST
Definition: common-types.h:53
enum target_xfer_status memory_xfer_auxv(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: auxv.c:223
gdb_byte * data
Definition: auxv.c:308
static void auxv_inferior_data_cleanup(struct inferior *inf, void *arg)
Definition: auxv.c:319
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
int val_print_string(struct type *elttype, const char *encoding, CORE_ADDR addr, int len, struct ui_file *stream, const struct value_print_options *options)
Definition: valprint.c:2496
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:163
void error(const char *fmt,...)
Definition: errors.c:38
long long LONGEST
Definition: common-types.h:52
const ULONGEST const LONGEST len
Definition: target.h:309