contrib/binutils-2.27/binutils/nm.c

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