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

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

   Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   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,
			      NULL, 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
7b6bb8da	3	Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
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
0e2de366 MS	37	/* This function handles access via /proc/PID/auxv, which is a common
0e2de366 MS	38	method 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
0e2de366 MS	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. */
9f2982ff JK	96
	97	pointer_address = SYMBOL_VALUE_ADDRESS (msym);
	98
3cd07d20	99	/* The location of the _dl_auxv symbol may no longer be correct if
0e2de366 MS	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.
	108
	109	If the memory read fails, return -1 to fallback on another
	110	mechanism for retrieving the AUXV.
	111
	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. */
3cd07d20 JK	118
	119	if (target_read_memory (pointer_address, ptr_buf, ptr_size) != 0)
	120	return -1;
	121
	122	data_address = extract_typed_address (ptr_buf, ptr_type);
9f2982ff	123
0e2de366 MS	124	/* Possibly still not initialized such as during an inferior
0e2de366 MS	125	startup. */
9f2982ff JK	126	if (data_address == 0)
	127	return -1;
	128
	129	data_address += offset;
	130
	131	if (writebuf != NULL)
	132	{
	133	if (target_write_memory (data_address, writebuf, len) == 0)
	134	return len;
	135	else
	136	return -1;
	137	}
	138
0e2de366 MS	139	/* Stop if trying to read past the existing AUXV block. The final
0e2de366 MS	140	AT_NULL was already returned before. */
9f2982ff JK	141
	142	if (offset >= auxv_pair_size)
	143	{
	144	if (target_read_memory (data_address - auxv_pair_size, ptr_buf,
	145	ptr_size) != 0)
	146	return -1;
	147
	148	if (extract_typed_address (ptr_buf, ptr_type) == AT_NULL)
	149	return 0;
	150	}
	151
	152	retval = 0;
	153	block = 0x400;
	154	gdb_assert (block % auxv_pair_size == 0);
	155
	156	while (len > 0)
	157	{
	158	if (block > len)
	159	block = len;
	160
0e2de366 MS	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). */
9f2982ff JK	165
	166	block &= -auxv_pair_size;
	167	if (block == 0)
	168	return retval;
	169
	170	if (target_read_memory (data_address, readbuf, block) != 0)
	171	{
	172	if (block <= auxv_pair_size)
	173	return retval;
	174
	175	block = auxv_pair_size;
	176	continue;
	177	}
	178
	179	data_address += block;
	180	len -= block;
	181
0e2de366 MS	182	/* Check terminal AT_NULL. This function is being called
	183	indefinitely being extended its READBUF until it returns EOF
	184	(0). */
9f2982ff JK	185
	186	while (block >= auxv_pair_size)
	187	{
	188	retval += auxv_pair_size;
	189
	190	if (extract_typed_address (readbuf, ptr_type) == AT_NULL)
	191	return retval;
	192
	193	readbuf += auxv_pair_size;
	194	block -= auxv_pair_size;
	195	}
	196	}
	197
	198	return retval;
	199	}
	200
	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. */
	203
	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)
	212	{
	213	gdb_assert (object == TARGET_OBJECT_AUXV);
	214	gdb_assert (readbuf \|\| writebuf);
	215
0e2de366 MS	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.
86e4bafc	221	*/
9f2982ff JK	222
	223	if (current_inferior ()->attach_flag != 0)
	224	{
	225	LONGEST retval;
	226
	227	retval = ld_so_xfer_auxv (readbuf, writebuf, offset, len);
	228	if (retval != -1)
	229	return retval;
	230	}
	231
	232	return procfs_xfer_auxv (readbuf, writebuf, offset, len);
	233	}
	234
14ed0a8b RM	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. */
2c0b251b	239	static int
c47ffbe3	240	default_auxv_parse (struct target_ops ops, gdb_byte *readptr,
36aa5e41	241	gdb_byte endptr, CORE_ADDR typep, CORE_ADDR *valp)
14ed0a8b	242	{
ffe5a37e UW	243	const int sizeof_auxv_field = gdbarch_ptr_bit (target_gdbarch)
ffe5a37e UW	244	/ TARGET_CHAR_BIT;
e17a4113	245	const enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
36aa5e41	246	gdb_byte ptr = readptr;
14ed0a8b RM	247
	248	if (endptr == ptr)
	249	return 0;
	250
	251	if (endptr - ptr < sizeof_auxv_field * 2)
	252	return -1;
	253
e17a4113	254	*typep = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
14ed0a8b	255	ptr += sizeof_auxv_field;
e17a4113	256	*valp = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
14ed0a8b RM	257	ptr += sizeof_auxv_field;
	258
	259	*readptr = ptr;
	260	return 1;
	261	}
	262
c47ffbe3 VP	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. */
	267	int
	268	target_auxv_parse (struct target_ops ops, gdb_byte *readptr,
	269	gdb_byte endptr, CORE_ADDR typep, CORE_ADDR *valp)
	270	{
	271	struct target_ops *t;
5b4ee69b	272
c47ffbe3 VP	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);
	276
	277	return default_auxv_parse (ops, readptr, endptr, typep, valp);
	278	}
	279
14ed0a8b RM	280	/* Extract the auxiliary vector entry with a_type matching MATCH.
	281	Return zero if no such entry was found, or -1 if there was
	282	an error getting the information. On success, return 1 after
	283	storing the entry's value field in VALP. /
	284	int
	285	target_auxv_search (struct target_ops ops, CORE_ADDR match, CORE_ADDR valp)
	286	{
	287	CORE_ADDR type, val;
36aa5e41	288	gdb_byte *data;
13547ab6	289	LONGEST n = target_read_alloc (ops, TARGET_OBJECT_AUXV, NULL, &data);
36aa5e41	290	gdb_byte *ptr = data;
14ed0a8b RM	291
	292	if (n <= 0)
	293	return n;
	294
	295	while (1)
	296	switch (target_auxv_parse (ops, &ptr, data + n, &type, &val))
	297	{
	298	case 1: /* Here's an entry, check it. */
	299	if (type == match)
	300	{
	301	xfree (data);
	302	*valp = val;
	303	return 1;
	304	}
	305	break;
	306	case 0: /* End of the vector. */
	307	xfree (data);
	308	return 0;
	309	default: /* Bogosity. */
	310	xfree (data);
	311	return -1;
	312	}
	313
	314	/NOTREACHED/
	315	}
	316
	317
0e2de366	318	/* Print the contents of the target's AUXV on the specified file. */
14ed0a8b RM	319	int
	320	fprint_target_auxv (struct ui_file file, struct target_ops ops)
	321	{
	322	CORE_ADDR type, val;
36aa5e41	323	gdb_byte *data;
13547ab6 DJ	324	LONGEST len = target_read_alloc (ops, TARGET_OBJECT_AUXV, NULL,
13547ab6 DJ	325	&data);
36aa5e41	326	gdb_byte *ptr = data;
14ed0a8b RM	327	int ents = 0;
	328
	329	if (len <= 0)
	330	return len;
	331
	332	while (target_auxv_parse (ops, &ptr, data + len, &type, &val) > 0)
	333	{
14ed0a8b RM	334	const char *name = "???";
	335	const char *description = "";
	336	enum { dec, hex, str } flavor = hex;
	337
	338	switch (type)
	339	{
	340	#define TAG(tag, text, kind) \
	341	case tag: name = #tag; description = text; flavor = kind; break
edefbb7c AC	342	TAG (AT_NULL, _("End of vector"), hex);
	343	TAG (AT_IGNORE, _("Entry should be ignored"), hex);
	344	TAG (AT_EXECFD, _("File descriptor of program"), dec);
	345	TAG (AT_PHDR, _("Program headers for program"), hex);
	346	TAG (AT_PHENT, _("Size of program header entry"), dec);
	347	TAG (AT_PHNUM, _("Number of program headers"), dec);
	348	TAG (AT_PAGESZ, _("System page size"), dec);
	349	TAG (AT_BASE, _("Base address of interpreter"), hex);
	350	TAG (AT_FLAGS, _("Flags"), hex);
	351	TAG (AT_ENTRY, _("Entry point of program"), hex);
	352	TAG (AT_NOTELF, _("Program is not ELF"), dec);
	353	TAG (AT_UID, _("Real user ID"), dec);
	354	TAG (AT_EUID, _("Effective user ID"), dec);
	355	TAG (AT_GID, _("Real group ID"), dec);
	356	TAG (AT_EGID, _("Effective group ID"), dec);
	357	TAG (AT_CLKTCK, _("Frequency of times()"), dec);
	358	TAG (AT_PLATFORM, _("String identifying platform"), str);
	359	TAG (AT_HWCAP, _("Machine-dependent CPU capability hints"), hex);
	360	TAG (AT_FPUCW, _("Used FPU control word"), dec);
	361	TAG (AT_DCACHEBSIZE, _("Data cache block size"), dec);
	362	TAG (AT_ICACHEBSIZE, _("Instruction cache block size"), dec);
	363	TAG (AT_UCACHEBSIZE, _("Unified cache block size"), dec);
	364	TAG (AT_IGNOREPPC, _("Entry should be ignored"), dec);
759cc328	365	TAG (AT_BASE_PLATFORM, _("String identifying base platform"), str);
ba30a4e9	366	TAG (AT_RANDOM, _("Address of 16 random bytes"), hex);
759cc328 UW	367	TAG (AT_EXECFN, _("File name of executable"), str);
759cc328 UW	368	TAG (AT_SECURE, _("Boolean, was exec setuid-like?"), dec);
edefbb7c AC	369	TAG (AT_SYSINFO, _("Special system info/entry points"), hex);
edefbb7c AC	370	TAG (AT_SYSINFO_EHDR, _("System-supplied DSO's ELF header"), hex);
edefbb7c AC	371	TAG (AT_SUN_UID, _("Effective user ID"), dec);
	372	TAG (AT_SUN_RUID, _("Real user ID"), dec);
	373	TAG (AT_SUN_GID, _("Effective group ID"), dec);
	374	TAG (AT_SUN_RGID, _("Real group ID"), dec);
	375	TAG (AT_SUN_LDELF, _("Dynamic linker's ELF header"), hex);
	376	TAG (AT_SUN_LDSHDR, _("Dynamic linker's section headers"), hex);
	377	TAG (AT_SUN_LDNAME, _("String giving name of dynamic linker"), str);
	378	TAG (AT_SUN_LPAGESZ, _("Large pagesize"), dec);
	379	TAG (AT_SUN_PLATFORM, _("Platform name string"), str);
	380	TAG (AT_SUN_HWCAP, _("Machine-dependent CPU capability hints"), hex);
	381	TAG (AT_SUN_IFLUSH, _("Should flush icache?"), dec);
	382	TAG (AT_SUN_CPU, _("CPU name string"), str);
	383	TAG (AT_SUN_EMUL_ENTRY, _("COFF entry point address"), hex);
	384	TAG (AT_SUN_EMUL_EXECFD, _("COFF executable file descriptor"), dec);
14ed0a8b	385	TAG (AT_SUN_EXECNAME,
edefbb7c AC	386	_("Canonicalized file name given to execve"), str);
	387	TAG (AT_SUN_MMU, _("String for name of MMU module"), str);
	388	TAG (AT_SUN_LDDATA, _("Dynamic linker's data segment address"), hex);
77d49ac6 MK	389	TAG (AT_SUN_AUXFLAGS,
77d49ac6 MK	390	_("AF_SUN_ flags passed from the kernel"), hex);
14ed0a8b RM	391	}
	392
	393	fprintf_filtered (file, "%-4s %-20s %-30s ",
623d3eb1	394	plongest (type), name, description);
14ed0a8b RM	395	switch (flavor)
	396	{
	397	case dec:
623d3eb1	398	fprintf_filtered (file, "%s\n", plongest (val));
14ed0a8b RM	399	break;
14ed0a8b RM	400	case hex:
5af949e3	401	fprintf_filtered (file, "%s\n", paddress (target_gdbarch, val));
14ed0a8b RM	402	break;
14ed0a8b RM	403	case str:
79a45b7d TT	404	{
79a45b7d TT	405	struct value_print_options opts;
5b4ee69b	406
79a45b7d TT	407	get_user_print_options (&opts);
79a45b7d TT	408	if (opts.addressprint)
5af949e3	409	fprintf_filtered (file, "%s", paddress (target_gdbarch, val));
6c7a06a3	410	val_print_string (builtin_type (target_gdbarch)->builtin_char,
09ca9e2e	411	NULL, val, -1, file, &opts);
79a45b7d TT	412	fprintf_filtered (file, "\n");
79a45b7d TT	413	}
14ed0a8b RM	414	break;
	415	}
	416	++ents;
7c6467a4 PP	417	if (type == AT_NULL)
7c6467a4 PP	418	break;
14ed0a8b RM	419	}
	420
	421	xfree (data);
	422
	423	return ents;
	424	}
	425
	426	static void
	427	info_auxv_command (char *cmd, int from_tty)
	428	{
14ed0a8b	429	if (! target_has_stack)
edefbb7c	430	error (_("The program has no auxiliary information now."));
14ed0a8b RM	431	else
	432	{
	433	int ents = fprint_target_auxv (gdb_stdout, &current_target);
5b4ee69b	434
14ed0a8b	435	if (ents < 0)
edefbb7c	436	error (_("No auxiliary vector found, or failed reading it."));
14ed0a8b	437	else if (ents == 0)
edefbb7c	438	error (_("Auxiliary vector is empty."));
14ed0a8b RM	439	}
	440	}
	441
	442
	443	extern initialize_file_ftype _initialize_auxv; /* -Wmissing-prototypes; */
	444
	445	void
	446	_initialize_auxv (void)
	447	{
	448	add_info ("auxv", info_auxv_command,
edefbb7c AC	449	_("Display the inferior's auxiliary vector.\n\
edefbb7c AC	450	This is information provided by the operating system at program startup."));
14ed0a8b	451	}