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