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