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