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