binutils/nm.c

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