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

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

   Copyright (C) 2004, 2005, 2006, 2007, 2008 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 "auxv.h"
#include "elf/common.h"

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


/* This function is called like a to_xfer_partial hook,
   but must be called with TARGET_OBJECT_AUXV.
   It handles access via /proc/PID/auxv, which is the common method.
   This function is appropriate for doing:
	   #define NATIVE_XFER_AUXV	procfs_xfer_auxv
   for a native target that uses inftarg.c's child_xfer_partial hook.  */

LONGEST
procfs_xfer_auxv (struct target_ops *ops,
		  int /* enum target_object */ object,
		  const char *annex,
		  gdb_byte *readbuf,
		  const gdb_byte *writebuf,
		  ULONGEST offset,
		  LONGEST len)
{
  char *pathname;
  int fd;
  LONGEST n;

  gdb_assert (object == TARGET_OBJECT_AUXV);
  gdb_assert (readbuf || writebuf);

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

/* 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
default_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
		   gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
{
  const int sizeof_auxv_field = TYPE_LENGTH (builtin_type_void_data_ptr);
  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);
  ptr += sizeof_auxv_field;
  *valp = extract_unsigned_integer (ptr, sizeof_auxv_field);
  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;
  int ents = 0;

  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)
    {
      extern int addressprint;
      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_SYSINFO, _("Special system info/entry points"), hex);
	  TAG (AT_SYSINFO_EHDR, _("System-supplied DSO's ELF header"), hex);
	  TAG (AT_SECURE, _("Boolean, was exec setuid-like?"), dec);
	  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 ",
			paddr_d (type), name, description);
      switch (flavor)
	{
	case dec:
	  fprintf_filtered (file, "%s\n", paddr_d (val));
	  break;
	case hex:
	  fprintf_filtered (file, "0x%s\n", paddr_nz (val));
	  break;
	case str:
	  if (addressprint)
	    fprintf_filtered (file, "0x%s", paddr_nz (val));
	  val_print_string (val, -1, 1, file);
	  fprintf_filtered (file, "\n");
	  break;
	}
      ++ents;
    }

  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
9b254dd1	3	Copyright (C) 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
14ed0a8b RM	4
	5	This file is part of GDB.
	6
	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
a9762ec7	9	the Free Software Foundation; either version 3 of the License, or
14ed0a8b RM	10	(at your option) any later version.
	11
	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.
	16
	17	You should have received a copy of the GNU General Public License
a9762ec7	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
14ed0a8b RM	19
	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
	28	#include "auxv.h"
	29	#include "elf/common.h"
	30
	31	#include <unistd.h>
	32	#include <fcntl.h>
	33
	34
	35	/* This function is called like a to_xfer_partial hook,
	36	but must be called with TARGET_OBJECT_AUXV.
	37	It handles access via /proc/PID/auxv, which is the common method.
	38	This function is appropriate for doing:
	39	#define NATIVE_XFER_AUXV procfs_xfer_auxv
	40	for a native target that uses inftarg.c's child_xfer_partial hook. */
	41
	42	LONGEST
	43	procfs_xfer_auxv (struct target_ops *ops,
	44	int /* enum target_object */ object,
	45	const char *annex,
36aa5e41 AC	46	gdb_byte *readbuf,
36aa5e41 AC	47	const gdb_byte *writebuf,
14ed0a8b RM	48	ULONGEST offset,
	49	LONGEST len)
	50	{
	51	char *pathname;
	52	int fd;
	53	LONGEST n;
	54
	55	gdb_assert (object == TARGET_OBJECT_AUXV);
	56	gdb_assert (readbuf \|\| writebuf);
	57
	58	pathname = xstrprintf ("/proc/%d/auxv", PIDGET (inferior_ptid));
	59	fd = open (pathname, writebuf != NULL ? O_WRONLY : O_RDONLY);
	60	xfree (pathname);
	61	if (fd < 0)
	62	return -1;
	63
	64	if (offset != (ULONGEST) 0
	65	&& lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
	66	n = -1;
	67	else if (readbuf != NULL)
	68	n = read (fd, readbuf, len);
	69	else
	70	n = write (fd, writebuf, len);
	71
	72	(void) close (fd);
	73
	74	return n;
	75	}
	76
14ed0a8b RM	77	/* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
	78	Return 0 if *READPTR is already at the end of the buffer.
	79	Return -1 if there is insufficient buffer for a whole entry.
	80	Return 1 if an entry was read into TYPEP and VALP. */
	81	int
c47ffbe3	82	default_auxv_parse (struct target_ops ops, gdb_byte *readptr,
36aa5e41	83	gdb_byte endptr, CORE_ADDR typep, CORE_ADDR *valp)
14ed0a8b RM	84	{
14ed0a8b RM	85	const int sizeof_auxv_field = TYPE_LENGTH (builtin_type_void_data_ptr);
36aa5e41	86	gdb_byte ptr = readptr;
14ed0a8b RM	87
	88	if (endptr == ptr)
	89	return 0;
	90
	91	if (endptr - ptr < sizeof_auxv_field * 2)
	92	return -1;
	93
	94	*typep = extract_unsigned_integer (ptr, sizeof_auxv_field);
	95	ptr += sizeof_auxv_field;
	96	*valp = extract_unsigned_integer (ptr, sizeof_auxv_field);
	97	ptr += sizeof_auxv_field;
	98
	99	*readptr = ptr;
	100	return 1;
	101	}
	102
c47ffbe3 VP	103	/* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
	104	Return 0 if *READPTR is already at the end of the buffer.
	105	Return -1 if there is insufficient buffer for a whole entry.
	106	Return 1 if an entry was read into TYPEP and VALP. */
	107	int
	108	target_auxv_parse (struct target_ops ops, gdb_byte *readptr,
	109	gdb_byte endptr, CORE_ADDR typep, CORE_ADDR *valp)
	110	{
	111	struct target_ops *t;
	112	for (t = ops; t != NULL; t = t->beneath)
	113	if (t->to_auxv_parse != NULL)
	114	return t->to_auxv_parse (t, readptr, endptr, typep, valp);
	115
	116	return default_auxv_parse (ops, readptr, endptr, typep, valp);
	117	}
	118
14ed0a8b RM	119	/* Extract the auxiliary vector entry with a_type matching MATCH.
	120	Return zero if no such entry was found, or -1 if there was
	121	an error getting the information. On success, return 1 after
	122	storing the entry's value field in VALP. /
	123	int
	124	target_auxv_search (struct target_ops ops, CORE_ADDR match, CORE_ADDR valp)
	125	{
	126	CORE_ADDR type, val;
36aa5e41	127	gdb_byte *data;
13547ab6	128	LONGEST n = target_read_alloc (ops, TARGET_OBJECT_AUXV, NULL, &data);
36aa5e41	129	gdb_byte *ptr = data;
14ed0a8b RM	130	int ents = 0;
	131
	132	if (n <= 0)
	133	return n;
	134
	135	while (1)
	136	switch (target_auxv_parse (ops, &ptr, data + n, &type, &val))
	137	{
	138	case 1: /* Here's an entry, check it. */
	139	if (type == match)
	140	{
	141	xfree (data);
	142	*valp = val;
	143	return 1;
	144	}
	145	break;
	146	case 0: /* End of the vector. */
	147	xfree (data);
	148	return 0;
	149	default: /* Bogosity. */
	150	xfree (data);
	151	return -1;
	152	}
	153
	154	/NOTREACHED/
	155	}
	156
	157
	158	/* Print the contents of the target's AUXV on the specified file. */
	159	int
	160	fprint_target_auxv (struct ui_file file, struct target_ops ops)
	161	{
	162	CORE_ADDR type, val;
36aa5e41	163	gdb_byte *data;
13547ab6 DJ	164	LONGEST len = target_read_alloc (ops, TARGET_OBJECT_AUXV, NULL,
13547ab6 DJ	165	&data);
36aa5e41	166	gdb_byte *ptr = data;
14ed0a8b RM	167	int ents = 0;
	168
	169	if (len <= 0)
	170	return len;
	171
	172	while (target_auxv_parse (ops, &ptr, data + len, &type, &val) > 0)
	173	{
	174	extern int addressprint;
	175	const char *name = "???";
	176	const char *description = "";
	177	enum { dec, hex, str } flavor = hex;
	178
	179	switch (type)
	180	{
	181	#define TAG(tag, text, kind) \
	182	case tag: name = #tag; description = text; flavor = kind; break
edefbb7c AC	183	TAG (AT_NULL, _("End of vector"), hex);
	184	TAG (AT_IGNORE, _("Entry should be ignored"), hex);
	185	TAG (AT_EXECFD, _("File descriptor of program"), dec);
	186	TAG (AT_PHDR, _("Program headers for program"), hex);
	187	TAG (AT_PHENT, _("Size of program header entry"), dec);
	188	TAG (AT_PHNUM, _("Number of program headers"), dec);
	189	TAG (AT_PAGESZ, _("System page size"), dec);
	190	TAG (AT_BASE, _("Base address of interpreter"), hex);
	191	TAG (AT_FLAGS, _("Flags"), hex);
	192	TAG (AT_ENTRY, _("Entry point of program"), hex);
	193	TAG (AT_NOTELF, _("Program is not ELF"), dec);
	194	TAG (AT_UID, _("Real user ID"), dec);
	195	TAG (AT_EUID, _("Effective user ID"), dec);
	196	TAG (AT_GID, _("Real group ID"), dec);
	197	TAG (AT_EGID, _("Effective group ID"), dec);
	198	TAG (AT_CLKTCK, _("Frequency of times()"), dec);
	199	TAG (AT_PLATFORM, _("String identifying platform"), str);
	200	TAG (AT_HWCAP, _("Machine-dependent CPU capability hints"), hex);
	201	TAG (AT_FPUCW, _("Used FPU control word"), dec);
	202	TAG (AT_DCACHEBSIZE, _("Data cache block size"), dec);
	203	TAG (AT_ICACHEBSIZE, _("Instruction cache block size"), dec);
	204	TAG (AT_UCACHEBSIZE, _("Unified cache block size"), dec);
	205	TAG (AT_IGNOREPPC, _("Entry should be ignored"), dec);
	206	TAG (AT_SYSINFO, _("Special system info/entry points"), hex);
	207	TAG (AT_SYSINFO_EHDR, _("System-supplied DSO's ELF header"), hex);
	208	TAG (AT_SECURE, _("Boolean, was exec setuid-like?"), dec);
	209	TAG (AT_SUN_UID, _("Effective user ID"), dec);
	210	TAG (AT_SUN_RUID, _("Real user ID"), dec);
	211	TAG (AT_SUN_GID, _("Effective group ID"), dec);
	212	TAG (AT_SUN_RGID, _("Real group ID"), dec);
	213	TAG (AT_SUN_LDELF, _("Dynamic linker's ELF header"), hex);
	214	TAG (AT_SUN_LDSHDR, _("Dynamic linker's section headers"), hex);
	215	TAG (AT_SUN_LDNAME, _("String giving name of dynamic linker"), str);
	216	TAG (AT_SUN_LPAGESZ, _("Large pagesize"), dec);
	217	TAG (AT_SUN_PLATFORM, _("Platform name string"), str);
	218	TAG (AT_SUN_HWCAP, _("Machine-dependent CPU capability hints"), hex);
	219	TAG (AT_SUN_IFLUSH, _("Should flush icache?"), dec);
	220	TAG (AT_SUN_CPU, _("CPU name string"), str);
	221	TAG (AT_SUN_EMUL_ENTRY, _("COFF entry point address"), hex);
	222	TAG (AT_SUN_EMUL_EXECFD, _("COFF executable file descriptor"), dec);
14ed0a8b	223	TAG (AT_SUN_EXECNAME,
edefbb7c AC	224	_("Canonicalized file name given to execve"), str);
	225	TAG (AT_SUN_MMU, _("String for name of MMU module"), str);
	226	TAG (AT_SUN_LDDATA, _("Dynamic linker's data segment address"), hex);
77d49ac6 MK	227	TAG (AT_SUN_AUXFLAGS,
77d49ac6 MK	228	_("AF_SUN_ flags passed from the kernel"), hex);
14ed0a8b RM	229	}
	230
	231	fprintf_filtered (file, "%-4s %-20s %-30s ",
	232	paddr_d (type), name, description);
	233	switch (flavor)
	234	{
	235	case dec:
	236	fprintf_filtered (file, "%s\n", paddr_d (val));
	237	break;
	238	case hex:
	239	fprintf_filtered (file, "0x%s\n", paddr_nz (val));
	240	break;
	241	case str:
	242	if (addressprint)
	243	fprintf_filtered (file, "0x%s", paddr_nz (val));
	244	val_print_string (val, -1, 1, file);
	245	fprintf_filtered (file, "\n");
	246	break;
	247	}
	248	++ents;
	249	}
	250
	251	xfree (data);
	252
	253	return ents;
	254	}
	255
	256	static void
	257	info_auxv_command (char *cmd, int from_tty)
	258	{
14ed0a8b	259	if (! target_has_stack)
edefbb7c	260	error (_("The program has no auxiliary information now."));
14ed0a8b RM	261	else
	262	{
	263	int ents = fprint_target_auxv (gdb_stdout, &current_target);
	264	if (ents < 0)
edefbb7c	265	error (_("No auxiliary vector found, or failed reading it."));
14ed0a8b	266	else if (ents == 0)
edefbb7c	267	error (_("Auxiliary vector is empty."));
14ed0a8b RM	268	}
	269	}
	270
	271
	272	extern initialize_file_ftype _initialize_auxv; /* -Wmissing-prototypes; */
	273
	274	void
	275	_initialize_auxv (void)
	276	{
	277	add_info ("auxv", info_auxv_command,
edefbb7c AC	278	_("Display the inferior's auxiliary vector.\n\
edefbb7c AC	279	This is information provided by the operating system at program startup."));
14ed0a8b	280	}