Attachment 295379 Details for Bug 433576 – preprocessed source

preprocessed source

ldgeneric.i (text/plain), 437.92 KB, created by Roland McGrath on 2008-02-20 03:53:16 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Roland McGrath

Created: 2008-02-20 03:53:16 UTC

Size: 437.92 KB

patch

obsolete

># 1 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c"
># 1 "/home/roland/stock-elfutils-build/src//"
># 1 "<built-in>"
># 1 "<command-line>"
># 1 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c"
># 27 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c"
># 1 "../config.h" 1
># 28 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c" 2
>
>
># 1 "/usr/include/assert.h" 1 3 4
># 37 "/usr/include/assert.h" 3 4
># 1 "/usr/include/features.h" 1 3 4
># 335 "/usr/include/features.h" 3 4
># 1 "/usr/include/sys/cdefs.h" 1 3 4
># 360 "/usr/include/sys/cdefs.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 361 "/usr/include/sys/cdefs.h" 2 3 4
># 336 "/usr/include/features.h" 2 3 4
># 359 "/usr/include/features.h" 3 4
># 1 "/usr/include/gnu/stubs.h" 1 3 4
>
>
>
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 5 "/usr/include/gnu/stubs.h" 2 3 4
>
>
># 1 "/usr/include/gnu/stubs-32.h" 1 3 4
># 8 "/usr/include/gnu/stubs.h" 2 3 4
># 360 "/usr/include/features.h" 2 3 4
># 38 "/usr/include/assert.h" 2 3 4
># 66 "/usr/include/assert.h" 3 4
>
>
>
>extern void __assert_fail (__const char *__assertion, __const char *__file,
>      unsigned int __line, __const char *__function)
>     __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, __const char *__file,
>      unsigned int __line,
>      __const char *__function)
>     __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
>     __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));
>
>
>
># 31 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c" 2
># 1 "/usr/include/ctype.h" 1 3 4
># 28 "/usr/include/ctype.h" 3 4
># 1 "/usr/include/bits/types.h" 1 3 4
># 28 "/usr/include/bits/types.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 29 "/usr/include/bits/types.h" 2 3 4
>
>
>typedef unsigned char __u_char;
>typedef unsigned short int __u_short;
>typedef unsigned int __u_int;
>typedef unsigned long int __u_long;
>
>
>typedef signed char __int8_t;
>typedef unsigned char __uint8_t;
>typedef signed short int __int16_t;
>typedef unsigned short int __uint16_t;
>typedef signed int __int32_t;
>typedef unsigned int __uint32_t;
>
>
>
>
>__extension__ typedef signed long long int __int64_t;
>__extension__ typedef unsigned long long int __uint64_t;
>
>
>
>
>
>
>
>__extension__ typedef long long int __quad_t;
>__extension__ typedef unsigned long long int __u_quad_t;
># 131 "/usr/include/bits/types.h" 3 4
># 1 "/usr/include/bits/typesizes.h" 1 3 4
># 132 "/usr/include/bits/types.h" 2 3 4
>
>
>__extension__ typedef __u_quad_t __dev_t;
>__extension__ typedef unsigned int __uid_t;
>__extension__ typedef unsigned int __gid_t;
>__extension__ typedef unsigned long int __ino_t;
>__extension__ typedef __u_quad_t __ino64_t;
>__extension__ typedef unsigned int __mode_t;
>__extension__ typedef unsigned int __nlink_t;
>__extension__ typedef long int __off_t;
>__extension__ typedef __quad_t __off64_t;
>__extension__ typedef int __pid_t;
>__extension__ typedef struct { int __val[2]; } __fsid_t;
>__extension__ typedef long int __clock_t;
>__extension__ typedef unsigned long int __rlim_t;
>__extension__ typedef __u_quad_t __rlim64_t;
>__extension__ typedef unsigned int __id_t;
>__extension__ typedef long int __time_t;
>__extension__ typedef unsigned int __useconds_t;
>__extension__ typedef long int __suseconds_t;
>
>__extension__ typedef int __daddr_t;
>__extension__ typedef long int __swblk_t;
>__extension__ typedef int __key_t;
>
>
>__extension__ typedef int __clockid_t;
>
>
>__extension__ typedef void * __timer_t;
>
>
>__extension__ typedef long int __blksize_t;
>
>
>
>
>__extension__ typedef long int __blkcnt_t;
>__extension__ typedef __quad_t __blkcnt64_t;
>
>
>__extension__ typedef unsigned long int __fsblkcnt_t;
>__extension__ typedef __u_quad_t __fsblkcnt64_t;
>
>
>__extension__ typedef unsigned long int __fsfilcnt_t;
>__extension__ typedef __u_quad_t __fsfilcnt64_t;
>
>__extension__ typedef int __ssize_t;
>
>
>
>typedef __off64_t __loff_t;
>typedef __quad_t *__qaddr_t;
>typedef char *__caddr_t;
>
>
>__extension__ typedef int __intptr_t;
>
>
>__extension__ typedef unsigned int __socklen_t;
># 29 "/usr/include/ctype.h" 2 3 4
>
>
># 41 "/usr/include/ctype.h" 3 4
># 1 "/usr/include/endian.h" 1 3 4
># 37 "/usr/include/endian.h" 3 4
># 1 "/usr/include/bits/endian.h" 1 3 4
># 38 "/usr/include/endian.h" 2 3 4
># 42 "/usr/include/ctype.h" 2 3 4
>
>
>
>
>
>
>enum
>{
>  _ISupper = (1 << (0)),
>  _ISlower = (1 << (1)),
>  _ISalpha = (1 << (2)),
>  _ISdigit = (1 << (3)),
>  _ISxdigit = (1 << (4)),
>  _ISspace = (1 << (5)),
>  _ISprint = (1 << (6)),
>  _ISgraph = (1 << (7)),
>  _ISblank = (1 << (8)),
>  _IScntrl = (1 << (9)),
>  _ISpunct = (1 << (10)),
>  _ISalnum = (1 << (11))
>};
># 81 "/usr/include/ctype.h" 3 4
>extern __const unsigned short int **__ctype_b_loc (void)
>     __attribute__ ((__nothrow__)) __attribute__ ((__const));
>extern __const __int32_t **__ctype_tolower_loc (void)
>     __attribute__ ((__nothrow__)) __attribute__ ((__const));
>extern __const __int32_t **__ctype_toupper_loc (void)
>     __attribute__ ((__nothrow__)) __attribute__ ((__const));
># 96 "/usr/include/ctype.h" 3 4
>
>
>
>
>
>
>extern int isalnum (int) __attribute__ ((__nothrow__));
>extern int isalpha (int) __attribute__ ((__nothrow__));
>extern int iscntrl (int) __attribute__ ((__nothrow__));
>extern int isdigit (int) __attribute__ ((__nothrow__));
>extern int islower (int) __attribute__ ((__nothrow__));
>extern int isgraph (int) __attribute__ ((__nothrow__));
>extern int isprint (int) __attribute__ ((__nothrow__));
>extern int ispunct (int) __attribute__ ((__nothrow__));
>extern int isspace (int) __attribute__ ((__nothrow__));
>extern int isupper (int) __attribute__ ((__nothrow__));
>extern int isxdigit (int) __attribute__ ((__nothrow__));
>
>
>
>extern int tolower (int __c) __attribute__ ((__nothrow__));
>
>
>extern int toupper (int __c) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>
>extern int isblank (int) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern int isctype (int __c, int __mask) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern int isascii (int __c) __attribute__ ((__nothrow__));
>
>
>
>extern int toascii (int __c) __attribute__ ((__nothrow__));
>
>
>
>extern int _toupper (int) __attribute__ ((__nothrow__));
>extern int _tolower (int) __attribute__ ((__nothrow__));
># 190 "/usr/include/ctype.h" 3 4
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__nothrow__)) tolower (int __c)
>{
>  return __c >= -128 && __c < 256 ? (*__ctype_tolower_loc ())[__c] : __c;
>}
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__nothrow__)) toupper (int __c)
>{
>  return __c >= -128 && __c < 256 ? (*__ctype_toupper_loc ())[__c] : __c;
>}
># 233 "/usr/include/ctype.h" 3 4
># 1 "/usr/include/xlocale.h" 1 3 4
># 28 "/usr/include/xlocale.h" 3 4
>typedef struct __locale_struct
>{
>
>  struct locale_data *__locales[13];
>
>
>  const unsigned short int *__ctype_b;
>  const int *__ctype_tolower;
>  const int *__ctype_toupper;
>
>
>  const char *__names[13];
>} *__locale_t;
># 234 "/usr/include/ctype.h" 2 3 4
># 247 "/usr/include/ctype.h" 3 4
>extern int isalnum_l (int, __locale_t) __attribute__ ((__nothrow__));
>extern int isalpha_l (int, __locale_t) __attribute__ ((__nothrow__));
>extern int iscntrl_l (int, __locale_t) __attribute__ ((__nothrow__));
>extern int isdigit_l (int, __locale_t) __attribute__ ((__nothrow__));
>extern int islower_l (int, __locale_t) __attribute__ ((__nothrow__));
>extern int isgraph_l (int, __locale_t) __attribute__ ((__nothrow__));
>extern int isprint_l (int, __locale_t) __attribute__ ((__nothrow__));
>extern int ispunct_l (int, __locale_t) __attribute__ ((__nothrow__));
>extern int isspace_l (int, __locale_t) __attribute__ ((__nothrow__));
>extern int isupper_l (int, __locale_t) __attribute__ ((__nothrow__));
>extern int isxdigit_l (int, __locale_t) __attribute__ ((__nothrow__));
>
>extern int isblank_l (int, __locale_t) __attribute__ ((__nothrow__));
>
>
>
>extern int __tolower_l (int __c, __locale_t __l) __attribute__ ((__nothrow__));
>extern int tolower_l (int __c, __locale_t __l) __attribute__ ((__nothrow__));
>
>
>extern int __toupper_l (int __c, __locale_t __l) __attribute__ ((__nothrow__));
>extern int toupper_l (int __c, __locale_t __l) __attribute__ ((__nothrow__));
># 323 "/usr/include/ctype.h" 3 4
>
># 32 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c" 2
># 1 "/usr/include/dlfcn.h" 1 3 4
># 26 "/usr/include/dlfcn.h" 3 4
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 1 3 4
># 214 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 3 4
>typedef unsigned int size_t;
># 27 "/usr/include/dlfcn.h" 2 3 4
>
>
># 1 "/usr/include/bits/dlfcn.h" 1 3 4
># 58 "/usr/include/bits/dlfcn.h" 3 4
>
>
>
>extern void _dl_mcount_wrapper_check (void *__selfpc) __attribute__ ((__nothrow__));
>
>
># 30 "/usr/include/dlfcn.h" 2 3 4
># 46 "/usr/include/dlfcn.h" 3 4
>typedef long int Lmid_t;
>
>
>
>
>
>
>
>
>
>
>
>extern void *dlopen (__const char *__file, int __mode) __attribute__ ((__nothrow__));
>
>
>
>extern int dlclose (void *__handle) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern void *dlsym (void *__restrict __handle,
>      __const char *__restrict __name) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>extern void *dlmopen (Lmid_t __nsid, __const char *__file, int __mode) __attribute__ ((__nothrow__));
>
>
>
>extern void *dlvsym (void *__restrict __handle,
>       __const char *__restrict __name,
>       __const char *__restrict __version)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));
>
>
>
>
>
>extern char *dlerror (void) __attribute__ ((__nothrow__));
>
>
>
>
>
>typedef struct
>{
>  __const char *dli_fname;
>  void *dli_fbase;
>  __const char *dli_sname;
>  void *dli_saddr;
>} Dl_info;
>
>
>
>extern int dladdr (__const void *__address, Dl_info *__info)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>
>extern int dladdr1 (__const void *__address, Dl_info *__info,
>      void **__extra_info, int __flags) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>enum
>  {
>
>    RTLD_DL_SYMENT = 1,
>
>
>    RTLD_DL_LINKMAP = 2
>  };
>
>
>
>
>
>
>
>extern int dlinfo (void *__restrict __handle,
>     int __request, void *__restrict __arg)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 3)));
>
>
>enum
>  {
>
>    RTLD_DI_LMID = 1,
>
>
>
>    RTLD_DI_LINKMAP = 2,
>
>    RTLD_DI_CONFIGADDR = 3,
>
>
>
>
>
>
>    RTLD_DI_SERINFO = 4,
>    RTLD_DI_SERINFOSIZE = 5,
>
>
>
>    RTLD_DI_ORIGIN = 6,
>
>    RTLD_DI_PROFILENAME = 7,
>    RTLD_DI_PROFILEOUT = 8,
>
>
>
>
>    RTLD_DI_TLS_MODID = 9,
>
>
>
>
>
>    RTLD_DI_TLS_DATA = 10,
>
>    RTLD_DI_MAX = 10,
>  };
>
>
>
>
>typedef struct
>{
>  char *dls_name;
>  unsigned int dls_flags;
>} Dl_serpath;
>
>
>
>typedef struct
>{
>  size_t dls_size;
>  unsigned int dls_cnt;
>  Dl_serpath dls_serpath[1];
>} Dl_serinfo;
>
>
>
>
># 33 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c" 2
># 1 "/usr/include/errno.h" 1 3 4
># 32 "/usr/include/errno.h" 3 4
>
>
>
>
># 1 "/usr/include/bits/errno.h" 1 3 4
># 25 "/usr/include/bits/errno.h" 3 4
># 1 "/usr/include/linux/errno.h" 1 3 4
>
>
>
># 1 "/usr/include/asm/errno.h" 1 3 4
>
>
>
># 1 "/usr/include/asm-generic/errno.h" 1 3 4
>
>
>
># 1 "/usr/include/asm-generic/errno-base.h" 1 3 4
># 5 "/usr/include/asm-generic/errno.h" 2 3 4
># 5 "/usr/include/asm/errno.h" 2 3 4
># 5 "/usr/include/linux/errno.h" 2 3 4
># 26 "/usr/include/bits/errno.h" 2 3 4
># 43 "/usr/include/bits/errno.h" 3 4
>extern int *__errno_location (void) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
># 37 "/usr/include/errno.h" 2 3 4
># 55 "/usr/include/errno.h" 3 4
>extern char *program_invocation_name, *program_invocation_short_name;
>
>
>
>
># 69 "/usr/include/errno.h" 3 4
>typedef int error_t;
># 34 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c" 2
># 1 "/usr/include/error.h" 1 3 4
># 26 "/usr/include/error.h" 3 4
>
>
>
>
>
>
>extern void error (int __status, int __errnum, __const char *__format, ...)
>     __attribute__ ((__format__ (__printf__, 3, 4)));
>
>extern void error_at_line (int __status, int __errnum, __const char *__fname,
>      unsigned int __lineno, __const char *__format, ...)
>     __attribute__ ((__format__ (__printf__, 5, 6)));
>
>
>
>
>extern void (*error_print_progname) (void);
>
>
>extern unsigned int error_message_count;
>
>
>
>extern int error_one_per_line;
>
>
>
># 1 "/usr/include/bits/error.h" 1 3 4
># 25 "/usr/include/bits/error.h" 3 4
>extern void __error_alias (int __status, int __errnum, __const char *__format, ...) __asm__ ("" "error")
>
>
>  __attribute__ ((__format__ (__printf__, 3, 4)));
>extern void __error_noreturn (int __status, int __errnum, __const char *__format, ...) __asm__ ("" "error")
>
>
>  __attribute__ ((__noreturn__, __format__ (__printf__, 3, 4)));
>
>
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) void
>error (int __status, int __errnum, __const char *__format, ...)
>{
>  if (__builtin_constant_p (__status) && __status != 0)
>    __error_noreturn (__status, __errnum, __format, __builtin_va_arg_pack ());
>  else
>    __error_alias (__status, __errnum, __format, __builtin_va_arg_pack ());
>}
>
>
>extern void __error_at_line_alias (int __status, int __errnum, __const char *__fname, unsigned int __line, __const char *__format, ...) __asm__ ("" "error_at_line")
>
>
>
>
>  __attribute__ ((__format__ (__printf__, 5, 6)));
>extern void __error_at_line_noreturn (int __status, int __errnum, __const char *__fname, unsigned int __line, __const char *__format, ...) __asm__ ("" "error_at_line")
>
>
>
>
>
>  __attribute__ ((__noreturn__, __format__ (__printf__, 5, 6)));
>
>
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) void
>error_at_line (int __status, int __errnum, __const char *__fname,
>        unsigned int __line,__const char *__format, ...)
>{
>  if (__builtin_constant_p (__status) && __status != 0)
>    __error_at_line_noreturn (__status, __errnum, __fname, __line, __format,
>         __builtin_va_arg_pack ());
>  else
>    __error_at_line_alias (__status, __errnum, __fname, __line,
>      __format, __builtin_va_arg_pack ());
>}
># 54 "/usr/include/error.h" 2 3 4
>
>
>
># 35 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c" 2
># 1 "/usr/include/fcntl.h" 1 3 4
># 30 "/usr/include/fcntl.h" 3 4
>
>
>
>
># 1 "/usr/include/bits/fcntl.h" 1 3 4
># 25 "/usr/include/bits/fcntl.h" 3 4
># 1 "/usr/include/sys/types.h" 1 3 4
># 29 "/usr/include/sys/types.h" 3 4
>
>
>
>
>
>
>typedef __u_char u_char;
>typedef __u_short u_short;
>typedef __u_int u_int;
>typedef __u_long u_long;
>typedef __quad_t quad_t;
>typedef __u_quad_t u_quad_t;
>typedef __fsid_t fsid_t;
>
>
>
>
>typedef __loff_t loff_t;
>
>
>
>
>
>typedef __ino64_t ino_t;
>
>
>
>
>typedef __ino64_t ino64_t;
>
>
>
>
>typedef __dev_t dev_t;
>
>
>
>
>typedef __gid_t gid_t;
>
>
>
>
>typedef __mode_t mode_t;
>
>
>
>
>typedef __nlink_t nlink_t;
>
>
>
>
>typedef __uid_t uid_t;
>
>
>
>
>
>
>
>typedef __off64_t off_t;
>
>
>
>
>typedef __off64_t off64_t;
>
>
>
>
>typedef __pid_t pid_t;
>
>
>
>
>typedef __id_t id_t;
>
>
>
>
>typedef __ssize_t ssize_t;
>
>
>
>
>
>typedef __daddr_t daddr_t;
>typedef __caddr_t caddr_t;
>
>
>
>
>
>typedef __key_t key_t;
># 133 "/usr/include/sys/types.h" 3 4
># 1 "/usr/include/time.h" 1 3 4
># 59 "/usr/include/time.h" 3 4
>
>
>typedef __clock_t clock_t;
>
>
>
># 75 "/usr/include/time.h" 3 4
>
>
>typedef __time_t time_t;
>
>
>
># 93 "/usr/include/time.h" 3 4
>typedef __clockid_t clockid_t;
># 105 "/usr/include/time.h" 3 4
>typedef __timer_t timer_t;
># 134 "/usr/include/sys/types.h" 2 3 4
>
>
>
>typedef __useconds_t useconds_t;
>
>
>
>typedef __suseconds_t suseconds_t;
>
>
>
>
>
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 1 3 4
># 148 "/usr/include/sys/types.h" 2 3 4
>
>
>
>typedef unsigned long int ulong;
>typedef unsigned short int ushort;
>typedef unsigned int uint;
># 195 "/usr/include/sys/types.h" 3 4
>typedef int int8_t __attribute__ ((__mode__ (__QI__)));
>typedef int int16_t __attribute__ ((__mode__ (__HI__)));
>typedef int int32_t __attribute__ ((__mode__ (__SI__)));
>typedef int int64_t __attribute__ ((__mode__ (__DI__)));
>
>
>typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
>typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
>typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
>typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));
>
>typedef int register_t __attribute__ ((__mode__ (__word__)));
># 220 "/usr/include/sys/types.h" 3 4
># 1 "/usr/include/sys/select.h" 1 3 4
># 31 "/usr/include/sys/select.h" 3 4
># 1 "/usr/include/bits/select.h" 1 3 4
># 32 "/usr/include/sys/select.h" 2 3 4
>
>
># 1 "/usr/include/bits/sigset.h" 1 3 4
># 24 "/usr/include/bits/sigset.h" 3 4
>typedef int __sig_atomic_t;
>
>
>
>
>typedef struct
>  {
>    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
>  } __sigset_t;
># 35 "/usr/include/sys/select.h" 2 3 4
>
>
>
>typedef __sigset_t sigset_t;
>
>
>
>
>
># 1 "/usr/include/time.h" 1 3 4
># 121 "/usr/include/time.h" 3 4
>struct timespec
>  {
>    __time_t tv_sec;
>    long int tv_nsec;
>  };
># 45 "/usr/include/sys/select.h" 2 3 4
>
># 1 "/usr/include/bits/time.h" 1 3 4
># 69 "/usr/include/bits/time.h" 3 4
>struct timeval
>  {
>    __time_t tv_sec;
>    __suseconds_t tv_usec;
>  };
># 47 "/usr/include/sys/select.h" 2 3 4
># 55 "/usr/include/sys/select.h" 3 4
>typedef long int __fd_mask;
># 67 "/usr/include/sys/select.h" 3 4
>typedef struct
>  {
>
>
>
>    __fd_mask fds_bits[1024 / (8 * sizeof (__fd_mask))];
>
>
>
>
>
>  } fd_set;
>
>
>
>
>
>
>typedef __fd_mask fd_mask;
># 99 "/usr/include/sys/select.h" 3 4
>
># 109 "/usr/include/sys/select.h" 3 4
>extern int select (int __nfds, fd_set *__restrict __readfds,
>     fd_set *__restrict __writefds,
>     fd_set *__restrict __exceptfds,
>     struct timeval *__restrict __timeout);
># 121 "/usr/include/sys/select.h" 3 4
>extern int pselect (int __nfds, fd_set *__restrict __readfds,
>      fd_set *__restrict __writefds,
>      fd_set *__restrict __exceptfds,
>      const struct timespec *__restrict __timeout,
>      const __sigset_t *__restrict __sigmask);
>
>
>
># 221 "/usr/include/sys/types.h" 2 3 4
>
>
># 1 "/usr/include/sys/sysmacros.h" 1 3 4
># 30 "/usr/include/sys/sysmacros.h" 3 4
>__extension__
>extern unsigned int gnu_dev_major (unsigned long long int __dev)
>     __attribute__ ((__nothrow__));
>__extension__
>extern unsigned int gnu_dev_minor (unsigned long long int __dev)
>     __attribute__ ((__nothrow__));
>__extension__
>extern unsigned long long int gnu_dev_makedev (unsigned int __major,
>            unsigned int __minor)
>     __attribute__ ((__nothrow__));
>
>
>__extension__ extern __inline __attribute__ ((__gnu_inline__)) unsigned int
>__attribute__ ((__nothrow__)) gnu_dev_major (unsigned long long int __dev)
>{
>  return ((__dev >> 8) & 0xfff) | ((unsigned int) (__dev >> 32) & ~0xfff);
>}
>
>__extension__ extern __inline __attribute__ ((__gnu_inline__)) unsigned int
>__attribute__ ((__nothrow__)) gnu_dev_minor (unsigned long long int __dev)
>{
>  return (__dev & 0xff) | ((unsigned int) (__dev >> 12) & ~0xff);
>}
>
>__extension__ extern __inline __attribute__ ((__gnu_inline__)) unsigned long long int
>__attribute__ ((__nothrow__)) gnu_dev_makedev (unsigned int __major, unsigned int __minor)
>{
>  return ((__minor & 0xff) | ((__major & 0xfff) << 8)
>   | (((unsigned long long int) (__minor & ~0xff)) << 12)
>   | (((unsigned long long int) (__major & ~0xfff)) << 32));
>}
># 224 "/usr/include/sys/types.h" 2 3 4
>
>
>
>
>typedef __blksize_t blksize_t;
># 248 "/usr/include/sys/types.h" 3 4
>typedef __blkcnt64_t blkcnt_t;
>
>
>
>typedef __fsblkcnt64_t fsblkcnt_t;
>
>
>
>typedef __fsfilcnt64_t fsfilcnt_t;
>
>
>
>
>
>typedef __blkcnt64_t blkcnt64_t;
>typedef __fsblkcnt64_t fsblkcnt64_t;
>typedef __fsfilcnt64_t fsfilcnt64_t;
>
>
>
>
>
># 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
># 24 "/usr/include/bits/pthreadtypes.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 25 "/usr/include/bits/pthreadtypes.h" 2 3 4
># 51 "/usr/include/bits/pthreadtypes.h" 3 4
>typedef unsigned long int pthread_t;
>
>
>typedef union
>{
>  char __size[36];
>  long int __align;
>} pthread_attr_t;
># 68 "/usr/include/bits/pthreadtypes.h" 3 4
>typedef struct __pthread_internal_slist
>{
>  struct __pthread_internal_slist *__next;
>} __pthread_slist_t;
>
>
>
>
>
>typedef union
>{
>  struct __pthread_mutex_s
>  {
>    int __lock;
>    unsigned int __count;
>    int __owner;
>
>
>
>
>
>    int __kind;
>
>
>
>
>
>    unsigned int __nusers;
>    __extension__ union
>    {
>      int __spins;
>      __pthread_slist_t __list;
>    };
>
>  } __data;
>  char __size[24];
>  long int __align;
>} pthread_mutex_t;
>
>typedef union
>{
>  char __size[4];
>  int __align;
>} pthread_mutexattr_t;
>
>
>
>
>typedef union
>{
>  struct
>  {
>    int __lock;
>    unsigned int __futex;
>    __extension__ unsigned long long int __total_seq;
>    __extension__ unsigned long long int __wakeup_seq;
>    __extension__ unsigned long long int __woken_seq;
>    void *__mutex;
>    unsigned int __nwaiters;
>    unsigned int __broadcast_seq;
>  } __data;
>  char __size[48];
>  __extension__ long long int __align;
>} pthread_cond_t;
>
>typedef union
>{
>  char __size[4];
>  int __align;
>} pthread_condattr_t;
>
>
>
>typedef unsigned int pthread_key_t;
>
>
>
>typedef int pthread_once_t;
>
>
>
>
>
>typedef union
>{
># 171 "/usr/include/bits/pthreadtypes.h" 3 4
>  struct
>  {
>    int __lock;
>    unsigned int __nr_readers;
>    unsigned int __readers_wakeup;
>    unsigned int __writer_wakeup;
>    unsigned int __nr_readers_queued;
>    unsigned int __nr_writers_queued;
>    unsigned char __pad1;
>    unsigned char __pad2;
>    unsigned char __shared;
>
>
>    unsigned char __flags;
>    int __writer;
>  } __data;
>
>  char __size[32];
>  long int __align;
>} pthread_rwlock_t;
>
>typedef union
>{
>  char __size[8];
>  long int __align;
>} pthread_rwlockattr_t;
>
>
>
>
>
>typedef volatile int pthread_spinlock_t;
>
>
>
>
>typedef union
>{
>  char __size[20];
>  long int __align;
>} pthread_barrier_t;
>
>typedef union
>{
>  char __size[4];
>  int __align;
>} pthread_barrierattr_t;
># 271 "/usr/include/sys/types.h" 2 3 4
>
>
>
># 26 "/usr/include/bits/fcntl.h" 2 3 4
>
># 1 "/usr/include/bits/uio.h" 1 3 4
># 44 "/usr/include/bits/uio.h" 3 4
>struct iovec
>  {
>    void *iov_base;
>    size_t iov_len;
>  };
># 28 "/usr/include/bits/fcntl.h" 2 3 4
># 144 "/usr/include/bits/fcntl.h" 3 4
>struct flock
>  {
>    short int l_type;
>    short int l_whence;
>
>
>
>
>    __off64_t l_start;
>    __off64_t l_len;
>
>    __pid_t l_pid;
>  };
>
>
>struct flock64
>  {
>    short int l_type;
>    short int l_whence;
>    __off64_t l_start;
>    __off64_t l_len;
>    __pid_t l_pid;
>  };
># 211 "/usr/include/bits/fcntl.h" 3 4
>
>
>
>
>
>extern ssize_t readahead (int __fd, __off64_t __offset, size_t __count)
>    __attribute__ ((__nothrow__));
>
>
>
>extern int sync_file_range (int __fd, __off64_t __from, __off64_t __to,
>       unsigned int __flags);
>
>
>
>extern ssize_t vmsplice (int __fdout, const struct iovec *__iov,
>    size_t __count, unsigned int __flags);
>
>
>extern ssize_t splice (int __fdin, __off64_t *__offin, int __fdout,
>         __off64_t *__offout, size_t __len,
>         unsigned int __flags);
>
>
>extern ssize_t tee (int __fdin, int __fdout, size_t __len,
>      unsigned int __flags);
>
>
>
>
># 35 "/usr/include/fcntl.h" 2 3 4
>
>
>
># 1 "/usr/include/sys/stat.h" 1 3 4
># 39 "/usr/include/sys/stat.h" 3 4
># 1 "/usr/include/time.h" 1 3 4
># 40 "/usr/include/sys/stat.h" 2 3 4
># 105 "/usr/include/sys/stat.h" 3 4
>
>
># 1 "/usr/include/bits/stat.h" 1 3 4
># 24 "/usr/include/bits/stat.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 25 "/usr/include/bits/stat.h" 2 3 4
># 45 "/usr/include/bits/stat.h" 3 4
>struct stat
>  {
>    __dev_t st_dev;
>
>
>
>
>    __ino64_t st_ino;
>
>    __mode_t st_mode;
>    __nlink_t st_nlink;
>    __uid_t st_uid;
>    __gid_t st_gid;
>    __dev_t st_rdev;
>    unsigned short int __pad2;
>
>
>
>    __off64_t st_size;
>
>    __blksize_t st_blksize;
>
>
>
>
>    __blkcnt64_t st_blocks;
># 79 "/usr/include/bits/stat.h" 3 4
>    struct timespec st_atim;
>    struct timespec st_mtim;
>    struct timespec st_ctim;
># 93 "/usr/include/bits/stat.h" 3 4
>    unsigned long int __unused4;
>    unsigned long int __unused5;
>  };
>
>
>
>struct stat64
>  {
>    __dev_t st_dev;
>    __ino64_t st_ino;
>    __mode_t st_mode;
>    __nlink_t st_nlink;
>    __uid_t st_uid;
>    __gid_t st_gid;
>    __dev_t st_rdev;
>    unsigned short int __pad2;
>    __off64_t st_size;
>    __blksize_t st_blksize;
>    __blkcnt64_t st_blocks;
>
>
>
>
>
>
>
>    struct timespec st_atim;
>    struct timespec st_mtim;
>    struct timespec st_ctim;
># 133 "/usr/include/bits/stat.h" 3 4
>    unsigned long int __unused4;
>    unsigned long int __unused5;
>  };
># 108 "/usr/include/sys/stat.h" 2 3 4
># 217 "/usr/include/sys/stat.h" 3 4
>extern int stat (__const char *__restrict __file, struct stat *__restrict __buf) __asm__ ("" "stat64") __attribute__ ((__nothrow__))
>
>     __attribute__ ((__nonnull__ (1, 2)));
>extern int fstat (int __fd, struct stat *__buf) __asm__ ("" "fstat64") __attribute__ ((__nothrow__))
>     __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>
>extern int stat64 (__const char *__restrict __file,
>     struct stat64 *__restrict __buf) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>extern int fstat64 (int __fd, struct stat64 *__buf) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
># 243 "/usr/include/sys/stat.h" 3 4
>extern int fstatat (int __fd, __const char *__restrict __file, struct stat *__restrict __buf, int __flag) __asm__ ("" "fstatat64") __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));
># 252 "/usr/include/sys/stat.h" 3 4
>extern int fstatat64 (int __fd, __const char *__restrict __file,
>        struct stat64 *__restrict __buf, int __flag)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));
># 265 "/usr/include/sys/stat.h" 3 4
>extern int lstat (__const char *__restrict __file, struct stat *__restrict __buf) __asm__ ("" "lstat64") __attribute__ ((__nothrow__))
>
>
>     __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern int lstat64 (__const char *__restrict __file,
>      struct stat64 *__restrict __buf)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern int chmod (__const char *__file, __mode_t __mode)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int lchmod (__const char *__file, __mode_t __mode)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int fchmod (int __fd, __mode_t __mode) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern int fchmodat (int __fd, __const char *__file, __mode_t mode, int __flag)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2))) ;
>
>
>
>
>
>
>extern __mode_t umask (__mode_t __mask) __attribute__ ((__nothrow__));
>
>
>
>
>extern __mode_t getumask (void) __attribute__ ((__nothrow__));
>
>
>
>extern int mkdir (__const char *__path, __mode_t __mode)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int mkdirat (int __fd, __const char *__path, __mode_t __mode)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>
>extern int mknod (__const char *__path, __mode_t __mode, __dev_t __dev)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int mknodat (int __fd, __const char *__path, __mode_t __mode,
>      __dev_t __dev) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern int mkfifo (__const char *__path, __mode_t __mode)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int mkfifoat (int __fd, __const char *__path, __mode_t __mode)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>extern int utimensat (int __fd, __const char *__path,
>        __const struct timespec __times[2],
>        int __flags)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>extern int futimens (int __fd, __const struct timespec __times[2]) __attribute__ ((__nothrow__));
># 408 "/usr/include/sys/stat.h" 3 4
>extern int __fxstat (int __ver, int __fildes, struct stat *__stat_buf) __asm__ ("" "__fxstat64") __attribute__ ((__nothrow__))
>
>     __attribute__ ((__nonnull__ (3)));
>extern int __xstat (int __ver, __const char *__filename, struct stat *__stat_buf) __asm__ ("" "__xstat64") __attribute__ ((__nothrow__))
>
>     __attribute__ ((__nonnull__ (2, 3)));
>extern int __lxstat (int __ver, __const char *__filename, struct stat *__stat_buf) __asm__ ("" "__lxstat64") __attribute__ ((__nothrow__))
>
>     __attribute__ ((__nonnull__ (2, 3)));
>extern int __fxstatat (int __ver, int __fildes, __const char *__filename, struct stat *__stat_buf, int __flag) __asm__ ("" "__fxstatat64") __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4)));
># 430 "/usr/include/sys/stat.h" 3 4
>extern int __fxstat64 (int __ver, int __fildes, struct stat64 *__stat_buf)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3)));
>extern int __xstat64 (int __ver, __const char *__filename,
>        struct stat64 *__stat_buf) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));
>extern int __lxstat64 (int __ver, __const char *__filename,
>         struct stat64 *__stat_buf) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));
>extern int __fxstatat64 (int __ver, int __fildes, __const char *__filename,
>    struct stat64 *__stat_buf, int __flag)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4)));
>
>extern int __xmknod (int __ver, __const char *__path, __mode_t __mode,
>       __dev_t *__dev) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 4)));
>
>extern int __xmknodat (int __ver, int __fd, __const char *__path,
>         __mode_t __mode, __dev_t *__dev)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 5)));
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__nothrow__)) stat (__const char *__path, struct stat *__statbuf)
>{
>  return __xstat (3, __path, __statbuf);
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__nothrow__)) lstat (__const char *__path, struct stat *__statbuf)
>{
>  return __lxstat (3, __path, __statbuf);
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__nothrow__)) fstat (int __fd, struct stat *__statbuf)
>{
>  return __fxstat (3, __fd, __statbuf);
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__nothrow__)) fstatat (int __fd, __const char *__filename, struct stat *__statbuf, int __flag)
>
>{
>  return __fxstatat (3, __fd, __filename, __statbuf, __flag);
>}
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__nothrow__)) mknod (__const char *__path, __mode_t __mode, __dev_t __dev)
>{
>  return __xmknod (1, __path, __mode, &__dev);
>}
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__nothrow__)) mknodat (int __fd, __const char *__path, __mode_t __mode, __dev_t __dev)
>
>{
>  return __xmknodat (1, __fd, __path, __mode, &__dev);
>}
>
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__nothrow__)) stat64 (__const char *__path, struct stat64 *__statbuf)
>{
>  return __xstat64 (3, __path, __statbuf);
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__nothrow__)) lstat64 (__const char *__path, struct stat64 *__statbuf)
>{
>  return __lxstat64 (3, __path, __statbuf);
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__nothrow__)) fstat64 (int __fd, struct stat64 *__statbuf)
>{
>  return __fxstat64 (3, __fd, __statbuf);
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__nothrow__)) fstatat64 (int __fd, __const char *__filename, struct stat64 *__statbuf, int __flag)
>
>{
>  return __fxstatat64 (3, __fd, __filename, __statbuf, __flag);
>}
>
>
>
>
>
>
>
># 39 "/usr/include/fcntl.h" 2 3 4
># 76 "/usr/include/fcntl.h" 3 4
>extern int fcntl (int __fd, int __cmd, ...);
># 88 "/usr/include/fcntl.h" 3 4
>extern int open (__const char *__file, int __oflag, ...) __asm__ ("" "open64")
>     __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int open64 (__const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
># 113 "/usr/include/fcntl.h" 3 4
>extern int openat (int __fd, __const char *__file, int __oflag, ...) __asm__ ("" "openat64") __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>
>extern int openat64 (int __fd, __const char *__file, int __oflag, ...)
>     __attribute__ ((__nonnull__ (2)));
># 133 "/usr/include/fcntl.h" 3 4
>extern int creat (__const char *__file, __mode_t __mode) __asm__ ("" "creat64") __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int creat64 (__const char *__file, __mode_t __mode) __attribute__ ((__nonnull__ (1)));
># 162 "/usr/include/fcntl.h" 3 4
>extern int lockf (int __fd, int __cmd, __off64_t __len) __asm__ ("" "lockf64");
>
>
>
>
>
>extern int lockf64 (int __fd, int __cmd, __off64_t __len);
># 180 "/usr/include/fcntl.h" 3 4
>extern int posix_fadvise (int __fd, __off64_t __offset, __off64_t __len, int __advise) __asm__ ("" "posix_fadvise64") __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>extern int posix_fadvise64 (int __fd, __off64_t __offset, __off64_t __len,
>       int __advise) __attribute__ ((__nothrow__));
># 201 "/usr/include/fcntl.h" 3 4
>extern int posix_fallocate (int __fd, __off64_t __offset, __off64_t __len) __asm__ ("" "posix_fallocate64");
>
>
>
>
>
>
>
>extern int posix_fallocate64 (int __fd, __off64_t __offset, __off64_t __len);
># 220 "/usr/include/fcntl.h" 3 4
>
># 36 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c" 2
># 1 "/usr/include/fnmatch.h" 1 3 4
># 65 "/usr/include/fnmatch.h" 3 4
>extern int fnmatch (const char *__pattern, const char *__name,
>      int __flags);
># 37 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c" 2
># 1 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/gelf.h" 1
># 53 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/gelf.h"
># 1 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/libelf.h" 1
># 56 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/libelf.h"
># 1 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/elf.h" 1
># 26 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/elf.h"
>
>
>
>
># 1 "/usr/include/stdint.h" 1 3 4
># 27 "/usr/include/stdint.h" 3 4
># 1 "/usr/include/bits/wchar.h" 1 3 4
># 28 "/usr/include/stdint.h" 2 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 29 "/usr/include/stdint.h" 2 3 4
># 49 "/usr/include/stdint.h" 3 4
>typedef unsigned char uint8_t;
>typedef unsigned short int uint16_t;
>
>typedef unsigned int uint32_t;
>
>
>
>
>
>__extension__
>typedef unsigned long long int uint64_t;
>
>
>
>
>
>
>typedef signed char int_least8_t;
>typedef short int int_least16_t;
>typedef int int_least32_t;
>
>
>
>__extension__
>typedef long long int int_least64_t;
>
>
>
>typedef unsigned char uint_least8_t;
>typedef unsigned short int uint_least16_t;
>typedef unsigned int uint_least32_t;
>
>
>
>__extension__
>typedef unsigned long long int uint_least64_t;
>
>
>
>
>
>
>typedef signed char int_fast8_t;
>
>
>
>
>
>typedef int int_fast16_t;
>typedef int int_fast32_t;
>__extension__
>typedef long long int int_fast64_t;
>
>
>
>typedef unsigned char uint_fast8_t;
>
>
>
>
>
>typedef unsigned int uint_fast16_t;
>typedef unsigned int uint_fast32_t;
>__extension__
>typedef unsigned long long int uint_fast64_t;
># 126 "/usr/include/stdint.h" 3 4
>typedef int intptr_t;
>
>
>typedef unsigned int uintptr_t;
># 138 "/usr/include/stdint.h" 3 4
>__extension__
>typedef long long int intmax_t;
>__extension__
>typedef unsigned long long int uintmax_t;
># 31 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/elf.h" 2
>
>
>typedef uint16_t Elf32_Half;
>typedef uint16_t Elf64_Half;
>
>
>typedef uint32_t Elf32_Word;
>typedef int32_t Elf32_Sword;
>typedef uint32_t Elf64_Word;
>typedef int32_t Elf64_Sword;
>
>
>typedef uint64_t Elf32_Xword;
>typedef int64_t Elf32_Sxword;
>typedef uint64_t Elf64_Xword;
>typedef int64_t Elf64_Sxword;
>
>
>typedef uint32_t Elf32_Addr;
>typedef uint64_t Elf64_Addr;
>
>
>typedef uint32_t Elf32_Off;
>typedef uint64_t Elf64_Off;
>
>
>typedef uint16_t Elf32_Section;
>typedef uint16_t Elf64_Section;
>
>
>typedef Elf32_Half Elf32_Versym;
>typedef Elf64_Half Elf64_Versym;
>
>
>
>
>
>
>typedef struct
>{
>  unsigned char e_ident[(16)];
>  Elf32_Half e_type;
>  Elf32_Half e_machine;
>  Elf32_Word e_version;
>  Elf32_Addr e_entry;
>  Elf32_Off e_phoff;
>  Elf32_Off e_shoff;
>  Elf32_Word e_flags;
>  Elf32_Half e_ehsize;
>  Elf32_Half e_phentsize;
>  Elf32_Half e_phnum;
>  Elf32_Half e_shentsize;
>  Elf32_Half e_shnum;
>  Elf32_Half e_shstrndx;
>} Elf32_Ehdr;
>
>typedef struct
>{
>  unsigned char e_ident[(16)];
>  Elf64_Half e_type;
>  Elf64_Half e_machine;
>  Elf64_Word e_version;
>  Elf64_Addr e_entry;
>  Elf64_Off e_phoff;
>  Elf64_Off e_shoff;
>  Elf64_Word e_flags;
>  Elf64_Half e_ehsize;
>  Elf64_Half e_phentsize;
>  Elf64_Half e_phnum;
>  Elf64_Half e_shentsize;
>  Elf64_Half e_shnum;
>  Elf64_Half e_shstrndx;
>} Elf64_Ehdr;
># 268 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/elf.h"
>typedef struct
>{
>  Elf32_Word sh_name;
>  Elf32_Word sh_type;
>  Elf32_Word sh_flags;
>  Elf32_Addr sh_addr;
>  Elf32_Off sh_offset;
>  Elf32_Word sh_size;
>  Elf32_Word sh_link;
>  Elf32_Word sh_info;
>  Elf32_Word sh_addralign;
>  Elf32_Word sh_entsize;
>} Elf32_Shdr;
>
>typedef struct
>{
>  Elf64_Word sh_name;
>  Elf64_Word sh_type;
>  Elf64_Xword sh_flags;
>  Elf64_Addr sh_addr;
>  Elf64_Off sh_offset;
>  Elf64_Xword sh_size;
>  Elf64_Word sh_link;
>  Elf64_Word sh_info;
>  Elf64_Xword sh_addralign;
>  Elf64_Xword sh_entsize;
>} Elf64_Shdr;
># 376 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/elf.h"
>typedef struct
>{
>  Elf32_Word st_name;
>  Elf32_Addr st_value;
>  Elf32_Word st_size;
>  unsigned char st_info;
>  unsigned char st_other;
>  Elf32_Section st_shndx;
>} Elf32_Sym;
>
>typedef struct
>{
>  Elf64_Word st_name;
>  unsigned char st_info;
>  unsigned char st_other;
>  Elf64_Section st_shndx;
>  Elf64_Addr st_value;
>  Elf64_Xword st_size;
>} Elf64_Sym;
>
>
>
>
>typedef struct
>{
>  Elf32_Half si_boundto;
>  Elf32_Half si_flags;
>} Elf32_Syminfo;
>
>typedef struct
>{
>  Elf64_Half si_boundto;
>  Elf64_Half si_flags;
>} Elf64_Syminfo;
># 489 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/elf.h"
>typedef struct
>{
>  Elf32_Addr r_offset;
>  Elf32_Word r_info;
>} Elf32_Rel;
>
>
>
>
>
>
>typedef struct
>{
>  Elf64_Addr r_offset;
>  Elf64_Xword r_info;
>} Elf64_Rel;
>
>
>
>typedef struct
>{
>  Elf32_Addr r_offset;
>  Elf32_Word r_info;
>  Elf32_Sword r_addend;
>} Elf32_Rela;
>
>typedef struct
>{
>  Elf64_Addr r_offset;
>  Elf64_Xword r_info;
>  Elf64_Sxword r_addend;
>} Elf64_Rela;
># 534 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/elf.h"
>typedef struct
>{
>  Elf32_Word p_type;
>  Elf32_Off p_offset;
>  Elf32_Addr p_vaddr;
>  Elf32_Addr p_paddr;
>  Elf32_Word p_filesz;
>  Elf32_Word p_memsz;
>  Elf32_Word p_flags;
>  Elf32_Word p_align;
>} Elf32_Phdr;
>
>typedef struct
>{
>  Elf64_Word p_type;
>  Elf64_Word p_flags;
>  Elf64_Off p_offset;
>  Elf64_Addr p_vaddr;
>  Elf64_Addr p_paddr;
>  Elf64_Xword p_filesz;
>  Elf64_Xword p_memsz;
>  Elf64_Xword p_align;
>} Elf64_Phdr;
># 619 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/elf.h"
>typedef struct
>{
>  Elf32_Sword d_tag;
>  union
>    {
>      Elf32_Word d_val;
>      Elf32_Addr d_ptr;
>    } d_un;
>} Elf32_Dyn;
>
>typedef struct
>{
>  Elf64_Sxword d_tag;
>  union
>    {
>      Elf64_Xword d_val;
>      Elf64_Addr d_ptr;
>    } d_un;
>} Elf64_Dyn;
># 786 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/elf.h"
>typedef struct
>{
>  Elf32_Half vd_version;
>  Elf32_Half vd_flags;
>  Elf32_Half vd_ndx;
>  Elf32_Half vd_cnt;
>  Elf32_Word vd_hash;
>  Elf32_Word vd_aux;
>  Elf32_Word vd_next;
>
>} Elf32_Verdef;
>
>typedef struct
>{
>  Elf64_Half vd_version;
>  Elf64_Half vd_flags;
>  Elf64_Half vd_ndx;
>  Elf64_Half vd_cnt;
>  Elf64_Word vd_hash;
>  Elf64_Word vd_aux;
>  Elf64_Word vd_next;
>
>} Elf64_Verdef;
># 828 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/elf.h"
>typedef struct
>{
>  Elf32_Word vda_name;
>  Elf32_Word vda_next;
>
>} Elf32_Verdaux;
>
>typedef struct
>{
>  Elf64_Word vda_name;
>  Elf64_Word vda_next;
>
>} Elf64_Verdaux;
>
>
>
>
>typedef struct
>{
>  Elf32_Half vn_version;
>  Elf32_Half vn_cnt;
>  Elf32_Word vn_file;
>
>  Elf32_Word vn_aux;
>  Elf32_Word vn_next;
>
>} Elf32_Verneed;
>
>typedef struct
>{
>  Elf64_Half vn_version;
>  Elf64_Half vn_cnt;
>  Elf64_Word vn_file;
>
>  Elf64_Word vn_aux;
>  Elf64_Word vn_next;
>
>} Elf64_Verneed;
># 875 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/elf.h"
>typedef struct
>{
>  Elf32_Word vna_hash;
>  Elf32_Half vna_flags;
>  Elf32_Half vna_other;
>  Elf32_Word vna_name;
>  Elf32_Word vna_next;
>
>} Elf32_Vernaux;
>
>typedef struct
>{
>  Elf64_Word vna_hash;
>  Elf64_Half vna_flags;
>  Elf64_Half vna_other;
>  Elf64_Word vna_name;
>  Elf64_Word vna_next;
>
>} Elf64_Vernaux;
># 909 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/elf.h"
>typedef struct
>{
>  uint32_t a_type;
>  union
>    {
>      uint32_t a_val;
>
>
>
>    } a_un;
>} Elf32_auxv_t;
>
>typedef struct
>{
>  uint64_t a_type;
>  union
>    {
>      uint64_t a_val;
>
>
>
>    } a_un;
>} Elf64_auxv_t;
># 987 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/elf.h"
>typedef struct
>{
>  Elf32_Word n_namesz;
>  Elf32_Word n_descsz;
>  Elf32_Word n_type;
>} Elf32_Nhdr;
>
>typedef struct
>{
>  Elf64_Word n_namesz;
>  Elf64_Word n_descsz;
>  Elf64_Word n_type;
>} Elf64_Nhdr;
># 1048 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/elf.h"
>typedef struct
>{
>  Elf32_Xword m_value;
>  Elf32_Word m_info;
>  Elf32_Word m_poffset;
>  Elf32_Half m_repeat;
>  Elf32_Half m_stride;
>} Elf32_Move;
>
>typedef struct
>{
>  Elf64_Xword m_value;
>  Elf64_Xword m_info;
>  Elf64_Xword m_poffset;
>  Elf64_Half m_repeat;
>  Elf64_Half m_stride;
>} Elf64_Move;
># 1395 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/elf.h"
>typedef union
>{
>  struct
>    {
>      Elf32_Word gt_current_g_value;
>      Elf32_Word gt_unused;
>    } gt_header;
>  struct
>    {
>      Elf32_Word gt_g_value;
>      Elf32_Word gt_bytes;
>    } gt_entry;
>} Elf32_gptab;
>
>
>
>typedef struct
>{
>  Elf32_Word ri_gprmask;
>  Elf32_Word ri_cprmask[4];
>  Elf32_Sword ri_gp_value;
>} Elf32_RegInfo;
>
>
>
>typedef struct
>{
>  unsigned char kind;
>
>  unsigned char size;
>  Elf32_Section section;
>
>  Elf32_Word info;
>} Elf_Options;
># 1471 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/elf.h"
>typedef struct
>{
>  Elf32_Word hwp_flags1;
>  Elf32_Word hwp_flags2;
>} Elf_Options_Hw;
># 1624 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/elf.h"
>typedef struct
>{
>  Elf32_Word l_name;
>  Elf32_Word l_time_stamp;
>  Elf32_Word l_checksum;
>  Elf32_Word l_version;
>  Elf32_Word l_flags;
>} Elf32_Lib;
>
>typedef struct
>{
>  Elf64_Word l_name;
>  Elf64_Word l_time_stamp;
>  Elf64_Word l_checksum;
>  Elf64_Word l_version;
>  Elf64_Word l_flags;
>} Elf64_Lib;
># 1655 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/elf.h"
>typedef Elf32_Addr Elf32_Conflict;
># 2648 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/elf.h"
>
># 57 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/libelf.h" 2
>
>
>
>typedef enum
>{
>  ELF_T_BYTE,
>  ELF_T_ADDR,
>  ELF_T_DYN,
>  ELF_T_EHDR,
>  ELF_T_HALF,
>  ELF_T_OFF,
>  ELF_T_PHDR,
>  ELF_T_RELA,
>  ELF_T_REL,
>  ELF_T_SHDR,
>  ELF_T_SWORD,
>  ELF_T_SYM,
>  ELF_T_WORD,
>  ELF_T_XWORD,
>  ELF_T_SXWORD,
>  ELF_T_VDEF,
>  ELF_T_VDAUX,
>  ELF_T_VNEED,
>  ELF_T_VNAUX,
>  ELF_T_NHDR,
>  ELF_T_SYMINFO,
>  ELF_T_MOVE,
>  ELF_T_LIB,
>  ELF_T_GNUHASH,
>  ELF_T_AUXV,
>
>  ELF_T_NUM
>} Elf_Type;
>
>
>typedef struct
>{
>  void *d_buf;
>  Elf_Type d_type;
>  unsigned int d_version;
>  size_t d_size;
>  loff_t d_off;
>  size_t d_align;
>} Elf_Data;
>
>
>
>typedef enum
>{
>  ELF_C_NULL,
>  ELF_C_READ,
>  ELF_C_RDWR,
>  ELF_C_WRITE,
>  ELF_C_CLR,
>  ELF_C_SET,
>  ELF_C_FDDONE,
>
>  ELF_C_FDREAD,
>
>
>  ELF_C_READ_MMAP,
>  ELF_C_RDWR_MMAP,
>  ELF_C_WRITE_MMAP,
>  ELF_C_READ_MMAP_PRIVATE,
>
>  ELF_C_EMPTY,
>
>  ELF_C_NUM
>} Elf_Cmd;
>
>
>
>enum
>{
>  ELF_F_DIRTY = 0x1,
>
>  ELF_F_LAYOUT = 0x4,
>
>  ELF_F_PERMISSIVE = 0x8
>
>};
>
>
>
>typedef enum
>{
>  ELF_K_NONE,
>  ELF_K_AR,
>  ELF_K_COFF,
>  ELF_K_ELF,
>
>  ELF_K_NUM
>} Elf_Kind;
>
>
>
>typedef struct
>{
>  char *ar_name;
>  time_t ar_date;
>  uid_t ar_uid;
>  gid_t ar_gid;
>  mode_t ar_mode;
>  loff_t ar_size;
>  char *ar_rawname;
>} Elf_Arhdr;
>
>
>
>typedef struct
>{
>  char *as_name;
>  size_t as_off;
>  unsigned long int as_hash;
>} Elf_Arsym;
>
>
>
>typedef struct Elf Elf;
>
>
>typedef struct Elf_Scn Elf_Scn;
>
>
>
>
>
>
>
>extern Elf *elf_begin (int __fildes, Elf_Cmd __cmd, Elf *__ref);
>
>
>  extern Elf *elf_clone (Elf *__elf, Elf_Cmd __cmd);
>
>
>extern Elf *elf_memory (char *__image, size_t __size);
>
>
>extern Elf_Cmd elf_next (Elf *__elf);
>
>
>extern int elf_end (Elf *__elf);
>
>
>extern loff_t elf_update (Elf *__elf, Elf_Cmd __cmd);
>
>
>extern Elf_Kind elf_kind (Elf *__elf) __attribute__ ((__pure__));
>
>
>extern loff_t elf_getbase (Elf *__elf);
>
>
>
>extern char *elf_getident (Elf *__elf, size_t *__nbytes);
>
>
>extern Elf32_Ehdr *elf32_getehdr (Elf *__elf);
>
>extern Elf64_Ehdr *elf64_getehdr (Elf *__elf);
>
>
>extern Elf32_Ehdr *elf32_newehdr (Elf *__elf);
>
>extern Elf64_Ehdr *elf64_newehdr (Elf *__elf);
>
>
>extern Elf32_Phdr *elf32_getphdr (Elf *__elf);
>
>extern Elf64_Phdr *elf64_getphdr (Elf *__elf);
>
>
>extern Elf32_Phdr *elf32_newphdr (Elf *__elf, size_t __cnt);
>
>extern Elf64_Phdr *elf64_newphdr (Elf *__elf, size_t __cnt);
>
>
>
>extern Elf_Scn *elf_getscn (Elf *__elf, size_t __index);
>
>
>extern Elf_Scn *elf32_offscn (Elf *__elf, Elf32_Off __offset);
>
>extern Elf_Scn *elf64_offscn (Elf *__elf, Elf64_Off __offset);
>
>
>extern size_t elf_ndxscn (Elf_Scn *__scn);
>
>
>extern Elf_Scn *elf_nextscn (Elf *__elf, Elf_Scn *__scn);
>
>
>extern Elf_Scn *elf_newscn (Elf *__elf);
>
>
>
>extern int elf_scnshndx (Elf_Scn *__scn);
>
>
>
>
>
>extern int elf_getshnum (Elf *__elf, size_t *__dst);
>
>
>
>
>
>
>extern int elf_getshstrndx (Elf *__elf, size_t *__dst);
>
>
>
>extern Elf32_Shdr *elf32_getshdr (Elf_Scn *__scn);
>
>extern Elf64_Shdr *elf64_getshdr (Elf_Scn *__scn);
>
>
>
>extern unsigned int elf_flagelf (Elf *__elf, Elf_Cmd __cmd,
>     unsigned int __flags);
>
>extern unsigned int elf_flagehdr (Elf *__elf, Elf_Cmd __cmd,
>      unsigned int __flags);
>
>extern unsigned int elf_flagphdr (Elf *__elf, Elf_Cmd __cmd,
>      unsigned int __flags);
>
>extern unsigned int elf_flagscn (Elf_Scn *__scn, Elf_Cmd __cmd,
>     unsigned int __flags);
>
>extern unsigned int elf_flagdata (Elf_Data *__data, Elf_Cmd __cmd,
>      unsigned int __flags);
>
>extern unsigned int elf_flagshdr (Elf_Scn *__scn, Elf_Cmd __cmd,
>      unsigned int __flags);
>
>
>
>
>extern Elf_Data *elf_getdata (Elf_Scn *__scn, Elf_Data *__data);
>
>
>extern Elf_Data *elf_rawdata (Elf_Scn *__scn, Elf_Data *__data);
>
>
>extern Elf_Data *elf_newdata (Elf_Scn *__scn);
>
>
>
>
>extern Elf_Data *elf_getdata_rawchunk (Elf *__elf,
>           loff_t __offset, size_t __size,
>           Elf_Type __type);
>
>
>
>extern char *elf_strptr (Elf *__elf, size_t __index, size_t __offset);
>
>
>
>extern Elf_Arhdr *elf_getarhdr (Elf *__elf);
>
>
>extern loff_t elf_getaroff (Elf *__elf);
>
>
>extern size_t elf_rand (Elf *__elf, size_t __offset);
>
>
>extern Elf_Arsym *elf_getarsym (Elf *__elf, size_t *__narsyms);
>
>
>
>extern int elf_cntl (Elf *__elf, Elf_Cmd __cmd);
>
>
>extern char *elf_rawfile (Elf *__elf, size_t *__nbytes);
>
>
>
>
>
>extern size_t elf32_fsize (Elf_Type __type, size_t __count,
>      unsigned int __version)
>       __attribute__ ((__const__));
>
>extern size_t elf64_fsize (Elf_Type __type, size_t __count,
>      unsigned int __version)
>       __attribute__ ((__const__));
>
>
>
>
>extern Elf_Data *elf32_xlatetom (Elf_Data *__dest, const Elf_Data *__src,
>     unsigned int __encode);
>
>extern Elf_Data *elf64_xlatetom (Elf_Data *__dest, const Elf_Data *__src,
>     unsigned int __encode);
>
>
>
>extern Elf_Data *elf32_xlatetof (Elf_Data *__dest, const Elf_Data *__src,
>     unsigned int __encode);
>
>extern Elf_Data *elf64_xlatetof (Elf_Data *__dest, const Elf_Data *__src,
>     unsigned int __encode);
>
>
>
>
>extern int elf_errno (void);
>
>
>
>
>
>extern const char *elf_errmsg (int __error);
>
>
>
>extern unsigned int elf_version (unsigned int __version);
>
>
>extern void elf_fill (int __fill);
>
>
>extern unsigned long int elf_hash (const char *__string)
>       __attribute__ ((__pure__));
>
>
>extern unsigned long int elf_gnu_hash (const char *__string)
>       __attribute__ ((__pure__));
>
>
>
>extern long int elf32_checksum (Elf *__elf);
>
>extern long int elf64_checksum (Elf *__elf);
># 54 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/gelf.h" 2
># 65 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/gelf.h"
>typedef Elf64_Half GElf_Half;
>
>
>typedef Elf64_Word GElf_Word;
>typedef Elf64_Sword GElf_Sword;
>
>
>typedef Elf64_Xword GElf_Xword;
>typedef Elf64_Sxword GElf_Sxword;
>
>
>typedef Elf64_Addr GElf_Addr;
>
>
>typedef Elf64_Off GElf_Off;
>
>
>
>typedef Elf64_Ehdr GElf_Ehdr;
>
>
>typedef Elf64_Shdr GElf_Shdr;
>
>
>
>
>typedef Elf64_Section GElf_Section;
>
>
>typedef Elf64_Sym GElf_Sym;
>
>
>
>typedef Elf64_Syminfo GElf_Syminfo;
>
>
>typedef Elf64_Rel GElf_Rel;
>
>
>typedef Elf64_Rela GElf_Rela;
>
>
>typedef Elf64_Phdr GElf_Phdr;
>
>
>typedef Elf64_Dyn GElf_Dyn;
>
>
>
>typedef Elf64_Verdef GElf_Verdef;
>
>
>typedef Elf64_Verdaux GElf_Verdaux;
>
>
>typedef Elf64_Verneed GElf_Verneed;
>
>
>typedef Elf64_Vernaux GElf_Vernaux;
>
>
>
>typedef Elf64_Versym GElf_Versym;
>
>
>
>typedef Elf64_auxv_t GElf_auxv_t;
>
>
>
>typedef Elf64_Nhdr GElf_Nhdr;
>
>
>
>typedef Elf64_Move GElf_Move;
>
>
>
>typedef Elf64_Lib GElf_Lib;
># 171 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/gelf.h"
>extern int gelf_getclass (Elf *__elf);
>
>
>
>
>
>extern size_t gelf_fsize (Elf *__elf, Elf_Type __type, size_t __count,
>     unsigned int __version);
>
>
>extern GElf_Ehdr *gelf_getehdr (Elf *__elf, GElf_Ehdr *__dest);
>
>
>extern int gelf_update_ehdr (Elf *__elf, GElf_Ehdr *__src);
>
>
>extern unsigned long int gelf_newehdr (Elf *__elf, int __class);
>
>
>extern Elf_Scn *gelf_offscn (Elf *__elf, GElf_Off __offset);
>
>
>extern GElf_Shdr *gelf_getshdr (Elf_Scn *__scn, GElf_Shdr *__dst);
>
>
>extern int gelf_update_shdr (Elf_Scn *__scn, GElf_Shdr *__src);
>
>
>extern GElf_Phdr *gelf_getphdr (Elf *__elf, int __ndx, GElf_Phdr *__dst);
>
>
>extern int gelf_update_phdr (Elf *__elf, int __ndx, GElf_Phdr *__src);
>
>
>extern unsigned long int gelf_newphdr (Elf *__elf, size_t __phnum);
>
>
>
>
>extern Elf_Data *gelf_xlatetom (Elf *__elf, Elf_Data *__dest,
>    const Elf_Data *__src, unsigned int __encode);
>
>
>
>extern Elf_Data *gelf_xlatetof (Elf *__elf, Elf_Data *__dest,
>    const Elf_Data *__src, unsigned int __encode);
>
>
>
>extern GElf_Rel *gelf_getrel (Elf_Data *__data, int __ndx, GElf_Rel *__dst);
>
>
>extern GElf_Rela *gelf_getrela (Elf_Data *__data, int __ndx, GElf_Rela *__dst);
>
>
>extern int gelf_update_rel (Elf_Data *__dst, int __ndx, GElf_Rel *__src);
>
>
>extern int gelf_update_rela (Elf_Data *__dst, int __ndx, GElf_Rela *__src);
>
>
>
>extern GElf_Sym *gelf_getsym (Elf_Data *__data, int __ndx, GElf_Sym *__dst);
>
>
>extern int gelf_update_sym (Elf_Data *__data, int __ndx, GElf_Sym *__src);
>
>
>
>
>extern GElf_Sym *gelf_getsymshndx (Elf_Data *__symdata, Elf_Data *__shndxdata,
>       int __ndx, GElf_Sym *__sym,
>       Elf32_Word *__xshndx);
>
>
>
>extern int gelf_update_symshndx (Elf_Data *__symdata, Elf_Data *__shndxdata,
>     int __ndx, GElf_Sym *__sym,
>     Elf32_Word __xshndx);
>
>
>
>
>extern GElf_Syminfo *gelf_getsyminfo (Elf_Data *__data, int __ndx,
>          GElf_Syminfo *__dst);
>
>
>
>extern int gelf_update_syminfo (Elf_Data *__data, int __ndx,
>    GElf_Syminfo *__src);
>
>
>
>extern GElf_Dyn *gelf_getdyn (Elf_Data *__data, int __ndx, GElf_Dyn *__dst);
>
>
>extern int gelf_update_dyn (Elf_Data *__dst, int __ndx, GElf_Dyn *__src);
>
>
>
>extern GElf_Move *gelf_getmove (Elf_Data *__data, int __ndx, GElf_Move *__dst);
>
>
>extern int gelf_update_move (Elf_Data *__data, int __ndx,
>        GElf_Move *__src);
>
>
>
>extern GElf_Lib *gelf_getlib (Elf_Data *__data, int __ndx, GElf_Lib *__dst);
>
>
>extern int gelf_update_lib (Elf_Data *__data, int __ndx, GElf_Lib *__src);
>
>
>
>
>extern GElf_Versym *gelf_getversym (Elf_Data *__data, int __ndx,
>        GElf_Versym *__dst);
>
>
>extern int gelf_update_versym (Elf_Data *__data, int __ndx,
>          GElf_Versym *__src);
>
>
>
>extern GElf_Verneed *gelf_getverneed (Elf_Data *__data, int __offset,
>          GElf_Verneed *__dst);
>
>
>extern int gelf_update_verneed (Elf_Data *__data, int __offset,
>    GElf_Verneed *__src);
>
>
>extern GElf_Vernaux *gelf_getvernaux (Elf_Data *__data, int __offset,
>          GElf_Vernaux *__dst);
>
>
>extern int gelf_update_vernaux (Elf_Data *__data, int __offset,
>    GElf_Vernaux *__src);
>
>
>
>extern GElf_Verdef *gelf_getverdef (Elf_Data *__data, int __offset,
>        GElf_Verdef *__dst);
>
>
>extern int gelf_update_verdef (Elf_Data *__data, int __offset,
>          GElf_Verdef *__src);
>
>
>
>extern GElf_Verdaux *gelf_getverdaux (Elf_Data *__data, int __offset,
>          GElf_Verdaux *__dst);
>
>
>extern int gelf_update_verdaux (Elf_Data *__data, int __offset,
>    GElf_Verdaux *__src);
>
>
>
>extern GElf_auxv_t *gelf_getauxv (Elf_Data *__data, int __ndx,
>      GElf_auxv_t *__dst);
>
>
>extern int gelf_update_auxv (Elf_Data *__data, int __ndx, GElf_auxv_t *__src);
>
>
>
>
>
>extern size_t gelf_getnote (Elf_Data *__data, size_t __offset,
>       GElf_Nhdr *__result,
>       size_t *__name_offset, size_t *__desc_offset);
>
>
>
>extern long int gelf_checksum (Elf *__elf);
># 38 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c" 2
># 1 "/usr/include/inttypes.h" 1 3 4
># 35 "/usr/include/inttypes.h" 3 4
>typedef long int __gwchar_t;
># 274 "/usr/include/inttypes.h" 3 4
>
># 288 "/usr/include/inttypes.h" 3 4
>typedef struct
>  {
>    long long int quot;
>    long long int rem;
>  } imaxdiv_t;
>
>
>
>
>
>extern intmax_t imaxabs (intmax_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern imaxdiv_t imaxdiv (intmax_t __numer, intmax_t __denom)
>      __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern intmax_t strtoimax (const char *__restrict __nptr,
>      char **__restrict __endptr, int __base) __attribute__ ((__nothrow__));
>
>
>extern uintmax_t strtoumax (const char *__restrict __nptr,
>       char ** __restrict __endptr, int __base) __attribute__ ((__nothrow__));
>
>
>extern intmax_t wcstoimax (const __gwchar_t *__restrict __nptr,
>      __gwchar_t **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__));
>
>
>extern uintmax_t wcstoumax (const __gwchar_t *__restrict __nptr,
>       __gwchar_t ** __restrict __endptr, int __base)
>     __attribute__ ((__nothrow__));
># 379 "/usr/include/inttypes.h" 3 4
>__extension__
>extern long long int __strtoll_internal (const char *__restrict __nptr,
>      char **__restrict __endptr,
>      int __base, int __group)
>  __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>extern __inline __attribute__ ((__gnu_inline__)) intmax_t
>__attribute__ ((__nothrow__)) strtoimax (const char *__restrict nptr, char **__restrict endptr, int base)
>
>{
>  return __strtoll_internal (nptr, endptr, base, 0);
>}
>
>__extension__
>extern unsigned long long int __strtoull_internal (const char *
>         __restrict __nptr,
>         char **
>         __restrict __endptr,
>         int __base,
>         int __group)
>  __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>extern __inline __attribute__ ((__gnu_inline__)) uintmax_t
>__attribute__ ((__nothrow__)) strtoumax (const char *__restrict nptr, char **__restrict endptr, int base)
>
>{
>  return __strtoull_internal (nptr, endptr, base, 0);
>}
>
>__extension__
>extern long long int __wcstoll_internal (const __gwchar_t *
>      __restrict __nptr,
>      __gwchar_t **__restrict __endptr,
>      int __base, int __group)
>  __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>extern __inline __attribute__ ((__gnu_inline__)) intmax_t
>__attribute__ ((__nothrow__)) wcstoimax (const __gwchar_t *__restrict nptr, __gwchar_t **__restrict endptr, int base)
>
>{
>  return __wcstoll_internal (nptr, endptr, base, 0);
>}
>
>
>__extension__
>extern unsigned long long int __wcstoull_internal (const __gwchar_t *
>         __restrict __nptr,
>         __gwchar_t **
>         __restrict __endptr,
>         int __base,
>         int __group)
>  __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>extern __inline __attribute__ ((__gnu_inline__)) uintmax_t
>__attribute__ ((__nothrow__)) wcstoumax (const __gwchar_t *__restrict nptr, __gwchar_t **__restrict endptr, int base)
>
>{
>  return __wcstoull_internal (nptr, endptr, base, 0);
>}
>
>
>
>
>
># 39 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c" 2
># 1 "/usr/include/libintl.h" 1 3 4
># 35 "/usr/include/libintl.h" 3 4
>
>
>
>
>
>extern char *gettext (const char *__msgid)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format_arg__ (1)));
>
>
>
>extern char *dgettext (const char *__domainname, const char *__msgid)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format_arg__ (2)));
>extern char *__dgettext (const char *__domainname, const char *__msgid)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format_arg__ (2)));
>
>
>
>extern char *dcgettext (const char *__domainname,
>   const char *__msgid, int __category)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format_arg__ (2)));
>extern char *__dcgettext (const char *__domainname,
>     const char *__msgid, int __category)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format_arg__ (2)));
>
>
>
>
>extern char *ngettext (const char *__msgid1, const char *__msgid2,
>         unsigned long int __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format_arg__ (1))) __attribute__ ((__format_arg__ (2)));
>
>
>
>extern char *dngettext (const char *__domainname, const char *__msgid1,
>   const char *__msgid2, unsigned long int __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));
>
>
>
>extern char *dcngettext (const char *__domainname, const char *__msgid1,
>    const char *__msgid2, unsigned long int __n,
>    int __category)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));
>
>
>
>
>
>extern char *textdomain (const char *__domainname) __attribute__ ((__nothrow__));
>
>
>
>extern char *bindtextdomain (const char *__domainname,
>        const char *__dirname) __attribute__ ((__nothrow__));
>
>
>
>extern char *bind_textdomain_codeset (const char *__domainname,
>          const char *__codeset) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 1 3 4
># 102 "/usr/include/libintl.h" 2 3 4
>
>
># 1 "/usr/include/locale.h" 1 3 4
># 29 "/usr/include/locale.h" 3 4
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 1 3 4
># 30 "/usr/include/locale.h" 2 3 4
># 1 "/usr/include/bits/locale.h" 1 3 4
># 27 "/usr/include/bits/locale.h" 3 4
>enum
>{
>  __LC_CTYPE = 0,
>  __LC_NUMERIC = 1,
>  __LC_TIME = 2,
>  __LC_COLLATE = 3,
>  __LC_MONETARY = 4,
>  __LC_MESSAGES = 5,
>  __LC_ALL = 6,
>  __LC_PAPER = 7,
>  __LC_NAME = 8,
>  __LC_ADDRESS = 9,
>  __LC_TELEPHONE = 10,
>  __LC_MEASUREMENT = 11,
>  __LC_IDENTIFICATION = 12
>};
># 31 "/usr/include/locale.h" 2 3 4
>
>
># 51 "/usr/include/locale.h" 3 4
>
>
>
>struct lconv
>{
>
>
>  char *decimal_point;
>  char *thousands_sep;
>
>
>
>
>
>  char *grouping;
>
>
>
>
>
>  char *int_curr_symbol;
>  char *currency_symbol;
>  char *mon_decimal_point;
>  char *mon_thousands_sep;
>  char *mon_grouping;
>  char *positive_sign;
>  char *negative_sign;
>  char int_frac_digits;
>  char frac_digits;
>
>  char p_cs_precedes;
>
>  char p_sep_by_space;
>
>  char n_cs_precedes;
>
>  char n_sep_by_space;
>
>
>
>
>
>
>  char p_sign_posn;
>  char n_sign_posn;
>
>
>  char int_p_cs_precedes;
>
>  char int_p_sep_by_space;
>
>  char int_n_cs_precedes;
>
>  char int_n_sep_by_space;
>
>
>
>
>
>
>  char int_p_sign_posn;
>  char int_n_sign_posn;
># 121 "/usr/include/locale.h" 3 4
>};
>
>
>
>extern char *setlocale (int __category, const char *__locale) __attribute__ ((__nothrow__));
>
>
>extern struct lconv *localeconv (void) __attribute__ ((__nothrow__));
>
>
># 148 "/usr/include/locale.h" 3 4
>typedef __locale_t locale_t;
>
>
>
>
>
>extern __locale_t newlocale (int __category_mask, const char *__locale,
>        __locale_t __base) __attribute__ ((__nothrow__));
># 189 "/usr/include/locale.h" 3 4
>extern __locale_t duplocale (__locale_t __dataset) __attribute__ ((__nothrow__));
>
>
>
>extern void freelocale (__locale_t __dataset) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern __locale_t uselocale (__locale_t __dataset) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>
># 105 "/usr/include/libintl.h" 2 3 4
># 122 "/usr/include/libintl.h" 3 4
>
># 40 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c" 2
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stdbool.h" 1 3 4
># 41 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c" 2
># 1 "/usr/include/stdio_ext.h" 1 3 4
># 26 "/usr/include/stdio_ext.h" 3 4
># 1 "/usr/include/stdio.h" 1 3 4
># 30 "/usr/include/stdio.h" 3 4
>
>
>
>
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 1 3 4
># 35 "/usr/include/stdio.h" 2 3 4
># 45 "/usr/include/stdio.h" 3 4
>struct _IO_FILE;
>
>
>
>typedef struct _IO_FILE FILE;
>
>
>
>
>
># 65 "/usr/include/stdio.h" 3 4
>typedef struct _IO_FILE __FILE;
># 75 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/libio.h" 1 3 4
># 32 "/usr/include/libio.h" 3 4
># 1 "/usr/include/_G_config.h" 1 3 4
># 15 "/usr/include/_G_config.h" 3 4
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 1 3 4
># 16 "/usr/include/_G_config.h" 2 3 4
>
>
>
>
># 1 "/usr/include/wchar.h" 1 3 4
># 78 "/usr/include/wchar.h" 3 4
>typedef struct
>{
>  int __count;
>  union
>  {
>
>    unsigned int __wch;
>
>
>
>    char __wchb[4];
>  } __value;
>} __mbstate_t;
># 21 "/usr/include/_G_config.h" 2 3 4
>
>typedef struct
>{
>  __off_t __pos;
>  __mbstate_t __state;
>} _G_fpos_t;
>typedef struct
>{
>  __off64_t __pos;
>  __mbstate_t __state;
>} _G_fpos64_t;
># 53 "/usr/include/_G_config.h" 3 4
>typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
>typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
>typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
>typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));
># 33 "/usr/include/libio.h" 2 3 4
># 53 "/usr/include/libio.h" 3 4
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stdarg.h" 1 3 4
># 43 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stdarg.h" 3 4
>typedef __builtin_va_list __gnuc_va_list;
># 54 "/usr/include/libio.h" 2 3 4
># 170 "/usr/include/libio.h" 3 4
>struct _IO_jump_t; struct _IO_FILE;
># 180 "/usr/include/libio.h" 3 4
>typedef void _IO_lock_t;
>
>
>
>
>
>struct _IO_marker {
>  struct _IO_marker *_next;
>  struct _IO_FILE *_sbuf;
>
>
>
>  int _pos;
># 203 "/usr/include/libio.h" 3 4
>};
>
>
>enum __codecvt_result
>{
>  __codecvt_ok,
>  __codecvt_partial,
>  __codecvt_error,
>  __codecvt_noconv
>};
># 271 "/usr/include/libio.h" 3 4
>struct _IO_FILE {
>  int _flags;
>
>
>
>
>  char* _IO_read_ptr;
>  char* _IO_read_end;
>  char* _IO_read_base;
>  char* _IO_write_base;
>  char* _IO_write_ptr;
>  char* _IO_write_end;
>  char* _IO_buf_base;
>  char* _IO_buf_end;
>
>  char *_IO_save_base;
>  char *_IO_backup_base;
>  char *_IO_save_end;
>
>  struct _IO_marker *_markers;
>
>  struct _IO_FILE *_chain;
>
>  int _fileno;
>
>
>
>  int _flags2;
>
>  __off_t _old_offset;
>
>
>
>  unsigned short _cur_column;
>  signed char _vtable_offset;
>  char _shortbuf[1];
>
>
>
>  _IO_lock_t *_lock;
># 319 "/usr/include/libio.h" 3 4
>  __off64_t _offset;
># 328 "/usr/include/libio.h" 3 4
>  void *__pad1;
>  void *__pad2;
>  void *__pad3;
>  void *__pad4;
>  size_t __pad5;
>
>  int _mode;
>
>  char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
>
>};
>
>
>typedef struct _IO_FILE _IO_FILE;
>
>
>struct _IO_FILE_plus;
>
>extern struct _IO_FILE_plus _IO_2_1_stdin_;
>extern struct _IO_FILE_plus _IO_2_1_stdout_;
>extern struct _IO_FILE_plus _IO_2_1_stderr_;
># 364 "/usr/include/libio.h" 3 4
>typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);
>
>
>
>
>
>
>
>typedef __ssize_t __io_write_fn (void *__cookie, const char *__buf,
>     size_t __n);
>
>
>
>
>
>
>
>typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);
>
>
>typedef int __io_close_fn (void *__cookie);
>
>
>
>
>typedef __io_read_fn cookie_read_function_t;
>typedef __io_write_fn cookie_write_function_t;
>typedef __io_seek_fn cookie_seek_function_t;
>typedef __io_close_fn cookie_close_function_t;
>
>
>typedef struct
>{
>  __io_read_fn *read;
>  __io_write_fn *write;
>  __io_seek_fn *seek;
>  __io_close_fn *close;
>} _IO_cookie_io_functions_t;
>typedef _IO_cookie_io_functions_t cookie_io_functions_t;
>
>struct _IO_cookie_file;
>
>
>extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
>        void *__cookie, _IO_cookie_io_functions_t __fns);
>
>
>
>
>
>
>
>extern int __underflow (_IO_FILE *);
>extern int __uflow (_IO_FILE *);
>extern int __overflow (_IO_FILE *, int);
># 458 "/usr/include/libio.h" 3 4
>extern int _IO_getc (_IO_FILE *__fp);
>extern int _IO_putc (int __c, _IO_FILE *__fp);
>extern int _IO_feof (_IO_FILE *__fp) __attribute__ ((__nothrow__));
>extern int _IO_ferror (_IO_FILE *__fp) __attribute__ ((__nothrow__));
>
>extern int _IO_peekc_locked (_IO_FILE *__fp);
>
>
>
>
>
>extern void _IO_flockfile (_IO_FILE *) __attribute__ ((__nothrow__));
>extern void _IO_funlockfile (_IO_FILE *) __attribute__ ((__nothrow__));
>extern int _IO_ftrylockfile (_IO_FILE *) __attribute__ ((__nothrow__));
># 488 "/usr/include/libio.h" 3 4
>extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
>   __gnuc_va_list, int *__restrict);
>extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
>    __gnuc_va_list);
>extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t);
>extern size_t _IO_sgetn (_IO_FILE *, void *, size_t);
>
>extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int);
>extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int);
>
>extern void _IO_free_backup_area (_IO_FILE *) __attribute__ ((__nothrow__));
># 76 "/usr/include/stdio.h" 2 3 4
>
>
>
>
>typedef __gnuc_va_list va_list;
># 89 "/usr/include/stdio.h" 3 4
>
>
>
>
>typedef _G_fpos64_t fpos_t;
>
>
>
>typedef _G_fpos64_t fpos64_t;
># 141 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/bits/stdio_lim.h" 1 3 4
># 142 "/usr/include/stdio.h" 2 3 4
>
>
>
>extern struct _IO_FILE *stdin;
>extern struct _IO_FILE *stdout;
>extern struct _IO_FILE *stderr;
>
>
>
>
>
>
>
>
>
>extern int remove (const char *__filename) __attribute__ ((__nothrow__));
>
>extern int rename (const char *__old, const char *__new) __attribute__ ((__nothrow__));
>
>
>
>
>extern int renameat (int __oldfd, const char *__old, int __newfd,
>       const char *__new) __attribute__ ((__nothrow__));
>
>
>
># 177 "/usr/include/stdio.h" 3 4
>extern FILE *tmpfile (void) __asm__ ("" "tmpfile64") ;
>
>
>
>
>
>
>extern FILE *tmpfile64 (void) ;
>
>
>
>extern char *tmpnam (char *__s) __attribute__ ((__nothrow__)) ;
>
>
>
>
>
>extern char *tmpnam_r (char *__s) __attribute__ ((__nothrow__)) ;
># 206 "/usr/include/stdio.h" 3 4
>extern char *tempnam (const char *__dir, const char *__pfx)
>     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) ;
>
>
>
>
>
>
>
>
>extern int fclose (FILE *__stream);
>
>
>
>
>extern int fflush (FILE *__stream);
>
># 231 "/usr/include/stdio.h" 3 4
>extern int fflush_unlocked (FILE *__stream);
># 241 "/usr/include/stdio.h" 3 4
>extern int fcloseall (void);
>
>
>
>
># 262 "/usr/include/stdio.h" 3 4
>extern FILE *fopen (const char *__restrict __filename, const char *__restrict __modes) __asm__ ("" "fopen64")
>
>  ;
>extern FILE *freopen (const char *__restrict __filename, const char *__restrict __modes, FILE *__restrict __stream) __asm__ ("" "freopen64")
>
>
>  ;
>
>
>
>
>
>
>
>extern FILE *fopen64 (const char *__restrict __filename,
>        const char *__restrict __modes) ;
>extern FILE *freopen64 (const char *__restrict __filename,
>   const char *__restrict __modes,
>   FILE *__restrict __stream) ;
>
>
>
>
>extern FILE *fdopen (int __fd, const char *__modes) __attribute__ ((__nothrow__)) ;
>
>
>
>
>
>extern FILE *fopencookie (void *__restrict __magic_cookie,
>     const char *__restrict __modes,
>     _IO_cookie_io_functions_t __io_funcs) __attribute__ ((__nothrow__)) ;
>
>
>extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
>  __attribute__ ((__nothrow__)) ;
>
>
>
>
>extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) __attribute__ ((__nothrow__)) ;
>
>
>
>
>
>
>extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) __attribute__ ((__nothrow__));
>
>
>
>extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
>      int __modes, size_t __n) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
>         size_t __size) __attribute__ ((__nothrow__));
>
>
>extern void setlinebuf (FILE *__stream) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>
>extern int fprintf (FILE *__restrict __stream,
>      const char *__restrict __format, ...);
>
>
>
>
>extern int printf (const char *__restrict __format, ...);
>
>extern int sprintf (char *__restrict __s,
>      const char *__restrict __format, ...) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
>       __gnuc_va_list __arg);
>
>
>
>
>extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
>
>extern int vsprintf (char *__restrict __s, const char *__restrict __format,
>       __gnuc_va_list __arg) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern int snprintf (char *__restrict __s, size_t __maxlen,
>       const char *__restrict __format, ...)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 4)));
>
>extern int vsnprintf (char *__restrict __s, size_t __maxlen,
>        const char *__restrict __format, __gnuc_va_list __arg)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 0)));
>
>
>
>
>
>
>extern int vasprintf (char **__restrict __ptr, const char *__restrict __f,
>        __gnuc_va_list __arg)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 0))) ;
>extern int __asprintf (char **__restrict __ptr,
>         const char *__restrict __fmt, ...)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 3))) ;
>extern int asprintf (char **__restrict __ptr,
>       const char *__restrict __fmt, ...)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 3))) ;
>
>
>
>
>
>
>
>extern int vdprintf (int __fd, const char *__restrict __fmt,
>       __gnuc_va_list __arg)
>     __attribute__ ((__format__ (__printf__, 2, 0)));
>extern int dprintf (int __fd, const char *__restrict __fmt, ...)
>     __attribute__ ((__format__ (__printf__, 2, 3)));
>
>
>
>
>
>
>
>
>extern int fscanf (FILE *__restrict __stream,
>     const char *__restrict __format, ...) ;
>
>
>
>
>extern int scanf (const char *__restrict __format, ...) ;
>
>extern int sscanf (const char *__restrict __s,
>     const char *__restrict __format, ...) __attribute__ ((__nothrow__));
># 443 "/usr/include/stdio.h" 3 4
>
>
>
>
>
>
>
>
>extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
>      __gnuc_va_list __arg)
>     __attribute__ ((__format__ (__scanf__, 2, 0))) ;
>
>
>
>
>
>extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
>     __attribute__ ((__format__ (__scanf__, 1, 0))) ;
>
>
>extern int vsscanf (const char *__restrict __s,
>      const char *__restrict __format, __gnuc_va_list __arg)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__scanf__, 2, 0)));
># 502 "/usr/include/stdio.h" 3 4
>
>
>
>
>
>
>
>
>
>extern int fgetc (FILE *__stream);
>extern int getc (FILE *__stream);
>
>
>
>
>
>extern int getchar (void);
>
># 530 "/usr/include/stdio.h" 3 4
>extern int getc_unlocked (FILE *__stream);
>extern int getchar_unlocked (void);
># 541 "/usr/include/stdio.h" 3 4
>extern int fgetc_unlocked (FILE *__stream);
>
>
>
>
>
>
>
>
>
>
>
>extern int fputc (int __c, FILE *__stream);
>extern int putc (int __c, FILE *__stream);
>
>
>
>
>
>extern int putchar (int __c);
>
># 574 "/usr/include/stdio.h" 3 4
>extern int fputc_unlocked (int __c, FILE *__stream);
>
>
>
>
>
>
>
>extern int putc_unlocked (int __c, FILE *__stream);
>extern int putchar_unlocked (int __c);
>
>
>
>
>
>
>extern int getw (FILE *__stream);
>
>
>extern int putw (int __w, FILE *__stream);
>
>
>
>
>
>
>
>
>extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
>     ;
>
>
>
>
>
>
>extern char *gets (char *__s) ;
>
># 620 "/usr/include/stdio.h" 3 4
>extern char *fgets_unlocked (char *__restrict __s, int __n,
>        FILE *__restrict __stream) ;
># 636 "/usr/include/stdio.h" 3 4
>extern __ssize_t __getdelim (char **__restrict __lineptr,
>          size_t *__restrict __n, int __delimiter,
>          FILE *__restrict __stream) ;
>extern __ssize_t getdelim (char **__restrict __lineptr,
>        size_t *__restrict __n, int __delimiter,
>        FILE *__restrict __stream) ;
>
>
>
>
>
>
>
>extern __ssize_t getline (char **__restrict __lineptr,
>       size_t *__restrict __n,
>       FILE *__restrict __stream) ;
>
>
>
>
>
>
>
>
>extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
>
>
>
>
>
>extern int puts (const char *__s);
>
>
>
>
>
>
>extern int ungetc (int __c, FILE *__stream);
>
>
>
>
>
>
>extern size_t fread (void *__restrict __ptr, size_t __size,
>       size_t __n, FILE *__restrict __stream) ;
>
>
>
>
>extern size_t fwrite (const void *__restrict __ptr, size_t __size,
>        size_t __n, FILE *__restrict __s) ;
>
># 697 "/usr/include/stdio.h" 3 4
>extern int fputs_unlocked (const char *__restrict __s,
>      FILE *__restrict __stream);
># 708 "/usr/include/stdio.h" 3 4
>extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
>         size_t __n, FILE *__restrict __stream) ;
>extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
>          size_t __n, FILE *__restrict __stream) ;
>
>
>
>
>
>
>
>
>extern int fseek (FILE *__stream, long int __off, int __whence);
>
>
>
>
>extern long int ftell (FILE *__stream) ;
>
>
>
>
>extern void rewind (FILE *__stream);
>
># 752 "/usr/include/stdio.h" 3 4
>extern int fseeko (FILE *__stream, __off64_t __off, int __whence) __asm__ ("" "fseeko64");
>
>
>extern __off64_t ftello (FILE *__stream) __asm__ ("" "ftello64");
>
>
>
>
>
>
>
>
># 777 "/usr/include/stdio.h" 3 4
>extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos) __asm__ ("" "fgetpos64");
>
>extern int fsetpos (FILE *__stream, const fpos_t *__pos) __asm__ ("" "fsetpos64");
>
>
>
>
>
>
>
>
>
>extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
>extern __off64_t ftello64 (FILE *__stream) ;
>extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
>extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos);
>
>
>
>
>extern void clearerr (FILE *__stream) __attribute__ ((__nothrow__));
>
>extern int feof (FILE *__stream) __attribute__ ((__nothrow__)) ;
>
>extern int ferror (FILE *__stream) __attribute__ ((__nothrow__)) ;
>
>
>
>
>extern void clearerr_unlocked (FILE *__stream) __attribute__ ((__nothrow__));
>extern int feof_unlocked (FILE *__stream) __attribute__ ((__nothrow__)) ;
>extern int ferror_unlocked (FILE *__stream) __attribute__ ((__nothrow__)) ;
>
>
>
>
>
>
>
>
>extern void perror (const char *__s);
>
>
>
>
>
>
># 1 "/usr/include/bits/sys_errlist.h" 1 3 4
># 27 "/usr/include/bits/sys_errlist.h" 3 4
>extern int sys_nerr;
>extern const char *const sys_errlist[];
>
>
>extern int _sys_nerr;
>extern const char *const _sys_errlist[];
># 825 "/usr/include/stdio.h" 2 3 4
>
>
>
>
>extern int fileno (FILE *__stream) __attribute__ ((__nothrow__)) ;
>
>
>
>
>extern int fileno_unlocked (FILE *__stream) __attribute__ ((__nothrow__)) ;
># 844 "/usr/include/stdio.h" 3 4
>extern FILE *popen (const char *__command, const char *__modes) ;
>
>
>
>
>
>extern int pclose (FILE *__stream);
>
>
>
>
>
>extern char *ctermid (char *__s) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern char *cuserid (char *__s);
>
>
>
>
>struct obstack;
>
>
>extern int obstack_printf (struct obstack *__restrict __obstack,
>      const char *__restrict __format, ...)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 3)));
>extern int obstack_vprintf (struct obstack *__restrict __obstack,
>       const char *__restrict __format,
>       __gnuc_va_list __args)
>     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 0)));
>
>
>
>
>
>
>
>extern void flockfile (FILE *__stream) __attribute__ ((__nothrow__));
>
>
>
>extern int ftrylockfile (FILE *__stream) __attribute__ ((__nothrow__)) ;
>
>
>extern void funlockfile (FILE *__stream) __attribute__ ((__nothrow__));
># 905 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/bits/stdio.h" 1 3 4
># 36 "/usr/include/bits/stdio.h" 3 4
>extern __inline __attribute__ ((__gnu_inline__)) int
>vprintf (const char *__restrict __fmt, __gnuc_va_list __arg)
>{
>  return vfprintf (stdout, __fmt, __arg);
>}
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>getchar (void)
>{
>  return _IO_getc (stdin);
>}
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>fgetc_unlocked (FILE *__fp)
>{
>  return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
>}
>
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>getc_unlocked (FILE *__fp)
>{
>  return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>getchar_unlocked (void)
>{
>  return (__builtin_expect (((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end), 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
>}
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>putchar (int __c)
>{
>  return _IO_putc (__c, stdout);
>}
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>fputc_unlocked (int __c, FILE *__stream)
>{
>  return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
>}
>
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>putc_unlocked (int __c, FILE *__stream)
>{
>  return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>putchar_unlocked (int __c)
>{
>  return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
>}
>
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) __ssize_t
>getline (char **__lineptr, size_t *__n, FILE *__stream)
>{
>  return __getdelim (__lineptr, __n, '\n', __stream);
>}
>
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__nothrow__)) feof_unlocked (FILE *__stream)
>{
>  return (((__stream)->_flags & 0x10) != 0);
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__nothrow__)) ferror_unlocked (FILE *__stream)
>{
>  return (((__stream)->_flags & 0x20) != 0);
>}
># 906 "/usr/include/stdio.h" 2 3 4
># 914 "/usr/include/stdio.h" 3 4
>
># 27 "/usr/include/stdio_ext.h" 2 3 4
>
>enum
>{
>
>  FSETLOCKING_QUERY = 0,
>
>
>
>  FSETLOCKING_INTERNAL,
>
>
>  FSETLOCKING_BYCALLER
>
>};
>
>
>
>
>
>
>extern size_t __fbufsize (FILE *__fp) __attribute__ ((__nothrow__));
>
>
>
>
>extern int __freading (FILE *__fp) __attribute__ ((__nothrow__));
>
>
>
>
>extern int __fwriting (FILE *__fp) __attribute__ ((__nothrow__));
>
>
>
>
>extern int __freadable (FILE *__fp) __attribute__ ((__nothrow__));
>
>
>extern int __fwritable (FILE *__fp) __attribute__ ((__nothrow__));
>
>
>
>extern int __flbf (FILE *__fp) __attribute__ ((__nothrow__));
>
>
>
>extern void __fpurge (FILE *__fp) __attribute__ ((__nothrow__));
>
>
>extern size_t __fpending (FILE *__fp) __attribute__ ((__nothrow__));
>
>
>extern void _flushlbf (void);
>
>
>
>extern int __fsetlocking (FILE *__fp, int __type) __attribute__ ((__nothrow__));
>
>
># 42 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c" 2
># 1 "/usr/include/stdlib.h" 1 3 4
># 33 "/usr/include/stdlib.h" 3 4
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 1 3 4
># 326 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 3 4
>typedef long int wchar_t;
># 34 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>
>
>
>
># 1 "/usr/include/bits/waitflags.h" 1 3 4
># 43 "/usr/include/stdlib.h" 2 3 4
># 1 "/usr/include/bits/waitstatus.h" 1 3 4
># 67 "/usr/include/bits/waitstatus.h" 3 4
>union wait
>  {
>    int w_status;
>    struct
>      {
>
>
>
>
>
>
>
> unsigned int:16;
> unsigned int __w_retcode:8;
> unsigned int __w_coredump:1;
> unsigned int __w_termsig:7;
>
>      } __wait_terminated;
>    struct
>      {
>
>
>
>
>
>
> unsigned int:16;
> unsigned int __w_stopsig:8;
> unsigned int __w_stopval:8;
>
>      } __wait_stopped;
>  };
># 44 "/usr/include/stdlib.h" 2 3 4
># 68 "/usr/include/stdlib.h" 3 4
>typedef union
>  {
>    union wait *__uptr;
>    int *__iptr;
>  } __WAIT_STATUS __attribute__ ((__transparent_union__));
># 96 "/usr/include/stdlib.h" 3 4
>
>
>typedef struct
>  {
>    int quot;
>    int rem;
>  } div_t;
>
>
>
>typedef struct
>  {
>    long int quot;
>    long int rem;
>  } ldiv_t;
>
>
>
>
>
>
>
>__extension__ typedef struct
>  {
>    long long int quot;
>    long long int rem;
>  } lldiv_t;
>
>
># 140 "/usr/include/stdlib.h" 3 4
>extern size_t __ctype_get_mb_cur_max (void) __attribute__ ((__nothrow__)) ;
>
>
>
>
>extern double atof (const char *__nptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>extern int atoi (const char *__nptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>extern long int atol (const char *__nptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>__extension__ extern long long int atoll (const char *__nptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>extern double strtod (const char *__restrict __nptr,
>        char **__restrict __endptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>extern float strtof (const char *__restrict __nptr,
>       char **__restrict __endptr) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>extern long double strtold (const char *__restrict __nptr,
>       char **__restrict __endptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>extern long int strtol (const char *__restrict __nptr,
>   char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>extern unsigned long int strtoul (const char *__restrict __nptr,
>      char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>__extension__
>extern long long int strtoq (const char *__restrict __nptr,
>        char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>__extension__
>extern unsigned long long int strtouq (const char *__restrict __nptr,
>           char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>__extension__
>extern long long int strtoll (const char *__restrict __nptr,
>         char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>__extension__
>extern unsigned long long int strtoull (const char *__restrict __nptr,
>     char **__restrict __endptr, int __base)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
># 240 "/usr/include/stdlib.h" 3 4
>extern long int strtol_l (const char *__restrict __nptr,
>     char **__restrict __endptr, int __base,
>     __locale_t __loc) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 4))) ;
>
>extern unsigned long int strtoul_l (const char *__restrict __nptr,
>        char **__restrict __endptr,
>        int __base, __locale_t __loc)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 4))) ;
>
>__extension__
>extern long long int strtoll_l (const char *__restrict __nptr,
>    char **__restrict __endptr, int __base,
>    __locale_t __loc)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 4))) ;
>
>__extension__
>extern unsigned long long int strtoull_l (const char *__restrict __nptr,
>       char **__restrict __endptr,
>       int __base, __locale_t __loc)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 4))) ;
>
>extern double strtod_l (const char *__restrict __nptr,
>   char **__restrict __endptr, __locale_t __loc)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 3))) ;
>
>extern float strtof_l (const char *__restrict __nptr,
>         char **__restrict __endptr, __locale_t __loc)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 3))) ;
>
>extern long double strtold_l (const char *__restrict __nptr,
>         char **__restrict __endptr,
>         __locale_t __loc)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 3))) ;
>
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) double
>__attribute__ ((__nothrow__)) atof (const char *__nptr)
>{
>  return strtod (__nptr, (char **) ((void *)0));
>}
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__nothrow__)) atoi (const char *__nptr)
>{
>  return (int) strtol (__nptr, (char **) ((void *)0), 10);
>}
>extern __inline __attribute__ ((__gnu_inline__)) long int
>__attribute__ ((__nothrow__)) atol (const char *__nptr)
>{
>  return strtol (__nptr, (char **) ((void *)0), 10);
>}
>
>
>
>
>__extension__ extern __inline __attribute__ ((__gnu_inline__)) long long int
>__attribute__ ((__nothrow__)) atoll (const char *__nptr)
>{
>  return strtoll (__nptr, (char **) ((void *)0), 10);
>}
>
># 311 "/usr/include/stdlib.h" 3 4
>extern char *l64a (long int __n) __attribute__ ((__nothrow__)) ;
>
>
>extern long int a64l (const char *__s)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
># 327 "/usr/include/stdlib.h" 3 4
>extern long int random (void) __attribute__ ((__nothrow__));
>
>
>extern void srandom (unsigned int __seed) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern char *initstate (unsigned int __seed, char *__statebuf,
>   size_t __statelen) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>extern char *setstate (char *__statebuf) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>struct random_data
>  {
>    int32_t *fptr;
>    int32_t *rptr;
>    int32_t *state;
>    int rand_type;
>    int rand_deg;
>    int rand_sep;
>    int32_t *end_ptr;
>  };
>
>extern int random_r (struct random_data *__restrict __buf,
>       int32_t *__restrict __result) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int srandom_r (unsigned int __seed, struct random_data *__buf)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
>   size_t __statelen,
>   struct random_data *__restrict __buf)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 4)));
>
>extern int setstate_r (char *__restrict __statebuf,
>         struct random_data *__restrict __buf)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern int rand (void) __attribute__ ((__nothrow__));
>
>extern void srand (unsigned int __seed) __attribute__ ((__nothrow__));
>
>
>
>
>extern int rand_r (unsigned int *__seed) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>extern double drand48 (void) __attribute__ ((__nothrow__));
>extern double erand48 (unsigned short int __xsubi[3]) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern long int lrand48 (void) __attribute__ ((__nothrow__));
>extern long int nrand48 (unsigned short int __xsubi[3])
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern long int mrand48 (void) __attribute__ ((__nothrow__));
>extern long int jrand48 (unsigned short int __xsubi[3])
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern void srand48 (long int __seedval) __attribute__ ((__nothrow__));
>extern unsigned short int *seed48 (unsigned short int __seed16v[3])
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>extern void lcong48 (unsigned short int __param[7]) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>struct drand48_data
>  {
>    unsigned short int __x[3];
>    unsigned short int __old_x[3];
>    unsigned short int __c;
>    unsigned short int __init;
>    unsigned long long int __a;
>  };
>
>
>extern int drand48_r (struct drand48_data *__restrict __buffer,
>        double *__restrict __result) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>extern int erand48_r (unsigned short int __xsubi[3],
>        struct drand48_data *__restrict __buffer,
>        double *__restrict __result) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int lrand48_r (struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>extern int nrand48_r (unsigned short int __xsubi[3],
>        struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int mrand48_r (struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>extern int jrand48_r (unsigned short int __xsubi[3],
>        struct drand48_data *__restrict __buffer,
>        long int *__restrict __result)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>extern int seed48_r (unsigned short int __seed16v[3],
>       struct drand48_data *__buffer) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int lcong48_r (unsigned short int __param[7],
>        struct drand48_data *__buffer)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>
>
>
>extern void *malloc (size_t __size) __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) ;
>
>extern void *calloc (size_t __nmemb, size_t __size)
>     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) ;
>
>
>
>
>
>
>
>
>
>
>extern void *realloc (void *__ptr, size_t __size)
>     __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));
>
>extern void free (void *__ptr) __attribute__ ((__nothrow__));
>
>
>
>
>extern void cfree (void *__ptr) __attribute__ ((__nothrow__));
>
>
>
># 1 "/usr/include/alloca.h" 1 3 4
># 25 "/usr/include/alloca.h" 3 4
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 1 3 4
># 26 "/usr/include/alloca.h" 2 3 4
>
>
>
>
>
>
>
>extern void *alloca (size_t __size) __attribute__ ((__nothrow__));
>
>
>
>
>
>
># 498 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>extern void *valloc (size_t __size) __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) ;
>
>
>
>
>extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>extern void abort (void) __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));
>
>
>
>extern int atexit (void (*__func) (void)) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern void exit (int __status) __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));
>
>
>
>
>
>
>extern void _Exit (int __status) __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));
>
>
>
>
>
>
>extern char *getenv (const char *__name) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>extern char *__secure_getenv (const char *__name)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>extern int putenv (char *__string) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int setenv (const char *__name, const char *__value, int __replace)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>
>extern int unsetenv (const char *__name) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern int clearenv (void) __attribute__ ((__nothrow__));
># 583 "/usr/include/stdlib.h" 3 4
>extern char *mktemp (char *__template) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
># 597 "/usr/include/stdlib.h" 3 4
>extern int mkstemp (char *__template) __asm__ ("" "mkstemp64")
>     __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
># 614 "/usr/include/stdlib.h" 3 4
>extern char *mkdtemp (char *__template) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
># 628 "/usr/include/stdlib.h" 3 4
>extern int mkostemp (char *__template, int __flags) __asm__ ("" "mkostemp64")
>     __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>
>
>
>
>extern int system (const char *__command) ;
>
>
>
>
>
>
>extern char *canonicalize_file_name (const char *__name)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
># 662 "/usr/include/stdlib.h" 3 4
>extern char *realpath (const char *__restrict __name,
>         char *__restrict __resolved) __attribute__ ((__nothrow__)) ;
>
>
>
>
>
>
>typedef int (*__compar_fn_t) (const void *, const void *);
>
>
>typedef __compar_fn_t comparison_fn_t;
>
>
>
>typedef int (*__compar_d_fn_t) (const void *, const void *, void *);
>
>
>
>
>
>extern void *bsearch (const void *__key, const void *__base,
>        size_t __nmemb, size_t __size, __compar_fn_t __compar)
>     __attribute__ ((__nonnull__ (1, 2, 5))) ;
>
>
>
>extern void qsort (void *__base, size_t __nmemb, size_t __size,
>     __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
>
>extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
>       __compar_d_fn_t __compar, void *__arg)
>  __attribute__ ((__nonnull__ (1, 4)));
>
>
>
>
>extern int abs (int __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)) ;
>extern long int labs (long int __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__)) ;
>
>
>
>__extension__ extern long long int llabs (long long int __x)
>     __attribute__ ((__nothrow__)) __attribute__ ((__const__)) ;
>
>
>
>
>
>
>
>extern div_t div (int __numer, int __denom)
>     __attribute__ ((__nothrow__)) __attribute__ ((__const__)) ;
>extern ldiv_t ldiv (long int __numer, long int __denom)
>     __attribute__ ((__nothrow__)) __attribute__ ((__const__)) ;
>
>
>
>
>__extension__ extern lldiv_t lldiv (long long int __numer,
>        long long int __denom)
>     __attribute__ ((__nothrow__)) __attribute__ ((__const__)) ;
>
># 735 "/usr/include/stdlib.h" 3 4
>extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4))) ;
>
>
>
>
>extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4))) ;
>
>
>
>
>extern char *gcvt (double __value, int __ndigit, char *__buf)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3))) ;
>
>
>
>
>extern char *qecvt (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4))) ;
>extern char *qfcvt (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4))) ;
>extern char *qgcvt (long double __value, int __ndigit, char *__buf)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3))) ;
>
>
>
>
>extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign, char *__restrict __buf,
>     size_t __len) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4, 5)));
>extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
>     int *__restrict __sign, char *__restrict __buf,
>     size_t __len) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4, 5)));
>
>extern int qecvt_r (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign,
>      char *__restrict __buf, size_t __len)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4, 5)));
>extern int qfcvt_r (long double __value, int __ndigit,
>      int *__restrict __decpt, int *__restrict __sign,
>      char *__restrict __buf, size_t __len)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4, 5)));
>
>
>
>
>
>
>
>extern int mblen (const char *__s, size_t __n) __attribute__ ((__nothrow__)) ;
>
>
>extern int mbtowc (wchar_t *__restrict __pwc,
>     const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__)) ;
>
>
>extern int wctomb (char *__s, wchar_t __wchar) __attribute__ ((__nothrow__)) ;
>
>
>
>extern size_t mbstowcs (wchar_t *__restrict __pwcs,
>   const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__));
>
>extern size_t wcstombs (char *__restrict __s,
>   const wchar_t *__restrict __pwcs, size_t __n)
>     __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>
>extern int rpmatch (const char *__response) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
># 823 "/usr/include/stdlib.h" 3 4
>extern int getsubopt (char **__restrict __optionp,
>        char *const *__restrict __tokens,
>        char **__restrict __valuep)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2, 3))) ;
>
>
>
>
>
>extern void setkey (const char *__key) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int posix_openpt (int __oflag) ;
>
>
>
>
>
>
>
>extern int grantpt (int __fd) __attribute__ ((__nothrow__));
>
>
>
>extern int unlockpt (int __fd) __attribute__ ((__nothrow__));
>
>
>
>
>extern char *ptsname (int __fd) __attribute__ ((__nothrow__)) ;
>
>
>
>
>
>
>extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>
>extern int getpt (void);
>
>
>
>
>
>
>extern int getloadavg (double __loadavg[], int __nelem)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
># 891 "/usr/include/stdlib.h" 3 4
>
># 43 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c" 2
># 1 "/usr/include/string.h" 1 3 4
># 28 "/usr/include/string.h" 3 4
>
>
>
>
>
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 1 3 4
># 34 "/usr/include/string.h" 2 3 4
>
>
>
>
>extern void *memcpy (void *__restrict __dest,
>       const void *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void *memmove (void *__dest, const void *__src, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
>        int __c, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern void *memset (void *__s, int __c, size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int memcmp (const void *__s1, const void *__s2, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void *memchr (const void *__s, int __c, size_t __n)
>      __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern void *rawmemchr (const void *__s, int __c)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern void *memrchr (const void *__s, int __c, size_t __n)
>      __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strncpy (char *__restrict __dest,
>        const char *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *strcat (char *__restrict __dest, const char *__restrict __src)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strncat (char *__restrict __dest, const char *__restrict __src,
>        size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strcmp (const char *__s1, const char *__s2)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int strncmp (const char *__s1, const char *__s2, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strcoll (const char *__s1, const char *__s2)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern size_t strxfrm (char *__restrict __dest,
>         const char *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
># 121 "/usr/include/string.h" 3 4
>extern int strcoll_l (const char *__s1, const char *__s2, __locale_t __l)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
>
>extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
>    __locale_t __l) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 4)));
>
>
>
>
>extern char *strdup (const char *__s)
>     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern char *strndup (const char *__string, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
># 165 "/usr/include/string.h" 3 4
>
>
>extern char *strchr (const char *__s, int __c)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>extern char *strrchr (const char *__s, int __c)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern char *strchrnul (const char *__s, int __c)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern size_t strcspn (const char *__s, const char *__reject)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern size_t strspn (const char *__s, const char *__accept)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strpbrk (const char *__s, const char *__accept)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strstr (const char *__haystack, const char *__needle)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern char *strtok (char *__restrict __s, const char *__restrict __delim)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern char *__strtok_r (char *__restrict __s,
>    const char *__restrict __delim,
>    char **__restrict __save_ptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));
>
>extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
>         char **__restrict __save_ptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));
>
>
>
>
>extern char *strcasestr (const char *__haystack, const char *__needle)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern void *memmem (const void *__haystack, size_t __haystacklen,
>       const void *__needle, size_t __needlelen)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>extern void *__mempcpy (void *__restrict __dest,
>   const void *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>extern void *mempcpy (void *__restrict __dest,
>        const void *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern size_t strlen (const char *__s)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern size_t strnlen (const char *__string, size_t __maxlen)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern char *strerror (int __errnum) __attribute__ ((__nothrow__));
>
># 281 "/usr/include/string.h" 3 4
>extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>extern char *strerror_l (int __errnum, __locale_t __l) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern void __bzero (void *__s, size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern void bcopy (const void *__src, void *__dest, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void bzero (void *__s, size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int bcmp (const void *__s1, const void *__s2, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *index (const char *__s, int __c)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern char *rindex (const char *__s, int __c)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int ffs (int __i) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>
>extern int ffsl (long int __l) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>__extension__ extern int ffsll (long long int __ll)
>     __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>
>extern int strcasecmp (const char *__s1, const char *__s2)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern int strcasecmp_l (const char *__s1, const char *__s2,
>    __locale_t __loc)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
>
>extern int strncasecmp_l (const char *__s1, const char *__s2,
>     size_t __n, __locale_t __loc)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));
>
>
>
>
>
>extern char *strsep (char **__restrict __stringp,
>       const char *__restrict __delim)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int strverscmp (const char *__s1, const char *__s2)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *strsignal (int __sig) __attribute__ ((__nothrow__));
>
>
>extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern char *__stpncpy (char *__restrict __dest,
>   const char *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>extern char *stpncpy (char *__restrict __dest,
>        const char *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *strfry (char *__string) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern void *memfrob (void *__s, size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern char *basename (const char *__filename) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
># 420 "/usr/include/string.h" 3 4
># 1 "/usr/include/bits/string.h" 1 3 4
># 421 "/usr/include/string.h" 2 3 4
>
>
># 1 "/usr/include/bits/string2.h" 1 3 4
># 80 "/usr/include/bits/string2.h" 3 4
>typedef struct { unsigned char __arr[2]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR2;
>typedef struct { unsigned char __arr[3]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR3;
>typedef struct { unsigned char __arr[4]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR4;
>typedef struct { unsigned char __arr[5]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR5;
>typedef struct { unsigned char __arr[6]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR6;
>typedef struct { unsigned char __arr[7]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR7;
>typedef struct { unsigned char __arr[8]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR8;
># 394 "/usr/include/bits/string2.h" 3 4
>extern void *__rawmemchr (const void *__s, int __c);
># 969 "/usr/include/bits/string2.h" 3 4
>extern __inline __attribute__ ((__gnu_inline__)) size_t __strcspn_c1 (const char *__s, int __reject);
>extern __inline __attribute__ ((__gnu_inline__)) size_t
>__strcspn_c1 (const char *__s, int __reject)
>{
>  register size_t __result = 0;
>  while (__s[__result] != '\0' && __s[__result] != __reject)
>    ++__result;
>  return __result;
>}
>
>extern __inline __attribute__ ((__gnu_inline__)) size_t __strcspn_c2 (const char *__s, int __reject1,
>         int __reject2);
>extern __inline __attribute__ ((__gnu_inline__)) size_t
>__strcspn_c2 (const char *__s, int __reject1, int __reject2)
>{
>  register size_t __result = 0;
>  while (__s[__result] != '\0' && __s[__result] != __reject1
>  && __s[__result] != __reject2)
>    ++__result;
>  return __result;
>}
>
>extern __inline __attribute__ ((__gnu_inline__)) size_t __strcspn_c3 (const char *__s, int __reject1,
>         int __reject2, int __reject3);
>extern __inline __attribute__ ((__gnu_inline__)) size_t
>__strcspn_c3 (const char *__s, int __reject1, int __reject2,
>       int __reject3)
>{
>  register size_t __result = 0;
>  while (__s[__result] != '\0' && __s[__result] != __reject1
>  && __s[__result] != __reject2 && __s[__result] != __reject3)
>    ++__result;
>  return __result;
>}
># 1045 "/usr/include/bits/string2.h" 3 4
>extern __inline __attribute__ ((__gnu_inline__)) size_t __strspn_c1 (const char *__s, int __accept);
>extern __inline __attribute__ ((__gnu_inline__)) size_t
>__strspn_c1 (const char *__s, int __accept)
>{
>  register size_t __result = 0;
>
>  while (__s[__result] == __accept)
>    ++__result;
>  return __result;
>}
>
>extern __inline __attribute__ ((__gnu_inline__)) size_t __strspn_c2 (const char *__s, int __accept1,
>        int __accept2);
>extern __inline __attribute__ ((__gnu_inline__)) size_t
>__strspn_c2 (const char *__s, int __accept1, int __accept2)
>{
>  register size_t __result = 0;
>
>  while (__s[__result] == __accept1 || __s[__result] == __accept2)
>    ++__result;
>  return __result;
>}
>
>extern __inline __attribute__ ((__gnu_inline__)) size_t __strspn_c3 (const char *__s, int __accept1,
>        int __accept2, int __accept3);
>extern __inline __attribute__ ((__gnu_inline__)) size_t
>__strspn_c3 (const char *__s, int __accept1, int __accept2, int __accept3)
>{
>  register size_t __result = 0;
>
>  while (__s[__result] == __accept1 || __s[__result] == __accept2
>  || __s[__result] == __accept3)
>    ++__result;
>  return __result;
>}
># 1121 "/usr/include/bits/string2.h" 3 4
>extern __inline __attribute__ ((__gnu_inline__)) char *__strpbrk_c2 (const char *__s, int __accept1,
>         int __accept2);
>extern __inline __attribute__ ((__gnu_inline__)) char *
>__strpbrk_c2 (const char *__s, int __accept1, int __accept2)
>{
>
>  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2)
>    ++__s;
>  return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s;
>}
>
>extern __inline __attribute__ ((__gnu_inline__)) char *__strpbrk_c3 (const char *__s, int __accept1,
>         int __accept2, int __accept3);
>extern __inline __attribute__ ((__gnu_inline__)) char *
>__strpbrk_c3 (const char *__s, int __accept1, int __accept2,
>       int __accept3)
>{
>
>  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2
>  && *__s != __accept3)
>    ++__s;
>  return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s;
>}
># 1172 "/usr/include/bits/string2.h" 3 4
>extern __inline __attribute__ ((__gnu_inline__)) char *__strtok_r_1c (char *__s, char __sep, char **__nextp);
>extern __inline __attribute__ ((__gnu_inline__)) char *
>__strtok_r_1c (char *__s, char __sep, char **__nextp)
>{
>  char *__result;
>  if (__s == ((void *)0))
>    __s = *__nextp;
>  while (*__s == __sep)
>    ++__s;
>  __result = ((void *)0);
>  if (*__s != '\0')
>    {
>      __result = __s++;
>      while (*__s != '\0')
> if (*__s++ == __sep)
>   {
>     __s[-1] = '\0';
>     break;
>   }
>    }
>  *__nextp = __s;
>  return __result;
>}
># 1204 "/usr/include/bits/string2.h" 3 4
>extern char *__strsep_g (char **__stringp, const char *__delim);
># 1222 "/usr/include/bits/string2.h" 3 4
>extern __inline __attribute__ ((__gnu_inline__)) char *__strsep_1c (char **__s, char __reject);
>extern __inline __attribute__ ((__gnu_inline__)) char *
>__strsep_1c (char **__s, char __reject)
>{
>  register char *__retval = *__s;
>  if (__retval != ((void *)0) && (*__s = (__extension__ (__builtin_constant_p (__reject) && !__builtin_constant_p (__retval) && (__reject) == '\0' ? (char *) __rawmemchr (__retval, __reject) : __builtin_strchr (__retval, __reject)))) != ((void *)0))
>    *(*__s)++ = '\0';
>  return __retval;
>}
>
>extern __inline __attribute__ ((__gnu_inline__)) char *__strsep_2c (char **__s, char __reject1, char __reject2);
>extern __inline __attribute__ ((__gnu_inline__)) char *
>__strsep_2c (char **__s, char __reject1, char __reject2)
>{
>  register char *__retval = *__s;
>  if (__retval != ((void *)0))
>    {
>      register char *__cp = __retval;
>      while (1)
> {
>   if (*__cp == '\0')
>     {
>       __cp = ((void *)0);
>   break;
>     }
>   if (*__cp == __reject1 || *__cp == __reject2)
>     {
>       *__cp++ = '\0';
>       break;
>     }
>   ++__cp;
> }
>      *__s = __cp;
>    }
>  return __retval;
>}
>
>extern __inline __attribute__ ((__gnu_inline__)) char *__strsep_3c (char **__s, char __reject1, char __reject2,
>       char __reject3);
>extern __inline __attribute__ ((__gnu_inline__)) char *
>__strsep_3c (char **__s, char __reject1, char __reject2, char __reject3)
>{
>  register char *__retval = *__s;
>  if (__retval != ((void *)0))
>    {
>      register char *__cp = __retval;
>      while (1)
> {
>   if (*__cp == '\0')
>     {
>       __cp = ((void *)0);
>   break;
>     }
>   if (*__cp == __reject1 || *__cp == __reject2 || *__cp == __reject3)
>     {
>       *__cp++ = '\0';
>       break;
>     }
>   ++__cp;
> }
>      *__s = __cp;
>    }
>  return __retval;
>}
># 1303 "/usr/include/bits/string2.h" 3 4
>extern char *__strdup (const char *__string) __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));
># 1322 "/usr/include/bits/string2.h" 3 4
>extern char *__strndup (const char *__string, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));
># 424 "/usr/include/string.h" 2 3 4
># 432 "/usr/include/string.h" 3 4
>
># 44 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c" 2
># 1 "/usr/include/unistd.h" 1 3 4
># 28 "/usr/include/unistd.h" 3 4
>
># 173 "/usr/include/unistd.h" 3 4
># 1 "/usr/include/bits/posix_opt.h" 1 3 4
># 174 "/usr/include/unistd.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/environments.h" 1 3 4
># 23 "/usr/include/bits/environments.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 24 "/usr/include/bits/environments.h" 2 3 4
># 178 "/usr/include/unistd.h" 2 3 4
># 197 "/usr/include/unistd.h" 3 4
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 1 3 4
># 198 "/usr/include/unistd.h" 2 3 4
># 245 "/usr/include/unistd.h" 3 4
>typedef __socklen_t socklen_t;
># 258 "/usr/include/unistd.h" 3 4
>extern int access (const char *__name, int __type) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int euidaccess (const char *__name, int __type)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int eaccess (const char *__name, int __type)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int faccessat (int __fd, const char *__file, int __type, int __flag)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2))) ;
># 304 "/usr/include/unistd.h" 3 4
>extern __off64_t lseek (int __fd, __off64_t __offset, int __whence) __asm__ ("" "lseek64") __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
>     __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern int close (int __fd);
>
>
>
>
>
>
>extern ssize_t read (int __fd, void *__buf, size_t __nbytes) ;
>
>
>
>
>
>extern ssize_t write (int __fd, const void *__buf, size_t __n) ;
># 355 "/usr/include/unistd.h" 3 4
>extern ssize_t pread (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) __asm__ ("" "pread64") ;
>
>
>extern ssize_t pwrite (int __fd, const void *__buf, size_t __nbytes, __off64_t __offset) __asm__ ("" "pwrite64") ;
># 371 "/usr/include/unistd.h" 3 4
>extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
>   __off64_t __offset) ;
>
>
>extern ssize_t pwrite64 (int __fd, const void *__buf, size_t __n,
>    __off64_t __offset) ;
>
>
>
>
>
>
>
>extern int pipe (int __pipedes[2]) __attribute__ ((__nothrow__)) ;
># 393 "/usr/include/unistd.h" 3 4
>extern unsigned int alarm (unsigned int __seconds) __attribute__ ((__nothrow__));
># 405 "/usr/include/unistd.h" 3 4
>extern unsigned int sleep (unsigned int __seconds);
>
>
>
>
>
>
>extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
>     __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern int usleep (__useconds_t __useconds);
># 429 "/usr/include/unistd.h" 3 4
>extern int pause (void);
>
>
>
>extern int chown (const char *__file, __uid_t __owner, __gid_t __group)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>extern int fchown (int __fd, __uid_t __owner, __gid_t __group) __attribute__ ((__nothrow__)) ;
>
>
>
>
>extern int lchown (const char *__file, __uid_t __owner, __gid_t __group)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>
>extern int fchownat (int __fd, const char *__file, __uid_t __owner,
>       __gid_t __group, int __flag)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2))) ;
>
>
>
>extern int chdir (const char *__path) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>extern int fchdir (int __fd) __attribute__ ((__nothrow__)) ;
># 471 "/usr/include/unistd.h" 3 4
>extern char *getcwd (char *__buf, size_t __size) __attribute__ ((__nothrow__)) ;
>
>
>
>
>
>extern char *get_current_dir_name (void) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern char *getwd (char *__buf)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) ;
>
>
>
>
>extern int dup (int __fd) __attribute__ ((__nothrow__)) ;
>
>
>extern int dup2 (int __fd, int __fd2) __attribute__ ((__nothrow__));
>
>
>extern char **__environ;
>
>extern char **environ;
>
>
>
>
>
>extern int execve (const char *__path, char *const __argv[],
>     char *const __envp[]) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int fexecve (int __fd, char *const __argv[], char *const __envp[])
>     __attribute__ ((__nothrow__));
>
>
>
>
>extern int execv (const char *__path, char *const __argv[])
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int execle (const char *__path, const char *__arg, ...)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int execl (const char *__path, const char *__arg, ...)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int execvp (const char *__file, char *const __argv[])
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int execlp (const char *__file, const char *__arg, ...)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int nice (int __inc) __attribute__ ((__nothrow__)) ;
>
>
>
>
>extern void _exit (int __status) __attribute__ ((__noreturn__));
>
>
>
>
>
># 1 "/usr/include/bits/confname.h" 1 3 4
># 26 "/usr/include/bits/confname.h" 3 4
>enum
>  {
>    _PC_LINK_MAX,
>
>    _PC_MAX_CANON,
>
>    _PC_MAX_INPUT,
>
>    _PC_NAME_MAX,
>
>    _PC_PATH_MAX,
>
>    _PC_PIPE_BUF,
>
>    _PC_CHOWN_RESTRICTED,
>
>    _PC_NO_TRUNC,
>
>    _PC_VDISABLE,
>
>    _PC_SYNC_IO,
>
>    _PC_ASYNC_IO,
>
>    _PC_PRIO_IO,
>
>    _PC_SOCK_MAXBUF,
>
>    _PC_FILESIZEBITS,
>
>    _PC_REC_INCR_XFER_SIZE,
>
>    _PC_REC_MAX_XFER_SIZE,
>
>    _PC_REC_MIN_XFER_SIZE,
>
>    _PC_REC_XFER_ALIGN,
>
>    _PC_ALLOC_SIZE_MIN,
>
>    _PC_SYMLINK_MAX,
>
>    _PC_2_SYMLINKS
>
>  };
>
>
>enum
>  {
>    _SC_ARG_MAX,
>
>    _SC_CHILD_MAX,
>
>    _SC_CLK_TCK,
>
>    _SC_NGROUPS_MAX,
>
>    _SC_OPEN_MAX,
>
>    _SC_STREAM_MAX,
>
>    _SC_TZNAME_MAX,
>
>    _SC_JOB_CONTROL,
>
>    _SC_SAVED_IDS,
>
>    _SC_REALTIME_SIGNALS,
>
>    _SC_PRIORITY_SCHEDULING,
>
>    _SC_TIMERS,
>
>    _SC_ASYNCHRONOUS_IO,
>
>    _SC_PRIORITIZED_IO,
>
>    _SC_SYNCHRONIZED_IO,
>
>    _SC_FSYNC,
>
>    _SC_MAPPED_FILES,
>
>    _SC_MEMLOCK,
>
>    _SC_MEMLOCK_RANGE,
>
>    _SC_MEMORY_PROTECTION,
>
>    _SC_MESSAGE_PASSING,
>
>    _SC_SEMAPHORES,
>
>    _SC_SHARED_MEMORY_OBJECTS,
>
>    _SC_AIO_LISTIO_MAX,
>
>    _SC_AIO_MAX,
>
>    _SC_AIO_PRIO_DELTA_MAX,
>
>    _SC_DELAYTIMER_MAX,
>
>    _SC_MQ_OPEN_MAX,
>
>    _SC_MQ_PRIO_MAX,
>
>    _SC_VERSION,
>
>    _SC_PAGESIZE,
>
>
>    _SC_RTSIG_MAX,
>
>    _SC_SEM_NSEMS_MAX,
>
>    _SC_SEM_VALUE_MAX,
>
>    _SC_SIGQUEUE_MAX,
>
>    _SC_TIMER_MAX,
>
>
>
>
>    _SC_BC_BASE_MAX,
>
>    _SC_BC_DIM_MAX,
>
>    _SC_BC_SCALE_MAX,
>
>    _SC_BC_STRING_MAX,
>
>    _SC_COLL_WEIGHTS_MAX,
>
>    _SC_EQUIV_CLASS_MAX,
>
>    _SC_EXPR_NEST_MAX,
>
>    _SC_LINE_MAX,
>
>    _SC_RE_DUP_MAX,
>
>    _SC_CHARCLASS_NAME_MAX,
>
>
>    _SC_2_VERSION,
>
>    _SC_2_C_BIND,
>
>    _SC_2_C_DEV,
>
>    _SC_2_FORT_DEV,
>
>    _SC_2_FORT_RUN,
>
>    _SC_2_SW_DEV,
>
>    _SC_2_LOCALEDEF,
>
>
>    _SC_PII,
>
>    _SC_PII_XTI,
>
>    _SC_PII_SOCKET,
>
>    _SC_PII_INTERNET,
>
>    _SC_PII_OSI,
>
>    _SC_POLL,
>
>    _SC_SELECT,
>
>    _SC_UIO_MAXIOV,
>
>    _SC_IOV_MAX = _SC_UIO_MAXIOV,
>
>    _SC_PII_INTERNET_STREAM,
>
>    _SC_PII_INTERNET_DGRAM,
>
>    _SC_PII_OSI_COTS,
>
>    _SC_PII_OSI_CLTS,
>
>    _SC_PII_OSI_M,
>
>    _SC_T_IOV_MAX,
>
>
>
>    _SC_THREADS,
>
>    _SC_THREAD_SAFE_FUNCTIONS,
>
>    _SC_GETGR_R_SIZE_MAX,
>
>    _SC_GETPW_R_SIZE_MAX,
>
>    _SC_LOGIN_NAME_MAX,
>
>    _SC_TTY_NAME_MAX,
>
>    _SC_THREAD_DESTRUCTOR_ITERATIONS,
>
>    _SC_THREAD_KEYS_MAX,
>
>    _SC_THREAD_STACK_MIN,
>
>    _SC_THREAD_THREADS_MAX,
>
>    _SC_THREAD_ATTR_STACKADDR,
>
>    _SC_THREAD_ATTR_STACKSIZE,
>
>    _SC_THREAD_PRIORITY_SCHEDULING,
>
>    _SC_THREAD_PRIO_INHERIT,
>
>    _SC_THREAD_PRIO_PROTECT,
>
>    _SC_THREAD_PROCESS_SHARED,
>
>
>    _SC_NPROCESSORS_CONF,
>
>    _SC_NPROCESSORS_ONLN,
>
>    _SC_PHYS_PAGES,
>
>    _SC_AVPHYS_PAGES,
>
>    _SC_ATEXIT_MAX,
>
>    _SC_PASS_MAX,
>
>
>    _SC_XOPEN_VERSION,
>
>    _SC_XOPEN_XCU_VERSION,
>
>    _SC_XOPEN_UNIX,
>
>    _SC_XOPEN_CRYPT,
>
>    _SC_XOPEN_ENH_I18N,
>
>    _SC_XOPEN_SHM,
>
>
>    _SC_2_CHAR_TERM,
>
>    _SC_2_C_VERSION,
>
>    _SC_2_UPE,
>
>
>    _SC_XOPEN_XPG2,
>
>    _SC_XOPEN_XPG3,
>
>    _SC_XOPEN_XPG4,
>
>
>    _SC_CHAR_BIT,
>
>    _SC_CHAR_MAX,
>
>    _SC_CHAR_MIN,
>
>    _SC_INT_MAX,
>
>    _SC_INT_MIN,
>
>    _SC_LONG_BIT,
>
>    _SC_WORD_BIT,
>
>    _SC_MB_LEN_MAX,
>
>    _SC_NZERO,
>
>    _SC_SSIZE_MAX,
>
>    _SC_SCHAR_MAX,
>
>    _SC_SCHAR_MIN,
>
>    _SC_SHRT_MAX,
>
>    _SC_SHRT_MIN,
>
>    _SC_UCHAR_MAX,
>
>    _SC_UINT_MAX,
>
>    _SC_ULONG_MAX,
>
>    _SC_USHRT_MAX,
>
>
>    _SC_NL_ARGMAX,
>
>    _SC_NL_LANGMAX,
>
>    _SC_NL_MSGMAX,
>
>    _SC_NL_NMAX,
>
>    _SC_NL_SETMAX,
>
>    _SC_NL_TEXTMAX,
>
>
>    _SC_XBS5_ILP32_OFF32,
>
>    _SC_XBS5_ILP32_OFFBIG,
>
>    _SC_XBS5_LP64_OFF64,
>
>    _SC_XBS5_LPBIG_OFFBIG,
>
>
>    _SC_XOPEN_LEGACY,
>
>    _SC_XOPEN_REALTIME,
>
>    _SC_XOPEN_REALTIME_THREADS,
>
>
>    _SC_ADVISORY_INFO,
>
>    _SC_BARRIERS,
>
>    _SC_BASE,
>
>    _SC_C_LANG_SUPPORT,
>
>    _SC_C_LANG_SUPPORT_R,
>
>    _SC_CLOCK_SELECTION,
>
>    _SC_CPUTIME,
>
>    _SC_THREAD_CPUTIME,
>
>    _SC_DEVICE_IO,
>
>    _SC_DEVICE_SPECIFIC,
>
>    _SC_DEVICE_SPECIFIC_R,
>
>    _SC_FD_MGMT,
>
>    _SC_FIFO,
>
>    _SC_PIPE,
>
>    _SC_FILE_ATTRIBUTES,
>
>    _SC_FILE_LOCKING,
>
>    _SC_FILE_SYSTEM,
>
>    _SC_MONOTONIC_CLOCK,
>
>    _SC_MULTI_PROCESS,
>
>    _SC_SINGLE_PROCESS,
>
>    _SC_NETWORKING,
>
>    _SC_READER_WRITER_LOCKS,
>
>    _SC_SPIN_LOCKS,
>
>    _SC_REGEXP,
>
>    _SC_REGEX_VERSION,
>
>    _SC_SHELL,
>
>    _SC_SIGNALS,
>
>    _SC_SPAWN,
>
>    _SC_SPORADIC_SERVER,
>
>    _SC_THREAD_SPORADIC_SERVER,
>
>    _SC_SYSTEM_DATABASE,
>
>    _SC_SYSTEM_DATABASE_R,
>
>    _SC_TIMEOUTS,
>
>    _SC_TYPED_MEMORY_OBJECTS,
>
>    _SC_USER_GROUPS,
>
>    _SC_USER_GROUPS_R,
>
>    _SC_2_PBS,
>
>    _SC_2_PBS_ACCOUNTING,
>
>    _SC_2_PBS_LOCATE,
>
>    _SC_2_PBS_MESSAGE,
>
>    _SC_2_PBS_TRACK,
>
>    _SC_SYMLOOP_MAX,
>
>    _SC_STREAMS,
>
>    _SC_2_PBS_CHECKPOINT,
>
>
>    _SC_V6_ILP32_OFF32,
>
>    _SC_V6_ILP32_OFFBIG,
>
>    _SC_V6_LP64_OFF64,
>
>    _SC_V6_LPBIG_OFFBIG,
>
>
>    _SC_HOST_NAME_MAX,
>
>    _SC_TRACE,
>
>    _SC_TRACE_EVENT_FILTER,
>
>    _SC_TRACE_INHERIT,
>
>    _SC_TRACE_LOG,
>
>
>    _SC_LEVEL1_ICACHE_SIZE,
>
>    _SC_LEVEL1_ICACHE_ASSOC,
>
>    _SC_LEVEL1_ICACHE_LINESIZE,
>
>    _SC_LEVEL1_DCACHE_SIZE,
>
>    _SC_LEVEL1_DCACHE_ASSOC,
>
>    _SC_LEVEL1_DCACHE_LINESIZE,
>
>    _SC_LEVEL2_CACHE_SIZE,
>
>    _SC_LEVEL2_CACHE_ASSOC,
>
>    _SC_LEVEL2_CACHE_LINESIZE,
>
>    _SC_LEVEL3_CACHE_SIZE,
>
>    _SC_LEVEL3_CACHE_ASSOC,
>
>    _SC_LEVEL3_CACHE_LINESIZE,
>
>    _SC_LEVEL4_CACHE_SIZE,
>
>    _SC_LEVEL4_CACHE_ASSOC,
>
>    _SC_LEVEL4_CACHE_LINESIZE,
>
>
>
>    _SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,
>
>    _SC_RAW_SOCKETS
>
>  };
>
>
>enum
>  {
>    _CS_PATH,
>
>
>    _CS_V6_WIDTH_RESTRICTED_ENVS,
>
>
>
>    _CS_GNU_LIBC_VERSION,
>
>    _CS_GNU_LIBPTHREAD_VERSION,
>
>
>    _CS_LFS_CFLAGS = 1000,
>
>    _CS_LFS_LDFLAGS,
>
>    _CS_LFS_LIBS,
>
>    _CS_LFS_LINTFLAGS,
>
>    _CS_LFS64_CFLAGS,
>
>    _CS_LFS64_LDFLAGS,
>
>    _CS_LFS64_LIBS,
>
>    _CS_LFS64_LINTFLAGS,
>
>
>    _CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
>
>    _CS_XBS5_ILP32_OFF32_LDFLAGS,
>
>    _CS_XBS5_ILP32_OFF32_LIBS,
>
>    _CS_XBS5_ILP32_OFF32_LINTFLAGS,
>
>    _CS_XBS5_ILP32_OFFBIG_CFLAGS,
>
>    _CS_XBS5_ILP32_OFFBIG_LDFLAGS,
>
>    _CS_XBS5_ILP32_OFFBIG_LIBS,
>
>    _CS_XBS5_ILP32_OFFBIG_LINTFLAGS,
>
>    _CS_XBS5_LP64_OFF64_CFLAGS,
>
>    _CS_XBS5_LP64_OFF64_LDFLAGS,
>
>    _CS_XBS5_LP64_OFF64_LIBS,
>
>    _CS_XBS5_LP64_OFF64_LINTFLAGS,
>
>    _CS_XBS5_LPBIG_OFFBIG_CFLAGS,
>
>    _CS_XBS5_LPBIG_OFFBIG_LDFLAGS,
>
>    _CS_XBS5_LPBIG_OFFBIG_LIBS,
>
>    _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,
>
>
>    _CS_POSIX_V6_ILP32_OFF32_CFLAGS,
>
>    _CS_POSIX_V6_ILP32_OFF32_LDFLAGS,
>
>    _CS_POSIX_V6_ILP32_OFF32_LIBS,
>
>    _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,
>
>    _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,
>
>    _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,
>
>    _CS_POSIX_V6_ILP32_OFFBIG_LIBS,
>
>    _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,
>
>    _CS_POSIX_V6_LP64_OFF64_CFLAGS,
>
>    _CS_POSIX_V6_LP64_OFF64_LDFLAGS,
>
>    _CS_POSIX_V6_LP64_OFF64_LIBS,
>
>    _CS_POSIX_V6_LP64_OFF64_LINTFLAGS,
>
>    _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,
>
>    _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,
>
>    _CS_POSIX_V6_LPBIG_OFFBIG_LIBS,
>
>    _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS
>
>  };
># 555 "/usr/include/unistd.h" 2 3 4
>
>
>extern long int pathconf (const char *__path, int __name)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern long int fpathconf (int __fd, int __name) __attribute__ ((__nothrow__));
>
>
>extern long int sysconf (int __name) __attribute__ ((__nothrow__));
>
>
>
>extern size_t confstr (int __name, char *__buf, size_t __len) __attribute__ ((__nothrow__));
>
>
>
>
>extern __pid_t getpid (void) __attribute__ ((__nothrow__));
>
>
>extern __pid_t getppid (void) __attribute__ ((__nothrow__));
>
>
>
>
>extern __pid_t getpgrp (void) __attribute__ ((__nothrow__));
># 591 "/usr/include/unistd.h" 3 4
>extern __pid_t __getpgid (__pid_t __pid) __attribute__ ((__nothrow__));
>
>extern __pid_t getpgid (__pid_t __pid) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern int setpgid (__pid_t __pid, __pid_t __pgid) __attribute__ ((__nothrow__));
># 617 "/usr/include/unistd.h" 3 4
>extern int setpgrp (void) __attribute__ ((__nothrow__));
># 634 "/usr/include/unistd.h" 3 4
>extern __pid_t setsid (void) __attribute__ ((__nothrow__));
>
>
>
>extern __pid_t getsid (__pid_t __pid) __attribute__ ((__nothrow__));
>
>
>
>extern __uid_t getuid (void) __attribute__ ((__nothrow__));
>
>
>extern __uid_t geteuid (void) __attribute__ ((__nothrow__));
>
>
>extern __gid_t getgid (void) __attribute__ ((__nothrow__));
>
>
>extern __gid_t getegid (void) __attribute__ ((__nothrow__));
>
>
>
>
>extern int getgroups (int __size, __gid_t __list[]) __attribute__ ((__nothrow__)) ;
>
>
>
>extern int group_member (__gid_t __gid) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern int setuid (__uid_t __uid) __attribute__ ((__nothrow__));
>
>
>
>
>extern int setreuid (__uid_t __ruid, __uid_t __euid) __attribute__ ((__nothrow__));
>
>
>
>
>extern int seteuid (__uid_t __uid) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern int setgid (__gid_t __gid) __attribute__ ((__nothrow__));
>
>
>
>
>extern int setregid (__gid_t __rgid, __gid_t __egid) __attribute__ ((__nothrow__));
>
>
>
>
>extern int setegid (__gid_t __gid) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
>     __attribute__ ((__nothrow__));
>
>
>
>extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid)
>     __attribute__ ((__nothrow__));
>
>
>
>extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
>     __attribute__ ((__nothrow__));
>
>
>
>extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
>     __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern __pid_t fork (void) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern __pid_t vfork (void) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern char *ttyname (int __fd) __attribute__ ((__nothrow__));
>
>
>
>extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2))) ;
>
>
>
>extern int isatty (int __fd) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern int ttyslot (void) __attribute__ ((__nothrow__));
>
>
>
>
>extern int link (const char *__from, const char *__to)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2))) ;
>
>
>
>
>extern int linkat (int __fromfd, const char *__from, int __tofd,
>     const char *__to, int __flags)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 4))) ;
>
>
>
>
>extern int symlink (const char *__from, const char *__to)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2))) ;
>
>
>
>
>extern ssize_t readlink (const char *__restrict __path,
>    char *__restrict __buf, size_t __len)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2))) ;
>
>
>
>
>extern int symlinkat (const char *__from, int __tofd,
>        const char *__to) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 3))) ;
>
>
>extern ssize_t readlinkat (int __fd, const char *__restrict __path,
>      char *__restrict __buf, size_t __len)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3))) ;
>
>
>
>extern int unlink (const char *__name) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int unlinkat (int __fd, const char *__name, int __flag)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>extern int rmdir (const char *__path) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern __pid_t tcgetpgrp (int __fd) __attribute__ ((__nothrow__));
>
>
>extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern char *getlogin (void);
>
>
>
>
>
>
>
>extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int setlogin (const char *__name) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
># 837 "/usr/include/unistd.h" 3 4
># 1 "/usr/include/getopt.h" 1 3 4
># 59 "/usr/include/getopt.h" 3 4
>extern char *optarg;
># 73 "/usr/include/getopt.h" 3 4
>extern int optind;
>
>
>
>
>extern int opterr;
>
>
>
>extern int optopt;
># 152 "/usr/include/getopt.h" 3 4
>extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
>       __attribute__ ((__nothrow__));
># 838 "/usr/include/unistd.h" 2 3 4
>
>
>
>
>
>
>
>extern int gethostname (char *__name, size_t __len) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int sethostname (const char *__name, size_t __len)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>extern int sethostid (long int __id) __attribute__ ((__nothrow__)) ;
>
>
>
>
>
>extern int getdomainname (char *__name, size_t __len)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>extern int setdomainname (const char *__name, size_t __len)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>extern int vhangup (void) __attribute__ ((__nothrow__));
>
>
>extern int revoke (const char *__file) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>
>
>extern int profil (unsigned short int *__sample_buffer, size_t __size,
>     size_t __offset, unsigned int __scale)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int acct (const char *__name) __attribute__ ((__nothrow__));
>
>
>
>extern char *getusershell (void) __attribute__ ((__nothrow__));
>extern void endusershell (void) __attribute__ ((__nothrow__));
>extern void setusershell (void) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern int daemon (int __nochdir, int __noclose) __attribute__ ((__nothrow__)) ;
>
>
>
>
>
>
>extern int chroot (const char *__path) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>extern char *getpass (const char *__prompt) __attribute__ ((__nonnull__ (1)));
># 923 "/usr/include/unistd.h" 3 4
>extern int fsync (int __fd);
>
>
>
>
>
>
>extern long int gethostid (void);
>
>
>extern void sync (void) __attribute__ ((__nothrow__));
>
>
>
>
>extern int getpagesize (void) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>
>
>extern int getdtablesize (void) __attribute__ ((__nothrow__));
># 952 "/usr/include/unistd.h" 3 4
>extern int truncate (const char *__file, __off64_t __length) __asm__ ("" "truncate64") __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>
>
>extern int truncate64 (const char *__file, __off64_t __length)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) ;
># 973 "/usr/include/unistd.h" 3 4
>extern int ftruncate (int __fd, __off64_t __length) __asm__ ("" "ftruncate64") __attribute__ ((__nothrow__)) ;
>
>
>
>
>
>
>extern int ftruncate64 (int __fd, __off64_t __length) __attribute__ ((__nothrow__)) ;
># 990 "/usr/include/unistd.h" 3 4
>extern int brk (void *__addr) __attribute__ ((__nothrow__)) ;
>
>
>
>
>
>extern void *sbrk (intptr_t __delta) __attribute__ ((__nothrow__));
># 1011 "/usr/include/unistd.h" 3 4
>extern long int syscall (long int __sysno, ...) __attribute__ ((__nothrow__));
># 1065 "/usr/include/unistd.h" 3 4
>extern int fdatasync (int __fildes);
>
>
>
>
>
>
>
>extern char *crypt (const char *__key, const char *__salt)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern void encrypt (char *__block, int __edflag) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern void swab (const void *__restrict __from, void *__restrict __to,
>    ssize_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>
>extern char *ctermid (char *__s) __attribute__ ((__nothrow__));
># 1103 "/usr/include/unistd.h" 3 4
>
># 45 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c" 2
># 1 "/usr/include/sys/param.h" 1 3 4
># 22 "/usr/include/sys/param.h" 3 4
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/limits.h" 1 3 4
># 11 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/limits.h" 3 4
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/syslimits.h" 1 3 4
>
>
>
>
>
>
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/limits.h" 1 3 4
># 122 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/limits.h" 3 4
># 1 "/usr/include/limits.h" 1 3 4
># 145 "/usr/include/limits.h" 3 4
># 1 "/usr/include/bits/posix1_lim.h" 1 3 4
># 153 "/usr/include/bits/posix1_lim.h" 3 4
># 1 "/usr/include/bits/local_lim.h" 1 3 4
># 36 "/usr/include/bits/local_lim.h" 3 4
># 1 "/usr/include/linux/limits.h" 1 3 4
># 37 "/usr/include/bits/local_lim.h" 2 3 4
># 154 "/usr/include/bits/posix1_lim.h" 2 3 4
># 146 "/usr/include/limits.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/posix2_lim.h" 1 3 4
># 150 "/usr/include/limits.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/xopen_lim.h" 1 3 4
># 34 "/usr/include/bits/xopen_lim.h" 3 4
># 1 "/usr/include/bits/stdio_lim.h" 1 3 4
># 35 "/usr/include/bits/xopen_lim.h" 2 3 4
># 154 "/usr/include/limits.h" 2 3 4
># 123 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/limits.h" 2 3 4
># 8 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/syslimits.h" 2 3 4
># 12 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/limits.h" 2 3 4
># 23 "/usr/include/sys/param.h" 2 3 4
>
># 1 "/usr/include/linux/param.h" 1 3 4
>
>
>
># 1 "/usr/include/asm/param.h" 1 3 4
># 5 "/usr/include/linux/param.h" 2 3 4
># 25 "/usr/include/sys/param.h" 2 3 4
># 46 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c" 2
>
>
># 1 "/net/ma/home/roland/redhat/stock-elfutils/src/../libelf/elf-knowledge.h" 1
># 49 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c" 2
># 1 "/net/ma/home/roland/redhat/stock-elfutils/src/ld.h" 1
># 30 "/net/ma/home/roland/redhat/stock-elfutils/src/ld.h"
># 1 "/usr/include/obstack.h" 1 3 4
># 144 "/usr/include/obstack.h" 3 4
>struct _obstack_chunk
>{
>  char *limit;
>  struct _obstack_chunk *prev;
>  char contents[4];
>};
>
>struct obstack
>{
>  long chunk_size;
>  struct _obstack_chunk *chunk;
>  char *object_base;
>  char *next_free;
>  char *chunk_limit;
>  union
>  {
>    int tempint;
>    void *tempptr;
>  } temp;
>  int alignment_mask;
>
>
>
>  struct _obstack_chunk *(*chunkfun) (void *, long);
>  void (*freefun) (void *, struct _obstack_chunk *);
>  void *extra_arg;
>  unsigned use_extra_arg:1;
>  unsigned maybe_empty_object:1;
>
>
>
>  unsigned alloc_failed:1;
>
>
>};
>
>
>
>extern void _obstack_newchunk (struct obstack *, int);
>extern int _obstack_begin (struct obstack *, int, int,
>       void *(*) (long), void (*) (void *));
>extern int _obstack_begin_1 (struct obstack *, int, int,
>        void *(*) (void *, long),
>        void (*) (void *, void *), void *);
>extern int _obstack_memory_used (struct obstack *);
>
>void obstack_free (struct obstack *obstack, void *block);
>
>
>
>
>
>
>extern void (*obstack_alloc_failed_handler) (void);
>
>
>extern int obstack_exit_failure;
># 31 "/net/ma/home/roland/redhat/stock-elfutils/src/ld.h" 2
>
>
># 1 "/net/ma/home/roland/redhat/stock-elfutils/src/xelf.h" 1
># 28 "/net/ma/home/roland/redhat/stock-elfutils/src/xelf.h"
># 1 "../config.h" 1
># 29 "/net/ma/home/roland/redhat/stock-elfutils/src/xelf.h" 2
>
>
># 1 "/net/ma/home/roland/redhat/stock-elfutils/src/../libebl/libebl.h" 1
># 54 "/net/ma/home/roland/redhat/stock-elfutils/src/../libebl/libebl.h"
># 1 "/net/ma/home/roland/redhat/stock-elfutils/src/../libdw/libdw.h" 1
># 55 "/net/ma/home/roland/redhat/stock-elfutils/src/../libdw/libdw.h"
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 1 3 4
># 152 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 3 4
>typedef int ptrdiff_t;
># 56 "/net/ma/home/roland/redhat/stock-elfutils/src/../libdw/libdw.h" 2
># 75 "/net/ma/home/roland/redhat/stock-elfutils/src/../libdw/libdw.h"
>typedef enum
>  {
>    DWARF_C_READ,
>    DWARF_C_RDWR,
>    DWARF_C_WRITE,
>  }
>Dwarf_Cmd;
>
>
>
>enum
>{
>  DWARF_CB_OK = 0,
>  DWARF_CB_ABORT
>};
>
>
>
>enum
>  {
>    DW_TAG_invalid = 0
>
>  };
>
>
>
>typedef GElf_Off Dwarf_Off;
>
>
>typedef GElf_Addr Dwarf_Addr;
>
>
>typedef GElf_Xword Dwarf_Word;
>typedef GElf_Sxword Dwarf_Sword;
>
>typedef GElf_Half Dwarf_Half;
>
>
>
>typedef struct Dwarf_Abbrev Dwarf_Abbrev;
>
>
>
>
>
>typedef struct Dwarf_Lines_s Dwarf_Lines;
>
>
>typedef struct Dwarf_Line_s Dwarf_Line;
>
>
>typedef struct Dwarf_Files_s Dwarf_Files;
>
>
>typedef struct Dwarf_Arange_s Dwarf_Arange;
>
>
>typedef struct Dwarf_Aranges_s Dwarf_Aranges;
>
>
>struct Dwarf_CU;
>
>
>typedef struct Dwarf_Macro_s Dwarf_Macro;
>
>
>typedef struct
>{
>  unsigned int code;
>  unsigned int form;
>  unsigned char *valp;
>  struct Dwarf_CU *cu;
>} Dwarf_Attribute;
>
>
>
>typedef struct
>{
>  Dwarf_Word length;
>  unsigned char *data;
>} Dwarf_Block;
>
>
>
>typedef struct
>{
>
>  void *addr;
>  struct Dwarf_CU *cu;
>  Dwarf_Abbrev *abbrev;
>
>  long int padding__;
>} Dwarf_Die;
>
>
>
>
>
>
>typedef struct
>{
>  Dwarf_Off cu_offset;
>  Dwarf_Off die_offset;
>  const char *name;
>} Dwarf_Global;
>
>
>
>
>typedef struct
>{
>  uint8_t atom;
>  Dwarf_Word number;
>  Dwarf_Word number2;
>  Dwarf_Word offset;
>} Dwarf_Op;
>
>
>
>typedef struct Dwarf Dwarf;
>
>
>
>
>
>
>typedef void (*__attribute__ ((noreturn)) Dwarf_OOM) (void);
># 210 "/net/ma/home/roland/redhat/stock-elfutils/src/../libdw/libdw.h"
>extern Dwarf *dwarf_begin (int fildes, Dwarf_Cmd cmd);
>
>
>extern Dwarf *dwarf_begin_elf (Elf *elf, Dwarf_Cmd cmd, Elf_Scn *scngrp);
>
>
>extern Elf *dwarf_getelf (Dwarf *dwarf);
>
>
>extern int dwarf_end (Dwarf *dwarf);
>
>
>
>extern Elf_Data *dwarf_getscn_info (Dwarf *dwarf);
>
>
>extern int dwarf_nextcu (Dwarf *dwarf, Dwarf_Off off, Dwarf_Off *next_off,
>    size_t *header_sizep, Dwarf_Off *abbrev_offsetp,
>    uint8_t *address_sizep, uint8_t *offset_sizep)
>     __attribute__ ((__nonnull__ (3)));
>
>
>
>extern Dwarf_Die *dwarf_offdie (Dwarf *dbg, Dwarf_Off offset,
>    Dwarf_Die *result) __attribute__ ((__nonnull__ (3)));
>
>
>extern Dwarf_Off dwarf_dieoffset (Dwarf_Die *die);
>
>
>extern Dwarf_Off dwarf_cuoffset (Dwarf_Die *die);
>
>
>extern Dwarf_Die *dwarf_diecu (Dwarf_Die *die, Dwarf_Die *result,
>          uint8_t *address_sizep, uint8_t *offset_sizep)
>     __attribute__ ((__nonnull__ (2)));
>
>
>extern Dwarf_Die *dwarf_addrdie (Dwarf *dbg, Dwarf_Addr addr,
>     Dwarf_Die *result) __attribute__ ((__nonnull__ (3)));
>
>
>extern int dwarf_child (Dwarf_Die *die, Dwarf_Die *result)
>     __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>
>
>extern int dwarf_siblingof (Dwarf_Die *die, Dwarf_Die *result)
>     __attribute__ ((__nonnull__ (2)));
>
>
>extern int dwarf_haschildren (Dwarf_Die *die) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern ptrdiff_t dwarf_getattrs (Dwarf_Die *die,
>     int (*callback) (Dwarf_Attribute *, void *),
>     void *arg, ptrdiff_t offset)
>     __attribute__ ((__nonnull__ (2)));
>
>
>extern int dwarf_tag (Dwarf_Die *die) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern Dwarf_Attribute *dwarf_attr (Dwarf_Die *die, unsigned int search_name,
>        Dwarf_Attribute *result)
>     __attribute__ ((__nonnull__ (3)));
>
>
>extern int dwarf_hasattr (Dwarf_Die *die, unsigned int search_name);
>
>
>
>extern Dwarf_Attribute *dwarf_attr_integrate (Dwarf_Die *die,
>           unsigned int search_name,
>           Dwarf_Attribute *result)
>     __attribute__ ((__nonnull__ (3)));
>extern int dwarf_hasattr_integrate (Dwarf_Die *die, unsigned int search_name);
>
>
>
>
>
>extern int dwarf_hasform (Dwarf_Attribute *attr, unsigned int search_form);
>
>
>extern unsigned int dwarf_whatattr (Dwarf_Attribute *attr);
>
>
>extern unsigned int dwarf_whatform (Dwarf_Attribute *attr);
>
>
>
>extern const char *dwarf_formstring (Dwarf_Attribute *attrp);
>
>
>extern int dwarf_formudata (Dwarf_Attribute *attr, Dwarf_Word *return_uval)
>     __attribute__ ((__nonnull__ (2)));
>
>
>extern int dwarf_formsdata (Dwarf_Attribute *attr, Dwarf_Sword *return_uval)
>     __attribute__ ((__nonnull__ (2)));
>
>
>extern int dwarf_formaddr (Dwarf_Attribute *attr, Dwarf_Addr *return_addr)
>     __attribute__ ((__nonnull__ (2)));
>
>
>
>extern int dwarf_formref (Dwarf_Attribute *attr, Dwarf_Off *return_offset)
>     __attribute__ ((__nonnull__ (2))) __attribute__ ((__deprecated__));
>
>
>extern Dwarf_Die *dwarf_formref_die (Dwarf_Attribute *attr, Dwarf_Die *die_mem)
>     __attribute__ ((__nonnull__ (2)));
>
>
>extern int dwarf_formblock (Dwarf_Attribute *attr, Dwarf_Block *return_block)
>     __attribute__ ((__nonnull__ (2)));
>
>
>extern int dwarf_formflag (Dwarf_Attribute *attr, _Bool *return_bool)
>     __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>extern const char *dwarf_diename (Dwarf_Die *die);
>
>
>extern int dwarf_highpc (Dwarf_Die *die, Dwarf_Addr *return_addr)
>     __attribute__ ((__nonnull__ (2)));
>
>
>extern int dwarf_lowpc (Dwarf_Die *die, Dwarf_Addr *return_addr)
>     __attribute__ ((__nonnull__ (2)));
>
>
>extern int dwarf_entrypc (Dwarf_Die *die, Dwarf_Addr *return_addr)
>     __attribute__ ((__nonnull__ (2)));
>
>
>
>extern int dwarf_haspc (Dwarf_Die *die, Dwarf_Addr pc);
># 372 "/net/ma/home/roland/redhat/stock-elfutils/src/../libdw/libdw.h"
>extern ptrdiff_t dwarf_ranges (Dwarf_Die *die,
>          ptrdiff_t offset, Dwarf_Addr *basep,
>          Dwarf_Addr *startp, Dwarf_Addr *endp);
>
>
>
>extern int dwarf_bytesize (Dwarf_Die *die);
>
>
>extern int dwarf_bitsize (Dwarf_Die *die);
>
>
>extern int dwarf_bitoffset (Dwarf_Die *die);
>
>
>extern int dwarf_arrayorder (Dwarf_Die *die);
>
>
>extern int dwarf_srclang (Dwarf_Die *die);
>
>
>
>extern Dwarf_Abbrev *dwarf_getabbrev (Dwarf_Die *die, Dwarf_Off offset,
>          size_t *lengthp);
>
>
>extern int dwarf_offabbrev (Dwarf *dbg, Dwarf_Off offset, size_t *lengthp,
>       Dwarf_Abbrev *abbrevp)
>     __attribute__ ((__nonnull__ (4)));
>
>
>extern unsigned int dwarf_getabbrevcode (Dwarf_Abbrev *abbrev);
>
>
>extern unsigned int dwarf_getabbrevtag (Dwarf_Abbrev *abbrev);
>
>
>extern int dwarf_abbrevhaschildren (Dwarf_Abbrev *abbrev);
>
>
>extern int dwarf_getattrcnt (Dwarf_Abbrev *abbrev, size_t *attrcntp)
>     __attribute__ ((__nonnull__ (2)));
>
>
>extern int dwarf_getabbrevattr (Dwarf_Abbrev *abbrev, size_t idx,
>    unsigned int *namep, unsigned int *formp,
>    Dwarf_Off *offset);
>
>
>
>extern const char *dwarf_getstring (Dwarf *dbg, Dwarf_Off offset,
>        size_t *lenp);
>
>
>
>extern ptrdiff_t dwarf_getpubnames (Dwarf *dbg,
>        int (*callback) (Dwarf *, Dwarf_Global *,
>           void *),
>        void *arg, ptrdiff_t offset)
>     __attribute__ ((__nonnull__ (2)));
>
>
>
>extern int dwarf_getsrclines (Dwarf_Die *cudie, Dwarf_Lines **lines,
>         size_t *nlines) __attribute__ ((__nonnull__ (2, 3)));
>
>
>extern Dwarf_Line *dwarf_onesrcline (Dwarf_Lines *lines, size_t idx);
>
>
>extern int dwarf_getsrcfiles (Dwarf_Die *cudie, Dwarf_Files **files,
>         size_t *nfiles)
>     __attribute__ ((__nonnull__ (2)));
>
>
>
>extern Dwarf_Line *dwarf_getsrc_die (Dwarf_Die *cudie, Dwarf_Addr addr);
>
>
>extern int dwarf_getsrc_file (Dwarf *dbg, const char *fname, int line, int col,
>         Dwarf_Line ***srcsp, size_t *nsrcs)
>     __attribute__ ((__nonnull__ (2, 5, 6)));
>
>
>
>extern int dwarf_lineaddr (Dwarf_Line *line, Dwarf_Addr *addrp);
>
>
>extern int dwarf_lineno (Dwarf_Line *line, int *linep)
>     __attribute__ ((__nonnull__ (2)));
>
>
>extern int dwarf_linecol (Dwarf_Line *line, int *colp)
>     __attribute__ ((__nonnull__ (2)));
>
>
>extern int dwarf_linebeginstatement (Dwarf_Line *line, _Bool *flagp)
>     __attribute__ ((__nonnull__ (2)));
>
>
>extern int dwarf_lineendsequence (Dwarf_Line *line, _Bool *flagp)
>     __attribute__ ((__nonnull__ (2)));
>
>
>extern int dwarf_lineblock (Dwarf_Line *line, _Bool *flagp)
>     __attribute__ ((__nonnull__ (2)));
>
>
>extern int dwarf_lineprologueend (Dwarf_Line *line, _Bool *flagp)
>     __attribute__ ((__nonnull__ (2)));
>
>
>extern int dwarf_lineepiloguebegin (Dwarf_Line *line, _Bool *flagp)
>     __attribute__ ((__nonnull__ (2)));
>
>
>
>extern const char *dwarf_linesrc (Dwarf_Line *line,
>      Dwarf_Word *mtime, Dwarf_Word *length);
>
>
>extern const char *dwarf_filesrc (Dwarf_Files *file, size_t idx,
>      Dwarf_Word *mtime, Dwarf_Word *length);
>
>
>
>
>
>extern int dwarf_getsrcdirs (Dwarf_Files *files,
>        const char *const **result, size_t *ndirs)
>  __attribute__ ((__nonnull__ (2, 3)));
>
>
>
>extern int dwarf_getlocation (Dwarf_Attribute *attr, Dwarf_Op **expr,
>         size_t *exprlen) __attribute__ ((__nonnull__ (2, 3)));
># 517 "/net/ma/home/roland/redhat/stock-elfutils/src/../libdw/libdw.h"
>extern int dwarf_getlocation_addr (Dwarf_Attribute *attr, Dwarf_Addr address,
>       Dwarf_Op **exprs, size_t *exprlens,
>       size_t nlocs);
># 528 "/net/ma/home/roland/redhat/stock-elfutils/src/../libdw/libdw.h"
>extern int dwarf_getscopes (Dwarf_Die *cudie, Dwarf_Addr pc,
>       Dwarf_Die **scopes);
>
>
>
>
>
>
>
>extern int dwarf_getscopes_die (Dwarf_Die *die, Dwarf_Die **scopes);
># 549 "/net/ma/home/roland/redhat/stock-elfutils/src/../libdw/libdw.h"
>extern int dwarf_getscopevar (Dwarf_Die *scopes, int nscopes,
>         const char *name, int skip_shadows,
>         const char *match_file,
>         int match_lineno, int match_linecol,
>         Dwarf_Die *result);
>
>
>
>
>extern int dwarf_getaranges (Dwarf *dbg, Dwarf_Aranges **aranges,
>        size_t *naranges)
>     __attribute__ ((__nonnull__ (2)));
>
>
>extern Dwarf_Arange *dwarf_onearange (Dwarf_Aranges *aranges, size_t idx);
>
>
>extern int dwarf_getarangeinfo (Dwarf_Arange *arange, Dwarf_Addr *addrp,
>    Dwarf_Word *lengthp, Dwarf_Off *offsetp);
>
>
>extern Dwarf_Arange *dwarf_getarange_addr (Dwarf_Aranges *aranges,
>        Dwarf_Addr addr);
>
>
>
>
>extern ptrdiff_t dwarf_getfuncs (Dwarf_Die *cudie,
>     int (*callback) (Dwarf_Die *, void *),
>     void *arg, ptrdiff_t offset);
>
>
>
>extern const char *dwarf_decl_file (Dwarf_Die *decl);
>
>
>extern int dwarf_decl_line (Dwarf_Die *decl, int *linep)
>     __attribute__ ((__nonnull__ (2)));
>
>
>extern int dwarf_decl_column (Dwarf_Die *decl, int *colp)
>     __attribute__ ((__nonnull__ (2)));
>
>
>
>extern int dwarf_func_inline (Dwarf_Die *func);
>
>
>extern int dwarf_func_inline_instances (Dwarf_Die *func,
>     int (*callback) (Dwarf_Die *, void *),
>     void *arg);
>
>
>
>
>
>
>extern int dwarf_entry_breakpoints (Dwarf_Die *die, Dwarf_Addr **bkpts);
>
>
>
>
>extern ptrdiff_t dwarf_getmacros (Dwarf_Die *cudie,
>      int (*callback) (Dwarf_Macro *, void *),
>      void *arg, ptrdiff_t offset)
>     __attribute__ ((__nonnull__ (2)));
>
>
>extern int dwarf_macro_opcode (Dwarf_Macro *macro, unsigned int *opcodep)
>     __attribute__ ((__nonnull__ (2)));
>
>
>extern int dwarf_macro_param1 (Dwarf_Macro *macro, Dwarf_Word *paramp)
>     __attribute__ ((__nonnull__ (2)));
>
>
>extern int dwarf_macro_param2 (Dwarf_Macro *macro, Dwarf_Word *paramp,
>          const char **strp);
>
>
>
>
>extern int dwarf_errno (void);
>
>
>
>
>
>extern const char *dwarf_errmsg (int err);
>
>
>
>extern Dwarf_OOM dwarf_new_oom_handler (Dwarf *dbg, Dwarf_OOM handler);
>
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) unsigned int
>dwarf_whatattr (Dwarf_Attribute *attr)
>{
>  return attr == ((void *)0) ? 0 : attr->code;
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) unsigned int
>dwarf_whatform (Dwarf_Attribute *attr)
>{
>  return attr == ((void *)0) ? 0 : attr->form;
>}
># 55 "/net/ma/home/roland/redhat/stock-elfutils/src/../libebl/libebl.h" 2
>
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 1 3 4
># 57 "/net/ma/home/roland/redhat/stock-elfutils/src/../libebl/libebl.h" 2
>
>
>
>
>
>
>typedef struct ebl Ebl;
>
>
>
>
>
>
>
>extern Ebl *ebl_openbackend (Elf *elf);
>
>extern Ebl *ebl_openbackend_machine (GElf_Half machine);
>
>extern Ebl *ebl_openbackend_emulation (const char *emulation);
>
>
>extern void ebl_closebackend (Ebl *bh);
>
>
>
>
>
>extern int ebl_get_elfmachine (Ebl *ebl) __attribute__ ((__pure__));
>
>
>extern int ebl_get_elfclass (Ebl *ebl) __attribute__ ((__pure__));
>
>
>extern int ebl_get_elfdata (Ebl *ebl) __attribute__ ((__pure__));
>
>
>
>
>
>
>extern const char *ebl_backend_name (Ebl *ebl);
>
>
>extern const char *ebl_object_type_name (Ebl *ebl, int object,
>      char *buf, size_t len);
>
>
>extern const char *ebl_reloc_type_name (Ebl *ebl, int reloc,
>     char *buf, size_t len);
>
>
>extern _Bool ebl_reloc_type_check (Ebl *ebl, int reloc);
>
>
>extern _Bool ebl_reloc_valid_use (Ebl *ebl, int reloc);
>
>
>
>extern Elf_Type ebl_reloc_simple_type (Ebl *ebl, int reloc);
>
>
>
>extern _Bool ebl_gotpc_reloc_check (Ebl *ebl, int reloc);
>
>
>extern const char *ebl_segment_type_name (Ebl *ebl, int segment,
>       char *buf, size_t len);
>
>
>extern const char *ebl_section_type_name (Ebl *ebl, int section,
>       char *buf, size_t len);
>
>
>extern const char *ebl_section_name (Ebl *ebl, int section, int xsection,
>         char *buf, size_t len,
>         const char *scnnames[], size_t shnum);
>
>
>extern const char *ebl_machine_flag_name (Ebl *ebl, GElf_Word flags,
>       char *buf, size_t len);
>
>
>extern _Bool ebl_machine_flag_check (Ebl *ebl, GElf_Word flags);
>
>
>extern _Bool ebl_machine_section_flag_check (Ebl *ebl, GElf_Xword flags);
>
>
>extern const char *ebl_symbol_type_name (Ebl *ebl, int symbol,
>      char *buf, size_t len);
>
>
>extern const char *ebl_symbol_binding_name (Ebl *ebl, int binding,
>         char *buf, size_t len);
>
>
>extern const char *ebl_dynamic_tag_name (Ebl *ebl, int64_t tag,
>      char *buf, size_t len);
>
>
>extern _Bool ebl_dynamic_tag_check (Ebl *ebl, int64_t tag);
>
>
>
>extern _Bool ebl_check_special_symbol (Ebl *ebl, GElf_Ehdr *ehdr,
>          const GElf_Sym *sym, const char *name,
>          const GElf_Shdr *destshdr);
>
>
>extern GElf_Word ebl_sh_flags_combine (Ebl *ebl, GElf_Word flags1,
>           GElf_Word flags2);
>
>
>extern const char *ebl_osabi_name (Ebl *ebl, int osabi, char *buf, size_t len);
>
>
>
>extern const char *ebl_core_note_type_name (Ebl *ebl, uint32_t type, char *buf,
>         size_t len);
>
>
>extern const char *ebl_object_note_type_name (Ebl *ebl, uint32_t type,
>           char *buf, size_t len);
>
>
>extern void ebl_object_note (Ebl *ebl, const char *name, uint32_t type,
>        uint32_t descsz, const char *desc);
>
>
>extern _Bool ebl_debugscn_p (Ebl *ebl, const char *name);
>
>
>extern _Bool ebl_copy_reloc_p (Ebl *ebl, int reloc);
>
>
>extern _Bool ebl_none_reloc_p (Ebl *ebl, int reloc);
>
>
>extern _Bool ebl_relative_reloc_p (Ebl *ebl, int reloc);
>
>
>extern _Bool ebl_section_strip_p (Ebl *ebl, const GElf_Ehdr *ehdr,
>     const GElf_Shdr *shdr, const char *name,
>     _Bool remove_comment, _Bool only_remove_debug);
>
>
>extern _Bool ebl_bss_plt_p (Ebl *ebl, GElf_Ehdr *ehdr);
>
>
>extern int ebl_sysvhash_entrysize (Ebl *ebl);
># 217 "/net/ma/home/roland/redhat/stock-elfutils/src/../libebl/libebl.h"
>extern int ebl_return_value_location (Ebl *ebl,
>          Dwarf_Die *functypedie,
>          const Dwarf_Op **locops);
># 231 "/net/ma/home/roland/redhat/stock-elfutils/src/../libebl/libebl.h"
>extern ssize_t ebl_register_info (Ebl *ebl,
>      int regno, char *name, size_t namelen,
>      const char **prefix, const char **setname,
>      int *bits, int *type);
>
>
>
>struct Ebl_Strtab;
>struct Ebl_Strent;
>
>
>extern struct Ebl_Strtab *ebl_strtabinit (_Bool nullstr);
>
>
>extern void ebl_strtabfree (struct Ebl_Strtab *st);
>
>
>extern struct Ebl_Strent *ebl_strtabadd (struct Ebl_Strtab *st,
>      const char *str, size_t len);
>
>
>
>extern void ebl_strtabfinalize (struct Ebl_Strtab *st, Elf_Data *data);
>
>
>extern size_t ebl_strtaboffset (struct Ebl_Strent *se);
>
>
>extern const char *ebl_string (struct Ebl_Strent *se);
>
>
>
>struct Ebl_WStrtab;
>struct Ebl_WStrent;
>
>
>extern struct Ebl_WStrtab *ebl_wstrtabinit (_Bool nullstr);
>
>
>extern void ebl_wstrtabfree (struct Ebl_WStrtab *st);
>
>
>extern struct Ebl_WStrent *ebl_wstrtabadd (struct Ebl_WStrtab *st,
>        const wchar_t *str, size_t len);
>
>
>
>extern void ebl_wstrtabfinalize (struct Ebl_WStrtab *st, Elf_Data *data);
>
>
>extern size_t ebl_wstrtaboffset (struct Ebl_WStrent *se);
>
>
>
>struct Ebl_GStrtab;
>struct Ebl_GStrent;
>
>
>extern struct Ebl_GStrtab *ebl_gstrtabinit (unsigned int width, _Bool nullstr);
>
>
>extern void ebl_gstrtabfree (struct Ebl_GStrtab *st);
>
>
>extern struct Ebl_GStrent *ebl_gstrtabadd (struct Ebl_GStrtab *st,
>        const char *str, size_t len);
>
>
>
>extern void ebl_gstrtabfinalize (struct Ebl_GStrtab *st, Elf_Data *data);
>
>
>extern size_t ebl_gstrtaboffset (struct Ebl_GStrent *se);
>
>
>
>typedef struct
>{
>  Dwarf_Half offset;
>  Dwarf_Half regno;
>  uint8_t bits;
>  uint8_t pad;
>  Dwarf_Half count;
>} Ebl_Register_Location;
>
>
>typedef struct
>{
>  const char *name;
>  const char *group;
>  Dwarf_Half offset;
>  Dwarf_Half count;
>  Elf_Type type;
>  char format;
>  _Bool thread_identifier;
>} Ebl_Core_Item;
>
>
>
>extern int ebl_core_note (Ebl *ebl, GElf_Word n_type, GElf_Word descsz,
>     GElf_Word *regs_offset, size_t *nregloc,
>     const Ebl_Register_Location **reglocs,
>     size_t *nitems, const Ebl_Core_Item **items)
>  __attribute__ ((__nonnull__ (1, 4, 5, 6, 7, 8)));
>
>
>extern int ebl_auxv_info (Ebl *ebl, GElf_Xword a_type,
>     const char **name, const char **format)
>  __attribute__ ((__nonnull__ (1, 3, 4)));
># 32 "/net/ma/home/roland/redhat/stock-elfutils/src/xelf.h" 2
># 34 "/net/ma/home/roland/redhat/stock-elfutils/src/ld.h" 2
># 44 "/net/ma/home/roland/redhat/stock-elfutils/src/ld.h"
>enum extract_rule
>  {
>    defaultextract,
>
>    weakextract,
>
>    allextract
>
>  };
>
>
>
>enum file_type
>  {
>    no_file_type = 0,
>    executable_file_type,
>    dso_file_type,
>    dso_needed_file_type,
>    relocatable_file_type,
>    archive_file_type
>  };
>
>
>struct usedfiles
>{
>
>  struct usedfiles *next;
>
>  _Bool group_start;
>
>  _Bool group_end;
># 84 "/net/ma/home/roland/redhat/stock-elfutils/src/ld.h"
>  struct usedfiles *group_backref;
>
>
>  const char *fname;
>
>  const char *rfname;
>
>
>  const char *soname;
>
>  struct Ebl_Strent *sonameent;
>
>
>  dev_t dev;
>  ino_t ino;
>
>  enum
>    {
>      not_opened,
>      opened,
>      in_archive,
>      closed
>    } status;
>
>
>  enum extract_rule extract_rule;
>
>
>  _Bool lazyload;
>
>
>
>  _Bool used;
>
>
>
>  _Bool as_needed;
>
>
>
>
>  int archive_seq;
>
>
>  struct usedfiles *archive_file;
>
>
>
>  enum file_type file_type;
>
>  Elf *elf;
>
>
>
>
>
>
>  GElf_Ehdr ehdr;
># 151 "/net/ma/home/roland/redhat/stock-elfutils/src/ld.h"
>  size_t shstrndx;
>
>
>  struct scninfo
>  {
>
>
>
>
>    Elf_Scn *scn;
>
>
>
>
>
>    GElf_Shdr shdr;
>
>
>
>    GElf_Off offset;
>
>    Elf32_Word outscnndx;
>
>    Elf32_Word allsectionsidx;
>
>    _Bool used;
>
>    _Bool unused_comdat;
>
>    _Bool comdat_group;
>
>    Elf32_Word grpid;
>
>    struct usedfiles *fileinfo;
>
>
>    struct symbol *symbols;
>
>
>    size_t relsize;
>
>
>    struct scninfo *next;
>  } *scninfo;
>
>
>  struct scninfo *groups;
>
>
>
>
>  Elf_Data *symtabdata;
>
>  Elf_Data *xndxdata;
>
>  Elf_Data *dynsymtabdata;
>
>  Elf_Data *versymdata;
>
>  Elf_Data *verdefdata;
>
>  size_t nverdef;
>
>
>  GElf_Versym *verdefused;
>
>  size_t nverdefused;
>
>  struct Ebl_Strent **verdefent;
>
>  Elf_Data *verneeddata;
>
>  Elf32_Word symstridx;
>
>  Elf32_Word dynsymstridx;
>
>  size_t nsymtab;
>  size_t nlocalsymbols;
>  size_t ndynsymtab;
>
>  Elf_Scn *dynscn;
>
>
>  Elf32_Word *symindirect;
>  Elf32_Word *dynsymindirect;
>
>
>  struct symbol **symref;
>  struct symbol **dynsymref;
>
>
>
>
>  int fd;
>
>
>
>  _Bool fd_passed;
>
>
>  _Bool has_merge_sections;
>};
>
>
>
>static inline int
>ld_file_rel_p (struct usedfiles *file)
>{
>  return (elf_kind (file->elf) == ELF_K_ELF
>   && (file->ehdr).e_type == 1);
>}
>
>static inline int
>ld_file_dso_p (struct usedfiles *file)
>{
>  return (elf_kind (file->elf) == ELF_K_ELF
>   && (file->ehdr).e_type == 3);
>}
>
>static inline int
>ld_file_ar_p (struct usedfiles *file)
>{
>  return elf_kind (file->elf) == ELF_K_AR;
>}
>
>
>struct pathelement
>{
>
>  struct pathelement *next;
>
>  const char *pname;
>
>
>  int exist;
>};
>
>
>
>struct ld_state;
>
>
>
>struct callbacks
>{
>
>
>
>  const char **(*lib_extensions) (struct ld_state *)
>       __attribute__ ((__const__));
># 310 "/net/ma/home/roland/redhat/stock-elfutils/src/ld.h"
>  int (*file_process) (int fd, struct usedfiles *, struct ld_state *,
>         struct usedfiles **);
>
>
>
>
>  int (*file_close) (struct usedfiles *, struct ld_state *);
># 328 "/net/ma/home/roland/redhat/stock-elfutils/src/ld.h"
>  void (*create_sections) (struct ld_state *);
>
>
>
>
>  int (*flag_unresolved) (struct ld_state *);
>
>
>
>
>
>  void (*generate_sections) (struct ld_state *);
>
>
>
>
>
>  int (*open_outfile) (struct ld_state *, int, int, int);
>
>
>
>
>  int (*create_outfile) (struct ld_state *);
>
>
>
>
>  void (*relocate_section) (struct ld_state *, Elf_Scn *, struct scninfo *,
>       const Elf32_Word *);
>
>
>
>
>
>
>  void (*count_relocations) (struct ld_state *, struct scninfo *);
>
>
>
>
>  void (*create_relocations) (struct ld_state *, const Elf32_Word *);
>
>
>
>
>  int (*finalize) (struct ld_state *);
>
>
>
>
>  _Bool (*special_section_number_p) (struct ld_state *, size_t);
>
>
>
>
>  _Bool (*section_type_p) (struct ld_state *, GElf_Word);
>
>
>
>
>  GElf_Xword (*dynamic_section_flags) (struct ld_state *);
>
>
>
>
>  void (*initialize_plt) (struct ld_state *, Elf_Scn *scn);
>
>
>
>
>  void (*initialize_pltrel) (struct ld_state *, Elf_Scn *scn);
>
>
>
>
>  void (*finalize_plt) (struct ld_state *, size_t, size_t, struct symbol **);
>
>
>
>
>
>  void (*initialize_got) (struct ld_state *, Elf_Scn *scn);
>
>
>
>
>  void (*initialize_gotplt) (struct ld_state *, Elf_Scn *scn);
>
>
>
>
>
>  int (*rel_type) (struct ld_state *);
>
>
>};
>
>
>
>
>struct symbol
>{
>
>  const char *name;
>
>  GElf_Xword size;
>
>  size_t symidx;
>
>  size_t outsymidx;
>
>
>  size_t scndx;
>  struct usedfiles *file;
>
>  Elf32_Word symscndx;
>
>
>
>
>  unsigned int outdynsymidx:16;
>
>
>  unsigned int type:4;
>
>  unsigned int defined:1;
>  unsigned int common:1;
>  unsigned int weak:1;
>  unsigned int added:1;
>  unsigned int merged:1;
>  unsigned int local:1;
>  unsigned int hidden:1;
>
>  unsigned int on_dsolist:1;
>
>
>  unsigned int need_copy:1;
>  unsigned int in_dso:1;
>
>  union
>  {
>
>
>
>    void *handle;
>    GElf_Addr value;
>  } merge;
>
>
>  struct symbol *next;
>  struct symbol *previous;
>
>
>  struct symbol *next_in_scn;
>};
>
>
>
># 1 "/net/ma/home/roland/redhat/stock-elfutils/src/symbolhash.h" 1
># 34 "/net/ma/home/roland/redhat/stock-elfutils/src/symbolhash.h"
># 1 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/dynamicsizehash.h" 1
># 50 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/dynamicsizehash.h"
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 1 3 4
># 51 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/dynamicsizehash.h" 2
># 74 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/dynamicsizehash.h"
>extern size_t next_prime (size_t seed);
># 86 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/dynamicsizehash.h"
>typedef struct ld_symbol_tab_ent { unsigned long int hashval; struct symbol * data; struct ld_symbol_tab_ent *next; } ld_symbol_tab_ent;
># 99 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/dynamicsizehash.h"
>typedef struct { unsigned long int size; unsigned long int filled; ld_symbol_tab_ent *table; ld_symbol_tab_ent *first; } ld_symbol_tab;
># 119 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/dynamicsizehash.h"
>extern int ld_symbol_tab_init (ld_symbol_tab *htab, unsigned long int init_size); extern int ld_symbol_tab_free (ld_symbol_tab *htab); extern int ld_symbol_tab_insert (ld_symbol_tab *htab, unsigned long int hval, struct symbol * data); extern int ld_symbol_tab_overwrite (ld_symbol_tab *htab, unsigned long int hval, struct symbol * data); extern struct symbol * ld_symbol_tab_find (ld_symbol_tab *htab, unsigned long int hval, struct symbol * val);
>
>
>
>
>
>
>
>extern struct symbol * ld_symbol_tab_iterate (ld_symbol_tab *htab, void **ptr);
># 35 "/net/ma/home/roland/redhat/stock-elfutils/src/symbolhash.h" 2
># 487 "/net/ma/home/roland/redhat/stock-elfutils/src/ld.h" 2
>
>
>struct filename_list
>{
>  const char *name;
>  struct usedfiles *real;
>  struct filename_list *next;
>  _Bool group_start;
>  _Bool group_end;
>  _Bool as_needed;
>};
>
>
>
>struct expression
>{
>  enum expression_tag
>    {
>      exp_num,
>      exp_sizeof_headers,
>      exp_pagesize,
>      exp_id,
>      exp_mult,
>      exp_div,
>      exp_mod,
>      exp_plus,
>      exp_minus,
>      exp_and,
>      exp_or,
>      exp_align
>    } tag;
>
>  union
>  {
>    uintmax_t num;
>    struct expression *child;
>    struct
>    {
>      struct expression *left;
>      struct expression *right;
>    } binary;
>    const char *str;
>  } val;
>};
>
>
>
>struct input_section_name
>{
>  const char *name;
>  _Bool sort_flag;
>};
>
>
>struct filemask_section_name
>{
>  const char *filemask;
>  const char *excludemask;
>  struct input_section_name *section_name;
>  _Bool keep_flag;
>};
>
>
>struct assignment
>{
>  const char *variable;
>  struct expression *expression;
>  struct symbol *sym;
>  _Bool provide_flag;
>};
>
>
>
>struct input_rule
>{
>  enum
>    {
>      input_section,
>      input_assignment
>    } tag;
>
>  union
>  {
>    struct assignment *assignment;
>    struct filemask_section_name *section;
>  } val;
>
>  struct input_rule *next;
>};
>
>
>
>struct output_section
>{
>  const char *name;
>  struct input_rule *input;
>  GElf_Addr max_alignment;
>  _Bool ignored;
>};
>
>
>
>struct output_rule
>{
>  enum
>    {
>      output_section,
>      output_assignment
>    } tag;
>
>  union
>  {
>    struct assignment *assignment;
>    struct output_section section;
>  } val;
>
>  struct output_rule *next;
>};
>
>
>
>struct output_segment
>{
>  int mode;
>  struct output_rule *output_rules;
>  struct output_segment *next;
>
>  GElf_Off offset;
>  GElf_Addr addr;
>  GElf_Xword align;
>};
>
>
>
>struct id_list
>{
>  union
>  {
>    enum id_type
>      {
> id_str,
> id_all,
> id_wild
>      } id_type;
>    struct
>    {
>      _Bool local;
>      const char *versionname;
>    } s;
>  } u;
>  const char *id;
>  struct id_list *next;
>};
>
>
>
>struct version
>{
>  struct version *next;
>  struct id_list *local_names;
>  struct id_list *global_names;
>  const char *versionname;
>  const char *parentname;
>};
>
>
>
>struct scnhead
>{
>
>  const char *name;
>
>
>  GElf_Xword flags;
>
>
>  GElf_Word type;
>
>
>
>  GElf_Word entsize;
>
>
>  const char *grp_signature;
>
>
>  GElf_Word align;
>
>
>
>  enum scn_kind
>    {
>      scn_normal,
>      scn_dot_interp,
>      scn_dot_got,
>      scn_dot_gotplt,
>      scn_dot_dynrel,
>      scn_dot_dynamic,
>      scn_dot_dynsym,
>      scn_dot_dynstr,
>      scn_dot_hash,
>      scn_dot_gnu_hash,
>      scn_dot_plt,
>      scn_dot_pltrel,
>      scn_dot_version,
>      scn_dot_version_r,
>      scn_dot_note_gnu_build_id
>    } kind;
>
>
>  _Bool used;
>
>
>  size_t relsize;
>
>
>
>  int segment_nr;
>
>
>
>
>
>
>  GElf_Word scnidx;
>
>
>
>  GElf_Word scnsymidx;
>
>
>  GElf_Addr addr;
>
>
>
>  struct Ebl_Strent *nameent;
>
>
>
>  struct symbol *symbols;
>
>
>  struct scninfo *last;
>};
>
>
>
># 1 "/net/ma/home/roland/redhat/stock-elfutils/src/sectionhash.h" 1
># 33 "/net/ma/home/roland/redhat/stock-elfutils/src/sectionhash.h"
># 1 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/dynamicsizehash.h" 1
># 50 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/dynamicsizehash.h"
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 1 3 4
># 51 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/dynamicsizehash.h" 2
># 74 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/dynamicsizehash.h"
>extern size_t next_prime (size_t seed);
># 86 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/dynamicsizehash.h"
>typedef struct ld_section_tab_ent { unsigned long int hashval; struct scnhead * data; struct ld_section_tab_ent *next; } ld_section_tab_ent;
># 99 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/dynamicsizehash.h"
>typedef struct { unsigned long int size; unsigned long int filled; ld_section_tab_ent *table; ld_section_tab_ent *first; } ld_section_tab;
># 119 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/dynamicsizehash.h"
>extern int ld_section_tab_init (ld_section_tab *htab, unsigned long int init_size); extern int ld_section_tab_free (ld_section_tab *htab); extern int ld_section_tab_insert (ld_section_tab *htab, unsigned long int hval, struct scnhead * data); extern int ld_section_tab_overwrite (ld_section_tab *htab, unsigned long int hval, struct scnhead * data); extern struct scnhead * ld_section_tab_find (ld_section_tab *htab, unsigned long int hval, struct scnhead * val);
>
>
>
>
>
>
>
>extern struct scnhead * ld_section_tab_iterate (ld_section_tab *htab, void **ptr);
># 34 "/net/ma/home/roland/redhat/stock-elfutils/src/sectionhash.h" 2
># 735 "/net/ma/home/roland/redhat/stock-elfutils/src/ld.h" 2
>
>
># 1 "/net/ma/home/roland/redhat/stock-elfutils/src/versionhash.h" 1
># 32 "/net/ma/home/roland/redhat/stock-elfutils/src/versionhash.h"
># 1 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/dynamicsizehash.h" 1
># 50 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/dynamicsizehash.h"
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 1 3 4
># 51 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/dynamicsizehash.h" 2
># 74 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/dynamicsizehash.h"
>extern size_t next_prime (size_t seed);
># 86 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/dynamicsizehash.h"
>typedef struct ld_version_str_tab_ent { unsigned long int hashval; struct id_list * data; } ld_version_str_tab_ent;
># 99 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/dynamicsizehash.h"
>typedef struct { unsigned long int size; unsigned long int filled; ld_version_str_tab_ent *table; } ld_version_str_tab;
># 119 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/dynamicsizehash.h"
>extern int ld_version_str_tab_init (ld_version_str_tab *htab, unsigned long int init_size); extern int ld_version_str_tab_free (ld_version_str_tab *htab); extern int ld_version_str_tab_insert (ld_version_str_tab *htab, unsigned long int hval, struct id_list * data); extern int ld_version_str_tab_overwrite (ld_version_str_tab *htab, unsigned long int hval, struct id_list * data); extern struct id_list * ld_version_str_tab_find (ld_version_str_tab *htab, unsigned long int hval, struct id_list * val);
># 33 "/net/ma/home/roland/redhat/stock-elfutils/src/versionhash.h" 2
># 738 "/net/ma/home/roland/redhat/stock-elfutils/src/ld.h" 2
>
>
>
>struct ld_state
>{
>
>  Ebl *ebl;
>
>
>  struct usedfiles *archives;
>
>  struct usedfiles *tailarchives;
>
>  _Bool group_start_requested;
>
>  struct usedfiles *group_start_archive;
>
>
>  struct usedfiles *dsofiles;
>
>  size_t ndsofiles;
>
>  struct usedfiles *relfiles;
>
>
>  struct usedfiles *needed;
>
>
>  struct filename_list *srcfiles;
>
>
>  struct pathelement *paths;
>
>  struct pathelement *tailpaths;
>
>
>  struct pathelement *rpath;
>  struct pathelement *rpath_link;
>  struct pathelement *runpath;
>  struct pathelement *runpath_link;
>  struct Ebl_Strent *rxxpath_strent;
>  int rxxpath_tag;
>
>
>  struct pathelement *ld_library_path1;
>  struct pathelement *ld_library_path2;
>
>
>  const char *outfname;
>
>  const char *tempfname;
>
>  int outfd;
>
>  Elf *outelf;
>
>
>  enum file_type file_type;
>
>
>  _Bool is_system_library;
>
>
>  size_t pagesize;
>
>
>  const char *interp;
>
>  Elf32_Word interpscnidx;
>
>
>  unsigned long int optlevel;
>
>
>  _Bool statically;
>
>
>
>  _Bool as_needed;
>
>
>  enum extract_rule extract_rule;
>
>
>  int last_archive_used;
>
>
>
>  _Bool trace_files;
>
>
>
>  _Bool muldefs;
>
>
>  _Bool nodefs;
>
>
>  _Bool add_ld_comment;
>
>
>  enum
>    {
>      strip_none,
>      strip_debug,
>      strip_all,
>      strip_everything
>    } strip;
>
>
>  struct callbacks callbacks;
>
>
>  const char *entry;
>
>
>  struct output_segment *output_segments;
>
>
>  struct symbol *lscript_syms;
>  size_t nlscript_syms;
>
>
>  ld_symbol_tab symbol_tab;
>
>
>  ld_section_tab section_tab;
>
>
>  struct scnhead **allsections;
>  size_t nallsections;
>  size_t nusedsections;
>  size_t nnotesections;
>
>
>  struct symbol *unresolved;
>
>  size_t nunresolved;
>
>  size_t nunresolved_nonweak;
>
>
>  struct symbol *common_syms;
>
>  struct scninfo *common_section;
>
>
>
>
>
>  struct symbol *from_dso;
>
>  size_t nfrom_dso;
>
>  size_t ndynsym;
>
>  size_t nplt;
>
>  size_t ngot;
>
>  size_t ncopy;
>
>  struct scninfo *copy_section;
>
>
>  size_t nsymtab;
>  size_t nlocalsymbols;
>
>
>  struct symbol *init_symbol;
>  struct symbol *fini_symbol;
>
>
>
>
>  struct output_segment *default_output_segments;
>
>  struct pathelement *default_paths;
>
>
>
>  void *ldlib;
>
>
>
>  struct Ebl_Strtab *shstrtab;
>
>
>  _Bool need_symtab;
>
>  Elf32_Word symscnidx;
>
>  Elf32_Word xndxscnidx;
>
>  Elf32_Word strscnidx;
>
>
>  _Bool need_dynsym;
>
>  Elf32_Word dynsymscnidx;
>
>  Elf32_Word dynstrscnidx;
>
>  size_t hashscnidx;
>  size_t gnuhashscnidx;
>
>
>  Elf32_Word pltscnidx;
>
>  size_t nplt_used;
>
>  Elf32_Word pltrelscnidx;
>
>
>  Elf32_Word gotscnidx;
>
>  Elf32_Word gotpltscnidx;
>
>
>  Elf32_Word reldynscnidx;
>
>
>  Elf32_Word versymscnidx;
>  Elf32_Word verneedscnidx;
>
>
>  int nverdefused;
>
>  int nverdeffile;
>
>  int nextveridx;
>
>
>  _Bool need_tls;
>  GElf_Addr tls_start;
>  GElf_Addr tls_tcb;
>
>
>
>  ld_version_str_tab version_str_tab;
>
>
>  _Bool default_bind_local;
>  _Bool default_bind_global;
>
>
>  enum execstack
>    {
>      execstack_false = 0,
>      execstack_true,
>      execstack_false_force
>    } execstack;
>
>
>  _Bool gc_sections;
>
>
>  Elf32_Word *dblindirect;
>
>
>  struct scngroup
>  {
>    Elf32_Word outscnidx;
>    int nscns;
>    struct member
>    {
>      struct scnhead *scn;
>      struct member *next;
>    } *member;
>    struct Ebl_Strent *nameent;
>    struct symbol *symbol;
>    struct scngroup *next;
>  } *groups;
>
>
>  _Bool need_got;
>
>  size_t nrel_got;
>
>
>  int ndynamic;
>
>  int ndynamic_filled;
>
>  Elf32_Word dynamicscnidx;
>
>
>  Elf32_Word dt_flags;
>
>  Elf32_Word dt_flags_1;
>
>  Elf32_Word dt_feature_1;
>
>
>  _Bool lazyload;
>
>
>  _Bool eh_frame_hdr;
>
>
>  enum
>    {
>      hash_style_none = 0,
>      hash_style_sysv = 1,
>
>      hash_style_gnu = 2
>
>    }
>  hash_style;
>
>
>
>
>  _Bool export_all_dynamic;
>
>
>  const char *build_id;
>  Elf32_Word buildidscnidx;
>
>
>  const char *soname;
>
>
>  struct scninfo *rellist;
>
>  size_t relsize_total;
>
>
>  struct symbol *got_symbol;
>
>  struct symbol *dyn_symbol;
>
>
>  struct obstack smem;
>};
>
>
>
>
>
>extern int ldparse (void);
>
>
>extern FILE *ldin;
>
>
>extern const char *ldin_fname;
>
>
>extern int ldlineno;
>
>
>extern int ld_scan_version_script;
>
>
>extern int verbose;
>extern int conserve_memory;
>
>
>
>extern struct ld_state ld_state;
>
>
>
>
>
>extern void ld_new_searchdir (const char *dir);
>
>
>extern struct usedfiles *ld_new_inputfile (const char *fname,
>        enum file_type type);
>
>
>
>
>
>
>extern int ld_prepare_state (const char *emulation);
>
>
>
>extern _Bool dynamically_linked_p (void);
>
>
>
>
>extern _Bool linked_from_dso_p (struct scninfo *scninfo, size_t symidx);
>
>__attribute__ ((__gnu_inline__))
>
>extern inline _Bool
>linked_from_dso_p (struct scninfo *scninfo, size_t symidx)
>{
>  struct usedfiles *file = scninfo->fileinfo;
>
>
>
>  if (symidx < file->nlocalsymbols)
>    return 0;
>
>  struct symbol *sym = file->symref[symidx];
>
>  return sym->defined && sym->in_dso;
>}
># 50 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c" 2
># 1 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/list.h" 1
># 51 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c" 2
># 1 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/md5.h" 1
># 31 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/md5.h"
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/limits.h" 1 3 4
># 32 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/md5.h" 2
>
>
>
>
>
>
>typedef uint32_t md5_uint32;
>typedef uintptr_t md5_uintptr;
>
>
>struct md5_ctx
>{
>  md5_uint32 A;
>  md5_uint32 B;
>  md5_uint32 C;
>  md5_uint32 D;
>
>  md5_uint32 total[2];
>  md5_uint32 buflen;
>  char buffer[128] __attribute__ ((__aligned__ (__alignof__ (md5_uint32))));
>};
># 61 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/md5.h"
>extern void md5_init_ctx (struct md5_ctx *ctx);
>
>
>
>
>
>extern void md5_process_block (const void *buffer, size_t len,
>          struct md5_ctx *ctx);
>
>
>
>
>
>extern void md5_process_bytes (const void *buffer, size_t len,
>          struct md5_ctx *ctx);
># 84 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/md5.h"
>extern void *md5_finish_ctx (struct md5_ctx *ctx, void *resbuf);
># 93 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/md5.h"
>extern void *md5_read_ctx (const struct md5_ctx *ctx, void *resbuf);
>
>
>
>
>
>extern int md5_stream (FILE *stream, void *resblock);
>
>
>
>
>
>extern void *md5_buffer (const char *buffer, size_t len, void *resblock);
># 52 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c" 2
># 1 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/sha1.h" 1
># 31 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/sha1.h"
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/limits.h" 1 3 4
># 32 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/sha1.h" 2
>
>
>
>
>
>
>typedef uint32_t sha1_uint32;
>typedef uintptr_t sha1_uintptr;
>
>
>struct sha1_ctx
>{
>  sha1_uint32 A;
>  sha1_uint32 B;
>  sha1_uint32 C;
>  sha1_uint32 D;
>  sha1_uint32 E;
>
>  sha1_uint32 total[2];
>  sha1_uint32 buflen;
>  char buffer[128] __attribute__ ((__aligned__ (__alignof__ (sha1_uint32))));
>};
>
>
>extern void sha1_init_ctx (struct sha1_ctx *ctx);
>
>
>
>
>
>extern void sha1_process_block (const void *buffer, size_t len,
>    struct sha1_ctx *ctx);
>
>
>
>
>
>extern void sha1_process_bytes (const void *buffer, size_t len,
>    struct sha1_ctx *ctx);
># 79 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/sha1.h"
>extern void *sha1_finish_ctx (struct sha1_ctx *ctx, void *resbuf);
># 88 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/sha1.h"
>extern void *sha1_read_ctx (const struct sha1_ctx *ctx, void *resbuf);
># 53 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c" 2
># 1 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/system.h" 1
># 52 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/system.h"
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 1 3 4
># 53 "/net/ma/home/roland/redhat/stock-elfutils/src/../lib/system.h" 2
>
>
>extern void *xmalloc (size_t) __attribute__ ((__malloc__));
>extern void *xcalloc (size_t, size_t) __attribute__ ((__malloc__));
>extern void *xrealloc (void *, size_t) __attribute__ ((__malloc__));
>
>extern char *xstrdup (const char *) __attribute__ ((__malloc__));
>extern char *xstrndup (const char *, size_t) __attribute__ ((__malloc__));
>
>
>extern uint32_t crc32 (uint32_t crc, unsigned char *buf, size_t len);
>extern int crc32_file (int fd, uint32_t *resp);
># 54 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c" 2
>
>
>
>struct unw_eh_frame_hdr
>{
>  unsigned char version;
>  unsigned char eh_frame_ptr_enc;
>  unsigned char fde_count_enc;
>  unsigned char table_enc;
>};
>
>
>
>
>static const char **ld_generic_lib_extensions (struct ld_state *)
>     __attribute__ ((__const__));
>static int ld_generic_file_close (struct usedfiles *fileinfo,
>      struct ld_state *statep);
>static int ld_generic_file_process (int fd, struct usedfiles *fileinfo,
>        struct ld_state *statep,
>        struct usedfiles **nextp);
>static void ld_generic_generate_sections (struct ld_state *statep);
>static void ld_generic_create_sections (struct ld_state *statep);
>static int ld_generic_flag_unresolved (struct ld_state *statep);
>static int ld_generic_open_outfile (struct ld_state *statep, int machine,
>        int class, int data);
>static int ld_generic_create_outfile (struct ld_state *statep);
>static void ld_generic_relocate_section (struct ld_state *statep,
>      Elf_Scn *outscn,
>      struct scninfo *firstp,
>      const Elf32_Word *dblindirect);
>static int ld_generic_finalize (struct ld_state *statep);
>static _Bool ld_generic_special_section_number_p (struct ld_state *statep,
>       size_t number);
>static _Bool ld_generic_section_type_p (struct ld_state *statep,
>           GElf_Word type);
>static GElf_Xword ld_generic_dynamic_section_flags (struct ld_state *statep);
>static void ld_generic_initialize_plt (struct ld_state *statep, Elf_Scn *scn);
>static void ld_generic_initialize_pltrel (struct ld_state *statep,
>       Elf_Scn *scn);
>static void ld_generic_initialize_got (struct ld_state *statep, Elf_Scn *scn);
>static void ld_generic_initialize_gotplt (struct ld_state *statep,
>       Elf_Scn *scn);
>static void ld_generic_finalize_plt (struct ld_state *statep, size_t nsym,
>         size_t nsym_dyn,
>         struct symbol **ndxtosymp);
>static int ld_generic_rel_type (struct ld_state *statep);
>static void ld_generic_count_relocations (struct ld_state *statep,
>       struct scninfo *scninfo);
>static void ld_generic_create_relocations (struct ld_state *statep,
>        const Elf32_Word *dblindirect);
>
>static int file_process2 (struct usedfiles *fileinfo);
>static void mark_section_used (struct scninfo *scninfo, Elf32_Word shndx,
>          struct scninfo **grpscnp);
>
>
>
>static struct symbol **ndxtosym;
>
>
>static struct Ebl_Strent **symstrent;
>
>
>
>static _Bool
>is_dso_p (int fd)
>{
>
>
>  GElf_Half e_type;
>
>  return (pread (fd, &e_type, sizeof (e_type), __builtin_offsetof (GElf_Ehdr, e_type))
>   == sizeof (e_type)
>   && e_type == 3);
>}
>
>
>
>
>static int
>print_file_name (FILE *s, struct usedfiles *fileinfo, int first_level,
>   int newline)
>{
>  int npar = 0;
>
>  if (fileinfo->archive_file != ((void *)0))
>    {
>      npar = print_file_name (s, fileinfo->archive_file, 0, 0) + 1;
>      fputc_unlocked ('(', s);
>      fputs_unlocked (fileinfo->rfname, s);
>
>      if (first_level)
> while (npar-- > 0)
>   fputc_unlocked (')', s);
>    }
>  else
>    fputs_unlocked (fileinfo->rfname, s);
>
>  if (first_level && newline)
>    fputc_unlocked ('\n', s);
>
>  return npar;
>}
>
>
>
>_Bool
>dynamically_linked_p (void)
>{
>  return (ld_state.file_type == dso_file_type || ld_state.nplt > 0
>   || ld_state.ngot > 0);
>}
>
>
>_Bool
>linked_from_dso_p (struct scninfo *scninfo, size_t symidx)
>{
>  struct usedfiles *file = scninfo->fileinfo;
>
>
>
>  if (symidx < file->nlocalsymbols)
>    return 0;
>
>  struct symbol *sym = file->symref[symidx];
>
>  return sym->defined && sym->in_dso;
>}
>
>
>
>
>int
>ld_prepare_state (const char *emulation)
>{
>
>  ld_state.nodefs = 1;
>
>
>
>  ld_state.add_ld_comment = 1;
>
>
>
>  ld_state.nextveridx = 2;
>
>
>  ld_symbol_tab_init (&ld_state.symbol_tab, 1027);
>  ld_section_tab_init (&ld_state.section_tab, 67);
>  ld_version_str_tab_init (&ld_state.version_str_tab, 67);
>
>
>  ld_state.shstrtab = ebl_strtabinit (1);
>  if (ld_state.shstrtab == ((void *)0))
>    error (1, (*__errno_location ()), dcgettext (((void *)0), "cannot create string table", __LC_MESSAGES));
>
>
>
>  ld_state.callbacks.lib_extensions = ld_generic_lib_extensions;
>  ld_state.callbacks.file_process = ld_generic_file_process;
>  ld_state.callbacks.file_close = ld_generic_file_close;
>  ld_state.callbacks.generate_sections = ld_generic_generate_sections;
>  ld_state.callbacks.create_sections = ld_generic_create_sections;
>  ld_state.callbacks.flag_unresolved = ld_generic_flag_unresolved;
>  ld_state.callbacks.open_outfile = ld_generic_open_outfile;
>  ld_state.callbacks.create_outfile = ld_generic_create_outfile;
>  ld_state.callbacks.relocate_section = ld_generic_relocate_section;
>  ld_state.callbacks.finalize = ld_generic_finalize;
>  ld_state.callbacks.special_section_number_p =
>    ld_generic_special_section_number_p;
>  ld_state.callbacks.section_type_p = ld_generic_section_type_p;
>  ld_state.callbacks.dynamic_section_flags = ld_generic_dynamic_section_flags;
>  ld_state.callbacks.initialize_plt = ld_generic_initialize_plt;
>  ld_state.callbacks.initialize_pltrel = ld_generic_initialize_pltrel;
>  ld_state.callbacks.initialize_got = ld_generic_initialize_got;
>  ld_state.callbacks.initialize_gotplt = ld_generic_initialize_gotplt;
>  ld_state.callbacks.finalize_plt = ld_generic_finalize_plt;
>  ld_state.callbacks.rel_type = ld_generic_rel_type;
>  ld_state.callbacks.count_relocations = ld_generic_count_relocations;
>  ld_state.callbacks.create_relocations = ld_generic_create_relocations;
>
>
>
>
>  if (emulation == ((void *)0))
>    {
>      emulation = ebl_backend_name (ld_state.ebl);
>      ((emulation != ((void *)0)) ? (void) (0) : __assert_fail ("emulation != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 242, __PRETTY_FUNCTION__));
>    }
>  size_t emulation_len = strlen (emulation);
>
>
>  char *fname = (char *) __builtin_alloca (sizeof "libld_" - 1 + emulation_len + sizeof ".so");
>
>  strcpy (__builtin_mempcpy (__builtin_stpcpy (fname, "libld_"), emulation, emulation_len), ".so");
>
>
>  void *h = dlopen (fname, 0x00001);
>  if (h == ((void *)0))
>    error (1, 0,
>    dcgettext (((void *)0), "cannot load ld backend library '%s': %s", __LC_MESSAGES),
>    fname, dlerror ());
>
>
>  char *initname = (char *) __builtin_alloca (emulation_len + sizeof "_ld_init");
>  strcpy (__builtin_mempcpy (initname, emulation, emulation_len), "_ld_init");
>  int (*initfct) (struct ld_state *)
>    = (int (*) (struct ld_state *)) dlsym (h, initname);
>
>  if (initfct == ((void *)0))
>    error (1, 0, dcgettext (((void *)0), "cannot find init function in ld backend library '%s': %s", __LC_MESSAGES),
>
>    fname, dlerror ());
>
>
>  ld_state.ldlib = h;
>
>
>  return initfct (&ld_state);
>
>
>
>
>
>
>
>}
>
>
>static int
>check_for_duplicate2 (struct usedfiles *newp, struct usedfiles *list)
>{
>  struct usedfiles *first;
>  struct usedfiles *prevp;
>
>  if (list == ((void *)0))
>    return 0;
>
>  prevp = list;
>  list = first = list->next;
>  do
>    {
>
>
>
>      if (__builtin_expect (!!(list->status == not_opened), 1))
> break;
>
>      if (__builtin_expect (!!(list->ino == newp->ino), 0)
>   && __builtin_expect (!!(list->dev == newp->dev), 0))
> {
>   close (newp->fd);
>   newp->fd = -1;
>   newp->status = closed;
>   if (newp->file_type == relocatable_file_type)
>     error (0, 0, dcgettext (((void *)0), "%s listed more than once as input", __LC_MESSAGES),
>     newp->rfname);
>
>   return 1;
> }
>      list = list->next;
>    }
>  while (__builtin_expect (!!(list != first), 1));
>
>  return 0;
>}
>
>
>static int
>check_for_duplicate (struct usedfiles *newp)
>{
>  struct stat st;
>
>  if (__builtin_expect (!!(fstat (newp->fd, &st) < 0), 0))
>    {
>      close (newp->fd);
>      return (*__errno_location ());
>    }
>
>  newp->dev = st.st_dev;
>  newp->ino = st.st_ino;
>
>  return (check_for_duplicate2 (newp, ld_state.relfiles)
>   || check_for_duplicate2 (newp, ld_state.dsofiles)
>   || check_for_duplicate2 (newp, ld_state.needed));
>}
>
>
>
>static int
>open_along_path2 (struct usedfiles *fileinfo, struct pathelement *path)
>{
>  const char *fname = fileinfo->fname;
>  size_t fnamelen = strlen (fname);
>  int err = 2;
>  struct pathelement *firstp = path;
>
>  if (path == ((void *)0))
>
>    return 2;
>
>  do
>    {
>      if (__builtin_expect (!!(path->exist >= 0), 1))
> {
>
>   char *rfname = ((void *)0);
>   size_t dirlen = strlen (path->pname);
>   int fd = -1;
>
>   if (fileinfo->file_type == archive_file_type)
>     {
>       const char **exts = (ld_state.statically
>       ? (const char *[2]) { ".a", ((void *)0) }
>       : (_dl_mcount_wrapper_check ((void *) ((&ld_state)->callbacks.lib_extensions)), (*((&ld_state)->callbacks.lib_extensions)) (&ld_state)));
>
>
>
>       while (*exts != ((void *)0))
>  {
>    size_t extlen = strlen (*exts);
>    rfname = (char *) __builtin_alloca (dirlen + 5 + fnamelen + extlen);
>    memcpy (__builtin_mempcpy (__builtin_stpcpy (__builtin_mempcpy (rfname, path->pname, dirlen), "/lib"), fname, fnamelen),
>
>
>
>     *exts, extlen + 1);
>
>    fd = open (rfname, 00);
>    if (__builtin_expect (!!(fd != -1), 1) || (*__errno_location ()) != 2)
>      {
>        err = fd == -1 ? (*__errno_location ()) : 0;
>        break;
>      }
>
>
>    ++exts;
>  }
>     }
>   else
>     {
>       ((fileinfo->file_type == dso_file_type || fileinfo->file_type == dso_needed_file_type) ? (void) (0) : __assert_fail ("fileinfo->file_type == dso_file_type || fileinfo->file_type == dso_needed_file_type", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 397, __PRETTY_FUNCTION__));
>
>
>       rfname = (char *) __builtin_alloca (dirlen + 1 + fnamelen + 1);
>       memcpy (__builtin_stpcpy (__builtin_mempcpy (rfname, path->pname, dirlen), "/"),
>        fname, fnamelen + 1);
>
>       fd = open (rfname, 00);
>       if (__builtin_expect (!!(fd == -1), 0))
>  err = (*__errno_location ());
>     }
>
>   if (__builtin_expect (!!(fd != -1), 1))
>     {
>
>
>       fileinfo->fd = fd;
>       path->exist = 1;
>
>
>       if (__builtin_expect (!!(check_for_duplicate (fileinfo) != 0), 0))
>  return 11;
>
>
>       fileinfo->rfname = ({ const char *_s = (rfname); __extension__ ({ struct obstack *__h = (&ld_state.smem); __extension__ ({ struct obstack *__o = (__h); int __len = ((strlen (_s))); if (__o->next_free + __len + 1 > __o->chunk_limit) _obstack_newchunk (__o, __len + 1); memcpy (__o->next_free, (_s), __len); __o->next_free += __len; *(__o->next_free)++ = 0; (void) 0; }); __extension__ ({ struct obstack *__o1 = (__h); void *__value = (void *) __o1->object_base; if (__o1->next_free == __value) __o1->maybe_empty_object = 1; __o1->next_free = ((sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask))); if (__o1->next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit; __o1->object_base = __o1->next_free; __value; }); }); });
>
>       if (__builtin_expect (!!(ld_state.trace_files), 0))
>  printf (fileinfo->file_type == archive_file_type
>   ? dcgettext (((void *)0), "%s (for -l%s)\n", __LC_MESSAGES)
>   : dcgettext (((void *)0), "%s (for DT_NEEDED %s)\n", __LC_MESSAGES),
>   rfname, fname);
>
>       return 0;
>     }
>
>
>
>   if (__builtin_expect (!!(path->exist == 0), 0))
>     {
>       struct stat st;
># 445 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c"
>       rfname[dirlen] = '\0';
>       if (__builtin_expect (!!(stat (rfname, &st) < 0), 0) || ! ((((st.st_mode)) & 0170000) == (0040000)))
>
>
>  path->exist = -1;
>       else
>  path->exist = 1;
>     }
> }
>
>
>      path = path->next;
>    }
>  while (__builtin_expect (!!(err == 2 && path != firstp), 1));
>
>  return err;
>}
>
>
>static int
>open_along_path (struct usedfiles *fileinfo)
>{
>  const char *fname = fileinfo->fname;
>  int err = 2;
>
>  if (fileinfo->file_type == relocatable_file_type)
>    {
>
>      fileinfo->fd = open (fname, 00);
>
>      if (__builtin_expect (!!(fileinfo->fd != -1), 1))
> {
>
>   if (__builtin_expect (!!(ld_state.trace_files), 0))
>     print_file_name (stdout, fileinfo, 1, 1);
>
>   return check_for_duplicate (fileinfo);
> }
>
>
>      err = (*__errno_location ());
>    }
>  else
>    {
>
>
>      err = open_along_path2 (fileinfo, ld_state.ld_library_path1);
>
>
>      if (err == 2)
> err = open_along_path2 (fileinfo,
>    fileinfo->file_type == archive_file_type
>    ? ld_state.paths : ld_state.rpath_link);
>
>
>      if (__builtin_expect (!!(err == 2), 0))
> {
>   err = open_along_path2 (fileinfo, ld_state.ld_library_path2);
>
>
>   if (err == 2)
>     {
>       if (fileinfo->file_type == dso_file_type)
>  err = open_along_path2 (fileinfo, ld_state.runpath_link);
>
>
>       if (err == 2)
>  err = open_along_path2 (fileinfo, ld_state.default_paths);
>     }
> }
>    }
>
>  if (__builtin_expect (!!(err != 0), 0)
>      && (err != 11 || fileinfo->file_type == relocatable_file_type))
>    error (0, err, dcgettext (((void *)0), "cannot open %s", __LC_MESSAGES), fileinfo->fname);
>
>  return err;
>}
>
>
>static int
>matching_group_comdat_scn (const GElf_Sym *sym, size_t shndx,
>      struct usedfiles *fileinfo, struct symbol *oldp)
>{
>  if ((shndx >= 0xff00 && shndx <= 0xffff)
>      || (oldp->scndx >= 0xff00 && oldp->scndx <= 0xffff))
>
>    return 0;
>
>  size_t newgrpid = fileinfo->scninfo[shndx].grpid;
>  size_t oldgrpid = oldp->file->scninfo[oldp->scndx].grpid;
>  if (newgrpid == 0 || oldgrpid == 0)
>    return 0;
>
>  (((fileinfo->scninfo[newgrpid].shdr).sh_type == 17) ? (void) (0) : __assert_fail ("(fileinfo->scninfo[newgrpid].shdr).sh_type == 17", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 540, __PRETTY_FUNCTION__));
>
>  (((oldp->file->scninfo[oldgrpid].shdr).sh_type == 17) ? (void) (0) : __assert_fail ("(oldp->file->scninfo[oldgrpid].shdr).sh_type == 17", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 542, __PRETTY_FUNCTION__));
>
>
>  if (! fileinfo->scninfo[newgrpid].comdat_group
>      || ! oldp->file->scninfo[oldgrpid].comdat_group)
>    return 0;
>
>  if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (fileinfo->scninfo[newgrpid].symbols->name) && __builtin_constant_p (oldp->file->scninfo[oldgrpid].symbols->name) && (__s1_len = strlen (fileinfo->scninfo[newgrpid].symbols->name), __s2_len = strlen (oldp->file->scninfo[oldgrpid].symbols->name), (!((size_t)(const void *)((fileinfo->scninfo[newgrpid].symbols->name) + 1) - (size_t)(const void *)(fileinfo->scninfo[newgrpid].symbols->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((oldp->file->scninfo[oldgrpid].symbols->name) + 1) - (size_t)(const void *)(oldp->file->scninfo[oldgrpid].symbols->name) == 1) || __s2_len >= 4)) ? __builtin_strcmp (fileinfo->scninfo[newgrpid].symbols->name, oldp->file->scninfo[oldgrpid].symbols->name) : (__builtin_constant_p (fileinfo->scninfo[newgrpid].symbols->name) && ((size_t)(const void *)((fileinfo->scninfo[newgrpid].symbols->name) + 1) - (size_t)(const void *)(fileinfo->scninfo[newgrpid].symbols->name) == 1) && (__s1_len = strlen (fileinfo->scninfo[newgrpid].symbols->name), __s1_len < 4) ? (__builtin_constant_p (oldp->file->scninfo[oldgrpid].symbols->name) && ((size_t)(const void *)((oldp->file->scninfo[oldgrpid].symbols->name) + 1) - (size_t)(const void *)(oldp->file->scninfo[oldgrpid].symbols->name) == 1) ? __builtin_strcmp (fileinfo->scninfo[newgrpid].symbols->name, oldp->file->scninfo[oldgrpid].symbols->name) : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (oldp->file->scninfo[oldgrpid].symbols->name); register int __result = (((const unsigned char *) (const char *) (fileinfo->scninfo[newgrpid].symbols->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (fileinfo->scninfo[newgrpid].symbols->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (fileinfo->scninfo[newgrpid].symbols->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (fileinfo->scninfo[newgrpid].symbols->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (oldp->file->scninfo[oldgrpid].symbols->name) && ((size_t)(const void *)((oldp->file->scninfo[oldgrpid].symbols->name) + 1) - (size_t)(const void *)(oldp->file->scninfo[oldgrpid].symbols->name) == 1) && (__s2_len = strlen (oldp->file->scninfo[oldgrpid].symbols->name), __s2_len < 4) ? (__builtin_constant_p (fileinfo->scninfo[newgrpid].symbols->name) && ((size_t)(const void *)((fileinfo->scninfo[newgrpid].symbols->name) + 1) - (size_t)(const void *)(fileinfo->scninfo[newgrpid].symbols->name) == 1) ? __builtin_strcmp (fileinfo->scninfo[newgrpid].symbols->name, oldp->file->scninfo[oldgrpid].symbols->name) : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (fileinfo->scninfo[newgrpid].symbols->name); register int __result = __s1[0] - ((const unsigned char *) (const char *) (oldp->file->scninfo[oldgrpid].symbols->name))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) (oldp->file->scninfo[oldgrpid].symbols->name))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) (oldp->file->scninfo[oldgrpid].symbols->name))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) (oldp->file->scninfo[oldgrpid].symbols->name))[3]); } } __result; }))) : __builtin_strcmp (fileinfo->scninfo[newgrpid].symbols->name, oldp->file->scninfo[oldgrpid].symbols->name)))); }) != 0)
>
>    return 0;
>
>
>  return 1;
>}
>
>
>static void
>check_type_and_size (const GElf_Sym *sym, struct usedfiles *fileinfo,
>       struct symbol *oldp)
>{
>
>
>
>
>
>
>  if (((sym->st_info) & 0xf) != 0 && oldp->type != 0
>      && __builtin_expect (!!(oldp->type != ((sym->st_info) & 0xf)), 0))
>    {
>      char buf1[64];
>      char buf2[64];
>
>      error (0, 0, dcgettext (((void *)0), "Warning: type of `%s' changed from %s in %s to %s in %s", __LC_MESSAGES),
>
>      oldp->name,
>      ebl_symbol_type_name (ld_state.ebl, oldp->type,
>       buf1, sizeof (buf1)),
>      oldp->file->rfname,
>      ebl_symbol_type_name (ld_state.ebl, ((sym->st_info) & 0xf),
>       buf2, sizeof (buf2)),
>      fileinfo->rfname);
>    }
>  else if (((sym->st_info) & 0xf) == 1
>    && oldp->size != 0
>    && __builtin_expect (!!(oldp->size != sym->st_size), 0))
>    error (0, 0, dcgettext (((void *)0), "Warning: size of `%s' changed from %" "ll" "u" " in %s to %" "ll" "u" " in %s", __LC_MESSAGES),
>
>    oldp->name, (uint64_t) oldp->size, oldp->file->rfname,
>    (uint64_t) sym->st_size, fileinfo->rfname);
>}
>
>
>static int
>check_definition (const GElf_Sym *sym, size_t shndx, size_t symidx,
>    struct usedfiles *fileinfo, struct symbol *oldp)
>{
>  int result = 0;
>  _Bool old_in_dso = (oldp->file->ehdr).e_type == 3;
>  _Bool new_in_dso = (fileinfo->ehdr).e_type == 3;
>  _Bool use_new_def = 0;
>
>  if (shndx != 0
>      && (! oldp->defined
>   || (shndx != 0xfff2 && oldp->common && ! new_in_dso)
>   || (old_in_dso && ! new_in_dso)))
>    {
>
>
>
>
>
>
>      check_type_and_size (sym, fileinfo, oldp);
>
>
>
>
>
>      if (! oldp->defined)
> {
>
>   --ld_state.nunresolved;
>   if (! oldp->weak)
>     --ld_state.nunresolved_nonweak;
>   do { __typeof (oldp) _elem = (oldp); ((ld_state.unresolved != ((void *)0) && _elem != ((void *)0) && (ld_state.unresolved != oldp || ({ __typeof (oldp) _runp = ld_state.unresolved->next; while (_runp != ld_state.unresolved) if (_runp == _elem) break; else _runp = _runp->next; _runp == _elem; }))) ? (void) (0) : __assert_fail ("ld_state.unresolved != ((void *)0) && _elem != ((void *)0) && (ld_state.unresolved != oldp || ({ __typeof (oldp) _runp = ld_state.unresolved->next; while (_runp != ld_state.unresolved) if (_runp == _elem) break; else _runp = _runp->next; _runp == _elem; }))", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 625, __PRETTY_FUNCTION__)); if (__builtin_expect (!!(_elem->next == _elem), 0)) ld_state.unresolved = ((void *)0); else { _elem->next->previous = _elem->previous; _elem->previous->next = _elem->next; if (__builtin_expect (!!(ld_state.unresolved == _elem), 0)) ld_state.unresolved = _elem->next; } (((_elem->next = _elem->previous = ((void *)0), 1)) ? (void) (0) : __assert_fail ("(_elem->next = _elem->previous = ((void *)0), 1)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 625, __PRETTY_FUNCTION__)); } while (0);
> }
>      else if (oldp->common)
>
> do { __typeof (oldp) _elem = (oldp); ((ld_state.common_syms != ((void *)0) && _elem != ((void *)0) && (ld_state.common_syms != oldp || ({ __typeof (oldp) _runp = ld_state.common_syms->next; while (_runp != ld_state.common_syms) if (_runp == _elem) break; else _runp = _runp->next; _runp == _elem; }))) ? (void) (0) : __assert_fail ("ld_state.common_syms != ((void *)0) && _elem != ((void *)0) && (ld_state.common_syms != oldp || ({ __typeof (oldp) _runp = ld_state.common_syms->next; while (_runp != ld_state.common_syms) if (_runp == _elem) break; else _runp = _runp->next; _runp == _elem; }))", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 629, __PRETTY_FUNCTION__)); if (__builtin_expect (!!(_elem->next == _elem), 0)) ld_state.common_syms = ((void *)0); else { _elem->next->previous = _elem->previous; _elem->previous->next = _elem->next; if (__builtin_expect (!!(ld_state.common_syms == _elem), 0)) ld_state.common_syms = _elem->next; } (((_elem->next = _elem->previous = ((void *)0), 1)) ? (void) (0) : __assert_fail ("(_elem->next = _elem->previous = ((void *)0), 1)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 629, __PRETTY_FUNCTION__)); } while (0);
>
>
>      use_new_def = 1;
>    }
>  else if (shndx != 0
>    && oldp->defined
>    && matching_group_comdat_scn (sym, shndx, fileinfo, oldp))
>
>
>
>                 ;
>  else if (shndx != 0
>    && __builtin_expect (!!(! oldp->common), 0)
>    && oldp->defined
>    && shndx != 0xfff2
>
>
>
>    && (!ld_state.muldefs || verbose)
>    && ! old_in_dso && fileinfo->file_type == relocatable_file_type)
>    {
>
>      char buf[64];
>      GElf_Sym oldsym_mem; GElf_Sym *oldsym;
>      struct usedfiles *oldfile;
>      const char *scnname;
>      Elf32_Word xndx;
>      size_t shnum;
>
>      if (elf_getshnum (fileinfo->elf, &shnum) < 0)
> error (1, 0,
>        dcgettext (((void *)0), "cannot determine number of sections: %s", __LC_MESSAGES),
>        elf_errmsg (-1));
>
>
>      if (shndx < 0xff00 || (shndx > 0xffff && shndx < shnum))
> scnname = elf_strptr (fileinfo->elf,
>         fileinfo->shstrndx,
>         (fileinfo->scninfo[shndx].shdr).sh_name);
>      else
>
> scnname = ebl_section_name (ld_state.ebl, shndx, 0, buf, sizeof (buf),
>        ((void *)0), shnum);
>
>
>      print_file_name (stderr, fileinfo, 1, 0);
>      fprintf (stderr,
>        dcgettext (((void *)0), "(%s+%#" "ll" "x" "): multiple definition of %s `%s'\n", __LC_MESSAGES),
>        scnname,
>        (uint64_t) sym->st_value,
>        ebl_symbol_type_name (ld_state.ebl, ((sym->st_info) & 0xf),
>         buf, sizeof (buf)),
>        oldp->name);
>
>      oldfile = oldp->file;
>      oldsym = gelf_getsymshndx (oldfile->symtabdata, oldfile->xndxdata, oldp->symidx, &oldsym_mem, &(xndx));
>
>      ((oldsym != ((void *)0)) ? (void) (0) : __assert_fail ("oldsym != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 687, __PRETTY_FUNCTION__));
>
>
>      if (oldp->scndx < 0xff00 || oldp->scndx > 0xffff)
> scnname = elf_strptr (oldfile->elf,
>         oldfile->shstrndx,
>         (oldfile->scninfo[shndx].shdr).sh_name);
>      else
> scnname = ebl_section_name (ld_state.ebl, oldp->scndx, oldp->scndx,
>        buf, sizeof (buf), ((void *)0), shnum);
>
>
>      print_file_name (stderr, oldfile, 1, 0);
>      fprintf (stderr, dcgettext (((void *)0), "(%s+%#" "ll" "x" "): first defined here\n", __LC_MESSAGES),
>        scnname, (uint64_t) oldsym->st_value);
>
>      if (__builtin_expect (!!(!ld_state.muldefs), 1))
> result = 1;
>    }
>  else if (old_in_dso && fileinfo->file_type == relocatable_file_type
>    && shndx != 0)
>
>
>
>    use_new_def = 1;
>  else if (old_in_dso && !new_in_dso && oldp->defined && !oldp->on_dsolist)
>    {
>      do { __typeof (oldp) _newp = (oldp); ((_newp->next == ((void *)0)) ? (void) (0) : __assert_fail ("_newp->next == ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 714, __PRETTY_FUNCTION__)); ((_newp->previous == ((void *)0)) ? (void) (0) : __assert_fail ("_newp->previous == ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 714, __PRETTY_FUNCTION__)); if (__builtin_expect (!!((ld_state.from_dso) == ((void *)0)), 0)) (ld_state.from_dso) = _newp->next = _newp->previous = _newp; else { _newp->next = (ld_state.from_dso); _newp->previous = (ld_state.from_dso)->previous; _newp->previous->next = _newp->next->previous = _newp; } } while (0);
>      ++ld_state.nfrom_dso;
>
>
>
>      if (oldp->type == 2)
> ++ld_state.nplt;
>      else
> ++ld_state.ngot;
>
>      oldp->on_dsolist = 1;
>    }
>  else if (oldp->common && shndx == 0xfff2)
>    {
>
>      oldp->size = (((oldp->size)>(sym->st_size))?(oldp->size):(sym->st_size));
>
>      oldp->merge.value = (((oldp->merge.value)>(sym->st_value))?(oldp->merge.value):(sym->st_value));
>    }
>
>  if (__builtin_expect (!!(use_new_def), 0))
>    {
>
>
>      if (old_in_dso && fileinfo->file_type == relocatable_file_type)
> {
>   do { __typeof (oldp) _elem = (oldp); ((ld_state.from_dso != ((void *)0) && _elem != ((void *)0) && (ld_state.from_dso != oldp || ({ __typeof (oldp) _runp = ld_state.from_dso->next; while (_runp != ld_state.from_dso) if (_runp == _elem) break; else _runp = _runp->next; _runp == _elem; }))) ? (void) (0) : __assert_fail ("ld_state.from_dso != ((void *)0) && _elem != ((void *)0) && (ld_state.from_dso != oldp || ({ __typeof (oldp) _runp = ld_state.from_dso->next; while (_runp != ld_state.from_dso) if (_runp == _elem) break; else _runp = _runp->next; _runp == _elem; }))", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 740, __PRETTY_FUNCTION__)); if (__builtin_expect (!!(_elem->next == _elem), 0)) ld_state.from_dso = ((void *)0); else { _elem->next->previous = _elem->previous; _elem->previous->next = _elem->next; if (__builtin_expect (!!(ld_state.from_dso == _elem), 0)) ld_state.from_dso = _elem->next; } (((_elem->next = _elem->previous = ((void *)0), 1)) ? (void) (0) : __assert_fail ("(_elem->next = _elem->previous = ((void *)0), 1)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 740, __PRETTY_FUNCTION__)); } while (0);
>   --ld_state.nfrom_dso;
>
>   if (__builtin_expect (!!(oldp->type == 2), 1))
>     --ld_state.nplt;
>   else
>     --ld_state.ngot;
>
>   oldp->on_dsolist = 0;
> }
>
>
>      oldp->size = sym->st_size;
>      oldp->type = ((sym->st_info) & 0xf);
>      oldp->symidx = symidx;
>      oldp->scndx = shndx;
>
>      oldp->file = fileinfo;
>      oldp->defined = 1;
>      oldp->in_dso = new_in_dso;
>      oldp->common = shndx == 0xfff2;
>      if (__builtin_expect (!!(fileinfo->file_type == relocatable_file_type), 1))
> {
>
>
>   oldp->weak = (((unsigned char) (sym->st_info)) >> 4) == 2;
>
>
>   if (shndx != 0xfff2 && shndx != 0xfff1)
>     {
>       struct scninfo *ignore;
>       mark_section_used (&fileinfo->scninfo[shndx], shndx, &ignore);
>     }
> }
>
>
>      if (new_in_dso && !old_in_dso)
> {
>   do { __typeof (oldp) _newp = (oldp); ((_newp->next == ((void *)0)) ? (void) (0) : __assert_fail ("_newp->next == ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 778, __PRETTY_FUNCTION__)); ((_newp->previous == ((void *)0)) ? (void) (0) : __assert_fail ("_newp->previous == ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 778, __PRETTY_FUNCTION__)); if (__builtin_expect (!!((ld_state.from_dso) == ((void *)0)), 0)) (ld_state.from_dso) = _newp->next = _newp->previous = _newp; else { _newp->next = (ld_state.from_dso); _newp->previous = (ld_state.from_dso)->previous; _newp->previous->next = _newp->next->previous = _newp; } } while (0);
>   ++ld_state.nfrom_dso;
>
>
>
>   if (oldp->type == 2)
>     ++ld_state.nplt;
>   else
>     ++ld_state.ngot;
>
>   oldp->on_dsolist = 1;
> }
>      else if (shndx == 0xfff2)
> {
>
>   oldp->merge.value = sym->st_value;
>
>   do { __typeof (oldp) _newp = (oldp); ((_newp->next == ((void *)0)) ? (void) (0) : __assert_fail ("_newp->next == ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 795, __PRETTY_FUNCTION__)); ((_newp->previous == ((void *)0)) ? (void) (0) : __assert_fail ("_newp->previous == ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 795, __PRETTY_FUNCTION__)); if (__builtin_expect (!!((ld_state.common_syms) == ((void *)0)), 0)) (ld_state.common_syms) = _newp->next = _newp->previous = _newp; else { _newp->next = (ld_state.common_syms); _newp->previous = (ld_state.common_syms)->previous; _newp->previous->next = _newp->next->previous = _newp; } } while (0);
> }
>    }
>
>  return result;
>}
>
>
>static struct scninfo *
>find_section_group (struct usedfiles *fileinfo, Elf32_Word shndx,
>      Elf_Data **datap)
>{
>  struct scninfo *runp;
>
>  for (runp = fileinfo->groups; runp != ((void *)0); runp = runp->next)
>    if (!runp->used)
>      {
> Elf32_Word *grpref;
> size_t cnt;
> Elf_Data *data;
>
> data = elf_getdata (runp->scn, ((void *)0));
> if (data == ((void *)0))
>   error (1, 0,
>   dcgettext (((void *)0), "%s: cannot get section group data: %s", __LC_MESSAGES),
>   fileinfo->fname, elf_errmsg (-1));
>
>
> ((elf_getdata (runp->scn, data) == ((void *)0)) ? (void) (0) : __assert_fail ("elf_getdata (runp->scn, data) == ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 823, __PRETTY_FUNCTION__));
>
> grpref = (Elf32_Word *) data->d_buf;
> cnt = data->d_size / sizeof (Elf32_Word);
>
>
> while (cnt > 1)
>   if (grpref[--cnt] == shndx)
>     {
>       *datap = data;
>       return runp;
>     }
>      }
>
>
>
>
>  error (1, 0, dcgettext (((void *)0), "%s: section '%s' with group flag set does not belong to any group", __LC_MESSAGES),
>
>  fileinfo->fname,
>  elf_strptr (fileinfo->elf, fileinfo->shstrndx,
>       (fileinfo->scninfo[shndx].shdr).sh_name));
>  return ((void *)0);
>}
>
>
>
>
>static void
>mark_section_group (struct usedfiles *fileinfo, Elf32_Word shndx,
>      struct scninfo **grpscnp)
>{
>
>
>  size_t cnt;
>  Elf32_Word *grpref;
>  Elf_Data *data;
>  struct scninfo *grpscn = find_section_group (fileinfo, shndx, &data);
>  *grpscnp = grpscn;
># 875 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c"
>  grpscn->used = 1;
>
>  grpref = (Elf32_Word *) data->d_buf;
>  cnt = data->d_size / sizeof (Elf32_Word);
>  while (cnt > 1)
>    {
>      Elf32_Word idx = grpref[--cnt];
>      GElf_Shdr *shdr = &(fileinfo->scninfo[idx].shdr);
>
>      if (fileinfo->scninfo[idx].grpid != grpscn->grpid)
> error (1, 0, dcgettext (((void *)0), "%s: section [%2d] '%s' is not in the correct section group", __LC_MESSAGES),
>
>        fileinfo->fname, (int) idx,
>        elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name));
>
>      if (ld_state.strip == strip_none
>
>   || (!ebl_debugscn_p (ld_state.ebl,
>          elf_strptr (fileinfo->elf, fileinfo->shstrndx,
>        shdr->sh_name))
>
>       && ((shdr->sh_type != 4 && shdr->sh_type != 9)
>    || !ebl_debugscn_p (ld_state.ebl,
>          elf_strptr (fileinfo->elf,
>        fileinfo->shstrndx,
>        (fileinfo->scninfo[shdr->sh_info].shdr).sh_name)))))
> {
>   struct scninfo *ignore;
>
>   mark_section_used (&fileinfo->scninfo[idx], idx, &ignore);
> }
>    }
>}
>
>
>static void
>mark_section_used (struct scninfo *scninfo, Elf32_Word shndx,
>     struct scninfo **grpscnp)
>{
>  if (__builtin_expect (!!(scninfo->used), 1))
>
>    return;
>
>
>  scninfo->used = 1;
>
>
>  GElf_Shdr *shdr = &(scninfo->shdr);
>
>
>
>  if (__builtin_expect (!!(scninfo->shdr.sh_type == 0), 0))
>
>    {
>
>
>
>      shdr = gelf_getshdr (scninfo->scn, &(scninfo->shdr));
>
>      if (__builtin_expect (!!(shdr == ((void *)0)), 0))
>
>
> return;
>    }
>
>
>  if (__builtin_expect (!!(shdr->sh_link != 0), 0))
>    {
>      struct scninfo *ignore;
>      mark_section_used (&scninfo->fileinfo->scninfo[shdr->sh_link],
>    shdr->sh_link, &ignore);
>    }
>
>
>  if (__builtin_expect (!!(shdr->sh_info != 0), 0) && (shdr->sh_flags & (1 << 6)))
>    {
>      struct scninfo *ignore;
>      mark_section_used (&scninfo->fileinfo->scninfo[shdr->sh_info],
>    shdr->sh_info, &ignore);
>    }
>
>  if (__builtin_expect (!!(shdr->sh_flags & (1 << 9)), 0) && ld_state.gc_sections)
>
>    mark_section_group (scninfo->fileinfo, shndx, grpscnp);
>}
>
>
>
>
>
>
>static void
>add_section (struct usedfiles *fileinfo, struct scninfo *scninfo)
>{
>  struct scnhead *queued;
>  struct scnhead search;
>  unsigned long int hval;
>  GElf_Shdr *shdr = &(scninfo->shdr);
>  struct scninfo *grpscn = ((void *)0);
>  Elf_Data *grpscndata = ((void *)0);
># 984 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c"
>  if (!scninfo->used
>      && (ld_state.strip == strip_none
>   || (shdr->sh_flags & (1 << 1)) != 0
>   || shdr->sh_type == 7
>   || (shdr->sh_type == 1
>       && __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)) && __builtin_constant_p (".comment") && (__s1_len = strlen (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)), __s2_len = strlen (".comment"), (!((size_t)(const void *)((elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)) + 1) - (size_t)(const void *)(elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((".comment") + 1) - (size_t)(const void *)(".comment") == 1) || __s2_len >= 4)) ? __builtin_strcmp (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name), ".comment") : (__builtin_constant_p (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)) && ((size_t)(const void *)((elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)) + 1) - (size_t)(const void *)(elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)) == 1) && (__s1_len = strlen (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)), __s1_len < 4) ? (__builtin_constant_p (".comment") && ((size_t)(const void *)((".comment") + 1) - (size_t)(const void *)(".comment") == 1) ? __builtin_strcmp (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name), ".comment") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (".comment"); register int __result = (((const unsigned char *) (const char *) (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (".comment") && ((size_t)(const void *)((".comment") + 1) - (size_t)(const void *)(".comment") == 1) && (__s2_len = strlen (".comment"), __s2_len < 4) ? (__builtin_constant_p (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)) && ((size_t)(const void *)((elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)) + 1) - (size_t)(const void *)(elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)) == 1) ? __builtin_strcmp (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name), ".comment") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)); register int __result = __s1[0] - ((const unsigned char *) (const char *) (".comment"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) (".comment"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) (".comment"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) (".comment"))[3]); } } __result; }))) : __builtin_strcmp (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name), ".comment")))); }) == 0))
>
>
>      && (fileinfo->status != in_archive || !ld_state.gc_sections))
>
>    mark_section_used (scninfo, elf_ndxscn (scninfo->scn), &grpscn);
>
>  if ((shdr->sh_flags & (1 << 9)) && grpscn == ((void *)0))
>
>
>    grpscn = find_section_group (fileinfo, elf_ndxscn (scninfo->scn),
>     &grpscndata);
>  ((grpscn == ((void *)0) || grpscn->symbols->name != ((void *)0)) ? (void) (0) : __assert_fail ("grpscn == ((void *)0) || grpscn->symbols->name != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1001, __PRETTY_FUNCTION__));
>
>
>  search.name = elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name);
>  search.type = shdr->sh_type;
>  search.flags = shdr->sh_flags;
>  search.entsize = shdr->sh_entsize;
>  search.grp_signature = grpscn != ((void *)0) ? grpscn->symbols->name : ((void *)0);
>  search.kind = scn_normal;
>  hval = elf_hash (search.name);
>
>
>  queued = ld_section_tab_find (&ld_state.section_tab, hval, &search);
>  if (queued != ((void *)0))
>    {
>      _Bool is_comdat = 0;
>
>
>
>      if (__builtin_expect (!!(shdr->sh_flags & (1 << 9)), 0))
> {
>
>   if (grpscndata == ((void *)0))
>     {
>       grpscndata = elf_getdata (grpscn->scn, ((void *)0));
>       ((grpscndata != ((void *)0)) ? (void) (0) : __assert_fail ("grpscndata != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1026, __PRETTY_FUNCTION__));
>     }
>
>
>   if ((((Elf32_Word *) grpscndata->d_buf)[0] & 0x1) != 0)
>     {
>
>
>
>
>
>
>       struct scninfo *runp = queued->last;
>       do
>  {
>    if ((runp->shdr).sh_flags & (1 << 9))
>      {
>        struct scninfo *grpscn2
>   = find_section_group (runp->fileinfo,
>           elf_ndxscn (runp->scn),
>           &grpscndata);
>
>        if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (grpscn->symbols->name) && __builtin_constant_p (grpscn2->symbols->name) && (__s1_len = strlen (grpscn->symbols->name), __s2_len = strlen (grpscn2->symbols->name), (!((size_t)(const void *)((grpscn->symbols->name) + 1) - (size_t)(const void *)(grpscn->symbols->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((grpscn2->symbols->name) + 1) - (size_t)(const void *)(grpscn2->symbols->name) == 1) || __s2_len >= 4)) ? __builtin_strcmp (grpscn->symbols->name, grpscn2->symbols->name) : (__builtin_constant_p (grpscn->symbols->name) && ((size_t)(const void *)((grpscn->symbols->name) + 1) - (size_t)(const void *)(grpscn->symbols->name) == 1) && (__s1_len = strlen (grpscn->symbols->name), __s1_len < 4) ? (__builtin_constant_p (grpscn2->symbols->name) && ((size_t)(const void *)((grpscn2->symbols->name) + 1) - (size_t)(const void *)(grpscn2->symbols->name) == 1) ? __builtin_strcmp (grpscn->symbols->name, grpscn2->symbols->name) : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (grpscn2->symbols->name); register int __result = (((const unsigned char *) (const char *) (grpscn->symbols->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (grpscn->symbols->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (grpscn->symbols->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (grpscn->symbols->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (grpscn2->symbols->name) && ((size_t)(const void *)((grpscn2->symbols->name) + 1) - (size_t)(const void *)(grpscn2->symbols->name) == 1) && (__s2_len = strlen (grpscn2->symbols->name), __s2_len < 4) ? (__builtin_constant_p (grpscn->symbols->name) && ((size_t)(const void *)((grpscn->symbols->name) + 1) - (size_t)(const void *)(grpscn->symbols->name) == 1) ? __builtin_strcmp (grpscn->symbols->name, grpscn2->symbols->name) : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (grpscn->symbols->name); register int __result = __s1[0] - ((const unsigned char *) (const char *) (grpscn2->symbols->name))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) (grpscn2->symbols->name))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) (grpscn2->symbols->name))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) (grpscn2->symbols->name))[3]); } } __result; }))) : __builtin_strcmp (grpscn->symbols->name, grpscn2->symbols->name)))); }) == 0)
>
>   {
>     scninfo->unused_comdat = is_comdat = 1;
>     break;
>   }
>      }
>
>    runp = runp->next;
>  }
>       while (runp != queued->last);
>     }
> }
>
>      if (!is_comdat)
> {
>
>   scninfo->next = queued->last->next;
>   queued->last = queued->last->next = scninfo;
>
>   queued->flags = ebl_sh_flags_combine (ld_state.ebl, queued->flags,
>      shdr->sh_flags);
>   queued->align = (((queued->align)>(shdr->sh_addralign))?(queued->align):(shdr->sh_addralign));
> }
>    }
>  else
>    {
>
>
>      queued = (struct scnhead *) xcalloc (sizeof (struct scnhead), 1);
>      queued->kind = scn_normal;
>      queued->name = search.name;
>      queued->type = shdr->sh_type;
>      queued->flags = shdr->sh_flags;
>      queued->align = shdr->sh_addralign;
>      queued->entsize = shdr->sh_entsize;
>      queued->grp_signature = grpscn != ((void *)0) ? grpscn->symbols->name : ((void *)0);
>      queued->segment_nr = ~0;
>      queued->last = scninfo->next = scninfo;
>
>
>      ld_state.need_tls |= (shdr->sh_flags & (1 << 10)) != 0;
>
>
>      ld_section_tab_insert (&ld_state.section_tab, hval, queued);
>    }
>}
>
>
>static int
>add_relocatable_file (struct usedfiles *fileinfo, GElf_Word secttype)
>{
>  size_t scncnt;
>  size_t cnt;
>  Elf_Data *symtabdata = ((void *)0);
>  Elf_Data *xndxdata = ((void *)0);
>  Elf_Data *versymdata = ((void *)0);
>  Elf_Data *verdefdata = ((void *)0);
>  Elf_Data *verneeddata = ((void *)0);
>  size_t symstridx = 0;
>  size_t nsymbols = 0;
>  size_t nlocalsymbols = 0;
>  _Bool has_merge_sections = 0;
>
>
>  enum execstack execstack = execstack_true;
>
>
>  ((fileinfo->elf != ((void *)0)) ? (void) (0) : __assert_fail ("fileinfo->elf != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1116, __PRETTY_FUNCTION__));
>
>
>  if (__builtin_expect (!!(elf_getshnum (fileinfo->elf, &scncnt) < 0), 0))
>    error (1, 0,
>    dcgettext (((void *)0), "cannot determine number of sections: %s", __LC_MESSAGES),
>    elf_errmsg (-1));
>
>  fileinfo->scninfo = (struct scninfo *)
>    ({ size_t _s = (scncnt * sizeof (struct scninfo)); memset (__extension__ ({ struct obstack *__h = (&ld_state.smem); __extension__ ({ struct obstack *__o = (__h); int __len = ((_s)); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len)); (void) 0; }); __extension__ ({ struct obstack *__o1 = (__h); void *__value = (void *) __o1->object_base; if (__o1->next_free == __value) __o1->maybe_empty_object = 1; __o1->next_free = ((sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask))); if (__o1->next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit; __o1->object_base = __o1->next_free; __value; }); }), '\0', _s); });
>
>
>
>
>
>
>  for (cnt = 0; cnt < scncnt; ++cnt)
>    {
>
>      fileinfo->scninfo[cnt].scn = elf_getscn (fileinfo->elf, cnt);
>
>
>      GElf_Shdr *shdr;
>
>
>
>      if (fileinfo->scninfo[cnt].shdr.sh_type == 0)
>
> {
>
>
>
>
>   shdr = gelf_getshdr (fileinfo->scninfo[cnt].scn, &(fileinfo->scninfo[cnt].shdr));
>
>
>   if (shdr == ((void *)0))
>     {
>
>       fprintf (stderr, dcgettext (((void *)0), "%s: invalid ELF file (%s:%d)\n", __LC_MESSAGES),
>         fileinfo->rfname, "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1156);
>       return 1;
>     }
> }
>      else
> shdr = &(fileinfo->scninfo[cnt].shdr);
>
>      Elf_Data *data = elf_getdata (fileinfo->scninfo[cnt].scn, ((void *)0));
>
>
>      has_merge_sections |= (shdr->sh_flags & (1 << 4)) != 0;
>
>
>
>      fileinfo->scninfo[cnt].fileinfo = fileinfo;
>
>      if (__builtin_expect (!!(shdr->sh_type == 2), 0)
>   || __builtin_expect (!!(shdr->sh_type == 11), 0))
> {
>   if (shdr->sh_type == 2)
>     {
>       ((fileinfo->symtabdata == ((void *)0)) ? (void) (0) : __assert_fail ("fileinfo->symtabdata == ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1177, __PRETTY_FUNCTION__));
>       fileinfo->symtabdata = data;
>       fileinfo->nsymtab = shdr->sh_size / shdr->sh_entsize;
>       fileinfo->nlocalsymbols = shdr->sh_info;
>       fileinfo->symstridx = shdr->sh_link;
>     }
>   else
>     {
>       ((fileinfo->dynsymtabdata == ((void *)0)) ? (void) (0) : __assert_fail ("fileinfo->dynsymtabdata == ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1185, __PRETTY_FUNCTION__));
>       fileinfo->dynsymtabdata = data;
>       fileinfo->ndynsymtab = shdr->sh_size / shdr->sh_entsize;
>       fileinfo->dynsymstridx = shdr->sh_link;
>     }
>
>
>
>   if (secttype == shdr->sh_type)
>     {
>       ((symtabdata == ((void *)0)) ? (void) (0) : __assert_fail ("symtabdata == ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1195, __PRETTY_FUNCTION__));
>       symtabdata = data;
>       symstridx = shdr->sh_link;
>       nsymbols = shdr->sh_size / shdr->sh_entsize;
>       nlocalsymbols = shdr->sh_info;
>     }
> }
>      else if (__builtin_expect (!!(shdr->sh_type == 18), 0))
> {
>   ((xndxdata == ((void *)0)) ? (void) (0) : __assert_fail ("xndxdata == ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1204, __PRETTY_FUNCTION__));
>   fileinfo->xndxdata = xndxdata = data;
> }
>      else if (__builtin_expect (!!(shdr->sh_type == 0x6fffffff), 0))
> {
>   ((versymdata == 0) ? (void) (0) : __assert_fail ("versymdata == 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1209, __PRETTY_FUNCTION__));
>   fileinfo->versymdata = versymdata = data;
> }
>      else if (__builtin_expect (!!(shdr->sh_type == 0x6ffffffd), 0))
> {
>   size_t nversions;
>
>   ((verdefdata == 0) ? (void) (0) : __assert_fail ("verdefdata == 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1216, __PRETTY_FUNCTION__));
>   fileinfo->verdefdata = verdefdata = data;
>
>
>
>   fileinfo->nverdef = nversions = shdr->sh_info;
>
>
>   fileinfo->verdefused = (GElf_Versym *)
>     ({ size_t _s = (sizeof (GElf_Versym) * (nversions + 1)); memset (__extension__ ({ struct obstack *__h = (&ld_state.smem); __extension__ ({ struct obstack *__o = (__h); int __len = ((_s)); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len)); (void) 0; }); __extension__ ({ struct obstack *__o1 = (__h); void *__value = (void *) __o1->object_base; if (__o1->next_free == __value) __o1->maybe_empty_object = 1; __o1->next_free = ((sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask))); if (__o1->next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit; __o1->object_base = __o1->next_free; __value; }); }), '\0', _s); });
>
>   fileinfo->verdefent = (struct Ebl_Strent **)
>     __extension__ ({ struct obstack *__h = (&ld_state.smem); __extension__ ({ struct obstack *__o = (__h); int __len = ((sizeof (struct Ebl_Strent *) * (nversions + 1))); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len)); (void) 0; }); __extension__ ({ struct obstack *__o1 = (__h); void *__value = (void *) __o1->object_base; if (__o1->next_free == __value) __o1->maybe_empty_object = 1; __o1->next_free = ((sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask))); if (__o1->next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit; __o1->object_base = __o1->next_free; __value; }); });
>
> }
>      else if (__builtin_expect (!!(shdr->sh_type == 0x6ffffffe), 0))
> {
>   ((verneeddata == 0) ? (void) (0) : __assert_fail ("verneeddata == 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1233, __PRETTY_FUNCTION__));
>   fileinfo->verneeddata = verneeddata = data;
> }
>      else if (__builtin_expect (!!(shdr->sh_type == 6), 0))
> {
>   ((fileinfo->dynscn == ((void *)0)) ? (void) (0) : __assert_fail ("fileinfo->dynscn == ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1238, __PRETTY_FUNCTION__));
>   fileinfo->dynscn = fileinfo->scninfo[cnt].scn;
> }
>      else if (__builtin_expect (!!(shdr->sh_type == 17), 0))
> {
>   Elf_Scn *symscn;
>   GElf_Shdr symshdr_mem; GElf_Shdr *symshdr;
>   Elf_Data *symdata;
>
>   if ((fileinfo->ehdr).e_type != 1)
>     error (1, 0, dcgettext (((void *)0), "%s: only files of type ET_REL might contain section groups", __LC_MESSAGES),
>
>     fileinfo->fname);
>
>   fileinfo->scninfo[cnt].next = fileinfo->groups;
>   fileinfo->scninfo[cnt].grpid = cnt;
>   fileinfo->groups = &fileinfo->scninfo[cnt];
>
>
>
>   fileinfo->scninfo[cnt].symbols = (struct symbol *)
>     ({ size_t _s = (sizeof (struct symbol)); memset (__extension__ ({ struct obstack *__h = (&ld_state.smem); __extension__ ({ struct obstack *__o = (__h); int __len = ((_s)); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len)); (void) 0; }); __extension__ ({ struct obstack *__o1 = (__h); void *__value = (void *) __o1->object_base; if (__o1->next_free == __value) __o1->maybe_empty_object = 1; __o1->next_free = ((sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask))); if (__o1->next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit; __o1->object_base = __o1->next_free; __value; }); }), '\0', _s); });
>
>   symscn = elf_getscn (fileinfo->elf, shdr->sh_link);
>   symshdr = gelf_getshdr (symscn, &symshdr_mem);
>   symdata = elf_getdata (symscn, ((void *)0));
>
>   if (symshdr != ((void *)0))
>     {
>       GElf_Sym sym_mem; GElf_Sym *sym;
>
>
>
>       sym = gelf_getsym (symdata, shdr->sh_info, &sym_mem);
>       if (sym != ((void *)0))
>  {
>    struct symbol *symbol = fileinfo->scninfo[cnt].symbols;
>
>
>    if (((sym->st_info) & 0xf) == 3)
>      {
>        GElf_Shdr buggyshdr_mem; GElf_Shdr *buggyshdr;
>        buggyshdr = gelf_getshdr (elf_getscn (fileinfo->elf, sym->st_shndx), &buggyshdr_mem);
>
>
>        symbol->name = elf_strptr (fileinfo->elf,
>       (fileinfo->ehdr).e_shstrndx,
>       buggyshdr->sh_name);
>        symbol->symidx = -1;
>      }
>    else
>
>      {
>        symbol->name = elf_strptr (fileinfo->elf,
>       symshdr->sh_link,
>       sym->st_name);
>        symbol->symidx = shdr->sh_info;
>      }
>    symbol->file = fileinfo;
>  }
>     }
>   if (fileinfo->scninfo[cnt].symbols->name == ((void *)0))
>     error (1, 0, dcgettext (((void *)0), "%s: cannot determine signature of section group [%2zd] '%s': %s", __LC_MESSAGES),
>
>     fileinfo->fname,
>     elf_ndxscn (fileinfo->scninfo[cnt].scn),
>     elf_strptr (fileinfo->elf, fileinfo->shstrndx,
>          shdr->sh_name),
>     elf_errmsg (-1));
>
>
>
>
>   if (data == ((void *)0))
>     error (1, 0, dcgettext (((void *)0), "%s: cannot get content of section group [%2zd] '%s': %s'", __LC_MESSAGES),
>
>     fileinfo->fname, elf_ndxscn (fileinfo->scninfo[cnt].scn),
>     elf_strptr (fileinfo->elf, fileinfo->shstrndx,
>          shdr->sh_name),
>     elf_errmsg (-1));
>
>   Elf32_Word *grpdata = (Elf32_Word *) data->d_buf;
>   if (grpdata[0] & 0x1)
>     fileinfo->scninfo[cnt].comdat_group = 1;
>   for (size_t inner = 1; inner < data->d_size / sizeof (Elf32_Word);
>        ++inner)
>     {
>       if (grpdata[inner] >= scncnt)
>  error (1, 0, dcgettext (((void *)0), "%s: group member %zu of section group [%2zd] '%s' has too high index: %" "u", __LC_MESSAGES),
>
>         fileinfo->fname,
>         inner, elf_ndxscn (fileinfo->scninfo[cnt].scn),
>         elf_strptr (fileinfo->elf, fileinfo->shstrndx,
>       shdr->sh_name),
>         grpdata[inner]);
>
>       fileinfo->scninfo[grpdata[inner]].grpid = cnt;
>     }
>
>
>
>
>   ((fileinfo->scninfo[cnt].used == 0) ? (void) (0) : __assert_fail ("fileinfo->scninfo[cnt].used == 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1340, __PRETTY_FUNCTION__));
> }
>      else if (! (_dl_mcount_wrapper_check ((void *) ((&ld_state)->callbacks.section_type_p)), (*((&ld_state)->callbacks.section_type_p)) (&ld_state, shdr->sh_type))
>        && __builtin_expect (!!((shdr->sh_flags & (1 << 8)) != 0), 0))
>
>
>
> error (1, 0,
>        dcgettext (((void *)0), "%s: section '%s' has unknown type: %d", __LC_MESSAGES),
>        fileinfo->fname,
>        elf_strptr (fileinfo->elf, fileinfo->shstrndx,
>      shdr->sh_name),
>        (int) shdr->sh_type);
>
>
>
>
>      else if (__builtin_expect (!!(fileinfo->file_type == relocatable_file_type), 1)
>        && __builtin_expect (!!(cnt > 0), 1)
>        && __builtin_expect (!!(shdr->sh_type == 1 || shdr->sh_type == 4 || shdr->sh_type == 9 || shdr->sh_type == 7 || shdr->sh_type == 8 || shdr->sh_type == 14 || shdr->sh_type == 15 || shdr->sh_type == 16), 1))
>
>
>
>
>
>
>
> {
>
>   if (shdr->sh_type == 1
>       && (shdr->sh_flags & (1 << 2)) == 0
>       && __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)) && __builtin_constant_p (".note.GNU-stack") && (__s1_len = strlen (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)), __s2_len = strlen (".note.GNU-stack"), (!((size_t)(const void *)((elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)) + 1) - (size_t)(const void *)(elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((".note.GNU-stack") + 1) - (size_t)(const void *)(".note.GNU-stack") == 1) || __s2_len >= 4)) ? __builtin_strcmp (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name), ".note.GNU-stack") : (__builtin_constant_p (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)) && ((size_t)(const void *)((elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)) + 1) - (size_t)(const void *)(elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)) == 1) && (__s1_len = strlen (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)), __s1_len < 4) ? (__builtin_constant_p (".note.GNU-stack") && ((size_t)(const void *)((".note.GNU-stack") + 1) - (size_t)(const void *)(".note.GNU-stack") == 1) ? __builtin_strcmp (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name), ".note.GNU-stack") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (".note.GNU-stack"); register int __result = (((const unsigned char *) (const char *) (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (".note.GNU-stack") && ((size_t)(const void *)((".note.GNU-stack") + 1) - (size_t)(const void *)(".note.GNU-stack") == 1) && (__s2_len = strlen (".note.GNU-stack"), __s2_len < 4) ? (__builtin_constant_p (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)) && ((size_t)(const void *)((elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)) + 1) - (size_t)(const void *)(elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)) == 1) ? __builtin_strcmp (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name), ".note.GNU-stack") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name)); register int __result = __s1[0] - ((const unsigned char *) (const char *) (".note.GNU-stack"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) (".note.GNU-stack"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) (".note.GNU-stack"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) (".note.GNU-stack"))[3]); } } __result; }))) : __builtin_strcmp (elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name), ".note.GNU-stack")))); }) == 0)
>
>
>     execstack = execstack_false;
>
>   add_section (fileinfo, &fileinfo->scninfo[cnt]);
> }
>    }
>
>
>
>  if (fileinfo->file_type == relocatable_file_type
>      && execstack == execstack_true
>      && ld_state.execstack != execstack_false_force)
>    ld_state.execstack = execstack_true;
>
>
>
>
>  if (__builtin_expect (!!(symtabdata != ((void *)0)), 1))
>    {
>
>
>      fileinfo->has_merge_sections = has_merge_sections;
>      if (__builtin_expect (!!(has_merge_sections), 1))
> {
>   fileinfo->symref = (struct symbol **)
>     ({ size_t _s = (nsymbols * sizeof (struct symbol *)); memset (__extension__ ({ struct obstack *__h = (&ld_state.smem); __extension__ ({ struct obstack *__o = (__h); int __len = ((_s)); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len)); (void) 0; }); __extension__ ({ struct obstack *__o1 = (__h); void *__value = (void *) __o1->object_base; if (__o1->next_free == __value) __o1->maybe_empty_object = 1; __o1->next_free = ((sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask))); if (__o1->next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit; __o1->object_base = __o1->next_free; __value; }); }), '\0', _s); });
>
>
>
>   for (cnt = 0; cnt < nlocalsymbols; ++cnt)
>     {
>       Elf32_Word shndx;
>       GElf_Sym sym_mem; GElf_Sym *sym;
>
>       sym = gelf_getsymshndx (symtabdata, xndxdata, cnt, &sym_mem, &(shndx));
>       if (sym == ((void *)0))
>  {
>
>    fprintf (stderr, dcgettext (((void *)0), "%s: invalid ELF file (%s:%d)\n", __LC_MESSAGES),
>      fileinfo->rfname, "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1412);
>    return 1;
>  }
>
>       if (__builtin_expect (!!(shndx != 0xffff), 1))
>  shndx = sym->st_shndx;
>       else if (__builtin_expect (!!(shndx == 0), 0))
>  {
>    fprintf (stderr, dcgettext (((void *)0), "%s: invalid ELF file (%s:%d)\n", __LC_MESSAGES),
>      fileinfo->rfname, "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1421);
>    return 1;
>  }
>
>       if (((sym->st_info) & 0xf) != 3
>    && (shndx < 0xff00 || shndx > 0xffff)
>    && ((fileinfo->scninfo[shndx].shdr).sh_flags
>        & (1 << 4)))
>  {
>
>
>    struct symbol *newp;
>
>    newp = (struct symbol *)
>      ({ size_t _s = (sizeof (struct symbol)); memset (__extension__ ({ struct obstack *__h = (&ld_state.smem); __extension__ ({ struct obstack *__o = (__h); int __len = ((_s)); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len)); (void) 0; }); __extension__ ({ struct obstack *__o1 = (__h); void *__value = (void *) __o1->object_base; if (__o1->next_free == __value) __o1->maybe_empty_object = 1; __o1->next_free = ((sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask))); if (__o1->next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit; __o1->object_base = __o1->next_free; __value; }); }), '\0', _s); });
>
>    newp->symidx = cnt;
>    newp->scndx = shndx;
>    newp->file = fileinfo;
>    fileinfo->symref[cnt] = newp;
>
>    if (fileinfo->scninfo[shndx].symbols == ((void *)0))
>      fileinfo->scninfo[shndx].symbols = newp->next_in_scn
>        = newp;
>    else
>      {
>        newp->next_in_scn
>   = fileinfo->scninfo[shndx].symbols->next_in_scn;
>        fileinfo->scninfo[shndx].symbols
>   = fileinfo->scninfo[shndx].symbols->next_in_scn = newp;
>      }
>  }
>     }
> }
>      else
>
>
>
>
>
> fileinfo->symref = (struct symbol **)
>   ({ size_t _s = (((nsymbols - nlocalsymbols) * sizeof (struct symbol *))); memset (__extension__ ({ struct obstack *__h = (&ld_state.smem); __extension__ ({ struct obstack *__o = (__h); int __len = ((_s)); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len)); (void) 0; }); __extension__ ({ struct obstack *__o1 = (__h); void *__value = (void *) __o1->object_base; if (__o1->next_free == __value) __o1->maybe_empty_object = 1; __o1->next_free = ((sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask))); if (__o1->next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit; __o1->object_base = __o1->next_free; __value; }); }), '\0', _s); })
>
>   - nlocalsymbols;
>
>
>
>      for (cnt = nlocalsymbols; cnt < nsymbols; ++cnt)
> {
>   GElf_Sym sym_mem; GElf_Sym *sym;
>   Elf32_Word shndx;
>   sym = gelf_getsymshndx (symtabdata, xndxdata, cnt, &sym_mem, &(shndx));
>
>   if (sym == ((void *)0))
>     {
>
>       fprintf (stderr, dcgettext (((void *)0), "%s: invalid ELF file (%s:%d)\n", __LC_MESSAGES),
>         fileinfo->rfname, "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1478);
>       return 1;
>     }
>
>   if (__builtin_expect (!!(shndx != 0xffff), 1))
>     shndx = sym->st_shndx;
>   else if (__builtin_expect (!!(shndx == 0), 0))
>     {
>       fprintf (stderr, dcgettext (((void *)0), "%s: invalid ELF file (%s:%d)\n", __LC_MESSAGES),
>         fileinfo->rfname, "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1487);
>       return 1;
>     }
>
>
>
>   if (__builtin_expect (!!(shndx == 0xfff1), 0) && secttype == 11)
>     continue;
>
>   if ((shndx < 0xff00 || shndx > 0xffff)
>       && fileinfo->scninfo[shndx].unused_comdat)
>
>     continue;
>
>
>
>   if (versymdata != ((void *)0))
>     {
>       GElf_Versym versym;
>
>       if (gelf_getversym (versymdata, cnt, &versym) == ((void *)0))
>
>  ((! "xelf_getversym failed") ? (void) (0) : __assert_fail ("! \"xelf_getversym failed\"", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1509, __PRETTY_FUNCTION__));
>
>       if ((versym & 0x8000) != 0)
>
>  continue;
>     }
>
>
>   struct symbol search;
>   search.name = elf_strptr (fileinfo->elf, symstridx, sym->st_name);
>   unsigned long int hval = elf_hash (search.name);
>
>
>
>
>
>   if (((__builtin_expect (!!(hval == 165832675ul), 0)
>  && __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (search.name) && __builtin_constant_p ("_DYNAMIC") && (__s1_len = strlen (search.name), __s2_len = strlen ("_DYNAMIC"), (!((size_t)(const void *)((search.name) + 1) - (size_t)(const void *)(search.name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("_DYNAMIC") + 1) - (size_t)(const void *)("_DYNAMIC") == 1) || __s2_len >= 4)) ? __builtin_strcmp (search.name, "_DYNAMIC") : (__builtin_constant_p (search.name) && ((size_t)(const void *)((search.name) + 1) - (size_t)(const void *)(search.name) == 1) && (__s1_len = strlen (search.name), __s1_len < 4) ? (__builtin_constant_p ("_DYNAMIC") && ((size_t)(const void *)(("_DYNAMIC") + 1) - (size_t)(const void *)("_DYNAMIC") == 1) ? __builtin_strcmp (search.name, "_DYNAMIC") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("_DYNAMIC"); register int __result = (((const unsigned char *) (const char *) (search.name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (search.name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (search.name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (search.name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("_DYNAMIC") && ((size_t)(const void *)(("_DYNAMIC") + 1) - (size_t)(const void *)("_DYNAMIC") == 1) && (__s2_len = strlen ("_DYNAMIC"), __s2_len < 4) ? (__builtin_constant_p (search.name) && ((size_t)(const void *)((search.name) + 1) - (size_t)(const void *)(search.name) == 1) ? __builtin_strcmp (search.name, "_DYNAMIC") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (search.name); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("_DYNAMIC"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("_DYNAMIC"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("_DYNAMIC"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("_DYNAMIC"))[3]); } } __result; }))) : __builtin_strcmp (search.name, "_DYNAMIC")))); }) == 0)
>        || (__builtin_expect (!!(hval == 102264335ul), 0)
>     && __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (search.name) && __builtin_constant_p ("_GLOBAL_OFFSET_TABLE_") && (__s1_len = strlen (search.name), __s2_len = strlen ("_GLOBAL_OFFSET_TABLE_"), (!((size_t)(const void *)((search.name) + 1) - (size_t)(const void *)(search.name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("_GLOBAL_OFFSET_TABLE_") + 1) - (size_t)(const void *)("_GLOBAL_OFFSET_TABLE_") == 1) || __s2_len >= 4)) ? __builtin_strcmp (search.name, "_GLOBAL_OFFSET_TABLE_") : (__builtin_constant_p (search.name) && ((size_t)(const void *)((search.name) + 1) - (size_t)(const void *)(search.name) == 1) && (__s1_len = strlen (search.name), __s1_len < 4) ? (__builtin_constant_p ("_GLOBAL_OFFSET_TABLE_") && ((size_t)(const void *)(("_GLOBAL_OFFSET_TABLE_") + 1) - (size_t)(const void *)("_GLOBAL_OFFSET_TABLE_") == 1) ? __builtin_strcmp (search.name, "_GLOBAL_OFFSET_TABLE_") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("_GLOBAL_OFFSET_TABLE_"); register int __result = (((const unsigned char *) (const char *) (search.name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (search.name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (search.name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (search.name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("_GLOBAL_OFFSET_TABLE_") && ((size_t)(const void *)(("_GLOBAL_OFFSET_TABLE_") + 1) - (size_t)(const void *)("_GLOBAL_OFFSET_TABLE_") == 1) && (__s2_len = strlen ("_GLOBAL_OFFSET_TABLE_"), __s2_len < 4) ? (__builtin_constant_p (search.name) && ((size_t)(const void *)((search.name) + 1) - (size_t)(const void *)(search.name) == 1) ? __builtin_strcmp (search.name, "_GLOBAL_OFFSET_TABLE_") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (search.name); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("_GLOBAL_OFFSET_TABLE_"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("_GLOBAL_OFFSET_TABLE_"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("_GLOBAL_OFFSET_TABLE_"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("_GLOBAL_OFFSET_TABLE_"))[3]); } } __result; }))) : __builtin_strcmp (search.name, "_GLOBAL_OFFSET_TABLE_")))); }) == 0))
>       && sym->st_shndx != 0
>
>
>       && fileinfo->file_type != relocatable_file_type)
>     continue;
>
>   struct symbol *oldp = ld_symbol_tab_find (&ld_state.symbol_tab,
>          hval, &search);
>   struct symbol *newp;
>   if (__builtin_expect (!!(oldp == ((void *)0)), 1))
>     {
>
>       newp = (struct symbol *) __extension__ ({ struct obstack *__h = (&ld_state.smem); __extension__ ({ struct obstack *__o = (__h); int __len = ((sizeof (*newp))); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len)); (void) 0; }); __extension__ ({ struct obstack *__o1 = (__h); void *__value = (void *) __o1->object_base; if (__o1->next_free == __value) __o1->maybe_empty_object = 1; __o1->next_free = ((sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask))); if (__o1->next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit; __o1->object_base = __o1->next_free; __value; }); });
>
>       newp->name = search.name;
>       newp->size = sym->st_size;
>       newp->type = ((sym->st_info) & 0xf);
>       newp->symidx = cnt;
>       newp->outsymidx = 0;
>       newp->outdynsymidx = 0;
>       newp->scndx = shndx;
>       newp->file = fileinfo;
>       newp->defined = newp->scndx != 0;
>       newp->common = newp->scndx == 0xfff2;
>       newp->weak = (((unsigned char) (sym->st_info)) >> 4) == 2;
>       newp->added = 0;
>       newp->merged = 0;
>       newp->local = 0;
>       newp->hidden = 0;
>       newp->need_copy = 0;
>       newp->on_dsolist = 0;
>       newp->in_dso = secttype == 11;
>       newp->next_in_scn = ((void *)0);
>
>       newp->next = ((void *)0);
>       newp->previous = ((void *)0);
>
>
>       if (newp->scndx == 0)
>  {
>    do { __typeof (newp) _newp = (newp); ((_newp->next == ((void *)0)) ? (void) (0) : __assert_fail ("_newp->next == ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1569, __PRETTY_FUNCTION__)); ((_newp->previous == ((void *)0)) ? (void) (0) : __assert_fail ("_newp->previous == ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1569, __PRETTY_FUNCTION__)); if (__builtin_expect (!!((ld_state.unresolved) == ((void *)0)), 0)) (ld_state.unresolved) = _newp->next = _newp->previous = _newp; else { _newp->next = (ld_state.unresolved); _newp->previous = (ld_state.unresolved)->previous; _newp->previous->next = _newp->next->previous = _newp; } } while (0);
>    ++ld_state.nunresolved;
>    if (! newp->weak)
>      ++ld_state.nunresolved_nonweak;
>  }
>       else if (newp->scndx == 0xfff2)
>  {
>
>    newp->merge.value = sym->st_value;
>
>    do { __typeof (newp) _newp = (newp); ((_newp->next == ((void *)0)) ? (void) (0) : __assert_fail ("_newp->next == ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1579, __PRETTY_FUNCTION__)); ((_newp->previous == ((void *)0)) ? (void) (0) : __assert_fail ("_newp->previous == ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1579, __PRETTY_FUNCTION__)); if (__builtin_expect (!!((ld_state.common_syms) == ((void *)0)), 0)) (ld_state.common_syms) = _newp->next = _newp->previous = _newp; else { _newp->next = (ld_state.common_syms); _newp->previous = (ld_state.common_syms)->previous; _newp->previous->next = _newp->next->previous = _newp; } } while (0);
>  }
>
>
>       if (__builtin_expect (!!(ld_symbol_tab_insert (&ld_state.symbol_tab, hval, newp) != 0), 0))
>
>
>  abort ();
>
>       fileinfo->symref[cnt] = newp;
>
>
>
>
>
>
>       if (hval == 6685956 && __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (newp->name) && __builtin_constant_p ("_init") && (__s1_len = strlen (newp->name), __s2_len = strlen ("_init"), (!((size_t)(const void *)((newp->name) + 1) - (size_t)(const void *)(newp->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("_init") + 1) - (size_t)(const void *)("_init") == 1) || __s2_len >= 4)) ? __builtin_strcmp (newp->name, "_init") : (__builtin_constant_p (newp->name) && ((size_t)(const void *)((newp->name) + 1) - (size_t)(const void *)(newp->name) == 1) && (__s1_len = strlen (newp->name), __s1_len < 4) ? (__builtin_constant_p ("_init") && ((size_t)(const void *)(("_init") + 1) - (size_t)(const void *)("_init") == 1) ? __builtin_strcmp (newp->name, "_init") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("_init"); register int __result = (((const unsigned char *) (const char *) (newp->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (newp->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (newp->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (newp->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("_init") && ((size_t)(const void *)(("_init") + 1) - (size_t)(const void *)("_init") == 1) && (__s2_len = strlen ("_init"), __s2_len < 4) ? (__builtin_constant_p (newp->name) && ((size_t)(const void *)((newp->name) + 1) - (size_t)(const void *)(newp->name) == 1) ? __builtin_strcmp (newp->name, "_init") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (newp->name); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("_init"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("_init"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("_init"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("_init"))[3]); } } __result; }))) : __builtin_strcmp (newp->name, "_init")))); }) == 0)
>  ld_state.init_symbol = newp;
>       else if (hval == 6672457 && __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (newp->name) && __builtin_constant_p ("_fini") && (__s1_len = strlen (newp->name), __s2_len = strlen ("_fini"), (!((size_t)(const void *)((newp->name) + 1) - (size_t)(const void *)(newp->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("_fini") + 1) - (size_t)(const void *)("_fini") == 1) || __s2_len >= 4)) ? __builtin_strcmp (newp->name, "_fini") : (__builtin_constant_p (newp->name) && ((size_t)(const void *)((newp->name) + 1) - (size_t)(const void *)(newp->name) == 1) && (__s1_len = strlen (newp->name), __s1_len < 4) ? (__builtin_constant_p ("_fini") && ((size_t)(const void *)(("_fini") + 1) - (size_t)(const void *)("_fini") == 1) ? __builtin_strcmp (newp->name, "_fini") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("_fini"); register int __result = (((const unsigned char *) (const char *) (newp->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (newp->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (newp->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (newp->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("_fini") && ((size_t)(const void *)(("_fini") + 1) - (size_t)(const void *)("_fini") == 1) && (__s2_len = strlen ("_fini"), __s2_len < 4) ? (__builtin_constant_p (newp->name) && ((size_t)(const void *)((newp->name) + 1) - (size_t)(const void *)(newp->name) == 1) ? __builtin_strcmp (newp->name, "_fini") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (newp->name); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("_fini"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("_fini"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("_fini"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("_fini"))[3]); } } __result; }))) : __builtin_strcmp (newp->name, "_fini")))); }) == 0)
>  ld_state.fini_symbol = newp;
>     }
>   else if (__builtin_expect (!!(check_definition (sym, shndx, cnt, fileinfo, oldp) != 0), 0))
>
>
>
>     return 1;
>   else
>
>
>     newp = fileinfo->symref[cnt] = oldp;
>
>
>   if (shndx != 0
>       && (shndx < 0xff00 || shndx > 0xffff))
>     {
>       struct scninfo *ignore;
>
>
>       size_t shnum;
>       ((elf_getshnum (fileinfo->elf, &shnum) == 0) ? (void) (0) : __assert_fail ("elf_getshnum (fileinfo->elf, &shnum) == 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1618, __PRETTY_FUNCTION__));
>       ((shndx < shnum) ? (void) (0) : __assert_fail ("shndx < shnum", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1619, __PRETTY_FUNCTION__));
>
>
>
>       mark_section_used (&fileinfo->scninfo[shndx], shndx, &ignore);
>
>
>
>       if ((fileinfo->scninfo[shndx].shdr).sh_flags
>    & (1 << 4))
>  {
>    if (fileinfo->scninfo[shndx].symbols == ((void *)0))
>      fileinfo->scninfo[shndx].symbols = newp->next_in_scn
>        = newp;
>    else
>      {
>        newp->next_in_scn
>   = fileinfo->scninfo[shndx].symbols->next_in_scn;
>        fileinfo->scninfo[shndx].symbols
>   = fileinfo->scninfo[shndx].symbols->next_in_scn = newp;
>      }
>  }
>     }
> }
>
>
>      if (__builtin_expect (!!(fileinfo->file_type == relocatable_file_type), 1))
> {
>   if (__builtin_expect (!!(ld_state.relfiles == ((void *)0)), 0))
>     ld_state.relfiles = fileinfo->next = fileinfo;
>   else
>     {
>       fileinfo->next = ld_state.relfiles->next;
>       ld_state.relfiles = ld_state.relfiles->next = fileinfo;
>     }
>
>
>   ld_state.nsymtab += fileinfo->nsymtab;
>   ld_state.nlocalsymbols += fileinfo->nlocalsymbols;
> }
>      else if (__builtin_expect (!!(fileinfo->file_type == dso_file_type), 1))
> {
>   do { __typeof (fileinfo) _newp = (fileinfo); ((_newp->next == ((void *)0)) ? (void) (0) : __assert_fail ("_newp->next == ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1661, __PRETTY_FUNCTION__)); if (__builtin_expect (!!((ld_state.dsofiles) == ((void *)0)), 0)) (ld_state.dsofiles) = _newp->next = _newp; else { _newp->next = (ld_state.dsofiles)->next; (ld_state.dsofiles) = (ld_state.dsofiles)->next = _newp; } } while (0);
>   ++ld_state.ndsofiles;
>
>   if (fileinfo->lazyload)
>
>
>
>
>
>     ++ld_state.ndsofiles;
> }
>    }
>
>  return 0;
>}
>
>
>int
>ld_handle_filename_list (struct filename_list *fnames)
>{
>  struct filename_list *runp;
>  int res = 0;
>
>  for (runp = fnames; runp != ((void *)0); runp = runp->next)
>    {
>      struct usedfiles *curp;
>
>
>      curp = runp->real = ld_new_inputfile (runp->name, relocatable_file_type);
>
>
>      curp->group_start = runp->group_start;
>      curp->group_end = runp->group_end;
>
>
>      curp->as_needed = runp->as_needed;
>
>
>
>      do
> res |= (_dl_mcount_wrapper_check ((void *) ((&ld_state)->callbacks.file_process)), (*((&ld_state)->callbacks.file_process)) (-1, curp, &ld_state, &curp));
>      while (curp != ((void *)0));
>    }
>
>
>  while (fnames != ((void *)0))
>    {
>      runp = fnames;
>      fnames = fnames->next;
>      free (runp);
>    }
>
>  return res;
>}
>
>
>
>static int
>open_elf (struct usedfiles *fileinfo, Elf *elf)
>{
>  int res = 0;
>
>  if (elf == ((void *)0))
>    error (1, 0,
>    dcgettext (((void *)0), "cannot get descriptor for ELF file (%s:%d): %s\n", __LC_MESSAGES),
>    "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1726, elf_errmsg (-1));
>
>  if (__builtin_expect (!!(elf_kind (elf) == ELF_K_NONE), 0))
>    {
>      struct filename_list *fnames;
>
>
>      fileinfo->status = closed;
>
>
>      if (fileinfo->fd != -1)
>
> ldin = fdopen (fileinfo->fd, "r");
>      else
> {
>
>   char *content;
>   size_t contentsize;
>
>
>   content = elf_rawfile (elf, &contentsize);
>   if (content == ((void *)0))
>     {
>       fprintf (stderr, dcgettext (((void *)0), "%s: invalid ELF file (%s:%d)\n", __LC_MESSAGES),
>         fileinfo->rfname, "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1750);
>       return 1;
>     }
>
>
>
>   ldin = fmemopen (content, contentsize, "r");
> }
>
>
>      __fsetlocking (ldin, FSETLOCKING_BYCALLER);
>
>      if (ldin == ((void *)0))
> error (1, (*__errno_location ()), dcgettext (((void *)0), "cannot open '%s'", __LC_MESSAGES),
>        fileinfo->rfname);
>
>
>
>      ld_state.srcfiles = ((void *)0);
>      ldlineno = 1;
>      ld_scan_version_script = 0;
>      ldin_fname = fileinfo->rfname;
>      res = ldparse ();
>
>      fclose (ldin);
>      if (fileinfo->fd != -1 && !fileinfo->fd_passed)
> {
>
>   close (fileinfo->fd);
>   fileinfo->fd = -1;
> }
>
>      elf_end (elf);
>
>      if (__builtin_expect (!!(res != 0), 0))
>
> return 1;
>
>
>      fileinfo->elf = ((void *)0);
>
>
>
>      fnames = ld_state.srcfiles;
>      if (fnames != ((void *)0))
> {
>   struct filename_list *oldp;
>
>
>   oldp = fnames;
>   fnames = fnames->next;
>   oldp->next = ((void *)0);
>
>
>   ld_state.srcfiles = ((void *)0);
>
>   if (__builtin_expect (!!(ld_handle_filename_list (fnames) != 0), 0))
>     return 1;
> }
>
>      return 0;
>    }
>
>
>  fileinfo->elf = elf;
>
>
>  fileinfo->status = opened;
>
>  return 0;
>}
>
>
>static int
>add_whole_archive (struct usedfiles *fileinfo)
>{
>  Elf *arelf;
>  Elf_Cmd cmd = ELF_C_READ_MMAP_PRIVATE;
>  int res = 0;
>
>  while ((arelf = elf_begin (fileinfo->fd, cmd, fileinfo->elf)) != ((void *)0))
>    {
>      Elf_Arhdr *arhdr = elf_getarhdr (arelf);
>      struct usedfiles *newp;
>
>      if (arhdr == ((void *)0))
> abort ();
>
>
>
>      ((__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (arhdr->ar_name) && __builtin_constant_p ("/") && (__s1_len = strlen (arhdr->ar_name), __s2_len = strlen ("/"), (!((size_t)(const void *)((arhdr->ar_name) + 1) - (size_t)(const void *)(arhdr->ar_name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("/") + 1) - (size_t)(const void *)("/") == 1) || __s2_len >= 4)) ? __builtin_strcmp (arhdr->ar_name, "/") : (__builtin_constant_p (arhdr->ar_name) && ((size_t)(const void *)((arhdr->ar_name) + 1) - (size_t)(const void *)(arhdr->ar_name) == 1) && (__s1_len = strlen (arhdr->ar_name), __s1_len < 4) ? (__builtin_constant_p ("/") && ((size_t)(const void *)(("/") + 1) - (size_t)(const void *)("/") == 1) ? __builtin_strcmp (arhdr->ar_name, "/") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("/"); register int __result = (((const unsigned char *) (const char *) (arhdr->ar_name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (arhdr->ar_name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (arhdr->ar_name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (arhdr->ar_name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("/") && ((size_t)(const void *)(("/") + 1) - (size_t)(const void *)("/") == 1) && (__s2_len = strlen ("/"), __s2_len < 4) ? (__builtin_constant_p (arhdr->ar_name) && ((size_t)(const void *)((arhdr->ar_name) + 1) - (size_t)(const void *)(arhdr->ar_name) == 1) ? __builtin_strcmp (arhdr->ar_name, "/") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (arhdr->ar_name); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("/"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("/"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("/"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("/"))[3]); } } __result; }))) : __builtin_strcmp (arhdr->ar_name, "/")))); }) != 0) ? (void) (0) : __assert_fail ("__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (arhdr->ar_name) && __builtin_constant_p (\"/\") && (__s1_len = strlen (arhdr->ar_name), __s2_len = strlen (\"/\"), (!((size_t)(const void *)((arhdr->ar_name) + 1) - (size_t)(const void *)(arhdr->ar_name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((\"/\") + 1) - (size_t)(const void *)(\"/\") == 1) || __s2_len >= 4)) ? __builtin_strcmp (arhdr->ar_name, \"/\") : (__builtin_constant_p (arhdr->ar_name) && ((size_t)(const void *)((arhdr->ar_name) + 1) - (size_t)(const void *)(arhdr->ar_name) == 1) && (__s1_len = strlen (arhdr->ar_name), __s1_len < 4) ? (__builtin_constant_p (\"/\") && ((size_t)(const void *)((\"/\") + 1) - (size_t)(const void *)(\"/\") == 1) ? __builtin_strcmp (arhdr->ar_name, \"/\") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (\"/\"); register int __result = (((const unsigned char *) (const char *) (arhdr->ar_name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (arhdr->ar_name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (arhdr->ar_name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (arhdr->ar_name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (\"/\") && ((size_t)(const void *)((\"/\") + 1) - (size_t)(const void *)(\"/\") == 1) && (__s2_len = strlen (\"/\"), __s2_len < 4) ? (__builtin_constant_p (arhdr->ar_name) && ((size_t)(const void *)((arhdr->ar_name) + 1) - (size_t)(const void *)(arhdr->ar_name) == 1) ? __builtin_strcmp (arhdr->ar_name, \"/\") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (arhdr->ar_name); register int __result = __s1[0] - ((const unsigned char *) (const char *) (\"/\"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) (\"/\"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) (\"/\"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) (\"/\"))[3]); } } __result; }))) : __builtin_strcmp (arhdr->ar_name, \"/\")))); }) != 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1840, __PRETTY_FUNCTION__));
>      ((__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (arhdr->ar_name) && __builtin_constant_p ("//") && (__s1_len = strlen (arhdr->ar_name), __s2_len = strlen ("//"), (!((size_t)(const void *)((arhdr->ar_name) + 1) - (size_t)(const void *)(arhdr->ar_name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("//") + 1) - (size_t)(const void *)("//") == 1) || __s2_len >= 4)) ? __builtin_strcmp (arhdr->ar_name, "//") : (__builtin_constant_p (arhdr->ar_name) && ((size_t)(const void *)((arhdr->ar_name) + 1) - (size_t)(const void *)(arhdr->ar_name) == 1) && (__s1_len = strlen (arhdr->ar_name), __s1_len < 4) ? (__builtin_constant_p ("//") && ((size_t)(const void *)(("//") + 1) - (size_t)(const void *)("//") == 1) ? __builtin_strcmp (arhdr->ar_name, "//") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("//"); register int __result = (((const unsigned char *) (const char *) (arhdr->ar_name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (arhdr->ar_name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (arhdr->ar_name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (arhdr->ar_name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("//") && ((size_t)(const void *)(("//") + 1) - (size_t)(const void *)("//") == 1) && (__s2_len = strlen ("//"), __s2_len < 4) ? (__builtin_constant_p (arhdr->ar_name) && ((size_t)(const void *)((arhdr->ar_name) + 1) - (size_t)(const void *)(arhdr->ar_name) == 1) ? __builtin_strcmp (arhdr->ar_name, "//") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (arhdr->ar_name); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("//"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("//"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("//"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("//"))[3]); } } __result; }))) : __builtin_strcmp (arhdr->ar_name, "//")))); }) != 0) ? (void) (0) : __assert_fail ("__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (arhdr->ar_name) && __builtin_constant_p (\"//\") && (__s1_len = strlen (arhdr->ar_name), __s2_len = strlen (\"//\"), (!((size_t)(const void *)((arhdr->ar_name) + 1) - (size_t)(const void *)(arhdr->ar_name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((\"//\") + 1) - (size_t)(const void *)(\"//\") == 1) || __s2_len >= 4)) ? __builtin_strcmp (arhdr->ar_name, \"//\") : (__builtin_constant_p (arhdr->ar_name) && ((size_t)(const void *)((arhdr->ar_name) + 1) - (size_t)(const void *)(arhdr->ar_name) == 1) && (__s1_len = strlen (arhdr->ar_name), __s1_len < 4) ? (__builtin_constant_p (\"//\") && ((size_t)(const void *)((\"//\") + 1) - (size_t)(const void *)(\"//\") == 1) ? __builtin_strcmp (arhdr->ar_name, \"//\") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (\"//\"); register int __result = (((const unsigned char *) (const char *) (arhdr->ar_name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (arhdr->ar_name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (arhdr->ar_name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (arhdr->ar_name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (\"//\") && ((size_t)(const void *)((\"//\") + 1) - (size_t)(const void *)(\"//\") == 1) && (__s2_len = strlen (\"//\"), __s2_len < 4) ? (__builtin_constant_p (arhdr->ar_name) && ((size_t)(const void *)((arhdr->ar_name) + 1) - (size_t)(const void *)(arhdr->ar_name) == 1) ? __builtin_strcmp (arhdr->ar_name, \"//\") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (arhdr->ar_name); register int __result = __s1[0] - ((const unsigned char *) (const char *) (\"//\"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) (\"//\"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) (\"//\"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) (\"//\"))[3]); } } __result; }))) : __builtin_strcmp (arhdr->ar_name, \"//\")))); }) != 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1841, __PRETTY_FUNCTION__));
>
>      newp = ld_new_inputfile (arhdr->ar_name, relocatable_file_type);
>      newp->archive_file = fileinfo;
>
>      if (__builtin_expect (!!(ld_state.trace_files), 0))
> print_file_name (stdout, newp, 1, 1);
>
>
>      newp->fd = -1;
>
>      newp->elf = arelf;
>
>      newp->status = opened;
>
>
>      res = file_process2 (newp);
>      if (__builtin_expect (!!(res != 0), 0))
>     break;
>
>
>      cmd = elf_next (arelf);
>    }
>
>  return res;
>}
>
>
>static int
>extract_from_archive (struct usedfiles *fileinfo)
>{
>  static int archive_seq;
>  int res = 0;
>
>  if (fileinfo->archive_seq == 0)
>
>
>    fileinfo->archive_seq = ++archive_seq;
>
>
>  ((ld_state.extract_rule == defaultextract || ld_state.extract_rule == weakextract) ? (void) (0) : __assert_fail ("ld_state.extract_rule == defaultextract || ld_state.extract_rule == weakextract", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1882, __PRETTY_FUNCTION__));
>
>  if ((__builtin_expect (!!(ld_state.extract_rule == defaultextract), 1)
>       ? ld_state.nunresolved_nonweak : ld_state.nunresolved) == 0)
>    return 0;
>
>  Elf_Arsym *syms;
>  size_t nsyms;
>
>
>  syms = elf_getarsym (fileinfo->elf, &nsyms);
>  if (syms == ((void *)0))
>    {
>    cannot_read_archive:
>      error (0, 0, dcgettext (((void *)0), "cannot read archive `%s': %s", __LC_MESSAGES),
>      fileinfo->rfname, elf_errmsg (-1));
>
>
>      fileinfo->status = closed;
>
>      return 1;
>    }
>
>
>
>
>
>  _Bool any_used;
>  do
>    {
>      any_used = 0;
>
>      size_t cnt;
>      for (cnt = 0; cnt < nsyms; ++cnt)
> {
>   struct symbol search = { .name = syms[cnt].as_name };
>   struct symbol *sym = ld_symbol_tab_find (&ld_state.symbol_tab,
>         syms[cnt].as_hash, &search);
>   if (sym != ((void *)0) && ! sym->defined)
>     {
>
>       Elf *arelf;
>       Elf_Arhdr *arhdr;
>       struct usedfiles *newp;
>
>
>       if (__builtin_expect (!!(elf_rand (fileinfo->elf, syms[cnt].as_off) != syms[cnt].as_off), 0))
>
>  goto cannot_read_archive;
>
>
>
>       arelf = elf_begin (fileinfo->fd, ELF_C_READ_MMAP_PRIVATE,
>     fileinfo->elf);
>       arhdr = elf_getarhdr (arelf);
>       if (arhdr == ((void *)0))
>  goto cannot_read_archive;
>
>
>
>
>       newp = ld_new_inputfile (({ const char *_s = (arhdr->ar_name); __extension__ ({ struct obstack *__h = (&ld_state.smem); __extension__ ({ struct obstack *__o = (__h); int __len = ((strlen (_s))); if (__o->next_free + __len + 1 > __o->chunk_limit) _obstack_newchunk (__o, __len + 1); memcpy (__o->next_free, (_s), __len); __o->next_free += __len; *(__o->next_free)++ = 0; (void) 0; }); __extension__ ({ struct obstack *__o1 = (__h); void *__value = (void *) __o1->object_base; if (__o1->next_free == __value) __o1->maybe_empty_object = 1; __o1->next_free = ((sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask))); if (__o1->next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit; __o1->object_base = __o1->next_free; __value; }); }); }),
>
>           relocatable_file_type);
>       newp->archive_file = fileinfo;
>
>       if (__builtin_expect (!!(ld_state.trace_files), 0))
>  print_file_name (stdout, newp, 1, 1);
>
>
>       newp->fd = -1;
>
>       newp->elf = arelf;
>
>       newp->status = in_archive;
>
>
>       res = file_process2 (newp);
>       if (__builtin_expect (!!(res != 0), 0))
>  return res;
>
>       any_used = 1;
>     }
> }
>
>      if (any_used)
> {
>
>   ((fileinfo->archive_seq != 0) ? (void) (0) : __assert_fail ("fileinfo->archive_seq != 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 1969, __PRETTY_FUNCTION__));
>   ld_state.last_archive_used = fileinfo->archive_seq;
> }
>    }
>  while (any_used);
>
>  return res;
>}
>
>
>static int
>file_process2 (struct usedfiles *fileinfo)
>{
>  int res;
>
>  if (__builtin_expect (!!(elf_kind (fileinfo->elf) == ELF_K_ELF), 1))
>    {
>
>
>
>
>      if (__builtin_expect (!!((fileinfo->ehdr).e_type == 0), 1))
>
> {
>   GElf_Ehdr *ehdr;
>
>
>
>   ehdr = gelf_getehdr (fileinfo->elf, &(fileinfo->ehdr));
>
>   if (ehdr == ((void *)0))
>     {
>       fprintf (stderr, dcgettext (((void *)0), "%s: invalid ELF file (%s:%d)\n", __LC_MESSAGES),
>         fileinfo->rfname, "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 2002);
>       fileinfo->status = closed;
>       return 1;
>     }
>
>   if ((fileinfo->ehdr).e_type != 1
>       && __builtin_expect (!!((fileinfo->ehdr).e_type != 3), 0))
>
>
>     {
>       char buf[64];
>
>       print_file_name (stderr, fileinfo, 1, 0);
>       fprintf (stderr,
>         dcgettext (((void *)0), "file of type %s cannot be linked in\n", __LC_MESSAGES),
>         ebl_object_type_name (ld_state.ebl,
>          (fileinfo->ehdr).e_type,
>          buf, sizeof (buf)));
>       fileinfo->status = closed;
>       return 1;
>     }
>
>
>   if ((fileinfo->ehdr).e_machine
>       != ebl_get_elfmachine (ld_state.ebl))
>     {
>       fprintf (stderr, dcgettext (((void *)0), "%s: input file incompatible with ELF machine type %s\n", __LC_MESSAGES),
>
>         fileinfo->rfname,
>         ebl_backend_name (ld_state.ebl));
>       fileinfo->status = closed;
>       return 1;
>     }
>
>
>   if (__builtin_expect (!!(elf_getshstrndx (fileinfo->elf, &fileinfo->shstrndx) < 0), 0))
>
>     {
>       fprintf (stderr, dcgettext (((void *)0), "%s: cannot get section header string table index: %s\n", __LC_MESSAGES),
>
>         fileinfo->rfname, elf_errmsg (-1));
>       fileinfo->status = closed;
>       return 1;
>     }
> }
>
>
>      if ((fileinfo->ehdr).e_type == 1)
> {
>
>
>   res = add_relocatable_file (fileinfo, 2);
> }
>      else
> {
>   _Bool has_l_name = fileinfo->file_type == archive_file_type;
>
>   (((fileinfo->ehdr).e_type == 3) ? (void) (0) : __assert_fail ("(fileinfo->ehdr).e_type == 3", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 2059, __PRETTY_FUNCTION__));
>
>
>
>   if (fileinfo->file_type != dso_needed_file_type)
>     fileinfo->file_type = dso_file_type;
>
>
>   if (ld_state.file_type == relocatable_file_type)
>     {
>       error (0, 0, dcgettext (((void *)0), "cannot use DSO '%s' when generating relocatable object file", __LC_MESSAGES),
>
>       fileinfo->fname);
>       return 1;
>     }
>
>
>
>   res = add_relocatable_file (fileinfo, 11);
>
>
>   ((fileinfo->dynscn != ((void *)0)) ? (void) (0) : __assert_fail ("fileinfo->dynscn != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 2080, __PRETTY_FUNCTION__));
>
>
>
>   GElf_Shdr dynshdr_mem; GElf_Shdr *dynshdr;
>   dynshdr = gelf_getshdr (fileinfo->dynscn, &dynshdr_mem);
>
>   Elf_Data *dyndata = elf_getdata (fileinfo->dynscn, ((void *)0));
>
>   if (dynshdr != ((void *)0))
>     {
>       int cnt = dynshdr->sh_size / dynshdr->sh_entsize;
>       GElf_Dyn dyn_mem; GElf_Dyn *dyn;
>
>       while (--cnt >= 0)
>  {
>    dyn = gelf_getdyn (dyndata, cnt, &dyn_mem);
>    if (dyn != ((void *)0))
>      {
>        if(dyn->d_tag == 1)
>   {
>     struct usedfiles *newp;
>
>     newp = ld_new_inputfile (elf_strptr (fileinfo->elf,
>              dynshdr->sh_link,
>              dyn->d_un.d_val),
>         dso_needed_file_type);
>
>
>
>
>     do { __typeof (newp) _newp = (newp); ((_newp->next == ((void *)0)) ? (void) (0) : __assert_fail ("_newp->next == ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 2111, __PRETTY_FUNCTION__)); if (__builtin_expect (!!((ld_state.needed) == ((void *)0)), 0)) (ld_state.needed) = _newp->next = _newp; else { _newp->next = (ld_state.needed)->next; (ld_state.needed) = (ld_state.needed)->next = _newp; } } while (0);
>   }
>        else if (dyn->d_tag == 14)
>   {
>
>
>     fileinfo->soname = elf_strptr (fileinfo->elf,
>        dynshdr->sh_link,
>        dyn->d_un.d_val);
>     has_l_name = 0;
>   }
>      }
>  }
>     }
>
>
>
>
>   if (__builtin_expect (!!(has_l_name), 0))
>     {
>
>
>       size_t len = strlen (fileinfo->fname) + 7;
>       char *newp;
>
>       newp = (char *) __extension__ ({ struct obstack *__h = (&ld_state.smem); __extension__ ({ struct obstack *__o = (__h); int __len = ((len)); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len)); (void) 0; }); __extension__ ({ struct obstack *__o1 = (__h); void *__value = (void *) __o1->object_base; if (__o1->next_free == __value) __o1->maybe_empty_object = 1; __o1->next_free = ((sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask))); if (__o1->next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit; __o1->object_base = __o1->next_free; __value; }); });
>       strcpy (__builtin_stpcpy (__builtin_stpcpy (newp, "lib"), fileinfo->fname), ".so");
>
>       fileinfo->soname = newp;
>     }
> }
>    }
>  else if (__builtin_expect (!!(elf_kind (fileinfo->elf) == ELF_K_AR), 1))
>    {
>      if (__builtin_expect (!!(ld_state.extract_rule == allextract), 0))
>
>
> res = add_whole_archive (fileinfo);
>      else if (ld_state.file_type == relocatable_file_type)
> {
>
>
>   if (verbose)
>     error (0, 0, dcgettext (((void *)0), "input file '%s' ignored", __LC_MESSAGES), fileinfo->fname);
>
>   res = 0;
> }
>      else
> {
>   if (ld_state.group_start_requested
>       && ld_state.group_start_archive == ((void *)0))
>     ld_state.group_start_archive = fileinfo;
>
>   if (ld_state.archives == ((void *)0))
>     ld_state.archives = fileinfo;
>
>   if (ld_state.tailarchives != ((void *)0))
>     ld_state.tailarchives->next = fileinfo;
>   ld_state.tailarchives = fileinfo;
>
>
>
>   res = extract_from_archive (fileinfo);
> }
>    }
>  else
>
>    abort ();
>
>  return res;
>}
>
>
>
>
>
>
>
>static int
>ld_generic_file_process (int fd, struct usedfiles *fileinfo,
>    struct ld_state *statep, struct usedfiles **nextp)
>{
>  int res = 0;
>
>
>  *nextp = fileinfo->next;
>
>
>  if (__builtin_expect (!!(fileinfo->group_start), 0))
>    {
>      ld_state.group_start_requested = 1;
>      fileinfo->group_start = 0;
>    }
>
>
>  if (__builtin_expect (!!(fileinfo->status == not_opened), 1))
>    {
>      _Bool fd_passed = 1;
>
>      if (__builtin_expect (!!(fd == -1), 1))
> {
>
>   int err = open_along_path (fileinfo);
>   if (__builtin_expect (!!(err != 0), 0))
>
>
>     return err == 11 ? 0 : err;
>
>   fd_passed = 0;
> }
>      else
> fileinfo->fd = fd;
>
>
>      fileinfo->fd_passed = fd_passed;
>
>
>
>
>
>
>
>      res = open_elf (fileinfo, elf_begin (fileinfo->fd,
>        is_dso_p (fileinfo->fd)
>        ? ELF_C_READ_MMAP
>        : ELF_C_READ_MMAP_PRIVATE, ((void *)0)));
>      if (__builtin_expect (!!(res != 0), 0))
> return res;
>    }
>
>
>  if (__builtin_expect (!!(fileinfo->status != closed), 1))
>    res = file_process2 (fileinfo);
>
>
>  if (__builtin_expect (!!(fileinfo->group_backref != ((void *)0)), 0))
>    {
>
>
>      if (ld_state.last_archive_used > fileinfo->group_backref->archive_seq)
> {
>   *nextp = fileinfo->group_backref;
>   ld_state.last_archive_used = 0;
> }
>      else
> {
>
>
>
>   struct usedfiles *runp = ld_state.archives;
>
>   do
>     {
>
>
>
>       elf_end (runp->elf);
>       runp->elf = ((void *)0);
>
>       runp = runp->next;
>     }
>   while (runp != fileinfo->next);
>
>
>   ld_state.archives = ((void *)0);
>
>
>   *nextp = fileinfo->next = ((void *)0);
> }
>    }
>  else if (__builtin_expect (!!(fileinfo->group_end), 0))
>    {
>
>
>
>
>      if (ld_state.group_start_requested)
> {
>   if (ld_state.group_start_archive != ld_state.tailarchives)
>
>     {
>       *nextp = ld_state.tailarchives->group_backref =
>  ld_state.group_start_archive;
>       ld_state.last_archive_used = 0;
>     }
>   else
>
>
>
>     if (ld_state.tailarchives != fileinfo)
>       {
>  *nextp = ld_state.group_start_archive;
>  ld_state.last_archive_used = 0;
>       }
> }
>
>
>      ld_state.group_start_requested = 0;
>      ld_state.group_start_archive = ((void *)0);
>      fileinfo->group_end = 0;
>    }
>
>  return res;
>}
>
>
>
>
>
>static const char **
>ld_generic_lib_extensions (struct ld_state *statep __attribute__ ((__unused__)))
>{
>  static const char *exts[] =
>    {
>      ".so", ".a", ((void *)0)
>    };
>
>  return exts;
>}
>
>
>
>static int
>ld_generic_flag_unresolved (struct ld_state *statep)
>{
>  int retval = 0;
>
>  if (ld_state.nunresolved_nonweak > 0)
>    {
>
>      struct symbol *first;
>      struct symbol *s;
>
>      s = first = ld_state.unresolved->next;
>      do
> {
>   if (! s->defined && ! s->weak)
>     {
>
>
>       if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (s->name) && __builtin_constant_p ("_GLOBAL_OFFSET_TABLE_") && (__s1_len = strlen (s->name), __s2_len = strlen ("_GLOBAL_OFFSET_TABLE_"), (!((size_t)(const void *)((s->name) + 1) - (size_t)(const void *)(s->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("_GLOBAL_OFFSET_TABLE_") + 1) - (size_t)(const void *)("_GLOBAL_OFFSET_TABLE_") == 1) || __s2_len >= 4)) ? __builtin_strcmp (s->name, "_GLOBAL_OFFSET_TABLE_") : (__builtin_constant_p (s->name) && ((size_t)(const void *)((s->name) + 1) - (size_t)(const void *)(s->name) == 1) && (__s1_len = strlen (s->name), __s1_len < 4) ? (__builtin_constant_p ("_GLOBAL_OFFSET_TABLE_") && ((size_t)(const void *)(("_GLOBAL_OFFSET_TABLE_") + 1) - (size_t)(const void *)("_GLOBAL_OFFSET_TABLE_") == 1) ? __builtin_strcmp (s->name, "_GLOBAL_OFFSET_TABLE_") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("_GLOBAL_OFFSET_TABLE_"); register int __result = (((const unsigned char *) (const char *) (s->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (s->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (s->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (s->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("_GLOBAL_OFFSET_TABLE_") && ((size_t)(const void *)(("_GLOBAL_OFFSET_TABLE_") + 1) - (size_t)(const void *)("_GLOBAL_OFFSET_TABLE_") == 1) && (__s2_len = strlen ("_GLOBAL_OFFSET_TABLE_"), __s2_len < 4) ? (__builtin_constant_p (s->name) && ((size_t)(const void *)((s->name) + 1) - (size_t)(const void *)(s->name) == 1) ? __builtin_strcmp (s->name, "_GLOBAL_OFFSET_TABLE_") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (s->name); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("_GLOBAL_OFFSET_TABLE_"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("_GLOBAL_OFFSET_TABLE_"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("_GLOBAL_OFFSET_TABLE_"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("_GLOBAL_OFFSET_TABLE_"))[3]); } } __result; }))) : __builtin_strcmp (s->name, "_GLOBAL_OFFSET_TABLE_")))); }) == 0
>    || __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (s->name) && __builtin_constant_p ("_DYNAMIC") && (__s1_len = strlen (s->name), __s2_len = strlen ("_DYNAMIC"), (!((size_t)(const void *)((s->name) + 1) - (size_t)(const void *)(s->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("_DYNAMIC") + 1) - (size_t)(const void *)("_DYNAMIC") == 1) || __s2_len >= 4)) ? __builtin_strcmp (s->name, "_DYNAMIC") : (__builtin_constant_p (s->name) && ((size_t)(const void *)((s->name) + 1) - (size_t)(const void *)(s->name) == 1) && (__s1_len = strlen (s->name), __s1_len < 4) ? (__builtin_constant_p ("_DYNAMIC") && ((size_t)(const void *)(("_DYNAMIC") + 1) - (size_t)(const void *)("_DYNAMIC") == 1) ? __builtin_strcmp (s->name, "_DYNAMIC") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("_DYNAMIC"); register int __result = (((const unsigned char *) (const char *) (s->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (s->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (s->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (s->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("_DYNAMIC") && ((size_t)(const void *)(("_DYNAMIC") + 1) - (size_t)(const void *)("_DYNAMIC") == 1) && (__s2_len = strlen ("_DYNAMIC"), __s2_len < 4) ? (__builtin_constant_p (s->name) && ((size_t)(const void *)((s->name) + 1) - (size_t)(const void *)(s->name) == 1) ? __builtin_strcmp (s->name, "_DYNAMIC") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (s->name); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("_DYNAMIC"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("_DYNAMIC"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("_DYNAMIC"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("_DYNAMIC"))[3]); } } __result; }))) : __builtin_strcmp (s->name, "_DYNAMIC")))); }) == 0)
>  {
>
>    ld_state.need_got = 1;
>
>
>    if (s->name[1] == 'G')
>      ld_state.got_symbol = s;
>    else
>      ld_state.dyn_symbol = s;
>  }
>       else if (ld_state.file_type != dso_file_type || !ld_state.nodefs)
>  {
>
>
>
>    error (0, 0, dcgettext (((void *)0), "undefined symbol `%s' in %s", __LC_MESSAGES),
>    s->name, s->file->fname);
>
>    retval = 1;
>  }
>     }
>
>
>
>
>
>
>
>   s = s->next;
> }
>      while (s != first);
>    }
>
>  return retval;
>}
>
>
>
>static int
>ld_generic_file_close (struct usedfiles *fileinfo, struct ld_state *statep)
>{
>
>  elf_end (fileinfo->elf);
>
>
>
>  if (!fileinfo->fd_passed && fileinfo->fd != -1)
>    close (fileinfo->fd);
>
>
>  if (fileinfo->fname != fileinfo->rfname)
>    free ((char *) fileinfo->rfname);
>
>  return 0;
>}
>
>
>static void
>new_generated_scn (enum scn_kind kind, const char *name, int type, int flags,
>     int entsize, int align)
>{
>  struct scnhead *newp;
>
>  newp = (struct scnhead *) ({ size_t _s = (sizeof (struct scnhead)); memset (__extension__ ({ struct obstack *__h = (&ld_state.smem); __extension__ ({ struct obstack *__o = (__h); int __len = ((_s)); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len)); (void) 0; }); __extension__ ({ struct obstack *__o1 = (__h); void *__value = (void *) __o1->object_base; if (__o1->next_free == __value) __o1->maybe_empty_object = 1; __o1->next_free = ((sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask))); if (__o1->next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit; __o1->object_base = __o1->next_free; __value; }); }), '\0', _s); });
>
>  newp->kind = kind;
>  newp->name = name;
>  newp->nameent = ebl_strtabadd (ld_state.shstrtab, name, 0);
>  newp->type = type;
>  newp->flags = flags;
>  newp->entsize = entsize;
>  newp->align = align;
>  newp->grp_signature = ((void *)0);
>  newp->used = 1;
>
>
>
>  ld_section_tab_insert (&ld_state.section_tab, elf_hash (name), newp);
>}
>
>
>
>
>static void
>ld_generic_generate_sections (struct ld_state *statep)
>{
>
>  int rel_type = (_dl_mcount_wrapper_check ((void *) ((&ld_state)->callbacks.rel_type)), (*((&ld_state)->callbacks.rel_type)) (&ld_state)) == 17 ? 9 : 4;
>
>
>  if (statep->build_id != ((void *)0))
>    new_generated_scn (scn_dot_note_gnu_build_id, ".note.gnu.build-id",
>         7, (1 << 1), 0, 4);
># 2456 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c"
>  if (dynamically_linked_p ())
>    {
>
>      _Bool use_versioning = 0;
>
>      _Bool need_version = 0;
>
>
>      if (ld_state.interp != ((void *)0) || ld_state.file_type != dso_file_type)
> new_generated_scn (scn_dot_interp, ".interp", 1, (1 << 1),
>      0, 1);
>
>
>      new_generated_scn (scn_dot_dynamic, ".dynamic", 6,
>    (_dl_mcount_wrapper_check ((void *) ((&ld_state)->callbacks.dynamic_section_flags)), (*((&ld_state)->callbacks.dynamic_section_flags)) (&ld_state)),
>    gelf_fsize (ld_state.outelf, ELF_T_DYN, 1, 1),
>    gelf_fsize (ld_state.outelf, ELF_T_ADDR, 1, 1));
>
>
>
>
>      ld_state.need_dynsym = 1;
>      new_generated_scn (scn_dot_dynsym, ".dynsym", 11, (1 << 1),
>    gelf_fsize (ld_state.outelf, ELF_T_SYM, 1, 1),
>    gelf_fsize (ld_state.outelf, ELF_T_ADDR, 1, 1));
>
>      new_generated_scn (scn_dot_dynstr, ".dynstr", 3, (1 << 1),
>    0, 1);
>
>
>      if (((ld_state.hash_style & hash_style_sysv) != 0))
> new_generated_scn (scn_dot_hash, ".hash", 5, (1 << 1),
>      sizeof (Elf32_Word), sizeof (Elf32_Word));
>      if (((ld_state.hash_style & hash_style_gnu) != 0))
> new_generated_scn (scn_dot_gnu_hash, ".gnu.hash", 0x6ffffff6,
>      (1 << 1), sizeof (Elf32_Word),
>      sizeof (Elf32_Word));
>
>
>      if (ld_state.nplt > 0)
> {
>
>
>   new_generated_scn (scn_dot_plt, ".plt", 1,
>        (1 << 1) | (1 << 2),
>
>        gelf_fsize (ld_state.outelf, ELF_T_ADDR, 1, 1),
>        gelf_fsize (ld_state.outelf, ELF_T_ADDR, 1, 1));
>
>
>
>   new_generated_scn (scn_dot_pltrel, ".rel.plt", rel_type, (1 << 1),
>        rel_type == 9
>        ? gelf_fsize (ld_state.outelf, ELF_T_REL, 1, 1)
>        : gelf_fsize (ld_state.outelf, ELF_T_RELA, 1, 1),
>        gelf_fsize (ld_state.outelf, ELF_T_ADDR, 1, 1));
>
>
>   new_generated_scn (scn_dot_gotplt, ".got.plt", 1,
>        (1 << 1) | (1 << 0),
>        gelf_fsize (ld_state.outelf, ELF_T_ADDR, 1, 1),
>        gelf_fsize (ld_state.outelf, ELF_T_ADDR, 1, 1));
>
>
>
>   if (ld_state.from_dso != ((void *)0))
>     {
>       struct symbol *srunp = ld_state.from_dso;
>
>       do
>  {
>    srunp->file->used = 1;
>
>    if (srunp->file->verdefdata != ((void *)0))
>      {
>        GElf_Versym versym;
>
>
>        use_versioning = 1;
>
>        need_version = 1;
>
>        if (gelf_getversym (srunp->file->versymdata, srunp->symidx, &versym) == ((void *)0))
>
>   ((! "xelf_getversym failed") ? (void) (0) : __assert_fail ("! \"xelf_getversym failed\"", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 2540, __PRETTY_FUNCTION__));
>
>
>
>        (((versym & 0x8000) == 0) ? (void) (0) : __assert_fail ("(versym & 0x8000) == 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 2544, __PRETTY_FUNCTION__));
>
>
>        ((versym > 1) ? (void) (0) : __assert_fail ("versym > 1", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 2547, __PRETTY_FUNCTION__));
>
>
>
>
>        if (! srunp->file->verdefused[versym])
>   {
>     srunp->file->verdefused[versym] = 1;
>
>     if (++srunp->file->nverdefused == 1)
>
>       ++ld_state.nverdeffile;
>     ++ld_state.nverdefused;
>   }
>      }
>  }
>       while ((srunp = srunp->next) != ld_state.from_dso);
>     }
>
>
>   if (need_version)
>     new_generated_scn (scn_dot_version_r, ".gnu.version_r",
>          0x6ffffffe, (1 << 1), 0,
>          gelf_fsize (ld_state.outelf, ELF_T_WORD, 1, 1));
> }
>
>
>
>      int ndt_needed = 0;
>      if (ld_state.ndsofiles > 0)
> {
>   struct usedfiles *frunp = ld_state.dsofiles;
>
>   do
>     if (! frunp->as_needed || frunp->used)
>       {
>  ++ndt_needed;
>  if (frunp->lazyload)
>
>
>
>
>
>
>    ++ndt_needed;
>       }
>   while ((frunp = frunp->next) != ld_state.dsofiles);
> }
>
>      if (use_versioning)
> new_generated_scn (scn_dot_version, ".gnu.version", 0x6fffffff,
>      (1 << 1),
>      gelf_fsize (ld_state.outelf, ELF_T_HALF, 1, 1),
>      gelf_fsize (ld_state.outelf, ELF_T_HALF, 1, 1));
>
>
>      ld_state.ndynamic = (7 + (ld_state.runpath != ((void *)0)
>    || ld_state.rpath != ((void *)0))
>      + ndt_needed
>      + (ld_state.init_symbol != ((void *)0) ? 1 : 0)
>      + (ld_state.fini_symbol != ((void *)0) ? 1 : 0)
>      + (use_versioning ? 1 : 0)
>      + (need_version ? 2 : 0)
>      + (ld_state.nplt > 0 ? 4 : 0)
>      + (ld_state.relsize_total > 0 ? 3 : 0));
>    }
>
>
>
>  ld_state.need_symtab = (ld_state.file_type == relocatable_file_type
>     || ld_state.strip == strip_none);
>
>
>  if (ld_state.need_got)
>
>    new_generated_scn (scn_dot_got, ".got", 1,
>         (1 << 1) | (1 << 0),
>         gelf_fsize (ld_state.outelf, ELF_T_ADDR, 1, 1),
>         gelf_fsize (ld_state.outelf, ELF_T_ADDR, 1, 1));
>
>
>  if (ld_state.relsize_total > 0)
>    new_generated_scn (scn_dot_dynrel, ".rel.dyn", rel_type, (1 << 1),
>         rel_type == 9
>         ? gelf_fsize (ld_state.outelf, ELF_T_REL, 1, 1)
>         : gelf_fsize (ld_state.outelf, ELF_T_RELA, 1, 1),
>         gelf_fsize (ld_state.outelf, ELF_T_ADDR, 1, 1));
>}
>
>
>
>
>static void
>remove_tempfile (int status, void *arg)
>{
>  if (status != 0 && ld_state.tempfname != ((void *)0))
>    unlink (ld_state.tempfname);
>}
>
>
>
>
>static int
>ld_generic_open_outfile (struct ld_state *statep, int machine, int klass,
>    int data)
>{
>
>
>
>
>  if (ld_state.outfname == ((void *)0))
>    ld_state.outfname = "a.out";
>
>  size_t outfname_len = strlen (ld_state.outfname);
>  char *tempfname = (char *) __extension__ ({ struct obstack *__h = (&ld_state.smem); __extension__ ({ struct obstack *__o = (__h); int __len = ((outfname_len + sizeof (".XXXXXX"))); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len)); (void) 0; }); __extension__ ({ struct obstack *__o1 = (__h); void *__value = (void *) __o1->object_base; if (__o1->next_free == __value) __o1->maybe_empty_object = 1; __o1->next_free = ((sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask))); if (__o1->next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit; __o1->object_base = __o1->next_free; __value; }); });
>
>  ld_state.tempfname = tempfname;
>
>  int fd;
>  int try = 0;
>  while (1)
>    {
>      strcpy (__builtin_mempcpy (tempfname, ld_state.outfname, outfname_len), ".XXXXXX");
>
>
>
>
>
>      if (mktemp (tempfname) != ((void *)0)
>   && (fd = open (tempfname, 02 | 0200 | 0100 | 0100000,
>    ld_state.file_type == relocatable_file_type
>    ? (0400|0200|(0400 >> 3)|(0200 >> 3)|((0400 >> 3) >> 3)|((0200 >> 3) >> 3)) : ((0400|0200|0100)|((0400|0200|0100) >> 3)|(((0400|0200|0100) >> 3) >> 3)))) != -1)
> break;
>
>
>      if (++try >= 10)
> error (1, (*__errno_location ()), dcgettext (((void *)0), "cannot create output file", __LC_MESSAGES));
>    }
>  ld_state.outfd = fd;
>
>
>
>  on_exit (remove_tempfile, ((void *)0));
>
>
>  Elf *elf = ld_state.outelf = elf_begin (fd,
>       conserve_memory
>       ? ELF_C_WRITE : ELF_C_WRITE_MMAP,
>       ((void *)0));
>  if (elf == ((void *)0))
>    error (1, 0,
>    dcgettext (((void *)0), "cannot create ELF descriptor for output file: %s", __LC_MESSAGES),
>    elf_errmsg (-1));
>
>
>  if (! gelf_newehdr (elf, klass))
>
>    error (1, 0,
>    dcgettext (((void *)0), "could not create ELF header for output file: %s", __LC_MESSAGES),
>    elf_errmsg (-1));
>
>
>  GElf_Ehdr ehdr_mem; GElf_Ehdr *ehdr;
>  ehdr = gelf_getehdr (elf, &ehdr_mem);
>  ((ehdr != ((void *)0)) ? (void) (0) : __assert_fail ("ehdr != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 2711, __PRETTY_FUNCTION__));
>
>
>  ehdr->e_machine = machine;
>
>
>  if (ld_state.file_type == executable_file_type)
>    ehdr->e_type = 2;
>  else if (ld_state.file_type == dso_file_type)
>    ehdr->e_type = 3;
>  else
>    {
>      ((ld_state.file_type == relocatable_file_type) ? (void) (0) : __assert_fail ("ld_state.file_type == relocatable_file_type", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 2723, __PRETTY_FUNCTION__));
>      ehdr->e_type = 1;
>    }
>
>
>  ehdr->e_version = 1;
>
>
>  ehdr->e_ident[5] = data;
>
>
>  (void) gelf_update_ehdr (elf, ehdr);
>
>  return 0;
>}
># 2746 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c"
>static void
>compute_copy_reloc_offset (GElf_Shdr *shdr)
>{
>  struct symbol *runp = ld_state.from_dso;
>  ((runp != ((void *)0)) ? (void) (0) : __assert_fail ("runp != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 2750, __PRETTY_FUNCTION__));
>
>  GElf_Off maxalign = 1;
>  GElf_Off offset = 0;
>
>  do
>    if (runp->need_copy)
>      {
># 2766 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c"
> GElf_Off symalign = ((((runp->file->scninfo[runp->scndx].shdr).sh_addralign)>(1))?((runp->file->scninfo[runp->scndx].shdr).sh_addralign):(1));
>
> maxalign = (((maxalign)>(symalign))?(maxalign):(symalign));
>
>
> offset = (offset + symalign - 1) & ~(symalign - 1);
>
> runp->merge.value = offset;
>
> offset += runp->size;
>      }
>  while ((runp = runp->next) != ld_state.from_dso);
>
>  shdr->sh_type = 8;
>  shdr->sh_size = offset;
>  shdr->sh_addralign = maxalign;
>}
>
>
>static void
>compute_common_symbol_offset (GElf_Shdr *shdr)
>{
>  struct symbol *runp = ld_state.common_syms;
>  ((runp != ((void *)0)) ? (void) (0) : __assert_fail ("runp != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 2789, __PRETTY_FUNCTION__));
>
>  GElf_Off maxalign = 1;
>  GElf_Off offset = 0;
>
>  do
>    {
>
>      GElf_Off symalign = runp->merge.value;
>
>
>      maxalign = (((maxalign)>(symalign))?(maxalign):(symalign));
>
>
>      offset = (offset + symalign - 1) & ~(symalign - 1);
>
>      runp->merge.value = offset;
>
>      offset += runp->size;
>    }
>  while ((runp = runp->next) != ld_state.common_syms);
>
>  shdr->sh_type = 8;
>  shdr->sh_size = offset;
>  shdr->sh_addralign = maxalign;
>}
>
>
>static void
>sort_sections_generic (void)
>{
>
>  abort ();
>}
>
>
>static int
>match_section (const char *osectname, struct filemask_section_name *sectmask,
>        struct scnhead **scnhead, _Bool new_section, size_t segment_nr)
>{
>  struct scninfo *prevp;
>  struct scninfo *runp;
>  struct scninfo *notused;
>
>  if (fnmatch (sectmask->section_name->name, (*scnhead)->name, 0) != 0)
>
>    return new_section;
>
>
>
>
>  if ((*scnhead)->kind != scn_normal)
>    {
>      (*scnhead)->name = osectname;
>      (*scnhead)->segment_nr = segment_nr;
>
>
>
>      if ((*scnhead)->type == 7)
> ++ld_state.nnotesections;
>
>      ld_state.allsections[ld_state.nallsections++] = (*scnhead);
>      return 1;
>    }
>
>
>
>  runp = (*scnhead)->last->next;
>  prevp = (*scnhead)->last;
>  notused = ((void *)0);
>
>  do
>    {
>
>      const char *brfname = basename (runp->fileinfo->rfname);
>
>
>
>
>      if (!runp->used
>   || (sectmask->filemask != ((void *)0)
>       && fnmatch (sectmask->filemask, brfname, 0) != 0)
>   || (sectmask->excludemask != ((void *)0)
>       && fnmatch (sectmask->excludemask, brfname, 0) == 0))
> {
>
>   if (notused == ((void *)0))
>     notused = runp;
>
>   prevp = runp;
>   runp = runp->next;
>   if (runp == notused)
>     runp = ((void *)0);
> }
>
>
>      else
> {
>   struct scninfo *found = runp;
>
>
>   if (prevp != runp)
>     runp = prevp->next = runp->next;
>   else
>     {
>       free (*scnhead);
>       *scnhead = ((void *)0);
>       runp = ((void *)0);
>     }
>
>
>
>
>   if (new_section)
>     {
>       struct scnhead *newp;
>
>       newp = (struct scnhead *) ({ size_t _s = (sizeof (*newp)); memset (__extension__ ({ struct obstack *__h = (&ld_state.smem); __extension__ ({ struct obstack *__o = (__h); int __len = ((_s)); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len)); (void) 0; }); __extension__ ({ struct obstack *__o1 = (__h); void *__value = (void *) __o1->object_base; if (__o1->next_free == __value) __o1->maybe_empty_object = 1; __o1->next_free = ((sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask))); if (__o1->next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit; __o1->object_base = __o1->next_free; __value; }); }), '\0', _s); });
>
>       newp->kind = scn_normal;
>       newp->name = osectname;
>       newp->type = (found->shdr).sh_type;
>
>
>       newp->flags = (found->shdr).sh_flags & ~(1 << 9);
>       newp->segment_nr = segment_nr;
>       newp->last = found->next = found;
>       newp->used = 1;
>       newp->relsize = found->relsize;
>       newp->entsize = (found->shdr).sh_entsize;
>
>
>
>       if (newp->type == 7)
>  ++ld_state.nnotesections;
>
>       ld_state.allsections[ld_state.nallsections++] = newp;
>       new_section = 0;
>     }
>   else
>     {
>       struct scnhead *queued;
>
>       queued = ld_state.allsections[ld_state.nallsections - 1];
>
>       found->next = queued->last->next;
>       queued->last = queued->last->next = found;
>
>
>
>
>       if (queued->type != (found->shdr).sh_type)
>
>  queued->type = 1;
>       if (queued->flags != (found->shdr).sh_flags)
>
>
>  queued->flags = ebl_sh_flags_combine (ld_state.ebl,
>            queued->flags,
>            (found->shdr).sh_flags
>            & ~(1 << 9));
>
>
>       queued->relsize += found->relsize;
>     }
> }
>    }
>  while (runp != ((void *)0));
>
>  return new_section;
>}
>
>
>static void
>sort_sections_lscript (void)
>{
>  struct scnhead *temp[ld_state.nallsections];
>
>
>  memcpy (temp, ld_state.allsections,
>   ld_state.nallsections * sizeof (temp[0]));
>  size_t nallsections = ld_state.nallsections;
>
>
>  struct output_segment *segment = ld_state.output_segments->next;
>  ld_state.output_segments->next = ((void *)0);
>  ld_state.output_segments = segment;
>
>
>
>
>  ld_state.nallsections = 0;
>  size_t segment_nr;
>  size_t last_writable = ~0ul;
>  for (segment_nr = 0; segment != ((void *)0); segment = segment->next, ++segment_nr)
>    {
>      struct output_rule *orule;
>
>      for (orule = segment->output_rules; orule != ((void *)0); orule = orule->next)
> if (orule->tag == output_section)
>   {
>     struct input_rule *irule;
>     _Bool new_section = 1;
>
>     for (irule = orule->val.section.input; irule != ((void *)0);
>   irule = irule->next)
>       if (irule->tag == input_section)
>  {
>    size_t cnt;
>
>    for (cnt = 0; cnt < nallsections; ++cnt)
>      if (temp[cnt] != ((void *)0))
>        new_section =
>   match_section (orule->val.section.name,
>           irule->val.section, &temp[cnt],
>           new_section, segment_nr);
>  }
>   }
>
>      if ((segment->mode & (1 << 1)) != 0)
> last_writable = ld_state.nallsections - 1;
>    }
>
>
>
>
>
>  if (ld_state.ncopy > 0 || ld_state.common_syms != ((void *)0))
>    {
>      if (last_writable == ~0ul)
> error (1, 0, "no writable segment");
>
>      if (ld_state.allsections[last_writable]->type != 8)
> {
>
>
>
>   ++last_writable;
>   memmove (&ld_state.allsections[last_writable + 1],
>     &ld_state.allsections[last_writable],
>     (ld_state.nallsections - last_writable)
>     * sizeof (ld_state.allsections[0]));
>
>   ld_state.allsections[last_writable] = (struct scnhead *)
>     ({ size_t _s = (sizeof (struct scnhead)); memset (__extension__ ({ struct obstack *__h = (&ld_state.smem); __extension__ ({ struct obstack *__o = (__h); int __len = ((_s)); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len)); (void) 0; }); __extension__ ({ struct obstack *__o1 = (__h); void *__value = (void *) __o1->object_base; if (__o1->next_free == __value) __o1->maybe_empty_object = 1; __o1->next_free = ((sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask))); if (__o1->next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit; __o1->object_base = __o1->next_free; __value; }); }), '\0', _s); });
>
>
>   ld_state.allsections[last_writable]->name = ".bss";
>
>   ld_state.allsections[last_writable]->type = 8;
>
>   ld_state.allsections[last_writable]->segment_nr
>     = ld_state.allsections[last_writable - 1]->segment_nr;
> }
>    }
>
>
>  if (ld_state.ncopy > 0)
>    {
>
>
>
>
>
>      struct scninfo *si = (struct scninfo *) ({ size_t _s = (sizeof (*si)); memset (__extension__ ({ struct obstack *__h = (&ld_state.smem); __extension__ ({ struct obstack *__o = (__h); int __len = ((_s)); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len)); (void) 0; }); __extension__ ({ struct obstack *__o1 = (__h); void *__value = (void *) __o1->object_base; if (__o1->next_free == __value) __o1->maybe_empty_object = 1; __o1->next_free = ((sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask))); if (__o1->next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit; __o1->object_base = __o1->next_free; __value; }); }), '\0', _s); });
>
>
>
>
>      compute_copy_reloc_offset (&(si->shdr));
>
>
>      si->used = 1;
>
>      ld_state.copy_section = si;
>
>      if (__builtin_expect (!!(ld_state.allsections[last_writable]->last != ((void *)0)), 1))
> {
>   si->next = ld_state.allsections[last_writable]->last->next;
>   ld_state.allsections[last_writable]->last->next = si;
>   ld_state.allsections[last_writable]->last = si;
> }
>      else
> ld_state.allsections[last_writable]->last = si->next = si;
>    }
>
>
>  if (ld_state.common_syms != ((void *)0))
>    {
>
>
>
>
>
>      struct scninfo *si = (struct scninfo *) ({ size_t _s = (sizeof (*si)); memset (__extension__ ({ struct obstack *__h = (&ld_state.smem); __extension__ ({ struct obstack *__o = (__h); int __len = ((_s)); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len)); (void) 0; }); __extension__ ({ struct obstack *__o1 = (__h); void *__value = (void *) __o1->object_base; if (__o1->next_free == __value) __o1->maybe_empty_object = 1; __o1->next_free = ((sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask))); if (__o1->next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit; __o1->object_base = __o1->next_free; __value; }); }), '\0', _s); });
>
>
>
>
>      compute_common_symbol_offset (&(si->shdr));
>
>
>      si->used = 1;
>
>      ld_state.common_section = si;
>
>      if (__builtin_expect (!!(ld_state.allsections[last_writable]->last != ((void *)0)), 1))
> {
>   si->next = ld_state.allsections[last_writable]->last->next;
>   ld_state.allsections[last_writable]->last->next = si;
>   ld_state.allsections[last_writable]->last = si;
> }
>      else
> ld_state.allsections[last_writable]->last = si->next = si;
>    }
>}
># 3122 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c"
>static void
>ld_generic_create_sections (struct ld_state *statep)
>{
>  struct scngroup *groups;
>  size_t cnt;
>
>
>
>
>  if (ld_state.file_type != relocatable_file_type)
>    {
>
>
>      struct scninfo *list = ((void *)0);
>      for (cnt = 0; cnt < ld_state.nallsections; ++cnt)
> if ((ld_state.allsections[cnt]->type == 9
>      || ld_state.allsections[cnt]->type == 4)
>
>
>     && ld_state.allsections[cnt]->last != ((void *)0))
>   {
>     if (list == ((void *)0))
>       list = ld_state.allsections[cnt]->last;
>     else
>       {
>
>  struct scninfo *first = list->next;
>  list->next = ld_state.allsections[cnt]->last->next;
>  ld_state.allsections[cnt]->last->next = first;
>  list = ld_state.allsections[cnt]->last;
>       }
>
>
>     ld_state.allsections[cnt] = ((void *)0);
>   }
>      ld_state.rellist = list;
>
>      if (ld_state.output_segments == ((void *)0))
>
> sort_sections_generic ();
>      else
> sort_sections_lscript ();
>    }
>
>
>
>  for (cnt = 0; cnt < ld_state.nallsections; ++cnt)
>    {
>      struct scnhead *head = ld_state.allsections[cnt];
>      Elf_Scn *scn;
>      GElf_Shdr shdr_mem; GElf_Shdr *shdr;
>
>
>      if (!head->used)
> continue;
>
>
>
>
>
>
>      if (ld_state.file_type == relocatable_file_type
>   && __builtin_expect (!!(head->flags & (1 << 9)), 0))
> {
># 3195 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c"
>   struct scninfo *runp;
>   Elf32_Word here_groupidx = 0;
>   struct scngroup *here_group;
>   struct member *newp;
>
>
>
>   runp = head->last;
>   do
>     {
>       ((runp->grpid != 0) ? (void) (0) : __assert_fail ("runp->grpid != 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3205, __PRETTY_FUNCTION__));
>
>       here_groupidx = runp->fileinfo->scninfo[runp->grpid].outscnndx;
>       if (here_groupidx != 0)
>  break;
>     }
>   while ((runp = runp->next) != head->last);
>
>   if (here_groupidx == 0)
>     {
>
>       scn = elf_newscn (ld_state.outelf);
>       shdr = gelf_getshdr (scn, &shdr_mem);
>       if (shdr == ((void *)0))
>  error (1, 0,
>         dcgettext (((void *)0), "cannot create section for output file: %s", __LC_MESSAGES),
>         elf_errmsg (-1));
>
>       here_group = (struct scngroup *) xmalloc (sizeof (*here_group));
>       here_group->outscnidx = here_groupidx = elf_ndxscn (scn);
>       here_group->nscns = 0;
>       here_group->member = ((void *)0);
>       here_group->next = ld_state.groups;
>
>
>
>
>
>
>       here_group->nameent
>  = ebl_strtabadd (ld_state.shstrtab,
>     elf_strptr (runp->fileinfo->elf,
>          runp->fileinfo->shstrndx,
>          (runp->shdr).sh_name),
>     0);
>
>       here_group->symbol
>  = runp->fileinfo->scninfo[runp->grpid].symbols;
>
>       ld_state.groups = here_group;
>     }
>   else
>     {
>
>       here_group = ld_state.groups;
>       while (here_group->outscnidx != here_groupidx)
>  here_group = here_group->next;
>     }
>
>
>   newp = (struct member *) __builtin_alloca (sizeof (*newp));
>   newp->scn = head;
>
>   newp->next = ((void *)0);
>
>   do { __typeof (newp) _newp = (newp); ((_newp->next == ((void *)0)) ? (void) (0) : __assert_fail ("_newp->next == ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3260, __PRETTY_FUNCTION__)); if (__builtin_expect (!!((here_group->member) == ((void *)0)), 0)) (here_group->member) = _newp->next = _newp; else { _newp->next = (here_group->member)->next; (here_group->member) = (here_group->member)->next = _newp; } } while (0);
>   ++here_group->nscns;
>
>
>   runp = head->last;
>   do
>     {
>       ((runp->grpid != 0) ? (void) (0) : __assert_fail ("runp->grpid != 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3267, __PRETTY_FUNCTION__));
>
>       if (runp->fileinfo->scninfo[runp->grpid].outscnndx == 0)
>  runp->fileinfo->scninfo[runp->grpid].outscnndx = here_groupidx;
>       else
>  ((runp->fileinfo->scninfo[runp->grpid].outscnndx == here_groupidx) ? (void) (0) : __assert_fail ("runp->fileinfo->scninfo[runp->grpid].outscnndx == here_groupidx", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3273, __PRETTY_FUNCTION__));
>
>     }
>   while ((runp = runp->next) != head->last);
> }
>
>
>
>      if (head->kind == scn_normal)
> head->nameent = ebl_strtabadd (ld_state.shstrtab, head->name, 0);
>
>
>
>      scn = elf_newscn (ld_state.outelf);
>      head->scnidx = elf_ndxscn (scn);
>      shdr = gelf_getshdr (scn, &shdr_mem);
>      if (shdr == ((void *)0))
> error (1, 0,
>        dcgettext (((void *)0), "cannot create section for output file: %s", __LC_MESSAGES),
>        elf_errmsg (-1));
>
>      ((head->type != 0) ? (void) (0) : __assert_fail ("head->type != 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3293, __PRETTY_FUNCTION__));
>      ((head->type != 2) ? (void) (0) : __assert_fail ("head->type != 2", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3294, __PRETTY_FUNCTION__));
>      ((head->type != 11 || head->kind != scn_normal) ? (void) (0) : __assert_fail ("head->type != 11 || head->kind != scn_normal", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3295, __PRETTY_FUNCTION__));
>      ((head->type != 3 || head->kind != scn_normal) ? (void) (0) : __assert_fail ("head->type != 3 || head->kind != scn_normal", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3296, __PRETTY_FUNCTION__));
>      ((head->type != 17) ? (void) (0) : __assert_fail ("head->type != 17", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3297, __PRETTY_FUNCTION__));
>      shdr->sh_type = head->type;
>      shdr->sh_flags = head->flags;
>      shdr->sh_addralign = head->align;
>      shdr->sh_entsize = head->entsize;
>      ((shdr->sh_entsize != 0 || (shdr->sh_flags & (1 << 4)) == 0) ? (void) (0) : __assert_fail ("shdr->sh_entsize != 0 || (shdr->sh_flags & (1 << 4)) == 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3302, __PRETTY_FUNCTION__));
>      (void) gelf_update_shdr (scn, shdr);
>
>
>
>      if (head->kind == scn_dot_dynsym)
> ld_state.dynsymscnidx = elf_ndxscn (scn);
>    }
>
>
>  groups = ld_state.groups;
>  while (groups != ((void *)0))
>    {
>      Elf_Scn *scn;
>      Elf_Data *data;
>      Elf32_Word *grpdata;
>      struct member *runp;
>
>      scn = elf_getscn (ld_state.outelf, groups->outscnidx);
>      ((scn != ((void *)0)) ? (void) (0) : __assert_fail ("scn != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3321, __PRETTY_FUNCTION__));
>
>      data = elf_newdata (scn);
>      if (data == ((void *)0))
> error (1, 0,
>        dcgettext (((void *)0), "cannot create section for output file: %s", __LC_MESSAGES),
>        elf_errmsg (-1));
>
>      data->d_size = (groups->nscns + 1) * sizeof (Elf32_Word);
>      data->d_buf = grpdata = (Elf32_Word *) xmalloc (data->d_size);
>      data->d_type = ELF_T_WORD;
>      data->d_version = 1;
>      data->d_off = 0;
>
>      data->d_align = sizeof (Elf32_Word);
>
>
>
>      grpdata[0] = 0;
>
>      runp = groups->member->next;
>      cnt = 1;
>      do
>
> grpdata[cnt++] = runp->scn->scnidx;
>      while ((runp = runp->next) != groups->member->next);
>
>      groups = groups->next;
>    }
>}
>
>
>static _Bool
>reduce_symbol_p (GElf_Sym *sym, struct Ebl_Strent *strent)
>{
>  const char *str;
>  const char *version;
>  struct id_list search;
>  struct id_list *verp;
>  _Bool result = ld_state.default_bind_local;
>
>  if ((((unsigned char) (sym->st_info)) >> 4) == 0 || sym->st_shndx == 0)
>
>
>
>    return 0;
>
>
>  (((((unsigned char) (sym->st_info)) >> 4) == 1 || (((unsigned char) (sym->st_info)) >> 4) == 2) ? (void) (0) : __assert_fail ("(((unsigned char) (sym->st_info)) >> 4) == 1 || (((unsigned char) (sym->st_info)) >> 4) == 2", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3370, __PRETTY_FUNCTION__));
>
>
>  str = ebl_string (strent);
>  version = (__extension__ (__builtin_constant_p ('@') && !__builtin_constant_p (str) && ('@') == '\0' ? (char *) __rawmemchr (str, '@') : __builtin_strchr (str, '@')));
>  if (version != ((void *)0))
>    {
>      search.id = (__extension__ ({ const char *__old = (str); size_t __len = strnlen (__old, (version - str)); char *__new = (char *) __builtin_alloca (__len + 1); __new[__len] = '\0'; (char *) memcpy (__new, __old, __len); }));
>      if (*++version == '@')
>
> ++version;
>    }
>  else
>    {
>      search.id = str;
>      version = "";
>    }
>
>  verp = ld_version_str_tab_find (&ld_state.version_str_tab,
>      elf_hash (search.id), &search);
>  while (verp != ((void *)0))
>    {
>
>
>      if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (verp->u.s.versionname) && __builtin_constant_p (version) && (__s1_len = strlen (verp->u.s.versionname), __s2_len = strlen (version), (!((size_t)(const void *)((verp->u.s.versionname) + 1) - (size_t)(const void *)(verp->u.s.versionname) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((version) + 1) - (size_t)(const void *)(version) == 1) || __s2_len >= 4)) ? __builtin_strcmp (verp->u.s.versionname, version) : (__builtin_constant_p (verp->u.s.versionname) && ((size_t)(const void *)((verp->u.s.versionname) + 1) - (size_t)(const void *)(verp->u.s.versionname) == 1) && (__s1_len = strlen (verp->u.s.versionname), __s1_len < 4) ? (__builtin_constant_p (version) && ((size_t)(const void *)((version) + 1) - (size_t)(const void *)(version) == 1) ? __builtin_strcmp (verp->u.s.versionname, version) : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (version); register int __result = (((const unsigned char *) (const char *) (verp->u.s.versionname))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (verp->u.s.versionname))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (verp->u.s.versionname))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (verp->u.s.versionname))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (version) && ((size_t)(const void *)((version) + 1) - (size_t)(const void *)(version) == 1) && (__s2_len = strlen (version), __s2_len < 4) ? (__builtin_constant_p (verp->u.s.versionname) && ((size_t)(const void *)((verp->u.s.versionname) + 1) - (size_t)(const void *)(verp->u.s.versionname) == 1) ? __builtin_strcmp (verp->u.s.versionname, version) : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (verp->u.s.versionname); register int __result = __s1[0] - ((const unsigned char *) (const char *) (version))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) (version))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) (version))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) (version))[3]); } } __result; }))) : __builtin_strcmp (verp->u.s.versionname, version)))); }) == 0)
>
> return verp->u.s.local;
>
>      verp = verp->next;
>    }
>
>
>
>  return result;
>}
>
>
>static GElf_Addr
>eval_expression (struct expression *expr, GElf_Addr addr)
>{
>  GElf_Addr val = ~((GElf_Addr) 0);
>
>  switch (expr->tag)
>    {
>    case exp_num:
>      val = expr->val.num;
>      break;
>
>    case exp_sizeof_headers:
>      {
>
>
> GElf_Shdr shdr_mem; GElf_Shdr *shdr;
>
> shdr = gelf_getshdr (elf_getscn (ld_state.outelf, 1), &shdr_mem);
> ((shdr != ((void *)0)) ? (void) (0) : __assert_fail ("shdr != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3424, __PRETTY_FUNCTION__));
>
> val = shdr->sh_offset;
>      }
>      break;
>
>    case exp_pagesize:
>      val = ld_state.pagesize;
>      break;
>
>    case exp_id:
>
>
>
>
>      if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (expr->val.str) && __builtin_constant_p (".") && (__s1_len = strlen (expr->val.str), __s2_len = strlen ("."), (!((size_t)(const void *)((expr->val.str) + 1) - (size_t)(const void *)(expr->val.str) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((".") + 1) - (size_t)(const void *)(".") == 1) || __s2_len >= 4)) ? __builtin_strcmp (expr->val.str, ".") : (__builtin_constant_p (expr->val.str) && ((size_t)(const void *)((expr->val.str) + 1) - (size_t)(const void *)(expr->val.str) == 1) && (__s1_len = strlen (expr->val.str), __s1_len < 4) ? (__builtin_constant_p (".") && ((size_t)(const void *)((".") + 1) - (size_t)(const void *)(".") == 1) ? __builtin_strcmp (expr->val.str, ".") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("."); register int __result = (((const unsigned char *) (const char *) (expr->val.str))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (expr->val.str))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (expr->val.str))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (expr->val.str))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (".") && ((size_t)(const void *)((".") + 1) - (size_t)(const void *)(".") == 1) && (__s2_len = strlen ("."), __s2_len < 4) ? (__builtin_constant_p (expr->val.str) && ((size_t)(const void *)((expr->val.str) + 1) - (size_t)(const void *)(expr->val.str) == 1) ? __builtin_strcmp (expr->val.str, ".") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (expr->val.str); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("."))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("."))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("."))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("."))[3]); } } __result; }))) : __builtin_strcmp (expr->val.str, ".")))); }) != 0)
> error (1, 0, dcgettext (((void *)0), "address computation expression contains variable '%s'", __LC_MESSAGES),
>
>        expr->val.str);
>
>      val = addr;
>      break;
>
>    case exp_mult:
>      val = (eval_expression (expr->val.binary.left, addr)
>      * eval_expression (expr->val.binary.right, addr));
>      break;
>
>    case exp_div:
>      val = (eval_expression (expr->val.binary.left, addr)
>      / eval_expression (expr->val.binary.right, addr));
>      break;
>
>    case exp_mod:
>      val = (eval_expression (expr->val.binary.left, addr)
>      % eval_expression (expr->val.binary.right, addr));
>      break;
>
>    case exp_plus:
>      val = (eval_expression (expr->val.binary.left, addr)
>      + eval_expression (expr->val.binary.right, addr));
>      break;
>
>    case exp_minus:
>      val = (eval_expression (expr->val.binary.left, addr)
>      - eval_expression (expr->val.binary.right, addr));
>      break;
>
>    case exp_and:
>      val = (eval_expression (expr->val.binary.left, addr)
>      & eval_expression (expr->val.binary.right, addr));
>      break;
>
>    case exp_or:
>      val = (eval_expression (expr->val.binary.left, addr)
>      | eval_expression (expr->val.binary.right, addr));
>      break;
>
>    case exp_align:
>      val = eval_expression (expr->val.child, addr);
>      if ((val & (val - 1)) != 0)
> error (1, 0, dcgettext (((void *)0), "argument '%" "ll" "u" "' of ALIGN in address computation expression is no power of two", __LC_MESSAGES),
>        (uintmax_t) val);
>      val = (addr + val - 1) & ~(val - 1);
>      break;
>    }
>
>  return val;
>}
>
>
>
>
>
>
>
>static size_t
>optimal_bucket_size (Elf32_Word *hashcodes, size_t maxcnt, int optlevel)
>{
>  size_t minsize;
>  size_t maxsize;
>  size_t bestsize;
>  uint64_t bestcost;
>  size_t size;
>  uint32_t *counts;
>  uint32_t *lengths;
>
>  if (maxcnt == 0)
>    return 0;
>
>
>  if (optlevel <= 0)
>    {
>      minsize = maxcnt;
>      maxsize = maxcnt + 10000 / maxcnt;
>    }
>  else
>    {
>
>
>      minsize = (((1)>(maxcnt / 4))?(1):(maxcnt / 4));
>
>
>      maxsize = 2 * maxcnt + (6 * (((optlevel)<(100))?(optlevel):(100)) * maxcnt) / 100;
>    }
>  bestsize = maxcnt;
>  bestcost = (2147483647 * 2U + 1U);
>
>
>  counts = (uint32_t *) xmalloc ((maxcnt + 1 + maxsize) * sizeof (uint32_t));
>  lengths = &counts[maxcnt + 1];
>
>  for (size = minsize; size <= maxsize; ++size)
>    {
>      size_t inner;
>      uint64_t cost;
>      uint32_t maxlength;
>      uint64_t success;
>      uint32_t acc;
>      double factor;
>
>      memset (lengths, '\0', size * sizeof (uint32_t));
>      memset (counts, '\0', (maxcnt + 1) * sizeof (uint32_t));
>
>
>      ((hashcodes[0] == 0) ? (void) (0) : __assert_fail ("hashcodes[0] == 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3549, __PRETTY_FUNCTION__));
>      for (inner = 1; inner < maxcnt; ++inner)
> ++lengths[hashcodes[inner] % size];
>
>
>      maxlength = 0;
>      for (inner = 0; inner < size; ++inner)
> {
>   ++counts[lengths[inner]];
>
>   if (lengths[inner] > maxlength)
>     maxlength = lengths[inner];
> }
>
>
>      acc = 0;
>      success = 0;
>      for (inner = 0; inner <= maxlength; ++inner)
> {
>   acc += inner;
>   success += counts[inner] * acc;
> }
># 3581 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c"
>      if (ld_state.is_system_library)
> factor = (1.0 * (double) success / (double) maxcnt
>    + 0.3 * (double) maxcnt / (double) size);
>      else
> factor = (0.3 * (double) success / (double) maxcnt
>    + 1.0 * (double) maxcnt / (double) size);
>
>
>
>      cost = (2 + maxcnt + size) * (factor + 1.0 / 16.0);
>
>
>
>
>
>
>
>      if (cost < bestcost)
> {
>   bestcost = cost;
>   bestsize = size;
> }
>    }
>
>  free (counts);
>
>  return bestsize;
>}
>
>
>static void
>optimal_gnu_hash_size (Elf32_Word *hashcodes, size_t maxcnt, int optlevel,
>         size_t *bitmask_nwords, size_t *shift, size_t *nbuckets)
>{
>
>  *bitmask_nwords = 256;
>  *shift = 6;
>  *nbuckets = 3 * maxcnt / 2;
>}
>
>
>static GElf_Addr
>find_entry_point (void)
>{
>  GElf_Addr result;
>
>  if (ld_state.entry != ((void *)0))
>    {
>      struct symbol search = { .name = ld_state.entry };
>      struct symbol *syment;
>
>      syment = ld_symbol_tab_find (&ld_state.symbol_tab,
>       elf_hash (ld_state.entry), &search);
>      if (syment != ((void *)0) && syment->defined)
> {
>
>   Elf_Data *data = elf_getdata (elf_getscn (ld_state.outelf,
>          ld_state.symscnidx), ((void *)0));
>
>   GElf_Sym sym_mem; GElf_Sym *sym;
>
>   sym = ((void *)0);
>   if (data != ((void *)0))
>     sym = gelf_getsym (data, ld_state.dblindirect[syment->outsymidx], &sym_mem);
>
>   if (sym == ((void *)0) && ld_state.need_dynsym && syment->outdynsymidx != 0)
>     {
>
>       data = elf_getdata (elf_getscn (ld_state.outelf,
>           ld_state.dynsymscnidx), ((void *)0));
>
>       sym = ((void *)0);
>       if (data != ((void *)0))
>  sym = gelf_getsym (data, syment->outdynsymidx, &sym_mem);
>     }
>
>   if (sym != ((void *)0))
>     return sym->st_value;
>
>
>
>
>   ((ld_state.need_symtab) ? (void) (0) : __assert_fail ("ld_state.need_symtab", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3663, __PRETTY_FUNCTION__));
>   ((ld_state.symscnidx != 0) ? (void) (0) : __assert_fail ("ld_state.symscnidx != 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3664, __PRETTY_FUNCTION__));
> }
>    }
>
>
>
>
>
>  result = 0;
>
>
>
>
>  if (ld_state.file_type == executable_file_type)
>    {
>      if (ld_state.entry != ((void *)0))
> error (0, 0, dcgettext (((void *)0), "cannot find entry symbol '%s': defaulting to %#0*" "ll" "x", __LC_MESSAGES),
>
>        ld_state.entry,
>        gelf_getclass (ld_state.outelf) == 1 ? 10 : 18,
>        (uint64_t) result);
>      else
> error (0, 0, dcgettext (((void *)0), "no entry symbol specified: defaulting to %#0*" "ll" "x", __LC_MESSAGES),
>
>        gelf_getclass (ld_state.outelf) == 1 ? 10 : 18,
>        (uint64_t) result);
>    }
>
>  return result;
>}
>
>
>static void
>fillin_special_symbol (struct symbol *symst, size_t scnidx, size_t nsym,
>         Elf_Data *symdata, struct Ebl_Strtab *strtab)
>{
>  ((ld_state.file_type != relocatable_file_type) ? (void) (0) : __assert_fail ("ld_state.file_type != relocatable_file_type", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3700, __PRETTY_FUNCTION__));
>
>  GElf_Sym sym_mem; GElf_Sym *sym;
>  sym = &sym_mem;
>
>
>  sym->st_name = 0;
>
>  sym->st_info = ((((symst->local ? 0 : 1)) << 4) + (((symst->type)) & 0xf));
>
>  sym->st_other = symst->hidden ? 2 : 0;
>
>
>
>  ((scnidx != 0) ? (void) (0) : __assert_fail ("scnidx != 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3714, __PRETTY_FUNCTION__));
>  ((scnidx < 0xff00 || scnidx == 0xfff1) ? (void) (0) : __assert_fail ("scnidx < 0xff00 || scnidx == 0xfff1", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3715, __PRETTY_FUNCTION__));
>  sym->st_shndx = scnidx;
>
>  sym->st_value = 0;
>
>  sym->st_size = 0;
>
>
>  if (scnidx != 0xfff1)
>    {
>      Elf_Data *data = elf_getdata (elf_getscn (ld_state.outelf, scnidx),
>        ((void *)0));
>      ((data != ((void *)0)) ? (void) (0) : __assert_fail ("data != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3727, __PRETTY_FUNCTION__));
>      sym->st_size = data->d_size;
>
>      ((elf_getdata (elf_getscn (ld_state.outelf, scnidx), data) == ((void *)0)) ? (void) (0) : __assert_fail ("elf_getdata (elf_getscn (ld_state.outelf, scnidx), data) == ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3731, __PRETTY_FUNCTION__));
>
>    }
>
>
>
>  (void) gelf_update_sym (symdata, nsym, sym);
>
>
>  ndxtosym[nsym] = symst;
>  symst->outsymidx = nsym;
>
>
>  symstrent[nsym] = ebl_strtabadd (strtab, symst->name, 0);
>}
>
>
>static void
>new_dynamic_entry (Elf_Data *data, int idx, GElf_Sxword tag, GElf_Addr val)
>{
>  GElf_Dyn dyn_mem; GElf_Dyn *dyn;
>  dyn = &dyn_mem;
>  dyn->d_tag = tag;
>  dyn->d_un.d_ptr = val;
>  (void) gelf_update_dyn (data, idx, dyn);
>}
>
>
>static void
>allocate_version_names (struct usedfiles *runp, struct Ebl_Strtab *dynstrtab)
>{
>
>  if (runp->status != opened || runp->verdefdata == ((void *)0))
>    return;
>
>
>  int offset = 0;
>  while (1)
>    {
>      GElf_Verdef def_mem; GElf_Verdef *def;
>      GElf_Verdaux aux_mem; GElf_Verdaux *aux;
>
>
>      def = gelf_getverdef (runp->verdefdata, offset, &def_mem);
>      ((def != ((void *)0)) ? (void) (0) : __assert_fail ("def != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3774, __PRETTY_FUNCTION__));
>      aux = gelf_getverdaux (runp->verdefdata, offset + def->vd_aux, &aux_mem);
>      ((aux != ((void *)0)) ? (void) (0) : __assert_fail ("aux != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3776, __PRETTY_FUNCTION__));
>
>      ((def->vd_ndx <= runp->nverdef) ? (void) (0) : __assert_fail ("def->vd_ndx <= runp->nverdef", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3778, __PRETTY_FUNCTION__));
>      if (def->vd_ndx == 1 || runp->verdefused[def->vd_ndx] != 0)
> {
>   runp->verdefent[def->vd_ndx]
>     = ebl_strtabadd (dynstrtab, elf_strptr (runp->elf,
>          runp->dynsymstridx,
>          aux->vda_name), 0);
>
>   if (def->vd_ndx > 1)
>     runp->verdefused[def->vd_ndx] = ld_state.nextveridx++;
> }
>
>      if (def->vd_next == 0)
>
> break;
>
>      offset += def->vd_next;
>    }
>}
>
>
>static GElf_Off
>create_verneed_data (GElf_Off offset, Elf_Data *verneeddata,
>       struct usedfiles *runp, int *ntotal)
>{
>  size_t verneed_size = gelf_fsize (ld_state.outelf, ELF_T_VNEED, 1, 1);
>  size_t vernaux_size = gelf_fsize (ld_state.outelf, ELF_T_VNAUX, 1, 1);
>  int need_offset;
>  _Bool filled = 0;
>  GElf_Verneed verneed;
>  GElf_Vernaux vernaux;
>  int ndef = 0;
>  size_t cnt;
>
>
>  if (runp->nverdefused == 0)
>    return offset;
>
>
>  need_offset = offset;
>  offset += verneed_size;
>
>  for (cnt = 2; cnt <= runp->nverdef; ++cnt)
>    if (runp->verdefused[cnt] != 0)
>      {
> ((runp->verdefent[cnt] != ((void *)0)) ? (void) (0) : __assert_fail ("runp->verdefent[cnt] != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3823, __PRETTY_FUNCTION__));
>
> if (filled)
>   {
>     vernaux.vna_next = vernaux_size;
>     (void) gelf_update_vernaux (verneeddata, offset, &vernaux);
>     offset += vernaux_size;
>   }
>
> vernaux.vna_hash = elf_hash (ebl_string (runp->verdefent[cnt]));
> vernaux.vna_flags = 0;
> vernaux.vna_other = runp->verdefused[cnt];
> vernaux.vna_name = ebl_strtaboffset (runp->verdefent[cnt]);
> filled = 1;
> ++ndef;
>      }
>
>  ((filled) ? (void) (0) : __assert_fail ("filled", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3840, __PRETTY_FUNCTION__));
>  vernaux.vna_next = 0;
>  (void) gelf_update_vernaux (verneeddata, offset, &vernaux);
>  offset += vernaux_size;
>
>  verneed.vn_version = 1;
>  verneed.vn_cnt = ndef;
>  verneed.vn_file = ebl_strtaboffset (runp->verdefent[1]);
>
>
>  verneed.vn_aux = verneed_size;
>  verneed.vn_next = --*ntotal > 0 ? offset - need_offset : 0;
>  (void) gelf_update_verneed (verneeddata, need_offset, &verneed);
>
>  return offset;
>}
>
>
>
>static Elf32_Word *global_hashcodes;
>static size_t global_nbuckets;
>static int
>sortfct_hashval (const void *p1, const void *p2)
>{
>  size_t idx1 = *(size_t *) p1;
>  size_t idx2 = *(size_t *) p2;
>
>  int def1 = ndxtosym[idx1]->defined && !ndxtosym[idx1]->in_dso;
>  int def2 = ndxtosym[idx2]->defined && !ndxtosym[idx2]->in_dso;
>
>  if (! def1 && def2)
>    return -1;
>  if (def1 && !def2)
>    return 1;
>  if (! def1)
>    return 0;
>
>  Elf32_Word hval1 = (global_hashcodes[ndxtosym[idx1]->outdynsymidx]
>        % global_nbuckets);
>  Elf32_Word hval2 = (global_hashcodes[ndxtosym[idx2]->outdynsymidx]
>        % global_nbuckets);
>
>  if (hval1 < hval2)
>    return -1;
>  if (hval1 > hval2)
>    return 1;
>  return 0;
>}
>
>
>
>
>
>
>
>static void
>create_gnu_hash (size_t nsym_local, size_t nsym, size_t nsym_dyn,
>   Elf32_Word *gnuhashcodes)
>{
>  size_t gnu_bitmask_nwords = 0;
>  size_t gnu_shift = 0;
>  size_t gnu_nbuckets = 0;
>  Elf32_Word *gnu_bitmask = ((void *)0);
>  Elf32_Word *gnu_buckets = ((void *)0);
>  Elf32_Word *gnu_chain = ((void *)0);
>  GElf_Shdr shdr_mem; GElf_Shdr *shdr;
>
>
>  optimal_gnu_hash_size (gnuhashcodes, nsym_dyn, ld_state.optlevel,
>    &gnu_bitmask_nwords, &gnu_shift, &gnu_nbuckets);
>
>
>  Elf_Scn *hashscn = elf_getscn (ld_state.outelf, ld_state.gnuhashscnidx);
>  shdr = gelf_getshdr (hashscn, &shdr_mem);
>  Elf_Data *hashdata = elf_newdata (hashscn);
>  if (shdr == ((void *)0) || hashdata == ((void *)0))
>    error (1, 0, dcgettext (((void *)0), "cannot create GNU hash table section for output file: %s", __LC_MESSAGES),
>
>    elf_errmsg (-1));
>
>  shdr->sh_link = ld_state.dynsymscnidx;
>  (void) gelf_update_shdr (hashscn, shdr);
>
>  hashdata->d_size = (gelf_fsize (ld_state.outelf, ELF_T_ADDR, gnu_bitmask_nwords, 1)
>
>        + (4 + gnu_nbuckets + nsym_dyn) * sizeof (Elf32_Word));
>  hashdata->d_buf = xcalloc (1, hashdata->d_size);
>  hashdata->d_align = sizeof (Elf32_Word);
>  hashdata->d_type = ELF_T_WORD;
>  hashdata->d_off = 0;
>
>  ((Elf32_Word *) hashdata->d_buf)[0] = gnu_nbuckets;
>  ((Elf32_Word *) hashdata->d_buf)[2] = gnu_bitmask_nwords;
>  ((Elf32_Word *) hashdata->d_buf)[3] = gnu_shift;
>  gnu_bitmask = &((Elf32_Word *) hashdata->d_buf)[4];
>  gnu_buckets = &gnu_bitmask[gelf_fsize (ld_state.outelf, ELF_T_ADDR, gnu_bitmask_nwords, 1)
>
>        / sizeof (*gnu_buckets)];
>  gnu_chain = &gnu_buckets[gnu_nbuckets];
>
>  void *endp = &gnu_chain[nsym_dyn];
>
>  ((endp == (void *) ((char *) hashdata->d_buf + hashdata->d_size)) ? (void) (0) : __assert_fail ("endp == (void *) ((char *) hashdata->d_buf + hashdata->d_size)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3942, __PRETTY_FUNCTION__));
>
>
>  size_t *remap = xmalloc (nsym_dyn * sizeof (size_t));
>
>  size_t nsym_dyn_cnt = 1;
>
>  for (size_t cnt = nsym_local; cnt < nsym; ++cnt)
>    if (symstrent[cnt] != ((void *)0))
>      {
> ((ndxtosym[cnt]->outdynsymidx > 0) ? (void) (0) : __assert_fail ("ndxtosym[cnt]->outdynsymidx > 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3952, __PRETTY_FUNCTION__));
> ((ndxtosym[cnt]->outdynsymidx < nsym_dyn) ? (void) (0) : __assert_fail ("ndxtosym[cnt]->outdynsymidx < nsym_dyn", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3953, __PRETTY_FUNCTION__));
> remap[ndxtosym[cnt]->outdynsymidx] = cnt;
>
> ++nsym_dyn_cnt;
>
>      }
>  ((nsym_dyn_cnt == nsym_dyn) ? (void) (0) : __assert_fail ("nsym_dyn_cnt == nsym_dyn", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3959, __PRETTY_FUNCTION__));
>
>
>  global_hashcodes = gnuhashcodes;
>  global_nbuckets = gnu_nbuckets;
>  qsort (remap + 1, nsym_dyn - 1, sizeof (size_t), sortfct_hashval);
>
>  _Bool bm32 = (gelf_fsize (ld_state.outelf, ELF_T_ADDR, 1, 1)
>        == sizeof (Elf32_Word));
>
>  size_t first_defined = 0;
>  Elf64_Word bitmask_idxbits = gnu_bitmask_nwords - 1;
>  Elf32_Word last_bucket = 0;
>  for (size_t cnt = 1; cnt < nsym_dyn; ++cnt)
>    {
>      if (first_defined == 0)
> {
>   if (! ndxtosym[remap[cnt]]->defined
>       || ndxtosym[remap[cnt]]->in_dso)
>     goto next;
>
>   ((Elf32_Word *) hashdata->d_buf)[1] = first_defined = cnt;
> }
>
>      Elf32_Word hval = gnuhashcodes[ndxtosym[remap[cnt]]->outdynsymidx];
>
>      if (bm32)
> {
>   Elf32_Word *bsw = &gnu_bitmask[(hval / 32) & bitmask_idxbits];
>   (((void *) gnu_bitmask <= (void *) bsw) ? (void) (0) : __assert_fail ("(void *) gnu_bitmask <= (void *) bsw", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3988, __PRETTY_FUNCTION__));
>   (((void *) bsw < (void *) gnu_buckets) ? (void) (0) : __assert_fail ("(void *) bsw < (void *) gnu_buckets", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3989, __PRETTY_FUNCTION__));
>   *bsw |= 1 << (hval & 31);
>   *bsw |= 1 << ((hval >> gnu_shift) & 31);
> }
>      else
> {
>   Elf64_Word *bsw = &((Elf64_Word *) gnu_bitmask)[(hval / 64)
>         & bitmask_idxbits];
>   (((void *) gnu_bitmask <= (void *) bsw) ? (void) (0) : __assert_fail ("(void *) gnu_bitmask <= (void *) bsw", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3997, __PRETTY_FUNCTION__));
>   (((void *) bsw < (void *) gnu_buckets) ? (void) (0) : __assert_fail ("(void *) bsw < (void *) gnu_buckets", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 3998, __PRETTY_FUNCTION__));
>   *bsw |= 1 << (hval & 63);
>   *bsw |= 1 << ((hval >> gnu_shift) & 63);
> }
>
>      size_t this_bucket = hval % gnu_nbuckets;
>      if (cnt == first_defined || this_bucket != last_bucket)
> {
>   if (cnt != first_defined)
>     {
>
>       (((void *) &gnu_chain[cnt - first_defined - 1] < endp) ? (void) (0) : __assert_fail ("(void *) &gnu_chain[cnt - first_defined - 1] < endp", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 4009, __PRETTY_FUNCTION__));
>       gnu_chain[cnt - first_defined - 1] |= 1;
>     }
>
>   ((this_bucket < gnu_nbuckets) ? (void) (0) : __assert_fail ("this_bucket < gnu_nbuckets", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 4013, __PRETTY_FUNCTION__));
>   gnu_buckets[this_bucket] = cnt;
>   last_bucket = this_bucket;
> }
>
>      ((cnt >= first_defined) ? (void) (0) : __assert_fail ("cnt >= first_defined", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 4018, __PRETTY_FUNCTION__));
>      ((cnt - first_defined < nsym_dyn) ? (void) (0) : __assert_fail ("cnt - first_defined < nsym_dyn", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 4019, __PRETTY_FUNCTION__));
>      gnu_chain[cnt - first_defined] = hval & ~1u;
>
>    next:
>      ndxtosym[remap[cnt]]->outdynsymidx = cnt;
>    }
>
>
>  if (first_defined != 0)
>    {
>      ((nsym_dyn > first_defined) ? (void) (0) : __assert_fail ("nsym_dyn > first_defined", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 4029, __PRETTY_FUNCTION__));
>      ((nsym_dyn - first_defined - 1 < nsym_dyn) ? (void) (0) : __assert_fail ("nsym_dyn - first_defined - 1 < nsym_dyn", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 4030, __PRETTY_FUNCTION__));
>      gnu_chain[nsym_dyn - first_defined - 1] |= 1;
>
>      hashdata->d_size -= first_defined * sizeof (Elf32_Word);
>    }
>  else
>
>
>    do { } while (0);
>
>  free (remap);
>}
>
>
>
>static void
>create_hash (size_t nsym_local, size_t nsym, size_t nsym_dyn,
>      Elf32_Word *hashcodes)
>{
>  size_t nbucket = 0;
>  Elf32_Word *bucket = ((void *)0);
>  Elf32_Word *chain = ((void *)0);
>  GElf_Shdr shdr_mem; GElf_Shdr *shdr;
>
>
>
>
>
>  if (((ld_state.hash_style & hash_style_gnu) != 0))
>    nbucket = 1;
>  else
>    nbucket = optimal_bucket_size (hashcodes, nsym_dyn, ld_state.optlevel);
>
>  Elf_Scn *hashscn = elf_getscn (ld_state.outelf, ld_state.hashscnidx);
>  shdr = gelf_getshdr (hashscn, &shdr_mem);
>  Elf_Data *hashdata = elf_newdata (hashscn);
>  if (shdr == ((void *)0) || hashdata == ((void *)0))
>    error (1, 0, dcgettext (((void *)0), "cannot create hash table section for output file: %s", __LC_MESSAGES),
>
>    elf_errmsg (-1));
>
>  shdr->sh_link = ld_state.dynsymscnidx;
>  (void) gelf_update_shdr (hashscn, shdr);
>
>  hashdata->d_size = (2 + nsym_dyn + nbucket) * sizeof (Elf32_Word);
>  hashdata->d_buf = xcalloc (1, hashdata->d_size);
>  hashdata->d_align = sizeof (Elf32_Word);
>  hashdata->d_type = ELF_T_WORD;
>  hashdata->d_off = 0;
>
>  ((Elf32_Word *) hashdata->d_buf)[0] = nbucket;
>  ((Elf32_Word *) hashdata->d_buf)[1] = nsym_dyn;
>  bucket = &((Elf32_Word *) hashdata->d_buf)[2];
>  chain = &((Elf32_Word *) hashdata->d_buf)[2 + nbucket];
>
>  for (size_t cnt = nsym_local; cnt < nsym; ++cnt)
>    if (symstrent[cnt] != ((void *)0))
>      {
> size_t dynidx = ndxtosym[cnt]->outdynsymidx;
> size_t hashidx = hashcodes[dynidx] % nbucket;
> if (bucket[hashidx] == 0)
>   bucket[hashidx] = dynidx;
> else
>   {
>     hashidx = bucket[hashidx];
>     while (chain[hashidx] != 0)
>       hashidx = chain[hashidx];
>
>     chain[hashidx] = dynidx;
>   }
>      }
>}
>
>
>static void
>create_build_id_section (Elf_Scn *scn)
>{
>
>  Elf_Data *d = elf_newdata (scn);
>  if (d == ((void *)0))
>    error (1, 0, dcgettext (((void *)0), "cannot create build ID section: %s", __LC_MESSAGES),
>    elf_errmsg (-1));
>
>  d->d_type = ELF_T_BYTE;
>  d->d_version = 1;
>
>
>  ((sizeof (Elf32_Nhdr) == sizeof (Elf64_Nhdr)) ? (void) (0) : __assert_fail ("sizeof (Elf32_Nhdr) == sizeof (Elf64_Nhdr)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 4117, __PRETTY_FUNCTION__));
>  d->d_size = sizeof (GElf_Nhdr);
>
>  d->d_size += sizeof ("GNU");
>  ((d->d_size % 4 == 0) ? (void) (0) : __assert_fail ("d->d_size % 4 == 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 4121, __PRETTY_FUNCTION__));
>
>  if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (ld_state.build_id) && __builtin_constant_p ("md5") && (__s1_len = strlen (ld_state.build_id), __s2_len = strlen ("md5"), (!((size_t)(const void *)((ld_state.build_id) + 1) - (size_t)(const void *)(ld_state.build_id) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("md5") + 1) - (size_t)(const void *)("md5") == 1) || __s2_len >= 4)) ? __builtin_strcmp (ld_state.build_id, "md5") : (__builtin_constant_p (ld_state.build_id) && ((size_t)(const void *)((ld_state.build_id) + 1) - (size_t)(const void *)(ld_state.build_id) == 1) && (__s1_len = strlen (ld_state.build_id), __s1_len < 4) ? (__builtin_constant_p ("md5") && ((size_t)(const void *)(("md5") + 1) - (size_t)(const void *)("md5") == 1) ? __builtin_strcmp (ld_state.build_id, "md5") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("md5"); register int __result = (((const unsigned char *) (const char *) (ld_state.build_id))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (ld_state.build_id))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (ld_state.build_id))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (ld_state.build_id))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("md5") && ((size_t)(const void *)(("md5") + 1) - (size_t)(const void *)("md5") == 1) && (__s2_len = strlen ("md5"), __s2_len < 4) ? (__builtin_constant_p (ld_state.build_id) && ((size_t)(const void *)((ld_state.build_id) + 1) - (size_t)(const void *)(ld_state.build_id) == 1) ? __builtin_strcmp (ld_state.build_id, "md5") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (ld_state.build_id); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("md5"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("md5"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("md5"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("md5"))[3]); } } __result; }))) : __builtin_strcmp (ld_state.build_id, "md5")))); }) == 0
>      || __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (ld_state.build_id) && __builtin_constant_p ("uuid") && (__s1_len = strlen (ld_state.build_id), __s2_len = strlen ("uuid"), (!((size_t)(const void *)((ld_state.build_id) + 1) - (size_t)(const void *)(ld_state.build_id) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("uuid") + 1) - (size_t)(const void *)("uuid") == 1) || __s2_len >= 4)) ? __builtin_strcmp (ld_state.build_id, "uuid") : (__builtin_constant_p (ld_state.build_id) && ((size_t)(const void *)((ld_state.build_id) + 1) - (size_t)(const void *)(ld_state.build_id) == 1) && (__s1_len = strlen (ld_state.build_id), __s1_len < 4) ? (__builtin_constant_p ("uuid") && ((size_t)(const void *)(("uuid") + 1) - (size_t)(const void *)("uuid") == 1) ? __builtin_strcmp (ld_state.build_id, "uuid") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("uuid"); register int __result = (((const unsigned char *) (const char *) (ld_state.build_id))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (ld_state.build_id))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (ld_state.build_id))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (ld_state.build_id))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("uuid") && ((size_t)(const void *)(("uuid") + 1) - (size_t)(const void *)("uuid") == 1) && (__s2_len = strlen ("uuid"), __s2_len < 4) ? (__builtin_constant_p (ld_state.build_id) && ((size_t)(const void *)((ld_state.build_id) + 1) - (size_t)(const void *)(ld_state.build_id) == 1) ? __builtin_strcmp (ld_state.build_id, "uuid") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (ld_state.build_id); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("uuid"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("uuid"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("uuid"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("uuid"))[3]); } } __result; }))) : __builtin_strcmp (ld_state.build_id, "uuid")))); }) == 0)
>    d->d_size += 16;
>  else if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (ld_state.build_id) && __builtin_constant_p ("sha1") && (__s1_len = strlen (ld_state.build_id), __s2_len = strlen ("sha1"), (!((size_t)(const void *)((ld_state.build_id) + 1) - (size_t)(const void *)(ld_state.build_id) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("sha1") + 1) - (size_t)(const void *)("sha1") == 1) || __s2_len >= 4)) ? __builtin_strcmp (ld_state.build_id, "sha1") : (__builtin_constant_p (ld_state.build_id) && ((size_t)(const void *)((ld_state.build_id) + 1) - (size_t)(const void *)(ld_state.build_id) == 1) && (__s1_len = strlen (ld_state.build_id), __s1_len < 4) ? (__builtin_constant_p ("sha1") && ((size_t)(const void *)(("sha1") + 1) - (size_t)(const void *)("sha1") == 1) ? __builtin_strcmp (ld_state.build_id, "sha1") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("sha1"); register int __result = (((const unsigned char *) (const char *) (ld_state.build_id))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (ld_state.build_id))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (ld_state.build_id))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (ld_state.build_id))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("sha1") && ((size_t)(const void *)(("sha1") + 1) - (size_t)(const void *)("sha1") == 1) && (__s2_len = strlen ("sha1"), __s2_len < 4) ? (__builtin_constant_p (ld_state.build_id) && ((size_t)(const void *)((ld_state.build_id) + 1) - (size_t)(const void *)(ld_state.build_id) == 1) ? __builtin_strcmp (ld_state.build_id, "sha1") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (ld_state.build_id); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("sha1"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("sha1"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("sha1"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("sha1"))[3]); } } __result; }))) : __builtin_strcmp (ld_state.build_id, "sha1")))); }) == 0)
>    d->d_size += 20;
>  else
>    {
>      ((ld_state.build_id[0] == '0' && ld_state.build_id[1] == 'x') ? (void) (0) : __assert_fail ("ld_state.build_id[0] == '0' && ld_state.build_id[1] == 'x'", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 4130, __PRETTY_FUNCTION__));
>
>
>      d->d_size += strlen (ld_state.build_id) / 2;
>    }
>
>  d->d_buf = xcalloc (d->d_size, 1);
>  d->d_off = 0;
>  d->d_align = 0;
>}
>
>
>static void
>compute_hash_sum (void (*hashfct) (const void *, size_t, void *), void *ctx)
>{
>
>  size_t shstrndx;
>  (void) elf_getshstrndx (ld_state.outelf, &shstrndx);
>
>  const char *ident = elf_getident (ld_state.outelf, ((void *)0));
>  _Bool same_byte_order = ((ident[5] == 1
>      && 4321 == 1234)
>     || (ident[5] == 2
>         && 4321 == 4321));
>
>
>  Elf_Scn *scn = ((void *)0);
>  while ((scn = elf_nextscn (ld_state.outelf, scn)) != ((void *)0))
>    {
>
>      GElf_Shdr shdr_mem;
>      GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
>      ((shdr != ((void *)0)) ? (void) (0) : __assert_fail ("shdr != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 4162, __PRETTY_FUNCTION__));
>
>      if ((((shdr)->sh_flags & (1 << 1)) == 0 && (shdr)->sh_type != 7 && (((shdr)->sh_type) != 1 || ((__extension__ (__builtin_constant_p (sizeof ".gnu.warning." - 1) && ((__builtin_constant_p (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)) && strlen (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)) < ((size_t) (sizeof ".gnu.warning." - 1))) || (__builtin_constant_p (".gnu.warning.") && strlen (".gnu.warning.") < ((size_t) (sizeof ".gnu.warning." - 1)))) ? __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)) && __builtin_constant_p (".gnu.warning.") && (__s1_len = strlen (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)), __s2_len = strlen (".gnu.warning."), (!((size_t)(const void *)((elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)) + 1) - (size_t)(const void *)(elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((".gnu.warning.") + 1) - (size_t)(const void *)(".gnu.warning.") == 1) || __s2_len >= 4)) ? __builtin_strcmp (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name), ".gnu.warning.") : (__builtin_constant_p (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)) && ((size_t)(const void *)((elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)) + 1) - (size_t)(const void *)(elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)) == 1) && (__s1_len = strlen (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)), __s1_len < 4) ? (__builtin_constant_p (".gnu.warning.") && ((size_t)(const void *)((".gnu.warning.") + 1) - (size_t)(const void *)(".gnu.warning.") == 1) ? __builtin_strcmp (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name), ".gnu.warning.") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (".gnu.warning."); register int __result = (((const unsigned char *) (const char *) (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (".gnu.warning.") && ((size_t)(const void *)((".gnu.warning.") + 1) - (size_t)(const void *)(".gnu.warning.") == 1) && (__s2_len = strlen (".gnu.warning."), __s2_len < 4) ? (__builtin_constant_p (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)) && ((size_t)(const void *)((elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)) + 1) - (size_t)(const void *)(elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)) == 1) ? __builtin_strcmp (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name), ".gnu.warning.") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)); register int __result = __s1[0] - ((const unsigned char *) (const char *) (".gnu.warning."))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) (".gnu.warning."))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) (".gnu.warning."))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) (".gnu.warning."))[3]); } } __result; }))) : __builtin_strcmp (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name), ".gnu.warning.")))); }) : strncmp (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name), ".gnu.warning.", sizeof ".gnu.warning." - 1))) != 0 && (1 || __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)) && __builtin_constant_p (".comment") && (__s1_len = strlen (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)), __s2_len = strlen (".comment"), (!((size_t)(const void *)((elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)) + 1) - (size_t)(const void *)(elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((".comment") + 1) - (size_t)(const void *)(".comment") == 1) || __s2_len >= 4)) ? __builtin_strcmp (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name), ".comment") : (__builtin_constant_p (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)) && ((size_t)(const void *)((elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)) + 1) - (size_t)(const void *)(elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)) == 1) && (__s1_len = strlen (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)), __s1_len < 4) ? (__builtin_constant_p (".comment") && ((size_t)(const void *)((".comment") + 1) - (size_t)(const void *)(".comment") == 1) ? __builtin_strcmp (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name), ".comment") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (".comment"); register int __result = (((const unsigned char *) (const char *) (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (".comment") && ((size_t)(const void *)((".comment") + 1) - (size_t)(const void *)(".comment") == 1) && (__s2_len = strlen (".comment"), __s2_len < 4) ? (__builtin_constant_p (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)) && ((size_t)(const void *)((elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)) + 1) - (size_t)(const void *)(elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)) == 1) ? __builtin_strcmp (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name), ".comment") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name)); register int __result = __s1[0] - ((const unsigned char *) (const char *) (".comment"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) (".comment"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) (".comment"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) (".comment"))[3]); } } __result; }))) : __builtin_strcmp (elf_strptr (ld_state.outelf, shstrndx, shdr->sh_name), ".comment")))); }) != 0))) && (shdr)->sh_type < 19))
>
>
> continue;
>
>
>      if (shdr->sh_type == 8)
> continue;
>
>
>      Elf_Data *data = ((void *)0);
>      while ((data = elf_getdata (scn, data)) != ((void *)0))
>
>
>
>
> if (__builtin_expect (!!(same_byte_order), 1) || data->d_type == ELF_T_BYTE)
>   hashfct (data->d_buf, data->d_size, ctx);
> else
>   {
>
>     if (gelf_xlatetof (ld_state.outelf, data, data, ident[5])
>  == ((void *)0))
>       error (1, 0, dcgettext (((void *)0), "cannot convert section data to file format: %s", __LC_MESSAGES),
>
>       elf_errmsg (-1));
>
>     hashfct (data->d_buf, data->d_size, ctx);
>
>
>     if (gelf_xlatetom (ld_state.outelf, data, data, ident[5])
>  == ((void *)0))
>       error (1, 0, dcgettext (((void *)0), "cannot convert section data to memory format: %s", __LC_MESSAGES),
>
>       elf_errmsg (-1));
>   }
>    }
>}
>
>
>
>static void
>compute_build_id (void)
>{
>  Elf_Data *d = elf_getdata (elf_getscn (ld_state.outelf,
>      ld_state.buildidscnidx), ((void *)0));
>  ((d != ((void *)0)) ? (void) (0) : __assert_fail ("d != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 4210, __PRETTY_FUNCTION__));
>
>  GElf_Nhdr *hdr = d->d_buf;
>  hdr->n_namesz = sizeof ("GNU");
>  hdr->n_type = 3;
>  char *dp = __builtin_mempcpy (hdr + 1, "GNU", sizeof ("GNU"));
>
>  if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (ld_state.build_id) && __builtin_constant_p ("sha1") && (__s1_len = strlen (ld_state.build_id), __s2_len = strlen ("sha1"), (!((size_t)(const void *)((ld_state.build_id) + 1) - (size_t)(const void *)(ld_state.build_id) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("sha1") + 1) - (size_t)(const void *)("sha1") == 1) || __s2_len >= 4)) ? __builtin_strcmp (ld_state.build_id, "sha1") : (__builtin_constant_p (ld_state.build_id) && ((size_t)(const void *)((ld_state.build_id) + 1) - (size_t)(const void *)(ld_state.build_id) == 1) && (__s1_len = strlen (ld_state.build_id), __s1_len < 4) ? (__builtin_constant_p ("sha1") && ((size_t)(const void *)(("sha1") + 1) - (size_t)(const void *)("sha1") == 1) ? __builtin_strcmp (ld_state.build_id, "sha1") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("sha1"); register int __result = (((const unsigned char *) (const char *) (ld_state.build_id))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (ld_state.build_id))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (ld_state.build_id))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (ld_state.build_id))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("sha1") && ((size_t)(const void *)(("sha1") + 1) - (size_t)(const void *)("sha1") == 1) && (__s2_len = strlen ("sha1"), __s2_len < 4) ? (__builtin_constant_p (ld_state.build_id) && ((size_t)(const void *)((ld_state.build_id) + 1) - (size_t)(const void *)(ld_state.build_id) == 1) ? __builtin_strcmp (ld_state.build_id, "sha1") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (ld_state.build_id); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("sha1"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("sha1"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("sha1"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("sha1"))[3]); } } __result; }))) : __builtin_strcmp (ld_state.build_id, "sha1")))); }) == 0)
>    {
>
>
>      struct sha1_ctx ctx;
>      sha1_init_ctx (&ctx);
>
>
>      compute_hash_sum ((void (*) (const void *, size_t, void *)) sha1_process_bytes,
>   &ctx);
>
>
>      (void) sha1_finish_ctx (&ctx, dp);
>
>      hdr->n_descsz = 20;
>    }
>  else if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (ld_state.build_id) && __builtin_constant_p ("md5") && (__s1_len = strlen (ld_state.build_id), __s2_len = strlen ("md5"), (!((size_t)(const void *)((ld_state.build_id) + 1) - (size_t)(const void *)(ld_state.build_id) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("md5") + 1) - (size_t)(const void *)("md5") == 1) || __s2_len >= 4)) ? __builtin_strcmp (ld_state.build_id, "md5") : (__builtin_constant_p (ld_state.build_id) && ((size_t)(const void *)((ld_state.build_id) + 1) - (size_t)(const void *)(ld_state.build_id) == 1) && (__s1_len = strlen (ld_state.build_id), __s1_len < 4) ? (__builtin_constant_p ("md5") && ((size_t)(const void *)(("md5") + 1) - (size_t)(const void *)("md5") == 1) ? __builtin_strcmp (ld_state.build_id, "md5") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("md5"); register int __result = (((const unsigned char *) (const char *) (ld_state.build_id))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (ld_state.build_id))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (ld_state.build_id))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (ld_state.build_id))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("md5") && ((size_t)(const void *)(("md5") + 1) - (size_t)(const void *)("md5") == 1) && (__s2_len = strlen ("md5"), __s2_len < 4) ? (__builtin_constant_p (ld_state.build_id) && ((size_t)(const void *)((ld_state.build_id) + 1) - (size_t)(const void *)(ld_state.build_id) == 1) ? __builtin_strcmp (ld_state.build_id, "md5") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (ld_state.build_id); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("md5"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("md5"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("md5"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("md5"))[3]); } } __result; }))) : __builtin_strcmp (ld_state.build_id, "md5")))); }) == 0)
>    {
>
>
>      struct md5_ctx ctx;
>      md5_init_ctx (&ctx);
>
>
>      compute_hash_sum ((void (*) (const void *, size_t, void *)) md5_process_bytes,
>   &ctx);
>
>
>      (void) md5_finish_ctx (&ctx, dp);
>
>      hdr->n_descsz = 16;
>    }
>  else if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (ld_state.build_id) && __builtin_constant_p ("uuid") && (__s1_len = strlen (ld_state.build_id), __s2_len = strlen ("uuid"), (!((size_t)(const void *)((ld_state.build_id) + 1) - (size_t)(const void *)(ld_state.build_id) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("uuid") + 1) - (size_t)(const void *)("uuid") == 1) || __s2_len >= 4)) ? __builtin_strcmp (ld_state.build_id, "uuid") : (__builtin_constant_p (ld_state.build_id) && ((size_t)(const void *)((ld_state.build_id) + 1) - (size_t)(const void *)(ld_state.build_id) == 1) && (__s1_len = strlen (ld_state.build_id), __s1_len < 4) ? (__builtin_constant_p ("uuid") && ((size_t)(const void *)(("uuid") + 1) - (size_t)(const void *)("uuid") == 1) ? __builtin_strcmp (ld_state.build_id, "uuid") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("uuid"); register int __result = (((const unsigned char *) (const char *) (ld_state.build_id))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (ld_state.build_id))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (ld_state.build_id))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (ld_state.build_id))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("uuid") && ((size_t)(const void *)(("uuid") + 1) - (size_t)(const void *)("uuid") == 1) && (__s2_len = strlen ("uuid"), __s2_len < 4) ? (__builtin_constant_p (ld_state.build_id) && ((size_t)(const void *)((ld_state.build_id) + 1) - (size_t)(const void *)(ld_state.build_id) == 1) ? __builtin_strcmp (ld_state.build_id, "uuid") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (ld_state.build_id); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("uuid"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("uuid"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("uuid"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("uuid"))[3]); } } __result; }))) : __builtin_strcmp (ld_state.build_id, "uuid")))); }) == 0)
>    {
>      int fd = open ("/dev/urandom", 00);
>      if (fd == -1)
> error (1, (*__errno_location ()), dcgettext (((void *)0), "cannot open '%s'", __LC_MESSAGES),
>        "/dev/urandom");
>
>      if ((__extension__ ({ long int __result; do __result = (long int) (read (fd, dp, 16)); while (__result == -1L && (*__errno_location ()) == 4); __result; })) != 16)
> error (1, 0, dcgettext (((void *)0), "cannot read enough data for UUID", __LC_MESSAGES));
>
>      close (fd);
>
>      hdr->n_descsz = 16;
>    }
>  else
>    {
>      const char *cp = ld_state.build_id + 2;
>
>
>
>      do
> {
>   if (((*__ctype_b_loc ())[(int) ((cp[0]))] & (unsigned short int) _ISxdigit))
>     {
>       char ch1 = (__extension__ ({ int __res; if (sizeof (cp[0]) > 1) { if (__builtin_constant_p (cp[0])) { int __c = (cp[0]); __res = __c < -128 || __c > 255 ? __c : (*__ctype_tolower_loc ())[__c]; } else __res = tolower (cp[0]); } else __res = (*__ctype_tolower_loc ())[(int) (cp[0])]; __res; }));
>       char ch2 = (__extension__ ({ int __res; if (sizeof (cp[1]) > 1) { if (__builtin_constant_p (cp[1])) { int __c = (cp[1]); __res = __c < -128 || __c > 255 ? __c : (*__ctype_tolower_loc ())[__c]; } else __res = tolower (cp[1]); } else __res = (*__ctype_tolower_loc ())[(int) (cp[1])]; __res; }));
>
>       *dp++ = (((((*__ctype_b_loc ())[(int) ((ch1))] & (unsigned short int) _ISdigit) ? ch1 - '0' : ch1 - 'a' + 10) << 4)
>         | (((*__ctype_b_loc ())[(int) ((ch2))] & (unsigned short int) _ISdigit) ? ch2 - '0' : ch2 - 'a' + 10));
>     }
>   else
>     ++cp;
> }
>      while (*cp != '\0');
>    }
>}
># 4299 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c"
>static int
>ld_generic_create_outfile (struct ld_state *statep)
>{
>  struct scnlist
>  {
>    size_t scnidx;
>    struct scninfo *scninfo;
>    struct scnlist *next;
>  };
>  struct scnlist *rellist = ((void *)0);
>  size_t cnt;
>  Elf_Scn *symscn = ((void *)0);
>  Elf_Scn *xndxscn = ((void *)0);
>  Elf_Scn *strscn = ((void *)0);
>  struct Ebl_Strtab *strtab = ((void *)0);
>  struct Ebl_Strtab *dynstrtab = ((void *)0);
>  GElf_Shdr shdr_mem; GElf_Shdr *shdr;
>  Elf_Data *data;
>  Elf_Data *symdata = ((void *)0);
>  Elf_Data *xndxdata = ((void *)0);
>  struct usedfiles *file;
>  size_t nsym;
>  size_t nsym_local;
>  size_t nsym_allocated;
>  size_t nsym_dyn = 0;
>  Elf32_Word *dblindirect = ((void *)0);
>
>  _Bool need_xndx;
>
>  Elf_Scn *shstrtab_scn;
>  size_t shstrtab_ndx;
>  GElf_Ehdr ehdr_mem; GElf_Ehdr *ehdr;
>  struct Ebl_Strent *symtab_ent = ((void *)0);
>  struct Ebl_Strent *xndx_ent = ((void *)0);
>  struct Ebl_Strent *strtab_ent = ((void *)0);
>  struct Ebl_Strent *shstrtab_ent;
>  struct scngroup *groups;
>  Elf_Scn *dynsymscn = ((void *)0);
>  Elf_Data *dynsymdata = ((void *)0);
>  Elf_Data *dynstrdata = ((void *)0);
>  Elf32_Word *hashcodes = ((void *)0);
>  Elf32_Word *gnuhashcodes = ((void *)0);
>  size_t nsym_dyn_allocated = 0;
>  Elf_Scn *versymscn = ((void *)0);
>  Elf_Data *versymdata = ((void *)0);
>
>  if (ld_state.need_symtab)
>    {
>
>
>      symscn = elf_newscn (ld_state.outelf);
>      ld_state.symscnidx = elf_ndxscn (symscn);
>      symdata = elf_newdata (symscn);
>      if (symdata == ((void *)0))
> error (1, 0,
>        dcgettext (((void *)0), "cannot create symbol table for output file: %s", __LC_MESSAGES),
>        elf_errmsg (-1));
>
>      symdata->d_type = ELF_T_SYM;
>
>
>      nsym_allocated = (1 + ld_state.nsymtab + ld_state.nplt + ld_state.ngot
>   + ld_state.nusedsections + ld_state.nlscript_syms);
>      symdata->d_size = gelf_fsize (ld_state.outelf, ELF_T_SYM, nsym_allocated, 1);
>
>
>
>
>      if (__builtin_expect (!!(ld_state.nusedsections >= 0xff00), 0))
> {
>   xndxscn = elf_newscn (ld_state.outelf);
>   ld_state.xndxscnidx = elf_ndxscn (xndxscn);
>
>   xndxdata = elf_newdata (xndxscn);
>   if (xndxdata == ((void *)0))
>     error (1, 0,
>     dcgettext (((void *)0), "cannot create symbol table for output file: %s", __LC_MESSAGES),
>     elf_errmsg (-1));
>
>
>
>   xndxdata->d_type = ELF_T_WORD;
>
>
>   xndxdata->d_size = gelf_fsize (ld_state.outelf, ELF_T_WORD, nsym_allocated, 1);
>
>
>   xndxdata->d_buf = memset (xmalloc (xndxdata->d_size), '\0',
>        gelf_fsize (ld_state.outelf, ELF_T_WORD, 1, 1));
>
>   xndxdata->d_off = 0;
>
>   xndxdata->d_align = sizeof (Elf32_Word);
> }
>    }
>  else
>    {
>      ((ld_state.need_dynsym) ? (void) (0) : __assert_fail ("ld_state.need_dynsym", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 4396, __PRETTY_FUNCTION__));
>
>
>
>      symscn = elf_getscn (ld_state.outelf, ld_state.dynsymscnidx);
>      symdata = elf_newdata (symscn);
>      if (symdata == ((void *)0))
> error (1, 0,
>        dcgettext (((void *)0), "cannot create symbol table for output file: %s", __LC_MESSAGES),
>        elf_errmsg (-1));
>
>      symdata->d_version = 1;
>      symdata->d_type = ELF_T_SYM;
>
>
>      nsym_allocated = (1 + ld_state.nsymtab + ld_state.nplt + ld_state.ngot
>   - ld_state.nlocalsymbols + ld_state.nlscript_syms);
>      symdata->d_size = gelf_fsize (ld_state.outelf, ELF_T_SYM, nsym_allocated, 1);
>
>    }
>
>
>  symdata->d_buf = memset (xmalloc (symdata->d_size), '\0',
>      gelf_fsize (ld_state.outelf, ELF_T_SYM, 1, 1));
>  symdata->d_off = 0;
>
>  symdata->d_align = gelf_fsize (ld_state.outelf, ELF_T_ADDR, 1, 1);
>
>
>
>  symstrent = (struct Ebl_Strent **) xcalloc (nsym_allocated,
>           sizeof (struct Ebl_Strent *));
>
>
>  nsym = 1;
>
>
>  for (cnt = 0; cnt < ld_state.nallsections; ++cnt)
>    {
>      struct scnhead *head = ld_state.allsections[cnt];
>      Elf_Scn *scn;
>      struct scninfo *runp;
>      GElf_Off offset;
>      Elf32_Word xndx;
>
>
>      if (!head->used)
> continue;
>
>
>      scn = elf_getscn (ld_state.outelf, head->scnidx);
>
>      if (__builtin_expect (!!(head->kind == scn_dot_interp), 0))
> {
>   Elf_Data *outdata = elf_newdata (scn);
>   if (outdata == ((void *)0))
>     error (1, 0,
>     dcgettext (((void *)0), "cannot create section for output file: %s", __LC_MESSAGES),
>     elf_errmsg (-1));
>
>
>   const char *interp = ld_state.interp ?: "/lib/ld.so.1";
>
>
>   outdata->d_buf = (void *) interp;
>   outdata->d_size = strlen (interp) + 1;
>   outdata->d_type = ELF_T_BYTE;
>   outdata->d_off = 0;
>   outdata->d_align = 1;
>   outdata->d_version = 1;
>
>
>   ld_state.interpscnidx = head->scnidx;
>
>   continue;
> }
>
>      if (__builtin_expect (!!(head->kind == scn_dot_got), 0))
> {
>
>   ld_state.gotscnidx = elf_ndxscn (scn);
>
>
>   (_dl_mcount_wrapper_check ((void *) ((&ld_state)->callbacks.initialize_got)), (*((&ld_state)->callbacks.initialize_got)) (&ld_state, scn));
>
>   continue;
> }
>
>      if (__builtin_expect (!!(head->kind == scn_dot_gotplt), 0))
> {
>
>   ld_state.gotpltscnidx = elf_ndxscn (scn);
>
>
>   (_dl_mcount_wrapper_check ((void *) ((&ld_state)->callbacks.initialize_gotplt)), (*((&ld_state)->callbacks.initialize_gotplt)) (&ld_state, scn));
>
>   continue;
> }
>
>      if (__builtin_expect (!!(head->kind == scn_dot_dynrel), 0))
> {
>   Elf_Data *outdata;
>
>   outdata = elf_newdata (scn);
>   if (outdata == ((void *)0))
>     error (1, 0,
>     dcgettext (((void *)0), "cannot create section for output file: %s", __LC_MESSAGES),
>     elf_errmsg (-1));
>
>   outdata->d_size = ld_state.relsize_total;
>   outdata->d_buf = xmalloc (outdata->d_size);
>   outdata->d_type = ((_dl_mcount_wrapper_check ((void *) ((&ld_state)->callbacks.rel_type)), (*((&ld_state)->callbacks.rel_type)) (&ld_state)) == 17
>        ? ELF_T_REL : ELF_T_RELA);
>   outdata->d_off = 0;
>   outdata->d_align = gelf_fsize (ld_state.outelf, ELF_T_ADDR, 1, 1);
>
>
>   ld_state.reldynscnidx = elf_ndxscn (scn);
>
>   continue;
> }
>
>      if (__builtin_expect (!!(head->kind == scn_dot_dynamic), 0))
> {
>
>   Elf_Data *outdata;
>
>
>   if (ld_state.dt_flags != 0)
>     ++ld_state.ndynamic;
>   if (ld_state.dt_flags_1 != 0)
>     ++ld_state.ndynamic;
>   if (ld_state.dt_feature_1 != 0)
>     ++ld_state.ndynamic;
>
>   outdata = elf_newdata (scn);
>   if (outdata == ((void *)0))
>     error (1, 0,
>     dcgettext (((void *)0), "cannot create section for output file: %s", __LC_MESSAGES),
>     elf_errmsg (-1));
>
>
>   outdata->d_size = gelf_fsize (ld_state.outelf, ELF_T_DYN, ld_state.ndynamic, 1);
>
>   outdata->d_buf = xcalloc (1, outdata->d_size);
>   outdata->d_type = ELF_T_DYN;
>   outdata->d_off = 0;
>   outdata->d_align = gelf_fsize (ld_state.outelf, ELF_T_ADDR, 1, 1);
>
>
>   ld_state.dynamicscnidx = elf_ndxscn (scn);
>
>   continue;
> }
>
>      if (__builtin_expect (!!(head->kind == scn_dot_dynsym), 0))
> {
>
>   ((ld_state.dynsymscnidx == elf_ndxscn (scn)) ? (void) (0) : __assert_fail ("ld_state.dynsymscnidx == elf_ndxscn (scn)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 4554, __PRETTY_FUNCTION__));
>
>   continue;
> }
>
>      if (__builtin_expect (!!(head->kind == scn_dot_dynstr), 0))
> {
>
>   ld_state.dynstrscnidx = elf_ndxscn (scn);
>
>
>   dynstrtab = ebl_strtabinit (1);
>
>
>
>
>
>   if (ld_state.ndsofiles > 0)
>     {
>       struct usedfiles *frunp = ld_state.dsofiles;
>
>       do
>  if (! frunp->as_needed || frunp->used)
>    frunp->sonameent = ebl_strtabadd (dynstrtab, frunp->soname,
>          0);
>       while ((frunp = frunp->next) != ld_state.dsofiles);
>     }
>
>
>
>
>
>   if (ld_state.runpath != ((void *)0) || ld_state.rpath != ((void *)0))
>     {
>       struct pathelement *startp;
>       struct pathelement *prunp;
>       int tag;
>       size_t len;
>       char *str;
>       char *cp;
>
>       if (ld_state.runpath != ((void *)0))
>  {
>    startp = ld_state.runpath;
>    tag = 29;
>  }
>       else
>  {
>    startp = ld_state.rpath;
>    tag = 15;
>  }
>
>
>       for (len = 0, prunp = startp; prunp != ((void *)0); prunp = prunp->next)
>  len += strlen (prunp->pname) + 1;
>
>       cp = str = (char *) __extension__ ({ struct obstack *__h = (&ld_state.smem); __extension__ ({ struct obstack *__o = (__h); int __len = ((len)); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len)); (void) 0; }); __extension__ ({ struct obstack *__o1 = (__h); void *__value = (void *) __o1->object_base; if (__o1->next_free == __value) __o1->maybe_empty_object = 1; __o1->next_free = ((sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask))); if (__o1->next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit; __o1->object_base = __o1->next_free; __value; }); });
>
>       for (prunp = startp; prunp != ((void *)0); prunp = prunp->next)
>  {
>    cp = __builtin_stpcpy (cp, prunp->pname);
>    *cp++ = ':';
>  }
>
>       cp[-1] = '\0';
>
>
>
>       ld_state.rxxpath_strent = ebl_strtabadd (dynstrtab, str, len);
>       ld_state.rxxpath_tag = tag;
>     }
>
>   continue;
> }
>
>      if (__builtin_expect (!!(head->kind == scn_dot_hash), 0))
> {
>
>   ld_state.hashscnidx = elf_ndxscn (scn);
>
>   continue;
> }
>
>      if (__builtin_expect (!!(head->kind == scn_dot_gnu_hash), 0))
> {
>
>   ld_state.gnuhashscnidx = elf_ndxscn (scn);
>
>   continue;
> }
>
>      if (__builtin_expect (!!(head->kind == scn_dot_plt), 0))
> {
>
>   ld_state.pltscnidx = elf_ndxscn (scn);
>
>
>   (_dl_mcount_wrapper_check ((void *) ((&ld_state)->callbacks.initialize_plt)), (*((&ld_state)->callbacks.initialize_plt)) (&ld_state, scn));
>
>   continue;
> }
>
>      if (__builtin_expect (!!(head->kind == scn_dot_pltrel), 0))
> {
>
>   ld_state.pltrelscnidx = elf_ndxscn (scn);
>
>
>   (_dl_mcount_wrapper_check ((void *) ((&ld_state)->callbacks.initialize_pltrel)), (*((&ld_state)->callbacks.initialize_pltrel)) (&ld_state, scn));
>
>   continue;
> }
>
>      if (__builtin_expect (!!(head->kind == scn_dot_version), 0))
> {
>
>   ld_state.versymscnidx = elf_ndxscn (scn);
>
>   continue;
> }
>
>      if (__builtin_expect (!!(head->kind == scn_dot_version_r), 0))
> {
>
>   ld_state.verneedscnidx = elf_ndxscn (scn);
>
>   continue;
> }
>
>      if (__builtin_expect (!!(head->kind == scn_dot_note_gnu_build_id), 0))
> {
>
>   ld_state.buildidscnidx = elf_ndxscn (scn);
>
>   create_build_id_section (scn);
>
>   continue;
> }
>
>
>      ((head->kind == scn_normal) ? (void) (0) : __assert_fail ("head->kind == scn_normal", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 4694, __PRETTY_FUNCTION__));
>
>
>
>      if (ld_state.need_symtab)
> {
>
>   GElf_Sym sym_mem; GElf_Sym *sym;
>
>
>
>
>
>   sym = &sym_mem;
>
>
>
>
>   sym->st_name = 0;
>   sym->st_info = ((((0)) << 4) + (((3)) & 0xf));
>   sym->st_other = 0;
>   sym->st_value = 0;
>   sym->st_size = 0;
>
>
>
>   if (__builtin_expect (!!(head->scnidx < 0xff00), 1))
>     {
>       sym->st_shndx = head->scnidx;
>       xndx = 0;
>     }
>   else
>     {
>       sym->st_shndx = 0xffff;
>       xndx = head->scnidx;
>     }
>
>
>
>
>   ((nsym < nsym_allocated) ? (void) (0) : __assert_fail ("nsym < nsym_allocated", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 4734, __PRETTY_FUNCTION__));
>   gelf_update_symshndx (symdata, xndxdata, nsym, sym, xndx);
>
>
>   head->scnsymidx = nsym++;
> }
>
>      if (head->type == 9 || head->type == 4)
> {
>
>
>   if (ld_state.file_type == relocatable_file_type)
>     {
>       struct scnlist *newp;
>
>       newp = (struct scnlist *) __builtin_alloca (sizeof (*newp));
>       newp->scnidx = head->scnidx;
>       newp->scninfo = head->last->next;
>
>       newp->next = ((void *)0);
>
>       do { __typeof (newp) _newp = (newp); ((_newp->next == ((void *)0)) ? (void) (0) : __assert_fail ("_newp->next == ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 4755, __PRETTY_FUNCTION__)); _newp->next = rellist; rellist = _newp; } while (0);
>     }
>   else
>     {
>
>
>
>
>
>       int type = head->type == 9 ? ELF_T_REL : ELF_T_RELA;
>
>       data = elf_newdata (scn);
>       if (data == ((void *)0))
>  error (1, 0,
>         dcgettext (((void *)0), "cannot create section for output file: %s", __LC_MESSAGES),
>         elf_errmsg (-1));
>
>       data->d_size = gelf_fsize (ld_state.outelf, type, head->relsize, 1);
>       data->d_buf = xcalloc (data->d_size, 1);
>       data->d_type = type;
>       data->d_align = gelf_fsize (ld_state.outelf, ELF_T_ADDR, 1, 1);
>       data->d_off = 0;
>
>       continue;
>     }
> }
>
>
>      if (head->flags & (1 << 4))
> {
>
>
>
>   Elf_Data *outdata;
>
>
>
>
>
>
>
>   runp = head->last->next;
>   if (runp->symbols == ((void *)0))
>     {
>       head->flags &= ~(1 << 4);
>       goto no_merge;
>     }
>   head->symbols = runp->symbols;
>
>   while ((runp = runp->next) != head->last->next)
>     {
>       if (runp->symbols == ((void *)0))
>  {
>    head->flags &= ~(1 << 4);
>    head->symbols = ((void *)0);
>    goto no_merge;
>  }
>
>       struct symbol *oldhead = head->symbols->next_in_scn;
>
>       head->symbols->next_in_scn = runp->symbols->next_in_scn;
>       runp->symbols->next_in_scn = oldhead;
>       head->symbols = runp->symbols;
>     }
>
>
>   outdata = elf_newdata (scn);
>   if (outdata == ((void *)0))
>     error (1, 0,
>     dcgettext (((void *)0), "cannot create section for output file: %s", __LC_MESSAGES),
>     elf_errmsg (-1));
>
>
>
>
>
>
>   if ((head->last->shdr).sh_entsize == 1
>       && (head->flags & (1 << 5)))
>     {
>
>       struct Ebl_Strtab *mergestrtab;
>       struct symbol *symrunp;
>       Elf_Data *locsymdata = ((void *)0);
>       Elf_Data *locdata = ((void *)0);
>
>       mergestrtab = ebl_strtabinit (0);
>
>       symrunp = head->symbols->next_in_scn;
>       file = ((void *)0);
>       do
>  {
>
>
>
>
>    if (symrunp->file != file)
>      {
>
>        file = symrunp->file;
>
>        locsymdata = file->symtabdata;
>
>        locdata = elf_rawdata (file->scninfo[symrunp->scndx].scn,
>          ((void *)0));
>        ((locdata != ((void *)0)) ? (void) (0) : __assert_fail ("locdata != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 4860, __PRETTY_FUNCTION__));
>
>
>
>
>
>        file->scninfo[symrunp->scndx].outscnndx = head->scnidx;
>      }
>
>
>
>    GElf_Sym sym_mem; GElf_Sym *sym;
>    sym = gelf_getsym (locsymdata, symrunp->symidx, &sym_mem);
>    ((sym != ((void *)0)) ? (void) (0) : __assert_fail ("sym != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 4873, __PRETTY_FUNCTION__));
>
>
>
>
>    symrunp->merge.handle
>      = ebl_strtabadd (mergestrtab,
>         (char *) locdata->d_buf + sym->st_value,
>         0);
>  }
>       while ((symrunp = symrunp->next_in_scn)
>       != head->symbols->next_in_scn);
>
>
>       ebl_strtabfinalize (mergestrtab, outdata);
>
>
>       symrunp = runp->symbols;
>       do
>  {
>    symrunp->merge.value
>      = ebl_strtaboffset (symrunp->merge.handle);
>    symrunp->merged = 1;
>  }
>       while ((symrunp = symrunp->next_in_scn) != runp->symbols);
>
>
>       ebl_strtabfree (mergestrtab);
>     }
>   else if (__builtin_expect (!!((head->last->shdr).sh_entsize == sizeof (wchar_t)), 1)
>
>     && __builtin_expect (!!(head->flags & (1 << 5)), 1))
>     {
>
>       struct Ebl_WStrtab *mergestrtab;
>       struct symbol *symrunp;
>       Elf_Data *locsymdata = ((void *)0);
>       Elf_Data *locdata = ((void *)0);
>
>       mergestrtab = ebl_wstrtabinit (0);
>
>       symrunp = runp->symbols;
>       file = ((void *)0);
>       do
>  {
>
>
>
>
>    if (symrunp->file != file)
>      {
>
>        file = symrunp->file;
>
>        locsymdata = file->symtabdata;
>
>        locdata = elf_rawdata (file->scninfo[symrunp->scndx].scn,
>          ((void *)0));
>        ((locdata != ((void *)0)) ? (void) (0) : __assert_fail ("locdata != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 4931, __PRETTY_FUNCTION__));
>
>
>
>
>
>
>        file->scninfo[symrunp->scndx].outscnndx = head->scnidx;
>      }
>
>
>
>    GElf_Sym sym_mem; GElf_Sym *sym;
>    sym = gelf_getsym (locsymdata, symrunp->symidx, &sym_mem);
>    ((sym != ((void *)0)) ? (void) (0) : __assert_fail ("sym != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 4945, __PRETTY_FUNCTION__));
>
>
>
>
>
>
>
>    symrunp->merge.handle
>      = ebl_wstrtabadd (mergestrtab,
>          (wchar_t *) ((char *) locdata->d_buf
>         + sym->st_value), 0);
>  }
>       while ((symrunp = symrunp->next_in_scn) != runp->symbols);
>
>
>       ebl_wstrtabfinalize (mergestrtab, outdata);
>
>
>       symrunp = runp->symbols;
>       do
>  {
>    symrunp->merge.value
>      = ebl_wstrtaboffset (symrunp->merge.handle);
>    symrunp->merged = 1;
>  }
>       while ((symrunp = symrunp->next_in_scn) != runp->symbols);
>
>
>       ebl_wstrtabfree (mergestrtab);
>     }
>   else
>     {
>
>       struct Ebl_GStrtab *mergestrtab;
>       struct symbol *symrunp;
>       Elf_Data *locsymdata = ((void *)0);
>       Elf_Data *locdata = ((void *)0);
>
>
>       unsigned int len = (head->flags & (1 << 5)) ? 0 : 1;
>
>
>
>       mergestrtab
>  = ebl_gstrtabinit ((head->last->shdr).sh_entsize,
>       0);
>
>       symrunp = runp->symbols;
>       file = ((void *)0);
>       do
>  {
>
>
>
>
>    if (symrunp->file != file)
>      {
>
>        file = symrunp->file;
>
>        locsymdata = file->symtabdata;
>
>        locdata = elf_rawdata (file->scninfo[symrunp->scndx].scn,
>          ((void *)0));
>        ((locdata != ((void *)0)) ? (void) (0) : __assert_fail ("locdata != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5010, __PRETTY_FUNCTION__));
>
>
>
>
>
>
>        file->scninfo[symrunp->scndx].outscnndx = head->scnidx;
>      }
>
>
>
>    GElf_Sym sym_mem; GElf_Sym *sym;
>    sym = gelf_getsym (locsymdata, symrunp->symidx, &sym_mem);
>    ((sym != ((void *)0)) ? (void) (0) : __assert_fail ("sym != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5024, __PRETTY_FUNCTION__));
>
>
>
>
>
>
>
>    symrunp->merge.handle
>      = ebl_gstrtabadd (mergestrtab,
>          (char *) locdata->d_buf + sym->st_value,
>          len);
>  }
>       while ((symrunp = symrunp->next_in_scn) != runp->symbols);
>
>
>       ebl_gstrtabfinalize (mergestrtab, outdata);
>
>
>       symrunp = runp->symbols;
>       do
>  {
>    symrunp->merge.value
>      = ebl_gstrtaboffset (symrunp->merge.handle);
>    symrunp->merged = 1;
>  }
>       while ((symrunp = symrunp->next_in_scn) != runp->symbols);
>
>
>       ebl_gstrtabfree (mergestrtab);
>     }
> }
>      else
> {
> no_merge:
>   ((head->scnidx == elf_ndxscn (scn)) ? (void) (0) : __assert_fail ("head->scnidx == elf_ndxscn (scn)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5059, __PRETTY_FUNCTION__));
>
>
>
>
>   runp = head->last->next;
>   offset = 0;
>   do
>     {
>       Elf_Data *outdata = elf_newdata (scn);
>       if (outdata == ((void *)0))
>  error (1, 0,
>         dcgettext (((void *)0), "cannot create section for output file: %s", __LC_MESSAGES),
>         elf_errmsg (-1));
>
>
>
>
>
>       if (__builtin_expect (!!(runp->scn != ((void *)0)), 1))
>  {
>    data = elf_getdata (runp->scn, ((void *)0));
>    ((data != ((void *)0)) ? (void) (0) : __assert_fail ("data != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5081, __PRETTY_FUNCTION__));
>
>
>    *outdata = *data;
>
>
>
>    ((elf_getdata (runp->scn, data) == ((void *)0)) ? (void) (0) : __assert_fail ("elf_getdata (runp->scn, data) == ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5088, __PRETTY_FUNCTION__));
>  }
>       else
>  {
>
>    (((runp->shdr).sh_type == 8) ? (void) (0) : __assert_fail ("(runp->shdr).sh_type == 8", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5093, __PRETTY_FUNCTION__));
>
>    outdata->d_buf = ((void *)0);
>    outdata->d_type = ELF_T_BYTE;
>    outdata->d_version = 1;
>    outdata->d_size = (runp->shdr).sh_size;
>    outdata->d_align = (runp->shdr).sh_addralign;
>  }
>
>       GElf_Off align = (((1)>(outdata->d_align))?(1):(outdata->d_align));
>       ((((((align) - 1) & (align)) == 0)) ? (void) (0) : __assert_fail ("((((align) - 1) & (align)) == 0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5103, __PRETTY_FUNCTION__));
>       offset = ((offset + align - 1) & ~(align - 1));
>
>       runp->offset = offset;
>       runp->outscnndx = head->scnidx;
>       runp->allsectionsidx = cnt;
>
>       outdata->d_off = offset;
>
>       offset += outdata->d_size;
>     }
>   while ((runp = runp->next) != head->last->next);
>
>
>   if (ld_state.add_ld_comment
>       && head->flags == 0
>       && head->type == 1
>       && __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (head->name) && __builtin_constant_p (".comment") && (__s1_len = strlen (head->name), __s2_len = strlen (".comment"), (!((size_t)(const void *)((head->name) + 1) - (size_t)(const void *)(head->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((".comment") + 1) - (size_t)(const void *)(".comment") == 1) || __s2_len >= 4)) ? __builtin_strcmp (head->name, ".comment") : (__builtin_constant_p (head->name) && ((size_t)(const void *)((head->name) + 1) - (size_t)(const void *)(head->name) == 1) && (__s1_len = strlen (head->name), __s1_len < 4) ? (__builtin_constant_p (".comment") && ((size_t)(const void *)((".comment") + 1) - (size_t)(const void *)(".comment") == 1) ? __builtin_strcmp (head->name, ".comment") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (".comment"); register int __result = (((const unsigned char *) (const char *) (head->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (head->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (head->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (head->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (".comment") && ((size_t)(const void *)((".comment") + 1) - (size_t)(const void *)(".comment") == 1) && (__s2_len = strlen (".comment"), __s2_len < 4) ? (__builtin_constant_p (head->name) && ((size_t)(const void *)((head->name) + 1) - (size_t)(const void *)(head->name) == 1) ? __builtin_strcmp (head->name, ".comment") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (head->name); register int __result = __s1[0] - ((const unsigned char *) (const char *) (".comment"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) (".comment"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) (".comment"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) (".comment"))[3]); } } __result; }))) : __builtin_strcmp (head->name, ".comment")))); }) == 0
>       && head->entsize == 0)
>     {
>       Elf_Data *outdata = elf_newdata (scn);
>
>       if (outdata == ((void *)0))
>  error (1, 0,
>         dcgettext (((void *)0), "cannot create section for output file: %s", __LC_MESSAGES),
>         elf_errmsg (-1));
>
>       outdata->d_buf = (void *) "\0ld (" "Red Hat elfutils" ") " "0.132";
>       outdata->d_size = strlen ((char *) outdata->d_buf + 1) + 2;
>       outdata->d_off = offset;
>       outdata->d_type = ELF_T_BYTE;
>       outdata->d_align = 1;
>     }
>
>
>
>
>
> }
>    }
>
>
>  strtab = ebl_strtabinit (1);
>  if (strtab == ((void *)0))
>    error (1, (*__errno_location ()), dcgettext (((void *)0), "cannot create string table", __LC_MESSAGES));
>
>
>
>
>  need_xndx = 0;
>
>
>
>
>
>
>
>  ndxtosym = (struct symbol **) xcalloc (nsym_allocated,
>      sizeof (struct symbol));
>
>
>  if (ld_state.got_symbol != ((void *)0))
>    {
>      ((nsym < nsym_allocated) ? (void) (0) : __assert_fail ("nsym < nsym_allocated", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5166, __PRETTY_FUNCTION__));
>
>      fillin_special_symbol (ld_state.got_symbol, ld_state.gotpltscnidx,
>        nsym++, symdata, strtab);
>    }
>
>
>  if (ld_state.dyn_symbol != ((void *)0))
>    {
>      ((nsym < nsym_allocated) ? (void) (0) : __assert_fail ("nsym < nsym_allocated", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5175, __PRETTY_FUNCTION__));
>      fillin_special_symbol (ld_state.dyn_symbol, ld_state.dynamicscnidx,
>        nsym++, symdata, strtab);
>    }
>
>
>
>  if (ld_state.lscript_syms != ((void *)0))
>    {
>      struct symbol *rsym = ld_state.lscript_syms;
>      do
> {
>   ((nsym < nsym_allocated) ? (void) (0) : __assert_fail ("nsym < nsym_allocated", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5187, __PRETTY_FUNCTION__));
>   fillin_special_symbol (rsym, 0xfff1, nsym++, symdata, strtab);
> }
>      while ((rsym = rsym->next) != ((void *)0));
>    }
>
>
>  file = ld_state.relfiles->next;
>  symdata = elf_getdata (elf_getscn (ld_state.outelf, ld_state.symscnidx),
>    ((void *)0));
>
>  do
>    {
>      size_t maxcnt;
>      Elf_Data *insymdata;
>      Elf_Data *inxndxdata;
>
>
>
>      ((ld_state.file_type != relocatable_file_type || file->dynsymtabdata == ((void *)0)) ? (void) (0) : __assert_fail ("ld_state.file_type != relocatable_file_type || file->dynsymtabdata == ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5207, __PRETTY_FUNCTION__));
>
>
>      insymdata = file->symtabdata;
>      ((insymdata != ((void *)0)) ? (void) (0) : __assert_fail ("insymdata != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5210, __PRETTY_FUNCTION__));
>      inxndxdata = file->xndxdata;
>
>      maxcnt = file->nsymtab;
>
>      file->symindirect = (Elf32_Word *) xcalloc (maxcnt, sizeof (Elf32_Word));
>
>
>
>      for (cnt = ld_state.need_symtab ? 1 : file->nlocalsymbols; cnt < maxcnt;
>    ++cnt)
> {
>   GElf_Sym sym_mem; GElf_Sym *sym;
>   Elf32_Word xndx;
>   struct symbol *defp = ((void *)0);
>
>   sym = gelf_getsymshndx (insymdata, inxndxdata, cnt, &sym_mem, &(xndx));
>   ((sym != ((void *)0)) ? (void) (0) : __assert_fail ("sym != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5227, __PRETTY_FUNCTION__));
>
>   if (__builtin_expect (!!(((sym->st_info) & 0xf) == 3), 0))
>     {
>
>       if (ld_state.need_symtab)
>  {
>
>
>
>    if (sym->st_shndx != 0xffff)
>      xndx = sym->st_shndx;
>
>    ((file->scninfo[xndx].allsectionsidx < ld_state.nallsections) ? (void) (0) : __assert_fail ("file->scninfo[xndx].allsectionsidx < ld_state.nallsections", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5241, __PRETTY_FUNCTION__));
>
>    file->symindirect[cnt] = ld_state.allsections[file->scninfo[xndx].allsectionsidx]->scnsymidx;
>
>
>
>  }
>       continue;
>     }
>
>   if ((ld_state.strip >= strip_all || !ld_state.need_symtab)
>
>       && ((sym->st_info) & 0xf) == 4)
>     continue;
># 5263 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c"
>   if (sym->st_shndx != 0
>       && (sym->st_shndx < 0xff00
>    || sym->st_shndx == 0xffff))
>     {
>
>
>
>
>       if (!ld_state.export_all_dynamic && !ld_state.need_symtab)
>  {
>    ((cnt >= file->nlocalsymbols) ? (void) (0) : __assert_fail ("cnt >= file->nlocalsymbols", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5273, __PRETTY_FUNCTION__));
>    defp = file->symref[cnt];
>    ((defp != ((void *)0)) ? (void) (0) : __assert_fail ("defp != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5275, __PRETTY_FUNCTION__));
>
>    if (!defp->in_dso)
>
>      continue;
>  }
>
>
>
>       if (sym->st_shndx != 0xffff)
>  xndx = sym->st_shndx;
>
>       sym->st_value += file->scninfo[xndx].offset;
>
>       ((file->scninfo[xndx].outscnndx < 0xff00 || file->scninfo[xndx].outscnndx > 0xffff) ? (void) (0) : __assert_fail ("file->scninfo[xndx].outscnndx < 0xff00 || file->scninfo[xndx].outscnndx > 0xffff", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5290, __PRETTY_FUNCTION__));
>
>       if (__builtin_expect (!!(file->scninfo[xndx].outscnndx > 0xff00), 0))
>  {
>
>
>    if (!ld_state.need_symtab)
>      error (1, 0, dcgettext (((void *)0), "section index too large in dynamic symbol table", __LC_MESSAGES));
>
>
>    ((xndxdata != ((void *)0)) ? (void) (0) : __assert_fail ("xndxdata != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5299, __PRETTY_FUNCTION__));
>    sym->st_shndx = 0xffff;
>    xndx = file->scninfo[xndx].outscnndx;
>
>    need_xndx = 1;
>
>  }
>       else
>  {
>    sym->st_shndx = file->scninfo[xndx].outscnndx;
>    xndx = 0;
>  }
>     }
>   else if (sym->st_shndx == 0xfff2 || sym->st_shndx == 0)
>     {
>
>
>
>       ((cnt >= file->nlocalsymbols) ? (void) (0) : __assert_fail ("cnt >= file->nlocalsymbols", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5317, __PRETTY_FUNCTION__));
>       defp = file->symref[cnt];
>       ((defp != ((void *)0)) ? (void) (0) : __assert_fail ("defp != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5319, __PRETTY_FUNCTION__));
>
>       ((sym->st_shndx != 0xfff2 || defp->defined) ? (void) (0) : __assert_fail ("sym->st_shndx != 0xfff2 || defp->defined", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5321, __PRETTY_FUNCTION__));
>
>       if ((sym->st_shndx == 0xfff2 && !defp->common)
>    || (sym->st_shndx == 0 && defp->defined)
>    || defp->added)
>
>
>  continue;
>
>
>       defp->added = 1;
>
>
>       if (sym->st_shndx == 0xfff2)
>  {
>    sym->st_value = (ld_state.common_section->offset
>       + file->symref[cnt]->merge.value);
>    ((ld_state.common_section->outscnndx < 0xff00) ? (void) (0) : __assert_fail ("ld_state.common_section->outscnndx < 0xff00", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5338, __PRETTY_FUNCTION__));
>    sym->st_shndx = ld_state.common_section->outscnndx;
>    xndx = 0;
>  }
>     }
>   else if (__builtin_expect (!!(sym->st_shndx != 0xfff1), 0))
>     {
>       if ((_dl_mcount_wrapper_check ((void *) ((&ld_state)->callbacks.special_section_number_p)), (*((&ld_state)->callbacks.special_section_number_p)) (&ld_state, sym->st_shndx)))
>
>
>  abort ();
>     }
>
>
>
>
>   if (sym->st_name != 0
>       && (ld_state.strip < strip_everything
>    || (((unsigned char) (sym->st_info)) >> 4) != 0))
>     symstrent[nsym] = ebl_strtabadd (strtab,
>          elf_strptr (file->elf,
>        file->symstridx,
>        sym->st_name), 0);
>
>
>
>
>   GElf_Word st_name = sym->st_name;
>   sym->st_name = 0;
>
>
>
>   if (file->has_merge_sections && file->symref[cnt] != ((void *)0)
>       && file->symref[cnt]->merged)
>     sym->st_value = file->symref[cnt]->merge.value;
>
>
>   ((nsym < nsym_allocated) ? (void) (0) : __assert_fail ("nsym < nsym_allocated", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5375, __PRETTY_FUNCTION__));
>   gelf_update_symshndx (symdata, xndxdata, nsym, sym, xndx);
>
>
>
>
>   if (defp == ((void *)0) && cnt >= file->nlocalsymbols)
>     {
>       defp = file->symref[cnt];
>
>       if (defp == ((void *)0))
>  {
>
>
>
>
>
>    struct symbol search;
>    search.name = elf_strptr (file->elf, file->symstridx,
>         st_name);
>    struct symbol *realp
>      = ld_symbol_tab_find (&ld_state.symbol_tab,
>       elf_hash (search.name), &search);
>    if (realp == ((void *)0))
>
>      error (1, 0,
>      "couldn't find symbol from COMDAT section");
>
>    file->symref[cnt] = realp;
>
>    continue;
>  }
>     }
>
>
>
>   ndxtosym[nsym] = defp;
>
>
>   if (cnt >= file->nlocalsymbols)
>     {
>       ((file->symref[cnt]->outsymidx == 0) ? (void) (0) : __assert_fail ("file->symref[cnt]->outsymidx == 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5416, __PRETTY_FUNCTION__));
>       file->symref[cnt]->outsymidx = nsym;
>     }
>   file->symindirect[cnt] = nsym++;
> }
>    }
>  while ((file = file->next) != ld_state.relfiles->next);
>
>
>  ((xndxdata == ((void *)0) || need_xndx) ? (void) (0) : __assert_fail ("xndxdata == ((void *)0) || need_xndx", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5425, __PRETTY_FUNCTION__));
>
>
>  if (ld_state.verneedscnidx != 0)
>    {
>
>
>
>
>      struct usedfiles *runp;
>
>      runp = ld_state.dsofiles->next;
>      do
> allocate_version_names (runp, dynstrtab);
>      while ((runp = runp->next) != ld_state.dsofiles->next);
>
>      if (ld_state.needed != ((void *)0))
> {
>   runp = ld_state.needed->next;
>   do
>     allocate_version_names (runp, dynstrtab);
>   while ((runp = runp->next) != ld_state.needed->next);
> }
>    }
>
>
>  if (ld_state.default_bind_local || ld_state.version_str_tab.filled > 0)
>
>
>    {
>
>      _Bool any_reduced = 0;
>
>      for (cnt = 1; cnt < nsym; ++cnt)
> {
>   GElf_Sym sym_mem; GElf_Sym *sym;
>
>
>
>   sym = gelf_getsym (symdata, cnt, &sym_mem);
>   ((sym != ((void *)0)) ? (void) (0) : __assert_fail ("sym != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5465, __PRETTY_FUNCTION__));
>
>   if (reduce_symbol_p (sym, symstrent[cnt]))
>     {
>
>       ((ndxtosym[cnt]->outdynsymidx != 0) ? (void) (0) : __assert_fail ("ndxtosym[cnt]->outdynsymidx != 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5470, __PRETTY_FUNCTION__));
>       ndxtosym[cnt]->outdynsymidx = 0;
>
>       sym->st_info = ((((0)) << 4) + (((((sym->st_info) & 0xf))) & 0xf));
>
>       (void) gelf_update_sym (symdata, cnt, sym);
>
>
>       if (ld_state.strip == strip_everything)
>  {
>    symstrent[cnt] = ((void *)0);
>    any_reduced = 1;
>  }
>     }
> }
>
>      if (__builtin_expect (!!(any_reduced), 0))
> {
>
>
>
>
>   struct Ebl_Strtab *newp = ebl_strtabinit (1);
>
>   for (cnt = 1; cnt < nsym; ++cnt)
>     if (symstrent[cnt] != ((void *)0))
>       symstrent[cnt] = ebl_strtabadd (newp,
>           ebl_string (symstrent[cnt]), 0);
>
>   ebl_strtabfree (strtab);
>   strtab = newp;
> }
>    }
>
>
>
>
>  if (ld_state.from_dso != ((void *)0))
>    {
>      struct symbol *runp;
>      size_t plt_base = nsym + ld_state.nfrom_dso - ld_state.nplt;
>      size_t plt_idx = 0;
>      size_t obj_idx = 0;
>
>      ((ld_state.nfrom_dso >= ld_state.nplt) ? (void) (0) : __assert_fail ("ld_state.nfrom_dso >= ld_state.nplt", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5514, __PRETTY_FUNCTION__));
>      runp = ld_state.from_dso;
>      do
> {
>
>
>   size_t idx;
>   if (runp->type == 2)
>     {
>
>       runp->merge.value = plt_idx + 1;
>       idx = plt_base + plt_idx++;
>     }
>   else
>     idx = nsym + obj_idx++;
>
>   GElf_Sym sym_mem; GElf_Sym *sym;
>   sym = &sym_mem;
>
>   sym->st_value = 0;
>   sym->st_size = runp->size;
>   sym->st_info = ((((runp->weak ? 2 : 1)) << 4) + (((runp->type)) & 0xf));
>
>   sym->st_other = 0;
>   sym->st_shndx = 0;
>
>
>   gelf_update_symshndx (symdata, xndxdata, idx, sym, 0);
>
>   const char *name = runp->name;
>   size_t namelen = 0;
>
>   if (runp->file->verdefdata != ((void *)0))
>     {
>
>       GElf_Versym versym;
>
>       (void) gelf_getversym (runp->file->versymdata, runp->symidx, &versym);
>
>
>
>       (((versym & 0x8000) == 0) ? (void) (0) : __assert_fail ("(versym & 0x8000) == 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5555, __PRETTY_FUNCTION__));
>
>       const char *versname
>  = ebl_string (runp->file->verdefent[versym]);
>
>       size_t versname_len = strlen (versname) + 1;
>       namelen = strlen (name) + versname_len + 2;
>       char *newp = (char *) __extension__ ({ struct obstack *__h = (&ld_state.smem); __extension__ ({ struct obstack *__o = (__h); int __len = ((namelen)); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len)); (void) 0; }); __extension__ ({ struct obstack *__o1 = (__h); void *__value = (void *) __o1->object_base; if (__o1->next_free == __value) __o1->maybe_empty_object = 1; __o1->next_free = ((sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof (int) < sizeof (void *) ? (__o1->object_base) : (char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask))); if (__o1->next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit; __o1->object_base = __o1->next_free; __value; }); });
>       memcpy (__builtin_stpcpy (__builtin_stpcpy (newp, name), "@@"),
>        versname, versname_len);
>       name = newp;
>     }
>
>   symstrent[idx] = ebl_strtabadd (strtab, name, namelen);
>
>
>   runp->outsymidx = idx;
>
>
>   ndxtosym[idx] = runp;
> }
>      while ((runp = runp->next) != ld_state.from_dso);
>
>      ((nsym + obj_idx == plt_base) ? (void) (0) : __assert_fail ("nsym + obj_idx == plt_base", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5578, __PRETTY_FUNCTION__));
>      ((plt_idx == ld_state.nplt) ? (void) (0) : __assert_fail ("plt_idx == ld_state.nplt", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5579, __PRETTY_FUNCTION__));
>      nsym = plt_base + plt_idx;
>    }
>
>
>
>  symdata->d_size = gelf_fsize (ld_state.outelf, ELF_T_SYM, nsym, 1);
>  if (__builtin_expect (!!(xndxdata != ((void *)0)), 0))
>    xndxdata->d_size = gelf_fsize (ld_state.outelf, ELF_T_WORD, nsym, 1);
>
>
>  strscn = elf_newscn (ld_state.outelf);
>  ld_state.strscnidx = elf_ndxscn (strscn);
>  data = elf_newdata (strscn);
>  shdr = gelf_getshdr (strscn, &shdr_mem);
>  if (data == ((void *)0) || shdr == ((void *)0))
>    error (1, 0,
>    dcgettext (((void *)0), "cannot create section for output file: %s", __LC_MESSAGES),
>    elf_errmsg (-1));
>
>
>
>  ebl_strtabfinalize (strtab, data);
>
>  shdr->sh_type = 3;
>  ((shdr->sh_entsize == 0) ? (void) (0) : __assert_fail ("shdr->sh_entsize == 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5604, __PRETTY_FUNCTION__));
>
>  if (__builtin_expect (!!(gelf_update_shdr (strscn, shdr) == 0), 0))
>    error (1, 0,
>    dcgettext (((void *)0), "cannot create section for output file: %s", __LC_MESSAGES),
>    elf_errmsg (-1));
>
>
>  for (cnt = 1; cnt < nsym; ++cnt)
>    if (symstrent[cnt] != ((void *)0))
>      {
> GElf_Sym sym_mem; GElf_Sym *sym;
>
>
>
> sym = gelf_getsym (symdata, cnt, &sym_mem);
>
> ((sym != ((void *)0)) ? (void) (0) : __assert_fail ("sym != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5621, __PRETTY_FUNCTION__));
> sym->st_name = ebl_strtaboffset (symstrent[cnt]);
> (void) gelf_update_sym (symdata, cnt, sym);
>      }
>
>
>
>
>
>
>  ld_state.dblindirect = dblindirect
>    = (Elf32_Word *) xmalloc (nsym * sizeof (Elf32_Word));
>
>
>
>
>
>  nsym_local = 1;
>  cnt = nsym - 1;
>  while (nsym_local < cnt)
>    {
>      GElf_Sym locsym_mem; GElf_Sym *locsym;
>      Elf32_Word locxndx;
>      GElf_Sym globsym_mem; GElf_Sym *globsym;
>      Elf32_Word globxndx;
>
>      do
> {
>   locsym = gelf_getsymshndx (symdata, xndxdata, nsym_local, &locsym_mem, &(locxndx));
>
>   ((locsym != ((void *)0)) ? (void) (0) : __assert_fail ("locsym != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5651, __PRETTY_FUNCTION__));
>
>   if ((((unsigned char) (locsym->st_info)) >> 4) != 0
>       && (ld_state.need_symtab || ld_state.export_all_dynamic))
>     {
>       do
>  {
>    globsym = gelf_getsymshndx (symdata, xndxdata, cnt, &globsym_mem, &(globxndx));
>
>    ((globsym != ((void *)0)) ? (void) (0) : __assert_fail ("globsym != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5660, __PRETTY_FUNCTION__));
>
>    if (__builtin_expect (!!((((unsigned char) (globsym->st_info)) >> 4) == 0), 0))
>      {
># 5672 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c"
>        gelf_update_symshndx (symdata, xndxdata, nsym_local, globsym, globxndx);
>
>        gelf_update_symshndx (symdata, xndxdata, cnt, locsym, locxndx);
>
>
>
>        dblindirect[nsym_local] = cnt;
>        dblindirect[cnt] = nsym_local;
>
>
>        struct Ebl_Strent *strtmp = symstrent[nsym_local];
>        symstrent[nsym_local] = symstrent[cnt];
>        symstrent[cnt] = strtmp;
>
>
>
>        struct symbol *symtmp = ndxtosym[nsym_local];
>        ndxtosym[nsym_local] = ndxtosym[cnt];
>        ndxtosym[cnt] = symtmp;
>
>
>        ++nsym_local;
>        --cnt;
>
>        break;
>      }
>
>    dblindirect[cnt] = cnt;
>  }
>       while (nsym_local < --cnt);
>
>       break;
>     }
>
>   dblindirect[nsym_local] = nsym_local;
> }
>      while (++nsym_local < cnt);
>    }
>
>
>
>  if (__builtin_expect (!!(nsym_local < nsym), 1))
>    {
>      GElf_Sym locsym_mem; GElf_Sym *locsym;
>
>
>      dblindirect[nsym_local] = nsym_local;
>
>
>      locsym = gelf_getsym (symdata, nsym_local, &locsym_mem);
>
>      ((locsym != ((void *)0)) ? (void) (0) : __assert_fail ("locsym != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5723, __PRETTY_FUNCTION__));
>
>      if ((((unsigned char) (locsym->st_info)) >> 4) == 0)
> ++nsym_local;
>    }
>
>
>
>
>  if (ld_state.versymscnidx != 0)
>    {
>
>
>
>      versymscn = elf_getscn (ld_state.outelf, ld_state.versymscnidx);
>      versymdata = elf_newdata (versymscn);
>      if (versymdata == ((void *)0))
> error (1, 0,
>        dcgettext (((void *)0), "cannot create versioning section: %s", __LC_MESSAGES),
>        elf_errmsg (-1));
>
>      versymdata->d_size = gelf_fsize (ld_state.outelf, ELF_T_HALF, nsym - nsym_local + 1, 1);
>
>      versymdata->d_buf = xcalloc (1, versymdata->d_size);
>      versymdata->d_align = gelf_fsize (ld_state.outelf, ELF_T_HALF, 1, 1);
>      versymdata->d_off = 0;
>      versymdata->d_type = ELF_T_HALF;
>    }
>
>
>
>
>
>
>  if (__builtin_expect (!!(!ld_state.need_symtab), 0))
>    {
>
>
>      size_t reduce = gelf_fsize (ld_state.outelf, ELF_T_SYM, nsym_local - 1, 1);
>
>      GElf_Sym nullsym_mem; GElf_Sym *nullsym;
>      nullsym = &nullsym_mem;
>
>
>
>      (void) gelf_update_sym (symdata, nsym_local - 1, memset (nullsym, '\0', sizeof (*nullsym)));
>
>
>
>      symdata->d_buf = (char *) symdata->d_buf + reduce;
>      symdata->d_size -= reduce;
>
>
>      if (versymdata != ((void *)0))
> {
>   nsym_dyn = 1;
>   for (cnt = nsym_local; cnt < nsym; ++cnt, ++nsym_dyn)
>     {
>       struct symbol *symp = ndxtosym[cnt];
>
>       if (symp->file->versymdata != ((void *)0))
>  {
>    GElf_Versym versym;
>
>    gelf_getversym (symp->file->versymdata, symp->symidx,
>      &versym);
>
>    (void) gelf_update_versym (versymdata, symp->outdynsymidx,
>          &symp->file->verdefused[versym]);
>  }
>       }
> }
>
>
>
>      nsym_dyn = nsym - nsym_local + 1;
>
>
>      abort ();
>    }
>  else if (ld_state.need_dynsym)
>    {
>
>
>
>      dynsymscn = elf_getscn (ld_state.outelf, ld_state.dynsymscnidx);
>      dynsymdata = elf_newdata (dynsymscn);
>
>      dynstrdata = elf_newdata (elf_getscn (ld_state.outelf,
>         ld_state.dynstrscnidx));
>      if (dynsymdata == ((void *)0) || dynstrdata == ((void *)0))
> error (1, 0, dcgettext (((void *)0), "cannot create dynamic symbol table for output file: %s", __LC_MESSAGES),
>
>        elf_errmsg (-1));
>
>      nsym_dyn_allocated = nsym - nsym_local + 1;
>      dynsymdata->d_size = gelf_fsize (ld_state.outelf, ELF_T_SYM, nsym_dyn_allocated, 1);
>
>      dynsymdata->d_buf = memset (xmalloc (dynsymdata->d_size), '\0',
>      gelf_fsize (ld_state.outelf, ELF_T_SYM, 1, 1));
>      dynsymdata->d_type = ELF_T_SYM;
>      dynsymdata->d_off = 0;
>      dynsymdata->d_align = gelf_fsize (ld_state.outelf, ELF_T_ADDR, 1, 1);
>
>
>
>      hashcodes = (Elf32_Word *) xcalloc (__builtin_popcount ((int) ld_state.hash_style)
>       * nsym_dyn_allocated,
>       sizeof (Elf32_Word));
>      gnuhashcodes = hashcodes;
>      if (((ld_state.hash_style & hash_style_sysv) != 0))
> gnuhashcodes += nsym_dyn_allocated;
>
>
>      nsym_dyn = 1;
>
>
>      for (cnt = nsym_local; cnt < nsym; ++cnt)
> {
>   GElf_Sym sym_mem; GElf_Sym *sym;
>
>   sym = gelf_getsym (symdata, cnt, &sym_mem);
>   ((sym != ((void *)0)) ? (void) (0) : __assert_fail ("sym != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5845, __PRETTY_FUNCTION__));
>
>   if (sym->st_shndx == 0xffff)
>     error (1, 0, dcgettext (((void *)0), "section index too large in dynamic symbol table", __LC_MESSAGES));
># 5860 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c"
>   if (((sym->st_info) & 0xf) == 4
>       || ((sym->st_other) & 0x03) == 1
>       || ((sym->st_other) & 0x03) == 2
>       || (!ld_state.export_all_dynamic
>    && !ndxtosym[cnt]->in_dso && ndxtosym[cnt]->defined))
>     {
>       symstrent[cnt] = ((void *)0);
>       continue;
>     }
>
>
>
>
>   ndxtosym[cnt]->outdynsymidx = nsym_dyn;
>
>
>   const char *str = ndxtosym[cnt]->name;
>   symstrent[cnt] = ebl_strtabadd (dynstrtab, str, 0);
>   if (((ld_state.hash_style & hash_style_sysv) != 0))
>     hashcodes[nsym_dyn] = elf_hash (str);
>   if (((ld_state.hash_style & hash_style_gnu) != 0))
>     gnuhashcodes[nsym_dyn] = elf_gnu_hash (str);
>   ++nsym_dyn;
> }
>
>      if (ld_state.file_type != relocatable_file_type)
> {
>
>   ebl_strtabfinalize (dynstrtab, dynstrdata);
>
>   ((ld_state.hashscnidx != 0 || ld_state.gnuhashscnidx != 0) ? (void) (0) : __assert_fail ("ld_state.hashscnidx != 0 || ld_state.gnuhashscnidx != 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5890, __PRETTY_FUNCTION__));
>
>
>   if (((ld_state.hash_style & hash_style_gnu) != 0))
>     create_gnu_hash (nsym_local, nsym, nsym_dyn, gnuhashcodes);
>
>
>
>
>   if (((ld_state.hash_style & hash_style_sysv) != 0))
>     create_hash (nsym_local, nsym, nsym_dyn, hashcodes);
> }
>
>
>      if (versymdata != ((void *)0))
> for (cnt = nsym_local; cnt < nsym; ++cnt)
>   if (symstrent[cnt] != ((void *)0))
>     {
>       struct symbol *symp = ndxtosym[cnt];
>
>
>
>       if (symp->file != ((void *)0) && symp->file->verdefdata != ((void *)0))
>  {
>    GElf_Versym versym;
>
>    gelf_getversym (symp->file->versymdata, symp->symidx,
>      &versym);
>
>    (void) gelf_update_versym (versymdata, symp->outdynsymidx,
>          &symp->file->verdefused[versym]);
>  }
>       else
>  {
>
>    GElf_Versym global = 1;
>    (void) gelf_update_versym (versymdata, nsym_dyn, &global);
>  }
>     }
>
>
>      if (versymdata != ((void *)0))
> {
>
>
>   versymdata->d_size = gelf_fsize (ld_state.outelf, ELF_T_HALF, nsym_dyn, 1);
>
>
>
>   shdr = gelf_getshdr (versymscn, &shdr_mem);
>   ((shdr != ((void *)0)) ? (void) (0) : __assert_fail ("shdr != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5940, __PRETTY_FUNCTION__));
>
>   shdr->sh_link = ld_state.dynsymscnidx;
>
>   (void) gelf_update_shdr (versymscn, shdr);
> }
>    }
>
>  if (ld_state.file_type != relocatable_file_type)
>    {
>
>      for (cnt = nsym_local; cnt < nsym; ++cnt)
> if (symstrent[cnt] != ((void *)0))
>   {
>     GElf_Sym sym_mem; GElf_Sym *sym;
>     size_t dynidx = ndxtosym[cnt]->outdynsymidx;
>
>
>
>
>
>
>
>     sym = gelf_getsym (symdata, cnt, &sym_mem);
>     ((sym != ((void *)0)) ? (void) (0) : __assert_fail ("sym != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 5964, __PRETTY_FUNCTION__));
>
>
>     sym->st_name = ebl_strtaboffset (symstrent[cnt]);
>
>     (void) gelf_update_sym (dynsymdata, dynidx, sym);
>   }
>
>      free (hashcodes);
>
>
>      if (ld_state.verneedscnidx != 0)
> {
>   Elf_Scn *verneedscn;
>   Elf_Data *verneeddata;
>   struct usedfiles *runp;
>   size_t verneed_size = gelf_fsize (ld_state.outelf, ELF_T_VNEED, 1, 1);
>   size_t vernaux_size = gelf_fsize (ld_state.outelf, ELF_T_VNAUX, 1, 1);
>   size_t offset;
>   int ntotal;
>
>   verneedscn = elf_getscn (ld_state.outelf, ld_state.verneedscnidx);
>   shdr = gelf_getshdr (verneedscn, &shdr_mem);
>   verneeddata = elf_newdata (verneedscn);
>   if (shdr == ((void *)0) || verneeddata == ((void *)0))
>     error (1, 0,
>     dcgettext (((void *)0), "cannot create versioning data: %s", __LC_MESSAGES),
>     elf_errmsg (-1));
>
>   verneeddata->d_size = (ld_state.nverdeffile * verneed_size
>     + ld_state.nverdefused * vernaux_size);
>   verneeddata->d_buf = xmalloc (verneeddata->d_size);
>   verneeddata->d_type = ELF_T_VNEED;
>   verneeddata->d_align = gelf_fsize (ld_state.outelf, ELF_T_WORD, 1, 1);
>   verneeddata->d_off = 0;
>
>   offset = 0;
>   ntotal = ld_state.nverdeffile;
>   runp = ld_state.dsofiles->next;
>   do
>     {
>       offset = create_verneed_data (offset, verneeddata, runp,
>         &ntotal);
>       runp = runp->next;
>     }
>   while (ntotal > 0 && runp != ld_state.dsofiles->next);
>
>   if (ntotal > 0)
>     {
>       runp = ld_state.needed->next;
>       do
>  {
>    offset = create_verneed_data (offset, verneeddata, runp,
>      &ntotal);
>    runp = runp->next;
>  }
>       while (ntotal > 0 && runp != ld_state.needed->next);
>     }
>
>   ((offset == verneeddata->d_size) ? (void) (0) : __assert_fail ("offset == verneeddata->d_size", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6023, __PRETTY_FUNCTION__));
>
>
>   shdr->sh_link = ld_state.dynstrscnidx;
>   shdr->sh_info = ld_state.nverdeffile;
>   (void) gelf_update_shdr (verneedscn, shdr);
> }
>
>
>      dynsymdata->d_size = gelf_fsize (ld_state.outelf, ELF_T_SYM, nsym_dyn, 1);
>      if (versymdata != ((void *)0))
> versymdata->d_size = gelf_fsize (ld_state.outelf, ELF_T_HALF, nsym_dyn, 1);
>
>
>
>      shdr = gelf_getshdr (dynsymscn, &shdr_mem);
>
>      shdr->sh_info = 1;
>
>      shdr->sh_link = ld_state.dynstrscnidx;
>
>      (void) gelf_update_shdr (dynsymscn, shdr);
>    }
>
>
>  free (symstrent);
>
>
>  ld_state.ndynsym = nsym_dyn;
>
>
>  symscn = elf_getscn (ld_state.outelf, ld_state.symscnidx);
>  shdr = gelf_getshdr (symscn, &shdr_mem);
>  if (shdr == ((void *)0))
>    error (1, 0,
>    dcgettext (((void *)0), "cannot create symbol table for output file: %s", __LC_MESSAGES),
>    elf_errmsg (-1));
>
>  shdr->sh_type = 2;
>  shdr->sh_link = ld_state.strscnidx;
>  shdr->sh_info = nsym_local;
>  shdr->sh_entsize = gelf_fsize (ld_state.outelf, ELF_T_SYM, 1, 1);
>
>  (void) gelf_update_shdr (symscn, shdr);
>
>
>
>  if (ld_state.symscnidx != 0)
>      symtab_ent = ebl_strtabadd (ld_state.shstrtab, ".symtab", 8);
>  if (ld_state.xndxscnidx != 0)
>    xndx_ent = ebl_strtabadd (ld_state.shstrtab, ".symtab_shndx", 14);
>  if (ld_state.strscnidx != 0)
>    strtab_ent = ebl_strtabadd (ld_state.shstrtab, ".strtab", 8);
># 6086 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c"
>  shstrtab_scn = elf_newscn (ld_state.outelf);
>  shstrtab_ndx = elf_ndxscn (shstrtab_scn);
>  if (__builtin_expect (!!(shstrtab_ndx == 0), 0))
>    error (1, 0,
>    dcgettext (((void *)0), "cannot create section header string section: %s", __LC_MESSAGES),
>    elf_errmsg (-1));
>
>
>  shstrtab_ent = ebl_strtabadd (ld_state.shstrtab, ".shstrtab", 10);
>  if (__builtin_expect (!!(shstrtab_ent == ((void *)0)), 0))
>    error (1, (*__errno_location ()),
>    dcgettext (((void *)0), "cannot create section header string section", __LC_MESSAGES));
>
>
>  data = elf_newdata (shstrtab_scn);
>  if (data == ((void *)0))
>    error (1, 0,
>    dcgettext (((void *)0), "cannot create section header string section: %s", __LC_MESSAGES),
>    elf_errmsg (-1));
>  ebl_strtabfinalize (ld_state.shstrtab, data);
>
>
>  for (cnt = 0; cnt < ld_state.nallsections; ++cnt)
>    if (ld_state.allsections[cnt]->scnidx != 0)
>      {
> Elf_Scn *scn;
>
> scn = elf_getscn (ld_state.outelf, ld_state.allsections[cnt]->scnidx);
>
> shdr = gelf_getshdr (scn, &shdr_mem);
> ((shdr != ((void *)0)) ? (void) (0) : __assert_fail ("shdr != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6116, __PRETTY_FUNCTION__));
>
> shdr->sh_name = ebl_strtaboffset (ld_state.allsections[cnt]->nameent);
>
> if (gelf_update_shdr (scn, shdr) == 0)
>   ((0) ? (void) (0) : __assert_fail ("0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6121, __PRETTY_FUNCTION__));
>      }
>
>
>
>  if (symtab_ent != ((void *)0))
>    {
>      Elf_Scn *scn = elf_getscn (ld_state.outelf, ld_state.symscnidx);
>
>      shdr = gelf_getshdr (scn, &shdr_mem);
>
>      ((shdr != ((void *)0)) ? (void) (0) : __assert_fail ("shdr != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6132, __PRETTY_FUNCTION__));
>
>      shdr->sh_name = ebl_strtaboffset (symtab_ent);
>
>      (void) gelf_update_shdr (scn, shdr);
>    }
>  if (xndx_ent != ((void *)0))
>    {
>      Elf_Scn *scn = elf_getscn (ld_state.outelf, ld_state.xndxscnidx);
>
>      shdr = gelf_getshdr (scn, &shdr_mem);
>
>      ((shdr != ((void *)0)) ? (void) (0) : __assert_fail ("shdr != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6144, __PRETTY_FUNCTION__));
>
>      shdr->sh_name = ebl_strtaboffset (xndx_ent);
>
>      (void) gelf_update_shdr (scn, shdr);
>    }
>  if (strtab_ent != ((void *)0))
>    {
>      Elf_Scn *scn = elf_getscn (ld_state.outelf, ld_state.strscnidx);
>
>      shdr = gelf_getshdr (scn, &shdr_mem);
>
>      ((shdr != ((void *)0)) ? (void) (0) : __assert_fail ("shdr != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6156, __PRETTY_FUNCTION__));
>
>      shdr->sh_name = ebl_strtaboffset (strtab_ent);
>
>      (void) gelf_update_shdr (scn, shdr);
>    }
>
>
>  shdr = gelf_getshdr (shstrtab_scn, &shdr_mem);
>  if (shdr == ((void *)0))
>    error (1, 0,
>    dcgettext (((void *)0), "cannot create section header string section: %s", __LC_MESSAGES),
>    elf_errmsg (-1));
>
>  shdr->sh_name = ebl_strtaboffset (shstrtab_ent);
>  shdr->sh_type = 3;
>
>  if (__builtin_expect (!!(gelf_update_shdr (shstrtab_scn, shdr) == 0), 0))
>    error (1, 0,
>    dcgettext (((void *)0), "cannot create section header string section: %s", __LC_MESSAGES),
>    elf_errmsg (-1));
>
>
>
>  groups = ld_state.groups;
>  while (groups != ((void *)0))
>    {
>      Elf_Scn *scn = elf_getscn (ld_state.outelf, groups->outscnidx);
>      shdr = gelf_getshdr (scn, &shdr_mem);
>      ((shdr != ((void *)0)) ? (void) (0) : __assert_fail ("shdr != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6185, __PRETTY_FUNCTION__));
>
>      shdr->sh_name = ebl_strtaboffset (groups->nameent);
>      shdr->sh_type = 17;
>      shdr->sh_flags = 0;
>      shdr->sh_link = ld_state.symscnidx;
>      shdr->sh_entsize = sizeof (Elf32_Word);
>
>
>      Elf32_Word si
> = groups->symbol->file->symindirect[groups->symbol->symidx];
>      if (si == 0)
> {
>   ((groups->symbol->file->symref[groups->symbol->symidx] != ((void *)0)) ? (void) (0) : __assert_fail ("groups->symbol->file->symref[groups->symbol->symidx] != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6199, __PRETTY_FUNCTION__));
>
>   si = groups->symbol->file->symref[groups->symbol->symidx]->outsymidx;
>   ((si != 0) ? (void) (0) : __assert_fail ("si != 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6201, __PRETTY_FUNCTION__));
> }
>      shdr->sh_info = ld_state.dblindirect[si];
>
>      (void) gelf_update_shdr (scn, shdr);
>
>      struct scngroup *oldp = groups;
>      groups = groups->next;
>      free (oldp);
>    }
>
>
>  if (ld_state.file_type != relocatable_file_type)
>    {
>
>
>
>
>
>
>
>      size_t nphdr = 0;
>
>
>      ++nphdr;
>
>      struct output_segment *segment = ld_state.output_segments;
>      while (segment != ((void *)0))
> {
>   ++nphdr;
>   segment = segment->next;
> }
>
>
>      nphdr += ld_state.nnotesections;
>
>
>
>
>      if (dynamically_linked_p ())
> {
>   ++nphdr;
>
>   if (ld_state.interp != ((void *)0) || ld_state.file_type != dso_file_type)
>     nphdr += 2;
> }
>
>
>      if (ld_state.need_tls)
> ++nphdr;
>
>
>      GElf_Phdr phdr_mem; GElf_Phdr *phdr;
>      if (gelf_newphdr (ld_state.outelf, nphdr) == 0)
> error (1, 0, dcgettext (((void *)0), "cannot create program header: %s", __LC_MESSAGES),
>        elf_errmsg (-1));
>
>
>
>
>
>      if (elf_update (ld_state.outelf, ELF_C_NULL) == -1)
> error (1, 0, dcgettext (((void *)0), "while determining file layout: %s", __LC_MESSAGES),
>        elf_errmsg (-1));
>
>
>
>
>      Elf32_Word nsec = 0;
>      Elf_Scn *scn = elf_getscn (ld_state.outelf,
>     ld_state.allsections[nsec]->scnidx);
>      shdr = gelf_getshdr (scn, &shdr_mem);
>      ((shdr != ((void *)0)) ? (void) (0) : __assert_fail ("shdr != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6273, __PRETTY_FUNCTION__));
>
>
>
>      GElf_Addr addr = shdr->sh_offset;
>      GElf_Addr tls_offset = 0;
>      GElf_Addr tls_start = ~((GElf_Addr) 0);
>      GElf_Addr tls_end = 0;
>      GElf_Off tls_filesize = 0;
>      GElf_Addr tls_align = 0;
>
>
>      nphdr = 0;
>      if (dynamically_linked_p ())
> {
>   ++nphdr;
>   if (ld_state.interp != ((void *)0)
>       || ld_state.file_type != dso_file_type)
>     nphdr += 2;
> }
>
>      segment = ld_state.output_segments;
>      while (segment != ((void *)0))
> {
>   struct output_rule *orule;
>   _Bool first_section = 1;
>   GElf_Off nobits_size = 0;
>   GElf_Off memsize = 0;
>
>
>   segment->align = ld_state.pagesize;
>
>   for (orule = segment->output_rules; orule != ((void *)0);
>        orule = orule->next)
>     if (orule->tag == output_section)
>       {
>
>
>  if (ld_state.allsections[nsec]->name
>      != orule->val.section.name)
>
>    continue;
>
>
>
>  if (segment->mode != 0)
>    {
>
>      struct scninfo *isect;
>      struct scninfo *first;
>
>      isect = first = ld_state.allsections[nsec]->last;
>      if (isect != ((void *)0))
>        do
>   isect->offset += addr;
>        while ((isect = isect->next) != first);
>
>
>      shdr->sh_addr = addr;
>
>
>      (void) gelf_update_shdr (scn, shdr);
>
>
>      ld_state.allsections[nsec]->addr = addr;
>
>
>      if (__builtin_expect (!!(shdr->sh_flags & (1 << 10)), 0))
>        {
>   if (tls_start > addr)
>     {
>       tls_start = addr;
>       tls_offset = shdr->sh_offset;
>     }
>   if (tls_end < addr + shdr->sh_size)
>     tls_end = addr + shdr->sh_size;
>   if (shdr->sh_type != 8)
>     tls_filesize += shdr->sh_size;
>   if (shdr->sh_addralign > tls_align)
>     tls_align = shdr->sh_addralign;
>        }
>    }
>
>  if (first_section)
>    {
>
>      if (segment == ld_state.output_segments)
>        {
>   segment->offset = 0;
>   segment->addr = addr - shdr->sh_offset;
>        }
>      else
>        {
>   segment->offset = shdr->sh_offset;
>   segment->addr = addr;
>        }
>
>
>      segment->align = (((segment->align)>(shdr->sh_addralign))?(segment->align):(shdr->sh_addralign));
>
>      first_section = 0;
>    }
>
>
>
>  if (shdr->sh_type != 8
>      || (shdr->sh_flags & (1 << 10)) == 0)
>    {
>      memsize = (shdr->sh_offset - segment->offset
>          + shdr->sh_size);
>      if (nobits_size != 0 && shdr->sh_type != 7)
>        error (1, 0, dcgettext (((void *)0), "internal error: non-nobits section follows nobits section", __LC_MESSAGES));
>
>      if (shdr->sh_type == 8)
>        nobits_size += shdr->sh_size;
>    }
>
>
>
>
>
>
>
>  GElf_Off oldoff = shdr->sh_offset;
>
>  if (++nsec >= ld_state.nallsections)
>    break;
>
>  scn = elf_getscn (ld_state.outelf,
>      ld_state.allsections[nsec]->scnidx);
>  shdr = gelf_getshdr (scn, &shdr_mem);
>  ((shdr != ((void *)0)) ? (void) (0) : __assert_fail ("shdr != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6404, __PRETTY_FUNCTION__));
>
>
>
>  ((oldoff <= shdr->sh_offset) ? (void) (0) : __assert_fail ("oldoff <= shdr->sh_offset", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6408, __PRETTY_FUNCTION__));
>  addr += shdr->sh_offset - oldoff;
>       }
>     else
>       {
>  ((orule->tag == output_assignment) ? (void) (0) : __assert_fail ("orule->tag == output_assignment", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6413, __PRETTY_FUNCTION__));
>
>  if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (orule->val.assignment->variable) && __builtin_constant_p (".") && (__s1_len = strlen (orule->val.assignment->variable), __s2_len = strlen ("."), (!((size_t)(const void *)((orule->val.assignment->variable) + 1) - (size_t)(const void *)(orule->val.assignment->variable) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((".") + 1) - (size_t)(const void *)(".") == 1) || __s2_len >= 4)) ? __builtin_strcmp (orule->val.assignment->variable, ".") : (__builtin_constant_p (orule->val.assignment->variable) && ((size_t)(const void *)((orule->val.assignment->variable) + 1) - (size_t)(const void *)(orule->val.assignment->variable) == 1) && (__s1_len = strlen (orule->val.assignment->variable), __s1_len < 4) ? (__builtin_constant_p (".") && ((size_t)(const void *)((".") + 1) - (size_t)(const void *)(".") == 1) ? __builtin_strcmp (orule->val.assignment->variable, ".") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("."); register int __result = (((const unsigned char *) (const char *) (orule->val.assignment->variable))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (orule->val.assignment->variable))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (orule->val.assignment->variable))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (orule->val.assignment->variable))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (".") && ((size_t)(const void *)((".") + 1) - (size_t)(const void *)(".") == 1) && (__s2_len = strlen ("."), __s2_len < 4) ? (__builtin_constant_p (orule->val.assignment->variable) && ((size_t)(const void *)((orule->val.assignment->variable) + 1) - (size_t)(const void *)(orule->val.assignment->variable) == 1) ? __builtin_strcmp (orule->val.assignment->variable, ".") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (orule->val.assignment->variable); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("."))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("."))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("."))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("."))[3]); } } __result; }))) : __builtin_strcmp (orule->val.assignment->variable, ".")))); }) == 0)
>
>    addr = eval_expression (orule->val.assignment->expression,
>       addr);
>  else if (orule->val.assignment->sym != ((void *)0))
>    {
>
>
>      GElf_Sym sym_mem; GElf_Sym *sym;
>      size_t idx;
>
>
>
>
>
>      idx = dblindirect[orule->val.assignment->sym->outsymidx];
>      sym = gelf_getsym (symdata, idx, &sym_mem);
>      sym->st_value = addr;
>      (void) gelf_update_sym (symdata, idx, sym);
>
>      idx = orule->val.assignment->sym->outdynsymidx;
>      if (idx != 0)
>        {
>   ((dynsymdata != ((void *)0)) ? (void) (0) : __assert_fail ("dynsymdata != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6438, __PRETTY_FUNCTION__));
>   sym = gelf_getsym (dynsymdata, idx, &sym_mem);
>   sym->st_value = addr;
>   (void) gelf_update_sym (dynsymdata, idx, sym);
>        }
>    }
>       }
>
>
>   if (segment->mode != 0)
>     {
>       phdr = &phdr_mem;
>
>       phdr->p_type = 1;
>       phdr->p_offset = segment->offset;
>       phdr->p_vaddr = segment->addr;
>       phdr->p_paddr = phdr->p_vaddr;
>       phdr->p_filesz = memsize - nobits_size;
>       phdr->p_memsz = memsize;
>       phdr->p_flags = segment->mode;
>       phdr->p_align = segment->align;
>
>       (void) gelf_update_phdr (ld_state.outelf, nphdr, phdr);
>       ++nphdr;
>     }
>
>   segment = segment->next;
> }
>
>
>      ehdr = gelf_getehdr (ld_state.outelf, &ehdr_mem);
>      ((ehdr != ((void *)0)) ? (void) (0) : __assert_fail ("ehdr != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6469, __PRETTY_FUNCTION__));
>
>
>      if (ld_state.need_tls)
> {
>   phdr = &phdr_mem;
>   phdr->p_type = 7;
>   phdr->p_offset = tls_offset;
>   phdr->p_vaddr = tls_start;
>   phdr->p_paddr = tls_start;
>   phdr->p_filesz = tls_filesize;
>   phdr->p_memsz = tls_end - tls_start;
>   phdr->p_flags = (1 << 2);
>   phdr->p_align = tls_align;
>   ld_state.tls_tcb = tls_end;
>   ld_state.tls_start = tls_start;
>
>   (void) gelf_update_phdr (ld_state.outelf, nphdr, phdr);
>   ++nphdr;
> }
>
>
>      phdr = &phdr_mem;
>      phdr->p_type = 0x6474e551;
>      phdr->p_offset = 0;
>      phdr->p_vaddr = 0;
>      phdr->p_paddr = 0;
>      phdr->p_filesz = 0;
>      phdr->p_memsz = 0;
>      phdr->p_flags = ((1 << 2) | (1 << 1)
>         | (ld_state.execstack == execstack_true ? (1 << 0) : 0));
>      phdr->p_align = gelf_fsize (ld_state.outelf, ELF_T_ADDR, 1, 1);
>
>      (void) gelf_update_phdr (ld_state.outelf, nphdr, phdr);
>      ++nphdr;
>
>
>
>
>      if (ld_state.need_symtab)
> for (cnt = 1; cnt < nsym; ++cnt)
>   {
>     GElf_Sym sym_mem; GElf_Sym *sym;
>     Elf32_Word shndx;
>
>     sym = gelf_getsymshndx (symdata, xndxdata, cnt, &sym_mem, &(shndx));
>     ((sym != ((void *)0)) ? (void) (0) : __assert_fail ("sym != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6515, __PRETTY_FUNCTION__));
>
>     if (sym->st_shndx != 0xffff)
>       shndx = sym->st_shndx;
>
>     if ((shndx > 0 && shndx < 0xff00)
>  || shndx > 0xffff)
>       {
>
>
>  sym->st_value += ld_state.allsections[shndx - 1]->addr;
>
>
>
>  (void) gelf_update_sym (symdata, cnt, sym);
>       }
>   }
>
>      if (ld_state.need_dynsym)
> for (cnt = 1; cnt < nsym_dyn; ++cnt)
>   {
>     GElf_Sym sym_mem; GElf_Sym *sym;
>
>     sym = gelf_getsym (dynsymdata, cnt, &sym_mem);
>     ((sym != ((void *)0)) ? (void) (0) : __assert_fail ("sym != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6539, __PRETTY_FUNCTION__));
>
>     if (sym->st_shndx > 0 && sym->st_shndx < 0xff00)
>       {
>
>
>  sym->st_value += ld_state.allsections[sym->st_shndx - 1]->addr;
>
>
>
>  (void) gelf_update_sym (dynsymdata, cnt, sym);
>       }
>   }
>
>
>
>
>
>      struct symbol *se;
>      void *p = ((void *)0);
>      while ((se = ld_symbol_tab_iterate (&ld_state.symbol_tab, &p)) != ((void *)0))
> if (! se->in_dso)
>   {
>     GElf_Sym sym_mem; GElf_Sym *sym;
>
>     addr = 0;
>
>     if (se->outdynsymidx != 0)
>       {
>  sym = gelf_getsym (dynsymdata, se->outdynsymidx, &sym_mem);
>  ((sym != ((void *)0)) ? (void) (0) : __assert_fail ("sym != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6569, __PRETTY_FUNCTION__));
>  addr = sym->st_value;
>       }
>     else if (se->outsymidx != 0)
>       {
>  ((dblindirect[se->outsymidx] != 0) ? (void) (0) : __assert_fail ("dblindirect[se->outsymidx] != 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6574, __PRETTY_FUNCTION__));
>  sym = gelf_getsym (symdata, dblindirect[se->outsymidx], &sym_mem);
>  ((sym != ((void *)0)) ? (void) (0) : __assert_fail ("sym != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6576, __PRETTY_FUNCTION__));
>  addr = sym->st_value;
>       }
>     else
>       abort ();
>
>     se->merge.value = addr;
>   }
>
>
>
>
>
>      if (ld_state.reldynscnidx != 0)
> {
>   ((ld_state.dynsymscnidx != 0) ? (void) (0) : __assert_fail ("ld_state.dynsymscnidx != 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6591, __PRETTY_FUNCTION__));
>   scn = elf_getscn (ld_state.outelf, ld_state.reldynscnidx);
>   shdr = gelf_getshdr (scn, &shdr_mem);
>   ((shdr != ((void *)0)) ? (void) (0) : __assert_fail ("shdr != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6594, __PRETTY_FUNCTION__));
>
>   shdr->sh_link = ld_state.dynsymscnidx;
>
>   (void) gelf_update_shdr (scn, shdr);
> }
>
>
>      if (dynamically_linked_p ())
> {
>   Elf_Scn *outscn;
>
>   int idx = 0;
>   if (ld_state.interp != ((void *)0) || ld_state.file_type != dso_file_type)
>     {
>       ((ld_state.interpscnidx != 0) ? (void) (0) : __assert_fail ("ld_state.interpscnidx != 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6609, __PRETTY_FUNCTION__));
>       shdr = gelf_getshdr (elf_getscn (ld_state.outelf, ld_state.interpscnidx), &shdr_mem);
>
>       ((shdr != ((void *)0)) ? (void) (0) : __assert_fail ("shdr != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6612, __PRETTY_FUNCTION__));
>
>       phdr = &phdr_mem;
>       phdr->p_type = 6;
>       phdr->p_offset = ehdr->e_phoff;
>       phdr->p_vaddr = ld_state.output_segments->addr + phdr->p_offset;
>       phdr->p_paddr = phdr->p_vaddr;
>       phdr->p_filesz = ehdr->e_phnum * ehdr->e_phentsize;
>       phdr->p_memsz = phdr->p_filesz;
>       phdr->p_flags = 0;
>       phdr->p_align = gelf_fsize (ld_state.outelf, ELF_T_ADDR, 1, 1);
>
>       (void) gelf_update_phdr (ld_state.outelf, idx, phdr);
>       ++idx;
>
>
>       phdr = &phdr_mem;
>       phdr->p_type = 3;
>       phdr->p_offset = shdr->sh_offset;
>       phdr->p_vaddr = shdr->sh_addr;
>       phdr->p_paddr = phdr->p_vaddr;
>       phdr->p_filesz = shdr->sh_size;
>       phdr->p_memsz = phdr->p_filesz;
>       phdr->p_flags = 0;
>       phdr->p_align = 1;
>
>       (void) gelf_update_phdr (ld_state.outelf, idx, phdr);
>       ++idx;
>     }
>
>
>
>   ((ld_state.dynamicscnidx) ? (void) (0) : __assert_fail ("ld_state.dynamicscnidx", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6644, __PRETTY_FUNCTION__));
>   outscn = elf_getscn (ld_state.outelf, ld_state.dynamicscnidx);
>   shdr = gelf_getshdr (outscn, &shdr_mem);
>   ((shdr != ((void *)0)) ? (void) (0) : __assert_fail ("shdr != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6647, __PRETTY_FUNCTION__));
>
>   phdr = &phdr_mem;
>   phdr->p_type = 2;
>   phdr->p_offset = shdr->sh_offset;
>   phdr->p_vaddr = shdr->sh_addr;
>   phdr->p_paddr = phdr->p_vaddr;
>   phdr->p_filesz = shdr->sh_size;
>   phdr->p_memsz = phdr->p_filesz;
>   phdr->p_flags = 0;
>   phdr->p_align = shdr->sh_addralign;
>
>   (void) gelf_update_phdr (ld_state.outelf, idx, phdr);
>
>
>   ((ld_state.dynstrscnidx != 0) ? (void) (0) : __assert_fail ("ld_state.dynstrscnidx != 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6662, __PRETTY_FUNCTION__));
>   shdr->sh_link = ld_state.dynstrscnidx;
>   (void) gelf_update_shdr (outscn, shdr);
>
>
>   Elf_Data *dyndata = elf_getdata (outscn, ((void *)0));
>   ((dyndata != ((void *)0)) ? (void) (0) : __assert_fail ("dyndata != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6668, __PRETTY_FUNCTION__));
>
>
>   if (ld_state.ndsofiles > 0)
>     {
>       struct usedfiles *runp = ld_state.dsofiles->next;
>
>       do
>  if (runp->used || !runp->as_needed)
>    {
>
>      if (runp->lazyload)
>        new_dynamic_entry (dyndata, ld_state.ndynamic_filled++,
>      0x6ffffdfd, 0x00000001);
>
>      new_dynamic_entry (dyndata, ld_state.ndynamic_filled++,
>           1,
>           ebl_strtaboffset (runp->sonameent));
>    }
>       while ((runp = runp->next) != ld_state.dsofiles->next);
>     }
>
>
>   if (ld_state.rxxpath_strent != ((void *)0))
>     new_dynamic_entry (dyndata, ld_state.ndynamic_filled++,
>          ld_state.rxxpath_tag,
>          ebl_strtaboffset (ld_state.rxxpath_strent));
>
>
>
>   if (ld_state.init_symbol != ((void *)0))
>     {
>       GElf_Sym sym_mem; GElf_Sym *sym;
>
>       if (ld_state.need_symtab)
>  sym = gelf_getsym (symdata, dblindirect[ld_state.init_symbol->outsymidx], &sym_mem);
>
>
>       else
>  sym = gelf_getsym (dynsymdata, ld_state.init_symbol->outdynsymidx, &sym_mem);
>
>       ((sym != ((void *)0)) ? (void) (0) : __assert_fail ("sym != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6709, __PRETTY_FUNCTION__));
>
>       new_dynamic_entry (dyndata, ld_state.ndynamic_filled++,
>     12, sym->st_value);
>     }
>   if (ld_state.fini_symbol != ((void *)0))
>     {
>       GElf_Sym sym_mem; GElf_Sym *sym;
>
>       if (ld_state.need_symtab)
>  sym = gelf_getsym (symdata, dblindirect[ld_state.fini_symbol->outsymidx], &sym_mem);
>
>
>       else
>  sym = gelf_getsym (dynsymdata, ld_state.fini_symbol->outdynsymidx, &sym_mem);
>
>       ((sym != ((void *)0)) ? (void) (0) : __assert_fail ("sym != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6725, __PRETTY_FUNCTION__));
>
>       new_dynamic_entry (dyndata, ld_state.ndynamic_filled++,
>     13, sym->st_value);
>     }
>
>
>
>   shdr = gelf_getshdr (elf_getscn (ld_state.outelf, ld_state.hashscnidx), &shdr_mem);
>
>   ((shdr != ((void *)0)) ? (void) (0) : __assert_fail ("shdr != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6735, __PRETTY_FUNCTION__));
>   new_dynamic_entry (dyndata, ld_state.ndynamic_filled++, 4,
>        shdr->sh_addr);
>
>
>   ((ld_state.dynsymscnidx != 0) ? (void) (0) : __assert_fail ("ld_state.dynsymscnidx != 0", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6740, __PRETTY_FUNCTION__));
>   shdr = gelf_getshdr (elf_getscn (ld_state.outelf, ld_state.dynsymscnidx), &shdr_mem);
>
>   ((shdr != ((void *)0)) ? (void) (0) : __assert_fail ("shdr != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6743, __PRETTY_FUNCTION__));
>   new_dynamic_entry (dyndata, ld_state.ndynamic_filled++, 6,
>        shdr->sh_addr);
>
>   new_dynamic_entry (dyndata, ld_state.ndynamic_filled++, 11,
>        gelf_fsize (ld_state.outelf, ELF_T_SYM, 1, 1));
>
>
>   shdr = gelf_getshdr (elf_getscn (ld_state.outelf, ld_state.dynstrscnidx), &shdr_mem);
>
>   ((shdr != ((void *)0)) ? (void) (0) : __assert_fail ("shdr != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6753, __PRETTY_FUNCTION__));
>   new_dynamic_entry (dyndata, ld_state.ndynamic_filled++, 5,
>        shdr->sh_addr);
>
>   new_dynamic_entry (dyndata, ld_state.ndynamic_filled++, 10,
>        shdr->sh_size);
>
>
>   if (ld_state.nplt > 0)
>     {
>
>       shdr = gelf_getshdr (elf_getscn (ld_state.outelf, ld_state.gotpltscnidx), &shdr_mem);
>
>       ((shdr != ((void *)0)) ? (void) (0) : __assert_fail ("shdr != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6766, __PRETTY_FUNCTION__));
>       new_dynamic_entry (dyndata, ld_state.ndynamic_filled++,
>
>
>     3, shdr->sh_addr);
>
>       shdr = gelf_getshdr (elf_getscn (ld_state.outelf, ld_state.pltrelscnidx), &shdr_mem);
>
>       ((shdr != ((void *)0)) ? (void) (0) : __assert_fail ("shdr != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6774, __PRETTY_FUNCTION__));
>       new_dynamic_entry (dyndata, ld_state.ndynamic_filled++,
>     2, shdr->sh_size);
>
>       new_dynamic_entry (dyndata, ld_state.ndynamic_filled++,
>     23, shdr->sh_addr);
>
>       new_dynamic_entry (dyndata, ld_state.ndynamic_filled++,
>     20, (_dl_mcount_wrapper_check ((void *) ((statep)->callbacks.rel_type)), (*((statep)->callbacks.rel_type)) (statep)));
>     }
>
>   if (ld_state.relsize_total > 0)
>     {
>       int rel = (_dl_mcount_wrapper_check ((void *) ((statep)->callbacks.rel_type)), (*((statep)->callbacks.rel_type)) (statep));
>       shdr = gelf_getshdr (elf_getscn (ld_state.outelf, ld_state.reldynscnidx), &shdr_mem);
>
>       ((shdr != ((void *)0)) ? (void) (0) : __assert_fail ("shdr != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6790, __PRETTY_FUNCTION__));
>       new_dynamic_entry (dyndata, ld_state.ndynamic_filled++,
>     rel, shdr->sh_addr);
>
>
>
>       ((8 - 7 == 1) ? (void) (0) : __assert_fail ("8 - 7 == 1", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6796, __PRETTY_FUNCTION__));
>       ((18 - 17 == 1) ? (void) (0) : __assert_fail ("18 - 17 == 1", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6797, __PRETTY_FUNCTION__));
>       new_dynamic_entry (dyndata, ld_state.ndynamic_filled++,
>     rel + 1, shdr->sh_size);
>
>
>       ((9 - 7 == 2) ? (void) (0) : __assert_fail ("9 - 7 == 2", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6802, __PRETTY_FUNCTION__));
>       ((19 - 17 == 2) ? (void) (0) : __assert_fail ("19 - 17 == 2", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6803, __PRETTY_FUNCTION__));
>       new_dynamic_entry (dyndata, ld_state.ndynamic_filled++,
>     rel + 2,
>     rel == 17
>     ? gelf_fsize (ld_state.outelf, ELF_T_REL, 1, 1)
>     : gelf_fsize (ld_state.outelf, ELF_T_RELA, 1, 1));
>
>     }
>
>   if (ld_state.verneedscnidx != 0)
>     {
>       shdr = gelf_getshdr (elf_getscn (ld_state.outelf, ld_state.verneedscnidx), &shdr_mem);
>
>       ((shdr != ((void *)0)) ? (void) (0) : __assert_fail ("shdr != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6816, __PRETTY_FUNCTION__));
>       new_dynamic_entry (dyndata, ld_state.ndynamic_filled++,
>     0x6ffffffe, shdr->sh_addr);
>
>       new_dynamic_entry (dyndata, ld_state.ndynamic_filled++,
>     0x6fffffff, ld_state.nverdeffile);
>     }
>
>   if (ld_state.versymscnidx != 0)
>     {
>       shdr = gelf_getshdr (elf_getscn (ld_state.outelf, ld_state.versymscnidx), &shdr_mem);
>
>       ((shdr != ((void *)0)) ? (void) (0) : __assert_fail ("shdr != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6828, __PRETTY_FUNCTION__));
>       new_dynamic_entry (dyndata, ld_state.ndynamic_filled++,
>     0x6ffffff0, shdr->sh_addr);
>     }
>
>
>   new_dynamic_entry (dyndata, ld_state.ndynamic_filled++, 21, 0);
>   ((ld_state.ndynamic_filled < ld_state.ndynamic) ? (void) (0) : __assert_fail ("ld_state.ndynamic_filled < ld_state.ndynamic", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6835, __PRETTY_FUNCTION__));
>
>
>   if (ld_state.dt_flags != 0)
>     new_dynamic_entry (dyndata, ld_state.ndynamic_filled++, 30,
>          ld_state.dt_flags);
>
>
>   if (ld_state.dt_flags_1 != 0)
>     new_dynamic_entry (dyndata, ld_state.ndynamic_filled++,
>          0x6ffffffb, ld_state.dt_flags_1);
>
>
>   if (ld_state.dt_feature_1 != 0)
>     new_dynamic_entry (dyndata, ld_state.ndynamic_filled++,
>          0x6ffffdfc, ld_state.dt_feature_1);
>
>   ((ld_state.ndynamic_filled <= ld_state.ndynamic) ? (void) (0) : __assert_fail ("ld_state.ndynamic_filled <= ld_state.ndynamic", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6852, __PRETTY_FUNCTION__));
> }
>    }
># 6865 "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c"
>  while (rellist != ((void *)0))
>    {
>      ((ld_state.file_type == relocatable_file_type) ? (void) (0) : __assert_fail ("ld_state.file_type == relocatable_file_type", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6867, __PRETTY_FUNCTION__));
>      Elf_Scn *outscn;
>
>      outscn = elf_getscn (ld_state.outelf, rellist->scnidx);
>      shdr = gelf_getshdr (outscn, &shdr_mem);
>
>      ((shdr != ((void *)0)) ? (void) (0) : __assert_fail ("shdr != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6873, __PRETTY_FUNCTION__));
>
>
>      shdr->sh_link = ld_state.symscnidx;
>
>
>
>
>      shdr->sh_info =
> rellist->scninfo->fileinfo->scninfo[(rellist->scninfo->shdr).sh_info].outscnndx;
>
>
>
>
>      (_dl_mcount_wrapper_check ((void *) ((statep)->callbacks.relocate_section)), (*((statep)->callbacks.relocate_section)) (statep, outscn, rellist->scninfo, dblindirect));
>
>
>      (void) gelf_update_shdr (outscn, shdr);
>
>
>      rellist = rellist->next;
>    }
>
>  if (ld_state.rellist != ((void *)0))
>    {
>      ((ld_state.file_type != relocatable_file_type) ? (void) (0) : __assert_fail ("ld_state.file_type != relocatable_file_type", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6898, __PRETTY_FUNCTION__));
>
>      (_dl_mcount_wrapper_check ((void *) ((statep)->callbacks.create_relocations)), (*((statep)->callbacks.create_relocations)) (statep, dblindirect));
>    }
>
>
>
>  ehdr = gelf_getehdr (ld_state.outelf, &ehdr_mem);
>  ((ehdr != ((void *)0)) ? (void) (0) : __assert_fail ("ehdr != ((void *)0)", "/net/ma/home/roland/redhat/stock-elfutils/src/ldgeneric.c", 6906, __PRETTY_FUNCTION__));
>
>
>  if (__builtin_expect (!!(shstrtab_ndx < 0xffff), 1)
>      && __builtin_expect (!!(shstrtab_ndx != 0xffff), 1))
>    ehdr->e_shstrndx = shstrtab_ndx;
>  else
>    {
>
>
>      Elf_Scn *scn = elf_getscn (ld_state.outelf, 0);
>
>      shdr = gelf_getshdr (scn, &shdr_mem);
>      if (__builtin_expect (!!(shdr == ((void *)0)), 0))
> error (1, 0,
>        dcgettext (((void *)0), "cannot get header of 0th section: %s", __LC_MESSAGES),
>        elf_errmsg (-1));
>
>      shdr->sh_link = shstrtab_ndx;
>
>      (void) gelf_update_shdr (scn, shdr);
>
>      ehdr->e_shstrndx = 0xffff;
>    }
>
>  if (ld_state.file_type != relocatable_file_type)
>
>    ehdr->e_entry = find_entry_point ();
>
>  if (__builtin_expect (!!(gelf_update_ehdr (ld_state.outelf, ehdr) == 0), 0))
>    error (1, 0,
>    dcgettext (((void *)0), "cannot update ELF header: %s", __LC_MESSAGES),
>    elf_errmsg (-1));
>
>
>
>  free (ld_state.dblindirect);
>
>
>
>  (_dl_mcount_wrapper_check ((void *) ((statep)->callbacks.finalize_plt)), (*((statep)->callbacks.finalize_plt)) (statep, nsym, nsym_local, ndxtosym));
>
>
>
>  if (ld_state.build_id != ((void *)0))
>    compute_build_id ();
>
>
>
>
>  free (ndxtosym);
>
>  return 0;
>}
>
>
>
>static void
>ld_generic_relocate_section (struct ld_state *statep, Elf_Scn *outscn,
>        struct scninfo *firstp,
>        const Elf32_Word *dblindirect)
>{
>  error (1, 0, dcgettext (((void *)0), "linker backend didn't specify function to relocate section", __LC_MESSAGES));
>
>
>}
>
>
>
>static int
>ld_generic_finalize (struct ld_state *statep)
>{
>
>  if (elf_update (ld_state.outelf, ELF_C_WRITE) == -1)
>      error (1, 0, dcgettext (((void *)0), "while writing output file: %s", __LC_MESSAGES),
>      elf_errmsg (-1));
>
>
>  if (elf_end (ld_state.outelf) != 0)
>    error (1, 0, dcgettext (((void *)0), "while finishing output file: %s", __LC_MESSAGES),
>    elf_errmsg (-1));
>
>
>  struct stat temp_st;
>  if (fstat (ld_state.outfd, &temp_st) != 0)
>    error (1, (*__errno_location ()), dcgettext (((void *)0), "cannot stat output file", __LC_MESSAGES));
>
>
>
>  if (rename (ld_state.tempfname, ld_state.outfname) != 0)
>
>    error (1, (*__errno_location ()), dcgettext (((void *)0), "cannot rename output file", __LC_MESSAGES));
>
>
>  struct stat new_st;
>  if (stat (ld_state.outfname, &new_st) != 0
>      || new_st.st_ino != temp_st.st_ino
>      || new_st.st_dev != temp_st.st_dev)
>    {
>
>      unlink (ld_state.outfname);
>      error (1, 0, dcgettext (((void *)0), "WARNING: temporary output file overwritten before linking finished", __LC_MESSAGES));
>
>    }
>
>
>  (void) close (ld_state.outfd);
>
>
>  ld_state.tempfname = ((void *)0);
>
>  return 0;
>}
>
>
>static _Bool
>ld_generic_special_section_number_p (struct ld_state *statep, size_t number)
>{
>
>  return 0;
>}
>
>
>static _Bool
>ld_generic_section_type_p (struct ld_state *statep, GElf_Word type)
>{
>  if (type < 19
>
>
>
>
>
>      || (type >= 0x6ffffffd && type <= 0x6fffffff))
>    return 1;
>
>  return 0;
>}
>
>
>static GElf_Xword
>ld_generic_dynamic_section_flags (struct ld_state *statep)
>{
>
>
>  return (1 << 1) | (1 << 0);
>}
>
>
>static void
>ld_generic_initialize_plt (struct ld_state *statep, Elf_Scn *scn)
>{
>
>
>
>  error (1, 0, dcgettext (((void *)0), "no machine specific '%s' implementation", __LC_MESSAGES),
>  "initialize_plt");
>}
>
>
>static void
>ld_generic_initialize_pltrel (struct ld_state *statep, Elf_Scn *scn)
>{
>
>
>
>  error (1, 0, dcgettext (((void *)0), "no machine specific '%s' implementation", __LC_MESSAGES),
>  "initialize_pltrel");
>}
>
>
>static void
>ld_generic_initialize_got (struct ld_state *statep, Elf_Scn *scn)
>{
>
>
>
>  error (1, 0, dcgettext (((void *)0), "no machine specific '%s' implementation", __LC_MESSAGES),
>  "initialize_got");
>}
>
>
>static void
>ld_generic_initialize_gotplt (struct ld_state *statep, Elf_Scn *scn)
>{
>
>
>
>  error (1, 0, dcgettext (((void *)0), "no machine specific '%s' implementation", __LC_MESSAGES),
>  "initialize_gotplt");
>}
>
>
>static void
>ld_generic_finalize_plt (struct ld_state *statep, size_t nsym, size_t nsym_dyn,
>    struct symbol **ndxtosymp)
>{
>
>}
>
>
>static int
>ld_generic_rel_type (struct ld_state *statep)
>{
>
>
>
>  error (1, 0, dcgettext (((void *)0), "no machine specific '%s' implementation", __LC_MESSAGES),
>  "rel_type");
>
>  return 0;
>}
>
>
>static void
>ld_generic_count_relocations (struct ld_state *statep, struct scninfo *scninfo)
>{
>
>
>
>  error (1, 0, dcgettext (((void *)0), "no machine specific '%s' implementation", __LC_MESSAGES),
>  "count_relocations");
>}
>
>
>static void
>ld_generic_create_relocations (struct ld_state *statep,
>          const Elf32_Word *dblindirect)
>{
>
>
>
>  error (1, 0, dcgettext (((void *)0), "no machine specific '%s' implementation", __LC_MESSAGES),
>  "create_relocations");
>}

Actions: View

Attachments on bug 433576: 295379