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