binutils/nm.c

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