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