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