contrib/binutils-2.25/binutils/nm.c

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