1 /* Auxiliary vector support for GDB, the GNU debugger.
3 Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 #include "gdb_assert.h"
31 #include "elf/common.h"
37 /* This function handles access via /proc/PID/auxv, which is a common method
38 for native targets. */
41 procfs_xfer_auxv (gdb_byte
*readbuf
,
42 const gdb_byte
*writebuf
,
50 pathname
= xstrprintf ("/proc/%d/auxv", PIDGET (inferior_ptid
));
51 fd
= open (pathname
, writebuf
!= NULL
? O_WRONLY
: O_RDONLY
);
56 if (offset
!= (ULONGEST
) 0
57 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
59 else if (readbuf
!= NULL
)
60 n
= read (fd
, readbuf
, len
);
62 n
= write (fd
, writebuf
, len
);
69 /* This function handles access via ld.so's symbol `_dl_auxv'. */
72 ld_so_xfer_auxv (gdb_byte
*readbuf
,
73 const gdb_byte
*writebuf
,
77 struct minimal_symbol
*msym
;
78 CORE_ADDR data_address
, pointer_address
;
79 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
80 size_t ptr_size
= TYPE_LENGTH (ptr_type
);
81 size_t auxv_pair_size
= 2 * ptr_size
;
82 gdb_byte
*ptr_buf
= alloca (ptr_size
);
86 msym
= lookup_minimal_symbol ("_dl_auxv", NULL
, NULL
);
90 if (MSYMBOL_SIZE (msym
) != ptr_size
)
93 /* POINTER_ADDRESS is a location where the `_dl_auxv' variable resides.
94 DATA_ADDRESS is the inferior value present in `_dl_auxv', therefore the
95 real inferior AUXV address. */
97 pointer_address
= SYMBOL_VALUE_ADDRESS (msym
);
99 /* The location of the _dl_auxv symbol may no longer be correct if
100 ld.so runs at a different address than the one present in the file.
101 This is very common case - for unprelinked ld.so or with a PIE executable.
102 PIE executable forces random address even for libraries already being
103 prelinked to some address. PIE executables themselves are never prelinked
104 even on prelinked systems. Prelinking of a PIE executable would block
105 their purpose of randomizing load of everything including the executable.
107 If the memory read fails, return -1 to fallback on another mechanism for
110 In most cases of a PIE running under valgrind there is no way to find
111 out the base addresses of any of ld.so, executable or AUXV as everything
112 is randomized and /proc information is not relevant for the virtual
113 executable running under valgrind. We think that we might need a valgrind
114 extension to make it work. This is PR 11440. */
116 if (target_read_memory (pointer_address
, ptr_buf
, ptr_size
) != 0)
119 data_address
= extract_typed_address (ptr_buf
, ptr_type
);
121 /* Possibly still not initialized such as during an inferior startup. */
122 if (data_address
== 0)
125 data_address
+= offset
;
127 if (writebuf
!= NULL
)
129 if (target_write_memory (data_address
, writebuf
, len
) == 0)
135 /* Stop if trying to read past the existing AUXV block. The final AT_NULL
136 was already returned before. */
138 if (offset
>= auxv_pair_size
)
140 if (target_read_memory (data_address
- auxv_pair_size
, ptr_buf
,
144 if (extract_typed_address (ptr_buf
, ptr_type
) == AT_NULL
)
150 gdb_assert (block
% auxv_pair_size
== 0);
157 /* Reading sizes smaller than AUXV_PAIR_SIZE is not supported. Tails
158 unaligned to AUXV_PAIR_SIZE will not be read during a call (they
159 should be completed during next read with new/extended buffer). */
161 block
&= -auxv_pair_size
;
165 if (target_read_memory (data_address
, readbuf
, block
) != 0)
167 if (block
<= auxv_pair_size
)
170 block
= auxv_pair_size
;
174 data_address
+= block
;
177 /* Check terminal AT_NULL. This function is being called indefinitely
178 being extended its READBUF until it returns EOF (0). */
180 while (block
>= auxv_pair_size
)
182 retval
+= auxv_pair_size
;
184 if (extract_typed_address (readbuf
, ptr_type
) == AT_NULL
)
187 readbuf
+= auxv_pair_size
;
188 block
-= auxv_pair_size
;
195 /* This function is called like a to_xfer_partial hook, but must be
196 called with TARGET_OBJECT_AUXV. It handles access to AUXV. */
199 memory_xfer_auxv (struct target_ops
*ops
,
200 enum target_object object
,
203 const gdb_byte
*writebuf
,
207 gdb_assert (object
== TARGET_OBJECT_AUXV
);
208 gdb_assert (readbuf
|| writebuf
);
210 /* ld_so_xfer_auxv is the only function safe for virtual executables being
211 executed by valgrind's memcheck. As using ld_so_xfer_auxv is problematic
212 during inferior startup GDB does call it only for attached processes. */
214 if (current_inferior ()->attach_flag
!= 0)
218 retval
= ld_so_xfer_auxv (readbuf
, writebuf
, offset
, len
);
223 return procfs_xfer_auxv (readbuf
, writebuf
, offset
, len
);
226 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
227 Return 0 if *READPTR is already at the end of the buffer.
228 Return -1 if there is insufficient buffer for a whole entry.
229 Return 1 if an entry was read into *TYPEP and *VALP. */
231 default_auxv_parse (struct target_ops
*ops
, gdb_byte
**readptr
,
232 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
234 const int sizeof_auxv_field
= gdbarch_ptr_bit (target_gdbarch
)
236 const enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
237 gdb_byte
*ptr
= *readptr
;
242 if (endptr
- ptr
< sizeof_auxv_field
* 2)
245 *typep
= extract_unsigned_integer (ptr
, sizeof_auxv_field
, byte_order
);
246 ptr
+= sizeof_auxv_field
;
247 *valp
= extract_unsigned_integer (ptr
, sizeof_auxv_field
, byte_order
);
248 ptr
+= sizeof_auxv_field
;
254 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
255 Return 0 if *READPTR is already at the end of the buffer.
256 Return -1 if there is insufficient buffer for a whole entry.
257 Return 1 if an entry was read into *TYPEP and *VALP. */
259 target_auxv_parse (struct target_ops
*ops
, gdb_byte
**readptr
,
260 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
262 struct target_ops
*t
;
264 for (t
= ops
; t
!= NULL
; t
= t
->beneath
)
265 if (t
->to_auxv_parse
!= NULL
)
266 return t
->to_auxv_parse (t
, readptr
, endptr
, typep
, valp
);
268 return default_auxv_parse (ops
, readptr
, endptr
, typep
, valp
);
271 /* Extract the auxiliary vector entry with a_type matching MATCH.
272 Return zero if no such entry was found, or -1 if there was
273 an error getting the information. On success, return 1 after
274 storing the entry's value field in *VALP. */
276 target_auxv_search (struct target_ops
*ops
, CORE_ADDR match
, CORE_ADDR
*valp
)
280 LONGEST n
= target_read_alloc (ops
, TARGET_OBJECT_AUXV
, NULL
, &data
);
281 gdb_byte
*ptr
= data
;
287 switch (target_auxv_parse (ops
, &ptr
, data
+ n
, &type
, &val
))
289 case 1: /* Here's an entry, check it. */
297 case 0: /* End of the vector. */
300 default: /* Bogosity. */
309 /* Print the contents of the target's AUXV on the specified file. */
311 fprint_target_auxv (struct ui_file
*file
, struct target_ops
*ops
)
315 LONGEST len
= target_read_alloc (ops
, TARGET_OBJECT_AUXV
, NULL
,
317 gdb_byte
*ptr
= data
;
323 while (target_auxv_parse (ops
, &ptr
, data
+ len
, &type
, &val
) > 0)
325 const char *name
= "???";
326 const char *description
= "";
327 enum { dec
, hex
, str
} flavor
= hex
;
331 #define TAG(tag, text, kind) \
332 case tag: name = #tag; description = text; flavor = kind; break
333 TAG (AT_NULL
, _("End of vector"), hex
);
334 TAG (AT_IGNORE
, _("Entry should be ignored"), hex
);
335 TAG (AT_EXECFD
, _("File descriptor of program"), dec
);
336 TAG (AT_PHDR
, _("Program headers for program"), hex
);
337 TAG (AT_PHENT
, _("Size of program header entry"), dec
);
338 TAG (AT_PHNUM
, _("Number of program headers"), dec
);
339 TAG (AT_PAGESZ
, _("System page size"), dec
);
340 TAG (AT_BASE
, _("Base address of interpreter"), hex
);
341 TAG (AT_FLAGS
, _("Flags"), hex
);
342 TAG (AT_ENTRY
, _("Entry point of program"), hex
);
343 TAG (AT_NOTELF
, _("Program is not ELF"), dec
);
344 TAG (AT_UID
, _("Real user ID"), dec
);
345 TAG (AT_EUID
, _("Effective user ID"), dec
);
346 TAG (AT_GID
, _("Real group ID"), dec
);
347 TAG (AT_EGID
, _("Effective group ID"), dec
);
348 TAG (AT_CLKTCK
, _("Frequency of times()"), dec
);
349 TAG (AT_PLATFORM
, _("String identifying platform"), str
);
350 TAG (AT_HWCAP
, _("Machine-dependent CPU capability hints"), hex
);
351 TAG (AT_FPUCW
, _("Used FPU control word"), dec
);
352 TAG (AT_DCACHEBSIZE
, _("Data cache block size"), dec
);
353 TAG (AT_ICACHEBSIZE
, _("Instruction cache block size"), dec
);
354 TAG (AT_UCACHEBSIZE
, _("Unified cache block size"), dec
);
355 TAG (AT_IGNOREPPC
, _("Entry should be ignored"), dec
);
356 TAG (AT_BASE_PLATFORM
, _("String identifying base platform"), str
);
357 TAG (AT_RANDOM
, _("Address of 16 random bytes"), hex
);
358 TAG (AT_EXECFN
, _("File name of executable"), str
);
359 TAG (AT_SECURE
, _("Boolean, was exec setuid-like?"), dec
);
360 TAG (AT_SYSINFO
, _("Special system info/entry points"), hex
);
361 TAG (AT_SYSINFO_EHDR
, _("System-supplied DSO's ELF header"), hex
);
362 TAG (AT_SUN_UID
, _("Effective user ID"), dec
);
363 TAG (AT_SUN_RUID
, _("Real user ID"), dec
);
364 TAG (AT_SUN_GID
, _("Effective group ID"), dec
);
365 TAG (AT_SUN_RGID
, _("Real group ID"), dec
);
366 TAG (AT_SUN_LDELF
, _("Dynamic linker's ELF header"), hex
);
367 TAG (AT_SUN_LDSHDR
, _("Dynamic linker's section headers"), hex
);
368 TAG (AT_SUN_LDNAME
, _("String giving name of dynamic linker"), str
);
369 TAG (AT_SUN_LPAGESZ
, _("Large pagesize"), dec
);
370 TAG (AT_SUN_PLATFORM
, _("Platform name string"), str
);
371 TAG (AT_SUN_HWCAP
, _("Machine-dependent CPU capability hints"), hex
);
372 TAG (AT_SUN_IFLUSH
, _("Should flush icache?"), dec
);
373 TAG (AT_SUN_CPU
, _("CPU name string"), str
);
374 TAG (AT_SUN_EMUL_ENTRY
, _("COFF entry point address"), hex
);
375 TAG (AT_SUN_EMUL_EXECFD
, _("COFF executable file descriptor"), dec
);
376 TAG (AT_SUN_EXECNAME
,
377 _("Canonicalized file name given to execve"), str
);
378 TAG (AT_SUN_MMU
, _("String for name of MMU module"), str
);
379 TAG (AT_SUN_LDDATA
, _("Dynamic linker's data segment address"), hex
);
380 TAG (AT_SUN_AUXFLAGS
,
381 _("AF_SUN_ flags passed from the kernel"), hex
);
384 fprintf_filtered (file
, "%-4s %-20s %-30s ",
385 plongest (type
), name
, description
);
389 fprintf_filtered (file
, "%s\n", plongest (val
));
392 fprintf_filtered (file
, "%s\n", paddress (target_gdbarch
, val
));
396 struct value_print_options opts
;
398 get_user_print_options (&opts
);
399 if (opts
.addressprint
)
400 fprintf_filtered (file
, "%s", paddress (target_gdbarch
, val
));
401 val_print_string (builtin_type (target_gdbarch
)->builtin_char
,
402 val
, -1, file
, &opts
);
403 fprintf_filtered (file
, "\n");
418 info_auxv_command (char *cmd
, int from_tty
)
420 if (! target_has_stack
)
421 error (_("The program has no auxiliary information now."));
424 int ents
= fprint_target_auxv (gdb_stdout
, ¤t_target
);
427 error (_("No auxiliary vector found, or failed reading it."));
429 error (_("Auxiliary vector is empty."));
434 extern initialize_file_ftype _initialize_auxv
; /* -Wmissing-prototypes; */
437 _initialize_auxv (void)
439 add_info ("auxv", info_auxv_command
,
440 _("Display the inferior's auxiliary vector.\n\
441 This is information provided by the operating system at program startup."));