Tests for validate symbol file using build-id.
[gdb/archer.git] / gdb / auxv.c
blob3a63a65d6c78e0a6c6bdd6a015fb68535dc152bf
1 /* Auxiliary vector support for GDB, the GNU debugger.
3 Copyright (C) 2004-2013 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/>. */
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 "gdb_assert.h"
27 #include "gdbcore.h"
28 #include "observer.h"
30 #include "auxv.h"
31 #include "elf/common.h"
33 #include <unistd.h>
34 #include <fcntl.h>
37 /* This function handles access via /proc/PID/auxv, which is a common
38 method for native targets. */
40 static LONGEST
41 procfs_xfer_auxv (gdb_byte *readbuf,
42 const gdb_byte *writebuf,
43 ULONGEST offset,
44 LONGEST len)
46 char *pathname;
47 int fd;
48 LONGEST n;
50 pathname = xstrprintf ("/proc/%d/auxv", PIDGET (inferior_ptid));
51 fd = open (pathname, writebuf != NULL ? O_WRONLY : O_RDONLY);
52 xfree (pathname);
53 if (fd < 0)
54 return -1;
56 if (offset != (ULONGEST) 0
57 && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
58 n = -1;
59 else if (readbuf != NULL)
60 n = read (fd, readbuf, len);
61 else
62 n = write (fd, writebuf, len);
64 (void) close (fd);
66 return n;
69 /* This function handles access via ld.so's symbol `_dl_auxv'. */
71 static LONGEST
72 ld_so_xfer_auxv (gdb_byte *readbuf,
73 const gdb_byte *writebuf,
74 ULONGEST offset,
75 LONGEST len)
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);
83 LONGEST retval;
84 size_t block;
86 msym = lookup_minimal_symbol ("_dl_auxv", NULL, NULL);
87 if (msym == NULL)
88 return -1;
90 if (MSYMBOL_SIZE (msym) != ptr_size)
91 return -1;
93 /* POINTER_ADDRESS is a location where the `_dl_auxv' variable
94 resides. DATA_ADDRESS is the inferior value present in
95 `_dl_auxv', therefore the 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
101 file. This is very common case - for unprelinked ld.so or with a
102 PIE executable. PIE executable forces random address even for
103 libraries already being prelinked to some address. PIE
104 executables themselves are never prelinked even on prelinked
105 systems. Prelinking of a PIE executable would block their
106 purpose of randomizing load of everything including the
107 executable.
109 If the memory read fails, return -1 to fallback on another
110 mechanism for retrieving the AUXV.
112 In most cases of a PIE running under valgrind there is no way to
113 find out the base addresses of any of ld.so, executable or AUXV
114 as everything is randomized and /proc information is not relevant
115 for the virtual executable running under valgrind. We think that
116 we might need a valgrind extension to make it work. This is PR
117 11440. */
119 if (target_read_memory (pointer_address, ptr_buf, ptr_size) != 0)
120 return -1;
122 data_address = extract_typed_address (ptr_buf, ptr_type);
124 /* Possibly still not initialized such as during an inferior
125 startup. */
126 if (data_address == 0)
127 return -1;
129 data_address += offset;
131 if (writebuf != NULL)
133 if (target_write_memory (data_address, writebuf, len) == 0)
134 return len;
135 else
136 return -1;
139 /* Stop if trying to read past the existing AUXV block. The final
140 AT_NULL was already returned before. */
142 if (offset >= auxv_pair_size)
144 if (target_read_memory (data_address - auxv_pair_size, ptr_buf,
145 ptr_size) != 0)
146 return -1;
148 if (extract_typed_address (ptr_buf, ptr_type) == AT_NULL)
149 return 0;
152 retval = 0;
153 block = 0x400;
154 gdb_assert (block % auxv_pair_size == 0);
156 while (len > 0)
158 if (block > len)
159 block = len;
161 /* Reading sizes smaller than AUXV_PAIR_SIZE is not supported.
162 Tails unaligned to AUXV_PAIR_SIZE will not be read during a
163 call (they should be completed during next read with
164 new/extended buffer). */
166 block &= -auxv_pair_size;
167 if (block == 0)
168 return retval;
170 if (target_read_memory (data_address, readbuf, block) != 0)
172 if (block <= auxv_pair_size)
173 return retval;
175 block = auxv_pair_size;
176 continue;
179 data_address += block;
180 len -= block;
182 /* Check terminal AT_NULL. This function is being called
183 indefinitely being extended its READBUF until it returns EOF
184 (0). */
186 while (block >= auxv_pair_size)
188 retval += auxv_pair_size;
190 if (extract_typed_address (readbuf, ptr_type) == AT_NULL)
191 return retval;
193 readbuf += auxv_pair_size;
194 block -= auxv_pair_size;
198 return retval;
201 /* This function is called like a to_xfer_partial hook, but must be
202 called with TARGET_OBJECT_AUXV. It handles access to AUXV. */
204 LONGEST
205 memory_xfer_auxv (struct target_ops *ops,
206 enum target_object object,
207 const char *annex,
208 gdb_byte *readbuf,
209 const gdb_byte *writebuf,
210 ULONGEST offset,
211 LONGEST len)
213 gdb_assert (object == TARGET_OBJECT_AUXV);
214 gdb_assert (readbuf || writebuf);
216 /* ld_so_xfer_auxv is the only function safe for virtual
217 executables being executed by valgrind's memcheck. Using
218 ld_so_xfer_auxv during inferior startup is problematic, because
219 ld.so symbol tables have not yet been relocated. So GDB uses
220 this function only when attaching to a process.
223 if (current_inferior ()->attach_flag != 0)
225 LONGEST retval;
227 retval = ld_so_xfer_auxv (readbuf, writebuf, offset, len);
228 if (retval != -1)
229 return retval;
232 return procfs_xfer_auxv (readbuf, writebuf, offset, len);
235 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
236 Return 0 if *READPTR is already at the end of the buffer.
237 Return -1 if there is insufficient buffer for a whole entry.
238 Return 1 if an entry was read into *TYPEP and *VALP. */
239 static int
240 default_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
241 gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
243 const int sizeof_auxv_field = gdbarch_ptr_bit (target_gdbarch ())
244 / TARGET_CHAR_BIT;
245 const enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
246 gdb_byte *ptr = *readptr;
248 if (endptr == ptr)
249 return 0;
251 if (endptr - ptr < sizeof_auxv_field * 2)
252 return -1;
254 *typep = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
255 ptr += sizeof_auxv_field;
256 *valp = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
257 ptr += sizeof_auxv_field;
259 *readptr = ptr;
260 return 1;
263 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
264 Return 0 if *READPTR is already at the end of the buffer.
265 Return -1 if there is insufficient buffer for a whole entry.
266 Return 1 if an entry was read into *TYPEP and *VALP. */
268 target_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
269 gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
271 struct target_ops *t;
273 for (t = ops; t != NULL; t = t->beneath)
274 if (t->to_auxv_parse != NULL)
275 return t->to_auxv_parse (t, readptr, endptr, typep, valp);
277 return default_auxv_parse (ops, readptr, endptr, typep, valp);
281 /* Per-inferior data key for auxv. */
282 static const struct inferior_data *auxv_inferior_data;
284 /* Auxiliary Vector information structure. This is used by GDB
285 for caching purposes for each inferior. This helps reduce the
286 overhead of transfering data from a remote target to the local host. */
287 struct auxv_info
289 LONGEST length;
290 gdb_byte *data;
293 /* Handles the cleanup of the auxv cache for inferior INF. ARG is ignored.
294 Frees whatever allocated space there is to be freed and sets INF's auxv cache
295 data pointer to NULL.
297 This function is called when the following events occur: inferior_appeared,
298 inferior_exit and executable_changed. */
300 static void
301 auxv_inferior_data_cleanup (struct inferior *inf, void *arg)
303 struct auxv_info *info;
305 info = inferior_data (inf, auxv_inferior_data);
306 if (info != NULL)
308 xfree (info->data);
309 xfree (info);
310 set_inferior_data (inf, auxv_inferior_data, NULL);
314 /* Invalidate INF's auxv cache. */
316 static void
317 invalidate_auxv_cache_inf (struct inferior *inf)
319 auxv_inferior_data_cleanup (inf, NULL);
322 /* Invalidate current inferior's auxv cache. */
324 static void
325 invalidate_auxv_cache (void)
327 invalidate_auxv_cache_inf (current_inferior ());
330 /* Fetch the auxv object from inferior INF. If auxv is cached already,
331 return a pointer to the cache. If not, fetch the auxv object from the
332 target and cache it. This function always returns a valid INFO pointer. */
334 static struct auxv_info *
335 get_auxv_inferior_data (struct target_ops *ops)
337 struct auxv_info *info;
338 struct inferior *inf = current_inferior ();
340 info = inferior_data (inf, auxv_inferior_data);
341 if (info == NULL)
343 info = XZALLOC (struct auxv_info);
344 info->length = target_read_alloc (ops, TARGET_OBJECT_AUXV,
345 NULL, &info->data);
346 set_inferior_data (inf, auxv_inferior_data, info);
349 return info;
352 /* Extract the auxiliary vector entry with a_type matching MATCH.
353 Return zero if no such entry was found, or -1 if there was
354 an error getting the information. On success, return 1 after
355 storing the entry's value field in *VALP. */
357 target_auxv_search (struct target_ops *ops, CORE_ADDR match, CORE_ADDR *valp)
359 CORE_ADDR type, val;
360 gdb_byte *data;
361 gdb_byte *ptr;
362 struct auxv_info *info;
364 info = get_auxv_inferior_data (ops);
366 data = info->data;
367 ptr = data;
369 if (info->length <= 0)
370 return info->length;
372 while (1)
373 switch (target_auxv_parse (ops, &ptr, data + info->length, &type, &val))
375 case 1: /* Here's an entry, check it. */
376 if (type == match)
378 *valp = val;
379 return 1;
381 break;
382 case 0: /* End of the vector. */
383 return 0;
384 default: /* Bogosity. */
385 return -1;
388 /*NOTREACHED*/
392 /* Print the contents of the target's AUXV on the specified file. */
394 fprint_target_auxv (struct ui_file *file, struct target_ops *ops)
396 CORE_ADDR type, val;
397 gdb_byte *data;
398 gdb_byte *ptr;
399 struct auxv_info *info;
400 int ents = 0;
402 info = get_auxv_inferior_data (ops);
404 data = info->data;
405 ptr = data;
406 if (info->length <= 0)
407 return info->length;
409 while (target_auxv_parse (ops, &ptr, data + info->length, &type, &val) > 0)
411 const char *name = "???";
412 const char *description = "";
413 enum { dec, hex, str } flavor = hex;
415 switch (type)
417 #define TAG(tag, text, kind) \
418 case tag: name = #tag; description = text; flavor = kind; break
419 TAG (AT_NULL, _("End of vector"), hex);
420 TAG (AT_IGNORE, _("Entry should be ignored"), hex);
421 TAG (AT_EXECFD, _("File descriptor of program"), dec);
422 TAG (AT_PHDR, _("Program headers for program"), hex);
423 TAG (AT_PHENT, _("Size of program header entry"), dec);
424 TAG (AT_PHNUM, _("Number of program headers"), dec);
425 TAG (AT_PAGESZ, _("System page size"), dec);
426 TAG (AT_BASE, _("Base address of interpreter"), hex);
427 TAG (AT_FLAGS, _("Flags"), hex);
428 TAG (AT_ENTRY, _("Entry point of program"), hex);
429 TAG (AT_NOTELF, _("Program is not ELF"), dec);
430 TAG (AT_UID, _("Real user ID"), dec);
431 TAG (AT_EUID, _("Effective user ID"), dec);
432 TAG (AT_GID, _("Real group ID"), dec);
433 TAG (AT_EGID, _("Effective group ID"), dec);
434 TAG (AT_CLKTCK, _("Frequency of times()"), dec);
435 TAG (AT_PLATFORM, _("String identifying platform"), str);
436 TAG (AT_HWCAP, _("Machine-dependent CPU capability hints"), hex);
437 TAG (AT_FPUCW, _("Used FPU control word"), dec);
438 TAG (AT_DCACHEBSIZE, _("Data cache block size"), dec);
439 TAG (AT_ICACHEBSIZE, _("Instruction cache block size"), dec);
440 TAG (AT_UCACHEBSIZE, _("Unified cache block size"), dec);
441 TAG (AT_IGNOREPPC, _("Entry should be ignored"), dec);
442 TAG (AT_BASE_PLATFORM, _("String identifying base platform"), str);
443 TAG (AT_RANDOM, _("Address of 16 random bytes"), hex);
444 TAG (AT_EXECFN, _("File name of executable"), str);
445 TAG (AT_SECURE, _("Boolean, was exec setuid-like?"), dec);
446 TAG (AT_SYSINFO, _("Special system info/entry points"), hex);
447 TAG (AT_SYSINFO_EHDR, _("System-supplied DSO's ELF header"), hex);
448 TAG (AT_L1I_CACHESHAPE, _("L1 Instruction cache information"), hex);
449 TAG (AT_L1D_CACHESHAPE, _("L1 Data cache information"), hex);
450 TAG (AT_L2_CACHESHAPE, _("L2 cache information"), hex);
451 TAG (AT_L3_CACHESHAPE, _("L3 cache information"), hex);
452 TAG (AT_SUN_UID, _("Effective user ID"), dec);
453 TAG (AT_SUN_RUID, _("Real user ID"), dec);
454 TAG (AT_SUN_GID, _("Effective group ID"), dec);
455 TAG (AT_SUN_RGID, _("Real group ID"), dec);
456 TAG (AT_SUN_LDELF, _("Dynamic linker's ELF header"), hex);
457 TAG (AT_SUN_LDSHDR, _("Dynamic linker's section headers"), hex);
458 TAG (AT_SUN_LDNAME, _("String giving name of dynamic linker"), str);
459 TAG (AT_SUN_LPAGESZ, _("Large pagesize"), dec);
460 TAG (AT_SUN_PLATFORM, _("Platform name string"), str);
461 TAG (AT_SUN_HWCAP, _("Machine-dependent CPU capability hints"), hex);
462 TAG (AT_SUN_IFLUSH, _("Should flush icache?"), dec);
463 TAG (AT_SUN_CPU, _("CPU name string"), str);
464 TAG (AT_SUN_EMUL_ENTRY, _("COFF entry point address"), hex);
465 TAG (AT_SUN_EMUL_EXECFD, _("COFF executable file descriptor"), dec);
466 TAG (AT_SUN_EXECNAME,
467 _("Canonicalized file name given to execve"), str);
468 TAG (AT_SUN_MMU, _("String for name of MMU module"), str);
469 TAG (AT_SUN_LDDATA, _("Dynamic linker's data segment address"), hex);
470 TAG (AT_SUN_AUXFLAGS,
471 _("AF_SUN_ flags passed from the kernel"), hex);
474 fprintf_filtered (file, "%-4s %-20s %-30s ",
475 plongest (type), name, description);
476 switch (flavor)
478 case dec:
479 fprintf_filtered (file, "%s\n", plongest (val));
480 break;
481 case hex:
482 fprintf_filtered (file, "%s\n", paddress (target_gdbarch (), val));
483 break;
484 case str:
486 struct value_print_options opts;
488 get_user_print_options (&opts);
489 if (opts.addressprint)
490 fprintf_filtered (file, "%s ", paddress (target_gdbarch (), val));
491 val_print_string (builtin_type (target_gdbarch ())->builtin_char,
492 NULL, val, -1, file, &opts);
493 fprintf_filtered (file, "\n");
495 break;
497 ++ents;
498 if (type == AT_NULL)
499 break;
502 return ents;
505 static void
506 info_auxv_command (char *cmd, int from_tty)
508 if (! target_has_stack)
509 error (_("The program has no auxiliary information now."));
510 else
512 int ents = fprint_target_auxv (gdb_stdout, &current_target);
514 if (ents < 0)
515 error (_("No auxiliary vector found, or failed reading it."));
516 else if (ents == 0)
517 error (_("Auxiliary vector is empty."));
522 extern initialize_file_ftype _initialize_auxv; /* -Wmissing-prototypes; */
524 void
525 _initialize_auxv (void)
527 add_info ("auxv", info_auxv_command,
528 _("Display the inferior's auxiliary vector.\n\
529 This is information provided by the operating system at program startup."));
531 /* Set an auxv cache per-inferior. */
532 auxv_inferior_data
533 = register_inferior_data_with_cleanup (NULL, auxv_inferior_data_cleanup);
535 /* Observers used to invalidate the auxv cache when needed. */
536 observer_attach_inferior_exit (invalidate_auxv_cache_inf);
537 observer_attach_inferior_appeared (invalidate_auxv_cache_inf);
538 observer_attach_executable_changed (invalidate_auxv_cache);