X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fauxv.c;h=53958011c81941c7cef35db50811b5b59fd6fb7f;hb=c0c3707ff46ccfb78ea175dd42d628d8c90dca8b;hp=593b0c8059b545dec8d5312b970721909b55dd25;hpb=86e4bafc3b0bb0148b95807d37b36aae14cdf56c;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/auxv.c b/gdb/auxv.c index 593b0c8059..53958011c8 100644 --- a/gdb/auxv.c +++ b/gdb/auxv.c @@ -1,7 +1,6 @@ /* Auxiliary vector support for GDB, the GNU debugger. - Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 - Free Software Foundation, Inc. + Copyright (C) 2004-2019 Free Software Foundation, Inc. This file is part of GDB. @@ -24,8 +23,10 @@ #include "command.h" #include "inferior.h" #include "valprint.h" -#include "gdb_assert.h" #include "gdbcore.h" +#include "observable.h" +#include "gdbsupport/filestuff.h" +#include "objfiles.h" #include "auxv.h" #include "elf/common.h" @@ -34,115 +35,130 @@ #include -/* This function handles access via /proc/PID/auxv, which is a common method - for native targets. */ +/* Implement the to_xfer_partial target_ops method. This function + handles access via /proc/PID/auxv, which is a common method for + native targets. */ -static LONGEST +static enum target_xfer_status procfs_xfer_auxv (gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, - LONGEST len) + ULONGEST len, + ULONGEST *xfered_len) { - char *pathname; int fd; - LONGEST n; + ssize_t l; - pathname = xstrprintf ("/proc/%d/auxv", PIDGET (inferior_ptid)); - fd = open (pathname, writebuf != NULL ? O_WRONLY : O_RDONLY); - xfree (pathname); + std::string pathname = string_printf ("/proc/%d/auxv", inferior_ptid.pid ()); + fd = gdb_open_cloexec (pathname, writebuf != NULL ? O_WRONLY : O_RDONLY, 0); if (fd < 0) - return -1; + return TARGET_XFER_E_IO; if (offset != (ULONGEST) 0 && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset) - n = -1; + l = -1; else if (readbuf != NULL) - n = read (fd, readbuf, len); + l = read (fd, readbuf, (size_t) len); else - n = write (fd, writebuf, len); + l = write (fd, writebuf, (size_t) len); (void) close (fd); - return n; + if (l < 0) + return TARGET_XFER_E_IO; + else if (l == 0) + return TARGET_XFER_EOF; + else + { + *xfered_len = (ULONGEST) l; + return TARGET_XFER_OK; + } } /* This function handles access via ld.so's symbol `_dl_auxv'. */ -static LONGEST +static enum target_xfer_status ld_so_xfer_auxv (gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, - LONGEST len) + ULONGEST len, ULONGEST *xfered_len) { - struct minimal_symbol *msym; + struct bound_minimal_symbol msym; CORE_ADDR data_address, pointer_address; - struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr; + struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr; size_t ptr_size = TYPE_LENGTH (ptr_type); size_t auxv_pair_size = 2 * ptr_size; - gdb_byte *ptr_buf = alloca (ptr_size); + gdb_byte *ptr_buf = (gdb_byte *) alloca (ptr_size); LONGEST retval; size_t block; msym = lookup_minimal_symbol ("_dl_auxv", NULL, NULL); - if (msym == NULL) - return -1; + if (msym.minsym == NULL) + return TARGET_XFER_E_IO; - if (MSYMBOL_SIZE (msym) != ptr_size) - return -1; + if (MSYMBOL_SIZE (msym.minsym) != ptr_size) + return TARGET_XFER_E_IO; - /* POINTER_ADDRESS is a location where the `_dl_auxv' variable resides. - DATA_ADDRESS is the inferior value present in `_dl_auxv', therefore the - real inferior AUXV address. */ + /* POINTER_ADDRESS is a location where the `_dl_auxv' variable + resides. DATA_ADDRESS is the inferior value present in + `_dl_auxv', therefore the real inferior AUXV address. */ - pointer_address = SYMBOL_VALUE_ADDRESS (msym); + pointer_address = BMSYMBOL_VALUE_ADDRESS (msym); /* The location of the _dl_auxv symbol may no longer be correct if - ld.so runs at a different address than the one present in the file. - This is very common case - for unprelinked ld.so or with a PIE executable. - PIE executable forces random address even for libraries already being - prelinked to some address. PIE executables themselves are never prelinked - even on prelinked systems. Prelinking of a PIE executable would block - their purpose of randomizing load of everything including the executable. - - If the memory read fails, return -1 to fallback on another mechanism for - retrieving the AUXV. - - In most cases of a PIE running under valgrind there is no way to find - out the base addresses of any of ld.so, executable or AUXV as everything - is randomized and /proc information is not relevant for the virtual - executable running under valgrind. We think that we might need a valgrind - extension to make it work. This is PR 11440. */ + ld.so runs at a different address than the one present in the + file. This is very common case - for unprelinked ld.so or with a + PIE executable. PIE executable forces random address even for + libraries already being prelinked to some address. PIE + executables themselves are never prelinked even on prelinked + systems. Prelinking of a PIE executable would block their + purpose of randomizing load of everything including the + executable. + + If the memory read fails, return -1 to fallback on another + mechanism for retrieving the AUXV. + + In most cases of a PIE running under valgrind there is no way to + find out the base addresses of any of ld.so, executable or AUXV + as everything is randomized and /proc information is not relevant + for the virtual executable running under valgrind. We think that + we might need a valgrind extension to make it work. This is PR + 11440. */ if (target_read_memory (pointer_address, ptr_buf, ptr_size) != 0) - return -1; + return TARGET_XFER_E_IO; data_address = extract_typed_address (ptr_buf, ptr_type); - /* Possibly still not initialized such as during an inferior startup. */ + /* Possibly still not initialized such as during an inferior + startup. */ if (data_address == 0) - return -1; + return TARGET_XFER_E_IO; data_address += offset; if (writebuf != NULL) { if (target_write_memory (data_address, writebuf, len) == 0) - return len; + { + *xfered_len = (ULONGEST) len; + return TARGET_XFER_OK; + } else - return -1; + return TARGET_XFER_E_IO; } - /* Stop if trying to read past the existing AUXV block. The final AT_NULL - was already returned before. */ + /* Stop if trying to read past the existing AUXV block. The final + AT_NULL was already returned before. */ if (offset >= auxv_pair_size) { if (target_read_memory (data_address - auxv_pair_size, ptr_buf, ptr_size) != 0) - return -1; + return TARGET_XFER_E_IO; if (extract_typed_address (ptr_buf, ptr_type) == AT_NULL) - return 0; + return TARGET_XFER_EOF; } retval = 0; @@ -154,18 +170,19 @@ ld_so_xfer_auxv (gdb_byte *readbuf, if (block > len) block = len; - /* Reading sizes smaller than AUXV_PAIR_SIZE is not supported. Tails - unaligned to AUXV_PAIR_SIZE will not be read during a call (they - should be completed during next read with new/extended buffer). */ + /* Reading sizes smaller than AUXV_PAIR_SIZE is not supported. + Tails unaligned to AUXV_PAIR_SIZE will not be read during a + call (they should be completed during next read with + new/extended buffer). */ block &= -auxv_pair_size; if (block == 0) - return retval; + break; if (target_read_memory (data_address, readbuf, block) != 0) { if (block <= auxv_pair_size) - return retval; + break; block = auxv_pair_size; continue; @@ -174,68 +191,74 @@ ld_so_xfer_auxv (gdb_byte *readbuf, data_address += block; len -= block; - /* Check terminal AT_NULL. This function is being called indefinitely - being extended its READBUF until it returns EOF (0). */ + /* Check terminal AT_NULL. This function is being called + indefinitely being extended its READBUF until it returns EOF + (0). */ while (block >= auxv_pair_size) { retval += auxv_pair_size; if (extract_typed_address (readbuf, ptr_type) == AT_NULL) - return retval; + { + *xfered_len = (ULONGEST) retval; + return TARGET_XFER_OK; + } readbuf += auxv_pair_size; block -= auxv_pair_size; } } - return retval; + *xfered_len = (ULONGEST) retval; + return TARGET_XFER_OK; } -/* This function is called like a to_xfer_partial hook, but must be - called with TARGET_OBJECT_AUXV. It handles access to AUXV. */ +/* Implement the to_xfer_partial target_ops method for + TARGET_OBJECT_AUXV. It handles access to AUXV. */ -LONGEST +enum target_xfer_status memory_xfer_auxv (struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, - LONGEST len) + ULONGEST len, ULONGEST *xfered_len) { gdb_assert (object == TARGET_OBJECT_AUXV); gdb_assert (readbuf || writebuf); - /* ld_so_xfer_auxv is the only function safe for virtual executables being - executed by valgrind's memcheck. Using ld_so_xfer_auxv during inferior - startup is problematic, because ld.so symbol tables have not yet been - relocated. So GDB uses this function only when attaching to a process. + /* ld_so_xfer_auxv is the only function safe for virtual + executables being executed by valgrind's memcheck. Using + ld_so_xfer_auxv during inferior startup is problematic, because + ld.so symbol tables have not yet been relocated. So GDB uses + this function only when attaching to a process. */ if (current_inferior ()->attach_flag != 0) { - LONGEST retval; + enum target_xfer_status ret; - retval = ld_so_xfer_auxv (readbuf, writebuf, offset, len); - if (retval != -1) - return retval; + ret = ld_so_xfer_auxv (readbuf, writebuf, offset, len, xfered_len); + if (ret != TARGET_XFER_E_IO) + return ret; } - return procfs_xfer_auxv (readbuf, writebuf, offset, len); + return procfs_xfer_auxv (readbuf, writebuf, offset, len, xfered_len); } /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR. Return 0 if *READPTR is already at the end of the buffer. Return -1 if there is insufficient buffer for a whole entry. Return 1 if an entry was read into *TYPEP and *VALP. */ -static int +int default_auxv_parse (struct target_ops *ops, gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp) { - const int sizeof_auxv_field = gdbarch_ptr_bit (target_gdbarch) + const int sizeof_auxv_field = gdbarch_ptr_bit (target_gdbarch ()) / TARGET_CHAR_BIT; - const enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch); + const enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); gdb_byte *ptr = *readptr; if (endptr == ptr) @@ -258,16 +281,63 @@ default_auxv_parse (struct target_ops *ops, gdb_byte **readptr, Return -1 if there is insufficient buffer for a whole entry. Return 1 if an entry was read into *TYPEP and *VALP. */ int -target_auxv_parse (struct target_ops *ops, gdb_byte **readptr, - gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp) +target_auxv_parse (gdb_byte **readptr, + gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp) +{ + struct gdbarch *gdbarch = target_gdbarch(); + + if (gdbarch_auxv_parse_p (gdbarch)) + return gdbarch_auxv_parse (gdbarch, readptr, endptr, typep, valp); + + return current_top_target ()->auxv_parse (readptr, endptr, typep, valp); +} + + +/* Auxiliary Vector information structure. This is used by GDB + for caching purposes for each inferior. This helps reduce the + overhead of transfering data from a remote target to the local host. */ +struct auxv_info +{ + gdb::optional data; +}; + +/* Per-inferior data key for auxv. */ +static const struct inferior_key auxv_inferior_data; + +/* Invalidate INF's auxv cache. */ + +static void +invalidate_auxv_cache_inf (struct inferior *inf) +{ + auxv_inferior_data.clear (inf); +} + +/* Invalidate current inferior's auxv cache. */ + +static void +invalidate_auxv_cache (void) +{ + invalidate_auxv_cache_inf (current_inferior ()); +} + +/* Fetch the auxv object from inferior INF. If auxv is cached already, + return a pointer to the cache. If not, fetch the auxv object from the + target and cache it. This function always returns a valid INFO pointer. */ + +static struct auxv_info * +get_auxv_inferior_data (struct target_ops *ops) { - struct target_ops *t; + struct auxv_info *info; + struct inferior *inf = current_inferior (); - for (t = ops; t != NULL; t = t->beneath) - if (t->to_auxv_parse != NULL) - return t->to_auxv_parse (t, readptr, endptr, typep, valp); - - return default_auxv_parse (ops, readptr, endptr, typep, valp); + info = auxv_inferior_data.get (inf); + if (info == NULL) + { + info = auxv_inferior_data.emplace (inf); + info->data = target_read_alloc (ops, TARGET_OBJECT_AUXV, NULL); + } + + return info; } /* Extract the auxiliary vector entry with a_type matching MATCH. @@ -278,29 +348,28 @@ int target_auxv_search (struct target_ops *ops, CORE_ADDR match, CORE_ADDR *valp) { CORE_ADDR type, val; - gdb_byte *data; - LONGEST n = target_read_alloc (ops, TARGET_OBJECT_AUXV, NULL, &data); - gdb_byte *ptr = data; + auxv_info *info = get_auxv_inferior_data (ops); - if (n <= 0) - return n; + if (!info->data) + return -1; + + gdb_byte *data = info->data->data (); + gdb_byte *ptr = data; + size_t len = info->data->size (); while (1) - switch (target_auxv_parse (ops, &ptr, data + n, &type, &val)) + switch (target_auxv_parse (&ptr, data + len, &type, &val)) { case 1: /* Here's an entry, check it. */ if (type == match) { - xfree (data); *valp = val; return 1; } break; case 0: /* End of the vector. */ - xfree (data); return 0; default: /* Bogosity. */ - xfree (data); return -1; } @@ -308,122 +377,167 @@ target_auxv_search (struct target_ops *ops, CORE_ADDR match, CORE_ADDR *valp) } -/* Print the contents of the target's AUXV on the specified file. */ +/* Print the description of a single AUXV entry on the specified file. */ + +void +fprint_auxv_entry (struct ui_file *file, const char *name, + const char *description, enum auxv_format format, + CORE_ADDR type, CORE_ADDR val) +{ + fprintf_filtered (file, ("%-4s %-20s %-30s "), + plongest (type), name, description); + switch (format) + { + case AUXV_FORMAT_DEC: + fprintf_filtered (file, ("%s\n"), plongest (val)); + break; + case AUXV_FORMAT_HEX: + fprintf_filtered (file, ("%s\n"), paddress (target_gdbarch (), val)); + break; + case AUXV_FORMAT_STR: + { + struct value_print_options opts; + + get_user_print_options (&opts); + if (opts.addressprint) + fprintf_filtered (file, ("%s "), paddress (target_gdbarch (), val)); + val_print_string (builtin_type (target_gdbarch ())->builtin_char, + NULL, val, -1, file, &opts); + fprintf_filtered (file, ("\n")); + } + break; + } +} + +/* The default implementation of gdbarch_print_auxv_entry. */ + +void +default_print_auxv_entry (struct gdbarch *gdbarch, struct ui_file *file, + CORE_ADDR type, CORE_ADDR val) +{ + const char *name = "???"; + const char *description = ""; + enum auxv_format format = AUXV_FORMAT_HEX; + + switch (type) + { +#define TAG(tag, text, kind) \ + case tag: name = #tag; description = text; format = kind; break + TAG (AT_NULL, _("End of vector"), AUXV_FORMAT_HEX); + TAG (AT_IGNORE, _("Entry should be ignored"), AUXV_FORMAT_HEX); + TAG (AT_EXECFD, _("File descriptor of program"), AUXV_FORMAT_DEC); + TAG (AT_PHDR, _("Program headers for program"), AUXV_FORMAT_HEX); + TAG (AT_PHENT, _("Size of program header entry"), AUXV_FORMAT_DEC); + TAG (AT_PHNUM, _("Number of program headers"), AUXV_FORMAT_DEC); + TAG (AT_PAGESZ, _("System page size"), AUXV_FORMAT_DEC); + TAG (AT_BASE, _("Base address of interpreter"), AUXV_FORMAT_HEX); + TAG (AT_FLAGS, _("Flags"), AUXV_FORMAT_HEX); + TAG (AT_ENTRY, _("Entry point of program"), AUXV_FORMAT_HEX); + TAG (AT_NOTELF, _("Program is not ELF"), AUXV_FORMAT_DEC); + TAG (AT_UID, _("Real user ID"), AUXV_FORMAT_DEC); + TAG (AT_EUID, _("Effective user ID"), AUXV_FORMAT_DEC); + TAG (AT_GID, _("Real group ID"), AUXV_FORMAT_DEC); + TAG (AT_EGID, _("Effective group ID"), AUXV_FORMAT_DEC); + TAG (AT_CLKTCK, _("Frequency of times()"), AUXV_FORMAT_DEC); + TAG (AT_PLATFORM, _("String identifying platform"), AUXV_FORMAT_STR); + TAG (AT_HWCAP, _("Machine-dependent CPU capability hints"), + AUXV_FORMAT_HEX); + TAG (AT_FPUCW, _("Used FPU control word"), AUXV_FORMAT_DEC); + TAG (AT_DCACHEBSIZE, _("Data cache block size"), AUXV_FORMAT_DEC); + TAG (AT_ICACHEBSIZE, _("Instruction cache block size"), AUXV_FORMAT_DEC); + TAG (AT_UCACHEBSIZE, _("Unified cache block size"), AUXV_FORMAT_DEC); + TAG (AT_IGNOREPPC, _("Entry should be ignored"), AUXV_FORMAT_DEC); + TAG (AT_BASE_PLATFORM, _("String identifying base platform"), + AUXV_FORMAT_STR); + TAG (AT_RANDOM, _("Address of 16 random bytes"), AUXV_FORMAT_HEX); + TAG (AT_HWCAP2, _("Extension of AT_HWCAP"), AUXV_FORMAT_HEX); + TAG (AT_EXECFN, _("File name of executable"), AUXV_FORMAT_STR); + TAG (AT_SECURE, _("Boolean, was exec setuid-like?"), AUXV_FORMAT_DEC); + TAG (AT_SYSINFO, _("Special system info/entry points"), AUXV_FORMAT_HEX); + TAG (AT_SYSINFO_EHDR, _("System-supplied DSO's ELF header"), + AUXV_FORMAT_HEX); + TAG (AT_L1I_CACHESHAPE, _("L1 Instruction cache information"), + AUXV_FORMAT_HEX); + TAG (AT_L1D_CACHESHAPE, _("L1 Data cache information"), AUXV_FORMAT_HEX); + TAG (AT_L2_CACHESHAPE, _("L2 cache information"), AUXV_FORMAT_HEX); + TAG (AT_L3_CACHESHAPE, _("L3 cache information"), AUXV_FORMAT_HEX); + TAG (AT_SUN_UID, _("Effective user ID"), AUXV_FORMAT_DEC); + TAG (AT_SUN_RUID, _("Real user ID"), AUXV_FORMAT_DEC); + TAG (AT_SUN_GID, _("Effective group ID"), AUXV_FORMAT_DEC); + TAG (AT_SUN_RGID, _("Real group ID"), AUXV_FORMAT_DEC); + TAG (AT_SUN_LDELF, _("Dynamic linker's ELF header"), AUXV_FORMAT_HEX); + TAG (AT_SUN_LDSHDR, _("Dynamic linker's section headers"), + AUXV_FORMAT_HEX); + TAG (AT_SUN_LDNAME, _("String giving name of dynamic linker"), + AUXV_FORMAT_STR); + TAG (AT_SUN_LPAGESZ, _("Large pagesize"), AUXV_FORMAT_DEC); + TAG (AT_SUN_PLATFORM, _("Platform name string"), AUXV_FORMAT_STR); + TAG (AT_SUN_CAP_HW1, _("Machine-dependent CPU capability hints"), + AUXV_FORMAT_HEX); + TAG (AT_SUN_IFLUSH, _("Should flush icache?"), AUXV_FORMAT_DEC); + TAG (AT_SUN_CPU, _("CPU name string"), AUXV_FORMAT_STR); + TAG (AT_SUN_EMUL_ENTRY, _("COFF entry point address"), AUXV_FORMAT_HEX); + TAG (AT_SUN_EMUL_EXECFD, _("COFF executable file descriptor"), + AUXV_FORMAT_DEC); + TAG (AT_SUN_EXECNAME, + _("Canonicalized file name given to execve"), AUXV_FORMAT_STR); + TAG (AT_SUN_MMU, _("String for name of MMU module"), AUXV_FORMAT_STR); + TAG (AT_SUN_LDDATA, _("Dynamic linker's data segment address"), + AUXV_FORMAT_HEX); + TAG (AT_SUN_AUXFLAGS, + _("AF_SUN_ flags passed from the kernel"), AUXV_FORMAT_HEX); + TAG (AT_SUN_EMULATOR, _("Name of emulation binary for runtime linker"), + AUXV_FORMAT_STR); + TAG (AT_SUN_BRANDNAME, _("Name of brand library"), AUXV_FORMAT_STR); + TAG (AT_SUN_BRAND_AUX1, _("Aux vector for brand modules 1"), + AUXV_FORMAT_HEX); + TAG (AT_SUN_BRAND_AUX2, _("Aux vector for brand modules 2"), + AUXV_FORMAT_HEX); + TAG (AT_SUN_BRAND_AUX3, _("Aux vector for brand modules 3"), + AUXV_FORMAT_HEX); + TAG (AT_SUN_CAP_HW2, _("Machine-dependent CPU capability hints 2"), + AUXV_FORMAT_HEX); + } + + fprint_auxv_entry (file, name, description, format, type, val); +} + +/* Print the contents of the target's AUXV on the specified file. */ + int fprint_target_auxv (struct ui_file *file, struct target_ops *ops) { + struct gdbarch *gdbarch = target_gdbarch (); CORE_ADDR type, val; - gdb_byte *data; - LONGEST len = target_read_alloc (ops, TARGET_OBJECT_AUXV, NULL, - &data); - gdb_byte *ptr = data; int ents = 0; + auxv_info *info = get_auxv_inferior_data (ops); - if (len <= 0) - return len; - - while (target_auxv_parse (ops, &ptr, data + len, &type, &val) > 0) - { - const char *name = "???"; - const char *description = ""; - enum { dec, hex, str } flavor = hex; + if (!info->data) + return -1; - switch (type) - { -#define TAG(tag, text, kind) \ - case tag: name = #tag; description = text; flavor = kind; break - TAG (AT_NULL, _("End of vector"), hex); - TAG (AT_IGNORE, _("Entry should be ignored"), hex); - TAG (AT_EXECFD, _("File descriptor of program"), dec); - TAG (AT_PHDR, _("Program headers for program"), hex); - TAG (AT_PHENT, _("Size of program header entry"), dec); - TAG (AT_PHNUM, _("Number of program headers"), dec); - TAG (AT_PAGESZ, _("System page size"), dec); - TAG (AT_BASE, _("Base address of interpreter"), hex); - TAG (AT_FLAGS, _("Flags"), hex); - TAG (AT_ENTRY, _("Entry point of program"), hex); - TAG (AT_NOTELF, _("Program is not ELF"), dec); - TAG (AT_UID, _("Real user ID"), dec); - TAG (AT_EUID, _("Effective user ID"), dec); - TAG (AT_GID, _("Real group ID"), dec); - TAG (AT_EGID, _("Effective group ID"), dec); - TAG (AT_CLKTCK, _("Frequency of times()"), dec); - TAG (AT_PLATFORM, _("String identifying platform"), str); - TAG (AT_HWCAP, _("Machine-dependent CPU capability hints"), hex); - TAG (AT_FPUCW, _("Used FPU control word"), dec); - TAG (AT_DCACHEBSIZE, _("Data cache block size"), dec); - TAG (AT_ICACHEBSIZE, _("Instruction cache block size"), dec); - TAG (AT_UCACHEBSIZE, _("Unified cache block size"), dec); - TAG (AT_IGNOREPPC, _("Entry should be ignored"), dec); - TAG (AT_BASE_PLATFORM, _("String identifying base platform"), str); - TAG (AT_RANDOM, _("Address of 16 random bytes"), hex); - TAG (AT_EXECFN, _("File name of executable"), str); - TAG (AT_SECURE, _("Boolean, was exec setuid-like?"), dec); - TAG (AT_SYSINFO, _("Special system info/entry points"), hex); - TAG (AT_SYSINFO_EHDR, _("System-supplied DSO's ELF header"), hex); - TAG (AT_SUN_UID, _("Effective user ID"), dec); - TAG (AT_SUN_RUID, _("Real user ID"), dec); - TAG (AT_SUN_GID, _("Effective group ID"), dec); - TAG (AT_SUN_RGID, _("Real group ID"), dec); - TAG (AT_SUN_LDELF, _("Dynamic linker's ELF header"), hex); - TAG (AT_SUN_LDSHDR, _("Dynamic linker's section headers"), hex); - TAG (AT_SUN_LDNAME, _("String giving name of dynamic linker"), str); - TAG (AT_SUN_LPAGESZ, _("Large pagesize"), dec); - TAG (AT_SUN_PLATFORM, _("Platform name string"), str); - TAG (AT_SUN_HWCAP, _("Machine-dependent CPU capability hints"), hex); - TAG (AT_SUN_IFLUSH, _("Should flush icache?"), dec); - TAG (AT_SUN_CPU, _("CPU name string"), str); - TAG (AT_SUN_EMUL_ENTRY, _("COFF entry point address"), hex); - TAG (AT_SUN_EMUL_EXECFD, _("COFF executable file descriptor"), dec); - TAG (AT_SUN_EXECNAME, - _("Canonicalized file name given to execve"), str); - TAG (AT_SUN_MMU, _("String for name of MMU module"), str); - TAG (AT_SUN_LDDATA, _("Dynamic linker's data segment address"), hex); - TAG (AT_SUN_AUXFLAGS, - _("AF_SUN_ flags passed from the kernel"), hex); - } + gdb_byte *data = info->data->data (); + gdb_byte *ptr = data; + size_t len = info->data->size (); - fprintf_filtered (file, "%-4s %-20s %-30s ", - plongest (type), name, description); - switch (flavor) - { - case dec: - fprintf_filtered (file, "%s\n", plongest (val)); - break; - case hex: - fprintf_filtered (file, "%s\n", paddress (target_gdbarch, val)); - break; - case str: - { - struct value_print_options opts; - - get_user_print_options (&opts); - if (opts.addressprint) - fprintf_filtered (file, "%s", paddress (target_gdbarch, val)); - val_print_string (builtin_type (target_gdbarch)->builtin_char, - val, -1, file, &opts); - fprintf_filtered (file, "\n"); - } - break; - } + while (target_auxv_parse (&ptr, data + len, &type, &val) > 0) + { + gdbarch_print_auxv_entry (gdbarch, file, type, val); ++ents; if (type == AT_NULL) break; } - xfree (data); - return ents; } static void -info_auxv_command (char *cmd, int from_tty) +info_auxv_command (const char *cmd, int from_tty) { if (! target_has_stack) error (_("The program has no auxiliary information now.")); else { - int ents = fprint_target_auxv (gdb_stdout, ¤t_target); + int ents = fprint_target_auxv (gdb_stdout, current_top_target ()); if (ents < 0) error (_("No auxiliary vector found, or failed reading it.")); @@ -432,13 +546,15 @@ info_auxv_command (char *cmd, int from_tty) } } - -extern initialize_file_ftype _initialize_auxv; /* -Wmissing-prototypes; */ - void _initialize_auxv (void) { add_info ("auxv", info_auxv_command, _("Display the inferior's auxiliary vector.\n\ This is information provided by the operating system at program startup.")); + + /* Observers used to invalidate the auxv cache when needed. */ + gdb::observers::inferior_exit.attach (invalidate_auxv_cache_inf); + gdb::observers::inferior_appeared.attach (invalidate_auxv_cache_inf); + gdb::observers::executable_changed.attach (invalidate_auxv_cache); }