1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  *      Copyright (c) 1988 AT&T
  24  *        All Rights Reserved
  25  *
  26  * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
  27  */
  28 
  29 /* Get definitions for the relocation types supported. */
  30 #define ELF_TARGET_ALL
  31 
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <locale.h>
  35 #include <unistd.h>
  36 #include <libelf.h>
  37 #include <sys/link.h>
  38 #include <sys/elf.h>
  39 #include <sys/machelf.h>
  40 #include <fcntl.h>
  41 #include <sys/stat.h>
  42 #include <errno.h>
  43 #include <string.h>
  44 #include "sgs.h"
  45 #include "conv.h"
  46 #include "dump.h"
  47 
  48 
  49 #define OPTSTR  "agcd:fhn:oprstvCLT:V?"         /* option string for getopt() */
  50 
  51 const char *UNKNOWN = "<unknown>";
  52 
  53 static SCNTAB *p_symtab, *p_head_scns, *p_dynsym;
  54 
  55 static int
  56         x_flag = 0,     /* option requires section header table */
  57         z_flag = 0,     /* process files within an archive */
  58         rn_flag = 0;    /* dump named relocation information */
  59 
  60 static int
  61         /* flags: ?_flag corresponds to ? option */
  62         a_flag = 0,     /* dump archive header of each member of archive */
  63         g_flag = 0,     /* dump archive symbol table */
  64         c_flag = 0,     /* dump the string table */
  65         d_flag = 0,     /* dump range of sections */
  66         f_flag = 0,     /* dump each file header */
  67         h_flag = 0,     /* dump section headers */
  68         n_flag = 0,     /* dump named section */
  69         o_flag = 0,     /* dump each program execution header */
  70         r_flag = 0,     /* dump relocation information */
  71         s_flag = 0,     /* dump section contents */
  72         t_flag = 0,     /* dump symbol table entries */
  73         C_flag = 0,     /* dump decoded C++ symbol names */
  74         L_flag = 0,     /* dump dynamic linking information */
  75         T_flag = 0,     /* dump symbol table range */
  76         V_flag = 0;     /* dump version information */
  77 
  78 int     p_flag = 0,     /* suppress printing of headings */
  79         v_flag = 0;     /* print information in verbose form */
  80 
  81 static int
  82         d_low = 0,      /* range for use with -d */
  83         d_hi = 0,
  84         d_num = 0;
  85 
  86 static int
  87         T_low = 0,      /* range for use with -T */
  88         T_hi = 0,
  89         T_num = 0;
  90 
  91 static char *name = NULL; /* for use with -n option */
  92 char *prog_name;
  93 static int errflag = 0;
  94 
  95 static struct stab_list_s {
  96         struct stab_list_s *next;
  97         char *strings;
  98         size_t size;
  99 } *StringTableList = (void *)0;
 100 
 101 extern void ar_sym_read();
 102 extern void dump_exec_header();
 103 
 104 
 105 /*
 106  * Get the section descriptor and set the size of the
 107  * data returned.  Data is byte-order converted.
 108  */
 109 void *
 110 get_scndata(Elf_Scn *fd_scn, size_t *size)
 111 {
 112         Elf_Data *p_data;
 113 
 114         p_data = 0;
 115         if ((p_data = elf_getdata(fd_scn, p_data)) == 0 ||
 116             p_data->d_size == 0) {
 117                 return (NULL);
 118         }
 119         *size = p_data->d_size;
 120         return (p_data->d_buf);
 121 }
 122 
 123 /*
 124  * Get the section descriptor and set the size of the
 125  * data returned.  Data is raw (i.e., not byte-order converted).
 126  */
 127 static void *
 128 get_rawscn(Elf_Scn *fd_scn, size_t *size)
 129 {
 130         Elf_Data *p_data;
 131 
 132         p_data = 0;
 133         if ((p_data = elf_rawdata(fd_scn, p_data)) == 0 ||
 134             p_data->d_size == 0) {
 135                 return (NULL);
 136         }
 137 
 138         *size = p_data->d_size;
 139         return (p_data->d_buf);
 140 }
 141 
 142 /*
 143  * Print out a usage message in short form when program is invoked
 144  * with insufficient or no arguments, and in long form when given
 145  * either a ? or an invalid option.
 146  */
 147 static void
 148 usage()
 149 {
 150         (void) fprintf(stderr,
 151         "Usage: %s [-%s] file(s) ...\n", prog_name, OPTSTR);
 152         if (errflag) {
 153                 (void) fprintf(stderr,
 154                 "\t\t[-a dump archive header of each member of archive]\n\
 155                 [-g dump archive global symbol table]\n\
 156                 [-c dump the string table]\n\
 157                 [-d dump range of sections]\n\
 158                 [-f dump each file header]\n\
 159                 [-h dump section headers]\n\
 160                 [-n dump named section]\n\
 161                 [-o dump each program execution header]\n\
 162                 [-p suppress printing of headings]\n\
 163                 [-r dump relocation information]\n\
 164                 [-s dump section contents]\n\
 165                 [-t dump symbol table entries]\n\
 166                 [-v print information in verbose form]\n\
 167                 [-C dump decoded C++ symbol names]\n\
 168                 [-L dump the .dynamic structure]\n\
 169                 [-T dump symbol table range]\n\
 170                 [-V dump version information]\n");
 171         }
 172 }
 173 
 174 /*
 175  * Set a range.  Input is a character string, a lower
 176  * bound and an upper bound.  This function converts
 177  * a character string into its correct integer values,
 178  * setting the first value as the lower bound, and
 179  * the second value as the upper bound.  If more values
 180  * are given they are ignored with a warning.
 181  */
 182 static void
 183 set_range(char *s, int  *low, int  *high)
 184 {
 185         char *w;
 186         char *lasts;
 187 
 188         while ((w = strtok_r(s, ",", &lasts)) != NULL) {
 189                 if (!(*low))
 190                         /* LINTED */
 191                         *low = (int)atol(w);
 192                 else
 193                         if (!(*high))
 194                                 /* LINTED */
 195                                 *high = (int)atol(w);
 196                         else {
 197                                 (void) fprintf(stderr,
 198                                     "%s: too many arguments - %s ignored\n",
 199                                     prog_name, w);
 200                                 return;
 201                         }
 202                 s = NULL;
 203         } /* end while */
 204 }
 205 
 206 
 207 /*
 208  * Print static shared library information.
 209  */
 210 static void
 211 print_static(SCNTAB *l_scns, char *filename)
 212 {
 213         size_t section_size;
 214         unsigned char *strtab;
 215         unsigned char *path, buf[1024];
 216         unsigned long *temp;
 217         unsigned long total, topath;
 218 
 219         (void) printf("\n  **** STATIC SHARED LIBRARY INFORMATION ****\n");
 220         (void) printf("\n%s:\n", filename);
 221         (void) printf("\t");
 222         section_size  = 0;
 223         if ((strtab = (unsigned char *)
 224             get_scndata(l_scns->p_sd, &section_size)) == NULL) {
 225                 return;
 226         }
 227 
 228         while (section_size != 0) {
 229                 /* LINTED */
 230                 temp = (unsigned long *)strtab;
 231                 total = temp[0];
 232                 topath = temp[1];
 233                 path = strtab + (topath*sizeof (long));
 234                 (void) strncpy((char *)buf, (char *)path,
 235                     (total - topath)*sizeof (long));
 236                 (void) fprintf(stdout, "%s\n", buf);
 237                 strtab += total*sizeof (long);
 238                 section_size -= (total*sizeof (long));
 239         }
 240 }
 241 
 242 /*
 243  * Print raw data in hexidecimal.  Input is the section data to
 244  * be printed out and the size of the data.  Output is relative
 245  * to a table lookup in dumpmap.h.
 246  */
 247 static void
 248 print_rawdata(unsigned char *p_sec, size_t size)
 249 {
 250         size_t   j;
 251         size_t   count;
 252 
 253         count = 1;
 254 
 255         (void) printf("\t");
 256         for (j = size/sizeof (short); j != 0; --j, ++count) {
 257                 (void) printf("%.2x %.2x ", p_sec[0], p_sec[1]);
 258                 p_sec += 2;
 259                 if (count == 12) {
 260                         (void) printf("\n\t");
 261                         count = 0;
 262                 }
 263         }
 264 
 265         /*
 266          * take care of last byte if odd byte section
 267          */
 268         if ((size & 0x1L) == 1L)
 269                 (void) printf("%.2x", *p_sec);
 270         (void) printf("\n");
 271 }
 272 
 273 
 274 
 275 /*
 276  * Print relocation data of type SHT_RELA
 277  * If d_flag, print data corresponding only to
 278  * the section or range of sections specified.
 279  * If n_flag, print data corresponding only to
 280  * the named section.
 281  */
 282 static void
 283 print_rela(Elf *elf_file, SCNTAB *p_scns, Elf_Data *rdata, Elf_Data *sym_data,
 284     GElf_Ehdr * p_ehdr, size_t reloc_size, size_t sym_size, char *filename,
 285     SCNTAB *reloc_symtab)
 286 {
 287         GElf_Rela rela;
 288         GElf_Sym sym;
 289         size_t no_entries;
 290         size_t rel_entsize;
 291         size_t no_syms;
 292         int type, symid;
 293         static int n_title = 0;
 294         int ndx = 0;
 295         char *sym_name;
 296         int adj = 0;
 297 
 298         if (gelf_getclass(elf_file) == ELFCLASS64)
 299                 adj = 8;
 300 
 301         rel_entsize = p_scns->p_shdr.sh_entsize;
 302         if ((rel_entsize == 0) ||
 303             (rel_entsize > p_scns->p_shdr.sh_size)) {
 304                 rel_entsize = gelf_fsize(elf_file, ELF_T_RELA, 1,
 305                     EV_CURRENT);
 306         }
 307         no_entries = reloc_size / rel_entsize;
 308 
 309         no_syms = sym_size / gelf_fsize(elf_file, ELF_T_SYM, 1, EV_CURRENT);
 310         while (no_entries--) {
 311                 (void) gelf_getrela(rdata, ndx, &rela);
 312                 /* LINTED */
 313                 type = (int)GELF_R_TYPE(rela.r_info);
 314                 /* LINTED */
 315                 symid = (int)GELF_R_SYM(rela.r_info);
 316                 /* LINTED */
 317                 if ((symid > (no_syms - 1)) || (symid < 0)) {
 318                         (void) fprintf(stderr, "%s: %s: invalid symbol table "
 319                             "offset - %d - in %s\n", prog_name, filename,
 320                             symid, p_scns->scn_name);
 321                         ndx++;
 322                         continue;
 323                 }
 324                 (void) gelf_getsym(sym_data, symid, &sym);
 325                 sym_name = (char *)elf_strptr(elf_file,
 326                     reloc_symtab->p_shdr.sh_link, sym.st_name);
 327                 if (sym_name == NULL)
 328                         sym_name = (char *)UNKNOWN;
 329                 if (r_flag && rn_flag) {
 330                         if (strcmp(name, p_scns->scn_name) != 0) {
 331                                 ndx++;
 332                                 continue;
 333                         }
 334                         if (!n_title) {
 335                                 (void) printf("\n%s:\n", p_scns->scn_name);
 336                                 (void) printf("%-*s%-*s%-*s%s\n\n",
 337                                     12 + adj, "Offset", 22, "Symndx",
 338                                     16, "Type", "Addend");
 339                                 n_title = 1;
 340                         }
 341                 }
 342                 if (d_flag) {
 343                         if (!d_hi)
 344                                 d_hi = d_low;
 345                         if ((symid < d_low) || (symid > d_hi)) {
 346                                 ndx++;
 347                                 continue;
 348                         }
 349                 }
 350 
 351                 (void) printf("%-#*llx", 12 + adj, EC_XWORD(rela.r_offset));
 352                 if (!v_flag) {
 353                         (void) printf("%-22d%-18d", symid, type);
 354                 } else {
 355                         Conv_inv_buf_t  inv_buf;
 356 
 357                         if (strlen(sym_name)) {
 358                                 size_t len = strlen(sym_name) + 1;
 359                                 char tmpstr[10];
 360                                 if (len > 22) {
 361                                         (void) sprintf(tmpstr, "%%-%ds",
 362                                             /* LINTED */
 363                                             (int)len);
 364                                         /*LINTED: E_SEC_PRINTF_VAR_FMT*/
 365                                         (void) printf(tmpstr, sym_name);
 366                                 } else
 367                                         (void) printf("%-22s", sym_name);
 368                         } else {
 369                                 (void) printf("%-22d", symid);
 370                         }
 371                         (void) printf("%-20s",
 372                             conv_reloc_type(p_ehdr->e_machine,
 373                             type, DUMP_CONVFMT, &inv_buf));
 374                 }
 375                 (void) printf("%lld\n", EC_SXWORD(rela.r_addend));
 376                 ndx++;
 377         }
 378 }
 379 
 380 /*
 381  * Print relocation data of type SHT_REL.
 382  * If d_flag, print data corresponding only to
 383  * the section or range of sections specified.
 384  * If n_flag, print data corresponding only to
 385  * the named section.
 386  */
 387 static void
 388 print_rel(Elf *elf_file, SCNTAB *p_scns, Elf_Data *rdata, Elf_Data *sym_data,
 389     GElf_Ehdr *p_ehdr, size_t reloc_size, size_t sym_size, char *filename,
 390     SCNTAB *reloc_symtab)
 391 {
 392         GElf_Rel rel;
 393         GElf_Sym sym;
 394         size_t no_entries;
 395         size_t rel_entsize;
 396         int type, symid;
 397         size_t no_syms;
 398         static int n_title = 0;
 399         int ndx = 0;
 400         char *sym_name;
 401         int adj = 0;
 402 
 403         if (gelf_getclass(elf_file) == ELFCLASS64)
 404                 adj = 8;
 405 
 406         rel_entsize = p_scns->p_shdr.sh_entsize;
 407         if ((rel_entsize == 0) ||
 408             (rel_entsize > p_scns->p_shdr.sh_size)) {
 409                 rel_entsize = gelf_fsize(elf_file, ELF_T_REL, 1,
 410                     EV_CURRENT);
 411         }
 412         no_entries = reloc_size / rel_entsize;
 413 
 414         no_syms = sym_size / gelf_fsize(elf_file, ELF_T_SYM, 1, EV_CURRENT);
 415         while (no_entries--) {
 416                 (void) gelf_getrel(rdata, ndx, &rel);
 417                 /* LINTED */
 418                 type = (int)GELF_R_TYPE(rel.r_info);
 419                 /* LINTED */
 420                 symid = (int)GELF_R_SYM(rel.r_info);
 421                 /* LINTED */
 422                 if ((symid > (no_syms - 1)) || (symid < 0)) {
 423                         (void) fprintf(stderr, "%s: %s: invalid symbol table "
 424                             "offset - %d - in %s\n", prog_name, filename,
 425                             symid, p_scns->scn_name);
 426                         ndx++;
 427                         continue;
 428                 }
 429                 (void) gelf_getsym(sym_data, symid, &sym);
 430                 sym_name = (char *)elf_strptr(elf_file,
 431                     reloc_symtab->p_shdr.sh_link, sym.st_name);
 432                 if (sym_name == NULL)
 433                         sym_name = (char *)UNKNOWN;
 434                 if (r_flag && rn_flag) {
 435                         if (strcmp(name, p_scns->scn_name) != 0) {
 436                                 ndx++;
 437                                 continue;
 438                         }
 439                         if (!n_title) {
 440                                 (void) printf("\n%s:\n", p_scns->scn_name);
 441                                 (void) printf("%-*s%-*s%s\n\n",
 442                                     12 + adj, "Offset", 20, "Symndx", "Type");
 443                                 n_title = 1;
 444                         }
 445                 }
 446                 if (d_flag) {
 447                         if (!d_hi)
 448                                 d_hi = d_low;
 449                         if ((symid < d_low) || (symid > d_hi)) {
 450                                 ndx++;
 451                                 continue;
 452                         }
 453                 }
 454 
 455                 (void) printf("%-#*llx", 12 + adj, EC_ADDR(rel.r_offset));
 456                 if (!v_flag) {
 457                         (void) printf("%-20d%-18d", symid, type);
 458                 } else {
 459                         Conv_inv_buf_t  inv_buf;
 460 
 461                         if (strlen(sym_name))
 462                                 (void) printf("%-20s", sym_name);
 463                         else {
 464                                 (void) printf("%-20d", sym.st_name);
 465                         }
 466                         (void) printf("%-20s",
 467                             conv_reloc_type(p_ehdr->e_machine,
 468                             type, DUMP_CONVFMT, &inv_buf));
 469                 }
 470                 (void) printf("\n");
 471                 ndx++;
 472         }
 473 }
 474 
 475 /* demangle C++ names */
 476 static char *
 477 demangled_name(char *s)
 478 {
 479         static char     *buf = NULL;
 480         const char      *dn;
 481         size_t          len;
 482 
 483         dn = conv_demangle_name(s);
 484 
 485         /*
 486          * If not demangled, just return the symbol name
 487          */
 488         if (strcmp(s, dn) == 0)
 489                 return (s);
 490 
 491         /*
 492          * Demangled. Format it
 493          */
 494         if (buf != NULL)
 495                 free(buf);
 496 
 497         len = strlen(dn) + strlen(s) + 4;
 498         if ((buf = malloc(len)) == NULL)
 499                 return (s);
 500 
 501         (void) snprintf(buf, len, "%s\t[%s]", dn, s);
 502         return (buf);
 503 }
 504 
 505 /*
 506  * Print the symbol table.  Input is an ELF file descriptor, a
 507  * pointer to the symbol table SCNTAB structure,
 508  * the number of symbols, a range of symbols to print,
 509  * an index which is the number of the
 510  * section in the file, and the filename.  The number of sections,
 511  * the range, and the index are set in
 512  * dump_symbol_table, depending on whether -n or -T were set.
 513  */
 514 static void
 515 print_symtab(Elf *elf_file, SCNTAB *p_symtab, Elf_Data *sym_data,
 516     long range, int index)
 517 {
 518         GElf_Sym sym;
 519         int adj = 0;            /* field adjustment for elf64 */
 520         Elf32_Word      *symshndx = 0;
 521         unsigned int    nosymshndx = 0;
 522         Conv_inv_buf_t  inv_buf;
 523 
 524 
 525         if (gelf_getclass(elf_file) == ELFCLASS64)
 526                 adj = 8;
 527 
 528         while (range > 0) {
 529                 char            *sym_name = (char *)0;
 530                 int             type, bind;
 531                 int             specsec;
 532                 unsigned int    shndx;
 533 
 534                 (void) gelf_getsym(sym_data, index, &sym);
 535                 type = (int)GELF_ST_TYPE(sym.st_info);
 536                 bind = (int)GELF_ST_BIND(sym.st_info);
 537 
 538                 if ((sym.st_shndx == SHN_XINDEX) &&
 539                     (symshndx == 0) && (nosymshndx == 0)) {
 540                         Elf_Scn         *_scn;
 541                         GElf_Shdr       _shdr;
 542                         size_t          symscnndx;
 543 
 544                         symscnndx = elf_ndxscn(p_symtab->p_sd);
 545                         _scn = 0;
 546                         while ((_scn = elf_nextscn(elf_file, _scn)) != 0) {
 547                                 if (gelf_getshdr(_scn, &_shdr) == 0)
 548                                         break;
 549                                 if ((_shdr.sh_type == SHT_SYMTAB_SHNDX) &&
 550                                     /* LINTED */
 551                                     (_shdr.sh_link == (GElf_Word)symscnndx)) {
 552                                         Elf_Data        *_data;
 553 
 554                                         if ((_data = elf_getdata(_scn, 0)) == 0)
 555                                                 continue;
 556 
 557                                         symshndx = (Elf32_Word *)_data->d_buf;
 558                                         nosymshndx = 0;
 559                                         break;
 560                                 }
 561                         }
 562                         nosymshndx = 1;
 563                 }
 564 
 565                 if ((symshndx) && (sym.st_shndx == SHN_XINDEX)) {
 566                         shndx = symshndx[index];
 567                         specsec = 0;
 568                 } else {
 569                         shndx = sym.st_shndx;
 570                         if ((sym.st_shndx == SHN_UNDEF) ||
 571                             (sym.st_shndx >= SHN_LORESERVE))
 572                                 specsec = 1;
 573                         else
 574                                 specsec = 0;
 575                 }
 576 
 577 
 578                 (void) printf("[%d]\t ", index++);
 579 
 580                 if (v_flag && (type == STT_SPARC_REGISTER)) {
 581                         /*
 582                          *  The strings "REG_G1" through "REG_G7" are intended
 583                          *  to be consistent with output from elfdump(1).
 584                          */
 585                         (void) printf("%-*s", 12 + adj,
 586                             conv_sym_SPARC_value(sym.st_value,
 587                             DUMP_CONVFMT, &inv_buf));
 588                 } else {
 589                         (void) printf("0x%-*llx", 10 + adj,
 590                             EC_ADDR(sym.st_value));
 591                 }
 592 
 593                 (void) printf("%-*lld", 9 + adj, EC_XWORD(sym.st_size));
 594 
 595                 if (!v_flag) {
 596                         (void) printf("%d\t\t%d\t%d\t%#x\t",
 597                             type, bind, (int)sym.st_other, (int)shndx);
 598                 } else {
 599                         GElf_Ehdr p_ehdr;
 600                         (void) gelf_getehdr(elf_file, &p_ehdr);
 601                         (void) printf("%s\t",
 602                             conv_sym_info_type(p_ehdr.e_machine, type,
 603                             DUMP_CONVFMT, &inv_buf));
 604                         (void) printf("%s",
 605                             conv_sym_info_bind(bind, DUMP_CONVFMT, &inv_buf));
 606                         (void) printf("\t  %d\t", EC_WORD(sym.st_other));
 607 
 608                         if (specsec)
 609                                 (void) printf("%s",
 610                                     conv_sym_shndx(p_ehdr.e_ident[EI_OSABI],
 611                                     p_ehdr.e_machine, shndx,
 612                                     CONV_FMT_DECIMAL, &inv_buf));
 613                         else
 614                                 (void) printf("%d", EC_WORD(shndx));
 615                         (void) printf("\t");
 616                 }
 617 
 618                 /* support machines where NULL-deref causes core dump */
 619                 if (sym.st_name == 0)
 620                         sym_name = (char *)UNKNOWN;
 621                 else
 622                         if (C_flag)
 623                                 sym_name = demangled_name(
 624                                     (char *)elf_strptr(elf_file,
 625                                     p_symtab->p_shdr.sh_link,
 626                                     sym.st_name));
 627                 else
 628                         sym_name = (char *)elf_strptr(elf_file,
 629                             p_symtab->p_shdr.sh_link, sym.st_name);
 630                 if (sym_name == NULL)
 631                         sym_name = (char *)UNKNOWN;
 632                 (void) printf("%s\n", sym_name);
 633 
 634                 range--;
 635         }       /* end while */
 636 }
 637 
 638 /*
 639  * Print the section header table.  Input is the SCNTAB structure,
 640  * the number of sections, an index which is the number of the
 641  * section in the file, and the filename.  The values of the SCNTAB
 642  * structure, the number of sections, and the index are set in
 643  * dump_shdr depending on whether the -n or -d modifiers were set.
 644  */
 645 static void
 646 print_shdr(Elf *elf_file, SCNTAB *s, int num_scns, int index)
 647 {
 648         SCNTAB *p;
 649         int num;
 650         int field;
 651         GElf_Ehdr p_ehdr;
 652 
 653         if (gelf_getclass(elf_file) == ELFCLASS64)
 654                 field = 21;
 655         else
 656                 field = 13;
 657 
 658         p = s;
 659         (void) gelf_getehdr(elf_file, &p_ehdr);
 660 
 661         for (num = 0; num < num_scns; num++, p++) {
 662                 (void) printf("[%d]\t", index++);
 663                 if (!v_flag) {
 664                         (void) printf("%u\t%llu\t",
 665                             EC_WORD(p->p_shdr.sh_type),
 666                             EC_XWORD(p->p_shdr.sh_flags));
 667                 } else {
 668                         Conv_inv_buf_t inv_buf;
 669 
 670                         /*LINTED: E_SEC_PRINTF_VAR_FMT*/
 671                         (void) printf(conv_sec_type(
 672                             p_ehdr.e_ident[EI_OSABI], p_ehdr.e_machine,
 673                             p->p_shdr.sh_type, DUMP_CONVFMT, &inv_buf));
 674                         (void) printf("    ");
 675 
 676                         if (p->p_shdr.sh_flags & SHF_WRITE)
 677                                 (void) printf("W");
 678                         else
 679                                 (void) printf("-");
 680                         if (p->p_shdr.sh_flags & SHF_ALLOC)
 681                                 (void) printf("A");
 682                         else
 683                                 (void) printf("-");
 684                         if (p->p_shdr.sh_flags & SHF_EXECINSTR)
 685                                 (void) printf("I");
 686                         else
 687                                 (void) printf("-");
 688 
 689                         if (p->p_shdr.sh_flags & SHF_ORDERED)
 690                                 (void) printf("O");
 691                         if (p->p_shdr.sh_flags & SHF_EXCLUDE)
 692                                 (void) printf("E");
 693 
 694                         (void) printf("\t");
 695 
 696                 }
 697                 (void) printf("%-#*llx%-#*llx%-#*llx%s%s\n",
 698                     field, EC_ADDR(p->p_shdr.sh_addr),
 699                     field, EC_OFF(p->p_shdr.sh_offset),
 700                     field, EC_XWORD(p->p_shdr.sh_size),
 701                     /* compatibility:  tab for elf32 */
 702                     (field == 13) ? "\t" : " ", p->scn_name);
 703 
 704                 (void) printf("\t%u\t%u\t%-#*llx%-#*llx\n\n",
 705                     EC_WORD(p->p_shdr.sh_link),
 706                     EC_WORD(p->p_shdr.sh_info),
 707                     field, EC_XWORD(p->p_shdr.sh_addralign),
 708                     field, EC_XWORD(p->p_shdr.sh_entsize));
 709         }
 710 }
 711 
 712 /*
 713  * Check that a range of numbers is valid.  Input is
 714  * a lower bound, an upper bound, a boundary condition,
 715  * and the filename.  Negative numbers and numbers greater
 716  * than the bound are invalid.  low must be smaller than hi.
 717  * The returned integer is the number of items in the
 718  * range if it is valid and -1 otherwise.
 719  */
 720 static int
 721 check_range(int low, int hi, size_t bound, char *filename)
 722 {
 723         if (((size_t)low > bound) || (low <= 0)) {
 724                 (void) fprintf(stderr,
 725                     "%s: %s: number out of range, %d\n",
 726                     prog_name, filename, low);
 727                 return (-1);
 728         }
 729         if (((size_t)hi > bound) || (hi < 0)) {
 730                 (void) fprintf(stderr,
 731                     "%s: %s: number out of range, %d\n",
 732                     prog_name, filename, hi);
 733                 return (-1);
 734         }
 735 
 736         if (hi && (low > hi)) {
 737                 (void) fprintf(stderr,
 738                     "%s: %s: invalid range, %d,%d\n",
 739                     prog_name, filename, low, hi);
 740                 return (-1);
 741         }
 742         if (hi)
 743                 return (hi - low + 1);
 744         else
 745                 return (1);
 746 }
 747 
 748 /*
 749  * Print relocation information.  Since this information is
 750  * machine dependent, new sections must be added for each machine
 751  * that is supported.  Input is an ELF file descriptor, the ELF header,
 752  * the SCNTAB structure, the number of sections, and a filename.
 753  * Set up necessary information to print relocation information
 754  * and call the appropriate print function depending on the
 755  * type of relocation information.  If the symbol table is
 756  * absent, no relocation data is processed.  Input is an
 757  * ELF file descriptor, the ELF header, the SCNTAB structure,
 758  * and the filename.  Set range of d_flag and name if n_flag.
 759  */
 760 static void
 761 dump_reloc_table(Elf *elf_file, GElf_Ehdr *p_ehdr,
 762     SCNTAB *p_scns, int num_scns, char *filename)
 763 {
 764         Elf_Data *rel_data;
 765         Elf_Data *sym_data;
 766         size_t    sym_size;
 767         size_t    reloc_size;
 768         SCNTAB *reloc_symtab;
 769         SCNTAB *head_scns;
 770         int r_title = 0;
 771         int adj = 0;
 772         size_t shnum;
 773 
 774         if (gelf_getclass(elf_file) == ELFCLASS64)
 775                 adj = 8;
 776 
 777         if ((!p_flag) && (!r_title)) {
 778                 (void) printf("\n    **** RELOCATION INFORMATION ****\n");
 779                 r_title = 1;
 780         }
 781 
 782         while (num_scns-- > 0) {
 783                 if ((p_scns->p_shdr.sh_type != SHT_RELA) &&
 784                     (p_scns->p_shdr.sh_type != SHT_REL)) {
 785                         p_scns++;
 786                         continue;
 787                 }
 788 
 789         head_scns = p_head_scns;
 790 
 791         if (elf_getshdrnum(elf_file, &shnum) == -1) {
 792                 (void) fprintf(stderr,
 793                     "%s: %s: elf_getshdrnum failed: %s\n",
 794                     prog_name, filename, elf_errmsg(-1));
 795                 return;
 796         }
 797 
 798         if ((p_scns->p_shdr.sh_link == 0) ||
 799             /* LINTED */
 800             (p_scns->p_shdr.sh_link >= (GElf_Word)shnum)) {
 801                 (void) fprintf(stderr, "%s: %s: invalid sh_link field: "
 802                     "section #: %d sh_link: %d\n",
 803                     /* LINTED */
 804                     prog_name, filename, (int)elf_ndxscn(p_scns->p_sd),
 805                     (int)p_scns->p_shdr.sh_link);
 806                 return;
 807         }
 808         head_scns += (p_scns->p_shdr.sh_link -1);
 809 
 810         if (head_scns->p_shdr.sh_type == SHT_SYMTAB) {
 811                 reloc_symtab = p_symtab;
 812         } else if (head_scns->p_shdr.sh_type  == SHT_DYNSYM) {
 813                 reloc_symtab = p_dynsym;
 814         } else {
 815                 (void) fprintf(stderr,
 816 "%s: %s: could not get symbol table\n", prog_name, filename);
 817                 return;
 818         }
 819 
 820         sym_data = NULL;
 821         sym_size = 0;
 822         reloc_size = 0;
 823 
 824         if ((sym_data = elf_getdata(reloc_symtab->p_sd, NULL)) == NULL) {
 825                 (void) fprintf(stderr,
 826                 "%s: %s: no symbol table data\n", prog_name, filename);
 827                 return;
 828         }
 829         sym_size = sym_data->d_size;
 830 
 831         if (p_scns == NULL) {
 832                 (void) fprintf(stderr,
 833                 "%s: %s: no section table data\n", prog_name, filename);
 834                 return;
 835         }
 836 
 837         if (p_scns->p_shdr.sh_type == SHT_RELA) {
 838                 if (!n_flag && r_flag)
 839                         (void) printf("\n%s:\n", p_scns->scn_name);
 840                 if (!p_flag && (!n_flag && r_flag))
 841                         (void) printf("%-*s%-*s%-*s%s\n\n",
 842                             12 + adj, "Offset", 22, "Symndx",
 843                             18, "Type", "Addend");
 844                 if ((rel_data = elf_getdata(p_scns->p_sd, NULL)) == NULL) {
 845                         (void) fprintf(stderr,
 846 "%s: %s: no relocation information\n", prog_name, filename);
 847                         return;
 848                 }
 849                 reloc_size = rel_data->d_size;
 850 
 851                 if (n_flag) {
 852                         rn_flag = 1;
 853                         print_rela(elf_file, p_scns, rel_data, sym_data, p_ehdr,
 854                             reloc_size, sym_size, filename, reloc_symtab);
 855                 }
 856                 if (d_flag) {
 857                         rn_flag = 0;
 858                         print_rela(elf_file, p_scns, rel_data, sym_data, p_ehdr,
 859                             reloc_size, sym_size, filename, reloc_symtab);
 860                 }
 861                 if (!n_flag && !d_flag)
 862                         print_rela(elf_file, p_scns, rel_data, sym_data, p_ehdr,
 863                             reloc_size, sym_size, filename, reloc_symtab);
 864         } else {
 865                 if (p_scns->p_shdr.sh_type == SHT_REL) {
 866                         if (!n_flag && r_flag)
 867                                 (void) printf("\n%s:\n", p_scns->scn_name);
 868                         if (!p_flag && (!n_flag && r_flag)) {
 869                                 (void) printf("%-*s%-*s%s\n\n",
 870                                     12 + adj, "Offset", 20, "Symndx", "Type");
 871                         }
 872                         if ((rel_data = elf_getdata(p_scns->p_sd, NULL))
 873                             == NULL) {
 874                                 (void) fprintf(stderr,
 875 "%s: %s: no relocation information\n", prog_name, filename);
 876                                 return;
 877                         }
 878                         reloc_size = rel_data->d_size;
 879                         if (n_flag) {
 880                                 rn_flag = 1;
 881                                 print_rel(elf_file, p_scns, rel_data, sym_data,
 882                                     p_ehdr, reloc_size, sym_size,
 883                                     filename, reloc_symtab);
 884                         }
 885                         if (d_flag) {
 886                                 rn_flag = 0;
 887                                 print_rel(elf_file, p_scns, rel_data, sym_data,
 888                                     p_ehdr, reloc_size, sym_size,
 889                                     filename, reloc_symtab);
 890                         }
 891                         if (!n_flag && !d_flag)
 892                                 print_rel(elf_file, p_scns, rel_data, sym_data,
 893                                     p_ehdr, reloc_size, sym_size,
 894                                     filename, reloc_symtab);
 895                 }
 896         }
 897         p_scns++;
 898         }
 899 }
 900 
 901 /*
 902  * Print out the string tables.  Input is an opened ELF file,
 903  * the SCNTAB structure, the number of sections, and the filename.
 904  * Since there can be more than one string table, all sections are
 905  * examined and any with the correct type are printed out.
 906  */
 907 static void
 908 dump_string_table(SCNTAB *s, int num_scns)
 909 {
 910         size_t section_size;
 911         unsigned char *strtab;
 912         int beg_of_string;
 913         int counter = 0;
 914         int str_off;
 915         int i;
 916 
 917         if (!p_flag) {
 918                 (void) printf("\n     **** STRING TABLE INFORMATION ****\n");
 919         }
 920 
 921         for (i = 0; i < num_scns; i++, s++) {
 922                 if (s->p_shdr.sh_type != SHT_STRTAB)
 923                         continue;
 924 
 925                 str_off = 0;
 926 
 927                 if (!p_flag) {
 928                         (void) printf("\n%s:\n", s->scn_name);
 929                         (void) printf("   <offset>  \tName\n");
 930                 }
 931                 section_size = 0;
 932                 if ((strtab = (unsigned char *)
 933                     get_scndata(s->p_sd, &section_size)) == NULL) {
 934                         continue;
 935                 }
 936 
 937                 if (section_size != 0) {
 938                         (void) printf("   <%d>  \t", str_off);
 939                         beg_of_string = 0;
 940                         while (section_size--) {
 941                                 unsigned char c = *strtab++;
 942 
 943                                 if (beg_of_string) {
 944                                         (void) printf("   <%d>  \t", str_off);
 945                                         counter++;
 946                                         beg_of_string = 0;
 947                                 }
 948                                 str_off++;
 949                                 switch (c) {
 950                                 case '\0':
 951                                         (void) printf("\n");
 952                                         beg_of_string = 1;
 953                                         break;
 954                                 default:
 955                                         (void) putchar(c);
 956                                 }
 957                         }
 958                 }
 959         }
 960         (void) printf("\n");
 961 }
 962 
 963 /*
 964  * Print the symbol table.  This function does not print the contents
 965  * of the symbol table but sets up the parameters and then calls
 966  * print_symtab to print the symbols.  Calling another function to print
 967  * the symbols allows both -T and -n to work correctly
 968  * simultaneously.  Input is an opened ELF file, a pointer to the
 969  * symbol table SCNTAB structure, and the filename.
 970  * Set the range of symbols to print if T_flag, and set
 971  * name of symbol to print if n_flag.
 972  */
 973 static void
 974 dump_symbol_table(Elf *elf_file, SCNTAB *p_symtab, char *filename)
 975 {
 976         Elf_Data  *sym_data;
 977         GElf_Sym  T_range, n_range;     /* for use with -T and -n */
 978         size_t count = 0;
 979         size_t sym_size;
 980         int index = 1;
 981         int found_it = 0;
 982         int i;
 983         int adj = 0;                    /*  field adjustment for elf64 */
 984 
 985         if (gelf_getclass(elf_file) == ELFCLASS64)
 986                 adj = 8;
 987 
 988         if (p_symtab == NULL) {
 989                 (void) fprintf(stderr,
 990                 "%s: %s: could not get symbol table\n", prog_name, filename);
 991                 return;
 992         }
 993 
 994         /* get symbol table data */
 995         sym_data = NULL;
 996         sym_size = 0;
 997         if ((sym_data =
 998             elf_getdata(p_symtab->p_sd, NULL)) == NULL) {
 999                 (void) printf("\n%s:\n", p_symtab->scn_name);
1000                 (void) printf("No symbol table data\n");
1001                 return;
1002         }
1003         sym_size = sym_data->d_size;
1004 
1005         count = sym_size / p_symtab->p_shdr.sh_entsize;
1006 
1007         if (n_flag && t_flag && !T_flag) {
1008                 /* LINTED */
1009                 for (i = 1; i < count; i++) {
1010                         (void) gelf_getsym(sym_data, i, &n_range);
1011                         if (strcmp(name, (char *)
1012                             elf_strptr(elf_file,
1013                             p_symtab->p_shdr.sh_link,
1014                             n_range.st_name)) != 0) {
1015                                 continue;
1016                         } else {
1017                                 found_it = 1;
1018                                 if (!p_flag) {
1019                                         (void) printf(
1020 "\n              ***** SYMBOL TABLE INFORMATION *****\n");
1021                                         (void) printf(
1022 "[Index]  %-*s%-*sType\tBind\tOther\tShndx\tName",
1023                                             12 + adj, "Value", 9 + adj, "Size");
1024                                 }
1025                                 (void) printf("\n%s:\n", p_symtab->scn_name);
1026                                 print_symtab(elf_file, p_symtab, sym_data,
1027                                     1, i);
1028                         }
1029                 }   /* end for */
1030                 if (!found_it) {
1031                         (void) fprintf(stderr, "%s: %s: %s not found\n",
1032                             prog_name, filename, name);
1033                 }
1034         } else if (T_flag) {
1035                 T_num = check_range(T_low, T_hi, count, filename);
1036                 if (T_num < 0)
1037                         return;
1038 
1039                 (void) gelf_getsym(sym_data, T_low-1, &T_range);
1040                 index = T_low;
1041 
1042                 if (!p_flag) {
1043                         (void) printf(
1044 "\n              ***** SYMBOL TABLE INFORMATION *****\n");
1045                         (void) printf(
1046 "[Index]  %-*s%-*sType\tBind\tOther\tShndx\tName",
1047                             12 + adj, "Value", 9 + adj, "Size");
1048                 }
1049                 (void) printf("\n%s:\n", p_symtab->scn_name);
1050                 print_symtab(elf_file, p_symtab, sym_data, T_num, index);
1051         } else {
1052                 if (!p_flag) {
1053                         (void) printf(
1054 "\n              ***** SYMBOL TABLE INFORMATION *****\n");
1055                         (void) printf(
1056 "[Index]  %-*s%-*sType\tBind\tOther\tShndx\tName",
1057                             12 + adj, "Value", 9 + adj, "Size");
1058                 }
1059                 (void) printf("\n%s:\n", p_symtab->scn_name);
1060                 print_symtab(elf_file, p_symtab, sym_data, count-1, 1);
1061         }
1062 }
1063 
1064 
1065 /*
1066  * Print dynamic linking information.  Input is an ELF
1067  * file descriptor, the SCNTAB structure, the number of
1068  * sections, and the filename.
1069  */
1070 static void
1071 dump_dynamic(Elf *elf_file, SCNTAB *p_scns, int num_scns, char *filename)
1072 {
1073 #define pdyn_Fmtptr     "%#llx"
1074 
1075         Elf_Data        *dyn_data;
1076         GElf_Dyn        p_dyn;
1077         GElf_Phdr       p_phdr;
1078         GElf_Ehdr       p_ehdr;
1079         int             index = 1;
1080         int             lib_scns = num_scns;
1081         SCNTAB          *l_scns = p_scns;
1082         int             header_num = 0;
1083         const char      *str;
1084 
1085         (void) gelf_getehdr(elf_file, &p_ehdr);
1086 
1087         if (!p_flag)
1088                 (void) printf("\n  **** DYNAMIC SECTION INFORMATION ****\n");
1089 
1090         for (; num_scns > 0; num_scns--, p_scns++) {
1091                 GElf_Word       link;
1092                 int             ii;
1093 
1094 
1095                 if (p_scns->p_shdr.sh_type != SHT_DYNAMIC)
1096                         continue;
1097 
1098                 if (!p_flag) {
1099                         (void) printf("%s:\n", p_scns->scn_name);
1100                         (void) printf("[INDEX]\tTag         Value\n");
1101                 }
1102 
1103                 if ((dyn_data = elf_getdata(p_scns->p_sd, NULL)) == 0) {
1104                         (void) fprintf(stderr, "%s: %s: no data in "
1105                             "%s section\n", prog_name, filename,
1106                             p_scns->scn_name);
1107                         return;
1108                 }
1109 
1110                 link = p_scns->p_shdr.sh_link;
1111                 ii = 0;
1112 
1113                 (void) gelf_getdyn(dyn_data, ii++, &p_dyn);
1114                 while (p_dyn.d_tag != DT_NULL) {
1115                         union {
1116                                 Conv_inv_buf_t          inv;
1117                                 Conv_dyn_flag_buf_t     dyn_flag;
1118                                 Conv_dyn_flag1_buf_t    dyn_flag1;
1119                                 Conv_dyn_feature1_buf_t dyn_feature1;
1120                                 Conv_dyn_posflag1_buf_t dyn_posflag1;
1121                         } conv_buf;
1122 
1123                         (void) printf("[%d]\t%-15.15s ", index++,
1124                             conv_dyn_tag(p_dyn.d_tag,
1125                             p_ehdr.e_ident[EI_OSABI], p_ehdr.e_machine,
1126                             DUMP_CONVFMT, &conv_buf.inv));
1127 
1128                         /*
1129                          * It would be nice to use a table driven loop
1130                          * here, but the address space is too sparse
1131                          * and irregular. A switch is simple and robust.
1132                          */
1133                         switch (p_dyn.d_tag) {
1134                         /*
1135                          * Items with an address value
1136                          */
1137                         case DT_PLTGOT:
1138                         case DT_HASH:
1139                         case DT_STRTAB:
1140                         case DT_RELA:
1141                         case DT_SYMTAB:
1142                         case DT_INIT:
1143                         case DT_FINI:
1144                         case DT_REL:
1145                         case DT_DEBUG:
1146                         case DT_TEXTREL:
1147                         case DT_JMPREL:
1148                         case DT_INIT_ARRAY:
1149                         case DT_FINI_ARRAY:
1150                         case DT_INIT_ARRAYSZ:
1151                         case DT_FINI_ARRAYSZ:
1152                         case DT_PREINIT_ARRAY:
1153                         case DT_PREINIT_ARRAYSZ:
1154                         case DT_SUNW_RTLDINF:
1155                         case DT_SUNW_CAP:
1156                         case DT_SUNW_CAPINFO:
1157                         case DT_SUNW_CAPCHAIN:
1158                         case DT_SUNW_SYMTAB:
1159                         case DT_SUNW_SYMSORT:
1160                         case DT_SUNW_TLSSORT:
1161                         case DT_PLTPAD:
1162                         case DT_MOVETAB:
1163                         case DT_SYMINFO:
1164                         case DT_RELACOUNT:
1165                         case DT_RELCOUNT:
1166                         case DT_VERSYM:
1167                         case DT_VERDEF:
1168                         case DT_VERDEFNUM:
1169                         case DT_VERNEED:
1170                                 (void) printf(pdyn_Fmtptr,
1171                                     EC_ADDR(p_dyn.d_un.d_ptr));
1172                                 break;
1173 
1174                         /*
1175                          * Items with a string value
1176                          */
1177                         case DT_NEEDED:
1178                         case DT_SONAME:
1179                         case DT_RPATH:
1180                         case DT_RUNPATH:
1181                         case DT_SUNW_AUXILIARY:
1182                         case DT_SUNW_FILTER:
1183                         case DT_CONFIG:
1184                         case DT_DEPAUDIT:
1185                         case DT_AUDIT:
1186                         case DT_AUXILIARY:
1187                         case DT_USED:
1188                         case DT_FILTER:
1189                                 if (v_flag) {   /* Look up the string */
1190                                         str = (char *)elf_strptr(elf_file, link,
1191                                             p_dyn.d_un.d_ptr);
1192                                         if (!(str && *str))
1193                                                 str = (char *)UNKNOWN;
1194                                         (void) printf("%s", str);
1195                                 } else {        /* Show the address */
1196                                         (void) printf(pdyn_Fmtptr,
1197                                             EC_ADDR(p_dyn.d_un.d_ptr));
1198                                 }
1199                                 break;
1200 
1201                         /*
1202                          * Items with a literal value
1203                          */
1204                         case DT_PLTRELSZ:
1205                         case DT_RELASZ:
1206                         case DT_RELAENT:
1207                         case DT_STRSZ:
1208                         case DT_SYMENT:
1209                         case DT_RELSZ:
1210                         case DT_RELENT:
1211                         case DT_PLTREL:
1212                         case DT_BIND_NOW:
1213                         case DT_CHECKSUM:
1214                         case DT_PLTPADSZ:
1215                         case DT_MOVEENT:
1216                         case DT_MOVESZ:
1217                         case DT_SYMINSZ:
1218                         case DT_SYMINENT:
1219                         case DT_VERNEEDNUM:
1220                         case DT_SPARC_REGISTER:
1221                         case DT_SUNW_SYMSZ:
1222                         case DT_SUNW_SORTENT:
1223                         case DT_SUNW_SYMSORTSZ:
1224                         case DT_SUNW_TLSSORTSZ:
1225                         case DT_SUNW_STRPAD:
1226                         case DT_SUNW_CAPCHAINENT:
1227                         case DT_SUNW_CAPCHAINSZ:
1228                         case DT_SUNW_ASLR:
1229                                 (void) printf(pdyn_Fmtptr,
1230                                     EC_XWORD(p_dyn.d_un.d_val));
1231                                 break;
1232 
1233                         /*
1234                          * Integer items that are bitmasks, or which
1235                          * can be otherwise formatted in symbolic form.
1236                          */
1237                         case DT_FLAGS:
1238                         case DT_FEATURE_1:
1239                         case DT_POSFLAG_1:
1240                         case DT_FLAGS_1:
1241                         case DT_SUNW_LDMACH:
1242                                 str = NULL;
1243                                 if (v_flag) {
1244                                         switch (p_dyn.d_tag) {
1245                                         case DT_FLAGS:
1246                                                 str = conv_dyn_flag(
1247                                                     p_dyn.d_un.d_val,
1248                                                     DUMP_CONVFMT,
1249                                                     &conv_buf.dyn_flag);
1250                                                 break;
1251                                         case DT_FEATURE_1:
1252                                                 str = conv_dyn_feature1(
1253                                                     p_dyn.d_un.d_val,
1254                                                     DUMP_CONVFMT,
1255                                                     &conv_buf.dyn_feature1);
1256                                                 break;
1257                                         case DT_POSFLAG_1:
1258                                                 str = conv_dyn_posflag1(
1259                                                     p_dyn.d_un.d_val,
1260                                                     DUMP_CONVFMT,
1261                                                     &conv_buf.dyn_posflag1);
1262                                                 break;
1263                                         case DT_FLAGS_1:
1264                                                 str = conv_dyn_flag1(
1265                                                     p_dyn.d_un.d_val, 0,
1266                                                     &conv_buf.dyn_flag1);
1267                                                 break;
1268                                         case DT_SUNW_LDMACH:
1269                                                 str = conv_ehdr_mach(
1270                                                     p_dyn.d_un.d_val, 0,
1271                                                     &conv_buf.inv);
1272                                                 break;
1273                                         }
1274                                 }
1275                                 if (str) {      /* Show as string */
1276                                         (void) printf("%s", str);
1277                                 } else {        /* Numeric form */
1278                                         (void) printf(pdyn_Fmtptr,
1279                                             EC_ADDR(p_dyn.d_un.d_ptr));
1280                                 }
1281                                 break;
1282 
1283                         /*
1284                          * Depreciated items with a literal value
1285                          */
1286                         case DT_DEPRECATED_SPARC_REGISTER:
1287                                 (void) printf(pdyn_Fmtptr
1288                                     "  (deprecated value)",
1289                                     EC_XWORD(p_dyn.d_un.d_val));
1290                                 break;
1291 
1292                         /* Ignored items */
1293                         case DT_SYMBOLIC:
1294                                 (void) printf("(ignored)");
1295                                 break;
1296                         }
1297                         (void) printf("\n");
1298                         (void) gelf_getdyn(dyn_data, ii++, &p_dyn);
1299                 }
1300         }
1301 
1302         /*
1303          * Check for existence of static shared library information.
1304          */
1305         while (header_num < p_ehdr.e_phnum) {
1306                 (void) gelf_getphdr(elf_file, header_num, &p_phdr);
1307                 if (p_phdr.p_type == PT_SHLIB) {
1308                         while (--lib_scns > 0) {
1309                                 if (strcmp(l_scns->scn_name, ".lib") == 0) {
1310                                         print_static(l_scns, filename);
1311                                 }
1312                                 l_scns++;
1313                         }
1314                 }
1315                 header_num++;
1316         }
1317 #undef  pdyn_Fmtptr
1318 }
1319 
1320 /*
1321  * Print the ELF header.  Input is an ELF file descriptor
1322  * and the filename.  If f_flag is set, the ELF header is
1323  * printed to stdout, otherwise the function returns after
1324  * setting the pointer to the ELF header.  Any values which
1325  * are not known are printed in decimal.  Fields must be updated
1326  * as new values are added.
1327  */
1328 static GElf_Ehdr *
1329 dump_elf_header(Elf *elf_file, char *filename, GElf_Ehdr * elf_head_p)
1330 {
1331         int class;
1332         int field;
1333 
1334         if (gelf_getehdr(elf_file, elf_head_p) == NULL) {
1335                 (void) fprintf(stderr, "%s: %s: %s\n", prog_name, filename,
1336                     elf_errmsg(-1));
1337                 return (NULL);
1338         }
1339 
1340         class = (int)elf_head_p->e_ident[4];
1341 
1342         if (class == ELFCLASS64)
1343                 field = 21;
1344         else
1345                 field = 13;
1346 
1347         if (!f_flag)
1348                 return (elf_head_p);
1349 
1350         if (!p_flag) {
1351                 (void) printf("\n                    **** ELF HEADER ****\n");
1352                 (void) printf("%-*s%-11s%-*sMachine     Version\n",
1353                     field, "Class", "Data", field, "Type");
1354                 (void) printf("%-*s%-11s%-*sFlags       Ehsize\n",
1355                     field, "Entry", "Phoff", field, "Shoff");
1356                 (void) printf("%-*s%-11s%-*sShnum       Shstrndx\n\n",
1357                     field, "Phentsize", "Phnum", field, "Shentsz");
1358         }
1359 
1360         if (!v_flag) {
1361                 (void) printf("%-*d%-11d%-*d%-12d%d\n",
1362                     field, elf_head_p->e_ident[4], elf_head_p->e_ident[5],
1363                     field, (int)elf_head_p->e_type, (int)elf_head_p->e_machine,
1364                     elf_head_p->e_version);
1365         } else {
1366                 Conv_inv_buf_t  inv_buf;
1367 
1368                 (void) printf("%-*s", field,
1369                     conv_ehdr_class(class, DUMP_CONVFMT, &inv_buf));
1370                 (void) printf("%-11s",
1371                     conv_ehdr_data(elf_head_p->e_ident[5], DUMP_CONVFMT,
1372                     &inv_buf));
1373                 (void) printf("%-*s", field,
1374                     conv_ehdr_type(elf_head_p->e_ident[EI_OSABI],
1375                     elf_head_p->e_type, DUMP_CONVFMT, &inv_buf));
1376                 (void) printf("%-12s",
1377                     conv_ehdr_mach(elf_head_p->e_machine, DUMP_CONVFMT,
1378                     &inv_buf));
1379                 (void) printf("%s\n",
1380                     conv_ehdr_vers(elf_head_p->e_version, DUMP_CONVFMT,
1381                     &inv_buf));
1382         }
1383         (void) printf("%-#*llx%-#11llx%-#*llx%-#12x%#x\n",
1384             field, EC_ADDR(elf_head_p->e_entry), EC_OFF(elf_head_p->e_phoff),
1385             field, EC_OFF(elf_head_p->e_shoff), EC_WORD(elf_head_p->e_flags),
1386             EC_WORD(elf_head_p->e_ehsize));
1387         if (!v_flag || (elf_head_p->e_shstrndx != SHN_XINDEX)) {
1388                 (void) printf("%-#*x%-11u%-#*x%-12u%u\n",
1389                     field, EC_WORD(elf_head_p->e_phentsize),
1390                     EC_WORD(elf_head_p->e_phnum),
1391                     field, EC_WORD(elf_head_p->e_shentsize),
1392                     EC_WORD(elf_head_p->e_shnum),
1393                     EC_WORD(elf_head_p->e_shstrndx));
1394         } else {
1395                 (void) printf("%-#*x%-11u%-#*x%-12uXINDEX\n",
1396                     field, EC_WORD(elf_head_p->e_phentsize),
1397                     EC_WORD(elf_head_p->e_phnum),
1398                     field, EC_WORD(elf_head_p->e_shentsize),
1399                     EC_WORD(elf_head_p->e_shnum));
1400         }
1401         if ((elf_head_p->e_shnum == 0) && (elf_head_p->e_shoff > 0)) {
1402                 Elf_Scn         *scn;
1403                 GElf_Shdr       shdr0;
1404                 int             field;
1405 
1406                 if (gelf_getclass(elf_file) == ELFCLASS64)
1407                         field = 21;
1408                 else
1409                         field = 13;
1410                 if (!p_flag) {
1411                         (void) printf("\n          **** SECTION HEADER[0] "
1412                             "{Elf Extensions} ****\n");
1413                         (void) printf(
1414                             "[No]\tType\tFlags\t%-*s %-*s%-*s%sName\n",
1415                             field, "Addr", field, "Offset", field,
1416                             "Size(shnum)",
1417                             /* compatibility:  tab for elf32 */
1418                             (field == 13) ? "\t" : "  ");
1419                         (void) printf("\tLn(strndx) Info\t%-*s Entsize\n",
1420                             field, "Adralgn");
1421                 }
1422                 if ((scn = elf_getscn(elf_file, 0)) == NULL) {
1423                         (void) fprintf(stderr,
1424                             "%s: %s: elf_getscn failed: %s\n",
1425                             prog_name, filename, elf_errmsg(-1));
1426                         return (NULL);
1427                 }
1428                 if (gelf_getshdr(scn, &shdr0) == 0) {
1429                         (void) fprintf(stderr,
1430                             "%s: %s: gelf_getshdr: %s\n",
1431                             prog_name, filename, elf_errmsg(-1));
1432                         return (NULL);
1433                 }
1434                 (void) printf("[0]\t%u\t%llu\t", EC_WORD(shdr0.sh_type),
1435                     EC_XWORD(shdr0.sh_flags));
1436 
1437                 (void) printf("%-#*llx %-#*llx%-*llu%s%-*u\n",
1438                     field, EC_ADDR(shdr0.sh_addr),
1439                     field, EC_OFF(shdr0.sh_offset),
1440                     field, EC_XWORD(shdr0.sh_size),
1441                     /* compatibility:  tab for elf32 */
1442                     ((field == 13) ? "\t" : "  "),
1443                     field, EC_WORD(shdr0.sh_name));
1444 
1445                 (void) printf("\t%u\t%u\t%-#*llx %-#*llx\n",
1446                     EC_WORD(shdr0.sh_link),
1447                     EC_WORD(shdr0.sh_info),
1448                     field, EC_XWORD(shdr0.sh_addralign),
1449                     field, EC_XWORD(shdr0.sh_entsize));
1450         }
1451         (void) printf("\n");
1452 
1453         return (elf_head_p);
1454 }
1455 
1456 /*
1457  * Print section contents.  Input is an ELF file descriptor,
1458  * the ELF header, the SCNTAB structure,
1459  * the number of symbols, and the filename.
1460  * The number of sections,
1461  * and the offset into the SCNTAB structure will be
1462  * set in dump_section if d_flag or n_flag are set.
1463  * If v_flag is set, sections which can be interpreted will
1464  * be interpreted, otherwise raw data will be output in hexidecimal.
1465  */
1466 static void
1467 print_section(Elf *elf_file,
1468     GElf_Ehdr *p_ehdr, SCNTAB *p, int num_scns, char *filename)
1469 {
1470         unsigned char    *p_sec;
1471         int     i;
1472         size_t  size;
1473 
1474         for (i = 0; i < num_scns; i++, p++) {
1475                 GElf_Shdr shdr;
1476 
1477                 size = 0;
1478                 if (s_flag && !v_flag)
1479                         p_sec = (unsigned char *)get_rawscn(p->p_sd, &size);
1480                 else
1481                         p_sec = (unsigned char *)get_scndata(p->p_sd, &size);
1482 
1483                 if ((gelf_getshdr(p->p_sd, &shdr) != NULL) &&
1484                     (shdr.sh_type == SHT_NOBITS)) {
1485                         continue;
1486                 }
1487                 if (s_flag && !v_flag) {
1488                         (void) printf("\n%s:\n", p->scn_name);
1489                         print_rawdata(p_sec, size);
1490                         continue;
1491                 }
1492                 if (shdr.sh_type == SHT_SYMTAB) {
1493                         dump_symbol_table(elf_file, p, filename);
1494                         continue;
1495                 }
1496                 if (shdr.sh_type == SHT_DYNSYM) {
1497                         dump_symbol_table(elf_file, p, filename);
1498                         continue;
1499                 }
1500                 if (shdr.sh_type == SHT_STRTAB) {
1501                         dump_string_table(p, 1);
1502                         continue;
1503                 }
1504                 if (shdr.sh_type == SHT_RELA) {
1505                         dump_reloc_table(elf_file, p_ehdr, p, 1, filename);
1506                         continue;
1507                 }
1508                 if (shdr.sh_type == SHT_REL) {
1509                         dump_reloc_table(elf_file, p_ehdr, p, 1, filename);
1510                         continue;
1511                 }
1512                 if (shdr.sh_type == SHT_DYNAMIC) {
1513                         dump_dynamic(elf_file, p, 1, filename);
1514                         continue;
1515                 }
1516 
1517                 (void) printf("\n%s:\n", p->scn_name);
1518                 print_rawdata(p_sec, size);
1519         }
1520         (void) printf("\n");
1521 }
1522 
1523 /*
1524  * Print section contents. This function does not print the contents
1525  * of the sections but sets up the parameters and then calls
1526  * print_section to print the contents.  Calling another function to print
1527  * the contents allows both -d and -n to work correctly
1528  * simultaneously. Input is an ELF file descriptor, the ELF header,
1529  * the SCNTAB structure, the number of sections, and the filename.
1530  * Set the range of sections if d_flag, and set section name if
1531  * n_flag.
1532  */
1533 static void
1534 dump_section(Elf *elf_file,
1535     GElf_Ehdr *p_ehdr, SCNTAB *s, int num_scns, char *filename)
1536 {
1537         SCNTAB *n_range, *d_range; /* for use with -n and -d modifiers */
1538         int i;
1539         int found_it = 0;  /* for use with -n section_name */
1540 
1541         if (n_flag) {
1542                 n_range = s;
1543 
1544                 for (i = 0; i < num_scns; i++, n_range++) {
1545                         if ((strcmp(name, n_range->scn_name)) != 0)
1546                                 continue;
1547                         else {
1548                                 found_it = 1;
1549                                 print_section(elf_file, p_ehdr,
1550                                     n_range, 1, filename);
1551                         }
1552                 }
1553 
1554                 if (!found_it) {
1555                         (void) fprintf(stderr, "%s: %s: %s not found\n",
1556                             prog_name, filename, name);
1557                 }
1558         } /* end n_flag */
1559 
1560         if (d_flag) {
1561                 d_range = s;
1562                 d_num = check_range(d_low, d_hi, num_scns, filename);
1563                 if (d_num < 0)
1564                         return;
1565                 d_range += d_low - 1;
1566 
1567                 print_section(elf_file, p_ehdr, d_range, d_num, filename);
1568         }       /* end d_flag */
1569 
1570         if (!n_flag && !d_flag)
1571                 print_section(elf_file, p_ehdr, s, num_scns, filename);
1572 }
1573 
1574 /*
1575  * Print the section header table. This function does not print the contents
1576  * of the section headers but sets up the parameters and then calls
1577  * print_shdr to print the contents.  Calling another function to print
1578  * the contents allows both -d and -n to work correctly
1579  * simultaneously.  Input is the SCNTAB structure,
1580  * the number of sections from the ELF header, and the filename.
1581  * Set the range of section headers to print if d_flag, and set
1582  * name of section header to print if n_flag.
1583  */
1584 static void
1585 dump_shdr(Elf *elf_file, SCNTAB *s, int num_scns, char *filename)
1586 {
1587 
1588         SCNTAB *n_range, *d_range;      /* for use with -n and -d modifiers */
1589         int field;
1590         int i;
1591         int found_it = 0;  /* for use with -n section_name */
1592 
1593         if (gelf_getclass(elf_file) == ELFCLASS64)
1594                 field = 21;
1595         else
1596                 field = 13;
1597 
1598         if (!p_flag) {
1599                 (void) printf("\n          **** SECTION HEADER TABLE ****\n");
1600                 (void) printf("[No]\tType\tFlags\t%-*s %-*s %-*s%sName\n",
1601                     field, "Addr", field, "Offset", field, "Size",
1602                     /* compatibility:  tab for elf32 */
1603                     (field == 13) ? "\t" : "  ");
1604                 (void) printf("\tLink\tInfo\t%-*s Entsize\n\n",
1605                     field, "Adralgn");
1606         }
1607 
1608         if (n_flag) {
1609                 n_range = s;
1610 
1611                 for (i = 1; i <= num_scns; i++, n_range++) {
1612                         if ((strcmp(name, n_range->scn_name)) != 0)
1613                                 continue;
1614                         else {
1615                                 found_it = 1;
1616                                 print_shdr(elf_file, n_range, 1, i);
1617                         }
1618                 }
1619 
1620                 if (!found_it) {
1621                         (void) fprintf(stderr, "%s: %s: %s not found\n",
1622                             prog_name, filename, name);
1623                 }
1624         } /* end n_flag */
1625 
1626         if (d_flag) {
1627                 d_range = s;
1628                 d_num = check_range(d_low, d_hi, num_scns, filename);
1629                 if (d_num < 0)
1630                         return;
1631                 d_range += d_low - 1;
1632 
1633                 print_shdr(elf_file, d_range, d_num, d_low);
1634         }       /* end d_flag */
1635 
1636         if (!n_flag && !d_flag)
1637                 print_shdr(elf_file, s, num_scns, 1);
1638 }
1639 
1640 /*
1641  * Process all of the command line options (except
1642  * for -a, -g, -f, and -o).  All of the options processed
1643  * by this function require the presence of the section
1644  * header table and will not be processed if it is not present.
1645  * Set up a buffer containing section name, section header,
1646  * and section descriptor for each section in the file.  This
1647  * structure is used to avoid duplicate calls to libelf functions.
1648  * Structure members for the symbol table, the debugging information,
1649  * and the line number information are global.  All of the
1650  * rest are local.
1651  */
1652 static void
1653 dump_section_table(Elf *elf_file, GElf_Ehdr *elf_head_p, char *filename)
1654 {
1655 
1656         static SCNTAB   *buffer, *p_scns;
1657         Elf_Scn         *scn = 0;
1658         char            *s_name = NULL;
1659         int             found = 0;
1660         unsigned int    num_scns;
1661         size_t          shstrndx;
1662         size_t          shnum;
1663 
1664 
1665         if (elf_getshdrnum(elf_file, &shnum) == -1) {
1666                 (void) fprintf(stderr,
1667                     "%s: %s: elf_getshdrnum failed: %s\n",
1668                     prog_name, filename, elf_errmsg(-1));
1669                 return;
1670         }
1671         if (elf_getshdrstrndx(elf_file, &shstrndx) == -1) {
1672                 (void) fprintf(stderr,
1673                     "%s: %s: elf_getshdrstrndx failed: %s\n",
1674                     prog_name, filename, elf_errmsg(-1));
1675                 return;
1676         }
1677 
1678         if ((buffer = calloc(shnum, sizeof (SCNTAB))) == NULL) {
1679                 (void) fprintf(stderr, "%s: %s: cannot calloc space\n",
1680                     prog_name, filename);
1681                 return;
1682         }
1683         /* LINTED */
1684         num_scns = (int)shnum - 1;
1685 
1686         p_symtab = (SCNTAB *)0;
1687         p_dynsym = (SCNTAB *)0;
1688         p_scns = buffer;
1689         p_head_scns = buffer;
1690 
1691         while ((scn = elf_nextscn(elf_file, scn)) != 0) {
1692                 if ((gelf_getshdr(scn, &buffer->p_shdr)) == 0) {
1693                         (void) fprintf(stderr,
1694                             "%s: %s: %s\n", prog_name, filename,
1695                             elf_errmsg(-1));
1696                         return;
1697                 }
1698                 s_name = (char *)
1699                     elf_strptr(elf_file, shstrndx, buffer->p_shdr.sh_name);
1700                 buffer->scn_name = s_name ? s_name : (char *)UNKNOWN;
1701                 buffer->p_sd   =  scn;
1702 
1703                 if (buffer->p_shdr.sh_type == SHT_SYMTAB) {
1704                         found += 1;
1705                         p_symtab = buffer;
1706                 }
1707                 if (buffer->p_shdr.sh_type == SHT_DYNSYM)
1708                         p_dynsym = buffer;
1709                 buffer++;
1710         }
1711 
1712         /*
1713          * These functions depend upon the presence of the section header table
1714          * and will not be invoked in its absence
1715          */
1716         if (h_flag) {
1717                 dump_shdr(elf_file, p_scns, num_scns, filename);
1718         }
1719         if (p_symtab && (t_flag || T_flag)) {
1720                 dump_symbol_table(elf_file, p_symtab, filename);
1721         }
1722         if (c_flag) {
1723                 dump_string_table(p_scns, num_scns);
1724         }
1725         if (r_flag) {
1726                 dump_reloc_table(elf_file, elf_head_p,
1727                     p_scns, num_scns, filename);
1728         }
1729         if (L_flag) {
1730                 dump_dynamic(elf_file, p_scns, num_scns, filename);
1731         }
1732         if (s_flag) {
1733                 dump_section(elf_file, elf_head_p, p_scns,
1734                     num_scns, filename);
1735         }
1736 }
1737 
1738 /*
1739  * Load the archive string table(s) (for extended-length strings)
1740  * into an in-core table/list
1741  */
1742 static struct stab_list_s *
1743 load_arstring_table(struct stab_list_s *STabList,
1744     int fd, Elf *elf_file, Elf_Arhdr *p_ar, char *filename)
1745 {
1746         off_t here;
1747         struct stab_list_s *STL_entry, *STL_next;
1748 
1749         if (p_ar) {
1750                 STL_entry = malloc(sizeof (struct stab_list_s));
1751                 STL_entry->next    = 0;
1752                 STL_entry->strings = 0;
1753                 STL_entry->size    = 0;
1754 
1755                 if (!STabList)
1756                         STabList = STL_entry;
1757                 else {
1758                         STL_next = STabList;
1759                         while (STL_next->next != (void *)0)
1760                                 STL_next = STL_next->next;
1761                         STL_next->next = STL_entry;
1762                 }
1763 
1764                 STL_entry->size    = p_ar->ar_size;
1765                 STL_entry->strings = malloc(p_ar->ar_size);
1766                 here = elf_getbase(elf_file);
1767                 if ((lseek(fd, here, 0)) != here) {
1768                         (void) fprintf(stderr,
1769                             "%s: %s: could not lseek\n", prog_name, filename);
1770                 }
1771 
1772                 if ((read(fd, STL_entry->strings, p_ar->ar_size)) == -1) {
1773                         (void) fprintf(stderr,
1774                             "%s: %s: could not read\n", prog_name, filename);
1775                 }
1776         }
1777         return (STabList);
1778 }
1779 
1780 /*
1781  * Print the archive header for each member of an archive.
1782  * Also call ar_sym_read to print the symbols in the
1783  * archive symbol table if g_flag.  Input is a file descriptor,
1784  * an ELF file descriptor, and the filename.  Putting the call
1785  * to dump the archive symbol table in this function is more
1786  * efficient since it is necessary to examine the archive member
1787  * name in the archive header to determine which member is the
1788  * symbol table.
1789  */
1790 static void
1791 dump_ar_hdr(int fd, Elf *elf_file, char *filename)
1792 {
1793         extern int v_flag, g_flag, a_flag, p_flag;
1794         Elf_Arhdr  *p_ar;
1795         Elf *arf;
1796         Elf_Cmd cmd;
1797         int title = 0;
1798         int err = 0;
1799 
1800         char buf[DATESIZE];
1801 
1802         cmd = ELF_C_READ;
1803         while ((arf = elf_begin(fd, cmd, elf_file)) != 0) {
1804                 p_ar = elf_getarhdr(arf);
1805                 if (p_ar == NULL) {
1806                         (void) fprintf(stderr,
1807                             "%s: %s: %s\n", prog_name, filename,
1808                             elf_errmsg(-1));
1809                         continue;
1810                 }
1811                 if ((strcmp(p_ar->ar_name, "/") == 0) ||
1812                     (strcmp(p_ar->ar_name, "/SYM64/") == 0)) {
1813                         if (g_flag)
1814                                 ar_sym_read(elf_file, filename);
1815                 } else if (strcmp(p_ar->ar_name, "//") == 0) {
1816                         StringTableList = load_arstring_table(
1817                             StringTableList, fd, arf, p_ar, filename);
1818                         cmd = elf_next(arf);
1819                         (void) elf_end(arf);
1820                         continue;
1821                 } else {
1822                         if (a_flag) {
1823                                 (void) printf("%s[%s]:\n", filename,
1824                                     p_ar->ar_name);
1825                                 if (!p_flag && title == 0) {
1826                                         if (!v_flag)
1827                                                 (void) printf(
1828 "\n\n\t\t\t***ARCHIVE HEADER***"
1829 "\n     Date          Uid     Gid    Mode      Size      Member Name\n\n");
1830                                         else
1831                                                 (void) printf(
1832 "\n\n\t\t\t***ARCHIVE HEADER***"
1833 "\n     Date                   Uid    Gid   Mode     Size     Member Name\n\n");
1834                                         title = 1;
1835                                 }
1836                                 if (!v_flag) {
1837                                         (void) printf(
1838 "\t0x%.8lx  %6d  %6d  0%.6ho  0x%.8lx  %-s\n\n",
1839                                             p_ar->ar_date, (int)p_ar->ar_uid,
1840                                             (int)p_ar->ar_gid,
1841                                             (int)p_ar->ar_mode,
1842                                             p_ar->ar_size, p_ar->ar_name);
1843                                 } else {
1844                                         if ((strftime(buf, DATESIZE,
1845                                             "%b %d %H:%M:%S %Y",
1846                                             localtime(
1847                                             &(p_ar->ar_date)))) == 0) {
1848                                                 (void) fprintf(stderr,
1849 "%s: %s: don't have enough space to store the date\n", prog_name, filename);
1850                                                 exit(1);
1851                                         }
1852                                         (void) printf(
1853 "\t%s %6d %6d 0%.6ho 0x%.8lx %-s\n\n",
1854                                             buf, (int)p_ar->ar_uid,
1855                                             (int)p_ar->ar_gid,
1856                                             (int)p_ar->ar_mode,
1857                                             p_ar->ar_size, p_ar->ar_name);
1858                                 }
1859                         }
1860                 }
1861                 cmd = elf_next(arf);
1862                 (void) elf_end(arf);
1863         } /* end while */
1864 
1865         err = elf_errno();
1866         if (err != 0) {
1867                 (void) fprintf(stderr,
1868                     "%s: %s: %s\n", prog_name, filename, elf_errmsg(err));
1869         }
1870 }
1871 
1872 /*
1873  * Process member files of an archive.  This function provides
1874  * a loop through an archive equivalent the processing of
1875  * each_file for individual object files.
1876  */
1877 static void
1878 dump_ar_files(int fd, Elf *elf_file, char *filename)
1879 {
1880         Elf_Arhdr  *p_ar;
1881         Elf *arf;
1882         Elf_Cmd cmd;
1883         Elf_Kind file_type;
1884         GElf_Ehdr elf_head;
1885         char *fullname;
1886 
1887         cmd = ELF_C_READ;
1888         while ((arf = elf_begin(fd, cmd, elf_file)) != 0) {
1889                 size_t  len;
1890 
1891                 p_ar = elf_getarhdr(arf);
1892                 if (p_ar == NULL) {
1893                         (void) fprintf(stderr, "%s: %s: %s\n",
1894                             prog_name, filename, elf_errmsg(-1));
1895                         return;
1896                 }
1897                 if (p_ar->ar_name[0] == '/') {
1898                         cmd = elf_next(arf);
1899                         (void) elf_end(arf);
1900                         continue;
1901                 }
1902 
1903                 len = strlen(filename) + strlen(p_ar->ar_name) + 3;
1904                 if ((fullname = malloc(len)) == NULL)
1905                         return;
1906                 (void) snprintf(fullname, len, "%s[%s]", filename,
1907                     p_ar->ar_name);
1908                 (void) printf("\n%s:\n", fullname);
1909                 file_type = elf_kind(arf);
1910                 if (file_type == ELF_K_ELF) {
1911                         if (dump_elf_header(arf, fullname, &elf_head) == NULL)
1912                                 return;
1913                         if (o_flag)
1914                                 dump_exec_header(arf,
1915                                     (unsigned)elf_head.e_phnum, fullname);
1916                         if (x_flag)
1917                                 dump_section_table(arf, &elf_head, fullname);
1918                 } else {
1919                         (void) fprintf(stderr, "%s: %s: invalid file type\n",
1920                             prog_name, fullname);
1921                         cmd = elf_next(arf);
1922                         (void) elf_end(arf);
1923                         continue;
1924                 }
1925 
1926                 cmd = elf_next(arf);
1927                 (void) elf_end(arf);
1928         } /* end while */
1929 }
1930 
1931 /*
1932  * Takes a filename as input.  Test first for a valid version
1933  * of libelf.a and exit on error.  Process each valid file
1934  * or archive given as input on the command line.  Check
1935  * for file type.  If it is an archive, process the archive-
1936  * specific options first, then files within the archive.
1937  * If it is an ELF object file, process it; otherwise
1938  * warn that it is an invalid file type.
1939  * All options except the archive-specific and program
1940  * execution header are processed in the function, dump_section_table.
1941  */
1942 static void
1943 each_file(char *filename)
1944 {
1945         Elf *elf_file;
1946         GElf_Ehdr elf_head;
1947         int fd;
1948         Elf_Kind   file_type;
1949 
1950         struct stat buf;
1951 
1952         Elf_Cmd cmd;
1953         errno = 0;
1954 
1955         if (stat(filename, &buf) == -1) {
1956                 int     err = errno;
1957                 (void) fprintf(stderr, "%s: %s: %s", prog_name, filename,
1958                     strerror(err));
1959                 return;
1960         }
1961 
1962         if ((fd = open((filename), O_RDONLY)) == -1) {
1963                 (void) fprintf(stderr, "%s: %s: cannot read\n", prog_name,
1964                     filename);
1965                 return;
1966         }
1967         cmd = ELF_C_READ;
1968         if ((elf_file = elf_begin(fd, cmd, (Elf *)0)) == NULL) {
1969                 (void) fprintf(stderr, "%s: %s: %s\n", prog_name, filename,
1970                     elf_errmsg(-1));
1971                 return;
1972         }
1973 
1974         file_type = elf_kind(elf_file);
1975         if (file_type == ELF_K_AR) {
1976                 if (a_flag || g_flag) {
1977                         dump_ar_hdr(fd, elf_file, filename);
1978                         elf_file = elf_begin(fd, cmd, (Elf *)0);
1979                 }
1980                 if (z_flag)
1981                         dump_ar_files(fd, elf_file, filename);
1982         } else {
1983                 if (file_type == ELF_K_ELF) {
1984                         (void) printf("\n%s:\n", filename);
1985                         if (dump_elf_header(elf_file, filename, &elf_head)) {
1986                                 if (o_flag)
1987                                         dump_exec_header(elf_file,
1988                                             (unsigned)elf_head.e_phnum,
1989                                             filename);
1990                                 if (x_flag)
1991                                         dump_section_table(elf_file,
1992                                             &elf_head, filename);
1993                         }
1994                 } else {
1995                         (void) fprintf(stderr, "%s: %s: invalid file type\n",
1996                             prog_name, filename);
1997                 }
1998         }
1999         (void) elf_end(elf_file);
2000         (void) close(fd);
2001 }
2002 
2003 /*
2004  * Sets up flags for command line options given and then
2005  * calls each_file() to process each file.
2006  */
2007 int
2008 main(int argc, char *argv[], char *envp[])
2009 {
2010         char *optstr = OPTSTR; /* option string used by getopt() */
2011         int optchar;
2012 
2013         /*
2014          * Check for a binary that better fits this architecture.
2015          */
2016         (void) conv_check_native(argv, envp);
2017 
2018         prog_name = argv[0];
2019 
2020         (void) setlocale(LC_ALL, "");
2021         while ((optchar = getopt(argc, argv, optstr)) != -1) {
2022                 switch (optchar) {
2023                 case 'a':
2024                         a_flag = 1;
2025                         x_flag = 1;
2026                         break;
2027                 case 'g':
2028                         g_flag = 1;
2029                         x_flag = 1;
2030                         break;
2031                 case 'v':
2032                         v_flag = 1;
2033                         break;
2034                 case 'p':
2035                         p_flag = 1;
2036                         break;
2037                 case 'f':
2038                         f_flag = 1;
2039                         z_flag = 1;
2040                         break;
2041                 case 'o':
2042                         o_flag = 1;
2043                         z_flag = 1;
2044                         break;
2045                 case 'h':
2046                         h_flag = 1;
2047                         x_flag = 1;
2048                         z_flag = 1;
2049                         break;
2050                 case 's':
2051                         s_flag = 1;
2052                         x_flag = 1;
2053                         z_flag = 1;
2054                         break;
2055                 case 'd':
2056                         d_flag = 1;
2057                         x_flag = 1;
2058                         z_flag = 1;
2059                         set_range(optarg, &d_low, &d_hi);
2060                         break;
2061                 case 'n':
2062                         n_flag++;
2063                         x_flag = 1;
2064                         z_flag = 1;
2065                         name = optarg;
2066                         break;
2067                 case 'r':
2068                         r_flag = 1;
2069                         x_flag = 1;
2070                         z_flag = 1;
2071                         break;
2072                 case 't':
2073                         t_flag = 1;
2074                         x_flag = 1;
2075                         z_flag = 1;
2076                         break;
2077                 case 'C':
2078                         C_flag = 1;
2079                         t_flag = 1;
2080                         x_flag = 1;
2081                         z_flag = 1;
2082                         break;
2083                 case 'T':
2084                         T_flag = 1;
2085                         x_flag = 1;
2086                         z_flag = 1;
2087                         set_range(optarg, &T_low, &T_hi);
2088                         break;
2089                 case 'c':
2090                         c_flag = 1;
2091                         x_flag = 1;
2092                         z_flag = 1;
2093                         break;
2094                 case 'L':
2095                         L_flag = 1;
2096                         x_flag = 1;
2097                         z_flag = 1;
2098                         break;
2099                 case 'V':
2100                         V_flag = 1;
2101                         (void) fprintf(stderr, "dump: %s %s\n",
2102                             (const char *)SGU_PKG,
2103                             (const char *)SGU_REL);
2104                         break;
2105                 case '?':
2106                         errflag += 1;
2107                         break;
2108                 default:
2109                         break;
2110                 }
2111         }
2112 
2113         if (errflag || (optind >= argc) || (!z_flag && !x_flag)) {
2114                 if (!(V_flag && (argc == 2))) {
2115                         usage();
2116                         exit(269);
2117                 }
2118         }
2119 
2120         if (elf_version(EV_CURRENT) == EV_NONE) {
2121                 (void) fprintf(stderr, "%s: libelf is out of date\n",
2122                     prog_name);
2123                 exit(101);
2124         }
2125 
2126         while (optind < argc) {
2127                 each_file(argv[optind]);
2128                 optind++;
2129         }
2130         return (0);
2131 }