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