|
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] Re: [Minios-devel] [UNIKRAFT/LIBELF PATCH 1/7] Copy from official ELF Tool Chain (0.7.1)
Reviewed-by: Razvan Deaconescu <razvan.deaconescu@xxxxxxxxx> On Wed, Mar 25, 2020 at 7:41 PM Simon Kuenzer <simon.kuenzer@xxxxxxxxx> wrote: > Unmodified copy of libelf sources from official ELF Tool Chain project: > https://downloads.sourceforge.net/project/elftoolchain/Sources/elftoolchain-0.7.1/elftoolchain-0.7.1.tar.bz2 > > Signed-off-by: Simon Kuenzer <simon.kuenzer@xxxxxxxxx> > --- > README.elftoolchain | 127 ++ > Version.map | 96 ++ > _elftc.h | 484 +++++++ > _libelf.h | 239 ++++ > _libelf_ar.h | 57 + > _libelf_config.h | 183 +++ > elf.c | 40 + > elf_begin.c | 91 ++ > elf_cntl.c | 58 + > elf_data.c | 276 ++++ > elf_end.c | 95 ++ > elf_errmsg.c | 83 ++ > elf_errno.c | 41 + > elf_fill.c | 37 + > elf_flag.c | 196 +++ > elf_getarhdr.c | 45 + > elf_getarsym.c | 56 + > elf_getbase.c | 46 + > elf_getident.c | 66 + > elf_hash.c | 54 + > elf_kind.c | 42 + > elf_memory.c | 47 + > elf_next.c | 64 + > elf_open.c | 67 + > elf_phnum.c | 65 + > elf_rand.c | 57 + > elf_rawfile.c | 51 + > elf_scn.c | 235 ++++ > elf_shnum.c | 65 + > elf_shstrndx.c | 80 ++ > elf_strptr.c | 132 ++ > elf_types.m4 | 309 +++++ > elf_update.c | 1215 +++++++++++++++++ > elf_version.c | 50 + > gelf_cap.c | 150 +++ > gelf_checksum.c | 56 + > gelf_dyn.c | 152 +++ > gelf_ehdr.c | 167 +++ > gelf_fsize.c | 60 + > gelf_getclass.c | 37 + > gelf_move.c | 159 +++ > gelf_phdr.c | 177 +++ > gelf_rel.c | 162 +++ > gelf_rela.c | 165 +++ > gelf_shdr.c | 130 ++ > gelf_sym.c | 159 +++ > gelf_syminfo.c | 152 +++ > gelf_symshndx.c | 137 ++ > gelf_xlate.c | 79 ++ > include/elfdefinitions.h | 2700 ++++++++++++++++++++++++++++++++++++++ > include/gelf.h | 110 ++ > include/libelf.h | 256 ++++ > libelf_align.c | 135 ++ > libelf_allocate.c | 210 +++ > libelf_ar.c | 466 +++++++ > libelf_ar_util.c | 360 +++++ > libelf_checksum.c | 98 ++ > libelf_convert.m4 | 1087 +++++++++++++++ > libelf_data.c | 101 ++ > libelf_ehdr.c | 204 +++ > libelf_extended.c | 134 ++ > libelf_fsize.m4 | 159 +++ > libelf_memory.c | 96 ++ > libelf_msize.m4 | 106 ++ > libelf_open.c | 249 ++++ > libelf_phdr.c | 153 +++ > libelf_shdr.c | 54 + > libelf_xlate.c | 148 +++ > 68 files changed, 13617 insertions(+) > create mode 100644 README.elftoolchain > create mode 100644 Version.map > create mode 100644 _elftc.h > create mode 100644 _libelf.h > create mode 100644 _libelf_ar.h > create mode 100644 _libelf_config.h > create mode 100644 elf.c > create mode 100644 elf_begin.c > create mode 100644 elf_cntl.c > create mode 100644 elf_data.c > create mode 100644 elf_end.c > create mode 100644 elf_errmsg.c > create mode 100644 elf_errno.c > create mode 100644 elf_fill.c > create mode 100644 elf_flag.c > create mode 100644 elf_getarhdr.c > create mode 100644 elf_getarsym.c > create mode 100644 elf_getbase.c > create mode 100644 elf_getident.c > create mode 100644 elf_hash.c > create mode 100644 elf_kind.c > create mode 100644 elf_memory.c > create mode 100644 elf_next.c > create mode 100644 elf_open.c > create mode 100644 elf_phnum.c > create mode 100644 elf_rand.c > create mode 100644 elf_rawfile.c > create mode 100644 elf_scn.c > create mode 100644 elf_shnum.c > create mode 100644 elf_shstrndx.c > create mode 100644 elf_strptr.c > create mode 100644 elf_types.m4 > create mode 100644 elf_update.c > create mode 100644 elf_version.c > create mode 100644 gelf_cap.c > create mode 100644 gelf_checksum.c > create mode 100644 gelf_dyn.c > create mode 100644 gelf_ehdr.c > create mode 100644 gelf_fsize.c > create mode 100644 gelf_getclass.c > create mode 100644 gelf_move.c > create mode 100644 gelf_phdr.c > create mode 100644 gelf_rel.c > create mode 100644 gelf_rela.c > create mode 100644 gelf_shdr.c > create mode 100644 gelf_sym.c > create mode 100644 gelf_syminfo.c > create mode 100644 gelf_symshndx.c > create mode 100644 gelf_xlate.c > create mode 100644 include/elfdefinitions.h > create mode 100644 include/gelf.h > create mode 100644 include/libelf.h > create mode 100644 libelf_align.c > create mode 100644 libelf_allocate.c > create mode 100644 libelf_ar.c > create mode 100644 libelf_ar_util.c > create mode 100644 libelf_checksum.c > create mode 100644 libelf_convert.m4 > create mode 100644 libelf_data.c > create mode 100644 libelf_ehdr.c > create mode 100644 libelf_extended.c > create mode 100644 libelf_fsize.m4 > create mode 100644 libelf_memory.c > create mode 100644 libelf_msize.m4 > create mode 100644 libelf_open.c > create mode 100644 libelf_phdr.c > create mode 100644 libelf_shdr.c > create mode 100644 libelf_xlate.c > > diff --git a/README.elftoolchain b/README.elftoolchain > new file mode 100644 > index 0000000..c9ab072 > --- /dev/null > +++ b/README.elftoolchain > @@ -0,0 +1,127 @@ > +The Elftoolchain Project > +======================== > + > +.. contents:: > +.. > + > +Description > +----------- > + > +This software implements essential compilation tools and libraries for: > + > +- managing program objects conforming to the ELF_ object format, and > +- for managing DWARF_ debugging information in ELF objects. > + > +The project currently implements the following utilities and > +libraries: > + > + =========== ============================================ > + Name Description > + =========== ============================================ > + ar Archive manager. > + addr2line Debug tool. > + brandelf Manage the ELF brand on executables. > + c++filt Translate encoded symbols. > + elfcopy Copy and translate between object formats. > + elfdump Diagnostic tool. > + findtextrel Find undesired text relocations. > + libdwarf DWARF access library. > + libelf ELF access library. > + mcs Manage comment sections. > + nm List symbols in an ELF object. > + ranlib Add archive symbol tables to an archive. > + readelf Display ELF information. > + size List object sizes. > + strings Extract printable strings. > + strip Discard information from ELF objects. > + =========== ============================================ > + > +.. _ELF: http://en.wikipedia.org/wiki/Executable_and_Linkable_Format > +.. _DWARF: http://www.dwarfstd.org/ > + > + > +Project Documentation > +--------------------- > + > +- Release notes for released versions of this software are present in > + the file ``RELEASE-NOTES`` in the current directory. > +- The file ``INSTALL`` in the current directory contains instructions > + on building and installing this software. > +- Reference documentation in the form of manual pages is provided for > + the utilities and libraries developed by the project. > +- Additional tutorial documentation is present in the > + ``documentation`` directory. > + > + > +Tracking Ongoing Development > +---------------------------- > + > +The project uses subversion_ for its version control system. > + > +The subversion branch for the current set of sources may be accessed > +at the following URL: > + > + https://elftoolchain.svn.sourceforge.net/svnroot/elftoolchain/trunk > + > +The project's source tree may be checked out from its repository by > +using the ``svn checkout`` command:: > + > + % svn checkout > https://elftoolchain.svn.sourceforge.net/svnroot/elftoolchain/trunk > + > +Checked-out sources may be kept upto-date by running ``svn update`` > +inside the source directory:: > + > + % svn update > + > + > +Instructions on building and installing the software are given in the > +file ``INSTALL`` in the current directory. > + > +.. _Subversion: > + > +Downloading Released Software > +----------------------------- > + > +Released versions of the project's software may also be downloaded > +from SourceForge's `file release system`_. > + > +.. _file release system: http://sourceforge.net/projects/elftoolchain/files/ > + > +Copyright and License > +--------------------- > + > +This code is copyright its authors, and is distributed under the `BSD > +License`_. > + > +.. _BSD License: http://www.opensource.org/licenses/bsd-license.php > + > + > +Developer Community > +------------------- > + > +The project's developers may be contacted using the mailing list: > +``<elftoolchain-developers@xxxxxxxxxxxxxxxxxxxxx>``. > + > + > +Reporting Bugs > +-------------- > + > +Please use our `Trac instance`_ for viewing existing bug reports and > +for submitting new bug reports. > + > +.. _`Trac instance`: http://sourceforge.net/apps/trac/elftoolchain/report > + > + > +Additional Information > +---------------------- > + > +Additional information about the project may be found on the `project > +website`_. > + > +.. _project website: http://elftoolchain.sourceforge.net/ > + > +.. $Id: README 2146 2011-11-11 09:39:00Z jkoshy $ > + > +.. Local Variables: > +.. mode: rst > +.. End: > diff --git a/Version.map b/Version.map > new file mode 100644 > index 0000000..e71a591 > --- /dev/null > +++ b/Version.map > @@ -0,0 +1,96 @@ > +/* $Id: Version.map 2574 2012-09-11 15:11:59Z jkoshy $ */ > + > +R1.0 { > +global: > + elf32_checksum; > + elf32_fsize; > + elf32_getehdr; > + elf32_getphdr; > + elf32_getshdr; > + elf32_newehdr; > + elf32_newphdr; > + elf32_xlatetof; > + elf32_xlatetom; > + elf64_checksum; > + elf64_fsize; > + elf64_getehdr; > + elf64_getphdr; > + elf64_getshdr; > + elf64_newehdr; > + elf64_newphdr; > + elf64_xlatetof; > + elf64_xlatetom; > + elf_begin; > + elf_cntl; > + elf_end; > + elf_errmsg; > + elf_errno; > + elf_fill; > + elf_flagarhdr; > + elf_flagdata; > + elf_flagehdr; > + elf_flagelf; > + elf_flagphdr; > + elf_flagscn; > + elf_flagshdr; > + elf_getarhdr; > + elf_getarsym; > + elf_getbase; > + elf_getdata; > + elf_getident; > + elf_getphdrnum; > + elf_getphnum; > + elf_getscn; > + elf_getshdrnum; > + elf_getshdrstrndx; > + elf_getshnum; > + elf_getshstrndx; > + elf_hash; > + elf_kind; > + elf_memory; > + elf_ndxscn; > + elf_newdata; > + elf_newscn; > + elf_next; > + elf_nextscn; > + elf_open; > + elf_openmemory; > + elf_rand; > + elf_rawdata; > + elf_rawfile; > + elf_setshstrndx; > + elf_strptr; > + elf_update; > + elf_version; > + gelf_checksum; > + gelf_fsize; > + gelf_getcap; > + gelf_getclass; > + gelf_getdyn; > + gelf_getehdr; > + gelf_getmove; > + gelf_getphdr; > + gelf_getrel; > + gelf_getrela; > + gelf_getshdr; > + gelf_getsym; > + gelf_getsyminfo; > + gelf_getsymshndx; > + gelf_newehdr; > + gelf_newphdr; > + gelf_update_cap; > + gelf_update_dyn; > + gelf_update_ehdr; > + gelf_update_move; > + gelf_update_phdr; > + gelf_update_rel; > + gelf_update_rela; > + gelf_update_shdr; > + gelf_update_sym; > + gelf_update_syminfo; > + gelf_update_symshndx; > + gelf_xlatetof; > + gelf_xlatetom; > +local: > + *; > +}; > diff --git a/_elftc.h b/_elftc.h > new file mode 100644 > index 0000000..94272ef > --- /dev/null > +++ b/_elftc.h > @@ -0,0 +1,484 @@ > +/*- > + * Copyright (c) 2009 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. > + * > + * $Id: _elftc.h 3244 2015-08-31 19:53:08Z emaste $ > + */ > + > +/** > + ** Miscellanous definitions needed by multiple components. > + **/ > + > +#ifndef _ELFTC_H > +#define _ELFTC_H > + > +#ifndef NULL > +#define NULL ((void *) 0) > +#endif > + > +#ifndef offsetof > +#define offsetof(T, M) ((int) &((T*) 0) -> M) > +#endif > + > +/* --QUEUE-MACROS-- [[ */ > + > +/* > + * Supply macros missing from <sys/queue.h> > + */ > + > +/* > + * 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. > + * 3. 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. > + */ > + > +#ifndef LIST_FOREACH_SAFE > +#define LIST_FOREACH_SAFE(var, head, field, tvar) \ > + for ((var) = LIST_FIRST((head)); \ > + (var) && ((tvar) = LIST_NEXT((var), field), 1); \ > + (var) = (tvar)) > +#endif > + > +#ifndef SLIST_FOREACH_SAFE > +#define SLIST_FOREACH_SAFE(var, head, field, tvar) \ > + for ((var) = SLIST_FIRST((head)); \ > + (var) && ((tvar) = SLIST_NEXT((var), field), 1); \ > + (var) = (tvar)) > +#endif > + > +#ifndef STAILQ_CONCAT > +#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 (/*CONSTCOND*/0) > +#endif > + > +#ifndef STAILQ_EMPTY > +#define STAILQ_EMPTY(head) ((head)->stqh_first == NULL) > +#endif > + > +#ifndef STAILQ_ENTRY > +#define STAILQ_ENTRY(type) \ > +struct { \ > + struct type *stqe_next; /* next element */ \ > +} > +#endif > + > +#ifndef STAILQ_FIRST > +#define STAILQ_FIRST(head) ((head)->stqh_first) > +#endif > + > +#ifndef STAILQ_HEAD > +#define STAILQ_HEAD(name, type) \ > +struct name { \ > + struct type *stqh_first; /* first element */ \ > + struct type **stqh_last; /* addr of last next element */ \ > +} > +#endif > + > +#ifndef STAILQ_HEAD_INITIALIZER > +#define STAILQ_HEAD_INITIALIZER(head) \ > + { NULL, &(head).stqh_first } > +#endif > + > +#ifndef STAILQ_FOREACH > +#define STAILQ_FOREACH(var, head, field) \ > + for ((var) = ((head)->stqh_first); \ > + (var); \ > + (var) = ((var)->field.stqe_next)) > +#endif > + > +#ifndef STAILQ_FOREACH_SAFE > +#define STAILQ_FOREACH_SAFE(var, head, field, tvar) \ > + for ((var) = STAILQ_FIRST((head)); \ > + (var) && ((tvar) = STAILQ_NEXT((var), field), 1); \ > + (var) = (tvar)) > +#endif > + > +#ifndef STAILQ_INIT > +#define STAILQ_INIT(head) do { \ > + (head)->stqh_first = NULL; \ > + (head)->stqh_last = &(head)->stqh_first; \ > +} while (/*CONSTCOND*/0) > +#endif > + > +#ifndef STAILQ_INSERT_HEAD > +#define STAILQ_INSERT_HEAD(head, elm, field) do { > \ > + if (((elm)->field.stqe_next = (head)->stqh_first) == NULL) \ > + (head)->stqh_last = &(elm)->field.stqe_next; \ > + (head)->stqh_first = (elm); \ > +} while (/*CONSTCOND*/0) > +#endif > + > +#ifndef STAILQ_INSERT_TAIL > +#define STAILQ_INSERT_TAIL(head, elm, field) do { > \ > + (elm)->field.stqe_next = NULL; \ > + *(head)->stqh_last = (elm); \ > + (head)->stqh_last = &(elm)->field.stqe_next; \ > +} while (/*CONSTCOND*/0) > +#endif > + > +#ifndef STAILQ_INSERT_AFTER > +#define STAILQ_INSERT_AFTER(head, listelm, elm, field) do { > \ > + if (((elm)->field.stqe_next = (listelm)->field.stqe_next) == NULL)\ > + (head)->stqh_last = &(elm)->field.stqe_next; \ > + (listelm)->field.stqe_next = (elm); \ > +} while (/*CONSTCOND*/0) > +#endif > + > +#ifndef STAILQ_LAST > +#define STAILQ_LAST(head, type, field) \ > + (STAILQ_EMPTY((head)) ? \ > + NULL : ((struct type *)(void *) \ > + ((char *)((head)->stqh_last) - offsetof(struct type, field)))) > +#endif > + > +#ifndef STAILQ_NEXT > +#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next) > +#endif > + > +#ifndef STAILQ_REMOVE > +#define STAILQ_REMOVE(head, elm, type, field) do { > \ > + if ((head)->stqh_first == (elm)) { \ > + STAILQ_REMOVE_HEAD((head), field); \ > + } else { \ > + struct type *curelm = (head)->stqh_first; \ > + while (curelm->field.stqe_next != (elm)) \ > + curelm = curelm->field.stqe_next; \ > + if ((curelm->field.stqe_next = \ > + curelm->field.stqe_next->field.stqe_next) == NULL) \ > + (head)->stqh_last = &(curelm)->field.stqe_next; \ > + } \ > +} while (/*CONSTCOND*/0) > +#endif > + > +#ifndef STAILQ_REMOVE_HEAD > +#define STAILQ_REMOVE_HEAD(head, field) do { > \ > + if (((head)->stqh_first = (head)->stqh_first->field.stqe_next) == \ > + NULL) \ > + (head)->stqh_last = &(head)->stqh_first; \ > +} while (/*CONSTCOND*/0) > +#endif > + > +/* > + * The STAILQ_SORT macro is adapted from Simon Tatham's O(n*log(n)) > + * mergesort algorithm. > + */ > +#ifndef STAILQ_SORT > +#define STAILQ_SORT(head, type, field, cmp) do { > \ > + STAILQ_HEAD(, type) _la, _lb; \ > + struct type *_p, *_q, *_e; \ > + int _i, _sz, _nmerges, _psz, _qsz; \ > + \ > + _sz = 1; \ > + do { \ > + _nmerges = 0; \ > + STAILQ_INIT(&_lb); \ > + while (!STAILQ_EMPTY((head))) { \ > + _nmerges++; \ > + STAILQ_INIT(&_la); \ > + _psz = 0; \ > + for (_i = 0; _i < _sz && !STAILQ_EMPTY((head)); \ > + _i++) { \ > + _e = STAILQ_FIRST((head)); \ > + if (_e == NULL) \ > + break; \ > + _psz++; \ > + STAILQ_REMOVE_HEAD((head), field); \ > + STAILQ_INSERT_TAIL(&_la, _e, field); \ > + } \ > + _p = STAILQ_FIRST(&_la); \ > + _qsz = _sz; \ > + _q = STAILQ_FIRST((head)); \ > + while (_psz > 0 || (_qsz > 0 && _q != NULL)) { \ > + if (_psz == 0) { \ > + _e = _q; \ > + _q = STAILQ_NEXT(_q, field); \ > + STAILQ_REMOVE_HEAD((head), \ > + field); \ > + _qsz--; \ > + } else if (_qsz == 0 || _q == NULL) { \ > + _e = _p; \ > + _p = STAILQ_NEXT(_p, field); \ > + STAILQ_REMOVE_HEAD(&_la, field);\ > + _psz--; \ > + } else if (cmp(_p, _q) <= 0) { \ > + _e = _p; \ > + _p = STAILQ_NEXT(_p, field); \ > + STAILQ_REMOVE_HEAD(&_la, field);\ > + _psz--; \ > + } else { \ > + _e = _q; \ > + _q = STAILQ_NEXT(_q, field); \ > + STAILQ_REMOVE_HEAD((head), \ > + field); \ > + _qsz--; \ > + } \ > + STAILQ_INSERT_TAIL(&_lb, _e, field); \ > + } \ > + } \ > + (head)->stqh_first = _lb.stqh_first; \ > + (head)->stqh_last = _lb.stqh_last; \ > + _sz *= 2; \ > + } while (_nmerges > 1); \ > +} while (/*CONSTCOND*/0) > +#endif > + > +#ifndef TAILQ_FOREACH_SAFE > +#define TAILQ_FOREACH_SAFE(var, head, field, tvar) \ > + for ((var) = TAILQ_FIRST((head)); \ > + (var) && ((tvar) = TAILQ_NEXT((var), field), 1); \ > + (var) = (tvar)) > +#endif > + > +/* ]] --QUEUE-MACROS-- */ > + > +/* > + * VCS Ids. > + */ > + > +#ifndef ELFTC_VCSID > + > +#if defined(__DragonFly__) > +#define ELFTC_VCSID(ID) __RCSID(ID) > +#endif > + > +#if defined(__FreeBSD__) > +#define ELFTC_VCSID(ID) __FBSDID(ID) > +#endif > + > +#if defined(__APPLE__) || defined(__GLIBC__) || defined(__GNU__) || \ > + defined(__linux__) > +#if defined(__GNUC__) > +#define ELFTC_VCSID(ID) __asm__(".ident\t\"" ID "\"") > +#else > +#define ELFTC_VCSID(ID) /**/ > +#endif > +#endif > + > +#if defined(__minix) > +#if defined(__GNUC__) > +#define ELFTC_VCSID(ID) __asm__(".ident\t\"" ID "\"") > +#else > +#define ELFTC_VCSID(ID) /**/ > +#endif /* __GNU__ */ > +#endif > + > +#if defined(__NetBSD__) > +#define ELFTC_VCSID(ID) __RCSID(ID) > +#endif > + > +#if defined(__OpenBSD__) > +#if defined(__GNUC__) > +#define ELFTC_VCSID(ID) __asm__(".ident\t\"" ID "\"") > +#else > +#define ELFTC_VCSID(ID) /**/ > +#endif /* __GNUC__ */ > +#endif > + > +#endif /* ELFTC_VCSID */ > + > +/* > + * Provide an equivalent for getprogname(3). > + */ > + > +#ifndef ELFTC_GETPROGNAME > + > +#if defined(__APPLE__) || defined(__DragonFly__) || defined(__FreeBSD__) || \ > + defined(__minix) || defined(__NetBSD__) > + > +#include <stdlib.h> > + > +#define ELFTC_GETPROGNAME() getprogname() > + > +#endif /* __DragonFly__ || __FreeBSD__ || __minix || __NetBSD__ */ > + > + > +#if defined(__GLIBC__) || defined(__linux__) > +#ifndef _GNU_SOURCE > +/* > + * GLIBC based systems have a global 'char *' pointer referencing > + * the executable's name. > + */ > +extern const char *program_invocation_short_name; > +#endif /* !_GNU_SOURCE */ > + > +#define ELFTC_GETPROGNAME() program_invocation_short_name > + > +#endif /* __GLIBC__ || __linux__ */ > + > + > +#if defined(__OpenBSD__) > + > +extern const char *__progname; > + > +#define ELFTC_GETPROGNAME() __progname > + > +#endif /* __OpenBSD__ */ > + > +#endif /* ELFTC_GETPROGNAME */ > + > + > +/** > + ** Per-OS configuration. > + **/ > + > +#if defined(__APPLE__) > + > +#include <libkern/OSByteOrder.h> > +#define htobe32(x) OSSwapHostToBigInt32(x) > +#define roundup2 roundup > + > +#define ELFTC_BYTE_ORDER _BYTE_ORDER > +#define ELFTC_BYTE_ORDER_LITTLE_ENDIAN _LITTLE_ENDIAN > +#define ELFTC_BYTE_ORDER_BIG_ENDIAN _BIG_ENDIAN > + > +#define ELFTC_HAVE_MMAP 1 > +#define ELFTC_HAVE_STRMODE 1 > + > +#define ELFTC_NEED_BYTEORDER_EXTENSIONS 1 > +#endif /* __APPLE__ */ > + > + > +#if defined(__DragonFly__) > + > +#include <osreldate.h> > +#include <sys/endian.h> > + > +#define ELFTC_BYTE_ORDER _BYTE_ORDER > +#define ELFTC_BYTE_ORDER_LITTLE_ENDIAN _LITTLE_ENDIAN > +#define ELFTC_BYTE_ORDER_BIG_ENDIAN _BIG_ENDIAN > + > +#define ELFTC_HAVE_MMAP 1 > + > +#endif > + > +#if defined(__GLIBC__) || defined(__linux__) > + > +#include <endian.h> > + > +#define ELFTC_BYTE_ORDER __BYTE_ORDER > +#define ELFTC_BYTE_ORDER_LITTLE_ENDIAN __LITTLE_ENDIAN > +#define ELFTC_BYTE_ORDER_BIG_ENDIAN __BIG_ENDIAN > + > +#define ELFTC_HAVE_MMAP 1 > + > +/* > + * Debian GNU/Linux and Debian GNU/kFreeBSD do not have strmode(3). > + */ > +#define ELFTC_HAVE_STRMODE 0 > + > +/* Whether we need to supply {be,le}32dec. */ > +#define ELFTC_NEED_BYTEORDER_EXTENSIONS 1 > + > +#define roundup2 roundup > + > +#endif /* __GLIBC__ || __linux__ */ > + > + > +#if defined(__FreeBSD__) > + > +#include <osreldate.h> > +#include <sys/endian.h> > + > +#define ELFTC_BYTE_ORDER _BYTE_ORDER > +#define ELFTC_BYTE_ORDER_LITTLE_ENDIAN _LITTLE_ENDIAN > +#define ELFTC_BYTE_ORDER_BIG_ENDIAN _BIG_ENDIAN > + > +#define ELFTC_HAVE_MMAP 1 > +#define ELFTC_HAVE_STRMODE 1 > +#if __FreeBSD_version <= 900000 > +#define ELFTC_BROKEN_YY_NO_INPUT 1 > +#endif > +#endif /* __FreeBSD__ */ > + > + > +#if defined(__minix) > +#define ELFTC_HAVE_MMAP 0 > +#endif /* __minix */ > + > + > +#if defined(__NetBSD__) > + > +#include <sys/param.h> > +#include <sys/endian.h> > + > +#define ELFTC_BYTE_ORDER _BYTE_ORDER > +#define ELFTC_BYTE_ORDER_LITTLE_ENDIAN _LITTLE_ENDIAN > +#define ELFTC_BYTE_ORDER_BIG_ENDIAN _BIG_ENDIAN > + > +#define ELFTC_HAVE_MMAP 1 > +#define ELFTC_HAVE_STRMODE 1 > +#if __NetBSD_Version__ <= 599002100 > +/* from src/doc/CHANGES: flex(1): Import flex-2.5.35 [christos 20091025] */ > +/* and 5.99.21 was from Wed Oct 21 21:28:36 2009 UTC */ > +# define ELFTC_BROKEN_YY_NO_INPUT 1 > +#endif > +#endif /* __NetBSD __ */ > + > + > +#if defined(__OpenBSD__) > + > +#include <sys/param.h> > +#include <sys/endian.h> > + > +#define ELFTC_BYTE_ORDER _BYTE_ORDER > +#define ELFTC_BYTE_ORDER_LITTLE_ENDIAN _LITTLE_ENDIAN > +#define ELFTC_BYTE_ORDER_BIG_ENDIAN _BIG_ENDIAN > + > +#define ELFTC_HAVE_MMAP 1 > +#define ELFTC_HAVE_STRMODE 1 > + > +#define ELFTC_NEED_BYTEORDER_EXTENSIONS 1 > +#define roundup2 roundup > + > +#endif /* __OpenBSD__ */ > + > +#endif /* _ELFTC_H */ > diff --git a/_libelf.h b/_libelf.h > new file mode 100644 > index 0000000..be45335 > --- /dev/null > +++ b/_libelf.h > @@ -0,0 +1,239 @@ > +/*- > + * Copyright (c) 2006,2008-2011 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. > + * > + * $Id: _libelf.h 3174 2015-03-27 17:13:41Z emaste $ > + */ > + > +#ifndef __LIBELF_H_ > +#define __LIBELF_H_ > + > +#include <sys/queue.h> > + > +#include "_libelf_config.h" > + > +#include "_elftc.h" > + > +/* > + * 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; > + unsigned char libelf_msg[LIBELF_MSG_SIZE]; > +}; > + > +extern struct _libelf_globals _libelf; > + > +#define LIBELF_PRIVATE(N) (_libelf.libelf_##N) > + > +#define LIBELF_ELF_ERROR_MASK 0xFF > +#define LIBELF_OS_ERROR_SHIFT 8 > + > +#define LIBELF_ERROR(E, O) (((E) & LIBELF_ELF_ERROR_MASK) | \ > + ((O) << LIBELF_OS_ERROR_SHIFT)) > + > +#define LIBELF_SET_ERROR(E, O) do { > \ > + LIBELF_PRIVATE(error) = LIBELF_ERROR(ELF_E_##E, (O)); \ > + } while (0) > + > +#define LIBELF_ADJUST_AR_SIZE(S) (((S) + 1U) & ~1U) > + > +/* > + * Flags for library internal use. These use the upper 16 bits of the > + * `e_flags' field. > + */ > +#define LIBELF_F_API_MASK 0x00FFFFU /* Flags defined by the > API. */ > +#define LIBELF_F_AR_HEADER 0x010000U /* translated header > available */ > +#define LIBELF_F_AR_VARIANT_SVR4 0x020000U /* BSD style ar(1) archive > */ > +#define LIBELF_F_DATA_MALLOCED 0x040000U /* whether data was > malloc'ed */ > +#define LIBELF_F_RAWFILE_MALLOC 0x080000U /* whether e_rawfile was > malloc'ed */ > +#define LIBELF_F_RAWFILE_MMAP 0x100000U /* whether e_rawfile was > mmap'ed */ > +#define LIBELF_F_SHDRS_LOADED 0x200000U /* whether all shdrs were > read in */ > +#define LIBELF_F_SPECIAL_FILE 0x400000U /* non-regular file */ > + > +struct _Elf { > + int e_activations; /* activation count */ > + 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 */ > + unsigned char *e_rawfile; /* uninterpreted bytes */ > + size_t e_rawsize; /* size of uninterpreted bytes */ > + unsigned int e_version; /* file version */ > + > + /* > + * Header information for archive members. See the > + * LIBELF_F_AR_HEADER flag. > + */ > + union { > + Elf_Arhdr *e_arhdr; /* translated header */ > + unsigned char *e_rawhdr; /* untranslated header */ > + } e_hdr; > + > + union { > + struct { /* ar(1) archives */ > + off_t e_next; /* set by elf_rand()/elf_next() */ > + int e_nchildren; > + unsigned char *e_rawstrtab; /* file name strings */ > + size_t e_rawstrtabsz; > + unsigned 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; > +}; > + > +/* > + * The internal descriptor wrapping the "Elf_Data" type. > + */ > +struct _Libelf_Data { > + Elf_Data d_data; /* The exported descriptor. */ > + Elf_Scn *d_scn; /* The containing section */ > + unsigned int d_flags; > + STAILQ_ENTRY(_Libelf_Data) d_next; > +}; > + > +struct _Elf_Scn { > + union { > + Elf32_Shdr s_shdr32; > + Elf64_Shdr s_shdr64; > + } s_shdr; > + STAILQ_HEAD(, _Libelf_Data) s_data; /* translated data */ > + STAILQ_HEAD(, _Libelf_Data) s_rawdata; /* raw data */ > + 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 > +}; > + > + > +/* > + * The LIBELF_COPY macros are used to copy fields from a GElf_* > + * structure to their 32-bit counterparts, while checking for out of > + * range values. > + * > + * - LIBELF_COPY_U32 :: copy an unsigned 32 bit field. > + * - LIBELF_COPY_S32 :: copy a signed 32 bit field. > + */ > + > +#define LIBELF_COPY_U32(DST, SRC, NAME) do { \ > + if ((SRC)->NAME > UINT32_MAX) { \ > + LIBELF_SET_ERROR(RANGE, 0); \ > + return (0); \ > + } \ > + (DST)->NAME = (SRC)->NAME & 0xFFFFFFFFU; \ > + } while (0) > + > +#define LIBELF_COPY_S32(DST, SRC, NAME) do { \ > + if ((SRC)->NAME > INT32_MAX || \ > + (SRC)->NAME < INT32_MIN) { \ > + LIBELF_SET_ERROR(RANGE, 0); \ > + return (0); \ > + } \ > + (DST)->NAME = (int32_t) (SRC)->NAME; \ > + } while (0) > + > + > +/* > + * Function Prototypes. > + */ > + > +#ifdef __cplusplus > +extern "C" { > +#endif > +struct _Libelf_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, int _reporterror); > +Elf *_libelf_ar_open_member(int _fd, Elf_Cmd _c, Elf *_ar); > +Elf_Arsym *_libelf_ar_process_bsd_symtab(Elf *_ar, size_t *_dst); > +Elf_Arsym *_libelf_ar_process_svr4_symtab(Elf *_ar, size_t *_dst); > +long _libelf_checksum(Elf *_e, int _elfclass); > +void *_libelf_ehdr(Elf *_e, int _elfclass, int _allocate); > +unsigned int _libelf_falign(Elf_Type _t, int _elfclass); > +size_t _libelf_fsize(Elf_Type _t, int _elfclass, unsigned int _version, > + size_t count); > +int (*_libelf_get_translator(Elf_Type _t, int _direction, int _elfclass)) > + (unsigned char *_dst, size_t dsz, unsigned 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_load_section_headers(Elf *e, void *ehdr); > +unsigned int _libelf_malign(Elf_Type _t, int _elfclass); > +Elf *_libelf_memory(unsigned char *_image, size_t _sz, int _reporterror); > +size_t _libelf_msize(Elf_Type _t, int _elfclass, unsigned int _version); > +void *_libelf_newphdr(Elf *_e, int _elfclass, size_t _count); > +Elf *_libelf_open_object(int _fd, Elf_Cmd _c, int _reporterror); > +struct _Libelf_Data *_libelf_release_data(struct _Libelf_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); > +#ifdef __cplusplus > +} > +#endif > + > +#endif /* __LIBELF_H_ */ > diff --git a/_libelf_ar.h b/_libelf_ar.h > new file mode 100644 > index 0000000..45a7e16 > --- /dev/null > +++ b/_libelf_ar.h > @@ -0,0 +1,57 @@ > +/*- > + * Copyright (c) 2010 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. > + * > + * $Id: _libelf_ar.h 3013 2014-03-23 06:16:59Z jkoshy $ > + */ > + > +#ifndef __LIBELF_AR_H_ > +#define __LIBELF_AR_H_ > + > +/* > + * Prototypes and declarations needed by libelf's ar(1) archive > + * handling code. > + */ > + > +#include <ar.h> > + > +#define LIBELF_AR_BSD_EXTENDED_NAME_PREFIX "#1/" > +#define LIBELF_AR_BSD_SYMTAB_NAME "__.SYMDEF" > +#define LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE \ > + (sizeof(LIBELF_AR_BSD_EXTENDED_NAME_PREFIX) - 1) > + > +#define IS_EXTENDED_BSD_NAME(NAME) \ > + (strncmp((const char *) (NAME), \ > + LIBELF_AR_BSD_EXTENDED_NAME_PREFIX, \ > + LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE) == 0) > + > + > +unsigned char *_libelf_ar_get_string(const char *_buf, size_t _sz, > + unsigned int _rawname, int _svr4names); > +char *_libelf_ar_get_raw_name(const struct ar_hdr *_arh); > +char *_libelf_ar_get_translated_name(const struct ar_hdr *_arh, Elf *_ar); > +int _libelf_ar_get_number(const char *_buf, size_t _sz, > + unsigned int _base, size_t *_ret); > + > +#endif /* __LIBELF_AR_H_ */ > diff --git a/_libelf_config.h b/_libelf_config.h > new file mode 100644 > index 0000000..1b8f35b > --- /dev/null > +++ b/_libelf_config.h > @@ -0,0 +1,183 @@ > +/*- > + * Copyright (c) 2008-2011 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. > + * > + * $Id: _libelf_config.h 3168 2015-02-24 19:17:47Z emaste $ > + */ > + > +#if defined(__APPLE__) || defined(__DragonFly__) > + > +#if defined(__amd64__) > +#define LIBELF_ARCH EM_X86_64 > +#define LIBELF_BYTEORDER ELFDATA2LSB > +#define LIBELF_CLASS ELFCLASS64 > +#elif defined(__i386__) > +#define LIBELF_ARCH EM_386 > +#define LIBELF_BYTEORDER ELFDATA2LSB > +#define LIBELF_CLASS ELFCLASS32 > +#endif > + > +#endif /* __DragonFly__ */ > + > +#ifdef __FreeBSD__ > + > +/* > + * Define LIBELF_{ARCH,BYTEORDER,CLASS} based on the machine architecture. > + * See also: <machine/elf.h>. > + */ > + > +#if defined(__amd64__) > + > +#define LIBELF_ARCH EM_X86_64 > +#define LIBELF_BYTEORDER ELFDATA2LSB > +#define LIBELF_CLASS ELFCLASS64 > + > +#elif defined(__aarch64__) > + > +#define LIBELF_ARCH EM_AARCH64 > +#define LIBELF_BYTEORDER ELFDATA2LSB > +#define LIBELF_CLASS ELFCLASS64 > + > +#elif defined(__arm__) > + > +#define LIBELF_ARCH EM_ARM > +#if defined(__ARMEB__) /* Big-endian ARM. */ > +#define LIBELF_BYTEORDER ELFDATA2MSB > +#else > +#define LIBELF_BYTEORDER ELFDATA2LSB > +#endif > +#define LIBELF_CLASS ELFCLASS32 > + > +#elif defined(__i386__) > + > +#define LIBELF_ARCH EM_386 > +#define LIBELF_BYTEORDER ELFDATA2LSB > +#define LIBELF_CLASS ELFCLASS32 > + > +#elif defined(__ia64__) > + > +#define LIBELF_ARCH EM_IA_64 > +#define LIBELF_BYTEORDER ELFDATA2LSB > +#define LIBELF_CLASS ELFCLASS64 > + > +#elif defined(__mips__) > + > +#define LIBELF_ARCH EM_MIPS > +#if defined(__MIPSEB__) > +#define LIBELF_BYTEORDER ELFDATA2MSB > +#else > +#define LIBELF_BYTEORDER ELFDATA2LSB > +#endif > +#define LIBELF_CLASS ELFCLASS32 > + > +#elif defined(__powerpc__) > + > +#define LIBELF_ARCH EM_PPC > +#define LIBELF_BYTEORDER ELFDATA2MSB > +#define LIBELF_CLASS ELFCLASS32 > + > +#elif defined(__sparc__) > + > +#define LIBELF_ARCH EM_SPARCV9 > +#define LIBELF_BYTEORDER ELFDATA2MSB > +#define LIBELF_CLASS ELFCLASS64 > + > +#else > +#error Unknown FreeBSD architecture. > +#endif > +#endif /* __FreeBSD__ */ > + > +/* > + * Definitions for Minix3. > + */ > +#ifdef __minix > + > +#define LIBELF_ARCH EM_386 > +#define LIBELF_BYTEORDER ELFDATA2LSB > +#define LIBELF_CLASS ELFCLASS32 > + > +#endif /* __minix */ > + > +#ifdef __NetBSD__ > + > +#include <machine/elf_machdep.h> > + > +#if !defined(ARCH_ELFSIZE) > +#error ARCH_ELFSIZE is not defined. > +#endif > + > +#if ARCH_ELFSIZE == 32 > +#define LIBELF_ARCH ELF32_MACHDEP_ID > +#define LIBELF_BYTEORDER ELF32_MACHDEP_ENDIANNESS > +#define LIBELF_CLASS ELFCLASS32 > +#define Elf_Note Elf32_Nhdr > +#else > +#define LIBELF_ARCH ELF64_MACHDEP_ID > +#define LIBELF_BYTEORDER ELF64_MACHDEP_ENDIANNESS > +#define LIBELF_CLASS ELFCLASS64 > +#define Elf_Note Elf64_Nhdr > +#endif > + > +#endif /* __NetBSD__ */ > + > +#if defined(__OpenBSD__) > + > +#include <machine/exec.h> > + > +#define LIBELF_ARCH ELF_TARG_MACH > +#define LIBELF_BYTEORDER ELF_TARG_DATA > +#define LIBELF_CLASS ELF_TARG_CLASS > + > +#endif > + > +/* > + * GNU & Linux compatibility. > + * > + * `__linux__' is defined in an environment runs the Linux kernel and glibc. > + * `__GNU__' is defined in an environment runs a GNU kernel (Hurd) and glibc. > + * `__GLIBC__' is defined for an environment that runs glibc over a non-GNU > + * kernel such as GNU/kFreeBSD. > + */ > + > +#if defined(__linux__) || defined(__GNU__) || defined(__GLIBC__) > + > +#if defined(__linux__) > + > +#include "native-elf-format.h" > + > +#define LIBELF_CLASS ELFTC_CLASS > +#define LIBELF_ARCH ELFTC_ARCH > +#define LIBELF_BYTEORDER ELFTC_BYTEORDER > + > +#endif /* defined(__linux__) */ > + > +#if LIBELF_CLASS == ELFCLASS32 > +#define Elf_Note Elf32_Nhdr > +#elif LIBELF_CLASS == ELFCLASS64 > +#define Elf_Note Elf64_Nhdr > +#else > +#error LIBELF_CLASS needs to be one of ELFCLASS32 or ELFCLASS64 > +#endif > + > +#endif /* defined(__linux__) || defined(__GNU__) || defined(__GLIBC__) */ > diff --git a/elf.c b/elf.c > new file mode 100644 > index 0000000..8f1925e > --- /dev/null > +++ b/elf.c > @@ -0,0 +1,40 @@ > +/*- > + * Copyright (c) 2006,2008,2011 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" > + > +ELFTC_VCSID("$Id: elf.c 2225 2011-11-26 18:55:54Z jkoshy $"); > + > +struct _libelf_globals _libelf = { > + .libelf_arch = LIBELF_ARCH, > + .libelf_byteorder = LIBELF_BYTEORDER, > + .libelf_class = LIBELF_CLASS, > + .libelf_error = 0, > + .libelf_fillchar = 0, > + .libelf_version = EV_NONE > +}; > diff --git a/elf_begin.c b/elf_begin.c > new file mode 100644 > index 0000000..9f4f237 > --- /dev/null > +++ b/elf_begin.c > @@ -0,0 +1,91 @@ > +/*- > + * Copyright (c) 2006,2008-2011 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" > + > +ELFTC_VCSID("$Id: elf_begin.c 2364 2011-12-28 17:55:25Z jkoshy $"); > + > +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: > + /* > + * The ELF_C_WRITE command is required to ignore the > + * descriptor passed in. > + */ > + a = NULL; > + break; > + > + 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 descriptor `a' was opened > + * using a valid file descriptor, we need to check if > + * the passed in `fd' value matches the original one. > + */ > + if (a && > + ((a->e_fd != -1 && 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, 1); > + else if (a->e_kind == ELF_K_AR) > + e = _libelf_ar_open_member(a->e_fd, c, a); > + else > + (e = a)->e_activations++; > + > + return (e); > +} > diff --git a/elf_cntl.c b/elf_cntl.c > new file mode 100644 > index 0000000..0607885 > --- /dev/null > +++ b/elf_cntl.c > @@ -0,0 +1,58 @@ > +/*- > + * Copyright (c) 2006,2008 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" > + > +ELFTC_VCSID("$Id: elf_cntl.c 2225 2011-11-26 18:55:54Z jkoshy $"); > + > +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/elf_data.c b/elf_data.c > new file mode 100644 > index 0000000..3d8ef6c > --- /dev/null > +++ b/elf_data.c > @@ -0,0 +1,276 @@ > +/*- > + * Copyright (c) 2006,2008,2011 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 <stdint.h> > +#include <stdlib.h> > + > +#include "_libelf.h" > + > +ELFTC_VCSID("$Id: elf_data.c 3258 2015-11-20 18:59:43Z emaste $"); > + > +Elf_Data * > +elf_getdata(Elf_Scn *s, Elf_Data *ed) > +{ > + Elf *e; > + unsigned int sh_type; > + int elfclass, elftype; > + size_t count, fsz, msz; > + struct _Libelf_Data *d; > + uint64_t sh_align, sh_offset, sh_size; > + int (*xlate)(unsigned char *_d, size_t _dsz, unsigned char *_s, > + size_t _c, int _swap); > + > + d = (struct _Libelf_Data *) ed; > + > + if (s == NULL || (e = s->s_elf) == NULL || > + (d != NULL && s != d->d_scn)) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (NULL); > + } > + > + assert(e->e_kind == ELF_K_ELF); > + > + if (d == NULL && (d = STAILQ_FIRST(&s->s_data)) != NULL) > + return (&d->d_data); > + > + if (d != NULL) > + return (&STAILQ_NEXT(d, d_next)->d_data); > + > + if (e->e_rawfile == NULL) { > + /* > + * In the ELF_C_WRITE case, there is no source that > + * can provide data for the section. > + */ > + LIBELF_SET_ERROR(ARGUMENT, 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 (sh_type == SHT_NULL) { > + LIBELF_SET_ERROR(SECTION, 0); > + return (NULL); > + } > + > + if ((elftype = _libelf_xlate_shtype(sh_type)) < ELF_T_FIRST || > + elftype > ELF_T_LAST || (sh_type != SHT_NOBITS && > + 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); > + } > + > + if (sh_size / fsz > SIZE_MAX) { > + LIBELF_SET_ERROR(RANGE, 0); > + return (NULL); > + } > + > + count = (size_t) (sh_size / fsz); > + > + msz = _libelf_msize(elftype, elfclass, e->e_version); > + > + if (count > 0 && msz > SIZE_MAX / count) { > + LIBELF_SET_ERROR(RANGE, 0); > + return (NULL); > + } > + > + assert(msz > 0); > + assert(count <= SIZE_MAX); > + assert(msz * count <= SIZE_MAX); > + > + if ((d = _libelf_allocate_data(s)) == NULL) > + return (NULL); > + > + d->d_data.d_buf = NULL; > + d->d_data.d_off = 0; > + d->d_data.d_align = sh_align; > + d->d_data.d_size = msz * count; > + d->d_data.d_type = elftype; > + d->d_data.d_version = e->e_version; > + > + if (sh_type == SHT_NOBITS || sh_size == 0) { > + STAILQ_INSERT_TAIL(&s->s_data, d, d_next); > + return (&d->d_data); > + } > + > + if ((d->d_data.d_buf = malloc(msz * count)) == NULL) { > + (void) _libelf_release_data(d); > + LIBELF_SET_ERROR(RESOURCE, 0); > + return (NULL); > + } > + > + d->d_flags |= LIBELF_F_DATA_MALLOCED; > + > + xlate = _libelf_get_translator(elftype, ELF_TOMEMORY, elfclass); > + if (!(*xlate)(d->d_data.d_buf, (size_t) d->d_data.d_size, > + e->e_rawfile + sh_offset, count, > + e->e_byteorder != LIBELF_PRIVATE(byteorder))) { > + _libelf_release_data(d); > + LIBELF_SET_ERROR(DATA, 0); > + return (NULL); > + } > + > + STAILQ_INSERT_TAIL(&s->s_data, d, d_next); > + > + return (&d->d_data); > +} > + > +Elf_Data * > +elf_newdata(Elf_Scn *s) > +{ > + Elf *e; > + struct _Libelf_Data *d; > + > + if (s == NULL || (e = s->s_elf) == NULL) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (NULL); > + } > + > + assert(e->e_kind == ELF_K_ELF); > + > + /* > + * 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 = _libelf_allocate_data(s)) == NULL) > + return (NULL); > + > + STAILQ_INSERT_TAIL(&s->s_data, d, d_next); > + > + d->d_data.d_align = 1; > + d->d_data.d_buf = NULL; > + d->d_data.d_off = (uint64_t) ~0; > + d->d_data.d_size = 0; > + d->d_data.d_type = ELF_T_BYTE; > + d->d_data.d_version = LIBELF_PRIVATE(version); > + > + (void) elf_flagscn(s, ELF_C_SET, ELF_F_DIRTY); > + > + return (&d->d_data); > +} > + > +/* > + * Retrieve a data descriptor for raw (untranslated) data for section > + * `s'. > + */ > + > +Elf_Data * > +elf_rawdata(Elf_Scn *s, Elf_Data *ed) > +{ > + Elf *e; > + int elf_class; > + uint32_t sh_type; > + struct _Libelf_Data *d; > + uint64_t sh_align, sh_offset, sh_size; > + > + if (s == NULL || (e = s->s_elf) == NULL || e->e_rawfile == NULL) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (NULL); > + } > + > + assert(e->e_kind == ELF_K_ELF); > + > + d = (struct _Libelf_Data *) ed; > + > + if (d == NULL && (d = STAILQ_FIRST(&s->s_rawdata)) != NULL) > + return (&d->d_data); > + > + if (d != NULL) > + return (&STAILQ_NEXT(d, d_next)->d_data); > + > + elf_class = e->e_class; > + > + assert(elf_class == ELFCLASS32 || elf_class == ELFCLASS64); > + > + if (elf_class == 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 (sh_type == SHT_NULL) { > + LIBELF_SET_ERROR(SECTION, 0); > + return (NULL); > + } > + > + if (sh_type != SHT_NOBITS && > + sh_offset + sh_size > (uint64_t) e->e_rawsize) { > + LIBELF_SET_ERROR(SECTION, 0); > + return (NULL); > + } > + > + if ((d = _libelf_allocate_data(s)) == NULL) > + return (NULL); > + > + d->d_data.d_buf = (sh_type == SHT_NOBITS || sh_size == 0) ? NULL : > + e->e_rawfile + sh_offset; > + d->d_data.d_off = 0; > + d->d_data.d_align = sh_align; > + d->d_data.d_size = sh_size; > + d->d_data.d_type = ELF_T_BYTE; > + d->d_data.d_version = e->e_version; > + > + STAILQ_INSERT_TAIL(&s->s_rawdata, d, d_next); > + > + return (&d->d_data); > +} > diff --git a/elf_end.c b/elf_end.c > new file mode 100644 > index 0000000..3f32ebb > --- /dev/null > +++ b/elf_end.c > @@ -0,0 +1,95 @@ > +/*- > + * Copyright (c) 2006,2008-2009,2011 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 <stdlib.h> > + > +#include "_libelf.h" > + > +#if ELFTC_HAVE_MMAP > +#include <sys/mman.h> > +#endif > + > +ELFTC_VCSID("$Id: elf_end.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +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_rawfile) { > + if (e->e_flags & LIBELF_F_RAWFILE_MALLOC) > + free(e->e_rawfile); > +#if ELFTC_HAVE_MMAP > + else if (e->e_flags & LIBELF_F_RAWFILE_MMAP) > + (void) munmap(e->e_rawfile, e->e_rawsize); > +#endif > + } > + > + 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/elf_errmsg.c b/elf_errmsg.c > new file mode 100644 > index 0000000..9e5b2e9 > --- /dev/null > +++ b/elf_errmsg.c > @@ -0,0 +1,83 @@ > +/*- > + * Copyright (c) 2006,2008,2011 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 <stdio.h> > +#include <string.h> > + > +#include "_libelf.h" > + > +ELFTC_VCSID("$Id: elf_errmsg.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +/* > + * Retrieve a human readable translation for an error message. > + */ > + > +static 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 == ELF_E_NONE && > + (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 < ELF_E_NONE || error >= ELF_E_NUM) > + return _libelf_errors[ELF_E_NUM]; > + if (oserr) { > + (void) snprintf((char *) LIBELF_PRIVATE(msg), > + sizeof(LIBELF_PRIVATE(msg)), "%s: %s", > + _libelf_errors[error], strerror(oserr)); > + return (const char *)&LIBELF_PRIVATE(msg); > + } > + return _libelf_errors[error]; > +} > diff --git a/elf_errno.c b/elf_errno.c > new file mode 100644 > index 0000000..10ae69a > --- /dev/null > +++ b/elf_errno.c > @@ -0,0 +1,41 @@ > +/*- > + * Copyright (c) 2006,2008,2011 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" > + > +ELFTC_VCSID("$Id: elf_errno.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +int > +elf_errno(void) > +{ > + int old; > + > + old = LIBELF_PRIVATE(error); > + LIBELF_PRIVATE(error) = 0; > + return (old & LIBELF_ELF_ERROR_MASK); > +} > diff --git a/elf_fill.c b/elf_fill.c > new file mode 100644 > index 0000000..427d78d > --- /dev/null > +++ b/elf_fill.c > @@ -0,0 +1,37 @@ > +/*- > + * Copyright (c) 2006,2008 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" > + > +ELFTC_VCSID("$Id: elf_fill.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +void > +elf_fill(int fill) > +{ > + LIBELF_PRIVATE(fillchar) = fill; > +} > diff --git a/elf_flag.c b/elf_flag.c > new file mode 100644 > index 0000000..7350321 > --- /dev/null > +++ b/elf_flag.c > @@ -0,0 +1,196 @@ > +/*- > + * Copyright (c) 2006,2008-2009,2011 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" > + > +ELFTC_VCSID("$Id: elf_flag.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +unsigned int > +elf_flagarhdr(Elf_Arhdr *a, Elf_Cmd c, unsigned int flags) > +{ > + unsigned int r; > + > + if (a == 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 = a->ar_flags |= flags; > + else > + r = a->ar_flags &= ~flags; > + > + return (r & LIBELF_F_API_MASK); > +} > + > +unsigned int > +elf_flagdata(Elf_Data *d, Elf_Cmd c, unsigned int flags) > +{ > + unsigned int r; > + struct _Libelf_Data *ld; > + > + if (d == NULL) > + return (0); > + > + if ((c != ELF_C_SET && c != ELF_C_CLR) || > + (flags & ~ELF_F_DIRTY) != 0) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (0); > + } > + > + ld = (struct _Libelf_Data *) d; > + > + if (c == ELF_C_SET) > + r = ld->d_flags |= flags; > + else > + r = ld->d_flags &= ~flags; > + > + return (r & LIBELF_F_API_MASK); > +} > + > +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) > +{ > + unsigned 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_ARCHIVE | ELF_F_ARCHIVE_SYSV | > + ELF_F_DIRTY | ELF_F_LAYOUT)) != 0) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (0); > + } > + > + if ((flags & ELF_F_ARCHIVE_SYSV) && (flags & ELF_F_ARCHIVE) == 0) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (0); > + } > + > + if ((flags & ELF_F_ARCHIVE) && e->e_cmd != ELF_C_WRITE) { > + LIBELF_SET_ERROR(MODE, 0); > + return (0); > + } > + > + if (c == ELF_C_SET) > + r = e->e_flags |= flags; > + else > + r = e->e_flags &= ~flags; > + return (r & LIBELF_F_API_MASK); > +} > + > +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) > +{ > + unsigned 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 & LIBELF_F_API_MASK); > +} > + > +unsigned int > +elf_flagshdr(Elf_Scn *s, Elf_Cmd c, unsigned int flags) > +{ > + return (elf_flagscn(s, c, flags)); > +} > diff --git a/elf_getarhdr.c b/elf_getarhdr.c > new file mode 100644 > index 0000000..75e2e86 > --- /dev/null > +++ b/elf_getarhdr.c > @@ -0,0 +1,45 @@ > +/*- > + * Copyright (c) 2006,2008,2010 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" > + > +ELFTC_VCSID("$Id: elf_getarhdr.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +Elf_Arhdr * > +elf_getarhdr(Elf *e) > +{ > + if (e == NULL) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (NULL); > + } > + > + if (e->e_flags & LIBELF_F_AR_HEADER) > + return (e->e_hdr.e_arhdr); > + > + return (_libelf_ar_gethdr(e)); > +} > diff --git a/elf_getarsym.c b/elf_getarsym.c > new file mode 100644 > index 0000000..3679b81 > --- /dev/null > +++ b/elf_getarsym.c > @@ -0,0 +1,56 @@ > +/*- > + * Copyright (c) 2006,2008 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" > + > +ELFTC_VCSID("$Id: elf_getarsym.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +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 = (ar->e_flags & LIBELF_F_AR_VARIANT_SVR4) ? > + _libelf_ar_process_svr4_symtab(ar, &n) : > + _libelf_ar_process_bsd_symtab(ar, &n); > + else > + LIBELF_SET_ERROR(ARCHIVE, 0); > + > + if (ptr) > + *ptr = n; > + return (symtab); > +} > diff --git a/elf_getbase.c b/elf_getbase.c > new file mode 100644 > index 0000000..b038c3d > --- /dev/null > +++ b/elf_getbase.c > @@ -0,0 +1,46 @@ > +/*- > + * Copyright (c) 2006,2008 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" > + > +ELFTC_VCSID("$Id: elf_getbase.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +off_t > +elf_getbase(Elf *e) > +{ > + if (e == NULL) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return ((off_t) -1); > + } > + > + if (e->e_parent == NULL) > + return ((off_t) 0); > + > + return ((off_t) ((uintptr_t) e->e_rawfile - > + (uintptr_t) e->e_parent->e_rawfile)); > +} > diff --git a/elf_getident.c b/elf_getident.c > new file mode 100644 > index 0000000..a69139c > --- /dev/null > +++ b/elf_getident.c > @@ -0,0 +1,66 @@ > +/*- > + * Copyright (c) 2006,2008 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" > + > +ELFTC_VCSID("$Id: elf_getident.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +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 ((char *) e->e_rawfile); > + > + error: > + if (sz) > + *sz = 0; > + return (NULL); > +} > diff --git a/elf_hash.c b/elf_hash.c > new file mode 100644 > index 0000000..ef7e44d > --- /dev/null > +++ b/elf_hash.c > @@ -0,0 +1,54 @@ > +/*- > + * Copyright (c) 2006,2008 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" > + > +ELFTC_VCSID("$Id: elf_hash.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +/* > + * This elf_hash function is defined by the System V ABI. > + */ > + > +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/elf_kind.c b/elf_kind.c > new file mode 100644 > index 0000000..f497bd3 > --- /dev/null > +++ b/elf_kind.c > @@ -0,0 +1,42 @@ > +/*- > + * Copyright (c) 2006,2008 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" > + > +ELFTC_VCSID("$Id: elf_kind.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +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/elf_memory.c b/elf_memory.c > new file mode 100644 > index 0000000..d70f6e0 > --- /dev/null > +++ b/elf_memory.c > @@ -0,0 +1,47 @@ > +/*- > + * Copyright (c) 2006,2008 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" > + > +ELFTC_VCSID("$Id: elf_memory.c 3013 2014-03-23 06:16:59Z jkoshy $"); > + > +Elf * > +elf_memory(char *image, size_t sz) > +{ > + 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); > + } > + > + return (_libelf_memory((unsigned char *) image, sz, 1)); > +} > diff --git a/elf_next.c b/elf_next.c > new file mode 100644 > index 0000000..4c33714 > --- /dev/null > +++ b/elf_next.c > @@ -0,0 +1,64 @@ > +/*- > + * Copyright (c) 2006,2008 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" > + > +ELFTC_VCSID("$Id: elf_next.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +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(e->e_rawfile > parent->e_rawfile); > + > + next = e->e_rawfile - parent->e_rawfile + (off_t) e->e_rawsize; > + next = (next + 1) & ~1; /* round up to an even boundary */ > + > + /* > + * Setup the 'e_next' field of the archive descriptor for the > + * next call to 'elf_begin()'. > + */ > + parent->e_u.e_ar.e_next = (next >= (off_t) parent->e_rawsize) ? > + (off_t) 0 : next; > + > + return (ELF_C_READ); > +} > diff --git a/elf_open.c b/elf_open.c > new file mode 100644 > index 0000000..5aad459 > --- /dev/null > +++ b/elf_open.c > @@ -0,0 +1,67 @@ > +/*- > + * Copyright (c) 2011 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" > + > +ELFTC_VCSID("$Id$"); > + > +/* > + * Extension API: open a file for reading, ignoring parse errors. > + */ > + > +Elf * > +elf_open(int fd) > +{ > + if (LIBELF_PRIVATE(version) == EV_NONE) { > + LIBELF_SET_ERROR(SEQUENCE, 0); > + return (NULL); > + } > + > + return (_libelf_open_object(fd, ELF_C_READ, 0)); > +} > + > +/* > + * Extension API: create an ELF descriptor for an in-memory object, > + * ignoring parse errors. > + */ > + > +Elf * > +elf_openmemory(char *image, size_t sz) > +{ > + 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); > + } > + > + return (_libelf_memory((unsigned char *) image, sz, 0)); > +} > diff --git a/elf_phnum.c b/elf_phnum.c > new file mode 100644 > index 0000000..4ac665d > --- /dev/null > +++ b/elf_phnum.c > @@ -0,0 +1,65 @@ > +/*- > + * Copyright (c) 2006,2008 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" > + > +ELFTC_VCSID("$Id: elf_phnum.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +static int > +_libelf_getphdrnum(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 (-1); > + } > + > + if ((eh = _libelf_ehdr(e, ec, 0)) == NULL) > + return (-1); > + > + *phnum = e->e_u.e_elf.e_nphdr; > + > + return (0); > +} > + > +int > +elf_getphdrnum(Elf *e, size_t *phnum) > +{ > + return (_libelf_getphdrnum(e, phnum)); > +} > + > +/* Deprecated API */ > +int > +elf_getphnum(Elf *e, size_t *phnum) > +{ > + return (_libelf_getphdrnum(e, phnum) >= 0); > +} > diff --git a/elf_rand.c b/elf_rand.c > new file mode 100644 > index 0000000..eb2c9ea > --- /dev/null > +++ b/elf_rand.c > @@ -0,0 +1,57 @@ > +/*- > + * Copyright (c) 2006,2008 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" > + > +ELFTC_VCSID("$Id: elf_rand.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +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 || > + (size_t) 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/elf_rawfile.c b/elf_rawfile.c > new file mode 100644 > index 0000000..f63982f > --- /dev/null > +++ b/elf_rawfile.c > @@ -0,0 +1,51 @@ > +/*- > + * Copyright (c) 2006,2008 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" > + > +ELFTC_VCSID("$Id: elf_rawfile.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +char * > +elf_rawfile(Elf *e, size_t *sz) > +{ > + size_t size; > + unsigned char *ptr; > + > + 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 ((char *) ptr); > +} > diff --git a/elf_scn.c b/elf_scn.c > new file mode 100644 > index 0000000..d3e2747 > --- /dev/null > +++ b/elf_scn.c > @@ -0,0 +1,235 @@ > +/*- > + * Copyright (c) 2006,2008-2010 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/queue.h> > + > +#include <assert.h> > +#include <errno.h> > +#include <gelf.h> > +#include <libelf.h> > +#include <stddef.h> > +#include <stdint.h> > +#include <stdlib.h> > + > +#include "_libelf.h" > + > +ELFTC_VCSID("$Id: elf_scn.c 3177 2015-03-30 18:19:41Z emaste $"); > + > +/* > + * Load an ELF section table and create a list of Elf_Scn structures. > + */ > +int > +_libelf_load_section_headers(Elf *e, void *ehdr) > +{ > + Elf_Scn *scn; > + uint64_t shoff; > + Elf32_Ehdr *eh32; > + Elf64_Ehdr *eh64; > + int ec, swapbytes; > + unsigned char *src; > + size_t fsz, i, shnum; > + int (*xlator)(unsigned char *_d, size_t _dsz, unsigned 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 (shoff > e->e_rawsize || \ > + fsz != (EH)->e_shentsize || \ > + shnum > SIZE_MAX / fsz || \ > + fsz * shnum > e->e_rawsize - shoff) { \ > + 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)((unsigned char *) &scn->s_shdr, sizeof(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_section_headers(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_section_headers(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/elf_shnum.c b/elf_shnum.c > new file mode 100644 > index 0000000..5c0560f > --- /dev/null > +++ b/elf_shnum.c > @@ -0,0 +1,65 @@ > +/*- > + * Copyright (c) 2006,2008 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" > + > +ELFTC_VCSID("$Id: elf_shnum.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +static int > +_libelf_getshdrnum(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 (-1); > + } > + > + if ((eh = _libelf_ehdr(e, ec, 0)) == NULL) > + return (-1); > + > + *shnum = e->e_u.e_elf.e_nscn; > + > + return (0); > +} > + > +int > +elf_getshdrnum(Elf *e, size_t *shnum) > +{ > + return (_libelf_getshdrnum(e, shnum)); > +} > + > +/* Deprecated API. */ > +int > +elf_getshnum(Elf *e, size_t *shnum) > +{ > + return (_libelf_getshdrnum(e, shnum) >= 0); > +} > diff --git a/elf_shstrndx.c b/elf_shstrndx.c > new file mode 100644 > index 0000000..dac40c9 > --- /dev/null > +++ b/elf_shstrndx.c > @@ -0,0 +1,80 @@ > +/*- > + * Copyright (c) 2006,2008 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" > + > +ELFTC_VCSID("$Id: elf_shstrndx.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +static int > +_libelf_getshdrstrndx(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 (-1); > + } > + > + if ((eh = _libelf_ehdr(e, ec, 0)) == NULL) > + return (-1); > + > + *strndx = e->e_u.e_elf.e_strndx; > + > + return (0); > +} > + > +int > +elf_getshdrstrndx(Elf *e, size_t *strndx) > +{ > + return (_libelf_getshdrstrndx(e, strndx)); > +} > + > +int > +elf_getshstrndx(Elf *e, size_t *strndx) /* Deprecated API. */ > +{ > + return (_libelf_getshdrstrndx(e, strndx) >= 0); > +} > + > +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/elf_strptr.c b/elf_strptr.c > new file mode 100644 > index 0000000..e2a6b28 > --- /dev/null > +++ b/elf_strptr.c > @@ -0,0 +1,132 @@ > +/*- > + * Copyright (c) 2006,2008 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 <assert.h> > +#include <gelf.h> > + > +#include "_libelf.h" > + > +ELFTC_VCSID("$Id: elf_strptr.c 2990 2014-03-17 09:56:58Z jkoshy $"); > + > +/* > + * 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; > + GElf_Shdr shdr; > + uint64_t alignment, count; > + > + 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 = (uint64_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 = roundup2(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/elf_types.m4 b/elf_types.m4 > new file mode 100644 > index 0000000..9e9680d > --- /dev/null > +++ b/elf_types.m4 > @@ -0,0 +1,309 @@ > +/*- > + * Copyright (c) 2006,2008 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. > + * > + * $Id: elf_types.m4 321 2009-03-07 16:59:14Z jkoshy $ > + */ > + > +/* > + * ELF types, defined in the "enum Elf_Type" API. > + * > + * The members of the list form a 2-tuple: (name, C-type-suffix). > + * + `name' is an Elf_Type symbol without the `ELF_T_' prefix. > + * + `C-type-suffix' is the suffix for Elf32_ and Elf64_ type names. > + */ > + > +define(`ELF_TYPE_LIST', > + ``ADDR, Addr', > + `BYTE, Byte', > + `CAP, Cap', > + `DYN, Dyn', > + `EHDR, Ehdr', > + `GNUHASH, -', > + `HALF, Half', > + `LWORD, Lword', > + `MOVE, Move', > + `MOVEP, MoveP', > + `NOTE, Note', > + `OFF, Off', > + `PHDR, Phdr', > + `REL, Rel', > + `RELA, Rela', > + `SHDR, Shdr', > + `SWORD, Sword', > + `SXWORD, Sxword', > + `SYMINFO, Syminfo', > + `SYM, Sym', > + `VDEF, Verdef', > + `VNEED, Verneed', > + `WORD, Word', > + `XWORD, Xword', > + `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/elf_update.c b/elf_update.c > new file mode 100644 > index 0000000..6cc109d > --- /dev/null > +++ b/elf_update.c > @@ -0,0 +1,1215 @@ > +/*- > + * Copyright (c) 2006-2011 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 <sys/stat.h> > + > +#include <assert.h> > +#include <errno.h> > +#include <gelf.h> > +#include <libelf.h> > +#include <stdlib.h> > +#include <string.h> > +#include <unistd.h> > + > +#include "_libelf.h" > + > +#if ELFTC_HAVE_MMAP > +#include <sys/mman.h> > +#endif > + > +ELFTC_VCSID("$Id: elf_update.c 3190 2015-05-04 15:23:08Z jkoshy $"); > + > +/* > + * Layout strategy: > + * > + * - Case 1: ELF_F_LAYOUT is asserted > + * In this case the application has full control over where the > + * section header table, program header table, and section data > + * will reside. The library only perform error checks. > + * > + * - Case 2: ELF_F_LAYOUT is not asserted > + * > + * The library will do the object layout using the following > + * ordering: > + * - The executable header is placed first, are required by the > + * ELF specification. > + * - The program header table is placed immediately following the > + * executable header. > + * - Section data, if any, is placed after the program header > + * table, aligned appropriately. > + * - The section header table, if needed, is placed last. > + * > + * There are two sub-cases to be taken care of: > + * > + * - Case 2a: e->e_cmd == ELF_C_READ or ELF_C_RDWR > + * > + * In this sub-case, the underlying ELF object may already have > + * content in it, which the application may have modified. The > + * library will retrieve content from the existing object as > + * needed. > + * > + * - Case 2b: e->e_cmd == ELF_C_WRITE > + * > + * The ELF object is being created afresh in this sub-case; > + * there is no pre-existing content in the underlying ELF > + * object. > + */ > + > +/* > + * The types of extents in an ELF object. > + */ > +enum elf_extent { > + ELF_EXTENT_EHDR, > + ELF_EXTENT_PHDR, > + ELF_EXTENT_SECTION, > + ELF_EXTENT_SHDR > +}; > + > +/* > + * A extent descriptor, used when laying out an ELF object. > + */ > +struct _Elf_Extent { > + SLIST_ENTRY(_Elf_Extent) ex_next; > + uint64_t ex_start; /* Start of the region. */ > + uint64_t ex_size; /* The size of the region. */ > + enum elf_extent ex_type; /* Type of region. */ > + void *ex_desc; /* Associated descriptor. */ > +}; > + > +SLIST_HEAD(_Elf_Extent_List, _Elf_Extent); > + > +/* > + * Compute the extents of a section, by looking at the data > + * descriptors associated with it. The function returns 1 > + * if successful, or zero if an error was detected. > + */ > +static int > +_libelf_compute_section_extents(Elf *e, Elf_Scn *s, off_t rc) > +{ > + Elf_Data *d; > + size_t fsz, msz; > + int ec, elftype; > + uint32_t sh_type; > + uint64_t d_align; > + Elf32_Shdr *shdr32; > + Elf64_Shdr *shdr64; > + struct _Libelf_Data *ld; > + uint64_t scn_size, scn_alignment; > + uint64_t sh_align, sh_entsize, sh_offset, sh_size; > + > + ec = e->e_class; > + > + shdr32 = &s->s_shdr.s_shdr32; > + shdr64 = &s->s_shdr.s_shdr64; > + if (ec == ELFCLASS32) { > + sh_type = shdr32->sh_type; > + sh_align = (uint64_t) shdr32->sh_addralign; > + sh_entsize = (uint64_t) shdr32->sh_entsize; > + sh_offset = (uint64_t) shdr32->sh_offset; > + sh_size = (uint64_t) shdr32->sh_size; > + } else { > + sh_type = shdr64->sh_type; > + sh_align = shdr64->sh_addralign; > + sh_entsize = shdr64->sh_entsize; > + sh_offset = shdr64->sh_offset; > + sh_size = shdr64->sh_size; > + } > + > + assert(sh_type != SHT_NULL && sh_type != SHT_NOBITS); > + > + elftype = _libelf_xlate_shtype(sh_type); > + if (elftype > ELF_T_LAST) { > + LIBELF_SET_ERROR(SECTION, 0); > + return (0); > + } > + > + if (sh_align == 0) > + sh_align = _libelf_falign(elftype, ec); > + > + /* > + * Compute the section's size and alignment using the data > + * descriptors associated with the section. > + */ > + if (STAILQ_EMPTY(&s->s_data)) { > + /* > + * The section's content (if any) has not been read in > + * yet. If section is not dirty marked dirty, we can > + * reuse the values in the 'sh_size' and 'sh_offset' > + * fields of the section header. > + */ > + if ((s->s_flags & ELF_F_DIRTY) == 0) { > + /* > + * If the library is doing the layout, then we > + * compute the new start offset for the > + * section based on the current offset and the > + * section's alignment needs. > + * > + * If the application is doing the layout, we > + * can use the value in the 'sh_offset' field > + * in the section header directly. > + */ > + if (e->e_flags & ELF_F_LAYOUT) > + goto updatedescriptor; > + else > + goto computeoffset; > + } > + > + /* > + * Otherwise, we need to bring in the section's data > + * from the underlying ELF object. > + */ > + if (e->e_cmd != ELF_C_WRITE && elf_getdata(s, NULL) == NULL) > + return (0); > + } > + > + /* > + * Loop through the section's data descriptors. > + */ > + scn_size = 0L; > + scn_alignment = 0; > + STAILQ_FOREACH(ld, &s->s_data, d_next) { > + > + d = &ld->d_data; > + > + /* > + * The data buffer's type is known. > + */ > + if (d->d_type >= ELF_T_NUM) { > + LIBELF_SET_ERROR(DATA, 0); > + return (0); > + } > + > + /* > + * The data buffer's version is supported. > + */ > + if (d->d_version != e->e_version) { > + LIBELF_SET_ERROR(VERSION, 0); > + return (0); > + } > + > + /* > + * The buffer's alignment is non-zero and a power of > + * two. > + */ > + if ((d_align = d->d_align) == 0 || > + (d_align & (d_align - 1))) { > + LIBELF_SET_ERROR(DATA, 0); > + return (0); > + } > + > + /* > + * The buffer's size should be a multiple of the > + * memory size of the underlying type. > + */ > + msz = _libelf_msize(d->d_type, ec, e->e_version); > + if (d->d_size % msz) { > + LIBELF_SET_ERROR(DATA, 0); > + return (0); > + } > + > + /* > + * If the application is controlling layout, then the > + * d_offset field should be compatible with the > + * buffer's specified alignment. > + */ > + if ((e->e_flags & ELF_F_LAYOUT) && > + (d->d_off & (d_align - 1))) { > + LIBELF_SET_ERROR(LAYOUT, 0); > + return (0); > + } > + > + /* > + * Compute the section's size. > + */ > + 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 = roundup2(scn_size, d->d_align); > + d->d_off = scn_size; > + fsz = _libelf_fsize(d->d_type, ec, d->d_version, > + (size_t) d->d_size / msz); > + scn_size += fsz; > + } > + > + /* > + * The section's alignment is the maximum alignment > + * needed for its data buffers. > + */ > + if (d_align > scn_alignment) > + scn_alignment = d_align; > + } > + > + > + /* > + * If the application is requesting full control over the > + * layout of the section, check the section's specified size, > + * offsets and alignment for sanity. > + */ > + if (e->e_flags & ELF_F_LAYOUT) { > + if (scn_alignment > sh_align || > + sh_offset % sh_align || > + sh_size < scn_size || > + sh_offset % _libelf_falign(elftype, ec)) { > + LIBELF_SET_ERROR(LAYOUT, 0); > + return (0); > + } > + goto updatedescriptor; > + } > + > + /* > + * Otherwise, compute the values in the section header. > + * > + * The section alignment is the maximum alignment for any of > + * its contained data descriptors. > + */ > + 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; > + > +computeoffset: > + /* > + * Compute the new offset for the section based on > + * the section's alignment needs. > + */ > + sh_offset = roundup((uint64_t) rc, sh_align); > + > + /* > + * Update the section header. > + */ > + if (ec == ELFCLASS32) { > + shdr32->sh_addralign = (uint32_t) sh_align; > + shdr32->sh_entsize = (uint32_t) sh_entsize; > + shdr32->sh_offset = (uint32_t) sh_offset; > + shdr32->sh_size = (uint32_t) sh_size; > + } else { > + shdr64->sh_addralign = sh_align; > + shdr64->sh_entsize = sh_entsize; > + shdr64->sh_offset = sh_offset; > + shdr64->sh_size = sh_size; > + } > + > +updatedescriptor: > + /* > + * Update the section descriptor. > + */ > + s->s_size = sh_size; > + s->s_offset = sh_offset; > + > + return (1); > +} > + > +/* > + * Free a list of extent descriptors. > + */ > + > +static void > +_libelf_release_extents(struct _Elf_Extent_List *extents) > +{ > + struct _Elf_Extent *ex; > + > + while ((ex = SLIST_FIRST(extents)) != NULL) { > + SLIST_REMOVE_HEAD(extents, ex_next); > + free(ex); > + } > +} > + > +/* > + * Check if an extent 's' defined by [start..start+size) is free. > + * This routine assumes that the given extent list is sorted in order > + * of ascending extent offsets. > + */ > + > +static int > +_libelf_extent_is_unused(struct _Elf_Extent_List *extents, > + const uint64_t start, const uint64_t size, struct _Elf_Extent **prevt) > +{ > + uint64_t tmax, tmin; > + struct _Elf_Extent *t, *pt; > + const uint64_t smax = start + size; > + > + /* First, look for overlaps with existing extents. */ > + pt = NULL; > + SLIST_FOREACH(t, extents, ex_next) { > + tmin = t->ex_start; > + tmax = tmin + t->ex_size; > + > + if (tmax <= start) { > + /* > + * 't' lies entirely before 's': ...| t |...| s |... > + */ > + pt = t; > + continue; > + } else if (smax <= tmin) { > + /* > + * 's' lies entirely before 't', and after 'pt': > + * ...| pt |...| s |...| t |... > + */ > + assert(pt == NULL || > + pt->ex_start + pt->ex_size <= start); > + break; > + } else > + /* 's' and 't' overlap. */ > + return (0); > + } > + > + if (prevt) > + *prevt = pt; > + return (1); > +} > + > +/* > + * Insert an extent into the list of extents. > + */ > + > +static int > +_libelf_insert_extent(struct _Elf_Extent_List *extents, int type, > + uint64_t start, uint64_t size, void *desc) > +{ > + struct _Elf_Extent *ex, *prevt; > + > + assert(type >= ELF_EXTENT_EHDR && type <= ELF_EXTENT_SHDR); > + > + prevt = NULL; > + > + /* > + * If the requested range overlaps with an existing extent, > + * signal an error. > + */ > + if (!_libelf_extent_is_unused(extents, start, size, &prevt)) { > + LIBELF_SET_ERROR(LAYOUT, 0); > + return (0); > + } > + > + /* Allocate and fill in a new extent descriptor. */ > + if ((ex = malloc(sizeof(struct _Elf_Extent))) == NULL) { > + LIBELF_SET_ERROR(RESOURCE, errno); > + return (0); > + } > + ex->ex_start = start; > + ex->ex_size = size; > + ex->ex_desc = desc; > + ex->ex_type = type; > + > + /* Insert the region descriptor into the list. */ > + if (prevt) > + SLIST_INSERT_AFTER(prevt, ex, ex_next); > + else > + SLIST_INSERT_HEAD(extents, ex, ex_next); > + return (1); > +} > + > +/* > + * Recompute section layout. > + */ > + > +static off_t > +_libelf_resync_sections(Elf *e, off_t rc, struct _Elf_Extent_List *extents) > +{ > + int ec; > + Elf_Scn *s; > + size_t sh_type; > + > + ec = e->e_class; > + > + /* > + * Make a pass through sections, computing the extent of each > + * section. > + */ > + STAILQ_FOREACH(s, &e->e_u.e_elf.e_scn, s_next) { > + if (ec == ELFCLASS32) > + sh_type = s->s_shdr.s_shdr32.sh_type; > + else > + sh_type = s->s_shdr.s_shdr64.sh_type; > + > + if (sh_type == SHT_NOBITS || sh_type == SHT_NULL) > + continue; > + > + if (_libelf_compute_section_extents(e, s, rc) == 0) > + return ((off_t) -1); > + > + if (s->s_size == 0) > + continue; > + > + if (!_libelf_insert_extent(extents, ELF_EXTENT_SECTION, > + s->s_offset, s->s_size, s)) > + return ((off_t) -1); > + > + if ((size_t) rc < s->s_offset + s->s_size) > + rc = (off_t) (s->s_offset + s->s_size); > + } > + > + return (rc); > +} > + > +/* > + * Recompute the layout of the ELF object and update the internal data > + * structures associated with the ELF descriptor. > + * > + * 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 extents in the ELF object are sorted in order of ascending > + * addresses. Sections have their section header table entries > + * updated. An error is signalled if an overlap was detected among > + * extents. > + * - Data descriptors associated with sections are checked for valid > + * types, offsets and alignment. > + * > + * After a resync_elf() successfully returns, the ELF descriptor is > + * ready for being handed over to _libelf_write_elf(). > + */ > + > +static off_t > +_libelf_resync_elf(Elf *e, struct _Elf_Extent_List *extents) > +{ > + int ec, eh_class; > + unsigned int eh_byteorder, eh_version; > + size_t align, fsz; > + size_t phnum, shnum; > + off_t rc, phoff, shoff; > + void *ehdr, *phdr; > + 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 = (off_t) eh32->e_phoff; > + shoff = (off_t) eh32->e_shoff; > + eh_version = eh32->e_version; > + } else { > + eh_byteorder = eh64->e_ident[EI_DATA]; > + eh_class = eh64->e_ident[EI_CLASS]; > + phoff = (off_t) eh64->e_phoff; > + shoff = (off_t) eh64->e_shoff; > + eh_version = eh64->e_version; > + } > + > + if (phoff < 0 || shoff < 0) { > + LIBELF_SET_ERROR(HEADER, 0); > + return ((off_t) -1); > + } > + > + 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 { > \ > + unsigned int _version = (unsigned int) (V); \ > + (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] = (unsigned char) (EC); \ > + (E)->e_ident[EI_VERSION] = (_version & 0xFFU); \ > + (E)->e_ehsize = (uint16_t) _libelf_fsize(ELF_T_EHDR, \ > + (EC), _version, (size_t) 1); \ > + (E)->e_phentsize = (uint16_t) ((phnum == 0) ? 0 : \ > + _libelf_fsize(ELF_T_PHDR, (EC), _version, \ > + (size_t) 1)); \ > + (E)->e_shentsize = (uint16_t) _libelf_fsize(ELF_T_SHDR, \ > + (EC), _version, (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 += (off_t) _libelf_fsize(ELF_T_EHDR, ec, eh_version, (size_t) 1); > + > + if (!_libelf_insert_extent(extents, ELF_EXTENT_EHDR, 0, (uint64_t) rc, > + ehdr)) > + return ((off_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(LAYOUT, 0); > + return ((off_t) -1); > + } > + > + if (phoff % (off_t) align) { > + LIBELF_SET_ERROR(LAYOUT, 0); > + return ((off_t) -1); > + } > + > + } else > + phoff = roundup(rc, (off_t) align); > + > + rc = phoff + (off_t) fsz; > + > + phdr = _libelf_getphdr(e, ec); > + > + if (!_libelf_insert_extent(extents, ELF_EXTENT_PHDR, > + (uint64_t) phoff, fsz, phdr)) > + return ((off_t) -1); > + } else > + phoff = 0; > + > + /* > + * Compute the layout of the sections associated with the > + * file. > + */ > + > + if (e->e_cmd != ELF_C_WRITE && > + (e->e_flags & LIBELF_F_SHDRS_LOADED) == 0 && > + _libelf_load_section_headers(e, ehdr) == 0) > + return ((off_t) -1); > + > + if ((rc = _libelf_resync_sections(e, rc, extents)) < 0) > + return ((off_t) -1); > + > + /* > + * Compute the space taken up by the section header table, if > + * one is needed. > + * > + * If ELF_F_LAYOUT has been asserted, the application may have > + * placed the section header table in between existing > + * sections, so the net size of the file need not increase due > + * to the presence of the section header table. > + * > + * If the library is responsible for laying out the object, > + * the section header table is placed after section data. > + */ > + if (shnum) { > + fsz = _libelf_fsize(ELF_T_SHDR, ec, eh_version, shnum); > + align = _libelf_falign(ELF_T_SHDR, ec); > + > + if (e->e_flags & ELF_F_LAYOUT) { > + if (shoff % (off_t) align) { > + LIBELF_SET_ERROR(LAYOUT, 0); > + return ((off_t) -1); > + } > + } else > + shoff = roundup(rc, (off_t) align); > + > + if (shoff + (off_t) fsz > rc) > + rc = shoff + (off_t) fsz; > + > + if (!_libelf_insert_extent(extents, ELF_EXTENT_SHDR, > + (uint64_t) shoff, fsz, NULL)) > + return ((off_t) -1); > + } 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 an ELF section. > + */ > + > +static off_t > +_libelf_write_scn(Elf *e, unsigned char *nf, struct _Elf_Extent *ex) > +{ > + int ec; > + off_t rc; > + Elf_Scn *s; > + int elftype; > + Elf_Data *d, dst; > + uint32_t sh_type; > + struct _Libelf_Data *ld; > + uint64_t sh_off, sh_size; > + size_t fsz, msz, nobjects; > + > + assert(ex->ex_type == ELF_EXTENT_SECTION); > + > + s = ex->ex_desc; > + rc = (off_t) ex->ex_start; > + > + if ((ec = e->e_class) == ELFCLASS32) { > + sh_type = s->s_shdr.s_shdr32.sh_type; > + sh_size = (uint64_t) s->s_shdr.s_shdr32.sh_size; > + } else { > + sh_type = s->s_shdr.s_shdr64.sh_type; > + sh_size = s->s_shdr.s_shdr64.sh_size; > + } > + > + /* > + * Ignore sections that do not allocate space in the file. > + */ > + if (sh_type == SHT_NOBITS || sh_type == SHT_NULL || sh_size == 0) > + return (rc); > + > + elftype = _libelf_xlate_shtype(sh_type); > + assert(elftype >= ELF_T_FIRST && elftype <= ELF_T_LAST); > + > + 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(ld, &s->s_rawdata, d_next) { > + > + d = &ld->d_data; > + > + if ((uint64_t) rc < sh_off + d->d_off) > + (void) memset(nf + rc, > + LIBELF_PRIVATE(fillchar), > + (size_t) (sh_off + d->d_off - > + (uint64_t) rc)); > + rc = (off_t) (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, > + (size_t) d->d_size); > + > + rc += (off_t) 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(ld, &s->s_data, d_next) { > + > + d = &ld->d_data; > + > + msz = _libelf_msize(d->d_type, ec, e->e_version); > + > + if ((uint64_t) rc < sh_off + d->d_off) > + (void) memset(nf + rc, > + LIBELF_PRIVATE(fillchar), > + (size_t) (sh_off + d->d_off - (uint64_t) rc)); > + > + rc = (off_t) (sh_off + d->d_off); > + > + assert(d->d_buf != NULL); > + assert(d->d_version == e->e_version); > + assert(d->d_size % msz == 0); > + > + nobjects = (size_t) (d->d_size / msz); > + > + fsz = _libelf_fsize(d->d_type, 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 += (off_t) fsz; > + } > + > + return (rc); > +} > + > +/* > + * Write out an ELF Executable Header. > + */ > + > +static off_t > +_libelf_write_ehdr(Elf *e, unsigned char *nf, struct _Elf_Extent *ex) > +{ > + int ec; > + void *ehdr; > + size_t fsz, msz; > + Elf_Data dst, src; > + > + assert(ex->ex_type == ELF_EXTENT_EHDR); > + assert(ex->ex_start == 0); /* Ehdr always comes first. */ > + > + ec = e->e_class; > + > + ehdr = _libelf_ehdr(e, ec, 0); > + assert(ehdr != NULL); > + > + 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; > + > + dst.d_buf = nf; > + dst.d_size = fsz; > + > + if (_libelf_xlate(&dst, &src, e->e_byteorder, ec, ELF_TOFILE) == > + NULL) > + return ((off_t) -1); > + > + return ((off_t) fsz); > +} > + > +/* > + * Write out an ELF program header table. > + */ > + > +static off_t > +_libelf_write_phdr(Elf *e, unsigned char *nf, struct _Elf_Extent *ex) > +{ > + int ec; > + void *ehdr; > + Elf32_Ehdr *eh32; > + Elf64_Ehdr *eh64; > + Elf_Data dst, src; > + size_t fsz, phnum; > + uint64_t phoff; > + > + assert(ex->ex_type == ELF_EXTENT_PHDR); > + > + ec = e->e_class; > + ehdr = _libelf_ehdr(e, ec, 0); > + phnum = e->e_u.e_elf.e_nphdr; > + > + assert(phnum > 0); > + > + if (ec == ELFCLASS32) { > + eh32 = (Elf32_Ehdr *) ehdr; > + phoff = (uint64_t) eh32->e_phoff; > + } else { > + eh64 = (Elf64_Ehdr *) ehdr; > + phoff = eh64->e_phoff; > + } > + > + assert(phoff > 0); > + assert(ex->ex_start == phoff); > + assert(phoff % _libelf_falign(ELF_T_PHDR, ec) == 0); > + > + (void) memset(&dst, 0, sizeof(dst)); > + (void) memset(&src, 0, sizeof(src)); > + > + fsz = _libelf_fsize(ELF_T_PHDR, ec, e->e_version, phnum); > + assert(fsz > 0); > + > + src.d_buf = _libelf_getphdr(e, ec); > + src.d_version = dst.d_version = e->e_version; > + src.d_type = ELF_T_PHDR; > + src.d_size = phnum * _libelf_msize(ELF_T_PHDR, ec, > + e->e_version); > + > + dst.d_size = fsz; > + dst.d_buf = nf + ex->ex_start; > + > + if (_libelf_xlate(&dst, &src, e->e_byteorder, ec, ELF_TOFILE) == > + NULL) > + return ((off_t) -1); > + > + return ((off_t) (phoff + fsz)); > +} > + > +/* > + * Write out an ELF section header table. > + */ > + > +static off_t > +_libelf_write_shdr(Elf *e, unsigned char *nf, struct _Elf_Extent *ex) > +{ > + int ec; > + void *ehdr; > + Elf_Scn *scn; > + uint64_t shoff; > + Elf32_Ehdr *eh32; > + Elf64_Ehdr *eh64; > + size_t fsz, nscn; > + Elf_Data dst, src; > + > + assert(ex->ex_type == ELF_EXTENT_SHDR); > + > + ec = e->e_class; > + ehdr = _libelf_ehdr(e, ec, 0); > + nscn = e->e_u.e_elf.e_nscn; > + > + if (ec == ELFCLASS32) { > + eh32 = (Elf32_Ehdr *) ehdr; > + shoff = (uint64_t) eh32->e_shoff; > + } else { > + eh64 = (Elf64_Ehdr *) ehdr; > + shoff = eh64->e_shoff; > + } > + > + assert(nscn > 0); > + assert(shoff % _libelf_falign(ELF_T_SHDR, ec) == 0); > + assert(ex->ex_start == shoff); > + > + (void) memset(&dst, 0, sizeof(dst)); > + (void) memset(&src, 0, sizeof(src)); > + > + 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 = nf + ex->ex_start + scn->s_ndx * fsz; > + > + if (_libelf_xlate(&dst, &src, e->e_byteorder, ec, > + ELF_TOFILE) == NULL) > + return ((off_t) -1); > + } > + > + return ((off_t) (ex->ex_start + nscn * fsz)); > +} > + > +/* > + * 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, struct _Elf_Extent_List *extents) > +{ > + off_t nrc, rc; > + Elf_Scn *scn, *tscn; > + struct _Elf_Extent *ex; > + unsigned char *newfile; > + > + assert(e->e_kind == ELF_K_ELF); > + assert(e->e_cmd == ELF_C_RDWR || e->e_cmd == ELF_C_WRITE); > + assert(e->e_fd >= 0); > + > + if ((newfile = malloc((size_t) newsize)) == NULL) { > + LIBELF_SET_ERROR(RESOURCE, errno); > + return ((off_t) -1); > + } > + > + nrc = rc = 0; > + SLIST_FOREACH(ex, extents, ex_next) { > + > + /* Fill inter-extent gaps. */ > + if (ex->ex_start > (size_t) rc) > + (void) memset(newfile + rc, LIBELF_PRIVATE(fillchar), > + (size_t) (ex->ex_start - (uint64_t) rc)); > + > + switch (ex->ex_type) { > + case ELF_EXTENT_EHDR: > + if ((nrc = _libelf_write_ehdr(e, newfile, ex)) < 0) > + goto error; > + break; > + > + case ELF_EXTENT_PHDR: > + if ((nrc = _libelf_write_phdr(e, newfile, ex)) < 0) > + goto error; > + break; > + > + case ELF_EXTENT_SECTION: > + if ((nrc = _libelf_write_scn(e, newfile, ex)) < 0) > + goto error; > + break; > + > + case ELF_EXTENT_SHDR: > + if ((nrc = _libelf_write_shdr(e, newfile, ex)) < 0) > + goto error; > + break; > + > + default: > + assert(0); > + break; > + } > + > + assert(ex->ex_start + ex->ex_size == (size_t) nrc); > + assert(rc < nrc); > + > + rc = nrc; > + } > + > + assert(rc == newsize); > + > + /* > + * For regular files, throw away existing file content and > + * unmap any existing mappings. > + */ > + if ((e->e_flags & LIBELF_F_SPECIAL_FILE) == 0) { > + if (ftruncate(e->e_fd, (off_t) 0) < 0 || > + lseek(e->e_fd, (off_t) 0, SEEK_SET)) { > + LIBELF_SET_ERROR(IO, errno); > + goto error; > + } > +#if ELFTC_HAVE_MMAP > + if (e->e_flags & LIBELF_F_RAWFILE_MMAP) { > + assert(e->e_rawfile != NULL); > + assert(e->e_cmd == ELF_C_RDWR); > + if (munmap(e->e_rawfile, e->e_rawsize) < 0) { > + LIBELF_SET_ERROR(IO, errno); > + goto error; > + } > + } > +#endif > + } > + > + /* > + * Write out the new contents. > + */ > + if (write(e->e_fd, newfile, (size_t) newsize) != newsize) { > + LIBELF_SET_ERROR(IO, errno); > + goto error; > + } > + > + /* > + * For files opened in ELF_C_RDWR mode, set up the new 'raw' > + * contents. > + */ > + if (e->e_cmd == ELF_C_RDWR) { > + assert(e->e_rawfile != NULL); > + assert((e->e_flags & LIBELF_F_RAWFILE_MALLOC) || > + (e->e_flags & LIBELF_F_RAWFILE_MMAP)); > + if (e->e_flags & LIBELF_F_RAWFILE_MALLOC) { > + free(e->e_rawfile); > + e->e_rawfile = newfile; > + newfile = NULL; > + } > +#if ELFTC_HAVE_MMAP > + else if (e->e_flags & LIBELF_F_RAWFILE_MMAP) { > + 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; > + } > + } > +#endif /* ELFTC_HAVE_MMAP */ > + > + /* Record the new size of the file. */ > + e->e_rawsize = (size_t) newsize; > + } else { > + /* File opened in ELF_C_WRITE mode. */ > + assert(e->e_rawfile == NULL); > + } > + > + /* > + * 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 (e->e_class == 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; > + } > + > + /* Free the temporary buffer. */ > + if (newfile) > + free(newfile); > + > + return (rc); > + > + error: > + free(newfile); > + > + return ((off_t) -1); > +} > + > +/* > + * Update an ELF object. > + */ > + > +off_t > +elf_update(Elf *e, Elf_Cmd c) > +{ > + int ec; > + off_t rc; > + struct _Elf_Extent_List extents; > + > + 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); > + } > + > + SLIST_INIT(&extents); > + > + if ((rc = _libelf_resync_elf(e, &extents)) < 0) > + goto done; > + > + if (c == ELF_C_NULL) > + goto done; > + > + if (e->e_fd < 0) { > + rc = (off_t) -1; > + LIBELF_SET_ERROR(SEQUENCE, 0); > + goto done; > + } > + > + rc = _libelf_write_elf(e, rc, &extents); > + > +done: > + _libelf_release_extents(&extents); > + return (rc); > +} > diff --git a/elf_version.c b/elf_version.c > new file mode 100644 > index 0000000..cd25954 > --- /dev/null > +++ b/elf_version.c > @@ -0,0 +1,50 @@ > +/*- > + * Copyright (c) 2006,2008 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" > + > +ELFTC_VCSID("$Id: elf_version.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +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/gelf_cap.c b/gelf_cap.c > new file mode 100644 > index 0000000..f509c69 > --- /dev/null > +++ b/gelf_cap.c > @@ -0,0 +1,150 @@ > +/*- > + * Copyright (c) 2006,2008 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 <gelf.h> > +#include <limits.h> > +#include <stdint.h> > + > +#include "_libelf.h" > + > +ELFTC_VCSID("$Id: gelf_cap.c 3177 2015-03-30 18:19:41Z emaste $"); > + > +GElf_Cap * > +gelf_getcap(Elf_Data *ed, int ndx, GElf_Cap *dst) > +{ > + int ec; > + Elf *e; > + size_t msz; > + Elf_Scn *scn; > + Elf32_Cap *cap32; > + Elf64_Cap *cap64; > + uint32_t sh_type; > + struct _Libelf_Data *d; > + > + d = (struct _Libelf_Data *) ed; > + > + 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_CAP) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (NULL); > + } > + > + msz = _libelf_msize(ELF_T_CAP, ec, e->e_version); > + > + assert(msz > 0); > + > + if (msz * (size_t) ndx >= d->d_data.d_size) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (NULL); > + } > + > + if (ec == ELFCLASS32) { > + > + cap32 = (Elf32_Cap *) d->d_data.d_buf + ndx; > + > + dst->c_tag = cap32->c_tag; > + dst->c_un.c_val = (Elf64_Xword) cap32->c_un.c_val; > + > + } else { > + > + cap64 = (Elf64_Cap *) d->d_data.d_buf + ndx; > + > + *dst = *cap64; > + } > + > + return (dst); > +} > + > +int > +gelf_update_cap(Elf_Data *ed, int ndx, GElf_Cap *gc) > +{ > + int ec; > + Elf *e; > + size_t msz; > + Elf_Scn *scn; > + Elf32_Cap *cap32; > + Elf64_Cap *cap64; > + uint32_t sh_type; > + struct _Libelf_Data *d; > + > + d = (struct _Libelf_Data *) ed; > + > + if (d == NULL || ndx < 0 || gc == 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_CAP) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (0); > + } > + > + msz = _libelf_msize(ELF_T_CAP, ec, e->e_version); > + assert(msz > 0); > + > + if (msz * (size_t) ndx >= d->d_data.d_size) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (0); > + } > + > + if (ec == ELFCLASS32) { > + cap32 = (Elf32_Cap *) d->d_data.d_buf + ndx; > + > + LIBELF_COPY_U32(cap32, gc, c_tag); > + LIBELF_COPY_U32(cap32, gc, c_un.c_val); > + } else { > + cap64 = (Elf64_Cap *) d->d_data.d_buf + ndx; > + > + *cap64 = *gc; > + } > + > + return (1); > +} > diff --git a/gelf_checksum.c b/gelf_checksum.c > new file mode 100644 > index 0000000..b16272f > --- /dev/null > +++ b/gelf_checksum.c > @@ -0,0 +1,56 @@ > +/*- > + * Copyright (c) 2006,2008 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" > + > +ELFTC_VCSID("$Id: gelf_checksum.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +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/gelf_dyn.c b/gelf_dyn.c > new file mode 100644 > index 0000000..7423309 > --- /dev/null > +++ b/gelf_dyn.c > @@ -0,0 +1,152 @@ > +/*- > + * Copyright (c) 2006,2008 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 <gelf.h> > +#include <limits.h> > +#include <stdint.h> > + > +#include "_libelf.h" > + > +ELFTC_VCSID("$Id: gelf_dyn.c 3177 2015-03-30 18:19:41Z emaste $"); > + > +GElf_Dyn * > +gelf_getdyn(Elf_Data *ed, int ndx, GElf_Dyn *dst) > +{ > + int ec; > + Elf *e; > + size_t msz; > + Elf_Scn *scn; > + Elf32_Dyn *dyn32; > + Elf64_Dyn *dyn64; > + uint32_t sh_type; > + struct _Libelf_Data *d; > + > + d = (struct _Libelf_Data *) ed; > + > + 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); > + assert(ndx >= 0); > + > + if (msz * (size_t) ndx >= d->d_data.d_size) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (NULL); > + } > + > + if (ec == ELFCLASS32) { > + dyn32 = (Elf32_Dyn *) d->d_data.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_data.d_buf + ndx; > + > + *dst = *dyn64; > + } > + > + return (dst); > +} > + > +int > +gelf_update_dyn(Elf_Data *ed, int ndx, GElf_Dyn *ds) > +{ > + int ec; > + Elf *e; > + size_t msz; > + Elf_Scn *scn; > + Elf32_Dyn *dyn32; > + Elf64_Dyn *dyn64; > + uint32_t sh_type; > + struct _Libelf_Data *d; > + > + d = (struct _Libelf_Data *) ed; > + > + 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); > + assert(ndx >= 0); > + > + if (msz * (size_t) ndx >= d->d_data.d_size) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (0); > + } > + > + if (ec == ELFCLASS32) { > + dyn32 = (Elf32_Dyn *) d->d_data.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_data.d_buf + ndx; > + > + *dyn64 = *ds; > + } > + > + return (1); > +} > diff --git a/gelf_ehdr.c b/gelf_ehdr.c > new file mode 100644 > index 0000000..dcd260e > --- /dev/null > +++ b/gelf_ehdr.c > @@ -0,0 +1,167 @@ > +/*- > + * Copyright (c) 2006,2008 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 <gelf.h> > +#include <libelf.h> > +#include <limits.h> > +#include <stdint.h> > +#include <string.h> > + > +#include "_libelf.h" > + > +ELFTC_VCSID("$Id: gelf_ehdr.c 3177 2015-03-30 18:19:41Z emaste $"); > + > +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); > + > + (void) elf_flagehdr(e, ELF_C_SET, ELF_F_DIRTY); > + > + 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; > + > + return (1); > +} > diff --git a/gelf_fsize.c b/gelf_fsize.c > new file mode 100644 > index 0000000..afdea73 > --- /dev/null > +++ b/gelf_fsize.c > @@ -0,0 +1,60 @@ > +/*- > + * Copyright (c) 2006,2008 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" > + > +ELFTC_VCSID("$Id: gelf_fsize.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +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/gelf_getclass.c b/gelf_getclass.c > new file mode 100644 > index 0000000..d7f6803 > --- /dev/null > +++ b/gelf_getclass.c > @@ -0,0 +1,37 @@ > +/*- > + * Copyright (c) 2006,2008 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" > + > +ELFTC_VCSID("$Id: gelf_getclass.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +int > +gelf_getclass(Elf *e) > +{ > + return (e != NULL ? e->e_class : ELFCLASSNONE); > +} > diff --git a/gelf_move.c b/gelf_move.c > new file mode 100644 > index 0000000..2ec8f25 > --- /dev/null > +++ b/gelf_move.c > @@ -0,0 +1,159 @@ > +/*- > + * Copyright (c) 2006,2008 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 <gelf.h> > +#include <limits.h> > +#include <stdint.h> > + > +#include "_libelf.h" > + > +ELFTC_VCSID("$Id: gelf_move.c 3177 2015-03-30 18:19:41Z emaste $"); > + > +GElf_Move * > +gelf_getmove(Elf_Data *ed, int ndx, GElf_Move *dst) > +{ > + int ec; > + Elf *e; > + size_t msz; > + Elf_Scn *scn; > + uint32_t sh_type; > + Elf32_Move *move32; > + Elf64_Move *move64; > + struct _Libelf_Data *d; > + > + d = (struct _Libelf_Data *) ed; > + > + 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_MOVE) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (NULL); > + } > + > + msz = _libelf_msize(ELF_T_MOVE, ec, e->e_version); > + > + assert(msz > 0); > + assert(ndx >= 0); > + > + if (msz * (size_t) ndx >= d->d_data.d_size) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (NULL); > + } > + > + if (ec == ELFCLASS32) { > + > + move32 = (Elf32_Move *) d->d_data.d_buf + ndx; > + > + dst->m_value = move32->m_value; > + dst->m_info = (Elf64_Xword) move32->m_info; > + dst->m_poffset = (Elf64_Xword) move32->m_poffset; > + dst->m_repeat = move32->m_repeat; > + dst->m_stride = move32->m_stride; > + } else { > + > + move64 = (Elf64_Move *) d->d_data.d_buf + ndx; > + > + *dst = *move64; > + } > + > + return (dst); > +} > + > +int > +gelf_update_move(Elf_Data *ed, int ndx, GElf_Move *gm) > +{ > + int ec; > + Elf *e; > + size_t msz; > + Elf_Scn *scn; > + uint32_t sh_type; > + Elf32_Move *move32; > + Elf64_Move *move64; > + struct _Libelf_Data *d; > + > + d = (struct _Libelf_Data *) ed; > + > + if (d == NULL || ndx < 0 || gm == 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_MOVE) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (0); > + } > + > + msz = _libelf_msize(ELF_T_MOVE, ec, e->e_version); > + > + assert(msz > 0); > + assert(ndx >= 0); > + > + if (msz * (size_t) ndx >= d->d_data.d_size) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (0); > + } > + > + if (ec == ELFCLASS32) { > + move32 = (Elf32_Move *) d->d_data.d_buf + ndx; > + > + move32->m_value = gm->m_value; > + LIBELF_COPY_U32(move32, gm, m_info); > + LIBELF_COPY_U32(move32, gm, m_poffset); > + move32->m_repeat = gm->m_repeat; > + move32->m_stride = gm->m_stride; > + > + } else { > + move64 = (Elf64_Move *) d->d_data.d_buf + ndx; > + > + *move64 = *gm; > + } > + > + return (1); > +} > diff --git a/gelf_phdr.c b/gelf_phdr.c > new file mode 100644 > index 0000000..31e20b0 > --- /dev/null > +++ b/gelf_phdr.c > @@ -0,0 +1,177 @@ > +/*- > + * Copyright (c) 2006,2008 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 <limits.h> > +#include <stdint.h> > + > +#include "_libelf.h" > + > +ELFTC_VCSID("$Id: gelf_phdr.c 3177 2015-03-30 18:19:41Z emaste $"); > + > +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); > + } > + > + (void) elf_flagphdr(e, ELF_C_SET, ELF_F_DIRTY); > + > + 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); > + > + return (1); > +} > diff --git a/gelf_rel.c b/gelf_rel.c > new file mode 100644 > index 0000000..02a6133 > --- /dev/null > +++ b/gelf_rel.c > @@ -0,0 +1,162 @@ > +/*- > + * Copyright (c) 2006,2008 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 <gelf.h> > +#include <limits.h> > +#include <stdint.h> > + > +#include "_libelf.h" > + > +ELFTC_VCSID("$Id: gelf_rel.c 3177 2015-03-30 18:19:41Z emaste $"); > + > +GElf_Rel * > +gelf_getrel(Elf_Data *ed, int ndx, GElf_Rel *dst) > +{ > + int ec; > + Elf *e; > + size_t msz; > + Elf_Scn *scn; > + uint32_t sh_type; > + Elf32_Rel *rel32; > + Elf64_Rel *rel64; > + struct _Libelf_Data *d; > + > + d = (struct _Libelf_Data *) ed; > + > + 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); > + assert(ndx >= 0); > + > + if (msz * (size_t) ndx >= d->d_data.d_size) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (NULL); > + } > + > + if (ec == ELFCLASS32) { > + rel32 = (Elf32_Rel *) d->d_data.d_buf + ndx; > + > + dst->r_offset = (Elf64_Addr) rel32->r_offset; > + dst->r_info = ELF64_R_INFO( > + (Elf64_Xword) ELF32_R_SYM(rel32->r_info), > + ELF32_R_TYPE(rel32->r_info)); > + > + } else { > + > + rel64 = (Elf64_Rel *) d->d_data.d_buf + ndx; > + > + *dst = *rel64; > + } > + > + return (dst); > +} > + > +int > +gelf_update_rel(Elf_Data *ed, int ndx, GElf_Rel *dr) > +{ > + int ec; > + Elf *e; > + size_t msz; > + Elf_Scn *scn; > + uint32_t sh_type; > + Elf32_Rel *rel32; > + Elf64_Rel *rel64; > + struct _Libelf_Data *d; > + > + d = (struct _Libelf_Data *) ed; > + > + 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); > + assert(ndx >= 0); > + > + if (msz * (size_t) ndx >= d->d_data.d_size) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (0); > + } > + > + if (ec == ELFCLASS32) { > + rel32 = (Elf32_Rel *) d->d_data.d_buf + ndx; > + > + LIBELF_COPY_U32(rel32, dr, r_offset); > + > + if (ELF64_R_SYM(dr->r_info) > ELF32_R_SYM(~0UL) || > + ELF64_R_TYPE(dr->r_info) > ELF32_R_TYPE(~0U)) { > + LIBELF_SET_ERROR(RANGE, 0); > + return (0); > + } > + rel32->r_info = ELF32_R_INFO( > + (Elf32_Word) ELF64_R_SYM(dr->r_info), > + (Elf32_Word) ELF64_R_TYPE(dr->r_info)); > + } else { > + rel64 = (Elf64_Rel *) d->d_data.d_buf + ndx; > + > + *rel64 = *dr; > + } > + > + return (1); > +} > diff --git a/gelf_rela.c b/gelf_rela.c > new file mode 100644 > index 0000000..d485ab9 > --- /dev/null > +++ b/gelf_rela.c > @@ -0,0 +1,165 @@ > +/*- > + * Copyright (c) 2006,2008 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 <gelf.h> > +#include <limits.h> > +#include <stdint.h> > + > +#include "_libelf.h" > + > +ELFTC_VCSID("$Id: gelf_rela.c 3177 2015-03-30 18:19:41Z emaste $"); > + > +GElf_Rela * > +gelf_getrela(Elf_Data *ed, int ndx, GElf_Rela *dst) > +{ > + int ec; > + Elf *e; > + size_t msz; > + Elf_Scn *scn; > + uint32_t sh_type; > + Elf32_Rela *rela32; > + Elf64_Rela *rela64; > + struct _Libelf_Data *d; > + > + d = (struct _Libelf_Data *) ed; > + > + 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); > + assert(ndx >= 0); > + > + if (msz * (size_t) ndx >= d->d_data.d_size) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (NULL); > + } > + > + if (ec == ELFCLASS32) { > + rela32 = (Elf32_Rela *) d->d_data.d_buf + ndx; > + > + dst->r_offset = (Elf64_Addr) rela32->r_offset; > + dst->r_info = ELF64_R_INFO( > + (Elf64_Xword) ELF32_R_SYM(rela32->r_info), > + ELF32_R_TYPE(rela32->r_info)); > + dst->r_addend = (Elf64_Sxword) rela32->r_addend; > + > + } else { > + > + rela64 = (Elf64_Rela *) d->d_data.d_buf + ndx; > + > + *dst = *rela64; > + } > + > + return (dst); > +} > + > +int > +gelf_update_rela(Elf_Data *ed, int ndx, GElf_Rela *dr) > +{ > + int ec; > + Elf *e; > + size_t msz; > + Elf_Scn *scn; > + uint32_t sh_type; > + Elf32_Rela *rela32; > + Elf64_Rela *rela64; > + struct _Libelf_Data *d; > + > + d = (struct _Libelf_Data *) ed; > + > + 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); > + assert(ndx >= 0); > + > + if (msz * (size_t) ndx >= d->d_data.d_size) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (0); > + } > + > + if (ec == ELFCLASS32) { > + rela32 = (Elf32_Rela *) d->d_data.d_buf + ndx; > + > + LIBELF_COPY_U32(rela32, dr, r_offset); > + > + if (ELF64_R_SYM(dr->r_info) > ELF32_R_SYM(~0UL) || > + ELF64_R_TYPE(dr->r_info) > ELF32_R_TYPE(~0U)) { > + LIBELF_SET_ERROR(RANGE, 0); > + return (0); > + } > + rela32->r_info = ELF32_R_INFO( > + (Elf32_Word) ELF64_R_SYM(dr->r_info), > + (Elf32_Word) ELF64_R_TYPE(dr->r_info)); > + > + LIBELF_COPY_S32(rela32, dr, r_addend); > + } else { > + rela64 = (Elf64_Rela *) d->d_data.d_buf + ndx; > + > + *rela64 = *dr; > + } > + > + return (1); > +} > diff --git a/gelf_shdr.c b/gelf_shdr.c > new file mode 100644 > index 0000000..1a9d949 > --- /dev/null > +++ b/gelf_shdr.c > @@ -0,0 +1,130 @@ > +/*- > + * Copyright (c) 2006,2008 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 <gelf.h> > +#include <libelf.h> > +#include <limits.h> > +#include <stdint.h> > + > +#include "_libelf.h" > + > +ELFTC_VCSID("$Id: gelf_shdr.c 3177 2015-03-30 18:19:41Z emaste $"); > + > +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); > + } > + > + (void) elf_flagscn(scn, ELF_C_SET, ELF_F_DIRTY); > + > + 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); > + > + return (1); > +} > diff --git a/gelf_sym.c b/gelf_sym.c > new file mode 100644 > index 0000000..ecd85fc > --- /dev/null > +++ b/gelf_sym.c > @@ -0,0 +1,159 @@ > +/*- > + * Copyright (c) 2006,2008 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 <gelf.h> > +#include <limits.h> > +#include <stdint.h> > + > +#include "_libelf.h" > + > +ELFTC_VCSID("$Id: gelf_sym.c 3177 2015-03-30 18:19:41Z emaste $"); > + > +GElf_Sym * > +gelf_getsym(Elf_Data *ed, int ndx, GElf_Sym *dst) > +{ > + int ec; > + Elf *e; > + size_t msz; > + Elf_Scn *scn; > + uint32_t sh_type; > + Elf32_Sym *sym32; > + Elf64_Sym *sym64; > + struct _Libelf_Data *d; > + > + d = (struct _Libelf_Data *) ed; > + > + 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); > + assert(ndx >= 0); > + > + if (msz * (size_t) ndx >= d->d_data.d_size) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (NULL); > + } > + > + if (ec == ELFCLASS32) { > + sym32 = (Elf32_Sym *) d->d_data.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 = sym32->st_info; > + dst->st_other = sym32->st_other; > + dst->st_shndx = sym32->st_shndx; > + } else { > + sym64 = (Elf64_Sym *) d->d_data.d_buf + ndx; > + > + *dst = *sym64; > + } > + > + return (dst); > +} > + > +int > +gelf_update_sym(Elf_Data *ed, int ndx, GElf_Sym *gs) > +{ > + int ec; > + Elf *e; > + size_t msz; > + Elf_Scn *scn; > + uint32_t sh_type; > + Elf32_Sym *sym32; > + Elf64_Sym *sym64; > + struct _Libelf_Data *d; > + > + d = (struct _Libelf_Data *) ed; > + > + 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); > + assert(ndx >= 0); > + > + if (msz * (size_t) ndx >= d->d_data.d_size) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (0); > + } > + > + if (ec == ELFCLASS32) { > + sym32 = (Elf32_Sym *) d->d_data.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_data.d_buf + ndx; > + > + *sym64 = *gs; > + } > + > + return (1); > +} > diff --git a/gelf_syminfo.c b/gelf_syminfo.c > new file mode 100644 > index 0000000..f6d7b6c > --- /dev/null > +++ b/gelf_syminfo.c > @@ -0,0 +1,152 @@ > +/*- > + * Copyright (c) 2006,2008 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 <gelf.h> > + > +#include "_libelf.h" > + > +ELFTC_VCSID("$Id: gelf_syminfo.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +GElf_Syminfo * > +gelf_getsyminfo(Elf_Data *ed, int ndx, GElf_Syminfo *dst) > +{ > + int ec; > + Elf *e; > + size_t msz; > + Elf_Scn *scn; > + uint32_t sh_type; > + struct _Libelf_Data *d; > + Elf32_Syminfo *syminfo32; > + Elf64_Syminfo *syminfo64; > + > + d = (struct _Libelf_Data *) ed; > + > + 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_SYMINFO) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (NULL); > + } > + > + msz = _libelf_msize(ELF_T_SYMINFO, ec, e->e_version); > + > + assert(msz > 0); > + assert(ndx >= 0); > + > + if (msz * (size_t) ndx >= d->d_data.d_size) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (NULL); > + } > + > + if (ec == ELFCLASS32) { > + > + syminfo32 = (Elf32_Syminfo *) d->d_data.d_buf + ndx; > + > + dst->si_boundto = syminfo32->si_boundto; > + dst->si_flags = syminfo32->si_flags; > + > + } else { > + > + syminfo64 = (Elf64_Syminfo *) d->d_data.d_buf + ndx; > + > + *dst = *syminfo64; > + } > + > + return (dst); > +} > + > +int > +gelf_update_syminfo(Elf_Data *ed, int ndx, GElf_Syminfo *gs) > +{ > + int ec; > + Elf *e; > + size_t msz; > + Elf_Scn *scn; > + uint32_t sh_type; > + struct _Libelf_Data *d; > + Elf32_Syminfo *syminfo32; > + Elf64_Syminfo *syminfo64; > + > + d = (struct _Libelf_Data *) ed; > + > + 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_SYMINFO) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (0); > + } > + > + msz = _libelf_msize(ELF_T_SYMINFO, ec, e->e_version); > + > + assert(msz > 0); > + assert(ndx >= 0); > + > + if (msz * (size_t) ndx >= d->d_data.d_size) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (0); > + } > + > + if (ec == ELFCLASS32) { > + syminfo32 = (Elf32_Syminfo *) d->d_data.d_buf + ndx; > + > + syminfo32->si_boundto = gs->si_boundto; > + syminfo32->si_flags = gs->si_flags; > + > + } else { > + syminfo64 = (Elf64_Syminfo *) d->d_data.d_buf + ndx; > + > + *syminfo64 = *gs; > + } > + > + return (1); > +} > diff --git a/gelf_symshndx.c b/gelf_symshndx.c > new file mode 100644 > index 0000000..b490aa2 > --- /dev/null > +++ b/gelf_symshndx.c > @@ -0,0 +1,137 @@ > +/*- > + * Copyright (c) 2006,2008 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 <gelf.h> > + > +#include "_libelf.h" > + > +ELFTC_VCSID("$Id: gelf_symshndx.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +GElf_Sym * > +gelf_getsymshndx(Elf_Data *d, Elf_Data *id, int ndx, GElf_Sym *dst, > + Elf32_Word *shindex) > +{ > + int ec; > + Elf *e; > + size_t msz; > + Elf_Scn *scn; > + uint32_t sh_type; > + struct _Libelf_Data *ld, *lid; > + > + ld = (struct _Libelf_Data *) d; > + lid = (struct _Libelf_Data *) id; > + > + if (gelf_getsym(d, ndx, dst) == 0) > + return (NULL); > + > + if (lid == NULL || (scn = lid->d_scn) == NULL || > + (e = scn->s_elf) == NULL || (e != ld->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); > + assert(ndx >= 0); > + > + if (msz * (size_t) 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; > + size_t msz; > + Elf_Scn *scn; > + uint32_t sh_type; > + struct _Libelf_Data *ld, *lid; > + > + ld = (struct _Libelf_Data *) d; > + lid = (struct _Libelf_Data *) id; > + > + if (gelf_update_sym(d, ndx, gs) == 0) > + return (0); > + > + if (lid == NULL || (scn = lid->d_scn) == NULL || > + (e = scn->s_elf) == NULL || (e != ld->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); > + assert(ndx >= 0); > + > + if (msz * (size_t) ndx >= id->d_size) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (0); > + } > + > + *(((Elf32_Word *) id->d_buf) + ndx) = xindex; > + > + return (1); > +} > diff --git a/gelf_xlate.c b/gelf_xlate.c > new file mode 100644 > index 0000000..f501819 > --- /dev/null > +++ b/gelf_xlate.c > @@ -0,0 +1,79 @@ > +/*- > + * Copyright (c) 2006,2008 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" > + > +ELFTC_VCSID("$Id: gelf_xlate.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +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/include/elfdefinitions.h b/include/elfdefinitions.h > new file mode 100644 > index 0000000..caa6a30 > --- /dev/null > +++ b/include/elfdefinitions.h > @@ -0,0 +1,2700 @@ > +/*- > + * Copyright (c) 2010 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. > + * > + * $Id: elfdefinitions.h 3403 2016-02-13 15:39:27Z jkoshy $ > + */ > + > +/* > + * These definitions are based on: > + * - The public specification of the ELF format as defined in the > + * October 2009 draft of System V ABI. > + * See: http://www.sco.com/developers/gabi/latest/ch4.intro.html > + * - The May 1998 (version 1.5) draft of "The ELF-64 object format". > + * - Processor-specific ELF ABI definitions for sparc, i386, amd64, mips, > + * ia64, and powerpc processors. > + * - The "Linkers and Libraries Guide", from Sun Microsystems. > + */ > + > +#ifndef _ELFDEFINITIONS_H_ > +#define _ELFDEFINITIONS_H_ > + > +#include <stdint.h> > + > +/* > + * Types of capabilities. > + */ > + > +#define _ELF_DEFINE_CAPABILITIES() \ > +_ELF_DEFINE_CA(CA_SUNW_NULL, 0, "ignored") \ > +_ELF_DEFINE_CA(CA_SUNW_HW_1, 1, "hardware capability") \ > +_ELF_DEFINE_CA(CA_SUNW_SW_1, 2, "software capability") > + > +#undef _ELF_DEFINE_CA > +#define _ELF_DEFINE_CA(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_CAPABILITIES() > + CA__LAST__ > +}; > + > +/* > + * Flags used with dynamic linking entries. > + */ > + > +#define _ELF_DEFINE_DYN_FLAGS() \ > +_ELF_DEFINE_DF(DF_ORIGIN, 0x1, \ > + "object being loaded may refer to $ORIGIN") \ > +_ELF_DEFINE_DF(DF_SYMBOLIC, 0x2, \ > + "search library for references before executable") \ > +_ELF_DEFINE_DF(DF_TEXTREL, 0x4, \ > + "relocation entries may modify text segment") \ > +_ELF_DEFINE_DF(DF_BIND_NOW, 0x8, \ > + "process relocation entries at load time") \ > +_ELF_DEFINE_DF(DF_STATIC_TLS, 0x10, \ > + "uses static thread-local storage") > +#undef _ELF_DEFINE_DF > +#define _ELF_DEFINE_DF(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_DYN_FLAGS() > + DF__LAST__ > +}; > + > + > +/* > + * Dynamic linking entry types. > + */ > + > +#define _ELF_DEFINE_DYN_TYPES() > \ > +_ELF_DEFINE_DT(DT_NULL, 0, "end of array") \ > +_ELF_DEFINE_DT(DT_NEEDED, 1, "names a needed library") \ > +_ELF_DEFINE_DT(DT_PLTRELSZ, 2, \ > + "size in bytes of associated relocation entries") \ > +_ELF_DEFINE_DT(DT_PLTGOT, 3, \ > + "address associated with the procedure linkage table") \ > +_ELF_DEFINE_DT(DT_HASH, 4, \ > + "address of the symbol hash table") \ > +_ELF_DEFINE_DT(DT_STRTAB, 5, \ > + "address of the string table") \ > +_ELF_DEFINE_DT(DT_SYMTAB, 6, \ > + "address of the symbol table") \ > +_ELF_DEFINE_DT(DT_RELA, 7, \ > + "address of the relocation table") \ > +_ELF_DEFINE_DT(DT_RELASZ, 8, "size of the DT_RELA table") \ > +_ELF_DEFINE_DT(DT_RELAENT, 9, "size of each DT_RELA entry") \ > +_ELF_DEFINE_DT(DT_STRSZ, 10, "size of the string table") \ > +_ELF_DEFINE_DT(DT_SYMENT, 11, > \ > + "size of a symbol table entry") \ > +_ELF_DEFINE_DT(DT_INIT, 12, > \ > + "address of the initialization function") \ > +_ELF_DEFINE_DT(DT_FINI, 13, > \ > + "address of the finalization function") \ > +_ELF_DEFINE_DT(DT_SONAME, 14, "names the shared object") \ > +_ELF_DEFINE_DT(DT_RPATH, 15, > \ > + "runtime library search path") \ > +_ELF_DEFINE_DT(DT_SYMBOLIC, 16, > \ > + "alter symbol resolution algorithm") \ > +_ELF_DEFINE_DT(DT_REL, 17, > \ > + "address of the DT_REL table") \ > +_ELF_DEFINE_DT(DT_RELSZ, 18, "size of the DT_REL table") \ > +_ELF_DEFINE_DT(DT_RELENT, 19, "size of each DT_REL entry") \ > +_ELF_DEFINE_DT(DT_PLTREL, 20, > \ > + "type of relocation entry in the procedure linkage table") \ > +_ELF_DEFINE_DT(DT_DEBUG, 21, "used for debugging") \ > +_ELF_DEFINE_DT(DT_TEXTREL, 22, > \ > + "text segment may be written to during relocation") \ > +_ELF_DEFINE_DT(DT_JMPREL, 23, > \ > + "address of relocation entries associated with the procedure linkage > table") \ > +_ELF_DEFINE_DT(DT_BIND_NOW, 24, > \ > + "bind symbols at loading time") \ > +_ELF_DEFINE_DT(DT_INIT_ARRAY, 25, > \ > + "pointers to initialization functions") \ > +_ELF_DEFINE_DT(DT_FINI_ARRAY, 26, > \ > + "pointers to termination functions") \ > +_ELF_DEFINE_DT(DT_INIT_ARRAYSZ, 27, "size of the DT_INIT_ARRAY") \ > +_ELF_DEFINE_DT(DT_FINI_ARRAYSZ, 28, "size of the DT_FINI_ARRAY") \ > +_ELF_DEFINE_DT(DT_RUNPATH, 29, > \ > + "index of library search path string") \ > +_ELF_DEFINE_DT(DT_FLAGS, 30, > \ > + "flags specific to the object being loaded") \ > +_ELF_DEFINE_DT(DT_ENCODING, 32, "standard semantics") \ > +_ELF_DEFINE_DT(DT_PREINIT_ARRAY, 32, > \ > + "pointers to pre-initialization functions") \ > +_ELF_DEFINE_DT(DT_PREINIT_ARRAYSZ, 33, > \ > + "size of pre-initialization array") \ > +_ELF_DEFINE_DT(DT_MAXPOSTAGS, 34, \ > + "the number of positive tags") \ > +_ELF_DEFINE_DT(DT_LOOS, 0x6000000DUL, \ > + "start of OS-specific types") \ > +_ELF_DEFINE_DT(DT_SUNW_AUXILIARY, 0x6000000DUL, \ > + "offset of string naming auxiliary filtees") \ > +_ELF_DEFINE_DT(DT_SUNW_RTLDINF, 0x6000000EUL, "rtld internal use") \ > +_ELF_DEFINE_DT(DT_SUNW_FILTER, 0x6000000FUL, \ > + "offset of string naming standard filtees") \ > +_ELF_DEFINE_DT(DT_SUNW_CAP, 0x60000010UL, \ > + "address of hardware capabilities section") \ > +_ELF_DEFINE_DT(DT_HIOS, 0x6FFFF000UL, \ > + "end of OS-specific types") \ > +_ELF_DEFINE_DT(DT_VALRNGLO, 0x6FFFFD00UL, \ > + "start of range using the d_val field") \ > +_ELF_DEFINE_DT(DT_GNU_PRELINKED, 0x6FFFFDF5UL, \ > + "prelinking timestamp") \ > +_ELF_DEFINE_DT(DT_GNU_CONFLICTSZ, 0x6FFFFDF6UL, \ > + "size of conflict section") \ > +_ELF_DEFINE_DT(DT_GNU_LIBLISTSZ, 0x6FFFFDF7UL, \ > + "size of library list") \ > +_ELF_DEFINE_DT(DT_CHECKSUM, 0x6FFFFDF8UL, \ > + "checksum for the object") \ > +_ELF_DEFINE_DT(DT_PLTPADSZ, 0x6FFFFDF9UL, \ > + "size of PLT padding") \ > +_ELF_DEFINE_DT(DT_MOVEENT, 0x6FFFFDFAUL, \ > + "size of DT_MOVETAB entries") \ > +_ELF_DEFINE_DT(DT_MOVESZ, 0x6FFFFDFBUL, \ > + "total size of the MOVETAB table") \ > +_ELF_DEFINE_DT(DT_FEATURE, 0x6FFFFDFCUL, "feature values") \ > +_ELF_DEFINE_DT(DT_POSFLAG_1, 0x6FFFFDFDUL, \ > + "dynamic position flags") \ > +_ELF_DEFINE_DT(DT_SYMINSZ, 0x6FFFFDFEUL, \ > + "size of the DT_SYMINFO table") \ > +_ELF_DEFINE_DT(DT_SYMINENT, 0x6FFFFDFFUL, \ > + "size of a DT_SYMINFO entry") \ > +_ELF_DEFINE_DT(DT_VALRNGHI, 0x6FFFFDFFUL, \ > + "end of range using the d_val field") \ > +_ELF_DEFINE_DT(DT_ADDRRNGLO, 0x6FFFFE00UL, \ > + "start of range using the d_ptr field") \ > +_ELF_DEFINE_DT(DT_GNU_HASH, 0x6FFFFEF5UL, \ > + "GNU style hash tables") \ > +_ELF_DEFINE_DT(DT_GNU_CONFLICT, 0x6FFFFEF8UL, \ > + "address of conflict section") \ > +_ELF_DEFINE_DT(DT_GNU_LIBLIST, 0x6FFFFEF9UL, \ > + "address of conflict section") \ > +_ELF_DEFINE_DT(DT_CONFIG, 0x6FFFFEFAUL, \ > + "configuration file") \ > +_ELF_DEFINE_DT(DT_DEPAUDIT, 0x6FFFFEFBUL, \ > + "string defining audit libraries") \ > +_ELF_DEFINE_DT(DT_AUDIT, 0x6FFFFEFCUL, \ > + "string defining audit libraries") \ > +_ELF_DEFINE_DT(DT_PLTPAD, 0x6FFFFEFDUL, "PLT padding") \ > +_ELF_DEFINE_DT(DT_MOVETAB, 0x6FFFFEFEUL, \ > + "address of a move table") \ > +_ELF_DEFINE_DT(DT_SYMINFO, 0x6FFFFEFFUL, \ > + "address of the symbol information table") \ > +_ELF_DEFINE_DT(DT_ADDRRNGHI, 0x6FFFFEFFUL, \ > + "end of range using the d_ptr field") \ > +_ELF_DEFINE_DT(DT_VERSYM, 0x6FFFFFF0UL, \ > + "address of the version section") \ > +_ELF_DEFINE_DT(DT_RELACOUNT, 0x6FFFFFF9UL, \ > + "count of RELA relocations") \ > +_ELF_DEFINE_DT(DT_RELCOUNT, 0x6FFFFFFAUL, \ > + "count of REL relocations") \ > +_ELF_DEFINE_DT(DT_FLAGS_1, 0x6FFFFFFBUL, "flag values") \ > +_ELF_DEFINE_DT(DT_VERDEF, 0x6FFFFFFCUL, \ > + "address of the version definition segment") \ > +_ELF_DEFINE_DT(DT_VERDEFNUM, 0x6FFFFFFDUL, \ > + "the number of version definition entries") \ > +_ELF_DEFINE_DT(DT_VERNEED, 0x6FFFFFFEUL, \ > + "address of section with needed versions") \ > +_ELF_DEFINE_DT(DT_VERNEEDNUM, 0x6FFFFFFFUL, \ > + "the number of version needed entries") \ > +_ELF_DEFINE_DT(DT_LOPROC, 0x70000000UL, \ > + "start of processor-specific types") \ > +_ELF_DEFINE_DT(DT_ARM_SYMTABSZ, 0x70000001UL, > \ > + "number of entries in the dynamic symbol table") \ > +_ELF_DEFINE_DT(DT_SPARC_REGISTER, 0x70000001UL, \ > + "index of an STT_SPARC_REGISTER symbol") \ > +_ELF_DEFINE_DT(DT_ARM_PREEMPTMAP, 0x70000002UL, \ > + "address of the preemption map") \ > +_ELF_DEFINE_DT(DT_MIPS_RLD_VERSION, 0x70000001UL, \ > + "version ID for runtime linker interface") \ > +_ELF_DEFINE_DT(DT_MIPS_TIME_STAMP, 0x70000002UL, \ > + "timestamp") \ > +_ELF_DEFINE_DT(DT_MIPS_ICHECKSUM, 0x70000003UL, \ > + "checksum of all external strings and common sizes") \ > +_ELF_DEFINE_DT(DT_MIPS_IVERSION, 0x70000004UL, \ > + "string table index of a version string") \ > +_ELF_DEFINE_DT(DT_MIPS_FLAGS, 0x70000005UL, \ > + "MIPS-specific flags") \ > +_ELF_DEFINE_DT(DT_MIPS_BASE_ADDRESS, 0x70000006UL, \ > + "base address for the executable/DSO") \ > +_ELF_DEFINE_DT(DT_MIPS_CONFLICT, 0x70000008UL, \ > + "address of .conflict section") \ > +_ELF_DEFINE_DT(DT_MIPS_LIBLIST, 0x70000009UL, \ > + "address of .liblist section") \ > +_ELF_DEFINE_DT(DT_MIPS_LOCAL_GOTNO, 0x7000000AUL, \ > + "number of local GOT entries") \ > +_ELF_DEFINE_DT(DT_MIPS_CONFLICTNO, 0x7000000BUL, \ > + "number of entries in the .conflict section") \ > +_ELF_DEFINE_DT(DT_MIPS_LIBLISTNO, 0x70000010UL, \ > + "number of entries in the .liblist section") \ > +_ELF_DEFINE_DT(DT_MIPS_SYMTABNO, 0x70000011UL, \ > + "number of entries in the .dynsym section") \ > +_ELF_DEFINE_DT(DT_MIPS_UNREFEXTNO, 0x70000012UL, \ > + "index of first external dynamic symbol not ref'ed locally") \ > +_ELF_DEFINE_DT(DT_MIPS_GOTSYM, 0x70000013UL, \ > + "index of first dynamic symbol corresponds to a GOT entry") \ > +_ELF_DEFINE_DT(DT_MIPS_HIPAGENO, 0x70000014UL, \ > + "number of page table entries in GOT") \ > +_ELF_DEFINE_DT(DT_MIPS_RLD_MAP, 0x70000016UL, \ > + "address of runtime linker map") \ > +_ELF_DEFINE_DT(DT_MIPS_DELTA_CLASS, 0x70000017UL, \ > + "Delta C++ class definition") \ > +_ELF_DEFINE_DT(DT_MIPS_DELTA_CLASS_NO, 0x70000018UL, \ > + "number of entries in DT_MIPS_DELTA_CLASS") \ > +_ELF_DEFINE_DT(DT_MIPS_DELTA_INSTANCE, 0x70000019UL, \ > + "Delta C++ class instances") \ > +_ELF_DEFINE_DT(DT_MIPS_DELTA_INSTANCE_NO, 0x7000001AUL, > \ > + "number of entries in DT_MIPS_DELTA_INSTANCE") \ > +_ELF_DEFINE_DT(DT_MIPS_DELTA_RELOC, 0x7000001BUL, \ > + "Delta relocations") \ > +_ELF_DEFINE_DT(DT_MIPS_DELTA_RELOC_NO, 0x7000001CUL, \ > + "number of entries in DT_MIPS_DELTA_RELOC") \ > +_ELF_DEFINE_DT(DT_MIPS_DELTA_SYM, 0x7000001DUL, \ > + "Delta symbols refered by Delta relocations") \ > +_ELF_DEFINE_DT(DT_MIPS_DELTA_SYM_NO, 0x7000001EUL, \ > + "number of entries in DT_MIPS_DELTA_SYM") \ > +_ELF_DEFINE_DT(DT_MIPS_DELTA_CLASSSYM, 0x70000020UL, \ > + "Delta symbols for class declarations") \ > +_ELF_DEFINE_DT(DT_MIPS_DELTA_CLASSSYM_NO, 0x70000021UL, > \ > + "number of entries in DT_MIPS_DELTA_CLASSSYM") \ > +_ELF_DEFINE_DT(DT_MIPS_CXX_FLAGS, 0x70000022UL, \ > + "C++ flavor flags") \ > +_ELF_DEFINE_DT(DT_MIPS_PIXIE_INIT, 0x70000023UL, \ > + "address of an initialization routine created by pixie") \ > +_ELF_DEFINE_DT(DT_MIPS_SYMBOL_LIB, 0x70000024UL, \ > + "address of .MIPS.symlib section") \ > +_ELF_DEFINE_DT(DT_MIPS_LOCALPAGE_GOTIDX, 0x70000025UL, \ > + "GOT index of first page table entry for a segment") \ > +_ELF_DEFINE_DT(DT_MIPS_LOCAL_GOTIDX, 0x70000026UL, \ > + "GOT index of first page table entry for a local symbol") \ > +_ELF_DEFINE_DT(DT_MIPS_HIDDEN_GOTIDX, 0x70000027UL, \ > + "GOT index of first page table entry for a hidden symbol") \ > +_ELF_DEFINE_DT(DT_MIPS_PROTECTED_GOTIDX, 0x70000028UL, \ > + "GOT index of first page table entry for a protected symbol") \ > +_ELF_DEFINE_DT(DT_MIPS_OPTIONS, 0x70000029UL, \ > + "address of .MIPS.options section") \ > +_ELF_DEFINE_DT(DT_MIPS_INTERFACE, 0x7000002AUL, \ > + "address of .MIPS.interface section") \ > +_ELF_DEFINE_DT(DT_MIPS_DYNSTR_ALIGN, 0x7000002BUL, "???") \ > +_ELF_DEFINE_DT(DT_MIPS_INTERFACE_SIZE, 0x7000002CUL, \ > + "size of .MIPS.interface section") \ > +_ELF_DEFINE_DT(DT_MIPS_RLD_TEXT_RESOLVE_ADDR, 0x7000002DUL, \ > + "address of _rld_text_resolve in GOT") \ > +_ELF_DEFINE_DT(DT_MIPS_PERF_SUFFIX, 0x7000002EUL, \ > + "default suffix of DSO to be appended by dlopen") \ > +_ELF_DEFINE_DT(DT_MIPS_COMPACT_SIZE, 0x7000002FUL, \ > + "size of a ucode compact relocation record (o32)") \ > +_ELF_DEFINE_DT(DT_MIPS_GP_VALUE, 0x70000030UL, \ > + "GP value of a specified GP relative range") \ > +_ELF_DEFINE_DT(DT_MIPS_AUX_DYNAMIC, 0x70000031UL, \ > + "address of an auxiliary dynamic table") \ > +_ELF_DEFINE_DT(DT_MIPS_PLTGOT, 0x70000032UL, \ > + "address of the PLTGOT") \ > +_ELF_DEFINE_DT(DT_MIPS_RLD_OBJ_UPDATE, 0x70000033UL, \ > + "object list update callback") \ > +_ELF_DEFINE_DT(DT_MIPS_RWPLT, 0x70000034UL, \ > + "address of a writable PLT") \ > +_ELF_DEFINE_DT(DT_PPC_GOT, 0x70000000UL, \ > + "value of _GLOBAL_OFFSET_TABLE_") \ > +_ELF_DEFINE_DT(DT_PPC_TLSOPT, 0x70000001UL, \ > + "TLS descriptor should be optimized") \ > +_ELF_DEFINE_DT(DT_PPC64_GLINK, 0x70000000UL, \ > + "address of .glink section") \ > +_ELF_DEFINE_DT(DT_PPC64_OPD, 0x70000001UL, \ > + "address of .opd section") \ > +_ELF_DEFINE_DT(DT_PPC64_OPDSZ, 0x70000002UL, \ > + "size of .opd section") \ > +_ELF_DEFINE_DT(DT_PPC64_TLSOPT, 0x70000003UL, \ > + "TLS descriptor should be optimized") \ > +_ELF_DEFINE_DT(DT_AUXILIARY, 0x7FFFFFFDUL, \ > + "offset of string naming auxiliary filtees") \ > +_ELF_DEFINE_DT(DT_USED, 0x7FFFFFFEUL, "ignored") \ > +_ELF_DEFINE_DT(DT_FILTER, 0x7FFFFFFFUL, \ > + "index of string naming filtees") \ > +_ELF_DEFINE_DT(DT_HIPROC, 0x7FFFFFFFUL, \ > + "end of processor-specific types") > + > +#undef _ELF_DEFINE_DT > +#define _ELF_DEFINE_DT(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_DYN_TYPES() > + DT__LAST__ = DT_HIPROC > +}; > + > +#define DT_DEPRECATED_SPARC_REGISTER DT_SPARC_REGISTER > + > +/* > + * Flags used in the executable header (field: e_flags). > + */ > +#define _ELF_DEFINE_EHDR_FLAGS() > \ > +_ELF_DEFINE_EF(EF_ARM_RELEXEC, 0x00000001UL, \ > + "dynamic segment describes only how to relocate segments") \ > +_ELF_DEFINE_EF(EF_ARM_HASENTRY, 0x00000002UL, \ > + "e_entry contains a program entry point") \ > +_ELF_DEFINE_EF(EF_ARM_SYMSARESORTED, 0x00000004UL, \ > + "subsection of symbol table is sorted by symbol value") \ > +_ELF_DEFINE_EF(EF_ARM_DYNSYMSUSESEGIDX, 0x00000008UL, \ > + "dynamic symbol st_shndx = containing segment index + 1") \ > +_ELF_DEFINE_EF(EF_ARM_MAPSYMSFIRST, 0x00000010UL, \ > + "mapping symbols precede other local symbols in symtab") \ > +_ELF_DEFINE_EF(EF_ARM_BE8, 0x00800000UL, \ > + "file contains BE-8 code") \ > +_ELF_DEFINE_EF(EF_ARM_LE8, 0x00400000UL, \ > + "file contains LE-8 code") \ > +_ELF_DEFINE_EF(EF_ARM_EABIMASK, 0xFF000000UL, \ > + "mask for ARM EABI version number (0 denotes GNU or unknown)") \ > +_ELF_DEFINE_EF(EF_ARM_EABI_UNKNOWN, 0x00000000UL, \ > + "Unknown or GNU ARM EABI version number") \ > +_ELF_DEFINE_EF(EF_ARM_EABI_VER1, 0x01000000UL, \ > + "ARM EABI version 1") \ > +_ELF_DEFINE_EF(EF_ARM_EABI_VER2, 0x02000000UL, \ > + "ARM EABI version 2") \ > +_ELF_DEFINE_EF(EF_ARM_EABI_VER3, 0x03000000UL, \ > + "ARM EABI version 3") \ > +_ELF_DEFINE_EF(EF_ARM_EABI_VER4, 0x04000000UL, \ > + "ARM EABI version 4") \ > +_ELF_DEFINE_EF(EF_ARM_EABI_VER5, 0x05000000UL, \ > + "ARM EABI version 5") \ > +_ELF_DEFINE_EF(EF_ARM_INTERWORK, 0x00000004UL, \ > + "GNU EABI extension") \ > +_ELF_DEFINE_EF(EF_ARM_APCS_26, 0x00000008UL, \ > + "GNU EABI extension") \ > +_ELF_DEFINE_EF(EF_ARM_APCS_FLOAT, 0x00000010UL, \ > + "GNU EABI extension") \ > +_ELF_DEFINE_EF(EF_ARM_PIC, 0x00000020UL, \ > + "GNU EABI extension") \ > +_ELF_DEFINE_EF(EF_ARM_ALIGN8, 0x00000040UL, \ > + "GNU EABI extension") \ > +_ELF_DEFINE_EF(EF_ARM_NEW_ABI, 0x00000080UL, \ > + "GNU EABI extension") \ > +_ELF_DEFINE_EF(EF_ARM_OLD_ABI, 0x00000100UL, \ > + "GNU EABI extension") \ > +_ELF_DEFINE_EF(EF_ARM_SOFT_FLOAT, 0x00000200UL, \ > + "GNU EABI extension") \ > +_ELF_DEFINE_EF(EF_ARM_VFP_FLOAT, 0x00000400UL, \ > + "GNU EABI extension") \ > +_ELF_DEFINE_EF(EF_ARM_MAVERICK_FLOAT, 0x00000800UL, \ > + "GNU EABI extension") \ > +_ELF_DEFINE_EF(EF_MIPS_NOREORDER, 0x00000001UL, \ > + "at least one .noreorder directive appeared in the source") \ > +_ELF_DEFINE_EF(EF_MIPS_PIC, 0x00000002UL, \ > + "file contains position independent code") \ > +_ELF_DEFINE_EF(EF_MIPS_CPIC, 0x00000004UL, \ > + "file's code uses standard conventions for calling PIC") \ > +_ELF_DEFINE_EF(EF_MIPS_UCODE, 0x00000010UL, \ > + "file contains UCODE (obsolete)") \ > +_ELF_DEFINE_EF(EF_MIPS_ABI2, 0x00000020UL, \ > + "file follows MIPS III 32-bit ABI") \ > +_ELF_DEFINE_EF(EF_MIPS_OPTIONS_FIRST, 0x00000080UL, \ > + "ld(1) should process .MIPS.options section first") \ > +_ELF_DEFINE_EF(EF_MIPS_ARCH_ASE, 0x0F000000UL, \ > + "file uses application-specific architectural extensions") \ > +_ELF_DEFINE_EF(EF_MIPS_ARCH_ASE_MDMX, 0x08000000UL, \ > + "file uses MDMX multimedia extensions") \ > +_ELF_DEFINE_EF(EF_MIPS_ARCH_ASE_M16, 0x04000000UL, \ > + "file uses MIPS-16 ISA extensions") \ > +_ELF_DEFINE_EF(EF_MIPS_ARCH, 0xF0000000UL, \ > + "4-bit MIPS architecture field") \ > +_ELF_DEFINE_EF(EF_PPC_EMB, 0x80000000UL, \ > + "Embedded PowerPC flag") \ > +_ELF_DEFINE_EF(EF_PPC_RELOCATABLE, 0x00010000UL, \ > + "-mrelocatable flag") \ > +_ELF_DEFINE_EF(EF_PPC_RELOCATABLE_LIB, 0x00008000UL, \ > + "-mrelocatable-lib flag") \ > +_ELF_DEFINE_EF(EF_SPARC_EXT_MASK, 0x00ffff00UL, \ > + "Vendor Extension mask") \ > +_ELF_DEFINE_EF(EF_SPARC_32PLUS, 0x00000100UL, \ > + "Generic V8+ features") \ > +_ELF_DEFINE_EF(EF_SPARC_SUN_US1, 0x00000200UL, \ > + "Sun UltraSPARCTM 1 Extensions") \ > +_ELF_DEFINE_EF(EF_SPARC_HAL_R1, 0x00000400UL, "HAL R1 Extensions") \ > +_ELF_DEFINE_EF(EF_SPARC_SUN_US3, 0x00000800UL, \ > + "Sun UltraSPARC 3 Extensions") \ > +_ELF_DEFINE_EF(EF_SPARCV9_MM, 0x00000003UL, \ > + "Mask for Memory Model") \ > +_ELF_DEFINE_EF(EF_SPARCV9_TSO, 0x00000000UL, \ > + "Total Store Ordering") \ > +_ELF_DEFINE_EF(EF_SPARCV9_PSO, 0x00000001UL, \ > + "Partial Store Ordering") \ > +_ELF_DEFINE_EF(EF_SPARCV9_RMO, 0x00000002UL, \ > + "Relaxed Memory Ordering") > + > +#undef _ELF_DEFINE_EF > +#define _ELF_DEFINE_EF(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_EHDR_FLAGS() > + EF__LAST__ > +}; > + > +/* > + * Offsets in the `ei_ident[]` field of an ELF executable header. > + */ > +#define _ELF_DEFINE_EI_OFFSETS() \ > +_ELF_DEFINE_EI(EI_MAG0, 0, "magic number") \ > +_ELF_DEFINE_EI(EI_MAG1, 1, "magic number") \ > +_ELF_DEFINE_EI(EI_MAG2, 2, "magic number") \ > +_ELF_DEFINE_EI(EI_MAG3, 3, "magic number") \ > +_ELF_DEFINE_EI(EI_CLASS, 4, "file class") \ > +_ELF_DEFINE_EI(EI_DATA, 5, "data encoding") \ > +_ELF_DEFINE_EI(EI_VERSION, 6, "file version") \ > +_ELF_DEFINE_EI(EI_OSABI, 7, "OS ABI kind") \ > +_ELF_DEFINE_EI(EI_ABIVERSION, 8, "OS ABI version") \ > +_ELF_DEFINE_EI(EI_PAD, 9, "padding start") \ > +_ELF_DEFINE_EI(EI_NIDENT, 16, "total size") > + > +#undef _ELF_DEFINE_EI > +#define _ELF_DEFINE_EI(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_EI_OFFSETS() > + EI__LAST__ > +}; > + > +/* > + * The ELF class of an object. > + */ > +#define _ELF_DEFINE_ELFCLASS() \ > +_ELF_DEFINE_EC(ELFCLASSNONE, 0, "Unknown ELF class") \ > +_ELF_DEFINE_EC(ELFCLASS32, 1, "32 bit objects") \ > +_ELF_DEFINE_EC(ELFCLASS64, 2, "64 bit objects") > + > +#undef _ELF_DEFINE_EC > +#define _ELF_DEFINE_EC(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_ELFCLASS() > + EC__LAST__ > +}; > + > +/* > + * Endianness of data in an ELF object. > + */ > + > +#define _ELF_DEFINE_ELF_DATA_ENDIANNESS() \ > +_ELF_DEFINE_ED(ELFDATANONE, 0, "Unknown data endianness") \ > +_ELF_DEFINE_ED(ELFDATA2LSB, 1, "little endian") \ > +_ELF_DEFINE_ED(ELFDATA2MSB, 2, "big endian") > + > +#undef _ELF_DEFINE_ED > +#define _ELF_DEFINE_ED(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_ELF_DATA_ENDIANNESS() > + ED__LAST__ > +}; > + > +/* > + * Values of the magic numbers used in identification array. > + */ > +#define _ELF_DEFINE_ELF_MAGIC() \ > +_ELF_DEFINE_EMAG(ELFMAG0, 0x7FU) \ > +_ELF_DEFINE_EMAG(ELFMAG1, 'E') \ > +_ELF_DEFINE_EMAG(ELFMAG2, 'L') \ > +_ELF_DEFINE_EMAG(ELFMAG3, 'F') > + > +#undef _ELF_DEFINE_EMAG > +#define _ELF_DEFINE_EMAG(N, V) N = V , > +enum { > + _ELF_DEFINE_ELF_MAGIC() > + ELFMAG__LAST__ > +}; > + > +/* > + * ELF OS ABI field. > + */ > +#define _ELF_DEFINE_ELF_OSABI() > \ > +_ELF_DEFINE_EABI(ELFOSABI_NONE, 0, \ > + "No extensions or unspecified") \ > +_ELF_DEFINE_EABI(ELFOSABI_SYSV, 0, "SYSV") \ > +_ELF_DEFINE_EABI(ELFOSABI_HPUX, 1, "Hewlett-Packard HP-UX") \ > +_ELF_DEFINE_EABI(ELFOSABI_NETBSD, 2, "NetBSD") \ > +_ELF_DEFINE_EABI(ELFOSABI_GNU, 3, "GNU") > \ > +_ELF_DEFINE_EABI(ELFOSABI_HURD, 4, "GNU/HURD") \ > +_ELF_DEFINE_EABI(ELFOSABI_86OPEN, 5, "86Open Common ABI") \ > +_ELF_DEFINE_EABI(ELFOSABI_SOLARIS, 6, "Sun Solaris") > \ > +_ELF_DEFINE_EABI(ELFOSABI_AIX, 7, "AIX") > \ > +_ELF_DEFINE_EABI(ELFOSABI_IRIX, 8, "IRIX") \ > +_ELF_DEFINE_EABI(ELFOSABI_FREEBSD, 9, "FreeBSD") \ > +_ELF_DEFINE_EABI(ELFOSABI_TRU64, 10, "Compaq TRU64 UNIX") \ > +_ELF_DEFINE_EABI(ELFOSABI_MODESTO, 11, "Novell Modesto") \ > +_ELF_DEFINE_EABI(ELFOSABI_OPENBSD, 12, "Open BSD") \ > +_ELF_DEFINE_EABI(ELFOSABI_OPENVMS, 13, "Open VMS") \ > +_ELF_DEFINE_EABI(ELFOSABI_NSK, 14, \ > + "Hewlett-Packard Non-Stop Kernel") \ > +_ELF_DEFINE_EABI(ELFOSABI_AROS, 15, "Amiga Research OS") \ > +_ELF_DEFINE_EABI(ELFOSABI_FENIXOS, 16, \ > + "The FenixOS highly scalable multi-core OS") \ > +_ELF_DEFINE_EABI(ELFOSABI_ARM_AEABI, 64, \ > + "ARM specific symbol versioning extensions") \ > +_ELF_DEFINE_EABI(ELFOSABI_ARM, 97, "ARM ABI") \ > +_ELF_DEFINE_EABI(ELFOSABI_STANDALONE, 255, \ > + "Standalone (embedded) application") > + > +#undef _ELF_DEFINE_EABI > +#define _ELF_DEFINE_EABI(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_ELF_OSABI() > + ELFOSABI__LAST__ > +}; > + > +#define ELFOSABI_LINUX ELFOSABI_GNU > + > +/* > + * ELF Machine types: (EM_*). > + */ > +#define _ELF_DEFINE_ELF_MACHINES() > \ > +_ELF_DEFINE_EM(EM_NONE, 0, "No machine") \ > +_ELF_DEFINE_EM(EM_M32, 1, "AT&T WE 32100") > \ > +_ELF_DEFINE_EM(EM_SPARC, 2, "SPARC") > \ > +_ELF_DEFINE_EM(EM_386, 3, "Intel 80386") \ > +_ELF_DEFINE_EM(EM_68K, 4, "Motorola 68000") \ > +_ELF_DEFINE_EM(EM_88K, 5, "Motorola 88000") \ > +_ELF_DEFINE_EM(EM_IAMCU, 6, "Intel MCU") \ > +_ELF_DEFINE_EM(EM_860, 7, "Intel 80860") \ > +_ELF_DEFINE_EM(EM_MIPS, 8, "MIPS I Architecture") \ > +_ELF_DEFINE_EM(EM_S370, 9, "IBM System/370 Processor") \ > +_ELF_DEFINE_EM(EM_MIPS_RS3_LE, 10, "MIPS RS3000 Little-endian") \ > +_ELF_DEFINE_EM(EM_PARISC, 15, "Hewlett-Packard PA-RISC") \ > +_ELF_DEFINE_EM(EM_VPP500, 17, "Fujitsu VPP500") \ > +_ELF_DEFINE_EM(EM_SPARC32PLUS, 18, > \ > + "Enhanced instruction set SPARC") \ > +_ELF_DEFINE_EM(EM_960, 19, "Intel 80960") \ > +_ELF_DEFINE_EM(EM_PPC, 20, "PowerPC") \ > +_ELF_DEFINE_EM(EM_PPC64, 21, "64-bit PowerPC") \ > +_ELF_DEFINE_EM(EM_S390, 22, "IBM System/390 Processor") \ > +_ELF_DEFINE_EM(EM_SPU, 23, "IBM SPU/SPC") \ > +_ELF_DEFINE_EM(EM_V800, 36, "NEC V800") \ > +_ELF_DEFINE_EM(EM_FR20, 37, "Fujitsu FR20") > \ > +_ELF_DEFINE_EM(EM_RH32, 38, "TRW RH-32") \ > +_ELF_DEFINE_EM(EM_RCE, 39, "Motorola RCE") > \ > +_ELF_DEFINE_EM(EM_ARM, 40, "Advanced RISC Machines ARM") \ > +_ELF_DEFINE_EM(EM_ALPHA, 41, "Digital Alpha") \ > +_ELF_DEFINE_EM(EM_SH, 42, "Hitachi SH") \ > +_ELF_DEFINE_EM(EM_SPARCV9, 43, "SPARC Version 9") \ > +_ELF_DEFINE_EM(EM_TRICORE, 44, > \ > + "Siemens TriCore embedded processor") \ > +_ELF_DEFINE_EM(EM_ARC, 45, > \ > + "Argonaut RISC Core, Argonaut Technologies Inc.") \ > +_ELF_DEFINE_EM(EM_H8_300, 46, "Hitachi H8/300") \ > +_ELF_DEFINE_EM(EM_H8_300H, 47, "Hitachi H8/300H") \ > +_ELF_DEFINE_EM(EM_H8S, 48, "Hitachi H8S") \ > +_ELF_DEFINE_EM(EM_H8_500, 49, "Hitachi H8/500") \ > +_ELF_DEFINE_EM(EM_IA_64, 50, > \ > + "Intel IA-64 processor architecture") \ > +_ELF_DEFINE_EM(EM_MIPS_X, 51, "Stanford MIPS-X") \ > +_ELF_DEFINE_EM(EM_COLDFIRE, 52, "Motorola ColdFire") \ > +_ELF_DEFINE_EM(EM_68HC12, 53, "Motorola M68HC12") \ > +_ELF_DEFINE_EM(EM_MMA, 54, > \ > + "Fujitsu MMA Multimedia Accelerator") \ > +_ELF_DEFINE_EM(EM_PCP, 55, "Siemens PCP") \ > +_ELF_DEFINE_EM(EM_NCPU, 56, > \ > + "Sony nCPU embedded RISC processor") \ > +_ELF_DEFINE_EM(EM_NDR1, 57, "Denso NDR1 microprocessor") \ > +_ELF_DEFINE_EM(EM_STARCORE, 58, "Motorola Star*Core processor") > \ > +_ELF_DEFINE_EM(EM_ME16, 59, "Toyota ME16 processor") \ > +_ELF_DEFINE_EM(EM_ST100, 60, > \ > + "STMicroelectronics ST100 processor") \ > +_ELF_DEFINE_EM(EM_TINYJ, 61, > \ > + "Advanced Logic Corp. TinyJ embedded processor family") \ > +_ELF_DEFINE_EM(EM_X86_64, 62, "AMD x86-64 architecture") \ > +_ELF_DEFINE_EM(EM_PDSP, 63, "Sony DSP Processor") \ > +_ELF_DEFINE_EM(EM_PDP10, 64, > \ > + "Digital Equipment Corp. PDP-10") \ > +_ELF_DEFINE_EM(EM_PDP11, 65, > \ > + "Digital Equipment Corp. PDP-11") \ > +_ELF_DEFINE_EM(EM_FX66, 66, "Siemens FX66 microcontroller") > \ > +_ELF_DEFINE_EM(EM_ST9PLUS, 67, > \ > + "STMicroelectronics ST9+ 8/16 bit microcontroller") \ > +_ELF_DEFINE_EM(EM_ST7, 68, > \ > + "STMicroelectronics ST7 8-bit microcontroller") \ > +_ELF_DEFINE_EM(EM_68HC16, 69, > \ > + "Motorola MC68HC16 Microcontroller") \ > +_ELF_DEFINE_EM(EM_68HC11, 70, > \ > + "Motorola MC68HC11 Microcontroller") \ > +_ELF_DEFINE_EM(EM_68HC08, 71, > \ > + "Motorola MC68HC08 Microcontroller") \ > +_ELF_DEFINE_EM(EM_68HC05, 72, > \ > + "Motorola MC68HC05 Microcontroller") \ > +_ELF_DEFINE_EM(EM_SVX, 73, "Silicon Graphics SVx") > \ > +_ELF_DEFINE_EM(EM_ST19, 74, > \ > + "STMicroelectronics ST19 8-bit microcontroller") \ > +_ELF_DEFINE_EM(EM_VAX, 75, "Digital VAX") \ > +_ELF_DEFINE_EM(EM_CRIS, 76, > \ > + "Axis Communications 32-bit embedded processor") \ > +_ELF_DEFINE_EM(EM_JAVELIN, 77, > \ > + "Infineon Technologies 32-bit embedded processor") \ > +_ELF_DEFINE_EM(EM_FIREPATH, 78, > \ > + "Element 14 64-bit DSP Processor") \ > +_ELF_DEFINE_EM(EM_ZSP, 79, > \ > + "LSI Logic 16-bit DSP Processor") \ > +_ELF_DEFINE_EM(EM_MMIX, 80, > \ > + "Donald Knuth's educational 64-bit processor") \ > +_ELF_DEFINE_EM(EM_HUANY, 81, > \ > + "Harvard University machine-independent object files") \ > +_ELF_DEFINE_EM(EM_PRISM, 82, "SiTera Prism") > \ > +_ELF_DEFINE_EM(EM_AVR, 83, > \ > + "Atmel AVR 8-bit microcontroller") \ > +_ELF_DEFINE_EM(EM_FR30, 84, "Fujitsu FR30") > \ > +_ELF_DEFINE_EM(EM_D10V, 85, "Mitsubishi D10V") \ > +_ELF_DEFINE_EM(EM_D30V, 86, "Mitsubishi D30V") \ > +_ELF_DEFINE_EM(EM_V850, 87, "NEC v850") \ > +_ELF_DEFINE_EM(EM_M32R, 88, "Mitsubishi M32R") \ > +_ELF_DEFINE_EM(EM_MN10300, 89, "Matsushita MN10300") \ > +_ELF_DEFINE_EM(EM_MN10200, 90, "Matsushita MN10200") \ > +_ELF_DEFINE_EM(EM_PJ, 91, "picoJava") \ > +_ELF_DEFINE_EM(EM_OPENRISC, 92, > \ > + "OpenRISC 32-bit embedded processor") \ > +_ELF_DEFINE_EM(EM_ARC_COMPACT, 93, > \ > + "ARC International ARCompact processor") \ > +_ELF_DEFINE_EM(EM_XTENSA, 94, > \ > + "Tensilica Xtensa Architecture") \ > +_ELF_DEFINE_EM(EM_VIDEOCORE, 95, > \ > + "Alphamosaic VideoCore processor") \ > +_ELF_DEFINE_EM(EM_TMM_GPP, 96, > \ > + "Thompson Multimedia General Purpose Processor") \ > +_ELF_DEFINE_EM(EM_NS32K, 97, > \ > + "National Semiconductor 32000 series") \ > +_ELF_DEFINE_EM(EM_TPC, 98, "Tenor Network TPC processor") \ > +_ELF_DEFINE_EM(EM_SNP1K, 99, "Trebia SNP 1000 processor") \ > +_ELF_DEFINE_EM(EM_ST200, 100, \ > + "STMicroelectronics (www.st.com) ST200 microcontroller") \ > +_ELF_DEFINE_EM(EM_IP2K, 101, \ > + "Ubicom IP2xxx microcontroller family") \ > +_ELF_DEFINE_EM(EM_MAX, 102, "MAX Processor") \ > +_ELF_DEFINE_EM(EM_CR, 103, \ > + "National Semiconductor CompactRISC microprocessor") \ > +_ELF_DEFINE_EM(EM_F2MC16, 104, "Fujitsu F2MC16") \ > +_ELF_DEFINE_EM(EM_MSP430, 105, \ > + "Texas Instruments embedded microcontroller msp430") \ > +_ELF_DEFINE_EM(EM_BLACKFIN, 106, \ > + "Analog Devices Blackfin (DSP) processor") \ > +_ELF_DEFINE_EM(EM_SE_C33, 107, \ > + "S1C33 Family of Seiko Epson processors") \ > +_ELF_DEFINE_EM(EM_SEP, 108, \ > + "Sharp embedded microprocessor") \ > +_ELF_DEFINE_EM(EM_ARCA, 109, "Arca RISC Microprocessor") \ > +_ELF_DEFINE_EM(EM_UNICORE, 110, \ > + "Microprocessor series from PKU-Unity Ltd. and MPRC of Peking > University") \ > +_ELF_DEFINE_EM(EM_EXCESS, 111, \ > + "eXcess: 16/32/64-bit configurable embedded CPU") \ > +_ELF_DEFINE_EM(EM_DXP, 112, \ > + "Icera Semiconductor Inc. Deep Execution Processor") \ > +_ELF_DEFINE_EM(EM_ALTERA_NIOS2, 113, \ > + "Altera Nios II soft-core processor") \ > +_ELF_DEFINE_EM(EM_CRX, 114, \ > + "National Semiconductor CompactRISC CRX microprocessor") \ > +_ELF_DEFINE_EM(EM_XGATE, 115, \ > + "Motorola XGATE embedded processor") \ > +_ELF_DEFINE_EM(EM_C166, 116, \ > + "Infineon C16x/XC16x processor") \ > +_ELF_DEFINE_EM(EM_M16C, 117, \ > + "Renesas M16C series microprocessors") \ > +_ELF_DEFINE_EM(EM_DSPIC30F, 118, \ > + "Microchip Technology dsPIC30F Digital Signal Controller") \ > +_ELF_DEFINE_EM(EM_CE, 119, \ > + "Freescale Communication Engine RISC core") \ > +_ELF_DEFINE_EM(EM_M32C, 120, \ > + "Renesas M32C series microprocessors") \ > +_ELF_DEFINE_EM(EM_TSK3000, 131, "Altium TSK3000 core") > \ > +_ELF_DEFINE_EM(EM_RS08, 132, \ > + "Freescale RS08 embedded processor") \ > +_ELF_DEFINE_EM(EM_SHARC, 133, \ > + "Analog Devices SHARC family of 32-bit DSP processors") \ > +_ELF_DEFINE_EM(EM_ECOG2, 134, \ > + "Cyan Technology eCOG2 microprocessor") \ > +_ELF_DEFINE_EM(EM_SCORE7, 135, \ > + "Sunplus S+core7 RISC processor") \ > +_ELF_DEFINE_EM(EM_DSP24, 136, \ > + "New Japan Radio (NJR) 24-bit DSP Processor") \ > +_ELF_DEFINE_EM(EM_VIDEOCORE3, 137, \ > + "Broadcom VideoCore III processor") \ > +_ELF_DEFINE_EM(EM_LATTICEMICO32, 138, \ > + "RISC processor for Lattice FPGA architecture") \ > +_ELF_DEFINE_EM(EM_SE_C17, 139, "Seiko Epson C17 family") \ > +_ELF_DEFINE_EM(EM_TI_C6000, 140, \ > + "The Texas Instruments TMS320C6000 DSP family") \ > +_ELF_DEFINE_EM(EM_TI_C2000, 141, \ > + "The Texas Instruments TMS320C2000 DSP family") \ > +_ELF_DEFINE_EM(EM_TI_C5500, 142, \ > + "The Texas Instruments TMS320C55x DSP family") \ > +_ELF_DEFINE_EM(EM_MMDSP_PLUS, 160, \ > + "STMicroelectronics 64bit VLIW Data Signal Processor") \ > +_ELF_DEFINE_EM(EM_CYPRESS_M8C, 161, "Cypress M8C microprocessor") \ > +_ELF_DEFINE_EM(EM_R32C, 162, \ > + "Renesas R32C series microprocessors") \ > +_ELF_DEFINE_EM(EM_TRIMEDIA, 163, \ > + "NXP Semiconductors TriMedia architecture family") \ > +_ELF_DEFINE_EM(EM_QDSP6, 164, "QUALCOMM DSP6 Processor") \ > +_ELF_DEFINE_EM(EM_8051, 165, "Intel 8051 and variants") \ > +_ELF_DEFINE_EM(EM_STXP7X, 166, \ > + "STMicroelectronics STxP7x family of configurable and extensible RISC > processors") \ > +_ELF_DEFINE_EM(EM_NDS32, 167, \ > + "Andes Technology compact code size embedded RISC processor family") \ > +_ELF_DEFINE_EM(EM_ECOG1, 168, \ > + "Cyan Technology eCOG1X family") \ > +_ELF_DEFINE_EM(EM_ECOG1X, 168, \ > + "Cyan Technology eCOG1X family") \ > +_ELF_DEFINE_EM(EM_MAXQ30, 169, \ > + "Dallas Semiconductor MAXQ30 Core Micro-controllers") \ > +_ELF_DEFINE_EM(EM_XIMO16, 170, \ > + "New Japan Radio (NJR) 16-bit DSP Processor") \ > +_ELF_DEFINE_EM(EM_MANIK, 171, \ > + "M2000 Reconfigurable RISC Microprocessor") \ > +_ELF_DEFINE_EM(EM_CRAYNV2, 172, \ > + "Cray Inc. NV2 vector architecture") \ > +_ELF_DEFINE_EM(EM_RX, 173, "Renesas RX family") \ > +_ELF_DEFINE_EM(EM_METAG, 174, \ > + "Imagination Technologies META processor architecture") \ > +_ELF_DEFINE_EM(EM_MCST_ELBRUS, 175, \ > + "MCST Elbrus general purpose hardware architecture") \ > +_ELF_DEFINE_EM(EM_ECOG16, 176, \ > + "Cyan Technology eCOG16 family") \ > +_ELF_DEFINE_EM(EM_CR16, 177, \ > + "National Semiconductor CompactRISC CR16 16-bit microprocessor") \ > +_ELF_DEFINE_EM(EM_ETPU, 178, \ > + "Freescale Extended Time Processing Unit") \ > +_ELF_DEFINE_EM(EM_SLE9X, 179, \ > + "Infineon Technologies SLE9X core") \ > +_ELF_DEFINE_EM(EM_AARCH64, 183, \ > + "AArch64 (64-bit ARM)") \ > +_ELF_DEFINE_EM(EM_AVR32, 185, \ > + "Atmel Corporation 32-bit microprocessor family") \ > +_ELF_DEFINE_EM(EM_STM8, 186, \ > + "STMicroeletronics STM8 8-bit microcontroller") \ > +_ELF_DEFINE_EM(EM_TILE64, 187, \ > + "Tilera TILE64 multicore architecture family") \ > +_ELF_DEFINE_EM(EM_TILEPRO, 188, \ > + "Tilera TILEPro multicore architecture family") \ > +_ELF_DEFINE_EM(EM_MICROBLAZE, 189, \ > + "Xilinx MicroBlaze 32-bit RISC soft processor core") \ > +_ELF_DEFINE_EM(EM_CUDA, 190, "NVIDIA CUDA architecture") \ > +_ELF_DEFINE_EM(EM_TILEGX, 191, \ > + "Tilera TILE-Gx multicore architecture family") \ > +_ELF_DEFINE_EM(EM_CLOUDSHIELD, 192, \ > + "CloudShield architecture family") \ > +_ELF_DEFINE_EM(EM_COREA_1ST, 193, \ > + "KIPO-KAIST Core-A 1st generation processor family") \ > +_ELF_DEFINE_EM(EM_COREA_2ND, 194, \ > + "KIPO-KAIST Core-A 2nd generation processor family") \ > +_ELF_DEFINE_EM(EM_ARC_COMPACT2, 195, "Synopsys ARCompact V2") \ > +_ELF_DEFINE_EM(EM_OPEN8, 196, \ > + "Open8 8-bit RISC soft processor core") \ > +_ELF_DEFINE_EM(EM_RL78, 197, "Renesas RL78 family") > \ > +_ELF_DEFINE_EM(EM_VIDEOCORE5, 198, "Broadcom VideoCore V processor") \ > +_ELF_DEFINE_EM(EM_78KOR, 199, "Renesas 78KOR family") \ > +_ELF_DEFINE_EM(EM_56800EX, 200, \ > + "Freescale 56800EX Digital Signal Controller") \ > +_ELF_DEFINE_EM(EM_BA1, 201, "Beyond BA1 CPU architecture") > \ > +_ELF_DEFINE_EM(EM_BA2, 202, "Beyond BA2 CPU architecture") > \ > +_ELF_DEFINE_EM(EM_XCORE, 203, "XMOS xCORE processor family") \ > +_ELF_DEFINE_EM(EM_MCHP_PIC, 204, "Microchip 8-bit PIC(r) family") \ > +_ELF_DEFINE_EM(EM_INTEL205, 205, "Reserved by Intel") \ > +_ELF_DEFINE_EM(EM_INTEL206, 206, "Reserved by Intel") \ > +_ELF_DEFINE_EM(EM_INTEL207, 207, "Reserved by Intel") \ > +_ELF_DEFINE_EM(EM_INTEL208, 208, "Reserved by Intel") \ > +_ELF_DEFINE_EM(EM_INTEL209, 209, "Reserved by Intel") \ > +_ELF_DEFINE_EM(EM_KM32, 210, "KM211 KM32 32-bit processor") \ > +_ELF_DEFINE_EM(EM_KMX32, 211, "KM211 KMX32 32-bit processor") \ > +_ELF_DEFINE_EM(EM_KMX16, 212, "KM211 KMX16 16-bit processor") \ > +_ELF_DEFINE_EM(EM_KMX8, 213, "KM211 KMX8 8-bit processor") \ > +_ELF_DEFINE_EM(EM_KVARC, 214, "KM211 KMX32 KVARC processor") \ > +_ELF_DEFINE_EM(EM_RISCV, 243, "RISC-V") > + > +#undef _ELF_DEFINE_EM > +#define _ELF_DEFINE_EM(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_ELF_MACHINES() > + EM__LAST__ > +}; > + > +/* Other synonyms. */ > +#define EM_AMD64 EM_X86_64 > +#define EM_ARC_A5 EM_ARC_COMPACT > + > +/* > + * ELF file types: (ET_*). > + */ > +#define _ELF_DEFINE_ELF_TYPES() > \ > +_ELF_DEFINE_ET(ET_NONE, 0, "No file type") \ > +_ELF_DEFINE_ET(ET_REL, 1, "Relocatable object") \ > +_ELF_DEFINE_ET(ET_EXEC, 2, "Executable") \ > +_ELF_DEFINE_ET(ET_DYN, 3, "Shared object") \ > +_ELF_DEFINE_ET(ET_CORE, 4, "Core file") \ > +_ELF_DEFINE_ET(ET_LOOS, 0xFE00U, "Begin OS-specific range") \ > +_ELF_DEFINE_ET(ET_HIOS, 0xFEFFU, "End OS-specific range") \ > +_ELF_DEFINE_ET(ET_LOPROC, 0xFF00U, "Begin processor-specific range") \ > +_ELF_DEFINE_ET(ET_HIPROC, 0xFFFFU, "End processor-specific range") > + > +#undef _ELF_DEFINE_ET > +#define _ELF_DEFINE_ET(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_ELF_TYPES() > + ET__LAST__ > +}; > + > +/* ELF file format version numbers. */ > +#define EV_NONE 0 > +#define EV_CURRENT 1 > + > +/* > + * Flags for section groups. > + */ > +#define GRP_COMDAT 0x1 /* COMDAT semantics */ > +#define GRP_MASKOS 0x0ff00000 /* OS-specific flags */ > +#define GRP_MASKPROC 0xf0000000 /* processor-specific flags */ > + > +/* > + * Flags / mask for .gnu.versym sections. > + */ > +#define VERSYM_VERSION 0x7fff > +#define VERSYM_HIDDEN 0x8000 > + > +/* > + * Flags used by program header table entries. > + */ > + > +#define _ELF_DEFINE_PHDR_FLAGS() > \ > +_ELF_DEFINE_PF(PF_X, 0x1, "Execute") \ > +_ELF_DEFINE_PF(PF_W, 0x2, "Write") \ > +_ELF_DEFINE_PF(PF_R, 0x4, "Read") \ > +_ELF_DEFINE_PF(PF_MASKOS, 0x0ff00000, "OS-specific flags") \ > +_ELF_DEFINE_PF(PF_MASKPROC, 0xf0000000, "Processor-specific flags") \ > +_ELF_DEFINE_PF(PF_ARM_SB, 0x10000000, > \ > + "segment contains the location addressed by the static base") \ > +_ELF_DEFINE_PF(PF_ARM_PI, 0x20000000, > \ > + "segment is position-independent") \ > +_ELF_DEFINE_PF(PF_ARM_ABS, 0x40000000, > \ > + "segment must be loaded at its base address") > + > +#undef _ELF_DEFINE_PF > +#define _ELF_DEFINE_PF(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_PHDR_FLAGS() > + PF__LAST__ > +}; > + > +/* > + * Types of program header table entries. > + */ > + > +#define _ELF_DEFINE_PHDR_TYPES() \ > +_ELF_DEFINE_PT(PT_NULL, 0, "ignored entry") \ > +_ELF_DEFINE_PT(PT_LOAD, 1, "loadable segment") \ > +_ELF_DEFINE_PT(PT_DYNAMIC, 2, \ > + "contains dynamic linking information") \ > +_ELF_DEFINE_PT(PT_INTERP, 3, "names an interpreter") \ > +_ELF_DEFINE_PT(PT_NOTE, 4, "auxiliary information") \ > +_ELF_DEFINE_PT(PT_SHLIB, 5, "reserved") \ > +_ELF_DEFINE_PT(PT_PHDR, 6, \ > + "describes the program header itself") \ > +_ELF_DEFINE_PT(PT_TLS, 7, "thread local storage") \ > +_ELF_DEFINE_PT(PT_LOOS, 0x60000000UL, \ > + "start of OS-specific range") \ > +_ELF_DEFINE_PT(PT_SUNW_UNWIND, 0x6464E550UL, \ > + "Solaris/amd64 stack unwind tables") \ > +_ELF_DEFINE_PT(PT_GNU_EH_FRAME, 0x6474E550UL, \ > + "GCC generated .eh_frame_hdr segment") \ > +_ELF_DEFINE_PT(PT_GNU_STACK, 0x6474E551UL, \ > + "Stack flags") \ > +_ELF_DEFINE_PT(PT_GNU_RELRO, 0x6474E552UL, \ > + "Segment becomes read-only after relocation") \ > +_ELF_DEFINE_PT(PT_SUNWBSS, 0x6FFFFFFAUL, \ > + "A Solaris .SUNW_bss section") \ > +_ELF_DEFINE_PT(PT_SUNWSTACK, 0x6FFFFFFBUL, \ > + "A Solaris process stack") \ > +_ELF_DEFINE_PT(PT_SUNWDTRACE, 0x6FFFFFFCUL, \ > + "Used by dtrace(1)") \ > +_ELF_DEFINE_PT(PT_SUNWCAP, 0x6FFFFFFDUL, \ > + "Special hardware capability requirements") \ > +_ELF_DEFINE_PT(PT_HIOS, 0x6FFFFFFFUL, \ > + "end of OS-specific range") \ > +_ELF_DEFINE_PT(PT_LOPROC, 0x70000000UL, \ > + "start of processor-specific range") \ > +_ELF_DEFINE_PT(PT_ARM_ARCHEXT, 0x70000000UL, \ > + "platform architecture compatibility information") \ > +_ELF_DEFINE_PT(PT_ARM_EXIDX, 0x70000001UL, \ > + "exception unwind tables") \ > +_ELF_DEFINE_PT(PT_MIPS_REGINFO, 0x70000000UL, \ > + "register usage information") \ > +_ELF_DEFINE_PT(PT_MIPS_RTPROC, 0x70000001UL, \ > + "runtime procedure table") \ > +_ELF_DEFINE_PT(PT_MIPS_OPTIONS, 0x70000002UL, \ > + "options segment") \ > +_ELF_DEFINE_PT(PT_HIPROC, 0x7FFFFFFFUL, \ > + "end of processor-specific range") > + > +#undef _ELF_DEFINE_PT > +#define _ELF_DEFINE_PT(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_PHDR_TYPES() > + PT__LAST__ = PT_HIPROC > +}; > + > +/* synonyms. */ > +#define PT_ARM_UNWIND PT_ARM_EXIDX > +#define PT_HISUNW PT_HIOS > +#define PT_LOSUNW PT_SUNWBSS > + > +/* > + * Section flags. > + */ > + > +#define _ELF_DEFINE_SECTION_FLAGS() > \ > +_ELF_DEFINE_SHF(SHF_WRITE, 0x1, \ > + "writable during program execution") \ > +_ELF_DEFINE_SHF(SHF_ALLOC, 0x2, \ > + "occupies memory during program execution") \ > +_ELF_DEFINE_SHF(SHF_EXECINSTR, 0x4, "executable instructions") \ > +_ELF_DEFINE_SHF(SHF_MERGE, 0x10, \ > + "may be merged to prevent duplication") \ > +_ELF_DEFINE_SHF(SHF_STRINGS, 0x20, \ > + "NUL-terminated character strings") \ > +_ELF_DEFINE_SHF(SHF_INFO_LINK, 0x40, \ > + "the sh_info field holds a link") \ > +_ELF_DEFINE_SHF(SHF_LINK_ORDER, 0x80, \ > + "special ordering requirements during linking") \ > +_ELF_DEFINE_SHF(SHF_OS_NONCONFORMING, 0x100, \ > + "requires OS-specific processing during linking") \ > +_ELF_DEFINE_SHF(SHF_GROUP, 0x200, \ > + "member of a section group") \ > +_ELF_DEFINE_SHF(SHF_TLS, 0x400, \ > + "holds thread-local storage") \ > +_ELF_DEFINE_SHF(SHF_COMPRESSED, 0x800, \ > + "holds compressed data") \ > +_ELF_DEFINE_SHF(SHF_MASKOS, 0x0FF00000UL, \ > + "bits reserved for OS-specific semantics") \ > +_ELF_DEFINE_SHF(SHF_AMD64_LARGE, 0x10000000UL, \ > + "section uses large code model") \ > +_ELF_DEFINE_SHF(SHF_ENTRYSECT, 0x10000000UL, \ > + "section contains an entry point (ARM)") \ > +_ELF_DEFINE_SHF(SHF_COMDEF, 0x80000000UL, \ > + "section may be multiply defined in input to link step (ARM)") \ > +_ELF_DEFINE_SHF(SHF_MIPS_GPREL, 0x10000000UL, \ > + "section must be part of global data area") \ > +_ELF_DEFINE_SHF(SHF_MIPS_MERGE, 0x20000000UL, \ > + "section data should be merged to eliminate duplication") \ > +_ELF_DEFINE_SHF(SHF_MIPS_ADDR, 0x40000000UL, \ > + "section data is addressed by default") \ > +_ELF_DEFINE_SHF(SHF_MIPS_STRING, 0x80000000UL, \ > + "section data is string data by default") \ > +_ELF_DEFINE_SHF(SHF_MIPS_NOSTRIP, 0x08000000UL, \ > + "section data may not be stripped") \ > +_ELF_DEFINE_SHF(SHF_MIPS_LOCAL, 0x04000000UL, \ > + "section data local to process") \ > +_ELF_DEFINE_SHF(SHF_MIPS_NAMES, 0x02000000UL, \ > + "linker must generate implicit hidden weak names") \ > +_ELF_DEFINE_SHF(SHF_MIPS_NODUPE, 0x01000000UL, \ > + "linker must retain only one copy") \ > +_ELF_DEFINE_SHF(SHF_ORDERED, 0x40000000UL, \ > + "section is ordered with respect to other sections") \ > +_ELF_DEFINE_SHF(SHF_EXCLUDE, 0x80000000UL, \ > + "section is excluded from executables and shared objects") \ > +_ELF_DEFINE_SHF(SHF_MASKPROC, 0xF0000000UL, \ > + "bits reserved for processor-specific semantics") > + > +#undef _ELF_DEFINE_SHF > +#define _ELF_DEFINE_SHF(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_SECTION_FLAGS() > + SHF__LAST__ > +}; > + > +/* > + * Special section indices. > + */ > +#define _ELF_DEFINE_SECTION_INDICES() \ > +_ELF_DEFINE_SHN(SHN_UNDEF, 0, "undefined section") \ > +_ELF_DEFINE_SHN(SHN_LORESERVE, 0xFF00U, "start of reserved area") > \ > +_ELF_DEFINE_SHN(SHN_LOPROC, 0xFF00U, \ > + "start of processor-specific range") \ > +_ELF_DEFINE_SHN(SHN_BEFORE, 0xFF00U, "used for section ordering") \ > +_ELF_DEFINE_SHN(SHN_AFTER, 0xFF01U, "used for section ordering") \ > +_ELF_DEFINE_SHN(SHN_AMD64_LCOMMON, 0xFF02U, "large common block label") \ > +_ELF_DEFINE_SHN(SHN_MIPS_ACOMMON, 0xFF00U, \ > + "allocated common symbols in a DSO") \ > +_ELF_DEFINE_SHN(SHN_MIPS_TEXT, 0xFF01U, "Reserved (obsolete)") \ > +_ELF_DEFINE_SHN(SHN_MIPS_DATA, 0xFF02U, "Reserved (obsolete)") \ > +_ELF_DEFINE_SHN(SHN_MIPS_SCOMMON, 0xFF03U, \ > + "gp-addressable common symbols") \ > +_ELF_DEFINE_SHN(SHN_MIPS_SUNDEFINED, 0xFF04U, \ > + "gp-addressable undefined symbols") \ > +_ELF_DEFINE_SHN(SHN_MIPS_LCOMMON, 0xFF05U, "local common symbols") \ > +_ELF_DEFINE_SHN(SHN_MIPS_LUNDEFINED, 0xFF06U, \ > + "local undefined symbols") \ > +_ELF_DEFINE_SHN(SHN_HIPROC, 0xFF1FU, \ > + "end of processor-specific range") \ > +_ELF_DEFINE_SHN(SHN_LOOS, 0xFF20U, \ > + "start of OS-specific range") \ > +_ELF_DEFINE_SHN(SHN_SUNW_IGNORE, 0xFF3FU, "used by dtrace") \ > +_ELF_DEFINE_SHN(SHN_HIOS, 0xFF3FU, \ > + "end of OS-specific range") \ > +_ELF_DEFINE_SHN(SHN_ABS, 0xFFF1U, "absolute references") \ > +_ELF_DEFINE_SHN(SHN_COMMON, 0xFFF2U, "references to COMMON areas") \ > +_ELF_DEFINE_SHN(SHN_XINDEX, 0xFFFFU, "extended index") \ > +_ELF_DEFINE_SHN(SHN_HIRESERVE, 0xFFFFU, "end of reserved area") > + > +#undef _ELF_DEFINE_SHN > +#define _ELF_DEFINE_SHN(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_SECTION_INDICES() > + SHN__LAST__ > +}; > + > +/* > + * Section types. > + */ > + > +#define _ELF_DEFINE_SECTION_TYPES() > \ > +_ELF_DEFINE_SHT(SHT_NULL, 0, "inactive header") \ > +_ELF_DEFINE_SHT(SHT_PROGBITS, 1, "program defined information") \ > +_ELF_DEFINE_SHT(SHT_SYMTAB, 2, "symbol table") > \ > +_ELF_DEFINE_SHT(SHT_STRTAB, 3, "string table") > \ > +_ELF_DEFINE_SHT(SHT_RELA, 4, > \ > + "relocation entries with addends") \ > +_ELF_DEFINE_SHT(SHT_HASH, 5, "symbol hash table") \ > +_ELF_DEFINE_SHT(SHT_DYNAMIC, 6, > \ > + "information for dynamic linking") \ > +_ELF_DEFINE_SHT(SHT_NOTE, 7, "additional notes") \ > +_ELF_DEFINE_SHT(SHT_NOBITS, 8, "section occupying no space") \ > +_ELF_DEFINE_SHT(SHT_REL, 9, > \ > + "relocation entries without addends") \ > +_ELF_DEFINE_SHT(SHT_SHLIB, 10, "reserved") \ > +_ELF_DEFINE_SHT(SHT_DYNSYM, 11, "symbol table") \ > +_ELF_DEFINE_SHT(SHT_INIT_ARRAY, 14, \ > + "pointers to initialization functions") \ > +_ELF_DEFINE_SHT(SHT_FINI_ARRAY, 15, \ > + "pointers to termination functions") \ > +_ELF_DEFINE_SHT(SHT_PREINIT_ARRAY, 16, \ > + "pointers to functions called before initialization") \ > +_ELF_DEFINE_SHT(SHT_GROUP, 17, "defines a section group") \ > +_ELF_DEFINE_SHT(SHT_SYMTAB_SHNDX, 18, \ > + "used for extended section numbering") \ > +_ELF_DEFINE_SHT(SHT_LOOS, 0x60000000UL, \ > + "start of OS-specific range") \ > +_ELF_DEFINE_SHT(SHT_SUNW_dof, 0x6FFFFFF4UL, \ > + "used by dtrace") \ > +_ELF_DEFINE_SHT(SHT_SUNW_cap, 0x6FFFFFF5UL, \ > + "capability requirements") \ > +_ELF_DEFINE_SHT(SHT_GNU_ATTRIBUTES, 0x6FFFFFF5UL, \ > + "object attributes") \ > +_ELF_DEFINE_SHT(SHT_SUNW_SIGNATURE, 0x6FFFFFF6UL, \ > + "module verification signature") \ > +_ELF_DEFINE_SHT(SHT_GNU_HASH, 0x6FFFFFF6UL, \ > + "GNU Hash sections") \ > +_ELF_DEFINE_SHT(SHT_GNU_LIBLIST, 0x6FFFFFF7UL, \ > + "List of libraries to be prelinked") \ > +_ELF_DEFINE_SHT(SHT_SUNW_ANNOTATE, 0x6FFFFFF7UL, \ > + "special section where unresolved references are allowed") \ > +_ELF_DEFINE_SHT(SHT_SUNW_DEBUGSTR, 0x6FFFFFF8UL, \ > + "debugging information") \ > +_ELF_DEFINE_SHT(SHT_CHECKSUM, 0x6FFFFFF8UL, \ > + "checksum for dynamic shared objects") \ > +_ELF_DEFINE_SHT(SHT_SUNW_DEBUG, 0x6FFFFFF9UL, \ > + "debugging information") \ > +_ELF_DEFINE_SHT(SHT_SUNW_move, 0x6FFFFFFAUL, \ > + "information to handle partially initialized symbols") \ > +_ELF_DEFINE_SHT(SHT_SUNW_COMDAT, 0x6FFFFFFBUL, \ > + "section supporting merging of multiple copies of data") \ > +_ELF_DEFINE_SHT(SHT_SUNW_syminfo, 0x6FFFFFFCUL, \ > + "additional symbol information") \ > +_ELF_DEFINE_SHT(SHT_SUNW_verdef, 0x6FFFFFFDUL, \ > + "symbol versioning information") \ > +_ELF_DEFINE_SHT(SHT_SUNW_verneed, 0x6FFFFFFEUL, \ > + "symbol versioning requirements") \ > +_ELF_DEFINE_SHT(SHT_SUNW_versym, 0x6FFFFFFFUL, \ > + "symbol versioning table") \ > +_ELF_DEFINE_SHT(SHT_HIOS, 0x6FFFFFFFUL, \ > + "end of OS-specific range") \ > +_ELF_DEFINE_SHT(SHT_LOPROC, 0x70000000UL, \ > + "start of processor-specific range") \ > +_ELF_DEFINE_SHT(SHT_ARM_EXIDX, 0x70000001UL, \ > + "exception index table") \ > +_ELF_DEFINE_SHT(SHT_ARM_PREEMPTMAP, 0x70000002UL, \ > + "BPABI DLL dynamic linking preemption map") \ > +_ELF_DEFINE_SHT(SHT_ARM_ATTRIBUTES, 0x70000003UL, \ > + "object file compatibility attributes") \ > +_ELF_DEFINE_SHT(SHT_ARM_DEBUGOVERLAY, 0x70000004UL, \ > + "overlay debug information") \ > +_ELF_DEFINE_SHT(SHT_ARM_OVERLAYSECTION, 0x70000005UL, \ > + "overlay debug information") \ > +_ELF_DEFINE_SHT(SHT_MIPS_LIBLIST, 0x70000000UL, \ > + "DSO library information used in link") \ > +_ELF_DEFINE_SHT(SHT_MIPS_MSYM, 0x70000001UL, \ > + "MIPS symbol table extension") \ > +_ELF_DEFINE_SHT(SHT_MIPS_CONFLICT, 0x70000002UL, \ > + "symbol conflicting with DSO-defined symbols ") \ > +_ELF_DEFINE_SHT(SHT_MIPS_GPTAB, 0x70000003UL, \ > + "global pointer table") \ > +_ELF_DEFINE_SHT(SHT_MIPS_UCODE, 0x70000004UL, \ > + "reserved") \ > +_ELF_DEFINE_SHT(SHT_MIPS_DEBUG, 0x70000005UL, \ > + "reserved (obsolete debug information)") \ > +_ELF_DEFINE_SHT(SHT_MIPS_REGINFO, 0x70000006UL, \ > + "register usage information") \ > +_ELF_DEFINE_SHT(SHT_MIPS_PACKAGE, 0x70000007UL, \ > + "OSF reserved") \ > +_ELF_DEFINE_SHT(SHT_MIPS_PACKSYM, 0x70000008UL, \ > + "OSF reserved") \ > +_ELF_DEFINE_SHT(SHT_MIPS_RELD, 0x70000009UL, \ > + "dynamic relocation") \ > +_ELF_DEFINE_SHT(SHT_MIPS_IFACE, 0x7000000BUL, \ > + "subprogram interface information") \ > +_ELF_DEFINE_SHT(SHT_MIPS_CONTENT, 0x7000000CUL, \ > + "section content classification") \ > +_ELF_DEFINE_SHT(SHT_MIPS_OPTIONS, 0x7000000DUL, \ > + "general options") \ > +_ELF_DEFINE_SHT(SHT_MIPS_DELTASYM, 0x7000001BUL, \ > + "Delta C++: symbol table") \ > +_ELF_DEFINE_SHT(SHT_MIPS_DELTAINST, 0x7000001CUL, \ > + "Delta C++: instance table") \ > +_ELF_DEFINE_SHT(SHT_MIPS_DELTACLASS, 0x7000001DUL, \ > + "Delta C++: class table") \ > +_ELF_DEFINE_SHT(SHT_MIPS_DWARF, 0x7000001EUL, \ > + "DWARF debug information") \ > +_ELF_DEFINE_SHT(SHT_MIPS_DELTADECL, 0x7000001FUL, \ > + "Delta C++: declarations") \ > +_ELF_DEFINE_SHT(SHT_MIPS_SYMBOL_LIB, 0x70000020UL, \ > + "symbol-to-library mapping") \ > +_ELF_DEFINE_SHT(SHT_MIPS_EVENTS, 0x70000021UL, \ > + "event locations") \ > +_ELF_DEFINE_SHT(SHT_MIPS_TRANSLATE, 0x70000022UL, \ > + "???") \ > +_ELF_DEFINE_SHT(SHT_MIPS_PIXIE, 0x70000023UL, \ > + "special pixie sections") \ > +_ELF_DEFINE_SHT(SHT_MIPS_XLATE, 0x70000024UL, \ > + "address translation table") \ > +_ELF_DEFINE_SHT(SHT_MIPS_XLATE_DEBUG, 0x70000025UL, \ > + "SGI internal address translation table") \ > +_ELF_DEFINE_SHT(SHT_MIPS_WHIRL, 0x70000026UL, \ > + "intermediate code") \ > +_ELF_DEFINE_SHT(SHT_MIPS_EH_REGION, 0x70000027UL, \ > + "C++ exception handling region info") \ > +_ELF_DEFINE_SHT(SHT_MIPS_XLATE_OLD, 0x70000028UL, \ > + "obsolete") \ > +_ELF_DEFINE_SHT(SHT_MIPS_PDR_EXCEPTION, 0x70000029UL, \ > + "runtime procedure descriptor table exception information") \ > +_ELF_DEFINE_SHT(SHT_MIPS_ABIFLAGS, 0x7000002AUL, \ > + "ABI flags") \ > +_ELF_DEFINE_SHT(SHT_SPARC_GOTDATA, 0x70000000UL, \ > + "SPARC-specific data") \ > +_ELF_DEFINE_SHT(SHT_AMD64_UNWIND, 0x70000001UL, \ > + "unwind tables for the AMD64") \ > +_ELF_DEFINE_SHT(SHT_ORDERED, 0x7FFFFFFFUL, \ > + "sort entries in the section") \ > +_ELF_DEFINE_SHT(SHT_HIPROC, 0x7FFFFFFFUL, \ > + "end of processor-specific range") \ > +_ELF_DEFINE_SHT(SHT_LOUSER, 0x80000000UL, \ > + "start of application-specific range") \ > +_ELF_DEFINE_SHT(SHT_HIUSER, 0xFFFFFFFFUL, \ > + "end of application-specific range") > + > +#undef _ELF_DEFINE_SHT > +#define _ELF_DEFINE_SHT(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_SECTION_TYPES() > + SHT__LAST__ = SHT_HIUSER > +}; > + > +/* Aliases for section types. */ > +#define SHT_GNU_verdef SHT_SUNW_verdef > +#define SHT_GNU_verneed SHT_SUNW_verneed > +#define SHT_GNU_versym SHT_SUNW_versym > + > +/* > + * Symbol binding information. > + */ > + > +#define _ELF_DEFINE_SYMBOL_BINDING() > \ > +_ELF_DEFINE_STB(STB_LOCAL, 0, > \ > + "not visible outside defining object file") \ > +_ELF_DEFINE_STB(STB_GLOBAL, 1, > \ > + "visible across all object files being combined") \ > +_ELF_DEFINE_STB(STB_WEAK, 2, > \ > + "visible across all object files but with low precedence") \ > +_ELF_DEFINE_STB(STB_LOOS, 10, "start of OS-specific range") \ > +_ELF_DEFINE_STB(STB_GNU_UNIQUE, 10, "unique symbol (GNU)") > \ > +_ELF_DEFINE_STB(STB_HIOS, 12, "end of OS-specific range") \ > +_ELF_DEFINE_STB(STB_LOPROC, 13, \ > + "start of processor-specific range") \ > +_ELF_DEFINE_STB(STB_HIPROC, 15, \ > + "end of processor-specific range") > + > +#undef _ELF_DEFINE_STB > +#define _ELF_DEFINE_STB(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_SYMBOL_BINDING() > + STB__LAST__ > +}; > + > +/* > + * Symbol types > + */ > + > +#define _ELF_DEFINE_SYMBOL_TYPES() > \ > +_ELF_DEFINE_STT(STT_NOTYPE, 0, "unspecified type") \ > +_ELF_DEFINE_STT(STT_OBJECT, 1, "data object") \ > +_ELF_DEFINE_STT(STT_FUNC, 2, "executable code") \ > +_ELF_DEFINE_STT(STT_SECTION, 3, "section") \ > +_ELF_DEFINE_STT(STT_FILE, 4, "source file") \ > +_ELF_DEFINE_STT(STT_COMMON, 5, "uninitialized common block") \ > +_ELF_DEFINE_STT(STT_TLS, 6, "thread local storage") > \ > +_ELF_DEFINE_STT(STT_LOOS, 10, "start of OS-specific types") \ > +_ELF_DEFINE_STT(STT_HIOS, 12, "end of OS-specific types") \ > +_ELF_DEFINE_STT(STT_LOPROC, 13, \ > + "start of processor-specific types") \ > +_ELF_DEFINE_STT(STT_ARM_TFUNC, 13, "Thumb function (GNU)") \ > +_ELF_DEFINE_STT(STT_ARM_16BIT, 15, "Thumb label (GNU)") \ > +_ELF_DEFINE_STT(STT_SPARC_REGISTER, 13, "SPARC register information") \ > +_ELF_DEFINE_STT(STT_HIPROC, 15, \ > + "end of processor-specific types") > + > +#undef _ELF_DEFINE_STT > +#define _ELF_DEFINE_STT(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_SYMBOL_TYPES() > + STT__LAST__ > +}; > + > +/* > + * Symbol binding. > + */ > + > +#define _ELF_DEFINE_SYMBOL_BINDING_KINDS() \ > +_ELF_DEFINE_SYB(SYMINFO_BT_SELF, 0xFFFFU, \ > + "bound to self") \ > +_ELF_DEFINE_SYB(SYMINFO_BT_PARENT, 0xFFFEU, \ > + "bound to parent") \ > +_ELF_DEFINE_SYB(SYMINFO_BT_NONE, 0xFFFDU, \ > + "no special binding") > + > +#undef _ELF_DEFINE_SYB > +#define _ELF_DEFINE_SYB(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_SYMBOL_BINDING_KINDS() > + SYMINFO__LAST__ > +}; > + > +/* > + * Symbol visibility. > + */ > + > +#define _ELF_DEFINE_SYMBOL_VISIBILITY() \ > +_ELF_DEFINE_STV(STV_DEFAULT, 0, \ > + "as specified by symbol type") \ > +_ELF_DEFINE_STV(STV_INTERNAL, 1, \ > + "as defined by processor semantics") \ > +_ELF_DEFINE_STV(STV_HIDDEN, 2, \ > + "hidden from other components") \ > +_ELF_DEFINE_STV(STV_PROTECTED, 3, \ > + "local references are not preemptable") > + > +#undef _ELF_DEFINE_STV > +#define _ELF_DEFINE_STV(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_SYMBOL_VISIBILITY() > + STV__LAST__ > +}; > + > +/* > + * Symbol flags. > + */ > +#define _ELF_DEFINE_SYMBOL_FLAGS() \ > +_ELF_DEFINE_SYF(SYMINFO_FLG_DIRECT, 0x01, \ > + "directly assocated reference") \ > +_ELF_DEFINE_SYF(SYMINFO_FLG_COPY, 0x04, \ > + "definition by copy-relocation") \ > +_ELF_DEFINE_SYF(SYMINFO_FLG_LAZYLOAD, 0x08, \ > + "object should be lazily loaded") \ > +_ELF_DEFINE_SYF(SYMINFO_FLG_DIRECTBIND, 0x10, \ > + "reference should be directly bound") \ > +_ELF_DEFINE_SYF(SYMINFO_FLG_NOEXTDIRECT, 0x20, \ > + "external references not allowed to bind to definition") > + > +#undef _ELF_DEFINE_SYF > +#define _ELF_DEFINE_SYF(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_SYMBOL_FLAGS() > + SYMINFO_FLG__LAST__ > +}; > + > +/* > + * Version dependencies. > + */ > +#define _ELF_DEFINE_VERSIONING_DEPENDENCIES() \ > +_ELF_DEFINE_VERD(VER_NDX_LOCAL, 0, "local scope") \ > +_ELF_DEFINE_VERD(VER_NDX_GLOBAL, 1, "global scope") > +#undef _ELF_DEFINE_VERD > +#define _ELF_DEFINE_VERD(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_VERSIONING_DEPENDENCIES() > + VER_NDX__LAST__ > +}; > + > +/* > + * Version flags. > + */ > +#define _ELF_DEFINE_VERSIONING_FLAGS() \ > +_ELF_DEFINE_VERF(VER_FLG_BASE, 0x1, "file version") \ > +_ELF_DEFINE_VERF(VER_FLG_WEAK, 0x2, "weak version") > +#undef _ELF_DEFINE_VERF > +#define _ELF_DEFINE_VERF(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_VERSIONING_FLAGS() > + VER_FLG__LAST__ > +}; > + > +/* > + * Version needs > + */ > +#define _ELF_DEFINE_VERSIONING_NEEDS() > \ > +_ELF_DEFINE_VRN(VER_NEED_NONE, 0, "invalid version") \ > +_ELF_DEFINE_VRN(VER_NEED_CURRENT, 1, "current version") > +#undef _ELF_DEFINE_VRN > +#define _ELF_DEFINE_VRN(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_VERSIONING_NEEDS() > + VER_NEED__LAST__ > +}; > + > +/* > + * Version numbers. > + */ > +#define _ELF_DEFINE_VERSIONING_NUMBERS() > \ > +_ELF_DEFINE_VRNU(VER_DEF_NONE, 0, "invalid version") \ > +_ELF_DEFINE_VRNU(VER_DEF_CURRENT, 1, "current version") > +#undef _ELF_DEFINE_VRNU > +#define _ELF_DEFINE_VRNU(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_VERSIONING_NUMBERS() > + VER_DEF__LAST__ > +}; > + > +/** > + ** Relocation types. > + **/ > + > +#define _ELF_DEFINE_386_RELOCATIONS() \ > +_ELF_DEFINE_RELOC(R_386_NONE, 0) \ > +_ELF_DEFINE_RELOC(R_386_32, 1) \ > +_ELF_DEFINE_RELOC(R_386_PC32, 2) \ > +_ELF_DEFINE_RELOC(R_386_GOT32, 3) \ > +_ELF_DEFINE_RELOC(R_386_PLT32, 4) \ > +_ELF_DEFINE_RELOC(R_386_COPY, 5) \ > +_ELF_DEFINE_RELOC(R_386_GLOB_DAT, 6) \ > +_ELF_DEFINE_RELOC(R_386_JUMP_SLOT, 7) \ > +_ELF_DEFINE_RELOC(R_386_RELATIVE, 8) \ > +_ELF_DEFINE_RELOC(R_386_GOTOFF, 9) \ > +_ELF_DEFINE_RELOC(R_386_GOTPC, 10) \ > +_ELF_DEFINE_RELOC(R_386_32PLT, 11) \ > +_ELF_DEFINE_RELOC(R_386_16, 20) \ > +_ELF_DEFINE_RELOC(R_386_PC16, 21) \ > +_ELF_DEFINE_RELOC(R_386_8, 22) \ > +_ELF_DEFINE_RELOC(R_386_PC8, 23) > + > +/* > + */ > +#define _ELF_DEFINE_AARCH64_RELOCATIONS() \ > +_ELF_DEFINE_RELOC(R_AARCH64_ABS64, 257) \ > +_ELF_DEFINE_RELOC(R_AARCH64_ABS32, 258) \ > + > +/* > + * These are the symbols used in the Sun ``Linkers and Loaders > + * Guide'', Document No: 817-1984-17. See the X86_64 relocations list > + * below for the spellings used in the ELF specification. > + */ > +#define _ELF_DEFINE_AMD64_RELOCATIONS() \ > +_ELF_DEFINE_RELOC(R_AMD64_NONE, 0) \ > +_ELF_DEFINE_RELOC(R_AMD64_64, 1) \ > +_ELF_DEFINE_RELOC(R_AMD64_PC32, 2) \ > +_ELF_DEFINE_RELOC(R_AMD64_GOT32, 3) \ > +_ELF_DEFINE_RELOC(R_AMD64_PLT32, 4) \ > +_ELF_DEFINE_RELOC(R_AMD64_COPY, 5) \ > +_ELF_DEFINE_RELOC(R_AMD64_GLOB_DAT, 6) \ > +_ELF_DEFINE_RELOC(R_AMD64_JUMP_SLOT, 7) \ > +_ELF_DEFINE_RELOC(R_AMD64_RELATIVE, 8) \ > +_ELF_DEFINE_RELOC(R_AMD64_GOTPCREL, 9) \ > +_ELF_DEFINE_RELOC(R_AMD64_32, 10) \ > +_ELF_DEFINE_RELOC(R_AMD64_32S, 11) \ > +_ELF_DEFINE_RELOC(R_AMD64_16, 12) \ > +_ELF_DEFINE_RELOC(R_AMD64_PC16, 13) \ > +_ELF_DEFINE_RELOC(R_AMD64_8, 14) \ > +_ELF_DEFINE_RELOC(R_AMD64_PC8, 15) \ > +_ELF_DEFINE_RELOC(R_AMD64_PC64, 24) \ > +_ELF_DEFINE_RELOC(R_AMD64_GOTOFF64, 25) \ > +_ELF_DEFINE_RELOC(R_AMD64_GOTPC32, 26) > + > +/* > + * Relocation definitions from the ARM ELF ABI, version "ARM IHI > + * 0044E" released on 30th November 2012. > + */ > +#define _ELF_DEFINE_ARM_RELOCATIONS() \ > +_ELF_DEFINE_RELOC(R_ARM_NONE, 0) \ > +_ELF_DEFINE_RELOC(R_ARM_PC24, 1) \ > +_ELF_DEFINE_RELOC(R_ARM_ABS32, 2) \ > +_ELF_DEFINE_RELOC(R_ARM_REL32, 3) \ > +_ELF_DEFINE_RELOC(R_ARM_LDR_PC_G0, 4) \ > +_ELF_DEFINE_RELOC(R_ARM_ABS16, 5) \ > +_ELF_DEFINE_RELOC(R_ARM_ABS12, 6) \ > +_ELF_DEFINE_RELOC(R_ARM_THM_ABS5, 7) \ > +_ELF_DEFINE_RELOC(R_ARM_ABS8, 8) \ > +_ELF_DEFINE_RELOC(R_ARM_SBREL32, 9) \ > +_ELF_DEFINE_RELOC(R_ARM_THM_CALL, 10) \ > +_ELF_DEFINE_RELOC(R_ARM_THM_PC8, 11) \ > +_ELF_DEFINE_RELOC(R_ARM_BREL_ADJ, 12) \ > +_ELF_DEFINE_RELOC(R_ARM_SWI24, 13) \ > +_ELF_DEFINE_RELOC(R_ARM_TLS_DESC, 13) \ > +_ELF_DEFINE_RELOC(R_ARM_THM_SWI8, 14) \ > +_ELF_DEFINE_RELOC(R_ARM_XPC25, 15) \ > +_ELF_DEFINE_RELOC(R_ARM_THM_XPC22, 16) \ > +_ELF_DEFINE_RELOC(R_ARM_TLS_DTPMOD32, 17) \ > +_ELF_DEFINE_RELOC(R_ARM_TLS_DTPOFF32, 18) \ > +_ELF_DEFINE_RELOC(R_ARM_TLS_TPOFF32, 19) \ > +_ELF_DEFINE_RELOC(R_ARM_COPY, 20) \ > +_ELF_DEFINE_RELOC(R_ARM_GLOB_DAT, 21) \ > +_ELF_DEFINE_RELOC(R_ARM_JUMP_SLOT, 22) \ > +_ELF_DEFINE_RELOC(R_ARM_RELATIVE, 23) \ > +_ELF_DEFINE_RELOC(R_ARM_GOTOFF32, 24) \ > +_ELF_DEFINE_RELOC(R_ARM_BASE_PREL, 25) \ > +_ELF_DEFINE_RELOC(R_ARM_GOT_BREL, 26) \ > +_ELF_DEFINE_RELOC(R_ARM_PLT32, 27) \ > +_ELF_DEFINE_RELOC(R_ARM_CALL, 28) \ > +_ELF_DEFINE_RELOC(R_ARM_JUMP24, 29) \ > +_ELF_DEFINE_RELOC(R_ARM_THM_JUMP24, 30) \ > +_ELF_DEFINE_RELOC(R_ARM_BASE_ABS, 31) \ > +_ELF_DEFINE_RELOC(R_ARM_ALU_PCREL_7_0, 32) \ > +_ELF_DEFINE_RELOC(R_ARM_ALU_PCREL_15_8, 33) \ > +_ELF_DEFINE_RELOC(R_ARM_ALU_PCREL_23_15, 34) \ > +_ELF_DEFINE_RELOC(R_ARM_LDR_SBREL_11_0_NC, 35) \ > +_ELF_DEFINE_RELOC(R_ARM_ALU_SBREL_19_12_NC, 36) \ > +_ELF_DEFINE_RELOC(R_ARM_ALU_SBREL_27_20_CK, 37) \ > +_ELF_DEFINE_RELOC(R_ARM_TARGET1, 38) \ > +_ELF_DEFINE_RELOC(R_ARM_SBREL31, 39) \ > +_ELF_DEFINE_RELOC(R_ARM_V4BX, 40) \ > +_ELF_DEFINE_RELOC(R_ARM_TARGET2, 41) \ > +_ELF_DEFINE_RELOC(R_ARM_PREL31, 42) \ > +_ELF_DEFINE_RELOC(R_ARM_MOVW_ABS_NC, 43) \ > +_ELF_DEFINE_RELOC(R_ARM_MOVT_ABS, 44) \ > +_ELF_DEFINE_RELOC(R_ARM_MOVW_PREL_NC, 45) \ > +_ELF_DEFINE_RELOC(R_ARM_MOVT_PREL, 46) \ > +_ELF_DEFINE_RELOC(R_ARM_THM_MOVW_ABS_NC, 47) \ > +_ELF_DEFINE_RELOC(R_ARM_THM_MOVT_ABS, 48) \ > +_ELF_DEFINE_RELOC(R_ARM_THM_MOVW_PREL_NC, 49) \ > +_ELF_DEFINE_RELOC(R_ARM_THM_MOVT_PREL, 50) \ > +_ELF_DEFINE_RELOC(R_ARM_THM_JUMP19, 51) \ > +_ELF_DEFINE_RELOC(R_ARM_THM_JUMP6, 52) \ > +_ELF_DEFINE_RELOC(R_ARM_THM_ALU_PREL_11_0, 53) \ > +_ELF_DEFINE_RELOC(R_ARM_THM_PC12, 54) \ > +_ELF_DEFINE_RELOC(R_ARM_ABS32_NOI, 55) \ > +_ELF_DEFINE_RELOC(R_ARM_REL32_NOI, 56) \ > +_ELF_DEFINE_RELOC(R_ARM_ALU_PC_G0_NC, 57) \ > +_ELF_DEFINE_RELOC(R_ARM_ALU_PC_G0, 58) \ > +_ELF_DEFINE_RELOC(R_ARM_ALU_PC_G1_NC, 59) \ > +_ELF_DEFINE_RELOC(R_ARM_ALU_PC_G1, 60) \ > +_ELF_DEFINE_RELOC(R_ARM_ALU_PC_G2, 61) \ > +_ELF_DEFINE_RELOC(R_ARM_LDR_PC_G1, 62) \ > +_ELF_DEFINE_RELOC(R_ARM_LDR_PC_G2, 63) \ > +_ELF_DEFINE_RELOC(R_ARM_LDRS_PC_G0, 64) \ > +_ELF_DEFINE_RELOC(R_ARM_LDRS_PC_G1, 65) \ > +_ELF_DEFINE_RELOC(R_ARM_LDRS_PC_G2, 66) \ > +_ELF_DEFINE_RELOC(R_ARM_LDC_PC_G0, 67) \ > +_ELF_DEFINE_RELOC(R_ARM_LDC_PC_G1, 68) \ > +_ELF_DEFINE_RELOC(R_ARM_LDC_PC_G2, 69) \ > +_ELF_DEFINE_RELOC(R_ARM_ALU_SB_G0_NC, 70) \ > +_ELF_DEFINE_RELOC(R_ARM_ALU_SB_G0, 71) \ > +_ELF_DEFINE_RELOC(R_ARM_ALU_SB_G1_NC, 72) \ > +_ELF_DEFINE_RELOC(R_ARM_ALU_SB_G1, 73) \ > +_ELF_DEFINE_RELOC(R_ARM_ALU_SB_G2, 74) \ > +_ELF_DEFINE_RELOC(R_ARM_LDR_SB_G0, 75) \ > +_ELF_DEFINE_RELOC(R_ARM_LDR_SB_G1, 76) \ > +_ELF_DEFINE_RELOC(R_ARM_LDR_SB_G2, 77) \ > +_ELF_DEFINE_RELOC(R_ARM_LDRS_SB_G0, 78) \ > +_ELF_DEFINE_RELOC(R_ARM_LDRS_SB_G1, 79) \ > +_ELF_DEFINE_RELOC(R_ARM_LDRS_SB_G2, 80) \ > +_ELF_DEFINE_RELOC(R_ARM_LDC_SB_G0, 81) \ > +_ELF_DEFINE_RELOC(R_ARM_LDC_SB_G1, 82) \ > +_ELF_DEFINE_RELOC(R_ARM_LDC_SB_G2, 83) \ > +_ELF_DEFINE_RELOC(R_ARM_MOVW_BREL_NC, 84) \ > +_ELF_DEFINE_RELOC(R_ARM_MOVT_BREL, 85) \ > +_ELF_DEFINE_RELOC(R_ARM_MOVW_BREL, 86) \ > +_ELF_DEFINE_RELOC(R_ARM_THM_MOVW_BREL_NC, 87) \ > +_ELF_DEFINE_RELOC(R_ARM_THM_MOVT_BREL, 88) \ > +_ELF_DEFINE_RELOC(R_ARM_THM_MOVW_BREL, 89) \ > +_ELF_DEFINE_RELOC(R_ARM_TLS_GOTDESC, 90) \ > +_ELF_DEFINE_RELOC(R_ARM_TLS_CALL, 91) \ > +_ELF_DEFINE_RELOC(R_ARM_TLS_DESCSEQ, 92) \ > +_ELF_DEFINE_RELOC(R_ARM_THM_TLS_CALL, 93) \ > +_ELF_DEFINE_RELOC(R_ARM_PLT32_ABS, 94) \ > +_ELF_DEFINE_RELOC(R_ARM_GOT_ABS, 95) \ > +_ELF_DEFINE_RELOC(R_ARM_GOT_PREL, 96) \ > +_ELF_DEFINE_RELOC(R_ARM_GOT_BREL12, 97) \ > +_ELF_DEFINE_RELOC(R_ARM_GOTOFF12, 98) \ > +_ELF_DEFINE_RELOC(R_ARM_GOTRELAX, 99) \ > +_ELF_DEFINE_RELOC(R_ARM_GNU_VTENTRY, 100) \ > +_ELF_DEFINE_RELOC(R_ARM_GNU_VTINHERIT, 101) \ > +_ELF_DEFINE_RELOC(R_ARM_THM_JUMP11, 102) \ > +_ELF_DEFINE_RELOC(R_ARM_THM_JUMP8, 103) \ > +_ELF_DEFINE_RELOC(R_ARM_TLS_GD32, 104) \ > +_ELF_DEFINE_RELOC(R_ARM_TLS_LDM32, 105) \ > +_ELF_DEFINE_RELOC(R_ARM_TLS_LDO32, 106) \ > +_ELF_DEFINE_RELOC(R_ARM_TLS_IE32, 107) \ > +_ELF_DEFINE_RELOC(R_ARM_TLS_LE32, 108) \ > +_ELF_DEFINE_RELOC(R_ARM_TLS_LDO12, 109) \ > +_ELF_DEFINE_RELOC(R_ARM_TLS_LE12, 110) \ > +_ELF_DEFINE_RELOC(R_ARM_TLS_IE12GP, 111) \ > +_ELF_DEFINE_RELOC(R_ARM_PRIVATE_0, 112) \ > +_ELF_DEFINE_RELOC(R_ARM_PRIVATE_1, 113) \ > +_ELF_DEFINE_RELOC(R_ARM_PRIVATE_2, 114) \ > +_ELF_DEFINE_RELOC(R_ARM_PRIVATE_3, 115) \ > +_ELF_DEFINE_RELOC(R_ARM_PRIVATE_4, 116) \ > +_ELF_DEFINE_RELOC(R_ARM_PRIVATE_5, 117) \ > +_ELF_DEFINE_RELOC(R_ARM_PRIVATE_6, 118) \ > +_ELF_DEFINE_RELOC(R_ARM_PRIVATE_7, 119) \ > +_ELF_DEFINE_RELOC(R_ARM_PRIVATE_8, 120) \ > +_ELF_DEFINE_RELOC(R_ARM_PRIVATE_9, 121) \ > +_ELF_DEFINE_RELOC(R_ARM_PRIVATE_10, 122) \ > +_ELF_DEFINE_RELOC(R_ARM_PRIVATE_11, 123) \ > +_ELF_DEFINE_RELOC(R_ARM_PRIVATE_12, 124) \ > +_ELF_DEFINE_RELOC(R_ARM_PRIVATE_13, 125) \ > +_ELF_DEFINE_RELOC(R_ARM_PRIVATE_14, 126) \ > +_ELF_DEFINE_RELOC(R_ARM_PRIVATE_15, 127) \ > +_ELF_DEFINE_RELOC(R_ARM_ME_TOO, 128) \ > +_ELF_DEFINE_RELOC(R_ARM_THM_TLS_DESCSEQ16, 129) \ > +_ELF_DEFINE_RELOC(R_ARM_THM_TLS_DESCSEQ32, 130) \ > +_ELF_DEFINE_RELOC(R_ARM_THM_GOT_BREL12, 131) \ > +_ELF_DEFINE_RELOC(R_ARM_IRELATIVE, 140) > + > +#define _ELF_DEFINE_IA64_RELOCATIONS() \ > +_ELF_DEFINE_RELOC(R_IA_64_NONE, 0) \ > +_ELF_DEFINE_RELOC(R_IA_64_IMM14, 0x21) \ > +_ELF_DEFINE_RELOC(R_IA_64_IMM22, 0x22) \ > +_ELF_DEFINE_RELOC(R_IA_64_IMM64, 0x23) \ > +_ELF_DEFINE_RELOC(R_IA_64_DIR32MSB, 0x24) \ > +_ELF_DEFINE_RELOC(R_IA_64_DIR32LSB, 0x25) \ > +_ELF_DEFINE_RELOC(R_IA_64_DIR64MSB, 0x26) \ > +_ELF_DEFINE_RELOC(R_IA_64_DIR64LSB, 0x27) \ > +_ELF_DEFINE_RELOC(R_IA_64_GPREL22, 0x2a) \ > +_ELF_DEFINE_RELOC(R_IA_64_GPREL64I, 0x2b) \ > +_ELF_DEFINE_RELOC(R_IA_64_GPREL32MSB, 0x2c) \ > +_ELF_DEFINE_RELOC(R_IA_64_GPREL32LSB, 0x2d) \ > +_ELF_DEFINE_RELOC(R_IA_64_GPREL64MSB, 0x2e) \ > +_ELF_DEFINE_RELOC(R_IA_64_GPREL64LSB, 0x2f) \ > +_ELF_DEFINE_RELOC(R_IA_64_LTOFF22, 0x32) \ > +_ELF_DEFINE_RELOC(R_IA_64_LTOFF64I, 0x33) \ > +_ELF_DEFINE_RELOC(R_IA_64_PLTOFF22, 0x3a) \ > +_ELF_DEFINE_RELOC(R_IA_64_PLTOFF64I, 0x3b) \ > +_ELF_DEFINE_RELOC(R_IA_64_PLTOFF64MSB, 0x3e) \ > +_ELF_DEFINE_RELOC(R_IA_64_PLTOFF64LSB, 0x3f) \ > +_ELF_DEFINE_RELOC(R_IA_64_FPTR64I, 0x43) \ > +_ELF_DEFINE_RELOC(R_IA_64_FPTR32MSB, 0x44) \ > +_ELF_DEFINE_RELOC(R_IA_64_FPTR32LSB, 0x45) \ > +_ELF_DEFINE_RELOC(R_IA_64_FPTR64MSB, 0x46) \ > +_ELF_DEFINE_RELOC(R_IA_64_FPTR64LSB, 0x47) \ > +_ELF_DEFINE_RELOC(R_IA_64_PCREL60B, 0x48) \ > +_ELF_DEFINE_RELOC(R_IA_64_PCREL21B, 0x49) \ > +_ELF_DEFINE_RELOC(R_IA_64_PCREL21M, 0x4a) \ > +_ELF_DEFINE_RELOC(R_IA_64_PCREL21F, 0x4b) \ > +_ELF_DEFINE_RELOC(R_IA_64_PCREL32MSB, 0x4c) \ > +_ELF_DEFINE_RELOC(R_IA_64_PCREL32LSB, 0x4d) \ > +_ELF_DEFINE_RELOC(R_IA_64_PCREL64MSB, 0x4e) \ > +_ELF_DEFINE_RELOC(R_IA_64_PCREL64LSB, 0x4f) \ > +_ELF_DEFINE_RELOC(R_IA_64_LTOFF_FPTR22, 0x52) \ > +_ELF_DEFINE_RELOC(R_IA_64_LTOFF_FPTR64I, 0x53) \ > +_ELF_DEFINE_RELOC(R_IA_64_LTOFF_FPTR32MSB, 0x54) \ > +_ELF_DEFINE_RELOC(R_IA_64_LTOFF_FPTR32LSB, 0x55) \ > +_ELF_DEFINE_RELOC(R_IA_64_LTOFF_FPTR64MSB, 0x56) \ > +_ELF_DEFINE_RELOC(R_IA_64_LTOFF_FPTR64LSB, 0x57) \ > +_ELF_DEFINE_RELOC(R_IA_64_SEGREL32MSB, 0x5c) \ > +_ELF_DEFINE_RELOC(R_IA_64_SEGREL32LSB, 0x5d) \ > +_ELF_DEFINE_RELOC(R_IA_64_SEGREL64MSB, 0x5e) \ > +_ELF_DEFINE_RELOC(R_IA_64_SEGREL64LSB, 0x5f) \ > +_ELF_DEFINE_RELOC(R_IA_64_SECREL32MSB, 0x64) \ > +_ELF_DEFINE_RELOC(R_IA_64_SECREL32LSB, 0x65) \ > +_ELF_DEFINE_RELOC(R_IA_64_SECREL64MSB, 0x66) \ > +_ELF_DEFINE_RELOC(R_IA_64_SECREL64LSB, 0x67) \ > +_ELF_DEFINE_RELOC(R_IA_64_REL32MSB, 0x6c) \ > +_ELF_DEFINE_RELOC(R_IA_64_REL32LSB, 0x6d) \ > +_ELF_DEFINE_RELOC(R_IA_64_REL64MSB, 0x6e) \ > +_ELF_DEFINE_RELOC(R_IA_64_REL64LSB, 0x6f) \ > +_ELF_DEFINE_RELOC(R_IA_64_LTV32MSB, 0x74) \ > +_ELF_DEFINE_RELOC(R_IA_64_LTV32LSB, 0x75) \ > +_ELF_DEFINE_RELOC(R_IA_64_LTV64MSB, 0x76) \ > +_ELF_DEFINE_RELOC(R_IA_64_LTV64LSB, 0x77) \ > +_ELF_DEFINE_RELOC(R_IA_64_PCREL21BI, 0x79) \ > +_ELF_DEFINE_RELOC(R_IA_64_PCREL22, 0x7A) \ > +_ELF_DEFINE_RELOC(R_IA_64_PCREL64I, 0x7B) \ > +_ELF_DEFINE_RELOC(R_IA_64_IPLTMSB, 0x80) \ > +_ELF_DEFINE_RELOC(R_IA_64_IPLTLSB, 0x81) \ > +_ELF_DEFINE_RELOC(R_IA_64_SUB, 0x85) \ > +_ELF_DEFINE_RELOC(R_IA_64_LTOFF22X, 0x86) \ > +_ELF_DEFINE_RELOC(R_IA_64_LDXMOV, 0x87) \ > +_ELF_DEFINE_RELOC(R_IA_64_TPREL14, 0x91) \ > +_ELF_DEFINE_RELOC(R_IA_64_TPREL22, 0x92) \ > +_ELF_DEFINE_RELOC(R_IA_64_TPREL64I, 0x93) \ > +_ELF_DEFINE_RELOC(R_IA_64_TPREL64MSB, 0x96) \ > +_ELF_DEFINE_RELOC(R_IA_64_TPREL64LSB, 0x97) \ > +_ELF_DEFINE_RELOC(R_IA_64_LTOFF_TPREL22, 0x9A) \ > +_ELF_DEFINE_RELOC(R_IA_64_DTPMOD64MSB, 0xA6) \ > +_ELF_DEFINE_RELOC(R_IA_64_DTPMOD64LSB, 0xA7) \ > +_ELF_DEFINE_RELOC(R_IA_64_LTOFF_DTPMOD22, 0xAA) \ > +_ELF_DEFINE_RELOC(R_IA_64_DTPREL14, 0xB1) \ > +_ELF_DEFINE_RELOC(R_IA_64_DTPREL22, 0xB2) \ > +_ELF_DEFINE_RELOC(R_IA_64_DTPREL64I, 0xB3) \ > +_ELF_DEFINE_RELOC(R_IA_64_DTPREL32MSB, 0xB4) \ > +_ELF_DEFINE_RELOC(R_IA_64_DTPREL32LSB, 0xB5) \ > +_ELF_DEFINE_RELOC(R_IA_64_DTPREL64MSB, 0xB6) \ > +_ELF_DEFINE_RELOC(R_IA_64_DTPREL64LSB, 0xB7) \ > +_ELF_DEFINE_RELOC(R_IA_64_LTOFF_DTPREL22, 0xBA) > + > +#define _ELF_DEFINE_MIPS_RELOCATIONS() \ > +_ELF_DEFINE_RELOC(R_MIPS_NONE, 0) \ > +_ELF_DEFINE_RELOC(R_MIPS_16, 1) \ > +_ELF_DEFINE_RELOC(R_MIPS_32, 2) \ > +_ELF_DEFINE_RELOC(R_MIPS_REL32, 3) \ > +_ELF_DEFINE_RELOC(R_MIPS_26, 4) \ > +_ELF_DEFINE_RELOC(R_MIPS_HI16, 5) \ > +_ELF_DEFINE_RELOC(R_MIPS_LO16, 6) \ > +_ELF_DEFINE_RELOC(R_MIPS_GPREL16, 7) \ > +_ELF_DEFINE_RELOC(R_MIPS_LITERAL, 8) \ > +_ELF_DEFINE_RELOC(R_MIPS_GOT16, 9) \ > +_ELF_DEFINE_RELOC(R_MIPS_PC16, 10) \ > +_ELF_DEFINE_RELOC(R_MIPS_CALL16, 11) \ > +_ELF_DEFINE_RELOC(R_MIPS_GPREL32, 12) \ > +_ELF_DEFINE_RELOC(R_MIPS_64, 18) \ > +_ELF_DEFINE_RELOC(R_MIPS_GOTHI16, 21) \ > +_ELF_DEFINE_RELOC(R_MIPS_GOTLO16, 22) \ > +_ELF_DEFINE_RELOC(R_MIPS_CALLHI16, 30) \ > +_ELF_DEFINE_RELOC(R_MIPS_CALLLO16, 31) \ > +_ELF_DEFINE_RELOC(R_MIPS_TLS_DTPMOD32, 38) \ > +_ELF_DEFINE_RELOC(R_MIPS_TLS_DTPREL32, 39) \ > +_ELF_DEFINE_RELOC(R_MIPS_TLS_DTPMOD64, 40) \ > +_ELF_DEFINE_RELOC(R_MIPS_TLS_DTPREL64, 41) \ > +_ELF_DEFINE_RELOC(R_MIPS_TLS_GD, 42) \ > +_ELF_DEFINE_RELOC(R_MIPS_TLS_LDM, 43) \ > +_ELF_DEFINE_RELOC(R_MIPS_TLS_DTPREL_HI16, 44) \ > +_ELF_DEFINE_RELOC(R_MIPS_TLS_DTPREL_LO16, 45) \ > +_ELF_DEFINE_RELOC(R_MIPS_TLS_GOTTPREL, 46) \ > +_ELF_DEFINE_RELOC(R_MIPS_TLS_TPREL32, 47) \ > +_ELF_DEFINE_RELOC(R_MIPS_TLS_TPREL64, 48) \ > +_ELF_DEFINE_RELOC(R_MIPS_TLS_TPREL_HI16, 49) \ > +_ELF_DEFINE_RELOC(R_MIPS_TLS_TPREL_LO16, 50) > + > +#define _ELF_DEFINE_PPC32_RELOCATIONS() \ > +_ELF_DEFINE_RELOC(R_PPC_NONE, 0) \ > +_ELF_DEFINE_RELOC(R_PPC_ADDR32, 1) \ > +_ELF_DEFINE_RELOC(R_PPC_ADDR24, 2) \ > +_ELF_DEFINE_RELOC(R_PPC_ADDR16, 3) \ > +_ELF_DEFINE_RELOC(R_PPC_ADDR16_LO, 4) \ > +_ELF_DEFINE_RELOC(R_PPC_ADDR16_HI, 5) \ > +_ELF_DEFINE_RELOC(R_PPC_ADDR16_HA, 6) \ > +_ELF_DEFINE_RELOC(R_PPC_ADDR14, 7) \ > +_ELF_DEFINE_RELOC(R_PPC_ADDR14_BRTAKEN, 8) \ > +_ELF_DEFINE_RELOC(R_PPC_ADDR14_BRNTAKEN, 9) \ > +_ELF_DEFINE_RELOC(R_PPC_REL24, 10) \ > +_ELF_DEFINE_RELOC(R_PPC_REL14, 11) \ > +_ELF_DEFINE_RELOC(R_PPC_REL14_BRTAKEN, 12) \ > +_ELF_DEFINE_RELOC(R_PPC_REL14_BRNTAKEN, 13) \ > +_ELF_DEFINE_RELOC(R_PPC_GOT16, 14) \ > +_ELF_DEFINE_RELOC(R_PPC_GOT16_LO, 15) \ > +_ELF_DEFINE_RELOC(R_PPC_GOT16_HI, 16) \ > +_ELF_DEFINE_RELOC(R_PPC_GOT16_HA, 17) \ > +_ELF_DEFINE_RELOC(R_PPC_PLTREL24, 18) \ > +_ELF_DEFINE_RELOC(R_PPC_COPY, 19) \ > +_ELF_DEFINE_RELOC(R_PPC_GLOB_DAT, 20) \ > +_ELF_DEFINE_RELOC(R_PPC_JMP_SLOT, 21) \ > +_ELF_DEFINE_RELOC(R_PPC_RELATIVE, 22) \ > +_ELF_DEFINE_RELOC(R_PPC_LOCAL24PC, 23) \ > +_ELF_DEFINE_RELOC(R_PPC_UADDR32, 24) \ > +_ELF_DEFINE_RELOC(R_PPC_UADDR16, 25) \ > +_ELF_DEFINE_RELOC(R_PPC_REL32, 26) \ > +_ELF_DEFINE_RELOC(R_PPC_PLT32, 27) \ > +_ELF_DEFINE_RELOC(R_PPC_PLTREL32, 28) \ > +_ELF_DEFINE_RELOC(R_PPC_PLT16_LO, 29) \ > +_ELF_DEFINE_RELOC(R_PPC_PLT16_HI, 30) \ > +_ELF_DEFINE_RELOC(R_PPC_PLT16_HA, 31) \ > +_ELF_DEFINE_RELOC(R_PPC_SDAREL16, 32) \ > +_ELF_DEFINE_RELOC(R_PPC_SECTOFF, 33) \ > +_ELF_DEFINE_RELOC(R_PPC_SECTOFF_LO, 34) \ > +_ELF_DEFINE_RELOC(R_PPC_SECTOFF_HI, 35) \ > +_ELF_DEFINE_RELOC(R_PPC_SECTOFF_HA, 36) \ > +_ELF_DEFINE_RELOC(R_PPC_ADDR30, 37) \ > +_ELF_DEFINE_RELOC(R_PPC_TLS, 67) \ > +_ELF_DEFINE_RELOC(R_PPC_DTPMOD32, 68) \ > +_ELF_DEFINE_RELOC(R_PPC_TPREL16, 69) \ > +_ELF_DEFINE_RELOC(R_PPC_TPREL16_LO, 70) \ > +_ELF_DEFINE_RELOC(R_PPC_TPREL16_HI, 71) \ > +_ELF_DEFINE_RELOC(R_PPC_TPREL16_HA, 72) \ > +_ELF_DEFINE_RELOC(R_PPC_TPREL32, 73) \ > +_ELF_DEFINE_RELOC(R_PPC_DTPREL16, 74) \ > +_ELF_DEFINE_RELOC(R_PPC_DTPREL16_LO, 75) \ > +_ELF_DEFINE_RELOC(R_PPC_DTPREL16_HI, 76) \ > +_ELF_DEFINE_RELOC(R_PPC_DTPREL16_HA, 77) \ > +_ELF_DEFINE_RELOC(R_PPC_DTPREL32, 78) \ > +_ELF_DEFINE_RELOC(R_PPC_GOT_TLSGD16, 79) \ > +_ELF_DEFINE_RELOC(R_PPC_GOT_TLSGD16_LO, 80) \ > +_ELF_DEFINE_RELOC(R_PPC_GOT_TLSGD16_HI, 81) \ > +_ELF_DEFINE_RELOC(R_PPC_GOT_TLSGD16_HA, 82) \ > +_ELF_DEFINE_RELOC(R_PPC_GOT_TLSLD16, 83) \ > +_ELF_DEFINE_RELOC(R_PPC_GOT_TLSLD16_LO, 84) \ > +_ELF_DEFINE_RELOC(R_PPC_GOT_TLSLD16_HI, 85) \ > +_ELF_DEFINE_RELOC(R_PPC_GOT_TLSLD16_HA, 86) \ > +_ELF_DEFINE_RELOC(R_PPC_GOT_TPREL16, 87) \ > +_ELF_DEFINE_RELOC(R_PPC_GOT_TPREL16_LO, 88) \ > +_ELF_DEFINE_RELOC(R_PPC_GOT_TPREL16_HI, 89) \ > +_ELF_DEFINE_RELOC(R_PPC_GOT_TPREL16_HA, 90) \ > +_ELF_DEFINE_RELOC(R_PPC_GOT_DTPREL16, 91) \ > +_ELF_DEFINE_RELOC(R_PPC_GOT_DTPREL16_LO, 92) \ > +_ELF_DEFINE_RELOC(R_PPC_GOT_DTPREL16_HI, 93) \ > +_ELF_DEFINE_RELOC(R_PPC_GOT_DTPREL16_HA, 94) \ > +_ELF_DEFINE_RELOC(R_PPC_TLSGD, 95) \ > +_ELF_DEFINE_RELOC(R_PPC_TLSLD, 96) \ > +_ELF_DEFINE_RELOC(R_PPC_EMB_NADDR32, 101) \ > +_ELF_DEFINE_RELOC(R_PPC_EMB_NADDR16, 102) \ > +_ELF_DEFINE_RELOC(R_PPC_EMB_NADDR16_LO, 103) \ > +_ELF_DEFINE_RELOC(R_PPC_EMB_NADDR16_HI, 104) \ > +_ELF_DEFINE_RELOC(R_PPC_EMB_NADDR16_HA, 105) \ > +_ELF_DEFINE_RELOC(R_PPC_EMB_SDAI16, 106) \ > +_ELF_DEFINE_RELOC(R_PPC_EMB_SDA2I16, 107) \ > +_ELF_DEFINE_RELOC(R_PPC_EMB_SDA2REL, 108) \ > +_ELF_DEFINE_RELOC(R_PPC_EMB_SDA21, 109) \ > +_ELF_DEFINE_RELOC(R_PPC_EMB_MRKREF, 110) \ > +_ELF_DEFINE_RELOC(R_PPC_EMB_RELSEC16, 111) \ > +_ELF_DEFINE_RELOC(R_PPC_EMB_RELST_LO, 112) \ > +_ELF_DEFINE_RELOC(R_PPC_EMB_RELST_HI, 113) \ > +_ELF_DEFINE_RELOC(R_PPC_EMB_RELST_HA, 114) \ > +_ELF_DEFINE_RELOC(R_PPC_EMB_BIT_FLD, 115) \ > +_ELF_DEFINE_RELOC(R_PPC_EMB_RELSDA, 116) \ > + > +#define _ELF_DEFINE_PPC64_RELOCATIONS() \ > +_ELF_DEFINE_RELOC(R_PPC64_NONE, 0) \ > +_ELF_DEFINE_RELOC(R_PPC64_ADDR32, 1) \ > +_ELF_DEFINE_RELOC(R_PPC64_ADDR24, 2) \ > +_ELF_DEFINE_RELOC(R_PPC64_ADDR16, 3) \ > +_ELF_DEFINE_RELOC(R_PPC64_ADDR16_LO, 4) \ > +_ELF_DEFINE_RELOC(R_PPC64_ADDR16_HI, 5) \ > +_ELF_DEFINE_RELOC(R_PPC64_ADDR16_HA, 6) \ > +_ELF_DEFINE_RELOC(R_PPC64_ADDR14, 7) \ > +_ELF_DEFINE_RELOC(R_PPC64_ADDR14_BRTAKEN, 8) \ > +_ELF_DEFINE_RELOC(R_PPC64_ADDR14_BRNTAKEN, 9) \ > +_ELF_DEFINE_RELOC(R_PPC64_REL24, 10) \ > +_ELF_DEFINE_RELOC(R_PPC64_REL14, 11) \ > +_ELF_DEFINE_RELOC(R_PPC64_REL14_BRTAKEN, 12) \ > +_ELF_DEFINE_RELOC(R_PPC64_REL14_BRNTAKEN, 13) \ > +_ELF_DEFINE_RELOC(R_PPC64_GOT16, 14) \ > +_ELF_DEFINE_RELOC(R_PPC64_GOT16_LO, 15) \ > +_ELF_DEFINE_RELOC(R_PPC64_GOT16_HI, 16) \ > +_ELF_DEFINE_RELOC(R_PPC64_GOT16_HA, 17) \ > +_ELF_DEFINE_RELOC(R_PPC64_COPY, 19) \ > +_ELF_DEFINE_RELOC(R_PPC64_GLOB_DAT, 20) \ > +_ELF_DEFINE_RELOC(R_PPC64_JMP_SLOT, 21) \ > +_ELF_DEFINE_RELOC(R_PPC64_RELATIVE, 22) \ > +_ELF_DEFINE_RELOC(R_PPC64_UADDR32, 24) \ > +_ELF_DEFINE_RELOC(R_PPC64_UADDR16, 25) \ > +_ELF_DEFINE_RELOC(R_PPC64_REL32, 26) \ > +_ELF_DEFINE_RELOC(R_PPC64_PLT32, 27) \ > +_ELF_DEFINE_RELOC(R_PPC64_PLTREL32, 28) \ > +_ELF_DEFINE_RELOC(R_PPC64_PLT16_LO, 29) \ > +_ELF_DEFINE_RELOC(R_PPC64_PLT16_HI, 30) \ > +_ELF_DEFINE_RELOC(R_PPC64_PLT16_HA, 31) \ > +_ELF_DEFINE_RELOC(R_PPC64_SECTOFF, 33) \ > +_ELF_DEFINE_RELOC(R_PPC64_SECTOFF_LO, 34) \ > +_ELF_DEFINE_RELOC(R_PPC64_SECTOFF_HI, 35) \ > +_ELF_DEFINE_RELOC(R_PPC64_SECTOFF_HA, 36) \ > +_ELF_DEFINE_RELOC(R_PPC64_ADDR30, 37) \ > +_ELF_DEFINE_RELOC(R_PPC64_ADDR64, 38) \ > +_ELF_DEFINE_RELOC(R_PPC64_ADDR16_HIGHER, 39) \ > +_ELF_DEFINE_RELOC(R_PPC64_ADDR16_HIGHERA, 40) \ > +_ELF_DEFINE_RELOC(R_PPC64_ADDR16_HIGHEST, 41) \ > +_ELF_DEFINE_RELOC(R_PPC64_ADDR16_HIGHESTA, 42) \ > +_ELF_DEFINE_RELOC(R_PPC64_UADDR64, 43) \ > +_ELF_DEFINE_RELOC(R_PPC64_REL64, 44) \ > +_ELF_DEFINE_RELOC(R_PPC64_PLT64, 45) \ > +_ELF_DEFINE_RELOC(R_PPC64_PLTREL64, 46) \ > +_ELF_DEFINE_RELOC(R_PPC64_TOC16, 47) \ > +_ELF_DEFINE_RELOC(R_PPC64_TOC16_LO, 48) \ > +_ELF_DEFINE_RELOC(R_PPC64_TOC16_HI, 49) \ > +_ELF_DEFINE_RELOC(R_PPC64_TOC16_HA, 50) \ > +_ELF_DEFINE_RELOC(R_PPC64_TOC, 51) \ > +_ELF_DEFINE_RELOC(R_PPC64_PLTGOT16, 52) \ > +_ELF_DEFINE_RELOC(R_PPC64_PLTGOT16_LO, 53) \ > +_ELF_DEFINE_RELOC(R_PPC64_PLTGOT16_HI, 54) \ > +_ELF_DEFINE_RELOC(R_PPC64_PLTGOT16_HA, 55) \ > +_ELF_DEFINE_RELOC(R_PPC64_ADDR16_DS, 56) \ > +_ELF_DEFINE_RELOC(R_PPC64_ADDR16_LO_DS, 57) \ > +_ELF_DEFINE_RELOC(R_PPC64_GOT16_DS, 58) \ > +_ELF_DEFINE_RELOC(R_PPC64_GOT16_LO_DS, 59) \ > +_ELF_DEFINE_RELOC(R_PPC64_PLT16_LO_DS, 60) \ > +_ELF_DEFINE_RELOC(R_PPC64_SECTOFF_DS, 61) \ > +_ELF_DEFINE_RELOC(R_PPC64_SECTOFF_LO_DS, 62) \ > +_ELF_DEFINE_RELOC(R_PPC64_TOC16_DS, 63) \ > +_ELF_DEFINE_RELOC(R_PPC64_TOC16_LO_DS, 64) \ > +_ELF_DEFINE_RELOC(R_PPC64_PLTGOT16_DS, 65) \ > +_ELF_DEFINE_RELOC(R_PPC64_PLTGOT16_LO_DS, 66) \ > +_ELF_DEFINE_RELOC(R_PPC64_TLS, 67) \ > +_ELF_DEFINE_RELOC(R_PPC64_DTPMOD64, 68) \ > +_ELF_DEFINE_RELOC(R_PPC64_TPREL16, 69) \ > +_ELF_DEFINE_RELOC(R_PPC64_TPREL16_LO, 60) \ > +_ELF_DEFINE_RELOC(R_PPC64_TPREL16_HI, 71) \ > +_ELF_DEFINE_RELOC(R_PPC64_TPREL16_HA, 72) \ > +_ELF_DEFINE_RELOC(R_PPC64_TPREL64, 73) \ > +_ELF_DEFINE_RELOC(R_PPC64_DTPREL16, 74) \ > +_ELF_DEFINE_RELOC(R_PPC64_DTPREL16_LO, 75) \ > +_ELF_DEFINE_RELOC(R_PPC64_DTPREL16_HI, 76) \ > +_ELF_DEFINE_RELOC(R_PPC64_DTPREL16_HA, 77) \ > +_ELF_DEFINE_RELOC(R_PPC64_DTPREL64, 78) \ > +_ELF_DEFINE_RELOC(R_PPC64_GOT_TLSGD16, 79) \ > +_ELF_DEFINE_RELOC(R_PPC64_GOT_TLSGD16_LO, 80) \ > +_ELF_DEFINE_RELOC(R_PPC64_GOT_TLSGD16_HI, 81) \ > +_ELF_DEFINE_RELOC(R_PPC64_GOT_TLSGD16_HA, 82) \ > +_ELF_DEFINE_RELOC(R_PPC64_GOT_TLSLD16, 83) \ > +_ELF_DEFINE_RELOC(R_PPC64_GOT_TLSLD16_LO, 84) \ > +_ELF_DEFINE_RELOC(R_PPC64_GOT_TLSLD16_HI, 85) \ > +_ELF_DEFINE_RELOC(R_PPC64_GOT_TLSLD16_HA, 86) \ > +_ELF_DEFINE_RELOC(R_PPC64_GOT_TPREL16_DS, 87) \ > +_ELF_DEFINE_RELOC(R_PPC64_GOT_TPREL16_LO_DS, 88) \ > +_ELF_DEFINE_RELOC(R_PPC64_GOT_TPREL16_HI, 89) \ > +_ELF_DEFINE_RELOC(R_PPC64_GOT_TPREL16_HA, 90) \ > +_ELF_DEFINE_RELOC(R_PPC64_GOT_DTPREL16_DS, 91) \ > +_ELF_DEFINE_RELOC(R_PPC64_GOT_DTPREL16_LO_DS, 92) \ > +_ELF_DEFINE_RELOC(R_PPC64_GOT_DTPREL16_HI, 93) \ > +_ELF_DEFINE_RELOC(R_PPC64_GOT_DTPREL16_HA, 94) \ > +_ELF_DEFINE_RELOC(R_PPC64_TPREL16_DS, 95) \ > +_ELF_DEFINE_RELOC(R_PPC64_TPREL16_LO_DS, 96) \ > +_ELF_DEFINE_RELOC(R_PPC64_TPREL16_HIGHER, 97) \ > +_ELF_DEFINE_RELOC(R_PPC64_TPREL16_HIGHERA, 98) \ > +_ELF_DEFINE_RELOC(R_PPC64_TPREL16_HIGHEST, 99) \ > +_ELF_DEFINE_RELOC(R_PPC64_TPREL16_HIGHESTA, 100) \ > +_ELF_DEFINE_RELOC(R_PPC64_DTPREL16_DS, 101) \ > +_ELF_DEFINE_RELOC(R_PPC64_DTPREL16_LO_DS, 102) \ > +_ELF_DEFINE_RELOC(R_PPC64_DTPREL16_HIGHER, 103) \ > +_ELF_DEFINE_RELOC(R_PPC64_DTPREL16_HIGHERA, 104) \ > +_ELF_DEFINE_RELOC(R_PPC64_DTPREL16_HIGHEST, 105) \ > +_ELF_DEFINE_RELOC(R_PPC64_DTPREL16_HIGHESTA, 106) \ > +_ELF_DEFINE_RELOC(R_PPC64_TLSGD, 107) \ > +_ELF_DEFINE_RELOC(R_PPC64_TLSLD, 108) > + > +#define _ELF_DEFINE_RISCV_RELOCATIONS() \ > +_ELF_DEFINE_RELOC(R_RISCV_NONE, 0) \ > +_ELF_DEFINE_RELOC(R_RISCV_32, 1) \ > +_ELF_DEFINE_RELOC(R_RISCV_64, 2) \ > +_ELF_DEFINE_RELOC(R_RISCV_RELATIVE, 3) \ > +_ELF_DEFINE_RELOC(R_RISCV_COPY, 4) \ > +_ELF_DEFINE_RELOC(R_RISCV_JUMP_SLOT, 5) \ > +_ELF_DEFINE_RELOC(R_RISCV_TLS_DTPMOD32, 6) \ > +_ELF_DEFINE_RELOC(R_RISCV_TLS_DTPMOD64, 7) \ > +_ELF_DEFINE_RELOC(R_RISCV_TLS_DTPREL32, 8) \ > +_ELF_DEFINE_RELOC(R_RISCV_TLS_DTPREL64, 9) \ > +_ELF_DEFINE_RELOC(R_RISCV_TLS_TPREL32, 10) \ > +_ELF_DEFINE_RELOC(R_RISCV_TLS_TPREL64, 11) \ > +_ELF_DEFINE_RELOC(R_RISCV_BRANCH, 16) \ > +_ELF_DEFINE_RELOC(R_RISCV_JAL, 17) \ > +_ELF_DEFINE_RELOC(R_RISCV_CALL, 18) \ > +_ELF_DEFINE_RELOC(R_RISCV_CALL_PLT, 19) \ > +_ELF_DEFINE_RELOC(R_RISCV_GOT_HI20, 20) \ > +_ELF_DEFINE_RELOC(R_RISCV_TLS_GOT_HI20, 21) \ > +_ELF_DEFINE_RELOC(R_RISCV_TLS_GD_HI20, 22) \ > +_ELF_DEFINE_RELOC(R_RISCV_PCREL_HI20, 23) \ > +_ELF_DEFINE_RELOC(R_RISCV_PCREL_LO12_I, 24) \ > +_ELF_DEFINE_RELOC(R_RISCV_PCREL_LO12_S, 25) \ > +_ELF_DEFINE_RELOC(R_RISCV_HI20, 26) \ > +_ELF_DEFINE_RELOC(R_RISCV_LO12_I, 27) \ > +_ELF_DEFINE_RELOC(R_RISCV_LO12_S, 28) \ > +_ELF_DEFINE_RELOC(R_RISCV_TPREL_HI20, 29) \ > +_ELF_DEFINE_RELOC(R_RISCV_TPREL_LO12_I, 30) \ > +_ELF_DEFINE_RELOC(R_RISCV_TPREL_LO12_S, 31) \ > +_ELF_DEFINE_RELOC(R_RISCV_TPREL_ADD, 32) \ > +_ELF_DEFINE_RELOC(R_RISCV_ADD8, 33) \ > +_ELF_DEFINE_RELOC(R_RISCV_ADD16, 34) \ > +_ELF_DEFINE_RELOC(R_RISCV_ADD32, 35) \ > +_ELF_DEFINE_RELOC(R_RISCV_ADD64, 36) \ > +_ELF_DEFINE_RELOC(R_RISCV_SUB8, 37) \ > +_ELF_DEFINE_RELOC(R_RISCV_SUB16, 38) \ > +_ELF_DEFINE_RELOC(R_RISCV_SUB32, 39) \ > +_ELF_DEFINE_RELOC(R_RISCV_SUB64, 40) \ > +_ELF_DEFINE_RELOC(R_RISCV_GNU_VTINHERIT, 41) \ > +_ELF_DEFINE_RELOC(R_RISCV_GNU_VTENTRY, 42) \ > +_ELF_DEFINE_RELOC(R_RISCV_ALIGN, 43) \ > +_ELF_DEFINE_RELOC(R_RISCV_RVC_BRANCH, 44) \ > +_ELF_DEFINE_RELOC(R_RISCV_RVC_JUMP, 45) > + > +#define _ELF_DEFINE_SPARC_RELOCATIONS() \ > +_ELF_DEFINE_RELOC(R_SPARC_NONE, 0) \ > +_ELF_DEFINE_RELOC(R_SPARC_8, 1) \ > +_ELF_DEFINE_RELOC(R_SPARC_16, 2) \ > +_ELF_DEFINE_RELOC(R_SPARC_32, 3) \ > +_ELF_DEFINE_RELOC(R_SPARC_DISP8, 4) \ > +_ELF_DEFINE_RELOC(R_SPARC_DISP16, 5) \ > +_ELF_DEFINE_RELOC(R_SPARC_DISP32, 6) \ > +_ELF_DEFINE_RELOC(R_SPARC_WDISP30, 7) \ > +_ELF_DEFINE_RELOC(R_SPARC_WDISP22, 8) \ > +_ELF_DEFINE_RELOC(R_SPARC_HI22, 9) \ > +_ELF_DEFINE_RELOC(R_SPARC_22, 10) \ > +_ELF_DEFINE_RELOC(R_SPARC_13, 11) \ > +_ELF_DEFINE_RELOC(R_SPARC_LO10, 12) \ > +_ELF_DEFINE_RELOC(R_SPARC_GOT10, 13) \ > +_ELF_DEFINE_RELOC(R_SPARC_GOT13, 14) \ > +_ELF_DEFINE_RELOC(R_SPARC_GOT22, 15) \ > +_ELF_DEFINE_RELOC(R_SPARC_PC10, 16) \ > +_ELF_DEFINE_RELOC(R_SPARC_PC22, 17) \ > +_ELF_DEFINE_RELOC(R_SPARC_WPLT30, 18) \ > +_ELF_DEFINE_RELOC(R_SPARC_COPY, 19) \ > +_ELF_DEFINE_RELOC(R_SPARC_GLOB_DAT, 20) \ > +_ELF_DEFINE_RELOC(R_SPARC_JMP_SLOT, 21) \ > +_ELF_DEFINE_RELOC(R_SPARC_RELATIVE, 22) \ > +_ELF_DEFINE_RELOC(R_SPARC_UA32, 23) \ > +_ELF_DEFINE_RELOC(R_SPARC_PLT32, 24) \ > +_ELF_DEFINE_RELOC(R_SPARC_HIPLT22, 25) \ > +_ELF_DEFINE_RELOC(R_SPARC_LOPLT10, 26) \ > +_ELF_DEFINE_RELOC(R_SPARC_PCPLT32, 27) \ > +_ELF_DEFINE_RELOC(R_SPARC_PCPLT22, 28) \ > +_ELF_DEFINE_RELOC(R_SPARC_PCPLT10, 29) \ > +_ELF_DEFINE_RELOC(R_SPARC_10, 30) \ > +_ELF_DEFINE_RELOC(R_SPARC_11, 31) \ > +_ELF_DEFINE_RELOC(R_SPARC_64, 32) \ > +_ELF_DEFINE_RELOC(R_SPARC_OLO10, 33) \ > +_ELF_DEFINE_RELOC(R_SPARC_HH22, 34) \ > +_ELF_DEFINE_RELOC(R_SPARC_HM10, 35) \ > +_ELF_DEFINE_RELOC(R_SPARC_LM22, 36) \ > +_ELF_DEFINE_RELOC(R_SPARC_PC_HH22, 37) \ > +_ELF_DEFINE_RELOC(R_SPARC_PC_HM10, 38) \ > +_ELF_DEFINE_RELOC(R_SPARC_PC_LM22, 39) \ > +_ELF_DEFINE_RELOC(R_SPARC_WDISP16, 40) \ > +_ELF_DEFINE_RELOC(R_SPARC_WDISP19, 41) \ > +_ELF_DEFINE_RELOC(R_SPARC_7, 43) \ > +_ELF_DEFINE_RELOC(R_SPARC_5, 44) \ > +_ELF_DEFINE_RELOC(R_SPARC_6, 45) \ > +_ELF_DEFINE_RELOC(R_SPARC_DISP64, 46) \ > +_ELF_DEFINE_RELOC(R_SPARC_PLT64, 47) \ > +_ELF_DEFINE_RELOC(R_SPARC_HIX22, 48) \ > +_ELF_DEFINE_RELOC(R_SPARC_LOX10, 49) \ > +_ELF_DEFINE_RELOC(R_SPARC_H44, 50) \ > +_ELF_DEFINE_RELOC(R_SPARC_M44, 51) \ > +_ELF_DEFINE_RELOC(R_SPARC_L44, 52) \ > +_ELF_DEFINE_RELOC(R_SPARC_REGISTER, 53) \ > +_ELF_DEFINE_RELOC(R_SPARC_UA64, 54) \ > +_ELF_DEFINE_RELOC(R_SPARC_UA16, 55) \ > +_ELF_DEFINE_RELOC(R_SPARC_GOTDATA_HIX22, 80) \ > +_ELF_DEFINE_RELOC(R_SPARC_GOTDATA_LOX10, 81) \ > +_ELF_DEFINE_RELOC(R_SPARC_GOTDATA_OP_HIX22, 82) \ > +_ELF_DEFINE_RELOC(R_SPARC_GOTDATA_OP_LOX10, 83) \ > +_ELF_DEFINE_RELOC(R_SPARC_GOTDATA_OP, 84) \ > +_ELF_DEFINE_RELOC(R_SPARC_H34, 85) > + > +#define _ELF_DEFINE_X86_64_RELOCATIONS() \ > +_ELF_DEFINE_RELOC(R_X86_64_NONE, 0) \ > +_ELF_DEFINE_RELOC(R_X86_64_64, 1) \ > +_ELF_DEFINE_RELOC(R_X86_64_PC32, 2) \ > +_ELF_DEFINE_RELOC(R_X86_64_GOT32, 3) \ > +_ELF_DEFINE_RELOC(R_X86_64_PLT32, 4) \ > +_ELF_DEFINE_RELOC(R_X86_64_COPY, 5) \ > +_ELF_DEFINE_RELOC(R_X86_64_GLOB_DAT, 6) \ > +_ELF_DEFINE_RELOC(R_X86_64_JUMP_SLOT, 7) \ > +_ELF_DEFINE_RELOC(R_X86_64_RELATIVE, 8) \ > +_ELF_DEFINE_RELOC(R_X86_64_GOTPCREL, 9) \ > +_ELF_DEFINE_RELOC(R_X86_64_32, 10) \ > +_ELF_DEFINE_RELOC(R_X86_64_32S, 11) \ > +_ELF_DEFINE_RELOC(R_X86_64_16, 12) \ > +_ELF_DEFINE_RELOC(R_X86_64_PC16, 13) \ > +_ELF_DEFINE_RELOC(R_X86_64_8, 14) \ > +_ELF_DEFINE_RELOC(R_X86_64_PC8, 15) \ > +_ELF_DEFINE_RELOC(R_X86_64_DTPMOD64, 16) \ > +_ELF_DEFINE_RELOC(R_X86_64_DTPOFF64, 17) \ > +_ELF_DEFINE_RELOC(R_X86_64_TPOFF64, 18) \ > +_ELF_DEFINE_RELOC(R_X86_64_TLSGD, 19) \ > +_ELF_DEFINE_RELOC(R_X86_64_TLSLD, 20) \ > +_ELF_DEFINE_RELOC(R_X86_64_DTPOFF32, 21) \ > +_ELF_DEFINE_RELOC(R_X86_64_GOTTPOFF, 22) \ > +_ELF_DEFINE_RELOC(R_X86_64_TPOFF32, 23) \ > +_ELF_DEFINE_RELOC(R_X86_64_PC64, 24) \ > +_ELF_DEFINE_RELOC(R_X86_64_GOTOFF64, 25) \ > +_ELF_DEFINE_RELOC(R_X86_64_GOTPC32, 26) \ > +_ELF_DEFINE_RELOC(R_X86_64_GOT64, 27) \ > +_ELF_DEFINE_RELOC(R_X86_64_GOTPCREL64, 28) \ > +_ELF_DEFINE_RELOC(R_X86_64_GOTPC64, 29) \ > +_ELF_DEFINE_RELOC(R_X86_64_GOTPLT64, 30) \ > +_ELF_DEFINE_RELOC(R_X86_64_PLTOFF64, 31) \ > +_ELF_DEFINE_RELOC(R_X86_64_SIZE32, 32) \ > +_ELF_DEFINE_RELOC(R_X86_64_SIZE64, 33) \ > +_ELF_DEFINE_RELOC(R_X86_64_GOTPC32_TLSDESC, 34) \ > +_ELF_DEFINE_RELOC(R_X86_64_TLSDESC_CALL, 35) \ > +_ELF_DEFINE_RELOC(R_X86_64_TLSDESC, 36) \ > +_ELF_DEFINE_RELOC(R_X86_64_IRELATIVE, 37) > + > +#define _ELF_DEFINE_RELOCATIONS() \ > +_ELF_DEFINE_386_RELOCATIONS() \ > +_ELF_DEFINE_AARCH64_RELOCATIONS() \ > +_ELF_DEFINE_AMD64_RELOCATIONS() \ > +_ELF_DEFINE_ARM_RELOCATIONS() \ > +_ELF_DEFINE_IA64_RELOCATIONS() \ > +_ELF_DEFINE_MIPS_RELOCATIONS() \ > +_ELF_DEFINE_PPC32_RELOCATIONS() \ > +_ELF_DEFINE_PPC64_RELOCATIONS() \ > +_ELF_DEFINE_RISCV_RELOCATIONS() \ > +_ELF_DEFINE_SPARC_RELOCATIONS() \ > +_ELF_DEFINE_X86_64_RELOCATIONS() > + > +#undef _ELF_DEFINE_RELOC > +#define _ELF_DEFINE_RELOC(N, V) N = V , > +enum { > + _ELF_DEFINE_RELOCATIONS() > + R__LAST__ > +}; > + > +#define PN_XNUM 0xFFFFU /* Use extended section > numbering. */ > + > +/** > + ** ELF Types. > + **/ > + > +typedef uint32_t Elf32_Addr; /* Program address. */ > +typedef uint8_t Elf32_Byte; /* Unsigned tiny integer. */ > +typedef uint16_t Elf32_Half; /* Unsigned medium integer. */ > +typedef uint32_t Elf32_Off; /* File offset. */ > +typedef uint16_t Elf32_Section; /* Section index. */ > +typedef int32_t Elf32_Sword; /* Signed integer. */ > +typedef uint32_t Elf32_Word; /* Unsigned integer. */ > +typedef uint64_t Elf32_Lword; /* Unsigned long integer. */ > + > +typedef uint64_t Elf64_Addr; /* Program address. */ > +typedef uint8_t Elf64_Byte; /* Unsigned tiny integer. */ > +typedef uint16_t Elf64_Half; /* Unsigned medium integer. */ > +typedef uint64_t Elf64_Off; /* File offset. */ > +typedef uint16_t Elf64_Section; /* Section index. */ > +typedef int32_t Elf64_Sword; /* Signed integer. */ > +typedef uint32_t Elf64_Word; /* Unsigned integer. */ > +typedef uint64_t Elf64_Lword; /* Unsigned long integer. */ > +typedef uint64_t Elf64_Xword; /* Unsigned long integer. */ > +typedef int64_t Elf64_Sxword; /* Signed long integer. */ > + > + > +/* > + * Capability descriptors. > + */ > + > +/* 32-bit capability descriptor. */ > +typedef struct { > + Elf32_Word c_tag; /* Type of entry. */ > + union { > + Elf32_Word c_val; /* Integer value. */ > + Elf32_Addr c_ptr; /* Pointer value. */ > + } c_un; > +} Elf32_Cap; > + > +/* 64-bit capability descriptor. */ > +typedef struct { > + Elf64_Xword c_tag; /* Type of entry. */ > + union { > + Elf64_Xword c_val; /* Integer value. */ > + Elf64_Addr c_ptr; /* Pointer value. */ > + } c_un; > +} Elf64_Cap; > + > +/* > + * MIPS .conflict section entries. > + */ > + > +/* 32-bit entry. */ > +typedef struct { > + Elf32_Addr c_index; > +} Elf32_Conflict; > + > +/* 64-bit entry. */ > +typedef struct { > + Elf64_Addr c_index; > +} Elf64_Conflict; > + > +/* > + * Dynamic section entries. > + */ > + > +/* 32-bit entry. */ > +typedef struct { > + Elf32_Sword d_tag; /* Type of entry. */ > + union { > + Elf32_Word d_val; /* Integer value. */ > + Elf32_Addr d_ptr; /* Pointer value. */ > + } d_un; > +} Elf32_Dyn; > + > +/* 64-bit entry. */ > +typedef struct { > + Elf64_Sxword d_tag; /* Type of entry. */ > + union { > + Elf64_Xword d_val; /* Integer value. */ > + Elf64_Addr d_ptr; /* Pointer value; */ > + } d_un; > +} Elf64_Dyn; > + > + > +/* > + * The executable header (EHDR). > + */ > + > +/* 32 bit EHDR. */ > +typedef struct { > + unsigned char e_ident[EI_NIDENT]; /* ELF identification. */ > + Elf32_Half e_type; /* Object file type (ET_*). */ > + Elf32_Half e_machine; /* Machine type (EM_*). */ > + Elf32_Word e_version; /* File format version (EV_*). */ > + Elf32_Addr e_entry; /* Start address. */ > + Elf32_Off e_phoff; /* File offset to the PHDR table. */ > + Elf32_Off e_shoff; /* File offset to the SHDRheader. */ > + Elf32_Word e_flags; /* Flags (EF_*). */ > + Elf32_Half e_ehsize; /* Elf header size in bytes. */ > + Elf32_Half e_phentsize; /* PHDR table entry size in bytes. */ > + Elf32_Half e_phnum; /* Number of PHDR entries. */ > + Elf32_Half e_shentsize; /* SHDR table entry size in bytes. */ > + Elf32_Half e_shnum; /* Number of SHDR entries. */ > + Elf32_Half e_shstrndx; /* Index of section name string table. */ > +} Elf32_Ehdr; > + > + > +/* 64 bit EHDR. */ > +typedef struct { > + unsigned char e_ident[EI_NIDENT]; /* ELF identification. */ > + Elf64_Half e_type; /* Object file type (ET_*). */ > + Elf64_Half e_machine; /* Machine type (EM_*). */ > + Elf64_Word e_version; /* File format version (EV_*). */ > + Elf64_Addr e_entry; /* Start address. */ > + Elf64_Off e_phoff; /* File offset to the PHDR table. */ > + Elf64_Off e_shoff; /* File offset to the SHDRheader. */ > + Elf64_Word e_flags; /* Flags (EF_*). */ > + Elf64_Half e_ehsize; /* Elf header size in bytes. */ > + Elf64_Half e_phentsize; /* PHDR table entry size in bytes. */ > + Elf64_Half e_phnum; /* Number of PHDR entries. */ > + Elf64_Half e_shentsize; /* SHDR table entry size in bytes. */ > + Elf64_Half e_shnum; /* Number of SHDR entries. */ > + Elf64_Half e_shstrndx; /* Index of section name string table. */ > +} Elf64_Ehdr; > + > + > +/* > + * Shared object information. > + */ > + > +/* 32-bit entry. */ > +typedef struct { > + Elf32_Word l_name; /* The name of a shared object. */ > + Elf32_Word l_time_stamp; /* 32-bit timestamp. */ > + Elf32_Word l_checksum; /* Checksum of visible symbols, sizes. */ > + Elf32_Word l_version; /* Interface version string index. */ > + Elf32_Word l_flags; /* Flags (LL_*). */ > +} Elf32_Lib; > + > +/* 64-bit entry. */ > +typedef struct { > + Elf64_Word l_name; /* The name of a shared object. */ > + Elf64_Word l_time_stamp; /* 32-bit timestamp. */ > + Elf64_Word l_checksum; /* Checksum of visible symbols, sizes. */ > + Elf64_Word l_version; /* Interface version string index. */ > + Elf64_Word l_flags; /* Flags (LL_*). */ > +} Elf64_Lib; > + > +#define _ELF_DEFINE_LL_FLAGS() \ > +_ELF_DEFINE_LL(LL_NONE, 0, \ > + "no flags") \ > +_ELF_DEFINE_LL(LL_EXACT_MATCH, 0x1, \ > + "require an exact match") \ > +_ELF_DEFINE_LL(LL_IGNORE_INT_VER, 0x2, \ > + "ignore version incompatibilities") \ > +_ELF_DEFINE_LL(LL_REQUIRE_MINOR, 0x4, \ > + "") \ > +_ELF_DEFINE_LL(LL_EXPORTS, 0x8, \ > + "") \ > +_ELF_DEFINE_LL(LL_DELAY_LOAD, 0x10, \ > + "") \ > +_ELF_DEFINE_LL(LL_DELTA, 0x20, \ > + "") > + > +#undef _ELF_DEFINE_LL > +#define _ELF_DEFINE_LL(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_LL_FLAGS() > + LL__LAST__ > +}; > + > +/* > + * Note tags > + */ > + > +#define _ELF_DEFINE_NOTE_ENTRY_TYPES() > \ > +_ELF_DEFINE_NT(NT_ABI_TAG, 1, "Tag indicating the ABI") \ > +_ELF_DEFINE_NT(NT_GNU_HWCAP, 2, "Hardware capabilities") \ > +_ELF_DEFINE_NT(NT_GNU_BUILD_ID, 3, "Build id, set by ld(1)") > \ > +_ELF_DEFINE_NT(NT_GNU_GOLD_VERSION, 4, \ > + "Version number of the GNU gold linker") \ > +_ELF_DEFINE_NT(NT_PRSTATUS, 1, "Process status") \ > +_ELF_DEFINE_NT(NT_FPREGSET, 2, "Floating point information") \ > +_ELF_DEFINE_NT(NT_PRPSINFO, 3, "Process information") \ > +_ELF_DEFINE_NT(NT_AUXV, 6, "Auxiliary vector") > \ > +_ELF_DEFINE_NT(NT_PRXFPREG, 0x46E62B7FUL, \ > + "Linux user_xfpregs structure") \ > +_ELF_DEFINE_NT(NT_PSTATUS, 10, "Linux process status") \ > +_ELF_DEFINE_NT(NT_FPREGS, 12, "Linux floating point regset") \ > +_ELF_DEFINE_NT(NT_PSINFO, 13, "Linux process information") \ > +_ELF_DEFINE_NT(NT_LWPSTATUS, 16, "Linux lwpstatus_t type") \ > +_ELF_DEFINE_NT(NT_LWPSINFO, 17, "Linux lwpinfo_t type") > + > +#undef _ELF_DEFINE_NT > +#define _ELF_DEFINE_NT(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_NOTE_ENTRY_TYPES() > + NT__LAST__ > +}; > + > +/* Aliases for the ABI tag. */ > +#define NT_FREEBSD_ABI_TAG NT_ABI_TAG > +#define NT_GNU_ABI_TAG NT_ABI_TAG > +#define NT_NETBSD_IDENT NT_ABI_TAG > +#define NT_OPENBSD_IDENT NT_ABI_TAG > + > +/* > + * Note descriptors. > + */ > + > +typedef struct { > + uint32_t n_namesz; /* Length of note's name. */ > + uint32_t n_descsz; /* Length of note's value. */ > + uint32_t n_type; /* Type of note. */ > +} Elf_Note; > + > +typedef Elf_Note Elf32_Nhdr; /* 32-bit note header. */ > +typedef Elf_Note Elf64_Nhdr; /* 64-bit note header. */ > + > +/* > + * MIPS ELF options descriptor header. > + */ > + > +typedef struct { > + Elf64_Byte kind; /* Type of options. */ > + Elf64_Byte size; /* Size of option descriptor. */ > + Elf64_Half section; /* Index of section affected. */ > + Elf64_Word info; /* Kind-specific information. */ > +} Elf_Options; > + > +/* > + * Option kinds. > + */ > + > +#define _ELF_DEFINE_OPTION_KINDS() > \ > +_ELF_DEFINE_ODK(ODK_NULL, 0, "undefined") \ > +_ELF_DEFINE_ODK(ODK_REGINFO, 1, "register usage info") \ > +_ELF_DEFINE_ODK(ODK_EXCEPTIONS, 2, "exception processing info") \ > +_ELF_DEFINE_ODK(ODK_PAD, 3, "section padding") \ > +_ELF_DEFINE_ODK(ODK_HWPATCH, 4, "hardware patch applied") \ > +_ELF_DEFINE_ODK(ODK_FILL, 5, "fill value used by linker") \ > +_ELF_DEFINE_ODK(ODK_TAGS, 6, "reserved space for tools") \ > +_ELF_DEFINE_ODK(ODK_HWAND, 7, "hardware AND patch applied") \ > +_ELF_DEFINE_ODK(ODK_HWOR, 8, "hardware OR patch applied") \ > +_ELF_DEFINE_ODK(ODK_GP_GROUP, 9, \ > + "GP group to use for text/data sections") \ > +_ELF_DEFINE_ODK(ODK_IDENT, 10, "ID information") \ > +_ELF_DEFINE_ODK(ODK_PAGESIZE, 11, "page size infomation") > + > +#undef _ELF_DEFINE_ODK > +#define _ELF_DEFINE_ODK(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_OPTION_KINDS() > + ODK__LAST__ > +}; > + > +/* > + * ODK_EXCEPTIONS info field masks. > + */ > + > +#define _ELF_DEFINE_ODK_EXCEPTIONS_MASK() > \ > +_ELF_DEFINE_OEX(OEX_FPU_MIN, 0x0000001FUL, \ > + "minimum FPU exception which must be enabled") \ > +_ELF_DEFINE_OEX(OEX_FPU_MAX, 0x00001F00UL, \ > + "maximum FPU exception which can be enabled") \ > +_ELF_DEFINE_OEX(OEX_PAGE0, 0x00010000UL, \ > + "page zero must be mapped") \ > +_ELF_DEFINE_OEX(OEX_SMM, 0x00020000UL, \ > + "run in sequential memory mode") \ > +_ELF_DEFINE_OEX(OEX_PRECISEFP, 0x00040000UL, \ > + "run in precise FP exception mode") \ > +_ELF_DEFINE_OEX(OEX_DISMISS, 0x00080000UL, \ > + "dismiss invalid address traps") > + > +#undef _ELF_DEFINE_OEX > +#define _ELF_DEFINE_OEX(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_ODK_EXCEPTIONS_MASK() > + OEX__LAST__ > +}; > + > +/* > + * ODK_PAD info field masks. > + */ > + > +#define _ELF_DEFINE_ODK_PAD_MASK() > \ > +_ELF_DEFINE_OPAD(OPAD_PREFIX, 0x0001) > \ > +_ELF_DEFINE_OPAD(OPAD_POSTFIX, 0x0002) > \ > +_ELF_DEFINE_OPAD(OPAD_SYMBOL, 0x0004) > + > +#undef _ELF_DEFINE_OPAD > +#define _ELF_DEFINE_OPAD(N, V) N = V , > +enum { > + _ELF_DEFINE_ODK_PAD_MASK() > + OPAD__LAST__ > +}; > + > +/* > + * ODK_HWPATCH info field masks. > + */ > + > +#define _ELF_DEFINE_ODK_HWPATCH_MASK() > \ > +_ELF_DEFINE_OHW(OHW_R4KEOP, 0x00000001UL, \ > + "patch for R4000 branch at end-of-page bug") \ > +_ELF_DEFINE_OHW(OHW_R8KPFETCH, 0x00000002UL, \ > + "R8000 prefetch bug may occur") \ > +_ELF_DEFINE_OHW(OHW_R5KEOP, 0x00000004UL, \ > + "patch for R5000 branch at end-of-page bug") \ > +_ELF_DEFINE_OHW(OHW_R5KCVTL, 0x00000008UL, \ > + "R5000 cvt.[ds].l bug: clean == 1") \ > +_ELF_DEFINE_OHW(OHW_R10KLDL, 0x00000010UL, \ > + "needd patch for R10000 misaligned load") > + > +#undef _ELF_DEFINE_OHW > +#define _ELF_DEFINE_OHW(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_ODK_HWPATCH_MASK() > + OHW__LAST__ > +}; > + > +/* > + * ODK_HWAND/ODK_HWOR info field and hwp_flags[12] masks. > + */ > + > +#define _ELF_DEFINE_ODK_HWP_MASK() > \ > +_ELF_DEFINE_HWP(OHWA0_R4KEOP_CHECKED, 0x00000001UL, \ > + "object checked for R4000 end-of-page bug") \ > +_ELF_DEFINE_HWP(OHWA0_R4KEOP_CLEAN, 0x00000002UL, \ > + "object verified clean for R4000 end-of-page bug") \ > +_ELF_DEFINE_HWP(OHWO0_FIXADE, 0x00000001UL, \ > + "object requires call to fixade") > + > +#undef _ELF_DEFINE_HWP > +#define _ELF_DEFINE_HWP(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_ODK_HWP_MASK() > + OHWX0__LAST__ > +}; > + > +/* > + * ODK_IDENT/ODK_GP_GROUP info field masks. > + */ > + > +#define _ELF_DEFINE_ODK_GP_MASK() > \ > +_ELF_DEFINE_OGP(OGP_GROUP, 0x0000FFFFUL, "GP group number") \ > +_ELF_DEFINE_OGP(OGP_SELF, 0x00010000UL, \ > + "GP group is self-contained") > + > +#undef _ELF_DEFINE_OGP > +#define _ELF_DEFINE_OGP(N, V, DESCR) N = V , > +enum { > + _ELF_DEFINE_ODK_GP_MASK() > + OGP__LAST__ > +}; > + > +/* > + * MIPS ELF register info descriptor. > + */ > + > +/* 32 bit RegInfo entry. */ > +typedef struct { > + Elf32_Word ri_gprmask; /* Mask of general register used. */ > + Elf32_Word ri_cprmask[4]; /* Mask of coprocessor register used. > */ > + Elf32_Addr ri_gp_value; /* GP register value. */ > +} Elf32_RegInfo; > + > +/* 64 bit RegInfo entry. */ > +typedef struct { > + Elf64_Word ri_gprmask; /* Mask of general register used. */ > + Elf64_Word ri_pad; /* Padding. */ > + Elf64_Word ri_cprmask[4]; /* Mask of coprocessor register used. > */ > + Elf64_Addr ri_gp_value; /* GP register value. */ > +} Elf64_RegInfo; > + > +/* > + * Program Header Table (PHDR) entries. > + */ > + > +/* 32 bit PHDR entry. */ > +typedef struct { > + Elf32_Word p_type; /* Type of segment. */ > + Elf32_Off p_offset; /* File offset to segment. */ > + Elf32_Addr p_vaddr; /* Virtual address in memory. */ > + Elf32_Addr p_paddr; /* Physical address (if relevant). */ > + Elf32_Word p_filesz; /* Size of segment in file. */ > + Elf32_Word p_memsz; /* Size of segment in memory. */ > + Elf32_Word p_flags; /* Segment flags. */ > + Elf32_Word p_align; /* Alignment constraints. */ > +} Elf32_Phdr; > + > +/* 64 bit PHDR entry. */ > +typedef struct { > + Elf64_Word p_type; /* Type of segment. */ > + Elf64_Word p_flags; /* Segment flags. */ > + Elf64_Off p_offset; /* File offset to segment. */ > + Elf64_Addr p_vaddr; /* Virtual address in memory. */ > + Elf64_Addr p_paddr; /* Physical address (if relevant). */ > + Elf64_Xword p_filesz; /* Size of segment in file. */ > + Elf64_Xword p_memsz; /* Size of segment in memory. */ > + Elf64_Xword p_align; /* Alignment constraints. */ > +} Elf64_Phdr; > + > + > +/* > + * Move entries, for describing data in COMMON blocks in a compact > + * manner. > + */ > + > +/* 32-bit move entry. */ > +typedef struct { > + Elf32_Lword m_value; /* Initialization value. */ > + Elf32_Word m_info; /* Encoded size and index. */ > + Elf32_Word m_poffset; /* Offset relative to symbol. */ > + Elf32_Half m_repeat; /* Repeat count. */ > + Elf32_Half m_stride; /* Number of units to skip. */ > +} Elf32_Move; > + > +/* 64-bit move entry. */ > +typedef struct { > + Elf64_Lword m_value; /* Initialization value. */ > + Elf64_Xword m_info; /* Encoded size and index. */ > + Elf64_Xword m_poffset; /* Offset relative to symbol. */ > + Elf64_Half m_repeat; /* Repeat count. */ > + Elf64_Half m_stride; /* Number of units to skip. */ > +} Elf64_Move; > + > +#define ELF32_M_SYM(I) ((I) >> 8) > +#define ELF32_M_SIZE(I) ((unsigned char) (I)) > +#define ELF32_M_INFO(M, S) (((M) << 8) + (unsigned char) (S)) > + > +#define ELF64_M_SYM(I) ((I) >> 8) > +#define ELF64_M_SIZE(I) ((unsigned char) (I)) > +#define ELF64_M_INFO(M, S) (((M) << 8) + (unsigned char) (S)) > + > +/* > + * Section Header Table (SHDR) entries. > + */ > + > +/* 32 bit SHDR */ > +typedef struct { > + Elf32_Word sh_name; /* index of section name */ > + Elf32_Word sh_type; /* section type */ > + Elf32_Word sh_flags; /* section flags */ > + Elf32_Addr sh_addr; /* in-memory address of section */ > + Elf32_Off sh_offset; /* file offset of section */ > + Elf32_Word sh_size; /* section size in bytes */ > + Elf32_Word sh_link; /* section header table link */ > + Elf32_Word sh_info; /* extra information */ > + Elf32_Word sh_addralign; /* alignment constraint */ > + Elf32_Word sh_entsize; /* size for fixed-size entries */ > +} Elf32_Shdr; > + > +/* 64 bit SHDR */ > +typedef struct { > + Elf64_Word sh_name; /* index of section name */ > + Elf64_Word sh_type; /* section type */ > + Elf64_Xword sh_flags; /* section flags */ > + Elf64_Addr sh_addr; /* in-memory address of section */ > + Elf64_Off sh_offset; /* file offset of section */ > + Elf64_Xword sh_size; /* section size in bytes */ > + Elf64_Word sh_link; /* section header table link */ > + Elf64_Word sh_info; /* extra information */ > + Elf64_Xword sh_addralign; /* alignment constraint */ > + Elf64_Xword sh_entsize; /* size for fixed-size entries */ > +} Elf64_Shdr; > + > + > +/* > + * Symbol table entries. > + */ > + > +typedef struct { > + Elf32_Word st_name; /* index of symbol's name */ > + Elf32_Addr st_value; /* value for the symbol */ > + Elf32_Word st_size; /* size of associated data */ > + unsigned char st_info; /* type and binding attributes */ > + unsigned char st_other; /* visibility */ > + Elf32_Half st_shndx; /* index of related section */ > +} Elf32_Sym; > + > +typedef struct { > + Elf64_Word st_name; /* index of symbol's name */ > + unsigned char st_info; /* type and binding attributes */ > + unsigned char st_other; /* visibility */ > + Elf64_Half st_shndx; /* index of related section */ > + Elf64_Addr st_value; /* value for the symbol */ > + Elf64_Xword st_size; /* size of associated data */ > +} Elf64_Sym; > + > +#define ELF32_ST_BIND(I) ((I) >> 4) > +#define ELF32_ST_TYPE(I) ((I) & 0xFU) > +#define ELF32_ST_INFO(B,T) (((B) << 4) + ((T) & 0xF)) > + > +#define ELF64_ST_BIND(I) ((I) >> 4) > +#define ELF64_ST_TYPE(I) ((I) & 0xFU) > +#define ELF64_ST_INFO(B,T) (((B) << 4) + ((T) & 0xF)) > + > +#define ELF32_ST_VISIBILITY(O) ((O) & 0x3) > +#define ELF64_ST_VISIBILITY(O) ((O) & 0x3) > + > +/* > + * Syminfo descriptors, containing additional symbol information. > + */ > + > +/* 32-bit entry. */ > +typedef struct { > + Elf32_Half si_boundto; /* Entry index with additional flags. */ > + Elf32_Half si_flags; /* Flags. */ > +} Elf32_Syminfo; > + > +/* 64-bit entry. */ > +typedef struct { > + Elf64_Half si_boundto; /* Entry index with additional flags. */ > + Elf64_Half si_flags; /* Flags. */ > +} Elf64_Syminfo; > + > +/* > + * Relocation descriptors. > + */ > + > +typedef struct { > + Elf32_Addr r_offset; /* location to apply relocation to */ > + Elf32_Word r_info; /* type+section for relocation */ > +} Elf32_Rel; > + > +typedef struct { > + Elf32_Addr r_offset; /* location to apply relocation to */ > + Elf32_Word r_info; /* type+section for relocation */ > + Elf32_Sword r_addend; /* constant addend */ > +} Elf32_Rela; > + > +typedef struct { > + Elf64_Addr r_offset; /* location to apply relocation to */ > + Elf64_Xword r_info; /* type+section for relocation */ > +} Elf64_Rel; > + > +typedef struct { > + Elf64_Addr r_offset; /* location to apply relocation to */ > + Elf64_Xword r_info; /* type+section for relocation */ > + Elf64_Sxword r_addend; /* constant addend */ > +} Elf64_Rela; > + > + > +#define ELF32_R_SYM(I) ((I) >> 8) > +#define ELF32_R_TYPE(I) ((unsigned char) (I)) > +#define ELF32_R_INFO(S,T) (((S) << 8) + (unsigned char) (T)) > + > +#define ELF64_R_SYM(I) ((I) >> 32) > +#define ELF64_R_TYPE(I) ((I) & 0xFFFFFFFFUL) > +#define ELF64_R_INFO(S,T) (((S) << 32) + ((T) & 0xFFFFFFFFUL)) > + > +/* > + * Symbol versioning structures. > + */ > + > +/* 32-bit structures. */ > +typedef struct > +{ > + Elf32_Word vda_name; /* Index to name. */ > + Elf32_Word vda_next; /* Offset to next entry. */ > +} Elf32_Verdaux; > + > +typedef struct > +{ > + Elf32_Word vna_hash; /* Hash value of dependency name. */ > + Elf32_Half vna_flags; /* Flags. */ > + Elf32_Half vna_other; /* Unused. */ > + Elf32_Word vna_name; /* Offset to dependency name. */ > + Elf32_Word vna_next; /* Offset to next vernaux entry. */ > +} Elf32_Vernaux; > + > +typedef struct > +{ > + Elf32_Half vd_version; /* Version information. */ > + Elf32_Half vd_flags; /* Flags. */ > + Elf32_Half vd_ndx; /* Index into the versym section. */ > + Elf32_Half vd_cnt; /* Number of aux entries. */ > + Elf32_Word vd_hash; /* Hash value of name. */ > + Elf32_Word vd_aux; /* Offset to aux entries. */ > + Elf32_Word vd_next; /* Offset to next version definition. */ > +} Elf32_Verdef; > + > +typedef struct > +{ > + Elf32_Half vn_version; /* Version number. */ > + Elf32_Half vn_cnt; /* Number of aux entries. */ > + Elf32_Word vn_file; /* Offset of associated file name. */ > + Elf32_Word vn_aux; /* Offset of vernaux array. */ > + Elf32_Word vn_next; /* Offset of next verneed entry. */ > +} Elf32_Verneed; > + > +typedef Elf32_Half Elf32_Versym; > + > +/* 64-bit structures. */ > + > +typedef struct { > + Elf64_Word vda_name; /* Index to name. */ > + Elf64_Word vda_next; /* Offset to next entry. */ > +} Elf64_Verdaux; > + > +typedef struct { > + Elf64_Word vna_hash; /* Hash value of dependency name. */ > + Elf64_Half vna_flags; /* Flags. */ > + Elf64_Half vna_other; /* Unused. */ > + Elf64_Word vna_name; /* Offset to dependency name. */ > + Elf64_Word vna_next; /* Offset to next vernaux entry. */ > +} Elf64_Vernaux; > + > +typedef struct { > + Elf64_Half vd_version; /* Version information. */ > + Elf64_Half vd_flags; /* Flags. */ > + Elf64_Half vd_ndx; /* Index into the versym section. */ > + Elf64_Half vd_cnt; /* Number of aux entries. */ > + Elf64_Word vd_hash; /* Hash value of name. */ > + Elf64_Word vd_aux; /* Offset to aux entries. */ > + Elf64_Word vd_next; /* Offset to next version definition. */ > +} Elf64_Verdef; > + > +typedef struct { > + Elf64_Half vn_version; /* Version number. */ > + Elf64_Half vn_cnt; /* Number of aux entries. */ > + Elf64_Word vn_file; /* Offset of associated file name. */ > + Elf64_Word vn_aux; /* Offset of vernaux array. */ > + Elf64_Word vn_next; /* Offset of next verneed entry. */ > +} Elf64_Verneed; > + > +typedef Elf64_Half Elf64_Versym; > + > + > +/* > + * The header for GNU-style hash sections. > + */ > + > +typedef struct { > + uint32_t gh_nbuckets; /* Number of hash buckets. */ > + uint32_t gh_symndx; /* First visible symbol in .dynsym. */ > + uint32_t gh_maskwords; /* #maskwords used in bloom filter. */ > + uint32_t gh_shift2; /* Bloom filter shift count. */ > +} Elf_GNU_Hash_Header; > + > +#endif /* _ELFDEFINITIONS_H_ */ > diff --git a/include/gelf.h b/include/gelf.h > new file mode 100644 > index 0000000..6eae0a5 > --- /dev/null > +++ b/include/gelf.h > @@ -0,0 +1,110 @@ > +/*- > + * Copyright (c) 2006,2008 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. > + * > + * $Id: gelf.h 3174 2015-03-27 17:13:41Z emaste $ > + */ > + > +#ifndef _GELF_H_ > +#define _GELF_H_ > + > +#include <libelf.h> > + > +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 > + > +#ifdef __cplusplus > +extern "C" { > +#endif > +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/include/libelf.h b/include/libelf.h > new file mode 100644 > index 0000000..47c11b9 > --- /dev/null > +++ b/include/libelf.h > @@ -0,0 +1,256 @@ > +/*- > + * Copyright (c) 2006,2008-2010 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. > + * > + * $Id: libelf.h 3174 2015-03-27 17:13:41Z emaste $ > + */ > + > +#ifndef _LIBELF_H_ > +#define _LIBELF_H_ > + > +#include <sys/types.h> > + > +#include <elfdefinitions.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_GNUHASH, /* GNU style hash tables. */ > + ELF_T_NUM > +} Elf_Type; > + > +#define ELF_T_FIRST ELF_T_ADDR > +#define ELF_T_LAST ELF_T_GNUHASH > + > +/* 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; > +} 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; > + > + /* > + * Members that are not part of the public API. > + */ > + unsigned int ar_flags; > +} 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(3) API extensions. */ > +#define ELF_F_ARCHIVE 0x100U /* archive creation */ > +#define ELF_F_ARCHIVE_SYSV 0x200U /* SYSV style archive */ > + > +#ifdef __cplusplus > +extern "C" { > +#endif > +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_flagarhdr(Elf_Arhdr *_arh, Elf_Cmd _cmd, > + unsigned int _flags); > +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_getphdrnum(Elf *_elf, size_t *_dst); > +int elf_getphnum(Elf *_elf, size_t *_dst); /* Deprecated */ > +Elf_Scn *elf_getscn(Elf *_elf, size_t _index); > +int elf_getshdrnum(Elf *_elf, size_t *_dst); > +int elf_getshnum(Elf *_elf, size_t *_dst); /* Deprecated */ > +int elf_getshdrstrndx(Elf *_elf, size_t *_dst); > +int elf_getshstrndx(Elf *_elf, size_t *_dst); /* Deprecated */ > +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); > +Elf *elf_open(int _fd); > +Elf *elf_openmemory(char *_image, size_t _size); > +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/libelf_align.c b/libelf_align.c > new file mode 100644 > index 0000000..5afb98b > --- /dev/null > +++ b/libelf_align.c > @@ -0,0 +1,135 @@ > +/*- > + * Copyright (c) 2006,2008 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 <libelf.h> > + > +#include "_libelf.h" > + > +ELFTC_VCSID("$Id: libelf_align.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +struct align { > + unsigned int a32; > + unsigned int a64; > +}; > + > +#ifdef __GNUC__ > +#define MALIGN(N) { \ > + .a32 = __alignof__(Elf32_##N), \ > + .a64 = __alignof__(Elf64_##N) \ > + } > +#define MALIGN64(V) { \ > + .a32 = 0, \ > + .a64 = __alignof__(Elf64_##V) \ > + } > +#define MALIGN_WORD() { \ > + .a32 = __alignof__(int32_t), \ > + .a64 = __alignof__(int64_t) \ > + } > +#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), > + [ELF_T_GNUHASH] = MALIGN_WORD() > +}; > + > +unsigned 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), > + [ELF_T_GNUHASH] = FALIGN(4,8) > +}; > + > +unsigned 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/libelf_allocate.c b/libelf_allocate.c > new file mode 100644 > index 0000000..0a74fac > --- /dev/null > +++ b/libelf_allocate.c > @@ -0,0 +1,210 @@ > +/*- > + * Copyright (c) 2006,2008,2010 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 <assert.h> > +#include <errno.h> > +#include <libelf.h> > +#include <stdlib.h> > +#include <string.h> > + > +#include "_libelf.h" > + > +ELFTC_VCSID("$Id: libelf_allocate.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +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_hdr.e_rawhdr = 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) > +{ > + Elf_Arhdr *arh; > + > + 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_flags & LIBELF_F_AR_HEADER) { > + arh = e->e_hdr.e_arhdr; > + FREE(arh->ar_name); > + FREE(arh->ar_rawname); > + free(arh); > + } > + > + break; > + > + default: > + break; > + } > + > + free(e); > + > + return (NULL); > +} > + > +struct _Libelf_Data * > +_libelf_allocate_data(Elf_Scn *s) > +{ > + struct _Libelf_Data *d; > + > + if ((d = calloc((size_t) 1, sizeof(*d))) == NULL) { > + LIBELF_SET_ERROR(RESOURCE, 0); > + return (NULL); > + } > + > + d->d_scn = s; > + > + return (d); > +} > + > +struct _Libelf_Data * > +_libelf_release_data(struct _Libelf_Data *d) > +{ > + > + if (d->d_flags & LIBELF_F_DATA_MALLOCED) > + free(d->d_data.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; > + struct _Libelf_Data *d, *td; > + > + assert(s != NULL); > + > + STAILQ_FOREACH_SAFE(d, &s->s_data, d_next, td) { > + STAILQ_REMOVE(&s->s_data, d, _Libelf_Data, d_next); > + d = _libelf_release_data(d); > + } > + > + STAILQ_FOREACH_SAFE(d, &s->s_rawdata, d_next, td) { > + assert((d->d_flags & LIBELF_F_DATA_MALLOCED) == 0); > + STAILQ_REMOVE(&s->s_rawdata, d, _Libelf_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/libelf_ar.c b/libelf_ar.c > new file mode 100644 > index 0000000..faeec2c > --- /dev/null > +++ b/libelf_ar.c > @@ -0,0 +1,466 @@ > +/*- > + * Copyright (c) 2006,2008,2010 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 <ctype.h> > +#include <libelf.h> > +#include <stdlib.h> > +#include <string.h> > + > +#include "_libelf.h" > +#include "_libelf_ar.h" > + > +ELFTC_VCSID("$Id: libelf_ar.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +#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: > + * > + * There are two variants of the `ar' archive format: traditional BSD > + * and SVR4. These differ in the way long file names are treated, and > + * in the layout of the archive symbol table. > + * > + * The `ar' header only has space for a 16 character file name. > + * > + * In the SVR4 format, file names are terminated with a '/', so this > + * effectively leaves 15 characters for the actual file name. Longer > + * file names stored in a separate 'string table' and referenced > + * indirectly from the name field. 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. > + * > + * In the BSD format, file names can be upto 16 characters. File > + * names shorter than 16 characters are padded to 16 characters using > + * (ASCII) space characters. File names with embedded spaces and file > + * names longer than 16 characters are stored immediately after the > + * archive header and the name field set to a special indirect name > + * matching the pattern "#1/[0-9]+". The digits form a decimal number > + * that corresponds to the actual length of the file name following > + * the archive header. The content of the archive member immediately > + * follows the file name, and the size field of the archive member > + * holds the sum of the sizes of the member and of the appended file > + * name. > + * > + * Archives may also have a symbol table (see ranlib(1)), mapping > + * program symbols to object files inside the archive. > + * > + * In the SVR4 format, 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. > + * > + * In the BSD format, the symbol table uses a file name of "__.SYMDEF". > + * It is structured as two parts: > + * - The first part is an array of "ranlib" structures preceded by > + * the size of the array in bytes. Each "ranlib" structure > + * describes one symbol. Each structure contains an offset into > + * the string table for the symbol name, and a file offset into the > + * archive for the member defining the symbol. > + * - The second part is a string table containing NUL-terminated > + * strings, preceded by the size of the string table in bytes. > + * > + * If the symbol table and string table are is present in an archive > + * they must be the very first objects and in that order. > + */ > + > + > +/* > + * Retrieve an archive header descriptor. > + */ > + > +Elf_Arhdr * > +_libelf_ar_gethdr(Elf *e) > +{ > + Elf *parent; > + Elf_Arhdr *eh; > + char *namelen; > + size_t n, nlen; > + struct ar_hdr *arh; > + > + if ((parent = e->e_parent) == NULL) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (NULL); > + } > + > + assert((e->e_flags & LIBELF_F_AR_HEADER) == 0); > + > + arh = (struct ar_hdr *) (uintptr_t) e->e_hdr.e_rawhdr; > + > + 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_hdr.e_arhdr = eh; > + e->e_flags |= LIBELF_F_AR_HEADER; > + > + eh->ar_name = eh->ar_rawname = NULL; > + > + if ((eh->ar_name = _libelf_ar_get_translated_name(arh, 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; > + > + /* > + * Get the true size of the member if extended naming is being used. > + */ > + if (IS_EXTENDED_BSD_NAME(arh->ar_name)) { > + namelen = arh->ar_name + > + LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE; > + if (_libelf_ar_get_number(namelen, sizeof(arh->ar_name) - > + LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE, 10, &nlen) == 0) > + goto error; > + n -= nlen; > + } > + > + eh->ar_size = n; > + > + if ((eh->ar_rawname = _libelf_ar_get_raw_name(arh)) == NULL) > + goto error; > + > + eh->ar_flags = 0; > + > + 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_flags &= ~LIBELF_F_AR_HEADER; > + e->e_hdr.e_rawhdr = (unsigned char *) arh; > + > + return (NULL); > +} > + > +Elf * > +_libelf_ar_open_member(int fd, Elf_Cmd c, Elf *elf) > +{ > + Elf *e; > + off_t next; > + size_t nsz, sz; > + struct ar_hdr *arh; > + char *member, *namelen; > + > + 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); > + > + /* > + * Retrieve the size of the member. > + */ > + if (_libelf_ar_get_number(arh->ar_size, sizeof(arh->ar_size), 10, > + &sz) == 0) { > + LIBELF_SET_ERROR(ARCHIVE, 0); > + return (NULL); > + } > + > + /* > + * Adjust the size field for members in BSD archives using > + * extended naming. > + */ > + if (IS_EXTENDED_BSD_NAME(arh->ar_name)) { > + namelen = arh->ar_name + > + LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE; > + if (_libelf_ar_get_number(namelen, sizeof(arh->ar_name) - > + LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE, 10, &nsz) == 0) { > + LIBELF_SET_ERROR(ARCHIVE, 0); > + return (NULL); > + } > + > + member = (char *) (arh + 1) + nsz; > + sz -= nsz; > + } else > + member = (char *) (arh + 1); > + > + > + if ((e = elf_memory(member, sz)) == NULL) > + return (NULL); > + > + e->e_fd = fd; > + e->e_cmd = c; > + e->e_hdr.e_rawhdr = (unsigned char *) arh; > + > + elf->e_u.e_ar.e_nchildren++; > + e->e_parent = elf; > + > + return (e); > +} > + > +/* > + * A BSD-style ar(1) symbol table has the following layout: > + * > + * - A count of bytes used by the following array of 'ranlib' > + * structures, stored as a 'long'. > + * - An array of 'ranlib' structures. Each array element is > + * two 'long's in size. > + * - A count of bytes used for the following symbol table. > + * - The symbol table itself. > + */ > + > +/* > + * A helper macro to read in a 'long' value from the archive. > + * > + * We use memcpy() since the source pointer may be misaligned with > + * respect to the natural alignment for a C 'long'. > + */ > +#define GET_LONG(P, V)do { \ > + memcpy(&(V), (P), sizeof(long)); \ > + (P) += sizeof(long); \ > + } while (0) > + > +Elf_Arsym * > +_libelf_ar_process_bsd_symtab(Elf *e, size_t *count) > +{ > + Elf_Arsym *symtab, *sym; > + unsigned int n, nentries; > + unsigned char *end, *p, *p0, *s, *s0; > + const size_t entrysize = 2 * sizeof(long); > + long arraysize, fileoffset, stroffset, strtabsize; > + > + assert(e != NULL); > + assert(count != NULL); > + assert(e->e_u.e_ar.e_symtab == NULL); > + > + symtab = NULL; > + > + /* > + * The BSD symbol table always contains the count fields even > + * if there are no entries in it. > + */ > + if (e->e_u.e_ar.e_rawsymtabsz < 2 * sizeof(long)) > + goto symtaberror; > + > + p = p0 = (unsigned char *) e->e_u.e_ar.e_rawsymtab; > + end = p0 + e->e_u.e_ar.e_rawsymtabsz; > + > + /* > + * Retrieve the size of the array of ranlib descriptors and > + * check it for validity. > + */ > + GET_LONG(p, arraysize); > + > + if (arraysize < 0 || p0 + arraysize >= end || > + ((size_t) arraysize % entrysize != 0)) > + goto symtaberror; > + > + /* > + * Check the value of the string table size. > + */ > + s = p + arraysize; > + GET_LONG(s, strtabsize); > + > + s0 = s; /* Start of string table. */ > + if (strtabsize < 0 || s0 + strtabsize > end) > + goto symtaberror; > + > + nentries = (size_t) arraysize / entrysize; > + > + /* > + * Allocate space for the returned Elf_Arsym array. > + */ > + if ((symtab = malloc(sizeof(Elf_Arsym) * (nentries + 1))) == NULL) { > + LIBELF_SET_ERROR(RESOURCE, 0); > + return (NULL); > + } > + > + /* Read in symbol table entries. */ > + for (n = 0, sym = symtab; n < nentries; n++, sym++) { > + GET_LONG(p, stroffset); > + GET_LONG(p, fileoffset); > + > + if (stroffset < 0 || fileoffset < 0 || > + (size_t) fileoffset >= e->e_rawsize) > + goto symtaberror; > + > + s = s0 + stroffset; > + > + if (s >= end) > + goto symtaberror; > + > + sym->as_off = (off_t) fileoffset; > + sym->as_hash = elf_hash((char *) s); > + sym->as_name = (char *) s; > + } > + > + /* Fill up the sentinel entry. */ > + sym->as_name = NULL; > + sym->as_hash = ~0UL; > + sym->as_off = (off_t) 0; > + > + /* Remember the processed symbol table. */ > + e->e_u.e_ar.e_symtab = symtab; > + > + *count = e->e_u.e_ar.e_symtabsz = nentries + 1; > + > + return (symtab); > + > +symtaberror: > + if (symtab) > + free(symtab); > + LIBELF_SET_ERROR(ARCHIVE, 0); > + return (NULL); > +} > + > +/* > + * An SVR4-style 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_svr4_symtab(Elf *e, size_t *count) > +{ > + uint32_t off; > + size_t n, nentries; > + Elf_Arsym *symtab, *sym; > + unsigned char *p, *s, *end; > + > + assert(e != NULL); > + assert(count != NULL); > + assert(e->e_u.e_ar.e_symtab == NULL); > + > + symtab = NULL; > + > + if (e->e_u.e_ar.e_rawsymtabsz < INTSZ) > + goto symtaberror; > + > + p = (unsigned char *) 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) > + goto symtaberror; > + > + /* 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--) { > + if (s >= end) > + goto symtaberror; > + > + GET_WORD(p, off); > + if (off >= e->e_rawsize) > + goto symtaberror; > + > + sym->as_off = (off_t) off; > + sym->as_hash = elf_hash((char *) s); > + sym->as_name = (char *) s; > + > + p += INTSZ; > + sym++; > + > + for (; s < end && *s++ != '\0';) /* skip to next string */ > + ; > + } > + > + /* 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); > + > +symtaberror: > + if (symtab) > + free(symtab); > + LIBELF_SET_ERROR(ARCHIVE, 0); > + return (NULL); > +} > diff --git a/libelf_ar_util.c b/libelf_ar_util.c > new file mode 100644 > index 0000000..239612e > --- /dev/null > +++ b/libelf_ar_util.c > @@ -0,0 +1,360 @@ > +/*- > + * Copyright (c) 2006,2009,2010 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 <stdlib.h> > +#include <string.h> > + > +#include "_libelf.h" > +#include "_libelf_ar.h" > + > +ELFTC_VCSID("$Id: libelf_ar_util.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +/* > + * Convert a string bounded by `start' and `start+sz' (exclusive) to a > + * number in the specified base. > + */ > +int > +_libelf_ar_get_number(const char *src, size_t sz, unsigned int base, > + size_t *ret) > +{ > + size_t r; > + unsigned int c, v; > + const unsigned char *e, *s; > + > + assert(base <= 10); > + > + s = (const unsigned char *) src; > + 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); > +} > + > +/* > + * Return the translated name for an archive member. > + */ > +char * > +_libelf_ar_get_translated_name(const struct ar_hdr *arh, Elf *ar) > +{ > + char *s; > + unsigned char c; > + size_t len, offset; > + const unsigned char *buf, *p, *q, *r; > + const size_t bufsize = sizeof(arh->ar_name); > + > + assert(arh != NULL); > + assert(ar->e_kind == ELF_K_AR); > + assert((const unsigned char *) arh >= ar->e_rawfile && > + (const unsigned char *) arh < ar->e_rawfile + ar->e_rawsize); > + > + buf = (const unsigned char *) arh->ar_name; > + > + /* > + * Check for extended naming. > + * > + * If the name matches the pattern "^/[0-9]+", it is an > + * SVR4-style extended name. If the name matches the pattern > + * "#1/[0-9]+", the entry uses BSD style extended naming. > + */ > + 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((const char *) (buf + 1), > + bufsize - 1, 10, &offset) == 0) { > + LIBELF_SET_ERROR(ARCHIVE, 0); > + return (NULL); > + } > + > + if (offset > ar->e_u.e_ar.e_rawstrtabsz) { > + LIBELF_SET_ERROR(ARCHIVE, 0); > + return (NULL); > + } > + > + p = q = ar->e_u.e_ar.e_rawstrtab + offset; > + r = ar->e_u.e_ar.e_rawstrtab + ar->e_u.e_ar.e_rawstrtabsz; > + > + for (; p < r && *p != '/'; p++) > + ; > + len = (size_t) (p - q + 1); /* space for the trailing NUL */ > + > + if ((s = malloc(len)) == NULL) { > + LIBELF_SET_ERROR(RESOURCE, 0); > + return (NULL); > + } > + > + (void) strncpy(s, (const char *) q, len - 1); > + s[len - 1] = '\0'; > + > + return (s); > + } else if (IS_EXTENDED_BSD_NAME(buf)) { > + r = buf + LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE; > + > + if (_libelf_ar_get_number((const char *) r, bufsize - > + LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE, 10, > + &len) == 0) { > + LIBELF_SET_ERROR(ARCHIVE, 0); > + return (NULL); > + } > + > + /* > + * Allocate space for the file name plus a > + * trailing NUL. > + */ > + if ((s = malloc(len + 1)) == NULL) { > + LIBELF_SET_ERROR(RESOURCE, 0); > + return (NULL); > + } > + > + /* > + * The file name follows the archive header. > + */ > + q = (const unsigned char *) (arh + 1); > + > + (void) strncpy(s, (const char *) q, len); > + s[len] = '\0'; > + > + return (s); > + } > + > + /* > + * A 'normal' name. > + * > + * Skip back over trailing blanks from the end of the field. > + * In the SVR4 format, a '/' is used as a terminator for > + * non-special names. > + */ > + for (q = buf + bufsize - 1; q >= buf && *q == ' '; --q) > + ; > + > + if (q >= buf) { > + if (*q == '/') { > + /* > + * SVR4 style names: ignore the trailing > + * character '/', but only if the name is not > + * one of the special names "/" and "//". > + */ > + if (q > buf + 1 || > + (q == (buf + 1) && *buf != '/')) > + q--; > + } > + > + len = (size_t) (q - buf + 2); /* Space for a trailing NUL. */ > + } else { > + /* The buffer only had blanks. */ > + buf = (const unsigned char *) ""; > + len = 1; > + } > + > + if ((s = malloc(len)) == NULL) { > + LIBELF_SET_ERROR(RESOURCE, 0); > + return (NULL); > + } > + > + (void) strncpy(s, (const char *) buf, len - 1); > + s[len - 1] = '\0'; > + > + return (s); > +} > + > +/* > + * Return the raw name for an archive member, inclusive of any > + * formatting characters. > + */ > +char * > +_libelf_ar_get_raw_name(const struct ar_hdr *arh) > +{ > + char *rawname; > + const size_t namesz = sizeof(arh->ar_name); > + > + if ((rawname = malloc(namesz + 1)) == NULL) { > + LIBELF_SET_ERROR(RESOURCE, 0); > + return (NULL); > + } > + > + (void) strncpy(rawname, arh->ar_name, namesz); > + rawname[namesz] = '\0'; > + return (rawname); > +} > + > +/* > + * Open an 'ar' archive. > + */ > +Elf * > +_libelf_ar_open(Elf *e, int reporterror) > +{ > + size_t sz; > + int scanahead; > + struct ar_hdr arh; > + unsigned char *s, *end; > + > + _libelf_init_elf(e, 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); > + > + /* > + * We use heuristics to determine the flavor of the archive we > + * are examining. > + * > + * SVR4 flavor archives use the name "/ " and "// " for > + * special members. > + * > + * In BSD flavor archives the symbol table, if present, is the > + * first archive with name "__.SYMDEF". > + */ > + > +#define READ_AR_HEADER(S, ARH, SZ, END) > \ > + do { \ > + if ((S) + sizeof((ARH)) > (END)) \ > + goto error; \ > + (void) memcpy(&(ARH), (S), sizeof((ARH))); \ > + if ((ARH).ar_fmag[0] != '`' || (ARH).ar_fmag[1] != '\n') \ > + goto error; \ > + if (_libelf_ar_get_number((char *) (ARH).ar_size, \ > + sizeof((ARH).ar_size), 10, &(SZ)) == 0) \ > + goto error; \ > + } while (0) > + > + READ_AR_HEADER(s, arh, sz, end); > + > + /* > + * Handle special archive members for the SVR4 format. > + */ > + if (arh.ar_name[0] == '/') { > + if (sz == 0) > + goto error; > + > + e->e_flags |= LIBELF_F_AR_VARIANT_SVR4; > + > + scanahead = 0; > + > + /* > + * The symbol table (file name "/ ") always comes before the > + * string table (file name "// "). > + */ > + if (arh.ar_name[1] == ' ') { > + /* "/ " => symbol table. */ > + scanahead = 1; /* The string table to follow. */ > + > + s += sizeof(arh); > + e->e_u.e_ar.e_rawsymtab = s; > + e->e_u.e_ar.e_rawsymtabsz = sz; > + > + sz = LIBELF_ADJUST_AR_SIZE(sz); > + s += sz; > + > + } else if (arh.ar_name[1] == '/' && arh.ar_name[2] == ' ') { > + /* "// " => string table for long file names. */ > + s += sizeof(arh); > + e->e_u.e_ar.e_rawstrtab = s; > + e->e_u.e_ar.e_rawstrtabsz = sz; > + > + sz = LIBELF_ADJUST_AR_SIZE(sz); > + s += sz; > + } > + > + /* > + * If the string table hasn't been seen yet, look for > + * it in the next member. > + */ > + if (scanahead) { > + READ_AR_HEADER(s, arh, sz, end); > + > + /* "// " => string table for long file names. */ > + if (arh.ar_name[0] == '/' && arh.ar_name[1] == '/' && > + arh.ar_name[2] == ' ') { > + > + s += sizeof(arh); > + > + e->e_u.e_ar.e_rawstrtab = s; > + e->e_u.e_ar.e_rawstrtabsz = sz; > + > + sz = LIBELF_ADJUST_AR_SIZE(sz); > + s += sz; > + } > + } > + } else if (strncmp(arh.ar_name, LIBELF_AR_BSD_SYMTAB_NAME, > + sizeof(LIBELF_AR_BSD_SYMTAB_NAME) - 1) == 0) { > + /* > + * BSD style archive symbol table. > + */ > + s += sizeof(arh); > + e->e_u.e_ar.e_rawsymtab = s; > + e->e_u.e_ar.e_rawsymtabsz = sz; > + > + sz = LIBELF_ADJUST_AR_SIZE(sz); > + s += sz; > + } > + > + /* > + * Update the 'next' offset, so that a subsequent elf_begin() > + * works as expected. > + */ > + e->e_u.e_ar.e_next = (off_t) (s - e->e_rawfile); > + > + return (e); > + > +error: > + if (!reporterror) { > + e->e_kind = ELF_K_NONE; > + return (e); > + } > + > + LIBELF_SET_ERROR(ARCHIVE, 0); > + return (NULL); > +} > diff --git a/libelf_checksum.c b/libelf_checksum.c > new file mode 100644 > index 0000000..ef86877 > --- /dev/null > +++ b/libelf_checksum.c > @@ -0,0 +1,98 @@ > +/*- > + * Copyright (c) 2006,2008 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" > + > +ELFTC_VCSID("$Id: libelf_checksum.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +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); > +} > + > +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, (size_t) d->d_size); > + } > + > + /* > + * Return a 16-bit checksum compatible with Solaris. > + */ > + return (long) (((checksum >> 16) & 0xFFFFUL) + (checksum & 0xFFFFUL)); > +} > diff --git a/libelf_convert.m4 b/libelf_convert.m4 > new file mode 100644 > index 0000000..9f99f1e > --- /dev/null > +++ b/libelf_convert.m4 > @@ -0,0 +1,1087 @@ > +/*- > + * Copyright (c) 2006-2011 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 <string.h> > + > +#include "_libelf.h" > + > +ELFTC_VCSID("$Id: libelf_convert.m4 3174 2015-03-27 17:13:41Z emaste $"); > + > +/* WARNING: GENERATED FROM __file__. */ > + > +divert(-1) > + > +# Generate conversion routines for converting between in-memory and > +# file representations of Elf data structures. > +# > +# These conversions use the type information defined in `elf_types.m4'. > + > +include(SRCDIR`/elf_types.m4') > + > +# For the purposes of generating conversion code, ELF types may be > +# classified according to the following characteristics: > +# > +# 1. Whether the ELF type can be directly mapped to an integral C > +# language type. For example, the ELF_T_WORD type maps directly to > +# a 'uint32_t', but ELF_T_GNUHASH lacks a matching C type. > +# > +# 2. Whether the type has word size dependent variants. For example, > +# ELT_T_EHDR is represented using C types Elf32_Ehdr and El64_Ehdr, > +# and the ELF_T_ADDR and ELF_T_OFF types have integral C types that > +# can be 32- or 64- bit wide. > +# > +# 3. Whether the ELF types has a fixed representation or not. For > +# example, the ELF_T_SYM type has a fixed size file representation, > +# some types like ELF_T_NOTE and ELF_T_GNUHASH use a variable size > +# representation. > +# > +# We use m4 macros to generate conversion code for ELF types that have > +# a fixed size representation. Conversion functions for the remaining > +# types are coded by hand. > +# > +#* Handling File and Memory Representations > +# > +# `In-memory' representations of an Elf data structure use natural > +# alignments and native byte ordering. This allows pointer arithmetic > +# and casting to work as expected. On the other hand, the `file' > +# representation of an ELF data structure could possibly be packed > +# tighter than its `in-memory' representation, and could be of a > +# differing byte order. Reading ELF objects that are members of `ar' > +# archives present an additional complication: `ar' pads file data to > +# even addresses, so file data structures in an archive member > +# residing inside an `ar' archive could be at misaligned memory > +# addresses when brought into memory. > +# > +# In summary, 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. > + > +# NOCVT(TYPE) -- Do not generate the cvt[] structure entry for TYPE > +define(`NOCVT',`define(`NOCVT_'$1,1)') > + > +# NOFUNC(TYPE) -- Do not generate a conversion function for TYPE > +define(`NOFUNC',`define(`NOFUNC_'$1,1)') > + > +# IGNORE(TYPE) -- Completely ignore the type. > +define(`IGNORE',`NOCVT($1)NOFUNC($1)') > + > +# Mark ELF types that should not be processed by the M4 macros below. > + > +# Types for which we use functions with non-standard names. > +IGNORE(`BYTE') # Uses a wrapper around memcpy(). > +IGNORE(`NOTE') # Not a fixed size type. > + > +# Types for which we supply hand-coded functions. > +NOFUNC(`GNUHASH') # A type with complex internal structure. > +NOFUNC(`VDEF') # See MAKE_VERSION_CONVERTERS below. > +NOFUNC(`VNEED') # .. > + > +# Unimplemented types. > +IGNORE(`MOVEP') > + > +# ELF types that don't exist in a 32-bit world. > +NOFUNC(`XWORD32') > +NOFUNC(`SXWORD32') > + > +# `Primitive' ELF types are those that are an alias for an integral > +# type. As they have no internal structure, they can be copied using > +# a `memcpy()', and byteswapped in straightforward way. > +# > +# Mark all ELF types that directly map to integral C types. > +define(`PRIM_ADDR', 1) > +define(`PRIM_BYTE', 1) > +define(`PRIM_HALF', 1) > +define(`PRIM_LWORD', 1) > +define(`PRIM_OFF', 1) > +define(`PRIM_SWORD', 1) > +define(`PRIM_SXWORD', 1) > +define(`PRIM_WORD', 1) > +define(`PRIM_XWORD', 1) > + > +# Note the primitive types that are size-dependent. > +define(`SIZEDEP_ADDR', 1) > +define(`SIZEDEP_OFF', 1) > + > +# Generate conversion functions for primitive types. > +# > +# Macro use: MAKEPRIMFUNCS(ELFTYPE,CTYPE,TYPESIZE,SYMSIZE) > +# `$1': Name of the ELF type. > +# `$2': C structure name suffix. > +# `$3': ELF class specifier for types, one of [`32', `64']. > +# `$4': Additional ELF class specifier, one of [`', `32', `64']. > +# > +# Generates a pair of conversion functions. > +define(`MAKEPRIMFUNCS',` > +static int > +_libelf_cvt_$1$4_tof(unsigned char *dst, size_t dsz, unsigned char *src, > + size_t count, int byteswap) > +{ > + Elf$3_$2 t, *s = (Elf$3_$2 *) (uintptr_t) src; > + size_t c; > + > + (void) dsz; > + > + if (!byteswap) { > + (void) memcpy(dst, src, count * sizeof(*s)); > + return (1); > + } > + > + for (c = 0; c < count; c++) { > + t = *s++; > + SWAP_$1$4(t); > + WRITE_$1$4(dst,t); > + } > + > + return (1); > +} > + > +static int > +_libelf_cvt_$1$4_tom(unsigned char *dst, size_t dsz, unsigned char *src, > + size_t count, int byteswap) > +{ > + Elf$3_$2 t, *d = (Elf$3_$2 *) (uintptr_t) dst; > + size_t c; > + > + if (dsz < count * sizeof(Elf$3_$2)) > + return (0); > + > + if (!byteswap) { > + (void) memcpy(dst, src, count * sizeof(*d)); > + return (1); > + } > + > + for (c = 0; c < count; c++) { > + READ_$1$4(src,t); > + SWAP_$1$4(t); > + *d++ = t; > + } > + > + return (1); > +} > +') > + > +# > +# Handling composite ELF types > +# > + > +# SWAP_FIELD(FIELDNAME,ELFTYPE) -- Generate code to swap one field. > +define(`SWAP_FIELD', > + `ifdef(`SIZEDEP_'$2, > + `SWAP_$2'SZ()`(t.$1); > + ', > + `SWAP_$2(t.$1); > + ')') > + > +# SWAP_MEMBERS(STRUCT) -- Iterate over a structure definition. > +define(`SWAP_MEMBERS', > + `ifelse($#,1,`/**/', > + `SWAP_FIELD($1)SWAP_MEMBERS(shift($@))')') > + > +# SWAP_STRUCT(CTYPE,SIZE) -- Generate code to swap an ELF structure. > +define(`SWAP_STRUCT', > + `pushdef(`SZ',$2)/* Swap an Elf$2_$1 */ > + SWAP_MEMBERS(Elf$2_$1_DEF)popdef(`SZ')') > + > +# WRITE_FIELD(ELFTYPE,FIELDNAME) -- Generate code to write one field. > +define(`WRITE_FIELD', > + `ifdef(`SIZEDEP_'$2, > + `WRITE_$2'SZ()`(dst,t.$1); > + ', > + `WRITE_$2(dst,t.$1); > + ')') > + > +# WRITE_MEMBERS(ELFTYPELIST) -- Iterate over a structure definition. > +define(`WRITE_MEMBERS', > + `ifelse($#,1,`/**/', > + `WRITE_FIELD($1)WRITE_MEMBERS(shift($@))')') > + > +# WRITE_STRUCT(CTYPE,SIZE) -- Generate code to write out an ELF structure. > +define(`WRITE_STRUCT', > + `pushdef(`SZ',$2)/* Write an Elf$2_$1 */ > + WRITE_MEMBERS(Elf$2_$1_DEF)popdef(`SZ')') > + > +# READ_FIELD(ELFTYPE,CTYPE) -- Generate code to read one field. > +define(`READ_FIELD', > + `ifdef(`SIZEDEP_'$2, > + `READ_$2'SZ()`(s,t.$1); > + ', > + `READ_$2(s,t.$1); > + ')') > + > +# READ_MEMBERS(ELFTYPELIST) -- Iterate over a structure definition. > +define(`READ_MEMBERS', > + `ifelse($#,1,`/**/', > + `READ_FIELD($1)READ_MEMBERS(shift($@))')') > + > +# READ_STRUCT(CTYPE,SIZE) -- Generate code to read an ELF structure. > +define(`READ_STRUCT', > + `pushdef(`SZ',$2)/* Read an Elf$2_$1 */ > + READ_MEMBERS(Elf$2_$1_DEF)popdef(`SZ')') > + > + > +# MAKECOMPFUNCS -- Generate converters for composite ELF 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(`MAKECOMPFUNCS', `ifdef(`NOFUNC_'$1$3,`',` > +static int > +_libelf_cvt_$1$3_tof(unsigned char *dst, size_t dsz, unsigned char *src, > + size_t count, int byteswap) > +{ > + Elf$3_$2 t, *s; > + size_t c; > + > + (void) dsz; > + > + 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) > + } > + > + return (1); > +} > + > +static int > +_libelf_cvt_$1$3_tom(unsigned char *dst, size_t dsz, unsigned 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 = src + (count - 1) * fsz; > + > + if (dsz < count * sizeof(Elf$3_$2)) > + return (0); > + > + while (count--) { > + s = s0; > + READ_STRUCT($2,$3) > + if (byteswap) { > + SWAP_STRUCT($2,$3) > + } > + *d-- = t; s0 -= fsz; > + } > + > + return (1); > +} > +')') > + > +# MAKE_TYPE_CONVERTER(ELFTYPE,CTYPE) > +# > +# Make type convertor functions from the type definition > +# of the ELF type: > +# - Skip convertors marked as `NOFUNC'. > +# - Invoke `MAKEPRIMFUNCS' or `MAKECOMPFUNCS' as appropriate. > +define(`MAKE_TYPE_CONVERTER', > + `ifdef(`NOFUNC_'$1,`', > + `ifdef(`PRIM_'$1, > + `ifdef(`SIZEDEP_'$1, > + `MAKEPRIMFUNCS($1,$2,32,32)dnl > + MAKEPRIMFUNCS($1,$2,64,64)', > + `MAKEPRIMFUNCS($1,$2,64)')', > + `MAKECOMPFUNCS($1,$2,32)dnl > + MAKECOMPFUNCS($1,$2,64)')')') > + > +# MAKE_TYPE_CONVERTERS(ELFTYPELIST) -- Generate conversion functions. > +define(`MAKE_TYPE_CONVERTERS', > + `ifelse($#,1,`', > + `MAKE_TYPE_CONVERTER($1)MAKE_TYPE_CONVERTERS(shift($@))')') > + > + > +# > +# Macros to generate entries for the table of convertors. > +# > + > +# CONV(ELFTYPE,SIZE,DIRECTION) > +# > +# Generate the name of a convertor function. > +define(`CONV', > + `ifdef(`NOFUNC_'$1$2, > + `.$3$2 = NULL', > + `ifdef(`PRIM_'$1, > + `ifdef(`SIZEDEP_'$1, > + `.$3$2 = _libelf_cvt_$1$2_$3', > + `.$3$2 = _libelf_cvt_$1_$3')', > + `.$3$2 = _libelf_cvt_$1$2_$3')')') > + > +# CONVERTER_NAME(ELFTYPE) > +# > +# Generate the contents of one `struct cvt' instance. > +define(`CONVERTER_NAME', > + `ifdef(`NOCVT_'$1,`', > + ` [ELF_T_$1] = { > + CONV($1,32,tof), > + CONV($1,32,tom), > + CONV($1,64,tof), > + CONV($1,64,tom) > + }, > + > +')') > + > +# CONVERTER_NAMES(ELFTYPELIST) > +# > +# Generate the `struct cvt[]' array. > +define(`CONVERTER_NAMES', > + `ifelse($#,1,`', > + `CONVERTER_NAME($1)CONVERTER_NAMES(shift($@))')') > + > +# > +# Handling ELF version sections. > +# > + > +# _FSZ(FIELD,BASETYPE) - return the file size for a field. > +define(`_FSZ', > + `ifelse($2,`HALF',2, > + $2,`WORD',4)') > + > +# FSZ(STRUCT) - determine the file size of a structure. > +define(`FSZ', > + `ifelse($#,1,0, > + `eval(_FSZ($1) + FSZ(shift($@)))')') > + > +# MAKE_VERSION_CONVERTERS(TYPE,BASE,AUX,PFX) -- Generate conversion > +# functions for versioning structures. > +define(`MAKE_VERSION_CONVERTERS', > + `MAKE_VERSION_CONVERTER($1,$2,$3,$4,32) > + MAKE_VERSION_CONVERTER($1,$2,$3,$4,64)') > + > +# MAKE_VERSION_CONVERTOR(TYPE,CBASE,CAUX,PFX,SIZE) -- Generate a > +# conversion function. > +define(`MAKE_VERSION_CONVERTER',` > +static int > +_libelf_cvt_$1$5_tof(unsigned char *dst, size_t dsz, unsigned char *src, > + size_t count, int byteswap) > +{ > + Elf$5_$2 t; > + Elf$5_$3 a; > + const size_t verfsz = FSZ(Elf$5_$2_DEF); > + const size_t auxfsz = FSZ(Elf$5_$3_DEF); > + const size_t vermsz = sizeof(Elf$5_$2); > + const size_t auxmsz = sizeof(Elf$5_$3); > + unsigned char * const dstend = dst + dsz; > + unsigned char * const srcend = src + count; > + unsigned char *dtmp, *dstaux, *srcaux; > + Elf$5_Word aux, anext, cnt, vnext; > + > + for (dtmp = dst, vnext = ~0U; > + vnext != 0 && dtmp + verfsz <= dstend && src + vermsz <= srcend; > + dtmp += vnext, src += vnext) { > + > + /* Read in an Elf$5_$2 structure. */ > + t = *((Elf$5_$2 *) (uintptr_t) src); > + > + aux = t.$4_aux; > + cnt = t.$4_cnt; > + vnext = t.$4_next; > + > + if (byteswap) { > + SWAP_STRUCT($2, $5) > + } > + > + dst = dtmp; > + WRITE_STRUCT($2, $5) > + > + if (aux < verfsz) > + return (0); > + > + /* Process AUX entries. */ > + for (anext = ~0U, dstaux = dtmp + aux, srcaux = src + aux; > + cnt != 0 && anext != 0 && dstaux + auxfsz <= dstend && > + srcaux + auxmsz <= srcend; > + dstaux += anext, srcaux += anext, cnt--) { > + > + /* Read in an Elf$5_$3 structure. */ > + a = *((Elf$5_$3 *) (uintptr_t) srcaux); > + anext = a.$4a_next; > + > + if (byteswap) { > + pushdef(`t',`a')SWAP_STRUCT($3, $5)popdef(`t') > + } > + > + dst = dstaux; > + pushdef(`t',`a')WRITE_STRUCT($3, $5)popdef(`t') > + } > + > + if (anext || cnt) > + return (0); > + } > + > + if (vnext) > + return (0); > + > + return (1); > +} > + > +static int > +_libelf_cvt_$1$5_tom(unsigned char *dst, size_t dsz, unsigned char *src, > + size_t count, int byteswap) > +{ > + Elf$5_$2 t, *dp; > + Elf$5_$3 a, *ap; > + const size_t verfsz = FSZ(Elf$5_$2_DEF); > + const size_t auxfsz = FSZ(Elf$5_$3_DEF); > + const size_t vermsz = sizeof(Elf$5_$2); > + const size_t auxmsz = sizeof(Elf$5_$3); > + unsigned char * const dstend = dst + dsz; > + unsigned char * const srcend = src + count; > + unsigned char *dstaux, *s, *srcaux, *stmp; > + Elf$5_Word aux, anext, cnt, vnext; > + > + for (stmp = src, vnext = ~0U; > + vnext != 0 && stmp + verfsz <= srcend && dst + vermsz <= dstend; > + stmp += vnext, dst += vnext) { > + > + /* Read in a $1 structure. */ > + s = stmp; > + READ_STRUCT($2, $5) > + if (byteswap) { > + SWAP_STRUCT($2, $5) > + } > + > + dp = (Elf$5_$2 *) (uintptr_t) dst; > + *dp = t; > + > + aux = t.$4_aux; > + cnt = t.$4_cnt; > + vnext = t.$4_next; > + > + if (aux < vermsz) > + return (0); > + > + /* Process AUX entries. */ > + for (anext = ~0U, dstaux = dst + aux, srcaux = stmp + aux; > + cnt != 0 && anext != 0 && dstaux + auxmsz <= dstend && > + srcaux + auxfsz <= srcend; > + dstaux += anext, srcaux += anext, cnt--) { > + > + s = srcaux; > + pushdef(`t',`a')READ_STRUCT($3, $5)popdef(`t') > + > + if (byteswap) { > + pushdef(`t',`a')SWAP_STRUCT($3, $5)popdef(`t') > + } > + > + anext = a.$4a_next; > + > + ap = ((Elf$5_$3 *) (uintptr_t) dstaux); > + *ap = a; > + } > + > + if (anext || cnt) > + return (0); > + } > + > + if (vnext) > + return (0); > + > + return (1); > +}') > + > +divert(0) > + > +/* > + * C macros to byte swap integral quantities. > + */ > + > +#define SWAP_BYTE(X) do { (void) (X); } while (0) > +#define SWAP_IDENT(X) do { (void) (X); } while (0) > +#define SWAP_HALF(X) do { > \ > + uint16_t _x = (uint16_t) (X); \ > + uint32_t _t = _x & 0xFFU; \ > + _t <<= 8U; _x >>= 8U; _t |= _x & 0xFFU; \ > + (X) = (uint16_t) _t; \ > + } while (0) > +#define _SWAP_WORD(X, T) 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) _t; \ > + } while (0) > +#define SWAP_ADDR32(X) _SWAP_WORD(X, Elf32_Addr) > +#define SWAP_OFF32(X) _SWAP_WORD(X, Elf32_Off) > +#define SWAP_SWORD(X) _SWAP_WORD(X, Elf32_Sword) > +#define SWAP_WORD(X) _SWAP_WORD(X, Elf32_Word) > +#define _SWAP_WORD64(X, T) 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) _t; \ > + } while (0) > +#define SWAP_ADDR64(X) _SWAP_WORD64(X, Elf64_Addr) > +#define SWAP_LWORD(X) _SWAP_WORD64(X, Elf64_Lword) > +#define SWAP_OFF64(X) _SWAP_WORD64(X, Elf64_Off) > +#define SWAP_SXWORD(X) _SWAP_WORD64(X, Elf64_Sxword) > +#define SWAP_XWORD(X) _SWAP_WORD64(X, Elf64_Xword) > + > +/* > + * C macros to write out various integral values. > + * > + * Note: > + * - 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); \ > + const unsigned 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 = (uint32_t) (X); \ > + unsigned char *const _p = (unsigned char *) (P); \ > + const unsigned 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 = (uint64_t) (X); \ > + unsigned char *const _p = (unsigned char *) (P); \ > + const unsigned 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) > + > +/* > + * C macros to read in various integral values. > + * > + * Note: > + * - The source pointer could be unaligned. > + * - Values are read 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,T) 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) _t; \ > + } while (0) > +#define READ_ADDR32(P,X) _READ_WORD(P, X, Elf32_Addr) > +#define READ_OFF32(P,X) _READ_WORD(P, X, Elf32_Off) > +#define READ_SWORD(P,X) _READ_WORD(P, X, Elf32_Sword) > +#define READ_WORD(P,X) _READ_WORD(P, X, Elf32_Word) > +#define _READ_WORD64(P,X,T) 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) _t; \ > + } while (0) > +#define READ_ADDR64(P,X) _READ_WORD64(P, X, Elf64_Addr) > +#define READ_LWORD(P,X) _READ_WORD64(P, X, Elf64_Lword) > +#define READ_OFF64(P,X) _READ_WORD64(P, X, Elf64_Off) > +#define READ_SXWORD(P,X) _READ_WORD64(P, X, Elf64_Sxword) > +#define READ_XWORD(P,X) _READ_WORD64(P, X, Elf64_Xword) > +#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)) > + > +/*[*/ > +MAKE_TYPE_CONVERTERS(ELF_TYPE_LIST) > +MAKE_VERSION_CONVERTERS(VDEF,Verdef,Verdaux,vd) > +MAKE_VERSION_CONVERTERS(VNEED,Verneed,Vernaux,vn) > +/*]*/ > + > +/* > + * Sections of type ELF_T_BYTE are never byteswapped, consequently a > + * simple memcpy suffices for both directions of conversion. > + */ > + > +static int > +_libelf_cvt_BYTE_tox(unsigned char *dst, size_t dsz, unsigned char *src, > + size_t count, int byteswap) > +{ > + (void) byteswap; > + if (dsz < count) > + return (0); > + if (dst != src) > + (void) memcpy(dst, src, count); > + return (1); > +} > + > +/* > + * Sections of type ELF_T_GNUHASH start with a header containing 4 32-bit > + * words. Bloom filter data comes next, followed by hash buckets and the > + * hash chain. > + * > + * Bloom filter words are 64 bit wide on ELFCLASS64 objects and are 32 bit > + * wide on ELFCLASS32 objects. The other objects in this section are 32 > + * bits wide. > + * > + * Argument `srcsz' denotes the number of bytes to be converted. In the > + * 32-bit case we need to translate `srcsz' to a count of 32-bit words. > + */ > + > +static int > +_libelf_cvt_GNUHASH32_tom(unsigned char *dst, size_t dsz, unsigned char *src, > + size_t srcsz, int byteswap) > +{ > + return (_libelf_cvt_WORD_tom(dst, dsz, src, srcsz / sizeof(uint32_t), > + byteswap)); > +} > + > +static int > +_libelf_cvt_GNUHASH32_tof(unsigned char *dst, size_t dsz, unsigned char *src, > + size_t srcsz, int byteswap) > +{ > + return (_libelf_cvt_WORD_tof(dst, dsz, src, srcsz / sizeof(uint32_t), > + byteswap)); > +} > + > +static int > +_libelf_cvt_GNUHASH64_tom(unsigned char *dst, size_t dsz, unsigned char *src, > + size_t srcsz, int byteswap) > +{ > + size_t sz; > + uint64_t t64, *bloom64; > + Elf_GNU_Hash_Header *gh; > + uint32_t n, nbuckets, nchains, maskwords, shift2, symndx, t32; > + uint32_t *buckets, *chains; > + > + sz = 4 * sizeof(uint32_t); /* File header is 4 words long. */ > + if (dsz < sizeof(Elf_GNU_Hash_Header) || srcsz < sz) > + return (0); > + > + /* Read in the section header and byteswap if needed. */ > + READ_WORD(src, nbuckets); > + READ_WORD(src, symndx); > + READ_WORD(src, maskwords); > + READ_WORD(src, shift2); > + > + srcsz -= sz; > + > + if (byteswap) { > + SWAP_WORD(nbuckets); > + SWAP_WORD(symndx); > + SWAP_WORD(maskwords); > + SWAP_WORD(shift2); > + } > + > + /* Check source buffer and destination buffer sizes. */ > + sz = nbuckets * sizeof(uint32_t) + maskwords * sizeof(uint64_t); > + if (srcsz < sz || dsz < sz + sizeof(Elf_GNU_Hash_Header)) > + return (0); > + > + gh = (Elf_GNU_Hash_Header *) (uintptr_t) dst; > + gh->gh_nbuckets = nbuckets; > + gh->gh_symndx = symndx; > + gh->gh_maskwords = maskwords; > + gh->gh_shift2 = shift2; > + > + dsz -= sizeof(Elf_GNU_Hash_Header); > + dst += sizeof(Elf_GNU_Hash_Header); > + > + bloom64 = (uint64_t *) (uintptr_t) dst; > + > + /* Copy bloom filter data. */ > + for (n = 0; n < maskwords; n++) { > + READ_XWORD(src, t64); > + if (byteswap) > + SWAP_XWORD(t64); > + bloom64[n] = t64; > + } > + > + /* The hash buckets follows the bloom filter. */ > + dst += maskwords * sizeof(uint64_t); > + buckets = (uint32_t *) (uintptr_t) dst; > + > + for (n = 0; n < nbuckets; n++) { > + READ_WORD(src, t32); > + if (byteswap) > + SWAP_WORD(t32); > + buckets[n] = t32; > + } > + > + dst += nbuckets * sizeof(uint32_t); > + > + /* The hash chain follows the hash buckets. */ > + dsz -= sz; > + srcsz -= sz; > + > + if (dsz < srcsz) /* Destination lacks space. */ > + return (0); > + > + nchains = srcsz / sizeof(uint32_t); > + chains = (uint32_t *) (uintptr_t) dst; > + > + for (n = 0; n < nchains; n++) { > + READ_WORD(src, t32); > + if (byteswap) > + SWAP_WORD(t32); > + *chains++ = t32; > + } > + > + return (1); > +} > + > +static int > +_libelf_cvt_GNUHASH64_tof(unsigned char *dst, size_t dsz, unsigned char *src, > + size_t srcsz, int byteswap) > +{ > + uint32_t *s32; > + size_t sz, hdrsz; > + uint64_t *s64, t64; > + Elf_GNU_Hash_Header *gh; > + uint32_t maskwords, n, nbuckets, nchains, t0, t1, t2, t3, t32; > + > + hdrsz = 4 * sizeof(uint32_t); /* Header is 4x32 bits. */ > + if (dsz < hdrsz || srcsz < sizeof(Elf_GNU_Hash_Header)) > + return (0); > + > + gh = (Elf_GNU_Hash_Header *) (uintptr_t) src; > + > + t0 = nbuckets = gh->gh_nbuckets; > + t1 = gh->gh_symndx; > + t2 = maskwords = gh->gh_maskwords; > + t3 = gh->gh_shift2; > + > + src += sizeof(Elf_GNU_Hash_Header); > + srcsz -= sizeof(Elf_GNU_Hash_Header); > + dsz -= hdrsz; > + > + sz = gh->gh_nbuckets * sizeof(uint32_t) + gh->gh_maskwords * > + sizeof(uint64_t); > + > + if (srcsz < sz || dsz < sz) > + return (0); > + > + /* Write out the header. */ > + if (byteswap) { > + SWAP_WORD(t0); > + SWAP_WORD(t1); > + SWAP_WORD(t2); > + SWAP_WORD(t3); > + } > + > + WRITE_WORD(dst, t0); > + WRITE_WORD(dst, t1); > + WRITE_WORD(dst, t2); > + WRITE_WORD(dst, t3); > + > + /* Copy the bloom filter and the hash table. */ > + s64 = (uint64_t *) (uintptr_t) src; > + for (n = 0; n < maskwords; n++) { > + t64 = *s64++; > + if (byteswap) > + SWAP_XWORD(t64); > + WRITE_WORD64(dst, t64); > + } > + > + s32 = (uint32_t *) s64; > + for (n = 0; n < nbuckets; n++) { > + t32 = *s32++; > + if (byteswap) > + SWAP_WORD(t32); > + WRITE_WORD(dst, t32); > + } > + > + srcsz -= sz; > + dsz -= sz; > + > + /* Copy out the hash chains. */ > + if (dsz < srcsz) > + return (0); > + > + nchains = srcsz / sizeof(uint32_t); > + for (n = 0; n < nchains; n++) { > + t32 = *s32++; > + if (byteswap) > + SWAP_WORD(t32); > + WRITE_WORD(dst, t32); > + } > + > + return (1); > +} > + > +/* > + * 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. > + * The destination buffer needs to be at least `count' bytes in size. > + */ > +static int > +_libelf_cvt_NOTE_tom(unsigned char *dst, size_t dsz, unsigned char *src, > + size_t count, int byteswap) > +{ > + uint32_t namesz, descsz, type; > + Elf_Note *en; > + size_t sz, hdrsz; > + > + if (dsz < count) /* Destination buffer is too small. */ > + return (0); > + > + hdrsz = 3 * sizeof(uint32_t); > + if (count < hdrsz) /* Source too small. */ > + return (0); > + > + if (!byteswap) { > + (void) memcpy(dst, src, count); > + return (1); > + } > + > + /* Process all notes in the section. */ > + while (count > hdrsz) { > + /* Read the note header. */ > + READ_WORD(src, namesz); > + READ_WORD(src, descsz); > + READ_WORD(src, type); > + > + /* Translate. */ > + SWAP_WORD(namesz); > + SWAP_WORD(descsz); > + SWAP_WORD(type); > + > + /* Copy out the translated note header. */ > + en = (Elf_Note *) (uintptr_t) dst; > + en->n_namesz = namesz; > + en->n_descsz = descsz; > + en->n_type = type; > + > + dsz -= sizeof(Elf_Note); > + dst += sizeof(Elf_Note); > + count -= hdrsz; > + > + ROUNDUP2(namesz, 4U); > + ROUNDUP2(descsz, 4U); > + > + sz = namesz + descsz; > + > + if (count < sz || dsz < sz) /* Buffers are too small. */ > + return (0); > + > + (void) memcpy(dst, src, sz); > + > + src += sz; > + dst += sz; > + > + count -= sz; > + dsz -= sz; > + } > + > + return (1); > +} > + > +static int > +_libelf_cvt_NOTE_tof(unsigned char *dst, size_t dsz, unsigned char *src, > + size_t count, int byteswap) > +{ > + uint32_t namesz, descsz, type; > + Elf_Note *en; > + size_t sz; > + > + if (dsz < count) > + return (0); > + > + if (!byteswap) { > + (void) memcpy(dst, src, count); > + return (1); > + } > + > + while (count > sizeof(Elf_Note)) { > + > + en = (Elf_Note *) (uintptr_t) src; > + namesz = en->n_namesz; > + descsz = en->n_descsz; > + type = en->n_type; > + > + sz = namesz; > + ROUNDUP2(sz, 4U); > + sz += descsz; > + ROUNDUP2(sz, 4U); > + > + 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); > + > + if (count < sz) > + sz = count; > + > + (void) memcpy(dst, src, sz); > + > + src += sz; > + dst += sz; > + count -= sz; > + } > + > + return (1); > +} > + > +struct converters { > + int (*tof32)(unsigned char *dst, size_t dsz, unsigned char *src, > + size_t cnt, int byteswap); > + int (*tom32)(unsigned char *dst, size_t dsz, unsigned char *src, > + size_t cnt, int byteswap); > + int (*tof64)(unsigned char *dst, size_t dsz, unsigned char *src, > + size_t cnt, int byteswap); > + int (*tom64)(unsigned char *dst, size_t dsz, unsigned char *src, > + size_t cnt, int byteswap); > +}; > + > + > +static struct converters cvt[ELF_T_NUM] = { > + /*[*/ > +CONVERTER_NAMES(ELF_TYPE_LIST) > + /*]*/ > + > + /* > + * Types that need 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 > + } > +}; > + > +int (*_libelf_get_translator(Elf_Type t, int direction, int elfclass)) > + (unsigned char *_dst, size_t dsz, unsigned 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/libelf_data.c b/libelf_data.c > new file mode 100644 > index 0000000..fcffd8b > --- /dev/null > +++ b/libelf_data.c > @@ -0,0 +1,101 @@ > +/*- > + * Copyright (c) 2006,2008 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" > + > +ELFTC_VCSID("$Id: libelf_data.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +int > +_libelf_xlate_shtype(uint32_t sht) > +{ > + /* > + * Look for known section types. > + */ > + 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_GNU_HASH: > + return (ELF_T_GNUHASH); > + case SHT_GNU_LIBLIST: > + return (ELF_T_WORD); > + 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_SUNW_dof: > + return (ELF_T_BYTE); > + case SHT_SUNW_move: > + return (ELF_T_MOVE); > + case SHT_SUNW_syminfo: > + return (ELF_T_SYMINFO); > + case SHT_SUNW_verdef: /* == SHT_GNU_verdef */ > + return (ELF_T_VDEF); > + case SHT_SUNW_verneed: /* == SHT_GNU_verneed */ > + return (ELF_T_VNEED); > + case SHT_SUNW_versym: /* == SHT_GNU_versym */ > + return (ELF_T_HALF); > + default: > + /* > + * Values in the range [SHT_LOOS..SHT_HIUSER] (i.e., > + * OS, processor and user-defined section types) are > + * legal, but since we do not know anything more about > + * their semantics, we return a type of ELF_T_BYTE. > + */ > + if (sht >= SHT_LOOS && sht <= SHT_HIUSER) > + return (ELF_T_BYTE); > + > + /* > + * Other values are unsupported. > + */ > + return (-1); > + } > +} > diff --git a/libelf_ehdr.c b/libelf_ehdr.c > new file mode 100644 > index 0000000..d375fb3 > --- /dev/null > +++ b/libelf_ehdr.c > @@ -0,0 +1,204 @@ > +/*- > + * Copyright (c) 2006,2008 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 <gelf.h> > +#include <libelf.h> > +#include <stdlib.h> > + > +#include "_libelf.h" > + > +ELFTC_VCSID("$Id: libelf_ehdr.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +/* > + * 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; > + int (*xlator)(unsigned char *_d, size_t _dsz, unsigned 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)((unsigned char *) &scn->s_shdr, sizeof(scn->s_shdr), > + (unsigned char *) 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 = (size_t) 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) & 0xFFU; \ > + 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; > + int (*xlator)(unsigned char *_d, size_t _dsz, unsigned 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)((unsigned char*) ehdr, msz, 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/libelf_extended.c b/libelf_extended.c > new file mode 100644 > index 0000000..96765a8 > --- /dev/null > +++ b/libelf_extended.c > @@ -0,0 +1,134 @@ > +/*- > + * Copyright (c) 2006,2008 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" > + > +ELFTC_VCSID("$Id: libelf_extended.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +/* > + * 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 & 0xFFFFU; > + else > + ((Elf64_Ehdr *) eh)->e_shnum = shnum & 0xFFFFU; > + > + > + 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 & 0xFFFFU; > + else > + ((Elf64_Ehdr *) eh)->e_shstrndx = shstrndx & 0xFFFFU; > + > + 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 & 0xFFFFU; > + else > + ((Elf64_Ehdr *) eh)->e_phnum = phnum & 0xFFFFU; > + > + return (1); > +} > diff --git a/libelf_fsize.m4 b/libelf_fsize.m4 > new file mode 100644 > index 0000000..9942d27 > --- /dev/null > +++ b/libelf_fsize.m4 > @@ -0,0 +1,159 @@ > +/*- > + * Copyright (c) 2006,2008-2011 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" > + > +ELFTC_VCSID("$Id: libelf_fsize.m4 2225 2011-11-26 18:55:54Z jkoshy $"); > + > +/* WARNING: GENERATED FROM __file__. */ > + > +/* > + * 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') > + > +/* Types that have variable length. */ > +define(`GNUHASH_SIZE', 1) > +define(`NOTE_SIZE', 1) > +define(`VDEF_SIZE', 1) > +define(`VNEED_SIZE', 1) > + > +/* 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/libelf_memory.c b/libelf_memory.c > new file mode 100644 > index 0000000..cb8e8f2 > --- /dev/null > +++ b/libelf_memory.c > @@ -0,0 +1,96 @@ > +/*- > + * Copyright (c) 2011 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 <string.h> > +#include <libelf.h> > + > +#include "_libelf.h" > + > +ELFTC_VCSID("$Id: libelf_memory.c 3013 2014-03-23 06:16:59Z jkoshy $"); > + > +/* > + * Create an ELF descriptor for a memory image, optionally reporting > + * parse errors. > + */ > + > +Elf * > +_libelf_memory(unsigned char *image, size_t sz, int reporterror) > +{ > + Elf *e; > + int e_class; > + enum Elf_Error error; > + unsigned int e_byteorder, e_version; > + > + assert(image != NULL); > + assert(sz > 0); > + > + 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)) { > + e_byteorder = image[EI_DATA]; > + e_class = image[EI_CLASS]; > + e_version = image[EI_VERSION]; > + > + error = ELF_E_NONE; > + > + if (e_version > EV_CURRENT) > + error = ELF_E_VERSION; > + else if ((e_byteorder != ELFDATA2LSB && e_byteorder != > + ELFDATA2MSB) || (e_class != ELFCLASS32 && e_class != > + ELFCLASS64)) > + error = ELF_E_HEADER; > + > + if (error != ELF_E_NONE) { > + if (reporterror) { > + LIBELF_PRIVATE(error) = LIBELF_ERROR(error, > 0); > + (void) _libelf_release_elf(e); > + return (NULL); > + } > + } else { > + _libelf_init_elf(e, ELF_K_ELF); > + > + e->e_byteorder = e_byteorder; > + e->e_class = e_class; > + e->e_version = e_version; > + } > + } else if (sz >= SARMAG && > + strncmp((const char *) image, ARMAG, (size_t) SARMAG) == 0) > + return (_libelf_ar_open(e, reporterror)); > + > + return (e); > +} > diff --git a/libelf_msize.m4 b/libelf_msize.m4 > new file mode 100644 > index 0000000..179880c > --- /dev/null > +++ b/libelf_msize.m4 > @@ -0,0 +1,106 @@ > +/*- > + * Copyright (c) 2006,2008-2011 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 <string.h> > + > +#include "_libelf.h" > + > +ELFTC_VCSID("$Id: libelf_msize.m4 3174 2015-03-27 17:13:41Z emaste $"); > + > +/* WARNING: GENERATED FROM __file__. */ > + > +struct msize { > + size_t msz32; > + size_t msz64; > +}; > + > +divert(-1) > +include(SRCDIR`/elf_types.m4') > + > +/* > + * ELF types whose memory representations have a variable size. > + */ > +define(BYTE_SIZE, 1) > +define(GNUHASH_SIZE, 1) > +define(NOTE_SIZE, 1) > +define(VDEF_SIZE, 1) > +define(VNEED_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/libelf_open.c b/libelf_open.c > new file mode 100644 > index 0000000..7ec3395 > --- /dev/null > +++ b/libelf_open.c > @@ -0,0 +1,249 @@ > +/*- > + * Copyright (c) 2006,2008-2011 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 <sys/stat.h> > + > +#include <assert.h> > +#include <errno.h> > +#include <libelf.h> > +#include <stdlib.h> > +#include <unistd.h> > + > +#include "_libelf.h" > + > +#if ELFTC_HAVE_MMAP > +#include <sys/mman.h> > +#endif > + > +ELFTC_VCSID("$Id: libelf_open.c 3007 2014-03-22 08:10:14Z jkoshy $"); > + > +#define _LIBELF_INITSIZE (64*1024) > + > +/* > + * Read from a device file, pipe or socket. > + */ > +static void * > +_libelf_read_special_file(int fd, size_t *fsz) > +{ > + ssize_t readsz; > + size_t bufsz, datasz; > + unsigned char *buf, *t; > + > + datasz = 0; > + readsz = 0; > + bufsz = _LIBELF_INITSIZE; > + if ((buf = malloc(bufsz)) == NULL) > + goto resourceerror; > + > + /* > + * Read data from the file descriptor till we reach EOF, or > + * till an error is encountered. > + */ > + do { > + /* Check if we need to expand the data buffer. */ > + if (datasz == bufsz) { > + bufsz *= 2; > + if ((t = realloc(buf, bufsz)) == NULL) > + goto resourceerror; > + buf = t; > + } > + > + do { > + assert(bufsz - datasz > 0); > + t = buf + datasz; > + if ((readsz = read(fd, t, bufsz - datasz)) <= 0) > + break; > + datasz += (size_t) readsz; > + } while (datasz < bufsz); > + > + } while (readsz > 0); > + > + if (readsz < 0) { > + LIBELF_SET_ERROR(IO, errno); > + goto error; > + } > + > + assert(readsz == 0); > + > + /* > + * Free up extra buffer space. > + */ > + if (bufsz > datasz) { > + if (datasz > 0) { > + if ((t = realloc(buf, datasz)) == NULL) > + goto resourceerror; > + buf = t; > + } else { /* Zero bytes read. */ > + LIBELF_SET_ERROR(ARGUMENT, 0); > + free(buf); > + buf = NULL; > + } > + } > + > + *fsz = datasz; > + return (buf); > + > +resourceerror: > + LIBELF_SET_ERROR(RESOURCE, 0); > +error: > + if (buf != NULL) > + free(buf); > + return (NULL); > +} > + > +/* > + * Read the contents of the file referenced by the file descriptor > + * 'fd'. > + */ > + > +Elf * > +_libelf_open_object(int fd, Elf_Cmd c, int reporterror) > +{ > + Elf *e; > + void *m; > + mode_t mode; > + size_t fsize; > + struct stat sb; > + unsigned int flags; > + > + assert(c == ELF_C_READ || c == ELF_C_RDWR || c == ELF_C_WRITE); > + > + if (fstat(fd, &sb) < 0) { > + LIBELF_SET_ERROR(IO, errno); > + return (NULL); > + } > + > + mode = sb.st_mode; > + fsize = (size_t) sb.st_size; > + > + /* > + * Reject unsupported file types. > + */ > + if (!S_ISREG(mode) && !S_ISCHR(mode) && !S_ISFIFO(mode) && > + !S_ISSOCK(mode)) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (NULL); > + } > + > + /* > + * For ELF_C_WRITE mode, allocate and return a descriptor. > + */ > + if (c == ELF_C_WRITE) { > + 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; > + if (!S_ISREG(mode)) > + e->e_flags |= LIBELF_F_SPECIAL_FILE; > + } > + > + return (e); > + } > + > + > + /* > + * ELF_C_READ and ELF_C_RDWR mode. > + */ > + m = NULL; > + flags = 0; > + if (S_ISREG(mode)) { > + > + /* > + * Reject zero length files. > + */ > + if (fsize == 0) { > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (NULL); > + } > + > +#if ELFTC_HAVE_MMAP > + /* > + * Always map regular files in with 'PROT_READ' > + * permissions. > + * > + * For objects opened in ELF_C_RDWR mode, when > + * elf_update(3) is called, we remove this mapping, > + * write file data out using write(2), and map the new > + * contents back. > + */ > + m = mmap(NULL, fsize, PROT_READ, MAP_PRIVATE, fd, (off_t) 0); > + > + if (m == MAP_FAILED) > + m = NULL; > + else > + flags = LIBELF_F_RAWFILE_MMAP; > +#endif > + > + /* > + * Fallback to a read() if the call to mmap() failed, > + * or if mmap() is not available. > + */ > + if (m == NULL) { > + if ((m = malloc(fsize)) == NULL) { > + LIBELF_SET_ERROR(RESOURCE, 0); > + return (NULL); > + } > + > + if (read(fd, m, fsize) != (ssize_t) fsize) { > + LIBELF_SET_ERROR(IO, errno); > + free(m); > + return (NULL); > + } > + > + flags = LIBELF_F_RAWFILE_MALLOC; > + } > + } else if ((m = _libelf_read_special_file(fd, &fsize)) != NULL) > + flags = LIBELF_F_RAWFILE_MALLOC | LIBELF_F_SPECIAL_FILE; > + else > + return (NULL); > + > + if ((e = _libelf_memory(m, fsize, reporterror)) == NULL) { > + assert((flags & LIBELF_F_RAWFILE_MALLOC) || > + (flags & LIBELF_F_RAWFILE_MMAP)); > + if (flags & LIBELF_F_RAWFILE_MALLOC) > + free(m); > +#if ELFTC_HAVE_MMAP > + else > + (void) munmap(m, fsize); > +#endif > + return (NULL); > + } > + > + /* ar(1) archives aren't supported in RDWR mode. */ > + if (c == ELF_C_RDWR && e->e_kind == ELF_K_AR) { > + (void) elf_end(e); > + LIBELF_SET_ERROR(ARGUMENT, 0); > + return (NULL); > + } > + > + e->e_flags |= flags; > + e->e_fd = fd; > + e->e_cmd = c; > + > + return (e); > +} > diff --git a/libelf_phdr.c b/libelf_phdr.c > new file mode 100644 > index 0000000..ba872bb > --- /dev/null > +++ b/libelf_phdr.c > @@ -0,0 +1,153 @@ > +/*- > + * Copyright (c) 2006,2008 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 <gelf.h> > +#include <libelf.h> > +#include <stdlib.h> > + > +#include "_libelf.h" > + > +ELFTC_VCSID("$Id: libelf_phdr.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +void * > +_libelf_getphdr(Elf *e, int ec) > +{ > + size_t phnum; > + size_t fsz, msz; > + uint64_t phoff; > + Elf32_Ehdr *eh32; > + Elf64_Ehdr *eh64; > + void *ehdr, *phdr; > + int (*xlator)(unsigned char *_d, size_t _dsz, unsigned 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; > + phoff = (uint64_t) eh32->e_phoff; > + } else { > + eh64 = (Elf64_Ehdr *) ehdr; > + 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, phnum * msz, 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/libelf_shdr.c b/libelf_shdr.c > new file mode 100644 > index 0000000..862264b > --- /dev/null > +++ b/libelf_shdr.c > @@ -0,0 +1,54 @@ > +/*- > + * Copyright (c) 2006,2008 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" > + > +ELFTC_VCSID("$Id: libelf_shdr.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +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/libelf_xlate.c b/libelf_xlate.c > new file mode 100644 > index 0000000..6ee7624 > --- /dev/null > +++ b/libelf_xlate.c > @@ -0,0 +1,148 @@ > +/*- > + * Copyright (c) 2006,2008 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" > + > +ELFTC_VCSID("$Id: libelf_xlate.c 3174 2015-03-27 17:13:41Z emaste $"); > + > +/* > + * 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) > +{ > + int byteswap; > + 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) { > + 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 = (size_t) src->d_size / fsz; > + dsz = cnt * msz; > + } else { > + cnt = (size_t) 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 + (size_t) src->d_size; > + db = (uintptr_t) dst->d_buf; > + de = db + (size_t) 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; > + > + byteswap = encoding != LIBELF_PRIVATE(byteorder); > + > + if (src->d_size == 0 || > + (db == sb && !byteswap && fsz == msz)) > + return (dst); /* nothing more to do */ > + > + if (!(_libelf_get_translator(src->d_type, direction, elfclass)) > + (dst->d_buf, dsz, src->d_buf, cnt, byteswap)) { > + LIBELF_SET_ERROR(DATA, 0); > + return (NULL); > + } > + > + return (dst); > +} > -- > 2.20.1 > > > > _______________________________________________ > Minios-devel mailing list > Minios-devel@xxxxxxxxxxxxxxxxxxxx > https://lists.xenproject.org/mailman/listinfo/minios-devel _______________________________________________ Minios-devel mailing list Minios-devel@xxxxxxxxxxxxxxxxxxxx https://lists.xenproject.org/mailman/listinfo/minios-devel
|
 |
Lists.xenproject.org is hosted with RackSpace, monitoring our |