binutils/nm.c

   1 /* nm.c -- Describe symbol table of a rel file.
   2    Copyright (C) 1991-2016 Free Software Foundation, Inc.
   3
   4    This file is part of GNU Binutils.
   5
   6    This program 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    This program is distributed in the hope that it will be useful,
  12    but 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, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  19    02110-1301, USA.  */
  20
  21 #include "sysdep.h"
  22 #include "bfd.h"
  23 #include "progress.h"
  24 #include "getopt.h"
  25 #include "aout/stab_gnu.h"
  26 #include "aout/ranlib.h"
  27 #include "demangle.h"
  28 #include "libiberty.h"
  29 #include "elf-bfd.h"
  30 #include "elf/common.h"
  31 #define DO_NOT_DEFINE_AOUTHDR
  32 #define DO_NOT_DEFINE_FILHDR
  33 #define DO_NOT_DEFINE_LINENO
  34 #define DO_NOT_DEFINE_SCNHDR
  35 #include "coff/external.h"
  36 #include "coff/internal.h"
  37 #include "libcoff.h"
  38 #include "bucomm.h"
  39 #include "plugin-api.h"
  40 #include "plugin.h"
  41
  42 /* When sorting by size, we use this structure to hold the size and a
  43    pointer to the minisymbol.  */
  44
  45 struct size_sym
  46 {
  47   const void *minisym;
  48   bfd_vma size;
  49 };
  50
  51 /* When fetching relocs, we use this structure to pass information to
  52    get_relocs.  */
  53
  54 struct get_relocs_info
  55 {
  56   asection **secs;
  57   arelent ***relocs;
  58   long *relcount;
  59   asymbol **syms;
  60 };
  61
  62 struct extended_symbol_info
  63 {
  64   symbol_info *sinfo;
  65   bfd_vma ssize;
  66   elf_symbol_type *elfinfo;
  67   coff_symbol_type *coffinfo;
  68   /* FIXME: We should add more fields for Type, Line, Section.  */
  69 };
  70 #define SYM_NAME(sym)        (sym->sinfo->name)
  71 #define SYM_VALUE(sym)       (sym->sinfo->value)
  72 #define SYM_TYPE(sym)        (sym->sinfo->type)
  73 #define SYM_STAB_NAME(sym)   (sym->sinfo->stab_name)
  74 #define SYM_STAB_DESC(sym)   (sym->sinfo->stab_desc)
  75 #define SYM_STAB_OTHER(sym)  (sym->sinfo->stab_other)
  76 #define SYM_SIZE(sym) \
  77   (sym->elfinfo ? sym->elfinfo->internal_elf_sym.st_size: sym->ssize)
  78
  79 /* The output formatting functions.  */
  80 static void print_object_filename_bsd (char *);
  81 static void print_object_filename_sysv (char *);
  82 static void print_object_filename_posix (char *);
  83 static void print_archive_filename_bsd (char *);
  84 static void print_archive_filename_sysv (char *);
  85 static void print_archive_filename_posix (char *);
  86 static void print_archive_member_bsd (char *, const char *);
  87 static void print_archive_member_sysv (char *, const char *);
  88 static void print_archive_member_posix (char *, const char *);
  89 static void print_symbol_filename_bsd (bfd *, bfd *);
  90 static void print_symbol_filename_sysv (bfd *, bfd *);
  91 static void print_symbol_filename_posix (bfd *, bfd *);
  92 static void print_value (bfd *, bfd_vma);
  93 static void print_symbol_info_bsd (struct extended_symbol_info *, bfd *);
  94 static void print_symbol_info_sysv (struct extended_symbol_info *, bfd *);
  95 static void print_symbol_info_posix (struct extended_symbol_info *, bfd *);
  96
  97 /* Support for different output formats.  */
  98 struct output_fns
  99   {
 100     /* Print the name of an object file given on the command line.  */
 101     void (*print_object_filename) (char *);
 102
 103     /* Print the name of an archive file given on the command line.  */
 104     void (*print_archive_filename) (char *);
 105
 106     /* Print the name of an archive member file.  */
 107     void (*print_archive_member) (char *, const char *);
 108
 109     /* Print the name of the file (and archive, if there is one)
 110        containing a symbol.  */
 111     void (*print_symbol_filename) (bfd *, bfd *);
 112
 113     /* Print a line of information about a symbol.  */
 114     void (*print_symbol_info) (struct extended_symbol_info *, bfd *);
 115   };
 116
 117 static struct output_fns formats[] =
 118 {
 119   {print_object_filename_bsd,
 120    print_archive_filename_bsd,
 121    print_archive_member_bsd,
 122    print_symbol_filename_bsd,
 123    print_symbol_info_bsd},
 124   {print_object_filename_sysv,
 125    print_archive_filename_sysv,
 126    print_archive_member_sysv,
 127    print_symbol_filename_sysv,
 128    print_symbol_info_sysv},
 129   {print_object_filename_posix,
 130    print_archive_filename_posix,
 131    print_archive_member_posix,
 132    print_symbol_filename_posix,
 133    print_symbol_info_posix}
 134 };
 135
 136 /* Indices in `formats'.  */
 137 #define FORMAT_BSD 0
 138 #define FORMAT_SYSV 1
 139 #define FORMAT_POSIX 2
 140 #define FORMAT_DEFAULT FORMAT_BSD
 141
 142 /* The output format to use.  */
 143 static struct output_fns *format = &formats[FORMAT_DEFAULT];
 144
 145 /* Command options.  */
 146
 147 static int do_demangle = 0;     /* Pretty print C++ symbol names.  */
 148 static int external_only = 0;   /* Print external symbols only.  */
 149 static int defined_only = 0;    /* Print defined symbols only.  */
 150 static int no_sort = 0;         /* Don't sort; print syms in order found.  */
 151 static int print_debug_syms = 0;/* Print debugger-only symbols too.  */
 152 static int print_armap = 0;     /* Describe __.SYMDEF data in archive files.  */
 153 static int print_size = 0;      /* Print size of defined symbols.  */
 154 static int reverse_sort = 0;    /* Sort in downward(alpha or numeric) order.  */
 155 static int sort_numerically = 0;/* Sort in numeric rather than alpha order.  */
 156 static int sort_by_size = 0;    /* Sort by size of symbol.  */
 157 static int undefined_only = 0;  /* Print undefined symbols only.  */
 158 static int dynamic = 0;         /* Print dynamic symbols.  */
 159 static int show_version = 0;    /* Show the version number.  */
 160 static int show_stats = 0;      /* Show statistics.  */
 161 static int show_synthetic = 0;  /* Display synthesized symbols too.  */
 162 static int line_numbers = 0;    /* Print line numbers for symbols.  */
 163 static int allow_special_symbols = 0;  /* Allow special symbols.  */
 164 static int with_symbol_versions = 0; /* Include symbol version information in the output.  */
 165
 166 /* When to print the names of files.  Not mutually exclusive in SYSV format.  */
 167 static int filename_per_file = 0;       /* Once per file, on its own line.  */
 168 static int filename_per_symbol = 0;     /* Once per symbol, at start of line.  */
 169
 170 /* Print formats for printing a symbol value.  */
 171 static char value_format_32bit[] = "%08lx";
 172 #if BFD_HOST_64BIT_LONG
 173 static char value_format_64bit[] = "%016lx";
 174 #elif BFD_HOST_64BIT_LONG_LONG
 175 #ifndef __MSVCRT__
 176 static char value_format_64bit[] = "%016llx";
 177 #else
 178 static char value_format_64bit[] = "%016I64x";
 179 #endif
 180 #endif
 181 static int print_width = 0;
 182 static int print_radix = 16;
 183 /* Print formats for printing stab info.  */
 184 static char other_format[] = "%02x";
 185 static char desc_format[] = "%04x";
 186
 187 static char *target = NULL;
 188 #if BFD_SUPPORTS_PLUGINS
 189 static const char *plugin_target = "plugin";
 190 #else
 191 static const char *plugin_target = NULL;
 192 #endif
 193
 194 /* Used to cache the line numbers for a BFD.  */
 195 static bfd *lineno_cache_bfd;
 196 static bfd *lineno_cache_rel_bfd;
 197
 198 #define OPTION_TARGET 200
 199 #define OPTION_PLUGIN (OPTION_TARGET + 1)
 200 #define OPTION_SIZE_SORT (OPTION_PLUGIN + 1)
 201
 202 static struct option long_options[] =
 203 {
 204   {"debug-syms", no_argument, &print_debug_syms, 1},
 205   {"demangle", optional_argument, 0, 'C'},
 206   {"dynamic", no_argument, &dynamic, 1},
 207   {"extern-only", no_argument, &external_only, 1},
 208   {"format", required_argument, 0, 'f'},
 209   {"help", no_argument, 0, 'h'},
 210   {"line-numbers", no_argument, 0, 'l'},
 211   {"no-cplus", no_argument, &do_demangle, 0},  /* Linux compatibility.  */
 212   {"no-demangle", no_argument, &do_demangle, 0},
 213   {"no-sort", no_argument, 0, 'p'},
 214   {"numeric-sort", no_argument, 0, 'n'},
 215   {"plugin", required_argument, 0, OPTION_PLUGIN},
 216   {"portability", no_argument, 0, 'P'},
 217   {"print-armap", no_argument, &print_armap, 1},
 218   {"print-file-name", no_argument, 0, 'o'},
 219   {"print-size", no_argument, 0, 'S'},
 220   {"radix", required_argument, 0, 't'},
 221   {"reverse-sort", no_argument, &reverse_sort, 1},
 222   {"size-sort", no_argument, 0, OPTION_SIZE_SORT},
 223   {"special-syms", no_argument, &allow_special_symbols, 1},
 224   {"stats", no_argument, &show_stats, 1},
 225   {"synthetic", no_argument, &show_synthetic, 1},
 226   {"target", required_argument, 0, OPTION_TARGET},
 227   {"defined-only", no_argument, &defined_only, 1},
 228   {"undefined-only", no_argument, &undefined_only, 1},
 229   {"version", no_argument, &show_version, 1},
 230   {"with-symbol-versions", no_argument, &with_symbol_versions, 1},
 231   {0, no_argument, 0, 0}
 232 };
 233 \f
 234 /* Some error-reporting functions.  */
 235
 236 ATTRIBUTE_NORETURN static void
 237 usage (FILE *stream, int status)
 238 {
 239   fprintf (stream, _("Usage: %s [option(s)] [file(s)]\n"), program_name);
 240   fprintf (stream, _(" List symbols in [file(s)] (a.out by default).\n"));
 241   fprintf (stream, _(" The options are:\n\
 242   -a, --debug-syms       Display debugger-only symbols\n\
 243   -A, --print-file-name  Print name of the input file before every symbol\n\
 244   -B                     Same as --format=bsd\n\
 245   -C, --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
 246                           The STYLE, if specified, can be `auto' (the default),\n\
 247                           `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
 248                           or `gnat'\n\
 249       --no-demangle      Do not demangle low-level symbol names\n\
 250   -D, --dynamic          Display dynamic symbols instead of normal symbols\n\
 251       --defined-only     Display only defined symbols\n\
 252   -e                     (ignored)\n\
 253   -f, --format=FORMAT    Use the output format FORMAT.  FORMAT can be `bsd',\n\
 254                            `sysv' or `posix'.  The default is `bsd'\n\
 255   -g, --extern-only      Display only external symbols\n\
 256   -l, --line-numbers     Use debugging information to find a filename and\n\
 257                            line number for each symbol\n\
 258   -n, --numeric-sort     Sort symbols numerically by address\n\
 259   -o                     Same as -A\n\
 260   -p, --no-sort          Do not sort the symbols\n\
 261   -P, --portability      Same as --format=posix\n\
 262   -r, --reverse-sort     Reverse the sense of the sort\n"));
 263 #if BFD_SUPPORTS_PLUGINS
 264   fprintf (stream, _("\
 265       --plugin NAME      Load the specified plugin\n"));
 266 #endif
 267   fprintf (stream, _("\
 268   -S, --print-size       Print size of defined symbols\n\
 269   -s, --print-armap      Include index for symbols from archive members\n\
 270       --size-sort        Sort symbols by size\n\
 271       --special-syms     Include special symbols in the output\n\
 272       --synthetic        Display synthetic symbols as well\n\
 273   -t, --radix=RADIX      Use RADIX for printing symbol values\n\
 274       --target=BFDNAME   Specify the target object format as BFDNAME\n\
 275   -u, --undefined-only   Display only undefined symbols\n\
 276       --with-symbol-versions  Display version strings after symbol names\n\
 277   -X 32_64               (ignored)\n\
 278   @FILE                  Read options from FILE\n\
 279   -h, --help             Display this information\n\
 280   -V, --version          Display this program's version number\n\
 281 \n"));
 282   list_supported_targets (program_name, stream);
 283   if (REPORT_BUGS_TO[0] && status == 0)
 284     fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
 285   exit (status);
 286 }
 287
 288 /* Set the radix for the symbol value and size according to RADIX.  */
 289
 290 static void
 291 set_print_radix (char *radix)
 292 {
 293   switch (*radix)
 294     {
 295     case 'x':
 296       break;
 297     case 'd':
 298     case 'o':
 299       if (*radix == 'd')
 300         print_radix = 10;
 301       else
 302         print_radix = 8;
 303       value_format_32bit[4] = *radix;
 304 #if BFD_HOST_64BIT_LONG
 305       value_format_64bit[5] = *radix;
 306 #elif BFD_HOST_64BIT_LONG_LONG
 307 #ifndef __MSVCRT__
 308       value_format_64bit[6] = *radix;
 309 #else
 310       value_format_64bit[7] = *radix;
 311 #endif
 312 #endif
 313       other_format[3] = desc_format[3] = *radix;
 314       break;
 315     default:
 316       fatal (_("%s: invalid radix"), radix);
 317     }
 318 }
 319
 320 static void
 321 set_output_format (char *f)
 322 {
 323   int i;
 324
 325   switch (*f)
 326     {
 327     case 'b':
 328     case 'B':
 329       i = FORMAT_BSD;
 330       break;
 331     case 'p':
 332     case 'P':
 333       i = FORMAT_POSIX;
 334       break;
 335     case 's':
 336     case 'S':
 337       i = FORMAT_SYSV;
 338       break;
 339     default:
 340       fatal (_("%s: invalid output format"), f);
 341     }
 342   format = &formats[i];
 343 }
 344 \f
 345 static const char *
 346 get_elf_symbol_type (unsigned int type)
 347 {
 348   static char *bufp;
 349   int n;
 350
 351   switch (type)
 352     {
 353     case STT_NOTYPE:   return "NOTYPE";
 354     case STT_OBJECT:   return "OBJECT";
 355     case STT_FUNC:     return "FUNC";
 356     case STT_SECTION:  return "SECTION";
 357     case STT_FILE:     return "FILE";
 358     case STT_COMMON:   return "COMMON";
 359     case STT_TLS:      return "TLS";
 360     }
 361
 362   free (bufp);
 363   if (type >= STT_LOPROC && type <= STT_HIPROC)
 364     n = asprintf (&bufp, _("<processor specific>: %d"), type);
 365   else if (type >= STT_LOOS && type <= STT_HIOS)
 366     n = asprintf (&bufp, _("<OS specific>: %d"), type);
 367   else
 368     n = asprintf (&bufp, _("<unknown>: %d"), type);
 369   if (n < 0)
 370     fatal ("%s", xstrerror (errno));
 371   return bufp;
 372 }
 373
 374 static const char *
 375 get_coff_symbol_type (const struct internal_syment *sym)
 376 {
 377   static char *bufp;
 378   int n;
 379
 380   switch (sym->n_sclass)
 381     {
 382     case C_BLOCK: return "Block";
 383     case C_FILE:  return "File";
 384     case C_LINE:  return "Line";
 385     }
 386
 387   if (!sym->n_type)
 388     return "None";
 389
 390   switch (DTYPE(sym->n_type))
 391     {
 392     case DT_FCN: return "Function";
 393     case DT_PTR: return "Pointer";
 394     case DT_ARY: return "Array";
 395     }
 396
 397   free (bufp);
 398   n = asprintf (&bufp, _("<unknown>: %d/%d"), sym->n_sclass, sym->n_type);
 399   if (n < 0)
 400     fatal ("%s", xstrerror (errno));
 401   return bufp;
 402 }
 403 \f
 404 /* Print symbol name NAME, read from ABFD, with printf format FORM,
 405    demangling it if requested.  */
 406
 407 static void
 408 print_symname (const char *form, const char *name, bfd *abfd)
 409 {
 410   if (do_demangle && *name)
 411     {
 412       char *res = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
 413
 414       if (res != NULL)
 415         {
 416           printf (form, res);
 417           free (res);
 418           return;
 419         }
 420     }
 421
 422   printf (form, name);
 423 }
 424
 425 static void
 426 print_symdef_entry (bfd *abfd)
 427 {
 428   symindex idx = BFD_NO_MORE_SYMBOLS;
 429   carsym *thesym;
 430   bfd_boolean everprinted = FALSE;
 431
 432   for (idx = bfd_get_next_mapent (abfd, idx, &thesym);
 433        idx != BFD_NO_MORE_SYMBOLS;
 434        idx = bfd_get_next_mapent (abfd, idx, &thesym))
 435     {
 436       bfd *elt;
 437       if (!everprinted)
 438         {
 439           printf (_("\nArchive index:\n"));
 440           everprinted = TRUE;
 441         }
 442       elt = bfd_get_elt_at_index (abfd, idx);
 443       if (elt == NULL)
 444         bfd_fatal ("bfd_get_elt_at_index");
 445       if (thesym->name != (char *) NULL)
 446         {
 447           print_symname ("%s", thesym->name, abfd);
 448           printf (" in %s\n", bfd_get_filename (elt));
 449         }
 450     }
 451 }
 452 \f
 453 /* Choose which symbol entries to print;
 454    compact them downward to get rid of the rest.
 455    Return the number of symbols to be printed.  */
 456
 457 static long
 458 filter_symbols (bfd *abfd, bfd_boolean is_dynamic, void *minisyms,
 459                 long symcount, unsigned int size)
 460 {
 461   bfd_byte *from, *fromend, *to;
 462   asymbol *store;
 463
 464   store = bfd_make_empty_symbol (abfd);
 465   if (store == NULL)
 466     bfd_fatal (bfd_get_filename (abfd));
 467
 468   from = (bfd_byte *) minisyms;
 469   fromend = from + symcount * size;
 470   to = (bfd_byte *) minisyms;
 471
 472   for (; from < fromend; from += size)
 473     {
 474       int keep = 0;
 475       asymbol *sym;
 476
 477       PROGRESS (1);
 478
 479       sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, (const void *) from, store);
 480       if (sym == NULL)
 481         bfd_fatal (bfd_get_filename (abfd));
 482
 483       if (strcmp (sym->name, "__gnu_lto_slim") == 0)
 484         non_fatal (_("%s: plugin needed to handle lto object"),
 485                    bfd_get_filename (abfd));
 486
 487       if (undefined_only)
 488         keep = bfd_is_und_section (sym->section);
 489       else if (external_only)
 490         /* PR binutls/12753: Unique symbols are global too.  */
 491         keep = ((sym->flags & (BSF_GLOBAL
 492                                | BSF_WEAK
 493                                | BSF_GNU_UNIQUE)) != 0
 494                 || bfd_is_und_section (sym->section)
 495                 || bfd_is_com_section (sym->section));
 496       else
 497         keep = 1;
 498
 499       if (keep
 500           && ! print_debug_syms
 501           && (sym->flags & BSF_DEBUGGING) != 0)
 502         keep = 0;
 503
 504       if (keep
 505           && sort_by_size
 506           && (bfd_is_abs_section (sym->section)
 507               || bfd_is_und_section (sym->section)))
 508         keep = 0;
 509
 510       if (keep
 511           && defined_only)
 512         {
 513           if (bfd_is_und_section (sym->section))
 514             keep = 0;
 515         }
 516
 517       if (keep
 518           && bfd_is_target_special_symbol (abfd, sym)
 519           && ! allow_special_symbols)
 520         keep = 0;
 521
 522       if (keep)
 523         {
 524           if (to != from)
 525             memcpy (to, from, size);
 526           to += size;
 527         }
 528     }
 529
 530   return (to - (bfd_byte *) minisyms) / size;
 531 }
 532 \f
 533 /* These globals are used to pass information into the sorting
 534    routines.  */
 535 static bfd *sort_bfd;
 536 static bfd_boolean sort_dynamic;
 537 static asymbol *sort_x;
 538 static asymbol *sort_y;
 539
 540 /* Symbol-sorting predicates */
 541 #define valueof(x) ((x)->section->vma + (x)->value)
 542
 543 /* Numeric sorts.  Undefined symbols are always considered "less than"
 544    defined symbols with zero values.  Common symbols are not treated
 545    specially -- i.e., their sizes are used as their "values".  */
 546
 547 static int
 548 non_numeric_forward (const void *P_x, const void *P_y)
 549 {
 550   asymbol *x, *y;
 551   const char *xn, *yn;
 552
 553   x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
 554   y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
 555   if (x == NULL || y == NULL)
 556     bfd_fatal (bfd_get_filename (sort_bfd));
 557
 558   xn = bfd_asymbol_name (x);
 559   yn = bfd_asymbol_name (y);
 560
 561   if (yn == NULL)
 562     return xn != NULL;
 563   if (xn == NULL)
 564     return -1;
 565
 566 #ifdef HAVE_STRCOLL
 567   /* Solaris 2.5 has a bug in strcoll.
 568      strcoll returns invalid values when confronted with empty strings.  */
 569   if (*yn == '\0')
 570     return *xn != '\0';
 571   if (*xn == '\0')
 572     return -1;
 573
 574   return strcoll (xn, yn);
 575 #else
 576   return strcmp (xn, yn);
 577 #endif
 578 }
 579
 580 static int
 581 non_numeric_reverse (const void *x, const void *y)
 582 {
 583   return - non_numeric_forward (x, y);
 584 }
 585
 586 static int
 587 numeric_forward (const void *P_x, const void *P_y)
 588 {
 589   asymbol *x, *y;
 590   asection *xs, *ys;
 591
 592   x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
 593   y =  bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
 594   if (x == NULL || y == NULL)
 595     bfd_fatal (bfd_get_filename (sort_bfd));
 596
 597   xs = bfd_get_section (x);
 598   ys = bfd_get_section (y);
 599
 600   if (bfd_is_und_section (xs))
 601     {
 602       if (! bfd_is_und_section (ys))
 603         return -1;
 604     }
 605   else if (bfd_is_und_section (ys))
 606     return 1;
 607   else if (valueof (x) != valueof (y))
 608     return valueof (x) < valueof (y) ? -1 : 1;
 609
 610   return non_numeric_forward (P_x, P_y);
 611 }
 612
 613 static int
 614 numeric_reverse (const void *x, const void *y)
 615 {
 616   return - numeric_forward (x, y);
 617 }
 618
 619 static int (*(sorters[2][2])) (const void *, const void *) =
 620 {
 621   { non_numeric_forward, non_numeric_reverse },
 622   { numeric_forward, numeric_reverse }
 623 };
 624
 625 /* This sort routine is used by sort_symbols_by_size.  It is similar
 626    to numeric_forward, but when symbols have the same value it sorts
 627    by section VMA.  This simplifies the sort_symbols_by_size code
 628    which handles symbols at the end of sections.  Also, this routine
 629    tries to sort file names before other symbols with the same value.
 630    That will make the file name have a zero size, which will make
 631    sort_symbols_by_size choose the non file name symbol, leading to
 632    more meaningful output.  For similar reasons, this code sorts
 633    gnu_compiled_* and gcc2_compiled before other symbols with the same
 634    value.  */
 635
 636 static int
 637 size_forward1 (const void *P_x, const void *P_y)
 638 {
 639   asymbol *x, *y;
 640   asection *xs, *ys;
 641   const char *xn, *yn;
 642   size_t xnl, ynl;
 643   int xf, yf;
 644
 645   x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
 646   y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
 647   if (x == NULL || y == NULL)
 648     bfd_fatal (bfd_get_filename (sort_bfd));
 649
 650   xs = bfd_get_section (x);
 651   ys = bfd_get_section (y);
 652
 653   if (bfd_is_und_section (xs))
 654     abort ();
 655   if (bfd_is_und_section (ys))
 656     abort ();
 657
 658   if (valueof (x) != valueof (y))
 659     return valueof (x) < valueof (y) ? -1 : 1;
 660
 661   if (xs->vma != ys->vma)
 662     return xs->vma < ys->vma ? -1 : 1;
 663
 664   xn = bfd_asymbol_name (x);
 665   yn = bfd_asymbol_name (y);
 666   xnl = strlen (xn);
 667   ynl = strlen (yn);
 668
 669   /* The symbols gnu_compiled and gcc2_compiled convey even less
 670      information than the file name, so sort them out first.  */
 671
 672   xf = (strstr (xn, "gnu_compiled") != NULL
 673         || strstr (xn, "gcc2_compiled") != NULL);
 674   yf = (strstr (yn, "gnu_compiled") != NULL
 675         || strstr (yn, "gcc2_compiled") != NULL);
 676
 677   if (xf && ! yf)
 678     return -1;
 679   if (! xf && yf)
 680     return 1;
 681
 682   /* We use a heuristic for the file name.  It may not work on non
 683      Unix systems, but it doesn't really matter; the only difference
 684      is precisely which symbol names get printed.  */
 685
 686 #define file_symbol(s, sn, snl)                 \
 687   (((s)->flags & BSF_FILE) != 0                 \
 688    || ((sn)[(snl) - 2] == '.'                   \
 689        && ((sn)[(snl) - 1] == 'o'               \
 690            || (sn)[(snl) - 1] == 'a')))
 691
 692   xf = file_symbol (x, xn, xnl);
 693   yf = file_symbol (y, yn, ynl);
 694
 695   if (xf && ! yf)
 696     return -1;
 697   if (! xf && yf)
 698     return 1;
 699
 700   return non_numeric_forward (P_x, P_y);
 701 }
 702
 703 /* This sort routine is used by sort_symbols_by_size.  It is sorting
 704    an array of size_sym structures into size order.  */
 705
 706 static int
 707 size_forward2 (const void *P_x, const void *P_y)
 708 {
 709   const struct size_sym *x = (const struct size_sym *) P_x;
 710   const struct size_sym *y = (const struct size_sym *) P_y;
 711
 712   if (x->size < y->size)
 713     return reverse_sort ? 1 : -1;
 714   else if (x->size > y->size)
 715     return reverse_sort ? -1 : 1;
 716   else
 717     return sorters[0][reverse_sort] (x->minisym, y->minisym);
 718 }
 719
 720 /* Sort the symbols by size.  ELF provides a size but for other formats
 721    we have to make a guess by assuming that the difference between the
 722    address of a symbol and the address of the next higher symbol is the
 723    size.  */
 724
 725 static long
 726 sort_symbols_by_size (bfd *abfd, bfd_boolean is_dynamic, void *minisyms,
 727                       long symcount, unsigned int size,
 728                       struct size_sym **symsizesp)
 729 {
 730   struct size_sym *symsizes;
 731   bfd_byte *from, *fromend;
 732   asymbol *sym = NULL;
 733   asymbol *store_sym, *store_next;
 734
 735   qsort (minisyms, symcount, size, size_forward1);
 736
 737   /* We are going to return a special set of symbols and sizes to
 738      print.  */
 739   symsizes = (struct size_sym *) xmalloc (symcount * sizeof (struct size_sym));
 740   *symsizesp = symsizes;
 741
 742   /* Note that filter_symbols has already removed all absolute and
 743      undefined symbols.  Here we remove all symbols whose size winds
 744      up as zero.  */
 745   from = (bfd_byte *) minisyms;
 746   fromend = from + symcount * size;
 747
 748   store_sym = sort_x;
 749   store_next = sort_y;
 750
 751   if (from < fromend)
 752     {
 753       sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, (const void *) from,
 754                                       store_sym);
 755       if (sym == NULL)
 756         bfd_fatal (bfd_get_filename (abfd));
 757     }
 758
 759   for (; from < fromend; from += size)
 760     {
 761       asymbol *next;
 762       asection *sec;
 763       bfd_vma sz;
 764       asymbol *temp;
 765
 766       if (from + size < fromend)
 767         {
 768           next = bfd_minisymbol_to_symbol (abfd,
 769                                            is_dynamic,
 770                                            (const void *) (from + size),
 771                                            store_next);
 772           if (next == NULL)
 773             bfd_fatal (bfd_get_filename (abfd));
 774         }
 775       else
 776         next = NULL;
 777
 778       sec = bfd_get_section (sym);
 779
 780       if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
 781         sz = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
 782       else if (bfd_is_com_section (sec))
 783         sz = sym->value;
 784       else
 785         {
 786           if (from + size < fromend
 787               && sec == bfd_get_section (next))
 788             sz = valueof (next) - valueof (sym);
 789           else
 790             sz = (bfd_get_section_vma (abfd, sec)
 791                   + bfd_section_size (abfd, sec)
 792                   - valueof (sym));
 793         }
 794
 795       if (sz != 0)
 796         {
 797           symsizes->minisym = (const void *) from;
 798           symsizes->size = sz;
 799           ++symsizes;
 800         }
 801
 802       sym = next;
 803
 804       temp = store_sym;
 805       store_sym = store_next;
 806       store_next = temp;
 807     }
 808
 809   symcount = symsizes - *symsizesp;
 810
 811   /* We must now sort again by size.  */
 812   qsort ((void *) *symsizesp, symcount, sizeof (struct size_sym), size_forward2);
 813
 814   return symcount;
 815 }
 816
 817 /* This function is used to get the relocs for a particular section.
 818    It is called via bfd_map_over_sections.  */
 819
 820 static void
 821 get_relocs (bfd *abfd, asection *sec, void *dataarg)
 822 {
 823   struct get_relocs_info *data = (struct get_relocs_info *) dataarg;
 824
 825   *data->secs = sec;
 826
 827   if ((sec->flags & SEC_RELOC) == 0)
 828     {
 829       *data->relocs = NULL;
 830       *data->relcount = 0;
 831     }
 832   else
 833     {
 834       long relsize;
 835
 836       relsize = bfd_get_reloc_upper_bound (abfd, sec);
 837       if (relsize < 0)
 838         bfd_fatal (bfd_get_filename (abfd));
 839
 840       *data->relocs = (arelent **) xmalloc (relsize);
 841       *data->relcount = bfd_canonicalize_reloc (abfd, sec, *data->relocs,
 842                                                 data->syms);
 843       if (*data->relcount < 0)
 844         bfd_fatal (bfd_get_filename (abfd));
 845     }
 846
 847   ++data->secs;
 848   ++data->relocs;
 849   ++data->relcount;
 850 }
 851
 852 /* Print a single symbol.  */
 853
 854 static void
 855 print_symbol (bfd *        abfd,
 856               asymbol *    sym,
 857               bfd_vma      ssize,
 858               bfd *        archive_bfd)
 859 {
 860   symbol_info syminfo;
 861   struct extended_symbol_info info;
 862
 863   PROGRESS (1);
 864
 865   format->print_symbol_filename (archive_bfd, abfd);
 866
 867   bfd_get_symbol_info (abfd, sym, &syminfo);
 868
 869   info.sinfo = &syminfo;
 870   info.ssize = ssize;
 871   /* Synthetic symbols do not have a full symbol type set of data available.  */
 872   if ((sym->flags & BSF_SYNTHETIC) != 0)
 873     {
 874       info.elfinfo = NULL;
 875       info.coffinfo = NULL;
 876     }
 877   else
 878     {
 879       info.elfinfo = elf_symbol_from (abfd, sym);
 880       info.coffinfo = coff_symbol_from (sym);
 881     }
 882
 883   format->print_symbol_info (&info, abfd);
 884
 885   if (with_symbol_versions)
 886     {
 887       const char *  version_string = NULL;
 888       bfd_boolean   hidden = FALSE;
 889
 890       if ((sym->flags & BSF_SYNTHETIC) == 0)
 891         version_string = bfd_get_symbol_version_string (abfd, sym, &hidden);
 892
 893       if (bfd_is_und_section (bfd_get_section (sym)))
 894         hidden = TRUE;
 895
 896       if (version_string && *version_string != '\0')
 897         printf (hidden ? "@%s" : "@@%s", version_string);
 898     }
 899
 900   if (line_numbers)
 901     {
 902       static asymbol **syms;
 903       static long symcount;
 904       const char *filename, *functionname;
 905       unsigned int lineno;
 906
 907       /* We need to get the canonical symbols in order to call
 908          bfd_find_nearest_line.  This is inefficient, but, then, you
 909          don't have to use --line-numbers.  */
 910       if (abfd != lineno_cache_bfd && syms != NULL)
 911         {
 912           free (syms);
 913           syms = NULL;
 914         }
 915       if (syms == NULL)
 916         {
 917           long symsize;
 918
 919           symsize = bfd_get_symtab_upper_bound (abfd);
 920           if (symsize < 0)
 921             bfd_fatal (bfd_get_filename (abfd));
 922           syms = (asymbol **) xmalloc (symsize);
 923           symcount = bfd_canonicalize_symtab (abfd, syms);
 924           if (symcount < 0)
 925             bfd_fatal (bfd_get_filename (abfd));
 926           lineno_cache_bfd = abfd;
 927         }
 928
 929       if (bfd_is_und_section (bfd_get_section (sym)))
 930         {
 931           static asection **secs;
 932           static arelent ***relocs;
 933           static long *relcount;
 934           static unsigned int seccount;
 935           unsigned int i;
 936           const char *symname;
 937
 938           /* For an undefined symbol, we try to find a reloc for the
 939              symbol, and print the line number of the reloc.  */
 940           if (abfd != lineno_cache_rel_bfd && relocs != NULL)
 941             {
 942               for (i = 0; i < seccount; i++)
 943                 if (relocs[i] != NULL)
 944                   free (relocs[i]);
 945               free (secs);
 946               free (relocs);
 947               free (relcount);
 948               secs = NULL;
 949               relocs = NULL;
 950               relcount = NULL;
 951             }
 952
 953           if (relocs == NULL)
 954             {
 955               struct get_relocs_info rinfo;
 956
 957               seccount = bfd_count_sections (abfd);
 958
 959               secs = (asection **) xmalloc (seccount * sizeof *secs);
 960               relocs = (arelent ***) xmalloc (seccount * sizeof *relocs);
 961               relcount = (long *) xmalloc (seccount * sizeof *relcount);
 962
 963               rinfo.secs = secs;
 964               rinfo.relocs = relocs;
 965               rinfo.relcount = relcount;
 966               rinfo.syms = syms;
 967               bfd_map_over_sections (abfd, get_relocs, (void *) &rinfo);
 968               lineno_cache_rel_bfd = abfd;
 969             }
 970
 971           symname = bfd_asymbol_name (sym);
 972           for (i = 0; i < seccount; i++)
 973             {
 974               long j;
 975
 976               for (j = 0; j < relcount[i]; j++)
 977                 {
 978                   arelent *r;
 979
 980                   r = relocs[i][j];
 981                   if (r->sym_ptr_ptr != NULL
 982                       && (*r->sym_ptr_ptr)->section == sym->section
 983                       && (*r->sym_ptr_ptr)->value == sym->value
 984                       && strcmp (symname,
 985                                  bfd_asymbol_name (*r->sym_ptr_ptr)) == 0
 986                       && bfd_find_nearest_line (abfd, secs[i], syms,
 987                                                 r->address, &filename,
 988                                                 &functionname, &lineno)
 989                       && filename != NULL)
 990                     {
 991                       /* We only print the first one we find.  */
 992                       printf ("\t%s:%u", filename, lineno);
 993                       i = seccount;
 994                       break;
 995                     }
 996                 }
 997             }
 998         }
 999       else if (bfd_get_section (sym)->owner == abfd)
1000         {
1001           if ((bfd_find_line (abfd, syms, sym, &filename, &lineno)
1002                || bfd_find_nearest_line (abfd, bfd_get_section (sym),
1003                                          syms, sym->value, &filename,
1004                                          &functionname, &lineno))
1005               && filename != NULL
1006               && lineno != 0)
1007             printf ("\t%s:%u", filename, lineno);
1008         }
1009     }
1010
1011   putchar ('\n');
1012 }
1013 \f
1014 /* Print the symbols when sorting by size.  */
1015
1016 static void
1017 print_size_symbols (bfd *              abfd,
1018                     bfd_boolean        is_dynamic,
1019                     struct size_sym *  symsizes,
1020                     long               symcount,
1021                     bfd *              archive_bfd)
1022 {
1023   asymbol *store;
1024   struct size_sym *from;
1025   struct size_sym *fromend;
1026
1027   store = bfd_make_empty_symbol (abfd);
1028   if (store == NULL)
1029     bfd_fatal (bfd_get_filename (abfd));
1030
1031   from = symsizes;
1032   fromend = from + symcount;
1033
1034   for (; from < fromend; from++)
1035     {
1036       asymbol *sym;
1037
1038       sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from->minisym, store);
1039       if (sym == NULL)
1040         bfd_fatal (bfd_get_filename (abfd));
1041
1042       print_symbol (abfd, sym, from->size, archive_bfd);
1043     }
1044 }
1045
1046 \f
1047 /* Print the symbols of ABFD that are held in MINISYMS.
1048
1049    If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.
1050
1051    SYMCOUNT is the number of symbols in MINISYMS.
1052
1053    SIZE is the size of a symbol in MINISYMS.  */
1054
1055 static void
1056 print_symbols (bfd *         abfd,
1057                bfd_boolean   is_dynamic,
1058                void *        minisyms,
1059                long          symcount,
1060                unsigned int  size,
1061                bfd *         archive_bfd)
1062 {
1063   asymbol *store;
1064   bfd_byte *from;
1065   bfd_byte *fromend;
1066
1067   store = bfd_make_empty_symbol (abfd);
1068   if (store == NULL)
1069     bfd_fatal (bfd_get_filename (abfd));
1070
1071   from = (bfd_byte *) minisyms;
1072   fromend = from + symcount * size;
1073
1074   for (; from < fromend; from += size)
1075     {
1076       asymbol *sym;
1077
1078       sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from, store);
1079       if (sym == NULL)
1080         bfd_fatal (bfd_get_filename (abfd));
1081
1082       print_symbol (abfd, sym, (bfd_vma) 0, archive_bfd);
1083     }
1084 }
1085
1086 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.  */
1087
1088 static void
1089 display_rel_file (bfd *abfd, bfd *archive_bfd)
1090 {
1091   long symcount;
1092   void *minisyms;
1093   unsigned int size;
1094   struct size_sym *symsizes;
1095
1096   if (! dynamic)
1097     {
1098       if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
1099         {
1100           non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1101           return;
1102         }
1103     }
1104
1105   symcount = bfd_read_minisymbols (abfd, dynamic, &minisyms, &size);
1106   if (symcount < 0)
1107     {
1108       if (dynamic && bfd_get_error () == bfd_error_no_symbols)
1109         {
1110           non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1111           return;
1112         }
1113
1114       bfd_fatal (bfd_get_filename (abfd));
1115     }
1116
1117   if (symcount == 0)
1118     {
1119       non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1120       return;
1121     }
1122
1123   if (show_synthetic && size == sizeof (asymbol *))
1124     {
1125       asymbol *synthsyms;
1126       asymbol **static_syms = NULL;
1127       asymbol **dyn_syms = NULL;
1128       long static_count = 0;
1129       long dyn_count = 0;
1130       long synth_count;
1131
1132       if (dynamic)
1133         {
1134           dyn_count = symcount;
1135           dyn_syms = (asymbol **) minisyms;
1136         }
1137       else
1138         {
1139           long storage = bfd_get_dynamic_symtab_upper_bound (abfd);
1140
1141           static_count = symcount;
1142           static_syms = (asymbol **) minisyms;
1143
1144           if (storage > 0)
1145             {
1146               dyn_syms = (asymbol **) xmalloc (storage);
1147               dyn_count = bfd_canonicalize_dynamic_symtab (abfd, dyn_syms);
1148               if (dyn_count < 0)
1149                 bfd_fatal (bfd_get_filename (abfd));
1150             }
1151         }
1152
1153       synth_count = bfd_get_synthetic_symtab (abfd, static_count, static_syms,
1154                                               dyn_count, dyn_syms, &synthsyms);
1155       if (synth_count > 0)
1156         {
1157           asymbol **symp;
1158           void *new_mini;
1159           long i;
1160
1161           new_mini = xmalloc ((symcount + synth_count + 1) * sizeof (*symp));
1162           symp = (asymbol **) new_mini;
1163           memcpy (symp, minisyms, symcount * sizeof (*symp));
1164           symp += symcount;
1165           for (i = 0; i < synth_count; i++)
1166             *symp++ = synthsyms + i;
1167           *symp = 0;
1168           minisyms = new_mini;
1169           symcount += synth_count;
1170         }
1171     }
1172
1173   /* Discard the symbols we don't want to print.
1174      It's OK to do this in place; we'll free the storage anyway
1175      (after printing).  */
1176
1177   symcount = filter_symbols (abfd, dynamic, minisyms, symcount, size);
1178
1179   symsizes = NULL;
1180   if (! no_sort)
1181     {
1182       sort_bfd = abfd;
1183       sort_dynamic = dynamic;
1184       sort_x = bfd_make_empty_symbol (abfd);
1185       sort_y = bfd_make_empty_symbol (abfd);
1186       if (sort_x == NULL || sort_y == NULL)
1187         bfd_fatal (bfd_get_filename (abfd));
1188
1189       if (! sort_by_size)
1190         qsort (minisyms, symcount, size,
1191                sorters[sort_numerically][reverse_sort]);
1192       else
1193         symcount = sort_symbols_by_size (abfd, dynamic, minisyms, symcount,
1194                                          size, &symsizes);
1195     }
1196
1197   if (! sort_by_size)
1198     print_symbols (abfd, dynamic, minisyms, symcount, size, archive_bfd);
1199   else
1200     print_size_symbols (abfd, dynamic, symsizes, symcount, archive_bfd);
1201
1202   free (minisyms);
1203   free (symsizes);
1204 }
1205
1206 static void
1207 set_print_width (bfd *file)
1208 {
1209   print_width = bfd_get_arch_size (file);
1210
1211   if (print_width == -1)
1212     {
1213       /* PR binutils/4292
1214          Guess the target's bitsize based on its name.
1215          We assume here than any 64-bit format will include
1216          "64" somewhere in its name.  The only known exception
1217          is the MMO object file format.  */
1218       if (strstr (bfd_get_target (file), "64") != NULL
1219           || strcmp (bfd_get_target (file), "mmo") == 0)
1220         print_width = 64;
1221       else
1222         print_width = 32;
1223     }
1224 }
1225
1226 static void
1227 display_archive (bfd *file)
1228 {
1229   bfd *arfile = NULL;
1230   bfd *last_arfile = NULL;
1231   char **matching;
1232
1233   format->print_archive_filename (bfd_get_filename (file));
1234
1235   if (print_armap)
1236     print_symdef_entry (file);
1237
1238   for (;;)
1239     {
1240       PROGRESS (1);
1241
1242       arfile = bfd_openr_next_archived_file (file, arfile);
1243
1244       if (arfile == NULL)
1245         {
1246           if (bfd_get_error () != bfd_error_no_more_archived_files)
1247             bfd_fatal (bfd_get_filename (file));
1248           break;
1249         }
1250
1251       if (bfd_check_format_matches (arfile, bfd_object, &matching))
1252         {
1253           set_print_width (arfile);
1254           format->print_archive_member (bfd_get_filename (file),
1255                                         bfd_get_filename (arfile));
1256           display_rel_file (arfile, file);
1257         }
1258       else
1259         {
1260           bfd_nonfatal (bfd_get_filename (arfile));
1261           if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1262             {
1263               list_matching_formats (matching);
1264               free (matching);
1265             }
1266         }
1267
1268       if (last_arfile != NULL)
1269         {
1270           bfd_close (last_arfile);
1271           lineno_cache_bfd = NULL;
1272           lineno_cache_rel_bfd = NULL;
1273           if (arfile == last_arfile)
1274             return;
1275         }
1276       last_arfile = arfile;
1277     }
1278
1279   if (last_arfile != NULL)
1280     {
1281       bfd_close (last_arfile);
1282       lineno_cache_bfd = NULL;
1283       lineno_cache_rel_bfd = NULL;
1284     }
1285 }
1286
1287 static bfd_boolean
1288 display_file (char *filename)
1289 {
1290   bfd_boolean retval = TRUE;
1291   bfd *file;
1292   char **matching;
1293
1294   if (get_file_size (filename) < 1)
1295     return FALSE;
1296
1297   file = bfd_openr (filename, target ? target : plugin_target);
1298   if (file == NULL)
1299     {
1300       bfd_nonfatal (filename);
1301       return FALSE;
1302     }
1303
1304   /* If printing line numbers, decompress the debug sections.  */
1305   if (line_numbers)
1306     file->flags |= BFD_DECOMPRESS;
1307
1308   if (bfd_check_format (file, bfd_archive))
1309     {
1310       display_archive (file);
1311     }
1312   else if (bfd_check_format_matches (file, bfd_object, &matching))
1313     {
1314       set_print_width (file);
1315       format->print_object_filename (filename);
1316       display_rel_file (file, NULL);
1317     }
1318   else
1319     {
1320       bfd_nonfatal (filename);
1321       if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1322         {
1323           list_matching_formats (matching);
1324           free (matching);
1325         }
1326       retval = FALSE;
1327     }
1328
1329   if (!bfd_close (file))
1330     bfd_fatal (filename);
1331
1332   lineno_cache_bfd = NULL;
1333   lineno_cache_rel_bfd = NULL;
1334
1335   return retval;
1336 }
1337 \f
1338 /* The following 3 groups of functions are called unconditionally,
1339    once at the start of processing each file of the appropriate type.
1340    They should check `filename_per_file' and `filename_per_symbol',
1341    as appropriate for their output format, to determine whether to
1342    print anything.  */
1343 \f
1344 /* Print the name of an object file given on the command line.  */
1345
1346 static void
1347 print_object_filename_bsd (char *filename)
1348 {
1349   if (filename_per_file && !filename_per_symbol)
1350     printf ("\n%s:\n", filename);
1351 }
1352
1353 static void
1354 print_object_filename_sysv (char *filename)
1355 {
1356   if (undefined_only)
1357     printf (_("\n\nUndefined symbols from %s:\n\n"), filename);
1358   else
1359     printf (_("\n\nSymbols from %s:\n\n"), filename);
1360   if (print_width == 32)
1361     printf (_("\
1362 Name                  Value   Class        Type         Size     Line  Section\n\n"));
1363   else
1364     printf (_("\
1365 Name                  Value           Class        Type         Size             Line  Section\n\n"));
1366 }
1367
1368 static void
1369 print_object_filename_posix (char *filename)
1370 {
1371   if (filename_per_file && !filename_per_symbol)
1372     printf ("%s:\n", filename);
1373 }
1374 \f
1375 /* Print the name of an archive file given on the command line.  */
1376
1377 static void
1378 print_archive_filename_bsd (char *filename)
1379 {
1380   if (filename_per_file)
1381     printf ("\n%s:\n", filename);
1382 }
1383
1384 static void
1385 print_archive_filename_sysv (char *filename ATTRIBUTE_UNUSED)
1386 {
1387 }
1388
1389 static void
1390 print_archive_filename_posix (char *filename ATTRIBUTE_UNUSED)
1391 {
1392 }
1393 \f
1394 /* Print the name of an archive member file.  */
1395
1396 static void
1397 print_archive_member_bsd (char *archive ATTRIBUTE_UNUSED,
1398                           const char *filename)
1399 {
1400   if (!filename_per_symbol)
1401     printf ("\n%s:\n", filename);
1402 }
1403
1404 static void
1405 print_archive_member_sysv (char *archive, const char *filename)
1406 {
1407   if (undefined_only)
1408     printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive, filename);
1409   else
1410     printf (_("\n\nSymbols from %s[%s]:\n\n"), archive, filename);
1411   if (print_width == 32)
1412     printf (_("\
1413 Name                  Value   Class        Type         Size     Line  Section\n\n"));
1414   else
1415     printf (_("\
1416 Name                  Value           Class        Type         Size             Line  Section\n\n"));
1417 }
1418
1419 static void
1420 print_archive_member_posix (char *archive, const char *filename)
1421 {
1422   if (!filename_per_symbol)
1423     printf ("%s[%s]:\n", archive, filename);
1424 }
1425 \f
1426 /* Print the name of the file (and archive, if there is one)
1427    containing a symbol.  */
1428
1429 static void
1430 print_symbol_filename_bsd (bfd *archive_bfd, bfd *abfd)
1431 {
1432   if (filename_per_symbol)
1433     {
1434       if (archive_bfd)
1435         printf ("%s:", bfd_get_filename (archive_bfd));
1436       printf ("%s:", bfd_get_filename (abfd));
1437     }
1438 }
1439
1440 static void
1441 print_symbol_filename_sysv (bfd *archive_bfd, bfd *abfd)
1442 {
1443   if (filename_per_symbol)
1444     {
1445       if (archive_bfd)
1446         printf ("%s:", bfd_get_filename (archive_bfd));
1447       printf ("%s:", bfd_get_filename (abfd));
1448     }
1449 }
1450
1451 static void
1452 print_symbol_filename_posix (bfd *archive_bfd, bfd *abfd)
1453 {
1454   if (filename_per_symbol)
1455     {
1456       if (archive_bfd)
1457         printf ("%s[%s]: ", bfd_get_filename (archive_bfd),
1458                 bfd_get_filename (abfd));
1459       else
1460         printf ("%s: ", bfd_get_filename (abfd));
1461     }
1462 }
1463 \f
1464 /* Print a symbol value.  */
1465
1466 static void
1467 print_value (bfd *abfd ATTRIBUTE_UNUSED, bfd_vma val)
1468 {
1469   switch (print_width)
1470     {
1471     case 32:
1472       printf (value_format_32bit, (unsigned long) val);
1473       break;
1474
1475     case 64:
1476 #if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
1477       printf (value_format_64bit, val);
1478 #else
1479       /* We have a 64 bit value to print, but the host is only 32 bit.  */
1480       if (print_radix == 16)
1481         bfd_fprintf_vma (abfd, stdout, val);
1482       else
1483         {
1484           char buf[30];
1485           char *s;
1486
1487           s = buf + sizeof buf;
1488           *--s = '\0';
1489           while (val > 0)
1490             {
1491               *--s = (val % print_radix) + '0';
1492               val /= print_radix;
1493             }
1494           while ((buf + sizeof buf - 1) - s < 16)
1495             *--s = '0';
1496           printf ("%s", s);
1497         }
1498 #endif
1499       break;
1500
1501     default:
1502       fatal (_("Print width has not been initialized (%d)"), print_width);
1503       break;
1504     }
1505 }
1506
1507 /* Print a line of information about a symbol.  */
1508
1509 static void
1510 print_symbol_info_bsd (struct extended_symbol_info *info, bfd *abfd)
1511 {
1512   if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1513     {
1514       if (print_width == 64)
1515         printf ("        ");
1516       printf ("        ");
1517     }
1518   else
1519     {
1520       /* Normally we print the value of the symbol.  If we are printing the
1521          size or sorting by size then we print its size, except for the
1522          (weird) special case where both flags are defined, in which case we
1523          print both values.  This conforms to documented behaviour.  */
1524       if (sort_by_size && !print_size)
1525         print_value (abfd, SYM_SIZE (info));
1526       else
1527         print_value (abfd, SYM_VALUE (info));
1528       if (print_size && SYM_SIZE (info))
1529         {
1530           printf (" ");
1531           print_value (abfd, SYM_SIZE (info));
1532         }
1533     }
1534
1535   printf (" %c", SYM_TYPE (info));
1536
1537   if (SYM_TYPE (info) == '-')
1538     {
1539       /* A stab.  */
1540       printf (" ");
1541       printf (other_format, SYM_STAB_OTHER (info));
1542       printf (" ");
1543       printf (desc_format, SYM_STAB_DESC (info));
1544       printf (" %5s", SYM_STAB_NAME (info));
1545     }
1546   print_symname (" %s", SYM_NAME (info), abfd);
1547 }
1548
1549 static void
1550 print_symbol_info_sysv (struct extended_symbol_info *info, bfd *abfd)
1551 {
1552   print_symname ("%-20s|", SYM_NAME (info), abfd);
1553
1554   if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1555     {
1556       if (print_width == 32)
1557         printf ("        ");
1558       else
1559         printf ("                ");
1560     }
1561   else
1562     print_value (abfd, SYM_VALUE (info));
1563
1564   printf ("|   %c  |", SYM_TYPE (info));
1565
1566   if (SYM_TYPE (info) == '-')
1567     {
1568       /* A stab.  */
1569       printf ("%18s|  ", SYM_STAB_NAME (info));         /* (C) Type.  */
1570       printf (desc_format, SYM_STAB_DESC (info));       /* Size.  */
1571       printf ("|     |");                               /* Line, Section.  */
1572     }
1573   else
1574     {
1575       /* Type, Size, Line, Section */
1576       if (info->elfinfo)
1577         printf ("%18s|",
1578                 get_elf_symbol_type (ELF_ST_TYPE (info->elfinfo->internal_elf_sym.st_info)));
1579       else if (info->coffinfo)
1580         printf ("%18s|",
1581                 get_coff_symbol_type (&info->coffinfo->native->u.syment));
1582       else
1583         printf ("                  |");
1584
1585       if (SYM_SIZE (info))
1586         print_value (abfd, SYM_SIZE (info));
1587       else
1588         {
1589           if (print_width == 32)
1590             printf ("        ");
1591           else
1592             printf ("                ");
1593         }
1594
1595       if (info->elfinfo)
1596         printf("|     |%s", info->elfinfo->symbol.section->name);
1597       else if (info->coffinfo)
1598         printf("|     |%s", info->coffinfo->symbol.section->name);
1599       else
1600         printf("|     |");
1601     }
1602 }
1603
1604 static void
1605 print_symbol_info_posix (struct extended_symbol_info *info, bfd *abfd)
1606 {
1607   print_symname ("%s ", SYM_NAME (info), abfd);
1608   printf ("%c ", SYM_TYPE (info));
1609
1610   if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1611     printf ("        ");
1612   else
1613     {
1614       print_value (abfd, SYM_VALUE (info));
1615       printf (" ");
1616       if (SYM_SIZE (info))
1617         print_value (abfd, SYM_SIZE (info));
1618     }
1619 }
1620 \f
1621 int
1622 main (int argc, char **argv)
1623 {
1624   int c;
1625   int retval;
1626
1627 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1628   setlocale (LC_MESSAGES, "");
1629 #endif
1630 #if defined (HAVE_SETLOCALE)
1631   setlocale (LC_CTYPE, "");
1632   setlocale (LC_COLLATE, "");
1633 #endif
1634   bindtextdomain (PACKAGE, LOCALEDIR);
1635   textdomain (PACKAGE);
1636
1637   program_name = *argv;
1638   xmalloc_set_program_name (program_name);
1639   bfd_set_error_program_name (program_name);
1640 #if BFD_SUPPORTS_PLUGINS
1641   bfd_plugin_set_program_name (program_name);
1642 #endif
1643
1644   START_PROGRESS (program_name, 0);
1645
1646   expandargv (&argc, &argv);
1647
1648   bfd_init ();
1649   set_default_bfd_target ();
1650
1651   while ((c = getopt_long (argc, argv, "aABCDef:gHhlnopPrSst:uvVvX:",
1652                            long_options, (int *) 0)) != EOF)
1653     {
1654       switch (c)
1655         {
1656         case 'a':
1657           print_debug_syms = 1;
1658           break;
1659         case 'A':
1660         case 'o':
1661           filename_per_symbol = 1;
1662           break;
1663         case 'B':               /* For MIPS compatibility.  */
1664           set_output_format ("bsd");
1665           break;
1666         case 'C':
1667           do_demangle = 1;
1668           if (optarg != NULL)
1669             {
1670               enum demangling_styles style;
1671
1672               style = cplus_demangle_name_to_style (optarg);
1673               if (style == unknown_demangling)
1674                 fatal (_("unknown demangling style `%s'"),
1675                        optarg);
1676
1677               cplus_demangle_set_style (style);
1678             }
1679           break;
1680         case 'D':
1681           dynamic = 1;
1682           break;
1683         case 'e':
1684           /* Ignored for HP/UX compatibility.  */
1685           break;
1686         case 'f':
1687           set_output_format (optarg);
1688           break;
1689         case 'g':
1690           external_only = 1;
1691           break;
1692         case 'H':
1693         case 'h':
1694           usage (stdout, 0);
1695         case 'l':
1696           line_numbers = 1;
1697           break;
1698         case 'n':
1699         case 'v':
1700           no_sort = 0;
1701           sort_numerically = 1;
1702           sort_by_size = 0;
1703           break;
1704         case 'p':
1705           no_sort = 1;
1706           sort_numerically = 0;
1707           sort_by_size = 0;
1708           break;
1709         case OPTION_SIZE_SORT:
1710           no_sort = 0;
1711           sort_numerically = 0;
1712           sort_by_size = 1;
1713           break;
1714         case 'P':
1715           set_output_format ("posix");
1716           break;
1717         case 'r':
1718           reverse_sort = 1;
1719           break;
1720         case 's':
1721           print_armap = 1;
1722           break;
1723         case 'S':
1724           print_size = 1;
1725           break;
1726         case 't':
1727           set_print_radix (optarg);
1728           break;
1729         case 'u':
1730           undefined_only = 1;
1731           break;
1732         case 'V':
1733           show_version = 1;
1734           break;
1735         case 'X':
1736           /* Ignored for (partial) AIX compatibility.  On AIX, the
1737              argument has values 32, 64, or 32_64, and specifies that
1738              only 32-bit, only 64-bit, or both kinds of objects should
1739              be examined.  The default is 32.  So plain AIX nm on a
1740              library archive with both kinds of objects will ignore
1741              the 64-bit ones.  For GNU nm, the default is and always
1742              has been -X 32_64, and other options are not supported.  */
1743           if (strcmp (optarg, "32_64") != 0)
1744             fatal (_("Only -X 32_64 is supported"));
1745           break;
1746
1747         case OPTION_TARGET:     /* --target */
1748           target = optarg;
1749           break;
1750
1751         case OPTION_PLUGIN:     /* --plugin */
1752 #if BFD_SUPPORTS_PLUGINS
1753           bfd_plugin_set_plugin (optarg);
1754 #else
1755           fatal (_("sorry - this program has been built without plugin support\n"));
1756 #endif
1757           break;
1758
1759         case 0:         /* A long option that just sets a flag.  */
1760           break;
1761
1762         default:
1763           usage (stderr, 1);
1764         }
1765     }
1766
1767   if (show_version)
1768     print_version ("nm");
1769
1770   if (sort_by_size && undefined_only)
1771     {
1772       non_fatal (_("Using the --size-sort and --undefined-only options together"));
1773       non_fatal (_("will produce no output, since undefined symbols have no size."));
1774       return 0;
1775     }
1776
1777   /* OK, all options now parsed.  If no filename specified, do a.out.  */
1778   if (optind == argc)
1779     return !display_file ("a.out");
1780
1781   retval = 0;
1782
1783   if (argc - optind > 1)
1784     filename_per_file = 1;
1785
1786   /* We were given several filenames to do.  */
1787   while (optind < argc)
1788     {
1789       PROGRESS (1);
1790       if (!display_file (argv[optind++]))
1791         retval++;
1792     }
1793
1794   END_PROGRESS (program_name);
1795
1796 #ifdef HAVE_SBRK
1797   if (show_stats)
1798     {
1799       char *lim = (char *) sbrk (0);
1800
1801       non_fatal (_("data size %ld"), (long) (lim - (char *) &environ));
1802     }
1803 #endif
1804
1805   exit (retval);
1806   return retval;
1807 }