contrib/binutils-2.22/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   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           sort_numerically = 1;
1597           break;
1598         case 'p':
1599           no_sort = 1;
1600           break;
1601         case 'P':
1602           set_output_format ("posix");
1603           break;
1604         case 'r':
1605           reverse_sort = 1;
1606           break;
1607         case 's':
1608           print_armap = 1;
1609           break;
1610         case 'S':
1611           print_size = 1;
1612           break;
1613         case 't':
1614           set_print_radix (optarg);
1615           break;
1616         case 'u':
1617           undefined_only = 1;
1618           break;
1619         case 'V':
1620           show_version = 1;
1621           break;
1622         case 'X':
1623           /* Ignored for (partial) AIX compatibility.  On AIX, the
1624              argument has values 32, 64, or 32_64, and specifies that
1625              only 32-bit, only 64-bit, or both kinds of objects should
1626              be examined.  The default is 32.  So plain AIX nm on a
1627              library archive with both kinds of objects will ignore
1628              the 64-bit ones.  For GNU nm, the default is and always
1629              has been -X 32_64, and other options are not supported.  */
1630           if (strcmp (optarg, "32_64") != 0)
1631             fatal (_("Only -X 32_64 is supported"));
1632           break;
1633
1634         case OPTION_TARGET:     /* --target */
1635           target = optarg;
1636           break;
1637
1638         case OPTION_PLUGIN:     /* --plugin */
1639 #if BFD_SUPPORTS_PLUGINS
1640           plugin_target = "plugin";
1641           bfd_plugin_set_plugin (optarg);
1642 #else
1643           fatal (_("sorry - this program has been built without plugin support\n"));
1644 #endif
1645           break;
1646
1647         case 0:         /* A long option that just sets a flag.  */
1648           break;
1649
1650         default:
1651           usage (stderr, 1);
1652         }
1653     }
1654
1655   if (show_version)
1656     print_version ("nm");
1657
1658   if (sort_by_size && undefined_only)
1659     {
1660       non_fatal (_("Using the --size-sort and --undefined-only options together"));
1661       non_fatal (_("will produce no output, since undefined symbols have no size."));
1662       return 0;
1663     }
1664
1665   /* OK, all options now parsed.  If no filename specified, do a.out.  */
1666   if (optind == argc)
1667     return !display_file ("a.out");
1668
1669   retval = 0;
1670
1671   if (argc - optind > 1)
1672     filename_per_file = 1;
1673
1674   /* We were given several filenames to do.  */
1675   while (optind < argc)
1676     {
1677       PROGRESS (1);
1678       if (!display_file (argv[optind++]))
1679         retval++;
1680     }
1681
1682   END_PROGRESS (program_name);
1683
1684 #ifdef HAVE_SBRK
1685   if (show_stats)
1686     {
1687       char *lim = (char *) sbrk (0);
1688
1689       non_fatal (_("data size %ld"), (long) (lim - (char *) &environ));
1690     }
1691 #endif
1692
1693   exit (retval);
1694   return retval;
1695 }