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