[deliverable/binutils-gdb.git] / gdb / auxv.c

/* Auxiliary vector support for GDB, the GNU debugger.

   Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010
   Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"
#include "target.h"
#include "gdbtypes.h"
#include "command.h"
#include "inferior.h"
#include "valprint.h"
#include "gdb_assert.h"
#include "gdbcore.h"

#include "auxv.h"
#include "elf/common.h"

#include <unistd.h>
#include <fcntl.h>


/* This function handles access via /proc/PID/auxv, which is a common method
   for native targets.  */

static LONGEST
procfs_xfer_auxv (gdb_byte *readbuf,
		  const gdb_byte *writebuf,
		  ULONGEST offset,
		  LONGEST len)
{
  char *pathname;
  int fd;
  LONGEST n;

  pathname = xstrprintf ("/proc/%d/auxv", PIDGET (inferior_ptid));
  fd = open (pathname, writebuf != NULL ? O_WRONLY : O_RDONLY);
  xfree (pathname);
  if (fd < 0)
    return -1;

  if (offset != (ULONGEST) 0
      && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
    n = -1;
  else if (readbuf != NULL)
    n = read (fd, readbuf, len);
  else
    n = write (fd, writebuf, len);

  (void) close (fd);

  return n;
}

/* This function handles access via ld.so's symbol `_dl_auxv'.  */

static LONGEST
ld_so_xfer_auxv (gdb_byte *readbuf,
		 const gdb_byte *writebuf,
		 ULONGEST offset,
		 LONGEST len)
{
  struct minimal_symbol *msym;
  CORE_ADDR data_address, pointer_address;
  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);
  LONGEST retval;
  size_t block;

  msym = lookup_minimal_symbol ("_dl_auxv", NULL, NULL);
  if (msym == NULL)
    return -1;

  if (MSYMBOL_SIZE (msym) != ptr_size)
    return -1;

  /* 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);

  /* 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.  */

  if (target_read_memory (pointer_address, ptr_buf, ptr_size) != 0)
    return -1;

  data_address = extract_typed_address (ptr_buf, ptr_type);

  /* Possibly still not initialized such as during an inferior startup.  */
  if (data_address == 0)
    return -1;

  data_address += offset;

  if (writebuf != NULL)
    {
      if (target_write_memory (data_address, writebuf, len) == 0)
	return len;
      else
	return -1;
    }

  /* 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;

      if (extract_typed_address (ptr_buf, ptr_type) == AT_NULL)
	return 0;
    }

  retval = 0;
  block = 0x400;
  gdb_assert (block % auxv_pair_size == 0);

  while (len > 0)
    {
      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).  */

      block &= -auxv_pair_size;
      if (block == 0)
	return retval;

      if (target_read_memory (data_address, readbuf, block) != 0)
	{
	  if (block <= auxv_pair_size)
	    return retval;

	  block = auxv_pair_size;
	  continue;
	}

      data_address += block;
      len -= block;

      /* 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;

	  readbuf += auxv_pair_size;
	  block -= auxv_pair_size;
	}
    }

  return retval;
}

/* This function is called like a to_xfer_partial hook, but must be
   called with TARGET_OBJECT_AUXV.  It handles access to AUXV.  */

LONGEST
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)
{
  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.
      */

  if (current_inferior ()->attach_flag != 0)
    {
      LONGEST retval;

      retval = ld_so_xfer_auxv (readbuf, writebuf, offset, len);
      if (retval != -1)
	return retval;
    }

  return procfs_xfer_auxv (readbuf, writebuf, offset, 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
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)
				/ TARGET_CHAR_BIT;
  const enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
  gdb_byte *ptr = *readptr;

  if (endptr == ptr)
    return 0;

  if (endptr - ptr < sizeof_auxv_field * 2)
    return -1;

  *typep = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
  ptr += sizeof_auxv_field;
  *valp = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
  ptr += sizeof_auxv_field;

  *readptr = ptr;
  return 1;
}

/* 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.  */
int
target_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
                  gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
{
  struct target_ops *t;

  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);
}

/* Extract the auxiliary vector entry with a_type matching MATCH.
   Return zero if no such entry was found, or -1 if there was
   an error getting the information.  On success, return 1 after
   storing the entry's value field in *VALP.  */
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;

  if (n <= 0)
    return n;

  while (1)
    switch (target_auxv_parse (ops, &ptr, data + n, &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;
      }

  /*NOTREACHED*/
}


/* Print the contents of the target's AUXV on the specified file. */
int
fprint_target_auxv (struct ui_file *file, struct target_ops *ops)
{
  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;

  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;

      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);
	}

      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;
	}
      ++ents;
      if (type == AT_NULL)
	break;
    }

  xfree (data);

  return ents;
}

static void
info_auxv_command (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, &current_target);

      if (ents < 0)
	error (_("No auxiliary vector found, or failed reading it."));
      else if (ents == 0)
	error (_("Auxiliary vector is empty."));
    }
}


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."));
}
Commit	Line	Data
14ed0a8b RM	1	/* Auxiliary vector support for GDB, the GNU debugger.
14ed0a8b RM	2
4c38e0a4	3	Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010
0fb0cc75	4	Free Software Foundation, Inc.
14ed0a8b RM	5
	6	This file is part of GDB.
	7
	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
a9762ec7	10	the Free Software Foundation; either version 3 of the License, or
14ed0a8b RM	11	(at your option) any later version.
	12
	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.
	17
	18	You should have received a copy of the GNU General Public License
a9762ec7	19	along with this program. If not, see <http://www.gnu.org/licenses/>. */
14ed0a8b RM	20
	21	#include "defs.h"
	22	#include "target.h"
	23	#include "gdbtypes.h"
	24	#include "command.h"
	25	#include "inferior.h"
	26	#include "valprint.h"
	27	#include "gdb_assert.h"
9f2982ff	28	#include "gdbcore.h"
14ed0a8b RM	29
	30	#include "auxv.h"
	31	#include "elf/common.h"
	32
	33	#include <unistd.h>
	34	#include <fcntl.h>
	35
	36
9f2982ff JK	37	/* This function handles access via /proc/PID/auxv, which is a common method
9f2982ff JK	38	for native targets. */
14ed0a8b	39
9f2982ff JK	40	static LONGEST
9f2982ff JK	41	procfs_xfer_auxv (gdb_byte *readbuf,
36aa5e41	42	const gdb_byte *writebuf,
14ed0a8b RM	43	ULONGEST offset,
	44	LONGEST len)
	45	{
	46	char *pathname;
	47	int fd;
	48	LONGEST n;
	49
14ed0a8b RM	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;
	55
	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);
	63
	64	(void) close (fd);
	65
	66	return n;
	67	}
	68
9f2982ff JK	69	/* This function handles access via ld.so's symbol `_dl_auxv'. */
	70
	71	static LONGEST
	72	ld_so_xfer_auxv (gdb_byte *readbuf,
	73	const gdb_byte *writebuf,
	74	ULONGEST offset,
	75	LONGEST len)
	76	{
	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;
	85
	86	msym = lookup_minimal_symbol ("_dl_auxv", NULL, NULL);
	87	if (msym == NULL)
	88	return -1;
	89
	90	if (MSYMBOL_SIZE (msym) != ptr_size)
	91	return -1;
	92
	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. */
	96
	97	pointer_address = SYMBOL_VALUE_ADDRESS (msym);
	98
3cd07d20 JK	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.
	106
	107	If the memory read fails, return -1 to fallback on another mechanism for
	108	retrieving the AUXV.
	109
	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. */
	115
	116	if (target_read_memory (pointer_address, ptr_buf, ptr_size) != 0)
	117	return -1;
	118
	119	data_address = extract_typed_address (ptr_buf, ptr_type);
9f2982ff JK	120
	121	/* Possibly still not initialized such as during an inferior startup. */
	122	if (data_address == 0)
	123	return -1;
	124
	125	data_address += offset;
	126
	127	if (writebuf != NULL)
	128	{
	129	if (target_write_memory (data_address, writebuf, len) == 0)
	130	return len;
	131	else
	132	return -1;
	133	}
	134
	135	/* Stop if trying to read past the existing AUXV block. The final AT_NULL
	136	was already returned before. */
	137
	138	if (offset >= auxv_pair_size)
	139	{
	140	if (target_read_memory (data_address - auxv_pair_size, ptr_buf,
	141	ptr_size) != 0)
	142	return -1;
	143
	144	if (extract_typed_address (ptr_buf, ptr_type) == AT_NULL)
	145	return 0;
	146	}
	147
	148	retval = 0;
	149	block = 0x400;
	150	gdb_assert (block % auxv_pair_size == 0);
	151
	152	while (len > 0)
	153	{
	154	if (block > len)
	155	block = len;
	156
	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). */
	160
	161	block &= -auxv_pair_size;
	162	if (block == 0)
	163	return retval;
	164
	165	if (target_read_memory (data_address, readbuf, block) != 0)
	166	{
	167	if (block <= auxv_pair_size)
	168	return retval;
	169
	170	block = auxv_pair_size;
	171	continue;
	172	}
	173
	174	data_address += block;
	175	len -= block;
	176
	177	/* Check terminal AT_NULL. This function is being called indefinitely
	178	being extended its READBUF until it returns EOF (0). */
	179
	180	while (block >= auxv_pair_size)
	181	{
	182	retval += auxv_pair_size;
	183
184	if (extract_typed_address (readbuf, ptr_type) == AT_NULL)
185	return retval;
186
187	readbuf += auxv_pair_size;
188	block -= auxv_pair_size;
189	}
190	}
191
192	return retval;
193	}
194
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. */
197
198	LONGEST
199	memory_xfer_auxv (struct target_ops *ops,
200	enum target_object object,
201	const char *annex,
202	gdb_byte *readbuf,
203	const gdb_byte *writebuf,
204	ULONGEST offset,
205	LONGEST len)
206	{
207	gdb_assert (object == TARGET_OBJECT_AUXV);
208	gdb_assert (readbuf \|\| writebuf);
209
210	/* ld_so_xfer_auxv is the only function safe for virtual executables being
86e4bafc JK	211	executed by valgrind's memcheck. Using ld_so_xfer_auxv during inferior
	212	startup is problematic, because ld.so symbol tables have not yet been
	213	relocated. So GDB uses this function only when attaching to a process.
	214	*/
9f2982ff JK	215
	216	if (current_inferior ()->attach_flag != 0)
	217	{
	218	LONGEST retval;
	219
	220	retval = ld_so_xfer_auxv (readbuf, writebuf, offset, len);
	221	if (retval != -1)
	222	return retval;
	223	}
	224
	225	return procfs_xfer_auxv (readbuf, writebuf, offset, len);
	226	}
	227
14ed0a8b RM	228	/* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
	229	Return 0 if *READPTR is already at the end of the buffer.
	230	Return -1 if there is insufficient buffer for a whole entry.
	231	Return 1 if an entry was read into TYPEP and VALP. */
2c0b251b	232	static int
c47ffbe3	233	default_auxv_parse (struct target_ops ops, gdb_byte *readptr,
36aa5e41	234	gdb_byte endptr, CORE_ADDR typep, CORE_ADDR *valp)
14ed0a8b	235	{
ffe5a37e UW	236	const int sizeof_auxv_field = gdbarch_ptr_bit (target_gdbarch)
ffe5a37e UW	237	/ TARGET_CHAR_BIT;
e17a4113	238	const enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
36aa5e41	239	gdb_byte ptr = readptr;
14ed0a8b RM	240
	241	if (endptr == ptr)
	242	return 0;
	243
	244	if (endptr - ptr < sizeof_auxv_field * 2)
	245	return -1;
	246
e17a4113	247	*typep = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
14ed0a8b	248	ptr += sizeof_auxv_field;
e17a4113	249	*valp = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
14ed0a8b RM	250	ptr += sizeof_auxv_field;
	251
	252	*readptr = ptr;
	253	return 1;
	254	}
	255
c47ffbe3 VP	256	/* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
	257	Return 0 if *READPTR is already at the end of the buffer.
	258	Return -1 if there is insufficient buffer for a whole entry.
	259	Return 1 if an entry was read into TYPEP and VALP. */
	260	int
	261	target_auxv_parse (struct target_ops ops, gdb_byte *readptr,
	262	gdb_byte endptr, CORE_ADDR typep, CORE_ADDR *valp)
	263	{
	264	struct target_ops *t;
5b4ee69b	265
c47ffbe3 VP	266	for (t = ops; t != NULL; t = t->beneath)
	267	if (t->to_auxv_parse != NULL)
	268	return t->to_auxv_parse (t, readptr, endptr, typep, valp);
	269
	270	return default_auxv_parse (ops, readptr, endptr, typep, valp);
	271	}
	272
14ed0a8b RM	273	/* Extract the auxiliary vector entry with a_type matching MATCH.
	274	Return zero if no such entry was found, or -1 if there was
	275	an error getting the information. On success, return 1 after
	276	storing the entry's value field in VALP. /
	277	int
	278	target_auxv_search (struct target_ops ops, CORE_ADDR match, CORE_ADDR valp)
	279	{
	280	CORE_ADDR type, val;
36aa5e41	281	gdb_byte *data;
13547ab6	282	LONGEST n = target_read_alloc (ops, TARGET_OBJECT_AUXV, NULL, &data);
36aa5e41	283	gdb_byte *ptr = data;
14ed0a8b RM	284
	285	if (n <= 0)
	286	return n;
	287
	288	while (1)
	289	switch (target_auxv_parse (ops, &ptr, data + n, &type, &val))
	290	{
	291	case 1: /* Here's an entry, check it. */
	292	if (type == match)
	293	{
	294	xfree (data);
	295	*valp = val;
	296	return 1;
	297	}
	298	break;
	299	case 0: /* End of the vector. */
	300	xfree (data);
	301	return 0;
	302	default: /* Bogosity. */
	303	xfree (data);
	304	return -1;
	305	}
	306
	307	/NOTREACHED/
	308	}
	309
	310
	311	/* Print the contents of the target's AUXV on the specified file. */
	312	int
	313	fprint_target_auxv (struct ui_file file, struct target_ops ops)
	314	{
	315	CORE_ADDR type, val;
36aa5e41	316	gdb_byte *data;
13547ab6 DJ	317	LONGEST len = target_read_alloc (ops, TARGET_OBJECT_AUXV, NULL,
13547ab6 DJ	318	&data);
36aa5e41	319	gdb_byte *ptr = data;
14ed0a8b RM	320	int ents = 0;
	321
	322	if (len <= 0)
	323	return len;
	324
	325	while (target_auxv_parse (ops, &ptr, data + len, &type, &val) > 0)
	326	{
14ed0a8b RM	327	const char *name = "???";
	328	const char *description = "";
	329	enum { dec, hex, str } flavor = hex;
	330
	331	switch (type)
	332	{
	333	#define TAG(tag, text, kind) \
	334	case tag: name = #tag; description = text; flavor = kind; break
edefbb7c AC	335	TAG (AT_NULL, _("End of vector"), hex);
	336	TAG (AT_IGNORE, _("Entry should be ignored"), hex);
	337	TAG (AT_EXECFD, _("File descriptor of program"), dec);
	338	TAG (AT_PHDR, _("Program headers for program"), hex);
	339	TAG (AT_PHENT, _("Size of program header entry"), dec);
	340	TAG (AT_PHNUM, _("Number of program headers"), dec);
	341	TAG (AT_PAGESZ, _("System page size"), dec);
	342	TAG (AT_BASE, _("Base address of interpreter"), hex);
	343	TAG (AT_FLAGS, _("Flags"), hex);
	344	TAG (AT_ENTRY, _("Entry point of program"), hex);
	345	TAG (AT_NOTELF, _("Program is not ELF"), dec);
	346	TAG (AT_UID, _("Real user ID"), dec);
	347	TAG (AT_EUID, _("Effective user ID"), dec);
	348	TAG (AT_GID, _("Real group ID"), dec);
	349	TAG (AT_EGID, _("Effective group ID"), dec);
	350	TAG (AT_CLKTCK, _("Frequency of times()"), dec);
	351	TAG (AT_PLATFORM, _("String identifying platform"), str);
	352	TAG (AT_HWCAP, _("Machine-dependent CPU capability hints"), hex);
	353	TAG (AT_FPUCW, _("Used FPU control word"), dec);
	354	TAG (AT_DCACHEBSIZE, _("Data cache block size"), dec);
	355	TAG (AT_ICACHEBSIZE, _("Instruction cache block size"), dec);
	356	TAG (AT_UCACHEBSIZE, _("Unified cache block size"), dec);
	357	TAG (AT_IGNOREPPC, _("Entry should be ignored"), dec);
759cc328	358	TAG (AT_BASE_PLATFORM, _("String identifying base platform"), str);
ba30a4e9	359	TAG (AT_RANDOM, _("Address of 16 random bytes"), hex);
759cc328 UW	360	TAG (AT_EXECFN, _("File name of executable"), str);
759cc328 UW	361	TAG (AT_SECURE, _("Boolean, was exec setuid-like?"), dec);
edefbb7c AC	362	TAG (AT_SYSINFO, _("Special system info/entry points"), hex);
edefbb7c AC	363	TAG (AT_SYSINFO_EHDR, _("System-supplied DSO's ELF header"), hex);
edefbb7c AC	364	TAG (AT_SUN_UID, _("Effective user ID"), dec);
	365	TAG (AT_SUN_RUID, _("Real user ID"), dec);
	366	TAG (AT_SUN_GID, _("Effective group ID"), dec);
	367	TAG (AT_SUN_RGID, _("Real group ID"), dec);
	368	TAG (AT_SUN_LDELF, _("Dynamic linker's ELF header"), hex);
	369	TAG (AT_SUN_LDSHDR, _("Dynamic linker's section headers"), hex);
	370	TAG (AT_SUN_LDNAME, _("String giving name of dynamic linker"), str);
	371	TAG (AT_SUN_LPAGESZ, _("Large pagesize"), dec);
	372	TAG (AT_SUN_PLATFORM, _("Platform name string"), str);
	373	TAG (AT_SUN_HWCAP, _("Machine-dependent CPU capability hints"), hex);
	374	TAG (AT_SUN_IFLUSH, _("Should flush icache?"), dec);
	375	TAG (AT_SUN_CPU, _("CPU name string"), str);
	376	TAG (AT_SUN_EMUL_ENTRY, _("COFF entry point address"), hex);
	377	TAG (AT_SUN_EMUL_EXECFD, _("COFF executable file descriptor"), dec);
14ed0a8b	378	TAG (AT_SUN_EXECNAME,
edefbb7c AC	379	_("Canonicalized file name given to execve"), str);
	380	TAG (AT_SUN_MMU, _("String for name of MMU module"), str);
	381	TAG (AT_SUN_LDDATA, _("Dynamic linker's data segment address"), hex);
77d49ac6 MK	382	TAG (AT_SUN_AUXFLAGS,
77d49ac6 MK	383	_("AF_SUN_ flags passed from the kernel"), hex);
14ed0a8b RM	384	}
	385
	386	fprintf_filtered (file, "%-4s %-20s %-30s ",
623d3eb1	387	plongest (type), name, description);
14ed0a8b RM	388	switch (flavor)
	389	{
	390	case dec:
623d3eb1	391	fprintf_filtered (file, "%s\n", plongest (val));
14ed0a8b RM	392	break;
14ed0a8b RM	393	case hex:
5af949e3	394	fprintf_filtered (file, "%s\n", paddress (target_gdbarch, val));
14ed0a8b RM	395	break;
14ed0a8b RM	396	case str:
79a45b7d TT	397	{
79a45b7d TT	398	struct value_print_options opts;
5b4ee69b	399
79a45b7d TT	400	get_user_print_options (&opts);
79a45b7d TT	401	if (opts.addressprint)
5af949e3	402	fprintf_filtered (file, "%s", paddress (target_gdbarch, val));
6c7a06a3 TT	403	val_print_string (builtin_type (target_gdbarch)->builtin_char,
6c7a06a3 TT	404	val, -1, file, &opts);
79a45b7d TT	405	fprintf_filtered (file, "\n");
79a45b7d TT	406	}
14ed0a8b RM	407	break;
	408	}
	409	++ents;
7c6467a4 PP	410	if (type == AT_NULL)
7c6467a4 PP	411	break;
14ed0a8b RM	412	}
	413
	414	xfree (data);
	415
	416	return ents;
	417	}
	418
	419	static void
	420	info_auxv_command (char *cmd, int from_tty)
	421	{
14ed0a8b	422	if (! target_has_stack)
edefbb7c	423	error (_("The program has no auxiliary information now."));
14ed0a8b RM	424	else
	425	{
	426	int ents = fprint_target_auxv (gdb_stdout, &current_target);
5b4ee69b	427
14ed0a8b	428	if (ents < 0)
edefbb7c	429	error (_("No auxiliary vector found, or failed reading it."));
14ed0a8b	430	else if (ents == 0)
edefbb7c	431	error (_("Auxiliary vector is empty."));
14ed0a8b RM	432	}
	433	}
	434
	435
	436	extern initialize_file_ftype _initialize_auxv; /* -Wmissing-prototypes; */
	437
	438	void
	439	_initialize_auxv (void)
	440	{
	441	add_info ("auxv", info_auxv_command,
edefbb7c AC	442	_("Display the inferior's auxiliary vector.\n\
edefbb7c AC	443	This is information provided by the operating system at program startup."));
14ed0a8b	444	}