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