Changeset 771e7f1 in rtems-tools


Ignore:
Timestamp:
Apr 30, 2018, 4:20:32 AM (13 months ago)
Author:
Chris Johns <chrisj@…>
Branches:
master
Children:
4bb3996
Parents:
6f48c91
git-author:
Chris Johns <chrisj@…> (04/30/18 04:20:32)
git-committer:
Chris Johns <chrisj@…> (04/30/18 05:18:34)
Message:

rtemstoolkit: Update elftoolchain to the latest code.

The update is taken from:

https://svn.code.sf.net/p/elftoolchain/code/trunk

Update #3417

Location:
rtemstoolkit
Files:
5 added
79 edited

Legend:

Unmodified
Added
Removed
  • rtemstoolkit/elftoolchain/common/Makefile

    r6f48c91 r771e7f1  
    1 # $Id: Makefile 2140 2011-11-10 14:27:03Z jkoshy $
     1# $Id: Makefile 3594 2018-04-11 18:26:50Z jkoshy $
    22
    33TOP=    ..
    44
    5 INCS=   elfdefinitions.h
    6 INCSDIR?=       /usr/include
     5INCS=           elfdefinitions.h
     6INCSDIR=        /usr/include
    77
    88.PHONY: all clean clobber depend obj
    99
    10 all depend obj:
     10all depend:
    1111
    1212clean clobber:
    1313        rm -f ${CLEANFILES}
    1414
     15cleandepend:
     16        rm -f ${.OBJDIR}/.depend
     17
    1518.include "${TOP}/mk/elftoolchain.inc.mk"
  • rtemstoolkit/elftoolchain/common/_elftc.h

    r6f48c91 r771e7f1  
    2424 * SUCH DAMAGE.
    2525 *
    26  * $Id: _elftc.h 2064 2011-10-26 15:12:32Z jkoshy $
     26 * $Id: _elftc.h 3446 2016-05-03 01:31:17Z emaste $
    2727 */
    2828
    2929/**
    30  ** Miscellanous definitions needed by multiple components.
     30 ** Miscellaneous definitions needed by multiple components.
    3131 **/
    3232
     
    4242#endif
    4343
     44/* --QUEUE-MACROS-- [[ */
     45
    4446/*
    4547 * Supply macros missing from <sys/queue.h>
    4648 */
    4749
     50/*
     51 * Copyright (c) 1991, 1993
     52 *      The Regents of the University of California.  All rights reserved.
     53 *
     54 * Redistribution and use in source and binary forms, with or without
     55 * modification, are permitted provided that the following conditions
     56 * are met:
     57 * 1. Redistributions of source code must retain the above copyright
     58 *    notice, this list of conditions and the following disclaimer.
     59 * 2. Redistributions in binary form must reproduce the above copyright
     60 *    notice, this list of conditions and the following disclaimer in the
     61 *    documentation and/or other materials provided with the distribution.
     62 * 3. Neither the name of the University nor the names of its contributors
     63 *    may be used to endorse or promote products derived from this software
     64 *    without specific prior written permission.
     65 *
     66 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     67 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     68 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     69 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     70 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     71 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     72 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     73 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     74 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     75 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     76 * SUCH DAMAGE.
     77 */
     78
     79#ifndef LIST_FOREACH_SAFE
     80#define LIST_FOREACH_SAFE(var, head, field, tvar)               \
     81        for ((var) = LIST_FIRST((head));                        \
     82            (var) && ((tvar) = LIST_NEXT((var), field), 1);     \
     83            (var) = (tvar))
     84#endif
     85
     86#ifndef SLIST_FOREACH_SAFE
     87#define SLIST_FOREACH_SAFE(var, head, field, tvar)              \
     88        for ((var) = SLIST_FIRST((head));                       \
     89            (var) && ((tvar) = SLIST_NEXT((var), field), 1);    \
     90            (var) = (tvar))
     91#endif
     92
     93#ifndef STAILQ_CONCAT
     94#define STAILQ_CONCAT(head1, head2) do {                        \
     95        if (!STAILQ_EMPTY((head2))) {                           \
     96                *(head1)->stqh_last = (head2)->stqh_first;      \
     97                (head1)->stqh_last = (head2)->stqh_last;        \
     98                STAILQ_INIT((head2));                           \
     99        }                                                       \
     100} while (/*CONSTCOND*/0)
     101#endif
     102
     103#ifndef STAILQ_EMPTY
     104#define STAILQ_EMPTY(head)      ((head)->stqh_first == NULL)
     105#endif
     106
     107#ifndef STAILQ_ENTRY
     108#define STAILQ_ENTRY(type)                                      \
     109struct {                                                        \
     110        struct type *stqe_next; /* next element */              \
     111}
     112#endif
     113
     114#ifndef STAILQ_FIRST
     115#define STAILQ_FIRST(head)      ((head)->stqh_first)
     116#endif
     117
     118#ifndef STAILQ_HEAD
     119#define STAILQ_HEAD(name, type)                                 \
     120struct name {                                                   \
     121        struct type *stqh_first; /* first element */            \
     122        struct type **stqh_last; /* addr of last next element */ \
     123}
     124#endif
     125
     126#ifndef STAILQ_HEAD_INITIALIZER
     127#define STAILQ_HEAD_INITIALIZER(head)                           \
     128        { NULL, &(head).stqh_first }
     129#endif
     130
     131#ifndef STAILQ_FOREACH
     132#define STAILQ_FOREACH(var, head, field)                        \
     133        for ((var) = ((head)->stqh_first);                      \
     134                (var);                                          \
     135                (var) = ((var)->field.stqe_next))
     136#endif
     137
    48138#ifndef STAILQ_FOREACH_SAFE
    49 #define STAILQ_FOREACH_SAFE(var, head, field, tvar)            \
    50        for ((var) = STAILQ_FIRST((head));                      \
    51             (var) && ((tvar) = STAILQ_NEXT((var), field), 1);  \
    52             (var) = (tvar))
     139#define STAILQ_FOREACH_SAFE(var, head, field, tvar)             \
     140       for ((var) = STAILQ_FIRST((head));                       \
     141            (var) && ((tvar) = STAILQ_NEXT((var), field), 1);   \
     142            (var) = (tvar))
     143#endif
     144
     145#ifndef STAILQ_INIT
     146#define STAILQ_INIT(head) do {                                  \
     147        (head)->stqh_first = NULL;                              \
     148        (head)->stqh_last = &(head)->stqh_first;                \
     149} while (/*CONSTCOND*/0)
     150#endif
     151
     152#ifndef STAILQ_INSERT_HEAD
     153#define STAILQ_INSERT_HEAD(head, elm, field) do {                       \
     154        if (((elm)->field.stqe_next = (head)->stqh_first) == NULL)      \
     155                (head)->stqh_last = &(elm)->field.stqe_next;            \
     156        (head)->stqh_first = (elm);                                     \
     157} while (/*CONSTCOND*/0)
     158#endif
     159
     160#ifndef STAILQ_INSERT_TAIL
     161#define STAILQ_INSERT_TAIL(head, elm, field) do {                       \
     162        (elm)->field.stqe_next = NULL;                                  \
     163        *(head)->stqh_last = (elm);                                     \
     164        (head)->stqh_last = &(elm)->field.stqe_next;                    \
     165} while (/*CONSTCOND*/0)
     166#endif
     167
     168#ifndef STAILQ_INSERT_AFTER
     169#define STAILQ_INSERT_AFTER(head, listelm, elm, field) do {             \
     170        if (((elm)->field.stqe_next = (listelm)->field.stqe_next) == NULL)\
     171                (head)->stqh_last = &(elm)->field.stqe_next;            \
     172        (listelm)->field.stqe_next = (elm);                             \
     173} while (/*CONSTCOND*/0)
    53174#endif
    54175
    55176#ifndef STAILQ_LAST
    56 #define STAILQ_LAST(head, type, field)                                  \
    57         (STAILQ_EMPTY((head)) ?                                         \
    58                 NULL :                                                  \
    59                 ((struct type *)(void *)                                \
    60                 ((char *)((head)->stqh_last) - offsetof(struct type, field))))
     177#define STAILQ_LAST(head, type, field)                                  \
     178        (STAILQ_EMPTY((head)) ?                                 \
     179            NULL : ((struct type *)(void *)                             \
     180            ((char *)((head)->stqh_last) - offsetof(struct type, field))))
     181#endif
     182
     183#ifndef STAILQ_NEXT
     184#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next)
     185#endif
     186
     187#ifndef STAILQ_REMOVE
     188#define STAILQ_REMOVE(head, elm, type, field) do {                      \
     189        if ((head)->stqh_first == (elm)) {                              \
     190                STAILQ_REMOVE_HEAD((head), field);                      \
     191        } else {                                                        \
     192                struct type *curelm = (head)->stqh_first;               \
     193                while (curelm->field.stqe_next != (elm))                \
     194                        curelm = curelm->field.stqe_next;               \
     195                if ((curelm->field.stqe_next =                          \
     196                        curelm->field.stqe_next->field.stqe_next) == NULL) \
     197                            (head)->stqh_last = &(curelm)->field.stqe_next; \
     198        }                                                               \
     199} while (/*CONSTCOND*/0)
     200#endif
     201
     202#ifndef STAILQ_REMOVE_HEAD
     203#define STAILQ_REMOVE_HEAD(head, field) do {                            \
     204        if (((head)->stqh_first = (head)->stqh_first->field.stqe_next) == \
     205            NULL)                                                       \
     206                (head)->stqh_last = &(head)->stqh_first;                \
     207} while (/*CONSTCOND*/0)
     208#endif
     209
     210/*
     211 * The STAILQ_SORT macro is adapted from Simon Tatham's O(n*log(n))
     212 * mergesort algorithm.
     213 */
     214#ifndef STAILQ_SORT
     215#define STAILQ_SORT(head, type, field, cmp) do {                        \
     216        STAILQ_HEAD(, type) _la, _lb;                                   \
     217        struct type *_p, *_q, *_e;                                      \
     218        int _i, _sz, _nmerges, _psz, _qsz;                              \
     219                                                                        \
     220        _sz = 1;                                                        \
     221        do {                                                            \
     222                _nmerges = 0;                                           \
     223                STAILQ_INIT(&_lb);                                      \
     224                while (!STAILQ_EMPTY((head))) {                         \
     225                        _nmerges++;                                     \
     226                        STAILQ_INIT(&_la);                              \
     227                        _psz = 0;                                       \
     228                        for (_i = 0; _i < _sz && !STAILQ_EMPTY((head)); \
     229                             _i++) {                                    \
     230                                _e = STAILQ_FIRST((head));              \
     231                                if (_e == NULL)                         \
     232                                        break;                          \
     233                                _psz++;                                 \
     234                                STAILQ_REMOVE_HEAD((head), field);      \
     235                                STAILQ_INSERT_TAIL(&_la, _e, field);    \
     236                        }                                               \
     237                        _p = STAILQ_FIRST(&_la);                        \
     238                        _qsz = _sz;                                     \
     239                        _q = STAILQ_FIRST((head));                      \
     240                        while (_psz > 0 || (_qsz > 0 && _q != NULL)) {  \
     241                                if (_psz == 0) {                        \
     242                                        _e = _q;                        \
     243                                        _q = STAILQ_NEXT(_q, field);    \
     244                                        STAILQ_REMOVE_HEAD((head),      \
     245                                            field);                     \
     246                                        _qsz--;                         \
     247                                } else if (_qsz == 0 || _q == NULL) {   \
     248                                        _e = _p;                        \
     249                                        _p = STAILQ_NEXT(_p, field);    \
     250                                        STAILQ_REMOVE_HEAD(&_la, field);\
     251                                        _psz--;                         \
     252                                } else if (cmp(_p, _q) <= 0) {          \
     253                                        _e = _p;                        \
     254                                        _p = STAILQ_NEXT(_p, field);    \
     255                                        STAILQ_REMOVE_HEAD(&_la, field);\
     256                                        _psz--;                         \
     257                                } else {                                \
     258                                        _e = _q;                        \
     259                                        _q = STAILQ_NEXT(_q, field);    \
     260                                        STAILQ_REMOVE_HEAD((head),      \
     261                                            field);                     \
     262                                        _qsz--;                         \
     263                                }                                       \
     264                                STAILQ_INSERT_TAIL(&_lb, _e, field);    \
     265                        }                                               \
     266                }                                                       \
     267                (head)->stqh_first = _lb.stqh_first;                    \
     268                (head)->stqh_last = _lb.stqh_last;                      \
     269                _sz *= 2;                                               \
     270        } while (_nmerges > 1);                                         \
     271} while (/*CONSTCOND*/0)
    61272#endif
    62273
     
    68279#endif
    69280
     281/* ]] --QUEUE-MACROS-- */
     282
    70283/*
    71284 * VCS Ids.
     
    73286
    74287#ifndef ELFTC_VCSID
     288
     289#if defined(__DragonFly__)
     290#define ELFTC_VCSID(ID)         __RCSID(ID)
     291#endif
    75292
    76293#if defined(__FreeBSD__)
     
    78295#endif
    79296
    80 #if defined(__linux__) || defined(__GNU__) || defined(__GLIBC__)
     297#if defined(__APPLE__) || defined(__GLIBC__) || defined(__GNU__) || \
     298    defined(__linux__)
    81299#if defined(__GNUC__)
    82300#define ELFTC_VCSID(ID)         __asm__(".ident\t\"" ID "\"")
     
    86304#endif
    87305
     306#if defined(__minix)
     307#if defined(__GNUC__)
     308#define ELFTC_VCSID(ID)         __asm__(".ident\t\"" ID "\"")
     309#else
     310#define ELFTC_VCSID(ID)         /**/
     311#endif  /* __GNU__ */
     312#endif
     313
    88314#if defined(__NetBSD__)
    89315#define ELFTC_VCSID(ID)         __RCSID(ID)
    90316#endif
    91317
     318#if defined(__OpenBSD__)
     319#if defined(__GNUC__)
     320#define ELFTC_VCSID(ID)         __asm__(".ident\t\"" ID "\"")
     321#else
     322#define ELFTC_VCSID(ID)         /**/
     323#endif  /* __GNUC__ */
     324#endif
     325
     326#ifndef ELFTC_VCSID
     327#define ELFTC_VCSID(ID)         /**/
     328#endif
     329
    92330#endif  /* ELFTC_VCSID */
    93331
     
    98336#ifndef ELFTC_GETPROGNAME
    99337
    100 #if defined(__FreeBSD__) || defined(__NetBSD__)
     338#if defined(__APPLE__) || defined(__DragonFly__) || defined(__FreeBSD__) || \
     339    defined(__minix) || defined(__NetBSD__)
    101340
    102341#include <stdlib.h>
     
    104343#define ELFTC_GETPROGNAME()     getprogname()
    105344
    106 #endif  /* defined(__FreeBSD__) || defined(__NetBSD__) */
    107 
    108 
    109 #if defined(__linux__)
    110 
     345#endif  /* __DragonFly__ || __FreeBSD__ || __minix || __NetBSD__ */
     346
     347
     348#if defined(__GLIBC__) || defined(__linux__)
     349#ifndef _GNU_SOURCE
    111350/*
    112351 * GLIBC based systems have a global 'char *' pointer referencing
     
    114353 */
    115354extern const char *program_invocation_short_name;
     355#endif  /* !_GNU_SOURCE */
    116356
    117357#define ELFTC_GETPROGNAME()     program_invocation_short_name
    118358
    119 #endif  /* __linux__ */
     359#endif  /* __GLIBC__ || __linux__ */
     360
     361
     362#if defined(__OpenBSD__)
     363
     364extern const char *__progname;
     365
     366#define ELFTC_GETPROGNAME()     __progname
     367
     368#endif  /* __OpenBSD__ */
     369
     370#ifndef ELFTC_GETPROGNAME
     371#define ELFTC_GETPROGNAME() "no_progname"
     372#endif
    120373
    121374#endif  /* ELFTC_GETPROGNAME */
     375
    122376
    123377/**
     
    125379 **/
    126380
    127 #if defined(__linux__)
     381#if defined(__APPLE__)
     382
     383#include <libkern/OSByteOrder.h>
     384#define htobe32(x)      OSSwapHostToBigInt32(x)
     385#define roundup2        roundup
     386
     387#define ELFTC_BYTE_ORDER                        _BYTE_ORDER
     388#define ELFTC_BYTE_ORDER_LITTLE_ENDIAN          _LITTLE_ENDIAN
     389#define ELFTC_BYTE_ORDER_BIG_ENDIAN             _BIG_ENDIAN
     390
     391#define ELFTC_HAVE_MMAP                         1
     392#define ELFTC_HAVE_STRMODE                      1
     393
     394#define ELFTC_NEED_BYTEORDER_EXTENSIONS         1
     395#endif /* __APPLE__ */
     396
     397
     398#if defined(__DragonFly__)
     399
     400#include <osreldate.h>
     401#include <sys/endian.h>
     402
     403#define ELFTC_BYTE_ORDER                        _BYTE_ORDER
     404#define ELFTC_BYTE_ORDER_LITTLE_ENDIAN          _LITTLE_ENDIAN
     405#define ELFTC_BYTE_ORDER_BIG_ENDIAN             _BIG_ENDIAN
     406
     407#define ELFTC_HAVE_MMAP                         1
     408
     409#endif
     410
     411#if defined(__GLIBC__) || defined(__linux__)
    128412
    129413#include <endian.h>
     
    133417#define ELFTC_BYTE_ORDER_BIG_ENDIAN             __BIG_ENDIAN
    134418
    135 /*
    136  * Debian GNU/Linux is missing strmode(3).
     419#define ELFTC_HAVE_MMAP                         1
     420
     421/*
     422 * Debian GNU/Linux and Debian GNU/kFreeBSD do not have strmode(3).
    137423 */
    138424#define ELFTC_HAVE_STRMODE                      0
     
    143429#define roundup2        roundup
    144430
    145 #endif  /* __linux__ */
     431#endif  /* __GLIBC__ || __linux__ */
    146432
    147433
     
    155441#define ELFTC_BYTE_ORDER_BIG_ENDIAN             _BIG_ENDIAN
    156442
     443#define ELFTC_HAVE_MMAP                         1
    157444#define ELFTC_HAVE_STRMODE                      1
    158445#if __FreeBSD_version <= 900000
     
    162449
    163450
     451#if defined(__minix)
     452#define ELFTC_HAVE_MMAP                         0
     453#endif  /* __minix */
     454
     455
    164456#if defined(__NetBSD__)
    165457
     458#include <sys/param.h>
    166459#include <sys/endian.h>
    167460
     
    170463#define ELFTC_BYTE_ORDER_BIG_ENDIAN             _BIG_ENDIAN
    171464
     465#define ELFTC_HAVE_MMAP                         1
    172466#define ELFTC_HAVE_STRMODE                      1
    173 #define ELFTC_BROKEN_YY_NO_INPUT                1
     467#if __NetBSD_Version__ <= 599002100
     468/* from src/doc/CHANGES: flex(1): Import flex-2.5.35 [christos 20091025] */
     469/* and 5.99.21 was from Wed Oct 21 21:28:36 2009 UTC */
     470#  define ELFTC_BROKEN_YY_NO_INPUT              1
     471#endif
    174472#endif  /* __NetBSD __ */
    175473
     474
     475#if defined(__OpenBSD__)
     476
     477#include <sys/param.h>
     478#include <sys/endian.h>
     479
     480#define ELFTC_BYTE_ORDER                        _BYTE_ORDER
     481#define ELFTC_BYTE_ORDER_LITTLE_ENDIAN          _LITTLE_ENDIAN
     482#define ELFTC_BYTE_ORDER_BIG_ENDIAN             _BIG_ENDIAN
     483
     484#define ELFTC_HAVE_MMAP                         1
     485#define ELFTC_HAVE_STRMODE                      1
     486
     487#define ELFTC_NEED_BYTEORDER_EXTENSIONS         1
     488#define roundup2        roundup
     489
     490#endif  /* __OpenBSD__ */
     491
     492#if defined(__WIN32__) || defined(__CYGWIN__)
     493
     494#if defined(__CYGWIN__)
     495#include <sys/endian.h>
     496#else /* __CYGWIN */
     497#include <winsock2.h>
     498#define htobe32(x)      (x)
     499#endif /* __WIN32__ */
     500
     501#include <sys/param.h>
     502
     503#define ELFTC_BYTE_ORDER                        _BYTE_ORDER
     504#define ELFTC_BYTE_ORDER_LITTLE_ENDIAN          _LITTLE_ENDIAN
     505#define ELFTC_BYTE_ORDER_BIG_ENDIAN             _BIG_ENDIAN
     506
     507#define ELFTC_HAVE_MMAP                         1
     508
     509#endif  /* __WIN32__ || __CYGWIN__ */
     510
    176511#endif  /* _ELFTC_H */
  • rtemstoolkit/elftoolchain/common/elfdefinitions.h

    r6f48c91 r771e7f1  
    2424 * SUCH DAMAGE.
    2525 *
    26  * $Id: elfdefinitions.h 2132 2011-11-10 08:27:41Z jkoshy $
     26 * $Id: elfdefinitions.h 3515 2017-01-24 22:04:22Z emaste $
    2727 */
    2828
     
    154154_ELF_DEFINE_DT(DT_SUNW_CAP,         0x60000010UL,                       \
    155155        "address of hardware capabilities section")                     \
     156_ELF_DEFINE_DT(DT_SUNW_ASLR,        0x60000023UL,                       \
     157        "Address Space Layout Randomization flag")                      \
    156158_ELF_DEFINE_DT(DT_HIOS,             0x6FFFF000UL,                       \
    157159        "end of OS-specific types")                                     \
     
    172174_ELF_DEFINE_DT(DT_MOVESZ,           0x6FFFFDFBUL,                       \
    173175        "total size of the MOVETAB table")                              \
    174 _ELF_DEFINE_DT(DT_FEATURE_1,        0x6FFFFDFCUL, "feature values")     \
     176_ELF_DEFINE_DT(DT_FEATURE        0x6FFFFDFCUL, "feature values")     \
    175177_ELF_DEFINE_DT(DT_POSFLAG_1,        0x6FFFFDFDUL,                       \
    176178        "dynamic position flags")                                       \
     
    185187_ELF_DEFINE_DT(DT_GNU_HASH,         0x6FFFFEF5UL,                       \
    186188        "GNU style hash tables")                                        \
     189_ELF_DEFINE_DT(DT_TLSDESC_PLT,      0x6FFFFEF6UL,                       \
     190        "location of PLT entry for TLS descriptor resolver calls")      \
     191_ELF_DEFINE_DT(DT_TLSDESC_GOT,      0x6FFFFEF7UL,                       \
     192        "location of GOT entry used by TLS descriptor resolver PLT entry") \
    187193_ELF_DEFINE_DT(DT_GNU_CONFLICT,     0x6FFFFEF8UL,                       \
    188194        "address of conflict section")                                  \
     
    270276        "number of entries in DT_MIPS_DELTA_RELOC")                     \
    271277_ELF_DEFINE_DT(DT_MIPS_DELTA_SYM,   0x7000001DUL,                       \
    272         "Delta symbols refered by Delta relocations")                   \
     278        "Delta symbols referred by Delta relocations")                  \
    273279_ELF_DEFINE_DT(DT_MIPS_DELTA_SYM_NO, 0x7000001EUL,                      \
    274280        "number of entries in DT_MIPS_DELTA_SYM")                       \
     
    363369_ELF_DEFINE_EF(EF_ARM_EABIMASK,     0xFF000000UL,                       \
    364370        "mask for ARM EABI version number (0 denotes GNU or unknown)")  \
     371_ELF_DEFINE_EF(EF_ARM_EABI_UNKNOWN, 0x00000000UL,                       \
     372        "Unknown or GNU ARM EABI version number")                       \
     373_ELF_DEFINE_EF(EF_ARM_EABI_VER1,    0x01000000UL,                       \
     374        "ARM EABI version 1")                                           \
     375_ELF_DEFINE_EF(EF_ARM_EABI_VER2,    0x02000000UL,                       \
     376        "ARM EABI version 2")                                           \
     377_ELF_DEFINE_EF(EF_ARM_EABI_VER3,    0x03000000UL,                       \
     378        "ARM EABI version 3")                                           \
     379_ELF_DEFINE_EF(EF_ARM_EABI_VER4,    0x04000000UL,                       \
     380        "ARM EABI version 4")                                           \
     381_ELF_DEFINE_EF(EF_ARM_EABI_VER5,    0x05000000UL,                       \
     382        "ARM EABI version 5")                                           \
    365383_ELF_DEFINE_EF(EF_ARM_INTERWORK,    0x00000004UL,                       \
    366384        "GNU EABI extension")                                           \
     
    529547_ELF_DEFINE_EABI(ELFOSABI_FENIXOS,    16,                               \
    530548        "The FenixOS highly scalable multi-core OS")                    \
     549_ELF_DEFINE_EABI(ELFOSABI_CLOUDABI,   17, "Nuxi CloudABI")              \
    531550_ELF_DEFINE_EABI(ELFOSABI_ARM_AEABI,  64,                               \
    532551        "ARM specific symbol versioning extensions")                    \
     
    554573_ELF_DEFINE_EM(EM_68K,              4, "Motorola 68000")                \
    555574_ELF_DEFINE_EM(EM_88K,              5, "Motorola 88000")                \
     575_ELF_DEFINE_EM(EM_IAMCU,            6, "Intel MCU")                     \
    556576_ELF_DEFINE_EM(EM_860,              7, "Intel 80860")                   \
    557577_ELF_DEFINE_EM(EM_MIPS,             8, "MIPS I Architecture")           \
     
    759779_ELF_DEFINE_EM(EM_SLE9X,            179,                                \
    760780        "Infineon Technologies SLE9X core")                             \
     781_ELF_DEFINE_EM(EM_AARCH64,          183,                                \
     782        "AArch64 (64-bit ARM)")                                         \
    761783_ELF_DEFINE_EM(EM_AVR32,            185,                                \
    762784        "Atmel Corporation 32-bit microprocessor family")               \
     
    783805_ELF_DEFINE_EM(EM_RL78,             197, "Renesas RL78 family")         \
    784806_ELF_DEFINE_EM(EM_VIDEOCORE5,       198, "Broadcom VideoCore V processor") \
    785 _ELF_DEFINE_EM(EM_78KOR,            199, "Renesas 78KOR family")
     807_ELF_DEFINE_EM(EM_78KOR,            199, "Renesas 78KOR family")        \
     808_ELF_DEFINE_EM(EM_56800EX,          200,                                \
     809        "Freescale 56800EX Digital Signal Controller")                  \
     810_ELF_DEFINE_EM(EM_BA1,              201, "Beyond BA1 CPU architecture") \
     811_ELF_DEFINE_EM(EM_BA2,              202, "Beyond BA2 CPU architecture") \
     812_ELF_DEFINE_EM(EM_XCORE,            203, "XMOS xCORE processor family") \
     813_ELF_DEFINE_EM(EM_MCHP_PIC,         204, "Microchip 8-bit PIC(r) family") \
     814_ELF_DEFINE_EM(EM_INTEL205,         205, "Reserved by Intel")           \
     815_ELF_DEFINE_EM(EM_INTEL206,         206, "Reserved by Intel")           \
     816_ELF_DEFINE_EM(EM_INTEL207,         207, "Reserved by Intel")           \
     817_ELF_DEFINE_EM(EM_INTEL208,         208, "Reserved by Intel")           \
     818_ELF_DEFINE_EM(EM_INTEL209,         209, "Reserved by Intel")           \
     819_ELF_DEFINE_EM(EM_KM32,             210, "KM211 KM32 32-bit processor") \
     820_ELF_DEFINE_EM(EM_KMX32,            211, "KM211 KMX32 32-bit processor") \
     821_ELF_DEFINE_EM(EM_KMX16,            212, "KM211 KMX16 16-bit processor") \
     822_ELF_DEFINE_EM(EM_KMX8,             213, "KM211 KMX8 8-bit processor")  \
     823_ELF_DEFINE_EM(EM_KVARC,            214, "KM211 KMX32 KVARC processor") \
     824_ELF_DEFINE_EM(EM_RISCV,            243, "RISC-V")
    786825
    787826#undef  _ELF_DEFINE_EM
     
    792831};
    793832
    794 /* Older synonyms. */
     833/* Other synonyms. */
     834#define EM_AMD64                EM_X86_64
    795835#define EM_ARC_A5               EM_ARC_COMPACT
    796836
     
    826866#define GRP_MASKOS      0x0ff00000      /* OS-specific flags */
    827867#define GRP_MASKPROC    0xf0000000      /* processor-specific flags */
     868
     869/*
     870 * Flags / mask for .gnu.versym sections.
     871 */
     872#define VERSYM_VERSION  0x7fff
     873#define VERSYM_HIDDEN   0x8000
    828874
    829875/*
     
    876922_ELF_DEFINE_PT(PT_GNU_RELRO,        0x6474E552UL,               \
    877923        "Segment becomes read-only after relocation")           \
     924_ELF_DEFINE_PT(PT_OPENBSD_RANDOMIZE,0x65A3DBE6UL,               \
     925        "Segment filled with random data")                      \
     926_ELF_DEFINE_PT(PT_OPENBSD_WXNEEDED, 0x65A3DBE7UL,               \
     927        "Program violates W^X")                                 \
     928_ELF_DEFINE_PT(PT_OPENBSD_BOOTDATA, 0x65A41BE6UL,               \
     929        "Boot data")                                            \
    878930_ELF_DEFINE_PT(PT_SUNWBSS,          0x6FFFFFFAUL,               \
    879931        "A Solaris .SUNW_bss section")                          \
     
    937989_ELF_DEFINE_SHF(SHF_TLS,             0x400,                             \
    938990        "holds thread-local storage")                                   \
     991_ELF_DEFINE_SHF(SHF_COMPRESSED,      0x800,                             \
     992        "holds compressed data")                                        \
    939993_ELF_DEFINE_SHF(SHF_MASKOS,          0x0FF00000UL,                      \
    940994        "bits reserved for OS-specific semantics")                      \
     
    11491203_ELF_DEFINE_SHT(SHT_MIPS_PDR_EXCEPTION, 0x70000029UL,                   \
    11501204        "runtime procedure descriptor table exception information")     \
     1205_ELF_DEFINE_SHT(SHT_MIPS_ABIFLAGS,   0x7000002AUL,                      \
     1206        "ABI flags")                                                    \
    11511207_ELF_DEFINE_SHT(SHT_SPARC_GOTDATA,   0x70000000UL,                      \
    11521208        "SPARC-specific data")                                          \
    1153 _ELF_DEFINE_SHT(SHT_AMD64_UNWIND,    0x70000001UL,                      \
     1209_ELF_DEFINE_SHT(SHT_X86_64_UNWIND,   0x70000001UL,                      \
    11541210        "unwind tables for the AMD64")                                  \
    11551211_ELF_DEFINE_SHT(SHT_ORDERED,         0x7FFFFFFFUL,                      \
     
    11701226
    11711227/* Aliases for section types. */
     1228#define SHT_AMD64_UNWIND        SHT_X86_64_UNWIND
    11721229#define SHT_GNU_verdef          SHT_SUNW_verdef
    11731230#define SHT_GNU_verneed         SHT_SUNW_verneed
     
    11861243        "visible across all object files but with low precedence")      \
    11871244_ELF_DEFINE_STB(STB_LOOS,            10, "start of OS-specific range")  \
     1245_ELF_DEFINE_STB(STB_GNU_UNIQUE,      10, "unique symbol (GNU)")         \
    11881246_ELF_DEFINE_STB(STB_HIOS,            12, "end of OS-specific range")    \
    11891247_ELF_DEFINE_STB(STB_LOPROC,          13,                                \
     
    12121270_ELF_DEFINE_STT(STT_TLS,             6, "thread local storage")         \
    12131271_ELF_DEFINE_STT(STT_LOOS,            10, "start of OS-specific types")  \
     1272_ELF_DEFINE_STT(STT_GNU_IFUNC,       10, "indirect function")   \
    12141273_ELF_DEFINE_STT(STT_HIOS,            12, "end of OS-specific types")    \
    12151274_ELF_DEFINE_STT(STT_LOPROC,          13,                                \
     
    12171276_ELF_DEFINE_STT(STT_ARM_TFUNC,       13, "Thumb function (GNU)")        \
    12181277_ELF_DEFINE_STT(STT_ARM_16BIT,       15, "Thumb label (GNU)")           \
     1278_ELF_DEFINE_STT(STT_SPARC_REGISTER,  13, "SPARC register information")  \
    12191279_ELF_DEFINE_STT(STT_HIPROC,          15,                                \
    12201280        "end of processor-specific types")
     
    13531413_ELF_DEFINE_RELOC(R_386_COPY,           5)      \
    13541414_ELF_DEFINE_RELOC(R_386_GLOB_DAT,       6)      \
    1355 _ELF_DEFINE_RELOC(R_386_JMP_SLOT,       7)      \
     1415_ELF_DEFINE_RELOC(R_386_JUMP_SLOT,      7)      \
    13561416_ELF_DEFINE_RELOC(R_386_RELATIVE,       8)      \
    13571417_ELF_DEFINE_RELOC(R_386_GOTOFF,         9)      \
    13581418_ELF_DEFINE_RELOC(R_386_GOTPC,          10)     \
    13591419_ELF_DEFINE_RELOC(R_386_32PLT,          11)     \
     1420_ELF_DEFINE_RELOC(R_386_TLS_TPOFF,      14)     \
     1421_ELF_DEFINE_RELOC(R_386_TLS_IE,         15)     \
     1422_ELF_DEFINE_RELOC(R_386_TLS_GOTIE,      16)     \
     1423_ELF_DEFINE_RELOC(R_386_TLS_LE,         17)     \
     1424_ELF_DEFINE_RELOC(R_386_TLS_GD,         18)     \
     1425_ELF_DEFINE_RELOC(R_386_TLS_LDM,        19)     \
    13601426_ELF_DEFINE_RELOC(R_386_16,             20)     \
    13611427_ELF_DEFINE_RELOC(R_386_PC16,           21)     \
    13621428_ELF_DEFINE_RELOC(R_386_8,              22)     \
    1363 _ELF_DEFINE_RELOC(R_386_PC8,            23)
     1429_ELF_DEFINE_RELOC(R_386_PC8,            23)     \
     1430_ELF_DEFINE_RELOC(R_386_TLS_GD_32,      24)     \
     1431_ELF_DEFINE_RELOC(R_386_TLS_GD_PUSH,    25)     \
     1432_ELF_DEFINE_RELOC(R_386_TLS_GD_CALL,    26)     \
     1433_ELF_DEFINE_RELOC(R_386_TLS_GD_POP,     27)     \
     1434_ELF_DEFINE_RELOC(R_386_TLS_LDM_32,     28)     \
     1435_ELF_DEFINE_RELOC(R_386_TLS_LDM_PUSH,   29)     \
     1436_ELF_DEFINE_RELOC(R_386_TLS_LDM_CALL,   30)     \
     1437_ELF_DEFINE_RELOC(R_386_TLS_LDM_POP,    31)     \
     1438_ELF_DEFINE_RELOC(R_386_TLS_LDO_32,     32)     \
     1439_ELF_DEFINE_RELOC(R_386_TLS_IE_32,      33)     \
     1440_ELF_DEFINE_RELOC(R_386_TLS_LE_32,      34)     \
     1441_ELF_DEFINE_RELOC(R_386_TLS_DTPMOD32,   35)     \
     1442_ELF_DEFINE_RELOC(R_386_TLS_DTPOFF32,   36)     \
     1443_ELF_DEFINE_RELOC(R_386_TLS_TPOFF32,    37)     \
     1444_ELF_DEFINE_RELOC(R_386_SIZE32,         38)     \
     1445_ELF_DEFINE_RELOC(R_386_TLS_GOTDESC,    39)     \
     1446_ELF_DEFINE_RELOC(R_386_TLS_DESC_CALL,  40)     \
     1447_ELF_DEFINE_RELOC(R_386_TLS_DESC,       41)     \
     1448_ELF_DEFINE_RELOC(R_386_IRELATIVE,      42)     \
     1449_ELF_DEFINE_RELOC(R_386_GOT32X,         43)
     1450
     1451
     1452/*
     1453 */
     1454#define _ELF_DEFINE_AARCH64_RELOCATIONS()                               \
     1455_ELF_DEFINE_RELOC(R_AARCH64_NONE,                               0)      \
     1456_ELF_DEFINE_RELOC(R_AARCH64_ABS64,                              257)    \
     1457_ELF_DEFINE_RELOC(R_AARCH64_ABS32,                              258)    \
     1458_ELF_DEFINE_RELOC(R_AARCH64_ABS16,                              259)    \
     1459_ELF_DEFINE_RELOC(R_AARCH64_PREL64,                             260)    \
     1460_ELF_DEFINE_RELOC(R_AARCH64_PREL32,                             261)    \
     1461_ELF_DEFINE_RELOC(R_AARCH64_PREL16,                             262)    \
     1462_ELF_DEFINE_RELOC(R_AARCH64_MOVW_UABS_G0,                       263)    \
     1463_ELF_DEFINE_RELOC(R_AARCH64_MOVW_UABS_G0_NC,                    264)    \
     1464_ELF_DEFINE_RELOC(R_AARCH64_MOVW_UABS_G1,                       265)    \
     1465_ELF_DEFINE_RELOC(R_AARCH64_MOVW_UABS_G1_NC,                    266)    \
     1466_ELF_DEFINE_RELOC(R_AARCH64_MOVW_UABS_G2,                       267)    \
     1467_ELF_DEFINE_RELOC(R_AARCH64_MOVW_UABS_G2_NC,                    268)    \
     1468_ELF_DEFINE_RELOC(R_AARCH64_MOVW_UABS_G3,                       269)    \
     1469_ELF_DEFINE_RELOC(R_AARCH64_MOVW_SABS_G0,                       270)    \
     1470_ELF_DEFINE_RELOC(R_AARCH64_MOVW_SABS_G1,                       271)    \
     1471_ELF_DEFINE_RELOC(R_AARCH64_MOVW_SABS_G2,                       272)    \
     1472_ELF_DEFINE_RELOC(R_AARCH64_LD_PREL_LO19,                       273)    \
     1473_ELF_DEFINE_RELOC(R_AARCH64_ADR_PREL_LO21,                      274)    \
     1474_ELF_DEFINE_RELOC(R_AARCH64_ADR_PREL_PG_HI21,                   275)    \
     1475_ELF_DEFINE_RELOC(R_AARCH64_ADR_PREL_PG_HI21_NC,                276)    \
     1476_ELF_DEFINE_RELOC(R_AARCH64_ADD_ABS_LO12_NC,                    277)    \
     1477_ELF_DEFINE_RELOC(R_AARCH64_LDST8_ABS_LO12_NC,                  278)    \
     1478_ELF_DEFINE_RELOC(R_AARCH64_TSTBR14,                            279)    \
     1479_ELF_DEFINE_RELOC(R_AARCH64_CONDBR19,                           280)    \
     1480_ELF_DEFINE_RELOC(R_AARCH64_JUMP26,                             282)    \
     1481_ELF_DEFINE_RELOC(R_AARCH64_CALL26,                             283)    \
     1482_ELF_DEFINE_RELOC(R_AARCH64_LDST16_ABS_LO12_NC,                 284)    \
     1483_ELF_DEFINE_RELOC(R_AARCH64_LDST32_ABS_LO12_NC,                 285)    \
     1484_ELF_DEFINE_RELOC(R_AARCH64_LDST64_ABS_LO12_NC,                 286)    \
     1485_ELF_DEFINE_RELOC(R_AARCH64_MOVW_PREL_G0,                       287)    \
     1486_ELF_DEFINE_RELOC(R_AARCH64_MOVW_PREL_G0_NC,                    288)    \
     1487_ELF_DEFINE_RELOC(R_AARCH64_MOVW_PREL_G1,                       289)    \
     1488_ELF_DEFINE_RELOC(R_AARCH64_MOVW_PREL_G1_NC,                    290)    \
     1489_ELF_DEFINE_RELOC(R_AARCH64_MOVW_PREL_G2,                       291)    \
     1490_ELF_DEFINE_RELOC(R_AARCH64_MOVW_PREL_G2_NC,                    292)    \
     1491_ELF_DEFINE_RELOC(R_AARCH64_MOVW_PREL_G3,                       293)    \
     1492_ELF_DEFINE_RELOC(R_AARCH64_LDST128_ABS_LO12_NC,                299)    \
     1493_ELF_DEFINE_RELOC(R_AARCH64_MOVW_GOTOFF_G0,                     300)    \
     1494_ELF_DEFINE_RELOC(R_AARCH64_MOVW_GOTOFF_G0_NC,                  301)    \
     1495_ELF_DEFINE_RELOC(R_AARCH64_MOVW_GOTOFF_G1,                     302)    \
     1496_ELF_DEFINE_RELOC(R_AARCH64_MOVW_GOTOFF_G1_NC,                  303)    \
     1497_ELF_DEFINE_RELOC(R_AARCH64_MOVW_GOTOFF_G2,                     304)    \
     1498_ELF_DEFINE_RELOC(R_AARCH64_MOVW_GOTOFF_G2_NC,                  305)    \
     1499_ELF_DEFINE_RELOC(R_AARCH64_MOVW_GOTOFF_G3,                     306)    \
     1500_ELF_DEFINE_RELOC(R_AARCH64_GOTREL64,                           307)    \
     1501_ELF_DEFINE_RELOC(R_AARCH64_GOTREL32,                           308)    \
     1502_ELF_DEFINE_RELOC(R_AARCH64_GOT_LD_PREL19,                      309)    \
     1503_ELF_DEFINE_RELOC(R_AARCH64_LD64_GOTOFF_LO15,                   310)    \
     1504_ELF_DEFINE_RELOC(R_AARCH64_ADR_GOT_PAGE,                       311)    \
     1505_ELF_DEFINE_RELOC(R_AARCH64_LD64_GOT_LO12_NC,                   312)    \
     1506_ELF_DEFINE_RELOC(R_AARCH64_LD64_GOTPAGE_LO15,                  313)    \
     1507_ELF_DEFINE_RELOC(R_AARCH64_TLSGD_ADR_PREL21,                   512)    \
     1508_ELF_DEFINE_RELOC(R_AARCH64_TLSGD_ADR_PAGE21,                   513)    \
     1509_ELF_DEFINE_RELOC(R_AARCH64_TLSGD_ADD_LO12_NC,                  514)    \
     1510_ELF_DEFINE_RELOC(R_AARCH64_TLSGD_MOVW_G1,                      515)    \
     1511_ELF_DEFINE_RELOC(R_AARCH64_TLSGD_MOVW_G0_NC,                   516)    \
     1512_ELF_DEFINE_RELOC(R_AARCH64_TLSLD_ADR_PREL21,                   517)    \
     1513_ELF_DEFINE_RELOC(R_AARCH64_TLSLD_ADR_PAGE21,                   518)    \
     1514_ELF_DEFINE_RELOC(R_AARCH64_TLSLD_ADD_LO12_NC,                  519)    \
     1515_ELF_DEFINE_RELOC(R_AARCH64_TLSLD_MOVW_G1,                      520)    \
     1516_ELF_DEFINE_RELOC(R_AARCH64_TLSLD_MOVW_G0_NC,                   521)    \
     1517_ELF_DEFINE_RELOC(R_AARCH64_TLSLD_LD_PREL19,                    522)    \
     1518_ELF_DEFINE_RELOC(R_AARCH64_TLSLD_MOVW_DTPREL_G2,               523)    \
     1519_ELF_DEFINE_RELOC(R_AARCH64_TLSLD_MOVW_DTPREL_G1,               524)    \
     1520_ELF_DEFINE_RELOC(R_AARCH64_TLSLD_MOVW_DTPREL_G1_NC,            525)    \
     1521_ELF_DEFINE_RELOC(R_AARCH64_TLSLD_MOVW_DTPREL_G0,               526)    \
     1522_ELF_DEFINE_RELOC(R_AARCH64_TLSLD_MOVW_DTPREL_G0_NC,            527)    \
     1523_ELF_DEFINE_RELOC(R_AARCH64_TLSLD_ADD_DTPREL_HI12,              529)    \
     1524_ELF_DEFINE_RELOC(R_AARCH64_TLSLD_ADD_DTPREL_LO12_NC,           530)    \
     1525_ELF_DEFINE_RELOC(R_AARCH64_TLSLD_LDST8_DTPREL_LO12,            531)    \
     1526_ELF_DEFINE_RELOC(R_AARCH64_TLSLD_LDST8_DTPREL_LO12_NC,         532)    \
     1527_ELF_DEFINE_RELOC(R_AARCH64_TLSLD_LDST16_DTPREL_LO12,           533)    \
     1528_ELF_DEFINE_RELOC(R_AARCH64_TLSLD_LDST16_DTPREL_LO12_NC,        534)    \
     1529_ELF_DEFINE_RELOC(R_AARCH64_TLSLD_LDST32_DTPREL_LO12,           535)    \
     1530_ELF_DEFINE_RELOC(R_AARCH64_TLSLD_LDST32_DTPREL_LO12_NC,        536)    \
     1531_ELF_DEFINE_RELOC(R_AARCH64_TLSLD_LDST64_DTPREL_LO12,           537)    \
     1532_ELF_DEFINE_RELOC(R_AARCH64_TLSLD_LDST64_DTPREL_LO12_NC,        538)    \
     1533_ELF_DEFINE_RELOC(R_AARCH64_TLSIE_MOVW_GOTTPREL_G1,             539)    \
     1534_ELF_DEFINE_RELOC(R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC,          540)    \
     1535_ELF_DEFINE_RELOC(R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21,          541)    \
     1536_ELF_DEFINE_RELOC(R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC,        542)    \
     1537_ELF_DEFINE_RELOC(R_AARCH64_TLSIE_LD_GOTTPREL_PREL19,           543)    \
     1538_ELF_DEFINE_RELOC(R_AARCH64_TLSLE_MOVW_TPREL_G2,                544)    \
     1539_ELF_DEFINE_RELOC(R_AARCH64_TLSLE_MOVW_TPREL_G1,                545)    \
     1540_ELF_DEFINE_RELOC(R_AARCH64_TLSLE_MOVW_TPREL_G1_NC,             546)    \
     1541_ELF_DEFINE_RELOC(R_AARCH64_TLSLE_MOVW_TPREL_G0,                547)    \
     1542_ELF_DEFINE_RELOC(R_AARCH64_TLSLE_MOVW_TPREL_G0_NC,             548)    \
     1543_ELF_DEFINE_RELOC(R_AARCH64_TLSLE_ADD_TPREL_HI12,               549)    \
     1544_ELF_DEFINE_RELOC(R_AARCH64_TLSLE_ADD_TPREL_LO12,               550)    \
     1545_ELF_DEFINE_RELOC(R_AARCH64_TLSLE_ADD_TPREL_LO12_NC,            551)    \
     1546_ELF_DEFINE_RELOC(R_AARCH64_TLSLE_LDST8_TPREL_LO12,             552)    \
     1547_ELF_DEFINE_RELOC(R_AARCH64_TLSLE_LDST8_TPREL_LO12_NC,          553)    \
     1548_ELF_DEFINE_RELOC(R_AARCH64_TLSLE_LDST16_TPREL_LO12,            554)    \
     1549_ELF_DEFINE_RELOC(R_AARCH64_TLSLE_LDST16_TPREL_LO12_NC,         555)    \
     1550_ELF_DEFINE_RELOC(R_AARCH64_TLSLE_LDST32_TPREL_LO12,            556)    \
     1551_ELF_DEFINE_RELOC(R_AARCH64_TLSLE_LDST32_TPREL_LO12_NC,         557)    \
     1552_ELF_DEFINE_RELOC(R_AARCH64_TLSLE_LDST64_TPREL_LO12,            558)    \
     1553_ELF_DEFINE_RELOC(R_AARCH64_TLSLE_LDST64_TPREL_LO12_NC,         559)    \
     1554_ELF_DEFINE_RELOC(R_AARCH64_TLSDESC_LD_PREL19,                  560)    \
     1555_ELF_DEFINE_RELOC(R_AARCH64_TLSDESC_ADR_PREL21,                 561)    \
     1556_ELF_DEFINE_RELOC(R_AARCH64_TLSDESC_ADR_PAGE21,                 562)    \
     1557_ELF_DEFINE_RELOC(R_AARCH64_TLSDESC_LD64_LO12,                  563)    \
     1558_ELF_DEFINE_RELOC(R_AARCH64_TLSDESC_ADD_LO12,                   564)    \
     1559_ELF_DEFINE_RELOC(R_AARCH64_TLSDESC_OFF_G1,                     565)    \
     1560_ELF_DEFINE_RELOC(R_AARCH64_TLSDESC_OFF_G0_NC,                  566)    \
     1561_ELF_DEFINE_RELOC(R_AARCH64_TLSDESC_LDR,                        567)    \
     1562_ELF_DEFINE_RELOC(R_AARCH64_TLSDESC_ADD,                        568)    \
     1563_ELF_DEFINE_RELOC(R_AARCH64_TLSDESC_CALL,                       569)    \
     1564_ELF_DEFINE_RELOC(R_AARCH64_TLSLE_LDST128_TPREL_LO12,           570)    \
     1565_ELF_DEFINE_RELOC(R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC,        571)    \
     1566_ELF_DEFINE_RELOC(R_AARCH64_TLSLD_LDST128_DTPREL_LO12,          572)    \
     1567_ELF_DEFINE_RELOC(R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC,       573)    \
     1568_ELF_DEFINE_RELOC(R_AARCH64_COPY,                               1024)   \
     1569_ELF_DEFINE_RELOC(R_AARCH64_GLOB_DAT,                           1025)   \
     1570_ELF_DEFINE_RELOC(R_AARCH64_JUMP_SLOT,                          1026)   \
     1571_ELF_DEFINE_RELOC(R_AARCH64_RELATIVE,                           1027)   \
     1572_ELF_DEFINE_RELOC(R_AARCH64_TLS_DTPREL64,                       1028)   \
     1573_ELF_DEFINE_RELOC(R_AARCH64_TLS_DTPMOD64,                       1029)   \
     1574_ELF_DEFINE_RELOC(R_AARCH64_TLS_TPREL64,                        1030)   \
     1575_ELF_DEFINE_RELOC(R_AARCH64_TLSDESC,                            1031)   \
     1576_ELF_DEFINE_RELOC(R_AARCH64_IRELATIVE,                          1032)
    13641577
    13651578/*
     
    13891602_ELF_DEFINE_RELOC(R_AMD64_GOTPC32,      26)
    13901603
     1604/*
     1605 * Relocation definitions from the ARM ELF ABI, version "ARM IHI
     1606 * 0044E" released on 30th November 2012.
     1607 */
    13911608#define _ELF_DEFINE_ARM_RELOCATIONS()                   \
    13921609_ELF_DEFINE_RELOC(R_ARM_NONE,                   0)      \
     
    14041621_ELF_DEFINE_RELOC(R_ARM_BREL_ADJ,               12)     \
    14051622_ELF_DEFINE_RELOC(R_ARM_SWI24,                  13)     \
     1623_ELF_DEFINE_RELOC(R_ARM_TLS_DESC,               13)     \
    14061624_ELF_DEFINE_RELOC(R_ARM_THM_SWI8,               14)     \
    14071625_ELF_DEFINE_RELOC(R_ARM_XPC25,                  15)     \
     
    14221640_ELF_DEFINE_RELOC(R_ARM_THM_JUMP24,             30)     \
    14231641_ELF_DEFINE_RELOC(R_ARM_BASE_ABS,               31)     \
    1424 _ELF_DEFINE_RELOC(R_ARM_ALU_PCREL7_0,           32)     \
    1425 _ELF_DEFINE_RELOC(R_ARM_ALU_PCREL15_8,          33)     \
    1426 _ELF_DEFINE_RELOC(R_ARM_ALU_PCREL23_15,         34)     \
    1427 _ELF_DEFINE_RELOC(R_ARM_LDR_SBREL_11_0,         35)     \
    1428 _ELF_DEFINE_RELOC(R_ARM_ALU_SBREL_19_12,        36)     \
    1429 _ELF_DEFINE_RELOC(R_ARM_ALU_SBREL_27_20,        37)     \
     1642_ELF_DEFINE_RELOC(R_ARM_ALU_PCREL_7_0,          32)     \
     1643_ELF_DEFINE_RELOC(R_ARM_ALU_PCREL_15_8,         33)     \
     1644_ELF_DEFINE_RELOC(R_ARM_ALU_PCREL_23_15,        34)     \
     1645_ELF_DEFINE_RELOC(R_ARM_LDR_SBREL_11_0_NC,      35)     \
     1646_ELF_DEFINE_RELOC(R_ARM_ALU_SBREL_19_12_NC,     36)     \
     1647_ELF_DEFINE_RELOC(R_ARM_ALU_SBREL_27_20_CK,     37)     \
    14301648_ELF_DEFINE_RELOC(R_ARM_TARGET1,                38)     \
    14311649_ELF_DEFINE_RELOC(R_ARM_SBREL31,                39)     \
     
    14391657_ELF_DEFINE_RELOC(R_ARM_THM_MOVW_ABS_NC,        47)     \
    14401658_ELF_DEFINE_RELOC(R_ARM_THM_MOVT_ABS,           48)     \
    1441 _ELF_DEFINE_RELOC(R_ARM_MOVW_PREL_NC,           49)     \
     1659_ELF_DEFINE_RELOC(R_ARM_THM_MOVW_PREL_NC,       49)     \
    14421660_ELF_DEFINE_RELOC(R_ARM_THM_MOVT_PREL,          50)     \
    14431661_ELF_DEFINE_RELOC(R_ARM_THM_JUMP19,             51)     \
     
    15021720_ELF_DEFINE_RELOC(R_ARM_TLS_LE12,               110)    \
    15031721_ELF_DEFINE_RELOC(R_ARM_TLS_IE12GP,             111)    \
     1722_ELF_DEFINE_RELOC(R_ARM_PRIVATE_0,              112)    \
     1723_ELF_DEFINE_RELOC(R_ARM_PRIVATE_1,              113)    \
     1724_ELF_DEFINE_RELOC(R_ARM_PRIVATE_2,              114)    \
     1725_ELF_DEFINE_RELOC(R_ARM_PRIVATE_3,              115)    \
     1726_ELF_DEFINE_RELOC(R_ARM_PRIVATE_4,              116)    \
     1727_ELF_DEFINE_RELOC(R_ARM_PRIVATE_5,              117)    \
     1728_ELF_DEFINE_RELOC(R_ARM_PRIVATE_6,              118)    \
     1729_ELF_DEFINE_RELOC(R_ARM_PRIVATE_7,              119)    \
     1730_ELF_DEFINE_RELOC(R_ARM_PRIVATE_8,              120)    \
     1731_ELF_DEFINE_RELOC(R_ARM_PRIVATE_9,              121)    \
     1732_ELF_DEFINE_RELOC(R_ARM_PRIVATE_10,             122)    \
     1733_ELF_DEFINE_RELOC(R_ARM_PRIVATE_11,             123)    \
     1734_ELF_DEFINE_RELOC(R_ARM_PRIVATE_12,             124)    \
     1735_ELF_DEFINE_RELOC(R_ARM_PRIVATE_13,             125)    \
     1736_ELF_DEFINE_RELOC(R_ARM_PRIVATE_14,             126)    \
     1737_ELF_DEFINE_RELOC(R_ARM_PRIVATE_15,             127)    \
    15041738_ELF_DEFINE_RELOC(R_ARM_ME_TOO,                 128)    \
    15051739_ELF_DEFINE_RELOC(R_ARM_THM_TLS_DESCSEQ16,      129)    \
    1506 _ELF_DEFINE_RELOC(R_ARM_THM_TLS_DESCSEQ32,      130)
     1740_ELF_DEFINE_RELOC(R_ARM_THM_TLS_DESCSEQ32,      130)    \
     1741_ELF_DEFINE_RELOC(R_ARM_THM_GOT_BREL12,         131)    \
     1742_ELF_DEFINE_RELOC(R_ARM_IRELATIVE,              140)
    15071743
    15081744#define _ELF_DEFINE_IA64_RELOCATIONS()                  \
     
    15621798_ELF_DEFINE_RELOC(R_IA_64_LTV64MSB,             0x76)   \
    15631799_ELF_DEFINE_RELOC(R_IA_64_LTV64LSB,             0x77)   \
    1564 _ELF_DEFINE_RELOC(R_IA_64_PCREL21BIa,           0x79)   \
     1800_ELF_DEFINE_RELOC(R_IA_64_PCREL21BI,            0x79)   \
    15651801_ELF_DEFINE_RELOC(R_IA_64_PCREL22,              0x7A)   \
    15661802_ELF_DEFINE_RELOC(R_IA_64_PCREL64I,             0x7B)   \
     
    15881824_ELF_DEFINE_RELOC(R_IA_64_LTOFF_DTPREL22,       0xBA)
    15891825
    1590 #define _ELF_DEFINE_MIPS_RELOCATIONS()          \
    1591 _ELF_DEFINE_RELOC(R_MIPS_NONE,          0)      \
    1592 _ELF_DEFINE_RELOC(R_MIPS_16,            1)      \
    1593 _ELF_DEFINE_RELOC(R_MIPS_32,            2)      \
    1594 _ELF_DEFINE_RELOC(R_MIPS_REL32,         3)      \
    1595 _ELF_DEFINE_RELOC(R_MIPS_26,            4)      \
    1596 _ELF_DEFINE_RELOC(R_MIPS_HI16,          5)      \
    1597 _ELF_DEFINE_RELOC(R_MIPS_LO16,          6)      \
    1598 _ELF_DEFINE_RELOC(R_MIPS_GPREL16,       7)      \
    1599 _ELF_DEFINE_RELOC(R_MIPS_LITERAL,       8)      \
    1600 _ELF_DEFINE_RELOC(R_MIPS_GOT16,         9)      \
    1601 _ELF_DEFINE_RELOC(R_MIPS_PC16,          10)     \
    1602 _ELF_DEFINE_RELOC(R_MIPS_CALL16,        11)     \
    1603 _ELF_DEFINE_RELOC(R_MIPS_GPREL32,       12)     \
    1604 _ELF_DEFINE_RELOC(R_MIPS_64,            18)     \
    1605 _ELF_DEFINE_RELOC(R_MIPS_GOTHI16,       21)     \
    1606 _ELF_DEFINE_RELOC(R_MIPS_GOTLO16,       22)     \
    1607 _ELF_DEFINE_RELOC(R_MIPS_CALLHI16,      30)     \
    1608 _ELF_DEFINE_RELOC(R_MIPS_CALLLO16,      31)
     1826#define _ELF_DEFINE_MIPS_RELOCATIONS()                  \
     1827_ELF_DEFINE_RELOC(R_MIPS_NONE,                  0)      \
     1828_ELF_DEFINE_RELOC(R_MIPS_16,                    1)      \
     1829_ELF_DEFINE_RELOC(R_MIPS_32,                    2)      \
     1830_ELF_DEFINE_RELOC(R_MIPS_REL32,                 3)      \
     1831_ELF_DEFINE_RELOC(R_MIPS_26,                    4)      \
     1832_ELF_DEFINE_RELOC(R_MIPS_HI16,                  5)      \
     1833_ELF_DEFINE_RELOC(R_MIPS_LO16,                  6)      \
     1834_ELF_DEFINE_RELOC(R_MIPS_GPREL16,               7)      \
     1835_ELF_DEFINE_RELOC(R_MIPS_LITERAL,               8)      \
     1836_ELF_DEFINE_RELOC(R_MIPS_GOT16,                 9)      \
     1837_ELF_DEFINE_RELOC(R_MIPS_PC16,                  10)     \
     1838_ELF_DEFINE_RELOC(R_MIPS_CALL16,                11)     \
     1839_ELF_DEFINE_RELOC(R_MIPS_GPREL32,               12)     \
     1840_ELF_DEFINE_RELOC(R_MIPS_SHIFT5,                16)     \
     1841_ELF_DEFINE_RELOC(R_MIPS_SHIFT6,                17)     \
     1842_ELF_DEFINE_RELOC(R_MIPS_64,                    18)     \
     1843_ELF_DEFINE_RELOC(R_MIPS_GOT_DISP,              19)     \
     1844_ELF_DEFINE_RELOC(R_MIPS_GOT_PAGE,              20)     \
     1845_ELF_DEFINE_RELOC(R_MIPS_GOT_OFST,              21)     \
     1846_ELF_DEFINE_RELOC(R_MIPS_GOT_HI16,              22)     \
     1847_ELF_DEFINE_RELOC(R_MIPS_GOT_LO16,              23)     \
     1848_ELF_DEFINE_RELOC(R_MIPS_SUB,                   24)     \
     1849_ELF_DEFINE_RELOC(R_MIPS_CALLHI16,              30)     \
     1850_ELF_DEFINE_RELOC(R_MIPS_CALLLO16,              31)     \
     1851_ELF_DEFINE_RELOC(R_MIPS_JALR,                  37)     \
     1852_ELF_DEFINE_RELOC(R_MIPS_TLS_DTPMOD32,          38)     \
     1853_ELF_DEFINE_RELOC(R_MIPS_TLS_DTPREL32,          39)     \
     1854_ELF_DEFINE_RELOC(R_MIPS_TLS_DTPMOD64,          40)     \
     1855_ELF_DEFINE_RELOC(R_MIPS_TLS_DTPREL64,          41)     \
     1856_ELF_DEFINE_RELOC(R_MIPS_TLS_GD,                42)     \
     1857_ELF_DEFINE_RELOC(R_MIPS_TLS_LDM,               43)     \
     1858_ELF_DEFINE_RELOC(R_MIPS_TLS_DTPREL_HI16,       44)     \
     1859_ELF_DEFINE_RELOC(R_MIPS_TLS_DTPREL_LO16,       45)     \
     1860_ELF_DEFINE_RELOC(R_MIPS_TLS_GOTTPREL,          46)     \
     1861_ELF_DEFINE_RELOC(R_MIPS_TLS_TPREL32,           47)     \
     1862_ELF_DEFINE_RELOC(R_MIPS_TLS_TPREL64,           48)     \
     1863_ELF_DEFINE_RELOC(R_MIPS_TLS_TPREL_HI16,        49)     \
     1864_ELF_DEFINE_RELOC(R_MIPS_TLS_TPREL_LO16,        50)
    16091865
    16101866#define _ELF_DEFINE_PPC32_RELOCATIONS()         \
     
    16391895_ELF_DEFINE_RELOC(R_PPC_PLTREL32,       28)     \
    16401896_ELF_DEFINE_RELOC(R_PPC_PLT16_LO,       29)     \
    1641 _ELF_DEFINE_RELOC(R_PPL_PLT16_HI,       30)     \
     1897_ELF_DEFINE_RELOC(R_PPC_PLT16_HI,       30)     \
    16421898_ELF_DEFINE_RELOC(R_PPC_PLT16_HA,       31)     \
    16431899_ELF_DEFINE_RELOC(R_PPC_SDAREL16,       32)     \
     
    18022058_ELF_DEFINE_RELOC(R_PPC64_TLSLD,                108)
    18032059
     2060#define _ELF_DEFINE_RISCV_RELOCATIONS()                 \
     2061_ELF_DEFINE_RELOC(R_RISCV_NONE,                 0)      \
     2062_ELF_DEFINE_RELOC(R_RISCV_32,                   1)      \
     2063_ELF_DEFINE_RELOC(R_RISCV_64,                   2)      \
     2064_ELF_DEFINE_RELOC(R_RISCV_RELATIVE,             3)      \
     2065_ELF_DEFINE_RELOC(R_RISCV_COPY,                 4)      \
     2066_ELF_DEFINE_RELOC(R_RISCV_JUMP_SLOT,            5)      \
     2067_ELF_DEFINE_RELOC(R_RISCV_TLS_DTPMOD32,         6)      \
     2068_ELF_DEFINE_RELOC(R_RISCV_TLS_DTPMOD64,         7)      \
     2069_ELF_DEFINE_RELOC(R_RISCV_TLS_DTPREL32,         8)      \
     2070_ELF_DEFINE_RELOC(R_RISCV_TLS_DTPREL64,         9)      \
     2071_ELF_DEFINE_RELOC(R_RISCV_TLS_TPREL32,          10)     \
     2072_ELF_DEFINE_RELOC(R_RISCV_TLS_TPREL64,          11)     \
     2073_ELF_DEFINE_RELOC(R_RISCV_BRANCH,               16)     \
     2074_ELF_DEFINE_RELOC(R_RISCV_JAL,                  17)     \
     2075_ELF_DEFINE_RELOC(R_RISCV_CALL,                 18)     \
     2076_ELF_DEFINE_RELOC(R_RISCV_CALL_PLT,             19)     \
     2077_ELF_DEFINE_RELOC(R_RISCV_GOT_HI20,             20)     \
     2078_ELF_DEFINE_RELOC(R_RISCV_TLS_GOT_HI20,         21)     \
     2079_ELF_DEFINE_RELOC(R_RISCV_TLS_GD_HI20,          22)     \
     2080_ELF_DEFINE_RELOC(R_RISCV_PCREL_HI20,           23)     \
     2081_ELF_DEFINE_RELOC(R_RISCV_PCREL_LO12_I,         24)     \
     2082_ELF_DEFINE_RELOC(R_RISCV_PCREL_LO12_S,         25)     \
     2083_ELF_DEFINE_RELOC(R_RISCV_HI20,                 26)     \
     2084_ELF_DEFINE_RELOC(R_RISCV_LO12_I,               27)     \
     2085_ELF_DEFINE_RELOC(R_RISCV_LO12_S,               28)     \
     2086_ELF_DEFINE_RELOC(R_RISCV_TPREL_HI20,           29)     \
     2087_ELF_DEFINE_RELOC(R_RISCV_TPREL_LO12_I,         30)     \
     2088_ELF_DEFINE_RELOC(R_RISCV_TPREL_LO12_S,         31)     \
     2089_ELF_DEFINE_RELOC(R_RISCV_TPREL_ADD,            32)     \
     2090_ELF_DEFINE_RELOC(R_RISCV_ADD8,                 33)     \
     2091_ELF_DEFINE_RELOC(R_RISCV_ADD16,                34)     \
     2092_ELF_DEFINE_RELOC(R_RISCV_ADD32,                35)     \
     2093_ELF_DEFINE_RELOC(R_RISCV_ADD64,                36)     \
     2094_ELF_DEFINE_RELOC(R_RISCV_SUB8,                 37)     \
     2095_ELF_DEFINE_RELOC(R_RISCV_SUB16,                38)     \
     2096_ELF_DEFINE_RELOC(R_RISCV_SUB32,                39)     \
     2097_ELF_DEFINE_RELOC(R_RISCV_SUB64,                40)     \
     2098_ELF_DEFINE_RELOC(R_RISCV_GNU_VTINHERIT,        41)     \
     2099_ELF_DEFINE_RELOC(R_RISCV_GNU_VTENTRY,          42)     \
     2100_ELF_DEFINE_RELOC(R_RISCV_ALIGN,                43)     \
     2101_ELF_DEFINE_RELOC(R_RISCV_RVC_BRANCH,           44)     \
     2102_ELF_DEFINE_RELOC(R_RISCV_RVC_JUMP,             45)     \
     2103_ELF_DEFINE_RELOC(R_RISCV_RVC_LUI,              46)     \
     2104_ELF_DEFINE_RELOC(R_RISCV_GPREL_I,              47)     \
     2105_ELF_DEFINE_RELOC(R_RISCV_GPREL_S,              48)
     2106
    18042107#define _ELF_DEFINE_SPARC_RELOCATIONS()         \
    18052108_ELF_DEFINE_RELOC(R_SPARC_NONE,         0)      \
     
    18452148_ELF_DEFINE_RELOC(R_SPARC_WDISP16,      40)     \
    18462149_ELF_DEFINE_RELOC(R_SPARC_WDISP19,      41)     \
     2150_ELF_DEFINE_RELOC(R_SPARC_GLOB_JMP,     42)     \
    18472151_ELF_DEFINE_RELOC(R_SPARC_7,            43)     \
    18482152_ELF_DEFINE_RELOC(R_SPARC_5,            44)     \
     
    18582162_ELF_DEFINE_RELOC(R_SPARC_UA64,         54)     \
    18592163_ELF_DEFINE_RELOC(R_SPARC_UA16,         55)     \
     2164_ELF_DEFINE_RELOC(R_SPARC_TLS_GD_HI22,  56)     \
     2165_ELF_DEFINE_RELOC(R_SPARC_TLS_GD_LO10,  57)     \
     2166_ELF_DEFINE_RELOC(R_SPARC_TLS_GD_ADD,   58)     \
     2167_ELF_DEFINE_RELOC(R_SPARC_TLS_GD_CALL,  59)     \
     2168_ELF_DEFINE_RELOC(R_SPARC_TLS_LDM_HI22, 60)     \
     2169_ELF_DEFINE_RELOC(R_SPARC_TLS_LDM_LO10, 61)     \
     2170_ELF_DEFINE_RELOC(R_SPARC_TLS_LDM_ADD,  62)     \
     2171_ELF_DEFINE_RELOC(R_SPARC_TLS_LDM_CALL, 63)     \
     2172_ELF_DEFINE_RELOC(R_SPARC_TLS_LDO_HIX22, 64)    \
     2173_ELF_DEFINE_RELOC(R_SPARC_TLS_LDO_LOX10, 65)    \
     2174_ELF_DEFINE_RELOC(R_SPARC_TLS_LDO_ADD,  66)     \
     2175_ELF_DEFINE_RELOC(R_SPARC_TLS_IE_HI22,  67)     \
     2176_ELF_DEFINE_RELOC(R_SPARC_TLS_IE_LO10,  68)     \
     2177_ELF_DEFINE_RELOC(R_SPARC_TLS_IE_LD,    69)     \
     2178_ELF_DEFINE_RELOC(R_SPARC_TLS_IE_LDX,   70)     \
     2179_ELF_DEFINE_RELOC(R_SPARC_TLS_IE_ADD,   71)     \
     2180_ELF_DEFINE_RELOC(R_SPARC_TLS_LE_HIX22, 72)     \
     2181_ELF_DEFINE_RELOC(R_SPARC_TLS_LE_LOX10, 73)     \
     2182_ELF_DEFINE_RELOC(R_SPARC_TLS_DTPMOD32, 74)     \
     2183_ELF_DEFINE_RELOC(R_SPARC_TLS_DTPMOD64, 75)     \
     2184_ELF_DEFINE_RELOC(R_SPARC_TLS_DTPOFF32, 76)     \
     2185_ELF_DEFINE_RELOC(R_SPARC_TLS_DTPOFF64, 77)     \
     2186_ELF_DEFINE_RELOC(R_SPARC_TLS_TPOFF32,  78)     \
     2187_ELF_DEFINE_RELOC(R_SPARC_TLS_TPOFF64,  79)     \
    18602188_ELF_DEFINE_RELOC(R_SPARC_GOTDATA_HIX22, 80)    \
    18612189_ELF_DEFINE_RELOC(R_SPARC_GOTDATA_LOX10, 81)    \
     
    18932221_ELF_DEFINE_RELOC(R_X86_64_GOTOFF64,    25)     \
    18942222_ELF_DEFINE_RELOC(R_X86_64_GOTPC32,     26)     \
     2223_ELF_DEFINE_RELOC(R_X86_64_GOT64,       27)     \
     2224_ELF_DEFINE_RELOC(R_X86_64_GOTPCREL64,  28)     \
     2225_ELF_DEFINE_RELOC(R_X86_64_GOTPC64,     29)     \
     2226_ELF_DEFINE_RELOC(R_X86_64_GOTPLT64,    30)     \
     2227_ELF_DEFINE_RELOC(R_X86_64_PLTOFF64,    31)     \
    18952228_ELF_DEFINE_RELOC(R_X86_64_SIZE32,      32)     \
    18962229_ELF_DEFINE_RELOC(R_X86_64_SIZE64,      33)     \
    18972230_ELF_DEFINE_RELOC(R_X86_64_GOTPC32_TLSDESC, 34) \
    18982231_ELF_DEFINE_RELOC(R_X86_64_TLSDESC_CALL, 35)    \
    1899 _ELF_DEFINE_RELOC(R_X86_64_TLSDESC,     36)
     2232_ELF_DEFINE_RELOC(R_X86_64_TLSDESC,     36)     \
     2233_ELF_DEFINE_RELOC(R_X86_64_IRELATIVE,   37)     \
     2234_ELF_DEFINE_RELOC(R_X86_64_RELATIVE64,  38)     \
     2235_ELF_DEFINE_RELOC(R_X86_64_GOTPCRELX,   41)     \
     2236_ELF_DEFINE_RELOC(R_X86_64_REX_GOTPCRELX, 42)
    19002237
    19012238#define _ELF_DEFINE_RELOCATIONS()               \
    19022239_ELF_DEFINE_386_RELOCATIONS()                   \
     2240_ELF_DEFINE_AARCH64_RELOCATIONS()               \
    19032241_ELF_DEFINE_AMD64_RELOCATIONS()                 \
     2242_ELF_DEFINE_ARM_RELOCATIONS()                   \
    19042243_ELF_DEFINE_IA64_RELOCATIONS()                  \
    19052244_ELF_DEFINE_MIPS_RELOCATIONS()                  \
    19062245_ELF_DEFINE_PPC32_RELOCATIONS()                 \
    19072246_ELF_DEFINE_PPC64_RELOCATIONS()                 \
     2247_ELF_DEFINE_RISCV_RELOCATIONS()                 \
    19082248_ELF_DEFINE_SPARC_RELOCATIONS()                 \
    19092249_ELF_DEFINE_X86_64_RELOCATIONS()
     
    20592399/* 64-bit entry. */
    20602400typedef struct {
    2061         Elf64_Word l_name;
    2062         Elf64_Word l_time_stamp;
    2063         Elf64_Word l_checksum;
    2064         Elf64_Word l_version;
    2065         Elf64_Word l_flags;
     2401        Elf64_Word l_name;           /* The name of a shared object. */
     2402        Elf64_Word l_time_stamp;     /* 32-bit timestamp. */
     2403        Elf64_Word l_checksum;       /* Checksum of visible symbols, sizes. */
     2404        Elf64_Word l_version;        /* Interface version string index. */
     2405        Elf64_Word l_flags;          /* Flags (LL_*). */
    20662406} Elf64_Lib;
    20672407
     
    21652505        "GP group to use for text/data sections")                       \
    21662506_ELF_DEFINE_ODK(ODK_IDENT,      10,     "ID information")               \
    2167 _ELF_DEFINE_ODK(ODK_PAGESIZE,   11,     "page size infomation")
     2507_ELF_DEFINE_ODK(ODK_PAGESIZE,   11,     "page size information")
    21682508
    21692509#undef  _ELF_DEFINE_ODK
     
    23112651typedef struct {
    23122652        Elf64_Word      p_type;      /* Type of segment. */
    2313         Elf64_Word      p_flags;     /* File offset to segment. */
    2314         Elf64_Off       p_offset;    /* Virtual address in memory. */
    2315         Elf64_Addr      p_vaddr;     /* Physical address (if relevant). */
    2316         Elf64_Addr      p_paddr;     /* Size of segment in file. */
    2317         Elf64_Xword     p_filesz;    /* Size of segment in memory. */
    2318         Elf64_Xword     p_memsz;     /* Segment flags. */
     2653        Elf64_Word      p_flags;     /* Segment flags. */
     2654        Elf64_Off       p_offset;    /* File offset to segment. */
     2655        Elf64_Addr      p_vaddr;     /* Virtual address in memory. */
     2656        Elf64_Addr      p_paddr;     /* Physical address (if relevant). */
     2657        Elf64_Xword     p_filesz;    /* Size of segment in file. */
     2658        Elf64_Xword     p_memsz;     /* Size of segment in memory. */
    23192659        Elf64_Xword     p_align;     /* Alignment constraints. */
    23202660} Elf64_Phdr;
     
    24002740typedef struct {
    24012741        Elf64_Word      st_name;     /* index of symbol's name */
    2402         unsigned char   st_info;     /* value for the symbol */
    2403         unsigned char   st_other;    /* size of associated data */
    2404         Elf64_Half      st_shndx;    /* type and binding attributes */
    2405         Elf64_Addr      st_value;    /* visibility */
    2406         Elf64_Xword     st_size;     /* index of related section */
     2742        unsigned char   st_info;     /* type and binding attributes */
     2743        unsigned char   st_other;    /* visibility */
     2744        Elf64_Half      st_shndx;    /* index of related section */
     2745        Elf64_Addr      st_value;    /* value for the symbol */
     2746        Elf64_Xword     st_size;     /* size of associated data */
    24072747} Elf64_Sym;
    24082748
  • rtemstoolkit/elftoolchain/common/native-elf-format

    r6f48c91 r771e7f1  
    11#!/bin/sh
    22#
    3 # $Id: native-elf-format 2064 2011-10-26 15:12:32Z jkoshy $
     3# $Id: native-elf-format 3293 2016-01-07 19:26:27Z emaste $
    44#
    55# Find the native ELF format for a host platform by compiling a
     
    2020
    2121cc -c ${tmp_c} -o ${tmp_o}
    22 LANG="C" readelf -h ${tmp_o} | awk '
     22LC_ALL=C readelf -h ${tmp_o} | awk '
    2323$1 ~ "Class:" {
    2424        sub("ELF","",$2); elfclass = $2;
     
    3434        if (match($0, "Intel.*386")) {
    3535            elfarch = "EM_386";
    36         } else if (match($0, ".*X86-64")) {
     36        } else if (match($0, "MIPS")) {
     37            elfarch = "EM_MIPS";
     38        } else if (match($0, ".*[xX]86-64")) {
    3739            elfarch = "EM_X86_64";
    3840        } else {
     
    4547    printf("#define     ELFTC_BYTEORDER ELFDATA2%s\n", elfdata);
    4648}'
     49
  • rtemstoolkit/elftoolchain/common/os.Linux.mk

    r6f48c91 r771e7f1  
    22# Build recipes for Linux based operating systems.
    33#
    4 # $Id: os.Linux.mk 2064 2011-10-26 15:12:32Z jkoshy $
     4# $Id: os.Linux.mk 3594 2018-04-11 18:26:50Z jkoshy $
    55
    66_NATIVE_ELF_FORMAT = native-elf-format
    77
    8 .BEGIN: ${_NATIVE_ELF_FORMAT}.h
     8.if !make(obj)
     9.BEGIN: ${.OBJDIR}/${_NATIVE_ELF_FORMAT}.h
    910
    10 ${_NATIVE_ELF_FORMAT}.h:
     11${.OBJDIR}/${_NATIVE_ELF_FORMAT}.h:
    1112        ${.CURDIR}/${_NATIVE_ELF_FORMAT} > ${.TARGET} || rm ${.TARGET}
     13.endif
    1214
    13 CLEANFILES += ${_NATIVE_ELF_FORMAT}.h
     15CLEANFILES += ${.OBJDIR}/${_NATIVE_ELF_FORMAT}.h
  • rtemstoolkit/elftoolchain/common/uthash.h

    r6f48c91 r771e7f1  
    11/*
    2 Copyright (c) 2003-2011, Troy D. Hanson     http://uthash.sourceforge.net
     2Copyright (c) 2003-2013, Troy D. Hanson     http://uthash.sourceforge.net
    33All rights reserved.
    44
     
    2222*/
    2323
    24 /* $Id: uthash.h 2064 2011-10-26 15:12:32Z jkoshy $ */
     24/* $Id: uthash.h 2682 2012-11-23 22:04:22Z kaiwang27 $ */
    2525
    2626#ifndef UTHASH_H
     
    6767#endif
    6868
    69 #define UTHASH_VERSION 1.9.4
    70 
     69#define UTHASH_VERSION 1.9.7
     70
     71#ifndef uthash_fatal
    7172#define uthash_fatal(msg) exit(-1)        /* fatal error (out of memory,etc) */
     73#endif
     74#ifndef uthash_malloc
    7275#define uthash_malloc(sz) malloc(sz)      /* malloc fcn                      */
     76#endif
     77#ifndef uthash_free
    7378#define uthash_free(ptr,sz) free(ptr)     /* free fcn                        */
    74 
     79#endif
     80
     81#ifndef uthash_noexpand_fyi
    7582#define uthash_noexpand_fyi(tbl)          /* can be defined to log noexpand  */
     83#endif
     84#ifndef uthash_expand_fyi
    7685#define uthash_expand_fyi(tbl)            /* can be defined to log expands   */
     86#endif
    7787
    7888/* initial number of buckets */
     
    107117  memset((tbl)->bloom_bv, 0, HASH_BLOOM_BYTELEN);                                \
    108118  (tbl)->bloom_sig = HASH_BLOOM_SIGNATURE;                                       \
    109 } while (0);
     119} while (0) 
    110120
    111121#define HASH_BLOOM_FREE(tbl)                                                     \
    112122do {                                                                             \
    113123  uthash_free((tbl)->bloom_bv, HASH_BLOOM_BYTELEN);                              \
    114 } while (0);
     124} while (0) 
    115125
    116126#define HASH_BLOOM_BITSET(bv,idx) (bv[(idx)/8] |= (1U << ((idx)%8)))
     
    150160
    151161#define HASH_ADD(hh,head,fieldname,keylen_in,add)                                \
    152         HASH_ADD_KEYPTR(hh,head,&add->fieldname,keylen_in,add)
     162        HASH_ADD_KEYPTR(hh,head,&((add)->fieldname),keylen_in,add)
    153163 
    154164#define HASH_ADD_KEYPTR(hh,head,keyptr,keylen_in,add)                            \
     
    157167 (add)->hh.next = NULL;                                                          \
    158168 (add)->hh.key = (char*)keyptr;                                                  \
    159  (add)->hh.keylen = keylen_in;                                                   \
     169 (add)->hh.keylen = (unsigned)keylen_in;                                                   \
    160170 if (!(head)) {                                                                  \
    161171    head = (add);                                                                \
     
    208218        if ((delptr) == ELMT_FROM_HH((head)->hh.tbl,(head)->hh.tbl->tail)) {     \
    209219            (head)->hh.tbl->tail =                                               \
    210                 (UT_hash_handle*)((char*)((delptr)->hh.prev) +                   \
     220                (UT_hash_handle*)((ptrdiff_t)((delptr)->hh.prev) +               \
    211221                (head)->hh.tbl->hho);                                            \
    212222        }                                                                        \
    213223        if ((delptr)->hh.prev) {                                                 \
    214             ((UT_hash_handle*)((char*)((delptr)->hh.prev) +                      \
     224            ((UT_hash_handle*)((ptrdiff_t)((delptr)->hh.prev) +                  \
    215225                    (head)->hh.tbl->hho))->next = (delptr)->hh.next;             \
    216226        } else {                                                                 \
     
    218228        }                                                                        \
    219229        if (_hd_hh_del->next) {                                                  \
    220             ((UT_hash_handle*)((char*)_hd_hh_del->next +                         \
     230            ((UT_hash_handle*)((ptrdiff_t)_hd_hh_del->next +                     \
    221231                    (head)->hh.tbl->hho))->prev =                                \
    222232                    _hd_hh_del->prev;                                            \
     
    358368      hashv = (hashv * 16777619) ^ _hf_key[_fn_i];                               \
    359369  bkt = hashv & (num_bkts-1);                                                    \
    360 } while(0);
     370} while(0) 
    361371 
    362372#define HASH_OAT(key,keylen,num_bkts,hashv,bkt)                                  \
     
    395405  hashv = 0xfeedbeef;                                                            \
    396406  _hj_i = _hj_j = 0x9e3779b9;                                                    \
    397   _hj_k = keylen;                                                                \
     407  _hj_k = (unsigned)keylen;                                                                \
    398408  while (_hj_k >= 12) {                                                          \
    399409    _hj_i +=    (_hj_key[0] + ( (unsigned)_hj_key[1] << 8 )                      \
     
    483493    hashv += hashv >> 6;                                                         \
    484494    bkt = hashv & (num_bkts-1);                                                  \
    485 } while(0);
     495} while(0) 
    486496
    487497#ifdef HASH_USING_NO_STRICT_ALIASING
     
    495505 *   cc -## a.c (where a.c is a simple test file)   (Sun Studio)
    496506 */
    497 #if (defined(__i386__) || defined(__x86_64__))
     507#if (defined(__i386__) || defined(__x86_64__)  || defined(_M_IX86))
    498508#define MUR_GETBLOCK(p,i) p[i]
    499509#else /* non intel */
     
    534544  uint32_t _mur_c1 = 0xcc9e2d51;                                       \
    535545  uint32_t _mur_c2 = 0x1b873593;                                       \
     546  uint32_t _mur_k1 = 0;                                                \
     547  const uint8_t *_mur_tail;                                            \
    536548  const uint32_t *_mur_blocks = (const uint32_t*)(_mur_data+_mur_nblocks*4); \
    537549  int _mur_i;                                                          \
    538550  for(_mur_i = -_mur_nblocks; _mur_i; _mur_i++) {                      \
    539     uint32_t _mur_k1 = MUR_GETBLOCK(_mur_blocks,_mur_i);               \
     551    _mur_k1 = MUR_GETBLOCK(_mur_blocks,_mur_i);                        \
    540552    _mur_k1 *= _mur_c1;                                                \
    541553    _mur_k1 = MUR_ROTL32(_mur_k1,15);                                  \
     
    546558    _mur_h1 = _mur_h1*5+0xe6546b64;                                    \
    547559  }                                                                    \
    548   const uint8_t *_mur_tail = (const uint8_t*)(_mur_data + _mur_nblocks*4); \
    549   uint32_t _mur_k1=0;                                                  \
     560  _mur_tail = (const uint8_t*)(_mur_data + _mur_nblocks*4);            \
     561  _mur_k1=0;                                                           \
    550562  switch((keylen) & 3) {                                               \
    551563    case 3: _mur_k1 ^= _mur_tail[2] << 16;                             \
     
    573585 else out=NULL;                                                                  \
    574586 while (out) {                                                                   \
    575     if (out->hh.keylen == keylen_in) {                                           \
    576         if ((HASH_KEYCMP(out->hh.key,keyptr,keylen_in)) == 0) break;             \
     587    if ((out)->hh.keylen == keylen_in) {                                           \
     588        if ((HASH_KEYCMP((out)->hh.key,keyptr,keylen_in)) == 0) break;             \
    577589    }                                                                            \
    578     if (out->hh.hh_next) DECLTYPE_ASSIGN(out,ELMT_FROM_HH(tbl,out->hh.hh_next)); \
     590    if ((out)->hh.hh_next) DECLTYPE_ASSIGN(out,ELMT_FROM_HH(tbl,(out)->hh.hh_next)); \
    579591    else out = NULL;                                                             \
    580592 }                                                                               \
     
    817829    uthash_free((head)->hh.tbl->buckets,                                         \
    818830                (head)->hh.tbl->num_buckets*sizeof(struct UT_hash_bucket));      \
     831    HASH_BLOOM_FREE((head)->hh.tbl);                                             \
    819832    uthash_free((head)->hh.tbl, sizeof(UT_hash_table));                          \
    820833    (head)=NULL;                                                                 \
  • rtemstoolkit/elftoolchain/libelf/Makefile

    r6f48c91 r771e7f1  
    1 # $Id: Makefile 1345 2011-01-01 11:17:52Z jkoshy $
     1# $Id: Makefile 3594 2018-04-11 18:26:50Z jkoshy $
    22
    3 TOP=    ${.CURDIR}/..
     3TOP=    ..
    44
    55LIB=    elf
     
    2020        elf_memory.c                                            \
    2121        elf_next.c                                              \
     22        elf_open.c                                              \
    2223        elf_rand.c                                              \
    2324        elf_rawfile.c                                           \
     
    5253        libelf_ehdr.c                                           \
    5354        libelf_extended.c                                       \
     55        libelf_memory.c                                         \
     56        libelf_open.c                                           \
    5457        libelf_phdr.c                                           \
    5558        libelf_shdr.c                                           \
    5659        libelf_xlate.c                                          \
    5760        ${GENSRCS}
    58 INCS=   libelf.h gelf.h
     61
     62INCS=           libelf.h gelf.h
     63INCSDIR=        /usr/include
    5964
    6065GENSRCS=        libelf_fsize.c libelf_msize.c libelf_convert.c
     
    8893        elf_memory.3                                            \
    8994        elf_next.3                                              \
     95        elf_open.3                                              \
    9096        elf_rawfile.3                                           \
    9197        elf_rand.3                                              \
     
    127133        elf_getscn.3 elf_nextscn.3              \
    128134        elf_getshstrndx.3 elf_setshstrndx.3     \
     135        elf_open.3 elf_openmemory.3             \
    129136        gelf_getcap.3 gelf_update_cap.3         \
    130137        gelf_getdyn.3 gelf_update_dyn.3         \
  • rtemstoolkit/elftoolchain/libelf/Version.map

    r6f48c91 r771e7f1  
    1 /*
    2  * $Id: Version.map 2033 2011-10-23 09:21:13Z jkoshy $
    3  *
    4  * $FreeBSD: src/lib/libelf/Version.map,v 1.3 2007/04/29 14:05:22 deischen Exp $
    5  */
    6 FBSD_1.0 {
     1/* $Id: Version.map 2574 2012-09-11 15:11:59Z jkoshy $ */
     2
     3R1.0 {
    74global:
    85        elf32_checksum;
     
    4239        elf_getdata;
    4340        elf_getident;
    44         elf_getscn;
    4541        elf_getphdrnum;
    4642        elf_getphnum;
     43        elf_getscn;
    4744        elf_getshdrnum;
     45        elf_getshdrstrndx;
    4846        elf_getshnum;
    49         elf_getshdrstrndx;
    5047        elf_getshstrndx;
    5148        elf_hash;
     
    5754        elf_next;
    5855        elf_nextscn;
     56        elf_open;
     57        elf_openmemory;
    5958        elf_rand;
    6059        elf_rawdata;
  • rtemstoolkit/elftoolchain/libelf/_libelf.h

    r6f48c91 r771e7f1  
    2424 * SUCH DAMAGE.
    2525 *
    26  * $Id: _libelf.h 1921 2011-09-23 08:04:02Z jkoshy $
     26 * $Id: _libelf.h 3174 2015-03-27 17:13:41Z emaste $
    2727 */
    2828
     
    4949        int             libelf_fillchar;
    5050        unsigned int    libelf_version;
    51         char            libelf_msg[LIBELF_MSG_SIZE];
     51        unsigned char   libelf_msg[LIBELF_MSG_SIZE];
    5252};
    5353
     
    5959#define LIBELF_OS_ERROR_SHIFT                   8
    6060
     61#define LIBELF_ERROR(E, O) (((E) & LIBELF_ELF_ERROR_MASK) |     \
     62        ((O) << LIBELF_OS_ERROR_SHIFT))
     63
    6164#define LIBELF_SET_ERROR(E, O) do {                                     \
    62         LIBELF_PRIVATE(error) = ((ELF_E_##E & LIBELF_ELF_ERROR_MASK)|   \
    63             ((O) << LIBELF_OS_ERROR_SHIFT));                            \
     65                LIBELF_PRIVATE(error) = LIBELF_ERROR(ELF_E_##E, (O));   \
    6466        } while (0)
    6567
     
    7072 * `e_flags' field.
    7173 */
    72 #define LIBELF_F_API_MASK       0x00FFFF  /* Flags defined by the API. */
    73 #define LIBELF_F_AR_HEADER      0x010000  /* translated header available */
    74 #define LIBELF_F_AR_VARIANT_SVR4 0x020000 /* BSD style ar(1) archive */
    75 #define LIBELF_F_DATA_MALLOCED  0x040000 /* whether data was malloc'ed */
    76 #define LIBELF_F_RAWFILE_MALLOC 0x080000 /* whether e_rawfile was malloc'ed */
    77 #define LIBELF_F_RAWFILE_MMAP   0x100000 /* whether e_rawfile was mmap'ed */
    78 #define LIBELF_F_SHDRS_LOADED   0x200000 /* whether all shdrs were read in */
    79 #define LIBELF_F_SPECIAL_FILE   0x400000 /* non-regular file */
     74#define LIBELF_F_API_MASK       0x00FFFFU  /* Flags defined by the API. */
     75#define LIBELF_F_AR_HEADER      0x010000U  /* translated header available */
     76#define LIBELF_F_AR_VARIANT_SVR4 0x020000U /* BSD style ar(1) archive */
     77#define LIBELF_F_DATA_MALLOCED  0x040000U /* whether data was malloc'ed */
     78#define LIBELF_F_RAWFILE_MALLOC 0x080000U /* whether e_rawfile was malloc'ed */
     79#define LIBELF_F_RAWFILE_MMAP   0x100000U /* whether e_rawfile was mmap'ed */
     80#define LIBELF_F_SHDRS_LOADED   0x200000U /* whether all shdrs were read in */
     81#define LIBELF_F_SPECIAL_FILE   0x400000U /* non-regular file */
    8082
    8183struct _Elf {
     
    8890        Elf_Kind        e_kind;         /* ELF_K_* */
    8991        Elf             *e_parent;      /* non-NULL for archive members */
    90         char            *e_rawfile;     /* uninterpreted bytes */
     92        unsigned char   *e_rawfile;     /* uninterpreted bytes */
    9193        size_t          e_rawsize;      /* size of uninterpreted bytes */
    9294        unsigned int    e_version;      /* file version */
     
    98100        union {
    99101                Elf_Arhdr       *e_arhdr;       /* translated header */
    100                 char            *e_rawhdr;      /* untranslated header */
     102                unsigned char   *e_rawhdr;      /* untranslated header */
    101103        } e_hdr;
    102104
     
    105107                        off_t   e_next; /* set by elf_rand()/elf_next() */
    106108                        int     e_nchildren;
    107                         char    *e_rawstrtab;   /* file name strings */
     109                        unsigned char *e_rawstrtab; /* file name strings */
    108110                        size_t  e_rawstrtabsz;
    109                         char    *e_rawsymtab;   /* symbol table */
     111                        unsigned char *e_rawsymtab;     /* symbol table */
    110112                        size_t  e_rawsymtabsz;
    111113                        Elf_Arsym *e_symtab;
     
    129131};
    130132
     133/*
     134 * The internal descriptor wrapping the "Elf_Data" type.
     135 */
     136struct _Libelf_Data {
     137        Elf_Data        d_data;         /* The exported descriptor. */
     138        Elf_Scn         *d_scn;         /* The containing section */
     139        unsigned int    d_flags;
     140        STAILQ_ENTRY(_Libelf_Data) d_next;
     141};
     142
    131143struct _Elf_Scn {
    132144        union {
     
    134146                Elf64_Shdr      s_shdr64;
    135147        } s_shdr;
    136         STAILQ_HEAD(, _Elf_Data) s_data;        /* list of Elf_Data descriptors */
    137         STAILQ_HEAD(, _Elf_Data) s_rawdata;     /* raw data for this section */
     148        STAILQ_HEAD(, _Libelf_Data) s_data;     /* translated data */
     149        STAILQ_HEAD(, _Libelf_Data) s_rawdata;  /* raw data */
    138150        STAILQ_ENTRY(_Elf_Scn) s_next;
    139151        struct _Elf     *s_elf;         /* parent ELF descriptor */
     
    151163};
    152164
    153 #define LIBELF_COPY_U32(DST,SRC,NAME)   do {            \
    154                 if ((SRC)->NAME > UINT_MAX) {           \
    155                         LIBELF_SET_ERROR(RANGE, 0);     \
    156                         return (0);                     \
    157                 }                                       \
    158                 (DST)->NAME = (SRC)->NAME;              \
     165
     166/*
     167 * The LIBELF_COPY macros are used to copy fields from a GElf_*
     168 * structure to their 32-bit counterparts, while checking for out of
     169 * range values.
     170 *
     171 * - LIBELF_COPY_U32 :: copy an unsigned 32 bit field.
     172 * - LIBELF_COPY_S32 :: copy a signed 32 bit field.
     173 */
     174
     175#define LIBELF_COPY_U32(DST, SRC, NAME) do {                    \
     176                if ((SRC)->NAME > UINT32_MAX) {                 \
     177                        LIBELF_SET_ERROR(RANGE, 0);             \
     178                        return (0);                             \
     179                }                                               \
     180                (DST)->NAME = (SRC)->NAME & 0xFFFFFFFFU;        \
    159181        } while (0)
    160182
    161 #define LIBELF_COPY_S32(DST,SRC,NAME)   do {            \
    162                 if ((SRC)->NAME > INT_MAX ||            \
    163                     (SRC)->NAME < INT_MIN) {            \
    164                         LIBELF_SET_ERROR(RANGE, 0);     \
    165                         return (0);                     \
    166                 }                                       \
    167                 (DST)->NAME = (SRC)->NAME;              \
     183#define LIBELF_COPY_S32(DST, SRC, NAME) do {                    \
     184                if ((SRC)->NAME > INT32_MAX ||                  \
     185                    (SRC)->NAME < INT32_MIN) {                  \
     186                        LIBELF_SET_ERROR(RANGE, 0);             \
     187                        return (0);                             \
     188                }                                               \
     189                (DST)->NAME = (int32_t) (SRC)->NAME;            \
    168190        } while (0)
    169191
     
    173195 */
    174196
    175 __BEGIN_DECLS
    176 Elf_Data *_libelf_allocate_data(Elf_Scn *_s);
     197#ifdef __cplusplus
     198extern "C" {
     199#endif
     200struct _Libelf_Data *_libelf_allocate_data(Elf_Scn *_s);
    177201Elf     *_libelf_allocate_elf(void);
    178202Elf_Scn *_libelf_allocate_scn(Elf *_e, size_t _ndx);
    179203Elf_Arhdr *_libelf_ar_gethdr(Elf *_e);
    180 Elf     *_libelf_ar_open(Elf *_e);
     204Elf     *_libelf_ar_open(Elf *_e, int _reporterror);
    181205Elf     *_libelf_ar_open_member(int _fd, Elf_Cmd _c, Elf *_ar);
    182 int     _libelf_ar_get_member(char *_s, size_t _sz, int _base, size_t *_ret);
    183206Elf_Arsym *_libelf_ar_process_bsd_symtab(Elf *_ar, size_t *_dst);
    184207Elf_Arsym *_libelf_ar_process_svr4_symtab(Elf *_ar, size_t *_dst);
    185 unsigned long _libelf_checksum(Elf *_e, int _elfclass);
     208long    _libelf_checksum(Elf *_e, int _elfclass);
    186209void    *_libelf_ehdr(Elf *_e, int _elfclass, int _allocate);
    187 int     _libelf_falign(Elf_Type _t, int _elfclass);
     210unsigned int _libelf_falign(Elf_Type _t, int _elfclass);
    188211size_t  _libelf_fsize(Elf_Type _t, int _elfclass, unsigned int _version,
    189212    size_t count);
    190213int     (*_libelf_get_translator(Elf_Type _t, int _direction, int _elfclass))
    191             (char *_dst, size_t dsz, char *_src, size_t _cnt, int _byteswap);
     214            (unsigned char *_dst, size_t dsz, unsigned char *_src,
     215             size_t _cnt, int _byteswap);
    192216void    *_libelf_getphdr(Elf *_e, int _elfclass);
    193217void    *_libelf_getshdr(Elf_Scn *_scn, int _elfclass);
    194218void    _libelf_init_elf(Elf *_e, Elf_Kind _kind);
    195219int     _libelf_load_section_headers(Elf *e, void *ehdr);
    196 int     _libelf_malign(Elf_Type _t, int _elfclass);
     220unsigned int _libelf_malign(Elf_Type _t, int _elfclass);
     221Elf     *_libelf_memory(unsigned char *_image, size_t _sz, int _reporterror);
    197222size_t  _libelf_msize(Elf_Type _t, int _elfclass, unsigned int _version);
    198223void    *_libelf_newphdr(Elf *_e, int _elfclass, size_t _count);
    199 Elf_Data *_libelf_release_data(Elf_Data *_d);
     224Elf     *_libelf_open_object(int _fd, Elf_Cmd _c, int _reporterror);
     225struct _Libelf_Data *_libelf_release_data(struct _Libelf_Data *_d);
    200226Elf     *_libelf_release_elf(Elf *_e);
    201227Elf_Scn *_libelf_release_scn(Elf_Scn *_s);
     
    207233    unsigned int _encoding, int _elfclass, int _direction);
    208234int     _libelf_xlate_shtype(uint32_t _sht);
    209 __END_DECLS
     235#ifdef __cplusplus
     236}
     237#endif
    210238
    211239#endif  /* __LIBELF_H_ */
  • rtemstoolkit/elftoolchain/libelf/_libelf_ar.h

    r6f48c91 r771e7f1  
    2424 * SUCH DAMAGE.
    2525 *
    26  * $Id: _libelf_ar.h 2032 2011-10-23 09:07:00Z jkoshy $
     26 * $Id: _libelf_ar.h 3013 2014-03-23 06:16:59Z jkoshy $
    2727 */
    2828
     
    4343
    4444#define IS_EXTENDED_BSD_NAME(NAME)                              \
    45         (strncmp((NAME), LIBELF_AR_BSD_EXTENDED_NAME_PREFIX,    \
     45        (strncmp((const char *) (NAME),                         \
     46         LIBELF_AR_BSD_EXTENDED_NAME_PREFIX,                    \
    4647         LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE) == 0)
    4748
    4849
    49 char    *_libelf_ar_get_string(const char *_buf, size_t _sz, int _rawname,
    50     int _svr4names);
     50unsigned char *_libelf_ar_get_string(const char *_buf, size_t _sz,
     51    unsigned int _rawname, int _svr4names);
    5152char    *_libelf_ar_get_raw_name(const struct ar_hdr *_arh);
    5253char    *_libelf_ar_get_translated_name(const struct ar_hdr *_arh, Elf *_ar);
    53 int     _libelf_ar_get_number(const char *_buf, size_t _sz, int _base,
    54     size_t *_ret);
     54int     _libelf_ar_get_number(const char *_buf, size_t _sz,
     55    unsigned int _base, size_t *_ret);
    5556
    5657#endif  /* __LIBELF_AR_H_ */
  • rtemstoolkit/elftoolchain/libelf/_libelf_config.h

    r6f48c91 r771e7f1  
    2424 * SUCH DAMAGE.
    2525 *
    26  * $Id: _libelf_config.h 2032 2011-10-23 09:07:00Z jkoshy $
    27  */
     26 * $Id: _libelf_config.h 3566 2017-08-31 02:28:40Z emaste $
     27 */
     28
     29#if defined(__APPLE__) || defined(__DragonFly__)
     30
     31#if     defined(__amd64__)
     32#define LIBELF_ARCH             EM_X86_64
     33#define LIBELF_BYTEORDER        ELFDATA2LSB
     34#define LIBELF_CLASS            ELFCLASS64
     35#elif   defined(__i386__)
     36#define LIBELF_ARCH             EM_386
     37#define LIBELF_BYTEORDER        ELFDATA2LSB
     38#define LIBELF_CLASS            ELFCLASS32
     39#endif
     40
     41#endif  /* __DragonFly__ */
    2842
    2943#ifdef __FreeBSD__
    30 
    31 #define LIBELF_VCSID(ID)        __FBSDID(ID)
    3244
    3345/*
     
    4254#define LIBELF_CLASS            ELFCLASS64
    4355
     56#elif   defined(__aarch64__)
     57
     58#define LIBELF_ARCH             EM_AARCH64
     59#define LIBELF_BYTEORDER        ELFDATA2LSB
     60#define LIBELF_CLASS            ELFCLASS64
     61
    4462#elif   defined(__arm__)
    4563
     
    8098#define LIBELF_CLASS            ELFCLASS32
    8199
     100#elif   defined(__riscv) && (__riscv_xlen == 64)
     101
     102#define LIBELF_ARCH             EM_RISCV
     103#define LIBELF_BYTEORDER        ELFDATA2LSB
     104#define LIBELF_CLASS            ELFCLASS64
     105
    82106#elif   defined(__sparc__)
    83107
     
    91115#endif  /* __FreeBSD__ */
    92116
     117/*
     118 * Definitions for Minix3.
     119 */
     120#ifdef __minix
     121
     122#define LIBELF_ARCH             EM_386
     123#define LIBELF_BYTEORDER        ELFDATA2LSB
     124#define LIBELF_CLASS            ELFCLASS32
     125
     126#endif  /* __minix */
    93127
    94128#ifdef __NetBSD__
    95129
    96130#include <machine/elf_machdep.h>
    97 
    98 #define LIBELF_VCSID(ID)        __RCSID(ID)
    99131
    100132#if     !defined(ARCH_ELFSIZE)
     
    116148#endif  /* __NetBSD__ */
    117149
    118 #ifdef __APPLE__
    119 
    120 #define LIBELF_VCSID(ID)
    121 
    122 #if     defined(__amd64__)
    123 
    124 #define LIBELF_ARCH             EM_X86_64
    125 #define LIBELF_BYTEORDER        ELFDATA2LSB
    126 #define LIBELF_CLASS            ELFCLASS64
    127 
    128 #elif   defined(__i386__)
    129 
    130 #define LIBELF_ARCH             EM_386
    131 #define LIBELF_BYTEORDER        ELFDATA2LSB
    132 #define LIBELF_CLASS            ELFCLASS32
    133 
    134 #else
    135 #error  Unknown Apple architecture.
    136 #endif
    137 
    138 #define roundup2        roundup
    139 
    140 #endif  /* __APPLE__ */
     150#if defined(__OpenBSD__)
     151
     152#include <machine/exec.h>
     153
     154#define LIBELF_ARCH             ELF_TARG_MACH
     155#define LIBELF_BYTEORDER        ELF_TARG_DATA
     156#define LIBELF_CLASS            ELF_TARG_CLASS
     157
     158#endif
    141159
    142160/*
     
    161179#endif  /* defined(__linux__) */
    162180
    163 #define LIBELF_VCSID(ID)
    164 
    165181#if     LIBELF_CLASS == ELFCLASS32
    166182#define Elf_Note                Elf32_Nhdr
     
    171187#endif
    172188
    173 #define roundup2        roundup
    174 
    175189#endif /* defined(__linux__) || defined(__GNU__) || defined(__GLIBC__) */
    176190
    177191#if defined(__WIN32__) || defined(__CYGWIN__)
    178192
    179 #define LIBELF_VCSID(ID)
    180 
    181 #if     defined(__amd64__)
    182 
    183 #define LIBELF_ARCH             EM_X86_64
    184 #define LIBELF_BYTEORDER        ELFDATA2LSB
    185 #define LIBELF_CLASS            ELFCLASS64
    186 
    187 #elif   defined(__i386__)
    188 
    189 #define LIBELF_ARCH             EM_386
    190 #define LIBELF_BYTEORDER        ELFDATA2LSB
    191 #define LIBELF_CLASS            ELFCLASS32
    192 
    193 #else
    194 #error  Unknown Apple architecture.
    195 #endif
    196 
    197 #endif  /* __APPLE__ */
     193#define LIBELF_VCSID(ID)
     194
     195#if     defined(__amd64__)
     196
     197#define LIBELF_ARCH             EM_X86_64
     198#define LIBELF_BYTEORDER        ELFDATA2LSB
     199#define LIBELF_CLASS            ELFCLASS64
     200
     201#elif   defined(__i386__)
     202
     203#define LIBELF_ARCH             EM_386
     204#define LIBELF_BYTEORDER        ELFDATA2LSB
     205#define LIBELF_CLASS            ELFCLASS32
     206
     207#else
     208#error  Unknown Windows architecture.
     209#endif
     210
     211#endif  /* __WIN32__ || __CYGWIN__ */
  • rtemstoolkit/elftoolchain/libelf/elf.3

    r6f48c91 r771e7f1  
    2222.\" such damage.
    2323.\"
    24 .\" $Id: elf.3 1730 2011-08-14 10:03:34Z jkoshy $
     24.\" $Id: elf.3 3195 2015-05-12 17:22:19Z emaste $
    2525.\"
    26 .Dd August 14, 2011
     26.Dd July 28, 2014
    2727.Os
    2828.Dt ELF 3
     
    252252A pointer to data in memory.
    253253.It Vt "uint64_t d_off"
    254 The offset with the containing section where this descriptors data
     254The offset within the containing section where this descriptor's data
    255255would be placed.
    256256This field will be computed by the library unless the application
     
    368368.It Dv SHT_DYNSYM Ta Dv ELF_T_SYM Ta Symbols for dynamic linking.
    369369.It Dv SHT_FINI_ARRAY Ta Dv ELF_T_ADDR Ta Termination function pointers.
     370.It Dv SHT_GNU_HASH Ta Dv ELF_T_GNUHASH Ta GNU hash sections.
     371.It Dv SHT_GNU_LIBLIST Ta Dv ELF_T_WORD Ta List of libraries to be pre-linked.
     372.It Dv SHT_GNU_verdef Ta Dv ELF_T_VDEF Ta Symbol version definitions.
     373.It Dv SHT_GNU_verneed Ta Dv ELF_T_VNEED Ta Symbol versioning requirements.
     374.It Dv SHT_GNU_versym Ta Dv ELF_T_HALF Ta Version symbols.
    370375.It Dv SHT_GROUP Ta Dv ELF_T_WORD Ta Section group marker.
    371376.It Dv SHT_HASH Ta Dv ELF_T_HASH Ta Symbol hashes.
     
    384389.It Dv SHT_SYMTAB Ta Dv ELF_T_SYM Ta Symbol tables.
    385390.It Dv SHT_SYMTAB_SHNDX Ta Dv ELF_T_WORD Ta Used with extended section numbering.
    386 .It Dv SHT_GNU_verdef Ta Dv ELF_T_VDEF Ta Symbol version definitions.
    387 .It Dv SHT_GNU_verneed Ta Dv ELF_T_VNEED Ta Symbol versioning requirements.
    388 .It Dv SHT_GNU_versym Ta Dv ELF_T_HALF Ta Version symbols.
     391.It Dv SHT_SUNW_dof Ta Dv ELF_T_BYTE Ta Xo
     392Used by
     393.Xr dtrace 1 .
     394.Xc
    389395.It Dv SHT_SUNW_move Ta Dv ELF_T_MOVE Ta ELF move records.
    390396.It Dv SHT_SUNW_syminfo Ta Dv ELF_T_SYMINFO Ta Additional symbol flags.
    391 .El
    392 .TE
     397.It Dv SHT_SUNW_verdef Ta Dv ELF_T_VDEF Ta Xo
     398Same as
     399.Dv SHT_GNU_verdef .
     400.Xc
     401.It Dv SHT_SUNW_verneed Ta Dv ELF_T_VNEED Ta Xo
     402Same as
     403.Dv SHT_GNU_verneed .
     404.Xc
     405.It Dv SHT_SUNW_versym Ta Dv ELF_T_HALF Ta Xo
     406Same as
     407.Dv SHT_GNU_versym .
     408.Xc
     409.El
     410.Pp
     411Section types in the range
     412.Ns [ Dv SHT_LOOS ,
     413.Dv SHT_HIUSER ]
     414are otherwise considered to be of type
     415.Dv ELF_T_BYTE .
    393416.Ss Functional Grouping
    394417This section contains a brief overview of the available functionality
     
    430453Iterate through the sections in an ELF object.
    431454.It Fn elf_rawdata
    432 Retrieve untranslated data for an ELF sectino.
     455Retrieve untranslated data for an ELF section.
    433456.It Fn elf_rawfile
    434457Return a pointer to the untranslated file contents for an ELF object.
     
    533556following which the library will use the data offsets and alignments
    534557specified by the application when laying out the file.
    535 Application control of file layout is described further in the 
     558Application control of file layout is described further in the
    536559.Xr elf_update 3
    537560manual page.
     
    586609.Sh AUTHORS
    587610The ELF library was written by
    588 .An "Joseph Koshy"
    589 .Aq jkoshy@FreeBSD.org .
     611.An Joseph Koshy Aq Mt jkoshy@FreeBSD.org .
  • rtemstoolkit/elftoolchain/libelf/elf.c

    r6f48c91 r771e7f1  
    2929#include "_libelf.h"
    3030
    31 LIBELF_VCSID("$Id: elf.c 1345 2011-01-01 11:17:52Z jkoshy $");
     31ELFTC_VCSID("$Id: elf.c 2225 2011-11-26 18:55:54Z jkoshy $");
    3232
    3333struct _libelf_globals _libelf = {
  • rtemstoolkit/elftoolchain/libelf/elf_begin.3

    r6f48c91 r771e7f1  
    2222.\" such damage.
    2323.\"
    24 .\" $Id: elf_begin.3 1925 2011-09-23 09:34:05Z jkoshy $
     24.\" $Id: elf_begin.3 3182 2015-04-10 16:08:10Z emaste $
    2525.\"
    26 .Dd September 23, 2011
     26.Dd December 11, 2011
    2727.Os
    2828.Dt ELF_BEGIN 3
     
    273273An
    274274.Xr ar 1
    275 archive was opened with with
     275archive was opened with
    276276.Ar cmd
    277277set to
     
    300300was called before a working version was established with
    301301.Xr elf_version 3 .
     302.It Bq Er ELF_E_VERSION
     303The ELF object referenced by argument
     304.Ar fd
     305was of an unsupported ELF version.
    302306.El
    303307.Sh SEE ALSO
  • rtemstoolkit/elftoolchain/libelf/elf_begin.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    29 #include <sys/types.h>
    30 #include <sys/errno.h>
    31 #include <sys/mman.h>
    32 #include <sys/stat.h>
    33 
    34 #include <ar.h>
    35 #include <assert.h>
    36 #include <ctype.h>
    37 #include <errno.h>
    3827#include <libelf.h>
    39 #include <stdlib.h>
    40 #include <unistd.h>
    4128
    4229#include "_libelf.h"
    4330
    44 LIBELF_VCSID("$Id: elf_begin.c 1923 2011-09-23 09:01:13Z jkoshy $");
    45 
    46 #define _LIBELF_INITSIZE        (64*1024)
    47 
    48 /*
    49  * Read from a device file, pipe or socket.
    50  */
    51 static void *
    52 _libelf_read_special_file(int fd, size_t *fsz)
    53 {
    54         ssize_t readsz;
    55         size_t bufsz, datasz;
    56         unsigned char *buf, *t;
    57 
    58         datasz = 0;
    59         readsz = 0;
    60         bufsz = _LIBELF_INITSIZE;
    61         if ((buf = malloc(bufsz)) == NULL)
    62                 goto resourceerror;
    63 
    64         /*
    65          * Read data from the file descriptor till we reach EOF, or
    66          * till an error is encountered.
    67          */
    68         do {
    69                 /* Check if we need to expand the data buffer. */
    70                 if (datasz == bufsz) {
    71                         bufsz *= 2;
    72                         if ((t = realloc(buf, bufsz)) == NULL)
    73                                 goto resourceerror;
    74                         buf = t;
    75                 }
    76 
    77                 do {
    78                         readsz = bufsz - datasz;
    79                         t = buf + datasz;
    80                         if ((readsz = read(fd, t, readsz)) <= 0)
    81                                 break;
    82                         datasz += readsz;
    83                 } while (datasz < bufsz);
    84 
    85         } while (readsz > 0);
    86 
    87         if (readsz < 0) {
    88                 LIBELF_SET_ERROR(IO, errno);
    89                 goto error;
    90         }
    91 
    92         assert(readsz == 0);
    93 
    94         /*
    95          * Free up extra buffer space.
    96          */
    97         if (bufsz > datasz) {
    98                 if (datasz > 0) {
    99                         if ((t = realloc(buf, datasz)) == NULL)
    100                                 goto resourceerror;
    101                         buf = t;
    102                 } else {        /* Zero bytes read. */
    103                         LIBELF_SET_ERROR(ARGUMENT, 0);
    104                         free(buf);
    105                         buf = NULL;
    106                 }
    107         }
    108 
    109         *fsz = datasz;
    110         return (buf);
    111 
    112 resourceerror:
    113         LIBELF_SET_ERROR(RESOURCE, 0);
    114 error:
    115         if (buf != NULL)
    116                 free(buf);
    117         return (NULL);
    118 }
    119 
    120 
    121 static Elf *
    122 _libelf_open_object(int fd, Elf_Cmd c)
    123 {
    124         Elf *e;
    125         void *m;
    126         mode_t mode;
    127         size_t fsize;
    128         struct stat sb;
    129         unsigned int flags;
    130 
    131         assert(c == ELF_C_READ || c == ELF_C_RDWR || c == ELF_C_WRITE);
    132 
    133         if (fstat(fd, &sb) < 0) {
    134                 LIBELF_SET_ERROR(IO, errno);
    135                 return (NULL);
    136         }
    137 
    138         mode = sb.st_mode;
    139         fsize = (size_t) sb.st_size;
    140 
    141         /*
    142          * Reject unsupported file types.
    143          */
    144         if (!S_ISREG(mode) && !S_ISCHR(mode) && !S_ISFIFO(mode) &&
    145             !S_ISSOCK(mode)) {
    146                 LIBELF_SET_ERROR(ARGUMENT, 0);
    147                 return (NULL);
    148         }
    149 
    150         /*
    151          * For ELF_C_WRITE mode, allocate and return a descriptor.
    152          */
    153         if (c == ELF_C_WRITE) {
    154                 if ((e = _libelf_allocate_elf()) != NULL) {
    155                         _libelf_init_elf(e, ELF_K_ELF);
    156                         e->e_byteorder = LIBELF_PRIVATE(byteorder);
    157                         e->e_fd = fd;
    158                         e->e_cmd = c;
    159                         if (!S_ISREG(mode))
    160                                 e->e_flags |= LIBELF_F_SPECIAL_FILE;
    161                 }
    162 
    163                 return (e);
    164         }
    165 
    166 
    167         /*
    168          * ELF_C_READ and ELF_C_RDWR mode.
    169          */
    170         m = NULL;
    171         flags = 0;
    172         if (S_ISREG(mode)) {
    173                 /*
    174                  * Always map regular files in with 'PROT_READ'
    175                  * permissions.
    176                  *
    177                  * For objects opened in ELF_C_RDWR mode, when
    178                  * elf_update(3) is called, we remove this mapping,
    179                  * write file data out using write(2), and map the new
    180                  * contents back.
    181                  */
    182                 if ((m = mmap(NULL, fsize, PROT_READ, MAP_PRIVATE, fd,
    183                     (off_t) 0)) == MAP_FAILED) {
    184                         LIBELF_SET_ERROR(IO, errno);
    185                         return (NULL);
    186                 }
    187 
    188                 flags = LIBELF_F_RAWFILE_MMAP;
    189         } else if ((m = _libelf_read_special_file(fd, &fsize)) != NULL)
    190                 flags = LIBELF_F_RAWFILE_MALLOC | LIBELF_F_SPECIAL_FILE;
    191         else
    192                 return (NULL);
    193 
    194         if ((e = elf_memory(m, fsize)) == NULL) {
    195                 assert((flags & LIBELF_F_RAWFILE_MALLOC) ||
    196                     (flags & LIBELF_F_RAWFILE_MMAP));
    197                 if (flags & LIBELF_F_RAWFILE_MMAP)
    198                         (void) munmap(m, fsize);
    199                 else
    200                         free(m);
    201                 return (NULL);
    202         }
    203 
    204         /* ar(1) archives aren't supported in RDWR mode. */
    205         if (c == ELF_C_RDWR && e->e_kind == ELF_K_AR) {
    206                 (void) elf_end(e);
    207                 LIBELF_SET_ERROR(ARGUMENT, 0);
    208                 return (NULL);
    209         }
    210 
    211         e->e_flags |= flags;
    212         e->e_fd = fd;
    213         e->e_cmd = c;
    214 
    215         return (e);
    216 }
     31ELFTC_VCSID("$Id: elf_begin.c 2364 2011-12-28 17:55:25Z jkoshy $");
    21732
    21833Elf *
     
    26782
    26883        if (a == NULL)
    269                 e = _libelf_open_object(fd, c);
     84                e = _libelf_open_object(fd, c, 1);
    27085        else if (a->e_kind == ELF_K_AR)
    27186                e = _libelf_ar_open_member(a->e_fd, c, a);
  • rtemstoolkit/elftoolchain/libelf/elf_cntl.3

    r6f48c91 r771e7f1  
    2222.\" such damage.
    2323.\"
    24 .\" $Id: elf_cntl.3 289 2009-01-08 08:26:08Z jkoshy $
     24.\" $Id: elf_cntl.3 3181 2015-04-10 13:22:51Z emaste $
    2525.\"
    2626.Dd August 9, 2006
  • rtemstoolkit/elftoolchain/libelf/elf_cntl.c

    r6f48c91 r771e7f1  
    2929#include "_libelf.h"
    3030
    31 LIBELF_VCSID("$Id: elf_cntl.c 189 2008-07-20 10:38:08Z jkoshy $");
     31ELFTC_VCSID("$Id: elf_cntl.c 2225 2011-11-26 18:55:54Z jkoshy $");
    3232
    3333int
  • rtemstoolkit/elftoolchain/libelf/elf_data.c

    r6f48c91 r771e7f1  
    2828#include <errno.h>
    2929#include <libelf.h>
     30#include <stdint.h>
    3031#include <stdlib.h>
    3132
    3233#include "_libelf.h"
    3334
    34 LIBELF_VCSID("$Id: elf_data.c 1765 2011-08-22 05:59:05Z jkoshy $");
     35ELFTC_VCSID("$Id: elf_data.c 3466 2016-05-11 18:35:44Z emaste $");
    3536
    3637Elf_Data *
    37 elf_getdata(Elf_Scn *s, Elf_Data *d)
     38elf_getdata(Elf_Scn *s, Elf_Data *ed)
    3839{
    3940        Elf *e;
    40         size_t fsz, msz, count;
     41        unsigned int sh_type;
    4142        int elfclass, elftype;
    42         unsigned int sh_type;
     43        size_t count, fsz, msz;
     44        struct _Libelf_Data *d;
    4345        uint64_t sh_align, sh_offset, sh_size;
    44         int (*xlate)(char *_d, size_t _dsz, char *_s, size_t _c, int _swap);
     46        int (*xlate)(unsigned char *_d, size_t _dsz, unsigned char *_s,
     47            size_t _c, int _swap);
     48
     49        d = (struct _Libelf_Data *) ed;
    4550
    4651        if (s == NULL || (e = s->s_elf) == NULL ||
     
    5358
    5459        if (d == NULL && (d = STAILQ_FIRST(&s->s_data)) != NULL)
    55                 return (d);
     60                return (&d->d_data);
    5661
    5762        if (d != NULL)
    58                 return (STAILQ_NEXT(d, d_next));
     63                return (&STAILQ_NEXT(d, d_next)->d_data);
    5964
    6065        if (e->e_rawfile == NULL) {
     
    9095        if ((elftype = _libelf_xlate_shtype(sh_type)) < ELF_T_FIRST ||
    9196            elftype > ELF_T_LAST || (sh_type != SHT_NOBITS &&
    92             sh_offset + sh_size > (uint64_t) e->e_rawsize)) {
     97            (sh_offset > e->e_rawsize || sh_size > e->e_rawsize - sh_offset))) {
    9398                LIBELF_SET_ERROR(SECTION, 0);
    9499                return (NULL);
     
    106111        }
    107112
    108         count = sh_size / fsz;
     113        if (sh_size / fsz > SIZE_MAX) {
     114                LIBELF_SET_ERROR(RANGE, 0);
     115                return (NULL);
     116        }
     117
     118        count = (size_t) (sh_size / fsz);
    109119
    110120        msz = _libelf_msize(elftype, elfclass, e->e_version);
    111121
     122        if (count > 0 && msz > SIZE_MAX / count) {
     123                LIBELF_SET_ERROR(RANGE, 0);
     124                return (NULL);
     125        }
     126
    112127        assert(msz > 0);
     128        assert(count <= SIZE_MAX);
     129        assert(msz * count <= SIZE_MAX);
    113130
    114131        if ((d = _libelf_allocate_data(s)) == NULL)
    115132                return (NULL);
    116133
    117         d->d_buf     = NULL;
    118         d->d_off     = 0;
    119         d->d_align   = sh_align;
    120         d->d_size    = msz * count;
    121         d->d_type    = elftype;
    122         d->d_version = e->e_version;
     134        d->d_data.d_buf     = NULL;
     135        d->d_data.d_off     = 0;
     136        d->d_data.d_align   = sh_align;
     137        d->d_data.d_size    = msz * count;
     138        d->d_data.d_type    = elftype;
     139        d->d_data.d_version = e->e_version;
    123140
    124141        if (sh_type == SHT_NOBITS || sh_size == 0) {
    125142                STAILQ_INSERT_TAIL(&s->s_data, d, d_next);
    126                 return (d);
     143                return (&d->d_data);
    127144        }
    128145
    129         if ((d->d_buf = malloc(msz*count)) == NULL) {
     146        if ((d->d_data.d_buf = malloc(msz * count)) == NULL) {
    130147                (void) _libelf_release_data(d);
    131148                LIBELF_SET_ERROR(RESOURCE, 0);
     
    136153
    137154        xlate = _libelf_get_translator(elftype, ELF_TOMEMORY, elfclass);
    138         if (!(*xlate)(d->d_buf, d->d_size, e->e_rawfile + sh_offset, count,
     155        if (!(*xlate)(d->d_data.d_buf, (size_t) d->d_data.d_size,
     156            e->e_rawfile + sh_offset, count,
    139157            e->e_byteorder != LIBELF_PRIVATE(byteorder))) {
    140158                _libelf_release_data(d);
     
    145163        STAILQ_INSERT_TAIL(&s->s_data, d, d_next);
    146164
    147         return (d);
     165        return (&d->d_data);
    148166}
    149167
     
    152170{
    153171        Elf *e;
    154         Elf_Data *d;
     172        struct _Libelf_Data *d;
    155173
    156174        if (s == NULL || (e = s->s_elf) == NULL) {
     
    174192        STAILQ_INSERT_TAIL(&s->s_data, d, d_next);
    175193
    176         d->d_align = 1;
    177         d->d_buf = NULL;
    178         d->d_off = (uint64_t) ~0;
    179         d->d_size = 0;
    180         d->d_type = ELF_T_BYTE;
    181         d->d_version = LIBELF_PRIVATE(version);
     194        d->d_data.d_align = 1;
     195        d->d_data.d_buf = NULL;
     196        d->d_data.d_off = (uint64_t) ~0;
     197        d->d_data.d_size = 0;
     198        d->d_data.d_type = ELF_T_BYTE;
     199        d->d_data.d_version = LIBELF_PRIVATE(version);
    182200
    183201        (void) elf_flagscn(s, ELF_C_SET, ELF_F_DIRTY);
    184202
    185         return (d);
     203        return (&d->d_data);
    186204}
    187205
     
    192210
    193211Elf_Data *
    194 elf_rawdata(Elf_Scn *s, Elf_Data *d)
     212elf_rawdata(Elf_Scn *s, Elf_Data *ed)
    195213{
    196214        Elf *e;
    197215        int elf_class;
    198216        uint32_t sh_type;
     217        struct _Libelf_Data *d;
    199218        uint64_t sh_align, sh_offset, sh_size;
    200219
     
    206225        assert(e->e_kind == ELF_K_ELF);
    207226
     227        d = (struct _Libelf_Data *) ed;
     228
    208229        if (d == NULL && (d = STAILQ_FIRST(&s->s_rawdata)) != NULL)
    209                 return (d);
     230                return (&d->d_data);
    210231
    211232        if (d != NULL)
    212                 return (STAILQ_NEXT(d, d_next));
     233                return (&STAILQ_NEXT(d, d_next)->d_data);
    213234
    214235        elf_class = e->e_class;
     
    228249        }
    229250
    230         if (sh_type == SHT_NULL)
    231                 return (NULL);
     251        if (sh_type == SHT_NULL) {
     252                LIBELF_SET_ERROR(SECTION, 0);
     253                return (NULL);
     254        }
     255
     256        if (sh_type != SHT_NOBITS &&
     257            (sh_offset > e->e_rawsize || sh_size > e->e_rawsize - sh_offset)) {
     258                LIBELF_SET_ERROR(SECTION, 0);
     259                return (NULL);
     260        }
    232261
    233262        if ((d = _libelf_allocate_data(s)) == NULL)
    234263                return (NULL);
    235264
    236         d->d_buf    = (sh_type == SHT_NOBITS || sh_size == 0) ? NULL :
     265        d->d_data.d_buf = (sh_type == SHT_NOBITS || sh_size == 0) ? NULL :
    237266            e->e_rawfile + sh_offset;
    238         d->d_off     = 0;
    239         d->d_align   = sh_align;
    240         d->d_size    = sh_size;
    241         d->d_type    = ELF_T_BYTE;
    242         d->d_version = e->e_version;
     267        d->d_data.d_off     = 0;
     268        d->d_data.d_align   = sh_align;
     269        d->d_data.d_size    = sh_size;
     270        d->d_data.d_type    = ELF_T_BYTE;
     271        d->d_data.d_version = e->e_version;
    243272
    244273        STAILQ_INSERT_TAIL(&s->s_rawdata, d, d_next);
    245274
    246         return (d);
     275        return (&d->d_data);
    247276}
  • rtemstoolkit/elftoolchain/libelf/elf_end.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    29 #include <sys/mman.h>
    30 
    3127#include <assert.h>
    3228#include <libelf.h>
     
    3531#include "_libelf.h"
    3632
    37 LIBELF_VCSID("$Id: elf_end.c 1922 2011-09-23 08:04:33Z jkoshy $");
     33#if     ELFTC_HAVE_MMAP
     34#include <sys/mman.h>
     35#endif
     36
     37ELFTC_VCSID("$Id: elf_end.c 3174 2015-03-27 17:13:41Z emaste $");
    3838
    3939int
     
    7878
    7979                if (e->e_rawfile) {
    80                         if (e->e_flags & LIBELF_F_RAWFILE_MMAP)
     80                        if (e->e_flags & LIBELF_F_RAWFILE_MALLOC)
     81                                free(e->e_rawfile);
     82#if     ELFTC_HAVE_MMAP
     83                        else if (e->e_flags & LIBELF_F_RAWFILE_MMAP)
    8184                                (void) munmap(e->e_rawfile, e->e_rawsize);
    82                         else if (e->e_flags & LIBELF_F_RAWFILE_MALLOC)
    83                                 free(e->e_rawfile);
     85#endif
    8486                }
    8587
  • rtemstoolkit/elftoolchain/libelf/elf_errmsg.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <libelf.h>
    3028#include <stdio.h>
     
    3331#include "_libelf.h"
    3432
    35 LIBELF_VCSID("$Id: elf_errmsg.c 1345 2011-01-01 11:17:52Z jkoshy $");
     33ELFTC_VCSID("$Id: elf_errmsg.c 3174 2015-03-27 17:13:41Z emaste $");
    3634
    3735/*
     
    3937 */
    4038
    41 const char *_libelf_errors[] = {
     39static const char *_libelf_errors[] = {
    4240#define DEFINE_ERROR(N,S)       [ELF_E_##N] = S
    4341        DEFINE_ERROR(NONE,      "No Error"),
     
    7775                return _libelf_errors[ELF_E_NUM];
    7876        if (oserr) {
    79                 (void) snprintf(LIBELF_PRIVATE(msg),
     77                (void) snprintf((char *) LIBELF_PRIVATE(msg),
    8078                    sizeof(LIBELF_PRIVATE(msg)), "%s: %s",
    8179                    _libelf_errors[error], strerror(oserr));
  • rtemstoolkit/elftoolchain/libelf/elf_errno.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <libelf.h>
    3028
    3129#include "_libelf.h"
    3230
    33 LIBELF_VCSID("$Id: elf_errno.c 1345 2011-01-01 11:17:52Z jkoshy $");
     31ELFTC_VCSID("$Id: elf_errno.c 3174 2015-03-27 17:13:41Z emaste $");
    3432
    3533int
  • rtemstoolkit/elftoolchain/libelf/elf_fill.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <libelf.h>
    3028
    3129#include "_libelf.h"
    3230
    33 LIBELF_VCSID("$Id: elf_fill.c 189 2008-07-20 10:38:08Z jkoshy $");
     31ELFTC_VCSID("$Id: elf_fill.c 3174 2015-03-27 17:13:41Z emaste $");
    3432
    3533void
  • rtemstoolkit/elftoolchain/libelf/elf_flag.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <libelf.h>
    3028
    3129#include "_libelf.h"
    3230
    33 LIBELF_VCSID("$Id: elf_flag.c 1918 2011-09-22 10:42:06Z jkoshy $");
     31ELFTC_VCSID("$Id: elf_flag.c 3174 2015-03-27 17:13:41Z emaste $");
    3432
    3533unsigned int
     
    5957{
    6058        unsigned int r;
     59        struct _Libelf_Data *ld;
    6160
    6261        if (d == NULL)
     
    6968        }
    7069
     70        ld = (struct _Libelf_Data *) d;
     71
    7172        if (c == ELF_C_SET)
    72                 r = d->d_flags |= flags;
     73                r = ld->d_flags |= flags;
    7374        else
    74                 r = d->d_flags &= ~flags;
     75                r = ld->d_flags &= ~flags;
    7576
    7677        return (r & LIBELF_F_API_MASK);
     
    109110elf_flagelf(Elf *e, Elf_Cmd c, unsigned int flags)
    110111{
    111         int r;
     112        unsigned int r;
    112113
    113114        if (e == NULL)
     
    171172elf_flagscn(Elf_Scn *s, Elf_Cmd c, unsigned int flags)
    172173{
    173         int r;
     174        unsigned int r;
    174175
    175176        if (s == NULL)
  • rtemstoolkit/elftoolchain/libelf/elf_flagdata.3

    r6f48c91 r771e7f1  
    1 .\" Copyright (c) 2006-2008 Joseph Koshy.  All rights reserved.
     1.\" Copyright (c) 2006-2008,2011 Joseph Koshy.  All rights reserved.
    22.\"
    33.\" Redistribution and use in source and binary forms, with or without
     
    2222.\" such damage.
    2323.\"
    24 .\" $Id: elf_flagdata.3 221 2008-08-10 04:56:27Z jkoshy $
    25 .\"
    26 .Dd October 22, 2007
     24.\" $Id: elf_flagdata.3 3479 2016-06-25 20:44:33Z jkoshy $
     25.\"
     26.Dd December 3, 2011
    2727.Os
    2828.Dt ELF_FLAGDATA 3
     
    6565.Ar scn
    6666denote the data structures whose flags need to be changed.
     67These values should have been returned by prior calls to
     68functions in the ELF(3) API set:
     69.Bl -bullet -compact
     70.It
     71Argument
     72.Ar arhdr
     73should have been returned by a prior call to
     74.Xr elf_getarhdr 3 .
     75.It
     76Argument
     77.Ar data
     78should have been returned by a prior call to one of
     79.Xr elf_newdata 3 ,
     80.Xr elf_getdata 3
     81or
     82.Xr elf_rawdata 3 .
     83.It
     84Argument
     85.Ar elf
     86should have been allocated by a prior call to one of
     87.Xr elf_begin 3
     88or
     89.Xr elf_memory 3 .
     90.It
     91Argument
     92.Ar scn
     93should have been returned by a prior call to one of
     94.Xr elf_getscn 3 ,
     95.Xr elf_newscn 3
     96or
     97.Xr elf_nextscn 3 .
     98.El
    6799These values are allowed to be NULL to simplify error handling in
    68100application code.
     
    135167queried.
    136168.Sh RETURN VALUES
    137 These functions return the updated flags is successful, and zero if
     169These functions return the updated flags if successful, or zero if
    138170an error is detected.
    139171.Sh COMPATIBILITY
     
    177209.Xr elf32_newehdr 3 ,
    178210.Xr elf32_newphdr 3 ,
    179 .Xr elf32_newshdr 3 ,
    180211.Xr elf64_newehdr 3 ,
    181212.Xr elf64_newphdr 3 ,
    182 .Xr elf64_newshdr 3 ,
    183213.Xr elf_newdata 3 ,
    184214.Xr elf_update 3 ,
     
    186216.Xr gelf_newehdr 3 ,
    187217.Xr gelf_newphdr 3 ,
    188 .Xr gelf_newshdr 3 ,
    189218.Xr gelf_update_dyn 3 ,
    190219.Xr gelf_update_move 3 ,
  • rtemstoolkit/elftoolchain/libelf/elf_getarhdr.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <libelf.h>
    3028
    3129#include "_libelf.h"
    3230
    33 LIBELF_VCSID("$Id: elf_getarhdr.c 1341 2011-01-01 04:28:29Z jkoshy $");
     31ELFTC_VCSID("$Id: elf_getarhdr.c 3174 2015-03-27 17:13:41Z emaste $");
    3432
    3533Elf_Arhdr *
  • rtemstoolkit/elftoolchain/libelf/elf_getarsym.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <libelf.h>
    3028
    3129#include "_libelf.h"
    3230
    33 LIBELF_VCSID("$Id: elf_getarsym.c 1360 2011-01-08 08:27:41Z jkoshy $");
     31ELFTC_VCSID("$Id: elf_getarsym.c 3174 2015-03-27 17:13:41Z emaste $");
    3432
    3533Elf_Arsym *
  • rtemstoolkit/elftoolchain/libelf/elf_getbase.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <libelf.h>
    3028
    3129#include "_libelf.h"
    3230
    33 LIBELF_VCSID("$Id: elf_getbase.c 977 2010-06-06 11:50:31Z jkoshy $");
     31ELFTC_VCSID("$Id: elf_getbase.c 3174 2015-03-27 17:13:41Z emaste $");
    3432
    3533off_t
  • rtemstoolkit/elftoolchain/libelf/elf_getdata.3

    r6f48c91 r771e7f1  
    2222.\" such damage.
    2323.\"
    24 .\" $Id: elf_getdata.3 1766 2011-08-22 06:01:03Z jkoshy $
     24.\" $Id: elf_getdata.3 3181 2015-04-10 13:22:51Z emaste $
    2525.\"
    2626.Dd January 26, 2011
     
    175175.Sh ERRORS
    176176These functions may fail with the following errors:
    177 .Bl -tag -width "[ELF_E_RESOURCE]" 
     177.Bl -tag -width "[ELF_E_RESOURCE]"
    178178.It Bq Er ELF_E_ARGUMENT
    179179Either of the arguments
  • rtemstoolkit/elftoolchain/libelf/elf_getident.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <ar.h>
    3028#include <assert.h>
     
    3331#include "_libelf.h"
    3432
    35 LIBELF_VCSID("$Id: elf_getident.c 189 2008-07-20 10:38:08Z jkoshy $");
     33ELFTC_VCSID("$Id: elf_getident.c 3174 2015-03-27 17:13:41Z emaste $");
    3634
    3735char *
  • rtemstoolkit/elftoolchain/libelf/elf_hash.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <libelf.h>
    3028
    31 #include "_libelf_config.h"
     29#include "_libelf.h"
    3230
    33 LIBELF_VCSID("$Id: elf_hash.c 189 2008-07-20 10:38:08Z jkoshy $");
     31ELFTC_VCSID("$Id: elf_hash.c 3174 2015-03-27 17:13:41Z emaste $");
    3432
    3533/*
  • rtemstoolkit/elftoolchain/libelf/elf_kind.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <libelf.h>
    3028
    3129#include "_libelf.h"
    3230
    33 LIBELF_VCSID("$Id: elf_kind.c 189 2008-07-20 10:38:08Z jkoshy $");
     31ELFTC_VCSID("$Id: elf_kind.c 3174 2015-03-27 17:13:41Z emaste $");
    3432
    3533Elf_Kind
  • rtemstoolkit/elftoolchain/libelf/elf_memory.3

    r6f48c91 r771e7f1  
    2222.\" such damage.
    2323.\"
    24 .\" $Id: elf_memory.3 189 2008-07-20 10:38:08Z jkoshy $
     24.\" $Id: elf_memory.3 2314 2011-12-11 06:19:51Z jkoshy $
    2525.\"
    2626.Dd June 28, 2006
     
    110110.Xr elf_version 3 .
    111111.It Bq Er ELF_E_VERSION
    112 The argument
     112The ELF object referenced by argument
    113113.Ar image
    114 corresponds to an ELF file with an unsupported version.
     114was of an unsupported ELF version.
    115115.El
    116116.Sh SEE ALSO
  • rtemstoolkit/elftoolchain/libelf/elf_memory.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    29 #include <ar.h>
    3027#include <libelf.h>
    31 #include <string.h>
    3228
    3329#include "_libelf.h"
    3430
    35 LIBELF_VCSID("$Id: elf_memory.c 189 2008-07-20 10:38:08Z jkoshy $");
     31ELFTC_VCSID("$Id: elf_memory.c 3013 2014-03-23 06:16:59Z jkoshy $");
    3632
    3733Elf *
    3834elf_memory(char *image, size_t sz)
    3935{
    40         Elf *e;
    41 
    4236        if (LIBELF_PRIVATE(version) == EV_NONE) {
    4337                LIBELF_SET_ERROR(SEQUENCE, 0);
     
    5044        }
    5145
    52         if ((e = _libelf_allocate_elf()) == NULL)
    53                 return (NULL);
    54 
    55         e->e_cmd = ELF_C_READ;
    56         e->e_rawfile = image;
    57         e->e_rawsize = sz;
    58 
    59 #undef  LIBELF_IS_ELF
    60 #define LIBELF_IS_ELF(P) ((P)[EI_MAG0] == ELFMAG0 &&            \
    61         (P)[EI_MAG1] == ELFMAG1 && (P)[EI_MAG2] == ELFMAG2 &&   \
    62         (P)[EI_MAG3] == ELFMAG3)
    63 
    64         if (sz > EI_NIDENT && LIBELF_IS_ELF(image)) {
    65                 _libelf_init_elf(e, ELF_K_ELF);
    66                 e->e_class = image[EI_CLASS];
    67                 e->e_byteorder = image[EI_DATA];
    68                 e->e_version = image[EI_VERSION];
    69 
    70                 if (e->e_version > EV_CURRENT) {
    71                         e = _libelf_release_elf(e);
    72                         LIBELF_SET_ERROR(VERSION, 0);
    73                         return (NULL);
    74                 }
    75 
    76                 if ((e->e_byteorder != ELFDATA2LSB && e->e_byteorder !=
    77                     ELFDATA2MSB) || (e->e_class != ELFCLASS32 && e->e_class !=
    78                     ELFCLASS64)) {
    79                         e = _libelf_release_elf(e);
    80                         LIBELF_SET_ERROR(HEADER, 0);
    81                         return (NULL);
    82                 }
    83 
    84         } else if (sz >= SARMAG &&
    85             strncmp(image, ARMAG, (size_t) SARMAG) == 0) {
    86                 _libelf_init_elf(e, ELF_K_AR);
    87                 e = _libelf_ar_open(e);
    88         } else
    89                 _libelf_init_elf(e, ELF_K_NONE);
    90 
    91         return (e);
     46        return (_libelf_memory((unsigned char *) image, sz, 1));
    9247}
  • rtemstoolkit/elftoolchain/libelf/elf_next.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <ar.h>
    3028#include <assert.h>
     
    3331#include "_libelf.h"
    3432
    35 LIBELF_VCSID("$Id: elf_next.c 1678 2011-07-28 04:36:34Z jkoshy $");
     33ELFTC_VCSID("$Id: elf_next.c 3174 2015-03-27 17:13:41Z emaste $");
    3634
    3735Elf_Cmd
     
    4947         }
    5048
    51         assert (parent->e_kind == ELF_K_AR);
    52         assert (parent->e_cmd == ELF_C_READ);
     49        assert(parent->e_kind == ELF_K_AR);
     50        assert(parent->e_cmd == ELF_C_READ);
    5351        assert(e->e_rawfile > parent->e_rawfile);
    5452
    55         next = e->e_rawfile - parent->e_rawfile + e->e_rawsize;
     53        next = e->e_rawfile - parent->e_rawfile + (off_t) e->e_rawsize;
    5654        next = (next + 1) & ~1; /* round up to an even boundary */
    5755
     56        /*
     57         * Setup the 'e_next' field of the archive descriptor for the
     58         * next call to 'elf_begin()'.
     59         */
    5860        parent->e_u.e_ar.e_next = (next >= (off_t) parent->e_rawsize) ?
    5961            (off_t) 0 : next;
  • rtemstoolkit/elftoolchain/libelf/elf_phnum.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <ar.h>
    3028#include <libelf.h>
     
    3230#include "_libelf.h"
    3331
    34 LIBELF_VCSID("$Id: elf_phnum.c 466 2009-08-04 17:17:42Z jkoshy $");
     32ELFTC_VCSID("$Id: elf_phnum.c 3174 2015-03-27 17:13:41Z emaste $");
    3533
    3634static int
  • rtemstoolkit/elftoolchain/libelf/elf_rand.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <ar.h>
    3028#include <libelf.h>
     
    3230#include "_libelf.h"
    3331
    34 LIBELF_VCSID("$Id: elf_rand.c 189 2008-07-20 10:38:08Z jkoshy $");
     32ELFTC_VCSID("$Id: elf_rand.c 3174 2015-03-27 17:13:41Z emaste $");
    3533
    3634off_t
     
    4139        if (ar == NULL || ar->e_kind != ELF_K_AR ||
    4240            (offset & 1) || offset < SARMAG ||
    43             offset + sizeof(struct ar_hdr) >= ar->e_rawsize) {
     41            (size_t) offset + sizeof(struct ar_hdr) >= ar->e_rawsize) {
    4442                LIBELF_SET_ERROR(ARGUMENT, 0);
    4543                return 0;
  • rtemstoolkit/elftoolchain/libelf/elf_rawfile.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <libelf.h>
    3028
    3129#include "_libelf.h"
    3230
    33 LIBELF_VCSID("$Id: elf_rawfile.c 189 2008-07-20 10:38:08Z jkoshy $");
     31ELFTC_VCSID("$Id: elf_rawfile.c 3174 2015-03-27 17:13:41Z emaste $");
    3432
    3533char *
    3634elf_rawfile(Elf *e, size_t *sz)
    3735{
    38         char *ptr;
    3936        size_t size;
     37        unsigned char *ptr;
    4038
    4139        size = e ? e->e_rawsize : 0;
     
    5048                *sz = size;
    5149
    52         return (ptr);
     50        return ((char *) ptr);
    5351}
  • rtemstoolkit/elftoolchain/libelf/elf_scn.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    2827#include <sys/queue.h>
    2928
     
    3332#include <libelf.h>
    3433#include <stddef.h>
     34#include <stdint.h>
    3535#include <stdlib.h>
    3636
    3737#include "_libelf.h"
    3838
    39 LIBELF_VCSID("$Id: elf_scn.c 1077 2010-08-09 15:37:40Z jkoshy $");
     39ELFTC_VCSID("$Id: elf_scn.c 3177 2015-03-30 18:19:41Z emaste $");
    4040
    4141/*
     
    4545_libelf_load_section_headers(Elf *e, void *ehdr)
    4646{
    47         int ec, swapbytes;
    48         size_t fsz, i, shnum;
     47        Elf_Scn *scn;
    4948        uint64_t shoff;
    50         char *src;
    5149        Elf32_Ehdr *eh32;
    5250        Elf64_Ehdr *eh64;
    53         Elf_Scn *scn;
    54         int (*xlator)(char *_d, size_t _dsz, char *_s, size_t _c, int _swap);
     51        int ec, swapbytes;
     52        unsigned char *src;
     53        size_t fsz, i, shnum;
     54        int (*xlator)(unsigned char *_d, size_t _dsz, unsigned char *_s,
     55            size_t _c, int _swap);
    5556
    5657        assert(e != NULL);
     
    5960
    6061#define CHECK_EHDR(E,EH)        do {                            \
    61                 if (fsz != (EH)->e_shentsize ||                 \
    62                     shoff + fsz * shnum > e->e_rawsize) {       \
     62                if (shoff > e->e_rawsize ||                     \
     63                    fsz != (EH)->e_shentsize ||                 \
     64                    shnum > SIZE_MAX / fsz ||                   \
     65                    fsz * shnum > e->e_rawsize - shoff) {       \
    6366                        LIBELF_SET_ERROR(HEADER, 0);            \
    6467                        return (0);                             \
     
    9699                assert(STAILQ_FIRST(&e->e_u.e_elf.e_scn) ==
    97100                    STAILQ_LAST(&e->e_u.e_elf.e_scn, _Elf_Scn, s_next));
    98    
     101
    99102                i = 1;
    100103                src += fsz;
     
    105108                        return (0);
    106109
    107                 (*xlator)((char *) &scn->s_shdr, sizeof(scn->s_shdr), src,
    108                     (size_t) 1, swapbytes);
     110                (*xlator)((unsigned char *) &scn->s_shdr, sizeof(scn->s_shdr),
     111                    src, (size_t) 1, swapbytes);
    109112
    110113                if (ec == ELFCLASS32) {
  • rtemstoolkit/elftoolchain/libelf/elf_shnum.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <ar.h>
    3028#include <libelf.h>
     
    3230#include "_libelf.h"
    3331
    34 LIBELF_VCSID("$Id: elf_shnum.c 466 2009-08-04 17:17:42Z jkoshy $");
     32ELFTC_VCSID("$Id: elf_shnum.c 3174 2015-03-27 17:13:41Z emaste $");
    3533
    3634static int
  • rtemstoolkit/elftoolchain/libelf/elf_shstrndx.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <ar.h>
    3028#include <libelf.h>
     
    3230#include "_libelf.h"
    3331
    34 LIBELF_VCSID("$Id: elf_shstrndx.c 466 2009-08-04 17:17:42Z jkoshy $");
     32ELFTC_VCSID("$Id: elf_shstrndx.c 3174 2015-03-27 17:13:41Z emaste $");
    3533
    3634static int
  • rtemstoolkit/elftoolchain/libelf/elf_strptr.c

    r6f48c91 r771e7f1  
    2525 */
    2626
     27#include <sys/param.h>
     28
    2729#include <assert.h>
    2830#include <gelf.h>
     
    3032#include "_libelf.h"
    3133
    32 LIBELF_VCSID("$Id: elf_strptr.c 189 2008-07-20 10:38:08Z jkoshy $");
     34ELFTC_VCSID("$Id: elf_strptr.c 2990 2014-03-17 09:56:58Z jkoshy $");
    3335
    3436/*
     
    4143        Elf_Scn *s;
    4244        Elf_Data *d;
    43         size_t alignment, count;
    4445        GElf_Shdr shdr;
     46        uint64_t alignment, count;
    4547
    4648        if (e == NULL || e->e_kind != ELF_K_ELF) {
     
    8991                 * by alignment requirements.
    9092                 */
    91                 count = (size_t) 0;     /* cumulative count of bytes seen */
     93                count = (uint64_t) 0;   /* cumulative count of bytes seen */
    9294                while ((d = elf_getdata(s, d)) != NULL && count <= offset) {
    9395
  • rtemstoolkit/elftoolchain/libelf/elf_update.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/mman.h>
     27#include <sys/param.h>
    2828#include <sys/stat.h>
    2929
     
    3838#include "_libelf.h"
    3939
    40 LIBELF_VCSID("$Id: elf_update.c 1922 2011-09-23 08:04:33Z jkoshy $");
     40#if     ELFTC_HAVE_MMAP
     41#include <sys/mman.h>
     42#endif
     43
     44ELFTC_VCSID("$Id: elf_update.c 3190 2015-05-04 15:23:08Z jkoshy $");
    4145
    4246/*
     
    107111_libelf_compute_section_extents(Elf *e, Elf_Scn *s, off_t rc)
    108112{
    109         int ec;
     113        Elf_Data *d;
    110114        size_t fsz, msz;
    111         Elf_Data *d;
     115        int ec, elftype;
     116        uint32_t sh_type;
     117        uint64_t d_align;
    112118        Elf32_Shdr *shdr32;
    113119        Elf64_Shdr *shdr64;
    114         uint32_t sh_type;
    115         uint64_t d_align;
    116         unsigned int elftype;
     120        struct _Libelf_Data *ld;
    117121        uint64_t scn_size, scn_alignment;
    118122        uint64_t sh_align, sh_entsize, sh_offset, sh_size;
     
    188192        scn_size = 0L;
    189193        scn_alignment = 0;
    190         STAILQ_FOREACH(d, &s->s_data, d_next)  {
     194        STAILQ_FOREACH(ld, &s->s_data, d_next)  {
     195
     196                d = &ld->d_data;
    191197
    192198                /*
     
    247253                        d->d_off = scn_size;
    248254                        fsz = _libelf_fsize(d->d_type, ec, d->d_version,
    249                             d->d_size / msz);
     255                            (size_t) d->d_size / msz);
    250256                        scn_size += fsz;
    251257                }
     
    266272         */
    267273        if (e->e_flags & ELF_F_LAYOUT) {
    268                 if (scn_alignment > sh_align || sh_offset % sh_align ||
    269                     sh_size < scn_size) {
     274                if (scn_alignment > sh_align ||
     275                    sh_offset % sh_align ||
     276                    sh_size < scn_size ||
     277                    sh_offset % _libelf_falign(elftype, ec)) {
    270278                        LIBELF_SET_ERROR(LAYOUT, 0);
    271279                        return (0);
     
    301309         * the section's alignment needs.
    302310         */
    303         sh_offset = roundup(rc, sh_align);
     311        sh_offset = roundup((uint64_t) rc, sh_align);
    304312
    305313        /*
     
    465473
    466474                if ((size_t) rc < s->s_offset + s->s_size)
    467                         rc = s->s_offset + s->s_size;
     475                        rc = (off_t) (s->s_offset + s->s_size);
    468476        }
    469477
     
    496504_libelf_resync_elf(Elf *e, struct _Elf_Extent_List *extents)
    497505{
    498         int ec, eh_class, eh_type;
     506        int ec, eh_class;
    499507        unsigned int eh_byteorder, eh_version;
    500508        size_t align, fsz;
     
    523531                eh_byteorder = eh32->e_ident[EI_DATA];
    524532                eh_class     = eh32->e_ident[EI_CLASS];
    525                 phoff        = (uint64_t) eh32->e_phoff;
    526                 shoff        = (uint64_t) eh32->e_shoff;
    527                 eh_type      = eh32->e_type;
     533                phoff        = (off_t) eh32->e_phoff;
     534                shoff        = (off_t) eh32->e_shoff;
    528535                eh_version   = eh32->e_version;
    529536        } else {
    530537                eh_byteorder = eh64->e_ident[EI_DATA];
    531538                eh_class     = eh64->e_ident[EI_CLASS];
    532                 phoff        = eh64->e_phoff;
    533                 shoff        = eh64->e_shoff;
    534                 eh_type      = eh64->e_type;
     539                phoff        = (off_t) eh64->e_phoff;
     540                shoff        = (off_t) eh64->e_shoff;
    535541                eh_version   = eh64->e_version;
     542        }
     543
     544        if (phoff < 0 || shoff < 0) {
     545                LIBELF_SET_ERROR(HEADER, 0);
     546                return ((off_t) -1);
    536547        }
    537548
     
    560571
    561572#define INITIALIZE_EHDR(E,EC,V) do {                                    \
     573                unsigned int _version = (unsigned int) (V);             \
    562574                (E)->e_ident[EI_MAG0] = ELFMAG0;                        \
    563575                (E)->e_ident[EI_MAG1] = ELFMAG1;                        \
    564576                (E)->e_ident[EI_MAG2] = ELFMAG2;                        \
    565577                (E)->e_ident[EI_MAG3] = ELFMAG3;                        \
    566                 (E)->e_ident[EI_CLASS] = (EC);                          \
    567                 (E)->e_ident[EI_VERSION] = (V);                         \
    568                 (E)->e_ehsize = _libelf_fsize(ELF_T_EHDR, (EC), (V),    \
    569                     (size_t) 1);                                        \
    570                 (E)->e_phentsize = (phnum == 0) ? 0 : _libelf_fsize(    \
    571                     ELF_T_PHDR, (EC), (V), (size_t) 1);                 \
    572                 (E)->e_shentsize = _libelf_fsize(ELF_T_SHDR, (EC), (V), \
    573                     (size_t) 1);                                        \
     578                (E)->e_ident[EI_CLASS] = (unsigned char) (EC);          \
     579                (E)->e_ident[EI_VERSION] = (_version & 0xFFU);          \
     580                (E)->e_ehsize = (uint16_t) _libelf_fsize(ELF_T_EHDR,    \
     581                    (EC), _version, (size_t) 1);                        \
     582                (E)->e_phentsize = (uint16_t) ((phnum == 0) ? 0 :       \
     583                    _libelf_fsize(ELF_T_PHDR, (EC), _version,           \
     584                        (size_t) 1));                                   \
     585                (E)->e_shentsize = (uint16_t) _libelf_fsize(ELF_T_SHDR, \
     586                    (EC), _version, (size_t) 1);                        \
    574587        } while (0)
    575588
     
    581594        (void) elf_flagehdr(e, ELF_C_SET, ELF_F_DIRTY);
    582595
    583         rc += _libelf_fsize(ELF_T_EHDR, ec, eh_version, (size_t) 1);
    584 
    585         if (!_libelf_insert_extent(extents, ELF_EXTENT_EHDR, 0, rc, ehdr))
     596        rc += (off_t) _libelf_fsize(ELF_T_EHDR, ec, eh_version, (size_t) 1);
     597
     598        if (!_libelf_insert_extent(extents, ELF_EXTENT_EHDR, 0, (uint64_t) rc,
     599                ehdr))
    586600                return ((off_t) -1);
    587601
     
    604618                        }
    605619
    606                         if (phoff % align) {
     620                        if (phoff % (off_t) align) {
    607621                                LIBELF_SET_ERROR(LAYOUT, 0);
    608622                                return ((off_t) -1);
     
    610624
    611625                } else
    612                         phoff = roundup(rc, align);
    613 
    614                 rc = phoff + fsz;
     626                        phoff = roundup(rc, (off_t) align);
     627
     628                rc = phoff + (off_t) fsz;
    615629
    616630                phdr = _libelf_getphdr(e, ec);
    617631
    618                 if (!_libelf_insert_extent(extents, ELF_EXTENT_PHDR, phoff,
    619                         fsz, phdr))
     632                if (!_libelf_insert_extent(extents, ELF_EXTENT_PHDR,
     633                        (uint64_t) phoff, fsz, phdr))
    620634                        return ((off_t) -1);
    621635        } else
     
    652666
    653667                if (e->e_flags & ELF_F_LAYOUT) {
    654                         if (shoff % align) {
     668                        if (shoff % (off_t) align) {
    655669                                LIBELF_SET_ERROR(LAYOUT, 0);
    656670                                return ((off_t) -1);
    657671                        }
    658672                } else
    659                         shoff = roundup(rc, align);
    660 
    661                 if (shoff + fsz > (size_t) rc)
    662                         rc = shoff + fsz;
    663 
    664                 if (!_libelf_insert_extent(extents, ELF_EXTENT_SHDR, shoff,
    665                     fsz, NULL))
     673                        shoff = roundup(rc, (off_t) align);
     674
     675                if (shoff + (off_t) fsz > rc)
     676                        rc = shoff + (off_t) fsz;
     677
     678                if (!_libelf_insert_extent(extents, ELF_EXTENT_SHDR,
     679                        (uint64_t) shoff, fsz, NULL))
    666680                        return ((off_t) -1);
    667681        } else
     
    696710 */
    697711
    698 static size_t
    699 _libelf_write_scn(Elf *e, char *nf, struct _Elf_Extent *ex)
     712static off_t
     713_libelf_write_scn(Elf *e, unsigned char *nf, struct _Elf_Extent *ex)
    700714{
    701715        int ec;
    702         size_t fsz, msz, nobjects, rc;
     716        off_t rc;
     717        Elf_Scn *s;
     718        int elftype;
     719        Elf_Data *d, dst;
    703720        uint32_t sh_type;
     721        struct _Libelf_Data *ld;
    704722        uint64_t sh_off, sh_size;
    705         int elftype;
    706         Elf_Scn *s;
    707         Elf_Data *d, dst;
     723        size_t fsz, msz, nobjects;
    708724
    709725        assert(ex->ex_type == ELF_EXTENT_SECTION);
    710726
    711727        s = ex->ex_desc;
    712         rc = ex->ex_start;
     728        rc = (off_t) ex->ex_start;
    713729
    714730        if ((ec = e->e_class) == ELFCLASS32) {
     
    745761                        return ((off_t) -1);
    746762
    747                 STAILQ_FOREACH(d, &s->s_rawdata, d_next) {
     763                STAILQ_FOREACH(ld, &s->s_rawdata, d_next) {
     764
     765                        d = &ld->d_data;
     766
    748767                        if ((uint64_t) rc < sh_off + d->d_off)
    749768                                (void) memset(nf + rc,
    750                                     LIBELF_PRIVATE(fillchar), sh_off +
    751                                     d->d_off - rc);
    752                         rc = sh_off + d->d_off;
     769                                    LIBELF_PRIVATE(fillchar),
     770                                    (size_t) (sh_off + d->d_off -
     771                                        (uint64_t) rc));
     772                        rc = (off_t) (sh_off + d->d_off);
    753773
    754774                        assert(d->d_buf != NULL);
     
    757777
    758778                        (void) memcpy(nf + rc,
    759                             e->e_rawfile + s->s_rawoff + d->d_off, d->d_size);
    760 
    761                         rc += d->d_size;
     779                            e->e_rawfile + s->s_rawoff + d->d_off,
     780                            (size_t) d->d_size);
     781
     782                        rc += (off_t) d->d_size;
    762783                }
    763784
     
    773794        dst.d_version = e->e_version;
    774795
    775         STAILQ_FOREACH(d, &s->s_data, d_next) {
     796        STAILQ_FOREACH(ld, &s->s_data, d_next) {
     797
     798                d = &ld->d_data;
    776799
    777800                msz = _libelf_msize(d->d_type, ec, e->e_version);
     
    779802                if ((uint64_t) rc < sh_off + d->d_off)
    780803                        (void) memset(nf + rc,
    781                             LIBELF_PRIVATE(fillchar), sh_off + d->d_off - rc);
    782 
    783                 rc = sh_off + d->d_off;
     804                            LIBELF_PRIVATE(fillchar),
     805                            (size_t) (sh_off + d->d_off - (uint64_t) rc));
     806
     807                rc = (off_t) (sh_off + d->d_off);
    784808
    785809                assert(d->d_buf != NULL);
     
    787811                assert(d->d_size % msz == 0);
    788812
    789                 nobjects = d->d_size / msz;
     813                nobjects = (size_t) (d->d_size / msz);
    790814
    791815                fsz = _libelf_fsize(d->d_type, ec, e->e_version, nobjects);
     
    798822                        return ((off_t) -1);
    799823
    800                 rc += fsz;
    801         }
    802 
    803         return ((off_t) rc);
     824                rc += (off_t) fsz;
     825        }
     826
     827        return (rc);
    804828}
    805829
     
    809833
    810834static off_t
    811 _libelf_write_ehdr(Elf *e, char *nf, struct _Elf_Extent *ex)
     835_libelf_write_ehdr(Elf *e, unsigned char *nf, struct _Elf_Extent *ex)
    812836{
    813837        int ec;
     
    850874
    851875static off_t
    852 _libelf_write_phdr(Elf *e, char *nf, struct _Elf_Extent *ex)
     876_libelf_write_phdr(Elf *e, unsigned char *nf, struct _Elf_Extent *ex)
    853877{
    854878        int ec;
     
    899923                return ((off_t) -1);
    900924
    901         return (phoff + fsz);
     925        return ((off_t) (phoff + fsz));
    902926}
    903927
     
    907931
    908932static off_t
    909 _libelf_write_shdr(Elf *e, char *nf, struct _Elf_Extent *ex)
     933_libelf_write_shdr(Elf *e, unsigned char *nf, struct _Elf_Extent *ex)
    910934{
    911935        int ec;
     
    959983        }
    960984
    961         return (ex->ex_start + nscn * fsz);
     985        return ((off_t) (ex->ex_start + nscn * fsz));
    962986}
    963987
     
    9831007{
    9841008        off_t nrc, rc;
    985         char *newfile;
    9861009        Elf_Scn *scn, *tscn;
    9871010        struct _Elf_Extent *ex;
     1011        unsigned char *newfile;
    9881012
    9891013        assert(e->e_kind == ELF_K_ELF);
     
    10021026                if (ex->ex_start > (size_t) rc)
    10031027                        (void) memset(newfile + rc, LIBELF_PRIVATE(fillchar),
    1004                             ex->ex_start - rc);
     1028                            (size_t) (ex->ex_start - (uint64_t) rc));
    10051029
    10061030                switch (ex->ex_type) {
     
    10481072                        goto error;
    10491073                }
     1074#if     ELFTC_HAVE_MMAP
    10501075                if (e->e_flags & LIBELF_F_RAWFILE_MMAP) {
    10511076                        assert(e->e_rawfile != NULL);
     
    10561081                        }
    10571082                }
     1083#endif
    10581084        }
    10591085
     
    10721098        if (e->e_cmd == ELF_C_RDWR) {
    10731099                assert(e->e_rawfile != NULL);
    1074                 if (e->e_flags & LIBELF_F_RAWFILE_MMAP) {
     1100                assert((e->e_flags & LIBELF_F_RAWFILE_MALLOC) ||
     1101                    (e->e_flags & LIBELF_F_RAWFILE_MMAP));
     1102                if (e->e_flags & LIBELF_F_RAWFILE_MALLOC) {
     1103                        free(e->e_rawfile);
     1104                        e->e_rawfile = newfile;
     1105                        newfile = NULL;
     1106                }
     1107#if     ELFTC_HAVE_MMAP
     1108                else if (e->e_flags & LIBELF_F_RAWFILE_MMAP) {
    10751109                        if ((e->e_rawfile = mmap(NULL, (size_t) newsize,
    10761110                            PROT_READ, MAP_PRIVATE, e->e_fd, (off_t) 0)) ==
     
    10791113                                goto error;
    10801114                        }
    1081                 } else if (e->e_flags & LIBELF_F_RAWFILE_MALLOC) {
    1082                         free(e->e_rawfile);
    1083                         e->e_rawfile = newfile;
    1084                         newfile = NULL;
    1085                 }
     1115                }
     1116#endif  /* ELFTC_HAVE_MMAP */
    10861117
    10871118                /* Record the new size of the file. */
    1088                 e->e_rawsize = newsize;
     1119                e->e_rawsize = (size_t) newsize;
    10891120        } else {
    10901121                /* File opened in ELF_C_WRITE mode. */
     
    11771208        }
    11781209
    1179         return (_libelf_write_elf(e, rc, &extents));
     1210        rc = _libelf_write_elf(e, rc, &extents);
    11801211
    11811212done:
  • rtemstoolkit/elftoolchain/libelf/elf_version.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <libelf.h>
    3028
    3129#include "_libelf.h"
    3230
    33 LIBELF_VCSID("$Id: elf_version.c 189 2008-07-20 10:38:08Z jkoshy $");
     31ELFTC_VCSID("$Id: elf_version.c 3174 2015-03-27 17:13:41Z emaste $");
    3432
    3533unsigned int
  • rtemstoolkit/elftoolchain/libelf/gelf.3

    r6f48c91 r771e7f1  
    2222.\" such damage.
    2323.\"
    24 .\" $Id: gelf.3 189 2008-07-20 10:38:08Z jkoshy $
     24.\" $Id: gelf.3 3195 2015-05-12 17:22:19Z emaste $
    2525.\"
    2626.Dd September 1, 2006
     
    198198.Sh AUTHORS
    199199The GElf API was implemented by
    200 .An "Joseph Koshy"
    201 .Aq jkoshy@FreeBSD.org .
     200.An Joseph Koshy Aq Mt jkoshy@FreeBSD.org .
  • rtemstoolkit/elftoolchain/libelf/gelf.h

    r6f48c91 r771e7f1  
    2424 * SUCH DAMAGE.
    2525 *
    26  * $Id: gelf.h 1168 2010-09-04 01:03:25Z jkoshy $
     26 * $Id: gelf.h 3174 2015-03-27 17:13:41Z emaste $
    2727 */
    2828
    2929#ifndef _GELF_H_
    3030#define _GELF_H_
    31 
    32 #include <sys/cdefs.h>
    3331
    3432#include <libelf.h>
     
    7068#define GELF_ST_VISIBILITY              ELF64_ST_VISIBILITY
    7169
    72 __BEGIN_DECLS
     70#ifdef __cplusplus
     71extern "C" {
     72#endif
    7373long            gelf_checksum(Elf *_elf);
    7474size_t          gelf_fsize(Elf *_elf, Elf_Type _type, size_t _count,
     
    104104int             gelf_update_move(Elf_Data *_dst, int _index, GElf_Move *_src);
    105105int             gelf_update_syminfo(Elf_Data *_dst, int _index, GElf_Syminfo *_src);
    106 __END_DECLS
     106#ifdef __cplusplus
     107}
     108#endif
    107109
    108110#endif  /* _GELF_H_ */
  • rtemstoolkit/elftoolchain/libelf/gelf_cap.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <assert.h>
    3028#include <gelf.h>
     29#include <limits.h>
     30#include <stdint.h>
    3131
    3232#include "_libelf.h"
    3333
    34 LIBELF_VCSID("$Id: gelf_cap.c 1166 2010-09-04 00:54:36Z jkoshy $");
     34ELFTC_VCSID("$Id: gelf_cap.c 3177 2015-03-30 18:19:41Z emaste $");
    3535
    3636GElf_Cap *
    37 gelf_getcap(Elf_Data *d, int ndx, GElf_Cap *dst)
     37gelf_getcap(Elf_Data *ed, int ndx, GElf_Cap *dst)
    3838{
    3939        int ec;
    4040        Elf *e;
     41        size_t msz;
    4142        Elf_Scn *scn;
    4243        Elf32_Cap *cap32;
    4344        Elf64_Cap *cap64;
    44         size_t msz;
    4545        uint32_t sh_type;
     46        struct _Libelf_Data *d;
     47
     48        d = (struct _Libelf_Data *) ed;
    4649
    4750        if (d == NULL || ndx < 0 || dst == NULL ||
     
    6972        assert(msz > 0);
    7073
    71         if (msz * ndx >= d->d_size) {
     74        if (msz * (size_t) ndx >= d->d_data.d_size) {
    7275                LIBELF_SET_ERROR(ARGUMENT, 0);
    7376                return (NULL);
     
    7679        if (ec == ELFCLASS32) {
    7780
    78                 cap32 = (Elf32_Cap *) d->d_buf + ndx;
     81                cap32 = (Elf32_Cap *) d->d_data.d_buf + ndx;
    7982
    8083                dst->c_tag  = cap32->c_tag;
     
    8386        } else {
    8487
    85                 cap64 = (Elf64_Cap *) d->d_buf + ndx;
     88                cap64 = (Elf64_Cap *) d->d_data.d_buf + ndx;
    8689
    8790                *dst = *cap64;
     
    9295
    9396int
    94 gelf_update_cap(Elf_Data *d, int ndx, GElf_Cap *gc)
     97gelf_update_cap(Elf_Data *ed, int ndx, GElf_Cap *gc)
    9598{
    9699        int ec;
    97100        Elf *e;
     101        size_t msz;
    98102        Elf_Scn *scn;
    99103        Elf32_Cap *cap32;
    100104        Elf64_Cap *cap64;
    101         size_t msz;
    102105        uint32_t sh_type;
     106        struct _Libelf_Data *d;
     107
     108        d = (struct _Libelf_Data *) ed;
    103109
    104110        if (d == NULL || ndx < 0 || gc == NULL ||
     
    125131        assert(msz > 0);
    126132
    127         if (msz * ndx >= d->d_size) {
     133        if (msz * (size_t) ndx >= d->d_data.d_size) {
    128134                LIBELF_SET_ERROR(ARGUMENT, 0);
    129135                return (0);
     
    131137
    132138        if (ec == ELFCLASS32) {
    133                 cap32 = (Elf32_Cap *) d->d_buf + ndx;
     139                cap32 = (Elf32_Cap *) d->d_data.d_buf + ndx;
    134140
    135141                LIBELF_COPY_U32(cap32, gc, c_tag);
    136142                LIBELF_COPY_U32(cap32, gc, c_un.c_val);
    137143        } else {
    138                 cap64 = (Elf64_Cap *) d->d_buf + ndx;
     144                cap64 = (Elf64_Cap *) d->d_data.d_buf + ndx;
    139145
    140146                *cap64 = *gc;
  • rtemstoolkit/elftoolchain/libelf/gelf_checksum.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <gelf.h>
    3028#include <libelf.h>
     
    3230#include "_libelf.h"
    3331
    34 LIBELF_VCSID("$Id: gelf_checksum.c 189 2008-07-20 10:38:08Z jkoshy $");
     32ELFTC_VCSID("$Id: gelf_checksum.c 3174 2015-03-27 17:13:41Z emaste $");
    3533
    3634long
  • rtemstoolkit/elftoolchain/libelf/gelf_dyn.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <assert.h>
    3028#include <gelf.h>
     29#include <limits.h>
     30#include <stdint.h>
    3131
    3232#include "_libelf.h"
    3333
    34 LIBELF_VCSID("$Id: gelf_dyn.c 189 2008-07-20 10:38:08Z jkoshy $");
     34ELFTC_VCSID("$Id: gelf_dyn.c 3177 2015-03-30 18:19:41Z emaste $");
    3535
    3636GElf_Dyn *
    37 gelf_getdyn(Elf_Data *d, int ndx, GElf_Dyn *dst)
     37gelf_getdyn(Elf_Data *ed, int ndx, GElf_Dyn *dst)
    3838{
    3939        int ec;
    4040        Elf *e;
     41        size_t msz;
    4142        Elf_Scn *scn;
    4243        Elf32_Dyn *dyn32;
    4344        Elf64_Dyn *dyn64;
    44         size_t msz;
    4545        uint32_t sh_type;
     46        struct _Libelf_Data *d;
     47
     48        d = (struct _Libelf_Data *) ed;
    4649
    4750        if (d == NULL || ndx < 0 || dst == NULL ||
     
    6871
    6972        assert(msz > 0);
     73        assert(ndx >= 0);
    7074
    71         if (msz * ndx >= d->d_size) {
     75        if (msz * (size_t) ndx >= d->d_data.d_size) {
    7276                LIBELF_SET_ERROR(ARGUMENT, 0);
    7377                return (NULL);
     
    7579
    7680        if (ec == ELFCLASS32) {
    77                 dyn32 = (Elf32_Dyn *) d->d_buf + ndx;
     81                dyn32 = (Elf32_Dyn *) d->d_data.d_buf + ndx;
    7882
    7983                dst->d_tag      = dyn32->d_tag;
     
    8286        } else {
    8387
    84                 dyn64 = (Elf64_Dyn *) d->d_buf + ndx;
     88                dyn64 = (Elf64_Dyn *) d->d_data.d_buf + ndx;
    8589
    8690                *dst = *dyn64;
     
    9195
    9296int
    93 gelf_update_dyn(Elf_Data *d, int ndx, GElf_Dyn *ds)
     97gelf_update_dyn(Elf_Data *ed, int ndx, GElf_Dyn *ds)
    9498{
    9599        int ec;
    96100        Elf *e;
     101        size_t msz;
    97102        Elf_Scn *scn;
    98103        Elf32_Dyn *dyn32;
    99104        Elf64_Dyn *dyn64;
    100         size_t msz;
    101105        uint32_t sh_type;
     106        struct _Libelf_Data *d;
     107
     108        d = (struct _Libelf_Data *) ed;
    102109
    103110        if (d == NULL || ndx < 0 || ds == NULL ||
     
    122129
    123130        msz = _libelf_msize(ELF_T_DYN, ec, e->e_version);
     131
    124132        assert(msz > 0);
     133        assert(ndx >= 0);
    125134
    126         if (msz * ndx >= d->d_size) {
     135        if (msz * (size_t) ndx >= d->d_data.d_size) {
    127136                LIBELF_SET_ERROR(ARGUMENT, 0);
    128137                return (0);
     
    130139
    131140        if (ec == ELFCLASS32) {
    132                 dyn32 = (Elf32_Dyn *) d->d_buf + ndx;
     141                dyn32 = (Elf32_Dyn *) d->d_data.d_buf + ndx;
    133142
    134143                LIBELF_COPY_S32(dyn32, ds, d_tag);
    135144                LIBELF_COPY_U32(dyn32, ds, d_un.d_val);
    136145        } else {
    137                 dyn64 = (Elf64_Dyn *) d->d_buf + ndx;
     146                dyn64 = (Elf64_Dyn *) d->d_data.d_buf + ndx;
    138147
    139148                *dyn64 = *ds;
  • rtemstoolkit/elftoolchain/libelf/gelf_ehdr.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <assert.h>
    3028#include <gelf.h>
    3129#include <libelf.h>
     30#include <limits.h>
     31#include <stdint.h>
    3232#include <string.h>
    3333
    3434#include "_libelf.h"
    3535
    36 LIBELF_VCSID("$Id: gelf_ehdr.c 1678 2011-07-28 04:36:34Z jkoshy $");
     36ELFTC_VCSID("$Id: gelf_ehdr.c 3177 2015-03-30 18:19:41Z emaste $");
    3737
    3838Elf32_Ehdr *
  • rtemstoolkit/elftoolchain/libelf/gelf_fsize.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <gelf.h>
    3028#include <libelf.h>
     
    3230#include "_libelf.h"
    3331
    34 LIBELF_VCSID("$Id: gelf_fsize.c 189 2008-07-20 10:38:08Z jkoshy $");
     32ELFTC_VCSID("$Id: gelf_fsize.c 3174 2015-03-27 17:13:41Z emaste $");
    3533
    3634size_t
  • rtemstoolkit/elftoolchain/libelf/gelf_getclass.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <gelf.h>
    3028
    3129#include "_libelf.h"
    3230
    33 LIBELF_VCSID("$Id: gelf_getclass.c 189 2008-07-20 10:38:08Z jkoshy $");
     31ELFTC_VCSID("$Id: gelf_getclass.c 3174 2015-03-27 17:13:41Z emaste $");
    3432
    3533int
  • rtemstoolkit/elftoolchain/libelf/gelf_move.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <assert.h>
    3028#include <gelf.h>
     29#include <limits.h>
     30#include <stdint.h>
    3131
    3232#include "_libelf.h"
    3333
    34 LIBELF_VCSID("$Id: gelf_move.c 1166 2010-09-04 00:54:36Z jkoshy $");
     34ELFTC_VCSID("$Id: gelf_move.c 3177 2015-03-30 18:19:41Z emaste $");
    3535
    3636GElf_Move *
    37 gelf_getmove(Elf_Data *d, int ndx, GElf_Move *dst)
     37gelf_getmove(Elf_Data *ed, int ndx, GElf_Move *dst)
    3838{
    3939        int ec;
    4040        Elf *e;
     41        size_t msz;
    4142        Elf_Scn *scn;
     43        uint32_t sh_type;
    4244        Elf32_Move *move32;
    4345        Elf64_Move *move64;
    44         size_t msz;
    45         uint32_t sh_type;
     46        struct _Libelf_Data *d;
     47
     48        d = (struct _Libelf_Data *) ed;
    4649
    4750        if (d == NULL || ndx < 0 || dst == NULL ||
     
    6871
    6972        assert(msz > 0);
     73        assert(ndx >= 0);
    7074
    71         if (msz * ndx >= d->d_size) {
     75        if (msz * (size_t) ndx >= d->d_data.d_size) {
    7276                LIBELF_SET_ERROR(ARGUMENT, 0);
    7377                return (NULL);
     
    7680        if (ec == ELFCLASS32) {
    7781
    78                 move32 = (Elf32_Move *) d->d_buf + ndx;
     82                move32 = (Elf32_Move *) d->d_data.d_buf + ndx;
    7983
    8084                dst->m_value   = move32->m_value;
     
    8589        } else {
    8690
    87                 move64 = (Elf64_Move *) d->d_buf + ndx;
     91                move64 = (Elf64_Move *) d->d_data.d_buf + ndx;
    8892
    8993                *dst = *move64;
     
    9498
    9599int
    96 gelf_update_move(Elf_Data *d, int ndx, GElf_Move *gm)
     100gelf_update_move(Elf_Data *ed, int ndx, GElf_Move *gm)
    97101{
    98102        int ec;
    99103        Elf *e;
     104        size_t msz;
    100105        Elf_Scn *scn;
     106        uint32_t sh_type;
    101107        Elf32_Move *move32;
    102108        Elf64_Move *move64;
    103         size_t msz;
    104         uint32_t sh_type;
     109        struct _Libelf_Data *d;
     110
     111        d = (struct _Libelf_Data *) ed;
    105112
    106113        if (d == NULL || ndx < 0 || gm == NULL ||
     
    125132
    126133        msz = _libelf_msize(ELF_T_MOVE, ec, e->e_version);
     134
    127135        assert(msz > 0);
     136        assert(ndx >= 0);
    128137
    129         if (msz * ndx >= d->d_size) {
     138        if (msz * (size_t) ndx >= d->d_data.d_size) {
    130139                LIBELF_SET_ERROR(ARGUMENT, 0);
    131140                return (0);
     
    133142
    134143        if (ec == ELFCLASS32) {
    135                 move32 = (Elf32_Move *) d->d_buf + ndx;
     144                move32 = (Elf32_Move *) d->d_data.d_buf + ndx;
    136145
    137146                move32->m_value  = gm->m_value;
     
    142151
    143152        } else {
    144                 move64 = (Elf64_Move *) d->d_buf + ndx;
     153                move64 = (Elf64_Move *) d->d_data.d_buf + ndx;
    145154
    146155                *move64 = *gm;
  • rtemstoolkit/elftoolchain/libelf/gelf_newehdr.3

    r6f48c91 r771e7f1  
    2222.\" such damage.
    2323.\"
    24 .\" $Id: gelf_newehdr.3 189 2008-07-20 10:38:08Z jkoshy $
     24.\" $Id: gelf_newehdr.3 3500 2016-12-04 11:08:44Z jkoshy $
    2525.\"
    2626.Dd October 22, 2007
     
    128128These functions return a pointer to a translated header descriptor
    129129if successful, or NULL on failure.
     130.Sh COMPATIBILITY
     131The
     132.Fn gelf_newehdr
     133function uses a type of
     134.Ft "void *"
     135for its returned value.
     136This differs from some other implementations of the ELF(3) API, which use an
     137.Ft "unsigned long"
     138return type.
    130139.Sh ERRORS
    131140These functions can fail with the following errors:
  • rtemstoolkit/elftoolchain/libelf/gelf_newphdr.3

    r6f48c91 r771e7f1  
    2222.\" such damage.
    2323.\"
    24 .\" $Id: gelf_newphdr.3 189 2008-07-20 10:38:08Z jkoshy $
     24.\" $Id: gelf_newphdr.3 3500 2016-12-04 11:08:44Z jkoshy $
    2525.\"
    2626.Dd October 22, 2007
     
    9898The functions a valid pointer if successful, or NULL in case an error
    9999was encountered.
     100.Sh COMPATIBILITY
     101The
     102.Fn gelf_newphdr
     103function uses a type of
     104.Ft "void *"
     105for its returned value.
     106This differs from some other implementations of the ELF(3) API, which use an
     107.Ft "unsigned long"
     108return type.
    100109.Sh ERRORS
    101110These functions may fail with the following errors:
  • rtemstoolkit/elftoolchain/libelf/gelf_phdr.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <gelf.h>
    3028#include <libelf.h>
     29#include <limits.h>
     30#include <stdint.h>
    3131
    3232#include "_libelf.h"
    3333
    34 LIBELF_VCSID("$Id: gelf_phdr.c 189 2008-07-20 10:38:08Z jkoshy $");
     34ELFTC_VCSID("$Id: gelf_phdr.c 3576 2017-09-14 02:15:29Z emaste $");
    3535
    3636Elf32_Phdr *
     
    5454        Elf32_Phdr *ep32;
    5555        Elf64_Phdr *ep64;
     56        size_t phnum;
    5657
    5758        if (d == NULL || e == NULL ||
    5859            ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64) ||
    59             (e->e_kind != ELF_K_ELF) || index < 0) {
     60            (e->e_kind != ELF_K_ELF) || index < 0 ||
     61            elf_getphdrnum(e, &phnum) < 0) {
     62                LIBELF_SET_ERROR(ARGUMENT, 0);
     63                return (NULL);
     64        }
     65
     66        if ((size_t)index >= phnum) {
    6067                LIBELF_SET_ERROR(ARGUMENT, 0);
    6168                return (NULL);
     
    6673                    ((ep32 = _libelf_getphdr(e, ELFCLASS32)) == NULL))
    6774                        return (NULL);
    68 
    69                 if (index >= eh32->e_phnum) {
    70                         LIBELF_SET_ERROR(ARGUMENT, 0);
    71                         return (NULL);
    72                 }
    7375
    7476                ep32 += index;
     
    8789                    (ep64 = _libelf_getphdr(e, ELFCLASS64)) == NULL)
    8890                        return (NULL);
    89 
    90                 if (index >= eh64->e_phnum) {
    91                         LIBELF_SET_ERROR(ARGUMENT, 0);
    92                         return (NULL);
    93                 }
    9491
    9592                ep64 += index;
     
    126123gelf_update_phdr(Elf *e, int ndx, GElf_Phdr *s)
    127124{
    128         int ec, phnum;
     125        int ec;
     126        size_t phnum;
    129127        void *ehdr;
    130128        Elf32_Phdr *ph32;
     
    132130
    133131        if (s == NULL || e == NULL || e->e_kind != ELF_K_ELF ||
    134             ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
     132            ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64) ||
     133            elf_getphdrnum(e, &phnum) < 0) {
    135134                LIBELF_SET_ERROR(ARGUMENT, 0);
    136135                return (0);
     
    145144                return (0);
    146145
    147         if (ec == ELFCLASS32)
    148                 phnum = ((Elf32_Ehdr *) ehdr)->e_phnum;
    149         else
    150                 phnum = ((Elf64_Ehdr *) ehdr)->e_phnum;
    151 
    152         if (ndx < 0 || ndx > phnum) {
     146        if (ndx < 0 || (size_t)ndx > phnum) {
    153147                LIBELF_SET_ERROR(ARGUMENT, 0);
    154148                return (0);
  • rtemstoolkit/elftoolchain/libelf/gelf_rel.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <assert.h>
    3028#include <gelf.h>
     29#include <limits.h>
     30#include <stdint.h>
    3131
    3232#include "_libelf.h"
    3333
    34 LIBELF_VCSID("$Id: gelf_rel.c 189 2008-07-20 10:38:08Z jkoshy $");
     34ELFTC_VCSID("$Id: gelf_rel.c 3177 2015-03-30 18:19:41Z emaste $");
    3535
    3636GElf_Rel *
    37 gelf_getrel(Elf_Data *d, int ndx, GElf_Rel *dst)
     37gelf_getrel(Elf_Data *ed, int ndx, GElf_Rel *dst)
    3838{
    3939        int ec;
    4040        Elf *e;
     41        size_t msz;
    4142        Elf_Scn *scn;
     43        uint32_t sh_type;
    4244        Elf32_Rel *rel32;
    4345        Elf64_Rel *rel64;
    44         size_t msz;
    45         uint32_t sh_type;
     46        struct _Libelf_Data *d;
     47
     48        d = (struct _Libelf_Data *) ed;
    4649
    4750        if (d == NULL || ndx < 0 || dst == NULL ||
     
    6871
    6972        assert(msz > 0);
     73        assert(ndx >= 0);
    7074
    71         if (msz * ndx >= d->d_size) {
     75        if (msz * (size_t) ndx >= d->d_data.d_size) {
    7276                LIBELF_SET_ERROR(ARGUMENT, 0);
    7377                return (NULL);
     
    7579
    7680        if (ec == ELFCLASS32) {
    77                 rel32 = (Elf32_Rel *) d->d_buf + ndx;
     81                rel32 = (Elf32_Rel *) d->d_data.d_buf + ndx;
    7882
    7983                dst->r_offset = (Elf64_Addr) rel32->r_offset;
     
    8488        } else {
    8589
    86                 rel64 = (Elf64_Rel *) d->d_buf + ndx;
     90                rel64 = (Elf64_Rel *) d->d_data.d_buf + ndx;
    8791
    8892                *dst = *rel64;
     
    9397
    9498int
    95 gelf_update_rel(Elf_Data *d, int ndx, GElf_Rel *dr)
     99gelf_update_rel(Elf_Data *ed, int ndx, GElf_Rel *dr)
    96100{
    97101        int ec;
    98102        Elf *e;
     103        size_t msz;
    99104        Elf_Scn *scn;
     105        uint32_t sh_type;
    100106        Elf32_Rel *rel32;
    101107        Elf64_Rel *rel64;
    102         size_t msz;
    103         uint32_t sh_type;
     108        struct _Libelf_Data *d;
     109
     110        d = (struct _Libelf_Data *) ed;
    104111
    105112        if (d == NULL || ndx < 0 || dr == NULL ||
     
    124131
    125132        msz = _libelf_msize(ELF_T_REL, ec, e->e_version);
     133
    126134        assert(msz > 0);
     135        assert(ndx >= 0);
    127136
    128         if (msz * ndx >= d->d_size) {
     137        if (msz * (size_t) ndx >= d->d_data.d_size) {
    129138                LIBELF_SET_ERROR(ARGUMENT, 0);
    130139                return (0);
     
    132141
    133142        if (ec == ELFCLASS32) {
    134                 rel32 = (Elf32_Rel *) d->d_buf + ndx;
     143                rel32 = (Elf32_Rel *) d->d_data.d_buf + ndx;
    135144
    136145                LIBELF_COPY_U32(rel32, dr, r_offset);
     
    141150                        return (0);
    142151                }
    143                 rel32->r_info = ELF32_R_INFO(ELF64_R_SYM(dr->r_info),
    144                     ELF64_R_TYPE(dr->r_info));
     152                rel32->r_info = ELF32_R_INFO(
     153                        (Elf32_Word) ELF64_R_SYM(dr->r_info),
     154                        (Elf32_Word) ELF64_R_TYPE(dr->r_info));
    145155        } else {
    146                 rel64 = (Elf64_Rel *) d->d_buf + ndx;
     156                rel64 = (Elf64_Rel *) d->d_data.d_buf + ndx;
    147157
    148158                *rel64 = *dr;
  • rtemstoolkit/elftoolchain/libelf/gelf_rela.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <assert.h>
    3028#include <gelf.h>
     29#include <limits.h>
     30#include <stdint.h>
    3131
    3232#include "_libelf.h"
    3333
    34 LIBELF_VCSID("$Id: gelf_rela.c 189 2008-07-20 10:38:08Z jkoshy $");
     34ELFTC_VCSID("$Id: gelf_rela.c 3177 2015-03-30 18:19:41Z emaste $");
    3535
    3636GElf_Rela *
    37 gelf_getrela(Elf_Data *d, int ndx, GElf_Rela *dst)
     37gelf_getrela(Elf_Data *ed, int ndx, GElf_Rela *dst)
    3838{
    3939        int ec;
    4040        Elf *e;
     41        size_t msz;
    4142        Elf_Scn *scn;
     43        uint32_t sh_type;
    4244        Elf32_Rela *rela32;
    4345        Elf64_Rela *rela64;
    44         size_t msz;
    45         uint32_t sh_type;
     46        struct _Libelf_Data *d;
     47
     48        d = (struct _Libelf_Data *) ed;
    4649
    4750        if (d == NULL || ndx < 0 || dst == NULL ||
     
    6871
    6972        assert(msz > 0);
     73        assert(ndx >= 0);
    7074
    71         if (msz * ndx >= d->d_size) {
     75        if (msz * (size_t) ndx >= d->d_data.d_size) {
    7276                LIBELF_SET_ERROR(ARGUMENT, 0);
    7377                return (NULL);
     
    7579
    7680        if (ec == ELFCLASS32) {
    77                 rela32 = (Elf32_Rela *) d->d_buf + ndx;
     81                rela32 = (Elf32_Rela *) d->d_data.d_buf + ndx;
    7882
    7983                dst->r_offset = (Elf64_Addr) rela32->r_offset;
     
    8589        } else {
    8690
    87                 rela64 = (Elf64_Rela *) d->d_buf + ndx;
     91                rela64 = (Elf64_Rela *) d->d_data.d_buf + ndx;
    8892
    8993                *dst = *rela64;
     
    9498
    9599int
    96 gelf_update_rela(Elf_Data *d, int ndx, GElf_Rela *dr)
     100gelf_update_rela(Elf_Data *ed, int ndx, GElf_Rela *dr)
    97101{
    98102        int ec;
    99103        Elf *e;
     104        size_t msz;
    100105        Elf_Scn *scn;
     106        uint32_t sh_type;
    101107        Elf32_Rela *rela32;
    102108        Elf64_Rela *rela64;
    103         size_t msz;
    104         uint32_t sh_type;
     109        struct _Libelf_Data *d;
     110
     111        d = (struct _Libelf_Data *) ed;
    105112
    106113        if (d == NULL || ndx < 0 || dr == NULL ||
     
    125132
    126133        msz = _libelf_msize(ELF_T_RELA, ec, e->e_version);
     134
    127135        assert(msz > 0);
     136        assert(ndx >= 0);
    128137
    129         if (msz * ndx >= d->d_size) {
     138        if (msz * (size_t) ndx >= d->d_data.d_size) {
    130139                LIBELF_SET_ERROR(ARGUMENT, 0);
    131140                return (0);
     
    133142
    134143        if (ec == ELFCLASS32) {
    135                 rela32 = (Elf32_Rela *) d->d_buf + ndx;
     144                rela32 = (Elf32_Rela *) d->d_data.d_buf + ndx;
    136145
    137146                LIBELF_COPY_U32(rela32, dr, r_offset);
     
    142151                        return (0);
    143152                }
    144                 rela32->r_info = ELF32_R_INFO(ELF64_R_SYM(dr->r_info),
    145                     ELF64_R_TYPE(dr->r_info));
     153                rela32->r_info = ELF32_R_INFO(
     154                        (Elf32_Word) ELF64_R_SYM(dr->r_info),
     155                        (Elf32_Word) ELF64_R_TYPE(dr->r_info));
    146156
    147157                LIBELF_COPY_S32(rela32, dr, r_addend);
    148158        } else {
    149                 rela64 = (Elf64_Rela *) d->d_buf + ndx;
     159                rela64 = (Elf64_Rela *) d->d_data.d_buf + ndx;
    150160
    151161                *rela64 = *dr;
  • rtemstoolkit/elftoolchain/libelf/gelf_shdr.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <assert.h>
    3028#include <gelf.h>
    3129#include <libelf.h>
     30#include <limits.h>
     31#include <stdint.h>
    3232
    3333#include "_libelf.h"
    3434
    35 LIBELF_VCSID("$Id: gelf_shdr.c 189 2008-07-20 10:38:08Z jkoshy $");
     35ELFTC_VCSID("$Id: gelf_shdr.c 3177 2015-03-30 18:19:41Z emaste $");
    3636
    3737Elf32_Shdr *
  • rtemstoolkit/elftoolchain/libelf/gelf_sym.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <assert.h>
    3028#include <gelf.h>
     29#include <limits.h>
     30#include <stdint.h>
    3131
    3232#include "_libelf.h"
    3333
    34 LIBELF_VCSID("$Id: gelf_sym.c 189 2008-07-20 10:38:08Z jkoshy $");
     34ELFTC_VCSID("$Id: gelf_sym.c 3177 2015-03-30 18:19:41Z emaste $");
    3535
    3636GElf_Sym *
    37 gelf_getsym(Elf_Data *d, int ndx, GElf_Sym *dst)
     37gelf_getsym(Elf_Data *ed, int ndx, GElf_Sym *dst)
    3838{
    3939        int ec;
    4040        Elf *e;
     41        size_t msz;
    4142        Elf_Scn *scn;
     43        uint32_t sh_type;
    4244        Elf32_Sym *sym32;
    4345        Elf64_Sym *sym64;
    44         size_t msz;
    45         uint32_t sh_type;
     46        struct _Libelf_Data *d;
     47
     48        d = (struct _Libelf_Data *) ed;
    4649
    4750        if (d == NULL || ndx < 0 || dst == NULL ||
     
    6871
    6972        assert(msz > 0);
     73        assert(ndx >= 0);
    7074
    71         if (msz * ndx >= d->d_size) {
     75        if (msz * (size_t) ndx >= d->d_data.d_size) {
    7276                LIBELF_SET_ERROR(ARGUMENT, 0);
    7377                return (NULL);
     
    7579
    7680        if (ec == ELFCLASS32) {
    77 
    78                 sym32 = (Elf32_Sym *) d->d_buf + ndx;
     81                sym32 = (Elf32_Sym *) d->d_data.d_buf + ndx;
    7982
    8083                dst->st_name  = sym32->st_name;
    8184                dst->st_value = (Elf64_Addr) sym32->st_value;
    8285                dst->st_size  = (Elf64_Xword) sym32->st_size;
    83                 dst->st_info  = ELF64_ST_INFO(ELF32_ST_BIND(sym32->st_info),
    84                     ELF32_ST_TYPE(sym32->st_info));
     86                dst->st_info  = sym32->st_info;
    8587                dst->st_other = sym32->st_other;
    8688                dst->st_shndx = sym32->st_shndx;
    8789        } else {
    88 
    89                 sym64 = (Elf64_Sym *) d->d_buf + ndx;
     90                sym64 = (Elf64_Sym *) d->d_data.d_buf + ndx;
    9091
    9192                *dst = *sym64;
     
    9697
    9798int
    98 gelf_update_sym(Elf_Data *d, int ndx, GElf_Sym *gs)
     99gelf_update_sym(Elf_Data *ed, int ndx, GElf_Sym *gs)
    99100{
    100101        int ec;
    101102        Elf *e;
     103        size_t msz;
    102104        Elf_Scn *scn;
     105        uint32_t sh_type;
    103106        Elf32_Sym *sym32;
    104107        Elf64_Sym *sym64;
    105         size_t msz;
    106         uint32_t sh_type;
     108        struct _Libelf_Data *d;
     109
     110        d = (struct _Libelf_Data *) ed;
    107111
    108112        if (d == NULL || ndx < 0 || gs == NULL ||
     
    127131
    128132        msz = _libelf_msize(ELF_T_SYM, ec, e->e_version);
     133
    129134        assert(msz > 0);
     135        assert(ndx >= 0);
    130136
    131         if (msz * ndx >= d->d_size) {
     137        if (msz * (size_t) ndx >= d->d_data.d_size) {
    132138                LIBELF_SET_ERROR(ARGUMENT, 0);
    133139                return (0);
     
    135141
    136142        if (ec == ELFCLASS32) {
    137                 sym32 = (Elf32_Sym *) d->d_buf + ndx;
     143                sym32 = (Elf32_Sym *) d->d_data.d_buf + ndx;
    138144
    139145                sym32->st_name  = gs->st_name;
     
    145151                LIBELF_COPY_U32(sym32, gs, st_size);
    146152        } else {
    147                 sym64 = (Elf64_Sym *) d->d_buf + ndx;
     153                sym64 = (Elf64_Sym *) d->d_data.d_buf + ndx;
    148154
    149155                *sym64 = *gs;
  • rtemstoolkit/elftoolchain/libelf/gelf_syminfo.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <assert.h>
    3028#include <gelf.h>
     
    3230#include "_libelf.h"
    3331
    34 LIBELF_VCSID("$Id: gelf_syminfo.c 1166 2010-09-04 00:54:36Z jkoshy $");
     32ELFTC_VCSID("$Id: gelf_syminfo.c 3174 2015-03-27 17:13:41Z emaste $");
    3533
    3634GElf_Syminfo *
    37 gelf_getsyminfo(Elf_Data *d, int ndx, GElf_Syminfo *dst)
     35gelf_getsyminfo(Elf_Data *ed, int ndx, GElf_Syminfo *dst)
    3836{
    3937        int ec;
    4038        Elf *e;
     39        size_t msz;
    4140        Elf_Scn *scn;
     41        uint32_t sh_type;
     42        struct _Libelf_Data *d;
    4243        Elf32_Syminfo *syminfo32;
    4344        Elf64_Syminfo *syminfo64;
    44         size_t msz;
    45         uint32_t sh_type;
     45
     46        d = (struct _Libelf_Data *) ed;
    4647
    4748        if (d == NULL || ndx < 0 || dst == NULL ||
     
    6869
    6970        assert(msz > 0);
     71        assert(ndx >= 0);
    7072
    71         if (msz * ndx >= d->d_size) {
     73        if (msz * (size_t) ndx >= d->d_data.d_size) {
    7274                LIBELF_SET_ERROR(ARGUMENT, 0);
    7375                return (NULL);
     
    7678        if (ec == ELFCLASS32) {
    7779
    78                 syminfo32 = (Elf32_Syminfo *) d->d_buf + ndx;
     80                syminfo32 = (Elf32_Syminfo *) d->d_data.d_buf + ndx;
    7981
    8082                dst->si_boundto = syminfo32->si_boundto;
     
    8385        } else {
    8486
    85                 syminfo64 = (Elf64_Syminfo *) d->d_buf + ndx;
     87                syminfo64 = (Elf64_Syminfo *) d->d_data.d_buf + ndx;
    8688
    8789                *dst = *syminfo64;
     
    9294
    9395int
    94 gelf_update_syminfo(Elf_Data *d, int ndx, GElf_Syminfo *gs)
     96gelf_update_syminfo(Elf_Data *ed, int ndx, GElf_Syminfo *gs)
    9597{
    9698        int ec;
    9799        Elf *e;
     100        size_t msz;
    98101        Elf_Scn *scn;
     102        uint32_t sh_type;
     103        struct _Libelf_Data *d;
    99104        Elf32_Syminfo *syminfo32;
    100105        Elf64_Syminfo *syminfo64;
    101         size_t msz;
    102         uint32_t sh_type;
     106
     107        d = (struct _Libelf_Data *) ed;
    103108
    104109        if (d == NULL || ndx < 0 || gs == NULL ||
     
    123128
    124129        msz = _libelf_msize(ELF_T_SYMINFO, ec, e->e_version);
     130
    125131        assert(msz > 0);
     132        assert(ndx >= 0);
    126133
    127         if (msz * ndx >= d->d_size) {
     134        if (msz * (size_t) ndx >= d->d_data.d_size) {
    128135                LIBELF_SET_ERROR(ARGUMENT, 0);
    129136                return (0);
     
    131138
    132139        if (ec == ELFCLASS32) {
    133                 syminfo32 = (Elf32_Syminfo *) d->d_buf + ndx;
     140                syminfo32 = (Elf32_Syminfo *) d->d_data.d_buf + ndx;
    134141
    135142                syminfo32->si_boundto  = gs->si_boundto;
     
    137144
    138145        } else {
    139                 syminfo64 = (Elf64_Syminfo *) d->d_buf + ndx;
     146                syminfo64 = (Elf64_Syminfo *) d->d_data.d_buf + ndx;
    140147
    141148                *syminfo64 = *gs;
  • rtemstoolkit/elftoolchain/libelf/gelf_symshndx.c

    r6f48c91 r771e7f1  
    2525 */
    2626
    27 #include <sys/cdefs.h>
    28 
    2927#include <assert.h>
    3028#include <gelf.h>
     
    3230#include "_libelf.h"
    3331
    34 LIBELF_VCSID("$Id: gelf_symshndx.c 189 2008-07-20 10:38:08Z jkoshy $");
     32ELFTC_VCSID("$Id: gelf_symshndx.c 3174 2015-03-27 17:13:41Z emaste $");
    3533
    3634GElf_Sym *
     
    4038        int ec;
    4139        Elf *e;
     40        size_t msz;
    4241        Elf_Scn *scn;
    43         size_t msz;
    4442        uint32_t sh_type;
     43        struct _Libelf_Data *ld, *lid;
     44
     45        ld = (struct _Libelf_Data *) d;
     46        lid = (struct _Libelf_Data *) id;
    4547
    4648        if (gelf_getsym(d, ndx, dst) == 0)
    4749                return (NULL);
    4850
    49         if (id == NULL || (scn = id->d_scn) == NULL ||
    50             (e = scn->s_elf) == NULL || (e != d->d_scn->s_elf) ||
     51        if (lid == NULL || (scn = lid->d_scn) == NULL ||
     52            (e = scn->s_elf) == NULL || (e != ld->d_scn->s_elf) ||
    5153            shindex == NULL) {
    5254                LIBELF_SET_ERROR(ARGUMENT, 0);
     
    7173
    7274        assert(msz > 0);
     75        assert(ndx >= 0);
    7376
    74         if (msz * ndx >= id->d_size) {
     77        if (msz * (size_t) ndx >= id->d_size) {
    7578                LIBELF_SET_ERROR(ARGUMENT, 0);
    7679                return (NULL);
     
    8891        int ec;
    8992        Elf *e;
     93        size_t msz;
    9094        Elf_Scn *scn;
    91         size_t msz;
    9295        uint32_t sh_type;
     96        struct _Libelf_Data *ld, *lid;
     97
     98        ld = (struct _Libelf_Data *) d;
     99        lid = (struct _Libelf_Data *) id;
    93100
    94101        if (gelf_update_sym(d, ndx, gs) == 0)
    95102                return (0);
    96103
    97         if (id == NULL || (scn = id->d_scn) == NULL ||
    98             (e = scn->s_elf) == NULL || (e != d->d_scn->s_elf)) {
     104        if (lid == NULL || (scn = lid->d_scn) == NULL ||
     105            (e = scn->s_elf) == NULL || (e != ld->d_scn->s_elf)) {
    99106                LIBELF_SET_ERROR(ARGUMENT, 0);
    100107                return (0);
     
    116123
    117124        msz = _libelf_msize(ELF_T_WORD, ec, e->e_version);
     125
    118126        assert(msz > 0);
     </