binutils/nm.c

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