libelf/libelfP.h

   1 /* Internal interfaces for libelf.
   2    Copyright (C) 1998-2010 Red Hat, Inc.
   3    This file is part of Red Hat elfutils.
   4    Contributed by Ulrich Drepper <drepper@redhat.com>, 1998.
   5
   6    Red Hat elfutils is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by the
   8    Free Software Foundation; version 2 of the License.
   9
  10    Red Hat elfutils is distributed in the hope that it will be useful, but
  11    WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License along
  16    with Red Hat elfutils; if not, write to the Free Software Foundation,
  17    Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
  18
  19    In addition, as a special exception, Red Hat, Inc. gives You the
  20    additional right to link the code of Red Hat elfutils with code licensed
  21    under any Open Source Initiative certified open source license
  22    (http://www.opensource.org/licenses/index.php) which requires the
  23    distribution of source code with any binary distribution and to
  24    distribute linked combinations of the two.  Non-GPL Code permitted under
  25    this exception must only link to the code of Red Hat elfutils through
  26    those well defined interfaces identified in the file named EXCEPTION
  27    found in the source code files (the "Approved Interfaces").  The files
  28    of Non-GPL Code may instantiate templates or use macros or inline
  29    functions from the Approved Interfaces without causing the resulting
  30    work to be covered by the GNU General Public License.  Only Red Hat,
  31    Inc. may make changes or additions to the list of Approved Interfaces.
  32    Red Hat's grant of this exception is conditioned upon your not adding
  33    any new exceptions.  If you wish to add a new Approved Interface or
  34    exception, please contact Red Hat.  You must obey the GNU General Public
  35    License in all respects for all of the Red Hat elfutils code and other
  36    code used in conjunction with Red Hat elfutils except the Non-GPL Code
  37    covered by this exception.  If you modify this file, you may extend this
  38    exception to your version of the file, but you are not obligated to do
  39    so.  If you do not wish to provide this exception without modification,
  40    you must delete this exception statement from your version and license
  41    this file solely under the GPL without exception.
  42
  43    Red Hat elfutils is an included package of the Open Invention Network.
  44    An included package of the Open Invention Network is a package for which
  45    Open Invention Network licensees cross-license their patents.  No patent
  46    license is granted, either expressly or impliedly, by designation as an
  47    included package.  Should you wish to participate in the Open Invention
  48    Network licensing program, please visit www.openinventionnetwork.com
  49    <http://www.openinventionnetwork.com>.  */
  50
  51 #ifndef _LIBELFP_H
  52 #define _LIBELFP_H 1
  53
  54 #ifdef HAVE_CONFIG_H
  55 # include <config.h>
  56 #endif
  57
  58 #include <ar.h>
  59 #include <gelf.h>
  60
  61 #include <errno.h>
  62 #include <stdint.h>
  63 #include <stdio.h>
  64 #include <string.h>
  65
  66 /* gettext helper macros.  */
  67 #define _(Str) dgettext ("elfutils", Str)
  68
  69
  70 /* Helper Macros to write 32 bit and 64 bit functions.  */
  71 #define __elfw2_(Bits, Name) __elf##Bits##_##Name
  72 #define elfw2_(Bits, Name) elf##Bits##_##Name
  73 #define ElfW2_(Bits, Name) Elf##Bits##_##Name
  74 #define ELFW2_(Bits, Name) ELF##Bits##_##Name
  75 #define ELFW_(Name, Bits) Name##Bits
  76 #define __elfw2(Bits, Name) __elfw2_(Bits, Name)
  77 #define elfw2(Bits, Name) elfw2_(Bits, Name)
  78 #define ElfW2(Bits, Name) ElfW2_(Bits, Name)
  79 #define ELFW2(Bits, Name) ELFW2_(Bits, Name)
  80 #define ELFW(Name, Bits)  ELFW_(Name, Bits)
  81
  82
  83 /* Sizes of the external types, for 32 bits objects.  */
  84 #define ELF32_FSZ_ADDR   4
  85 #define ELF32_FSZ_OFF    4
  86 #define ELF32_FSZ_HALF   2
  87 #define ELF32_FSZ_WORD   4
  88 #define ELF32_FSZ_SWORD  4
  89 #define ELF32_FSZ_XWORD  8
  90 #define ELF32_FSZ_SXWORD 8
  91
  92 /* Same for 64 bits objects.  */
  93 #define ELF64_FSZ_ADDR   8
  94 #define ELF64_FSZ_OFF    8
  95 #define ELF64_FSZ_HALF   2
  96 #define ELF64_FSZ_WORD   4
  97 #define ELF64_FSZ_SWORD  4
  98 #define ELF64_FSZ_XWORD  8
  99 #define ELF64_FSZ_SXWORD 8
 100
 101
 102 /* This is an extension of the ELF_F_* enumeration.  The values here are
 103    not part of the library interface, they are only used internally.  */
 104 enum
 105 {
 106   ELF_F_MMAPPED = 0x40,
 107   ELF_F_MALLOCED = 0x80,
 108   ELF_F_FILEDATA = 0x100
 109 };
 110
 111
 112 /* Get definition of all the external types.  */
 113 #include "exttypes.h"
 114
 115
 116 /* Error values.  */
 117 enum
 118 {
 119   ELF_E_NOERROR = 0,
 120   ELF_E_UNKNOWN_ERROR,
 121   ELF_E_UNKNOWN_VERSION,
 122   ELF_E_UNKNOWN_TYPE,
 123   ELF_E_INVALID_HANDLE,
 124   ELF_E_SOURCE_SIZE,
 125   ELF_E_DEST_SIZE,
 126   ELF_E_INVALID_ENCODING,
 127   ELF_E_NOMEM,
 128   ELF_E_INVALID_FILE,
 129   ELF_E_INVALID_OP,
 130   ELF_E_NO_VERSION,
 131   ELF_E_INVALID_CMD,
 132   ELF_E_RANGE,
 133   ELF_E_ARCHIVE_FMAG,
 134   ELF_E_INVALID_ARCHIVE,
 135   ELF_E_NO_ARCHIVE,
 136   ELF_E_NO_INDEX,
 137   ELF_E_READ_ERROR,
 138   ELF_E_WRITE_ERROR,
 139   ELF_E_INVALID_CLASS,
 140   ELF_E_INVALID_INDEX,
 141   ELF_E_INVALID_OPERAND,
 142   ELF_E_INVALID_SECTION,
 143   ELF_E_INVALID_COMMAND,
 144   ELF_E_WRONG_ORDER_EHDR,
 145   ELF_E_FD_DISABLED,
 146   ELF_E_FD_MISMATCH,
 147   ELF_E_OFFSET_RANGE,
 148   ELF_E_NOT_NUL_SECTION,
 149   ELF_E_DATA_MISMATCH,
 150   ELF_E_INVALID_SECTION_HEADER,
 151   ELF_E_INVALID_DATA,
 152   ELF_E_DATA_ENCODING,
 153   ELF_E_SECTION_TOO_SMALL,
 154   ELF_E_INVALID_ALIGN,
 155   ELF_E_INVALID_SHENTSIZE,
 156   ELF_E_UPDATE_RO,
 157   ELF_E_NOFILE,
 158   ELF_E_GROUP_NOT_REL,
 159   ELF_E_INVALID_PHDR,
 160   ELF_E_NO_PHDR,
 161   ELF_E_INVALID_OFFSET,
 162   /* Keep this as the last entry.  */
 163   ELF_E_NUM
 164 };
 165
 166
 167 /* The visible `Elf_Data' type is not sufficent for some operations due
 168    to a misdesigned interface.  Extend it for internal purposes.  */
 169 typedef struct
 170 {
 171   Elf_Data d;
 172   Elf_Scn *s;
 173 } Elf_Data_Scn;
 174
 175
 176 /* List of `Elf_Data' descriptors.  This is what makes up the section
 177    contents.  */
 178 typedef struct Elf_Data_List
 179 {
 180   /* `data' *must* be the first element in the struct.  */
 181   Elf_Data_Scn data;
 182   struct Elf_Data_List *next;
 183   int flags;
 184 } Elf_Data_List;
 185
 186
 187 /* Descriptor for ELF section.  */
 188 struct Elf_Scn
 189 {
 190   /* We have to distinguish several different situations:
 191
 192      1. the section is user created.  Therefore there is no file or memory
 193         region to read the data from.  Here we have two different subcases:
 194
 195         a) data was not yet added (before the first `elf_newdata' call)
 196
 197         b) at least one data set is available
 198
 199      2. this is a section from a file/memory region.  We have to read the
 200         current content in one data block if we have to.  But we don't
 201         read the data until it is necessary.  So we have the subcases:
 202
 203         a) the section in the file has size zero (for whatever reason)
 204
 205         b) the data of the file is not (yet) read
 206
 207         c) the data is read and available.
 208
 209      In addition to this we have different data sets, the raw and the converted
 210      data.  This distinction only exists for the data read from the file.
 211      All user-added data set (all but the first when read from the file or
 212      all of them for user-create sections) are the same in both formats.
 213      We don't create the converted data before it is necessary.
 214
 215      The `data_read' element signals whether data is available in the
 216      raw format.
 217
 218      If there is data from the file/memory region or if read one data
 219      set is added the `rawdata_list_read' pointer in non-NULL and points
 220      to the last filled data set.  `raw_datalist_rear' is therefore NULL
 221      only if there is no data set at all.
 222
 223      This so far allows to distinguish all but two cases (given that the
 224      `rawdata_list' and `data_list' entries are initialized to zero) is
 225      between not yet loaded data from the file/memory region and a section
 226      with zero size and type ELF_T_BYTE.   */
 227   Elf_Data_List data_list;      /* List of data buffers.  */
 228   Elf_Data_List *data_list_rear; /* Pointer to the rear of the data list. */
 229
 230   Elf_Data_Scn rawdata;         /* Uninterpreted data of the section.  */
 231
 232   int data_read;                /* Nonzero if the section was created by the
 233                                    user or if the data from the file/memory
 234                                    is read.  */
 235   int shndx_index;              /* Index of the extended section index
 236                                    table for this symbol table (if this
 237                                    section is a symbol table).  */
 238
 239   size_t index;                 /* Index of this section.  */
 240   struct Elf *elf;              /* The underlying ELF file.  */
 241
 242   union
 243   {
 244     Elf32_Shdr *e32;            /* Pointer to 32bit section header.  */
 245     Elf64_Shdr *e64;            /* Pointer to 64bit section header.  */
 246   } shdr;
 247
 248   unsigned int shdr_flags;      /* Section header modified?  */
 249   unsigned int flags;           /* Section changed in size?  */
 250
 251   char *rawdata_base;           /* The unmodified data of the section.  */
 252   char *data_base;              /* The converted data of the section.  */
 253
 254   struct Elf_ScnList *list;     /* Pointer to the section list element the
 255                                    data is in.  */
 256 };
 257
 258
 259 /* List of section.  */
 260 typedef struct Elf_ScnList
 261 {
 262   unsigned int cnt;             /* Number of elements of 'data' used.  */
 263   unsigned int max;             /* Number of elements of 'data' allocated.  */
 264   struct Elf_ScnList *next;     /* Next block of sections.  */
 265   struct Elf_Scn data[0];       /* Section data.  */
 266 } Elf_ScnList;
 267
 268
 269 /* elf_getdata_rawchunk result.  */
 270 typedef struct Elf_Data_Chunk
 271 {
 272   Elf_Data_Scn data;
 273   union
 274   {
 275     Elf_Scn dummy_scn;
 276     struct Elf_Data_Chunk *next;
 277   };
 278 } Elf_Data_Chunk;
 279
 280
 281 /* The ELF descriptor.  */
 282 struct Elf
 283 {
 284   /* Address to which the file was mapped.  NULL if not mapped.  */
 285   void *map_address;
 286
 287   /* When created for an archive member this points to the descriptor
 288      for the archive. */
 289   Elf *parent;
 290   Elf *next;             /* Used in list of archive descriptors.  */
 291
 292   /* What kind of file is underneath (ELF file, archive...).  */
 293   Elf_Kind kind;
 294
 295   /* Command used to create this descriptor.  */
 296   Elf_Cmd cmd;
 297
 298   /* The binary class.  */
 299   unsigned int class;
 300
 301   /* The used file descriptor.  -1 if not available anymore.  */
 302   int fildes;
 303
 304   /* Offset in the archive this file starts or zero.  */
 305   off_t start_offset;
 306
 307   /* Size of the file in the archive or the entire file size, or ~0
 308      for an (yet) unknown size.  */
 309   size_t maximum_size;
 310
 311   /* Describes the way the memory was allocated and if the dirty bit is
 312      signalled it means that the whole file has to be rewritten since
 313      the layout changed.  */
 314   int flags;
 315
 316   /* Reference counting for the descriptor.  */
 317   int ref_count;
 318
 319   /* Lock to handle multithreaded programs.  */
 320   rwlock_define (,lock);
 321
 322   union
 323   {
 324     struct
 325     {
 326       /* The next fields are only useful when testing for ==/!= NULL.  */
 327       void *ehdr;
 328       void *shdr;
 329       void *phdr;
 330
 331       Elf_ScnList *scns_last;   /* Last element in the section list.
 332                                    If NULL the data has not yet been
 333                                    read from the file.  */
 334       Elf_Data_Chunk *rawchunks; /* List of elf_getdata_rawchunk results.  */
 335       unsigned int scnincr;     /* Number of sections allocate the last
 336                                    time.  */
 337       int ehdr_flags;           /* Flags (dirty) for ELF header.  */
 338       int phdr_flags;           /* Flags (dirty|malloc) for program header.  */
 339       int shdr_malloced;        /* Nonzero if shdr array was allocated.  */
 340       off64_t sizestr_offset;   /* Offset of the size string in the parent
 341                                    if this is an archive member.  */
 342     } elf;
 343
 344     struct
 345     {
 346       Elf32_Ehdr *ehdr;         /* Pointer to the ELF header.  This is
 347                                    never malloced.  */
 348       Elf32_Shdr *shdr;         /* Used when reading from a file.  */
 349       Elf32_Phdr *phdr;         /* Pointer to the program header array.  */
 350       Elf_ScnList *scns_last;   /* Last element in the section list.
 351                                    If NULL the data has not yet been
 352                                    read from the file.  */
 353       Elf_Data_Chunk *rawchunks; /* List of elf_getdata_rawchunk results.  */
 354       unsigned int scnincr;     /* Number of sections allocate the last
 355                                    time.  */
 356       int ehdr_flags;           /* Flags (dirty) for ELF header.  */
 357       int phdr_flags;           /* Flags (dirty|malloc) for program header.  */
 358       int shdr_malloced;        /* Nonzero if shdr array was allocated.  */
 359       off64_t sizestr_offset;   /* Offset of the size string in the parent
 360                                    if this is an archive member.  */
 361       Elf32_Ehdr ehdr_mem;      /* Memory used for ELF header when not
 362                                    mmaped.  */
 363       char __e32scnspad[sizeof (Elf64_Ehdr) - sizeof (Elf32_Ehdr)];
 364
 365       /* The section array.  */
 366       Elf_ScnList scns;
 367     } elf32;
 368
 369     struct
 370     {
 371       Elf64_Ehdr *ehdr;         /* Pointer to the ELF header.  This is
 372                                    never malloced.  */
 373       Elf64_Shdr *shdr;         /* Used when reading from a file.  */
 374       Elf64_Phdr *phdr;         /* Pointer to the program header array.  */
 375       Elf_ScnList *scns_last;   /* Last element in the section list.
 376                                    If NULL the data has not yet been
 377                                    read from the file.  */
 378       Elf_Data_Chunk *rawchunks; /* List of elf_getdata_rawchunk results.  */
 379       unsigned int scnincr;     /* Number of sections allocate the last
 380                                    time.  */
 381       int ehdr_flags;           /* Flags (dirty) for ELF header.  */
 382       int phdr_flags;           /* Flags (dirty|malloc) for program header.  */
 383       int shdr_malloced;        /* Nonzero if shdr array was allocated.  */
 384       off64_t sizestr_offset;   /* Offset of the size string in the parent
 385                                    if this is an archive member.  */
 386       Elf64_Ehdr ehdr_mem;      /* Memory used for ELF header when not
 387                                    mmaped.  */
 388
 389       /* The section array.  */
 390       Elf_ScnList scns;
 391     } elf64;
 392
 393     struct
 394     {
 395       Elf *children;            /* List of all descriptors for this archive. */
 396       Elf_Arsym *ar_sym;        /* Symbol table returned by elf_getarsym.  */
 397       size_t ar_sym_num;        /* Number of entries in `ar_sym'.  */
 398       char *long_names;         /* If no index is available but long names
 399                                    are used this elements points to the data.*/
 400       size_t long_names_len;    /* Length of the long name table.  */
 401       off_t offset;             /* Offset in file we are currently at.
 402                                    elf_next() advances this to the next
 403                                    member of the archive.  */
 404       Elf_Arhdr elf_ar_hdr;     /* Structure returned by 'elf_getarhdr'.  */
 405       struct ar_hdr ar_hdr;     /* Header read from file.  */
 406       char ar_name[16];         /* NUL terminated ar_name of elf_ar_hdr.  */
 407       char raw_name[17];        /* This is a buffer for the NUL terminated
 408                                    named raw_name used in the elf_ar_hdr.  */
 409     } ar;
 410   } state;
 411
 412   /* There absolutely never must be anything following the union.  */
 413 };
 414
 415 /* Type of the conversion functions.  These functions will convert the
 416    byte order.  */
 417 typedef void (*xfct_t) (void *, const void *, size_t, int);
 418
 419 /* The table with the function pointers.  */
 420 extern const xfct_t __elf_xfctstom[EV_NUM - 1][EV_NUM - 1][ELFCLASSNUM - 1][ELF_T_NUM] attribute_hidden;
 421 extern const xfct_t __elf_xfctstof[EV_NUM - 1][EV_NUM - 1][ELFCLASSNUM - 1][ELF_T_NUM] attribute_hidden;
 422
 423
 424 /* Array with sizes of the external types indexed by ELF version, binary
 425    class, and type. */
 426 extern const size_t __libelf_type_sizes[EV_NUM - 1][ELFCLASSNUM - 1][ELF_T_NUM] attribute_hidden;
 427 /* We often have to access the size for a type in the current version.  */
 428 #if EV_NUM != 2
 429 # define elf_typesize(class,type,n) \
 430   elfw2(class,fsize) (type, n, __libelf_version)
 431 #else
 432 # define elf_typesize(class,type,n) \
 433   (__libelf_type_sizes[EV_CURRENT - 1][ELFW(ELFCLASS,class) - 1][type] * n)
 434 #endif
 435
 436 /* Currently selected version of the ELF specification.  */
 437 extern unsigned int __libelf_version attribute_hidden;
 438
 439 /* The byte value used for filling gaps.  */
 440 extern int __libelf_fill_byte attribute_hidden;
 441
 442 /* Nonzero if the version was set.  */
 443 extern int __libelf_version_initialized attribute_hidden;
 444
 445 /* Index for __libelf_type_sizes et al.  */
 446 #if EV_NUM == 2
 447 # define LIBELF_EV_IDX  0
 448 #else
 449 # define LIBELF_EV_IDX  (__libelf_version - 1)
 450 #endif
 451
 452 #if !ALLOW_UNALIGNED
 453 /* Array with alignment requirements of the internal types indexed by ELF
 454    version, binary class, and type. */
 455 extern const uint_fast8_t __libelf_type_aligns[EV_NUM - 1][ELFCLASSNUM - 1][ELF_T_NUM] attribute_hidden;
 456 # define __libelf_type_align(class, type)       \
 457     (__libelf_type_aligns[LIBELF_EV_IDX][class - 1][type] ?: 1)
 458 #else
 459 # define __libelf_type_align(class, type)       1
 460 #endif
 461
 462 /* The libelf API does not have such a function but it is still useful.
 463    Get the memory size for the given type.
 464
 465    These functions cannot be marked internal since they are aliases
 466    of the export elfXX_fsize functions.*/
 467 extern size_t __elf32_msize (Elf_Type __type, size_t __count,
 468                              unsigned int __version);
 469 extern size_t __elf64_msize (Elf_Type __type, size_t __count,
 470                              unsigned int __version);
 471
 472
 473 /* Create Elf descriptor from memory image.  */
 474 extern Elf *__libelf_read_mmaped_file (int fildes, void *map_address,
 475                                        off_t offset, size_t maxsize,
 476                                        Elf_Cmd cmd, Elf *parent)
 477      internal_function;
 478
 479 /* Set error value.  */
 480 extern void __libelf_seterrno (int value) internal_function;
 481
 482 /* Get the next archive header.  */
 483 extern int __libelf_next_arhdr_wrlock (Elf *elf) internal_function;
 484
 485 /* Read all of the file associated with the descriptor.  */
 486 extern char *__libelf_readall (Elf *elf) internal_function;
 487
 488 /* Read the complete section table and convert the byte order if necessary.  */
 489 extern int __libelf_readsections (Elf *elf) internal_function;
 490
 491 /* Store the information for the raw data in the `rawdata_list' element.  */
 492 extern int __libelf_set_rawdata (Elf_Scn *scn) internal_function;
 493 extern int __libelf_set_rawdata_wrlock (Elf_Scn *scn) internal_function;
 494
 495
 496 /* Helper functions for elf_update.  */
 497 extern off_t __elf32_updatenull_wrlock (Elf *elf, int *change_bop,
 498                                         size_t shnum) internal_function;
 499 extern off_t __elf64_updatenull_wrlock (Elf *elf, int *change_bop,
 500                                         size_t shnum) internal_function;
 501
 502 extern int __elf32_updatemmap (Elf *elf, int change_bo, size_t shnum)
 503      internal_function;
 504 extern int __elf64_updatemmap (Elf *elf, int change_bo, size_t shnum)
 505      internal_function;
 506 extern int __elf32_updatefile (Elf *elf, int change_bo, size_t shnum)
 507      internal_function;
 508 extern int __elf64_updatefile (Elf *elf, int change_bo, size_t shnum)
 509      internal_function;
 510
 511
 512 /* Alias for exported functions to avoid PLT entries, and
 513    rdlock/wrlock variants of these functions.  */
 514 extern int __elf_end_internal (Elf *__elf) attribute_hidden;
 515 extern Elf *__elf_begin_internal (int __fildes, Elf_Cmd __cmd, Elf *__ref)
 516      attribute_hidden;
 517 extern Elf32_Ehdr *__elf32_getehdr_wrlock (Elf *__elf) internal_function;
 518 extern Elf64_Ehdr *__elf64_getehdr_wrlock (Elf *__elf) internal_function;
 519 extern Elf32_Ehdr *__elf32_newehdr_internal (Elf *__elf) attribute_hidden;
 520 extern Elf64_Ehdr *__elf64_newehdr_internal (Elf *__elf) attribute_hidden;
 521 extern Elf32_Phdr *__elf32_getphdr_internal (Elf *__elf) attribute_hidden;
 522 extern Elf64_Phdr *__elf64_getphdr_internal (Elf *__elf) attribute_hidden;
 523 extern Elf32_Phdr *__elf32_getphdr_wrlock (Elf *__elf) attribute_hidden;
 524 extern Elf64_Phdr *__elf64_getphdr_wrlock (Elf *__elf) attribute_hidden;
 525 extern Elf32_Phdr *__elf32_newphdr_internal (Elf *__elf, size_t __cnt)
 526      attribute_hidden;
 527 extern Elf64_Phdr *__elf64_newphdr_internal (Elf *__elf, size_t __cnt)
 528      attribute_hidden;
 529 extern Elf_Scn *__elf32_offscn_internal (Elf *__elf, Elf32_Off __offset)
 530      attribute_hidden;
 531 extern Elf_Scn *__elf64_offscn_internal (Elf *__elf, Elf64_Off __offset)
 532      attribute_hidden;
 533 extern int __elf_getphdrnum_rdlock (Elf *__elf, size_t *__dst)
 534      internal_function;
 535 extern int __elf_getshdrnum_rdlock (Elf *__elf, size_t *__dst)
 536      internal_function;
 537 extern int __elf_getshdrstrndx_internal (Elf *__elf, size_t *__dst)
 538      attribute_hidden;
 539 extern Elf32_Shdr *__elf32_getshdr_rdlock (Elf_Scn *__scn) internal_function;
 540 extern Elf64_Shdr *__elf64_getshdr_rdlock (Elf_Scn *__scn) internal_function;
 541 extern Elf32_Shdr *__elf32_getshdr_wrlock (Elf_Scn *__scn) internal_function;
 542 extern Elf64_Shdr *__elf64_getshdr_wrlock (Elf_Scn *__scn) internal_function;
 543 extern Elf_Scn *__elf_getscn_internal (Elf *__elf, size_t __index)
 544      attribute_hidden;
 545 extern Elf_Scn *__elf_nextscn_internal (Elf *__elf, Elf_Scn *__scn)
 546      attribute_hidden;
 547 extern int __elf_scnshndx_internal (Elf_Scn *__scn) attribute_hidden;
 548 extern Elf_Data *__elf_getdata_internal (Elf_Scn *__scn, Elf_Data *__data)
 549      attribute_hidden;
 550 extern Elf_Data *__elf_getdata_rdlock (Elf_Scn *__scn, Elf_Data *__data)
 551      internal_function;
 552 extern Elf_Data *__elf_rawdata_internal (Elf_Scn *__scn, Elf_Data *__data)
 553      attribute_hidden;
 554 extern char *__elf_strptr_internal (Elf *__elf, size_t __index,
 555                                     size_t __offset) attribute_hidden;
 556 extern Elf_Data *__elf32_xlatetom_internal (Elf_Data *__dest,
 557                                             const Elf_Data *__src,
 558                                             unsigned int __encode)
 559      attribute_hidden;
 560 extern Elf_Data *__elf64_xlatetom_internal (Elf_Data *__dest,
 561                                             const Elf_Data *__src,
 562                                             unsigned int __encode)
 563      attribute_hidden;
 564 extern Elf_Data *__elf32_xlatetof_internal (Elf_Data *__dest,
 565                                             const Elf_Data *__src,
 566                                             unsigned int __encode)
 567      attribute_hidden;
 568 extern Elf_Data *__elf64_xlatetof_internal (Elf_Data *__dest,
 569                                             const Elf_Data *__src,
 570                                             unsigned int __encode)
 571      attribute_hidden;
 572 extern unsigned int __elf_version_internal (unsigned int __version)
 573      attribute_hidden;
 574 extern unsigned long int __elf_hash_internal (const char *__string)
 575        __attribute__ ((__pure__, visibility ("hidden")));
 576 extern long int __elf32_checksum_internal (Elf *__elf) attribute_hidden;
 577 extern long int __elf64_checksum_internal (Elf *__elf) attribute_hidden;
 578
 579
 580 extern GElf_Ehdr *__gelf_getehdr_rdlock (Elf *__elf, GElf_Ehdr *__dest)
 581      internal_function;
 582 extern size_t __gelf_fsize_internal (Elf *__elf, Elf_Type __type,
 583                                      size_t __count, unsigned int __version)
 584      attribute_hidden;
 585 extern GElf_Shdr *__gelf_getshdr_internal (Elf_Scn *__scn, GElf_Shdr *__dst)
 586      attribute_hidden;
 587 extern GElf_Sym *__gelf_getsym_internal (Elf_Data *__data, int __ndx,
 588                                          GElf_Sym *__dst) attribute_hidden;
 589
 590
 591 extern uint32_t __libelf_crc32 (uint32_t crc, unsigned char *buf, size_t len)
 592      attribute_hidden;
 593
 594
 595 /* We often have to update a flag iff a value changed.  Make this
 596    convenient.  */
 597 #define update_if_changed(var, exp, flag) \
 598   do {                                                                        \
 599     __typeof__ (var) *_var = &(var);                                          \
 600     __typeof__ (exp) _exp = (exp);                                            \
 601     if (*_var != _exp)                                                        \
 602       {                                                                       \
 603         *_var = _exp;                                                         \
 604         (flag) |= ELF_F_DIRTY;                                                \
 605       }                                                                       \
 606   } while (0)
 607
 608 /* Align offset to 4 bytes as needed for note name and descriptor data.  */
 609 #define NOTE_ALIGN(n)   (((n) + 3) & -4U)
 610
 611 #endif  /* libelfP.h */