ELF.h revision 5af8f421b6412e52530608097e39d2602195629f
1//===-- llvm/Support/ELF.h - ELF constants and data structures --*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This header contains common, non-processor-specific data structures and 11// constants for the ELF file format. 12// 13// The details of the ELF32 bits in this file are largely based on 14// the Tool Interface Standard (TIS) Executable and Linking Format 15// (ELF) Specification Version 1.2, May 1995. The ELF64 stuff is not 16// standardized, as far as I can tell. It was largely based on information 17// I found in OpenBSD header files. 18// 19//===----------------------------------------------------------------------===// 20 21#ifndef LLVM_SUPPORT_ELF_H 22#define LLVM_SUPPORT_ELF_H 23 24#include "llvm/System/DataTypes.h" 25#include <cstring> 26 27namespace llvm { 28 29namespace ELF { 30 31typedef uint32_t Elf32_Addr; // Program address 32typedef uint16_t Elf32_Half; 33typedef uint32_t Elf32_Off; // File offset 34typedef int32_t Elf32_Sword; 35typedef uint32_t Elf32_Word; 36 37typedef uint64_t Elf64_Addr; 38typedef uint64_t Elf64_Off; 39typedef int32_t Elf64_Shalf; 40typedef int32_t Elf64_Sword; 41typedef uint32_t Elf64_Word; 42typedef int64_t Elf64_Sxword; 43typedef uint64_t Elf64_Xword; 44typedef uint32_t Elf64_Half; 45typedef uint16_t Elf64_Quarter; 46 47// Object file magic string. 48static const char ElfMagic[] = { 0x7f, 'E', 'L', 'F', '\0' }; 49 50struct Elf32_Ehdr { 51 unsigned char e_ident[16]; // ELF Identification bytes 52 Elf32_Half e_type; // Type of file (see ET_* below) 53 Elf32_Half e_machine; // Required architecture for this file (see EM_*) 54 Elf32_Word e_version; // Must be equal to 1 55 Elf32_Addr e_entry; // Address to jump to in order to start program 56 Elf32_Off e_phoff; // Program header table's file offset, in bytes 57 Elf32_Off e_shoff; // Section header table's file offset, in bytes 58 Elf32_Word e_flags; // Processor-specific flags 59 Elf32_Half e_ehsize; // Size of ELF header, in bytes 60 Elf32_Half e_phentsize; // Size of an entry in the program header table 61 Elf32_Half e_phnum; // Number of entries in the program header table 62 Elf32_Half e_shentsize; // Size of an entry in the section header table 63 Elf32_Half e_shnum; // Number of entries in the section header table 64 Elf32_Half e_shstrndx; // Sect hdr table index of sect name string table 65 bool checkMagic () const { 66 return (memcmp (e_ident, ElfMagic, strlen (ElfMagic))) == 0; 67 } 68 unsigned char getFileClass () const { return e_ident[4]; } 69 unsigned char getDataEncoding () { return e_ident[5]; } 70}; 71 72// 64-bit ELF header. Fields are the same as for ELF32, but with different 73// types (see above). 74struct Elf64_Ehdr { 75 unsigned char e_ident[16]; 76 Elf64_Quarter e_type; 77 Elf64_Quarter e_machine; 78 Elf64_Half e_version; 79 Elf64_Addr e_entry; 80 Elf64_Off e_phoff; 81 Elf64_Off e_shoff; 82 Elf64_Half e_flags; 83 Elf64_Quarter e_ehsize; 84 Elf64_Quarter e_phentsize; 85 Elf64_Quarter e_phnum; 86 Elf64_Quarter e_shentsize; 87 Elf64_Quarter e_shnum; 88 Elf64_Quarter e_shstrndx; 89}; 90 91// File types 92enum { 93 ET_NONE = 0, // No file type 94 ET_REL = 1, // Relocatable file 95 ET_EXEC = 2, // Executable file 96 ET_DYN = 3, // Shared object file 97 ET_CORE = 4, // Core file 98 ET_LOPROC = 0xff00, // Beginning of processor-specific codes 99 ET_HIPROC = 0xffff // Processor-specific 100}; 101 102// Versioning 103enum { 104 EV_NONE = 0, 105 EV_CURRENT = 1 106}; 107 108// Machine architectures 109enum { 110 EM_NONE = 0, // No machine 111 EM_M32 = 1, // AT&T WE 32100 112 EM_SPARC = 2, // SPARC 113 EM_386 = 3, // Intel 386 114 EM_68K = 4, // Motorola 68000 115 EM_88K = 5, // Motorola 88000 116 EM_486 = 6, // Intel 486 (deprecated) 117 EM_860 = 7, // Intel 80860 118 EM_MIPS = 8, // MIPS R3000 119 EM_PPC = 20, // PowerPC 120 EM_ARM = 40, // ARM 121 EM_ALPHA = 41, // DEC Alpha 122 EM_SPARCV9 = 43, // SPARC V9 123 EM_X86_64 = 62 // AMD64 124}; 125 126// Object file classes. 127enum { 128 ELFCLASS32 = 1, // 32-bit object file 129 ELFCLASS64 = 2 // 64-bit object file 130}; 131 132// Object file byte orderings. 133enum { 134 ELFDATA2LSB = 1, // Little-endian object file 135 ELFDATA2MSB = 2 // Big-endian object file 136}; 137 138// OS ABI identification -- unused. 139enum { 140 ELFOSABI_NONE = 0 141}; 142 143// Section header. 144struct Elf32_Shdr { 145 Elf32_Word sh_name; // Section name (index into string table) 146 Elf32_Word sh_type; // Section type (SHT_*) 147 Elf32_Word sh_flags; // Section flags (SHF_*) 148 Elf32_Addr sh_addr; // Address where section is to be loaded 149 Elf32_Off sh_offset; // File offset of section data, in bytes 150 Elf32_Word sh_size; // Size of section, in bytes 151 Elf32_Word sh_link; // Section type-specific header table index link 152 Elf32_Word sh_info; // Section type-specific extra information 153 Elf32_Word sh_addralign; // Section address alignment 154 Elf32_Word sh_entsize; // Size of records contained within the section 155}; 156 157// Section header for ELF64 - same fields as ELF32, different types. 158struct Elf64_Shdr { 159 Elf64_Half sh_name; 160 Elf64_Half sh_type; 161 Elf64_Xword sh_flags; 162 Elf64_Addr sh_addr; 163 Elf64_Off sh_offset; 164 Elf64_Xword sh_size; 165 Elf64_Half sh_link; 166 Elf64_Half sh_info; 167 Elf64_Xword sh_addralign; 168 Elf64_Xword sh_entsize; 169}; 170 171// Special section indices. 172enum { 173 SHN_UNDEF = 0, // Undefined, missing, irrelevant, or meaningless 174 SHN_LORESERVE = 0xff00, // Lowest reserved index 175 SHN_LOPROC = 0xff00, // Lowest processor-specific index 176 SHN_HIPROC = 0xff1f, // Highest processor-specific index 177 SHN_ABS = 0xfff1, // Symbol has absolute value; does not need relocation 178 SHN_COMMON = 0xfff2, // FORTRAN COMMON or C external global variables 179 SHN_HIRESERVE = 0xffff // Highest reserved index 180}; 181 182// Section types. 183enum { 184 SHT_NULL = 0, // No associated section (inactive entry). 185 SHT_PROGBITS = 1, // Program-defined contents. 186 SHT_SYMTAB = 2, // Symbol table. 187 SHT_STRTAB = 3, // String table. 188 SHT_RELA = 4, // Relocation entries; explicit addends. 189 SHT_HASH = 5, // Symbol hash table. 190 SHT_DYNAMIC = 6, // Information for dynamic linking. 191 SHT_NOTE = 7, // Information about the file. 192 SHT_NOBITS = 8, // Data occupies no space in the file. 193 SHT_REL = 9, // Relocation entries; no explicit addends. 194 SHT_SHLIB = 10, // Reserved. 195 SHT_DYNSYM = 11, // Symbol table. 196 SHT_LOPROC = 0x70000000, // Lowest processor architecture-specific type. 197 SHT_HIPROC = 0x7fffffff, // Highest processor architecture-specific type. 198 SHT_LOUSER = 0x80000000, // Lowest type reserved for applications. 199 SHT_HIUSER = 0xffffffff // Highest type reserved for applications. 200}; 201 202// Section flags. 203enum { 204 SHF_WRITE = 0x1, // Section data should be writable during execution. 205 SHF_ALLOC = 0x2, // Section occupies memory during program execution. 206 SHF_EXECINSTR = 0x4, // Section contains executable machine instructions. 207 SHF_MASKPROC = 0xf0000000 // Bits indicating processor-specific flags. 208}; 209 210// Symbol table entries. 211struct Elf32_Sym { 212 Elf32_Word st_name; // Symbol name (index into string table) 213 Elf32_Addr st_value; // Value or address associated with the symbol 214 Elf32_Word st_size; // Size of the symbol 215 unsigned char st_info; // Symbol's type and binding attributes 216 unsigned char st_other; // Must be zero; reserved 217 Elf32_Half st_shndx; // Which section (header table index) it's defined in 218 219 // These accessors and mutators correspond to the ELF32_ST_BIND, 220 // ELF32_ST_TYPE, and ELF32_ST_INFO macros defined in the ELF specification: 221 unsigned char getBinding () const { return st_info >> 4; } 222 unsigned char getType () const { return st_info & 0x0f; } 223 void setBinding (unsigned char b) { setBindingAndType (b, getType ()); } 224 void setType (unsigned char t) { setBindingAndType (getBinding (), t); } 225 void setBindingAndType (unsigned char b, unsigned char t) { 226 st_info = (b << 4) + (t & 0x0f); 227 } 228}; 229 230// Symbol bindings. 231enum { 232 STB_LOCAL = 0, // Local symbol, not visible outside obj file containing def 233 STB_GLOBAL = 1, // Global symbol, visible to all object files being combined 234 STB_WEAK = 2, // Weak symbol, like global but lower-precedence 235 STB_LOPROC = 13, // Lowest processor-specific binding type 236 STB_HIPROC = 15 // Highest processor-specific binding type 237}; 238 239// Symbol types. 240enum { 241 STT_NOTYPE = 0, // Symbol's type is not specified 242 STT_OBJECT = 1, // Symbol is a data object (variable, array, etc.) 243 STT_FUNC = 2, // Symbol is executable code (function, etc.) 244 STT_SECTION = 3, // Symbol refers to a section 245 STT_FILE = 4, // Local, absolute symbol that refers to a file 246 STT_LOPROC = 13, // Lowest processor-specific symbol type 247 STT_HIPROC = 15 // Highest processor-specific symbol type 248}; 249 250// Relocation entry, without explicit addend. 251struct Elf32_Rel { 252 Elf32_Addr r_offset; // Location (file byte offset, or program virtual addr) 253 Elf32_Word r_info; // Symbol table index and type of relocation to apply 254 255 // These accessors and mutators correspond to the ELF32_R_SYM, ELF32_R_TYPE, 256 // and ELF32_R_INFO macros defined in the ELF specification: 257 Elf32_Word getSymbol () const { return (r_info >> 8); } 258 unsigned char getType () const { return (unsigned char) (r_info & 0x0ff); } 259 void setSymbol (Elf32_Word s) { setSymbolAndType (s, getType ()); } 260 void setType (unsigned char t) { setSymbolAndType (getSymbol(), t); } 261 void setSymbolAndType (Elf32_Word s, unsigned char t) { 262 r_info = (s << 8) + t; 263 }; 264}; 265 266// Relocation entry with explicit addend. 267struct Elf32_Rela { 268 Elf32_Addr r_offset; // Location (file byte offset, or program virtual addr) 269 Elf32_Word r_info; // Symbol table index and type of relocation to apply 270 Elf32_Sword r_addend; // Compute value for relocatable field by adding this 271 272 // These accessors and mutators correspond to the ELF32_R_SYM, ELF32_R_TYPE, 273 // and ELF32_R_INFO macros defined in the ELF specification: 274 Elf32_Word getSymbol () const { return (r_info >> 8); } 275 unsigned char getType () const { return (unsigned char) (r_info & 0x0ff); } 276 void setSymbol (Elf32_Word s) { setSymbolAndType (s, getType ()); } 277 void setType (unsigned char t) { setSymbolAndType (getSymbol(), t); } 278 void setSymbolAndType (Elf32_Word s, unsigned char t) { 279 r_info = (s << 8) + t; 280 }; 281}; 282 283// Program header. 284struct Elf32_Phdr { 285 Elf32_Word p_type; // Type of segment 286 Elf32_Off p_offset; // File offset where segment is located, in bytes 287 Elf32_Addr p_vaddr; // Virtual address of beginning of segment 288 Elf32_Addr p_paddr; // Physical address of beginning of segment (OS-specific) 289 Elf32_Word p_filesz; // Num. of bytes in file image of segment (may be zero) 290 Elf32_Word p_memsz; // Num. of bytes in mem image of segment (may be zero) 291 Elf32_Word p_flags; // Segment flags 292 Elf32_Word p_align; // Segment alignment constraint 293}; 294 295// Segment types. 296enum { 297 PT_NULL = 0, // Unused segment. 298 PT_LOAD = 1, // Loadable segment. 299 PT_DYNAMIC = 2, // Dynamic linking information. 300 PT_INTERP = 3, // Interpreter pathname. 301 PT_NOTE = 4, // Auxiliary information. 302 PT_SHLIB = 5, // Reserved. 303 PT_PHDR = 6, // The program header table itself. 304 PT_LOPROC = 0x70000000, // Lowest processor-specific program hdr entry type. 305 PT_HIPROC = 0x7fffffff // Highest processor-specific program hdr entry type. 306}; 307 308// Segment flag bits. 309enum { 310 PF_X = 1, // Execute 311 PF_W = 2, // Write 312 PF_R = 4, // Read 313 PF_MASKPROC = 0xf0000000 // Unspecified 314}; 315 316} // end namespace ELF 317 318} // end namespace llvm 319 320#endif 321