binutils/nm.c

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