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