binutils/nm.c

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