1 /*- 2 * Copyright (c) 2007-2012 Kai Wang 3 * Copyright (c) 2003 David O'Brien. All rights reserved. 4 * Copyright (c) 2001 Jake Burkholder 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #include <sys/param.h> 30 #include <sys/queue.h> 31 #include <sys/stat.h> 32 33 #include <ar.h> 34 #include <assert.h> 35 #include <err.h> 36 #include <fcntl.h> 37 #include <gelf.h> 38 #include <getopt.h> 39 #include <libelftc.h> 40 #include <inttypes.h> 41 #include <stdio.h> 42 #include <stdlib.h> 43 #include <string.h> 44 #include <unistd.h> 45 46 #ifdef USE_LIBARCHIVE_AR 47 #include <archive.h> 48 #include <archive_entry.h> 49 #endif 50 51 #include "_elftc.h" 52 53 ELFTC_VCSID("$Id: elfdump.c 3482 2016-08-02 18:47:00Z emaste $"); 54 55 #if defined(ELFTC_NEED_ELF_NOTE_DEFINITION) 56 #include "native-elf-format.h" 57 #if ELFTC_CLASS == ELFCLASS32 58 typedef Elf32_Nhdr Elf_Note; 59 #else 60 typedef Elf64_Nhdr Elf_Note; 61 #endif 62 #endif 63 64 /* elfdump(1) options. */ 65 #define ED_DYN (1<<0) 66 #define ED_EHDR (1<<1) 67 #define ED_GOT (1<<2) 68 #define ED_HASH (1<<3) 69 #define ED_INTERP (1<<4) 70 #define ED_NOTE (1<<5) 71 #define ED_PHDR (1<<6) 72 #define ED_REL (1<<7) 73 #define ED_SHDR (1<<8) 74 #define ED_SYMTAB (1<<9) 75 #define ED_SYMVER (1<<10) 76 #define ED_CHECKSUM (1<<11) 77 #define ED_ALL ((1<<12)-1) 78 79 /* elfdump(1) run control flags. */ 80 #define SOLARIS_FMT (1<<0) 81 #define PRINT_FILENAME (1<<1) 82 #define PRINT_ARSYM (1<<2) 83 #define ONLY_ARSYM (1<<3) 84 85 /* Convenient print macro. */ 86 #define PRT(...) fprintf(ed->out, __VA_ARGS__) 87 88 /* Internal data structure for sections. */ 89 struct section { 90 const char *name; /* section name */ 91 Elf_Scn *scn; /* section scn */ 92 uint64_t off; /* section offset */ 93 uint64_t sz; /* section size */ 94 uint64_t entsize; /* section entsize */ 95 uint64_t align; /* section alignment */ 96 uint64_t type; /* section type */ 97 uint64_t flags; /* section flags */ 98 uint64_t addr; /* section virtual addr */ 99 uint32_t link; /* section link ndx */ 100 uint32_t info; /* section info ndx */ 101 }; 102 103 struct spec_name { 104 const char *name; 105 STAILQ_ENTRY(spec_name) sn_list; 106 }; 107 108 /* Structure encapsulates the global data for readelf(1). */ 109 struct elfdump { 110 FILE *out; /* output redirection. */ 111 const char *filename; /* current processing file. */ 112 const char *archive; /* archive name */ 113 int options; /* command line options. */ 114 int flags; /* run control flags. */ 115 Elf *elf; /* underlying ELF descriptor. */ 116 #ifndef USE_LIBARCHIVE_AR 117 Elf *ar; /* ar(1) archive descriptor. */ 118 #endif 119 GElf_Ehdr ehdr; /* ELF header. */ 120 int ec; /* ELF class. */ 121 size_t shnum; /* #sections. */ 122 struct section *sl; /* list of sections. */ 123 STAILQ_HEAD(, spec_name) snl; /* list of names specified by -N. */ 124 }; 125 126 /* Relocation entry. */ 127 struct rel_entry { 128 union { 129 GElf_Rel rel; 130 GElf_Rela rela; 131 } u_r; 132 const char *symn; 133 uint32_t type; 134 }; 135 136 #if defined(ELFTC_NEED_BYTEORDER_EXTENSIONS) 137 static __inline uint32_t 138 be32dec(const void *pp) 139 { 140 unsigned char const *p = (unsigned char const *)pp; 141 142 return ((p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]); 143 } 144 145 static __inline uint32_t 146 le32dec(const void *pp) 147 { 148 unsigned char const *p = (unsigned char const *)pp; 149 150 return ((p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0]); 151 } 152 #endif 153 154 /* http://www.sco.com/developers/gabi/latest/ch5.dynamic.html#tag_encodings */ 155 static const char * 156 d_tags(uint64_t tag) 157 { 158 static char unknown_buf[64]; 159 160 switch (tag) { 161 case DT_NULL: return "DT_NULL"; 162 case DT_NEEDED: return "DT_NEEDED"; 163 case DT_PLTRELSZ: return "DT_PLTRELSZ"; 164 case DT_PLTGOT: return "DT_PLTGOT"; 165 case DT_HASH: return "DT_HASH"; 166 case DT_STRTAB: return "DT_STRTAB"; 167 case DT_SYMTAB: return "DT_SYMTAB"; 168 case DT_RELA: return "DT_RELA"; 169 case DT_RELASZ: return "DT_RELASZ"; 170 case DT_RELAENT: return "DT_RELAENT"; 171 case DT_STRSZ: return "DT_STRSZ"; 172 case DT_SYMENT: return "DT_SYMENT"; 173 case DT_INIT: return "DT_INIT"; 174 case DT_FINI: return "DT_FINI"; 175 case DT_SONAME: return "DT_SONAME"; 176 case DT_RPATH: return "DT_RPATH"; 177 case DT_SYMBOLIC: return "DT_SYMBOLIC"; 178 case DT_REL: return "DT_REL"; 179 case DT_RELSZ: return "DT_RELSZ"; 180 case DT_RELENT: return "DT_RELENT"; 181 case DT_PLTREL: return "DT_PLTREL"; 182 case DT_DEBUG: return "DT_DEBUG"; 183 case DT_TEXTREL: return "DT_TEXTREL"; 184 case DT_JMPREL: return "DT_JMPREL"; 185 case DT_BIND_NOW: return "DT_BIND_NOW"; 186 case DT_INIT_ARRAY: return "DT_INIT_ARRAY"; 187 case DT_FINI_ARRAY: return "DT_FINI_ARRAY"; 188 case DT_INIT_ARRAYSZ: return "DT_INIT_ARRAYSZ"; 189 case DT_FINI_ARRAYSZ: return "DT_FINI_ARRAYSZ"; 190 case DT_RUNPATH: return "DT_RUNPATH"; 191 case DT_FLAGS: return "DT_FLAGS"; 192 case DT_PREINIT_ARRAY: return "DT_PREINIT_ARRAY"; /* XXX DT_ENCODING */ 193 case DT_PREINIT_ARRAYSZ:return "DT_PREINIT_ARRAYSZ"; 194 /* 0x6000000D - 0x6ffff000 operating system-specific semantics */ 195 case 0x6ffffdf5: return "DT_GNU_PRELINKED"; 196 case 0x6ffffdf6: return "DT_GNU_CONFLICTSZ"; 197 case 0x6ffffdf7: return "DT_GNU_LIBLISTSZ"; 198 case 0x6ffffdf8: return "DT_SUNW_CHECKSUM"; 199 case DT_PLTPADSZ: return "DT_PLTPADSZ"; 200 case DT_MOVEENT: return "DT_MOVEENT"; 201 case DT_MOVESZ: return "DT_MOVESZ"; 202 case 0x6ffffdfc: return "DT_FEATURE"; 203 case DT_POSFLAG_1: return "DT_POSFLAG_1"; 204 case DT_SYMINSZ: return "DT_SYMINSZ"; 205 case DT_SYMINENT: return "DT_SYMINENT (DT_VALRNGHI)"; 206 case DT_ADDRRNGLO: return "DT_ADDRRNGLO"; 207 case DT_GNU_HASH: return "DT_GNU_HASH"; 208 case 0x6ffffef8: return "DT_GNU_CONFLICT"; 209 case 0x6ffffef9: return "DT_GNU_LIBLIST"; 210 case 0x6ffffefa: return "DT_CONFIG"; 211 case 0x6ffffefb: return "DT_DEPAUDIT"; 212 case 0x6ffffefc: return "DT_AUDIT"; 213 case 0x6ffffefd: return "DT_PLTPAD"; 214 case 0x6ffffefe: return "DT_MOVETAB"; 215 case DT_SYMINFO: return "DT_SYMINFO (DT_ADDRRNGHI)"; 216 case DT_RELACOUNT: return "DT_RELACOUNT"; 217 case DT_RELCOUNT: return "DT_RELCOUNT"; 218 case DT_FLAGS_1: return "DT_FLAGS_1"; 219 case DT_VERDEF: return "DT_VERDEF"; 220 case DT_VERDEFNUM: return "DT_VERDEFNUM"; 221 case DT_VERNEED: return "DT_VERNEED"; 222 case DT_VERNEEDNUM: return "DT_VERNEEDNUM"; 223 case 0x6ffffff0: return "DT_GNU_VERSYM"; 224 /* 0x70000000 - 0x7fffffff processor-specific semantics */ 225 case 0x70000000: return "DT_IA_64_PLT_RESERVE"; 226 case 0x7ffffffd: return "DT_SUNW_AUXILIARY"; 227 case 0x7ffffffe: return "DT_SUNW_USED"; 228 case 0x7fffffff: return "DT_SUNW_FILTER"; 229 } 230 231 snprintf(unknown_buf, sizeof(unknown_buf), 232 "<unknown: %#llx>", (unsigned long long)tag); 233 return (unknown_buf); 234 } 235 236 static const char * 237 e_machines(unsigned int mach) 238 { 239 static char machdesc[64]; 240 241 switch (mach) { 242 case EM_NONE: return "EM_NONE"; 243 case EM_M32: return "EM_M32"; 244 case EM_SPARC: return "EM_SPARC"; 245 case EM_386: return "EM_386"; 246 case EM_68K: return "EM_68K"; 247 case EM_88K: return "EM_88K"; 248 case EM_IAMCU: return "EM_IAMCU"; 249 case EM_860: return "EM_860"; 250 case EM_MIPS: return "EM_MIPS"; 251 case EM_PPC: return "EM_PPC"; 252 case EM_PPC64: return "EM_PPC64"; 253 case EM_ARM: return "EM_ARM"; 254 case EM_ALPHA: return "EM_ALPHA (legacy)"; 255 case EM_SPARCV9:return "EM_SPARCV9"; 256 case EM_IA_64: return "EM_IA_64"; 257 case EM_X86_64: return "EM_X86_64"; 258 case EM_AARCH64:return "EM_AARCH64"; 259 case EM_RISCV: return "EM_RISCV"; 260 } 261 snprintf(machdesc, sizeof(machdesc), 262 "(unknown machine) -- type 0x%x", mach); 263 return (machdesc); 264 } 265 266 static const char * 267 elf_type_str(unsigned int type) 268 { 269 static char s_type[32]; 270 271 switch (type) 272 { 273 case ET_NONE: return "ET_NONE"; 274 case ET_REL: return "ET_REL"; 275 case ET_EXEC: return "ET_EXEC"; 276 case ET_DYN: return "ET_DYN"; 277 case ET_CORE: return "ET_CORE"; 278 } 279 if (type >= ET_LOPROC) 280 snprintf(s_type, sizeof(s_type), "<proc: %#x>", type); 281 else if (type >= ET_LOOS && type <= ET_HIOS) 282 snprintf(s_type, sizeof(s_type), "<os: %#x>", type); 283 else 284 snprintf(s_type, sizeof(s_type), "<unknown: %#x", type); 285 return (s_type); 286 } 287 288 static const char * 289 elf_version_str(unsigned int ver) 290 { 291 static char s_ver[32]; 292 293 switch (ver) { 294 case EV_NONE: return "EV_NONE"; 295 case EV_CURRENT: return "EV_CURRENT"; 296 } 297 snprintf(s_ver, sizeof(s_ver), "<unknown: %#x>", ver); 298 return (s_ver); 299 } 300 301 static const char * 302 elf_class_str(unsigned int class) 303 { 304 static char s_class[32]; 305 306 switch (class) { 307 case ELFCLASSNONE: return "ELFCLASSNONE"; 308 case ELFCLASS32: return "ELFCLASS32"; 309 case ELFCLASS64: return "ELFCLASS64"; 310 } 311 snprintf(s_class, sizeof(s_class), "<unknown: %#x>", class); 312 return (s_class); 313 } 314 315 static const char * 316 elf_data_str(unsigned int data) 317 { 318 static char s_data[32]; 319 320 switch (data) { 321 case ELFDATANONE: return "ELFDATANONE"; 322 case ELFDATA2LSB: return "ELFDATA2LSB"; 323 case ELFDATA2MSB: return "ELFDATA2MSB"; 324 } 325 snprintf(s_data, sizeof(s_data), "<unknown: %#x>", data); 326 return (s_data); 327 } 328 329 static const char *ei_abis[256] = { 330 "ELFOSABI_NONE", "ELFOSABI_HPUX", "ELFOSABI_NETBSD", "ELFOSABI_LINUX", 331 "ELFOSABI_HURD", "ELFOSABI_86OPEN", "ELFOSABI_SOLARIS", "ELFOSABI_AIX", 332 "ELFOSABI_IRIX", "ELFOSABI_FREEBSD", "ELFOSABI_TRU64", 333 "ELFOSABI_MODESTO", "ELFOSABI_OPENBSD", 334 [17] = "ELFOSABI_CLOUDABI", 335 [64] = "ELFOSABI_ARM_AEABI", 336 [97] = "ELFOSABI_ARM", 337 [255] = "ELFOSABI_STANDALONE" 338 }; 339 340 static const char * 341 elf_phdr_type_str(unsigned int type) 342 { 343 static char s_type[32]; 344 345 switch (type) { 346 case PT_NULL: return "PT_NULL"; 347 case PT_LOAD: return "PT_LOAD"; 348 case PT_DYNAMIC: return "PT_DYNAMIC"; 349 case PT_INTERP: return "PT_INTERP"; 350 case PT_NOTE: return "PT_NOTE"; 351 case PT_SHLIB: return "PT_SHLIB"; 352 case PT_PHDR: return "PT_PHDR"; 353 case PT_TLS: return "PT_TLS"; 354 case PT_GNU_EH_FRAME: return "PT_GNU_EH_FRAME"; 355 case PT_GNU_STACK: return "PT_GNU_STACK"; 356 case PT_GNU_RELRO: return "PT_GNU_RELRO"; 357 } 358 snprintf(s_type, sizeof(s_type), "<unknown: %#x>", type); 359 return (s_type); 360 } 361 362 static const char *p_flags[] = { 363 "", "PF_X", "PF_W", "PF_X|PF_W", "PF_R", "PF_X|PF_R", "PF_W|PF_R", 364 "PF_X|PF_W|PF_R" 365 }; 366 367 static const char * 368 sh_name(struct elfdump *ed, int ndx) 369 { 370 static char num[10]; 371 372 switch (ndx) { 373 case SHN_UNDEF: return "UNDEF"; 374 case SHN_ABS: return "ABS"; 375 case SHN_COMMON: return "COMMON"; 376 default: 377 if ((uint64_t)ndx < ed->shnum) 378 return (ed->sl[ndx].name); 379 else { 380 snprintf(num, sizeof(num), "%d", ndx); 381 return (num); 382 } 383 } 384 } 385 386 /* http://www.sco.com/developers/gabi/latest/ch4.sheader.html#sh_type */ 387 static const char * 388 sh_types(uint64_t mach, uint64_t sht) { 389 static char unknown_buf[64]; 390 391 if (sht < 0x60000000) { 392 switch (sht) { 393 case SHT_NULL: return "SHT_NULL"; 394 case SHT_PROGBITS: return "SHT_PROGBITS"; 395 case SHT_SYMTAB: return "SHT_SYMTAB"; 396 case SHT_STRTAB: return "SHT_STRTAB"; 397 case SHT_RELA: return "SHT_RELA"; 398 case SHT_HASH: return "SHT_HASH"; 399 case SHT_DYNAMIC: return "SHT_DYNAMIC"; 400 case SHT_NOTE: return "SHT_NOTE"; 401 case SHT_NOBITS: return "SHT_NOBITS"; 402 case SHT_REL: return "SHT_REL"; 403 case SHT_SHLIB: return "SHT_SHLIB"; 404 case SHT_DYNSYM: return "SHT_DYNSYM"; 405 case SHT_INIT_ARRAY: return "SHT_INIT_ARRAY"; 406 case SHT_FINI_ARRAY: return "SHT_FINI_ARRAY"; 407 case SHT_PREINIT_ARRAY: return "SHT_PREINIT_ARRAY"; 408 case SHT_GROUP: return "SHT_GROUP"; 409 case SHT_SYMTAB_SHNDX: return "SHT_SYMTAB_SHNDX"; 410 } 411 } else if (sht < 0x70000000) { 412 /* 0x60000000-0x6fffffff operating system-specific semantics */ 413 switch (sht) { 414 case 0x6ffffff0: return "XXX:VERSYM"; 415 case SHT_SUNW_dof: return "SHT_SUNW_dof"; 416 case SHT_GNU_HASH: return "SHT_GNU_HASH"; 417 case 0x6ffffff7: return "SHT_GNU_LIBLIST"; 418 case 0x6ffffffc: return "XXX:VERDEF"; 419 case SHT_SUNW_verdef: return "SHT_SUNW(GNU)_verdef"; 420 case SHT_SUNW_verneed: return "SHT_SUNW(GNU)_verneed"; 421 case SHT_SUNW_versym: return "SHT_SUNW(GNU)_versym"; 422 } 423 } else if (sht < 0x80000000) { 424 /* 0x70000000 - 0x7fffffff processor-specific semantics */ 425 switch (mach) { 426 case EM_ARM: 427 switch (sht) { 428 case SHT_ARM_EXIDX: return "SHT_ARM_EXIDX"; 429 case SHT_ARM_PREEMPTMAP: return "SHT_ARM_PREEMPTMAP"; 430 case SHT_ARM_ATTRIBUTES: return "SHT_ARM_ATTRIBUTES"; 431 case SHT_ARM_DEBUGOVERLAY: 432 return "SHT_ARM_DEBUGOVERLAY"; 433 case SHT_ARM_OVERLAYSECTION: 434 return "SHT_ARM_OVERLAYSECTION"; 435 } 436 break; 437 case EM_IA_64: 438 switch (sht) { 439 case 0x70000000: return "SHT_IA_64_EXT"; 440 case 0x70000001: return "SHT_IA_64_UNWIND"; 441 } 442 break; 443 case EM_MIPS: 444 switch (sht) { 445 case SHT_MIPS_REGINFO: return "SHT_MIPS_REGINFO"; 446 case SHT_MIPS_OPTIONS: return "SHT_MIPS_OPTIONS"; 447 case SHT_MIPS_ABIFLAGS: return "SHT_MIPS_ABIFLAGS"; 448 } 449 break; 450 } 451 switch (sht) { 452 case 0x7ffffffd: return "XXX:AUXILIARY"; 453 case 0x7fffffff: return "XXX:FILTER"; 454 } 455 } 456 /* 0x80000000 - 0xffffffff application programs */ 457 458 snprintf(unknown_buf, sizeof(unknown_buf), 459 "<unknown: %#llx>", (unsigned long long)sht); 460 return (unknown_buf); 461 } 462 463 /* 464 * Define known section flags. These flags are defined in the order 465 * they are to be printed out. 466 */ 467 #define DEFINE_SHFLAGS() \ 468 DEFINE_SHF(WRITE) \ 469 DEFINE_SHF(ALLOC) \ 470 DEFINE_SHF(EXECINSTR) \ 471 DEFINE_SHF(MERGE) \ 472 DEFINE_SHF(STRINGS) \ 473 DEFINE_SHF(INFO_LINK) \ 474 DEFINE_SHF(LINK_ORDER) \ 475 DEFINE_SHF(OS_NONCONFORMING) \ 476 DEFINE_SHF(GROUP) \ 477 DEFINE_SHF(TLS) \ 478 DEFINE_SHF(COMPRESSED) 479 480 #undef DEFINE_SHF 481 #define DEFINE_SHF(F) "SHF_" #F "|" 482 #define ALLSHFLAGS DEFINE_SHFLAGS() 483 484 static const char * 485 sh_flags(uint64_t shf) 486 { 487 static char flg[sizeof(ALLSHFLAGS)+1]; 488 489 flg[0] = '\0'; 490 491 #undef DEFINE_SHF 492 #define DEFINE_SHF(N) \ 493 if (shf & SHF_##N) \ 494 strcat(flg, "SHF_" #N "|"); \ 495 496 DEFINE_SHFLAGS() 497 498 flg[strlen(flg) - 1] = '\0'; /* Remove the trailing "|". */ 499 500 return (flg); 501 } 502 503 static const char * 504 st_type(unsigned int mach, unsigned int type) 505 { 506 static char s_type[32]; 507 508 switch (type) { 509 case STT_NOTYPE: return "STT_NOTYPE"; 510 case STT_OBJECT: return "STT_OBJECT"; 511 case STT_FUNC: return "STT_FUNC"; 512 case STT_SECTION: return "STT_SECTION"; 513 case STT_FILE: return "STT_FILE"; 514 case STT_COMMON: return "STT_COMMON"; 515 case STT_TLS: return "STT_TLS"; 516 case 13: 517 if (mach == EM_SPARCV9) 518 return "STT_SPARC_REGISTER"; 519 break; 520 } 521 snprintf(s_type, sizeof(s_type), "<unknown: %#x>", type); 522 return (s_type); 523 } 524 525 static const char * 526 st_type_S(unsigned int type) 527 { 528 static char s_type[32]; 529 530 switch (type) { 531 case STT_NOTYPE: return "NOTY"; 532 case STT_OBJECT: return "OBJT"; 533 case STT_FUNC: return "FUNC"; 534 case STT_SECTION: return "SECT"; 535 case STT_FILE: return "FILE"; 536 } 537 snprintf(s_type, sizeof(s_type), "<unknown: %#x>", type); 538 return (s_type); 539 } 540 541 static const char * 542 st_bindings(unsigned int sbind) 543 { 544 static char s_sbind[32]; 545 546 switch (sbind) { 547 case STB_LOCAL: return "STB_LOCAL"; 548 case STB_GLOBAL: return "STB_GLOBAL"; 549 case STB_WEAK: return "STB_WEAK"; 550 case STB_GNU_UNIQUE: return "STB_GNU_UNIQUE"; 551 default: 552 if (sbind >= STB_LOOS && sbind <= STB_HIOS) 553 return "OS"; 554 else if (sbind >= STB_LOPROC && sbind <= STB_HIPROC) 555 return "PROC"; 556 else 557 snprintf(s_sbind, sizeof(s_sbind), "<unknown: %#x>", 558 sbind); 559 return (s_sbind); 560 } 561 } 562 563 static const char * 564 st_bindings_S(unsigned int sbind) 565 { 566 static char s_sbind[32]; 567 568 switch (sbind) { 569 case STB_LOCAL: return "LOCL"; 570 case STB_GLOBAL: return "GLOB"; 571 case STB_WEAK: return "WEAK"; 572 case STB_GNU_UNIQUE: return "UNIQ"; 573 default: 574 if (sbind >= STB_LOOS && sbind <= STB_HIOS) 575 return "OS"; 576 else if (sbind >= STB_LOPROC && sbind <= STB_HIPROC) 577 return "PROC"; 578 else 579 snprintf(s_sbind, sizeof(s_sbind), "<%#x>", 580 sbind); 581 return (s_sbind); 582 } 583 } 584 585 static unsigned char st_others[] = { 586 'D', 'I', 'H', 'P' 587 }; 588 589 static void add_name(struct elfdump *ed, const char *name); 590 static void elf_print_object(struct elfdump *ed); 591 static void elf_print_elf(struct elfdump *ed); 592 static void elf_print_ehdr(struct elfdump *ed); 593 static void elf_print_phdr(struct elfdump *ed); 594 static void elf_print_shdr(struct elfdump *ed); 595 static void elf_print_symtab(struct elfdump *ed, int i); 596 static void elf_print_symtabs(struct elfdump *ed); 597 static void elf_print_symver(struct elfdump *ed); 598 static void elf_print_verdef(struct elfdump *ed, struct section *s); 599 static void elf_print_verneed(struct elfdump *ed, struct section *s); 600 static void elf_print_interp(struct elfdump *ed); 601 static void elf_print_dynamic(struct elfdump *ed); 602 static void elf_print_rel_entry(struct elfdump *ed, struct section *s, 603 int j, struct rel_entry *r); 604 static void elf_print_rela(struct elfdump *ed, struct section *s, 605 Elf_Data *data); 606 static void elf_print_rel(struct elfdump *ed, struct section *s, 607 Elf_Data *data); 608 static void elf_print_reloc(struct elfdump *ed); 609 static void elf_print_got(struct elfdump *ed); 610 static void elf_print_got_section(struct elfdump *ed, struct section *s); 611 static void elf_print_note(struct elfdump *ed); 612 static void elf_print_svr4_hash(struct elfdump *ed, struct section *s); 613 static void elf_print_svr4_hash64(struct elfdump *ed, struct section *s); 614 static void elf_print_gnu_hash(struct elfdump *ed, struct section *s); 615 static void elf_print_hash(struct elfdump *ed); 616 static void elf_print_checksum(struct elfdump *ed); 617 static void find_gotrel(struct elfdump *ed, struct section *gs, 618 struct rel_entry *got); 619 static struct spec_name *find_name(struct elfdump *ed, const char *name); 620 static int get_ent_count(const struct section *s, int *ent_count); 621 static const char *get_symbol_name(struct elfdump *ed, uint32_t symtab, int i); 622 static const char *get_string(struct elfdump *ed, int strtab, size_t off); 623 static void get_versym(struct elfdump *ed, int i, uint16_t **vs, int *nvs); 624 static void load_sections(struct elfdump *ed); 625 static void unload_sections(struct elfdump *ed); 626 static void usage(void); 627 #ifdef USE_LIBARCHIVE_AR 628 static int ac_detect_ar(int fd); 629 static void ac_print_ar(struct elfdump *ed, int fd); 630 #else 631 static void elf_print_ar(struct elfdump *ed, int fd); 632 #endif /* USE_LIBARCHIVE_AR */ 633 634 static struct option elfdump_longopts[] = 635 { 636 { "help", no_argument, NULL, 'H' }, 637 { "version", no_argument, NULL, 'V' }, 638 { NULL, 0, NULL, 0 } 639 }; 640 641 int 642 main(int ac, char **av) 643 { 644 struct elfdump *ed, ed_storage; 645 struct spec_name *sn; 646 int ch, i; 647 648 ed = &ed_storage; 649 memset(ed, 0, sizeof(*ed)); 650 STAILQ_INIT(&ed->snl); 651 ed->out = stdout; 652 while ((ch = getopt_long(ac, av, "acdeiGHhknN:prsSvVw:", 653 elfdump_longopts, NULL)) != -1) 654 switch (ch) { 655 case 'a': 656 ed->options = ED_ALL; 657 break; 658 case 'c': 659 ed->options |= ED_SHDR; 660 break; 661 case 'd': 662 ed->options |= ED_DYN; 663 break; 664 case 'e': 665 ed->options |= ED_EHDR; 666 break; 667 case 'i': 668 ed->options |= ED_INTERP; 669 break; 670 case 'G': 671 ed->options |= ED_GOT; 672 break; 673 case 'h': 674 ed->options |= ED_HASH; 675 break; 676 case 'k': 677 ed->options |= ED_CHECKSUM; 678 break; 679 case 'n': 680 ed->options |= ED_NOTE; 681 break; 682 case 'N': 683 add_name(ed, optarg); 684 break; 685 case 'p': 686 ed->options |= ED_PHDR; 687 break; 688 case 'r': 689 ed->options |= ED_REL; 690 break; 691 case 's': 692 ed->options |= ED_SYMTAB; 693 break; 694 case 'S': 695 ed->flags |= SOLARIS_FMT; 696 break; 697 case 'v': 698 ed->options |= ED_SYMVER; 699 break; 700 case 'V': 701 (void) printf("%s (%s)\n", ELFTC_GETPROGNAME(), 702 elftc_version()); 703 exit(EXIT_SUCCESS); 704 break; 705 case 'w': 706 if ((ed->out = fopen(optarg, "w")) == NULL) 707 err(EXIT_FAILURE, "%s", optarg); 708 break; 709 case '?': 710 case 'H': 711 default: 712 usage(); 713 } 714 715 ac -= optind; 716 av += optind; 717 718 if (ed->options == 0) 719 ed->options = ED_ALL; 720 sn = NULL; 721 if (ed->options & ED_SYMTAB && 722 (STAILQ_EMPTY(&ed->snl) || (sn = find_name(ed, "ARSYM")) != NULL)) { 723 ed->flags |= PRINT_ARSYM; 724 if (sn != NULL) { 725 STAILQ_REMOVE(&ed->snl, sn, spec_name, sn_list); 726 if (STAILQ_EMPTY(&ed->snl)) 727 ed->flags |= ONLY_ARSYM; 728 } 729 } 730 if (ac == 0) 731 usage(); 732 if (ac > 1) 733 ed->flags |= PRINT_FILENAME; 734 if (elf_version(EV_CURRENT) == EV_NONE) 735 errx(EXIT_FAILURE, "ELF library initialization failed: %s", 736 elf_errmsg(-1)); 737 738 for (i = 0; i < ac; i++) { 739 ed->filename = av[i]; 740 ed->archive = NULL; 741 elf_print_object(ed); 742 } 743 744 exit(EXIT_SUCCESS); 745 } 746 747 #ifdef USE_LIBARCHIVE_AR 748 749 /* Archive symbol table entry. */ 750 struct arsym_entry { 751 char *sym_name; 752 size_t off; 753 }; 754 755 /* 756 * Convenient wrapper for general libarchive error handling. 757 */ 758 #define AC(CALL) do { \ 759 if ((CALL)) { \ 760 warnx("%s", archive_error_string(a)); \ 761 return; \ 762 } \ 763 } while (0) 764 765 /* 766 * Detect an ar(1) archive using libarchive(3). 767 */ 768 static int 769 ac_detect_ar(int fd) 770 { 771 struct archive *a; 772 struct archive_entry *entry; 773 int r; 774 775 r = -1; 776 if ((a = archive_read_new()) == NULL) 777 return (0); 778 archive_read_support_format_ar(a); 779 if (archive_read_open_fd(a, fd, 10240) == ARCHIVE_OK) 780 r = archive_read_next_header(a, &entry); 781 archive_read_close(a); 782 archive_read_free(a); 783 784 return (r == ARCHIVE_OK); 785 } 786 787 /* 788 * Dump an ar(1) archive using libarchive(3). 789 */ 790 static void 791 ac_print_ar(struct elfdump *ed, int fd) 792 { 793 struct archive *a; 794 struct archive_entry *entry; 795 struct arsym_entry *arsym; 796 const char *name; 797 char idx[10], *b; 798 void *buff; 799 size_t size; 800 uint32_t cnt, i; 801 int r; 802 803 if (lseek(fd, 0, SEEK_SET) == -1) 804 err(EXIT_FAILURE, "lseek failed"); 805 if ((a = archive_read_new()) == NULL) 806 errx(EXIT_FAILURE, "%s", archive_error_string(a)); 807 archive_read_support_format_ar(a); 808 AC(archive_read_open_fd(a, fd, 10240)); 809 for(;;) { 810 r = archive_read_next_header(a, &entry); 811 if (r == ARCHIVE_FATAL) 812 errx(EXIT_FAILURE, "%s", archive_error_string(a)); 813 if (r == ARCHIVE_EOF) 814 break; 815 if (r == ARCHIVE_WARN || r == ARCHIVE_RETRY) 816 warnx("%s", archive_error_string(a)); 817 if (r == ARCHIVE_RETRY) 818 continue; 819 name = archive_entry_pathname(entry); 820 size = archive_entry_size(entry); 821 if (size == 0) 822 continue; 823 if ((buff = malloc(size)) == NULL) { 824 warn("malloc failed"); 825 continue; 826 } 827 if (archive_read_data(a, buff, size) != (ssize_t)size) { 828 warnx("%s", archive_error_string(a)); 829 free(buff); 830 continue; 831 } 832 833 /* 834 * Note that when processing arsym via libarchive, there is 835 * no way to tell which member a certain symbol belongs to, 836 * since we can not just "lseek" to a member offset and read 837 * the member header. 838 */ 839 if (!strcmp(name, "/") && ed->flags & PRINT_ARSYM) { 840 b = buff; 841 cnt = be32dec(b); 842 if (cnt == 0) { 843 free(buff); 844 continue; 845 } 846 arsym = calloc(cnt, sizeof(*arsym)); 847 if (arsym == NULL) 848 err(EXIT_FAILURE, "calloc failed"); 849 b += sizeof(uint32_t); 850 for (i = 0; i < cnt; i++) { 851 arsym[i].off = be32dec(b); 852 b += sizeof(uint32_t); 853 } 854 for (i = 0; i < cnt; i++) { 855 arsym[i].sym_name = b; 856 b += strlen(b) + 1; 857 } 858 if (ed->flags & SOLARIS_FMT) { 859 PRT("\nSymbol Table: (archive)\n"); 860 PRT(" index offset symbol\n"); 861 } else 862 PRT("\nsymbol table (archive):\n"); 863 for (i = 0; i < cnt; i++) { 864 if (ed->flags & SOLARIS_FMT) { 865 snprintf(idx, sizeof(idx), "[%d]", i); 866 PRT("%10s ", idx); 867 PRT("0x%8.8jx ", 868 (uintmax_t)arsym[i].off); 869 PRT("%s\n", arsym[i].sym_name); 870 } else { 871 PRT("\nentry: %d\n", i); 872 PRT("\toffset: %#jx\n", 873 (uintmax_t)arsym[i].off); 874 PRT("\tsymbol: %s\n", 875 arsym[i].sym_name); 876 } 877 } 878 free(arsym); 879 free(buff); 880 /* No need to continue if we only dump ARSYM. */ 881 if (ed->flags & ONLY_ARSYM) { 882 AC(archive_read_close(a)); 883 AC(archive_read_free(a)); 884 return; 885 } 886 continue; 887 } 888 if ((ed->elf = elf_memory(buff, size)) == NULL) { 889 warnx("elf_memroy() failed: %s", 890 elf_errmsg(-1)); 891 free(buff); 892 continue; 893 } 894 /* Skip non-ELF member. */ 895 if (elf_kind(ed->elf) == ELF_K_ELF) { 896 printf("\n%s(%s):\n", ed->archive, name); 897 elf_print_elf(ed); 898 } 899 elf_end(ed->elf); 900 free(buff); 901 } 902 AC(archive_read_close(a)); 903 AC(archive_read_free(a)); 904 } 905 906 #else /* USE_LIBARCHIVE_AR */ 907 908 /* 909 * Dump an ar(1) archive. 910 */ 911 static void 912 elf_print_ar(struct elfdump *ed, int fd) 913 { 914 Elf *e; 915 Elf_Arhdr *arh; 916 Elf_Arsym *arsym; 917 Elf_Cmd cmd; 918 char idx[10]; 919 size_t cnt, i; 920 921 ed->ar = ed->elf; 922 923 if (ed->flags & PRINT_ARSYM) { 924 cnt = 0; 925 if ((arsym = elf_getarsym(ed->ar, &cnt)) == NULL) { 926 warnx("elf_getarsym failed: %s", elf_errmsg(-1)); 927 goto print_members; 928 } 929 if (cnt == 0) 930 goto print_members; 931 if (ed->flags & SOLARIS_FMT) { 932 PRT("\nSymbol Table: (archive)\n"); 933 PRT(" index offset member name and symbol\n"); 934 } else 935 PRT("\nsymbol table (archive):\n"); 936 for (i = 0; i < cnt - 1; i++) { 937 if (elf_rand(ed->ar, arsym[i].as_off) != 938 arsym[i].as_off) { 939 warnx("elf_rand failed: %s", elf_errmsg(-1)); 940 break; 941 } 942 if ((e = elf_begin(fd, ELF_C_READ, ed->ar)) == NULL) { 943 warnx("elf_begin failed: %s", elf_errmsg(-1)); 944 break; 945 } 946 if ((arh = elf_getarhdr(e)) == NULL) { 947 warnx("elf_getarhdr failed: %s", 948 elf_errmsg(-1)); 949 break; 950 } 951 if (ed->flags & SOLARIS_FMT) { 952 snprintf(idx, sizeof(idx), "[%zu]", i); 953 PRT("%10s ", idx); 954 PRT("0x%8.8jx ", 955 (uintmax_t)arsym[i].as_off); 956 PRT("(%s):%s\n", arh->ar_name, 957 arsym[i].as_name); 958 } else { 959 PRT("\nentry: %zu\n", i); 960 PRT("\toffset: %#jx\n", 961 (uintmax_t)arsym[i].as_off); 962 PRT("\tmember: %s\n", arh->ar_name); 963 PRT("\tsymbol: %s\n", arsym[i].as_name); 964 } 965 elf_end(e); 966 } 967 968 /* No need to continue if we only dump ARSYM. */ 969 if (ed->flags & ONLY_ARSYM) 970 return; 971 } 972 973 print_members: 974 975 /* Rewind the archive. */ 976 if (elf_rand(ed->ar, SARMAG) != SARMAG) { 977 warnx("elf_rand failed: %s", elf_errmsg(-1)); 978 return; 979 } 980 981 /* Dump each member of the archive. */ 982 cmd = ELF_C_READ; 983 while ((ed->elf = elf_begin(fd, cmd, ed->ar)) != NULL) { 984 /* Skip non-ELF member. */ 985 if (elf_kind(ed->elf) == ELF_K_ELF) { 986 if ((arh = elf_getarhdr(ed->elf)) == NULL) { 987 warnx("elf_getarhdr failed: %s", 988 elf_errmsg(-1)); 989 break; 990 } 991 printf("\n%s(%s):\n", ed->archive, arh->ar_name); 992 elf_print_elf(ed); 993 } 994 cmd = elf_next(ed->elf); 995 elf_end(ed->elf); 996 } 997 } 998 999 #endif /* USE_LIBARCHIVE_AR */ 1000 1001 /* 1002 * Dump an object. (ELF object or ar(1) archive) 1003 */ 1004 static void 1005 elf_print_object(struct elfdump *ed) 1006 { 1007 int fd; 1008 1009 if ((fd = open(ed->filename, O_RDONLY)) == -1) { 1010 warn("open %s failed", ed->filename); 1011 return; 1012 } 1013 1014 #ifdef USE_LIBARCHIVE_AR 1015 if (ac_detect_ar(fd)) { 1016 ed->archive = ed->filename; 1017 ac_print_ar(ed, fd); 1018 return; 1019 } 1020 #endif /* USE_LIBARCHIVE_AR */ 1021 1022 if ((ed->elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL) { 1023 warnx("elf_begin() failed: %s", elf_errmsg(-1)); 1024 return; 1025 } 1026 1027 switch (elf_kind(ed->elf)) { 1028 case ELF_K_NONE: 1029 warnx("Not an ELF file."); 1030 return; 1031 case ELF_K_ELF: 1032 if (ed->flags & PRINT_FILENAME) 1033 printf("\n%s:\n", ed->filename); 1034 elf_print_elf(ed); 1035 break; 1036 case ELF_K_AR: 1037 #ifndef USE_LIBARCHIVE_AR 1038 ed->archive = ed->filename; 1039 elf_print_ar(ed, fd); 1040 #endif 1041 break; 1042 default: 1043 warnx("Internal: libelf returned unknown elf kind."); 1044 return; 1045 } 1046 1047 elf_end(ed->elf); 1048 } 1049 1050 /* 1051 * Dump an ELF object. 1052 */ 1053 static void 1054 elf_print_elf(struct elfdump *ed) 1055 { 1056 1057 if (gelf_getehdr(ed->elf, &ed->ehdr) == NULL) { 1058 warnx("gelf_getehdr failed: %s", elf_errmsg(-1)); 1059 return; 1060 } 1061 if ((ed->ec = gelf_getclass(ed->elf)) == ELFCLASSNONE) { 1062 warnx("gelf_getclass failed: %s", elf_errmsg(-1)); 1063 return; 1064 } 1065 1066 if (ed->options & (ED_SHDR | ED_DYN | ED_REL | ED_GOT | ED_SYMTAB | 1067 ED_SYMVER | ED_NOTE | ED_HASH)) 1068 load_sections(ed); 1069 1070 if (ed->options & ED_EHDR) 1071 elf_print_ehdr(ed); 1072 if (ed->options & ED_PHDR) 1073 elf_print_phdr(ed); 1074 if (ed->options & ED_INTERP) 1075 elf_print_interp(ed); 1076 if (ed->options & ED_SHDR) 1077 elf_print_shdr(ed); 1078 if (ed->options & ED_DYN) 1079 elf_print_dynamic(ed); 1080 if (ed->options & ED_REL) 1081 elf_print_reloc(ed); 1082 if (ed->options & ED_GOT) 1083 elf_print_got(ed); 1084 if (ed->options & ED_SYMTAB) 1085 elf_print_symtabs(ed); 1086 if (ed->options & ED_SYMVER) 1087 elf_print_symver(ed); 1088 if (ed->options & ED_NOTE) 1089 elf_print_note(ed); 1090 if (ed->options & ED_HASH) 1091 elf_print_hash(ed); 1092 if (ed->options & ED_CHECKSUM) 1093 elf_print_checksum(ed); 1094 1095 unload_sections(ed); 1096 } 1097 1098 /* 1099 * Read the section headers from ELF object and store them in the 1100 * internal cache. 1101 */ 1102 static void 1103 load_sections(struct elfdump *ed) 1104 { 1105 struct section *s; 1106 const char *name; 1107 Elf_Scn *scn; 1108 GElf_Shdr sh; 1109 size_t shstrndx, ndx; 1110 int elferr; 1111 1112 assert(ed->sl == NULL); 1113 1114 if (!elf_getshnum(ed->elf, &ed->shnum)) { 1115 warnx("elf_getshnum failed: %s", elf_errmsg(-1)); 1116 return; 1117 } 1118 if (ed->shnum == 0) 1119 return; 1120 if ((ed->sl = calloc(ed->shnum, sizeof(*ed->sl))) == NULL) 1121 err(EXIT_FAILURE, "calloc failed"); 1122 if (!elf_getshstrndx(ed->elf, &shstrndx)) { 1123 warnx("elf_getshstrndx failed: %s", elf_errmsg(-1)); 1124 return; 1125 } 1126 if ((scn = elf_getscn(ed->elf, 0)) == NULL) { 1127 warnx("elf_getscn failed: %s", elf_errmsg(-1)); 1128 return; 1129 } 1130 (void) elf_errno(); 1131 do { 1132 if (gelf_getshdr(scn, &sh) == NULL) { 1133 warnx("gelf_getshdr failed: %s", elf_errmsg(-1)); 1134 (void) elf_errno(); 1135 continue; 1136 } 1137 if ((name = elf_strptr(ed->elf, shstrndx, sh.sh_name)) == NULL) { 1138 (void) elf_errno(); 1139 name = "ERROR"; 1140 } 1141 if ((ndx = elf_ndxscn(scn)) == SHN_UNDEF) 1142 if ((elferr = elf_errno()) != 0) { 1143 warnx("elf_ndxscn failed: %s", 1144 elf_errmsg(elferr)); 1145 continue; 1146 } 1147 if (ndx >= ed->shnum) { 1148 warnx("section index of '%s' out of range", name); 1149 continue; 1150 } 1151 s = &ed->sl[ndx]; 1152 s->name = name; 1153 s->scn = scn; 1154 s->off = sh.sh_offset; 1155 s->sz = sh.sh_size; 1156 s->entsize = sh.sh_entsize; 1157 s->align = sh.sh_addralign; 1158 s->type = sh.sh_type; 1159 s->flags = sh.sh_flags; 1160 s->addr = sh.sh_addr; 1161 s->link = sh.sh_link; 1162 s->info = sh.sh_info; 1163 } while ((scn = elf_nextscn(ed->elf, scn)) != NULL); 1164 elferr = elf_errno(); 1165 if (elferr != 0) 1166 warnx("elf_nextscn failed: %s", elf_errmsg(elferr)); 1167 } 1168 1169 /* 1170 * Release section related resources. 1171 */ 1172 static void 1173 unload_sections(struct elfdump *ed) 1174 { 1175 if (ed->sl != NULL) { 1176 free(ed->sl); 1177 ed->sl = NULL; 1178 } 1179 } 1180 1181 /* 1182 * Add a name to the '-N' name list. 1183 */ 1184 static void 1185 add_name(struct elfdump *ed, const char *name) 1186 { 1187 struct spec_name *sn; 1188 1189 if (find_name(ed, name)) 1190 return; 1191 if ((sn = malloc(sizeof(*sn))) == NULL) { 1192 warn("malloc failed"); 1193 return; 1194 } 1195 sn->name = name; 1196 STAILQ_INSERT_TAIL(&ed->snl, sn, sn_list); 1197 } 1198 1199 /* 1200 * Lookup a name in the '-N' name list. 1201 */ 1202 static struct spec_name * 1203 find_name(struct elfdump *ed, const char *name) 1204 { 1205 struct spec_name *sn; 1206 1207 STAILQ_FOREACH(sn, &ed->snl, sn_list) { 1208 if (!strcmp(sn->name, name)) 1209 return (sn); 1210 } 1211 1212 return (NULL); 1213 } 1214 1215 /* 1216 * Retrieve the name of a symbol using the section index of the symbol 1217 * table and the index of the symbol within that table. 1218 */ 1219 static const char * 1220 get_symbol_name(struct elfdump *ed, uint32_t symtab, int i) 1221 { 1222 static char sname[64]; 1223 struct section *s; 1224 const char *name; 1225 GElf_Sym sym; 1226 Elf_Data *data; 1227 int elferr; 1228 1229 if (symtab >= ed->shnum) 1230 return (""); 1231 s = &ed->sl[symtab]; 1232 if (s->type != SHT_SYMTAB && s->type != SHT_DYNSYM) 1233 return (""); 1234 (void) elf_errno(); 1235 if ((data = elf_getdata(s->scn, NULL)) == NULL) { 1236 elferr = elf_errno(); 1237 if (elferr != 0) 1238 warnx("elf_getdata failed: %s", elf_errmsg(elferr)); 1239 return (""); 1240 } 1241 if (gelf_getsym(data, i, &sym) != &sym) 1242 return (""); 1243 if (GELF_ST_TYPE(sym.st_info) == STT_SECTION) { 1244 if (sym.st_shndx < ed->shnum) { 1245 snprintf(sname, sizeof(sname), "%s (section)", 1246 ed->sl[sym.st_shndx].name); 1247 return (sname); 1248 } else 1249 return (""); 1250 } 1251 if ((name = elf_strptr(ed->elf, s->link, sym.st_name)) == NULL) 1252 return (""); 1253 1254 return (name); 1255 } 1256 1257 /* 1258 * Retrieve a string using string table section index and the string offset. 1259 */ 1260 static const char* 1261 get_string(struct elfdump *ed, int strtab, size_t off) 1262 { 1263 const char *name; 1264 1265 if ((name = elf_strptr(ed->elf, strtab, off)) == NULL) 1266 return (""); 1267 1268 return (name); 1269 } 1270 1271 /* 1272 * Dump the ELF Executable Header. 1273 */ 1274 static void 1275 elf_print_ehdr(struct elfdump *ed) 1276 { 1277 1278 if (!STAILQ_EMPTY(&ed->snl)) 1279 return; 1280 1281 if (ed->flags & SOLARIS_FMT) { 1282 PRT("\nELF Header\n"); 1283 PRT(" ei_magic: { %#x, %c, %c, %c }\n", 1284 ed->ehdr.e_ident[0], ed->ehdr.e_ident[1], 1285 ed->ehdr.e_ident[2], ed->ehdr.e_ident[3]); 1286 PRT(" ei_class: %-18s", 1287 elf_class_str(ed->ehdr.e_ident[EI_CLASS])); 1288 PRT(" ei_data: %s\n", 1289 elf_data_str(ed->ehdr.e_ident[EI_DATA])); 1290 PRT(" e_machine: %-18s", e_machines(ed->ehdr.e_machine)); 1291 PRT(" e_version: %s\n", 1292 elf_version_str(ed->ehdr.e_version)); 1293 PRT(" e_type: %s\n", elf_type_str(ed->ehdr.e_type)); 1294 PRT(" e_flags: %18d\n", ed->ehdr.e_flags); 1295 PRT(" e_entry: %#18jx", (uintmax_t)ed->ehdr.e_entry); 1296 PRT(" e_ehsize: %6d", ed->ehdr.e_ehsize); 1297 PRT(" e_shstrndx:%5d\n", ed->ehdr.e_shstrndx); 1298 PRT(" e_shoff: %#18jx", (uintmax_t)ed->ehdr.e_shoff); 1299 PRT(" e_shentsize: %3d", ed->ehdr.e_shentsize); 1300 PRT(" e_shnum: %5d\n", ed->ehdr.e_shnum); 1301 PRT(" e_phoff: %#18jx", (uintmax_t)ed->ehdr.e_phoff); 1302 PRT(" e_phentsize: %3d", ed->ehdr.e_phentsize); 1303 PRT(" e_phnum: %5d\n", ed->ehdr.e_phnum); 1304 } else { 1305 PRT("\nelf header:\n"); 1306 PRT("\n"); 1307 PRT("\te_ident: %s %s %s\n", 1308 elf_class_str(ed->ehdr.e_ident[EI_CLASS]), 1309 elf_data_str(ed->ehdr.e_ident[EI_DATA]), 1310 ei_abis[ed->ehdr.e_ident[EI_OSABI]]); 1311 PRT("\te_type: %s\n", elf_type_str(ed->ehdr.e_type)); 1312 PRT("\te_machine: %s\n", e_machines(ed->ehdr.e_machine)); 1313 PRT("\te_version: %s\n", elf_version_str(ed->ehdr.e_version)); 1314 PRT("\te_entry: %#jx\n", (uintmax_t)ed->ehdr.e_entry); 1315 PRT("\te_phoff: %ju\n", (uintmax_t)ed->ehdr.e_phoff); 1316 PRT("\te_shoff: %ju\n", (uintmax_t) ed->ehdr.e_shoff); 1317 PRT("\te_flags: %u\n", ed->ehdr.e_flags); 1318 PRT("\te_ehsize: %u\n", ed->ehdr.e_ehsize); 1319 PRT("\te_phentsize: %u\n", ed->ehdr.e_phentsize); 1320 PRT("\te_phnum: %u\n", ed->ehdr.e_phnum); 1321 PRT("\te_shentsize: %u\n", ed->ehdr.e_shentsize); 1322 PRT("\te_shnum: %u\n", ed->ehdr.e_shnum); 1323 PRT("\te_shstrndx: %u\n", ed->ehdr.e_shstrndx); 1324 } 1325 } 1326 1327 /* 1328 * Dump the ELF Program Header Table. 1329 */ 1330 static void 1331 elf_print_phdr(struct elfdump *ed) 1332 { 1333 GElf_Phdr ph; 1334 size_t phnum, i; 1335 int header; 1336 1337 if (elf_getphnum(ed->elf, &phnum) == 0) { 1338 warnx("elf_getphnum failed: %s", elf_errmsg(-1)); 1339 return; 1340 } 1341 header = 0; 1342 for (i = 0; i < phnum; i++) { 1343 if (gelf_getphdr(ed->elf, i, &ph) != &ph) { 1344 warnx("elf_getphdr failed: %s", elf_errmsg(-1)); 1345 continue; 1346 } 1347 if (!STAILQ_EMPTY(&ed->snl) && 1348 find_name(ed, elf_phdr_type_str(ph.p_type)) == NULL) 1349 continue; 1350 if (ed->flags & SOLARIS_FMT) { 1351 PRT("\nProgram Header[%zu]:\n", i); 1352 PRT(" p_vaddr: %#-14jx", (uintmax_t)ph.p_vaddr); 1353 PRT(" p_flags: [ %s ]\n", 1354 p_flags[ph.p_flags & 0x7]); 1355 PRT(" p_paddr: %#-14jx", (uintmax_t)ph.p_paddr); 1356 PRT(" p_type: [ %s ]\n", 1357 elf_phdr_type_str(ph.p_type)); 1358 PRT(" p_filesz: %#-14jx", 1359 (uintmax_t)ph.p_filesz); 1360 PRT(" p_memsz: %#jx\n", (uintmax_t)ph.p_memsz); 1361 PRT(" p_offset: %#-14jx", 1362 (uintmax_t)ph.p_offset); 1363 PRT(" p_align: %#jx\n", (uintmax_t)ph.p_align); 1364 } else { 1365 if (!header) { 1366 PRT("\nprogram header:\n"); 1367 header = 1; 1368 } 1369 PRT("\n"); 1370 PRT("entry: %zu\n", i); 1371 PRT("\tp_type: %s\n", elf_phdr_type_str(ph.p_type)); 1372 PRT("\tp_offset: %ju\n", (uintmax_t)ph.p_offset); 1373 PRT("\tp_vaddr: %#jx\n", (uintmax_t)ph.p_vaddr); 1374 PRT("\tp_paddr: %#jx\n", (uintmax_t)ph.p_paddr); 1375 PRT("\tp_filesz: %ju\n", (uintmax_t)ph.p_filesz); 1376 PRT("\tp_memsz: %ju\n", (uintmax_t)ph.p_memsz); 1377 PRT("\tp_flags: %s\n", p_flags[ph.p_flags & 0x7]); 1378 PRT("\tp_align: %ju\n", (uintmax_t)ph.p_align); 1379 } 1380 } 1381 } 1382 1383 /* 1384 * Dump the ELF Section Header Table. 1385 */ 1386 static void 1387 elf_print_shdr(struct elfdump *ed) 1388 { 1389 struct section *s; 1390 size_t i; 1391 1392 if (!STAILQ_EMPTY(&ed->snl)) 1393 return; 1394 1395 if ((ed->flags & SOLARIS_FMT) == 0) 1396 PRT("\nsection header:\n"); 1397 for (i = 0; i < ed->shnum; i++) { 1398 s = &ed->sl[i]; 1399 if (ed->flags & SOLARIS_FMT) { 1400 if (i == 0) 1401 continue; 1402 PRT("\nSection Header[%zu]:", i); 1403 PRT(" sh_name: %s\n", s->name); 1404 PRT(" sh_addr: %#-14jx", (uintmax_t)s->addr); 1405 if (s->flags != 0) 1406 PRT(" sh_flags: [ %s ]\n", sh_flags(s->flags)); 1407 else 1408 PRT(" sh_flags: 0\n"); 1409 PRT(" sh_size: %#-14jx", (uintmax_t)s->sz); 1410 PRT(" sh_type: [ %s ]\n", 1411 sh_types(ed->ehdr.e_machine, s->type)); 1412 PRT(" sh_offset: %#-14jx", (uintmax_t)s->off); 1413 PRT(" sh_entsize: %#jx\n", (uintmax_t)s->entsize); 1414 PRT(" sh_link: %-14u", s->link); 1415 PRT(" sh_info: %u\n", s->info); 1416 PRT(" sh_addralign: %#jx\n", (uintmax_t)s->align); 1417 } else { 1418 PRT("\n"); 1419 PRT("entry: %ju\n", (uintmax_t)i); 1420 PRT("\tsh_name: %s\n", s->name); 1421 PRT("\tsh_type: %s\n", 1422 sh_types(ed->ehdr.e_machine, s->type)); 1423 PRT("\tsh_flags: %s\n", sh_flags(s->flags)); 1424 PRT("\tsh_addr: %#jx\n", (uintmax_t)s->addr); 1425 PRT("\tsh_offset: %ju\n", (uintmax_t)s->off); 1426 PRT("\tsh_size: %ju\n", (uintmax_t)s->sz); 1427 PRT("\tsh_link: %u\n", s->link); 1428 PRT("\tsh_info: %u\n", s->info); 1429 PRT("\tsh_addralign: %ju\n", (uintmax_t)s->align); 1430 PRT("\tsh_entsize: %ju\n", (uintmax_t)s->entsize); 1431 } 1432 } 1433 } 1434 1435 /* 1436 * Return number of entries in the given section. We'd prefer ent_count be a 1437 * size_t, but libelf APIs already use int for section indices. 1438 */ 1439 static int 1440 get_ent_count(const struct section *s, int *ent_count) 1441 { 1442 if (s->entsize == 0) { 1443 warnx("section %s has entry size 0", s->name); 1444 return (0); 1445 } else if (s->sz / s->entsize > INT_MAX) { 1446 warnx("section %s has invalid section count", s->name); 1447 return (0); 1448 } 1449 *ent_count = (int)(s->sz / s->entsize); 1450 return (1); 1451 } 1452 1453 /* 1454 * Retrieve the content of the corresponding SHT_SUNW_versym section for 1455 * a symbol table section. 1456 */ 1457 static void 1458 get_versym(struct elfdump *ed, int i, uint16_t **vs, int *nvs) 1459 { 1460 struct section *s; 1461 Elf_Data *data; 1462 size_t j; 1463 int elferr; 1464 1465 s = NULL; 1466 for (j = 0; j < ed->shnum; j++) { 1467 s = &ed->sl[j]; 1468 if (s->type == SHT_SUNW_versym && s->link == (uint32_t)i) 1469 break; 1470 } 1471 if (j >= ed->shnum) { 1472 *vs = NULL; 1473 return; 1474 } 1475 (void) elf_errno(); 1476 if ((data = elf_getdata(s->scn, NULL)) == NULL) { 1477 elferr = elf_errno(); 1478 if (elferr != 0) 1479 warnx("elf_getdata failed: %s", elf_errmsg(elferr)); 1480 *vs = NULL; 1481 return; 1482 } 1483 1484 *vs = data->d_buf; 1485 assert(data->d_size == s->sz); 1486 if (!get_ent_count(s, nvs)) 1487 *nvs = 0; 1488 } 1489 1490 /* 1491 * Dump the symbol table section. 1492 */ 1493 static void 1494 elf_print_symtab(struct elfdump *ed, int i) 1495 { 1496 struct section *s; 1497 const char *name; 1498 uint16_t *vs; 1499 char idx[10]; 1500 Elf_Data *data; 1501 GElf_Sym sym; 1502 int len, j, elferr, nvs; 1503 1504 s = &ed->sl[i]; 1505 if (ed->flags & SOLARIS_FMT) 1506 PRT("\nSymbol Table Section: %s\n", s->name); 1507 else 1508 PRT("\nsymbol table (%s):\n", s->name); 1509 (void) elf_errno(); 1510 if ((data = elf_getdata(s->scn, NULL)) == NULL) { 1511 elferr = elf_errno(); 1512 if (elferr != 0) 1513 warnx("elf_getdata failed: %s", elf_errmsg(elferr)); 1514 return; 1515 } 1516 vs = NULL; 1517 nvs = 0; 1518 assert(data->d_size == s->sz); 1519 if (!get_ent_count(s, &len)) 1520 return; 1521 if (ed->flags & SOLARIS_FMT) { 1522 if (ed->ec == ELFCLASS32) 1523 PRT(" index value "); 1524 else 1525 PRT(" index value "); 1526 PRT("size type bind oth ver shndx name\n"); 1527 get_versym(ed, i, &vs, &nvs); 1528 if (vs != NULL && nvs != len) { 1529 warnx("#symbol not equal to #versym"); 1530 vs = NULL; 1531 } 1532 } 1533 for (j = 0; j < len; j++) { 1534 if (gelf_getsym(data, j, &sym) != &sym) { 1535 warnx("gelf_getsym failed: %s", elf_errmsg(-1)); 1536 continue; 1537 } 1538 name = get_string(ed, s->link, sym.st_name); 1539 if (ed->flags & SOLARIS_FMT) { 1540 snprintf(idx, sizeof(idx), "[%d]", j); 1541 if (ed->ec == ELFCLASS32) 1542 PRT("%10s ", idx); 1543 else 1544 PRT("%10s ", idx); 1545 PRT("0x%8.8jx ", (uintmax_t)sym.st_value); 1546 if (ed->ec == ELFCLASS32) 1547 PRT("0x%8.8jx ", (uintmax_t)sym.st_size); 1548 else 1549 PRT("0x%12.12jx ", (uintmax_t)sym.st_size); 1550 PRT("%s ", st_type_S(GELF_ST_TYPE(sym.st_info))); 1551 PRT("%s ", st_bindings_S(GELF_ST_BIND(sym.st_info))); 1552 PRT("%c ", st_others[sym.st_other]); 1553 PRT("%3u ", (vs == NULL ? 0 : vs[j])); 1554 PRT("%-11.11s ", sh_name(ed, sym.st_shndx)); 1555 PRT("%s\n", name); 1556 } else { 1557 PRT("\nentry: %d\n", j); 1558 PRT("\tst_name: %s\n", name); 1559 PRT("\tst_value: %#jx\n", (uintmax_t)sym.st_value); 1560 PRT("\tst_size: %ju\n", (uintmax_t)sym.st_size); 1561 PRT("\tst_info: %s %s\n", 1562 st_type(ed->ehdr.e_machine, 1563 GELF_ST_TYPE(sym.st_info)), 1564 st_bindings(GELF_ST_BIND(sym.st_info))); 1565 PRT("\tst_shndx: %ju\n", (uintmax_t)sym.st_shndx); 1566 } 1567 } 1568 } 1569 1570 /* 1571 * Dump the symbol tables. (.dynsym and .symtab) 1572 */ 1573 static void 1574 elf_print_symtabs(struct elfdump *ed) 1575 { 1576 size_t i; 1577 1578 for (i = 0; i < ed->shnum; i++) 1579 if ((ed->sl[i].type == SHT_SYMTAB || 1580 ed->sl[i].type == SHT_DYNSYM) && 1581 (STAILQ_EMPTY(&ed->snl) || find_name(ed, ed->sl[i].name))) 1582 elf_print_symtab(ed, i); 1583 } 1584 1585 /* 1586 * Dump the content of .dynamic section. 1587 */ 1588 static void 1589 elf_print_dynamic(struct elfdump *ed) 1590 { 1591 struct section *s; 1592 const char *name; 1593 char idx[10]; 1594 Elf_Data *data; 1595 GElf_Dyn dyn; 1596 int elferr, i, len; 1597 1598 s = NULL; 1599 for (i = 0; (size_t)i < ed->shnum; i++) { 1600 s = &ed->sl[i]; 1601 if (s->type == SHT_DYNAMIC && 1602 (STAILQ_EMPTY(&ed->snl) || find_name(ed, s->name))) 1603 break; 1604 } 1605 if ((size_t)i >= ed->shnum) 1606 return; 1607 1608 if (ed->flags & SOLARIS_FMT) { 1609 PRT("Dynamic Section: %s\n", s->name); 1610 PRT(" index tag value\n"); 1611 } else 1612 PRT("\ndynamic:\n"); 1613 (void) elf_errno(); 1614 if ((data = elf_getdata(s->scn, NULL)) == NULL) { 1615 elferr = elf_errno(); 1616 if (elferr != 0) 1617 warnx("elf_getdata failed: %s", elf_errmsg(elferr)); 1618 return; 1619 } 1620 assert(data->d_size == s->sz); 1621 if (!get_ent_count(s, &len)) 1622 return; 1623 for (i = 0; i < len; i++) { 1624 if (gelf_getdyn(data, i, &dyn) != &dyn) { 1625 warnx("gelf_getdyn failed: %s", elf_errmsg(-1)); 1626 continue; 1627 } 1628 1629 if (ed->flags & SOLARIS_FMT) { 1630 snprintf(idx, sizeof(idx), "[%d]", i); 1631 PRT("%10s %-16s ", idx, d_tags(dyn.d_tag)); 1632 } else { 1633 PRT("\n"); 1634 PRT("entry: %d\n", i); 1635 PRT("\td_tag: %s\n", d_tags(dyn.d_tag)); 1636 } 1637 switch(dyn.d_tag) { 1638 case DT_NEEDED: 1639 case DT_SONAME: 1640 case DT_RPATH: 1641 case DT_RUNPATH: 1642 if ((name = elf_strptr(ed->elf, s->link, 1643 dyn.d_un.d_val)) == NULL) 1644 name = ""; 1645 if (ed->flags & SOLARIS_FMT) 1646 PRT("%#-16jx %s\n", (uintmax_t)dyn.d_un.d_val, 1647 name); 1648 else 1649 PRT("\td_val: %s\n", name); 1650 break; 1651 case DT_PLTRELSZ: 1652 case DT_RELA: 1653 case DT_RELASZ: 1654 case DT_RELAENT: 1655 case DT_RELACOUNT: 1656 case DT_STRSZ: 1657 case DT_SYMENT: 1658 case DT_RELSZ: 1659 case DT_RELENT: 1660 case DT_PLTREL: 1661 case DT_VERDEF: 1662 case DT_VERDEFNUM: 1663 case DT_VERNEED: 1664 case DT_VERNEEDNUM: 1665 case DT_VERSYM: 1666 if (ed->flags & SOLARIS_FMT) 1667 PRT("%#jx\n", (uintmax_t)dyn.d_un.d_val); 1668 else 1669 PRT("\td_val: %ju\n", 1670 (uintmax_t)dyn.d_un.d_val); 1671 break; 1672 case DT_PLTGOT: 1673 case DT_HASH: 1674 case DT_GNU_HASH: 1675 case DT_STRTAB: 1676 case DT_SYMTAB: 1677 case DT_INIT: 1678 case DT_FINI: 1679 case DT_REL: 1680 case DT_JMPREL: 1681 case DT_DEBUG: 1682 if (ed->flags & SOLARIS_FMT) 1683 PRT("%#jx\n", (uintmax_t)dyn.d_un.d_ptr); 1684 else 1685 PRT("\td_ptr: %#jx\n", 1686 (uintmax_t)dyn.d_un.d_ptr); 1687 break; 1688 case DT_NULL: 1689 case DT_SYMBOLIC: 1690 case DT_TEXTREL: 1691 default: 1692 if (ed->flags & SOLARIS_FMT) 1693 PRT("\n"); 1694 break; 1695 } 1696 } 1697 } 1698 1699 /* 1700 * Dump a .rel/.rela section entry. 1701 */ 1702 static void 1703 elf_print_rel_entry(struct elfdump *ed, struct section *s, int j, 1704 struct rel_entry *r) 1705 { 1706 1707 if (ed->flags & SOLARIS_FMT) { 1708 PRT(" %-23s ", elftc_reloc_type_str(ed->ehdr.e_machine, 1709 GELF_R_TYPE(r->u_r.rel.r_info))); 1710 PRT("%#12jx ", (uintmax_t)r->u_r.rel.r_offset); 1711 if (r->type == SHT_RELA) 1712 PRT("%10jd ", (intmax_t)r->u_r.rela.r_addend); 1713 else 1714 PRT(" "); 1715 PRT("%-14s ", s->name); 1716 PRT("%s\n", r->symn); 1717 } else { 1718 PRT("\n"); 1719 PRT("entry: %d\n", j); 1720 PRT("\tr_offset: %#jx\n", (uintmax_t)r->u_r.rel.r_offset); 1721 if (ed->ec == ELFCLASS32) 1722 PRT("\tr_info: %#jx\n", (uintmax_t) 1723 ELF32_R_INFO(ELF64_R_SYM(r->u_r.rel.r_info), 1724 ELF64_R_TYPE(r->u_r.rel.r_info))); 1725 else 1726 PRT("\tr_info: %#jx\n", (uintmax_t)r->u_r.rel.r_info); 1727 if (r->type == SHT_RELA) 1728 PRT("\tr_addend: %jd\n", 1729 (intmax_t)r->u_r.rela.r_addend); 1730 } 1731 } 1732 1733 /* 1734 * Dump a relocation section of type SHT_RELA. 1735 */ 1736 static void 1737 elf_print_rela(struct elfdump *ed, struct section *s, Elf_Data *data) 1738 { 1739 struct rel_entry r; 1740 int j, len; 1741 1742 if (ed->flags & SOLARIS_FMT) { 1743 PRT("\nRelocation Section: %s\n", s->name); 1744 PRT(" type offset " 1745 "addend section with respect to\n"); 1746 } else 1747 PRT("\nrelocation with addend (%s):\n", s->name); 1748 r.type = SHT_RELA; 1749 assert(data->d_size == s->sz); 1750 if (!get_ent_count(s, &len)) 1751 return; 1752 for (j = 0; j < len; j++) { 1753 if (gelf_getrela(data, j, &r.u_r.rela) != &r.u_r.rela) { 1754 warnx("gelf_getrela failed: %s", 1755 elf_errmsg(-1)); 1756 continue; 1757 } 1758 r.symn = get_symbol_name(ed, s->link, 1759 GELF_R_SYM(r.u_r.rela.r_info)); 1760 elf_print_rel_entry(ed, s, j, &r); 1761 } 1762 } 1763 1764 /* 1765 * Dump a relocation section of type SHT_REL. 1766 */ 1767 static void 1768 elf_print_rel(struct elfdump *ed, struct section *s, Elf_Data *data) 1769 { 1770 struct rel_entry r; 1771 int j, len; 1772 1773 if (ed->flags & SOLARIS_FMT) { 1774 PRT("\nRelocation Section: %s\n", s->name); 1775 PRT(" type offset " 1776 "section with respect to\n"); 1777 } else 1778 PRT("\nrelocation (%s):\n", s->name); 1779 r.type = SHT_REL; 1780 assert(data->d_size == s->sz); 1781 if (!get_ent_count(s, &len)) 1782 return; 1783 for (j = 0; j < len; j++) { 1784 if (gelf_getrel(data, j, &r.u_r.rel) != &r.u_r.rel) { 1785 warnx("gelf_getrel failed: %s", elf_errmsg(-1)); 1786 continue; 1787 } 1788 r.symn = get_symbol_name(ed, s->link, 1789 GELF_R_SYM(r.u_r.rel.r_info)); 1790 elf_print_rel_entry(ed, s, j, &r); 1791 } 1792 } 1793 1794 /* 1795 * Dump relocation sections. 1796 */ 1797 static void 1798 elf_print_reloc(struct elfdump *ed) 1799 { 1800 struct section *s; 1801 Elf_Data *data; 1802 size_t i; 1803 int elferr; 1804 1805 for (i = 0; i < ed->shnum; i++) { 1806 s = &ed->sl[i]; 1807 if ((s->type == SHT_REL || s->type == SHT_RELA) && 1808 (STAILQ_EMPTY(&ed->snl) || find_name(ed, s->name))) { 1809 (void) elf_errno(); 1810 if ((data = elf_getdata(s->scn, NULL)) == NULL) { 1811 elferr = elf_errno(); 1812 if (elferr != 0) 1813 warnx("elf_getdata failed: %s", 1814 elf_errmsg(elferr)); 1815 continue; 1816 } 1817 if (s->type == SHT_REL) 1818 elf_print_rel(ed, s, data); 1819 else 1820 elf_print_rela(ed, s, data); 1821 } 1822 } 1823 } 1824 1825 /* 1826 * Dump the content of PT_INTERP segment. 1827 */ 1828 static void 1829 elf_print_interp(struct elfdump *ed) 1830 { 1831 const char *s; 1832 GElf_Phdr phdr; 1833 size_t filesize, i, phnum; 1834 1835 if (!STAILQ_EMPTY(&ed->snl) && find_name(ed, "PT_INTERP") == NULL) 1836 return; 1837 1838 if ((s = elf_rawfile(ed->elf, &filesize)) == NULL) { 1839 warnx("elf_rawfile failed: %s", elf_errmsg(-1)); 1840 return; 1841 } 1842 if (!elf_getphnum(ed->elf, &phnum)) { 1843 warnx("elf_getphnum failed: %s", elf_errmsg(-1)); 1844 return; 1845 } 1846 for (i = 0; i < phnum; i++) { 1847 if (gelf_getphdr(ed->elf, i, &phdr) != &phdr) { 1848 warnx("elf_getphdr failed: %s", elf_errmsg(-1)); 1849 continue; 1850 } 1851 if (phdr.p_type == PT_INTERP) { 1852 if (phdr.p_offset >= filesize) { 1853 warnx("invalid phdr offset"); 1854 continue; 1855 } 1856 PRT("\ninterp:\n"); 1857 PRT("\t%s\n", s + phdr.p_offset); 1858 } 1859 } 1860 } 1861 1862 /* 1863 * Search the relocation sections for entries referring to the .got section. 1864 */ 1865 static void 1866 find_gotrel(struct elfdump *ed, struct section *gs, struct rel_entry *got) 1867 { 1868 struct section *s; 1869 struct rel_entry r; 1870 Elf_Data *data; 1871 size_t i; 1872 int elferr, j, k, len; 1873 1874 for(i = 0; i < ed->shnum; i++) { 1875 s = &ed->sl[i]; 1876 if (s->type != SHT_REL && s->type != SHT_RELA) 1877 continue; 1878 (void) elf_errno(); 1879 if ((data = elf_getdata(s->scn, NULL)) == NULL) { 1880 elferr = elf_errno(); 1881 if (elferr != 0) 1882 warnx("elf_getdata failed: %s", 1883 elf_errmsg(elferr)); 1884 return; 1885 } 1886 memset(&r, 0, sizeof(struct rel_entry)); 1887 r.type = s->type; 1888 assert(data->d_size == s->sz); 1889 if (!get_ent_count(s, &len)) 1890 return; 1891 for (j = 0; j < len; j++) { 1892 if (s->type == SHT_REL) { 1893 if (gelf_getrel(data, j, &r.u_r.rel) != 1894 &r.u_r.rel) { 1895 warnx("gelf_getrel failed: %s", 1896 elf_errmsg(-1)); 1897 continue; 1898 } 1899 } else { 1900 if (gelf_getrela(data, j, &r.u_r.rela) != 1901 &r.u_r.rela) { 1902 warnx("gelf_getrel failed: %s", 1903 elf_errmsg(-1)); 1904 continue; 1905 } 1906 } 1907 if (r.u_r.rel.r_offset >= gs->addr && 1908 r.u_r.rel.r_offset < gs->addr + gs->sz) { 1909 r.symn = get_symbol_name(ed, s->link, 1910 GELF_R_SYM(r.u_r.rel.r_info)); 1911 k = (r.u_r.rel.r_offset - gs->addr) / 1912 gs->entsize; 1913 memcpy(&got[k], &r, sizeof(struct rel_entry)); 1914 } 1915 } 1916 } 1917 } 1918 1919 static void 1920 elf_print_got_section(struct elfdump *ed, struct section *s) 1921 { 1922 struct rel_entry *got; 1923 Elf_Data *data, dst; 1924 int elferr, i, len; 1925 1926 if (s->entsize == 0) { 1927 /* XXX IA64 GOT section generated by gcc has entry size 0. */ 1928 if (s->align != 0) 1929 s->entsize = s->align; 1930 else 1931 return; 1932 } 1933 1934 if (!get_ent_count(s, &len)) 1935 return; 1936 if (ed->flags & SOLARIS_FMT) 1937 PRT("\nGlobal Offset Table Section: %s (%d entries)\n", 1938 s->name, len); 1939 else 1940 PRT("\nglobal offset table: %s\n", s->name); 1941 (void) elf_errno(); 1942 if ((data = elf_getdata(s->scn, NULL)) == NULL) { 1943 elferr = elf_errno(); 1944 if (elferr != 0) 1945 warnx("elf_getdata failed: %s", elf_errmsg(elferr)); 1946 return; 1947 } 1948 1949 /* 1950 * GOT section has section type SHT_PROGBITS, thus libelf treats it as 1951 * byte stream and will not perform any translation on it. As a result, 1952 * an exlicit call to gelf_xlatetom is needed here. Depends on arch, 1953 * GOT section should be translated to either WORD or XWORD. 1954 */ 1955 if (ed->ec == ELFCLASS32) 1956 data->d_type = ELF_T_WORD; 1957 else 1958 data->d_type = ELF_T_XWORD; 1959 memcpy(&dst, data, sizeof(Elf_Data)); 1960 if (gelf_xlatetom(ed->elf, &dst, data, ed->ehdr.e_ident[EI_DATA]) != 1961 &dst) { 1962 warnx("gelf_xlatetom failed: %s", elf_errmsg(-1)); 1963 return; 1964 } 1965 assert(dst.d_size == s->sz); 1966 if (ed->flags & SOLARIS_FMT) { 1967 /* 1968 * In verbose/Solaris mode, we search the relocation sections 1969 * and try to find the corresponding reloc entry for each GOT 1970 * section entry. 1971 */ 1972 if ((got = calloc(len, sizeof(struct rel_entry))) == NULL) 1973 err(EXIT_FAILURE, "calloc failed"); 1974 find_gotrel(ed, s, got); 1975 if (ed->ec == ELFCLASS32) { 1976 PRT(" ndx addr value reloc "); 1977 PRT("addend symbol\n"); 1978 } else { 1979 PRT(" ndx addr value "); 1980 PRT("reloc addend symbol\n"); 1981 } 1982 for(i = 0; i < len; i++) { 1983 PRT("[%5.5d] ", i); 1984 if (ed->ec == ELFCLASS32) { 1985 PRT("%-8.8jx ", 1986 (uintmax_t) (s->addr + i * s->entsize)); 1987 PRT("%-8.8x ", *((uint32_t *)dst.d_buf + i)); 1988 } else { 1989 PRT("%-16.16jx ", 1990 (uintmax_t) (s->addr + i * s->entsize)); 1991 PRT("%-16.16jx ", 1992 (uintmax_t) *((uint64_t *)dst.d_buf + i)); 1993 } 1994 PRT("%-18s ", elftc_reloc_type_str(ed->ehdr.e_machine, 1995 GELF_R_TYPE(got[i].u_r.rel.r_info))); 1996 if (ed->ec == ELFCLASS32) 1997 PRT("%-8.8jd ", 1998 (intmax_t)got[i].u_r.rela.r_addend); 1999 else 2000 PRT("%-12.12jd ", 2001 (intmax_t)got[i].u_r.rela.r_addend); 2002 if (got[i].symn == NULL) 2003 got[i].symn = ""; 2004 PRT("%s\n", got[i].symn); 2005 } 2006 free(got); 2007 } else { 2008 for(i = 0; i < len; i++) { 2009 PRT("\nentry: %d\n", i); 2010 if (ed->ec == ELFCLASS32) 2011 PRT("\t%#x\n", *((uint32_t *)dst.d_buf + i)); 2012 else 2013 PRT("\t%#jx\n", 2014 (uintmax_t) *((uint64_t *)dst.d_buf + i)); 2015 } 2016 } 2017 } 2018 2019 /* 2020 * Dump the content of Global Offset Table section. 2021 */ 2022 static void 2023 elf_print_got(struct elfdump *ed) 2024 { 2025 struct section *s; 2026 size_t i; 2027 2028 if (!STAILQ_EMPTY(&ed->snl)) 2029 return; 2030 2031 s = NULL; 2032 for (i = 0; i < ed->shnum; i++) { 2033 s = &ed->sl[i]; 2034 if (s->name && !strncmp(s->name, ".got", 4) && 2035 (STAILQ_EMPTY(&ed->snl) || find_name(ed, s->name))) 2036 elf_print_got_section(ed, s); 2037 } 2038 } 2039 2040 /* 2041 * Dump the content of .note.ABI-tag section. 2042 */ 2043 static void 2044 elf_print_note(struct elfdump *ed) 2045 { 2046 struct section *s; 2047 Elf_Data *data; 2048 Elf_Note *en; 2049 uint32_t namesz; 2050 uint32_t descsz; 2051 uint32_t desc; 2052 size_t count; 2053 int elferr, i; 2054 uint8_t *src; 2055 char idx[10]; 2056 2057 s = NULL; 2058 for (i = 0; (size_t)i < ed->shnum; i++) { 2059 s = &ed->sl[i]; 2060 if (s->type == SHT_NOTE && s->name && 2061 !strcmp(s->name, ".note.ABI-tag") && 2062 (STAILQ_EMPTY(&ed->snl) || find_name(ed, s->name))) 2063 break; 2064 } 2065 if ((size_t)i >= ed->shnum) 2066 return; 2067 if (ed->flags & SOLARIS_FMT) 2068 PRT("\nNote Section: %s\n", s->name); 2069 else 2070 PRT("\nnote (%s):\n", s->name); 2071 (void) elf_errno(); 2072 if ((data = elf_getdata(s->scn, NULL)) == NULL) { 2073 elferr = elf_errno(); 2074 if (elferr != 0) 2075 warnx("elf_getdata failed: %s", elf_errmsg(elferr)); 2076 return; 2077 } 2078 src = data->d_buf; 2079 count = data->d_size; 2080 while (count > sizeof(Elf_Note)) { 2081 en = (Elf_Note *) (uintptr_t) src; 2082 namesz = en->n_namesz; 2083 descsz = en->n_descsz; 2084 src += sizeof(Elf_Note); 2085 count -= sizeof(Elf_Note); 2086 if (roundup2(namesz, 4) + roundup2(descsz, 4) > count) { 2087 warnx("truncated note section"); 2088 return; 2089 } 2090 if (ed->flags & SOLARIS_FMT) { 2091 PRT("\n type %#x\n", en->n_type); 2092 PRT(" namesz %#x:\n", en->n_namesz); 2093 PRT("%s\n", src); 2094 } else 2095 PRT("\t%s ", src); 2096 src += roundup2(namesz, 4); 2097 count -= roundup2(namesz, 4); 2098 2099 /* 2100 * Note that we dump the whole desc part if we're in 2101 * "Solaris mode", while in the normal mode, we only look 2102 * at the first 4 bytes (a 32bit word) of the desc, i.e, 2103 * we assume that it's always a FreeBSD version number. 2104 */ 2105 if (ed->flags & SOLARIS_FMT) { 2106 PRT(" descsz %#x:", en->n_descsz); 2107 for (i = 0; (uint32_t)i < descsz; i++) { 2108 if ((i & 0xF) == 0) { 2109 snprintf(idx, sizeof(idx), "desc[%d]", 2110 i); 2111 PRT("\n %-9s", idx); 2112 } else if ((i & 0x3) == 0) 2113 PRT(" "); 2114 PRT(" %2.2x", src[i]); 2115 } 2116 PRT("\n"); 2117 } else { 2118 if (ed->ehdr.e_ident[EI_DATA] == ELFDATA2MSB) 2119 desc = be32dec(src); 2120 else 2121 desc = le32dec(src); 2122 PRT("%d\n", desc); 2123 } 2124 src += roundup2(descsz, 4); 2125 count -= roundup2(descsz, 4); 2126 } 2127 } 2128 2129 /* 2130 * Dump a hash table. 2131 */ 2132 static void 2133 elf_print_svr4_hash(struct elfdump *ed, struct section *s) 2134 { 2135 Elf_Data *data; 2136 uint32_t *buf; 2137 uint32_t *bucket, *chain; 2138 uint32_t nbucket, nchain; 2139 uint32_t *bl, *c, maxl, total; 2140 uint32_t i, j; 2141 int first, elferr; 2142 char idx[10]; 2143 2144 if (ed->flags & SOLARIS_FMT) 2145 PRT("\nHash Section: %s\n", s->name); 2146 else 2147 PRT("\nhash table (%s):\n", s->name); 2148 (void) elf_errno(); 2149 if ((data = elf_getdata(s->scn, NULL)) == NULL) { 2150 elferr = elf_errno(); 2151 if (elferr != 0) 2152 warnx("elf_getdata failed: %s", 2153 elf_errmsg(elferr)); 2154 return; 2155 } 2156 if (data->d_size < 2 * sizeof(uint32_t)) { 2157 warnx(".hash section too small"); 2158 return; 2159 } 2160 buf = data->d_buf; 2161 nbucket = buf[0]; 2162 nchain = buf[1]; 2163 if (nbucket <= 0 || nchain <= 0) { 2164 warnx("Malformed .hash section"); 2165 return; 2166 } 2167 if (data->d_size != 2168 ((uint64_t)nbucket + (uint64_t)nchain + 2) * sizeof(uint32_t)) { 2169 warnx("Malformed .hash section"); 2170 return; 2171 } 2172 bucket = &buf[2]; 2173 chain = &buf[2 + nbucket]; 2174 2175 if (ed->flags & SOLARIS_FMT) { 2176 maxl = 0; 2177 if ((bl = calloc(nbucket, sizeof(*bl))) == NULL) 2178 err(EXIT_FAILURE, "calloc failed"); 2179 for (i = 0; i < nbucket; i++) 2180 for (j = bucket[i]; j > 0 && j < nchain; j = chain[j]) 2181 if (++bl[i] > maxl) 2182 maxl = bl[i]; 2183 if ((c = calloc(maxl + 1, sizeof(*c))) == NULL) 2184 err(EXIT_FAILURE, "calloc failed"); 2185 for (i = 0; i < nbucket; i++) 2186 c[bl[i]]++; 2187 PRT(" bucket symndx name\n"); 2188 for (i = 0; i < nbucket; i++) { 2189 first = 1; 2190 for (j = bucket[i]; j > 0 && j < nchain; j = chain[j]) { 2191 if (first) { 2192 PRT("%10d ", i); 2193 first = 0; 2194 } else 2195 PRT(" "); 2196 snprintf(idx, sizeof(idx), "[%d]", j); 2197 PRT("%-10s ", idx); 2198 PRT("%s\n", get_symbol_name(ed, s->link, j)); 2199 } 2200 } 2201 PRT("\n"); 2202 total = 0; 2203 for (i = 0; i <= maxl; i++) { 2204 total += c[i] * i; 2205 PRT("%10u buckets contain %8d symbols\n", c[i], i); 2206 } 2207 PRT("%10u buckets %8u symbols (globals)\n", nbucket, 2208 total); 2209 } else { 2210 PRT("\nnbucket: %u\n", nbucket); 2211 PRT("nchain: %u\n\n", nchain); 2212 for (i = 0; i < nbucket; i++) 2213 PRT("bucket[%d]:\n\t%u\n\n", i, bucket[i]); 2214 for (i = 0; i < nchain; i++) 2215 PRT("chain[%d]:\n\t%u\n\n", i, chain[i]); 2216 } 2217 } 2218 2219 /* 2220 * Dump a 64bit hash table. 2221 */ 2222 static void 2223 elf_print_svr4_hash64(struct elfdump *ed, struct section *s) 2224 { 2225 Elf_Data *data, dst; 2226 uint64_t *buf; 2227 uint64_t *bucket, *chain; 2228 uint64_t nbucket, nchain; 2229 uint64_t *bl, *c, maxl, total; 2230 uint64_t i, j; 2231 int elferr, first; 2232 char idx[10]; 2233 2234 if (ed->flags & SOLARIS_FMT) 2235 PRT("\nHash Section: %s\n", s->name); 2236 else 2237 PRT("\nhash table (%s):\n", s->name); 2238 2239 /* 2240 * ALPHA uses 64-bit hash entries. Since libelf assumes that 2241 * .hash section contains only 32-bit entry, an explicit 2242 * gelf_xlatetom is needed here. 2243 */ 2244 (void) elf_errno(); 2245 if ((data = elf_rawdata(s->scn, NULL)) == NULL) { 2246 elferr = elf_errno(); 2247 if (elferr != 0) 2248 warnx("elf_rawdata failed: %s", 2249 elf_errmsg(elferr)); 2250 return; 2251 } 2252 data->d_type = ELF_T_XWORD; 2253 memcpy(&dst, data, sizeof(Elf_Data)); 2254 if (gelf_xlatetom(ed->elf, &dst, data, 2255 ed->ehdr.e_ident[EI_DATA]) != &dst) { 2256 warnx("gelf_xlatetom failed: %s", elf_errmsg(-1)); 2257 return; 2258 } 2259 if (dst.d_size < 2 * sizeof(uint64_t)) { 2260 warnx(".hash section too small"); 2261 return; 2262 } 2263 buf = dst.d_buf; 2264 nbucket = buf[0]; 2265 nchain = buf[1]; 2266 if (nbucket <= 0 || nchain <= 0) { 2267 warnx("Malformed .hash section"); 2268 return; 2269 } 2270 if (dst.d_size != (nbucket + nchain + 2) * sizeof(uint64_t)) { 2271 warnx("Malformed .hash section"); 2272 return; 2273 } 2274 bucket = &buf[2]; 2275 chain = &buf[2 + nbucket]; 2276 2277 if (ed->flags & SOLARIS_FMT) { 2278 maxl = 0; 2279 if ((bl = calloc(nbucket, sizeof(*bl))) == NULL) 2280 err(EXIT_FAILURE, "calloc failed"); 2281 for (i = 0; i < nbucket; i++) 2282 for (j = bucket[i]; j > 0 && j < nchain; j = chain[j]) 2283 if (++bl[i] > maxl) 2284 maxl = bl[i]; 2285 if ((c = calloc(maxl + 1, sizeof(*c))) == NULL) 2286 err(EXIT_FAILURE, "calloc failed"); 2287 for (i = 0; i < nbucket; i++) 2288 c[bl[i]]++; 2289 PRT(" bucket symndx name\n"); 2290 for (i = 0; i < nbucket; i++) { 2291 first = 1; 2292 for (j = bucket[i]; j > 0 && j < nchain; j = chain[j]) { 2293 if (first) { 2294 PRT("%10zu ", i); 2295 first = 0; 2296 } else 2297 PRT(" "); 2298 snprintf(idx, sizeof(idx), "[%zu]", (size_t)j); 2299 PRT("%-10s ", idx); 2300 PRT("%s\n", get_symbol_name(ed, s->link, j)); 2301 } 2302 } 2303 PRT("\n"); 2304 total = 0; 2305 for (i = 0; i <= maxl; i++) { 2306 total += c[i] * i; 2307 PRT("%10ju buckets contain %8zu symbols\n", 2308 (uintmax_t)c[i], i); 2309 } 2310 PRT("%10ju buckets %8ju symbols (globals)\n", 2311 (uintmax_t)nbucket, (uintmax_t)total); 2312 } else { 2313 PRT("\nnbucket: %ju\n", (uintmax_t)nbucket); 2314 PRT("nchain: %ju\n\n", (uintmax_t)nchain); 2315 for (i = 0; i < nbucket; i++) 2316 PRT("bucket[%zu]:\n\t%ju\n\n", i, (uintmax_t)bucket[i]); 2317 for (i = 0; i < nchain; i++) 2318 PRT("chain[%zu]:\n\t%ju\n\n", i, (uintmax_t)chain[i]); 2319 } 2320 2321 } 2322 2323 /* 2324 * Dump a GNU hash table. 2325 */ 2326 static void 2327 elf_print_gnu_hash(struct elfdump *ed, struct section *s) 2328 { 2329 struct section *ds; 2330 Elf_Data *data; 2331 uint32_t *buf; 2332 uint32_t *bucket, *chain; 2333 uint32_t nbucket, nchain, symndx, maskwords, shift2; 2334 uint32_t *bl, *c, maxl, total; 2335 uint32_t i, j; 2336 int first, elferr, dynsymcount; 2337 char idx[10]; 2338 2339 if (ed->flags & SOLARIS_FMT) 2340 PRT("\nGNU Hash Section: %s\n", s->name); 2341 else 2342 PRT("\ngnu hash table (%s):\n", s->name); 2343 (void) elf_errno(); 2344 if ((data = elf_getdata(s->scn, NULL)) == NULL) { 2345 elferr = elf_errno(); 2346 if (elferr != 0) 2347 warnx("elf_getdata failed: %s", 2348 elf_errmsg(elferr)); 2349 return; 2350 } 2351 if (data->d_size < 4 * sizeof(uint32_t)) { 2352 warnx(".gnu.hash section too small"); 2353 return; 2354 } 2355 buf = data->d_buf; 2356 nbucket = buf[0]; 2357 symndx = buf[1]; 2358 maskwords = buf[2]; 2359 shift2 = buf[3]; 2360 buf += 4; 2361 if (s->link >= ed->shnum) { 2362 warnx("Malformed .gnu.hash section"); 2363 return; 2364 } 2365 ds = &ed->sl[s->link]; 2366 if (!get_ent_count(ds, &dynsymcount)) 2367 return; 2368 if (symndx >= (uint32_t)dynsymcount) { 2369 warnx("Malformed .gnu.hash section"); 2370 return; 2371 } 2372 nchain = dynsymcount - symndx; 2373 if (data->d_size != 4 * sizeof(uint32_t) + maskwords * 2374 (ed->ec == ELFCLASS32 ? sizeof(uint32_t) : sizeof(uint64_t)) + 2375 ((uint64_t)nbucket + (uint64_t)nchain) * sizeof(uint32_t)) { 2376 warnx("Malformed .gnu.hash section"); 2377 return; 2378 } 2379 bucket = buf + (ed->ec == ELFCLASS32 ? maskwords : maskwords * 2); 2380 chain = bucket + nbucket; 2381 2382 if (ed->flags & SOLARIS_FMT) { 2383 maxl = 0; 2384 if ((bl = calloc(nbucket, sizeof(*bl))) == NULL) 2385 err(EXIT_FAILURE, "calloc failed"); 2386 for (i = 0; i < nbucket; i++) 2387 for (j = bucket[i]; j > 0 && j - symndx < nchain; j++) { 2388 if (++bl[i] > maxl) 2389 maxl = bl[i]; 2390 if (chain[j - symndx] & 1) 2391 break; 2392 } 2393 if ((c = calloc(maxl + 1, sizeof(*c))) == NULL) 2394 err(EXIT_FAILURE, "calloc failed"); 2395 for (i = 0; i < nbucket; i++) 2396 c[bl[i]]++; 2397 PRT(" bucket symndx name\n"); 2398 for (i = 0; i < nbucket; i++) { 2399 first = 1; 2400 for (j = bucket[i]; j > 0 && j - symndx < nchain; j++) { 2401 if (first) { 2402 PRT("%10d ", i); 2403 first = 0; 2404 } else 2405 PRT(" "); 2406 snprintf(idx, sizeof(idx), "[%d]", j ); 2407 PRT("%-10s ", idx); 2408 PRT("%s\n", get_symbol_name(ed, s->link, j)); 2409 if (chain[j - symndx] & 1) 2410 break; 2411 } 2412 } 2413 PRT("\n"); 2414 total = 0; 2415 for (i = 0; i <= maxl; i++) { 2416 total += c[i] * i; 2417 PRT("%10u buckets contain %8d symbols\n", c[i], i); 2418 } 2419 PRT("%10u buckets %8u symbols (globals)\n", nbucket, 2420 total); 2421 } else { 2422 PRT("\nnbucket: %u\n", nbucket); 2423 PRT("symndx: %u\n", symndx); 2424 PRT("maskwords: %u\n", maskwords); 2425 PRT("shift2: %u\n", shift2); 2426 PRT("nchain: %u\n\n", nchain); 2427 for (i = 0; i < nbucket; i++) 2428 PRT("bucket[%d]:\n\t%u\n\n", i, bucket[i]); 2429 for (i = 0; i < nchain; i++) 2430 PRT("chain[%d]:\n\t%u\n\n", i, chain[i]); 2431 } 2432 } 2433 2434 /* 2435 * Dump hash tables. 2436 */ 2437 static void 2438 elf_print_hash(struct elfdump *ed) 2439 { 2440 struct section *s; 2441 size_t i; 2442 2443 for (i = 0; i < ed->shnum; i++) { 2444 s = &ed->sl[i]; 2445 if ((s->type == SHT_HASH || s->type == SHT_GNU_HASH) && 2446 (STAILQ_EMPTY(&ed->snl) || find_name(ed, s->name))) { 2447 if (s->type == SHT_GNU_HASH) 2448 elf_print_gnu_hash(ed, s); 2449 else if (ed->ehdr.e_machine == EM_ALPHA && 2450 s->entsize == 8) 2451 elf_print_svr4_hash64(ed, s); 2452 else 2453 elf_print_svr4_hash(ed, s); 2454 } 2455 } 2456 } 2457 2458 /* 2459 * Dump the content of a Version Definition(SHT_SUNW_Verdef) Section. 2460 */ 2461 static void 2462 elf_print_verdef(struct elfdump *ed, struct section *s) 2463 { 2464 Elf_Data *data; 2465 Elf32_Verdef *vd; 2466 Elf32_Verdaux *vda; 2467 const char *str; 2468 char idx[10]; 2469 uint8_t *buf, *end, *buf2; 2470 int i, j, elferr, count; 2471 2472 if (ed->flags & SOLARIS_FMT) 2473 PRT("Version Definition Section: %s\n", s->name); 2474 else 2475 PRT("\nversion definition section (%s):\n", s->name); 2476 (void) elf_errno(); 2477 if ((data = elf_getdata(s->scn, NULL)) == NULL) { 2478 elferr = elf_errno(); 2479 if (elferr != 0) 2480 warnx("elf_getdata failed: %s", 2481 elf_errmsg(elferr)); 2482 return; 2483 } 2484 buf = data->d_buf; 2485 end = buf + data->d_size; 2486 i = 0; 2487 if (ed->flags & SOLARIS_FMT) 2488 PRT(" index version dependency\n"); 2489 while (buf + sizeof(Elf32_Verdef) <= end) { 2490 vd = (Elf32_Verdef *) (uintptr_t) buf; 2491 if (ed->flags & SOLARIS_FMT) { 2492 snprintf(idx, sizeof(idx), "[%d]", vd->vd_ndx); 2493 PRT("%10s ", idx); 2494 } else { 2495 PRT("\nentry: %d\n", i++); 2496 PRT("\tvd_version: %u\n", vd->vd_version); 2497 PRT("\tvd_flags: %u\n", vd->vd_flags); 2498 PRT("\tvd_ndx: %u\n", vd->vd_ndx); 2499 PRT("\tvd_cnt: %u\n", vd->vd_cnt); 2500 PRT("\tvd_hash: %u\n", vd->vd_hash); 2501 PRT("\tvd_aux: %u\n", vd->vd_aux); 2502 PRT("\tvd_next: %u\n\n", vd->vd_next); 2503 } 2504 buf2 = buf + vd->vd_aux; 2505 j = 0; 2506 count = 0; 2507 while (buf2 + sizeof(Elf32_Verdaux) <= end && j < vd->vd_cnt) { 2508 vda = (Elf32_Verdaux *) (uintptr_t) buf2; 2509 str = get_string(ed, s->link, vda->vda_name); 2510 if (ed->flags & SOLARIS_FMT) { 2511 if (count == 0) 2512 PRT("%-26.26s", str); 2513 else if (count == 1) 2514 PRT(" %-20.20s", str); 2515 else { 2516 PRT("\n%40.40s", ""); 2517 PRT("%s", str); 2518 } 2519 } else { 2520 PRT("\t\tvda: %d\n", j++); 2521 PRT("\t\t\tvda_name: %s\n", str); 2522 PRT("\t\t\tvda_next: %u\n", vda->vda_next); 2523 } 2524 if (vda->vda_next == 0) { 2525 if (ed->flags & SOLARIS_FMT) { 2526 if (vd->vd_flags & VER_FLG_BASE) { 2527 if (count == 0) 2528 PRT("%-20.20s", ""); 2529 PRT("%s", "[ BASE ]"); 2530 } 2531 PRT("\n"); 2532 } 2533 break; 2534 } 2535 if (ed->flags & SOLARIS_FMT) 2536 count++; 2537 buf2 += vda->vda_next; 2538 } 2539 if (vd->vd_next == 0) 2540 break; 2541 buf += vd->vd_next; 2542 } 2543 } 2544 2545 /* 2546 * Dump the content of a Version Needed(SHT_SUNW_Verneed) Section. 2547 */ 2548 static void 2549 elf_print_verneed(struct elfdump *ed, struct section *s) 2550 { 2551 Elf_Data *data; 2552 Elf32_Verneed *vn; 2553 Elf32_Vernaux *vna; 2554 uint8_t *buf, *end, *buf2; 2555 int i, j, elferr, first; 2556 2557 if (ed->flags & SOLARIS_FMT) 2558 PRT("\nVersion Needed Section: %s\n", s->name); 2559 else 2560 PRT("\nversion need section (%s):\n", s->name); 2561 (void) elf_errno(); 2562 if ((data = elf_getdata(s->scn, NULL)) == NULL) { 2563 elferr = elf_errno(); 2564 if (elferr != 0) 2565 warnx("elf_getdata failed: %s", 2566 elf_errmsg(elferr)); 2567 return; 2568 } 2569 buf = data->d_buf; 2570 end = buf + data->d_size; 2571 if (ed->flags & SOLARIS_FMT) 2572 PRT(" file version\n"); 2573 i = 0; 2574 while (buf + sizeof(Elf32_Verneed) <= end) { 2575 vn = (Elf32_Verneed *) (uintptr_t) buf; 2576 if (ed->flags & SOLARIS_FMT) 2577 PRT(" %-26.26s ", 2578 get_string(ed, s->link, vn->vn_file)); 2579 else { 2580 PRT("\nentry: %d\n", i++); 2581 PRT("\tvn_version: %u\n", vn->vn_version); 2582 PRT("\tvn_cnt: %u\n", vn->vn_cnt); 2583 PRT("\tvn_file: %s\n", 2584 get_string(ed, s->link, vn->vn_file)); 2585 PRT("\tvn_aux: %u\n", vn->vn_aux); 2586 PRT("\tvn_next: %u\n\n", vn->vn_next); 2587 } 2588 buf2 = buf + vn->vn_aux; 2589 j = 0; 2590 first = 1; 2591 while (buf2 + sizeof(Elf32_Vernaux) <= end && j < vn->vn_cnt) { 2592 vna = (Elf32_Vernaux *) (uintptr_t) buf2; 2593 if (ed->flags & SOLARIS_FMT) { 2594 if (!first) 2595 PRT("%40.40s", ""); 2596 else 2597 first = 0; 2598 PRT("%s\n", get_string(ed, s->link, 2599 vna->vna_name)); 2600 } else { 2601 PRT("\t\tvna: %d\n", j++); 2602 PRT("\t\t\tvna_hash: %u\n", vna->vna_hash); 2603 PRT("\t\t\tvna_flags: %u\n", vna->vna_flags); 2604 PRT("\t\t\tvna_other: %u\n", vna->vna_other); 2605 PRT("\t\t\tvna_name: %s\n", 2606 get_string(ed, s->link, vna->vna_name)); 2607 PRT("\t\t\tvna_next: %u\n", vna->vna_next); 2608 } 2609 if (vna->vna_next == 0) 2610 break; 2611 buf2 += vna->vna_next; 2612 } 2613 if (vn->vn_next == 0) 2614 break; 2615 buf += vn->vn_next; 2616 } 2617 } 2618 2619 /* 2620 * Dump the symbol-versioning sections. 2621 */ 2622 static void 2623 elf_print_symver(struct elfdump *ed) 2624 { 2625 struct section *s; 2626 size_t i; 2627 2628 for (i = 0; i < ed->shnum; i++) { 2629 s = &ed->sl[i]; 2630 if (!STAILQ_EMPTY(&ed->snl) && !find_name(ed, s->name)) 2631 continue; 2632 if (s->type == SHT_SUNW_verdef) 2633 elf_print_verdef(ed, s); 2634 if (s->type == SHT_SUNW_verneed) 2635 elf_print_verneed(ed, s); 2636 } 2637 } 2638 2639 /* 2640 * Dump the ELF checksum. See gelf_checksum(3) for details. 2641 */ 2642 static void 2643 elf_print_checksum(struct elfdump *ed) 2644 { 2645 2646 if (!STAILQ_EMPTY(&ed->snl)) 2647 return; 2648 2649 PRT("\nelf checksum: %#lx\n", gelf_checksum(ed->elf)); 2650 } 2651 2652 #define USAGE_MESSAGE "\ 2653 Usage: %s [options] file...\n\ 2654 Display information about ELF objects and ar(1) archives.\n\n\ 2655 Options:\n\ 2656 -a Show all information.\n\ 2657 -c Show shared headers.\n\ 2658 -d Show dynamic symbols.\n\ 2659 -e Show the ELF header.\n\ 2660 -G Show the GOT.\n\ 2661 -H | --help Show a usage message and exit.\n\ 2662 -h Show hash values.\n\ 2663 -i Show the dynamic interpreter.\n\ 2664 -k Show the ELF checksum.\n\ 2665 -n Show the contents of note sections.\n\ 2666 -N NAME Show the section named \"NAME\".\n\ 2667 -p Show the program header.\n\ 2668 -r Show relocations.\n\ 2669 -s Show the symbol table.\n\ 2670 -S Use the Solaris elfdump format.\n\ 2671 -v Show symbol-versioning information.\n\ 2672 -V | --version Print a version identifier and exit.\n\ 2673 -w FILE Write output to \"FILE\".\n" 2674 2675 static void 2676 usage(void) 2677 { 2678 fprintf(stderr, USAGE_MESSAGE, ELFTC_GETPROGNAME()); 2679 exit(EXIT_FAILURE); 2680 } 2681