binutils/nm.c

   1 /* nm.c -- Describe symbol table of a rel file.
   2    Copyright (C) 1991-2017 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       int synthetic = (sym->flags & BSF_SYNTHETIC);
 767
 768       if (from + size < fromend)
 769         {
 770           next = bfd_minisymbol_to_symbol (abfd,
 771                                            is_dynamic,
 772                                            (const void *) (from + size),
 773                                            store_next);
 774           if (next == NULL)
 775             bfd_fatal (bfd_get_filename (abfd));
 776         }
 777       else
 778         next = NULL;
 779
 780       sec = bfd_get_section (sym);
 781
 782       /* Synthetic symbols don't have a full type set of data available, thus
 783          we can't rely on that information for the symbol size.  */
 784       if (!synthetic && bfd_get_flavour (abfd) == bfd_target_elf_flavour)
 785         sz = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
 786       else if (!synthetic && bfd_is_com_section (sec))
 787         sz = sym->value;
 788       else
 789         {
 790           if (from + size < fromend
 791               && sec == bfd_get_section (next))
 792             sz = valueof (next) - valueof (sym);
 793           else
 794             sz = (bfd_get_section_vma (abfd, sec)
 795                   + bfd_section_size (abfd, sec)
 796                   - valueof (sym));
 797         }
 798
 799       if (sz != 0)
 800         {
 801           symsizes->minisym = (const void *) from;
 802           symsizes->size = sz;
 803           ++symsizes;
 804         }
 805
 806       sym = next;
 807
 808       temp = store_sym;
 809       store_sym = store_next;
 810       store_next = temp;
 811     }
 812
 813   symcount = symsizes - *symsizesp;
 814
 815   /* We must now sort again by size.  */
 816   qsort ((void *) *symsizesp, symcount, sizeof (struct size_sym), size_forward2);
 817
 818   return symcount;
 819 }
 820
 821 /* This function is used to get the relocs for a particular section.
 822    It is called via bfd_map_over_sections.  */
 823
 824 static void
 825 get_relocs (bfd *abfd, asection *sec, void *dataarg)
 826 {
 827   struct get_relocs_info *data = (struct get_relocs_info *) dataarg;
 828
 829   *data->secs = sec;
 830
 831   if ((sec->flags & SEC_RELOC) == 0)
 832     {
 833       *data->relocs = NULL;
 834       *data->relcount = 0;
 835     }
 836   else
 837     {
 838       long relsize;
 839
 840       relsize = bfd_get_reloc_upper_bound (abfd, sec);
 841       if (relsize < 0)
 842         bfd_fatal (bfd_get_filename (abfd));
 843
 844       *data->relocs = (arelent **) xmalloc (relsize);
 845       *data->relcount = bfd_canonicalize_reloc (abfd, sec, *data->relocs,
 846                                                 data->syms);
 847       if (*data->relcount < 0)
 848         bfd_fatal (bfd_get_filename (abfd));
 849     }
 850
 851   ++data->secs;
 852   ++data->relocs;
 853   ++data->relcount;
 854 }
 855
 856 /* Print a single symbol.  */
 857
 858 static void
 859 print_symbol (bfd *        abfd,
 860               asymbol *    sym,
 861               bfd_vma      ssize,
 862               bfd *        archive_bfd)
 863 {
 864   symbol_info syminfo;
 865   struct extended_symbol_info info;
 866
 867   PROGRESS (1);
 868
 869   format->print_symbol_filename (archive_bfd, abfd);
 870
 871   bfd_get_symbol_info (abfd, sym, &syminfo);
 872
 873   info.sinfo = &syminfo;
 874   info.ssize = ssize;
 875   /* Synthetic symbols do not have a full symbol type set of data available.  */
 876   if ((sym->flags & BSF_SYNTHETIC) != 0)
 877     {
 878       info.elfinfo = NULL;
 879       info.coffinfo = NULL;
 880     }
 881   else
 882     {
 883       info.elfinfo = elf_symbol_from (abfd, sym);
 884       info.coffinfo = coff_symbol_from (sym);
 885     }
 886
 887   format->print_symbol_info (&info, abfd);
 888
 889   if (with_symbol_versions)
 890     {
 891       const char *  version_string = NULL;
 892       bfd_boolean   hidden = FALSE;
 893
 894       if ((sym->flags & BSF_SYNTHETIC) == 0)
 895         version_string = bfd_get_symbol_version_string (abfd, sym, &hidden);
 896
 897       if (bfd_is_und_section (bfd_get_section (sym)))
 898         hidden = TRUE;
 899
 900       if (version_string && *version_string != '\0')
 901         printf (hidden ? "@%s" : "@@%s", version_string);
 902     }
 903
 904   if (line_numbers)
 905     {
 906       static asymbol **syms;
 907       static long symcount;
 908       const char *filename, *functionname;
 909       unsigned int lineno;
 910
 911       /* We need to get the canonical symbols in order to call
 912          bfd_find_nearest_line.  This is inefficient, but, then, you
 913          don't have to use --line-numbers.  */
 914       if (abfd != lineno_cache_bfd && syms != NULL)
 915         {
 916           free (syms);
 917           syms = NULL;
 918         }
 919       if (syms == NULL)
 920         {
 921           long symsize;
 922
 923           symsize = bfd_get_symtab_upper_bound (abfd);
 924           if (symsize < 0)
 925             bfd_fatal (bfd_get_filename (abfd));
 926           syms = (asymbol **) xmalloc (symsize);
 927           symcount = bfd_canonicalize_symtab (abfd, syms);
 928           if (symcount < 0)
 929             bfd_fatal (bfd_get_filename (abfd));
 930           lineno_cache_bfd = abfd;
 931         }
 932
 933       if (bfd_is_und_section (bfd_get_section (sym)))
 934         {
 935           static asection **secs;
 936           static arelent ***relocs;
 937           static long *relcount;
 938           static unsigned int seccount;
 939           unsigned int i;
 940           const char *symname;
 941
 942           /* For an undefined symbol, we try to find a reloc for the
 943              symbol, and print the line number of the reloc.  */
 944           if (abfd != lineno_cache_rel_bfd && relocs != NULL)
 945             {
 946               for (i = 0; i < seccount; i++)
 947                 if (relocs[i] != NULL)
 948                   free (relocs[i]);
 949               free (secs);
 950               free (relocs);
 951               free (relcount);
 952               secs = NULL;
 953               relocs = NULL;
 954               relcount = NULL;
 955             }
 956
 957           if (relocs == NULL)
 958             {
 959               struct get_relocs_info rinfo;
 960
 961               seccount = bfd_count_sections (abfd);
 962
 963               secs = (asection **) xmalloc (seccount * sizeof *secs);
 964               relocs = (arelent ***) xmalloc (seccount * sizeof *relocs);
 965               relcount = (long *) xmalloc (seccount * sizeof *relcount);
 966
 967               rinfo.secs = secs;
 968               rinfo.relocs = relocs;
 969               rinfo.relcount = relcount;
 970               rinfo.syms = syms;
 971               bfd_map_over_sections (abfd, get_relocs, (void *) &rinfo);
 972               lineno_cache_rel_bfd = abfd;
 973             }
 974
 975           symname = bfd_asymbol_name (sym);
 976           for (i = 0; i < seccount; i++)
 977             {
 978               long j;
 979
 980               for (j = 0; j < relcount[i]; j++)
 981                 {
 982                   arelent *r;
 983
 984                   r = relocs[i][j];
 985                   if (r->sym_ptr_ptr != NULL
 986                       && (*r->sym_ptr_ptr)->section == sym->section
 987                       && (*r->sym_ptr_ptr)->value == sym->value
 988                       && strcmp (symname,
 989                                  bfd_asymbol_name (*r->sym_ptr_ptr)) == 0
 990                       && bfd_find_nearest_line (abfd, secs[i], syms,
 991                                                 r->address, &filename,
 992                                                 &functionname, &lineno)
 993                       && filename != NULL)
 994                     {
 995                       /* We only print the first one we find.  */
 996                       printf ("\t%s:%u", filename, lineno);
 997                       i = seccount;
 998                       break;
 999                     }
1000                 }
1001             }
1002         }
1003       else if (bfd_get_section (sym)->owner == abfd)
1004         {
1005           if ((bfd_find_line (abfd, syms, sym, &filename, &lineno)
1006                || bfd_find_nearest_line (abfd, bfd_get_section (sym),
1007                                          syms, sym->value, &filename,
1008                                          &functionname, &lineno))
1009               && filename != NULL
1010               && lineno != 0)
1011             printf ("\t%s:%u", filename, lineno);
1012         }
1013     }
1014
1015   putchar ('\n');
1016 }
1017 \f
1018 /* Print the symbols when sorting by size.  */
1019
1020 static void
1021 print_size_symbols (bfd *              abfd,
1022                     bfd_boolean        is_dynamic,
1023                     struct size_sym *  symsizes,
1024                     long               symcount,
1025                     bfd *              archive_bfd)
1026 {
1027   asymbol *store;
1028   struct size_sym *from;
1029   struct size_sym *fromend;
1030
1031   store = bfd_make_empty_symbol (abfd);
1032   if (store == NULL)
1033     bfd_fatal (bfd_get_filename (abfd));
1034
1035   from = symsizes;
1036   fromend = from + symcount;
1037
1038   for (; from < fromend; from++)
1039     {
1040       asymbol *sym;
1041
1042       sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from->minisym, store);
1043       if (sym == NULL)
1044         bfd_fatal (bfd_get_filename (abfd));
1045
1046       print_symbol (abfd, sym, from->size, archive_bfd);
1047     }
1048 }
1049
1050 \f
1051 /* Print the symbols of ABFD that are held in MINISYMS.
1052
1053    If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.
1054
1055    SYMCOUNT is the number of symbols in MINISYMS.
1056
1057    SIZE is the size of a symbol in MINISYMS.  */
1058
1059 static void
1060 print_symbols (bfd *         abfd,
1061                bfd_boolean   is_dynamic,
1062                void *        minisyms,
1063                long          symcount,
1064                unsigned int  size,
1065                bfd *         archive_bfd)
1066 {
1067   asymbol *store;
1068   bfd_byte *from;
1069   bfd_byte *fromend;
1070
1071   store = bfd_make_empty_symbol (abfd);
1072   if (store == NULL)
1073     bfd_fatal (bfd_get_filename (abfd));
1074
1075   from = (bfd_byte *) minisyms;
1076   fromend = from + symcount * size;
1077
1078   for (; from < fromend; from += size)
1079     {
1080       asymbol *sym;
1081
1082       sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from, store);
1083       if (sym == NULL)
1084         bfd_fatal (bfd_get_filename (abfd));
1085
1086       print_symbol (abfd, sym, (bfd_vma) 0, archive_bfd);
1087     }
1088 }
1089
1090 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.  */
1091
1092 static void
1093 display_rel_file (bfd *abfd, bfd *archive_bfd)
1094 {
1095   long symcount;
1096   void *minisyms;
1097   unsigned int size;
1098   struct size_sym *symsizes;
1099   asymbol *synthsyms = NULL;
1100
1101   if (! dynamic)
1102     {
1103       if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
1104         {
1105           non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1106           return;
1107         }
1108     }
1109
1110   symcount = bfd_read_minisymbols (abfd, dynamic, &minisyms, &size);
1111   if (symcount < 0)
1112     {
1113       if (dynamic && bfd_get_error () == bfd_error_no_symbols)
1114         {
1115           non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1116           return;
1117         }
1118
1119       bfd_fatal (bfd_get_filename (abfd));
1120     }
1121
1122   if (symcount == 0)
1123     {
1124       non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1125       return;
1126     }
1127
1128   if (show_synthetic && size == sizeof (asymbol *))
1129     {
1130       asymbol **static_syms = NULL;
1131       asymbol **dyn_syms = NULL;
1132       long static_count = 0;
1133       long dyn_count = 0;
1134       long synth_count;
1135
1136       if (dynamic)
1137         {
1138           dyn_count = symcount;
1139           dyn_syms = (asymbol **) minisyms;
1140         }
1141       else
1142         {
1143           long storage = bfd_get_dynamic_symtab_upper_bound (abfd);
1144
1145           static_count = symcount;
1146           static_syms = (asymbol **) minisyms;
1147
1148           if (storage > 0)
1149             {
1150               dyn_syms = (asymbol **) xmalloc (storage);
1151               dyn_count = bfd_canonicalize_dynamic_symtab (abfd, dyn_syms);
1152               if (dyn_count < 0)
1153                 bfd_fatal (bfd_get_filename (abfd));
1154             }
1155         }
1156
1157       synth_count = bfd_get_synthetic_symtab (abfd, static_count, static_syms,
1158                                               dyn_count, dyn_syms, &synthsyms);
1159       if (synth_count > 0)
1160         {
1161           asymbol **symp;
1162           void *new_mini;
1163           long i;
1164
1165           new_mini = xmalloc ((symcount + synth_count + 1) * sizeof (*symp));
1166           symp = (asymbol **) new_mini;
1167           memcpy (symp, minisyms, symcount * sizeof (*symp));
1168           symp += symcount;
1169           for (i = 0; i < synth_count; i++)
1170             *symp++ = synthsyms + i;
1171           *symp = 0;
1172           minisyms = new_mini;
1173           symcount += synth_count;
1174         }
1175     }
1176
1177   /* Discard the symbols we don't want to print.
1178      It's OK to do this in place; we'll free the storage anyway
1179      (after printing).  */
1180
1181   symcount = filter_symbols (abfd, dynamic, minisyms, symcount, size);
1182
1183   symsizes = NULL;
1184   if (! no_sort)
1185     {
1186       sort_bfd = abfd;
1187       sort_dynamic = dynamic;
1188       sort_x = bfd_make_empty_symbol (abfd);
1189       sort_y = bfd_make_empty_symbol (abfd);
1190       if (sort_x == NULL || sort_y == NULL)
1191         bfd_fatal (bfd_get_filename (abfd));
1192
1193       if (! sort_by_size)
1194         qsort (minisyms, symcount, size,
1195                sorters[sort_numerically][reverse_sort]);
1196       else
1197         symcount = sort_symbols_by_size (abfd, dynamic, minisyms, symcount,
1198                                          size, &symsizes);
1199     }
1200
1201   if (! sort_by_size)
1202     print_symbols (abfd, dynamic, minisyms, symcount, size, archive_bfd);
1203   else
1204     print_size_symbols (abfd, dynamic, symsizes, symcount, archive_bfd);
1205
1206   if (synthsyms)
1207     free (synthsyms);
1208   free (minisyms);
1209   free (symsizes);
1210 }
1211
1212 static void
1213 set_print_width (bfd *file)
1214 {
1215   print_width = bfd_get_arch_size (file);
1216
1217   if (print_width == -1)
1218     {
1219       /* PR binutils/4292
1220          Guess the target's bitsize based on its name.
1221          We assume here than any 64-bit format will include
1222          "64" somewhere in its name.  The only known exception
1223          is the MMO object file format.  */
1224       if (strstr (bfd_get_target (file), "64") != NULL
1225           || strcmp (bfd_get_target (file), "mmo") == 0)
1226         print_width = 64;
1227       else
1228         print_width = 32;
1229     }
1230 }
1231
1232 static void
1233 display_archive (bfd *file)
1234 {
1235   bfd *arfile = NULL;
1236   bfd *last_arfile = NULL;
1237   char **matching;
1238
1239   format->print_archive_filename (bfd_get_filename (file));
1240
1241   if (print_armap)
1242     print_symdef_entry (file);
1243
1244   for (;;)
1245     {
1246       PROGRESS (1);
1247
1248       arfile = bfd_openr_next_archived_file (file, arfile);
1249
1250       if (arfile == NULL)
1251         {
1252           if (bfd_get_error () != bfd_error_no_more_archived_files)
1253             bfd_fatal (bfd_get_filename (file));
1254           break;
1255         }
1256
1257       if (bfd_check_format_matches (arfile, bfd_object, &matching))
1258         {
1259           set_print_width (arfile);
1260           format->print_archive_member (bfd_get_filename (file),
1261                                         bfd_get_filename (arfile));
1262           display_rel_file (arfile, file);
1263         }
1264       else
1265         {
1266           bfd_nonfatal (bfd_get_filename (arfile));
1267           if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1268             {
1269               list_matching_formats (matching);
1270               free (matching);
1271             }
1272         }
1273
1274       if (last_arfile != NULL)
1275         {
1276           bfd_close (last_arfile);
1277           lineno_cache_bfd = NULL;
1278           lineno_cache_rel_bfd = NULL;
1279           if (arfile == last_arfile)
1280             return;
1281         }
1282       last_arfile = arfile;
1283     }
1284
1285   if (last_arfile != NULL)
1286     {
1287       bfd_close (last_arfile);
1288       lineno_cache_bfd = NULL;
1289       lineno_cache_rel_bfd = NULL;
1290     }
1291 }
1292
1293 static bfd_boolean
1294 display_file (char *filename)
1295 {
1296   bfd_boolean retval = TRUE;
1297   bfd *file;
1298   char **matching;
1299
1300   if (get_file_size (filename) < 1)
1301     return FALSE;
1302
1303   file = bfd_openr (filename, target ? target : plugin_target);
1304   if (file == NULL)
1305     {
1306       bfd_nonfatal (filename);
1307       return FALSE;
1308     }
1309
1310   /* If printing line numbers, decompress the debug sections.  */
1311   if (line_numbers)
1312     file->flags |= BFD_DECOMPRESS;
1313
1314   if (bfd_check_format (file, bfd_archive))
1315     {
1316       display_archive (file);
1317     }
1318   else if (bfd_check_format_matches (file, bfd_object, &matching))
1319     {
1320       set_print_width (file);
1321       format->print_object_filename (filename);
1322       display_rel_file (file, NULL);
1323     }
1324   else
1325     {
1326       bfd_nonfatal (filename);
1327       if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1328         {
1329           list_matching_formats (matching);
1330           free (matching);
1331         }
1332       retval = FALSE;
1333     }
1334
1335   if (!bfd_close (file))
1336     bfd_fatal (filename);
1337
1338   lineno_cache_bfd = NULL;
1339   lineno_cache_rel_bfd = NULL;
1340
1341   return retval;
1342 }
1343 \f
1344 /* The following 3 groups of functions are called unconditionally,
1345    once at the start of processing each file of the appropriate type.
1346    They should check `filename_per_file' and `filename_per_symbol',
1347    as appropriate for their output format, to determine whether to
1348    print anything.  */
1349 \f
1350 /* Print the name of an object file given on the command line.  */
1351
1352 static void
1353 print_object_filename_bsd (char *filename)
1354 {
1355   if (filename_per_file && !filename_per_symbol)
1356     printf ("\n%s:\n", filename);
1357 }
1358
1359 static void
1360 print_object_filename_sysv (char *filename)
1361 {
1362   if (undefined_only)
1363     printf (_("\n\nUndefined symbols from %s:\n\n"), filename);
1364   else
1365     printf (_("\n\nSymbols from %s:\n\n"), filename);
1366   if (print_width == 32)
1367     printf (_("\
1368 Name                  Value   Class        Type         Size     Line  Section\n\n"));
1369   else
1370     printf (_("\
1371 Name                  Value           Class        Type         Size             Line  Section\n\n"));
1372 }
1373
1374 static void
1375 print_object_filename_posix (char *filename)
1376 {
1377   if (filename_per_file && !filename_per_symbol)
1378     printf ("%s:\n", filename);
1379 }
1380 \f
1381 /* Print the name of an archive file given on the command line.  */
1382
1383 static void
1384 print_archive_filename_bsd (char *filename)
1385 {
1386   if (filename_per_file)
1387     printf ("\n%s:\n", filename);
1388 }
1389
1390 static void
1391 print_archive_filename_sysv (char *filename ATTRIBUTE_UNUSED)
1392 {
1393 }
1394
1395 static void
1396 print_archive_filename_posix (char *filename ATTRIBUTE_UNUSED)
1397 {
1398 }
1399 \f
1400 /* Print the name of an archive member file.  */
1401
1402 static void
1403 print_archive_member_bsd (char *archive ATTRIBUTE_UNUSED,
1404                           const char *filename)
1405 {
1406   if (!filename_per_symbol)
1407     printf ("\n%s:\n", filename);
1408 }
1409
1410 static void
1411 print_archive_member_sysv (char *archive, const char *filename)
1412 {
1413   if (undefined_only)
1414     printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive, filename);
1415   else
1416     printf (_("\n\nSymbols from %s[%s]:\n\n"), archive, filename);
1417   if (print_width == 32)
1418     printf (_("\
1419 Name                  Value   Class        Type         Size     Line  Section\n\n"));
1420   else
1421     printf (_("\
1422 Name                  Value           Class        Type         Size             Line  Section\n\n"));
1423 }
1424
1425 static void
1426 print_archive_member_posix (char *archive, const char *filename)
1427 {
1428   if (!filename_per_symbol)
1429     printf ("%s[%s]:\n", archive, filename);
1430 }
1431 \f
1432 /* Print the name of the file (and archive, if there is one)
1433    containing a symbol.  */
1434
1435 static void
1436 print_symbol_filename_bsd (bfd *archive_bfd, bfd *abfd)
1437 {
1438   if (filename_per_symbol)
1439     {
1440       if (archive_bfd)
1441         printf ("%s:", bfd_get_filename (archive_bfd));
1442       printf ("%s:", bfd_get_filename (abfd));
1443     }
1444 }
1445
1446 static void
1447 print_symbol_filename_sysv (bfd *archive_bfd, bfd *abfd)
1448 {
1449   if (filename_per_symbol)
1450     {
1451       if (archive_bfd)
1452         printf ("%s:", bfd_get_filename (archive_bfd));
1453       printf ("%s:", bfd_get_filename (abfd));
1454     }
1455 }
1456
1457 static void
1458 print_symbol_filename_posix (bfd *archive_bfd, bfd *abfd)
1459 {
1460   if (filename_per_symbol)
1461     {
1462       if (archive_bfd)
1463         printf ("%s[%s]: ", bfd_get_filename (archive_bfd),
1464                 bfd_get_filename (abfd));
1465       else
1466         printf ("%s: ", bfd_get_filename (abfd));
1467     }
1468 }
1469 \f
1470 /* Print a symbol value.  */
1471
1472 static void
1473 print_value (bfd *abfd ATTRIBUTE_UNUSED, bfd_vma val)
1474 {
1475   switch (print_width)
1476     {
1477     case 32:
1478       printf (value_format_32bit, (unsigned long) val);
1479       break;
1480
1481     case 64:
1482 #if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
1483       printf (value_format_64bit, val);
1484 #else
1485       /* We have a 64 bit value to print, but the host is only 32 bit.  */
1486       if (print_radix == 16)
1487         bfd_fprintf_vma (abfd, stdout, val);
1488       else
1489         {
1490           char buf[30];
1491           char *s;
1492
1493           s = buf + sizeof buf;
1494           *--s = '\0';
1495           while (val > 0)
1496             {
1497               *--s = (val % print_radix) + '0';
1498               val /= print_radix;
1499             }
1500           while ((buf + sizeof buf - 1) - s < 16)
1501             *--s = '0';
1502           printf ("%s", s);
1503         }
1504 #endif
1505       break;
1506
1507     default:
1508       fatal (_("Print width has not been initialized (%d)"), print_width);
1509       break;
1510     }
1511 }
1512
1513 /* Print a line of information about a symbol.  */
1514
1515 static void
1516 print_symbol_info_bsd (struct extended_symbol_info *info, bfd *abfd)
1517 {
1518   if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1519     {
1520       if (print_width == 64)
1521         printf ("        ");
1522       printf ("        ");
1523     }
1524   else
1525     {
1526       /* Normally we print the value of the symbol.  If we are printing the
1527          size or sorting by size then we print its size, except for the
1528          (weird) special case where both flags are defined, in which case we
1529          print both values.  This conforms to documented behaviour.  */
1530       if (sort_by_size && !print_size)
1531         print_value (abfd, SYM_SIZE (info));
1532       else
1533         print_value (abfd, SYM_VALUE (info));
1534       if (print_size && SYM_SIZE (info))
1535         {
1536           printf (" ");
1537           print_value (abfd, SYM_SIZE (info));
1538         }
1539     }
1540
1541   printf (" %c", SYM_TYPE (info));
1542
1543   if (SYM_TYPE (info) == '-')
1544     {
1545       /* A stab.  */
1546       printf (" ");
1547       printf (other_format, SYM_STAB_OTHER (info));
1548       printf (" ");
1549       printf (desc_format, SYM_STAB_DESC (info));
1550       printf (" %5s", SYM_STAB_NAME (info));
1551     }
1552   print_symname (" %s", SYM_NAME (info), abfd);
1553 }
1554
1555 static void
1556 print_symbol_info_sysv (struct extended_symbol_info *info, bfd *abfd)
1557 {
1558   print_symname ("%-20s|", SYM_NAME (info), abfd);
1559
1560   if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1561     {
1562       if (print_width == 32)
1563         printf ("        ");
1564       else
1565         printf ("                ");
1566     }
1567   else
1568     print_value (abfd, SYM_VALUE (info));
1569
1570   printf ("|   %c  |", SYM_TYPE (info));
1571
1572   if (SYM_TYPE (info) == '-')
1573     {
1574       /* A stab.  */
1575       printf ("%18s|  ", SYM_STAB_NAME (info));         /* (C) Type.  */
1576       printf (desc_format, SYM_STAB_DESC (info));       /* Size.  */
1577       printf ("|     |");                               /* Line, Section.  */
1578     }
1579   else
1580     {
1581       /* Type, Size, Line, Section */
1582       if (info->elfinfo)
1583         printf ("%18s|",
1584                 get_elf_symbol_type (ELF_ST_TYPE (info->elfinfo->internal_elf_sym.st_info)));
1585       else if (info->coffinfo)
1586         printf ("%18s|",
1587                 get_coff_symbol_type (&info->coffinfo->native->u.syment));
1588       else
1589         printf ("                  |");
1590
1591       if (SYM_SIZE (info))
1592         print_value (abfd, SYM_SIZE (info));
1593       else
1594         {
1595           if (print_width == 32)
1596             printf ("        ");
1597           else
1598             printf ("                ");
1599         }
1600
1601       if (info->elfinfo)
1602         printf("|     |%s", info->elfinfo->symbol.section->name);
1603       else if (info->coffinfo)
1604         printf("|     |%s", info->coffinfo->symbol.section->name);
1605       else
1606         printf("|     |");
1607     }
1608 }
1609
1610 static void
1611 print_symbol_info_posix (struct extended_symbol_info *info, bfd *abfd)
1612 {
1613   print_symname ("%s ", SYM_NAME (info), abfd);
1614   printf ("%c ", SYM_TYPE (info));
1615
1616   if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1617     printf ("        ");
1618   else
1619     {
1620       print_value (abfd, SYM_VALUE (info));
1621       printf (" ");
1622       if (SYM_SIZE (info))
1623         print_value (abfd, SYM_SIZE (info));
1624     }
1625 }
1626 \f
1627 int
1628 main (int argc, char **argv)
1629 {
1630   int c;
1631   int retval;
1632
1633 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1634   setlocale (LC_MESSAGES, "");
1635 #endif
1636 #if defined (HAVE_SETLOCALE)
1637   setlocale (LC_CTYPE, "");
1638   setlocale (LC_COLLATE, "");
1639 #endif
1640   bindtextdomain (PACKAGE, LOCALEDIR);
1641   textdomain (PACKAGE);
1642
1643   program_name = *argv;
1644   xmalloc_set_program_name (program_name);
1645   bfd_set_error_program_name (program_name);
1646 #if BFD_SUPPORTS_PLUGINS
1647   bfd_plugin_set_program_name (program_name);
1648 #endif
1649
1650   START_PROGRESS (program_name, 0);
1651
1652   expandargv (&argc, &argv);
1653
1654   bfd_init ();
1655   set_default_bfd_target ();
1656
1657   while ((c = getopt_long (argc, argv, "aABCDef:gHhlnopPrSst:uvVvX:",
1658                            long_options, (int *) 0)) != EOF)
1659     {
1660       switch (c)
1661         {
1662         case 'a':
1663           print_debug_syms = 1;
1664           break;
1665         case 'A':
1666         case 'o':
1667           filename_per_symbol = 1;
1668           break;
1669         case 'B':               /* For MIPS compatibility.  */
1670           set_output_format ("bsd");
1671           break;
1672         case 'C':
1673           do_demangle = 1;
1674           if (optarg != NULL)
1675             {
1676               enum demangling_styles style;
1677
1678               style = cplus_demangle_name_to_style (optarg);
1679               if (style == unknown_demangling)
1680                 fatal (_("unknown demangling style `%s'"),
1681                        optarg);
1682
1683               cplus_demangle_set_style (style);
1684             }
1685           break;
1686         case 'D':
1687           dynamic = 1;
1688           break;
1689         case 'e':
1690           /* Ignored for HP/UX compatibility.  */
1691           break;
1692         case 'f':
1693           set_output_format (optarg);
1694           break;
1695         case 'g':
1696           external_only = 1;
1697           break;
1698         case 'H':
1699         case 'h':
1700           usage (stdout, 0);
1701         case 'l':
1702           line_numbers = 1;
1703           break;
1704         case 'n':
1705         case 'v':
1706           no_sort = 0;
1707           sort_numerically = 1;
1708           sort_by_size = 0;
1709           break;
1710         case 'p':
1711           no_sort = 1;
1712           sort_numerically = 0;
1713           sort_by_size = 0;
1714           break;
1715         case OPTION_SIZE_SORT:
1716           no_sort = 0;
1717           sort_numerically = 0;
1718           sort_by_size = 1;
1719           break;
1720         case 'P':
1721           set_output_format ("posix");
1722           break;
1723         case 'r':
1724           reverse_sort = 1;
1725           break;
1726         case 's':
1727           print_armap = 1;
1728           break;
1729         case 'S':
1730           print_size = 1;
1731           break;
1732         case 't':
1733           set_print_radix (optarg);
1734           break;
1735         case 'u':
1736           undefined_only = 1;
1737           break;
1738         case 'V':
1739           show_version = 1;
1740           break;
1741         case 'X':
1742           /* Ignored for (partial) AIX compatibility.  On AIX, the
1743              argument has values 32, 64, or 32_64, and specifies that
1744              only 32-bit, only 64-bit, or both kinds of objects should
1745              be examined.  The default is 32.  So plain AIX nm on a
1746              library archive with both kinds of objects will ignore
1747              the 64-bit ones.  For GNU nm, the default is and always
1748              has been -X 32_64, and other options are not supported.  */
1749           if (strcmp (optarg, "32_64") != 0)
1750             fatal (_("Only -X 32_64 is supported"));
1751           break;
1752
1753         case OPTION_TARGET:     /* --target */
1754           target = optarg;
1755           break;
1756
1757         case OPTION_PLUGIN:     /* --plugin */
1758 #if BFD_SUPPORTS_PLUGINS
1759           bfd_plugin_set_plugin (optarg);
1760 #else
1761           fatal (_("sorry - this program has been built without plugin support\n"));
1762 #endif
1763           break;
1764
1765         case 0:         /* A long option that just sets a flag.  */
1766           break;
1767
1768         default:
1769           usage (stderr, 1);
1770         }
1771     }
1772
1773   if (show_version)
1774     print_version ("nm");
1775
1776   if (sort_by_size && undefined_only)
1777     {
1778       non_fatal (_("Using the --size-sort and --undefined-only options together"));
1779       non_fatal (_("will produce no output, since undefined symbols have no size."));
1780       return 0;
1781     }
1782
1783   /* OK, all options now parsed.  If no filename specified, do a.out.  */
1784   if (optind == argc)
1785     return !display_file ("a.out");
1786
1787   retval = 0;
1788
1789   if (argc - optind > 1)
1790     filename_per_file = 1;
1791
1792   /* We were given several filenames to do.  */
1793   while (optind < argc)
1794     {
1795       PROGRESS (1);
1796       if (!display_file (argv[optind++]))
1797         retval++;
1798     }
1799
1800   END_PROGRESS (program_name);
1801
1802   exit (retval);
1803   return retval;
1804 }