contrib/binutils-2.24/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         /* PR binutls/12753: Unique symbols are global too.  */
 439         keep = ((sym->flags & (BSF_GLOBAL
 440                                | BSF_WEAK
 441                                | 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
 955       sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from->minisym, store);
 956       if (sym == NULL)
 957         bfd_fatal (bfd_get_filename (abfd));
 958
 959       print_symbol (abfd, sym, from->size, archive_bfd);
 960     }
 961 }
 962
 963 \f
 964 /* Print the symbols.  If ARCHIVE_BFD is non-NULL, it is the archive
 965    containing ABFD.  */
 966
 967 static void
 968 print_symbols (bfd *abfd, bfd_boolean is_dynamic, void *minisyms, long symcount,
 969                unsigned int size, bfd *archive_bfd)
 970 {
 971   asymbol *store;
 972   bfd_byte *from, *fromend;
 973
 974   store = bfd_make_empty_symbol (abfd);
 975   if (store == NULL)
 976     bfd_fatal (bfd_get_filename (abfd));
 977
 978   from = (bfd_byte *) minisyms;
 979   fromend = from + symcount * size;
 980   for (; from < fromend; from += size)
 981     {
 982       asymbol *sym;
 983
 984       sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from, store);
 985       if (sym == NULL)
 986         bfd_fatal (bfd_get_filename (abfd));
 987
 988       print_symbol (abfd, sym, (bfd_vma) 0, archive_bfd);
 989     }
 990 }
 991
 992 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.  */
 993
 994 static void
 995 display_rel_file (bfd *abfd, bfd *archive_bfd)
 996 {
 997   long symcount;
 998   void *minisyms;
 999   unsigned int size;
1000   struct size_sym *symsizes;
1001
1002   if (! dynamic)
1003     {
1004       if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
1005         {
1006           non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1007           return;
1008         }
1009     }
1010
1011   symcount = bfd_read_minisymbols (abfd, dynamic, &minisyms, &size);
1012   if (symcount < 0)
1013     {
1014       if (dynamic && bfd_get_error () == bfd_error_no_symbols)
1015         {
1016           non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1017           return;
1018         }
1019
1020       bfd_fatal (bfd_get_filename (abfd));
1021     }
1022
1023   if (symcount == 0)
1024     {
1025       non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1026       return;
1027     }
1028
1029   if (show_synthetic && size == sizeof (asymbol *))
1030     {
1031       asymbol *synthsyms;
1032       long synth_count;
1033       asymbol **static_syms = NULL;
1034       asymbol **dyn_syms = NULL;
1035       long static_count = 0;
1036       long dyn_count = 0;
1037
1038       if (dynamic)
1039         {
1040           dyn_count = symcount;
1041           dyn_syms = (asymbol **) minisyms;
1042         }
1043       else
1044         {
1045           long storage = bfd_get_dynamic_symtab_upper_bound (abfd);
1046
1047           static_count = symcount;
1048           static_syms = (asymbol **) minisyms;
1049
1050           if (storage > 0)
1051             {
1052               dyn_syms = (asymbol **) xmalloc (storage);
1053               dyn_count = bfd_canonicalize_dynamic_symtab (abfd, dyn_syms);
1054               if (dyn_count < 0)
1055                 bfd_fatal (bfd_get_filename (abfd));
1056             }
1057         }
1058       synth_count = bfd_get_synthetic_symtab (abfd, static_count, static_syms,
1059                                               dyn_count, dyn_syms, &synthsyms);
1060       if (synth_count > 0)
1061         {
1062           asymbol **symp;
1063           void *new_mini;
1064           long i;
1065
1066           new_mini = xmalloc ((symcount + synth_count + 1) * sizeof (*symp));
1067           symp = (asymbol **) new_mini;
1068           memcpy (symp, minisyms, symcount * sizeof (*symp));
1069           symp += symcount;
1070           for (i = 0; i < synth_count; i++)
1071             *symp++ = synthsyms + i;
1072           *symp = 0;
1073           minisyms = new_mini;
1074           symcount += synth_count;
1075         }
1076     }
1077
1078   /* Discard the symbols we don't want to print.
1079      It's OK to do this in place; we'll free the storage anyway
1080      (after printing).  */
1081
1082   symcount = filter_symbols (abfd, dynamic, minisyms, symcount, size);
1083
1084   symsizes = NULL;
1085   if (! no_sort)
1086     {
1087       sort_bfd = abfd;
1088       sort_dynamic = dynamic;
1089       sort_x = bfd_make_empty_symbol (abfd);
1090       sort_y = bfd_make_empty_symbol (abfd);
1091       if (sort_x == NULL || sort_y == NULL)
1092         bfd_fatal (bfd_get_filename (abfd));
1093
1094       if (! sort_by_size)
1095         qsort (minisyms, symcount, size,
1096                sorters[sort_numerically][reverse_sort]);
1097       else
1098         symcount = sort_symbols_by_size (abfd, dynamic, minisyms, symcount,
1099                                          size, &symsizes);
1100     }
1101
1102   if (! sort_by_size)
1103     print_symbols (abfd, dynamic, minisyms, symcount, size, archive_bfd);
1104   else
1105     print_size_symbols (abfd, dynamic, symsizes, symcount, archive_bfd);
1106
1107   free (minisyms);
1108   free (symsizes);
1109 }
1110
1111 static void
1112 set_print_width (bfd *file)
1113 {
1114   print_width = bfd_get_arch_size (file);
1115
1116   if (print_width == -1)
1117     {
1118       /* PR binutils/4292
1119          Guess the target's bitsize based on its name.
1120          We assume here than any 64-bit format will include
1121          "64" somewhere in its name.  The only known exception
1122          is the MMO object file format.  */
1123       if (strstr (bfd_get_target (file), "64") != NULL
1124           || strcmp (bfd_get_target (file), "mmo") == 0)
1125         print_width = 64;
1126       else
1127         print_width = 32;
1128     }
1129 }
1130
1131 static void
1132 display_archive (bfd *file)
1133 {
1134   bfd *arfile = NULL;
1135   bfd *last_arfile = NULL;
1136   char **matching;
1137
1138   format->print_archive_filename (bfd_get_filename (file));
1139
1140   if (print_armap)
1141     print_symdef_entry (file);
1142
1143   for (;;)
1144     {
1145       PROGRESS (1);
1146
1147       arfile = bfd_openr_next_archived_file (file, arfile);
1148
1149       if (arfile == NULL)
1150         {
1151           if (bfd_get_error () != bfd_error_no_more_archived_files)
1152             bfd_fatal (bfd_get_filename (file));
1153           break;
1154         }
1155
1156       if (bfd_check_format_matches (arfile, bfd_object, &matching))
1157         {
1158           set_print_width (arfile);
1159           format->print_archive_member (bfd_get_filename (file),
1160                                         bfd_get_filename (arfile));
1161           display_rel_file (arfile, file);
1162         }
1163       else
1164         {
1165           bfd_nonfatal (bfd_get_filename (arfile));
1166           if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1167             {
1168               list_matching_formats (matching);
1169               free (matching);
1170             }
1171         }
1172
1173       if (last_arfile != NULL)
1174         {
1175           bfd_close (last_arfile);
1176           lineno_cache_bfd = NULL;
1177           lineno_cache_rel_bfd = NULL;
1178         }
1179       last_arfile = arfile;
1180     }
1181
1182   if (last_arfile != NULL)
1183     {
1184       bfd_close (last_arfile);
1185       lineno_cache_bfd = NULL;
1186       lineno_cache_rel_bfd = NULL;
1187     }
1188 }
1189
1190 static bfd_boolean
1191 display_file (char *filename)
1192 {
1193   bfd_boolean retval = TRUE;
1194   bfd *file;
1195   char **matching;
1196
1197   if (get_file_size (filename) < 1)
1198     return FALSE;
1199
1200   file = bfd_openr (filename, target ? target : plugin_target);
1201   if (file == NULL)
1202     {
1203       bfd_nonfatal (filename);
1204       return FALSE;
1205     }
1206
1207   /* If printing line numbers, decompress the debug sections.  */
1208   if (line_numbers)
1209     file->flags |= BFD_DECOMPRESS;
1210
1211   if (bfd_check_format (file, bfd_archive))
1212     {
1213       display_archive (file);
1214     }
1215   else if (bfd_check_format_matches (file, bfd_object, &matching))
1216     {
1217       set_print_width (file);
1218       format->print_object_filename (filename);
1219       display_rel_file (file, NULL);
1220     }
1221   else
1222     {
1223       bfd_nonfatal (filename);
1224       if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1225         {
1226           list_matching_formats (matching);
1227           free (matching);
1228         }
1229       retval = FALSE;
1230     }
1231
1232   if (!bfd_close (file))
1233     bfd_fatal (filename);
1234
1235   lineno_cache_bfd = NULL;
1236   lineno_cache_rel_bfd = NULL;
1237
1238   return retval;
1239 }
1240 \f
1241 /* The following 3 groups of functions are called unconditionally,
1242    once at the start of processing each file of the appropriate type.
1243    They should check `filename_per_file' and `filename_per_symbol',
1244    as appropriate for their output format, to determine whether to
1245    print anything.  */
1246 \f
1247 /* Print the name of an object file given on the command line.  */
1248
1249 static void
1250 print_object_filename_bsd (char *filename)
1251 {
1252   if (filename_per_file && !filename_per_symbol)
1253     printf ("\n%s:\n", filename);
1254 }
1255
1256 static void
1257 print_object_filename_sysv (char *filename)
1258 {
1259   if (undefined_only)
1260     printf (_("\n\nUndefined symbols from %s:\n\n"), filename);
1261   else
1262     printf (_("\n\nSymbols from %s:\n\n"), filename);
1263   if (print_width == 32)
1264     printf (_("\
1265 Name                  Value   Class        Type         Size     Line  Section\n\n"));
1266   else
1267     printf (_("\
1268 Name                  Value           Class        Type         Size             Line  Section\n\n"));
1269 }
1270
1271 static void
1272 print_object_filename_posix (char *filename)
1273 {
1274   if (filename_per_file && !filename_per_symbol)
1275     printf ("%s:\n", filename);
1276 }
1277 \f
1278 /* Print the name of an archive file given on the command line.  */
1279
1280 static void
1281 print_archive_filename_bsd (char *filename)
1282 {
1283   if (filename_per_file)
1284     printf ("\n%s:\n", filename);
1285 }
1286
1287 static void
1288 print_archive_filename_sysv (char *filename ATTRIBUTE_UNUSED)
1289 {
1290 }
1291
1292 static void
1293 print_archive_filename_posix (char *filename ATTRIBUTE_UNUSED)
1294 {
1295 }
1296 \f
1297 /* Print the name of an archive member file.  */
1298
1299 static void
1300 print_archive_member_bsd (char *archive ATTRIBUTE_UNUSED,
1301                           const char *filename)
1302 {
1303   if (!filename_per_symbol)
1304     printf ("\n%s:\n", filename);
1305 }
1306
1307 static void
1308 print_archive_member_sysv (char *archive, const char *filename)
1309 {
1310   if (undefined_only)
1311     printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive, filename);
1312   else
1313     printf (_("\n\nSymbols from %s[%s]:\n\n"), archive, filename);
1314   if (print_width == 32)
1315     printf (_("\
1316 Name                  Value   Class        Type         Size     Line  Section\n\n"));
1317   else
1318     printf (_("\
1319 Name                  Value           Class        Type         Size             Line  Section\n\n"));
1320 }
1321
1322 static void
1323 print_archive_member_posix (char *archive, const char *filename)
1324 {
1325   if (!filename_per_symbol)
1326     printf ("%s[%s]:\n", archive, filename);
1327 }
1328 \f
1329 /* Print the name of the file (and archive, if there is one)
1330    containing a symbol.  */
1331
1332 static void
1333 print_symbol_filename_bsd (bfd *archive_bfd, bfd *abfd)
1334 {
1335   if (filename_per_symbol)
1336     {
1337       if (archive_bfd)
1338         printf ("%s:", bfd_get_filename (archive_bfd));
1339       printf ("%s:", bfd_get_filename (abfd));
1340     }
1341 }
1342
1343 static void
1344 print_symbol_filename_sysv (bfd *archive_bfd, bfd *abfd)
1345 {
1346   if (filename_per_symbol)
1347     {
1348       if (archive_bfd)
1349         printf ("%s:", bfd_get_filename (archive_bfd));
1350       printf ("%s:", bfd_get_filename (abfd));
1351     }
1352 }
1353
1354 static void
1355 print_symbol_filename_posix (bfd *archive_bfd, bfd *abfd)
1356 {
1357   if (filename_per_symbol)
1358     {
1359       if (archive_bfd)
1360         printf ("%s[%s]: ", bfd_get_filename (archive_bfd),
1361                 bfd_get_filename (abfd));
1362       else
1363         printf ("%s: ", bfd_get_filename (abfd));
1364     }
1365 }
1366 \f
1367 /* Print a symbol value.  */
1368
1369 static void
1370 print_value (bfd *abfd ATTRIBUTE_UNUSED, bfd_vma val)
1371 {
1372   switch (print_width)
1373     {
1374     case 32:
1375       printf (value_format_32bit, (unsigned long) val);
1376       break;
1377
1378     case 64:
1379 #if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
1380       printf (value_format_64bit, val);
1381 #else
1382       /* We have a 64 bit value to print, but the host is only 32 bit.  */
1383       if (print_radix == 16)
1384         bfd_fprintf_vma (abfd, stdout, val);
1385       else
1386         {
1387           char buf[30];
1388           char *s;
1389
1390           s = buf + sizeof buf;
1391           *--s = '\0';
1392           while (val > 0)
1393             {
1394               *--s = (val % print_radix) + '0';
1395               val /= print_radix;
1396             }
1397           while ((buf + sizeof buf - 1) - s < 16)
1398             *--s = '0';
1399           printf ("%s", s);
1400         }
1401 #endif
1402       break;
1403
1404     default:
1405       fatal (_("Print width has not been initialized (%d)"), print_width);
1406       break;
1407     }
1408 }
1409
1410 /* Print a line of information about a symbol.  */
1411
1412 static void
1413 print_symbol_info_bsd (struct extended_symbol_info *info, bfd *abfd)
1414 {
1415   if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1416     {
1417       if (print_width == 64)
1418         printf ("        ");
1419       printf ("        ");
1420     }
1421   else
1422     {
1423       /* Normally we print the value of the symbol.  If we are printing the
1424          size or sorting by size then we print its size, except for the
1425          (weird) special case where both flags are defined, in which case we
1426          print both values.  This conforms to documented behaviour.  */
1427       if (sort_by_size && !print_size)
1428         print_value (abfd, SYM_SIZE (info));
1429       else
1430         print_value (abfd, SYM_VALUE (info));
1431
1432       if (print_size && SYM_SIZE (info))
1433         {
1434           printf (" ");
1435           print_value (abfd, SYM_SIZE (info));
1436         }
1437     }
1438
1439   printf (" %c", SYM_TYPE (info));
1440
1441   if (SYM_TYPE (info) == '-')
1442     {
1443       /* A stab.  */
1444       printf (" ");
1445       printf (other_format, SYM_STAB_OTHER (info));
1446       printf (" ");
1447       printf (desc_format, SYM_STAB_DESC (info));
1448       printf (" %5s", SYM_STAB_NAME (info));
1449     }
1450   print_symname (" %s", SYM_NAME (info), abfd);
1451 }
1452
1453 static void
1454 print_symbol_info_sysv (struct extended_symbol_info *info, bfd *abfd)
1455 {
1456   print_symname ("%-20s|", SYM_NAME (info), abfd);
1457
1458   if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1459     {
1460       if (print_width == 32)
1461         printf ("        ");
1462       else
1463         printf ("                ");
1464     }
1465   else
1466     print_value (abfd, SYM_VALUE (info));
1467
1468   printf ("|   %c  |", SYM_TYPE (info));
1469
1470   if (SYM_TYPE (info) == '-')
1471     {
1472       /* A stab.  */
1473       printf ("%18s|  ", SYM_STAB_NAME (info));         /* (C) Type.  */
1474       printf (desc_format, SYM_STAB_DESC (info));       /* Size.  */
1475       printf ("|     |");                               /* Line, Section.  */
1476     }
1477   else
1478     {
1479       /* Type, Size, Line, Section */
1480       if (info->elfinfo)
1481         printf ("%18s|",
1482                 get_symbol_type (ELF_ST_TYPE (info->elfinfo->internal_elf_sym.st_info)));
1483       else
1484         printf ("                  |");
1485
1486       if (SYM_SIZE (info))
1487         print_value (abfd, SYM_SIZE (info));
1488       else
1489         {
1490           if (print_width == 32)
1491             printf ("        ");
1492           else
1493             printf ("                ");
1494         }
1495
1496       if (info->elfinfo)
1497         printf("|     |%s", info->elfinfo->symbol.section->name);
1498       else
1499         printf("|     |");
1500     }
1501 }
1502
1503 static void
1504 print_symbol_info_posix (struct extended_symbol_info *info, bfd *abfd)
1505 {
1506   print_symname ("%s ", SYM_NAME (info), abfd);
1507   printf ("%c ", SYM_TYPE (info));
1508
1509   if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1510     printf ("        ");
1511   else
1512     {
1513       print_value (abfd, SYM_VALUE (info));
1514       printf (" ");
1515       if (SYM_SIZE (info))
1516         print_value (abfd, SYM_SIZE (info));
1517     }
1518 }
1519 \f
1520 int
1521 main (int argc, char **argv)
1522 {
1523   int c;
1524   int retval;
1525
1526 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1527   setlocale (LC_MESSAGES, "");
1528 #endif
1529 #if defined (HAVE_SETLOCALE)
1530   setlocale (LC_CTYPE, "");
1531   setlocale (LC_COLLATE, "");
1532 #endif
1533   bindtextdomain (PACKAGE, LOCALEDIR);
1534   textdomain (PACKAGE);
1535
1536   program_name = *argv;
1537   xmalloc_set_program_name (program_name);
1538 #if BFD_SUPPORTS_PLUGINS
1539   bfd_plugin_set_program_name (program_name);
1540 #endif
1541
1542   START_PROGRESS (program_name, 0);
1543
1544   expandargv (&argc, &argv);
1545
1546   bfd_init ();
1547   set_default_bfd_target ();
1548
1549   while ((c = getopt_long (argc, argv, "aABCDef:gHhlnopPrSst:uvVvX:",
1550                            long_options, (int *) 0)) != EOF)
1551     {
1552       switch (c)
1553         {
1554         case 'a':
1555           print_debug_syms = 1;
1556           break;
1557         case 'A':
1558         case 'o':
1559           filename_per_symbol = 1;
1560           break;
1561         case 'B':               /* For MIPS compatibility.  */
1562           set_output_format ("bsd");
1563           break;
1564         case 'C':
1565           do_demangle = 1;
1566           if (optarg != NULL)
1567             {
1568               enum demangling_styles style;
1569
1570               style = cplus_demangle_name_to_style (optarg);
1571               if (style == unknown_demangling)
1572                 fatal (_("unknown demangling style `%s'"),
1573                        optarg);
1574
1575               cplus_demangle_set_style (style);
1576             }
1577           break;
1578         case 'D':
1579           dynamic = 1;
1580           break;
1581         case 'e':
1582           /* Ignored for HP/UX compatibility.  */
1583           break;
1584         case 'f':
1585           set_output_format (optarg);
1586           break;
1587         case 'g':
1588           external_only = 1;
1589           break;
1590         case 'H':
1591         case 'h':
1592           usage (stdout, 0);
1593         case 'l':
1594           line_numbers = 1;
1595           break;
1596         case 'n':
1597         case 'v':
1598           no_sort = 0;
1599           sort_numerically = 1;
1600           sort_by_size = 0;
1601           break;
1602         case 'p':
1603           no_sort = 1;
1604           sort_numerically = 0;
1605           sort_by_size = 0;
1606           break;
1607         case OPTION_SIZE_SORT:
1608           no_sort = 0;
1609           sort_numerically = 0;
1610           sort_by_size = 1;
1611           break;
1612         case 'P':
1613           set_output_format ("posix");
1614           break;
1615         case 'r':
1616           reverse_sort = 1;
1617           break;
1618         case 's':
1619           print_armap = 1;
1620           break;
1621         case 'S':
1622           print_size = 1;
1623           break;
1624         case 't':
1625           set_print_radix (optarg);
1626           break;
1627         case 'u':
1628           undefined_only = 1;
1629           break;
1630         case 'V':
1631           show_version = 1;
1632           break;
1633         case 'X':
1634           /* Ignored for (partial) AIX compatibility.  On AIX, the
1635              argument has values 32, 64, or 32_64, and specifies that
1636              only 32-bit, only 64-bit, or both kinds of objects should
1637              be examined.  The default is 32.  So plain AIX nm on a
1638              library archive with both kinds of objects will ignore
1639              the 64-bit ones.  For GNU nm, the default is and always
1640              has been -X 32_64, and other options are not supported.  */
1641           if (strcmp (optarg, "32_64") != 0)
1642             fatal (_("Only -X 32_64 is supported"));
1643           break;
1644
1645         case OPTION_TARGET:     /* --target */
1646           target = optarg;
1647           break;
1648
1649         case OPTION_PLUGIN:     /* --plugin */
1650 #if BFD_SUPPORTS_PLUGINS
1651           plugin_target = "plugin";
1652           bfd_plugin_set_plugin (optarg);
1653 #else
1654           fatal (_("sorry - this program has been built without plugin support\n"));
1655 #endif
1656           break;
1657
1658         case 0:         /* A long option that just sets a flag.  */
1659           break;
1660
1661         default:
1662           usage (stderr, 1);
1663         }
1664     }
1665
1666   if (show_version)
1667     print_version ("nm");
1668
1669   if (sort_by_size && undefined_only)
1670     {
1671       non_fatal (_("Using the --size-sort and --undefined-only options together"));
1672       non_fatal (_("will produce no output, since undefined symbols have no size."));
1673       return 0;
1674     }
1675
1676   /* OK, all options now parsed.  If no filename specified, do a.out.  */
1677   if (optind == argc)
1678     return !display_file ("a.out");
1679
1680   retval = 0;
1681
1682   if (argc - optind > 1)
1683     filename_per_file = 1;
1684
1685   /* We were given several filenames to do.  */
1686   while (optind < argc)
1687     {
1688       PROGRESS (1);
1689       if (!display_file (argv[optind++]))
1690         retval++;
1691     }
1692
1693   END_PROGRESS (program_name);
1694
1695 #ifdef HAVE_SBRK
1696   if (show_stats)
1697     {
1698       char *lim = (char *) sbrk (0);
1699
1700       non_fatal (_("data size %ld"), (long) (lim - (char *) &environ));
1701     }
1702 #endif
1703
1704   exit (retval);
1705   return retval;
1706 }