LCOV - code coverage report
Current view: top level - include/llvm/BinaryFormat - ELF.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 6 6 100.0 %
Date: 2018-05-20 00:06:23 Functions: 0 0 -
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- llvm/BinaryFormat/ELF.h - ELF constants and 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 the Tool
      14             : // Interface Standard (TIS) Executable and Linking Format (ELF) Specification
      15             : // Version 1.2, May 1995. The ELF64 stuff is based on ELF-64 Object File Format
      16             : // Version 1.5, Draft 2, May 1998 as well as OpenBSD header files.
      17             : //
      18             : //===----------------------------------------------------------------------===//
      19             : 
      20             : #ifndef LLVM_BINARYFORMAT_ELF_H
      21             : #define LLVM_BINARYFORMAT_ELF_H
      22             : 
      23             : #include <cstdint>
      24             : #include <cstring>
      25             : 
      26             : namespace llvm {
      27             : namespace ELF {
      28             : 
      29             : using Elf32_Addr = uint32_t; // Program address
      30             : using Elf32_Off = uint32_t;  // File offset
      31             : using Elf32_Half = uint16_t;
      32             : using Elf32_Word = uint32_t;
      33             : using Elf32_Sword = int32_t;
      34             : 
      35             : using Elf64_Addr = uint64_t;
      36             : using Elf64_Off = uint64_t;
      37             : using Elf64_Half = uint16_t;
      38             : using Elf64_Word = uint32_t;
      39             : using Elf64_Sword = int32_t;
      40             : using Elf64_Xword = uint64_t;
      41             : using Elf64_Sxword = int64_t;
      42             : 
      43             : // Object file magic string.
      44             : static const char ElfMagic[] = {0x7f, 'E', 'L', 'F', '\0'};
      45             : 
      46             : // e_ident size and indices.
      47             : enum {
      48             :   EI_MAG0 = 0,       // File identification index.
      49             :   EI_MAG1 = 1,       // File identification index.
      50             :   EI_MAG2 = 2,       // File identification index.
      51             :   EI_MAG3 = 3,       // File identification index.
      52             :   EI_CLASS = 4,      // File class.
      53             :   EI_DATA = 5,       // Data encoding.
      54             :   EI_VERSION = 6,    // File version.
      55             :   EI_OSABI = 7,      // OS/ABI identification.
      56             :   EI_ABIVERSION = 8, // ABI version.
      57             :   EI_PAD = 9,        // Start of padding bytes.
      58             :   EI_NIDENT = 16     // Number of bytes in e_ident.
      59             : };
      60             : 
      61             : struct Elf32_Ehdr {
      62             :   unsigned char e_ident[EI_NIDENT]; // ELF Identification bytes
      63             :   Elf32_Half e_type;                // Type of file (see ET_* below)
      64             :   Elf32_Half e_machine;   // Required architecture for this file (see EM_*)
      65             :   Elf32_Word e_version;   // Must be equal to 1
      66             :   Elf32_Addr e_entry;     // Address to jump to in order to start program
      67             :   Elf32_Off e_phoff;      // Program header table's file offset, in bytes
      68             :   Elf32_Off e_shoff;      // Section header table's file offset, in bytes
      69             :   Elf32_Word e_flags;     // Processor-specific flags
      70             :   Elf32_Half e_ehsize;    // Size of ELF header, in bytes
      71             :   Elf32_Half e_phentsize; // Size of an 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 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;  // Sect hdr table index of sect name string table
      76             : 
      77             :   bool checkMagic() const {
      78             :     return (memcmp(e_ident, ElfMagic, strlen(ElfMagic))) == 0;
      79             :   }
      80             : 
      81             :   unsigned char getFileClass() const { return e_ident[EI_CLASS]; }
      82             :   unsigned char getDataEncoding() const { return e_ident[EI_DATA]; }
      83             : };
      84             : 
      85             : // 64-bit ELF header. Fields are the same as for ELF32, but with different
      86             : // types (see above).
      87             : struct Elf64_Ehdr {
      88             :   unsigned char e_ident[EI_NIDENT];
      89             :   Elf64_Half e_type;
      90             :   Elf64_Half e_machine;
      91             :   Elf64_Word e_version;
      92             :   Elf64_Addr e_entry;
      93             :   Elf64_Off e_phoff;
      94             :   Elf64_Off e_shoff;
      95             :   Elf64_Word e_flags;
      96             :   Elf64_Half e_ehsize;
      97             :   Elf64_Half e_phentsize;
      98             :   Elf64_Half e_phnum;
      99             :   Elf64_Half e_shentsize;
     100             :   Elf64_Half e_shnum;
     101             :   Elf64_Half e_shstrndx;
     102             : 
     103             :   bool checkMagic() const {
     104             :     return (memcmp(e_ident, ElfMagic, strlen(ElfMagic))) == 0;
     105             :   }
     106             : 
     107             :   unsigned char getFileClass() const { return e_ident[EI_CLASS]; }
     108             :   unsigned char getDataEncoding() const { return e_ident[EI_DATA]; }
     109             : };
     110             : 
     111             : // File types
     112             : enum {
     113             :   ET_NONE = 0,        // No file type
     114             :   ET_REL = 1,         // Relocatable file
     115             :   ET_EXEC = 2,        // Executable file
     116             :   ET_DYN = 3,         // Shared object file
     117             :   ET_CORE = 4,        // Core file
     118             :   ET_LOPROC = 0xff00, // Beginning of processor-specific codes
     119             :   ET_HIPROC = 0xffff  // Processor-specific
     120             : };
     121             : 
     122             : // Versioning
     123             : enum { EV_NONE = 0, EV_CURRENT = 1 };
     124             : 
     125             : // Machine architectures
     126             : // See current registered ELF machine architectures at:
     127             : //    http://www.uxsglobal.com/developers/gabi/latest/ch4.eheader.html
     128             : enum {
     129             :   EM_NONE = 0,           // No machine
     130             :   EM_M32 = 1,            // AT&T WE 32100
     131             :   EM_SPARC = 2,          // SPARC
     132             :   EM_386 = 3,            // Intel 386
     133             :   EM_68K = 4,            // Motorola 68000
     134             :   EM_88K = 5,            // Motorola 88000
     135             :   EM_IAMCU = 6,          // Intel MCU
     136             :   EM_860 = 7,            // Intel 80860
     137             :   EM_MIPS = 8,           // MIPS R3000
     138             :   EM_S370 = 9,           // IBM System/370
     139             :   EM_MIPS_RS3_LE = 10,   // MIPS RS3000 Little-endian
     140             :   EM_PARISC = 15,        // Hewlett-Packard PA-RISC
     141             :   EM_VPP500 = 17,        // Fujitsu VPP500
     142             :   EM_SPARC32PLUS = 18,   // Enhanced instruction set SPARC
     143             :   EM_960 = 19,           // Intel 80960
     144             :   EM_PPC = 20,           // PowerPC
     145             :   EM_PPC64 = 21,         // PowerPC64
     146             :   EM_S390 = 22,          // IBM System/390
     147             :   EM_SPU = 23,           // IBM SPU/SPC
     148             :   EM_V800 = 36,          // NEC V800
     149             :   EM_FR20 = 37,          // Fujitsu FR20
     150             :   EM_RH32 = 38,          // TRW RH-32
     151             :   EM_RCE = 39,           // Motorola RCE
     152             :   EM_ARM = 40,           // ARM
     153             :   EM_ALPHA = 41,         // DEC Alpha
     154             :   EM_SH = 42,            // Hitachi SH
     155             :   EM_SPARCV9 = 43,       // SPARC V9
     156             :   EM_TRICORE = 44,       // Siemens TriCore
     157             :   EM_ARC = 45,           // Argonaut RISC Core
     158             :   EM_H8_300 = 46,        // Hitachi H8/300
     159             :   EM_H8_300H = 47,       // Hitachi H8/300H
     160             :   EM_H8S = 48,           // Hitachi H8S
     161             :   EM_H8_500 = 49,        // Hitachi H8/500
     162             :   EM_IA_64 = 50,         // Intel IA-64 processor architecture
     163             :   EM_MIPS_X = 51,        // Stanford MIPS-X
     164             :   EM_COLDFIRE = 52,      // Motorola ColdFire
     165             :   EM_68HC12 = 53,        // Motorola M68HC12
     166             :   EM_MMA = 54,           // Fujitsu MMA Multimedia Accelerator
     167             :   EM_PCP = 55,           // Siemens PCP
     168             :   EM_NCPU = 56,          // Sony nCPU embedded RISC processor
     169             :   EM_NDR1 = 57,          // Denso NDR1 microprocessor
     170             :   EM_STARCORE = 58,      // Motorola Star*Core processor
     171             :   EM_ME16 = 59,          // Toyota ME16 processor
     172             :   EM_ST100 = 60,         // STMicroelectronics ST100 processor
     173             :   EM_TINYJ = 61,         // Advanced Logic Corp. TinyJ embedded processor family
     174             :   EM_X86_64 = 62,        // AMD x86-64 architecture
     175             :   EM_PDSP = 63,          // Sony DSP Processor
     176             :   EM_PDP10 = 64,         // Digital Equipment Corp. PDP-10
     177             :   EM_PDP11 = 65,         // Digital Equipment Corp. PDP-11
     178             :   EM_FX66 = 66,          // Siemens FX66 microcontroller
     179             :   EM_ST9PLUS = 67,       // STMicroelectronics ST9+ 8/16 bit microcontroller
     180             :   EM_ST7 = 68,           // STMicroelectronics ST7 8-bit microcontroller
     181             :   EM_68HC16 = 69,        // Motorola MC68HC16 Microcontroller
     182             :   EM_68HC11 = 70,        // Motorola MC68HC11 Microcontroller
     183             :   EM_68HC08 = 71,        // Motorola MC68HC08 Microcontroller
     184             :   EM_68HC05 = 72,        // Motorola MC68HC05 Microcontroller
     185             :   EM_SVX = 73,           // Silicon Graphics SVx
     186             :   EM_ST19 = 74,          // STMicroelectronics ST19 8-bit microcontroller
     187             :   EM_VAX = 75,           // Digital VAX
     188             :   EM_CRIS = 76,          // Axis Communications 32-bit embedded processor
     189             :   EM_JAVELIN = 77,       // Infineon Technologies 32-bit embedded processor
     190             :   EM_FIREPATH = 78,      // Element 14 64-bit DSP Processor
     191             :   EM_ZSP = 79,           // LSI Logic 16-bit DSP Processor
     192             :   EM_MMIX = 80,          // Donald Knuth's educational 64-bit processor
     193             :   EM_HUANY = 81,         // Harvard University machine-independent object files
     194             :   EM_PRISM = 82,         // SiTera Prism
     195             :   EM_AVR = 83,           // Atmel AVR 8-bit microcontroller
     196             :   EM_FR30 = 84,          // Fujitsu FR30
     197             :   EM_D10V = 85,          // Mitsubishi D10V
     198             :   EM_D30V = 86,          // Mitsubishi D30V
     199             :   EM_V850 = 87,          // NEC v850
     200             :   EM_M32R = 88,          // Mitsubishi M32R
     201             :   EM_MN10300 = 89,       // Matsushita MN10300
     202             :   EM_MN10200 = 90,       // Matsushita MN10200
     203             :   EM_PJ = 91,            // picoJava
     204             :   EM_OPENRISC = 92,      // OpenRISC 32-bit embedded processor
     205             :   EM_ARC_COMPACT = 93,   // ARC International ARCompact processor (old
     206             :                          // spelling/synonym: EM_ARC_A5)
     207             :   EM_XTENSA = 94,        // Tensilica Xtensa Architecture
     208             :   EM_VIDEOCORE = 95,     // Alphamosaic VideoCore processor
     209             :   EM_TMM_GPP = 96,       // Thompson Multimedia General Purpose Processor
     210             :   EM_NS32K = 97,         // National Semiconductor 32000 series
     211             :   EM_TPC = 98,           // Tenor Network TPC processor
     212             :   EM_SNP1K = 99,         // Trebia SNP 1000 processor
     213             :   EM_ST200 = 100,        // STMicroelectronics (www.st.com) ST200
     214             :   EM_IP2K = 101,         // Ubicom IP2xxx microcontroller family
     215             :   EM_MAX = 102,          // MAX Processor
     216             :   EM_CR = 103,           // National Semiconductor CompactRISC microprocessor
     217             :   EM_F2MC16 = 104,       // Fujitsu F2MC16
     218             :   EM_MSP430 = 105,       // Texas Instruments embedded microcontroller msp430
     219             :   EM_BLACKFIN = 106,     // Analog Devices Blackfin (DSP) processor
     220             :   EM_SE_C33 = 107,       // S1C33 Family of Seiko Epson processors
     221             :   EM_SEP = 108,          // Sharp embedded microprocessor
     222             :   EM_ARCA = 109,         // Arca RISC Microprocessor
     223             :   EM_UNICORE = 110,      // Microprocessor series from PKU-Unity Ltd. and MPRC
     224             :                          // of Peking University
     225             :   EM_EXCESS = 111,       // eXcess: 16/32/64-bit configurable embedded CPU
     226             :   EM_DXP = 112,          // Icera Semiconductor Inc. Deep Execution Processor
     227             :   EM_ALTERA_NIOS2 = 113, // Altera Nios II soft-core processor
     228             :   EM_CRX = 114,          // National Semiconductor CompactRISC CRX
     229             :   EM_XGATE = 115,        // Motorola XGATE embedded processor
     230             :   EM_C166 = 116,         // Infineon C16x/XC16x processor
     231             :   EM_M16C = 117,         // Renesas M16C series microprocessors
     232             :   EM_DSPIC30F = 118,     // Microchip Technology dsPIC30F Digital Signal
     233             :                          // Controller
     234             :   EM_CE = 119,           // Freescale Communication Engine RISC core
     235             :   EM_M32C = 120,         // Renesas M32C series microprocessors
     236             :   EM_TSK3000 = 131,      // Altium TSK3000 core
     237             :   EM_RS08 = 132,         // Freescale RS08 embedded processor
     238             :   EM_SHARC = 133,        // Analog Devices SHARC family of 32-bit DSP
     239             :                          // processors
     240             :   EM_ECOG2 = 134,        // Cyan Technology eCOG2 microprocessor
     241             :   EM_SCORE7 = 135,       // Sunplus S+core7 RISC processor
     242             :   EM_DSP24 = 136,        // New Japan Radio (NJR) 24-bit DSP Processor
     243             :   EM_VIDEOCORE3 = 137,   // Broadcom VideoCore III processor
     244             :   EM_LATTICEMICO32 = 138, // RISC processor for Lattice FPGA architecture
     245             :   EM_SE_C17 = 139,        // Seiko Epson C17 family
     246             :   EM_TI_C6000 = 140,      // The Texas Instruments TMS320C6000 DSP family
     247             :   EM_TI_C2000 = 141,      // The Texas Instruments TMS320C2000 DSP family
     248             :   EM_TI_C5500 = 142,      // The Texas Instruments TMS320C55x DSP family
     249             :   EM_MMDSP_PLUS = 160,    // STMicroelectronics 64bit VLIW Data Signal Processor
     250             :   EM_CYPRESS_M8C = 161,   // Cypress M8C microprocessor
     251             :   EM_R32C = 162,          // Renesas R32C series microprocessors
     252             :   EM_TRIMEDIA = 163,      // NXP Semiconductors TriMedia architecture family
     253             :   EM_HEXAGON = 164,       // Qualcomm Hexagon processor
     254             :   EM_8051 = 165,          // Intel 8051 and variants
     255             :   EM_STXP7X = 166,        // STMicroelectronics STxP7x family of configurable
     256             :                           // and extensible RISC processors
     257             :   EM_NDS32 = 167,         // Andes Technology compact code size embedded RISC
     258             :                           // processor family
     259             :   EM_ECOG1 = 168,         // Cyan Technology eCOG1X family
     260             :   EM_ECOG1X = 168,        // Cyan Technology eCOG1X family
     261             :   EM_MAXQ30 = 169,        // Dallas Semiconductor MAXQ30 Core Micro-controllers
     262             :   EM_XIMO16 = 170,        // New Japan Radio (NJR) 16-bit DSP Processor
     263             :   EM_MANIK = 171,         // M2000 Reconfigurable RISC Microprocessor
     264             :   EM_CRAYNV2 = 172,       // Cray Inc. NV2 vector architecture
     265             :   EM_RX = 173,            // Renesas RX family
     266             :   EM_METAG = 174,         // Imagination Technologies META processor
     267             :                           // architecture
     268             :   EM_MCST_ELBRUS = 175,   // MCST Elbrus general purpose hardware architecture
     269             :   EM_ECOG16 = 176,        // Cyan Technology eCOG16 family
     270             :   EM_CR16 = 177,          // National Semiconductor CompactRISC CR16 16-bit
     271             :                           // microprocessor
     272             :   EM_ETPU = 178,          // Freescale Extended Time Processing Unit
     273             :   EM_SLE9X = 179,         // Infineon Technologies SLE9X core
     274             :   EM_L10M = 180,          // Intel L10M
     275             :   EM_K10M = 181,          // Intel K10M
     276             :   EM_AARCH64 = 183,       // ARM AArch64
     277             :   EM_AVR32 = 185,         // Atmel Corporation 32-bit microprocessor family
     278             :   EM_STM8 = 186,          // STMicroeletronics STM8 8-bit microcontroller
     279             :   EM_TILE64 = 187,        // Tilera TILE64 multicore architecture family
     280             :   EM_TILEPRO = 188,       // Tilera TILEPro multicore architecture family
     281             :   EM_CUDA = 190,          // NVIDIA CUDA architecture
     282             :   EM_TILEGX = 191,        // Tilera TILE-Gx multicore architecture family
     283             :   EM_CLOUDSHIELD = 192,   // CloudShield architecture family
     284             :   EM_COREA_1ST = 193,     // KIPO-KAIST Core-A 1st generation processor family
     285             :   EM_COREA_2ND = 194,     // KIPO-KAIST Core-A 2nd generation processor family
     286             :   EM_ARC_COMPACT2 = 195,  // Synopsys ARCompact V2
     287             :   EM_OPEN8 = 196,         // Open8 8-bit RISC soft processor core
     288             :   EM_RL78 = 197,          // Renesas RL78 family
     289             :   EM_VIDEOCORE5 = 198,    // Broadcom VideoCore V processor
     290             :   EM_78KOR = 199,         // Renesas 78KOR family
     291             :   EM_56800EX = 200,       // Freescale 56800EX Digital Signal Controller (DSC)
     292             :   EM_BA1 = 201,           // Beyond BA1 CPU architecture
     293             :   EM_BA2 = 202,           // Beyond BA2 CPU architecture
     294             :   EM_XCORE = 203,         // XMOS xCORE processor family
     295             :   EM_MCHP_PIC = 204,      // Microchip 8-bit PIC(r) family
     296             :   EM_INTEL205 = 205,      // Reserved by Intel
     297             :   EM_INTEL206 = 206,      // Reserved by Intel
     298             :   EM_INTEL207 = 207,      // Reserved by Intel
     299             :   EM_INTEL208 = 208,      // Reserved by Intel
     300             :   EM_INTEL209 = 209,      // Reserved by Intel
     301             :   EM_KM32 = 210,          // KM211 KM32 32-bit processor
     302             :   EM_KMX32 = 211,         // KM211 KMX32 32-bit processor
     303             :   EM_KMX16 = 212,         // KM211 KMX16 16-bit processor
     304             :   EM_KMX8 = 213,          // KM211 KMX8 8-bit processor
     305             :   EM_KVARC = 214,         // KM211 KVARC processor
     306             :   EM_CDP = 215,           // Paneve CDP architecture family
     307             :   EM_COGE = 216,          // Cognitive Smart Memory Processor
     308             :   EM_COOL = 217,          // iCelero CoolEngine
     309             :   EM_NORC = 218,          // Nanoradio Optimized RISC
     310             :   EM_CSR_KALIMBA = 219,   // CSR Kalimba architecture family
     311             :   EM_AMDGPU = 224,        // AMD GPU architecture
     312             :   EM_RISCV = 243,         // RISC-V
     313             :   EM_LANAI = 244,         // Lanai 32-bit processor
     314             :   EM_BPF = 247,           // Linux kernel bpf virtual machine
     315             : 
     316             :   // A request has been made to the maintainer of the official registry for
     317             :   // such numbers for an official value for WebAssembly. As soon as one is
     318             :   // allocated, this enum will be updated to use it.
     319             :   EM_WEBASSEMBLY = 0x4157, // WebAssembly architecture
     320             : };
     321             : 
     322             : // Object file classes.
     323             : enum {
     324             :   ELFCLASSNONE = 0,
     325             :   ELFCLASS32 = 1, // 32-bit object file
     326             :   ELFCLASS64 = 2  // 64-bit object file
     327             : };
     328             : 
     329             : // Object file byte orderings.
     330             : enum {
     331             :   ELFDATANONE = 0, // Invalid data encoding.
     332             :   ELFDATA2LSB = 1, // Little-endian object file
     333             :   ELFDATA2MSB = 2  // Big-endian object file
     334             : };
     335             : 
     336             : // OS ABI identification.
     337             : enum {
     338             :   ELFOSABI_NONE = 0,           // UNIX System V ABI
     339             :   ELFOSABI_HPUX = 1,           // HP-UX operating system
     340             :   ELFOSABI_NETBSD = 2,         // NetBSD
     341             :   ELFOSABI_GNU = 3,            // GNU/Linux
     342             :   ELFOSABI_LINUX = 3,          // Historical alias for ELFOSABI_GNU.
     343             :   ELFOSABI_HURD = 4,           // GNU/Hurd
     344             :   ELFOSABI_SOLARIS = 6,        // Solaris
     345             :   ELFOSABI_AIX = 7,            // AIX
     346             :   ELFOSABI_IRIX = 8,           // IRIX
     347             :   ELFOSABI_FREEBSD = 9,        // FreeBSD
     348             :   ELFOSABI_TRU64 = 10,         // TRU64 UNIX
     349             :   ELFOSABI_MODESTO = 11,       // Novell Modesto
     350             :   ELFOSABI_OPENBSD = 12,       // OpenBSD
     351             :   ELFOSABI_OPENVMS = 13,       // OpenVMS
     352             :   ELFOSABI_NSK = 14,           // Hewlett-Packard Non-Stop Kernel
     353             :   ELFOSABI_AROS = 15,          // AROS
     354             :   ELFOSABI_FENIXOS = 16,       // FenixOS
     355             :   ELFOSABI_CLOUDABI = 17,      // Nuxi CloudABI
     356             :   ELFOSABI_FIRST_ARCH = 64,    // First architecture-specific OS ABI
     357             :   ELFOSABI_AMDGPU_HSA = 64,    // AMD HSA runtime
     358             :   ELFOSABI_AMDGPU_PAL = 65,    // AMD PAL runtime
     359             :   ELFOSABI_AMDGPU_MESA3D = 66, // AMD GCN GPUs (GFX6+) for MESA runtime
     360             :   ELFOSABI_ARM = 97,           // ARM
     361             :   ELFOSABI_C6000_ELFABI = 64,  // Bare-metal TMS320C6000
     362             :   ELFOSABI_C6000_LINUX = 65,   // Linux TMS320C6000
     363             :   ELFOSABI_STANDALONE = 255,   // Standalone (embedded) application
     364             :   ELFOSABI_LAST_ARCH = 255     // Last Architecture-specific OS ABI
     365             : };
     366             : 
     367             : #define ELF_RELOC(name, value) name = value,
     368             : 
     369             : // X86_64 relocations.
     370             : enum {
     371             : #include "ELFRelocs/x86_64.def"
     372             : };
     373             : 
     374             : // i386 relocations.
     375             : enum {
     376             : #include "ELFRelocs/i386.def"
     377             : };
     378             : 
     379             : // ELF Relocation types for PPC32
     380             : enum {
     381             : #include "ELFRelocs/PowerPC.def"
     382             : };
     383             : 
     384             : // Specific e_flags for PPC64
     385             : enum {
     386             :   // e_flags bits specifying ABI:
     387             :   // 1 for original ABI using function descriptors,
     388             :   // 2 for revised ABI without function descriptors,
     389             :   // 0 for unspecified or not using any features affected by the differences.
     390             :   EF_PPC64_ABI = 3
     391             : };
     392             : 
     393             : // Special values for the st_other field in the symbol table entry for PPC64.
     394             : enum {
     395             :   STO_PPC64_LOCAL_BIT = 5,
     396             :   STO_PPC64_LOCAL_MASK = (7 << STO_PPC64_LOCAL_BIT)
     397             : };
     398             : static inline int64_t decodePPC64LocalEntryOffset(unsigned Other) {
     399           2 :   unsigned Val = (Other & STO_PPC64_LOCAL_MASK) >> STO_PPC64_LOCAL_BIT;
     400          30 :   return ((1 << Val) >> 2) << 2;
     401             : }
     402             : static inline unsigned encodePPC64LocalEntryOffset(int64_t Offset) {
     403             :   unsigned Val =
     404          28 :       (Offset >= 4 * 4 ? (Offset >= 8 * 4 ? (Offset >= 16 * 4 ? 6 : 5) : 4)
     405             :                        : (Offset >= 2 * 4 ? 3 : (Offset >= 1 * 4 ? 2 : 0)));
     406          28 :   return Val << STO_PPC64_LOCAL_BIT;
     407             : }
     408             : 
     409             : // ELF Relocation types for PPC64
     410             : enum {
     411             : #include "ELFRelocs/PowerPC64.def"
     412             : };
     413             : 
     414             : // ELF Relocation types for AArch64
     415             : enum {
     416             : #include "ELFRelocs/AArch64.def"
     417             : };
     418             : 
     419             : // ARM Specific e_flags
     420             : enum : unsigned {
     421             :   EF_ARM_SOFT_FLOAT = 0x00000200U,
     422             :   EF_ARM_VFP_FLOAT = 0x00000400U,
     423             :   EF_ARM_EABI_UNKNOWN = 0x00000000U,
     424             :   EF_ARM_EABI_VER1 = 0x01000000U,
     425             :   EF_ARM_EABI_VER2 = 0x02000000U,
     426             :   EF_ARM_EABI_VER3 = 0x03000000U,
     427             :   EF_ARM_EABI_VER4 = 0x04000000U,
     428             :   EF_ARM_EABI_VER5 = 0x05000000U,
     429             :   EF_ARM_EABIMASK = 0xFF000000U
     430             : };
     431             : 
     432             : // ELF Relocation types for ARM
     433             : enum {
     434             : #include "ELFRelocs/ARM.def"
     435             : };
     436             : 
     437             : // ARC Specific e_flags
     438             : enum : unsigned {
     439             :   EF_ARC_MACH_MSK = 0x000000ff,
     440             :   EF_ARC_OSABI_MSK = 0x00000f00,
     441             :   E_ARC_MACH_ARC600 = 0x00000002,
     442             :   E_ARC_MACH_ARC601 = 0x00000004,
     443             :   E_ARC_MACH_ARC700 = 0x00000003,
     444             :   EF_ARC_CPU_ARCV2EM = 0x00000005,
     445             :   EF_ARC_CPU_ARCV2HS = 0x00000006,
     446             :   E_ARC_OSABI_ORIG = 0x00000000,
     447             :   E_ARC_OSABI_V2 = 0x00000200,
     448             :   E_ARC_OSABI_V3 = 0x00000300,
     449             :   E_ARC_OSABI_V4 = 0x00000400,
     450             :   EF_ARC_PIC = 0x00000100
     451             : };
     452             : 
     453             : // ELF Relocation types for ARC
     454             : enum {
     455             : #include "ELFRelocs/ARC.def"
     456             : };
     457             : 
     458             : // AVR specific e_flags
     459             : enum : unsigned {
     460             :   EF_AVR_ARCH_AVR1 = 1,
     461             :   EF_AVR_ARCH_AVR2 = 2,
     462             :   EF_AVR_ARCH_AVR25 = 25,
     463             :   EF_AVR_ARCH_AVR3 = 3,
     464             :   EF_AVR_ARCH_AVR31 = 31,
     465             :   EF_AVR_ARCH_AVR35 = 35,
     466             :   EF_AVR_ARCH_AVR4 = 4,
     467             :   EF_AVR_ARCH_AVR5 = 5,
     468             :   EF_AVR_ARCH_AVR51 = 51,
     469             :   EF_AVR_ARCH_AVR6 = 6,
     470             :   EF_AVR_ARCH_AVRTINY = 100,
     471             :   EF_AVR_ARCH_XMEGA1 = 101,
     472             :   EF_AVR_ARCH_XMEGA2 = 102,
     473             :   EF_AVR_ARCH_XMEGA3 = 103,
     474             :   EF_AVR_ARCH_XMEGA4 = 104,
     475             :   EF_AVR_ARCH_XMEGA5 = 105,
     476             :   EF_AVR_ARCH_XMEGA6 = 106,
     477             :   EF_AVR_ARCH_XMEGA7 = 107
     478             : };
     479             : 
     480             : // ELF Relocation types for AVR
     481             : enum {
     482             : #include "ELFRelocs/AVR.def"
     483             : };
     484             : 
     485             : // Mips Specific e_flags
     486             : enum : unsigned {
     487             :   EF_MIPS_NOREORDER = 0x00000001, // Don't reorder instructions
     488             :   EF_MIPS_PIC = 0x00000002,       // Position independent code
     489             :   EF_MIPS_CPIC = 0x00000004,      // Call object with Position independent code
     490             :   EF_MIPS_ABI2 = 0x00000020,      // File uses N32 ABI
     491             :   EF_MIPS_32BITMODE = 0x00000100, // Code compiled for a 64-bit machine
     492             :                                   // in 32-bit mode
     493             :   EF_MIPS_FP64 = 0x00000200,      // Code compiled for a 32-bit machine
     494             :                                   // but uses 64-bit FP registers
     495             :   EF_MIPS_NAN2008 = 0x00000400,   // Uses IEE 754-2008 NaN encoding
     496             : 
     497             :   // ABI flags
     498             :   EF_MIPS_ABI_O32 = 0x00001000, // This file follows the first MIPS 32 bit ABI
     499             :   EF_MIPS_ABI_O64 = 0x00002000, // O32 ABI extended for 64-bit architecture.
     500             :   EF_MIPS_ABI_EABI32 = 0x00003000, // EABI in 32 bit mode.
     501             :   EF_MIPS_ABI_EABI64 = 0x00004000, // EABI in 64 bit mode.
     502             :   EF_MIPS_ABI = 0x0000f000,        // Mask for selecting EF_MIPS_ABI_ variant.
     503             : 
     504             :   // MIPS machine variant
     505             :   EF_MIPS_MACH_NONE = 0x00000000,    // A standard MIPS implementation.
     506             :   EF_MIPS_MACH_3900 = 0x00810000,    // Toshiba R3900
     507             :   EF_MIPS_MACH_4010 = 0x00820000,    // LSI R4010
     508             :   EF_MIPS_MACH_4100 = 0x00830000,    // NEC VR4100
     509             :   EF_MIPS_MACH_4650 = 0x00850000,    // MIPS R4650
     510             :   EF_MIPS_MACH_4120 = 0x00870000,    // NEC VR4120
     511             :   EF_MIPS_MACH_4111 = 0x00880000,    // NEC VR4111/VR4181
     512             :   EF_MIPS_MACH_SB1 = 0x008a0000,     // Broadcom SB-1
     513             :   EF_MIPS_MACH_OCTEON = 0x008b0000,  // Cavium Networks Octeon
     514             :   EF_MIPS_MACH_XLR = 0x008c0000,     // RMI Xlr
     515             :   EF_MIPS_MACH_OCTEON2 = 0x008d0000, // Cavium Networks Octeon2
     516             :   EF_MIPS_MACH_OCTEON3 = 0x008e0000, // Cavium Networks Octeon3
     517             :   EF_MIPS_MACH_5400 = 0x00910000,    // NEC VR5400
     518             :   EF_MIPS_MACH_5900 = 0x00920000,    // MIPS R5900
     519             :   EF_MIPS_MACH_5500 = 0x00980000,    // NEC VR5500
     520             :   EF_MIPS_MACH_9000 = 0x00990000,    // Unknown
     521             :   EF_MIPS_MACH_LS2E = 0x00a00000,    // ST Microelectronics Loongson 2E
     522             :   EF_MIPS_MACH_LS2F = 0x00a10000,    // ST Microelectronics Loongson 2F
     523             :   EF_MIPS_MACH_LS3A = 0x00a20000,    // Loongson 3A
     524             :   EF_MIPS_MACH = 0x00ff0000,         // EF_MIPS_MACH_xxx selection mask
     525             : 
     526             :   // ARCH_ASE
     527             :   EF_MIPS_MICROMIPS = 0x02000000,     // microMIPS
     528             :   EF_MIPS_ARCH_ASE_M16 = 0x04000000,  // Has Mips-16 ISA extensions
     529             :   EF_MIPS_ARCH_ASE_MDMX = 0x08000000, // Has MDMX multimedia extensions
     530             :   EF_MIPS_ARCH_ASE = 0x0f000000,      // Mask for EF_MIPS_ARCH_ASE_xxx flags
     531             : 
     532             :   // ARCH
     533             :   EF_MIPS_ARCH_1 = 0x00000000,    // MIPS1 instruction set
     534             :   EF_MIPS_ARCH_2 = 0x10000000,    // MIPS2 instruction set
     535             :   EF_MIPS_ARCH_3 = 0x20000000,    // MIPS3 instruction set
     536             :   EF_MIPS_ARCH_4 = 0x30000000,    // MIPS4 instruction set
     537             :   EF_MIPS_ARCH_5 = 0x40000000,    // MIPS5 instruction set
     538             :   EF_MIPS_ARCH_32 = 0x50000000,   // MIPS32 instruction set per linux not elf.h
     539             :   EF_MIPS_ARCH_64 = 0x60000000,   // MIPS64 instruction set per linux not elf.h
     540             :   EF_MIPS_ARCH_32R2 = 0x70000000, // mips32r2, mips32r3, mips32r5
     541             :   EF_MIPS_ARCH_64R2 = 0x80000000, // mips64r2, mips64r3, mips64r5
     542             :   EF_MIPS_ARCH_32R6 = 0x90000000, // mips32r6
     543             :   EF_MIPS_ARCH_64R6 = 0xa0000000, // mips64r6
     544             :   EF_MIPS_ARCH = 0xf0000000       // Mask for applying EF_MIPS_ARCH_ variant
     545             : };
     546             : 
     547             : // ELF Relocation types for Mips
     548             : enum {
     549             : #include "ELFRelocs/Mips.def"
     550             : };
     551             : 
     552             : // Special values for the st_other field in the symbol table entry for MIPS.
     553             : enum {
     554             :   STO_MIPS_OPTIONAL = 0x04,  // Symbol whose definition is optional
     555             :   STO_MIPS_PLT = 0x08,       // PLT entry related dynamic table record
     556             :   STO_MIPS_PIC = 0x20,       // PIC func in an object mixes PIC/non-PIC
     557             :   STO_MIPS_MICROMIPS = 0x80, // MIPS Specific ISA for MicroMips
     558             :   STO_MIPS_MIPS16 = 0xf0     // MIPS Specific ISA for Mips16
     559             : };
     560             : 
     561             : // .MIPS.options section descriptor kinds
     562             : enum {
     563             :   ODK_NULL = 0,       // Undefined
     564             :   ODK_REGINFO = 1,    // Register usage information
     565             :   ODK_EXCEPTIONS = 2, // Exception processing options
     566             :   ODK_PAD = 3,        // Section padding options
     567             :   ODK_HWPATCH = 4,    // Hardware patches applied
     568             :   ODK_FILL = 5,       // Linker fill value
     569             :   ODK_TAGS = 6,       // Space for tool identification
     570             :   ODK_HWAND = 7,      // Hardware AND patches applied
     571             :   ODK_HWOR = 8,       // Hardware OR patches applied
     572             :   ODK_GP_GROUP = 9,   // GP group to use for text/data sections
     573             :   ODK_IDENT = 10,     // ID information
     574             :   ODK_PAGESIZE = 11   // Page size information
     575             : };
     576             : 
     577             : // Hexagon-specific e_flags
     578             : enum {
     579             :   // Object processor version flags, bits[11:0]
     580             :   EF_HEXAGON_MACH_V2 = 0x00000001,  // Hexagon V2
     581             :   EF_HEXAGON_MACH_V3 = 0x00000002,  // Hexagon V3
     582             :   EF_HEXAGON_MACH_V4 = 0x00000003,  // Hexagon V4
     583             :   EF_HEXAGON_MACH_V5 = 0x00000004,  // Hexagon V5
     584             :   EF_HEXAGON_MACH_V55 = 0x00000005, // Hexagon V55
     585             :   EF_HEXAGON_MACH_V60 = 0x00000060, // Hexagon V60
     586             :   EF_HEXAGON_MACH_V62 = 0x00000062, // Hexagon V62
     587             :   EF_HEXAGON_MACH_V65 = 0x00000065, // Hexagon V65
     588             : 
     589             :   // Highest ISA version flags
     590             :   EF_HEXAGON_ISA_MACH = 0x00000000, // Same as specified in bits[11:0]
     591             :                                     // of e_flags
     592             :   EF_HEXAGON_ISA_V2 = 0x00000010,   // Hexagon V2 ISA
     593             :   EF_HEXAGON_ISA_V3 = 0x00000020,   // Hexagon V3 ISA
     594             :   EF_HEXAGON_ISA_V4 = 0x00000030,   // Hexagon V4 ISA
     595             :   EF_HEXAGON_ISA_V5 = 0x00000040,   // Hexagon V5 ISA
     596             :   EF_HEXAGON_ISA_V55 = 0x00000050,  // Hexagon V55 ISA
     597             :   EF_HEXAGON_ISA_V60 = 0x00000060,  // Hexagon V60 ISA
     598             :   EF_HEXAGON_ISA_V62 = 0x00000062,  // Hexagon V62 ISA
     599             :   EF_HEXAGON_ISA_V65 = 0x00000065,  // Hexagon V65 ISA
     600             : };
     601             : 
     602             : // Hexagon-specific section indexes for common small data
     603             : enum {
     604             :   SHN_HEXAGON_SCOMMON = 0xff00,   // Other access sizes
     605             :   SHN_HEXAGON_SCOMMON_1 = 0xff01, // Byte-sized access
     606             :   SHN_HEXAGON_SCOMMON_2 = 0xff02, // Half-word-sized access
     607             :   SHN_HEXAGON_SCOMMON_4 = 0xff03, // Word-sized access
     608             :   SHN_HEXAGON_SCOMMON_8 = 0xff04  // Double-word-size access
     609             : };
     610             : 
     611             : // ELF Relocation types for Hexagon
     612             : enum {
     613             : #include "ELFRelocs/Hexagon.def"
     614             : };
     615             : 
     616             : // ELF Relocation type for Lanai.
     617             : enum {
     618             : #include "ELFRelocs/Lanai.def"
     619             : };
     620             : 
     621             : // RISCV Specific e_flags
     622             : enum : unsigned {
     623             :   EF_RISCV_RVC = 0x0001,
     624             :   EF_RISCV_FLOAT_ABI = 0x0006,
     625             :   EF_RISCV_FLOAT_ABI_SOFT = 0x0000,
     626             :   EF_RISCV_FLOAT_ABI_SINGLE = 0x0002,
     627             :   EF_RISCV_FLOAT_ABI_DOUBLE = 0x0004,
     628             :   EF_RISCV_FLOAT_ABI_QUAD = 0x0006,
     629             :   EF_RISCV_RVE = 0x0008
     630             : };
     631             : 
     632             : // ELF Relocation types for RISC-V
     633             : enum {
     634             : #include "ELFRelocs/RISCV.def"
     635             : };
     636             : 
     637             : // ELF Relocation types for S390/zSeries
     638             : enum {
     639             : #include "ELFRelocs/SystemZ.def"
     640             : };
     641             : 
     642             : // ELF Relocation type for Sparc.
     643             : enum {
     644             : #include "ELFRelocs/Sparc.def"
     645             : };
     646             : 
     647             : // ELF Relocation types for WebAssembly
     648             : enum {
     649             : #include "ELFRelocs/WebAssembly.def"
     650             : };
     651             : 
     652             : // AMDGPU specific e_flags.
     653             : enum : unsigned {
     654             :   // Processor selection mask for EF_AMDGPU_MACH_* values.
     655             :   EF_AMDGPU_MACH = 0x0ff,
     656             : 
     657             :   // Not specified processor.
     658             :   EF_AMDGPU_MACH_NONE = 0x000,
     659             : 
     660             :   // R600-based processors.
     661             : 
     662             :   // Radeon HD 2000/3000 Series (R600).
     663             :   EF_AMDGPU_MACH_R600_R600 = 0x001,
     664             :   EF_AMDGPU_MACH_R600_R630 = 0x002,
     665             :   EF_AMDGPU_MACH_R600_RS880 = 0x003,
     666             :   EF_AMDGPU_MACH_R600_RV670 = 0x004,
     667             :   // Radeon HD 4000 Series (R700).
     668             :   EF_AMDGPU_MACH_R600_RV710 = 0x005,
     669             :   EF_AMDGPU_MACH_R600_RV730 = 0x006,
     670             :   EF_AMDGPU_MACH_R600_RV770 = 0x007,
     671             :   // Radeon HD 5000 Series (Evergreen).
     672             :   EF_AMDGPU_MACH_R600_CEDAR = 0x008,
     673             :   EF_AMDGPU_MACH_R600_CYPRESS = 0x009,
     674             :   EF_AMDGPU_MACH_R600_JUNIPER = 0x00a,
     675             :   EF_AMDGPU_MACH_R600_REDWOOD = 0x00b,
     676             :   EF_AMDGPU_MACH_R600_SUMO = 0x00c,
     677             :   // Radeon HD 6000 Series (Northern Islands).
     678             :   EF_AMDGPU_MACH_R600_BARTS = 0x00d,
     679             :   EF_AMDGPU_MACH_R600_CAICOS = 0x00e,
     680             :   EF_AMDGPU_MACH_R600_CAYMAN = 0x00f,
     681             :   EF_AMDGPU_MACH_R600_TURKS = 0x010,
     682             : 
     683             :   // Reserved for R600-based processors.
     684             :   EF_AMDGPU_MACH_R600_RESERVED_FIRST = 0x011,
     685             :   EF_AMDGPU_MACH_R600_RESERVED_LAST = 0x01f,
     686             : 
     687             :   // First/last R600-based processors.
     688             :   EF_AMDGPU_MACH_R600_FIRST = EF_AMDGPU_MACH_R600_R600,
     689             :   EF_AMDGPU_MACH_R600_LAST = EF_AMDGPU_MACH_R600_TURKS,
     690             : 
     691             :   // AMDGCN-based processors.
     692             : 
     693             :   // AMDGCN GFX6.
     694             :   EF_AMDGPU_MACH_AMDGCN_GFX600 = 0x020,
     695             :   EF_AMDGPU_MACH_AMDGCN_GFX601 = 0x021,
     696             :   // AMDGCN GFX7.
     697             :   EF_AMDGPU_MACH_AMDGCN_GFX700 = 0x022,
     698             :   EF_AMDGPU_MACH_AMDGCN_GFX701 = 0x023,
     699             :   EF_AMDGPU_MACH_AMDGCN_GFX702 = 0x024,
     700             :   EF_AMDGPU_MACH_AMDGCN_GFX703 = 0x025,
     701             :   EF_AMDGPU_MACH_AMDGCN_GFX704 = 0x026,
     702             :   // AMDGCN GFX8.
     703             :   EF_AMDGPU_MACH_AMDGCN_GFX801 = 0x028,
     704             :   EF_AMDGPU_MACH_AMDGCN_GFX802 = 0x029,
     705             :   EF_AMDGPU_MACH_AMDGCN_GFX803 = 0x02a,
     706             :   EF_AMDGPU_MACH_AMDGCN_GFX810 = 0x02b,
     707             :   // AMDGCN GFX9.
     708             :   EF_AMDGPU_MACH_AMDGCN_GFX900 = 0x02c,
     709             :   EF_AMDGPU_MACH_AMDGCN_GFX902 = 0x02d,
     710             :   EF_AMDGPU_MACH_AMDGCN_GFX904 = 0x02e,
     711             :   EF_AMDGPU_MACH_AMDGCN_GFX906 = 0x02f,
     712             : 
     713             :   // Reserved for AMDGCN-based processors.
     714             :   EF_AMDGPU_MACH_AMDGCN_RESERVED0 = 0x027,
     715             :   EF_AMDGPU_MACH_AMDGCN_RESERVED1 = 0x030,
     716             : 
     717             :   // First/last AMDGCN-based processors.
     718             :   EF_AMDGPU_MACH_AMDGCN_FIRST = EF_AMDGPU_MACH_AMDGCN_GFX600,
     719             :   EF_AMDGPU_MACH_AMDGCN_LAST = EF_AMDGPU_MACH_AMDGCN_GFX906,
     720             : 
     721             :   // Indicates if the xnack target feature is enabled for all code contained in
     722             :   // the object.
     723             :   EF_AMDGPU_XNACK = 0x100,
     724             : };
     725             : 
     726             : // ELF Relocation types for AMDGPU
     727             : enum {
     728             : #include "ELFRelocs/AMDGPU.def"
     729             : };
     730             : 
     731             : // ELF Relocation types for BPF
     732             : enum {
     733             : #include "ELFRelocs/BPF.def"
     734             : };
     735             : 
     736             : #undef ELF_RELOC
     737             : 
     738             : // Section header.
     739             : struct Elf32_Shdr {
     740             :   Elf32_Word sh_name;      // Section name (index into string table)
     741             :   Elf32_Word sh_type;      // Section type (SHT_*)
     742             :   Elf32_Word sh_flags;     // Section flags (SHF_*)
     743             :   Elf32_Addr sh_addr;      // Address where section is to be loaded
     744             :   Elf32_Off sh_offset;     // File offset of section data, in bytes
     745             :   Elf32_Word sh_size;      // Size of section, in bytes
     746             :   Elf32_Word sh_link;      // Section type-specific header table index link
     747             :   Elf32_Word sh_info;      // Section type-specific extra information
     748             :   Elf32_Word sh_addralign; // Section address alignment
     749             :   Elf32_Word sh_entsize;   // Size of records contained within the section
     750             : };
     751             : 
     752             : // Section header for ELF64 - same fields as ELF32, different types.
     753             : struct Elf64_Shdr {
     754             :   Elf64_Word sh_name;
     755             :   Elf64_Word sh_type;
     756             :   Elf64_Xword sh_flags;
     757             :   Elf64_Addr sh_addr;
     758             :   Elf64_Off sh_offset;
     759             :   Elf64_Xword sh_size;
     760             :   Elf64_Word sh_link;
     761             :   Elf64_Word sh_info;
     762             :   Elf64_Xword sh_addralign;
     763             :   Elf64_Xword sh_entsize;
     764             : };
     765             : 
     766             : // Special section indices.
     767             : enum {
     768             :   SHN_UNDEF = 0,          // Undefined, missing, irrelevant, or meaningless
     769             :   SHN_LORESERVE = 0xff00, // Lowest reserved index
     770             :   SHN_LOPROC = 0xff00,    // Lowest processor-specific index
     771             :   SHN_HIPROC = 0xff1f,    // Highest processor-specific index
     772             :   SHN_LOOS = 0xff20,      // Lowest operating system-specific index
     773             :   SHN_HIOS = 0xff3f,      // Highest operating system-specific index
     774             :   SHN_ABS = 0xfff1,       // Symbol has absolute value; does not need relocation
     775             :   SHN_COMMON = 0xfff2,    // FORTRAN COMMON or C external global variables
     776             :   SHN_XINDEX = 0xffff,    // Mark that the index is >= SHN_LORESERVE
     777             :   SHN_HIRESERVE = 0xffff  // Highest reserved index
     778             : };
     779             : 
     780             : // Section types.
     781             : enum : unsigned {
     782             :   SHT_NULL = 0,                         // No associated section (inactive entry).
     783             :   SHT_PROGBITS = 1,                     // Program-defined contents.
     784             :   SHT_SYMTAB = 2,                       // Symbol table.
     785             :   SHT_STRTAB = 3,                       // String table.
     786             :   SHT_RELA = 4,                         // Relocation entries; explicit addends.
     787             :   SHT_HASH = 5,                         // Symbol hash table.
     788             :   SHT_DYNAMIC = 6,                      // Information for dynamic linking.
     789             :   SHT_NOTE = 7,                         // Information about the file.
     790             :   SHT_NOBITS = 8,                       // Data occupies no space in the file.
     791             :   SHT_REL = 9,                          // Relocation entries; no explicit addends.
     792             :   SHT_SHLIB = 10,                       // Reserved.
     793             :   SHT_DYNSYM = 11,                      // Symbol table.
     794             :   SHT_INIT_ARRAY = 14,                  // Pointers to initialization functions.
     795             :   SHT_FINI_ARRAY = 15,                  // Pointers to termination functions.
     796             :   SHT_PREINIT_ARRAY = 16,               // Pointers to pre-init functions.
     797             :   SHT_GROUP = 17,                       // Section group.
     798             :   SHT_SYMTAB_SHNDX = 18,                // Indices for SHN_XINDEX entries.
     799             :   SHT_LOOS = 0x60000000,                // Lowest operating system-specific type.
     800             :   // Android packed relocation section types.
     801             :   // https://android.googlesource.com/platform/bionic/+/6f12bfece5dcc01325e0abba56a46b1bcf991c69/tools/relocation_packer/src/elf_file.cc#37
     802             :   SHT_ANDROID_REL = 0x60000001,
     803             :   SHT_ANDROID_RELA = 0x60000002,
     804             :   SHT_LLVM_ODRTAB = 0x6fff4c00,         // LLVM ODR table.
     805             :   SHT_LLVM_LINKER_OPTIONS = 0x6fff4c01, // LLVM Linker Options.
     806             :   SHT_GNU_ATTRIBUTES = 0x6ffffff5,      // Object attributes.
     807             :   SHT_GNU_HASH = 0x6ffffff6,            // GNU-style hash table.
     808             :   SHT_GNU_verdef = 0x6ffffffd,          // GNU version definitions.
     809             :   SHT_GNU_verneed = 0x6ffffffe,         // GNU version references.
     810             :   SHT_GNU_versym = 0x6fffffff,          // GNU symbol versions table.
     811             :   SHT_HIOS = 0x6fffffff,                // Highest operating system-specific type.
     812             :   SHT_LOPROC = 0x70000000,              // Lowest processor arch-specific type.
     813             :   // Fixme: All this is duplicated in MCSectionELF. Why??
     814             :   // Exception Index table
     815             :   SHT_ARM_EXIDX = 0x70000001U,
     816             :   // BPABI DLL dynamic linking pre-emption map
     817             :   SHT_ARM_PREEMPTMAP = 0x70000002U,
     818             :   //  Object file compatibility attributes
     819             :   SHT_ARM_ATTRIBUTES = 0x70000003U,
     820             :   SHT_ARM_DEBUGOVERLAY = 0x70000004U,
     821             :   SHT_ARM_OVERLAYSECTION = 0x70000005U,
     822             :   SHT_HEX_ORDERED = 0x70000000,         // Link editor is to sort the entries in
     823             :                                         // this section based on their sizes
     824             :   SHT_X86_64_UNWIND = 0x70000001,       // Unwind information
     825             : 
     826             :   SHT_MIPS_REGINFO = 0x70000006,        // Register usage information
     827             :   SHT_MIPS_OPTIONS = 0x7000000d,        // General options
     828             :   SHT_MIPS_DWARF = 0x7000001e,          // DWARF debugging section.
     829             :   SHT_MIPS_ABIFLAGS = 0x7000002a,       // ABI information.
     830             : 
     831             :   SHT_HIPROC = 0x7fffffff,              // Highest processor arch-specific type.
     832             :   SHT_LOUSER = 0x80000000,              // Lowest type reserved for applications.
     833             :   SHT_HIUSER = 0xffffffff               // Highest type reserved for applications.
     834             : };
     835             : 
     836             : // Section flags.
     837             : enum : unsigned {
     838             :   // Section data should be writable during execution.
     839             :   SHF_WRITE = 0x1,
     840             : 
     841             :   // Section occupies memory during program execution.
     842             :   SHF_ALLOC = 0x2,
     843             : 
     844             :   // Section contains executable machine instructions.
     845             :   SHF_EXECINSTR = 0x4,
     846             : 
     847             :   // The data in this section may be merged.
     848             :   SHF_MERGE = 0x10,
     849             : 
     850             :   // The data in this section is null-terminated strings.
     851             :   SHF_STRINGS = 0x20,
     852             : 
     853             :   // A field in this section holds a section header table index.
     854             :   SHF_INFO_LINK = 0x40U,
     855             : 
     856             :   // Adds special ordering requirements for link editors.
     857             :   SHF_LINK_ORDER = 0x80U,
     858             : 
     859             :   // This section requires special OS-specific processing to avoid incorrect
     860             :   // behavior.
     861             :   SHF_OS_NONCONFORMING = 0x100U,
     862             : 
     863             :   // This section is a member of a section group.
     864             :   SHF_GROUP = 0x200U,
     865             : 
     866             :   // This section holds Thread-Local Storage.
     867             :   SHF_TLS = 0x400U,
     868             : 
     869             :   // Identifies a section containing compressed data.
     870             :   SHF_COMPRESSED = 0x800U,
     871             : 
     872             :   // This section is excluded from the final executable or shared library.
     873             :   SHF_EXCLUDE = 0x80000000U,
     874             : 
     875             :   // Start of target-specific flags.
     876             : 
     877             :   SHF_MASKOS = 0x0ff00000,
     878             : 
     879             :   // Bits indicating processor-specific flags.
     880             :   SHF_MASKPROC = 0xf0000000,
     881             : 
     882             :   /// All sections with the "d" flag are grouped together by the linker to form
     883             :   /// the data section and the dp register is set to the start of the section by
     884             :   /// the boot code.
     885             :   XCORE_SHF_DP_SECTION = 0x10000000,
     886             : 
     887             :   /// All sections with the "c" flag are grouped together by the linker to form
     888             :   /// the constant pool and the cp register is set to the start of the constant
     889             :   /// pool by the boot code.
     890             :   XCORE_SHF_CP_SECTION = 0x20000000,
     891             : 
     892             :   // If an object file section does not have this flag set, then it may not hold
     893             :   // more than 2GB and can be freely referred to in objects using smaller code
     894             :   // models. Otherwise, only objects using larger code models can refer to them.
     895             :   // For example, a medium code model object can refer to data in a section that
     896             :   // sets this flag besides being able to refer to data in a section that does
     897             :   // not set it; likewise, a small code model object can refer only to code in a
     898             :   // section that does not set this flag.
     899             :   SHF_X86_64_LARGE = 0x10000000,
     900             : 
     901             :   // All sections with the GPREL flag are grouped into a global data area
     902             :   // for faster accesses
     903             :   SHF_HEX_GPREL = 0x10000000,
     904             : 
     905             :   // Section contains text/data which may be replicated in other sections.
     906             :   // Linker must retain only one copy.
     907             :   SHF_MIPS_NODUPES = 0x01000000,
     908             : 
     909             :   // Linker must generate implicit hidden weak names.
     910             :   SHF_MIPS_NAMES = 0x02000000,
     911             : 
     912             :   // Section data local to process.
     913             :   SHF_MIPS_LOCAL = 0x04000000,
     914             : 
     915             :   // Do not strip this section.
     916             :   SHF_MIPS_NOSTRIP = 0x08000000,
     917             : 
     918             :   // Section must be part of global data area.
     919             :   SHF_MIPS_GPREL = 0x10000000,
     920             : 
     921             :   // This section should be merged.
     922             :   SHF_MIPS_MERGE = 0x20000000,
     923             : 
     924             :   // Address size to be inferred from section entry size.
     925             :   SHF_MIPS_ADDR = 0x40000000,
     926             : 
     927             :   // Section data is string data by default.
     928             :   SHF_MIPS_STRING = 0x80000000,
     929             : 
     930             :   // Make code section unreadable when in execute-only mode
     931             :   SHF_ARM_PURECODE = 0x20000000
     932             : };
     933             : 
     934             : // Section Group Flags
     935             : enum : unsigned {
     936             :   GRP_COMDAT = 0x1,
     937             :   GRP_MASKOS = 0x0ff00000,
     938             :   GRP_MASKPROC = 0xf0000000
     939             : };
     940             : 
     941             : // Symbol table entries for ELF32.
     942             : struct Elf32_Sym {
     943             :   Elf32_Word st_name;     // Symbol name (index into string table)
     944             :   Elf32_Addr st_value;    // Value or address associated with the symbol
     945             :   Elf32_Word st_size;     // Size of the symbol
     946             :   unsigned char st_info;  // Symbol's type and binding attributes
     947             :   unsigned char st_other; // Must be zero; reserved
     948             :   Elf32_Half st_shndx;    // Which section (header table index) it's defined in
     949             : 
     950             :   // These accessors and mutators correspond to the ELF32_ST_BIND,
     951             :   // ELF32_ST_TYPE, and ELF32_ST_INFO macros defined in the ELF specification:
     952             :   unsigned char getBinding() const { return st_info >> 4; }
     953             :   unsigned char getType() const { return st_info & 0x0f; }
     954             :   void setBinding(unsigned char b) { setBindingAndType(b, getType()); }
     955             :   void setType(unsigned char t) { setBindingAndType(getBinding(), t); }
     956             :   void setBindingAndType(unsigned char b, unsigned char t) {
     957             :     st_info = (b << 4) + (t & 0x0f);
     958             :   }
     959             : };
     960             : 
     961             : // Symbol table entries for ELF64.
     962             : struct Elf64_Sym {
     963             :   Elf64_Word st_name;     // Symbol name (index into string table)
     964             :   unsigned char st_info;  // Symbol's type and binding attributes
     965             :   unsigned char st_other; // Must be zero; reserved
     966             :   Elf64_Half st_shndx;    // Which section (header tbl index) it's defined in
     967             :   Elf64_Addr st_value;    // Value or address associated with the symbol
     968             :   Elf64_Xword st_size;    // Size of the symbol
     969             : 
     970             :   // These accessors and mutators are identical to those defined for ELF32
     971             :   // symbol table entries.
     972             :   unsigned char getBinding() const { return st_info >> 4; }
     973             :   unsigned char getType() const { return st_info & 0x0f; }
     974             :   void setBinding(unsigned char b) { setBindingAndType(b, getType()); }
     975             :   void setType(unsigned char t) { setBindingAndType(getBinding(), t); }
     976             :   void setBindingAndType(unsigned char b, unsigned char t) {
     977             :     st_info = (b << 4) + (t & 0x0f);
     978             :   }
     979             : };
     980             : 
     981             : // The size (in bytes) of symbol table entries.
     982             : enum {
     983             :   SYMENTRY_SIZE32 = 16, // 32-bit symbol entry size
     984             :   SYMENTRY_SIZE64 = 24  // 64-bit symbol entry size.
     985             : };
     986             : 
     987             : // Symbol bindings.
     988             : enum {
     989             :   STB_LOCAL = 0,  // Local symbol, not visible outside obj file containing def
     990             :   STB_GLOBAL = 1, // Global symbol, visible to all object files being combined
     991             :   STB_WEAK = 2,   // Weak symbol, like global but lower-precedence
     992             :   STB_GNU_UNIQUE = 10,
     993             :   STB_LOOS = 10,   // Lowest operating system-specific binding type
     994             :   STB_HIOS = 12,   // Highest operating system-specific binding type
     995             :   STB_LOPROC = 13, // Lowest processor-specific binding type
     996             :   STB_HIPROC = 15  // Highest processor-specific binding type
     997             : };
     998             : 
     999             : // Symbol types.
    1000             : enum {
    1001             :   STT_NOTYPE = 0,     // Symbol's type is not specified
    1002             :   STT_OBJECT = 1,     // Symbol is a data object (variable, array, etc.)
    1003             :   STT_FUNC = 2,       // Symbol is executable code (function, etc.)
    1004             :   STT_SECTION = 3,    // Symbol refers to a section
    1005             :   STT_FILE = 4,       // Local, absolute symbol that refers to a file
    1006             :   STT_COMMON = 5,     // An uninitialized common block
    1007             :   STT_TLS = 6,        // Thread local data object
    1008             :   STT_GNU_IFUNC = 10, // GNU indirect function
    1009             :   STT_LOOS = 10,      // Lowest operating system-specific symbol type
    1010             :   STT_HIOS = 12,      // Highest operating system-specific symbol type
    1011             :   STT_LOPROC = 13,    // Lowest processor-specific symbol type
    1012             :   STT_HIPROC = 15,    // Highest processor-specific symbol type
    1013             : 
    1014             :   // AMDGPU symbol types
    1015             :   STT_AMDGPU_HSA_KERNEL = 10
    1016             : };
    1017             : 
    1018             : enum {
    1019             :   STV_DEFAULT = 0,  // Visibility is specified by binding type
    1020             :   STV_INTERNAL = 1, // Defined by processor supplements
    1021             :   STV_HIDDEN = 2,   // Not visible to other components
    1022             :   STV_PROTECTED = 3 // Visible in other components but not preemptable
    1023             : };
    1024             : 
    1025             : // Symbol number.
    1026             : enum { STN_UNDEF = 0 };
    1027             : 
    1028             : // Special relocation symbols used in the MIPS64 ELF relocation entries
    1029             : enum {
    1030             :   RSS_UNDEF = 0, // None
    1031             :   RSS_GP = 1,    // Value of gp
    1032             :   RSS_GP0 = 2,   // Value of gp used to create object being relocated
    1033             :   RSS_LOC = 3    // Address of location being relocated
    1034             : };
    1035             : 
    1036             : // Relocation entry, without explicit addend.
    1037             : struct Elf32_Rel {
    1038             :   Elf32_Addr r_offset; // Location (file byte offset, or program virtual addr)
    1039             :   Elf32_Word r_info;   // Symbol table index and type of relocation to apply
    1040             : 
    1041             :   // These accessors and mutators correspond to the ELF32_R_SYM, ELF32_R_TYPE,
    1042             :   // and ELF32_R_INFO macros defined in the ELF specification:
    1043             :   Elf32_Word getSymbol() const { return (r_info >> 8); }
    1044             :   unsigned char getType() const { return (unsigned char)(r_info & 0x0ff); }
    1045             :   void setSymbol(Elf32_Word s) { setSymbolAndType(s, getType()); }
    1046             :   void setType(unsigned char t) { setSymbolAndType(getSymbol(), t); }
    1047             :   void setSymbolAndType(Elf32_Word s, unsigned char t) {
    1048             :     r_info = (s << 8) + t;
    1049             :   }
    1050             : };
    1051             : 
    1052             : // Relocation entry with explicit addend.
    1053             : struct Elf32_Rela {
    1054             :   Elf32_Addr r_offset;  // Location (file byte offset, or program virtual addr)
    1055             :   Elf32_Word r_info;    // Symbol table index and type of relocation to apply
    1056             :   Elf32_Sword r_addend; // Compute value for relocatable field by adding this
    1057             : 
    1058             :   // These accessors and mutators correspond to the ELF32_R_SYM, ELF32_R_TYPE,
    1059             :   // and ELF32_R_INFO macros defined in the ELF specification:
    1060             :   Elf32_Word getSymbol() const { return (r_info >> 8); }
    1061             :   unsigned char getType() const { return (unsigned char)(r_info & 0x0ff); }
    1062             :   void setSymbol(Elf32_Word s) { setSymbolAndType(s, getType()); }
    1063             :   void setType(unsigned char t) { setSymbolAndType(getSymbol(), t); }
    1064             :   void setSymbolAndType(Elf32_Word s, unsigned char t) {
    1065      689892 :     r_info = (s << 8) + t;
    1066             :   }
    1067             : };
    1068             : 
    1069             : // Relocation entry, without explicit addend.
    1070             : struct Elf64_Rel {
    1071             :   Elf64_Addr r_offset; // Location (file byte offset, or program virtual addr).
    1072             :   Elf64_Xword r_info;  // Symbol table index and type of relocation to apply.
    1073             : 
    1074             :   // These accessors and mutators correspond to the ELF64_R_SYM, ELF64_R_TYPE,
    1075             :   // and ELF64_R_INFO macros defined in the ELF specification:
    1076             :   Elf64_Word getSymbol() const { return (r_info >> 32); }
    1077             :   Elf64_Word getType() const { return (Elf64_Word)(r_info & 0xffffffffL); }
    1078             :   void setSymbol(Elf64_Word s) { setSymbolAndType(s, getType()); }
    1079             :   void setType(Elf64_Word t) { setSymbolAndType(getSymbol(), t); }
    1080             :   void setSymbolAndType(Elf64_Word s, Elf64_Word t) {
    1081             :     r_info = ((Elf64_Xword)s << 32) + (t & 0xffffffffL);
    1082             :   }
    1083             : };
    1084             : 
    1085             : // Relocation entry with explicit addend.
    1086             : struct Elf64_Rela {
    1087             :   Elf64_Addr r_offset; // Location (file byte offset, or program virtual addr).
    1088             :   Elf64_Xword r_info;  // Symbol table index and type of relocation to apply.
    1089             :   Elf64_Sxword r_addend; // Compute value for relocatable field by adding this.
    1090             : 
    1091             :   // These accessors and mutators correspond to the ELF64_R_SYM, ELF64_R_TYPE,
    1092             :   // and ELF64_R_INFO macros defined in the ELF specification:
    1093             :   Elf64_Word getSymbol() const { return (r_info >> 32); }
    1094             :   Elf64_Word getType() const { return (Elf64_Word)(r_info & 0xffffffffL); }
    1095             :   void setSymbol(Elf64_Word s) { setSymbolAndType(s, getType()); }
    1096             :   void setType(Elf64_Word t) { setSymbolAndType(getSymbol(), t); }
    1097             :   void setSymbolAndType(Elf64_Word s, Elf64_Word t) {
    1098     1529615 :     r_info = ((Elf64_Xword)s << 32) + (t & 0xffffffffL);
    1099             :   }
    1100             : };
    1101             : 
    1102             : // Program header for ELF32.
    1103             : struct Elf32_Phdr {
    1104             :   Elf32_Word p_type;   // Type of segment
    1105             :   Elf32_Off p_offset;  // File offset where segment is located, in bytes
    1106             :   Elf32_Addr p_vaddr;  // Virtual address of beginning of segment
    1107             :   Elf32_Addr p_paddr;  // Physical address of beginning of segment (OS-specific)
    1108             :   Elf32_Word p_filesz; // Num. of bytes in file image of segment (may be zero)
    1109             :   Elf32_Word p_memsz;  // Num. of bytes in mem image of segment (may be zero)
    1110             :   Elf32_Word p_flags;  // Segment flags
    1111             :   Elf32_Word p_align;  // Segment alignment constraint
    1112             : };
    1113             : 
    1114             : // Program header for ELF64.
    1115             : struct Elf64_Phdr {
    1116             :   Elf64_Word p_type;    // Type of segment
    1117             :   Elf64_Word p_flags;   // Segment flags
    1118             :   Elf64_Off p_offset;   // File offset where segment is located, in bytes
    1119             :   Elf64_Addr p_vaddr;   // Virtual address of beginning of segment
    1120             :   Elf64_Addr p_paddr;   // Physical addr of beginning of segment (OS-specific)
    1121             :   Elf64_Xword p_filesz; // Num. of bytes in file image of segment (may be zero)
    1122             :   Elf64_Xword p_memsz;  // Num. of bytes in mem image of segment (may be zero)
    1123             :   Elf64_Xword p_align;  // Segment alignment constraint
    1124             : };
    1125             : 
    1126             : // Segment types.
    1127             : enum {
    1128             :   PT_NULL = 0,            // Unused segment.
    1129             :   PT_LOAD = 1,            // Loadable segment.
    1130             :   PT_DYNAMIC = 2,         // Dynamic linking information.
    1131             :   PT_INTERP = 3,          // Interpreter pathname.
    1132             :   PT_NOTE = 4,            // Auxiliary information.
    1133             :   PT_SHLIB = 5,           // Reserved.
    1134             :   PT_PHDR = 6,            // The program header table itself.
    1135             :   PT_TLS = 7,             // The thread-local storage template.
    1136             :   PT_LOOS = 0x60000000,   // Lowest operating system-specific pt entry type.
    1137             :   PT_HIOS = 0x6fffffff,   // Highest operating system-specific pt entry type.
    1138             :   PT_LOPROC = 0x70000000, // Lowest processor-specific program hdr entry type.
    1139             :   PT_HIPROC = 0x7fffffff, // Highest processor-specific program hdr entry type.
    1140             : 
    1141             :   // x86-64 program header types.
    1142             :   // These all contain stack unwind tables.
    1143             :   PT_GNU_EH_FRAME = 0x6474e550,
    1144             :   PT_SUNW_EH_FRAME = 0x6474e550,
    1145             :   PT_SUNW_UNWIND = 0x6464e550,
    1146             : 
    1147             :   PT_GNU_STACK = 0x6474e551, // Indicates stack executability.
    1148             :   PT_GNU_RELRO = 0x6474e552, // Read-only after relocation.
    1149             : 
    1150             :   PT_OPENBSD_RANDOMIZE = 0x65a3dbe6, // Fill with random data.
    1151             :   PT_OPENBSD_WXNEEDED = 0x65a3dbe7,  // Program does W^X violations.
    1152             :   PT_OPENBSD_BOOTDATA = 0x65a41be6,  // Section for boot arguments.
    1153             : 
    1154             :   // ARM program header types.
    1155             :   PT_ARM_ARCHEXT = 0x70000000, // Platform architecture compatibility info
    1156             :   // These all contain stack unwind tables.
    1157             :   PT_ARM_EXIDX = 0x70000001,
    1158             :   PT_ARM_UNWIND = 0x70000001,
    1159             : 
    1160             :   // MIPS program header types.
    1161             :   PT_MIPS_REGINFO = 0x70000000,  // Register usage information.
    1162             :   PT_MIPS_RTPROC = 0x70000001,   // Runtime procedure table.
    1163             :   PT_MIPS_OPTIONS = 0x70000002,  // Options segment.
    1164             :   PT_MIPS_ABIFLAGS = 0x70000003, // Abiflags segment.
    1165             : 
    1166             :   // WebAssembly program header types.
    1167             :   PT_WEBASSEMBLY_FUNCTIONS = PT_LOPROC + 0, // Function definitions.
    1168             : };
    1169             : 
    1170             : // Segment flag bits.
    1171             : enum : unsigned {
    1172             :   PF_X = 1,                // Execute
    1173             :   PF_W = 2,                // Write
    1174             :   PF_R = 4,                // Read
    1175             :   PF_MASKOS = 0x0ff00000,  // Bits for operating system-specific semantics.
    1176             :   PF_MASKPROC = 0xf0000000 // Bits for processor-specific semantics.
    1177             : };
    1178             : 
    1179             : // Dynamic table entry for ELF32.
    1180             : struct Elf32_Dyn {
    1181             :   Elf32_Sword d_tag; // Type of dynamic table entry.
    1182             :   union {
    1183             :     Elf32_Word d_val; // Integer value of entry.
    1184             :     Elf32_Addr d_ptr; // Pointer value of entry.
    1185             :   } d_un;
    1186             : };
    1187             : 
    1188             : // Dynamic table entry for ELF64.
    1189             : struct Elf64_Dyn {
    1190             :   Elf64_Sxword d_tag; // Type of dynamic table entry.
    1191             :   union {
    1192             :     Elf64_Xword d_val; // Integer value of entry.
    1193             :     Elf64_Addr d_ptr;  // Pointer value of entry.
    1194             :   } d_un;
    1195             : };
    1196             : 
    1197             : // Dynamic table entry tags.
    1198             : enum {
    1199             : #define DYNAMIC_TAG(name, value) DT_##name = value,
    1200             : #include "DynamicTags.def"
    1201             : #undef DYNAMIC_TAG
    1202             : };
    1203             : 
    1204             : // DT_FLAGS values.
    1205             : enum {
    1206             :   DF_ORIGIN = 0x01,    // The object may reference $ORIGIN.
    1207             :   DF_SYMBOLIC = 0x02,  // Search the shared lib before searching the exe.
    1208             :   DF_TEXTREL = 0x04,   // Relocations may modify a non-writable segment.
    1209             :   DF_BIND_NOW = 0x08,  // Process all relocations on load.
    1210             :   DF_STATIC_TLS = 0x10 // Reject attempts to load dynamically.
    1211             : };
    1212             : 
    1213             : // State flags selectable in the `d_un.d_val' element of the DT_FLAGS_1 entry.
    1214             : enum {
    1215             :   DF_1_NOW = 0x00000001,       // Set RTLD_NOW for this object.
    1216             :   DF_1_GLOBAL = 0x00000002,    // Set RTLD_GLOBAL for this object.
    1217             :   DF_1_GROUP = 0x00000004,     // Set RTLD_GROUP for this object.
    1218             :   DF_1_NODELETE = 0x00000008,  // Set RTLD_NODELETE for this object.
    1219             :   DF_1_LOADFLTR = 0x00000010,  // Trigger filtee loading at runtime.
    1220             :   DF_1_INITFIRST = 0x00000020, // Set RTLD_INITFIRST for this object.
    1221             :   DF_1_NOOPEN = 0x00000040,    // Set RTLD_NOOPEN for this object.
    1222             :   DF_1_ORIGIN = 0x00000080,    // $ORIGIN must be handled.
    1223             :   DF_1_DIRECT = 0x00000100,    // Direct binding enabled.
    1224             :   DF_1_TRANS = 0x00000200,
    1225             :   DF_1_INTERPOSE = 0x00000400,  // Object is used to interpose.
    1226             :   DF_1_NODEFLIB = 0x00000800,   // Ignore default lib search path.
    1227             :   DF_1_NODUMP = 0x00001000,     // Object can't be dldump'ed.
    1228             :   DF_1_CONFALT = 0x00002000,    // Configuration alternative created.
    1229             :   DF_1_ENDFILTEE = 0x00004000,  // Filtee terminates filters search.
    1230             :   DF_1_DISPRELDNE = 0x00008000, // Disp reloc applied at build time.
    1231             :   DF_1_DISPRELPND = 0x00010000, // Disp reloc applied at run-time.
    1232             :   DF_1_NODIRECT = 0x00020000,   // Object has no-direct binding.
    1233             :   DF_1_IGNMULDEF = 0x00040000,
    1234             :   DF_1_NOKSYMS = 0x00080000,
    1235             :   DF_1_NOHDR = 0x00100000,
    1236             :   DF_1_EDITED = 0x00200000, // Object is modified after built.
    1237             :   DF_1_NORELOC = 0x00400000,
    1238             :   DF_1_SYMINTPOSE = 0x00800000, // Object has individual interposers.
    1239             :   DF_1_GLOBAUDIT = 0x01000000,  // Global auditing required.
    1240             :   DF_1_SINGLETON = 0x02000000   // Singleton symbols are used.
    1241             : };
    1242             : 
    1243             : // DT_MIPS_FLAGS values.
    1244             : enum {
    1245             :   RHF_NONE = 0x00000000,                   // No flags.
    1246             :   RHF_QUICKSTART = 0x00000001,             // Uses shortcut pointers.
    1247             :   RHF_NOTPOT = 0x00000002,                 // Hash size is not a power of two.
    1248             :   RHS_NO_LIBRARY_REPLACEMENT = 0x00000004, // Ignore LD_LIBRARY_PATH.
    1249             :   RHF_NO_MOVE = 0x00000008,                // DSO address may not be relocated.
    1250             :   RHF_SGI_ONLY = 0x00000010,               // SGI specific features.
    1251             :   RHF_GUARANTEE_INIT = 0x00000020,         // Guarantee that .init will finish
    1252             :                                            // executing before any non-init
    1253             :                                            // code in DSO is called.
    1254             :   RHF_DELTA_C_PLUS_PLUS = 0x00000040,      // Contains Delta C++ code.
    1255             :   RHF_GUARANTEE_START_INIT = 0x00000080,   // Guarantee that .init will start
    1256             :                                            // executing before any non-init
    1257             :                                            // code in DSO is called.
    1258             :   RHF_PIXIE = 0x00000100,                  // Generated by pixie.
    1259             :   RHF_DEFAULT_DELAY_LOAD = 0x00000200,     // Delay-load DSO by default.
    1260             :   RHF_REQUICKSTART = 0x00000400,           // Object may be requickstarted
    1261             :   RHF_REQUICKSTARTED = 0x00000800,         // Object has been requickstarted
    1262             :   RHF_CORD = 0x00001000,                   // Generated by cord.
    1263             :   RHF_NO_UNRES_UNDEF = 0x00002000,         // Object contains no unresolved
    1264             :                                            // undef symbols.
    1265             :   RHF_RLD_ORDER_SAFE = 0x00004000          // Symbol table is in a safe order.
    1266             : };
    1267             : 
    1268             : // ElfXX_VerDef structure version (GNU versioning)
    1269             : enum { VER_DEF_NONE = 0, VER_DEF_CURRENT = 1 };
    1270             : 
    1271             : // VerDef Flags (ElfXX_VerDef::vd_flags)
    1272             : enum { VER_FLG_BASE = 0x1, VER_FLG_WEAK = 0x2, VER_FLG_INFO = 0x4 };
    1273             : 
    1274             : // Special constants for the version table. (SHT_GNU_versym/.gnu.version)
    1275             : enum {
    1276             :   VER_NDX_LOCAL = 0,       // Unversioned local symbol
    1277             :   VER_NDX_GLOBAL = 1,      // Unversioned global symbol
    1278             :   VERSYM_VERSION = 0x7fff, // Version Index mask
    1279             :   VERSYM_HIDDEN = 0x8000   // Hidden bit (non-default version)
    1280             : };
    1281             : 
    1282             : // ElfXX_VerNeed structure version (GNU versioning)
    1283             : enum { VER_NEED_NONE = 0, VER_NEED_CURRENT = 1 };
    1284             : 
    1285             : // SHT_NOTE section types
    1286             : enum {
    1287             :   NT_FREEBSD_THRMISC = 7,
    1288             :   NT_FREEBSD_PROCSTAT_PROC = 8,
    1289             :   NT_FREEBSD_PROCSTAT_FILES = 9,
    1290             :   NT_FREEBSD_PROCSTAT_VMMAP = 10,
    1291             :   NT_FREEBSD_PROCSTAT_GROUPS = 11,
    1292             :   NT_FREEBSD_PROCSTAT_UMASK = 12,
    1293             :   NT_FREEBSD_PROCSTAT_RLIMIT = 13,
    1294             :   NT_FREEBSD_PROCSTAT_OSREL = 14,
    1295             :   NT_FREEBSD_PROCSTAT_PSSTRINGS = 15,
    1296             :   NT_FREEBSD_PROCSTAT_AUXV = 16,
    1297             : };
    1298             : 
    1299             : enum {
    1300             :   NT_GNU_ABI_TAG = 1,
    1301             :   NT_GNU_HWCAP = 2,
    1302             :   NT_GNU_BUILD_ID = 3,
    1303             :   NT_GNU_GOLD_VERSION = 4,
    1304             :   NT_GNU_PROPERTY_TYPE_0 = 5,
    1305             : };
    1306             : 
    1307             : // Property types used in GNU_PROPERTY_TYPE_0 notes.
    1308             : enum {
    1309             :   GNU_PROPERTY_STACK_SIZE = 1,
    1310             :   GNU_PROPERTY_NO_COPY_ON_PROTECTED = 2,
    1311             : };
    1312             : 
    1313             : // AMDGPU specific notes.
    1314             : enum {
    1315             :   // Note types with values between 0 and 9 (inclusive) are reserved.
    1316             :   NT_AMD_AMDGPU_HSA_METADATA = 10,
    1317             :   NT_AMD_AMDGPU_ISA = 11,
    1318             :   NT_AMD_AMDGPU_PAL_METADATA = 12
    1319             : };
    1320             : 
    1321             : enum {
    1322             :   GNU_ABI_TAG_LINUX = 0,
    1323             :   GNU_ABI_TAG_HURD = 1,
    1324             :   GNU_ABI_TAG_SOLARIS = 2,
    1325             :   GNU_ABI_TAG_FREEBSD = 3,
    1326             :   GNU_ABI_TAG_NETBSD = 4,
    1327             :   GNU_ABI_TAG_SYLLABLE = 5,
    1328             :   GNU_ABI_TAG_NACL = 6,
    1329             : };
    1330             : 
    1331             : // Android packed relocation group flags.
    1332             : enum {
    1333             :   RELOCATION_GROUPED_BY_INFO_FLAG = 1,
    1334             :   RELOCATION_GROUPED_BY_OFFSET_DELTA_FLAG = 2,
    1335             :   RELOCATION_GROUPED_BY_ADDEND_FLAG = 4,
    1336             :   RELOCATION_GROUP_HAS_ADDEND_FLAG = 8,
    1337             : };
    1338             : 
    1339             : // Compressed section header for ELF32.
    1340             : struct Elf32_Chdr {
    1341             :   Elf32_Word ch_type;
    1342             :   Elf32_Word ch_size;
    1343             :   Elf32_Word ch_addralign;
    1344             : };
    1345             : 
    1346             : // Compressed section header for ELF64.
    1347             : struct Elf64_Chdr {
    1348             :   Elf64_Word ch_type;
    1349             :   Elf64_Word ch_reserved;
    1350             :   Elf64_Xword ch_size;
    1351             :   Elf64_Xword ch_addralign;
    1352             : };
    1353             : 
    1354             : // Node header for ELF32.
    1355             : struct Elf32_Nhdr {
    1356             :   Elf32_Word n_namesz;
    1357             :   Elf32_Word n_descsz;
    1358             :   Elf32_Word n_type;
    1359             : };
    1360             : 
    1361             : // Node header for ELF64.
    1362             : struct Elf64_Nhdr {
    1363             :   Elf64_Word n_namesz;
    1364             :   Elf64_Word n_descsz;
    1365             :   Elf64_Word n_type;
    1366             : };
    1367             : 
    1368             : // Legal values for ch_type field of compressed section header.
    1369             : enum {
    1370             :   ELFCOMPRESS_ZLIB = 1,            // ZLIB/DEFLATE algorithm.
    1371             :   ELFCOMPRESS_LOOS = 0x60000000,   // Start of OS-specific.
    1372             :   ELFCOMPRESS_HIOS = 0x6fffffff,   // End of OS-specific.
    1373             :   ELFCOMPRESS_LOPROC = 0x70000000, // Start of processor-specific.
    1374             :   ELFCOMPRESS_HIPROC = 0x7fffffff  // End of processor-specific.
    1375             : };
    1376             : 
    1377             : } // end namespace ELF
    1378             : } // end namespace llvm
    1379             : 
    1380             : #endif // LLVM_BINARYFORMAT_ELF_H

Generated by: LCOV version 1.13