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