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 {
 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 ((sym->flags & BSF_SYNTHETIC) != 0)
 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                     bfd *              archive_bfd)
 996 {
 997   asymbol *store;
 998   struct size_sym *from;
 999   struct size_sym *fromend;
1000
1001   store = bfd_make_empty_symbol (abfd);
1002   if (store == NULL)
1003     bfd_fatal (bfd_get_filename (abfd));
1004
1005   from = symsizes;
1006   fromend = from + symcount;
1007
1008   for (; from < fromend; from++)
1009     {
1010       asymbol *sym;
1011
1012       sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from->minisym, store);
1013       if (sym == NULL)
1014         bfd_fatal (bfd_get_filename (abfd));
1015
1016       print_symbol (abfd, sym, from->size, archive_bfd);
1017     }
1018 }
1019
1020 \f
1021 /* Print the symbols of ABFD that are held in MINISYMS.
1022
1023    If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.
1024
1025    SYMCOUNT is the number of symbols in MINISYMS.
1026
1027    SIZE is the size of a symbol in MINISYMS.  */
1028
1029 static void
1030 print_symbols (bfd *         abfd,
1031                bfd_boolean   is_dynamic,
1032                void *        minisyms,
1033                long          symcount,
1034                unsigned int  size,
1035                bfd *         archive_bfd)
1036 {
1037   asymbol *store;
1038   bfd_byte *from;
1039   bfd_byte *fromend;
1040
1041   store = bfd_make_empty_symbol (abfd);
1042   if (store == NULL)
1043     bfd_fatal (bfd_get_filename (abfd));
1044
1045   from = (bfd_byte *) minisyms;
1046   fromend = from + symcount * size;
1047
1048   for (; from < fromend; from += size)
1049     {
1050       asymbol *sym;
1051
1052       sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from, store);
1053       if (sym == NULL)
1054         bfd_fatal (bfd_get_filename (abfd));
1055
1056       print_symbol (abfd, sym, (bfd_vma) 0, archive_bfd);
1057     }
1058 }
1059
1060 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.  */
1061
1062 static void
1063 display_rel_file (bfd *abfd, bfd *archive_bfd)
1064 {
1065   long symcount;
1066   void *minisyms;
1067   unsigned int size;
1068   struct size_sym *symsizes;
1069
1070   if (! dynamic)
1071     {
1072       if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
1073         {
1074           non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1075           return;
1076         }
1077     }
1078
1079   symcount = bfd_read_minisymbols (abfd, dynamic, &minisyms, &size);
1080   if (symcount < 0)
1081     {
1082       if (dynamic && bfd_get_error () == bfd_error_no_symbols)
1083         {
1084           non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1085           return;
1086         }
1087
1088       bfd_fatal (bfd_get_filename (abfd));
1089     }
1090
1091   if (symcount == 0)
1092     {
1093       non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1094       return;
1095     }
1096
1097   if (show_synthetic && size == sizeof (asymbol *))
1098     {
1099       asymbol *synthsyms;
1100       asymbol **static_syms = NULL;
1101       asymbol **dyn_syms = NULL;
1102       long static_count = 0;
1103       long dyn_count = 0;
1104       long synth_count;
1105
1106       if (dynamic)
1107         {
1108           dyn_count = symcount;
1109           dyn_syms = (asymbol **) minisyms;
1110         }
1111       else
1112         {
1113           long storage = bfd_get_dynamic_symtab_upper_bound (abfd);
1114
1115           static_count = symcount;
1116           static_syms = (asymbol **) minisyms;
1117
1118           if (storage > 0)
1119             {
1120               dyn_syms = (asymbol **) xmalloc (storage);
1121               dyn_count = bfd_canonicalize_dynamic_symtab (abfd, dyn_syms);
1122               if (dyn_count < 0)
1123                 bfd_fatal (bfd_get_filename (abfd));
1124             }
1125         }
1126
1127       synth_count = bfd_get_synthetic_symtab (abfd, static_count, static_syms,
1128                                               dyn_count, dyn_syms, &synthsyms);
1129       if (synth_count > 0)
1130         {
1131           asymbol **symp;
1132           void *new_mini;
1133           long i;
1134
1135           new_mini = xmalloc ((symcount + synth_count + 1) * sizeof (*symp));
1136           symp = (asymbol **) new_mini;
1137           memcpy (symp, minisyms, symcount * sizeof (*symp));
1138           symp += symcount;
1139           for (i = 0; i < synth_count; i++)
1140             *symp++ = synthsyms + i;
1141           *symp = 0;
1142           minisyms = new_mini;
1143           symcount += synth_count;
1144         }
1145     }
1146
1147   /* Discard the symbols we don't want to print.
1148      It's OK to do this in place; we'll free the storage anyway
1149      (after printing).  */
1150
1151   symcount = filter_symbols (abfd, dynamic, minisyms, symcount, size);
1152
1153   symsizes = NULL;
1154   if (! no_sort)
1155     {
1156       sort_bfd = abfd;
1157       sort_dynamic = dynamic;
1158       sort_x = bfd_make_empty_symbol (abfd);
1159       sort_y = bfd_make_empty_symbol (abfd);
1160       if (sort_x == NULL || sort_y == NULL)
1161         bfd_fatal (bfd_get_filename (abfd));
1162
1163       if (! sort_by_size)
1164         qsort (minisyms, symcount, size,
1165                sorters[sort_numerically][reverse_sort]);
1166       else
1167         symcount = sort_symbols_by_size (abfd, dynamic, minisyms, symcount,
1168                                          size, &symsizes);
1169     }
1170
1171   if (! sort_by_size)
1172     print_symbols (abfd, dynamic, minisyms, symcount, size, archive_bfd);
1173   else
1174     print_size_symbols (abfd, dynamic, symsizes, symcount, archive_bfd);
1175
1176   free (minisyms);
1177   free (symsizes);
1178 }
1179
1180 static void
1181 set_print_width (bfd *file)
1182 {
1183   print_width = bfd_get_arch_size (file);
1184
1185   if (print_width == -1)
1186     {
1187       /* PR binutils/4292
1188          Guess the target's bitsize based on its name.
1189          We assume here than any 64-bit format will include
1190          "64" somewhere in its name.  The only known exception
1191          is the MMO object file format.  */
1192       if (strstr (bfd_get_target (file), "64") != NULL
1193           || strcmp (bfd_get_target (file), "mmo") == 0)
1194         print_width = 64;
1195       else
1196         print_width = 32;
1197     }
1198 }
1199
1200 static void
1201 display_archive (bfd *file)
1202 {
1203   bfd *arfile = NULL;
1204   bfd *last_arfile = NULL;
1205   char **matching;
1206
1207   format->print_archive_filename (bfd_get_filename (file));
1208
1209   if (print_armap)
1210     print_symdef_entry (file);
1211
1212   for (;;)
1213     {
1214       PROGRESS (1);
1215
1216       arfile = bfd_openr_next_archived_file (file, arfile);
1217
1218       if (arfile == NULL)
1219         {
1220           if (bfd_get_error () != bfd_error_no_more_archived_files)
1221             bfd_fatal (bfd_get_filename (file));
1222           break;
1223         }
1224
1225       if (bfd_check_format_matches (arfile, bfd_object, &matching))
1226         {
1227           set_print_width (arfile);
1228           format->print_archive_member (bfd_get_filename (file),
1229                                         bfd_get_filename (arfile));
1230           display_rel_file (arfile, file);
1231         }
1232       else
1233         {
1234           bfd_nonfatal (bfd_get_filename (arfile));
1235           if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1236             {
1237               list_matching_formats (matching);
1238               free (matching);
1239             }
1240         }
1241
1242       if (last_arfile != NULL)
1243         {
1244           bfd_close (last_arfile);
1245           lineno_cache_bfd = NULL;
1246           lineno_cache_rel_bfd = NULL;
1247           if (arfile == last_arfile)
1248             return;
1249         }
1250       last_arfile = arfile;
1251     }
1252
1253   if (last_arfile != NULL)
1254     {
1255       bfd_close (last_arfile);
1256       lineno_cache_bfd = NULL;
1257       lineno_cache_rel_bfd = NULL;
1258     }
1259 }
1260
1261 static bfd_boolean
1262 display_file (char *filename)
1263 {
1264   bfd_boolean retval = TRUE;
1265   bfd *file;
1266   char **matching;
1267
1268   if (get_file_size (filename) < 1)
1269     return FALSE;
1270
1271   file = bfd_openr (filename, target ? target : plugin_target);
1272   if (file == NULL)
1273     {
1274       bfd_nonfatal (filename);
1275       return FALSE;
1276     }
1277
1278   /* If printing line numbers, decompress the debug sections.  */
1279   if (line_numbers)
1280     file->flags |= BFD_DECOMPRESS;
1281
1282   if (bfd_check_format (file, bfd_archive))
1283     {
1284       display_archive (file);
1285     }
1286   else if (bfd_check_format_matches (file, bfd_object, &matching))
1287     {
1288       set_print_width (file);
1289       format->print_object_filename (filename);
1290       display_rel_file (file, NULL);
1291     }
1292   else
1293     {
1294       bfd_nonfatal (filename);
1295       if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1296         {
1297           list_matching_formats (matching);
1298           free (matching);
1299         }
1300       retval = FALSE;
1301     }
1302
1303   if (!bfd_close (file))
1304     bfd_fatal (filename);
1305
1306   lineno_cache_bfd = NULL;
1307   lineno_cache_rel_bfd = NULL;
1308
1309   return retval;
1310 }
1311 \f
1312 /* The following 3 groups of functions are called unconditionally,
1313    once at the start of processing each file of the appropriate type.
1314    They should check `filename_per_file' and `filename_per_symbol',
1315    as appropriate for their output format, to determine whether to
1316    print anything.  */
1317 \f
1318 /* Print the name of an object file given on the command line.  */
1319
1320 static void
1321 print_object_filename_bsd (char *filename)
1322 {
1323   if (filename_per_file && !filename_per_symbol)
1324     printf ("\n%s:\n", filename);
1325 }
1326
1327 static void
1328 print_object_filename_sysv (char *filename)
1329 {
1330   if (undefined_only)
1331     printf (_("\n\nUndefined symbols from %s:\n\n"), filename);
1332   else
1333     printf (_("\n\nSymbols from %s:\n\n"), filename);
1334   if (print_width == 32)
1335     printf (_("\
1336 Name                  Value   Class        Type         Size     Line  Section\n\n"));
1337   else
1338     printf (_("\
1339 Name                  Value           Class        Type         Size             Line  Section\n\n"));
1340 }
1341
1342 static void
1343 print_object_filename_posix (char *filename)
1344 {
1345   if (filename_per_file && !filename_per_symbol)
1346     printf ("%s:\n", filename);
1347 }
1348 \f
1349 /* Print the name of an archive file given on the command line.  */
1350
1351 static void
1352 print_archive_filename_bsd (char *filename)
1353 {
1354   if (filename_per_file)
1355     printf ("\n%s:\n", filename);
1356 }
1357
1358 static void
1359 print_archive_filename_sysv (char *filename ATTRIBUTE_UNUSED)
1360 {
1361 }
1362
1363 static void
1364 print_archive_filename_posix (char *filename ATTRIBUTE_UNUSED)
1365 {
1366 }
1367 \f
1368 /* Print the name of an archive member file.  */
1369
1370 static void
1371 print_archive_member_bsd (char *archive ATTRIBUTE_UNUSED,
1372                           const char *filename)
1373 {
1374   if (!filename_per_symbol)
1375     printf ("\n%s:\n", filename);
1376 }
1377
1378 static void
1379 print_archive_member_sysv (char *archive, const char *filename)
1380 {
1381   if (undefined_only)
1382     printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive, filename);
1383   else
1384     printf (_("\n\nSymbols from %s[%s]:\n\n"), archive, filename);
1385   if (print_width == 32)
1386     printf (_("\
1387 Name                  Value   Class        Type         Size     Line  Section\n\n"));
1388   else
1389     printf (_("\
1390 Name                  Value           Class        Type         Size             Line  Section\n\n"));
1391 }
1392
1393 static void
1394 print_archive_member_posix (char *archive, const char *filename)
1395 {
1396   if (!filename_per_symbol)
1397     printf ("%s[%s]:\n", archive, filename);
1398 }
1399 \f
1400 /* Print the name of the file (and archive, if there is one)
1401    containing a symbol.  */
1402
1403 static void
1404 print_symbol_filename_bsd (bfd *archive_bfd, bfd *abfd)
1405 {
1406   if (filename_per_symbol)
1407     {
1408       if (archive_bfd)
1409         printf ("%s:", bfd_get_filename (archive_bfd));
1410       printf ("%s:", bfd_get_filename (abfd));
1411     }
1412 }
1413
1414 static void
1415 print_symbol_filename_sysv (bfd *archive_bfd, bfd *abfd)
1416 {
1417   if (filename_per_symbol)
1418     {
1419       if (archive_bfd)
1420         printf ("%s:", bfd_get_filename (archive_bfd));
1421       printf ("%s:", bfd_get_filename (abfd));
1422     }
1423 }
1424
1425 static void
1426 print_symbol_filename_posix (bfd *archive_bfd, bfd *abfd)
1427 {
1428   if (filename_per_symbol)
1429     {
1430       if (archive_bfd)
1431         printf ("%s[%s]: ", bfd_get_filename (archive_bfd),
1432                 bfd_get_filename (abfd));
1433       else
1434         printf ("%s: ", bfd_get_filename (abfd));
1435     }
1436 }
1437 \f
1438 /* Print a symbol value.  */
1439
1440 static void
1441 print_value (bfd *abfd ATTRIBUTE_UNUSED, bfd_vma val)
1442 {
1443   switch (print_width)
1444     {
1445     case 32:
1446       printf (value_format_32bit, (unsigned long) val);
1447       break;
1448
1449     case 64:
1450 #if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
1451       printf (value_format_64bit, val);
1452 #else
1453       /* We have a 64 bit value to print, but the host is only 32 bit.  */
1454       if (print_radix == 16)
1455         bfd_fprintf_vma (abfd, stdout, val);
1456       else
1457         {
1458           char buf[30];
1459           char *s;
1460
1461           s = buf + sizeof buf;
1462           *--s = '\0';
1463           while (val > 0)
1464             {
1465               *--s = (val % print_radix) + '0';
1466               val /= print_radix;
1467             }
1468           while ((buf + sizeof buf - 1) - s < 16)
1469             *--s = '0';
1470           printf ("%s", s);
1471         }
1472 #endif
1473       break;
1474
1475     default:
1476       fatal (_("Print width has not been initialized (%d)"), print_width);
1477       break;
1478     }
1479 }
1480
1481 /* Print a line of information about a symbol.  */
1482
1483 static void
1484 print_symbol_info_bsd (struct extended_symbol_info *info, bfd *abfd)
1485 {
1486   if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1487     {
1488       if (print_width == 64)
1489         printf ("        ");
1490       printf ("        ");
1491     }
1492   else
1493     {
1494       /* Normally we print the value of the symbol.  If we are printing the
1495          size or sorting by size then we print its size, except for the
1496          (weird) special case where both flags are defined, in which case we
1497          print both values.  This conforms to documented behaviour.  */
1498       if (sort_by_size && !print_size)
1499         print_value (abfd, SYM_SIZE (info));
1500       else
1501         print_value (abfd, SYM_VALUE (info));
1502       if (print_size && SYM_SIZE (info))
1503         {
1504           printf (" ");
1505           print_value (abfd, SYM_SIZE (info));
1506         }
1507     }
1508
1509   printf (" %c", SYM_TYPE (info));
1510
1511   if (SYM_TYPE (info) == '-')
1512     {
1513       /* A stab.  */
1514       printf (" ");
1515       printf (other_format, SYM_STAB_OTHER (info));
1516       printf (" ");
1517       printf (desc_format, SYM_STAB_DESC (info));
1518       printf (" %5s", SYM_STAB_NAME (info));
1519     }
1520   print_symname (" %s", SYM_NAME (info), abfd);
1521 }
1522
1523 static void
1524 print_symbol_info_sysv (struct extended_symbol_info *info, bfd *abfd)
1525 {
1526   print_symname ("%-20s|", SYM_NAME (info), abfd);
1527
1528   if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1529     {
1530       if (print_width == 32)
1531         printf ("        ");
1532       else
1533         printf ("                ");
1534     }
1535   else
1536     print_value (abfd, SYM_VALUE (info));
1537
1538   printf ("|   %c  |", SYM_TYPE (info));
1539
1540   if (SYM_TYPE (info) == '-')
1541     {
1542       /* A stab.  */
1543       printf ("%18s|  ", SYM_STAB_NAME (info));         /* (C) Type.  */
1544       printf (desc_format, SYM_STAB_DESC (info));       /* Size.  */
1545       printf ("|     |");                               /* Line, Section.  */
1546     }
1547   else
1548     {
1549       /* Type, Size, Line, Section */
1550       if (info->elfinfo)
1551         printf ("%18s|",
1552                 get_elf_symbol_type (ELF_ST_TYPE (info->elfinfo->internal_elf_sym.st_info)));
1553       else if (info->coffinfo)
1554         printf ("%18s|",
1555                 get_coff_symbol_type (&info->coffinfo->native->u.syment));
1556       else
1557         printf ("                  |");
1558
1559       if (SYM_SIZE (info))
1560         print_value (abfd, SYM_SIZE (info));
1561       else
1562         {
1563           if (print_width == 32)
1564             printf ("        ");
1565           else
1566             printf ("                ");
1567         }
1568
1569       if (info->elfinfo)
1570         printf("|     |%s", info->elfinfo->symbol.section->name);
1571       else if (info->coffinfo)
1572         printf("|     |%s", info->coffinfo->symbol.section->name);
1573       else
1574         printf("|     |");
1575     }
1576 }
1577
1578 static void
1579 print_symbol_info_posix (struct extended_symbol_info *info, bfd *abfd)
1580 {
1581   print_symname ("%s ", SYM_NAME (info), abfd);
1582   printf ("%c ", SYM_TYPE (info));
1583
1584   if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1585     printf ("        ");
1586   else
1587     {
1588       print_value (abfd, SYM_VALUE (info));
1589       printf (" ");
1590       if (SYM_SIZE (info))
1591         print_value (abfd, SYM_SIZE (info));
1592     }
1593 }
1594 \f
1595 int
1596 main (int argc, char **argv)
1597 {
1598   int c;
1599   int retval;
1600
1601 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1602   setlocale (LC_MESSAGES, "");
1603 #endif
1604 #if defined (HAVE_SETLOCALE)
1605   setlocale (LC_CTYPE, "");
1606   setlocale (LC_COLLATE, "");
1607 #endif
1608   bindtextdomain (PACKAGE, LOCALEDIR);
1609   textdomain (PACKAGE);
1610
1611   program_name = *argv;
1612   xmalloc_set_program_name (program_name);
1613   bfd_set_error_program_name (program_name);
1614 #if BFD_SUPPORTS_PLUGINS
1615   bfd_plugin_set_program_name (program_name);
1616 #endif
1617
1618   START_PROGRESS (program_name, 0);
1619
1620   expandargv (&argc, &argv);
1621
1622   bfd_init ();
1623   set_default_bfd_target ();
1624
1625   while ((c = getopt_long (argc, argv, "aABCDef:gHhlnopPrSst:uvVvX:",
1626                            long_options, (int *) 0)) != EOF)
1627     {
1628       switch (c)
1629         {
1630         case 'a':
1631           print_debug_syms = 1;
1632           break;
1633         case 'A':
1634         case 'o':
1635           filename_per_symbol = 1;
1636           break;
1637         case 'B':               /* For MIPS compatibility.  */
1638           set_output_format ("bsd");
1639           break;
1640         case 'C':
1641           do_demangle = 1;
1642           if (optarg != NULL)
1643             {
1644               enum demangling_styles style;
1645
1646               style = cplus_demangle_name_to_style (optarg);
1647               if (style == unknown_demangling)
1648                 fatal (_("unknown demangling style `%s'"),
1649                        optarg);
1650
1651               cplus_demangle_set_style (style);
1652             }
1653           break;
1654         case 'D':
1655           dynamic = 1;
1656           break;
1657         case 'e':
1658           /* Ignored for HP/UX compatibility.  */
1659           break;
1660         case 'f':
1661           set_output_format (optarg);
1662           break;
1663         case 'g':
1664           external_only = 1;
1665           break;
1666         case 'H':
1667         case 'h':
1668           usage (stdout, 0);
1669         case 'l':
1670           line_numbers = 1;
1671           break;
1672         case 'n':
1673         case 'v':
1674           no_sort = 0;
1675           sort_numerically = 1;
1676           sort_by_size = 0;
1677           break;
1678         case 'p':
1679           no_sort = 1;
1680           sort_numerically = 0;
1681           sort_by_size = 0;
1682           break;
1683         case OPTION_SIZE_SORT:
1684           no_sort = 0;
1685           sort_numerically = 0;
1686           sort_by_size = 1;
1687           break;
1688         case 'P':
1689           set_output_format ("posix");
1690           break;
1691         case 'r':
1692           reverse_sort = 1;
1693           break;
1694         case 's':
1695           print_armap = 1;
1696           break;
1697         case 'S':
1698           print_size = 1;
1699           break;
1700         case 't':
1701           set_print_radix (optarg);
1702           break;
1703         case 'u':
1704           undefined_only = 1;
1705           break;
1706         case 'V':
1707           show_version = 1;
1708           break;
1709         case 'X':
1710           /* Ignored for (partial) AIX compatibility.  On AIX, the
1711              argument has values 32, 64, or 32_64, and specifies that
1712              only 32-bit, only 64-bit, or both kinds of objects should
1713              be examined.  The default is 32.  So plain AIX nm on a
1714              library archive with both kinds of objects will ignore
1715              the 64-bit ones.  For GNU nm, the default is and always
1716              has been -X 32_64, and other options are not supported.  */
1717           if (strcmp (optarg, "32_64") != 0)
1718             fatal (_("Only -X 32_64 is supported"));
1719           break;
1720
1721         case OPTION_TARGET:     /* --target */
1722           target = optarg;
1723           break;
1724
1725         case OPTION_PLUGIN:     /* --plugin */
1726 #if BFD_SUPPORTS_PLUGINS
1727           bfd_plugin_set_plugin (optarg);
1728 #else
1729           fatal (_("sorry - this program has been built without plugin support\n"));
1730 #endif
1731           break;
1732
1733         case 0:         /* A long option that just sets a flag.  */
1734           break;
1735
1736         default:
1737           usage (stderr, 1);
1738         }
1739     }
1740
1741   if (show_version)
1742     print_version ("nm");
1743
1744   if (sort_by_size && undefined_only)
1745     {
1746       non_fatal (_("Using the --size-sort and --undefined-only options together"));
1747       non_fatal (_("will produce no output, since undefined symbols have no size."));
1748       return 0;
1749     }
1750
1751   /* OK, all options now parsed.  If no filename specified, do a.out.  */
1752   if (optind == argc)
1753     return !display_file ("a.out");
1754
1755   retval = 0;
1756
1757   if (argc - optind > 1)
1758     filename_per_file = 1;
1759
1760   /* We were given several filenames to do.  */
1761   while (optind < argc)
1762     {
1763       PROGRESS (1);
1764       if (!display_file (argv[optind++]))
1765         retval++;
1766     }
1767
1768   END_PROGRESS (program_name);
1769
1770 #ifdef HAVE_SBRK
1771   if (show_stats)
1772     {
1773       char *lim = (char *) sbrk (0);
1774
1775       non_fatal (_("data size %ld"), (long) (lim - (char *) &environ));
1776     }
1777 #endif
1778
1779   exit (retval);
1780   return retval;
1781 }