contrib/elftoolchain/elfdump/elfdump.c

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