contrib/elftoolchain/nm/nm.c

   1 /*-
   2  * Copyright (c) 2007 Hyogeol Lee <hyogeollee@gmail.com>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer
  10  *    in this position and unchanged.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include <sys/queue.h>
  28 #include <sys/types.h>
  29 #include <sys/stat.h>
  30 #include <ar.h>
  31 #include <assert.h>
  32 #include <capsicum_helpers.h>
  33 #include <ctype.h>
  34 #include <dwarf.h>
  35 #include <err.h>
  36 #include <errno.h>
  37 #include <fcntl.h>
  38 #include <gelf.h>
  39 #include <getopt.h>
  40 #include <inttypes.h>
  41 #include <libdwarf.h>
  42 #include <libelftc.h>
  43 #include <stdbool.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include <strings.h>
  48 #include <unistd.h>
  49
  50 #include <libcasper.h>
  51 #include <casper/cap_fileargs.h>
  52
  53 #include "_elftc.h"
  54
  55 ELFTC_VCSID("$Id: nm.c 3504 2016-12-17 15:33:16Z kaiwang27 $");
  56
  57 /* symbol information list */
  58 STAILQ_HEAD(sym_head, sym_entry);
  59
  60 struct sym_entry {
  61         char            *name;
  62         GElf_Sym        *sym;
  63         STAILQ_ENTRY(sym_entry) sym_entries;
  64 };
  65
  66 typedef int (*fn_sort)(const void *, const void *);
  67 typedef void (*fn_elem_print)(char, const char *, const GElf_Sym *, const char *);
  68 typedef void (*fn_sym_print)(const GElf_Sym *);
  69 typedef int (*fn_filter)(char, const GElf_Sym *, const char *);
  70
  71 /* output filter list */
  72 static SLIST_HEAD(filter_head, filter_entry) nm_out_filter =
  73     SLIST_HEAD_INITIALIZER(nm_out_filter);
  74
  75 struct filter_entry {
  76         fn_filter       fn;
  77         SLIST_ENTRY(filter_entry) filter_entries;
  78 };
  79
  80 struct sym_print_data {
  81         struct sym_head *headp;
  82         size_t          sh_num, list_num;
  83         const char      *t_table, **s_table, *filename, *objname;
  84 };
  85
  86 struct nm_prog_info {
  87         const char      *name;
  88         const char      *def_filename;
  89 };
  90
  91 /* List for line number information. */
  92 struct line_info_entry {
  93         uint64_t        addr;   /* address */
  94         uint64_t        line;   /* line number */
  95         char            *file;  /* file name with path */
  96         SLIST_ENTRY(line_info_entry) entries;
  97 };
  98 SLIST_HEAD(line_info_head, line_info_entry);
  99
 100 /* List for function line number information. */
 101 struct func_info_entry {
 102         char            *name;  /* function name */
 103         char            *file;  /* file name with path */
 104         uint64_t        lowpc;  /* low address */
 105         uint64_t        highpc; /* high address */
 106         uint64_t        line;   /* line number */
 107         SLIST_ENTRY(func_info_entry) entries;
 108 };
 109 SLIST_HEAD(func_info_head, func_info_entry);
 110
 111 /* List for variable line number information. */
 112 struct var_info_entry {
 113         char            *name;  /* variable name */
 114         char            *file;  /* file name with path */
 115         uint64_t        addr;   /* address */
 116         uint64_t        line;   /* line number */
 117         SLIST_ENTRY(var_info_entry) entries;
 118 };
 119 SLIST_HEAD(var_info_head, var_info_entry);
 120
 121 /* output numric type */
 122 enum radix {
 123         RADIX_OCT,
 124         RADIX_HEX,
 125         RADIX_DEC
 126 };
 127
 128 /* output symbol type, PRINT_SYM_DYN for dynamic symbol only */
 129 enum print_symbol {
 130         PRINT_SYM_SYM,
 131         PRINT_SYM_DYN
 132 };
 133
 134 /* output name type */
 135 enum print_name {
 136         PRINT_NAME_NONE,
 137         PRINT_NAME_FULL,
 138         PRINT_NAME_MULTI
 139 };
 140
 141 struct nm_prog_options {
 142         enum print_symbol       print_symbol;
 143         enum print_name         print_name;
 144         enum radix              t;
 145         int                     demangle_type;
 146         bool                    print_debug;
 147         bool                    print_armap;
 148         int                     print_size;
 149         bool                    debug_line;
 150         int                     def_only;
 151         bool                    undef_only;
 152         int                     sort_size;
 153         bool                    sort_reverse;
 154         int                     no_demangle;
 155
 156         /*
 157          * function pointer to sort symbol list.
 158          * possible function - cmp_name, cmp_none, cmp_size, cmp_value
 159          */
 160         fn_sort                 sort_fn;
 161
 162         /*
 163          * function pointer to print symbol elem.
 164          * possible function - sym_elem_print_all
 165          *                     sym_elem_print_all_portable
 166          *                     sym_elem_print_all_sysv
 167          */
 168         fn_elem_print           elem_print_fn;
 169
 170         fn_sym_print            value_print_fn;
 171         fn_sym_print            size_print_fn;
 172
 173         fileargs_t              *fileargs;
 174 };
 175
 176 #define CHECK_SYM_PRINT_DATA(p) (p->headp == NULL || p->sh_num == 0 ||        \
 177 p->t_table == NULL || p->s_table == NULL || p->filename == NULL)
 178 #define IS_SYM_TYPE(t)          ((t) == '?' || isalpha((t)) != 0)
 179 #define IS_UNDEF_SYM_TYPE(t)    ((t) == 'U' || (t) == 'v' || (t) == 'w')
 180 #define UNUSED(p)               ((void)p)
 181
 182 static int              cmp_name(const void *, const void *);
 183 static int              cmp_none(const void *, const void *);
 184 static int              cmp_size(const void *, const void *);
 185 static int              cmp_value(const void *, const void *);
 186 static void             enter_cap_mode(int, char **);
 187 static void             filter_dest(void);
 188 static int              filter_insert(fn_filter);
 189 static void             get_opt(int *, char ***);
 190 static int              get_sym(Elf *, struct sym_head *, int, size_t, size_t,
 191                             const char *, const char **, int);
 192 static const char *     get_sym_name(Elf *, const GElf_Sym *, size_t,
 193                             const char **, int);
 194 static char             get_sym_type(const GElf_Sym *, const char *);
 195 static void             global_dest(void);
 196 static void             global_init(void);
 197 static bool             is_sec_data(GElf_Shdr *);
 198 static bool             is_sec_debug(const char *);
 199 static bool             is_sec_nobits(GElf_Shdr *);
 200 static bool             is_sec_readonly(GElf_Shdr *);
 201 static bool             is_sec_text(GElf_Shdr *);
 202 static void             print_ar_index(int, Elf *);
 203 static void             print_header(const char *, const char *);
 204 static void             print_version(void);
 205 static int              read_elf(Elf *, const char *, Elf_Kind);
 206 static int              read_object(const char *);
 207 static int              read_files(int, char **);
 208 static void             set_opt_value_print_fn(enum radix);
 209 static int              sym_elem_def(char, const GElf_Sym *, const char *);
 210 static int              sym_elem_global(char, const GElf_Sym *, const char *);
 211 static int              sym_elem_global_static(char, const GElf_Sym *,
 212                             const char *);
 213 static int              sym_elem_nondebug(char, const GElf_Sym *, const char *);
 214 static int              sym_elem_nonzero_size(char, const GElf_Sym *,
 215                             const char *);
 216 static void             sym_elem_print_all(char, const char *,
 217                             const GElf_Sym *, const char *);
 218 static void             sym_elem_print_all_portable(char, const char *,
 219                             const GElf_Sym *, const char *);
 220 static void             sym_elem_print_all_sysv(char, const char *,
 221                             const GElf_Sym *, const char *);
 222 static int              sym_elem_undef(char, const GElf_Sym *, const char *);
 223 static void             sym_list_dest(struct sym_head *);
 224 static int              sym_list_insert(struct sym_head *, const char *,
 225                             const GElf_Sym *);
 226 static void             sym_list_print(struct sym_print_data *,
 227                             struct func_info_head *, struct var_info_head *,
 228                             struct line_info_head *);
 229 static void             sym_list_print_each(struct sym_entry *,
 230                             struct sym_print_data *, struct func_info_head *,
 231                             struct var_info_head *, struct line_info_head *);
 232 static struct sym_entry *sym_list_sort(struct sym_print_data *);
 233 static void             sym_size_oct_print(const GElf_Sym *);
 234 static void             sym_size_hex_print(const GElf_Sym *);
 235 static void             sym_size_dec_print(const GElf_Sym *);
 236 static void             sym_value_oct_print(const GElf_Sym *);
 237 static void             sym_value_hex_print(const GElf_Sym *);
 238 static void             sym_value_dec_print(const GElf_Sym *);
 239 static void             usage(int);
 240
 241 static struct nm_prog_info      nm_info;
 242 static struct nm_prog_options   nm_opts;
 243 static int                      nm_elfclass;
 244
 245 /*
 246  * Point to current sym_print_data to use portable qsort function.
 247  *  (e.g. There is no qsort_r function in NetBSD.)
 248  *
 249  * Using in sym_list_sort.
 250  */
 251 static struct sym_print_data    *nm_print_data;
 252
 253 static const struct option nm_longopts[] = {
 254         { "debug-syms",         no_argument,            NULL,           'a' },
 255         { "defined-only",       no_argument,            &nm_opts.def_only, 1},
 256         { "demangle",           optional_argument,      NULL,           'C' },
 257         { "dynamic",            no_argument,            NULL,           'D' },
 258         { "extern-only",        no_argument,            NULL,           'g' },
 259         { "format",             required_argument,      NULL,           'F' },
 260         { "help",               no_argument,            NULL,           'h' },
 261         { "line-numbers",       no_argument,            NULL,           'l' },
 262         { "no-demangle",        no_argument,            &nm_opts.no_demangle,
 263           1},
 264         { "no-sort",            no_argument,            NULL,           'p' },
 265         { "numeric-sort",       no_argument,            NULL,           'v' },
 266         { "print-armap",        no_argument,            NULL,           's' },
 267         { "print-file-name",    no_argument,            NULL,           'A' },
 268         { "print-size",         no_argument,            NULL,           'S' },
 269         { "radix",              required_argument,      NULL,           't' },
 270         { "reverse-sort",       no_argument,            NULL,           'r' },
 271         { "size-sort",          no_argument,            &nm_opts.sort_size, 1},
 272         { "undefined-only",     no_argument,            NULL,           'u' },
 273         { "version",            no_argument,            NULL,           'V' },
 274         { NULL,                 0,                      NULL,           0   }
 275 };
 276
 277 #if defined(ELFTC_NEED_BYTEORDER_EXTENSIONS)
 278 static __inline uint32_t
 279 be32dec(const void *pp)
 280 {
 281         unsigned char const *p = (unsigned char const *)pp;
 282
 283         return ((p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]);
 284 }
 285
 286 static __inline uint32_t
 287 le32dec(const void *pp)
 288 {
 289         unsigned char const *p = (unsigned char const *)pp;
 290
 291         return ((p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0]);
 292 }
 293
 294 static __inline uint64_t
 295 be64dec(const void *pp)
 296 {
 297         unsigned char const *p = (unsigned char const *)pp;
 298
 299         return (((uint64_t)be32dec(p) << 32) | be32dec(p + 4));
 300 }
 301
 302 static __inline uint64_t
 303 le64dec(const void *pp)
 304 {
 305         unsigned char const *p = (unsigned char const *)pp;
 306
 307         return (((uint64_t)le32dec(p + 4) << 32) | le32dec(p));
 308 }
 309 #endif
 310
 311 static int
 312 cmp_name(const void *l, const void *r)
 313 {
 314
 315         assert(l != NULL);
 316         assert(r != NULL);
 317         assert(((const struct sym_entry *)l)->name != NULL);
 318         assert(((const struct sym_entry *)r)->name != NULL);
 319
 320         return (strcmp(((const struct sym_entry *)l)->name,
 321             ((const struct sym_entry *)r)->name));
 322 }
 323
 324 static int
 325 cmp_none(const void *l, const void *r)
 326 {
 327
 328         UNUSED(l);
 329         UNUSED(r);
 330
 331         return (0);
 332 }
 333
 334 /* Size comparison. If l and r have same size, compare their name. */
 335 static int
 336 cmp_size(const void *lp, const void *rp)
 337 {
 338         const struct sym_entry *l, *r;
 339
 340         l = lp;
 341         r = rp;
 342
 343         assert(l != NULL);
 344         assert(l->name != NULL);
 345         assert(l->sym != NULL);
 346         assert(r != NULL);
 347         assert(r->name != NULL);
 348         assert(r->sym != NULL);
 349
 350         if (l->sym->st_size == r->sym->st_size)
 351                 return (strcmp(l->name, r->name));
 352
 353         return (l->sym->st_size - r->sym->st_size);
 354 }
 355
 356 /* Value comparison. Undefined symbols come first. */
 357 static int
 358 cmp_value(const void *lp, const void *rp)
 359 {
 360         const struct sym_entry *l, *r;
 361         const char *ttable;
 362         int l_is_undef, r_is_undef;
 363
 364         l = lp;
 365         r = rp;
 366
 367         assert(nm_print_data != NULL);
 368         ttable = nm_print_data->t_table;
 369
 370         assert(l != NULL);
 371         assert(l->name != NULL);
 372         assert(l->sym != NULL);
 373         assert(r != NULL);
 374         assert(r->name != NULL);
 375         assert(r->sym != NULL);
 376         assert(ttable != NULL);
 377
 378         l_is_undef = IS_UNDEF_SYM_TYPE(get_sym_type(l->sym, ttable)) ? 1 : 0;
 379         r_is_undef = IS_UNDEF_SYM_TYPE(get_sym_type(r->sym, ttable)) ? 1 : 0;
 380
 381         assert(l_is_undef + r_is_undef >= 0);
 382         assert(l_is_undef + r_is_undef <= 2);
 383
 384         switch (l_is_undef + r_is_undef) {
 385         case 0:
 386                 /* Both defined */
 387                 if (l->sym->st_value == r->sym->st_value)
 388                         return (strcmp(l->name, r->name));
 389                 return (l->sym->st_value > r->sym->st_value ? 1 : -1);
 390         case 1:
 391                 /* One undefined */
 392                 return (l_is_undef == 0 ? 1 : -1);
 393         case 2:
 394                 /* Both undefined */
 395                 return (strcmp(l->name, r->name));
 396         }
 397         /* NOTREACHED */
 398
 399         return (l->sym->st_value - r->sym->st_value);
 400 }
 401
 402 static void
 403 enter_cap_mode(int argc, char **argv)
 404 {
 405         cap_rights_t rights;
 406         fileargs_t *fa;
 407         char *defaultfn;
 408
 409         cap_rights_init(&rights, CAP_FSTAT, CAP_MMAP_R);
 410
 411         if (argc == 0) {
 412                 defaultfn = strdup(nm_info.def_filename);
 413                 if (defaultfn == NULL)
 414                         err(EXIT_FAILURE, "strdup");
 415                 argc = 1;
 416                 argv = &defaultfn;
 417         }
 418
 419         fa = fileargs_init(argc, argv, O_RDONLY, 0, &rights, FA_OPEN);
 420         if (fa == NULL)
 421                 err(EXIT_FAILURE, "failed to initialize fileargs");
 422
 423         caph_cache_catpages();
 424         if (caph_limit_stdio() < 0)
 425                 err(EXIT_FAILURE, "failed to limit stdio rights");
 426         if (caph_enter_casper() < 0)
 427                 err(EXIT_FAILURE, "failed to enter capability mode");
 428
 429         nm_opts.fileargs = fa;
 430 }
 431
 432 static void
 433 filter_dest(void)
 434 {
 435         struct filter_entry *e;
 436
 437         while (!SLIST_EMPTY(&nm_out_filter)) {
 438                 e = SLIST_FIRST(&nm_out_filter);
 439                 SLIST_REMOVE_HEAD(&nm_out_filter, filter_entries);
 440                 free(e);
 441         }
 442 }
 443
 444 static int
 445 filter_insert(fn_filter filter_fn)
 446 {
 447         struct filter_entry *e;
 448
 449         assert(filter_fn != NULL);
 450
 451         if ((e = malloc(sizeof(struct filter_entry))) == NULL) {
 452                 warn("malloc");
 453                 return (0);
 454         }
 455         e->fn = filter_fn;
 456         SLIST_INSERT_HEAD(&nm_out_filter, e, filter_entries);
 457
 458         return (1);
 459 }
 460
 461 static int
 462 parse_demangle_option(const char *opt)
 463 {
 464
 465         if (opt == NULL)
 466                 return (ELFTC_DEM_UNKNOWN);
 467         else if (!strncasecmp(opt, "gnu-v2", 6))
 468                 return (ELFTC_DEM_GNU2);
 469         else if (!strncasecmp(opt, "gnu-v3", 6))
 470                 return (ELFTC_DEM_GNU3);
 471         else if (!strncasecmp(opt, "arm", 3))
 472                 return (ELFTC_DEM_ARM);
 473         else
 474                 errx(EXIT_FAILURE, "unknown demangling style '%s'", opt);
 475
 476         /* NOTREACHED */
 477         return (0);
 478 }
 479
 480 static void
 481 get_opt(int *argc, char ***argv)
 482 {
 483         int ch;
 484         bool is_posix, oflag;
 485
 486         if (*argc <= 0 || *argv == NULL)
 487                 return;
 488
 489         oflag = is_posix = false;
 490         nm_opts.t = RADIX_HEX;
 491         while ((ch = getopt_long(*argc, *argv, "ABCDF:PSVaefghlnoprst:uvx",
 492             nm_longopts, NULL)) != -1) {
 493                 switch (ch) {
 494                 case 'A':
 495                         nm_opts.print_name = PRINT_NAME_FULL;
 496                         break;
 497                 case 'B':
 498                         nm_opts.elem_print_fn = &sym_elem_print_all;
 499                         break;
 500                 case 'C':
 501                         nm_opts.demangle_type = parse_demangle_option(optarg);
 502                         break;
 503                 case 'D':
 504                         nm_opts.print_symbol = PRINT_SYM_DYN;
 505                         break;
 506                 case 'F':
 507                         /* sysv, bsd, posix */
 508                         switch (optarg[0]) {
 509                         case 'B':
 510                         case 'b':
 511                                 nm_opts.elem_print_fn = &sym_elem_print_all;
 512                                 break;
 513                         case 'P':
 514                         case 'p':
 515                                 is_posix = true;
 516                                 nm_opts.elem_print_fn =
 517                                     &sym_elem_print_all_portable;
 518                                 break;
 519                         case 'S':
 520                         case 's':
 521                                 nm_opts.elem_print_fn =
 522                                     &sym_elem_print_all_sysv;
 523                                 break;
 524                         default:
 525                                 warnx("%s: Invalid format", optarg);
 526                                 usage(1);
 527                         }
 528
 529                         break;
 530                 case 'P':
 531                         is_posix = true;
 532                         nm_opts.elem_print_fn = &sym_elem_print_all_portable;
 533                         break;
 534                 case 'S':
 535                         nm_opts.print_size = 1;
 536                         break;
 537                 case 'V':
 538                         print_version();
 539                         /* NOTREACHED */
 540                 case 'a':
 541                         nm_opts.print_debug = true;
 542                         break;
 543                 case 'e':
 544                         filter_insert(sym_elem_global_static);
 545                         break;
 546                 case 'f':
 547                         break;
 548                 case 'g':
 549                         filter_insert(sym_elem_global);
 550                         break;
 551                 case 'h':
 552                         usage(0);
 553                         break;
 554                 case 'l':
 555                         nm_opts.debug_line = true;
 556                         break;
 557                 case 'n':
 558                 case 'v':
 559                         nm_opts.sort_fn = &cmp_value;
 560                         break;
 561                 case 'o':
 562                         oflag = true;
 563                         break;
 564                 case 'p':
 565                         nm_opts.sort_fn = &cmp_none;
 566                         break;
 567                 case 'r':
 568                         nm_opts.sort_reverse = true;
 569                         break;
 570                 case 's':
 571                         nm_opts.print_armap = true;
 572                         break;
 573                 case 't':
 574                         /* t require always argument to getopt_long */
 575                         switch (optarg[0]) {
 576                         case 'd':
 577                                 nm_opts.t = RADIX_DEC;
 578                                 break;
 579                         case 'o':
 580                                 nm_opts.t = RADIX_OCT;
 581                                 break;
 582                         case 'x':
 583                                 nm_opts.t = RADIX_HEX;
 584                                 break;
 585                         default:
 586                                 warnx("%s: Invalid radix", optarg);
 587                                 usage(1);
 588                         }
 589                         break;
 590                 case 'u':
 591                         filter_insert(sym_elem_undef);
 592                         nm_opts.undef_only = true;
 593                         break;
 594                 /* case 'v': see case 'n' above. */
 595                 case 'x':
 596                         nm_opts.t = RADIX_HEX;
 597                         break;
 598                 case 0:
 599                         if (nm_opts.sort_size != 0) {
 600                                 nm_opts.sort_fn = &cmp_size;
 601                                 filter_insert(sym_elem_def);
 602                                 filter_insert(sym_elem_nonzero_size);
 603                         }
 604                         if (nm_opts.def_only != 0)
 605                                 filter_insert(sym_elem_def);
 606                         if (nm_opts.no_demangle != 0)
 607                                 nm_opts.demangle_type = -1;
 608                         break;
 609                 default :
 610                         usage(1);
 611                 }
 612         }
 613         *argc -= optind;
 614         *argv += optind;
 615
 616         /*
 617          * In POSIX mode, the '-o' option controls the output radix.
 618          * In non-POSIX mode, the option is a synonym for the '-A' and
 619          * '--print-file-name' options.
 620          */
 621         if (oflag) {
 622                 if (is_posix)
 623                         nm_opts.t = RADIX_OCT;
 624                 else
 625                         nm_opts.print_name = PRINT_NAME_FULL;
 626         }
 627
 628         assert(nm_opts.sort_fn != NULL && "nm_opts.sort_fn is null");
 629         assert(nm_opts.elem_print_fn != NULL &&
 630             "nm_opts.elem_print_fn is null");
 631         assert(nm_opts.value_print_fn != NULL &&
 632             "nm_opts.value_print_fn is null");
 633
 634         set_opt_value_print_fn(nm_opts.t);
 635
 636         if (nm_opts.undef_only == true) {
 637                 if (nm_opts.sort_fn == &cmp_size)
 638                         errx(EXIT_FAILURE,
 639                             "--size-sort with -u is meaningless");
 640                 if (nm_opts.def_only != 0)
 641                         errx(EXIT_FAILURE,
 642                             "-u with --defined-only is meaningless");
 643         }
 644         if (nm_opts.print_debug == false)
 645                 filter_insert(sym_elem_nondebug);
 646         if (nm_opts.sort_reverse == true && nm_opts.sort_fn == cmp_none)
 647                 nm_opts.sort_reverse = false;
 648 }
 649
 650 /*
 651  * Get symbol information from elf.
 652  */
 653 static int
 654 get_sym(Elf *elf, struct sym_head *headp, int shnum, size_t dynndx,
 655     size_t strndx, const char *type_table, const char **sec_table,
 656     int sec_table_size)
 657 {
 658         Elf_Scn *scn;
 659         Elf_Data *data;
 660         GElf_Shdr shdr;
 661         GElf_Sym sym;
 662         struct filter_entry *fep;
 663         size_t ndx;
 664         int rtn;
 665         const char *sym_name;
 666         char type;
 667         bool filter;
 668         int i, j;
 669
 670         assert(elf != NULL);
 671         assert(headp != NULL);
 672
 673         rtn = 0;
 674         for (i = 1; i < shnum; i++) {
 675                 if ((scn = elf_getscn(elf, i)) == NULL) {
 676                         warnx("elf_getscn failed: %s", elf_errmsg(-1));
 677                         continue;
 678                 }
 679                 if (gelf_getshdr(scn, &shdr) != &shdr) {
 680                         warnx("gelf_getshdr failed: %s", elf_errmsg(-1));
 681                         continue;
 682                 }
 683                 if (shdr.sh_type == SHT_SYMTAB) {
 684                         if (nm_opts.print_symbol != PRINT_SYM_SYM)
 685                                 continue;
 686                 } else if (shdr.sh_type == SHT_DYNSYM) {
 687                         if (nm_opts.print_symbol != PRINT_SYM_DYN)
 688                                 continue;
 689                 } else
 690                         continue;
 691
 692                 ndx = shdr.sh_type == SHT_DYNSYM ? dynndx : strndx;
 693
 694                 data = NULL;
 695                 while ((data = elf_getdata(scn, data)) != NULL) {
 696                         j = 1;
 697                         while (gelf_getsym(data, j++, &sym) != NULL) {
 698                                 sym_name = get_sym_name(elf, &sym, ndx,
 699                                     sec_table, sec_table_size);
 700                                 filter = false;
 701                                 type = get_sym_type(&sym, type_table);
 702                                 SLIST_FOREACH(fep, &nm_out_filter,
 703                                     filter_entries) {
 704                                         if (!fep->fn(type, &sym, sym_name)) {
 705                                                 filter = true;
 706                                                 break;
 707                                         }
 708                                 }
 709                                 if (filter == false) {
 710                                         if (sym_list_insert(headp, sym_name,
 711                                             &sym) == 0)
 712                                                 return (0);
 713                                         rtn++;
 714                                 }
 715                         }
 716                 }
 717         }
 718
 719         return (rtn);
 720 }
 721
 722 static const char *
 723 get_sym_name(Elf *elf, const GElf_Sym *sym, size_t ndx, const char **sec_table,
 724     int sec_table_size)
 725 {
 726         const char *sym_name;
 727
 728         sym_name = NULL;
 729
 730         /* Show section name as symbol name for STT_SECTION symbols. */
 731         if (GELF_ST_TYPE(sym->st_info) == STT_SECTION) {
 732                 if (sec_table != NULL && sym->st_shndx < sec_table_size)
 733                         sym_name = sec_table[sym->st_shndx];
 734         } else
 735                 sym_name = elf_strptr(elf, ndx, sym->st_name);
 736
 737         if (sym_name == NULL)
 738                 sym_name = "(null)";
 739
 740         return (sym_name);
 741 }
 742
 743 static char
 744 get_sym_type(const GElf_Sym *sym, const char *type_table)
 745 {
 746         bool is_local;
 747
 748         if (sym == NULL || type_table == NULL)
 749                 return ('?');
 750
 751         is_local = sym->st_info >> 4 == STB_LOCAL;
 752
 753         if (sym->st_shndx == SHN_ABS) /* absolute */
 754                 return (is_local ? 'a' : 'A');
 755
 756         if (sym->st_shndx == SHN_COMMON) /* common */
 757                 return ('C');
 758
 759         if ((sym->st_info) >> 4 == STB_WEAK) { /* weak */
 760                 if ((sym->st_info & 0xf) == STT_OBJECT)
 761                         return (sym->st_shndx == SHN_UNDEF ? 'v' : 'V');
 762
 763                 return (sym->st_shndx == SHN_UNDEF ? 'w' : 'W');
 764         }
 765
 766         if (sym->st_shndx == SHN_UNDEF) /* undefined */
 767                 return ('U');
 768
 769         return (is_local == true && type_table[sym->st_shndx] != 'N' ?
 770             tolower((unsigned char) type_table[sym->st_shndx]) :
 771             type_table[sym->st_shndx]);
 772 }
 773
 774 static void
 775 global_dest(void)
 776 {
 777
 778         filter_dest();
 779 }
 780
 781 static void
 782 global_init(void)
 783 {
 784
 785         if (elf_version(EV_CURRENT) == EV_NONE)
 786                 errx(EXIT_FAILURE, "elf_version error");
 787
 788         nm_info.name = ELFTC_GETPROGNAME();
 789         nm_info.def_filename = "a.out";
 790         nm_opts.print_symbol = PRINT_SYM_SYM;
 791         nm_opts.print_name = PRINT_NAME_NONE;
 792         nm_opts.demangle_type = -1;
 793         nm_opts.print_debug = false;
 794         nm_opts.print_armap = false;
 795         nm_opts.print_size = 0;
 796         nm_opts.debug_line = false;
 797         nm_opts.def_only = 0;
 798         nm_opts.undef_only = false;
 799         nm_opts.sort_size = 0;
 800         nm_opts.sort_reverse = false;
 801         nm_opts.no_demangle = 0;
 802         nm_opts.sort_fn = &cmp_name;
 803         nm_opts.elem_print_fn = &sym_elem_print_all;
 804         nm_opts.value_print_fn = &sym_value_dec_print;
 805         nm_opts.size_print_fn = &sym_size_dec_print;
 806         nm_opts.fileargs = NULL;
 807         SLIST_INIT(&nm_out_filter);
 808 }
 809
 810 static bool
 811 is_sec_data(GElf_Shdr *s)
 812 {
 813
 814         assert(s != NULL && "shdr is NULL");
 815
 816         return (((s->sh_flags & SHF_ALLOC) != 0) && s->sh_type != SHT_NOBITS);
 817 }
 818
 819 static bool
 820 is_sec_debug(const char *shname)
 821 {
 822         const char *dbg_sec[] = {
 823                 ".debug",
 824                 ".gnu.linkonce.wi.",
 825                 ".line",
 826                 ".rel.debug",
 827                 ".rela.debug",
 828                 ".stab",
 829                 NULL
 830         };
 831         const char **p;
 832
 833         if (shname == NULL)
 834                 return (false);
 835
 836         for (p = dbg_sec; *p; p++) {
 837                 if (!strncmp(shname, *p, strlen(*p)))
 838                         return (true);
 839         }
 840
 841         return (false);
 842 }
 843
 844 static bool
 845 is_sec_nobits(GElf_Shdr *s)
 846 {
 847
 848         assert(s != NULL && "shdr is NULL");
 849
 850         return (s->sh_type == SHT_NOBITS);
 851 }
 852
 853 static bool
 854 is_sec_readonly(GElf_Shdr *s)
 855 {
 856
 857         assert(s != NULL && "shdr is NULL");
 858
 859         return ((s->sh_flags & SHF_WRITE) == 0);
 860 }
 861
 862 static bool
 863 is_sec_text(GElf_Shdr *s)
 864 {
 865
 866         assert(s != NULL && "shdr is NULL");
 867
 868         return ((s->sh_flags & SHF_EXECINSTR) != 0);
 869 }
 870
 871 static void
 872 print_ar_index(int fd, Elf *arf)
 873 {
 874         Elf *elf;
 875         Elf_Arhdr *arhdr;
 876         Elf_Arsym *arsym;
 877         Elf_Cmd cmd;
 878         off_t start;
 879         size_t arsym_size;
 880
 881         if (arf == NULL)
 882                 return;
 883
 884         if ((arsym = elf_getarsym(arf, &arsym_size)) == NULL)
 885                 return;
 886
 887         printf("\nArchive index:\n");
 888
 889         start = arsym->as_off;
 890         cmd = ELF_C_READ;
 891         while (arsym_size > 1) {
 892                 if (elf_rand(arf, arsym->as_off) == arsym->as_off &&
 893                     (elf = elf_begin(fd, cmd, arf)) != NULL) {
 894                         if ((arhdr = elf_getarhdr(elf)) != NULL)
 895                                 printf("%s in %s\n", arsym->as_name,
 896                                     arhdr->ar_name != NULL ?
 897                                     arhdr->ar_name : arhdr->ar_rawname);
 898                         elf_end(elf);
 899                 }
 900                 ++arsym;
 901                 --arsym_size;
 902         }
 903
 904         elf_rand(arf, start);
 905 }
 906
 907 #define DEMANGLED_BUFFER_SIZE   (8 * 1024)
 908 #define PRINT_DEMANGLED_NAME(FORMAT, NAME) do {                         \
 909         char _demangled[DEMANGLED_BUFFER_SIZE];                         \
 910         if (nm_opts.demangle_type < 0 ||                                \
 911             elftc_demangle((NAME), _demangled, sizeof(_demangled),      \
 912                 nm_opts.demangle_type) < 0)                             \
 913                 printf((FORMAT), (NAME));                               \
 914         else                                                            \
 915                 printf((FORMAT), _demangled);                           \
 916         } while (0)
 917
 918 static void
 919 print_header(const char *file, const char *obj)
 920 {
 921
 922         if (file == NULL)
 923                 return;
 924
 925         if (nm_opts.elem_print_fn == &sym_elem_print_all_sysv) {
 926                 printf("\n\n%s from %s",
 927                     nm_opts.undef_only == false ? "Symbols" :
 928                     "Undefined symbols", file);
 929                 if (obj != NULL)
 930                         printf("[%s]", obj);
 931                 printf(":\n\n");
 932
 933                 printf("\
 934 Name                  Value           Class        Type         Size             Line  Section\n\n");
 935         } else {
 936                 /* archive file without -A option and POSIX */
 937                 if (nm_opts.print_name != PRINT_NAME_FULL && obj != NULL) {
 938                         if (nm_opts.elem_print_fn ==
 939                             sym_elem_print_all_portable)
 940                                 printf("%s[%s]:\n", file, obj);
 941                         else if (nm_opts.elem_print_fn == sym_elem_print_all)
 942                                 printf("\n%s:\n", obj);
 943                         /* multiple files(not archive) without -A option */
 944                 } else if (nm_opts.print_name == PRINT_NAME_MULTI) {
 945                         if (nm_opts.elem_print_fn == sym_elem_print_all)
 946                                 printf("\n");
 947                         printf("%s:\n", file);
 948                 }
 949         }
 950 }
 951
 952 static void
 953 print_version(void)
 954 {
 955
 956         (void) printf("%s (%s)\n", nm_info.name, elftc_version());
 957         exit(0);
 958 }
 959
 960 static uint64_t
 961 get_block_value(Dwarf_Debug dbg, Dwarf_Block *block)
 962 {
 963         Elf *elf;
 964         GElf_Ehdr eh;
 965         Dwarf_Error de;
 966
 967         if (dwarf_get_elf(dbg, &elf, &de) != DW_DLV_OK) {
 968                 warnx("dwarf_get_elf failed: %s", dwarf_errmsg(de));
 969                 return (0);
 970         }
 971
 972         if (gelf_getehdr(elf, &eh) != &eh) {
 973                 warnx("gelf_getehdr failed: %s", elf_errmsg(-1));
 974                 return (0);
 975         }
 976
 977         if (block->bl_len == 5) {
 978                 if (eh.e_ident[EI_DATA] == ELFDATA2LSB)
 979                         return (le32dec((uint8_t *) block->bl_data + 1));
 980                 else
 981                         return (be32dec((uint8_t *) block->bl_data + 1));
 982         } else if (block->bl_len == 9) {
 983                 if (eh.e_ident[EI_DATA] == ELFDATA2LSB)
 984                         return (le64dec((uint8_t *) block->bl_data + 1));
 985                 else
 986                         return (be64dec((uint8_t *) block->bl_data + 1));
 987         }
 988
 989         return (0);
 990 }
 991
 992 static char *
 993 find_object_name(Dwarf_Debug dbg, Dwarf_Die die)
 994 {
 995         Dwarf_Die ret_die;
 996         Dwarf_Attribute at;
 997         Dwarf_Off off;
 998         Dwarf_Error de;
 999         const char *str;
1000         char *name;
1001
1002         if (dwarf_attrval_string(die, DW_AT_name, &str, &de) == DW_DLV_OK) {
1003                 if ((name = strdup(str)) == NULL) {
1004                         warn("strdup");
1005                         return (NULL);
1006                 }
1007                 return (name);
1008         }
1009
1010         if (dwarf_attr(die, DW_AT_specification, &at, &de) != DW_DLV_OK)
1011                 return (NULL);
1012
1013         if (dwarf_global_formref(at, &off, &de) != DW_DLV_OK)
1014                 return (NULL);
1015
1016         if (dwarf_offdie(dbg, off, &ret_die, &de) != DW_DLV_OK)
1017                 return (NULL);
1018
1019         return (find_object_name(dbg, ret_die));
1020 }
1021
1022 static void
1023 search_line_attr(Dwarf_Debug dbg, struct func_info_head *func_info,
1024     struct var_info_head *var_info, Dwarf_Die die, char **src_files,
1025     Dwarf_Signed filecount)
1026 {
1027         Dwarf_Attribute at;
1028         Dwarf_Unsigned udata;
1029         Dwarf_Half tag;
1030         Dwarf_Block *block;
1031         Dwarf_Bool flag;
1032         Dwarf_Die ret_die;
1033         Dwarf_Error de;
1034         struct func_info_entry *func;
1035         struct var_info_entry *var;
1036         int ret;
1037
1038         if (dwarf_tag(die, &tag, &de) != DW_DLV_OK) {
1039                 warnx("dwarf_tag failed: %s", dwarf_errmsg(de));
1040                 goto cont_search;
1041         }
1042
1043         /* We're interested in DIEs which define functions or variables. */
1044         if (tag != DW_TAG_subprogram && tag != DW_TAG_entry_point &&
1045             tag != DW_TAG_inlined_subroutine && tag != DW_TAG_variable)
1046                 goto cont_search;
1047
1048         if (tag == DW_TAG_variable) {
1049
1050                 /* Ignore "artificial" variable. */
1051                 if (dwarf_attrval_flag(die, DW_AT_artificial, &flag, &de) ==
1052                     DW_DLV_OK && flag)
1053                         goto cont_search;
1054
1055                 /* Ignore pure declaration. */
1056                 if (dwarf_attrval_flag(die, DW_AT_declaration, &flag, &de) ==
1057                     DW_DLV_OK && flag)
1058                         goto cont_search;
1059
1060                 /* Ignore stack varaibles. */
1061                 if (dwarf_attrval_flag(die, DW_AT_external, &flag, &de) !=
1062                     DW_DLV_OK || !flag)
1063                         goto cont_search;
1064
1065                 if ((var = calloc(1, sizeof(*var))) == NULL) {
1066                         warn("calloc failed");
1067                         goto cont_search;
1068                 }
1069
1070                 if (dwarf_attrval_unsigned(die, DW_AT_decl_file, &udata,
1071                     &de) == DW_DLV_OK && udata > 0 &&
1072                     (Dwarf_Signed) (udata - 1) < filecount) {
1073                         var->file = strdup(src_files[udata - 1]);
1074                         if (var->file == NULL) {
1075                                 warn("strdup");
1076                                 free(var);
1077                                 goto cont_search;
1078                         }
1079                 }
1080
1081                 if (dwarf_attrval_unsigned(die, DW_AT_decl_line, &udata, &de) ==
1082                     DW_DLV_OK)
1083                         var->line = udata;
1084
1085                 var->name = find_object_name(dbg, die);
1086                 if (var->name == NULL) {
1087                         if (var->file)
1088                                 free(var->file);
1089                         free(var);
1090                         goto cont_search;
1091                 }
1092
1093                 if (dwarf_attr(die, DW_AT_location, &at, &de) == DW_DLV_OK &&
1094                     dwarf_formblock(at, &block, &de) == DW_DLV_OK) {
1095                         /*
1096                          * Since we ignored stack variables, the rest are the
1097                          * external varaibles which should always use DW_OP_addr
1098                          * operator for DW_AT_location value.
1099                          */
1100                         if (*((uint8_t *)block->bl_data) == DW_OP_addr)
1101                                 var->addr = get_block_value(dbg, block);
1102                 }
1103
1104                 SLIST_INSERT_HEAD(var_info, var, entries);
1105
1106         } else {
1107
1108                 if ((func = calloc(1, sizeof(*func))) == NULL) {
1109                         warn("calloc failed");
1110                         goto cont_search;
1111                 }
1112
1113                 /*
1114                  * Note that dwarf_attrval_unsigned() handles DW_AT_abstract_origin
1115                  * internally, so it can retrieve DW_AT_decl_file/DW_AT_decl_line
1116                  * attributes for inlined functions as well.
1117                  */
1118                 if (dwarf_attrval_unsigned(die, DW_AT_decl_file, &udata,
1119                     &de) == DW_DLV_OK && udata > 0 &&
1120                     (Dwarf_Signed) (udata - 1) < filecount) {
1121                         func->file = strdup(src_files[udata - 1]);
1122                         if (func->file == NULL) {
1123                                 warn("strdup");
1124                                 free(func);
1125                                 goto cont_search;
1126                         }
1127                 }
1128
1129                 if (dwarf_attrval_unsigned(die, DW_AT_decl_line, &udata, &de) ==
1130                     DW_DLV_OK)
1131                         func->line = udata;
1132
1133                 func->name = find_object_name(dbg, die);
1134                 if (func->name == NULL) {
1135                         if (func->file)
1136                                 free(func->file);
1137                         free(func);
1138                         goto cont_search;
1139                 }
1140
1141                 if (dwarf_attrval_unsigned(die, DW_AT_low_pc, &udata, &de) ==
1142                     DW_DLV_OK)
1143                         func->lowpc = udata;
1144                 if (dwarf_attrval_unsigned(die, DW_AT_high_pc, &udata, &de) ==
1145                     DW_DLV_OK)
1146                         func->highpc = udata;
1147
1148                 SLIST_INSERT_HEAD(func_info, func, entries);
1149         }
1150
1151 cont_search:
1152
1153         /* Search children. */
1154         ret = dwarf_child(die, &ret_die, &de);
1155         if (ret == DW_DLV_ERROR)
1156                 warnx("dwarf_child: %s", dwarf_errmsg(de));
1157         else if (ret == DW_DLV_OK)
1158                 search_line_attr(dbg, func_info, var_info, ret_die, src_files,
1159                     filecount);
1160
1161         /* Search sibling. */
1162         ret = dwarf_siblingof(dbg, die, &ret_die, &de);
1163         if (ret == DW_DLV_ERROR)
1164                 warnx("dwarf_siblingof: %s", dwarf_errmsg(de));
1165         else if (ret == DW_DLV_OK)
1166                 search_line_attr(dbg, func_info, var_info, ret_die, src_files,
1167                     filecount);
1168
1169         dwarf_dealloc(dbg, die, DW_DLA_DIE);
1170 }
1171
1172 /*
1173  * Read elf file and collect symbol information, sort them, print.
1174  * Return 1 at failed, 0 at success.
1175  */
1176 static int
1177 read_elf(Elf *elf, const char *filename, Elf_Kind kind)
1178 {
1179         Dwarf_Debug dbg;
1180         Dwarf_Die die;
1181         Dwarf_Error de;
1182         Dwarf_Half tag;
1183         Elf_Arhdr *arhdr;
1184         Elf_Scn *scn;
1185         GElf_Shdr shdr;
1186         GElf_Half i;
1187         Dwarf_Line *lbuf;
1188         Dwarf_Unsigned lineno;
1189         Dwarf_Signed lcount, filecount;
1190         Dwarf_Addr lineaddr;
1191         struct sym_print_data p_data;
1192         struct sym_head list_head;
1193         struct line_info_head *line_info;
1194         struct func_info_head *func_info;
1195         struct var_info_head *var_info;
1196         struct line_info_entry *lie;
1197         struct func_info_entry *func;
1198         struct var_info_entry *var;
1199         const char *shname, *objname;
1200         char *type_table, **sec_table, *sfile, **src_files;
1201         size_t shstrndx, shnum, dynndx, strndx;
1202         int ret, rtn, e_err;
1203
1204 #define OBJNAME (objname == NULL ? filename : objname)
1205
1206         assert(filename != NULL && "filename is null");
1207
1208         STAILQ_INIT(&list_head);
1209         type_table = NULL;
1210         sec_table = NULL;
1211         line_info = NULL;
1212         func_info = NULL;
1213         var_info = NULL;
1214         objname = NULL;
1215         dynndx = SHN_UNDEF;
1216         strndx = SHN_UNDEF;
1217         rtn = 0;
1218
1219         nm_elfclass = gelf_getclass(elf);
1220
1221         if (kind == ELF_K_AR) {
1222                 if ((arhdr = elf_getarhdr(elf)) == NULL)
1223                         goto next_cmd;
1224                 objname = arhdr->ar_name != NULL ? arhdr->ar_name :
1225                     arhdr->ar_rawname;
1226         }
1227         if (!elf_getshnum(elf, &shnum)) {
1228                 if ((e_err = elf_errno()) != 0)
1229                         warnx("%s: %s", OBJNAME, "File format not recognized");
1230                 else
1231                         warnx("%s: cannot get section number", OBJNAME);
1232                 rtn = 1;
1233                 goto next_cmd;
1234         }
1235         if (shnum == 0) {
1236                 warnx("%s: has no section", OBJNAME);
1237                 rtn = 1;
1238                 goto next_cmd;
1239         }
1240         if (!elf_getshstrndx(elf, &shstrndx)) {
1241                 warnx("%s: cannot get str index", OBJNAME);
1242                 rtn = 1;
1243                 goto next_cmd;
1244         }
1245         /* type_table for type determine */
1246         if ((type_table = malloc(sizeof(char) * shnum)) == NULL) {
1247                 warn("%s: malloc", OBJNAME);
1248                 rtn = 1;
1249                 goto next_cmd;
1250         }
1251         /* sec_table for section name to display in sysv format */
1252         if ((sec_table = calloc(shnum, sizeof(char *))) == NULL) {
1253                 warn("%s: calloc", OBJNAME);
1254                 rtn = 1;
1255                 goto next_cmd;
1256         }
1257
1258         type_table[0] = 'U';
1259         if ((sec_table[0] = strdup("*UND*")) == NULL) {
1260                 warn("strdup");
1261                 goto next_cmd;
1262         }
1263
1264         for (i = 1; i < shnum; ++i) {
1265                 type_table[i] = 'U';
1266                 if ((scn = elf_getscn(elf, i)) == NULL) {
1267                         if ((e_err = elf_errno()) != 0)
1268                                 warnx("%s: %s", OBJNAME, elf_errmsg(e_err));
1269                         else
1270                                 warnx("%s: cannot get section", OBJNAME);
1271                         rtn = 1;
1272                         goto next_cmd;
1273                 }
1274                 if (gelf_getshdr(scn, &shdr) == NULL)
1275                         goto next_cmd;
1276
1277                 /*
1278                  * Cannot test by type and attribute for dynstr, strtab
1279                  */
1280                 shname = elf_strptr(elf, shstrndx, (size_t) shdr.sh_name);
1281                 if (shname != NULL) {
1282                         if ((sec_table[i] = strdup(shname)) == NULL) {
1283                                 warn("strdup");
1284                                 goto next_cmd;
1285                         }
1286                         if (!strncmp(shname, ".dynstr", 7)) {
1287                                 dynndx = elf_ndxscn(scn);
1288                                 if (dynndx == SHN_UNDEF) {
1289                                         warnx("%s: elf_ndxscn failed: %s",
1290                                             OBJNAME, elf_errmsg(-1));
1291                                         goto next_cmd;
1292                                 }
1293                         }
1294                         if (!strncmp(shname, ".strtab", 7)) {
1295                                 strndx = elf_ndxscn(scn);
1296                                 if (strndx == SHN_UNDEF) {
1297                                         warnx("%s: elf_ndxscn failed: %s",
1298                                             OBJNAME, elf_errmsg(-1));
1299                                         goto next_cmd;
1300                                 }
1301                         }
1302                 } else {
1303                         sec_table[i] = strdup("*UND*");
1304                         if (sec_table[i] == NULL) {
1305                                 warn("strdup");
1306                                 goto next_cmd;
1307                         }
1308                 }
1309
1310
1311                 if (is_sec_text(&shdr))
1312                         type_table[i] = 'T';
1313                 else if (is_sec_data(&shdr)) {
1314                         if (is_sec_readonly(&shdr))
1315                                 type_table[i] = 'R';
1316                         else
1317                                 type_table[i] = 'D';
1318                 } else if (is_sec_nobits(&shdr))
1319                         type_table[i] = 'B';
1320                 else if (is_sec_debug(shname))
1321                         type_table[i] = 'N';
1322                 else if (is_sec_readonly(&shdr) && !is_sec_nobits(&shdr))
1323                         type_table[i] = 'n';
1324         }
1325
1326         print_header(filename, objname);
1327
1328         if ((dynndx == SHN_UNDEF && nm_opts.print_symbol == PRINT_SYM_DYN) ||
1329             (strndx == SHN_UNDEF && nm_opts.print_symbol == PRINT_SYM_SYM)) {
1330                 warnx("%s: no symbols", OBJNAME);
1331                 /* This is not an error case */
1332                 goto next_cmd;
1333         }
1334
1335         STAILQ_INIT(&list_head);
1336
1337         if (!nm_opts.debug_line)
1338                 goto process_sym;
1339
1340         /*
1341          * Collect dwarf line number information.
1342          */
1343
1344         if (dwarf_elf_init(elf, DW_DLC_READ, NULL, NULL, &dbg, &de) !=
1345             DW_DLV_OK) {
1346                 warnx("dwarf_elf_init failed: %s", dwarf_errmsg(de));
1347                 goto process_sym;
1348         }
1349
1350         line_info = malloc(sizeof(struct line_info_head));
1351         func_info = malloc(sizeof(struct func_info_head));
1352         var_info = malloc(sizeof(struct var_info_head));
1353         if (line_info != NULL)
1354                 SLIST_INIT(line_info);
1355         if (func_info != NULL)
1356                 SLIST_INIT(func_info);
1357         if (var_info != NULL)
1358                 SLIST_INIT(var_info);
1359         if (line_info == NULL || func_info == NULL || var_info == NULL) {
1360                 warn("malloc");
1361                 (void) dwarf_finish(dbg, &de);
1362                 goto process_sym;
1363         }
1364
1365         while ((ret = dwarf_next_cu_header(dbg, NULL, NULL, NULL, NULL, NULL,
1366             &de)) ==  DW_DLV_OK) {
1367                 die = NULL;
1368                 while (dwarf_siblingof(dbg, die, &die, &de) == DW_DLV_OK) {
1369                         if (dwarf_tag(die, &tag, &de) != DW_DLV_OK) {
1370                                 warnx("dwarf_tag failed: %s",
1371                                     dwarf_errmsg(de));
1372                                 continue;
1373                         }
1374                         /* XXX: What about DW_TAG_partial_unit? */
1375                         if (tag == DW_TAG_compile_unit)
1376                                 break;
1377                 }
1378                 if (die == NULL) {
1379                         warnx("could not find DW_TAG_compile_unit die");
1380                         continue;
1381                 }
1382
1383                 /* Retrieve source file list. */
1384                 ret = dwarf_srcfiles(die, &src_files, &filecount, &de);
1385                 if (ret == DW_DLV_ERROR)
1386                         warnx("dwarf_srclines: %s", dwarf_errmsg(de));
1387                 if (ret != DW_DLV_OK)
1388                         continue;
1389
1390                 /*
1391                  * Retrieve line number information from .debug_line section.
1392                  */
1393
1394                 ret = dwarf_srclines(die, &lbuf, &lcount, &de);
1395                 if (ret == DW_DLV_ERROR)
1396                         warnx("dwarf_srclines: %s", dwarf_errmsg(de));
1397                 if (ret != DW_DLV_OK)
1398                         goto line_attr;
1399                 for (i = 0; (Dwarf_Signed) i < lcount; i++) {
1400                         if (dwarf_lineaddr(lbuf[i], &lineaddr, &de)) {
1401                                 warnx("dwarf_lineaddr: %s", dwarf_errmsg(de));
1402                                 continue;
1403                         }
1404                         if (dwarf_lineno(lbuf[i], &lineno, &de)) {
1405                                 warnx("dwarf_lineno: %s", dwarf_errmsg(de));
1406                                 continue;
1407                         }
1408                         if (dwarf_linesrc(lbuf[i], &sfile, &de)) {
1409                                 warnx("dwarf_linesrc: %s", dwarf_errmsg(de));
1410                                 continue;
1411                         }
1412                         if ((lie = malloc(sizeof(*lie))) == NULL) {
1413                                 warn("malloc");
1414                                 continue;
1415                         }
1416                         lie->addr = lineaddr;
1417                         lie->line = lineno;
1418                         lie->file = strdup(sfile);
1419                         if (lie->file == NULL) {
1420                                 warn("strdup");
1421                                 free(lie);
1422                                 continue;
1423                         }
1424                         SLIST_INSERT_HEAD(line_info, lie, entries);
1425                 }
1426
1427         line_attr:
1428                 /* Retrieve line number information from DIEs. */
1429                 search_line_attr(dbg, func_info, var_info, die, src_files, filecount);
1430         }
1431
1432         (void) dwarf_finish(dbg, &de);
1433
1434 process_sym:
1435
1436         p_data.list_num = get_sym(elf, &list_head, shnum, dynndx, strndx,
1437             type_table, (void *) sec_table, shnum);
1438
1439         if (p_data.list_num == 0)
1440                 goto next_cmd;
1441
1442         p_data.headp = &list_head;
1443         p_data.sh_num = shnum;
1444         p_data.t_table = type_table;
1445         p_data.s_table = (void *) sec_table;
1446         p_data.filename = filename;
1447         p_data.objname = objname;
1448
1449         sym_list_print(&p_data, func_info, var_info, line_info);
1450
1451 next_cmd:
1452         if (nm_opts.debug_line) {
1453                 if (func_info != NULL) {
1454                         while (!SLIST_EMPTY(func_info)) {
1455                                 func = SLIST_FIRST(func_info);
1456                                 SLIST_REMOVE_HEAD(func_info, entries);
1457                                 free(func->file);
1458                                 free(func->name);
1459                                 free(func);
1460                         }
1461                         free(func_info);
1462                         func_info = NULL;
1463                 }
1464                 if (var_info != NULL) {
1465                         while (!SLIST_EMPTY(var_info)) {
1466                                 var = SLIST_FIRST(var_info);
1467                                 SLIST_REMOVE_HEAD(var_info, entries);
1468                                 free(var->file);
1469                                 free(var->name);
1470                                 free(var);
1471                         }
1472                         free(var_info);
1473                         var_info = NULL;
1474                 }
1475                 if (line_info != NULL) {
1476                         while (!SLIST_EMPTY(line_info)) {
1477                                 lie = SLIST_FIRST(line_info);
1478                                 SLIST_REMOVE_HEAD(line_info, entries);
1479                                 free(lie->file);
1480                                 free(lie);
1481                         }
1482                         free(line_info);
1483                         line_info = NULL;
1484                 }
1485         }
1486
1487         if (sec_table != NULL)
1488                 for (i = 0; i < shnum; ++i)
1489                         free(sec_table[i]);
1490         free(sec_table);
1491         free(type_table);
1492
1493         sym_list_dest(&list_head);
1494
1495         return (rtn);
1496
1497 #undef  OBJNAME
1498 }
1499
1500 static int
1501 read_object(const char *filename)
1502 {
1503         Elf *elf, *arf;
1504         Elf_Cmd elf_cmd;
1505         Elf_Kind kind;
1506         int fd, rtn, e_err;
1507
1508         assert(filename != NULL && "filename is null");
1509
1510         if ((fd = fileargs_open(nm_opts.fileargs, filename)) == -1) {
1511                 warn("'%s'", filename);
1512                 return (1);
1513         }
1514
1515         elf_cmd = ELF_C_READ;
1516         if ((arf = elf_begin(fd, elf_cmd, (Elf *) NULL)) == NULL) {
1517                 if ((e_err = elf_errno()) != 0)
1518                         warnx("elf_begin error: %s", elf_errmsg(e_err));
1519                 else
1520                         warnx("elf_begin error");
1521                 close(fd);
1522                 return (1);
1523         }
1524
1525         assert(arf != NULL && "arf is null.");
1526
1527         rtn = 0;
1528         if ((kind = elf_kind(arf)) == ELF_K_NONE) {
1529                 warnx("%s: File format not recognized", filename);
1530                 elf_end(arf);
1531                 close(fd);
1532                 return (1);
1533         }
1534         if (kind == ELF_K_AR) {
1535                 if (nm_opts.print_name == PRINT_NAME_MULTI &&
1536                     nm_opts.elem_print_fn == sym_elem_print_all)
1537                         printf("\n%s:\n", filename);
1538                 if (nm_opts.print_armap == true)
1539                         print_ar_index(fd, arf);
1540         }
1541
1542         while ((elf = elf_begin(fd, elf_cmd, arf)) != NULL) {
1543                 rtn |= read_elf(elf, filename, kind);
1544
1545                 /*
1546                  * If file is not archive, elf_next return ELF_C_NULL and
1547                  * stop the loop.
1548                  */
1549                 elf_cmd = elf_next(elf);
1550                 elf_end(elf);
1551         }
1552
1553         elf_end(arf);
1554         close(fd);
1555
1556         return (rtn);
1557 }
1558
1559 static int
1560 read_files(int argc, char **argv)
1561 {
1562         int rtn = 0;
1563
1564         if (argc < 0 || argv == NULL)
1565                 return (1);
1566
1567         if (argc == 0)
1568                 rtn |= read_object(nm_info.def_filename);
1569         else {
1570                 if (nm_opts.print_name == PRINT_NAME_NONE && argc > 1)
1571                         nm_opts.print_name = PRINT_NAME_MULTI;
1572                 while (argc > 0) {
1573                         rtn |= read_object(*argv);
1574                         --argc;
1575                         ++argv;
1576                 }
1577         }
1578
1579         return (rtn);
1580 }
1581
1582 static void
1583 print_lineno(struct sym_entry *ep, struct func_info_head *func_info,
1584     struct var_info_head *var_info, struct line_info_head *line_info)
1585 {
1586         struct func_info_entry *func;
1587         struct var_info_entry *var;
1588         struct line_info_entry *lie;
1589
1590         /* For function symbol, search the function line information list.  */
1591         if ((ep->sym->st_info & 0xf) == STT_FUNC && func_info != NULL) {
1592                 SLIST_FOREACH(func, func_info, entries) {
1593                         if (func->name != NULL &&
1594                             !strcmp(ep->name, func->name) &&
1595                             ep->sym->st_value >= func->lowpc &&
1596                             ep->sym->st_value < func->highpc) {
1597                                 printf("\t%s:%" PRIu64, func->file, func->line);
1598                                 return;
1599                         }
1600                 }
1601         }
1602
1603         /* For variable symbol, search the variable line information list.  */
1604         if ((ep->sym->st_info & 0xf) == STT_OBJECT && var_info != NULL) {
1605                 SLIST_FOREACH(var, var_info, entries) {
1606                         if (!strcmp(ep->name, var->name) &&
1607                             ep->sym->st_value == var->addr) {
1608                                 printf("\t%s:%" PRIu64, var->file, var->line);
1609                                 return;
1610                         }
1611                 }
1612         }
1613
1614         /* Otherwise search line number information the .debug_line section. */
1615         if (line_info != NULL) {
1616                 SLIST_FOREACH(lie, line_info, entries) {
1617                         if (ep->sym->st_value == lie->addr) {
1618                                 printf("\t%s:%" PRIu64, lie->file, lie->line);
1619                                 return;
1620                         }
1621                 }
1622         }
1623 }
1624
1625 static void
1626 set_opt_value_print_fn(enum radix t)
1627 {
1628
1629         switch (t) {
1630         case RADIX_OCT:
1631                 nm_opts.value_print_fn = &sym_value_oct_print;
1632                 nm_opts.size_print_fn = &sym_size_oct_print;
1633
1634                 break;
1635         case RADIX_DEC:
1636                 nm_opts.value_print_fn = &sym_value_dec_print;
1637                 nm_opts.size_print_fn = &sym_size_dec_print;
1638
1639                 break;
1640         case RADIX_HEX:
1641         default :
1642                 nm_opts.value_print_fn = &sym_value_hex_print;
1643                 nm_opts.size_print_fn  = &sym_size_hex_print;
1644         }
1645
1646         assert(nm_opts.value_print_fn != NULL &&
1647             "nm_opts.value_print_fn is null");
1648 }
1649
1650 static void
1651 sym_elem_print_all(char type, const char *sec, const GElf_Sym *sym,
1652     const char *name)
1653 {
1654
1655         if (sec == NULL || sym == NULL || name == NULL ||
1656             nm_opts.value_print_fn == NULL)
1657                 return;
1658
1659         if (IS_UNDEF_SYM_TYPE(type)) {
1660                 if (nm_opts.t == RADIX_HEX && nm_elfclass == ELFCLASS32)
1661                         printf("%-8s", "");
1662                 else
1663                         printf("%-16s", "");
1664         } else {
1665                 switch ((nm_opts.sort_fn == & cmp_size ? 2 : 0) +
1666                     nm_opts.print_size) {
1667                 case 3:
1668                         if (sym->st_size != 0) {
1669                                 nm_opts.value_print_fn(sym);
1670                                 printf(" ");
1671                                 nm_opts.size_print_fn(sym);
1672                         }
1673                         break;
1674
1675                 case 2:
1676                         if (sym->st_size != 0)
1677                                 nm_opts.size_print_fn(sym);
1678                         break;
1679
1680                 case 1:
1681                         nm_opts.value_print_fn(sym);
1682                         if (sym->st_size != 0) {
1683                                 printf(" ");
1684                                 nm_opts.size_print_fn(sym);
1685                         }
1686                         break;
1687
1688                 case 0:
1689                 default:
1690                         nm_opts.value_print_fn(sym);
1691                 }
1692         }
1693
1694         printf(" %c ", type);
1695         PRINT_DEMANGLED_NAME("%s", name);
1696 }
1697
1698 static void
1699 sym_elem_print_all_portable(char type, const char *sec, const GElf_Sym *sym,
1700     const char *name)
1701 {
1702
1703         if (sec == NULL || sym == NULL || name == NULL ||
1704             nm_opts.value_print_fn == NULL)
1705                 return;
1706
1707         PRINT_DEMANGLED_NAME("%s", name);
1708         printf(" %c ", type);
1709         if (!IS_UNDEF_SYM_TYPE(type)) {
1710                 nm_opts.value_print_fn(sym);
1711                 printf(" ");
1712                 if (sym->st_size != 0)
1713                         nm_opts.size_print_fn(sym);
1714         } else
1715                 printf("        ");
1716 }
1717
1718 static void
1719 sym_elem_print_all_sysv(char type, const char *sec, const GElf_Sym *sym,
1720     const char *name)
1721 {
1722
1723         if (sec == NULL || sym == NULL || name == NULL ||
1724             nm_opts.value_print_fn == NULL)
1725                 return;
1726
1727         PRINT_DEMANGLED_NAME("%-20s|", name);
1728         if (IS_UNDEF_SYM_TYPE(type))
1729                 printf("                ");
1730         else
1731                 nm_opts.value_print_fn(sym);
1732
1733         printf("|   %c  |", type);
1734
1735         switch (sym->st_info & 0xf) {
1736         case STT_OBJECT:
1737                 printf("%18s|", "OBJECT");
1738                 break;
1739
1740         case STT_FUNC:
1741                 printf("%18s|", "FUNC");
1742                 break;
1743
1744         case STT_SECTION:
1745                 printf("%18s|", "SECTION");
1746                 break;
1747
1748         case STT_FILE:
1749                 printf("%18s|", "FILE");
1750                 break;
1751
1752         case STT_LOPROC:
1753                 printf("%18s|", "LOPROC");
1754                 break;
1755
1756         case STT_HIPROC:
1757                 printf("%18s|", "HIPROC");
1758                 break;
1759
1760         case STT_NOTYPE:
1761         default:
1762                 printf("%18s|", "NOTYPE");
1763         }
1764
1765         if (sym->st_size != 0)
1766                 nm_opts.size_print_fn(sym);
1767         else
1768                 printf("                ");
1769
1770         printf("|     |%s", sec);
1771 }
1772
1773 static int
1774 sym_elem_def(char type, const GElf_Sym *sym, const char *name)
1775 {
1776
1777         assert(IS_SYM_TYPE((unsigned char) type));
1778
1779         UNUSED(sym);
1780         UNUSED(name);
1781
1782         return (!IS_UNDEF_SYM_TYPE((unsigned char) type));
1783 }
1784
1785 static int
1786 sym_elem_global(char type, const GElf_Sym *sym, const char *name)
1787 {
1788
1789         assert(IS_SYM_TYPE((unsigned char) type));
1790
1791         UNUSED(sym);
1792         UNUSED(name);
1793
1794         /* weak symbols resemble global. */
1795         return (isupper((unsigned char) type) || type == 'w');
1796 }
1797
1798 static int
1799 sym_elem_global_static(char type, const GElf_Sym *sym, const char *name)
1800 {
1801         unsigned char info;
1802
1803         assert(sym != NULL);
1804
1805         UNUSED(type);
1806         UNUSED(name);
1807
1808         info = sym->st_info >> 4;
1809
1810         return (info == STB_LOCAL ||
1811             info == STB_GLOBAL ||
1812             info == STB_WEAK);
1813 }
1814
1815 static int
1816 sym_elem_nondebug(char type, const GElf_Sym *sym, const char *name)
1817 {
1818
1819         assert(sym != NULL);
1820
1821         UNUSED(type);
1822         UNUSED(name);
1823
1824         if (sym->st_value == 0 && (sym->st_info & 0xf) == STT_FILE)
1825                 return (0);
1826         if (sym->st_name == 0)
1827                 return (0);
1828
1829         return (1);
1830 }
1831
1832 static int
1833 sym_elem_nonzero_size(char type, const GElf_Sym *sym, const char *name)
1834 {
1835
1836         assert(sym != NULL);
1837
1838         UNUSED(type);
1839         UNUSED(name);
1840
1841         return (sym->st_size > 0);
1842 }
1843
1844 static int
1845 sym_elem_undef(char type, const GElf_Sym *sym, const char *name)
1846 {
1847
1848         assert(IS_SYM_TYPE((unsigned char) type));
1849
1850         UNUSED(sym);
1851         UNUSED(name);
1852
1853         return (IS_UNDEF_SYM_TYPE((unsigned char) type));
1854 }
1855
1856 static void
1857 sym_list_dest(struct sym_head *headp)
1858 {
1859         struct sym_entry *ep, *ep_n;
1860
1861         if (headp == NULL)
1862                 return;
1863
1864         ep = STAILQ_FIRST(headp);
1865         while (ep != NULL) {
1866                 ep_n = STAILQ_NEXT(ep, sym_entries);
1867                 free(ep->sym);
1868                 free(ep->name);
1869                 free(ep);
1870                 ep = ep_n;
1871         }
1872 }
1873
1874 static int
1875 sym_list_insert(struct sym_head *headp, const char *name, const GElf_Sym *sym)
1876 {
1877         struct sym_entry *e;
1878
1879         if (headp == NULL || name == NULL || sym == NULL)
1880                 return (0);
1881         if ((e = malloc(sizeof(struct sym_entry))) == NULL) {
1882                 warn("malloc");
1883                 return (0);
1884         }
1885         if ((e->name = strdup(name)) == NULL) {
1886                 warn("strdup");
1887                 free(e);
1888                 return (0);
1889         }
1890         if ((e->sym = malloc(sizeof(GElf_Sym))) == NULL) {
1891                 warn("malloc");
1892                 free(e->name);
1893                 free(e);
1894                 return (0);
1895         }
1896
1897         memcpy(e->sym, sym, sizeof(GElf_Sym));
1898
1899         /* Display size instead of value for common symbol. */
1900         if (sym->st_shndx == SHN_COMMON)
1901                 e->sym->st_value = sym->st_size;
1902
1903         STAILQ_INSERT_TAIL(headp, e, sym_entries);
1904
1905         return (1);
1906 }
1907
1908 /* If file has not .debug_info, line_info will be NULL */
1909 static void
1910 sym_list_print(struct sym_print_data *p, struct func_info_head *func_info,
1911     struct var_info_head *var_info, struct line_info_head *line_info)
1912 {
1913         struct sym_entry *e_v;
1914         size_t si;
1915         int i;
1916
1917         if (p == NULL || CHECK_SYM_PRINT_DATA(p))
1918                 return;
1919         if ((e_v = sym_list_sort(p)) == NULL)
1920                 return;
1921         if (nm_opts.sort_reverse == false)
1922                 for (si = 0; si != p->list_num; ++si)
1923                         sym_list_print_each(&e_v[si], p, func_info, var_info,
1924                             line_info);
1925         else
1926                 for (i = p->list_num - 1; i != -1; --i)
1927                         sym_list_print_each(&e_v[i], p, func_info, var_info,
1928                             line_info);
1929
1930         free(e_v);
1931 }
1932
1933 /* If file has not .debug_info, line_info will be NULL */
1934 static void
1935 sym_list_print_each(struct sym_entry *ep, struct sym_print_data *p,
1936     struct func_info_head *func_info, struct var_info_head *var_info,
1937     struct line_info_head *line_info)
1938 {
1939         const char *sec;
1940         char type;
1941
1942         if (ep == NULL || CHECK_SYM_PRINT_DATA(p))
1943                 return;
1944
1945         assert(ep->name != NULL);
1946         assert(ep->sym != NULL);
1947
1948         type = get_sym_type(ep->sym, p->t_table);
1949
1950         if (nm_opts.print_name == PRINT_NAME_FULL) {
1951                 printf("%s", p->filename);
1952                 if (nm_opts.elem_print_fn == &sym_elem_print_all_portable) {
1953                         if (p->objname != NULL)
1954                                 printf("[%s]", p->objname);
1955                         printf(": ");
1956                 } else {
1957                         if (p->objname != NULL)
1958                                 printf(":%s", p->objname);
1959                         printf(":");
1960                 }
1961         }
1962
1963         switch (ep->sym->st_shndx) {
1964         case SHN_LOPROC:
1965                 /* LOPROC or LORESERVE */
1966                 sec = "*LOPROC*";
1967                 break;
1968         case SHN_HIPROC:
1969                 sec = "*HIPROC*";
1970                 break;
1971         case SHN_LOOS:
1972                 sec = "*LOOS*";
1973                 break;
1974         case SHN_HIOS:
1975                 sec = "*HIOS*";
1976                 break;
1977         case SHN_ABS:
1978                 sec = "*ABS*";
1979                 break;
1980         case SHN_COMMON:
1981                 sec = "*COM*";
1982                 break;
1983         case SHN_HIRESERVE:
1984                 /* HIRESERVE or XINDEX */
1985                 sec = "*HIRESERVE*";
1986                 break;
1987         default:
1988                 if (ep->sym->st_shndx > p->sh_num)
1989                         return;
1990                 sec = p->s_table[ep->sym->st_shndx];
1991                 break;
1992         }
1993
1994         nm_opts.elem_print_fn(type, sec, ep->sym, ep->name);
1995
1996         if (nm_opts.debug_line == true && !IS_UNDEF_SYM_TYPE(type))
1997                 print_lineno(ep, func_info, var_info, line_info);
1998
1999         printf("\n");
2000 }
2001
2002 static struct sym_entry *
2003 sym_list_sort(struct sym_print_data *p)
2004 {
2005         struct sym_entry *ep, *e_v;
2006         int idx;
2007
2008         if (p == NULL || CHECK_SYM_PRINT_DATA(p))
2009                 return (NULL);
2010
2011         if ((e_v = malloc(sizeof(struct sym_entry) * p->list_num)) == NULL) {
2012                 warn("malloc");
2013                 return (NULL);
2014         }
2015
2016         idx = 0;
2017         STAILQ_FOREACH(ep, p->headp, sym_entries) {
2018                 if (ep->name != NULL && ep->sym != NULL) {
2019                         e_v[idx].name = ep->name;
2020                         e_v[idx].sym = ep->sym;
2021                         ++idx;
2022                 }
2023         }
2024
2025         assert((size_t)idx == p->list_num);
2026
2027         if (nm_opts.sort_fn != &cmp_none) {
2028                 nm_print_data = p;
2029                 assert(nm_print_data != NULL);
2030                 qsort(e_v, p->list_num, sizeof(struct sym_entry),
2031                     nm_opts.sort_fn);
2032         }
2033
2034         return (e_v);
2035 }
2036
2037 static void
2038 sym_size_oct_print(const GElf_Sym *sym)
2039 {
2040
2041         assert(sym != NULL && "sym is null");
2042         printf("%016" PRIo64, sym->st_size);
2043 }
2044
2045 static void
2046 sym_size_hex_print(const GElf_Sym *sym)
2047 {
2048
2049         assert(sym != NULL && "sym is null");
2050         if (nm_elfclass == ELFCLASS32)
2051                 printf("%08" PRIx64, sym->st_size);
2052         else
2053                 printf("%016" PRIx64, sym->st_size);
2054 }
2055
2056 static void
2057 sym_size_dec_print(const GElf_Sym *sym)
2058 {
2059
2060         assert(sym != NULL && "sym is null");
2061         printf("%016" PRId64, sym->st_size);
2062 }
2063
2064 static void
2065 sym_value_oct_print(const GElf_Sym *sym)
2066 {
2067
2068         assert(sym != NULL && "sym is null");
2069         printf("%016" PRIo64, sym->st_value);
2070 }
2071
2072 static void
2073 sym_value_hex_print(const GElf_Sym *sym)
2074 {
2075
2076         assert(sym != NULL && "sym is null");
2077         if (nm_elfclass == ELFCLASS32)
2078                 printf("%08" PRIx64, sym->st_value);
2079         else
2080                 printf("%016" PRIx64, sym->st_value);
2081 }
2082
2083 static void
2084 sym_value_dec_print(const GElf_Sym *sym)
2085 {
2086
2087         assert(sym != NULL && "sym is null");
2088         printf("%016" PRId64, sym->st_value);
2089 }
2090
2091 static void
2092 usage(int exitcode)
2093 {
2094
2095         printf("Usage: %s [options] file ...\
2096 \n  Display symbolic information in file.\n\
2097 \n  Options: \
2098 \n  -A, --print-file-name     Write the full pathname or library name of an\
2099 \n                            object on each line.\
2100 \n  -a, --debug-syms          Display all symbols include debugger-only\
2101 \n                            symbols.", nm_info.name);
2102         printf("\
2103 \n  -B                        Equivalent to specifying \"--format=bsd\".\
2104 \n  -C, --demangle[=style]    Decode low-level symbol names.\
2105 \n      --no-demangle         Do not demangle low-level symbol names.\
2106 \n  -D, --dynamic             Display only dynamic symbols.\
2107 \n  -e                        Display only global and static symbols.");
2108         printf("\
2109 \n  -f                        Produce full output (default).\
2110 \n      --format=format       Display output in specific format.  Allowed\
2111 \n                            formats are: \"bsd\", \"posix\" and \"sysv\".\
2112 \n  -g, --extern-only         Display only global symbol information.\
2113 \n  -h, --help                Show this help message.\
2114 \n  -l, --line-numbers        Display filename and linenumber using\
2115 \n                            debugging information.\
2116 \n  -n, --numeric-sort        Sort symbols numerically by value.");
2117         printf("\
2118 \n  -o                        Write numeric values in octal. Equivalent to\
2119 \n                            specifying \"-t o\".\
2120 \n  -p, --no-sort             Do not sort symbols.\
2121 \n  -P                        Write information in a portable output format.\
2122 \n                            Equivalent to specifying \"--format=posix\".\
2123 \n  -r, --reverse-sort        Reverse the order of the sort.\
2124 \n  -S, --print-size          Print symbol sizes instead values.\
2125 \n  -s, --print-armap         Include an index of archive members.\
2126 \n      --size-sort           Sort symbols by size.");
2127         printf("\
2128 \n  -t, --radix=format        Write each numeric value in the specified\
2129 \n                            format:\
2130 \n                               d   In decimal,\
2131 \n                               o   In octal,\
2132 \n                               x   In hexadecimal.");
2133         printf("\
2134 \n  -u, --undefined-only      Display only undefined symbols.\
2135 \n      --defined-only        Display only defined symbols.\
2136 \n  -V, --version             Show the version identifier for %s.\
2137 \n  -v                        Sort output by value.\
2138 \n  -x                        Write numeric values in hexadecimal.\
2139 \n                            Equivalent to specifying \"-t x\".",
2140             nm_info.name);
2141         printf("\n\
2142 \n  The default options are: output in bsd format, use a hexadecimal radix,\
2143 \n  sort by symbol name, do not demangle names.\n");
2144
2145         exit(exitcode);
2146 }
2147
2148 /*
2149  * Display symbolic information in file.
2150  * Return 0 at success, >0 at failed.
2151  */
2152 int
2153 main(int argc, char **argv)
2154 {
2155         int rtn;
2156
2157         global_init();
2158         get_opt(&argc, &argv);
2159         enter_cap_mode(argc, argv);
2160         rtn = read_files(argc, argv);
2161         global_dest();
2162
2163         exit(rtn);
2164 }