GDB (xrefs)

/tmp/gdb-8.1/gdb/auxv.c
Go to the documentation of this file.
1 /* Auxiliary vector support for GDB, the GNU debugger.
2
3 Copyright (C) 2004-2018 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
43 procfs_xfer_auxv (gdb_byte *readbuf,
44 const gdb_byte *writebuf,
45 ULONGEST offset,
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
83 ld_so_xfer_auxv (gdb_byte *readbuf,
84 const gdb_byte *writebuf,
85 ULONGEST offset,
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 = (gdb_byte *) 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
222 enum target_xfer_status
223 memory_xfer_auxv (struct target_ops *ops,
224 enum target_object object,
225 const char *annex,
226 gdb_byte *readbuf,
227 const gdb_byte *writebuf,
228 ULONGEST offset,
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 {
307 LONGEST length;
308 gdb_byte *data;
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
319 auxv_inferior_data_cleanup (struct inferior *inf, void *arg)
320 {
321 struct auxv_info *info;
322
323 info = (struct auxv_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
335 invalidate_auxv_cache_inf (struct inferior *inf)
336 {
337 auxv_inferior_data_cleanup (inf, NULL);
338 }
339
340 /* Invalidate current inferior's auxv cache. */
341
342 static void
343 invalidate_auxv_cache (void)
344 {
345 invalidate_auxv_cache_inf (current_inferior ());
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 *
353 get_auxv_inferior_data (struct target_ops *ops)
354 {
355 struct auxv_info *info;
356 struct inferior *inf = current_inferior ();
357
358 info = (struct auxv_info *) inferior_data (inf, auxv_inferior_data);
359 if (info == NULL)
360 {
361 info = XCNEW (struct auxv_info);
362 info->length = target_read_alloc (ops, TARGET_OBJECT_AUXV,
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
375 target_auxv_search (struct target_ops *ops, CORE_ADDR match, CORE_ADDR *valp)
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 description of a single AUXV entry on the specified file. */
411
412 void
413 fprint_auxv_entry (struct ui_file *file, const char *name,
414 const char *description, enum auxv_format format,
415 CORE_ADDR type, CORE_ADDR val)
416 {
417 fprintf_filtered (file, ("%-4s %-20s %-30s "),
418 plongest (type), name, description);
419 switch (format)
420 {
421 case AUXV_FORMAT_DEC:
422 fprintf_filtered (file, ("%s\n"), plongest (val));
423 break;
424 case AUXV_FORMAT_HEX:
425 fprintf_filtered (file, ("%s\n"), paddress (target_gdbarch (), val));
426 break;
427 case AUXV_FORMAT_STR:
428 {
429 struct value_print_options opts;
430
431 get_user_print_options (&opts);
432 if (opts.addressprint)
433 fprintf_filtered (file, ("%s "), paddress (target_gdbarch (), val));
434 val_print_string (builtin_type (target_gdbarch ())->builtin_char,
435 NULL, val, -1, file, &opts);
436 fprintf_filtered (file, ("\n"));
437 }
438 break;
439 }
440 }
441
442 /* The default implementation of gdbarch_print_auxv_entry. */
443
444 void
445 default_print_auxv_entry (struct gdbarch *gdbarch, struct ui_file *file,
446 CORE_ADDR type, CORE_ADDR val)
447 {
448 const char *name = "???";
449 const char *description = "";
450 enum auxv_format format = AUXV_FORMAT_HEX;
451
452 switch (type)
453 {
454 #define TAG(tag, text, kind) \
455 case tag: name = #tag; description = text; format = kind; break
456 TAG (AT_NULL, _("End of vector"), AUXV_FORMAT_HEX);
457 TAG (AT_IGNORE, _("Entry should be ignored"), AUXV_FORMAT_HEX);
458 TAG (AT_EXECFD, _("File descriptor of program"), AUXV_FORMAT_DEC);
459 TAG (AT_PHDR, _("Program headers for program"), AUXV_FORMAT_HEX);
460 TAG (AT_PHENT, _("Size of program header entry"), AUXV_FORMAT_DEC);
461 TAG (AT_PHNUM, _("Number of program headers"), AUXV_FORMAT_DEC);
462 TAG (AT_PAGESZ, _("System page size"), AUXV_FORMAT_DEC);
463 TAG (AT_BASE, _("Base address of interpreter"), AUXV_FORMAT_HEX);
464 TAG (AT_FLAGS, _("Flags"), AUXV_FORMAT_HEX);
465 TAG (AT_ENTRY, _("Entry point of program"), AUXV_FORMAT_HEX);
466 TAG (AT_NOTELF, _("Program is not ELF"), AUXV_FORMAT_DEC);
467 TAG (AT_UID, _("Real user ID"), AUXV_FORMAT_DEC);
468 TAG (AT_EUID, _("Effective user ID"), AUXV_FORMAT_DEC);
469 TAG (AT_GID, _("Real group ID"), AUXV_FORMAT_DEC);
470 TAG (AT_EGID, _("Effective group ID"), AUXV_FORMAT_DEC);
471 TAG (AT_CLKTCK, _("Frequency of times()"), AUXV_FORMAT_DEC);
472 TAG (AT_PLATFORM, _("String identifying platform"), AUXV_FORMAT_STR);
473 TAG (AT_HWCAP, _("Machine-dependent CPU capability hints"),
474 AUXV_FORMAT_HEX);
475 TAG (AT_FPUCW, _("Used FPU control word"), AUXV_FORMAT_DEC);
476 TAG (AT_DCACHEBSIZE, _("Data cache block size"), AUXV_FORMAT_DEC);
477 TAG (AT_ICACHEBSIZE, _("Instruction cache block size"), AUXV_FORMAT_DEC);
478 TAG (AT_UCACHEBSIZE, _("Unified cache block size"), AUXV_FORMAT_DEC);
479 TAG (AT_IGNOREPPC, _("Entry should be ignored"), AUXV_FORMAT_DEC);
480 TAG (AT_BASE_PLATFORM, _("String identifying base platform"),
481 AUXV_FORMAT_STR);
482 TAG (AT_RANDOM, _("Address of 16 random bytes"), AUXV_FORMAT_HEX);
483 TAG (AT_HWCAP2, _("Extension of AT_HWCAP"), AUXV_FORMAT_HEX);
484 TAG (AT_EXECFN, _("File name of executable"), AUXV_FORMAT_STR);
485 TAG (AT_SECURE, _("Boolean, was exec setuid-like?"), AUXV_FORMAT_DEC);
486 TAG (AT_SYSINFO, _("Special system info/entry points"), AUXV_FORMAT_HEX);
487 TAG (AT_SYSINFO_EHDR, _("System-supplied DSO's ELF header"),
488 AUXV_FORMAT_HEX);
489 TAG (AT_L1I_CACHESHAPE, _("L1 Instruction cache information"),
490 AUXV_FORMAT_HEX);
491 TAG (AT_L1D_CACHESHAPE, _("L1 Data cache information"), AUXV_FORMAT_HEX);
492 TAG (AT_L2_CACHESHAPE, _("L2 cache information"), AUXV_FORMAT_HEX);
493 TAG (AT_L3_CACHESHAPE, _("L3 cache information"), AUXV_FORMAT_HEX);
494 TAG (AT_SUN_UID, _("Effective user ID"), AUXV_FORMAT_DEC);
495 TAG (AT_SUN_RUID, _("Real user ID"), AUXV_FORMAT_DEC);
496 TAG (AT_SUN_GID, _("Effective group ID"), AUXV_FORMAT_DEC);
497 TAG (AT_SUN_RGID, _("Real group ID"), AUXV_FORMAT_DEC);
498 TAG (AT_SUN_LDELF, _("Dynamic linker's ELF header"), AUXV_FORMAT_HEX);
499 TAG (AT_SUN_LDSHDR, _("Dynamic linker's section headers"),
500 AUXV_FORMAT_HEX);
501 TAG (AT_SUN_LDNAME, _("String giving name of dynamic linker"),
502 AUXV_FORMAT_STR);
503 TAG (AT_SUN_LPAGESZ, _("Large pagesize"), AUXV_FORMAT_DEC);
504 TAG (AT_SUN_PLATFORM, _("Platform name string"), AUXV_FORMAT_STR);
505 TAG (AT_SUN_HWCAP, _("Machine-dependent CPU capability hints"),
506 AUXV_FORMAT_HEX);
507 TAG (AT_SUN_IFLUSH, _("Should flush icache?"), AUXV_FORMAT_DEC);
508 TAG (AT_SUN_CPU, _("CPU name string"), AUXV_FORMAT_STR);
509 TAG (AT_SUN_EMUL_ENTRY, _("COFF entry point address"), AUXV_FORMAT_HEX);
510 TAG (AT_SUN_EMUL_EXECFD, _("COFF executable file descriptor"),
511 AUXV_FORMAT_DEC);
512 TAG (AT_SUN_EXECNAME,
513 _("Canonicalized file name given to execve"), AUXV_FORMAT_STR);
514 TAG (AT_SUN_MMU, _("String for name of MMU module"), AUXV_FORMAT_STR);
515 TAG (AT_SUN_LDDATA, _("Dynamic linker's data segment address"),
516 AUXV_FORMAT_HEX);
517 TAG (AT_SUN_AUXFLAGS,
518 _("AF_SUN_ flags passed from the kernel"), AUXV_FORMAT_HEX);
519 }
520
521 fprint_auxv_entry (file, name, description, format, type, val);
522 }
523
524 /* Print the contents of the target's AUXV on the specified file. */
525
526 int
527 fprint_target_auxv (struct ui_file *file, struct target_ops *ops)
528 {
529 struct gdbarch *gdbarch = target_gdbarch ();
530 CORE_ADDR type, val;
531 gdb_byte *data;
532 gdb_byte *ptr;
533 struct auxv_info *info;
534 int ents = 0;
535
536 info = get_auxv_inferior_data (ops);
537
538 data = info->data;
539 ptr = data;
540 if (info->length <= 0)
541 return info->length;
542
543 while (target_auxv_parse (ops, &ptr, data + info->length, &type, &val) > 0)
544 {
545 gdbarch_print_auxv_entry (gdbarch, file, type, val);
546 ++ents;
547 if (type == AT_NULL)
548 break;
549 }
550
551 return ents;
552 }
553
554 static void
555 info_auxv_command (const char *cmd, int from_tty)
556 {
557 if (! target_has_stack)
558 error (_("The program has no auxiliary information now."));
559 else
560 {
561 int ents = fprint_target_auxv (gdb_stdout, &current_target);
562
563 if (ents < 0)
564 error (_("No auxiliary vector found, or failed reading it."));
565 else if (ents == 0)
566 error (_("Auxiliary vector is empty."));
567 }
568 }
569
570 void
571 _initialize_auxv (void)
572 {
573 add_info ("auxv", info_auxv_command,
574 _("Display the inferior's auxiliary vector.\n\
575 This is information provided by the operating system at program startup."));
576
577 /* Set an auxv cache per-inferior. */
578 auxv_inferior_data
579 = register_inferior_data_with_cleanup (NULL, auxv_inferior_data_cleanup);
580
581 /* Observers used to invalidate the auxv cache when needed. */
582 observer_attach_inferior_exit (invalidate_auxv_cache_inf);
583 observer_attach_inferior_appeared (invalidate_auxv_cache_inf);
584 observer_attach_executable_changed (invalidate_auxv_cache);
585 }
target_gdbarch
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5467
gdbarch
Definition: gdbarch.c:127
read
ssize_t read(int fd, void *buf, size_t count)
Definition: expect-read1.c:26
extract_typed_address
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
Definition: findvar.c:154
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
target_write_memory
int target_write_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
Definition: target.c:1451
ptid_get_pid
int ptid_get_pid(const ptid_t &ptid)
Definition: ptid.c:47
command.h
xfree
void xfree(void *)
BMSYMBOL_VALUE_ADDRESS
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:691
procfs_xfer_auxv
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
gdbarch_ptr_bit
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1831
plongest
char * plongest(LONGEST l)
Definition: print-utils.c:137
target_read_alloc
LONGEST target_read_alloc(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte **buf_p)
Definition: target.c:1918
builtin_type
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:5217
add_info
struct cmd_list_element * add_info(const char *name, cmd_const_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:886
observer_attach_executable_changed
struct observer * observer_attach_executable_changed(observer_executable_changed_ftype *f)
inferior
Definition: inferior.h:310
auxv.h
fprint_target_auxv
int fprint_target_auxv(struct ui_file *file, struct target_ops *ops)
Definition: auxv.c:527
auxv_info
Definition: auxv.c:305
observer_attach_inferior_exit
struct observer * observer_attach_inferior_exit(observer_inferior_exit_ftype *f)
invalidate_auxv_cache
static void invalidate_auxv_cache(void)
Definition: auxv.c:343
_
#define _(String)
Definition: gdb_locale.h:35
ui_file
Definition: ui-file.h:26
defs.h
builtin_type
Definition: gdbtypes.h:1495
gdbarch_auxv_parse
int gdbarch_auxv_parse(struct gdbarch *gdbarch, gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
Definition: gdbarch.c:4911
paddress
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2745
objfiles.h
observer.h
default_print_auxv_entry
void default_print_auxv_entry(struct gdbarch *gdbarch, struct ui_file *file, CORE_ADDR type, CORE_ADDR val)
Definition: auxv.c:445
default_auxv_parse
int default_auxv_parse(struct target_ops *ops, gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
Definition: auxv.c:258
gdbarch_auxv_parse_p
int gdbarch_auxv_parse_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:4904
name
const char *const name
Definition: aarch64-tdep.c:76
gdbarch_print_auxv_entry
void gdbarch_print_auxv_entry(struct gdbarch *gdbarch, struct ui_file *file, CORE_ADDR type, CORE_ADDR val)
Definition: gdbarch.c:4928
value_print_options
Definition: valprint.h:25
current_target
struct target_ops current_target
target_ops
Definition: target.h:412
fprintf_filtered
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2008
extract_unsigned_integer
static ULONGEST extract_unsigned_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:577
auxv_inferior_data
static const struct inferior_data * auxv_inferior_data
Definition: auxv.c:300
bound_minimal_symbol
Definition: minsyms.h:29
auxv_info::length
LONGEST length
Definition: auxv.c:307
target_auxv_search
int target_auxv_search(struct target_ops *ops, CORE_ADDR match, CORE_ADDR *valp)
Definition: auxv.c:375
get_auxv_inferior_data
static struct auxv_info * get_auxv_inferior_data(struct target_ops *ops)
Definition: auxv.c:353
MSYMBOL_SIZE
#define MSYMBOL_SIZE(msymbol)
Definition: symtab.h:672
gdbarch_byte_order
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1509
inferior.h
TARGET_XFER_OK
Definition: target.h:209
target_xfer_status
target_xfer_status
Definition: target.h:206
TARGET_CHAR_BIT
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
type
Definition: gdbtypes.h:749
TAG
#define TAG(tag, text, kind)
inf
Definition: gnu-nat.c:174
type
static const char * type
Definition: language.c:113
invalidate_auxv_cache_inf
static void invalidate_auxv_cache_inf(struct inferior *inf)
Definition: auxv.c:335
target_auxv_parse
int target_auxv_parse(struct target_ops *ops, gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
Definition: auxv.c:286
value_print_options::format
int format
Definition: valprint.h:64
xstrprintf
char * xstrprintf(const char *format,...)
Definition: common-utils.c:107
AUXV_FORMAT_STR
Definition: auxv.h:50
auxv_format
auxv_format
Definition: auxv.h:50
value_print_options::addressprint
int addressprint
Definition: valprint.h:43
observer_attach_inferior_appeared
struct observer * observer_attach_inferior_appeared(observer_inferior_appeared_ftype *f)
target_object
target_object
Definition: target.h:132
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
block
Definition: block.h:60
TARGET_OBJECT_AUXV
Definition: target.h:154
target_ops::to_auxv_parse
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:805
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
target_has_stack
#define target_has_stack
Definition: target.h:1735
SEEK_SET
#define SEEK_SET
Definition: defs.h:93
XCNEW
#define XCNEW(T)
Definition: poison.h:121
gdbcore.h
TARGET_XFER_EOF
Definition: target.h:212
target_read_memory
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1370
inferior_ptid
ptid_t inferior_ptid
Definition: infcmd.c:94
builtin_type::builtin_data_ptr
struct type * builtin_data_ptr
Definition: gdbtypes.h:1554
bound_minimal_symbol::minsym
struct minimal_symbol * minsym
Definition: minsyms.h:34
get_user_print_options
void get_user_print_options(struct value_print_options *opts)
Definition: valprint.c:120
offset
int offset
Definition: agent.c:65
fprint_auxv_entry
void fprint_auxv_entry(struct ui_file *file, const char *name, const char *description, enum auxv_format format, CORE_ADDR type, CORE_ADDR val)
Definition: auxv.c:413
target.h
_initialize_auxv
void _initialize_auxv(void)
Definition: auxv.c:571
gdbarch::data
void ** data
Definition: gdbarch.c:148
AUXV_FORMAT_HEX
Definition: auxv.h:50
gdb_open_cloexec
int gdb_open_cloexec(const char *filename, int flags, unsigned long mode)
Definition: filestuff.c:283
ld_so_xfer_auxv
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
current_inferior
struct inferior * current_inferior(void)
Definition: inferior.c:58
gdbtypes.h
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
memory_xfer_auxv
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
auxv_info::data
gdb_byte * data
Definition: auxv.c:308
auxv_inferior_data_cleanup
static void auxv_inferior_data_cleanup(struct inferior *inf, void *arg)
Definition: auxv.c:319
info_auxv_command
static void info_auxv_command(const char *cmd, int from_tty)
Definition: auxv.c:555
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
val_print_string
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:2795
AUXV_FORMAT_DEC
Definition: auxv.h:50
filestuff.h
valprint.h
lookup_minimal_symbol
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:311
error
void error(const char *fmt,...)
Definition: errors.c:38
TARGET_XFER_E_IO
Definition: target.h:220
LONGEST
long long LONGEST
Definition: common-types.h:52
gdb_stdout
#define gdb_stdout
Definition: utils.h:340