Add support for Visual Studio 2019

external/libelf/src/32.fsize.c

@@ -0,0 +1,155 @@
+/*
+32.fsize.c - implementation of the elf{32,64}_fsize(3) functions.
+Copyright (C) 1995 - 2001 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+#include <ext_types.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: 32.fsize.c,v 1.13 2008/05/23 08:15:33 michael Exp $";
+#endif /* lint */
+
+const size_t
+_elf_fmsize[2][EV_CURRENT - EV_NONE][ELF_T_NUM][2] = {
+    /* ELFCLASS32 */
+    {
+	/* version 1 */
+	{
+	    { sizeof(unsigned char),  sizeof(unsigned char)      },
+	    { sizeof(Elf32_Addr),     sizeof(__ext_Elf32_Addr)   },
+	    { sizeof(Elf32_Dyn),      sizeof(__ext_Elf32_Dyn)    },
+	    { sizeof(Elf32_Ehdr),     sizeof(__ext_Elf32_Ehdr)   },
+	    { sizeof(Elf32_Half),     sizeof(__ext_Elf32_Half)   },
+	    { sizeof(Elf32_Off),      sizeof(__ext_Elf32_Off)    },
+	    { sizeof(Elf32_Phdr),     sizeof(__ext_Elf32_Phdr)   },
+	    { sizeof(Elf32_Rela),     sizeof(__ext_Elf32_Rela)   },
+	    { sizeof(Elf32_Rel),      sizeof(__ext_Elf32_Rel)    },
+	    { sizeof(Elf32_Shdr),     sizeof(__ext_Elf32_Shdr)   },
+	    { sizeof(Elf32_Sword),    sizeof(__ext_Elf32_Sword)  },
+	    { sizeof(Elf32_Sym),      sizeof(__ext_Elf32_Sym)    },
+	    { sizeof(Elf32_Word),     sizeof(__ext_Elf32_Word)   },
+	    { 0, 0 },	/* there is no Elf32_Sxword */
+	    { 0, 0 },	/* there is no Elf32_Xword */
+	    /* XXX: check Solaris values */
+	    { 0, 0 },	/* Elf32_Verdef/Verdaux size varies */
+	    { 0, 0 },	/* Elf32_Verneed/Vernaux size varies */
+	},
+    },
+#if __LIBELF64
+    /* ELFCLASS64 */
+    {
+	/* version 1 */
+	{
+	    { sizeof(unsigned char),  sizeof(unsigned char)      },
+	    { sizeof(Elf64_Addr),     sizeof(__ext_Elf64_Addr)   },
+	    { sizeof(Elf64_Dyn),      sizeof(__ext_Elf64_Dyn)    },
+	    { sizeof(Elf64_Ehdr),     sizeof(__ext_Elf64_Ehdr)   },
+	    { sizeof(Elf64_Half),     sizeof(__ext_Elf64_Half)   },
+	    { sizeof(Elf64_Off),      sizeof(__ext_Elf64_Off)    },
+	    { sizeof(Elf64_Phdr),     sizeof(__ext_Elf64_Phdr)   },
+	    { sizeof(Elf64_Rela),     sizeof(__ext_Elf64_Rela)   },
+	    { sizeof(Elf64_Rel),      sizeof(__ext_Elf64_Rel)    },
+	    { sizeof(Elf64_Shdr),     sizeof(__ext_Elf64_Shdr)   },
+	    { sizeof(Elf64_Sword),    sizeof(__ext_Elf64_Sword)  },
+	    { sizeof(Elf64_Sym),      sizeof(__ext_Elf64_Sym)    },
+	    { sizeof(Elf64_Word),     sizeof(__ext_Elf64_Word)   },
+	    { sizeof(Elf64_Sxword),   sizeof(__ext_Elf64_Sxword) },
+	    { sizeof(Elf64_Xword),    sizeof(__ext_Elf64_Xword)  },
+	    /* XXX: check Solaris values */
+	    { 0, 0 },	/* Elf64_Verdef/Verdaux size varies */
+	    { 0, 0 },	/* Elf64_Verneed/Vernaux size varies */
+	},
+    },
+#endif /* __LIBELF64 */
+};
+
+static size_t
+_elf_fsize(unsigned cls, Elf_Type type, unsigned ver) {
+    size_t n = 0;
+
+    if (!valid_version(ver)) {
+	seterr(ERROR_UNKNOWN_VERSION);
+    }
+    else if (!valid_type(type)) {
+	seterr(ERROR_UNKNOWN_TYPE);
+    }
+    else if (!(n = _fsize(cls, ver, type))) {
+	seterr(ERROR_UNKNOWN_TYPE);
+    }
+    return n;
+}
+
+size_t
+elf32_fsize(Elf_Type type, size_t count, unsigned ver) {
+    return count * _elf_fsize(ELFCLASS32, type, ver);
+}
+
+#if __LIBELF64
+
+size_t
+elf64_fsize(Elf_Type type, size_t count, unsigned ver) {
+    return count * _elf_fsize(ELFCLASS64, type, ver);
+}
+
+size_t
+gelf_fsize(Elf *elf, Elf_Type type, size_t count, unsigned ver) {
+    if (elf) {
+	if (elf->e_kind != ELF_K_ELF) {
+	    seterr(ERROR_NOTELF);
+	}
+	else if (valid_class(elf->e_class)) {
+	    return count * _elf_fsize(elf->e_class, type, ver);
+	}
+	else {
+	    seterr(ERROR_UNKNOWN_CLASS);
+	}
+    }
+    return 0;
+}
+
+/*
+ * Extension: report memory size
+ */
+size_t
+gelf_msize(Elf *elf, Elf_Type type, size_t count, unsigned ver) {
+    size_t n;
+
+    if (elf) {
+	if (elf->e_kind != ELF_K_ELF) {
+	    seterr(ERROR_NOTELF);
+	}
+	else if (!valid_class(elf->e_class)) {
+	    seterr(ERROR_UNKNOWN_CLASS);
+	}
+	else if (!valid_version(ver)) {
+	    seterr(ERROR_UNKNOWN_VERSION);
+	}
+	else if (!valid_type(type)) {
+	    seterr(ERROR_UNKNOWN_TYPE);
+	}
+	else if (!(n = _msize(elf->e_class, ver, type))) {
+	    seterr(ERROR_UNKNOWN_TYPE);
+	}
+	else {
+	    return count * n;
+	}
+    }
+    return 0;
+}
+
+#endif /* __LIBELF64 */

external/libelf/src/32.getehdr.c

@@ -0,0 +1,56 @@
+/*
+32.getehdr.c - implementation of the elf{32,64}_getehdr(3) functions.
+Copyright (C) 1995 - 1998 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: 32.getehdr.c,v 1.9 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+char*
+_elf_getehdr(Elf *elf, unsigned cls) {
+    if (!elf) {
+	return NULL;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if (elf->e_kind != ELF_K_ELF) {
+	seterr(ERROR_NOTELF);
+    }
+    else if (elf->e_class != cls) {
+	seterr(ERROR_CLASSMISMATCH);
+    }
+    else if (elf->e_ehdr || _elf_cook(elf)) {
+	return elf->e_ehdr;
+    }
+    return NULL;
+}
+
+Elf32_Ehdr*
+elf32_getehdr(Elf *elf) {
+    return (Elf32_Ehdr*)_elf_getehdr(elf, ELFCLASS32);
+}
+
+#if __LIBELF64
+
+Elf64_Ehdr*
+elf64_getehdr(Elf *elf) {
+    return (Elf64_Ehdr*)_elf_getehdr(elf, ELFCLASS64);
+}
+
+#endif /* __LIBELF64 */

external/libelf/src/32.getphdr.c

@@ -0,0 +1,56 @@
+/*
+32.getphdr.c - implementation of the elf{32,64}_getphdr(3) functions.
+Copyright (C) 1995 - 2000 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: 32.getphdr.c,v 1.11 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+char*
+_elf_getphdr(Elf *elf, unsigned cls) {
+    if (!elf) {
+	return NULL;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if (elf->e_kind != ELF_K_ELF) {
+	seterr(ERROR_NOTELF);
+    }
+    else if (elf->e_class != cls) {
+	seterr(ERROR_CLASSMISMATCH);
+    }
+    else if (elf->e_ehdr || _elf_cook(elf)) {
+	return elf->e_phdr;
+    }
+    return NULL;
+}
+
+Elf32_Phdr*
+elf32_getphdr(Elf *elf) {
+    return (Elf32_Phdr*)_elf_getphdr(elf, ELFCLASS32);
+}
+
+#if __LIBELF64
+
+Elf64_Phdr*
+elf64_getphdr(Elf *elf) {
+    return (Elf64_Phdr*)_elf_getphdr(elf, ELFCLASS64);
+}
+
+#endif /* __LIBELF64 */

external/libelf/src/32.getshdr.c

@@ -0,0 +1,58 @@
+/*
+32.getshdr.c - implementation of the elf{32,64}_getshdr(3) functions.
+Copyright (C) 1995 - 1998 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: 32.getshdr.c,v 1.10 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+Elf32_Shdr*
+elf32_getshdr(Elf_Scn *scn) {
+    if (!scn) {
+	return NULL;
+    }
+    elf_assert(scn->s_magic == SCN_MAGIC);
+    elf_assert(scn->s_elf);
+    elf_assert(scn->s_elf->e_magic == ELF_MAGIC);
+    if (scn->s_elf->e_class == ELFCLASS32) {
+	return &scn->s_shdr32;
+    }
+    seterr(ERROR_CLASSMISMATCH);
+    return NULL;
+}
+
+#if __LIBELF64
+
+Elf64_Shdr*
+elf64_getshdr(Elf_Scn *scn) {
+    if (!scn) {
+	return NULL;
+    }
+    elf_assert(scn->s_magic == SCN_MAGIC);
+    elf_assert(scn->s_elf);
+    elf_assert(scn->s_elf->e_magic == ELF_MAGIC);
+    if (scn->s_elf->e_class == ELFCLASS64) {
+	return &scn->s_shdr64;
+    }
+    seterr(ERROR_CLASSMISMATCH);
+    return NULL;
+}
+
+#endif /* __LIBELF64 */

external/libelf/src/32.newehdr.c

@@ -0,0 +1,80 @@
+/*
+ * 32.newehdr.c - implementation of the elf{32,64}_newehdr(3) functions.
+ * Copyright (C) 1995 - 2006 Michael Riepe
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: 32.newehdr.c,v 1.16 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+static char*
+_elf_newehdr(Elf *elf, unsigned cls) {
+    size_t size;
+
+    if (!elf) {
+	return NULL;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if (elf->e_readable) {
+	return _elf_getehdr(elf, cls);
+    }
+    else if (!elf->e_ehdr) {
+	size = _msize(cls, _elf_version, ELF_T_EHDR);
+	elf_assert(size);
+	if ((elf->e_ehdr = (char*)malloc(size))) {
+	    memset(elf->e_ehdr, 0, size);
+	    elf->e_ehdr_flags |= ELF_F_DIRTY;
+	    elf->e_kind = ELF_K_ELF;
+	    elf->e_class = cls;
+	    return elf->e_ehdr;
+	}
+	seterr(ERROR_MEM_EHDR);
+    }
+    else if (elf->e_class != cls) {
+	seterr(ERROR_CLASSMISMATCH);
+    }
+    else {
+	elf_assert(elf->e_kind == ELF_K_ELF);
+	return elf->e_ehdr;
+    }
+    return NULL;
+}
+
+Elf32_Ehdr*
+elf32_newehdr(Elf *elf) {
+    return (Elf32_Ehdr*)_elf_newehdr(elf, ELFCLASS32);
+}
+
+#if __LIBELF64
+
+Elf64_Ehdr*
+elf64_newehdr(Elf *elf) {
+    return (Elf64_Ehdr*)_elf_newehdr(elf, ELFCLASS64);
+}
+
+unsigned long
+gelf_newehdr(Elf *elf, int cls) {
+    if (!valid_class(cls) || !_msize(cls, _elf_version, ELF_T_EHDR)) {
+	seterr(ERROR_UNKNOWN_CLASS);
+	return 0;
+    }
+    return (unsigned long)_elf_newehdr(elf, cls);
+}
+
+#endif /* __LIBELF64 */

external/libelf/src/32.newphdr.c

@@ -0,0 +1,118 @@
+/*
+ * 32.newphdr.c - implementation of the elf{32,64}_newphdr(3) functions.
+ * Copyright (C) 1995 - 2006 Michael Riepe
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: 32.newphdr.c,v 1.16 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+static char*
+_elf_newphdr(Elf *elf, size_t count, unsigned cls) {
+    size_t extcount = 0;
+    Elf_Scn *scn = NULL;
+    char *phdr = NULL;
+    size_t size;
+
+    if (!elf) {
+	return NULL;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if (!elf->e_ehdr && !elf->e_readable) {
+	seterr(ERROR_NOEHDR);
+    }
+    else if (elf->e_kind != ELF_K_ELF) {
+	seterr(ERROR_NOTELF);
+    }
+    else if (elf->e_class != cls) {
+	seterr(ERROR_CLASSMISMATCH);
+    }
+    else if (elf->e_ehdr || _elf_cook(elf)) {
+	size = _msize(cls, _elf_version, ELF_T_PHDR);
+	elf_assert(size);
+	if (!(scn = _elf_first_scn(elf))) {
+	    return NULL;
+	}
+	if (count) {
+	    if (!(phdr = (char*)malloc(count * size))) {
+		seterr(ERROR_MEM_PHDR);
+		return NULL;
+	    }
+	    memset(phdr, 0, count * size);
+	}
+	elf_assert(elf->e_ehdr);
+	elf->e_phnum = count;
+	if (count >= PN_XNUM) {
+	    /*
+	     * get NULL section (create it if necessary)
+	     */
+	    extcount = count;
+	    count = PN_XNUM;
+	}
+	if (cls == ELFCLASS32) {
+	    ((Elf32_Ehdr*)elf->e_ehdr)->e_phnum = count;
+	    scn->s_shdr32.sh_info = extcount;
+	}
+#if __LIBELF64
+	else if (cls == ELFCLASS64) {
+	    ((Elf64_Ehdr*)elf->e_ehdr)->e_phnum = count;
+	    scn->s_shdr64.sh_info = extcount;
+	}
+#endif /* __LIBELF64 */
+	else {
+	    seterr(ERROR_UNIMPLEMENTED);
+	    if (phdr) {
+		free(phdr);
+	    }
+	    return NULL;
+	}
+	if (elf->e_phdr) {
+	    free(elf->e_phdr);
+	}
+	elf->e_phdr = phdr;
+	elf->e_phdr_flags |= ELF_F_DIRTY;
+	elf->e_ehdr_flags |= ELF_F_DIRTY;
+	scn->s_scn_flags |= ELF_F_DIRTY;
+	return phdr;
+    }
+    return NULL;
+}
+
+Elf32_Phdr*
+elf32_newphdr(Elf *elf, size_t count) {
+    return (Elf32_Phdr*)_elf_newphdr(elf, count, ELFCLASS32);
+}
+
+#if __LIBELF64
+
+Elf64_Phdr*
+elf64_newphdr(Elf *elf, size_t count) {
+    return (Elf64_Phdr*)_elf_newphdr(elf, count, ELFCLASS64);
+}
+
+unsigned long
+gelf_newphdr(Elf *elf, size_t phnum) {
+    if (!valid_class(elf->e_class)) {
+	seterr(ERROR_UNKNOWN_CLASS);
+	return 0;
+    }
+    return (unsigned long)_elf_newphdr(elf, phnum, elf->e_class);
+}
+
+#endif /* __LIBELF64 */

external/libelf/src/32.xlatetof.c

@@ -0,0 +1,438 @@
+/*
+ * 32.xlatetof.c - implementation of the elf32_xlateto[fm](3) functions.
+ * Copyright (C) 1995 - 2006 Michael Riepe
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <private.h>
+#include <ext_types.h>
+#include <byteswap.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: 32.xlatetof.c,v 1.27 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+/*
+ * Ugly, ugly
+ */
+#ifdef _WIN32
+# define Cat2(a,b)a##b
+# define Cat3(a,b,c)a##b##c
+# define Ex1(m1,m2,a,b)m1##m2(a##b)
+# define Ex2(m1,m2,a,b,c)m1##m2(a,b##c)
+#else /* _WIN32 */
+# define x
+# if defined/**/x
+#  define Cat2(a,b)a##b
+#  define Cat3(a,b,c)a##b##c
+#  define Ex1(m1,m2,a,b)m1##m2(a##b)
+#  define Ex2(m1,m2,a,b,c)m1##m2(a,b##c)
+# else
+#  define Cat2(a,b)a/**/b
+#  define Cat3(a,b,c)a/**/b/**/c
+#  define Ex1(m1,m2,a,b)m1/**/m2(a/**/b)
+#  define Ex2(m1,m2,a,b,c)m1/**/m2(a,b/**/c)
+# endif
+# undef x
+#endif /* _WIN32 */
+
+/*
+ * auxiliary macros for execution order reversal
+ */
+#define seq_forw(a,b) a b
+#define seq_back(a,b) b a
+
+/*
+ * function instantiator
+ */
+#define copy_type_e_io(name,e,io,tfrom,tto,copy)		\
+    static size_t						\
+    Cat3(name,_,io)(unsigned char *dst, const unsigned char *src, size_t n) {	\
+	n /= sizeof(tfrom);					\
+	if (n && dst) {						\
+	    const tfrom *from = (const tfrom*)src;		\
+	    tto *to = (tto*)dst;				\
+	    size_t i;						\
+								\
+	    if (sizeof(tfrom) < sizeof(tto)) {			\
+		from += n;					\
+		to += n;					\
+		for (i = 0; i < n; i++) {			\
+		    --from;					\
+		    --to;					\
+		    copy(e,io,seq_back)				\
+		}						\
+	    }							\
+	    else {						\
+		for (i = 0; i < n; i++) {			\
+		    copy(e,io,seq_forw)				\
+		    from++;					\
+		    to++;					\
+		}						\
+	    }							\
+	}							\
+	return n * sizeof(tto);					\
+    }
+
+#define copy_type_e(name,e,type,copy)				\
+    copy_type_e_io(name,e,tom,Cat2(__ext_,type),type,copy)	\
+    copy_type_e_io(name,e,tof,type,Cat2(__ext_,type),copy)
+
+/*
+ * master function instantiator
+ */
+#define copy_type(name,version,type,copy)		\
+    copy_type_e(Cat3(name,L,version),L,type,copy)	\
+    copy_type_e(Cat3(name,M,version),M,type,copy)
+
+/*
+ * scalar copying
+ */
+#define copy_scalar_tom(type)	*to = Cat2(__load_,type)(*from);
+#define copy_scalar_tof(type)	Cat2(__store_,type)(*to, *from);
+
+/*
+ * structure member copying
+ */
+#define copy_tom(mb,type)	to->mb = Cat2(__load_,type)(from->mb);
+#define copy_tof(mb,type)	Cat2(__store_,type)(to->mb, from->mb);
+
+/*
+ * structure member copying (direction independent)
+ */
+#define copy_byte(e,io,mb)	to->mb = from->mb;
+#define copy_addr(e,io,mb)	Ex2(copy_,io,mb,u32,e)
+#define copy_half(e,io,mb)	Ex2(copy_,io,mb,u16,e)
+#define copy_off(e,io,mb)	Ex2(copy_,io,mb,u32,e)
+#define copy_sword(e,io,mb)	Ex2(copy_,io,mb,i32,e)
+#define copy_word(e,io,mb)	Ex2(copy_,io,mb,u32,e)
+#define copy_arr(e,io,mb)	\
+    array_copy(to->mb, sizeof(to->mb), from->mb, sizeof(from->mb));
+
+/*
+ * scalar copying (direction independent)
+ * these macros are used as `copy' arguments to copy_type()
+ */
+#define copy_addr_11(e,io,seq)	Ex1(copy_scalar_,io,u32,e)
+#define copy_half_11(e,io,seq)	Ex1(copy_scalar_,io,u16,e)
+#define copy_off_11(e,io,seq)	Ex1(copy_scalar_,io,u32,e)
+#define copy_sword_11(e,io,seq)	Ex1(copy_scalar_,io,i32,e)
+#define copy_word_11(e,io,seq)	Ex1(copy_scalar_,io,u32,e)
+
+/*
+ * structure copying (direction independent)
+ * these macros are used as `copy' arguments to copy_type()
+ */
+#define copy_dyn_11(e,io,seq)		\
+    seq(copy_sword(e,io,d_tag),		\
+    seq(copy_addr(e,io,d_un.d_ptr),	\
+    nullcopy))
+#define copy_ehdr_11(e,io,seq)		\
+    seq(copy_arr(e,io,e_ident),		\
+    seq(copy_half(e,io,e_type),		\
+    seq(copy_half(e,io,e_machine),	\
+    seq(copy_word(e,io,e_version),	\
+    seq(copy_addr(e,io,e_entry),	\
+    seq(copy_off(e,io,e_phoff),		\
+    seq(copy_off(e,io,e_shoff),		\
+    seq(copy_word(e,io,e_flags),	\
+    seq(copy_half(e,io,e_ehsize),	\
+    seq(copy_half(e,io,e_phentsize),	\
+    seq(copy_half(e,io,e_phnum),	\
+    seq(copy_half(e,io,e_shentsize),	\
+    seq(copy_half(e,io,e_shnum),	\
+    seq(copy_half(e,io,e_shstrndx),	\
+    nullcopy))))))))))))))
+#define copy_phdr_11(e,io,seq)		\
+    seq(copy_word(e,io,p_type),		\
+    seq(copy_off(e,io,p_offset),	\
+    seq(copy_addr(e,io,p_vaddr),	\
+    seq(copy_addr(e,io,p_paddr),	\
+    seq(copy_word(e,io,p_filesz),	\
+    seq(copy_word(e,io,p_memsz),	\
+    seq(copy_word(e,io,p_flags),	\
+    seq(copy_word(e,io,p_align),	\
+    nullcopy))))))))
+#define copy_rela_11(e,io,seq)		\
+    seq(copy_addr(e,io,r_offset),	\
+    seq(copy_word(e,io,r_info),		\
+    seq(copy_sword(e,io,r_addend),	\
+    nullcopy)))
+#define copy_rel_11(e,io,seq)		\
+    seq(copy_addr(e,io,r_offset),	\
+    seq(copy_word(e,io,r_info),		\
+    nullcopy))
+#define copy_shdr_11(e,io,seq)		\
+    seq(copy_word(e,io,sh_name),	\
+    seq(copy_word(e,io,sh_type),	\
+    seq(copy_word(e,io,sh_flags),	\
+    seq(copy_addr(e,io,sh_addr),	\
+    seq(copy_off(e,io,sh_offset),	\
+    seq(copy_word(e,io,sh_size),	\
+    seq(copy_word(e,io,sh_link),	\
+    seq(copy_word(e,io,sh_info),	\
+    seq(copy_word(e,io,sh_addralign),	\
+    seq(copy_word(e,io,sh_entsize),	\
+    nullcopy))))))))))
+#define copy_sym_11(e,io,seq)		\
+    seq(copy_word(e,io,st_name),	\
+    seq(copy_addr(e,io,st_value),	\
+    seq(copy_word(e,io,st_size),	\
+    seq(copy_byte(e,io,st_info),	\
+    seq(copy_byte(e,io,st_other),	\
+    seq(copy_half(e,io,st_shndx),	\
+    nullcopy))))))
+
+#define nullcopy /**/
+
+static size_t
+byte_copy(unsigned char *dst, const unsigned char *src, size_t n) {
+    if (n && dst && dst != src) {
+#if HAVE_BROKEN_MEMMOVE
+	size_t i;
+
+	if (dst >= src + n || dst + n <= src) {
+	    memcpy(dst, src, n);
+	}
+	else if (dst < src) {
+	    for (i = 0; i < n; i++) {
+		dst[i] = src[i];
+	    }
+	}
+	else {
+	    for (i = n; --i; ) {
+		dst[i] = src[i];
+	    }
+	}
+#else /* HAVE_BROKEN_MEMMOVE */
+	memmove(dst, src, n);
+#endif /* HAVE_BROKEN_MEMMOVE */
+    }
+    return n;
+}
+
+static void
+array_copy(unsigned char *dst, size_t dlen, const unsigned char *src, size_t slen) {
+    byte_copy(dst, src, dlen < slen ? dlen : slen);
+    if (dlen > slen) {
+	memset(dst + slen, 0, dlen - slen);
+    }
+}
+
+/*
+ * instantiate copy functions
+ */
+copy_type(addr_32,_,Elf32_Addr,copy_addr_11)
+copy_type(half_32,_,Elf32_Half,copy_half_11)
+copy_type(off_32,_,Elf32_Off,copy_off_11)
+copy_type(sword_32,_,Elf32_Sword,copy_sword_11)
+copy_type(word_32,_,Elf32_Word,copy_word_11)
+copy_type(dyn_32,11,Elf32_Dyn,copy_dyn_11)
+copy_type(ehdr_32,11,Elf32_Ehdr,copy_ehdr_11)
+copy_type(phdr_32,11,Elf32_Phdr,copy_phdr_11)
+copy_type(rela_32,11,Elf32_Rela,copy_rela_11)
+copy_type(rel_32,11,Elf32_Rel,copy_rel_11)
+copy_type(shdr_32,11,Elf32_Shdr,copy_shdr_11)
+copy_type(sym_32,11,Elf32_Sym,copy_sym_11)
+
+typedef size_t (*xlator)(unsigned char*, const unsigned char*, size_t);
+typedef xlator xltab[ELF_T_NUM][2];
+
+/*
+ * translation table (32-bit, version 1 -> version 1)
+ */
+#if PIC
+static xltab
+#else /* PIC */
+static const xltab
+#endif /* PIC */
+xlate32_11[/*encoding*/] = {
+    {
+	{ byte_copy,        byte_copy       },
+	{ addr_32L__tom,    addr_32L__tof   },
+	{ dyn_32L11_tom,    dyn_32L11_tof   },
+	{ ehdr_32L11_tom,   ehdr_32L11_tof  },
+	{ half_32L__tom,    half_32L__tof   },
+	{ off_32L__tom,	    off_32L__tof    },
+	{ phdr_32L11_tom,   phdr_32L11_tof  },
+	{ rela_32L11_tom,   rela_32L11_tof  },
+	{ rel_32L11_tom,    rel_32L11_tof   },
+	{ shdr_32L11_tom,   shdr_32L11_tof  },
+	{ sword_32L__tom,   sword_32L__tof  },
+	{ sym_32L11_tom,    sym_32L11_tof   },
+	{ word_32L__tom,    word_32L__tof   },
+	{ 0,                0               },	/* there is no Sxword */
+	{ 0,                0               },	/* there is no Xword */
+#if __LIBELF_SYMBOL_VERSIONS
+	{ _elf_verdef_32L11_tom,  _elf_verdef_32L11_tof  },
+	{ _elf_verneed_32L11_tom, _elf_verneed_32L11_tof },
+#else /* __LIBELF_SYMBOL_VERSIONS */
+	{ 0,                0               },
+	{ 0,                0               },
+#endif /* __LIBELF_SYMBOL_VERSIONS */
+    },
+    {
+	{ byte_copy,        byte_copy       },
+	{ addr_32M__tom,    addr_32M__tof   },
+	{ dyn_32M11_tom,    dyn_32M11_tof   },
+	{ ehdr_32M11_tom,   ehdr_32M11_tof  },
+	{ half_32M__tom,    half_32M__tof   },
+	{ off_32M__tom,	    off_32M__tof    },
+	{ phdr_32M11_tom,   phdr_32M11_tof  },
+	{ rela_32M11_tom,   rela_32M11_tof  },
+	{ rel_32M11_tom,    rel_32M11_tof   },
+	{ shdr_32M11_tom,   shdr_32M11_tof  },
+	{ sword_32M__tom,   sword_32M__tof  },
+	{ sym_32M11_tom,    sym_32M11_tof   },
+	{ word_32M__tom,    word_32M__tof   },
+	{ 0,                0               },	/* there is no Sxword */
+	{ 0,                0               },	/* there is no Xword */
+#if __LIBELF_SYMBOL_VERSIONS
+	{ _elf_verdef_32M11_tom,  _elf_verdef_32M11_tof  },
+	{ _elf_verneed_32M11_tom, _elf_verneed_32M11_tof },
+#else /* __LIBELF_SYMBOL_VERSIONS */
+	{ 0,                0               },
+	{ 0,                0               },
+#endif /* __LIBELF_SYMBOL_VERSIONS */
+    },
+};
+
+/*
+ * main translation table (32-bit)
+ */
+#if PIC
+static xltab*
+#else /* PIC */
+static const xltab *const
+#endif /* PIC */
+xlate32[EV_CURRENT - EV_NONE][EV_CURRENT - EV_NONE] = {
+    { xlate32_11, },
+};
+
+#define translator(sv,dv,enc,type,d)	\
+    (xlate32[(sv) - EV_NONE - 1]	\
+	    [(dv) - EV_NONE - 1]	\
+	    [(enc) - ELFDATA2LSB]	\
+	    [(type) - ELF_T_BYTE]	\
+	    [d])
+
+/*
+ * destination buffer size
+ */
+size_t
+_elf32_xltsize(const Elf_Data *src, unsigned dv, unsigned encode, int tof) {
+    Elf_Type type = src->d_type;
+    unsigned sv = src->d_version;
+    xlator op;
+
+    if (!valid_version(sv) || !valid_version(dv)) {
+	seterr(ERROR_UNKNOWN_VERSION);
+	return (size_t)-1;
+    }
+    if (tof) {
+	/*
+	 * Encoding doesn't really matter (the translator only looks at
+	 * the source, which resides in memory), but we need a proper
+	 * encoding to select a translator...
+	 */
+	encode = ELFDATA2LSB;
+    }
+    else if (!valid_encoding(encode)) {
+	seterr(ERROR_UNKNOWN_ENCODING);
+	return (size_t)-1;
+    }
+    if (!valid_type(type)) {
+	seterr(ERROR_UNKNOWN_TYPE);
+	return (size_t)-1;
+    }
+    if (!(op = translator(sv, dv, encode, type, tof))) {
+	seterr(ERROR_UNKNOWN_TYPE);
+	return (size_t)-1;
+    }
+    return (*op)(NULL, src->d_buf, src->d_size);
+}
+
+/*
+ * direction-independent translation
+ */
+static Elf_Data*
+elf32_xlate(Elf_Data *dst, const Elf_Data *src, unsigned encode, int tof) {
+    Elf_Type type;
+    int dv;
+    int sv;
+    size_t dsize;
+    size_t tmp;
+    xlator op;
+
+    if (!src || !dst) {
+	return NULL;
+    }
+    if (!src->d_buf || !dst->d_buf) {
+	seterr(ERROR_NULLBUF);
+	return NULL;
+    }
+    if (!valid_encoding(encode)) {
+	seterr(ERROR_UNKNOWN_ENCODING);
+	return NULL;
+    }
+    sv = src->d_version;
+    dv = dst->d_version;
+    if (!valid_version(sv) || !valid_version(dv)) {
+	seterr(ERROR_UNKNOWN_VERSION);
+	return NULL;
+    }
+    type = src->d_type;
+    if (!valid_type(type)) {
+	seterr(ERROR_UNKNOWN_TYPE);
+	return NULL;
+    }
+    op = translator(sv, dv, encode, type, tof);
+    if (!op) {
+	seterr(ERROR_UNKNOWN_TYPE);
+	return NULL;
+    }
+    dsize = (*op)(NULL, src->d_buf, src->d_size);
+    if (dsize == (size_t)-1) {
+	return NULL;
+    }
+    if (dst->d_size < dsize) {
+	seterr(ERROR_DST2SMALL);
+	return NULL;
+    }
+    if (dsize) {
+	tmp = (*op)(dst->d_buf, src->d_buf, src->d_size);
+	if (tmp == (size_t)-1) {
+	    return NULL;
+	}
+	elf_assert(tmp == dsize);
+    }
+    dst->d_size = dsize;
+    dst->d_type = type;
+    return dst;
+}
+
+/*
+ * finally, the "official" translation functions
+ */
+Elf_Data*
+elf32_xlatetom(Elf_Data *dst, const Elf_Data *src, unsigned encode) {
+    return elf32_xlate(dst, src, encode, 0);
+}
+
+Elf_Data*
+elf32_xlatetof(Elf_Data *dst, const Elf_Data *src, unsigned encode) {
+    return elf32_xlate(dst, src, encode, 1);
+}

external/libelf/src/64.xlatetof.c

@@ -0,0 +1,512 @@
+/*
+ * 64.xlatetof.c - implementation of the elf64_xlateto[fm](3) functions.
+ * Copyright (C) 1995 - 2006 Michael Riepe
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <private.h>
+#include <ext_types.h>
+#include <byteswap.h>
+
+#if __LIBELF64
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: 64.xlatetof.c,v 1.27 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+/*
+ * Ugly, ugly
+ */
+#ifdef _WIN32
+# define Cat2(a,b)a##b
+# define Cat3(a,b,c)a##b##c
+# define Ex1(m1,m2,a,b)m1##m2(a##b)
+# define Ex2(m1,m2,a,b,c)m1##m2(a,b##c)
+#else /* _WIN32 */
+# define x
+# if defined/**/x
+#  define Cat2(a,b)a##b
+#  define Cat3(a,b,c)a##b##c
+#  define Ex1(m1,m2,a,b)m1##m2(a##b)
+#  define Ex2(m1,m2,a,b,c)m1##m2(a,b##c)
+# else
+#  define Cat2(a,b)a/**/b
+#  define Cat3(a,b,c)a/**/b/**/c
+#  define Ex1(m1,m2,a,b)m1/**/m2(a/**/b)
+#  define Ex2(m1,m2,a,b,c)m1/**/m2(a,b/**/c)
+# endif
+# undef x
+#endif /* _WIN32 */
+
+/*
+ * auxiliary macros for execution order reversal
+ */
+#define seq_forw(a,b) a b
+#define seq_back(a,b) b a
+
+/*
+ * function instantiator
+ */
+#define copy_type_e_io(name,e,io,tfrom,tto,copy)		\
+    static size_t						\
+    Cat3(name,_,io)(unsigned char *dst, const unsigned char *src, size_t n) {	\
+	n /= sizeof(tfrom);					\
+	if (n && dst) {						\
+	    const tfrom *from = (const tfrom*)src;		\
+	    tto *to = (tto*)dst;				\
+	    size_t i;						\
+								\
+	    if (sizeof(tfrom) < sizeof(tto)) {			\
+		from += n;					\
+		to += n;					\
+		for (i = 0; i < n; i++) {			\
+		    --from;					\
+		    --to;					\
+		    copy(e,io,seq_back)				\
+		}						\
+	    }							\
+	    else {						\
+		for (i = 0; i < n; i++) {			\
+		    copy(e,io,seq_forw)				\
+		    from++;					\
+		    to++;					\
+		}						\
+	    }							\
+	}							\
+	return n * sizeof(tto);					\
+    }
+
+#define copy_type_e(name,e,type,copy)				\
+    copy_type_e_io(name,e,tom,Cat2(__ext_,type),type,copy)	\
+    copy_type_e_io(name,e,tof,type,Cat2(__ext_,type),copy)
+
+/*
+ * master function instantiator
+ */
+#define copy_type(name,version,type,copy)		\
+    copy_type_e(Cat3(name,L,version),L,type,copy)	\
+    copy_type_e(Cat3(name,M,version),M,type,copy)
+
+/*
+ * scalar copying
+ */
+#define copy_scalar_tom(type)	*to = Cat2(__load_,type)(*from);
+#define copy_scalar_tof(type)	Cat2(__store_,type)(*to, *from);
+
+/*
+ * structure member copying
+ */
+#define copy_tom(mb,type)	to->mb = Cat2(__load_,type)(from->mb);
+#define copy_tof(mb,type)	Cat2(__store_,type)(to->mb, from->mb);
+
+/*
+ * structure member copying (direction independent)
+ */
+#define copy_byte(e,io,mb)	to->mb = from->mb;
+#define copy_addr(e,io,mb)	Ex2(copy_,io,mb,u64,e)
+#define copy_half(e,io,mb)	Ex2(copy_,io,mb,u16,e)
+#define copy_off(e,io,mb)	Ex2(copy_,io,mb,u64,e)
+#define copy_sword(e,io,mb)	Ex2(copy_,io,mb,i32,e)
+#define copy_word(e,io,mb)	Ex2(copy_,io,mb,u32,e)
+#define copy_sxword(e,io,mb)	Ex2(copy_,io,mb,i64,e)
+#define copy_xword(e,io,mb)	Ex2(copy_,io,mb,u64,e)
+#define copy_arr(e,io,mb)	\
+    array_copy(to->mb, sizeof(to->mb), from->mb, sizeof(from->mb));
+
+/*
+ * scalar copying (direction independent)
+ * these macros are used as `copy' arguments to copy_type()
+ */
+#define copy_addr_11(e,io,seq)	Ex1(copy_scalar_,io,u64,e)
+#define copy_half_11(e,io,seq)	Ex1(copy_scalar_,io,u16,e)
+#define copy_off_11(e,io,seq)	Ex1(copy_scalar_,io,u64,e)
+#define copy_sword_11(e,io,seq)	Ex1(copy_scalar_,io,i32,e)
+#define copy_word_11(e,io,seq)	Ex1(copy_scalar_,io,u32,e)
+#define copy_sxword_11(e,io,seq)Ex1(copy_scalar_,io,i64,e)
+#define copy_xword_11(e,io,seq)	Ex1(copy_scalar_,io,u64,e)
+
+/*
+ * structure copying (direction independent)
+ * these macros are used as `copy' arguments to copy_type()
+ */
+#define copy_dyn_11(e,io,seq)		\
+    seq(copy_xword(e,io,d_tag),		\
+    seq(copy_addr(e,io,d_un.d_ptr),	\
+    nullcopy))
+#define copy_ehdr_11(e,io,seq)		\
+    seq(copy_arr(e,io,e_ident),		\
+    seq(copy_half(e,io,e_type),		\
+    seq(copy_half(e,io,e_machine),	\
+    seq(copy_word(e,io,e_version),	\
+    seq(copy_addr(e,io,e_entry),	\
+    seq(copy_off(e,io,e_phoff),		\
+    seq(copy_off(e,io,e_shoff),		\
+    seq(copy_word(e,io,e_flags),	\
+    seq(copy_half(e,io,e_ehsize),	\
+    seq(copy_half(e,io,e_phentsize),	\
+    seq(copy_half(e,io,e_phnum),	\
+    seq(copy_half(e,io,e_shentsize),	\
+    seq(copy_half(e,io,e_shnum),	\
+    seq(copy_half(e,io,e_shstrndx),	\
+    nullcopy))))))))))))))
+#define copy_phdr_11(e,io,seq)		\
+    seq(copy_word(e,io,p_type),		\
+    seq(copy_word(e,io,p_flags),	\
+    seq(copy_off(e,io,p_offset),	\
+    seq(copy_addr(e,io,p_vaddr),	\
+    seq(copy_addr(e,io,p_paddr),	\
+    seq(copy_xword(e,io,p_filesz),	\
+    seq(copy_xword(e,io,p_memsz),	\
+    seq(copy_xword(e,io,p_align),	\
+    nullcopy))))))))
+#if __LIBELF64_IRIX
+#define copy_rela_11(e,io,seq)		\
+    seq(copy_addr(e,io,r_offset),	\
+    seq(copy_word(e,io,r_sym),		\
+    seq(copy_byte(e,io,r_ssym),		\
+    seq(copy_byte(e,io,r_type3),	\
+    seq(copy_byte(e,io,r_type2),	\
+    seq(copy_byte(e,io,r_type),		\
+    seq(copy_sxword(e,io,r_addend),	\
+    nullcopy)))))))
+#define copy_rel_11(e,io,seq)		\
+    seq(copy_addr(e,io,r_offset),	\
+    seq(copy_word(e,io,r_sym),		\
+    seq(copy_byte(e,io,r_ssym),		\
+    seq(copy_byte(e,io,r_type3),	\
+    seq(copy_byte(e,io,r_type2),	\
+    seq(copy_byte(e,io,r_type),		\
+    nullcopy))))))
+#else /* __LIBELF64_IRIX */
+#define copy_rela_11(e,io,seq)		\
+    seq(copy_addr(e,io,r_offset),	\
+    seq(copy_xword(e,io,r_info),	\
+    seq(copy_sxword(e,io,r_addend),	\
+    nullcopy)))
+#define copy_rel_11(e,io,seq)		\
+    seq(copy_addr(e,io,r_offset),	\
+    seq(copy_xword(e,io,r_info),	\
+    nullcopy))
+#endif /* __LIBELF64_IRIX */
+#define copy_shdr_11(e,io,seq)		\
+    seq(copy_word(e,io,sh_name),	\
+    seq(copy_word(e,io,sh_type),	\
+    seq(copy_xword(e,io,sh_flags),	\
+    seq(copy_addr(e,io,sh_addr),	\
+    seq(copy_off(e,io,sh_offset),	\
+    seq(copy_xword(e,io,sh_size),	\
+    seq(copy_word(e,io,sh_link),	\
+    seq(copy_word(e,io,sh_info),	\
+    seq(copy_xword(e,io,sh_addralign),	\
+    seq(copy_xword(e,io,sh_entsize),	\
+    nullcopy))))))))))
+#define copy_sym_11(e,io,seq)		\
+    seq(copy_word(e,io,st_name),	\
+    seq(copy_byte(e,io,st_info),	\
+    seq(copy_byte(e,io,st_other),	\
+    seq(copy_half(e,io,st_shndx),	\
+    seq(copy_addr(e,io,st_value),	\
+    seq(copy_xword(e,io,st_size),	\
+    nullcopy))))))
+
+#define nullcopy /**/
+
+static size_t
+byte_copy(unsigned char *dst, const unsigned char *src, size_t n) {
+    if (n && dst && dst != src) {
+#if HAVE_BROKEN_MEMMOVE
+	size_t i;
+
+	if (dst >= src + n || dst + n <= src) {
+	    memcpy(dst, src, n);
+	}
+	else if (dst < src) {
+	    for (i = 0; i < n; i++) {
+		dst[i] = src[i];
+	    }
+	}
+	else {
+	    for (i = n; --i; ) {
+		dst[i] = src[i];
+	    }
+	}
+#else /* HAVE_BROKEN_MEMMOVE */
+	memmove(dst, src, n);
+#endif /* HAVE_BROKEN_MEMMOVE */
+    }
+    return n;
+}
+
+static void
+array_copy(unsigned char *dst, size_t dlen, const unsigned char *src, size_t slen) {
+    byte_copy(dst, src, dlen < slen ? dlen : slen);
+    if (dlen > slen) {
+	memset(dst + slen, 0, dlen - slen);
+    }
+}
+
+/*
+ * instantiate copy functions
+ */
+copy_type(addr_64,_,Elf64_Addr,copy_addr_11)
+copy_type(half_64,_,Elf64_Half,copy_half_11)
+copy_type(off_64,_,Elf64_Off,copy_off_11)
+copy_type(sword_64,_,Elf64_Sword,copy_sword_11)
+copy_type(word_64,_,Elf64_Word,copy_word_11)
+copy_type(sxword_64,_,Elf64_Sxword,copy_sxword_11)
+copy_type(xword_64,_,Elf64_Xword,copy_xword_11)
+copy_type(dyn_64,11,Elf64_Dyn,copy_dyn_11)
+copy_type(ehdr_64,11,Elf64_Ehdr,copy_ehdr_11)
+copy_type(phdr_64,11,Elf64_Phdr,copy_phdr_11)
+copy_type(rela_64,11,Elf64_Rela,copy_rela_11)
+copy_type(rel_64,11,Elf64_Rel,copy_rel_11)
+copy_type(shdr_64,11,Elf64_Shdr,copy_shdr_11)
+copy_type(sym_64,11,Elf64_Sym,copy_sym_11)
+
+typedef size_t (*xlator)(unsigned char*, const unsigned char*, size_t);
+typedef xlator xltab[ELF_T_NUM][2];
+
+/*
+ * translation table (64-bit, version 1 -> version 1)
+ */
+#if PIC
+static xltab
+#else /* PIC */
+static const xltab
+#endif /* PIC */
+xlate64_11[/*encoding*/] = {
+    {
+	{ byte_copy,        byte_copy       },
+	{ addr_64L__tom,    addr_64L__tof   },
+	{ dyn_64L11_tom,    dyn_64L11_tof   },
+	{ ehdr_64L11_tom,   ehdr_64L11_tof  },
+	{ half_64L__tom,    half_64L__tof   },
+	{ off_64L__tom,     off_64L__tof    },
+	{ phdr_64L11_tom,   phdr_64L11_tof  },
+	{ rela_64L11_tom,   rela_64L11_tof  },
+	{ rel_64L11_tom,    rel_64L11_tof   },
+	{ shdr_64L11_tom,   shdr_64L11_tof  },
+	{ sword_64L__tom,   sword_64L__tof  },
+	{ sym_64L11_tom,    sym_64L11_tof   },
+	{ word_64L__tom,    word_64L__tof   },
+	{ sxword_64L__tom,  sxword_64L__tof },
+	{ xword_64L__tom,   xword_64L__tof  },
+#if __LIBELF_SYMBOL_VERSIONS
+	{ _elf_verdef_64L11_tom,  _elf_verdef_64L11_tof  },
+	{ _elf_verneed_64L11_tom, _elf_verneed_64L11_tof },
+#else /* __LIBELF_SYMBOL_VERSIONS */
+	{ 0,                0               },
+	{ 0,                0               },
+#endif /* __LIBELF_SYMBOL_VERSIONS */
+    },
+    {
+	{ byte_copy,        byte_copy       },
+	{ addr_64M__tom,    addr_64M__tof   },
+	{ dyn_64M11_tom,    dyn_64M11_tof   },
+	{ ehdr_64M11_tom,   ehdr_64M11_tof  },
+	{ half_64M__tom,    half_64M__tof   },
+	{ off_64M__tom,     off_64M__tof    },
+	{ phdr_64M11_tom,   phdr_64M11_tof  },
+	{ rela_64M11_tom,   rela_64M11_tof  },
+	{ rel_64M11_tom,    rel_64M11_tof   },
+	{ shdr_64M11_tom,   shdr_64M11_tof  },
+	{ sword_64M__tom,   sword_64M__tof  },
+	{ sym_64M11_tom,    sym_64M11_tof   },
+	{ word_64M__tom,    word_64M__tof   },
+	{ sxword_64M__tom,  sxword_64M__tof },
+	{ xword_64M__tom,   xword_64M__tof  },
+#if __LIBELF_SYMBOL_VERSIONS
+	{ _elf_verdef_64M11_tom,  _elf_verdef_64M11_tof  },
+	{ _elf_verneed_64M11_tom, _elf_verneed_64M11_tof },
+#else /* __LIBELF_SYMBOL_VERSIONS */
+	{ 0,                0               },
+	{ 0,                0               },
+#endif /* __LIBELF_SYMBOL_VERSIONS */
+    },
+};
+
+/*
+ * main translation table (64-bit)
+ */
+#if PIC
+static xltab*
+#else /* PIC */
+static const xltab *const
+#endif /* PIC */
+xlate64[EV_CURRENT - EV_NONE][EV_CURRENT - EV_NONE] = {
+    { xlate64_11, },
+};
+
+#define translator(sv,dv,enc,type,d)	\
+    (xlate64[(sv) - EV_NONE - 1]	\
+	    [(dv) - EV_NONE - 1]	\
+	    [(enc) - ELFDATA2LSB]	\
+	    [(type) - ELF_T_BYTE]	\
+	    [d])
+
+/*
+ * destination buffer size
+ */
+size_t
+_elf64_xltsize(const Elf_Data *src, unsigned dv, unsigned encode, int tof) {
+    Elf_Type type = src->d_type;
+    unsigned sv = src->d_version;
+    xlator op;
+
+    if (!valid_version(sv) || !valid_version(dv)) {
+	seterr(ERROR_UNKNOWN_VERSION);
+	return (size_t)-1;
+    }
+    if (tof) {
+	/*
+	 * Encoding doesn't really matter (the translator only looks at
+	 * the source, which resides in memory), but we need a proper
+	 * encoding to select a translator...
+	 */
+	encode = ELFDATA2LSB;
+    }
+    else if (!valid_encoding(encode)) {
+	seterr(ERROR_UNKNOWN_ENCODING);
+	return (size_t)-1;
+    }
+    if (!valid_type(type)) {
+	seterr(ERROR_UNKNOWN_TYPE);
+	return (size_t)-1;
+    }
+    if (!(op = translator(sv, dv, encode, type, tof))) {
+	seterr(ERROR_UNKNOWN_TYPE);
+	return (size_t)-1;
+    }
+    return (*op)(NULL, src->d_buf, src->d_size);
+}
+
+/*
+ * direction-independent translation
+ */
+static Elf_Data*
+elf64_xlate(Elf_Data *dst, const Elf_Data *src, unsigned encode, int tof) {
+    Elf_Type type;
+    int dv;
+    int sv;
+    size_t dsize;
+    size_t tmp;
+    xlator op;
+
+    if (!src || !dst) {
+	return NULL;
+    }
+    if (!src->d_buf || !dst->d_buf) {
+	seterr(ERROR_NULLBUF);
+	return NULL;
+    }
+    if (!valid_encoding(encode)) {
+	seterr(ERROR_UNKNOWN_ENCODING);
+	return NULL;
+    }
+    sv = src->d_version;
+    dv = dst->d_version;
+    if (!valid_version(sv) || !valid_version(dv)) {
+	seterr(ERROR_UNKNOWN_VERSION);
+	return NULL;
+    }
+    type = src->d_type;
+    if (!valid_type(type)) {
+	seterr(ERROR_UNKNOWN_TYPE);
+	return NULL;
+    }
+    op = translator(sv, dv, encode, type, tof);
+    if (!op) {
+	seterr(ERROR_UNKNOWN_TYPE);
+	return NULL;
+    }
+    dsize = (*op)(NULL, src->d_buf, src->d_size);
+    if (dsize == (size_t)-1) {
+	return NULL;
+    }
+    if (dst->d_size < dsize) {
+	seterr(ERROR_DST2SMALL);
+	return NULL;
+    }
+    if (dsize) {
+	tmp = (*op)(dst->d_buf, src->d_buf, src->d_size);
+	if (tmp == (size_t)-1) {
+	    return NULL;
+	}
+	elf_assert(tmp == dsize);
+    }
+    dst->d_size = dsize;
+    dst->d_type = type;
+    return dst;
+}
+
+/*
+ * finally, the "official" translation functions
+ */
+Elf_Data*
+elf64_xlatetom(Elf_Data *dst, const Elf_Data *src, unsigned encode) {
+    return elf64_xlate(dst, src, encode, 0);
+}
+
+Elf_Data*
+elf64_xlatetof(Elf_Data *dst, const Elf_Data *src, unsigned encode) {
+    return elf64_xlate(dst, src, encode, 1);
+}
+
+Elf_Data*
+gelf_xlatetom(Elf *elf, Elf_Data *dst, const Elf_Data *src, unsigned encode) {
+    if (elf) {
+	if (elf->e_kind != ELF_K_ELF) {
+	    seterr(ERROR_NOTELF);
+	}
+	else if (elf->e_class == ELFCLASS32) {
+	    return elf32_xlatetom(dst, src, encode);
+	}
+	else if (elf->e_class == ELFCLASS64) {
+	    return elf64_xlatetom(dst, src, encode);
+	}
+	else if (valid_class(elf->e_class)) {
+	    seterr(ERROR_UNIMPLEMENTED);
+	}
+	else {
+	    seterr(ERROR_UNKNOWN_CLASS);
+	}
+    }
+    return NULL;
+}
+
+Elf_Data*
+gelf_xlatetof(Elf *elf, Elf_Data *dst, const Elf_Data *src, unsigned encode) {
+    if (elf) {
+	if (elf->e_kind != ELF_K_ELF) {
+	    seterr(ERROR_NOTELF);
+	}
+	else if (elf->e_class == ELFCLASS32) {
+	    return elf32_xlatetof(dst, src, encode);
+	}
+	else if (elf->e_class == ELFCLASS64) {
+	    return elf64_xlatetof(dst, src, encode);
+	}
+	else if (valid_class(elf->e_class)) {
+	    seterr(ERROR_UNIMPLEMENTED);
+	}
+	else {
+	    seterr(ERROR_UNKNOWN_CLASS);
+	}
+    }
+    return NULL;
+}
+
+#endif /* __LIBELF64__ */

external/libelf/src/assert.c

@@ -0,0 +1,33 @@
+/*
+assert.c - assert function for libelf.
+Copyright (C) 1999 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: assert.c,v 1.5 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+#include <stdio.h>
+
+void
+__elf_assert(const char *file, unsigned line, const char *cond) {
+    fprintf(stderr, "%s:%u: libelf assertion failure: %s\n",
+	    file, line, cond);
+    abort();
+}

external/libelf/src/begin.c

@@ -0,0 +1,429 @@
+/*
+ * begin.c - implementation of the elf_begin(3) and elf_memory(3) functions.
+ * Copyright (C) 1995 - 2004 Michael Riepe
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: begin.c,v 1.22 2009/11/01 13:04:19 michael Exp $";
+#endif /* lint */
+
+static const Elf _elf_init = INIT_ELF;
+static const char fmag[] = ARFMAG;
+
+static unsigned long
+getnum(const char *str, size_t len, int base, size_t *err) {
+    unsigned long result = 0;
+
+    while (len && *str == ' ') {
+	str++; len--;
+    }
+    while (len && *str >= '0' && (*str - '0') < base) {
+	result = base * result + *str++ - '0'; len--;
+    }
+    while (len && *str == ' ') {
+	str++; len--;
+    }
+    if (len) {
+	*err = len;
+    }
+    return result;
+}
+
+static void
+_elf_init_ar(Elf *elf) {
+    struct ar_hdr *hdr;
+    size_t offset;
+    size_t size;
+    size_t err = 0;
+
+    elf->e_kind = ELF_K_AR;
+    elf->e_idlen = SARMAG;
+    elf->e_off = SARMAG;
+
+    /* process special members */
+    offset = SARMAG;
+    while (!elf->e_strtab && offset + sizeof(*hdr) <= elf->e_size) {
+	hdr = (struct ar_hdr*)(elf->e_data + offset);
+	if (memcmp(hdr->ar_fmag, fmag, sizeof(fmag) - 1)) {
+	    break;
+	}
+	if (hdr->ar_name[0] != '/') {
+	    break;
+	}
+	size = getnum(hdr->ar_size, sizeof(hdr->ar_size), 10, &err);
+	if (err || !size) {
+	    break;
+	}
+	offset += sizeof(*hdr);
+	if (offset + size > elf->e_size) {
+	    break;
+	}
+	if (hdr->ar_name[1] == '/' && hdr->ar_name[2] == ' ') {
+	    elf->e_strtab = elf->e_data + offset;
+	    elf->e_strlen = size;
+	    break;
+	}
+	if (hdr->ar_name[1] != ' ') {
+	    break;
+	}
+	/*
+	 * Windows (.lib) archives provide two symbol tables
+	 * The first one is the one we want.
+	 */
+	if (!elf->e_symtab) {
+	    elf->e_symtab = elf->e_data + offset;
+	    elf->e_symlen = size;
+	}
+	offset += size + (size & 1);
+    }
+}
+
+static Elf_Arhdr*
+_elf_arhdr(Elf *arf) {
+    struct ar_hdr *hdr;
+    Elf_Arhdr *arhdr;
+    size_t namelen;
+    size_t tmp;
+    char *name;
+    size_t err = 0;
+
+    if (arf->e_off == arf->e_size) {
+	/* no error! */
+	return NULL;
+    }
+    if (arf->e_off < 0 || arf->e_off > arf->e_size) {
+	seterr(ERROR_OUTSIDE);
+	return NULL;
+    }
+    if (arf->e_off + sizeof(*hdr) > arf->e_size) {
+	seterr(ERROR_TRUNC_ARHDR);
+	return NULL;
+    }
+    elf_assert(arf->e_data != NULL);
+    hdr = (struct ar_hdr*)(arf->e_data + arf->e_off);
+    if (memcmp(hdr->ar_fmag, fmag, sizeof(fmag) - 1)) {
+	seterr(ERROR_ARFMAG);
+	return NULL;
+    }
+
+    name = hdr->ar_name;
+    for (namelen = sizeof(hdr->ar_name); namelen > 0; namelen--) {
+	if (name[namelen - 1] != ' ') {
+	    break;
+	}
+    }
+    if (name[0] == '/') {
+	if (name[1] >= '0' && name[1] <= '9') {
+	    if (!arf->e_strtab) {
+		seterr(ERROR_ARSTRTAB);
+		return NULL;
+	    }
+	    tmp = getnum(&name[1], namelen - 1, 10, &err);
+	    if (err) {
+		seterr(ERROR_ARSPECIAL);
+		return NULL;
+	    }
+	    if (tmp < 0 || tmp >= arf->e_strlen) {
+		seterr(ERROR_ARSTRTAB);
+		return NULL;
+	    }
+	    for (namelen = tmp; namelen < arf->e_strlen; namelen++) {
+		if (arf->e_strtab[namelen] == '/') {
+		    break;
+		}
+	    }
+	    if (namelen == arf->e_strlen) {
+		seterr(ERROR_ARSTRTAB);
+		return NULL;
+	    }
+	    name = arf->e_strtab + tmp;
+	    namelen -= tmp;
+	}
+	else if (namelen != 1 && !(namelen == 2 && name[1] == '/')) {
+	    seterr(ERROR_ARSPECIAL);
+	    return NULL;
+	}
+    }
+    else if (namelen > 0 && name[namelen - 1] == '/') {
+	namelen--;
+    }
+    /* XXX some broken software omits the trailing slash
+    else {
+	namelen = 0;
+    }
+    */
+
+    if (!(arhdr = (Elf_Arhdr*)malloc(sizeof(*arhdr) +
+		     sizeof(hdr->ar_name) + namelen + 2))) {
+	seterr(ERROR_MEM_ARHDR);
+	return NULL;
+    }
+
+    arhdr->ar_name = NULL;
+    arhdr->ar_rawname = (char*)(arhdr + 1);
+    arhdr->ar_date = getnum(hdr->ar_date, sizeof(hdr->ar_date), 10, &err);
+    arhdr->ar_uid = getnum(hdr->ar_uid, sizeof(hdr->ar_uid), 10, &err);
+    arhdr->ar_gid = getnum(hdr->ar_gid, sizeof(hdr->ar_gid), 10, &err);
+    arhdr->ar_mode = getnum(hdr->ar_mode, sizeof(hdr->ar_mode), 8, &err);
+    arhdr->ar_size = getnum(hdr->ar_size, sizeof(hdr->ar_size), 10, &err);
+    if (err) {
+	free(arhdr);
+	seterr(ERROR_ARHDR);
+	return NULL;
+    }
+    if (arf->e_off + sizeof(struct ar_hdr) + arhdr->ar_size > arf->e_size) {
+	free(arhdr);
+	seterr(ERROR_TRUNC_MEMBER);
+	return NULL;
+    }
+
+    memcpy(arhdr->ar_rawname, hdr->ar_name, sizeof(hdr->ar_name));
+    arhdr->ar_rawname[sizeof(hdr->ar_name)] = '\0';
+
+    if (namelen) {
+	arhdr->ar_name = arhdr->ar_rawname + sizeof(hdr->ar_name) + 1;
+	memcpy(arhdr->ar_name, name, namelen);
+	arhdr->ar_name[namelen] = '\0';
+    }
+
+    return arhdr;
+}
+
+static void
+_elf_check_type(Elf *elf, size_t size) {
+    elf->e_idlen = size;
+    if (size >= EI_NIDENT && !memcmp(elf->e_data, ELFMAG, SELFMAG)) {
+	elf->e_kind = ELF_K_ELF;
+	elf->e_idlen = EI_NIDENT;
+	elf->e_class = elf->e_data[EI_CLASS];
+	elf->e_encoding = elf->e_data[EI_DATA];
+	elf->e_version = elf->e_data[EI_VERSION];
+    }
+    else if (size >= SARMAG && !memcmp(elf->e_data, ARMAG, SARMAG)) {
+	_elf_init_ar(elf);
+    }
+}
+
+Elf*
+elf_begin(int fd, Elf_Cmd cmd, Elf *ref) {
+    Elf_Arhdr *arhdr = NULL;
+    size_t size = 0;
+    off_t off;
+    Elf *elf;
+
+    elf_assert(_elf_init.e_magic == ELF_MAGIC);
+    if (_elf_version == EV_NONE) {
+	seterr(ERROR_VERSION_UNSET);
+	return NULL;
+    }
+    else if (cmd == ELF_C_NULL) {
+	return NULL;
+    }
+    else if (cmd == ELF_C_WRITE) {
+	ref = NULL;
+    }
+    else if (cmd != ELF_C_READ && cmd != ELF_C_RDWR) {
+	seterr(ERROR_INVALID_CMD);
+	return NULL;
+    }
+    else if (ref) {
+	elf_assert(ref->e_magic == ELF_MAGIC);
+	if (!ref->e_readable || (cmd == ELF_C_RDWR && !ref->e_writable)) {
+	    seterr(ERROR_CMDMISMATCH);
+	    return NULL;
+	}
+	if (ref->e_kind != ELF_K_AR) {
+	    ref->e_count++;
+	    return ref;
+	}
+	if (cmd == ELF_C_RDWR) {
+	    seterr(ERROR_MEMBERWRITE);
+	    return NULL;
+	}
+	if (ref->e_memory) {
+	    fd = ref->e_fd;
+	}
+	else if (fd != ref->e_fd) {
+	    seterr(ERROR_FDMISMATCH);
+	    return NULL;
+	}
+	if (!(arhdr = _elf_arhdr(ref))) {
+	    return NULL;
+	}
+	size = arhdr->ar_size;
+    }
+    else if ((off = lseek(fd, (off_t)0, SEEK_END)) == (off_t)-1
+	  || (off_t)(size = off) != off) {
+	seterr(ERROR_IO_GETSIZE);
+	return NULL;
+    }
+
+    if (!(elf = (Elf*)malloc(sizeof(Elf)))) {
+	seterr(ERROR_MEM_ELF);
+	return NULL;
+    }
+    *elf = _elf_init;
+    elf->e_fd = fd;
+    elf->e_parent = ref;
+    elf->e_size = elf->e_dsize = size;
+
+    if (cmd != ELF_C_READ) {
+	elf->e_writable = 1;
+    }
+    if (cmd != ELF_C_WRITE) {
+	elf->e_readable = 1;
+    }
+    else {
+	return elf;
+    }
+
+    if (ref) {
+	size_t offset = ref->e_off + sizeof(struct ar_hdr);
+	Elf *xelf;
+
+	elf_assert(arhdr);
+	elf->e_arhdr = arhdr;
+	elf->e_base = ref->e_base + offset;
+	/*
+	 * Share the archive's memory image. To avoid
+	 * multiple independent elf descriptors if the
+	 * same member is requested twice, scan the list
+	 * of open members for duplicates.
+	 *
+	 * I don't know how SVR4 handles this case. Don't rely on it.
+	 */
+	for (xelf = ref->e_members; xelf; xelf = xelf->e_link) {
+	    elf_assert(xelf->e_parent == ref);
+	    if (xelf->e_base == elf->e_base) {
+		free(arhdr);
+		free(elf);
+		xelf->e_count++;
+		return xelf;
+	    }
+	}
+	if (size == 0) {
+	    elf->e_data = NULL;
+	}
+#if 1
+	else {
+	    /*
+	     * Archive members may be misaligned.  Freezing them will
+	     * cause libelf to allocate buffers for translated data,
+	     * which should be properly aligned in all cases.
+	     */
+	    elf_assert(!ref->e_cooked);
+	    elf->e_data = elf->e_rawdata = ref->e_data + offset;
+	}
+#else
+	else if (ref->e_data == ref->e_rawdata) {
+	    elf_assert(!ref->e_cooked);
+	    /*
+	     * archive is frozen - freeze member, too
+	     */
+	    elf->e_data = elf->e_rawdata = ref->e_data + offset;
+	}
+	else {
+	    elf_assert(!ref->e_memory);
+	    elf->e_data = ref->e_data + offset;
+	    /*
+	     * The member's memory image may have been modified if
+	     * the member has been processed before. Since we need the
+	     * original image, we have to re-read the archive file.
+	     * Will fail if the archive's file descriptor is disabled.
+	     */
+	    if (!ref->e_cooked) {
+		ref->e_cooked = 1;
+	    }
+	    else if (!_elf_read(ref, elf->e_data, offset, size)) {
+		free(arhdr);
+		free(elf);
+		return NULL;
+	    }
+	}
+#endif
+	elf->e_next = offset + size + (size & 1);
+	elf->e_disabled = ref->e_disabled;
+	elf->e_memory = ref->e_memory;
+	/* parent/child linking */
+	elf->e_link = ref->e_members;
+	ref->e_members = elf;
+	ref->e_count++;
+	/* Slowaris compatibility - do not rely on this! */
+	ref->e_off = elf->e_next;
+    }
+    else if (size) {
+#if HAVE_MMAP
+	/*
+	 * Using mmap on writable files will interfere with elf_update
+	 */
+	if (!elf->e_writable && (elf->e_data = _elf_mmap(elf))) {
+	    elf->e_unmap_data = 1;
+	}
+	else
+#endif /* HAVE_MMAP */
+	if (!(elf->e_data = _elf_read(elf, NULL, 0, size))) {
+	    free(elf);
+	    return NULL;
+	}
+    }
+
+    _elf_check_type(elf, size);
+    return elf;
+}
+
+Elf*
+elf_memory(char *image, size_t size) {
+    Elf *elf;
+
+    elf_assert(_elf_init.e_magic == ELF_MAGIC);
+    if (_elf_version == EV_NONE) {
+	seterr(ERROR_VERSION_UNSET);
+	return NULL;
+    }
+    else if (size == 0 || image == NULL) {
+	/* TODO: set error code? */
+	return NULL;
+    }
+
+    if (!(elf = (Elf*)malloc(sizeof(Elf)))) {
+	seterr(ERROR_MEM_ELF);
+	return NULL;
+    }
+    *elf = _elf_init;
+    elf->e_size = elf->e_dsize = size;
+    elf->e_data = elf->e_rawdata = image;
+    elf->e_readable = 1;
+    elf->e_disabled = 1;
+    elf->e_memory = 1;
+
+    _elf_check_type(elf, size);
+    return elf;
+}
+
+#if __LIBELF64
+
+int
+gelf_getclass(Elf *elf) {
+    if (elf && elf->e_kind == ELF_K_ELF && valid_class(elf->e_class)) {
+	return elf->e_class;
+    }
+    return ELFCLASSNONE;
+}
+
+#endif /* __LIBELF64 */

external/libelf/src/byteswap.h

@@ -0,0 +1,95 @@
+/*
+byteswap.h - functions and macros for byte swapping.
+Copyright (C) 1995 - 2001 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+/* @(#) $Id: byteswap.h,v 1.7 2008/05/23 08:15:34 michael Exp $ */
+
+#ifndef _BYTESWAP_H
+#define _BYTESWAP_H
+
+#define lu(from,i,s)	(((__libelf_u32_t)((unsigned char*)(from))[i])<<(s))
+#define li(from,i,s)	(((__libelf_i32_t)((  signed char*)(from))[i])<<(s))
+
+#define __load_u16L(from)	((__libelf_u32_t) \
+    (lu(from,1,8) | lu(from,0,0)))
+#define __load_u16M(from)	((__libelf_u32_t) \
+    (lu(from,0,8) | lu(from,1,0)))
+#define __load_i16L(from)	((__libelf_i32_t) \
+    (li(from,1,8) | lu(from,0,0)))
+#define __load_i16M(from)	((__libelf_i32_t) \
+    (li(from,0,8) | lu(from,1,0)))
+
+#define __load_u32L(from)	((__libelf_u32_t) \
+    (lu(from,3,24) | lu(from,2,16) | lu(from,1,8) | lu(from,0,0)))
+#define __load_u32M(from)	((__libelf_u32_t) \
+    (lu(from,0,24) | lu(from,1,16) | lu(from,2,8) | lu(from,3,0)))
+#define __load_i32L(from)	((__libelf_i32_t) \
+    (li(from,3,24) | lu(from,2,16) | lu(from,1,8) | lu(from,0,0)))
+#define __load_i32M(from)	((__libelf_i32_t) \
+    (li(from,0,24) | lu(from,1,16) | lu(from,2,8) | lu(from,3,0)))
+
+#define su(to,i,v,s)	(((char*)(to))[i]=((__libelf_u32_t)(v)>>(s)))
+#define si(to,i,v,s)	(((char*)(to))[i]=((__libelf_i32_t)(v)>>(s)))
+
+#define __store_u16L(to,v)	\
+    (su(to,1,v,8), su(to,0,v,0))
+#define __store_u16M(to,v)	\
+    (su(to,0,v,8), su(to,1,v,0))
+#define __store_i16L(to,v)	\
+    (si(to,1,v,8), si(to,0,v,0))
+#define __store_i16M(to,v)	\
+    (si(to,0,v,8), si(to,1,v,0))
+
+#define __store_u32L(to,v)	\
+    (su(to,3,v,24), su(to,2,v,16), su(to,1,v,8), su(to,0,v,0))
+#define __store_u32M(to,v)	\
+    (su(to,0,v,24), su(to,1,v,16), su(to,2,v,8), su(to,3,v,0))
+#define __store_i32L(to,v)	\
+    (si(to,3,v,24), si(to,2,v,16), si(to,1,v,8), si(to,0,v,0))
+#define __store_i32M(to,v)	\
+    (si(to,0,v,24), si(to,1,v,16), si(to,2,v,8), si(to,3,v,0))
+
+#if __LIBELF64
+
+/*
+ * conversion functions from swap64.c
+ */
+extern __libelf_u64_t _elf_load_u64L(const unsigned char *from);
+extern __libelf_u64_t _elf_load_u64M(const unsigned char *from);
+extern __libelf_i64_t _elf_load_i64L(const unsigned char *from);
+extern __libelf_i64_t _elf_load_i64M(const unsigned char *from);
+extern void _elf_store_u64L(unsigned char *to, __libelf_u64_t v);
+extern void _elf_store_u64M(unsigned char *to, __libelf_u64_t v);
+extern void _elf_store_i64L(unsigned char *to, __libelf_u64_t v);
+extern void _elf_store_i64M(unsigned char *to, __libelf_u64_t v);
+
+/*
+ * aliases for existing conversion code
+ */
+#define __load_u64L	_elf_load_u64L
+#define __load_u64M	_elf_load_u64M
+#define __load_i64L	_elf_load_i64L
+#define __load_i64M	_elf_load_i64M
+#define __store_u64L	_elf_store_u64L
+#define __store_u64M	_elf_store_u64M
+#define __store_i64L	_elf_store_i64L
+#define __store_i64M	_elf_store_i64M
+
+#endif /* __LIBELF64 */
+
+#endif /* _BYTESWAP_H */

external/libelf/src/checksum.c

@@ -0,0 +1,178 @@
+/*
+checksum.c - implementation of the elf{32,64}_checksum(3) functions.
+Copyright (C) 1995 - 2001 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: checksum.c,v 1.7 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+/*
+ * Compatibility note:
+ *
+ * The algorithm used in {elf32,elf64,gelf}_checksum() does not seem to
+ * be documented.  I hope I got it right.  My implementation does the
+ * following:
+ *
+ *   - skip sections that do not have the SHF_ALLOC flag set
+ *   - skip sections of type SHT_NULL, SHT_NOBITS, SHT_DYNSYM and
+ *     SHT_DYNAMIC
+ *   - add all data bytes from the remaining sections, modulo 2**32
+ *   - add upper and lower half of the result
+ *   - subtract 0xffff if the result is > 0xffff
+ *   - if any error occurs, return 0L
+ */
+
+static int
+skip_section(Elf_Scn *scn, unsigned cls) {
+    if (cls == ELFCLASS32) {
+	Elf32_Shdr *shdr = &scn->s_shdr32;
+
+	if (!(shdr->sh_flags & SHF_ALLOC)) {
+	    return 1;
+	}
+	switch (shdr->sh_type) {
+	    case SHT_NULL:
+	    case SHT_NOBITS:
+	    /* Solaris seems to ignore these, too */
+	    case SHT_DYNSYM:
+	    case SHT_DYNAMIC:
+		return 1;
+	}
+    }
+#if __LIBELF64
+    else if (cls == ELFCLASS64) {
+	Elf64_Shdr *shdr = &scn->s_shdr64;
+
+	if (!(shdr->sh_flags & SHF_ALLOC)) {
+	    return 1;
+	}
+	switch (shdr->sh_type) {
+	    case SHT_NULL:
+	    case SHT_NOBITS:
+	    /* Solaris seems to ignore these, too */
+	    case SHT_DYNSYM:
+	    case SHT_DYNAMIC:
+		return 1;
+	}
+    }
+#endif /* __LIBELF64 */
+    else {
+	seterr(ERROR_UNIMPLEMENTED);
+    }
+    return 0;
+}
+
+static long
+add_bytes(unsigned char *ptr, size_t len) {
+    long csum = 0;
+
+    while (len--) {
+	csum += *ptr++;
+    }
+    return csum;
+}
+
+static long
+_elf_csum(Elf *elf) {
+    long csum = 0;
+    Elf_Data *data;
+    Elf_Scn *scn;
+
+    if (!elf->e_ehdr && !_elf_cook(elf)) {
+	/* propagate errors from _elf_cook */
+	return 0L;
+    }
+    seterr(0);
+    for (scn = elf->e_scn_1; scn; scn = scn->s_link) {
+	if (scn->s_index == SHN_UNDEF || skip_section(scn, elf->e_class)) {
+	    continue;
+	}
+	data = NULL;
+	while ((data = elf_getdata(scn, data))) {
+	    if (data->d_size) {
+		if (data->d_buf == NULL) {
+		    seterr(ERROR_NULLBUF);
+		    return 0L;
+		}
+		csum += add_bytes(data->d_buf, data->d_size);
+	    }
+	}
+    }
+    if (_elf_errno) {
+	return 0L;
+    }
+    csum = (csum & 0xffff) + ((csum >> 16) & 0xffff);
+    if (csum > 0xffff) {
+	csum -= 0xffff;
+    }
+    return csum;
+}
+
+long
+elf32_checksum(Elf *elf) {
+    if (elf) {
+	if (elf->e_kind != ELF_K_ELF) {
+	    seterr(ERROR_NOTELF);
+	}
+	else if (elf->e_class != ELFCLASS32) {
+	    seterr(ERROR_CLASSMISMATCH);
+	}
+	else {
+	    return _elf_csum(elf);
+	}
+    }
+    return 0L;
+}
+
+#if __LIBELF64
+
+long
+elf64_checksum(Elf *elf) {
+    if (elf) {
+	if (elf->e_kind != ELF_K_ELF) {
+	    seterr(ERROR_NOTELF);
+	}
+	else if (elf->e_class != ELFCLASS64) {
+	    seterr(ERROR_CLASSMISMATCH);
+	}
+	else {
+	    return _elf_csum(elf);
+	}
+    }
+    return 0L;
+}
+
+long
+gelf_checksum(Elf *elf) {
+    if (elf) {
+	if (elf->e_kind != ELF_K_ELF) {
+	    seterr(ERROR_NOTELF);
+	}
+	else if (!valid_class(elf->e_class)) {
+	    seterr(ERROR_UNKNOWN_CLASS);
+	}
+	else {
+	    return _elf_csum(elf);
+	}
+    }
+    return 0L;
+}
+
+#endif /* __LIBELF64 */

external/libelf/src/cntl.c

@@ -0,0 +1,71 @@
+/*
+cntl.c - implementation of the elf_cntl(3) function.
+Copyright (C) 1995 - 1998 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: cntl.c,v 1.7 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+int
+elf_cntl(Elf *elf, Elf_Cmd cmd) {
+    Elf_Scn *scn;
+    Elf *child;
+
+    if (!elf) {
+	return -1;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if (cmd == ELF_C_FDREAD) {
+	if (!elf->e_readable) {
+	    seterr(ERROR_WRONLY);
+	    return -1;
+	}
+    }
+    else if (cmd != ELF_C_FDDONE) {
+	seterr(ERROR_INVALID_CMD);
+	return -1;
+    }
+    if (elf->e_disabled) {
+	return 0;
+    }
+    if (elf->e_kind == ELF_K_AR) {
+	for (child = elf->e_members; child; child = child->e_link) {
+	    elf_assert(elf == child->e_parent);
+	    if (elf_cntl(child, cmd)) {
+		return -1;
+	    }
+	}
+    }
+    else if (elf->e_kind == ELF_K_ELF && cmd == ELF_C_FDREAD) {
+	if (!elf->e_ehdr && !_elf_cook(elf)) {
+	    return -1;
+	}
+	for (scn = elf->e_scn_1; scn; scn = scn->s_link) {
+	    if (scn->s_index == SHN_UNDEF || scn->s_type == SHT_NULL) {
+		continue;
+	    }
+	    else if (!elf_getdata(scn, NULL)) {
+		return -1;
+	    }
+	}
+    }
+    elf->e_disabled = 1;
+    return 0;
+}

external/libelf/src/config.h

@@ -0,0 +1,164 @@
+/*
+ * lib/config.h.w32 - configuration file for W32 port
+ * Copyright (C) 2004 - 2006 Michael Riepe
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * @(#) $Id: config.h.w32,v 1.2 2006/09/07 15:55:42 michael Exp $
+ */
+
+/* Define to empty if the keyword does not work.  */
+#undef const
+
+/* Define if you have a working `mmap' system call.  */
+#undef HAVE_MMAP
+
+/* Define to `long' if <sys/types.h> doesn't define.  */
+#undef off_t
+
+/* Define to `unsigned' if <sys/types.h> doesn't define.  */
+#undef size_t
+
+/* Define if you have the ANSI C header files.  */
+#define STDC_HEADERS 1
+
+/* Define if you want to include extra debugging code */
+#define ENABLE_DEBUG 1
+
+/* Define if memmove() does not copy overlapping arrays correctly */
+#undef HAVE_BROKEN_MEMMOVE
+
+/* Define if you have the catgets function. */
+#undef HAVE_CATGETS
+
+/* Define if you have the dgettext function. */
+#undef HAVE_DGETTEXT
+
+/* Define if you have the memset function.  */
+#define HAVE_MEMSET 1
+
+/* Define if struct nlist is declared in <elf.h> or <sys/elf.h> */
+#undef HAVE_STRUCT_NLIST_DECLARATION
+
+/* Define if Elf32_Dyn is declared in <link.h> */
+#undef __LIBELF_NEED_LINK_H
+
+/* Define if Elf32_Dyn is declared in <sys/link.h> */
+#undef __LIBELF_NEED_SYS_LINK_H
+
+/* Define to `<elf.h>' or `<sys/elf.h>' if one of them is present */
+#undef __LIBELF_HEADER_ELF_H
+
+/* Define if you want 64-bit support (and your system supports it) */
+#define __LIBELF64 1
+
+/* Define if you want 64-bit support, and are running IRIX */
+#undef __LIBELF64_IRIX
+
+/* Define if you want 64-bit support, and are running Linux */
+#undef __LIBELF64_LINUX
+
+/* Define if you want symbol versioning (and your system supports it) */
+#define __LIBELF_SYMBOL_VERSIONS 1
+
+/* Define if symbol versioning uses Sun section type (SHT_SUNW_*) */
+#define __LIBELF_SUN_SYMBOL_VERSIONS 1
+
+/* Define if symbol versioning uses GNU section types (SHT_GNU_*) */
+#undef __LIBELF_GNU_SYMBOL_VERSIONS
+
+/* Define to a 64-bit signed integer type if one exists */
+#define __libelf_i64_t __int64
+
+/* Define to a 64-bit unsigned integer type if one exists */
+#define __libelf_u64_t unsigned __int64
+
+/* Define to a 32-bit signed integer type if one exists */
+#define __libelf_i32_t int
+
+/* Define to a 32-bit unsigned integer type if one exists */
+#define __libelf_u32_t unsigned int
+
+/* Define to a 16-bit signed integer type if one exists */
+#define __libelf_i16_t short int
+
+/* Define to a 16-bit unsigned integer type if one exists */
+#define __libelf_u16_t unsigned short int
+
+/* The number of bytes in a __int64.  */
+#define SIZEOF___INT64 8
+
+/* The number of bytes in a int.  */
+#define SIZEOF_INT 4
+
+/* The number of bytes in a long.  */
+#define SIZEOF_LONG 4
+
+/* The number of bytes in a long long.  */
+#define SIZEOF_LONG_LONG 0
+
+/* The number of bytes in a short.  */
+#define SIZEOF_SHORT 2
+
+/* Define if you have the ftruncate function.  */
+#undef HAVE_FTRUNCATE
+
+/* Define if you have the getpagesize function.  */
+#undef HAVE_GETPAGESIZE
+
+/* Define if you have the memcmp function.  */
+#define HAVE_MEMCMP 1
+
+/* Define if you have the memcpy function.  */
+#define HAVE_MEMCPY 1
+
+/* Define if you have the memmove function.  */
+#define HAVE_MEMMOVE 1
+
+/* Define if you have the memset function.  */
+#define HAVE_MEMSET 1
+
+/* Define if you have the <ar.h> header file.  */
+#undef HAVE_AR_H
+
+/* Define if you have the <elf.h> header file.  */
+#undef HAVE_ELF_H
+
+/* Define if you have the <fcntl.h> header file.  */
+#undef HAVE_FCNTL_H
+
+/* Define if you have the <gelf.h> header file.  */
+#undef HAVE_GELF_H
+
+/* Define if you have the <libelf.h> header file.  */
+#undef HAVE_LIBELF_H
+
+/* Define if you have the <link.h> header file.  */
+#undef HAVE_LINK_H
+
+/* Define if you have the <nlist.h> header file.  */
+#undef HAVE_NLIST_H
+
+/* Define if you have the <sys/elf.h> header file.  */
+#undef HAVE_SYS_ELF_H
+
+/* Define if you have the <sys/link.h> header file.  */
+#undef HAVE_SYS_LINK_H
+
+/* Define if you have the <unistd.h> header file.  */
+#undef HAVE_UNISTD_H
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1

external/libelf/src/cook.c

@@ -0,0 +1,501 @@
+/*
+ * cook.c - read and translate ELF files.
+ * Copyright (C) 1995 - 2006 Michael Riepe
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: cook.c,v 1.29 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+const Elf_Scn _elf_scn_init = INIT_SCN;
+const Scn_Data _elf_data_init = INIT_DATA;
+
+Elf_Type
+_elf_scn_type(unsigned t) {
+    switch (t) {
+	case SHT_DYNAMIC:       return ELF_T_DYN;
+	case SHT_DYNSYM:        return ELF_T_SYM;
+	case SHT_HASH:          return ELF_T_WORD;
+	case SHT_REL:           return ELF_T_REL;
+	case SHT_RELA:          return ELF_T_RELA;
+	case SHT_SYMTAB:        return ELF_T_SYM;
+	case SHT_SYMTAB_SHNDX:	return ELF_T_WORD;	/* XXX: really? */
+#if __LIBELF_SYMBOL_VERSIONS
+#if __LIBELF_SUN_SYMBOL_VERSIONS
+	case SHT_SUNW_verdef:   return ELF_T_VDEF;
+	case SHT_SUNW_verneed:  return ELF_T_VNEED;
+	case SHT_SUNW_versym:   return ELF_T_HALF;
+#else /* __LIBELF_SUN_SYMBOL_VERSIONS */
+	case SHT_GNU_verdef:    return ELF_T_VDEF;
+	case SHT_GNU_verneed:   return ELF_T_VNEED;
+	case SHT_GNU_versym:    return ELF_T_HALF;
+#endif /* __LIBELF_SUN_SYMBOL_VERSIONS */
+#endif /* __LIBELF_SYMBOL_VERSIONS */
+    }
+    return ELF_T_BYTE;
+}
+
+/*
+ * Check for overflow on 32-bit systems
+ */
+#define overflow(a,b,t)	(sizeof(a) < sizeof(t) && (t)(a) != (b))
+
+#define truncerr(t) ((t)==ELF_T_EHDR?ERROR_TRUNC_EHDR:	\
+		    ((t)==ELF_T_PHDR?ERROR_TRUNC_PHDR:	\
+		    ERROR_INTERNAL))
+#define memerr(t)   ((t)==ELF_T_EHDR?ERROR_MEM_EHDR:	\
+		    ((t)==ELF_T_PHDR?ERROR_MEM_PHDR:	\
+		    ERROR_INTERNAL))
+
+Elf_Data*
+_elf_xlatetom(const Elf *elf, Elf_Data *dst, const Elf_Data *src) {
+    if (elf->e_class == ELFCLASS32) {
+	return elf32_xlatetom(dst, src, elf->e_encoding);
+    }
+#if __LIBELF64
+    else if (elf->e_class == ELFCLASS64) {
+	return elf64_xlatetom(dst, src, elf->e_encoding);
+    }
+#endif /* __LIBELF64 */
+    seterr(ERROR_UNIMPLEMENTED);
+    return NULL;
+}
+
+static char*
+_elf_item(void *buf, Elf *elf, Elf_Type type, size_t off) {
+    Elf_Data src, dst;
+
+    elf_assert(valid_type(type));
+    if (off < 0 || off > elf->e_size) {
+	seterr(ERROR_OUTSIDE);
+	return NULL;
+    }
+
+    src.d_type = type;
+    src.d_version = elf->e_version;
+    src.d_size = _fsize(elf->e_class, src.d_version, type);
+    elf_assert(src.d_size);
+    if ((elf->e_size - off) < src.d_size) {
+	seterr(truncerr(type));
+	return NULL;
+    }
+
+    dst.d_version = _elf_version;
+    dst.d_size = _msize(elf->e_class, dst.d_version, type);
+    elf_assert(dst.d_size);
+
+    if (!(dst.d_buf = buf) && !(dst.d_buf = malloc(dst.d_size))) {
+	seterr(memerr(type));
+	return NULL;
+    }
+
+    elf_assert(elf->e_data);
+    if (elf->e_rawdata) {
+	src.d_buf = elf->e_rawdata + off;
+    }
+    else {
+	src.d_buf = elf->e_data + off;
+    }
+
+    if (_elf_xlatetom(elf, &dst, &src)) {
+	return (char*)dst.d_buf;
+    }
+    if (dst.d_buf != buf) {
+	free(dst.d_buf);
+    }
+    return NULL;
+}
+
+static int
+_elf_cook_phdr(Elf *elf) {
+    size_t num, off, entsz;
+
+    if (elf->e_class == ELFCLASS32) {
+	num = ((Elf32_Ehdr*)elf->e_ehdr)->e_phnum;
+	off = ((Elf32_Ehdr*)elf->e_ehdr)->e_phoff;
+	entsz = ((Elf32_Ehdr*)elf->e_ehdr)->e_phentsize;
+    }
+#if __LIBELF64
+    else if (elf->e_class == ELFCLASS64) {
+	num = ((Elf64_Ehdr*)elf->e_ehdr)->e_phnum;
+	off = ((Elf64_Ehdr*)elf->e_ehdr)->e_phoff;
+	entsz = ((Elf64_Ehdr*)elf->e_ehdr)->e_phentsize;
+	/*
+	 * Check for overflow on 32-bit systems
+	 */
+	if (overflow(off, ((Elf64_Ehdr*)elf->e_ehdr)->e_phoff, Elf64_Off)) {
+	    seterr(ERROR_OUTSIDE);
+	    return 0;
+	}
+    }
+#endif /* __LIBELF64 */
+    else {
+	seterr(ERROR_UNIMPLEMENTED);
+	return 0;
+    }
+    if (off) {
+	Elf_Scn *scn;
+	size_t size;
+	unsigned i;
+	char *p;
+
+	if (num == PN_XNUM) {
+	    /*
+	     * Overflow in ehdr->e_phnum.
+	     * Get real value from first SHDR.
+	     */
+	    if (!(scn = elf->e_scn_1)) {
+		seterr(ERROR_NOSUCHSCN);
+		return 0;
+	    }
+	    if (elf->e_class == ELFCLASS32) {
+		num = scn->s_shdr32.sh_info;
+	    }
+#if __LIBELF64
+	    else if (elf->e_class == ELFCLASS64) {
+		num = scn->s_shdr64.sh_info;
+	    }
+#endif /* __LIBELF64 */
+	    /* we already had this
+	    else {
+		seterr(ERROR_UNIMPLEMENTED);
+		return 0;
+	    }
+	    */
+	}
+
+	size = _fsize(elf->e_class, elf->e_version, ELF_T_PHDR);
+	elf_assert(size);
+#if ENABLE_EXTENDED_FORMAT
+	if (entsz < size) {
+#else /* ENABLE_EXTENDED_FORMAT */
+	if (entsz != size) {
+#endif /* ENABLE_EXTENDED_FORMAT */
+	    seterr(ERROR_EHDR_PHENTSIZE);
+	    return 0;
+	}
+	size = _msize(elf->e_class, _elf_version, ELF_T_PHDR);
+	elf_assert(size);
+	if (!(p = malloc(num * size))) {
+	    seterr(memerr(ELF_T_PHDR));
+	    return 0;
+	}
+	for (i = 0; i < num; i++) {
+	    if (!_elf_item(p + i * size, elf, ELF_T_PHDR, off + i * entsz)) {
+		free(p);
+		return 0;
+	    }
+	}
+	elf->e_phdr = p;
+	elf->e_phnum = num;
+    }
+    return 1;
+}
+
+static int
+_elf_cook_shdr(Elf *elf) {
+    size_t num, off, entsz;
+
+    if (elf->e_class == ELFCLASS32) {
+	num = ((Elf32_Ehdr*)elf->e_ehdr)->e_shnum;
+	off = ((Elf32_Ehdr*)elf->e_ehdr)->e_shoff;
+	entsz = ((Elf32_Ehdr*)elf->e_ehdr)->e_shentsize;
+    }
+#if __LIBELF64
+    else if (elf->e_class == ELFCLASS64) {
+	num = ((Elf64_Ehdr*)elf->e_ehdr)->e_shnum;
+	off = ((Elf64_Ehdr*)elf->e_ehdr)->e_shoff;
+	entsz = ((Elf64_Ehdr*)elf->e_ehdr)->e_shentsize;
+	/*
+	 * Check for overflow on 32-bit systems
+	 */
+	if (overflow(off, ((Elf64_Ehdr*)elf->e_ehdr)->e_shoff, Elf64_Off)) {
+	    seterr(ERROR_OUTSIDE);
+	    return 0;
+	}
+    }
+#endif /* __LIBELF64 */
+    else {
+	seterr(ERROR_UNIMPLEMENTED);
+	return 0;
+    }
+    if (off) {
+	struct tmp {
+	    Elf_Scn	scn;
+	    Scn_Data	data;
+	} *head;
+	Elf_Data src, dst;
+	Elf_Scn *scn;
+	Scn_Data *sd;
+	unsigned i;
+
+	if (off < 0 || off > elf->e_size) {
+	    seterr(ERROR_OUTSIDE);
+	    return 0;
+	}
+
+	src.d_type = ELF_T_SHDR;
+	src.d_version = elf->e_version;
+	src.d_size = _fsize(elf->e_class, src.d_version, ELF_T_SHDR);
+	elf_assert(src.d_size);
+#if ENABLE_EXTENDED_FORMAT
+	if (entsz < src.d_size) {
+#else /* ENABLE_EXTENDED_FORMAT */
+	if (entsz != src.d_size) {
+#endif /* ENABLE_EXTENDED_FORMAT */
+	    seterr(ERROR_EHDR_SHENTSIZE);
+	    return 0;
+	}
+	dst.d_version = EV_CURRENT;
+
+	if (num == 0) {
+	    union {
+		Elf32_Shdr sh32;
+#if __LIBELF64
+		Elf64_Shdr sh64;
+#endif /* __LIBELF64 */
+	    } u;
+
+	    /*
+	     * Overflow in ehdr->e_shnum.
+	     * Get real value from first SHDR.
+	     */
+	    if (elf->e_size - off < entsz) {
+		seterr(ERROR_TRUNC_SHDR);
+		return 0;
+	    }
+	    if (elf->e_rawdata) {
+		src.d_buf = elf->e_rawdata + off;
+	    }
+	    else {
+		src.d_buf = elf->e_data + off;
+	    }
+	    dst.d_buf = &u;
+	    dst.d_size = sizeof(u);
+	    if (!_elf_xlatetom(elf, &dst, &src)) {
+		return 0;
+	    }
+	    elf_assert(dst.d_size == _msize(elf->e_class, EV_CURRENT, ELF_T_SHDR));
+	    elf_assert(dst.d_type == ELF_T_SHDR);
+	    if (elf->e_class == ELFCLASS32) {
+		num = u.sh32.sh_size;
+	    }
+#if __LIBELF64
+	    else if (elf->e_class == ELFCLASS64) {
+		num = u.sh64.sh_size;
+		/*
+		 * Check for overflow on 32-bit systems
+		 */
+		if (overflow(num, u.sh64.sh_size, Elf64_Xword)) {
+		    seterr(ERROR_OUTSIDE);
+		    return 0;
+		}
+	    }
+#endif /* __LIBELF64 */
+	}
+
+	if ((elf->e_size - off) / entsz < num) {
+	    seterr(ERROR_TRUNC_SHDR);
+	    return 0;
+	}
+
+	if (!(head = (struct tmp*)malloc(num * sizeof(struct tmp)))) {
+	    seterr(ERROR_MEM_SCN);
+	    return 0;
+	}
+	for (scn = NULL, i = num; i-- > 0; ) {
+	    head[i].scn = _elf_scn_init;
+	    head[i].data = _elf_data_init;
+	    head[i].scn.s_link = scn;
+	    if (!scn) {
+		elf->e_scn_n = &head[i].scn;
+	    }
+	    scn = &head[i].scn;
+	    sd = &head[i].data;
+
+	    if (elf->e_rawdata) {
+		src.d_buf = elf->e_rawdata + off + i * entsz;
+	    }
+	    else {
+		src.d_buf = elf->e_data + off + i * entsz;
+	    }
+	    dst.d_buf = &scn->s_uhdr;
+	    dst.d_size = sizeof(scn->s_uhdr);
+	    if (!_elf_xlatetom(elf, &dst, &src)) {
+		elf->e_scn_n = NULL;
+		free(head);
+		return 0;
+	    }
+	    elf_assert(dst.d_size == _msize(elf->e_class, EV_CURRENT, ELF_T_SHDR));
+	    elf_assert(dst.d_type == ELF_T_SHDR);
+
+	    scn->s_elf = elf;
+	    scn->s_index = i;
+	    scn->s_data_1 = sd;
+	    scn->s_data_n = sd;
+
+	    sd->sd_scn = scn;
+
+	    if (elf->e_class == ELFCLASS32) {
+		Elf32_Shdr *shdr = &scn->s_shdr32;
+
+		scn->s_type = shdr->sh_type;
+		scn->s_size = shdr->sh_size;
+		scn->s_offset = shdr->sh_offset;
+		sd->sd_data.d_align = shdr->sh_addralign;
+		sd->sd_data.d_type = _elf_scn_type(scn->s_type);
+	    }
+#if __LIBELF64
+	    else if (elf->e_class == ELFCLASS64) {
+		Elf64_Shdr *shdr = &scn->s_shdr64;
+
+		scn->s_type = shdr->sh_type;
+		scn->s_size = shdr->sh_size;
+		scn->s_offset = shdr->sh_offset;
+		sd->sd_data.d_align = shdr->sh_addralign;
+		/*
+		 * Check for overflow on 32-bit systems
+		 */
+		if (overflow(scn->s_size, shdr->sh_size, Elf64_Xword)
+		 || overflow(scn->s_offset, shdr->sh_offset, Elf64_Off)
+		 || overflow(sd->sd_data.d_align, shdr->sh_addralign, Elf64_Xword)) {
+		    seterr(ERROR_OUTSIDE);
+		    return 0;
+		}
+		sd->sd_data.d_type = _elf_scn_type(scn->s_type);
+		/*
+		 * QUIRKS MODE:
+		 *
+		 * Some 64-bit architectures use 64-bit entries in the
+		 * .hash section. This violates the ELF standard, and
+		 * should be fixed. It's mostly harmless as long as the
+		 * binary and the machine running your program have the
+		 * same byte order, but you're in trouble if they don't,
+		 * and if the entry size is wrong.
+		 *
+		 * As a workaround, I let libelf guess the right size
+		 * for the binary. This relies pretty much on the fact
+		 * that the binary provides correct data in the section
+		 * headers. If it doesn't, it's probably broken anyway.
+		 * Therefore, libelf uses a standard conforming value
+		 * when it's not absolutely sure.
+		 */
+		if (scn->s_type == SHT_HASH) {
+		    int override = 0;
+
+		    /*
+		     * sh_entsize must reflect the entry size
+		     */
+		    if (shdr->sh_entsize == ELF64_FSZ_ADDR) {
+			override++;
+		    }
+		    /*
+		     * sh_size must be a multiple of sh_entsize
+		     */
+		    if (shdr->sh_size % ELF64_FSZ_ADDR == 0) {
+			override++;
+		    }
+		    /*
+		     * There must be room for at least 2 entries
+		     */
+		    if (shdr->sh_size >= 2 * ELF64_FSZ_ADDR) {
+			override++;
+		    }
+		    /*
+		     * sh_addralign must be correctly set
+		     */
+		    if (shdr->sh_addralign == ELF64_FSZ_ADDR) {
+			override++;
+		    }
+		    /*
+		     * The section must be properly aligned
+		     */
+		    if (shdr->sh_offset % ELF64_FSZ_ADDR == 0) {
+			override++;
+		    }
+		    /* XXX: also look at the data? */
+		    /*
+		     * Make a conservative decision...
+		     */
+		    if (override >= 5) {
+			sd->sd_data.d_type = ELF_T_ADDR;
+		    }
+		}
+		/*
+		 * END QUIRKS MODE.
+		 */
+	    }
+#endif /* __LIBELF64 */
+	    /* we already had this
+	    else {
+		seterr(ERROR_UNIMPLEMENTED);
+		return 0;
+	    }
+	    */
+
+	    sd->sd_data.d_size = scn->s_size;
+	    sd->sd_data.d_version = _elf_version;
+	}
+	elf_assert(scn == &head[0].scn);
+	elf->e_scn_1 = &head[0].scn;
+	head[0].scn.s_freeme = 1;
+    }
+    return 1;
+}
+
+static int
+_elf_cook_file(Elf *elf) {
+    elf->e_ehdr = _elf_item(NULL, elf, ELF_T_EHDR, 0);
+    if (!elf->e_ehdr) {
+	return 0;
+    }
+    /*
+     * Note: _elf_cook_phdr may require the first section header!
+     */
+    if (!_elf_cook_shdr(elf)) {
+	return 0;
+    }
+    if (!_elf_cook_phdr(elf)) {
+	return 0;
+    }
+    return 1;
+}
+
+int
+_elf_cook(Elf *elf) {
+    elf_assert(_elf_scn_init.s_magic == SCN_MAGIC);
+    elf_assert(_elf_data_init.sd_magic == DATA_MAGIC);
+    elf_assert(elf);
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    elf_assert(elf->e_kind == ELF_K_ELF);
+    elf_assert(!elf->e_ehdr);
+    if (!valid_version(elf->e_version)) {
+	seterr(ERROR_UNKNOWN_VERSION);
+    }
+    else if (!valid_encoding(elf->e_encoding)) {
+	seterr(ERROR_UNKNOWN_ENCODING);
+    }
+    else if (valid_class(elf->e_class)) {
+	return _elf_cook_file(elf);
+    }
+    else {
+	seterr(ERROR_UNKNOWN_CLASS);
+    }
+    return 0;
+}

external/libelf/src/data.c

@@ -0,0 +1,36 @@
+/*
+ * data.c - libelf internal variables.
+ * Copyright (C) 1995 - 1998, 2007 Michael Riepe
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: data.c,v 1.8 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+unsigned _elf_version = EV_NONE;
+int _elf_errno = 0;
+int _elf_fill = 0;
+
+#if ENABLE_SANITY_CHECKS
+#define SANITY_CHECKS	-1
+#else
+#define SANITY_CHECKS	0
+#endif
+
+int _elf_sanity_checks = SANITY_CHECKS;

external/libelf/src/end.c

@@ -0,0 +1,118 @@
+/*
+ * end.c - implementation of the elf_end(3) function.
+ * Copyright (C) 1995 - 2004 Michael Riepe
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: end.c,v 1.12 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+#if HAVE_MMAP
+#include <sys/mman.h>
+#endif /* HAVE_MMAP */
+
+static void
+_elf_free(void *ptr) {
+    if (ptr) {
+	free(ptr);
+    }
+}
+
+static void
+_elf_free_scns(Elf *elf, Elf_Scn *scn) {
+    Scn_Data *sd, *tmp;
+    Elf_Scn *freescn;
+
+    for (freescn = NULL; scn; scn = scn->s_link) {
+	elf_assert(scn->s_magic == SCN_MAGIC);
+	elf_assert(scn->s_elf == elf);
+	for (sd = scn->s_data_1; sd; sd = tmp) {
+	    elf_assert(sd->sd_magic == DATA_MAGIC);
+	    elf_assert(sd->sd_scn == scn);
+	    tmp = sd->sd_link;
+	    if (sd->sd_free_data) {
+		_elf_free(sd->sd_memdata);
+	    }
+	    if (sd->sd_freeme) {
+		free(sd);
+	    }
+	}
+	if ((sd = scn->s_rawdata)) {
+	    elf_assert(sd->sd_magic == DATA_MAGIC);
+	    elf_assert(sd->sd_scn == scn);
+	    if (sd->sd_free_data) {
+		_elf_free(sd->sd_memdata);
+	    }
+	    if (sd->sd_freeme) {
+		free(sd);
+	    }
+	}
+	if (scn->s_freeme) {
+	    _elf_free(freescn);
+	    freescn = scn;
+	}
+    }
+    _elf_free(freescn);
+}
+
+int
+elf_end(Elf *elf) {
+    Elf **siblings;
+
+    if (!elf) {
+	return 0;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if (--elf->e_count) {
+	return elf->e_count;
+    }
+    if (elf->e_parent) {
+	elf_assert(elf->e_parent->e_magic == ELF_MAGIC);
+	elf_assert(elf->e_parent->e_kind == ELF_K_AR);
+	siblings = &elf->e_parent->e_members;
+	while (*siblings) {
+	    if (*siblings == elf) {
+		*siblings = elf->e_link;
+		break;
+	    }
+	    siblings = &(*siblings)->e_link;
+	}
+	elf_end(elf->e_parent);
+	_elf_free(elf->e_arhdr);
+    }
+#if HAVE_MMAP
+    else if (elf->e_unmap_data) {
+	munmap(elf->e_data, elf->e_size);
+    }
+#endif /* HAVE_MMAP */
+    else if (!elf->e_memory) {
+	_elf_free(elf->e_data);
+    }
+    _elf_free_scns(elf, elf->e_scn_1);
+    if (elf->e_rawdata != elf->e_data) {
+	_elf_free(elf->e_rawdata);
+    }
+    if (elf->e_free_syms) {
+	_elf_free(elf->e_symtab);
+    }
+    _elf_free(elf->e_ehdr);
+    _elf_free(elf->e_phdr);
+    free(elf);
+    return 0;
+}

external/libelf/src/errmsg.c

@@ -0,0 +1,77 @@
+/*
+ * errmsg.c - implementation of the elf_errmsg(3) function.
+ * Copyright (C) 1995 - 1999, 2004 Michael Riepe
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: errmsg.c,v 1.11 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+#if HAVE_DGETTEXT
+# undef HAVE_CATGETS
+# include <libintl.h>
+#else /* HAVE_DGETTEXT */
+# define dgettext(dom, str) str
+#endif /* HAVE_DGETTEXT */
+
+#if HAVE_CATGETS
+# include <nl_types.h>
+static nl_catd _libelf_cat = (nl_catd)0;
+#endif /* HAVE_CATGETS */
+
+#if HAVE_DGETTEXT || HAVE_CATGETS
+static const char domain[] = "libelf";
+#endif /* HAVE_DGETTEXT || HAVE_CATGETS */
+
+#if PIC
+static const char *_messages[] = {
+#else /* PIC */
+static const char *const _messages[] = {
+#endif /* PIC */
+#define __err__(a,b)	b,
+#include <errors.h>		/* include string tables from errors.h */
+#undef __err__
+};
+
+const char*
+elf_errmsg(int err) {
+    if (err == 0) {
+	err = _elf_errno;
+	if (err == 0) {
+	    return NULL;
+	}
+    }
+    else if (err == -1) {
+	err = _elf_errno;
+    }
+
+    if (err < 0 || err >= ERROR_NUM || _messages[err] == NULL) {
+	err = ERROR_UNKNOWN;
+    }
+
+#if HAVE_CATGETS
+    if (_libelf_cat == (nl_catd)0) {
+	_libelf_cat = catopen(domain, 0);
+    }
+    if (_libelf_cat != (nl_catd)-1) {
+	return catgets(_libelf_cat, 1, err + 1, _messages[err]);
+    }
+#endif /* HAVE_CATGETS */
+    return dgettext(domain, _messages[err]);
+}

external/libelf/src/errno.c

@@ -0,0 +1,32 @@
+/*
+errno.c - implementation of the elf_errno(3) function.
+Copyright (C) 1995 - 1998 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: errno.c,v 1.7 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+int
+elf_errno(void) {
+    int tmp = _elf_errno;
+
+    _elf_errno = 0;
+    return tmp;
+}

external/libelf/src/errors.h

@@ -0,0 +1,100 @@
+/*
+ * errors.h - exhaustive list of all error codes and messages for libelf.
+ * Copyright (C) 1995 - 2003, 2006 Michael Riepe
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+/* @(#) $Id: errors.h,v 1.18 2008/05/23 08:15:34 michael Exp $ */
+
+/* dummy for xgettext */
+#define _(str) str
+
+__err__(ERROR_OK,		_("no error"))
+__err__(ERROR_UNKNOWN,		_("unknown error"))
+__err__(ERROR_INTERNAL,		_("Internal error: unknown reason"))
+__err__(ERROR_UNIMPLEMENTED,	_("Internal error: not implemented"))
+__err__(ERROR_WRONLY,		_("Request error: cntl(ELF_C_FDREAD) on write-only file"))
+__err__(ERROR_INVALID_CMD,	_("Request error: invalid ELF_C_* argument"))
+__err__(ERROR_FDDISABLED,	_("Request error: file descriptor disabled"))
+__err__(ERROR_NOTARCHIVE,	_("Request error: not an archive"))
+__err__(ERROR_BADOFF,		_("Request error: offset out of range"))
+__err__(ERROR_UNKNOWN_VERSION,	_("Request error: unknown ELF version"))
+__err__(ERROR_CMDMISMATCH,	_("Request error: ELF_C_* argument does not match"))
+__err__(ERROR_MEMBERWRITE,	_("Request error: archive member begin() for writing"))
+__err__(ERROR_FDMISMATCH,	_("Request error: archive/member file descriptor mismatch"))
+__err__(ERROR_NOTELF,		_("Request error: not an ELF file"))
+__err__(ERROR_CLASSMISMATCH,	_("Request error: class file/memory mismatch"))
+__err__(ERROR_UNKNOWN_TYPE,	_("Request error: invalid ELF_T_* argument"))
+__err__(ERROR_UNKNOWN_ENCODING,	_("Request error: unknown data encoding"))
+__err__(ERROR_DST2SMALL,	_("Request error: destination buffer too small"))
+__err__(ERROR_NULLBUF,		_("Request error: d_buf is NULL"))
+__err__(ERROR_UNKNOWN_CLASS,	_("Request error: unknown ELF class"))
+__err__(ERROR_ELFSCNMISMATCH,	_("Request error: section does not belong to file"))
+__err__(ERROR_NOSUCHSCN,	_("Request error: no section at index"))
+__err__(ERROR_NULLSCN,		_("Request error: can't manipulate null section"))
+__err__(ERROR_SCNDATAMISMATCH,	_("Request error: data does not belong to section"))
+__err__(ERROR_NOSTRTAB,		_("Request error: no string table"))
+__err__(ERROR_BADSTROFF,	_("Request error: string table offset out of range"))
+__err__(ERROR_RDONLY,		_("Request error: update(ELF_C_WRITE) on read-only file"))
+__err__(ERROR_IO_SEEK,		_("I/O error: seek"))
+__err__(ERROR_IO_2BIG,		_("I/O error: file too big for memory"))
+__err__(ERROR_IO_READ,		_("I/O error: raw read"))
+__err__(ERROR_IO_GETSIZE,	_("I/O error: get file size"))
+__err__(ERROR_IO_WRITE,		_("I/O error: output write"))
+__err__(ERROR_IO_TRUNC,		_("I/O error: can't truncate output file"))
+__err__(ERROR_VERSION_UNSET,	_("Sequence error: must set ELF version first"))
+__err__(ERROR_NOEHDR,		_("Sequence error: must create ELF header first"))
+__err__(ERROR_OUTSIDE,		_("Format error: reference outside file"))
+__err__(ERROR_TRUNC_ARHDR,	_("Format error: archive header truncated"))
+__err__(ERROR_ARFMAG,		_("Format error: archive fmag"))
+__err__(ERROR_ARHDR,		_("Format error: archive header"))
+__err__(ERROR_TRUNC_MEMBER,	_("Format error: archive member truncated"))
+__err__(ERROR_SIZE_ARSYMTAB,	_("Format error: archive symbol table size"))
+__err__(ERROR_ARSTRTAB,		_("Format error: archive string table"))
+__err__(ERROR_ARSPECIAL,	_("Format error: archive special name unknown"))
+__err__(ERROR_TRUNC_EHDR,	_("Format error: ELF header truncated"))
+__err__(ERROR_TRUNC_PHDR,	_("Format error: program header table truncated"))
+__err__(ERROR_TRUNC_SHDR,	_("Format error: section header table truncated"))
+__err__(ERROR_TRUNC_SCN,	_("Format error: data region truncated"))
+__err__(ERROR_ALIGN_PHDR,	_("Format error: program header table alignment"))
+__err__(ERROR_ALIGN_SHDR,	_("Format error: section header table alignment"))
+__err__(ERROR_VERDEF_FORMAT,	_("Format error: bad parameter in Verdef record"))
+__err__(ERROR_VERDEF_VERSION,	_("Format error: unknown Verdef version"))
+__err__(ERROR_VERNEED_FORMAT,	_("Format error: bad parameter in Verneed record"))
+__err__(ERROR_VERNEED_VERSION,	_("Format error: unknown Verneed version"))
+__err__(ERROR_EHDR_SHNUM,	_("Format error: bad e_shnum value"))
+__err__(ERROR_EHDR_SHENTSIZE,	_("Format error: bad e_shentsize value"))
+__err__(ERROR_EHDR_PHENTSIZE,	_("Format error: bad e_phentsize value"))
+__err__(ERROR_UNTERM,		_("Format error: unterminated string in string table"))
+__err__(ERROR_SCN2SMALL,	_("Layout error: section size too small for data"))
+__err__(ERROR_SCN_OVERLAP,	_("Layout error: overlapping sections"))
+__err__(ERROR_MEM_ELF,		_("Memory error: elf descriptor"))
+__err__(ERROR_MEM_ARSYMTAB,	_("Memory error: archive symbol table"))
+__err__(ERROR_MEM_ARHDR,	_("Memory error: archive member header"))
+__err__(ERROR_MEM_EHDR,		_("Memory error: ELF header"))
+__err__(ERROR_MEM_PHDR,		_("Memory error: program header table"))
+__err__(ERROR_MEM_SHDR,		_("Memory error: section header table"))
+__err__(ERROR_MEM_SCN,		_("Memory error: section descriptor"))
+__err__(ERROR_MEM_SCNDATA,	_("Memory error: section data"))
+__err__(ERROR_MEM_OUTBUF,	_("Memory error: output file space"))
+__err__(ERROR_MEM_TEMPORARY,    _("Memory error: temporary buffer"))
+__err__(ERROR_BADVALUE,		_("GElf error: value out of range"))
+__err__(ERROR_BADINDEX,		_("GElf error: index out of range"))
+__err__(ERROR_BADTYPE,		_("GElf error: type mismatch"))
+__err__(ERROR_MEM_SYM,		_("GElf error: not enough memory for GElf_Sym"))
+__err__(ERROR_MEM_DYN,		_("GElf error: not enough memory for GElf_Dyn"))
+__err__(ERROR_MEM_RELA,		_("GElf error: not enough memory for GElf_Rela"))
+__err__(ERROR_MEM_REL,		_("GElf error: not enough memory for GElf_Rel"))

external/libelf/src/ext_types.h

@@ -0,0 +1,334 @@
+/*
+ext_types.h - external representation of ELF data types.
+Copyright (C) 1995 - 1998 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+/* @(#) $Id: ext_types.h,v 1.9 2008/05/23 08:15:34 michael Exp $ */
+
+#ifndef _EXT_TYPES_H
+#define _EXT_TYPES_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*
+ * Scalar data types
+ */
+typedef unsigned char __ext_Elf32_Addr  [ELF32_FSZ_ADDR];
+typedef unsigned char __ext_Elf32_Half  [ELF32_FSZ_HALF];
+typedef unsigned char __ext_Elf32_Off   [ELF32_FSZ_OFF];
+typedef unsigned char __ext_Elf32_Sword [ELF32_FSZ_SWORD];
+typedef unsigned char __ext_Elf32_Word  [ELF32_FSZ_WORD];
+
+#if __LIBELF64
+
+typedef unsigned char __ext_Elf32_Lword [8];
+
+typedef unsigned char __ext_Elf64_Addr  [ELF64_FSZ_ADDR];
+typedef unsigned char __ext_Elf64_Half  [ELF64_FSZ_HALF];
+typedef unsigned char __ext_Elf64_Off   [ELF64_FSZ_OFF];
+typedef unsigned char __ext_Elf64_Sword [ELF64_FSZ_SWORD];
+typedef unsigned char __ext_Elf64_Word  [ELF64_FSZ_WORD];
+typedef unsigned char __ext_Elf64_Sxword[ELF64_FSZ_SXWORD];
+typedef unsigned char __ext_Elf64_Xword [ELF64_FSZ_XWORD];
+
+typedef unsigned char __ext_Elf64_Lword [8];
+
+#endif /* __LIBELF64 */
+
+/*
+ * ELF header
+ */
+typedef struct {
+    unsigned char	e_ident[EI_NIDENT];
+    __ext_Elf32_Half	e_type;
+    __ext_Elf32_Half	e_machine;
+    __ext_Elf32_Word	e_version;
+    __ext_Elf32_Addr	e_entry;
+    __ext_Elf32_Off	e_phoff;
+    __ext_Elf32_Off	e_shoff;
+    __ext_Elf32_Word	e_flags;
+    __ext_Elf32_Half	e_ehsize;
+    __ext_Elf32_Half	e_phentsize;
+    __ext_Elf32_Half	e_phnum;
+    __ext_Elf32_Half	e_shentsize;
+    __ext_Elf32_Half	e_shnum;
+    __ext_Elf32_Half	e_shstrndx;
+} __ext_Elf32_Ehdr;
+
+#if __LIBELF64
+typedef struct {
+    unsigned char	e_ident[EI_NIDENT];
+    __ext_Elf64_Half	e_type;
+    __ext_Elf64_Half	e_machine;
+    __ext_Elf64_Word	e_version;
+    __ext_Elf64_Addr	e_entry;
+    __ext_Elf64_Off	e_phoff;
+    __ext_Elf64_Off	e_shoff;
+    __ext_Elf64_Word	e_flags;
+    __ext_Elf64_Half	e_ehsize;
+    __ext_Elf64_Half	e_phentsize;
+    __ext_Elf64_Half	e_phnum;
+    __ext_Elf64_Half	e_shentsize;
+    __ext_Elf64_Half	e_shnum;
+    __ext_Elf64_Half	e_shstrndx;
+} __ext_Elf64_Ehdr;
+#endif /* __LIBELF64 */
+
+/*
+ * Section header
+ */
+typedef struct {
+    __ext_Elf32_Word	sh_name;
+    __ext_Elf32_Word	sh_type;
+    __ext_Elf32_Word	sh_flags;
+    __ext_Elf32_Addr	sh_addr;
+    __ext_Elf32_Off	sh_offset;
+    __ext_Elf32_Word	sh_size;
+    __ext_Elf32_Word	sh_link;
+    __ext_Elf32_Word	sh_info;
+    __ext_Elf32_Word	sh_addralign;
+    __ext_Elf32_Word	sh_entsize;
+} __ext_Elf32_Shdr;
+
+#if __LIBELF64
+typedef struct {
+    __ext_Elf64_Word	sh_name;
+    __ext_Elf64_Word	sh_type;
+    __ext_Elf64_Xword	sh_flags;
+    __ext_Elf64_Addr	sh_addr;
+    __ext_Elf64_Off	sh_offset;
+    __ext_Elf64_Xword	sh_size;
+    __ext_Elf64_Word	sh_link;
+    __ext_Elf64_Word	sh_info;
+    __ext_Elf64_Xword	sh_addralign;
+    __ext_Elf64_Xword	sh_entsize;
+} __ext_Elf64_Shdr;
+#endif /* __LIBELF64 */
+
+/*
+ * Symbol table
+ */
+typedef struct {
+    __ext_Elf32_Word	st_name;
+    __ext_Elf32_Addr	st_value;
+    __ext_Elf32_Word	st_size;
+    unsigned char	st_info;
+    unsigned char	st_other;
+    __ext_Elf32_Half	st_shndx;
+} __ext_Elf32_Sym;
+
+#if __LIBELF64
+typedef struct {
+    __ext_Elf64_Word	st_name;
+    unsigned char	st_info;
+    unsigned char	st_other;
+    __ext_Elf64_Half	st_shndx;
+    __ext_Elf64_Addr	st_value;
+    __ext_Elf64_Xword	st_size;
+} __ext_Elf64_Sym;
+#endif /* __LIBELF64 */
+
+/*
+ * Relocation
+ */
+typedef struct {
+    __ext_Elf32_Addr	r_offset;
+    __ext_Elf32_Word	r_info;
+} __ext_Elf32_Rel;
+
+typedef struct {
+    __ext_Elf32_Addr	r_offset;
+    __ext_Elf32_Word	r_info;
+    __ext_Elf32_Sword	r_addend;
+} __ext_Elf32_Rela;
+
+#if __LIBELF64
+typedef struct {
+    __ext_Elf64_Addr	r_offset;
+#if __LIBELF64_IRIX
+    __ext_Elf64_Word	r_sym;
+    unsigned char	r_ssym;
+    unsigned char	r_type3;
+    unsigned char	r_type2;
+    unsigned char	r_type;
+#else /* __LIBELF64_IRIX */
+    __ext_Elf64_Xword	r_info;
+#endif /* __LIBELF64_IRIX */
+} __ext_Elf64_Rel;
+
+typedef struct {
+    __ext_Elf64_Addr	r_offset;
+#if __LIBELF64_IRIX
+    __ext_Elf64_Word	r_sym;
+    unsigned char	r_ssym;
+    unsigned char	r_type3;
+    unsigned char	r_type2;
+    unsigned char	r_type;
+#else /* __LIBELF64_IRIX */
+    __ext_Elf64_Xword	r_info;
+#endif /* __LIBELF64_IRIX */
+    __ext_Elf64_Sxword	r_addend;
+} __ext_Elf64_Rela;
+#endif /* __LIBELF64 */
+
+/*
+ * Program header
+ */
+typedef struct {
+    __ext_Elf32_Word	p_type;
+    __ext_Elf32_Off	p_offset;
+    __ext_Elf32_Addr	p_vaddr;
+    __ext_Elf32_Addr	p_paddr;
+    __ext_Elf32_Word	p_filesz;
+    __ext_Elf32_Word	p_memsz;
+    __ext_Elf32_Word	p_flags;
+    __ext_Elf32_Word	p_align;
+} __ext_Elf32_Phdr;
+
+#if __LIBELF64
+typedef struct {
+    __ext_Elf64_Word	p_type;
+    __ext_Elf64_Word	p_flags;
+    __ext_Elf64_Off	p_offset;
+    __ext_Elf64_Addr	p_vaddr;
+    __ext_Elf64_Addr	p_paddr;
+    __ext_Elf64_Xword	p_filesz;
+    __ext_Elf64_Xword	p_memsz;
+    __ext_Elf64_Xword	p_align;
+} __ext_Elf64_Phdr;
+#endif /* __LIBELF64 */
+
+/*
+ * Dynamic structure
+ */
+typedef struct {
+    __ext_Elf32_Sword	d_tag;
+    union {
+	__ext_Elf32_Word	d_val;
+	__ext_Elf32_Addr	d_ptr;
+    } d_un;
+} __ext_Elf32_Dyn;
+
+#if __LIBELF64
+typedef struct {
+    __ext_Elf64_Sxword	d_tag;
+    union {
+	__ext_Elf64_Xword	d_val;
+	__ext_Elf64_Addr	d_ptr;
+    } d_un;
+} __ext_Elf64_Dyn;
+#endif /* __LIBELF64 */
+
+/*
+ * Version definitions
+ */
+typedef struct {
+    __ext_Elf32_Half	vd_version;
+    __ext_Elf32_Half	vd_flags;
+    __ext_Elf32_Half	vd_ndx;
+    __ext_Elf32_Half	vd_cnt;
+    __ext_Elf32_Word	vd_hash;
+    __ext_Elf32_Word	vd_aux;
+    __ext_Elf32_Word	vd_next;
+} __ext_Elf32_Verdef;
+
+typedef struct {
+    __ext_Elf32_Word	vda_name;
+    __ext_Elf32_Word	vda_next;
+} __ext_Elf32_Verdaux;
+
+typedef struct {
+    __ext_Elf32_Half	vn_version;
+    __ext_Elf32_Half	vn_cnt;
+    __ext_Elf32_Word	vn_file;
+    __ext_Elf32_Word	vn_aux;
+    __ext_Elf32_Word	vn_next;
+} __ext_Elf32_Verneed;
+
+typedef struct {
+    __ext_Elf32_Word	vna_hash;
+    __ext_Elf32_Half	vna_flags;
+    __ext_Elf32_Half	vna_other;
+    __ext_Elf32_Word	vna_name;
+    __ext_Elf32_Word	vna_next;
+} __ext_Elf32_Vernaux;
+
+#if __LIBELF64
+
+typedef struct {
+    __ext_Elf64_Half	vd_version;
+    __ext_Elf64_Half	vd_flags;
+    __ext_Elf64_Half	vd_ndx;
+    __ext_Elf64_Half	vd_cnt;
+    __ext_Elf64_Word	vd_hash;
+    __ext_Elf64_Word	vd_aux;
+    __ext_Elf64_Word	vd_next;
+} __ext_Elf64_Verdef;
+
+typedef struct {
+    __ext_Elf64_Word	vda_name;
+    __ext_Elf64_Word	vda_next;
+} __ext_Elf64_Verdaux;
+
+typedef struct {
+    __ext_Elf64_Half	vn_version;
+    __ext_Elf64_Half	vn_cnt;
+    __ext_Elf64_Word	vn_file;
+    __ext_Elf64_Word	vn_aux;
+    __ext_Elf64_Word	vn_next;
+} __ext_Elf64_Verneed;
+
+typedef struct {
+    __ext_Elf64_Word	vna_hash;
+    __ext_Elf64_Half	vna_flags;
+    __ext_Elf64_Half	vna_other;
+    __ext_Elf64_Word	vna_name;
+    __ext_Elf64_Word	vna_next;
+} __ext_Elf64_Vernaux;
+
+#endif /* __LIBELF64 */
+
+/*
+ * Move section
+ */
+#if __LIBELF64
+
+typedef struct {
+    __ext_Elf32_Lword	m_value;
+    __ext_Elf32_Word	m_info;
+    __ext_Elf32_Word	m_poffset;
+    __ext_Elf32_Half	m_repeat;
+    __ext_Elf32_Half	m_stride;
+} __ext_Elf32_Move;
+
+typedef struct {
+    __ext_Elf64_Lword	m_value;
+    __ext_Elf64_Xword	m_info;
+    __ext_Elf64_Xword	m_poffset;
+    __ext_Elf64_Half	m_repeat;
+    __ext_Elf64_Half	m_stride;
+} __ext_Elf64_Move;
+
+#endif /* __LIBELF64 */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* _EXT_TYPES_H */

external/libelf/src/fill.c

@@ -0,0 +1,29 @@
+/*
+fill.c - implementation of the elf_fill(3) function.
+Copyright (C) 1995 - 1998 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: fill.c,v 1.7 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+void
+elf_fill(int fill) {
+    _elf_fill = fill;
+}

external/libelf/src/flag.c

@@ -0,0 +1,92 @@
+/*
+flag.c - implementation of the elf_flag*(3) functions.
+Copyright (C) 1995 - 1998 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: flag.c,v 1.7 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+static unsigned
+_elf_flag(unsigned *f, Elf_Cmd cmd, unsigned flags) {
+    if (cmd == ELF_C_SET) {
+	return *f |= flags;
+    }
+    if (cmd == ELF_C_CLR) {
+	return *f &= ~flags;
+    }
+    seterr(ERROR_INVALID_CMD);
+    return 0;
+}
+
+unsigned
+elf_flagdata(Elf_Data *data, Elf_Cmd cmd, unsigned flags) {
+    Scn_Data *sd = (Scn_Data*)data;
+
+    if (!sd) {
+	return 0;
+    }
+    elf_assert(sd->sd_magic == DATA_MAGIC);
+    return _elf_flag(&sd->sd_data_flags, cmd, flags);
+}
+
+unsigned
+elf_flagehdr(Elf *elf, Elf_Cmd cmd, unsigned flags) {
+    if (!elf) {
+	return 0;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    return _elf_flag(&elf->e_ehdr_flags, cmd, flags);
+}
+
+unsigned
+elf_flagelf(Elf *elf, Elf_Cmd cmd, unsigned flags) {
+    if (!elf) {
+	return 0;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    return _elf_flag(&elf->e_elf_flags, cmd, flags);
+}
+
+unsigned
+elf_flagphdr(Elf *elf, Elf_Cmd cmd, unsigned flags) {
+    if (!elf) {
+	return 0;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    return _elf_flag(&elf->e_phdr_flags, cmd, flags);
+}
+
+unsigned
+elf_flagscn(Elf_Scn *scn, Elf_Cmd cmd, unsigned flags) {
+    if (!scn) {
+	return 0;
+    }
+    elf_assert(scn->s_magic == SCN_MAGIC);
+    return _elf_flag(&scn->s_scn_flags, cmd, flags);
+}
+
+unsigned
+elf_flagshdr(Elf_Scn *scn, Elf_Cmd cmd, unsigned flags) {
+    if (!scn) {
+	return 0;
+    }
+    elf_assert(scn->s_magic == SCN_MAGIC);
+    return _elf_flag(&scn->s_shdr_flags, cmd, flags);
+}

external/libelf/src/gelf.h

@@ -0,0 +1,155 @@
+/*
+ * gelf.h - public header file for libelf.
+ * Copyright (C) 2000 - 2006 Michael Riepe
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+/* @(#) $Id: gelf.h,v 1.16 2008/05/23 08:15:34 michael Exp $ */
+
+#ifndef _GELF_H
+#define _GELF_H
+
+#if __LIBELF_INTERNAL__
+#include <libelf.h>
+#else /* __LIBELF_INTERNAL__ */
+#include <libelf/libelf.h>
+#endif /* __LIBELF_INTERNAL__ */
+
+#if __LIBELF_NEED_LINK_H
+#include <link.h>
+#elif __LIBELF_NEED_SYS_LINK_H
+#include <sys/link.h>
+#endif /* __LIBELF_NEED_LINK_H */
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#ifndef __P
+# if (__STDC__ + 0) || defined(__cplusplus) || defined(_WIN32)
+#  define __P(args) args
+# else /* __STDC__ || defined(__cplusplus) */
+#  define __P(args) ()
+# endif /* __STDC__ || defined(__cplusplus) */
+#endif /* __P */
+
+#if !__LIBELF64
+
+#error "GElf is not supported on this system."
+
+#else /* __LIBELF64 */
+
+typedef Elf64_Addr	GElf_Addr;
+typedef Elf64_Half	GElf_Half;
+typedef Elf64_Off	GElf_Off;
+typedef Elf64_Sword	GElf_Sword;
+typedef Elf64_Word	GElf_Word;
+typedef Elf64_Sxword	GElf_Sxword;
+typedef Elf64_Xword	GElf_Xword;
+
+typedef Elf64_Ehdr	GElf_Ehdr;
+typedef Elf64_Phdr	GElf_Phdr;
+typedef Elf64_Shdr	GElf_Shdr;
+typedef Elf64_Dyn	GElf_Dyn;
+typedef Elf64_Rel	GElf_Rel;
+typedef Elf64_Rela	GElf_Rela;
+typedef Elf64_Sym	GElf_Sym;
+
+/*
+ * Symbol versioning
+ */
+#if __LIBELF_SYMBOL_VERSIONS
+typedef Elf64_Verdef	GElf_Verdef;
+typedef Elf64_Verneed	GElf_Verneed;
+typedef Elf64_Verdaux	GElf_Verdaux;
+typedef Elf64_Vernaux	GElf_Vernaux;
+#endif /* __LIBELF_SYMBOL_VERSIONS */
+
+/*
+ * These types aren't implemented (yet)
+ *
+typedef Elf64_Move    GElf_Move;
+typedef Elf64_Syminfo GElf_Syminfo;
+ */
+
+/*
+ * Generic macros
+ */
+#define GELF_ST_BIND	ELF64_ST_BIND
+#define GELF_ST_TYPE	ELF64_ST_TYPE
+#define GELF_ST_INFO	ELF64_ST_INFO
+
+#define GELF_R_TYPE	ELF64_R_TYPE
+#define GELF_R_SYM	ELF64_R_SYM
+#define GELF_R_INFO	ELF64_R_INFO
+
+/*
+ * Function declarations
+ */
+extern int             gelf_getclass __P((Elf *__elf));
+
+extern size_t             gelf_fsize __P((Elf *__elf, Elf_Type __type, size_t __count, unsigned __ver));
+
+extern Elf_Data       *gelf_xlatetof __P((Elf *__elf, Elf_Data *__dst, const Elf_Data *__src, unsigned __encode));
+extern Elf_Data       *gelf_xlatetom __P((Elf *__elf, Elf_Data *__dst, const Elf_Data *__src, unsigned __encode));
+
+extern GElf_Ehdr       *gelf_getehdr __P((Elf *__elf, GElf_Ehdr *__dst));
+extern int          gelf_update_ehdr __P((Elf *__elf, GElf_Ehdr *__src));
+extern unsigned long    gelf_newehdr __P((Elf *__elf, int __elfclass));
+
+extern GElf_Phdr       *gelf_getphdr __P((Elf *__elf, int ndx, GElf_Phdr *__dst));
+extern int          gelf_update_phdr __P((Elf *__elf, int ndx, GElf_Phdr *__src));
+extern unsigned long    gelf_newphdr __P((Elf *__elf, size_t __phnum));
+
+extern GElf_Shdr       *gelf_getshdr __P((Elf_Scn *__scn, GElf_Shdr *__dst));
+extern int          gelf_update_shdr __P((Elf_Scn *__scn, GElf_Shdr *__src));
+
+extern GElf_Dyn         *gelf_getdyn __P((Elf_Data *__src, int __ndx, GElf_Dyn *__dst));
+extern int           gelf_update_dyn __P((Elf_Data *__dst, int __ndx, GElf_Dyn *__src));
+
+extern GElf_Rel         *gelf_getrel __P((Elf_Data *__src, int __ndx, GElf_Rel *__dst));
+extern int           gelf_update_rel __P((Elf_Data *__dst, int __ndx, GElf_Rel *__src));
+
+extern GElf_Rela       *gelf_getrela __P((Elf_Data *__src, int __ndx, GElf_Rela *__dst));
+extern int          gelf_update_rela __P((Elf_Data *__dst, int __ndx, GElf_Rela *__src));
+
+extern GElf_Sym         *gelf_getsym __P((Elf_Data *__src, int __ndx, GElf_Sym *__dst));
+extern int           gelf_update_sym __P((Elf_Data *__dst, int __ndx, GElf_Sym *__src));
+
+extern long            gelf_checksum __P((Elf *__elf));
+
+/*
+ * These functions aren't implemented (yet)
+ *
+extern GElf_Move       *gelf_getmove __P((Elf_Data *__src, int __ndx, GElf_Move *__src));
+extern int          gelf_update_move __P((Elf_Data *__dst, int __ndx, GElf_Move *__src));
+ *
+extern GElf_Syminfo* gelf_getsyminfo __P((Elf_Data *__src, int __ndx, GElf_Syminfo *__dst));
+extern int       gelf_update_syminfo __P((Elf_Data *__dst, int __ndx, GElf_Syminfo *__src));
+ */
+
+/*
+ * Extensions (not available in other versions of libelf)
+ */
+extern size_t             gelf_msize __P((Elf *__elf, Elf_Type __type, size_t __count, unsigned __ver));
+
+#endif /* __LIBELF64 */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* _GELF_H */

external/libelf/src/gelfehdr.c

@@ -0,0 +1,140 @@
+/*
+ * gelfehdr.c - gelf_* translation functions.
+ * Copyright (C) 2000 - 2006 Michael Riepe
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <private.h>
+
+#if __LIBELF64
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: gelfehdr.c,v 1.9 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+#define check_and_copy(type, d, s, name, eret)		\
+    do {						\
+	if (sizeof((d)->name) < sizeof((s)->name)	\
+	 && (type)(s)->name != (s)->name) {		\
+	    seterr(ERROR_BADVALUE);			\
+	    return (eret);				\
+	}						\
+	(d)->name = (type)(s)->name;			\
+    } while (0)
+
+GElf_Ehdr*
+gelf_getehdr(Elf *elf, GElf_Ehdr *dst) {
+    GElf_Ehdr buf;
+    char *tmp;
+
+    if (!elf) {
+	return NULL;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    tmp = _elf_getehdr(elf, elf->e_class);
+    if (!tmp) {
+	return NULL;
+    }
+    if (!dst) {
+	dst = &buf;
+    }
+    if (elf->e_class == ELFCLASS64) {
+	*dst = *(Elf64_Ehdr*)tmp;
+    }
+    else if (elf->e_class == ELFCLASS32) {
+	Elf32_Ehdr *src = (Elf32_Ehdr*)tmp;
+
+	memcpy(dst->e_ident, src->e_ident, EI_NIDENT);
+	check_and_copy(GElf_Half, dst, src, e_type,      NULL);
+	check_and_copy(GElf_Half, dst, src, e_machine,   NULL);
+	check_and_copy(GElf_Word, dst, src, e_version,   NULL);
+	check_and_copy(GElf_Addr, dst, src, e_entry,     NULL);
+	check_and_copy(GElf_Off,  dst, src, e_phoff,     NULL);
+	check_and_copy(GElf_Off,  dst, src, e_shoff,     NULL);
+	check_and_copy(GElf_Word, dst, src, e_flags,     NULL);
+	check_and_copy(GElf_Half, dst, src, e_ehsize,    NULL);
+	check_and_copy(GElf_Half, dst, src, e_phentsize, NULL);
+	check_and_copy(GElf_Half, dst, src, e_phnum,     NULL);
+	check_and_copy(GElf_Half, dst, src, e_shentsize, NULL);
+	check_and_copy(GElf_Half, dst, src, e_shnum,     NULL);
+	check_and_copy(GElf_Half, dst, src, e_shstrndx,  NULL);
+    }
+    else {
+	if (valid_class(elf->e_class)) {
+	    seterr(ERROR_UNIMPLEMENTED);
+	}
+	else {
+	    seterr(ERROR_UNKNOWN_CLASS);
+	}
+	return NULL;
+    }
+    if (dst == &buf) {
+	dst = (GElf_Ehdr*)malloc(sizeof(GElf_Ehdr));
+	if (!dst) {
+	    seterr(ERROR_MEM_EHDR);
+	    return NULL;
+	}
+	*dst = buf;
+    }
+    return dst;
+}
+
+int
+gelf_update_ehdr(Elf *elf, GElf_Ehdr *src) {
+    char *tmp;
+
+    if (!elf || !src) {
+	return 0;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    tmp = _elf_getehdr(elf, elf->e_class);
+    if (!tmp) {
+	return 0;
+    }
+    if (elf->e_class == ELFCLASS64) {
+	*(Elf64_Ehdr*)tmp = *src;
+    }
+    else if (elf->e_class == ELFCLASS32) {
+	Elf32_Ehdr *dst = (Elf32_Ehdr*)tmp;
+
+	memcpy(dst->e_ident, src->e_ident, EI_NIDENT);
+	check_and_copy(Elf32_Half, dst, src, e_type,      0);
+	check_and_copy(Elf32_Half, dst, src, e_machine,   0);
+	check_and_copy(Elf32_Word, dst, src, e_version,   0);
+	check_and_copy(Elf32_Addr, dst, src, e_entry,     0);
+	check_and_copy(Elf32_Off,  dst, src, e_phoff,     0);
+	check_and_copy(Elf32_Off,  dst, src, e_shoff,     0);
+	check_and_copy(Elf32_Word, dst, src, e_flags,     0);
+	check_and_copy(Elf32_Half, dst, src, e_ehsize,    0);
+	check_and_copy(Elf32_Half, dst, src, e_phentsize, 0);
+	check_and_copy(Elf32_Half, dst, src, e_phnum,     0);
+	check_and_copy(Elf32_Half, dst, src, e_shentsize, 0);
+	check_and_copy(Elf32_Half, dst, src, e_shnum,     0);
+	check_and_copy(Elf32_Half, dst, src, e_shstrndx,  0);
+    }
+    else {
+	if (valid_class(elf->e_class)) {
+	    seterr(ERROR_UNIMPLEMENTED);
+	}
+	else {
+	    seterr(ERROR_UNKNOWN_CLASS);
+	}
+	return 0;
+    }
+    return 1;
+}
+
+#endif /* __LIBELF64 */

external/libelf/src/gelfphdr.c

@@ -0,0 +1,148 @@
+/*
+ * gelfphdr.c - gelf_* translation functions.
+ * Copyright (C) 2000 - 2006 Michael Riepe
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <private.h>
+
+#if __LIBELF64
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: gelfphdr.c,v 1.9 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+#define check_and_copy(type, d, s, name, eret)		\
+    do {						\
+	if (sizeof((d)->name) < sizeof((s)->name)	\
+	 && (type)(s)->name != (s)->name) {		\
+	    seterr(ERROR_BADVALUE);			\
+	    return (eret);				\
+	}						\
+	(d)->name = (type)(s)->name;			\
+    } while (0)
+
+GElf_Phdr*
+gelf_getphdr(Elf *elf, int ndx, GElf_Phdr *dst) {
+    GElf_Phdr buf;
+    char *tmp;
+    size_t n;
+
+    if (!elf) {
+	return NULL;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    tmp = _elf_getphdr(elf, elf->e_class);
+    if (!tmp) {
+	return NULL;
+    }
+    if (ndx < 0 || ndx >= elf->e_phnum) {
+	seterr(ERROR_BADINDEX);
+	return NULL;
+    }
+    n = _msize(elf->e_class, _elf_version, ELF_T_PHDR);
+    if (n == 0) {
+	seterr(ERROR_UNIMPLEMENTED);
+	return NULL;
+    }
+    if (!dst) {
+	dst = &buf;
+    }
+    if (elf->e_class == ELFCLASS64) {
+	*dst = *(Elf64_Phdr*)(tmp + ndx * n);
+    }
+    else if (elf->e_class == ELFCLASS32) {
+	Elf32_Phdr *src = (Elf32_Phdr*)(tmp + ndx * n);
+
+	check_and_copy(GElf_Word,  dst, src, p_type,   NULL);
+	check_and_copy(GElf_Word,  dst, src, p_flags,  NULL);
+	check_and_copy(GElf_Off,   dst, src, p_offset, NULL);
+	check_and_copy(GElf_Addr,  dst, src, p_vaddr,  NULL);
+	check_and_copy(GElf_Addr,  dst, src, p_paddr,  NULL);
+	check_and_copy(GElf_Xword, dst, src, p_filesz, NULL);
+	check_and_copy(GElf_Xword, dst, src, p_memsz,  NULL);
+	check_and_copy(GElf_Xword, dst, src, p_align,  NULL);
+    }
+    else {
+	if (valid_class(elf->e_class)) {
+	    seterr(ERROR_UNIMPLEMENTED);
+	}
+	else {
+	    seterr(ERROR_UNKNOWN_CLASS);
+	}
+	return NULL;
+    }
+    if (dst == &buf) {
+	dst = (GElf_Phdr*)malloc(sizeof(GElf_Phdr));
+	if (!dst) {
+	    seterr(ERROR_MEM_PHDR);
+	    return NULL;
+	}
+	*dst = buf;
+    }
+    return dst;
+}
+
+int
+gelf_update_phdr(Elf *elf, int ndx, GElf_Phdr *src) {
+    char *tmp;
+    size_t n;
+
+    if (!elf || !src) {
+	return 0;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    tmp = _elf_getphdr(elf, elf->e_class);
+    if (!tmp) {
+	return 0;
+    }
+    if (ndx < 0 || ndx >= elf->e_phnum) {
+	seterr(ERROR_BADINDEX);
+	return 0;
+    }
+    n = _msize(elf->e_class, _elf_version, ELF_T_PHDR);
+    if (n == 0) {
+	seterr(ERROR_UNIMPLEMENTED);
+	return 0;
+    }
+    if (elf->e_class == ELFCLASS64) {
+	*(Elf64_Phdr*)(tmp + ndx * n) = *src;
+    }
+    else if (elf->e_class == ELFCLASS32) {
+	Elf32_Phdr *dst = (Elf32_Phdr*)(tmp + ndx * n);
+
+	check_and_copy(Elf32_Word, dst, src, p_type,   0);
+	check_and_copy(Elf32_Off,  dst, src, p_offset, 0);
+	check_and_copy(Elf32_Addr, dst, src, p_vaddr,  0);
+	check_and_copy(Elf32_Addr, dst, src, p_paddr,  0);
+	check_and_copy(Elf32_Word, dst, src, p_filesz, 0);
+	check_and_copy(Elf32_Word, dst, src, p_memsz,  0);
+	check_and_copy(Elf32_Word, dst, src, p_flags,  0);
+	check_and_copy(Elf32_Word, dst, src, p_align,  0);
+    }
+    else {
+	if (valid_class(elf->e_class)) {
+	    seterr(ERROR_UNIMPLEMENTED);
+	}
+	else {
+	    seterr(ERROR_UNKNOWN_CLASS);
+	}
+	return 0;
+    }
+    return 1;
+}
+
+#endif /* __LIBELF64 */

external/libelf/src/gelfshdr.c

@@ -0,0 +1,125 @@
+/*
+ * gelfshdr.c - gelf_* translation functions.
+ * Copyright (C) 2000 - 2006 Michael Riepe
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <private.h>
+
+#if __LIBELF64
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: gelfshdr.c,v 1.10 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+#define check_and_copy(type, d, s, name, eret)		\
+    do {						\
+	if (sizeof((d)->name) < sizeof((s)->name)	\
+	 && (type)(s)->name != (s)->name) {		\
+	    seterr(ERROR_BADVALUE);			\
+	    return (eret);				\
+	}						\
+	(d)->name = (type)(s)->name;			\
+    } while (0)
+
+GElf_Shdr*
+gelf_getshdr(Elf_Scn *scn, GElf_Shdr *dst) {
+    GElf_Shdr buf;
+
+    if (!scn) {
+	return NULL;
+    }
+    elf_assert(scn->s_magic == SCN_MAGIC);
+    elf_assert(scn->s_elf);
+    elf_assert(scn->s_elf->e_magic == ELF_MAGIC);
+    if (!dst) {
+	dst = &buf;
+    }
+    if (scn->s_elf->e_class == ELFCLASS64) {
+	*dst = scn->s_shdr64;
+    }
+    else if (scn->s_elf->e_class == ELFCLASS32) {
+	Elf32_Shdr *src = &scn->s_shdr32;
+
+	check_and_copy(GElf_Word,  dst, src, sh_name,      NULL);
+	check_and_copy(GElf_Word,  dst, src, sh_type,      NULL);
+	check_and_copy(GElf_Xword, dst, src, sh_flags,     NULL);
+	check_and_copy(GElf_Addr,  dst, src, sh_addr,      NULL);
+	check_and_copy(GElf_Off,   dst, src, sh_offset,    NULL);
+	check_and_copy(GElf_Xword, dst, src, sh_size,      NULL);
+	check_and_copy(GElf_Word,  dst, src, sh_link,      NULL);
+	check_and_copy(GElf_Word,  dst, src, sh_info,      NULL);
+	check_and_copy(GElf_Xword, dst, src, sh_addralign, NULL);
+	check_and_copy(GElf_Xword, dst, src, sh_entsize,   NULL);
+    }
+    else {
+	if (valid_class(scn->s_elf->e_class)) {
+	    seterr(ERROR_UNIMPLEMENTED);
+	}
+	else {
+	    seterr(ERROR_UNKNOWN_CLASS);
+	}
+	return NULL;
+    }
+    if (dst == &buf) {
+	dst = (GElf_Shdr*)malloc(sizeof(GElf_Shdr));
+	if (!dst) {
+	    seterr(ERROR_MEM_SHDR);
+	    return NULL;
+	}
+	*dst = buf;
+    }
+    return dst;
+}
+
+int
+gelf_update_shdr(Elf_Scn *scn, GElf_Shdr *src) {
+    if (!scn || !src) {
+	return 0;
+    }
+    elf_assert(scn->s_magic == SCN_MAGIC);
+    elf_assert(scn->s_elf);
+    elf_assert(scn->s_elf->e_magic == ELF_MAGIC);
+    if (scn->s_elf->e_class == ELFCLASS64) {
+	scn->s_shdr64 = *src;
+    }
+    else if (scn->s_elf->e_class == ELFCLASS32) {
+	Elf32_Shdr *dst = &scn->s_shdr32;
+
+	check_and_copy(Elf32_Word, dst, src, sh_name,      0);
+	check_and_copy(Elf32_Word, dst, src, sh_type,      0);
+	check_and_copy(Elf32_Word, dst, src, sh_flags,     0);
+	check_and_copy(Elf32_Addr, dst, src, sh_addr,      0);
+	check_and_copy(Elf32_Off,  dst, src, sh_offset,    0);
+	check_and_copy(Elf32_Word, dst, src, sh_size,      0);
+	check_and_copy(Elf32_Word, dst, src, sh_link,      0);
+	check_and_copy(Elf32_Word, dst, src, sh_info,      0);
+	check_and_copy(Elf32_Word, dst, src, sh_addralign, 0);
+	check_and_copy(Elf32_Word, dst, src, sh_entsize,   0);
+    }
+    else {
+	if (valid_class(scn->s_elf->e_class)) {
+	    seterr(ERROR_UNIMPLEMENTED);
+	}
+	else {
+	    seterr(ERROR_UNKNOWN_CLASS);
+	}
+	return 0;
+    }
+    return 1;
+}
+
+#endif /* __LIBELF64 */

external/libelf/src/gelftrans.c

@@ -0,0 +1,407 @@
+/*
+gelftrans.c - gelf_* translation functions.
+Copyright (C) 2000 - 2001 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#if __LIBELF64
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: gelftrans.c,v 1.10 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+#define check_and_copy(type, d, s, name, eret)		\
+    do {						\
+	if (sizeof((d)->name) < sizeof((s)->name)	\
+	 && (type)(s)->name != (s)->name) {		\
+	    seterr(ERROR_BADVALUE);			\
+	    return (eret);				\
+	}						\
+	(d)->name = (type)(s)->name;			\
+    } while (0)
+
+/*
+ * These macros are missing on some Linux systems
+ */
+#if !defined(ELF32_R_SYM) || !defined(ELF32_R_TYPE) || !defined(ELF32_R_INFO)
+# undef ELF32_R_SYM
+# undef ELF32_R_TYPE
+# undef ELF32_R_INFO
+# define ELF32_R_SYM(i)		((i)>>8)
+# define ELF32_R_TYPE(i)	((unsigned char)(i))
+# define ELF32_R_INFO(s,t)	(((s)<<8)+(unsigned char)(t))
+#endif /* !defined(...) */
+
+#if !defined(ELF64_R_SYM) || !defined(ELF64_R_TYPE) || !defined(ELF64_R_INFO)
+# undef ELF64_R_SYM
+# undef ELF64_R_TYPE
+# undef ELF64_R_INFO
+# define ELF64_R_SYM(i)		((i)>>32)
+# define ELF64_R_TYPE(i)	((i)&0xffffffffL)
+# define ELF64_R_INFO(s,t)	(((Elf64_Xword)(s)<<32)+((t)&0xffffffffL))
+#endif /* !defined(...) */
+
+static char*
+get_addr_and_class(const Elf_Data *data, int ndx, Elf_Type type, unsigned *cls) {
+    Scn_Data *sd = (Scn_Data*)data;
+    Elf_Scn *scn;
+    Elf *elf;
+    size_t n;
+
+    if (!sd) {
+	return NULL;
+    }
+    elf_assert(sd->sd_magic == DATA_MAGIC);
+    scn = sd->sd_scn;
+    elf_assert(scn);
+    elf_assert(scn->s_magic == SCN_MAGIC);
+    elf = scn->s_elf;
+    elf_assert(elf);
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if (elf->e_kind != ELF_K_ELF) {
+	seterr(ERROR_NOTELF);
+	return NULL;
+    }
+    if (!valid_class(elf->e_class)) {
+	seterr(ERROR_UNKNOWN_CLASS);
+	return NULL;
+    }
+    if (data->d_type != type) {
+	seterr(ERROR_BADTYPE);
+	return NULL;
+    }
+    n = _msize(elf->e_class, data->d_version, type);
+    if (n == 0) {
+	seterr(ERROR_UNIMPLEMENTED);
+	return NULL;
+    }
+    if (ndx < 0 || data->d_size < (ndx + 1) * n) {
+	seterr(ERROR_BADINDEX);
+	return NULL;
+    }
+    if (!data->d_buf) {
+	seterr(ERROR_NULLBUF);
+	return NULL;
+    }
+    if (cls) {
+	*cls = elf->e_class;
+    }
+    return (char*)data->d_buf + n * ndx;
+}
+
+GElf_Sym*
+gelf_getsym(Elf_Data *src, int ndx, GElf_Sym *dst) {
+    GElf_Sym buf;
+    unsigned cls;
+    char *tmp;
+
+    if (!dst) {
+	dst = &buf;
+    }
+    tmp = get_addr_and_class(src, ndx, ELF_T_SYM, &cls);
+    if (!tmp) {
+	return NULL;
+    }
+    if (cls == ELFCLASS64) {
+	*dst = *(Elf64_Sym*)tmp;
+    }
+    else if (cls == ELFCLASS32) {
+	Elf32_Sym *src = (Elf32_Sym*)tmp;
+
+	check_and_copy(GElf_Word,     dst, src, st_name,  NULL);
+	check_and_copy(unsigned char, dst, src, st_info,  NULL);
+	check_and_copy(unsigned char, dst, src, st_other, NULL);
+	check_and_copy(GElf_Half,     dst, src, st_shndx, NULL);
+	check_and_copy(GElf_Addr,     dst, src, st_value, NULL);
+	check_and_copy(GElf_Xword,    dst, src, st_size,  NULL);
+    }
+    else {
+	seterr(ERROR_UNIMPLEMENTED);
+	return NULL;
+    }
+    if (dst == &buf) {
+	dst = (GElf_Sym*)malloc(sizeof(GElf_Sym));
+	if (!dst) {
+	    seterr(ERROR_MEM_SYM);
+	    return NULL;
+	}
+	*dst = buf;
+    }
+    return dst;
+}
+
+int
+gelf_update_sym(Elf_Data *dst, int ndx, GElf_Sym *src) {
+    unsigned cls;
+    char *tmp;
+
+    tmp = get_addr_and_class(dst, ndx, ELF_T_SYM, &cls);
+    if (!tmp) {
+	return 0;
+    }
+    if (cls == ELFCLASS64) {
+	*(Elf64_Sym*)tmp = *src;
+    }
+    else if (cls == ELFCLASS32) {
+	Elf32_Sym *dst = (Elf32_Sym*)tmp;
+
+	check_and_copy(Elf32_Word,    dst, src, st_name,  0);
+	check_and_copy(Elf32_Addr,    dst, src, st_value, 0);
+	check_and_copy(Elf32_Word,    dst, src, st_size,  0);
+	check_and_copy(unsigned char, dst, src, st_info,  0);
+	check_and_copy(unsigned char, dst, src, st_other, 0);
+	check_and_copy(Elf32_Half,    dst, src, st_shndx, 0);
+    }
+    else {
+	seterr(ERROR_UNIMPLEMENTED);
+	return 0;
+    }
+    return 1;
+}
+
+GElf_Dyn*
+gelf_getdyn(Elf_Data *src, int ndx, GElf_Dyn *dst) {
+    GElf_Dyn buf;
+    unsigned cls;
+    char *tmp;
+
+    if (!dst) {
+	dst = &buf;
+    }
+    tmp = get_addr_and_class(src, ndx, ELF_T_DYN, &cls);
+    if (!tmp) {
+	return NULL;
+    }
+    if (cls == ELFCLASS64) {
+	*dst = *(Elf64_Dyn*)tmp;
+    }
+    else if (cls == ELFCLASS32) {
+	Elf32_Dyn *src = (Elf32_Dyn*)tmp;
+
+	check_and_copy(GElf_Sxword, dst, src, d_tag,      NULL);
+	check_and_copy(GElf_Xword,  dst, src, d_un.d_val, NULL);
+    }
+    else {
+	seterr(ERROR_UNIMPLEMENTED);
+	return NULL;
+    }
+    if (dst == &buf) {
+	dst = (GElf_Dyn*)malloc(sizeof(GElf_Dyn));
+	if (!dst) {
+	    seterr(ERROR_MEM_DYN);
+	    return NULL;
+	}
+	*dst = buf;
+    }
+    return dst;
+}
+
+int
+gelf_update_dyn(Elf_Data *dst, int ndx, GElf_Dyn *src) {
+    unsigned cls;
+    char *tmp;
+
+    tmp = get_addr_and_class(dst, ndx, ELF_T_DYN, &cls);
+    if (!tmp) {
+	return 0;
+    }
+    if (cls == ELFCLASS64) {
+	*(Elf64_Dyn*)tmp = *src;
+    }
+    else if (cls == ELFCLASS32) {
+	Elf32_Dyn *dst = (Elf32_Dyn*)tmp;
+
+	check_and_copy(Elf32_Sword, dst, src, d_tag,      0);
+	check_and_copy(Elf32_Word,  dst, src, d_un.d_val, 0);
+    }
+    else {
+	seterr(ERROR_UNIMPLEMENTED);
+	return 0;
+    }
+    return 1;
+}
+
+GElf_Rela*
+gelf_getrela(Elf_Data *src, int ndx, GElf_Rela *dst) {
+    GElf_Rela buf;
+    unsigned cls;
+    char *tmp;
+
+    if (!dst) {
+	dst = &buf;
+    }
+    tmp = get_addr_and_class(src, ndx, ELF_T_RELA, &cls);
+    if (!tmp) {
+	return NULL;
+    }
+    if (cls == ELFCLASS64) {
+	*dst = *(Elf64_Rela*)tmp;
+    }
+    else if (cls == ELFCLASS32) {
+	Elf32_Rela *src = (Elf32_Rela*)tmp;
+
+	check_and_copy(GElf_Addr,   dst, src, r_offset, NULL);
+	dst->r_info = ELF64_R_INFO((Elf64_Xword)ELF32_R_SYM(src->r_info),
+				   (Elf64_Xword)ELF32_R_TYPE(src->r_info));
+	check_and_copy(GElf_Sxword, dst, src, r_addend, NULL);
+    }
+    else {
+	seterr(ERROR_UNIMPLEMENTED);
+	return NULL;
+    }
+    if (dst == &buf) {
+	dst = (GElf_Rela*)malloc(sizeof(GElf_Rela));
+	if (!dst) {
+	    seterr(ERROR_MEM_RELA);
+	    return NULL;
+	}
+	*dst = buf;
+    }
+    return dst;
+}
+
+int
+gelf_update_rela(Elf_Data *dst, int ndx, GElf_Rela *src) {
+    unsigned cls;
+    char *tmp;
+
+    tmp = get_addr_and_class(dst, ndx, ELF_T_RELA, &cls);
+    if (!tmp) {
+	return 0;
+    }
+    if (cls == ELFCLASS64) {
+	*(Elf64_Rela*)tmp = *src;
+    }
+    else if (cls == ELFCLASS32) {
+	Elf32_Rela *dst = (Elf32_Rela*)tmp;
+
+	check_and_copy(Elf32_Addr,  dst, src, r_offset, 0);
+	if (ELF64_R_SYM(src->r_info) > 0xffffffUL
+	 || ELF64_R_TYPE(src->r_info) > 0xffUL) {
+	    seterr(ERROR_BADVALUE);
+	    return 0;
+	}
+	dst->r_info = ELF32_R_INFO((Elf32_Word)ELF64_R_SYM(src->r_info),
+				  (Elf32_Word)ELF64_R_TYPE(src->r_info));
+	check_and_copy(Elf32_Sword, dst, src, r_addend, 0);
+    }
+    else {
+	seterr(ERROR_UNIMPLEMENTED);
+	return 0;
+    }
+    return 1;
+}
+
+GElf_Rel*
+gelf_getrel(Elf_Data *src, int ndx, GElf_Rel *dst) {
+    GElf_Rel buf;
+    unsigned cls;
+    char *tmp;
+
+    if (!dst) {
+	dst = &buf;
+    }
+    tmp = get_addr_and_class(src, ndx, ELF_T_REL, &cls);
+    if (!tmp) {
+	return NULL;
+    }
+    if (cls == ELFCLASS64) {
+	*dst = *(Elf64_Rel*)tmp;
+    }
+    else if (cls == ELFCLASS32) {
+	Elf32_Rel *src = (Elf32_Rel*)tmp;
+
+	check_and_copy(GElf_Addr, dst, src, r_offset, NULL);
+	dst->r_info = ELF64_R_INFO((Elf64_Xword)ELF32_R_SYM(src->r_info),
+				   (Elf64_Xword)ELF32_R_TYPE(src->r_info));
+    }
+    else {
+	seterr(ERROR_UNIMPLEMENTED);
+	return NULL;
+    }
+    if (dst == &buf) {
+	dst = (GElf_Rel*)malloc(sizeof(GElf_Rel));
+	if (!dst) {
+	    seterr(ERROR_MEM_REL);
+	    return NULL;
+	}
+	*dst = buf;
+    }
+    return dst;
+}
+
+int
+gelf_update_rel(Elf_Data *dst, int ndx, GElf_Rel *src) {
+    unsigned cls;
+    char *tmp;
+
+    tmp = get_addr_and_class(dst, ndx, ELF_T_REL, &cls);
+    if (!tmp) {
+	return 0;
+    }
+    if (cls == ELFCLASS64) {
+	*(Elf64_Rel*)tmp = *src;
+    }
+    else if (cls == ELFCLASS32) {
+	Elf32_Rel *dst = (Elf32_Rel*)tmp;
+
+	check_and_copy(Elf32_Addr, dst, src, r_offset, 0);
+	if (ELF64_R_SYM(src->r_info) > 0xffffffUL
+	 || ELF64_R_TYPE(src->r_info) > 0xffUL) {
+	    seterr(ERROR_BADVALUE);
+	    return 0;
+	}
+	dst->r_info = ELF32_R_INFO((Elf32_Word)ELF64_R_SYM(src->r_info),
+				   (Elf32_Word)ELF64_R_TYPE(src->r_info));
+    }
+    else {
+	seterr(ERROR_UNIMPLEMENTED);
+	return 0;
+    }
+    return 1;
+}
+
+#if 0
+
+GElf_Syminfo*
+gelf_getsyminfo(Elf_Data *src, int ndx, GElf_Syminfo *dst) {
+    seterr(ERROR_UNIMPLEMENTED);
+    return NULL;
+}
+
+int
+gelf_update_syminfo(Elf_Data *dst, int ndx, GElf_Syminfo *src) {
+    seterr(ERROR_UNIMPLEMENTED);
+    return 0;
+}
+
+GElf_Move*
+gelf_getmove(Elf_Data *src, int ndx, GElf_Move *src) {
+    seterr(ERROR_UNIMPLEMENTED);
+    return NULL;
+}
+
+int
+gelf_update_move(Elf_Data *dst, int ndx, GElf_Move *src) {
+    seterr(ERROR_UNIMPLEMENTED);
+    return 0;
+}
+
+#endif
+
+#endif /* __LIBELF64 */

external/libelf/src/getarhdr.c

@@ -0,0 +1,37 @@
+/*
+getarhdr.c - implementation of the elf_getarhdr(3) function.
+Copyright (C) 1995 - 1998 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: getarhdr.c,v 1.7 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+Elf_Arhdr*
+elf_getarhdr(Elf *elf) {
+    if (!elf) {
+	return NULL;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if (elf->e_arhdr) {
+	return elf->e_arhdr;
+    }
+    seterr(ERROR_NOTARCHIVE);
+    return NULL;
+}

external/libelf/src/getaroff.c

@@ -0,0 +1,40 @@
+/*
+ * getaroff.c - implementation of the elf_getaroff(3) function.
+ * Copyright (C) 2009 Michael Riepe
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: getaroff.c,v 1.1 2009/11/01 13:04:19 michael Exp $";
+#endif /* lint */
+
+off_t
+elf_getaroff(Elf *elf) {
+    Elf *ref;
+
+    if (!elf) {
+	return (off_t)-1;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if (!(ref = elf->e_parent)) {
+	return (off_t)-1;
+    }
+    elf_assert(ref->e_magic == ELF_MAGIC);
+    elf_assert(elf->e_base >= ref->e_base + SARMAG + sizeof(struct ar_hdr));
+    return (off_t)(elf->e_base - ref->e_base - sizeof(struct ar_hdr));
+}

external/libelf/src/getarsym.c

@@ -0,0 +1,87 @@
+/*
+ * getarsym.c - implementation of the elf_getarsym(3) function.
+ * Copyright (C) 1995 - 1998, 2004 Michael Riepe
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <private.h>
+#include <byteswap.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: getarsym.c,v 1.9 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+Elf_Arsym*
+elf_getarsym(Elf *elf, size_t *ptr) {
+    Elf_Arsym *syms;
+    size_t count;
+    size_t tmp;
+    size_t i;
+    char *s;
+    char *e;
+
+    if (!ptr) {
+	ptr = &tmp;
+    }
+    *ptr = 0;
+    if (!elf) {
+	return NULL;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if (elf->e_kind != ELF_K_AR) {
+	seterr(ERROR_NOTARCHIVE);
+	return NULL;
+    }
+    if (elf->e_symtab && !elf->e_free_syms) {
+	if (elf->e_symlen < 4) {
+	    seterr(ERROR_SIZE_ARSYMTAB);
+	    return NULL;
+	}
+	count = __load_u32M(elf->e_symtab);
+	if (elf->e_symlen < 4 * (count + 1)) {
+	    seterr(ERROR_SIZE_ARSYMTAB);
+	    return NULL;
+	}
+	if (!(syms = (Elf_Arsym*)malloc((count + 1) * sizeof(*syms)))) {
+	    seterr(ERROR_MEM_ARSYMTAB);
+	    return NULL;
+	}
+	s = elf->e_symtab + 4 * (count + 1);
+	e = elf->e_symtab + elf->e_symlen;
+	for (i = 0; i < count; i++, s++) {
+	    syms[i].as_name = s;
+	    while (s < e && *s) {
+		s++;
+	    }
+	    if (s >= e) {
+		seterr(ERROR_SIZE_ARSYMTAB);
+		free(syms);
+		return NULL;
+	    }
+	    elf_assert(!*s);
+	    syms[i].as_hash = elf_hash((unsigned char*)syms[i].as_name);
+	    syms[i].as_off = __load_u32M(elf->e_symtab + 4 * (i + 1));
+	}
+	syms[count].as_name = NULL;
+	syms[count].as_hash = ~0UL;
+	syms[count].as_off = 0;
+	elf->e_symtab = (char*)syms;
+	elf->e_symlen = count + 1;
+	elf->e_free_syms = 1;
+    }
+    *ptr = elf->e_symlen;
+    return (Elf_Arsym*)elf->e_symtab;
+}

external/libelf/src/getbase.c

@@ -0,0 +1,33 @@
+/*
+getbase.c - implementation of the elf_getbase(3) function.
+Copyright (C) 1995 - 1998 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: getbase.c,v 1.7 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+off_t
+elf_getbase(Elf *elf) {
+    if (!elf) {
+	return -1;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    return (off_t)elf->e_base;
+}

external/libelf/src/getdata.c

@@ -0,0 +1,157 @@
+/*
+getdata.c - implementation of the elf_getdata(3) function.
+Copyright (C) 1995 - 2001 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: getdata.c,v 1.13 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+static Elf_Data*
+_elf_cook_scn(Elf *elf, Elf_Scn *scn, Scn_Data *sd) {
+    Elf_Data dst;
+    Elf_Data src;
+    int flag = 0;
+    size_t dlen;
+
+    elf_assert(elf->e_data);
+
+    /*
+     * Prepare source
+     */
+    src = sd->sd_data;
+    src.d_version = elf->e_version;
+    if (elf->e_rawdata) {
+	src.d_buf = elf->e_rawdata + scn->s_offset;
+    }
+    else {
+	src.d_buf = elf->e_data + scn->s_offset;
+    }
+
+    /*
+     * Prepare destination (needs prepared source!)
+     */
+    dst = sd->sd_data;
+    if (elf->e_class == ELFCLASS32) {
+	dlen = _elf32_xltsize(&src, dst.d_version, elf->e_encoding, 0);
+    }
+#if __LIBELF64
+    else if (elf->e_class == ELFCLASS64) {
+	dlen = _elf64_xltsize(&src, dst.d_version, elf->e_encoding, 0);
+    }
+#endif /* __LIBELF64 */
+    else {
+	elf_assert(valid_class(elf->e_class));
+	seterr(ERROR_UNIMPLEMENTED);
+	return NULL;
+    }
+    if (dlen == (size_t)-1) {
+	return NULL;
+    }
+    dst.d_size = dlen;
+    if (elf->e_rawdata != elf->e_data && dst.d_size <= src.d_size) {
+	dst.d_buf = elf->e_data + scn->s_offset;
+    }
+    else if (!(dst.d_buf = malloc(dst.d_size))) {
+	seterr(ERROR_MEM_SCNDATA);
+	return NULL;
+    }
+    else {
+	flag = 1;
+    }
+
+    /*
+     * Translate data
+     */
+    if (_elf_xlatetom(elf, &dst, &src)) {
+	sd->sd_memdata = (char*)dst.d_buf;
+	sd->sd_data = dst;
+	if (!(sd->sd_free_data = flag)) {
+	    elf->e_cooked = 1;
+	}
+	return &sd->sd_data;
+    }
+
+    if (flag) {
+	free(dst.d_buf);
+    }
+    return NULL;
+}
+
+Elf_Data*
+elf_getdata(Elf_Scn *scn, Elf_Data *data) {
+    Scn_Data *sd;
+    Elf *elf;
+
+    if (!scn) {
+	return NULL;
+    }
+    elf_assert(scn->s_magic == SCN_MAGIC);
+    if (scn->s_index == SHN_UNDEF) {
+	seterr(ERROR_NULLSCN);
+    }
+    else if (data) {
+	for (sd = scn->s_data_1; sd; sd = sd->sd_link) {
+	    elf_assert(sd->sd_magic == DATA_MAGIC);
+	    elf_assert(sd->sd_scn == scn);
+	    if (data == &sd->sd_data) {
+		/*
+		 * sd_link allocated by elf_newdata().
+		 */
+		return &sd->sd_link->sd_data;
+	    }
+	}
+	seterr(ERROR_SCNDATAMISMATCH);
+    }
+    else if ((sd = scn->s_data_1)) {
+	elf_assert(sd->sd_magic == DATA_MAGIC);
+	elf_assert(sd->sd_scn == scn);
+	elf = scn->s_elf;
+	elf_assert(elf);
+	elf_assert(elf->e_magic == ELF_MAGIC);
+	if (sd->sd_freeme) {
+	    /* allocated by elf_newdata() */
+	    return &sd->sd_data;
+	}
+	else if (scn->s_type == SHT_NULL) {
+	    seterr(ERROR_NULLSCN);
+	}
+	else if (sd->sd_memdata) {
+	    /* already cooked */
+	    return &sd->sd_data;
+	}
+	else if (scn->s_offset < 0 || scn->s_offset > elf->e_size) {
+	    seterr(ERROR_OUTSIDE);
+	}
+	else if (scn->s_type == SHT_NOBITS || !scn->s_size) {
+	    /* no data to read */
+	    return &sd->sd_data;
+	}
+	else if (scn->s_offset + scn->s_size > elf->e_size) {
+	    seterr(ERROR_TRUNC_SCN);
+	}
+	else if (valid_class(elf->e_class)) {
+	    return _elf_cook_scn(elf, scn, sd);
+	}
+	else {
+	    seterr(ERROR_UNKNOWN_CLASS);
+	}
+    }
+    return NULL;
+}

external/libelf/src/getident.c

@@ -0,0 +1,48 @@
+/*
+getident.c - implementation of the elf_getident(3) function.
+Copyright (C) 1995 - 1998 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: getident.c,v 1.7 2008/05/23 08:15:34 michael Exp $";
+#endif /* lint */
+
+char*
+elf_getident(Elf *elf, size_t *ptr) {
+    size_t tmp;
+
+    if (!ptr) {
+	ptr = &tmp;
+    }
+    if (!elf) {
+	*ptr = 0;
+	return NULL;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if (elf->e_kind != ELF_K_ELF) {
+	*ptr = elf->e_idlen;
+	return elf->e_data;
+    }
+    if (elf->e_ehdr || _elf_cook(elf)) {
+	*ptr = elf->e_idlen;
+	return elf->e_ehdr;
+    }
+    *ptr = 0;
+    return NULL;
+}

external/libelf/src/getscn.c

@@ -0,0 +1,48 @@
+/*
+getscn.c - implementation of the elf_getscn(3) function.
+Copyright (C) 1995 - 1998 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: getscn.c,v 1.7 2008/05/23 08:15:35 michael Exp $";
+#endif /* lint */
+
+Elf_Scn*
+elf_getscn(Elf *elf, size_t index) {
+    Elf_Scn *scn;
+
+    if (!elf) {
+	return NULL;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if (elf->e_kind != ELF_K_ELF) {
+	seterr(ERROR_NOTELF);
+    }
+    else if (elf->e_ehdr || _elf_cook(elf)) {
+	for (scn = elf->e_scn_1; scn; scn = scn->s_link) {
+	    elf_assert(scn->s_magic == SCN_MAGIC);
+	    elf_assert(scn->s_elf == elf);
+	    if (scn->s_index == index) {
+		return scn;
+	    }
+	}
+	seterr(ERROR_NOSUCHSCN);
+    }
+    return NULL;
+}

external/libelf/src/hash.c

@@ -0,0 +1,38 @@
+/*
+hash.c - implementation of the elf_hash(3) function.
+Copyright (C) 1995 - 2002 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: hash.c,v 1.10 2008/05/23 08:15:35 michael Exp $";
+#endif /* lint */
+
+unsigned long
+elf_hash(const unsigned char *name) {
+    unsigned long hash = 0;
+    unsigned long tmp;
+
+    while (*name) {
+	hash = (hash << 4) + (unsigned char)*name++;
+	if ((tmp = hash & 0xf0000000)) {
+	    hash ^= tmp | (tmp >> 24);
+	}
+    }
+    return hash;
+}

external/libelf/src/input.c

@@ -0,0 +1,106 @@
+/*
+ * input.c - low-level input for libelf.
+ * Copyright (C) 1995 - 2001, 2005 Michael Riepe
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: input.c,v 1.11 2008/05/23 08:15:35 michael Exp $";
+#endif /* lint */
+
+#include <errno.h>
+
+#if HAVE_MMAP
+#include <sys/mman.h>
+#endif /* HAVE_MMAP */
+
+static int
+xread(int fd, char *buffer, size_t len) {
+    size_t done = 0;
+    size_t n;
+
+    while (done < len) {
+	n = read(fd, buffer + done, len - done);
+	if (n == 0) {
+	    /* premature end of file */
+	    return -1;
+	}
+	else if (n != (size_t)-1) {
+	    /* some bytes read, continue */
+	    done += n;
+	}
+	else if (errno != EAGAIN && errno != EINTR) {
+	    /* real error */
+	    return -1;
+	}
+    }
+    return 0;
+}
+
+void*
+_elf_read(Elf *elf, void *buffer, size_t off, size_t len) {
+    void *tmp;
+
+    elf_assert(elf);
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    elf_assert(off >= 0 && off + len <= elf->e_size);
+    if (elf->e_disabled) {
+	seterr(ERROR_FDDISABLED);
+    }
+    else if (len) {
+	off += elf->e_base;
+	if (lseek(elf->e_fd, (off_t)off, SEEK_SET) != (off_t)off) {
+	    seterr(ERROR_IO_SEEK);
+	}
+	else if (!(tmp = buffer) && !(tmp = malloc(len))) {
+	    seterr(ERROR_IO_2BIG);
+	}
+	else if (xread(elf->e_fd, tmp, len)) {
+	    seterr(ERROR_IO_READ);
+	    if (tmp != buffer) {
+		free(tmp);
+	    }
+	}
+	else {
+	    return tmp;
+	}
+    }
+    return NULL;
+}
+
+void*
+_elf_mmap(Elf *elf) {
+#if HAVE_MMAP
+    void *tmp;
+
+    elf_assert(elf);
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    elf_assert(elf->e_base == 0);
+    if (elf->e_disabled) {
+	seterr(ERROR_FDDISABLED);
+    }
+    else if (elf->e_size) {
+	tmp = (void*)mmap(0, elf->e_size, PROT_READ | PROT_WRITE,
+			  MAP_PRIVATE, elf->e_fd, 0);
+	if (tmp != (void*)-1) {
+	    return tmp;
+	}
+    }
+#endif /* HAVE_MMAP */
+    return NULL;
+}

external/libelf/src/kind.c

@@ -0,0 +1,33 @@
+/*
+kind.c - implementation of the elf_kind(3) function.
+Copyright (C) 1995 - 1998 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: kind.c,v 1.7 2008/05/23 08:15:35 michael Exp $";
+#endif /* lint */
+
+Elf_Kind
+elf_kind(Elf *elf) {
+    if (!elf) {
+	return ELF_K_NONE;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    return elf->e_kind;
+}

external/libelf/src/libelf.def

@@ -0,0 +1,82 @@
+LIBRARY libelf
+VERSION 0.8
+EXPORTS
+	elf_begin
+	elf_cntl
+	elf_delscn
+	elf_end
+	elf_errmsg
+	elf_errno
+	elf_fill
+	elf_flagdata
+	elf_flagehdr
+	elf_flagelf
+	elf_flagphdr
+	elf_flagscn
+	elf_flagshdr
+	elf_getarhdr
+	elf_getarsym
+	elf_getbase
+	elf_getdata
+	elf_getident
+	elf_getscn
+	elf_hash
+	elf_kind
+	elf_memory
+	elf_ndxscn
+	elf_newdata
+	elf_newscn
+	elf_next
+	elf_nextscn
+	elf_rand
+	elf_rawdata
+	elf_rawfile
+	elf_strptr
+	elf_update
+	elf_version
+	elf32_checksum
+	elf32_fsize
+	elf32_getehdr
+	elf32_getphdr
+	elf32_getshdr
+	elf32_newehdr
+	elf32_newphdr
+	elf32_xlatetof
+	elf32_xlatetom
+	elf64_checksum
+	elf64_fsize
+	elf64_getehdr
+	elf64_getphdr
+	elf64_getshdr
+	elf64_newehdr
+	elf64_newphdr
+	elf64_xlatetof
+	elf64_xlatetom
+	elfx_movscn
+	elfx_remscn
+	gelf_checksum
+	gelf_fsize
+	gelf_getclass
+	gelf_getdyn
+	gelf_getehdr
+	gelf_getphdr
+	gelf_getrel
+	gelf_getrela
+	gelf_getshdr
+	gelf_getsym
+	gelf_msize
+	gelf_newehdr
+	gelf_newphdr
+	gelf_update_dyn
+	gelf_update_ehdr
+	gelf_update_phdr
+	gelf_update_rel
+	gelf_update_rela
+	gelf_update_shdr
+	gelf_update_sym
+	gelf_xlatetof
+	gelf_xlatetom
+	elf_getphnum
+	elf_getshnum
+	elf_getshstrndx
+	elfx_update_shstrndx

external/libelf/src/memset.c

@@ -0,0 +1,53 @@
+/*
+ * memset.c - replacement for memset(3), using duff's device.
+ * Copyright (C) 1995 - 2004 Michael Riepe
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: memset.c,v 1.11 2008/05/23 08:15:35 michael Exp $";
+#endif /* lint */
+
+#include <stddef.h>	/* for size_t */
+#include <sys/types.h>
+
+void*
+_elf_memset(void *s, int c, size_t n) {
+    char *t = (char*)s;
+
+    if (n) {
+	switch (n % 8u) {
+	    do {
+		n -= 8;
+		default:
+		case 0: *t++ = (char)c;
+		case 7: *t++ = (char)c;
+		case 6: *t++ = (char)c;
+		case 5: *t++ = (char)c;
+		case 4: *t++ = (char)c;
+		case 3: *t++ = (char)c;
+		case 2: *t++ = (char)c;
+		case 1: *t++ = (char)c;
+	    }
+	    while (n > 8);
+	}
+    }
+    return s;
+}

external/libelf/src/ndxscn.c

@@ -0,0 +1,33 @@
+/*
+ndxscn.c - implementation of the elf_ndxscn(3) function.
+Copyright (C) 1995 - 1998 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: ndxscn.c,v 1.7 2008/05/23 08:15:35 michael Exp $";
+#endif /* lint */
+
+size_t
+elf_ndxscn(Elf_Scn *scn) {
+    if (!scn) {
+	return SHN_UNDEF;
+    }
+    elf_assert(scn->s_magic == SCN_MAGIC);
+    return scn->s_index;
+}

external/libelf/src/newdata.c

@@ -0,0 +1,56 @@
+/*
+newdata.c - implementation of the elf_newdata(3) function.
+Copyright (C) 1995 - 2000 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: newdata.c,v 1.10 2008/05/23 08:15:35 michael Exp $";
+#endif /* lint */
+
+Elf_Data*
+elf_newdata(Elf_Scn *scn) {
+    Scn_Data *sd;
+
+    if (!scn) {
+	return NULL;
+    }
+    elf_assert(scn->s_magic == SCN_MAGIC);
+    if (scn->s_index == SHN_UNDEF) {
+	seterr(ERROR_NULLSCN);
+    }
+    else if (!(sd = (Scn_Data*)malloc(sizeof(*sd)))) {
+	seterr(ERROR_MEM_SCNDATA);
+    }
+    else {
+	*sd = _elf_data_init;
+	sd->sd_scn = scn;
+	sd->sd_data_flags = ELF_F_DIRTY;
+	sd->sd_freeme = 1;
+	sd->sd_data.d_version = _elf_version;
+	if (scn->s_data_n) {
+	    scn->s_data_n->sd_link = sd;
+	}
+	else {
+	    scn->s_data_1 = sd;
+	}
+	scn->s_data_n = sd;
+	return &sd->sd_data;
+    }
+    return NULL;
+}

external/libelf/src/newscn.c

@@ -0,0 +1,145 @@
+/*
+ * newscn.c - implementation of the elf_newscn(3) function.
+ * Copyright (C) 1995 - 2006 Michael Riepe
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: newscn.c,v 1.13 2008/05/23 08:15:35 michael Exp $";
+#endif /* lint */
+
+int
+_elf_update_shnum(Elf *elf, size_t shnum) {
+    size_t extshnum = 0;
+    Elf_Scn *scn;
+
+    elf_assert(elf);
+    elf_assert(elf->e_ehdr);
+    scn = elf->e_scn_1;
+    elf_assert(scn);
+    elf_assert(scn->s_index == 0);
+    if (shnum >= SHN_LORESERVE) {
+	extshnum = shnum;
+	shnum = 0;
+    }
+    if (elf->e_class == ELFCLASS32) {
+	((Elf32_Ehdr*)elf->e_ehdr)->e_shnum = shnum;
+	scn->s_shdr32.sh_size = extshnum;
+    }
+#if __LIBELF64
+    else if (elf->e_class == ELFCLASS64) {
+	((Elf64_Ehdr*)elf->e_ehdr)->e_shnum = shnum;
+	scn->s_shdr64.sh_size = extshnum;
+    }
+#endif /* __LIBELF64 */
+    else {
+	if (valid_class(elf->e_class)) {
+	    seterr(ERROR_UNIMPLEMENTED);
+	}
+	else {
+	    seterr(ERROR_UNKNOWN_CLASS);
+	}
+	return -1;
+    }
+    elf->e_ehdr_flags |= ELF_F_DIRTY;
+    scn->s_shdr_flags |= ELF_F_DIRTY;
+    return 0;
+}
+
+static Elf_Scn*
+_makescn(Elf *elf, size_t index) {
+    Elf_Scn *scn;
+
+    elf_assert(elf);
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    elf_assert(elf->e_ehdr);
+    elf_assert(_elf_scn_init.s_magic == SCN_MAGIC);
+    if (!(scn = (Elf_Scn*)malloc(sizeof(*scn)))) {
+	seterr(ERROR_MEM_SCN);
+	return NULL;
+    }
+    *scn = _elf_scn_init;
+    scn->s_elf = elf;
+    scn->s_scn_flags = ELF_F_DIRTY;
+    scn->s_shdr_flags = ELF_F_DIRTY;
+    scn->s_freeme = 1;
+    scn->s_index = index;
+    return scn;
+}
+
+Elf_Scn*
+_elf_first_scn(Elf *elf) {
+    Elf_Scn *scn;
+
+    elf_assert(elf);
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if ((scn = elf->e_scn_1)) {
+	return scn;
+    }
+    if ((scn = _makescn(elf, 0))) {
+	elf->e_scn_1 = elf->e_scn_n = scn;
+	if (_elf_update_shnum(elf, 1)) {
+	    free(scn);
+	    elf->e_scn_1 = elf->e_scn_n = scn = NULL;
+	}
+    }
+    return scn;
+}
+
+static Elf_Scn*
+_buildscn(Elf *elf) {
+    Elf_Scn *scn;
+
+    if (!_elf_first_scn(elf)) {
+	return NULL;
+    }
+    scn = elf->e_scn_n;
+    elf_assert(scn);
+    if (!(scn = _makescn(elf, scn->s_index + 1))) {
+	return NULL;
+    }
+    if (_elf_update_shnum(elf, scn->s_index + 1)) {
+	free(scn);
+	return NULL;
+    }
+    elf->e_scn_n = elf->e_scn_n->s_link = scn;
+    return scn;
+}
+
+Elf_Scn*
+elf_newscn(Elf *elf) {
+    Elf_Scn *scn;
+
+    if (!elf) {
+	return NULL;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if (!elf->e_readable && !elf->e_ehdr) {
+	seterr(ERROR_NOEHDR);
+    }
+    else if (elf->e_kind != ELF_K_ELF) {
+	seterr(ERROR_NOTELF);
+    }
+    else if (!elf->e_ehdr && !_elf_cook(elf)) {
+	return NULL;
+    }
+    else if ((scn = _buildscn(elf))) {
+	return scn;
+    }
+    return NULL;
+}

external/libelf/src/next.c

@@ -0,0 +1,42 @@
+/*
+next.c - implementation of the elf_next(3) function.
+Copyright (C) 1995 - 1998 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: next.c,v 1.7 2008/05/23 08:15:35 michael Exp $";
+#endif /* lint */
+
+Elf_Cmd
+elf_next(Elf *elf) {
+    if (!elf) {
+	return ELF_C_NULL;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if (!elf->e_parent) {
+	return ELF_C_NULL;
+    }
+    elf_assert(elf->e_parent->e_magic == ELF_MAGIC);
+    elf_assert(elf->e_parent->e_kind == ELF_K_AR);
+    elf->e_parent->e_off = elf->e_next;
+    if (elf->e_next == elf->e_parent->e_size) {
+	return ELF_C_NULL;
+    }
+    return ELF_C_READ;
+}

external/libelf/src/nextscn.c

@@ -0,0 +1,54 @@
+/*
+nextscn.c - implementation of the elf_nextscn(3) function.
+Copyright (C) 1995 - 1998 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: nextscn.c,v 1.7 2008/05/23 08:15:35 michael Exp $";
+#endif /* lint */
+
+Elf_Scn*
+elf_nextscn(Elf *elf, Elf_Scn *scn) {
+    if (!elf) {
+	return NULL;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if (scn) {
+	elf_assert(scn->s_magic == SCN_MAGIC);
+	if (scn->s_elf == elf) {
+	    return scn->s_link;
+	}
+	seterr(ERROR_ELFSCNMISMATCH);
+    }
+    else if (elf->e_kind != ELF_K_ELF) {
+	seterr(ERROR_NOTELF);
+    }
+    else if (elf->e_ehdr || _elf_cook(elf)) {
+	elf_assert(elf->e_ehdr);
+	for (scn = elf->e_scn_1; scn; scn = scn->s_link) {
+	    elf_assert(scn->s_magic == SCN_MAGIC);
+	    elf_assert(scn->s_elf == elf);
+	    if (scn->s_index == 1) {
+		return scn;
+	    }
+	}
+	seterr(ERROR_NOSUCHSCN);
+    }
+    return NULL;
+}

external/libelf/src/nlist.c

@@ -0,0 +1,253 @@
+/*
+ * nlist.c - implementation of the nlist(3) function.
+ * Copyright (C) 1995 - 2004 Michael Riepe
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <private.h>
+#include <nlist.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: nlist.c,v 1.15 2008/05/23 08:15:35 michael Exp $";
+#endif /* lint */
+
+#if !defined(_WIN32)
+#if HAVE_FCNTL_H
+#include <fcntl.h>
+#else
+extern int open();
+#endif /* HAVE_FCNTL_H */
+#endif /* defined(_WIN32) */
+
+#ifndef O_RDONLY
+#define O_RDONLY	0
+#endif /* O_RDONLY */
+
+#ifndef O_BINARY
+#define O_BINARY	0
+#endif /* O_BINARY */
+
+#define FILE_OPEN_MODE	(O_RDONLY | O_BINARY)
+
+#define PRIME	217
+
+struct hash {
+    const char*		name;
+    unsigned long	hash;
+    unsigned		next;
+};
+
+static const char*
+symbol_name(Elf *elf, const void *syms, const char *names, size_t nlimit, size_t index) {
+    size_t off;
+
+    if (elf->e_class == ELFCLASS32) {
+	off = ((Elf32_Sym*)syms)[index].st_name;
+    }
+#if __LIBELF64
+    else if (elf->e_class == ELFCLASS64) {
+	off = ((Elf64_Sym*)syms)[index].st_name;
+    }
+#endif /* __LIBELF64 */
+    else {
+	return NULL;
+    }
+    if (off >= 0 && off < nlimit) {
+	return &names[off];
+    }
+    return NULL;
+}
+
+static void
+copy_symbol(Elf *elf, struct nlist *np, const void *syms, size_t index) {
+    if (elf->e_class == ELFCLASS32) {
+	np->n_value = ((Elf32_Sym*)syms)[index].st_value;
+	np->n_scnum = ((Elf32_Sym*)syms)[index].st_shndx;
+    }
+#if __LIBELF64
+    else if (elf->e_class == ELFCLASS64) {
+	np->n_value = ((Elf64_Sym*)syms)[index].st_value;
+	np->n_scnum = ((Elf64_Sym*)syms)[index].st_shndx;
+    }
+#endif /* __LIBELF64 */
+    /*
+     * this needs more work
+     */
+    np->n_type = 0;
+    np->n_sclass = 0;
+    np->n_numaux = 0;
+}
+
+static int
+_elf_nlist(Elf *elf, struct nlist *nl) {
+    unsigned first[PRIME];
+    Elf_Scn *symtab = NULL;
+    Elf_Scn *strtab = NULL;
+    Elf_Data *symdata;
+    Elf_Data *strdata;
+    size_t symsize;
+    size_t nsymbols;
+    const char *name;
+    struct hash *table;
+    unsigned long hash;
+    unsigned i;
+    struct nlist *np;
+
+    /*
+     * Get and translate ELF header, section table and so on.
+     * Must be class independent, so don't use elf32_get*().
+     */
+    if (elf->e_kind != ELF_K_ELF) {
+	return -1;
+    }
+    if (!elf->e_ehdr && !_elf_cook(elf)) {
+	return -1;
+    }
+
+    /*
+     * Find symbol table. If there is none, try dynamic symbols.
+     */
+    for (symtab = elf->e_scn_1; symtab; symtab = symtab->s_link) {
+	if (symtab->s_type == SHT_SYMTAB) {
+	    break;
+	}
+	if (symtab->s_type == SHT_DYNSYM) {
+	    strtab = symtab;
+	}
+    }
+    if (!symtab && !(symtab = strtab)) {
+	return -1;
+    }
+
+    /*
+     * Get associated string table.
+     */
+    i = 0;
+    if (elf->e_class == ELFCLASS32) {
+	i = symtab->s_shdr32.sh_link;
+    }
+#if __LIBELF64
+    else if (elf->e_class == ELFCLASS64) {
+	i = symtab->s_shdr64.sh_link;
+    }
+#endif /* __LIBELF64 */
+    if (i == 0) {
+	return -1;
+    }
+    for (strtab = elf->e_scn_1; strtab; strtab = strtab->s_link) {
+	if (strtab->s_index == i) {
+	    break;
+	}
+    }
+    if (!strtab || strtab->s_type != SHT_STRTAB) {
+	return -1;
+    }
+
+    /*
+     * Get and translate section data.
+     */
+    symdata = elf_getdata(symtab, NULL);
+    strdata = elf_getdata(strtab, NULL);
+    if (!symdata || !strdata) {
+	return -1;
+    }
+    symsize = _msize(elf->e_class, _elf_version, ELF_T_SYM);
+    elf_assert(symsize);
+    nsymbols = symdata->d_size / symsize;
+    if (!symdata->d_buf || !strdata->d_buf || !nsymbols || !strdata->d_size) {
+	return -1;
+    }
+
+    /*
+     * Build a simple hash table.
+     */
+    if (!(table = (struct hash*)malloc(nsymbols * sizeof(*table)))) {
+	return -1;
+    }
+    for (i = 0; i < PRIME; i++) {
+	first[i] = 0;
+    }
+    for (i = 0; i < nsymbols; i++) {
+	table[i].name = NULL;
+	table[i].hash = 0;
+	table[i].next = 0;
+    }
+    for (i = 1; i < nsymbols; i++) {
+	name = symbol_name(elf, symdata->d_buf, strdata->d_buf,
+			   strdata->d_size, i);
+	if (name == NULL) {
+	    free(table);
+	    return -1;
+	}
+	if (*name != '\0') {
+	    table[i].name = name;
+	    table[i].hash = elf_hash((unsigned char*)name);
+	    hash = table[i].hash % PRIME;
+	    table[i].next = first[hash];
+	    first[hash] = i;
+	}
+    }
+
+    /*
+     * Lookup symbols, one by one.
+     */
+    for (np = nl; (name = np->n_name) && *name; np++) {
+	hash = elf_hash((unsigned char*)name);
+	for (i = first[hash % PRIME]; i; i = table[i].next) {
+	    if (table[i].hash == hash && !strcmp(table[i].name, name)) {
+		break;
+	    }
+	}
+	if (i) {
+	    copy_symbol(elf, np, symdata->d_buf, i);
+	}
+	else {
+	    np->n_value = 0;
+	    np->n_scnum = 0;
+	    np->n_type = 0;
+	    np->n_sclass = 0;
+	    np->n_numaux = 0;
+	}
+    }
+    free(table);
+    return 0;
+}
+
+int
+nlist(const char *filename, struct nlist *nl) {
+    int result = -1;
+    unsigned oldver;
+    Elf *elf;
+    int fd;
+
+    if ((oldver = elf_version(EV_CURRENT)) != EV_NONE) {
+	if ((fd = open(filename, FILE_OPEN_MODE)) != -1) {
+	    if ((elf = elf_begin(fd, ELF_C_READ, NULL))) {
+		result = _elf_nlist(elf, nl);
+		elf_end(elf);
+	    }
+	    close(fd);
+	}
+	elf_version(oldver);
+    }
+    if (result) {
+	while (nl->n_name && *nl->n_name) {
+	    nl->n_value = 0;
+	    nl++;
+	}
+    }
+    return result;
+}

external/libelf/src/nlist.h

@@ -0,0 +1,48 @@
+/*
+ * nlist.h - public header file for nlist(3).
+ * Copyright (C) 1995 - 2006 Michael Riepe
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+/* @(#) $Id: nlist.h,v 1.10 2008/05/23 08:15:35 michael Exp $ */
+
+#ifndef _NLIST_H
+#define _NLIST_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+struct nlist {
+    char*		n_name;
+    long		n_value;
+    short		n_scnum;
+    unsigned short	n_type;
+    char		n_sclass;
+    char		n_numaux;
+};
+
+#if (__STDC__ + 0) || defined(__cplusplus) || defined(_WIN32)
+extern int nlist(const char *__filename, struct nlist *__nl);
+#else /* __STDC__ || defined(__cplusplus) */
+extern int nlist();
+#endif /* __STDC__ || defined(__cplusplus) */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* _NLIST_H */

external/libelf/src/opt.delscn.c

@@ -0,0 +1,205 @@
+/*
+opt.delscn.c - implementation of the elf_delscn(3) function.
+Copyright (C) 1995 - 2001 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: opt.delscn.c,v 1.12 2008/05/23 08:15:35 michael Exp $";
+#endif /* lint */
+
+static size_t
+_newindex(size_t old, size_t index) {
+    return old == index ? SHN_UNDEF : (old > index ? old - 1 : old);
+}
+
+static void
+_elf32_update_shdr(Elf *elf, size_t index) {
+    Elf32_Shdr *shdr;
+    Elf_Scn *scn;
+
+    ((Elf32_Ehdr*)elf->e_ehdr)->e_shnum = elf->e_scn_n->s_index + 1;
+    for (scn = elf->e_scn_1; scn; scn = scn->s_link) {
+	shdr = &scn->s_shdr32;
+	switch (shdr->sh_type) {
+	    case SHT_REL:
+	    case SHT_RELA:
+		shdr->sh_info = _newindex(shdr->sh_info, index);
+		/* fall through */
+	    case SHT_DYNSYM:
+	    case SHT_DYNAMIC:
+	    case SHT_HASH:
+	    case SHT_SYMTAB:
+#if __LIBELF_SYMBOL_VERSIONS
+#if __LIBELF_SUN_SYMBOL_VERSIONS
+	    case SHT_SUNW_verdef:
+	    case SHT_SUNW_verneed:
+	    case SHT_SUNW_versym:
+#else /* __LIBELF_SUN_SYMBOL_VERSIONS */
+	    case SHT_GNU_verdef:
+	    case SHT_GNU_verneed:
+	    case SHT_GNU_versym:
+#endif /* __LIBELF_SUN_SYMBOL_VERSIONS */
+#endif /* __LIBELF_SYMBOL_VERSIONS */
+		shdr->sh_link = _newindex(shdr->sh_link, index);
+		/* fall through */
+	    default:
+		break;
+	}
+    }
+}
+
+#if __LIBELF64
+
+static void
+_elf64_update_shdr(Elf *elf, size_t index) {
+    Elf64_Shdr *shdr;
+    Elf_Scn *scn;
+
+    ((Elf64_Ehdr*)elf->e_ehdr)->e_shnum = elf->e_scn_n->s_index + 1;
+    for (scn = elf->e_scn_1; scn; scn = scn->s_link) {
+	shdr = &scn->s_shdr64;
+	switch (shdr->sh_type) {
+	    case SHT_REL:
+	    case SHT_RELA:
+		shdr->sh_info = _newindex(shdr->sh_info, index);
+		/* fall through */
+	    case SHT_DYNSYM:
+	    case SHT_DYNAMIC:
+	    case SHT_HASH:
+	    case SHT_SYMTAB:
+#if __LIBELF_SYMBOL_VERSIONS
+#if __LIBELF_SUN_SYMBOL_VERSIONS
+	    case SHT_SUNW_verdef:
+	    case SHT_SUNW_verneed:
+	    case SHT_SUNW_versym:
+#else /* __LIBELF_SUN_SYMBOL_VERSIONS */
+	    case SHT_GNU_verdef:
+	    case SHT_GNU_verneed:
+	    case SHT_GNU_versym:
+#endif /* __LIBELF_SUN_SYMBOL_VERSIONS */
+#endif /* __LIBELF_SYMBOL_VERSIONS */
+		shdr->sh_link = _newindex(shdr->sh_link, index);
+		/* fall through */
+	    default:
+		break;
+	}
+    }
+}
+
+#endif /* __LIBELF64 */
+
+size_t
+elf_delscn(Elf *elf, Elf_Scn *scn) {
+    Elf_Scn *pscn;
+    Scn_Data *sd;
+    Scn_Data *tmp;
+    size_t index;
+
+    if (!elf || !scn) {
+	return SHN_UNDEF;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    elf_assert(scn->s_magic == SCN_MAGIC);
+    elf_assert(elf->e_ehdr);
+    if (scn->s_elf != elf) {
+	seterr(ERROR_ELFSCNMISMATCH);
+	return SHN_UNDEF;
+    }
+    elf_assert(elf->e_scn_1);
+    if (scn == elf->e_scn_1) {
+	seterr(ERROR_NULLSCN);
+	return SHN_UNDEF;
+    }
+
+    /*
+     * Find previous section.
+     */
+    for (pscn = elf->e_scn_1; pscn->s_link; pscn = pscn->s_link) {
+	if (pscn->s_link == scn) {
+	    break;
+	}
+    }
+    if (pscn->s_link != scn) {
+	seterr(ERROR_ELFSCNMISMATCH);
+	return SHN_UNDEF;
+    }
+    /*
+     * Unlink section.
+     */
+    if (elf->e_scn_n == scn) {
+	elf->e_scn_n = pscn;
+    }
+    pscn->s_link = scn->s_link;
+    index = scn->s_index;
+    /*
+     * Free section descriptor and data.
+     */
+    for (sd = scn->s_data_1; sd; sd = tmp) {
+	elf_assert(sd->sd_magic == DATA_MAGIC);
+	elf_assert(sd->sd_scn == scn);
+	tmp = sd->sd_link;
+	if (sd->sd_free_data && sd->sd_memdata) {
+	    free(sd->sd_memdata);
+	}
+	if (sd->sd_freeme) {
+	    free(sd);
+	}
+    }
+    if ((sd = scn->s_rawdata)) {
+	elf_assert(sd->sd_magic == DATA_MAGIC);
+	elf_assert(sd->sd_scn == scn);
+	if (sd->sd_free_data && sd->sd_memdata) {
+	    free(sd->sd_memdata);
+	}
+	if (sd->sd_freeme) {
+	    free(sd);
+	}
+    }
+    if (scn->s_freeme) {
+	elf_assert(scn->s_index > 0);
+	free(scn);
+    }
+    /*
+     * Adjust section indices.
+     */
+    for (scn = pscn->s_link; scn; scn = scn->s_link) {
+	elf_assert(scn->s_index > index);
+	scn->s_index--;
+    }
+    /*
+     * Adjust ELF header and well-known section headers.
+     */
+    if (elf->e_class == ELFCLASS32) {
+	_elf32_update_shdr(elf, index);
+	return index;
+    }
+#if __LIBELF64
+    else if (elf->e_class == ELFCLASS64) {
+	_elf64_update_shdr(elf, index);
+	return index;
+    }
+#endif /* __LIBELF64 */
+    else if (valid_class(elf->e_class)) {
+	seterr(ERROR_UNIMPLEMENTED);
+    }
+    else {
+	seterr(ERROR_UNKNOWN_CLASS);
+    }
+    return SHN_UNDEF;
+}

external/libelf/src/private.h

@@ -0,0 +1,446 @@
+/*
+ * private.h - private definitions for libelf.
+ * Copyright (C) 1995 - 2007 Michael Riepe
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+/* @(#) $Id: private.h,v 1.40 2009/11/01 13:04:19 michael Exp $ */
+
+#ifndef _PRIVATE_H
+#define _PRIVATE_H
+
+#define __LIBELF_INTERNAL__ 1
+
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+/*
+ * Workaround for GLIBC bug:
+ * include <stdint.h> before <sys/types.h>
+ */
+#if HAVE_STDINT_H
+#include <stdint.h>
+#endif
+#include <sys/types.h>
+
+#if STDC_HEADERS
+# include <stdlib.h>
+# include <string.h>
+#else /* STDC_HEADERS */
+extern void *malloc(), *realloc();
+extern void free(), bcopy(), abort();
+extern int strcmp(), strncmp(), memcmp();
+extern void *memcpy(), *memmove(), *memset();
+#endif /* STDC_HEADERS */
+
+#if defined(_WIN32)
+#include <io.h>
+#else
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#else /* HAVE_UNISTD_H */
+extern int read(), write(), close();
+extern off_t lseek();
+#if HAVE_FTRUNCATE
+extern int ftruncate();
+#endif /* HAVE_FTRUNCATE */
+#endif /* HAVE_UNISTD_H */
+#endif /* defined(_WIN32) */
+
+#ifndef SEEK_SET
+#define SEEK_SET	0
+#endif /* SEEK_SET */
+#ifndef SEEK_CUR
+#define SEEK_CUR	1
+#endif /* SEEK_CUR */
+#ifndef SEEK_END
+#define SEEK_END	2
+#endif /* SEEK_END */
+
+#if !HAVE_MEMCMP
+# define memcmp	strncmp
+#endif /* !HAVE_MEMCMP */
+#if !HAVE_MEMCPY
+# define memcpy(d,s,n)	bcopy(s,d,n)
+#endif /* !HAVE_MEMCPY */
+#if !HAVE_MEMMOVE
+# define memmove(d,s,n)	bcopy(s,d,n)
+#endif /* !HAVE_MEMMOVE */
+
+#if !HAVE_MEMSET
+# define memset _elf_memset
+extern void *_elf_memset();
+#endif /* !HAVE_MEMSET */
+
+#if HAVE_STRUCT_NLIST_DECLARATION
+# define nlist __override_nlist_declaration
+#endif /* HAVE_STRUCT_NLIST_DECLARATION */
+
+#if __LIBELF_NEED_LINK_H
+# include <link.h>
+#elif __LIBELF_NEED_SYS_LINK_H
+# include <sys/link.h>
+#endif /* __LIBELF_NEED_LINK_H */
+
+#if HAVE_AR_H
+#include <ar.h>
+#else /* HAVE_AR_H */
+
+#define ARMAG	"!<arch>\n"
+#define SARMAG	8
+
+struct ar_hdr {
+    char    ar_name[16];
+    char    ar_date[12];
+    char    ar_uid[6];
+    char    ar_gid[6];
+    char    ar_mode[8];
+    char    ar_size[10];
+    char    ar_fmag[2];
+};
+
+#define ARFMAG	"`\n"
+
+#endif /* HAVE_AR_H */
+
+#include <libelf.h>
+
+#if HAVE_STRUCT_NLIST_DECLARATION
+# undef nlist
+#endif /* HAVE_STRUCT_NLIST_DECLARATION */
+
+#if __LIBELF64
+#include <gelf.h>
+#endif /* __LIBELF64 */
+
+typedef struct Scn_Data Scn_Data;
+
+/*
+ * ELF descriptor
+ */
+struct Elf {
+    /* common */
+    size_t	e_size;			/* file/member size */
+    size_t	e_dsize;		/* size of memory image */
+    Elf_Kind	e_kind;			/* kind of file */
+    char*	e_data;			/* file/member data */
+    char*	e_rawdata;		/* file/member raw data */
+    size_t	e_idlen;		/* identifier size */
+    int		e_fd;			/* file descriptor */
+    unsigned	e_count;		/* activation count */
+    /* archive members (still common) */
+    Elf*	e_parent;		/* NULL if not an archive member */
+    size_t	e_next;			/* 0 if not an archive member */
+    size_t	e_base;			/* 0 if not an archive member */
+    Elf*	e_link;			/* next archive member or NULL */
+    Elf_Arhdr*	e_arhdr;		/* archive member header or NULL */
+    /* archives */
+    size_t	e_off;			/* current member offset (for elf_begin) */
+    Elf*	e_members;		/* linked list of active archive members */
+    char*	e_symtab;		/* archive symbol table */
+    size_t	e_symlen;		/* length of archive symbol table */
+    char*	e_strtab;		/* archive string table */
+    size_t	e_strlen;		/* length of archive string table */
+    /* ELF files */
+    unsigned	e_class;		/* ELF class */
+    unsigned	e_encoding;		/* ELF data encoding */
+    unsigned	e_version;		/* ELF version */
+    char*	e_ehdr;			/* ELF header */
+    char*	e_phdr;			/* ELF program header table */
+    size_t	e_phnum;		/* size of program header table */
+    Elf_Scn*	e_scn_1;		/* first section */
+    Elf_Scn*	e_scn_n;		/* last section */
+    unsigned	e_elf_flags;		/* elf flags (ELF_F_*) */
+    unsigned	e_ehdr_flags;		/* ehdr flags (ELF_F_*) */
+    unsigned	e_phdr_flags;		/* phdr flags (ELF_F_*) */
+    /* misc flags */
+    unsigned	e_readable : 1;		/* file is readable */
+    unsigned	e_writable : 1;		/* file is writable */
+    unsigned	e_disabled : 1;		/* e_fd has been disabled */
+    unsigned	e_cooked : 1;		/* e_data was modified */
+    unsigned	e_free_syms : 1;	/* e_symtab is malloc'ed */
+    unsigned	e_unmap_data : 1;	/* e_data is mmap'ed */
+    unsigned	e_memory : 1;		/* created by elf_memory() */
+    /* magic number for debugging */
+    long	e_magic;
+};
+
+#define ELF_MAGIC	0x012b649e
+
+#define INIT_ELF	{\
+    /* e_size */	0,\
+    /* e_dsize */	0,\
+    /* e_kind */	ELF_K_NONE,\
+    /* e_data */	NULL,\
+    /* e_rawdata */	NULL,\
+    /* e_idlen */	0,\
+    /* e_fd */		-1,\
+    /* e_count */	1,\
+    /* e_parent */	NULL,\
+    /* e_next */	0,\
+    /* e_base */	0,\
+    /* e_link */	NULL,\
+    /* e_arhdr */	NULL,\
+    /* e_off */		0,\
+    /* e_members */	NULL,\
+    /* e_symtab */	NULL,\
+    /* e_symlen */	0,\
+    /* e_strtab */	NULL,\
+    /* e_strlen */	0,\
+    /* e_class */	ELFCLASSNONE,\
+    /* e_encoding */	ELFDATANONE,\
+    /* e_version */	EV_NONE,\
+    /* e_ehdr */	NULL,\
+    /* e_phdr */	NULL,\
+    /* e_phnum */	0,\
+    /* e_scn_1 */	NULL,\
+    /* e_scn_n */	NULL,\
+    /* e_elf_flags */	0,\
+    /* e_ehdr_flags */	0,\
+    /* e_phdr_flags */	0,\
+    /* e_readable */	0,\
+    /* e_writable */	0,\
+    /* e_disabled */	0,\
+    /* e_cooked */	0,\
+    /* e_free_syms */	0,\
+    /* e_unmap_data */	0,\
+    /* e_memory */	0,\
+    /* e_magic */	ELF_MAGIC\
+}
+
+/*
+ * Section descriptor
+ */
+struct Elf_Scn {
+    Elf_Scn*	s_link;			/* pointer to next Elf_Scn */
+    Elf*	s_elf;			/* pointer to elf descriptor */
+    size_t	s_index;		/* number of this section */
+    unsigned	s_scn_flags;		/* section flags (ELF_F_*) */
+    unsigned	s_shdr_flags;		/* shdr flags (ELF_F_*) */
+    Scn_Data*	s_data_1;		/* first data buffer */
+    Scn_Data*	s_data_n;		/* last data buffer */
+    Scn_Data*	s_rawdata;		/* raw data buffer */
+    /* data copied from shdr */
+    unsigned	s_type;			/* section type */
+    size_t	s_offset;		/* section offset */
+    size_t	s_size;			/* section size */
+    /* misc flags */
+    unsigned	s_freeme : 1;		/* this Elf_Scn was malloc'ed */
+    /* section header */
+    union {
+#if __LIBELF64
+	Elf64_Shdr	u_shdr64;
+#endif /* __LIBELF64 */
+	Elf32_Shdr	u_shdr32;
+    }		s_uhdr;
+    /* magic number for debugging */
+    long	s_magic;
+};
+#define s_shdr32	s_uhdr.u_shdr32
+#define s_shdr64	s_uhdr.u_shdr64
+
+#define SCN_MAGIC	0x012c747d
+
+#define INIT_SCN	{\
+    /* s_link */	NULL,\
+    /* s_elf */		NULL,\
+    /* s_index */	0,\
+    /* s_scn_flags */	0,\
+    /* s_shdr_flags */	0,\
+    /* s_data_1 */	NULL,\
+    /* s_data_n */	NULL,\
+    /* s_rawdata */	NULL,\
+    /* s_type */	SHT_NULL,\
+    /* s_offset */	0,\
+    /* s_size */	0,\
+    /* s_freeme */	0,\
+    /* s_uhdr */	{{0,}},\
+    /* s_magic */	SCN_MAGIC\
+}
+
+/*
+ * Data descriptor
+ */
+struct Scn_Data {
+    Elf_Data	sd_data;		/* must be first! */
+    Scn_Data*	sd_link;		/* pointer to next Scn_Data */
+    Elf_Scn*	sd_scn;			/* pointer to section */
+    char*	sd_memdata;		/* memory image of section */
+    unsigned	sd_data_flags;		/* data flags (ELF_F_*) */
+    /* misc flags */
+    unsigned	sd_freeme : 1;		/* this Scn_Data was malloc'ed */
+    unsigned	sd_free_data : 1;	/* sd_memdata is malloc'ed */
+    /* magic number for debugging */
+    long	sd_magic;
+};
+
+#define DATA_MAGIC	0x01072639
+
+#define INIT_DATA	{\
+    {\
+    /* d_buf */		NULL,\
+    /* d_type */	ELF_T_BYTE,\
+    /* d_size */	0,\
+    /* d_off */		0,\
+    /* d_align */	0,\
+    /* d_version */	EV_NONE\
+    },\
+    /* sd_link */	NULL,\
+    /* sd_scn */	NULL,\
+    /* sd_memdata */	NULL,\
+    /* sd_data_flags */	0,\
+    /* sd_freeme */	0,\
+    /* sd_free_data */	0,\
+    /* sd_magic */	DATA_MAGIC\
+}
+
+/*
+ * Private status variables
+ */
+extern unsigned _elf_version;
+extern int _elf_errno;
+extern int _elf_fill;
+extern int _elf_sanity_checks;
+#define SANITY_CHECK_STRPTR	(1u << 0)
+
+/*
+ * Private functions
+ */
+extern void *_elf_read __P((Elf*, void*, size_t, size_t));
+extern void *_elf_mmap __P((Elf*));
+extern int _elf_cook __P((Elf*));
+extern char *_elf_getehdr __P((Elf*, unsigned));
+extern char *_elf_getphdr __P((Elf*, unsigned));
+extern Elf_Data *_elf_xlatetom __P((const Elf*, Elf_Data*, const Elf_Data*));
+extern Elf_Type _elf_scn_type __P((unsigned));
+extern size_t _elf32_xltsize __P((const Elf_Data *__src, unsigned __dv, unsigned __encode, int __tof));
+extern size_t _elf64_xltsize __P((const Elf_Data *__src, unsigned __dv, unsigned __encode, int __tof));
+extern int _elf_update_shnum(Elf *__elf, size_t __shnum);
+extern Elf_Scn *_elf_first_scn(Elf *__elf);
+
+/*
+ * Special translators
+ */
+extern size_t _elf_verdef_32L11_tof __P((unsigned char *dst, const unsigned char *src, size_t n));
+extern size_t _elf_verdef_32L11_tom __P((unsigned char *dst, const unsigned char *src, size_t n));
+extern size_t _elf_verdef_32M11_tof __P((unsigned char *dst, const unsigned char *src, size_t n));
+extern size_t _elf_verdef_32M11_tom __P((unsigned char *dst, const unsigned char *src, size_t n));
+extern size_t _elf_verdef_64L11_tof __P((unsigned char *dst, const unsigned char *src, size_t n));
+extern size_t _elf_verdef_64L11_tom __P((unsigned char *dst, const unsigned char *src, size_t n));
+extern size_t _elf_verdef_64M11_tof __P((unsigned char *dst, const unsigned char *src, size_t n));
+extern size_t _elf_verdef_64M11_tom __P((unsigned char *dst, const unsigned char *src, size_t n));
+extern size_t _elf_verneed_32L11_tof __P((unsigned char *dst, const unsigned char *src, size_t n));
+extern size_t _elf_verneed_32L11_tom __P((unsigned char *dst, const unsigned char *src, size_t n));
+extern size_t _elf_verneed_32M11_tof __P((unsigned char *dst, const unsigned char *src, size_t n));
+extern size_t _elf_verneed_32M11_tom __P((unsigned char *dst, const unsigned char *src, size_t n));
+extern size_t _elf_verneed_64L11_tof __P((unsigned char *dst, const unsigned char *src, size_t n));
+extern size_t _elf_verneed_64L11_tom __P((unsigned char *dst, const unsigned char *src, size_t n));
+extern size_t _elf_verneed_64M11_tof __P((unsigned char *dst, const unsigned char *src, size_t n));
+extern size_t _elf_verneed_64M11_tom __P((unsigned char *dst, const unsigned char *src, size_t n));
+
+/*
+ * Private data
+ */
+extern const Elf_Scn _elf_scn_init;
+extern const Scn_Data _elf_data_init;
+extern const size_t _elf_fmsize[2][EV_CURRENT - EV_NONE][ELF_T_NUM][2];
+
+/*
+ * Access macros for _elf_fmsize[]
+ */
+#define _fmsize(c,v,t,w)	\
+	(_elf_fmsize[(c)-ELFCLASS32][(v)-EV_NONE-1][(t)-ELF_T_BYTE][(w)])
+#define _fsize(c,v,t)		_fmsize((c),(v),(t),1)
+#define _msize(c,v,t)		_fmsize((c),(v),(t),0)
+
+/*
+ * Various checks
+ */
+#define valid_class(c)		((c) >= ELFCLASS32 && (c) <= ELFCLASS64)
+#define valid_encoding(e)	((e) >= ELFDATA2LSB && (e) <= ELFDATA2MSB)
+#define valid_version(v)	((v) > EV_NONE && (v) <= EV_CURRENT)
+#define valid_type(t)		((unsigned)(t) < ELF_T_NUM)
+
+/*
+ * Error codes
+ */
+enum {
+#define __err__(a,b)	a,
+#include <errors.h>		/* include constants from errors.h */
+#undef __err__
+ERROR_NUM
+};
+
+#define seterr(err)	(_elf_errno = (err))
+
+/*
+ * Sizes of data types (external representation)
+ * These definitions should be in <elf.h>, but...
+ */
+#ifndef ELF32_FSZ_ADDR
+# define ELF32_FSZ_ADDR		4
+# define ELF32_FSZ_HALF		2
+# define ELF32_FSZ_OFF		4
+# define ELF32_FSZ_SWORD	4
+# define ELF32_FSZ_WORD		4
+#endif /* ELF32_FSZ_ADDR */
+#ifndef ELF64_FSZ_ADDR
+# define ELF64_FSZ_ADDR		8
+# define ELF64_FSZ_HALF		2
+# define ELF64_FSZ_OFF		8
+# define ELF64_FSZ_SWORD	4
+# define ELF64_FSZ_SXWORD	8
+# define ELF64_FSZ_WORD		4
+# define ELF64_FSZ_XWORD	8
+#endif /* ELF64_FSZ_ADDR */
+
+/*
+ * More missing pieces, in no particular order
+ */
+#ifndef SHT_SYMTAB_SHNDX
+#define SHT_SYMTAB_SHNDX	18
+#endif /* SHT_SYMTAB_SHNDX */
+
+#ifndef SHN_XINDEX
+#define SHN_XINDEX		0xffff
+#endif /* SHN_XINDEX */
+
+#ifndef PN_XNUM
+#define PN_XNUM			0xffff
+#endif /* PN_XNUM */
+
+/*
+ * Debugging
+ */
+#if ENABLE_DEBUG
+extern void __elf_assert __P((const char*, unsigned, const char*));
+# if (__STDC__ + 0)
+#  define elf_assert(x)	do{if(!(x))__elf_assert(__FILE__,__LINE__,#x);}while(0)
+# else /* __STDC__ */
+#  define elf_assert(x)	do{if(!(x))__elf_assert(__FILE__,__LINE__,"x");}while(0)
+# endif /* __STDC__ */
+#else /* ENABLE_DEBUG */
+# define elf_assert(x)	do{}while(0)
+#endif /* ENABLE_DEBUG */
+
+/*
+ * Return values for certain functions
+ */
+#define LIBELF_SUCCESS	1
+#define LIBELF_FAILURE	0
+
+#endif /* _PRIVATE_H */

external/libelf/src/rand.c

@@ -0,0 +1,43 @@
+/*
+rand.c - implementation of the elf_rand(3) function.
+Copyright (C) 1995 - 1998 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: rand.c,v 1.7 2008/05/23 08:15:35 michael Exp $";
+#endif /* lint */
+
+size_t
+elf_rand(Elf *elf, size_t offset) {
+    if (!elf) {
+	return 0;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if (elf->e_kind != ELF_K_AR) {
+	seterr(ERROR_NOTARCHIVE);
+    }
+    else if (offset <= 0 || offset > elf->e_size) {
+	seterr(ERROR_BADOFF);
+    }
+    else {
+	elf->e_off = offset;
+	return offset;
+    }
+    return 0;
+}

external/libelf/src/rawdata.c

@@ -0,0 +1,89 @@
+/*
+rawdata.c - implementation of the elf_rawdata(3) function.
+Copyright (C) 1995 - 2000 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: rawdata.c,v 1.10 2008/05/23 08:15:35 michael Exp $";
+#endif /* lint */
+
+Elf_Data*
+elf_rawdata(Elf_Scn *scn, Elf_Data *data) {
+    Scn_Data *sd;
+    Elf *elf;
+
+    if (!scn) {
+	return NULL;
+    }
+    elf_assert(scn->s_magic == SCN_MAGIC);
+    elf = scn->s_elf;
+    elf_assert(elf);
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if (!elf->e_readable) {
+	return NULL;
+    }
+    else if (scn->s_index == SHN_UNDEF || scn->s_type == SHT_NULL) {
+	seterr(ERROR_NULLSCN);
+    }
+    else if (data) {
+	return NULL;
+    }
+    else if ((sd = scn->s_rawdata)) {
+	elf_assert(sd->sd_magic == DATA_MAGIC);
+	elf_assert(sd->sd_scn == scn);
+	return &sd->sd_data;
+    }
+    else if (scn->s_offset < 0 || scn->s_offset > elf->e_size) {
+	seterr(ERROR_OUTSIDE);
+    }
+    else if (scn->s_type != SHT_NOBITS
+	    && scn->s_offset + scn->s_size > elf->e_size) {
+	seterr(ERROR_TRUNC_SCN);
+    }
+    else if (!(sd = (Scn_Data*)malloc(sizeof(*sd)))) {
+	seterr(ERROR_MEM_SCNDATA);
+    }
+    else {
+	*sd = _elf_data_init;
+	sd->sd_scn = scn;
+	sd->sd_freeme = 1;
+	sd->sd_data.d_size = scn->s_size;
+	sd->sd_data.d_version = _elf_version;
+	if (scn->s_type != SHT_NOBITS && scn->s_size) {
+	    if (!(sd->sd_memdata = (char*)malloc(scn->s_size))) {
+		seterr(ERROR_IO_2BIG);
+		free(sd);
+		return NULL;
+	    }
+	    else if (elf->e_rawdata) {
+		memcpy(sd->sd_memdata, elf->e_rawdata + scn->s_offset, scn->s_size);
+	    }
+	    else if (!_elf_read(elf, sd->sd_memdata, scn->s_offset, scn->s_size)) {
+		free(sd->sd_memdata);
+		free(sd);
+		return NULL;
+	    }
+	    sd->sd_data.d_buf = sd->sd_memdata;
+	    sd->sd_free_data = 1;
+	}
+	scn->s_rawdata = sd;
+	return &sd->sd_data;
+    }
+    return NULL;
+}

external/libelf/src/rawfile.c

@@ -0,0 +1,54 @@
+/*
+ * rawfile.c - implementation of the elf_rawfile(3) function.
+ * Copyright (C) 1995 - 2009 Michael Riepe
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: rawfile.c,v 1.8 2009/05/22 17:07:46 michael Exp $";
+#endif /* lint */
+
+char*
+elf_rawfile(Elf *elf, size_t *ptr) {
+    size_t tmp;
+
+    if (!ptr) {
+	ptr = &tmp;
+    }
+    *ptr = 0;
+    if (!elf) {
+	return NULL;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if (!elf->e_readable) {
+	return NULL;
+    }
+    else if (elf->e_size) {
+	if (!elf->e_rawdata) {
+	    elf_assert(elf->e_data);
+	    if (!elf->e_cooked) {
+		elf->e_rawdata = elf->e_data;
+	    }
+	    else if (!(elf->e_rawdata = _elf_read(elf, NULL, 0, elf->e_size))) {
+		return NULL;
+	    }
+	}
+	*ptr = elf->e_size;
+    }
+    return elf->e_rawdata;
+}

external/libelf/src/strptr.c

@@ -0,0 +1,150 @@
+/*
+ * strptr.c - implementation of the elf_strptr(3) function.
+ * Copyright (C) 1995 - 2007 Michael Riepe
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: strptr.c,v 1.12 2008/05/23 08:15:35 michael Exp $";
+#endif /* lint */
+
+char*
+elf_strptr(Elf *elf, size_t section, size_t offset) {
+    Elf_Data *data;
+    Elf_Scn *scn;
+    size_t n;
+    char *s;
+
+    if (!elf) {
+	return NULL;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if (!(scn = elf_getscn(elf, section))) {
+	return NULL;
+    }
+    if (scn->s_index == SHN_UNDEF) {
+	seterr(ERROR_NOSTRTAB);
+	return NULL;
+    }
+    /*
+     * checking the section header is more appropriate
+     */
+    if (elf->e_class == ELFCLASS32) {
+	if (scn->s_shdr32.sh_type != SHT_STRTAB) {
+	    seterr(ERROR_NOSTRTAB);
+	    return NULL;
+	}
+    }
+#if __LIBELF64
+    else if (elf->e_class == ELFCLASS64) {
+	if (scn->s_shdr64.sh_type != SHT_STRTAB) {
+	    seterr(ERROR_NOSTRTAB);
+	    return NULL;
+	}
+    }
+#endif /* __LIBELF64 */
+    else if (valid_class(elf->e_class)) {
+	seterr(ERROR_UNIMPLEMENTED);
+	return NULL;
+    }
+    else {
+	seterr(ERROR_UNKNOWN_CLASS);
+	return NULL;
+    }
+    /*
+     * Find matching buffer
+     */
+    n = 0;
+    data = NULL;
+    if (elf->e_elf_flags & ELF_F_LAYOUT) {
+	/*
+	 * Programmer is responsible for d_off
+	 * Note: buffers may be in any order!
+	 */
+	while ((data = elf_getdata(scn, data))) {
+	    n = data->d_off;
+	    if (offset >= n && offset - n < data->d_size) {
+		/*
+		 * Found it
+		 */
+		break;
+	    }
+	}
+    }
+    else {
+	/*
+	 * Calculate offsets myself
+	 */
+	while ((data = elf_getdata(scn, data))) {
+	    if (data->d_align > 1) {
+		n += data->d_align - 1;
+		n -= n % data->d_align;
+	    }
+	    if (offset < n) {
+		/*
+		 * Invalid offset: points into a hole
+		 */
+		seterr(ERROR_BADSTROFF);
+		return NULL;
+	    }
+	    if (offset - n < data->d_size) {
+		/*
+		 * Found it
+		 */
+		break;
+	    }
+	    n += data->d_size;
+	}
+    }
+    if (data == NULL) {
+	/*
+	 * Not found
+	 */
+	seterr(ERROR_BADSTROFF);
+	return NULL;
+    }
+    if (data->d_buf == NULL) {
+	/*
+	 * Buffer is NULL (usually the programmers' fault)
+	 */
+	seterr(ERROR_NULLBUF);
+	return NULL;
+    }
+    offset -= n;
+    s = (char*)data->d_buf;
+    if (!(_elf_sanity_checks & SANITY_CHECK_STRPTR)) {
+	return s + offset;
+    }
+    /*
+     * Perform extra sanity check
+     */
+    for (n = offset; n < data->d_size; n++) {
+	if (s[n] == '\0') {
+	    /*
+	     * Return properly NUL terminated string
+	     */
+	    return s + offset;
+	}
+    }
+    /*
+     * String is not NUL terminated
+     * Return error to avoid SEGV in application
+     */
+    seterr(ERROR_UNTERM);
+    return NULL;
+}

external/libelf/src/swap64.c

@@ -0,0 +1,81 @@
+/*
+swap64.c - 64-bit byte swapping functions.
+Copyright (C) 1995 - 2001 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+#include <byteswap.h>
+
+#if __LIBELF64
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: swap64.c,v 1.6 2008/05/23 08:15:35 michael Exp $";
+#endif /* lint */
+
+__libelf_u64_t
+_elf_load_u64L(const unsigned char *from) {
+    return ((__libelf_u64_t)__load_u32L(from + 4) << 32)
+	 | (__libelf_u64_t)__load_u32L(from);
+}
+
+__libelf_u64_t
+_elf_load_u64M(const unsigned char *from) {
+    return ((__libelf_u64_t)__load_u32M(from) << 32)
+	 | (__libelf_u64_t)__load_u32M(from + 4);
+}
+
+__libelf_i64_t
+_elf_load_i64L(const unsigned char *from) {
+    return ((__libelf_i64_t)__load_i32L(from + 4) << 32)
+	 | (__libelf_u64_t)__load_u32L(from);
+}
+
+__libelf_i64_t
+_elf_load_i64M(const unsigned char *from) {
+    return ((__libelf_i64_t)__load_i32M(from) << 32)
+	 | (__libelf_u64_t)__load_u32M(from + 4);
+}
+
+void
+_elf_store_u64L(unsigned char *to, __libelf_u64_t v) {
+    __store_u32L(to, (__libelf_u32_t)v);
+    v >>= 32;
+    __store_u32L(to + 4, (__libelf_u32_t)v);
+}
+
+void
+_elf_store_u64M(unsigned char *to, __libelf_u64_t v) {
+    __store_u32M(to + 4, (__libelf_u32_t)v);
+    v >>= 32;
+    __store_u32M(to, (__libelf_u32_t)v);
+}
+
+void
+_elf_store_i64L(unsigned char *to, __libelf_u64_t v) {
+    __store_u32L(to, (__libelf_u32_t)v);
+    v >>= 32;
+    __store_i32L(to + 4, (__libelf_u32_t)v);
+}
+
+void
+_elf_store_i64M(unsigned char *to, __libelf_u64_t v) {
+    __store_u32M(to + 4, (__libelf_u32_t)v);
+    v >>= 32;
+    __store_i32M(to, (__libelf_u32_t)v);
+}
+
+#endif /* __LIBELF64 */

external/libelf/src/verdef.h

@@ -0,0 +1,241 @@
+/*
+ * verdef.h - copy versioning information.
+ * Copyright (C) 2001 - 2006 Michael Riepe
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#ifndef lint
+static const char verdef_h_rcsid[] = "@(#) $Id: verdef.h,v 1.13 2008/05/23 08:15:35 michael Exp $";
+#endif /* lint */
+
+#if VER_DEF_CURRENT != 1
+#error libelf currently does not support VER_DEF_CURRENT != 1
+#endif /* VER_DEF_CURRENT != 1 */
+
+#if TOFILE
+
+static void
+__store_verdaux(verdaux_ftype *dst, const verdaux_mtype *src, unsigned enc) {
+    if (enc == ELFDATA2LSB) {
+	__store_u32L(dst->vda_name, src->vda_name);
+	__store_u32L(dst->vda_next, src->vda_next);
+    }
+    else {
+	__store_u32M(dst->vda_name, src->vda_name);
+	__store_u32M(dst->vda_next, src->vda_next);
+    }
+}
+
+static void
+__store_verdef(verdef_ftype *dst, const verdef_mtype *src, unsigned enc) {
+    if (enc == ELFDATA2LSB) {
+	__store_u16L(dst->vd_version, src->vd_version);
+	__store_u16L(dst->vd_flags,   src->vd_flags);
+	__store_u16L(dst->vd_ndx,     src->vd_ndx);
+	__store_u16L(dst->vd_cnt,     src->vd_cnt);
+	__store_u32L(dst->vd_hash,    src->vd_hash);
+	__store_u32L(dst->vd_aux,     src->vd_aux);
+	__store_u32L(dst->vd_next,    src->vd_next);
+    }
+    else {
+	__store_u16M(dst->vd_version, src->vd_version);
+	__store_u16M(dst->vd_flags,   src->vd_flags);
+	__store_u16M(dst->vd_ndx,     src->vd_ndx);
+	__store_u16M(dst->vd_cnt,     src->vd_cnt);
+	__store_u32M(dst->vd_hash,    src->vd_hash);
+	__store_u32M(dst->vd_aux,     src->vd_aux);
+	__store_u32M(dst->vd_next,    src->vd_next);
+    }
+}
+
+typedef verdaux_mtype		verdaux_stype;
+typedef verdaux_ftype		verdaux_dtype;
+typedef verdef_mtype		verdef_stype;
+typedef verdef_ftype		verdef_dtype;
+typedef align_mtype		verdef_atype;
+
+#define copy_verdaux_srctotmp(d, s, e)	(*(d) = *(s))
+#define copy_verdaux_tmptodst(d, s, e)	__store_verdaux((d), (s), (e))
+#define copy_verdef_srctotmp(d, s, e)	(*(d) = *(s))
+#define copy_verdef_tmptodst(d, s, e)	__store_verdef((d), (s), (e))
+
+#define translator_suffix	_tof
+
+#else /* TOFILE */
+
+static void
+__load_verdaux(verdaux_mtype *dst, const verdaux_ftype *src, unsigned enc) {
+    if (enc == ELFDATA2LSB) {
+	dst->vda_name = __load_u32L(src->vda_name);
+	dst->vda_next = __load_u32L(src->vda_next);
+    }
+    else {
+	dst->vda_name = __load_u32M(src->vda_name);
+	dst->vda_next = __load_u32M(src->vda_next);
+    }
+}
+
+static void
+__load_verdef(verdef_mtype *dst, const verdef_ftype *src, unsigned enc) {
+    if (enc == ELFDATA2LSB) {
+	dst->vd_version = __load_u16L(src->vd_version);
+	dst->vd_flags   = __load_u16L(src->vd_flags);
+	dst->vd_ndx     = __load_u16L(src->vd_ndx);
+	dst->vd_cnt     = __load_u16L(src->vd_cnt);
+	dst->vd_hash    = __load_u32L(src->vd_hash);
+	dst->vd_aux     = __load_u32L(src->vd_aux);
+	dst->vd_next    = __load_u32L(src->vd_next);
+    }
+    else {
+	dst->vd_version = __load_u16M(src->vd_version);
+	dst->vd_flags   = __load_u16M(src->vd_flags);
+	dst->vd_ndx     = __load_u16M(src->vd_ndx);
+	dst->vd_cnt     = __load_u16M(src->vd_cnt);
+	dst->vd_hash    = __load_u32M(src->vd_hash);
+	dst->vd_aux     = __load_u32M(src->vd_aux);
+	dst->vd_next    = __load_u32M(src->vd_next);
+    }
+}
+
+typedef verdaux_ftype		verdaux_stype;
+typedef verdaux_mtype		verdaux_dtype;
+typedef verdef_ftype		verdef_stype;
+typedef verdef_mtype		verdef_dtype;
+typedef align_ftype		verdef_atype;
+
+#define copy_verdaux_srctotmp(d, s, e)	__load_verdaux((d), (s), (e))
+#define copy_verdaux_tmptodst(d, s, e)	(*(d) = *(s))
+#define copy_verdef_srctotmp(d, s, e)	__load_verdef((d), (s), (e))
+#define copy_verdef_tmptodst(d, s, e)	(*(d) = *(s))
+
+#define translator_suffix	_tom
+
+#endif /* TOFILE */
+
+#define cat3(a,b,c)	a##b##c
+#define xlt3(p,e,s)	cat3(p,e,s)
+#define xltprefix(x)	xlt3(x,_,class_suffix)
+#define translator(x,e)	xlt3(xltprefix(_elf_##x),e,translator_suffix)
+
+static size_t
+xlt_verdef(unsigned char *dst, const unsigned char *src, size_t n, unsigned enc) {
+    size_t off;
+
+    if (sizeof(verdef_stype) != sizeof(verdef_dtype)
+     || sizeof(verdaux_stype) != sizeof(verdaux_dtype)) {
+	/* never happens for ELF v1 and Verneed v1 */
+	seterr(ERROR_UNIMPLEMENTED);
+	return (size_t)-1;
+    }
+    /* size translation shortcut */
+    if (dst == NULL) {
+	return n;
+    }
+    if (src == NULL) {
+	seterr(ERROR_NULLBUF);
+	return (size_t)-1;
+    }
+    off = 0;
+    while (off + sizeof(verdef_stype) <= n) {
+	const verdef_stype *svd;
+	verdef_dtype *dvd;
+	verdef_mtype vd;
+	size_t acount;
+	size_t aoff;
+
+	/*
+	 * check for proper alignment
+	 */
+	if (off % sizeof(verdef_atype)) {
+	    seterr(ERROR_VERDEF_FORMAT);
+	    return (size_t)-1;
+	}
+	/*
+	 * copy and check src
+	 */
+	svd = (verdef_stype*)(src + off);
+	dvd = (verdef_dtype*)(dst + off);
+	copy_verdef_srctotmp(&vd, svd, enc);
+	if (vd.vd_version < 1
+	 || vd.vd_version > VER_DEF_CURRENT) {
+	    seterr(ERROR_VERDEF_VERSION);
+	    return (size_t)-1;
+	}
+	if (vd.vd_cnt < 1
+	 || vd.vd_aux == 0) {
+	    seterr(ERROR_VERDEF_FORMAT);
+	    return (size_t)-1;
+	}
+	copy_verdef_tmptodst(dvd, &vd, enc);
+	/*
+	 * copy aux array
+	 */
+	aoff = off + vd.vd_aux;
+	for (acount = 0; acount < vd.vd_cnt; acount++) {
+	    const verdaux_stype *svda;
+	    verdaux_dtype *dvda;
+	    verdaux_mtype vda;
+
+	    /*
+	     * are we still inside the buffer limits?
+	     */
+	    if (aoff + sizeof(verdaux_stype) > n) {
+		break;
+	    }
+	    /*
+	     * check for proper alignment
+	     */
+	    if (aoff % sizeof(verdef_atype)) {
+		seterr(ERROR_VERDEF_FORMAT);
+		return (size_t)-1;
+	    }
+	    /*
+	     * copy and check src
+	     */
+	    svda = (verdaux_stype*)(src + aoff);
+	    dvda = (verdaux_dtype*)(dst + aoff);
+	    copy_verdaux_srctotmp(&vda, svda, enc);
+	    copy_verdaux_tmptodst(dvda, &vda, enc);
+	    /*
+	     * advance to next verdaux
+	     */
+	    if (vda.vda_next == 0) {
+		/* end of list */
+		break;
+	    }
+	    aoff += vda.vda_next;
+	}
+	/*
+	 * advance to next verdef
+	 */
+	if (vd.vd_next == 0) {
+	    /* end of list */
+	    break;
+	}
+	off += vd.vd_next;
+    }
+    return n;
+}
+
+size_t
+translator(verdef,L11)(unsigned char *dst, const unsigned char *src, size_t n) {
+    return xlt_verdef(dst, src, n, ELFDATA2LSB);
+}
+
+size_t
+translator(verdef,M11)(unsigned char *dst, const unsigned char *src, size_t n) {
+    return xlt_verdef(dst, src, n, ELFDATA2MSB);
+}

external/libelf/src/verdef_32_tof.c

@@ -0,0 +1,53 @@
+/*
+verdef_32_tof.c - copy 32-bit versioning information.
+Copyright (C) 2001 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+#include <ext_types.h>
+#include <byteswap.h>
+
+#if __LIBELF_SYMBOL_VERSIONS
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: verdef_32_tof.c,v 1.5 2008/05/23 08:15:35 michael Exp $";
+#endif /* lint */
+
+typedef Elf32_Verdaux		verdaux_mtype;
+typedef Elf32_Verdef		verdef_mtype;
+typedef Elf32_Vernaux		vernaux_mtype;
+typedef Elf32_Verneed		verneed_mtype;
+typedef Elf32_Word		align_mtype;
+
+typedef __ext_Elf32_Verdaux	verdaux_ftype;
+typedef __ext_Elf32_Verdef	verdef_ftype;
+typedef __ext_Elf32_Vernaux	vernaux_ftype;
+typedef __ext_Elf32_Verneed	verneed_ftype;
+typedef __ext_Elf32_Word	align_ftype;
+
+#define class_suffix		32
+
+#undef TOFILE
+#define TOFILE 1
+
+/*
+ * Include shared code
+ */
+#include "verdef.h"
+#include "verneed.h"
+
+#endif /* __LIBELF_SYMBOL_VERSIONS */

external/libelf/src/verdef_32_tom.c

@@ -0,0 +1,53 @@
+/*
+verdef_32_tom.c - copy 32-bit versioning information.
+Copyright (C) 2001 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+#include <ext_types.h>
+#include <byteswap.h>
+
+#if __LIBELF_SYMBOL_VERSIONS
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: verdef_32_tom.c,v 1.5 2008/05/23 08:15:35 michael Exp $";
+#endif /* lint */
+
+typedef Elf32_Verdaux		verdaux_mtype;
+typedef Elf32_Verdef		verdef_mtype;
+typedef Elf32_Vernaux		vernaux_mtype;
+typedef Elf32_Verneed		verneed_mtype;
+typedef Elf32_Word		align_mtype;
+
+typedef __ext_Elf32_Verdaux	verdaux_ftype;
+typedef __ext_Elf32_Verdef	verdef_ftype;
+typedef __ext_Elf32_Vernaux	vernaux_ftype;
+typedef __ext_Elf32_Verneed	verneed_ftype;
+typedef __ext_Elf32_Word	align_ftype;
+
+#define class_suffix		32
+
+#undef TOFILE
+#define TOFILE 0
+
+/*
+ * Include shared code
+ */
+#include "verdef.h"
+#include "verneed.h"
+
+#endif /* __LIBELF_SYMBOL_VERSIONS */

external/libelf/src/verdef_64_tof.c

@@ -0,0 +1,53 @@
+/*
+verdef_64_tof.c - copy 64-bit versioning information.
+Copyright (C) 2001 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+#include <ext_types.h>
+#include <byteswap.h>
+
+#if __LIBELF64 && __LIBELF_SYMBOL_VERSIONS
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: verdef_64_tof.c,v 1.5 2008/05/23 08:15:35 michael Exp $";
+#endif /* lint */
+
+typedef Elf64_Verdaux		verdaux_mtype;
+typedef Elf64_Verdef		verdef_mtype;
+typedef Elf64_Vernaux		vernaux_mtype;
+typedef Elf64_Verneed		verneed_mtype;
+typedef Elf64_Word		align_mtype;
+
+typedef __ext_Elf64_Verdaux	verdaux_ftype;
+typedef __ext_Elf64_Verdef	verdef_ftype;
+typedef __ext_Elf64_Vernaux	vernaux_ftype;
+typedef __ext_Elf64_Verneed	verneed_ftype;
+typedef __ext_Elf64_Word	align_ftype;
+
+#define class_suffix		64
+
+#undef TOFILE
+#define TOFILE 1
+
+/*
+ * Include shared code
+ */
+#include "verdef.h"
+#include "verneed.h"
+
+#endif /* __LIBELF64 && __LIBELF_SYMBOL_VERSIONS */

external/libelf/src/verdef_64_tom.c

@@ -0,0 +1,53 @@
+/*
+verdef_64_tom.c - copy 64-bit versioning information.
+Copyright (C) 2001 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+#include <ext_types.h>
+#include <byteswap.h>
+
+#if __LIBELF64 && __LIBELF_SYMBOL_VERSIONS
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: verdef_64_tom.c,v 1.5 2008/05/23 08:15:35 michael Exp $";
+#endif /* lint */
+
+typedef Elf64_Verdaux		verdaux_mtype;
+typedef Elf64_Verdef		verdef_mtype;
+typedef Elf64_Vernaux		vernaux_mtype;
+typedef Elf64_Verneed		verneed_mtype;
+typedef Elf64_Word		align_mtype;
+
+typedef __ext_Elf64_Verdaux	verdaux_ftype;
+typedef __ext_Elf64_Verdef	verdef_ftype;
+typedef __ext_Elf64_Vernaux	vernaux_ftype;
+typedef __ext_Elf64_Verneed	verneed_ftype;
+typedef __ext_Elf64_Word	align_ftype;
+
+#define class_suffix		64
+
+#undef TOFILE
+#define TOFILE 0
+
+/*
+ * Include shared code
+ */
+#include "verdef.h"
+#include "verneed.h"
+
+#endif /* __LIBELF64 && __LIBELF_SYMBOL_VERSIONS */

external/libelf/src/verneed.h

@@ -0,0 +1,245 @@
+/*
+ * verneed.h - copy versioning information.
+ * Copyright (C) 2001 - 2006 Michael Riepe
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#ifndef lint
+static const char verneed_h_rcsid[] = "@(#) $Id: verneed.h,v 1.13 2008/05/23 08:15:35 michael Exp $";
+#endif /* lint */
+
+#if VER_NEED_CURRENT != 1
+#error libelf currently does not support VER_NEED_CURRENT != 1
+#endif /* VER_NEED_CURRENT != 1 */
+
+#if TOFILE
+
+static void
+__store_vernaux(vernaux_ftype *dst, const vernaux_mtype *src, unsigned enc) {
+    if (enc == ELFDATA2LSB) {
+	__store_u32L(dst->vna_hash,  src->vna_hash);
+	__store_u16L(dst->vna_flags, src->vna_flags);
+	__store_u16L(dst->vna_other, src->vna_other);
+	__store_u32L(dst->vna_name,  src->vna_name);
+	__store_u32L(dst->vna_next,  src->vna_next);
+    }
+    else {
+	__store_u32M(dst->vna_hash,  src->vna_hash);
+	__store_u16M(dst->vna_flags, src->vna_flags);
+	__store_u16M(dst->vna_other, src->vna_other);
+	__store_u32M(dst->vna_name,  src->vna_name);
+	__store_u32M(dst->vna_next,  src->vna_next);
+    }
+}
+
+static void
+__store_verneed(verneed_ftype *dst, const verneed_mtype *src, unsigned enc) {
+    if (enc == ELFDATA2LSB) {
+	__store_u16L(dst->vn_version, src->vn_version);
+	__store_u16L(dst->vn_cnt,     src->vn_cnt);
+	__store_u32L(dst->vn_file,    src->vn_file);
+	__store_u32L(dst->vn_aux,     src->vn_aux);
+	__store_u32L(dst->vn_next,    src->vn_next);
+    }
+    else {
+	__store_u16M(dst->vn_version, src->vn_version);
+	__store_u16M(dst->vn_cnt,     src->vn_cnt);
+	__store_u32M(dst->vn_file,    src->vn_file);
+	__store_u32M(dst->vn_aux,     src->vn_aux);
+	__store_u32M(dst->vn_next,    src->vn_next);
+    }
+}
+
+typedef vernaux_mtype		vernaux_stype;
+typedef vernaux_ftype		vernaux_dtype;
+typedef verneed_mtype		verneed_stype;
+typedef verneed_ftype		verneed_dtype;
+typedef align_mtype		verneed_atype;
+
+#define copy_vernaux_srctotmp(d, s, e)	(*(d) = *(s))
+#define copy_vernaux_tmptodst(d, s, e)	__store_vernaux((d), (s), (e))
+#define copy_verneed_srctotmp(d, s, e)	(*(d) = *(s))
+#define copy_verneed_tmptodst(d, s, e)	__store_verneed((d), (s), (e))
+
+#define translator_suffix	_tof
+
+#else /* TOFILE */
+
+static void
+__load_vernaux(vernaux_mtype *dst, const vernaux_ftype *src, unsigned enc) {
+    if (enc == ELFDATA2LSB) {
+	dst->vna_hash  = __load_u32L(src->vna_hash);
+	dst->vna_flags = __load_u16L(src->vna_flags);
+	dst->vna_other = __load_u16L(src->vna_other);
+	dst->vna_name  = __load_u32L(src->vna_name);
+	dst->vna_next  = __load_u32L(src->vna_next);
+    }
+    else {
+	dst->vna_hash  = __load_u32M(src->vna_hash);
+	dst->vna_flags = __load_u16M(src->vna_flags);
+	dst->vna_other = __load_u16M(src->vna_other);
+	dst->vna_name  = __load_u32M(src->vna_name);
+	dst->vna_next  = __load_u32M(src->vna_next);
+    }
+}
+
+static void
+__load_verneed(verneed_mtype *dst, const verneed_ftype *src, unsigned enc) {
+    if (enc == ELFDATA2LSB) {
+	dst->vn_version = __load_u16L(src->vn_version);
+	dst->vn_cnt     = __load_u16L(src->vn_cnt);
+	dst->vn_file    = __load_u32L(src->vn_file);
+	dst->vn_aux     = __load_u32L(src->vn_aux);
+	dst->vn_next    = __load_u32L(src->vn_next);
+    }
+    else {
+	dst->vn_version = __load_u16M(src->vn_version);
+	dst->vn_cnt     = __load_u16M(src->vn_cnt);
+	dst->vn_file    = __load_u32M(src->vn_file);
+	dst->vn_aux     = __load_u32M(src->vn_aux);
+	dst->vn_next    = __load_u32M(src->vn_next);
+    }
+}
+
+typedef vernaux_ftype		vernaux_stype;
+typedef vernaux_mtype		vernaux_dtype;
+typedef verneed_ftype		verneed_stype;
+typedef verneed_mtype		verneed_dtype;
+typedef align_ftype		verneed_atype;
+
+#define copy_vernaux_srctotmp(d, s, e)	__load_vernaux((d), (s), (e))
+#define copy_vernaux_tmptodst(d, s, e)	(*(d) = *(s))
+#define copy_verneed_srctotmp(d, s, e)	__load_verneed((d), (s), (e))
+#define copy_verneed_tmptodst(d, s, e)	(*(d) = *(s))
+
+#define translator_suffix	_tom
+
+#endif /* TOFILE */
+
+#define cat3(a,b,c)	a##b##c
+#define xlt3(p,e,s)	cat3(p,e,s)
+#define xltprefix(x)	xlt3(x,_,class_suffix)
+#define translator(x,e)	xlt3(xltprefix(_elf_##x),e,translator_suffix)
+
+static size_t
+xlt_verneed(unsigned char *dst, const unsigned char *src, size_t n, unsigned enc) {
+    size_t off;
+
+    if (sizeof(verneed_stype) != sizeof(verneed_dtype)
+     || sizeof(vernaux_stype) != sizeof(vernaux_dtype)) {
+	/* never happens for ELF v1 and Verneed v1 */
+	seterr(ERROR_UNIMPLEMENTED);
+	return (size_t)-1;
+    }
+    /* size translation shortcut */
+    if (dst == NULL) {
+	return n;
+    }
+    if (src == NULL) {
+	seterr(ERROR_NULLBUF);
+	return (size_t)-1;
+    }
+    off = 0;
+    while (off + sizeof(verneed_stype) <= n) {
+	const verneed_stype *svn;
+	verneed_dtype *dvn;
+	verneed_mtype vn;
+	size_t acount;
+	size_t aoff;
+
+	/*
+	 * check for proper alignment
+	 */
+	if (off % sizeof(verneed_atype)) {
+	    seterr(ERROR_VERNEED_FORMAT);
+	    return (size_t)-1;
+	}
+	/*
+	 * copy and check src
+	 */
+	svn = (verneed_stype*)(src + off);
+	dvn = (verneed_dtype*)(dst + off);
+	copy_verneed_srctotmp(&vn, svn, enc);
+	if (vn.vn_version < 1
+	 || vn.vn_version > VER_NEED_CURRENT) {
+	    seterr(ERROR_VERNEED_VERSION);
+	    return (size_t)-1;
+	}
+	if (vn.vn_cnt < 1
+	 || vn.vn_aux == 0) {
+	    seterr(ERROR_VERNEED_FORMAT);
+	    return (size_t)-1;
+	}
+	copy_verneed_tmptodst(dvn, &vn, enc);
+	/*
+	 * copy aux array
+	 */
+	aoff = off + vn.vn_aux;
+	for (acount = 0; acount < vn.vn_cnt; acount++) {
+	    const vernaux_stype *svna;
+	    vernaux_dtype *dvna;
+	    vernaux_mtype vna;
+
+	    /*
+	     * are we still inside the buffer limits?
+	     */
+	    if (aoff + sizeof(vernaux_stype) > n) {
+		break;
+	    }
+	    /*
+	     * check for proper alignment
+	     */
+	    if (aoff % sizeof(verneed_atype)) {
+		seterr(ERROR_VERNEED_FORMAT);
+		return (size_t)-1;
+	    }
+	    /*
+	     * copy and check src
+	     */
+	    svna = (vernaux_stype*)(src + aoff);
+	    dvna = (vernaux_dtype*)(dst + aoff);
+	    copy_vernaux_srctotmp(&vna, svna, enc);
+	    copy_vernaux_tmptodst(dvna, &vna, enc);
+	    /*
+	     * advance to next vernaux
+	     */
+	    if (vna.vna_next == 0) {
+		/* end of list */
+		break;
+	    }
+	    aoff += vna.vna_next;
+	}
+	/*
+	 * advance to next verneed
+	 */
+	if (vn.vn_next == 0) {
+	    /* end of list */
+	    break;
+	}
+	off += vn.vn_next;
+    }
+    return n;
+}
+
+size_t
+translator(verneed,L11)(unsigned char *dst, const unsigned char *src, size_t n) {
+    return xlt_verneed(dst, src, n, ELFDATA2LSB);
+}
+
+size_t
+translator(verneed,M11)(unsigned char *dst, const unsigned char *src, size_t n) {
+    return xlt_verneed(dst, src, n, ELFDATA2MSB);
+}

external/libelf/src/version.c

@@ -0,0 +1,44 @@
+/*
+ * version.c - implementation of the elf_version(3) function.
+ * Copyright (C) 1995 - 1998, 2007 Michael Riepe
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: version.c,v 1.8 2008/05/23 08:15:35 michael Exp $";
+#endif /* lint */
+
+unsigned
+elf_version(unsigned ver) {
+    const char *s;
+    unsigned tmp;
+
+    if ((s = getenv("LIBELF_SANITY_CHECKS"))) {
+	_elf_sanity_checks = (int)strtol(s, (char**)NULL, 0);
+    }
+    if (ver == EV_NONE) {
+	return EV_CURRENT;
+    }
+    if (!valid_version(ver)) {
+	seterr(ERROR_UNKNOWN_VERSION);
+	return EV_NONE;
+    }
+    tmp = _elf_version == EV_NONE ? EV_CURRENT : _elf_version;
+    _elf_version = ver;
+    return tmp;
+}

external/libelf/src/x.elfext.c

@@ -0,0 +1,190 @@
+/*
+ * x.elfext.c -- handle ELF format extensions
+ * Copyright (C) 2002 - 2006 Michael Riepe
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: x.elfext.c,v 1.5 2009/07/07 17:57:43 michael Exp $";
+#endif /* lint */
+
+int
+elf_getphdrnum(Elf *elf, size_t *resultp) {
+    if (!elf) {
+	return -1;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if (elf->e_kind != ELF_K_ELF) {
+	seterr(ERROR_NOTELF);
+	return -1;
+    }
+    if (!elf->e_ehdr && !_elf_cook(elf)) {
+	return -1;
+    }
+    if (resultp) {
+	*resultp = elf->e_phnum;
+    }
+    return 0;
+}
+
+int
+elf_getshdrnum(Elf *elf, size_t *resultp) {
+    size_t num = 0;
+    Elf_Scn *scn;
+
+    if (!elf) {
+	return -1;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if (elf->e_kind != ELF_K_ELF) {
+	seterr(ERROR_NOTELF);
+	return -1;
+    }
+    if (!elf->e_ehdr && !_elf_cook(elf)) {
+	return -1;
+    }
+    if ((scn = elf->e_scn_n)) {
+	num = scn->s_index + 1;
+    }
+    if (resultp) {
+	*resultp = num;
+    }
+    return 0;
+}
+
+int
+elf_getshdrstrndx(Elf *elf, size_t *resultp) {
+    size_t num = 0;
+    size_t dummy;
+    Elf_Scn *scn;
+
+    if (!elf) {
+	return -1;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if (resultp == NULL) {
+	resultp = &dummy;	/* handle NULL pointer gracefully */
+    }
+    if (elf->e_kind != ELF_K_ELF) {
+	seterr(ERROR_NOTELF);
+	return -1;
+    }
+    if (!elf->e_ehdr && !_elf_cook(elf)) {
+	return -1;
+    }
+    if (elf->e_class == ELFCLASS32) {
+	num = ((Elf32_Ehdr*)elf->e_ehdr)->e_shstrndx;
+    }
+#if __LIBELF64
+    else if (elf->e_class == ELFCLASS64) {
+	num = ((Elf64_Ehdr*)elf->e_ehdr)->e_shstrndx;
+    }
+#endif /* __LIBELF64 */
+    else {
+	if (valid_class(elf->e_class)) {
+	    seterr(ERROR_UNIMPLEMENTED);
+	}
+	else {
+	    seterr(ERROR_UNKNOWN_CLASS);
+	}
+	return -1;
+    }
+    if (num != SHN_XINDEX) {
+	*resultp = num;
+	return 0;
+    }
+    /*
+     * look at first section header
+     */
+    if (!(scn = elf->e_scn_1)) {
+	seterr(ERROR_NOSUCHSCN);
+	return -1;
+    }
+    elf_assert(scn->s_magic == SCN_MAGIC);
+#if __LIBELF64
+    if (elf->e_class == ELFCLASS64) {
+	*resultp = scn->s_shdr64.sh_link;
+	return 0;
+    }
+#endif /* __LIBELF64 */
+    *resultp = scn->s_shdr32.sh_link;
+    return 0;
+}
+
+int
+elf_getphnum(Elf *elf, size_t *resultp) {
+    return elf_getphdrnum(elf, resultp) ? LIBELF_FAILURE : LIBELF_SUCCESS;
+}
+
+int
+elf_getshnum(Elf *elf, size_t *resultp) {
+    return elf_getshdrnum(elf, resultp) ? LIBELF_FAILURE : LIBELF_SUCCESS;
+}
+
+int
+elf_getshstrndx(Elf *elf, size_t *resultp) {
+    return elf_getshdrstrndx(elf, resultp) ? LIBELF_FAILURE : LIBELF_SUCCESS;
+}
+
+int
+elfx_update_shstrndx(Elf *elf, size_t value) {
+    size_t extvalue = 0;
+    Elf_Scn *scn;
+
+    if (!elf) {
+	return LIBELF_FAILURE;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if (value >= SHN_LORESERVE) {
+	extvalue = value;
+	value = SHN_XINDEX;
+    }
+    if (elf->e_kind != ELF_K_ELF) {
+	seterr(ERROR_NOTELF);
+	return LIBELF_FAILURE;
+    }
+    if (!elf->e_ehdr && !_elf_cook(elf)) {
+	return LIBELF_FAILURE;
+    }
+    if (!(scn = _elf_first_scn(elf))) {
+	return LIBELF_FAILURE;
+    }
+    elf_assert(scn->s_magic == SCN_MAGIC);
+    if (elf->e_class == ELFCLASS32) {
+	((Elf32_Ehdr*)elf->e_ehdr)->e_shstrndx = value;
+	scn->s_shdr32.sh_link = extvalue;
+    }
+#if __LIBELF64
+    else if (elf->e_class == ELFCLASS64) {
+	((Elf64_Ehdr*)elf->e_ehdr)->e_shstrndx = value;
+	scn->s_shdr64.sh_link = extvalue;
+    }
+#endif /* __LIBELF64 */
+    else {
+	if (valid_class(elf->e_class)) {
+	    seterr(ERROR_UNIMPLEMENTED);
+	}
+	else {
+	    seterr(ERROR_UNKNOWN_CLASS);
+	}
+	return LIBELF_FAILURE;
+    }
+    elf->e_ehdr_flags |= ELF_F_DIRTY;
+    scn->s_shdr_flags |= ELF_F_DIRTY;
+    return LIBELF_SUCCESS;
+}

external/libelf/src/x.movscn.c

@@ -0,0 +1,112 @@
+/*
+x.movscn.c - implementation of the elfx_movscn(3) function.
+Copyright (C) 1995 - 2001, 2003 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: x.movscn.c,v 1.14 2008/05/23 08:15:35 michael Exp $";
+#endif /* lint */
+
+size_t
+elfx_movscn(Elf *elf, Elf_Scn *scn, Elf_Scn *after) {
+    Elf_Scn *prev;
+    Elf_Scn *tmp;
+    int off;
+
+    if (!elf || !scn || !after) {
+	return SHN_UNDEF;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if (elf->e_kind != ELF_K_ELF) {
+	seterr(ERROR_NOTELF);
+	return SHN_UNDEF;
+    }
+    elf_assert(scn->s_magic == SCN_MAGIC);
+    elf_assert(after->s_magic == SCN_MAGIC);
+    if (scn->s_elf != elf || after->s_elf != elf) {
+	seterr(ERROR_ELFSCNMISMATCH);
+	return SHN_UNDEF;
+    }
+    elf_assert(elf->e_scn_1);
+    if (scn == elf->e_scn_1) {
+	seterr(ERROR_NULLSCN);
+	return SHN_UNDEF;
+    }
+    if (scn == after || scn == after->s_link) {
+	/* nothing to do */
+	return scn->s_index;
+    }
+
+    /*
+     * Find previous section.
+     */
+    prev = NULL;
+    for (tmp = elf->e_scn_1; tmp->s_link; tmp = tmp->s_link) {
+	if (tmp->s_link == scn) {
+	    prev = tmp;
+	    break;
+	}
+    }
+    elf_assert(prev != NULL);
+
+    /*
+     * Update section indices
+     */
+    off = 0;
+    for (tmp = elf->e_scn_1; tmp; tmp = tmp->s_link) {
+	if (off) {
+	    tmp->s_index += off;
+	}
+	if (tmp == after) {
+	    off++;
+	}
+	else if (tmp == scn) {
+	    off--;
+	}
+    }
+    elf_assert(off == 0);
+
+    /*
+     * Move section.
+     */
+    prev->s_link = scn->s_link;
+    scn->s_link = after->s_link;
+    after->s_link = scn;
+    scn->s_index = after->s_index + 1;
+    if (elf->e_scn_n == scn) {
+	elf->e_scn_n = prev;
+    }
+    else if (elf->e_scn_n == after) {
+	elf->e_scn_n = scn;
+    }
+
+#if ENABLE_DEBUG
+    /*
+     * Check section indices
+     */
+    tmp = elf->e_scn_1;
+    elf_assert(tmp->s_index == 0);
+    while (tmp->s_link) {
+	elf_assert(tmp->s_link->s_index == tmp->s_index + 1);
+	tmp = tmp->s_link;
+    }
+#endif /* ENABLE_DEBUG */
+
+    return scn->s_index;
+}

external/libelf/src/x.remscn.c

@@ -0,0 +1,119 @@
+/*
+x.remscn.c - implementation of the elfx_remscn(3) function.
+Copyright (C) 1995 - 2001, 2003 Michael Riepe
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include <private.h>
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: x.remscn.c,v 1.15 2008/05/23 08:15:35 michael Exp $";
+#endif /* lint */
+
+size_t
+elfx_remscn(Elf *elf, Elf_Scn *scn) {
+    Elf_Scn *pscn;
+    Scn_Data *sd;
+    Scn_Data *tmp;
+    size_t index;
+
+    if (!elf || !scn) {
+	return SHN_UNDEF;
+    }
+    elf_assert(elf->e_magic == ELF_MAGIC);
+    if (elf->e_kind != ELF_K_ELF) {
+	seterr(ERROR_NOTELF);
+	return SHN_UNDEF;
+    }
+    elf_assert(scn->s_magic == SCN_MAGIC);
+    elf_assert(elf->e_ehdr);
+    if (scn->s_elf != elf) {
+	seterr(ERROR_ELFSCNMISMATCH);
+	return SHN_UNDEF;
+    }
+    elf_assert(elf->e_scn_1);
+    if (scn == elf->e_scn_1) {
+	seterr(ERROR_NULLSCN);
+	return SHN_UNDEF;
+    }
+
+    /*
+     * Find previous section.
+     */
+    for (pscn = elf->e_scn_1; pscn->s_link; pscn = pscn->s_link) {
+	if (pscn->s_link == scn) {
+	    break;
+	}
+    }
+    if (pscn->s_link != scn) {
+	seterr(ERROR_ELFSCNMISMATCH);
+	return SHN_UNDEF;
+    }
+
+    /*
+     * Unlink section.
+     */
+    if (elf->e_scn_n == scn) {
+	elf->e_scn_n = pscn;
+    }
+    pscn->s_link = scn->s_link;
+    index = scn->s_index;
+
+    /*
+     * Free section descriptor and data.
+     */
+    for (sd = scn->s_data_1; sd; sd = tmp) {
+	elf_assert(sd->sd_magic == DATA_MAGIC);
+	elf_assert(sd->sd_scn == scn);
+	tmp = sd->sd_link;
+	if (sd->sd_free_data && sd->sd_memdata) {
+	    free(sd->sd_memdata);
+	}
+	if (sd->sd_freeme) {
+	    free(sd);
+	}
+    }
+    if ((sd = scn->s_rawdata)) {
+	elf_assert(sd->sd_magic == DATA_MAGIC);
+	elf_assert(sd->sd_scn == scn);
+	if (sd->sd_free_data && sd->sd_memdata) {
+	    free(sd->sd_memdata);
+	}
+	if (sd->sd_freeme) {
+	    free(sd);
+	}
+    }
+    if (scn->s_freeme) {
+	elf_assert(scn->s_index > 0);
+	free(scn);
+    }
+
+    /*
+     * Adjust section indices.
+     */
+    for (scn = pscn->s_link; scn; scn = scn->s_link) {
+	elf_assert(scn->s_index > index);
+	scn->s_index--;
+    }
+
+    /*
+     * Adjust section count in ELF header
+     */
+    if (_elf_update_shnum(elf, elf->e_scn_n->s_index + 1)) {
+	return SHN_UNDEF;
+    }
+    return index;
+}