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