GDB (xrefs)
Loading...
Searching...
No Matches
auxv.c
Go to the documentation of this file.
1/* Auxiliary vector support for GDB, the GNU debugger.
2
3 Copyright (C) 2004-2023 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 "observable.h"
28#include "gdbsupport/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
42static enum target_xfer_status
43procfs_xfer_auxv (gdb_byte *readbuf,
44 const gdb_byte *writebuf,
45 ULONGEST offset,
46 ULONGEST len,
47 ULONGEST *xfered_len)
48{
49 ssize_t l;
50
51 std::string pathname = string_printf ("/proc/%d/auxv", inferior_ptid.pid ());
52 scoped_fd fd
53 = gdb_open_cloexec (pathname, writebuf != NULL ? O_WRONLY : O_RDONLY, 0);
54 if (fd.get () < 0)
55 return TARGET_XFER_E_IO;
56
57 if (offset != (ULONGEST) 0
58 && lseek (fd.get (), (off_t) offset, SEEK_SET) != (off_t) offset)
59 l = -1;
60 else if (readbuf != NULL)
61 l = read (fd.get (), readbuf, (size_t) len);
62 else
63 l = write (fd.get (), writebuf, (size_t) len);
64
65 if (l < 0)
66 return TARGET_XFER_E_IO;
67 else if (l == 0)
68 return TARGET_XFER_EOF;
69 else
70 {
71 *xfered_len = (ULONGEST) l;
72 return TARGET_XFER_OK;
73 }
74}
75
76/* This function handles access via ld.so's symbol `_dl_auxv'. */
77
78static enum target_xfer_status
79ld_so_xfer_auxv (gdb_byte *readbuf,
80 const gdb_byte *writebuf,
81 ULONGEST offset,
82 ULONGEST len, ULONGEST *xfered_len)
83{
84 struct bound_minimal_symbol msym;
85 CORE_ADDR data_address, pointer_address;
86 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
87 size_t ptr_size = ptr_type->length ();
88 size_t auxv_pair_size = 2 * ptr_size;
89 gdb_byte *ptr_buf = (gdb_byte *) alloca (ptr_size);
90 LONGEST retval;
91 size_t block;
92
93 msym = lookup_minimal_symbol ("_dl_auxv", NULL, NULL);
94 if (msym.minsym == NULL)
95 return TARGET_XFER_E_IO;
96
97 if (msym.minsym->size () != ptr_size)
98 return TARGET_XFER_E_IO;
99
100 /* POINTER_ADDRESS is a location where the `_dl_auxv' variable
101 resides. DATA_ADDRESS is the inferior value present in
102 `_dl_auxv', therefore the real inferior AUXV address. */
103
104 pointer_address = msym.value_address ();
105
106 /* The location of the _dl_auxv symbol may no longer be correct if
107 ld.so runs at a different address than the one present in the
108 file. This is very common case - for unprelinked ld.so or with a
109 PIE executable. PIE executable forces random address even for
110 libraries already being prelinked to some address. PIE
111 executables themselves are never prelinked even on prelinked
112 systems. Prelinking of a PIE executable would block their
113 purpose of randomizing load of everything including the
114 executable.
115
116 If the memory read fails, return -1 to fallback on another
117 mechanism for retrieving the AUXV.
118
119 In most cases of a PIE running under valgrind there is no way to
120 find out the base addresses of any of ld.so, executable or AUXV
121 as everything is randomized and /proc information is not relevant
122 for the virtual executable running under valgrind. We think that
123 we might need a valgrind extension to make it work. This is PR
124 11440. */
125
126 if (target_read_memory (pointer_address, ptr_buf, ptr_size) != 0)
127 return TARGET_XFER_E_IO;
128
129 data_address = extract_typed_address (ptr_buf, ptr_type);
130
131 /* Possibly still not initialized such as during an inferior
132 startup. */
133 if (data_address == 0)
134 return TARGET_XFER_E_IO;
135
136 data_address += offset;
137
138 if (writebuf != NULL)
139 {
140 if (target_write_memory (data_address, writebuf, len) == 0)
141 {
142 *xfered_len = (ULONGEST) len;
143 return TARGET_XFER_OK;
144 }
145 else
146 return TARGET_XFER_E_IO;
147 }
148
149 /* Stop if trying to read past the existing AUXV block. The final
150 AT_NULL was already returned before. */
151
152 if (offset >= auxv_pair_size)
153 {
154 if (target_read_memory (data_address - auxv_pair_size, ptr_buf,
155 ptr_size) != 0)
156 return TARGET_XFER_E_IO;
157
158 if (extract_typed_address (ptr_buf, ptr_type) == AT_NULL)
159 return TARGET_XFER_EOF;
160 }
161
162 retval = 0;
163 block = 0x400;
164 gdb_assert (block % auxv_pair_size == 0);
165
166 while (len > 0)
167 {
168 if (block > len)
169 block = len;
170
171 /* Reading sizes smaller than AUXV_PAIR_SIZE is not supported.
172 Tails unaligned to AUXV_PAIR_SIZE will not be read during a
173 call (they should be completed during next read with
174 new/extended buffer). */
175
176 block &= -auxv_pair_size;
177 if (block == 0)
178 break;
179
180 if (target_read_memory (data_address, readbuf, block) != 0)
181 {
182 if (block <= auxv_pair_size)
183 break;
184
185 block = auxv_pair_size;
186 continue;
187 }
188
189 data_address += block;
190 len -= block;
191
192 /* Check terminal AT_NULL. This function is being called
193 indefinitely being extended its READBUF until it returns EOF
194 (0). */
195
196 while (block >= auxv_pair_size)
197 {
198 retval += auxv_pair_size;
199
200 if (extract_typed_address (readbuf, ptr_type) == AT_NULL)
201 {
202 *xfered_len = (ULONGEST) retval;
203 return TARGET_XFER_OK;
204 }
205
206 readbuf += auxv_pair_size;
207 block -= auxv_pair_size;
208 }
209 }
210
211 *xfered_len = (ULONGEST) retval;
212 return TARGET_XFER_OK;
213}
214
215/* Implement the to_xfer_partial target_ops method for
216 TARGET_OBJECT_AUXV. It handles access to AUXV. */
217
220 enum target_object object,
221 const char *annex,
222 gdb_byte *readbuf,
223 const gdb_byte *writebuf,
224 ULONGEST offset,
225 ULONGEST len, ULONGEST *xfered_len)
226{
227 gdb_assert (object == TARGET_OBJECT_AUXV);
228 gdb_assert (readbuf || writebuf);
229
230 /* ld_so_xfer_auxv is the only function safe for virtual
231 executables being executed by valgrind's memcheck. Using
232 ld_so_xfer_auxv during inferior startup is problematic, because
233 ld.so symbol tables have not yet been relocated. So GDB uses
234 this function only when attaching to a process.
235 */
236
237 if (current_inferior ()->attach_flag)
238 {
239 enum target_xfer_status ret;
240
241 ret = ld_so_xfer_auxv (readbuf, writebuf, offset, len, xfered_len);
242 if (ret != TARGET_XFER_E_IO)
243 return ret;
244 }
245
246 return procfs_xfer_auxv (readbuf, writebuf, offset, len, xfered_len);
247}
248
249/* This function compared to other auxv_parse functions: it takes the size of
250 the auxv type field as a parameter. */
251
252static int
253generic_auxv_parse (struct gdbarch *gdbarch, const gdb_byte **readptr,
254 const gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp,
255 int sizeof_auxv_type)
256{
257 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
258 const int sizeof_auxv_val = ptr_type->length ();
259 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
260 const gdb_byte *ptr = *readptr;
261
262 if (endptr == ptr)
263 return 0;
264
265 if (endptr - ptr < 2 * sizeof_auxv_val)
266 return -1;
267
268 *typep = extract_unsigned_integer (ptr, sizeof_auxv_type, byte_order);
269 /* Even if the auxv type takes less space than an auxv value, there is
270 padding after the type such that the value is aligned on a multiple of
271 its size (and this is why we advance by `sizeof_auxv_val` and not
272 `sizeof_auxv_type`). */
273 ptr += sizeof_auxv_val;
274 *valp = extract_unsigned_integer (ptr, sizeof_auxv_val, byte_order);
275 ptr += sizeof_auxv_val;
276
277 *readptr = ptr;
278 return 1;
279}
280
281/* See auxv.h. */
282
283int
284default_auxv_parse (struct target_ops *ops, const gdb_byte **readptr,
285 const gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
286{
287 struct gdbarch *gdbarch = target_gdbarch ();
288 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
289 const int sizeof_auxv_type = ptr_type->length ();
290
291 return generic_auxv_parse (gdbarch, readptr, endptr, typep, valp,
292 sizeof_auxv_type);
293}
294
295/* See auxv.h. */
296
297int
298svr4_auxv_parse (struct gdbarch *gdbarch, const gdb_byte **readptr,
299 const gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
300{
301 struct type *int_type = builtin_type (gdbarch)->builtin_int;
302 const int sizeof_auxv_type = int_type->length ();
303
304 return generic_auxv_parse (gdbarch, readptr, endptr, typep, valp,
305 sizeof_auxv_type);
306}
307
308/* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
309
310 Use the auxv_parse method from GDBARCH, if defined, else use the auxv_parse
311 method of OPS.
312
313 Return 0 if *READPTR is already at the end of the buffer.
314 Return -1 if there is insufficient buffer for a whole entry.
315 Return 1 if an entry was read into *TYPEP and *VALP. */
316
317static int
318parse_auxv (target_ops *ops, gdbarch *gdbarch, const gdb_byte **readptr,
319 const gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
320{
322 return gdbarch_auxv_parse (gdbarch, readptr, endptr, typep, valp);
323
324 return ops->auxv_parse (readptr, endptr, typep, valp);
325}
326
327
328/* Auxiliary Vector information structure. This is used by GDB
329 for caching purposes for each inferior. This helps reduce the
330 overhead of transfering data from a remote target to the local host. */
332{
333 gdb::optional<gdb::byte_vector> data;
334};
335
336/* Per-inferior data key for auxv. */
338
339/* Invalidate INF's auxv cache. */
340
341static void
346
347/* Invalidate the auxv cache for all inferiors using PSPACE. */
348
349static void
356
357/* See auxv.h. */
358
359const gdb::optional<gdb::byte_vector> &
361{
364
365 if (info == nullptr)
366 {
367 info = auxv_inferior_data.emplace (inf);
368 info->data = target_read_auxv_raw (inf->top_target ());
369 }
370
371 return info->data;
372}
373
374/* See auxv.h. */
375
376gdb::optional<gdb::byte_vector>
378{
379 return target_read_alloc (ops, TARGET_OBJECT_AUXV, NULL);
380}
381
382/* See auxv.h. */
383
384int
385target_auxv_search (const gdb::byte_vector &auxv, target_ops *ops,
386 gdbarch *gdbarch, CORE_ADDR match, CORE_ADDR *valp)
387{
388 CORE_ADDR type, val;
389 const gdb_byte *data = auxv.data ();
390 const gdb_byte *ptr = data;
391 size_t len = auxv.size ();
392
393 while (1)
394 switch (parse_auxv (ops, gdbarch, &ptr, data + len, &type, &val))
395 {
396 case 1: /* Here's an entry, check it. */
397 if (type == match)
398 {
399 *valp = val;
400 return 1;
401 }
402 break;
403 case 0: /* End of the vector. */
404 return 0;
405 default: /* Bogosity. */
406 return -1;
407 }
408}
409
410/* See auxv.h. */
411
412int
413target_auxv_search (CORE_ADDR match, CORE_ADDR *valp)
414{
415 const gdb::optional<gdb::byte_vector> &auxv = target_read_auxv ();
416
417 if (!auxv.has_value ())
418 return -1;
419
420 return target_auxv_search (*auxv, current_inferior ()->top_target (),
421 current_inferior ()->gdbarch, match, valp);
422}
423
424/* Print the description of a single AUXV entry on the specified file. */
425
426void
427fprint_auxv_entry (struct ui_file *file, const char *name,
428 const char *description, enum auxv_format format,
429 CORE_ADDR type, CORE_ADDR val)
430{
431 gdb_printf (file, ("%-4s %-20s %-30s "),
432 plongest (type), name, description);
433 switch (format)
434 {
435 case AUXV_FORMAT_DEC:
436 gdb_printf (file, ("%s\n"), plongest (val));
437 break;
438 case AUXV_FORMAT_HEX:
439 gdb_printf (file, ("%s\n"), paddress (target_gdbarch (), val));
440 break;
441 case AUXV_FORMAT_STR:
442 {
443 struct value_print_options opts;
444
446 if (opts.addressprint)
447 gdb_printf (file, ("%s "), paddress (target_gdbarch (), val));
448 val_print_string (builtin_type (target_gdbarch ())->builtin_char,
449 NULL, val, -1, file, &opts);
450 gdb_printf (file, ("\n"));
451 }
452 break;
453 }
454}
455
456/* The default implementation of gdbarch_print_auxv_entry. */
457
458void
460 CORE_ADDR type, CORE_ADDR val)
461{
462 const char *name = "???";
463 const char *description = "";
465
466 switch (type)
467 {
468#define TAG(tag, text, kind) \
469 case tag: name = #tag; description = text; format = kind; break
470 TAG (AT_NULL, _("End of vector"), AUXV_FORMAT_HEX);
471 TAG (AT_IGNORE, _("Entry should be ignored"), AUXV_FORMAT_HEX);
472 TAG (AT_EXECFD, _("File descriptor of program"), AUXV_FORMAT_DEC);
473 TAG (AT_PHDR, _("Program headers for program"), AUXV_FORMAT_HEX);
474 TAG (AT_PHENT, _("Size of program header entry"), AUXV_FORMAT_DEC);
475 TAG (AT_PHNUM, _("Number of program headers"), AUXV_FORMAT_DEC);
476 TAG (AT_PAGESZ, _("System page size"), AUXV_FORMAT_DEC);
477 TAG (AT_BASE, _("Base address of interpreter"), AUXV_FORMAT_HEX);
478 TAG (AT_FLAGS, _("Flags"), AUXV_FORMAT_HEX);
479 TAG (AT_ENTRY, _("Entry point of program"), AUXV_FORMAT_HEX);
480 TAG (AT_NOTELF, _("Program is not ELF"), AUXV_FORMAT_DEC);
481 TAG (AT_UID, _("Real user ID"), AUXV_FORMAT_DEC);
482 TAG (AT_EUID, _("Effective user ID"), AUXV_FORMAT_DEC);
483 TAG (AT_GID, _("Real group ID"), AUXV_FORMAT_DEC);
484 TAG (AT_EGID, _("Effective group ID"), AUXV_FORMAT_DEC);
485 TAG (AT_CLKTCK, _("Frequency of times()"), AUXV_FORMAT_DEC);
486 TAG (AT_PLATFORM, _("String identifying platform"), AUXV_FORMAT_STR);
487 TAG (AT_HWCAP, _("Machine-dependent CPU capability hints"),
489 TAG (AT_FPUCW, _("Used FPU control word"), AUXV_FORMAT_DEC);
490 TAG (AT_DCACHEBSIZE, _("Data cache block size"), AUXV_FORMAT_DEC);
491 TAG (AT_ICACHEBSIZE, _("Instruction cache block size"), AUXV_FORMAT_DEC);
492 TAG (AT_UCACHEBSIZE, _("Unified cache block size"), AUXV_FORMAT_DEC);
493 TAG (AT_IGNOREPPC, _("Entry should be ignored"), AUXV_FORMAT_DEC);
494 TAG (AT_BASE_PLATFORM, _("String identifying base platform"),
496 TAG (AT_RANDOM, _("Address of 16 random bytes"), AUXV_FORMAT_HEX);
497 TAG (AT_HWCAP2, _("Extension of AT_HWCAP"), AUXV_FORMAT_HEX);
498 TAG (AT_RSEQ_FEATURE_SIZE, _("rseq supported feature size"),
500 TAG (AT_RSEQ_ALIGN, _("rseq allocation alignment"),
502 TAG (AT_EXECFN, _("File name of executable"), AUXV_FORMAT_STR);
503 TAG (AT_SECURE, _("Boolean, was exec setuid-like?"), AUXV_FORMAT_DEC);
504 TAG (AT_SYSINFO, _("Special system info/entry points"), AUXV_FORMAT_HEX);
505 TAG (AT_SYSINFO_EHDR, _("System-supplied DSO's ELF header"),
507 TAG (AT_L1I_CACHESHAPE, _("L1 Instruction cache information"),
509 TAG (AT_L1I_CACHESIZE, _("L1 Instruction cache size"), AUXV_FORMAT_HEX);
510 TAG (AT_L1I_CACHEGEOMETRY, _("L1 Instruction cache geometry"),
512 TAG (AT_L1D_CACHESHAPE, _("L1 Data cache information"), AUXV_FORMAT_HEX);
513 TAG (AT_L1D_CACHESIZE, _("L1 Data cache size"), AUXV_FORMAT_HEX);
514 TAG (AT_L1D_CACHEGEOMETRY, _("L1 Data cache geometry"),
516 TAG (AT_L2_CACHESHAPE, _("L2 cache information"), AUXV_FORMAT_HEX);
517 TAG (AT_L2_CACHESIZE, _("L2 cache size"), AUXV_FORMAT_HEX);
518 TAG (AT_L2_CACHEGEOMETRY, _("L2 cache geometry"), AUXV_FORMAT_HEX);
519 TAG (AT_L3_CACHESHAPE, _("L3 cache information"), AUXV_FORMAT_HEX);
520 TAG (AT_L3_CACHESIZE, _("L3 cache size"), AUXV_FORMAT_HEX);
521 TAG (AT_L3_CACHEGEOMETRY, _("L3 cache geometry"), AUXV_FORMAT_HEX);
522 TAG (AT_MINSIGSTKSZ, _("Minimum stack size for signal delivery"),
524 TAG (AT_SUN_UID, _("Effective user ID"), AUXV_FORMAT_DEC);
525 TAG (AT_SUN_RUID, _("Real user ID"), AUXV_FORMAT_DEC);
526 TAG (AT_SUN_GID, _("Effective group ID"), AUXV_FORMAT_DEC);
527 TAG (AT_SUN_RGID, _("Real group ID"), AUXV_FORMAT_DEC);
528 TAG (AT_SUN_LDELF, _("Dynamic linker's ELF header"), AUXV_FORMAT_HEX);
529 TAG (AT_SUN_LDSHDR, _("Dynamic linker's section headers"),
531 TAG (AT_SUN_LDNAME, _("String giving name of dynamic linker"),
533 TAG (AT_SUN_LPAGESZ, _("Large pagesize"), AUXV_FORMAT_DEC);
534 TAG (AT_SUN_PLATFORM, _("Platform name string"), AUXV_FORMAT_STR);
535 TAG (AT_SUN_CAP_HW1, _("Machine-dependent CPU capability hints"),
537 TAG (AT_SUN_IFLUSH, _("Should flush icache?"), AUXV_FORMAT_DEC);
538 TAG (AT_SUN_CPU, _("CPU name string"), AUXV_FORMAT_STR);
539 TAG (AT_SUN_EMUL_ENTRY, _("COFF entry point address"), AUXV_FORMAT_HEX);
540 TAG (AT_SUN_EMUL_EXECFD, _("COFF executable file descriptor"),
542 TAG (AT_SUN_EXECNAME,
543 _("Canonicalized file name given to execve"), AUXV_FORMAT_STR);
544 TAG (AT_SUN_MMU, _("String for name of MMU module"), AUXV_FORMAT_STR);
545 TAG (AT_SUN_LDDATA, _("Dynamic linker's data segment address"),
547 TAG (AT_SUN_AUXFLAGS,
548 _("AF_SUN_ flags passed from the kernel"), AUXV_FORMAT_HEX);
549 TAG (AT_SUN_EMULATOR, _("Name of emulation binary for runtime linker"),
551 TAG (AT_SUN_BRANDNAME, _("Name of brand library"), AUXV_FORMAT_STR);
552 TAG (AT_SUN_BRAND_AUX1, _("Aux vector for brand modules 1"),
554 TAG (AT_SUN_BRAND_AUX2, _("Aux vector for brand modules 2"),
556 TAG (AT_SUN_BRAND_AUX3, _("Aux vector for brand modules 3"),
558 TAG (AT_SUN_CAP_HW2, _("Machine-dependent CPU capability hints 2"),
560 }
561
562 fprint_auxv_entry (file, name, description, format, type, val);
563}
564
565/* Print the contents of the target's AUXV on the specified file. */
566
567static int
569{
570 struct gdbarch *gdbarch = target_gdbarch ();
571 CORE_ADDR type, val;
572 int ents = 0;
573 const gdb::optional<gdb::byte_vector> &auxv = target_read_auxv ();
574
575 if (!auxv.has_value ())
576 return -1;
577
578 const gdb_byte *data = auxv->data ();
579 const gdb_byte *ptr = data;
580 size_t len = auxv->size ();
581
582 while (parse_auxv (current_inferior ()->top_target (),
584 &ptr, data + len, &type, &val) > 0)
585 {
587 ++ents;
588 if (type == AT_NULL)
589 break;
590 }
591
592 return ents;
593}
594
595static void
596info_auxv_command (const char *cmd, int from_tty)
597{
598 if (! target_has_stack ())
599 error (_("The program has no auxiliary information now."));
600 else
601 {
602 int ents = fprint_target_auxv (gdb_stdout);
603
604 if (ents < 0)
605 error (_("No auxiliary vector found, or failed reading it."));
606 else if (ents == 0)
607 error (_("Auxiliary vector is empty."));
608 }
609}
610
611void _initialize_auxv ();
612void
614{
616 _("Display the inferior's auxiliary vector.\n\
617This is information provided by the operating system at program startup."));
618
619 /* Observers used to invalidate the auxv cache when needed. */
623 "auxv");
624}
const char *const name
struct gdbarch * target_gdbarch(void)
static void info_auxv_command(const char *cmd, int from_tty)
Definition auxv.c:596
static const registry< inferior >::key< auxv_info > auxv_inferior_data
Definition auxv.c:337
static void auxv_all_objfiles_removed(program_space *pspace)
Definition auxv.c:350
int default_auxv_parse(struct target_ops *ops, const gdb_byte **readptr, const gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
Definition auxv.c:284
void _initialize_auxv()
Definition auxv.c:613
int target_auxv_search(const gdb::byte_vector &auxv, target_ops *ops, gdbarch *gdbarch, CORE_ADDR match, CORE_ADDR *valp)
Definition auxv.c:385
const gdb::optional< gdb::byte_vector > & target_read_auxv()
Definition auxv.c:360
#define TAG(tag, text, kind)
static int parse_auxv(target_ops *ops, gdbarch *gdbarch, const gdb_byte **readptr, const gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
Definition auxv.c:318
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:427
static int generic_auxv_parse(struct gdbarch *gdbarch, const gdb_byte **readptr, const gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp, int sizeof_auxv_type)
Definition auxv.c:253
static void invalidate_auxv_cache_inf(struct inferior *inf)
Definition auxv.c:342
int svr4_auxv_parse(struct gdbarch *gdbarch, const gdb_byte **readptr, const gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
Definition auxv.c:298
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:79
void default_print_auxv_entry(struct gdbarch *gdbarch, struct ui_file *file, CORE_ADDR type, CORE_ADDR val)
Definition auxv.c:459
gdb::optional< gdb::byte_vector > target_read_auxv_raw(target_ops *ops)
Definition auxv.c:377
static int fprint_target_auxv(struct ui_file *file)
Definition auxv.c:568
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
auxv_format
Definition auxv.h:75
@ AUXV_FORMAT_DEC
Definition auxv.h:75
@ AUXV_FORMAT_STR
Definition auxv.h:75
@ AUXV_FORMAT_HEX
Definition auxv.h:75
target_xfer_partial_ftype memory_xfer_auxv
void * get(unsigned key)
Definition registry.h:211
struct cmd_list_element * add_info(const char *name, cmd_simple_func_ftype *fun, const char *doc)
#define SEEK_SET
Definition defs.h:101
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
Definition findvar.c:152
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition defs.h:480
ssize_t read(int fd, void *buf, size_t count)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition gdbarch.c:1396
int gdbarch_auxv_parse(struct gdbarch *gdbarch, const gdb_byte **readptr, const gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
Definition gdbarch.c:5181
void gdbarch_print_auxv_entry(struct gdbarch *gdbarch, struct ui_file *file, CORE_ADDR type, CORE_ADDR val)
Definition gdbarch.c:5198
bool gdbarch_auxv_parse_p(struct gdbarch *gdbarch)
Definition gdbarch.c:5174
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition gdbtypes.c:6168
ptid_t inferior_ptid
Definition infcmd.c:74
struct inferior * current_inferior(void)
Definition inferior.c:55
all_inferiors_range all_inferiors(process_stratum_target *proc_target=nullptr)
Definition inferior.h:821
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition minsyms.c:363
observable< struct inferior * > inferior_exit
observable< program_space * > all_objfiles_removed
observable< struct inferior * > inferior_appeared
struct program_space * current_program_space
Definition progspace.c:40
enum var_types type
Definition scm-param.c:142
gdb::optional< gdb::byte_vector > data
Definition auxv.c:333
Definition block.h:109
CORE_ADDR value_address() const
Definition minsyms.h:41
struct minimal_symbol * minsym
Definition minsyms.h:49
struct type * builtin_data_ptr
Definition gdbtypes.h:2135
struct type * builtin_int
Definition gdbtypes.h:2080
Definition gnu-nat.c:153
unsigned long size() const
Definition symtab.h:784
virtual int auxv_parse(const gdb_byte **readptr, const gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp) TARGET_DEFAULT_FUNC(default_auxv_parse)
ULONGEST length() const
Definition gdbtypes.h:983
int target_has_stack()
Definition target.c:177
int target_write_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
Definition target.c:1861
gdb::optional< gdb::byte_vector > target_read_alloc(struct target_ops *ops, enum target_object object, const char *annex)
Definition target.c:2312
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition target.c:1785
target_xfer_status
Definition target.h:219
@ TARGET_XFER_E_IO
Definition target.h:232
@ TARGET_XFER_EOF
Definition target.h:224
@ TARGET_XFER_OK
Definition target.h:221
target_object
Definition target.h:143
@ TARGET_OBJECT_AUXV
Definition target.h:162
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition utils.c:3166
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1886
#define gdb_stdout
Definition utils.h:182
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:2643
void get_user_print_options(struct value_print_options *opts)
Definition valprint.c:135