include/elf/internal.h

   1 /* ELF support for BFD.
   2    Copyright 1991, 1992, 1993, 1994, 1995, 1997, 1998, 2000, 2001, 2002,
   3    2003, 2006, 2007, 2008 Free Software Foundation, Inc.
   4
   5    Written by Fred Fish @ Cygnus Support, from information published
   6    in "UNIX System V Release 4, Programmers Guide: ANSI C and
   7    Programming Support Tools".
   8
   9 This file is part of BFD, the Binary File Descriptor library.
  10
  11 This program is free software; you can redistribute it and/or modify
  12 it under the terms of the GNU General Public License as published by
  13 the Free Software Foundation; either version 2 of the License, or
  14 (at your option) any later version.
  15
  16 This program is distributed in the hope that it will be useful,
  17 but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 GNU General Public License for more details.
  20
  21 You should have received a copy of the GNU General Public License
  22 along with this program; if not, write to the Free Software
  23 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  24
  25
  26 /* This file is part of ELF support for BFD, and contains the portions
  27    that describe how ELF is represented internally in the BFD library.
  28    I.E. it describes the in-memory representation of ELF.  It requires
  29    the elf-common.h file which contains the portions that are common to
  30    both the internal and external representations. */
  31
  32
  33 /* NOTE that these structures are not kept in the same order as they appear
  34    in the object file.  In some cases they've been reordered for more optimal
  35    packing under various circumstances.  */
  36
  37 #ifndef _ELF_INTERNAL_H
  38 #define _ELF_INTERNAL_H
  39
  40 /* Special section indices, which may show up in st_shndx fields, among
  41    other places.  */
  42
  43 #undef SHN_UNDEF
  44 #undef SHN_LORESERVE
  45 #undef SHN_LOPROC
  46 #undef SHN_HIPROC
  47 #undef SHN_LOOS
  48 #undef SHN_HIOS
  49 #undef SHN_ABS
  50 #undef SHN_COMMON
  51 #undef SHN_XINDEX
  52 #undef SHN_HIRESERVE
  53 #define SHN_UNDEF       0               /* Undefined section reference */
  54 #define SHN_LORESERVE   (-0x100u)       /* Begin range of reserved indices */
  55 #define SHN_LOPROC      (-0x100u)       /* Begin range of appl-specific */
  56 #define SHN_HIPROC      (-0xE1u)        /* End range of appl-specific */
  57 #define SHN_LOOS        (-0xE0u)        /* OS specific semantics, lo */
  58 #define SHN_HIOS        (-0xC1u)        /* OS specific semantics, hi */
  59 #define SHN_ABS         (-0xFu)         /* Associated symbol is absolute */
  60 #define SHN_COMMON      (-0xEu)         /* Associated symbol is in common */
  61 #define SHN_XINDEX      (-0x1u)         /* Section index is held elsewhere */
  62 #define SHN_HIRESERVE   (-0x1u)         /* End range of reserved indices */
  63 #define SHN_BAD         (-0x101u)       /* Used internally by bfd */
  64
  65 /* ELF Header */
  66
  67 #define EI_NIDENT       16              /* Size of e_ident[] */
  68
  69 typedef struct elf_internal_ehdr {
  70   unsigned char         e_ident[EI_NIDENT]; /* ELF "magic number" */
  71   bfd_vma               e_entry;        /* Entry point virtual address */
  72   bfd_size_type         e_phoff;        /* Program header table file offset */
  73   bfd_size_type         e_shoff;        /* Section header table file offset */
  74   unsigned long         e_version;      /* Identifies object file version */
  75   unsigned long         e_flags;        /* Processor-specific flags */
  76   unsigned short        e_type;         /* Identifies object file type */
  77   unsigned short        e_machine;      /* Specifies required architecture */
  78   unsigned int          e_ehsize;       /* ELF header size in bytes */
  79   unsigned int          e_phentsize;    /* Program header table entry size */
  80   unsigned int          e_phnum;        /* Program header table entry count */
  81   unsigned int          e_shentsize;    /* Section header table entry size */
  82   unsigned int          e_shnum;        /* Section header table entry count */
  83   unsigned int          e_shstrndx;     /* Section header string table index */
  84 } Elf_Internal_Ehdr;
  85
  86 /* Program header */
  87
  88 struct elf_internal_phdr {
  89   unsigned long p_type;                 /* Identifies program segment type */
  90   unsigned long p_flags;                /* Segment flags */
  91   bfd_vma       p_offset;               /* Segment file offset */
  92   bfd_vma       p_vaddr;                /* Segment virtual address */
  93   bfd_vma       p_paddr;                /* Segment physical address */
  94   bfd_vma       p_filesz;               /* Segment size in file */
  95   bfd_vma       p_memsz;                /* Segment size in memory */
  96   bfd_vma       p_align;                /* Segment alignment, file & memory */
  97 };
  98
  99 typedef struct elf_internal_phdr Elf_Internal_Phdr;
 100
 101 /* Section header */
 102
 103 typedef struct elf_internal_shdr {
 104   unsigned int  sh_name;                /* Section name, index in string tbl */
 105   unsigned int  sh_type;                /* Type of section */
 106   bfd_vma       sh_flags;               /* Miscellaneous section attributes */
 107   bfd_vma       sh_addr;                /* Section virtual addr at execution */
 108   file_ptr      sh_offset;              /* Section file offset */
 109   bfd_size_type sh_size;                /* Size of section in bytes */
 110   unsigned int  sh_link;                /* Index of another section */
 111   unsigned int  sh_info;                /* Additional section information */
 112   bfd_vma       sh_addralign;           /* Section alignment */
 113   bfd_size_type sh_entsize;             /* Entry size if section holds table */
 114
 115   /* The internal rep also has some cached info associated with it. */
 116   asection *    bfd_section;            /* Associated BFD section.  */
 117   unsigned char *contents;              /* Section contents.  */
 118 } Elf_Internal_Shdr;
 119
 120 /* Symbol table entry */
 121
 122 struct elf_internal_sym {
 123   bfd_vma       st_value;               /* Value of the symbol */
 124   bfd_vma       st_size;                /* Associated symbol size */
 125   unsigned long st_name;                /* Symbol name, index in string tbl */
 126   unsigned char st_info;                /* Type and binding attributes */
 127   unsigned char st_other;               /* Visibilty, and target specific */
 128   unsigned int  st_shndx;               /* Associated section index */
 129 };
 130
 131 typedef struct elf_internal_sym Elf_Internal_Sym;
 132
 133 /* Note segments */
 134
 135 typedef struct elf_internal_note {
 136   unsigned long namesz;                 /* Size of entry's owner string */
 137   unsigned long descsz;                 /* Size of the note descriptor */
 138   unsigned long type;                   /* Interpretation of the descriptor */
 139   char *        namedata;               /* Start of the name+desc data */
 140   char *        descdata;               /* Start of the desc data */
 141   bfd_vma       descpos;                /* File offset of the descdata */
 142 } Elf_Internal_Note;
 143
 144 /* Relocation Entries */
 145
 146 typedef struct elf_internal_rela {
 147   bfd_vma       r_offset;       /* Location at which to apply the action */
 148   bfd_vma       r_info;         /* Index and Type of relocation */
 149   bfd_vma       r_addend;       /* Constant addend used to compute value */
 150 } Elf_Internal_Rela;
 151
 152 /* dynamic section structure */
 153
 154 typedef struct elf_internal_dyn {
 155   /* This needs to support 64-bit values in elf64.  */
 156   bfd_vma d_tag;                /* entry tag value */
 157   union {
 158     /* This needs to support 64-bit values in elf64.  */
 159     bfd_vma     d_val;
 160     bfd_vma     d_ptr;
 161   } d_un;
 162 } Elf_Internal_Dyn;
 163
 164 /* This structure appears in a SHT_GNU_verdef section.  */
 165
 166 typedef struct elf_internal_verdef {
 167   unsigned short vd_version;    /* Version number of structure.  */
 168   unsigned short vd_flags;      /* Flags (VER_FLG_*).  */
 169   unsigned short vd_ndx;        /* Version index.  */
 170   unsigned short vd_cnt;        /* Number of verdaux entries.  */
 171   unsigned long  vd_hash;       /* Hash of name.  */
 172   unsigned long  vd_aux;        /* Offset to verdaux entries.  */
 173   unsigned long  vd_next;       /* Offset to next verdef.  */
 174
 175   /* These fields are set up when BFD reads in the structure.  FIXME:
 176      It would be cleaner to store these in a different structure.  */
 177   bfd                         *vd_bfd;          /* BFD.  */
 178   const char                  *vd_nodename;     /* Version name.  */
 179   struct elf_internal_verdef  *vd_nextdef;      /* vd_next as pointer.  */
 180   struct elf_internal_verdaux *vd_auxptr;       /* vd_aux as pointer.  */
 181   unsigned int                 vd_exp_refno;    /* Used by the linker.  */
 182 } Elf_Internal_Verdef;
 183
 184 /* This structure appears in a SHT_GNU_verdef section.  */
 185
 186 typedef struct elf_internal_verdaux {
 187   unsigned long vda_name;       /* String table offset of name.  */
 188   unsigned long vda_next;       /* Offset to next verdaux.  */
 189
 190   /* These fields are set up when BFD reads in the structure.  FIXME:
 191      It would be cleaner to store these in a different structure.  */
 192   const char *vda_nodename;                     /* vda_name as pointer.  */
 193   struct elf_internal_verdaux *vda_nextptr;     /* vda_next as pointer.  */
 194 } Elf_Internal_Verdaux;
 195
 196 /* This structure appears in a SHT_GNU_verneed section.  */
 197
 198 typedef struct elf_internal_verneed {
 199   unsigned short vn_version;    /* Version number of structure.  */
 200   unsigned short vn_cnt;        /* Number of vernaux entries.  */
 201   unsigned long  vn_file;       /* String table offset of library name.  */
 202   unsigned long  vn_aux;        /* Offset to vernaux entries.  */
 203   unsigned long  vn_next;       /* Offset to next verneed.  */
 204
 205   /* These fields are set up when BFD reads in the structure.  FIXME:
 206      It would be cleaner to store these in a different structure.  */
 207   bfd                         *vn_bfd;          /* BFD.  */
 208   const char                  *vn_filename;     /* vn_file as pointer.  */
 209   struct elf_internal_vernaux *vn_auxptr;       /* vn_aux as pointer.  */
 210   struct elf_internal_verneed *vn_nextref;      /* vn_nextref as pointer.  */
 211 } Elf_Internal_Verneed;
 212
 213 /* This structure appears in a SHT_GNU_verneed section.  */
 214
 215 typedef struct elf_internal_vernaux {
 216   unsigned long  vna_hash;      /* Hash of dependency name.  */
 217   unsigned short vna_flags;     /* Flags (VER_FLG_*).  */
 218   unsigned short vna_other;     /* Unused.  */
 219   unsigned long  vna_name;      /* String table offset to version name.  */
 220   unsigned long  vna_next;      /* Offset to next vernaux.  */
 221
 222   /* These fields are set up when BFD reads in the structure.  FIXME:
 223      It would be cleaner to store these in a different structure.  */
 224   const char                  *vna_nodename;    /* vna_name as pointer.  */
 225   struct elf_internal_vernaux *vna_nextptr;     /* vna_next as pointer.  */
 226 } Elf_Internal_Vernaux;
 227
 228 /* This structure appears in a SHT_GNU_versym section.  This is not a
 229    standard ELF structure; ELF just uses Elf32_Half.  */
 230
 231 typedef struct elf_internal_versym {
 232   unsigned short vs_vers;
 233 } Elf_Internal_Versym;
 234
 235 /* Structure for syminfo section.  */
 236 typedef struct
 237 {
 238   unsigned short int    si_boundto;
 239   unsigned short int    si_flags;
 240 } Elf_Internal_Syminfo;
 241
 242 /* This structure appears on the stack and in NT_AUXV core file notes.  */
 243 typedef struct
 244 {
 245   bfd_vma a_type;
 246   bfd_vma a_val;
 247 } Elf_Internal_Auxv;
 248
 249
 250 /* This structure is used to describe how sections should be assigned
 251    to program segments.  */
 252
 253 struct elf_segment_map
 254 {
 255   /* Next program segment.  */
 256   struct elf_segment_map *next;
 257   /* Program segment type.  */
 258   unsigned long p_type;
 259   /* Program segment flags.  */
 260   unsigned long p_flags;
 261   /* Program segment physical address.  */
 262   bfd_vma p_paddr;
 263   /* Program segment virtual address offset from section vma.  */
 264   bfd_vma p_vaddr_offset;
 265   /* Program segment alignment.  */
 266   bfd_vma p_align;
 267   /* Segment size in file and memory */
 268   bfd_vma p_size;
 269   /* Whether the p_flags field is valid; if not, the flags are based
 270      on the section flags.  */
 271   unsigned int p_flags_valid : 1;
 272   /* Whether the p_paddr field is valid; if not, the physical address
 273      is based on the section lma values.  */
 274   unsigned int p_paddr_valid : 1;
 275   /* Whether the p_align field is valid; if not, PT_LOAD segment
 276      alignment is based on the default maximum page size.  */
 277   unsigned int p_align_valid : 1;
 278   /* Whether the p_size field is valid; if not, the size are based
 279      on the section sizes.  */
 280   unsigned int p_size_valid : 1;
 281   /* Whether this segment includes the file header.  */
 282   unsigned int includes_filehdr : 1;
 283   /* Whether this segment includes the program headers.  */
 284   unsigned int includes_phdrs : 1;
 285   /* Number of sections (may be 0).  */
 286   unsigned int count;
 287   /* Sections.  Actual number of elements is in count field.  */
 288   asection *sections[1];
 289 };
 290
 291 /* .tbss is special.  It doesn't contribute memory space to normal
 292    segments and it doesn't take file space in normal segments.  */
 293 #define ELF_SECTION_SIZE(sec_hdr, segment)                      \
 294    (((sec_hdr->sh_flags & SHF_TLS) == 0                         \
 295      || sec_hdr->sh_type != SHT_NOBITS                          \
 296      || segment->p_type == PT_TLS) ? sec_hdr->sh_size : 0)
 297
 298 /* Decide if the given sec_hdr is in the given segment.  PT_TLS segment
 299    contains only SHF_TLS sections.  Only PT_LOAD, PT_GNU_RELRO and
 300    and PT_TLS segments can contain SHF_TLS sections.  */
 301 #define ELF_IS_SECTION_IN_SEGMENT(sec_hdr, segment)                     \
 302   (((((sec_hdr->sh_flags & SHF_TLS) != 0)                               \
 303      && (segment->p_type == PT_TLS                                      \
 304          || segment->p_type == PT_GNU_RELRO                             \
 305          || segment->p_type == PT_LOAD))                                \
 306     || ((sec_hdr->sh_flags & SHF_TLS) == 0                              \
 307         && segment->p_type != PT_TLS))                                  \
 308    /* Any section besides one of type SHT_NOBITS must have a file       \
 309       offset within the segment.  */                                    \
 310    && (sec_hdr->sh_type == SHT_NOBITS                                   \
 311        || ((bfd_vma) sec_hdr->sh_offset >= segment->p_offset            \
 312            && (sec_hdr->sh_offset + ELF_SECTION_SIZE(sec_hdr, segment)  \
 313                <= segment->p_offset + segment->p_filesz)))              \
 314    /* SHF_ALLOC sections must have VMAs within the segment.  Be         \
 315       careful about segments right at the end of memory.  */            \
 316    && ((sec_hdr->sh_flags & SHF_ALLOC) == 0                             \
 317        || (sec_hdr->sh_addr >= segment->p_vaddr                         \
 318            && (sec_hdr->sh_addr - segment->p_vaddr                      \
 319                + ELF_SECTION_SIZE(sec_hdr, segment) <= segment->p_memsz))))
 320
 321 /* Decide if the given sec_hdr is in the given segment in file.  */
 322 #define ELF_IS_SECTION_IN_SEGMENT_FILE(sec_hdr, segment)        \
 323   (sec_hdr->sh_size > 0                                         \
 324    && ELF_IS_SECTION_IN_SEGMENT (sec_hdr, segment))
 325
 326 /* Decide if the given sec_hdr is in the given segment in memory.  */
 327 #define ELF_IS_SECTION_IN_SEGMENT_MEMORY(sec_hdr, segment)      \
 328   (ELF_SECTION_SIZE(sec_hdr, segment) > 0                       \
 329    && ELF_IS_SECTION_IN_SEGMENT (sec_hdr, segment))
 330
 331 #endif /* _ELF_INTERNAL_H */