[thirdparty/glibc.git] / elf / dl-sysdep.c

/* Operating system support for run-time dynamic linker.  Generic Unix version.
   Copyright (C) 1995-2016 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

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

   The GNU C Library 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
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <http://www.gnu.org/licenses/>.  */

/* We conditionalize the whole of this file rather than simply eliding it
   from the static build, because other sysdeps/ versions of this file
   might define things needed by a static build.  */

#ifdef SHARED

#include <assert.h>
#include <elf.h>
#include <errno.h>
#include <fcntl.h>
#include <libintl.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <ldsodefs.h>
#include <_itoa.h>
#include <fpu_control.h>

#include <entry.h>
#include <dl-machine.h>
#include <dl-procinfo.h>
#include <dl-osinfo.h>
#include <hp-timing.h>
#include <tls.h>

extern char **_environ attribute_hidden;
extern char _end[] attribute_hidden;

/* Protect SUID program against misuse of file descriptors.  */
extern void __libc_check_standard_fds (void);

#ifdef NEED_DL_BASE_ADDR
ElfW(Addr) _dl_base_addr;
#endif
int __libc_enable_secure attribute_relro = 0;
rtld_hidden_data_def (__libc_enable_secure)
int __libc_multiple_libcs = 0;	/* Defining this here avoids the inclusion
				   of init-first.  */
/* This variable contains the lowest stack address ever used.  */
void *__libc_stack_end attribute_relro = NULL;
rtld_hidden_data_def(__libc_stack_end)
void *_dl_random attribute_relro = NULL;

#ifndef DL_FIND_ARG_COMPONENTS
# define DL_FIND_ARG_COMPONENTS(cookie, argc, argv, envp, auxp)	\
  do {									      \
    void **_tmp;							      \
    (argc) = *(long int *) cookie;					      \
    (argv) = (char **) ((long int *) cookie + 1);			      \
    (envp) = (argv) + (argc) + 1;					      \
    for (_tmp = (void **) (envp); *_tmp; ++_tmp)			      \
      continue;								      \
    (auxp) = (void *) ++_tmp;						      \
  } while (0)
#endif

#ifndef DL_STACK_END
# define DL_STACK_END(cookie) ((void *) (cookie))
#endif

ElfW(Addr)
_dl_sysdep_start (void **start_argptr,
		  void (*dl_main) (const ElfW(Phdr) *phdr, ElfW(Word) phnum,
				   ElfW(Addr) *user_entry, ElfW(auxv_t) *auxv))
{
  const ElfW(Phdr) *phdr = NULL;
  ElfW(Word) phnum = 0;
  ElfW(Addr) user_entry;
  ElfW(auxv_t) *av;
#ifdef HAVE_AUX_SECURE
# define set_seen(tag) (tag)	/* Evaluate for the side effects.  */
# define set_seen_secure() ((void) 0)
#else
  uid_t uid = 0;
  gid_t gid = 0;
  unsigned int seen = 0;
# define set_seen_secure() (seen = -1)
# ifdef HAVE_AUX_XID
#  define set_seen(tag) (tag)	/* Evaluate for the side effects.  */
# else
#  define M(type) (1 << (type))
#  define set_seen(tag) seen |= M ((tag)->a_type)
# endif
#endif
#ifdef NEED_DL_SYSINFO
  uintptr_t new_sysinfo = 0;
#endif

  __libc_stack_end = DL_STACK_END (start_argptr);
  DL_FIND_ARG_COMPONENTS (start_argptr, _dl_argc, _dl_argv, _environ,
			  GLRO(dl_auxv));

  user_entry = (ElfW(Addr)) ENTRY_POINT;
  GLRO(dl_platform) = NULL; /* Default to nothing known about the platform.  */

  for (av = GLRO(dl_auxv); av->a_type != AT_NULL; set_seen (av++))
    switch (av->a_type)
      {
      case AT_PHDR:
	phdr = (void *) av->a_un.a_val;
	break;
      case AT_PHNUM:
	phnum = av->a_un.a_val;
	break;
      case AT_PAGESZ:
	GLRO(dl_pagesize) = av->a_un.a_val;
	break;
      case AT_ENTRY:
	user_entry = av->a_un.a_val;
	break;
#ifdef NEED_DL_BASE_ADDR
      case AT_BASE:
	_dl_base_addr = av->a_un.a_val;
	break;
#endif
#ifndef HAVE_AUX_SECURE
      case AT_UID:
      case AT_EUID:
	uid ^= av->a_un.a_val;
	break;
      case AT_GID:
      case AT_EGID:
	gid ^= av->a_un.a_val;
	break;
#endif
      case AT_SECURE:
#ifndef HAVE_AUX_SECURE
	seen = -1;
#endif
	__libc_enable_secure = av->a_un.a_val;
	break;
      case AT_PLATFORM:
	GLRO(dl_platform) = (void *) av->a_un.a_val;
	break;
      case AT_HWCAP:
	GLRO(dl_hwcap) = (unsigned long int) av->a_un.a_val;
	break;
      case AT_HWCAP2:
	GLRO(dl_hwcap2) = (unsigned long int) av->a_un.a_val;
	break;
      case AT_CLKTCK:
	GLRO(dl_clktck) = av->a_un.a_val;
	break;
      case AT_FPUCW:
	GLRO(dl_fpu_control) = av->a_un.a_val;
	break;
#ifdef NEED_DL_SYSINFO
      case AT_SYSINFO:
	new_sysinfo = av->a_un.a_val;
	break;
#endif
#ifdef NEED_DL_SYSINFO_DSO
      case AT_SYSINFO_EHDR:
	GLRO(dl_sysinfo_dso) = (void *) av->a_un.a_val;
	break;
#endif
      case AT_RANDOM:
	_dl_random = (void *) av->a_un.a_val;
	break;
#ifdef DL_PLATFORM_AUXV
      DL_PLATFORM_AUXV
#endif
      }

#ifndef HAVE_AUX_SECURE
  if (seen != -1)
    {
      /* Fill in the values we have not gotten from the kernel through the
	 auxiliary vector.  */
# ifndef HAVE_AUX_XID
#  define SEE(UID, var, uid) \
   if ((seen & M (AT_##UID)) == 0) var ^= __get##uid ()
      SEE (UID, uid, uid);
      SEE (EUID, uid, euid);
      SEE (GID, gid, gid);
      SEE (EGID, gid, egid);
# endif

      /* If one of the two pairs of IDs does not match this is a setuid
	 or setgid run.  */
      __libc_enable_secure = uid | gid;
    }
#endif

#ifndef HAVE_AUX_PAGESIZE
  if (GLRO(dl_pagesize) == 0)
    GLRO(dl_pagesize) = __getpagesize ();
#endif

#ifdef NEED_DL_SYSINFO
  if (new_sysinfo != 0)
    {
# ifdef NEED_DL_SYSINFO_DSO
      /* Only set the sysinfo value if we also have the vsyscall DSO.  */
      if (GLRO(dl_sysinfo_dso) != 0)
# endif
        GLRO(dl_sysinfo) = new_sysinfo;
    }
#endif

#ifdef DL_SYSDEP_INIT
  DL_SYSDEP_INIT;
#endif

#ifdef DL_PLATFORM_INIT
  DL_PLATFORM_INIT;
#endif

  /* Determine the length of the platform name.  */
  if (GLRO(dl_platform) != NULL)
    GLRO(dl_platformlen) = strlen (GLRO(dl_platform));

  if (__sbrk (0) == _end)
    /* The dynamic linker was run as a program, and so the initial break
       starts just after our bss, at &_end.  The malloc in dl-minimal.c
       will consume the rest of this page, so tell the kernel to move the
       break up that far.  When the user program examines its break, it
       will see this new value and not clobber our data.  */
    __sbrk (GLRO(dl_pagesize)
	    - ((_end - (char *) 0) & (GLRO(dl_pagesize) - 1)));

  /* If this is a SUID program we make sure that FDs 0, 1, and 2 are
     allocated.  If necessary we are doing it ourself.  If it is not
     possible we stop the program.  */
  if (__builtin_expect (__libc_enable_secure, 0))
    __libc_check_standard_fds ();

  (*dl_main) (phdr, phnum, &user_entry, GLRO(dl_auxv));
  return user_entry;
}

void
internal_function
_dl_sysdep_start_cleanup (void)
{
}

void
internal_function
_dl_show_auxv (void)
{
  char buf[64];
  ElfW(auxv_t) *av;

  /* Terminate string.  */
  buf[63] = '\0';

  /* The following code assumes that the AT_* values are encoded
     starting from 0 with AT_NULL, 1 for AT_IGNORE, and all other values
     close by (otherwise the array will be too large).  In case we have
     to support a platform where these requirements are not fulfilled
     some alternative implementation has to be used.  */
  for (av = GLRO(dl_auxv); av->a_type != AT_NULL; ++av)
    {
      static const struct
      {
	const char label[17];
	enum { unknown = 0, dec, hex, str, ignore } form : 8;
      } auxvars[] =
	{
	  [AT_EXECFD - 2] =		{ "EXECFD:       ", dec },
	  [AT_EXECFN - 2] =		{ "EXECFN:       ", str },
	  [AT_PHDR - 2] =		{ "PHDR:         0x", hex },
	  [AT_PHENT - 2] =		{ "PHENT:        ", dec },
	  [AT_PHNUM - 2] =		{ "PHNUM:        ", dec },
	  [AT_PAGESZ - 2] =		{ "PAGESZ:       ", dec },
	  [AT_BASE - 2] =		{ "BASE:         0x", hex },
	  [AT_FLAGS - 2] =		{ "FLAGS:        0x", hex },
	  [AT_ENTRY - 2] =		{ "ENTRY:        0x", hex },
	  [AT_NOTELF - 2] =		{ "NOTELF:       ", hex },
	  [AT_UID - 2] =		{ "UID:          ", dec },
	  [AT_EUID - 2] =		{ "EUID:         ", dec },
	  [AT_GID - 2] =		{ "GID:          ", dec },
	  [AT_EGID - 2] =		{ "EGID:         ", dec },
	  [AT_PLATFORM - 2] =		{ "PLATFORM:     ", str },
	  [AT_HWCAP - 2] =		{ "HWCAP:        ", hex },
	  [AT_CLKTCK - 2] =		{ "CLKTCK:       ", dec },
	  [AT_FPUCW - 2] =		{ "FPUCW:        ", hex },
	  [AT_DCACHEBSIZE - 2] =	{ "DCACHEBSIZE:  0x", hex },
	  [AT_ICACHEBSIZE - 2] =	{ "ICACHEBSIZE:  0x", hex },
	  [AT_UCACHEBSIZE - 2] =	{ "UCACHEBSIZE:  0x", hex },
	  [AT_IGNOREPPC - 2] =		{ "IGNOREPPC", ignore },
	  [AT_SECURE - 2] =		{ "SECURE:       ", dec },
	  [AT_BASE_PLATFORM - 2] =	{ "BASE_PLATFORM:", str },
	  [AT_SYSINFO - 2] =		{ "SYSINFO:      0x", hex },
	  [AT_SYSINFO_EHDR - 2] =	{ "SYSINFO_EHDR: 0x", hex },
	  [AT_RANDOM - 2] =		{ "RANDOM:       0x", hex },
	  [AT_HWCAP2 - 2] =		{ "HWCAP2:       0x", hex },
	};
      unsigned int idx = (unsigned int) (av->a_type - 2);

      if ((unsigned int) av->a_type < 2u
	  || (idx < sizeof (auxvars) / sizeof (auxvars[0])
	      && auxvars[idx].form == ignore))
	continue;

      assert (AT_NULL == 0);
      assert (AT_IGNORE == 1);

      if (av->a_type == AT_HWCAP || av->a_type == AT_HWCAP2)
	{
	  /* These are handled in a special way per platform.  */
	  if (_dl_procinfo (av->a_type, av->a_un.a_val) == 0)
	    continue;
	}

      if (idx < sizeof (auxvars) / sizeof (auxvars[0])
	  && auxvars[idx].form != unknown)
	{
	  const char *val = (char *) av->a_un.a_val;

	  if (__builtin_expect (auxvars[idx].form, dec) == dec)
	    val = _itoa ((unsigned long int) av->a_un.a_val,
			 buf + sizeof buf - 1, 10, 0);
	  else if (__builtin_expect (auxvars[idx].form, hex) == hex)
	    val = _itoa ((unsigned long int) av->a_un.a_val,
			 buf + sizeof buf - 1, 16, 0);

	  _dl_printf ("AT_%s%s\n", auxvars[idx].label, val);

	  continue;
	}

      /* Unknown value: print a generic line.  */
      char buf2[17];
      buf2[sizeof (buf2) - 1] = '\0';
      const char *val2 = _itoa ((unsigned long int) av->a_un.a_val,
				buf2 + sizeof buf2 - 1, 16, 0);
      const char *val =  _itoa ((unsigned long int) av->a_type,
				buf + sizeof buf - 1, 16, 0);
      _dl_printf ("AT_??? (0x%s): 0x%s\n", val, val2);
    }
}

#endif
Commit	Line	Data
b6ab06ce	1	/* Operating system support for run-time dynamic linker. Generic Unix version.
f7a9f785	2	Copyright (C) 1995-2016 Free Software Foundation, Inc.
b6ab06ce UD	3	This file is part of the GNU C Library.
	4
	5	The GNU C Library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 of the License, or (at your option) any later version.
	9
	10	The GNU C Library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	Lesser General Public License for more details.
	14
	15	You should have received a copy of the GNU Lesser General Public
59ba27a6 PE	16	License along with the GNU C Library; if not, see
59ba27a6 PE	17	<http://www.gnu.org/licenses/>. */
b6ab06ce	18
91363dbb RM	19	/* We conditionalize the whole of this file rather than simply eliding it
	20	from the static build, because other sysdeps/ versions of this file
	21	might define things needed by a static build. */
	22
	23	#ifdef SHARED
	24
b6ab06ce UD	25	#include <assert.h>
	26	#include <elf.h>
	27	#include <errno.h>
	28	#include <fcntl.h>
	29	#include <libintl.h>
	30	#include <stdlib.h>
	31	#include <string.h>
	32	#include <unistd.h>
	33	#include <sys/types.h>
	34	#include <sys/stat.h>
	35	#include <sys/mman.h>
	36	#include <ldsodefs.h>
eb96ffb0	37	#include <_itoa.h>
b6ab06ce UD	38	#include <fpu_control.h>
	39
	40	#include <entry.h>
	41	#include <dl-machine.h>
	42	#include <dl-procinfo.h>
	43	#include <dl-osinfo.h>
	44	#include <hp-timing.h>
	45	#include <tls.h>
	46
b6ab06ce	47	extern char **_environ attribute_hidden;
b1c1949e	48	extern char _end[] attribute_hidden;
b6ab06ce UD	49
	50	/* Protect SUID program against misuse of file descriptors. */
	51	extern void __libc_check_standard_fds (void);
	52
	53	#ifdef NEED_DL_BASE_ADDR
	54	ElfW(Addr) _dl_base_addr;
	55	#endif
	56	int __libc_enable_secure attribute_relro = 0;
6bc6bd3b	57	rtld_hidden_data_def (__libc_enable_secure)
b6ab06ce UD	58	int __libc_multiple_libcs = 0; /* Defining this here avoids the inclusion
	59	of init-first. */
	60	/* This variable contains the lowest stack address ever used. */
	61	void *__libc_stack_end attribute_relro = NULL;
	62	rtld_hidden_data_def(__libc_stack_end)
965cb60a	63	void *_dl_random attribute_relro = NULL;
b6ab06ce UD	64
	65	#ifndef DL_FIND_ARG_COMPONENTS
	66	# define DL_FIND_ARG_COMPONENTS(cookie, argc, argv, envp, auxp) \
	67	do { \
	68	void **_tmp; \
	69	(argc) = (long int ) cookie; \
	70	(argv) = (char *) ((long int ) cookie + 1); \
	71	(envp) = (argv) + (argc) + 1; \
	72	for (_tmp = (void *) (envp); _tmp; ++_tmp) \
	73	continue; \
	74	(auxp) = (void *) ++_tmp; \
	75	} while (0)
	76	#endif
	77
	78	#ifndef DL_STACK_END
	79	# define DL_STACK_END(cookie) ((void *) (cookie))
	80	#endif
	81
	82	ElfW(Addr)
	83	_dl_sysdep_start (void **start_argptr,
	84	void (dl_main) (const ElfW(Phdr) phdr, ElfW(Word) phnum,
3a56ea26	85	ElfW(Addr) user_entry, ElfW(auxv_t) auxv))
b6ab06ce UD	86	{
	87	const ElfW(Phdr) *phdr = NULL;
	88	ElfW(Word) phnum = 0;
	89	ElfW(Addr) user_entry;
	90	ElfW(auxv_t) *av;
	91	#ifdef HAVE_AUX_SECURE
	92	# define set_seen(tag) (tag) /* Evaluate for the side effects. */
	93	# define set_seen_secure() ((void) 0)
	94	#else
	95	uid_t uid = 0;
	96	gid_t gid = 0;
	97	unsigned int seen = 0;
	98	# define set_seen_secure() (seen = -1)
	99	# ifdef HAVE_AUX_XID
	100	# define set_seen(tag) (tag) /* Evaluate for the side effects. */
	101	# else
	102	# define M(type) (1 << (type))
	103	# define set_seen(tag) seen \|= M ((tag)->a_type)
	104	# endif
	105	#endif
	106	#ifdef NEED_DL_SYSINFO
	107	uintptr_t new_sysinfo = 0;
	108	#endif
	109
	110	__libc_stack_end = DL_STACK_END (start_argptr);
4243cbea	111	DL_FIND_ARG_COMPONENTS (start_argptr, _dl_argc, _dl_argv, _environ,
c7683a6d	112	GLRO(dl_auxv));
b6ab06ce UD	113
	114	user_entry = (ElfW(Addr)) ENTRY_POINT;
	115	GLRO(dl_platform) = NULL; /* Default to nothing known about the platform. */
	116
c7683a6d	117	for (av = GLRO(dl_auxv); av->a_type != AT_NULL; set_seen (av++))
b6ab06ce UD	118	switch (av->a_type)
	119	{
	120	case AT_PHDR:
	121	phdr = (void *) av->a_un.a_val;
	122	break;
	123	case AT_PHNUM:
	124	phnum = av->a_un.a_val;
	125	break;
	126	case AT_PAGESZ:
	127	GLRO(dl_pagesize) = av->a_un.a_val;
	128	break;
	129	case AT_ENTRY:
	130	user_entry = av->a_un.a_val;
	131	break;
	132	#ifdef NEED_DL_BASE_ADDR
	133	case AT_BASE:
	134	_dl_base_addr = av->a_un.a_val;
	135	break;
	136	#endif
	137	#ifndef HAVE_AUX_SECURE
	138	case AT_UID:
	139	case AT_EUID:
	140	uid ^= av->a_un.a_val;
	141	break;
	142	case AT_GID:
	143	case AT_EGID:
	144	gid ^= av->a_un.a_val;
	145	break;
	146	#endif
	147	case AT_SECURE:
	148	#ifndef HAVE_AUX_SECURE
	149	seen = -1;
	150	#endif
6bc6bd3b	151	__libc_enable_secure = av->a_un.a_val;
b6ab06ce UD	152	break;
	153	case AT_PLATFORM:
	154	GLRO(dl_platform) = (void *) av->a_un.a_val;
	155	break;
	156	case AT_HWCAP:
	157	GLRO(dl_hwcap) = (unsigned long int) av->a_un.a_val;
	158	break;
1ae8bfe0 RA	159	case AT_HWCAP2:
	160	GLRO(dl_hwcap2) = (unsigned long int) av->a_un.a_val;
	161	break;
b6ab06ce UD	162	case AT_CLKTCK:
	163	GLRO(dl_clktck) = av->a_un.a_val;
	164	break;
	165	case AT_FPUCW:
	166	GLRO(dl_fpu_control) = av->a_un.a_val;
	167	break;
	168	#ifdef NEED_DL_SYSINFO
	169	case AT_SYSINFO:
	170	new_sysinfo = av->a_un.a_val;
	171	break;
	172	#endif
7775448e	173	#ifdef NEED_DL_SYSINFO_DSO
b6ab06ce UD	174	case AT_SYSINFO_EHDR:
	175	GLRO(dl_sysinfo_dso) = (void *) av->a_un.a_val;
	176	break;
	177	#endif
965cb60a UD	178	case AT_RANDOM:
	179	_dl_random = (void *) av->a_un.a_val;
	180	break;
b6ab06ce UD	181	#ifdef DL_PLATFORM_AUXV
	182	DL_PLATFORM_AUXV
	183	#endif
	184	}
	185
	186	#ifndef HAVE_AUX_SECURE
	187	if (seen != -1)
	188	{
	189	/* Fill in the values we have not gotten from the kernel through the
	190	auxiliary vector. */
	191	# ifndef HAVE_AUX_XID
	192	# define SEE(UID, var, uid) \
	193	if ((seen & M (AT_##UID)) == 0) var ^= __get##uid ()
	194	SEE (UID, uid, uid);
	195	SEE (EUID, uid, euid);
	196	SEE (GID, gid, gid);
	197	SEE (EGID, gid, egid);
	198	# endif
	199
	200	/* If one of the two pairs of IDs does not match this is a setuid
	201	or setgid run. */
6bc6bd3b	202	__libc_enable_secure = uid \| gid;
b6ab06ce UD	203	}
	204	#endif
	205
	206	#ifndef HAVE_AUX_PAGESIZE
	207	if (GLRO(dl_pagesize) == 0)
	208	GLRO(dl_pagesize) = __getpagesize ();
	209	#endif
	210
60bfd54c RM	211	#ifdef NEED_DL_SYSINFO
	212	if (new_sysinfo != 0)
	213	{
	214	# ifdef NEED_DL_SYSINFO_DSO
	215	/* Only set the sysinfo value if we also have the vsyscall DSO. */
	216	if (GLRO(dl_sysinfo_dso) != 0)
	217	# endif
	218	GLRO(dl_sysinfo) = new_sysinfo;
	219	}
b6ab06ce UD	220	#endif
	221
	222	#ifdef DL_SYSDEP_INIT
	223	DL_SYSDEP_INIT;
	224	#endif
	225
	226	#ifdef DL_PLATFORM_INIT
	227	DL_PLATFORM_INIT;
	228	#endif
	229
	230	/* Determine the length of the platform name. */
	231	if (GLRO(dl_platform) != NULL)
	232	GLRO(dl_platformlen) = strlen (GLRO(dl_platform));
	233
b1c1949e	234	if (__sbrk (0) == _end)
b6ab06ce UD	235	/* The dynamic linker was run as a program, and so the initial break
	236	starts just after our bss, at &_end. The malloc in dl-minimal.c
	237	will consume the rest of this page, so tell the kernel to move the
	238	break up that far. When the user program examines its break, it
	239	will see this new value and not clobber our data. */
	240	__sbrk (GLRO(dl_pagesize)
b1c1949e	241	- ((_end - (char *) 0) & (GLRO(dl_pagesize) - 1)));
b6ab06ce UD	242
	243	/* If this is a SUID program we make sure that FDs 0, 1, and 2 are
	244	allocated. If necessary we are doing it ourself. If it is not
	245	possible we stop the program. */
6bc6bd3b	246	if (__builtin_expect (__libc_enable_secure, 0))
b6ab06ce UD	247	__libc_check_standard_fds ();
b6ab06ce UD	248
c7683a6d	249	(*dl_main) (phdr, phnum, &user_entry, GLRO(dl_auxv));
b6ab06ce UD	250	return user_entry;
	251	}
	252
	253	void
	254	internal_function
	255	_dl_sysdep_start_cleanup (void)
	256	{
	257	}
	258
	259	void
	260	internal_function
	261	_dl_show_auxv (void)
	262	{
	263	char buf[64];
	264	ElfW(auxv_t) *av;
	265
	266	/* Terminate string. */
	267	buf[63] = '\0';
	268
	269	/* The following code assumes that the AT_* values are encoded
	270	starting from 0 with AT_NULL, 1 for AT_IGNORE, and all other values
	271	close by (otherwise the array will be too large). In case we have
	272	to support a platform where these requirements are not fulfilled
	273	some alternative implementation has to be used. */
c7683a6d	274	for (av = GLRO(dl_auxv); av->a_type != AT_NULL; ++av)
b6ab06ce UD	275	{
	276	static const struct
	277	{
f53713a8 UD	278	const char label[17];
f53713a8 UD	279	enum { unknown = 0, dec, hex, str, ignore } form : 8;
b6ab06ce UD	280	} auxvars[] =
b6ab06ce UD	281	{
f53713a8 UD	282	[AT_EXECFD - 2] = { "EXECFD: ", dec },
	283	[AT_EXECFN - 2] = { "EXECFN: ", str },
	284	[AT_PHDR - 2] = { "PHDR: 0x", hex },
	285	[AT_PHENT - 2] = { "PHENT: ", dec },
	286	[AT_PHNUM - 2] = { "PHNUM: ", dec },
	287	[AT_PAGESZ - 2] = { "PAGESZ: ", dec },
	288	[AT_BASE - 2] = { "BASE: 0x", hex },
	289	[AT_FLAGS - 2] = { "FLAGS: 0x", hex },
	290	[AT_ENTRY - 2] = { "ENTRY: 0x", hex },
	291	[AT_NOTELF - 2] = { "NOTELF: ", hex },
	292	[AT_UID - 2] = { "UID: ", dec },
	293	[AT_EUID - 2] = { "EUID: ", dec },
	294	[AT_GID - 2] = { "GID: ", dec },
	295	[AT_EGID - 2] = { "EGID: ", dec },
	296	[AT_PLATFORM - 2] = { "PLATFORM: ", str },
	297	[AT_HWCAP - 2] = { "HWCAP: ", hex },
	298	[AT_CLKTCK - 2] = { "CLKTCK: ", dec },
	299	[AT_FPUCW - 2] = { "FPUCW: ", hex },
	300	[AT_DCACHEBSIZE - 2] = { "DCACHEBSIZE: 0x", hex },
	301	[AT_ICACHEBSIZE - 2] = { "ICACHEBSIZE: 0x", hex },
	302	[AT_UCACHEBSIZE - 2] = { "UCACHEBSIZE: 0x", hex },
	303	[AT_IGNOREPPC - 2] = { "IGNOREPPC", ignore },
	304	[AT_SECURE - 2] = { "SECURE: ", dec },
	305	[AT_BASE_PLATFORM - 2] = { "BASE_PLATFORM:", str },
	306	[AT_SYSINFO - 2] = { "SYSINFO: 0x", hex },
	307	[AT_SYSINFO_EHDR - 2] = { "SYSINFO_EHDR: 0x", hex },
	308	[AT_RANDOM - 2] = { "RANDOM: 0x", hex },
1ae8bfe0	309	[AT_HWCAP2 - 2] = { "HWCAP2: 0x", hex },
b6ab06ce UD	310	};
	311	unsigned int idx = (unsigned int) (av->a_type - 2);
	312
171a70b4 PP	313	if ((unsigned int) av->a_type < 2u
	314	\|\| (idx < sizeof (auxvars) / sizeof (auxvars[0])
	315	&& auxvars[idx].form == ignore))
b6ab06ce UD	316	continue;
	317
	318	assert (AT_NULL == 0);
	319	assert (AT_IGNORE == 1);
	320
1ae8bfe0	321	if (av->a_type == AT_HWCAP \|\| av->a_type == AT_HWCAP2)
b6ab06ce	322	{
1ae8bfe0 RA	323	/* These are handled in a special way per platform. */
1ae8bfe0 RA	324	if (_dl_procinfo (av->a_type, av->a_un.a_val) == 0)
b6ab06ce UD	325	continue;
	326	}
	327
	328	if (idx < sizeof (auxvars) / sizeof (auxvars[0])
	329	&& auxvars[idx].form != unknown)
	330	{
	331	const char val = (char ) av->a_un.a_val;
	332
	333	if (__builtin_expect (auxvars[idx].form, dec) == dec)
	334	val = _itoa ((unsigned long int) av->a_un.a_val,
	335	buf + sizeof buf - 1, 10, 0);
	336	else if (__builtin_expect (auxvars[idx].form, hex) == hex)
	337	val = _itoa ((unsigned long int) av->a_un.a_val,
	338	buf + sizeof buf - 1, 16, 0);
	339
f53713a8	340	_dl_printf ("AT_%s%s\n", auxvars[idx].label, val);
b6ab06ce UD	341
	342	continue;
	343	}
	344
	345	/* Unknown value: print a generic line. */
	346	char buf2[17];
fbb04b35	347	buf2[sizeof (buf2) - 1] = '\0';
b6ab06ce UD	348	const char *val2 = _itoa ((unsigned long int) av->a_un.a_val,
	349	buf2 + sizeof buf2 - 1, 16, 0);
	350	const char *val = _itoa ((unsigned long int) av->a_type,
	351	buf + sizeof buf - 1, 16, 0);
	352	_dl_printf ("AT_??? (0x%s): 0x%s\n", val, val2);
	353	}
	354	}
	355
91363dbb	356	#endif