contrib/binutils-2.21/binutils/nm.c

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