binutils/nm.c

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