mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-10-31 08:16:47 +00:00
b676d9815d
ELF specification. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@108924 91177308-0d34-0410-b5e6-96231b3b80d8
541 lines
21 KiB
C++
541 lines
21 KiB
C++
//===-- llvm/Support/ELF.h - ELF constants and data structures --*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This header contains common, non-processor-specific data structures and
|
|
// constants for the ELF file format.
|
|
//
|
|
// The details of the ELF32 bits in this file are largely based on the Tool
|
|
// Interface Standard (TIS) Executable and Linking Format (ELF) Specification
|
|
// Version 1.2, May 1995. The ELF64 stuff is based on ELF-64 Object File Format
|
|
// Version 1.5, Draft 2, May 1998 as well as OpenBSD header files.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_SUPPORT_ELF_H
|
|
#define LLVM_SUPPORT_ELF_H
|
|
|
|
#include "llvm/System/DataTypes.h"
|
|
#include <cstring>
|
|
|
|
namespace llvm {
|
|
|
|
namespace ELF {
|
|
|
|
typedef uint32_t Elf32_Addr; // Program address
|
|
typedef uint16_t Elf32_Half;
|
|
typedef uint32_t Elf32_Off; // File offset
|
|
typedef int32_t Elf32_Sword;
|
|
typedef uint32_t Elf32_Word;
|
|
|
|
typedef uint64_t Elf64_Addr;
|
|
typedef uint64_t Elf64_Off;
|
|
typedef int32_t Elf64_Shalf;
|
|
typedef int32_t Elf64_Sword;
|
|
typedef uint32_t Elf64_Word;
|
|
typedef int64_t Elf64_Sxword;
|
|
typedef uint64_t Elf64_Xword;
|
|
typedef uint32_t Elf64_Half;
|
|
typedef uint16_t Elf64_Quarter;
|
|
|
|
// Object file magic string.
|
|
static const char ElfMagic[] = { 0x7f, 'E', 'L', 'F', '\0' };
|
|
|
|
// e_ident size and indices.
|
|
enum {
|
|
EI_MAG0 = 0, // File identification index.
|
|
EI_MAG1 = 1, // File identification index.
|
|
EI_MAG2 = 2, // File identification index.
|
|
EI_MAG3 = 3, // File identification index.
|
|
EI_CLASS = 4, // File class.
|
|
EI_DATA = 5, // Data encoding.
|
|
EI_VERSION = 6, // File version.
|
|
EI_OSABI = 7, // OS/ABI identification.
|
|
EI_ABIVERSION = 8, // ABI version.
|
|
EI_PAD = 9, // Start of padding bytes.
|
|
EI_NIDENT = 16 // Number of bytes in e_ident.
|
|
};
|
|
|
|
struct Elf32_Ehdr {
|
|
unsigned char e_ident[EI_NIDENT]; // ELF Identification bytes
|
|
Elf32_Half e_type; // Type of file (see ET_* below)
|
|
Elf32_Half e_machine; // Required architecture for this file (see EM_*)
|
|
Elf32_Word e_version; // Must be equal to 1
|
|
Elf32_Addr e_entry; // Address to jump to in order to start program
|
|
Elf32_Off e_phoff; // Program header table's file offset, in bytes
|
|
Elf32_Off e_shoff; // Section header table's file offset, in bytes
|
|
Elf32_Word e_flags; // Processor-specific flags
|
|
Elf32_Half e_ehsize; // Size of ELF header, in bytes
|
|
Elf32_Half e_phentsize; // Size of an entry in the program header table
|
|
Elf32_Half e_phnum; // Number of entries in the program header table
|
|
Elf32_Half e_shentsize; // Size of an entry in the section header table
|
|
Elf32_Half e_shnum; // Number of entries in the section header table
|
|
Elf32_Half e_shstrndx; // Sect hdr table index of sect name string table
|
|
bool checkMagic() const {
|
|
return (memcmp(e_ident, ElfMagic, strlen(ElfMagic))) == 0;
|
|
}
|
|
unsigned char getFileClass() const { return e_ident[EI_CLASS]; }
|
|
unsigned char getDataEncoding() const { return e_ident[EI_DATA]; }
|
|
};
|
|
|
|
// 64-bit ELF header. Fields are the same as for ELF32, but with different
|
|
// types (see above).
|
|
struct Elf64_Ehdr {
|
|
unsigned char e_ident[EI_NIDENT];
|
|
Elf64_Quarter e_type;
|
|
Elf64_Quarter e_machine;
|
|
Elf64_Half e_version;
|
|
Elf64_Addr e_entry;
|
|
Elf64_Off e_phoff;
|
|
Elf64_Off e_shoff;
|
|
Elf64_Half e_flags;
|
|
Elf64_Quarter e_ehsize;
|
|
Elf64_Quarter e_phentsize;
|
|
Elf64_Quarter e_phnum;
|
|
Elf64_Quarter e_shentsize;
|
|
Elf64_Quarter e_shnum;
|
|
Elf64_Quarter e_shstrndx;
|
|
bool checkMagic() const {
|
|
return (memcmp(e_ident, ElfMagic, strlen(ElfMagic))) == 0;
|
|
}
|
|
unsigned char getFileClass() const { return e_ident[EI_CLASS]; }
|
|
unsigned char getDataEncoding() const { return e_ident[EI_DATA]; }
|
|
};
|
|
|
|
// File types
|
|
enum {
|
|
ET_NONE = 0, // No file type
|
|
ET_REL = 1, // Relocatable file
|
|
ET_EXEC = 2, // Executable file
|
|
ET_DYN = 3, // Shared object file
|
|
ET_CORE = 4, // Core file
|
|
ET_LOPROC = 0xff00, // Beginning of processor-specific codes
|
|
ET_HIPROC = 0xffff // Processor-specific
|
|
};
|
|
|
|
// Versioning
|
|
enum {
|
|
EV_NONE = 0,
|
|
EV_CURRENT = 1
|
|
};
|
|
|
|
// Machine architectures
|
|
enum {
|
|
EM_NONE = 0, // No machine
|
|
EM_M32 = 1, // AT&T WE 32100
|
|
EM_SPARC = 2, // SPARC
|
|
EM_386 = 3, // Intel 386
|
|
EM_68K = 4, // Motorola 68000
|
|
EM_88K = 5, // Motorola 88000
|
|
EM_486 = 6, // Intel 486 (deprecated)
|
|
EM_860 = 7, // Intel 80860
|
|
EM_MIPS = 8, // MIPS R3000
|
|
EM_PPC = 20, // PowerPC
|
|
EM_PPC64 = 21, // PowerPC64
|
|
EM_ARM = 40, // ARM
|
|
EM_ALPHA = 41, // DEC Alpha
|
|
EM_SPARCV9 = 43, // SPARC V9
|
|
EM_X86_64 = 62 // AMD64
|
|
};
|
|
|
|
// Object file classes.
|
|
enum {
|
|
ELFCLASS32 = 1, // 32-bit object file
|
|
ELFCLASS64 = 2 // 64-bit object file
|
|
};
|
|
|
|
// Object file byte orderings.
|
|
enum {
|
|
ELFDATANONE = 0, // Invalid data encoding.
|
|
ELFDATA2LSB = 1, // Little-endian object file
|
|
ELFDATA2MSB = 2 // Big-endian object file
|
|
};
|
|
|
|
// OS ABI identification.
|
|
enum {
|
|
ELFOSABI_NONE = 0, // UNIX System V ABI
|
|
ELFOSABI_HPUX = 1, // HP-UX operating system
|
|
ELFOSABI_NETBSD = 2, // NetBSD
|
|
ELFOSABI_LINUX = 3, // GNU/Linux
|
|
ELFOSABI_HURD = 4, // GNU/Hurd
|
|
ELFOSABI_SOLARIS = 6, // Solaris
|
|
ELFOSABI_AIX = 7, // AIX
|
|
ELFOSABI_IRIX = 8, // IRIX
|
|
ELFOSABI_FREEBSD = 9, // FreeBSD
|
|
ELFOSABI_TRU64 = 10, // TRU64 UNIX
|
|
ELFOSABI_MODESTO = 11, // Novell Modesto
|
|
ELFOSABI_OPENBSD = 12, // OpenBSD
|
|
ELFOSABI_OPENVMS = 13, // OpenVMS
|
|
ELFOSABI_NSK = 14, // Hewlett-Packard Non-Stop Kernel
|
|
ELFOSABI_AROS = 15, // AROS
|
|
ELFOSABI_FENIXOS = 16, // FenixOS
|
|
ELFOSABI_C6000_ELFABI = 64, // Bare-metal TMS320C6000
|
|
ELFOSABI_C6000_LINUX = 65, // Linux TMS320C6000
|
|
ELFOSABI_ARM = 97, // ARM
|
|
ELFOSABI_STANDALONE = 255 // Standalone (embedded) application
|
|
};
|
|
|
|
// X86_64 relocations.
|
|
enum {
|
|
R_X86_64_NONE = 0,
|
|
R_X86_64_64 = 1,
|
|
R_X86_64_PC32 = 2,
|
|
R_X86_64_GOT32 = 3,
|
|
R_X86_64_PLT32 = 4,
|
|
R_X86_64_COPY = 5,
|
|
R_X86_64_GLOB_DAT = 6,
|
|
R_X86_64_JUMP_SLOT = 7,
|
|
R_X86_64_RELATIVE = 8,
|
|
R_X86_64_GOTPCREL = 9,
|
|
R_X86_64_32 = 10,
|
|
R_X86_64_32S = 11,
|
|
R_X86_64_16 = 12,
|
|
R_X86_64_PC16 = 13,
|
|
R_X86_64_8 = 14,
|
|
R_X86_64_PC8 = 15,
|
|
R_X86_64_DTPMOD64 = 16,
|
|
R_X86_64_DTPOFF64 = 17,
|
|
R_X86_64_TPOFF64 = 18,
|
|
R_X86_64_TLSGD = 19,
|
|
R_X86_64_TLSLD = 20,
|
|
R_X86_64_DTPOFF32 = 21,
|
|
R_X86_64_GOTTPOFF = 22,
|
|
R_X86_64_TPOFF32 = 23,
|
|
R_X86_64_PC64 = 24,
|
|
R_X86_64_GOTOFF64 = 25,
|
|
R_X86_64_GOTPC32 = 26,
|
|
R_X86_64_SIZE32 = 32,
|
|
R_X86_64_SIZE64 = 33,
|
|
R_X86_64_GOTPC32_TLSDESC = 34,
|
|
R_X86_64_TLSDESC_CALL = 35,
|
|
R_X86_64_TLSDESC = 36
|
|
};
|
|
|
|
// Section header.
|
|
struct Elf32_Shdr {
|
|
Elf32_Word sh_name; // Section name (index into string table)
|
|
Elf32_Word sh_type; // Section type (SHT_*)
|
|
Elf32_Word sh_flags; // Section flags (SHF_*)
|
|
Elf32_Addr sh_addr; // Address where section is to be loaded
|
|
Elf32_Off sh_offset; // File offset of section data, in bytes
|
|
Elf32_Word sh_size; // Size of section, in bytes
|
|
Elf32_Word sh_link; // Section type-specific header table index link
|
|
Elf32_Word sh_info; // Section type-specific extra information
|
|
Elf32_Word sh_addralign; // Section address alignment
|
|
Elf32_Word sh_entsize; // Size of records contained within the section
|
|
};
|
|
|
|
// Section header for ELF64 - same fields as ELF32, different types.
|
|
struct Elf64_Shdr {
|
|
Elf64_Half sh_name;
|
|
Elf64_Half sh_type;
|
|
Elf64_Xword sh_flags;
|
|
Elf64_Addr sh_addr;
|
|
Elf64_Off sh_offset;
|
|
Elf64_Xword sh_size;
|
|
Elf64_Half sh_link;
|
|
Elf64_Half sh_info;
|
|
Elf64_Xword sh_addralign;
|
|
Elf64_Xword sh_entsize;
|
|
};
|
|
|
|
// Special section indices.
|
|
enum {
|
|
SHN_UNDEF = 0, // Undefined, missing, irrelevant, or meaningless
|
|
SHN_LORESERVE = 0xff00, // Lowest reserved index
|
|
SHN_LOPROC = 0xff00, // Lowest processor-specific index
|
|
SHN_HIPROC = 0xff1f, // Highest processor-specific index
|
|
SHN_ABS = 0xfff1, // Symbol has absolute value; does not need relocation
|
|
SHN_COMMON = 0xfff2, // FORTRAN COMMON or C external global variables
|
|
SHN_HIRESERVE = 0xffff // Highest reserved index
|
|
};
|
|
|
|
// Section types.
|
|
enum {
|
|
SHT_NULL = 0, // No associated section (inactive entry).
|
|
SHT_PROGBITS = 1, // Program-defined contents.
|
|
SHT_SYMTAB = 2, // Symbol table.
|
|
SHT_STRTAB = 3, // String table.
|
|
SHT_RELA = 4, // Relocation entries; explicit addends.
|
|
SHT_HASH = 5, // Symbol hash table.
|
|
SHT_DYNAMIC = 6, // Information for dynamic linking.
|
|
SHT_NOTE = 7, // Information about the file.
|
|
SHT_NOBITS = 8, // Data occupies no space in the file.
|
|
SHT_REL = 9, // Relocation entries; no explicit addends.
|
|
SHT_SHLIB = 10, // Reserved.
|
|
SHT_DYNSYM = 11, // Symbol table.
|
|
SHT_INIT_ARRAY = 14, // Pointers to initialisation functions.
|
|
SHT_FINI_ARRAY = 15, // Pointers to termination functions.
|
|
SHT_PREINIT_ARRAY = 16, // Pointers to pre-init functions.
|
|
SHT_GROUP = 17, // Section group.
|
|
SHT_SYMTAB_SHNDX = 18, // Indicies for SHN_XINDEX entries.
|
|
SHT_LOOS = 0x60000000, // Lowest operating system-specific type.
|
|
SHT_HIOS = 0x6fffffff, // Highest operating system-specific type.
|
|
SHT_LOPROC = 0x70000000, // Lowest processor architecture-specific type.
|
|
SHT_HIPROC = 0x7fffffff, // Highest processor architecture-specific type.
|
|
SHT_LOUSER = 0x80000000, // Lowest type reserved for applications.
|
|
SHT_HIUSER = 0xffffffff // Highest type reserved for applications.
|
|
};
|
|
|
|
// Section flags.
|
|
enum {
|
|
SHF_WRITE = 0x1, // Section data should be writable during execution.
|
|
SHF_ALLOC = 0x2, // Section occupies memory during program execution.
|
|
SHF_EXECINSTR = 0x4, // Section contains executable machine instructions.
|
|
SHF_MASKPROC = 0xf0000000 // Bits indicating processor-specific flags.
|
|
};
|
|
|
|
// Symbol table entries for ELF32.
|
|
struct Elf32_Sym {
|
|
Elf32_Word st_name; // Symbol name (index into string table)
|
|
Elf32_Addr st_value; // Value or address associated with the symbol
|
|
Elf32_Word st_size; // Size of the symbol
|
|
unsigned char st_info; // Symbol's type and binding attributes
|
|
unsigned char st_other; // Must be zero; reserved
|
|
Elf32_Half st_shndx; // Which section (header table index) it's defined in
|
|
|
|
// These accessors and mutators correspond to the ELF32_ST_BIND,
|
|
// ELF32_ST_TYPE, and ELF32_ST_INFO macros defined in the ELF specification:
|
|
unsigned char getBinding() const { return st_info >> 4; }
|
|
unsigned char getType() const { return st_info & 0x0f; }
|
|
void setBinding(unsigned char b) { setBindingAndType(b, getType()); }
|
|
void setType(unsigned char t) { setBindingAndType(getBinding(), t); }
|
|
void setBindingAndType(unsigned char b, unsigned char t) {
|
|
st_info = (b << 4) + (t & 0x0f);
|
|
}
|
|
};
|
|
|
|
// Symbol table entries for ELF64.
|
|
struct Elf64_Sym {
|
|
Elf64_Word st_name; // Symbol name (index into string table)
|
|
unsigned char st_info; // Symbol's type and binding attributes
|
|
unsigned char st_other; // Must be zero; reserved
|
|
Elf64_Half st_shndx; // Which section (header table index) it's defined in
|
|
Elf64_Addr st_value; // Value or address associated with the symbol
|
|
Elf64_Xword st_size; // Size of the symbol
|
|
|
|
// These accessors and mutators are identical to those defined for ELF32
|
|
// symbol table entries.
|
|
unsigned char getBinding() const { return st_info >> 4; }
|
|
unsigned char getType() const { return st_info & 0x0f; }
|
|
void setBinding(unsigned char b) { setBindingAndType(b, getType()); }
|
|
void setType(unsigned char t) { setBindingAndType(getBinding(), t); }
|
|
void setBindingAndType(unsigned char b, unsigned char t) {
|
|
st_info = (b << 4) + (t & 0x0f);
|
|
}
|
|
};
|
|
|
|
// Symbol bindings.
|
|
enum {
|
|
STB_LOCAL = 0, // Local symbol, not visible outside obj file containing def
|
|
STB_GLOBAL = 1, // Global symbol, visible to all object files being combined
|
|
STB_WEAK = 2, // Weak symbol, like global but lower-precedence
|
|
STB_LOPROC = 13, // Lowest processor-specific binding type
|
|
STB_HIPROC = 15 // Highest processor-specific binding type
|
|
};
|
|
|
|
// Symbol types.
|
|
enum {
|
|
STT_NOTYPE = 0, // Symbol's type is not specified
|
|
STT_OBJECT = 1, // Symbol is a data object (variable, array, etc.)
|
|
STT_FUNC = 2, // Symbol is executable code (function, etc.)
|
|
STT_SECTION = 3, // Symbol refers to a section
|
|
STT_FILE = 4, // Local, absolute symbol that refers to a file
|
|
STT_COMMON = 5, // An uninitialised common block
|
|
STT_TLS = 6, // Thread local data object
|
|
STT_LOPROC = 13, // Lowest processor-specific symbol type
|
|
STT_HIPROC = 15 // Highest processor-specific symbol type
|
|
};
|
|
|
|
enum {
|
|
STV_DEFAULT = 0, // Visibility is specified by binding type
|
|
STV_INTERNAL = 1, // Defined by processor supplements
|
|
STV_HIDDEN = 2, // Not visible to other components
|
|
STV_PROTECTED = 3 // Visible in other components but not preemptable
|
|
};
|
|
|
|
// Relocation entry, without explicit addend.
|
|
struct Elf32_Rel {
|
|
Elf32_Addr r_offset; // Location (file byte offset, or program virtual addr)
|
|
Elf32_Word r_info; // Symbol table index and type of relocation to apply
|
|
|
|
// These accessors and mutators correspond to the ELF32_R_SYM, ELF32_R_TYPE,
|
|
// and ELF32_R_INFO macros defined in the ELF specification:
|
|
Elf32_Word getSymbol() const { return (r_info >> 8); }
|
|
unsigned char getType() const { return (unsigned char) (r_info & 0x0ff); }
|
|
void setSymbol(Elf32_Word s) { setSymbolAndType(s, getType()); }
|
|
void setType(unsigned char t) { setSymbolAndType(getSymbol(), t); }
|
|
void setSymbolAndType(Elf32_Word s, unsigned char t) {
|
|
r_info = (s << 8) + t;
|
|
}
|
|
};
|
|
|
|
// Relocation entry with explicit addend.
|
|
struct Elf32_Rela {
|
|
Elf32_Addr r_offset; // Location (file byte offset, or program virtual addr)
|
|
Elf32_Word r_info; // Symbol table index and type of relocation to apply
|
|
Elf32_Sword r_addend; // Compute value for relocatable field by adding this
|
|
|
|
// These accessors and mutators correspond to the ELF32_R_SYM, ELF32_R_TYPE,
|
|
// and ELF32_R_INFO macros defined in the ELF specification:
|
|
Elf32_Word getSymbol() const { return (r_info >> 8); }
|
|
unsigned char getType() const { return (unsigned char) (r_info & 0x0ff); }
|
|
void setSymbol(Elf32_Word s) { setSymbolAndType(s, getType()); }
|
|
void setType(unsigned char t) { setSymbolAndType(getSymbol(), t); }
|
|
void setSymbolAndType(Elf32_Word s, unsigned char t) {
|
|
r_info = (s << 8) + t;
|
|
}
|
|
};
|
|
|
|
// Relocation entry, without explicit addend.
|
|
struct Elf64_Rel {
|
|
Elf64_Addr r_offset; // Location (file byte offset, or program virtual addr).
|
|
Elf64_Xword r_info; // Symbol table index and type of relocation to apply.
|
|
|
|
// These accessors and mutators correspond to the ELF64_R_SYM, ELF64_R_TYPE,
|
|
// and ELF64_R_INFO macros defined in the ELF specification:
|
|
Elf64_Xword getSymbol() const { return (r_info >> 32); }
|
|
unsigned char getType() const {
|
|
return (unsigned char) (r_info & 0xffffffffL);
|
|
}
|
|
void setSymbol(Elf32_Word s) { setSymbolAndType(s, getType()); }
|
|
void setType(unsigned char t) { setSymbolAndType(getSymbol(), t); }
|
|
void setSymbolAndType(Elf64_Xword s, unsigned char t) {
|
|
r_info = (s << 32) + (t&0xffffffffL);
|
|
}
|
|
};
|
|
|
|
// Relocation entry with explicit addend.
|
|
struct Elf64_Rela {
|
|
Elf64_Addr r_offset; // Location (file byte offset, or program virtual addr).
|
|
Elf64_Xword r_info; // Symbol table index and type of relocation to apply.
|
|
Elf64_Sxword r_addend; // Compute value for relocatable field by adding this.
|
|
|
|
// These accessors and mutators correspond to the ELF64_R_SYM, ELF64_R_TYPE,
|
|
// and ELF64_R_INFO macros defined in the ELF specification:
|
|
Elf64_Xword getSymbol() const { return (r_info >> 32); }
|
|
unsigned char getType() const {
|
|
return (unsigned char) (r_info & 0xffffffffL);
|
|
}
|
|
void setSymbol(Elf64_Xword s) { setSymbolAndType(s, getType()); }
|
|
void setType(unsigned char t) { setSymbolAndType(getSymbol(), t); }
|
|
void setSymbolAndType(Elf64_Xword s, unsigned char t) {
|
|
r_info = (s << 32) + (t&0xffffffffL);
|
|
}
|
|
};
|
|
|
|
// Program header for ELF32.
|
|
struct Elf32_Phdr {
|
|
Elf32_Word p_type; // Type of segment
|
|
Elf32_Off p_offset; // File offset where segment is located, in bytes
|
|
Elf32_Addr p_vaddr; // Virtual address of beginning of segment
|
|
Elf32_Addr p_paddr; // Physical address of beginning of segment (OS-specific)
|
|
Elf32_Word p_filesz; // Num. of bytes in file image of segment (may be zero)
|
|
Elf32_Word p_memsz; // Num. of bytes in mem image of segment (may be zero)
|
|
Elf32_Word p_flags; // Segment flags
|
|
Elf32_Word p_align; // Segment alignment constraint
|
|
};
|
|
|
|
// Program header for ELF64.
|
|
struct Elf64_Phdr {
|
|
Elf64_Word p_type; // Type of segment
|
|
Elf64_Word p_flags; // Segment flags
|
|
Elf64_Off p_offset; // File offset where segment is located, in bytes
|
|
Elf64_Addr p_vaddr; // Virtual address of beginning of segment
|
|
Elf64_Addr p_paddr; // Physical address of beginning of segment (OS-specific)
|
|
Elf64_Xword p_filesz; // Num. of bytes in file image of segment (may be zero)
|
|
Elf64_Xword p_memsz; // Num. of bytes in mem image of segment (may be zero)
|
|
Elf64_Xword p_align; // Segment alignment constraint
|
|
};
|
|
|
|
// Segment types.
|
|
enum {
|
|
PT_NULL = 0, // Unused segment.
|
|
PT_LOAD = 1, // Loadable segment.
|
|
PT_DYNAMIC = 2, // Dynamic linking information.
|
|
PT_INTERP = 3, // Interpreter pathname.
|
|
PT_NOTE = 4, // Auxiliary information.
|
|
PT_SHLIB = 5, // Reserved.
|
|
PT_PHDR = 6, // The program header table itself.
|
|
PT_LOPROC = 0x70000000, // Lowest processor-specific program hdr entry type.
|
|
PT_HIPROC = 0x7fffffff // Highest processor-specific program hdr entry type.
|
|
};
|
|
|
|
// Segment flag bits.
|
|
enum {
|
|
PF_X = 1, // Execute
|
|
PF_W = 2, // Write
|
|
PF_R = 4, // Read
|
|
PF_MASKPROC = 0xf0000000 // Unspecified
|
|
};
|
|
|
|
// Dynamic table entry for ELF32.
|
|
struct Elf32_Dyn
|
|
{
|
|
Elf32_Sword d_tag; // Type of dynamic table entry.
|
|
union
|
|
{
|
|
Elf32_Word d_val; // Integer value of entry.
|
|
Elf32_Addr d_ptr; // Pointer value of entry.
|
|
} d_un;
|
|
};
|
|
|
|
// Dynamic table entry for ELF64.
|
|
struct Elf64_Dyn
|
|
{
|
|
Elf64_Sxword d_tag; // Type of dynamic table entry.
|
|
union
|
|
{
|
|
Elf64_Xword d_val; // Integer value of entry.
|
|
Elf64_Addr d_ptr; // Pointer value of entry.
|
|
} d_un;
|
|
};
|
|
|
|
// Dynamic table entry tags.
|
|
enum {
|
|
DT_NULL = 0, // Marks end of dynamic array.
|
|
DT_NEEDED = 1, // String table offset of needed library.
|
|
DT_PLTRELSZ = 2, // Size of relocation entries in PLT.
|
|
DT_PLTGOT = 3, // Address associated with linkage table.
|
|
DT_HASH = 4, // Address of symbolic hash table.
|
|
DT_STRTAB = 5, // Address of dynamic string table.
|
|
DT_SYMTAB = 6, // Address of dynamic symbol table.
|
|
DT_RELA = 7, // Address of relocation table (Rela entries).
|
|
DT_RELASZ = 8, // Size of Rela relocation table.
|
|
DT_RELAENT = 9, // Size of a Rela relocation entry.
|
|
DT_STRSZ = 10, // Total size of the string table.
|
|
DT_SYMENT = 11, // Size of a symbol table entry.
|
|
DT_INIT = 12, // Address of initialization function.
|
|
DT_FINI = 13, // Address of termination function.
|
|
DT_SONAME = 14, // String table offset of a shared objects name.
|
|
DT_RPATH = 15, // String table offset of library search path.
|
|
DT_SYMBOLIC = 16, // Changes symbol resolution algorithm.
|
|
DT_REL = 17, // Address of relocation table (Rel entries).
|
|
DT_RELSZ = 18, // Size of Rel relocation table.
|
|
DT_RELENT = 19, // Size of a Rel relocation entry.
|
|
DT_PLTREL = 20, // Type of relocation entry used for linking.
|
|
DT_DEBUG = 21, // Reserved for debugger.
|
|
DT_TEXTREL = 22, // Relocations exist for non-writable segements.
|
|
DT_JMPREL = 23, // Address of relocations associated with PLT.
|
|
DT_BIND_NOW = 24, // Process all relocations before execution.
|
|
DT_INIT_ARRAY = 25, // Pointer to array of initialization functions.
|
|
DT_FINI_ARRAY = 26, // Pointer to array of termination functions.
|
|
DT_INIT_ARRAYSZ = 27, // Size of DT_INIT_ARRAY.
|
|
DT_FINI_ARRAYSZ = 28, // Size of DT_FINI_ARRAY.
|
|
DT_LOOS = 0x60000000, // Start of environment specific tags.
|
|
DT_HIOS = 0x6FFFFFFF, // End of environment specific tags.
|
|
DT_LOPROC = 0x70000000, // Start of processor specific tags.
|
|
DT_HIPROC = 0x7FFFFFFF // End of processor specific tags.
|
|
};
|
|
|
|
} // end namespace ELF
|
|
|
|
} // end namespace llvm
|
|
|
|
#endif
|