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