binutils/nm.c

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