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