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