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   asymbol *synthsyms = NULL;
1098
1099   if (! dynamic)
1100     {
1101       if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
1102         {
1103           non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1104           return;
1105         }
1106     }
1107
1108   symcount = bfd_read_minisymbols (abfd, dynamic, &minisyms, &size);
1109   if (symcount < 0)
1110     {
1111       if (dynamic && bfd_get_error () == bfd_error_no_symbols)
1112         {
1113           non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1114           return;
1115         }
1116
1117       bfd_fatal (bfd_get_filename (abfd));
1118     }
1119
1120   if (symcount == 0)
1121     {
1122       non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1123       return;
1124     }
1125
1126   if (show_synthetic && size == sizeof (asymbol *))
1127     {
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   if (synthsyms)
1205     free (synthsyms);
1206   free (minisyms);
1207   free (symsizes);
1208 }
1209
1210 static void
1211 set_print_width (bfd *file)
1212 {
1213   print_width = bfd_get_arch_size (file);
1214
1215   if (print_width == -1)
1216     {
1217       /* PR binutils/4292
1218          Guess the target's bitsize based on its name.
1219          We assume here than any 64-bit format will include
1220          "64" somewhere in its name.  The only known exception
1221          is the MMO object file format.  */
1222       if (strstr (bfd_get_target (file), "64") != NULL
1223           || strcmp (bfd_get_target (file), "mmo") == 0)
1224         print_width = 64;
1225       else
1226         print_width = 32;
1227     }
1228 }
1229
1230 static void
1231 display_archive (bfd *file)
1232 {
1233   bfd *arfile = NULL;
1234   bfd *last_arfile = NULL;
1235   char **matching;
1236
1237   format->print_archive_filename (bfd_get_filename (file));
1238
1239   if (print_armap)
1240     print_symdef_entry (file);
1241
1242   for (;;)
1243     {
1244       PROGRESS (1);
1245
1246       arfile = bfd_openr_next_archived_file (file, arfile);
1247
1248       if (arfile == NULL)
1249         {
1250           if (bfd_get_error () != bfd_error_no_more_archived_files)
1251             bfd_fatal (bfd_get_filename (file));
1252           break;
1253         }
1254
1255       if (bfd_check_format_matches (arfile, bfd_object, &matching))
1256         {
1257           set_print_width (arfile);
1258           format->print_archive_member (bfd_get_filename (file),
1259                                         bfd_get_filename (arfile));
1260           display_rel_file (arfile, file);
1261         }
1262       else
1263         {
1264           bfd_nonfatal (bfd_get_filename (arfile));
1265           if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1266             {
1267               list_matching_formats (matching);
1268               free (matching);
1269             }
1270         }
1271
1272       if (last_arfile != NULL)
1273         {
1274           bfd_close (last_arfile);
1275           lineno_cache_bfd = NULL;
1276           lineno_cache_rel_bfd = NULL;
1277           if (arfile == last_arfile)
1278             return;
1279         }
1280       last_arfile = arfile;
1281     }
1282
1283   if (last_arfile != NULL)
1284     {
1285       bfd_close (last_arfile);
1286       lineno_cache_bfd = NULL;
1287       lineno_cache_rel_bfd = NULL;
1288     }
1289 }
1290
1291 static bfd_boolean
1292 display_file (char *filename)
1293 {
1294   bfd_boolean retval = TRUE;
1295   bfd *file;
1296   char **matching;
1297
1298   if (get_file_size (filename) < 1)
1299     return FALSE;
1300
1301   file = bfd_openr (filename, target ? target : plugin_target);
1302   if (file == NULL)
1303     {
1304       bfd_nonfatal (filename);
1305       return FALSE;
1306     }
1307
1308   /* If printing line numbers, decompress the debug sections.  */
1309   if (line_numbers)
1310     file->flags |= BFD_DECOMPRESS;
1311
1312   if (bfd_check_format (file, bfd_archive))
1313     {
1314       display_archive (file);
1315     }
1316   else if (bfd_check_format_matches (file, bfd_object, &matching))
1317     {
1318       set_print_width (file);
1319       format->print_object_filename (filename);
1320       display_rel_file (file, NULL);
1321     }
1322   else
1323     {
1324       bfd_nonfatal (filename);
1325       if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1326         {
1327           list_matching_formats (matching);
1328           free (matching);
1329         }
1330       retval = FALSE;
1331     }
1332
1333   if (!bfd_close (file))
1334     bfd_fatal (filename);
1335
1336   lineno_cache_bfd = NULL;
1337   lineno_cache_rel_bfd = NULL;
1338
1339   return retval;
1340 }
1341 \f
1342 /* The following 3 groups of functions are called unconditionally,
1343    once at the start of processing each file of the appropriate type.
1344    They should check `filename_per_file' and `filename_per_symbol',
1345    as appropriate for their output format, to determine whether to
1346    print anything.  */
1347 \f
1348 /* Print the name of an object file given on the command line.  */
1349
1350 static void
1351 print_object_filename_bsd (char *filename)
1352 {
1353   if (filename_per_file && !filename_per_symbol)
1354     printf ("\n%s:\n", filename);
1355 }
1356
1357 static void
1358 print_object_filename_sysv (char *filename)
1359 {
1360   if (undefined_only)
1361     printf (_("\n\nUndefined symbols from %s:\n\n"), filename);
1362   else
1363     printf (_("\n\nSymbols from %s:\n\n"), filename);
1364   if (print_width == 32)
1365     printf (_("\
1366 Name                  Value   Class        Type         Size     Line  Section\n\n"));
1367   else
1368     printf (_("\
1369 Name                  Value           Class        Type         Size             Line  Section\n\n"));
1370 }
1371
1372 static void
1373 print_object_filename_posix (char *filename)
1374 {
1375   if (filename_per_file && !filename_per_symbol)
1376     printf ("%s:\n", filename);
1377 }
1378 \f
1379 /* Print the name of an archive file given on the command line.  */
1380
1381 static void
1382 print_archive_filename_bsd (char *filename)
1383 {
1384   if (filename_per_file)
1385     printf ("\n%s:\n", filename);
1386 }
1387
1388 static void
1389 print_archive_filename_sysv (char *filename ATTRIBUTE_UNUSED)
1390 {
1391 }
1392
1393 static void
1394 print_archive_filename_posix (char *filename ATTRIBUTE_UNUSED)
1395 {
1396 }
1397 \f
1398 /* Print the name of an archive member file.  */
1399
1400 static void
1401 print_archive_member_bsd (char *archive ATTRIBUTE_UNUSED,
1402                           const char *filename)
1403 {
1404   if (!filename_per_symbol)
1405     printf ("\n%s:\n", filename);
1406 }
1407
1408 static void
1409 print_archive_member_sysv (char *archive, const char *filename)
1410 {
1411   if (undefined_only)
1412     printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive, filename);
1413   else
1414     printf (_("\n\nSymbols from %s[%s]:\n\n"), archive, filename);
1415   if (print_width == 32)
1416     printf (_("\
1417 Name                  Value   Class        Type         Size     Line  Section\n\n"));
1418   else
1419     printf (_("\
1420 Name                  Value           Class        Type         Size             Line  Section\n\n"));
1421 }
1422
1423 static void
1424 print_archive_member_posix (char *archive, const char *filename)
1425 {
1426   if (!filename_per_symbol)
1427     printf ("%s[%s]:\n", archive, filename);
1428 }
1429 \f
1430 /* Print the name of the file (and archive, if there is one)
1431    containing a symbol.  */
1432
1433 static void
1434 print_symbol_filename_bsd (bfd *archive_bfd, bfd *abfd)
1435 {
1436   if (filename_per_symbol)
1437     {
1438       if (archive_bfd)
1439         printf ("%s:", bfd_get_filename (archive_bfd));
1440       printf ("%s:", bfd_get_filename (abfd));
1441     }
1442 }
1443
1444 static void
1445 print_symbol_filename_sysv (bfd *archive_bfd, bfd *abfd)
1446 {
1447   if (filename_per_symbol)
1448     {
1449       if (archive_bfd)
1450         printf ("%s:", bfd_get_filename (archive_bfd));
1451       printf ("%s:", bfd_get_filename (abfd));
1452     }
1453 }
1454
1455 static void
1456 print_symbol_filename_posix (bfd *archive_bfd, bfd *abfd)
1457 {
1458   if (filename_per_symbol)
1459     {
1460       if (archive_bfd)
1461         printf ("%s[%s]: ", bfd_get_filename (archive_bfd),
1462                 bfd_get_filename (abfd));
1463       else
1464         printf ("%s: ", bfd_get_filename (abfd));
1465     }
1466 }
1467 \f
1468 /* Print a symbol value.  */
1469
1470 static void
1471 print_value (bfd *abfd ATTRIBUTE_UNUSED, bfd_vma val)
1472 {
1473   switch (print_width)
1474     {
1475     case 32:
1476       printf (value_format_32bit, (unsigned long) val);
1477       break;
1478
1479     case 64:
1480 #if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
1481       printf (value_format_64bit, val);
1482 #else
1483       /* We have a 64 bit value to print, but the host is only 32 bit.  */
1484       if (print_radix == 16)
1485         bfd_fprintf_vma (abfd, stdout, val);
1486       else
1487         {
1488           char buf[30];
1489           char *s;
1490
1491           s = buf + sizeof buf;
1492           *--s = '\0';
1493           while (val > 0)
1494             {
1495               *--s = (val % print_radix) + '0';
1496               val /= print_radix;
1497             }
1498           while ((buf + sizeof buf - 1) - s < 16)
1499             *--s = '0';
1500           printf ("%s", s);
1501         }
1502 #endif
1503       break;
1504
1505     default:
1506       fatal (_("Print width has not been initialized (%d)"), print_width);
1507       break;
1508     }
1509 }
1510
1511 /* Print a line of information about a symbol.  */
1512
1513 static void
1514 print_symbol_info_bsd (struct extended_symbol_info *info, bfd *abfd)
1515 {
1516   if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1517     {
1518       if (print_width == 64)
1519         printf ("        ");
1520       printf ("        ");
1521     }
1522   else
1523     {
1524       /* Normally we print the value of the symbol.  If we are printing the
1525          size or sorting by size then we print its size, except for the
1526          (weird) special case where both flags are defined, in which case we
1527          print both values.  This conforms to documented behaviour.  */
1528       if (sort_by_size && !print_size)
1529         print_value (abfd, SYM_SIZE (info));
1530       else
1531         print_value (abfd, SYM_VALUE (info));
1532       if (print_size && SYM_SIZE (info))
1533         {
1534           printf (" ");
1535           print_value (abfd, SYM_SIZE (info));
1536         }
1537     }
1538
1539   printf (" %c", SYM_TYPE (info));
1540
1541   if (SYM_TYPE (info) == '-')
1542     {
1543       /* A stab.  */
1544       printf (" ");
1545       printf (other_format, SYM_STAB_OTHER (info));
1546       printf (" ");
1547       printf (desc_format, SYM_STAB_DESC (info));
1548       printf (" %5s", SYM_STAB_NAME (info));
1549     }
1550   print_symname (" %s", SYM_NAME (info), abfd);
1551 }
1552
1553 static void
1554 print_symbol_info_sysv (struct extended_symbol_info *info, bfd *abfd)
1555 {
1556   print_symname ("%-20s|", SYM_NAME (info), abfd);
1557
1558   if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1559     {
1560       if (print_width == 32)
1561         printf ("        ");
1562       else
1563         printf ("                ");
1564     }
1565   else
1566     print_value (abfd, SYM_VALUE (info));
1567
1568   printf ("|   %c  |", SYM_TYPE (info));
1569
1570   if (SYM_TYPE (info) == '-')
1571     {
1572       /* A stab.  */
1573       printf ("%18s|  ", SYM_STAB_NAME (info));         /* (C) Type.  */
1574       printf (desc_format, SYM_STAB_DESC (info));       /* Size.  */
1575       printf ("|     |");                               /* Line, Section.  */
1576     }
1577   else
1578     {
1579       /* Type, Size, Line, Section */
1580       if (info->elfinfo)
1581         printf ("%18s|",
1582                 get_elf_symbol_type (ELF_ST_TYPE (info->elfinfo->internal_elf_sym.st_info)));
1583       else if (info->coffinfo)
1584         printf ("%18s|",
1585                 get_coff_symbol_type (&info->coffinfo->native->u.syment));
1586       else
1587         printf ("                  |");
1588
1589       if (SYM_SIZE (info))
1590         print_value (abfd, SYM_SIZE (info));
1591       else
1592         {
1593           if (print_width == 32)
1594             printf ("        ");
1595           else
1596             printf ("                ");
1597         }
1598
1599       if (info->elfinfo)
1600         printf("|     |%s", info->elfinfo->symbol.section->name);
1601       else if (info->coffinfo)
1602         printf("|     |%s", info->coffinfo->symbol.section->name);
1603       else
1604         printf("|     |");
1605     }
1606 }
1607
1608 static void
1609 print_symbol_info_posix (struct extended_symbol_info *info, bfd *abfd)
1610 {
1611   print_symname ("%s ", SYM_NAME (info), abfd);
1612   printf ("%c ", SYM_TYPE (info));
1613
1614   if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1615     printf ("        ");
1616   else
1617     {
1618       print_value (abfd, SYM_VALUE (info));
1619       printf (" ");
1620       if (SYM_SIZE (info))
1621         print_value (abfd, SYM_SIZE (info));
1622     }
1623 }
1624 \f
1625 int
1626 main (int argc, char **argv)
1627 {
1628   int c;
1629   int retval;
1630
1631 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1632   setlocale (LC_MESSAGES, "");
1633 #endif
1634 #if defined (HAVE_SETLOCALE)
1635   setlocale (LC_CTYPE, "");
1636   setlocale (LC_COLLATE, "");
1637 #endif
1638   bindtextdomain (PACKAGE, LOCALEDIR);
1639   textdomain (PACKAGE);
1640
1641   program_name = *argv;
1642   xmalloc_set_program_name (program_name);
1643   bfd_set_error_program_name (program_name);
1644 #if BFD_SUPPORTS_PLUGINS
1645   bfd_plugin_set_program_name (program_name);
1646 #endif
1647
1648   START_PROGRESS (program_name, 0);
1649
1650   expandargv (&argc, &argv);
1651
1652   bfd_init ();
1653   set_default_bfd_target ();
1654
1655   while ((c = getopt_long (argc, argv, "aABCDef:gHhlnopPrSst:uvVvX:",
1656                            long_options, (int *) 0)) != EOF)
1657     {
1658       switch (c)
1659         {
1660         case 'a':
1661           print_debug_syms = 1;
1662           break;
1663         case 'A':
1664         case 'o':
1665           filename_per_symbol = 1;
1666           break;
1667         case 'B':               /* For MIPS compatibility.  */
1668           set_output_format ("bsd");
1669           break;
1670         case 'C':
1671           do_demangle = 1;
1672           if (optarg != NULL)
1673             {
1674               enum demangling_styles style;
1675
1676               style = cplus_demangle_name_to_style (optarg);
1677               if (style == unknown_demangling)
1678                 fatal (_("unknown demangling style `%s'"),
1679                        optarg);
1680
1681               cplus_demangle_set_style (style);
1682             }
1683           break;
1684         case 'D':
1685           dynamic = 1;
1686           break;
1687         case 'e':
1688           /* Ignored for HP/UX compatibility.  */
1689           break;
1690         case 'f':
1691           set_output_format (optarg);
1692           break;
1693         case 'g':
1694           external_only = 1;
1695           break;
1696         case 'H':
1697         case 'h':
1698           usage (stdout, 0);
1699         case 'l':
1700           line_numbers = 1;
1701           break;
1702         case 'n':
1703         case 'v':
1704           no_sort = 0;
1705           sort_numerically = 1;
1706           sort_by_size = 0;
1707           break;
1708         case 'p':
1709           no_sort = 1;
1710           sort_numerically = 0;
1711           sort_by_size = 0;
1712           break;
1713         case OPTION_SIZE_SORT:
1714           no_sort = 0;
1715           sort_numerically = 0;
1716           sort_by_size = 1;
1717           break;
1718         case 'P':
1719           set_output_format ("posix");
1720           break;
1721         case 'r':
1722           reverse_sort = 1;
1723           break;
1724         case 's':
1725           print_armap = 1;
1726           break;
1727         case 'S':
1728           print_size = 1;
1729           break;
1730         case 't':
1731           set_print_radix (optarg);
1732           break;
1733         case 'u':
1734           undefined_only = 1;
1735           break;
1736         case 'V':
1737           show_version = 1;
1738           break;
1739         case 'X':
1740           /* Ignored for (partial) AIX compatibility.  On AIX, the
1741              argument has values 32, 64, or 32_64, and specifies that
1742              only 32-bit, only 64-bit, or both kinds of objects should
1743              be examined.  The default is 32.  So plain AIX nm on a
1744              library archive with both kinds of objects will ignore
1745              the 64-bit ones.  For GNU nm, the default is and always
1746              has been -X 32_64, and other options are not supported.  */
1747           if (strcmp (optarg, "32_64") != 0)
1748             fatal (_("Only -X 32_64 is supported"));
1749           break;
1750
1751         case OPTION_TARGET:     /* --target */
1752           target = optarg;
1753           break;
1754
1755         case OPTION_PLUGIN:     /* --plugin */
1756 #if BFD_SUPPORTS_PLUGINS
1757           bfd_plugin_set_plugin (optarg);
1758 #else
1759           fatal (_("sorry - this program has been built without plugin support\n"));
1760 #endif
1761           break;
1762
1763         case 0:         /* A long option that just sets a flag.  */
1764           break;
1765
1766         default:
1767           usage (stderr, 1);
1768         }
1769     }
1770
1771   if (show_version)
1772     print_version ("nm");
1773
1774   if (sort_by_size && undefined_only)
1775     {
1776       non_fatal (_("Using the --size-sort and --undefined-only options together"));
1777       non_fatal (_("will produce no output, since undefined symbols have no size."));
1778       return 0;
1779     }
1780
1781   /* OK, all options now parsed.  If no filename specified, do a.out.  */
1782   if (optind == argc)
1783     return !display_file ("a.out");
1784
1785   retval = 0;
1786
1787   if (argc - optind > 1)
1788     filename_per_file = 1;
1789
1790   /* We were given several filenames to do.  */
1791   while (optind < argc)
1792     {
1793       PROGRESS (1);
1794       if (!display_file (argv[optind++]))
1795         retval++;
1796     }
1797
1798   END_PROGRESS (program_name);
1799
1800   exit (retval);
1801   return retval;
1802 }