binutils/nm.c

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