binutils/nm.c

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