1 // elfcpp.h -- main header file for elfcpp -*- C++ -*- 2 3 // Copyright (C) 2006-2020 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 // Link editor is to sort the entries in this section based on the 417 // address specified in the associated symbol table entry. 418 SHT_ORDERED = 0x7fffffff 419 }; 420 421 // The valid bit flags found in the Shdr sh_flags field. 422 423 enum SHF 424 { 425 SHF_WRITE = 0x1, 426 SHF_ALLOC = 0x2, 427 SHF_EXECINSTR = 0x4, 428 SHF_MERGE = 0x10, 429 SHF_STRINGS = 0x20, 430 SHF_INFO_LINK = 0x40, 431 SHF_LINK_ORDER = 0x80, 432 SHF_OS_NONCONFORMING = 0x100, 433 SHF_GROUP = 0x200, 434 SHF_TLS = 0x400, 435 SHF_COMPRESSED = 0x800, 436 SHF_MASKOS = 0x0ff00000, 437 SHF_MASKPROC = 0xf0000000, 438 439 // Indicates this section requires ordering in relation to 440 // other sections of the same type. Ordered sections are 441 // combined within the section pointed to by the sh_link entry. 442 // The sh_info values SHN_BEFORE and SHN_AFTER imply that the 443 // sorted section is to precede or follow, respectively, all 444 // other sections in the set being ordered. 445 SHF_ORDERED = 0x40000000, 446 // This section is excluded from input to the link-edit of an 447 // executable or shared object. This flag is ignored if SHF_ALLOC 448 // is also set, or if relocations exist against the section. 449 SHF_EXCLUDE = 0x80000000, 450 451 // Section with data that is GP relative addressable. 452 SHF_MIPS_GPREL = 0x10000000, 453 454 // x86_64 specific large section. 455 SHF_X86_64_LARGE = 0x10000000 456 }; 457 458 // Values which appear in the first Elf_WXword of the section data 459 // of a SHF_COMPRESSED section. 460 enum 461 { 462 ELFCOMPRESS_ZLIB = 1, 463 ELFCOMPRESS_LOOS = 0x60000000, 464 ELFCOMPRESS_HIOS = 0x6fffffff, 465 ELFCOMPRESS_LOPROC = 0x70000000, 466 ELFCOMPRESS_HIPROC = 0x7fffffff, 467 }; 468 469 // Bit flags which appear in the first 32-bit word of the section data 470 // of a SHT_GROUP section. 471 472 enum 473 { 474 GRP_COMDAT = 0x1, 475 GRP_MASKOS = 0x0ff00000, 476 GRP_MASKPROC = 0xf0000000 477 }; 478 479 // The valid values found in the Phdr p_type field. 480 481 enum PT 482 { 483 PT_NULL = 0, 484 PT_LOAD = 1, 485 PT_DYNAMIC = 2, 486 PT_INTERP = 3, 487 PT_NOTE = 4, 488 PT_SHLIB = 5, 489 PT_PHDR = 6, 490 PT_TLS = 7, 491 PT_LOOS = 0x60000000, 492 PT_HIOS = 0x6fffffff, 493 PT_LOPROC = 0x70000000, 494 PT_HIPROC = 0x7fffffff, 495 // The remaining values are not in the standard. 496 // Frame unwind information. 497 PT_GNU_EH_FRAME = 0x6474e550, 498 PT_SUNW_EH_FRAME = 0x6474e550, 499 // Stack flags. 500 PT_GNU_STACK = 0x6474e551, 501 // Read only after relocation. 502 PT_GNU_RELRO = 0x6474e552, 503 // Platform architecture compatibility information 504 PT_ARM_ARCHEXT = 0x70000000, 505 // Exception unwind tables 506 PT_ARM_EXIDX = 0x70000001, 507 // Register usage information. Identifies one .reginfo section. 508 PT_MIPS_REGINFO =0x70000000, 509 // Runtime procedure table. 510 PT_MIPS_RTPROC = 0x70000001, 511 // .MIPS.options section. 512 PT_MIPS_OPTIONS = 0x70000002, 513 // .MIPS.abiflags section. 514 PT_MIPS_ABIFLAGS = 0x70000003, 515 // Platform architecture compatibility information 516 PT_AARCH64_ARCHEXT = 0x70000000, 517 // Exception unwind tables 518 PT_AARCH64_UNWIND = 0x70000001, 519 // 4k page table size 520 PT_S390_PGSTE = 0x70000000, 521 }; 522 523 // The valid bit flags found in the Phdr p_flags field. 524 525 enum PF 526 { 527 PF_X = 0x1, 528 PF_W = 0x2, 529 PF_R = 0x4, 530 PF_MASKOS = 0x0ff00000, 531 PF_MASKPROC = 0xf0000000 532 }; 533 534 // Symbol binding from Sym st_info field. 535 536 enum STB 537 { 538 STB_LOCAL = 0, 539 STB_GLOBAL = 1, 540 STB_WEAK = 2, 541 STB_LOOS = 10, 542 STB_GNU_UNIQUE = 10, 543 STB_HIOS = 12, 544 STB_LOPROC = 13, 545 STB_HIPROC = 15 546 }; 547 548 // Symbol types from Sym st_info field. 549 550 enum STT 551 { 552 STT_NOTYPE = 0, 553 STT_OBJECT = 1, 554 STT_FUNC = 2, 555 STT_SECTION = 3, 556 STT_FILE = 4, 557 STT_COMMON = 5, 558 STT_TLS = 6, 559 560 // GNU extension: symbol value points to a function which is called 561 // at runtime to determine the final value of the symbol. 562 STT_GNU_IFUNC = 10, 563 564 STT_LOOS = 10, 565 STT_HIOS = 12, 566 STT_LOPROC = 13, 567 STT_HIPROC = 15, 568 569 // The section type that must be used for register symbols on 570 // Sparc. These symbols initialize a global register. 571 STT_SPARC_REGISTER = 13, 572 573 // ARM: a THUMB function. This is not defined in ARM ELF Specification but 574 // used by the GNU tool-chain. 575 STT_ARM_TFUNC = 13 576 }; 577 578 inline STB 579 elf_st_bind(unsigned char info) 580 { 581 return static_cast<STB>(info >> 4); 582 } 583 584 inline STT 585 elf_st_type(unsigned char info) 586 { 587 return static_cast<STT>(info & 0xf); 588 } 589 590 inline unsigned char 591 elf_st_info(STB bind, STT type) 592 { 593 return ((static_cast<unsigned char>(bind) << 4) 594 + (static_cast<unsigned char>(type) & 0xf)); 595 } 596 597 // Symbol visibility from Sym st_other field. 598 599 enum STV 600 { 601 STV_DEFAULT = 0, 602 STV_INTERNAL = 1, 603 STV_HIDDEN = 2, 604 STV_PROTECTED = 3 605 }; 606 607 inline STV 608 elf_st_visibility(unsigned char other) 609 { 610 return static_cast<STV>(other & 0x3); 611 } 612 613 inline unsigned char 614 elf_st_nonvis(unsigned char other) 615 { 616 return static_cast<STV>(other >> 2); 617 } 618 619 inline unsigned char 620 elf_st_other(STV vis, unsigned char nonvis) 621 { 622 return ((nonvis << 2) 623 + (static_cast<unsigned char>(vis) & 3)); 624 } 625 626 // Reloc information from Rel/Rela r_info field. 627 628 template<int size> 629 unsigned int 630 elf_r_sym(typename Elf_types<size>::Elf_WXword); 631 632 template<> 633 inline unsigned int 634 elf_r_sym<32>(Elf_Word v) 635 { 636 return v >> 8; 637 } 638 639 template<> 640 inline unsigned int 641 elf_r_sym<64>(Elf_Xword v) 642 { 643 return v >> 32; 644 } 645 646 template<int size> 647 unsigned int 648 elf_r_type(typename Elf_types<size>::Elf_WXword); 649 650 template<> 651 inline unsigned int 652 elf_r_type<32>(Elf_Word v) 653 { 654 return v & 0xff; 655 } 656 657 template<> 658 inline unsigned int 659 elf_r_type<64>(Elf_Xword v) 660 { 661 return v & 0xffffffff; 662 } 663 664 template<int size> 665 typename Elf_types<size>::Elf_WXword 666 elf_r_info(unsigned int s, unsigned int t); 667 668 template<> 669 inline Elf_Word 670 elf_r_info<32>(unsigned int s, unsigned int t) 671 { 672 return (s << 8) + (t & 0xff); 673 } 674 675 template<> 676 inline Elf_Xword 677 elf_r_info<64>(unsigned int s, unsigned int t) 678 { 679 return (static_cast<Elf_Xword>(s) << 32) + (t & 0xffffffff); 680 } 681 682 // Dynamic tags found in the PT_DYNAMIC segment. 683 684 enum DT 685 { 686 DT_NULL = 0, 687 DT_NEEDED = 1, 688 DT_PLTRELSZ = 2, 689 DT_PLTGOT = 3, 690 DT_HASH = 4, 691 DT_STRTAB = 5, 692 DT_SYMTAB = 6, 693 DT_RELA = 7, 694 DT_RELASZ = 8, 695 DT_RELAENT = 9, 696 DT_STRSZ = 10, 697 DT_SYMENT = 11, 698 DT_INIT = 12, 699 DT_FINI = 13, 700 DT_SONAME = 14, 701 DT_RPATH = 15, 702 DT_SYMBOLIC = 16, 703 DT_REL = 17, 704 DT_RELSZ = 18, 705 DT_RELENT = 19, 706 DT_PLTREL = 20, 707 DT_DEBUG = 21, 708 DT_TEXTREL = 22, 709 DT_JMPREL = 23, 710 DT_BIND_NOW = 24, 711 DT_INIT_ARRAY = 25, 712 DT_FINI_ARRAY = 26, 713 DT_INIT_ARRAYSZ = 27, 714 DT_FINI_ARRAYSZ = 28, 715 DT_RUNPATH = 29, 716 DT_FLAGS = 30, 717 718 // This is used to mark a range of dynamic tags. It is not really 719 // a tag value. 720 DT_ENCODING = 32, 721 722 DT_PREINIT_ARRAY = 32, 723 DT_PREINIT_ARRAYSZ = 33, 724 DT_LOOS = 0x6000000d, 725 DT_HIOS = 0x6ffff000, 726 DT_LOPROC = 0x70000000, 727 DT_HIPROC = 0x7fffffff, 728 729 // The remaining values are extensions used by GNU or Solaris. 730 DT_VALRNGLO = 0x6ffffd00, 731 DT_GNU_PRELINKED = 0x6ffffdf5, 732 DT_GNU_CONFLICTSZ = 0x6ffffdf6, 733 DT_GNU_LIBLISTSZ = 0x6ffffdf7, 734 DT_CHECKSUM = 0x6ffffdf8, 735 DT_PLTPADSZ = 0x6ffffdf9, 736 DT_MOVEENT = 0x6ffffdfa, 737 DT_MOVESZ = 0x6ffffdfb, 738 DT_FEATURE = 0x6ffffdfc, 739 DT_POSFLAG_1 = 0x6ffffdfd, 740 DT_SYMINSZ = 0x6ffffdfe, 741 DT_SYMINENT = 0x6ffffdff, 742 DT_VALRNGHI = 0x6ffffdff, 743 744 DT_ADDRRNGLO = 0x6ffffe00, 745 DT_GNU_HASH = 0x6ffffef5, 746 DT_TLSDESC_PLT = 0x6ffffef6, 747 DT_TLSDESC_GOT = 0x6ffffef7, 748 DT_GNU_CONFLICT = 0x6ffffef8, 749 DT_GNU_LIBLIST = 0x6ffffef9, 750 DT_CONFIG = 0x6ffffefa, 751 DT_DEPAUDIT = 0x6ffffefb, 752 DT_AUDIT = 0x6ffffefc, 753 DT_PLTPAD = 0x6ffffefd, 754 DT_MOVETAB = 0x6ffffefe, 755 DT_SYMINFO = 0x6ffffeff, 756 DT_ADDRRNGHI = 0x6ffffeff, 757 758 DT_RELACOUNT = 0x6ffffff9, 759 DT_RELCOUNT = 0x6ffffffa, 760 DT_FLAGS_1 = 0x6ffffffb, 761 DT_VERDEF = 0x6ffffffc, 762 DT_VERDEFNUM = 0x6ffffffd, 763 DT_VERNEED = 0x6ffffffe, 764 DT_VERNEEDNUM = 0x6fffffff, 765 766 DT_VERSYM = 0x6ffffff0, 767 768 // Specify the value of _GLOBAL_OFFSET_TABLE_. 769 DT_PPC_GOT = 0x70000000, 770 771 // Specify whether various optimisations are possible. 772 DT_PPC_OPT = 0x70000001, 773 774 // Specify the start of the .glink section. 775 DT_PPC64_GLINK = 0x70000000, 776 777 // Specify the start and size of the .opd section. 778 DT_PPC64_OPD = 0x70000001, 779 DT_PPC64_OPDSZ = 0x70000002, 780 781 // Specify whether various optimisations are possible. 782 DT_PPC64_OPT = 0x70000003, 783 784 // The index of an STT_SPARC_REGISTER symbol within the DT_SYMTAB 785 // symbol table. One dynamic entry exists for every STT_SPARC_REGISTER 786 // symbol in the symbol table. 787 DT_SPARC_REGISTER = 0x70000001, 788 789 // MIPS specific dynamic array tags. 790 // 32 bit version number for runtime linker interface. 791 DT_MIPS_RLD_VERSION = 0x70000001, 792 // Time stamp. 793 DT_MIPS_TIME_STAMP = 0x70000002, 794 // Checksum of external strings and common sizes. 795 DT_MIPS_ICHECKSUM = 0x70000003, 796 // Index of version string in string table. 797 DT_MIPS_IVERSION = 0x70000004, 798 // 32 bits of flags. 799 DT_MIPS_FLAGS = 0x70000005, 800 // Base address of the segment. 801 DT_MIPS_BASE_ADDRESS = 0x70000006, 802 // ??? 803 DT_MIPS_MSYM = 0x70000007, 804 // Address of .conflict section. 805 DT_MIPS_CONFLICT = 0x70000008, 806 // Address of .liblist section. 807 DT_MIPS_LIBLIST = 0x70000009, 808 // Number of local global offset table entries. 809 DT_MIPS_LOCAL_GOTNO = 0x7000000a, 810 // Number of entries in the .conflict section. 811 DT_MIPS_CONFLICTNO = 0x7000000b, 812 // Number of entries in the .liblist section. 813 DT_MIPS_LIBLISTNO = 0x70000010, 814 // Number of entries in the .dynsym section. 815 DT_MIPS_SYMTABNO = 0x70000011, 816 // Index of first external dynamic symbol not referenced locally. 817 DT_MIPS_UNREFEXTNO = 0x70000012, 818 // Index of first dynamic symbol in global offset table. 819 DT_MIPS_GOTSYM = 0x70000013, 820 // Number of page table entries in global offset table. 821 DT_MIPS_HIPAGENO = 0x70000014, 822 // Address of run time loader map, used for debugging. 823 DT_MIPS_RLD_MAP = 0x70000016, 824 // Delta C++ class definition. 825 DT_MIPS_DELTA_CLASS = 0x70000017, 826 // Number of entries in DT_MIPS_DELTA_CLASS. 827 DT_MIPS_DELTA_CLASS_NO = 0x70000018, 828 // Delta C++ class instances. 829 DT_MIPS_DELTA_INSTANCE = 0x70000019, 830 // Number of entries in DT_MIPS_DELTA_INSTANCE. 831 DT_MIPS_DELTA_INSTANCE_NO = 0x7000001a, 832 // Delta relocations. 833 DT_MIPS_DELTA_RELOC = 0x7000001b, 834 // Number of entries in DT_MIPS_DELTA_RELOC. 835 DT_MIPS_DELTA_RELOC_NO = 0x7000001c, 836 // Delta symbols that Delta relocations refer to. 837 DT_MIPS_DELTA_SYM = 0x7000001d, 838 // Number of entries in DT_MIPS_DELTA_SYM. 839 DT_MIPS_DELTA_SYM_NO = 0x7000001e, 840 // Delta symbols that hold class declarations. 841 DT_MIPS_DELTA_CLASSSYM = 0x70000020, 842 // Number of entries in DT_MIPS_DELTA_CLASSSYM. 843 DT_MIPS_DELTA_CLASSSYM_NO = 0x70000021, 844 // Flags indicating information about C++ flavor. 845 DT_MIPS_CXX_FLAGS = 0x70000022, 846 // Pixie information (???). 847 DT_MIPS_PIXIE_INIT = 0x70000023, 848 // Address of .MIPS.symlib 849 DT_MIPS_SYMBOL_LIB = 0x70000024, 850 // The GOT index of the first PTE for a segment 851 DT_MIPS_LOCALPAGE_GOTIDX = 0x70000025, 852 // The GOT index of the first PTE for a local symbol 853 DT_MIPS_LOCAL_GOTIDX = 0x70000026, 854 // The GOT index of the first PTE for a hidden symbol 855 DT_MIPS_HIDDEN_GOTIDX = 0x70000027, 856 // The GOT index of the first PTE for a protected symbol 857 DT_MIPS_PROTECTED_GOTIDX = 0x70000028, 858 // Address of `.MIPS.options'. 859 DT_MIPS_OPTIONS = 0x70000029, 860 // Address of `.interface'. 861 DT_MIPS_INTERFACE = 0x7000002a, 862 // ??? 863 DT_MIPS_DYNSTR_ALIGN = 0x7000002b, 864 // Size of the .interface section. 865 DT_MIPS_INTERFACE_SIZE = 0x7000002c, 866 // Size of rld_text_resolve function stored in the GOT. 867 DT_MIPS_RLD_TEXT_RESOLVE_ADDR = 0x7000002d, 868 // Default suffix of DSO to be added by rld on dlopen() calls. 869 DT_MIPS_PERF_SUFFIX = 0x7000002e, 870 // Size of compact relocation section (O32). 871 DT_MIPS_COMPACT_SIZE = 0x7000002f, 872 // GP value for auxiliary GOTs. 873 DT_MIPS_GP_VALUE = 0x70000030, 874 // Address of auxiliary .dynamic. 875 DT_MIPS_AUX_DYNAMIC = 0x70000031, 876 // Address of the base of the PLTGOT. 877 DT_MIPS_PLTGOT = 0x70000032, 878 // Points to the base of a writable PLT. 879 DT_MIPS_RWPLT = 0x70000034, 880 // Relative offset of run time loader map, used for debugging. 881 DT_MIPS_RLD_MAP_REL = 0x70000035, 882 883 DT_AUXILIARY = 0x7ffffffd, 884 DT_USED = 0x7ffffffe, 885 DT_FILTER = 0x7fffffff 886 }; 887 888 // Flags found in the DT_FLAGS dynamic element. 889 890 enum DF 891 { 892 DF_ORIGIN = 0x1, 893 DF_SYMBOLIC = 0x2, 894 DF_TEXTREL = 0x4, 895 DF_BIND_NOW = 0x8, 896 DF_STATIC_TLS = 0x10 897 }; 898 899 // Flags found in the DT_FLAGS_1 dynamic element. 900 901 enum DF_1 902 { 903 DF_1_NOW = 0x1, 904 DF_1_GLOBAL = 0x2, 905 DF_1_GROUP = 0x4, 906 DF_1_NODELETE = 0x8, 907 DF_1_LOADFLTR = 0x10, 908 DF_1_INITFIRST = 0x20, 909 DF_1_NOOPEN = 0x40, 910 DF_1_ORIGIN = 0x80, 911 DF_1_DIRECT = 0x100, 912 DF_1_TRANS = 0x200, 913 DF_1_INTERPOSE = 0x400, 914 DF_1_NODEFLIB = 0x800, 915 DF_1_NODUMP = 0x1000, 916 DF_1_CONLFAT = 0x2000 917 }; 918 919 // Version numbers which appear in the vd_version field of a Verdef 920 // structure. 921 922 const int VER_DEF_NONE = 0; 923 const int VER_DEF_CURRENT = 1; 924 925 // Version numbers which appear in the vn_version field of a Verneed 926 // structure. 927 928 const int VER_NEED_NONE = 0; 929 const int VER_NEED_CURRENT = 1; 930 931 // Bit flags which appear in vd_flags of Verdef and vna_flags of 932 // Vernaux. 933 934 const int VER_FLG_BASE = 0x1; 935 const int VER_FLG_WEAK = 0x2; 936 const int VER_FLG_INFO = 0x4; 937 938 // Special constants found in the SHT_GNU_versym entries. 939 940 const int VER_NDX_LOCAL = 0; 941 const int VER_NDX_GLOBAL = 1; 942 943 // A SHT_GNU_versym section holds 16-bit words. This bit is set if 944 // the symbol is hidden and can only be seen when referenced using an 945 // explicit version number. This is a GNU extension. 946 947 const int VERSYM_HIDDEN = 0x8000; 948 949 // This is the mask for the rest of the data in a word read from a 950 // SHT_GNU_versym section. 951 952 const int VERSYM_VERSION = 0x7fff; 953 954 // Note descriptor type codes for notes in a non-core file with an 955 // empty name. 956 957 enum 958 { 959 // A version string. 960 NT_VERSION = 1, 961 // An architecture string. 962 NT_ARCH = 2 963 }; 964 965 // Note descriptor type codes for notes in a non-core file with the 966 // name "GNU". 967 968 enum 969 { 970 // The minimum ABI level. This is used by the dynamic linker to 971 // describe the minimal kernel version on which a shared library may 972 // be used. Th value should be four words. Word 0 is an OS 973 // descriptor (see below). Word 1 is the major version of the ABI. 974 // Word 2 is the minor version. Word 3 is the subminor version. 975 NT_GNU_ABI_TAG = 1, 976 // Hardware capabilities information. Word 0 is the number of 977 // entries. Word 1 is a bitmask of enabled entries. The rest of 978 // the descriptor is a series of entries, where each entry is a 979 // single byte followed by a nul terminated string. The byte gives 980 // the bit number to test if enabled in the bitmask. 981 NT_GNU_HWCAP = 2, 982 // The build ID as set by the linker's --build-id option. The 983 // format of the descriptor depends on the build ID style. 984 NT_GNU_BUILD_ID = 3, 985 // The version of gold used to link. Th descriptor is just a 986 // string. 987 NT_GNU_GOLD_VERSION = 4, 988 // Program property note, as described in "Linux Extensions to the gABI". 989 NT_GNU_PROPERTY_TYPE_0 = 5 990 }; 991 992 // The OS values which may appear in word 0 of a NT_GNU_ABI_TAG note. 993 994 enum 995 { 996 ELF_NOTE_OS_LINUX = 0, 997 ELF_NOTE_OS_GNU = 1, 998 ELF_NOTE_OS_SOLARIS2 = 2, 999 ELF_NOTE_OS_FREEBSD = 3, 1000 ELF_NOTE_OS_NETBSD = 4, 1001 ELF_NOTE_OS_SYLLABLE = 5 1002 }; 1003 1004 // Program property types for NT_GNU_PROPERTY_TYPE_0. 1005 1006 enum 1007 { 1008 GNU_PROPERTY_STACK_SIZE = 1, 1009 GNU_PROPERTY_NO_COPY_ON_PROTECTED = 2, 1010 GNU_PROPERTY_LOPROC = 0xc0000000, 1011 GNU_PROPERTY_X86_ISA_1_USED = 0xc0000000, 1012 GNU_PROPERTY_X86_ISA_1_NEEDED = 0xc0000001, 1013 GNU_PROPERTY_X86_FEATURE_1_AND = 0xc0000002, 1014 GNU_PROPERTY_HIPROC = 0xdfffffff, 1015 GNU_PROPERTY_LOUSER = 0xe0000000, 1016 GNU_PROPERTY_HIUSER = 0xffffffff 1017 }; 1018 1019 } // End namespace elfcpp. 1020 1021 // Include internal details after defining the types. 1022 #include "elfcpp_internal.h" 1023 1024 namespace elfcpp 1025 { 1026 1027 // The offset of the ELF file header in the ELF file. 1028 1029 const int file_header_offset = 0; 1030 1031 // ELF structure sizes. 1032 1033 template<int size> 1034 struct Elf_sizes 1035 { 1036 // Size of ELF file header. 1037 static const int ehdr_size = sizeof(internal::Ehdr_data<size>); 1038 // Size of ELF segment header. 1039 static const int phdr_size = sizeof(internal::Phdr_data<size>); 1040 // Size of ELF section header. 1041 static const int shdr_size = sizeof(internal::Shdr_data<size>); 1042 // Size of ELF compression header. 1043 static const int chdr_size = sizeof(internal::Chdr_data<size>); 1044 // Size of ELF symbol table entry. 1045 static const int sym_size = sizeof(internal::Sym_data<size>); 1046 // Sizes of ELF reloc entries. 1047 static const int rel_size = sizeof(internal::Rel_data<size>); 1048 static const int rela_size = sizeof(internal::Rela_data<size>); 1049 // Size of ELF dynamic entry. 1050 static const int dyn_size = sizeof(internal::Dyn_data<size>); 1051 // Size of ELF version structures. 1052 static const int verdef_size = sizeof(internal::Verdef_data); 1053 static const int verdaux_size = sizeof(internal::Verdaux_data); 1054 static const int verneed_size = sizeof(internal::Verneed_data); 1055 static const int vernaux_size = sizeof(internal::Vernaux_data); 1056 }; 1057 1058 // Accessor class for the ELF file header. 1059 1060 template<int size, bool big_endian> 1061 class Ehdr 1062 { 1063 public: 1064 Ehdr(const unsigned char* p) 1065 : p_(reinterpret_cast<const internal::Ehdr_data<size>*>(p)) 1066 { } 1067 1068 template<typename File> 1069 Ehdr(File* file, typename File::Location loc) 1070 : p_(reinterpret_cast<const internal::Ehdr_data<size>*>( 1071 file->view(loc.file_offset, loc.data_size).data())) 1072 { } 1073 1074 const unsigned char* 1075 get_e_ident() const 1076 { return this->p_->e_ident; } 1077 1078 Elf_Half 1079 get_e_type() const 1080 { return Convert<16, big_endian>::convert_host(this->p_->e_type); } 1081 1082 Elf_Half 1083 get_e_machine() const 1084 { return Convert<16, big_endian>::convert_host(this->p_->e_machine); } 1085 1086 Elf_Word 1087 get_e_version() const 1088 { return Convert<32, big_endian>::convert_host(this->p_->e_version); } 1089 1090 typename Elf_types<size>::Elf_Addr 1091 get_e_entry() const 1092 { return Convert<size, big_endian>::convert_host(this->p_->e_entry); } 1093 1094 typename Elf_types<size>::Elf_Off 1095 get_e_phoff() const 1096 { return Convert<size, big_endian>::convert_host(this->p_->e_phoff); } 1097 1098 typename Elf_types<size>::Elf_Off 1099 get_e_shoff() const 1100 { return Convert<size, big_endian>::convert_host(this->p_->e_shoff); } 1101 1102 Elf_Word 1103 get_e_flags() const 1104 { return Convert<32, big_endian>::convert_host(this->p_->e_flags); } 1105 1106 Elf_Half 1107 get_e_ehsize() const 1108 { return Convert<16, big_endian>::convert_host(this->p_->e_ehsize); } 1109 1110 Elf_Half 1111 get_e_phentsize() const 1112 { return Convert<16, big_endian>::convert_host(this->p_->e_phentsize); } 1113 1114 Elf_Half 1115 get_e_phnum() const 1116 { return Convert<16, big_endian>::convert_host(this->p_->e_phnum); } 1117 1118 Elf_Half 1119 get_e_shentsize() const 1120 { return Convert<16, big_endian>::convert_host(this->p_->e_shentsize); } 1121 1122 Elf_Half 1123 get_e_shnum() const 1124 { return Convert<16, big_endian>::convert_host(this->p_->e_shnum); } 1125 1126 Elf_Half 1127 get_e_shstrndx() const 1128 { return Convert<16, big_endian>::convert_host(this->p_->e_shstrndx); } 1129 1130 private: 1131 const internal::Ehdr_data<size>* p_; 1132 }; 1133 1134 // Write class for the ELF file header. 1135 1136 template<int size, bool big_endian> 1137 class Ehdr_write 1138 { 1139 public: 1140 Ehdr_write(unsigned char* p) 1141 : p_(reinterpret_cast<internal::Ehdr_data<size>*>(p)) 1142 { } 1143 1144 void 1145 put_e_ident(const unsigned char v[EI_NIDENT]) const 1146 { memcpy(this->p_->e_ident, v, EI_NIDENT); } 1147 1148 void 1149 put_e_type(Elf_Half v) 1150 { this->p_->e_type = Convert<16, big_endian>::convert_host(v); } 1151 1152 void 1153 put_e_machine(Elf_Half v) 1154 { this->p_->e_machine = Convert<16, big_endian>::convert_host(v); } 1155 1156 void 1157 put_e_version(Elf_Word v) 1158 { this->p_->e_version = Convert<32, big_endian>::convert_host(v); } 1159 1160 void 1161 put_e_entry(typename Elf_types<size>::Elf_Addr v) 1162 { this->p_->e_entry = Convert<size, big_endian>::convert_host(v); } 1163 1164 void 1165 put_e_phoff(typename Elf_types<size>::Elf_Off v) 1166 { this->p_->e_phoff = Convert<size, big_endian>::convert_host(v); } 1167 1168 void 1169 put_e_shoff(typename Elf_types<size>::Elf_Off v) 1170 { this->p_->e_shoff = Convert<size, big_endian>::convert_host(v); } 1171 1172 void 1173 put_e_flags(Elf_Word v) 1174 { this->p_->e_flags = Convert<32, big_endian>::convert_host(v); } 1175 1176 void 1177 put_e_ehsize(Elf_Half v) 1178 { this->p_->e_ehsize = Convert<16, big_endian>::convert_host(v); } 1179 1180 void 1181 put_e_phentsize(Elf_Half v) 1182 { this->p_->e_phentsize = Convert<16, big_endian>::convert_host(v); } 1183 1184 void 1185 put_e_phnum(Elf_Half v) 1186 { this->p_->e_phnum = Convert<16, big_endian>::convert_host(v); } 1187 1188 void 1189 put_e_shentsize(Elf_Half v) 1190 { this->p_->e_shentsize = Convert<16, big_endian>::convert_host(v); } 1191 1192 void 1193 put_e_shnum(Elf_Half v) 1194 { this->p_->e_shnum = Convert<16, big_endian>::convert_host(v); } 1195 1196 void 1197 put_e_shstrndx(Elf_Half v) 1198 { this->p_->e_shstrndx = Convert<16, big_endian>::convert_host(v); } 1199 1200 private: 1201 internal::Ehdr_data<size>* p_; 1202 }; 1203 1204 // Accessor class for an ELF section header. 1205 1206 template<int size, bool big_endian> 1207 class Shdr 1208 { 1209 public: 1210 Shdr(const unsigned char* p) 1211 : p_(reinterpret_cast<const internal::Shdr_data<size>*>(p)) 1212 { } 1213 1214 template<typename File> 1215 Shdr(File* file, typename File::Location loc) 1216 : p_(reinterpret_cast<const internal::Shdr_data<size>*>( 1217 file->view(loc.file_offset, loc.data_size).data())) 1218 { } 1219 1220 Elf_Word 1221 get_sh_name() const 1222 { return Convert<32, big_endian>::convert_host(this->p_->sh_name); } 1223 1224 Elf_Word 1225 get_sh_type() const 1226 { return Convert<32, big_endian>::convert_host(this->p_->sh_type); } 1227 1228 typename Elf_types<size>::Elf_WXword 1229 get_sh_flags() const 1230 { return Convert<size, big_endian>::convert_host(this->p_->sh_flags); } 1231 1232 typename Elf_types<size>::Elf_Addr 1233 get_sh_addr() const 1234 { return Convert<size, big_endian>::convert_host(this->p_->sh_addr); } 1235 1236 typename Elf_types<size>::Elf_Off 1237 get_sh_offset() const 1238 { return Convert<size, big_endian>::convert_host(this->p_->sh_offset); } 1239 1240 typename Elf_types<size>::Elf_WXword 1241 get_sh_size() const 1242 { return Convert<size, big_endian>::convert_host(this->p_->sh_size); } 1243 1244 Elf_Word 1245 get_sh_link() const 1246 { return Convert<32, big_endian>::convert_host(this->p_->sh_link); } 1247 1248 Elf_Word 1249 get_sh_info() const 1250 { return Convert<32, big_endian>::convert_host(this->p_->sh_info); } 1251 1252 typename Elf_types<size>::Elf_WXword 1253 get_sh_addralign() const 1254 { return 1255 Convert<size, big_endian>::convert_host(this->p_->sh_addralign); } 1256 1257 typename Elf_types<size>::Elf_WXword 1258 get_sh_entsize() const 1259 { return Convert<size, big_endian>::convert_host(this->p_->sh_entsize); } 1260 1261 private: 1262 const internal::Shdr_data<size>* p_; 1263 }; 1264 1265 // Write class for an ELF section header. 1266 1267 template<int size, bool big_endian> 1268 class Shdr_write 1269 { 1270 public: 1271 Shdr_write(unsigned char* p) 1272 : p_(reinterpret_cast<internal::Shdr_data<size>*>(p)) 1273 { } 1274 1275 void 1276 put_sh_name(Elf_Word v) 1277 { this->p_->sh_name = Convert<32, big_endian>::convert_host(v); } 1278 1279 void 1280 put_sh_type(Elf_Word v) 1281 { this->p_->sh_type = Convert<32, big_endian>::convert_host(v); } 1282 1283 void 1284 put_sh_flags(typename Elf_types<size>::Elf_WXword v) 1285 { this->p_->sh_flags = Convert<size, big_endian>::convert_host(v); } 1286 1287 void 1288 put_sh_addr(typename Elf_types<size>::Elf_Addr v) 1289 { this->p_->sh_addr = Convert<size, big_endian>::convert_host(v); } 1290 1291 void 1292 put_sh_offset(typename Elf_types<size>::Elf_Off v) 1293 { this->p_->sh_offset = Convert<size, big_endian>::convert_host(v); } 1294 1295 void 1296 put_sh_size(typename Elf_types<size>::Elf_WXword v) 1297 { this->p_->sh_size = Convert<size, big_endian>::convert_host(v); } 1298 1299 void 1300 put_sh_link(Elf_Word v) 1301 { this->p_->sh_link = Convert<32, big_endian>::convert_host(v); } 1302 1303 void 1304 put_sh_info(Elf_Word v) 1305 { this->p_->sh_info = Convert<32, big_endian>::convert_host(v); } 1306 1307 void 1308 put_sh_addralign(typename Elf_types<size>::Elf_WXword v) 1309 { this->p_->sh_addralign = Convert<size, big_endian>::convert_host(v); } 1310 1311 void 1312 put_sh_entsize(typename Elf_types<size>::Elf_WXword v) 1313 { this->p_->sh_entsize = Convert<size, big_endian>::convert_host(v); } 1314 1315 private: 1316 internal::Shdr_data<size>* p_; 1317 }; 1318 1319 // Accessor class for an ELF compression header. 1320 1321 template<int size, bool big_endian> 1322 class Chdr 1323 { 1324 public: 1325 Chdr(const unsigned char* p) 1326 : p_(reinterpret_cast<const internal::Chdr_data<size>*>(p)) 1327 { } 1328 1329 template<typename File> 1330 Chdr(File* file, typename File::Location loc) 1331 : p_(reinterpret_cast<const internal::Chdr_data<size>*>( 1332 file->view(loc.file_offset, loc.data_size).data())) 1333 { } 1334 1335 Elf_Word 1336 get_ch_type() const 1337 { return Convert<size, big_endian>::convert_host(this->p_->ch_type); } 1338 1339 typename Elf_types<size>::Elf_WXword 1340 get_ch_size() const 1341 { return Convert<size, big_endian>::convert_host(this->p_->ch_size); } 1342 1343 typename Elf_types<size>::Elf_WXword 1344 get_ch_addralign() const 1345 { return 1346 Convert<size, big_endian>::convert_host(this->p_->ch_addralign); } 1347 1348 private: 1349 const internal::Chdr_data<size>* p_; 1350 }; 1351 1352 // Write class for an ELF compression header. 1353 1354 template<int size, bool big_endian> 1355 class Chdr_write 1356 { 1357 public: 1358 Chdr_write(unsigned char* p) 1359 : p_(reinterpret_cast<internal::Chdr_data<size>*>(p)) 1360 { } 1361 1362 void 1363 put_ch_type(typename Elf_types<size>::Elf_WXword v) 1364 { this->p_->ch_type = Convert<size, big_endian>::convert_host(v); } 1365 1366 void 1367 put_ch_size(typename Elf_types<size>::Elf_WXword v) 1368 { this->p_->ch_size = Convert<size, big_endian>::convert_host(v); } 1369 1370 void 1371 put_ch_addralign(typename Elf_types<size>::Elf_WXword v) 1372 { this->p_->ch_addralign = Convert<size, big_endian>::convert_host(v); } 1373 1374 void 1375 put_ch_reserved(Elf_Word); 1376 1377 private: 1378 internal::Chdr_data<size>* p_; 1379 }; 1380 1381 template<> 1382 inline void 1383 elfcpp::Chdr_write<64, true>::put_ch_reserved(Elf_Word v) 1384 { 1385 this->p_->ch_reserved = v; 1386 } 1387 1388 template<> 1389 inline void 1390 elfcpp::Chdr_write<64, false>::put_ch_reserved(Elf_Word v) 1391 { 1392 this->p_->ch_reserved = v; 1393 } 1394 1395 // Accessor class for an ELF segment header. 1396 1397 template<int size, bool big_endian> 1398 class Phdr 1399 { 1400 public: 1401 Phdr(const unsigned char* p) 1402 : p_(reinterpret_cast<const internal::Phdr_data<size>*>(p)) 1403 { } 1404 1405 template<typename File> 1406 Phdr(File* file, typename File::Location loc) 1407 : p_(reinterpret_cast<internal::Phdr_data<size>*>( 1408 file->view(loc.file_offset, loc.data_size).data())) 1409 { } 1410 1411 Elf_Word 1412 get_p_type() const 1413 { return Convert<32, big_endian>::convert_host(this->p_->p_type); } 1414 1415 typename Elf_types<size>::Elf_Off 1416 get_p_offset() const 1417 { return Convert<size, big_endian>::convert_host(this->p_->p_offset); } 1418 1419 typename Elf_types<size>::Elf_Addr 1420 get_p_vaddr() const 1421 { return Convert<size, big_endian>::convert_host(this->p_->p_vaddr); } 1422 1423 typename Elf_types<size>::Elf_Addr 1424 get_p_paddr() const 1425 { return Convert<size, big_endian>::convert_host(this->p_->p_paddr); } 1426 1427 typename Elf_types<size>::Elf_WXword 1428 get_p_filesz() const 1429 { return Convert<size, big_endian>::convert_host(this->p_->p_filesz); } 1430 1431 typename Elf_types<size>::Elf_WXword 1432 get_p_memsz() const 1433 { return Convert<size, big_endian>::convert_host(this->p_->p_memsz); } 1434 1435 Elf_Word 1436 get_p_flags() const 1437 { return Convert<32, big_endian>::convert_host(this->p_->p_flags); } 1438 1439 typename Elf_types<size>::Elf_WXword 1440 get_p_align() const 1441 { return Convert<size, big_endian>::convert_host(this->p_->p_align); } 1442 1443 private: 1444 const internal::Phdr_data<size>* p_; 1445 }; 1446 1447 // Write class for an ELF segment header. 1448 1449 template<int size, bool big_endian> 1450 class Phdr_write 1451 { 1452 public: 1453 Phdr_write(unsigned char* p) 1454 : p_(reinterpret_cast<internal::Phdr_data<size>*>(p)) 1455 { } 1456 1457 void 1458 put_p_type(Elf_Word v) 1459 { this->p_->p_type = Convert<32, big_endian>::convert_host(v); } 1460 1461 void 1462 put_p_offset(typename Elf_types<size>::Elf_Off v) 1463 { this->p_->p_offset = Convert<size, big_endian>::convert_host(v); } 1464 1465 void 1466 put_p_vaddr(typename Elf_types<size>::Elf_Addr v) 1467 { this->p_->p_vaddr = Convert<size, big_endian>::convert_host(v); } 1468 1469 void 1470 put_p_paddr(typename Elf_types<size>::Elf_Addr v) 1471 { this->p_->p_paddr = Convert<size, big_endian>::convert_host(v); } 1472 1473 void 1474 put_p_filesz(typename Elf_types<size>::Elf_WXword v) 1475 { this->p_->p_filesz = Convert<size, big_endian>::convert_host(v); } 1476 1477 void 1478 put_p_memsz(typename Elf_types<size>::Elf_WXword v) 1479 { this->p_->p_memsz = Convert<size, big_endian>::convert_host(v); } 1480 1481 void 1482 put_p_flags(Elf_Word v) 1483 { this->p_->p_flags = Convert<32, big_endian>::convert_host(v); } 1484 1485 void 1486 put_p_align(typename Elf_types<size>::Elf_WXword v) 1487 { this->p_->p_align = Convert<size, big_endian>::convert_host(v); } 1488 1489 private: 1490 internal::Phdr_data<size>* p_; 1491 }; 1492 1493 // Accessor class for an ELF symbol table entry. 1494 1495 template<int size, bool big_endian> 1496 class Sym 1497 { 1498 public: 1499 Sym(const unsigned char* p) 1500 : p_(reinterpret_cast<const internal::Sym_data<size>*>(p)) 1501 { } 1502 1503 template<typename File> 1504 Sym(File* file, typename File::Location loc) 1505 : p_(reinterpret_cast<const internal::Sym_data<size>*>( 1506 file->view(loc.file_offset, loc.data_size).data())) 1507 { } 1508 1509 Elf_Word 1510 get_st_name() const 1511 { return Convert<32, big_endian>::convert_host(this->p_->st_name); } 1512 1513 typename Elf_types<size>::Elf_Addr 1514 get_st_value() const 1515 { return Convert<size, big_endian>::convert_host(this->p_->st_value); } 1516 1517 typename Elf_types<size>::Elf_WXword 1518 get_st_size() const 1519 { return Convert<size, big_endian>::convert_host(this->p_->st_size); } 1520 1521 unsigned char 1522 get_st_info() const 1523 { return this->p_->st_info; } 1524 1525 STB 1526 get_st_bind() const 1527 { return elf_st_bind(this->get_st_info()); } 1528 1529 STT 1530 get_st_type() const 1531 { return elf_st_type(this->get_st_info()); } 1532 1533 unsigned char 1534 get_st_other() const 1535 { return this->p_->st_other; } 1536 1537 STV 1538 get_st_visibility() const 1539 { return elf_st_visibility(this->get_st_other()); } 1540 1541 unsigned char 1542 get_st_nonvis() const 1543 { return elf_st_nonvis(this->get_st_other()); } 1544 1545 Elf_Half 1546 get_st_shndx() const 1547 { return Convert<16, big_endian>::convert_host(this->p_->st_shndx); } 1548 1549 private: 1550 const internal::Sym_data<size>* p_; 1551 }; 1552 1553 // Writer class for an ELF symbol table entry. 1554 1555 template<int size, bool big_endian> 1556 class Sym_write 1557 { 1558 public: 1559 Sym_write(unsigned char* p) 1560 : p_(reinterpret_cast<internal::Sym_data<size>*>(p)) 1561 { } 1562 1563 void 1564 put_st_name(Elf_Word v) 1565 { this->p_->st_name = Convert<32, big_endian>::convert_host(v); } 1566 1567 void 1568 put_st_value(typename Elf_types<size>::Elf_Addr v) 1569 { this->p_->st_value = Convert<size, big_endian>::convert_host(v); } 1570 1571 void 1572 put_st_size(typename Elf_types<size>::Elf_WXword v) 1573 { this->p_->st_size = Convert<size, big_endian>::convert_host(v); } 1574 1575 void 1576 put_st_info(unsigned char v) 1577 { this->p_->st_info = v; } 1578 1579 void 1580 put_st_info(STB bind, STT type) 1581 { this->p_->st_info = elf_st_info(bind, type); } 1582 1583 void 1584 put_st_other(unsigned char v) 1585 { this->p_->st_other = v; } 1586 1587 void 1588 put_st_other(STV vis, unsigned char nonvis) 1589 { this->p_->st_other = elf_st_other(vis, nonvis); } 1590 1591 void 1592 put_st_shndx(Elf_Half v) 1593 { this->p_->st_shndx = Convert<16, big_endian>::convert_host(v); } 1594 1595 Sym<size, big_endian> 1596 sym() 1597 { return Sym<size, big_endian>(reinterpret_cast<unsigned char*>(this->p_)); } 1598 1599 private: 1600 internal::Sym_data<size>* p_; 1601 }; 1602 1603 // Accessor classes for an ELF REL relocation entry. 1604 1605 template<int size, bool big_endian> 1606 class Rel 1607 { 1608 public: 1609 Rel(const unsigned char* p) 1610 : p_(reinterpret_cast<const internal::Rel_data<size>*>(p)) 1611 { } 1612 1613 template<typename File> 1614 Rel(File* file, typename File::Location loc) 1615 : p_(reinterpret_cast<const internal::Rel_data<size>*>( 1616 file->view(loc.file_offset, loc.data_size).data())) 1617 { } 1618 1619 typename Elf_types<size>::Elf_Addr 1620 get_r_offset() const 1621 { return Convert<size, big_endian>::convert_host(this->p_->r_offset); } 1622 1623 typename Elf_types<size>::Elf_WXword 1624 get_r_info() const 1625 { return Convert<size, big_endian>::convert_host(this->p_->r_info); } 1626 1627 private: 1628 const internal::Rel_data<size>* p_; 1629 }; 1630 1631 // Writer class for an ELF Rel relocation. 1632 1633 template<int size, bool big_endian> 1634 class Rel_write 1635 { 1636 public: 1637 Rel_write(unsigned char* p) 1638 : p_(reinterpret_cast<internal::Rel_data<size>*>(p)) 1639 { } 1640 1641 void 1642 put_r_offset(typename Elf_types<size>::Elf_Addr v) 1643 { this->p_->r_offset = Convert<size, big_endian>::convert_host(v); } 1644 1645 void 1646 put_r_info(typename Elf_types<size>::Elf_WXword v) 1647 { this->p_->r_info = Convert<size, big_endian>::convert_host(v); } 1648 1649 private: 1650 internal::Rel_data<size>* p_; 1651 }; 1652 1653 // Accessor class for an ELF Rela relocation. 1654 1655 template<int size, bool big_endian> 1656 class Rela 1657 { 1658 public: 1659 Rela(const unsigned char* p) 1660 : p_(reinterpret_cast<const internal::Rela_data<size>*>(p)) 1661 { } 1662 1663 template<typename File> 1664 Rela(File* file, typename File::Location loc) 1665 : p_(reinterpret_cast<const internal::Rela_data<size>*>( 1666 file->view(loc.file_offset, loc.data_size).data())) 1667 { } 1668 1669 typename Elf_types<size>::Elf_Addr 1670 get_r_offset() const 1671 { return Convert<size, big_endian>::convert_host(this->p_->r_offset); } 1672 1673 typename Elf_types<size>::Elf_WXword 1674 get_r_info() const 1675 { return Convert<size, big_endian>::convert_host(this->p_->r_info); } 1676 1677 typename Elf_types<size>::Elf_Swxword 1678 get_r_addend() const 1679 { return Convert<size, big_endian>::convert_host(this->p_->r_addend); } 1680 1681 private: 1682 const internal::Rela_data<size>* p_; 1683 }; 1684 1685 // Writer class for an ELF Rela relocation. 1686 1687 template<int size, bool big_endian> 1688 class Rela_write 1689 { 1690 public: 1691 Rela_write(unsigned char* p) 1692 : p_(reinterpret_cast<internal::Rela_data<size>*>(p)) 1693 { } 1694 1695 void 1696 put_r_offset(typename Elf_types<size>::Elf_Addr v) 1697 { this->p_->r_offset = Convert<size, big_endian>::convert_host(v); } 1698 1699 void 1700 put_r_info(typename Elf_types<size>::Elf_WXword v) 1701 { this->p_->r_info = Convert<size, big_endian>::convert_host(v); } 1702 1703 void 1704 put_r_addend(typename Elf_types<size>::Elf_Swxword v) 1705 { this->p_->r_addend = Convert<size, big_endian>::convert_host(v); } 1706 1707 private: 1708 internal::Rela_data<size>* p_; 1709 }; 1710 1711 // MIPS-64 has a non-standard relocation layout. 1712 1713 template<bool big_endian> 1714 class Mips64_rel 1715 { 1716 public: 1717 Mips64_rel(const unsigned char* p) 1718 : p_(reinterpret_cast<const internal::Mips64_rel_data*>(p)) 1719 { } 1720 1721 template<typename File> 1722 Mips64_rel(File* file, typename File::Location loc) 1723 : p_(reinterpret_cast<const internal::Mips64_rel_data*>( 1724 file->view(loc.file_offset, loc.data_size).data())) 1725 { } 1726 1727 typename Elf_types<64>::Elf_Addr 1728 get_r_offset() const 1729 { return Convert<64, big_endian>::convert_host(this->p_->r_offset); } 1730 1731 Elf_Word 1732 get_r_sym() const 1733 { return Convert<32, big_endian>::convert_host(this->p_->r_sym); } 1734 1735 unsigned char 1736 get_r_ssym() const 1737 { return this->p_->r_ssym; } 1738 1739 unsigned char 1740 get_r_type() const 1741 { return this->p_->r_type; } 1742 1743 unsigned char 1744 get_r_type2() const 1745 { return this->p_->r_type2; } 1746 1747 unsigned char 1748 get_r_type3() const 1749 { return this->p_->r_type3; } 1750 1751 private: 1752 const internal::Mips64_rel_data* p_; 1753 }; 1754 1755 template<bool big_endian> 1756 class Mips64_rel_write 1757 { 1758 public: 1759 Mips64_rel_write(unsigned char* p) 1760 : p_(reinterpret_cast<internal::Mips64_rel_data*>(p)) 1761 { } 1762 1763 void 1764 put_r_offset(typename Elf_types<64>::Elf_Addr v) 1765 { this->p_->r_offset = Convert<64, big_endian>::convert_host(v); } 1766 1767 void 1768 put_r_sym(Elf_Word v) 1769 { this->p_->r_sym = Convert<32, big_endian>::convert_host(v); } 1770 1771 void 1772 put_r_ssym(unsigned char v) 1773 { this->p_->r_ssym = v; } 1774 1775 void 1776 put_r_type(unsigned char v) 1777 { this->p_->r_type = v; } 1778 1779 void 1780 put_r_type2(unsigned char v) 1781 { this->p_->r_type2 = v; } 1782 1783 void 1784 put_r_type3(unsigned char v) 1785 { this->p_->r_type3 = v; } 1786 1787 private: 1788 internal::Mips64_rel_data* p_; 1789 }; 1790 1791 template<bool big_endian> 1792 class Mips64_rela 1793 { 1794 public: 1795 Mips64_rela(const unsigned char* p) 1796 : p_(reinterpret_cast<const internal::Mips64_rela_data*>(p)) 1797 { } 1798 1799 template<typename File> 1800 Mips64_rela(File* file, typename File::Location loc) 1801 : p_(reinterpret_cast<const internal::Mips64_rela_data*>( 1802 file->view(loc.file_offset, loc.data_size).data())) 1803 { } 1804 1805 typename Elf_types<64>::Elf_Addr 1806 get_r_offset() const 1807 { return Convert<64, big_endian>::convert_host(this->p_->r_offset); } 1808 1809 Elf_Word 1810 get_r_sym() const 1811 { return Convert<32, big_endian>::convert_host(this->p_->r_sym); } 1812 1813 unsigned char 1814 get_r_ssym() const 1815 { return this->p_->r_ssym; } 1816 1817 unsigned char 1818 get_r_type() const 1819 { return this->p_->r_type; } 1820 1821 unsigned char 1822 get_r_type2() const 1823 { return this->p_->r_type2; } 1824 1825 unsigned char 1826 get_r_type3() const 1827 { return this->p_->r_type3; } 1828 1829 typename Elf_types<64>::Elf_Swxword 1830 get_r_addend() const 1831 { return Convert<64, big_endian>::convert_host(this->p_->r_addend); } 1832 1833 private: 1834 const internal::Mips64_rela_data* p_; 1835 }; 1836 1837 template<bool big_endian> 1838 class Mips64_rela_write 1839 { 1840 public: 1841 Mips64_rela_write(unsigned char* p) 1842 : p_(reinterpret_cast<internal::Mips64_rela_data*>(p)) 1843 { } 1844 1845 void 1846 put_r_offset(typename Elf_types<64>::Elf_Addr v) 1847 { this->p_->r_offset = Convert<64, big_endian>::convert_host(v); } 1848 1849 void 1850 put_r_sym(Elf_Word v) 1851 { this->p_->r_sym = Convert<32, big_endian>::convert_host(v); } 1852 1853 void 1854 put_r_ssym(unsigned char v) 1855 { this->p_->r_ssym = v; } 1856 1857 void 1858 put_r_type(unsigned char v) 1859 { this->p_->r_type = v; } 1860 1861 void 1862 put_r_type2(unsigned char v) 1863 { this->p_->r_type2 = v; } 1864 1865 void 1866 put_r_type3(unsigned char v) 1867 { this->p_->r_type3 = v; } 1868 1869 void 1870 put_r_addend(typename Elf_types<64>::Elf_Swxword v) 1871 { this->p_->r_addend = Convert<64, big_endian>::convert_host(v); } 1872 1873 private: 1874 internal::Mips64_rela_data* p_; 1875 }; 1876 1877 // Accessor classes for entries in the ELF SHT_DYNAMIC section aka 1878 // PT_DYNAMIC segment. 1879 1880 template<int size, bool big_endian> 1881 class Dyn 1882 { 1883 public: 1884 Dyn(const unsigned char* p) 1885 : p_(reinterpret_cast<const internal::Dyn_data<size>*>(p)) 1886 { } 1887 1888 template<typename File> 1889 Dyn(File* file, typename File::Location loc) 1890 : p_(reinterpret_cast<const internal::Dyn_data<size>*>( 1891 file->view(loc.file_offset, loc.data_size).data())) 1892 { } 1893 1894 typename Elf_types<size>::Elf_Swxword 1895 get_d_tag() const 1896 { return Convert<size, big_endian>::convert_host(this->p_->d_tag); } 1897 1898 typename Elf_types<size>::Elf_WXword 1899 get_d_val() const 1900 { return Convert<size, big_endian>::convert_host(this->p_->d_val); } 1901 1902 typename Elf_types<size>::Elf_Addr 1903 get_d_ptr() const 1904 { return Convert<size, big_endian>::convert_host(this->p_->d_val); } 1905 1906 private: 1907 const internal::Dyn_data<size>* p_; 1908 }; 1909 1910 // Write class for an entry in the SHT_DYNAMIC section. 1911 1912 template<int size, bool big_endian> 1913 class Dyn_write 1914 { 1915 public: 1916 Dyn_write(unsigned char* p) 1917 : p_(reinterpret_cast<internal::Dyn_data<size>*>(p)) 1918 { } 1919 1920 void 1921 put_d_tag(typename Elf_types<size>::Elf_Swxword v) 1922 { this->p_->d_tag = Convert<size, big_endian>::convert_host(v); } 1923 1924 void 1925 put_d_val(typename Elf_types<size>::Elf_WXword v) 1926 { this->p_->d_val = Convert<size, big_endian>::convert_host(v); } 1927 1928 void 1929 put_d_ptr(typename Elf_types<size>::Elf_Addr v) 1930 { this->p_->d_val = Convert<size, big_endian>::convert_host(v); } 1931 1932 private: 1933 internal::Dyn_data<size>* p_; 1934 }; 1935 1936 // Accessor classes for entries in the ELF SHT_GNU_verdef section. 1937 1938 template<int size, bool big_endian> 1939 class Verdef 1940 { 1941 public: 1942 Verdef(const unsigned char* p) 1943 : p_(reinterpret_cast<const internal::Verdef_data*>(p)) 1944 { } 1945 1946 template<typename File> 1947 Verdef(File* file, typename File::Location loc) 1948 : p_(reinterpret_cast<const internal::Verdef_data*>( 1949 file->view(loc.file_offset, loc.data_size).data())) 1950 { } 1951 1952 Elf_Half 1953 get_vd_version() const 1954 { return Convert<16, big_endian>::convert_host(this->p_->vd_version); } 1955 1956 Elf_Half 1957 get_vd_flags() const 1958 { return Convert<16, big_endian>::convert_host(this->p_->vd_flags); } 1959 1960 Elf_Half 1961 get_vd_ndx() const 1962 { return Convert<16, big_endian>::convert_host(this->p_->vd_ndx); } 1963 1964 Elf_Half 1965 get_vd_cnt() const 1966 { return Convert<16, big_endian>::convert_host(this->p_->vd_cnt); } 1967 1968 Elf_Word 1969 get_vd_hash() const 1970 { return Convert<32, big_endian>::convert_host(this->p_->vd_hash); } 1971 1972 Elf_Word 1973 get_vd_aux() const 1974 { return Convert<32, big_endian>::convert_host(this->p_->vd_aux); } 1975 1976 Elf_Word 1977 get_vd_next() const 1978 { return Convert<32, big_endian>::convert_host(this->p_->vd_next); } 1979 1980 private: 1981 const internal::Verdef_data* p_; 1982 }; 1983 1984 template<int size, bool big_endian> 1985 class Verdef_write 1986 { 1987 public: 1988 Verdef_write(unsigned char* p) 1989 : p_(reinterpret_cast<internal::Verdef_data*>(p)) 1990 { } 1991 1992 void 1993 set_vd_version(Elf_Half v) 1994 { this->p_->vd_version = Convert<16, big_endian>::convert_host(v); } 1995 1996 void 1997 set_vd_flags(Elf_Half v) 1998 { this->p_->vd_flags = Convert<16, big_endian>::convert_host(v); } 1999 2000 void 2001 set_vd_ndx(Elf_Half v) 2002 { this->p_->vd_ndx = Convert<16, big_endian>::convert_host(v); } 2003 2004 void 2005 set_vd_cnt(Elf_Half v) 2006 { this->p_->vd_cnt = Convert<16, big_endian>::convert_host(v); } 2007 2008 void 2009 set_vd_hash(Elf_Word v) 2010 { this->p_->vd_hash = Convert<32, big_endian>::convert_host(v); } 2011 2012 void 2013 set_vd_aux(Elf_Word v) 2014 { this->p_->vd_aux = Convert<32, big_endian>::convert_host(v); } 2015 2016 void 2017 set_vd_next(Elf_Word v) 2018 { this->p_->vd_next = Convert<32, big_endian>::convert_host(v); } 2019 2020 private: 2021 internal::Verdef_data* p_; 2022 }; 2023 2024 // Accessor classes for auxiliary entries in the ELF SHT_GNU_verdef 2025 // section. 2026 2027 template<int size, bool big_endian> 2028 class Verdaux 2029 { 2030 public: 2031 Verdaux(const unsigned char* p) 2032 : p_(reinterpret_cast<const internal::Verdaux_data*>(p)) 2033 { } 2034 2035 template<typename File> 2036 Verdaux(File* file, typename File::Location loc) 2037 : p_(reinterpret_cast<const internal::Verdaux_data*>( 2038 file->view(loc.file_offset, loc.data_size).data())) 2039 { } 2040 2041 Elf_Word 2042 get_vda_name() const 2043 { return Convert<32, big_endian>::convert_host(this->p_->vda_name); } 2044 2045 Elf_Word 2046 get_vda_next() const 2047 { return Convert<32, big_endian>::convert_host(this->p_->vda_next); } 2048 2049 private: 2050 const internal::Verdaux_data* p_; 2051 }; 2052 2053 template<int size, bool big_endian> 2054 class Verdaux_write 2055 { 2056 public: 2057 Verdaux_write(unsigned char* p) 2058 : p_(reinterpret_cast<internal::Verdaux_data*>(p)) 2059 { } 2060 2061 void 2062 set_vda_name(Elf_Word v) 2063 { this->p_->vda_name = Convert<32, big_endian>::convert_host(v); } 2064 2065 void 2066 set_vda_next(Elf_Word v) 2067 { this->p_->vda_next = Convert<32, big_endian>::convert_host(v); } 2068 2069 private: 2070 internal::Verdaux_data* p_; 2071 }; 2072 2073 // Accessor classes for entries in the ELF SHT_GNU_verneed section. 2074 2075 template<int size, bool big_endian> 2076 class Verneed 2077 { 2078 public: 2079 Verneed(const unsigned char* p) 2080 : p_(reinterpret_cast<const internal::Verneed_data*>(p)) 2081 { } 2082 2083 template<typename File> 2084 Verneed(File* file, typename File::Location loc) 2085 : p_(reinterpret_cast<const internal::Verneed_data*>( 2086 file->view(loc.file_offset, loc.data_size).data())) 2087 { } 2088 2089 Elf_Half 2090 get_vn_version() const 2091 { return Convert<16, big_endian>::convert_host(this->p_->vn_version); } 2092 2093 Elf_Half 2094 get_vn_cnt() const 2095 { return Convert<16, big_endian>::convert_host(this->p_->vn_cnt); } 2096 2097 Elf_Word 2098 get_vn_file() const 2099 { return Convert<32, big_endian>::convert_host(this->p_->vn_file); } 2100 2101 Elf_Word 2102 get_vn_aux() const 2103 { return Convert<32, big_endian>::convert_host(this->p_->vn_aux); } 2104 2105 Elf_Word 2106 get_vn_next() const 2107 { return Convert<32, big_endian>::convert_host(this->p_->vn_next); } 2108 2109 private: 2110 const internal::Verneed_data* p_; 2111 }; 2112 2113 template<int size, bool big_endian> 2114 class Verneed_write 2115 { 2116 public: 2117 Verneed_write(unsigned char* p) 2118 : p_(reinterpret_cast<internal::Verneed_data*>(p)) 2119 { } 2120 2121 void 2122 set_vn_version(Elf_Half v) 2123 { this->p_->vn_version = Convert<16, big_endian>::convert_host(v); } 2124 2125 void 2126 set_vn_cnt(Elf_Half v) 2127 { this->p_->vn_cnt = Convert<16, big_endian>::convert_host(v); } 2128 2129 void 2130 set_vn_file(Elf_Word v) 2131 { this->p_->vn_file = Convert<32, big_endian>::convert_host(v); } 2132 2133 void 2134 set_vn_aux(Elf_Word v) 2135 { this->p_->vn_aux = Convert<32, big_endian>::convert_host(v); } 2136 2137 void 2138 set_vn_next(Elf_Word v) 2139 { this->p_->vn_next = Convert<32, big_endian>::convert_host(v); } 2140 2141 private: 2142 internal::Verneed_data* p_; 2143 }; 2144 2145 // Accessor classes for auxiliary entries in the ELF SHT_GNU_verneed 2146 // section. 2147 2148 template<int size, bool big_endian> 2149 class Vernaux 2150 { 2151 public: 2152 Vernaux(const unsigned char* p) 2153 : p_(reinterpret_cast<const internal::Vernaux_data*>(p)) 2154 { } 2155 2156 template<typename File> 2157 Vernaux(File* file, typename File::Location loc) 2158 : p_(reinterpret_cast<const internal::Vernaux_data*>( 2159 file->view(loc.file_offset, loc.data_size).data())) 2160 { } 2161 2162 Elf_Word 2163 get_vna_hash() const 2164 { return Convert<32, big_endian>::convert_host(this->p_->vna_hash); } 2165 2166 Elf_Half 2167 get_vna_flags() const 2168 { return Convert<16, big_endian>::convert_host(this->p_->vna_flags); } 2169 2170 Elf_Half 2171 get_vna_other() const 2172 { return Convert<16, big_endian>::convert_host(this->p_->vna_other); } 2173 2174 Elf_Word 2175 get_vna_name() const 2176 { return Convert<32, big_endian>::convert_host(this->p_->vna_name); } 2177 2178 Elf_Word 2179 get_vna_next() const 2180 { return Convert<32, big_endian>::convert_host(this->p_->vna_next); } 2181 2182 private: 2183 const internal::Vernaux_data* p_; 2184 }; 2185 2186 template<int size, bool big_endian> 2187 class Vernaux_write 2188 { 2189 public: 2190 Vernaux_write(unsigned char* p) 2191 : p_(reinterpret_cast<internal::Vernaux_data*>(p)) 2192 { } 2193 2194 void 2195 set_vna_hash(Elf_Word v) 2196 { this->p_->vna_hash = Convert<32, big_endian>::convert_host(v); } 2197 2198 void 2199 set_vna_flags(Elf_Half v) 2200 { this->p_->vna_flags = Convert<16, big_endian>::convert_host(v); } 2201 2202 void 2203 set_vna_other(Elf_Half v) 2204 { this->p_->vna_other = Convert<16, big_endian>::convert_host(v); } 2205 2206 void 2207 set_vna_name(Elf_Word v) 2208 { this->p_->vna_name = Convert<32, big_endian>::convert_host(v); } 2209 2210 void 2211 set_vna_next(Elf_Word v) 2212 { this->p_->vna_next = Convert<32, big_endian>::convert_host(v); } 2213 2214 private: 2215 internal::Vernaux_data* p_; 2216 }; 2217 2218 } // End namespace elfcpp. 2219 2220 #endif // !defined(ELFPCP_H) 2221