1 /* Auxiliary vector support for GDB, the GNU debugger.
3 Copyright (C) 2004-2018 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 "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
,
53 pathname
= xstrprintf ("/proc/%d/auxv", ptid_get_pid (inferior_ptid
));
54 fd
= gdb_open_cloexec (pathname
, writebuf
!= NULL
? O_WRONLY
: O_RDONLY
, 0);
57 return TARGET_XFER_E_IO
;
59 if (offset
!= (ULONGEST
) 0
60 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
62 else if (readbuf
!= NULL
)
63 l
= read (fd
, readbuf
, (size_t) len
);
65 l
= write (fd
, writebuf
, (size_t) len
);
70 return TARGET_XFER_E_IO
;
72 return TARGET_XFER_EOF
;
75 *xfered_len
= (ULONGEST
) l
;
76 return TARGET_XFER_OK
;
80 /* This function handles access via ld.so's symbol `_dl_auxv'. */
82 static enum target_xfer_status
83 ld_so_xfer_auxv (gdb_byte
*readbuf
,
84 const gdb_byte
*writebuf
,
86 ULONGEST len
, ULONGEST
*xfered_len
)
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
);
97 msym
= lookup_minimal_symbol ("_dl_auxv", NULL
, NULL
);
98 if (msym
.minsym
== NULL
)
99 return TARGET_XFER_E_IO
;
101 if (MSYMBOL_SIZE (msym
.minsym
) != ptr_size
)
102 return TARGET_XFER_E_IO
;
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. */
108 pointer_address
= BMSYMBOL_VALUE_ADDRESS (msym
);
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
120 If the memory read fails, return -1 to fallback on another
121 mechanism for retrieving the AUXV.
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
130 if (target_read_memory (pointer_address
, ptr_buf
, ptr_size
) != 0)
131 return TARGET_XFER_E_IO
;
133 data_address
= extract_typed_address (ptr_buf
, ptr_type
);
135 /* Possibly still not initialized such as during an inferior
137 if (data_address
== 0)
138 return TARGET_XFER_E_IO
;
140 data_address
+= offset
;
142 if (writebuf
!= NULL
)
144 if (target_write_memory (data_address
, writebuf
, len
) == 0)
146 *xfered_len
= (ULONGEST
) len
;
147 return TARGET_XFER_OK
;
150 return TARGET_XFER_E_IO
;
153 /* Stop if trying to read past the existing AUXV block. The final
154 AT_NULL was already returned before. */
156 if (offset
>= auxv_pair_size
)
158 if (target_read_memory (data_address
- auxv_pair_size
, ptr_buf
,
160 return TARGET_XFER_E_IO
;
162 if (extract_typed_address (ptr_buf
, ptr_type
) == AT_NULL
)
163 return TARGET_XFER_EOF
;
168 gdb_assert (block
% auxv_pair_size
== 0);
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). */
180 block
&= -auxv_pair_size
;
184 if (target_read_memory (data_address
, readbuf
, block
) != 0)
186 if (block
<= auxv_pair_size
)
189 block
= auxv_pair_size
;
193 data_address
+= block
;
196 /* Check terminal AT_NULL. This function is being called
197 indefinitely being extended its READBUF until it returns EOF
200 while (block
>= auxv_pair_size
)
202 retval
+= auxv_pair_size
;
204 if (extract_typed_address (readbuf
, ptr_type
) == AT_NULL
)
206 *xfered_len
= (ULONGEST
) retval
;
207 return TARGET_XFER_OK
;
210 readbuf
+= auxv_pair_size
;
211 block
-= auxv_pair_size
;
215 *xfered_len
= (ULONGEST
) retval
;
216 return TARGET_XFER_OK
;
219 /* Implement the to_xfer_partial target_ops method for
220 TARGET_OBJECT_AUXV. It handles access to AUXV. */
222 enum target_xfer_status
223 memory_xfer_auxv (struct target_ops
*ops
,
224 enum target_object object
,
227 const gdb_byte
*writebuf
,
229 ULONGEST len
, ULONGEST
*xfered_len
)
231 gdb_assert (object
== TARGET_OBJECT_AUXV
);
232 gdb_assert (readbuf
|| writebuf
);
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.
241 if (current_inferior ()->attach_flag
!= 0)
243 enum target_xfer_status ret
;
245 ret
= ld_so_xfer_auxv (readbuf
, writebuf
, offset
, len
, xfered_len
);
246 if (ret
!= TARGET_XFER_E_IO
)
250 return procfs_xfer_auxv (readbuf
, writebuf
, offset
, len
, xfered_len
);
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. */
258 default_auxv_parse (struct target_ops
*ops
, gdb_byte
**readptr
,
259 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
261 const int sizeof_auxv_field
= gdbarch_ptr_bit (target_gdbarch ())
263 const enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
264 gdb_byte
*ptr
= *readptr
;
269 if (endptr
- ptr
< sizeof_auxv_field
* 2)
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
;
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. */
286 target_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();
291 if (gdbarch_auxv_parse_p (gdbarch
))
292 return gdbarch_auxv_parse (gdbarch
, readptr
, endptr
, typep
, valp
);
294 return current_target
.to_auxv_parse (¤t_target
, readptr
, endptr
,
299 /* Per-inferior data key for auxv. */
300 static const struct inferior_data
*auxv_inferior_data
;
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. */
307 gdb::optional
<gdb::byte_vector
> data
;
310 /* Handles the cleanup of the auxv cache for inferior INF. ARG is ignored.
311 Frees whatever allocated space there is to be freed and sets INF's auxv cache
312 data pointer to NULL.
314 This function is called when the following events occur: inferior_appeared,
315 inferior_exit and executable_changed. */
318 auxv_inferior_data_cleanup (struct inferior
*inf
, void *arg
)
320 struct auxv_info
*info
;
322 info
= (struct auxv_info
*) inferior_data (inf
, auxv_inferior_data
);
326 set_inferior_data (inf
, auxv_inferior_data
, NULL
);
330 /* Invalidate INF's auxv cache. */
333 invalidate_auxv_cache_inf (struct inferior
*inf
)
335 auxv_inferior_data_cleanup (inf
, NULL
);
338 /* Invalidate current inferior's auxv cache. */
341 invalidate_auxv_cache (void)
343 invalidate_auxv_cache_inf (current_inferior ());
346 /* Fetch the auxv object from inferior INF. If auxv is cached already,
347 return a pointer to the cache. If not, fetch the auxv object from the
348 target and cache it. This function always returns a valid INFO pointer. */
350 static struct auxv_info
*
351 get_auxv_inferior_data (struct target_ops
*ops
)
353 struct auxv_info
*info
;
354 struct inferior
*inf
= current_inferior ();
356 info
= (struct auxv_info
*) inferior_data (inf
, auxv_inferior_data
);
359 info
= new auxv_info
;
360 info
->data
= target_read_alloc (ops
, TARGET_OBJECT_AUXV
, NULL
);
361 set_inferior_data (inf
, auxv_inferior_data
, info
);
367 /* Extract the auxiliary vector entry with a_type matching MATCH.
368 Return zero if no such entry was found, or -1 if there was
369 an error getting the information. On success, return 1 after
370 storing the entry's value field in *VALP. */
372 target_auxv_search (struct target_ops
*ops
, CORE_ADDR match
, CORE_ADDR
*valp
)
375 auxv_info
*info
= get_auxv_inferior_data (ops
);
380 gdb_byte
*data
= info
->data
->data ();
381 gdb_byte
*ptr
= data
;
382 size_t len
= info
->data
->size ();
385 switch (target_auxv_parse (ops
, &ptr
, data
+ len
, &type
, &val
))
387 case 1: /* Here's an entry, check it. */
394 case 0: /* End of the vector. */
396 default: /* Bogosity. */
404 /* Print the description of a single AUXV entry on the specified file. */
407 fprint_auxv_entry (struct ui_file
*file
, const char *name
,
408 const char *description
, enum auxv_format format
,
409 CORE_ADDR type
, CORE_ADDR val
)
411 fprintf_filtered (file
, ("%-4s %-20s %-30s "),
412 plongest (type
), name
, description
);
415 case AUXV_FORMAT_DEC
:
416 fprintf_filtered (file
, ("%s\n"), plongest (val
));
418 case AUXV_FORMAT_HEX
:
419 fprintf_filtered (file
, ("%s\n"), paddress (target_gdbarch (), val
));
421 case AUXV_FORMAT_STR
:
423 struct value_print_options opts
;
425 get_user_print_options (&opts
);
426 if (opts
.addressprint
)
427 fprintf_filtered (file
, ("%s "), paddress (target_gdbarch (), val
));
428 val_print_string (builtin_type (target_gdbarch ())->builtin_char
,
429 NULL
, val
, -1, file
, &opts
);
430 fprintf_filtered (file
, ("\n"));
436 /* The default implementation of gdbarch_print_auxv_entry. */
439 default_print_auxv_entry (struct gdbarch
*gdbarch
, struct ui_file
*file
,
440 CORE_ADDR type
, CORE_ADDR val
)
442 const char *name
= "???";
443 const char *description
= "";
444 enum auxv_format format
= AUXV_FORMAT_HEX
;
448 #define TAG(tag, text, kind) \
449 case tag: name = #tag; description = text; format = kind; break
450 TAG (AT_NULL
, _("End of vector"), AUXV_FORMAT_HEX
);
451 TAG (AT_IGNORE
, _("Entry should be ignored"), AUXV_FORMAT_HEX
);
452 TAG (AT_EXECFD
, _("File descriptor of program"), AUXV_FORMAT_DEC
);
453 TAG (AT_PHDR
, _("Program headers for program"), AUXV_FORMAT_HEX
);
454 TAG (AT_PHENT
, _("Size of program header entry"), AUXV_FORMAT_DEC
);
455 TAG (AT_PHNUM
, _("Number of program headers"), AUXV_FORMAT_DEC
);
456 TAG (AT_PAGESZ
, _("System page size"), AUXV_FORMAT_DEC
);
457 TAG (AT_BASE
, _("Base address of interpreter"), AUXV_FORMAT_HEX
);
458 TAG (AT_FLAGS
, _("Flags"), AUXV_FORMAT_HEX
);
459 TAG (AT_ENTRY
, _("Entry point of program"), AUXV_FORMAT_HEX
);
460 TAG (AT_NOTELF
, _("Program is not ELF"), AUXV_FORMAT_DEC
);
461 TAG (AT_UID
, _("Real user ID"), AUXV_FORMAT_DEC
);
462 TAG (AT_EUID
, _("Effective user ID"), AUXV_FORMAT_DEC
);
463 TAG (AT_GID
, _("Real group ID"), AUXV_FORMAT_DEC
);
464 TAG (AT_EGID
, _("Effective group ID"), AUXV_FORMAT_DEC
);
465 TAG (AT_CLKTCK
, _("Frequency of times()"), AUXV_FORMAT_DEC
);
466 TAG (AT_PLATFORM
, _("String identifying platform"), AUXV_FORMAT_STR
);
467 TAG (AT_HWCAP
, _("Machine-dependent CPU capability hints"),
469 TAG (AT_FPUCW
, _("Used FPU control word"), AUXV_FORMAT_DEC
);
470 TAG (AT_DCACHEBSIZE
, _("Data cache block size"), AUXV_FORMAT_DEC
);
471 TAG (AT_ICACHEBSIZE
, _("Instruction cache block size"), AUXV_FORMAT_DEC
);
472 TAG (AT_UCACHEBSIZE
, _("Unified cache block size"), AUXV_FORMAT_DEC
);
473 TAG (AT_IGNOREPPC
, _("Entry should be ignored"), AUXV_FORMAT_DEC
);
474 TAG (AT_BASE_PLATFORM
, _("String identifying base platform"),
476 TAG (AT_RANDOM
, _("Address of 16 random bytes"), AUXV_FORMAT_HEX
);
477 TAG (AT_HWCAP2
, _("Extension of AT_HWCAP"), AUXV_FORMAT_HEX
);
478 TAG (AT_EXECFN
, _("File name of executable"), AUXV_FORMAT_STR
);
479 TAG (AT_SECURE
, _("Boolean, was exec setuid-like?"), AUXV_FORMAT_DEC
);
480 TAG (AT_SYSINFO
, _("Special system info/entry points"), AUXV_FORMAT_HEX
);
481 TAG (AT_SYSINFO_EHDR
, _("System-supplied DSO's ELF header"),
483 TAG (AT_L1I_CACHESHAPE
, _("L1 Instruction cache information"),
485 TAG (AT_L1D_CACHESHAPE
, _("L1 Data cache information"), AUXV_FORMAT_HEX
);
486 TAG (AT_L2_CACHESHAPE
, _("L2 cache information"), AUXV_FORMAT_HEX
);
487 TAG (AT_L3_CACHESHAPE
, _("L3 cache information"), AUXV_FORMAT_HEX
);
488 TAG (AT_SUN_UID
, _("Effective user ID"), AUXV_FORMAT_DEC
);
489 TAG (AT_SUN_RUID
, _("Real user ID"), AUXV_FORMAT_DEC
);
490 TAG (AT_SUN_GID
, _("Effective group ID"), AUXV_FORMAT_DEC
);
491 TAG (AT_SUN_RGID
, _("Real group ID"), AUXV_FORMAT_DEC
);
492 TAG (AT_SUN_LDELF
, _("Dynamic linker's ELF header"), AUXV_FORMAT_HEX
);
493 TAG (AT_SUN_LDSHDR
, _("Dynamic linker's section headers"),
495 TAG (AT_SUN_LDNAME
, _("String giving name of dynamic linker"),
497 TAG (AT_SUN_LPAGESZ
, _("Large pagesize"), AUXV_FORMAT_DEC
);
498 TAG (AT_SUN_PLATFORM
, _("Platform name string"), AUXV_FORMAT_STR
);
499 TAG (AT_SUN_HWCAP
, _("Machine-dependent CPU capability hints"),
501 TAG (AT_SUN_IFLUSH
, _("Should flush icache?"), AUXV_FORMAT_DEC
);
502 TAG (AT_SUN_CPU
, _("CPU name string"), AUXV_FORMAT_STR
);
503 TAG (AT_SUN_EMUL_ENTRY
, _("COFF entry point address"), AUXV_FORMAT_HEX
);
504 TAG (AT_SUN_EMUL_EXECFD
, _("COFF executable file descriptor"),
506 TAG (AT_SUN_EXECNAME
,
507 _("Canonicalized file name given to execve"), AUXV_FORMAT_STR
);
508 TAG (AT_SUN_MMU
, _("String for name of MMU module"), AUXV_FORMAT_STR
);
509 TAG (AT_SUN_LDDATA
, _("Dynamic linker's data segment address"),
511 TAG (AT_SUN_AUXFLAGS
,
512 _("AF_SUN_ flags passed from the kernel"), AUXV_FORMAT_HEX
);
515 fprint_auxv_entry (file
, name
, description
, format
, type
, val
);
518 /* Print the contents of the target's AUXV on the specified file. */
521 fprint_target_auxv (struct ui_file
*file
, struct target_ops
*ops
)
523 struct gdbarch
*gdbarch
= target_gdbarch ();
526 auxv_info
*info
= get_auxv_inferior_data (ops
);
531 gdb_byte
*data
= info
->data
->data ();
532 gdb_byte
*ptr
= data
;
533 size_t len
= info
->data
->size ();
535 while (target_auxv_parse (ops
, &ptr
, data
+ len
, &type
, &val
) > 0)
537 gdbarch_print_auxv_entry (gdbarch
, file
, type
, val
);
547 info_auxv_command (const char *cmd
, int from_tty
)
549 if (! target_has_stack
)
550 error (_("The program has no auxiliary information now."));
553 int ents
= fprint_target_auxv (gdb_stdout
, ¤t_target
);
556 error (_("No auxiliary vector found, or failed reading it."));
558 error (_("Auxiliary vector is empty."));
563 _initialize_auxv (void)
565 add_info ("auxv", info_auxv_command
,
566 _("Display the inferior's auxiliary vector.\n\
567 This is information provided by the operating system at program startup."));
569 /* Set an auxv cache per-inferior. */
571 = register_inferior_data_with_cleanup (NULL
, auxv_inferior_data_cleanup
);
573 /* Observers used to invalidate the auxv cache when needed. */
574 gdb::observers::inferior_exit
.attach (invalidate_auxv_cache_inf
);
575 gdb::observers::inferior_appeared
.attach (invalidate_auxv_cache_inf
);
576 gdb::observers::executable_changed
.attach (invalidate_auxv_cache
);