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