binutils/nm.c

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