binutils/nm.c

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