src/nm.c

   1 /* Print symbol information from ELF file in human-readable form.
   2    Copyright (C) 2000-2008, 2009, 2011, 2012, 2014 Red Hat, Inc.
   3    This file is part of elfutils.
   4    Written by Ulrich Drepper <drepper@redhat.com>, 2000.
   5
   6    This file is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    elfutils is distributed in the hope that it will be useful, but
  12    WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #ifdef HAVE_CONFIG_H
  20 # include <config.h>
  21 #endif
  22
  23 #include <ar.h>
  24 #include <argp.h>
  25 #include <assert.h>
  26 #include <ctype.h>
  27 #include <dwarf.h>
  28 #include <errno.h>
  29 #include <error.h>
  30 #include <fcntl.h>
  31 #include <gelf.h>
  32 #include <inttypes.h>
  33 #include <libdw.h>
  34 #include <libintl.h>
  35 #include <locale.h>
  36 #include <mcheck.h>
  37 #include <obstack.h>
  38 #include <search.h>
  39 #include <stdbool.h>
  40 #include <stdio.h>
  41 #include <stdio_ext.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include <unistd.h>
  45 #include <sys/param.h>
  46
  47 #include <system.h>
  48 #include "../libebl/libeblP.h"
  49
  50
  51 /* Name and version of program.  */
  52 static void print_version (FILE *stream, struct argp_state *state);
  53 ARGP_PROGRAM_VERSION_HOOK_DEF = print_version;
  54
  55 /* Bug report address.  */
  56 ARGP_PROGRAM_BUG_ADDRESS_DEF = PACKAGE_BUGREPORT;
  57
  58
  59 /* Values for the parameters which have no short form.  */
  60 #define OPT_DEFINED             0x100
  61 #define OPT_MARK_SPECIAL        0x101
  62
  63 /* Definitions of arguments for argp functions.  */
  64 static const struct argp_option options[] =
  65 {
  66   { NULL, 0, NULL, 0, N_("Output selection:"), 0 },
  67   { "debug-syms", 'a', NULL, 0, N_("Display debugger-only symbols"), 0 },
  68   { "defined-only", OPT_DEFINED, NULL, 0, N_("Display only defined symbols"),
  69     0 },
  70   { "dynamic", 'D', NULL, 0,
  71     N_("Display dynamic symbols instead of normal symbols"), 0 },
  72   { "extern-only", 'g', NULL, 0, N_("Display only external symbols"), 0 },
  73   { "undefined-only", 'u', NULL, 0, N_("Display only undefined symbols"), 0 },
  74   { "print-armap", 's', NULL, 0,
  75     N_("Include index for symbols from archive members"), 0 },
  76
  77   { NULL, 0, NULL, 0, N_("Output format:"), 0 },
  78   { "print-file-name", 'A', NULL, 0,
  79     N_("Print name of the input file before every symbol"), 0 },
  80   { NULL, 'o', NULL, OPTION_HIDDEN, "Same as -A", 0 },
  81   { "format", 'f', "FORMAT", 0,
  82     N_("Use the output format FORMAT.  FORMAT can be `bsd', `sysv' or `posix'.  The default is `sysv'"),
  83     0 },
  84   { NULL, 'B', NULL, 0, N_("Same as --format=bsd"), 0 },
  85   { "portability", 'P', NULL, 0, N_("Same as --format=posix"), 0 },
  86   { "radix", 't', "RADIX", 0, N_("Use RADIX for printing symbol values"), 0 },
  87   { "mark-special", OPT_MARK_SPECIAL, NULL, 0, N_("Mark special symbols"), 0 },
  88   { "mark-weak", OPT_MARK_SPECIAL, NULL, OPTION_HIDDEN, "", 0 },
  89   { "print-size", 'S', NULL, 0, N_("Print size of defined symbols"), 0 },
  90
  91   { NULL, 0, NULL, 0, N_("Output options:"), 0 },
  92   { "numeric-sort", 'n', NULL, 0, N_("Sort symbols numerically by address"),
  93     0 },
  94   { "no-sort", 'p', NULL, 0, N_("Do not sort the symbols"), 0 },
  95   { "reverse-sort", 'r', NULL, 0, N_("Reverse the sense of the sort"), 0 },
  96 #ifdef USE_DEMANGLE
  97   { "demangle", 'C', NULL, 0,
  98     N_("Decode low-level symbol names into source code names"), 0 },
  99 #endif
 100   { NULL, 0, NULL, 0, N_("Miscellaneous:"), 0 },
 101   { NULL, 0, NULL, 0, NULL, 0 }
 102 };
 103
 104 /* Short description of program.  */
 105 static const char doc[] = N_("List symbols from FILEs (a.out by default).");
 106
 107 /* Strings for arguments in help texts.  */
 108 static const char args_doc[] = N_("[FILE...]");
 109
 110 /* Prototype for option handler.  */
 111 static error_t parse_opt (int key, char *arg, struct argp_state *state);
 112
 113 /* Parser children.  */
 114 static struct argp_child argp_children[] =
 115   {
 116     { &color_argp, 0, N_("Output formatting"), 2 },
 117     { NULL, 0, NULL, 0}
 118   };
 119
 120 /* Data structure to communicate with argp functions.  */
 121 static struct argp argp =
 122 {
 123   options, parse_opt, args_doc, doc, argp_children, NULL, NULL
 124 };
 125
 126
 127 /* Print symbols in file named FNAME.  */
 128 static int process_file (const char *fname, bool more_than_one);
 129
 130 /* Handle content of archive.  */
 131 static int handle_ar (int fd, Elf *elf, const char *prefix, const char *fname,
 132                       const char *suffix);
 133
 134 /* Handle ELF file.  */
 135 static int handle_elf (Elf *elf, const char *prefix, const char *fname,
 136                        const char *suffix);
 137
 138
 139 #define INTERNAL_ERROR(fname) \
 140   error (EXIT_FAILURE, 0, gettext ("%s: INTERNAL ERROR %d (%s-%s): %s"),      \
 141          fname, __LINE__, PACKAGE_VERSION, __DATE__, elf_errmsg (-1))
 142
 143
 144 /* Internal representation of symbols.  */
 145 typedef struct GElf_SymX
 146 {
 147   GElf_Sym sym;
 148   Elf32_Word xndx;
 149   char *where;
 150 } GElf_SymX;
 151
 152
 153 /* User-selectable options.  */
 154
 155 /* The selected output format.  */
 156 static enum
 157 {
 158   format_sysv = 0,
 159   format_bsd,
 160   format_posix
 161 } format;
 162
 163 /* Print defined, undefined, or both?  */
 164 static bool hide_undefined;
 165 static bool hide_defined;
 166
 167 /* Print local symbols also?  */
 168 static bool hide_local;
 169
 170 /* Nonzero if full filename should precede every symbol.  */
 171 static bool print_file_name;
 172
 173 /* If true print size of defined symbols in BSD format.  */
 174 static bool print_size;
 175
 176 /* If true print archive index.  */
 177 static bool print_armap;
 178
 179 /* If true reverse sorting.  */
 180 static bool reverse_sort;
 181
 182 #ifdef USE_DEMANGLE
 183 /* If true demangle symbols.  */
 184 static bool demangle;
 185 #endif
 186
 187 /* Type of the section we are printing.  */
 188 static GElf_Word symsec_type = SHT_SYMTAB;
 189
 190 /* Sorting selection.  */
 191 static enum
 192 {
 193   sort_name = 0,
 194   sort_numeric,
 195   sort_nosort
 196 } sort;
 197
 198 /* Radix for printed numbers.  */
 199 static enum
 200 {
 201   radix_hex = 0,
 202   radix_decimal,
 203   radix_octal
 204 } radix;
 205
 206 /* If nonzero mark special symbols:
 207    - weak symbols are distinguished from global symbols by adding
 208      a `*' after the identifying letter for the symbol class and type.
 209    - TLS symbols are distinguished from normal symbols by adding
 210      a '@' after the identifying letter for the symbol class and type.  */
 211 static bool mark_special;
 212
 213
 214 int
 215 main (int argc, char *argv[])
 216 {
 217   int remaining;
 218   int result = 0;
 219
 220   /* Make memory leak detection possible.  */
 221   mtrace ();
 222
 223   /* We use no threads here which can interfere with handling a stream.  */
 224   (void) __fsetlocking (stdin, FSETLOCKING_BYCALLER);
 225   (void) __fsetlocking (stdout, FSETLOCKING_BYCALLER);
 226   (void) __fsetlocking (stderr, FSETLOCKING_BYCALLER);
 227
 228   /* Set locale.  */
 229   (void) setlocale (LC_ALL, "");
 230
 231   /* Make sure the message catalog can be found.  */
 232   (void) bindtextdomain (PACKAGE_TARNAME, LOCALEDIR);
 233
 234   /* Initialize the message catalog.  */
 235   (void) textdomain (PACKAGE_TARNAME);
 236
 237   /* Parse and process arguments.  */
 238   (void) argp_parse (&argp, argc, argv, 0, &remaining, NULL);
 239
 240   /* Tell the library which version we are expecting.  */
 241   (void) elf_version (EV_CURRENT);
 242
 243   if (remaining == argc)
 244     /* The user didn't specify a name so we use a.out.  */
 245     result = process_file ("a.out", false);
 246   else
 247     {
 248       /* Process all the remaining files.  */
 249       const bool more_than_one = remaining + 1 < argc;
 250
 251       do
 252         result |= process_file (argv[remaining], more_than_one);
 253       while (++remaining < argc);
 254     }
 255
 256   return result;
 257 }
 258
 259
 260 /* Print the version information.  */
 261 static void
 262 print_version (FILE *stream, struct argp_state *state __attribute__ ((unused)))
 263 {
 264   fprintf (stream, "nm (%s) %s\n", PACKAGE_NAME, PACKAGE_VERSION);
 265   fprintf (stream, gettext ("\
 266 Copyright (C) %s Red Hat, Inc.\n\
 267 This is free software; see the source for copying conditions.  There is NO\n\
 268 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
 269 "), "2012");
 270   fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
 271 }
 272
 273
 274 /* Handle program arguments.  */
 275 static error_t
 276 parse_opt (int key, char *arg,
 277            struct argp_state *state __attribute__ ((unused)))
 278 {
 279   switch (key)
 280     {
 281     case 'a':
 282       /* XXX */
 283       break;
 284
 285 #ifdef USE_DEMANGLE
 286     case 'C':
 287       demangle = true;
 288       break;
 289 #endif
 290
 291     case 'f':
 292       if (strcmp (arg, "bsd") == 0)
 293         format = format_bsd;
 294       else if (strcmp (arg, "posix") == 0)
 295         format = format_posix;
 296       else
 297         /* Be bug compatible.  The BFD implementation also defaulted to
 298            using the SysV format if nothing else matches.  */
 299         format = format_sysv;
 300       break;
 301
 302     case 'g':
 303       hide_local = true;
 304       break;
 305
 306     case 'n':
 307       sort = sort_numeric;
 308       break;
 309
 310     case 'p':
 311       sort = sort_nosort;
 312       break;
 313
 314     case 't':
 315       if (strcmp (arg, "10") == 0 || strcmp (arg, "d") == 0)
 316         radix = radix_decimal;
 317       else if (strcmp (arg, "8") == 0 || strcmp (arg, "o") == 0)
 318         radix = radix_octal;
 319       else
 320         radix = radix_hex;
 321       break;
 322
 323     case 'u':
 324       hide_undefined = false;
 325       hide_defined = true;
 326       break;
 327
 328     case 'A':
 329     case 'o':
 330       print_file_name = true;
 331       break;
 332
 333     case 'B':
 334       format = format_bsd;
 335       break;
 336
 337     case 'D':
 338       symsec_type = SHT_DYNSYM;
 339       break;
 340
 341     case 'P':
 342       format = format_posix;
 343       break;
 344
 345     case OPT_DEFINED:
 346       hide_undefined = true;
 347       hide_defined = false;
 348       break;
 349
 350     case OPT_MARK_SPECIAL:
 351       mark_special = true;
 352       break;
 353
 354     case 'S':
 355       print_size = true;
 356       break;
 357
 358     case 's':
 359       print_armap = true;
 360       break;
 361
 362     case 'r':
 363       reverse_sort = true;
 364       break;
 365
 366     default:
 367       return ARGP_ERR_UNKNOWN;
 368     }
 369   return 0;
 370 }
 371
 372
 373 /* Open the file and determine the type.  */
 374 static int
 375 process_file (const char *fname, bool more_than_one)
 376 {
 377   /* Open the file.  */
 378   int fd = open (fname, O_RDONLY);
 379   if (fd == -1)
 380     {
 381       error (0, errno, gettext ("cannot open '%s'"), fname);
 382       return 1;
 383     }
 384
 385   /* Now get the ELF descriptor.  */
 386   Elf *elf = elf_begin (fd, ELF_C_READ_MMAP, NULL);
 387   if (elf != NULL)
 388     {
 389       if (elf_kind (elf) == ELF_K_ELF)
 390         {
 391           int result = handle_elf (elf, more_than_one ? "" : NULL,
 392                                    fname, NULL);
 393
 394           if (elf_end (elf) != 0)
 395             INTERNAL_ERROR (fname);
 396
 397           if (close (fd) != 0)
 398             error (EXIT_FAILURE, errno, gettext ("while closing '%s'"), fname);
 399
 400           return result;
 401         }
 402       else if (elf_kind (elf) == ELF_K_AR)
 403         {
 404           int result = handle_ar (fd, elf, NULL, fname, NULL);
 405
 406           if (elf_end (elf) != 0)
 407             INTERNAL_ERROR (fname);
 408
 409           if (close (fd) != 0)
 410             error (EXIT_FAILURE, errno, gettext ("while closing '%s'"), fname);
 411
 412           return result;
 413         }
 414
 415       /* We cannot handle this type.  Close the descriptor anyway.  */
 416       if (elf_end (elf) != 0)
 417         INTERNAL_ERROR (fname);
 418     }
 419
 420   error (0, 0, gettext ("%s: File format not recognized"), fname);
 421
 422   return 1;
 423 }
 424
 425
 426 static int
 427 handle_ar (int fd, Elf *elf, const char *prefix, const char *fname,
 428            const char *suffix)
 429 {
 430   size_t fname_len = strlen (fname) + 1;
 431   size_t prefix_len = prefix != NULL ? strlen (prefix) : 0;
 432   char new_prefix[prefix_len + fname_len + 2];
 433   size_t suffix_len = suffix != NULL ? strlen (suffix) : 0;
 434   char new_suffix[suffix_len + 2];
 435   Elf *subelf;
 436   Elf_Cmd cmd = ELF_C_READ_MMAP;
 437   int result = 0;
 438
 439   char *cp = new_prefix;
 440   if (prefix != NULL)
 441     cp = stpcpy (cp, prefix);
 442   cp = stpcpy (cp, fname);
 443   stpcpy (cp, "[");
 444
 445   cp = new_suffix;
 446   if (suffix != NULL)
 447     cp = stpcpy (cp, suffix);
 448   stpcpy (cp, "]");
 449
 450   /* First print the archive index if this is wanted.  */
 451   if (print_armap)
 452     {
 453       Elf_Arsym *arsym = elf_getarsym (elf, NULL);
 454
 455       if (arsym != NULL)
 456         {
 457           Elf_Arhdr *arhdr = NULL;
 458           size_t arhdr_off = 0; /* Note: 0 is no valid offset.  */
 459
 460           fputs_unlocked (gettext("\nArchive index:\n"), stdout);
 461
 462           while (arsym->as_off != 0)
 463             {
 464               if (arhdr_off != arsym->as_off
 465                   && (elf_rand (elf, arsym->as_off) != arsym->as_off
 466                       || (subelf = elf_begin (fd, cmd, elf)) == NULL
 467                       || (arhdr = elf_getarhdr (subelf)) == NULL))
 468                 {
 469                   error (0, 0, gettext ("invalid offset %zu for symbol %s"),
 470                          arsym->as_off, arsym->as_name);
 471                   continue;
 472                 }
 473
 474               printf (gettext ("%s in %s\n"), arsym->as_name, arhdr->ar_name);
 475
 476               ++arsym;
 477             }
 478
 479           if (elf_rand (elf, SARMAG) != SARMAG)
 480             {
 481               error (0, 0,
 482                      gettext ("cannot reset archive offset to beginning"));
 483               return 1;
 484             }
 485         }
 486     }
 487
 488   /* Process all the files contained in the archive.  */
 489   while ((subelf = elf_begin (fd, cmd, elf)) != NULL)
 490     {
 491       /* The the header for this element.  */
 492       Elf_Arhdr *arhdr = elf_getarhdr (subelf);
 493
 494       /* Skip over the index entries.  */
 495       if (strcmp (arhdr->ar_name, "/") != 0
 496           && strcmp (arhdr->ar_name, "//") != 0)
 497         {
 498           if (elf_kind (subelf) == ELF_K_ELF)
 499             result |= handle_elf (subelf, new_prefix, arhdr->ar_name,
 500                                   new_suffix);
 501           else if (elf_kind (subelf) == ELF_K_AR)
 502             result |= handle_ar (fd, subelf, new_prefix, arhdr->ar_name,
 503                                  new_suffix);
 504           else
 505             {
 506               error (0, 0, gettext ("%s%s%s: file format not recognized"),
 507                      new_prefix, arhdr->ar_name, new_suffix);
 508               result = 1;
 509             }
 510         }
 511
 512       /* Get next archive element.  */
 513       cmd = elf_next (subelf);
 514       if (elf_end (subelf) != 0)
 515         INTERNAL_ERROR (fname);
 516     }
 517
 518   return result;
 519 }
 520
 521
 522 /* Mapping of radix and binary class to length.  */
 523 static const int length_map[2][3] =
 524 {
 525   [ELFCLASS32 - 1] =
 526   {
 527     [radix_hex] = 8,
 528     [radix_decimal] = 10,
 529     [radix_octal] = 11
 530   },
 531   [ELFCLASS64 - 1] =
 532   {
 533     [radix_hex] = 16,
 534     [radix_decimal] = 20,
 535     [radix_octal] = 22
 536   }
 537 };
 538
 539
 540 static int
 541 global_compare (const void *p1, const void *p2)
 542 {
 543   const Dwarf_Global *g1 = (const Dwarf_Global *) p1;
 544   const Dwarf_Global *g2 = (const Dwarf_Global *) p2;
 545
 546   return strcmp (g1->name, g2->name);
 547 }
 548
 549
 550 static void *global_root;
 551
 552
 553 static int
 554 get_global (Dwarf *dbg __attribute__ ((unused)), Dwarf_Global *global,
 555             void *arg __attribute__ ((unused)))
 556 {
 557   tsearch (memcpy (xmalloc (sizeof (Dwarf_Global)), global,
 558                    sizeof (Dwarf_Global)),
 559            &global_root, global_compare);
 560
 561   return DWARF_CB_OK;
 562 }
 563
 564
 565 struct local_name
 566 {
 567   const char *name;
 568   const char *file;
 569   Dwarf_Word lineno;
 570   Dwarf_Addr lowpc;
 571   Dwarf_Addr highpc;
 572 };
 573
 574
 575 static int
 576 local_compare (const void *p1, const void *p2)
 577 {
 578   struct local_name *g1 = (struct local_name *) p1;
 579   struct local_name *g2 = (struct local_name *) p2;
 580   int result;
 581
 582   result = strcmp (g1->name, g2->name);
 583   if (result == 0)
 584     {
 585       if (g1->lowpc <= g2->lowpc && g1->highpc >= g2->highpc)
 586         {
 587           /* g2 is contained in g1.  Update the data.  */
 588           g2->lowpc = g1->lowpc;
 589           g2->highpc = g1->highpc;
 590           result = 0;
 591         }
 592       else if (g2->lowpc <= g1->lowpc && g2->highpc >= g1->highpc)
 593         {
 594           /* g1 is contained in g2.  Update the data.  */
 595           g1->lowpc = g2->lowpc;
 596           g1->highpc = g2->highpc;
 597           result = 0;
 598         }
 599       else
 600         result = g1->lowpc < g2->lowpc ? -1 : 1;
 601     }
 602
 603   return result;
 604 }
 605
 606
 607 static int
 608 get_var_range (Dwarf_Die *die, Dwarf_Word *lowpc, Dwarf_Word *highpc)
 609 {
 610   Dwarf_Attribute locattr_mem;
 611   Dwarf_Attribute *locattr = dwarf_attr (die, DW_AT_location, &locattr_mem);
 612   if  (locattr == NULL)
 613     return 1;
 614
 615   Dwarf_Op *loc;
 616   size_t nloc;
 617   if (dwarf_getlocation (locattr, &loc, &nloc) != 0)
 618     return 1;
 619
 620   /* Interpret the location expressions.  */
 621   // XXX For now just the simple one:
 622   if (nloc == 1 && loc[0].atom == DW_OP_addr)
 623     {
 624       *lowpc = *highpc = loc[0].number;
 625       return 0;
 626     }
 627
 628   return 1;
 629 }
 630
 631
 632
 633 static void *local_root;
 634
 635
 636 static void
 637 get_local_names (Dwarf *dbg)
 638 {
 639   Dwarf_Off offset = 0;
 640   Dwarf_Off old_offset;
 641   size_t hsize;
 642
 643   while (dwarf_nextcu (dbg, old_offset = offset, &offset, &hsize, NULL, NULL,
 644                        NULL) == 0)
 645     {
 646       Dwarf_Die cudie_mem;
 647       Dwarf_Die *cudie = dwarf_offdie (dbg, old_offset + hsize, &cudie_mem);
 648
 649       /* If we cannot get the CU DIE there is no need to go on with
 650          this CU.  */
 651       if (cudie == NULL)
 652         continue;
 653       /* This better be a CU DIE.  */
 654       if (dwarf_tag (cudie) != DW_TAG_compile_unit)
 655         continue;
 656
 657       /* Get the line information.  */
 658       Dwarf_Files *files;
 659       size_t nfiles;
 660       if (dwarf_getsrcfiles (cudie, &files, &nfiles) != 0)
 661         continue;
 662
 663       Dwarf_Die die_mem;
 664       Dwarf_Die *die = &die_mem;
 665       if (dwarf_child (cudie, die) == 0)
 666         /* Iterate over all immediate children of the CU DIE.  */
 667         do
 668           {
 669             int tag = dwarf_tag (die);
 670             if (tag != DW_TAG_subprogram && tag != DW_TAG_variable)
 671               continue;
 672
 673             /* We are interested in five attributes: name, decl_file,
 674                decl_line, low_pc, and high_pc.  */
 675             Dwarf_Attribute attr_mem;
 676             Dwarf_Attribute *attr = dwarf_attr (die, DW_AT_name, &attr_mem);
 677             const char *name = dwarf_formstring (attr);
 678             if (name == NULL)
 679               continue;
 680
 681             Dwarf_Word fileidx;
 682             attr = dwarf_attr (die, DW_AT_decl_file, &attr_mem);
 683             if (dwarf_formudata (attr, &fileidx) != 0 || fileidx >= nfiles)
 684               continue;
 685
 686             Dwarf_Word lineno;
 687             attr = dwarf_attr (die, DW_AT_decl_line, &attr_mem);
 688             if (dwarf_formudata (attr, &lineno) != 0 || lineno == 0)
 689               continue;
 690
 691             Dwarf_Addr lowpc;
 692             Dwarf_Addr highpc;
 693             if (tag == DW_TAG_subprogram)
 694               {
 695                 if (dwarf_lowpc (die, &lowpc) != 0
 696                     || dwarf_highpc (die, &highpc) != 0)
 697                   continue;
 698               }
 699             else
 700               {
 701                 if (get_var_range (die, &lowpc, &highpc) != 0)
 702                   continue;
 703               }
 704
 705             /* We have all the information.  Create a record.  */
 706             struct local_name *newp
 707               = (struct local_name *) xmalloc (sizeof (*newp));
 708             newp->name = name;
 709             newp->file = dwarf_filesrc (files, fileidx, NULL, NULL);
 710             newp->lineno = lineno;
 711             newp->lowpc = lowpc;
 712             newp->highpc = highpc;
 713
 714             /* Since we cannot deallocate individual memory we do not test
 715                for duplicates in the tree.  This should not happen anyway.  */
 716             if (tsearch (newp, &local_root, local_compare) == NULL)
 717               error (EXIT_FAILURE, errno,
 718                      gettext ("cannot create search tree"));
 719           }
 720         while (dwarf_siblingof (die, die) == 0);
 721     }
 722 }
 723
 724 /* Do elf_strptr, but return a backup string and never NULL.  */
 725 static const char *
 726 sym_name (Elf *elf, GElf_Word strndx, GElf_Word st_name, char buf[], size_t n)
 727 {
 728   const char *symstr = elf_strptr (elf, strndx, st_name);
 729   if (symstr == NULL)
 730     {
 731       snprintf (buf, n, "[invalid st_name %#" PRIx32 "]", st_name);
 732       symstr = buf;
 733     }
 734   return symstr;
 735 }
 736
 737 /* Show symbols in SysV format.  */
 738 static void
 739 show_symbols_sysv (Ebl *ebl, GElf_Word strndx, const char *fullname,
 740                    GElf_SymX *syms, size_t nsyms, int longest_name,
 741                    int longest_where)
 742 {
 743   size_t shnum;
 744   if (elf_getshdrnum (ebl->elf, &shnum) < 0)
 745     INTERNAL_ERROR (fullname);
 746
 747   bool scnnames_malloced = shnum * sizeof (const char *) > 128 * 1024;
 748   const char **scnnames;
 749   if (scnnames_malloced)
 750     scnnames = (const char **) xmalloc (sizeof (const char *) * shnum);
 751   else
 752     scnnames = (const char **) alloca (sizeof (const char *) * shnum);
 753   /* Get the section header string table index.  */
 754   size_t shstrndx;
 755   if (elf_getshdrstrndx (ebl->elf, &shstrndx) < 0)
 756     error (EXIT_FAILURE, 0,
 757            gettext ("cannot get section header string table index"));
 758
 759   /* Cache the section names.  */
 760   Elf_Scn *scn = NULL;
 761   size_t cnt = 1;
 762   while ((scn = elf_nextscn (ebl->elf, scn)) != NULL)
 763     {
 764       GElf_Shdr shdr_mem;
 765
 766       assert (elf_ndxscn (scn) == cnt);
 767       cnt++;
 768
 769       char *name = elf_strptr (ebl->elf, shstrndx,
 770                                gelf_getshdr (scn, &shdr_mem)->sh_name);
 771       if (unlikely (name == NULL))
 772         {
 773           const size_t bufsz = sizeof "[invalid sh_name 0x12345678]";
 774           name = alloca (bufsz);
 775           snprintf (name, bufsz, "[invalid sh_name %#" PRIx32 "]",
 776                     gelf_getshdr (scn, &shdr_mem)->sh_name);
 777         }
 778       scnnames[elf_ndxscn (scn)] = name;
 779     }
 780
 781   int digits = length_map[gelf_getclass (ebl->elf) - 1][radix];
 782
 783   /* We always print this prolog.  */
 784   printf (gettext ("\n\nSymbols from %s:\n\n"), fullname);
 785
 786   /* The header line.  */
 787   printf (gettext ("%*s%-*s %-*s Class  Type     %-*s %*s Section\n\n"),
 788           print_file_name ? (int) strlen (fullname) + 1: 0, "",
 789           longest_name, sgettext ("sysv|Name"),
 790           /* TRANS: the "sysv|" parts makes the string unique.  */
 791           digits, sgettext ("sysv|Value"),
 792           /* TRANS: the "sysv|" parts makes the string unique.  */
 793           digits, sgettext ("sysv|Size"),
 794           /* TRANS: the "sysv|" parts makes the string unique.  */
 795           longest_where, sgettext ("sysv|Line"));
 796
 797 #ifdef USE_DEMANGLE
 798   size_t demangle_buffer_len = 0;
 799   char *demangle_buffer = NULL;
 800 #endif
 801
 802   /* Iterate over all symbols.  */
 803   for (cnt = 1; cnt < nsyms; ++cnt)
 804     {
 805       /* In this format SECTION entries are not printed.  */
 806       if (GELF_ST_TYPE (syms[cnt].sym.st_info) == STT_SECTION)
 807         continue;
 808
 809       char symstrbuf[50];
 810       const char *symstr = sym_name (ebl->elf, strndx, syms[cnt].sym.st_name,
 811                                      symstrbuf, sizeof symstrbuf);
 812
 813 #ifdef USE_DEMANGLE
 814       /* Demangle if necessary.  Require GNU v3 ABI by the "_Z" prefix.  */
 815       if (demangle && symstr[0] == '_' && symstr[1] == 'Z')
 816         {
 817           int status = -1;
 818           char *dmsymstr = __cxa_demangle (symstr, demangle_buffer,
 819                                            &demangle_buffer_len, &status);
 820
 821           if (status == 0)
 822             symstr = dmsymstr;
 823         }
 824 #endif
 825
 826       char symbindbuf[50];
 827       char symtypebuf[50];
 828       char secnamebuf[1024];
 829       char addressbuf[(64 + 2) / 3 + 1];
 830       char sizebuf[(64 + 2) / 3 + 1];
 831
 832       /* If we have to precede the line with the file name.  */
 833       if (print_file_name)
 834         {
 835           fputs_unlocked (fullname, stdout);
 836           putchar_unlocked (':');
 837         }
 838
 839       /* Covert the address.  */
 840       if (syms[cnt].sym.st_shndx == SHN_UNDEF)
 841         addressbuf[0] = sizebuf[0] = '\0';
 842       else
 843         {
 844           snprintf (addressbuf, sizeof (addressbuf),
 845                     (radix == radix_hex ? "%0*" PRIx64
 846                      : (radix == radix_decimal ? "%0*" PRId64
 847                         : "%0*" PRIo64)),
 848                     digits, syms[cnt].sym.st_value);
 849           snprintf (sizebuf, sizeof (sizebuf),
 850                     (radix == radix_hex ? "%0*" PRIx64
 851                      : (radix == radix_decimal ? "%0*" PRId64
 852                         : "%0*" PRIo64)),
 853                     digits, syms[cnt].sym.st_size);
 854         }
 855
 856       /* Print the actual string.  */
 857       printf ("%-*s|%s|%-6s|%-8s|%s|%*s|%s\n",
 858               longest_name, symstr, addressbuf,
 859               ebl_symbol_binding_name (ebl,
 860                                        GELF_ST_BIND (syms[cnt].sym.st_info),
 861                                        symbindbuf, sizeof (symbindbuf)),
 862               ebl_symbol_type_name (ebl, GELF_ST_TYPE (syms[cnt].sym.st_info),
 863                                     symtypebuf, sizeof (symtypebuf)),
 864               sizebuf, longest_where, syms[cnt].where,
 865               ebl_section_name (ebl, syms[cnt].sym.st_shndx, syms[cnt].xndx,
 866                                 secnamebuf, sizeof (secnamebuf), scnnames,
 867                                 shnum));
 868     }
 869
 870 #ifdef USE_DEMANGLE
 871   free (demangle_buffer);
 872 #endif
 873
 874   if (scnnames_malloced)
 875     free (scnnames);
 876 }
 877
 878
 879 static char
 880 class_type_char (Elf *elf, const GElf_Ehdr *ehdr, GElf_Sym *sym)
 881 {
 882   int local_p = GELF_ST_BIND (sym->st_info) == STB_LOCAL;
 883
 884   /* XXX Add support for architecture specific types and classes.  */
 885   if (sym->st_shndx == SHN_ABS)
 886     return local_p ? 'a' : 'A';
 887
 888   if (sym->st_shndx == SHN_UNDEF)
 889     /* Undefined symbols must be global.  */
 890     return 'U';
 891
 892   char result = "NDTSFBD         "[GELF_ST_TYPE (sym->st_info)];
 893
 894   if (result == 'D')
 895     {
 896       /* Special handling: unique data symbols.  */
 897       if (ehdr->e_ident[EI_OSABI] == ELFOSABI_LINUX
 898           && GELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE)
 899         result = 'u';
 900       else
 901         {
 902           GElf_Shdr shdr_mem;
 903           GElf_Shdr *shdr = gelf_getshdr (elf_getscn (elf, sym->st_shndx),
 904                                           &shdr_mem);
 905           if (shdr != NULL)
 906             {
 907               if ((shdr->sh_flags & SHF_WRITE) == 0)
 908                 result = 'R';
 909               else if (shdr->sh_type == SHT_NOBITS)
 910                 result = 'B';
 911             }
 912         }
 913     }
 914
 915   return local_p ? tolower (result) : result;
 916 }
 917
 918
 919 static void
 920 show_symbols_bsd (Elf *elf, const GElf_Ehdr *ehdr, GElf_Word strndx,
 921                   const char *prefix, const char *fname, const char *fullname,
 922                   GElf_SymX *syms, size_t nsyms)
 923 {
 924   int digits = length_map[gelf_getclass (elf) - 1][radix];
 925
 926   if (prefix != NULL && ! print_file_name)
 927     printf ("\n%s:\n", fname);
 928
 929 #ifdef USE_DEMANGLE
 930   size_t demangle_buffer_len = 0;
 931   char *demangle_buffer = NULL;
 932 #endif
 933
 934   /* Iterate over all symbols.  */
 935   for (size_t cnt = 0; cnt < nsyms; ++cnt)
 936     {
 937       char symstrbuf[50];
 938       const char *symstr = sym_name (elf, strndx, syms[cnt].sym.st_name,
 939                                      symstrbuf, sizeof symstrbuf);
 940
 941       /* Printing entries with a zero-length name makes the output
 942          not very well parseable.  Since these entries don't carry
 943          much information we leave them out.  */
 944       if (symstr[0] == '\0')
 945         continue;
 946
 947       /* We do not print the entries for files.  */
 948       if (GELF_ST_TYPE (syms[cnt].sym.st_info) == STT_FILE)
 949         continue;
 950
 951 #ifdef USE_DEMANGLE
 952       /* Demangle if necessary.  Require GNU v3 ABI by the "_Z" prefix.  */
 953       if (demangle && symstr[0] == '_' && symstr[1] == 'Z')
 954         {
 955           int status = -1;
 956           char *dmsymstr = __cxa_demangle (symstr, demangle_buffer,
 957                                            &demangle_buffer_len, &status);
 958
 959           if (status == 0)
 960             symstr = dmsymstr;
 961         }
 962 #endif
 963
 964       /* If we have to precede the line with the file name.  */
 965       if (print_file_name)
 966         {
 967           fputs_unlocked (fullname, stdout);
 968           putchar_unlocked (':');
 969         }
 970
 971       bool is_tls = GELF_ST_TYPE (syms[cnt].sym.st_info) == STT_TLS;
 972       bool is_weak = GELF_ST_BIND (syms[cnt].sym.st_info) == STB_WEAK;
 973       const char *marker = (mark_special
 974                             ? (is_tls ? "@" : (is_weak ? "*" : " ")) : "");
 975
 976       if (syms[cnt].sym.st_shndx == SHN_UNDEF)
 977         {
 978           const char *color = "";
 979           if (color_mode)
 980             {
 981               if (is_tls)
 982                 color = color_undef_tls;
 983               else if (is_weak)
 984                 color = color_undef_weak;
 985               else
 986                 color = color_undef;
 987             }
 988
 989           printf ("%*s %sU%s %s", digits, "", color, marker, symstr);
 990         }
 991       else
 992         {
 993           const char *color = "";
 994           if (color_mode)
 995             {
 996               if (is_tls)
 997                 color = color_tls;
 998               else if (is_weak)
 999                 color = color_weak;
1000               else
1001                 color = color_symbol;
1002             }
1003           if (print_size && syms[cnt].sym.st_size != 0)
1004             {
1005 #define HEXFMT "%6$s%2$0*1$" PRIx64 "%8$s %10$0*9$" PRIx64 " %7$s%3$c%4$s %5$s"
1006 #define DECFMT "%6$s%2$*1$" PRId64 "%8$s %10$*9$" PRId64 " %7$s%3$c%4$s %5$s"
1007 #define OCTFMT "%6$s%2$0*1$" PRIo64 "%8$s %10$0*9$" PRIo64 " %7$s%3$c%4$s %5$s"
1008               printf ((radix == radix_hex ? HEXFMT
1009                        : (radix == radix_decimal ? DECFMT : OCTFMT)),
1010                       digits, syms[cnt].sym.st_value,
1011                       class_type_char (elf, ehdr, &syms[cnt].sym), marker,
1012                       symstr,
1013                       color_mode ? color_address : "",
1014                       color,
1015                       color_mode ? color_off : "",
1016                       digits, (uint64_t) syms[cnt].sym.st_size);
1017 #undef HEXFMT
1018 #undef DECFMT
1019 #undef OCTFMT
1020             }
1021           else
1022             {
1023 #define HEXFMT "%6$s%2$0*1$" PRIx64 "%8$s %7$s%3$c%4$s %5$s"
1024 #define DECFMT "%6$s%2$*1$" PRId64 "%8$s %7$s%3$c%4$s %5$s"
1025 #define OCTFMT "%6$s%2$0*1$" PRIo64 "%8$s %7$s%3$c%4$s %5$s"
1026               printf ((radix == radix_hex ? HEXFMT
1027                        : (radix == radix_decimal ? DECFMT : OCTFMT)),
1028                       digits, syms[cnt].sym.st_value,
1029                       class_type_char (elf, ehdr, &syms[cnt].sym), marker,
1030                       symstr,
1031                       color_mode ? color_address : "",
1032                       color,
1033                       color_mode ? color_off : "");
1034 #undef HEXFMT
1035 #undef DECFMT
1036 #undef OCTFMT
1037             }
1038         }
1039
1040       if (color_mode)
1041         fputs_unlocked (color_off, stdout);
1042       putchar_unlocked ('\n');
1043     }
1044
1045 #ifdef USE_DEMANGLE
1046   free (demangle_buffer);
1047 #endif
1048 }
1049
1050
1051 static void
1052 show_symbols_posix (Elf *elf, const GElf_Ehdr *ehdr, GElf_Word strndx,
1053                     const char *prefix, const char *fullname, GElf_SymX *syms,
1054                     size_t nsyms)
1055 {
1056   if (prefix != NULL && ! print_file_name)
1057     printf ("%s:\n", fullname);
1058
1059   int digits = length_map[gelf_getclass (elf) - 1][radix];
1060
1061 #ifdef USE_DEMANGLE
1062   size_t demangle_buffer_len = 0;
1063   char *demangle_buffer = NULL;
1064 #endif
1065
1066   /* Iterate over all symbols.  */
1067   for (size_t cnt = 0; cnt < nsyms; ++cnt)
1068     {
1069       char symstrbuf[50];
1070       const char *symstr = sym_name (elf, strndx, syms[cnt].sym.st_name,
1071                                      symstrbuf, sizeof symstrbuf);
1072
1073       /* Printing entries with a zero-length name makes the output
1074          not very well parseable.  Since these entries don't carry
1075          much information we leave them out.  */
1076       if (symstr[0] == '\0')
1077         continue;
1078
1079 #ifdef USE_DEMANGLE
1080       /* Demangle if necessary.  Require GNU v3 ABI by the "_Z" prefix.  */
1081       if (demangle && symstr[0] == '_' && symstr[1] == 'Z')
1082         {
1083           int status = -1;
1084           char *dmsymstr = __cxa_demangle (symstr, demangle_buffer,
1085                                            &demangle_buffer_len, &status);
1086
1087           if (status == 0)
1088             symstr = dmsymstr;
1089         }
1090 #endif
1091
1092       /* If we have to precede the line with the file name.  */
1093       if (print_file_name)
1094         {
1095           fputs_unlocked (fullname, stdout);
1096           putchar_unlocked (':');
1097           putchar_unlocked (' ');
1098         }
1099
1100       printf ((radix == radix_hex
1101                ? "%s %c%s %0*" PRIx64 " %0*" PRIx64 "\n"
1102                : (radix == radix_decimal
1103                   ? "%s %c%s %*" PRId64 " %*" PRId64 "\n"
1104                   : "%s %c%s %0*" PRIo64 " %0*" PRIo64 "\n")),
1105               symstr,
1106               class_type_char (elf, ehdr, &syms[cnt].sym),
1107               mark_special
1108               ? (GELF_ST_TYPE (syms[cnt].sym.st_info) == STT_TLS
1109                  ? "@"
1110                  : (GELF_ST_BIND (syms[cnt].sym.st_info) == STB_WEAK
1111                     ? "*" : " "))
1112               : "",
1113               digits, syms[cnt].sym.st_value,
1114               digits, syms[cnt].sym.st_size);
1115     }
1116
1117 #ifdef USE_DEMANGLE
1118   free (demangle_buffer);
1119 #endif
1120 }
1121
1122
1123 /* Maximum size of memory we allocate on the stack.  */
1124 #define MAX_STACK_ALLOC 65536
1125
1126 static int
1127 sort_by_address (const void *p1, const void *p2)
1128 {
1129   GElf_SymX *s1 = (GElf_SymX *) p1;
1130   GElf_SymX *s2 = (GElf_SymX *) p2;
1131
1132   int result = (s1->sym.st_value < s2->sym.st_value
1133                 ? -1 : (s1->sym.st_value == s2->sym.st_value ? 0 : 1));
1134
1135   return reverse_sort ? -result : result;
1136 }
1137
1138 static Elf_Data *sort_by_name_strtab;
1139
1140 static int
1141 sort_by_name (const void *p1, const void *p2)
1142 {
1143   GElf_SymX *s1 = (GElf_SymX *) p1;
1144   GElf_SymX *s2 = (GElf_SymX *) p2;
1145
1146   const char *n1 = sort_by_name_strtab->d_buf + s1->sym.st_name;
1147   const char *n2 = sort_by_name_strtab->d_buf + s2->sym.st_name;
1148
1149   int result = strcmp (n1, n2);
1150
1151   return reverse_sort ? -result : result;
1152 }
1153
1154 static void
1155 show_symbols (Ebl *ebl, GElf_Ehdr *ehdr, Elf_Scn *scn, Elf_Scn *xndxscn,
1156               GElf_Shdr *shdr, const char *prefix, const char *fname,
1157               const char *fullname)
1158 {
1159   /* Get the section header string table index.  */
1160   size_t shstrndx;
1161   if (elf_getshdrstrndx (ebl->elf, &shstrndx) < 0)
1162     error (EXIT_FAILURE, 0,
1163            gettext ("cannot get section header string table index"));
1164
1165   /* The section is that large.  */
1166   size_t size = shdr->sh_size;
1167   /* One entry is this large.  */
1168   size_t entsize = shdr->sh_entsize;
1169
1170   /* Consistency checks.  */
1171   if (entsize != gelf_fsize (ebl->elf, ELF_T_SYM, 1, ehdr->e_version))
1172     error (0, 0,
1173            gettext ("%s: entry size in section `%s' is not what we expect"),
1174            fullname, elf_strptr (ebl->elf, shstrndx, shdr->sh_name));
1175   else if (size % entsize != 0)
1176     error (0, 0,
1177            gettext ("%s: size of section `%s' is not multiple of entry size"),
1178            fullname, elf_strptr (ebl->elf, shstrndx, shdr->sh_name));
1179
1180   /* Compute number of entries.  Handle buggy entsize values.  */
1181   size_t nentries = size / (entsize ?: 1);
1182
1183
1184 #define obstack_chunk_alloc xmalloc
1185 #define obstack_chunk_free free
1186   struct obstack whereob;
1187   obstack_init (&whereob);
1188
1189   /* Get a DWARF debugging descriptor.  It's no problem if this isn't
1190      possible.  We just won't print any line number information.  */
1191   Dwarf *dbg = NULL;
1192   if (format == format_sysv)
1193     {
1194       dbg = dwarf_begin_elf (ebl->elf, DWARF_C_READ, NULL);
1195       if (dbg != NULL)
1196         {
1197           (void) dwarf_getpubnames (dbg, get_global, NULL, 0);
1198
1199           get_local_names (dbg);
1200         }
1201     }
1202
1203   /* Allocate the memory.
1204
1205      XXX We can use a dirty trick here.  Since GElf_Sym == Elf64_Sym we
1206      can use the data memory instead of copying again if what we read
1207      is a 64 bit file.  */
1208   GElf_SymX *sym_mem;
1209   if (nentries * sizeof (GElf_SymX) < MAX_STACK_ALLOC)
1210     sym_mem = (GElf_SymX *) alloca (nentries * sizeof (GElf_SymX));
1211   else
1212     sym_mem = (GElf_SymX *) xmalloc (nentries * sizeof (GElf_SymX));
1213
1214   /* Get the data of the section.  */
1215   Elf_Data *data = elf_getdata (scn, NULL);
1216   Elf_Data *xndxdata = elf_getdata (xndxscn, NULL);
1217   if (data == NULL || (xndxscn != NULL && xndxdata == NULL))
1218     INTERNAL_ERROR (fullname);
1219
1220   /* Iterate over all symbols.  */
1221 #ifdef USE_DEMANGLE
1222   size_t demangle_buffer_len = 0;
1223   char *demangle_buffer = NULL;
1224 #endif
1225   int longest_name = 4;
1226   int longest_where = 4;
1227   size_t nentries_used = 0;
1228   for (size_t cnt = 0; cnt < nentries; ++cnt)
1229     {
1230       GElf_Sym *sym = gelf_getsymshndx (data, xndxdata, cnt,
1231                                         &sym_mem[nentries_used].sym,
1232                                         &sym_mem[nentries_used].xndx);
1233       if (sym == NULL)
1234         INTERNAL_ERROR (fullname);
1235
1236       /* Filter out administrative symbols without a name and those
1237          deselected by the user with command line options.  */
1238       if ((hide_undefined && sym->st_shndx == SHN_UNDEF)
1239           || (hide_defined && sym->st_shndx != SHN_UNDEF)
1240           || (hide_local && GELF_ST_BIND (sym->st_info) == STB_LOCAL))
1241         continue;
1242
1243       sym_mem[nentries_used].where = "";
1244       if (format == format_sysv)
1245         {
1246           const char *symstr = elf_strptr (ebl->elf, shdr->sh_link,
1247                                            sym->st_name);
1248           if (symstr == NULL)
1249             continue;
1250
1251 #ifdef USE_DEMANGLE
1252           /* Demangle if necessary.  Require GNU v3 ABI by the "_Z" prefix.  */
1253           if (demangle && symstr[0] == '_' && symstr[1] == 'Z')
1254             {
1255               int status = -1;
1256               char *dmsymstr = __cxa_demangle (symstr, demangle_buffer,
1257                                                &demangle_buffer_len, &status);
1258
1259               if (status == 0)
1260                 symstr = dmsymstr;
1261             }
1262 #endif
1263
1264           longest_name = MAX ((size_t) longest_name, strlen (symstr));
1265
1266           if (sym->st_shndx != SHN_UNDEF
1267               && GELF_ST_BIND (sym->st_info) != STB_LOCAL
1268               && global_root != NULL)
1269             {
1270               Dwarf_Global fake = { .name = symstr };
1271               Dwarf_Global **found = tfind (&fake, &global_root,
1272                                             global_compare);
1273               if (found != NULL)
1274                 {
1275                   Dwarf_Die die_mem;
1276                   Dwarf_Die *die = dwarf_offdie (dbg, (*found)->die_offset,
1277                                                  &die_mem);
1278
1279                   Dwarf_Die cudie_mem;
1280                   Dwarf_Die *cudie = NULL;
1281
1282                   Dwarf_Addr lowpc;
1283                   Dwarf_Addr highpc;
1284                   if (die != NULL
1285                       && dwarf_lowpc (die, &lowpc) == 0
1286                       && lowpc <= sym->st_value
1287                       && dwarf_highpc (die, &highpc) == 0
1288                       && highpc > sym->st_value)
1289                     cudie = dwarf_offdie (dbg, (*found)->cu_offset,
1290                                           &cudie_mem);
1291                   if (cudie != NULL)
1292                     {
1293                       Dwarf_Line *line = dwarf_getsrc_die (cudie,
1294                                                            sym->st_value);
1295                       if (line != NULL)
1296                         {
1297                           /* We found the line.  */
1298                           int lineno;
1299                           (void) dwarf_lineno (line, &lineno);
1300                           int n;
1301                           n = obstack_printf (&whereob, "%s:%d%c",
1302                                               basename (dwarf_linesrc (line,
1303                                                                        NULL,
1304                                                                        NULL)),
1305                                               lineno, '\0');
1306                           sym_mem[nentries_used].where
1307                             = obstack_finish (&whereob);
1308
1309                           /* The return value of obstack_print included the
1310                              NUL byte, so subtract one.  */
1311                           if (--n > (int) longest_where)
1312                             longest_where = (size_t) n;
1313                         }
1314                     }
1315                 }
1316             }
1317
1318           /* Try to find the symbol among the local symbols.  */
1319           if (sym_mem[nentries_used].where[0] == '\0')
1320             {
1321               struct local_name fake =
1322                 {
1323                   .name = symstr,
1324                   .lowpc = sym->st_value,
1325                   .highpc = sym->st_value,
1326                 };
1327               struct local_name **found = tfind (&fake, &local_root,
1328                                                  local_compare);
1329               if (found != NULL)
1330                 {
1331                   /* We found the line.  */
1332                   int n = obstack_printf (&whereob, "%s:%" PRIu64 "%c",
1333                                           basename ((*found)->file),
1334                                           (*found)->lineno,
1335                                           '\0');
1336                   sym_mem[nentries_used].where = obstack_finish (&whereob);
1337
1338                   /* The return value of obstack_print included the
1339                      NUL byte, so subtract one.  */
1340                   if (--n > (int) longest_where)
1341                     longest_where = (size_t) n;
1342                 }
1343             }
1344         }
1345
1346       /* We use this entry.  */
1347       ++nentries_used;
1348     }
1349 #ifdef USE_DEMANGLE
1350   free (demangle_buffer);
1351 #endif
1352   /* Now we know the exact number.  */
1353   nentries = nentries_used;
1354
1355   /* Sort the entries according to the users wishes.  */
1356   if (sort == sort_name)
1357     {
1358       sort_by_name_strtab = elf_getdata (elf_getscn (ebl->elf, shdr->sh_link),
1359                                          NULL);
1360       qsort (sym_mem, nentries, sizeof (GElf_SymX), sort_by_name);
1361     }
1362   else if (sort == sort_numeric)
1363     qsort (sym_mem, nentries, sizeof (GElf_SymX), sort_by_address);
1364
1365   /* Finally print according to the users selection.  */
1366   switch (format)
1367     {
1368     case format_sysv:
1369       show_symbols_sysv (ebl, shdr->sh_link, fullname, sym_mem, nentries,
1370                          longest_name, longest_where);
1371       break;
1372
1373     case format_bsd:
1374       show_symbols_bsd (ebl->elf, ehdr, shdr->sh_link, prefix, fname, fullname,
1375                         sym_mem, nentries);
1376       break;
1377
1378     case format_posix:
1379     default:
1380       assert (format == format_posix);
1381       show_symbols_posix (ebl->elf, ehdr, shdr->sh_link, prefix, fullname,
1382                           sym_mem, nentries);
1383       break;
1384     }
1385
1386   /* Free all memory.  */
1387   if (nentries * sizeof (GElf_Sym) >= MAX_STACK_ALLOC)
1388     free (sym_mem);
1389
1390   obstack_free (&whereob, NULL);
1391
1392   if (dbg != NULL)
1393     {
1394       tdestroy (global_root, free);
1395       global_root = NULL;
1396
1397       tdestroy (local_root, free);
1398       local_root = NULL;
1399
1400       (void) dwarf_end (dbg);
1401     }
1402 }
1403
1404
1405 static int
1406 handle_elf (Elf *elf, const char *prefix, const char *fname,
1407             const char *suffix)
1408 {
1409   size_t prefix_len = prefix == NULL ? 0 : strlen (prefix);
1410   size_t suffix_len = suffix == NULL ? 0 : strlen (suffix);
1411   size_t fname_len = strlen (fname) + 1;
1412   char fullname[prefix_len + 1 + fname_len + suffix_len];
1413   char *cp = fullname;
1414   Elf_Scn *scn = NULL;
1415   int any = 0;
1416   int result = 0;
1417   GElf_Ehdr ehdr_mem;
1418   GElf_Ehdr *ehdr;
1419   Ebl *ebl;
1420
1421   /* Get the backend for this object file type.  */
1422   ebl = ebl_openbackend (elf);
1423
1424   /* We need the ELF header in a few places.  */
1425   ehdr = gelf_getehdr (elf, &ehdr_mem);
1426   if (ehdr == NULL)
1427     INTERNAL_ERROR (fullname);
1428
1429   /* If we are asked to print the dynamic symbol table and this is
1430      executable or dynamic executable, fail.  */
1431   if (symsec_type == SHT_DYNSYM
1432       && ehdr->e_type != ET_EXEC && ehdr->e_type != ET_DYN)
1433     {
1434       /* XXX Add machine specific object file types.  */
1435       error (0, 0, gettext ("%s%s%s%s: Invalid operation"),
1436              prefix ?: "", prefix ? "(" : "", fname, prefix ? ")" : "");
1437       result = 1;
1438       goto out;
1439     }
1440
1441   /* Create the full name of the file.  */
1442   if (prefix != NULL)
1443     cp = mempcpy (cp, prefix, prefix_len);
1444   cp = mempcpy (cp, fname, fname_len);
1445   if (suffix != NULL)
1446     memcpy (cp - 1, suffix, suffix_len + 1);
1447
1448   /* Find the symbol table.
1449
1450      XXX Can there be more than one?  Do we print all?  Currently we do.  */
1451   while ((scn = elf_nextscn (elf, scn)) != NULL)
1452     {
1453       GElf_Shdr shdr_mem;
1454       GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
1455
1456       if (shdr == NULL)
1457         INTERNAL_ERROR (fullname);
1458
1459       if (shdr->sh_type == symsec_type)
1460         {
1461           Elf_Scn *xndxscn = NULL;
1462
1463           /* We have a symbol table.  First make sure we remember this.  */
1464           any = 1;
1465
1466           /* Look for an extended section index table for this section.  */
1467           if (symsec_type == SHT_SYMTAB)
1468             {
1469               size_t scnndx = elf_ndxscn (scn);
1470
1471               while ((xndxscn = elf_nextscn (elf, xndxscn)) != NULL)
1472                 {
1473                   GElf_Shdr xndxshdr_mem;
1474                   GElf_Shdr *xndxshdr = gelf_getshdr (xndxscn, &xndxshdr_mem);
1475
1476                   if (xndxshdr == NULL)
1477                     INTERNAL_ERROR (fullname);
1478
1479                   if (xndxshdr->sh_type == SHT_SYMTAB_SHNDX
1480                       && xndxshdr->sh_link == scnndx)
1481                     break;
1482                 }
1483             }
1484
1485           show_symbols (ebl, ehdr, scn, xndxscn, shdr, prefix, fname,
1486                         fullname);
1487         }
1488     }
1489
1490   if (! any)
1491     {
1492       error (0, 0, gettext ("%s%s%s: no symbols"),
1493              prefix ?: "", prefix ? ":" : "", fname);
1494       result = 1;
1495     }
1496
1497  out:
1498   /* Close the ELF backend library descriptor.  */
1499   ebl_closebackend (ebl);
1500
1501   return result;
1502 }
1503
1504
1505 #include "debugpred.h"