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                                 (void) printf(pdyn_Fmtptr,
1229                                     EC_XWORD(p_dyn.d_un.d_val));
1230                                 break;
1231 
1232                         /*
1233                          * Integer items that are bitmasks, or which
1234                          * can be otherwise formatted in symbolic form.
1235                          */
1236                         case DT_FLAGS:
1237                         case DT_FEATURE_1:
1238                         case DT_POSFLAG_1:
1239                         case DT_FLAGS_1:
1240                         case DT_SUNW_LDMACH:
1241                                 str = NULL;
1242                                 if (v_flag) {
1243                                         switch (p_dyn.d_tag) {
1244                                         case DT_FLAGS:
1245                                                 str = conv_dyn_flag(
1246                                                     p_dyn.d_un.d_val,
1247                                                     DUMP_CONVFMT,
1248                                                     &conv_buf.dyn_flag);
1249                                                 break;
1250                                         case DT_FEATURE_1:
1251                                                 str = conv_dyn_feature1(
1252                                                     p_dyn.d_un.d_val,
1253                                                     DUMP_CONVFMT,
1254                                                     &conv_buf.dyn_feature1);
1255                                                 break;
1256                                         case DT_POSFLAG_1:
1257                                                 str = conv_dyn_posflag1(
1258                                                     p_dyn.d_un.d_val,
1259                                                     DUMP_CONVFMT,
1260                                                     &conv_buf.dyn_posflag1);
1261                                                 break;
1262                                         case DT_FLAGS_1:
1263                                                 str = conv_dyn_flag1(
1264                                                     p_dyn.d_un.d_val, 0,
1265                                                     &conv_buf.dyn_flag1);
1266                                                 break;
1267                                         case DT_SUNW_LDMACH:
1268                                                 str = conv_ehdr_mach(
1269                                                     p_dyn.d_un.d_val, 0,
1270                                                     &conv_buf.inv);
1271                                                 break;
1272                                         }
1273                                 }
1274                                 if (str) {      /* Show as string */
1275                                         (void) printf("%s", str);
1276                                 } else {        /* Numeric form */
1277                                         (void) printf(pdyn_Fmtptr,
1278                                             EC_ADDR(p_dyn.d_un.d_ptr));
1279                                 }
1280                                 break;
1281 
1282                         /*
1283                          * Depreciated items with a literal value
1284                          */
1285                         case DT_DEPRECATED_SPARC_REGISTER:
1286                                 (void) printf(pdyn_Fmtptr
1287                                     "  (deprecated value)",
1288                                     EC_XWORD(p_dyn.d_un.d_val));
1289                                 break;
1290 
1291                         /* Ignored items */
1292                         case DT_SYMBOLIC:
1293                                 (void) printf("(ignored)");
1294                                 break;
1295                         }
1296                         (void) printf("\n");
1297                         (void) gelf_getdyn(dyn_data, ii++, &p_dyn);
1298                 }
1299         }
1300 
1301         /*
1302          * Check for existence of static shared library information.
1303          */
1304         while (header_num < p_ehdr.e_phnum) {
1305                 (void) gelf_getphdr(elf_file, header_num, &p_phdr);
1306                 if (p_phdr.p_type == PT_SHLIB) {
1307                         while (--lib_scns > 0) {
1308                                 if (strcmp(l_scns->scn_name, ".lib") == 0) {
1309                                         print_static(l_scns, filename);
1310                                 }
1311                                 l_scns++;
1312                         }
1313                 }
1314                 header_num++;
1315         }
1316 #undef  pdyn_Fmtptr
1317 }
1318 
1319 /*
1320  * Print the ELF header.  Input is an ELF file descriptor
1321  * and the filename.  If f_flag is set, the ELF header is
1322  * printed to stdout, otherwise the function returns after
1323  * setting the pointer to the ELF header.  Any values which
1324  * are not known are printed in decimal.  Fields must be updated
1325  * as new values are added.
1326  */
1327 static GElf_Ehdr *
1328 dump_elf_header(Elf *elf_file, char *filename, GElf_Ehdr * elf_head_p)
1329 {
1330         int class;
1331         int field;
1332 
1333         if (gelf_getehdr(elf_file, elf_head_p) == NULL) {
1334                 (void) fprintf(stderr, "%s: %s: %s\n", prog_name, filename,
1335                     elf_errmsg(-1));
1336                 return (NULL);
1337         }
1338 
1339         class = (int)elf_head_p->e_ident[4];
1340 
1341         if (class == ELFCLASS64)
1342                 field = 21;
1343         else
1344                 field = 13;
1345 
1346         if (!f_flag)
1347                 return (elf_head_p);
1348 
1349         if (!p_flag) {
1350                 (void) printf("\n                    **** ELF HEADER ****\n");
1351                 (void) printf("%-*s%-11s%-*sMachine     Version\n",
1352                     field, "Class", "Data", field, "Type");
1353                 (void) printf("%-*s%-11s%-*sFlags       Ehsize\n",
1354                     field, "Entry", "Phoff", field, "Shoff");
1355                 (void) printf("%-*s%-11s%-*sShnum       Shstrndx\n\n",
1356                     field, "Phentsize", "Phnum", field, "Shentsz");
1357         }
1358 
1359         if (!v_flag) {
1360                 (void) printf("%-*d%-11d%-*d%-12d%d\n",
1361                     field, elf_head_p->e_ident[4], elf_head_p->e_ident[5],
1362                     field, (int)elf_head_p->e_type, (int)elf_head_p->e_machine,
1363                     elf_head_p->e_version);
1364         } else {
1365                 Conv_inv_buf_t  inv_buf;
1366 
1367                 (void) printf("%-*s", field,
1368                     conv_ehdr_class(class, DUMP_CONVFMT, &inv_buf));
1369                 (void) printf("%-11s",
1370                     conv_ehdr_data(elf_head_p->e_ident[5], DUMP_CONVFMT,
1371                     &inv_buf));
1372                 (void) printf("%-*s", field,
1373                     conv_ehdr_type(elf_head_p->e_ident[EI_OSABI],
1374                     elf_head_p->e_type, DUMP_CONVFMT, &inv_buf));
1375                 (void) printf("%-12s",
1376                     conv_ehdr_mach(elf_head_p->e_machine, DUMP_CONVFMT,
1377                     &inv_buf));
1378                 (void) printf("%s\n",
1379                     conv_ehdr_vers(elf_head_p->e_version, DUMP_CONVFMT,
1380                     &inv_buf));
1381         }
1382         (void) printf("%-#*llx%-#11llx%-#*llx%-#12x%#x\n",
1383             field, EC_ADDR(elf_head_p->e_entry), EC_OFF(elf_head_p->e_phoff),
1384             field, EC_OFF(elf_head_p->e_shoff), EC_WORD(elf_head_p->e_flags),
1385             EC_WORD(elf_head_p->e_ehsize));
1386         if (!v_flag || (elf_head_p->e_shstrndx != SHN_XINDEX)) {
1387                 (void) printf("%-#*x%-11u%-#*x%-12u%u\n",
1388                     field, EC_WORD(elf_head_p->e_phentsize),
1389                     EC_WORD(elf_head_p->e_phnum),
1390                     field, EC_WORD(elf_head_p->e_shentsize),
1391                     EC_WORD(elf_head_p->e_shnum),
1392                     EC_WORD(elf_head_p->e_shstrndx));
1393         } else {
1394                 (void) printf("%-#*x%-11u%-#*x%-12uXINDEX\n",
1395                     field, EC_WORD(elf_head_p->e_phentsize),
1396                     EC_WORD(elf_head_p->e_phnum),
1397                     field, EC_WORD(elf_head_p->e_shentsize),
1398                     EC_WORD(elf_head_p->e_shnum));
1399         }
1400         if ((elf_head_p->e_shnum == 0) && (elf_head_p->e_shoff > 0)) {
1401                 Elf_Scn         *scn;
1402                 GElf_Shdr       shdr0;
1403                 int             field;
1404 
1405                 if (gelf_getclass(elf_file) == ELFCLASS64)
1406                         field = 21;
1407                 else
1408                         field = 13;
1409                 if (!p_flag) {
1410                         (void) printf("\n          **** SECTION HEADER[0] "
1411                             "{Elf Extensions} ****\n");
1412                         (void) printf(
1413                             "[No]\tType\tFlags\t%-*s %-*s%-*s%sName\n",
1414                             field, "Addr", field, "Offset", field,
1415                             "Size(shnum)",
1416                             /* compatibility:  tab for elf32 */
1417                             (field == 13) ? "\t" : "  ");
1418                         (void) printf("\tLn(strndx) Info\t%-*s Entsize\n",
1419                             field, "Adralgn");
1420                 }
1421                 if ((scn = elf_getscn(elf_file, 0)) == NULL) {
1422                         (void) fprintf(stderr,
1423                             "%s: %s: elf_getscn failed: %s\n",
1424                             prog_name, filename, elf_errmsg(-1));
1425                         return (NULL);
1426                 }
1427                 if (gelf_getshdr(scn, &shdr0) == 0) {
1428                         (void) fprintf(stderr,
1429                             "%s: %s: gelf_getshdr: %s\n",
1430                             prog_name, filename, elf_errmsg(-1));
1431                         return (NULL);
1432                 }
1433                 (void) printf("[0]\t%u\t%llu\t", EC_WORD(shdr0.sh_type),
1434                     EC_XWORD(shdr0.sh_flags));
1435 
1436                 (void) printf("%-#*llx %-#*llx%-*llu%s%-*u\n",
1437                     field, EC_ADDR(shdr0.sh_addr),
1438                     field, EC_OFF(shdr0.sh_offset),
1439                     field, EC_XWORD(shdr0.sh_size),
1440                     /* compatibility:  tab for elf32 */
1441                     ((field == 13) ? "\t" : "  "),
1442                     field, EC_WORD(shdr0.sh_name));
1443 
1444                 (void) printf("\t%u\t%u\t%-#*llx %-#*llx\n",
1445                     EC_WORD(shdr0.sh_link),
1446                     EC_WORD(shdr0.sh_info),
1447                     field, EC_XWORD(shdr0.sh_addralign),
1448                     field, EC_XWORD(shdr0.sh_entsize));
1449         }
1450         (void) printf("\n");
1451 
1452         return (elf_head_p);
1453 }
1454 
1455 /*
1456  * Print section contents.  Input is an ELF file descriptor,
1457  * the ELF header, the SCNTAB structure,
1458  * the number of symbols, and the filename.
1459  * The number of sections,
1460  * and the offset into the SCNTAB structure will be
1461  * set in dump_section if d_flag or n_flag are set.
1462  * If v_flag is set, sections which can be interpreted will
1463  * be interpreted, otherwise raw data will be output in hexidecimal.
1464  */
1465 static void
1466 print_section(Elf *elf_file,
1467         GElf_Ehdr *p_ehdr, SCNTAB *p, int num_scns, char *filename)
1468 {
1469         unsigned char    *p_sec;
1470         int     i;
1471         size_t  size;
1472 
1473         for (i = 0; i < num_scns; i++, p++) {
1474                 GElf_Shdr shdr;
1475 
1476                 size = 0;
1477                 if (s_flag && !v_flag)
1478                         p_sec = (unsigned char *)get_rawscn(p->p_sd, &size);
1479                 else
1480                         p_sec = (unsigned char *)get_scndata(p->p_sd, &size);
1481 
1482                 if ((gelf_getshdr(p->p_sd, &shdr) != NULL) &&
1483                     (shdr.sh_type == SHT_NOBITS)) {
1484                         continue;
1485                 }
1486                 if (s_flag && !v_flag) {
1487                         (void) printf("\n%s:\n", p->scn_name);
1488                         print_rawdata(p_sec, size);
1489                         continue;
1490                 }
1491                 if (shdr.sh_type == SHT_SYMTAB) {
1492                         dump_symbol_table(elf_file, p, filename);
1493                         continue;
1494                 }
1495                 if (shdr.sh_type == SHT_DYNSYM) {
1496                         dump_symbol_table(elf_file, p, filename);
1497                         continue;
1498                 }
1499                 if (shdr.sh_type == SHT_STRTAB) {
1500                         dump_string_table(p, 1);
1501                         continue;
1502                 }
1503                 if (shdr.sh_type == SHT_RELA) {
1504                         dump_reloc_table(elf_file, p_ehdr, p, 1, filename);
1505                         continue;
1506                 }
1507                 if (shdr.sh_type == SHT_REL) {
1508                         dump_reloc_table(elf_file, p_ehdr, p, 1, filename);
1509                         continue;
1510                 }
1511                 if (shdr.sh_type == SHT_DYNAMIC) {
1512                         dump_dynamic(elf_file, p, 1, filename);
1513                         continue;
1514                 }
1515 
1516                 (void) printf("\n%s:\n", p->scn_name);
1517                 print_rawdata(p_sec, size);
1518         }
1519         (void) printf("\n");
1520 }
1521 
1522 /*
1523  * Print section contents. This function does not print the contents
1524  * of the sections but sets up the parameters and then calls
1525  * print_section to print the contents.  Calling another function to print
1526  * the contents allows both -d and -n to work correctly
1527  * simultaneously. Input is an ELF file descriptor, the ELF header,
1528  * the SCNTAB structure, the number of sections, and the filename.
1529  * Set the range of sections if d_flag, and set section name if
1530  * n_flag.
1531  */
1532 static void
1533 dump_section(Elf *elf_file,
1534         GElf_Ehdr *p_ehdr, SCNTAB *s, int num_scns, char *filename)
1535 {
1536         SCNTAB *n_range, *d_range; /* for use with -n and -d modifiers */
1537         int i;
1538         int found_it = 0;  /* for use with -n section_name */
1539 
1540         if (n_flag) {
1541                 n_range = s;
1542 
1543                 for (i = 0; i < num_scns; i++, n_range++) {
1544                         if ((strcmp(name, n_range->scn_name)) != 0)
1545                                 continue;
1546                         else {
1547                                 found_it = 1;
1548                                 print_section(elf_file, p_ehdr,
1549                                     n_range, 1, filename);
1550                         }
1551                 }
1552 
1553                 if (!found_it) {
1554                         (void) fprintf(stderr, "%s: %s: %s not found\n",
1555                             prog_name, filename, name);
1556                 }
1557         } /* end n_flag */
1558 
1559         if (d_flag) {
1560                 d_range = s;
1561                 d_num = check_range(d_low, d_hi, num_scns, filename);
1562                 if (d_num < 0)
1563                         return;
1564                 d_range += d_low - 1;
1565 
1566                 print_section(elf_file, p_ehdr, d_range, d_num, filename);
1567         }       /* end d_flag */
1568 
1569         if (!n_flag && !d_flag)
1570                 print_section(elf_file, p_ehdr, s, num_scns, filename);
1571 }
1572 
1573 /*
1574  * Print the section header table. This function does not print the contents
1575  * of the section headers but sets up the parameters and then calls
1576  * print_shdr to print the contents.  Calling another function to print
1577  * the contents allows both -d and -n to work correctly
1578  * simultaneously.  Input is the SCNTAB structure,
1579  * the number of sections from the ELF header, and the filename.
1580  * Set the range of section headers to print if d_flag, and set
1581  * name of section header to print if n_flag.
1582  */
1583 static void
1584 dump_shdr(Elf *elf_file, SCNTAB *s, int num_scns, char *filename)
1585 {
1586 
1587         SCNTAB *n_range, *d_range;      /* for use with -n and -d modifiers */
1588         int field;
1589         int i;
1590         int found_it = 0;  /* for use with -n section_name */
1591 
1592         if (gelf_getclass(elf_file) == ELFCLASS64)
1593                 field = 21;
1594         else
1595                 field = 13;
1596 
1597         if (!p_flag) {
1598                 (void) printf("\n          **** SECTION HEADER TABLE ****\n");
1599                 (void) printf("[No]\tType\tFlags\t%-*s %-*s %-*s%sName\n",
1600                     field, "Addr", field, "Offset", field, "Size",
1601                     /* compatibility:  tab for elf32 */
1602                     (field == 13) ? "\t" : "  ");
1603                 (void) printf("\tLink\tInfo\t%-*s Entsize\n\n",
1604                     field, "Adralgn");
1605         }
1606 
1607         if (n_flag) {
1608                 n_range = s;
1609 
1610                 for (i = 1; i <= num_scns; i++, n_range++) {
1611                         if ((strcmp(name, n_range->scn_name)) != 0)
1612                                 continue;
1613                         else {
1614                                 found_it = 1;
1615                                 print_shdr(elf_file, n_range, 1, i);
1616                         }
1617                 }
1618 
1619                 if (!found_it) {
1620                         (void) fprintf(stderr, "%s: %s: %s not found\n",
1621                             prog_name, filename, name);
1622                 }
1623         } /* end n_flag */
1624 
1625         if (d_flag) {
1626                 d_range = s;
1627                 d_num = check_range(d_low, d_hi, num_scns, filename);
1628                 if (d_num < 0)
1629                         return;
1630                 d_range += d_low - 1;
1631 
1632                 print_shdr(elf_file, d_range, d_num, d_low);
1633         }       /* end d_flag */
1634 
1635         if (!n_flag && !d_flag)
1636                 print_shdr(elf_file, s, num_scns, 1);
1637 }
1638 
1639 /*
1640  * Process all of the command line options (except
1641  * for -a, -g, -f, and -o).  All of the options processed
1642  * by this function require the presence of the section
1643  * header table and will not be processed if it is not present.
1644  * Set up a buffer containing section name, section header,
1645  * and section descriptor for each section in the file.  This
1646  * structure is used to avoid duplicate calls to libelf functions.
1647  * Structure members for the symbol table, the debugging information,
1648  * and the line number information are global.  All of the
1649  * rest are local.
1650  */
1651 static void
1652 dump_section_table(Elf *elf_file, GElf_Ehdr *elf_head_p, char *filename)
1653 {
1654 
1655         static SCNTAB   *buffer, *p_scns;
1656         Elf_Scn         *scn = 0;
1657         char            *s_name = NULL;
1658         int             found = 0;
1659         unsigned int    num_scns;
1660         size_t          shstrndx;
1661         size_t          shnum;
1662 
1663 
1664         if (elf_getshdrnum(elf_file, &shnum) == -1) {
1665                 (void) fprintf(stderr,
1666                     "%s: %s: elf_getshdrnum failed: %s\n",
1667                     prog_name, filename, elf_errmsg(-1));
1668                 return;
1669         }
1670         if (elf_getshdrstrndx(elf_file, &shstrndx) == -1) {
1671                 (void) fprintf(stderr,
1672                     "%s: %s: elf_getshdrstrndx failed: %s\n",
1673                     prog_name, filename, elf_errmsg(-1));
1674                 return;
1675         }
1676 
1677         if ((buffer = calloc(shnum, sizeof (SCNTAB))) == NULL) {
1678                 (void) fprintf(stderr, "%s: %s: cannot calloc space\n",
1679                     prog_name, filename);
1680                 return;
1681         }
1682         /* LINTED */
1683         num_scns = (int)shnum - 1;
1684 
1685         p_symtab = (SCNTAB *)0;
1686         p_dynsym = (SCNTAB *)0;
1687         p_scns = buffer;
1688         p_head_scns = buffer;
1689 
1690         while ((scn = elf_nextscn(elf_file, scn)) != 0) {
1691                 if ((gelf_getshdr(scn, &buffer->p_shdr)) == 0) {
1692                         (void) fprintf(stderr,
1693                             "%s: %s: %s\n", prog_name, filename,
1694                             elf_errmsg(-1));
1695                         return;
1696                 }
1697                 s_name = (char *)
1698                     elf_strptr(elf_file, shstrndx, buffer->p_shdr.sh_name);
1699                 buffer->scn_name = s_name ? s_name : (char *)UNKNOWN;
1700                 buffer->p_sd   =  scn;
1701 
1702                 if (buffer->p_shdr.sh_type == SHT_SYMTAB) {
1703                         found += 1;
1704                         p_symtab = buffer;
1705                 }
1706                 if (buffer->p_shdr.sh_type == SHT_DYNSYM)
1707                         p_dynsym = buffer;
1708                 buffer++;
1709         }
1710 
1711         /*
1712          * These functions depend upon the presence of the section header table
1713          * and will not be invoked in its absence
1714          */
1715         if (h_flag) {
1716                 dump_shdr(elf_file, p_scns, num_scns, filename);
1717         }
1718         if (p_symtab && (t_flag || T_flag)) {
1719                 dump_symbol_table(elf_file, p_symtab, filename);
1720         }
1721         if (c_flag) {
1722                 dump_string_table(p_scns, num_scns);
1723         }
1724         if (r_flag) {
1725                 dump_reloc_table(elf_file, elf_head_p,
1726                     p_scns, num_scns, filename);
1727         }
1728         if (L_flag) {
1729                 dump_dynamic(elf_file, p_scns, num_scns, filename);
1730         }
1731         if (s_flag) {
1732                 dump_section(elf_file, elf_head_p, p_scns,
1733                     num_scns, filename);
1734         }
1735 }
1736 
1737 /*
1738  * Load the archive string table(s) (for extended-length strings)
1739  * into an in-core table/list
1740  */
1741 static struct stab_list_s *
1742 load_arstring_table(struct stab_list_s *STabList,
1743         int fd, Elf *elf_file, Elf_Arhdr *p_ar, char *filename)
1744 {
1745         off_t here;
1746         struct stab_list_s *STL_entry, *STL_next;
1747 
1748         if (p_ar) {
1749                 STL_entry = malloc(sizeof (struct stab_list_s));
1750                 STL_entry->next    = 0;
1751                 STL_entry->strings = 0;
1752                 STL_entry->size    = 0;
1753 
1754                 if (!STabList)
1755                         STabList = STL_entry;
1756                 else {
1757                         STL_next = STabList;
1758                         while (STL_next->next != (void *)0)
1759                                 STL_next = STL_next->next;
1760                         STL_next->next = STL_entry;
1761                 }
1762 
1763                 STL_entry->size    = p_ar->ar_size;
1764                 STL_entry->strings = malloc(p_ar->ar_size);
1765                 here = elf_getbase(elf_file);
1766                 if ((lseek(fd, here, 0)) != here) {
1767                         (void) fprintf(stderr,
1768                             "%s: %s: could not lseek\n", prog_name, filename);
1769                 }
1770 
1771                 if ((read(fd, STL_entry->strings, p_ar->ar_size)) == -1) {
1772                         (void) fprintf(stderr,
1773                             "%s: %s: could not read\n", prog_name, filename);
1774                 }
1775         }
1776         return (STabList);
1777 }
1778 
1779 /*
1780  * Print the archive header for each member of an archive.
1781  * Also call ar_sym_read to print the symbols in the
1782  * archive symbol table if g_flag.  Input is a file descriptor,
1783  * an ELF file descriptor, and the filename.  Putting the call
1784  * to dump the archive symbol table in this function is more
1785  * efficient since it is necessary to examine the archive member
1786  * name in the archive header to determine which member is the
1787  * symbol table.
1788  */
1789 static void
1790 dump_ar_hdr(int fd, Elf *elf_file, char *filename)
1791 {
1792         extern int v_flag, g_flag, a_flag, p_flag;
1793         Elf_Arhdr  *p_ar;
1794         Elf *arf;
1795         Elf_Cmd cmd;
1796         int title = 0;
1797         int err = 0;
1798 
1799         char buf[DATESIZE];
1800 
1801         cmd = ELF_C_READ;
1802         while ((arf = elf_begin(fd, cmd, elf_file)) != 0) {
1803                 p_ar = elf_getarhdr(arf);
1804                 if (p_ar == NULL) {
1805                         (void) fprintf(stderr,
1806                             "%s: %s: %s\n", prog_name, filename,
1807                             elf_errmsg(-1));
1808                         continue;
1809                 }
1810                 if ((strcmp(p_ar->ar_name, "/") == 0) ||
1811                     (strcmp(p_ar->ar_name, "/SYM64/") == 0)) {
1812                         if (g_flag)
1813                                 ar_sym_read(elf_file, filename);
1814                 } else if (strcmp(p_ar->ar_name, "//") == 0) {
1815                         StringTableList = load_arstring_table(
1816                             StringTableList, fd, arf, p_ar, filename);
1817                         cmd = elf_next(arf);
1818                         (void) elf_end(arf);
1819                         continue;
1820                 } else {
1821                         if (a_flag) {
1822                                 (void) printf("%s[%s]:\n", filename,
1823                                     p_ar->ar_name);
1824                                 if (!p_flag && title == 0) {
1825                                         if (!v_flag)
1826                                                 (void) printf(
1827 "\n\n\t\t\t***ARCHIVE HEADER***"
1828 "\n     Date          Uid     Gid    Mode      Size      Member Name\n\n");
1829                                         else
1830                                                 (void) printf(
1831 "\n\n\t\t\t***ARCHIVE HEADER***"
1832 "\n     Date                   Uid    Gid   Mode     Size     Member Name\n\n");
1833                                         title = 1;
1834                                 }
1835                                 if (!v_flag) {
1836                                         (void) printf(
1837 "\t0x%.8lx  %6d  %6d  0%.6ho  0x%.8lx  %-s\n\n",
1838                                             p_ar->ar_date, (int)p_ar->ar_uid,
1839                                             (int)p_ar->ar_gid,
1840                                             (int)p_ar->ar_mode,
1841                                             p_ar->ar_size, p_ar->ar_name);
1842                                 } else {
1843                                         if ((strftime(buf, DATESIZE,
1844                                             "%b %d %H:%M:%S %Y",
1845                                             localtime(
1846                                             &(p_ar->ar_date)))) == 0) {
1847                                                 (void) fprintf(stderr,
1848 "%s: %s: don't have enough space to store the date\n", prog_name, filename);
1849                                                 exit(1);
1850                                         }
1851                                         (void) printf(
1852 "\t%s %6d %6d 0%.6ho 0x%.8lx %-s\n\n",
1853                                             buf, (int)p_ar->ar_uid,
1854                                             (int)p_ar->ar_gid,
1855                                             (int)p_ar->ar_mode,
1856                                             p_ar->ar_size, p_ar->ar_name);
1857                                 }
1858                         }
1859                 }
1860                 cmd = elf_next(arf);
1861                 (void) elf_end(arf);
1862         } /* end while */
1863 
1864         err = elf_errno();
1865         if (err != 0) {
1866                 (void) fprintf(stderr,
1867                     "%s: %s: %s\n", prog_name, filename, elf_errmsg(err));
1868         }
1869 }
1870 
1871 /*
1872  * Process member files of an archive.  This function provides
1873  * a loop through an archive equivalent the processing of
1874  * each_file for individual object files.
1875  */
1876 static void
1877 dump_ar_files(int fd, Elf *elf_file, char *filename)
1878 {
1879         Elf_Arhdr  *p_ar;
1880         Elf *arf;
1881         Elf_Cmd cmd;
1882         Elf_Kind file_type;
1883         GElf_Ehdr elf_head;
1884         char *fullname;
1885 
1886         cmd = ELF_C_READ;
1887         while ((arf = elf_begin(fd, cmd, elf_file)) != 0) {
1888                 size_t  len;
1889 
1890                 p_ar = elf_getarhdr(arf);
1891                 if (p_ar == NULL) {
1892                         (void) fprintf(stderr, "%s: %s: %s\n",
1893                             prog_name, filename, elf_errmsg(-1));
1894                         return;
1895                 }
1896                 if (p_ar->ar_name[0] == '/') {
1897                         cmd = elf_next(arf);
1898                         (void) elf_end(arf);
1899                         continue;
1900                 }
1901 
1902                 len = strlen(filename) + strlen(p_ar->ar_name) + 3;
1903                 if ((fullname = malloc(len)) == NULL)
1904                         return;
1905                 (void) snprintf(fullname, len, "%s[%s]", filename,
1906                     p_ar->ar_name);
1907                 (void) printf("\n%s:\n", fullname);
1908                 file_type = elf_kind(arf);
1909                 if (file_type == ELF_K_ELF) {
1910                         if (dump_elf_header(arf, fullname, &elf_head) == NULL)
1911                                 return;
1912                         if (o_flag)
1913                                 dump_exec_header(arf,
1914                                     (unsigned)elf_head.e_phnum, fullname);
1915                         if (x_flag)
1916                                 dump_section_table(arf, &elf_head, fullname);
1917                 } else {
1918                         (void) fprintf(stderr, "%s: %s: invalid file type\n",
1919                             prog_name, fullname);
1920                         cmd = elf_next(arf);
1921                         (void) elf_end(arf);
1922                         continue;
1923                 }
1924 
1925                 cmd = elf_next(arf);
1926                 (void) elf_end(arf);
1927         } /* end while */
1928 }
1929 
1930 /*
1931  * Takes a filename as input.  Test first for a valid version
1932  * of libelf.a and exit on error.  Process each valid file
1933  * or archive given as input on the command line.  Check
1934  * for file type.  If it is an archive, process the archive-
1935  * specific options first, then files within the archive.
1936  * If it is an ELF object file, process it; otherwise
1937  * warn that it is an invalid file type.
1938  * All options except the archive-specific and program
1939  * execution header are processed in the function, dump_section_table.
1940  */
1941 static void
1942 each_file(char *filename)
1943 {
1944         Elf *elf_file;
1945         GElf_Ehdr elf_head;
1946         int fd;
1947         Elf_Kind   file_type;
1948 
1949         struct stat buf;
1950 
1951         Elf_Cmd cmd;
1952         errno = 0;
1953 
1954         if (stat(filename, &buf) == -1) {
1955                 int     err = errno;
1956                 (void) fprintf(stderr, "%s: %s: %s", prog_name, filename,
1957                     strerror(err));
1958                 return;
1959         }
1960 
1961         if ((fd = open((filename), O_RDONLY)) == -1) {
1962                 (void) fprintf(stderr, "%s: %s: cannot read\n", prog_name,
1963                     filename);
1964                 return;
1965         }
1966         cmd = ELF_C_READ;
1967         if ((elf_file = elf_begin(fd, cmd, (Elf *)0)) == NULL) {
1968                 (void) fprintf(stderr, "%s: %s: %s\n", prog_name, filename,
1969                     elf_errmsg(-1));
1970                 return;
1971         }
1972 
1973         file_type = elf_kind(elf_file);
1974         if (file_type == ELF_K_AR) {
1975                 if (a_flag || g_flag) {
1976                         dump_ar_hdr(fd, elf_file, filename);
1977                         elf_file = elf_begin(fd, cmd, (Elf *)0);
1978                 }
1979                 if (z_flag)
1980                         dump_ar_files(fd, elf_file, filename);
1981         } else {
1982                 if (file_type == ELF_K_ELF) {
1983                         (void) printf("\n%s:\n", filename);
1984                         if (dump_elf_header(elf_file, filename, &elf_head)) {
1985                                 if (o_flag)
1986                                         dump_exec_header(elf_file,
1987                                             (unsigned)elf_head.e_phnum,
1988                                             filename);
1989                                 if (x_flag)
1990                                         dump_section_table(elf_file,
1991                                             &elf_head, filename);
1992                         }
1993                 } else {
1994                         (void) fprintf(stderr, "%s: %s: invalid file type\n",
1995                             prog_name, filename);
1996                 }
1997         }
1998         (void) elf_end(elf_file);
1999         (void) close(fd);
2000 }
2001 
2002 /*
2003  * Sets up flags for command line options given and then
2004  * calls each_file() to process each file.
2005  */
2006 int
2007 main(int argc, char *argv[], char *envp[])
2008 {
2009         char *optstr = OPTSTR; /* option string used by getopt() */
2010         int optchar;
2011 
2012         /*
2013          * Check for a binary that better fits this architecture.
2014          */
2015         (void) conv_check_native(argv, envp);
2016 
2017         prog_name = argv[0];
2018 
2019         (void) setlocale(LC_ALL, "");
2020         while ((optchar = getopt(argc, argv, optstr)) != -1) {
2021                 switch (optchar) {
2022                 case 'a':
2023                         a_flag = 1;
2024                         x_flag = 1;
2025                         break;
2026                 case 'g':
2027                         g_flag = 1;
2028                         x_flag = 1;
2029                         break;
2030                 case 'v':
2031                         v_flag = 1;
2032                         break;
2033                 case 'p':
2034                         p_flag = 1;
2035                         break;
2036                 case 'f':
2037                         f_flag = 1;
2038                         z_flag = 1;
2039                         break;
2040                 case 'o':
2041                         o_flag = 1;
2042                         z_flag = 1;
2043                         break;
2044                 case 'h':
2045                         h_flag = 1;
2046                         x_flag = 1;
2047                         z_flag = 1;
2048                         break;
2049                 case 's':
2050                         s_flag = 1;
2051                         x_flag = 1;
2052                         z_flag = 1;
2053                         break;
2054                 case 'd':
2055                         d_flag = 1;
2056                         x_flag = 1;
2057                         z_flag = 1;
2058                         set_range(optarg, &d_low, &d_hi);
2059                         break;
2060                 case 'n':
2061                         n_flag++;
2062                         x_flag = 1;
2063                         z_flag = 1;
2064                         name = optarg;
2065                         break;
2066                 case 'r':
2067                         r_flag = 1;
2068                         x_flag = 1;
2069                         z_flag = 1;
2070                         break;
2071                 case 't':
2072                         t_flag = 1;
2073                         x_flag = 1;
2074                         z_flag = 1;
2075                         break;
2076                 case 'C':
2077                         C_flag = 1;
2078                         t_flag = 1;
2079                         x_flag = 1;
2080                         z_flag = 1;
2081                         break;
2082                 case 'T':
2083                         T_flag = 1;
2084                         x_flag = 1;
2085                         z_flag = 1;
2086                         set_range(optarg, &T_low, &T_hi);
2087                         break;
2088                 case 'c':
2089                         c_flag = 1;
2090                         x_flag = 1;
2091                         z_flag = 1;
2092                         break;
2093                 case 'L':
2094                         L_flag = 1;
2095                         x_flag = 1;
2096                         z_flag = 1;
2097                         break;
2098                 case 'V':
2099                         V_flag = 1;
2100                         (void) fprintf(stderr, "dump: %s %s\n",
2101                             (const char *)SGU_PKG,
2102                             (const char *)SGU_REL);
2103                         break;
2104                 case '?':
2105                         errflag += 1;
2106                         break;
2107                 default:
2108                         break;
2109                 }
2110         }
2111 
2112         if (errflag || (optind >= argc) || (!z_flag && !x_flag)) {
2113                 if (!(V_flag && (argc == 2))) {
2114                         usage();
2115                         exit(269);
2116                 }
2117         }
2118 
2119         if (elf_version(EV_CURRENT) == EV_NONE) {
2120                 (void) fprintf(stderr, "%s: libelf is out of date\n",
2121                     prog_name);
2122                 exit(101);
2123         }
2124 
2125         while (optind < argc) {
2126                 each_file(argv[optind]);
2127                 optind++;
2128         }
2129         return (0);
2130 }