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