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