1 /* Auxiliary vector support for GDB, the GNU debugger.
3 Copyright (C) 2004-2021 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
27 #include "observable.h"
28 #include "gdbsupport/filestuff.h"
32 #include "elf/common.h"
38 /* Implement the to_xfer_partial target_ops method. This function
39 handles access via /proc/PID/auxv, which is a common method for
42 static enum target_xfer_status
43 procfs_xfer_auxv (gdb_byte
*readbuf
,
44 const gdb_byte
*writebuf
,
52 std::string pathname
= string_printf ("/proc/%d/auxv", inferior_ptid
.pid ());
53 fd
= gdb_open_cloexec (pathname
, writebuf
!= NULL
? O_WRONLY
: O_RDONLY
, 0);
55 return TARGET_XFER_E_IO
;
57 if (offset
!= (ULONGEST
) 0
58 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
60 else if (readbuf
!= NULL
)
61 l
= read (fd
, readbuf
, (size_t) len
);
63 l
= write (fd
, writebuf
, (size_t) len
);
68 return TARGET_XFER_E_IO
;
70 return TARGET_XFER_EOF
;
73 *xfered_len
= (ULONGEST
) l
;
74 return TARGET_XFER_OK
;
78 /* This function handles access via ld.so's symbol `_dl_auxv'. */
80 static enum target_xfer_status
81 ld_so_xfer_auxv (gdb_byte
*readbuf
,
82 const gdb_byte
*writebuf
,
84 ULONGEST len
, ULONGEST
*xfered_len
)
86 struct bound_minimal_symbol msym
;
87 CORE_ADDR data_address
, pointer_address
;
88 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
89 size_t ptr_size
= TYPE_LENGTH (ptr_type
);
90 size_t auxv_pair_size
= 2 * ptr_size
;
91 gdb_byte
*ptr_buf
= (gdb_byte
*) alloca (ptr_size
);
95 msym
= lookup_minimal_symbol ("_dl_auxv", NULL
, NULL
);
96 if (msym
.minsym
== NULL
)
97 return TARGET_XFER_E_IO
;
99 if (MSYMBOL_SIZE (msym
.minsym
) != ptr_size
)
100 return TARGET_XFER_E_IO
;
102 /* POINTER_ADDRESS is a location where the `_dl_auxv' variable
103 resides. DATA_ADDRESS is the inferior value present in
104 `_dl_auxv', therefore the real inferior AUXV address. */
106 pointer_address
= BMSYMBOL_VALUE_ADDRESS (msym
);
108 /* The location of the _dl_auxv symbol may no longer be correct if
109 ld.so runs at a different address than the one present in the
110 file. This is very common case - for unprelinked ld.so or with a
111 PIE executable. PIE executable forces random address even for
112 libraries already being prelinked to some address. PIE
113 executables themselves are never prelinked even on prelinked
114 systems. Prelinking of a PIE executable would block their
115 purpose of randomizing load of everything including the
118 If the memory read fails, return -1 to fallback on another
119 mechanism for retrieving the AUXV.
121 In most cases of a PIE running under valgrind there is no way to
122 find out the base addresses of any of ld.so, executable or AUXV
123 as everything is randomized and /proc information is not relevant
124 for the virtual executable running under valgrind. We think that
125 we might need a valgrind extension to make it work. This is PR
128 if (target_read_memory (pointer_address
, ptr_buf
, ptr_size
) != 0)
129 return TARGET_XFER_E_IO
;
131 data_address
= extract_typed_address (ptr_buf
, ptr_type
);
133 /* Possibly still not initialized such as during an inferior
135 if (data_address
== 0)
136 return TARGET_XFER_E_IO
;
138 data_address
+= offset
;
140 if (writebuf
!= NULL
)
142 if (target_write_memory (data_address
, writebuf
, len
) == 0)
144 *xfered_len
= (ULONGEST
) len
;
145 return TARGET_XFER_OK
;
148 return TARGET_XFER_E_IO
;
151 /* Stop if trying to read past the existing AUXV block. The final
152 AT_NULL was already returned before. */
154 if (offset
>= auxv_pair_size
)
156 if (target_read_memory (data_address
- auxv_pair_size
, ptr_buf
,
158 return TARGET_XFER_E_IO
;
160 if (extract_typed_address (ptr_buf
, ptr_type
) == AT_NULL
)
161 return TARGET_XFER_EOF
;
166 gdb_assert (block
% auxv_pair_size
== 0);
173 /* Reading sizes smaller than AUXV_PAIR_SIZE is not supported.
174 Tails unaligned to AUXV_PAIR_SIZE will not be read during a
175 call (they should be completed during next read with
176 new/extended buffer). */
178 block
&= -auxv_pair_size
;
182 if (target_read_memory (data_address
, readbuf
, block
) != 0)
184 if (block
<= auxv_pair_size
)
187 block
= auxv_pair_size
;
191 data_address
+= block
;
194 /* Check terminal AT_NULL. This function is being called
195 indefinitely being extended its READBUF until it returns EOF
198 while (block
>= auxv_pair_size
)
200 retval
+= auxv_pair_size
;
202 if (extract_typed_address (readbuf
, ptr_type
) == AT_NULL
)
204 *xfered_len
= (ULONGEST
) retval
;
205 return TARGET_XFER_OK
;
208 readbuf
+= auxv_pair_size
;
209 block
-= auxv_pair_size
;
213 *xfered_len
= (ULONGEST
) retval
;
214 return TARGET_XFER_OK
;
217 /* Implement the to_xfer_partial target_ops method for
218 TARGET_OBJECT_AUXV. It handles access to AUXV. */
220 enum target_xfer_status
221 memory_xfer_auxv (struct target_ops
*ops
,
222 enum target_object object
,
225 const gdb_byte
*writebuf
,
227 ULONGEST len
, ULONGEST
*xfered_len
)
229 gdb_assert (object
== TARGET_OBJECT_AUXV
);
230 gdb_assert (readbuf
|| writebuf
);
232 /* ld_so_xfer_auxv is the only function safe for virtual
233 executables being executed by valgrind's memcheck. Using
234 ld_so_xfer_auxv during inferior startup is problematic, because
235 ld.so symbol tables have not yet been relocated. So GDB uses
236 this function only when attaching to a process.
239 if (current_inferior ()->attach_flag
!= 0)
241 enum target_xfer_status ret
;
243 ret
= ld_so_xfer_auxv (readbuf
, writebuf
, offset
, len
, xfered_len
);
244 if (ret
!= TARGET_XFER_E_IO
)
248 return procfs_xfer_auxv (readbuf
, writebuf
, offset
, len
, xfered_len
);
251 /* This function compared to other auxv_parse functions: it takes the size of
252 the auxv type field as a parameter. */
255 generic_auxv_parse (struct gdbarch
*gdbarch
, gdb_byte
**readptr
,
256 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
,
257 int sizeof_auxv_type
)
259 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
260 const int sizeof_auxv_val
= TYPE_LENGTH (ptr_type
);
261 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
262 gdb_byte
*ptr
= *readptr
;
267 if (endptr
- ptr
< 2 * sizeof_auxv_val
)
270 *typep
= extract_unsigned_integer (ptr
, sizeof_auxv_type
, byte_order
);
271 /* Even if the auxv type takes less space than an auxv value, there is
272 padding after the type such that the value is aligned on a multiple of
273 its size (and this is why we advance by `sizeof_auxv_val` and not
274 `sizeof_auxv_type`). */
275 ptr
+= sizeof_auxv_val
;
276 *valp
= extract_unsigned_integer (ptr
, sizeof_auxv_val
, byte_order
);
277 ptr
+= sizeof_auxv_val
;
286 default_auxv_parse (struct target_ops
*ops
, gdb_byte
**readptr
,
287 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
289 struct gdbarch
*gdbarch
= target_gdbarch ();
290 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
291 const int sizeof_auxv_type
= TYPE_LENGTH (ptr_type
);
293 return generic_auxv_parse (gdbarch
, readptr
, endptr
, typep
, valp
,
300 svr4_auxv_parse (struct gdbarch
*gdbarch
, gdb_byte
**readptr
,
301 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
303 struct type
*int_type
= builtin_type (gdbarch
)->builtin_int
;
304 const int sizeof_auxv_type
= TYPE_LENGTH (int_type
);
306 return generic_auxv_parse (gdbarch
, readptr
, endptr
, typep
, valp
,
310 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
311 Return 0 if *READPTR is already at the end of the buffer.
312 Return -1 if there is insufficient buffer for a whole entry.
313 Return 1 if an entry was read into *TYPEP and *VALP. */
315 target_auxv_parse (gdb_byte
**readptr
,
316 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
318 struct gdbarch
*gdbarch
= target_gdbarch();
320 if (gdbarch_auxv_parse_p (gdbarch
))
321 return gdbarch_auxv_parse (gdbarch
, readptr
, endptr
, typep
, valp
);
323 return current_inferior ()->top_target ()->auxv_parse (readptr
, endptr
,
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. */
333 gdb::optional
<gdb::byte_vector
> data
;
336 /* Per-inferior data key for auxv. */
337 static const struct inferior_key
<auxv_info
> auxv_inferior_data
;
339 /* Invalidate INF's auxv cache. */
342 invalidate_auxv_cache_inf (struct inferior
*inf
)
344 auxv_inferior_data
.clear (inf
);
347 /* Invalidate current inferior's auxv cache. */
350 invalidate_auxv_cache (void)
352 invalidate_auxv_cache_inf (current_inferior ());
355 /* Fetch the auxv object from inferior INF. If auxv is cached already,
356 return a pointer to the cache. If not, fetch the auxv object from the
357 target and cache it. This function always returns a valid INFO pointer. */
359 static struct auxv_info
*
360 get_auxv_inferior_data (struct target_ops
*ops
)
362 struct auxv_info
*info
;
363 struct inferior
*inf
= current_inferior ();
365 info
= auxv_inferior_data
.get (inf
);
368 info
= auxv_inferior_data
.emplace (inf
);
369 info
->data
= target_read_alloc (ops
, TARGET_OBJECT_AUXV
, NULL
);
375 /* Extract the auxiliary vector entry with a_type matching MATCH.
376 Return zero if no such entry was found, or -1 if there was
377 an error getting the information. On success, return 1 after
378 storing the entry's value field in *VALP. */
380 target_auxv_search (struct target_ops
*ops
, CORE_ADDR match
, CORE_ADDR
*valp
)
383 auxv_info
*info
= get_auxv_inferior_data (ops
);
388 gdb_byte
*data
= info
->data
->data ();
389 gdb_byte
*ptr
= data
;
390 size_t len
= info
->data
->size ();
393 switch (target_auxv_parse (&ptr
, data
+ len
, &type
, &val
))
395 case 1: /* Here's an entry, check it. */
402 case 0: /* End of the vector. */
404 default: /* Bogosity. */
412 /* Print the description of a single AUXV entry on the specified file. */
415 fprint_auxv_entry (struct ui_file
*file
, const char *name
,
416 const char *description
, enum auxv_format format
,
417 CORE_ADDR type
, CORE_ADDR val
)
419 fprintf_filtered (file
, ("%-4s %-20s %-30s "),
420 plongest (type
), name
, description
);
423 case AUXV_FORMAT_DEC
:
424 fprintf_filtered (file
, ("%s\n"), plongest (val
));
426 case AUXV_FORMAT_HEX
:
427 fprintf_filtered (file
, ("%s\n"), paddress (target_gdbarch (), val
));
429 case AUXV_FORMAT_STR
:
431 struct value_print_options opts
;
433 get_user_print_options (&opts
);
434 if (opts
.addressprint
)
435 fprintf_filtered (file
, ("%s "), paddress (target_gdbarch (), val
));
436 val_print_string (builtin_type (target_gdbarch ())->builtin_char
,
437 NULL
, val
, -1, file
, &opts
);
438 fprintf_filtered (file
, ("\n"));
444 /* The default implementation of gdbarch_print_auxv_entry. */
447 default_print_auxv_entry (struct gdbarch
*gdbarch
, struct ui_file
*file
,
448 CORE_ADDR type
, CORE_ADDR val
)
450 const char *name
= "???";
451 const char *description
= "";
452 enum auxv_format format
= AUXV_FORMAT_HEX
;
456 #define TAG(tag, text, kind) \
457 case tag: name = #tag; description = text; format = kind; break
458 TAG (AT_NULL
, _("End of vector"), AUXV_FORMAT_HEX
);
459 TAG (AT_IGNORE
, _("Entry should be ignored"), AUXV_FORMAT_HEX
);
460 TAG (AT_EXECFD
, _("File descriptor of program"), AUXV_FORMAT_DEC
);
461 TAG (AT_PHDR
, _("Program headers for program"), AUXV_FORMAT_HEX
);
462 TAG (AT_PHENT
, _("Size of program header entry"), AUXV_FORMAT_DEC
);
463 TAG (AT_PHNUM
, _("Number of program headers"), AUXV_FORMAT_DEC
);
464 TAG (AT_PAGESZ
, _("System page size"), AUXV_FORMAT_DEC
);
465 TAG (AT_BASE
, _("Base address of interpreter"), AUXV_FORMAT_HEX
);
466 TAG (AT_FLAGS
, _("Flags"), AUXV_FORMAT_HEX
);
467 TAG (AT_ENTRY
, _("Entry point of program"), AUXV_FORMAT_HEX
);
468 TAG (AT_NOTELF
, _("Program is not ELF"), AUXV_FORMAT_DEC
);
469 TAG (AT_UID
, _("Real user ID"), AUXV_FORMAT_DEC
);
470 TAG (AT_EUID
, _("Effective user ID"), AUXV_FORMAT_DEC
);
471 TAG (AT_GID
, _("Real group ID"), AUXV_FORMAT_DEC
);
472 TAG (AT_EGID
, _("Effective group ID"), AUXV_FORMAT_DEC
);
473 TAG (AT_CLKTCK
, _("Frequency of times()"), AUXV_FORMAT_DEC
);
474 TAG (AT_PLATFORM
, _("String identifying platform"), AUXV_FORMAT_STR
);
475 TAG (AT_HWCAP
, _("Machine-dependent CPU capability hints"),
477 TAG (AT_FPUCW
, _("Used FPU control word"), AUXV_FORMAT_DEC
);
478 TAG (AT_DCACHEBSIZE
, _("Data cache block size"), AUXV_FORMAT_DEC
);
479 TAG (AT_ICACHEBSIZE
, _("Instruction cache block size"), AUXV_FORMAT_DEC
);
480 TAG (AT_UCACHEBSIZE
, _("Unified cache block size"), AUXV_FORMAT_DEC
);
481 TAG (AT_IGNOREPPC
, _("Entry should be ignored"), AUXV_FORMAT_DEC
);
482 TAG (AT_BASE_PLATFORM
, _("String identifying base platform"),
484 TAG (AT_RANDOM
, _("Address of 16 random bytes"), AUXV_FORMAT_HEX
);
485 TAG (AT_HWCAP2
, _("Extension of AT_HWCAP"), AUXV_FORMAT_HEX
);
486 TAG (AT_EXECFN
, _("File name of executable"), AUXV_FORMAT_STR
);
487 TAG (AT_SECURE
, _("Boolean, was exec setuid-like?"), AUXV_FORMAT_DEC
);
488 TAG (AT_SYSINFO
, _("Special system info/entry points"), AUXV_FORMAT_HEX
);
489 TAG (AT_SYSINFO_EHDR
, _("System-supplied DSO's ELF header"),
491 TAG (AT_L1I_CACHESHAPE
, _("L1 Instruction cache information"),
493 TAG (AT_L1I_CACHESIZE
, _("L1 Instruction cache size"), AUXV_FORMAT_HEX
);
494 TAG (AT_L1I_CACHEGEOMETRY
, _("L1 Instruction cache geometry"),
496 TAG (AT_L1D_CACHESHAPE
, _("L1 Data cache information"), AUXV_FORMAT_HEX
);
497 TAG (AT_L1D_CACHESIZE
, _("L1 Data cache size"), AUXV_FORMAT_HEX
);
498 TAG (AT_L1D_CACHEGEOMETRY
, _("L1 Data cache geometry"),
500 TAG (AT_L2_CACHESHAPE
, _("L2 cache information"), AUXV_FORMAT_HEX
);
501 TAG (AT_L2_CACHESIZE
, _("L2 cache size"), AUXV_FORMAT_HEX
);
502 TAG (AT_L2_CACHEGEOMETRY
, _("L2 cache geometry"), AUXV_FORMAT_HEX
);
503 TAG (AT_L3_CACHESHAPE
, _("L3 cache information"), AUXV_FORMAT_HEX
);
504 TAG (AT_L3_CACHESIZE
, _("L3 cache size"), AUXV_FORMAT_HEX
);
505 TAG (AT_L3_CACHEGEOMETRY
, _("L3 cache geometry"), AUXV_FORMAT_HEX
);
506 TAG (AT_MINSIGSTKSZ
, _("Minimum stack size for signal delivery"),
508 TAG (AT_SUN_UID
, _("Effective user ID"), AUXV_FORMAT_DEC
);
509 TAG (AT_SUN_RUID
, _("Real user ID"), AUXV_FORMAT_DEC
);
510 TAG (AT_SUN_GID
, _("Effective group ID"), AUXV_FORMAT_DEC
);
511 TAG (AT_SUN_RGID
, _("Real group ID"), AUXV_FORMAT_DEC
);
512 TAG (AT_SUN_LDELF
, _("Dynamic linker's ELF header"), AUXV_FORMAT_HEX
);
513 TAG (AT_SUN_LDSHDR
, _("Dynamic linker's section headers"),
515 TAG (AT_SUN_LDNAME
, _("String giving name of dynamic linker"),
517 TAG (AT_SUN_LPAGESZ
, _("Large pagesize"), AUXV_FORMAT_DEC
);
518 TAG (AT_SUN_PLATFORM
, _("Platform name string"), AUXV_FORMAT_STR
);
519 TAG (AT_SUN_CAP_HW1
, _("Machine-dependent CPU capability hints"),
521 TAG (AT_SUN_IFLUSH
, _("Should flush icache?"), AUXV_FORMAT_DEC
);
522 TAG (AT_SUN_CPU
, _("CPU name string"), AUXV_FORMAT_STR
);
523 TAG (AT_SUN_EMUL_ENTRY
, _("COFF entry point address"), AUXV_FORMAT_HEX
);
524 TAG (AT_SUN_EMUL_EXECFD
, _("COFF executable file descriptor"),
526 TAG (AT_SUN_EXECNAME
,
527 _("Canonicalized file name given to execve"), AUXV_FORMAT_STR
);
528 TAG (AT_SUN_MMU
, _("String for name of MMU module"), AUXV_FORMAT_STR
);
529 TAG (AT_SUN_LDDATA
, _("Dynamic linker's data segment address"),
531 TAG (AT_SUN_AUXFLAGS
,
532 _("AF_SUN_ flags passed from the kernel"), AUXV_FORMAT_HEX
);
533 TAG (AT_SUN_EMULATOR
, _("Name of emulation binary for runtime linker"),
535 TAG (AT_SUN_BRANDNAME
, _("Name of brand library"), AUXV_FORMAT_STR
);
536 TAG (AT_SUN_BRAND_AUX1
, _("Aux vector for brand modules 1"),
538 TAG (AT_SUN_BRAND_AUX2
, _("Aux vector for brand modules 2"),
540 TAG (AT_SUN_BRAND_AUX3
, _("Aux vector for brand modules 3"),
542 TAG (AT_SUN_CAP_HW2
, _("Machine-dependent CPU capability hints 2"),
546 fprint_auxv_entry (file
, name
, description
, format
, type
, val
);
549 /* Print the contents of the target's AUXV on the specified file. */
552 fprint_target_auxv (struct ui_file
*file
, struct target_ops
*ops
)
554 struct gdbarch
*gdbarch
= target_gdbarch ();
557 auxv_info
*info
= get_auxv_inferior_data (ops
);
562 gdb_byte
*data
= info
->data
->data ();
563 gdb_byte
*ptr
= data
;
564 size_t len
= info
->data
->size ();
566 while (target_auxv_parse (&ptr
, data
+ len
, &type
, &val
) > 0)
568 gdbarch_print_auxv_entry (gdbarch
, file
, type
, val
);
578 info_auxv_command (const char *cmd
, int from_tty
)
580 if (! target_has_stack ())
581 error (_("The program has no auxiliary information now."));
584 int ents
= fprint_target_auxv (gdb_stdout
,
585 current_inferior ()->top_target ());
588 error (_("No auxiliary vector found, or failed reading it."));
590 error (_("Auxiliary vector is empty."));
594 void _initialize_auxv ();
598 add_info ("auxv", info_auxv_command
,
599 _("Display the inferior's auxiliary vector.\n\
600 This is information provided by the operating system at program startup."));
602 /* Observers used to invalidate the auxv cache when needed. */
603 gdb::observers::inferior_exit
.attach (invalidate_auxv_cache_inf
, "auxv");
604 gdb::observers::inferior_appeared
.attach (invalidate_auxv_cache_inf
, "auxv");
605 gdb::observers::executable_changed
.attach (invalidate_auxv_cache
, "auxv");