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 pinfo->symtab_pos = place; 1752 } 1753 else 1754 { 1755 pinfo->symbols = NULL; 1756 pinfo->num_symbols = 0; 1757 pinfo->symtab_pos = -1; 1758 } 1759 1760 if (! prefix_addresses) 1761 { 1762 pinfo->fprintf_func (pinfo->stream, "\n"); 1763 objdump_print_addr_with_sym (abfd, section, sym, addr, 1764 pinfo, FALSE); 1765 pinfo->fprintf_func (pinfo->stream, ":\n"); 1766 } 1767 1768 if (sym != NULL && bfd_asymbol_value (sym) > addr) 1769 nextsym = sym; 1770 else if (sym == NULL) 1771 nextsym = NULL; 1772 else 1773 { 1774#define is_valid_next_sym(SYM) \ 1775 ((SYM)->section == section \ 1776 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \ 1777 && pinfo->symbol_is_valid (SYM, pinfo)) 1778 1779 /* Search forward for the next appropriate symbol in 1780 SECTION. Note that all the symbols are sorted 1781 together into one big array, and that some sections 1782 may have overlapping addresses. */ 1783 while (place < sorted_symcount 1784 && ! is_valid_next_sym (sorted_syms [place])) 1785 ++place; 1786 1787 if (place >= sorted_symcount) 1788 nextsym = NULL; 1789 else 1790 nextsym = sorted_syms[place]; 1791 } 1792 1793 if (sym != NULL && bfd_asymbol_value (sym) > addr) 1794 nextstop_offset = bfd_asymbol_value (sym) - section->vma; 1795 else if (nextsym == NULL) 1796 nextstop_offset = stop_offset; 1797 else 1798 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma; 1799 1800 if (nextstop_offset > stop_offset) 1801 nextstop_offset = stop_offset; 1802 1803 /* If a symbol is explicitly marked as being an object 1804 rather than a function, just dump the bytes without 1805 disassembling them. */ 1806 if (disassemble_all 1807 || sym == NULL 1808 || bfd_asymbol_value (sym) > addr 1809 || ((sym->flags & BSF_OBJECT) == 0 1810 && (strstr (bfd_asymbol_name (sym), "gnu_compiled") 1811 == NULL) 1812 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled") 1813 == NULL)) 1814 || (sym->flags & BSF_FUNCTION) != 0) 1815 insns = TRUE; 1816 else 1817 insns = FALSE; 1818 1819 disassemble_bytes (pinfo, paux->disassemble_fn, insns, data, 1820 addr_offset, nextstop_offset, 1821 rel_offset, &rel_pp, rel_ppend); 1822 1823 addr_offset = nextstop_offset; 1824 sym = nextsym; 1825 } 1826 1827 free (data); 1828 1829 if (rel_ppstart != NULL) 1830 free (rel_ppstart); 1831} 1832 1833/* Disassemble the contents of an object file. */ 1834 1835static void 1836disassemble_data (bfd *abfd) 1837{ 1838 struct disassemble_info disasm_info; 1839 struct objdump_disasm_info aux; 1840 long i; 1841 1842 print_files = NULL; 1843 prev_functionname = NULL; 1844 prev_line = -1; 1845 1846 /* We make a copy of syms to sort. We don't want to sort syms 1847 because that will screw up the relocs. */ 1848 sorted_symcount = symcount ? symcount : dynsymcount; 1849 sorted_syms = xmalloc ((sorted_symcount + synthcount) * sizeof (asymbol *)); 1850 memcpy (sorted_syms, symcount ? syms : dynsyms, 1851 sorted_symcount * sizeof (asymbol *)); 1852 1853 sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount); 1854 1855 for (i = 0; i < synthcount; ++i) 1856 { 1857 sorted_syms[sorted_symcount] = synthsyms + i; 1858 ++sorted_symcount; 1859 } 1860 1861 /* Sort the symbols into section and symbol order. */ 1862 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols); 1863 1864 init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf); 1865 1866 disasm_info.application_data = (void *) &aux; 1867 aux.abfd = abfd; 1868 aux.require_sec = FALSE; 1869 aux.dynrelbuf = NULL; 1870 aux.dynrelcount = 0; 1871 aux.reloc = NULL; 1872 1873 disasm_info.print_address_func = objdump_print_address; 1874 disasm_info.symbol_at_address_func = objdump_symbol_at_address; 1875 1876 if (machine != NULL) 1877 { 1878 const bfd_arch_info_type *info = bfd_scan_arch (machine); 1879 1880 if (info == NULL) 1881 fatal (_("Can't use supplied machine %s"), machine); 1882 1883 abfd->arch_info = info; 1884 } 1885 1886 if (endian != BFD_ENDIAN_UNKNOWN) 1887 { 1888 struct bfd_target *xvec; 1889 1890 xvec = xmalloc (sizeof (struct bfd_target)); 1891 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target)); 1892 xvec->byteorder = endian; 1893 abfd->xvec = xvec; 1894 } 1895 1896 /* Use libopcodes to locate a suitable disassembler. */ 1897 aux.disassemble_fn = disassembler (abfd); 1898 if (!aux.disassemble_fn) 1899 { 1900 non_fatal (_("Can't disassemble for architecture %s\n"), 1901 bfd_printable_arch_mach (bfd_get_arch (abfd), 0)); 1902 exit_status = 1; 1903 return; 1904 } 1905 1906 disasm_info.flavour = bfd_get_flavour (abfd); 1907 disasm_info.arch = bfd_get_arch (abfd); 1908 disasm_info.mach = bfd_get_mach (abfd); 1909 disasm_info.disassembler_options = disassembler_options; 1910 disasm_info.octets_per_byte = bfd_octets_per_byte (abfd); 1911 disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES; 1912 disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END; 1913 disasm_info.disassembler_needs_relocs = FALSE; 1914 1915 if (bfd_big_endian (abfd)) 1916 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG; 1917 else if (bfd_little_endian (abfd)) 1918 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE; 1919 else 1920 /* ??? Aborting here seems too drastic. We could default to big or little 1921 instead. */ 1922 disasm_info.endian = BFD_ENDIAN_UNKNOWN; 1923 1924 /* Allow the target to customize the info structure. */ 1925 disassemble_init_for_target (& disasm_info); 1926 1927 /* Pre-load the dynamic relocs if we are going 1928 to be dumping them along with the disassembly. */ 1929 if (dump_dynamic_reloc_info) 1930 { 1931 long relsize = bfd_get_dynamic_reloc_upper_bound (abfd); 1932 1933 if (relsize < 0) 1934 bfd_fatal (bfd_get_filename (abfd)); 1935 1936 if (relsize > 0) 1937 { 1938 aux.dynrelbuf = xmalloc (relsize); 1939 aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd, 1940 aux.dynrelbuf, 1941 dynsyms); 1942 if (aux.dynrelcount < 0) 1943 bfd_fatal (bfd_get_filename (abfd)); 1944 1945 /* Sort the relocs by address. */ 1946 qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *), 1947 compare_relocs); 1948 } 1949 } 1950 disasm_info.symtab = sorted_syms; 1951 disasm_info.symtab_size = sorted_symcount; 1952 1953 bfd_map_over_sections (abfd, disassemble_section, & disasm_info); 1954 1955 if (aux.dynrelbuf != NULL) 1956 free (aux.dynrelbuf); 1957 free (sorted_syms); 1958} 1959 1960int 1961load_debug_section (enum dwarf_section_display_enum debug, void *file) 1962{ 1963 struct dwarf_section *section = &debug_displays [debug].section; 1964 bfd *abfd = file; 1965 asection *sec; 1966 bfd_boolean ret; 1967 1968 /* If it is already loaded, do nothing. */ 1969 if (section->start != NULL) 1970 return 1; 1971 1972 /* Locate the debug section. */ 1973 sec = bfd_get_section_by_name (abfd, section->name); 1974 if (sec == NULL) 1975 return 0; 1976 1977 section->address = bfd_get_section_vma (abfd, sec); 1978 section->size = bfd_get_section_size (sec); 1979 section->start = xmalloc (section->size); 1980 1981 if (is_relocatable && debug_displays [debug].relocate) 1982 ret = bfd_simple_get_relocated_section_contents (abfd, 1983 sec, 1984 section->start, 1985 syms) != NULL; 1986 else 1987 ret = bfd_get_section_contents (abfd, sec, section->start, 0, 1988 section->size); 1989 1990 if (!ret) 1991 { 1992 free_debug_section (debug); 1993 printf (_("\nCan't get contents for section '%s'.\n"), 1994 section->name); 1995 } 1996 1997 return ret; 1998} 1999 2000void 2001free_debug_section (enum dwarf_section_display_enum debug) 2002{ 2003 struct dwarf_section *section = &debug_displays [debug].section; 2004 2005 if (section->start == NULL) 2006 return; 2007 2008 free ((char *) section->start); 2009 section->start = NULL; 2010 section->address = 0; 2011 section->size = 0; 2012} 2013 2014static void 2015dump_dwarf_section (bfd *abfd, asection *section, 2016 void *arg ATTRIBUTE_UNUSED) 2017{ 2018 const char *name = bfd_get_section_name (abfd, section); 2019 const char *match; 2020 enum dwarf_section_display_enum i; 2021 2022 if (CONST_STRNEQ (name, ".gnu.linkonce.wi.")) 2023 match = ".debug_info"; 2024 else 2025 match = name; 2026 2027 for (i = 0; i < max; i++) 2028 if (strcmp (debug_displays[i].section.name, match) == 0) 2029 { 2030 if (!debug_displays[i].eh_frame) 2031 { 2032 struct dwarf_section *sec = &debug_displays [i].section; 2033 2034 if (load_debug_section (i, abfd)) 2035 { 2036 debug_displays[i].display (sec, abfd); 2037 2038 if (i != info && i != abbrev) 2039 free_debug_section (i); 2040 } 2041 } 2042 break; 2043 } 2044} 2045 2046static const char *mach_o_dwarf_sections [] = { 2047 "LC_SEGMENT.__DWARFA.__debug_abbrev", /* .debug_abbrev */ 2048 "LC_SEGMENT.__DWARFA.__debug_aranges", /* .debug_aranges */ 2049 "LC_SEGMENT.__DWARFA.__debug_frame", /* .debug_frame */ 2050 "LC_SEGMENT.__DWARFA.__debug_info", /* .debug_info */ 2051 "LC_SEGMENT.__DWARFA.__debug_line", /* .debug_line */ 2052 "LC_SEGMENT.__DWARFA.__debug_pubnames", /* .debug_pubnames */ 2053 ".eh_frame", /* .eh_frame */ 2054 "LC_SEGMENT.__DWARFA.__debug_macinfo", /* .debug_macinfo */ 2055 "LC_SEGMENT.__DWARFA.__debug_str", /* .debug_str */ 2056 "LC_SEGMENT.__DWARFA.__debug_loc", /* .debug_loc */ 2057 "LC_SEGMENT.__DWARFA.__debug_pubtypes", /* .debug_pubtypes */ 2058 "LC_SEGMENT.__DWARFA.__debug_ranges", /* .debug_ranges */ 2059 "LC_SEGMENT.__DWARFA.__debug_static_func", /* .debug_static_func */ 2060 "LC_SEGMENT.__DWARFA.__debug_static_vars", /* .debug_static_vars */ 2061 "LC_SEGMENT.__DWARFA.__debug_types", /* .debug_types */ 2062 "LC_SEGMENT.__DWARFA.__debug_weaknames" /* .debug_weaknames */ 2063}; 2064 2065static const char *generic_dwarf_sections [max]; 2066 2067static void 2068check_mach_o_dwarf (bfd *abfd) 2069{ 2070 static enum bfd_flavour old_flavour = bfd_target_unknown_flavour; 2071 enum bfd_flavour current_flavour = bfd_get_flavour (abfd); 2072 enum dwarf_section_display_enum i; 2073 2074 if (generic_dwarf_sections [0] == NULL) 2075 for (i = 0; i < max; i++) 2076 generic_dwarf_sections [i] = debug_displays[i].section.name; 2077 2078 if (old_flavour != current_flavour) 2079 { 2080 if (current_flavour == bfd_target_mach_o_flavour) 2081 for (i = 0; i < max; i++) 2082 debug_displays[i].section.name = mach_o_dwarf_sections [i]; 2083 else if (old_flavour == bfd_target_mach_o_flavour) 2084 for (i = 0; i < max; i++) 2085 debug_displays[i].section.name = generic_dwarf_sections [i]; 2086 2087 old_flavour = current_flavour; 2088 } 2089} 2090 2091/* Dump the dwarf debugging information. */ 2092 2093static void 2094dump_dwarf (bfd *abfd) 2095{ 2096 is_relocatable = ((abfd->flags & (HAS_RELOC | EXEC_P | DYNAMIC)) 2097 == HAS_RELOC); 2098 2099 /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit 2100 targets will return 64. */ 2101 eh_addr_size = bfd_get_arch_size (abfd) == 64 ? 8 : 4; 2102 2103 if (bfd_big_endian (abfd)) 2104 byte_get = byte_get_big_endian; 2105 else if (bfd_little_endian (abfd)) 2106 byte_get = byte_get_little_endian; 2107 else 2108 abort (); 2109 2110 check_mach_o_dwarf (abfd); 2111 2112 bfd_map_over_sections (abfd, dump_dwarf_section, NULL); 2113 2114 free_debug_memory (); 2115} 2116 2117/* Read ABFD's stabs section STABSECT_NAME, and return a pointer to 2118 it. Return NULL on failure. */ 2119 2120static char * 2121read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr) 2122{ 2123 asection *stabsect; 2124 bfd_size_type size; 2125 char *contents; 2126 2127 stabsect = bfd_get_section_by_name (abfd, sect_name); 2128 if (stabsect == NULL) 2129 { 2130 printf (_("No %s section present\n\n"), sect_name); 2131 return FALSE; 2132 } 2133 2134 size = bfd_section_size (abfd, stabsect); 2135 contents = xmalloc (size); 2136 2137 if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size)) 2138 { 2139 non_fatal (_("Reading %s section of %s failed: %s"), 2140 sect_name, bfd_get_filename (abfd), 2141 bfd_errmsg (bfd_get_error ())); 2142 free (contents); 2143 exit_status = 1; 2144 return NULL; 2145 } 2146 2147 *size_ptr = size; 2148 2149 return contents; 2150} 2151 2152/* Stabs entries use a 12 byte format: 2153 4 byte string table index 2154 1 byte stab type 2155 1 byte stab other field 2156 2 byte stab desc field 2157 4 byte stab value 2158 FIXME: This will have to change for a 64 bit object format. */ 2159 2160#define STRDXOFF (0) 2161#define TYPEOFF (4) 2162#define OTHEROFF (5) 2163#define DESCOFF (6) 2164#define VALOFF (8) 2165#define STABSIZE (12) 2166 2167/* Print ABFD's stabs section STABSECT_NAME (in `stabs'), 2168 using string table section STRSECT_NAME (in `strtab'). */ 2169 2170static void 2171print_section_stabs (bfd *abfd, 2172 const char *stabsect_name, 2173 unsigned *string_offset_ptr) 2174{ 2175 int i; 2176 unsigned file_string_table_offset = 0; 2177 unsigned next_file_string_table_offset = *string_offset_ptr; 2178 bfd_byte *stabp, *stabs_end; 2179 2180 stabp = stabs; 2181 stabs_end = stabp + stab_size; 2182 2183 printf (_("Contents of %s section:\n\n"), stabsect_name); 2184 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n"); 2185 2186 /* Loop through all symbols and print them. 2187 2188 We start the index at -1 because there is a dummy symbol on 2189 the front of stabs-in-{coff,elf} sections that supplies sizes. */ 2190 for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++) 2191 { 2192 const char *name; 2193 unsigned long strx; 2194 unsigned char type, other; 2195 unsigned short desc; 2196 bfd_vma value; 2197 2198 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF); 2199 type = bfd_h_get_8 (abfd, stabp + TYPEOFF); 2200 other = bfd_h_get_8 (abfd, stabp + OTHEROFF); 2201 desc = bfd_h_get_16 (abfd, stabp + DESCOFF); 2202 value = bfd_h_get_32 (abfd, stabp + VALOFF); 2203 2204 printf ("\n%-6d ", i); 2205 /* Either print the stab name, or, if unnamed, print its number 2206 again (makes consistent formatting for tools like awk). */ 2207 name = bfd_get_stab_name (type); 2208 if (name != NULL) 2209 printf ("%-6s", name); 2210 else if (type == N_UNDF) 2211 printf ("HdrSym"); 2212 else 2213 printf ("%-6d", type); 2214 printf (" %-6d %-6d ", other, desc); 2215 bfd_printf_vma (abfd, value); 2216 printf (" %-6lu", strx); 2217 2218 /* Symbols with type == 0 (N_UNDF) specify the length of the 2219 string table associated with this file. We use that info 2220 to know how to relocate the *next* file's string table indices. */ 2221 if (type == N_UNDF) 2222 { 2223 file_string_table_offset = next_file_string_table_offset; 2224 next_file_string_table_offset += value; 2225 } 2226 else 2227 { 2228 /* Using the (possibly updated) string table offset, print the 2229 string (if any) associated with this symbol. */ 2230 if ((strx + file_string_table_offset) < stabstr_size) 2231 printf (" %s", &strtab[strx + file_string_table_offset]); 2232 else 2233 printf (" *"); 2234 } 2235 } 2236 printf ("\n\n"); 2237 *string_offset_ptr = next_file_string_table_offset; 2238} 2239 2240typedef struct 2241{ 2242 const char * section_name; 2243 const char * string_section_name; 2244 unsigned string_offset; 2245} 2246stab_section_names; 2247 2248static void 2249find_stabs_section (bfd *abfd, asection *section, void *names) 2250{ 2251 int len; 2252 stab_section_names * sought = (stab_section_names *) names; 2253 2254 /* Check for section names for which stabsect_name is a prefix, to 2255 handle .stab.N, etc. */ 2256 len = strlen (sought->section_name); 2257 2258 /* If the prefix matches, and the files section name ends with a 2259 nul or a digit, then we match. I.e., we want either an exact 2260 match or a section followed by a number. */ 2261 if (strncmp (sought->section_name, section->name, len) == 0 2262 && (section->name[len] == 0 2263 || (section->name[len] == '.' && ISDIGIT (section->name[len + 1])))) 2264 { 2265 if (strtab == NULL) 2266 strtab = read_section_stabs (abfd, sought->string_section_name, 2267 &stabstr_size); 2268 2269 if (strtab) 2270 { 2271 stabs = (bfd_byte *) read_section_stabs (abfd, section->name, 2272 &stab_size); 2273 if (stabs) 2274 print_section_stabs (abfd, section->name, &sought->string_offset); 2275 } 2276 } 2277} 2278 2279static void 2280dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name) 2281{ 2282 stab_section_names s; 2283 2284 s.section_name = stabsect_name; 2285 s.string_section_name = strsect_name; 2286 s.string_offset = 0; 2287 2288 bfd_map_over_sections (abfd, find_stabs_section, & s); 2289 2290 free (strtab); 2291 strtab = NULL; 2292} 2293 2294/* Dump the any sections containing stabs debugging information. */ 2295 2296static void 2297dump_stabs (bfd *abfd) 2298{ 2299 dump_stabs_section (abfd, ".stab", ".stabstr"); 2300 dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr"); 2301 dump_stabs_section (abfd, ".stab.index", ".stab.indexstr"); 2302 dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$"); 2303} 2304 2305static void 2306dump_bfd_header (bfd *abfd) 2307{ 2308 char *comma = ""; 2309 2310 printf (_("architecture: %s, "), 2311 bfd_printable_arch_mach (bfd_get_arch (abfd), 2312 bfd_get_mach (abfd))); 2313 printf (_("flags 0x%08x:\n"), abfd->flags); 2314 2315#define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";} 2316 PF (HAS_RELOC, "HAS_RELOC"); 2317 PF (EXEC_P, "EXEC_P"); 2318 PF (HAS_LINENO, "HAS_LINENO"); 2319 PF (HAS_DEBUG, "HAS_DEBUG"); 2320 PF (HAS_SYMS, "HAS_SYMS"); 2321 PF (HAS_LOCALS, "HAS_LOCALS"); 2322 PF (DYNAMIC, "DYNAMIC"); 2323 PF (WP_TEXT, "WP_TEXT"); 2324 PF (D_PAGED, "D_PAGED"); 2325 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE"); 2326 PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE"); 2327 printf (_("\nstart address 0x")); 2328 bfd_printf_vma (abfd, abfd->start_address); 2329 printf ("\n"); 2330} 2331 2332 2333static void 2334dump_bfd_private_header (bfd *abfd) 2335{ 2336 bfd_print_private_bfd_data (abfd, stdout); 2337} 2338 2339 2340/* Display a section in hexadecimal format with associated characters. 2341 Each line prefixed by the zero padded address. */ 2342 2343static void 2344dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED) 2345{ 2346 bfd_byte *data = 0; 2347 bfd_size_type datasize; 2348 bfd_size_type addr_offset; 2349 bfd_size_type start_offset; 2350 bfd_size_type stop_offset; 2351 unsigned int opb = bfd_octets_per_byte (abfd); 2352 /* Bytes per line. */ 2353 const int onaline = 16; 2354 char buf[64]; 2355 int count; 2356 int width; 2357 2358 if ((section->flags & SEC_HAS_CONTENTS) == 0) 2359 return; 2360 2361 if (! process_section_p (section)) 2362 return; 2363 2364 if ((datasize = bfd_section_size (abfd, section)) == 0) 2365 return; 2366 2367 printf (_("Contents of section %s:\n"), section->name); 2368 2369 data = xmalloc (datasize); 2370 2371 bfd_get_section_contents (abfd, section, data, 0, datasize); 2372 2373 /* Compute the address range to display. */ 2374 if (start_address == (bfd_vma) -1 2375 || start_address < section->vma) 2376 start_offset = 0; 2377 else 2378 start_offset = start_address - section->vma; 2379 2380 if (stop_address == (bfd_vma) -1) 2381 stop_offset = datasize / opb; 2382 else 2383 { 2384 if (stop_address < section->vma) 2385 stop_offset = 0; 2386 else 2387 stop_offset = stop_address - section->vma; 2388 2389 if (stop_offset > datasize / opb) 2390 stop_offset = datasize / opb; 2391 } 2392 2393 width = 4; 2394 2395 bfd_sprintf_vma (abfd, buf, start_offset + section->vma); 2396 if (strlen (buf) >= sizeof (buf)) 2397 abort (); 2398 2399 count = 0; 2400 while (buf[count] == '0' && buf[count+1] != '\0') 2401 count++; 2402 count = strlen (buf) - count; 2403 if (count > width) 2404 width = count; 2405 2406 bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1); 2407 if (strlen (buf) >= sizeof (buf)) 2408 abort (); 2409 2410 count = 0; 2411 while (buf[count] == '0' && buf[count+1] != '\0') 2412 count++; 2413 count = strlen (buf) - count; 2414 if (count > width) 2415 width = count; 2416 2417 for (addr_offset = start_offset; 2418 addr_offset < stop_offset; addr_offset += onaline / opb) 2419 { 2420 bfd_size_type j; 2421 2422 bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma)); 2423 count = strlen (buf); 2424 if ((size_t) count >= sizeof (buf)) 2425 abort (); 2426 2427 putchar (' '); 2428 while (count < width) 2429 { 2430 putchar ('0'); 2431 count++; 2432 } 2433 fputs (buf + count - width, stdout); 2434 putchar (' '); 2435 2436 for (j = addr_offset * opb; 2437 j < addr_offset * opb + onaline; j++) 2438 { 2439 if (j < stop_offset * opb) 2440 printf ("%02x", (unsigned) (data[j])); 2441 else 2442 printf (" "); 2443 if ((j & 3) == 3) 2444 printf (" "); 2445 } 2446 2447 printf (" "); 2448 for (j = addr_offset * opb; 2449 j < addr_offset * opb + onaline; j++) 2450 { 2451 if (j >= stop_offset * opb) 2452 printf (" "); 2453 else 2454 printf ("%c", ISPRINT (data[j]) ? data[j] : '.'); 2455 } 2456 putchar ('\n'); 2457 } 2458 free (data); 2459} 2460 2461/* Actually display the various requested regions. */ 2462 2463static void 2464dump_data (bfd *abfd) 2465{ 2466 bfd_map_over_sections (abfd, dump_section, NULL); 2467} 2468 2469/* Should perhaps share code and display with nm? */ 2470 2471static void 2472dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic) 2473{ 2474 asymbol **current; 2475 long max; 2476 long count; 2477 2478 if (dynamic) 2479 { 2480 current = dynsyms; 2481 max = dynsymcount; 2482 printf ("DYNAMIC SYMBOL TABLE:\n"); 2483 } 2484 else 2485 { 2486 current = syms; 2487 max = symcount; 2488 printf ("SYMBOL TABLE:\n"); 2489 } 2490 2491 if (max == 0) 2492 printf (_("no symbols\n")); 2493 2494 for (count = 0; count < max; count++) 2495 { 2496 bfd *cur_bfd; 2497 2498 if (*current == NULL) 2499 printf (_("no information for symbol number %ld\n"), count); 2500 2501 else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL) 2502 printf (_("could not determine the type of symbol number %ld\n"), 2503 count); 2504 2505 else if (process_section_p ((* current)->section) 2506 && (dump_special_syms 2507 || !bfd_is_target_special_symbol (cur_bfd, *current))) 2508 { 2509 const char *name = (*current)->name; 2510 2511 if (do_demangle && name != NULL && *name != '\0') 2512 { 2513 char *alloc; 2514 2515 /* If we want to demangle the name, we demangle it 2516 here, and temporarily clobber it while calling 2517 bfd_print_symbol. FIXME: This is a gross hack. */ 2518 alloc = demangle (cur_bfd, name); 2519 (*current)->name = alloc; 2520 bfd_print_symbol (cur_bfd, stdout, *current, 2521 bfd_print_symbol_all); 2522 (*current)->name = name; 2523 free (alloc); 2524 } 2525 else 2526 bfd_print_symbol (cur_bfd, stdout, *current, 2527 bfd_print_symbol_all); 2528 printf ("\n"); 2529 } 2530 2531 current++; 2532 } 2533 printf ("\n\n"); 2534} 2535 2536static void 2537dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount) 2538{ 2539 arelent **p; 2540 char *last_filename, *last_functionname; 2541 unsigned int last_line; 2542 2543 /* Get column headers lined up reasonably. */ 2544 { 2545 static int width; 2546 2547 if (width == 0) 2548 { 2549 char buf[30]; 2550 2551 bfd_sprintf_vma (abfd, buf, (bfd_vma) -1); 2552 width = strlen (buf) - 7; 2553 } 2554 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, ""); 2555 } 2556 2557 last_filename = NULL; 2558 last_functionname = NULL; 2559 last_line = 0; 2560 2561 for (p = relpp; relcount && *p != NULL; p++, relcount--) 2562 { 2563 arelent *q = *p; 2564 const char *filename, *functionname; 2565 unsigned int line; 2566 const char *sym_name; 2567 const char *section_name; 2568 2569 if (start_address != (bfd_vma) -1 2570 && q->address < start_address) 2571 continue; 2572 if (stop_address != (bfd_vma) -1 2573 && q->address > stop_address) 2574 continue; 2575 2576 if (with_line_numbers 2577 && sec != NULL 2578 && bfd_find_nearest_line (abfd, sec, syms, q->address, 2579 &filename, &functionname, &line)) 2580 { 2581 if (functionname != NULL 2582 && (last_functionname == NULL 2583 || strcmp (functionname, last_functionname) != 0)) 2584 { 2585 printf ("%s():\n", functionname); 2586 if (last_functionname != NULL) 2587 free (last_functionname); 2588 last_functionname = xstrdup (functionname); 2589 } 2590 2591 if (line > 0 2592 && (line != last_line 2593 || (filename != NULL 2594 && last_filename != NULL 2595 && strcmp (filename, last_filename) != 0))) 2596 { 2597 printf ("%s:%u\n", filename == NULL ? "???" : filename, line); 2598 last_line = line; 2599 if (last_filename != NULL) 2600 free (last_filename); 2601 if (filename == NULL) 2602 last_filename = NULL; 2603 else 2604 last_filename = xstrdup (filename); 2605 } 2606 } 2607 2608 if (q->sym_ptr_ptr && *q->sym_ptr_ptr) 2609 { 2610 sym_name = (*(q->sym_ptr_ptr))->name; 2611 section_name = (*(q->sym_ptr_ptr))->section->name; 2612 } 2613 else 2614 { 2615 sym_name = NULL; 2616 section_name = NULL; 2617 } 2618 2619 bfd_printf_vma (abfd, q->address); 2620 if (q->howto == NULL) 2621 printf (" *unknown* "); 2622 else if (q->howto->name) 2623 printf (" %-16s ", q->howto->name); 2624 else 2625 printf (" %-16d ", q->howto->type); 2626 if (sym_name) 2627 objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr); 2628 else 2629 { 2630 if (section_name == NULL) 2631 section_name = "*unknown*"; 2632 printf ("[%s]", section_name); 2633 } 2634 2635 if (q->addend) 2636 { 2637 printf ("+0x"); 2638 bfd_printf_vma (abfd, q->addend); 2639 } 2640 2641 printf ("\n"); 2642 } 2643} 2644 2645static void 2646dump_relocs_in_section (bfd *abfd, 2647 asection *section, 2648 void *dummy ATTRIBUTE_UNUSED) 2649{ 2650 arelent **relpp; 2651 long relcount; 2652 long relsize; 2653 2654 if ( bfd_is_abs_section (section) 2655 || bfd_is_und_section (section) 2656 || bfd_is_com_section (section) 2657 || (! process_section_p (section)) 2658 || ((section->flags & SEC_RELOC) == 0)) 2659 return; 2660 2661 relsize = bfd_get_reloc_upper_bound (abfd, section); 2662 if (relsize < 0) 2663 bfd_fatal (bfd_get_filename (abfd)); 2664 2665 printf ("RELOCATION RECORDS FOR [%s]:", section->name); 2666 2667 if (relsize == 0) 2668 { 2669 printf (" (none)\n\n"); 2670 return; 2671 } 2672 2673 relpp = xmalloc (relsize); 2674 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms); 2675 2676 if (relcount < 0) 2677 bfd_fatal (bfd_get_filename (abfd)); 2678 else if (relcount == 0) 2679 printf (" (none)\n\n"); 2680 else 2681 { 2682 printf ("\n"); 2683 dump_reloc_set (abfd, section, relpp, relcount); 2684 printf ("\n\n"); 2685 } 2686 free (relpp); 2687} 2688 2689static void 2690dump_relocs (bfd *abfd) 2691{ 2692 bfd_map_over_sections (abfd, dump_relocs_in_section, NULL); 2693} 2694 2695static void 2696dump_dynamic_relocs (bfd *abfd) 2697{ 2698 long relsize; 2699 arelent **relpp; 2700 long relcount; 2701 2702 relsize = bfd_get_dynamic_reloc_upper_bound (abfd); 2703 if (relsize < 0) 2704 bfd_fatal (bfd_get_filename (abfd)); 2705 2706 printf ("DYNAMIC RELOCATION RECORDS"); 2707 2708 if (relsize == 0) 2709 printf (" (none)\n\n"); 2710 else 2711 { 2712 relpp = xmalloc (relsize); 2713 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms); 2714 2715 if (relcount < 0) 2716 bfd_fatal (bfd_get_filename (abfd)); 2717 else if (relcount == 0) 2718 printf (" (none)\n\n"); 2719 else 2720 { 2721 printf ("\n"); 2722 dump_reloc_set (abfd, NULL, relpp, relcount); 2723 printf ("\n\n"); 2724 } 2725 free (relpp); 2726 } 2727} 2728 2729/* Creates a table of paths, to search for source files. */ 2730 2731static void 2732add_include_path (const char *path) 2733{ 2734 if (path[0] == 0) 2735 return; 2736 include_path_count++; 2737 include_paths = xrealloc (include_paths, 2738 include_path_count * sizeof (*include_paths)); 2739#ifdef HAVE_DOS_BASED_FILE_SYSTEM 2740 if (path[1] == ':' && path[2] == 0) 2741 path = concat (path, ".", (const char *) 0); 2742#endif 2743 include_paths[include_path_count - 1] = path; 2744} 2745 2746static void 2747adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED, 2748 asection *section, 2749 void *arg) 2750{ 2751 if ((section->flags & SEC_DEBUGGING) == 0) 2752 { 2753 bfd_boolean *has_reloc_p = (bfd_boolean *) arg; 2754 section->vma += adjust_section_vma; 2755 if (*has_reloc_p) 2756 section->lma += adjust_section_vma; 2757 } 2758} 2759 2760/* Dump selected contents of ABFD. */ 2761 2762static void 2763dump_bfd (bfd *abfd) 2764{ 2765 /* If we are adjusting section VMA's, change them all now. Changing 2766 the BFD information is a hack. However, we must do it, or 2767 bfd_find_nearest_line will not do the right thing. */ 2768 if (adjust_section_vma != 0) 2769 { 2770 bfd_boolean has_reloc = (abfd->flags & HAS_RELOC); 2771 bfd_map_over_sections (abfd, adjust_addresses, &has_reloc); 2772 } 2773 2774 if (! dump_debugging_tags) 2775 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd), 2776 abfd->xvec->name); 2777 if (dump_ar_hdrs) 2778 print_arelt_descr (stdout, abfd, TRUE); 2779 if (dump_file_header) 2780 dump_bfd_header (abfd); 2781 if (dump_private_headers) 2782 dump_bfd_private_header (abfd); 2783 if (! dump_debugging_tags) 2784 putchar ('\n'); 2785 if (dump_section_headers) 2786 dump_headers (abfd); 2787 2788 if (dump_symtab 2789 || dump_reloc_info 2790 || disassemble 2791 || dump_debugging 2792 || dump_dwarf_section_info) 2793 syms = slurp_symtab (abfd); 2794 if (dump_dynamic_symtab || dump_dynamic_reloc_info 2795 || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0)) 2796 dynsyms = slurp_dynamic_symtab (abfd); 2797 if (disassemble) 2798 { 2799 synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms, 2800 dynsymcount, dynsyms, &synthsyms); 2801 if (synthcount < 0) 2802 synthcount = 0; 2803 } 2804 2805 if (dump_symtab) 2806 dump_symbols (abfd, FALSE); 2807 if (dump_dynamic_symtab) 2808 dump_symbols (abfd, TRUE); 2809 if (dump_dwarf_section_info) 2810 dump_dwarf (abfd); 2811 if (dump_stab_section_info) 2812 dump_stabs (abfd); 2813 if (dump_reloc_info && ! disassemble) 2814 dump_relocs (abfd); 2815 if (dump_dynamic_reloc_info && ! disassemble) 2816 dump_dynamic_relocs (abfd); 2817 if (dump_section_contents) 2818 dump_data (abfd); 2819 if (disassemble) 2820 disassemble_data (abfd); 2821 2822 if (dump_debugging) 2823 { 2824 void *dhandle; 2825 2826 dhandle = read_debugging_info (abfd, syms, symcount); 2827 if (dhandle != NULL) 2828 { 2829 if (! print_debugging_info (stdout, dhandle, abfd, syms, demangle, 2830 dump_debugging_tags ? TRUE : FALSE)) 2831 { 2832 non_fatal (_("%s: printing debugging information failed"), 2833 bfd_get_filename (abfd)); 2834 exit_status = 1; 2835 } 2836 } 2837 } 2838 2839 if (syms) 2840 { 2841 free (syms); 2842 syms = NULL; 2843 } 2844 2845 if (dynsyms) 2846 { 2847 free (dynsyms); 2848 dynsyms = NULL; 2849 } 2850 2851 if (synthsyms) 2852 { 2853 free (synthsyms); 2854 synthsyms = NULL; 2855 } 2856 2857 symcount = 0; 2858 dynsymcount = 0; 2859 synthcount = 0; 2860} 2861 2862static void 2863display_bfd (bfd *abfd) 2864{ 2865 char **matching; 2866 2867 if (bfd_check_format_matches (abfd, bfd_object, &matching)) 2868 { 2869 dump_bfd (abfd); 2870 return; 2871 } 2872 2873 if (bfd_get_error () == bfd_error_file_ambiguously_recognized) 2874 { 2875 nonfatal (bfd_get_filename (abfd)); 2876 list_matching_formats (matching); 2877 free (matching); 2878 return; 2879 } 2880 2881 if (bfd_get_error () != bfd_error_file_not_recognized) 2882 { 2883 nonfatal (bfd_get_filename (abfd)); 2884 return; 2885 } 2886 2887 if (bfd_check_format_matches (abfd, bfd_core, &matching)) 2888 { 2889 dump_bfd (abfd); 2890 return; 2891 } 2892 2893 nonfatal (bfd_get_filename (abfd)); 2894 2895 if (bfd_get_error () == bfd_error_file_ambiguously_recognized) 2896 { 2897 list_matching_formats (matching); 2898 free (matching); 2899 } 2900} 2901 2902static void 2903display_file (char *filename, char *target) 2904{ 2905 bfd *file; 2906 bfd *arfile = NULL; 2907 2908 if (get_file_size (filename) < 1) 2909 { 2910 exit_status = 1; 2911 return; 2912 } 2913 2914 file = bfd_openr (filename, target); 2915 if (file == NULL) 2916 { 2917 nonfatal (filename); 2918 return; 2919 } 2920 2921 /* If the file is an archive, process all of its elements. */ 2922 if (bfd_check_format (file, bfd_archive)) 2923 { 2924 bfd *last_arfile = NULL; 2925 2926 printf (_("In archive %s:\n"), bfd_get_filename (file)); 2927 for (;;) 2928 { 2929 bfd_set_error (bfd_error_no_error); 2930 2931 arfile = bfd_openr_next_archived_file (file, arfile); 2932 if (arfile == NULL) 2933 { 2934 if (bfd_get_error () != bfd_error_no_more_archived_files) 2935 nonfatal (bfd_get_filename (file)); 2936 break; 2937 } 2938 2939 display_bfd (arfile); 2940 2941 if (last_arfile != NULL) 2942 bfd_close (last_arfile); 2943 last_arfile = arfile; 2944 } 2945 2946 if (last_arfile != NULL) 2947 bfd_close (last_arfile); 2948 } 2949 else 2950 display_bfd (file); 2951 2952 bfd_close (file); 2953} 2954 2955int 2956main (int argc, char **argv) 2957{ 2958 int c; 2959 char *target = default_target; 2960 bfd_boolean seenflag = FALSE; 2961 2962#if defined (HAVE_SETLOCALE) 2963#if defined (HAVE_LC_MESSAGES) 2964 setlocale (LC_MESSAGES, ""); 2965#endif 2966 setlocale (LC_CTYPE, ""); 2967#endif 2968 2969 bindtextdomain (PACKAGE, LOCALEDIR); 2970 textdomain (PACKAGE); 2971 2972 program_name = *argv; 2973 xmalloc_set_program_name (program_name); 2974 2975 START_PROGRESS (program_name, 0); 2976 2977 expandargv (&argc, &argv); 2978 2979 bfd_init (); 2980 set_default_bfd_target (); 2981 2982 while ((c = getopt_long (argc, argv, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeGW", 2983 long_options, (int *) 0)) 2984 != EOF) 2985 { 2986 switch (c) 2987 { 2988 case 0: 2989 break; /* We've been given a long option. */ 2990 case 'm': 2991 machine = optarg; 2992 break; 2993 case 'M': 2994 if (disassembler_options) 2995 /* Ignore potential memory leak for now. */ 2996 disassembler_options = concat (disassembler_options, ",", 2997 optarg, NULL); 2998 else 2999 disassembler_options = optarg; 3000 break; 3001 case 'j': 3002 if (only_used == only_size) 3003 { 3004 only_size += 8; 3005 only = xrealloc (only, only_size * sizeof (char *)); 3006 } 3007 only [only_used++] = optarg; 3008 break; 3009 case 'l': 3010 with_line_numbers = TRUE; 3011 break; 3012 case 'b': 3013 target = optarg; 3014 break; 3015 case 'C': 3016 do_demangle = TRUE; 3017 if (optarg != NULL) 3018 { 3019 enum demangling_styles style; 3020 3021 style = cplus_demangle_name_to_style (optarg); 3022 if (style == unknown_demangling) 3023 fatal (_("unknown demangling style `%s'"), 3024 optarg); 3025 3026 cplus_demangle_set_style (style); 3027 } 3028 break; 3029 case 'w': 3030 wide_output = TRUE; 3031 break; 3032 case OPTION_ADJUST_VMA: 3033 adjust_section_vma = parse_vma (optarg, "--adjust-vma"); 3034 break; 3035 case OPTION_START_ADDRESS: 3036 start_address = parse_vma (optarg, "--start-address"); 3037 break; 3038 case OPTION_STOP_ADDRESS: 3039 stop_address = parse_vma (optarg, "--stop-address"); 3040 break; 3041 case 'E': 3042 if (strcmp (optarg, "B") == 0) 3043 endian = BFD_ENDIAN_BIG; 3044 else if (strcmp (optarg, "L") == 0) 3045 endian = BFD_ENDIAN_LITTLE; 3046 else 3047 { 3048 non_fatal (_("unrecognized -E option")); 3049 usage (stderr, 1); 3050 } 3051 break; 3052 case OPTION_ENDIAN: 3053 if (strncmp (optarg, "big", strlen (optarg)) == 0) 3054 endian = BFD_ENDIAN_BIG; 3055 else if (strncmp (optarg, "little", strlen (optarg)) == 0) 3056 endian = BFD_ENDIAN_LITTLE; 3057 else 3058 { 3059 non_fatal (_("unrecognized --endian type `%s'"), optarg); 3060 usage (stderr, 1); 3061 } 3062 break; 3063 3064 case 'f': 3065 dump_file_header = TRUE; 3066 seenflag = TRUE; 3067 break; 3068 case 'i': 3069 formats_info = TRUE; 3070 seenflag = TRUE; 3071 break; 3072 case 'I': 3073 add_include_path (optarg); 3074 break; 3075 case 'p': 3076 dump_private_headers = TRUE; 3077 seenflag = TRUE; 3078 break; 3079 case 'x': 3080 dump_private_headers = TRUE; 3081 dump_symtab = TRUE; 3082 dump_reloc_info = TRUE; 3083 dump_file_header = TRUE; 3084 dump_ar_hdrs = TRUE; 3085 dump_section_headers = TRUE; 3086 seenflag = TRUE; 3087 break; 3088 case 't': 3089 dump_symtab = TRUE; 3090 seenflag = TRUE; 3091 break; 3092 case 'T': 3093 dump_dynamic_symtab = TRUE; 3094 seenflag = TRUE; 3095 break; 3096 case 'd': 3097 disassemble = TRUE; 3098 seenflag = TRUE; 3099 break; 3100 case 'z': 3101 disassemble_zeroes = TRUE; 3102 break; 3103 case 'D': 3104 disassemble = TRUE; 3105 disassemble_all = TRUE; 3106 seenflag = TRUE; 3107 break; 3108 case 'S': 3109 disassemble = TRUE; 3110 with_source_code = TRUE; 3111 seenflag = TRUE; 3112 break; 3113 case 'g': 3114 dump_debugging = 1; 3115 seenflag = TRUE; 3116 break; 3117 case 'e': 3118 dump_debugging = 1; 3119 dump_debugging_tags = 1; 3120 do_demangle = TRUE; 3121 seenflag = TRUE; 3122 break; 3123 case 'W': 3124 dump_dwarf_section_info = TRUE; 3125 seenflag = TRUE; 3126 do_debug_info = 1; 3127 do_debug_abbrevs = 1; 3128 do_debug_lines = 1; 3129 do_debug_pubnames = 1; 3130 do_debug_aranges = 1; 3131 do_debug_ranges = 1; 3132 do_debug_frames = 1; 3133 do_debug_macinfo = 1; 3134 do_debug_str = 1; 3135 do_debug_loc = 1; 3136 break; 3137 case 'G': 3138 dump_stab_section_info = TRUE; 3139 seenflag = TRUE; 3140 break; 3141 case 's': 3142 dump_section_contents = TRUE; 3143 seenflag = TRUE; 3144 break; 3145 case 'r': 3146 dump_reloc_info = TRUE; 3147 seenflag = TRUE; 3148 break; 3149 case 'R': 3150 dump_dynamic_reloc_info = TRUE; 3151 seenflag = TRUE; 3152 break; 3153 case 'a': 3154 dump_ar_hdrs = TRUE; 3155 seenflag = TRUE; 3156 break; 3157 case 'h': 3158 dump_section_headers = TRUE; 3159 seenflag = TRUE; 3160 break; 3161 case 'H': 3162 usage (stdout, 0); 3163 seenflag = TRUE; 3164 case 'v': 3165 case 'V': 3166 show_version = TRUE; 3167 seenflag = TRUE; 3168 break; 3169 3170 default: 3171 usage (stderr, 1); 3172 } 3173 } 3174 3175 if (show_version) 3176 print_version ("objdump"); 3177 3178 if (!seenflag) 3179 usage (stderr, 2); 3180 3181 if (formats_info) 3182 exit_status = display_info (); 3183 else 3184 { 3185 if (optind == argc) 3186 display_file ("a.out", target); 3187 else 3188 for (; optind < argc;) 3189 display_file (argv[optind++], target); 3190 } 3191 3192 END_PROGRESS (program_name); 3193 3194 return exit_status; 3195} 3196