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