objdump.c revision 78828
1/* objdump.c -- dump information about an object file. 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 3 2000, 2001 4 Free Software Foundation, Inc. 5 6This file is part of GNU Binutils. 7 8This program is free software; you can redistribute it and/or modify 9it under the terms of the GNU General Public License as published by 10the Free Software Foundation; either version 2, or (at your option) 11any later version. 12 13This program is distributed in the hope that it will be useful, 14but WITHOUT ANY WARRANTY; without even the implied warranty of 15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16GNU General Public License for more details. 17 18You should have received a copy of the GNU General Public License 19along with this program; if not, write to the Free Software 20Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 21 22#include "bfd.h" 23#include "getopt.h" 24#include "progress.h" 25#include "bucomm.h" 26#include <ctype.h> 27#include "dis-asm.h" 28#include "libiberty.h" 29#include "demangle.h" 30#include "debug.h" 31#include "budbg.h" 32 33/* Internal headers for the ELF .stab-dump code - sorry. */ 34#define BYTES_IN_WORD 32 35#include "aout/aout64.h" 36 37#ifdef NEED_DECLARATION_FPRINTF 38/* This is needed by INIT_DISASSEMBLE_INFO. */ 39extern int fprintf PARAMS ((FILE *, const char *, ...)); 40#endif 41 42/* Exit status. */ 43static int exit_status = 0; 44 45static char *default_target = NULL; /* default at runtime */ 46 47static int show_version = 0; /* show the version number */ 48static int dump_section_contents; /* -s */ 49static int dump_section_headers; /* -h */ 50static boolean dump_file_header; /* -f */ 51static int dump_symtab; /* -t */ 52static int dump_dynamic_symtab; /* -T */ 53static int dump_reloc_info; /* -r */ 54static int dump_dynamic_reloc_info; /* -R */ 55static int dump_ar_hdrs; /* -a */ 56static int dump_private_headers; /* -p */ 57static int prefix_addresses; /* --prefix-addresses */ 58static int with_line_numbers; /* -l */ 59static boolean with_source_code; /* -S */ 60static int show_raw_insn; /* --show-raw-insn */ 61static int dump_stab_section_info; /* --stabs */ 62static int do_demangle; /* -C, --demangle */ 63static boolean disassemble; /* -d */ 64static boolean disassemble_all; /* -D */ 65static int disassemble_zeroes; /* --disassemble-zeroes */ 66static boolean formats_info; /* -i */ 67static char *only; /* -j secname */ 68static int wide_output; /* -w */ 69static bfd_vma start_address = (bfd_vma) -1; /* --start-address */ 70static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */ 71static int dump_debugging; /* --debugging */ 72static bfd_vma adjust_section_vma = 0; /* --adjust-vma */ 73static int file_start_context = 0; /* --file-start-context */ 74 75/* Extra info to pass to the disassembler address printing function. */ 76struct objdump_disasm_info { 77 bfd *abfd; 78 asection *sec; 79 boolean require_sec; 80}; 81 82/* Architecture to disassemble for, or default if NULL. */ 83static char *machine = (char *) NULL; 84 85/* Target specific options to the disassembler. */ 86static char *disassembler_options = (char *) NULL; 87 88/* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */ 89static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN; 90 91/* The symbol table. */ 92static asymbol **syms; 93 94/* Number of symbols in `syms'. */ 95static long symcount = 0; 96 97/* The sorted symbol table. */ 98static asymbol **sorted_syms; 99 100/* Number of symbols in `sorted_syms'. */ 101static long sorted_symcount = 0; 102 103/* The dynamic symbol table. */ 104static asymbol **dynsyms; 105 106/* Number of symbols in `dynsyms'. */ 107static long dynsymcount = 0; 108 109/* Static declarations. */ 110 111static void 112usage PARAMS ((FILE *, int)); 113 114static void 115nonfatal PARAMS ((const char *)); 116 117static void 118display_file PARAMS ((char *filename, char *target)); 119 120static void 121dump_section_header PARAMS ((bfd *, asection *, PTR)); 122 123static void 124dump_headers PARAMS ((bfd *)); 125 126static void 127dump_data PARAMS ((bfd *abfd)); 128 129static void 130dump_relocs PARAMS ((bfd *abfd)); 131 132static void 133dump_dynamic_relocs PARAMS ((bfd * abfd)); 134 135static void 136dump_reloc_set PARAMS ((bfd *, asection *, arelent **, long)); 137 138static void 139dump_symbols PARAMS ((bfd *abfd, boolean dynamic)); 140 141static void 142dump_bfd_header PARAMS ((bfd *)); 143 144static void 145dump_bfd_private_header PARAMS ((bfd *)); 146 147static void 148display_bfd PARAMS ((bfd *abfd)); 149 150static void 151display_target_list PARAMS ((void)); 152 153static void 154display_info_table PARAMS ((int, int)); 155 156static void 157display_target_tables PARAMS ((void)); 158 159static void 160display_info PARAMS ((void)); 161 162static void 163objdump_print_value PARAMS ((bfd_vma, struct disassemble_info *, boolean)); 164 165static void 166objdump_print_symname PARAMS ((bfd *, struct disassemble_info *, asymbol *)); 167 168static asymbol * 169find_symbol_for_address PARAMS ((bfd *, asection *, bfd_vma, boolean, long *)); 170 171static void 172objdump_print_addr_with_sym PARAMS ((bfd *, asection *, asymbol *, bfd_vma, 173 struct disassemble_info *, boolean)); 174 175static void 176objdump_print_addr PARAMS ((bfd_vma, struct disassemble_info *, boolean)); 177 178static void 179objdump_print_address PARAMS ((bfd_vma, struct disassemble_info *)); 180 181static void 182show_line PARAMS ((bfd *, asection *, bfd_vma)); 183 184static void 185disassemble_bytes PARAMS ((struct disassemble_info *, disassembler_ftype, 186 boolean, bfd_byte *, bfd_vma, bfd_vma, 187 arelent ***, arelent **)); 188 189static void 190disassemble_data PARAMS ((bfd *)); 191 192static const char * 193endian_string PARAMS ((enum bfd_endian)); 194 195static asymbol ** 196slurp_symtab PARAMS ((bfd *)); 197 198static asymbol ** 199slurp_dynamic_symtab PARAMS ((bfd *)); 200 201static long 202remove_useless_symbols PARAMS ((asymbol **, long)); 203 204static int 205compare_symbols PARAMS ((const PTR, const PTR)); 206 207static int 208compare_relocs PARAMS ((const PTR, const PTR)); 209 210static void 211dump_stabs PARAMS ((bfd *)); 212 213static boolean 214read_section_stabs PARAMS ((bfd *, const char *, const char *)); 215 216static void 217print_section_stabs PARAMS ((bfd *, const char *, const char *)); 218 219static void 220usage (stream, status) 221 FILE *stream; 222 int status; 223{ 224 fprintf (stream, _("Usage: %s OPTION... FILE...\n"), program_name); 225 fprintf (stream, _("Display information from object FILE.\n")); 226 fprintf (stream, _("\n At least one of the following switches must be given:\n")); 227 fprintf (stream, _("\ 228 -a, --archive-headers Display archive header information\n\ 229 -f, --file-headers Display the contents of the overall file header\n\ 230 -p, --private-headers Display object format specific file header contents\n\ 231 -h, --[section-]headers Display the contents of the section headers\n\ 232 -x, --all-headers Display the contents of all headers\n\ 233 -d, --disassemble Display assembler contents of executable sections\n\ 234 -D, --disassemble-all Display assembler contents of all sections\n\ 235 -S, --source Intermix source code with disassembly\n\ 236 -s, --full-contents Display the full contents of all sections requested\n\ 237 -g, --debugging Display debug information in object file\n\ 238 -G, --stabs Display (in raw form) any STABS info in the file\n\ 239 -t, --syms Display the contents of the symbol table(s)\n\ 240 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\ 241 -r, --reloc Display the relocation entries in the file\n\ 242 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\ 243 -V, --version Display this program's version number\n\ 244 -i, --info List object formats and architectures supported\n\ 245 -H, --help Display this information\n\ 246")); 247 if (status != 2) 248 { 249 fprintf (stream, _("\n The following switches are optional:\n")); 250 fprintf (stream, _("\ 251 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\ 252 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\ 253 -j, --section=NAME Only display information for section NAME\n\ 254 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\ 255 -EB --endian=big Assume big endian format when disassembling\n\ 256 -EL --endian=little Assume little endian format when disassembling\n\ 257 --file-start-context Include context from start of file (with -S)\n\ 258 -l, --line-numbers Include line numbers and filenames in output\n\ 259 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\ 260 The STYLE, if specified, can be `auto', 'gnu',\n\ 261 'lucid', 'arm', 'hp', 'edg', or 'gnu-new-abi'\n\ 262 -w, --wide Format output for more than 80 columns\n\ 263 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\ 264 --start-address=ADDR Only process data whoes address is >= ADDR\n\ 265 --stop-address=ADDR Only process data whoes address is <= ADDR\n\ 266 --prefix-addresses Print complete address alongside disassembly\n\ 267 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\ 268 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\ 269\n")); 270 list_supported_targets (program_name, stream); 271 272 disassembler_usage (stream); 273 } 274 if (status == 0) 275 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO); 276 exit (status); 277} 278 279/* 150 isn't special; it's just an arbitrary non-ASCII char value. */ 280 281#define OPTION_ENDIAN (150) 282#define OPTION_START_ADDRESS (OPTION_ENDIAN + 1) 283#define OPTION_STOP_ADDRESS (OPTION_START_ADDRESS + 1) 284#define OPTION_ADJUST_VMA (OPTION_STOP_ADDRESS + 1) 285 286static struct option long_options[]= 287{ 288 {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA}, 289 {"all-headers", no_argument, NULL, 'x'}, 290 {"private-headers", no_argument, NULL, 'p'}, 291 {"architecture", required_argument, NULL, 'm'}, 292 {"archive-headers", no_argument, NULL, 'a'}, 293 {"debugging", no_argument, NULL, 'g'}, 294 {"demangle", optional_argument, NULL, 'C'}, 295 {"disassemble", no_argument, NULL, 'd'}, 296 {"disassemble-all", no_argument, NULL, 'D'}, 297 {"disassembler-options", required_argument, NULL, 'M'}, 298 {"disassemble-zeroes", no_argument, NULL, 'z'}, 299 {"dynamic-reloc", no_argument, NULL, 'R'}, 300 {"dynamic-syms", no_argument, NULL, 'T'}, 301 {"endian", required_argument, NULL, OPTION_ENDIAN}, 302 {"file-headers", no_argument, NULL, 'f'}, 303 {"file-start-context", no_argument, &file_start_context, 1}, 304 {"full-contents", no_argument, NULL, 's'}, 305 {"headers", no_argument, NULL, 'h'}, 306 {"help", no_argument, NULL, 'H'}, 307 {"info", no_argument, NULL, 'i'}, 308 {"line-numbers", no_argument, NULL, 'l'}, 309 {"no-show-raw-insn", no_argument, &show_raw_insn, -1}, 310 {"prefix-addresses", no_argument, &prefix_addresses, 1}, 311 {"reloc", no_argument, NULL, 'r'}, 312 {"section", required_argument, NULL, 'j'}, 313 {"section-headers", no_argument, NULL, 'h'}, 314 {"show-raw-insn", no_argument, &show_raw_insn, 1}, 315 {"source", no_argument, NULL, 'S'}, 316 {"stabs", no_argument, NULL, 'G'}, 317 {"start-address", required_argument, NULL, OPTION_START_ADDRESS}, 318 {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS}, 319 {"syms", no_argument, NULL, 't'}, 320 {"target", required_argument, NULL, 'b'}, 321 {"version", no_argument, NULL, 'V'}, 322 {"wide", no_argument, NULL, 'w'}, 323 {0, no_argument, 0, 0} 324}; 325 326static void 327nonfatal (msg) 328 const char *msg; 329{ 330 bfd_nonfatal (msg); 331 exit_status = 1; 332} 333 334static void 335dump_section_header (abfd, section, ignored) 336 bfd *abfd ATTRIBUTE_UNUSED; 337 asection *section; 338 PTR ignored ATTRIBUTE_UNUSED; 339{ 340 char *comma = ""; 341 unsigned int opb = bfd_octets_per_byte (abfd); 342 343 printf ("%3d %-13s %08lx ", section->index, 344 bfd_get_section_name (abfd, section), 345 (unsigned long) bfd_section_size (abfd, section) / opb); 346 printf_vma (bfd_get_section_vma (abfd, section)); 347 printf (" "); 348 printf_vma (section->lma); 349 printf (" %08lx 2**%u", section->filepos, 350 bfd_get_section_alignment (abfd, section)); 351 if (! wide_output) 352 printf ("\n "); 353 printf (" "); 354 355#define PF(x, y) \ 356 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; } 357 358 PF (SEC_HAS_CONTENTS, "CONTENTS"); 359 PF (SEC_ALLOC, "ALLOC"); 360 PF (SEC_CONSTRUCTOR, "CONSTRUCTOR"); 361 PF (SEC_CONSTRUCTOR_TEXT, "CONSTRUCTOR TEXT"); 362 PF (SEC_CONSTRUCTOR_DATA, "CONSTRUCTOR DATA"); 363 PF (SEC_CONSTRUCTOR_BSS, "CONSTRUCTOR BSS"); 364 PF (SEC_LOAD, "LOAD"); 365 PF (SEC_RELOC, "RELOC"); 366#ifdef SEC_BALIGN 367 PF (SEC_BALIGN, "BALIGN"); 368#endif 369 PF (SEC_READONLY, "READONLY"); 370 PF (SEC_CODE, "CODE"); 371 PF (SEC_DATA, "DATA"); 372 PF (SEC_ROM, "ROM"); 373 PF (SEC_DEBUGGING, "DEBUGGING"); 374 PF (SEC_NEVER_LOAD, "NEVER_LOAD"); 375 PF (SEC_EXCLUDE, "EXCLUDE"); 376 PF (SEC_SORT_ENTRIES, "SORT_ENTRIES"); 377 PF (SEC_BLOCK, "BLOCK"); 378 PF (SEC_CLINK, "CLINK"); 379 PF (SEC_SMALL_DATA, "SMALL_DATA"); 380 PF (SEC_SHARED, "SHARED"); 381 382 if ((section->flags & SEC_LINK_ONCE) != 0) 383 { 384 const char *ls; 385 386 switch (section->flags & SEC_LINK_DUPLICATES) 387 { 388 default: 389 abort (); 390 case SEC_LINK_DUPLICATES_DISCARD: 391 ls = "LINK_ONCE_DISCARD"; 392 break; 393 case SEC_LINK_DUPLICATES_ONE_ONLY: 394 ls = "LINK_ONCE_ONE_ONLY"; 395 break; 396 case SEC_LINK_DUPLICATES_SAME_SIZE: 397 ls = "LINK_ONCE_SAME_SIZE"; 398 break; 399 case SEC_LINK_DUPLICATES_SAME_CONTENTS: 400 ls = "LINK_ONCE_SAME_CONTENTS"; 401 break; 402 } 403 printf ("%s%s", comma, ls); 404 405 if (section->comdat != NULL) 406 printf (" (COMDAT %s %ld)", section->comdat->name, 407 section->comdat->symbol); 408 409 comma = ", "; 410 } 411 412 printf ("\n"); 413#undef PF 414} 415 416static void 417dump_headers (abfd) 418 bfd *abfd; 419{ 420 printf (_("Sections:\n")); 421 422#ifndef BFD64 423 printf (_("Idx Name Size VMA LMA File off Algn")); 424#else 425 printf (_("Idx Name Size VMA LMA File off Algn")); 426#endif 427 428 if (wide_output) 429 printf (_(" Flags")); 430 printf ("\n"); 431 432 bfd_map_over_sections (abfd, dump_section_header, (PTR) NULL); 433} 434 435static asymbol ** 436slurp_symtab (abfd) 437 bfd *abfd; 438{ 439 asymbol **sy = (asymbol **) NULL; 440 long storage; 441 442 if (!(bfd_get_file_flags (abfd) & HAS_SYMS)) 443 { 444 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd)); 445 symcount = 0; 446 return NULL; 447 } 448 449 storage = bfd_get_symtab_upper_bound (abfd); 450 if (storage < 0) 451 bfd_fatal (bfd_get_filename (abfd)); 452 453 if (storage) 454 { 455 sy = (asymbol **) xmalloc (storage); 456 } 457 symcount = bfd_canonicalize_symtab (abfd, sy); 458 if (symcount < 0) 459 bfd_fatal (bfd_get_filename (abfd)); 460 if (symcount == 0) 461 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd)); 462 return sy; 463} 464 465/* Read in the dynamic symbols. */ 466 467static asymbol ** 468slurp_dynamic_symtab (abfd) 469 bfd *abfd; 470{ 471 asymbol **sy = (asymbol **) NULL; 472 long storage; 473 474 storage = bfd_get_dynamic_symtab_upper_bound (abfd); 475 if (storage < 0) 476 { 477 if (!(bfd_get_file_flags (abfd) & DYNAMIC)) 478 { 479 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd)); 480 dynsymcount = 0; 481 return NULL; 482 } 483 484 bfd_fatal (bfd_get_filename (abfd)); 485 } 486 487 if (storage) 488 { 489 sy = (asymbol **) xmalloc (storage); 490 } 491 dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy); 492 if (dynsymcount < 0) 493 bfd_fatal (bfd_get_filename (abfd)); 494 if (dynsymcount == 0) 495 non_fatal (_("%s: No dynamic symbols"), bfd_get_filename (abfd)); 496 return sy; 497} 498 499/* Filter out (in place) symbols that are useless for disassembly. 500 COUNT is the number of elements in SYMBOLS. 501 Return the number of useful symbols. */ 502 503static long 504remove_useless_symbols (symbols, count) 505 asymbol **symbols; 506 long count; 507{ 508 register asymbol **in_ptr = symbols, **out_ptr = symbols; 509 510 while (--count >= 0) 511 { 512 asymbol *sym = *in_ptr++; 513 514 if (sym->name == NULL || sym->name[0] == '\0') 515 continue; 516 if (sym->flags & (BSF_DEBUGGING)) 517 continue; 518 if (bfd_is_und_section (sym->section) 519 || bfd_is_com_section (sym->section)) 520 continue; 521 522 *out_ptr++ = sym; 523 } 524 return out_ptr - symbols; 525} 526 527/* Sort symbols into value order. */ 528 529static int 530compare_symbols (ap, bp) 531 const PTR ap; 532 const PTR bp; 533{ 534 const asymbol *a = *(const asymbol **)ap; 535 const asymbol *b = *(const asymbol **)bp; 536 const char *an, *bn; 537 size_t anl, bnl; 538 boolean af, bf; 539 flagword aflags, bflags; 540 541 if (bfd_asymbol_value (a) > bfd_asymbol_value (b)) 542 return 1; 543 else if (bfd_asymbol_value (a) < bfd_asymbol_value (b)) 544 return -1; 545 546 if (a->section > b->section) 547 return 1; 548 else if (a->section < b->section) 549 return -1; 550 551 an = bfd_asymbol_name (a); 552 bn = bfd_asymbol_name (b); 553 anl = strlen (an); 554 bnl = strlen (bn); 555 556 /* The symbols gnu_compiled and gcc2_compiled convey no real 557 information, so put them after other symbols with the same value. */ 558 559 af = (strstr (an, "gnu_compiled") != NULL 560 || strstr (an, "gcc2_compiled") != NULL); 561 bf = (strstr (bn, "gnu_compiled") != NULL 562 || strstr (bn, "gcc2_compiled") != NULL); 563 564 if (af && ! bf) 565 return 1; 566 if (! af && bf) 567 return -1; 568 569 /* We use a heuristic for the file name, to try to sort it after 570 more useful symbols. It may not work on non Unix systems, but it 571 doesn't really matter; the only difference is precisely which 572 symbol names get printed. */ 573 574#define file_symbol(s, sn, snl) \ 575 (((s)->flags & BSF_FILE) != 0 \ 576 || ((sn)[(snl) - 2] == '.' \ 577 && ((sn)[(snl) - 1] == 'o' \ 578 || (sn)[(snl) - 1] == 'a'))) 579 580 af = file_symbol (a, an, anl); 581 bf = file_symbol (b, bn, bnl); 582 583 if (af && ! bf) 584 return 1; 585 if (! af && bf) 586 return -1; 587 588 /* Try to sort global symbols before local symbols before function 589 symbols before debugging symbols. */ 590 591 aflags = a->flags; 592 bflags = b->flags; 593 594 if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING)) 595 { 596 if ((aflags & BSF_DEBUGGING) != 0) 597 return 1; 598 else 599 return -1; 600 } 601 if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION)) 602 { 603 if ((aflags & BSF_FUNCTION) != 0) 604 return -1; 605 else 606 return 1; 607 } 608 if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL)) 609 { 610 if ((aflags & BSF_LOCAL) != 0) 611 return 1; 612 else 613 return -1; 614 } 615 if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL)) 616 { 617 if ((aflags & BSF_GLOBAL) != 0) 618 return -1; 619 else 620 return 1; 621 } 622 623 /* Symbols that start with '.' might be section names, so sort them 624 after symbols that don't start with '.'. */ 625 if (an[0] == '.' && bn[0] != '.') 626 return 1; 627 if (an[0] != '.' && bn[0] == '.') 628 return -1; 629 630 /* Finally, if we can't distinguish them in any other way, try to 631 get consistent results by sorting the symbols by name. */ 632 return strcmp (an, bn); 633} 634 635/* Sort relocs into address order. */ 636 637static int 638compare_relocs (ap, bp) 639 const PTR ap; 640 const PTR bp; 641{ 642 const arelent *a = *(const arelent **)ap; 643 const arelent *b = *(const arelent **)bp; 644 645 if (a->address > b->address) 646 return 1; 647 else if (a->address < b->address) 648 return -1; 649 650 /* So that associated relocations tied to the same address show up 651 in the correct order, we don't do any further sorting. */ 652 if (a > b) 653 return 1; 654 else if (a < b) 655 return -1; 656 else 657 return 0; 658} 659 660/* Print VMA to STREAM. If SKIP_ZEROES is true, omit leading zeroes. */ 661 662static void 663objdump_print_value (vma, info, skip_zeroes) 664 bfd_vma vma; 665 struct disassemble_info *info; 666 boolean skip_zeroes; 667{ 668 char buf[30]; 669 char *p; 670 671 sprintf_vma (buf, vma); 672 if (! skip_zeroes) 673 p = buf; 674 else 675 { 676 for (p = buf; *p == '0'; ++p) 677 ; 678 if (*p == '\0') 679 --p; 680 } 681 (*info->fprintf_func) (info->stream, "%s", p); 682} 683 684/* Print the name of a symbol. */ 685 686static void 687objdump_print_symname (abfd, info, sym) 688 bfd *abfd; 689 struct disassemble_info *info; 690 asymbol *sym; 691{ 692 char *alloc; 693 const char *name; 694 const char *print; 695 696 alloc = NULL; 697 name = bfd_asymbol_name (sym); 698 if (! do_demangle || name[0] == '\0') 699 print = name; 700 else 701 { 702 /* Demangle the name. */ 703 if (bfd_get_symbol_leading_char (abfd) == name[0]) 704 ++name; 705 706 alloc = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS); 707 if (alloc == NULL) 708 print = name; 709 else 710 print = alloc; 711 } 712 713 if (info != NULL) 714 (*info->fprintf_func) (info->stream, "%s", print); 715 else 716 printf ("%s", print); 717 718 if (alloc != NULL) 719 free (alloc); 720} 721 722/* Locate a symbol given a bfd, a section, and a VMA. If REQUIRE_SEC 723 is true, then always require the symbol to be in the section. This 724 returns NULL if there is no suitable symbol. If PLACE is not NULL, 725 then *PLACE is set to the index of the symbol in sorted_syms. */ 726 727static asymbol * 728find_symbol_for_address (abfd, sec, vma, require_sec, place) 729 bfd *abfd; 730 asection *sec; 731 bfd_vma vma; 732 boolean require_sec; 733 long *place; 734{ 735 /* @@ Would it speed things up to cache the last two symbols returned, 736 and maybe their address ranges? For many processors, only one memory 737 operand can be present at a time, so the 2-entry cache wouldn't be 738 constantly churned by code doing heavy memory accesses. */ 739 740 /* Indices in `sorted_syms'. */ 741 long min = 0; 742 long max = sorted_symcount; 743 long thisplace; 744 unsigned int opb = bfd_octets_per_byte (abfd); 745 746 if (sorted_symcount < 1) 747 return NULL; 748 749 /* Perform a binary search looking for the closest symbol to the 750 required value. We are searching the range (min, max]. */ 751 while (min + 1 < max) 752 { 753 asymbol *sym; 754 755 thisplace = (max + min) / 2; 756 sym = sorted_syms[thisplace]; 757 758 if (bfd_asymbol_value (sym) > vma) 759 max = thisplace; 760 else if (bfd_asymbol_value (sym) < vma) 761 min = thisplace; 762 else 763 { 764 min = thisplace; 765 break; 766 } 767 } 768 769 /* The symbol we want is now in min, the low end of the range we 770 were searching. If there are several symbols with the same 771 value, we want the first one. */ 772 thisplace = min; 773 while (thisplace > 0 774 && (bfd_asymbol_value (sorted_syms[thisplace]) 775 == bfd_asymbol_value (sorted_syms[thisplace - 1]))) 776 --thisplace; 777 778 /* If the file is relocateable, and the symbol could be from this 779 section, prefer a symbol from this section over symbols from 780 others, even if the other symbol's value might be closer. 781 782 Note that this may be wrong for some symbol references if the 783 sections have overlapping memory ranges, but in that case there's 784 no way to tell what's desired without looking at the relocation 785 table. */ 786 787 if (sorted_syms[thisplace]->section != sec 788 && (require_sec 789 || ((abfd->flags & HAS_RELOC) != 0 790 && vma >= bfd_get_section_vma (abfd, sec) 791 && vma < (bfd_get_section_vma (abfd, sec) 792 + bfd_section_size (abfd, sec) / opb)))) 793 { 794 long i; 795 796 for (i = thisplace + 1; i < sorted_symcount; i++) 797 { 798 if (bfd_asymbol_value (sorted_syms[i]) 799 != bfd_asymbol_value (sorted_syms[thisplace])) 800 break; 801 } 802 --i; 803 for (; i >= 0; i--) 804 { 805 if (sorted_syms[i]->section == sec 806 && (i == 0 807 || sorted_syms[i - 1]->section != sec 808 || (bfd_asymbol_value (sorted_syms[i]) 809 != bfd_asymbol_value (sorted_syms[i - 1])))) 810 { 811 thisplace = i; 812 break; 813 } 814 } 815 816 if (sorted_syms[thisplace]->section != sec) 817 { 818 /* We didn't find a good symbol with a smaller value. 819 Look for one with a larger value. */ 820 for (i = thisplace + 1; i < sorted_symcount; i++) 821 { 822 if (sorted_syms[i]->section == sec) 823 { 824 thisplace = i; 825 break; 826 } 827 } 828 } 829 830 if (sorted_syms[thisplace]->section != sec 831 && (require_sec 832 || ((abfd->flags & HAS_RELOC) != 0 833 && vma >= bfd_get_section_vma (abfd, sec) 834 && vma < (bfd_get_section_vma (abfd, sec) 835 + bfd_section_size (abfd, sec))))) 836 { 837 /* There is no suitable symbol. */ 838 return NULL; 839 } 840 } 841 842 if (place != NULL) 843 *place = thisplace; 844 845 return sorted_syms[thisplace]; 846} 847 848/* Print an address to INFO symbolically. */ 849 850static void 851objdump_print_addr_with_sym (abfd, sec, sym, vma, info, skip_zeroes) 852 bfd *abfd; 853 asection *sec; 854 asymbol *sym; 855 bfd_vma vma; 856 struct disassemble_info *info; 857 boolean skip_zeroes; 858{ 859 objdump_print_value (vma, info, skip_zeroes); 860 861 if (sym == NULL) 862 { 863 bfd_vma secaddr; 864 865 (*info->fprintf_func) (info->stream, " <%s", 866 bfd_get_section_name (abfd, sec)); 867 secaddr = bfd_get_section_vma (abfd, sec); 868 if (vma < secaddr) 869 { 870 (*info->fprintf_func) (info->stream, "-0x"); 871 objdump_print_value (secaddr - vma, info, true); 872 } 873 else if (vma > secaddr) 874 { 875 (*info->fprintf_func) (info->stream, "+0x"); 876 objdump_print_value (vma - secaddr, info, true); 877 } 878 (*info->fprintf_func) (info->stream, ">"); 879 } 880 else 881 { 882 (*info->fprintf_func) (info->stream, " <"); 883 objdump_print_symname (abfd, info, sym); 884 if (bfd_asymbol_value (sym) > vma) 885 { 886 (*info->fprintf_func) (info->stream, "-0x"); 887 objdump_print_value (bfd_asymbol_value (sym) - vma, info, true); 888 } 889 else if (vma > bfd_asymbol_value (sym)) 890 { 891 (*info->fprintf_func) (info->stream, "+0x"); 892 objdump_print_value (vma - bfd_asymbol_value (sym), info, true); 893 } 894 (*info->fprintf_func) (info->stream, ">"); 895 } 896} 897 898/* Print VMA to INFO, symbolically if possible. If SKIP_ZEROES is 899 true, don't output leading zeroes. */ 900 901static void 902objdump_print_addr (vma, info, skip_zeroes) 903 bfd_vma vma; 904 struct disassemble_info *info; 905 boolean skip_zeroes; 906{ 907 struct objdump_disasm_info *aux; 908 asymbol *sym; 909 910 if (sorted_symcount < 1) 911 { 912 (*info->fprintf_func) (info->stream, "0x"); 913 objdump_print_value (vma, info, skip_zeroes); 914 return; 915 } 916 917 aux = (struct objdump_disasm_info *) info->application_data; 918 sym = find_symbol_for_address (aux->abfd, aux->sec, vma, aux->require_sec, 919 (long *) NULL); 920 objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, info, 921 skip_zeroes); 922} 923 924/* Print VMA to INFO. This function is passed to the disassembler 925 routine. */ 926 927static void 928objdump_print_address (vma, info) 929 bfd_vma vma; 930 struct disassemble_info *info; 931{ 932 objdump_print_addr (vma, info, ! prefix_addresses); 933} 934 935/* Determine of the given address has a symbol associated with it. */ 936 937static int 938objdump_symbol_at_address (vma, info) 939 bfd_vma vma; 940 struct disassemble_info * info; 941{ 942 struct objdump_disasm_info * aux; 943 asymbol * sym; 944 945 /* No symbols - do not bother checking. */ 946 if (sorted_symcount < 1) 947 return 0; 948 949 aux = (struct objdump_disasm_info *) info->application_data; 950 sym = find_symbol_for_address (aux->abfd, aux->sec, vma, aux->require_sec, 951 (long *) NULL); 952 953 return (sym != NULL && (bfd_asymbol_value (sym) == vma)); 954} 955 956/* Hold the last function name and the last line number we displayed 957 in a disassembly. */ 958 959static char *prev_functionname; 960static unsigned int prev_line; 961 962/* We keep a list of all files that we have seen when doing a 963 dissassembly with source, so that we know how much of the file to 964 display. This can be important for inlined functions. */ 965 966struct print_file_list 967{ 968 struct print_file_list *next; 969 char *filename; 970 unsigned int line; 971 FILE *f; 972}; 973 974static struct print_file_list *print_files; 975 976/* The number of preceding context lines to show when we start 977 displaying a file for the first time. */ 978 979#define SHOW_PRECEDING_CONTEXT_LINES (5) 980 981/* Skip ahead to a given line in a file, optionally printing each 982 line. */ 983 984static void 985skip_to_line PARAMS ((struct print_file_list *, unsigned int, boolean)); 986 987static void 988skip_to_line (p, line, show) 989 struct print_file_list *p; 990 unsigned int line; 991 boolean show; 992{ 993 while (p->line < line) 994 { 995 char buf[100]; 996 997 if (fgets (buf, sizeof buf, p->f) == NULL) 998 { 999 fclose (p->f); 1000 p->f = NULL; 1001 break; 1002 } 1003 1004 if (show) 1005 printf ("%s", buf); 1006 1007 if (strchr (buf, '\n') != NULL) 1008 ++p->line; 1009 } 1010} 1011 1012/* Show the line number, or the source line, in a dissassembly 1013 listing. */ 1014 1015static void 1016show_line (abfd, section, addr_offset) 1017 bfd *abfd; 1018 asection *section; 1019 bfd_vma addr_offset; 1020{ 1021 CONST char *filename; 1022 CONST char *functionname; 1023 unsigned int line; 1024 1025 if (! with_line_numbers && ! with_source_code) 1026 return; 1027 1028 if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename, 1029 &functionname, &line)) 1030 return; 1031 1032 if (filename != NULL && *filename == '\0') 1033 filename = NULL; 1034 if (functionname != NULL && *functionname == '\0') 1035 functionname = NULL; 1036 1037 if (with_line_numbers) 1038 { 1039 if (functionname != NULL 1040 && (prev_functionname == NULL 1041 || strcmp (functionname, prev_functionname) != 0)) 1042 printf ("%s():\n", functionname); 1043 if (line > 0 && line != prev_line) 1044 printf ("%s:%u\n", filename == NULL ? "???" : filename, line); 1045 } 1046 1047 if (with_source_code 1048 && filename != NULL 1049 && line > 0) 1050 { 1051 struct print_file_list **pp, *p; 1052 1053 for (pp = &print_files; *pp != NULL; pp = &(*pp)->next) 1054 if (strcmp ((*pp)->filename, filename) == 0) 1055 break; 1056 p = *pp; 1057 1058 if (p != NULL) 1059 { 1060 if (p != print_files) 1061 { 1062 int l; 1063 1064 /* We have reencountered a file name which we saw 1065 earlier. This implies that either we are dumping out 1066 code from an included file, or the same file was 1067 linked in more than once. There are two common cases 1068 of an included file: inline functions in a header 1069 file, and a bison or flex skeleton file. In the 1070 former case we want to just start printing (but we 1071 back up a few lines to give context); in the latter 1072 case we want to continue from where we left off. I 1073 can't think of a good way to distinguish the cases, 1074 so I used a heuristic based on the file name. */ 1075 if (strcmp (p->filename + strlen (p->filename) - 2, ".h") != 0) 1076 l = p->line; 1077 else 1078 { 1079 l = line - SHOW_PRECEDING_CONTEXT_LINES; 1080 if (l < 0) 1081 l = 0; 1082 } 1083 1084 if (p->f == NULL) 1085 { 1086 p->f = fopen (p->filename, "r"); 1087 p->line = 0; 1088 } 1089 if (p->f != NULL) 1090 skip_to_line (p, l, false); 1091 1092 if (print_files->f != NULL) 1093 { 1094 fclose (print_files->f); 1095 print_files->f = NULL; 1096 } 1097 } 1098 1099 if (p->f != NULL) 1100 { 1101 skip_to_line (p, line, true); 1102 *pp = p->next; 1103 p->next = print_files; 1104 print_files = p; 1105 } 1106 } 1107 else 1108 { 1109 FILE *f; 1110 1111 f = fopen (filename, "r"); 1112 if (f != NULL) 1113 { 1114 int l; 1115 1116 p = ((struct print_file_list *) 1117 xmalloc (sizeof (struct print_file_list))); 1118 p->filename = xmalloc (strlen (filename) + 1); 1119 strcpy (p->filename, filename); 1120 p->line = 0; 1121 p->f = f; 1122 1123 if (print_files != NULL && print_files->f != NULL) 1124 { 1125 fclose (print_files->f); 1126 print_files->f = NULL; 1127 } 1128 p->next = print_files; 1129 print_files = p; 1130 1131 if (file_start_context) 1132 l = 0; 1133 else 1134 l = line - SHOW_PRECEDING_CONTEXT_LINES; 1135 if (l < 0) 1136 l = 0; 1137 skip_to_line (p, l, false); 1138 if (p->f != NULL) 1139 skip_to_line (p, line, true); 1140 } 1141 } 1142 } 1143 1144 if (functionname != NULL 1145 && (prev_functionname == NULL 1146 || strcmp (functionname, prev_functionname) != 0)) 1147 { 1148 if (prev_functionname != NULL) 1149 free (prev_functionname); 1150 prev_functionname = xmalloc (strlen (functionname) + 1); 1151 strcpy (prev_functionname, functionname); 1152 } 1153 1154 if (line > 0 && line != prev_line) 1155 prev_line = line; 1156} 1157 1158/* Pseudo FILE object for strings. */ 1159typedef struct 1160{ 1161 char *buffer; 1162 size_t size; 1163 char *current; 1164} SFILE; 1165 1166/* sprintf to a "stream" */ 1167 1168static int 1169#ifdef ANSI_PROTOTYPES 1170objdump_sprintf (SFILE *f, const char *format, ...) 1171#else 1172objdump_sprintf (va_alist) 1173 va_dcl 1174#endif 1175{ 1176#ifndef ANSI_PROTOTYPES 1177 SFILE *f; 1178 const char *format; 1179#endif 1180 char *buf; 1181 va_list args; 1182 size_t n; 1183 1184#ifdef ANSI_PROTOTYPES 1185 va_start (args, format); 1186#else 1187 va_start (args); 1188 f = va_arg (args, SFILE *); 1189 format = va_arg (args, const char *); 1190#endif 1191 1192 vasprintf (&buf, format, args); 1193 1194 va_end (args); 1195 1196 if (buf == NULL) 1197 { 1198 fatal (_("Out of virtual memory")); 1199 } 1200 1201 n = strlen (buf); 1202 1203 while ((size_t) ((f->buffer + f->size) - f->current) < n + 1) 1204 { 1205 size_t curroff; 1206 1207 curroff = f->current - f->buffer; 1208 f->size *= 2; 1209 f->buffer = xrealloc (f->buffer, f->size); 1210 f->current = f->buffer + curroff; 1211 } 1212 1213 memcpy (f->current, buf, n); 1214 f->current += n; 1215 f->current[0] = '\0'; 1216 1217 free (buf); 1218 1219 return n; 1220} 1221 1222/* The number of zeroes we want to see before we start skipping them. 1223 The number is arbitrarily chosen. */ 1224 1225#define SKIP_ZEROES (8) 1226 1227/* The number of zeroes to skip at the end of a section. If the 1228 number of zeroes at the end is between SKIP_ZEROES_AT_END and 1229 SKIP_ZEROES, they will be disassembled. If there are fewer than 1230 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic 1231 attempt to avoid disassembling zeroes inserted by section 1232 alignment. */ 1233 1234#define SKIP_ZEROES_AT_END (3) 1235 1236/* Disassemble some data in memory between given values. */ 1237 1238static void 1239disassemble_bytes (info, disassemble_fn, insns, data, 1240 start_offset, stop_offset, relppp, 1241 relppend) 1242 struct disassemble_info *info; 1243 disassembler_ftype disassemble_fn; 1244 boolean insns; 1245 bfd_byte *data; 1246 bfd_vma start_offset; 1247 bfd_vma stop_offset; 1248 arelent ***relppp; 1249 arelent **relppend; 1250{ 1251 struct objdump_disasm_info *aux; 1252 asection *section; 1253 int octets_per_line; 1254 boolean done_dot; 1255 int skip_addr_chars; 1256 bfd_vma addr_offset; 1257 int opb = info->octets_per_byte; 1258 1259 aux = (struct objdump_disasm_info *) info->application_data; 1260 section = aux->sec; 1261 1262 if (insns) 1263 octets_per_line = 4; 1264 else 1265 octets_per_line = 16; 1266 1267 /* Figure out how many characters to skip at the start of an 1268 address, to make the disassembly look nicer. We discard leading 1269 zeroes in chunks of 4, ensuring that there is always a leading 1270 zero remaining. */ 1271 skip_addr_chars = 0; 1272 if (! prefix_addresses) 1273 { 1274 char buf[30]; 1275 char *s; 1276 1277 sprintf_vma (buf, section->vma + 1278 bfd_section_size (section->owner, section) / opb); 1279 s = buf; 1280 while (s[0] == '0' && s[1] == '0' && s[2] == '0' && s[3] == '0' 1281 && s[4] == '0') 1282 { 1283 skip_addr_chars += 4; 1284 s += 4; 1285 } 1286 } 1287 1288 info->insn_info_valid = 0; 1289 1290 done_dot = false; 1291 addr_offset = start_offset; 1292 while (addr_offset < stop_offset) 1293 { 1294 bfd_vma z; 1295 int octets = 0; 1296 boolean need_nl = false; 1297 1298 /* If we see more than SKIP_ZEROES octets of zeroes, we just 1299 print `...'. */ 1300 for (z = addr_offset * opb; z < stop_offset * opb; z++) 1301 if (data[z] != 0) 1302 break; 1303 if (! disassemble_zeroes 1304 && (info->insn_info_valid == 0 1305 || info->branch_delay_insns == 0) 1306 && (z - addr_offset * opb >= SKIP_ZEROES 1307 || (z == stop_offset * opb && 1308 z - addr_offset * opb < SKIP_ZEROES_AT_END))) 1309 { 1310 printf ("\t...\n"); 1311 1312 /* If there are more nonzero octets to follow, we only skip 1313 zeroes in multiples of 4, to try to avoid running over 1314 the start of an instruction which happens to start with 1315 zero. */ 1316 if (z != stop_offset * opb) 1317 z = addr_offset * opb + ((z - addr_offset * opb) &~ 3); 1318 1319 octets = z - addr_offset * opb; 1320 } 1321 else 1322 { 1323 char buf[50]; 1324 SFILE sfile; 1325 int bpc = 0; 1326 int pb = 0; 1327 1328 done_dot = false; 1329 1330 if (with_line_numbers || with_source_code) 1331 show_line (aux->abfd, section, addr_offset); 1332 1333 if (! prefix_addresses) 1334 { 1335 char *s; 1336 1337 sprintf_vma (buf, section->vma + addr_offset); 1338 for (s = buf + skip_addr_chars; *s == '0'; s++) 1339 *s = ' '; 1340 if (*s == '\0') 1341 *--s = '0'; 1342 printf ("%s:\t", buf + skip_addr_chars); 1343 } 1344 else 1345 { 1346 aux->require_sec = true; 1347 objdump_print_address (section->vma + addr_offset, info); 1348 aux->require_sec = false; 1349 putchar (' '); 1350 } 1351 1352 if (insns) 1353 { 1354 sfile.size = 120; 1355 sfile.buffer = xmalloc (sfile.size); 1356 sfile.current = sfile.buffer; 1357 info->fprintf_func = (fprintf_ftype) objdump_sprintf; 1358 info->stream = (FILE *) &sfile; 1359 info->bytes_per_line = 0; 1360 info->bytes_per_chunk = 0; 1361 1362#ifdef DISASSEMBLER_NEEDS_RELOCS 1363 /* FIXME: This is wrong. It tests the number of octets 1364 in the last instruction, not the current one. */ 1365 if (*relppp < relppend 1366 && (**relppp)->address >= addr_offset 1367 && (**relppp)->address <= addr_offset + octets / opb) 1368 info->flags = INSN_HAS_RELOC; 1369 else 1370#endif 1371 info->flags = 0; 1372 1373 octets = (*disassemble_fn) (section->vma + addr_offset, info); 1374 info->fprintf_func = (fprintf_ftype) fprintf; 1375 info->stream = stdout; 1376 if (info->bytes_per_line != 0) 1377 octets_per_line = info->bytes_per_line; 1378 if (octets < 0) 1379 { 1380 if (sfile.current != sfile.buffer) 1381 printf ("%s\n", sfile.buffer); 1382 free (sfile.buffer); 1383 break; 1384 } 1385 } 1386 else 1387 { 1388 bfd_vma j; 1389 1390 octets = octets_per_line; 1391 if (addr_offset + octets / opb > stop_offset) 1392 octets = (stop_offset - addr_offset) * opb; 1393 1394 for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j) 1395 { 1396 if (isprint (data[j])) 1397 buf[j - addr_offset * opb] = data[j]; 1398 else 1399 buf[j - addr_offset * opb] = '.'; 1400 } 1401 buf[j - addr_offset * opb] = '\0'; 1402 } 1403 1404 if (prefix_addresses 1405 ? show_raw_insn > 0 1406 : show_raw_insn >= 0) 1407 { 1408 bfd_vma j; 1409 1410 /* If ! prefix_addresses and ! wide_output, we print 1411 octets_per_line octets per line. */ 1412 pb = octets; 1413 if (pb > octets_per_line && ! prefix_addresses && ! wide_output) 1414 pb = octets_per_line; 1415 1416 if (info->bytes_per_chunk) 1417 bpc = info->bytes_per_chunk; 1418 else 1419 bpc = 1; 1420 1421 for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc) 1422 { 1423 int k; 1424 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE) 1425 { 1426 for (k = bpc - 1; k >= 0; k--) 1427 printf ("%02x", (unsigned) data[j + k]); 1428 putchar (' '); 1429 } 1430 else 1431 { 1432 for (k = 0; k < bpc; k++) 1433 printf ("%02x", (unsigned) data[j + k]); 1434 putchar (' '); 1435 } 1436 } 1437 1438 for (; pb < octets_per_line; pb += bpc) 1439 { 1440 int k; 1441 1442 for (k = 0; k < bpc; k++) 1443 printf (" "); 1444 putchar (' '); 1445 } 1446 1447 /* Separate raw data from instruction by extra space. */ 1448 if (insns) 1449 putchar ('\t'); 1450 else 1451 printf (" "); 1452 } 1453 1454 if (! insns) 1455 printf ("%s", buf); 1456 else 1457 { 1458 printf ("%s", sfile.buffer); 1459 free (sfile.buffer); 1460 } 1461 1462 if (prefix_addresses 1463 ? show_raw_insn > 0 1464 : show_raw_insn >= 0) 1465 { 1466 while (pb < octets) 1467 { 1468 bfd_vma j; 1469 char *s; 1470 1471 putchar ('\n'); 1472 j = addr_offset * opb + pb; 1473 1474 sprintf_vma (buf, section->vma + j / opb); 1475 for (s = buf + skip_addr_chars; *s == '0'; s++) 1476 *s = ' '; 1477 if (*s == '\0') 1478 *--s = '0'; 1479 printf ("%s:\t", buf + skip_addr_chars); 1480 1481 pb += octets_per_line; 1482 if (pb > octets) 1483 pb = octets; 1484 for (; j < addr_offset * opb + pb; j += bpc) 1485 { 1486 int k; 1487 1488 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE) 1489 { 1490 for (k = bpc - 1; k >= 0; k--) 1491 printf ("%02x", (unsigned) data[j + k]); 1492 putchar (' '); 1493 } 1494 else 1495 { 1496 for (k = 0; k < bpc; k++) 1497 printf ("%02x", (unsigned) data[j + k]); 1498 putchar (' '); 1499 } 1500 } 1501 } 1502 } 1503 1504 if (!wide_output) 1505 putchar ('\n'); 1506 else 1507 need_nl = true; 1508 } 1509 1510 if ((section->flags & SEC_RELOC) != 0 1511#ifndef DISASSEMBLER_NEEDS_RELOCS 1512 && dump_reloc_info 1513#endif 1514 ) 1515 { 1516 while ((*relppp) < relppend 1517 && ((**relppp)->address >= (bfd_vma) addr_offset 1518 && (**relppp)->address < (bfd_vma) addr_offset + octets / opb)) 1519#ifdef DISASSEMBLER_NEEDS_RELOCS 1520 if (! dump_reloc_info) 1521 ++(*relppp); 1522 else 1523#endif 1524 { 1525 arelent *q; 1526 1527 q = **relppp; 1528 1529 if (wide_output) 1530 putchar ('\t'); 1531 else 1532 printf ("\t\t\t"); 1533 1534 objdump_print_value (section->vma + q->address, info, true); 1535 1536 printf (": %s\t", q->howto->name); 1537 1538 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL) 1539 printf ("*unknown*"); 1540 else 1541 { 1542 const char *sym_name; 1543 1544 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr); 1545 if (sym_name != NULL && *sym_name != '\0') 1546 objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr); 1547 else 1548 { 1549 asection *sym_sec; 1550 1551 sym_sec = bfd_get_section (*q->sym_ptr_ptr); 1552 sym_name = bfd_get_section_name (aux->abfd, sym_sec); 1553 if (sym_name == NULL || *sym_name == '\0') 1554 sym_name = "*unknown*"; 1555 printf ("%s", sym_name); 1556 } 1557 } 1558 1559 if (q->addend) 1560 { 1561 printf ("+0x"); 1562 objdump_print_value (q->addend, info, true); 1563 } 1564 1565 printf ("\n"); 1566 need_nl = false; 1567 ++(*relppp); 1568 } 1569 } 1570 1571 if (need_nl) 1572 printf ("\n"); 1573 1574 addr_offset += octets / opb; 1575 } 1576} 1577 1578/* Disassemble the contents of an object file. */ 1579 1580static void 1581disassemble_data (abfd) 1582 bfd *abfd; 1583{ 1584 unsigned long addr_offset; 1585 disassembler_ftype disassemble_fn; 1586 struct disassemble_info disasm_info; 1587 struct objdump_disasm_info aux; 1588 asection *section; 1589 unsigned int opb; 1590 1591 print_files = NULL; 1592 prev_functionname = NULL; 1593 prev_line = -1; 1594 1595 /* We make a copy of syms to sort. We don't want to sort syms 1596 because that will screw up the relocs. */ 1597 sorted_syms = (asymbol **) xmalloc (symcount * sizeof (asymbol *)); 1598 memcpy (sorted_syms, syms, symcount * sizeof (asymbol *)); 1599 1600 sorted_symcount = remove_useless_symbols (sorted_syms, symcount); 1601 1602 /* Sort the symbols into section and symbol order */ 1603 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols); 1604 1605 INIT_DISASSEMBLE_INFO(disasm_info, stdout, fprintf); 1606 disasm_info.application_data = (PTR) &aux; 1607 aux.abfd = abfd; 1608 aux.require_sec = false; 1609 disasm_info.print_address_func = objdump_print_address; 1610 disasm_info.symbol_at_address_func = objdump_symbol_at_address; 1611 1612 if (machine != (char *) NULL) 1613 { 1614 const bfd_arch_info_type *info = bfd_scan_arch (machine); 1615 if (info == NULL) 1616 { 1617 fatal (_("Can't use supplied machine %s"), machine); 1618 } 1619 abfd->arch_info = info; 1620 } 1621 1622 if (endian != BFD_ENDIAN_UNKNOWN) 1623 { 1624 struct bfd_target *xvec; 1625 1626 xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target)); 1627 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target)); 1628 xvec->byteorder = endian; 1629 abfd->xvec = xvec; 1630 } 1631 1632 disassemble_fn = disassembler (abfd); 1633 if (!disassemble_fn) 1634 { 1635 non_fatal (_("Can't disassemble for architecture %s\n"), 1636 bfd_printable_arch_mach (bfd_get_arch (abfd), 0)); 1637 exit_status = 1; 1638 return; 1639 } 1640 1641 opb = bfd_octets_per_byte (abfd); 1642 1643 disasm_info.flavour = bfd_get_flavour (abfd); 1644 disasm_info.arch = bfd_get_arch (abfd); 1645 disasm_info.mach = bfd_get_mach (abfd); 1646 disasm_info.disassembler_options = disassembler_options; 1647 disasm_info.octets_per_byte = opb; 1648 1649 if (bfd_big_endian (abfd)) 1650 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG; 1651 else if (bfd_little_endian (abfd)) 1652 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE; 1653 else 1654 /* ??? Aborting here seems too drastic. We could default to big or little 1655 instead. */ 1656 disasm_info.endian = BFD_ENDIAN_UNKNOWN; 1657 1658 for (section = abfd->sections; 1659 section != (asection *) NULL; 1660 section = section->next) 1661 { 1662 bfd_byte *data = NULL; 1663 bfd_size_type datasize = 0; 1664 arelent **relbuf = NULL; 1665 arelent **relpp = NULL; 1666 arelent **relppend = NULL; 1667 unsigned long stop_offset; 1668 asymbol *sym = NULL; 1669 long place = 0; 1670 1671 if ((section->flags & SEC_LOAD) == 0 1672 || (! disassemble_all 1673 && only == NULL 1674 && (section->flags & SEC_CODE) == 0)) 1675 continue; 1676 if (only != (char *) NULL && strcmp (only, section->name) != 0) 1677 continue; 1678 1679 if ((section->flags & SEC_RELOC) != 0 1680#ifndef DISASSEMBLER_NEEDS_RELOCS 1681 && dump_reloc_info 1682#endif 1683 ) 1684 { 1685 long relsize; 1686 1687 relsize = bfd_get_reloc_upper_bound (abfd, section); 1688 if (relsize < 0) 1689 bfd_fatal (bfd_get_filename (abfd)); 1690 1691 if (relsize > 0) 1692 { 1693 long relcount; 1694 1695 relbuf = (arelent **) xmalloc (relsize); 1696 relcount = bfd_canonicalize_reloc (abfd, section, relbuf, syms); 1697 if (relcount < 0) 1698 bfd_fatal (bfd_get_filename (abfd)); 1699 1700 /* Sort the relocs by address. */ 1701 qsort (relbuf, relcount, sizeof (arelent *), compare_relocs); 1702 1703 relpp = relbuf; 1704 relppend = relpp + relcount; 1705 1706 /* Skip over the relocs belonging to addresses below the 1707 start address. */ 1708 if (start_address != (bfd_vma) -1) 1709 { 1710 while (relpp < relppend 1711 && (*relpp)->address < start_address) 1712 ++relpp; 1713 } 1714 } 1715 } 1716 1717 printf (_("Disassembly of section %s:\n"), section->name); 1718 1719 datasize = bfd_get_section_size_before_reloc (section); 1720 if (datasize == 0) 1721 continue; 1722 1723 data = (bfd_byte *) xmalloc ((size_t) datasize); 1724 1725 bfd_get_section_contents (abfd, section, data, 0, datasize); 1726 1727 aux.sec = section; 1728 disasm_info.buffer = data; 1729 disasm_info.buffer_vma = section->vma; 1730 disasm_info.buffer_length = datasize; 1731 if (start_address == (bfd_vma) -1 1732 || start_address < disasm_info.buffer_vma) 1733 addr_offset = 0; 1734 else 1735 addr_offset = start_address - disasm_info.buffer_vma; 1736 if (stop_address == (bfd_vma) -1) 1737 stop_offset = datasize / opb; 1738 else 1739 { 1740 if (stop_address < disasm_info.buffer_vma) 1741 stop_offset = 0; 1742 else 1743 stop_offset = stop_address - disasm_info.buffer_vma; 1744 if (stop_offset > disasm_info.buffer_length / opb) 1745 stop_offset = disasm_info.buffer_length / opb; 1746 } 1747 1748 sym = find_symbol_for_address (abfd, section, section->vma + addr_offset, 1749 true, &place); 1750 1751 while (addr_offset < stop_offset) 1752 { 1753 asymbol *nextsym; 1754 unsigned long nextstop_offset; 1755 boolean insns; 1756 1757 if (sym != NULL && bfd_asymbol_value (sym) <= section->vma + addr_offset) 1758 { 1759 int x; 1760 1761 for (x = place; 1762 (x < sorted_symcount 1763 && bfd_asymbol_value (sorted_syms[x]) <= section->vma + addr_offset); 1764 ++x) 1765 continue; 1766 disasm_info.symbols = & sorted_syms[place]; 1767 disasm_info.num_symbols = x - place; 1768 } 1769 else 1770 disasm_info.symbols = NULL; 1771 1772 if (! prefix_addresses) 1773 { 1774 printf ("\n"); 1775 objdump_print_addr_with_sym (abfd, section, sym, 1776 section->vma + addr_offset, 1777 &disasm_info, 1778 false); 1779 printf (":\n"); 1780 } 1781 1782 if (sym != NULL && bfd_asymbol_value (sym) > section->vma + addr_offset) 1783 nextsym = sym; 1784 else if (sym == NULL) 1785 nextsym = NULL; 1786 else 1787 { 1788 /* Search forward for the next appropriate symbol in 1789 SECTION. Note that all the symbols are sorted 1790 together into one big array, and that some sections 1791 may have overlapping addresses. */ 1792 while (place < sorted_symcount 1793 && (sorted_syms[place]->section != section 1794 || (bfd_asymbol_value (sorted_syms[place]) 1795 <= bfd_asymbol_value (sym)))) 1796 ++place; 1797 if (place >= sorted_symcount) 1798 nextsym = NULL; 1799 else 1800 nextsym = sorted_syms[place]; 1801 } 1802 1803 if (sym != NULL && bfd_asymbol_value (sym) > section->vma + addr_offset) 1804 { 1805 nextstop_offset = bfd_asymbol_value (sym) - section->vma; 1806 if (nextstop_offset > stop_offset) 1807 nextstop_offset = stop_offset; 1808 } 1809 else if (nextsym == NULL) 1810 nextstop_offset = stop_offset; 1811 else 1812 { 1813 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma; 1814 if (nextstop_offset > stop_offset) 1815 nextstop_offset = stop_offset; 1816 } 1817 1818 /* If a symbol is explicitly marked as being an object 1819 rather than a function, just dump the bytes without 1820 disassembling them. */ 1821 if (disassemble_all 1822 || sym == NULL 1823 || bfd_asymbol_value (sym) > section->vma + addr_offset 1824 || ((sym->flags & BSF_OBJECT) == 0 1825 && (strstr (bfd_asymbol_name (sym), "gnu_compiled") 1826 == NULL) 1827 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled") 1828 == NULL)) 1829 || (sym->flags & BSF_FUNCTION) != 0) 1830 insns = true; 1831 else 1832 insns = false; 1833 1834 disassemble_bytes (&disasm_info, disassemble_fn, insns, data, 1835 addr_offset, nextstop_offset, &relpp, relppend); 1836 1837 addr_offset = nextstop_offset; 1838 sym = nextsym; 1839 } 1840 1841 free (data); 1842 if (relbuf != NULL) 1843 free (relbuf); 1844 } 1845 free (sorted_syms); 1846} 1847 1848 1849/* Define a table of stab values and print-strings. We wish the initializer 1850 could be a direct-mapped table, but instead we build one the first 1851 time we need it. */ 1852 1853static void dump_section_stabs PARAMS ((bfd *abfd, char *stabsect_name, 1854 char *strsect_name)); 1855 1856/* Dump the stabs sections from an object file that has a section that 1857 uses Sun stabs encoding. */ 1858 1859static void 1860dump_stabs (abfd) 1861 bfd *abfd; 1862{ 1863 dump_section_stabs (abfd, ".stab", ".stabstr"); 1864 dump_section_stabs (abfd, ".stab.excl", ".stab.exclstr"); 1865 dump_section_stabs (abfd, ".stab.index", ".stab.indexstr"); 1866 dump_section_stabs (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$"); 1867} 1868 1869static bfd_byte *stabs; 1870static bfd_size_type stab_size; 1871 1872static char *strtab; 1873static bfd_size_type stabstr_size; 1874 1875/* Read ABFD's stabs section STABSECT_NAME into `stabs' 1876 and string table section STRSECT_NAME into `strtab'. 1877 If the section exists and was read, allocate the space and return true. 1878 Otherwise return false. */ 1879 1880static boolean 1881read_section_stabs (abfd, stabsect_name, strsect_name) 1882 bfd *abfd; 1883 const char *stabsect_name; 1884 const char *strsect_name; 1885{ 1886 asection *stabsect, *stabstrsect; 1887 1888 stabsect = bfd_get_section_by_name (abfd, stabsect_name); 1889 if (0 == stabsect) 1890 { 1891 printf (_("No %s section present\n\n"), stabsect_name); 1892 return false; 1893 } 1894 1895 stabstrsect = bfd_get_section_by_name (abfd, strsect_name); 1896 if (0 == stabstrsect) 1897 { 1898 non_fatal (_("%s has no %s section"), 1899 bfd_get_filename (abfd), strsect_name); 1900 exit_status = 1; 1901 return false; 1902 } 1903 1904 stab_size = bfd_section_size (abfd, stabsect); 1905 stabstr_size = bfd_section_size (abfd, stabstrsect); 1906 1907 stabs = (bfd_byte *) xmalloc (stab_size); 1908 strtab = (char *) xmalloc (stabstr_size); 1909 1910 if (! bfd_get_section_contents (abfd, stabsect, (PTR) stabs, 0, stab_size)) 1911 { 1912 non_fatal (_("Reading %s section of %s failed: %s"), 1913 stabsect_name, bfd_get_filename (abfd), 1914 bfd_errmsg (bfd_get_error ())); 1915 free (stabs); 1916 free (strtab); 1917 exit_status = 1; 1918 return false; 1919 } 1920 1921 if (! bfd_get_section_contents (abfd, stabstrsect, (PTR) strtab, 0, 1922 stabstr_size)) 1923 { 1924 non_fatal (_("Reading %s section of %s failed: %s\n"), 1925 strsect_name, bfd_get_filename (abfd), 1926 bfd_errmsg (bfd_get_error ())); 1927 free (stabs); 1928 free (strtab); 1929 exit_status = 1; 1930 return false; 1931 } 1932 1933 return true; 1934} 1935 1936/* Stabs entries use a 12 byte format: 1937 4 byte string table index 1938 1 byte stab type 1939 1 byte stab other field 1940 2 byte stab desc field 1941 4 byte stab value 1942 FIXME: This will have to change for a 64 bit object format. */ 1943 1944#define STRDXOFF (0) 1945#define TYPEOFF (4) 1946#define OTHEROFF (5) 1947#define DESCOFF (6) 1948#define VALOFF (8) 1949#define STABSIZE (12) 1950 1951/* Print ABFD's stabs section STABSECT_NAME (in `stabs'), 1952 using string table section STRSECT_NAME (in `strtab'). */ 1953 1954static void 1955print_section_stabs (abfd, stabsect_name, strsect_name) 1956 bfd *abfd; 1957 const char *stabsect_name; 1958 const char *strsect_name ATTRIBUTE_UNUSED; 1959{ 1960 int i; 1961 unsigned file_string_table_offset = 0, next_file_string_table_offset = 0; 1962 bfd_byte *stabp, *stabs_end; 1963 1964 stabp = stabs; 1965 stabs_end = stabp + stab_size; 1966 1967 printf (_("Contents of %s section:\n\n"), stabsect_name); 1968 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n"); 1969 1970 /* Loop through all symbols and print them. 1971 1972 We start the index at -1 because there is a dummy symbol on 1973 the front of stabs-in-{coff,elf} sections that supplies sizes. */ 1974 1975 for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++) 1976 { 1977 const char *name; 1978 unsigned long strx; 1979 unsigned char type, other; 1980 unsigned short desc; 1981 bfd_vma value; 1982 1983 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF); 1984 type = bfd_h_get_8 (abfd, stabp + TYPEOFF); 1985 other = bfd_h_get_8 (abfd, stabp + OTHEROFF); 1986 desc = bfd_h_get_16 (abfd, stabp + DESCOFF); 1987 value = bfd_h_get_32 (abfd, stabp + VALOFF); 1988 1989 printf ("\n%-6d ", i); 1990 /* Either print the stab name, or, if unnamed, print its number 1991 again (makes consistent formatting for tools like awk). */ 1992 name = bfd_get_stab_name (type); 1993 if (name != NULL) 1994 printf ("%-6s", name); 1995 else if (type == N_UNDF) 1996 printf ("HdrSym"); 1997 else 1998 printf ("%-6d", type); 1999 printf (" %-6d %-6d ", other, desc); 2000 printf_vma (value); 2001 printf (" %-6lu", strx); 2002 2003 /* Symbols with type == 0 (N_UNDF) specify the length of the 2004 string table associated with this file. We use that info 2005 to know how to relocate the *next* file's string table indices. */ 2006 2007 if (type == N_UNDF) 2008 { 2009 file_string_table_offset = next_file_string_table_offset; 2010 next_file_string_table_offset += value; 2011 } 2012 else 2013 { 2014 /* Using the (possibly updated) string table offset, print the 2015 string (if any) associated with this symbol. */ 2016 2017 if ((strx + file_string_table_offset) < stabstr_size) 2018 printf (" %s", &strtab[strx + file_string_table_offset]); 2019 else 2020 printf (" *"); 2021 } 2022 } 2023 printf ("\n\n"); 2024} 2025 2026static void 2027dump_section_stabs (abfd, stabsect_name, strsect_name) 2028 bfd *abfd; 2029 char *stabsect_name; 2030 char *strsect_name; 2031{ 2032 asection *s; 2033 2034 /* Check for section names for which stabsect_name is a prefix, to 2035 handle .stab0, etc. */ 2036 for (s = abfd->sections; 2037 s != NULL; 2038 s = s->next) 2039 { 2040 int len; 2041 2042 len = strlen (stabsect_name); 2043 2044 /* If the prefix matches, and the files section name ends with a 2045 nul or a digit, then we match. I.e., we want either an exact 2046 match or a section followed by a number. */ 2047 if (strncmp (stabsect_name, s->name, len) == 0 2048 && (s->name[len] == '\000' 2049 || isdigit ((unsigned char) s->name[len]))) 2050 { 2051 if (read_section_stabs (abfd, s->name, strsect_name)) 2052 { 2053 print_section_stabs (abfd, s->name, strsect_name); 2054 free (stabs); 2055 free (strtab); 2056 } 2057 } 2058 } 2059} 2060 2061static void 2062dump_bfd_header (abfd) 2063 bfd *abfd; 2064{ 2065 char *comma = ""; 2066 2067 printf (_("architecture: %s, "), 2068 bfd_printable_arch_mach (bfd_get_arch (abfd), 2069 bfd_get_mach (abfd))); 2070 printf (_("flags 0x%08x:\n"), abfd->flags); 2071 2072#define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";} 2073 PF (HAS_RELOC, "HAS_RELOC"); 2074 PF (EXEC_P, "EXEC_P"); 2075 PF (HAS_LINENO, "HAS_LINENO"); 2076 PF (HAS_DEBUG, "HAS_DEBUG"); 2077 PF (HAS_SYMS, "HAS_SYMS"); 2078 PF (HAS_LOCALS, "HAS_LOCALS"); 2079 PF (DYNAMIC, "DYNAMIC"); 2080 PF (WP_TEXT, "WP_TEXT"); 2081 PF (D_PAGED, "D_PAGED"); 2082 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE"); 2083 printf (_("\nstart address 0x")); 2084 printf_vma (abfd->start_address); 2085 printf ("\n"); 2086} 2087 2088static void 2089dump_bfd_private_header (abfd) 2090bfd *abfd; 2091{ 2092 bfd_print_private_bfd_data (abfd, stdout); 2093} 2094 2095/* Dump selected contents of ABFD */ 2096 2097static void 2098dump_bfd (abfd) 2099 bfd *abfd; 2100{ 2101 /* If we are adjusting section VMA's, change them all now. Changing 2102 the BFD information is a hack. However, we must do it, or 2103 bfd_find_nearest_line will not do the right thing. */ 2104 if (adjust_section_vma != 0) 2105 { 2106 asection *s; 2107 2108 for (s = abfd->sections; s != NULL; s = s->next) 2109 { 2110 s->vma += adjust_section_vma; 2111 s->lma += adjust_section_vma; 2112 } 2113 } 2114 2115 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd), 2116 abfd->xvec->name); 2117 if (dump_ar_hdrs) 2118 print_arelt_descr (stdout, abfd, true); 2119 if (dump_file_header) 2120 dump_bfd_header (abfd); 2121 if (dump_private_headers) 2122 dump_bfd_private_header (abfd); 2123 putchar ('\n'); 2124 if (dump_section_headers) 2125 dump_headers (abfd); 2126 if (dump_symtab || dump_reloc_info || disassemble || dump_debugging) 2127 { 2128 syms = slurp_symtab (abfd); 2129 } 2130 if (dump_dynamic_symtab || dump_dynamic_reloc_info) 2131 { 2132 dynsyms = slurp_dynamic_symtab (abfd); 2133 } 2134 if (dump_symtab) 2135 dump_symbols (abfd, false); 2136 if (dump_dynamic_symtab) 2137 dump_symbols (abfd, true); 2138 if (dump_stab_section_info) 2139 dump_stabs (abfd); 2140 if (dump_reloc_info && ! disassemble) 2141 dump_relocs (abfd); 2142 if (dump_dynamic_reloc_info) 2143 dump_dynamic_relocs (abfd); 2144 if (dump_section_contents) 2145 dump_data (abfd); 2146 if (disassemble) 2147 disassemble_data (abfd); 2148 if (dump_debugging) 2149 { 2150 PTR dhandle; 2151 2152 dhandle = read_debugging_info (abfd, syms, symcount); 2153 if (dhandle != NULL) 2154 { 2155 if (! print_debugging_info (stdout, dhandle)) 2156 { 2157 non_fatal (_("%s: printing debugging information failed"), 2158 bfd_get_filename (abfd)); 2159 exit_status = 1; 2160 } 2161 } 2162 } 2163 if (syms) 2164 { 2165 free (syms); 2166 syms = NULL; 2167 } 2168 if (dynsyms) 2169 { 2170 free (dynsyms); 2171 dynsyms = NULL; 2172 } 2173} 2174 2175static void 2176display_bfd (abfd) 2177 bfd *abfd; 2178{ 2179 char **matching; 2180 2181 if (bfd_check_format_matches (abfd, bfd_object, &matching)) 2182 { 2183 dump_bfd (abfd); 2184 return; 2185 } 2186 2187 if (bfd_get_error () == bfd_error_file_ambiguously_recognized) 2188 { 2189 nonfatal (bfd_get_filename (abfd)); 2190 list_matching_formats (matching); 2191 free (matching); 2192 return; 2193 } 2194 2195 if (bfd_get_error () != bfd_error_file_not_recognized) 2196 { 2197 nonfatal (bfd_get_filename (abfd)); 2198 return; 2199 } 2200 2201 if (bfd_check_format_matches (abfd, bfd_core, &matching)) 2202 { 2203 dump_bfd (abfd); 2204 return; 2205 } 2206 2207 nonfatal (bfd_get_filename (abfd)); 2208 2209 if (bfd_get_error () == bfd_error_file_ambiguously_recognized) 2210 { 2211 list_matching_formats (matching); 2212 free (matching); 2213 } 2214} 2215 2216static void 2217display_file (filename, target) 2218 char *filename; 2219 char *target; 2220{ 2221 bfd *file, *arfile = (bfd *) NULL; 2222 2223 file = bfd_openr (filename, target); 2224 if (file == NULL) 2225 { 2226 nonfatal (filename); 2227 return; 2228 } 2229 2230 if (bfd_check_format (file, bfd_archive) == true) 2231 { 2232 bfd *last_arfile = NULL; 2233 2234 printf (_("In archive %s:\n"), bfd_get_filename (file)); 2235 for (;;) 2236 { 2237 bfd_set_error (bfd_error_no_error); 2238 2239 arfile = bfd_openr_next_archived_file (file, arfile); 2240 if (arfile == NULL) 2241 { 2242 if (bfd_get_error () != bfd_error_no_more_archived_files) 2243 nonfatal (bfd_get_filename (file)); 2244 break; 2245 } 2246 2247 display_bfd (arfile); 2248 2249 if (last_arfile != NULL) 2250 bfd_close (last_arfile); 2251 last_arfile = arfile; 2252 } 2253 2254 if (last_arfile != NULL) 2255 bfd_close (last_arfile); 2256 } 2257 else 2258 display_bfd (file); 2259 2260 bfd_close (file); 2261} 2262 2263/* Actually display the various requested regions */ 2264 2265static void 2266dump_data (abfd) 2267 bfd *abfd; 2268{ 2269 asection *section; 2270 bfd_byte *data = 0; 2271 bfd_size_type datasize = 0; 2272 bfd_size_type addr_offset; 2273 bfd_size_type start_offset, stop_offset; 2274 unsigned int opb = bfd_octets_per_byte (abfd); 2275 2276 for (section = abfd->sections; section != NULL; section = 2277 section->next) 2278 { 2279 int onaline = 16; 2280 2281 if (only == (char *) NULL || 2282 strcmp (only, section->name) == 0) 2283 { 2284 if (section->flags & SEC_HAS_CONTENTS) 2285 { 2286 printf (_("Contents of section %s:\n"), section->name); 2287 2288 if (bfd_section_size (abfd, section) == 0) 2289 continue; 2290 data = (bfd_byte *) xmalloc ((size_t) bfd_section_size (abfd, section)); 2291 datasize = bfd_section_size (abfd, section); 2292 2293 2294 bfd_get_section_contents (abfd, section, (PTR) data, 0, bfd_section_size (abfd, section)); 2295 2296 if (start_address == (bfd_vma) -1 2297 || start_address < section->vma) 2298 start_offset = 0; 2299 else 2300 start_offset = start_address - section->vma; 2301 if (stop_address == (bfd_vma) -1) 2302 stop_offset = bfd_section_size (abfd, section) / opb; 2303 else 2304 { 2305 if (stop_address < section->vma) 2306 stop_offset = 0; 2307 else 2308 stop_offset = stop_address - section->vma; 2309 if (stop_offset > bfd_section_size (abfd, section) / opb) 2310 stop_offset = bfd_section_size (abfd, section) / opb; 2311 } 2312 for (addr_offset = start_offset; 2313 addr_offset < stop_offset; addr_offset += onaline) 2314 { 2315 bfd_size_type j; 2316 2317 printf (" %04lx ", (unsigned long int) 2318 (addr_offset + section->vma)); 2319 for (j = addr_offset * opb; 2320 j < addr_offset * opb + onaline; j++) 2321 { 2322 if (j < stop_offset * opb) 2323 printf ("%02x", (unsigned) (data[j])); 2324 else 2325 printf (" "); 2326 if ((j & 3) == 3) 2327 printf (" "); 2328 } 2329 2330 printf (" "); 2331 for (j = addr_offset; j < addr_offset * opb + onaline; j++) 2332 { 2333 if (j >= stop_offset * opb) 2334 printf (" "); 2335 else 2336 printf ("%c", isprint (data[j]) ? data[j] : '.'); 2337 } 2338 putchar ('\n'); 2339 } 2340 free (data); 2341 } 2342 } 2343 } 2344} 2345 2346/* Should perhaps share code and display with nm? */ 2347static void 2348dump_symbols (abfd, dynamic) 2349 bfd *abfd ATTRIBUTE_UNUSED; 2350 boolean dynamic; 2351{ 2352 asymbol **current; 2353 long max; 2354 long count; 2355 2356 if (dynamic) 2357 { 2358 current = dynsyms; 2359 max = dynsymcount; 2360 if (max == 0) 2361 return; 2362 printf ("DYNAMIC SYMBOL TABLE:\n"); 2363 } 2364 else 2365 { 2366 current = syms; 2367 max = symcount; 2368 if (max == 0) 2369 return; 2370 printf ("SYMBOL TABLE:\n"); 2371 } 2372 2373 for (count = 0; count < max; count++) 2374 { 2375 if (*current) 2376 { 2377 bfd *cur_bfd = bfd_asymbol_bfd (*current); 2378 2379 if (cur_bfd != NULL) 2380 { 2381 const char *name; 2382 char *alloc; 2383 2384 name = bfd_asymbol_name (*current); 2385 alloc = NULL; 2386 if (do_demangle && name != NULL && *name != '\0') 2387 { 2388 const char *n; 2389 2390 /* If we want to demangle the name, we demangle it 2391 here, and temporarily clobber it while calling 2392 bfd_print_symbol. FIXME: This is a gross hack. */ 2393 2394 n = name; 2395 if (bfd_get_symbol_leading_char (cur_bfd) == *n) 2396 ++n; 2397 alloc = cplus_demangle (n, DMGL_ANSI | DMGL_PARAMS); 2398 if (alloc != NULL) 2399 (*current)->name = alloc; 2400 else 2401 (*current)->name = n; 2402 } 2403 2404 bfd_print_symbol (cur_bfd, stdout, *current, 2405 bfd_print_symbol_all); 2406 2407 (*current)->name = name; 2408 if (alloc != NULL) 2409 free (alloc); 2410 2411 printf ("\n"); 2412 } 2413 } 2414 current++; 2415 } 2416 printf ("\n"); 2417 printf ("\n"); 2418} 2419 2420static void 2421dump_relocs (abfd) 2422 bfd *abfd; 2423{ 2424 arelent **relpp; 2425 long relcount; 2426 asection *a; 2427 2428 for (a = abfd->sections; a != (asection *) NULL; a = a->next) 2429 { 2430 long relsize; 2431 2432 if (bfd_is_abs_section (a)) 2433 continue; 2434 if (bfd_is_und_section (a)) 2435 continue; 2436 if (bfd_is_com_section (a)) 2437 continue; 2438 2439 if (only) 2440 { 2441 if (strcmp (only, a->name)) 2442 continue; 2443 } 2444 else if ((a->flags & SEC_RELOC) == 0) 2445 continue; 2446 2447 relsize = bfd_get_reloc_upper_bound (abfd, a); 2448 if (relsize < 0) 2449 bfd_fatal (bfd_get_filename (abfd)); 2450 2451 printf ("RELOCATION RECORDS FOR [%s]:", a->name); 2452 2453 if (relsize == 0) 2454 { 2455 printf (" (none)\n\n"); 2456 } 2457 else 2458 { 2459 relpp = (arelent **) xmalloc (relsize); 2460 relcount = bfd_canonicalize_reloc (abfd, a, relpp, syms); 2461 if (relcount < 0) 2462 bfd_fatal (bfd_get_filename (abfd)); 2463 else if (relcount == 0) 2464 { 2465 printf (" (none)\n\n"); 2466 } 2467 else 2468 { 2469 printf ("\n"); 2470 dump_reloc_set (abfd, a, relpp, relcount); 2471 printf ("\n\n"); 2472 } 2473 free (relpp); 2474 } 2475 } 2476} 2477 2478static void 2479dump_dynamic_relocs (abfd) 2480 bfd *abfd; 2481{ 2482 long relsize; 2483 arelent **relpp; 2484 long relcount; 2485 2486 relsize = bfd_get_dynamic_reloc_upper_bound (abfd); 2487 if (relsize < 0) 2488 bfd_fatal (bfd_get_filename (abfd)); 2489 2490 printf ("DYNAMIC RELOCATION RECORDS"); 2491 2492 if (relsize == 0) 2493 { 2494 printf (" (none)\n\n"); 2495 } 2496 else 2497 { 2498 relpp = (arelent **) xmalloc (relsize); 2499 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms); 2500 if (relcount < 0) 2501 bfd_fatal (bfd_get_filename (abfd)); 2502 else if (relcount == 0) 2503 { 2504 printf (" (none)\n\n"); 2505 } 2506 else 2507 { 2508 printf ("\n"); 2509 dump_reloc_set (abfd, (asection *) NULL, relpp, relcount); 2510 printf ("\n\n"); 2511 } 2512 free (relpp); 2513 } 2514} 2515 2516static void 2517dump_reloc_set (abfd, sec, relpp, relcount) 2518 bfd *abfd; 2519 asection *sec; 2520 arelent **relpp; 2521 long relcount; 2522{ 2523 arelent **p; 2524 char *last_filename, *last_functionname; 2525 unsigned int last_line; 2526 2527 /* Get column headers lined up reasonably. */ 2528 { 2529 static int width; 2530 if (width == 0) 2531 { 2532 char buf[30]; 2533 sprintf_vma (buf, (bfd_vma) -1); 2534 width = strlen (buf) - 7; 2535 } 2536 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, ""); 2537 } 2538 2539 last_filename = NULL; 2540 last_functionname = NULL; 2541 last_line = 0; 2542 2543 for (p = relpp; relcount && *p != (arelent *) NULL; p++, relcount--) 2544 { 2545 arelent *q = *p; 2546 const char *filename, *functionname; 2547 unsigned int line; 2548 const char *sym_name; 2549 const char *section_name; 2550 2551 if (start_address != (bfd_vma) -1 2552 && q->address < start_address) 2553 continue; 2554 if (stop_address != (bfd_vma) -1 2555 && q->address > stop_address) 2556 continue; 2557 2558 if (with_line_numbers 2559 && sec != NULL 2560 && bfd_find_nearest_line (abfd, sec, syms, q->address, 2561 &filename, &functionname, &line)) 2562 { 2563 if (functionname != NULL 2564 && (last_functionname == NULL 2565 || strcmp (functionname, last_functionname) != 0)) 2566 { 2567 printf ("%s():\n", functionname); 2568 if (last_functionname != NULL) 2569 free (last_functionname); 2570 last_functionname = xstrdup (functionname); 2571 } 2572 if (line > 0 2573 && (line != last_line 2574 || (filename != NULL 2575 && last_filename != NULL 2576 && strcmp (filename, last_filename) != 0))) 2577 { 2578 printf ("%s:%u\n", filename == NULL ? "???" : filename, line); 2579 last_line = line; 2580 if (last_filename != NULL) 2581 free (last_filename); 2582 if (filename == NULL) 2583 last_filename = NULL; 2584 else 2585 last_filename = xstrdup (filename); 2586 } 2587 } 2588 2589 if (q->sym_ptr_ptr && *q->sym_ptr_ptr) 2590 { 2591 sym_name = (*(q->sym_ptr_ptr))->name; 2592 section_name = (*(q->sym_ptr_ptr))->section->name; 2593 } 2594 else 2595 { 2596 sym_name = NULL; 2597 section_name = NULL; 2598 } 2599 if (sym_name) 2600 { 2601 printf_vma (q->address); 2602 if (q->howto->name) 2603 printf (" %-16s ", q->howto->name); 2604 else 2605 printf (" %-16d ", q->howto->type); 2606 objdump_print_symname (abfd, (struct disassemble_info *) NULL, 2607 *q->sym_ptr_ptr); 2608 } 2609 else 2610 { 2611 if (section_name == (CONST char *) NULL) 2612 section_name = "*unknown*"; 2613 printf_vma (q->address); 2614 printf (" %-16s [%s]", 2615 q->howto->name, 2616 section_name); 2617 } 2618 if (q->addend) 2619 { 2620 printf ("+0x"); 2621 printf_vma (q->addend); 2622 } 2623 printf ("\n"); 2624 } 2625} 2626 2627/* The length of the longest architecture name + 1. */ 2628#define LONGEST_ARCH sizeof("powerpc:common") 2629 2630static const char * 2631endian_string (endian) 2632 enum bfd_endian endian; 2633{ 2634 if (endian == BFD_ENDIAN_BIG) 2635 return "big endian"; 2636 else if (endian == BFD_ENDIAN_LITTLE) 2637 return "little endian"; 2638 else 2639 return "endianness unknown"; 2640} 2641 2642/* List the targets that BFD is configured to support, each followed 2643 by its endianness and the architectures it supports. */ 2644 2645static void 2646display_target_list () 2647{ 2648 extern const bfd_target *const *bfd_target_vector; 2649 char *dummy_name; 2650 int t; 2651 2652 dummy_name = make_temp_file (NULL); 2653 for (t = 0; bfd_target_vector[t]; t++) 2654 { 2655 const bfd_target *p = bfd_target_vector[t]; 2656 bfd *abfd = bfd_openw (dummy_name, p->name); 2657 int a; 2658 2659 printf ("%s\n (header %s, data %s)\n", p->name, 2660 endian_string (p->header_byteorder), 2661 endian_string (p->byteorder)); 2662 2663 if (abfd == NULL) 2664 { 2665 nonfatal (dummy_name); 2666 continue; 2667 } 2668 2669 if (! bfd_set_format (abfd, bfd_object)) 2670 { 2671 if (bfd_get_error () != bfd_error_invalid_operation) 2672 nonfatal (p->name); 2673 bfd_close_all_done (abfd); 2674 continue; 2675 } 2676 2677 for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++) 2678 if (bfd_set_arch_mach (abfd, (enum bfd_architecture) a, 0)) 2679 printf (" %s\n", 2680 bfd_printable_arch_mach ((enum bfd_architecture) a, 0)); 2681 bfd_close_all_done (abfd); 2682 } 2683 unlink (dummy_name); 2684 free (dummy_name); 2685} 2686 2687/* Print a table showing which architectures are supported for entries 2688 FIRST through LAST-1 of bfd_target_vector (targets across, 2689 architectures down). */ 2690 2691static void 2692display_info_table (first, last) 2693 int first; 2694 int last; 2695{ 2696 extern const bfd_target *const *bfd_target_vector; 2697 int t, a; 2698 char *dummy_name; 2699 2700 /* Print heading of target names. */ 2701 printf ("\n%*s", (int) LONGEST_ARCH, " "); 2702 for (t = first; t < last && bfd_target_vector[t]; t++) 2703 printf ("%s ", bfd_target_vector[t]->name); 2704 putchar ('\n'); 2705 2706 dummy_name = make_temp_file (NULL); 2707 for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++) 2708 if (strcmp (bfd_printable_arch_mach (a, 0), "UNKNOWN!") != 0) 2709 { 2710 printf ("%*s ", (int) LONGEST_ARCH - 1, 2711 bfd_printable_arch_mach (a, 0)); 2712 for (t = first; t < last && bfd_target_vector[t]; t++) 2713 { 2714 const bfd_target *p = bfd_target_vector[t]; 2715 boolean ok = true; 2716 bfd *abfd = bfd_openw (dummy_name, p->name); 2717 2718 if (abfd == NULL) 2719 { 2720 nonfatal (p->name); 2721 ok = false; 2722 } 2723 2724 if (ok) 2725 { 2726 if (! bfd_set_format (abfd, bfd_object)) 2727 { 2728 if (bfd_get_error () != bfd_error_invalid_operation) 2729 nonfatal (p->name); 2730 ok = false; 2731 } 2732 } 2733 2734 if (ok) 2735 { 2736 if (! bfd_set_arch_mach (abfd, a, 0)) 2737 ok = false; 2738 } 2739 2740 if (ok) 2741 printf ("%s ", p->name); 2742 else 2743 { 2744 int l = strlen (p->name); 2745 while (l--) 2746 putchar ('-'); 2747 putchar (' '); 2748 } 2749 if (abfd != NULL) 2750 bfd_close_all_done (abfd); 2751 } 2752 putchar ('\n'); 2753 } 2754 unlink (dummy_name); 2755 free (dummy_name); 2756} 2757 2758/* Print tables of all the target-architecture combinations that 2759 BFD has been configured to support. */ 2760 2761static void 2762display_target_tables () 2763{ 2764 int t, columns; 2765 extern const bfd_target *const *bfd_target_vector; 2766 char *colum; 2767 2768 columns = 0; 2769 colum = getenv ("COLUMNS"); 2770 if (colum != NULL) 2771 columns = atoi (colum); 2772 if (columns == 0) 2773 columns = 80; 2774 2775 t = 0; 2776 while (bfd_target_vector[t] != NULL) 2777 { 2778 int oldt = t, wid; 2779 2780 wid = LONGEST_ARCH + strlen (bfd_target_vector[t]->name) + 1; 2781 ++t; 2782 while (wid < columns && bfd_target_vector[t] != NULL) 2783 { 2784 int newwid; 2785 2786 newwid = wid + strlen (bfd_target_vector[t]->name) + 1; 2787 if (newwid >= columns) 2788 break; 2789 wid = newwid; 2790 ++t; 2791 } 2792 display_info_table (oldt, t); 2793 } 2794} 2795 2796static void 2797display_info () 2798{ 2799 printf (_("BFD header file version %s\n"), BFD_VERSION); 2800 display_target_list (); 2801 display_target_tables (); 2802} 2803 2804int 2805main (argc, argv) 2806 int argc; 2807 char **argv; 2808{ 2809 int c; 2810 char *target = default_target; 2811 boolean seenflag = false; 2812 2813#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES) 2814 setlocale (LC_MESSAGES, ""); 2815#endif 2816 bindtextdomain (PACKAGE, LOCALEDIR); 2817 textdomain (PACKAGE); 2818 2819 program_name = *argv; 2820 xmalloc_set_program_name (program_name); 2821 2822 START_PROGRESS (program_name, 0); 2823 2824 bfd_init (); 2825 set_default_bfd_target (); 2826 2827 while ((c = getopt_long (argc, argv, "pib:m:M:VCdDlfahHrRtTxsSj:wE:zgG", 2828 long_options, (int *) 0)) 2829 != EOF) 2830 { 2831 switch (c) 2832 { 2833 case 0: 2834 break; /* we've been given a long option */ 2835 case 'm': 2836 machine = optarg; 2837 break; 2838 case 'M': 2839 disassembler_options = optarg; 2840 break; 2841 case 'j': 2842 only = optarg; 2843 break; 2844 case 'l': 2845 with_line_numbers = true; 2846 break; 2847 case 'b': 2848 target = optarg; 2849 break; 2850 case 'C': 2851 do_demangle = true; 2852 if (optarg != NULL) 2853 { 2854 enum demangling_styles style; 2855 2856 style = cplus_demangle_name_to_style (optarg); 2857 if (style == unknown_demangling) 2858 fatal (_("unknown demangling style `%s'"), 2859 optarg); 2860 2861 cplus_demangle_set_style (style); 2862 } 2863 break; 2864 case 'w': 2865 wide_output = true; 2866 break; 2867 case OPTION_ADJUST_VMA: 2868 adjust_section_vma = parse_vma (optarg, "--adjust-vma"); 2869 break; 2870 case OPTION_START_ADDRESS: 2871 start_address = parse_vma (optarg, "--start-address"); 2872 break; 2873 case OPTION_STOP_ADDRESS: 2874 stop_address = parse_vma (optarg, "--stop-address"); 2875 break; 2876 case 'E': 2877 if (strcmp (optarg, "B") == 0) 2878 endian = BFD_ENDIAN_BIG; 2879 else if (strcmp (optarg, "L") == 0) 2880 endian = BFD_ENDIAN_LITTLE; 2881 else 2882 { 2883 non_fatal (_("unrecognized -E option")); 2884 usage (stderr, 1); 2885 } 2886 break; 2887 case OPTION_ENDIAN: 2888 if (strncmp (optarg, "big", strlen (optarg)) == 0) 2889 endian = BFD_ENDIAN_BIG; 2890 else if (strncmp (optarg, "little", strlen (optarg)) == 0) 2891 endian = BFD_ENDIAN_LITTLE; 2892 else 2893 { 2894 non_fatal (_("unrecognized --endian type `%s'"), optarg); 2895 usage (stderr, 1); 2896 } 2897 break; 2898 2899 case 'f': 2900 dump_file_header = true; 2901 seenflag = true; 2902 break; 2903 case 'i': 2904 formats_info = true; 2905 seenflag = true; 2906 break; 2907 case 'p': 2908 dump_private_headers = true; 2909 seenflag = true; 2910 break; 2911 case 'x': 2912 dump_private_headers = true; 2913 dump_symtab = true; 2914 dump_reloc_info = true; 2915 dump_file_header = true; 2916 dump_ar_hdrs = true; 2917 dump_section_headers = true; 2918 seenflag = true; 2919 break; 2920 case 't': 2921 dump_symtab = true; 2922 seenflag = true; 2923 break; 2924 case 'T': 2925 dump_dynamic_symtab = true; 2926 seenflag = true; 2927 break; 2928 case 'd': 2929 disassemble = true; 2930 seenflag = true; 2931 break; 2932 case 'z': 2933 disassemble_zeroes = true; 2934 break; 2935 case 'D': 2936 disassemble = true; 2937 disassemble_all = true; 2938 seenflag = true; 2939 break; 2940 case 'S': 2941 disassemble = true; 2942 with_source_code = true; 2943 seenflag = true; 2944 break; 2945 case 'g': 2946 dump_debugging = 1; 2947 seenflag = true; 2948 break; 2949 case 'G': 2950 dump_stab_section_info = true; 2951 seenflag = true; 2952 break; 2953 case 's': 2954 dump_section_contents = true; 2955 seenflag = true; 2956 break; 2957 case 'r': 2958 dump_reloc_info = true; 2959 seenflag = true; 2960 break; 2961 case 'R': 2962 dump_dynamic_reloc_info = true; 2963 seenflag = true; 2964 break; 2965 case 'a': 2966 dump_ar_hdrs = true; 2967 seenflag = true; 2968 break; 2969 case 'h': 2970 dump_section_headers = true; 2971 seenflag = true; 2972 break; 2973 case 'H': 2974 usage (stdout, 0); 2975 seenflag = true; 2976 case 'V': 2977 show_version = true; 2978 seenflag = true; 2979 break; 2980 2981 default: 2982 usage (stderr, 1); 2983 } 2984 } 2985 2986 if (show_version) 2987 print_version ("objdump"); 2988 2989 if (seenflag == false) 2990 usage (stderr, 2); 2991 2992 if (formats_info) 2993 display_info (); 2994 else 2995 { 2996 if (optind == argc) 2997 display_file ("a.out", target); 2998 else 2999 for (; optind < argc;) 3000 display_file (argv[optind++], target); 3001 } 3002 3003 END_PROGRESS (program_name); 3004 3005 return exit_status; 3006} 3007