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