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