Index: stable/11/contrib/llvm-project/llvm/include/llvm/BinaryFormat/ELF.h =================================================================== --- stable/11/contrib/llvm-project/llvm/include/llvm/BinaryFormat/ELF.h (revision 361946) +++ stable/11/contrib/llvm-project/llvm/include/llvm/BinaryFormat/ELF.h (revision 361947) @@ -1,1574 +1,1575 @@ //===- llvm/BinaryFormat/ELF.h - ELF constants and structures ---*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // 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_BINARYFORMAT_ELF_H #define LLVM_BINARYFORMAT_ELF_H #include #include namespace llvm { namespace ELF { using Elf32_Addr = uint32_t; // Program address using Elf32_Off = uint32_t; // File offset using Elf32_Half = uint16_t; using Elf32_Word = uint32_t; using Elf32_Sword = int32_t; using Elf64_Addr = uint64_t; using Elf64_Off = uint64_t; using Elf64_Half = uint16_t; using Elf64_Word = uint32_t; using Elf64_Sword = int32_t; using Elf64_Xword = uint64_t; using Elf64_Sxword = int64_t; // 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_Half e_type; Elf64_Half e_machine; Elf64_Word e_version; Elf64_Addr e_entry; Elf64_Off e_phoff; Elf64_Off e_shoff; Elf64_Word e_flags; Elf64_Half e_ehsize; Elf64_Half e_phentsize; Elf64_Half e_phnum; Elf64_Half e_shentsize; Elf64_Half e_shnum; Elf64_Half 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 // See current registered ELF machine architectures at: // http://www.uxsglobal.com/developers/gabi/latest/ch4.eheader.html 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_IAMCU = 6, // Intel MCU EM_860 = 7, // Intel 80860 EM_MIPS = 8, // MIPS R3000 EM_S370 = 9, // IBM System/370 EM_MIPS_RS3_LE = 10, // MIPS RS3000 Little-endian EM_PARISC = 15, // Hewlett-Packard PA-RISC EM_VPP500 = 17, // Fujitsu VPP500 EM_SPARC32PLUS = 18, // Enhanced instruction set SPARC EM_960 = 19, // Intel 80960 EM_PPC = 20, // PowerPC EM_PPC64 = 21, // PowerPC64 EM_S390 = 22, // IBM System/390 EM_SPU = 23, // IBM SPU/SPC EM_V800 = 36, // NEC V800 EM_FR20 = 37, // Fujitsu FR20 EM_RH32 = 38, // TRW RH-32 EM_RCE = 39, // Motorola RCE EM_ARM = 40, // ARM EM_ALPHA = 41, // DEC Alpha EM_SH = 42, // Hitachi SH EM_SPARCV9 = 43, // SPARC V9 EM_TRICORE = 44, // Siemens TriCore EM_ARC = 45, // Argonaut RISC Core EM_H8_300 = 46, // Hitachi H8/300 EM_H8_300H = 47, // Hitachi H8/300H EM_H8S = 48, // Hitachi H8S EM_H8_500 = 49, // Hitachi H8/500 EM_IA_64 = 50, // Intel IA-64 processor architecture EM_MIPS_X = 51, // Stanford MIPS-X EM_COLDFIRE = 52, // Motorola ColdFire EM_68HC12 = 53, // Motorola M68HC12 EM_MMA = 54, // Fujitsu MMA Multimedia Accelerator EM_PCP = 55, // Siemens PCP EM_NCPU = 56, // Sony nCPU embedded RISC processor EM_NDR1 = 57, // Denso NDR1 microprocessor EM_STARCORE = 58, // Motorola Star*Core processor EM_ME16 = 59, // Toyota ME16 processor EM_ST100 = 60, // STMicroelectronics ST100 processor EM_TINYJ = 61, // Advanced Logic Corp. TinyJ embedded processor family EM_X86_64 = 62, // AMD x86-64 architecture EM_PDSP = 63, // Sony DSP Processor EM_PDP10 = 64, // Digital Equipment Corp. PDP-10 EM_PDP11 = 65, // Digital Equipment Corp. PDP-11 EM_FX66 = 66, // Siemens FX66 microcontroller EM_ST9PLUS = 67, // STMicroelectronics ST9+ 8/16 bit microcontroller EM_ST7 = 68, // STMicroelectronics ST7 8-bit microcontroller EM_68HC16 = 69, // Motorola MC68HC16 Microcontroller EM_68HC11 = 70, // Motorola MC68HC11 Microcontroller EM_68HC08 = 71, // Motorola MC68HC08 Microcontroller EM_68HC05 = 72, // Motorola MC68HC05 Microcontroller EM_SVX = 73, // Silicon Graphics SVx EM_ST19 = 74, // STMicroelectronics ST19 8-bit microcontroller EM_VAX = 75, // Digital VAX EM_CRIS = 76, // Axis Communications 32-bit embedded processor EM_JAVELIN = 77, // Infineon Technologies 32-bit embedded processor EM_FIREPATH = 78, // Element 14 64-bit DSP Processor EM_ZSP = 79, // LSI Logic 16-bit DSP Processor EM_MMIX = 80, // Donald Knuth's educational 64-bit processor EM_HUANY = 81, // Harvard University machine-independent object files EM_PRISM = 82, // SiTera Prism EM_AVR = 83, // Atmel AVR 8-bit microcontroller EM_FR30 = 84, // Fujitsu FR30 EM_D10V = 85, // Mitsubishi D10V EM_D30V = 86, // Mitsubishi D30V EM_V850 = 87, // NEC v850 EM_M32R = 88, // Mitsubishi M32R EM_MN10300 = 89, // Matsushita MN10300 EM_MN10200 = 90, // Matsushita MN10200 EM_PJ = 91, // picoJava EM_OPENRISC = 92, // OpenRISC 32-bit embedded processor EM_ARC_COMPACT = 93, // ARC International ARCompact processor (old // spelling/synonym: EM_ARC_A5) EM_XTENSA = 94, // Tensilica Xtensa Architecture EM_VIDEOCORE = 95, // Alphamosaic VideoCore processor EM_TMM_GPP = 96, // Thompson Multimedia General Purpose Processor EM_NS32K = 97, // National Semiconductor 32000 series EM_TPC = 98, // Tenor Network TPC processor EM_SNP1K = 99, // Trebia SNP 1000 processor EM_ST200 = 100, // STMicroelectronics (www.st.com) ST200 EM_IP2K = 101, // Ubicom IP2xxx microcontroller family EM_MAX = 102, // MAX Processor EM_CR = 103, // National Semiconductor CompactRISC microprocessor EM_F2MC16 = 104, // Fujitsu F2MC16 EM_MSP430 = 105, // Texas Instruments embedded microcontroller msp430 EM_BLACKFIN = 106, // Analog Devices Blackfin (DSP) processor EM_SE_C33 = 107, // S1C33 Family of Seiko Epson processors EM_SEP = 108, // Sharp embedded microprocessor EM_ARCA = 109, // Arca RISC Microprocessor EM_UNICORE = 110, // Microprocessor series from PKU-Unity Ltd. and MPRC // of Peking University EM_EXCESS = 111, // eXcess: 16/32/64-bit configurable embedded CPU EM_DXP = 112, // Icera Semiconductor Inc. Deep Execution Processor EM_ALTERA_NIOS2 = 113, // Altera Nios II soft-core processor EM_CRX = 114, // National Semiconductor CompactRISC CRX EM_XGATE = 115, // Motorola XGATE embedded processor EM_C166 = 116, // Infineon C16x/XC16x processor EM_M16C = 117, // Renesas M16C series microprocessors EM_DSPIC30F = 118, // Microchip Technology dsPIC30F Digital Signal // Controller EM_CE = 119, // Freescale Communication Engine RISC core EM_M32C = 120, // Renesas M32C series microprocessors EM_TSK3000 = 131, // Altium TSK3000 core EM_RS08 = 132, // Freescale RS08 embedded processor EM_SHARC = 133, // Analog Devices SHARC family of 32-bit DSP // processors EM_ECOG2 = 134, // Cyan Technology eCOG2 microprocessor EM_SCORE7 = 135, // Sunplus S+core7 RISC processor EM_DSP24 = 136, // New Japan Radio (NJR) 24-bit DSP Processor EM_VIDEOCORE3 = 137, // Broadcom VideoCore III processor EM_LATTICEMICO32 = 138, // RISC processor for Lattice FPGA architecture EM_SE_C17 = 139, // Seiko Epson C17 family EM_TI_C6000 = 140, // The Texas Instruments TMS320C6000 DSP family EM_TI_C2000 = 141, // The Texas Instruments TMS320C2000 DSP family EM_TI_C5500 = 142, // The Texas Instruments TMS320C55x DSP family EM_MMDSP_PLUS = 160, // STMicroelectronics 64bit VLIW Data Signal Processor EM_CYPRESS_M8C = 161, // Cypress M8C microprocessor EM_R32C = 162, // Renesas R32C series microprocessors EM_TRIMEDIA = 163, // NXP Semiconductors TriMedia architecture family EM_HEXAGON = 164, // Qualcomm Hexagon processor EM_8051 = 165, // Intel 8051 and variants EM_STXP7X = 166, // STMicroelectronics STxP7x family of configurable // and extensible RISC processors EM_NDS32 = 167, // Andes Technology compact code size embedded RISC // processor family EM_ECOG1 = 168, // Cyan Technology eCOG1X family EM_ECOG1X = 168, // Cyan Technology eCOG1X family EM_MAXQ30 = 169, // Dallas Semiconductor MAXQ30 Core Micro-controllers EM_XIMO16 = 170, // New Japan Radio (NJR) 16-bit DSP Processor EM_MANIK = 171, // M2000 Reconfigurable RISC Microprocessor EM_CRAYNV2 = 172, // Cray Inc. NV2 vector architecture EM_RX = 173, // Renesas RX family EM_METAG = 174, // Imagination Technologies META processor // architecture EM_MCST_ELBRUS = 175, // MCST Elbrus general purpose hardware architecture EM_ECOG16 = 176, // Cyan Technology eCOG16 family EM_CR16 = 177, // National Semiconductor CompactRISC CR16 16-bit // microprocessor EM_ETPU = 178, // Freescale Extended Time Processing Unit EM_SLE9X = 179, // Infineon Technologies SLE9X core EM_L10M = 180, // Intel L10M EM_K10M = 181, // Intel K10M EM_AARCH64 = 183, // ARM AArch64 EM_AVR32 = 185, // Atmel Corporation 32-bit microprocessor family EM_STM8 = 186, // STMicroeletronics STM8 8-bit microcontroller EM_TILE64 = 187, // Tilera TILE64 multicore architecture family EM_TILEPRO = 188, // Tilera TILEPro multicore architecture family EM_CUDA = 190, // NVIDIA CUDA architecture EM_TILEGX = 191, // Tilera TILE-Gx multicore architecture family EM_CLOUDSHIELD = 192, // CloudShield architecture family EM_COREA_1ST = 193, // KIPO-KAIST Core-A 1st generation processor family EM_COREA_2ND = 194, // KIPO-KAIST Core-A 2nd generation processor family EM_ARC_COMPACT2 = 195, // Synopsys ARCompact V2 EM_OPEN8 = 196, // Open8 8-bit RISC soft processor core EM_RL78 = 197, // Renesas RL78 family EM_VIDEOCORE5 = 198, // Broadcom VideoCore V processor EM_78KOR = 199, // Renesas 78KOR family EM_56800EX = 200, // Freescale 56800EX Digital Signal Controller (DSC) EM_BA1 = 201, // Beyond BA1 CPU architecture EM_BA2 = 202, // Beyond BA2 CPU architecture EM_XCORE = 203, // XMOS xCORE processor family EM_MCHP_PIC = 204, // Microchip 8-bit PIC(r) family EM_INTEL205 = 205, // Reserved by Intel EM_INTEL206 = 206, // Reserved by Intel EM_INTEL207 = 207, // Reserved by Intel EM_INTEL208 = 208, // Reserved by Intel EM_INTEL209 = 209, // Reserved by Intel EM_KM32 = 210, // KM211 KM32 32-bit processor EM_KMX32 = 211, // KM211 KMX32 32-bit processor EM_KMX16 = 212, // KM211 KMX16 16-bit processor EM_KMX8 = 213, // KM211 KMX8 8-bit processor EM_KVARC = 214, // KM211 KVARC processor EM_CDP = 215, // Paneve CDP architecture family EM_COGE = 216, // Cognitive Smart Memory Processor EM_COOL = 217, // iCelero CoolEngine EM_NORC = 218, // Nanoradio Optimized RISC EM_CSR_KALIMBA = 219, // CSR Kalimba architecture family EM_AMDGPU = 224, // AMD GPU architecture EM_RISCV = 243, // RISC-V EM_LANAI = 244, // Lanai 32-bit processor EM_BPF = 247, // Linux kernel bpf virtual machine }; // Object file classes. enum { ELFCLASSNONE = 0, 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_GNU = 3, // GNU/Linux ELFOSABI_LINUX = 3, // Historical alias for ELFOSABI_GNU. 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_CLOUDABI = 17, // Nuxi CloudABI ELFOSABI_FIRST_ARCH = 64, // First architecture-specific OS ABI ELFOSABI_AMDGPU_HSA = 64, // AMD HSA runtime ELFOSABI_AMDGPU_PAL = 65, // AMD PAL runtime ELFOSABI_AMDGPU_MESA3D = 66, // AMD GCN GPUs (GFX6+) for MESA runtime ELFOSABI_ARM = 97, // ARM ELFOSABI_C6000_ELFABI = 64, // Bare-metal TMS320C6000 ELFOSABI_C6000_LINUX = 65, // Linux TMS320C6000 ELFOSABI_STANDALONE = 255, // Standalone (embedded) application ELFOSABI_LAST_ARCH = 255 // Last Architecture-specific OS ABI }; #define ELF_RELOC(name, value) name = value, // X86_64 relocations. enum { #include "ELFRelocs/x86_64.def" }; // i386 relocations. enum { #include "ELFRelocs/i386.def" }; // ELF Relocation types for PPC32 enum { #include "ELFRelocs/PowerPC.def" }; // Specific e_flags for PPC64 enum { // e_flags bits specifying ABI: // 1 for original ABI using function descriptors, // 2 for revised ABI without function descriptors, // 0 for unspecified or not using any features affected by the differences. EF_PPC64_ABI = 3 }; // Special values for the st_other field in the symbol table entry for PPC64. enum { STO_PPC64_LOCAL_BIT = 5, STO_PPC64_LOCAL_MASK = (7 << STO_PPC64_LOCAL_BIT) }; static inline int64_t decodePPC64LocalEntryOffset(unsigned Other) { unsigned Val = (Other & STO_PPC64_LOCAL_MASK) >> STO_PPC64_LOCAL_BIT; return ((1 << Val) >> 2) << 2; } static inline unsigned encodePPC64LocalEntryOffset(int64_t Offset) { unsigned Val = (Offset >= 4 * 4 ? (Offset >= 8 * 4 ? (Offset >= 16 * 4 ? 6 : 5) : 4) : (Offset >= 2 * 4 ? 3 : (Offset >= 1 * 4 ? 2 : 0))); return Val << STO_PPC64_LOCAL_BIT; } // ELF Relocation types for PPC64 enum { #include "ELFRelocs/PowerPC64.def" }; // ELF Relocation types for AArch64 enum { #include "ELFRelocs/AArch64.def" }; // ARM Specific e_flags enum : unsigned { EF_ARM_SOFT_FLOAT = 0x00000200U, // Legacy pre EABI_VER5 EF_ARM_ABI_FLOAT_SOFT = 0x00000200U, // EABI_VER5 EF_ARM_VFP_FLOAT = 0x00000400U, // Legacy pre EABI_VER5 EF_ARM_ABI_FLOAT_HARD = 0x00000400U, // EABI_VER5 EF_ARM_EABI_UNKNOWN = 0x00000000U, EF_ARM_EABI_VER1 = 0x01000000U, EF_ARM_EABI_VER2 = 0x02000000U, EF_ARM_EABI_VER3 = 0x03000000U, EF_ARM_EABI_VER4 = 0x04000000U, EF_ARM_EABI_VER5 = 0x05000000U, EF_ARM_EABIMASK = 0xFF000000U }; // ELF Relocation types for ARM enum { #include "ELFRelocs/ARM.def" }; // ARC Specific e_flags enum : unsigned { EF_ARC_MACH_MSK = 0x000000ff, EF_ARC_OSABI_MSK = 0x00000f00, E_ARC_MACH_ARC600 = 0x00000002, E_ARC_MACH_ARC601 = 0x00000004, E_ARC_MACH_ARC700 = 0x00000003, EF_ARC_CPU_ARCV2EM = 0x00000005, EF_ARC_CPU_ARCV2HS = 0x00000006, E_ARC_OSABI_ORIG = 0x00000000, E_ARC_OSABI_V2 = 0x00000200, E_ARC_OSABI_V3 = 0x00000300, E_ARC_OSABI_V4 = 0x00000400, EF_ARC_PIC = 0x00000100 }; // ELF Relocation types for ARC enum { #include "ELFRelocs/ARC.def" }; // AVR specific e_flags enum : unsigned { EF_AVR_ARCH_AVR1 = 1, EF_AVR_ARCH_AVR2 = 2, EF_AVR_ARCH_AVR25 = 25, EF_AVR_ARCH_AVR3 = 3, EF_AVR_ARCH_AVR31 = 31, EF_AVR_ARCH_AVR35 = 35, EF_AVR_ARCH_AVR4 = 4, EF_AVR_ARCH_AVR5 = 5, EF_AVR_ARCH_AVR51 = 51, EF_AVR_ARCH_AVR6 = 6, EF_AVR_ARCH_AVRTINY = 100, EF_AVR_ARCH_XMEGA1 = 101, EF_AVR_ARCH_XMEGA2 = 102, EF_AVR_ARCH_XMEGA3 = 103, EF_AVR_ARCH_XMEGA4 = 104, EF_AVR_ARCH_XMEGA5 = 105, EF_AVR_ARCH_XMEGA6 = 106, EF_AVR_ARCH_XMEGA7 = 107 }; // ELF Relocation types for AVR enum { #include "ELFRelocs/AVR.def" }; // Mips Specific e_flags enum : unsigned { EF_MIPS_NOREORDER = 0x00000001, // Don't reorder instructions EF_MIPS_PIC = 0x00000002, // Position independent code EF_MIPS_CPIC = 0x00000004, // Call object with Position independent code EF_MIPS_ABI2 = 0x00000020, // File uses N32 ABI EF_MIPS_32BITMODE = 0x00000100, // Code compiled for a 64-bit machine // in 32-bit mode EF_MIPS_FP64 = 0x00000200, // Code compiled for a 32-bit machine // but uses 64-bit FP registers EF_MIPS_NAN2008 = 0x00000400, // Uses IEE 754-2008 NaN encoding // ABI flags EF_MIPS_ABI_O32 = 0x00001000, // This file follows the first MIPS 32 bit ABI EF_MIPS_ABI_O64 = 0x00002000, // O32 ABI extended for 64-bit architecture. EF_MIPS_ABI_EABI32 = 0x00003000, // EABI in 32 bit mode. EF_MIPS_ABI_EABI64 = 0x00004000, // EABI in 64 bit mode. EF_MIPS_ABI = 0x0000f000, // Mask for selecting EF_MIPS_ABI_ variant. // MIPS machine variant EF_MIPS_MACH_NONE = 0x00000000, // A standard MIPS implementation. EF_MIPS_MACH_3900 = 0x00810000, // Toshiba R3900 EF_MIPS_MACH_4010 = 0x00820000, // LSI R4010 EF_MIPS_MACH_4100 = 0x00830000, // NEC VR4100 EF_MIPS_MACH_4650 = 0x00850000, // MIPS R4650 EF_MIPS_MACH_4120 = 0x00870000, // NEC VR4120 EF_MIPS_MACH_4111 = 0x00880000, // NEC VR4111/VR4181 EF_MIPS_MACH_SB1 = 0x008a0000, // Broadcom SB-1 EF_MIPS_MACH_OCTEON = 0x008b0000, // Cavium Networks Octeon EF_MIPS_MACH_XLR = 0x008c0000, // RMI Xlr EF_MIPS_MACH_OCTEON2 = 0x008d0000, // Cavium Networks Octeon2 EF_MIPS_MACH_OCTEON3 = 0x008e0000, // Cavium Networks Octeon3 EF_MIPS_MACH_5400 = 0x00910000, // NEC VR5400 EF_MIPS_MACH_5900 = 0x00920000, // MIPS R5900 EF_MIPS_MACH_5500 = 0x00980000, // NEC VR5500 EF_MIPS_MACH_9000 = 0x00990000, // Unknown EF_MIPS_MACH_LS2E = 0x00a00000, // ST Microelectronics Loongson 2E EF_MIPS_MACH_LS2F = 0x00a10000, // ST Microelectronics Loongson 2F EF_MIPS_MACH_LS3A = 0x00a20000, // Loongson 3A EF_MIPS_MACH = 0x00ff0000, // EF_MIPS_MACH_xxx selection mask // ARCH_ASE EF_MIPS_MICROMIPS = 0x02000000, // microMIPS EF_MIPS_ARCH_ASE_M16 = 0x04000000, // Has Mips-16 ISA extensions EF_MIPS_ARCH_ASE_MDMX = 0x08000000, // Has MDMX multimedia extensions EF_MIPS_ARCH_ASE = 0x0f000000, // Mask for EF_MIPS_ARCH_ASE_xxx flags // ARCH EF_MIPS_ARCH_1 = 0x00000000, // MIPS1 instruction set EF_MIPS_ARCH_2 = 0x10000000, // MIPS2 instruction set EF_MIPS_ARCH_3 = 0x20000000, // MIPS3 instruction set EF_MIPS_ARCH_4 = 0x30000000, // MIPS4 instruction set EF_MIPS_ARCH_5 = 0x40000000, // MIPS5 instruction set EF_MIPS_ARCH_32 = 0x50000000, // MIPS32 instruction set per linux not elf.h EF_MIPS_ARCH_64 = 0x60000000, // MIPS64 instruction set per linux not elf.h EF_MIPS_ARCH_32R2 = 0x70000000, // mips32r2, mips32r3, mips32r5 EF_MIPS_ARCH_64R2 = 0x80000000, // mips64r2, mips64r3, mips64r5 EF_MIPS_ARCH_32R6 = 0x90000000, // mips32r6 EF_MIPS_ARCH_64R6 = 0xa0000000, // mips64r6 EF_MIPS_ARCH = 0xf0000000 // Mask for applying EF_MIPS_ARCH_ variant }; // ELF Relocation types for Mips enum { #include "ELFRelocs/Mips.def" }; // Special values for the st_other field in the symbol table entry for MIPS. enum { STO_MIPS_OPTIONAL = 0x04, // Symbol whose definition is optional STO_MIPS_PLT = 0x08, // PLT entry related dynamic table record STO_MIPS_PIC = 0x20, // PIC func in an object mixes PIC/non-PIC STO_MIPS_MICROMIPS = 0x80, // MIPS Specific ISA for MicroMips STO_MIPS_MIPS16 = 0xf0 // MIPS Specific ISA for Mips16 }; // .MIPS.options section descriptor kinds enum { ODK_NULL = 0, // Undefined ODK_REGINFO = 1, // Register usage information ODK_EXCEPTIONS = 2, // Exception processing options ODK_PAD = 3, // Section padding options ODK_HWPATCH = 4, // Hardware patches applied ODK_FILL = 5, // Linker fill value ODK_TAGS = 6, // Space for tool identification ODK_HWAND = 7, // Hardware AND patches applied ODK_HWOR = 8, // Hardware OR patches applied ODK_GP_GROUP = 9, // GP group to use for text/data sections ODK_IDENT = 10, // ID information ODK_PAGESIZE = 11 // Page size information }; // Hexagon-specific e_flags enum { // Object processor version flags, bits[11:0] EF_HEXAGON_MACH_V2 = 0x00000001, // Hexagon V2 EF_HEXAGON_MACH_V3 = 0x00000002, // Hexagon V3 EF_HEXAGON_MACH_V4 = 0x00000003, // Hexagon V4 EF_HEXAGON_MACH_V5 = 0x00000004, // Hexagon V5 EF_HEXAGON_MACH_V55 = 0x00000005, // Hexagon V55 EF_HEXAGON_MACH_V60 = 0x00000060, // Hexagon V60 EF_HEXAGON_MACH_V62 = 0x00000062, // Hexagon V62 EF_HEXAGON_MACH_V65 = 0x00000065, // Hexagon V65 EF_HEXAGON_MACH_V66 = 0x00000066, // Hexagon V66 // Highest ISA version flags EF_HEXAGON_ISA_MACH = 0x00000000, // Same as specified in bits[11:0] // of e_flags EF_HEXAGON_ISA_V2 = 0x00000010, // Hexagon V2 ISA EF_HEXAGON_ISA_V3 = 0x00000020, // Hexagon V3 ISA EF_HEXAGON_ISA_V4 = 0x00000030, // Hexagon V4 ISA EF_HEXAGON_ISA_V5 = 0x00000040, // Hexagon V5 ISA EF_HEXAGON_ISA_V55 = 0x00000050, // Hexagon V55 ISA EF_HEXAGON_ISA_V60 = 0x00000060, // Hexagon V60 ISA EF_HEXAGON_ISA_V62 = 0x00000062, // Hexagon V62 ISA EF_HEXAGON_ISA_V65 = 0x00000065, // Hexagon V65 ISA EF_HEXAGON_ISA_V66 = 0x00000066, // Hexagon V66 ISA }; // Hexagon-specific section indexes for common small data enum { SHN_HEXAGON_SCOMMON = 0xff00, // Other access sizes SHN_HEXAGON_SCOMMON_1 = 0xff01, // Byte-sized access SHN_HEXAGON_SCOMMON_2 = 0xff02, // Half-word-sized access SHN_HEXAGON_SCOMMON_4 = 0xff03, // Word-sized access SHN_HEXAGON_SCOMMON_8 = 0xff04 // Double-word-size access }; // ELF Relocation types for Hexagon enum { #include "ELFRelocs/Hexagon.def" }; // ELF Relocation type for Lanai. enum { #include "ELFRelocs/Lanai.def" }; // RISCV Specific e_flags enum : unsigned { EF_RISCV_RVC = 0x0001, EF_RISCV_FLOAT_ABI = 0x0006, EF_RISCV_FLOAT_ABI_SOFT = 0x0000, EF_RISCV_FLOAT_ABI_SINGLE = 0x0002, EF_RISCV_FLOAT_ABI_DOUBLE = 0x0004, EF_RISCV_FLOAT_ABI_QUAD = 0x0006, EF_RISCV_RVE = 0x0008 }; // ELF Relocation types for RISC-V enum { #include "ELFRelocs/RISCV.def" }; // ELF Relocation types for S390/zSeries enum { #include "ELFRelocs/SystemZ.def" }; // ELF Relocation type for Sparc. enum { #include "ELFRelocs/Sparc.def" }; // AMDGPU specific e_flags. enum : unsigned { // Processor selection mask for EF_AMDGPU_MACH_* values. EF_AMDGPU_MACH = 0x0ff, // Not specified processor. EF_AMDGPU_MACH_NONE = 0x000, // R600-based processors. // Radeon HD 2000/3000 Series (R600). EF_AMDGPU_MACH_R600_R600 = 0x001, EF_AMDGPU_MACH_R600_R630 = 0x002, EF_AMDGPU_MACH_R600_RS880 = 0x003, EF_AMDGPU_MACH_R600_RV670 = 0x004, // Radeon HD 4000 Series (R700). EF_AMDGPU_MACH_R600_RV710 = 0x005, EF_AMDGPU_MACH_R600_RV730 = 0x006, EF_AMDGPU_MACH_R600_RV770 = 0x007, // Radeon HD 5000 Series (Evergreen). EF_AMDGPU_MACH_R600_CEDAR = 0x008, EF_AMDGPU_MACH_R600_CYPRESS = 0x009, EF_AMDGPU_MACH_R600_JUNIPER = 0x00a, EF_AMDGPU_MACH_R600_REDWOOD = 0x00b, EF_AMDGPU_MACH_R600_SUMO = 0x00c, // Radeon HD 6000 Series (Northern Islands). EF_AMDGPU_MACH_R600_BARTS = 0x00d, EF_AMDGPU_MACH_R600_CAICOS = 0x00e, EF_AMDGPU_MACH_R600_CAYMAN = 0x00f, EF_AMDGPU_MACH_R600_TURKS = 0x010, // Reserved for R600-based processors. EF_AMDGPU_MACH_R600_RESERVED_FIRST = 0x011, EF_AMDGPU_MACH_R600_RESERVED_LAST = 0x01f, // First/last R600-based processors. EF_AMDGPU_MACH_R600_FIRST = EF_AMDGPU_MACH_R600_R600, EF_AMDGPU_MACH_R600_LAST = EF_AMDGPU_MACH_R600_TURKS, // AMDGCN-based processors. // AMDGCN GFX6. EF_AMDGPU_MACH_AMDGCN_GFX600 = 0x020, EF_AMDGPU_MACH_AMDGCN_GFX601 = 0x021, // AMDGCN GFX7. EF_AMDGPU_MACH_AMDGCN_GFX700 = 0x022, EF_AMDGPU_MACH_AMDGCN_GFX701 = 0x023, EF_AMDGPU_MACH_AMDGCN_GFX702 = 0x024, EF_AMDGPU_MACH_AMDGCN_GFX703 = 0x025, EF_AMDGPU_MACH_AMDGCN_GFX704 = 0x026, // AMDGCN GFX8. EF_AMDGPU_MACH_AMDGCN_GFX801 = 0x028, EF_AMDGPU_MACH_AMDGCN_GFX802 = 0x029, EF_AMDGPU_MACH_AMDGCN_GFX803 = 0x02a, EF_AMDGPU_MACH_AMDGCN_GFX810 = 0x02b, // AMDGCN GFX9. EF_AMDGPU_MACH_AMDGCN_GFX900 = 0x02c, EF_AMDGPU_MACH_AMDGCN_GFX902 = 0x02d, EF_AMDGPU_MACH_AMDGCN_GFX904 = 0x02e, EF_AMDGPU_MACH_AMDGCN_GFX906 = 0x02f, EF_AMDGPU_MACH_AMDGCN_GFX908 = 0x030, EF_AMDGPU_MACH_AMDGCN_GFX909 = 0x031, // AMDGCN GFX10. EF_AMDGPU_MACH_AMDGCN_GFX1010 = 0x033, EF_AMDGPU_MACH_AMDGCN_GFX1011 = 0x034, EF_AMDGPU_MACH_AMDGCN_GFX1012 = 0x035, // Reserved for AMDGCN-based processors. EF_AMDGPU_MACH_AMDGCN_RESERVED0 = 0x027, EF_AMDGPU_MACH_AMDGCN_RESERVED1 = 0x032, // First/last AMDGCN-based processors. EF_AMDGPU_MACH_AMDGCN_FIRST = EF_AMDGPU_MACH_AMDGCN_GFX600, EF_AMDGPU_MACH_AMDGCN_LAST = EF_AMDGPU_MACH_AMDGCN_GFX1012, // Indicates if the "xnack" target feature is enabled for all code contained // in the object. EF_AMDGPU_XNACK = 0x100, // Indicates if the "sram-ecc" target feature is enabled for all code // contained in the object. EF_AMDGPU_SRAM_ECC = 0x200, }; // ELF Relocation types for AMDGPU enum { #include "ELFRelocs/AMDGPU.def" }; // ELF Relocation types for BPF enum { #include "ELFRelocs/BPF.def" }; // MSP430 specific e_flags enum : unsigned { EF_MSP430_MACH_MSP430x11 = 11, EF_MSP430_MACH_MSP430x11x1 = 110, EF_MSP430_MACH_MSP430x12 = 12, EF_MSP430_MACH_MSP430x13 = 13, EF_MSP430_MACH_MSP430x14 = 14, EF_MSP430_MACH_MSP430x15 = 15, EF_MSP430_MACH_MSP430x16 = 16, EF_MSP430_MACH_MSP430x20 = 20, EF_MSP430_MACH_MSP430x22 = 22, EF_MSP430_MACH_MSP430x23 = 23, EF_MSP430_MACH_MSP430x24 = 24, EF_MSP430_MACH_MSP430x26 = 26, EF_MSP430_MACH_MSP430x31 = 31, EF_MSP430_MACH_MSP430x32 = 32, EF_MSP430_MACH_MSP430x33 = 33, EF_MSP430_MACH_MSP430x41 = 41, EF_MSP430_MACH_MSP430x42 = 42, EF_MSP430_MACH_MSP430x43 = 43, EF_MSP430_MACH_MSP430x44 = 44, EF_MSP430_MACH_MSP430X = 45, EF_MSP430_MACH_MSP430x46 = 46, EF_MSP430_MACH_MSP430x47 = 47, EF_MSP430_MACH_MSP430x54 = 54, }; // ELF Relocation types for MSP430 enum { #include "ELFRelocs/MSP430.def" }; #undef ELF_RELOC // 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_Word sh_name; Elf64_Word sh_type; Elf64_Xword sh_flags; Elf64_Addr sh_addr; Elf64_Off sh_offset; Elf64_Xword sh_size; Elf64_Word sh_link; Elf64_Word 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_LOOS = 0xff20, // Lowest operating system-specific index SHN_HIOS = 0xff3f, // Highest operating system-specific index SHN_ABS = 0xfff1, // Symbol has absolute value; does not need relocation SHN_COMMON = 0xfff2, // FORTRAN COMMON or C external global variables SHN_XINDEX = 0xffff, // Mark that the index is >= SHN_LORESERVE SHN_HIRESERVE = 0xffff // Highest reserved index }; // Section types. enum : unsigned { 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 initialization 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, // Indices for SHN_XINDEX entries. // Experimental support for SHT_RELR sections. For details, see proposal // at https://groups.google.com/forum/#!topic/generic-abi/bX460iggiKg SHT_RELR = 19, // Relocation entries; only offsets. SHT_LOOS = 0x60000000, // Lowest operating system-specific type. // Android packed relocation section types. // https://android.googlesource.com/platform/bionic/+/6f12bfece5dcc01325e0abba56a46b1bcf991c69/tools/relocation_packer/src/elf_file.cc#37 SHT_ANDROID_REL = 0x60000001, SHT_ANDROID_RELA = 0x60000002, SHT_LLVM_ODRTAB = 0x6fff4c00, // LLVM ODR table. SHT_LLVM_LINKER_OPTIONS = 0x6fff4c01, // LLVM Linker Options. SHT_LLVM_CALL_GRAPH_PROFILE = 0x6fff4c02, // LLVM Call Graph Profile. SHT_LLVM_ADDRSIG = 0x6fff4c03, // List of address-significant symbols // for safe ICF. SHT_LLVM_DEPENDENT_LIBRARIES = 0x6fff4c04, // LLVM Dependent Library Specifiers. SHT_LLVM_SYMPART = 0x6fff4c05, // Symbol partition specification. SHT_LLVM_PART_EHDR = 0x6fff4c06, // ELF header for loadable partition. SHT_LLVM_PART_PHDR = 0x6fff4c07, // Phdrs for loadable partition. // Android's experimental support for SHT_RELR sections. // https://android.googlesource.com/platform/bionic/+/b7feec74547f84559a1467aca02708ff61346d2a/libc/include/elf.h#512 SHT_ANDROID_RELR = 0x6fffff00, // Relocation entries; only offsets. SHT_GNU_ATTRIBUTES = 0x6ffffff5, // Object attributes. SHT_GNU_HASH = 0x6ffffff6, // GNU-style hash table. SHT_GNU_verdef = 0x6ffffffd, // GNU version definitions. SHT_GNU_verneed = 0x6ffffffe, // GNU version references. SHT_GNU_versym = 0x6fffffff, // GNU symbol versions table. SHT_HIOS = 0x6fffffff, // Highest operating system-specific type. SHT_LOPROC = 0x70000000, // Lowest processor arch-specific type. // Fixme: All this is duplicated in MCSectionELF. Why?? // Exception Index table SHT_ARM_EXIDX = 0x70000001U, // BPABI DLL dynamic linking pre-emption map SHT_ARM_PREEMPTMAP = 0x70000002U, // Object file compatibility attributes SHT_ARM_ATTRIBUTES = 0x70000003U, SHT_ARM_DEBUGOVERLAY = 0x70000004U, SHT_ARM_OVERLAYSECTION = 0x70000005U, SHT_HEX_ORDERED = 0x70000000, // Link editor is to sort the entries in // this section based on their sizes SHT_X86_64_UNWIND = 0x70000001, // Unwind information SHT_MIPS_REGINFO = 0x70000006, // Register usage information SHT_MIPS_OPTIONS = 0x7000000d, // General options SHT_MIPS_DWARF = 0x7000001e, // DWARF debugging section. SHT_MIPS_ABIFLAGS = 0x7000002a, // ABI information. SHT_MSP430_ATTRIBUTES = 0x70000003U, SHT_HIPROC = 0x7fffffff, // Highest processor arch-specific type. SHT_LOUSER = 0x80000000, // Lowest type reserved for applications. SHT_HIUSER = 0xffffffff // Highest type reserved for applications. }; // Section flags. enum : unsigned { // Section data should be writable during execution. SHF_WRITE = 0x1, // Section occupies memory during program execution. SHF_ALLOC = 0x2, // Section contains executable machine instructions. SHF_EXECINSTR = 0x4, // The data in this section may be merged. SHF_MERGE = 0x10, // The data in this section is null-terminated strings. SHF_STRINGS = 0x20, // A field in this section holds a section header table index. SHF_INFO_LINK = 0x40U, // Adds special ordering requirements for link editors. SHF_LINK_ORDER = 0x80U, // This section requires special OS-specific processing to avoid incorrect // behavior. SHF_OS_NONCONFORMING = 0x100U, // This section is a member of a section group. SHF_GROUP = 0x200U, // This section holds Thread-Local Storage. SHF_TLS = 0x400U, // Identifies a section containing compressed data. SHF_COMPRESSED = 0x800U, // This section is excluded from the final executable or shared library. SHF_EXCLUDE = 0x80000000U, // Start of target-specific flags. SHF_MASKOS = 0x0ff00000, // Bits indicating processor-specific flags. SHF_MASKPROC = 0xf0000000, /// All sections with the "d" flag are grouped together by the linker to form /// the data section and the dp register is set to the start of the section by /// the boot code. XCORE_SHF_DP_SECTION = 0x10000000, /// All sections with the "c" flag are grouped together by the linker to form /// the constant pool and the cp register is set to the start of the constant /// pool by the boot code. XCORE_SHF_CP_SECTION = 0x20000000, // If an object file section does not have this flag set, then it may not hold // more than 2GB and can be freely referred to in objects using smaller code // models. Otherwise, only objects using larger code models can refer to them. // For example, a medium code model object can refer to data in a section that // sets this flag besides being able to refer to data in a section that does // not set it; likewise, a small code model object can refer only to code in a // section that does not set this flag. SHF_X86_64_LARGE = 0x10000000, // All sections with the GPREL flag are grouped into a global data area // for faster accesses SHF_HEX_GPREL = 0x10000000, // Section contains text/data which may be replicated in other sections. // Linker must retain only one copy. SHF_MIPS_NODUPES = 0x01000000, // Linker must generate implicit hidden weak names. SHF_MIPS_NAMES = 0x02000000, // Section data local to process. SHF_MIPS_LOCAL = 0x04000000, // Do not strip this section. SHF_MIPS_NOSTRIP = 0x08000000, // Section must be part of global data area. SHF_MIPS_GPREL = 0x10000000, // This section should be merged. SHF_MIPS_MERGE = 0x20000000, // Address size to be inferred from section entry size. SHF_MIPS_ADDR = 0x40000000, // Section data is string data by default. SHF_MIPS_STRING = 0x80000000, // Make code section unreadable when in execute-only mode SHF_ARM_PURECODE = 0x20000000 }; // Section Group Flags enum : unsigned { GRP_COMDAT = 0x1, GRP_MASKOS = 0x0ff00000, GRP_MASKPROC = 0xf0000000 }; // 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 tbl 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); } }; // The size (in bytes) of symbol table entries. enum { SYMENTRY_SIZE32 = 16, // 32-bit symbol entry size SYMENTRY_SIZE64 = 24 // 64-bit symbol entry size. }; // 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_GNU_UNIQUE = 10, STB_LOOS = 10, // Lowest operating system-specific binding type STB_HIOS = 12, // Highest operating system-specific binding type 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 uninitialized common block STT_TLS = 6, // Thread local data object STT_GNU_IFUNC = 10, // GNU indirect function STT_LOOS = 10, // Lowest operating system-specific symbol type STT_HIOS = 12, // Highest operating system-specific symbol type STT_LOPROC = 13, // Lowest processor-specific symbol type STT_HIPROC = 15, // Highest processor-specific symbol type // AMDGPU symbol types STT_AMDGPU_HSA_KERNEL = 10 }; 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 }; // Symbol number. enum { STN_UNDEF = 0 }; // Special relocation symbols used in the MIPS64 ELF relocation entries enum { RSS_UNDEF = 0, // None RSS_GP = 1, // Value of gp RSS_GP0 = 2, // Value of gp used to create object being relocated RSS_LOC = 3 // Address of location being relocated }; // 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 or info (relative relocations only). typedef Elf32_Word Elf32_Relr; // offset/bitmap for relative relocations // 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_Word getSymbol() const { return (r_info >> 32); } Elf64_Word getType() const { return (Elf64_Word)(r_info & 0xffffffffL); } void setSymbol(Elf64_Word s) { setSymbolAndType(s, getType()); } void setType(Elf64_Word t) { setSymbolAndType(getSymbol(), t); } void setSymbolAndType(Elf64_Word s, Elf64_Word t) { r_info = ((Elf64_Xword)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_Word getSymbol() const { return (r_info >> 32); } Elf64_Word getType() const { return (Elf64_Word)(r_info & 0xffffffffL); } void setSymbol(Elf64_Word s) { setSymbolAndType(s, getType()); } void setType(Elf64_Word t) { setSymbolAndType(getSymbol(), t); } void setSymbolAndType(Elf64_Word s, Elf64_Word t) { r_info = ((Elf64_Xword)s << 32) + (t & 0xffffffffL); } }; // Relocation entry without explicit addend or info (relative relocations only). typedef Elf64_Xword Elf64_Relr; // offset/bitmap for relative relocations // 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 addr 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_TLS = 7, // The thread-local storage template. PT_LOOS = 0x60000000, // Lowest operating system-specific pt entry type. PT_HIOS = 0x6fffffff, // Highest operating system-specific pt entry type. PT_LOPROC = 0x70000000, // Lowest processor-specific program hdr entry type. PT_HIPROC = 0x7fffffff, // Highest processor-specific program hdr entry type. // x86-64 program header types. // These all contain stack unwind tables. PT_GNU_EH_FRAME = 0x6474e550, PT_SUNW_EH_FRAME = 0x6474e550, PT_SUNW_UNWIND = 0x6464e550, PT_GNU_STACK = 0x6474e551, // Indicates stack executability. PT_GNU_RELRO = 0x6474e552, // Read-only after relocation. PT_GNU_PROPERTY = 0x6474e553, // .note.gnu.property notes sections. PT_OPENBSD_RANDOMIZE = 0x65a3dbe6, // Fill with random data. PT_OPENBSD_WXNEEDED = 0x65a3dbe7, // Program does W^X violations. PT_OPENBSD_BOOTDATA = 0x65a41be6, // Section for boot arguments. // ARM program header types. PT_ARM_ARCHEXT = 0x70000000, // Platform architecture compatibility info // These all contain stack unwind tables. PT_ARM_EXIDX = 0x70000001, PT_ARM_UNWIND = 0x70000001, // MIPS program header types. PT_MIPS_REGINFO = 0x70000000, // Register usage information. PT_MIPS_RTPROC = 0x70000001, // Runtime procedure table. PT_MIPS_OPTIONS = 0x70000002, // Options segment. PT_MIPS_ABIFLAGS = 0x70000003, // Abiflags segment. }; // Segment flag bits. enum : unsigned { PF_X = 1, // Execute PF_W = 2, // Write PF_R = 4, // Read PF_MASKOS = 0x0ff00000, // Bits for operating system-specific semantics. PF_MASKPROC = 0xf0000000 // Bits for processor-specific semantics. }; // 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 { #define DYNAMIC_TAG(name, value) DT_##name = value, #include "DynamicTags.def" #undef DYNAMIC_TAG }; // DT_FLAGS values. enum { DF_ORIGIN = 0x01, // The object may reference $ORIGIN. DF_SYMBOLIC = 0x02, // Search the shared lib before searching the exe. DF_TEXTREL = 0x04, // Relocations may modify a non-writable segment. DF_BIND_NOW = 0x08, // Process all relocations on load. DF_STATIC_TLS = 0x10 // Reject attempts to load dynamically. }; // State flags selectable in the `d_un.d_val' element of the DT_FLAGS_1 entry. enum { DF_1_NOW = 0x00000001, // Set RTLD_NOW for this object. DF_1_GLOBAL = 0x00000002, // Set RTLD_GLOBAL for this object. DF_1_GROUP = 0x00000004, // Set RTLD_GROUP for this object. DF_1_NODELETE = 0x00000008, // Set RTLD_NODELETE for this object. DF_1_LOADFLTR = 0x00000010, // Trigger filtee loading at runtime. DF_1_INITFIRST = 0x00000020, // Set RTLD_INITFIRST for this object. DF_1_NOOPEN = 0x00000040, // Set RTLD_NOOPEN for this object. DF_1_ORIGIN = 0x00000080, // $ORIGIN must be handled. DF_1_DIRECT = 0x00000100, // Direct binding enabled. DF_1_TRANS = 0x00000200, DF_1_INTERPOSE = 0x00000400, // Object is used to interpose. DF_1_NODEFLIB = 0x00000800, // Ignore default lib search path. DF_1_NODUMP = 0x00001000, // Object can't be dldump'ed. DF_1_CONFALT = 0x00002000, // Configuration alternative created. DF_1_ENDFILTEE = 0x00004000, // Filtee terminates filters search. DF_1_DISPRELDNE = 0x00008000, // Disp reloc applied at build time. DF_1_DISPRELPND = 0x00010000, // Disp reloc applied at run-time. DF_1_NODIRECT = 0x00020000, // Object has no-direct binding. DF_1_IGNMULDEF = 0x00040000, DF_1_NOKSYMS = 0x00080000, DF_1_NOHDR = 0x00100000, DF_1_EDITED = 0x00200000, // Object is modified after built. DF_1_NORELOC = 0x00400000, DF_1_SYMINTPOSE = 0x00800000, // Object has individual interposers. DF_1_GLOBAUDIT = 0x01000000, // Global auditing required. - DF_1_SINGLETON = 0x02000000 // Singleton symbols are used. + DF_1_SINGLETON = 0x02000000, // Singleton symbols are used. + DF_1_PIE = 0x08000000, // Object is a position-independent executable. }; // DT_MIPS_FLAGS values. enum { RHF_NONE = 0x00000000, // No flags. RHF_QUICKSTART = 0x00000001, // Uses shortcut pointers. RHF_NOTPOT = 0x00000002, // Hash size is not a power of two. RHS_NO_LIBRARY_REPLACEMENT = 0x00000004, // Ignore LD_LIBRARY_PATH. RHF_NO_MOVE = 0x00000008, // DSO address may not be relocated. RHF_SGI_ONLY = 0x00000010, // SGI specific features. RHF_GUARANTEE_INIT = 0x00000020, // Guarantee that .init will finish // executing before any non-init // code in DSO is called. RHF_DELTA_C_PLUS_PLUS = 0x00000040, // Contains Delta C++ code. RHF_GUARANTEE_START_INIT = 0x00000080, // Guarantee that .init will start // executing before any non-init // code in DSO is called. RHF_PIXIE = 0x00000100, // Generated by pixie. RHF_DEFAULT_DELAY_LOAD = 0x00000200, // Delay-load DSO by default. RHF_REQUICKSTART = 0x00000400, // Object may be requickstarted RHF_REQUICKSTARTED = 0x00000800, // Object has been requickstarted RHF_CORD = 0x00001000, // Generated by cord. RHF_NO_UNRES_UNDEF = 0x00002000, // Object contains no unresolved // undef symbols. RHF_RLD_ORDER_SAFE = 0x00004000 // Symbol table is in a safe order. }; // ElfXX_VerDef structure version (GNU versioning) enum { VER_DEF_NONE = 0, VER_DEF_CURRENT = 1 }; // VerDef Flags (ElfXX_VerDef::vd_flags) enum { VER_FLG_BASE = 0x1, VER_FLG_WEAK = 0x2, VER_FLG_INFO = 0x4 }; // Special constants for the version table. (SHT_GNU_versym/.gnu.version) enum { VER_NDX_LOCAL = 0, // Unversioned local symbol VER_NDX_GLOBAL = 1, // Unversioned global symbol VERSYM_VERSION = 0x7fff, // Version Index mask VERSYM_HIDDEN = 0x8000 // Hidden bit (non-default version) }; // ElfXX_VerNeed structure version (GNU versioning) enum { VER_NEED_NONE = 0, VER_NEED_CURRENT = 1 }; // SHT_NOTE section types enum { NT_FREEBSD_THRMISC = 7, NT_FREEBSD_PROCSTAT_PROC = 8, NT_FREEBSD_PROCSTAT_FILES = 9, NT_FREEBSD_PROCSTAT_VMMAP = 10, NT_FREEBSD_PROCSTAT_GROUPS = 11, NT_FREEBSD_PROCSTAT_UMASK = 12, NT_FREEBSD_PROCSTAT_RLIMIT = 13, NT_FREEBSD_PROCSTAT_OSREL = 14, NT_FREEBSD_PROCSTAT_PSSTRINGS = 15, NT_FREEBSD_PROCSTAT_AUXV = 16, }; // Generic note types enum : unsigned { NT_VERSION = 1, NT_ARCH = 2, NT_GNU_BUILD_ATTRIBUTE_OPEN = 0x100, NT_GNU_BUILD_ATTRIBUTE_FUNC = 0x101, }; // Core note types enum : unsigned { NT_PRSTATUS = 1, NT_FPREGSET = 2, NT_PRPSINFO = 3, NT_TASKSTRUCT = 4, NT_AUXV = 6, NT_PSTATUS = 10, NT_FPREGS = 12, NT_PSINFO = 13, NT_LWPSTATUS = 16, NT_LWPSINFO = 17, NT_WIN32PSTATUS = 18, NT_PPC_VMX = 0x100, NT_PPC_VSX = 0x102, NT_PPC_TAR = 0x103, NT_PPC_PPR = 0x104, NT_PPC_DSCR = 0x105, NT_PPC_EBB = 0x106, NT_PPC_PMU = 0x107, NT_PPC_TM_CGPR = 0x108, NT_PPC_TM_CFPR = 0x109, NT_PPC_TM_CVMX = 0x10a, NT_PPC_TM_CVSX = 0x10b, NT_PPC_TM_SPR = 0x10c, NT_PPC_TM_CTAR = 0x10d, NT_PPC_TM_CPPR = 0x10e, NT_PPC_TM_CDSCR = 0x10f, NT_386_TLS = 0x200, NT_386_IOPERM = 0x201, NT_X86_XSTATE = 0x202, NT_S390_HIGH_GPRS = 0x300, NT_S390_TIMER = 0x301, NT_S390_TODCMP = 0x302, NT_S390_TODPREG = 0x303, NT_S390_CTRS = 0x304, NT_S390_PREFIX = 0x305, NT_S390_LAST_BREAK = 0x306, NT_S390_SYSTEM_CALL = 0x307, NT_S390_TDB = 0x308, NT_S390_VXRS_LOW = 0x309, NT_S390_VXRS_HIGH = 0x30a, NT_S390_GS_CB = 0x30b, NT_S390_GS_BC = 0x30c, NT_ARM_VFP = 0x400, NT_ARM_TLS = 0x401, NT_ARM_HW_BREAK = 0x402, NT_ARM_HW_WATCH = 0x403, NT_ARM_SVE = 0x405, NT_ARM_PAC_MASK = 0x406, NT_FILE = 0x46494c45, NT_PRXFPREG = 0x46e62b7f, NT_SIGINFO = 0x53494749, }; // LLVM-specific notes. enum { NT_LLVM_HWASAN_GLOBALS = 3, }; // GNU note types enum { NT_GNU_ABI_TAG = 1, NT_GNU_HWCAP = 2, NT_GNU_BUILD_ID = 3, NT_GNU_GOLD_VERSION = 4, NT_GNU_PROPERTY_TYPE_0 = 5, }; // Property types used in GNU_PROPERTY_TYPE_0 notes. enum : unsigned { GNU_PROPERTY_STACK_SIZE = 1, GNU_PROPERTY_NO_COPY_ON_PROTECTED = 2, GNU_PROPERTY_AARCH64_FEATURE_1_AND = 0xc0000000, GNU_PROPERTY_X86_FEATURE_1_AND = 0xc0000002, GNU_PROPERTY_X86_ISA_1_NEEDED = 0xc0008000, GNU_PROPERTY_X86_FEATURE_2_NEEDED = 0xc0008001, GNU_PROPERTY_X86_ISA_1_USED = 0xc0010000, GNU_PROPERTY_X86_FEATURE_2_USED = 0xc0010001, }; // aarch64 processor feature bits. enum : unsigned { GNU_PROPERTY_AARCH64_FEATURE_1_BTI = 1 << 0, GNU_PROPERTY_AARCH64_FEATURE_1_PAC = 1 << 1, }; // x86 processor feature bits. enum : unsigned { GNU_PROPERTY_X86_FEATURE_1_IBT = 1 << 0, GNU_PROPERTY_X86_FEATURE_1_SHSTK = 1 << 1, GNU_PROPERTY_X86_ISA_1_CMOV = 1 << 0, GNU_PROPERTY_X86_ISA_1_SSE = 1 << 1, GNU_PROPERTY_X86_ISA_1_SSE2 = 1 << 2, GNU_PROPERTY_X86_ISA_1_SSE3 = 1 << 3, GNU_PROPERTY_X86_ISA_1_SSSE3 = 1 << 4, GNU_PROPERTY_X86_ISA_1_SSE4_1 = 1 << 5, GNU_PROPERTY_X86_ISA_1_SSE4_2 = 1 << 6, GNU_PROPERTY_X86_ISA_1_AVX = 1 << 7, GNU_PROPERTY_X86_ISA_1_AVX2 = 1 << 8, GNU_PROPERTY_X86_ISA_1_FMA = 1 << 9, GNU_PROPERTY_X86_ISA_1_AVX512F = 1 << 10, GNU_PROPERTY_X86_ISA_1_AVX512CD = 1 << 11, GNU_PROPERTY_X86_ISA_1_AVX512ER = 1 << 12, GNU_PROPERTY_X86_ISA_1_AVX512PF = 1 << 13, GNU_PROPERTY_X86_ISA_1_AVX512VL = 1 << 14, GNU_PROPERTY_X86_ISA_1_AVX512DQ = 1 << 15, GNU_PROPERTY_X86_ISA_1_AVX512BW = 1 << 16, GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS = 1 << 17, GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW = 1 << 18, GNU_PROPERTY_X86_ISA_1_AVX512_BITALG = 1 << 19, GNU_PROPERTY_X86_ISA_1_AVX512_IFMA = 1 << 20, GNU_PROPERTY_X86_ISA_1_AVX512_VBMI = 1 << 21, GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2 = 1 << 22, GNU_PROPERTY_X86_ISA_1_AVX512_VNNI = 1 << 23, GNU_PROPERTY_X86_FEATURE_2_X86 = 1 << 0, GNU_PROPERTY_X86_FEATURE_2_X87 = 1 << 1, GNU_PROPERTY_X86_FEATURE_2_MMX = 1 << 2, GNU_PROPERTY_X86_FEATURE_2_XMM = 1 << 3, GNU_PROPERTY_X86_FEATURE_2_YMM = 1 << 4, GNU_PROPERTY_X86_FEATURE_2_ZMM = 1 << 5, GNU_PROPERTY_X86_FEATURE_2_FXSR = 1 << 6, GNU_PROPERTY_X86_FEATURE_2_XSAVE = 1 << 7, GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT = 1 << 8, GNU_PROPERTY_X86_FEATURE_2_XSAVEC = 1 << 9, }; // AMDGPU-specific section indices. enum { SHN_AMDGPU_LDS = 0xff00, // Variable in LDS; symbol encoded like SHN_COMMON }; // AMD specific notes. (Code Object V2) enum { // Note types with values between 0 and 9 (inclusive) are reserved. NT_AMD_AMDGPU_HSA_METADATA = 10, NT_AMD_AMDGPU_ISA = 11, NT_AMD_AMDGPU_PAL_METADATA = 12 }; // AMDGPU specific notes. (Code Object V3) enum { // Note types with values between 0 and 31 (inclusive) are reserved. NT_AMDGPU_METADATA = 32 }; enum { GNU_ABI_TAG_LINUX = 0, GNU_ABI_TAG_HURD = 1, GNU_ABI_TAG_SOLARIS = 2, GNU_ABI_TAG_FREEBSD = 3, GNU_ABI_TAG_NETBSD = 4, GNU_ABI_TAG_SYLLABLE = 5, GNU_ABI_TAG_NACL = 6, }; constexpr const char *ELF_NOTE_GNU = "GNU"; // Android packed relocation group flags. enum { RELOCATION_GROUPED_BY_INFO_FLAG = 1, RELOCATION_GROUPED_BY_OFFSET_DELTA_FLAG = 2, RELOCATION_GROUPED_BY_ADDEND_FLAG = 4, RELOCATION_GROUP_HAS_ADDEND_FLAG = 8, }; // Compressed section header for ELF32. struct Elf32_Chdr { Elf32_Word ch_type; Elf32_Word ch_size; Elf32_Word ch_addralign; }; // Compressed section header for ELF64. struct Elf64_Chdr { Elf64_Word ch_type; Elf64_Word ch_reserved; Elf64_Xword ch_size; Elf64_Xword ch_addralign; }; // Node header for ELF32. struct Elf32_Nhdr { Elf32_Word n_namesz; Elf32_Word n_descsz; Elf32_Word n_type; }; // Node header for ELF64. struct Elf64_Nhdr { Elf64_Word n_namesz; Elf64_Word n_descsz; Elf64_Word n_type; }; // Legal values for ch_type field of compressed section header. enum { ELFCOMPRESS_ZLIB = 1, // ZLIB/DEFLATE algorithm. ELFCOMPRESS_LOOS = 0x60000000, // Start of OS-specific. ELFCOMPRESS_HIOS = 0x6fffffff, // End of OS-specific. ELFCOMPRESS_LOPROC = 0x70000000, // Start of processor-specific. ELFCOMPRESS_HIPROC = 0x7fffffff // End of processor-specific. }; } // end namespace ELF } // end namespace llvm #endif // LLVM_BINARYFORMAT_ELF_H Index: stable/11/contrib/llvm-project/llvm/tools/llvm-readobj/ELFDumper.cpp =================================================================== --- stable/11/contrib/llvm-project/llvm/tools/llvm-readobj/ELFDumper.cpp (revision 361946) +++ stable/11/contrib/llvm-project/llvm/tools/llvm-readobj/ELFDumper.cpp (revision 361947) @@ -1,6419 +1,6420 @@ //===- ELFDumper.cpp - ELF-specific dumper --------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file implements the ELF-specific dumper for llvm-readobj. /// //===----------------------------------------------------------------------===// #include "ARMEHABIPrinter.h" #include "DwarfCFIEHPrinter.h" #include "Error.h" #include "ObjDumper.h" #include "StackMapPrinter.h" #include "llvm-readobj.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseSet.h" #include "llvm/ADT/MapVector.h" #include "llvm/ADT/Optional.h" #include "llvm/ADT/PointerIntPair.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringRef.h" #include "llvm/ADT/Twine.h" #include "llvm/BinaryFormat/AMDGPUMetadataVerifier.h" #include "llvm/BinaryFormat/ELF.h" #include "llvm/Demangle/Demangle.h" #include "llvm/Object/ELF.h" #include "llvm/Object/ELFObjectFile.h" #include "llvm/Object/ELFTypes.h" #include "llvm/Object/Error.h" #include "llvm/Object/ObjectFile.h" #include "llvm/Object/RelocationResolver.h" #include "llvm/Object/StackMapParser.h" #include "llvm/Support/AMDGPUMetadata.h" #include "llvm/Support/ARMAttributeParser.h" #include "llvm/Support/ARMBuildAttributes.h" #include "llvm/Support/Casting.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/Endian.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/Format.h" #include "llvm/Support/FormatVariadic.h" #include "llvm/Support/FormattedStream.h" #include "llvm/Support/LEB128.h" #include "llvm/Support/MathExtras.h" #include "llvm/Support/MipsABIFlags.h" #include "llvm/Support/ScopedPrinter.h" #include "llvm/Support/raw_ostream.h" #include #include #include #include #include #include #include #include #include #include #include using namespace llvm; using namespace llvm::object; using namespace ELF; #define LLVM_READOBJ_ENUM_CASE(ns, enum) \ case ns::enum: \ return #enum; #define ENUM_ENT(enum, altName) \ { #enum, altName, ELF::enum } #define ENUM_ENT_1(enum) \ { #enum, #enum, ELF::enum } #define LLVM_READOBJ_PHDR_ENUM(ns, enum) \ case ns::enum: \ return std::string(#enum).substr(3); #define TYPEDEF_ELF_TYPES(ELFT) \ using ELFO = ELFFile; \ using Elf_Addr = typename ELFT::Addr; \ using Elf_Shdr = typename ELFT::Shdr; \ using Elf_Sym = typename ELFT::Sym; \ using Elf_Dyn = typename ELFT::Dyn; \ using Elf_Dyn_Range = typename ELFT::DynRange; \ using Elf_Rel = typename ELFT::Rel; \ using Elf_Rela = typename ELFT::Rela; \ using Elf_Relr = typename ELFT::Relr; \ using Elf_Rel_Range = typename ELFT::RelRange; \ using Elf_Rela_Range = typename ELFT::RelaRange; \ using Elf_Relr_Range = typename ELFT::RelrRange; \ using Elf_Phdr = typename ELFT::Phdr; \ using Elf_Half = typename ELFT::Half; \ using Elf_Ehdr = typename ELFT::Ehdr; \ using Elf_Word = typename ELFT::Word; \ using Elf_Hash = typename ELFT::Hash; \ using Elf_GnuHash = typename ELFT::GnuHash; \ using Elf_Note = typename ELFT::Note; \ using Elf_Sym_Range = typename ELFT::SymRange; \ using Elf_Versym = typename ELFT::Versym; \ using Elf_Verneed = typename ELFT::Verneed; \ using Elf_Vernaux = typename ELFT::Vernaux; \ using Elf_Verdef = typename ELFT::Verdef; \ using Elf_Verdaux = typename ELFT::Verdaux; \ using Elf_CGProfile = typename ELFT::CGProfile; \ using uintX_t = typename ELFT::uint; namespace { template class DumpStyle; /// Represents a contiguous uniform range in the file. We cannot just create a /// range directly because when creating one of these from the .dynamic table /// the size, entity size and virtual address are different entries in arbitrary /// order (DT_REL, DT_RELSZ, DT_RELENT for example). struct DynRegionInfo { DynRegionInfo(StringRef ObjName) : FileName(ObjName) {} DynRegionInfo(const void *A, uint64_t S, uint64_t ES, StringRef ObjName) : Addr(A), Size(S), EntSize(ES), FileName(ObjName) {} /// Address in current address space. const void *Addr = nullptr; /// Size in bytes of the region. uint64_t Size = 0; /// Size of each entity in the region. uint64_t EntSize = 0; /// Name of the file. Used for error reporting. StringRef FileName; template ArrayRef getAsArrayRef() const { const Type *Start = reinterpret_cast(Addr); if (!Start) return {Start, Start}; if (EntSize != sizeof(Type) || Size % EntSize) { // TODO: Add a section index to this warning. reportWarning(createError("invalid section size (" + Twine(Size) + ") or entity size (" + Twine(EntSize) + ")"), FileName); return {Start, Start}; } return {Start, Start + (Size / EntSize)}; } }; namespace { struct VerdAux { unsigned Offset; std::string Name; }; struct VerDef { unsigned Offset; unsigned Version; unsigned Flags; unsigned Ndx; unsigned Cnt; unsigned Hash; std::string Name; std::vector AuxV; }; struct VernAux { unsigned Hash; unsigned Flags; unsigned Other; unsigned Offset; std::string Name; }; struct VerNeed { unsigned Version; unsigned Cnt; unsigned Offset; std::string File; std::vector AuxV; }; } // namespace template class ELFDumper : public ObjDumper { public: ELFDumper(const object::ELFObjectFile *ObjF, ScopedPrinter &Writer); void printFileHeaders() override; void printSectionHeaders() override; void printRelocations() override; void printDependentLibs() override; void printDynamicRelocations() override; void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) override; void printHashSymbols() override; void printUnwindInfo() override; void printDynamicTable() override; void printNeededLibraries() override; void printProgramHeaders(bool PrintProgramHeaders, cl::boolOrDefault PrintSectionMapping) override; void printHashTable() override; void printGnuHashTable() override; void printLoadName() override; void printVersionInfo() override; void printGroupSections() override; void printArchSpecificInfo() override; void printStackMap() const override; void printHashHistogram() override; void printCGProfile() override; void printAddrsig() override; void printNotes() override; void printELFLinkerOptions() override; void printStackSizes() override; const object::ELFObjectFile *getElfObject() const { return ObjF; }; private: std::unique_ptr> ELFDumperStyle; TYPEDEF_ELF_TYPES(ELFT) DynRegionInfo checkDRI(DynRegionInfo DRI) { const ELFFile *Obj = ObjF->getELFFile(); if (DRI.Addr < Obj->base() || reinterpret_cast(DRI.Addr) + DRI.Size > Obj->base() + Obj->getBufSize()) reportError(errorCodeToError(llvm::object::object_error::parse_failed), ObjF->getFileName()); return DRI; } DynRegionInfo createDRIFrom(const Elf_Phdr *P, uintX_t EntSize) { return checkDRI({ObjF->getELFFile()->base() + P->p_offset, P->p_filesz, EntSize, ObjF->getFileName()}); } DynRegionInfo createDRIFrom(const Elf_Shdr *S) { return checkDRI({ObjF->getELFFile()->base() + S->sh_offset, S->sh_size, S->sh_entsize, ObjF->getFileName()}); } void printAttributes(); void printMipsReginfo(); void printMipsOptions(); std::pair findDynamic(const ELFFile *Obj); void loadDynamicTable(const ELFFile *Obj); void parseDynamicTable(const ELFFile *Obj); Expected getSymbolVersion(const Elf_Sym *symb, bool &IsDefault) const; Error LoadVersionMap() const; const object::ELFObjectFile *ObjF; DynRegionInfo DynRelRegion; DynRegionInfo DynRelaRegion; DynRegionInfo DynRelrRegion; DynRegionInfo DynPLTRelRegion; DynRegionInfo DynSymRegion; DynRegionInfo DynamicTable; StringRef DynamicStringTable; std::string SOName = ""; const Elf_Hash *HashTable = nullptr; const Elf_GnuHash *GnuHashTable = nullptr; const Elf_Shdr *DotSymtabSec = nullptr; const Elf_Shdr *DotCGProfileSec = nullptr; const Elf_Shdr *DotAddrsigSec = nullptr; StringRef DynSymtabName; ArrayRef ShndxTable; const Elf_Shdr *SymbolVersionSection = nullptr; // .gnu.version const Elf_Shdr *SymbolVersionNeedSection = nullptr; // .gnu.version_r const Elf_Shdr *SymbolVersionDefSection = nullptr; // .gnu.version_d struct VersionEntry { std::string Name; bool IsVerDef; }; mutable SmallVector, 16> VersionMap; public: Elf_Dyn_Range dynamic_table() const { // A valid .dynamic section contains an array of entries terminated // with a DT_NULL entry. However, sometimes the section content may // continue past the DT_NULL entry, so to dump the section correctly, // we first find the end of the entries by iterating over them. Elf_Dyn_Range Table = DynamicTable.getAsArrayRef(); size_t Size = 0; while (Size < Table.size()) if (Table[Size++].getTag() == DT_NULL) break; return Table.slice(0, Size); } Elf_Sym_Range dynamic_symbols() const { return DynSymRegion.getAsArrayRef(); } Elf_Rel_Range dyn_rels() const; Elf_Rela_Range dyn_relas() const; Elf_Relr_Range dyn_relrs() const; std::string getFullSymbolName(const Elf_Sym *Symbol, StringRef StrTable, bool IsDynamic) const; Expected getSymbolSectionIndex(const Elf_Sym *Symbol, const Elf_Sym *FirstSym) const; Expected getSymbolSectionName(const Elf_Sym *Symbol, unsigned SectionIndex) const; Expected getStaticSymbolName(uint32_t Index) const; std::string getDynamicString(uint64_t Value) const; Expected getSymbolVersionByIndex(uint32_t VersionSymbolIndex, bool &IsDefault) const; void printSymbolsHelper(bool IsDynamic) const; void printDynamicEntry(raw_ostream &OS, uint64_t Type, uint64_t Value) const; const Elf_Shdr *getDotSymtabSec() const { return DotSymtabSec; } const Elf_Shdr *getDotCGProfileSec() const { return DotCGProfileSec; } const Elf_Shdr *getDotAddrsigSec() const { return DotAddrsigSec; } ArrayRef getShndxTable() const { return ShndxTable; } StringRef getDynamicStringTable() const { return DynamicStringTable; } const DynRegionInfo &getDynRelRegion() const { return DynRelRegion; } const DynRegionInfo &getDynRelaRegion() const { return DynRelaRegion; } const DynRegionInfo &getDynRelrRegion() const { return DynRelrRegion; } const DynRegionInfo &getDynPLTRelRegion() const { return DynPLTRelRegion; } const DynRegionInfo &getDynamicTableRegion() const { return DynamicTable; } const Elf_Hash *getHashTable() const { return HashTable; } const Elf_GnuHash *getGnuHashTable() const { return GnuHashTable; } Expected> getVersionTable(const Elf_Shdr *Sec, ArrayRef *SymTab, StringRef *StrTab) const; Expected> getVersionDefinitions(const Elf_Shdr *Sec) const; Expected> getVersionDependencies(const Elf_Shdr *Sec) const; }; template static Expected getLinkAsStrtab(const ELFFile *Obj, const typename ELFT::Shdr *Sec, unsigned SecNdx) { Expected StrTabSecOrErr = Obj->getSection(Sec->sh_link); if (!StrTabSecOrErr) return createError("invalid section linked to " + object::getELFSectionTypeName( Obj->getHeader()->e_machine, Sec->sh_type) + " section with index " + Twine(SecNdx) + ": " + toString(StrTabSecOrErr.takeError())); Expected StrTabOrErr = Obj->getStringTable(*StrTabSecOrErr); if (!StrTabOrErr) return createError("invalid string table linked to " + object::getELFSectionTypeName( Obj->getHeader()->e_machine, Sec->sh_type) + " section with index " + Twine(SecNdx) + ": " + toString(StrTabOrErr.takeError())); return *StrTabOrErr; } // Returns the linked symbol table and associated string table for a given section. template static Expected> getLinkAsSymtab(const ELFFile *Obj, const typename ELFT::Shdr *Sec, unsigned SecNdx, unsigned ExpectedType) { Expected SymtabOrErr = Obj->getSection(Sec->sh_link); if (!SymtabOrErr) return createError("invalid section linked to " + object::getELFSectionTypeName( Obj->getHeader()->e_machine, Sec->sh_type) + " section with index " + Twine(SecNdx) + ": " + toString(SymtabOrErr.takeError())); if ((*SymtabOrErr)->sh_type != ExpectedType) return createError( "invalid section linked to " + object::getELFSectionTypeName(Obj->getHeader()->e_machine, Sec->sh_type) + " section with index " + Twine(SecNdx) + ": expected " + object::getELFSectionTypeName(Obj->getHeader()->e_machine, ExpectedType) + ", but got " + object::getELFSectionTypeName(Obj->getHeader()->e_machine, (*SymtabOrErr)->sh_type)); Expected StrTabOrErr = getLinkAsStrtab(Obj, *SymtabOrErr, Sec->sh_link); if (!StrTabOrErr) return createError( "can't get a string table for the symbol table linked to " + object::getELFSectionTypeName(Obj->getHeader()->e_machine, Sec->sh_type) + " section with index " + Twine(SecNdx) + ": " + toString(StrTabOrErr.takeError())); Expected SymsOrErr = Obj->symbols(*SymtabOrErr); if (!SymsOrErr) return createError( "unable to read symbols from the symbol table with index " + Twine(Sec->sh_link) + ": " + toString(SymsOrErr.takeError())); return std::make_pair(*SymsOrErr, *StrTabOrErr); } template Expected> ELFDumper::getVersionTable(const Elf_Shdr *Sec, ArrayRef *SymTab, StringRef *StrTab) const { assert((!SymTab && !StrTab) || (SymTab && StrTab)); const ELFFile *Obj = ObjF->getELFFile(); unsigned SecNdx = Sec - &cantFail(Obj->sections()).front(); if (uintptr_t(Obj->base() + Sec->sh_offset) % sizeof(uint16_t) != 0) return createError("the SHT_GNU_versym section with index " + Twine(SecNdx) + " is misaligned"); Expected> VersionsOrErr = Obj->template getSectionContentsAsArray(Sec); if (!VersionsOrErr) return createError( "cannot read content of SHT_GNU_versym section with index " + Twine(SecNdx) + ": " + toString(VersionsOrErr.takeError())); Expected, StringRef>> SymTabOrErr = getLinkAsSymtab(Obj, Sec, SecNdx, SHT_DYNSYM); if (!SymTabOrErr) { ELFDumperStyle->reportUniqueWarning(SymTabOrErr.takeError()); return *VersionsOrErr; } if (SymTabOrErr->first.size() != VersionsOrErr->size()) ELFDumperStyle->reportUniqueWarning( createError("SHT_GNU_versym section with index " + Twine(SecNdx) + ": the number of entries (" + Twine(VersionsOrErr->size()) + ") does not match the number of symbols (" + Twine(SymTabOrErr->first.size()) + ") in the symbol table with index " + Twine(Sec->sh_link))); if (SymTab) std::tie(*SymTab, *StrTab) = *SymTabOrErr; return *VersionsOrErr; } template Expected> ELFDumper::getVersionDefinitions(const Elf_Shdr *Sec) const { const ELFFile *Obj = ObjF->getELFFile(); unsigned SecNdx = Sec - &cantFail(Obj->sections()).front(); Expected StrTabOrErr = getLinkAsStrtab(Obj, Sec, SecNdx); if (!StrTabOrErr) return StrTabOrErr.takeError(); Expected> ContentsOrErr = Obj->getSectionContents(Sec); if (!ContentsOrErr) return createError( "cannot read content of SHT_GNU_verdef section with index " + Twine(SecNdx) + ": " + toString(ContentsOrErr.takeError())); const uint8_t *Start = ContentsOrErr->data(); const uint8_t *End = Start + ContentsOrErr->size(); auto ExtractNextAux = [&](const uint8_t *&VerdauxBuf, unsigned VerDefNdx) -> Expected { if (VerdauxBuf + sizeof(Elf_Verdaux) > End) return createError("invalid SHT_GNU_verdef section with index " + Twine(SecNdx) + ": version definition " + Twine(VerDefNdx) + " refers to an auxiliary entry that goes past the end " "of the section"); auto *Verdaux = reinterpret_cast(VerdauxBuf); VerdauxBuf += Verdaux->vda_next; VerdAux Aux; Aux.Offset = VerdauxBuf - Start; if (Verdaux->vda_name <= StrTabOrErr->size()) Aux.Name = StrTabOrErr->drop_front(Verdaux->vda_name); else Aux.Name = "vda_name) + ">"; return Aux; }; std::vector Ret; const uint8_t *VerdefBuf = Start; for (unsigned I = 1; I <= /*VerDefsNum=*/Sec->sh_info; ++I) { if (VerdefBuf + sizeof(Elf_Verdef) > End) return createError("invalid SHT_GNU_verdef section with index " + Twine(SecNdx) + ": version definition " + Twine(I) + " goes past the end of the section"); if (uintptr_t(VerdefBuf) % sizeof(uint32_t) != 0) return createError( "invalid SHT_GNU_verdef section with index " + Twine(SecNdx) + ": found a misaligned version definition entry at offset 0x" + Twine::utohexstr(VerdefBuf - Start)); unsigned Version = *reinterpret_cast(VerdefBuf); if (Version != 1) return createError("unable to dump SHT_GNU_verdef section with index " + Twine(SecNdx) + ": version " + Twine(Version) + " is not yet supported"); const Elf_Verdef *D = reinterpret_cast(VerdefBuf); VerDef &VD = *Ret.emplace(Ret.end()); VD.Offset = VerdefBuf - Start; VD.Version = D->vd_version; VD.Flags = D->vd_flags; VD.Ndx = D->vd_ndx; VD.Cnt = D->vd_cnt; VD.Hash = D->vd_hash; const uint8_t *VerdauxBuf = VerdefBuf + D->vd_aux; for (unsigned J = 0; J < D->vd_cnt; ++J) { if (uintptr_t(VerdauxBuf) % sizeof(uint32_t) != 0) return createError("invalid SHT_GNU_verdef section with index " + Twine(SecNdx) + ": found a misaligned auxiliary entry at offset 0x" + Twine::utohexstr(VerdauxBuf - Start)); Expected AuxOrErr = ExtractNextAux(VerdauxBuf, I); if (!AuxOrErr) return AuxOrErr.takeError(); if (J == 0) VD.Name = AuxOrErr->Name; else VD.AuxV.push_back(*AuxOrErr); } VerdefBuf += D->vd_next; } return Ret; } template Expected> ELFDumper::getVersionDependencies(const Elf_Shdr *Sec) const { const ELFFile *Obj = ObjF->getELFFile(); unsigned SecNdx = Sec - &cantFail(Obj->sections()).front(); StringRef StrTab; Expected StrTabOrErr = getLinkAsStrtab(Obj, Sec, SecNdx); if (!StrTabOrErr) ELFDumperStyle->reportUniqueWarning(StrTabOrErr.takeError()); else StrTab = *StrTabOrErr; Expected> ContentsOrErr = Obj->getSectionContents(Sec); if (!ContentsOrErr) return createError( "cannot read content of SHT_GNU_verneed section with index " + Twine(SecNdx) + ": " + toString(ContentsOrErr.takeError())); const uint8_t *Start = ContentsOrErr->data(); const uint8_t *End = Start + ContentsOrErr->size(); const uint8_t *VerneedBuf = Start; std::vector Ret; for (unsigned I = 1; I <= /*VerneedNum=*/Sec->sh_info; ++I) { if (VerneedBuf + sizeof(Elf_Verdef) > End) return createError("invalid SHT_GNU_verneed section with index " + Twine(SecNdx) + ": version dependency " + Twine(I) + " goes past the end of the section"); if (uintptr_t(VerneedBuf) % sizeof(uint32_t) != 0) return createError( "invalid SHT_GNU_verneed section with index " + Twine(SecNdx) + ": found a misaligned version dependency entry at offset 0x" + Twine::utohexstr(VerneedBuf - Start)); unsigned Version = *reinterpret_cast(VerneedBuf); if (Version != 1) return createError("unable to dump SHT_GNU_verneed section with index " + Twine(SecNdx) + ": version " + Twine(Version) + " is not yet supported"); const Elf_Verneed *Verneed = reinterpret_cast(VerneedBuf); VerNeed &VN = *Ret.emplace(Ret.end()); VN.Version = Verneed->vn_version; VN.Cnt = Verneed->vn_cnt; VN.Offset = VerneedBuf - Start; if (Verneed->vn_file < StrTab.size()) VN.File = StrTab.drop_front(Verneed->vn_file); else VN.File = "vn_file) + ">"; const uint8_t *VernauxBuf = VerneedBuf + Verneed->vn_aux; for (unsigned J = 0; J < Verneed->vn_cnt; ++J) { if (uintptr_t(VernauxBuf) % sizeof(uint32_t) != 0) return createError("invalid SHT_GNU_verneed section with index " + Twine(SecNdx) + ": found a misaligned auxiliary entry at offset 0x" + Twine::utohexstr(VernauxBuf - Start)); if (VernauxBuf + sizeof(Elf_Vernaux) > End) return createError( "invalid SHT_GNU_verneed section with index " + Twine(SecNdx) + ": version dependency " + Twine(I) + " refers to an auxiliary entry that goes past the end " "of the section"); const Elf_Vernaux *Vernaux = reinterpret_cast(VernauxBuf); VernAux &Aux = *VN.AuxV.emplace(VN.AuxV.end()); Aux.Hash = Vernaux->vna_hash; Aux.Flags = Vernaux->vna_flags; Aux.Other = Vernaux->vna_other; Aux.Offset = VernauxBuf - Start; if (StrTab.size() <= Vernaux->vna_name) Aux.Name = ""; else Aux.Name = StrTab.drop_front(Vernaux->vna_name); VernauxBuf += Vernaux->vna_next; } VerneedBuf += Verneed->vn_next; } return Ret; } template void ELFDumper::printSymbolsHelper(bool IsDynamic) const { StringRef StrTable, SymtabName; size_t Entries = 0; Elf_Sym_Range Syms(nullptr, nullptr); const ELFFile *Obj = ObjF->getELFFile(); if (IsDynamic) { StrTable = DynamicStringTable; Syms = dynamic_symbols(); SymtabName = DynSymtabName; if (DynSymRegion.Addr) Entries = DynSymRegion.Size / DynSymRegion.EntSize; } else { if (!DotSymtabSec) return; StrTable = unwrapOrError(ObjF->getFileName(), Obj->getStringTableForSymtab(*DotSymtabSec)); Syms = unwrapOrError(ObjF->getFileName(), Obj->symbols(DotSymtabSec)); SymtabName = unwrapOrError(ObjF->getFileName(), Obj->getSectionName(DotSymtabSec)); Entries = DotSymtabSec->getEntityCount(); } if (Syms.begin() == Syms.end()) return; // The st_other field has 2 logical parts. The first two bits hold the symbol // visibility (STV_*) and the remainder hold other platform-specific values. bool NonVisibilityBitsUsed = llvm::find_if(Syms, [](const Elf_Sym &S) { return S.st_other & ~0x3; }) != Syms.end(); ELFDumperStyle->printSymtabMessage(Obj, SymtabName, Entries, NonVisibilityBitsUsed); for (const auto &Sym : Syms) ELFDumperStyle->printSymbol(Obj, &Sym, Syms.begin(), StrTable, IsDynamic, NonVisibilityBitsUsed); } template class MipsGOTParser; template class DumpStyle { public: using Elf_Shdr = typename ELFT::Shdr; using Elf_Sym = typename ELFT::Sym; using Elf_Addr = typename ELFT::Addr; DumpStyle(ELFDumper *Dumper) : Dumper(Dumper) { FileName = this->Dumper->getElfObject()->getFileName(); // Dumper reports all non-critical errors as warnings. // It does not print the same warning more than once. WarningHandler = [this](const Twine &Msg) { if (Warnings.insert(Msg.str()).second) reportWarning(createError(Msg), FileName); return Error::success(); }; } virtual ~DumpStyle() = default; virtual void printFileHeaders(const ELFFile *Obj) = 0; virtual void printGroupSections(const ELFFile *Obj) = 0; virtual void printRelocations(const ELFFile *Obj) = 0; virtual void printSectionHeaders(const ELFFile *Obj) = 0; virtual void printSymbols(const ELFFile *Obj, bool PrintSymbols, bool PrintDynamicSymbols) = 0; virtual void printHashSymbols(const ELFFile *Obj) {} virtual void printDependentLibs(const ELFFile *Obj) = 0; virtual void printDynamic(const ELFFile *Obj) {} virtual void printDynamicRelocations(const ELFFile *Obj) = 0; virtual void printSymtabMessage(const ELFFile *Obj, StringRef Name, size_t Offset, bool NonVisibilityBitsUsed) {} virtual void printSymbol(const ELFFile *Obj, const Elf_Sym *Symbol, const Elf_Sym *FirstSym, StringRef StrTable, bool IsDynamic, bool NonVisibilityBitsUsed) = 0; virtual void printProgramHeaders(const ELFFile *Obj, bool PrintProgramHeaders, cl::boolOrDefault PrintSectionMapping) = 0; virtual void printVersionSymbolSection(const ELFFile *Obj, const Elf_Shdr *Sec) = 0; virtual void printVersionDefinitionSection(const ELFFile *Obj, const Elf_Shdr *Sec) = 0; virtual void printVersionDependencySection(const ELFFile *Obj, const Elf_Shdr *Sec) = 0; virtual void printHashHistogram(const ELFFile *Obj) = 0; virtual void printCGProfile(const ELFFile *Obj) = 0; virtual void printAddrsig(const ELFFile *Obj) = 0; virtual void printNotes(const ELFFile *Obj) = 0; virtual void printELFLinkerOptions(const ELFFile *Obj) = 0; virtual void printStackSizes(const ELFObjectFile *Obj) = 0; void printNonRelocatableStackSizes(const ELFObjectFile *Obj, std::function PrintHeader); void printRelocatableStackSizes(const ELFObjectFile *Obj, std::function PrintHeader); void printFunctionStackSize(const ELFObjectFile *Obj, uint64_t SymValue, SectionRef FunctionSec, const StringRef SectionName, DataExtractor Data, uint64_t *Offset); void printStackSize(const ELFObjectFile *Obj, RelocationRef Rel, SectionRef FunctionSec, const StringRef &StackSizeSectionName, const RelocationResolver &Resolver, DataExtractor Data); virtual void printStackSizeEntry(uint64_t Size, StringRef FuncName) = 0; virtual void printMipsGOT(const MipsGOTParser &Parser) = 0; virtual void printMipsPLT(const MipsGOTParser &Parser) = 0; virtual void printMipsABIFlags(const ELFObjectFile *Obj) = 0; const ELFDumper *dumper() const { return Dumper; } void reportUniqueWarning(Error Err) const; protected: std::function WarningHandler; StringRef FileName; private: std::unordered_set Warnings; const ELFDumper *Dumper; }; template class GNUStyle : public DumpStyle { formatted_raw_ostream &OS; public: TYPEDEF_ELF_TYPES(ELFT) GNUStyle(ScopedPrinter &W, ELFDumper *Dumper) : DumpStyle(Dumper), OS(static_cast(W.getOStream())) { assert (&W.getOStream() == &llvm::fouts()); } void printFileHeaders(const ELFO *Obj) override; void printGroupSections(const ELFFile *Obj) override; void printRelocations(const ELFO *Obj) override; void printSectionHeaders(const ELFO *Obj) override; void printSymbols(const ELFO *Obj, bool PrintSymbols, bool PrintDynamicSymbols) override; void printHashSymbols(const ELFO *Obj) override; void printDependentLibs(const ELFFile *Obj) override; void printDynamic(const ELFFile *Obj) override; void printDynamicRelocations(const ELFO *Obj) override; void printSymtabMessage(const ELFO *Obj, StringRef Name, size_t Offset, bool NonVisibilityBitsUsed) override; void printProgramHeaders(const ELFO *Obj, bool PrintProgramHeaders, cl::boolOrDefault PrintSectionMapping) override; void printVersionSymbolSection(const ELFFile *Obj, const Elf_Shdr *Sec) override; void printVersionDefinitionSection(const ELFFile *Obj, const Elf_Shdr *Sec) override; void printVersionDependencySection(const ELFFile *Obj, const Elf_Shdr *Sec) override; void printHashHistogram(const ELFFile *Obj) override; void printCGProfile(const ELFFile *Obj) override; void printAddrsig(const ELFFile *Obj) override; void printNotes(const ELFFile *Obj) override; void printELFLinkerOptions(const ELFFile *Obj) override; void printStackSizes(const ELFObjectFile *Obj) override; void printStackSizeEntry(uint64_t Size, StringRef FuncName) override; void printMipsGOT(const MipsGOTParser &Parser) override; void printMipsPLT(const MipsGOTParser &Parser) override; void printMipsABIFlags(const ELFObjectFile *Obj) override; private: struct Field { std::string Str; unsigned Column; Field(StringRef S, unsigned Col) : Str(S), Column(Col) {} Field(unsigned Col) : Column(Col) {} }; template std::string printEnum(T Value, ArrayRef> EnumValues) { for (const auto &EnumItem : EnumValues) if (EnumItem.Value == Value) return EnumItem.AltName; return to_hexString(Value, false); } template std::string printFlags(T Value, ArrayRef> EnumValues, TEnum EnumMask1 = {}, TEnum EnumMask2 = {}, TEnum EnumMask3 = {}) { std::string Str; for (const auto &Flag : EnumValues) { if (Flag.Value == 0) continue; TEnum EnumMask{}; if (Flag.Value & EnumMask1) EnumMask = EnumMask1; else if (Flag.Value & EnumMask2) EnumMask = EnumMask2; else if (Flag.Value & EnumMask3) EnumMask = EnumMask3; bool IsEnum = (Flag.Value & EnumMask) != 0; if ((!IsEnum && (Value & Flag.Value) == Flag.Value) || (IsEnum && (Value & EnumMask) == Flag.Value)) { if (!Str.empty()) Str += ", "; Str += Flag.AltName; } } return Str; } formatted_raw_ostream &printField(struct Field F) { if (F.Column != 0) OS.PadToColumn(F.Column); OS << F.Str; OS.flush(); return OS; } void printHashedSymbol(const ELFO *Obj, const Elf_Sym *FirstSym, uint32_t Sym, StringRef StrTable, uint32_t Bucket); void printRelocHeader(unsigned SType); void printRelocation(const ELFO *Obj, const Elf_Shdr *SymTab, const Elf_Rela &R, bool IsRela); void printRelocation(const ELFO *Obj, const Elf_Sym *Sym, StringRef SymbolName, const Elf_Rela &R, bool IsRela); void printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, const Elf_Sym *First, StringRef StrTable, bool IsDynamic, bool NonVisibilityBitsUsed) override; std::string getSymbolSectionNdx(const ELFO *Obj, const Elf_Sym *Symbol, const Elf_Sym *FirstSym); void printDynamicRelocation(const ELFO *Obj, Elf_Rela R, bool IsRela); bool checkTLSSections(const Elf_Phdr &Phdr, const Elf_Shdr &Sec); bool checkoffsets(const Elf_Phdr &Phdr, const Elf_Shdr &Sec); bool checkVMA(const Elf_Phdr &Phdr, const Elf_Shdr &Sec); bool checkPTDynamic(const Elf_Phdr &Phdr, const Elf_Shdr &Sec); void printProgramHeaders(const ELFO *Obj); void printSectionMapping(const ELFO *Obj); void printGNUVersionSectionProlog(const ELFFile *Obj, const typename ELFT::Shdr *Sec, const Twine &Label, unsigned EntriesNum); }; template void DumpStyle::reportUniqueWarning(Error Err) const { handleAllErrors(std::move(Err), [&](const ErrorInfoBase &EI) { cantFail(WarningHandler(EI.message()), "WarningHandler should always return ErrorSuccess"); }); } template class LLVMStyle : public DumpStyle { public: TYPEDEF_ELF_TYPES(ELFT) LLVMStyle(ScopedPrinter &W, ELFDumper *Dumper) : DumpStyle(Dumper), W(W) {} void printFileHeaders(const ELFO *Obj) override; void printGroupSections(const ELFFile *Obj) override; void printRelocations(const ELFO *Obj) override; void printRelocations(const Elf_Shdr *Sec, const ELFO *Obj); void printSectionHeaders(const ELFO *Obj) override; void printSymbols(const ELFO *Obj, bool PrintSymbols, bool PrintDynamicSymbols) override; void printDependentLibs(const ELFFile *Obj) override; void printDynamic(const ELFFile *Obj) override; void printDynamicRelocations(const ELFO *Obj) override; void printProgramHeaders(const ELFO *Obj, bool PrintProgramHeaders, cl::boolOrDefault PrintSectionMapping) override; void printVersionSymbolSection(const ELFFile *Obj, const Elf_Shdr *Sec) override; void printVersionDefinitionSection(const ELFFile *Obj, const Elf_Shdr *Sec) override; void printVersionDependencySection(const ELFFile *Obj, const Elf_Shdr *Sec) override; void printHashHistogram(const ELFFile *Obj) override; void printCGProfile(const ELFFile *Obj) override; void printAddrsig(const ELFFile *Obj) override; void printNotes(const ELFFile *Obj) override; void printELFLinkerOptions(const ELFFile *Obj) override; void printStackSizes(const ELFObjectFile *Obj) override; void printStackSizeEntry(uint64_t Size, StringRef FuncName) override; void printMipsGOT(const MipsGOTParser &Parser) override; void printMipsPLT(const MipsGOTParser &Parser) override; void printMipsABIFlags(const ELFObjectFile *Obj) override; private: void printRelocation(const ELFO *Obj, Elf_Rela Rel, const Elf_Shdr *SymTab); void printDynamicRelocation(const ELFO *Obj, Elf_Rela Rel); void printSymbols(const ELFO *Obj); void printDynamicSymbols(const ELFO *Obj); void printSymbolSection(const Elf_Sym *Symbol, const Elf_Sym *First); void printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, const Elf_Sym *First, StringRef StrTable, bool IsDynamic, bool /*NonVisibilityBitsUsed*/) override; void printProgramHeaders(const ELFO *Obj); void printSectionMapping(const ELFO *Obj) {} ScopedPrinter &W; }; } // end anonymous namespace namespace llvm { template static std::error_code createELFDumper(const ELFObjectFile *Obj, ScopedPrinter &Writer, std::unique_ptr &Result) { Result.reset(new ELFDumper(Obj, Writer)); return readobj_error::success; } std::error_code createELFDumper(const object::ObjectFile *Obj, ScopedPrinter &Writer, std::unique_ptr &Result) { // Little-endian 32-bit if (const ELF32LEObjectFile *ELFObj = dyn_cast(Obj)) return createELFDumper(ELFObj, Writer, Result); // Big-endian 32-bit if (const ELF32BEObjectFile *ELFObj = dyn_cast(Obj)) return createELFDumper(ELFObj, Writer, Result); // Little-endian 64-bit if (const ELF64LEObjectFile *ELFObj = dyn_cast(Obj)) return createELFDumper(ELFObj, Writer, Result); // Big-endian 64-bit if (const ELF64BEObjectFile *ELFObj = dyn_cast(Obj)) return createELFDumper(ELFObj, Writer, Result); return readobj_error::unsupported_obj_file_format; } } // end namespace llvm template Error ELFDumper::LoadVersionMap() const { // If there is no dynamic symtab or version table, there is nothing to do. if (!DynSymRegion.Addr || !SymbolVersionSection) return Error::success(); // Has the VersionMap already been loaded? if (!VersionMap.empty()) return Error::success(); // The first two version indexes are reserved. // Index 0 is LOCAL, index 1 is GLOBAL. VersionMap.push_back(VersionEntry()); VersionMap.push_back(VersionEntry()); auto InsertEntry = [this](unsigned N, StringRef Version, bool IsVerdef) { if (N >= VersionMap.size()) VersionMap.resize(N + 1); VersionMap[N] = {Version, IsVerdef}; }; if (SymbolVersionDefSection) { Expected> Defs = this->getVersionDefinitions(SymbolVersionDefSection); if (!Defs) return Defs.takeError(); for (const VerDef &Def : *Defs) InsertEntry(Def.Ndx & ELF::VERSYM_VERSION, Def.Name, true); } if (SymbolVersionNeedSection) { Expected> Deps = this->getVersionDependencies(SymbolVersionNeedSection); if (!Deps) return Deps.takeError(); for (const VerNeed &Dep : *Deps) for (const VernAux &Aux : Dep.AuxV) InsertEntry(Aux.Other & ELF::VERSYM_VERSION, Aux.Name, false); } return Error::success(); } template Expected ELFDumper::getSymbolVersion(const Elf_Sym *Sym, bool &IsDefault) const { // This is a dynamic symbol. Look in the GNU symbol version table. if (!SymbolVersionSection) { // No version table. IsDefault = false; return ""; } // Determine the position in the symbol table of this entry. size_t EntryIndex = (reinterpret_cast(Sym) - reinterpret_cast(DynSymRegion.Addr)) / sizeof(Elf_Sym); // Get the corresponding version index entry. const Elf_Versym *Versym = unwrapOrError( ObjF->getFileName(), ObjF->getELFFile()->template getEntry( SymbolVersionSection, EntryIndex)); return this->getSymbolVersionByIndex(Versym->vs_index, IsDefault); } static std::string maybeDemangle(StringRef Name) { return opts::Demangle ? demangle(Name) : Name.str(); } template Expected ELFDumper::getStaticSymbolName(uint32_t Index) const { const ELFFile *Obj = ObjF->getELFFile(); Expected SymOrErr = Obj->getSymbol(DotSymtabSec, Index); if (!SymOrErr) return SymOrErr.takeError(); Expected StrTabOrErr = Obj->getStringTableForSymtab(*DotSymtabSec); if (!StrTabOrErr) return StrTabOrErr.takeError(); Expected NameOrErr = (*SymOrErr)->getName(*StrTabOrErr); if (!NameOrErr) return NameOrErr.takeError(); return maybeDemangle(*NameOrErr); } template Expected ELFDumper::getSymbolVersionByIndex(uint32_t SymbolVersionIndex, bool &IsDefault) const { size_t VersionIndex = SymbolVersionIndex & VERSYM_VERSION; // Special markers for unversioned symbols. if (VersionIndex == VER_NDX_LOCAL || VersionIndex == VER_NDX_GLOBAL) { IsDefault = false; return ""; } // Lookup this symbol in the version table. if (Error E = LoadVersionMap()) return std::move(E); if (VersionIndex >= VersionMap.size() || !VersionMap[VersionIndex]) return createError("SHT_GNU_versym section refers to a version index " + Twine(VersionIndex) + " which is missing"); const VersionEntry &Entry = *VersionMap[VersionIndex]; if (Entry.IsVerDef) IsDefault = !(SymbolVersionIndex & VERSYM_HIDDEN); else IsDefault = false; return Entry.Name.c_str(); } template std::string ELFDumper::getFullSymbolName(const Elf_Sym *Symbol, StringRef StrTable, bool IsDynamic) const { std::string SymbolName = maybeDemangle( unwrapOrError(ObjF->getFileName(), Symbol->getName(StrTable))); if (SymbolName.empty() && Symbol->getType() == ELF::STT_SECTION) { Elf_Sym_Range Syms = unwrapOrError( ObjF->getFileName(), ObjF->getELFFile()->symbols(DotSymtabSec)); Expected SectionIndex = getSymbolSectionIndex(Symbol, Syms.begin()); if (!SectionIndex) { ELFDumperStyle->reportUniqueWarning(SectionIndex.takeError()); return ""; } Expected NameOrErr = getSymbolSectionName(Symbol, *SectionIndex); if (!NameOrErr) { ELFDumperStyle->reportUniqueWarning(NameOrErr.takeError()); return ("
").str(); } return *NameOrErr; } if (!IsDynamic) return SymbolName; bool IsDefault; Expected VersionOrErr = getSymbolVersion(&*Symbol, IsDefault); if (!VersionOrErr) { ELFDumperStyle->reportUniqueWarning(VersionOrErr.takeError()); return SymbolName + "@"; } if (!VersionOrErr->empty()) { SymbolName += (IsDefault ? "@@" : "@"); SymbolName += *VersionOrErr; } return SymbolName; } template Expected ELFDumper::getSymbolSectionIndex(const Elf_Sym *Symbol, const Elf_Sym *FirstSym) const { return Symbol->st_shndx == SHN_XINDEX ? object::getExtendedSymbolTableIndex(Symbol, FirstSym, ShndxTable) : Symbol->st_shndx; } // If the Symbol has a reserved st_shndx other than SHN_XINDEX, return a // descriptive interpretation of the st_shndx value. Otherwise, return the name // of the section with index SectionIndex. This function assumes that if the // Symbol has st_shndx == SHN_XINDEX the SectionIndex will be the value derived // from the SHT_SYMTAB_SHNDX section. template Expected ELFDumper::getSymbolSectionName(const Elf_Sym *Symbol, unsigned SectionIndex) const { if (Symbol->isUndefined()) return "Undefined"; if (Symbol->isProcessorSpecific()) return "Processor Specific"; if (Symbol->isOSSpecific()) return "Operating System Specific"; if (Symbol->isAbsolute()) return "Absolute"; if (Symbol->isCommon()) return "Common"; if (Symbol->isReserved() && Symbol->st_shndx != SHN_XINDEX) return "Reserved"; const ELFFile *Obj = ObjF->getELFFile(); Expected SecOrErr = Obj->getSection(SectionIndex); if (!SecOrErr) return SecOrErr.takeError(); return Obj->getSectionName(*SecOrErr); } template static const typename ELFO::Elf_Shdr * findNotEmptySectionByAddress(const ELFO *Obj, StringRef FileName, uint64_t Addr) { for (const auto &Shdr : unwrapOrError(FileName, Obj->sections())) if (Shdr.sh_addr == Addr && Shdr.sh_size > 0) return &Shdr; return nullptr; } template static const typename ELFO::Elf_Shdr * findSectionByName(const ELFO &Obj, StringRef FileName, StringRef Name) { for (const auto &Shdr : unwrapOrError(FileName, Obj.sections())) if (Name == unwrapOrError(FileName, Obj.getSectionName(&Shdr))) return &Shdr; return nullptr; } static const EnumEntry ElfClass[] = { {"None", "none", ELF::ELFCLASSNONE}, {"32-bit", "ELF32", ELF::ELFCLASS32}, {"64-bit", "ELF64", ELF::ELFCLASS64}, }; static const EnumEntry ElfDataEncoding[] = { {"None", "none", ELF::ELFDATANONE}, {"LittleEndian", "2's complement, little endian", ELF::ELFDATA2LSB}, {"BigEndian", "2's complement, big endian", ELF::ELFDATA2MSB}, }; static const EnumEntry ElfObjectFileType[] = { {"None", "NONE (none)", ELF::ET_NONE}, {"Relocatable", "REL (Relocatable file)", ELF::ET_REL}, {"Executable", "EXEC (Executable file)", ELF::ET_EXEC}, {"SharedObject", "DYN (Shared object file)", ELF::ET_DYN}, {"Core", "CORE (Core file)", ELF::ET_CORE}, }; static const EnumEntry ElfOSABI[] = { {"SystemV", "UNIX - System V", ELF::ELFOSABI_NONE}, {"HPUX", "UNIX - HP-UX", ELF::ELFOSABI_HPUX}, {"NetBSD", "UNIX - NetBSD", ELF::ELFOSABI_NETBSD}, {"GNU/Linux", "UNIX - GNU", ELF::ELFOSABI_LINUX}, {"GNU/Hurd", "GNU/Hurd", ELF::ELFOSABI_HURD}, {"Solaris", "UNIX - Solaris", ELF::ELFOSABI_SOLARIS}, {"AIX", "UNIX - AIX", ELF::ELFOSABI_AIX}, {"IRIX", "UNIX - IRIX", ELF::ELFOSABI_IRIX}, {"FreeBSD", "UNIX - FreeBSD", ELF::ELFOSABI_FREEBSD}, {"TRU64", "UNIX - TRU64", ELF::ELFOSABI_TRU64}, {"Modesto", "Novell - Modesto", ELF::ELFOSABI_MODESTO}, {"OpenBSD", "UNIX - OpenBSD", ELF::ELFOSABI_OPENBSD}, {"OpenVMS", "VMS - OpenVMS", ELF::ELFOSABI_OPENVMS}, {"NSK", "HP - Non-Stop Kernel", ELF::ELFOSABI_NSK}, {"AROS", "AROS", ELF::ELFOSABI_AROS}, {"FenixOS", "FenixOS", ELF::ELFOSABI_FENIXOS}, {"CloudABI", "CloudABI", ELF::ELFOSABI_CLOUDABI}, {"Standalone", "Standalone App", ELF::ELFOSABI_STANDALONE} }; static const EnumEntry SymVersionFlags[] = { {"Base", "BASE", VER_FLG_BASE}, {"Weak", "WEAK", VER_FLG_WEAK}, {"Info", "INFO", VER_FLG_INFO}}; static const EnumEntry AMDGPUElfOSABI[] = { {"AMDGPU_HSA", "AMDGPU - HSA", ELF::ELFOSABI_AMDGPU_HSA}, {"AMDGPU_PAL", "AMDGPU - PAL", ELF::ELFOSABI_AMDGPU_PAL}, {"AMDGPU_MESA3D", "AMDGPU - MESA3D", ELF::ELFOSABI_AMDGPU_MESA3D} }; static const EnumEntry ARMElfOSABI[] = { {"ARM", "ARM", ELF::ELFOSABI_ARM} }; static const EnumEntry C6000ElfOSABI[] = { {"C6000_ELFABI", "Bare-metal C6000", ELF::ELFOSABI_C6000_ELFABI}, {"C6000_LINUX", "Linux C6000", ELF::ELFOSABI_C6000_LINUX} }; static const EnumEntry ElfMachineType[] = { ENUM_ENT(EM_NONE, "None"), ENUM_ENT(EM_M32, "WE32100"), ENUM_ENT(EM_SPARC, "Sparc"), ENUM_ENT(EM_386, "Intel 80386"), ENUM_ENT(EM_68K, "MC68000"), ENUM_ENT(EM_88K, "MC88000"), ENUM_ENT(EM_IAMCU, "EM_IAMCU"), ENUM_ENT(EM_860, "Intel 80860"), ENUM_ENT(EM_MIPS, "MIPS R3000"), ENUM_ENT(EM_S370, "IBM System/370"), ENUM_ENT(EM_MIPS_RS3_LE, "MIPS R3000 little-endian"), ENUM_ENT(EM_PARISC, "HPPA"), ENUM_ENT(EM_VPP500, "Fujitsu VPP500"), ENUM_ENT(EM_SPARC32PLUS, "Sparc v8+"), ENUM_ENT(EM_960, "Intel 80960"), ENUM_ENT(EM_PPC, "PowerPC"), ENUM_ENT(EM_PPC64, "PowerPC64"), ENUM_ENT(EM_S390, "IBM S/390"), ENUM_ENT(EM_SPU, "SPU"), ENUM_ENT(EM_V800, "NEC V800 series"), ENUM_ENT(EM_FR20, "Fujistsu FR20"), ENUM_ENT(EM_RH32, "TRW RH-32"), ENUM_ENT(EM_RCE, "Motorola RCE"), ENUM_ENT(EM_ARM, "ARM"), ENUM_ENT(EM_ALPHA, "EM_ALPHA"), ENUM_ENT(EM_SH, "Hitachi SH"), ENUM_ENT(EM_SPARCV9, "Sparc v9"), ENUM_ENT(EM_TRICORE, "Siemens Tricore"), ENUM_ENT(EM_ARC, "ARC"), ENUM_ENT(EM_H8_300, "Hitachi H8/300"), ENUM_ENT(EM_H8_300H, "Hitachi H8/300H"), ENUM_ENT(EM_H8S, "Hitachi H8S"), ENUM_ENT(EM_H8_500, "Hitachi H8/500"), ENUM_ENT(EM_IA_64, "Intel IA-64"), ENUM_ENT(EM_MIPS_X, "Stanford MIPS-X"), ENUM_ENT(EM_COLDFIRE, "Motorola Coldfire"), ENUM_ENT(EM_68HC12, "Motorola MC68HC12 Microcontroller"), ENUM_ENT(EM_MMA, "Fujitsu Multimedia Accelerator"), ENUM_ENT(EM_PCP, "Siemens PCP"), ENUM_ENT(EM_NCPU, "Sony nCPU embedded RISC processor"), ENUM_ENT(EM_NDR1, "Denso NDR1 microprocesspr"), ENUM_ENT(EM_STARCORE, "Motorola Star*Core processor"), ENUM_ENT(EM_ME16, "Toyota ME16 processor"), ENUM_ENT(EM_ST100, "STMicroelectronics ST100 processor"), ENUM_ENT(EM_TINYJ, "Advanced Logic Corp. TinyJ embedded processor"), ENUM_ENT(EM_X86_64, "Advanced Micro Devices X86-64"), ENUM_ENT(EM_PDSP, "Sony DSP processor"), ENUM_ENT(EM_PDP10, "Digital Equipment Corp. PDP-10"), ENUM_ENT(EM_PDP11, "Digital Equipment Corp. PDP-11"), ENUM_ENT(EM_FX66, "Siemens FX66 microcontroller"), ENUM_ENT(EM_ST9PLUS, "STMicroelectronics ST9+ 8/16 bit microcontroller"), ENUM_ENT(EM_ST7, "STMicroelectronics ST7 8-bit microcontroller"), ENUM_ENT(EM_68HC16, "Motorola MC68HC16 Microcontroller"), ENUM_ENT(EM_68HC11, "Motorola MC68HC11 Microcontroller"), ENUM_ENT(EM_68HC08, "Motorola MC68HC08 Microcontroller"), ENUM_ENT(EM_68HC05, "Motorola MC68HC05 Microcontroller"), ENUM_ENT(EM_SVX, "Silicon Graphics SVx"), ENUM_ENT(EM_ST19, "STMicroelectronics ST19 8-bit microcontroller"), ENUM_ENT(EM_VAX, "Digital VAX"), ENUM_ENT(EM_CRIS, "Axis Communications 32-bit embedded processor"), ENUM_ENT(EM_JAVELIN, "Infineon Technologies 32-bit embedded cpu"), ENUM_ENT(EM_FIREPATH, "Element 14 64-bit DSP processor"), ENUM_ENT(EM_ZSP, "LSI Logic's 16-bit DSP processor"), ENUM_ENT(EM_MMIX, "Donald Knuth's educational 64-bit processor"), ENUM_ENT(EM_HUANY, "Harvard Universitys's machine-independent object format"), ENUM_ENT(EM_PRISM, "Vitesse Prism"), ENUM_ENT(EM_AVR, "Atmel AVR 8-bit microcontroller"), ENUM_ENT(EM_FR30, "Fujitsu FR30"), ENUM_ENT(EM_D10V, "Mitsubishi D10V"), ENUM_ENT(EM_D30V, "Mitsubishi D30V"), ENUM_ENT(EM_V850, "NEC v850"), ENUM_ENT(EM_M32R, "Renesas M32R (formerly Mitsubishi M32r)"), ENUM_ENT(EM_MN10300, "Matsushita MN10300"), ENUM_ENT(EM_MN10200, "Matsushita MN10200"), ENUM_ENT(EM_PJ, "picoJava"), ENUM_ENT(EM_OPENRISC, "OpenRISC 32-bit embedded processor"), ENUM_ENT(EM_ARC_COMPACT, "EM_ARC_COMPACT"), ENUM_ENT(EM_XTENSA, "Tensilica Xtensa Processor"), ENUM_ENT(EM_VIDEOCORE, "Alphamosaic VideoCore processor"), ENUM_ENT(EM_TMM_GPP, "Thompson Multimedia General Purpose Processor"), ENUM_ENT(EM_NS32K, "National Semiconductor 32000 series"), ENUM_ENT(EM_TPC, "Tenor Network TPC processor"), ENUM_ENT(EM_SNP1K, "EM_SNP1K"), ENUM_ENT(EM_ST200, "STMicroelectronics ST200 microcontroller"), ENUM_ENT(EM_IP2K, "Ubicom IP2xxx 8-bit microcontrollers"), ENUM_ENT(EM_MAX, "MAX Processor"), ENUM_ENT(EM_CR, "National Semiconductor CompactRISC"), ENUM_ENT(EM_F2MC16, "Fujitsu F2MC16"), ENUM_ENT(EM_MSP430, "Texas Instruments msp430 microcontroller"), ENUM_ENT(EM_BLACKFIN, "Analog Devices Blackfin"), ENUM_ENT(EM_SE_C33, "S1C33 Family of Seiko Epson processors"), ENUM_ENT(EM_SEP, "Sharp embedded microprocessor"), ENUM_ENT(EM_ARCA, "Arca RISC microprocessor"), ENUM_ENT(EM_UNICORE, "Unicore"), ENUM_ENT(EM_EXCESS, "eXcess 16/32/64-bit configurable embedded CPU"), ENUM_ENT(EM_DXP, "Icera Semiconductor Inc. Deep Execution Processor"), ENUM_ENT(EM_ALTERA_NIOS2, "Altera Nios"), ENUM_ENT(EM_CRX, "National Semiconductor CRX microprocessor"), ENUM_ENT(EM_XGATE, "Motorola XGATE embedded processor"), ENUM_ENT(EM_C166, "Infineon Technologies xc16x"), ENUM_ENT(EM_M16C, "Renesas M16C"), ENUM_ENT(EM_DSPIC30F, "Microchip Technology dsPIC30F Digital Signal Controller"), ENUM_ENT(EM_CE, "Freescale Communication Engine RISC core"), ENUM_ENT(EM_M32C, "Renesas M32C"), ENUM_ENT(EM_TSK3000, "Altium TSK3000 core"), ENUM_ENT(EM_RS08, "Freescale RS08 embedded processor"), ENUM_ENT(EM_SHARC, "EM_SHARC"), ENUM_ENT(EM_ECOG2, "Cyan Technology eCOG2 microprocessor"), ENUM_ENT(EM_SCORE7, "SUNPLUS S+Core"), ENUM_ENT(EM_DSP24, "New Japan Radio (NJR) 24-bit DSP Processor"), ENUM_ENT(EM_VIDEOCORE3, "Broadcom VideoCore III processor"), ENUM_ENT(EM_LATTICEMICO32, "Lattice Mico32"), ENUM_ENT(EM_SE_C17, "Seiko Epson C17 family"), ENUM_ENT(EM_TI_C6000, "Texas Instruments TMS320C6000 DSP family"), ENUM_ENT(EM_TI_C2000, "Texas Instruments TMS320C2000 DSP family"), ENUM_ENT(EM_TI_C5500, "Texas Instruments TMS320C55x DSP family"), ENUM_ENT(EM_MMDSP_PLUS, "STMicroelectronics 64bit VLIW Data Signal Processor"), ENUM_ENT(EM_CYPRESS_M8C, "Cypress M8C microprocessor"), ENUM_ENT(EM_R32C, "Renesas R32C series microprocessors"), ENUM_ENT(EM_TRIMEDIA, "NXP Semiconductors TriMedia architecture family"), ENUM_ENT(EM_HEXAGON, "Qualcomm Hexagon"), ENUM_ENT(EM_8051, "Intel 8051 and variants"), ENUM_ENT(EM_STXP7X, "STMicroelectronics STxP7x family"), ENUM_ENT(EM_NDS32, "Andes Technology compact code size embedded RISC processor family"), ENUM_ENT(EM_ECOG1, "Cyan Technology eCOG1 microprocessor"), ENUM_ENT(EM_ECOG1X, "Cyan Technology eCOG1X family"), ENUM_ENT(EM_MAXQ30, "Dallas Semiconductor MAXQ30 Core microcontrollers"), ENUM_ENT(EM_XIMO16, "New Japan Radio (NJR) 16-bit DSP Processor"), ENUM_ENT(EM_MANIK, "M2000 Reconfigurable RISC Microprocessor"), ENUM_ENT(EM_CRAYNV2, "Cray Inc. NV2 vector architecture"), ENUM_ENT(EM_RX, "Renesas RX"), ENUM_ENT(EM_METAG, "Imagination Technologies Meta processor architecture"), ENUM_ENT(EM_MCST_ELBRUS, "MCST Elbrus general purpose hardware architecture"), ENUM_ENT(EM_ECOG16, "Cyan Technology eCOG16 family"), ENUM_ENT(EM_CR16, "Xilinx MicroBlaze"), ENUM_ENT(EM_ETPU, "Freescale Extended Time Processing Unit"), ENUM_ENT(EM_SLE9X, "Infineon Technologies SLE9X core"), ENUM_ENT(EM_L10M, "EM_L10M"), ENUM_ENT(EM_K10M, "EM_K10M"), ENUM_ENT(EM_AARCH64, "AArch64"), ENUM_ENT(EM_AVR32, "Atmel Corporation 32-bit microprocessor family"), ENUM_ENT(EM_STM8, "STMicroeletronics STM8 8-bit microcontroller"), ENUM_ENT(EM_TILE64, "Tilera TILE64 multicore architecture family"), ENUM_ENT(EM_TILEPRO, "Tilera TILEPro multicore architecture family"), ENUM_ENT(EM_CUDA, "NVIDIA CUDA architecture"), ENUM_ENT(EM_TILEGX, "Tilera TILE-Gx multicore architecture family"), ENUM_ENT(EM_CLOUDSHIELD, "EM_CLOUDSHIELD"), ENUM_ENT(EM_COREA_1ST, "EM_COREA_1ST"), ENUM_ENT(EM_COREA_2ND, "EM_COREA_2ND"), ENUM_ENT(EM_ARC_COMPACT2, "EM_ARC_COMPACT2"), ENUM_ENT(EM_OPEN8, "EM_OPEN8"), ENUM_ENT(EM_RL78, "Renesas RL78"), ENUM_ENT(EM_VIDEOCORE5, "Broadcom VideoCore V processor"), ENUM_ENT(EM_78KOR, "EM_78KOR"), ENUM_ENT(EM_56800EX, "EM_56800EX"), ENUM_ENT(EM_AMDGPU, "EM_AMDGPU"), ENUM_ENT(EM_RISCV, "RISC-V"), ENUM_ENT(EM_LANAI, "EM_LANAI"), ENUM_ENT(EM_BPF, "EM_BPF"), }; static const EnumEntry ElfSymbolBindings[] = { {"Local", "LOCAL", ELF::STB_LOCAL}, {"Global", "GLOBAL", ELF::STB_GLOBAL}, {"Weak", "WEAK", ELF::STB_WEAK}, {"Unique", "UNIQUE", ELF::STB_GNU_UNIQUE}}; static const EnumEntry ElfSymbolVisibilities[] = { {"DEFAULT", "DEFAULT", ELF::STV_DEFAULT}, {"INTERNAL", "INTERNAL", ELF::STV_INTERNAL}, {"HIDDEN", "HIDDEN", ELF::STV_HIDDEN}, {"PROTECTED", "PROTECTED", ELF::STV_PROTECTED}}; static const EnumEntry AMDGPUSymbolTypes[] = { { "AMDGPU_HSA_KERNEL", ELF::STT_AMDGPU_HSA_KERNEL } }; static const char *getGroupType(uint32_t Flag) { if (Flag & ELF::GRP_COMDAT) return "COMDAT"; else return "(unknown)"; } static const EnumEntry ElfSectionFlags[] = { ENUM_ENT(SHF_WRITE, "W"), ENUM_ENT(SHF_ALLOC, "A"), ENUM_ENT(SHF_EXECINSTR, "X"), ENUM_ENT(SHF_MERGE, "M"), ENUM_ENT(SHF_STRINGS, "S"), ENUM_ENT(SHF_INFO_LINK, "I"), ENUM_ENT(SHF_LINK_ORDER, "L"), ENUM_ENT(SHF_OS_NONCONFORMING, "O"), ENUM_ENT(SHF_GROUP, "G"), ENUM_ENT(SHF_TLS, "T"), ENUM_ENT(SHF_COMPRESSED, "C"), ENUM_ENT(SHF_EXCLUDE, "E"), }; static const EnumEntry ElfXCoreSectionFlags[] = { ENUM_ENT(XCORE_SHF_CP_SECTION, ""), ENUM_ENT(XCORE_SHF_DP_SECTION, "") }; static const EnumEntry ElfARMSectionFlags[] = { ENUM_ENT(SHF_ARM_PURECODE, "y") }; static const EnumEntry ElfHexagonSectionFlags[] = { ENUM_ENT(SHF_HEX_GPREL, "") }; static const EnumEntry ElfMipsSectionFlags[] = { ENUM_ENT(SHF_MIPS_NODUPES, ""), ENUM_ENT(SHF_MIPS_NAMES, ""), ENUM_ENT(SHF_MIPS_LOCAL, ""), ENUM_ENT(SHF_MIPS_NOSTRIP, ""), ENUM_ENT(SHF_MIPS_GPREL, ""), ENUM_ENT(SHF_MIPS_MERGE, ""), ENUM_ENT(SHF_MIPS_ADDR, ""), ENUM_ENT(SHF_MIPS_STRING, "") }; static const EnumEntry ElfX86_64SectionFlags[] = { ENUM_ENT(SHF_X86_64_LARGE, "l") }; static std::vector> getSectionFlagsForTarget(unsigned EMachine) { std::vector> Ret(std::begin(ElfSectionFlags), std::end(ElfSectionFlags)); switch (EMachine) { case EM_ARM: Ret.insert(Ret.end(), std::begin(ElfARMSectionFlags), std::end(ElfARMSectionFlags)); break; case EM_HEXAGON: Ret.insert(Ret.end(), std::begin(ElfHexagonSectionFlags), std::end(ElfHexagonSectionFlags)); break; case EM_MIPS: Ret.insert(Ret.end(), std::begin(ElfMipsSectionFlags), std::end(ElfMipsSectionFlags)); break; case EM_X86_64: Ret.insert(Ret.end(), std::begin(ElfX86_64SectionFlags), std::end(ElfX86_64SectionFlags)); break; case EM_XCORE: Ret.insert(Ret.end(), std::begin(ElfXCoreSectionFlags), std::end(ElfXCoreSectionFlags)); break; default: break; } return Ret; } static std::string getGNUFlags(unsigned EMachine, uint64_t Flags) { // Here we are trying to build the flags string in the same way as GNU does. // It is not that straightforward. Imagine we have sh_flags == 0x90000000. // SHF_EXCLUDE ("E") has a value of 0x80000000 and SHF_MASKPROC is 0xf0000000. // GNU readelf will not print "E" or "Ep" in this case, but will print just // "p". It only will print "E" when no other processor flag is set. std::string Str; bool HasUnknownFlag = false; bool HasOSFlag = false; bool HasProcFlag = false; std::vector> FlagsList = getSectionFlagsForTarget(EMachine); while (Flags) { // Take the least significant bit as a flag. uint64_t Flag = Flags & -Flags; Flags -= Flag; // Find the flag in the known flags list. auto I = llvm::find_if(FlagsList, [=](const EnumEntry &E) { // Flags with empty names are not printed in GNU style output. return E.Value == Flag && !E.AltName.empty(); }); if (I != FlagsList.end()) { Str += I->AltName; continue; } // If we did not find a matching regular flag, then we deal with an OS // specific flag, processor specific flag or an unknown flag. if (Flag & ELF::SHF_MASKOS) { HasOSFlag = true; Flags &= ~ELF::SHF_MASKOS; } else if (Flag & ELF::SHF_MASKPROC) { HasProcFlag = true; // Mask off all the processor-specific bits. This removes the SHF_EXCLUDE // bit if set so that it doesn't also get printed. Flags &= ~ELF::SHF_MASKPROC; } else { HasUnknownFlag = true; } } // "o", "p" and "x" are printed last. if (HasOSFlag) Str += "o"; if (HasProcFlag) Str += "p"; if (HasUnknownFlag) Str += "x"; return Str; } static const char *getElfSegmentType(unsigned Arch, unsigned Type) { // Check potentially overlapped processor-specific // program header type. switch (Arch) { case ELF::EM_ARM: switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, PT_ARM_EXIDX); } break; case ELF::EM_MIPS: case ELF::EM_MIPS_RS3_LE: switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_REGINFO); LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_RTPROC); LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_OPTIONS); LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_ABIFLAGS); } break; } switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, PT_NULL ); LLVM_READOBJ_ENUM_CASE(ELF, PT_LOAD ); LLVM_READOBJ_ENUM_CASE(ELF, PT_DYNAMIC); LLVM_READOBJ_ENUM_CASE(ELF, PT_INTERP ); LLVM_READOBJ_ENUM_CASE(ELF, PT_NOTE ); LLVM_READOBJ_ENUM_CASE(ELF, PT_SHLIB ); LLVM_READOBJ_ENUM_CASE(ELF, PT_PHDR ); LLVM_READOBJ_ENUM_CASE(ELF, PT_TLS ); LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_EH_FRAME); LLVM_READOBJ_ENUM_CASE(ELF, PT_SUNW_UNWIND); LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_STACK); LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_RELRO); LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_PROPERTY); LLVM_READOBJ_ENUM_CASE(ELF, PT_OPENBSD_RANDOMIZE); LLVM_READOBJ_ENUM_CASE(ELF, PT_OPENBSD_WXNEEDED); LLVM_READOBJ_ENUM_CASE(ELF, PT_OPENBSD_BOOTDATA); default: return ""; } } static std::string getElfPtType(unsigned Arch, unsigned Type) { switch (Type) { LLVM_READOBJ_PHDR_ENUM(ELF, PT_NULL) LLVM_READOBJ_PHDR_ENUM(ELF, PT_LOAD) LLVM_READOBJ_PHDR_ENUM(ELF, PT_DYNAMIC) LLVM_READOBJ_PHDR_ENUM(ELF, PT_INTERP) LLVM_READOBJ_PHDR_ENUM(ELF, PT_NOTE) LLVM_READOBJ_PHDR_ENUM(ELF, PT_SHLIB) LLVM_READOBJ_PHDR_ENUM(ELF, PT_PHDR) LLVM_READOBJ_PHDR_ENUM(ELF, PT_TLS) LLVM_READOBJ_PHDR_ENUM(ELF, PT_GNU_EH_FRAME) LLVM_READOBJ_PHDR_ENUM(ELF, PT_SUNW_UNWIND) LLVM_READOBJ_PHDR_ENUM(ELF, PT_GNU_STACK) LLVM_READOBJ_PHDR_ENUM(ELF, PT_GNU_RELRO) LLVM_READOBJ_PHDR_ENUM(ELF, PT_GNU_PROPERTY) default: // All machine specific PT_* types switch (Arch) { case ELF::EM_ARM: if (Type == ELF::PT_ARM_EXIDX) return "EXIDX"; break; case ELF::EM_MIPS: case ELF::EM_MIPS_RS3_LE: switch (Type) { case PT_MIPS_REGINFO: return "REGINFO"; case PT_MIPS_RTPROC: return "RTPROC"; case PT_MIPS_OPTIONS: return "OPTIONS"; case PT_MIPS_ABIFLAGS: return "ABIFLAGS"; } break; } } return std::string(": ") + to_string(format_hex(Type, 1)); } static const EnumEntry ElfSegmentFlags[] = { LLVM_READOBJ_ENUM_ENT(ELF, PF_X), LLVM_READOBJ_ENUM_ENT(ELF, PF_W), LLVM_READOBJ_ENUM_ENT(ELF, PF_R) }; static const EnumEntry ElfHeaderMipsFlags[] = { ENUM_ENT(EF_MIPS_NOREORDER, "noreorder"), ENUM_ENT(EF_MIPS_PIC, "pic"), ENUM_ENT(EF_MIPS_CPIC, "cpic"), ENUM_ENT(EF_MIPS_ABI2, "abi2"), ENUM_ENT(EF_MIPS_32BITMODE, "32bitmode"), ENUM_ENT(EF_MIPS_FP64, "fp64"), ENUM_ENT(EF_MIPS_NAN2008, "nan2008"), ENUM_ENT(EF_MIPS_ABI_O32, "o32"), ENUM_ENT(EF_MIPS_ABI_O64, "o64"), ENUM_ENT(EF_MIPS_ABI_EABI32, "eabi32"), ENUM_ENT(EF_MIPS_ABI_EABI64, "eabi64"), ENUM_ENT(EF_MIPS_MACH_3900, "3900"), ENUM_ENT(EF_MIPS_MACH_4010, "4010"), ENUM_ENT(EF_MIPS_MACH_4100, "4100"), ENUM_ENT(EF_MIPS_MACH_4650, "4650"), ENUM_ENT(EF_MIPS_MACH_4120, "4120"), ENUM_ENT(EF_MIPS_MACH_4111, "4111"), ENUM_ENT(EF_MIPS_MACH_SB1, "sb1"), ENUM_ENT(EF_MIPS_MACH_OCTEON, "octeon"), ENUM_ENT(EF_MIPS_MACH_XLR, "xlr"), ENUM_ENT(EF_MIPS_MACH_OCTEON2, "octeon2"), ENUM_ENT(EF_MIPS_MACH_OCTEON3, "octeon3"), ENUM_ENT(EF_MIPS_MACH_5400, "5400"), ENUM_ENT(EF_MIPS_MACH_5900, "5900"), ENUM_ENT(EF_MIPS_MACH_5500, "5500"), ENUM_ENT(EF_MIPS_MACH_9000, "9000"), ENUM_ENT(EF_MIPS_MACH_LS2E, "loongson-2e"), ENUM_ENT(EF_MIPS_MACH_LS2F, "loongson-2f"), ENUM_ENT(EF_MIPS_MACH_LS3A, "loongson-3a"), ENUM_ENT(EF_MIPS_MICROMIPS, "micromips"), ENUM_ENT(EF_MIPS_ARCH_ASE_M16, "mips16"), ENUM_ENT(EF_MIPS_ARCH_ASE_MDMX, "mdmx"), ENUM_ENT(EF_MIPS_ARCH_1, "mips1"), ENUM_ENT(EF_MIPS_ARCH_2, "mips2"), ENUM_ENT(EF_MIPS_ARCH_3, "mips3"), ENUM_ENT(EF_MIPS_ARCH_4, "mips4"), ENUM_ENT(EF_MIPS_ARCH_5, "mips5"), ENUM_ENT(EF_MIPS_ARCH_32, "mips32"), ENUM_ENT(EF_MIPS_ARCH_64, "mips64"), ENUM_ENT(EF_MIPS_ARCH_32R2, "mips32r2"), ENUM_ENT(EF_MIPS_ARCH_64R2, "mips64r2"), ENUM_ENT(EF_MIPS_ARCH_32R6, "mips32r6"), ENUM_ENT(EF_MIPS_ARCH_64R6, "mips64r6") }; static const EnumEntry ElfHeaderAMDGPUFlags[] = { LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_NONE), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_R600), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_R630), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RS880), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV670), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV710), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV730), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV770), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CEDAR), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CYPRESS), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_JUNIPER), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_REDWOOD), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_SUMO), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_BARTS), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CAICOS), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CAYMAN), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_TURKS), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX600), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX601), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX700), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX701), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX702), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX703), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX704), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX801), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX802), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX803), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX810), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX900), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX902), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX904), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX906), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX908), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX909), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1010), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1011), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1012), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_XNACK), LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_SRAM_ECC) }; static const EnumEntry ElfHeaderRISCVFlags[] = { ENUM_ENT(EF_RISCV_RVC, "RVC"), ENUM_ENT(EF_RISCV_FLOAT_ABI_SINGLE, "single-float ABI"), ENUM_ENT(EF_RISCV_FLOAT_ABI_DOUBLE, "double-float ABI"), ENUM_ENT(EF_RISCV_FLOAT_ABI_QUAD, "quad-float ABI"), ENUM_ENT(EF_RISCV_RVE, "RVE") }; static const EnumEntry ElfSymOtherFlags[] = { LLVM_READOBJ_ENUM_ENT(ELF, STV_INTERNAL), LLVM_READOBJ_ENUM_ENT(ELF, STV_HIDDEN), LLVM_READOBJ_ENUM_ENT(ELF, STV_PROTECTED) }; static const EnumEntry ElfMipsSymOtherFlags[] = { LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_OPTIONAL), LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PLT), LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PIC), LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_MICROMIPS) }; static const EnumEntry ElfMips16SymOtherFlags[] = { LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_OPTIONAL), LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PLT), LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_MIPS16) }; static const char *getElfMipsOptionsOdkType(unsigned Odk) { switch (Odk) { LLVM_READOBJ_ENUM_CASE(ELF, ODK_NULL); LLVM_READOBJ_ENUM_CASE(ELF, ODK_REGINFO); LLVM_READOBJ_ENUM_CASE(ELF, ODK_EXCEPTIONS); LLVM_READOBJ_ENUM_CASE(ELF, ODK_PAD); LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWPATCH); LLVM_READOBJ_ENUM_CASE(ELF, ODK_FILL); LLVM_READOBJ_ENUM_CASE(ELF, ODK_TAGS); LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWAND); LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWOR); LLVM_READOBJ_ENUM_CASE(ELF, ODK_GP_GROUP); LLVM_READOBJ_ENUM_CASE(ELF, ODK_IDENT); LLVM_READOBJ_ENUM_CASE(ELF, ODK_PAGESIZE); default: return "Unknown"; } } template std::pair ELFDumper::findDynamic(const ELFFile *Obj) { // Try to locate the PT_DYNAMIC header. const Elf_Phdr *DynamicPhdr = nullptr; for (const Elf_Phdr &Phdr : unwrapOrError(ObjF->getFileName(), Obj->program_headers())) { if (Phdr.p_type != ELF::PT_DYNAMIC) continue; DynamicPhdr = &Phdr; break; } // Try to locate the .dynamic section in the sections header table. const Elf_Shdr *DynamicSec = nullptr; for (const Elf_Shdr &Sec : unwrapOrError(ObjF->getFileName(), Obj->sections())) { if (Sec.sh_type != ELF::SHT_DYNAMIC) continue; DynamicSec = &Sec; break; } if (DynamicPhdr && DynamicPhdr->p_offset + DynamicPhdr->p_filesz > ObjF->getMemoryBufferRef().getBufferSize()) { reportWarning( createError( "PT_DYNAMIC segment offset + size exceeds the size of the file"), ObjF->getFileName()); // Don't use the broken dynamic header. DynamicPhdr = nullptr; } if (DynamicPhdr && DynamicSec) { StringRef Name = unwrapOrError(ObjF->getFileName(), Obj->getSectionName(DynamicSec)); if (DynamicSec->sh_addr + DynamicSec->sh_size > DynamicPhdr->p_vaddr + DynamicPhdr->p_memsz || DynamicSec->sh_addr < DynamicPhdr->p_vaddr) reportWarning(createError("The SHT_DYNAMIC section '" + Name + "' is not contained within the " "PT_DYNAMIC segment"), ObjF->getFileName()); if (DynamicSec->sh_addr != DynamicPhdr->p_vaddr) reportWarning(createError("The SHT_DYNAMIC section '" + Name + "' is not at the start of " "PT_DYNAMIC segment"), ObjF->getFileName()); } return std::make_pair(DynamicPhdr, DynamicSec); } template void ELFDumper::loadDynamicTable(const ELFFile *Obj) { const Elf_Phdr *DynamicPhdr; const Elf_Shdr *DynamicSec; std::tie(DynamicPhdr, DynamicSec) = findDynamic(Obj); if (!DynamicPhdr && !DynamicSec) return; DynRegionInfo FromPhdr(ObjF->getFileName()); bool IsPhdrTableValid = false; if (DynamicPhdr) { FromPhdr = createDRIFrom(DynamicPhdr, sizeof(Elf_Dyn)); IsPhdrTableValid = !FromPhdr.getAsArrayRef().empty(); } // Locate the dynamic table described in a section header. // Ignore sh_entsize and use the expected value for entry size explicitly. // This allows us to dump dynamic sections with a broken sh_entsize // field. DynRegionInfo FromSec(ObjF->getFileName()); bool IsSecTableValid = false; if (DynamicSec) { FromSec = checkDRI({ObjF->getELFFile()->base() + DynamicSec->sh_offset, DynamicSec->sh_size, sizeof(Elf_Dyn), ObjF->getFileName()}); IsSecTableValid = !FromSec.getAsArrayRef().empty(); } // When we only have information from one of the SHT_DYNAMIC section header or // PT_DYNAMIC program header, just use that. if (!DynamicPhdr || !DynamicSec) { if ((DynamicPhdr && IsPhdrTableValid) || (DynamicSec && IsSecTableValid)) { DynamicTable = DynamicPhdr ? FromPhdr : FromSec; parseDynamicTable(Obj); } else { reportWarning(createError("no valid dynamic table was found"), ObjF->getFileName()); } return; } // At this point we have tables found from the section header and from the // dynamic segment. Usually they match, but we have to do sanity checks to // verify that. if (FromPhdr.Addr != FromSec.Addr) reportWarning(createError("SHT_DYNAMIC section header and PT_DYNAMIC " "program header disagree about " "the location of the dynamic table"), ObjF->getFileName()); if (!IsPhdrTableValid && !IsSecTableValid) { reportWarning(createError("no valid dynamic table was found"), ObjF->getFileName()); return; } // Information in the PT_DYNAMIC program header has priority over the information // in a section header. if (IsPhdrTableValid) { if (!IsSecTableValid) reportWarning( createError( "SHT_DYNAMIC dynamic table is invalid: PT_DYNAMIC will be used"), ObjF->getFileName()); DynamicTable = FromPhdr; } else { reportWarning( createError( "PT_DYNAMIC dynamic table is invalid: SHT_DYNAMIC will be used"), ObjF->getFileName()); DynamicTable = FromSec; } parseDynamicTable(Obj); } template ELFDumper::ELFDumper(const object::ELFObjectFile *ObjF, ScopedPrinter &Writer) : ObjDumper(Writer), ObjF(ObjF), DynRelRegion(ObjF->getFileName()), DynRelaRegion(ObjF->getFileName()), DynRelrRegion(ObjF->getFileName()), DynPLTRelRegion(ObjF->getFileName()), DynSymRegion(ObjF->getFileName()), DynamicTable(ObjF->getFileName()) { const ELFFile *Obj = ObjF->getELFFile(); for (const Elf_Shdr &Sec : unwrapOrError(ObjF->getFileName(), Obj->sections())) { switch (Sec.sh_type) { case ELF::SHT_SYMTAB: if (!DotSymtabSec) DotSymtabSec = &Sec; break; case ELF::SHT_DYNSYM: if (!DynSymRegion.Size) { DynSymRegion = createDRIFrom(&Sec); // This is only used (if Elf_Shdr present)for naming section in GNU // style DynSymtabName = unwrapOrError(ObjF->getFileName(), Obj->getSectionName(&Sec)); if (Expected E = Obj->getStringTableForSymtab(Sec)) DynamicStringTable = *E; else reportWarning(E.takeError(), ObjF->getFileName()); } break; case ELF::SHT_SYMTAB_SHNDX: ShndxTable = unwrapOrError(ObjF->getFileName(), Obj->getSHNDXTable(Sec)); break; case ELF::SHT_GNU_versym: if (!SymbolVersionSection) SymbolVersionSection = &Sec; break; case ELF::SHT_GNU_verdef: if (!SymbolVersionDefSection) SymbolVersionDefSection = &Sec; break; case ELF::SHT_GNU_verneed: if (!SymbolVersionNeedSection) SymbolVersionNeedSection = &Sec; break; case ELF::SHT_LLVM_CALL_GRAPH_PROFILE: if (!DotCGProfileSec) DotCGProfileSec = &Sec; break; case ELF::SHT_LLVM_ADDRSIG: if (!DotAddrsigSec) DotAddrsigSec = &Sec; break; } } loadDynamicTable(Obj); if (opts::Output == opts::GNU) ELFDumperStyle.reset(new GNUStyle(Writer, this)); else ELFDumperStyle.reset(new LLVMStyle(Writer, this)); } template void ELFDumper::parseDynamicTable(const ELFFile *Obj) { auto toMappedAddr = [&](uint64_t Tag, uint64_t VAddr) -> const uint8_t * { auto MappedAddrOrError = ObjF->getELFFile()->toMappedAddr(VAddr); if (!MappedAddrOrError) { Error Err = createError("Unable to parse DT_" + Obj->getDynamicTagAsString(Tag) + ": " + llvm::toString(MappedAddrOrError.takeError())); reportWarning(std::move(Err), ObjF->getFileName()); return nullptr; } return MappedAddrOrError.get(); }; uint64_t SONameOffset = 0; const char *StringTableBegin = nullptr; uint64_t StringTableSize = 0; for (const Elf_Dyn &Dyn : dynamic_table()) { switch (Dyn.d_tag) { case ELF::DT_HASH: HashTable = reinterpret_cast( toMappedAddr(Dyn.getTag(), Dyn.getPtr())); break; case ELF::DT_GNU_HASH: GnuHashTable = reinterpret_cast( toMappedAddr(Dyn.getTag(), Dyn.getPtr())); break; case ELF::DT_STRTAB: StringTableBegin = reinterpret_cast( toMappedAddr(Dyn.getTag(), Dyn.getPtr())); break; case ELF::DT_STRSZ: StringTableSize = Dyn.getVal(); break; case ELF::DT_SYMTAB: { // Often we find the information about the dynamic symbol table // location in the SHT_DYNSYM section header. However, the value in // DT_SYMTAB has priority, because it is used by dynamic loaders to // locate .dynsym at runtime. The location we find in the section header // and the location we find here should match. If we can't map the // DT_SYMTAB value to an address (e.g. when there are no program headers), we // ignore its value. if (const uint8_t *VA = toMappedAddr(Dyn.getTag(), Dyn.getPtr())) { // EntSize is non-zero if the dynamic symbol table has been found via a // section header. if (DynSymRegion.EntSize && VA != DynSymRegion.Addr) reportWarning( createError( "SHT_DYNSYM section header and DT_SYMTAB disagree about " "the location of the dynamic symbol table"), ObjF->getFileName()); DynSymRegion.Addr = VA; DynSymRegion.EntSize = sizeof(Elf_Sym); } break; } case ELF::DT_RELA: DynRelaRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr()); break; case ELF::DT_RELASZ: DynRelaRegion.Size = Dyn.getVal(); break; case ELF::DT_RELAENT: DynRelaRegion.EntSize = Dyn.getVal(); break; case ELF::DT_SONAME: SONameOffset = Dyn.getVal(); break; case ELF::DT_REL: DynRelRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr()); break; case ELF::DT_RELSZ: DynRelRegion.Size = Dyn.getVal(); break; case ELF::DT_RELENT: DynRelRegion.EntSize = Dyn.getVal(); break; case ELF::DT_RELR: case ELF::DT_ANDROID_RELR: DynRelrRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr()); break; case ELF::DT_RELRSZ: case ELF::DT_ANDROID_RELRSZ: DynRelrRegion.Size = Dyn.getVal(); break; case ELF::DT_RELRENT: case ELF::DT_ANDROID_RELRENT: DynRelrRegion.EntSize = Dyn.getVal(); break; case ELF::DT_PLTREL: if (Dyn.getVal() == DT_REL) DynPLTRelRegion.EntSize = sizeof(Elf_Rel); else if (Dyn.getVal() == DT_RELA) DynPLTRelRegion.EntSize = sizeof(Elf_Rela); else reportError(createError(Twine("unknown DT_PLTREL value of ") + Twine((uint64_t)Dyn.getVal())), ObjF->getFileName()); break; case ELF::DT_JMPREL: DynPLTRelRegion.Addr = toMappedAddr(Dyn.getTag(), Dyn.getPtr()); break; case ELF::DT_PLTRELSZ: DynPLTRelRegion.Size = Dyn.getVal(); break; } } if (StringTableBegin) DynamicStringTable = StringRef(StringTableBegin, StringTableSize); SOName = getDynamicString(SONameOffset); } template typename ELFDumper::Elf_Rel_Range ELFDumper::dyn_rels() const { return DynRelRegion.getAsArrayRef(); } template typename ELFDumper::Elf_Rela_Range ELFDumper::dyn_relas() const { return DynRelaRegion.getAsArrayRef(); } template typename ELFDumper::Elf_Relr_Range ELFDumper::dyn_relrs() const { return DynRelrRegion.getAsArrayRef(); } template void ELFDumper::printFileHeaders() { ELFDumperStyle->printFileHeaders(ObjF->getELFFile()); } template void ELFDumper::printSectionHeaders() { ELFDumperStyle->printSectionHeaders(ObjF->getELFFile()); } template void ELFDumper::printRelocations() { ELFDumperStyle->printRelocations(ObjF->getELFFile()); } template void ELFDumper::printProgramHeaders( bool PrintProgramHeaders, cl::boolOrDefault PrintSectionMapping) { ELFDumperStyle->printProgramHeaders(ObjF->getELFFile(), PrintProgramHeaders, PrintSectionMapping); } template void ELFDumper::printVersionInfo() { // Dump version symbol section. ELFDumperStyle->printVersionSymbolSection(ObjF->getELFFile(), SymbolVersionSection); // Dump version definition section. ELFDumperStyle->printVersionDefinitionSection(ObjF->getELFFile(), SymbolVersionDefSection); // Dump version dependency section. ELFDumperStyle->printVersionDependencySection(ObjF->getELFFile(), SymbolVersionNeedSection); } template void ELFDumper::printDependentLibs() { ELFDumperStyle->printDependentLibs(ObjF->getELFFile()); } template void ELFDumper::printDynamicRelocations() { ELFDumperStyle->printDynamicRelocations(ObjF->getELFFile()); } template void ELFDumper::printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) { ELFDumperStyle->printSymbols(ObjF->getELFFile(), PrintSymbols, PrintDynamicSymbols); } template void ELFDumper::printHashSymbols() { ELFDumperStyle->printHashSymbols(ObjF->getELFFile()); } template void ELFDumper::printHashHistogram() { ELFDumperStyle->printHashHistogram(ObjF->getELFFile()); } template void ELFDumper::printCGProfile() { ELFDumperStyle->printCGProfile(ObjF->getELFFile()); } template void ELFDumper::printNotes() { ELFDumperStyle->printNotes(ObjF->getELFFile()); } template void ELFDumper::printELFLinkerOptions() { ELFDumperStyle->printELFLinkerOptions(ObjF->getELFFile()); } template void ELFDumper::printStackSizes() { ELFDumperStyle->printStackSizes(ObjF); } #define LLVM_READOBJ_DT_FLAG_ENT(prefix, enum) \ { #enum, prefix##_##enum } static const EnumEntry ElfDynamicDTFlags[] = { LLVM_READOBJ_DT_FLAG_ENT(DF, ORIGIN), LLVM_READOBJ_DT_FLAG_ENT(DF, SYMBOLIC), LLVM_READOBJ_DT_FLAG_ENT(DF, TEXTREL), LLVM_READOBJ_DT_FLAG_ENT(DF, BIND_NOW), LLVM_READOBJ_DT_FLAG_ENT(DF, STATIC_TLS) }; static const EnumEntry ElfDynamicDTFlags1[] = { LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOW), LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAL), LLVM_READOBJ_DT_FLAG_ENT(DF_1, GROUP), LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODELETE), LLVM_READOBJ_DT_FLAG_ENT(DF_1, LOADFLTR), LLVM_READOBJ_DT_FLAG_ENT(DF_1, INITFIRST), LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOOPEN), LLVM_READOBJ_DT_FLAG_ENT(DF_1, ORIGIN), LLVM_READOBJ_DT_FLAG_ENT(DF_1, DIRECT), LLVM_READOBJ_DT_FLAG_ENT(DF_1, TRANS), LLVM_READOBJ_DT_FLAG_ENT(DF_1, INTERPOSE), LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODEFLIB), LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODUMP), LLVM_READOBJ_DT_FLAG_ENT(DF_1, CONFALT), LLVM_READOBJ_DT_FLAG_ENT(DF_1, ENDFILTEE), LLVM_READOBJ_DT_FLAG_ENT(DF_1, DISPRELDNE), LLVM_READOBJ_DT_FLAG_ENT(DF_1, DISPRELPND), LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODIRECT), LLVM_READOBJ_DT_FLAG_ENT(DF_1, IGNMULDEF), LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOKSYMS), LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOHDR), LLVM_READOBJ_DT_FLAG_ENT(DF_1, EDITED), LLVM_READOBJ_DT_FLAG_ENT(DF_1, NORELOC), LLVM_READOBJ_DT_FLAG_ENT(DF_1, SYMINTPOSE), LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAUDIT), - LLVM_READOBJ_DT_FLAG_ENT(DF_1, SINGLETON) + LLVM_READOBJ_DT_FLAG_ENT(DF_1, SINGLETON), + LLVM_READOBJ_DT_FLAG_ENT(DF_1, PIE), }; static const EnumEntry ElfDynamicDTMipsFlags[] = { LLVM_READOBJ_DT_FLAG_ENT(RHF, NONE), LLVM_READOBJ_DT_FLAG_ENT(RHF, QUICKSTART), LLVM_READOBJ_DT_FLAG_ENT(RHF, NOTPOT), LLVM_READOBJ_DT_FLAG_ENT(RHS, NO_LIBRARY_REPLACEMENT), LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_MOVE), LLVM_READOBJ_DT_FLAG_ENT(RHF, SGI_ONLY), LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_INIT), LLVM_READOBJ_DT_FLAG_ENT(RHF, DELTA_C_PLUS_PLUS), LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_START_INIT), LLVM_READOBJ_DT_FLAG_ENT(RHF, PIXIE), LLVM_READOBJ_DT_FLAG_ENT(RHF, DEFAULT_DELAY_LOAD), LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTART), LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTARTED), LLVM_READOBJ_DT_FLAG_ENT(RHF, CORD), LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_UNRES_UNDEF), LLVM_READOBJ_DT_FLAG_ENT(RHF, RLD_ORDER_SAFE) }; #undef LLVM_READOBJ_DT_FLAG_ENT template void printFlags(T Value, ArrayRef> Flags, raw_ostream &OS) { using FlagEntry = EnumEntry; using FlagVector = SmallVector; FlagVector SetFlags; for (const auto &Flag : Flags) { if (Flag.Value == 0) continue; if ((Value & Flag.Value) == Flag.Value) SetFlags.push_back(Flag); } for (const auto &Flag : SetFlags) { OS << Flag.Name << " "; } } template void ELFDumper::printDynamicEntry(raw_ostream &OS, uint64_t Type, uint64_t Value) const { const char *ConvChar = (opts::Output == opts::GNU) ? "0x%" PRIx64 : "0x%" PRIX64; // Handle custom printing of architecture specific tags switch (ObjF->getELFFile()->getHeader()->e_machine) { case EM_AARCH64: switch (Type) { case DT_AARCH64_BTI_PLT: case DT_AARCH64_PAC_PLT: OS << Value; return; default: break; } break; case EM_HEXAGON: switch (Type) { case DT_HEXAGON_VER: OS << Value; return; case DT_HEXAGON_SYMSZ: case DT_HEXAGON_PLT: OS << format(ConvChar, Value); return; default: break; } break; case EM_MIPS: switch (Type) { case DT_MIPS_RLD_VERSION: case DT_MIPS_LOCAL_GOTNO: case DT_MIPS_SYMTABNO: case DT_MIPS_UNREFEXTNO: OS << Value; return; case DT_MIPS_TIME_STAMP: case DT_MIPS_ICHECKSUM: case DT_MIPS_IVERSION: case DT_MIPS_BASE_ADDRESS: case DT_MIPS_MSYM: case DT_MIPS_CONFLICT: case DT_MIPS_LIBLIST: case DT_MIPS_CONFLICTNO: case DT_MIPS_LIBLISTNO: case DT_MIPS_GOTSYM: case DT_MIPS_HIPAGENO: case DT_MIPS_RLD_MAP: case DT_MIPS_DELTA_CLASS: case DT_MIPS_DELTA_CLASS_NO: case DT_MIPS_DELTA_INSTANCE: case DT_MIPS_DELTA_RELOC: case DT_MIPS_DELTA_RELOC_NO: case DT_MIPS_DELTA_SYM: case DT_MIPS_DELTA_SYM_NO: case DT_MIPS_DELTA_CLASSSYM: case DT_MIPS_DELTA_CLASSSYM_NO: case DT_MIPS_CXX_FLAGS: case DT_MIPS_PIXIE_INIT: case DT_MIPS_SYMBOL_LIB: case DT_MIPS_LOCALPAGE_GOTIDX: case DT_MIPS_LOCAL_GOTIDX: case DT_MIPS_HIDDEN_GOTIDX: case DT_MIPS_PROTECTED_GOTIDX: case DT_MIPS_OPTIONS: case DT_MIPS_INTERFACE: case DT_MIPS_DYNSTR_ALIGN: case DT_MIPS_INTERFACE_SIZE: case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: case DT_MIPS_PERF_SUFFIX: case DT_MIPS_COMPACT_SIZE: case DT_MIPS_GP_VALUE: case DT_MIPS_AUX_DYNAMIC: case DT_MIPS_PLTGOT: case DT_MIPS_RWPLT: case DT_MIPS_RLD_MAP_REL: OS << format(ConvChar, Value); return; case DT_MIPS_FLAGS: printFlags(Value, makeArrayRef(ElfDynamicDTMipsFlags), OS); return; default: break; } break; default: break; } switch (Type) { case DT_PLTREL: if (Value == DT_REL) { OS << "REL"; break; } else if (Value == DT_RELA) { OS << "RELA"; break; } LLVM_FALLTHROUGH; case DT_PLTGOT: case DT_HASH: case DT_STRTAB: case DT_SYMTAB: case DT_RELA: case DT_INIT: case DT_FINI: case DT_REL: case DT_JMPREL: case DT_INIT_ARRAY: case DT_FINI_ARRAY: case DT_PREINIT_ARRAY: case DT_DEBUG: case DT_VERDEF: case DT_VERNEED: case DT_VERSYM: case DT_GNU_HASH: case DT_NULL: OS << format(ConvChar, Value); break; case DT_RELACOUNT: case DT_RELCOUNT: case DT_VERDEFNUM: case DT_VERNEEDNUM: OS << Value; break; case DT_PLTRELSZ: case DT_RELASZ: case DT_RELAENT: case DT_STRSZ: case DT_SYMENT: case DT_RELSZ: case DT_RELENT: case DT_INIT_ARRAYSZ: case DT_FINI_ARRAYSZ: case DT_PREINIT_ARRAYSZ: case DT_ANDROID_RELSZ: case DT_ANDROID_RELASZ: OS << Value << " (bytes)"; break; case DT_NEEDED: case DT_SONAME: case DT_AUXILIARY: case DT_USED: case DT_FILTER: case DT_RPATH: case DT_RUNPATH: { const std::map TagNames = { {DT_NEEDED, "Shared library"}, {DT_SONAME, "Library soname"}, {DT_AUXILIARY, "Auxiliary library"}, {DT_USED, "Not needed object"}, {DT_FILTER, "Filter library"}, {DT_RPATH, "Library rpath"}, {DT_RUNPATH, "Library runpath"}, }; OS << TagNames.at(Type) << ": [" << getDynamicString(Value) << "]"; break; } case DT_FLAGS: printFlags(Value, makeArrayRef(ElfDynamicDTFlags), OS); break; case DT_FLAGS_1: printFlags(Value, makeArrayRef(ElfDynamicDTFlags1), OS); break; default: OS << format(ConvChar, Value); break; } } template std::string ELFDumper::getDynamicString(uint64_t Value) const { if (DynamicStringTable.empty()) return ""; if (Value < DynamicStringTable.size()) return DynamicStringTable.data() + Value; return Twine("").str(); } template void ELFDumper::printUnwindInfo() { DwarfCFIEH::PrinterContext Ctx(W, ObjF); Ctx.printUnwindInformation(); } namespace { template <> void ELFDumper::printUnwindInfo() { const ELFFile *Obj = ObjF->getELFFile(); const unsigned Machine = Obj->getHeader()->e_machine; if (Machine == EM_ARM) { ARM::EHABI::PrinterContext Ctx(W, Obj, ObjF->getFileName(), DotSymtabSec); Ctx.PrintUnwindInformation(); } DwarfCFIEH::PrinterContext Ctx(W, ObjF); Ctx.printUnwindInformation(); } } // end anonymous namespace template void ELFDumper::printDynamicTable() { ELFDumperStyle->printDynamic(ObjF->getELFFile()); } template void ELFDumper::printNeededLibraries() { ListScope D(W, "NeededLibraries"); std::vector Libs; for (const auto &Entry : dynamic_table()) if (Entry.d_tag == ELF::DT_NEEDED) Libs.push_back(getDynamicString(Entry.d_un.d_val)); llvm::stable_sort(Libs); for (const auto &L : Libs) W.startLine() << L << "\n"; } template void ELFDumper::printHashTable() { DictScope D(W, "HashTable"); if (!HashTable) return; W.printNumber("Num Buckets", HashTable->nbucket); W.printNumber("Num Chains", HashTable->nchain); W.printList("Buckets", HashTable->buckets()); W.printList("Chains", HashTable->chains()); } template void ELFDumper::printGnuHashTable() { DictScope D(W, "GnuHashTable"); if (!GnuHashTable) return; W.printNumber("Num Buckets", GnuHashTable->nbuckets); W.printNumber("First Hashed Symbol Index", GnuHashTable->symndx); W.printNumber("Num Mask Words", GnuHashTable->maskwords); W.printNumber("Shift Count", GnuHashTable->shift2); W.printHexList("Bloom Filter", GnuHashTable->filter()); W.printList("Buckets", GnuHashTable->buckets()); Elf_Sym_Range Syms = dynamic_symbols(); unsigned NumSyms = std::distance(Syms.begin(), Syms.end()); if (!NumSyms) reportError(createError("No dynamic symbol section"), ObjF->getFileName()); W.printHexList("Values", GnuHashTable->values(NumSyms)); } template void ELFDumper::printLoadName() { W.printString("LoadName", SOName); } template void ELFDumper::printArchSpecificInfo() { const ELFFile *Obj = ObjF->getELFFile(); switch (Obj->getHeader()->e_machine) { case EM_ARM: printAttributes(); break; case EM_MIPS: { ELFDumperStyle->printMipsABIFlags(ObjF); printMipsOptions(); printMipsReginfo(); MipsGOTParser Parser(Obj, ObjF->getFileName(), dynamic_table(), dynamic_symbols()); if (Parser.hasGot()) ELFDumperStyle->printMipsGOT(Parser); if (Parser.hasPlt()) ELFDumperStyle->printMipsPLT(Parser); break; } default: break; } } template void ELFDumper::printAttributes() { W.startLine() << "Attributes not implemented.\n"; } namespace { template <> void ELFDumper::printAttributes() { const ELFFile *Obj = ObjF->getELFFile(); if (Obj->getHeader()->e_machine != EM_ARM) { W.startLine() << "Attributes not implemented.\n"; return; } DictScope BA(W, "BuildAttributes"); for (const ELFO::Elf_Shdr &Sec : unwrapOrError(ObjF->getFileName(), Obj->sections())) { if (Sec.sh_type != ELF::SHT_ARM_ATTRIBUTES) continue; ArrayRef Contents = unwrapOrError(ObjF->getFileName(), Obj->getSectionContents(&Sec)); if (Contents[0] != ARMBuildAttrs::Format_Version) { errs() << "unrecognised FormatVersion: 0x" << Twine::utohexstr(Contents[0]) << '\n'; continue; } W.printHex("FormatVersion", Contents[0]); if (Contents.size() == 1) continue; ARMAttributeParser(&W).Parse(Contents, true); } } template class MipsGOTParser { public: TYPEDEF_ELF_TYPES(ELFT) using Entry = typename ELFO::Elf_Addr; using Entries = ArrayRef; const bool IsStatic; const ELFO * const Obj; MipsGOTParser(const ELFO *Obj, StringRef FileName, Elf_Dyn_Range DynTable, Elf_Sym_Range DynSyms); bool hasGot() const { return !GotEntries.empty(); } bool hasPlt() const { return !PltEntries.empty(); } uint64_t getGp() const; const Entry *getGotLazyResolver() const; const Entry *getGotModulePointer() const; const Entry *getPltLazyResolver() const; const Entry *getPltModulePointer() const; Entries getLocalEntries() const; Entries getGlobalEntries() const; Entries getOtherEntries() const; Entries getPltEntries() const; uint64_t getGotAddress(const Entry * E) const; int64_t getGotOffset(const Entry * E) const; const Elf_Sym *getGotSym(const Entry *E) const; uint64_t getPltAddress(const Entry * E) const; const Elf_Sym *getPltSym(const Entry *E) const; StringRef getPltStrTable() const { return PltStrTable; } private: const Elf_Shdr *GotSec; size_t LocalNum; size_t GlobalNum; const Elf_Shdr *PltSec; const Elf_Shdr *PltRelSec; const Elf_Shdr *PltSymTable; StringRef FileName; Elf_Sym_Range GotDynSyms; StringRef PltStrTable; Entries GotEntries; Entries PltEntries; }; } // end anonymous namespace template MipsGOTParser::MipsGOTParser(const ELFO *Obj, StringRef FileName, Elf_Dyn_Range DynTable, Elf_Sym_Range DynSyms) : IsStatic(DynTable.empty()), Obj(Obj), GotSec(nullptr), LocalNum(0), GlobalNum(0), PltSec(nullptr), PltRelSec(nullptr), PltSymTable(nullptr), FileName(FileName) { // See "Global Offset Table" in Chapter 5 in the following document // for detailed GOT description. // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf // Find static GOT secton. if (IsStatic) { GotSec = findSectionByName(*Obj, FileName, ".got"); if (!GotSec) return; ArrayRef Content = unwrapOrError(FileName, Obj->getSectionContents(GotSec)); GotEntries = Entries(reinterpret_cast(Content.data()), Content.size() / sizeof(Entry)); LocalNum = GotEntries.size(); return; } // Lookup dynamic table tags which define GOT/PLT layouts. Optional DtPltGot; Optional DtLocalGotNum; Optional DtGotSym; Optional DtMipsPltGot; Optional DtJmpRel; for (const auto &Entry : DynTable) { switch (Entry.getTag()) { case ELF::DT_PLTGOT: DtPltGot = Entry.getVal(); break; case ELF::DT_MIPS_LOCAL_GOTNO: DtLocalGotNum = Entry.getVal(); break; case ELF::DT_MIPS_GOTSYM: DtGotSym = Entry.getVal(); break; case ELF::DT_MIPS_PLTGOT: DtMipsPltGot = Entry.getVal(); break; case ELF::DT_JMPREL: DtJmpRel = Entry.getVal(); break; } } // Find dynamic GOT section. if (DtPltGot || DtLocalGotNum || DtGotSym) { if (!DtPltGot) report_fatal_error("Cannot find PLTGOT dynamic table tag."); if (!DtLocalGotNum) report_fatal_error("Cannot find MIPS_LOCAL_GOTNO dynamic table tag."); if (!DtGotSym) report_fatal_error("Cannot find MIPS_GOTSYM dynamic table tag."); size_t DynSymTotal = DynSyms.size(); if (*DtGotSym > DynSymTotal) reportError( createError("MIPS_GOTSYM exceeds a number of dynamic symbols"), FileName); GotSec = findNotEmptySectionByAddress(Obj, FileName, *DtPltGot); if (!GotSec) reportError(createError("There is no not empty GOT section at 0x" + Twine::utohexstr(*DtPltGot)), FileName); LocalNum = *DtLocalGotNum; GlobalNum = DynSymTotal - *DtGotSym; ArrayRef Content = unwrapOrError(FileName, Obj->getSectionContents(GotSec)); GotEntries = Entries(reinterpret_cast(Content.data()), Content.size() / sizeof(Entry)); GotDynSyms = DynSyms.drop_front(*DtGotSym); } // Find PLT section. if (DtMipsPltGot || DtJmpRel) { if (!DtMipsPltGot) report_fatal_error("Cannot find MIPS_PLTGOT dynamic table tag."); if (!DtJmpRel) report_fatal_error("Cannot find JMPREL dynamic table tag."); PltSec = findNotEmptySectionByAddress(Obj, FileName, * DtMipsPltGot); if (!PltSec) report_fatal_error("There is no not empty PLTGOT section at 0x " + Twine::utohexstr(*DtMipsPltGot)); PltRelSec = findNotEmptySectionByAddress(Obj, FileName, * DtJmpRel); if (!PltRelSec) report_fatal_error("There is no not empty RELPLT section at 0x" + Twine::utohexstr(*DtJmpRel)); ArrayRef PltContent = unwrapOrError(FileName, Obj->getSectionContents(PltSec)); PltEntries = Entries(reinterpret_cast(PltContent.data()), PltContent.size() / sizeof(Entry)); PltSymTable = unwrapOrError(FileName, Obj->getSection(PltRelSec->sh_link)); PltStrTable = unwrapOrError(FileName, Obj->getStringTableForSymtab(*PltSymTable)); } } template uint64_t MipsGOTParser::getGp() const { return GotSec->sh_addr + 0x7ff0; } template const typename MipsGOTParser::Entry * MipsGOTParser::getGotLazyResolver() const { return LocalNum > 0 ? &GotEntries[0] : nullptr; } template const typename MipsGOTParser::Entry * MipsGOTParser::getGotModulePointer() const { if (LocalNum < 2) return nullptr; const Entry &E = GotEntries[1]; if ((E >> (sizeof(Entry) * 8 - 1)) == 0) return nullptr; return &E; } template typename MipsGOTParser::Entries MipsGOTParser::getLocalEntries() const { size_t Skip = getGotModulePointer() ? 2 : 1; if (LocalNum - Skip <= 0) return Entries(); return GotEntries.slice(Skip, LocalNum - Skip); } template typename MipsGOTParser::Entries MipsGOTParser::getGlobalEntries() const { if (GlobalNum == 0) return Entries(); return GotEntries.slice(LocalNum, GlobalNum); } template typename MipsGOTParser::Entries MipsGOTParser::getOtherEntries() const { size_t OtherNum = GotEntries.size() - LocalNum - GlobalNum; if (OtherNum == 0) return Entries(); return GotEntries.slice(LocalNum + GlobalNum, OtherNum); } template uint64_t MipsGOTParser::getGotAddress(const Entry *E) const { int64_t Offset = std::distance(GotEntries.data(), E) * sizeof(Entry); return GotSec->sh_addr + Offset; } template int64_t MipsGOTParser::getGotOffset(const Entry *E) const { int64_t Offset = std::distance(GotEntries.data(), E) * sizeof(Entry); return Offset - 0x7ff0; } template const typename MipsGOTParser::Elf_Sym * MipsGOTParser::getGotSym(const Entry *E) const { int64_t Offset = std::distance(GotEntries.data(), E); return &GotDynSyms[Offset - LocalNum]; } template const typename MipsGOTParser::Entry * MipsGOTParser::getPltLazyResolver() const { return PltEntries.empty() ? nullptr : &PltEntries[0]; } template const typename MipsGOTParser::Entry * MipsGOTParser::getPltModulePointer() const { return PltEntries.size() < 2 ? nullptr : &PltEntries[1]; } template typename MipsGOTParser::Entries MipsGOTParser::getPltEntries() const { if (PltEntries.size() <= 2) return Entries(); return PltEntries.slice(2, PltEntries.size() - 2); } template uint64_t MipsGOTParser::getPltAddress(const Entry *E) const { int64_t Offset = std::distance(PltEntries.data(), E) * sizeof(Entry); return PltSec->sh_addr + Offset; } template const typename MipsGOTParser::Elf_Sym * MipsGOTParser::getPltSym(const Entry *E) const { int64_t Offset = std::distance(getPltEntries().data(), E); if (PltRelSec->sh_type == ELF::SHT_REL) { Elf_Rel_Range Rels = unwrapOrError(FileName, Obj->rels(PltRelSec)); return unwrapOrError(FileName, Obj->getRelocationSymbol(&Rels[Offset], PltSymTable)); } else { Elf_Rela_Range Rels = unwrapOrError(FileName, Obj->relas(PltRelSec)); return unwrapOrError(FileName, Obj->getRelocationSymbol(&Rels[Offset], PltSymTable)); } } static const EnumEntry ElfMipsISAExtType[] = { {"None", Mips::AFL_EXT_NONE}, {"Broadcom SB-1", Mips::AFL_EXT_SB1}, {"Cavium Networks Octeon", Mips::AFL_EXT_OCTEON}, {"Cavium Networks Octeon2", Mips::AFL_EXT_OCTEON2}, {"Cavium Networks OcteonP", Mips::AFL_EXT_OCTEONP}, {"Cavium Networks Octeon3", Mips::AFL_EXT_OCTEON3}, {"LSI R4010", Mips::AFL_EXT_4010}, {"Loongson 2E", Mips::AFL_EXT_LOONGSON_2E}, {"Loongson 2F", Mips::AFL_EXT_LOONGSON_2F}, {"Loongson 3A", Mips::AFL_EXT_LOONGSON_3A}, {"MIPS R4650", Mips::AFL_EXT_4650}, {"MIPS R5900", Mips::AFL_EXT_5900}, {"MIPS R10000", Mips::AFL_EXT_10000}, {"NEC VR4100", Mips::AFL_EXT_4100}, {"NEC VR4111/VR4181", Mips::AFL_EXT_4111}, {"NEC VR4120", Mips::AFL_EXT_4120}, {"NEC VR5400", Mips::AFL_EXT_5400}, {"NEC VR5500", Mips::AFL_EXT_5500}, {"RMI Xlr", Mips::AFL_EXT_XLR}, {"Toshiba R3900", Mips::AFL_EXT_3900} }; static const EnumEntry ElfMipsASEFlags[] = { {"DSP", Mips::AFL_ASE_DSP}, {"DSPR2", Mips::AFL_ASE_DSPR2}, {"Enhanced VA Scheme", Mips::AFL_ASE_EVA}, {"MCU", Mips::AFL_ASE_MCU}, {"MDMX", Mips::AFL_ASE_MDMX}, {"MIPS-3D", Mips::AFL_ASE_MIPS3D}, {"MT", Mips::AFL_ASE_MT}, {"SmartMIPS", Mips::AFL_ASE_SMARTMIPS}, {"VZ", Mips::AFL_ASE_VIRT}, {"MSA", Mips::AFL_ASE_MSA}, {"MIPS16", Mips::AFL_ASE_MIPS16}, {"microMIPS", Mips::AFL_ASE_MICROMIPS}, {"XPA", Mips::AFL_ASE_XPA}, {"CRC", Mips::AFL_ASE_CRC}, {"GINV", Mips::AFL_ASE_GINV}, }; static const EnumEntry ElfMipsFpABIType[] = { {"Hard or soft float", Mips::Val_GNU_MIPS_ABI_FP_ANY}, {"Hard float (double precision)", Mips::Val_GNU_MIPS_ABI_FP_DOUBLE}, {"Hard float (single precision)", Mips::Val_GNU_MIPS_ABI_FP_SINGLE}, {"Soft float", Mips::Val_GNU_MIPS_ABI_FP_SOFT}, {"Hard float (MIPS32r2 64-bit FPU 12 callee-saved)", Mips::Val_GNU_MIPS_ABI_FP_OLD_64}, {"Hard float (32-bit CPU, Any FPU)", Mips::Val_GNU_MIPS_ABI_FP_XX}, {"Hard float (32-bit CPU, 64-bit FPU)", Mips::Val_GNU_MIPS_ABI_FP_64}, {"Hard float compat (32-bit CPU, 64-bit FPU)", Mips::Val_GNU_MIPS_ABI_FP_64A} }; static const EnumEntry ElfMipsFlags1[] { {"ODDSPREG", Mips::AFL_FLAGS1_ODDSPREG}, }; static int getMipsRegisterSize(uint8_t Flag) { switch (Flag) { case Mips::AFL_REG_NONE: return 0; case Mips::AFL_REG_32: return 32; case Mips::AFL_REG_64: return 64; case Mips::AFL_REG_128: return 128; default: return -1; } } template static void printMipsReginfoData(ScopedPrinter &W, const Elf_Mips_RegInfo &Reginfo) { W.printHex("GP", Reginfo.ri_gp_value); W.printHex("General Mask", Reginfo.ri_gprmask); W.printHex("Co-Proc Mask0", Reginfo.ri_cprmask[0]); W.printHex("Co-Proc Mask1", Reginfo.ri_cprmask[1]); W.printHex("Co-Proc Mask2", Reginfo.ri_cprmask[2]); W.printHex("Co-Proc Mask3", Reginfo.ri_cprmask[3]); } template void ELFDumper::printMipsReginfo() { const ELFFile *Obj = ObjF->getELFFile(); const Elf_Shdr *Shdr = findSectionByName(*Obj, ObjF->getFileName(), ".reginfo"); if (!Shdr) { W.startLine() << "There is no .reginfo section in the file.\n"; return; } ArrayRef Sec = unwrapOrError(ObjF->getFileName(), Obj->getSectionContents(Shdr)); if (Sec.size() != sizeof(Elf_Mips_RegInfo)) { W.startLine() << "The .reginfo section has a wrong size.\n"; return; } DictScope GS(W, "MIPS RegInfo"); auto *Reginfo = reinterpret_cast *>(Sec.data()); printMipsReginfoData(W, *Reginfo); } template void ELFDumper::printMipsOptions() { const ELFFile *Obj = ObjF->getELFFile(); const Elf_Shdr *Shdr = findSectionByName(*Obj, ObjF->getFileName(), ".MIPS.options"); if (!Shdr) { W.startLine() << "There is no .MIPS.options section in the file.\n"; return; } DictScope GS(W, "MIPS Options"); ArrayRef Sec = unwrapOrError(ObjF->getFileName(), Obj->getSectionContents(Shdr)); while (!Sec.empty()) { if (Sec.size() < sizeof(Elf_Mips_Options)) { W.startLine() << "The .MIPS.options section has a wrong size.\n"; return; } auto *O = reinterpret_cast *>(Sec.data()); DictScope GS(W, getElfMipsOptionsOdkType(O->kind)); switch (O->kind) { case ODK_REGINFO: printMipsReginfoData(W, O->getRegInfo()); break; default: W.startLine() << "Unsupported MIPS options tag.\n"; break; } Sec = Sec.slice(O->size); } } template void ELFDumper::printStackMap() const { const ELFFile *Obj = ObjF->getELFFile(); const Elf_Shdr *StackMapSection = nullptr; for (const auto &Sec : unwrapOrError(ObjF->getFileName(), Obj->sections())) { StringRef Name = unwrapOrError(ObjF->getFileName(), Obj->getSectionName(&Sec)); if (Name == ".llvm_stackmaps") { StackMapSection = &Sec; break; } } if (!StackMapSection) return; ArrayRef StackMapContentsArray = unwrapOrError( ObjF->getFileName(), Obj->getSectionContents(StackMapSection)); prettyPrintStackMap( W, StackMapParser(StackMapContentsArray)); } template void ELFDumper::printGroupSections() { ELFDumperStyle->printGroupSections(ObjF->getELFFile()); } template void ELFDumper::printAddrsig() { ELFDumperStyle->printAddrsig(ObjF->getELFFile()); } static inline void printFields(formatted_raw_ostream &OS, StringRef Str1, StringRef Str2) { OS.PadToColumn(2u); OS << Str1; OS.PadToColumn(37u); OS << Str2 << "\n"; OS.flush(); } template static std::string getSectionHeadersNumString(const ELFFile *Obj, StringRef FileName) { const typename ELFT::Ehdr *ElfHeader = Obj->getHeader(); if (ElfHeader->e_shnum != 0) return to_string(ElfHeader->e_shnum); ArrayRef Arr = unwrapOrError(FileName, Obj->sections()); if (Arr.empty()) return "0"; return "0 (" + to_string(Arr[0].sh_size) + ")"; } template static std::string getSectionHeaderTableIndexString(const ELFFile *Obj, StringRef FileName) { const typename ELFT::Ehdr *ElfHeader = Obj->getHeader(); if (ElfHeader->e_shstrndx != SHN_XINDEX) return to_string(ElfHeader->e_shstrndx); ArrayRef Arr = unwrapOrError(FileName, Obj->sections()); if (Arr.empty()) return "65535 (corrupt: out of range)"; return to_string(ElfHeader->e_shstrndx) + " (" + to_string(Arr[0].sh_link) + ")"; } template void GNUStyle::printFileHeaders(const ELFO *Obj) { const Elf_Ehdr *e = Obj->getHeader(); OS << "ELF Header:\n"; OS << " Magic: "; std::string Str; for (int i = 0; i < ELF::EI_NIDENT; i++) OS << format(" %02x", static_cast(e->e_ident[i])); OS << "\n"; Str = printEnum(e->e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass)); printFields(OS, "Class:", Str); Str = printEnum(e->e_ident[ELF::EI_DATA], makeArrayRef(ElfDataEncoding)); printFields(OS, "Data:", Str); OS.PadToColumn(2u); OS << "Version:"; OS.PadToColumn(37u); OS << to_hexString(e->e_ident[ELF::EI_VERSION]); if (e->e_version == ELF::EV_CURRENT) OS << " (current)"; OS << "\n"; Str = printEnum(e->e_ident[ELF::EI_OSABI], makeArrayRef(ElfOSABI)); printFields(OS, "OS/ABI:", Str); printFields(OS, "ABI Version:", std::to_string(e->e_ident[ELF::EI_ABIVERSION])); Str = printEnum(e->e_type, makeArrayRef(ElfObjectFileType)); printFields(OS, "Type:", Str); Str = printEnum(e->e_machine, makeArrayRef(ElfMachineType)); printFields(OS, "Machine:", Str); Str = "0x" + to_hexString(e->e_version); printFields(OS, "Version:", Str); Str = "0x" + to_hexString(e->e_entry); printFields(OS, "Entry point address:", Str); Str = to_string(e->e_phoff) + " (bytes into file)"; printFields(OS, "Start of program headers:", Str); Str = to_string(e->e_shoff) + " (bytes into file)"; printFields(OS, "Start of section headers:", Str); std::string ElfFlags; if (e->e_machine == EM_MIPS) ElfFlags = printFlags(e->e_flags, makeArrayRef(ElfHeaderMipsFlags), unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI), unsigned(ELF::EF_MIPS_MACH)); else if (e->e_machine == EM_RISCV) ElfFlags = printFlags(e->e_flags, makeArrayRef(ElfHeaderRISCVFlags)); Str = "0x" + to_hexString(e->e_flags); if (!ElfFlags.empty()) Str = Str + ", " + ElfFlags; printFields(OS, "Flags:", Str); Str = to_string(e->e_ehsize) + " (bytes)"; printFields(OS, "Size of this header:", Str); Str = to_string(e->e_phentsize) + " (bytes)"; printFields(OS, "Size of program headers:", Str); Str = to_string(e->e_phnum); printFields(OS, "Number of program headers:", Str); Str = to_string(e->e_shentsize) + " (bytes)"; printFields(OS, "Size of section headers:", Str); Str = getSectionHeadersNumString(Obj, this->FileName); printFields(OS, "Number of section headers:", Str); Str = getSectionHeaderTableIndexString(Obj, this->FileName); printFields(OS, "Section header string table index:", Str); } namespace { struct GroupMember { StringRef Name; uint64_t Index; }; struct GroupSection { StringRef Name; std::string Signature; uint64_t ShName; uint64_t Index; uint32_t Link; uint32_t Info; uint32_t Type; std::vector Members; }; template std::vector getGroups(const ELFFile *Obj, StringRef FileName) { using Elf_Shdr = typename ELFT::Shdr; using Elf_Sym = typename ELFT::Sym; using Elf_Word = typename ELFT::Word; std::vector Ret; uint64_t I = 0; for (const Elf_Shdr &Sec : unwrapOrError(FileName, Obj->sections())) { ++I; if (Sec.sh_type != ELF::SHT_GROUP) continue; const Elf_Shdr *Symtab = unwrapOrError(FileName, Obj->getSection(Sec.sh_link)); StringRef StrTable = unwrapOrError(FileName, Obj->getStringTableForSymtab(*Symtab)); const Elf_Sym *Sym = unwrapOrError( FileName, Obj->template getEntry(Symtab, Sec.sh_info)); auto Data = unwrapOrError( FileName, Obj->template getSectionContentsAsArray(&Sec)); StringRef Name = unwrapOrError(FileName, Obj->getSectionName(&Sec)); StringRef Signature = StrTable.data() + Sym->st_name; Ret.push_back({Name, maybeDemangle(Signature), Sec.sh_name, I - 1, Sec.sh_link, Sec.sh_info, Data[0], {}}); std::vector &GM = Ret.back().Members; for (uint32_t Ndx : Data.slice(1)) { auto Sec = unwrapOrError(FileName, Obj->getSection(Ndx)); const StringRef Name = unwrapOrError(FileName, Obj->getSectionName(Sec)); GM.push_back({Name, Ndx}); } } return Ret; } DenseMap mapSectionsToGroups(ArrayRef Groups) { DenseMap Ret; for (const GroupSection &G : Groups) for (const GroupMember &GM : G.Members) Ret.insert({GM.Index, &G}); return Ret; } } // namespace template void GNUStyle::printGroupSections(const ELFO *Obj) { std::vector V = getGroups(Obj, this->FileName); DenseMap Map = mapSectionsToGroups(V); for (const GroupSection &G : V) { OS << "\n" << getGroupType(G.Type) << " group section [" << format_decimal(G.Index, 5) << "] `" << G.Name << "' [" << G.Signature << "] contains " << G.Members.size() << " sections:\n" << " [Index] Name\n"; for (const GroupMember &GM : G.Members) { const GroupSection *MainGroup = Map[GM.Index]; if (MainGroup != &G) { OS.flush(); errs() << "Error: section [" << format_decimal(GM.Index, 5) << "] in group section [" << format_decimal(G.Index, 5) << "] already in group section [" << format_decimal(MainGroup->Index, 5) << "]"; errs().flush(); continue; } OS << " [" << format_decimal(GM.Index, 5) << "] " << GM.Name << "\n"; } } if (V.empty()) OS << "There are no section groups in this file.\n"; } template void GNUStyle::printRelocation(const ELFO *Obj, const Elf_Shdr *SymTab, const Elf_Rela &R, bool IsRela) { const Elf_Sym *Sym = unwrapOrError(this->FileName, Obj->getRelocationSymbol(&R, SymTab)); std::string TargetName; if (Sym && Sym->getType() == ELF::STT_SECTION) { const Elf_Shdr *Sec = unwrapOrError( this->FileName, Obj->getSection(Sym, SymTab, this->dumper()->getShndxTable())); TargetName = unwrapOrError(this->FileName, Obj->getSectionName(Sec)); } else if (Sym) { StringRef StrTable = unwrapOrError(this->FileName, Obj->getStringTableForSymtab(*SymTab)); TargetName = this->dumper()->getFullSymbolName( Sym, StrTable, SymTab->sh_type == SHT_DYNSYM /* IsDynamic */); } printRelocation(Obj, Sym, TargetName, R, IsRela); } template void GNUStyle::printRelocation(const ELFO *Obj, const Elf_Sym *Sym, StringRef SymbolName, const Elf_Rela &R, bool IsRela) { // First two fields are bit width dependent. The rest of them are fixed width. unsigned Bias = ELFT::Is64Bits ? 8 : 0; Field Fields[5] = {0, 10 + Bias, 19 + 2 * Bias, 42 + 2 * Bias, 53 + 2 * Bias}; unsigned Width = ELFT::Is64Bits ? 16 : 8; Fields[0].Str = to_string(format_hex_no_prefix(R.r_offset, Width)); Fields[1].Str = to_string(format_hex_no_prefix(R.r_info, Width)); SmallString<32> RelocName; Obj->getRelocationTypeName(R.getType(Obj->isMips64EL()), RelocName); Fields[2].Str = RelocName.c_str(); if (Sym && (!SymbolName.empty() || Sym->getValue() != 0)) Fields[3].Str = to_string(format_hex_no_prefix(Sym->getValue(), Width)); Fields[4].Str = SymbolName; for (const Field &F : Fields) printField(F); std::string Addend; if (IsRela) { int64_t RelAddend = R.r_addend; if (!SymbolName.empty()) { if (R.r_addend < 0) { Addend = " - "; RelAddend = std::abs(RelAddend); } else Addend = " + "; } Addend += to_hexString(RelAddend, false); } OS << Addend << "\n"; } template void GNUStyle::printRelocHeader(unsigned SType) { bool IsRela = SType == ELF::SHT_RELA || SType == ELF::SHT_ANDROID_RELA; bool IsRelr = SType == ELF::SHT_RELR || SType == ELF::SHT_ANDROID_RELR; if (ELFT::Is64Bits) OS << " "; else OS << " "; if (IsRelr && opts::RawRelr) OS << "Data "; else OS << "Offset"; if (ELFT::Is64Bits) OS << " Info Type" << " Symbol's Value Symbol's Name"; else OS << " Info Type Sym. Value Symbol's Name"; if (IsRela) OS << " + Addend"; OS << "\n"; } template void GNUStyle::printRelocations(const ELFO *Obj) { bool HasRelocSections = false; for (const Elf_Shdr &Sec : unwrapOrError(this->FileName, Obj->sections())) { if (Sec.sh_type != ELF::SHT_REL && Sec.sh_type != ELF::SHT_RELA && Sec.sh_type != ELF::SHT_RELR && Sec.sh_type != ELF::SHT_ANDROID_REL && Sec.sh_type != ELF::SHT_ANDROID_RELA && Sec.sh_type != ELF::SHT_ANDROID_RELR) continue; HasRelocSections = true; StringRef Name = unwrapOrError(this->FileName, Obj->getSectionName(&Sec)); unsigned Entries = Sec.getEntityCount(); std::vector AndroidRelas; if (Sec.sh_type == ELF::SHT_ANDROID_REL || Sec.sh_type == ELF::SHT_ANDROID_RELA) { // Android's packed relocation section needs to be unpacked first // to get the actual number of entries. AndroidRelas = unwrapOrError(this->FileName, Obj->android_relas(&Sec)); Entries = AndroidRelas.size(); } std::vector RelrRelas; if (!opts::RawRelr && (Sec.sh_type == ELF::SHT_RELR || Sec.sh_type == ELF::SHT_ANDROID_RELR)) { // .relr.dyn relative relocation section needs to be unpacked first // to get the actual number of entries. Elf_Relr_Range Relrs = unwrapOrError(this->FileName, Obj->relrs(&Sec)); RelrRelas = unwrapOrError(this->FileName, Obj->decode_relrs(Relrs)); Entries = RelrRelas.size(); } uintX_t Offset = Sec.sh_offset; OS << "\nRelocation section '" << Name << "' at offset 0x" << to_hexString(Offset, false) << " contains " << Entries << " entries:\n"; printRelocHeader(Sec.sh_type); const Elf_Shdr *SymTab = unwrapOrError(this->FileName, Obj->getSection(Sec.sh_link)); switch (Sec.sh_type) { case ELF::SHT_REL: for (const auto &R : unwrapOrError(this->FileName, Obj->rels(&Sec))) { Elf_Rela Rela; Rela.r_offset = R.r_offset; Rela.r_info = R.r_info; Rela.r_addend = 0; printRelocation(Obj, SymTab, Rela, false); } break; case ELF::SHT_RELA: for (const auto &R : unwrapOrError(this->FileName, Obj->relas(&Sec))) printRelocation(Obj, SymTab, R, true); break; case ELF::SHT_RELR: case ELF::SHT_ANDROID_RELR: if (opts::RawRelr) for (const auto &R : unwrapOrError(this->FileName, Obj->relrs(&Sec))) OS << to_string(format_hex_no_prefix(R, ELFT::Is64Bits ? 16 : 8)) << "\n"; else for (const auto &R : RelrRelas) printRelocation(Obj, SymTab, R, false); break; case ELF::SHT_ANDROID_REL: case ELF::SHT_ANDROID_RELA: for (const auto &R : AndroidRelas) printRelocation(Obj, SymTab, R, Sec.sh_type == ELF::SHT_ANDROID_RELA); break; } } if (!HasRelocSections) OS << "\nThere are no relocations in this file.\n"; } // Print the offset of a particular section from anyone of the ranges: // [SHT_LOOS, SHT_HIOS], [SHT_LOPROC, SHT_HIPROC], [SHT_LOUSER, SHT_HIUSER]. // If 'Type' does not fall within any of those ranges, then a string is // returned as '' followed by the type value. static std::string getSectionTypeOffsetString(unsigned Type) { if (Type >= SHT_LOOS && Type <= SHT_HIOS) return "LOOS+0x" + to_hexString(Type - SHT_LOOS); else if (Type >= SHT_LOPROC && Type <= SHT_HIPROC) return "LOPROC+0x" + to_hexString(Type - SHT_LOPROC); else if (Type >= SHT_LOUSER && Type <= SHT_HIUSER) return "LOUSER+0x" + to_hexString(Type - SHT_LOUSER); return "0x" + to_hexString(Type) + ": "; } static std::string getSectionTypeString(unsigned Arch, unsigned Type) { using namespace ELF; switch (Arch) { case EM_ARM: switch (Type) { case SHT_ARM_EXIDX: return "ARM_EXIDX"; case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP"; case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES"; case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY"; case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION"; } break; case EM_X86_64: switch (Type) { case SHT_X86_64_UNWIND: return "X86_64_UNWIND"; } break; case EM_MIPS: case EM_MIPS_RS3_LE: switch (Type) { case SHT_MIPS_REGINFO: return "MIPS_REGINFO"; case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS"; case SHT_MIPS_DWARF: return "MIPS_DWARF"; case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS"; } break; } switch (Type) { case SHT_NULL: return "NULL"; case SHT_PROGBITS: return "PROGBITS"; case SHT_SYMTAB: return "SYMTAB"; case SHT_STRTAB: return "STRTAB"; case SHT_RELA: return "RELA"; case SHT_HASH: return "HASH"; case SHT_DYNAMIC: return "DYNAMIC"; case SHT_NOTE: return "NOTE"; case SHT_NOBITS: return "NOBITS"; case SHT_REL: return "REL"; case SHT_SHLIB: return "SHLIB"; case SHT_DYNSYM: return "DYNSYM"; case SHT_INIT_ARRAY: return "INIT_ARRAY"; case SHT_FINI_ARRAY: return "FINI_ARRAY"; case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY"; case SHT_GROUP: return "GROUP"; case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICES"; case SHT_ANDROID_REL: return "ANDROID_REL"; case SHT_ANDROID_RELA: return "ANDROID_RELA"; case SHT_RELR: case SHT_ANDROID_RELR: return "RELR"; case SHT_LLVM_ODRTAB: return "LLVM_ODRTAB"; case SHT_LLVM_LINKER_OPTIONS: return "LLVM_LINKER_OPTIONS"; case SHT_LLVM_CALL_GRAPH_PROFILE: return "LLVM_CALL_GRAPH_PROFILE"; case SHT_LLVM_ADDRSIG: return "LLVM_ADDRSIG"; case SHT_LLVM_DEPENDENT_LIBRARIES: return "LLVM_DEPENDENT_LIBRARIES"; case SHT_LLVM_SYMPART: return "LLVM_SYMPART"; case SHT_LLVM_PART_EHDR: return "LLVM_PART_EHDR"; case SHT_LLVM_PART_PHDR: return "LLVM_PART_PHDR"; // FIXME: Parse processor specific GNU attributes case SHT_GNU_ATTRIBUTES: return "ATTRIBUTES"; case SHT_GNU_HASH: return "GNU_HASH"; case SHT_GNU_verdef: return "VERDEF"; case SHT_GNU_verneed: return "VERNEED"; case SHT_GNU_versym: return "VERSYM"; default: return getSectionTypeOffsetString(Type); } return ""; } static void printSectionDescription(formatted_raw_ostream &OS, unsigned EMachine) { OS << "Key to Flags:\n"; OS << " W (write), A (alloc), X (execute), M (merge), S (strings), I " "(info),\n"; OS << " L (link order), O (extra OS processing required), G (group), T " "(TLS),\n"; OS << " C (compressed), x (unknown), o (OS specific), E (exclude),\n"; if (EMachine == EM_X86_64) OS << " l (large), "; else if (EMachine == EM_ARM) OS << " y (purecode), "; else OS << " "; OS << "p (processor specific)\n"; } template void GNUStyle::printSectionHeaders(const ELFO *Obj) { unsigned Bias = ELFT::Is64Bits ? 0 : 8; ArrayRef Sections = unwrapOrError(this->FileName, Obj->sections()); OS << "There are " << to_string(Sections.size()) << " section headers, starting at offset " << "0x" << to_hexString(Obj->getHeader()->e_shoff, false) << ":\n\n"; OS << "Section Headers:\n"; Field Fields[11] = { {"[Nr]", 2}, {"Name", 7}, {"Type", 25}, {"Address", 41}, {"Off", 58 - Bias}, {"Size", 65 - Bias}, {"ES", 72 - Bias}, {"Flg", 75 - Bias}, {"Lk", 79 - Bias}, {"Inf", 82 - Bias}, {"Al", 86 - Bias}}; for (auto &F : Fields) printField(F); OS << "\n"; const ELFObjectFile *ElfObj = this->dumper()->getElfObject(); size_t SectionIndex = 0; for (const Elf_Shdr &Sec : Sections) { Fields[0].Str = to_string(SectionIndex); Fields[1].Str = unwrapOrError( ElfObj->getFileName(), Obj->getSectionName(&Sec, this->WarningHandler)); Fields[2].Str = getSectionTypeString(Obj->getHeader()->e_machine, Sec.sh_type); Fields[3].Str = to_string(format_hex_no_prefix(Sec.sh_addr, ELFT::Is64Bits ? 16 : 8)); Fields[4].Str = to_string(format_hex_no_prefix(Sec.sh_offset, 6)); Fields[5].Str = to_string(format_hex_no_prefix(Sec.sh_size, 6)); Fields[6].Str = to_string(format_hex_no_prefix(Sec.sh_entsize, 2)); Fields[7].Str = getGNUFlags(Obj->getHeader()->e_machine, Sec.sh_flags); Fields[8].Str = to_string(Sec.sh_link); Fields[9].Str = to_string(Sec.sh_info); Fields[10].Str = to_string(Sec.sh_addralign); OS.PadToColumn(Fields[0].Column); OS << "[" << right_justify(Fields[0].Str, 2) << "]"; for (int i = 1; i < 7; i++) printField(Fields[i]); OS.PadToColumn(Fields[7].Column); OS << right_justify(Fields[7].Str, 3); OS.PadToColumn(Fields[8].Column); OS << right_justify(Fields[8].Str, 2); OS.PadToColumn(Fields[9].Column); OS << right_justify(Fields[9].Str, 3); OS.PadToColumn(Fields[10].Column); OS << right_justify(Fields[10].Str, 2); OS << "\n"; ++SectionIndex; } printSectionDescription(OS, Obj->getHeader()->e_machine); } template void GNUStyle::printSymtabMessage(const ELFO *Obj, StringRef Name, size_t Entries, bool NonVisibilityBitsUsed) { if (!Name.empty()) OS << "\nSymbol table '" << Name << "' contains " << Entries << " entries:\n"; else OS << "\n Symbol table for image:\n"; if (ELFT::Is64Bits) OS << " Num: Value Size Type Bind Vis"; else OS << " Num: Value Size Type Bind Vis"; if (NonVisibilityBitsUsed) OS << " "; OS << " Ndx Name\n"; } template std::string GNUStyle::getSymbolSectionNdx(const ELFO *Obj, const Elf_Sym *Symbol, const Elf_Sym *FirstSym) { unsigned SectionIndex = Symbol->st_shndx; switch (SectionIndex) { case ELF::SHN_UNDEF: return "UND"; case ELF::SHN_ABS: return "ABS"; case ELF::SHN_COMMON: return "COM"; case ELF::SHN_XINDEX: { Expected IndexOrErr = object::getExtendedSymbolTableIndex( Symbol, FirstSym, this->dumper()->getShndxTable()); if (!IndexOrErr) { assert(Symbol->st_shndx == SHN_XINDEX && "getSymbolSectionIndex should only fail due to an invalid " "SHT_SYMTAB_SHNDX table/reference"); this->reportUniqueWarning(IndexOrErr.takeError()); return "RSV[0xffff]"; } return to_string(format_decimal(*IndexOrErr, 3)); } default: // Find if: // Processor specific if (SectionIndex >= ELF::SHN_LOPROC && SectionIndex <= ELF::SHN_HIPROC) return std::string("PRC[0x") + to_string(format_hex_no_prefix(SectionIndex, 4)) + "]"; // OS specific if (SectionIndex >= ELF::SHN_LOOS && SectionIndex <= ELF::SHN_HIOS) return std::string("OS[0x") + to_string(format_hex_no_prefix(SectionIndex, 4)) + "]"; // Architecture reserved: if (SectionIndex >= ELF::SHN_LORESERVE && SectionIndex <= ELF::SHN_HIRESERVE) return std::string("RSV[0x") + to_string(format_hex_no_prefix(SectionIndex, 4)) + "]"; // A normal section with an index return to_string(format_decimal(SectionIndex, 3)); } } template void GNUStyle::printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, const Elf_Sym *FirstSym, StringRef StrTable, bool IsDynamic, bool NonVisibilityBitsUsed) { static int Idx = 0; static bool Dynamic = true; // If this function was called with a different value from IsDynamic // from last call, happens when we move from dynamic to static symbol // table, "Num" field should be reset. if (!Dynamic != !IsDynamic) { Idx = 0; Dynamic = false; } unsigned Bias = ELFT::Is64Bits ? 8 : 0; Field Fields[8] = {0, 8, 17 + Bias, 23 + Bias, 31 + Bias, 38 + Bias, 48 + Bias, 51 + Bias}; Fields[0].Str = to_string(format_decimal(Idx++, 6)) + ":"; Fields[1].Str = to_string( format_hex_no_prefix(Symbol->st_value, ELFT::Is64Bits ? 16 : 8)); Fields[2].Str = to_string(format_decimal(Symbol->st_size, 5)); unsigned char SymbolType = Symbol->getType(); if (Obj->getHeader()->e_machine == ELF::EM_AMDGPU && SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS) Fields[3].Str = printEnum(SymbolType, makeArrayRef(AMDGPUSymbolTypes)); else Fields[3].Str = printEnum(SymbolType, makeArrayRef(ElfSymbolTypes)); Fields[4].Str = printEnum(Symbol->getBinding(), makeArrayRef(ElfSymbolBindings)); Fields[5].Str = printEnum(Symbol->getVisibility(), makeArrayRef(ElfSymbolVisibilities)); if (Symbol->st_other & ~0x3) Fields[5].Str += " [st_other, 2)) + ">]"; Fields[6].Column += NonVisibilityBitsUsed ? 13 : 0; Fields[6].Str = getSymbolSectionNdx(Obj, Symbol, FirstSym); Fields[7].Str = this->dumper()->getFullSymbolName(Symbol, StrTable, IsDynamic); for (auto &Entry : Fields) printField(Entry); OS << "\n"; } template void GNUStyle::printHashedSymbol(const ELFO *Obj, const Elf_Sym *FirstSym, uint32_t Sym, StringRef StrTable, uint32_t Bucket) { unsigned Bias = ELFT::Is64Bits ? 8 : 0; Field Fields[9] = {0, 6, 11, 20 + Bias, 25 + Bias, 34 + Bias, 41 + Bias, 49 + Bias, 53 + Bias}; Fields[0].Str = to_string(format_decimal(Sym, 5)); Fields[1].Str = to_string(format_decimal(Bucket, 3)) + ":"; const auto Symbol = FirstSym + Sym; Fields[2].Str = to_string( format_hex_no_prefix(Symbol->st_value, ELFT::Is64Bits ? 16 : 8)); Fields[3].Str = to_string(format_decimal(Symbol->st_size, 5)); unsigned char SymbolType = Symbol->getType(); if (Obj->getHeader()->e_machine == ELF::EM_AMDGPU && SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS) Fields[4].Str = printEnum(SymbolType, makeArrayRef(AMDGPUSymbolTypes)); else Fields[4].Str = printEnum(SymbolType, makeArrayRef(ElfSymbolTypes)); Fields[5].Str = printEnum(Symbol->getBinding(), makeArrayRef(ElfSymbolBindings)); Fields[6].Str = printEnum(Symbol->getVisibility(), makeArrayRef(ElfSymbolVisibilities)); Fields[7].Str = getSymbolSectionNdx(Obj, Symbol, FirstSym); Fields[8].Str = this->dumper()->getFullSymbolName(Symbol, StrTable, true); for (auto &Entry : Fields) printField(Entry); OS << "\n"; } template void GNUStyle::printSymbols(const ELFO *Obj, bool PrintSymbols, bool PrintDynamicSymbols) { if (!PrintSymbols && !PrintDynamicSymbols) return; // GNU readelf prints both the .dynsym and .symtab with --symbols. this->dumper()->printSymbolsHelper(true); if (PrintSymbols) this->dumper()->printSymbolsHelper(false); } template void GNUStyle::printHashSymbols(const ELFO *Obj) { if (this->dumper()->getDynamicStringTable().empty()) return; auto StringTable = this->dumper()->getDynamicStringTable(); auto DynSyms = this->dumper()->dynamic_symbols(); // Try printing .hash if (auto SysVHash = this->dumper()->getHashTable()) { OS << "\n Symbol table of .hash for image:\n"; if (ELFT::Is64Bits) OS << " Num Buc: Value Size Type Bind Vis Ndx Name"; else OS << " Num Buc: Value Size Type Bind Vis Ndx Name"; OS << "\n"; auto Buckets = SysVHash->buckets(); auto Chains = SysVHash->chains(); for (uint32_t Buc = 0; Buc < SysVHash->nbucket; Buc++) { if (Buckets[Buc] == ELF::STN_UNDEF) continue; std::vector Visited(SysVHash->nchain); for (uint32_t Ch = Buckets[Buc]; Ch < SysVHash->nchain; Ch = Chains[Ch]) { if (Ch == ELF::STN_UNDEF) break; if (Visited[Ch]) { reportWarning( createError(".hash section is invalid: bucket " + Twine(Ch) + ": a cycle was detected in the linked chain"), this->FileName); break; } printHashedSymbol(Obj, &DynSyms[0], Ch, StringTable, Buc); Visited[Ch] = true; } } } // Try printing .gnu.hash if (auto GnuHash = this->dumper()->getGnuHashTable()) { OS << "\n Symbol table of .gnu.hash for image:\n"; if (ELFT::Is64Bits) OS << " Num Buc: Value Size Type Bind Vis Ndx Name"; else OS << " Num Buc: Value Size Type Bind Vis Ndx Name"; OS << "\n"; auto Buckets = GnuHash->buckets(); for (uint32_t Buc = 0; Buc < GnuHash->nbuckets; Buc++) { if (Buckets[Buc] == ELF::STN_UNDEF) continue; uint32_t Index = Buckets[Buc]; uint32_t GnuHashable = Index - GnuHash->symndx; // Print whole chain while (true) { printHashedSymbol(Obj, &DynSyms[0], Index++, StringTable, Buc); // Chain ends at symbol with stopper bit if ((GnuHash->values(DynSyms.size())[GnuHashable++] & 1) == 1) break; } } } } static inline std::string printPhdrFlags(unsigned Flag) { std::string Str; Str = (Flag & PF_R) ? "R" : " "; Str += (Flag & PF_W) ? "W" : " "; Str += (Flag & PF_X) ? "E" : " "; return Str; } // SHF_TLS sections are only in PT_TLS, PT_LOAD or PT_GNU_RELRO // PT_TLS must only have SHF_TLS sections template bool GNUStyle::checkTLSSections(const Elf_Phdr &Phdr, const Elf_Shdr &Sec) { return (((Sec.sh_flags & ELF::SHF_TLS) && ((Phdr.p_type == ELF::PT_TLS) || (Phdr.p_type == ELF::PT_LOAD) || (Phdr.p_type == ELF::PT_GNU_RELRO))) || (!(Sec.sh_flags & ELF::SHF_TLS) && Phdr.p_type != ELF::PT_TLS)); } // Non-SHT_NOBITS must have its offset inside the segment // Only non-zero section can be at end of segment template bool GNUStyle::checkoffsets(const Elf_Phdr &Phdr, const Elf_Shdr &Sec) { if (Sec.sh_type == ELF::SHT_NOBITS) return true; bool IsSpecial = (Sec.sh_type == ELF::SHT_NOBITS) && ((Sec.sh_flags & ELF::SHF_TLS) != 0); // .tbss is special, it only has memory in PT_TLS and has NOBITS properties auto SectionSize = (IsSpecial && Phdr.p_type != ELF::PT_TLS) ? 0 : Sec.sh_size; if (Sec.sh_offset >= Phdr.p_offset) return ((Sec.sh_offset + SectionSize <= Phdr.p_filesz + Phdr.p_offset) /*only non-zero sized sections at end*/ && (Sec.sh_offset + 1 <= Phdr.p_offset + Phdr.p_filesz)); return false; } // SHF_ALLOC must have VMA inside segment // Only non-zero section can be at end of segment template bool GNUStyle::checkVMA(const Elf_Phdr &Phdr, const Elf_Shdr &Sec) { if (!(Sec.sh_flags & ELF::SHF_ALLOC)) return true; bool IsSpecial = (Sec.sh_type == ELF::SHT_NOBITS) && ((Sec.sh_flags & ELF::SHF_TLS) != 0); // .tbss is special, it only has memory in PT_TLS and has NOBITS properties auto SectionSize = (IsSpecial && Phdr.p_type != ELF::PT_TLS) ? 0 : Sec.sh_size; if (Sec.sh_addr >= Phdr.p_vaddr) return ((Sec.sh_addr + SectionSize <= Phdr.p_vaddr + Phdr.p_memsz) && (Sec.sh_addr + 1 <= Phdr.p_vaddr + Phdr.p_memsz)); return false; } // No section with zero size must be at start or end of PT_DYNAMIC template bool GNUStyle::checkPTDynamic(const Elf_Phdr &Phdr, const Elf_Shdr &Sec) { if (Phdr.p_type != ELF::PT_DYNAMIC || Sec.sh_size != 0 || Phdr.p_memsz == 0) return true; // Is section within the phdr both based on offset and VMA ? return ((Sec.sh_type == ELF::SHT_NOBITS) || (Sec.sh_offset > Phdr.p_offset && Sec.sh_offset < Phdr.p_offset + Phdr.p_filesz)) && (!(Sec.sh_flags & ELF::SHF_ALLOC) || (Sec.sh_addr > Phdr.p_vaddr && Sec.sh_addr < Phdr.p_memsz)); } template void GNUStyle::printProgramHeaders( const ELFO *Obj, bool PrintProgramHeaders, cl::boolOrDefault PrintSectionMapping) { if (PrintProgramHeaders) printProgramHeaders(Obj); // Display the section mapping along with the program headers, unless // -section-mapping is explicitly set to false. if (PrintSectionMapping != cl::BOU_FALSE) printSectionMapping(Obj); } template void GNUStyle::printProgramHeaders(const ELFO *Obj) { unsigned Bias = ELFT::Is64Bits ? 8 : 0; const Elf_Ehdr *Header = Obj->getHeader(); Field Fields[8] = {2, 17, 26, 37 + Bias, 48 + Bias, 56 + Bias, 64 + Bias, 68 + Bias}; OS << "\nElf file type is " << printEnum(Header->e_type, makeArrayRef(ElfObjectFileType)) << "\n" << "Entry point " << format_hex(Header->e_entry, 3) << "\n" << "There are " << Header->e_phnum << " program headers," << " starting at offset " << Header->e_phoff << "\n\n" << "Program Headers:\n"; if (ELFT::Is64Bits) OS << " Type Offset VirtAddr PhysAddr " << " FileSiz MemSiz Flg Align\n"; else OS << " Type Offset VirtAddr PhysAddr FileSiz " << "MemSiz Flg Align\n"; unsigned Width = ELFT::Is64Bits ? 18 : 10; unsigned SizeWidth = ELFT::Is64Bits ? 8 : 7; for (const auto &Phdr : unwrapOrError(this->FileName, Obj->program_headers())) { Fields[0].Str = getElfPtType(Header->e_machine, Phdr.p_type); Fields[1].Str = to_string(format_hex(Phdr.p_offset, 8)); Fields[2].Str = to_string(format_hex(Phdr.p_vaddr, Width)); Fields[3].Str = to_string(format_hex(Phdr.p_paddr, Width)); Fields[4].Str = to_string(format_hex(Phdr.p_filesz, SizeWidth)); Fields[5].Str = to_string(format_hex(Phdr.p_memsz, SizeWidth)); Fields[6].Str = printPhdrFlags(Phdr.p_flags); Fields[7].Str = to_string(format_hex(Phdr.p_align, 1)); for (auto Field : Fields) printField(Field); if (Phdr.p_type == ELF::PT_INTERP) { OS << "\n [Requesting program interpreter: "; OS << reinterpret_cast(Obj->base()) + Phdr.p_offset << "]"; } OS << "\n"; } } template void GNUStyle::printSectionMapping(const ELFO *Obj) { OS << "\n Section to Segment mapping:\n Segment Sections...\n"; DenseSet BelongsToSegment; int Phnum = 0; for (const Elf_Phdr &Phdr : unwrapOrError(this->FileName, Obj->program_headers())) { std::string Sections; OS << format(" %2.2d ", Phnum++); for (const Elf_Shdr &Sec : unwrapOrError(this->FileName, Obj->sections())) { // Check if each section is in a segment and then print mapping. // readelf additionally makes sure it does not print zero sized sections // at end of segments and for PT_DYNAMIC both start and end of section // .tbss must only be shown in PT_TLS section. bool TbssInNonTLS = (Sec.sh_type == ELF::SHT_NOBITS) && ((Sec.sh_flags & ELF::SHF_TLS) != 0) && Phdr.p_type != ELF::PT_TLS; if (!TbssInNonTLS && checkTLSSections(Phdr, Sec) && checkoffsets(Phdr, Sec) && checkVMA(Phdr, Sec) && checkPTDynamic(Phdr, Sec) && (Sec.sh_type != ELF::SHT_NULL)) { Sections += unwrapOrError(this->FileName, Obj->getSectionName(&Sec)).str() + " "; BelongsToSegment.insert(&Sec); } } OS << Sections << "\n"; OS.flush(); } // Display sections that do not belong to a segment. std::string Sections; for (const Elf_Shdr &Sec : unwrapOrError(this->FileName, Obj->sections())) { if (BelongsToSegment.find(&Sec) == BelongsToSegment.end()) Sections += unwrapOrError(this->FileName, Obj->getSectionName(&Sec)).str() + ' '; } if (!Sections.empty()) { OS << " None " << Sections << '\n'; OS.flush(); } } namespace { template struct RelSymbol { const typename ELFT::Sym *Sym; std::string Name; }; template RelSymbol getSymbolForReloc(const ELFFile *Obj, StringRef FileName, const ELFDumper *Dumper, const typename ELFT::Rela &Reloc) { uint32_t SymIndex = Reloc.getSymbol(Obj->isMips64EL()); const typename ELFT::Sym *Sym = Dumper->dynamic_symbols().begin() + SymIndex; Expected ErrOrName = Sym->getName(Dumper->getDynamicStringTable()); std::string Name; if (ErrOrName) { Name = maybeDemangle(*ErrOrName); } else { reportWarning( createError("unable to get name of the dynamic symbol with index " + Twine(SymIndex) + ": " + toString(ErrOrName.takeError())), FileName); Name = ""; } return {Sym, std::move(Name)}; } } // namespace template void GNUStyle::printDynamicRelocation(const ELFO *Obj, Elf_Rela R, bool IsRela) { RelSymbol S = getSymbolForReloc(Obj, this->FileName, this->dumper(), R); printRelocation(Obj, S.Sym, S.Name, R, IsRela); } template void GNUStyle::printDynamic(const ELFO *Obj) { Elf_Dyn_Range Table = this->dumper()->dynamic_table(); if (Table.empty()) return; const DynRegionInfo &DynamicTableRegion = this->dumper()->getDynamicTableRegion(); OS << "Dynamic section at offset " << format_hex(reinterpret_cast(DynamicTableRegion.Addr) - Obj->base(), 1) << " contains " << Table.size() << " entries:\n"; bool Is64 = ELFT::Is64Bits; if (Is64) OS << " Tag Type Name/Value\n"; else OS << " Tag Type Name/Value\n"; for (auto Entry : Table) { uintX_t Tag = Entry.getTag(); std::string TypeString = std::string("(") + Obj->getDynamicTagAsString(Tag).c_str() + ")"; OS << " " << format_hex(Tag, Is64 ? 18 : 10) << format(" %-20s ", TypeString.c_str()); this->dumper()->printDynamicEntry(OS, Tag, Entry.getVal()); OS << "\n"; } } template void GNUStyle::printDynamicRelocations(const ELFO *Obj) { const DynRegionInfo &DynRelRegion = this->dumper()->getDynRelRegion(); const DynRegionInfo &DynRelaRegion = this->dumper()->getDynRelaRegion(); const DynRegionInfo &DynRelrRegion = this->dumper()->getDynRelrRegion(); const DynRegionInfo &DynPLTRelRegion = this->dumper()->getDynPLTRelRegion(); if (DynRelaRegion.Size > 0) { OS << "\n'RELA' relocation section at offset " << format_hex(reinterpret_cast(DynRelaRegion.Addr) - Obj->base(), 1) << " contains " << DynRelaRegion.Size << " bytes:\n"; printRelocHeader(ELF::SHT_RELA); for (const Elf_Rela &Rela : this->dumper()->dyn_relas()) printDynamicRelocation(Obj, Rela, true); } if (DynRelRegion.Size > 0) { OS << "\n'REL' relocation section at offset " << format_hex(reinterpret_cast(DynRelRegion.Addr) - Obj->base(), 1) << " contains " << DynRelRegion.Size << " bytes:\n"; printRelocHeader(ELF::SHT_REL); for (const Elf_Rel &Rel : this->dumper()->dyn_rels()) { Elf_Rela Rela; Rela.r_offset = Rel.r_offset; Rela.r_info = Rel.r_info; Rela.r_addend = 0; printDynamicRelocation(Obj, Rela, false); } } if (DynRelrRegion.Size > 0) { OS << "\n'RELR' relocation section at offset " << format_hex(reinterpret_cast(DynRelrRegion.Addr) - Obj->base(), 1) << " contains " << DynRelrRegion.Size << " bytes:\n"; printRelocHeader(ELF::SHT_REL); Elf_Relr_Range Relrs = this->dumper()->dyn_relrs(); std::vector RelrRelas = unwrapOrError(this->FileName, Obj->decode_relrs(Relrs)); for (const Elf_Rela &Rela : RelrRelas) { printDynamicRelocation(Obj, Rela, false); } } if (DynPLTRelRegion.Size) { OS << "\n'PLT' relocation section at offset " << format_hex(reinterpret_cast(DynPLTRelRegion.Addr) - Obj->base(), 1) << " contains " << DynPLTRelRegion.Size << " bytes:\n"; } if (DynPLTRelRegion.EntSize == sizeof(Elf_Rela)) { printRelocHeader(ELF::SHT_RELA); for (const Elf_Rela &Rela : DynPLTRelRegion.getAsArrayRef()) printDynamicRelocation(Obj, Rela, true); } else { printRelocHeader(ELF::SHT_REL); for (const Elf_Rel &Rel : DynPLTRelRegion.getAsArrayRef()) { Elf_Rela Rela; Rela.r_offset = Rel.r_offset; Rela.r_info = Rel.r_info; Rela.r_addend = 0; printDynamicRelocation(Obj, Rela, false); } } } template void GNUStyle::printGNUVersionSectionProlog( const ELFFile *Obj, const typename ELFT::Shdr *Sec, const Twine &Label, unsigned EntriesNum) { StringRef SecName = unwrapOrError(this->FileName, Obj->getSectionName(Sec)); OS << Label << " section '" << SecName << "' " << "contains " << EntriesNum << " entries:\n"; unsigned SecNdx = Sec - &cantFail(Obj->sections()).front(); StringRef SymTabName = ""; Expected SymTabOrErr = Obj->getSection(Sec->sh_link); if (SymTabOrErr) SymTabName = unwrapOrError(this->FileName, Obj->getSectionName(*SymTabOrErr)); else this->reportUniqueWarning( createError("invalid section linked to " + object::getELFSectionTypeName(Obj->getHeader()->e_machine, Sec->sh_type) + " section with index " + Twine(SecNdx) + ": " + toString(SymTabOrErr.takeError()))); OS << " Addr: " << format_hex_no_prefix(Sec->sh_addr, 16) << " Offset: " << format_hex(Sec->sh_offset, 8) << " Link: " << Sec->sh_link << " (" << SymTabName << ")\n"; } template void GNUStyle::printVersionSymbolSection(const ELFFile *Obj, const Elf_Shdr *Sec) { if (!Sec) return; printGNUVersionSectionProlog(Obj, Sec, "Version symbols", Sec->sh_size / sizeof(Elf_Versym)); Expected> VerTableOrErr = this->dumper()->getVersionTable(Sec, /*SymTab=*/nullptr, /*StrTab=*/nullptr); if (!VerTableOrErr) { this->reportUniqueWarning(VerTableOrErr.takeError()); return; } ArrayRef VerTable = *VerTableOrErr; std::vector Versions; for (size_t I = 0, E = VerTable.size(); I < E; ++I) { unsigned Ndx = VerTable[I].vs_index; if (Ndx == VER_NDX_LOCAL || Ndx == VER_NDX_GLOBAL) { Versions.emplace_back(Ndx == VER_NDX_LOCAL ? "*local*" : "*global*"); continue; } bool IsDefault; Expected NameOrErr = this->dumper()->getSymbolVersionByIndex(Ndx, IsDefault); if (!NameOrErr) { if (!NameOrErr) { unsigned SecNdx = Sec - &cantFail(Obj->sections()).front(); this->reportUniqueWarning(createError( "unable to get a version for entry " + Twine(I) + " of SHT_GNU_versym section with index " + Twine(SecNdx) + ": " + toString(NameOrErr.takeError()))); } Versions.emplace_back(""); continue; } Versions.emplace_back(*NameOrErr); } // readelf prints 4 entries per line. uint64_t Entries = VerTable.size(); for (uint64_t VersymRow = 0; VersymRow < Entries; VersymRow += 4) { OS << " " << format_hex_no_prefix(VersymRow, 3) << ":"; for (uint64_t I = 0; (I < 4) && (I + VersymRow) < Entries; ++I) { unsigned Ndx = VerTable[VersymRow + I].vs_index; OS << format("%4x%c", Ndx & VERSYM_VERSION, Ndx & VERSYM_HIDDEN ? 'h' : ' '); OS << left_justify("(" + std::string(Versions[VersymRow + I]) + ")", 13); } OS << '\n'; } OS << '\n'; } static std::string versionFlagToString(unsigned Flags) { if (Flags == 0) return "none"; std::string Ret; auto AddFlag = [&Ret, &Flags](unsigned Flag, StringRef Name) { if (!(Flags & Flag)) return; if (!Ret.empty()) Ret += " | "; Ret += Name; Flags &= ~Flag; }; AddFlag(VER_FLG_BASE, "BASE"); AddFlag(VER_FLG_WEAK, "WEAK"); AddFlag(VER_FLG_INFO, "INFO"); AddFlag(~0, ""); return Ret; } template void GNUStyle::printVersionDefinitionSection(const ELFFile *Obj, const Elf_Shdr *Sec) { if (!Sec) return; printGNUVersionSectionProlog(Obj, Sec, "Version definition", Sec->sh_info); Expected> V = this->dumper()->getVersionDefinitions(Sec); if (!V) { this->reportUniqueWarning(V.takeError()); return; } for (const VerDef &Def : *V) { OS << format(" 0x%04x: Rev: %u Flags: %s Index: %u Cnt: %u Name: %s\n", Def.Offset, Def.Version, versionFlagToString(Def.Flags).c_str(), Def.Ndx, Def.Cnt, Def.Name.data()); unsigned I = 0; for (const VerdAux &Aux : Def.AuxV) OS << format(" 0x%04x: Parent %u: %s\n", Aux.Offset, ++I, Aux.Name.data()); } OS << '\n'; } template void GNUStyle::printVersionDependencySection(const ELFFile *Obj, const Elf_Shdr *Sec) { if (!Sec) return; unsigned VerneedNum = Sec->sh_info; printGNUVersionSectionProlog(Obj, Sec, "Version needs", VerneedNum); Expected> V = this->dumper()->getVersionDependencies(Sec); if (!V) { this->reportUniqueWarning(V.takeError()); return; } for (const VerNeed &VN : *V) { OS << format(" 0x%04x: Version: %u File: %s Cnt: %u\n", VN.Offset, VN.Version, VN.File.data(), VN.Cnt); for (const VernAux &Aux : VN.AuxV) OS << format(" 0x%04x: Name: %s Flags: %s Version: %u\n", Aux.Offset, Aux.Name.data(), versionFlagToString(Aux.Flags).c_str(), Aux.Other); } OS << '\n'; } // Hash histogram shows statistics of how efficient the hash was for the // dynamic symbol table. The table shows number of hash buckets for different // lengths of chains as absolute number and percentage of the total buckets. // Additionally cumulative coverage of symbols for each set of buckets. template void GNUStyle::printHashHistogram(const ELFFile *Obj) { // Print histogram for .hash section if (const Elf_Hash *HashTable = this->dumper()->getHashTable()) { size_t NBucket = HashTable->nbucket; size_t NChain = HashTable->nchain; ArrayRef Buckets = HashTable->buckets(); ArrayRef Chains = HashTable->chains(); size_t TotalSyms = 0; // If hash table is correct, we have at least chains with 0 length size_t MaxChain = 1; size_t CumulativeNonZero = 0; if (NChain == 0 || NBucket == 0) return; std::vector ChainLen(NBucket, 0); // Go over all buckets and and note chain lengths of each bucket (total // unique chain lengths). for (size_t B = 0; B < NBucket; B++) { std::vector Visited(NChain); for (size_t C = Buckets[B]; C < NChain; C = Chains[C]) { if (C == ELF::STN_UNDEF) break; if (Visited[C]) { reportWarning( createError(".hash section is invalid: bucket " + Twine(C) + ": a cycle was detected in the linked chain"), this->FileName); break; } Visited[C] = true; if (MaxChain <= ++ChainLen[B]) MaxChain++; } TotalSyms += ChainLen[B]; } if (!TotalSyms) return; std::vector Count(MaxChain, 0) ; // Count how long is the chain for each bucket for (size_t B = 0; B < NBucket; B++) ++Count[ChainLen[B]]; // Print Number of buckets with each chain lengths and their cumulative // coverage of the symbols OS << "Histogram for bucket list length (total of " << NBucket << " buckets)\n" << " Length Number % of total Coverage\n"; for (size_t I = 0; I < MaxChain; I++) { CumulativeNonZero += Count[I] * I; OS << format("%7lu %-10lu (%5.1f%%) %5.1f%%\n", I, Count[I], (Count[I] * 100.0) / NBucket, (CumulativeNonZero * 100.0) / TotalSyms); } } // Print histogram for .gnu.hash section if (const Elf_GnuHash *GnuHashTable = this->dumper()->getGnuHashTable()) { size_t NBucket = GnuHashTable->nbuckets; ArrayRef Buckets = GnuHashTable->buckets(); unsigned NumSyms = this->dumper()->dynamic_symbols().size(); if (!NumSyms) return; ArrayRef Chains = GnuHashTable->values(NumSyms); size_t Symndx = GnuHashTable->symndx; size_t TotalSyms = 0; size_t MaxChain = 1; size_t CumulativeNonZero = 0; if (Chains.empty() || NBucket == 0) return; std::vector ChainLen(NBucket, 0); for (size_t B = 0; B < NBucket; B++) { if (!Buckets[B]) continue; size_t Len = 1; for (size_t C = Buckets[B] - Symndx; C < Chains.size() && (Chains[C] & 1) == 0; C++) if (MaxChain < ++Len) MaxChain++; ChainLen[B] = Len; TotalSyms += Len; } MaxChain++; if (!TotalSyms) return; std::vector Count(MaxChain, 0) ; for (size_t B = 0; B < NBucket; B++) ++Count[ChainLen[B]]; // Print Number of buckets with each chain lengths and their cumulative // coverage of the symbols OS << "Histogram for `.gnu.hash' bucket list length (total of " << NBucket << " buckets)\n" << " Length Number % of total Coverage\n"; for (size_t I = 0; I void GNUStyle::printCGProfile(const ELFFile *Obj) { OS << "GNUStyle::printCGProfile not implemented\n"; } template void GNUStyle::printAddrsig(const ELFFile *Obj) { reportError(createError("--addrsig: not implemented"), this->FileName); } static StringRef getGenericNoteTypeName(const uint32_t NT) { static const struct { uint32_t ID; const char *Name; } Notes[] = { {ELF::NT_VERSION, "NT_VERSION (version)"}, {ELF::NT_ARCH, "NT_ARCH (architecture)"}, {ELF::NT_GNU_BUILD_ATTRIBUTE_OPEN, "OPEN"}, {ELF::NT_GNU_BUILD_ATTRIBUTE_FUNC, "func"}, }; for (const auto &Note : Notes) if (Note.ID == NT) return Note.Name; return ""; } static StringRef getCoreNoteTypeName(const uint32_t NT) { static const struct { uint32_t ID; const char *Name; } Notes[] = { {ELF::NT_PRSTATUS, "NT_PRSTATUS (prstatus structure)"}, {ELF::NT_FPREGSET, "NT_FPREGSET (floating point registers)"}, {ELF::NT_PRPSINFO, "NT_PRPSINFO (prpsinfo structure)"}, {ELF::NT_TASKSTRUCT, "NT_TASKSTRUCT (task structure)"}, {ELF::NT_AUXV, "NT_AUXV (auxiliary vector)"}, {ELF::NT_PSTATUS, "NT_PSTATUS (pstatus structure)"}, {ELF::NT_FPREGS, "NT_FPREGS (floating point registers)"}, {ELF::NT_PSINFO, "NT_PSINFO (psinfo structure)"}, {ELF::NT_LWPSTATUS, "NT_LWPSTATUS (lwpstatus_t structure)"}, {ELF::NT_LWPSINFO, "NT_LWPSINFO (lwpsinfo_t structure)"}, {ELF::NT_WIN32PSTATUS, "NT_WIN32PSTATUS (win32_pstatus structure)"}, {ELF::NT_PPC_VMX, "NT_PPC_VMX (ppc Altivec registers)"}, {ELF::NT_PPC_VSX, "NT_PPC_VSX (ppc VSX registers)"}, {ELF::NT_PPC_TAR, "NT_PPC_TAR (ppc TAR register)"}, {ELF::NT_PPC_PPR, "NT_PPC_PPR (ppc PPR register)"}, {ELF::NT_PPC_DSCR, "NT_PPC_DSCR (ppc DSCR register)"}, {ELF::NT_PPC_EBB, "NT_PPC_EBB (ppc EBB registers)"}, {ELF::NT_PPC_PMU, "NT_PPC_PMU (ppc PMU registers)"}, {ELF::NT_PPC_TM_CGPR, "NT_PPC_TM_CGPR (ppc checkpointed GPR registers)"}, {ELF::NT_PPC_TM_CFPR, "NT_PPC_TM_CFPR (ppc checkpointed floating point registers)"}, {ELF::NT_PPC_TM_CVMX, "NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)"}, {ELF::NT_PPC_TM_CVSX, "NT_PPC_TM_CVSX (ppc checkpointed VSX registers)"}, {ELF::NT_PPC_TM_SPR, "NT_PPC_TM_SPR (ppc TM special purpose registers)"}, {ELF::NT_PPC_TM_CTAR, "NT_PPC_TM_CTAR (ppc checkpointed TAR register)"}, {ELF::NT_PPC_TM_CPPR, "NT_PPC_TM_CPPR (ppc checkpointed PPR register)"}, {ELF::NT_PPC_TM_CDSCR, "NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)"}, {ELF::NT_386_TLS, "NT_386_TLS (x86 TLS information)"}, {ELF::NT_386_IOPERM, "NT_386_IOPERM (x86 I/O permissions)"}, {ELF::NT_X86_XSTATE, "NT_X86_XSTATE (x86 XSAVE extended state)"}, {ELF::NT_S390_HIGH_GPRS, "NT_S390_HIGH_GPRS (s390 upper register halves)"}, {ELF::NT_S390_TIMER, "NT_S390_TIMER (s390 timer register)"}, {ELF::NT_S390_TODCMP, "NT_S390_TODCMP (s390 TOD comparator register)"}, {ELF::NT_S390_TODPREG, "NT_S390_TODPREG (s390 TOD programmable register)"}, {ELF::NT_S390_CTRS, "NT_S390_CTRS (s390 control registers)"}, {ELF::NT_S390_PREFIX, "NT_S390_PREFIX (s390 prefix register)"}, {ELF::NT_S390_LAST_BREAK, "NT_S390_LAST_BREAK (s390 last breaking event address)"}, {ELF::NT_S390_SYSTEM_CALL, "NT_S390_SYSTEM_CALL (s390 system call restart data)"}, {ELF::NT_S390_TDB, "NT_S390_TDB (s390 transaction diagnostic block)"}, {ELF::NT_S390_VXRS_LOW, "NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)"}, {ELF::NT_S390_VXRS_HIGH, "NT_S390_VXRS_HIGH (s390 vector registers 16-31)"}, {ELF::NT_S390_GS_CB, "NT_S390_GS_CB (s390 guarded-storage registers)"}, {ELF::NT_S390_GS_BC, "NT_S390_GS_BC (s390 guarded-storage broadcast control)"}, {ELF::NT_ARM_VFP, "NT_ARM_VFP (arm VFP registers)"}, {ELF::NT_ARM_TLS, "NT_ARM_TLS (AArch TLS registers)"}, {ELF::NT_ARM_HW_BREAK, "NT_ARM_HW_BREAK (AArch hardware breakpoint registers)"}, {ELF::NT_ARM_HW_WATCH, "NT_ARM_HW_WATCH (AArch hardware watchpoint registers)"}, {ELF::NT_FILE, "NT_FILE (mapped files)"}, {ELF::NT_PRXFPREG, "NT_PRXFPREG (user_xfpregs structure)"}, {ELF::NT_SIGINFO, "NT_SIGINFO (siginfo_t data)"}, }; for (const auto &Note : Notes) if (Note.ID == NT) return Note.Name; return ""; } static std::string getGNUNoteTypeName(const uint32_t NT) { static const struct { uint32_t ID; const char *Name; } Notes[] = { {ELF::NT_GNU_ABI_TAG, "NT_GNU_ABI_TAG (ABI version tag)"}, {ELF::NT_GNU_HWCAP, "NT_GNU_HWCAP (DSO-supplied software HWCAP info)"}, {ELF::NT_GNU_BUILD_ID, "NT_GNU_BUILD_ID (unique build ID bitstring)"}, {ELF::NT_GNU_GOLD_VERSION, "NT_GNU_GOLD_VERSION (gold version)"}, {ELF::NT_GNU_PROPERTY_TYPE_0, "NT_GNU_PROPERTY_TYPE_0 (property note)"}, }; for (const auto &Note : Notes) if (Note.ID == NT) return std::string(Note.Name); std::string string; raw_string_ostream OS(string); OS << format("Unknown note type (0x%08x)", NT); return OS.str(); } static std::string getFreeBSDNoteTypeName(const uint32_t NT) { static const struct { uint32_t ID; const char *Name; } Notes[] = { {ELF::NT_FREEBSD_THRMISC, "NT_THRMISC (thrmisc structure)"}, {ELF::NT_FREEBSD_PROCSTAT_PROC, "NT_PROCSTAT_PROC (proc data)"}, {ELF::NT_FREEBSD_PROCSTAT_FILES, "NT_PROCSTAT_FILES (files data)"}, {ELF::NT_FREEBSD_PROCSTAT_VMMAP, "NT_PROCSTAT_VMMAP (vmmap data)"}, {ELF::NT_FREEBSD_PROCSTAT_GROUPS, "NT_PROCSTAT_GROUPS (groups data)"}, {ELF::NT_FREEBSD_PROCSTAT_UMASK, "NT_PROCSTAT_UMASK (umask data)"}, {ELF::NT_FREEBSD_PROCSTAT_RLIMIT, "NT_PROCSTAT_RLIMIT (rlimit data)"}, {ELF::NT_FREEBSD_PROCSTAT_OSREL, "NT_PROCSTAT_OSREL (osreldate data)"}, {ELF::NT_FREEBSD_PROCSTAT_PSSTRINGS, "NT_PROCSTAT_PSSTRINGS (ps_strings data)"}, {ELF::NT_FREEBSD_PROCSTAT_AUXV, "NT_PROCSTAT_AUXV (auxv data)"}, }; for (const auto &Note : Notes) if (Note.ID == NT) return std::string(Note.Name); std::string string; raw_string_ostream OS(string); OS << format("Unknown note type (0x%08x)", NT); return OS.str(); } static std::string getAMDNoteTypeName(const uint32_t NT) { static const struct { uint32_t ID; const char *Name; } Notes[] = {{ELF::NT_AMD_AMDGPU_HSA_METADATA, "NT_AMD_AMDGPU_HSA_METADATA (HSA Metadata)"}, {ELF::NT_AMD_AMDGPU_ISA, "NT_AMD_AMDGPU_ISA (ISA Version)"}, {ELF::NT_AMD_AMDGPU_PAL_METADATA, "NT_AMD_AMDGPU_PAL_METADATA (PAL Metadata)"}}; for (const auto &Note : Notes) if (Note.ID == NT) return std::string(Note.Name); std::string string; raw_string_ostream OS(string); OS << format("Unknown note type (0x%08x)", NT); return OS.str(); } static std::string getAMDGPUNoteTypeName(const uint32_t NT) { if (NT == ELF::NT_AMDGPU_METADATA) return std::string("NT_AMDGPU_METADATA (AMDGPU Metadata)"); std::string string; raw_string_ostream OS(string); OS << format("Unknown note type (0x%08x)", NT); return OS.str(); } template static std::string getGNUProperty(uint32_t Type, uint32_t DataSize, ArrayRef Data) { std::string str; raw_string_ostream OS(str); uint32_t PrData; auto DumpBit = [&](uint32_t Flag, StringRef Name) { if (PrData & Flag) { PrData &= ~Flag; OS << Name; if (PrData) OS << ", "; } }; switch (Type) { default: OS << format("", Type); return OS.str(); case GNU_PROPERTY_STACK_SIZE: { OS << "stack size: "; if (DataSize == sizeof(typename ELFT::uint)) OS << formatv("{0:x}", (uint64_t)(*(const typename ELFT::Addr *)Data.data())); else OS << format("", DataSize); return OS.str(); } case GNU_PROPERTY_NO_COPY_ON_PROTECTED: OS << "no copy on protected"; if (DataSize) OS << format(" ", DataSize); return OS.str(); case GNU_PROPERTY_AARCH64_FEATURE_1_AND: case GNU_PROPERTY_X86_FEATURE_1_AND: OS << ((Type == GNU_PROPERTY_AARCH64_FEATURE_1_AND) ? "aarch64 feature: " : "x86 feature: "); if (DataSize != 4) { OS << format("", DataSize); return OS.str(); } PrData = support::endian::read32(Data.data()); if (PrData == 0) { OS << ""; return OS.str(); } if (Type == GNU_PROPERTY_AARCH64_FEATURE_1_AND) { DumpBit(GNU_PROPERTY_AARCH64_FEATURE_1_BTI, "BTI"); DumpBit(GNU_PROPERTY_AARCH64_FEATURE_1_PAC, "PAC"); } else { DumpBit(GNU_PROPERTY_X86_FEATURE_1_IBT, "IBT"); DumpBit(GNU_PROPERTY_X86_FEATURE_1_SHSTK, "SHSTK"); } if (PrData) OS << format("", PrData); return OS.str(); case GNU_PROPERTY_X86_ISA_1_NEEDED: case GNU_PROPERTY_X86_ISA_1_USED: OS << "x86 ISA " << (Type == GNU_PROPERTY_X86_ISA_1_NEEDED ? "needed: " : "used: "); if (DataSize != 4) { OS << format("", DataSize); return OS.str(); } PrData = support::endian::read32(Data.data()); if (PrData == 0) { OS << ""; return OS.str(); } DumpBit(GNU_PROPERTY_X86_ISA_1_CMOV, "CMOV"); DumpBit(GNU_PROPERTY_X86_ISA_1_SSE, "SSE"); DumpBit(GNU_PROPERTY_X86_ISA_1_SSE2, "SSE2"); DumpBit(GNU_PROPERTY_X86_ISA_1_SSE3, "SSE3"); DumpBit(GNU_PROPERTY_X86_ISA_1_SSSE3, "SSSE3"); DumpBit(GNU_PROPERTY_X86_ISA_1_SSE4_1, "SSE4_1"); DumpBit(GNU_PROPERTY_X86_ISA_1_SSE4_2, "SSE4_2"); DumpBit(GNU_PROPERTY_X86_ISA_1_AVX, "AVX"); DumpBit(GNU_PROPERTY_X86_ISA_1_AVX2, "AVX2"); DumpBit(GNU_PROPERTY_X86_ISA_1_FMA, "FMA"); DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512F, "AVX512F"); DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512CD, "AVX512CD"); DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512ER, "AVX512ER"); DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512PF, "AVX512PF"); DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512VL, "AVX512VL"); DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512DQ, "AVX512DQ"); DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512BW, "AVX512BW"); DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS, "AVX512_4FMAPS"); DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW, "AVX512_4VNNIW"); DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512_BITALG, "AVX512_BITALG"); DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512_IFMA, "AVX512_IFMA"); DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512_VBMI, "AVX512_VBMI"); DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2, "AVX512_VBMI2"); DumpBit(GNU_PROPERTY_X86_ISA_1_AVX512_VNNI, "AVX512_VNNI"); if (PrData) OS << format("", PrData); return OS.str(); break; case GNU_PROPERTY_X86_FEATURE_2_NEEDED: case GNU_PROPERTY_X86_FEATURE_2_USED: OS << "x86 feature " << (Type == GNU_PROPERTY_X86_FEATURE_2_NEEDED ? "needed: " : "used: "); if (DataSize != 4) { OS << format("", DataSize); return OS.str(); } PrData = support::endian::read32(Data.data()); if (PrData == 0) { OS << ""; return OS.str(); } DumpBit(GNU_PROPERTY_X86_FEATURE_2_X86, "x86"); DumpBit(GNU_PROPERTY_X86_FEATURE_2_X87, "x87"); DumpBit(GNU_PROPERTY_X86_FEATURE_2_MMX, "MMX"); DumpBit(GNU_PROPERTY_X86_FEATURE_2_XMM, "XMM"); DumpBit(GNU_PROPERTY_X86_FEATURE_2_YMM, "YMM"); DumpBit(GNU_PROPERTY_X86_FEATURE_2_ZMM, "ZMM"); DumpBit(GNU_PROPERTY_X86_FEATURE_2_FXSR, "FXSR"); DumpBit(GNU_PROPERTY_X86_FEATURE_2_XSAVE, "XSAVE"); DumpBit(GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT, "XSAVEOPT"); DumpBit(GNU_PROPERTY_X86_FEATURE_2_XSAVEC, "XSAVEC"); if (PrData) OS << format("", PrData); return OS.str(); } } template static SmallVector getGNUPropertyList(ArrayRef Arr) { using Elf_Word = typename ELFT::Word; SmallVector Properties; while (Arr.size() >= 8) { uint32_t Type = *reinterpret_cast(Arr.data()); uint32_t DataSize = *reinterpret_cast(Arr.data() + 4); Arr = Arr.drop_front(8); // Take padding size into account if present. uint64_t PaddedSize = alignTo(DataSize, sizeof(typename ELFT::uint)); std::string str; raw_string_ostream OS(str); if (Arr.size() < PaddedSize) { OS << format("", Type, DataSize); Properties.push_back(OS.str()); break; } Properties.push_back( getGNUProperty(Type, DataSize, Arr.take_front(PaddedSize))); Arr = Arr.drop_front(PaddedSize); } if (!Arr.empty()) Properties.push_back(""); return Properties; } struct GNUAbiTag { std::string OSName; std::string ABI; bool IsValid; }; template static GNUAbiTag getGNUAbiTag(ArrayRef Desc) { typedef typename ELFT::Word Elf_Word; ArrayRef Words(reinterpret_cast(Desc.begin()), reinterpret_cast(Desc.end())); if (Words.size() < 4) return {"", "", /*IsValid=*/false}; static const char *OSNames[] = { "Linux", "Hurd", "Solaris", "FreeBSD", "NetBSD", "Syllable", "NaCl", }; StringRef OSName = "Unknown"; if (Words[0] < array_lengthof(OSNames)) OSName = OSNames[Words[0]]; uint32_t Major = Words[1], Minor = Words[2], Patch = Words[3]; std::string str; raw_string_ostream ABI(str); ABI << Major << "." << Minor << "." << Patch; return {OSName, ABI.str(), /*IsValid=*/true}; } static std::string getGNUBuildId(ArrayRef Desc) { std::string str; raw_string_ostream OS(str); for (const auto &B : Desc) OS << format_hex_no_prefix(B, 2); return OS.str(); } static StringRef getGNUGoldVersion(ArrayRef Desc) { return StringRef(reinterpret_cast(Desc.data()), Desc.size()); } template static void printGNUNote(raw_ostream &OS, uint32_t NoteType, ArrayRef Desc) { switch (NoteType) { default: return; case ELF::NT_GNU_ABI_TAG: { const GNUAbiTag &AbiTag = getGNUAbiTag(Desc); if (!AbiTag.IsValid) OS << " "; else OS << " OS: " << AbiTag.OSName << ", ABI: " << AbiTag.ABI; break; } case ELF::NT_GNU_BUILD_ID: { OS << " Build ID: " << getGNUBuildId(Desc); break; } case ELF::NT_GNU_GOLD_VERSION: OS << " Version: " << getGNUGoldVersion(Desc); break; case ELF::NT_GNU_PROPERTY_TYPE_0: OS << " Properties:"; for (const auto &Property : getGNUPropertyList(Desc)) OS << " " << Property << "\n"; break; } OS << '\n'; } struct AMDNote { std::string Type; std::string Value; }; template static AMDNote getAMDNote(uint32_t NoteType, ArrayRef Desc) { switch (NoteType) { default: return {"", ""}; case ELF::NT_AMD_AMDGPU_HSA_METADATA: return { "HSA Metadata", std::string(reinterpret_cast(Desc.data()), Desc.size())}; case ELF::NT_AMD_AMDGPU_ISA: return { "ISA Version", std::string(reinterpret_cast(Desc.data()), Desc.size())}; } } struct AMDGPUNote { std::string Type; std::string Value; }; template static AMDGPUNote getAMDGPUNote(uint32_t NoteType, ArrayRef Desc) { switch (NoteType) { default: return {"", ""}; case ELF::NT_AMDGPU_METADATA: { auto MsgPackString = StringRef(reinterpret_cast(Desc.data()), Desc.size()); msgpack::Document MsgPackDoc; if (!MsgPackDoc.readFromBlob(MsgPackString, /*Multi=*/false)) return {"AMDGPU Metadata", "Invalid AMDGPU Metadata"}; AMDGPU::HSAMD::V3::MetadataVerifier Verifier(true); if (!Verifier.verify(MsgPackDoc.getRoot())) return {"AMDGPU Metadata", "Invalid AMDGPU Metadata"}; std::string HSAMetadataString; raw_string_ostream StrOS(HSAMetadataString); MsgPackDoc.toYAML(StrOS); return {"AMDGPU Metadata", StrOS.str()}; } } } struct CoreFileMapping { uint64_t Start, End, Offset; StringRef Filename; }; struct CoreNote { uint64_t PageSize; std::vector Mappings; }; static Expected readCoreNote(DataExtractor Desc) { // Expected format of the NT_FILE note description: // 1. # of file mappings (call it N) // 2. Page size // 3. N (start, end, offset) triples // 4. N packed filenames (null delimited) // Each field is an Elf_Addr, except for filenames which are char* strings. CoreNote Ret; const int Bytes = Desc.getAddressSize(); if (!Desc.isValidOffsetForAddress(2)) return createStringError(object_error::parse_failed, "malformed note: header too short"); if (Desc.getData().back() != 0) return createStringError(object_error::parse_failed, "malformed note: not NUL terminated"); uint64_t DescOffset = 0; uint64_t FileCount = Desc.getAddress(&DescOffset); Ret.PageSize = Desc.getAddress(&DescOffset); if (!Desc.isValidOffsetForAddress(3 * FileCount * Bytes)) return createStringError(object_error::parse_failed, "malformed note: too short for number of files"); uint64_t FilenamesOffset = 0; DataExtractor Filenames( Desc.getData().drop_front(DescOffset + 3 * FileCount * Bytes), Desc.isLittleEndian(), Desc.getAddressSize()); Ret.Mappings.resize(FileCount); for (CoreFileMapping &Mapping : Ret.Mappings) { if (!Filenames.isValidOffsetForDataOfSize(FilenamesOffset, 1)) return createStringError(object_error::parse_failed, "malformed note: too few filenames"); Mapping.Start = Desc.getAddress(&DescOffset); Mapping.End = Desc.getAddress(&DescOffset); Mapping.Offset = Desc.getAddress(&DescOffset); Mapping.Filename = Filenames.getCStrRef(&FilenamesOffset); } return Ret; } template static void printCoreNote(raw_ostream &OS, const CoreNote &Note) { // Length of "0x
" string. const int FieldWidth = ELFT::Is64Bits ? 18 : 10; OS << " Page size: " << format_decimal(Note.PageSize, 0) << '\n'; OS << " " << right_justify("Start", FieldWidth) << " " << right_justify("End", FieldWidth) << " " << right_justify("Page Offset", FieldWidth) << '\n'; for (const CoreFileMapping &Mapping : Note.Mappings) { OS << " " << format_hex(Mapping.Start, FieldWidth) << " " << format_hex(Mapping.End, FieldWidth) << " " << format_hex(Mapping.Offset, FieldWidth) << "\n " << Mapping.Filename << '\n'; } } template void GNUStyle::printNotes(const ELFFile *Obj) { auto PrintHeader = [&](const typename ELFT::Off Offset, const typename ELFT::Addr Size) { OS << "Displaying notes found at file offset " << format_hex(Offset, 10) << " with length " << format_hex(Size, 10) << ":\n" << " Owner Data size \tDescription\n"; }; auto ProcessNote = [&](const Elf_Note &Note) { StringRef Name = Note.getName(); ArrayRef Descriptor = Note.getDesc(); Elf_Word Type = Note.getType(); // Print the note owner/type. OS << " " << left_justify(Name, 20) << ' ' << format_hex(Descriptor.size(), 10) << '\t'; if (Name == "GNU") { OS << getGNUNoteTypeName(Type) << '\n'; } else if (Name == "FreeBSD") { OS << getFreeBSDNoteTypeName(Type) << '\n'; } else if (Name == "AMD") { OS << getAMDNoteTypeName(Type) << '\n'; } else if (Name == "AMDGPU") { OS << getAMDGPUNoteTypeName(Type) << '\n'; } else { StringRef NoteType = Obj->getHeader()->e_type == ELF::ET_CORE ? getCoreNoteTypeName(Type) : getGenericNoteTypeName(Type); if (!NoteType.empty()) OS << NoteType << '\n'; else OS << "Unknown note type: (" << format_hex(Type, 10) << ")\n"; } // Print the description, or fallback to printing raw bytes for unknown // owners. if (Name == "GNU") { printGNUNote(OS, Type, Descriptor); } else if (Name == "AMD") { const AMDNote N = getAMDNote(Type, Descriptor); if (!N.Type.empty()) OS << " " << N.Type << ":\n " << N.Value << '\n'; } else if (Name == "AMDGPU") { const AMDGPUNote N = getAMDGPUNote(Type, Descriptor); if (!N.Type.empty()) OS << " " << N.Type << ":\n " << N.Value << '\n'; } else if (Name == "CORE") { if (Type == ELF::NT_FILE) { DataExtractor DescExtractor(Descriptor, ELFT::TargetEndianness == support::little, sizeof(Elf_Addr)); Expected Note = readCoreNote(DescExtractor); if (Note) printCoreNote(OS, *Note); else reportWarning(Note.takeError(), this->FileName); } } else if (!Descriptor.empty()) { OS << " description data:"; for (uint8_t B : Descriptor) OS << " " << format("%02x", B); OS << '\n'; } }; ArrayRef Sections = unwrapOrError(this->FileName, Obj->sections()); if (Obj->getHeader()->e_type != ELF::ET_CORE && !Sections.empty()) { for (const auto &S : Sections) { if (S.sh_type != SHT_NOTE) continue; PrintHeader(S.sh_offset, S.sh_size); Error Err = Error::success(); for (auto Note : Obj->notes(S, Err)) ProcessNote(Note); if (Err) reportError(std::move(Err), this->FileName); } } else { for (const auto &P : unwrapOrError(this->FileName, Obj->program_headers())) { if (P.p_type != PT_NOTE) continue; PrintHeader(P.p_offset, P.p_filesz); Error Err = Error::success(); for (auto Note : Obj->notes(P, Err)) ProcessNote(Note); if (Err) reportError(std::move(Err), this->FileName); } } } template void GNUStyle::printELFLinkerOptions(const ELFFile *Obj) { OS << "printELFLinkerOptions not implemented!\n"; } template void GNUStyle::printDependentLibs(const ELFFile *Obj) { OS << "printDependentLibs not implemented!\n"; } // Used for printing section names in places where possible errors can be // ignored. static StringRef getSectionName(const SectionRef &Sec) { Expected NameOrErr = Sec.getName(); if (NameOrErr) return *NameOrErr; consumeError(NameOrErr.takeError()); return ""; } // Used for printing symbol names in places where possible errors can be // ignored. static std::string getSymbolName(const ELFSymbolRef &Sym) { Expected NameOrErr = Sym.getName(); if (NameOrErr) return maybeDemangle(*NameOrErr); consumeError(NameOrErr.takeError()); return ""; } template void DumpStyle::printFunctionStackSize( const ELFObjectFile *Obj, uint64_t SymValue, SectionRef FunctionSec, const StringRef SectionName, DataExtractor Data, uint64_t *Offset) { // This function ignores potentially erroneous input, unless it is directly // related to stack size reporting. SymbolRef FuncSym; for (const ELFSymbolRef &Symbol : Obj->symbols()) { Expected SymAddrOrErr = Symbol.getAddress(); if (!SymAddrOrErr) { consumeError(SymAddrOrErr.takeError()); continue; } if (Symbol.getELFType() == ELF::STT_FUNC && *SymAddrOrErr == SymValue) { // Check if the symbol is in the right section. if (FunctionSec.containsSymbol(Symbol)) { FuncSym = Symbol; break; } } } std::string FuncName = "?"; // A valid SymbolRef has a non-null object file pointer. if (FuncSym.BasicSymbolRef::getObject()) FuncName = getSymbolName(FuncSym); else reportWarning( createError("could not identify function symbol for stack size entry"), Obj->getFileName()); // Extract the size. The expectation is that Offset is pointing to the right // place, i.e. past the function address. uint64_t PrevOffset = *Offset; uint64_t StackSize = Data.getULEB128(Offset); // getULEB128() does not advance Offset if it is not able to extract a valid // integer. if (*Offset == PrevOffset) reportError( createStringError(object_error::parse_failed, "could not extract a valid stack size in section %s", SectionName.data()), Obj->getFileName()); printStackSizeEntry(StackSize, FuncName); } template void GNUStyle::printStackSizeEntry(uint64_t Size, StringRef FuncName) { OS.PadToColumn(2); OS << format_decimal(Size, 11); OS.PadToColumn(18); OS << FuncName << "\n"; } template void DumpStyle::printStackSize(const ELFObjectFile *Obj, RelocationRef Reloc, SectionRef FunctionSec, const StringRef &StackSizeSectionName, const RelocationResolver &Resolver, DataExtractor Data) { // This function ignores potentially erroneous input, unless it is directly // related to stack size reporting. object::symbol_iterator RelocSym = Reloc.getSymbol(); uint64_t RelocSymValue = 0; StringRef FileStr = Obj->getFileName(); if (RelocSym != Obj->symbol_end()) { // Ensure that the relocation symbol is in the function section, i.e. the // section where the functions whose stack sizes we are reporting are // located. auto SectionOrErr = RelocSym->getSection(); if (!SectionOrErr) { reportWarning( createError("cannot identify the section for relocation symbol '" + getSymbolName(*RelocSym) + "'"), FileStr); consumeError(SectionOrErr.takeError()); } else if (*SectionOrErr != FunctionSec) { reportWarning(createError("relocation symbol '" + getSymbolName(*RelocSym) + "' is not in the expected section"), FileStr); // Pretend that the symbol is in the correct section and report its // stack size anyway. FunctionSec = **SectionOrErr; } Expected RelocSymValueOrErr = RelocSym->getValue(); if (RelocSymValueOrErr) RelocSymValue = *RelocSymValueOrErr; else consumeError(RelocSymValueOrErr.takeError()); } uint64_t Offset = Reloc.getOffset(); if (!Data.isValidOffsetForDataOfSize(Offset, sizeof(Elf_Addr) + 1)) reportError( createStringError(object_error::parse_failed, "found invalid relocation offset into section %s " "while trying to extract a stack size entry", StackSizeSectionName.data()), FileStr); uint64_t Addend = Data.getAddress(&Offset); uint64_t SymValue = Resolver(Reloc, RelocSymValue, Addend); this->printFunctionStackSize(Obj, SymValue, FunctionSec, StackSizeSectionName, Data, &Offset); } template void DumpStyle::printNonRelocatableStackSizes( const ELFObjectFile *Obj, std::function PrintHeader) { // This function ignores potentially erroneous input, unless it is directly // related to stack size reporting. const ELFFile *EF = Obj->getELFFile(); StringRef FileStr = Obj->getFileName(); for (const SectionRef &Sec : Obj->sections()) { StringRef SectionName = getSectionName(Sec); if (SectionName != ".stack_sizes") continue; PrintHeader(); const Elf_Shdr *ElfSec = Obj->getSection(Sec.getRawDataRefImpl()); ArrayRef Contents = unwrapOrError(this->FileName, EF->getSectionContents(ElfSec)); DataExtractor Data(Contents, Obj->isLittleEndian(), sizeof(Elf_Addr)); // A .stack_sizes section header's sh_link field is supposed to point // to the section that contains the functions whose stack sizes are // described in it. const Elf_Shdr *FunctionELFSec = unwrapOrError(this->FileName, EF->getSection(ElfSec->sh_link)); uint64_t Offset = 0; while (Offset < Contents.size()) { // The function address is followed by a ULEB representing the stack // size. Check for an extra byte before we try to process the entry. if (!Data.isValidOffsetForDataOfSize(Offset, sizeof(Elf_Addr) + 1)) { reportError( createStringError( object_error::parse_failed, "section %s ended while trying to extract a stack size entry", SectionName.data()), FileStr); } uint64_t SymValue = Data.getAddress(&Offset); printFunctionStackSize(Obj, SymValue, Obj->toSectionRef(FunctionELFSec), SectionName, Data, &Offset); } } } template void DumpStyle::printRelocatableStackSizes( const ELFObjectFile *Obj, std::function PrintHeader) { const ELFFile *EF = Obj->getELFFile(); // Build a map between stack size sections and their corresponding relocation // sections. llvm::MapVector StackSizeRelocMap; const SectionRef NullSection{}; for (const SectionRef &Sec : Obj->sections()) { StringRef SectionName; if (Expected NameOrErr = Sec.getName()) SectionName = *NameOrErr; else consumeError(NameOrErr.takeError()); // A stack size section that we haven't encountered yet is mapped to the // null section until we find its corresponding relocation section. if (SectionName == ".stack_sizes") if (StackSizeRelocMap.count(Sec) == 0) { StackSizeRelocMap[Sec] = NullSection; continue; } // Check relocation sections if they are relocating contents of a // stack sizes section. const Elf_Shdr *ElfSec = Obj->getSection(Sec.getRawDataRefImpl()); uint32_t SectionType = ElfSec->sh_type; if (SectionType != ELF::SHT_RELA && SectionType != ELF::SHT_REL) continue; Expected RelSecOrErr = Sec.getRelocatedSection(); if (!RelSecOrErr) reportError(createStringError(object_error::parse_failed, "%s: failed to get a relocated section: %s", SectionName.data(), toString(RelSecOrErr.takeError()).c_str()), Obj->getFileName()); const Elf_Shdr *ContentsSec = Obj->getSection((*RelSecOrErr)->getRawDataRefImpl()); Expected ContentsSectionNameOrErr = EF->getSectionName(ContentsSec); if (!ContentsSectionNameOrErr) { consumeError(ContentsSectionNameOrErr.takeError()); continue; } if (*ContentsSectionNameOrErr != ".stack_sizes") continue; // Insert a mapping from the stack sizes section to its relocation section. StackSizeRelocMap[Obj->toSectionRef(ContentsSec)] = Sec; } for (const auto &StackSizeMapEntry : StackSizeRelocMap) { PrintHeader(); const SectionRef &StackSizesSec = StackSizeMapEntry.first; const SectionRef &RelocSec = StackSizeMapEntry.second; // Warn about stack size sections without a relocation section. StringRef StackSizeSectionName = getSectionName(StackSizesSec); if (RelocSec == NullSection) { reportWarning(createError("section " + StackSizeSectionName + " does not have a corresponding " "relocation section"), Obj->getFileName()); continue; } // A .stack_sizes section header's sh_link field is supposed to point // to the section that contains the functions whose stack sizes are // described in it. const Elf_Shdr *StackSizesELFSec = Obj->getSection(StackSizesSec.getRawDataRefImpl()); const SectionRef FunctionSec = Obj->toSectionRef(unwrapOrError( this->FileName, EF->getSection(StackSizesELFSec->sh_link))); bool (*IsSupportedFn)(uint64_t); RelocationResolver Resolver; std::tie(IsSupportedFn, Resolver) = getRelocationResolver(*Obj); auto Contents = unwrapOrError(this->FileName, StackSizesSec.getContents()); DataExtractor Data(Contents, Obj->isLittleEndian(), sizeof(Elf_Addr)); for (const RelocationRef &Reloc : RelocSec.relocations()) { if (!IsSupportedFn || !IsSupportedFn(Reloc.getType())) reportError(createStringError( object_error::parse_failed, "unsupported relocation type in section %s: %s", getSectionName(RelocSec).data(), EF->getRelocationTypeName(Reloc.getType()).data()), Obj->getFileName()); this->printStackSize(Obj, Reloc, FunctionSec, StackSizeSectionName, Resolver, Data); } } } template void GNUStyle::printStackSizes(const ELFObjectFile *Obj) { bool HeaderHasBeenPrinted = false; auto PrintHeader = [&]() { if (HeaderHasBeenPrinted) return; OS << "\nStack Sizes:\n"; OS.PadToColumn(9); OS << "Size"; OS.PadToColumn(18); OS << "Function\n"; HeaderHasBeenPrinted = true; }; // For non-relocatable objects, look directly for sections whose name starts // with .stack_sizes and process the contents. if (Obj->isRelocatableObject()) this->printRelocatableStackSizes(Obj, PrintHeader); else this->printNonRelocatableStackSizes(Obj, PrintHeader); } template void GNUStyle::printMipsGOT(const MipsGOTParser &Parser) { size_t Bias = ELFT::Is64Bits ? 8 : 0; auto PrintEntry = [&](const Elf_Addr *E, StringRef Purpose) { OS.PadToColumn(2); OS << format_hex_no_prefix(Parser.getGotAddress(E), 8 + Bias); OS.PadToColumn(11 + Bias); OS << format_decimal(Parser.getGotOffset(E), 6) << "(gp)"; OS.PadToColumn(22 + Bias); OS << format_hex_no_prefix(*E, 8 + Bias); OS.PadToColumn(31 + 2 * Bias); OS << Purpose << "\n"; }; OS << (Parser.IsStatic ? "Static GOT:\n" : "Primary GOT:\n"); OS << " Canonical gp value: " << format_hex_no_prefix(Parser.getGp(), 8 + Bias) << "\n\n"; OS << " Reserved entries:\n"; if (ELFT::Is64Bits) OS << " Address Access Initial Purpose\n"; else OS << " Address Access Initial Purpose\n"; PrintEntry(Parser.getGotLazyResolver(), "Lazy resolver"); if (Parser.getGotModulePointer()) PrintEntry(Parser.getGotModulePointer(), "Module pointer (GNU extension)"); if (!Parser.getLocalEntries().empty()) { OS << "\n"; OS << " Local entries:\n"; if (ELFT::Is64Bits) OS << " Address Access Initial\n"; else OS << " Address Access Initial\n"; for (auto &E : Parser.getLocalEntries()) PrintEntry(&E, ""); } if (Parser.IsStatic) return; if (!Parser.getGlobalEntries().empty()) { OS << "\n"; OS << " Global entries:\n"; if (ELFT::Is64Bits) OS << " Address Access Initial Sym.Val." << " Type Ndx Name\n"; else OS << " Address Access Initial Sym.Val. Type Ndx Name\n"; for (auto &E : Parser.getGlobalEntries()) { const Elf_Sym *Sym = Parser.getGotSym(&E); std::string SymName = this->dumper()->getFullSymbolName( Sym, this->dumper()->getDynamicStringTable(), false); OS.PadToColumn(2); OS << to_string(format_hex_no_prefix(Parser.getGotAddress(&E), 8 + Bias)); OS.PadToColumn(11 + Bias); OS << to_string(format_decimal(Parser.getGotOffset(&E), 6)) + "(gp)"; OS.PadToColumn(22 + Bias); OS << to_string(format_hex_no_prefix(E, 8 + Bias)); OS.PadToColumn(31 + 2 * Bias); OS << to_string(format_hex_no_prefix(Sym->st_value, 8 + Bias)); OS.PadToColumn(40 + 3 * Bias); OS << printEnum(Sym->getType(), makeArrayRef(ElfSymbolTypes)); OS.PadToColumn(48 + 3 * Bias); OS << getSymbolSectionNdx(Parser.Obj, Sym, this->dumper()->dynamic_symbols().begin()); OS.PadToColumn(52 + 3 * Bias); OS << SymName << "\n"; } } if (!Parser.getOtherEntries().empty()) OS << "\n Number of TLS and multi-GOT entries " << Parser.getOtherEntries().size() << "\n"; } template void GNUStyle::printMipsPLT(const MipsGOTParser &Parser) { size_t Bias = ELFT::Is64Bits ? 8 : 0; auto PrintEntry = [&](const Elf_Addr *E, StringRef Purpose) { OS.PadToColumn(2); OS << format_hex_no_prefix(Parser.getPltAddress(E), 8 + Bias); OS.PadToColumn(11 + Bias); OS << format_hex_no_prefix(*E, 8 + Bias); OS.PadToColumn(20 + 2 * Bias); OS << Purpose << "\n"; }; OS << "PLT GOT:\n\n"; OS << " Reserved entries:\n"; OS << " Address Initial Purpose\n"; PrintEntry(Parser.getPltLazyResolver(), "PLT lazy resolver"); if (Parser.getPltModulePointer()) PrintEntry(Parser.getPltModulePointer(), "Module pointer"); if (!Parser.getPltEntries().empty()) { OS << "\n"; OS << " Entries:\n"; OS << " Address Initial Sym.Val. Type Ndx Name\n"; for (auto &E : Parser.getPltEntries()) { const Elf_Sym *Sym = Parser.getPltSym(&E); std::string SymName = this->dumper()->getFullSymbolName( Sym, this->dumper()->getDynamicStringTable(), false); OS.PadToColumn(2); OS << to_string(format_hex_no_prefix(Parser.getPltAddress(&E), 8 + Bias)); OS.PadToColumn(11 + Bias); OS << to_string(format_hex_no_prefix(E, 8 + Bias)); OS.PadToColumn(20 + 2 * Bias); OS << to_string(format_hex_no_prefix(Sym->st_value, 8 + Bias)); OS.PadToColumn(29 + 3 * Bias); OS << printEnum(Sym->getType(), makeArrayRef(ElfSymbolTypes)); OS.PadToColumn(37 + 3 * Bias); OS << getSymbolSectionNdx(Parser.Obj, Sym, this->dumper()->dynamic_symbols().begin()); OS.PadToColumn(41 + 3 * Bias); OS << SymName << "\n"; } } } template void GNUStyle::printMipsABIFlags(const ELFObjectFile *ObjF) { const ELFFile *Obj = ObjF->getELFFile(); const Elf_Shdr *Shdr = findSectionByName(*Obj, ObjF->getFileName(), ".MIPS.abiflags"); if (!Shdr) return; ArrayRef Sec = unwrapOrError(ObjF->getFileName(), Obj->getSectionContents(Shdr)); if (Sec.size() != sizeof(Elf_Mips_ABIFlags)) reportError(createError(".MIPS.abiflags section has a wrong size"), ObjF->getFileName()); auto *Flags = reinterpret_cast *>(Sec.data()); OS << "MIPS ABI Flags Version: " << Flags->version << "\n\n"; OS << "ISA: MIPS" << int(Flags->isa_level); if (Flags->isa_rev > 1) OS << "r" << int(Flags->isa_rev); OS << "\n"; OS << "GPR size: " << getMipsRegisterSize(Flags->gpr_size) << "\n"; OS << "CPR1 size: " << getMipsRegisterSize(Flags->cpr1_size) << "\n"; OS << "CPR2 size: " << getMipsRegisterSize(Flags->cpr2_size) << "\n"; OS << "FP ABI: " << printEnum(Flags->fp_abi, makeArrayRef(ElfMipsFpABIType)) << "\n"; OS << "ISA Extension: " << printEnum(Flags->isa_ext, makeArrayRef(ElfMipsISAExtType)) << "\n"; if (Flags->ases == 0) OS << "ASEs: None\n"; else // FIXME: Print each flag on a separate line. OS << "ASEs: " << printFlags(Flags->ases, makeArrayRef(ElfMipsASEFlags)) << "\n"; OS << "FLAGS 1: " << format_hex_no_prefix(Flags->flags1, 8, false) << "\n"; OS << "FLAGS 2: " << format_hex_no_prefix(Flags->flags2, 8, false) << "\n"; OS << "\n"; } template void LLVMStyle::printFileHeaders(const ELFO *Obj) { const Elf_Ehdr *E = Obj->getHeader(); { DictScope D(W, "ElfHeader"); { DictScope D(W, "Ident"); W.printBinary("Magic", makeArrayRef(E->e_ident).slice(ELF::EI_MAG0, 4)); W.printEnum("Class", E->e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass)); W.printEnum("DataEncoding", E->e_ident[ELF::EI_DATA], makeArrayRef(ElfDataEncoding)); W.printNumber("FileVersion", E->e_ident[ELF::EI_VERSION]); auto OSABI = makeArrayRef(ElfOSABI); if (E->e_ident[ELF::EI_OSABI] >= ELF::ELFOSABI_FIRST_ARCH && E->e_ident[ELF::EI_OSABI] <= ELF::ELFOSABI_LAST_ARCH) { switch (E->e_machine) { case ELF::EM_AMDGPU: OSABI = makeArrayRef(AMDGPUElfOSABI); break; case ELF::EM_ARM: OSABI = makeArrayRef(ARMElfOSABI); break; case ELF::EM_TI_C6000: OSABI = makeArrayRef(C6000ElfOSABI); break; } } W.printEnum("OS/ABI", E->e_ident[ELF::EI_OSABI], OSABI); W.printNumber("ABIVersion", E->e_ident[ELF::EI_ABIVERSION]); W.printBinary("Unused", makeArrayRef(E->e_ident).slice(ELF::EI_PAD)); } W.printEnum("Type", E->e_type, makeArrayRef(ElfObjectFileType)); W.printEnum("Machine", E->e_machine, makeArrayRef(ElfMachineType)); W.printNumber("Version", E->e_version); W.printHex("Entry", E->e_entry); W.printHex("ProgramHeaderOffset", E->e_phoff); W.printHex("SectionHeaderOffset", E->e_shoff); if (E->e_machine == EM_MIPS) W.printFlags("Flags", E->e_flags, makeArrayRef(ElfHeaderMipsFlags), unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI), unsigned(ELF::EF_MIPS_MACH)); else if (E->e_machine == EM_AMDGPU) W.printFlags("Flags", E->e_flags, makeArrayRef(ElfHeaderAMDGPUFlags), unsigned(ELF::EF_AMDGPU_MACH)); else if (E->e_machine == EM_RISCV) W.printFlags("Flags", E->e_flags, makeArrayRef(ElfHeaderRISCVFlags)); else W.printFlags("Flags", E->e_flags); W.printNumber("HeaderSize", E->e_ehsize); W.printNumber("ProgramHeaderEntrySize", E->e_phentsize); W.printNumber("ProgramHeaderCount", E->e_phnum); W.printNumber("SectionHeaderEntrySize", E->e_shentsize); W.printString("SectionHeaderCount", getSectionHeadersNumString(Obj, this->FileName)); W.printString("StringTableSectionIndex", getSectionHeaderTableIndexString(Obj, this->FileName)); } } template void LLVMStyle::printGroupSections(const ELFO *Obj) { DictScope Lists(W, "Groups"); std::vector V = getGroups(Obj, this->FileName); DenseMap Map = mapSectionsToGroups(V); for (const GroupSection &G : V) { DictScope D(W, "Group"); W.printNumber("Name", G.Name, G.ShName); W.printNumber("Index", G.Index); W.printNumber("Link", G.Link); W.printNumber("Info", G.Info); W.printHex("Type", getGroupType(G.Type), G.Type); W.startLine() << "Signature: " << G.Signature << "\n"; ListScope L(W, "Section(s) in group"); for (const GroupMember &GM : G.Members) { const GroupSection *MainGroup = Map[GM.Index]; if (MainGroup != &G) { W.flush(); errs() << "Error: " << GM.Name << " (" << GM.Index << ") in a group " + G.Name + " (" << G.Index << ") is already in a group " + MainGroup->Name + " (" << MainGroup->Index << ")\n"; errs().flush(); continue; } W.startLine() << GM.Name << " (" << GM.Index << ")\n"; } } if (V.empty()) W.startLine() << "There are no group sections in the file.\n"; } template void LLVMStyle::printRelocations(const ELFO *Obj) { ListScope D(W, "Relocations"); int SectionNumber = -1; for (const Elf_Shdr &Sec : unwrapOrError(this->FileName, Obj->sections())) { ++SectionNumber; if (Sec.sh_type != ELF::SHT_REL && Sec.sh_type != ELF::SHT_RELA && Sec.sh_type != ELF::SHT_RELR && Sec.sh_type != ELF::SHT_ANDROID_REL && Sec.sh_type != ELF::SHT_ANDROID_RELA && Sec.sh_type != ELF::SHT_ANDROID_RELR) continue; StringRef Name = unwrapOrError(this->FileName, Obj->getSectionName(&Sec)); W.startLine() << "Section (" << SectionNumber << ") " << Name << " {\n"; W.indent(); printRelocations(&Sec, Obj); W.unindent(); W.startLine() << "}\n"; } } template void LLVMStyle::printRelocations(const Elf_Shdr *Sec, const ELFO *Obj) { const Elf_Shdr *SymTab = unwrapOrError(this->FileName, Obj->getSection(Sec->sh_link)); switch (Sec->sh_type) { case ELF::SHT_REL: for (const Elf_Rel &R : unwrapOrError(this->FileName, Obj->rels(Sec))) { Elf_Rela Rela; Rela.r_offset = R.r_offset; Rela.r_info = R.r_info; Rela.r_addend = 0; printRelocation(Obj, Rela, SymTab); } break; case ELF::SHT_RELA: for (const Elf_Rela &R : unwrapOrError(this->FileName, Obj->relas(Sec))) printRelocation(Obj, R, SymTab); break; case ELF::SHT_RELR: case ELF::SHT_ANDROID_RELR: { Elf_Relr_Range Relrs = unwrapOrError(this->FileName, Obj->relrs(Sec)); if (opts::RawRelr) { for (const Elf_Relr &R : Relrs) W.startLine() << W.hex(R) << "\n"; } else { std::vector RelrRelas = unwrapOrError(this->FileName, Obj->decode_relrs(Relrs)); for (const Elf_Rela &R : RelrRelas) printRelocation(Obj, R, SymTab); } break; } case ELF::SHT_ANDROID_REL: case ELF::SHT_ANDROID_RELA: for (const Elf_Rela &R : unwrapOrError(this->FileName, Obj->android_relas(Sec))) printRelocation(Obj, R, SymTab); break; } } template void LLVMStyle::printRelocation(const ELFO *Obj, Elf_Rela Rel, const Elf_Shdr *SymTab) { SmallString<32> RelocName; Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName); std::string TargetName; const Elf_Sym *Sym = unwrapOrError(this->FileName, Obj->getRelocationSymbol(&Rel, SymTab)); if (Sym && Sym->getType() == ELF::STT_SECTION) { const Elf_Shdr *Sec = unwrapOrError( this->FileName, Obj->getSection(Sym, SymTab, this->dumper()->getShndxTable())); TargetName = unwrapOrError(this->FileName, Obj->getSectionName(Sec)); } else if (Sym) { StringRef StrTable = unwrapOrError(this->FileName, Obj->getStringTableForSymtab(*SymTab)); TargetName = this->dumper()->getFullSymbolName( Sym, StrTable, SymTab->sh_type == SHT_DYNSYM /* IsDynamic */); } if (opts::ExpandRelocs) { DictScope Group(W, "Relocation"); W.printHex("Offset", Rel.r_offset); W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL())); W.printNumber("Symbol", !TargetName.empty() ? TargetName : "-", Rel.getSymbol(Obj->isMips64EL())); W.printHex("Addend", Rel.r_addend); } else { raw_ostream &OS = W.startLine(); OS << W.hex(Rel.r_offset) << " " << RelocName << " " << (!TargetName.empty() ? TargetName : "-") << " " << W.hex(Rel.r_addend) << "\n"; } } template void LLVMStyle::printSectionHeaders(const ELFO *Obj) { ListScope SectionsD(W, "Sections"); int SectionIndex = -1; ArrayRef Sections = unwrapOrError(this->FileName, Obj->sections()); const ELFObjectFile *ElfObj = this->dumper()->getElfObject(); std::vector> FlagsList = getSectionFlagsForTarget(Obj->getHeader()->e_machine); for (const Elf_Shdr &Sec : Sections) { StringRef Name = unwrapOrError( ElfObj->getFileName(), Obj->getSectionName(&Sec, this->WarningHandler)); DictScope SectionD(W, "Section"); W.printNumber("Index", ++SectionIndex); W.printNumber("Name", Name, Sec.sh_name); W.printHex( "Type", object::getELFSectionTypeName(Obj->getHeader()->e_machine, Sec.sh_type), Sec.sh_type); W.printFlags("Flags", Sec.sh_flags, makeArrayRef(FlagsList)); W.printHex("Address", Sec.sh_addr); W.printHex("Offset", Sec.sh_offset); W.printNumber("Size", Sec.sh_size); W.printNumber("Link", Sec.sh_link); W.printNumber("Info", Sec.sh_info); W.printNumber("AddressAlignment", Sec.sh_addralign); W.printNumber("EntrySize", Sec.sh_entsize); if (opts::SectionRelocations) { ListScope D(W, "Relocations"); printRelocations(&Sec, Obj); } if (opts::SectionSymbols) { ListScope D(W, "Symbols"); const Elf_Shdr *Symtab = this->dumper()->getDotSymtabSec(); StringRef StrTable = unwrapOrError(this->FileName, Obj->getStringTableForSymtab(*Symtab)); for (const Elf_Sym &Sym : unwrapOrError(this->FileName, Obj->symbols(Symtab))) { const Elf_Shdr *SymSec = unwrapOrError( this->FileName, Obj->getSection(&Sym, Symtab, this->dumper()->getShndxTable())); if (SymSec == &Sec) printSymbol( Obj, &Sym, unwrapOrError(this->FileName, Obj->symbols(Symtab)).begin(), StrTable, false, false); } } if (opts::SectionData && Sec.sh_type != ELF::SHT_NOBITS) { ArrayRef Data = unwrapOrError(this->FileName, Obj->getSectionContents(&Sec)); W.printBinaryBlock( "SectionData", StringRef(reinterpret_cast(Data.data()), Data.size())); } } } template void LLVMStyle::printSymbolSection(const Elf_Sym *Symbol, const Elf_Sym *First) { Expected SectionIndex = this->dumper()->getSymbolSectionIndex(Symbol, First); if (!SectionIndex) { assert(Symbol->st_shndx == SHN_XINDEX && "getSymbolSectionIndex should only fail due to an invalid " "SHT_SYMTAB_SHNDX table/reference"); this->reportUniqueWarning(SectionIndex.takeError()); W.printHex("Section", "Reserved", SHN_XINDEX); return; } Expected SectionName = this->dumper()->getSymbolSectionName(Symbol, *SectionIndex); if (!SectionName) { this->reportUniqueWarning(SectionName.takeError()); W.printHex("Section", "", *SectionIndex); } else { W.printHex("Section", *SectionName, *SectionIndex); } } template void LLVMStyle::printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, const Elf_Sym *First, StringRef StrTable, bool IsDynamic, bool /*NonVisibilityBitsUsed*/) { std::string FullSymbolName = this->dumper()->getFullSymbolName(Symbol, StrTable, IsDynamic); unsigned char SymbolType = Symbol->getType(); DictScope D(W, "Symbol"); W.printNumber("Name", FullSymbolName, Symbol->st_name); W.printHex("Value", Symbol->st_value); W.printNumber("Size", Symbol->st_size); W.printEnum("Binding", Symbol->getBinding(), makeArrayRef(ElfSymbolBindings)); if (Obj->getHeader()->e_machine == ELF::EM_AMDGPU && SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS) W.printEnum("Type", SymbolType, makeArrayRef(AMDGPUSymbolTypes)); else W.printEnum("Type", SymbolType, makeArrayRef(ElfSymbolTypes)); if (Symbol->st_other == 0) // Usually st_other flag is zero. Do not pollute the output // by flags enumeration in that case. W.printNumber("Other", 0); else { std::vector> SymOtherFlags(std::begin(ElfSymOtherFlags), std::end(ElfSymOtherFlags)); if (Obj->getHeader()->e_machine == EM_MIPS) { // Someones in their infinite wisdom decided to make STO_MIPS_MIPS16 // flag overlapped with other ST_MIPS_xxx flags. So consider both // cases separately. if ((Symbol->st_other & STO_MIPS_MIPS16) == STO_MIPS_MIPS16) SymOtherFlags.insert(SymOtherFlags.end(), std::begin(ElfMips16SymOtherFlags), std::end(ElfMips16SymOtherFlags)); else SymOtherFlags.insert(SymOtherFlags.end(), std::begin(ElfMipsSymOtherFlags), std::end(ElfMipsSymOtherFlags)); } W.printFlags("Other", Symbol->st_other, makeArrayRef(SymOtherFlags), 0x3u); } printSymbolSection(Symbol, First); } template void LLVMStyle::printSymbols(const ELFO *Obj, bool PrintSymbols, bool PrintDynamicSymbols) { if (PrintSymbols) printSymbols(Obj); if (PrintDynamicSymbols) printDynamicSymbols(Obj); } template void LLVMStyle::printSymbols(const ELFO *Obj) { ListScope Group(W, "Symbols"); this->dumper()->printSymbolsHelper(false); } template void LLVMStyle::printDynamicSymbols(const ELFO *Obj) { ListScope Group(W, "DynamicSymbols"); this->dumper()->printSymbolsHelper(true); } template void LLVMStyle::printDynamic(const ELFFile *Obj) { Elf_Dyn_Range Table = this->dumper()->dynamic_table(); if (Table.empty()) return; raw_ostream &OS = W.getOStream(); W.startLine() << "DynamicSection [ (" << Table.size() << " entries)\n"; bool Is64 = ELFT::Is64Bits; if (Is64) W.startLine() << " Tag Type Name/Value\n"; else W.startLine() << " Tag Type Name/Value\n"; for (auto Entry : Table) { uintX_t Tag = Entry.getTag(); W.startLine() << " " << format_hex(Tag, Is64 ? 18 : 10, true) << " " << format("%-21s", Obj->getDynamicTagAsString(Tag).c_str()); this->dumper()->printDynamicEntry(OS, Tag, Entry.getVal()); OS << "\n"; } W.startLine() << "]\n"; } template void LLVMStyle::printDynamicRelocations(const ELFO *Obj) { const DynRegionInfo &DynRelRegion = this->dumper()->getDynRelRegion(); const DynRegionInfo &DynRelaRegion = this->dumper()->getDynRelaRegion(); const DynRegionInfo &DynRelrRegion = this->dumper()->getDynRelrRegion(); const DynRegionInfo &DynPLTRelRegion = this->dumper()->getDynPLTRelRegion(); if (DynRelRegion.Size && DynRelaRegion.Size) report_fatal_error("There are both REL and RELA dynamic relocations"); W.startLine() << "Dynamic Relocations {\n"; W.indent(); if (DynRelaRegion.Size > 0) for (const Elf_Rela &Rela : this->dumper()->dyn_relas()) printDynamicRelocation(Obj, Rela); else for (const Elf_Rel &Rel : this->dumper()->dyn_rels()) { Elf_Rela Rela; Rela.r_offset = Rel.r_offset; Rela.r_info = Rel.r_info; Rela.r_addend = 0; printDynamicRelocation(Obj, Rela); } if (DynRelrRegion.Size > 0) { Elf_Relr_Range Relrs = this->dumper()->dyn_relrs(); std::vector RelrRelas = unwrapOrError(this->FileName, Obj->decode_relrs(Relrs)); for (const Elf_Rela &Rela : RelrRelas) printDynamicRelocation(Obj, Rela); } if (DynPLTRelRegion.EntSize == sizeof(Elf_Rela)) for (const Elf_Rela &Rela : DynPLTRelRegion.getAsArrayRef()) printDynamicRelocation(Obj, Rela); else for (const Elf_Rel &Rel : DynPLTRelRegion.getAsArrayRef()) { Elf_Rela Rela; Rela.r_offset = Rel.r_offset; Rela.r_info = Rel.r_info; Rela.r_addend = 0; printDynamicRelocation(Obj, Rela); } W.unindent(); W.startLine() << "}\n"; } template void LLVMStyle::printDynamicRelocation(const ELFO *Obj, Elf_Rela Rel) { SmallString<32> RelocName; Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName); std::string SymbolName = getSymbolForReloc(Obj, this->FileName, this->dumper(), Rel).Name; if (opts::ExpandRelocs) { DictScope Group(W, "Relocation"); W.printHex("Offset", Rel.r_offset); W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL())); W.printString("Symbol", !SymbolName.empty() ? SymbolName : "-"); W.printHex("Addend", Rel.r_addend); } else { raw_ostream &OS = W.startLine(); OS << W.hex(Rel.r_offset) << " " << RelocName << " " << (!SymbolName.empty() ? SymbolName : "-") << " " << W.hex(Rel.r_addend) << "\n"; } } template void LLVMStyle::printProgramHeaders( const ELFO *Obj, bool PrintProgramHeaders, cl::boolOrDefault PrintSectionMapping) { if (PrintProgramHeaders) printProgramHeaders(Obj); if (PrintSectionMapping == cl::BOU_TRUE) printSectionMapping(Obj); } template void LLVMStyle::printProgramHeaders(const ELFO *Obj) { ListScope L(W, "ProgramHeaders"); for (const Elf_Phdr &Phdr : unwrapOrError(this->FileName, Obj->program_headers())) { DictScope P(W, "ProgramHeader"); W.printHex("Type", getElfSegmentType(Obj->getHeader()->e_machine, Phdr.p_type), Phdr.p_type); W.printHex("Offset", Phdr.p_offset); W.printHex("VirtualAddress", Phdr.p_vaddr); W.printHex("PhysicalAddress", Phdr.p_paddr); W.printNumber("FileSize", Phdr.p_filesz); W.printNumber("MemSize", Phdr.p_memsz); W.printFlags("Flags", Phdr.p_flags, makeArrayRef(ElfSegmentFlags)); W.printNumber("Alignment", Phdr.p_align); } } template void LLVMStyle::printVersionSymbolSection(const ELFFile *Obj, const Elf_Shdr *Sec) { ListScope SS(W, "VersionSymbols"); if (!Sec) return; StringRef StrTable; ArrayRef Syms; Expected> VerTableOrErr = this->dumper()->getVersionTable(Sec, &Syms, &StrTable); if (!VerTableOrErr) { this->reportUniqueWarning(VerTableOrErr.takeError()); return; } if (StrTable.empty() || Syms.empty() || Syms.size() != VerTableOrErr->size()) return; for (size_t I = 0, E = Syms.size(); I < E; ++I) { DictScope S(W, "Symbol"); W.printNumber("Version", (*VerTableOrErr)[I].vs_index & VERSYM_VERSION); W.printString("Name", this->dumper()->getFullSymbolName( &Syms[I], StrTable, /*IsDynamic=*/true)); } } template void LLVMStyle::printVersionDefinitionSection(const ELFFile *Obj, const Elf_Shdr *Sec) { ListScope SD(W, "VersionDefinitions"); if (!Sec) return; Expected> V = this->dumper()->getVersionDefinitions(Sec); if (!V) { this->reportUniqueWarning(V.takeError()); return; } for (const VerDef &D : *V) { DictScope Def(W, "Definition"); W.printNumber("Version", D.Version); W.printFlags("Flags", D.Flags, makeArrayRef(SymVersionFlags)); W.printNumber("Index", D.Ndx); W.printNumber("Hash", D.Hash); W.printString("Name", D.Name.c_str()); W.printList( "Predecessors", D.AuxV, [](raw_ostream &OS, const VerdAux &Aux) { OS << Aux.Name.c_str(); }); } } template void LLVMStyle::printVersionDependencySection(const ELFFile *Obj, const Elf_Shdr *Sec) { ListScope SD(W, "VersionRequirements"); if (!Sec) return; Expected> V = this->dumper()->getVersionDependencies(Sec); if (!V) { this->reportUniqueWarning(V.takeError()); return; } for (const VerNeed &VN : *V) { DictScope Entry(W, "Dependency"); W.printNumber("Version", VN.Version); W.printNumber("Count", VN.Cnt); W.printString("FileName", VN.File.c_str()); ListScope L(W, "Entries"); for (const VernAux &Aux : VN.AuxV) { DictScope Entry(W, "Entry"); W.printNumber("Hash", Aux.Hash); W.printFlags("Flags", Aux.Flags, makeArrayRef(SymVersionFlags)); W.printNumber("Index", Aux.Other); W.printString("Name", Aux.Name.c_str()); } } } template void LLVMStyle::printHashHistogram(const ELFFile *Obj) { W.startLine() << "Hash Histogram not implemented!\n"; } template void LLVMStyle::printCGProfile(const ELFFile *Obj) { ListScope L(W, "CGProfile"); if (!this->dumper()->getDotCGProfileSec()) return; auto CGProfile = unwrapOrError( this->FileName, Obj->template getSectionContentsAsArray( this->dumper()->getDotCGProfileSec())); for (const Elf_CGProfile &CGPE : CGProfile) { DictScope D(W, "CGProfileEntry"); W.printNumber( "From", unwrapOrError(this->FileName, this->dumper()->getStaticSymbolName(CGPE.cgp_from)), CGPE.cgp_from); W.printNumber( "To", unwrapOrError(this->FileName, this->dumper()->getStaticSymbolName(CGPE.cgp_to)), CGPE.cgp_to); W.printNumber("Weight", CGPE.cgp_weight); } } static Expected> toULEB128Array(ArrayRef Data) { std::vector Ret; const uint8_t *Cur = Data.begin(); const uint8_t *End = Data.end(); while (Cur != End) { unsigned Size; const char *Err; Ret.push_back(decodeULEB128(Cur, &Size, End, &Err)); if (Err) return createError(Err); Cur += Size; } return Ret; } template void LLVMStyle::printAddrsig(const ELFFile *Obj) { ListScope L(W, "Addrsig"); if (!this->dumper()->getDotAddrsigSec()) return; ArrayRef Contents = unwrapOrError( this->FileName, Obj->getSectionContents(this->dumper()->getDotAddrsigSec())); Expected> V = toULEB128Array(Contents); if (!V) { reportWarning(V.takeError(), this->FileName); return; } for (uint64_t Sym : *V) { Expected NameOrErr = this->dumper()->getStaticSymbolName(Sym); if (NameOrErr) { W.printNumber("Sym", *NameOrErr, Sym); continue; } reportWarning(NameOrErr.takeError(), this->FileName); W.printNumber("Sym", "", Sym); } } template static void printGNUNoteLLVMStyle(uint32_t NoteType, ArrayRef Desc, ScopedPrinter &W) { switch (NoteType) { default: return; case ELF::NT_GNU_ABI_TAG: { const GNUAbiTag &AbiTag = getGNUAbiTag(Desc); if (!AbiTag.IsValid) { W.printString("ABI", ""); } else { W.printString("OS", AbiTag.OSName); W.printString("ABI", AbiTag.ABI); } break; } case ELF::NT_GNU_BUILD_ID: { W.printString("Build ID", getGNUBuildId(Desc)); break; } case ELF::NT_GNU_GOLD_VERSION: W.printString("Version", getGNUGoldVersion(Desc)); break; case ELF::NT_GNU_PROPERTY_TYPE_0: ListScope D(W, "Property"); for (const auto &Property : getGNUPropertyList(Desc)) W.printString(Property); break; } } static void printCoreNoteLLVMStyle(const CoreNote &Note, ScopedPrinter &W) { W.printNumber("Page Size", Note.PageSize); for (const CoreFileMapping &Mapping : Note.Mappings) { ListScope D(W, "Mapping"); W.printHex("Start", Mapping.Start); W.printHex("End", Mapping.End); W.printHex("Offset", Mapping.Offset); W.printString("Filename", Mapping.Filename); } } template void LLVMStyle::printNotes(const ELFFile *Obj) { ListScope L(W, "Notes"); auto PrintHeader = [&](const typename ELFT::Off Offset, const typename ELFT::Addr Size) { W.printHex("Offset", Offset); W.printHex("Size", Size); }; auto ProcessNote = [&](const Elf_Note &Note) { DictScope D2(W, "Note"); StringRef Name = Note.getName(); ArrayRef Descriptor = Note.getDesc(); Elf_Word Type = Note.getType(); // Print the note owner/type. W.printString("Owner", Name); W.printHex("Data size", Descriptor.size()); if (Name == "GNU") { W.printString("Type", getGNUNoteTypeName(Type)); } else if (Name == "FreeBSD") { W.printString("Type", getFreeBSDNoteTypeName(Type)); } else if (Name == "AMD") { W.printString("Type", getAMDNoteTypeName(Type)); } else if (Name == "AMDGPU") { W.printString("Type", getAMDGPUNoteTypeName(Type)); } else { StringRef NoteType = Obj->getHeader()->e_type == ELF::ET_CORE ? getCoreNoteTypeName(Type) : getGenericNoteTypeName(Type); if (!NoteType.empty()) W.printString("Type", NoteType); else W.printString("Type", "Unknown (" + to_string(format_hex(Type, 10)) + ")"); } // Print the description, or fallback to printing raw bytes for unknown // owners. if (Name == "GNU") { printGNUNoteLLVMStyle(Type, Descriptor, W); } else if (Name == "AMD") { const AMDNote N = getAMDNote(Type, Descriptor); if (!N.Type.empty()) W.printString(N.Type, N.Value); } else if (Name == "AMDGPU") { const AMDGPUNote N = getAMDGPUNote(Type, Descriptor); if (!N.Type.empty()) W.printString(N.Type, N.Value); } else if (Name == "CORE") { if (Type == ELF::NT_FILE) { DataExtractor DescExtractor(Descriptor, ELFT::TargetEndianness == support::little, sizeof(Elf_Addr)); Expected Note = readCoreNote(DescExtractor); if (Note) printCoreNoteLLVMStyle(*Note, W); else reportWarning(Note.takeError(), this->FileName); } } else if (!Descriptor.empty()) { W.printBinaryBlock("Description data", Descriptor); } }; ArrayRef Sections = unwrapOrError(this->FileName, Obj->sections()); if (Obj->getHeader()->e_type != ELF::ET_CORE && !Sections.empty()) { for (const auto &S : Sections) { if (S.sh_type != SHT_NOTE) continue; DictScope D(W, "NoteSection"); PrintHeader(S.sh_offset, S.sh_size); Error Err = Error::success(); for (auto Note : Obj->notes(S, Err)) ProcessNote(Note); if (Err) reportError(std::move(Err), this->FileName); } } else { for (const auto &P : unwrapOrError(this->FileName, Obj->program_headers())) { if (P.p_type != PT_NOTE) continue; DictScope D(W, "NoteSection"); PrintHeader(P.p_offset, P.p_filesz); Error Err = Error::success(); for (auto Note : Obj->notes(P, Err)) ProcessNote(Note); if (Err) reportError(std::move(Err), this->FileName); } } } template void LLVMStyle::printELFLinkerOptions(const ELFFile *Obj) { ListScope L(W, "LinkerOptions"); unsigned I = -1; for (const Elf_Shdr &Shdr : unwrapOrError(this->FileName, Obj->sections())) { ++I; if (Shdr.sh_type != ELF::SHT_LLVM_LINKER_OPTIONS) continue; ArrayRef Contents = unwrapOrError(this->FileName, Obj->getSectionContents(&Shdr)); if (Contents.empty()) continue; if (Contents.back() != 0) { reportWarning(createError("SHT_LLVM_LINKER_OPTIONS section at index " + Twine(I) + " is broken: the " "content is not null-terminated"), this->FileName); continue; } SmallVector Strings; toStringRef(Contents.drop_back()).split(Strings, '\0'); if (Strings.size() % 2 != 0) { reportWarning( createError( "SHT_LLVM_LINKER_OPTIONS section at index " + Twine(I) + " is broken: an incomplete " "key-value pair was found. The last possible key was: \"" + Strings.back() + "\""), this->FileName); continue; } for (size_t I = 0; I < Strings.size(); I += 2) W.printString(Strings[I], Strings[I + 1]); } } template void LLVMStyle::printDependentLibs(const ELFFile *Obj) { ListScope L(W, "DependentLibs"); auto Warn = [this](unsigned SecNdx, StringRef Msg) { this->reportUniqueWarning( createError("SHT_LLVM_DEPENDENT_LIBRARIES section at index " + Twine(SecNdx) + " is broken: " + Msg)); }; unsigned I = -1; for (const Elf_Shdr &Shdr : unwrapOrError(this->FileName, Obj->sections())) { ++I; if (Shdr.sh_type != ELF::SHT_LLVM_DEPENDENT_LIBRARIES) continue; Expected> ContentsOrErr = Obj->getSectionContents(&Shdr); if (!ContentsOrErr) { Warn(I, toString(ContentsOrErr.takeError())); continue; } ArrayRef Contents = *ContentsOrErr; if (!Contents.empty() && Contents.back() != 0) { Warn(I, "the content is not null-terminated"); continue; } for (const uint8_t *I = Contents.begin(), *E = Contents.end(); I < E;) { StringRef Lib((const char *)I); W.printString(Lib); I += Lib.size() + 1; } } } template void LLVMStyle::printStackSizes(const ELFObjectFile *Obj) { ListScope L(W, "StackSizes"); if (Obj->isRelocatableObject()) this->printRelocatableStackSizes(Obj, []() {}); else this->printNonRelocatableStackSizes(Obj, []() {}); } template void LLVMStyle::printStackSizeEntry(uint64_t Size, StringRef FuncName) { DictScope D(W, "Entry"); W.printString("Function", FuncName); W.printHex("Size", Size); } template void LLVMStyle::printMipsGOT(const MipsGOTParser &Parser) { auto PrintEntry = [&](const Elf_Addr *E) { W.printHex("Address", Parser.getGotAddress(E)); W.printNumber("Access", Parser.getGotOffset(E)); W.printHex("Initial", *E); }; DictScope GS(W, Parser.IsStatic ? "Static GOT" : "Primary GOT"); W.printHex("Canonical gp value", Parser.getGp()); { ListScope RS(W, "Reserved entries"); { DictScope D(W, "Entry"); PrintEntry(Parser.getGotLazyResolver()); W.printString("Purpose", StringRef("Lazy resolver")); } if (Parser.getGotModulePointer()) { DictScope D(W, "Entry"); PrintEntry(Parser.getGotModulePointer()); W.printString("Purpose", StringRef("Module pointer (GNU extension)")); } } { ListScope LS(W, "Local entries"); for (auto &E : Parser.getLocalEntries()) { DictScope D(W, "Entry"); PrintEntry(&E); } } if (Parser.IsStatic) return; { ListScope GS(W, "Global entries"); for (auto &E : Parser.getGlobalEntries()) { DictScope D(W, "Entry"); PrintEntry(&E); const Elf_Sym *Sym = Parser.getGotSym(&E); W.printHex("Value", Sym->st_value); W.printEnum("Type", Sym->getType(), makeArrayRef(ElfSymbolTypes)); printSymbolSection(Sym, this->dumper()->dynamic_symbols().begin()); std::string SymName = this->dumper()->getFullSymbolName( Sym, this->dumper()->getDynamicStringTable(), true); W.printNumber("Name", SymName, Sym->st_name); } } W.printNumber("Number of TLS and multi-GOT entries", uint64_t(Parser.getOtherEntries().size())); } template void LLVMStyle::printMipsPLT(const MipsGOTParser &Parser) { auto PrintEntry = [&](const Elf_Addr *E) { W.printHex("Address", Parser.getPltAddress(E)); W.printHex("Initial", *E); }; DictScope GS(W, "PLT GOT"); { ListScope RS(W, "Reserved entries"); { DictScope D(W, "Entry"); PrintEntry(Parser.getPltLazyResolver()); W.printString("Purpose", StringRef("PLT lazy resolver")); } if (auto E = Parser.getPltModulePointer()) { DictScope D(W, "Entry"); PrintEntry(E); W.printString("Purpose", StringRef("Module pointer")); } } { ListScope LS(W, "Entries"); for (auto &E : Parser.getPltEntries()) { DictScope D(W, "Entry"); PrintEntry(&E); const Elf_Sym *Sym = Parser.getPltSym(&E); W.printHex("Value", Sym->st_value); W.printEnum("Type", Sym->getType(), makeArrayRef(ElfSymbolTypes)); printSymbolSection(Sym, this->dumper()->dynamic_symbols().begin()); std::string SymName = this->dumper()->getFullSymbolName(Sym, Parser.getPltStrTable(), true); W.printNumber("Name", SymName, Sym->st_name); } } } template void LLVMStyle::printMipsABIFlags(const ELFObjectFile *ObjF) { const ELFFile *Obj = ObjF->getELFFile(); const Elf_Shdr *Shdr = findSectionByName(*Obj, ObjF->getFileName(), ".MIPS.abiflags"); if (!Shdr) { W.startLine() << "There is no .MIPS.abiflags section in the file.\n"; return; } ArrayRef Sec = unwrapOrError(ObjF->getFileName(), Obj->getSectionContents(Shdr)); if (Sec.size() != sizeof(Elf_Mips_ABIFlags)) { W.startLine() << "The .MIPS.abiflags section has a wrong size.\n"; return; } auto *Flags = reinterpret_cast *>(Sec.data()); raw_ostream &OS = W.getOStream(); DictScope GS(W, "MIPS ABI Flags"); W.printNumber("Version", Flags->version); W.startLine() << "ISA: "; if (Flags->isa_rev <= 1) OS << format("MIPS%u", Flags->isa_level); else OS << format("MIPS%ur%u", Flags->isa_level, Flags->isa_rev); OS << "\n"; W.printEnum("ISA Extension", Flags->isa_ext, makeArrayRef(ElfMipsISAExtType)); W.printFlags("ASEs", Flags->ases, makeArrayRef(ElfMipsASEFlags)); W.printEnum("FP ABI", Flags->fp_abi, makeArrayRef(ElfMipsFpABIType)); W.printNumber("GPR size", getMipsRegisterSize(Flags->gpr_size)); W.printNumber("CPR1 size", getMipsRegisterSize(Flags->cpr1_size)); W.printNumber("CPR2 size", getMipsRegisterSize(Flags->cpr2_size)); W.printFlags("Flags 1", Flags->flags1, makeArrayRef(ElfMipsFlags1)); W.printHex("Flags 2", Flags->flags2); } Index: stable/11/contrib/llvm-project/llvm =================================================================== --- stable/11/contrib/llvm-project/llvm (revision 361946) +++ stable/11/contrib/llvm-project/llvm (revision 361947) Property changes on: stable/11/contrib/llvm-project/llvm ___________________________________________________________________ Modified: svn:mergeinfo ## -0,0 +0,1 ## Merged /head/contrib/llvm-project/llvm:r361739 Index: stable/11 =================================================================== --- stable/11 (revision 361946) +++ stable/11 (revision 361947) Property changes on: stable/11 ___________________________________________________________________ Modified: svn:mergeinfo ## -0,0 +0,1 ## Merged /head:r361739