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