1 /* 2 * File: ELF.h 3 * 4 * Copyright (c) Freescale Semiconductor, Inc. All rights reserved. 5 * See included license file for license details. 6 */ 7 #if !defined(_ELF_h_) 8 #define _ELF_h_ 9 10 //! \name ELF types 11 //! Types used in ELF file structures. 12 //@{ 13 typedef uint32_t Elf32_Addr; 14 typedef uint16_t Elf32_Half; 15 typedef /*off_t*/ uint32_t Elf32_Off; 16 typedef int32_t Elf32_Sword; 17 typedef uint32_t Elf32_Word; 18 //@} 19 20 // All ELF structures are byte aligned. Any alignment padding is explicit. 21 #pragma pack(1) 22 23 //! \name File header 24 //@{ 25 26 /*! 27 * Constants for the various fields of Elf32_Ehdr.e_ident. 28 */ 29 enum { 30 EI_MAG0 = 0, 31 EI_MAG1, 32 EI_MAG2, 33 EI_MAG3, 34 EI_CLASS, 35 EI_DATA, 36 EI_VERSION, 37 EI_PAD, 38 EI_NIDENT = 16, 39 40 // Magic number. 41 ELFMAG0 = 0x7f, 42 ELFMAG1 = 'E', 43 ELFMAG2 = 'L', 44 ELFMAG3 = 'F', 45 46 // EI_CLASS 47 ELFCLASSNONE = 0, 48 ELFCLASS32 = 1, 49 ELFCLASS64 = 2, 50 51 // EI_DATA 52 ELFDATANONE = 0, 53 ELFDATA2LSB = 1, 54 ELFDATA2MSB = 2 55 }; 56 57 /*! 58 * \brief ELF file header. 59 */ 60 struct Elf32_Ehdr 61 { 62 unsigned char e_ident[EI_NIDENT]; //!< Magic number identifying the file format. 63 Elf32_Half e_type; //!< Identifies the object file format. 64 Elf32_Half e_machine; //!< Specified the architecture for the object file. 65 Elf32_Word e_version; //!< Object file version. 66 Elf32_Addr e_entry; //!< Virtual address of the entry point, or 0. 67 Elf32_Off e_phoff; //!< Program header table offset in bytes, or 0 if no program header table. 68 Elf32_Off e_shoff; //!< Section header table offset in bytes, or 0 if no section header table. 69 Elf32_Word e_flags; //!< Processor-specific flags associated with the file. 70 Elf32_Half e_ehsize; //!< The ELF header's size in bytes. 71 Elf32_Half e_phentsize; //!< Size in bytes of one entry in the program header table. 72 Elf32_Half e_phnum; //!< Number of entries in the program header table. 73 Elf32_Half e_shentsize; //!< Size in bytes of an entry in the section header table. 74 Elf32_Half e_shnum; //!< Number of entries in the section header table. 75 Elf32_Half e_shstrndx; //!< Section header table index of the section name string table. 76 }; 77 78 /*! 79 * Constants for #Elf32_Ehdr.e_type. 80 */ 81 enum { 82 ET_NONE, //!< No file type. 83 ET_REL, //!< Relocatable file. 84 ET_EXEC, //!< Executable file. 85 ET_DYN, //!< Shared object file. 86 ET_CORE, //!< Core file. 87 ET_LOPROC, //!< Low bound of processor-specific file types. 88 ET_HIPROC //!< High bound of processor-specific file types. 89 }; 90 91 /*! 92 * ARM-specific #Elf32_Ehdr.e_flags 93 */ 94 enum { 95 EF_ARM_HASENTRY = 0x02, //!< #Elf32_Ehdr.e_entry contains a program-loader entry point. 96 EF_ARM_SYMSARESORTED = 0x04, //!< Each subsection of the symbol table is sorted by symbol value. 97 EF_ARM_DYNSYMSUSESEGIDX = 0x08, //!< Symbols in dynamic symbol tables that are defined in sections included in program segment n have #Elf32_Sym.st_shndx = n + 1. 98 EF_ARM_MAPSYMSFIRST = 0x10, //!< Mapping symbols precede other local symbols in the symbol table. 99 EF_ARM_EABIMASK = 0xff000000, //!< This masks an 8-bit version number, the version of the ARM EABI to which this ELF file conforms. The current EABI version is #ARM_EABI_VERSION. 100 101 ARM_EABI_VERSION = 0x02000000 //!< Current ARM EABI version. 102 }; 103 104 //@} 105 106 //! \name Sections 107 //@{ 108 109 /*! 110 * \brief ELF section header. 111 * 112 * An object file's section header table lets one locate all the file's 113 * sections. The section header table is an array of #Elf32_Shdr structures. 114 * A section header table index is a subscript into this array. The ELF 115 * header's #Elf32_Ehdr::e_shoff member gives the byte offset from the beginning of 116 * the file to the section header table; #Elf32_Ehdr::e_shnum tells how many entries 117 * the section header table contains; #Elf32_Ehdr::e_shentsize gives the size in bytes 118 * of each entry. 119 * 120 * Some section header table indexes are reserved. An object file will not 121 * have sections for these special indexes: 122 * - #SHN_UNDEF 123 * - #SHN_LORESERVE 124 * - #SHN_LOPROC 125 * - #SHN_HIPROC 126 * - #SHN_ABS 127 * - #SHN_COMMON 128 * - #SHN_HIRESERVE 129 */ 130 struct Elf32_Shdr 131 { 132 Elf32_Word sh_name; //!< The section's name. Index into the section header string table section. 133 Elf32_Word sh_type; //!< Section type, describing the contents and semantics. 134 Elf32_Word sh_flags; //!< Section flags describing various attributes. 135 Elf32_Addr sh_addr; //!< The address at which the section will appear in the memory image, or 0. 136 Elf32_Off sh_offset; //!< Offset from beginning of the file to the first byte in the section. 137 Elf32_Word sh_size; //!< The section's size in bytes. 138 Elf32_Word sh_link; //!< Section header table link index. Interpretation depends on section type. 139 Elf32_Word sh_info; //!< Extra information about the section. Depends on section type. 140 Elf32_Word sh_addralign; //!< Address alignment constraint. Values are 0 and positive powers of 2. 141 Elf32_Word sh_entsize; //!< Size in bytes of section entries, or 0 if the section does not have fixed-size entries. 142 }; 143 144 /*! 145 * Special section indexes. 146 */ 147 enum { 148 SHN_UNDEF = 0, 149 SHN_LORESERVE = 0xff00, 150 SHN_LOPROC = 0xff00, 151 SHN_HIPROC = 0xff1f, 152 SHN_ABS = 0xfff1, //!< The symbol has an absolute value that will not change because of relocation. 153 SHN_COMMON = 0xfff2, //!< The symbol labels a common block that has not yet been allocated. 154 SHN_HIRESERVE = 0xffff 155 }; 156 157 /*! 158 * Section type constants. 159 */ 160 enum { 161 SHT_NULL = 0, 162 SHT_PROGBITS = 1, 163 SHT_SYMTAB = 2, 164 SHT_STRTAB = 3, 165 SHT_RELA = 4, 166 SHT_HASH = 5, 167 SHT_DYNAMIC = 6, 168 SHT_NOTE = 7, 169 SHT_NOBITS = 8, 170 SHT_REL = 9, 171 SHT_SHLIB = 10, 172 SHT_DYNSYM = 11 173 }; 174 175 /*! 176 * Section flag constants. 177 */ 178 enum { 179 SHF_WRITE = 0x1, //!< Section is writable. 180 SHF_ALLOC = 0x2, //!< Allocate section. 181 SHF_EXECINSTR = 0x4 //!< Section contains executable instructions. 182 }; 183 184 /*! 185 * ARM-specific section flag constants 186 */ 187 enum { 188 SHF_ENTRYSECT = 0x10000000, //!< The section contains an entry point. 189 SHF_COMDEF = 0x80000000 //!< The section may be multiply defined in the input to a link step. 190 }; 191 192 #define BSS_SECTION_NAME ".bss" 193 #define DATA_SECTION_NAME ".data" 194 #define TEXT_SECTION_NAME ".text" 195 #define SHSTRTAB_SECTION_NAME ".shstrtab" 196 #define STRTAB_SECTION_NAME ".strtab" 197 #define SYMTAB_SECTION_NAME ".symtab" 198 199 //@} 200 201 //! \name Segments 202 //@{ 203 204 /*! 205 * \brief ELF program header. 206 * 207 * An executable or shared object file's program header table is an array of 208 * structures, each describing a segment or other information the system needs 209 * to prepare the program for execution. An object file segment contains one 210 * or more sections. Program headers are meaningful only for executable and 211 * shared object files. A file specifies its own program header size with the 212 * ELF header's #Elf32_Ehdr::e_phentsize and #Elf32_Ehdr::e_phnum members. 213 */ 214 struct Elf32_Phdr 215 { 216 Elf32_Word p_type; //!< What type of segment this header describes. 217 Elf32_Off p_offset; //!< Offset in bytes from start of file to the first byte of the segment. 218 Elf32_Addr p_vaddr; //!< Virtual address at which the segment will reside in memory. 219 Elf32_Addr p_paddr; //!< Physical address, for systems where this is relevant. 220 Elf32_Word p_filesz; //!< Number of bytes of file data the segment consumes. May be zero. 221 Elf32_Word p_memsz; //!< Size in bytes of the segment in memory. May be zero. 222 Elf32_Word p_flags; //!< Flags relevant to the segment. 223 Elf32_Word p_align; //!< Alignment constraint for segment addresses. Possible values are 0 and positive powers of 2. 224 }; 225 226 /*! 227 * Segment type constants. 228 */ 229 enum { 230 PT_NULL = 0, 231 PT_LOAD = 1, 232 PT_DYNAMIC = 2, 233 PT_INTERP = 3, 234 PT_NOTE = 4, 235 PT_SHLIB = 5, 236 PT_PHDR = 6 237 }; 238 239 /*! 240 * Program header flag constants. 241 */ 242 enum { 243 PF_X = 0x1, //!< Segment is executable. 244 PF_W = 0x2, //!< Segment is writable. 245 PF_R = 0x4 //!< Segment is readable. 246 }; 247 248 //@} 249 250 //! \name Symbol table 251 //@{ 252 253 enum { 254 STN_UNDEF = 0 //!< Undefined symbol index. 255 }; 256 257 /*! 258 * \brief ELF symbol table entry. 259 * 260 * An object file's symbol table holds information needed to locate and 261 * relocate a program's symbolic definitions and references. A symbol 262 * table index is a subscript into this array. Index 0 both designates 263 * the first entry in the table and serves as the undefined symbol index. 264 */ 265 struct Elf32_Sym 266 { 267 Elf32_Word st_name; //!< Index into file's string table. 268 Elf32_Addr st_value; //!< Value associated with the symbol. Depends on context. 269 Elf32_Word st_size; //!< Size associated with symbol. 0 if the symbol has no size or an unknown size. 270 unsigned char st_info; //!< Specified the symbol's type and binding attributes. 271 unsigned char st_other; //!< Currently 0 (reserved). 272 Elf32_Half st_shndx; //!< Section header table index for this symbol. 273 }; 274 275 //! \name st_info macros 276 //! Macros for manipulating the st_info field of Elf32_Sym struct. 277 //@{ 278 #define ELF32_ST_BIND(i) ((i) >> 4) //!< Get binding attributes. 279 #define ELF32_ST_TYPE(i) ((i) & 0x0f) //!< Get symbol type. 280 #define ELF32_ST_INFO(b, t) (((b) << 4) + ((t) & 0x0f)) //!< Construct st_info value from binding attributes and symbol type. 281 //@} 282 283 /*! 284 * \brief Symbol binding attributes. 285 * 286 * These constants are mask values. 287 */ 288 enum { 289 STB_LOCAL = 0, //!< Local symbol not visible outside the object file. 290 STB_GLOBAL = 1, //!< Symbol is visible to all object files being linked together. 291 STB_WEAK = 2, //!< Like global symbols, but with lower precedence. 292 293 // Processor-specific semantics. 294 STB_LOPROC = 13, 295 STB_HIPROC = 15 296 }; 297 298 /*! 299 * \brief Symbol types. 300 */ 301 enum { 302 STT_NOTYPE = 0, //!< The symbol's type is not specified. 303 STT_OBJECT = 1, //!< The symbol is associated with a data object, such as a variable or array. 304 STT_FUNC = 2, //!< The symbol is associated with a function or other executable code. 305 STT_SECTION = 3, //!< The synmbol is associated with a section. Primarily used for relocation. 306 STT_FILE = 4, //!< A file symbol has STB_LOCAL binding, its section index is SHN_ABS, and it precedes the other STB_LOCAL symbols for the file, if it is present. 307 308 STT_LOPROC = 13, //!< Low bound of processor-specific symbol types. 309 STT_HIPROC = 15 //!< High bound of processor-specific symbol types. 310 }; 311 312 /*! 313 * GHS-specific constants 314 */ 315 enum { 316 STO_THUMB = 1 //!< This flag is set on #Elf32_Sym.st_other if the symbol is Thumb mode code. 317 }; 318 319 #define ARM_SEQUENCE_MAPSYM "$a" 320 #define DATA_SEQUENCE_MAPSYM "$d" 321 #define THUMB_SEQUENCE_MAPSYM "$t" 322 323 #define THUMB_BL_TAGSYM "$b" 324 #define FN_PTR_CONST_TAGSYM "$f" 325 #define INDIRECT_FN_CALL_TAGSYM "$p" 326 #define MAPPING_SYMBOL_COUNT_TAGSYM "$m" 327 328 //@} 329 330 #pragma pack() 331 332 #endif // _ELF_h_ 333