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