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