1 // elfcpp.h -- main header file for elfcpp -*- C++ -*- 2 3 // Copyright (C) 2006-2022 Free Software Foundation, Inc. 4 // Written by Ian Lance Taylor <iant@google.com>. 5 6 // This file is part of elfcpp. 7 8 // This program is free software; you can redistribute it and/or 9 // modify it under the terms of the GNU Library General Public License 10 // as published by the Free Software Foundation; either version 2, or 11 // (at your option) any later version. 12 13 // In addition to the permissions in the GNU Library General Public 14 // License, the Free Software Foundation gives you unlimited 15 // permission to link the compiled version of this file into 16 // combinations with other programs, and to distribute those 17 // combinations without any restriction coming from the use of this 18 // file. (The Library Public License restrictions do apply in other 19 // respects; for example, they cover modification of the file, and 20 // distribution when not linked into a combined executable.) 21 22 // This program is distributed in the hope that it will be useful, but 23 // WITHOUT ANY WARRANTY; without even the implied warranty of 24 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 25 // Library General Public License for more details. 26 27 // You should have received a copy of the GNU Library General Public 28 // License along with this program; if not, write to the Free Software 29 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 30 // 02110-1301, USA. 31 32 // This is the external interface for elfcpp. 33 34 #ifndef ELFCPP_H 35 #define ELFCPP_H 36 37 #include "elfcpp_swap.h" 38 39 #include <stdint.h> 40 41 namespace elfcpp 42 { 43 44 // Basic ELF types. 45 46 // These types are always the same size. 47 48 typedef uint16_t Elf_Half; 49 typedef uint32_t Elf_Word; 50 typedef int32_t Elf_Sword; 51 typedef uint64_t Elf_Xword; 52 typedef int64_t Elf_Sxword; 53 54 // These types vary in size depending on the ELF file class. The 55 // template parameter should be 32 or 64. 56 57 template<int size> 58 struct Elf_types; 59 60 template<> 61 struct Elf_types<32> 62 { 63 typedef uint32_t Elf_Addr; 64 typedef uint32_t Elf_Off; 65 typedef uint32_t Elf_WXword; 66 typedef int32_t Elf_Swxword; 67 }; 68 69 template<> 70 struct Elf_types<64> 71 { 72 typedef uint64_t Elf_Addr; 73 typedef uint64_t Elf_Off; 74 typedef uint64_t Elf_WXword; 75 typedef int64_t Elf_Swxword; 76 }; 77 78 // Offsets within the Ehdr e_ident field. 79 80 const int EI_MAG0 = 0; 81 const int EI_MAG1 = 1; 82 const int EI_MAG2 = 2; 83 const int EI_MAG3 = 3; 84 const int EI_CLASS = 4; 85 const int EI_DATA = 5; 86 const int EI_VERSION = 6; 87 const int EI_OSABI = 7; 88 const int EI_ABIVERSION = 8; 89 const int EI_PAD = 9; 90 const int EI_NIDENT = 16; 91 92 // The valid values found in Ehdr e_ident[EI_MAG0 through EI_MAG3]. 93 94 const int ELFMAG0 = 0x7f; 95 const int ELFMAG1 = 'E'; 96 const int ELFMAG2 = 'L'; 97 const int ELFMAG3 = 'F'; 98 99 // The valid values found in Ehdr e_ident[EI_CLASS]. 100 101 enum 102 { 103 ELFCLASSNONE = 0, 104 ELFCLASS32 = 1, 105 ELFCLASS64 = 2 106 }; 107 108 // The valid values found in Ehdr e_ident[EI_DATA]. 109 110 enum 111 { 112 ELFDATANONE = 0, 113 ELFDATA2LSB = 1, 114 ELFDATA2MSB = 2 115 }; 116 117 // The valid values found in Ehdr e_ident[EI_VERSION] and e_version. 118 119 enum 120 { 121 EV_NONE = 0, 122 EV_CURRENT = 1 123 }; 124 125 // The valid values found in Ehdr e_ident[EI_OSABI]. 126 127 enum ELFOSABI 128 { 129 ELFOSABI_NONE = 0, 130 ELFOSABI_HPUX = 1, 131 ELFOSABI_NETBSD = 2, 132 ELFOSABI_GNU = 3, 133 // ELFOSABI_LINUX is an alias for ELFOSABI_GNU. 134 ELFOSABI_LINUX = 3, 135 ELFOSABI_SOLARIS = 6, 136 ELFOSABI_AIX = 7, 137 ELFOSABI_IRIX = 8, 138 ELFOSABI_FREEBSD = 9, 139 ELFOSABI_TRU64 = 10, 140 ELFOSABI_MODESTO = 11, 141 ELFOSABI_OPENBSD = 12, 142 ELFOSABI_OPENVMS = 13, 143 ELFOSABI_NSK = 14, 144 ELFOSABI_AROS = 15, 145 // A GNU extension for the ARM. 146 ELFOSABI_ARM = 97, 147 // A GNU extension for the MSP. 148 ELFOSABI_STANDALONE = 255 149 }; 150 151 // The valid values found in the Ehdr e_type field. 152 153 enum ET 154 { 155 ET_NONE = 0, 156 ET_REL = 1, 157 ET_EXEC = 2, 158 ET_DYN = 3, 159 ET_CORE = 4, 160 ET_LOOS = 0xfe00, 161 ET_HIOS = 0xfeff, 162 ET_LOPROC = 0xff00, 163 ET_HIPROC = 0xffff 164 }; 165 166 // The valid values found in the Ehdr e_machine field. 167 168 enum EM 169 { 170 EM_NONE = 0, 171 EM_M32 = 1, 172 EM_SPARC = 2, 173 EM_386 = 3, 174 EM_68K = 4, 175 EM_88K = 5, 176 EM_IAMCU = 6, 177 EM_860 = 7, 178 EM_MIPS = 8, 179 EM_S370 = 9, 180 EM_MIPS_RS3_LE = 10, 181 // 11 was the old Sparc V9 ABI. 182 // 12 through 14 are reserved. 183 EM_PARISC = 15, 184 // 16 is reserved. 185 // Some old PowerPC object files use 17. 186 EM_VPP500 = 17, 187 EM_SPARC32PLUS = 18, 188 EM_960 = 19, 189 EM_PPC = 20, 190 EM_PPC64 = 21, 191 EM_S390 = 22, 192 // 23 through 35 are served. 193 EM_V800 = 36, 194 EM_FR20 = 37, 195 EM_RH32 = 38, 196 EM_RCE = 39, 197 EM_ARM = 40, 198 EM_ALPHA = 41, 199 EM_SH = 42, 200 EM_SPARCV9 = 43, 201 EM_TRICORE = 44, 202 EM_ARC = 45, 203 EM_H8_300 = 46, 204 EM_H8_300H = 47, 205 EM_H8S = 48, 206 EM_H8_500 = 49, 207 EM_IA_64 = 50, 208 EM_MIPS_X = 51, 209 EM_COLDFIRE = 52, 210 EM_68HC12 = 53, 211 EM_MMA = 54, 212 EM_PCP = 55, 213 EM_NCPU = 56, 214 EM_NDR1 = 57, 215 EM_STARCORE = 58, 216 EM_ME16 = 59, 217 EM_ST100 = 60, 218 EM_TINYJ = 61, 219 EM_X86_64 = 62, 220 EM_PDSP = 63, 221 EM_PDP10 = 64, 222 EM_PDP11 = 65, 223 EM_FX66 = 66, 224 EM_ST9PLUS = 67, 225 EM_ST7 = 68, 226 EM_68HC16 = 69, 227 EM_68HC11 = 70, 228 EM_68HC08 = 71, 229 EM_68HC05 = 72, 230 EM_SVX = 73, 231 EM_ST19 = 74, 232 EM_VAX = 75, 233 EM_CRIS = 76, 234 EM_JAVELIN = 77, 235 EM_FIREPATH = 78, 236 EM_ZSP = 79, 237 EM_MMIX = 80, 238 EM_HUANY = 81, 239 EM_PRISM = 82, 240 EM_AVR = 83, 241 EM_FR30 = 84, 242 EM_D10V = 85, 243 EM_D30V = 86, 244 EM_V850 = 87, 245 EM_M32R = 88, 246 EM_MN10300 = 89, 247 EM_MN10200 = 90, 248 EM_PJ = 91, 249 EM_OR1K = 92, 250 EM_ARC_A5 = 93, 251 EM_XTENSA = 94, 252 EM_VIDEOCORE = 95, 253 EM_TMM_GPP = 96, 254 EM_NS32K = 97, 255 EM_TPC = 98, 256 // Some old picoJava object files use 99 (EM_PJ is correct). 257 EM_SNP1K = 99, 258 EM_ST200 = 100, 259 EM_IP2K = 101, 260 EM_MAX = 102, 261 EM_CR = 103, 262 EM_F2MC16 = 104, 263 EM_MSP430 = 105, 264 EM_BLACKFIN = 106, 265 EM_SE_C33 = 107, 266 EM_SEP = 108, 267 EM_ARCA = 109, 268 EM_UNICORE = 110, 269 EM_ALTERA_NIOS2 = 113, 270 EM_CRX = 114, 271 EM_TI_PRU = 144, 272 EM_AARCH64 = 183, 273 EM_TILEGX = 191, 274 // The Morph MT. 275 EM_MT = 0x2530, 276 // DLX. 277 EM_DLX = 0x5aa5, 278 // FRV. 279 EM_FRV = 0x5441, 280 // Infineon Technologies 16-bit microcontroller with C166-V2 core. 281 EM_X16X = 0x4688, 282 // Xstorym16 283 EM_XSTORMY16 = 0xad45, 284 // Renesas M32C 285 EM_M32C = 0xfeb0, 286 // Vitesse IQ2000 287 EM_IQ2000 = 0xfeba, 288 // NIOS 289 EM_NIOS32 = 0xfebb 290 // Old AVR objects used 0x1057 (EM_AVR is correct). 291 // Old MSP430 objects used 0x1059 (EM_MSP430 is correct). 292 // Old FR30 objects used 0x3330 (EM_FR30 is correct). 293 // Old OpenRISC objects used 0x3426 and 0x8472 (EM_OR1K is correct). 294 // Old D10V objects used 0x7650 (EM_D10V is correct). 295 // Old D30V objects used 0x7676 (EM_D30V is correct). 296 // Old IP2X objects used 0x8217 (EM_IP2K is correct). 297 // Old PowerPC objects used 0x9025 (EM_PPC is correct). 298 // Old Alpha objects used 0x9026 (EM_ALPHA is correct). 299 // Old M32R objects used 0x9041 (EM_M32R is correct). 300 // Old V850 objects used 0x9080 (EM_V850 is correct). 301 // Old S/390 objects used 0xa390 (EM_S390 is correct). 302 // Old Xtensa objects used 0xabc7 (EM_XTENSA is correct). 303 // Old MN10300 objects used 0xbeef (EM_MN10300 is correct). 304 // Old MN10200 objects used 0xdead (EM_MN10200 is correct). 305 }; 306 307 // A special value found in the Ehdr e_phnum field. 308 309 enum 310 { 311 // Number of program segments stored in sh_info field of first 312 // section headre. 313 PN_XNUM = 0xffff 314 }; 315 316 // Special section indices. 317 318 enum 319 { 320 SHN_UNDEF = 0, 321 SHN_LORESERVE = 0xff00, 322 SHN_LOPROC = 0xff00, 323 SHN_HIPROC = 0xff1f, 324 SHN_LOOS = 0xff20, 325 SHN_HIOS = 0xff3f, 326 SHN_ABS = 0xfff1, 327 SHN_COMMON = 0xfff2, 328 SHN_XINDEX = 0xffff, 329 SHN_HIRESERVE = 0xffff, 330 331 // Provide for initial and final section ordering in conjunction 332 // with the SHF_LINK_ORDER and SHF_ORDERED section flags. 333 SHN_BEFORE = 0xff00, 334 SHN_AFTER = 0xff01, 335 336 // x86_64 specific large common symbol. 337 SHN_X86_64_LCOMMON = 0xff02 338 }; 339 340 // The valid values found in the Shdr sh_type field. 341 342 enum SHT 343 { 344 SHT_NULL = 0, 345 SHT_PROGBITS = 1, 346 SHT_SYMTAB = 2, 347 SHT_STRTAB = 3, 348 SHT_RELA = 4, 349 SHT_HASH = 5, 350 SHT_DYNAMIC = 6, 351 SHT_NOTE = 7, 352 SHT_NOBITS = 8, 353 SHT_REL = 9, 354 SHT_SHLIB = 10, 355 SHT_DYNSYM = 11, 356 SHT_INIT_ARRAY = 14, 357 SHT_FINI_ARRAY = 15, 358 SHT_PREINIT_ARRAY = 16, 359 SHT_GROUP = 17, 360 SHT_SYMTAB_SHNDX = 18, 361 SHT_LOOS = 0x60000000, 362 SHT_HIOS = 0x6fffffff, 363 SHT_LOPROC = 0x70000000, 364 SHT_HIPROC = 0x7fffffff, 365 SHT_LOUSER = 0x80000000, 366 SHT_HIUSER = 0xffffffff, 367 // The remaining values are not in the standard. 368 // Incremental build data. 369 SHT_GNU_INCREMENTAL_INPUTS = 0x6fff4700, 370 SHT_GNU_INCREMENTAL_SYMTAB = 0x6fff4701, 371 SHT_GNU_INCREMENTAL_RELOCS = 0x6fff4702, 372 SHT_GNU_INCREMENTAL_GOT_PLT = 0x6fff4703, 373 // Object attributes. 374 SHT_GNU_ATTRIBUTES = 0x6ffffff5, 375 // GNU style dynamic hash table. 376 SHT_GNU_HASH = 0x6ffffff6, 377 // List of prelink dependencies. 378 SHT_GNU_LIBLIST = 0x6ffffff7, 379 // Versions defined by file. 380 SHT_SUNW_verdef = 0x6ffffffd, 381 SHT_GNU_verdef = 0x6ffffffd, 382 // Versions needed by file. 383 SHT_SUNW_verneed = 0x6ffffffe, 384 SHT_GNU_verneed = 0x6ffffffe, 385 // Symbol versions, 386 SHT_SUNW_versym = 0x6fffffff, 387 SHT_GNU_versym = 0x6fffffff, 388 389 SHT_SPARC_GOTDATA = 0x70000000, 390 391 // ARM-specific section types. 392 // Exception Index table. 393 SHT_ARM_EXIDX = 0x70000001, 394 // BPABI DLL dynamic linking pre-emption map. 395 SHT_ARM_PREEMPTMAP = 0x70000002, 396 // Object file compatibility attributes. 397 SHT_ARM_ATTRIBUTES = 0x70000003, 398 // Support for debugging overlaid programs. 399 SHT_ARM_DEBUGOVERLAY = 0x70000004, 400 SHT_ARM_OVERLAYSECTION = 0x70000005, 401 402 // x86_64 unwind information. 403 SHT_X86_64_UNWIND = 0x70000001, 404 405 // MIPS-specific section types. 406 // Section contains register usage information. 407 SHT_MIPS_REGINFO = 0x70000006, 408 // Section contains miscellaneous options. 409 SHT_MIPS_OPTIONS = 0x7000000d, 410 // ABI related flags section. 411 SHT_MIPS_ABIFLAGS = 0x7000002a, 412 413 // AARCH64-specific section type. 414 SHT_AARCH64_ATTRIBUTES = 0x70000003, 415 416 // CSKY-specific section types. 417 // Object file compatibility attributes. 418 SHT_CSKY_ATTRIBUTES = 0x70000001, 419 420 // Link editor is to sort the entries in this section based on the 421 // address specified in the associated symbol table entry. 422 SHT_ORDERED = 0x7fffffff 423 }; 424 425 // The valid bit flags found in the Shdr sh_flags field. 426 427 enum SHF 428 { 429 SHF_WRITE = 0x1, 430 SHF_ALLOC = 0x2, 431 SHF_EXECINSTR = 0x4, 432 SHF_MERGE = 0x10, 433 SHF_STRINGS = 0x20, 434 SHF_INFO_LINK = 0x40, 435 SHF_LINK_ORDER = 0x80, 436 SHF_OS_NONCONFORMING = 0x100, 437 SHF_GROUP = 0x200, 438 SHF_TLS = 0x400, 439 SHF_COMPRESSED = 0x800, 440 SHF_MASKOS = 0x0ff00000, 441 SHF_GNU_RETAIN = 0x200000, 442 SHF_MASKPROC = 0xf0000000, 443 444 // Indicates this section requires ordering in relation to 445 // other sections of the same type. Ordered sections are 446 // combined within the section pointed to by the sh_link entry. 447 // The sh_info values SHN_BEFORE and SHN_AFTER imply that the 448 // sorted section is to precede or follow, respectively, all 449 // other sections in the set being ordered. 450 SHF_ORDERED = 0x40000000, 451 // This section is excluded from input to the link-edit of an 452 // executable or shared object. This flag is ignored if SHF_ALLOC 453 // is also set, or if relocations exist against the section. 454 SHF_EXCLUDE = 0x80000000, 455 456 // Section with data that is GP relative addressable. 457 SHF_MIPS_GPREL = 0x10000000, 458 459 // x86_64 specific large section. 460 SHF_X86_64_LARGE = 0x10000000 461 }; 462 463 // Values which appear in the first Elf_WXword of the section data 464 // of a SHF_COMPRESSED section. 465 enum 466 { 467 ELFCOMPRESS_ZLIB = 1, 468 ELFCOMPRESS_LOOS = 0x60000000, 469 ELFCOMPRESS_HIOS = 0x6fffffff, 470 ELFCOMPRESS_LOPROC = 0x70000000, 471 ELFCOMPRESS_HIPROC = 0x7fffffff, 472 }; 473 474 // Bit flags which appear in the first 32-bit word of the section data 475 // of a SHT_GROUP section. 476 477 enum 478 { 479 GRP_COMDAT = 0x1, 480 GRP_MASKOS = 0x0ff00000, 481 GRP_MASKPROC = 0xf0000000 482 }; 483 484 // The valid values found in the Phdr p_type field. 485 486 enum PT 487 { 488 PT_NULL = 0, 489 PT_LOAD = 1, 490 PT_DYNAMIC = 2, 491 PT_INTERP = 3, 492 PT_NOTE = 4, 493 PT_SHLIB = 5, 494 PT_PHDR = 6, 495 PT_TLS = 7, 496 PT_LOOS = 0x60000000, 497 PT_HIOS = 0x6fffffff, 498 PT_LOPROC = 0x70000000, 499 PT_HIPROC = 0x7fffffff, 500 // The remaining values are not in the standard. 501 // Frame unwind information. 502 PT_GNU_EH_FRAME = 0x6474e550, 503 PT_SUNW_EH_FRAME = 0x6474e550, 504 // Stack flags. 505 PT_GNU_STACK = 0x6474e551, 506 // Read only after relocation. 507 PT_GNU_RELRO = 0x6474e552, 508 // Platform architecture compatibility information 509 PT_ARM_ARCHEXT = 0x70000000, 510 // Exception unwind tables 511 PT_ARM_EXIDX = 0x70000001, 512 // Register usage information. Identifies one .reginfo section. 513 PT_MIPS_REGINFO =0x70000000, 514 // Runtime procedure table. 515 PT_MIPS_RTPROC = 0x70000001, 516 // .MIPS.options section. 517 PT_MIPS_OPTIONS = 0x70000002, 518 // .MIPS.abiflags section. 519 PT_MIPS_ABIFLAGS = 0x70000003, 520 // Platform architecture compatibility information 521 PT_AARCH64_ARCHEXT = 0x70000000, 522 // Exception unwind tables 523 PT_AARCH64_UNWIND = 0x70000001, 524 // 4k page table size 525 PT_S390_PGSTE = 0x70000000, 526 }; 527 528 // The valid bit flags found in the Phdr p_flags field. 529 530 enum PF 531 { 532 PF_X = 0x1, 533 PF_W = 0x2, 534 PF_R = 0x4, 535 PF_MASKOS = 0x0ff00000, 536 PF_MASKPROC = 0xf0000000 537 }; 538 539 // Symbol binding from Sym st_info field. 540 541 enum STB 542 { 543 STB_LOCAL = 0, 544 STB_GLOBAL = 1, 545 STB_WEAK = 2, 546 STB_LOOS = 10, 547 STB_GNU_UNIQUE = 10, 548 STB_HIOS = 12, 549 STB_LOPROC = 13, 550 STB_HIPROC = 15 551 }; 552 553 // Symbol types from Sym st_info field. 554 555 enum STT 556 { 557 STT_NOTYPE = 0, 558 STT_OBJECT = 1, 559 STT_FUNC = 2, 560 STT_SECTION = 3, 561 STT_FILE = 4, 562 STT_COMMON = 5, 563 STT_TLS = 6, 564 565 // GNU extension: symbol value points to a function which is called 566 // at runtime to determine the final value of the symbol. 567 STT_GNU_IFUNC = 10, 568 569 STT_LOOS = 10, 570 STT_HIOS = 12, 571 STT_LOPROC = 13, 572 STT_HIPROC = 15, 573 574 // The section type that must be used for register symbols on 575 // Sparc. These symbols initialize a global register. 576 STT_SPARC_REGISTER = 13, 577 578 // ARM: a THUMB function. This is not defined in ARM ELF Specification but 579 // used by the GNU tool-chain. 580 STT_ARM_TFUNC = 13 581 }; 582 583 inline STB 584 elf_st_bind(unsigned char info) 585 { 586 return static_cast<STB>(info >> 4); 587 } 588 589 inline STT 590 elf_st_type(unsigned char info) 591 { 592 return static_cast<STT>(info & 0xf); 593 } 594 595 inline unsigned char 596 elf_st_info(STB bind, STT type) 597 { 598 return ((static_cast<unsigned char>(bind) << 4) 599 + (static_cast<unsigned char>(type) & 0xf)); 600 } 601 602 // Symbol visibility from Sym st_other field. 603 604 enum STV 605 { 606 STV_DEFAULT = 0, 607 STV_INTERNAL = 1, 608 STV_HIDDEN = 2, 609 STV_PROTECTED = 3 610 }; 611 612 inline STV 613 elf_st_visibility(unsigned char other) 614 { 615 return static_cast<STV>(other & 0x3); 616 } 617 618 inline unsigned char 619 elf_st_nonvis(unsigned char other) 620 { 621 return static_cast<STV>(other >> 2); 622 } 623 624 inline unsigned char 625 elf_st_other(STV vis, unsigned char nonvis) 626 { 627 return ((nonvis << 2) 628 + (static_cast<unsigned char>(vis) & 3)); 629 } 630 631 // Reloc information from Rel/Rela r_info field. 632 633 template<int size> 634 unsigned int 635 elf_r_sym(typename Elf_types<size>::Elf_WXword); 636 637 template<> 638 inline unsigned int 639 elf_r_sym<32>(Elf_Word v) 640 { 641 return v >> 8; 642 } 643 644 template<> 645 inline unsigned int 646 elf_r_sym<64>(Elf_Xword v) 647 { 648 return v >> 32; 649 } 650 651 template<int size> 652 unsigned int 653 elf_r_type(typename Elf_types<size>::Elf_WXword); 654 655 template<> 656 inline unsigned int 657 elf_r_type<32>(Elf_Word v) 658 { 659 return v & 0xff; 660 } 661 662 template<> 663 inline unsigned int 664 elf_r_type<64>(Elf_Xword v) 665 { 666 return v & 0xffffffff; 667 } 668 669 template<int size> 670 typename Elf_types<size>::Elf_WXword 671 elf_r_info(unsigned int s, unsigned int t); 672 673 template<> 674 inline Elf_Word 675 elf_r_info<32>(unsigned int s, unsigned int t) 676 { 677 return (s << 8) + (t & 0xff); 678 } 679 680 template<> 681 inline Elf_Xword 682 elf_r_info<64>(unsigned int s, unsigned int t) 683 { 684 return (static_cast<Elf_Xword>(s) << 32) + (t & 0xffffffff); 685 } 686 687 // Dynamic tags found in the PT_DYNAMIC segment. 688 689 enum DT 690 { 691 DT_NULL = 0, 692 DT_NEEDED = 1, 693 DT_PLTRELSZ = 2, 694 DT_PLTGOT = 3, 695 DT_HASH = 4, 696 DT_STRTAB = 5, 697 DT_SYMTAB = 6, 698 DT_RELA = 7, 699 DT_RELASZ = 8, 700 DT_RELAENT = 9, 701 DT_STRSZ = 10, 702 DT_SYMENT = 11, 703 DT_INIT = 12, 704 DT_FINI = 13, 705 DT_SONAME = 14, 706 DT_RPATH = 15, 707 DT_SYMBOLIC = 16, 708 DT_REL = 17, 709 DT_RELSZ = 18, 710 DT_RELENT = 19, 711 DT_PLTREL = 20, 712 DT_DEBUG = 21, 713 DT_TEXTREL = 22, 714 DT_JMPREL = 23, 715 DT_BIND_NOW = 24, 716 DT_INIT_ARRAY = 25, 717 DT_FINI_ARRAY = 26, 718 DT_INIT_ARRAYSZ = 27, 719 DT_FINI_ARRAYSZ = 28, 720 DT_RUNPATH = 29, 721 DT_FLAGS = 30, 722 723 // This is used to mark a range of dynamic tags. It is not really 724 // a tag value. 725 DT_ENCODING = 32, 726 727 DT_PREINIT_ARRAY = 32, 728 DT_PREINIT_ARRAYSZ = 33, 729 DT_LOOS = 0x6000000d, 730 DT_HIOS = 0x6ffff000, 731 DT_LOPROC = 0x70000000, 732 DT_HIPROC = 0x7fffffff, 733 734 // The remaining values are extensions used by GNU or Solaris. 735 DT_VALRNGLO = 0x6ffffd00, 736 DT_GNU_FLAGS_1 = 0x6ffffdf4, 737 DT_GNU_PRELINKED = 0x6ffffdf5, 738 DT_GNU_CONFLICTSZ = 0x6ffffdf6, 739 DT_GNU_LIBLISTSZ = 0x6ffffdf7, 740 DT_CHECKSUM = 0x6ffffdf8, 741 DT_PLTPADSZ = 0x6ffffdf9, 742 DT_MOVEENT = 0x6ffffdfa, 743 DT_MOVESZ = 0x6ffffdfb, 744 DT_FEATURE = 0x6ffffdfc, 745 DT_POSFLAG_1 = 0x6ffffdfd, 746 DT_SYMINSZ = 0x6ffffdfe, 747 DT_SYMINENT = 0x6ffffdff, 748 DT_VALRNGHI = 0x6ffffdff, 749 750 DT_ADDRRNGLO = 0x6ffffe00, 751 DT_GNU_HASH = 0x6ffffef5, 752 DT_TLSDESC_PLT = 0x6ffffef6, 753 DT_TLSDESC_GOT = 0x6ffffef7, 754 DT_GNU_CONFLICT = 0x6ffffef8, 755 DT_GNU_LIBLIST = 0x6ffffef9, 756 DT_CONFIG = 0x6ffffefa, 757 DT_DEPAUDIT = 0x6ffffefb, 758 DT_AUDIT = 0x6ffffefc, 759 DT_PLTPAD = 0x6ffffefd, 760 DT_MOVETAB = 0x6ffffefe, 761 DT_SYMINFO = 0x6ffffeff, 762 DT_ADDRRNGHI = 0x6ffffeff, 763 764 DT_RELACOUNT = 0x6ffffff9, 765 DT_RELCOUNT = 0x6ffffffa, 766 DT_FLAGS_1 = 0x6ffffffb, 767 DT_VERDEF = 0x6ffffffc, 768 DT_VERDEFNUM = 0x6ffffffd, 769 DT_VERNEED = 0x6ffffffe, 770 DT_VERNEEDNUM = 0x6fffffff, 771 772 DT_VERSYM = 0x6ffffff0, 773 774 // Specify the value of _GLOBAL_OFFSET_TABLE_. 775 DT_PPC_GOT = 0x70000000, 776 777 // Specify whether various optimisations are possible. 778 DT_PPC_OPT = 0x70000001, 779 780 // Specify the start of the .glink section. 781 DT_PPC64_GLINK = 0x70000000, 782 783 // Specify the start and size of the .opd section. 784 DT_PPC64_OPD = 0x70000001, 785 DT_PPC64_OPDSZ = 0x70000002, 786 787 // Specify whether various optimisations are possible. 788 DT_PPC64_OPT = 0x70000003, 789 790 // The index of an STT_SPARC_REGISTER symbol within the DT_SYMTAB 791 // symbol table. One dynamic entry exists for every STT_SPARC_REGISTER 792 // symbol in the symbol table. 793 DT_SPARC_REGISTER = 0x70000001, 794 795 // MIPS specific dynamic array tags. 796 // 32 bit version number for runtime linker interface. 797 DT_MIPS_RLD_VERSION = 0x70000001, 798 // Time stamp. 799 DT_MIPS_TIME_STAMP = 0x70000002, 800 // Checksum of external strings and common sizes. 801 DT_MIPS_ICHECKSUM = 0x70000003, 802 // Index of version string in string table. 803 DT_MIPS_IVERSION = 0x70000004, 804 // 32 bits of flags. 805 DT_MIPS_FLAGS = 0x70000005, 806 // Base address of the segment. 807 DT_MIPS_BASE_ADDRESS = 0x70000006, 808 // ??? 809 DT_MIPS_MSYM = 0x70000007, 810 // Address of .conflict section. 811 DT_MIPS_CONFLICT = 0x70000008, 812 // Address of .liblist section. 813 DT_MIPS_LIBLIST = 0x70000009, 814 // Number of local global offset table entries. 815 DT_MIPS_LOCAL_GOTNO = 0x7000000a, 816 // Number of entries in the .conflict section. 817 DT_MIPS_CONFLICTNO = 0x7000000b, 818 // Number of entries in the .liblist section. 819 DT_MIPS_LIBLISTNO = 0x70000010, 820 // Number of entries in the .dynsym section. 821 DT_MIPS_SYMTABNO = 0x70000011, 822 // Index of first external dynamic symbol not referenced locally. 823 DT_MIPS_UNREFEXTNO = 0x70000012, 824 // Index of first dynamic symbol in global offset table. 825 DT_MIPS_GOTSYM = 0x70000013, 826 // Number of page table entries in global offset table. 827 DT_MIPS_HIPAGENO = 0x70000014, 828 // Address of run time loader map, used for debugging. 829 DT_MIPS_RLD_MAP = 0x70000016, 830 // Delta C++ class definition. 831 DT_MIPS_DELTA_CLASS = 0x70000017, 832 // Number of entries in DT_MIPS_DELTA_CLASS. 833 DT_MIPS_DELTA_CLASS_NO = 0x70000018, 834 // Delta C++ class instances. 835 DT_MIPS_DELTA_INSTANCE = 0x70000019, 836 // Number of entries in DT_MIPS_DELTA_INSTANCE. 837 DT_MIPS_DELTA_INSTANCE_NO = 0x7000001a, 838 // Delta relocations. 839 DT_MIPS_DELTA_RELOC = 0x7000001b, 840 // Number of entries in DT_MIPS_DELTA_RELOC. 841 DT_MIPS_DELTA_RELOC_NO = 0x7000001c, 842 // Delta symbols that Delta relocations refer to. 843 DT_MIPS_DELTA_SYM = 0x7000001d, 844 // Number of entries in DT_MIPS_DELTA_SYM. 845 DT_MIPS_DELTA_SYM_NO = 0x7000001e, 846 // Delta symbols that hold class declarations. 847 DT_MIPS_DELTA_CLASSSYM = 0x70000020, 848 // Number of entries in DT_MIPS_DELTA_CLASSSYM. 849 DT_MIPS_DELTA_CLASSSYM_NO = 0x70000021, 850 // Flags indicating information about C++ flavor. 851 DT_MIPS_CXX_FLAGS = 0x70000022, 852 // Pixie information (???). 853 DT_MIPS_PIXIE_INIT = 0x70000023, 854 // Address of .MIPS.symlib 855 DT_MIPS_SYMBOL_LIB = 0x70000024, 856 // The GOT index of the first PTE for a segment 857 DT_MIPS_LOCALPAGE_GOTIDX = 0x70000025, 858 // The GOT index of the first PTE for a local symbol 859 DT_MIPS_LOCAL_GOTIDX = 0x70000026, 860 // The GOT index of the first PTE for a hidden symbol 861 DT_MIPS_HIDDEN_GOTIDX = 0x70000027, 862 // The GOT index of the first PTE for a protected symbol 863 DT_MIPS_PROTECTED_GOTIDX = 0x70000028, 864 // Address of `.MIPS.options'. 865 DT_MIPS_OPTIONS = 0x70000029, 866 // Address of `.interface'. 867 DT_MIPS_INTERFACE = 0x7000002a, 868 // ??? 869 DT_MIPS_DYNSTR_ALIGN = 0x7000002b, 870 // Size of the .interface section. 871 DT_MIPS_INTERFACE_SIZE = 0x7000002c, 872 // Size of rld_text_resolve function stored in the GOT. 873 DT_MIPS_RLD_TEXT_RESOLVE_ADDR = 0x7000002d, 874 // Default suffix of DSO to be added by rld on dlopen() calls. 875 DT_MIPS_PERF_SUFFIX = 0x7000002e, 876 // Size of compact relocation section (O32). 877 DT_MIPS_COMPACT_SIZE = 0x7000002f, 878 // GP value for auxiliary GOTs. 879 DT_MIPS_GP_VALUE = 0x70000030, 880 // Address of auxiliary .dynamic. 881 DT_MIPS_AUX_DYNAMIC = 0x70000031, 882 // Address of the base of the PLTGOT. 883 DT_MIPS_PLTGOT = 0x70000032, 884 // Points to the base of a writable PLT. 885 DT_MIPS_RWPLT = 0x70000034, 886 // Relative offset of run time loader map, used for debugging. 887 DT_MIPS_RLD_MAP_REL = 0x70000035, 888 889 DT_AUXILIARY = 0x7ffffffd, 890 DT_USED = 0x7ffffffe, 891 DT_FILTER = 0x7fffffff 892 }; 893 894 // Flags found in the DT_FLAGS dynamic element. 895 896 enum DF 897 { 898 DF_ORIGIN = 0x1, 899 DF_SYMBOLIC = 0x2, 900 DF_TEXTREL = 0x4, 901 DF_BIND_NOW = 0x8, 902 DF_STATIC_TLS = 0x10 903 }; 904 905 // Flags found in the DT_FLAGS_1 dynamic element. 906 907 enum DF_1 908 { 909 DF_1_NOW = 0x1, 910 DF_1_GLOBAL = 0x2, 911 DF_1_GROUP = 0x4, 912 DF_1_NODELETE = 0x8, 913 DF_1_LOADFLTR = 0x10, 914 DF_1_INITFIRST = 0x20, 915 DF_1_NOOPEN = 0x40, 916 DF_1_ORIGIN = 0x80, 917 DF_1_DIRECT = 0x100, 918 DF_1_TRANS = 0x200, 919 DF_1_INTERPOSE = 0x400, 920 DF_1_NODEFLIB = 0x800, 921 DF_1_NODUMP = 0x1000, 922 DF_1_CONLFAT = 0x2000, 923 DF_1_PIE = 0x08000000 924 }; 925 926 // Flags found in the DT_GNU_FLAGS_1 dynamic element. 927 enum DF_GNU_1 928 { 929 DF_GNU_1_UNIQUE = 0x1, 930 }; 931 932 // Version numbers which appear in the vd_version field of a Verdef 933 // structure. 934 935 const int VER_DEF_NONE = 0; 936 const int VER_DEF_CURRENT = 1; 937 938 // Version numbers which appear in the vn_version field of a Verneed 939 // structure. 940 941 const int VER_NEED_NONE = 0; 942 const int VER_NEED_CURRENT = 1; 943 944 // Bit flags which appear in vd_flags of Verdef and vna_flags of 945 // Vernaux. 946 947 const int VER_FLG_BASE = 0x1; 948 const int VER_FLG_WEAK = 0x2; 949 const int VER_FLG_INFO = 0x4; 950 951 // Special constants found in the SHT_GNU_versym entries. 952 953 const int VER_NDX_LOCAL = 0; 954 const int VER_NDX_GLOBAL = 1; 955 956 // A SHT_GNU_versym section holds 16-bit words. This bit is set if 957 // the symbol is hidden and can only be seen when referenced using an 958 // explicit version number. This is a GNU extension. 959 960 const int VERSYM_HIDDEN = 0x8000; 961 962 // This is the mask for the rest of the data in a word read from a 963 // SHT_GNU_versym section. 964 965 const int VERSYM_VERSION = 0x7fff; 966 967 // Note descriptor type codes for notes in a non-core file with an 968 // empty name. 969 970 enum 971 { 972 // A version string. 973 NT_VERSION = 1, 974 // An architecture string. 975 NT_ARCH = 2 976 }; 977 978 // Note descriptor type codes for notes in a non-core file with the 979 // name "GNU". 980 981 enum 982 { 983 // The minimum ABI level. This is used by the dynamic linker to 984 // describe the minimal kernel version on which a shared library may 985 // be used. Th value should be four words. Word 0 is an OS 986 // descriptor (see below). Word 1 is the major version of the ABI. 987 // Word 2 is the minor version. Word 3 is the subminor version. 988 NT_GNU_ABI_TAG = 1, 989 // Hardware capabilities information. Word 0 is the number of 990 // entries. Word 1 is a bitmask of enabled entries. The rest of 991 // the descriptor is a series of entries, where each entry is a 992 // single byte followed by a nul terminated string. The byte gives 993 // the bit number to test if enabled in the bitmask. 994 NT_GNU_HWCAP = 2, 995 // The build ID as set by the linker's --build-id option. The 996 // format of the descriptor depends on the build ID style. 997 NT_GNU_BUILD_ID = 3, 998 // The version of gold used to link. Th descriptor is just a 999 // string. 1000 NT_GNU_GOLD_VERSION = 4, 1001 // Program property note, as described in "Linux Extensions to the gABI". 1002 NT_GNU_PROPERTY_TYPE_0 = 5 1003 }; 1004 1005 // The OS values which may appear in word 0 of a NT_GNU_ABI_TAG note. 1006 1007 enum 1008 { 1009 ELF_NOTE_OS_LINUX = 0, 1010 ELF_NOTE_OS_GNU = 1, 1011 ELF_NOTE_OS_SOLARIS2 = 2, 1012 ELF_NOTE_OS_FREEBSD = 3, 1013 ELF_NOTE_OS_NETBSD = 4, 1014 ELF_NOTE_OS_SYLLABLE = 5 1015 }; 1016 1017 // Program property types for NT_GNU_PROPERTY_TYPE_0. 1018 1019 enum 1020 { 1021 GNU_PROPERTY_STACK_SIZE = 1, 1022 GNU_PROPERTY_NO_COPY_ON_PROTECTED = 2, 1023 GNU_PROPERTY_LOPROC = 0xc0000000, 1024 GNU_PROPERTY_X86_COMPAT_ISA_1_USED = 0xc0000000, 1025 GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED = 0xc0000001, 1026 GNU_PROPERTY_X86_UINT32_AND_LO = 0xc0000002, 1027 GNU_PROPERTY_X86_UINT32_AND_HI = 0xc0007fff, 1028 GNU_PROPERTY_X86_UINT32_OR_LO = 0xc0008000, 1029 GNU_PROPERTY_X86_UINT32_OR_HI = 0xc000ffff, 1030 GNU_PROPERTY_X86_UINT32_OR_AND_LO = 0xc0010000, 1031 GNU_PROPERTY_X86_UINT32_OR_AND_HI = 0xc0017fff, 1032 GNU_PROPERTY_X86_COMPAT_2_ISA_1_NEEDED = GNU_PROPERTY_X86_UINT32_OR_LO + 0, 1033 GNU_PROPERTY_X86_COMPAT_2_ISA_1_USED = GNU_PROPERTY_X86_UINT32_OR_AND_LO + 0, 1034 GNU_PROPERTY_X86_FEATURE_1_AND = GNU_PROPERTY_X86_UINT32_AND_LO + 0, 1035 GNU_PROPERTY_X86_ISA_1_NEEDED = GNU_PROPERTY_X86_UINT32_OR_LO + 2, 1036 GNU_PROPERTY_X86_FEATURE_2_NEEDED = GNU_PROPERTY_X86_UINT32_OR_LO + 1, 1037 GNU_PROPERTY_X86_ISA_1_USED = GNU_PROPERTY_X86_UINT32_OR_AND_LO + 2, 1038 GNU_PROPERTY_X86_FEATURE_2_USED = GNU_PROPERTY_X86_UINT32_OR_AND_LO + 1, 1039 GNU_PROPERTY_HIPROC = 0xdfffffff, 1040 GNU_PROPERTY_LOUSER = 0xe0000000, 1041 GNU_PROPERTY_HIUSER = 0xffffffff 1042 }; 1043 1044 } // End namespace elfcpp. 1045 1046 // Include internal details after defining the types. 1047 #include "elfcpp_internal.h" 1048 1049 namespace elfcpp 1050 { 1051 1052 // The offset of the ELF file header in the ELF file. 1053 1054 const int file_header_offset = 0; 1055 1056 // ELF structure sizes. 1057 1058 template<int size> 1059 struct Elf_sizes 1060 { 1061 // Size of ELF file header. 1062 static const int ehdr_size = sizeof(internal::Ehdr_data<size>); 1063 // Size of ELF segment header. 1064 static const int phdr_size = sizeof(internal::Phdr_data<size>); 1065 // Size of ELF section header. 1066 static const int shdr_size = sizeof(internal::Shdr_data<size>); 1067 // Size of ELF compression header. 1068 static const int chdr_size = sizeof(internal::Chdr_data<size>); 1069 // Size of ELF symbol table entry. 1070 static const int sym_size = sizeof(internal::Sym_data<size>); 1071 // Sizes of ELF reloc entries. 1072 static const int rel_size = sizeof(internal::Rel_data<size>); 1073 static const int rela_size = sizeof(internal::Rela_data<size>); 1074 // Size of ELF dynamic entry. 1075 static const int dyn_size = sizeof(internal::Dyn_data<size>); 1076 // Size of ELF version structures. 1077 static const int verdef_size = sizeof(internal::Verdef_data); 1078 static const int verdaux_size = sizeof(internal::Verdaux_data); 1079 static const int verneed_size = sizeof(internal::Verneed_data); 1080 static const int vernaux_size = sizeof(internal::Vernaux_data); 1081 }; 1082 1083 // Accessor class for the ELF file header. 1084 1085 template<int size, bool big_endian> 1086 class Ehdr 1087 { 1088 public: 1089 Ehdr(const unsigned char* p) 1090 : p_(reinterpret_cast<const internal::Ehdr_data<size>*>(p)) 1091 { } 1092 1093 template<typename File> 1094 Ehdr(File* file, typename File::Location loc) 1095 : p_(reinterpret_cast<const internal::Ehdr_data<size>*>( 1096 file->view(loc.file_offset, loc.data_size).data())) 1097 { } 1098 1099 const unsigned char* 1100 get_e_ident() const 1101 { return this->p_->e_ident; } 1102 1103 unsigned char 1104 get_ei_osabi() const 1105 { return this->p_->e_ident[EI_OSABI]; } 1106 1107 unsigned char 1108 get_ei_abiversion() const 1109 { return this->p_->e_ident[EI_ABIVERSION]; } 1110 1111 Elf_Half 1112 get_e_type() const 1113 { return Convert<16, big_endian>::convert_host(this->p_->e_type); } 1114 1115 Elf_Half 1116 get_e_machine() const 1117 { return Convert<16, big_endian>::convert_host(this->p_->e_machine); } 1118 1119 Elf_Word 1120 get_e_version() const 1121 { return Convert<32, big_endian>::convert_host(this->p_->e_version); } 1122 1123 typename Elf_types<size>::Elf_Addr 1124 get_e_entry() const 1125 { return Convert<size, big_endian>::convert_host(this->p_->e_entry); } 1126 1127 typename Elf_types<size>::Elf_Off 1128 get_e_phoff() const 1129 { return Convert<size, big_endian>::convert_host(this->p_->e_phoff); } 1130 1131 typename Elf_types<size>::Elf_Off 1132 get_e_shoff() const 1133 { return Convert<size, big_endian>::convert_host(this->p_->e_shoff); } 1134 1135 Elf_Word 1136 get_e_flags() const 1137 { return Convert<32, big_endian>::convert_host(this->p_->e_flags); } 1138 1139 Elf_Half 1140 get_e_ehsize() const 1141 { return Convert<16, big_endian>::convert_host(this->p_->e_ehsize); } 1142 1143 Elf_Half 1144 get_e_phentsize() const 1145 { return Convert<16, big_endian>::convert_host(this->p_->e_phentsize); } 1146 1147 Elf_Half 1148 get_e_phnum() const 1149 { return Convert<16, big_endian>::convert_host(this->p_->e_phnum); } 1150 1151 Elf_Half 1152 get_e_shentsize() const 1153 { return Convert<16, big_endian>::convert_host(this->p_->e_shentsize); } 1154 1155 Elf_Half 1156 get_e_shnum() const 1157 { return Convert<16, big_endian>::convert_host(this->p_->e_shnum); } 1158 1159 Elf_Half 1160 get_e_shstrndx() const 1161 { return Convert<16, big_endian>::convert_host(this->p_->e_shstrndx); } 1162 1163 private: 1164 const internal::Ehdr_data<size>* p_; 1165 }; 1166 1167 // Write class for the ELF file header. 1168 1169 template<int size, bool big_endian> 1170 class Ehdr_write 1171 { 1172 public: 1173 Ehdr_write(unsigned char* p) 1174 : p_(reinterpret_cast<internal::Ehdr_data<size>*>(p)) 1175 { } 1176 1177 void 1178 put_e_ident(const unsigned char v[EI_NIDENT]) const 1179 { memcpy(this->p_->e_ident, v, EI_NIDENT); } 1180 1181 void 1182 put_e_type(Elf_Half v) 1183 { this->p_->e_type = Convert<16, big_endian>::convert_host(v); } 1184 1185 void 1186 put_e_machine(Elf_Half v) 1187 { this->p_->e_machine = Convert<16, big_endian>::convert_host(v); } 1188 1189 void 1190 put_e_version(Elf_Word v) 1191 { this->p_->e_version = Convert<32, big_endian>::convert_host(v); } 1192 1193 void 1194 put_e_entry(typename Elf_types<size>::Elf_Addr v) 1195 { this->p_->e_entry = Convert<size, big_endian>::convert_host(v); } 1196 1197 void 1198 put_e_phoff(typename Elf_types<size>::Elf_Off v) 1199 { this->p_->e_phoff = Convert<size, big_endian>::convert_host(v); } 1200 1201 void 1202 put_e_shoff(typename Elf_types<size>::Elf_Off v) 1203 { this->p_->e_shoff = Convert<size, big_endian>::convert_host(v); } 1204 1205 void 1206 put_e_flags(Elf_Word v) 1207 { this->p_->e_flags = Convert<32, big_endian>::convert_host(v); } 1208 1209 void 1210 put_e_ehsize(Elf_Half v) 1211 { this->p_->e_ehsize = Convert<16, big_endian>::convert_host(v); } 1212 1213 void 1214 put_e_phentsize(Elf_Half v) 1215 { this->p_->e_phentsize = Convert<16, big_endian>::convert_host(v); } 1216 1217 void 1218 put_e_phnum(Elf_Half v) 1219 { this->p_->e_phnum = Convert<16, big_endian>::convert_host(v); } 1220 1221 void 1222 put_e_shentsize(Elf_Half v) 1223 { this->p_->e_shentsize = Convert<16, big_endian>::convert_host(v); } 1224 1225 void 1226 put_e_shnum(Elf_Half v) 1227 { this->p_->e_shnum = Convert<16, big_endian>::convert_host(v); } 1228 1229 void 1230 put_e_shstrndx(Elf_Half v) 1231 { this->p_->e_shstrndx = Convert<16, big_endian>::convert_host(v); } 1232 1233 private: 1234 internal::Ehdr_data<size>* p_; 1235 }; 1236 1237 // Accessor class for an ELF section header. 1238 1239 template<int size, bool big_endian> 1240 class Shdr 1241 { 1242 public: 1243 Shdr(const unsigned char* p) 1244 : p_(reinterpret_cast<const internal::Shdr_data<size>*>(p)) 1245 { } 1246 1247 template<typename File> 1248 Shdr(File* file, typename File::Location loc) 1249 : p_(reinterpret_cast<const internal::Shdr_data<size>*>( 1250 file->view(loc.file_offset, loc.data_size).data())) 1251 { } 1252 1253 Elf_Word 1254 get_sh_name() const 1255 { return Convert<32, big_endian>::convert_host(this->p_->sh_name); } 1256 1257 Elf_Word 1258 get_sh_type() const 1259 { return Convert<32, big_endian>::convert_host(this->p_->sh_type); } 1260 1261 typename Elf_types<size>::Elf_WXword 1262 get_sh_flags() const 1263 { return Convert<size, big_endian>::convert_host(this->p_->sh_flags); } 1264 1265 typename Elf_types<size>::Elf_Addr 1266 get_sh_addr() const 1267 { return Convert<size, big_endian>::convert_host(this->p_->sh_addr); } 1268 1269 typename Elf_types<size>::Elf_Off 1270 get_sh_offset() const 1271 { return Convert<size, big_endian>::convert_host(this->p_->sh_offset); } 1272 1273 typename Elf_types<size>::Elf_WXword 1274 get_sh_size() const 1275 { return Convert<size, big_endian>::convert_host(this->p_->sh_size); } 1276 1277 Elf_Word 1278 get_sh_link() const 1279 { return Convert<32, big_endian>::convert_host(this->p_->sh_link); } 1280 1281 Elf_Word 1282 get_sh_info() const 1283 { return Convert<32, big_endian>::convert_host(this->p_->sh_info); } 1284 1285 typename Elf_types<size>::Elf_WXword 1286 get_sh_addralign() const 1287 { return 1288 Convert<size, big_endian>::convert_host(this->p_->sh_addralign); } 1289 1290 typename Elf_types<size>::Elf_WXword 1291 get_sh_entsize() const 1292 { return Convert<size, big_endian>::convert_host(this->p_->sh_entsize); } 1293 1294 private: 1295 const internal::Shdr_data<size>* p_; 1296 }; 1297 1298 // Write class for an ELF section header. 1299 1300 template<int size, bool big_endian> 1301 class Shdr_write 1302 { 1303 public: 1304 Shdr_write(unsigned char* p) 1305 : p_(reinterpret_cast<internal::Shdr_data<size>*>(p)) 1306 { } 1307 1308 void 1309 put_sh_name(Elf_Word v) 1310 { this->p_->sh_name = Convert<32, big_endian>::convert_host(v); } 1311 1312 void 1313 put_sh_type(Elf_Word v) 1314 { this->p_->sh_type = Convert<32, big_endian>::convert_host(v); } 1315 1316 void 1317 put_sh_flags(typename Elf_types<size>::Elf_WXword v) 1318 { this->p_->sh_flags = Convert<size, big_endian>::convert_host(v); } 1319 1320 void 1321 put_sh_addr(typename Elf_types<size>::Elf_Addr v) 1322 { this->p_->sh_addr = Convert<size, big_endian>::convert_host(v); } 1323 1324 void 1325 put_sh_offset(typename Elf_types<size>::Elf_Off v) 1326 { this->p_->sh_offset = Convert<size, big_endian>::convert_host(v); } 1327 1328 void 1329 put_sh_size(typename Elf_types<size>::Elf_WXword v) 1330 { this->p_->sh_size = Convert<size, big_endian>::convert_host(v); } 1331 1332 void 1333 put_sh_link(Elf_Word v) 1334 { this->p_->sh_link = Convert<32, big_endian>::convert_host(v); } 1335 1336 void 1337 put_sh_info(Elf_Word v) 1338 { this->p_->sh_info = Convert<32, big_endian>::convert_host(v); } 1339 1340 void 1341 put_sh_addralign(typename Elf_types<size>::Elf_WXword v) 1342 { this->p_->sh_addralign = Convert<size, big_endian>::convert_host(v); } 1343 1344 void 1345 put_sh_entsize(typename Elf_types<size>::Elf_WXword v) 1346 { this->p_->sh_entsize = Convert<size, big_endian>::convert_host(v); } 1347 1348 private: 1349 internal::Shdr_data<size>* p_; 1350 }; 1351 1352 // Accessor class for an ELF compression header. 1353 1354 template<int size, bool big_endian> 1355 class Chdr 1356 { 1357 public: 1358 Chdr(const unsigned char* p) 1359 : p_(reinterpret_cast<const internal::Chdr_data<size>*>(p)) 1360 { } 1361 1362 template<typename File> 1363 Chdr(File* file, typename File::Location loc) 1364 : p_(reinterpret_cast<const internal::Chdr_data<size>*>( 1365 file->view(loc.file_offset, loc.data_size).data())) 1366 { } 1367 1368 Elf_Word 1369 get_ch_type() const 1370 { return Convert<size, big_endian>::convert_host(this->p_->ch_type); } 1371 1372 typename Elf_types<size>::Elf_WXword 1373 get_ch_size() const 1374 { return Convert<size, big_endian>::convert_host(this->p_->ch_size); } 1375 1376 typename Elf_types<size>::Elf_WXword 1377 get_ch_addralign() const 1378 { return 1379 Convert<size, big_endian>::convert_host(this->p_->ch_addralign); } 1380 1381 private: 1382 const internal::Chdr_data<size>* p_; 1383 }; 1384 1385 // Write class for an ELF compression header. 1386 1387 template<int size, bool big_endian> 1388 class Chdr_write 1389 { 1390 public: 1391 Chdr_write(unsigned char* p) 1392 : p_(reinterpret_cast<internal::Chdr_data<size>*>(p)) 1393 { } 1394 1395 void 1396 put_ch_type(typename Elf_types<size>::Elf_WXword v) 1397 { this->p_->ch_type = Convert<size, big_endian>::convert_host(v); } 1398 1399 void 1400 put_ch_size(typename Elf_types<size>::Elf_WXword v) 1401 { this->p_->ch_size = Convert<size, big_endian>::convert_host(v); } 1402 1403 void 1404 put_ch_addralign(typename Elf_types<size>::Elf_WXword v) 1405 { this->p_->ch_addralign = Convert<size, big_endian>::convert_host(v); } 1406 1407 void 1408 put_ch_reserved(Elf_Word); 1409 1410 private: 1411 internal::Chdr_data<size>* p_; 1412 }; 1413 1414 template<> 1415 inline void 1416 elfcpp::Chdr_write<64, true>::put_ch_reserved(Elf_Word v) 1417 { 1418 this->p_->ch_reserved = v; 1419 } 1420 1421 template<> 1422 inline void 1423 elfcpp::Chdr_write<64, false>::put_ch_reserved(Elf_Word v) 1424 { 1425 this->p_->ch_reserved = v; 1426 } 1427 1428 // Accessor class for an ELF segment header. 1429 1430 template<int size, bool big_endian> 1431 class Phdr 1432 { 1433 public: 1434 Phdr(const unsigned char* p) 1435 : p_(reinterpret_cast<const internal::Phdr_data<size>*>(p)) 1436 { } 1437 1438 template<typename File> 1439 Phdr(File* file, typename File::Location loc) 1440 : p_(reinterpret_cast<internal::Phdr_data<size>*>( 1441 file->view(loc.file_offset, loc.data_size).data())) 1442 { } 1443 1444 Elf_Word 1445 get_p_type() const 1446 { return Convert<32, big_endian>::convert_host(this->p_->p_type); } 1447 1448 typename Elf_types<size>::Elf_Off 1449 get_p_offset() const 1450 { return Convert<size, big_endian>::convert_host(this->p_->p_offset); } 1451 1452 typename Elf_types<size>::Elf_Addr 1453 get_p_vaddr() const 1454 { return Convert<size, big_endian>::convert_host(this->p_->p_vaddr); } 1455 1456 typename Elf_types<size>::Elf_Addr 1457 get_p_paddr() const 1458 { return Convert<size, big_endian>::convert_host(this->p_->p_paddr); } 1459 1460 typename Elf_types<size>::Elf_WXword 1461 get_p_filesz() const 1462 { return Convert<size, big_endian>::convert_host(this->p_->p_filesz); } 1463 1464 typename Elf_types<size>::Elf_WXword 1465 get_p_memsz() const 1466 { return Convert<size, big_endian>::convert_host(this->p_->p_memsz); } 1467 1468 Elf_Word 1469 get_p_flags() const 1470 { return Convert<32, big_endian>::convert_host(this->p_->p_flags); } 1471 1472 typename Elf_types<size>::Elf_WXword 1473 get_p_align() const 1474 { return Convert<size, big_endian>::convert_host(this->p_->p_align); } 1475 1476 private: 1477 const internal::Phdr_data<size>* p_; 1478 }; 1479 1480 // Write class for an ELF segment header. 1481 1482 template<int size, bool big_endian> 1483 class Phdr_write 1484 { 1485 public: 1486 Phdr_write(unsigned char* p) 1487 : p_(reinterpret_cast<internal::Phdr_data<size>*>(p)) 1488 { } 1489 1490 void 1491 put_p_type(Elf_Word v) 1492 { this->p_->p_type = Convert<32, big_endian>::convert_host(v); } 1493 1494 void 1495 put_p_offset(typename Elf_types<size>::Elf_Off v) 1496 { this->p_->p_offset = Convert<size, big_endian>::convert_host(v); } 1497 1498 void 1499 put_p_vaddr(typename Elf_types<size>::Elf_Addr v) 1500 { this->p_->p_vaddr = Convert<size, big_endian>::convert_host(v); } 1501 1502 void 1503 put_p_paddr(typename Elf_types<size>::Elf_Addr v) 1504 { this->p_->p_paddr = Convert<size, big_endian>::convert_host(v); } 1505 1506 void 1507 put_p_filesz(typename Elf_types<size>::Elf_WXword v) 1508 { this->p_->p_filesz = Convert<size, big_endian>::convert_host(v); } 1509 1510 void 1511 put_p_memsz(typename Elf_types<size>::Elf_WXword v) 1512 { this->p_->p_memsz = Convert<size, big_endian>::convert_host(v); } 1513 1514 void 1515 put_p_flags(Elf_Word v) 1516 { this->p_->p_flags = Convert<32, big_endian>::convert_host(v); } 1517 1518 void 1519 put_p_align(typename Elf_types<size>::Elf_WXword v) 1520 { this->p_->p_align = Convert<size, big_endian>::convert_host(v); } 1521 1522 private: 1523 internal::Phdr_data<size>* p_; 1524 }; 1525 1526 // Accessor class for an ELF symbol table entry. 1527 1528 template<int size, bool big_endian> 1529 class Sym 1530 { 1531 public: 1532 Sym(const unsigned char* p) 1533 : p_(reinterpret_cast<const internal::Sym_data<size>*>(p)) 1534 { } 1535 1536 template<typename File> 1537 Sym(File* file, typename File::Location loc) 1538 : p_(reinterpret_cast<const internal::Sym_data<size>*>( 1539 file->view(loc.file_offset, loc.data_size).data())) 1540 { } 1541 1542 Elf_Word 1543 get_st_name() const 1544 { return Convert<32, big_endian>::convert_host(this->p_->st_name); } 1545 1546 typename Elf_types<size>::Elf_Addr 1547 get_st_value() const 1548 { return Convert<size, big_endian>::convert_host(this->p_->st_value); } 1549 1550 typename Elf_types<size>::Elf_WXword 1551 get_st_size() const 1552 { return Convert<size, big_endian>::convert_host(this->p_->st_size); } 1553 1554 unsigned char 1555 get_st_info() const 1556 { return this->p_->st_info; } 1557 1558 STB 1559 get_st_bind() const 1560 { return elf_st_bind(this->get_st_info()); } 1561 1562 STT 1563 get_st_type() const 1564 { return elf_st_type(this->get_st_info()); } 1565 1566 unsigned char 1567 get_st_other() const 1568 { return this->p_->st_other; } 1569 1570 STV 1571 get_st_visibility() const 1572 { return elf_st_visibility(this->get_st_other()); } 1573 1574 unsigned char 1575 get_st_nonvis() const 1576 { return elf_st_nonvis(this->get_st_other()); } 1577 1578 Elf_Half 1579 get_st_shndx() const 1580 { return Convert<16, big_endian>::convert_host(this->p_->st_shndx); } 1581 1582 private: 1583 const internal::Sym_data<size>* p_; 1584 }; 1585 1586 // Writer class for an ELF symbol table entry. 1587 1588 template<int size, bool big_endian> 1589 class Sym_write 1590 { 1591 public: 1592 Sym_write(unsigned char* p) 1593 : p_(reinterpret_cast<internal::Sym_data<size>*>(p)) 1594 { } 1595 1596 void 1597 put_st_name(Elf_Word v) 1598 { this->p_->st_name = Convert<32, big_endian>::convert_host(v); } 1599 1600 void 1601 put_st_value(typename Elf_types<size>::Elf_Addr v) 1602 { this->p_->st_value = Convert<size, big_endian>::convert_host(v); } 1603 1604 void 1605 put_st_size(typename Elf_types<size>::Elf_WXword v) 1606 { this->p_->st_size = Convert<size, big_endian>::convert_host(v); } 1607 1608 void 1609 put_st_info(unsigned char v) 1610 { this->p_->st_info = v; } 1611 1612 void 1613 put_st_info(STB bind, STT type) 1614 { this->p_->st_info = elf_st_info(bind, type); } 1615 1616 void 1617 put_st_other(unsigned char v) 1618 { this->p_->st_other = v; } 1619 1620 void 1621 put_st_other(STV vis, unsigned char nonvis) 1622 { this->p_->st_other = elf_st_other(vis, nonvis); } 1623 1624 void 1625 put_st_shndx(Elf_Half v) 1626 { this->p_->st_shndx = Convert<16, big_endian>::convert_host(v); } 1627 1628 Sym<size, big_endian> 1629 sym() 1630 { return Sym<size, big_endian>(reinterpret_cast<unsigned char*>(this->p_)); } 1631 1632 private: 1633 internal::Sym_data<size>* p_; 1634 }; 1635 1636 // Accessor classes for an ELF REL relocation entry. 1637 1638 template<int size, bool big_endian> 1639 class Rel 1640 { 1641 public: 1642 Rel(const unsigned char* p) 1643 : p_(reinterpret_cast<const internal::Rel_data<size>*>(p)) 1644 { } 1645 1646 template<typename File> 1647 Rel(File* file, typename File::Location loc) 1648 : p_(reinterpret_cast<const internal::Rel_data<size>*>( 1649 file->view(loc.file_offset, loc.data_size).data())) 1650 { } 1651 1652 typename Elf_types<size>::Elf_Addr 1653 get_r_offset() const 1654 { return Convert<size, big_endian>::convert_host(this->p_->r_offset); } 1655 1656 typename Elf_types<size>::Elf_WXword 1657 get_r_info() const 1658 { return Convert<size, big_endian>::convert_host(this->p_->r_info); } 1659 1660 private: 1661 const internal::Rel_data<size>* p_; 1662 }; 1663 1664 // Writer class for an ELF Rel relocation. 1665 1666 template<int size, bool big_endian> 1667 class Rel_write 1668 { 1669 public: 1670 Rel_write(unsigned char* p) 1671 : p_(reinterpret_cast<internal::Rel_data<size>*>(p)) 1672 { } 1673 1674 void 1675 put_r_offset(typename Elf_types<size>::Elf_Addr v) 1676 { this->p_->r_offset = Convert<size, big_endian>::convert_host(v); } 1677 1678 void 1679 put_r_info(typename Elf_types<size>::Elf_WXword v) 1680 { this->p_->r_info = Convert<size, big_endian>::convert_host(v); } 1681 1682 private: 1683 internal::Rel_data<size>* p_; 1684 }; 1685 1686 // Accessor class for an ELF Rela relocation. 1687 1688 template<int size, bool big_endian> 1689 class Rela 1690 { 1691 public: 1692 Rela(const unsigned char* p) 1693 : p_(reinterpret_cast<const internal::Rela_data<size>*>(p)) 1694 { } 1695 1696 template<typename File> 1697 Rela(File* file, typename File::Location loc) 1698 : p_(reinterpret_cast<const internal::Rela_data<size>*>( 1699 file->view(loc.file_offset, loc.data_size).data())) 1700 { } 1701 1702 typename Elf_types<size>::Elf_Addr 1703 get_r_offset() const 1704 { return Convert<size, big_endian>::convert_host(this->p_->r_offset); } 1705 1706 typename Elf_types<size>::Elf_WXword 1707 get_r_info() const 1708 { return Convert<size, big_endian>::convert_host(this->p_->r_info); } 1709 1710 typename Elf_types<size>::Elf_Swxword 1711 get_r_addend() const 1712 { return Convert<size, big_endian>::convert_host(this->p_->r_addend); } 1713 1714 private: 1715 const internal::Rela_data<size>* p_; 1716 }; 1717 1718 // Writer class for an ELF Rela relocation. 1719 1720 template<int size, bool big_endian> 1721 class Rela_write 1722 { 1723 public: 1724 Rela_write(unsigned char* p) 1725 : p_(reinterpret_cast<internal::Rela_data<size>*>(p)) 1726 { } 1727 1728 void 1729 put_r_offset(typename Elf_types<size>::Elf_Addr v) 1730 { this->p_->r_offset = Convert<size, big_endian>::convert_host(v); } 1731 1732 void 1733 put_r_info(typename Elf_types<size>::Elf_WXword v) 1734 { this->p_->r_info = Convert<size, big_endian>::convert_host(v); } 1735 1736 void 1737 put_r_addend(typename Elf_types<size>::Elf_Swxword v) 1738 { this->p_->r_addend = Convert<size, big_endian>::convert_host(v); } 1739 1740 private: 1741 internal::Rela_data<size>* p_; 1742 }; 1743 1744 // MIPS-64 has a non-standard relocation layout. 1745 1746 template<bool big_endian> 1747 class Mips64_rel 1748 { 1749 public: 1750 Mips64_rel(const unsigned char* p) 1751 : p_(reinterpret_cast<const internal::Mips64_rel_data*>(p)) 1752 { } 1753 1754 template<typename File> 1755 Mips64_rel(File* file, typename File::Location loc) 1756 : p_(reinterpret_cast<const internal::Mips64_rel_data*>( 1757 file->view(loc.file_offset, loc.data_size).data())) 1758 { } 1759 1760 typename Elf_types<64>::Elf_Addr 1761 get_r_offset() const 1762 { return Convert<64, big_endian>::convert_host(this->p_->r_offset); } 1763 1764 Elf_Word 1765 get_r_sym() const 1766 { return Convert<32, big_endian>::convert_host(this->p_->r_sym); } 1767 1768 unsigned char 1769 get_r_ssym() const 1770 { return this->p_->r_ssym; } 1771 1772 unsigned char 1773 get_r_type() const 1774 { return this->p_->r_type; } 1775 1776 unsigned char 1777 get_r_type2() const 1778 { return this->p_->r_type2; } 1779 1780 unsigned char 1781 get_r_type3() const 1782 { return this->p_->r_type3; } 1783 1784 private: 1785 const internal::Mips64_rel_data* p_; 1786 }; 1787 1788 template<bool big_endian> 1789 class Mips64_rel_write 1790 { 1791 public: 1792 Mips64_rel_write(unsigned char* p) 1793 : p_(reinterpret_cast<internal::Mips64_rel_data*>(p)) 1794 { } 1795 1796 void 1797 put_r_offset(typename Elf_types<64>::Elf_Addr v) 1798 { this->p_->r_offset = Convert<64, big_endian>::convert_host(v); } 1799 1800 void 1801 put_r_sym(Elf_Word v) 1802 { this->p_->r_sym = Convert<32, big_endian>::convert_host(v); } 1803 1804 void 1805 put_r_ssym(unsigned char v) 1806 { this->p_->r_ssym = v; } 1807 1808 void 1809 put_r_type(unsigned char v) 1810 { this->p_->r_type = v; } 1811 1812 void 1813 put_r_type2(unsigned char v) 1814 { this->p_->r_type2 = v; } 1815 1816 void 1817 put_r_type3(unsigned char v) 1818 { this->p_->r_type3 = v; } 1819 1820 private: 1821 internal::Mips64_rel_data* p_; 1822 }; 1823 1824 template<bool big_endian> 1825 class Mips64_rela 1826 { 1827 public: 1828 Mips64_rela(const unsigned char* p) 1829 : p_(reinterpret_cast<const internal::Mips64_rela_data*>(p)) 1830 { } 1831 1832 template<typename File> 1833 Mips64_rela(File* file, typename File::Location loc) 1834 : p_(reinterpret_cast<const internal::Mips64_rela_data*>( 1835 file->view(loc.file_offset, loc.data_size).data())) 1836 { } 1837 1838 typename Elf_types<64>::Elf_Addr 1839 get_r_offset() const 1840 { return Convert<64, big_endian>::convert_host(this->p_->r_offset); } 1841 1842 Elf_Word 1843 get_r_sym() const 1844 { return Convert<32, big_endian>::convert_host(this->p_->r_sym); } 1845 1846 unsigned char 1847 get_r_ssym() const 1848 { return this->p_->r_ssym; } 1849 1850 unsigned char 1851 get_r_type() const 1852 { return this->p_->r_type; } 1853 1854 unsigned char 1855 get_r_type2() const 1856 { return this->p_->r_type2; } 1857 1858 unsigned char 1859 get_r_type3() const 1860 { return this->p_->r_type3; } 1861 1862 typename Elf_types<64>::Elf_Swxword 1863 get_r_addend() const 1864 { return Convert<64, big_endian>::convert_host(this->p_->r_addend); } 1865 1866 private: 1867 const internal::Mips64_rela_data* p_; 1868 }; 1869 1870 template<bool big_endian> 1871 class Mips64_rela_write 1872 { 1873 public: 1874 Mips64_rela_write(unsigned char* p) 1875 : p_(reinterpret_cast<internal::Mips64_rela_data*>(p)) 1876 { } 1877 1878 void 1879 put_r_offset(typename Elf_types<64>::Elf_Addr v) 1880 { this->p_->r_offset = Convert<64, big_endian>::convert_host(v); } 1881 1882 void 1883 put_r_sym(Elf_Word v) 1884 { this->p_->r_sym = Convert<32, big_endian>::convert_host(v); } 1885 1886 void 1887 put_r_ssym(unsigned char v) 1888 { this->p_->r_ssym = v; } 1889 1890 void 1891 put_r_type(unsigned char v) 1892 { this->p_->r_type = v; } 1893 1894 void 1895 put_r_type2(unsigned char v) 1896 { this->p_->r_type2 = v; } 1897 1898 void 1899 put_r_type3(unsigned char v) 1900 { this->p_->r_type3 = v; } 1901 1902 void 1903 put_r_addend(typename Elf_types<64>::Elf_Swxword v) 1904 { this->p_->r_addend = Convert<64, big_endian>::convert_host(v); } 1905 1906 private: 1907 internal::Mips64_rela_data* p_; 1908 }; 1909 1910 // Accessor classes for entries in the ELF SHT_DYNAMIC section aka 1911 // PT_DYNAMIC segment. 1912 1913 template<int size, bool big_endian> 1914 class Dyn 1915 { 1916 public: 1917 Dyn(const unsigned char* p) 1918 : p_(reinterpret_cast<const internal::Dyn_data<size>*>(p)) 1919 { } 1920 1921 template<typename File> 1922 Dyn(File* file, typename File::Location loc) 1923 : p_(reinterpret_cast<const internal::Dyn_data<size>*>( 1924 file->view(loc.file_offset, loc.data_size).data())) 1925 { } 1926 1927 typename Elf_types<size>::Elf_Swxword 1928 get_d_tag() const 1929 { return Convert<size, big_endian>::convert_host(this->p_->d_tag); } 1930 1931 typename Elf_types<size>::Elf_WXword 1932 get_d_val() const 1933 { return Convert<size, big_endian>::convert_host(this->p_->d_val); } 1934 1935 typename Elf_types<size>::Elf_Addr 1936 get_d_ptr() const 1937 { return Convert<size, big_endian>::convert_host(this->p_->d_val); } 1938 1939 private: 1940 const internal::Dyn_data<size>* p_; 1941 }; 1942 1943 // Write class for an entry in the SHT_DYNAMIC section. 1944 1945 template<int size, bool big_endian> 1946 class Dyn_write 1947 { 1948 public: 1949 Dyn_write(unsigned char* p) 1950 : p_(reinterpret_cast<internal::Dyn_data<size>*>(p)) 1951 { } 1952 1953 void 1954 put_d_tag(typename Elf_types<size>::Elf_Swxword v) 1955 { this->p_->d_tag = Convert<size, big_endian>::convert_host(v); } 1956 1957 void 1958 put_d_val(typename Elf_types<size>::Elf_WXword v) 1959 { this->p_->d_val = Convert<size, big_endian>::convert_host(v); } 1960 1961 void 1962 put_d_ptr(typename Elf_types<size>::Elf_Addr v) 1963 { this->p_->d_val = Convert<size, big_endian>::convert_host(v); } 1964 1965 private: 1966 internal::Dyn_data<size>* p_; 1967 }; 1968 1969 // Accessor classes for entries in the ELF SHT_GNU_verdef section. 1970 1971 template<int size, bool big_endian> 1972 class Verdef 1973 { 1974 public: 1975 Verdef(const unsigned char* p) 1976 : p_(reinterpret_cast<const internal::Verdef_data*>(p)) 1977 { } 1978 1979 template<typename File> 1980 Verdef(File* file, typename File::Location loc) 1981 : p_(reinterpret_cast<const internal::Verdef_data*>( 1982 file->view(loc.file_offset, loc.data_size).data())) 1983 { } 1984 1985 Elf_Half 1986 get_vd_version() const 1987 { return Convert<16, big_endian>::convert_host(this->p_->vd_version); } 1988 1989 Elf_Half 1990 get_vd_flags() const 1991 { return Convert<16, big_endian>::convert_host(this->p_->vd_flags); } 1992 1993 Elf_Half 1994 get_vd_ndx() const 1995 { return Convert<16, big_endian>::convert_host(this->p_->vd_ndx); } 1996 1997 Elf_Half 1998 get_vd_cnt() const 1999 { return Convert<16, big_endian>::convert_host(this->p_->vd_cnt); } 2000 2001 Elf_Word 2002 get_vd_hash() const 2003 { return Convert<32, big_endian>::convert_host(this->p_->vd_hash); } 2004 2005 Elf_Word 2006 get_vd_aux() const 2007 { return Convert<32, big_endian>::convert_host(this->p_->vd_aux); } 2008 2009 Elf_Word 2010 get_vd_next() const 2011 { return Convert<32, big_endian>::convert_host(this->p_->vd_next); } 2012 2013 private: 2014 const internal::Verdef_data* p_; 2015 }; 2016 2017 template<int size, bool big_endian> 2018 class Verdef_write 2019 { 2020 public: 2021 Verdef_write(unsigned char* p) 2022 : p_(reinterpret_cast<internal::Verdef_data*>(p)) 2023 { } 2024 2025 void 2026 set_vd_version(Elf_Half v) 2027 { this->p_->vd_version = Convert<16, big_endian>::convert_host(v); } 2028 2029 void 2030 set_vd_flags(Elf_Half v) 2031 { this->p_->vd_flags = Convert<16, big_endian>::convert_host(v); } 2032 2033 void 2034 set_vd_ndx(Elf_Half v) 2035 { this->p_->vd_ndx = Convert<16, big_endian>::convert_host(v); } 2036 2037 void 2038 set_vd_cnt(Elf_Half v) 2039 { this->p_->vd_cnt = Convert<16, big_endian>::convert_host(v); } 2040 2041 void 2042 set_vd_hash(Elf_Word v) 2043 { this->p_->vd_hash = Convert<32, big_endian>::convert_host(v); } 2044 2045 void 2046 set_vd_aux(Elf_Word v) 2047 { this->p_->vd_aux = Convert<32, big_endian>::convert_host(v); } 2048 2049 void 2050 set_vd_next(Elf_Word v) 2051 { this->p_->vd_next = Convert<32, big_endian>::convert_host(v); } 2052 2053 private: 2054 internal::Verdef_data* p_; 2055 }; 2056 2057 // Accessor classes for auxiliary entries in the ELF SHT_GNU_verdef 2058 // section. 2059 2060 template<int size, bool big_endian> 2061 class Verdaux 2062 { 2063 public: 2064 Verdaux(const unsigned char* p) 2065 : p_(reinterpret_cast<const internal::Verdaux_data*>(p)) 2066 { } 2067 2068 template<typename File> 2069 Verdaux(File* file, typename File::Location loc) 2070 : p_(reinterpret_cast<const internal::Verdaux_data*>( 2071 file->view(loc.file_offset, loc.data_size).data())) 2072 { } 2073 2074 Elf_Word 2075 get_vda_name() const 2076 { return Convert<32, big_endian>::convert_host(this->p_->vda_name); } 2077 2078 Elf_Word 2079 get_vda_next() const 2080 { return Convert<32, big_endian>::convert_host(this->p_->vda_next); } 2081 2082 private: 2083 const internal::Verdaux_data* p_; 2084 }; 2085 2086 template<int size, bool big_endian> 2087 class Verdaux_write 2088 { 2089 public: 2090 Verdaux_write(unsigned char* p) 2091 : p_(reinterpret_cast<internal::Verdaux_data*>(p)) 2092 { } 2093 2094 void 2095 set_vda_name(Elf_Word v) 2096 { this->p_->vda_name = Convert<32, big_endian>::convert_host(v); } 2097 2098 void 2099 set_vda_next(Elf_Word v) 2100 { this->p_->vda_next = Convert<32, big_endian>::convert_host(v); } 2101 2102 private: 2103 internal::Verdaux_data* p_; 2104 }; 2105 2106 // Accessor classes for entries in the ELF SHT_GNU_verneed section. 2107 2108 template<int size, bool big_endian> 2109 class Verneed 2110 { 2111 public: 2112 Verneed(const unsigned char* p) 2113 : p_(reinterpret_cast<const internal::Verneed_data*>(p)) 2114 { } 2115 2116 template<typename File> 2117 Verneed(File* file, typename File::Location loc) 2118 : p_(reinterpret_cast<const internal::Verneed_data*>( 2119 file->view(loc.file_offset, loc.data_size).data())) 2120 { } 2121 2122 Elf_Half 2123 get_vn_version() const 2124 { return Convert<16, big_endian>::convert_host(this->p_->vn_version); } 2125 2126 Elf_Half 2127 get_vn_cnt() const 2128 { return Convert<16, big_endian>::convert_host(this->p_->vn_cnt); } 2129 2130 Elf_Word 2131 get_vn_file() const 2132 { return Convert<32, big_endian>::convert_host(this->p_->vn_file); } 2133 2134 Elf_Word 2135 get_vn_aux() const 2136 { return Convert<32, big_endian>::convert_host(this->p_->vn_aux); } 2137 2138 Elf_Word 2139 get_vn_next() const 2140 { return Convert<32, big_endian>::convert_host(this->p_->vn_next); } 2141 2142 private: 2143 const internal::Verneed_data* p_; 2144 }; 2145 2146 template<int size, bool big_endian> 2147 class Verneed_write 2148 { 2149 public: 2150 Verneed_write(unsigned char* p) 2151 : p_(reinterpret_cast<internal::Verneed_data*>(p)) 2152 { } 2153 2154 void 2155 set_vn_version(Elf_Half v) 2156 { this->p_->vn_version = Convert<16, big_endian>::convert_host(v); } 2157 2158 void 2159 set_vn_cnt(Elf_Half v) 2160 { this->p_->vn_cnt = Convert<16, big_endian>::convert_host(v); } 2161 2162 void 2163 set_vn_file(Elf_Word v) 2164 { this->p_->vn_file = Convert<32, big_endian>::convert_host(v); } 2165 2166 void 2167 set_vn_aux(Elf_Word v) 2168 { this->p_->vn_aux = Convert<32, big_endian>::convert_host(v); } 2169 2170 void 2171 set_vn_next(Elf_Word v) 2172 { this->p_->vn_next = Convert<32, big_endian>::convert_host(v); } 2173 2174 private: 2175 internal::Verneed_data* p_; 2176 }; 2177 2178 // Accessor classes for auxiliary entries in the ELF SHT_GNU_verneed 2179 // section. 2180 2181 template<int size, bool big_endian> 2182 class Vernaux 2183 { 2184 public: 2185 Vernaux(const unsigned char* p) 2186 : p_(reinterpret_cast<const internal::Vernaux_data*>(p)) 2187 { } 2188 2189 template<typename File> 2190 Vernaux(File* file, typename File::Location loc) 2191 : p_(reinterpret_cast<const internal::Vernaux_data*>( 2192 file->view(loc.file_offset, loc.data_size).data())) 2193 { } 2194 2195 Elf_Word 2196 get_vna_hash() const 2197 { return Convert<32, big_endian>::convert_host(this->p_->vna_hash); } 2198 2199 Elf_Half 2200 get_vna_flags() const 2201 { return Convert<16, big_endian>::convert_host(this->p_->vna_flags); } 2202 2203 Elf_Half 2204 get_vna_other() const 2205 { return Convert<16, big_endian>::convert_host(this->p_->vna_other); } 2206 2207 Elf_Word 2208 get_vna_name() const 2209 { return Convert<32, big_endian>::convert_host(this->p_->vna_name); } 2210 2211 Elf_Word 2212 get_vna_next() const 2213 { return Convert<32, big_endian>::convert_host(this->p_->vna_next); } 2214 2215 private: 2216 const internal::Vernaux_data* p_; 2217 }; 2218 2219 template<int size, bool big_endian> 2220 class Vernaux_write 2221 { 2222 public: 2223 Vernaux_write(unsigned char* p) 2224 : p_(reinterpret_cast<internal::Vernaux_data*>(p)) 2225 { } 2226 2227 void 2228 set_vna_hash(Elf_Word v) 2229 { this->p_->vna_hash = Convert<32, big_endian>::convert_host(v); } 2230 2231 void 2232 set_vna_flags(Elf_Half v) 2233 { this->p_->vna_flags = Convert<16, big_endian>::convert_host(v); } 2234 2235 void 2236 set_vna_other(Elf_Half v) 2237 { this->p_->vna_other = Convert<16, big_endian>::convert_host(v); } 2238 2239 void 2240 set_vna_name(Elf_Word v) 2241 { this->p_->vna_name = Convert<32, big_endian>::convert_host(v); } 2242 2243 void 2244 set_vna_next(Elf_Word v) 2245 { this->p_->vna_next = Convert<32, big_endian>::convert_host(v); } 2246 2247 private: 2248 internal::Vernaux_data* p_; 2249 }; 2250 2251 } // End namespace elfcpp. 2252 2253 #endif // !defined(ELFPCP_H) 2254