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_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    || ((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
1100   if (! dynamic)
1101     {
1102       if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
1103         {
1104           non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1105           return;
1106         }
1107     }
1108
1109   symcount = bfd_read_minisymbols (abfd, dynamic, &minisyms, &size);
1110   if (symcount < 0)
1111     {
1112       if (dynamic && bfd_get_error () == bfd_error_no_symbols)
1113         {
1114           non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1115           return;
1116         }
1117
1118       bfd_fatal (bfd_get_filename (abfd));
1119     }
1120
1121   if (symcount == 0)
1122     {
1123       non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1124       return;
1125     }
1126
1127   if (show_synthetic && size == sizeof (asymbol *))
1128     {
1129       asymbol *synthsyms;
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   free (minisyms);
1207   free (symsizes);
1208 }
1209
1210 static void
1211 set_print_width (bfd *file)
1212 {
1213   print_width = bfd_get_arch_size (file);
1214
1215   if (print_width == -1)
1216     {
1217       /* PR binutils/4292
1218          Guess the target's bitsize based on its name.
1219          We assume here than any 64-bit format will include
1220          "64" somewhere in its name.  The only known exception
1221          is the MMO object file format.  */
1222       if (strstr (bfd_get_target (file), "64") != NULL
1223           || strcmp (bfd_get_target (file), "mmo") == 0)
1224         print_width = 64;
1225       else
1226         print_width = 32;
1227     }
1228 }
1229
1230 static void
1231 display_archive (bfd *file)
1232 {
1233   bfd *arfile = NULL;
1234   bfd *last_arfile = NULL;
1235   char **matching;
1236
1237   format->print_archive_filename (bfd_get_filename (file));
1238
1239   if (print_armap)
1240     print_symdef_entry (file);
1241
1242   for (;;)
1243     {
1244       PROGRESS (1);
1245
1246       arfile = bfd_openr_next_archived_file (file, arfile);
1247
1248       if (arfile == NULL)
1249         {
1250           if (bfd_get_error () != bfd_error_no_more_archived_files)
1251             bfd_fatal (bfd_get_filename (file));
1252           break;
1253         }
1254
1255       if (bfd_check_format_matches (arfile, bfd_object, &matching))
1256         {
1257           set_print_width (arfile);
1258           format->print_archive_member (bfd_get_filename (file),
1259                                         bfd_get_filename (arfile));
1260           display_rel_file (arfile, file);
1261         }
1262       else
1263         {
1264           bfd_nonfatal (bfd_get_filename (arfile));
1265           if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1266             {
1267               list_matching_formats (matching);
1268               free (matching);
1269             }
1270         }
1271
1272       if (last_arfile != NULL)
1273         {
1274           bfd_close (last_arfile);
1275           lineno_cache_bfd = NULL;
1276           lineno_cache_rel_bfd = NULL;
1277           if (arfile == last_arfile)
1278             return;
1279         }
1280       last_arfile = arfile;
1281     }
1282
1283   if (last_arfile != NULL)
1284     {
1285       bfd_close (last_arfile);
1286       lineno_cache_bfd = NULL;
1287       lineno_cache_rel_bfd = NULL;
1288     }
1289 }
1290
1291 static bfd_boolean
1292 display_file (char *filename)
1293 {
1294   bfd_boolean retval = TRUE;
1295   bfd *file;
1296   char **matching;
1297
1298   if (get_file_size (filename) < 1)
1299     return FALSE;
1300
1301   file = bfd_openr (filename, target ? target : plugin_target);
1302   if (file == NULL)
1303     {
1304       bfd_nonfatal (filename);
1305       return FALSE;
1306     }
1307
1308   /* If printing line numbers, decompress the debug sections.  */
1309   if (line_numbers)
1310     file->flags |= BFD_DECOMPRESS;
1311
1312   if (bfd_check_format (file, bfd_archive))
1313     {
1314       display_archive (file);
1315     }
1316   else if (bfd_check_format_matches (file, bfd_object, &matching))
1317     {
1318       set_print_width (file);
1319       format->print_object_filename (filename);
1320       display_rel_file (file, NULL);
1321     }
1322   else
1323     {
1324       bfd_nonfatal (filename);
1325       if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1326         {
1327           list_matching_formats (matching);
1328           free (matching);
1329         }
1330       retval = FALSE;
1331     }
1332
1333   if (!bfd_close (file))
1334     bfd_fatal (filename);
1335
1336   lineno_cache_bfd = NULL;
1337   lineno_cache_rel_bfd = NULL;
1338
1339   return retval;
1340 }
1341 \f
1342 /* The following 3 groups of functions are called unconditionally,
1343    once at the start of processing each file of the appropriate type.
1344    They should check `filename_per_file' and `filename_per_symbol',
1345    as appropriate for their output format, to determine whether to
1346    print anything.  */
1347 \f
1348 /* Print the name of an object file given on the command line.  */
1349
1350 static void
1351 print_object_filename_bsd (char *filename)
1352 {
1353   if (filename_per_file && !filename_per_symbol)
1354     printf ("\n%s:\n", filename);
1355 }
1356
1357 static void
1358 print_object_filename_sysv (char *filename)
1359 {
1360   if (undefined_only)
1361     printf (_("\n\nUndefined symbols from %s:\n\n"), filename);
1362   else
1363     printf (_("\n\nSymbols from %s:\n\n"), filename);
1364   if (print_width == 32)
1365     printf (_("\
1366 Name                  Value   Class        Type         Size     Line  Section\n\n"));
1367   else
1368     printf (_("\
1369 Name                  Value           Class        Type         Size             Line  Section\n\n"));
1370 }
1371
1372 static void
1373 print_object_filename_posix (char *filename)
1374 {
1375   if (filename_per_file && !filename_per_symbol)
1376     printf ("%s:\n", filename);
1377 }
1378 \f
1379 /* Print the name of an archive file given on the command line.  */
1380
1381 static void
1382 print_archive_filename_bsd (char *filename)
1383 {
1384   if (filename_per_file)
1385     printf ("\n%s:\n", filename);
1386 }
1387
1388 static void
1389 print_archive_filename_sysv (char *filename ATTRIBUTE_UNUSED)
1390 {
1391 }
1392
1393 static void
1394 print_archive_filename_posix (char *filename ATTRIBUTE_UNUSED)
1395 {
1396 }
1397 \f
1398 /* Print the name of an archive member file.  */
1399
1400 static void
1401 print_archive_member_bsd (char *archive ATTRIBUTE_UNUSED,
1402                           const char *filename)
1403 {
1404   if (!filename_per_symbol)
1405     printf ("\n%s:\n", filename);
1406 }
1407
1408 static void
1409 print_archive_member_sysv (char *archive, const char *filename)
1410 {
1411   if (undefined_only)
1412     printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive, filename);
1413   else
1414     printf (_("\n\nSymbols from %s[%s]:\n\n"), archive, filename);
1415   if (print_width == 32)
1416     printf (_("\
1417 Name                  Value   Class        Type         Size     Line  Section\n\n"));
1418   else
1419     printf (_("\
1420 Name                  Value           Class        Type         Size             Line  Section\n\n"));
1421 }
1422
1423 static void
1424 print_archive_member_posix (char *archive, const char *filename)
1425 {
1426   if (!filename_per_symbol)
1427     printf ("%s[%s]:\n", archive, filename);
1428 }
1429 \f
1430 /* Print the name of the file (and archive, if there is one)
1431    containing a symbol.  */
1432
1433 static void
1434 print_symbol_filename_bsd (bfd *archive_bfd, bfd *abfd)
1435 {
1436   if (filename_per_symbol)
1437     {
1438       if (archive_bfd)
1439         printf ("%s:", bfd_get_filename (archive_bfd));
1440       printf ("%s:", bfd_get_filename (abfd));
1441     }
1442 }
1443
1444 static void
1445 print_symbol_filename_sysv (bfd *archive_bfd, bfd *abfd)
1446 {
1447   if (filename_per_symbol)
1448     {
1449       if (archive_bfd)
1450         printf ("%s:", bfd_get_filename (archive_bfd));
1451       printf ("%s:", bfd_get_filename (abfd));
1452     }
1453 }
1454
1455 static void
1456 print_symbol_filename_posix (bfd *archive_bfd, bfd *abfd)
1457 {
1458   if (filename_per_symbol)
1459     {
1460       if (archive_bfd)
1461         printf ("%s[%s]: ", bfd_get_filename (archive_bfd),
1462                 bfd_get_filename (abfd));
1463       else
1464         printf ("%s: ", bfd_get_filename (abfd));
1465     }
1466 }
1467 \f
1468 /* Print a symbol value.  */
1469
1470 static void
1471 print_value (bfd *abfd ATTRIBUTE_UNUSED, bfd_vma val)
1472 {
1473   switch (print_width)
1474     {
1475     case 32:
1476       printf (value_format_32bit, (unsigned long) val);
1477       break;
1478
1479     case 64:
1480 #if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
1481       printf (value_format_64bit, val);
1482 #else
1483       /* We have a 64 bit value to print, but the host is only 32 bit.  */
1484       if (print_radix == 16)
1485         bfd_fprintf_vma (abfd, stdout, val);
1486       else
1487         {
1488           char buf[30];
1489           char *s;
1490
1491           s = buf + sizeof buf;
1492           *--s = '\0';
1493           while (val > 0)
1494             {
1495               *--s = (val % print_radix) + '0';
1496               val /= print_radix;
1497             }
1498           while ((buf + sizeof buf - 1) - s < 16)
1499             *--s = '0';
1500           printf ("%s", s);
1501         }
1502 #endif
1503       break;
1504
1505     default:
1506       fatal (_("Print width has not been initialized (%d)"), print_width);
1507       break;
1508     }
1509 }
1510
1511 /* Print a line of information about a symbol.  */
1512
1513 static void
1514 print_symbol_info_bsd (struct extended_symbol_info *info, bfd *abfd)
1515 {
1516   if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1517     {
1518       if (print_width == 64)
1519         printf ("        ");
1520       printf ("        ");
1521     }
1522   else
1523     {
1524       /* Normally we print the value of the symbol.  If we are printing the
1525          size or sorting by size then we print its size, except for the
1526          (weird) special case where both flags are defined, in which case we
1527          print both values.  This conforms to documented behaviour.  */
1528       if (sort_by_size && !print_size)
1529         print_value (abfd, SYM_SIZE (info));
1530       else
1531         print_value (abfd, SYM_VALUE (info));
1532       if (print_size && SYM_SIZE (info))
1533         {
1534           printf (" ");
1535           print_value (abfd, SYM_SIZE (info));
1536         }
1537     }
1538
1539   printf (" %c", SYM_TYPE (info));
1540
1541   if (SYM_TYPE (info) == '-')
1542     {
1543       /* A stab.  */
1544       printf (" ");
1545       printf (other_format, SYM_STAB_OTHER (info));
1546       printf (" ");
1547       printf (desc_format, SYM_STAB_DESC (info));
1548       printf (" %5s", SYM_STAB_NAME (info));
1549     }
1550   print_symname (" %s", SYM_NAME (info), abfd);
1551 }
1552
1553 static void
1554 print_symbol_info_sysv (struct extended_symbol_info *info, bfd *abfd)
1555 {
1556   print_symname ("%-20s|", SYM_NAME (info), abfd);
1557
1558   if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1559     {
1560       if (print_width == 32)
1561         printf ("        ");
1562       else
1563         printf ("                ");
1564     }
1565   else
1566     print_value (abfd, SYM_VALUE (info));
1567
1568   printf ("|   %c  |", SYM_TYPE (info));
1569
1570   if (SYM_TYPE (info) == '-')
1571     {
1572       /* A stab.  */
1573       printf ("%18s|  ", SYM_STAB_NAME (info));         /* (C) Type.  */
1574       printf (desc_format, SYM_STAB_DESC (info));       /* Size.  */
1575       printf ("|     |");                               /* Line, Section.  */
1576     }
1577   else
1578     {
1579       /* Type, Size, Line, Section */
1580       if (info->elfinfo)
1581         printf ("%18s|",
1582                 get_elf_symbol_type (ELF_ST_TYPE (info->elfinfo->internal_elf_sym.st_info)));
1583       else if (info->coffinfo)
1584         printf ("%18s|",
1585                 get_coff_symbol_type (&info->coffinfo->native->u.syment));
1586       else
1587         printf ("                  |");
1588
1589       if (SYM_SIZE (info))
1590         print_value (abfd, SYM_SIZE (info));
1591       else
1592         {
1593           if (print_width == 32)
1594             printf ("        ");
1595           else
1596             printf ("                ");
1597         }
1598
1599       if (info->elfinfo)
1600         printf("|     |%s", info->elfinfo->symbol.section->name);
1601       else if (info->coffinfo)
1602         printf("|     |%s", info->coffinfo->symbol.section->name);
1603       else
1604         printf("|     |");
1605     }
1606 }
1607
1608 static void
1609 print_symbol_info_posix (struct extended_symbol_info *info, bfd *abfd)
1610 {
1611   print_symname ("%s ", SYM_NAME (info), abfd);
1612   printf ("%c ", SYM_TYPE (info));
1613
1614   if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1615     printf ("        ");
1616   else
1617     {
1618       print_value (abfd, SYM_VALUE (info));
1619       printf (" ");
1620       if (SYM_SIZE (info))
1621         print_value (abfd, SYM_SIZE (info));
1622     }
1623 }
1624 \f
1625 int
1626 main (int argc, char **argv)
1627 {
1628   int c;
1629   int retval;
1630
1631 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1632   setlocale (LC_MESSAGES, "");
1633 #endif
1634 #if defined (HAVE_SETLOCALE)
1635   setlocale (LC_CTYPE, "");
1636   setlocale (LC_COLLATE, "");
1637 #endif
1638   bindtextdomain (PACKAGE, LOCALEDIR);
1639   textdomain (PACKAGE);
1640
1641   program_name = *argv;
1642   xmalloc_set_program_name (program_name);
1643   bfd_set_error_program_name (program_name);
1644 #if BFD_SUPPORTS_PLUGINS
1645   bfd_plugin_set_program_name (program_name);
1646 #endif
1647
1648   START_PROGRESS (program_name, 0);
1649
1650   expandargv (&argc, &argv);
1651
1652   bfd_init ();
1653   set_default_bfd_target ();
1654
1655   while ((c = getopt_long (argc, argv, "aABCDef:gHhlnopPrSst:uvVvX:",
1656                            long_options, (int *) 0)) != EOF)
1657     {
1658       switch (c)
1659         {
1660         case 'a':
1661           print_debug_syms = 1;
1662           break;
1663         case 'A':
1664         case 'o':
1665           filename_per_symbol = 1;
1666           break;
1667         case 'B':               /* For MIPS compatibility.  */
1668           set_output_format ("bsd");
1669           break;
1670         case 'C':
1671           do_demangle = 1;
1672           if (optarg != NULL)
1673             {
1674               enum demangling_styles style;
1675
1676               style = cplus_demangle_name_to_style (optarg);
1677               if (style == unknown_demangling)
1678                 fatal (_("unknown demangling style `%s'"),
1679                        optarg);
1680
1681               cplus_demangle_set_style (style);
1682             }
1683           break;
1684         case 'D':
1685           dynamic = 1;
1686           break;
1687         case 'e':
1688           /* Ignored for HP/UX compatibility.  */
1689           break;
1690         case 'f':
1691           set_output_format (optarg);
1692           break;
1693         case 'g':
1694           external_only = 1;
1695           break;
1696         case 'H':
1697         case 'h':
1698           usage (stdout, 0);
1699         case 'l':
1700           line_numbers = 1;
1701           break;
1702         case 'n':
1703         case 'v':
1704           no_sort = 0;
1705           sort_numerically = 1;
1706           sort_by_size = 0;
1707           break;
1708         case 'p':
1709           no_sort = 1;
1710           sort_numerically = 0;
1711           sort_by_size = 0;
1712           break;
1713         case OPTION_SIZE_SORT:
1714           no_sort = 0;
1715           sort_numerically = 0;
1716           sort_by_size = 1;
1717           break;
1718         case 'P':
1719           set_output_format ("posix");
1720           break;
1721         case 'r':
1722           reverse_sort = 1;
1723           break;
1724         case 's':
1725           print_armap = 1;
1726           break;
1727         case 'S':
1728           print_size = 1;
1729           break;
1730         case 't':
1731           set_print_radix (optarg);
1732           break;
1733         case 'u':
1734           undefined_only = 1;
1735           break;
1736         case 'V':
1737           show_version = 1;
1738           break;
1739         case 'X':
1740           /* Ignored for (partial) AIX compatibility.  On AIX, the
1741              argument has values 32, 64, or 32_64, and specifies that
1742              only 32-bit, only 64-bit, or both kinds of objects should
1743              be examined.  The default is 32.  So plain AIX nm on a
1744              library archive with both kinds of objects will ignore
1745              the 64-bit ones.  For GNU nm, the default is and always
1746              has been -X 32_64, and other options are not supported.  */
1747           if (strcmp (optarg, "32_64") != 0)
1748             fatal (_("Only -X 32_64 is supported"));
1749           break;
1750
1751         case OPTION_TARGET:     /* --target */
1752           target = optarg;
1753           break;
1754
1755         case OPTION_PLUGIN:     /* --plugin */
1756 #if BFD_SUPPORTS_PLUGINS
1757           bfd_plugin_set_plugin (optarg);
1758 #else
1759           fatal (_("sorry - this program has been built without plugin support\n"));
1760 #endif
1761           break;
1762
1763         case 0:         /* A long option that just sets a flag.  */
1764           break;
1765
1766         default:
1767           usage (stderr, 1);
1768         }
1769     }
1770
1771   if (show_version)
1772     print_version ("nm");
1773
1774   if (sort_by_size && undefined_only)
1775     {
1776       non_fatal (_("Using the --size-sort and --undefined-only options together"));
1777       non_fatal (_("will produce no output, since undefined symbols have no size."));
1778       return 0;
1779     }
1780
1781   /* OK, all options now parsed.  If no filename specified, do a.out.  */
1782   if (optind == argc)
1783     return !display_file ("a.out");
1784
1785   retval = 0;
1786
1787   if (argc - optind > 1)
1788     filename_per_file = 1;
1789
1790   /* We were given several filenames to do.  */
1791   while (optind < argc)
1792     {
1793       PROGRESS (1);
1794       if (!display_file (argv[optind++]))
1795         retval++;
1796     }
1797
1798   END_PROGRESS (program_name);
1799
1800 #ifdef HAVE_SBRK
1801   if (show_stats)
1802     {
1803       char *lim = (char *) sbrk (0);
1804
1805       non_fatal (_("data size %ld"), (long) (lim - (char *) &environ));
1806     }
1807 #endif
1808
1809   exit (retval);
1810   return retval;
1811 }