ext: Revert "ext: remove libelf"
authorHoa Nguyen <hoanguyen@ucdavis.edu>
Wed, 2 Sep 2020 00:30:46 +0000 (17:30 -0700)
committerHoa Nguyen <hoanguyen@ucdavis.edu>
Wed, 2 Sep 2020 20:36:14 +0000 (20:36 +0000)
This reverts commit fa13042b5a1b4120bb7d96d15170bbd5d5068fad,
which removes ext/libelf.

Signed-off-by: Hoa Nguyen <hoanguyen@ucdavis.edu>
Change-Id: Id0ffb480fa5f5fe8faa4816d367b580ebe4c38d7
Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/33939
Reviewed-by: Gabe Black <gabeblack@google.com>
Maintainer: Gabe Black <gabeblack@google.com>
Tested-by: kokoro <noreply+kokoro@google.com>
59 files changed:
ext/libelf/_libelf.h [new file with mode: 0644]
ext/libelf/elf32.h [new file with mode: 0644]
ext/libelf/elf64.h [new file with mode: 0644]
ext/libelf/elf_begin.c [new file with mode: 0644]
ext/libelf/elf_cntl.c [new file with mode: 0644]
ext/libelf/elf_common.h [new file with mode: 0644]
ext/libelf/elf_data.c [new file with mode: 0644]
ext/libelf/elf_end.c [new file with mode: 0644]
ext/libelf/elf_errmsg.c [new file with mode: 0644]
ext/libelf/elf_errno.c [new file with mode: 0644]
ext/libelf/elf_fill.c [new file with mode: 0644]
ext/libelf/elf_flag.c [new file with mode: 0644]
ext/libelf/elf_getarhdr.c [new file with mode: 0644]
ext/libelf/elf_getarsym.c [new file with mode: 0644]
ext/libelf/elf_getbase.c [new file with mode: 0644]
ext/libelf/elf_getident.c [new file with mode: 0644]
ext/libelf/elf_hash.c [new file with mode: 0644]
ext/libelf/elf_kind.c [new file with mode: 0644]
ext/libelf/elf_memory.c [new file with mode: 0644]
ext/libelf/elf_next.c [new file with mode: 0644]
ext/libelf/elf_phnum.c [new file with mode: 0644]
ext/libelf/elf_queue.h [new file with mode: 0644]
ext/libelf/elf_rand.c [new file with mode: 0644]
ext/libelf/elf_rawfile.c [new file with mode: 0644]
ext/libelf/elf_scn.c [new file with mode: 0644]
ext/libelf/elf_shnum.c [new file with mode: 0644]
ext/libelf/elf_shstrndx.c [new file with mode: 0644]
ext/libelf/elf_strptr.c [new file with mode: 0644]
ext/libelf/elf_types.m4 [new file with mode: 0644]
ext/libelf/elf_update.c [new file with mode: 0644]
ext/libelf/elf_version.c [new file with mode: 0644]
ext/libelf/gelf.h [new file with mode: 0644]
ext/libelf/gelf_checksum.c [new file with mode: 0644]
ext/libelf/gelf_dyn.c [new file with mode: 0644]
ext/libelf/gelf_ehdr.c [new file with mode: 0644]
ext/libelf/gelf_fsize.c [new file with mode: 0644]
ext/libelf/gelf_getclass.c [new file with mode: 0644]
ext/libelf/gelf_phdr.c [new file with mode: 0644]
ext/libelf/gelf_rel.c [new file with mode: 0644]
ext/libelf/gelf_rela.c [new file with mode: 0644]
ext/libelf/gelf_shdr.c [new file with mode: 0644]
ext/libelf/gelf_sym.c [new file with mode: 0644]
ext/libelf/gelf_symshndx.c [new file with mode: 0644]
ext/libelf/gelf_xlate.c [new file with mode: 0644]
ext/libelf/libelf.c [new file with mode: 0644]
ext/libelf/libelf.h [new file with mode: 0644]
ext/libelf/libelf_align.c [new file with mode: 0644]
ext/libelf/libelf_allocate.c [new file with mode: 0644]
ext/libelf/libelf_ar.c [new file with mode: 0644]
ext/libelf/libelf_checksum.c [new file with mode: 0644]
ext/libelf/libelf_convert.m4 [new file with mode: 0644]
ext/libelf/libelf_data.c [new file with mode: 0644]
ext/libelf/libelf_ehdr.c [new file with mode: 0644]
ext/libelf/libelf_extended.c [new file with mode: 0644]
ext/libelf/libelf_fsize.m4 [new file with mode: 0644]
ext/libelf/libelf_msize.m4 [new file with mode: 0644]
ext/libelf/libelf_phdr.c [new file with mode: 0644]
ext/libelf/libelf_shdr.c [new file with mode: 0644]
ext/libelf/libelf_xlate.c [new file with mode: 0644]

diff --git a/ext/libelf/_libelf.h b/ext/libelf/_libelf.h
new file mode 100644 (file)
index 0000000..f6cec6e
--- /dev/null
@@ -0,0 +1,194 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD: src/lib/libelf/_libelf.h,v 1.2 2006/12/25 02:22:22 jkoshy Exp $
+ */
+
+#ifndef        __LIBELF_H_
+#define        __LIBELF_H_
+
+#include "elf_queue.h"
+#include "libelf.h"
+
+#ifndef        NULL
+#define NULL   ((void *) 0)
+#endif
+
+/*
+ * Library-private data structures.
+ */
+
+#define LIBELF_MSG_SIZE        256
+
+struct _libelf_globals {
+        int            libelf_arch;
+        unsigned int   libelf_byteorder;
+        int            libelf_class;
+        int            libelf_error;
+        int            libelf_fillchar;
+        unsigned int   libelf_version;
+        char           libelf_msg[LIBELF_MSG_SIZE];
+};
+
+struct _libelf_globals *_libelf_private();
+
+#define        LIBELF_PRIVATE(N)       (_libelf_private()->libelf_##N)
+
+#define        LIBELF_ELF_ERROR_MASK   0xFF
+#define        LIBELF_OS_ERROR_SHIFT   8
+
+#define        LIBELF_SET_ERROR(E, O) do {                                     \
+        LIBELF_PRIVATE(error) = ((ELF_E_##E & LIBELF_ELF_ERROR_MASK)|  \
+            ((O) << LIBELF_OS_ERROR_SHIFT));                           \
+        } while (0)
+
+#define        LIBELF_ADJUST_AR_SIZE(S)        (((S) + 1U) & ~1U)
+
+/*
+ * Flags for library internal use.  These use the upper 16 bits of a
+ * flags field.
+ */
+#define        LIBELF_F_MALLOCED       0x010000 /* whether data was malloc'ed */
+#define        LIBELF_F_MMAP           0x020000 /* whether e_rawfile was mmap'ed */
+#define        LIBELF_F_SHDRS_LOADED   0x040000 /* whether all shdrs were read in */
+
+struct _Elf {
+        int            e_activations;  /* activation count */
+        Elf_Arhdr      *e_arhdr;       /* header for archive members */
+        unsigned int   e_byteorder;    /* ELFDATA* */
+        int            e_class;        /* ELFCLASS*  */
+        Elf_Cmd                e_cmd;          /* ELF_C_* used at creation time */
+        int            e_fd;           /* associated file descriptor */
+        unsigned int   e_flags;        /* ELF_F_*, LIBELF_F_* flags */
+        Elf_Kind       e_kind;         /* ELF_K_* */
+        Elf            *e_parent;      /* non-NULL for archive members */
+        char           *e_rawfile;     /* uninterpreted bytes */
+        size_t         e_rawsize;      /* size of uninterpreted bytes */
+        unsigned int   e_version;      /* file version */
+
+        union {
+                struct {               /* ar(1) archives */
+                        off_t  e_next; /* set by elf_rand()/elf_next() */
+                        int    e_nchildren;
+                        char   *e_rawstrtab;   /* file name strings */
+                        size_t e_rawstrtabsz;
+                        char   *e_rawsymtab;   /* symbol table */
+                        size_t e_rawsymtabsz;
+                        Elf_Arsym *e_symtab;
+                        size_t e_symtabsz;
+                } e_ar;
+                struct {               /* regular ELF files */
+                        union {
+                                Elf32_Ehdr *e_ehdr32;
+                                Elf64_Ehdr *e_ehdr64;
+                        } e_ehdr;
+                        union {
+                                Elf32_Phdr *e_phdr32;
+                                Elf64_Phdr *e_phdr64;
+                        } e_phdr;
+                        STAILQ_HEAD(, _Elf_Scn)        e_scn;  /* section list */
+                        size_t e_nphdr;        /* number of Phdr entries */
+                        size_t e_nscn;         /* number of sections */
+                        size_t e_strndx;       /* string table section index */
+                } e_elf;
+        } e_u;
+};
+
+struct _Elf_Scn {
+        union {
+                Elf32_Shdr     s_shdr32;
+                Elf64_Shdr     s_shdr64;
+        } s_shdr;
+        STAILQ_HEAD(, _Elf_Data) s_data;       /* list of Elf_Data descriptors */
+        STAILQ_HEAD(, _Elf_Data) s_rawdata;    /* raw data for this section */
+        STAILQ_ENTRY(_Elf_Scn) s_next;
+        struct _Elf    *s_elf;         /* parent ELF descriptor */
+        unsigned int   s_flags;        /* flags for the section as a whole */
+        size_t         s_ndx;          /* index# for this section */
+        uint64_t       s_offset;       /* managed by elf_update() */
+        uint64_t       s_rawoff;       /* original offset in the file */
+        uint64_t       s_size;         /* managed by elf_update() */
+};
+
+
+enum {
+        ELF_TOFILE,
+        ELF_TOMEMORY
+};
+
+#define        LIBELF_COPY_U32(DST,SRC,NAME)   do {            \
+                if ((SRC)->NAME > UINT_MAX) {          \
+                        LIBELF_SET_ERROR(RANGE, 0);    \
+                        return (0);                    \
+                }                                      \
+                (DST)->NAME = (SRC)->NAME;             \
+        } while (0)
+
+#define        LIBELF_COPY_S32(DST,SRC,NAME)   do {            \
+                if ((SRC)->NAME > INT_MAX ||           \
+                    (SRC)->NAME < INT_MIN) {           \
+                        LIBELF_SET_ERROR(RANGE, 0);    \
+                        return (0);                    \
+                }                                      \
+                (DST)->NAME = (SRC)->NAME;             \
+        } while (0)
+
+
+/*
+ * Prototypes
+ */
+
+Elf_Data *_libelf_allocate_data(Elf_Scn *_s);
+Elf    *_libelf_allocate_elf(void);
+Elf_Scn        *_libelf_allocate_scn(Elf *_e, size_t _ndx);
+Elf_Arhdr *_libelf_ar_gethdr(Elf *_e);
+Elf    *_libelf_ar_open(Elf *_e);
+Elf    *_libelf_ar_open_member(int _fd, Elf_Cmd _c, Elf *_ar);
+Elf_Arsym *_libelf_ar_process_symtab(Elf *_ar, size_t *_dst);
+unsigned long _libelf_checksum(Elf *_e, int _elfclass);
+void   *_libelf_ehdr(Elf *_e, int _elfclass, int _allocate);
+int    _libelf_falign(Elf_Type _t, int _elfclass);
+size_t _libelf_fsize(Elf_Type _t, int _elfclass, unsigned int _version,
+    size_t count);
+void   (*_libelf_get_translator(Elf_Type _t, int _direction, int _elfclass))
+            (char *_dst, char *_src, size_t _cnt, int _byteswap);
+void   *_libelf_getphdr(Elf *_e, int _elfclass);
+void   *_libelf_getshdr(Elf_Scn *_scn, int _elfclass);
+void   _libelf_init_elf(Elf *_e, Elf_Kind _kind);
+int    _libelf_malign(Elf_Type _t, int _elfclass);
+size_t _libelf_msize(Elf_Type _t, int _elfclass, unsigned int _version);
+void   *_libelf_newphdr(Elf *_e, int _elfclass, size_t _count);
+Elf_Data *_libelf_release_data(Elf_Data *_d);
+Elf    *_libelf_release_elf(Elf *_e);
+Elf_Scn        *_libelf_release_scn(Elf_Scn *_s);
+int    _libelf_setphnum(Elf *_e, void *_eh, int _elfclass, size_t _phnum);
+int    _libelf_setshnum(Elf *_e, void *_eh, int _elfclass, size_t _shnum);
+int    _libelf_setshstrndx(Elf *_e, void *_eh, int _elfclass,
+    size_t _shstrndx);
+Elf_Data *_libelf_xlate(Elf_Data *_d, const Elf_Data *_s,
+    unsigned int _encoding, int _elfclass, int _direction);
+int    _libelf_xlate_shtype(uint32_t _sht);
+
+#endif /* __LIBELF_H_ */
diff --git a/ext/libelf/elf32.h b/ext/libelf/elf32.h
new file mode 100644 (file)
index 0000000..d62de50
--- /dev/null
@@ -0,0 +1,245 @@
+/*-
+ * Copyright (c) 1996-1998 John D. Polstra.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD: src/sys/sys/elf32.h,v 1.13 2006/10/17 05:43:30 jkoshy Exp $
+ */
+
+#ifndef _SYS_ELF32_H_
+#define _SYS_ELF32_H_ 1
+
+#include "elf_common.h"
+
+/*
+ * ELF definitions common to all 32-bit architectures.
+ */
+
+typedef uint32_t       Elf32_Addr;
+typedef uint16_t       Elf32_Half;
+typedef uint32_t       Elf32_Off;
+typedef int32_t                Elf32_Sword;
+typedef uint32_t       Elf32_Word;
+typedef uint64_t       Elf32_Lword;
+
+typedef Elf32_Word     Elf32_Hashelt;
+
+/* Non-standard class-dependent datatype used for abstraction. */
+typedef Elf32_Word     Elf32_Size;
+typedef Elf32_Sword    Elf32_Ssize;
+
+/*
+ * ELF header.
+ */
+
+typedef struct {
+        unsigned char  e_ident[EI_NIDENT];     /* File identification. */
+        Elf32_Half     e_type;         /* File type. */
+        Elf32_Half     e_machine;      /* Machine architecture. */
+        Elf32_Word     e_version;      /* ELF format version. */
+        Elf32_Addr     e_entry;        /* Entry point. */
+        Elf32_Off      e_phoff;        /* Program header file offset. */
+        Elf32_Off      e_shoff;        /* Section header file offset. */
+        Elf32_Word     e_flags;        /* Architecture-specific flags. */
+        Elf32_Half     e_ehsize;       /* Size of ELF header in bytes. */
+        Elf32_Half     e_phentsize;    /* Size of program header entry. */
+        Elf32_Half     e_phnum;        /* Number of program header entries. */
+        Elf32_Half     e_shentsize;    /* Size of section header entry. */
+        Elf32_Half     e_shnum;        /* Number of section header entries. */
+        Elf32_Half     e_shstrndx;     /* Section name strings section. */
+} Elf32_Ehdr;
+
+/*
+ * Section header.
+ */
+
+typedef struct {
+        Elf32_Word     sh_name;        /* Section name (index into the
+                                           section header string table). */
+        Elf32_Word     sh_type;        /* Section type. */
+        Elf32_Word     sh_flags;       /* Section flags. */
+        Elf32_Addr     sh_addr;        /* Address in memory image. */
+        Elf32_Off      sh_offset;      /* Offset in file. */
+        Elf32_Word     sh_size;        /* Size in bytes. */
+        Elf32_Word     sh_link;        /* Index of a related section. */
+        Elf32_Word     sh_info;        /* Depends on section type. */
+        Elf32_Word     sh_addralign;   /* Alignment in bytes. */
+        Elf32_Word     sh_entsize;     /* Size of each entry in section. */
+} Elf32_Shdr;
+
+/*
+ * Program header.
+ */
+
+typedef struct {
+        Elf32_Word     p_type;         /* Entry type. */
+        Elf32_Off      p_offset;       /* File offset of contents. */
+        Elf32_Addr     p_vaddr;        /* Virtual address in memory image. */
+        Elf32_Addr     p_paddr;        /* Physical address (not used). */
+        Elf32_Word     p_filesz;       /* Size of contents in file. */
+        Elf32_Word     p_memsz;        /* Size of contents in memory. */
+        Elf32_Word     p_flags;        /* Access permission flags. */
+        Elf32_Word     p_align;        /* Alignment in memory and file. */
+} Elf32_Phdr;
+
+/*
+ * Dynamic structure.  The ".dynamic" section contains an array of them.
+ */
+
+typedef struct {
+        Elf32_Sword    d_tag;          /* Entry type. */
+        union {
+                Elf32_Word     d_val;  /* Integer value. */
+                Elf32_Addr     d_ptr;  /* Address value. */
+        } d_un;
+} Elf32_Dyn;
+
+/*
+ * Relocation entries.
+ */
+
+/* Relocations that don't need an addend field. */
+typedef struct {
+        Elf32_Addr     r_offset;       /* Location to be relocated. */
+        Elf32_Word     r_info;         /* Relocation type and symbol index. */
+} Elf32_Rel;
+
+/* Relocations that need an addend field. */
+typedef struct {
+        Elf32_Addr     r_offset;       /* Location to be relocated. */
+        Elf32_Word     r_info;         /* Relocation type and symbol index. */
+        Elf32_Sword    r_addend;       /* Addend. */
+} Elf32_Rela;
+
+/* Macros for accessing the fields of r_info. */
+#define ELF32_R_SYM(info)      ((info) >> 8)
+#define ELF32_R_TYPE(info)     ((unsigned char)(info))
+
+/* Macro for constructing r_info from field values. */
+#define ELF32_R_INFO(sym, type)        (((sym) << 8) + (unsigned char)(type))
+
+/*
+ *     Note entry header
+ */
+typedef Elf_Note Elf32_Nhdr;
+
+/*
+ *     Move entry
+ */
+typedef struct {
+        Elf32_Lword    m_value;        /* symbol value */
+        Elf32_Word     m_info;         /* size + index */
+        Elf32_Word     m_poffset;      /* symbol offset */
+        Elf32_Half     m_repeat;       /* repeat count */
+        Elf32_Half     m_stride;       /* stride info */
+} Elf32_Move;
+
+/*
+ *     The macros compose and decompose values for Move.r_info
+ *
+ *     sym = ELF32_M_SYM(M.m_info)
+ *     size = ELF32_M_SIZE(M.m_info)
+ *     M.m_info = ELF32_M_INFO(sym, size)
+ */
+#define        ELF32_M_SYM(info)       ((info)>>8)
+#define        ELF32_M_SIZE(info)      ((unsigned char)(info))
+#define        ELF32_M_INFO(sym, size) (((sym)<<8)+(unsigned char)(size))
+
+/*
+ *     Hardware/Software capabilities entry
+ */
+typedef struct {
+        Elf32_Word     c_tag;          /* how to interpret value */
+        union {
+                Elf32_Word     c_val;
+                Elf32_Addr     c_ptr;
+        } c_un;
+} Elf32_Cap;
+
+/*
+ * Symbol table entries.
+ */
+
+typedef struct {
+        Elf32_Word     st_name;        /* String table index of name. */
+        Elf32_Addr     st_value;       /* Symbol value. */
+        Elf32_Word     st_size;        /* Size of associated object. */
+        unsigned char  st_info;        /* Type and binding information. */
+        unsigned char  st_other;       /* Reserved (not used). */
+        Elf32_Half     st_shndx;       /* Section index of symbol. */
+} Elf32_Sym;
+
+/* Macros for accessing the fields of st_info. */
+#define ELF32_ST_BIND(info)            ((info) >> 4)
+#define ELF32_ST_TYPE(info)            ((info) & 0xf)
+
+/* Macro for constructing st_info from field values. */
+#define ELF32_ST_INFO(bind, type)      (((bind) << 4) + ((type) & 0xf))
+
+/* Macro for accessing the fields of st_other. */
+#define ELF32_ST_VISIBILITY(oth)       ((oth) & 0x3)
+
+/* Structures used by Sun & GNU symbol versioning. */
+typedef struct
+{
+        Elf32_Half     vd_version;
+        Elf32_Half     vd_flags;
+        Elf32_Half     vd_ndx;
+        Elf32_Half     vd_cnt;
+        Elf32_Word     vd_hash;
+        Elf32_Word     vd_aux;
+        Elf32_Word     vd_next;
+} Elf32_Verdef;
+
+typedef struct
+{
+        Elf32_Word     vda_name;
+        Elf32_Word     vda_next;
+} Elf32_Verdaux;
+
+typedef struct
+{
+        Elf32_Half     vn_version;
+        Elf32_Half     vn_cnt;
+        Elf32_Word     vn_file;
+        Elf32_Word     vn_aux;
+        Elf32_Word     vn_next;
+} Elf32_Verneed;
+
+typedef struct
+{
+        Elf32_Word     vna_hash;
+        Elf32_Half     vna_flags;
+        Elf32_Half     vna_other;
+        Elf32_Word     vna_name;
+        Elf32_Word     vna_next;
+} Elf32_Vernaux;
+
+typedef Elf32_Half Elf32_Versym;
+
+typedef struct {
+        Elf32_Half     si_boundto;     /* direct bindings - symbol bound to */
+        Elf32_Half     si_flags;       /* per symbol flags */
+} Elf32_Syminfo;
+
+#endif /* !_SYS_ELF32_H_ */
diff --git a/ext/libelf/elf64.h b/ext/libelf/elf64.h
new file mode 100644 (file)
index 0000000..a59f3a0
--- /dev/null
@@ -0,0 +1,248 @@
+/*-
+ * Copyright (c) 1996-1998 John D. Polstra.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD: src/sys/sys/elf64.h,v 1.17 2006/10/17 05:43:30 jkoshy Exp $
+ */
+
+#ifndef _SYS_ELF64_H_
+#define _SYS_ELF64_H_ 1
+
+#include "elf_common.h"
+
+/*
+ * ELF definitions common to all 64-bit architectures.
+ */
+
+typedef uint64_t       Elf64_Addr;
+typedef uint16_t       Elf64_Half;
+typedef uint64_t       Elf64_Off;
+typedef int32_t                Elf64_Sword;
+typedef int64_t                Elf64_Sxword;
+typedef uint32_t       Elf64_Word;
+typedef uint64_t       Elf64_Lword;
+typedef uint64_t       Elf64_Xword;
+
+/*
+ * Types of dynamic symbol hash table bucket and chain elements.
+ *
+ * This is inconsistent among 64 bit architectures, so a machine dependent
+ * typedef is required.
+ */
+
+typedef Elf64_Word     Elf64_Hashelt;
+
+/* Non-standard class-dependent datatype used for abstraction. */
+typedef Elf64_Xword    Elf64_Size;
+typedef Elf64_Sxword   Elf64_Ssize;
+
+/*
+ * ELF header.
+ */
+
+typedef struct {
+        unsigned char  e_ident[EI_NIDENT];     /* File identification. */
+        Elf64_Half     e_type;         /* File type. */
+        Elf64_Half     e_machine;      /* Machine architecture. */
+        Elf64_Word     e_version;      /* ELF format version. */
+        Elf64_Addr     e_entry;        /* Entry point. */
+        Elf64_Off      e_phoff;        /* Program header file offset. */
+        Elf64_Off      e_shoff;        /* Section header file offset. */
+        Elf64_Word     e_flags;        /* Architecture-specific flags. */
+        Elf64_Half     e_ehsize;       /* Size of ELF header in bytes. */
+        Elf64_Half     e_phentsize;    /* Size of program header entry. */
+        Elf64_Half     e_phnum;        /* Number of program header entries. */
+        Elf64_Half     e_shentsize;    /* Size of section header entry. */
+        Elf64_Half     e_shnum;        /* Number of section header entries. */
+        Elf64_Half     e_shstrndx;     /* Section name strings section. */
+} Elf64_Ehdr;
+
+/*
+ * Section header.
+ */
+
+typedef struct {
+        Elf64_Word     sh_name;        /* Section name (index into the
+                                           section header string table). */
+        Elf64_Word     sh_type;        /* Section type. */
+        Elf64_Xword    sh_flags;       /* Section flags. */
+        Elf64_Addr     sh_addr;        /* Address in memory image. */
+        Elf64_Off      sh_offset;      /* Offset in file. */
+        Elf64_Xword    sh_size;        /* Size in bytes. */
+        Elf64_Word     sh_link;        /* Index of a related section. */
+        Elf64_Word     sh_info;        /* Depends on section type. */
+        Elf64_Xword    sh_addralign;   /* Alignment in bytes. */
+        Elf64_Xword    sh_entsize;     /* Size of each entry in section. */
+} Elf64_Shdr;
+
+/*
+ * Program header.
+ */
+
+typedef struct {
+        Elf64_Word     p_type;         /* Entry type. */
+        Elf64_Word     p_flags;        /* Access permission flags. */
+        Elf64_Off      p_offset;       /* File offset of contents. */
+        Elf64_Addr     p_vaddr;        /* Virtual address in memory image. */
+        Elf64_Addr     p_paddr;        /* Physical address (not used). */
+        Elf64_Xword    p_filesz;       /* Size of contents in file. */
+        Elf64_Xword    p_memsz;        /* Size of contents in memory. */
+        Elf64_Xword    p_align;        /* Alignment in memory and file. */
+} Elf64_Phdr;
+
+/*
+ * Dynamic structure.  The ".dynamic" section contains an array of them.
+ */
+
+typedef struct {
+        Elf64_Sxword   d_tag;          /* Entry type. */
+        union {
+                Elf64_Xword    d_val;  /* Integer value. */
+                Elf64_Addr     d_ptr;  /* Address value. */
+        } d_un;
+} Elf64_Dyn;
+
+/*
+ * Relocation entries.
+ */
+
+/* Relocations that don't need an addend field. */
+typedef struct {
+        Elf64_Addr     r_offset;       /* Location to be relocated. */
+        Elf64_Xword    r_info;         /* Relocation type and symbol index. */
+} Elf64_Rel;
+
+/* Relocations that need an addend field. */
+typedef struct {
+        Elf64_Addr     r_offset;       /* Location to be relocated. */
+        Elf64_Xword    r_info;         /* Relocation type and symbol index. */
+        Elf64_Sxword   r_addend;       /* Addend. */
+} Elf64_Rela;
+
+/* Macros for accessing the fields of r_info. */
+#define ELF64_R_SYM(info)      ((info) >> 32)
+#define ELF64_R_TYPE(info)     ((info) & 0xffffffffL)
+
+/* Macro for constructing r_info from field values. */
+#define ELF64_R_INFO(sym, type)        (((sym) << 32) + ((type) & 0xffffffffL))
+
+#define        ELF64_R_TYPE_DATA(info) (((Elf64_Xword)(info)<<32)>>40)
+#define        ELF64_R_TYPE_ID(info)   (((Elf64_Xword)(info)<<56)>>56)
+#define        ELF64_R_TYPE_INFO(data, type)   \
+                (((Elf64_Xword)(data)<<8)+(Elf64_Xword)(type))
+
+/*
+ *     Note entry header
+ */
+typedef Elf_Note Elf64_Nhdr;
+
+/*
+ *     Move entry
+ */
+typedef struct {
+        Elf64_Lword    m_value;        /* symbol value */
+        Elf64_Xword    m_info;         /* size + index */
+        Elf64_Xword    m_poffset;      /* symbol offset */
+        Elf64_Half     m_repeat;       /* repeat count */
+        Elf64_Half     m_stride;       /* stride info */
+} Elf64_Move;
+
+#define        ELF64_M_SYM(info)       ((info)>>8)
+#define        ELF64_M_SIZE(info)      ((unsigned char)(info))
+#define        ELF64_M_INFO(sym, size) (((sym)<<8)+(unsigned char)(size))
+
+/*
+ *     Hardware/Software capabilities entry
+ */
+typedef struct {
+        Elf64_Xword    c_tag;          /* how to interpret value */
+        union {
+                Elf64_Xword    c_val;
+                Elf64_Addr     c_ptr;
+        } c_un;
+} Elf64_Cap;
+
+/*
+ * Symbol table entries.
+ */
+
+typedef struct {
+        Elf64_Word     st_name;        /* String table index of name. */
+        unsigned char  st_info;        /* Type and binding information. */
+        unsigned char  st_other;       /* Reserved (not used). */
+        Elf64_Half     st_shndx;       /* Section index of symbol. */
+        Elf64_Addr     st_value;       /* Symbol value. */
+        Elf64_Xword    st_size;        /* Size of associated object. */
+} Elf64_Sym;
+
+/* Macros for accessing the fields of st_info. */
+#define ELF64_ST_BIND(info)            ((info) >> 4)
+#define ELF64_ST_TYPE(info)            ((info) & 0xf)
+
+/* Macro for constructing st_info from field values. */
+#define ELF64_ST_INFO(bind, type)      (((bind) << 4) + ((type) & 0xf))
+
+/* Macro for accessing the fields of st_other. */
+#define ELF64_ST_VISIBILITY(oth)       ((oth) & 0x3)
+
+/* Structures used by Sun & GNU-style symbol versioning. */
+typedef struct {
+        Elf64_Half     vd_version;
+        Elf64_Half     vd_flags;
+        Elf64_Half     vd_ndx;
+        Elf64_Half     vd_cnt;
+        Elf64_Word     vd_hash;
+        Elf64_Word     vd_aux;
+        Elf64_Word     vd_next;
+} Elf64_Verdef;
+
+typedef struct {
+        Elf64_Word     vda_name;
+        Elf64_Word     vda_next;
+} Elf64_Verdaux;
+
+typedef struct {
+        Elf64_Half     vn_version;
+        Elf64_Half     vn_cnt;
+        Elf64_Word     vn_file;
+        Elf64_Word     vn_aux;
+        Elf64_Word     vn_next;
+} Elf64_Verneed;
+
+typedef struct {
+        Elf64_Word     vna_hash;
+        Elf64_Half     vna_flags;
+        Elf64_Half     vna_other;
+        Elf64_Word     vna_name;
+        Elf64_Word     vna_next;
+} Elf64_Vernaux;
+
+typedef Elf64_Half Elf64_Versym;
+
+typedef struct {
+        Elf64_Half     si_boundto;     /* direct bindings - symbol bound to */
+        Elf64_Half     si_flags;       /* per symbol flags */
+} Elf64_Syminfo;
+
+#endif /* !_SYS_ELF64_H_ */
diff --git a/ext/libelf/elf_begin.c b/ext/libelf/elf_begin.c
new file mode 100644 (file)
index 0000000..1b37aa0
--- /dev/null
@@ -0,0 +1,154 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#include <sys/types.h>
+#include <errno.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+
+#include <ar.h>
+#include <ctype.h>
+#include "libelf.h"
+
+#include "_libelf.h"
+
+static Elf *
+_libelf_open_object(int fd, Elf_Cmd c)
+{
+        Elf *e;
+        void *m;
+        struct stat sb;
+
+        /*
+         * 'Raw' files are always mapped with 'PROT_READ'.  At
+         * elf_update(3) time for files opened with ELF_C_RDWR the
+         * mapping is unmapped, file data is written to using write(2)
+         * and then the raw data is immediately mapped back in.
+         */
+        if (fstat(fd, &sb) < 0) {
+                LIBELF_SET_ERROR(IO, errno);
+                return (NULL);
+        }
+
+        m = NULL;
+        if ((m = mmap(NULL, (size_t) sb.st_size, PROT_READ, MAP_PRIVATE, fd,
+            (off_t) 0)) == MAP_FAILED) {
+                LIBELF_SET_ERROR(IO, errno);
+                return (NULL);
+        }
+
+        if ((e = elf_memory(m, (size_t) sb.st_size)) == NULL) {
+                (void) munmap(m, (size_t) sb.st_size);
+                return (NULL);
+        }
+
+        e->e_flags |= LIBELF_F_MMAP;
+        e->e_fd = fd;
+        e->e_cmd = c;
+
+        if (c == ELF_C_RDWR && e->e_kind == ELF_K_AR) {
+                (void) elf_end(e);
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        return (e);
+}
+
+Elf *
+elf_begin(int fd, Elf_Cmd c, Elf *a)
+{
+        Elf *e;
+
+        e = NULL;
+
+        if (LIBELF_PRIVATE(version) == EV_NONE) {
+                LIBELF_SET_ERROR(SEQUENCE, 0);
+                return (NULL);
+        }
+
+        switch (c) {
+        case ELF_C_NULL:
+                return (NULL);
+
+        case ELF_C_WRITE:
+
+                if (a != NULL) { /* not allowed for ar(1) archives. */
+                        LIBELF_SET_ERROR(ARGUMENT, 0);
+                        return (NULL);
+                }
+
+                /*
+                 * Check writeability of `fd' immediately and fail if
+                 * not writeable.
+                 */
+                if (ftruncate(fd, (off_t) 0) < 0) {
+                        LIBELF_SET_ERROR(IO, errno);
+                        return (NULL);
+                }
+
+                if ((e = _libelf_allocate_elf()) != NULL) {
+                        _libelf_init_elf(e, ELF_K_ELF);
+                        e->e_byteorder = LIBELF_PRIVATE(byteorder);
+                        e->e_fd = fd;
+                        e->e_cmd = c;
+                }
+                return (e);
+
+        case ELF_C_RDWR:
+                if (a != NULL) { /* not allowed for ar(1) archives. */
+                        LIBELF_SET_ERROR(ARGUMENT, 0);
+                        return (NULL);
+                }
+                /*FALLTHROUGH*/
+        case ELF_C_READ:
+                /*
+                 * Descriptor `a' could be for a regular ELF file, or
+                 * for an ar(1) archive.
+                 */
+                if (a && (a->e_fd != fd || c != a->e_cmd)) {
+                        LIBELF_SET_ERROR(ARGUMENT, 0);
+                        return (NULL);
+                }
+
+                break;
+
+        default:
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+
+        }
+
+        if (a == NULL)
+                e = _libelf_open_object(fd, c);
+        else if (a->e_kind == ELF_K_AR)
+                e = _libelf_ar_open_member(fd, c, a);
+        else
+                (e = a)->e_activations++;
+
+        return (e);
+}
diff --git a/ext/libelf/elf_cntl.c b/ext/libelf/elf_cntl.c
new file mode 100644 (file)
index 0000000..20b0af8
--- /dev/null
@@ -0,0 +1,57 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#include "libelf.h"
+
+#include "_libelf.h"
+
+int
+elf_cntl(Elf *e, Elf_Cmd c)
+{
+        if (e == NULL ||
+            (c != ELF_C_FDDONE && c != ELF_C_FDREAD)) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (-1);
+        }
+
+        if (e->e_parent) {
+                LIBELF_SET_ERROR(ARCHIVE, 0);
+                return (-1);
+        }
+
+        if (c == ELF_C_FDREAD) {
+                if (e->e_cmd == ELF_C_WRITE) {
+                        LIBELF_SET_ERROR(MODE, 0);
+                        return (-1);
+                }
+                else
+                        return (0);
+        }
+
+        e->e_fd = -1;
+        return 0;
+}
diff --git a/ext/libelf/elf_common.h b/ext/libelf/elf_common.h
new file mode 100644 (file)
index 0000000..52d1d14
--- /dev/null
@@ -0,0 +1,848 @@
+/*-
+ * Copyright (c) 1998 John D. Polstra.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD: src/sys/sys/elf_common.h,v 1.22 2007/04/03 01:47:07 kan Exp $
+ */
+
+#ifndef _SYS_ELF_COMMON_H_
+#define _SYS_ELF_COMMON_H_ 1
+
+#include <inttypes.h>
+
+/*
+ * ELF definitions that are independent of architecture or word size.
+ */
+
+/*
+ * Note header.  The ".note" section contains an array of notes.  Each
+ * begins with this header, aligned to a word boundary.  Immediately
+ * following the note header is n_namesz bytes of name, padded to the
+ * next word boundary.  Then comes n_descsz bytes of descriptor, again
+ * padded to a word boundary.  The values of n_namesz and n_descsz do
+ * not include the padding.
+ */
+
+typedef struct {
+        uint32_t       n_namesz;       /* Length of name. */
+        uint32_t       n_descsz;       /* Length of descriptor. */
+        uint32_t       n_type;         /* Type of this note. */
+} Elf_Note;
+
+/* Indexes into the e_ident array.  Keep synced with
+   http://www.sco.com/developers/gabi/latest/ch4.eheader.html */
+#define EI_MAG0                0       /* Magic number, byte 0. */
+#define EI_MAG1                1       /* Magic number, byte 1. */
+#define EI_MAG2                2       /* Magic number, byte 2. */
+#define EI_MAG3                3       /* Magic number, byte 3. */
+#define EI_CLASS       4       /* Class of machine. */
+#define EI_DATA                5       /* Data format. */
+#define EI_VERSION     6       /* ELF format version. */
+#define EI_OSABI       7       /* Operating system / ABI identification */
+#define EI_ABIVERSION  8       /* ABI version */
+#define OLD_EI_BRAND   8       /* Start of architecture identification. */
+#define EI_PAD         9       /* Start of padding (per SVR4 ABI). */
+#define EI_NIDENT      16      /* Size of e_ident array. */
+
+/* Values for the magic number bytes. */
+#define ELFMAG0                0x7f
+#define ELFMAG1                'E'
+#define ELFMAG2                'L'
+#define ELFMAG3                'F'
+#define ELFMAG         "\177ELF"       /* magic string */
+#define SELFMAG                4               /* magic string size */
+
+/* Values for e_ident[EI_VERSION] and e_version. */
+#define EV_NONE                0
+#define EV_CURRENT     1
+
+/* Values for e_ident[EI_CLASS]. */
+#define ELFCLASSNONE   0       /* Unknown class. */
+#define ELFCLASS32     1       /* 32-bit architecture. */
+#define ELFCLASS64     2       /* 64-bit architecture. */
+
+/* Values for e_ident[EI_DATA]. */
+#define ELFDATANONE    0       /* Unknown data format. */
+#define ELFDATA2LSB    1       /* 2's complement little-endian. */
+#define ELFDATA2MSB    2       /* 2's complement big-endian. */
+
+/* Values for e_ident[EI_OSABI]. */
+#define ELFOSABI_NONE          0       /* UNIX System V ABI */
+#define ELFOSABI_HPUX          1       /* HP-UX operating system */
+#define ELFOSABI_NETBSD                2       /* NetBSD */
+#define ELFOSABI_LINUX         3       /* GNU/Linux */
+#define ELFOSABI_HURD          4       /* GNU/Hurd */
+#define ELFOSABI_86OPEN                5       /* 86Open common IA32 ABI */
+#define ELFOSABI_SOLARIS       6       /* Solaris */
+#define ELFOSABI_AIX           7       /* AIX */
+#define ELFOSABI_IRIX          8       /* IRIX */
+#define ELFOSABI_FREEBSD       9       /* FreeBSD */
+#define ELFOSABI_TRU64         10      /* TRU64 UNIX */
+#define ELFOSABI_MODESTO       11      /* Novell Modesto */
+#define ELFOSABI_OPENBSD       12      /* OpenBSD */
+#define ELFOSABI_OPENVMS       13      /* Open VMS */
+#define ELFOSABI_NSK           14      /* HP Non-Stop Kernel */
+#define ELFOSABI_ARM           97      /* ARM */
+#define ELFOSABI_STANDALONE    255     /* Standalone (embedded) application */
+
+#define ELFOSABI_SYSV          ELFOSABI_NONE   /* symbol used in old spec */
+#define ELFOSABI_MONTEREY      ELFOSABI_AIX    /* Monterey */
+
+/* e_ident */
+#define IS_ELF(ehdr)   ((ehdr).e_ident[EI_MAG0] == ELFMAG0 && \
+                         (ehdr).e_ident[EI_MAG1] == ELFMAG1 && \
+                         (ehdr).e_ident[EI_MAG2] == ELFMAG2 && \
+                         (ehdr).e_ident[EI_MAG3] == ELFMAG3)
+
+/* Values for e_type. */
+#define ET_NONE                0       /* Unknown type. */
+#define ET_REL         1       /* Relocatable. */
+#define ET_EXEC                2       /* Executable. */
+#define ET_DYN         3       /* Shared object. */
+#define ET_CORE                4       /* Core file. */
+#define ET_LOOS                0xfe00  /* First operating system specific. */
+#define ET_HIOS                0xfeff  /* Last operating system-specific. */
+#define ET_LOPROC      0xff00  /* First processor-specific. */
+#define ET_HIPROC      0xffff  /* Last processor-specific. */
+
+/* Values for e_machine. */
+#define EM_NONE                0       /* Unknown machine. */
+#define EM_M32         1       /* AT&T WE32100. */
+#define EM_SPARC       2       /* Sun SPARC. */
+#define EM_386         3       /* Intel i386. */
+#define EM_68K         4       /* Motorola 68000. */
+#define EM_88K         5       /* Motorola 88000. */
+#define EM_860         7       /* Intel i860. */
+#define EM_MIPS                8       /* MIPS R3000 Big-Endian only. */
+#define EM_S370                9       /* IBM System/370. */
+#define EM_MIPS_RS3_LE 10      /* MIPS R3000 Little-Endian. */
+#define EM_SPARC64     11      /* SPARC 64-bit */
+#define EM_PARISC      15      /* HP PA-RISC. */
+#define EM_VPP500      17      /* Fujitsu VPP500. */
+#define EM_SPARC32PLUS 18      /* SPARC v8plus. */
+#define EM_960         19      /* Intel 80960. */
+#define EM_PPC         20      /* PowerPC 32-bit. */
+#define EM_PPC64       21      /* PowerPC 64-bit. */
+#define EM_S390                22      /* IBM System/390. */
+#define EM_V800                36      /* NEC V800. */
+#define EM_FR20                37      /* Fujitsu FR20. */
+#define EM_RH32                38      /* TRW RH-32. */
+#define EM_RCE         39      /* Motorola RCE. */
+#define EM_ARM         40      /* ARM. */
+#define EM_SH          42      /* Hitachi SH. */
+#define EM_SPARCV9     43      /* SPARC v9 64-bit. */
+#define EM_TRICORE     44      /* Siemens TriCore embedded processor. */
+#define EM_ARC         45      /* Argonaut RISC Core. */
+#define EM_H8_300      46      /* Hitachi H8/300. */
+#define EM_H8_300H     47      /* Hitachi H8/300H. */
+#define EM_H8S         48      /* Hitachi H8S. */
+#define EM_H8_500      49      /* Hitachi H8/500. */
+#define EM_IA_64       50      /* Intel IA-64 Processor. */
+#define EM_MIPS_X      51      /* Stanford MIPS-X. */
+#define EM_COLDFIRE    52      /* Motorola ColdFire. */
+#define EM_68HC12      53      /* Motorola M68HC12. */
+#define EM_MMA         54      /* Fujitsu MMA. */
+#define EM_PCP         55      /* Siemens PCP. */
+#define EM_NCPU                56      /* Sony nCPU. */
+#define EM_NDR1                57      /* Denso NDR1 microprocessor. */
+#define EM_STARCORE    58      /* Motorola Star*Core processor. */
+#define EM_ME16                59      /* Toyota ME16 processor. */
+#define EM_ST100       60      /* STMicroelectronics ST100 processor. */
+#define EM_TINYJ       61      /* Advanced Logic Corp. TinyJ processor. */
+#define EM_X86_64      62      /* Advanced Micro Devices x86-64 */
+#define        EM_AMD64        EM_X86_64       /* Advanced Micro Devices x86-64 (compat) */
+#define EM_AARCH64      183     /* AArch64 64 bit ARM. */
+#define EM_RISCV       243 /* Berkeley RISC-V */
+
+/* Non-standard or deprecated. */
+#define EM_486         6       /* Intel i486. */
+#define EM_MIPS_RS4_BE 10      /* MIPS R4000 Big-Endian */
+#define EM_ALPHA_STD   41      /* Digital Alpha (standard value). */
+#define EM_ALPHA       0x9026  /* Alpha (written in the absence of an ABI) */
+
+/* Special section indexes. */
+#define SHN_UNDEF           0          /* Undefined, missing, irrelevant. */
+#define SHN_LORESERVE  0xff00          /* First of reserved range. */
+#define SHN_LOPROC     0xff00          /* First processor-specific. */
+#define SHN_HIPROC     0xff1f          /* Last processor-specific. */
+#define SHN_LOOS       0xff20          /* First operating system-specific. */
+#define SHN_HIOS       0xff3f          /* Last operating system-specific. */
+#define SHN_ABS                0xfff1          /* Absolute values. */
+#define SHN_COMMON     0xfff2          /* Common data. */
+#define SHN_XINDEX     0xffff          /* Escape -- index stored elsewhere. */
+#define SHN_HIRESERVE  0xffff          /* Last of reserved range. */
+
+/* sh_type */
+#define SHT_NULL               0       /* inactive */
+#define SHT_PROGBITS           1       /* program defined information */
+#define SHT_SYMTAB             2       /* symbol table section */
+#define SHT_STRTAB             3       /* string table section */
+#define SHT_RELA               4       /* relocation section with addends */
+#define SHT_HASH               5       /* symbol hash table section */
+#define SHT_DYNAMIC            6       /* dynamic section */
+#define SHT_NOTE               7       /* note section */
+#define SHT_NOBITS             8       /* no space section */
+#define SHT_REL                        9       /* relocation section - no addends */
+#define SHT_SHLIB              10      /* reserved - purpose unknown */
+#define SHT_DYNSYM             11      /* dynamic symbol table section */
+#define SHT_INIT_ARRAY         14      /* Initialization function pointers. */
+#define SHT_FINI_ARRAY         15      /* Termination function pointers. */
+#define SHT_PREINIT_ARRAY      16      /* Pre-initialization function ptrs. */
+#define SHT_GROUP              17      /* Section group. */
+#define SHT_SYMTAB_SHNDX       18      /* Section indexes (see SHN_XINDEX). */
+#define SHT_LOOS               0x60000000      /* First of OS specific semantics */
+#define SHT_LOSUNW             0x6ffffff4
+#define SHT_SUNW_dof           0x6ffffff4
+#define SHT_SUNW_cap           0x6ffffff5
+#define SHT_SUNW_SIGNATURE     0x6ffffff6
+#define SHT_SUNW_ANNOTATE      0x6ffffff7
+#define SHT_SUNW_DEBUGSTR      0x6ffffff8
+#define SHT_SUNW_DEBUG         0x6ffffff9
+#define SHT_SUNW_move          0x6ffffffa
+#define SHT_SUNW_COMDAT                0x6ffffffb
+#define SHT_SUNW_syminfo       0x6ffffffc
+#define SHT_SUNW_verdef                0x6ffffffd
+#define SHT_GNU_verdef         0x6ffffffd      /* Symbol versions provided */
+#define SHT_SUNW_verneed       0x6ffffffe
+#define SHT_GNU_verneed                0x6ffffffe      /* Symbol versions required */
+#define SHT_SUNW_versym                0x6fffffff
+#define SHT_GNU_versym         0x6fffffff      /* Symbol version table */
+#define SHT_HISUNW             0x6fffffff
+#define SHT_HIOS               0x6fffffff      /* Last of OS specific semantics */
+#define SHT_LOPROC             0x70000000      /* reserved range for processor */
+#define SHT_AMD64_UNWIND       0x70000001      /* unwind information */
+#define SHT_HIPROC             0x7fffffff      /* specific section header types */
+#define SHT_LOUSER             0x80000000      /* reserved range for application */
+#define SHT_HIUSER             0xffffffff      /* specific indexes */
+
+/* Flags for sh_flags. */
+#define SHF_WRITE              0x1     /* Section contains writable data. */
+#define SHF_ALLOC              0x2     /* Section occupies memory. */
+#define SHF_EXECINSTR          0x4     /* Section contains instructions. */
+#define SHF_MERGE              0x10    /* Section may be merged. */
+#define SHF_STRINGS            0x20    /* Section contains strings. */
+#define SHF_INFO_LINK          0x40    /* sh_info holds section index. */
+#define SHF_LINK_ORDER         0x80    /* Special ordering requirements. */
+#define SHF_OS_NONCONFORMING   0x100   /* OS-specific processing required. */
+#define SHF_GROUP              0x200   /* Member of section group. */
+#define SHF_TLS                        0x400   /* Section contains TLS data. */
+#define SHF_MASKOS     0x0ff00000      /* OS-specific semantics. */
+#define SHF_MASKPROC   0xf0000000      /* Processor-specific semantics. */
+
+/* Values for p_type. */
+#define PT_NULL                0       /* Unused entry. */
+#define PT_LOAD                1       /* Loadable segment. */
+#define PT_DYNAMIC     2       /* Dynamic linking information segment. */
+#define PT_INTERP      3       /* Pathname of interpreter. */
+#define PT_NOTE                4       /* Auxiliary information. */
+#define PT_SHLIB       5       /* Reserved (not used). */
+#define PT_PHDR                6       /* Location of program header itself. */
+#define        PT_TLS          7       /* Thread local storage segment */
+#define PT_LOOS                0x60000000      /* First OS-specific. */
+#define        PT_SUNW_UNWIND  0x6464e550      /* amd64 UNWIND program header */
+#define        PT_GNU_EH_FRAME 0x6474e550
+#define        PT_LOSUNW       0x6ffffffa
+#define        PT_SUNWBSS      0x6ffffffa      /* Sun Specific segment */
+#define        PT_SUNWSTACK    0x6ffffffb      /* describes the stack segment */
+#define        PT_SUNWDTRACE   0x6ffffffc      /* private */
+#define        PT_SUNWCAP      0x6ffffffd      /* hard/soft capabilities segment */
+#define        PT_HISUNW       0x6fffffff
+#define PT_HIOS                0x6fffffff      /* Last OS-specific. */
+#define PT_LOPROC      0x70000000      /* First processor-specific type. */
+#define PT_HIPROC      0x7fffffff      /* Last processor-specific type. */
+
+/* Values for p_flags. */
+#define PF_X           0x1             /* Executable. */
+#define PF_W           0x2             /* Writable. */
+#define PF_R           0x4             /* Readable. */
+#define PF_MASKOS      0x0ff00000      /* Operating system-specific. */
+#define PF_MASKPROC    0xf0000000      /* Processor-specific. */
+
+/* Extended program header index. */
+#define        PN_XNUM         0xffff
+
+/* Values for d_tag. */
+#define DT_NULL                0       /* Terminating entry. */
+#define DT_NEEDED      1       /* String table offset of a needed shared
+                                   library. */
+#define DT_PLTRELSZ    2       /* Total size in bytes of PLT relocations. */
+#define DT_PLTGOT      3       /* Processor-dependent address. */
+#define DT_HASH                4       /* Address of symbol hash table. */
+#define DT_STRTAB      5       /* Address of string table. */
+#define DT_SYMTAB      6       /* Address of symbol table. */
+#define DT_RELA                7       /* Address of ElfNN_Rela relocations. */
+#define DT_RELASZ      8       /* Total size of ElfNN_Rela relocations. */
+#define DT_RELAENT     9       /* Size of each ElfNN_Rela relocation entry. */
+#define DT_STRSZ       10      /* Size of string table. */
+#define DT_SYMENT      11      /* Size of each symbol table entry. */
+#define DT_INIT                12      /* Address of initialization function. */
+#define DT_FINI                13      /* Address of finalization function. */
+#define DT_SONAME      14      /* String table offset of shared object
+                                   name. */
+#define DT_RPATH       15      /* String table offset of library path. [sup] */
+#define DT_SYMBOLIC    16      /* Indicates "symbolic" linking. [sup] */
+#define DT_REL         17      /* Address of ElfNN_Rel relocations. */
+#define DT_RELSZ       18      /* Total size of ElfNN_Rel relocations. */
+#define DT_RELENT      19      /* Size of each ElfNN_Rel relocation. */
+#define DT_PLTREL      20      /* Type of relocation used for PLT. */
+#define DT_DEBUG       21      /* Reserved (not used). */
+#define DT_TEXTREL     22      /* Indicates there may be relocations in
+                                   non-writable segments. [sup] */
+#define DT_JMPREL      23      /* Address of PLT relocations. */
+#define        DT_BIND_NOW     24      /* [sup] */
+#define        DT_INIT_ARRAY   25      /* Address of the array of pointers to
+                                   initialization functions */
+#define        DT_FINI_ARRAY   26      /* Address of the array of pointers to
+                                   termination functions */
+#define        DT_INIT_ARRAYSZ 27      /* Size in bytes of the array of
+                                   initialization functions. */
+#define        DT_FINI_ARRAYSZ 28      /* Size in bytes of the array of
+                                   terminationfunctions. */
+#define        DT_RUNPATH      29      /* String table offset of a null-terminated
+                                   library search path string. */
+#define        DT_FLAGS        30      /* Object specific flag values. */
+#define        DT_ENCODING     32      /* Values greater than or equal to DT_ENCODING
+                                   and less than DT_LOOS follow the rules for
+                                   the interpretation of the d_un union
+                                   as follows: even == 'd_ptr', even == 'd_val'
+                                   or none */
+#define        DT_PREINIT_ARRAY 32     /* Address of the array of pointers to
+                                   pre-initialization functions. */
+#define        DT_PREINIT_ARRAYSZ 33   /* Size in bytes of the array of
+                                   pre-initialization functions. */
+#define        DT_MAXPOSTAGS   34      /* number of positive tags */
+#define        DT_LOOS         0x6000000d      /* First OS-specific */
+#define        DT_SUNW_AUXILIARY       0x6000000d      /* symbol auxiliary name */
+#define        DT_SUNW_RTLDINF         0x6000000e      /* ld.so.1 info (private) */
+#define        DT_SUNW_FILTER          0x6000000f      /* symbol filter name */
+#define        DT_SUNW_CAP             0x60000010      /* hardware/software */
+#define        DT_HIOS         0x6ffff000      /* Last OS-specific */
+
+/*
+ * DT_* entries which fall between DT_VALRNGHI & DT_VALRNGLO use the
+ * Dyn.d_un.d_val field of the Elf*_Dyn structure.
+ */
+#define        DT_VALRNGLO     0x6ffffd00
+#define        DT_CHECKSUM     0x6ffffdf8      /* elf checksum */
+#define        DT_PLTPADSZ     0x6ffffdf9      /* pltpadding size */
+#define        DT_MOVEENT      0x6ffffdfa      /* move table entry size */
+#define        DT_MOVESZ       0x6ffffdfb      /* move table size */
+#define        DT_FEATURE_1    0x6ffffdfc      /* feature holder */
+#define        DT_POSFLAG_1    0x6ffffdfd      /* flags for DT_* entries, effecting */
+                                        /*     the following DT_* entry. */
+                                        /*     See DF_P1_* definitions */
+#define        DT_SYMINSZ      0x6ffffdfe      /* syminfo table size (in bytes) */
+#define        DT_SYMINENT     0x6ffffdff      /* syminfo entry size (in bytes) */
+#define        DT_VALRNGHI     0x6ffffdff
+
+/*
+ * DT_* entries which fall between DT_ADDRRNGHI & DT_ADDRRNGLO use the
+ * Dyn.d_un.d_ptr field of the Elf*_Dyn structure.
+ *
+ * If any adjustment is made to the ELF object after it has been
+ * built, these entries will need to be adjusted.
+ */
+#define        DT_ADDRRNGLO    0x6ffffe00
+#define        DT_CONFIG       0x6ffffefa      /* configuration information */
+#define        DT_DEPAUDIT     0x6ffffefb      /* dependency auditing */
+#define        DT_AUDIT        0x6ffffefc      /* object auditing */
+#define        DT_PLTPAD       0x6ffffefd      /* pltpadding (sparcv9) */
+#define        DT_MOVETAB      0x6ffffefe      /* move table */
+#define        DT_SYMINFO      0x6ffffeff      /* syminfo table */
+#define        DT_ADDRRNGHI    0x6ffffeff
+
+#define        DT_VERSYM       0x6ffffff0      /* Address of versym section. */
+#define        DT_RELACOUNT    0x6ffffff9      /* number of RELATIVE relocations */
+#define        DT_RELCOUNT     0x6ffffffa      /* number of RELATIVE relocations */
+#define        DT_FLAGS_1      0x6ffffffb      /* state flags - see DF_1_* defs */
+#define        DT_VERDEF       0x6ffffffc      /* Address of verdef section. */
+#define        DT_VERDEFNUM    0x6ffffffd      /* Number of elems in verdef section */
+#define        DT_VERNEED      0x6ffffffe      /* Address of verneed section. */
+#define        DT_VERNEEDNUM   0x6fffffff      /* Number of elems in verneed section */
+
+#define        DT_LOPROC       0x70000000      /* First processor-specific type. */
+#define        DT_DEPRECATED_SPARC_REGISTER    0x7000001
+#define        DT_AUXILIARY    0x7ffffffd      /* shared library auxiliary name */
+#define        DT_USED         0x7ffffffe      /* ignored - same as needed */
+#define        DT_FILTER       0x7fffffff      /* shared library filter name */
+#define        DT_HIPROC       0x7fffffff      /* Last processor-specific type. */
+
+/* Values for DT_FLAGS */
+#define        DF_ORIGIN       0x0001  /* Indicates that the object being loaded may
+                                   make reference to the $ORIGIN substitution
+                                   string */
+#define        DF_SYMBOLIC     0x0002  /* Indicates "symbolic" linking. */
+#define        DF_TEXTREL      0x0004  /* Indicates there may be relocations in
+                                   non-writable segments. */
+#define        DF_BIND_NOW     0x0008  /* Indicates that the dynamic linker should
+                                   process all relocations for the object
+                                   containing this entry before transferring
+                                   control to the program. */
+#define        DF_STATIC_TLS   0x0010  /* Indicates that the shared object or
+                                   executable contains code using a static
+                                   thread-local storage scheme. */
+
+/* Values for n_type.  Used in core files. */
+#define NT_PRSTATUS    1       /* Process status. */
+#define NT_FPREGSET    2       /* Floating point registers. */
+#define NT_PRPSINFO    3       /* Process state info. */
+
+/* Symbol Binding - ELFNN_ST_BIND - st_info */
+#define STB_LOCAL      0       /* Local symbol */
+#define STB_GLOBAL     1       /* Global symbol */
+#define STB_WEAK       2       /* like global - lower precedence */
+#define STB_LOOS       10      /* Reserved range for operating system */
+#define STB_HIOS       12      /*   specific semantics. */
+#define STB_LOPROC     13      /* reserved range for processor */
+#define STB_HIPROC     15      /*   specific semantics. */
+
+/* Symbol type - ELFNN_ST_TYPE - st_info */
+#define STT_NOTYPE     0       /* Unspecified type. */
+#define STT_OBJECT     1       /* Data object. */
+#define STT_FUNC       2       /* Function. */
+#define STT_SECTION    3       /* Section. */
+#define STT_FILE       4       /* Source file. */
+#define STT_COMMON     5       /* Uninitialized common block. */
+#define STT_TLS                6       /* TLS object. */
+#define STT_NUM                7
+#define STT_LOOS       10      /* Reserved range for operating system */
+#define STT_HIOS       12      /*   specific semantics. */
+#define STT_LOPROC     13      /* reserved range for processor */
+#define STT_HIPROC     15      /*   specific semantics. */
+
+/* Symbol visibility - ELFNN_ST_VISIBILITY - st_other */
+#define STV_DEFAULT    0x0     /* Default visibility (see binding). */
+#define STV_INTERNAL   0x1     /* Special meaning in relocatable objects. */
+#define STV_HIDDEN     0x2     /* Not visible. */
+#define STV_PROTECTED  0x3     /* Visible but not preemptible. */
+
+/* Special symbol table indexes. */
+#define STN_UNDEF      0       /* Undefined symbol index. */
+
+/* Symbol versioning flags. */
+#define        VER_DEF_CURRENT 1
+#define VER_DEF_IDX(x) VER_NDX(x)
+
+#define        VER_FLG_BASE    0x01
+#define        VER_FLG_WEAK    0x02
+
+#define        VER_NEED_CURRENT        1
+#define VER_NEED_WEAK  (1u << 15)
+#define VER_NEED_HIDDEN        VER_NDX_HIDDEN
+#define VER_NEED_IDX(x)        VER_NDX(x)
+
+#define        VER_NDX_LOCAL   0
+#define        VER_NDX_GLOBAL  1
+#define VER_NDX_GIVEN  2
+
+#define VER_NDX_HIDDEN (1u << 15)
+#define VER_NDX(x)     ((x) & ~(1u << 15))
+
+#define        CA_SUNW_NULL    0
+#define        CA_SUNW_HW_1    1               /* first hardware capabilities entry */
+#define        CA_SUNW_SF_1    2               /* first software capabilities entry */
+
+/*
+ * Syminfo flag values
+ */
+#define        SYMINFO_FLG_DIRECT      0x0001  /* symbol ref has direct association */
+                                        /*     to object containing defn. */
+#define        SYMINFO_FLG_PASSTHRU    0x0002  /* ignored - see SYMINFO_FLG_FILTER */
+#define        SYMINFO_FLG_COPY        0x0004  /* symbol is a copy-reloc */
+#define        SYMINFO_FLG_LAZYLOAD    0x0008  /* object containing defn should be */
+                                        /*     lazily-loaded */
+#define        SYMINFO_FLG_DIRECTBIND  0x0010  /* ref should be bound directly to */
+                                        /*     object containing defn. */
+#define        SYMINFO_FLG_NOEXTDIRECT 0x0020  /* don't let an external reference */
+                                        /*     directly bind to this symbol */
+#define        SYMINFO_FLG_FILTER      0x0002  /* symbol ref is associated to a */
+#define        SYMINFO_FLG_AUXILIARY   0x0040  /*      standard or auxiliary filter */
+
+/*
+ * Syminfo.si_boundto values.
+ */
+#define        SYMINFO_BT_SELF         0xffff  /* symbol bound to self */
+#define        SYMINFO_BT_PARENT       0xfffe  /* symbol bound to parent */
+#define        SYMINFO_BT_NONE         0xfffd  /* no special symbol binding */
+#define        SYMINFO_BT_EXTERN       0xfffc  /* symbol defined as external */
+#define        SYMINFO_BT_LOWRESERVE   0xff00  /* beginning of reserved entries */
+
+/*
+ * Syminfo version values.
+ */
+#define        SYMINFO_NONE            0       /* Syminfo version */
+#define        SYMINFO_CURRENT         1
+#define        SYMINFO_NUM             2
+
+/*
+ * Relocation types.
+ *
+ * All machine architectures are defined here to allow tools on one to
+ * handle others.
+ */
+
+#define        R_386_NONE              0       /* No relocation. */
+#define        R_386_32                1       /* Add symbol value. */
+#define        R_386_PC32              2       /* Add PC-relative symbol value. */
+#define        R_386_GOT32             3       /* Add PC-relative GOT offset. */
+#define        R_386_PLT32             4       /* Add PC-relative PLT offset. */
+#define        R_386_COPY              5       /* Copy data from shared object. */
+#define        R_386_GLOB_DAT          6       /* Set GOT entry to data address. */
+#define        R_386_JMP_SLOT          7       /* Set GOT entry to code address. */
+#define        R_386_RELATIVE          8       /* Add load address of shared object. */
+#define        R_386_GOTOFF            9       /* Add GOT-relative symbol address. */
+#define        R_386_GOTPC             10      /* Add PC-relative GOT table address. */
+#define        R_386_TLS_TPOFF         14      /* Negative offset in static TLS block */
+#define        R_386_TLS_IE            15      /* Absolute address of GOT for -ve static TLS */
+#define        R_386_TLS_GOTIE         16      /* GOT entry for negative static TLS block */
+#define        R_386_TLS_LE            17      /* Negative offset relative to static TLS */
+#define        R_386_TLS_GD            18      /* 32 bit offset to GOT (index,off) pair */
+#define        R_386_TLS_LDM           19      /* 32 bit offset to GOT (index,zero) pair */
+#define        R_386_TLS_GD_32         24      /* 32 bit offset to GOT (index,off) pair */
+#define        R_386_TLS_GD_PUSH       25      /* pushl instruction for Sun ABI GD sequence */
+#define        R_386_TLS_GD_CALL       26      /* call instruction for Sun ABI GD sequence */
+#define        R_386_TLS_GD_POP        27      /* popl instruction for Sun ABI GD sequence */
+#define        R_386_TLS_LDM_32        28      /* 32 bit offset to GOT (index,zero) pair */
+#define        R_386_TLS_LDM_PUSH      29      /* pushl instruction for Sun ABI LD sequence */
+#define        R_386_TLS_LDM_CALL      30      /* call instruction for Sun ABI LD sequence */
+#define        R_386_TLS_LDM_POP       31      /* popl instruction for Sun ABI LD sequence */
+#define        R_386_TLS_LDO_32        32      /* 32 bit offset from start of TLS block */
+#define        R_386_TLS_IE_32         33      /* 32 bit offset to GOT static TLS offset entry */
+#define        R_386_TLS_LE_32         34      /* 32 bit offset within static TLS block */
+#define        R_386_TLS_DTPMOD32      35      /* GOT entry containing TLS index */
+#define        R_386_TLS_DTPOFF32      36      /* GOT entry containing TLS offset */
+#define        R_386_TLS_TPOFF32       37      /* GOT entry of -ve static TLS offset */
+
+#define        R_ARM_NONE              0       /* No relocation. */
+#define        R_ARM_PC24              1
+#define        R_ARM_ABS32             2
+#define        R_ARM_REL32             3
+#define        R_ARM_PC13              4
+#define        R_ARM_ABS16             5
+#define        R_ARM_ABS12             6
+#define        R_ARM_THM_ABS5          7
+#define        R_ARM_ABS8              8
+#define        R_ARM_SBREL32           9
+#define        R_ARM_THM_PC22          10
+#define        R_ARM_THM_PC8           11
+#define        R_ARM_AMP_VCALL9        12
+#define        R_ARM_SWI24             13
+#define        R_ARM_THM_SWI8          14
+#define        R_ARM_XPC25             15
+#define        R_ARM_THM_XPC22         16
+#define        R_ARM_COPY              20      /* Copy data from shared object. */
+#define        R_ARM_GLOB_DAT          21      /* Set GOT entry to data address. */
+#define        R_ARM_JUMP_SLOT         22      /* Set GOT entry to code address. */
+#define        R_ARM_RELATIVE          23      /* Add load address of shared object. */
+#define        R_ARM_GOTOFF            24      /* Add GOT-relative symbol address. */
+#define        R_ARM_GOTPC             25      /* Add PC-relative GOT table address. */
+#define        R_ARM_GOT32             26      /* Add PC-relative GOT offset. */
+#define        R_ARM_PLT32             27      /* Add PC-relative PLT offset. */
+#define        R_ARM_GNU_VTENTRY       100
+#define        R_ARM_GNU_VTINHERIT     101
+#define        R_ARM_RSBREL32          250
+#define        R_ARM_THM_RPC22         251
+#define        R_ARM_RREL32            252
+#define        R_ARM_RABS32            253
+#define        R_ARM_RPC24             254
+#define        R_ARM_RBASE             255
+
+/*     Name                    Value      Field        Calculation */
+#define        R_IA_64_NONE            0       /* None */
+#define        R_IA_64_IMM14           0x21    /* immediate14  S + A */
+#define        R_IA_64_IMM22           0x22    /* immediate22  S + A */
+#define        R_IA_64_IMM64           0x23    /* immediate64  S + A */
+#define        R_IA_64_DIR32MSB        0x24    /* word32 MSB   S + A */
+#define        R_IA_64_DIR32LSB        0x25    /* word32 LSB   S + A */
+#define        R_IA_64_DIR64MSB        0x26    /* word64 MSB   S + A */
+#define        R_IA_64_DIR64LSB        0x27    /* word64 LSB   S + A */
+#define        R_IA_64_GPREL22         0x2a    /* immediate22  @gprel(S + A) */
+#define        R_IA_64_GPREL64I        0x2b    /* immediate64  @gprel(S + A) */
+#define        R_IA_64_GPREL32MSB      0x2c    /* word32 MSB   @gprel(S + A) */
+#define        R_IA_64_GPREL32LSB      0x2d    /* word32 LSB   @gprel(S + A) */
+#define        R_IA_64_GPREL64MSB      0x2e    /* word64 MSB   @gprel(S + A) */
+#define        R_IA_64_GPREL64LSB      0x2f    /* word64 LSB   @gprel(S + A) */
+#define        R_IA_64_LTOFF22         0x32    /* immediate22  @ltoff(S + A) */
+#define        R_IA_64_LTOFF64I        0x33    /* immediate64  @ltoff(S + A) */
+#define        R_IA_64_PLTOFF22        0x3a    /* immediate22  @pltoff(S + A) */
+#define        R_IA_64_PLTOFF64I       0x3b    /* immediate64  @pltoff(S + A) */
+#define        R_IA_64_PLTOFF64MSB     0x3e    /* word64 MSB   @pltoff(S + A) */
+#define        R_IA_64_PLTOFF64LSB     0x3f    /* word64 LSB   @pltoff(S + A) */
+#define        R_IA_64_FPTR64I         0x43    /* immediate64  @fptr(S + A) */
+#define        R_IA_64_FPTR32MSB       0x44    /* word32 MSB   @fptr(S + A) */
+#define        R_IA_64_FPTR32LSB       0x45    /* word32 LSB   @fptr(S + A) */
+#define        R_IA_64_FPTR64MSB       0x46    /* word64 MSB   @fptr(S + A) */
+#define        R_IA_64_FPTR64LSB       0x47    /* word64 LSB   @fptr(S + A) */
+#define        R_IA_64_PCREL60B        0x48    /* immediate60 form1 S + A - P */
+#define        R_IA_64_PCREL21B        0x49    /* immediate21 form1 S + A - P */
+#define        R_IA_64_PCREL21M        0x4a    /* immediate21 form2 S + A - P */
+#define        R_IA_64_PCREL21F        0x4b    /* immediate21 form3 S + A - P */
+#define        R_IA_64_PCREL32MSB      0x4c    /* word32 MSB   S + A - P */
+#define        R_IA_64_PCREL32LSB      0x4d    /* word32 LSB   S + A - P */
+#define        R_IA_64_PCREL64MSB      0x4e    /* word64 MSB   S + A - P */
+#define        R_IA_64_PCREL64LSB      0x4f    /* word64 LSB   S + A - P */
+#define        R_IA_64_LTOFF_FPTR22    0x52    /* immediate22  @ltoff(@fptr(S + A)) */
+#define        R_IA_64_LTOFF_FPTR64I   0x53    /* immediate64  @ltoff(@fptr(S + A)) */
+#define        R_IA_64_LTOFF_FPTR32MSB 0x54    /* word32 MSB   @ltoff(@fptr(S + A)) */
+#define        R_IA_64_LTOFF_FPTR32LSB 0x55    /* word32 LSB   @ltoff(@fptr(S + A)) */
+#define        R_IA_64_LTOFF_FPTR64MSB 0x56    /* word64 MSB   @ltoff(@fptr(S + A)) */
+#define        R_IA_64_LTOFF_FPTR64LSB 0x57    /* word64 LSB   @ltoff(@fptr(S + A)) */
+#define        R_IA_64_SEGREL32MSB     0x5c    /* word32 MSB   @segrel(S + A) */
+#define        R_IA_64_SEGREL32LSB     0x5d    /* word32 LSB   @segrel(S + A) */
+#define        R_IA_64_SEGREL64MSB     0x5e    /* word64 MSB   @segrel(S + A) */
+#define        R_IA_64_SEGREL64LSB     0x5f    /* word64 LSB   @segrel(S + A) */
+#define        R_IA_64_SECREL32MSB     0x64    /* word32 MSB   @secrel(S + A) */
+#define        R_IA_64_SECREL32LSB     0x65    /* word32 LSB   @secrel(S + A) */
+#define        R_IA_64_SECREL64MSB     0x66    /* word64 MSB   @secrel(S + A) */
+#define        R_IA_64_SECREL64LSB     0x67    /* word64 LSB   @secrel(S + A) */
+#define        R_IA_64_REL32MSB        0x6c    /* word32 MSB   BD + A */
+#define        R_IA_64_REL32LSB        0x6d    /* word32 LSB   BD + A */
+#define        R_IA_64_REL64MSB        0x6e    /* word64 MSB   BD + A */
+#define        R_IA_64_REL64LSB        0x6f    /* word64 LSB   BD + A */
+#define        R_IA_64_LTV32MSB        0x74    /* word32 MSB   S + A */
+#define        R_IA_64_LTV32LSB        0x75    /* word32 LSB   S + A */
+#define        R_IA_64_LTV64MSB        0x76    /* word64 MSB   S + A */
+#define        R_IA_64_LTV64LSB        0x77    /* word64 LSB   S + A */
+#define        R_IA_64_PCREL21BI       0x79    /* immediate21 form1 S + A - P */
+#define        R_IA_64_PCREL22         0x7a    /* immediate22  S + A - P */
+#define        R_IA_64_PCREL64I        0x7b    /* immediate64  S + A - P */
+#define        R_IA_64_IPLTMSB         0x80    /* function descriptor MSB special */
+#define        R_IA_64_IPLTLSB         0x81    /* function descriptor LSB speciaal */
+#define        R_IA_64_SUB             0x85    /* immediate64  A - S */
+#define        R_IA_64_LTOFF22X        0x86    /* immediate22  special */
+#define        R_IA_64_LDXMOV          0x87    /* immediate22  special */
+#define        R_IA_64_TPREL14         0x91    /* imm14        @tprel(S + A) */
+#define        R_IA_64_TPREL22         0x92    /* imm22        @tprel(S + A) */
+#define        R_IA_64_TPREL64I        0x93    /* imm64        @tprel(S + A) */
+#define        R_IA_64_TPREL64MSB      0x96    /* word64 MSB   @tprel(S + A) */
+#define        R_IA_64_TPREL64LSB      0x97    /* word64 LSB   @tprel(S + A) */
+#define        R_IA_64_LTOFF_TPREL22   0x9a    /* imm22        @ltoff(@tprel(S+A)) */
+#define        R_IA_64_DTPMOD64MSB     0xa6    /* word64 MSB   @dtpmod(S + A) */
+#define        R_IA_64_DTPMOD64LSB     0xa7    /* word64 LSB   @dtpmod(S + A) */
+#define        R_IA_64_LTOFF_DTPMOD22  0xaa    /* imm22        @ltoff(@dtpmod(S+A)) */
+#define        R_IA_64_DTPREL14        0xb1    /* imm14        @dtprel(S + A) */
+#define        R_IA_64_DTPREL22        0xb2    /* imm22        @dtprel(S + A) */
+#define        R_IA_64_DTPREL64I       0xb3    /* imm64        @dtprel(S + A) */
+#define        R_IA_64_DTPREL32MSB     0xb4    /* word32 MSB   @dtprel(S + A) */
+#define        R_IA_64_DTPREL32LSB     0xb5    /* word32 LSB   @dtprel(S + A) */
+#define        R_IA_64_DTPREL64MSB     0xb6    /* word64 MSB   @dtprel(S + A) */
+#define        R_IA_64_DTPREL64LSB     0xb7    /* word64 LSB   @dtprel(S + A) */
+#define        R_IA_64_LTOFF_DTPREL22  0xba    /* imm22        @ltoff(@dtprel(S+A)) */
+
+#define        R_PPC_NONE              0       /* No relocation. */
+#define        R_PPC_ADDR32            1
+#define        R_PPC_ADDR24            2
+#define        R_PPC_ADDR16            3
+#define        R_PPC_ADDR16_LO         4
+#define        R_PPC_ADDR16_HI         5
+#define        R_PPC_ADDR16_HA         6
+#define        R_PPC_ADDR14            7
+#define        R_PPC_ADDR14_BRTAKEN    8
+#define        R_PPC_ADDR14_BRNTAKEN   9
+#define        R_PPC_REL24             10
+#define        R_PPC_REL14             11
+#define        R_PPC_REL14_BRTAKEN     12
+#define        R_PPC_REL14_BRNTAKEN    13
+#define        R_PPC_GOT16             14
+#define        R_PPC_GOT16_LO          15
+#define        R_PPC_GOT16_HI          16
+#define        R_PPC_GOT16_HA          17
+#define        R_PPC_PLTREL24          18
+#define        R_PPC_COPY              19
+#define        R_PPC_GLOB_DAT          20
+#define        R_PPC_JMP_SLOT          21
+#define        R_PPC_RELATIVE          22
+#define        R_PPC_LOCAL24PC         23
+#define        R_PPC_UADDR32           24
+#define        R_PPC_UADDR16           25
+#define        R_PPC_REL32             26
+#define        R_PPC_PLT32             27
+#define        R_PPC_PLTREL32          28
+#define        R_PPC_PLT16_LO          29
+#define        R_PPC_PLT16_HI          30
+#define        R_PPC_PLT16_HA          31
+#define        R_PPC_SDAREL16          32
+#define        R_PPC_SECTOFF           33
+#define        R_PPC_SECTOFF_LO        34
+#define        R_PPC_SECTOFF_HI        35
+#define        R_PPC_SECTOFF_HA        36
+
+/*
+ * TLS relocations
+ */
+#define R_PPC_TLS              67
+#define R_PPC_DTPMOD32         68
+#define R_PPC_TPREL16          69
+#define R_PPC_TPREL16_LO       70
+#define R_PPC_TPREL16_HI       71
+#define R_PPC_TPREL16_HA       72
+#define R_PPC_TPREL32          73
+#define R_PPC_DTPREL16         74
+#define R_PPC_DTPREL16_LO      75
+#define R_PPC_DTPREL16_HI      76
+#define R_PPC_DTPREL16_HA      77
+#define R_PPC_DTPREL32         78
+#define R_PPC_GOT_TLSGD16      79
+#define R_PPC_GOT_TLSGD16_LO   80
+#define R_PPC_GOT_TLSGD16_HI   81
+#define R_PPC_GOT_TLSGD16_HA   82
+#define R_PPC_GOT_TLSLD16      83
+#define R_PPC_GOT_TLSLD16_LO   84
+#define R_PPC_GOT_TLSLD16_HI   85
+#define R_PPC_GOT_TLSLD16_HA   86
+#define R_PPC_GOT_TPREL16      87
+#define R_PPC_GOT_TPREL16_LO   88
+#define R_PPC_GOT_TPREL16_HI   89
+#define R_PPC_GOT_TPREL16_HA   90
+
+/*
+ * The remaining relocs are from the Embedded ELF ABI, and are not in the
+ *  SVR4 ELF ABI.
+ */
+
+#define        R_PPC_EMB_NADDR32       101
+#define        R_PPC_EMB_NADDR16       102
+#define        R_PPC_EMB_NADDR16_LO    103
+#define        R_PPC_EMB_NADDR16_HI    104
+#define        R_PPC_EMB_NADDR16_HA    105
+#define        R_PPC_EMB_SDAI16        106
+#define        R_PPC_EMB_SDA2I16       107
+#define        R_PPC_EMB_SDA2REL       108
+#define        R_PPC_EMB_SDA21         109
+#define        R_PPC_EMB_MRKREF        110
+#define        R_PPC_EMB_RELSEC16      111
+#define        R_PPC_EMB_RELST_LO      112
+#define        R_PPC_EMB_RELST_HI      113
+#define        R_PPC_EMB_RELST_HA      114
+#define        R_PPC_EMB_BIT_FLD       115
+#define        R_PPC_EMB_RELSDA        116
+
+#define        R_SPARC_NONE            0
+#define        R_SPARC_8               1
+#define        R_SPARC_16              2
+#define        R_SPARC_32              3
+#define        R_SPARC_DISP8           4
+#define        R_SPARC_DISP16          5
+#define        R_SPARC_DISP32          6
+#define        R_SPARC_WDISP30         7
+#define        R_SPARC_WDISP22         8
+#define        R_SPARC_HI22            9
+#define        R_SPARC_22              10
+#define        R_SPARC_13              11
+#define        R_SPARC_LO10            12
+#define        R_SPARC_GOT10           13
+#define        R_SPARC_GOT13           14
+#define        R_SPARC_GOT22           15
+#define        R_SPARC_PC10            16
+#define        R_SPARC_PC22            17
+#define        R_SPARC_WPLT30          18
+#define        R_SPARC_COPY            19
+#define        R_SPARC_GLOB_DAT        20
+#define        R_SPARC_JMP_SLOT        21
+#define        R_SPARC_RELATIVE        22
+#define        R_SPARC_UA32            23
+#define        R_SPARC_PLT32           24
+#define        R_SPARC_HIPLT22         25
+#define        R_SPARC_LOPLT10         26
+#define        R_SPARC_PCPLT32         27
+#define        R_SPARC_PCPLT22         28
+#define        R_SPARC_PCPLT10         29
+#define        R_SPARC_10              30
+#define        R_SPARC_11              31
+#define        R_SPARC_64              32
+#define        R_SPARC_OLO10           33
+#define        R_SPARC_HH22            34
+#define        R_SPARC_HM10            35
+#define        R_SPARC_LM22            36
+#define        R_SPARC_PC_HH22         37
+#define        R_SPARC_PC_HM10         38
+#define        R_SPARC_PC_LM22         39
+#define        R_SPARC_WDISP16         40
+#define        R_SPARC_WDISP19         41
+#define        R_SPARC_GLOB_JMP        42
+#define        R_SPARC_7               43
+#define        R_SPARC_5               44
+#define        R_SPARC_6               45
+#define        R_SPARC_DISP64          46
+#define        R_SPARC_PLT64           47
+#define        R_SPARC_HIX22           48
+#define        R_SPARC_LOX10           49
+#define        R_SPARC_H44             50
+#define        R_SPARC_M44             51
+#define        R_SPARC_L44             52
+#define        R_SPARC_REGISTER        53
+#define        R_SPARC_UA64            54
+#define        R_SPARC_UA16            55
+#define        R_SPARC_TLS_GD_HI22     56
+#define        R_SPARC_TLS_GD_LO10     57
+#define        R_SPARC_TLS_GD_ADD      58
+#define        R_SPARC_TLS_GD_CALL     59
+#define        R_SPARC_TLS_LDM_HI22    60
+#define        R_SPARC_TLS_LDM_LO10    61
+#define        R_SPARC_TLS_LDM_ADD     62
+#define        R_SPARC_TLS_LDM_CALL    63
+#define        R_SPARC_TLS_LDO_HIX22   64
+#define        R_SPARC_TLS_LDO_LOX10   65
+#define        R_SPARC_TLS_LDO_ADD     66
+#define        R_SPARC_TLS_IE_HI22     67
+#define        R_SPARC_TLS_IE_LO10     68
+#define        R_SPARC_TLS_IE_LD       69
+#define        R_SPARC_TLS_IE_LDX      70
+#define        R_SPARC_TLS_IE_ADD      71
+#define        R_SPARC_TLS_LE_HIX22    72
+#define        R_SPARC_TLS_LE_LOX10    73
+#define        R_SPARC_TLS_DTPMOD32    74
+#define        R_SPARC_TLS_DTPMOD64    75
+#define        R_SPARC_TLS_DTPOFF32    76
+#define        R_SPARC_TLS_DTPOFF64    77
+#define        R_SPARC_TLS_TPOFF32     78
+#define        R_SPARC_TLS_TPOFF64     79
+
+#define        R_X86_64_NONE           0       /* No relocation. */
+#define        R_X86_64_64             1       /* Add 64 bit symbol value. */
+#define        R_X86_64_PC32           2       /* PC-relative 32 bit signed sym value. */
+#define        R_X86_64_GOT32          3       /* PC-relative 32 bit GOT offset. */
+#define        R_X86_64_PLT32          4       /* PC-relative 32 bit PLT offset. */
+#define        R_X86_64_COPY           5       /* Copy data from shared object. */
+#define        R_X86_64_GLOB_DAT       6       /* Set GOT entry to data address. */
+#define        R_X86_64_JMP_SLOT       7       /* Set GOT entry to code address. */
+#define        R_X86_64_RELATIVE       8       /* Add load address of shared object. */
+#define        R_X86_64_GOTPCREL       9       /* Add 32 bit signed pcrel offset to GOT. */
+#define        R_X86_64_32             10      /* Add 32 bit zero extended symbol value */
+#define        R_X86_64_32S            11      /* Add 32 bit sign extended symbol value */
+#define        R_X86_64_16             12      /* Add 16 bit zero extended symbol value */
+#define        R_X86_64_PC16           13      /* Add 16 bit signed extended pc relative symbol value */
+#define        R_X86_64_8              14      /* Add 8 bit zero extended symbol value */
+#define        R_X86_64_PC8            15      /* Add 8 bit signed extended pc relative symbol value */
+#define        R_X86_64_DTPMOD64       16      /* ID of module containing symbol */
+#define        R_X86_64_DTPOFF64       17      /* Offset in TLS block */
+#define        R_X86_64_TPOFF64        18      /* Offset in static TLS block */
+#define        R_X86_64_TLSGD          19      /* PC relative offset to GD GOT entry */
+#define        R_X86_64_TLSLD          20      /* PC relative offset to LD GOT entry */
+#define        R_X86_64_DTPOFF32       21      /* Offset in TLS block */
+#define        R_X86_64_GOTTPOFF       22      /* PC relative offset to IE GOT entry */
+#define        R_X86_64_TPOFF32        23      /* Offset in static TLS block */
+
+
+#endif /* !_SYS_ELF_COMMON_H_ */
diff --git a/ext/libelf/elf_data.c b/ext/libelf/elf_data.c
new file mode 100644 (file)
index 0000000..71e9575
--- /dev/null
@@ -0,0 +1,222 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#include <assert.h>
+#include <errno.h>
+#include "libelf.h"
+#include <stdlib.h>
+
+#include "_libelf.h"
+
+
+Elf_Data *
+elf_getdata(Elf_Scn *s, Elf_Data *d)
+{
+        Elf *e;
+        char *dst;
+        size_t fsz, msz, count;
+        int elfclass, elftype;
+        unsigned int sh_type;
+        uint64_t sh_align, sh_offset, sh_size;
+        void (*xlate)(char *_d, char *_s, size_t _c, int _swap);
+
+        if (s == NULL || (e = s->s_elf) == NULL || e->e_kind != ELF_K_ELF ||
+            (d != NULL && s != d->d_scn)) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        if (d == NULL && (d = STAILQ_FIRST(&s->s_data)) != NULL)
+                return (d);
+
+        if (d != NULL)
+                return (STAILQ_NEXT(d, d_next));
+
+        if (e->e_rawfile == NULL) {
+                LIBELF_SET_ERROR(SEQUENCE, 0);
+                return (NULL);
+        }
+
+        elfclass = e->e_class;
+
+        assert(elfclass == ELFCLASS32 || elfclass == ELFCLASS64);
+
+        if (elfclass == ELFCLASS32) {
+                sh_type   = s->s_shdr.s_shdr32.sh_type;
+                sh_offset = (uint64_t) s->s_shdr.s_shdr32.sh_offset;
+                sh_size   = (uint64_t) s->s_shdr.s_shdr32.sh_size;
+                sh_align  = (uint64_t) s->s_shdr.s_shdr32.sh_addralign;
+        } else {
+                sh_type   = s->s_shdr.s_shdr64.sh_type;
+                sh_offset = s->s_shdr.s_shdr64.sh_offset;
+                sh_size   = s->s_shdr.s_shdr64.sh_size;
+                sh_align  = s->s_shdr.s_shdr64.sh_addralign;
+        }
+
+        if ((elftype = _libelf_xlate_shtype(sh_type)) < ELF_T_FIRST ||
+            elftype > ELF_T_LAST ||
+            sh_offset + sh_size > (uint64_t) e->e_rawsize) {
+                LIBELF_SET_ERROR(SECTION, 0);
+                return (NULL);
+        }
+
+        if ((fsz = (elfclass == ELFCLASS32 ? elf32_fsize : elf64_fsize)(elftype,
+                 (size_t) 1, e->e_version)) == 0) {
+                LIBELF_SET_ERROR(UNIMPL, 0);
+                return (NULL);
+        }
+
+
+        if (sh_size % fsz) {
+                LIBELF_SET_ERROR(SECTION, 0);
+                return (NULL);
+        }
+
+        count = sh_size / fsz;
+
+        msz = _libelf_msize(elftype, elfclass, e->e_version);
+
+        assert(msz > 0);
+
+        if ((dst = malloc(msz*count)) == NULL) {
+                LIBELF_SET_ERROR(RESOURCE, 0);
+                return (NULL);
+        }
+
+        if ((d = _libelf_allocate_data(s)) == NULL)
+                return (NULL);
+
+        d->d_buf     = dst;
+        d->d_off     = 0;
+        d->d_align   = sh_align;
+        d->d_size    = msz * count;
+        d->d_type    = elftype;
+        d->d_version = e->e_version;
+
+        d->d_flags  |= LIBELF_F_MALLOCED;
+        STAILQ_INSERT_TAIL(&s->s_data, d, d_next);
+
+        xlate = _libelf_get_translator(elftype, ELF_TOMEMORY, elfclass);
+        (*xlate)(d->d_buf, e->e_rawfile + sh_offset, count, e->e_byteorder !=
+            LIBELF_PRIVATE(byteorder));
+
+        return (d);
+}
+
+Elf_Data *
+elf_newdata(Elf_Scn *s)
+{
+        Elf *e;
+        Elf_Data *d;
+
+        if (s == NULL || (e = s->s_elf) == NULL ||
+            e->e_kind != ELF_K_ELF) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        /*
+         * elf_newdata() has to append a data descriptor, so
+         * bring in existing section data if not already present.
+         */
+        if (e->e_rawfile && s->s_size > 0 && STAILQ_EMPTY(&s->s_data))
+                if (elf_getdata(s, NULL) == NULL)
+                        return (NULL);
+
+        if ((d = malloc(sizeof(Elf_Data))) == NULL) {
+                LIBELF_SET_ERROR(RESOURCE, errno);
+                return (NULL);
+        }
+
+        STAILQ_INSERT_TAIL(&s->s_data, d, d_next);
+        d->d_flags = 0;
+        d->d_scn = s;
+
+        d->d_align = 1;
+        d->d_buf = NULL;
+        d->d_off = (uint64_t) ~0;
+        d->d_size = 0;
+        d->d_type = ELF_T_BYTE;
+        d->d_version = LIBELF_PRIVATE(version);
+
+        (void) elf_flagscn(s, ELF_C_SET, ELF_F_DIRTY);
+
+        return (d);
+}
+
+/*
+ * Retrieve a data descriptor for raw (untranslated) data for section
+ * `s'.
+ */
+
+Elf_Data *
+elf_rawdata(Elf_Scn *s, Elf_Data *d)
+{
+        Elf *e;
+        int elf_class;
+        uint64_t sh_align, sh_offset, sh_size;
+
+        if (s == NULL || (e = s->s_elf) == NULL ||
+            e->e_kind != ELF_K_ELF || e->e_rawfile == NULL) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        if (d == NULL && (d = STAILQ_FIRST(&s->s_rawdata)) != NULL)
+                return (d);
+
+        if (d != NULL)
+                return (STAILQ_NEXT(d, d_next));
+
+        elf_class = e->e_class;
+
+        assert(elf_class == ELFCLASS32 || elf_class == ELFCLASS64);
+
+        if (elf_class == ELFCLASS32) {
+                sh_offset = (uint64_t) s->s_shdr.s_shdr32.sh_offset;
+                sh_size   = (uint64_t) s->s_shdr.s_shdr32.sh_size;
+                sh_align  = (uint64_t) s->s_shdr.s_shdr32.sh_addralign;
+        } else {
+                sh_offset = s->s_shdr.s_shdr64.sh_offset;
+                sh_size   = s->s_shdr.s_shdr64.sh_size;
+                sh_align  = s->s_shdr.s_shdr64.sh_addralign;
+        }
+
+        if ((d = _libelf_allocate_data(s)) == NULL)
+                return (NULL);
+
+        d->d_buf     = e->e_rawfile + sh_offset;
+        d->d_off     = 0;
+        d->d_align   = sh_align;
+        d->d_size    = sh_size;
+        d->d_type    = ELF_T_BYTE;
+        d->d_version = e->e_version;
+
+        STAILQ_INSERT_TAIL(&s->s_rawdata, d, d_next);
+
+        return (d);
+}
diff --git a/ext/libelf/elf_end.c b/ext/libelf/elf_end.c
new file mode 100644 (file)
index 0000000..082ca2d
--- /dev/null
@@ -0,0 +1,86 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#include <sys/mman.h>
+
+#include <assert.h>
+#include "libelf.h"
+#include <stdlib.h>
+
+#include "_libelf.h"
+
+int
+elf_end(Elf *e)
+{
+        Elf *sv;
+        Elf_Scn *scn, *tscn;
+
+        if (e == NULL || e->e_activations == 0)
+                return (0);
+
+        if (--e->e_activations > 0)
+                return (e->e_activations);
+
+        assert(e->e_activations == 0);
+
+        while (e && e->e_activations == 0) {
+                switch (e->e_kind) {
+                case ELF_K_AR:
+                        /*
+                         * If we still have open child descriptors, we
+                         * need to defer reclaiming resources till all
+                         * the child descriptors for the archive are
+                         * closed.
+                         */
+                        if (e->e_u.e_ar.e_nchildren > 0)
+                                return (0);
+                        break;
+                case ELF_K_ELF:
+                        /*
+                         * Reclaim all section descriptors.
+                         */
+                        STAILQ_FOREACH_SAFE(scn, &e->e_u.e_elf.e_scn, s_next, tscn)
+                                scn = _libelf_release_scn(scn);
+                        break;
+                case ELF_K_NUM:
+                        assert(0);
+                default:
+                        break;
+                }
+
+                if (e->e_flags & LIBELF_F_MMAP)
+                        (void) munmap(e->e_rawfile, e->e_rawsize);
+
+                sv = e;
+                if ((e = e->e_parent) != NULL)
+                        e->e_u.e_ar.e_nchildren--;
+                sv = _libelf_release_elf(sv);
+        }
+
+        return (0);
+}
+
diff --git a/ext/libelf/elf_errmsg.c b/ext/libelf/elf_errmsg.c
new file mode 100644 (file)
index 0000000..5fafd5f
--- /dev/null
@@ -0,0 +1,82 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#include <string.h>
+
+#include "_libelf.h"
+#include "libelf.h"
+
+/*
+ * Retrieve a human readable translation for an error message.
+ */
+
+const char *_libelf_errors[] = {
+#define        DEFINE_ERROR(N,S)       [ELF_E_##N] = S
+        DEFINE_ERROR(NONE,     "No Error"),
+        DEFINE_ERROR(ARCHIVE,  "Malformed ar(1) archive"),
+        DEFINE_ERROR(ARGUMENT, "Invalid argument"),
+        DEFINE_ERROR(CLASS,    "ELF class mismatch"),
+        DEFINE_ERROR(DATA,     "Invalid data buffer descriptor"),
+        DEFINE_ERROR(HEADER,   "Missing or malformed ELF header"),
+        DEFINE_ERROR(IO,       "I/O error"),
+        DEFINE_ERROR(LAYOUT,   "Layout constraint violation"),
+        DEFINE_ERROR(MODE,     "Incorrect ELF descriptor mode"),
+        DEFINE_ERROR(RANGE,    "Value out of range of target"),
+        DEFINE_ERROR(RESOURCE, "Resource exhaustion"),
+        DEFINE_ERROR(SECTION,  "Invalid section descriptor"),
+        DEFINE_ERROR(SEQUENCE, "API calls out of sequence"),
+        DEFINE_ERROR(UNIMPL,   "Unimplemented feature"),
+        DEFINE_ERROR(VERSION,  "Unknown ELF API version"),
+        DEFINE_ERROR(NUM,      "Unknown error")
+#undef DEFINE_ERROR
+};
+
+const char *
+elf_errmsg(int error)
+{
+        int oserr;
+
+        if (error == 0 && (error = LIBELF_PRIVATE(error)) == 0)
+            return NULL;
+        else if (error == -1)
+            error = LIBELF_PRIVATE(error);
+
+        oserr = error >> LIBELF_OS_ERROR_SHIFT;
+        error &= LIBELF_ELF_ERROR_MASK;
+
+        if (error < 0 || error >= ELF_E_NUM)
+                return _libelf_errors[ELF_E_NUM];
+        if (oserr) {
+                strncpy(LIBELF_PRIVATE(msg), _libelf_errors[error],
+                    sizeof(LIBELF_PRIVATE(msg)));
+                strncat(LIBELF_PRIVATE(msg), ": ", sizeof(LIBELF_PRIVATE(msg)));
+                strncat(LIBELF_PRIVATE(msg), strerror(oserr),
+                    sizeof(LIBELF_PRIVATE(msg)));
+                return (const char *)&LIBELF_PRIVATE(msg);
+        }
+        return _libelf_errors[error];
+}
diff --git a/ext/libelf/elf_errno.c b/ext/libelf/elf_errno.c
new file mode 100644 (file)
index 0000000..f860d1a
--- /dev/null
@@ -0,0 +1,40 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#include "libelf.h"
+
+#include "_libelf.h"
+
+int
+elf_errno(void)
+{
+        int old;
+
+        old = LIBELF_PRIVATE(error);
+        LIBELF_PRIVATE(error) = 0;
+        return (old & LIBELF_ELF_ERROR_MASK);
+}
diff --git a/ext/libelf/elf_fill.c b/ext/libelf/elf_fill.c
new file mode 100644 (file)
index 0000000..7d0ca63
--- /dev/null
@@ -0,0 +1,36 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#include "libelf.h"
+
+#include "_libelf.h"
+
+void
+elf_fill(int fill)
+{
+        LIBELF_PRIVATE(fillchar) = fill;
+}
diff --git a/ext/libelf/elf_flag.c b/ext/libelf/elf_flag.c
new file mode 100644 (file)
index 0000000..234964b
--- /dev/null
@@ -0,0 +1,162 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#include "libelf.h"
+
+#include "_libelf.h"
+
+unsigned int
+elf_flagdata(Elf_Data *d, Elf_Cmd c, unsigned int flags)
+{
+        Elf *e;
+        Elf_Scn *scn;
+        unsigned int r;
+
+        if (d == NULL)
+                return (0);
+
+        if ((c != ELF_C_SET && c != ELF_C_CLR) || (scn = d->d_scn) == NULL ||
+            (e = scn->s_elf) == NULL || e->e_kind != ELF_K_ELF ||
+            (flags & ~ELF_F_DIRTY) != 0) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        if (c == ELF_C_SET)
+            r = scn->s_flags |= flags;
+        else
+            r = scn->s_flags &= ~flags;
+
+        return (r);
+}
+
+unsigned int
+elf_flagehdr(Elf *e, Elf_Cmd c, unsigned int flags)
+{
+        int ec;
+        void *ehdr;
+
+        if (e == NULL)
+                return (0);
+
+        if ((c != ELF_C_SET && c != ELF_C_CLR) ||
+            (e->e_kind != ELF_K_ELF) || (flags & ~ELF_F_DIRTY) != 0 ||
+            ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        if (ec == ELFCLASS32)
+                ehdr = e->e_u.e_elf.e_ehdr.e_ehdr32;
+        else
+                ehdr = e->e_u.e_elf.e_ehdr.e_ehdr64;
+
+        if (ehdr == NULL) {
+                LIBELF_SET_ERROR(SEQUENCE, 0);
+                return (0);
+        }
+
+        return (elf_flagelf(e, c, flags));
+}
+
+unsigned int
+elf_flagelf(Elf *e, Elf_Cmd c, unsigned int flags)
+{
+        int r;
+
+        if (e == NULL)
+                return (0);
+
+        if ((c != ELF_C_SET && c != ELF_C_CLR) ||
+            (e->e_kind != ELF_K_ELF) ||
+            (flags & ~(ELF_F_DIRTY|ELF_F_LAYOUT)) != 0) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        if (c == ELF_C_SET)
+                r = e->e_flags |= flags;
+        else
+                r = e->e_flags &= ~flags;
+        return (r);
+}
+
+unsigned int
+elf_flagphdr(Elf *e, Elf_Cmd c, unsigned int flags)
+{
+        int ec;
+        void *phdr;
+
+        if (e == NULL)
+                return (0);
+
+        if ((c != ELF_C_SET && c != ELF_C_CLR) ||
+            (e->e_kind != ELF_K_ELF) || (flags & ~ELF_F_DIRTY) != 0 ||
+            ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        if (ec == ELFCLASS32)
+                phdr = e->e_u.e_elf.e_phdr.e_phdr32;
+        else
+                phdr = e->e_u.e_elf.e_phdr.e_phdr64;
+
+        if (phdr == NULL) {
+                LIBELF_SET_ERROR(SEQUENCE, 0);
+                return (0);
+        }
+
+        return (elf_flagelf(e, c, flags));
+}
+
+unsigned int
+elf_flagscn(Elf_Scn *s, Elf_Cmd c, unsigned int flags)
+{
+        int r;
+
+        if (s == NULL)
+                return (0);
+
+        if ((c != ELF_C_SET && c != ELF_C_CLR) ||
+            (flags & ~ELF_F_DIRTY) != 0) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        if (c == ELF_C_SET)
+                r = s->s_flags |= flags;
+        else
+                r = s->s_flags &= ~flags;
+        return (r);
+}
+
+unsigned int
+elf_flagshdr(Elf_Scn *s, Elf_Cmd c, unsigned int flags)
+{
+        return (elf_flagscn(s, c, flags));
+}
diff --git a/ext/libelf/elf_getarhdr.c b/ext/libelf/elf_getarhdr.c
new file mode 100644 (file)
index 0000000..e8456c2
--- /dev/null
@@ -0,0 +1,46 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#include "libelf.h"
+
+#include "_libelf.h"
+
+Elf_Arhdr *
+elf_getarhdr(Elf *e)
+{
+        Elf_Arhdr *arh;
+
+        if (e == NULL) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        if ((arh = e->e_arhdr) != NULL)
+                return (arh);
+
+        return (_libelf_ar_gethdr(e));
+}
diff --git a/ext/libelf/elf_getarsym.c b/ext/libelf/elf_getarsym.c
new file mode 100644 (file)
index 0000000..fc71dec
--- /dev/null
@@ -0,0 +1,54 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#include "libelf.h"
+
+#include "_libelf.h"
+
+Elf_Arsym *
+elf_getarsym(Elf *ar, size_t *ptr)
+{
+        size_t n;
+        Elf_Arsym *symtab;
+
+        n = 0;
+        symtab = NULL;
+
+        if (ar == NULL || ar->e_kind != ELF_K_AR)
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+        else if ((symtab = ar->e_u.e_ar.e_symtab) != NULL)
+                n = ar->e_u.e_ar.e_symtabsz;
+        else if (ar->e_u.e_ar.e_rawsymtab)
+                symtab = _libelf_ar_process_symtab(ar, &n);
+        else
+                LIBELF_SET_ERROR(ARCHIVE, 0);
+
+        if (ptr)
+                *ptr = n;
+        return (symtab);
+}
+
diff --git a/ext/libelf/elf_getbase.c b/ext/libelf/elf_getbase.c
new file mode 100644 (file)
index 0000000..28f097a
--- /dev/null
@@ -0,0 +1,43 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#include "libelf.h"
+
+#include "_libelf.h"
+
+off_t
+elf_getbase(Elf *e)
+{
+        if (e == NULL ||
+            e->e_parent == NULL) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (off_t) -1;
+        }
+
+        return ((off_t) ((uintptr_t) e->e_rawfile -
+            (uintptr_t) e->e_parent->e_rawfile));
+}
diff --git a/ext/libelf/elf_getident.c b/ext/libelf/elf_getident.c
new file mode 100644 (file)
index 0000000..41d09da
--- /dev/null
@@ -0,0 +1,65 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#include <ar.h>
+#include <assert.h>
+#include "libelf.h"
+
+#include "_libelf.h"
+
+char *
+elf_getident(Elf *e, size_t *sz)
+{
+
+        if (e == NULL) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                goto error;
+        }
+
+        if (e->e_cmd == ELF_C_WRITE && e->e_rawfile == NULL) {
+                LIBELF_SET_ERROR(SEQUENCE, 0);
+                goto error;
+        }
+
+        assert(e->e_kind != ELF_K_AR || e->e_cmd == ELF_C_READ);
+
+        if (sz) {
+                if (e->e_kind == ELF_K_AR)
+                        *sz = SARMAG;
+                else if (e->e_kind == ELF_K_ELF)
+                        *sz = EI_NIDENT;
+                else
+                        *sz = e->e_rawsize;
+        }
+
+        return (e->e_rawfile);
+
+ error:
+        if (sz)
+                *sz = 0;
+        return (NULL);
+}
diff --git a/ext/libelf/elf_hash.c b/ext/libelf/elf_hash.c
new file mode 100644 (file)
index 0000000..b2e4a0a
--- /dev/null
@@ -0,0 +1,52 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#include "libelf.h"
+
+/*
+ * This elf_hash function is defined by the System V ABI.  It must be
+ * kept compatible with "src/libexec/rtld-elf/rtld.c".
+ */
+
+unsigned long
+elf_hash(const char *name)
+{
+        unsigned long h, t;
+        const unsigned char *s;
+
+        s = (const unsigned char *) name;
+        h = t = 0;
+
+        for (; *s != '\0'; h = h & ~t) {
+                h = (h << 4) + *s++;
+                t = h & 0xF0000000UL;
+                if (t)
+                        h ^= t >> 24;
+        }
+
+        return (h);
+}
diff --git a/ext/libelf/elf_kind.c b/ext/libelf/elf_kind.c
new file mode 100644 (file)
index 0000000..8f4b1b6
--- /dev/null
@@ -0,0 +1,41 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#include "libelf.h"
+
+#include "_libelf.h"
+
+Elf_Kind
+elf_kind(Elf *e)
+{
+        if (e == NULL)
+                return (ELF_K_NONE);
+        if (e->e_kind == ELF_K_AR ||
+            e->e_kind == ELF_K_ELF)
+                return (e->e_kind);
+        return (ELF_K_NONE);
+}
diff --git a/ext/libelf/elf_memory.c b/ext/libelf/elf_memory.c
new file mode 100644 (file)
index 0000000..07c645b
--- /dev/null
@@ -0,0 +1,89 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#include <ar.h>
+#include "libelf.h"
+#include <string.h>
+
+#include "_libelf.h"
+
+Elf *
+elf_memory(char *image, size_t sz)
+{
+        Elf *e;
+
+        if (LIBELF_PRIVATE(version) == EV_NONE) {
+                LIBELF_SET_ERROR(SEQUENCE, 0);
+                return (NULL);
+        }
+
+        if (image == NULL || sz == 0) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        if ((e = _libelf_allocate_elf()) == NULL)
+                return (NULL);
+
+        e->e_cmd = ELF_C_READ;
+        e->e_rawfile = image;
+        e->e_rawsize = sz;
+
+#undef LIBELF_IS_ELF
+#define        LIBELF_IS_ELF(P) ((P)[EI_MAG0] == ELFMAG0 &&            \
+        (P)[EI_MAG1] == ELFMAG1 && (P)[EI_MAG2] == ELFMAG2 &&  \
+        (P)[EI_MAG3] == ELFMAG3)
+
+        if (sz > EI_NIDENT && LIBELF_IS_ELF(image)) {
+                _libelf_init_elf(e, ELF_K_ELF);
+                e->e_class = image[EI_CLASS];
+                e->e_byteorder = image[EI_DATA];
+                e->e_version = image[EI_VERSION];
+
+                if (e->e_version > EV_CURRENT) {
+                        e = _libelf_release_elf(e);
+                        LIBELF_SET_ERROR(VERSION, 0);
+                        return (NULL);
+                }
+
+                if ((e->e_byteorder != ELFDATA2LSB && e->e_byteorder !=
+                    ELFDATA2MSB) || (e->e_class != ELFCLASS32 && e->e_class !=
+                    ELFCLASS64)) {
+                        e = _libelf_release_elf(e);
+                        LIBELF_SET_ERROR(HEADER, 0);
+                        return (NULL);
+                }
+
+        } else if (sz >= SARMAG &&
+            strncmp(image, ARMAG, (size_t) SARMAG) == 0) {
+                _libelf_init_elf(e, ELF_K_AR);
+                e = _libelf_ar_open(e);
+        } else
+                _libelf_init_elf(e, ELF_K_NONE);
+
+        return (e);
+}
diff --git a/ext/libelf/elf_next.c b/ext/libelf/elf_next.c
new file mode 100644 (file)
index 0000000..1b1c409
--- /dev/null
@@ -0,0 +1,59 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#include <ar.h>
+#include <assert.h>
+#include "libelf.h"
+
+#include "_libelf.h"
+
+Elf_Cmd
+elf_next(Elf *e)
+{
+        off_t next;
+        Elf *parent;
+
+        if (e == NULL)
+                return (ELF_C_NULL);
+
+         if ((parent = e->e_parent) == NULL) {
+                 LIBELF_SET_ERROR(ARGUMENT, 0);
+                 return (ELF_C_NULL);
+         }
+
+        assert (parent->e_kind == ELF_K_AR);
+        assert (parent->e_cmd == ELF_C_READ);
+        assert((uintptr_t) e->e_rawfile % 2 == 0);
+        assert(e->e_rawfile > parent->e_rawfile);
+
+        next = e->e_rawfile - parent->e_rawfile + e->e_rawsize;
+        next = (next + 1) & ~1;        /* round up to an even boundary */
+
+        parent->e_u.e_ar.e_next = (next >= (off_t) parent->e_rawsize) ? (off_t) 0 : next;
+
+        return (ELF_C_READ);
+}
diff --git a/ext/libelf/elf_phnum.c b/ext/libelf/elf_phnum.c
new file mode 100644 (file)
index 0000000..0f0c5aa
--- /dev/null
@@ -0,0 +1,51 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#include <ar.h>
+#include "libelf.h"
+
+#include "_libelf.h"
+
+int
+elf_getphnum(Elf *e, size_t *phnum)
+{
+        void *eh;
+        int ec;
+
+        if (e == NULL || e->e_kind != ELF_K_ELF ||
+            ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        if ((eh = _libelf_ehdr(e, ec, 0)) == NULL)
+                return (0);
+
+        *phnum = e->e_u.e_elf.e_nphdr;
+
+        return (1);
+}
diff --git a/ext/libelf/elf_queue.h b/ext/libelf/elf_queue.h
new file mode 100644 (file)
index 0000000..37456dd
--- /dev/null
@@ -0,0 +1,616 @@
+/*-
+ * Copyright (c) 1991, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     @(#)queue.h     8.5 (Berkeley) 8/20/94
+ * $FreeBSD: src/sys/sys/queue.h,v 1.68 2006/10/24 11:20:29 ru Exp $
+ */
+
+#ifndef _SYS_QUEUE_H_
+#define        _SYS_QUEUE_H_
+
+/*
+ * This file defines four types of data structures: singly-linked lists,
+ * singly-linked tail queues, lists and tail queues.
+ *
+ * A singly-linked list is headed by a single forward pointer. The elements
+ * are singly linked for minimum space and pointer manipulation overhead at
+ * the expense of O(n) removal for arbitrary elements. New elements can be
+ * added to the list after an existing element or at the head of the list.
+ * Elements being removed from the head of the list should use the explicit
+ * macro for this purpose for optimum efficiency. A singly-linked list may
+ * only be traversed in the forward direction.  Singly-linked lists are ideal
+ * for applications with large datasets and few or no removals or for
+ * implementing a LIFO queue.
+ *
+ * A singly-linked tail queue is headed by a pair of pointers, one to the
+ * head of the list and the other to the tail of the list. The elements are
+ * singly linked for minimum space and pointer manipulation overhead at the
+ * expense of O(n) removal for arbitrary elements. New elements can be added
+ * to the list after an existing element, at the head of the list, or at the
+ * end of the list. Elements being removed from the head of the tail queue
+ * should use the explicit macro for this purpose for optimum efficiency.
+ * A singly-linked tail queue may only be traversed in the forward direction.
+ * Singly-linked tail queues are ideal for applications with large datasets
+ * and few or no removals or for implementing a FIFO queue.
+ *
+ * A list is headed by a single forward pointer (or an array of forward
+ * pointers for a hash table header). The elements are doubly linked
+ * so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before
+ * or after an existing element or at the head of the list. A list
+ * may only be traversed in the forward direction.
+ *
+ * A tail queue is headed by a pair of pointers, one to the head of the
+ * list and the other to the tail of the list. The elements are doubly
+ * linked so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before or
+ * after an existing element, at the head of the list, or at the end of
+ * the list. A tail queue may be traversed in either direction.
+ *
+ * For details on the use of these macros, see the queue(3) manual page.
+ *
+ *
+ *                             SLIST   LIST    STAILQ  TAILQ
+ * _HEAD                       +       +       +       +
+ * _HEAD_INITIALIZER           +       +       +       +
+ * _ENTRY                      +       +       +       +
+ * _INIT                       +       +       +       +
+ * _EMPTY                      +       +       +       +
+ * _FIRST                      +       +       +       +
+ * _NEXT                       +       +       +       +
+ * _PREV                       -       -       -       +
+ * _LAST                       -       -       +       +
+ * _FOREACH                    +       +       +       +
+ * _FOREACH_SAFE               +       +       +       +
+ * _FOREACH_REVERSE            -       -       -       +
+ * _FOREACH_REVERSE_SAFE       -       -       -       +
+ * _INSERT_HEAD                        +       +       +       +
+ * _INSERT_BEFORE              -       +       -       +
+ * _INSERT_AFTER               +       +       +       +
+ * _INSERT_TAIL                        -       -       +       +
+ * _CONCAT                     -       -       +       +
+ * _REMOVE_HEAD                        +       -       +       -
+ * _REMOVE                     +       +       +       +
+ *
+ */
+#ifdef QUEUE_MACRO_DEBUG
+/* Store the last 2 places the queue element or head was altered */
+struct qm_trace {
+        char * lastfile;
+        int lastline;
+        char * prevfile;
+        int prevline;
+};
+
+#define        TRACEBUF        struct qm_trace trace;
+#define        TRASHIT(x)      do {(x) = (void *)-1;} while (0)
+
+#define        QMD_TRACE_HEAD(head) do {                                       \
+        (head)->trace.prevline = (head)->trace.lastline;               \
+        (head)->trace.prevfile = (head)->trace.lastfile;               \
+        (head)->trace.lastline = __LINE__;                             \
+        (head)->trace.lastfile = __FILE__;                             \
+} while (0)
+
+#define        QMD_TRACE_ELEM(elem) do {                                       \
+        (elem)->trace.prevline = (elem)->trace.lastline;               \
+        (elem)->trace.prevfile = (elem)->trace.lastfile;               \
+        (elem)->trace.lastline = __LINE__;                             \
+        (elem)->trace.lastfile = __FILE__;                             \
+} while (0)
+
+#else
+#define        QMD_TRACE_ELEM(elem)
+#define        QMD_TRACE_HEAD(head)
+#define        TRACEBUF
+#define        TRASHIT(x)
+#endif /* QUEUE_MACRO_DEBUG */
+
+/*
+ * Singly-linked List declarations.
+ */
+#define        SLIST_HEAD(name, type)                                          \
+struct name {                                                          \
+        struct type *slh_first;        /* first element */                     \
+}
+
+#define        SLIST_HEAD_INITIALIZER(head)                                    \
+        { NULL }
+
+#define        SLIST_ENTRY(type)                                               \
+struct {                                                               \
+        struct type *sle_next; /* next element */                      \
+}
+
+/*
+ * Singly-linked List functions.
+ */
+#define        SLIST_EMPTY(head)       ((head)->slh_first == NULL)
+
+#define        SLIST_FIRST(head)       ((head)->slh_first)
+
+#define        SLIST_FOREACH(var, head, field)                                 \
+        for ((var) = SLIST_FIRST((head));                              \
+            (var);                                                     \
+            (var) = SLIST_NEXT((var), field))
+
+#define        SLIST_FOREACH_SAFE(var, head, field, tvar)                      \
+        for ((var) = SLIST_FIRST((head));                              \
+            (var) && ((tvar) = SLIST_NEXT((var), field), 1);           \
+            (var) = (tvar))
+
+#define        SLIST_FOREACH_PREVPTR(var, varp, head, field)                   \
+        for ((varp) = &SLIST_FIRST((head));                            \
+            ((var) = *(varp)) != NULL;                                 \
+            (varp) = &SLIST_NEXT((var), field))
+
+#define        SLIST_INIT(head) do {                                           \
+        SLIST_FIRST((head)) = NULL;                                    \
+} while (0)
+
+#define        SLIST_INSERT_AFTER(slistelm, elm, field) do {                   \
+        SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field);      \
+        SLIST_NEXT((slistelm), field) = (elm);                         \
+} while (0)
+
+#define        SLIST_INSERT_HEAD(head, elm, field) do {                        \
+        SLIST_NEXT((elm), field) = SLIST_FIRST((head));                        \
+        SLIST_FIRST((head)) = (elm);                                   \
+} while (0)
+
+#define        SLIST_NEXT(elm, field)  ((elm)->field.sle_next)
+
+#define        SLIST_REMOVE(head, elm, type, field) do {                       \
+        if (SLIST_FIRST((head)) == (elm)) {                            \
+                SLIST_REMOVE_HEAD((head), field);                      \
+        }                                                              \
+        else {                                                         \
+                struct type *curelm = SLIST_FIRST((head));             \
+                while (SLIST_NEXT(curelm, field) != (elm))             \
+                        curelm = SLIST_NEXT(curelm, field);            \
+                SLIST_NEXT(curelm, field) =                            \
+                    SLIST_NEXT(SLIST_NEXT(curelm, field), field);      \
+        }                                                              \
+        TRASHIT((elm)->field.sle_next);                                        \
+} while (0)
+
+#define        SLIST_REMOVE_HEAD(head, field) do {                             \
+        SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field);  \
+} while (0)
+
+/*
+ * Singly-linked Tail queue declarations.
+ */
+#define        STAILQ_HEAD(name, type)                                         \
+struct name {                                                          \
+        struct type *stqh_first;/* first element */                    \
+        struct type **stqh_last;/* addr of last next element */                \
+}
+
+#define        STAILQ_HEAD_INITIALIZER(head)                                   \
+        { NULL, &(head).stqh_first }
+
+#define        STAILQ_ENTRY(type)                                              \
+struct {                                                               \
+        struct type *stqe_next;        /* next element */                      \
+}
+
+/*
+ * Singly-linked Tail queue functions.
+ */
+#define        STAILQ_CONCAT(head1, head2) do {                                \
+        if (!STAILQ_EMPTY((head2))) {                                  \
+                *(head1)->stqh_last = (head2)->stqh_first;             \
+                (head1)->stqh_last = (head2)->stqh_last;               \
+                STAILQ_INIT((head2));                                  \
+        }                                                              \
+} while (0)
+
+#define        STAILQ_EMPTY(head)      ((head)->stqh_first == NULL)
+
+#define        STAILQ_FIRST(head)      ((head)->stqh_first)
+
+#define        STAILQ_FOREACH(var, head, field)                                \
+        for((var) = STAILQ_FIRST((head));                              \
+           (var);                                                      \
+           (var) = STAILQ_NEXT((var), field))
+
+
+#define        STAILQ_FOREACH_SAFE(var, head, field, tvar)                     \
+        for ((var) = STAILQ_FIRST((head));                             \
+            (var) && ((tvar) = STAILQ_NEXT((var), field), 1);          \
+            (var) = (tvar))
+
+#define        STAILQ_INIT(head) do {                                          \
+        STAILQ_FIRST((head)) = NULL;                                   \
+        (head)->stqh_last = &STAILQ_FIRST((head));                     \
+} while (0)
+
+#define        STAILQ_INSERT_AFTER(head, tqelm, elm, field) do {               \
+        if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\
+                (head)->stqh_last = &STAILQ_NEXT((elm), field);                \
+        STAILQ_NEXT((tqelm), field) = (elm);                           \
+} while (0)
+
+#define        STAILQ_INSERT_HEAD(head, elm, field) do {                       \
+        if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL)        \
+                (head)->stqh_last = &STAILQ_NEXT((elm), field);                \
+        STAILQ_FIRST((head)) = (elm);                                  \
+} while (0)
+
+#define        STAILQ_INSERT_TAIL(head, elm, field) do {                       \
+        STAILQ_NEXT((elm), field) = NULL;                              \
+        *(head)->stqh_last = (elm);                                    \
+        (head)->stqh_last = &STAILQ_NEXT((elm), field);                        \
+} while (0)
+
+#define        STAILQ_LAST(head, type, field)                                  \
+        (STAILQ_EMPTY((head)) ?                                                \
+                NULL :                                                 \
+                ((struct type *)(void *)                               \
+                ((char *)((head)->stqh_last) - offsetof(struct type, field))))
+
+#define        STAILQ_NEXT(elm, field) ((elm)->field.stqe_next)
+
+#define        STAILQ_REMOVE(head, elm, type, field) do {                      \
+        if (STAILQ_FIRST((head)) == (elm)) {                           \
+                STAILQ_REMOVE_HEAD((head), field);                     \
+        }                                                              \
+        else {                                                         \
+                struct type *curelm = STAILQ_FIRST((head));            \
+                while (STAILQ_NEXT(curelm, field) != (elm))            \
+                        curelm = STAILQ_NEXT(curelm, field);           \
+                if ((STAILQ_NEXT(curelm, field) =                      \
+                     STAILQ_NEXT(STAILQ_NEXT(curelm, field), field)) == NULL)\
+                        (head)->stqh_last = &STAILQ_NEXT((curelm), field);\
+        }                                                              \
+        TRASHIT((elm)->field.stqe_next);                               \
+} while (0)
+
+#define        STAILQ_REMOVE_HEAD(head, field) do {                            \
+        if ((STAILQ_FIRST((head)) =                                    \
+             STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL)                \
+                (head)->stqh_last = &STAILQ_FIRST((head));             \
+} while (0)
+
+/*
+ * List declarations.
+ */
+#define        LIST_HEAD(name, type)                                           \
+struct name {                                                          \
+        struct type *lh_first; /* first element */                     \
+}
+
+#define        LIST_HEAD_INITIALIZER(head)                                     \
+        { NULL }
+
+#define        LIST_ENTRY(type)                                                \
+struct {                                                               \
+        struct type *le_next;  /* next element */                      \
+        struct type **le_prev; /* address of previous next element */  \
+}
+
+/*
+ * List functions.
+ */
+
+#if (defined(_KERNEL) && defined(INVARIANTS))
+#define        QMD_LIST_CHECK_HEAD(head, field) do {                           \
+        if (LIST_FIRST((head)) != NULL &&                              \
+            LIST_FIRST((head))->field.le_prev !=                       \
+             &LIST_FIRST((head)))                                      \
+                panic("Bad list head %p first->prev != head", (head)); \
+} while (0)
+
+#define        QMD_LIST_CHECK_NEXT(elm, field) do {                            \
+        if (LIST_NEXT((elm), field) != NULL &&                         \
+            LIST_NEXT((elm), field)->field.le_prev !=                  \
+             &((elm)->field.le_next))                                  \
+                panic("Bad link elm %p next->prev != elm", (elm));     \
+} while (0)
+
+#define        QMD_LIST_CHECK_PREV(elm, field) do {                            \
+        if (*(elm)->field.le_prev != (elm))                            \
+                panic("Bad link elm %p prev->next != elm", (elm));     \
+} while (0)
+#else
+#define        QMD_LIST_CHECK_HEAD(head, field)
+#define        QMD_LIST_CHECK_NEXT(elm, field)
+#define        QMD_LIST_CHECK_PREV(elm, field)
+#endif /* (_KERNEL && INVARIANTS) */
+
+#define        LIST_EMPTY(head)        ((head)->lh_first == NULL)
+
+#define        LIST_FIRST(head)        ((head)->lh_first)
+
+#define        LIST_FOREACH(var, head, field)                                  \
+        for ((var) = LIST_FIRST((head));                               \
+            (var);                                                     \
+            (var) = LIST_NEXT((var), field))
+
+#define        LIST_FOREACH_SAFE(var, head, field, tvar)                       \
+        for ((var) = LIST_FIRST((head));                               \
+            (var) && ((tvar) = LIST_NEXT((var), field), 1);            \
+            (var) = (tvar))
+
+#define        LIST_INIT(head) do {                                            \
+        LIST_FIRST((head)) = NULL;                                     \
+} while (0)
+
+#define        LIST_INSERT_AFTER(listelm, elm, field) do {                     \
+        QMD_LIST_CHECK_NEXT(listelm, field);                           \
+        if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\
+                LIST_NEXT((listelm), field)->field.le_prev =           \
+                    &LIST_NEXT((elm), field);                          \
+        LIST_NEXT((listelm), field) = (elm);                           \
+        (elm)->field.le_prev = &LIST_NEXT((listelm), field);           \
+} while (0)
+
+#define        LIST_INSERT_BEFORE(listelm, elm, field) do {                    \
+        QMD_LIST_CHECK_PREV(listelm, field);                           \
+        (elm)->field.le_prev = (listelm)->field.le_prev;               \
+        LIST_NEXT((elm), field) = (listelm);                           \
+        *(listelm)->field.le_prev = (elm);                             \
+        (listelm)->field.le_prev = &LIST_NEXT((elm), field);           \
+} while (0)
+
+#define        LIST_INSERT_HEAD(head, elm, field) do {                         \
+        QMD_LIST_CHECK_HEAD((head), field);                            \
+        if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL)    \
+                LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\
+        LIST_FIRST((head)) = (elm);                                    \
+        (elm)->field.le_prev = &LIST_FIRST((head));                    \
+} while (0)
+
+#define        LIST_NEXT(elm, field)   ((elm)->field.le_next)
+
+#define        LIST_REMOVE(elm, field) do {                                    \
+        QMD_LIST_CHECK_NEXT(elm, field);                               \
+        QMD_LIST_CHECK_PREV(elm, field);                               \
+        if (LIST_NEXT((elm), field) != NULL)                           \
+                LIST_NEXT((elm), field)->field.le_prev =               \
+                    (elm)->field.le_prev;                              \
+        *(elm)->field.le_prev = LIST_NEXT((elm), field);               \
+        TRASHIT((elm)->field.le_next);                                 \
+        TRASHIT((elm)->field.le_prev);                                 \
+} while (0)
+
+/*
+ * Tail queue declarations.
+ */
+#define        TAILQ_HEAD(name, type)                                          \
+struct name {                                                          \
+        struct type *tqh_first;        /* first element */                     \
+        struct type **tqh_last;        /* addr of last next element */         \
+        TRACEBUF                                                       \
+}
+
+#define        TAILQ_HEAD_INITIALIZER(head)                                    \
+        { NULL, &(head).tqh_first }
+
+#define        TAILQ_ENTRY(type)                                               \
+struct {                                                               \
+        struct type *tqe_next; /* next element */                      \
+        struct type **tqe_prev;        /* address of previous next element */  \
+        TRACEBUF                                                       \
+}
+
+/*
+ * Tail queue functions.
+ */
+#if (defined(_KERNEL) && defined(INVARIANTS))
+#define        QMD_TAILQ_CHECK_HEAD(head, field) do {                          \
+        if (!TAILQ_EMPTY(head) &&                                      \
+            TAILQ_FIRST((head))->field.tqe_prev !=                     \
+             &TAILQ_FIRST((head)))                                     \
+                panic("Bad tailq head %p first->prev != head", (head));        \
+} while (0)
+
+#define        QMD_TAILQ_CHECK_TAIL(head, field) do {                          \
+        if (*(head)->tqh_last != NULL)                                 \
+                panic("Bad tailq NEXT(%p->tqh_last) != NULL", (head));         \
+} while (0)
+
+#define        QMD_TAILQ_CHECK_NEXT(elm, field) do {                           \
+        if (TAILQ_NEXT((elm), field) != NULL &&                                \
+            TAILQ_NEXT((elm), field)->field.tqe_prev !=                        \
+             &((elm)->field.tqe_next))                                 \
+                panic("Bad link elm %p next->prev != elm", (elm));     \
+} while (0)
+
+#define        QMD_TAILQ_CHECK_PREV(elm, field) do {                           \
+        if (*(elm)->field.tqe_prev != (elm))                           \
+                panic("Bad link elm %p prev->next != elm", (elm));     \
+} while (0)
+#else
+#define        QMD_TAILQ_CHECK_HEAD(head, field)
+#define        QMD_TAILQ_CHECK_TAIL(head, headname)
+#define        QMD_TAILQ_CHECK_NEXT(elm, field)
+#define        QMD_TAILQ_CHECK_PREV(elm, field)
+#endif /* (_KERNEL && INVARIANTS) */
+
+#define        TAILQ_CONCAT(head1, head2, field) do {                          \
+        if (!TAILQ_EMPTY(head2)) {                                     \
+                *(head1)->tqh_last = (head2)->tqh_first;               \
+                (head2)->tqh_first->field.tqe_prev = (head1)->tqh_last;        \
+                (head1)->tqh_last = (head2)->tqh_last;                 \
+                TAILQ_INIT((head2));                                   \
+                QMD_TRACE_HEAD(head1);                                 \
+                QMD_TRACE_HEAD(head2);                                 \
+        }                                                              \
+} while (0)
+
+#define        TAILQ_EMPTY(head)       ((head)->tqh_first == NULL)
+
+#define        TAILQ_FIRST(head)       ((head)->tqh_first)
+
+#define        TAILQ_FOREACH(var, head, field)                                 \
+        for ((var) = TAILQ_FIRST((head));                              \
+            (var);                                                     \
+            (var) = TAILQ_NEXT((var), field))
+
+#define        TAILQ_FOREACH_SAFE(var, head, field, tvar)                      \
+        for ((var) = TAILQ_FIRST((head));                              \
+            (var) && ((tvar) = TAILQ_NEXT((var), field), 1);           \
+            (var) = (tvar))
+
+#define        TAILQ_FOREACH_REVERSE(var, head, headname, field)               \
+        for ((var) = TAILQ_LAST((head), headname);                     \
+            (var);                                                     \
+            (var) = TAILQ_PREV((var), headname, field))
+
+#define        TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar)    \
+        for ((var) = TAILQ_LAST((head), headname);                     \
+            (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1); \
+            (var) = (tvar))
+
+#define        TAILQ_INIT(head) do {                                           \
+        TAILQ_FIRST((head)) = NULL;                                    \
+        (head)->tqh_last = &TAILQ_FIRST((head));                       \
+        QMD_TRACE_HEAD(head);                                          \
+} while (0)
+
+#define        TAILQ_INSERT_AFTER(head, listelm, elm, field) do {              \
+        QMD_TAILQ_CHECK_NEXT(listelm, field);                          \
+        if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\
+                TAILQ_NEXT((elm), field)->field.tqe_prev =             \
+                    &TAILQ_NEXT((elm), field);                         \
+        else {                                                         \
+                (head)->tqh_last = &TAILQ_NEXT((elm), field);          \
+                QMD_TRACE_HEAD(head);                                  \
+        }                                                              \
+        TAILQ_NEXT((listelm), field) = (elm);                          \
+        (elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field);         \
+        QMD_TRACE_ELEM(&(elm)->field);                                 \
+        QMD_TRACE_ELEM(&listelm->field);                               \
+} while (0)
+
+#define        TAILQ_INSERT_BEFORE(listelm, elm, field) do {                   \
+        QMD_TAILQ_CHECK_PREV(listelm, field);                          \
+        (elm)->field.tqe_prev = (listelm)->field.tqe_prev;             \
+        TAILQ_NEXT((elm), field) = (listelm);                          \
+        *(listelm)->field.tqe_prev = (elm);                            \
+        (listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field);         \
+        QMD_TRACE_ELEM(&(elm)->field);                                 \
+        QMD_TRACE_ELEM(&listelm->field);                               \
+} while (0)
+
+#define        TAILQ_INSERT_HEAD(head, elm, field) do {                        \
+        QMD_TAILQ_CHECK_HEAD(head, field);                             \
+        if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL)  \
+                TAILQ_FIRST((head))->field.tqe_prev =                  \
+                    &TAILQ_NEXT((elm), field);                         \
+        else                                                           \
+                (head)->tqh_last = &TAILQ_NEXT((elm), field);          \
+        TAILQ_FIRST((head)) = (elm);                                   \
+        (elm)->field.tqe_prev = &TAILQ_FIRST((head));                  \
+        QMD_TRACE_HEAD(head);                                          \
+        QMD_TRACE_ELEM(&(elm)->field);                                 \
+} while (0)
+
+#define        TAILQ_INSERT_TAIL(head, elm, field) do {                        \
+        QMD_TAILQ_CHECK_TAIL(head, field);                             \
+        TAILQ_NEXT((elm), field) = NULL;                               \
+        (elm)->field.tqe_prev = (head)->tqh_last;                      \
+        *(head)->tqh_last = (elm);                                     \
+        (head)->tqh_last = &TAILQ_NEXT((elm), field);                  \
+        QMD_TRACE_HEAD(head);                                          \
+        QMD_TRACE_ELEM(&(elm)->field);                                 \
+} while (0)
+
+#define        TAILQ_LAST(head, headname)                                      \
+        (*(((struct headname *)((head)->tqh_last))->tqh_last))
+
+#define        TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
+
+#define        TAILQ_PREV(elm, headname, field)                                \
+        (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
+
+#define        TAILQ_REMOVE(head, elm, field) do {                             \
+        QMD_TAILQ_CHECK_NEXT(elm, field);                              \
+        QMD_TAILQ_CHECK_PREV(elm, field);                              \
+        if ((TAILQ_NEXT((elm), field)) != NULL)                                \
+                TAILQ_NEXT((elm), field)->field.tqe_prev =             \
+                    (elm)->field.tqe_prev;                             \
+        else {                                                         \
+                (head)->tqh_last = (elm)->field.tqe_prev;              \
+                QMD_TRACE_HEAD(head);                                  \
+        }                                                              \
+        *(elm)->field.tqe_prev = TAILQ_NEXT((elm), field);             \
+        TRASHIT((elm)->field.tqe_next);                                        \
+        TRASHIT((elm)->field.tqe_prev);                                        \
+        QMD_TRACE_ELEM(&(elm)->field);                                 \
+} while (0)
+
+
+#ifdef _KERNEL
+
+/*
+ * XXX insque() and remque() are an old way of handling certain queues.
+ * They bogusly assumes that all queue heads look alike.
+ */
+
+struct quehead {
+        struct quehead *qh_link;
+        struct quehead *qh_rlink;
+};
+
+#ifdef __CC_SUPPORTS___INLINE
+
+static __inline void
+insque(void *a, void *b)
+{
+        struct quehead *element = (struct quehead *)a,
+                 *head = (struct quehead *)b;
+
+        element->qh_link = head->qh_link;
+        element->qh_rlink = head;
+        head->qh_link = element;
+        element->qh_link->qh_rlink = element;
+}
+
+static __inline void
+remque(void *a)
+{
+        struct quehead *element = (struct quehead *)a;
+
+        element->qh_link->qh_rlink = element->qh_rlink;
+        element->qh_rlink->qh_link = element->qh_link;
+        element->qh_rlink = 0;
+}
+
+#else /* !__CC_SUPPORTS___INLINE */
+
+void   insque(void *a, void *b);
+void   remque(void *a);
+
+#endif /* __CC_SUPPORTS___INLINE */
+
+#endif /* _KERNEL */
+
+#endif /* !_SYS_QUEUE_H_ */
diff --git a/ext/libelf/elf_rand.c b/ext/libelf/elf_rand.c
new file mode 100644 (file)
index 0000000..ac44aea
--- /dev/null
@@ -0,0 +1,56 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#include <ar.h>
+#include "libelf.h"
+
+#include "_libelf.h"
+
+off_t
+elf_rand(Elf *ar, off_t offset)
+{
+        struct ar_hdr *arh;
+
+        if (ar == NULL || ar->e_kind != ELF_K_AR ||
+            (offset & 1) || offset < SARMAG ||
+            offset + sizeof(struct ar_hdr) >= ar->e_rawsize) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return 0;
+        }
+
+        arh = (struct ar_hdr *) (ar->e_rawfile + offset);
+
+        /* a too simple sanity check */
+        if (arh->ar_fmag[0] != '`' || arh->ar_fmag[1] != '\n') {
+                LIBELF_SET_ERROR(ARCHIVE, 0);
+                return 0;
+        }
+
+        ar->e_u.e_ar.e_next = offset;
+
+        return (offset);
+}
diff --git a/ext/libelf/elf_rawfile.c b/ext/libelf/elf_rawfile.c
new file mode 100644 (file)
index 0000000..d926243
--- /dev/null
@@ -0,0 +1,50 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#include "libelf.h"
+
+#include "_libelf.h"
+
+char *
+elf_rawfile(Elf *e, size_t *sz)
+{
+        char *ptr;
+        size_t size;
+
+        size = e ? e->e_rawsize : 0;
+        ptr = NULL;
+
+        if (e == NULL)
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+        else if ((ptr = e->e_rawfile) == NULL && e->e_cmd == ELF_C_WRITE)
+                LIBELF_SET_ERROR(SEQUENCE, 0);
+
+        if (sz)
+                *sz = size;
+
+        return (ptr);
+}
diff --git a/ext/libelf/elf_scn.c b/ext/libelf/elf_scn.c
new file mode 100644 (file)
index 0000000..cf596ba
--- /dev/null
@@ -0,0 +1,227 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#include <assert.h>
+#include <errno.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+#include "gelf.h"
+#include "libelf.h"
+#include "_libelf.h"
+
+/*
+ * Load an ELF section table and create a list of Elf_Scn structures.
+ */
+static int
+_libelf_load_scn(Elf *e, void *ehdr)
+{
+        int ec, swapbytes;
+        size_t fsz, i, shnum;
+        uint64_t shoff;
+        char *src;
+        Elf32_Ehdr *eh32;
+        Elf64_Ehdr *eh64;
+        Elf_Scn *scn;
+        void (*xlator)(char *_d, char *_s, size_t _c, int _swap);
+
+        assert(e != NULL);
+        assert(ehdr != NULL);
+        assert((e->e_flags & LIBELF_F_SHDRS_LOADED) == 0);
+
+#define        CHECK_EHDR(E,EH)        do {                            \
+                if (fsz != (EH)->e_shentsize ||                        \
+                    shoff + fsz * shnum > e->e_rawsize) {      \
+                        LIBELF_SET_ERROR(HEADER, 0);           \
+                        return (0);                            \
+                }                                              \
+        } while (0)
+
+        ec = e->e_class;
+        fsz = _libelf_fsize(ELF_T_SHDR, ec, e->e_version, (size_t) 1);
+        assert(fsz > 0);
+
+        shnum = e->e_u.e_elf.e_nscn;
+
+        if (ec == ELFCLASS32) {
+                eh32 = (Elf32_Ehdr *) ehdr;
+                shoff = (uint64_t) eh32->e_shoff;
+                CHECK_EHDR(e, eh32);
+        } else {
+                eh64 = (Elf64_Ehdr *) ehdr;
+                shoff = eh64->e_shoff;
+                CHECK_EHDR(e, eh64);
+        }
+
+        xlator = _libelf_get_translator(ELF_T_SHDR, ELF_TOMEMORY, ec);
+
+        swapbytes = e->e_byteorder != LIBELF_PRIVATE(byteorder);
+        src = e->e_rawfile + shoff;
+
+        /*
+         * If the file is using extended numbering then section #0
+         * would have already been read in.
+         */
+
+        i = 0;
+        if (!STAILQ_EMPTY(&e->e_u.e_elf.e_scn)) {
+                assert(STAILQ_FIRST(&e->e_u.e_elf.e_scn) ==
+                    STAILQ_LAST(&e->e_u.e_elf.e_scn, _Elf_Scn, s_next));
+
+                i = 1;
+                src += fsz;
+        }
+
+        for (; i < shnum; i++, src += fsz) {
+                if ((scn = _libelf_allocate_scn(e, i)) == NULL)
+                        return (0);
+
+                (*xlator)((char *) &scn->s_shdr, src, (size_t) 1, swapbytes);
+
+                if (ec == ELFCLASS32) {
+                        scn->s_offset = scn->s_rawoff =
+                            scn->s_shdr.s_shdr32.sh_offset;
+                        scn->s_size = scn->s_shdr.s_shdr32.sh_size;
+                } else {
+                        scn->s_offset = scn->s_rawoff =
+                            scn->s_shdr.s_shdr64.sh_offset;
+                        scn->s_size = scn->s_shdr.s_shdr64.sh_size;
+                }
+        }
+
+        e->e_flags |= LIBELF_F_SHDRS_LOADED;
+
+        return (1);
+}
+
+
+Elf_Scn *
+elf_getscn(Elf *e, size_t index)
+{
+        int ec;
+        void *ehdr;
+        Elf_Scn *s;
+
+        if (e == NULL || e->e_kind != ELF_K_ELF ||
+            ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        if ((ehdr = _libelf_ehdr(e, ec, 0)) == NULL)
+                return (NULL);
+
+        if (e->e_cmd != ELF_C_WRITE &&
+            (e->e_flags & LIBELF_F_SHDRS_LOADED) == 0 &&
+            _libelf_load_scn(e, ehdr) == 0)
+                return (NULL);
+
+        STAILQ_FOREACH(s, &e->e_u.e_elf.e_scn, s_next)
+                if (s->s_ndx == index)
+                        return (s);
+
+        LIBELF_SET_ERROR(ARGUMENT, 0);
+        return (NULL);
+}
+
+size_t
+elf_ndxscn(Elf_Scn *s)
+{
+        if (s == NULL) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (SHN_UNDEF);
+        }
+        return (s->s_ndx);
+}
+
+Elf_Scn *
+elf_newscn(Elf *e)
+{
+        int ec;
+        void *ehdr;
+        Elf_Scn *scn;
+
+        if (e == NULL || e->e_kind != ELF_K_ELF) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        if ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64) {
+                LIBELF_SET_ERROR(CLASS, 0);
+                return (NULL);
+        }
+
+        if ((ehdr = _libelf_ehdr(e, ec, 0)) == NULL)
+                return (NULL);
+
+        /*
+         * The application may be asking for a new section descriptor
+         * on an ELF object opened with ELF_C_RDWR or ELF_C_READ.  We
+         * need to bring in the existing section information before
+         * appending a new one to the list.
+         *
+         * Per the ELF(3) API, an application is allowed to open a
+         * file using ELF_C_READ, mess with its internal structure and
+         * use elf_update(...,ELF_C_NULL) to compute its new layout.
+         */
+        if (e->e_cmd != ELF_C_WRITE &&
+            (e->e_flags & LIBELF_F_SHDRS_LOADED) == 0 &&
+            _libelf_load_scn(e, ehdr) == 0)
+                return (NULL);
+
+        if (STAILQ_EMPTY(&e->e_u.e_elf.e_scn)) {
+                assert(e->e_u.e_elf.e_nscn == 0);
+                if ((scn = _libelf_allocate_scn(e, (size_t) SHN_UNDEF)) ==
+                    NULL)
+                        return (NULL);
+                e->e_u.e_elf.e_nscn++;
+        }
+
+        assert(e->e_u.e_elf.e_nscn > 0);
+
+        if ((scn = _libelf_allocate_scn(e, e->e_u.e_elf.e_nscn)) == NULL)
+                return (NULL);
+
+        e->e_u.e_elf.e_nscn++;
+
+        (void) elf_flagscn(scn, ELF_C_SET, ELF_F_DIRTY);
+
+        return (scn);
+}
+
+Elf_Scn *
+elf_nextscn(Elf *e, Elf_Scn *s)
+{
+        if (e == NULL || (e->e_kind != ELF_K_ELF) ||
+            (s && s->s_elf != e)) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        return (s == NULL ? elf_getscn(e, (size_t) 1) :
+            STAILQ_NEXT(s, s_next));
+}
diff --git a/ext/libelf/elf_shnum.c b/ext/libelf/elf_shnum.c
new file mode 100644 (file)
index 0000000..adc77af
--- /dev/null
@@ -0,0 +1,51 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#include <ar.h>
+#include "libelf.h"
+
+#include "_libelf.h"
+
+int
+elf_getshnum(Elf *e, size_t *shnum)
+{
+        void *eh;
+        int ec;
+
+        if (e == NULL || e->e_kind != ELF_K_ELF ||
+            ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        if ((eh = _libelf_ehdr(e, ec, 0)) == NULL)
+                return (0);
+
+        *shnum = e->e_u.e_elf.e_nscn;
+
+        return (1);
+}
diff --git a/ext/libelf/elf_shstrndx.c b/ext/libelf/elf_shstrndx.c
new file mode 100644 (file)
index 0000000..5b9cccd
--- /dev/null
@@ -0,0 +1,67 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#include <ar.h>
+#include "libelf.h"
+
+#include "_libelf.h"
+
+int
+elf_getshstrndx(Elf *e, size_t *strndx)
+{
+        void *eh;
+        int ec;
+
+        if (e == NULL || e->e_kind != ELF_K_ELF ||
+            ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        if ((eh = _libelf_ehdr(e, ec, 0)) == NULL)
+                return (0);
+
+        *strndx = e->e_u.e_elf.e_strndx;
+
+        return (1);
+}
+
+int
+elf_setshstrndx(Elf *e, size_t strndx)
+{
+        void *eh;
+        int ec;
+
+        if (e == NULL || e->e_kind != ELF_K_ELF ||
+            ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64) ||
+            ((eh = _libelf_ehdr(e, ec, 0)) == NULL)) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        return (_libelf_setshstrndx(e, eh, ec, strndx));
+}
diff --git a/ext/libelf/elf_strptr.c b/ext/libelf/elf_strptr.c
new file mode 100644 (file)
index 0000000..6a05fa1
--- /dev/null
@@ -0,0 +1,134 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#include <sys/param.h>
+#ifdef __sun
+#include <sys/sysmacros.h>
+#endif
+
+#include <assert.h>
+#include "gelf.h"
+
+#include "_libelf.h"
+
+/*
+ * Convert an ELF section#,offset pair to a string pointer.
+ */
+
+char *
+elf_strptr(Elf *e, size_t scndx, size_t offset)
+{
+        Elf_Scn *s;
+        Elf_Data *d;
+        size_t alignment, count;
+        GElf_Shdr shdr;
+
+        if (e == NULL || e->e_kind != ELF_K_ELF) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        if ((s = elf_getscn(e, scndx)) == NULL ||
+            gelf_getshdr(s, &shdr) == NULL)
+                return (NULL);
+
+        if (shdr.sh_type != SHT_STRTAB ||
+            offset >= shdr.sh_size) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        d = NULL;
+        if (e->e_flags & ELF_F_LAYOUT) {
+
+                /*
+                 * The application is taking responsibility for the
+                 * ELF object's layout, so we can directly translate
+                 * an offset to a `char *' address using the `d_off'
+                 * members of Elf_Data descriptors.
+                 */
+                while ((d = elf_getdata(s, d)) != NULL) {
+
+                        if (d->d_buf == 0 || d->d_size == 0)
+                                continue;
+
+                        if (d->d_type != ELF_T_BYTE) {
+                                LIBELF_SET_ERROR(DATA, 0);
+                                return (NULL);
+                        }
+
+                        if (offset >= d->d_off &&
+                            offset < d->d_off + d->d_size)
+                                return ((char *) d->d_buf + offset - d->d_off);
+                }
+        } else {
+                /*
+                 * Otherwise, the `d_off' members are not useable and
+                 * we need to compute offsets ourselves, taking into
+                 * account 'holes' in coverage of the section introduced
+                 * by alignment requirements.
+                 */
+                count = (size_t) 0;    /* cumulative count of bytes seen */
+                while ((d = elf_getdata(s, d)) != NULL && count <= offset) {
+
+                        if (d->d_buf == NULL || d->d_size == 0)
+                                continue;
+
+                        if (d->d_type != ELF_T_BYTE) {
+                                LIBELF_SET_ERROR(DATA, 0);
+                                return (NULL);
+                        }
+
+                        if ((alignment = d->d_align) > 1) {
+                                if ((alignment & (alignment - 1)) != 0) {
+                                        LIBELF_SET_ERROR(DATA, 0);
+                                        return (NULL);
+                                }
+                                count = roundup(count, alignment);
+                        }
+
+                        if (offset < count) {
+                                /* offset starts in the 'hole' */
+                                LIBELF_SET_ERROR(ARGUMENT, 0);
+                                return (NULL);
+                        }
+
+                        if (offset < count + d->d_size) {
+                                if (d->d_buf != NULL)
+                                        return ((char *) d->d_buf +
+                                            offset - count);
+                                LIBELF_SET_ERROR(DATA, 0);
+                                return (NULL);
+                        }
+
+                        count += d->d_size;
+                }
+        }
+
+        LIBELF_SET_ERROR(ARGUMENT, 0);
+        return (NULL);
+}
diff --git a/ext/libelf/elf_types.m4 b/ext/libelf/elf_types.m4
new file mode 100644 (file)
index 0000000..a729233
--- /dev/null
@@ -0,0 +1,310 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD: src/lib/libelf/elf_types.m4,v 1.2 2006/12/18 05:40:01 jkoshy Exp $
+ */
+
+/*
+ * ELF types, defined in the "enum Elf_Type" API.
+ *
+ * The members of the list form a 3-tuple: (name, C-type-suffix, OSversion).
+ * + `name' is an Elf_Type symbol without the `ELF_T_' prefix.
+ * + `C-type-suffix' is the suffix for Elf32_ and Elf64_ type names.
+ * + `version' is the OS version the symbol first appeared in.
+ *
+ */
+
+define(`ELF_TYPE_LIST',
+       ``ADDR,         Addr,   600102',
+       `BYTE,          Byte,   600102',
+       `CAP,           Cap,    700025',
+       `DYN,           Dyn,    600102',
+       `EHDR,          Ehdr,   600102',
+       `HALF,          Half,   600102',
+       `LWORD,         Lword,  700025',
+       `MOVE,          Move,   700025',
+       `MOVEP,         MoveP,  700025',
+       `NOTE,          Note,   600102',
+       `OFF,           Off,    600102',
+       `PHDR,          Phdr,   600102',
+       `REL,           Rel,    600102',
+       `RELA,          Rela,   600102',
+       `SHDR,          Shdr,   600102',
+       `SWORD,         Sword,  600102',
+       `SXWORD,        Sxword, 700009',
+       `SYMINFO,       Syminfo, 700025',
+       `SYM,           Sym,    600102',
+       `VDEF,          Verdef, 700009',
+       `VNEED,         Verneed, 700009',
+       `WORD,          Word,   600102',
+       `XWORD,         Xword,  700009',
+       `NUM,           _,      _'')
+
+/*
+ * DEFINE_STRUCT(NAME,MEMBERLIST...)
+ *
+ * Map a type name to its members.
+ *
+ * Each member-list element comprises of pairs of (field name, type),
+ * in the sequence used in the file representation of `NAME'.
+ *
+ * Each member list element comprises a pair containing a field name
+ * and a basic type.  Basic types include IDENT, HALF, WORD, LWORD,
+ * ADDR{32,64}, OFF{32,64}, SWORD, XWORD, SXWORD.
+ *
+ * The last element of a member list is the null element: `_,_'.
+ */
+
+define(`DEFINE_STRUCT',`define(`$1_DEF',shift($@))dnl')
+
+DEFINE_STRUCT(`Elf32_Cap',
+       ``c_tag,        WORD',
+       `c_un.c_val,    WORD',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf64_Cap',
+       ``c_tag,        XWORD',
+       `c_un.c_val,    XWORD',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf32_Dyn',
+       ``d_tag,        SWORD',
+       `d_un.d_ptr,    WORD',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf64_Dyn',
+       ``d_tag,        SXWORD',
+       `d_un.d_ptr,    XWORD',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf32_Ehdr',
+       ``e_ident,      IDENT',
+       `e_type,        HALF',
+       `e_machine,     HALF',
+       `e_version,     WORD',
+       `e_entry,       ADDR',
+       `e_phoff,       OFF',
+       `e_shoff,       OFF',
+       `e_flags,       WORD',
+       `e_ehsize,      HALF',
+       `e_phentsize,   HALF',
+       `e_phnum,       HALF',
+       `e_shentsize,   HALF',
+       `e_shnum,       HALF',
+       `e_shstrndx,    HALF',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf64_Ehdr',
+       ``e_ident,      IDENT',
+       `e_type,        HALF',
+       `e_machine,     HALF',
+       `e_version,     WORD',
+       `e_entry,       ADDR',
+       `e_phoff,       OFF',
+       `e_shoff,       OFF',
+       `e_flags,       WORD',
+       `e_ehsize,      HALF',
+       `e_phentsize,   HALF',
+       `e_phnum,       HALF',
+       `e_shentsize,   HALF',
+       `e_shnum,       HALF',
+       `e_shstrndx,    HALF',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf32_Move',
+       ``m_value,      LWORD',
+       `m_info,        WORD',
+       `m_poffset,     WORD',
+       `m_repeat,      HALF',
+       `m_stride,      HALF',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf64_Move',
+       ``m_value,      LWORD',
+       `m_info,        XWORD',
+       `m_poffset,     XWORD',
+       `m_repeat,      HALF',
+       `m_stride,      HALF',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf32_Phdr',
+       ``p_type,       WORD',
+       `p_offset,      OFF',
+       `p_vaddr,       ADDR',
+       `p_paddr,       ADDR',
+       `p_filesz,      WORD',
+       `p_memsz,       WORD',
+       `p_flags,       WORD',
+       `p_align,       WORD',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf64_Phdr',
+       ``p_type,       WORD',
+       `p_flags,       WORD',
+       `p_offset,      OFF',
+       `p_vaddr,       ADDR',
+       `p_paddr,       ADDR',
+       `p_filesz,      XWORD',
+       `p_memsz,       XWORD',
+       `p_align,       XWORD',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf32_Rel',
+       ``r_offset,     ADDR',
+       `r_info,        WORD',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf64_Rel',
+       ``r_offset,     ADDR',
+       `r_info,        XWORD',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf32_Rela',
+       ``r_offset,     ADDR',
+       `r_info,        WORD',
+       `r_addend,      SWORD',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf64_Rela',
+       ``r_offset,     ADDR',
+       `r_info,        XWORD',
+       `r_addend,      SXWORD',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf32_Shdr',
+       ``sh_name,      WORD',
+       `sh_type,       WORD',
+       `sh_flags,      WORD',
+       `sh_addr,       ADDR',
+       `sh_offset,     OFF',
+       `sh_size,       WORD',
+       `sh_link,       WORD',
+       `sh_info,       WORD',
+       `sh_addralign,  WORD',
+       `sh_entsize,    WORD',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf64_Shdr',
+       ``sh_name,      WORD',
+       `sh_type,       WORD',
+       `sh_flags,      XWORD',
+       `sh_addr,       ADDR',
+       `sh_offset,     OFF',
+       `sh_size,       XWORD',
+       `sh_link,       WORD',
+       `sh_info,       WORD',
+       `sh_addralign,  XWORD',
+       `sh_entsize,    XWORD',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf32_Sym',
+       ``st_name,      WORD',
+       `st_value,      ADDR',
+       `st_size,       WORD',
+       `st_info,       BYTE',
+       `st_other,      BYTE',
+       `st_shndx,      HALF',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf64_Sym',
+       ``st_name,      WORD',
+       `st_info,       BYTE',
+       `st_other,      BYTE',
+       `st_shndx,      HALF',
+       `st_value,      ADDR',
+       `st_size,       XWORD',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf32_Syminfo',
+       ``si_boundto,   HALF',
+       `si_flags,      HALF',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf64_Syminfo',
+       ``si_boundto,   HALF',
+       `si_flags,      HALF',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf32_Verdaux',
+       ``vda_name,     WORD',
+       `vda_next,      WORD',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf64_Verdaux',
+       ``vda_name,     WORD',
+       `vda_next,      WORD',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf32_Verdef',
+       ``vd_version,   HALF',
+       `vd_flags,      HALF',
+       `vd_ndx,        HALF',
+       `vd_cnt,        HALF',
+       `vd_hash,       WORD',
+       `vd_aux,        WORD',
+       `vd_next,       WORD',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf64_Verdef',
+       ``vd_version,   HALF',
+       `vd_flags,      HALF',
+       `vd_ndx,        HALF',
+       `vd_cnt,        HALF',
+       `vd_hash,       WORD',
+       `vd_aux,        WORD',
+       `vd_next,       WORD',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf32_Verneed',
+       ``vn_version,   HALF',
+       `vn_cnt,        HALF',
+       `vn_file,       WORD',
+       `vn_aux,        WORD',
+       `vn_next,       WORD',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf64_Verneed',
+       ``vn_version,   HALF',
+       `vn_cnt,        HALF',
+       `vn_file,       WORD',
+       `vn_aux,        WORD',
+       `vn_next,       WORD',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf32_Vernaux',
+       ``vna_hash,     WORD',
+       `vna_flags,     HALF',
+       `vna_other,     HALF',
+       `vna_name,      WORD',
+       `vna_next,      WORD',
+       `_,_'')
+
+DEFINE_STRUCT(`Elf64_Vernaux',
+       ``vna_hash,     WORD',
+       `vna_flags,     HALF',
+       `vna_other,     HALF',
+       `vna_name,      WORD',
+       `vna_next,      WORD',
+       `_,_'')
diff --git a/ext/libelf/elf_update.c b/ext/libelf/elf_update.c
new file mode 100644 (file)
index 0000000..6959d3c
--- /dev/null
@@ -0,0 +1,885 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#include <sys/mman.h>
+#include <sys/param.h>
+#ifdef __sun
+#include <sys/sysmacros.h>
+#endif
+
+#include <assert.h>
+#include <errno.h>
+#include "gelf.h"
+#include "libelf.h"
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "_libelf.h"
+
+/*
+ * Update the internal data structures associated with an ELF object.
+ * Returns the size in bytes the ELF object would occupy in its file
+ * representation.
+ *
+ * After a successful call to this function, the following structures
+ * are updated:
+ *
+ * - The ELF header is updated.
+ * - All sections are sorted in order of ascending addresses and their
+ *   section header table entries updated.   An error is signalled
+ *   if an overlap was detected among sections.
+ * - All data descriptors associated with a section are sorted in order
+ *   of ascending addresses.  Overlaps, if detected, are signalled as
+ *   errors.  Other sanity checks for alignments, section types etc. are
+ *   made.
+ *
+ * After a resync_elf() successfully returns, the ELF descriptor is
+ * ready for being handed over to _libelf_write_elf().
+ *
+ * File alignments:
+ * PHDR - Addr
+ * SHDR - Addr
+ *
+ * XXX: how do we handle 'flags'.
+ */
+
+/*
+ * Compute the extents of a section, by looking at the.
+ */
+static int
+_libelf_compute_section_extents(Elf *e, Elf_Scn *s, off_t *rc)
+{
+        int ec;
+        Elf_Data *d, *td;
+        unsigned int elftype;
+        uint32_t sh_type;
+        uint64_t d_align;
+        uint64_t sh_align, sh_entsize, sh_offset, sh_size;
+        uint64_t scn_size, scn_alignment;
+
+        /*
+         * We need to recompute library private data structures if one
+         * or more of the following is true:
+         * - The underlying Shdr structure has been marked `dirty'.  Significant
+         *   fields include: `sh_offset', `sh_type', `sh_size', `sh_addralign'.
+         * - The Elf_Data structures part of this section have been marked
+         *   `dirty'.  Affected members include `d_align', `d_offset', `d_type',
+         *   and `d_size'.
+         * - The section as a whole is `dirty', e.g., it has been allocated
+         *   using elf_newscn(), or if a new Elf_Data structure was added using
+         *   elf_newdata().
+         *
+         * Each of these conditions would result in the ELF_F_DIRTY bit being
+         * set on the section descriptor's `s_flags' field.
+         */
+
+        ec = e->e_class;
+
+        if (ec == ELFCLASS32) {
+                sh_type    = s->s_shdr.s_shdr32.sh_type;
+                sh_align   = (uint64_t) s->s_shdr.s_shdr32.sh_addralign;
+                sh_entsize = (uint64_t) s->s_shdr.s_shdr32.sh_entsize;
+                sh_offset  = (uint64_t) s->s_shdr.s_shdr32.sh_offset;
+                sh_size    = (uint64_t) s->s_shdr.s_shdr32.sh_size;
+        } else {
+                sh_type    = s->s_shdr.s_shdr64.sh_type;
+                sh_align   = s->s_shdr.s_shdr64.sh_addralign;
+                sh_entsize = s->s_shdr.s_shdr64.sh_entsize;
+                sh_offset  = s->s_shdr.s_shdr64.sh_offset;
+                sh_size    = s->s_shdr.s_shdr64.sh_size;
+        }
+
+        if (sh_type == SHT_NULL || sh_type == SHT_NOBITS)
+                return (1);
+
+        if ((s->s_flags & ELF_F_DIRTY) == 0) {
+                if ((size_t) *rc < sh_offset + sh_size)
+                        *rc = sh_offset + sh_size;
+                return (1);
+        }
+
+        elftype = _libelf_xlate_shtype(sh_type);
+        if (elftype > ELF_T_LAST) {
+                LIBELF_SET_ERROR(SECTION, 0);
+                return (0);
+        }
+
+        /*
+         * Compute the extent of the data descriptors associated with
+         * this section.
+         */
+        scn_alignment = 0;
+        if (sh_align == 0)
+                sh_align = _libelf_falign(elftype, ec);
+
+        /* Compute the section alignment. */
+        STAILQ_FOREACH(d, &s->s_data, d_next)  {
+                if (d->d_type != elftype) {
+                        LIBELF_SET_ERROR(DATA, 0);
+                        return (0);
+                }
+                if (d->d_version != e->e_version) {
+                        LIBELF_SET_ERROR(VERSION, 0);
+                        return (0);
+                }
+                if ((d_align = d->d_align) % sh_align) {
+                        LIBELF_SET_ERROR(LAYOUT, 0);
+                        return (0);
+                }
+                if (d_align == 0 || (d_align & (d_align - 1))) {
+                        LIBELF_SET_ERROR(DATA, 0);
+                        return (0);
+                }
+                if (d_align > scn_alignment)
+                        scn_alignment = d_align;
+        }
+
+        scn_size = 0L;
+
+        STAILQ_FOREACH_SAFE(d, &s->s_data, d_next, td) {
+                if (e->e_flags & ELF_F_LAYOUT) {
+                        if ((uint64_t) d->d_off + d->d_size > scn_size)
+                                scn_size = d->d_off + d->d_size;
+                } else {
+                        scn_size = roundup(scn_size, scn_alignment);
+                        d->d_off = scn_size;
+                        scn_size += d->d_size;
+                }
+        }
+
+        /*
+         * If the application is requesting full control over the layout
+         * of the section, check its values for sanity.
+         */
+        if (e->e_flags & ELF_F_LAYOUT) {
+                if (scn_alignment > sh_align || sh_offset % sh_align ||
+                    sh_size < scn_size) {
+                        LIBELF_SET_ERROR(LAYOUT, 0);
+                        return (0);
+                }
+        } else {
+                /*
+                 * Otherwise compute the values in the section header.
+                 */
+
+                if (scn_alignment > sh_align)
+                        sh_align = scn_alignment;
+
+                /*
+                 * If the section entry size is zero, try and fill in an
+                 * appropriate entry size.  Per the elf(5) manual page
+                 * sections without fixed-size entries should have their
+                 * 'sh_entsize' field set to zero.
+                 */
+                if (sh_entsize == 0 &&
+                    (sh_entsize = _libelf_fsize(elftype, ec, e->e_version,
+                    (size_t) 1)) == 1)
+                        sh_entsize = 0;
+
+                sh_size = scn_size;
+                sh_offset = roundup(*rc, sh_align);
+
+                if (ec == ELFCLASS32) {
+                        s->s_shdr.s_shdr32.sh_addralign = (uint32_t) sh_align;
+                        s->s_shdr.s_shdr32.sh_entsize   = (uint32_t) sh_entsize;
+                        s->s_shdr.s_shdr32.sh_offset    = (uint32_t) sh_offset;
+                        s->s_shdr.s_shdr32.sh_size      = (uint32_t) sh_size;
+                } else {
+                        s->s_shdr.s_shdr64.sh_addralign = sh_align;
+                        s->s_shdr.s_shdr64.sh_entsize   = sh_entsize;
+                        s->s_shdr.s_shdr64.sh_offset    = sh_offset;
+                        s->s_shdr.s_shdr64.sh_size      = sh_size;
+                }
+        }
+
+        if ((size_t) *rc < sh_offset + sh_size)
+                *rc = sh_offset + sh_size;
+
+        s->s_size = sh_size;
+        s->s_offset = sh_offset;
+        return (1);
+}
+
+
+/*
+ * Insert a section in ascending order in the list
+ */
+
+static int
+_libelf_insert_section(Elf *e, Elf_Scn *s)
+{
+        Elf_Scn *t, *prevt;
+        uint64_t smax, smin, tmax, tmin;
+
+        smin = s->s_offset;
+        smax = smin + s->s_size;
+
+        prevt = NULL;
+        STAILQ_FOREACH(t, &e->e_u.e_elf.e_scn, s_next) {
+                tmin = t->s_offset;
+                tmax = tmin + t->s_size;
+
+                /* check if there is an overlap */
+                if (tmax < smin) {
+                        prevt = t;
+                        continue;
+                } else if (smax < tmin)
+                        break;
+                else {
+                        LIBELF_SET_ERROR(LAYOUT, 0);
+                        return (0);
+                }
+        }
+
+        if (prevt)
+                STAILQ_INSERT_AFTER(&e->e_u.e_elf.e_scn, prevt, s, s_next);
+        else
+                STAILQ_INSERT_HEAD(&e->e_u.e_elf.e_scn, s, s_next);
+        return (1);
+}
+
+static off_t
+_libelf_resync_sections(Elf *e, off_t rc)
+{
+        int ec;
+        off_t nrc;
+        size_t sh_type;
+        Elf_Scn *s, *ts;
+
+        ec = e->e_class;
+
+        /*
+         * Make a pass through sections, computing the extent of each
+         * section. Order in increasing order of addresses.
+         */
+
+        nrc = rc;
+        STAILQ_FOREACH(s, &e->e_u.e_elf.e_scn, s_next)
+                if (_libelf_compute_section_extents(e, s, &nrc) == 0)
+                        return ((off_t) -1);
+
+        STAILQ_FOREACH_SAFE(s, &e->e_u.e_elf.e_scn, s_next, ts) {
+                if (ec == ELFCLASS32)
+                        sh_type = s->s_shdr.s_shdr32.sh_type;
+                else
+                        sh_type = s->s_shdr.s_shdr64.sh_type;
+
+                /* XXX Do we need the 'size' field of an SHT_NOBITS section */
+                if (sh_type == SHT_NOBITS || sh_type == SHT_NULL)
+                        continue;
+
+                if (s->s_offset < (uint64_t) rc) {
+                        if (s->s_offset + s->s_size < (uint64_t) rc) {
+                                /*
+                                 * Try insert this section in the
+                                 * correct place in the list,
+                                 * detecting overlaps if any.
+                                 */
+                                STAILQ_REMOVE(&e->e_u.e_elf.e_scn, s, _Elf_Scn,
+                                    s_next);
+                                if (_libelf_insert_section(e, s) == 0)
+                                        return ((off_t) -1);
+                        } else {
+                                LIBELF_SET_ERROR(LAYOUT, 0);
+                                return ((off_t) -1);
+                        }
+                } else
+                        rc = s->s_offset + s->s_size;
+        }
+
+        assert(nrc == rc);
+
+        return (rc);
+}
+
+static off_t
+_libelf_resync_elf(Elf *e)
+{
+        int ec, eh_class, eh_type;
+        unsigned int eh_byteorder, eh_version;
+        size_t align, fsz;
+        size_t phnum, shnum;
+        off_t rc, phoff, shoff;
+        void *ehdr;
+        Elf32_Ehdr *eh32;
+        Elf64_Ehdr *eh64;
+
+        rc = 0;
+
+        ec = e->e_class;
+
+        assert(ec == ELFCLASS32 || ec == ELFCLASS64);
+
+        /*
+         * Prepare the EHDR.
+         */
+        if ((ehdr = _libelf_ehdr(e, ec, 0)) == NULL)
+                return ((off_t) -1);
+
+        eh32 = ehdr;
+        eh64 = ehdr;
+
+        if (ec == ELFCLASS32) {
+                eh_byteorder = eh32->e_ident[EI_DATA];
+                eh_class     = eh32->e_ident[EI_CLASS];
+                phoff        = (uint64_t) eh32->e_phoff;
+                shoff        = (uint64_t) eh32->e_shoff;
+                eh_type      = eh32->e_type;
+                eh_version   = eh32->e_version;
+        } else {
+                eh_byteorder = eh64->e_ident[EI_DATA];
+                eh_class     = eh64->e_ident[EI_CLASS];
+                phoff        = eh64->e_phoff;
+                shoff        = eh64->e_shoff;
+                eh_type      = eh64->e_type;
+                eh_version   = eh64->e_version;
+        }
+
+        if (eh_version == EV_NONE)
+                eh_version = EV_CURRENT;
+
+        if (eh_version != e->e_version) {      /* always EV_CURRENT */
+                LIBELF_SET_ERROR(VERSION, 0);
+                return ((off_t) -1);
+        }
+
+        if (eh_class != e->e_class) {
+                LIBELF_SET_ERROR(CLASS, 0);
+                return ((off_t) -1);
+        }
+
+        if (e->e_cmd != ELF_C_WRITE && eh_byteorder != e->e_byteorder) {
+                LIBELF_SET_ERROR(HEADER, 0);
+                return ((off_t) -1);
+        }
+
+        shnum = e->e_u.e_elf.e_nscn;
+        phnum = e->e_u.e_elf.e_nphdr;
+
+        e->e_byteorder = eh_byteorder;
+
+#define        INITIALIZE_EHDR(E,EC,V) do {                                    \
+                (E)->e_ident[EI_MAG0] = ELFMAG0;                       \
+                (E)->e_ident[EI_MAG1] = ELFMAG1;                       \
+                (E)->e_ident[EI_MAG2] = ELFMAG2;                       \
+                (E)->e_ident[EI_MAG3] = ELFMAG3;                       \
+                (E)->e_ident[EI_CLASS] = (EC);                         \
+                (E)->e_ident[EI_VERSION] = (V);                                \
+                (E)->e_ehsize = _libelf_fsize(ELF_T_EHDR, (EC), (V),   \
+                    (size_t) 1);                                       \
+                (E)->e_phentsize = _libelf_fsize(ELF_T_PHDR, (EC), (V),        \
+                    (size_t) 1);                                       \
+                (E)->e_shentsize = _libelf_fsize(ELF_T_SHDR, (EC), (V),        \
+                    (size_t) 1);                                       \
+        } while (0)
+
+        if (ec == ELFCLASS32)
+                INITIALIZE_EHDR(eh32, ec, eh_version);
+        else
+                INITIALIZE_EHDR(eh64, ec, eh_version);
+
+        (void) elf_flagehdr(e, ELF_C_SET, ELF_F_DIRTY);
+
+        rc += _libelf_fsize(ELF_T_EHDR, ec, eh_version, (size_t) 1);
+
+        /*
+         * Compute the layout the program header table, if one is
+         * present.  The program header table needs to be aligned to a
+         * `natural' boundary.
+         */
+        if (phnum) {
+                fsz = _libelf_fsize(ELF_T_PHDR, ec, eh_version, phnum);
+                align = _libelf_falign(ELF_T_PHDR, ec);
+
+                if (e->e_flags & ELF_F_LAYOUT) {
+                        /*
+                         * Check offsets for sanity.
+                         */
+                        if (rc > phoff) {
+                                LIBELF_SET_ERROR(HEADER, 0);
+                                return ((off_t) -1);
+                        }
+
+                        if (phoff % align) {
+                                LIBELF_SET_ERROR(LAYOUT, 0);
+                                return ((off_t) -1);
+                        }
+
+                } else
+                        phoff = roundup(rc, align);
+
+                rc = phoff + fsz;
+        } else
+                phoff = 0;
+
+        /*
+         * Compute the layout of the sections associated with the
+         * file.
+         */
+
+        if ((rc = _libelf_resync_sections(e, rc)) < 0)
+                return ((off_t) -1);
+
+        /*
+         * Compute the space taken up by the section header table, if
+         * one is needed.
+         */
+        if (shnum) {
+                fsz = _libelf_fsize(ELF_T_SHDR, ec, eh_version, (size_t) 1);
+                align = _libelf_falign(ELF_T_SHDR, ec);
+
+                if (e->e_flags & ELF_F_LAYOUT) {
+                        if (rc > shoff) {
+                                LIBELF_SET_ERROR(HEADER, 0);
+                                return ((off_t) -1);
+                        }
+
+                        if (shoff % align) {
+                                LIBELF_SET_ERROR(LAYOUT, 0);
+                                return ((off_t) -1);
+                        }
+                } else
+                        shoff = roundup(rc, align);
+
+                rc = shoff + fsz * shnum;
+        } else
+                shoff = 0;
+
+        /*
+         * Set the fields of the Executable Header that could potentially use
+         * extended numbering.
+         */
+        _libelf_setphnum(e, ehdr, ec, phnum);
+        _libelf_setshnum(e, ehdr, ec, shnum);
+
+        /*
+         * Update the `e_phoff' and `e_shoff' fields if the library is
+         * doing the layout.
+         */
+        if ((e->e_flags & ELF_F_LAYOUT) == 0) {
+                if (ec == ELFCLASS32) {
+                        eh32->e_phoff = (uint32_t) phoff;
+                        eh32->e_shoff = (uint32_t) shoff;
+                } else {
+                        eh64->e_phoff = (uint64_t) phoff;
+                        eh64->e_shoff = (uint64_t) shoff;
+                }
+        }
+
+        return (rc);
+}
+
+/*
+ * Write out the contents of a section.
+ */
+
+static off_t
+_libelf_write_scn(Elf *e, char *nf, Elf_Scn *s, off_t rc)
+{
+        int ec;
+        size_t fsz, msz, nobjects;
+        uint32_t sh_type;
+        uint64_t sh_off;
+        int elftype;
+        Elf_Data *d, dst;
+
+        if ((ec = e->e_class) == ELFCLASS32)
+                sh_type = s->s_shdr.s_shdr32.sh_type;
+        else
+                sh_type = s->s_shdr.s_shdr64.sh_type;
+
+        /*
+         * Ignore sections that do not allocate space in the file.
+         */
+        if (sh_type == SHT_NOBITS || sh_type == SHT_NULL)
+                return (rc);
+
+
+        elftype = _libelf_xlate_shtype(sh_type);
+        assert(elftype >= ELF_T_FIRST && elftype <= ELF_T_LAST);
+
+        msz = _libelf_msize(elftype, ec, e->e_version);
+
+        sh_off = s->s_offset;
+        assert(sh_off % _libelf_falign(elftype, ec) == 0);
+
+        /*
+         * If the section has a `rawdata' descriptor, and the section
+         * contents have not been modified, use its contents directly.
+         * The `s_rawoff' member contains the offset into the original
+         * file, while `s_offset' contains its new location in the
+         * destination.
+         */
+
+        if (STAILQ_EMPTY(&s->s_data)) {
+
+                if ((d = elf_rawdata(s, NULL)) == NULL)
+                        return ((off_t) -1);
+
+                STAILQ_FOREACH(d, &s->s_rawdata, d_next) {
+                        if ((uint64_t) rc < sh_off + d->d_off)
+                                (void) memset(nf + rc,
+                                    LIBELF_PRIVATE(fillchar), sh_off +
+                                    d->d_off - rc);
+                        rc = sh_off + d->d_off;
+
+                        assert(d->d_buf != NULL);
+                        assert(d->d_type == ELF_T_BYTE);
+                        assert(d->d_version == e->e_version);
+
+                        (void) memcpy(nf + rc,
+                            e->e_rawfile + s->s_rawoff + d->d_off, d->d_size);
+
+                        rc += d->d_size;
+                }
+
+                return (rc);
+        }
+
+        /*
+         * Iterate over the set of data descriptors for this section.
+         * The prior call to _libelf_resync_elf() would have setup the
+         * descriptors for this step.
+         */
+
+        dst.d_version = e->e_version;
+
+        STAILQ_FOREACH(d, &s->s_data, d_next) {
+
+                if ((uint64_t) rc < sh_off + d->d_off)
+                        (void) memset(nf + rc,
+                            LIBELF_PRIVATE(fillchar), sh_off + d->d_off - rc);
+
+                rc = sh_off + d->d_off;
+
+                assert(d->d_buf != NULL);
+                assert(d->d_type == (Elf_Type) elftype);
+                assert(d->d_version == e->e_version);
+                assert(d->d_size % msz == 0);
+
+                nobjects = d->d_size / msz;
+
+                fsz = _libelf_fsize(elftype, ec, e->e_version, nobjects);
+
+                dst.d_buf    = nf + rc;
+                dst.d_size   = fsz;
+
+                if (_libelf_xlate(&dst, d, e->e_byteorder, ec, ELF_TOFILE) ==
+                    NULL)
+                        return ((off_t) -1);
+
+                rc += fsz;
+        }
+
+        return ((off_t) rc);
+}
+
+/*
+ * Write out the file image.
+ *
+ * The original file could have been mapped in with an ELF_C_RDWR
+ * command and the application could have added new content or
+ * re-arranged its sections before calling elf_update().  Consequently
+ * its not safe to work `in place' on the original file.  So we
+ * malloc() the required space for the updated ELF object and build
+ * the object there and write it out to the underlying file at the
+ * end.  Note that the application may have opened the underlying file
+ * in ELF_C_RDWR and only retrieved/modified a few sections.  We take
+ * care to avoid translating file sections unnecessarily.
+ *
+ * Gaps in the coverage of the file by the file's sections will be
+ * filled with the fill character set by elf_fill(3).
+ */
+
+static off_t
+_libelf_write_elf(Elf *e, off_t newsize)
+{
+        int ec;
+        off_t rc;
+        size_t fsz, msz, phnum, shnum;
+        uint64_t phoff, shoff;
+        void *ehdr;
+        char *newfile;
+        Elf_Data dst, src;
+        Elf_Scn *scn, *tscn;
+        Elf32_Ehdr *eh32;
+        Elf64_Ehdr *eh64;
+
+        assert(e->e_kind == ELF_K_ELF);
+        assert(e->e_cmd != ELF_C_READ);
+        assert(e->e_fd >= 0);
+
+        if ((newfile = malloc((size_t) newsize)) == NULL) {
+                LIBELF_SET_ERROR(RESOURCE, errno);
+                return ((off_t) -1);
+        }
+
+        ec = e->e_class;
+
+        ehdr = _libelf_ehdr(e, ec, 0);
+        assert(ehdr != NULL);
+
+        phnum = e->e_u.e_elf.e_nphdr;
+
+        if (ec == ELFCLASS32) {
+                eh32 = (Elf32_Ehdr *) ehdr;
+
+                phoff = (uint64_t) eh32->e_phoff;
+                shnum = eh32->e_shnum;
+                shoff = (uint64_t) eh32->e_shoff;
+        } else {
+                eh64 = (Elf64_Ehdr *) ehdr;
+
+                phoff = eh64->e_phoff;
+                shnum = eh64->e_shnum;
+                shoff = eh64->e_shoff;
+        }
+
+        fsz = _libelf_fsize(ELF_T_EHDR, ec, e->e_version, (size_t) 1);
+        msz = _libelf_msize(ELF_T_EHDR, ec, e->e_version);
+
+        (void) memset(&dst, 0, sizeof(dst));
+        (void) memset(&src, 0, sizeof(src));
+
+        src.d_buf     = ehdr;
+        src.d_size    = msz;
+        src.d_type    = ELF_T_EHDR;
+        src.d_version = dst.d_version = e->e_version;
+
+        rc = 0;
+
+        dst.d_buf     = newfile + rc;
+        dst.d_size    = fsz;
+
+        if (_libelf_xlate(&dst, &src, e->e_byteorder, ec, ELF_TOFILE) ==
+            NULL)
+                goto error;
+
+        rc += fsz;
+
+        /*
+         * Write the program header table if present.
+         */
+
+        if (phnum != 0 && phoff != 0) {
+                assert((unsigned) rc <= phoff);
+
+                fsz = _libelf_fsize(ELF_T_PHDR, ec, e->e_version, phnum);
+
+                assert(phoff % _libelf_falign(ELF_T_PHDR, ec) == 0);
+                assert(fsz > 0);
+
+                src.d_version = dst.d_version = e->e_version;
+                src.d_type = ELF_T_PHDR;
+
+                if (ec == ELFCLASS32)
+                        src.d_buf = e->e_u.e_elf.e_phdr.e_phdr32;
+                else
+                        src.d_buf = e->e_u.e_elf.e_phdr.e_phdr64;
+
+                src.d_size = phnum * _libelf_msize(ELF_T_PHDR, ec,
+                    e->e_version);
+
+                dst.d_size = fsz;
+
+                if ((uint64_t) rc < phoff)
+                        (void) memset(newfile + rc,
+                            LIBELF_PRIVATE(fillchar), phoff - rc);
+
+                dst.d_buf = newfile + rc;
+
+                if (_libelf_xlate(&dst, &src, e->e_byteorder, ec, ELF_TOFILE) ==
+                    NULL)
+                        goto error;
+
+                rc = phoff + fsz;
+        }
+
+        /*
+         * Write out individual sections.
+         */
+
+        STAILQ_FOREACH(scn, &e->e_u.e_elf.e_scn, s_next)
+                if ((rc = _libelf_write_scn(e, newfile, scn, rc)) < 0)
+                        goto error;
+
+        /*
+         * Write out the section header table, if required.
+         */
+
+        if (shnum != 0 && shoff != 0) {
+                assert((unsigned) rc <= shoff);
+
+                if ((uint64_t) rc < shoff)
+                        (void) memset(newfile + rc,
+                            LIBELF_PRIVATE(fillchar), shoff - rc);
+
+                rc = shoff;
+
+                assert(rc % _libelf_falign(ELF_T_SHDR, ec) == 0);
+
+                src.d_type = ELF_T_SHDR;
+                src.d_size = _libelf_msize(ELF_T_SHDR, ec, e->e_version);
+                src.d_version = dst.d_version = e->e_version;
+
+                fsz = _libelf_fsize(ELF_T_SHDR, ec, e->e_version, (size_t) 1);
+
+                STAILQ_FOREACH(scn, &e->e_u.e_elf.e_scn, s_next) {
+                        if (ec == ELFCLASS32)
+                                src.d_buf = &scn->s_shdr.s_shdr32;
+                        else
+                                src.d_buf = &scn->s_shdr.s_shdr64;
+
+                        dst.d_size = fsz;
+                        dst.d_buf = newfile + rc;
+
+                        if (_libelf_xlate(&dst, &src, e->e_byteorder, ec,
+                                ELF_TOFILE) != &dst)
+                                goto error;
+
+                        rc += fsz;
+                }
+        }
+
+        /*
+         */
+
+        assert(rc == newsize);
+
+        /*
+         * Write out the constructed contents and remap the file in
+         * read-only.
+         */
+
+        if (e->e_rawfile && munmap(e->e_rawfile, e->e_rawsize) < 0) {
+                LIBELF_SET_ERROR(IO, errno);
+                goto error;
+        }
+
+        if (write(e->e_fd, newfile, (size_t) newsize) != newsize ||
+            lseek(e->e_fd, (off_t) 0, SEEK_SET) < 0) {
+                LIBELF_SET_ERROR(IO, errno);
+                goto error;
+        }
+
+        if (e->e_cmd != ELF_C_WRITE) {
+                if ((e->e_rawfile = mmap(NULL, (size_t) newsize, PROT_READ,
+                    MAP_PRIVATE, e->e_fd, (off_t) 0)) == MAP_FAILED) {
+                        LIBELF_SET_ERROR(IO, errno);
+                        goto error;
+                }
+                e->e_rawsize = newsize;
+        }
+
+        /*
+         * Reset flags, remove existing section descriptors and
+         * {E,P}HDR pointers so that a subsequent elf_get{e,p}hdr()
+         * and elf_getscn() will function correctly.
+         */
+
+        e->e_flags &= ~ELF_F_DIRTY;
+
+        STAILQ_FOREACH_SAFE(scn, &e->e_u.e_elf.e_scn, s_next, tscn)
+                _libelf_release_scn(scn);
+
+        if (ec == ELFCLASS32) {
+                free(e->e_u.e_elf.e_ehdr.e_ehdr32);
+                if (e->e_u.e_elf.e_phdr.e_phdr32)
+                        free(e->e_u.e_elf.e_phdr.e_phdr32);
+
+                e->e_u.e_elf.e_ehdr.e_ehdr32 = NULL;
+                e->e_u.e_elf.e_phdr.e_phdr32 = NULL;
+        } else {
+                free(e->e_u.e_elf.e_ehdr.e_ehdr64);
+                if (e->e_u.e_elf.e_phdr.e_phdr64)
+                        free(e->e_u.e_elf.e_phdr.e_phdr64);
+
+                e->e_u.e_elf.e_ehdr.e_ehdr64 = NULL;
+                e->e_u.e_elf.e_phdr.e_phdr64 = NULL;
+        }
+
+        return (rc);
+
+ error:
+        if (newfile)
+                free(newfile);
+        return ((off_t) -1);
+}
+
+off_t
+elf_update(Elf *e, Elf_Cmd c)
+{
+        int ec;
+        off_t rc;
+
+        rc = (off_t) -1;
+
+        if (e == NULL || e->e_kind != ELF_K_ELF ||
+            (c != ELF_C_NULL && c != ELF_C_WRITE)) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (rc);
+        }
+
+        if ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64) {
+                LIBELF_SET_ERROR(CLASS, 0);
+                return (rc);
+        }
+
+        if (e->e_version == EV_NONE)
+                e->e_version = EV_CURRENT;
+
+        if (c == ELF_C_WRITE && e->e_cmd == ELF_C_READ) {
+                LIBELF_SET_ERROR(MODE, 0);
+                return (rc);
+        }
+
+        if ((rc = _libelf_resync_elf(e)) < 0)
+                return (rc);
+
+        if (c == ELF_C_NULL)
+                return (rc);
+
+        if (e->e_cmd == ELF_C_READ) {
+                /*
+                 * This descriptor was opened in read-only mode or by
+                 * elf_memory().
+                 */
+                if (e->e_fd)
+                        LIBELF_SET_ERROR(MODE, 0);
+                else
+                        LIBELF_SET_ERROR(ARGUMENT, 0);
+                return ((off_t) -1);
+        }
+
+        if (e->e_fd < 0) {
+                LIBELF_SET_ERROR(SEQUENCE, 0);
+                return ((off_t) -1);
+        }
+
+        return (_libelf_write_elf(e, rc));
+}
diff --git a/ext/libelf/elf_version.c b/ext/libelf/elf_version.c
new file mode 100644 (file)
index 0000000..e4c1e7d
--- /dev/null
@@ -0,0 +1,47 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "libelf.h"
+#include "_libelf.h"
+
+unsigned int
+elf_version(unsigned int v)
+{
+        unsigned int old;
+
+        if ((old = LIBELF_PRIVATE(version)) == EV_NONE)
+                old = EV_CURRENT;
+
+        if (v == EV_NONE)
+                return old;
+        if (v > EV_CURRENT) {
+                LIBELF_SET_ERROR(VERSION, 0);
+                return EV_NONE;
+        }
+
+        LIBELF_PRIVATE(version) = v;
+        return (old);
+}
diff --git a/ext/libelf/gelf.h b/ext/libelf/gelf.h
new file mode 100644 (file)
index 0000000..6ccb87f
--- /dev/null
@@ -0,0 +1,113 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD: src/lib/libelf/gelf.h,v 1.3 2007/03/08 04:01:30 jkoshy Exp $
+ */
+
+#ifndef        _GELF_H_
+#define        _GELF_H_
+
+
+#include "libelf.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef Elf64_Addr     GElf_Addr;      /* Addresses */
+typedef Elf64_Half     GElf_Half;      /* Half words (16 bit) */
+typedef Elf64_Off      GElf_Off;       /* Offsets */
+typedef Elf64_Sword    GElf_Sword;     /* Signed words (32 bit) */
+typedef Elf64_Sxword   GElf_Sxword;    /* Signed long words (64 bit) */
+typedef Elf64_Word     GElf_Word;      /* Unsigned words (32 bit) */
+typedef Elf64_Xword    GElf_Xword;     /* Unsigned long words (64 bit) */
+
+typedef Elf64_Dyn      GElf_Dyn;       /* ".dynamic" section entries */
+typedef Elf64_Ehdr     GElf_Ehdr;      /* ELF header */
+typedef Elf64_Phdr     GElf_Phdr;      /* Program header */
+typedef Elf64_Shdr     GElf_Shdr;      /* Section header */
+typedef Elf64_Sym      GElf_Sym;       /* Symbol table entries */
+typedef Elf64_Rel      GElf_Rel;       /* Relocation entries */
+typedef Elf64_Rela     GElf_Rela;      /* Relocation entries with addend */
+
+typedef        Elf64_Cap       GElf_Cap;       /* SW/HW capabilities */
+typedef Elf64_Move     GElf_Move;      /* Move entries */
+typedef Elf64_Syminfo  GElf_Syminfo;   /* Symbol information */
+
+#define        GELF_M_INFO                     ELF64_M_INFO
+#define        GELF_M_SIZE                     ELF64_M_SIZE
+#define        GELF_M_SYM                      ELF64_M_SYM
+
+#define        GELF_R_INFO                     ELF64_R_INFO
+#define        GELF_R_SYM                      ELF64_R_SYM
+#define        GELF_R_TYPE                     ELF64_R_TYPE
+#define        GELF_R_TYPE_DATA                ELF64_R_TYPE_DATA
+#define        GELF_R_TYPE_ID                  ELF64_R_TYPE_ID
+#define        GELF_R_TYPE_INFO                ELF64_R_TYPE_INFO
+
+#define        GELF_ST_BIND                    ELF64_ST_BIND
+#define        GELF_ST_INFO                    ELF64_ST_INFO
+#define        GELF_ST_TYPE                    ELF64_ST_TYPE
+#define        GELF_ST_VISIBILITY              ELF64_ST_VISIBILITY
+
+long           gelf_checksum(Elf *_elf);
+size_t         gelf_fsize(Elf *_elf, Elf_Type _type, size_t _count,
+                        unsigned int _version);
+int            gelf_getclass(Elf *_elf);
+GElf_Dyn       *gelf_getdyn(Elf_Data *_data, int _index, GElf_Dyn *_dst);
+GElf_Ehdr      *gelf_getehdr(Elf *_elf, GElf_Ehdr *_dst);
+GElf_Phdr      *gelf_getphdr(Elf *_elf, int _index, GElf_Phdr *_dst);
+GElf_Rel       *gelf_getrel(Elf_Data *_src, int _index, GElf_Rel *_dst);
+GElf_Rela      *gelf_getrela(Elf_Data *_src, int _index, GElf_Rela *_dst);
+GElf_Shdr      *gelf_getshdr(Elf_Scn *_scn, GElf_Shdr *_dst);
+GElf_Sym       *gelf_getsym(Elf_Data *_src, int _index, GElf_Sym *_dst);
+GElf_Sym       *gelf_getsymshndx(Elf_Data *_src, Elf_Data *_shindexsrc,
+                        int _index, GElf_Sym *_dst, Elf32_Word *_shindexdst);
+void *         gelf_newehdr(Elf *_elf, int _class);
+void *         gelf_newphdr(Elf *_elf, size_t _phnum);
+int            gelf_update_dyn(Elf_Data *_dst, int _index, GElf_Dyn *_src);
+int            gelf_update_ehdr(Elf *_elf, GElf_Ehdr *_src);
+int            gelf_update_phdr(Elf *_elf, int _index, GElf_Phdr *_src);
+int            gelf_update_rel(Elf_Data *_dst, int _index, GElf_Rel *_src);
+int            gelf_update_rela(Elf_Data *_dst, int _index, GElf_Rela *_src);
+int            gelf_update_shdr(Elf_Scn *_dst, GElf_Shdr *_src);
+int            gelf_update_sym(Elf_Data *_dst, int _index, GElf_Sym *_src);
+int            gelf_update_symshndx(Elf_Data *_symdst, Elf_Data *_shindexdst,
+                        int _index, GElf_Sym *_symsrc, Elf32_Word _shindexsrc);
+Elf_Data       *gelf_xlatetof(Elf *_elf, Elf_Data *_dst, const Elf_Data *_src, unsigned int _encode);
+Elf_Data       *gelf_xlatetom(Elf *_elf, Elf_Data *_dst, const Elf_Data *_src, unsigned int _encode);
+
+GElf_Cap       *gelf_getcap(Elf_Data *_data, int _index, GElf_Cap *_cap);
+GElf_Move      *gelf_getmove(Elf_Data *_src, int _index, GElf_Move *_dst);
+GElf_Syminfo   *gelf_getsyminfo(Elf_Data *_src, int _index, GElf_Syminfo *_dst);
+int            gelf_update_cap(Elf_Data *_dst, int _index, GElf_Cap *_src);
+int            gelf_update_move(Elf_Data *_dst, int _index, GElf_Move *_src);
+int            gelf_update_syminfo(Elf_Data *_dst, int _index, GElf_Syminfo *_src);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _GELF_H_ */
diff --git a/ext/libelf/gelf_checksum.c b/ext/libelf/gelf_checksum.c
new file mode 100644 (file)
index 0000000..105cd28
--- /dev/null
@@ -0,0 +1,54 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "gelf.h"
+#include "libelf.h"
+
+#include "_libelf.h"
+
+long
+elf32_checksum(Elf *e)
+{
+        return (_libelf_checksum(e, ELFCLASS32));
+}
+
+long
+elf64_checksum(Elf *e)
+{
+        return (_libelf_checksum(e, ELFCLASS64));
+}
+
+long
+gelf_checksum(Elf *e)
+{
+        int ec;
+        if (e == NULL ||
+            ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0L);
+        }
+        return (_libelf_checksum(e, ec));
+}
diff --git a/ext/libelf/gelf_dyn.c b/ext/libelf/gelf_dyn.c
new file mode 100644 (file)
index 0000000..9820680
--- /dev/null
@@ -0,0 +1,140 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <assert.h>
+#include <limits.h>
+
+#include "gelf.h"
+#include "_libelf.h"
+
+GElf_Dyn *
+gelf_getdyn(Elf_Data *d, int ndx, GElf_Dyn *dst)
+{
+        int ec;
+        Elf *e;
+        Elf_Scn *scn;
+        Elf32_Dyn *dyn32;
+        Elf64_Dyn *dyn64;
+        size_t msz;
+        uint32_t sh_type;
+
+        if (d == NULL || ndx < 0 || dst == NULL ||
+            (scn = d->d_scn) == NULL ||
+            (e = scn->s_elf) == NULL) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        ec = e->e_class;
+        assert(ec == ELFCLASS32 || ec == ELFCLASS64);
+
+        if (ec == ELFCLASS32)
+                sh_type = scn->s_shdr.s_shdr32.sh_type;
+        else
+                sh_type = scn->s_shdr.s_shdr64.sh_type;
+
+        if (_libelf_xlate_shtype(sh_type) != ELF_T_DYN) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        msz = _libelf_msize(ELF_T_DYN, ec, e->e_version);
+
+        assert(msz > 0);
+
+        if (msz * ndx >= d->d_size) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        if (ec == ELFCLASS32) {
+                dyn32 = (Elf32_Dyn *) d->d_buf + ndx;
+
+                dst->d_tag      = dyn32->d_tag;
+                dst->d_un.d_val = (Elf64_Xword) dyn32->d_un.d_val;
+
+        } else {
+
+                dyn64 = (Elf64_Dyn *) d->d_buf + ndx;
+
+                *dst = *dyn64;
+        }
+
+        return (dst);
+}
+
+int
+gelf_update_dyn(Elf_Data *d, int ndx, GElf_Dyn *ds)
+{
+        int ec;
+        Elf *e;
+        Elf_Scn *scn;
+        Elf32_Dyn *dyn32;
+        Elf64_Dyn *dyn64;
+        size_t msz;
+        uint32_t sh_type;
+
+        if (d == NULL || ndx < 0 || ds == NULL ||
+            (scn = d->d_scn) == NULL ||
+            (e = scn->s_elf) == NULL) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        ec = e->e_class;
+        assert(ec == ELFCLASS32 || ec == ELFCLASS64);
+
+        if (ec == ELFCLASS32)
+                sh_type = scn->s_shdr.s_shdr32.sh_type;
+        else
+                sh_type = scn->s_shdr.s_shdr64.sh_type;
+
+        if (_libelf_xlate_shtype(sh_type) != ELF_T_DYN) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        msz = _libelf_msize(ELF_T_DYN, ec, e->e_version);
+        assert(msz > 0);
+
+        if (msz * ndx >= d->d_size) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        if (ec == ELFCLASS32) {
+                dyn32 = (Elf32_Dyn *) d->d_buf + ndx;
+
+                LIBELF_COPY_S32(dyn32, ds, d_tag);
+                LIBELF_COPY_U32(dyn32, ds, d_un.d_val);
+        } else {
+                dyn64 = (Elf64_Dyn *) d->d_buf + ndx;
+
+                *dyn64 = *ds;
+        }
+
+        return (1);
+}
diff --git a/ext/libelf/gelf_ehdr.c b/ext/libelf/gelf_ehdr.c
new file mode 100644 (file)
index 0000000..c410f4a
--- /dev/null
@@ -0,0 +1,164 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <limits.h>
+
+#include <assert.h>
+#include "gelf.h"
+#include "libelf.h"
+#include <string.h>
+
+#include "_libelf.h"
+
+Elf32_Ehdr *
+elf32_getehdr(Elf *e)
+{
+        return (_libelf_ehdr(e, ELFCLASS32, 0));
+}
+
+Elf64_Ehdr *
+elf64_getehdr(Elf *e)
+{
+        return (_libelf_ehdr(e, ELFCLASS64, 0));
+}
+
+GElf_Ehdr *
+gelf_getehdr(Elf *e, GElf_Ehdr *d)
+{
+        int ec;
+        Elf32_Ehdr *eh32;
+        Elf64_Ehdr *eh64;
+
+        if (d == NULL || e == NULL ||
+            ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        if (ec == ELFCLASS32) {
+                if ((eh32 = _libelf_ehdr(e, ELFCLASS32, 0)) == NULL)
+                        return (NULL);
+
+                (void) memcpy(d->e_ident, eh32->e_ident, sizeof(eh32->e_ident));
+                d->e_type              = eh32->e_type;
+                d->e_machine           = eh32->e_machine;
+                d->e_version           = eh32->e_version;
+                d->e_entry             = eh32->e_entry;
+                d->e_phoff             = eh32->e_phoff;
+                d->e_shoff             = eh32->e_shoff;
+                d->e_flags             = eh32->e_flags;
+                d->e_ehsize            = eh32->e_ehsize;
+                d->e_phentsize         = eh32->e_phentsize;
+                d->e_phnum             = eh32->e_phnum;
+                d->e_shentsize         = eh32->e_shentsize;
+                d->e_shnum             = eh32->e_shnum;
+                d->e_shstrndx          = eh32->e_shstrndx;
+
+                return (d);
+        }
+
+        assert(ec == ELFCLASS64);
+
+        if ((eh64 = _libelf_ehdr(e, ELFCLASS64, 0)) == NULL)
+                return (NULL);
+        *d = *eh64;
+
+        return (d);
+}
+
+Elf32_Ehdr *
+elf32_newehdr(Elf *e)
+{
+        return (_libelf_ehdr(e, ELFCLASS32, 1));
+}
+
+Elf64_Ehdr *
+elf64_newehdr(Elf *e)
+{
+        return (_libelf_ehdr(e, ELFCLASS64, 1));
+}
+
+void *
+gelf_newehdr(Elf *e, int ec)
+{
+        if (e != NULL &&
+            (ec == ELFCLASS32 || ec == ELFCLASS64))
+                return (_libelf_ehdr(e, ec, 1));
+
+        LIBELF_SET_ERROR(ARGUMENT, 0);
+        return (NULL);
+}
+
+int
+gelf_update_ehdr(Elf *e, GElf_Ehdr *s)
+{
+        int ec;
+        void *ehdr;
+        Elf32_Ehdr *eh32;
+        Elf64_Ehdr *eh64;
+
+        if (s== NULL || e == NULL || e->e_kind != ELF_K_ELF ||
+            ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        if (e->e_cmd == ELF_C_READ) {
+                LIBELF_SET_ERROR(MODE, 0);
+                return (0);
+        }
+
+        if ((ehdr = _libelf_ehdr(e, ec, 0)) == NULL)
+                return (0);
+
+        if (ec == ELFCLASS64) {
+                eh64 = (Elf64_Ehdr *) ehdr;
+                *eh64 = *s;
+                return (1);
+        }
+
+        eh32 = (Elf32_Ehdr *) ehdr;
+
+        (void) memcpy(eh32->e_ident, s->e_ident, sizeof(eh32->e_ident));
+
+        eh32->e_type      = s->e_type;
+        eh32->e_machine   = s->e_machine;
+        eh32->e_version   = s->e_version;
+        LIBELF_COPY_U32(eh32, s, e_entry);
+        LIBELF_COPY_U32(eh32, s, e_phoff);
+        LIBELF_COPY_U32(eh32, s, e_shoff);
+        eh32->e_flags     = s->e_flags;
+        eh32->e_ehsize    = s->e_ehsize;
+        eh32->e_phentsize = s->e_phentsize;
+        eh32->e_phnum     = s->e_phnum;
+        eh32->e_shentsize = s->e_shentsize;
+        eh32->e_shnum     = s->e_shnum;
+        eh32->e_shstrndx  = s->e_shstrndx;
+
+        (void) elf_flagehdr(e, ELF_C_SET, ELF_F_DIRTY);
+
+        return (1);
+}
diff --git a/ext/libelf/gelf_fsize.c b/ext/libelf/gelf_fsize.c
new file mode 100644 (file)
index 0000000..06add07
--- /dev/null
@@ -0,0 +1,58 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "gelf.h"
+#include "libelf.h"
+
+#include "_libelf.h"
+
+size_t
+elf32_fsize(Elf_Type t, size_t c, unsigned int v)
+{
+        return (_libelf_fsize(t, ELFCLASS32, v, c));
+}
+
+size_t
+elf64_fsize(Elf_Type t, size_t c, unsigned int v)
+{
+        return (_libelf_fsize(t, ELFCLASS64, v, c));
+}
+
+size_t
+gelf_fsize(Elf *e, Elf_Type t, size_t c, unsigned int v)
+{
+
+        if (e == NULL) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        if (e->e_class == ELFCLASS32 || e->e_class == ELFCLASS64)
+                return (_libelf_fsize(t, e->e_class, v, c));
+
+        LIBELF_SET_ERROR(ARGUMENT, 0);
+        return (0);
+}
diff --git a/ext/libelf/gelf_getclass.c b/ext/libelf/gelf_getclass.c
new file mode 100644 (file)
index 0000000..96f2007
--- /dev/null
@@ -0,0 +1,35 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "gelf.h"
+
+#include "_libelf.h"
+
+int
+gelf_getclass(Elf *e)
+{
+        return (e != NULL ? e->e_class : ELFCLASSNONE);
+}
diff --git a/ext/libelf/gelf_phdr.c b/ext/libelf/gelf_phdr.c
new file mode 100644 (file)
index 0000000..6125ec6
--- /dev/null
@@ -0,0 +1,175 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <limits.h>
+
+#include "gelf.h"
+#include "libelf.h"
+
+#include "_libelf.h"
+
+Elf32_Phdr *
+elf32_getphdr(Elf *e)
+{
+        return (_libelf_getphdr(e, ELFCLASS32));
+}
+
+Elf64_Phdr *
+elf64_getphdr(Elf *e)
+{
+        return (_libelf_getphdr(e, ELFCLASS64));
+}
+
+GElf_Phdr *
+gelf_getphdr(Elf *e, int index, GElf_Phdr *d)
+{
+        int ec;
+        Elf32_Ehdr *eh32;
+        Elf64_Ehdr *eh64;
+        Elf32_Phdr *ep32;
+        Elf64_Phdr *ep64;
+
+        if (d == NULL || e == NULL ||
+            ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64) ||
+            (e->e_kind != ELF_K_ELF) || index < 0) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        if (ec == ELFCLASS32) {
+                if ((eh32 = _libelf_ehdr(e, ELFCLASS32, 0)) == NULL ||
+                    ((ep32 = _libelf_getphdr(e, ELFCLASS32)) == NULL))
+                        return (NULL);
+
+                if (index >= eh32->e_phnum) {
+                        LIBELF_SET_ERROR(ARGUMENT, 0);
+                        return (NULL);
+                }
+
+                ep32 += index;
+
+                d->p_type   = ep32->p_type;
+                d->p_offset = ep32->p_offset;
+                d->p_vaddr  = (Elf64_Addr) ep32->p_vaddr;
+                d->p_paddr  = (Elf64_Addr) ep32->p_paddr;
+                d->p_filesz = (Elf64_Xword) ep32->p_filesz;
+                d->p_memsz  = (Elf64_Xword) ep32->p_memsz;
+                d->p_flags  = ep32->p_flags;
+                d->p_align  = (Elf64_Xword) ep32->p_align;
+
+        } else {
+                if ((eh64 = _libelf_ehdr(e, ELFCLASS64, 0)) == NULL ||
+                    (ep64 = _libelf_getphdr(e, ELFCLASS64)) == NULL)
+                        return (NULL);
+
+                if (index >= eh64->e_phnum) {
+                        LIBELF_SET_ERROR(ARGUMENT, 0);
+                        return (NULL);
+                }
+
+                ep64 += index;
+
+                *d = *ep64;
+        }
+
+        return (d);
+}
+
+Elf32_Phdr *
+elf32_newphdr(Elf *e, size_t count)
+{
+        return (_libelf_newphdr(e, ELFCLASS32, count));
+}
+
+Elf64_Phdr *
+elf64_newphdr(Elf *e, size_t count)
+{
+        return (_libelf_newphdr(e, ELFCLASS64, count));
+}
+
+void *
+gelf_newphdr(Elf *e, size_t count)
+{
+        if (e == NULL) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+        return (_libelf_newphdr(e, e->e_class, count));
+}
+
+int
+gelf_update_phdr(Elf *e, int ndx, GElf_Phdr *s)
+{
+        int ec, phnum;
+        void *ehdr;
+        Elf32_Phdr *ph32;
+        Elf64_Phdr *ph64;
+
+        if (s == NULL || e == NULL || e->e_kind != ELF_K_ELF ||
+            ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        if (e->e_cmd == ELF_C_READ) {
+                LIBELF_SET_ERROR(MODE, 0);
+                return (0);
+        }
+
+        if ((ehdr = _libelf_ehdr(e, ec, 0)) == NULL)
+                return (0);
+
+        if (ec == ELFCLASS32)
+                phnum = ((Elf32_Ehdr *) ehdr)->e_phnum;
+        else
+                phnum = ((Elf64_Ehdr *) ehdr)->e_phnum;
+
+        if (ndx < 0 || ndx > phnum) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        if (ec == ELFCLASS64) {
+                ph64 = e->e_u.e_elf.e_phdr.e_phdr64 + ndx;
+                *ph64 = *s;
+                return (1);
+        }
+
+        ph32 = e->e_u.e_elf.e_phdr.e_phdr32 + ndx;
+
+        ph32->p_type     =  s->p_type;
+        ph32->p_flags    =  s->p_flags;
+        LIBELF_COPY_U32(ph32, s, p_offset);
+        LIBELF_COPY_U32(ph32, s, p_vaddr);
+        LIBELF_COPY_U32(ph32, s, p_paddr);
+        LIBELF_COPY_U32(ph32, s, p_filesz);
+        LIBELF_COPY_U32(ph32, s, p_memsz);
+        LIBELF_COPY_U32(ph32, s, p_align);
+
+        (void) elf_flagphdr(e, ELF_C_SET, ELF_F_DIRTY);
+
+        return (1);
+}
diff --git a/ext/libelf/gelf_rel.c b/ext/libelf/gelf_rel.c
new file mode 100644 (file)
index 0000000..5606138
--- /dev/null
@@ -0,0 +1,141 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <limits.h>
+
+#include <assert.h>
+#include "gelf.h"
+
+#include "_libelf.h"
+
+GElf_Rel *
+gelf_getrel(Elf_Data *d, int ndx, GElf_Rel *dst)
+{
+        int ec;
+        Elf *e;
+        Elf_Scn *scn;
+        Elf32_Rel *rel32;
+        Elf64_Rel *rel64;
+        size_t msz;
+        uint32_t sh_type;
+
+        if (d == NULL || ndx < 0 || dst == NULL ||
+            (scn = d->d_scn) == NULL ||
+            (e = scn->s_elf) == NULL) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        ec = e->e_class;
+        assert(ec == ELFCLASS32 || ec == ELFCLASS64);
+
+        if (ec == ELFCLASS32)
+                sh_type = scn->s_shdr.s_shdr32.sh_type;
+        else
+                sh_type = scn->s_shdr.s_shdr64.sh_type;
+
+        if (_libelf_xlate_shtype(sh_type) != ELF_T_REL) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        msz = _libelf_msize(ELF_T_REL, ec, e->e_version);
+
+        assert(msz > 0);
+
+        if (msz * ndx >= d->d_size) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        if (ec == ELFCLASS32) {
+                rel32 = (Elf32_Rel *) d->d_buf + ndx;
+
+                dst->r_offset = (Elf64_Addr) rel32->r_offset;
+                dst->r_info   = (Elf64_Xword) rel32->r_info;
+
+        } else {
+
+                rel64 = (Elf64_Rel *) d->d_buf + ndx;
+
+                *dst = *rel64;
+        }
+
+        return (dst);
+}
+
+int
+gelf_update_rel(Elf_Data *d, int ndx, GElf_Rel *dr)
+{
+        int ec;
+        Elf *e;
+        Elf_Scn *scn;
+        Elf32_Rel *rel32;
+        Elf64_Rel *rel64;
+        size_t msz;
+        uint32_t sh_type;
+
+        if (d == NULL || ndx < 0 || dr == NULL ||
+            (scn = d->d_scn) == NULL ||
+            (e = scn->s_elf) == NULL) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        ec = e->e_class;
+        assert(ec == ELFCLASS32 || ec == ELFCLASS64);
+
+        if (ec == ELFCLASS32)
+                sh_type = scn->s_shdr.s_shdr32.sh_type;
+        else
+                sh_type = scn->s_shdr.s_shdr64.sh_type;
+
+        if (_libelf_xlate_shtype(sh_type) != ELF_T_REL) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        msz = _libelf_msize(ELF_T_REL, ec, e->e_version);
+        assert(msz > 0);
+
+        if (msz * ndx >= d->d_size) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        if (ec == ELFCLASS32) {
+                rel32 = (Elf32_Rel *) d->d_buf + ndx;
+
+                LIBELF_COPY_U32(rel32, dr, r_offset);
+                LIBELF_COPY_U32(rel32, dr, r_info);
+        } else {
+                rel64 = (Elf64_Rel *) d->d_buf + ndx;
+
+                *rel64 = *dr;
+        }
+
+        return (1);
+}
diff --git a/ext/libelf/gelf_rela.c b/ext/libelf/gelf_rela.c
new file mode 100644 (file)
index 0000000..fbd2a2c
--- /dev/null
@@ -0,0 +1,143 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <limits.h>
+
+#include <assert.h>
+#include "gelf.h"
+
+#include "_libelf.h"
+
+GElf_Rela *
+gelf_getrela(Elf_Data *d, int ndx, GElf_Rela *dst)
+{
+        int ec;
+        Elf *e;
+        Elf_Scn *scn;
+        Elf32_Rela *rela32;
+        Elf64_Rela *rela64;
+        size_t msz;
+        uint32_t sh_type;
+
+        if (d == NULL || ndx < 0 || dst == NULL ||
+            (scn = d->d_scn) == NULL ||
+            (e = scn->s_elf) == NULL) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        ec = e->e_class;
+        assert(ec == ELFCLASS32 || ec == ELFCLASS64);
+
+        if (ec == ELFCLASS32)
+                sh_type = scn->s_shdr.s_shdr32.sh_type;
+        else
+                sh_type = scn->s_shdr.s_shdr64.sh_type;
+
+        if (_libelf_xlate_shtype(sh_type) != ELF_T_RELA) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        msz = _libelf_msize(ELF_T_RELA, ec, e->e_version);
+
+        assert(msz > 0);
+
+        if (msz * ndx >= d->d_size) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        if (ec == ELFCLASS32) {
+                rela32 = (Elf32_Rela *) d->d_buf + ndx;
+
+                dst->r_offset = (Elf64_Addr) rela32->r_offset;
+                dst->r_info   = (Elf64_Xword) rela32->r_info;
+                dst->r_addend = (Elf64_Sxword) rela32->r_addend;
+
+        } else {
+
+                rela64 = (Elf64_Rela *) d->d_buf + ndx;
+
+                *dst = *rela64;
+        }
+
+        return (dst);
+}
+
+int
+gelf_update_rela(Elf_Data *d, int ndx, GElf_Rela *dr)
+{
+        int ec;
+        Elf *e;
+        Elf_Scn *scn;
+        Elf32_Rela *rela32;
+        Elf64_Rela *rela64;
+        size_t msz;
+        uint32_t sh_type;
+
+        if (d == NULL || ndx < 0 || dr == NULL ||
+            (scn = d->d_scn) == NULL ||
+            (e = scn->s_elf) == NULL) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        ec = e->e_class;
+        assert(ec == ELFCLASS32 || ec == ELFCLASS64);
+
+        if (ec == ELFCLASS32)
+                sh_type = scn->s_shdr.s_shdr32.sh_type;
+        else
+                sh_type = scn->s_shdr.s_shdr64.sh_type;
+
+        if (_libelf_xlate_shtype(sh_type) != ELF_T_RELA) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        msz = _libelf_msize(ELF_T_RELA, ec, e->e_version);
+        assert(msz > 0);
+
+        if (msz * ndx >= d->d_size) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        if (ec == ELFCLASS32) {
+                rela32 = (Elf32_Rela *) d->d_buf + ndx;
+
+                LIBELF_COPY_U32(rela32, dr, r_offset);
+                LIBELF_COPY_U32(rela32, dr, r_info);
+                LIBELF_COPY_S32(rela32, dr, r_addend);
+        } else {
+                rela64 = (Elf64_Rela *) d->d_buf + ndx;
+
+                *rela64 = *dr;
+        }
+
+        return (1);
+}
diff --git a/ext/libelf/gelf_shdr.c b/ext/libelf/gelf_shdr.c
new file mode 100644 (file)
index 0000000..16d6434
--- /dev/null
@@ -0,0 +1,128 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <limits.h>
+
+#include <assert.h>
+#include "gelf.h"
+#include "libelf.h"
+
+#include "_libelf.h"
+
+Elf32_Shdr *
+elf32_getshdr(Elf_Scn *s)
+{
+        return (_libelf_getshdr(s, ELFCLASS32));
+}
+
+Elf64_Shdr *
+elf64_getshdr(Elf_Scn *s)
+{
+        return (_libelf_getshdr(s, ELFCLASS64));
+}
+
+GElf_Shdr *
+gelf_getshdr(Elf_Scn *s, GElf_Shdr *d)
+{
+        int ec;
+        void *sh;
+        Elf32_Shdr *sh32;
+        Elf64_Shdr *sh64;
+
+        if (d == NULL) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        if ((sh = _libelf_getshdr(s, ELFCLASSNONE)) == NULL)
+                return (NULL);
+
+        ec = s->s_elf->e_class;
+        assert(ec == ELFCLASS32 || ec == ELFCLASS64);
+
+        if (ec == ELFCLASS32) {
+                sh32 = (Elf32_Shdr *) sh;
+
+                d->sh_name      = sh32->sh_name;
+                d->sh_type      = sh32->sh_type;
+                d->sh_flags     = (Elf64_Xword) sh32->sh_flags;
+                d->sh_addr      = (Elf64_Addr) sh32->sh_addr;
+                d->sh_offset    = (Elf64_Off) sh32->sh_offset;
+                d->sh_size      = (Elf64_Xword) sh32->sh_size;
+                d->sh_link      = sh32->sh_link;
+                d->sh_info      = sh32->sh_info;
+                d->sh_addralign = (Elf64_Xword) sh32->sh_addralign;
+                d->sh_entsize   = (Elf64_Xword) sh32->sh_entsize;
+        } else {
+                sh64 = (Elf64_Shdr *) sh;
+                *d = *sh64;
+        }
+
+        return (d);
+}
+
+int
+gelf_update_shdr(Elf_Scn *scn, GElf_Shdr *s)
+{
+        int ec;
+        Elf *e;
+        Elf32_Shdr *sh32;
+
+
+        if (s == NULL || scn == NULL || (e = scn->s_elf) == NULL ||
+            e->e_kind != ELF_K_ELF ||
+            ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        if (e->e_cmd == ELF_C_READ) {
+                LIBELF_SET_ERROR(MODE, 0);
+                return (0);
+        }
+
+        if (ec == ELFCLASS64) {
+                scn->s_shdr.s_shdr64 = *s;
+                return (1);
+        }
+
+        sh32 = &scn->s_shdr.s_shdr32;
+
+        sh32->sh_name   =  s->sh_name;
+        sh32->sh_type   =  s->sh_type;
+        LIBELF_COPY_U32(sh32, s, sh_flags);
+        LIBELF_COPY_U32(sh32, s, sh_addr);
+        LIBELF_COPY_U32(sh32, s, sh_offset);
+        LIBELF_COPY_U32(sh32, s, sh_size);
+        sh32->sh_link   =  s->sh_link;
+        sh32->sh_info   =  s->sh_info;
+        LIBELF_COPY_U32(sh32, s, sh_addralign);
+        LIBELF_COPY_U32(sh32, s, sh_entsize);
+
+        (void) elf_flagscn(scn, ELF_C_SET, ELF_F_DIRTY);
+
+        return (1);
+}
diff --git a/ext/libelf/gelf_sym.c b/ext/libelf/gelf_sym.c
new file mode 100644 (file)
index 0000000..78c8a08
--- /dev/null
@@ -0,0 +1,151 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <limits.h>
+
+#include <assert.h>
+#include "gelf.h"
+
+#include "_libelf.h"
+
+GElf_Sym *
+gelf_getsym(Elf_Data *d, int ndx, GElf_Sym *dst)
+{
+        int ec;
+        Elf *e;
+        Elf_Scn *scn;
+        Elf32_Sym *sym32;
+        Elf64_Sym *sym64;
+        size_t msz;
+        uint32_t sh_type;
+
+        if (d == NULL || ndx < 0 || dst == NULL ||
+            (scn = d->d_scn) == NULL ||
+            (e = scn->s_elf) == NULL) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        ec = e->e_class;
+        assert(ec == ELFCLASS32 || ec == ELFCLASS64);
+
+        if (ec == ELFCLASS32)
+                sh_type = scn->s_shdr.s_shdr32.sh_type;
+        else
+                sh_type = scn->s_shdr.s_shdr64.sh_type;
+
+        if (_libelf_xlate_shtype(sh_type) != ELF_T_SYM) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        msz = _libelf_msize(ELF_T_SYM, ec, e->e_version);
+
+        assert(msz > 0);
+
+        if (msz * ndx >= d->d_size) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        if (ec == ELFCLASS32) {
+
+                sym32 = (Elf32_Sym *) d->d_buf + ndx;
+
+                dst->st_name  = sym32->st_name;
+                dst->st_value = (Elf64_Addr) sym32->st_value;
+                dst->st_size  = (Elf64_Xword) sym32->st_size;
+                dst->st_info  = ELF64_ST_INFO(ELF32_ST_BIND(sym32->st_info),
+                    ELF32_ST_TYPE(sym32->st_info));
+                dst->st_other = sym32->st_other;
+                dst->st_shndx = sym32->st_shndx;
+        } else {
+
+                sym64 = (Elf64_Sym *) d->d_buf + ndx;
+
+                *dst = *sym64;
+        }
+
+        return (dst);
+}
+
+int
+gelf_update_sym(Elf_Data *d, int ndx, GElf_Sym *gs)
+{
+        int ec;
+        Elf *e;
+        Elf_Scn *scn;
+        Elf32_Sym *sym32;
+        Elf64_Sym *sym64;
+        size_t msz;
+        uint32_t sh_type;
+
+        if (d == NULL || ndx < 0 || gs == NULL ||
+            (scn = d->d_scn) == NULL ||
+            (e = scn->s_elf) == NULL) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        ec = e->e_class;
+        assert(ec == ELFCLASS32 || ec == ELFCLASS64);
+
+        if (ec == ELFCLASS32)
+                sh_type = scn->s_shdr.s_shdr32.sh_type;
+        else
+                sh_type = scn->s_shdr.s_shdr64.sh_type;
+
+        if (_libelf_xlate_shtype(sh_type) != ELF_T_SYM) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        msz = _libelf_msize(ELF_T_SYM, ec, e->e_version);
+        assert(msz > 0);
+
+        if (msz * ndx >= d->d_size) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        if (ec == ELFCLASS32) {
+                sym32 = (Elf32_Sym *) d->d_buf + ndx;
+
+                sym32->st_name  = gs->st_name;
+                sym32->st_info  = gs->st_info;
+                sym32->st_other = gs->st_other;
+                sym32->st_shndx = gs->st_shndx;
+
+                LIBELF_COPY_U32(sym32, gs, st_value);
+                LIBELF_COPY_U32(sym32, gs, st_size);
+        } else {
+                sym64 = (Elf64_Sym *) d->d_buf + ndx;
+
+                *sym64 = *gs;
+        }
+
+        return (1);
+}
diff --git a/ext/libelf/gelf_symshndx.c b/ext/libelf/gelf_symshndx.c
new file mode 100644 (file)
index 0000000..ec948fd
--- /dev/null
@@ -0,0 +1,126 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <limits.h>
+
+#include <assert.h>
+#include "gelf.h"
+
+#include "_libelf.h"
+
+GElf_Sym *
+gelf_getsymshndx(Elf_Data *d, Elf_Data *id, int ndx, GElf_Sym *dst,
+    Elf32_Word *shindex)
+{
+        int ec;
+        Elf *e;
+        Elf_Scn *scn;
+        size_t msz;
+        uint32_t sh_type;
+
+        if (gelf_getsym(d, ndx, dst) == 0)
+                return (NULL);
+
+        if (id == NULL || (scn = id->d_scn) == NULL ||
+            (e = scn->s_elf) == NULL || (e != d->d_scn->s_elf) ||
+            shindex == NULL) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        ec = e->e_class;
+        assert(ec == ELFCLASS32 || ec == ELFCLASS64);
+
+        if (ec == ELFCLASS32)
+                sh_type = scn->s_shdr.s_shdr32.sh_type;
+        else
+                sh_type = scn->s_shdr.s_shdr64.sh_type;
+
+        if (_libelf_xlate_shtype(sh_type) != ELF_T_WORD ||
+           id->d_type != ELF_T_WORD) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        msz = _libelf_msize(ELF_T_WORD, ec, e->e_version);
+
+        assert(msz > 0);
+
+        if (msz * ndx >= id->d_size) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        *shindex = ((Elf32_Word *) id->d_buf)[ndx];
+
+        return (dst);
+}
+
+int
+gelf_update_symshndx(Elf_Data *d, Elf_Data *id, int ndx, GElf_Sym *gs,
+    Elf32_Word xindex)
+{
+        int ec;
+        Elf *e;
+        Elf_Scn *scn;
+        size_t msz;
+        uint32_t sh_type;
+
+        if (gelf_update_sym(d, ndx, gs) == 0)
+                return (0);
+
+        if (id == NULL || (scn = id->d_scn) == NULL ||
+            (e = scn->s_elf) == NULL || (e != d->d_scn->s_elf)) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        ec = e->e_class;
+        assert(ec == ELFCLASS32 || ec == ELFCLASS64);
+
+        if (ec == ELFCLASS32)
+                sh_type = scn->s_shdr.s_shdr32.sh_type;
+        else
+                sh_type = scn->s_shdr.s_shdr64.sh_type;
+
+        if (_libelf_xlate_shtype(sh_type) != ELF_T_WORD ||
+            d->d_type != ELF_T_WORD) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        msz = _libelf_msize(ELF_T_WORD, ec, e->e_version);
+        assert(msz > 0);
+
+        if (msz * ndx >= id->d_size) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0);
+        }
+
+        *(((Elf32_Word *) id->d_buf) + ndx) = xindex;
+
+        return (1);
+}
diff --git a/ext/libelf/gelf_xlate.c b/ext/libelf/gelf_xlate.c
new file mode 100644 (file)
index 0000000..8ab98ad
--- /dev/null
@@ -0,0 +1,76 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "gelf.h"
+#include "libelf.h"
+#include <string.h>
+
+#include "_libelf.h"
+
+
+Elf_Data *
+elf32_xlatetof(Elf_Data *dst, const Elf_Data *src, unsigned int encoding)
+{
+        return _libelf_xlate(dst, src, encoding, ELFCLASS32, ELF_TOFILE);
+}
+
+Elf_Data *
+elf64_xlatetof(Elf_Data *dst, const Elf_Data *src, unsigned int encoding)
+{
+        return _libelf_xlate(dst, src, encoding, ELFCLASS64, ELF_TOFILE);
+}
+
+Elf_Data *
+elf32_xlatetom(Elf_Data *dst, const Elf_Data *src, unsigned int encoding)
+{
+        return _libelf_xlate(dst, src, encoding, ELFCLASS32, ELF_TOMEMORY);
+}
+
+Elf_Data *
+elf64_xlatetom(Elf_Data *dst, const Elf_Data *src, unsigned int encoding)
+{
+        return _libelf_xlate(dst, src, encoding, ELFCLASS64, ELF_TOMEMORY);
+}
+
+Elf_Data *
+gelf_xlatetom(Elf *e, Elf_Data *dst, const Elf_Data *src, unsigned int encoding)
+{
+        if (e != NULL)
+                return (_libelf_xlate(dst, src, encoding, e->e_class,
+                    ELF_TOMEMORY));
+        LIBELF_SET_ERROR(ARGUMENT, 0);
+        return (NULL);
+}
+
+Elf_Data *
+gelf_xlatetof(Elf *e, Elf_Data *dst, const Elf_Data *src, unsigned int encoding)
+{
+        if (e != NULL)
+                return (_libelf_xlate(dst, src, encoding, e->e_class,
+                    ELF_TOFILE));
+        LIBELF_SET_ERROR(ARGUMENT, 0);
+        return (NULL);
+}
diff --git a/ext/libelf/libelf.c b/ext/libelf/libelf.c
new file mode 100644 (file)
index 0000000..73f25a2
--- /dev/null
@@ -0,0 +1,51 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/param.h>
+
+#include "libelf.h"
+#include "_libelf.h"
+
+struct _libelf_globals *
+_libelf_private()
+{
+        static int initialized = 0;
+        static struct _libelf_globals private;
+
+        if (!initialized) {
+                uint32_t endian_test = ELFDATA2MSB << 24 | ELFDATA2LSB;
+
+                private.libelf_arch            = EM_NONE;
+                private.libelf_byteorder       = *(char *)&endian_test;
+                private.libelf_class           = ELFCLASSNONE;
+                private.libelf_error           = 0;
+                private.libelf_fillchar                = 0;
+                private.libelf_version         = EV_NONE;
+                initialized = 1;
+        }
+
+        return &private;
+}
diff --git a/ext/libelf/libelf.h b/ext/libelf/libelf.h
new file mode 100644 (file)
index 0000000..51b9a85
--- /dev/null
@@ -0,0 +1,249 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD: src/lib/libelf/libelf.h,v 1.1 2006/11/11 17:16:33 jkoshy Exp $
+ */
+
+#ifndef        _LIBELF_H_
+#define        _LIBELF_H_
+
+#include <sys/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "elf_queue.h"
+#include "elf32.h"
+#include "elf64.h"
+
+/* Library private data structures */
+typedef struct _Elf Elf;
+typedef struct _Elf_Scn Elf_Scn;
+
+/* File types */
+typedef enum {
+        ELF_K_NONE = 0,
+        ELF_K_AR,      /* `ar' archives */
+        ELF_K_COFF,    /* COFF files (unsupported) */
+        ELF_K_ELF,     /* ELF files */
+        ELF_K_NUM
+} Elf_Kind;
+
+#define        ELF_K_FIRST     ELF_K_NONE
+#define        ELF_K_LAST      ELF_K_NUM
+
+/* Data types */
+typedef enum {
+        ELF_T_ADDR,
+        ELF_T_BYTE,
+        ELF_T_CAP,
+        ELF_T_DYN,
+        ELF_T_EHDR,
+        ELF_T_HALF,
+        ELF_T_LWORD,
+        ELF_T_MOVE,
+        ELF_T_MOVEP,
+        ELF_T_NOTE,
+        ELF_T_OFF,
+        ELF_T_PHDR,
+        ELF_T_REL,
+        ELF_T_RELA,
+        ELF_T_SHDR,
+        ELF_T_SWORD,
+        ELF_T_SXWORD,
+        ELF_T_SYMINFO,
+        ELF_T_SYM,
+        ELF_T_VDEF,
+        ELF_T_VNEED,
+        ELF_T_WORD,
+        ELF_T_XWORD,
+        ELF_T_NUM
+} Elf_Type;
+
+#define        ELF_T_FIRST     ELF_T_ADDR
+#define        ELF_T_LAST      ELF_T_XWORD
+
+/* Commands */
+typedef enum {
+        ELF_C_NULL = 0,
+        ELF_C_CLR,
+        ELF_C_FDDONE,
+        ELF_C_FDREAD,
+        ELF_C_RDWR,
+        ELF_C_READ,
+        ELF_C_SET,
+        ELF_C_WRITE,
+        ELF_C_NUM
+} Elf_Cmd;
+
+#define        ELF_C_FIRST     ELF_C_NULL
+#define        ELF_C_LAST      ELF_C_NUM
+
+/*
+ * An `Elf_Data' structure describes data in an
+ * ELF section.
+ */
+typedef struct _Elf_Data {
+        /*
+         * `Public' members that are part of the ELF(3) API.
+         */
+        uint64_t       d_align;
+        void           *d_buf;
+        uint64_t       d_off;
+        uint64_t       d_size;
+        Elf_Type       d_type;
+        unsigned int   d_version;
+
+        /*
+         * Members that are not part of the public API.
+         */
+        Elf_Scn                *d_scn;         /* containing section */
+        unsigned int   d_flags;
+        STAILQ_ENTRY(_Elf_Data)        d_next;
+} Elf_Data;
+
+/*
+ * An `Elf_Arhdr' structure describes an archive
+ * header.
+ */
+typedef struct {
+        time_t         ar_date;
+        char           *ar_name;       /* archive member name */
+        gid_t          ar_gid;
+        mode_t         ar_mode;
+        char           *ar_rawname;    /* 'raw' member name */
+        size_t         ar_size;
+        uid_t          ar_uid;
+} Elf_Arhdr;
+
+/*
+ * An `Elf_Arsym' describes an entry in the archive
+ * symbol table.
+ */
+typedef struct {
+        off_t          as_off;         /* byte offset to member's header */
+        unsigned long  as_hash;        /* elf_hash() value for name */
+        char           *as_name;       /* null terminated symbol name */
+} Elf_Arsym;
+
+/*
+ * Error numbers.
+ */
+
+enum Elf_Error {
+        ELF_E_NONE,    /* No error */
+        ELF_E_ARCHIVE, /* Malformed ar(1) archive */
+        ELF_E_ARGUMENT,        /* Invalid argument */
+        ELF_E_CLASS,   /* Mismatched ELF class */
+        ELF_E_DATA,    /* Invalid data descriptor */
+        ELF_E_HEADER,  /* Missing or malformed ELF header */
+        ELF_E_IO,      /* I/O error */
+        ELF_E_LAYOUT,  /* Layout constraint violation */
+        ELF_E_MODE,    /* Wrong mode for ELF descriptor */
+        ELF_E_RANGE,   /* Value out of range */
+        ELF_E_RESOURCE,        /* Resource exhaustion */
+        ELF_E_SECTION, /* Invalid section descriptor */
+        ELF_E_SEQUENCE,        /* API calls out of sequence */
+        ELF_E_UNIMPL,  /* Feature is unimplemented */
+        ELF_E_VERSION, /* Unknown API version */
+        ELF_E_NUM      /* Max error number */
+};
+
+/*
+ * Flags defined by the API.
+ */
+
+#define        ELF_F_LAYOUT    0x001U  /* application will layout the file */
+#define        ELF_F_DIRTY     0x002U  /* a section or ELF file is dirty */
+
+Elf            *elf_begin(int _fd, Elf_Cmd _cmd, Elf *_elf);
+int            elf_cntl(Elf *_elf, Elf_Cmd _cmd);
+int            elf_end(Elf *_elf);
+const char     *elf_errmsg(int _error);
+int            elf_errno(void);
+void           elf_fill(int _fill);
+unsigned int   elf_flagdata(Elf_Data *_data, Elf_Cmd _cmd, unsigned int _flags);
+unsigned int   elf_flagehdr(Elf *_elf, Elf_Cmd _cmd, unsigned int _flags);
+unsigned int   elf_flagelf(Elf *_elf, Elf_Cmd _cmd, unsigned int _flags);
+unsigned int   elf_flagphdr(Elf *_elf, Elf_Cmd _cmd, unsigned int _flags);
+unsigned int   elf_flagscn(Elf_Scn *_scn, Elf_Cmd _cmd, unsigned int _flags);
+unsigned int   elf_flagshdr(Elf_Scn *_scn, Elf_Cmd _cmd, unsigned int _flags);
+Elf_Arhdr      *elf_getarhdr(Elf *_elf);
+Elf_Arsym      *elf_getarsym(Elf *_elf, size_t *_ptr);
+off_t          elf_getbase(Elf *_elf);
+Elf_Data       *elf_getdata(Elf_Scn *, Elf_Data *);
+char           *elf_getident(Elf *_elf, size_t *_ptr);
+int            elf_getphnum(Elf *_elf, size_t *_dst);
+Elf_Scn                *elf_getscn(Elf *_elf, size_t _index);
+int            elf_getshnum(Elf *_elf, size_t *_dst);
+int            elf_getshstrndx(Elf *_elf, size_t *_dst);
+unsigned long  elf_hash(const char *_name);
+Elf_Kind       elf_kind(Elf *_elf);
+Elf            *elf_memory(char *_image, size_t _size);
+size_t         elf_ndxscn(Elf_Scn *_scn);
+Elf_Data       *elf_newdata(Elf_Scn *_scn);
+Elf_Scn                *elf_newscn(Elf *_elf);
+Elf_Scn                *elf_nextscn(Elf *_elf, Elf_Scn *_scn);
+Elf_Cmd                elf_next(Elf *_elf);
+off_t          elf_rand(Elf *_elf, off_t _off);
+Elf_Data       *elf_rawdata(Elf_Scn *_scn, Elf_Data *_data);
+char           *elf_rawfile(Elf *_elf, size_t *_size);
+int            elf_setshstrndx(Elf *_elf, size_t _shnum);
+char           *elf_strptr(Elf *_elf, size_t _section, size_t _offset);
+off_t          elf_update(Elf *_elf, Elf_Cmd _cmd);
+unsigned int   elf_version(unsigned int _version);
+
+long           elf32_checksum(Elf *_elf);
+size_t         elf32_fsize(Elf_Type _type, size_t _count,
+                        unsigned int _version);
+Elf32_Ehdr     *elf32_getehdr(Elf *_elf);
+Elf32_Phdr     *elf32_getphdr(Elf *_elf);
+Elf32_Shdr     *elf32_getshdr(Elf_Scn *_scn);
+Elf32_Ehdr     *elf32_newehdr(Elf *_elf);
+Elf32_Phdr     *elf32_newphdr(Elf *_elf, size_t _count);
+Elf_Data       *elf32_xlatetof(Elf_Data *_dst, const Elf_Data *_src,
+                        unsigned int _enc);
+Elf_Data       *elf32_xlatetom(Elf_Data *_dst, const Elf_Data *_src,
+                        unsigned int _enc);
+
+long           elf64_checksum(Elf *_elf);
+size_t         elf64_fsize(Elf_Type _type, size_t _count,
+                        unsigned int _version);
+Elf64_Ehdr     *elf64_getehdr(Elf *_elf);
+Elf64_Phdr     *elf64_getphdr(Elf *_elf);
+Elf64_Shdr     *elf64_getshdr(Elf_Scn *_scn);
+Elf64_Ehdr     *elf64_newehdr(Elf *_elf);
+Elf64_Phdr     *elf64_newphdr(Elf *_elf, size_t _count);
+Elf_Data       *elf64_xlatetof(Elf_Data *_dst, const Elf_Data *_src,
+                        unsigned int _enc);
+Elf_Data       *elf64_xlatetom(Elf_Data *_dst, const Elf_Data *_src,
+                        unsigned int _enc);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _LIBELF_H_ */
diff --git a/ext/libelf/libelf_align.c b/ext/libelf/libelf_align.c
new file mode 100644 (file)
index 0000000..af44ecd
--- /dev/null
@@ -0,0 +1,130 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/types.h>
+
+//#include <machine/elf.h>
+//#include <machine/endian.h>
+
+#include "libelf.h"
+
+#include "_libelf.h"
+
+struct align {
+        int a32;
+        int a64;
+};
+
+#ifdef __GNUC__
+#define        MALIGN(N)       {                                       \
+                .a32 = __alignof__(Elf32_##N),                 \
+                .a64 = __alignof__(Elf64_##N)                  \
+        }
+#define        MALIGN64(V)       {                                     \
+                .a32 = 0,                                      \
+                .a64 = __alignof__(Elf64_##V)                  \
+        }
+#else
+#error Need the __alignof__ builtin.
+#endif
+#define        UNSUPPORTED()   {                                       \
+                .a32 = 0,                                      \
+                .a64 = 0                                       \
+        }
+
+static struct align malign[ELF_T_NUM] = {
+        [ELF_T_ADDR]   = MALIGN(Addr),
+        [ELF_T_BYTE]   = { .a32 = 1, .a64 = 1 },
+        [ELF_T_CAP]    = MALIGN(Cap),
+        [ELF_T_DYN]    = MALIGN(Dyn),
+        [ELF_T_EHDR]   = MALIGN(Ehdr),
+        [ELF_T_HALF]   = MALIGN(Half),
+        [ELF_T_LWORD]  = MALIGN(Lword),
+        [ELF_T_MOVE]   = MALIGN(Move),
+        [ELF_T_MOVEP]  = UNSUPPORTED(),
+        [ELF_T_NOTE]   = MALIGN(Nhdr),
+        [ELF_T_OFF]    = MALIGN(Off),
+        [ELF_T_PHDR]   = MALIGN(Phdr),
+        [ELF_T_REL]    = MALIGN(Rel),
+        [ELF_T_RELA]   = MALIGN(Rela),
+        [ELF_T_SHDR]   = MALIGN(Shdr),
+        [ELF_T_SWORD]  = MALIGN(Sword),
+        [ELF_T_SXWORD] = MALIGN64(Sxword),
+        [ELF_T_SYM]    = MALIGN(Sym),
+        [ELF_T_SYMINFO]        = MALIGN(Syminfo),
+        [ELF_T_VDEF]   = MALIGN(Verdef),
+        [ELF_T_VNEED]  = MALIGN(Verneed),
+        [ELF_T_WORD]   = MALIGN(Word),
+        [ELF_T_XWORD]  = MALIGN64(Xword)
+};
+
+int
+_libelf_malign(Elf_Type t, int elfclass)
+{
+        if (t >= ELF_T_NUM || (int) t < 0)
+                return (0);
+
+        return (elfclass == ELFCLASS32 ? malign[t].a32 :
+            malign[t].a64);
+}
+
+#define        FALIGN(A32,A64) { .a32 = (A32), .a64 = (A64) }
+
+static struct align falign[ELF_T_NUM] = {
+        [ELF_T_ADDR]   = FALIGN(4,8),
+        [ELF_T_BYTE]   = FALIGN(1,1),
+        [ELF_T_CAP]    = FALIGN(4,8),
+        [ELF_T_DYN]    = FALIGN(4,8),
+        [ELF_T_EHDR]   = FALIGN(4,8),
+        [ELF_T_HALF]   = FALIGN(2,2),
+        [ELF_T_LWORD]  = FALIGN(8,8),
+        [ELF_T_MOVE]   = FALIGN(8,8),
+        [ELF_T_MOVEP]  = UNSUPPORTED(),
+        [ELF_T_NOTE]   = FALIGN(4,4),
+        [ELF_T_OFF]    = FALIGN(4,8),
+        [ELF_T_PHDR]   = FALIGN(4,8),
+        [ELF_T_REL]    = FALIGN(4,8),
+        [ELF_T_RELA]   = FALIGN(4,8),
+        [ELF_T_SHDR]   = FALIGN(4,8),
+        [ELF_T_SWORD]  = FALIGN(4,4),
+        [ELF_T_SXWORD] = FALIGN(0,8),
+        [ELF_T_SYM]    = FALIGN(4,8),
+        [ELF_T_SYMINFO]        = FALIGN(2,2),
+        [ELF_T_VDEF]   = FALIGN(4,4),
+        [ELF_T_VNEED]  = FALIGN(4,4),
+        [ELF_T_WORD]   = FALIGN(4,4),
+        [ELF_T_XWORD]  = FALIGN(0,8)
+};
+
+int
+_libelf_falign(Elf_Type t, int elfclass)
+{
+        if (t >= ELF_T_NUM || (int) t < 0)
+                return (0);
+
+        return (elfclass == ELFCLASS32 ? falign[t].a32 :
+            falign[t].a64);
+}
diff --git a/ext/libelf/libelf_allocate.c b/ext/libelf/libelf_allocate.c
new file mode 100644 (file)
index 0000000..9e1280c
--- /dev/null
@@ -0,0 +1,206 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * Internal APIs
+ */
+
+#include <errno.h>
+
+#include <assert.h>
+#include "libelf.h"
+#include <stdlib.h>
+#include <string.h>
+
+#include "_libelf.h"
+
+Elf *
+_libelf_allocate_elf(void)
+{
+        Elf *e;
+
+        if ((e = malloc(sizeof(*e))) == NULL) {
+                LIBELF_SET_ERROR(RESOURCE, errno);
+                return NULL;
+        }
+
+        e->e_activations = 1;
+        e->e_arhdr      = NULL;
+        e->e_byteorder   = ELFDATANONE;
+        e->e_class       = ELFCLASSNONE;
+        e->e_cmd         = ELF_C_NULL;
+        e->e_fd          = -1;
+        e->e_flags      = 0;
+        e->e_kind        = ELF_K_NONE;
+        e->e_parent      = NULL;
+        e->e_rawfile     = NULL;
+        e->e_rawsize     = 0;
+        e->e_version     = LIBELF_PRIVATE(version);
+
+        (void) memset(&e->e_u, 0, sizeof(e->e_u));
+
+        return (e);
+}
+
+void
+_libelf_init_elf(Elf *e, Elf_Kind kind)
+{
+        assert(e != NULL);
+        assert(e->e_kind == ELF_K_NONE);
+
+        e->e_kind = kind;
+
+        switch (kind) {
+        case ELF_K_ELF:
+                STAILQ_INIT(&e->e_u.e_elf.e_scn);
+                break;
+        default:
+                break;
+        }
+}
+
+#define        FREE(P)         do {                            \
+                if (P)                                 \
+                        free(P);                       \
+        } while (0)
+
+
+Elf *
+_libelf_release_elf(Elf *e)
+{
+        switch (e->e_kind) {
+        case ELF_K_AR:
+                FREE(e->e_u.e_ar.e_symtab);
+                break;
+
+        case ELF_K_ELF:
+                switch (e->e_class) {
+                case ELFCLASS32:
+                        FREE(e->e_u.e_elf.e_ehdr.e_ehdr32);
+                        FREE(e->e_u.e_elf.e_phdr.e_phdr32);
+                        break;
+                case ELFCLASS64:
+                        FREE(e->e_u.e_elf.e_ehdr.e_ehdr64);
+                        FREE(e->e_u.e_elf.e_phdr.e_phdr64);
+                        break;
+                }
+
+                assert(STAILQ_EMPTY(&e->e_u.e_elf.e_scn));
+
+                if (e->e_arhdr) {
+                        FREE(e->e_arhdr->ar_name);
+                        FREE(e->e_arhdr->ar_rawname);
+                        free(e->e_arhdr);
+                }
+
+                break;
+
+        default:
+                break;
+        }
+
+        free(e);
+
+        return (NULL);
+}
+
+Elf_Data *
+_libelf_allocate_data(Elf_Scn *s)
+{
+        Elf_Data *d;
+
+        if ((d = calloc((size_t) 1, sizeof(Elf_Data))) == NULL) {
+                LIBELF_SET_ERROR(RESOURCE, 0);
+                return (NULL);
+        }
+
+        d->d_scn = s;
+
+        return (d);
+}
+
+Elf_Data *
+_libelf_release_data(Elf_Data *d)
+{
+
+        if (d->d_flags & LIBELF_F_MALLOCED)
+                free(d->d_buf);
+
+        free(d);
+
+        return (NULL);
+}
+
+Elf_Scn *
+_libelf_allocate_scn(Elf *e, size_t ndx)
+{
+        Elf_Scn *s;
+
+        if ((s = calloc((size_t) 1, sizeof(Elf_Scn))) == NULL) {
+                LIBELF_SET_ERROR(RESOURCE, errno);
+                return (NULL);
+        }
+
+        s->s_elf = e;
+        s->s_ndx = ndx;
+
+        STAILQ_INIT(&s->s_data);
+        STAILQ_INIT(&s->s_rawdata);
+
+        STAILQ_INSERT_TAIL(&e->e_u.e_elf.e_scn, s, s_next);
+
+        return (s);
+}
+
+Elf_Scn *
+_libelf_release_scn(Elf_Scn *s)
+{
+        Elf *e;
+        Elf_Data *d, *td;
+
+        assert(s != NULL);
+
+        STAILQ_FOREACH_SAFE(d, &s->s_data, d_next, td) {
+                STAILQ_REMOVE(&s->s_data, d, _Elf_Data, d_next);
+                d = _libelf_release_data(d);
+        }
+
+        STAILQ_FOREACH_SAFE(d, &s->s_rawdata, d_next, td) {
+                assert((d->d_flags & LIBELF_F_MALLOCED) == 0);
+                STAILQ_REMOVE(&s->s_rawdata, d, _Elf_Data, d_next);
+                d = _libelf_release_data(d);
+        }
+
+        e = s->s_elf;
+
+        assert(e != NULL);
+
+        STAILQ_REMOVE(&e->e_u.e_elf.e_scn, s, _Elf_Scn, s_next);
+
+        free(s);
+
+        return (NULL);
+}
diff --git a/ext/libelf/libelf_ar.c b/ext/libelf/libelf_ar.c
new file mode 100644 (file)
index 0000000..01e1624
--- /dev/null
@@ -0,0 +1,481 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS `AS IS' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <ar.h>
+#include <assert.h>
+#include <ctype.h>
+#include "libelf.h"
+#include <stdlib.h>
+#include <string.h>
+
+#include "_libelf.h"
+
+#define        LIBELF_NALLOC_SIZE      16
+
+/*
+ * `ar' archive handling.
+ *
+ * `ar' archives start with signature `ARMAG'.  Each archive member is
+ * preceded by a header containing meta-data for the member.  This
+ * header is described in <ar.h> (struct ar_hdr).  The header always
+ * starts on an even address.  File data is padded with "\n"
+ * characters to keep this invariant.
+ *
+ * Special considerations for `ar' archives:
+ *
+ * The `ar' header only has space for a 16 character file name.  File
+ * names are terminated with a '/', so this effectively leaves 15
+ * characters for the actual file name.  In order to accomodate longer
+ * file names, names may be stored in a separate 'string table' and
+ * referenced indirectly by a member header.  The string table itself
+ * appears as an archive member with name "// ".  An indirect file name
+ * in an `ar' header matches the pattern "/[0-9]*". The digits form a
+ * decimal number that corresponds to a byte offset into the string
+ * table where the actual file name of the object starts.  Strings in
+ * the string table are padded to start on even addresses.
+ *
+ * Archives may also have a symbol table (see ranlib(1)), mapping
+ * program symbols to object files inside the archive.  A symbol table
+ * uses a file name of "/ " in its archive header.  The symbol table
+ * is structured as:
+ *  - a 4-byte count of entries stored as a binary value, MSB first
+ *  - 'n' 4-byte offsets, stored as binary values, MSB first
+ *  - 'n' NUL-terminated strings, for ELF symbol names, stored unpadded.
+ *
+ * If the symbol table and string table are is present in an archive
+ * they must be the very first objects and in that order.
+ */
+
+/*
+ * Convert a string bounded by `start' and `start+sz' (exclusive) to a
+ * number in the specified base.
+ */
+static int
+_libelf_ar_get_number(char *s, size_t sz, int base, size_t *ret)
+{
+        int c, v;
+        size_t r;
+        char *e;
+
+        assert(base <= 10);
+
+        e = s + sz;
+
+        /* skip leading blanks */
+        for (;s < e && (c = *s) == ' '; s++)
+                ;
+
+        r = 0L;
+        for (;s < e; s++) {
+                if ((c = *s) == ' ')
+                        break;
+                if (c < '0' || c > '9')
+                        return (0);
+                v = c - '0';
+                if (v >= base)         /* Illegal digit. */
+                        break;
+                r *= base;
+                r += v;
+        }
+
+        *ret = r;
+
+        return (1);
+}
+
+/*
+ * Retrieve a string from a name field.  If `rawname' is set, leave
+ * ar(1) control characters in.
+ */
+static char *
+_libelf_ar_get_string(const char *buf, size_t bufsize, int rawname)
+{
+        const char *q;
+        char *r;
+        size_t sz;
+
+        if (rawname)
+                sz = bufsize + 1;
+        else {
+                /* Skip back over trailing blanks. */
+                for (q = buf + bufsize - 1; q >= buf && *q == ' '; --q)
+                        ;
+
+                if (q < buf) {
+                        /*
+                         * If the input buffer only had blanks in it,
+                         * return a zero-length string.
+                         */
+                        buf = "";
+                        sz = 1;
+                } else {
+                        /*
+                         * Remove the trailing '/' character, but only
+                         * if the name isn't one of the special names
+                         * "/" and "//".
+                         */
+                        if (q > buf + 1 ||
+                            (q == (buf + 1) && *buf != '/'))
+                                q--;
+
+                        sz = q - buf + 2; /* Space for a trailing NUL. */
+                }
+        }
+
+        if ((r = malloc(sz)) == NULL) {
+                LIBELF_SET_ERROR(RESOURCE, 0);
+                return (NULL);
+        }
+
+        (void) strncpy(r, buf, sz);
+        r[sz - 1] = '\0';
+
+        return (r);
+}
+
+/*
+ * Retrieve the full name of the archive member.
+ */
+static char *
+_libelf_ar_get_name(char *buf, size_t bufsize, Elf *e)
+{
+        char c, *q, *r, *s;
+        size_t len;
+        size_t offset;
+
+        assert(e->e_kind == ELF_K_AR);
+
+        if (buf[0] == '/' && (c = buf[1]) >= '0' && c <= '9') {
+                /*
+                 * The value in field ar_name is a decimal offset into
+                 * the archive string table where the actual name
+                 * resides.
+                 */
+                if (_libelf_ar_get_number(buf + 1, bufsize - 1, 10,
+                    &offset) == 0) {
+                        LIBELF_SET_ERROR(ARCHIVE, 0);
+                        return (NULL);
+                }
+
+                if (offset > e->e_u.e_ar.e_rawstrtabsz) {
+                        LIBELF_SET_ERROR(ARCHIVE, 0);
+                        return (NULL);
+                }
+
+                s = q = e->e_u.e_ar.e_rawstrtab + offset;
+                r = e->e_u.e_ar.e_rawstrtab + e->e_u.e_ar.e_rawstrtabsz;
+
+                for (s = q; s < r && *s != '/'; s++)
+                        ;
+                len = s - q + 1; /* space for the trailing NUL */
+
+                if ((s = malloc(len)) == NULL) {
+                        LIBELF_SET_ERROR(RESOURCE, 0);
+                        return (NULL);
+                }
+
+                (void) strncpy(s, q, len);
+                s[len - 1] = '\0';
+
+                return (s);
+        }
+
+        /*
+         * Normal 'name'
+         */
+        return (_libelf_ar_get_string(buf, bufsize, 0));
+}
+
+
+Elf_Arhdr *
+_libelf_ar_gethdr(Elf *e)
+{
+        Elf *parent;
+        struct ar_hdr *arh;
+        Elf_Arhdr *eh;
+        size_t n;
+
+        if ((parent = e->e_parent) == NULL) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        arh = (struct ar_hdr *) ((uintptr_t) e->e_rawfile - sizeof(struct ar_hdr));
+
+        assert((uintptr_t) arh >= (uintptr_t) parent->e_rawfile + SARMAG);
+        assert((uintptr_t) arh <= (uintptr_t) parent->e_rawfile + parent->e_rawsize -
+            sizeof(struct ar_hdr));
+
+        if ((eh = malloc(sizeof(Elf_Arhdr))) == NULL) {
+                LIBELF_SET_ERROR(RESOURCE, 0);
+                return (NULL);
+        }
+
+        e->e_arhdr = eh;
+        eh->ar_name = eh->ar_rawname = NULL;
+
+        if ((eh->ar_name = _libelf_ar_get_name(arh->ar_name, sizeof(arh->ar_name),
+                 parent)) == NULL)
+                goto error;
+
+        if (_libelf_ar_get_number(arh->ar_uid, sizeof(arh->ar_uid), 10, &n) == 0)
+                goto error;
+        eh->ar_uid = (uid_t) n;
+
+        if (_libelf_ar_get_number(arh->ar_gid, sizeof(arh->ar_gid), 10, &n) == 0)
+                goto error;
+        eh->ar_gid = (gid_t) n;
+
+        if (_libelf_ar_get_number(arh->ar_mode, sizeof(arh->ar_mode), 8, &n) == 0)
+                goto error;
+        eh->ar_mode = (mode_t) n;
+
+        if (_libelf_ar_get_number(arh->ar_size, sizeof(arh->ar_size), 10, &n) == 0)
+                goto error;
+        eh->ar_size = n;
+
+        if ((eh->ar_rawname = _libelf_ar_get_string(arh->ar_name,
+                 sizeof(arh->ar_name), 1)) == NULL)
+                goto error;
+
+        return (eh);
+
+ error:
+        if (eh) {
+                if (eh->ar_name)
+                        free(eh->ar_name);
+                if (eh->ar_rawname)
+                        free(eh->ar_rawname);
+                free(eh);
+        }
+        e->e_arhdr = NULL;
+
+        return (NULL);
+}
+
+Elf *
+_libelf_ar_open_member(int fd, Elf_Cmd c, Elf *elf)
+{
+        Elf *e;
+        off_t next;
+        struct ar_hdr *arh;
+        size_t sz;
+
+        assert(elf->e_kind == ELF_K_AR);
+
+        next = elf->e_u.e_ar.e_next;
+
+        /*
+         * `next' is only set to zero by elf_next() when the last
+         * member of an archive is processed.
+         */
+        if (next == (off_t) 0)
+                return (NULL);
+
+        assert((next & 1) == 0);
+
+        arh = (struct ar_hdr *) (elf->e_rawfile + next);
+
+        if (_libelf_ar_get_number(arh->ar_size, sizeof(arh->ar_size), 10, &sz) == 0) {
+                LIBELF_SET_ERROR(ARCHIVE, 0);
+                return (NULL);
+        }
+
+        assert(sz > 0);
+
+        arh++; /* skip over archive member header */
+
+        if ((e = elf_memory((char *) arh, sz)) == NULL)
+                return (NULL);
+
+        e->e_fd = fd;
+        e->e_cmd = c;
+
+        elf->e_u.e_ar.e_nchildren++;
+        e->e_parent = elf;
+
+        return (e);
+}
+
+Elf *
+_libelf_ar_open(Elf *e)
+{
+        int i;
+        char *s, *end;
+        size_t sz;
+        struct ar_hdr arh;
+
+        e->e_kind = ELF_K_AR;
+        e->e_u.e_ar.e_nchildren = 0;
+        e->e_u.e_ar.e_next = (off_t) -1;
+
+        /*
+         * Look for special members.
+         */
+
+        s = e->e_rawfile + SARMAG;
+        end = e->e_rawfile + e->e_rawsize;
+
+        assert(e->e_rawsize > 0);
+
+        /*
+         * Look for magic names "/ " and "// " in the first two entries
+         * of the archive.
+         */
+        for (i = 0; i < 2; i++) {
+
+                if (s + sizeof(arh) > end) {
+                        LIBELF_SET_ERROR(ARCHIVE, 0);
+                        return (NULL);
+                }
+
+                (void) memcpy(&arh, s, sizeof(arh));
+
+                if (arh.ar_fmag[0] != '`' || arh.ar_fmag[1] != '\n') {
+                        LIBELF_SET_ERROR(ARCHIVE, 0);
+                        return (NULL);
+                }
+
+                if (arh.ar_name[0] != '/')     /* not a special symbol */
+                        break;
+
+                if (_libelf_ar_get_number(arh.ar_size, sizeof(arh.ar_size), 10, &sz) == 0) {
+                        LIBELF_SET_ERROR(ARCHIVE, 0);
+                        return (NULL);
+                }
+
+                assert(sz > 0);
+
+                s += sizeof(arh);
+
+                if (arh.ar_name[1] == ' ') {   /* "/ " => symbol table */
+
+                        e->e_u.e_ar.e_rawsymtab = s;
+                        e->e_u.e_ar.e_rawsymtabsz = sz;
+
+                } else if (arh.ar_name[1] == '/' && arh.ar_name[2] == ' ') {
+
+                        /* "// " => string table for long file names */
+                        e->e_u.e_ar.e_rawstrtab = s;
+                        e->e_u.e_ar.e_rawstrtabsz = sz;
+                }
+
+                sz = LIBELF_ADJUST_AR_SIZE(sz);
+
+                s += sz;
+        }
+
+        e->e_u.e_ar.e_next = (off_t) (s - e->e_rawfile);
+
+        return (e);
+}
+
+/*
+ * An ar(1) symbol table has the following layout:
+ *
+ * The first 4 bytes are a binary count of the number of entries in the
+ * symbol table, stored MSB-first.
+ *
+ * Then there are 'n' 4-byte binary offsets, also stored MSB first.
+ *
+ * Following this, there are 'n' null-terminated strings.
+ */
+
+#define        GET_WORD(P, V) do {                     \
+                (V) = 0;                       \
+                (V) = (P)[0]; (V) <<= 8;       \
+                (V) += (P)[1]; (V) <<= 8;      \
+                (V) += (P)[2]; (V) <<= 8;      \
+                (V) += (P)[3];                 \
+        } while (0)
+
+#define        INTSZ   4
+
+Elf_Arsym *
+_libelf_ar_process_symtab(Elf *e, size_t *count)
+{
+        size_t n, nentries, off;
+        Elf_Arsym *symtab, *sym;
+        char *p, *s, *end;
+
+        assert(e != NULL);
+        assert(count != NULL);
+
+        if (e->e_u.e_ar.e_rawsymtabsz < INTSZ) {
+                LIBELF_SET_ERROR(ARCHIVE, 0);
+                return (NULL);
+        }
+
+        p = e->e_u.e_ar.e_rawsymtab;
+        end = p + e->e_u.e_ar.e_rawsymtabsz;
+
+        GET_WORD(p, nentries);
+        p += INTSZ;
+
+        if (nentries == 0 || p + nentries * INTSZ >= end) {
+                LIBELF_SET_ERROR(ARCHIVE, 0);
+                return (NULL);
+        }
+
+        /* Allocate space for a nentries + a sentinel. */
+        if ((symtab = malloc(sizeof(Elf_Arsym) * (nentries+1))) == NULL) {
+                LIBELF_SET_ERROR(RESOURCE, 0);
+                return (NULL);
+        }
+
+        s = p + (nentries * INTSZ); /* start of the string table. */
+
+        for (n = nentries, sym = symtab; n > 0; n--) {
+                off = 0;
+
+                GET_WORD(p, off);
+
+                sym->as_off = off;
+                sym->as_hash = elf_hash(s);
+                sym->as_name = s;
+
+                p += INTSZ;
+                sym++;
+
+                for (; s < end && *s++ != '\0';) /* skip to next string */
+                        ;
+                if (s > end) {
+                        LIBELF_SET_ERROR(ARCHIVE, 0);
+                        free(symtab);
+                        return (NULL);
+                }
+        }
+
+        /* Fill up the sentinel entry. */
+        sym->as_name = NULL;
+        sym->as_hash = ~0UL;
+        sym->as_off = (off_t) 0;
+
+        *count = e->e_u.e_ar.e_symtabsz = nentries + 1;
+        e->e_u.e_ar.e_symtab = symtab;
+
+        return (symtab);
+}
diff --git a/ext/libelf/libelf_checksum.c b/ext/libelf/libelf_checksum.c
new file mode 100644 (file)
index 0000000..1435175
--- /dev/null
@@ -0,0 +1,96 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "gelf.h"
+
+#include "_libelf.h"
+
+static unsigned long
+_libelf_sum(unsigned long c, const unsigned char *s, size_t size)
+{
+        if (s == NULL || size == 0)
+                return (c);
+
+        while (size--)
+                c += *s++;
+
+        return (c);
+}
+
+unsigned long
+_libelf_checksum(Elf *e, int elfclass)
+{
+        size_t shn;
+        Elf_Scn *scn;
+        Elf_Data *d;
+        unsigned long checksum;
+        GElf_Ehdr eh;
+        GElf_Shdr shdr;
+
+        if (e == NULL) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (0L);
+        }
+
+        if (e->e_class != elfclass) {
+                LIBELF_SET_ERROR(CLASS, 0);
+                return (0L);
+        }
+
+        if (gelf_getehdr(e, &eh) == NULL)
+                return (0);
+
+        /*
+         * Iterate over all sections in the ELF file, computing the
+         * checksum along the way.
+         *
+         * The first section is always SHN_UNDEF and can be skipped.
+         * Non-allocatable sections are skipped, as are sections that
+         * could be affected by utilities such as strip(1).
+         */
+
+        checksum = 0;
+        for (shn = 1; shn < e->e_u.e_elf.e_nscn; shn++) {
+                if ((scn = elf_getscn(e, shn)) == NULL)
+                        return (0);
+                if (gelf_getshdr(scn, &shdr) == NULL)
+                        return (0);
+                if ((shdr.sh_flags & SHF_ALLOC) == 0 ||
+                    shdr.sh_type == SHT_DYNAMIC ||
+                    shdr.sh_type == SHT_DYNSYM)
+                        continue;
+
+                d = NULL;
+                while ((d = elf_rawdata(scn, d)) != NULL)
+                        checksum = _libelf_sum(checksum,
+                            (unsigned char *) d->d_buf, d->d_size);
+        }
+
+        /*
+         * Return a 16-bit checksum compatible with Solaris.
+         */
+        return (((checksum >> 16) & 0xFFFFUL) + (checksum & 0xFFFFUL));
+}
diff --git a/ext/libelf/libelf_convert.m4 b/ext/libelf/libelf_convert.m4
new file mode 100644 (file)
index 0000000..1f21dbe
--- /dev/null
@@ -0,0 +1,657 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/types.h>
+
+#include <assert.h>
+#include <string.h>
+
+#include "elf32.h"
+#include "elf64.h"
+#include "libelf.h"
+#include "_libelf.h"
+
+/* WARNING: GENERATED FROM __file__. */
+
+/*
+ * Macros to swap various integral quantities.
+ */
+
+#define        SWAP_HALF(X)    do {                                            \
+               uint16_t _x = (uint16_t) (X);                           \
+               uint16_t _t = _x & 0xFF;                                \
+               _t <<= 8; _x >>= 8; _t |= _x & 0xFF;                    \
+               (X) = _t;                                               \
+       } while (0)
+#define        SWAP_WORD(X)    do {                                            \
+               uint32_t _x = (uint32_t) (X);                           \
+               uint32_t _t = _x & 0xFF;                                \
+               _t <<= 8; _x >>= 8; _t |= _x & 0xFF;                    \
+               _t <<= 8; _x >>= 8; _t |= _x & 0xFF;                    \
+               _t <<= 8; _x >>= 8; _t |= _x & 0xFF;                    \
+               (X) = _t;                                               \
+       } while (0)
+#define        SWAP_ADDR32(X)  SWAP_WORD(X)
+#define        SWAP_OFF32(X)   SWAP_WORD(X)
+#define        SWAP_SWORD(X)   SWAP_WORD(X)
+#define        SWAP_WORD64(X)  do {                                            \
+               uint64_t _x = (uint64_t) (X);                           \
+               uint64_t _t = _x & 0xFF;                                \
+               _t <<= 8; _x >>= 8; _t |= _x & 0xFF;                    \
+               _t <<= 8; _x >>= 8; _t |= _x & 0xFF;                    \
+               _t <<= 8; _x >>= 8; _t |= _x & 0xFF;                    \
+               _t <<= 8; _x >>= 8; _t |= _x & 0xFF;                    \
+               _t <<= 8; _x >>= 8; _t |= _x & 0xFF;                    \
+               _t <<= 8; _x >>= 8; _t |= _x & 0xFF;                    \
+               _t <<= 8; _x >>= 8; _t |= _x & 0xFF;                    \
+               (X) = _t;                                               \
+       } while (0)
+#define        SWAP_ADDR64(X)  SWAP_WORD64(X)
+#define        SWAP_LWORD(X)   SWAP_WORD64(X)
+#define        SWAP_OFF64(X)   SWAP_WORD64(X)
+#define        SWAP_SXWORD(X)  SWAP_WORD64(X)
+#define        SWAP_XWORD(X)   SWAP_WORD64(X)
+
+/*
+ * Write out various integral values.  The destination pointer could
+ * be unaligned.  Values are written out in native byte order.  The
+ * destination pointer is incremented after the write.
+ */
+#define        WRITE_BYTE(P,X) do {                                            \
+               unsigned char *const _p = (unsigned char *) (P);        \
+               _p[0]           = (unsigned char) (X);                  \
+               (P)             = _p + 1;                               \
+       } while (0)
+#define        WRITE_HALF(P,X) do {                                            \
+               uint16_t _t     = (X);                                  \
+               unsigned char *const _p = (unsigned char *) (P);        \
+               unsigned const char *const _q = (unsigned char *) &_t;  \
+               _p[0]           = _q[0];                                \
+               _p[1]           = _q[1];                                \
+               (P)             = _p + 2;                               \
+       } while (0)
+#define        WRITE_WORD(P,X) do {                                            \
+               uint32_t _t     = (X);                                  \
+               unsigned char *const _p = (unsigned char *) (P);        \
+               unsigned const char *const _q = (unsigned char *) &_t;  \
+               _p[0]           = _q[0];                                \
+               _p[1]           = _q[1];                                \
+               _p[2]           = _q[2];                                \
+               _p[3]           = _q[3];                                \
+               (P)             = _p + 4;                               \
+       } while (0)
+#define        WRITE_ADDR32(P,X)       WRITE_WORD(P,X)
+#define        WRITE_OFF32(P,X)        WRITE_WORD(P,X)
+#define        WRITE_SWORD(P,X)        WRITE_WORD(P,X)
+#define        WRITE_WORD64(P,X)       do {                                    \
+               uint64_t _t     = (X);                                  \
+               unsigned char *const _p = (unsigned char *) (P);        \
+               unsigned const char *const _q = (unsigned char *) &_t;  \
+               _p[0]           = _q[0];                                \
+               _p[1]           = _q[1];                                \
+               _p[2]           = _q[2];                                \
+               _p[3]           = _q[3];                                \
+               _p[4]           = _q[4];                                \
+               _p[5]           = _q[5];                                \
+               _p[6]           = _q[6];                                \
+               _p[7]           = _q[7];                                \
+               (P)             = _p + 8;                               \
+       } while (0)
+#define        WRITE_ADDR64(P,X)       WRITE_WORD64(P,X)
+#define        WRITE_LWORD(P,X)        WRITE_WORD64(P,X)
+#define        WRITE_OFF64(P,X)        WRITE_WORD64(P,X)
+#define        WRITE_SXWORD(P,X)       WRITE_WORD64(P,X)
+#define        WRITE_XWORD(P,X)        WRITE_WORD64(P,X)
+#define        WRITE_IDENT(P,X)        do {                                    \
+               (void) memcpy((P), (X), sizeof((X)));                   \
+               (P)             = (P) + EI_NIDENT;                      \
+       } while (0)
+
+/*
+ * Read in various integral values.  The source pointer could be
+ * unaligned.  Values are read in in native byte order.  The source
+ * pointer is incremented appropriately.
+ */
+
+#define        READ_BYTE(P,X)  do {                                            \
+               const unsigned char *const _p =                         \
+                       (const unsigned char *) (P);                    \
+               (X)             = _p[0];                                \
+               (P)             = (P) + 1;                              \
+       } while (0)
+#define        READ_HALF(P,X)  do {                                            \
+               uint16_t _t;                                            \
+               unsigned char *const _q = (unsigned char *) &_t;        \
+               const unsigned char *const _p =                         \
+                       (const unsigned char *) (P);                    \
+               _q[0]           = _p[0];                                \
+               _q[1]           = _p[1];                                \
+               (P)             = (P) + 2;                              \
+               (X)             = _t;                                   \
+       } while (0)
+#define        READ_WORD(P,X)  do {                                            \
+               uint32_t _t;                                            \
+               unsigned char *const _q = (unsigned char *) &_t;        \
+               const unsigned char *const _p =                         \
+                       (const unsigned char *) (P);                    \
+               _q[0]           = _p[0];                                \
+               _q[1]           = _p[1];                                \
+               _q[2]           = _p[2];                                \
+               _q[3]           = _p[3];                                \
+               (P)             = (P) + 4;                              \
+               (X)             = _t;                                   \
+       } while (0)
+#define        READ_ADDR32(P,X)        READ_WORD(P,X)
+#define        READ_OFF32(P,X)         READ_WORD(P,X)
+#define        READ_SWORD(P,X)         READ_WORD(P,X)
+#define        READ_WORD64(P,X)        do {                                    \
+               uint64_t _t;                                            \
+               unsigned char *const _q = (unsigned char *) &_t;        \
+               const unsigned char *const _p =                         \
+                       (const unsigned char *) (P);                    \
+               _q[0]           = _p[0];                                \
+               _q[1]           = _p[1];                                \
+               _q[2]           = _p[2];                                \
+               _q[3]           = _p[3];                                \
+               _q[4]           = _p[4];                                \
+               _q[5]           = _p[5];                                \
+               _q[6]           = _p[6];                                \
+               _q[7]           = _p[7];                                \
+               (P)             = (P) + 8;                              \
+               (X)             = _t;                                   \
+       } while (0)
+#define        READ_ADDR64(P,X)        READ_WORD64(P,X)
+#define        READ_LWORD(P,X)         READ_WORD64(P,X)
+#define        READ_OFF64(P,X)         READ_WORD64(P,X)
+#define        READ_SXWORD(P,X)        READ_WORD64(P,X)
+#define        READ_XWORD(P,X)         READ_WORD64(P,X)
+#define        READ_IDENT(P,X)         do {                                    \
+               (void) memcpy((X), (P), sizeof((X)));                   \
+               (P)             = (P) + EI_NIDENT;                      \
+       } while (0)
+
+#define        ROUNDUP2(V,N)   (V) = ((((V) + (N) - 1)) & ~((N) - 1))
+
+divert(-1)
+
+/*
+ * Generate conversion routines for converting between in-memory and
+ * file representations of Elf data structures.
+ *
+ * `In-memory' representations of an Elf data structure use natural
+ * alignments and native byte ordering.  This allows arithmetic and
+ * casting to work as expected.  On the other hand the `file'
+ * representation of an ELF data structure could be packed tighter
+ * than its `in-memory' representation, and could be of a differing
+ * byte order.  An additional complication is that `ar' only pads data
+ * to even addresses and so ELF archive member data being read from
+ * inside an `ar' archive could end up at misaligned memory addresses.
+ *
+ * Consequently, casting the `char *' pointers that point to memory
+ * representations (i.e., source pointers for the *_tof() functions
+ * and the destination pointers for the *_tom() functions), is safe,
+ * as these pointers should be correctly aligned for the memory type
+ * already.  However, pointers to file representations have to be
+ * treated as being potentially unaligned and no casting can be done.
+ */
+
+include(SRCDIR`/elf_types.m4')
+
+/*
+ * `IGNORE'_* flags turn off generation of template code.
+ */
+
+define(`IGNORE',
+  `define(IGNORE_$1`'32,       1)
+   define(IGNORE_$1`'64,       1)')
+
+IGNORE(MOVEP)
+IGNORE(NOTE)
+
+define(IGNORE_BYTE,            1)      /* 'lator, leave 'em bytes alone */
+define(IGNORE_NOTE,            1)
+define(IGNORE_SXWORD32,                1)
+define(IGNORE_XWORD32,         1)
+
+/*
+ * `BASE'_XXX flags cause class agnostic template functions
+ * to be generated.
+ */
+
+define(`BASE_BYTE',    1)
+define(`BASE_HALF',    1)
+define(`BASE_NOTE',    1)
+define(`BASE_WORD',    1)
+define(`BASE_LWORD',   1)
+define(`BASE_SWORD',   1)
+define(`BASE_XWORD',   1)
+define(`BASE_SXWORD',  1)
+
+/*
+ * `SIZEDEP'_XXX flags cause 32/64 bit variants to be generated
+ * for each primitive type.
+ */
+
+define(`SIZEDEP_ADDR', 1)
+define(`SIZEDEP_OFF',  1)
+
+/*
+ * `Primitive' ELF types are those that are an alias for an integral
+ * type.  They have no internal structure. These can be copied using
+ * a `memcpy()', and byteswapped in straightforward way.
+ *
+ * Macro use:
+ * `$1': Name of the ELF type.
+ * `$2': C structure name suffix
+ * `$3': ELF class specifier for symbols, one of [`', `32', `64']
+ * `$4': ELF class specifier for types, one of [`32', `64']
+ */
+define(`MAKEPRIM_TO_F',`
+static void
+libelf_cvt_$1$3_tof(char *dst, char *src, size_t count, int byteswap)
+{
+       Elf$4_$2 t, *s = (Elf$4_$2 *) (uintptr_t) src;
+       size_t c;
+
+       if (dst == src && !byteswap)
+               return;
+
+       if (!byteswap) {
+               (void) memcpy(dst, src, count * sizeof(*s));
+               return;
+       }
+
+       for (c = 0; c < count; c++) {
+               t = *s++;
+               SWAP_$1$3(t);
+               WRITE_$1$3(dst,t);
+       }
+}
+')
+
+define(`MAKEPRIM_TO_M',`
+static void
+libelf_cvt_$1$3_tom(char *dst, char *src, size_t count, int byteswap)
+{
+       Elf$4_$2 t, *d = (Elf$4_$2 *) (uintptr_t) dst;
+       size_t c;
+
+       if (dst == src && !byteswap)
+               return;
+
+       if (!byteswap) {
+               (void) memcpy(dst, src, count * sizeof(*d));
+               return;
+       }
+
+       for (c = 0; c < count; c++) {
+               READ_$1$3(src,t);
+               SWAP_$1$3(t);
+               *d++ = t;
+       }
+}
+')
+
+define(`SWAP_FIELD',
+  `ifdef(`IGNORE_'$2,`',
+    `ifelse(BASE_$2,1,
+      `SWAP_$2(t.$1);
+                       ',
+      `ifelse($2,BYTE,`',
+        `ifelse($2,IDENT,`',
+          `SWAP_$2'SZ()`(t.$1);
+                       ')')')')')
+define(`SWAP_MEMBERS',
+  `ifelse($#,1,`/**/',
+     `SWAP_FIELD($1)SWAP_MEMBERS(shift($@))')')
+
+define(`SWAP_STRUCT',
+  `pushdef(`SZ',$2)/* Swap an Elf$2_$1 */
+                       SWAP_MEMBERS(Elf$2_$1_DEF)popdef(`SZ')')
+
+define(`WRITE_FIELD',
+  `ifelse(BASE_$2,1,
+    `WRITE_$2(dst,t.$1);
+               ',
+    `ifelse($2,IDENT,
+      `WRITE_$2(dst,t.$1);
+               ',
+      `WRITE_$2'SZ()`(dst,t.$1);
+               ')')')
+define(`WRITE_MEMBERS',
+  `ifelse($#,1,`/**/',
+    `WRITE_FIELD($1)WRITE_MEMBERS(shift($@))')')
+
+define(`WRITE_STRUCT',
+  `pushdef(`SZ',$2)/* Write an Elf$2_$1 */
+               WRITE_MEMBERS(Elf$2_$1_DEF)popdef(`SZ')')
+
+define(`READ_FIELD',
+  `ifelse(BASE_$2,1,
+    `READ_$2(s,t.$1);
+               ',
+    `ifelse($2,IDENT,
+      `READ_$2(s,t.$1);
+               ',
+      `READ_$2'SZ()`(s,t.$1);
+               ')')')
+
+define(`READ_MEMBERS',
+  `ifelse($#,1,`/**/',
+    `READ_FIELD($1)READ_MEMBERS(shift($@))')')
+
+define(`READ_STRUCT',
+  `pushdef(`SZ',$2)/* Read an Elf$2_$1 */
+               READ_MEMBERS(Elf$2_$1_DEF)popdef(`SZ')')
+
+/*
+ * Converters for non-integral ELF data structures.
+ *
+ * When converting data to file representation, the source pointer
+ * will be naturally aligned for a data structure's in-memory
+ * representation.  When converting data to memory, the destination
+ * pointer will be similarly aligned.
+ *
+ * For in-place conversions, when converting to file representations,
+ * the source buffer is large enough to hold `file' data.  When
+ * converting from file to memory, we need to be careful to work
+ * `backwards', to avoid overwriting unconverted data.
+ *
+ * Macro use:
+ * `$1': Name of the ELF type.
+ * `$2': C structure name suffix.
+ * `$3': ELF class specifier, one of [`', `32', `64']
+ */
+
+define(`MAKE_TO_F',
+  `ifdef(`IGNORE_'$1$3,`',`
+static void
+libelf_cvt$3_$1_tof(char *dst, char *src, size_t count, int byteswap)
+{
+       Elf$3_$2        t, *s;
+       size_t c;
+
+       s = (Elf$3_$2 *) (uintptr_t) src;
+       for (c = 0; c < count; c++) {
+               t = *s++;
+               if (byteswap) {
+                       SWAP_STRUCT($2,$3)
+               }
+               WRITE_STRUCT($2,$3)
+       }
+}
+')')
+
+define(`MAKE_TO_M',
+  `ifdef(`IGNORE_'$1$3,`',`
+static void
+libelf_cvt$3_$1_tom(char *dst, char *src, size_t count, int byteswap)
+{
+       Elf$3_$2         t, *d;
+       unsigned char   *s,*s0;
+       size_t          fsz;
+
+       fsz = elf$3_fsize(ELF_T_$1, (size_t) 1, EV_CURRENT);
+       d   = ((Elf$3_$2 *) (uintptr_t) dst) + (count - 1);
+       s0  = (unsigned char *) src + (count - 1) * fsz;
+
+       while (count--) {
+               s = s0;
+               READ_STRUCT($2,$3)
+               if (byteswap) {
+                       SWAP_STRUCT($2,$3)
+               }
+               *d-- = t; s0 -= fsz;
+       }
+}
+')')
+
+/*
+ * Make type convertor functions from the type definition
+ * of the ELF type:
+ * - if the type is a base (i.e., `primitive') type:
+ *   - if it is marked as to be ignored (i.e., `IGNORE_'TYPE)
+ *     is defined, we skip the code generation step.
+ *   - if the type is declared as `SIZEDEP', then 32 and 64 bit
+ *     variants of the conversion functions are generated.
+ *   - otherwise a 32 bit variant is generated.
+ * - if the type is a structure type, we generate 32 and 64 bit
+ *   variants of the conversion functions.
+ */
+
+define(`MAKE_TYPE_CONVERTER',
+  `ifdef(`BASE'_$1,
+    `ifdef(`IGNORE_'$1,`',
+      `MAKEPRIM_TO_F($1,$2,`',64)
+       MAKEPRIM_TO_M($1,$2,`',64)')',
+    `ifdef(`SIZEDEP_'$1,
+      `MAKEPRIM_TO_F($1,$2,32,32)dnl
+       MAKEPRIM_TO_M($1,$2,32,32)dnl
+       MAKEPRIM_TO_F($1,$2,64,64)dnl
+       MAKEPRIM_TO_M($1,$2,64,64)',
+      `MAKE_TO_F($1,$2,32)dnl
+       MAKE_TO_F($1,$2,64)dnl
+       MAKE_TO_M($1,$2,32)dnl
+       MAKE_TO_M($1,$2,64)')')
+')
+
+define(`MAKE_TYPE_CONVERTERS',
+  `ifelse($#,1,`',
+    `MAKE_TYPE_CONVERTER($1)MAKE_TYPE_CONVERTERS(shift($@))')')
+
+divert(0)
+
+/*
+ * Sections of type ELF_T_BYTE are never byteswapped, consequently a
+ * simple memcpy suffices for both directions of conversion.
+ */
+
+static void
+libelf_cvt_BYTE_tox(char *dst, char *src, size_t count, int byteswap)
+{
+       (void) byteswap;
+       if (dst != src)
+               (void) memcpy(dst, src, count);
+}
+
+/*
+ * Elf_Note structures comprise a fixed size header followed by variable
+ * length strings.  The fixed size header needs to be byte swapped, but
+ * not the strings.
+ *
+ * Argument `count' denotes the total number of bytes to be converted.
+ */
+static void
+libelf_cvt_NOTE_tom(char *dst, char *src, size_t count, int byteswap)
+{
+       uint32_t namesz, descsz, type;
+       Elf_Note *en;
+       size_t sz;
+
+       if (dst == src && !byteswap)
+               return;
+
+       if (!byteswap) {
+               (void) memcpy(dst, src, count);
+               return;
+       }
+
+       while (count > sizeof(Elf_Note)) {
+
+               READ_WORD(src, namesz);
+               READ_WORD(src, descsz);
+               READ_WORD(src, type);
+
+               if (byteswap) {
+                       SWAP_WORD(namesz);
+                       SWAP_WORD(descsz);
+                       SWAP_WORD(type);
+               }
+
+               en = (Elf_Note *) (uintptr_t) dst;
+               en->n_namesz = namesz;
+               en->n_descsz = descsz;
+               en->n_type = type;
+
+               dst += sizeof(Elf_Note);
+
+               ROUNDUP2(namesz, 4);
+               ROUNDUP2(descsz, 4);
+
+               sz = namesz + descsz;
+
+               if (count < sz)
+                       sz = count;
+
+               (void) memcpy(dst, src, sz);
+
+               src += sz;
+               dst += sz;
+               count -= sz;
+       }
+}
+
+static void
+libelf_cvt_NOTE_tof(char *dst, char *src, size_t count, int byteswap)
+{
+       uint32_t namesz, descsz, type;
+       Elf_Note *en;
+       size_t sz;
+
+       if (dst == src && !byteswap)
+               return;
+
+       if (!byteswap) {
+               (void) memcpy(dst, src, count);
+               return;
+       }
+
+       while (count > sizeof(Elf_Note)) {
+
+               en = (Elf_Note *) (uintptr_t) src;
+               namesz = en->n_namesz;
+               descsz = en->n_descsz;
+               type = en->n_type;
+
+               if (byteswap) {
+                       SWAP_WORD(namesz);
+                       SWAP_WORD(descsz);
+                       SWAP_WORD(type);
+               }
+
+
+               WRITE_WORD(dst, namesz);
+               WRITE_WORD(dst, descsz);
+               WRITE_WORD(dst, type);
+
+               src += sizeof(Elf_Note);
+
+               ROUNDUP2(namesz, 4);
+               ROUNDUP2(descsz, 4);
+
+               sz = namesz + descsz;
+
+               if (count < sz)
+                       sz = count;
+
+               (void) memcpy(dst, src, sz);
+
+               src += sz;
+               dst += sz;
+               count -= sz;
+       }
+}
+
+MAKE_TYPE_CONVERTERS(ELF_TYPE_LIST)
+
+struct converters {
+       void    (*tof32)(char *dst, char *src, size_t cnt, int byteswap);
+       void    (*tom32)(char *dst, char *src, size_t cnt, int byteswap);
+       void    (*tof64)(char *dst, char *src, size_t cnt, int byteswap);
+       void    (*tom64)(char *dst, char *src, size_t cnt, int byteswap);
+};
+
+divert(-1)
+define(`CONV',
+  `ifdef(`IGNORE_'$1$2,
+    `.$3$2 = NULL',
+    `ifdef(`BASE_'$1,
+      `ifdef(`IGNORE_'$1,
+       `.$3$2 = NULL',
+        `.$3$2 = libelf_cvt_$1_$3')',
+      `ifdef(`SIZEDEP_'$1,
+        `.$3$2 = libelf_cvt_$1$2_$3',
+        `.$3$2 = libelf_cvt$2_$1_$3')')')')
+
+define(`CONVERTER_NAME',
+  `[ELF_T_$1] = {
+        CONV($1,32,tof), CONV($1,32,tom),
+        CONV($1,64,tof), CONV($1,64,tom) },')')
+
+define(`CONVERTER_NAMES',
+  `ifelse($#,1,`',
+    `CONVERTER_NAME($1)CONVERTER_NAMES(shift($@))')')
+
+undefine(`IGNORE_BYTE32')
+undefine(`IGNORE_BYTE64')
+divert(0)
+
+static struct converters cvt[ELF_T_NUM] = {
+CONVERTER_NAMES(ELF_TYPE_LIST)
+
+       /*
+        * Types that needs hand-coded converters follow.
+        */
+
+       [ELF_T_BYTE] = {
+               .tof32 = libelf_cvt_BYTE_tox,
+               .tom32 = libelf_cvt_BYTE_tox,
+               .tof64 = libelf_cvt_BYTE_tox,
+               .tom64 = libelf_cvt_BYTE_tox
+       },
+       [ELF_T_NOTE] = {
+               .tof32 = libelf_cvt_NOTE_tof,
+               .tom32 = libelf_cvt_NOTE_tom,
+               .tof64 = libelf_cvt_NOTE_tof,
+               .tom64 = libelf_cvt_NOTE_tom
+       }
+};
+
+void (*_libelf_get_translator(Elf_Type t, int direction, int elfclass))
+ (char *_dst, char *_src, size_t _cnt, int _byteswap)
+{
+       assert(elfclass == ELFCLASS32 || elfclass == ELFCLASS64);
+       assert(direction == ELF_TOFILE || direction == ELF_TOMEMORY);
+
+       if (t >= ELF_T_NUM ||
+           (elfclass != ELFCLASS32 && elfclass != ELFCLASS64) ||
+           (direction != ELF_TOFILE && direction != ELF_TOMEMORY))
+               return (NULL);
+
+       return ((elfclass == ELFCLASS32) ?
+           (direction == ELF_TOFILE ? cvt[t].tof32 : cvt[t].tom32) :
+           (direction == ELF_TOFILE ? cvt[t].tof64 : cvt[t].tom64));
+}
diff --git a/ext/libelf/libelf_data.c b/ext/libelf/libelf_data.c
new file mode 100644 (file)
index 0000000..49c6575
--- /dev/null
@@ -0,0 +1,78 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "libelf.h"
+
+#include "_libelf.h"
+
+int
+_libelf_xlate_shtype(uint32_t sht)
+{
+        switch (sht) {
+        case SHT_DYNAMIC:
+                return (ELF_T_DYN);
+        case SHT_DYNSYM:
+                return (ELF_T_SYM);
+        case SHT_FINI_ARRAY:
+                return (ELF_T_ADDR);
+        case SHT_GROUP:
+                return (ELF_T_WORD);
+        case SHT_HASH:
+                return (ELF_T_WORD);
+        case SHT_INIT_ARRAY:
+                return (ELF_T_ADDR);
+        case SHT_NOBITS:
+                return (ELF_T_BYTE);
+        case SHT_NOTE:
+                return (ELF_T_NOTE);
+        case SHT_PREINIT_ARRAY:
+                return (ELF_T_ADDR);
+        case SHT_PROGBITS:
+                return (ELF_T_BYTE);
+        case SHT_REL:
+                return (ELF_T_REL);
+        case SHT_RELA:
+                return (ELF_T_RELA);
+        case SHT_STRTAB:
+                return (ELF_T_BYTE);
+        case SHT_SYMTAB:
+                return (ELF_T_SYM);
+        case SHT_SYMTAB_SHNDX:
+                return (ELF_T_WORD);
+        case SHT_GNU_verdef:   /* == SHT_SUNW_verdef */
+                return (ELF_T_VDEF);
+        case SHT_GNU_verneed:  /* == SHT_SUNW_verneed */
+                return (ELF_T_VNEED);
+        case SHT_GNU_versym:   /* == SHT_SUNW_versym */
+                return (-1);   /* XXX */
+        case SHT_SUNW_move:
+                return (ELF_T_MOVE);
+        case SHT_SUNW_syminfo:
+                return (ELF_T_SYMINFO);
+        default:
+                return (-1);
+        }
+}
diff --git a/ext/libelf/libelf_ehdr.c b/ext/libelf/libelf_ehdr.c
new file mode 100644 (file)
index 0000000..c903946
--- /dev/null
@@ -0,0 +1,201 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD: src/lib/libelf/libelf_ehdr.c,v 1.2 2006/12/25 02:22:22 jkoshy Exp $
+ */
+
+#include <assert.h>
+#include "gelf.h"
+#include "libelf.h"
+#include <stdlib.h>
+
+#include "_libelf.h"
+
+/*
+ * Retrieve counts for sections, phdrs and the section string table index
+ * from section header #0 of the ELF object.
+ */
+static int
+_libelf_load_extended(Elf *e, int ec, uint64_t shoff, uint16_t phnum,
+    uint16_t strndx)
+{
+        Elf_Scn *scn;
+        size_t fsz;
+        void (*xlator)(char *_d, char *_s, size_t _c, int _swap);
+        uint32_t shtype;
+
+        assert(STAILQ_EMPTY(&e->e_u.e_elf.e_scn));
+
+        fsz = _libelf_fsize(ELF_T_SHDR, ec, e->e_version, 1);
+        assert(fsz > 0);
+
+        if (e->e_rawsize < shoff + fsz) { /* raw file too small */
+                LIBELF_SET_ERROR(HEADER, 0);
+                return (0);
+        }
+
+        if ((scn = _libelf_allocate_scn(e, (size_t) 0)) == NULL)
+                return (0);
+
+        xlator = _libelf_get_translator(ELF_T_SHDR, ELF_TOMEMORY, ec);
+        (*xlator)((char *) &scn->s_shdr, e->e_rawfile + shoff, (size_t) 1,
+            e->e_byteorder != LIBELF_PRIVATE(byteorder));
+
+#define        GET_SHDR_MEMBER(M) ((ec == ELFCLASS32) ? scn->s_shdr.s_shdr32.M : \
+                scn->s_shdr.s_shdr64.M)
+
+        if ((shtype = GET_SHDR_MEMBER(sh_type)) != SHT_NULL) {
+                LIBELF_SET_ERROR(SECTION, 0);
+                return (0);
+        }
+
+        e->e_u.e_elf.e_nscn = GET_SHDR_MEMBER(sh_size);
+        e->e_u.e_elf.e_nphdr = (phnum != PN_XNUM) ? phnum :
+            GET_SHDR_MEMBER(sh_info);
+        e->e_u.e_elf.e_strndx = (strndx != SHN_XINDEX) ? strndx :
+            GET_SHDR_MEMBER(sh_link);
+#undef GET_SHDR_MEMBER
+
+        return (1);
+}
+
+#define        EHDR_INIT(E,SZ)  do {                                           \
+                Elf##SZ##_Ehdr *eh = (E);                              \
+                eh->e_ident[EI_MAG0] = ELFMAG0;                                \
+                eh->e_ident[EI_MAG1] = ELFMAG1;                                \
+                eh->e_ident[EI_MAG2] = ELFMAG2;                                \
+                eh->e_ident[EI_MAG3] = ELFMAG3;                                \
+                eh->e_ident[EI_CLASS] = ELFCLASS##SZ;                  \
+                eh->e_ident[EI_DATA]  = ELFDATANONE;                   \
+                eh->e_ident[EI_VERSION] = LIBELF_PRIVATE(version);     \
+                eh->e_machine = EM_NONE;                               \
+                eh->e_type    = ELF_K_NONE;                            \
+                eh->e_version = LIBELF_PRIVATE(version);               \
+        } while (0)
+
+void *
+_libelf_ehdr(Elf *e, int ec, int allocate)
+{
+        void *ehdr;
+        size_t fsz, msz;
+        uint16_t phnum, shnum, strndx;
+        uint64_t shoff;
+        void (*xlator)(char *_d, char *_s, size_t _c, int _swap);
+
+        assert(ec == ELFCLASS32 || ec == ELFCLASS64);
+
+        if (e == NULL || e->e_kind != ELF_K_ELF) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        if (e->e_class != ELFCLASSNONE && e->e_class != ec) {
+                LIBELF_SET_ERROR(CLASS, 0);
+                return (NULL);
+        }
+
+        if (e->e_version != EV_CURRENT) {
+                LIBELF_SET_ERROR(VERSION, 0);
+                return (NULL);
+        }
+
+        if (e->e_class == ELFCLASSNONE)
+                e->e_class = ec;
+
+        if (ec == ELFCLASS32)
+                ehdr = (void *) e->e_u.e_elf.e_ehdr.e_ehdr32;
+        else
+                ehdr = (void *) e->e_u.e_elf.e_ehdr.e_ehdr64;
+
+        if (ehdr != NULL)      /* already have a translated ehdr */
+                return (ehdr);
+
+        fsz = _libelf_fsize(ELF_T_EHDR, ec, e->e_version, (size_t) 1);
+        assert(fsz > 0);
+
+        if (e->e_cmd != ELF_C_WRITE && e->e_rawsize < fsz) {
+                LIBELF_SET_ERROR(HEADER, 0);
+                return (NULL);
+        }
+
+        msz = _libelf_msize(ELF_T_EHDR, ec, EV_CURRENT);
+
+        assert(msz > 0);
+
+        if ((ehdr = calloc((size_t) 1, msz)) == NULL) {
+                LIBELF_SET_ERROR(RESOURCE, 0);
+                return (NULL);
+        }
+
+        if (ec == ELFCLASS32) {
+                e->e_u.e_elf.e_ehdr.e_ehdr32 = ehdr;
+                EHDR_INIT(ehdr,32);
+        } else {
+                e->e_u.e_elf.e_ehdr.e_ehdr64 = ehdr;
+                EHDR_INIT(ehdr,64);
+        }
+
+        if (allocate)
+                e->e_flags |= ELF_F_DIRTY;
+
+        if (e->e_cmd == ELF_C_WRITE)
+                return (ehdr);
+
+        xlator = _libelf_get_translator(ELF_T_EHDR, ELF_TOMEMORY, ec);
+        (*xlator)(ehdr, e->e_rawfile, (size_t) 1,
+            e->e_byteorder != LIBELF_PRIVATE(byteorder));
+
+        /*
+         * If extended numbering is being used, read the correct
+         * number of sections and program header entries.
+         */
+        if (ec == ELFCLASS32) {
+                phnum = ((Elf32_Ehdr *) ehdr)->e_phnum;
+                shnum = ((Elf32_Ehdr *) ehdr)->e_shnum;
+                shoff = ((Elf32_Ehdr *) ehdr)->e_shoff;
+                strndx = ((Elf32_Ehdr *) ehdr)->e_shstrndx;
+        } else {
+                phnum = ((Elf64_Ehdr *) ehdr)->e_phnum;
+                shnum = ((Elf64_Ehdr *) ehdr)->e_shnum;
+                shoff = ((Elf64_Ehdr *) ehdr)->e_shoff;
+                strndx = ((Elf64_Ehdr *) ehdr)->e_shstrndx;
+        }
+
+        if (shnum >= SHN_LORESERVE ||
+            (shoff == 0LL && (shnum != 0 || phnum == PN_XNUM ||
+                strndx == SHN_XINDEX))) {
+                LIBELF_SET_ERROR(HEADER, 0);
+                return (NULL);
+        }
+
+        if (shnum != 0 || shoff == 0LL) { /* not using extended numbering */
+                e->e_u.e_elf.e_nphdr = phnum;
+                e->e_u.e_elf.e_nscn = shnum;
+                e->e_u.e_elf.e_strndx = strndx;
+        } else if (_libelf_load_extended(e, ec, shoff, phnum, strndx) == 0)
+                return (NULL);
+
+        return (ehdr);
+}
diff --git a/ext/libelf/libelf_extended.c b/ext/libelf/libelf_extended.c
new file mode 100644 (file)
index 0000000..01363aa
--- /dev/null
@@ -0,0 +1,133 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <assert.h>
+#include "libelf.h"
+
+#include "_libelf.h"
+
+/*
+ * Retrieve section #0, allocating a new section if needed.
+ */
+static Elf_Scn *
+_libelf_getscn0(Elf *e)
+{
+        Elf_Scn *s;
+
+        if ((s = STAILQ_FIRST(&e->e_u.e_elf.e_scn)) != NULL)
+                return (s);
+
+        return (_libelf_allocate_scn(e, (size_t) SHN_UNDEF));
+}
+
+int
+_libelf_setshnum(Elf *e, void *eh, int ec, size_t shnum)
+{
+        Elf_Scn *scn;
+
+        if (shnum >= SHN_LORESERVE) {
+                if ((scn = _libelf_getscn0(e)) == NULL)
+                        return (0);
+
+                assert(scn->s_ndx == SHN_UNDEF);
+
+                if (ec == ELFCLASS32)
+                        scn->s_shdr.s_shdr32.sh_size = shnum;
+                else
+                        scn->s_shdr.s_shdr64.sh_size = shnum;
+
+                (void) elf_flagshdr(scn, ELF_C_SET, ELF_F_DIRTY);
+
+                shnum = 0;
+        }
+
+        if (ec == ELFCLASS32)
+                ((Elf32_Ehdr *) eh)->e_shnum = shnum;
+        else
+                ((Elf64_Ehdr *) eh)->e_shnum = shnum;
+
+
+        return (1);
+}
+
+int
+_libelf_setshstrndx(Elf *e, void *eh, int ec, size_t shstrndx)
+{
+        Elf_Scn *scn;
+
+        if (shstrndx >= SHN_LORESERVE) {
+                if ((scn = _libelf_getscn0(e)) == NULL)
+                        return (0);
+
+                assert(scn->s_ndx == SHN_UNDEF);
+
+                if (ec == ELFCLASS32)
+                        scn->s_shdr.s_shdr32.sh_link = shstrndx;
+                else
+                        scn->s_shdr.s_shdr64.sh_link = shstrndx;
+
+                (void) elf_flagshdr(scn, ELF_C_SET, ELF_F_DIRTY);
+
+                shstrndx = SHN_XINDEX;
+        }
+
+        if (ec == ELFCLASS32)
+                ((Elf32_Ehdr *) eh)->e_shstrndx = shstrndx;
+        else
+                ((Elf64_Ehdr *) eh)->e_shstrndx = shstrndx;
+
+        return (1);
+}
+
+int
+_libelf_setphnum(Elf *e, void *eh, int ec, size_t phnum)
+{
+        Elf_Scn *scn;
+
+        if (phnum >= PN_XNUM) {
+                if ((scn = _libelf_getscn0(e)) == NULL)
+                        return (0);
+
+                assert(scn->s_ndx == SHN_UNDEF);
+
+                if (ec == ELFCLASS32)
+                        scn->s_shdr.s_shdr32.sh_info = phnum;
+                else
+                        scn->s_shdr.s_shdr64.sh_info = phnum;
+
+                (void) elf_flagshdr(scn, ELF_C_SET, ELF_F_DIRTY);
+
+                phnum = PN_XNUM;
+        }
+
+        if (ec == ELFCLASS32)
+                ((Elf32_Ehdr *) eh)->e_phnum = phnum;
+        else
+                ((Elf64_Ehdr *) eh)->e_phnum = phnum;
+
+        return (1);
+}
+
diff --git a/ext/libelf/libelf_fsize.m4 b/ext/libelf/libelf_fsize.m4
new file mode 100644 (file)
index 0000000..fa4657b
--- /dev/null
@@ -0,0 +1,151 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD: src/lib/libelf/libelf_fsize.m4,v 1.2 2006/12/18 05:40:01 jkoshy Exp $
+ */
+
+#include "libelf.h"
+#include "_libelf.h"
+
+/*
+ * Create an array of file sizes from the elf_type definitions
+ */
+
+divert(-1)
+include(SRCDIR`/elf_types.m4')
+
+/*
+ * Translations from structure definitions to the size of their file
+ * representations.
+ */
+
+/* `Basic' types */
+define(`BYTE_SIZE',    1)
+define(`IDENT_SIZE',   `EI_NIDENT')
+define(`NOTE_SIZE',    1) /* Elf_Note structures have variable length. */
+
+/* Currently unimplemented types */
+define(`MOVEP_SIZE',   0)
+
+/* Overrides for 32 bit types that do not exist */
+define(`XWORD_SIZE32', 0)
+define(`SXWORD_SIZE32',        0)
+
+/*
+ * FSZ{32,64} define the sizes of 32 and 64 bit file structures respectively.
+ */
+
+define(`FSZ32',`_FSZ32($1_DEF)')
+define(`_FSZ32',
+  `ifelse($#,1,0,
+    `_BSZ32($1)+_FSZ32(shift($@))')')
+define(`_BSZ32',`$2_SIZE32')
+
+define(`FSZ64',`_FSZ64($1_DEF)')
+define(`_FSZ64',
+  `ifelse($#,1,0,
+    `_BSZ64($1)+_FSZ64(shift($@))')')
+define(`_BSZ64',`$2_SIZE64')
+
+/*
+ * DEFINE_ELF_FSIZES(TYPE,NAME)
+ *
+ * Shorthand for defining  for 32 and 64 versions
+ * of elf type TYPE.
+ *
+ * If TYPE`'_SIZE is defined, use its value for both 32 bit and 64 bit
+ * sizes.
+ *
+ * Otherwise, look for a explicit 32/64 bit size definition for TYPE,
+ * TYPE`'_SIZE32 or TYPE`'_SIZE64. If this definition is present, there
+ * is nothing further to do.
+ *
+ * Otherwise, if an Elf{32,64}_`'NAME structure definition is known,
+ * compute an expression that adds up the sizes of the structure's
+ * constituents.
+ *
+ * If such a structure definition is not known, treat TYPE as a primitive
+ * (i.e., integral) type and use sizeof(Elf{32,64}_`'NAME) to get its
+ * file representation size.
+ */
+
+define(`DEFINE_ELF_FSIZE',
+  `ifdef($1`_SIZE',
+    `define($1_SIZE32,$1_SIZE)
+     define($1_SIZE64,$1_SIZE)',
+    `ifdef($1`_SIZE32',`',
+      `ifdef(`Elf32_'$2`_DEF',
+        `define($1_SIZE32,FSZ32(Elf32_$2))',
+        `define($1_SIZE32,`sizeof(Elf32_'$2`)')')')
+     ifdef($1`_SIZE64',`',
+      `ifdef(`Elf64_'$2`_DEF',
+        `define($1_SIZE64,FSZ64(Elf64_$2))',
+        `define($1_SIZE64,`sizeof(Elf64_'$2`)')')')')')
+
+define(`DEFINE_ELF_FSIZES',
+  `ifelse($#,1,`',
+    `DEFINE_ELF_FSIZE($1)
+     DEFINE_ELF_FSIZES(shift($@))')')
+
+DEFINE_ELF_FSIZES(ELF_TYPE_LIST)
+DEFINE_ELF_FSIZE(`IDENT',`')   # `IDENT' is a pseudo type
+
+define(`FSIZE',
+  `[ELF_T_$1] = { .fsz32 = $1_SIZE32, .fsz64 = $1_SIZE64 },')
+define(`FSIZES',
+  `ifelse($#,1,`',
+    `FSIZE($1)
+FSIZES(shift($@))')')
+
+divert(0)
+
+struct fsize {
+       size_t fsz32;
+       size_t fsz64;
+};
+
+static struct fsize fsize[ELF_T_NUM] = {
+FSIZES(ELF_TYPE_LIST)
+};
+
+size_t
+_libelf_fsize(Elf_Type t, int ec, unsigned int v, size_t c)
+{
+       size_t sz;
+
+       sz = 0;
+       if (v != EV_CURRENT)
+               LIBELF_SET_ERROR(VERSION, 0);
+       else if ((int) t < ELF_T_FIRST || t > ELF_T_LAST)
+               LIBELF_SET_ERROR(ARGUMENT, 0);
+       else {
+               sz = ec == ELFCLASS64 ? fsize[t].fsz64 : fsize[t].fsz32;
+               if (sz == 0)
+                       LIBELF_SET_ERROR(UNIMPL, 0);
+       }
+
+       return (sz*c);
+}
+
diff --git a/ext/libelf/libelf_msize.m4 b/ext/libelf/libelf_msize.m4
new file mode 100644 (file)
index 0000000..cca3167
--- /dev/null
@@ -0,0 +1,101 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/types.h>
+
+#include <assert.h>
+#include <string.h>
+
+#include "elf32.h"
+#include "elf64.h"
+#include "libelf.h"
+#include "_libelf.h"
+
+/* WARNING: GENERATED FROM __file__. */
+
+struct msize {
+       size_t  msz32;
+       size_t  msz64;
+};
+
+divert(-1)
+include(SRCDIR`/elf_types.m4')
+
+define(BYTE_SIZE,      1)
+define(NOTE_SIZE,      1)
+
+/*
+ * Unimplemented types.
+ */
+define(MOVEP_SIZE,     0)
+define(SXWORD_SIZE32,  0)
+define(XWORD_SIZE32,   0)
+
+define(`DEFINE_ELF_MSIZE',
+  `ifdef($1`_SIZE',
+    `define($1_SIZE32,$1_SIZE)
+     define($1_SIZE64,$1_SIZE)',
+    `ifdef($1`_SIZE32',`',
+      `define($1_SIZE32,sizeof(Elf32_$2))')
+     ifdef($1`_SIZE64',`',
+      `define($1_SIZE64,sizeof(Elf64_$2))')')')
+define(`DEFINE_ELF_MSIZES',
+  `ifelse($#,1,`',
+    `DEFINE_ELF_MSIZE($1)
+     DEFINE_ELF_MSIZES(shift($@))')')
+
+DEFINE_ELF_MSIZES(ELF_TYPE_LIST)
+
+define(`MSIZE',
+  `[ELF_T_$1] = { .msz32 = $1_SIZE32, .msz64 = $1_SIZE64 },')
+define(`MSIZES',
+  `ifelse($#,1,`',
+    `MSIZE($1)
+MSIZES(shift($@))')')
+
+divert(0)
+
+static struct msize msize[ELF_T_NUM] = {
+MSIZES(ELF_TYPE_LIST)
+};
+
+size_t
+_libelf_msize(Elf_Type t, int elfclass, unsigned int version)
+{
+       size_t sz;
+
+       assert(elfclass == ELFCLASS32 || elfclass == ELFCLASS64);
+       assert((signed) t >= ELF_T_FIRST && t <= ELF_T_LAST);
+
+       if (version != EV_CURRENT) {
+               LIBELF_SET_ERROR(VERSION, 0);
+               return (0);
+       }
+
+       sz = (elfclass == ELFCLASS32) ? msize[t].msz32 : msize[t].msz64;
+
+       return (sz);
+}
diff --git a/ext/libelf/libelf_phdr.c b/ext/libelf/libelf_phdr.c
new file mode 100644 (file)
index 0000000..1d7e90b
--- /dev/null
@@ -0,0 +1,154 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD: src/lib/libelf/libelf_phdr.c,v 1.2 2006/12/25 02:22:22 jkoshy Exp $
+ */
+
+#include <assert.h>
+#include <stdlib.h>
+
+#include "gelf.h"
+#include "libelf.h"
+#include "_libelf.h"
+
+void *
+_libelf_getphdr(Elf *e, int ec)
+{
+        size_t phnum, phentsize;
+        size_t fsz, msz;
+        uint64_t phoff;
+        Elf32_Ehdr *eh32;
+        Elf64_Ehdr *eh64;
+        void *ehdr, *phdr;
+        void (*xlator)(char *_d, char *_s, size_t _c, int _swap);
+
+        assert(ec == ELFCLASS32 || ec == ELFCLASS64);
+
+        if (e == NULL) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        if ((phdr = (ec == ELFCLASS32 ?
+                 (void *) e->e_u.e_elf.e_phdr.e_phdr32 :
+                 (void *) e->e_u.e_elf.e_phdr.e_phdr64)) != NULL)
+                return (phdr);
+
+        /*
+         * Check the PHDR related fields in the EHDR for sanity.
+         */
+
+        if ((ehdr = _libelf_ehdr(e, ec, 0)) == NULL)
+                return (NULL);
+
+        phnum = e->e_u.e_elf.e_nphdr;
+
+        if (ec == ELFCLASS32) {
+                eh32      = (Elf32_Ehdr *) ehdr;
+                phentsize = eh32->e_phentsize;
+                phoff     = (uint64_t) eh32->e_phoff;
+        } else {
+                eh64      = (Elf64_Ehdr *) ehdr;
+                phentsize = eh64->e_phentsize;
+                phoff     = (uint64_t) eh64->e_phoff;
+        }
+
+        fsz = gelf_fsize(e, ELF_T_PHDR, phnum, e->e_version);
+
+        assert(fsz > 0);
+
+        if ((uint64_t) e->e_rawsize < (phoff + fsz)) {
+                LIBELF_SET_ERROR(HEADER, 0);
+                return (NULL);
+        }
+
+        msz = _libelf_msize(ELF_T_PHDR, ec, EV_CURRENT);
+
+        assert(msz > 0);
+
+        if ((phdr = calloc(phnum, msz)) == NULL) {
+                LIBELF_SET_ERROR(RESOURCE, 0);
+                return (NULL);
+        }
+
+        if (ec == ELFCLASS32)
+                e->e_u.e_elf.e_phdr.e_phdr32 = phdr;
+        else
+                e->e_u.e_elf.e_phdr.e_phdr64 = phdr;
+
+
+        xlator = _libelf_get_translator(ELF_T_PHDR, ELF_TOMEMORY, ec);
+        (*xlator)(phdr, e->e_rawfile + phoff, phnum,
+            e->e_byteorder != LIBELF_PRIVATE(byteorder));
+
+        return (phdr);
+}
+
+void *
+_libelf_newphdr(Elf *e, int ec, size_t count)
+{
+        void *ehdr, *newphdr, *oldphdr;
+        size_t msz;
+
+        if (e == NULL) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        if ((ehdr = _libelf_ehdr(e, ec, 0)) == NULL) {
+                LIBELF_SET_ERROR(SEQUENCE, 0);
+                return (NULL);
+        }
+
+        assert(e->e_class == ec);
+        assert(ec == ELFCLASS32 || ec == ELFCLASS64);
+        assert(e->e_version == EV_CURRENT);
+
+        msz = _libelf_msize(ELF_T_PHDR, ec, e->e_version);
+
+        assert(msz > 0);
+
+        newphdr = NULL;
+        if (count > 0 && (newphdr = calloc(count, msz)) == NULL) {
+                LIBELF_SET_ERROR(RESOURCE, 0);
+                return (NULL);
+        }
+
+        if (ec == ELFCLASS32) {
+                if ((oldphdr = (void *) e->e_u.e_elf.e_phdr.e_phdr32) != NULL)
+                        free(oldphdr);
+                e->e_u.e_elf.e_phdr.e_phdr32 = (Elf32_Phdr *) newphdr;
+        } else {
+                if ((oldphdr = (void *) e->e_u.e_elf.e_phdr.e_phdr64) != NULL)
+                        free(oldphdr);
+                e->e_u.e_elf.e_phdr.e_phdr64 = (Elf64_Phdr *) newphdr;
+        }
+
+        e->e_u.e_elf.e_nphdr = count;
+
+        elf_flagphdr(e, ELF_C_SET, ELF_F_DIRTY);
+
+        return (newphdr);
+}
diff --git a/ext/libelf/libelf_shdr.c b/ext/libelf/libelf_shdr.c
new file mode 100644 (file)
index 0000000..c1e1407
--- /dev/null
@@ -0,0 +1,51 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "gelf.h"
+#include "libelf.h"
+#include "_libelf.h"
+
+void *
+_libelf_getshdr(Elf_Scn *s, int ec)
+{
+        Elf *e;
+
+        if (s == NULL || (e = s->s_elf) == NULL ||
+            e->e_kind != ELF_K_ELF) {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        if (ec == ELFCLASSNONE)
+                ec = e->e_class;
+
+        if (ec != e->e_class) {
+                LIBELF_SET_ERROR(CLASS, 0);
+                return (NULL);
+        }
+
+        return ((void *) &s->s_shdr);
+}
diff --git a/ext/libelf/libelf_xlate.c b/ext/libelf/libelf_xlate.c
new file mode 100644 (file)
index 0000000..c5fea20
--- /dev/null
@@ -0,0 +1,141 @@
+/*-
+ * Copyright (c) 2006 Joseph Koshy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <assert.h>
+
+#include "libelf.h"
+#include "_libelf.h"
+
+/*
+ * Translate to/from the file representation of ELF objects.
+ *
+ * Translation could potentially involve the following
+ * transformations:
+ *
+ * - an endianness conversion,
+ * - a change of layout, as the file representation of ELF objects
+ *   can differ from their in-memory representation.
+ * - a change in representation due to a layout version change.
+ */
+
+Elf_Data *
+_libelf_xlate(Elf_Data *dst, const Elf_Data *src, unsigned int encoding,
+    int elfclass, int direction)
+{
+        size_t cnt, dsz, fsz, msz;
+        uintptr_t sb, se, db, de;
+
+        if (encoding == ELFDATANONE)
+                encoding = LIBELF_PRIVATE(byteorder);
+
+        if ((encoding != ELFDATA2LSB && encoding != ELFDATA2MSB) ||
+            dst == NULL || src == NULL || dst == src)  {
+                LIBELF_SET_ERROR(ARGUMENT, 0);
+                return (NULL);
+        }
+
+        assert(elfclass == ELFCLASS32 || elfclass == ELFCLASS64);
+        assert(direction == ELF_TOFILE || direction == ELF_TOMEMORY);
+
+        if (dst->d_version != src->d_version) {
+                LIBELF_SET_ERROR(UNIMPL, 0);
+                return (NULL);
+        }
+
+        if  (src->d_buf == NULL || dst->d_buf == NULL ||
+            src->d_size == 0) {
+                LIBELF_SET_ERROR(DATA, 0);
+                return (NULL);
+        }
+
+        if ((int) src->d_type < 0 || src->d_type >= ELF_T_NUM) {
+                LIBELF_SET_ERROR(DATA, 0);
+                return (NULL);
+        }
+
+        if ((fsz = (elfclass == ELFCLASS32 ? elf32_fsize : elf64_fsize)(src->d_type,
+                 (size_t) 1, src->d_version)) == 0)
+                return (NULL);
+
+        msz = _libelf_msize(src->d_type, elfclass, src->d_version);
+
+        assert(msz > 0);
+
+        if (src->d_size % (direction == ELF_TOMEMORY ? fsz : msz)) {
+                LIBELF_SET_ERROR(DATA, 0);
+                return (NULL);
+        }
+
+        /*
+         * Determine the number of objects that need to be converted, and
+         * the space required for the converted objects in the destination
+         * buffer.
+         */
+        if (direction == ELF_TOMEMORY) {
+                cnt = src->d_size / fsz;
+                dsz = cnt * msz;
+        } else {
+                cnt = src->d_size / msz;
+                dsz = cnt * fsz;
+        }
+
+        if (dst->d_size  <  dsz) {
+                LIBELF_SET_ERROR(DATA, 0);
+                return (NULL);
+        }
+
+        sb = (uintptr_t) src->d_buf;
+        se = sb + src->d_size;
+        db = (uintptr_t) dst->d_buf;
+        de = db + dst->d_size;
+
+        /*
+         * Check for overlapping buffers.  Note that db == sb is
+         * allowed.
+         */
+        if (db != sb && de > sb && se > db) {
+                LIBELF_SET_ERROR(DATA, 0);
+                return (NULL);
+        }
+
+        if ((direction == ELF_TOMEMORY ? db : sb) %
+            _libelf_malign(src->d_type, elfclass)) {
+                LIBELF_SET_ERROR(DATA, 0);
+                return (NULL);
+        }
+
+        dst->d_type = src->d_type;
+        dst->d_size = dsz;
+
+        if (db == sb && encoding == LIBELF_PRIVATE(byteorder) &&
+            fsz == msz)
+                return (dst);  /* nothing more to do */
+
+        (_libelf_get_translator(src->d_type, direction, elfclass))(dst->d_buf,
+            src->d_buf, cnt, encoding != LIBELF_PRIVATE(byteorder));
+
+        return (dst);
+}