1 /* objdump.c -- dump information about an object file.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
4 Free Software Foundation, Inc.
6 This file is part of GNU Binutils.
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)
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.
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. */
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.
29 The flow of execution is as follows:
31 1. Command line arguments are checked for control switches and the
32 information to be displayed is selected.
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.
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
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.
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. */
57 #include "safe-ctype.h"
59 #include "libiberty.h"
64 /* Internal headers for the ELF .stab-dump code - sorry. */
65 #define BYTES_IN_WORD 32
66 #include "aout/aout64.h"
69 static int exit_status = 0;
71 static char *default_target = NULL; /* Default at runtime. */
73 /* The following variables are set based on arguments passed on the
75 static int show_version = 0; /* Show the version number. */
76 static int dump_section_contents; /* -s */
77 static int dump_section_headers; /* -h */
78 static bfd_boolean dump_file_header; /* -f */
79 static int dump_symtab; /* -t */
80 static int dump_dynamic_symtab; /* -T */
81 static int dump_reloc_info; /* -r */
82 static int dump_dynamic_reloc_info; /* -R */
83 static int dump_ar_hdrs; /* -a */
84 static int dump_private_headers; /* -p */
85 static int prefix_addresses; /* --prefix-addresses */
86 static int with_line_numbers; /* -l */
87 static bfd_boolean with_source_code; /* -S */
88 static int show_raw_insn; /* --show-raw-insn */
89 static int dump_dwarf_section_info; /* --dwarf */
90 static int dump_stab_section_info; /* --stabs */
91 static int do_demangle; /* -C, --demangle */
92 static bfd_boolean disassemble; /* -d */
93 static bfd_boolean disassemble_all; /* -D */
94 static int disassemble_zeroes; /* --disassemble-zeroes */
95 static bfd_boolean formats_info; /* -i */
96 static int wide_output; /* -w */
97 static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
98 static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */
99 static int dump_debugging; /* --debugging */
100 static int dump_debugging_tags; /* --debugging-tags */
101 static int dump_special_syms = 0; /* --special-syms */
102 static bfd_vma adjust_section_vma = 0; /* --adjust-vma */
103 static int file_start_context = 0; /* --file-start-context */
105 /* Pointer to an array of section names provided by
106 one or more "-j secname" command line options. */
108 /* The total number of slots in the only[] array. */
109 static size_t only_size = 0;
110 /* The number of occupied slots in the only[] array. */
111 static size_t only_used = 0;
113 /* Variables for handling include file path table. */
114 static const char **include_paths;
115 static int include_path_count;
117 /* Extra info to pass to the section disassembler and address printing
119 struct objdump_disasm_info
123 bfd_boolean require_sec;
124 arelent ** dynrelbuf;
126 disassembler_ftype disassemble_fn;
130 /* Architecture to disassemble for, or default if NULL. */
131 static char *machine = NULL;
133 /* Target specific options to the disassembler. */
134 static char *disassembler_options = NULL;
136 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
137 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
139 /* The symbol table. */
140 static asymbol **syms;
142 /* Number of symbols in `syms'. */
143 static long symcount = 0;
145 /* The sorted symbol table. */
146 static asymbol **sorted_syms;
148 /* Number of symbols in `sorted_syms'. */
149 static long sorted_symcount = 0;
151 /* The dynamic symbol table. */
152 static asymbol **dynsyms;
154 /* The synthetic symbol table. */
155 static asymbol *synthsyms;
156 static long synthcount = 0;
158 /* Number of symbols in `dynsyms'. */
159 static long dynsymcount = 0;
161 static bfd_byte *stabs;
162 static bfd_size_type stab_size;
165 static bfd_size_type stabstr_size;
168 usage (FILE *stream, int status)
170 fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
171 fprintf (stream, _(" Display information from object <file(s)>.\n"));
172 fprintf (stream, _(" At least one of the following switches must be given:\n"));
173 fprintf (stream, _("\
174 -a, --archive-headers Display archive header information\n\
175 -f, --file-headers Display the contents of the overall file header\n\
176 -p, --private-headers Display object format specific file header contents\n\
177 -h, --[section-]headers Display the contents of the section headers\n\
178 -x, --all-headers Display the contents of all headers\n\
179 -d, --disassemble Display assembler contents of executable sections\n\
180 -D, --disassemble-all Display assembler contents of all sections\n\
181 -S, --source Intermix source code with disassembly\n\
182 -s, --full-contents Display the full contents of all sections requested\n\
183 -g, --debugging Display debug information in object file\n\
184 -e, --debugging-tags Display debug information using ctags style\n\
185 -G, --stabs Display (in raw form) any STABS info in the file\n\
186 -W, --dwarf Display DWARF info in the file\n\
187 -t, --syms Display the contents of the symbol table(s)\n\
188 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
189 -r, --reloc Display the relocation entries in the file\n\
190 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
191 @<file> Read options from <file>\n\
192 -v, --version Display this program's version number\n\
193 -i, --info List object formats and architectures supported\n\
194 -H, --help Display this information\n\
198 fprintf (stream, _("\n The following switches are optional:\n"));
199 fprintf (stream, _("\
200 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
201 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
202 -j, --section=NAME Only display information for section NAME\n\
203 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
204 -EB --endian=big Assume big endian format when disassembling\n\
205 -EL --endian=little Assume little endian format when disassembling\n\
206 --file-start-context Include context from start of file (with -S)\n\
207 -I, --include=DIR Add DIR to search list for source files\n\
208 -l, --line-numbers Include line numbers and filenames in output\n\
209 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
210 The STYLE, if specified, can be `auto', `gnu',\n\
211 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
213 -w, --wide Format output for more than 80 columns\n\
214 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
215 --start-address=ADDR Only process data whose address is >= ADDR\n\
216 --stop-address=ADDR Only process data whose address is <= ADDR\n\
217 --prefix-addresses Print complete address alongside disassembly\n\
218 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
219 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
220 --special-syms Include special symbols in symbol dumps\n\
222 list_supported_targets (program_name, stream);
223 list_supported_architectures (program_name, stream);
225 disassembler_usage (stream);
227 if (REPORT_BUGS_TO[0] && status == 0)
228 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
232 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
236 OPTION_START_ADDRESS,
241 static struct option long_options[]=
243 {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
244 {"all-headers", no_argument, NULL, 'x'},
245 {"private-headers", no_argument, NULL, 'p'},
246 {"architecture", required_argument, NULL, 'm'},
247 {"archive-headers", no_argument, NULL, 'a'},
248 {"debugging", no_argument, NULL, 'g'},
249 {"debugging-tags", no_argument, NULL, 'e'},
250 {"demangle", optional_argument, NULL, 'C'},
251 {"disassemble", no_argument, NULL, 'd'},
252 {"disassemble-all", no_argument, NULL, 'D'},
253 {"disassembler-options", required_argument, NULL, 'M'},
254 {"disassemble-zeroes", no_argument, NULL, 'z'},
255 {"dynamic-reloc", no_argument, NULL, 'R'},
256 {"dynamic-syms", no_argument, NULL, 'T'},
257 {"endian", required_argument, NULL, OPTION_ENDIAN},
258 {"file-headers", no_argument, NULL, 'f'},
259 {"file-start-context", no_argument, &file_start_context, 1},
260 {"full-contents", no_argument, NULL, 's'},
261 {"headers", no_argument, NULL, 'h'},
262 {"help", no_argument, NULL, 'H'},
263 {"info", no_argument, NULL, 'i'},
264 {"line-numbers", no_argument, NULL, 'l'},
265 {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
266 {"prefix-addresses", no_argument, &prefix_addresses, 1},
267 {"reloc", no_argument, NULL, 'r'},
268 {"section", required_argument, NULL, 'j'},
269 {"section-headers", no_argument, NULL, 'h'},
270 {"show-raw-insn", no_argument, &show_raw_insn, 1},
271 {"source", no_argument, NULL, 'S'},
272 {"special-syms", no_argument, &dump_special_syms, 1},
273 {"include", required_argument, NULL, 'I'},
274 {"dwarf", no_argument, NULL, 'W'},
275 {"stabs", no_argument, NULL, 'G'},
276 {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
277 {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
278 {"syms", no_argument, NULL, 't'},
279 {"target", required_argument, NULL, 'b'},
280 {"version", no_argument, NULL, 'V'},
281 {"wide", no_argument, NULL, 'w'},
282 {0, no_argument, 0, 0}
286 nonfatal (const char *msg)
293 dump_section_header (bfd *abfd, asection *section,
294 void *ignored ATTRIBUTE_UNUSED)
297 unsigned int opb = bfd_octets_per_byte (abfd);
299 /* Ignore linker created section. See elfNN_ia64_object_p in
301 if (section->flags & SEC_LINKER_CREATED)
304 printf ("%3d %-13s %08lx ", section->index,
305 bfd_get_section_name (abfd, section),
306 (unsigned long) bfd_section_size (abfd, section) / opb);
307 bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
309 bfd_printf_vma (abfd, section->lma);
310 printf (" %08lx 2**%u", (unsigned long) section->filepos,
311 bfd_get_section_alignment (abfd, section));
317 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
319 PF (SEC_HAS_CONTENTS, "CONTENTS");
320 PF (SEC_ALLOC, "ALLOC");
321 PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
322 PF (SEC_LOAD, "LOAD");
323 PF (SEC_RELOC, "RELOC");
324 PF (SEC_READONLY, "READONLY");
325 PF (SEC_CODE, "CODE");
326 PF (SEC_DATA, "DATA");
328 PF (SEC_DEBUGGING, "DEBUGGING");
329 PF (SEC_NEVER_LOAD, "NEVER_LOAD");
330 PF (SEC_EXCLUDE, "EXCLUDE");
331 PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
332 if (bfd_get_arch (abfd) == bfd_arch_tic54x)
334 PF (SEC_TIC54X_BLOCK, "BLOCK");
335 PF (SEC_TIC54X_CLINK, "CLINK");
337 PF (SEC_SMALL_DATA, "SMALL_DATA");
338 if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
339 PF (SEC_COFF_SHARED, "SHARED");
340 PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
341 PF (SEC_GROUP, "GROUP");
343 if ((section->flags & SEC_LINK_ONCE) != 0)
346 struct coff_comdat_info *comdat;
348 switch (section->flags & SEC_LINK_DUPLICATES)
352 case SEC_LINK_DUPLICATES_DISCARD:
353 ls = "LINK_ONCE_DISCARD";
355 case SEC_LINK_DUPLICATES_ONE_ONLY:
356 ls = "LINK_ONCE_ONE_ONLY";
358 case SEC_LINK_DUPLICATES_SAME_SIZE:
359 ls = "LINK_ONCE_SAME_SIZE";
361 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
362 ls = "LINK_ONCE_SAME_CONTENTS";
365 printf ("%s%s", comma, ls);
367 comdat = bfd_coff_get_comdat_section (abfd, section);
369 printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);
379 dump_headers (bfd *abfd)
381 printf (_("Sections:\n"));
384 printf (_("Idx Name Size VMA LMA File off Algn"));
386 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
387 if (bfd_get_arch_size (abfd) == 32)
388 printf (_("Idx Name Size VMA LMA File off Algn"));
390 printf (_("Idx Name Size VMA LMA File off Algn"));
394 printf (_(" Flags"));
395 if (abfd->flags & HAS_LOAD_PAGE)
399 bfd_map_over_sections (abfd, dump_section_header, NULL);
403 slurp_symtab (bfd *abfd)
408 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
414 storage = bfd_get_symtab_upper_bound (abfd);
416 bfd_fatal (bfd_get_filename (abfd));
418 sy = xmalloc (storage);
420 symcount = bfd_canonicalize_symtab (abfd, sy);
422 bfd_fatal (bfd_get_filename (abfd));
426 /* Read in the dynamic symbols. */
429 slurp_dynamic_symtab (bfd *abfd)
434 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
437 if (!(bfd_get_file_flags (abfd) & DYNAMIC))
439 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
444 bfd_fatal (bfd_get_filename (abfd));
447 sy = xmalloc (storage);
449 dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
451 bfd_fatal (bfd_get_filename (abfd));
455 /* Filter out (in place) symbols that are useless for disassembly.
456 COUNT is the number of elements in SYMBOLS.
457 Return the number of useful symbols. */
460 remove_useless_symbols (asymbol **symbols, long count)
462 asymbol **in_ptr = symbols, **out_ptr = symbols;
466 asymbol *sym = *in_ptr++;
468 if (sym->name == NULL || sym->name[0] == '\0')
470 if (sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
472 if (bfd_is_und_section (sym->section)
473 || bfd_is_com_section (sym->section))
478 return out_ptr - symbols;
481 /* Sort symbols into value order. */
484 compare_symbols (const void *ap, const void *bp)
486 const asymbol *a = * (const asymbol **) ap;
487 const asymbol *b = * (const asymbol **) bp;
497 if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
499 else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
502 if (a->section > b->section)
504 else if (a->section < b->section)
507 an = bfd_asymbol_name (a);
508 bn = bfd_asymbol_name (b);
512 /* The symbols gnu_compiled and gcc2_compiled convey no real
513 information, so put them after other symbols with the same value. */
514 af = (strstr (an, "gnu_compiled") != NULL
515 || strstr (an, "gcc2_compiled") != NULL);
516 bf = (strstr (bn, "gnu_compiled") != NULL
517 || strstr (bn, "gcc2_compiled") != NULL);
524 /* We use a heuristic for the file name, to try to sort it after
525 more useful symbols. It may not work on non Unix systems, but it
526 doesn't really matter; the only difference is precisely which
527 symbol names get printed. */
529 #define file_symbol(s, sn, snl) \
530 (((s)->flags & BSF_FILE) != 0 \
531 || ((sn)[(snl) - 2] == '.' \
532 && ((sn)[(snl) - 1] == 'o' \
533 || (sn)[(snl) - 1] == 'a')))
535 af = file_symbol (a, an, anl);
536 bf = file_symbol (b, bn, bnl);
543 /* Try to sort global symbols before local symbols before function
544 symbols before debugging symbols. */
549 if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
551 if ((aflags & BSF_DEBUGGING) != 0)
556 if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
558 if ((aflags & BSF_FUNCTION) != 0)
563 if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
565 if ((aflags & BSF_LOCAL) != 0)
570 if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
572 if ((aflags & BSF_GLOBAL) != 0)
578 /* Symbols that start with '.' might be section names, so sort them
579 after symbols that don't start with '.'. */
580 if (an[0] == '.' && bn[0] != '.')
582 if (an[0] != '.' && bn[0] == '.')
585 /* Finally, if we can't distinguish them in any other way, try to
586 get consistent results by sorting the symbols by name. */
587 return strcmp (an, bn);
590 /* Sort relocs into address order. */
593 compare_relocs (const void *ap, const void *bp)
595 const arelent *a = * (const arelent **) ap;
596 const arelent *b = * (const arelent **) bp;
598 if (a->address > b->address)
600 else if (a->address < b->address)
603 /* So that associated relocations tied to the same address show up
604 in the correct order, we don't do any further sorting. */
613 /* Print an address (VMA) to the output stream in INFO.
614 If SKIP_ZEROES is TRUE, omit leading zeroes. */
617 objdump_print_value (bfd_vma vma, struct disassemble_info *info,
618 bfd_boolean skip_zeroes)
622 struct objdump_disasm_info *aux;
624 aux = (struct objdump_disasm_info *) info->application_data;
625 bfd_sprintf_vma (aux->abfd, buf, vma);
630 for (p = buf; *p == '0'; ++p)
635 (*info->fprintf_func) (info->stream, "%s", p);
638 /* Print the name of a symbol. */
641 objdump_print_symname (bfd *abfd, struct disassemble_info *info,
648 name = bfd_asymbol_name (sym);
649 if (do_demangle && name[0] != '\0')
651 /* Demangle the name. */
652 alloc = demangle (abfd, name);
657 (*info->fprintf_func) (info->stream, "%s", name);
665 /* Locate a symbol given a bfd and a section (from INFO->application_data),
666 and a VMA. If INFO->application_data->require_sec is TRUE, then always
667 require the symbol to be in the section. Returns NULL if there is no
668 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
669 of the symbol in sorted_syms. */
672 find_symbol_for_address (bfd_vma vma,
673 struct disassemble_info *info,
676 /* @@ Would it speed things up to cache the last two symbols returned,
677 and maybe their address ranges? For many processors, only one memory
678 operand can be present at a time, so the 2-entry cache wouldn't be
679 constantly churned by code doing heavy memory accesses. */
681 /* Indices in `sorted_syms'. */
683 long max = sorted_symcount;
685 struct objdump_disasm_info *aux;
690 if (sorted_symcount < 1)
693 aux = (struct objdump_disasm_info *) info->application_data;
696 opb = bfd_octets_per_byte (abfd);
698 /* Perform a binary search looking for the closest symbol to the
699 required value. We are searching the range (min, max]. */
700 while (min + 1 < max)
704 thisplace = (max + min) / 2;
705 sym = sorted_syms[thisplace];
707 if (bfd_asymbol_value (sym) > vma)
709 else if (bfd_asymbol_value (sym) < vma)
718 /* The symbol we want is now in min, the low end of the range we
719 were searching. If there are several symbols with the same
720 value, we want the first one. */
723 && (bfd_asymbol_value (sorted_syms[thisplace])
724 == bfd_asymbol_value (sorted_syms[thisplace - 1])))
727 /* If the file is relocatable, and the symbol could be from this
728 section, prefer a symbol from this section over symbols from
729 others, even if the other symbol's value might be closer.
731 Note that this may be wrong for some symbol references if the
732 sections have overlapping memory ranges, but in that case there's
733 no way to tell what's desired without looking at the relocation
735 if (sorted_syms[thisplace]->section != sec
737 || ((abfd->flags & HAS_RELOC) != 0
738 && vma >= bfd_get_section_vma (abfd, sec)
739 && vma < (bfd_get_section_vma (abfd, sec)
740 + bfd_section_size (abfd, sec) / opb))))
744 for (i = thisplace + 1; i < sorted_symcount; i++)
746 if (bfd_asymbol_value (sorted_syms[i])
747 != bfd_asymbol_value (sorted_syms[thisplace]))
755 if (sorted_syms[i]->section == sec
757 || sorted_syms[i - 1]->section != sec
758 || (bfd_asymbol_value (sorted_syms[i])
759 != bfd_asymbol_value (sorted_syms[i - 1]))))
766 if (sorted_syms[thisplace]->section != sec)
768 /* We didn't find a good symbol with a smaller value.
769 Look for one with a larger value. */
770 for (i = thisplace + 1; i < sorted_symcount; i++)
772 if (sorted_syms[i]->section == sec)
780 if (sorted_syms[thisplace]->section != sec
782 || ((abfd->flags & HAS_RELOC) != 0
783 && vma >= bfd_get_section_vma (abfd, sec)
784 && vma < (bfd_get_section_vma (abfd, sec)
785 + bfd_section_size (abfd, sec)))))
786 /* There is no suitable symbol. */
790 /* Give the target a chance to reject the symbol. */
791 while (! info->symbol_is_valid (sorted_syms [thisplace], info))
794 if (thisplace >= sorted_symcount
795 || bfd_asymbol_value (sorted_syms [thisplace]) > vma)
802 return sorted_syms[thisplace];
805 /* Print an address and the offset to the nearest symbol. */
808 objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
809 bfd_vma vma, struct disassemble_info *info,
810 bfd_boolean skip_zeroes)
812 objdump_print_value (vma, info, skip_zeroes);
818 (*info->fprintf_func) (info->stream, " <%s",
819 bfd_get_section_name (abfd, sec));
820 secaddr = bfd_get_section_vma (abfd, sec);
823 (*info->fprintf_func) (info->stream, "-0x");
824 objdump_print_value (secaddr - vma, info, TRUE);
826 else if (vma > secaddr)
828 (*info->fprintf_func) (info->stream, "+0x");
829 objdump_print_value (vma - secaddr, info, TRUE);
831 (*info->fprintf_func) (info->stream, ">");
835 (*info->fprintf_func) (info->stream, " <");
836 objdump_print_symname (abfd, info, sym);
837 if (bfd_asymbol_value (sym) > vma)
839 (*info->fprintf_func) (info->stream, "-0x");
840 objdump_print_value (bfd_asymbol_value (sym) - vma, info, TRUE);
842 else if (vma > bfd_asymbol_value (sym))
844 (*info->fprintf_func) (info->stream, "+0x");
845 objdump_print_value (vma - bfd_asymbol_value (sym), info, TRUE);
847 (*info->fprintf_func) (info->stream, ">");
851 /* Print an address (VMA), symbolically if possible.
852 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
855 objdump_print_addr (bfd_vma vma,
856 struct disassemble_info *info,
857 bfd_boolean skip_zeroes)
859 struct objdump_disasm_info *aux;
860 asymbol *sym = NULL; /* Initialize to avoid compiler warning. */
861 bfd_boolean skip_find = FALSE;
863 if (sorted_symcount < 1)
865 (*info->fprintf_func) (info->stream, "0x");
866 objdump_print_value (vma, info, skip_zeroes);
870 aux = (struct objdump_disasm_info *) info->application_data;
872 if (aux->reloc != NULL
873 && aux->reloc->sym_ptr_ptr != NULL
874 && * aux->reloc->sym_ptr_ptr != NULL)
876 sym = * aux->reloc->sym_ptr_ptr;
878 /* Adjust the vma to the reloc. */
879 vma += bfd_asymbol_value (sym);
881 if (bfd_is_und_section (bfd_get_section (sym)))
886 sym = find_symbol_for_address (vma, info, NULL);
888 objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, info,
892 /* Print VMA to INFO. This function is passed to the disassembler
896 objdump_print_address (bfd_vma vma, struct disassemble_info *info)
898 objdump_print_addr (vma, info, ! prefix_addresses);
901 /* Determine if the given address has a symbol associated with it. */
904 objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * info)
908 sym = find_symbol_for_address (vma, info, NULL);
910 return (sym != NULL && (bfd_asymbol_value (sym) == vma));
913 /* Hold the last function name and the last line number we displayed
916 static char *prev_functionname;
917 static unsigned int prev_line;
919 /* We keep a list of all files that we have seen when doing a
920 disassembly with source, so that we know how much of the file to
921 display. This can be important for inlined functions. */
923 struct print_file_list
925 struct print_file_list *next;
926 const char *filename;
932 static struct print_file_list *print_files;
934 /* The number of preceding context lines to show when we start
935 displaying a file for the first time. */
937 #define SHOW_PRECEDING_CONTEXT_LINES (5)
939 /* Tries to open MODNAME, and if successful adds a node to print_files
940 linked list and returns that node. Returns NULL on failure. */
942 static struct print_file_list *
943 try_print_file_open (const char *origname, const char *modname)
945 struct print_file_list *p;
948 f = fopen (modname, "r");
952 if (print_files != NULL && print_files->f != NULL)
954 fclose (print_files->f);
955 print_files->f = NULL;
958 p = xmalloc (sizeof (struct print_file_list));
959 p->filename = origname;
960 p->modname = modname;
963 p->next = print_files;
968 /* If the the source file, as described in the symtab, is not found
969 try to locate it in one of the paths specified with -I
970 If found, add location to print_files linked list. */
972 static struct print_file_list *
973 update_source_path (const char *filename)
975 struct print_file_list *p;
979 if (filename == NULL)
982 p = try_print_file_open (filename, filename);
986 if (include_path_count == 0)
989 /* Get the name of the file. */
990 fname = strrchr (filename, '/');
991 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
993 /* We could have a mixed forward/back slash case. */
994 char *backslash = strrchr (filename, '\\');
995 if (fname == NULL || (backslash != NULL && backslash > fname))
997 if (fname == NULL && filename[0] != '\0' && filename[1] == ':')
998 fname = filename + 1;
1006 /* If file exists under a new path, we need to add it to the list
1007 so that show_line knows about it. */
1008 for (i = 0; i < include_path_count; i++)
1010 char *modname = concat (include_paths[i], "/", fname, (const char *) 0);
1012 p = try_print_file_open (filename, modname);
1022 /* Skip ahead to a given line in a file, optionally printing each
1026 skip_to_line (struct print_file_list *p, unsigned int line,
1029 while (p->line < line)
1033 if (fgets (buf, sizeof buf, p->f) == NULL)
1043 if (strchr (buf, '\n') != NULL)
1048 /* Show the line number, or the source line, in a disassembly
1052 show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
1054 const char *filename;
1055 const char *functionname;
1058 if (! with_line_numbers && ! with_source_code)
1061 if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename,
1062 &functionname, &line))
1065 if (filename != NULL && *filename == '\0')
1067 if (functionname != NULL && *functionname == '\0')
1068 functionname = NULL;
1070 if (with_line_numbers)
1072 if (functionname != NULL
1073 && (prev_functionname == NULL
1074 || strcmp (functionname, prev_functionname) != 0))
1075 printf ("%s():\n", functionname);
1076 if (line > 0 && line != prev_line)
1077 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
1080 if (with_source_code
1084 struct print_file_list **pp, *p;
1086 for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1087 if (strcmp ((*pp)->filename, filename) == 0)
1093 if (p != print_files)
1097 /* We have reencountered a file name which we saw
1098 earlier. This implies that either we are dumping out
1099 code from an included file, or the same file was
1100 linked in more than once. There are two common cases
1101 of an included file: inline functions in a header
1102 file, and a bison or flex skeleton file. In the
1103 former case we want to just start printing (but we
1104 back up a few lines to give context); in the latter
1105 case we want to continue from where we left off. I
1106 can't think of a good way to distinguish the cases,
1107 so I used a heuristic based on the file name. */
1108 if (strcmp (p->filename + strlen (p->filename) - 2, ".h") != 0)
1112 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1119 p->f = fopen (p->modname, "r");
1123 skip_to_line (p, l, FALSE);
1125 if (print_files->f != NULL)
1127 fclose (print_files->f);
1128 print_files->f = NULL;
1134 skip_to_line (p, line, TRUE);
1136 p->next = print_files;
1142 p = update_source_path (filename);
1148 if (file_start_context)
1151 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1154 skip_to_line (p, l, FALSE);
1156 skip_to_line (p, line, TRUE);
1161 if (functionname != NULL
1162 && (prev_functionname == NULL
1163 || strcmp (functionname, prev_functionname) != 0))
1165 if (prev_functionname != NULL)
1166 free (prev_functionname);
1167 prev_functionname = xmalloc (strlen (functionname) + 1);
1168 strcpy (prev_functionname, functionname);
1171 if (line > 0 && line != prev_line)
1175 /* Pseudo FILE object for strings. */
1183 /* sprintf to a "stream". */
1185 static int ATTRIBUTE_PRINTF_2
1186 objdump_sprintf (SFILE *f, const char *format, ...)
1193 size_t space = f->alloc - f->pos;
1195 va_start (args, format);
1196 n = vsnprintf (f->buffer + f->pos, space, format, args);
1202 f->alloc = (f->alloc + n) * 2;
1203 f->buffer = xrealloc (f->buffer, f->alloc);
1210 /* Returns TRUE if the specified section should be dumped. */
1213 process_section_p (asection * section)
1220 for (i = 0; i < only_used; i++)
1221 if (strcmp (only [i], section->name) == 0)
1228 /* The number of zeroes we want to see before we start skipping them.
1229 The number is arbitrarily chosen. */
1231 #define DEFAULT_SKIP_ZEROES 8
1233 /* The number of zeroes to skip at the end of a section. If the
1234 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1235 SKIP_ZEROES, they will be disassembled. If there are fewer than
1236 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1237 attempt to avoid disassembling zeroes inserted by section
1240 #define DEFAULT_SKIP_ZEROES_AT_END 3
1242 /* Disassemble some data in memory between given values. */
1245 disassemble_bytes (struct disassemble_info * info,
1246 disassembler_ftype disassemble_fn,
1249 bfd_vma start_offset,
1250 bfd_vma stop_offset,
1253 arelent ** relppend)
1255 struct objdump_disasm_info *aux;
1257 int octets_per_line;
1258 bfd_boolean done_dot;
1259 int skip_addr_chars;
1260 bfd_vma addr_offset;
1261 unsigned int opb = info->octets_per_byte;
1262 unsigned int skip_zeroes = info->skip_zeroes;
1263 unsigned int skip_zeroes_at_end = info->skip_zeroes_at_end;
1267 aux = (struct objdump_disasm_info *) info->application_data;
1271 sfile.buffer = xmalloc (sfile.alloc);
1275 octets_per_line = 4;
1277 octets_per_line = 16;
1279 /* Figure out how many characters to skip at the start of an
1280 address, to make the disassembly look nicer. We discard leading
1281 zeroes in chunks of 4, ensuring that there is always a leading
1283 skip_addr_chars = 0;
1284 if (! prefix_addresses)
1292 + bfd_section_size (section->owner, section) / opb));
1294 while (s[0] == '0' && s[1] == '0' && s[2] == '0' && s[3] == '0'
1297 skip_addr_chars += 4;
1302 info->insn_info_valid = 0;
1305 addr_offset = start_offset;
1306 while (addr_offset < stop_offset)
1309 bfd_boolean need_nl = FALSE;
1310 int previous_octets;
1312 /* Remember the length of the previous instruction. */
1313 previous_octets = octets;
1316 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1318 for (z = addr_offset * opb; z < stop_offset * opb; z++)
1321 if (! disassemble_zeroes
1322 && (info->insn_info_valid == 0
1323 || info->branch_delay_insns == 0)
1324 && (z - addr_offset * opb >= skip_zeroes
1325 || (z == stop_offset * opb &&
1326 z - addr_offset * opb < skip_zeroes_at_end)))
1330 /* If there are more nonzero octets to follow, we only skip
1331 zeroes in multiples of 4, to try to avoid running over
1332 the start of an instruction which happens to start with
1334 if (z != stop_offset * opb)
1335 z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1337 octets = z - addr_offset * opb;
1347 if (with_line_numbers || with_source_code)
1348 show_line (aux->abfd, section, addr_offset);
1350 if (! prefix_addresses)
1354 bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
1355 for (s = buf + skip_addr_chars; *s == '0'; s++)
1359 printf ("%s:\t", buf + skip_addr_chars);
1363 aux->require_sec = TRUE;
1364 objdump_print_address (section->vma + addr_offset, info);
1365 aux->require_sec = FALSE;
1372 info->fprintf_func = (fprintf_ftype) objdump_sprintf;
1373 info->stream = &sfile;
1374 info->bytes_per_line = 0;
1375 info->bytes_per_chunk = 0;
1378 if (info->disassembler_needs_relocs
1379 && *relppp < relppend)
1381 bfd_signed_vma distance_to_rel;
1383 distance_to_rel = (**relppp)->address
1384 - (rel_offset + addr_offset);
1386 /* Check to see if the current reloc is associated with
1387 the instruction that we are about to disassemble. */
1388 if (distance_to_rel == 0
1389 /* FIXME: This is wrong. We are trying to catch
1390 relocs that are addressed part way through the
1391 current instruction, as might happen with a packed
1392 VLIW instruction. Unfortunately we do not know the
1393 length of the current instruction since we have not
1394 disassembled it yet. Instead we take a guess based
1395 upon the length of the previous instruction. The
1396 proper solution is to have a new target-specific
1397 disassembler function which just returns the length
1398 of an instruction at a given address without trying
1399 to display its disassembly. */
1400 || (distance_to_rel > 0
1401 && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
1403 info->flags = INSN_HAS_RELOC;
1404 aux->reloc = **relppp;
1410 octets = (*disassemble_fn) (section->vma + addr_offset, info);
1411 info->fprintf_func = (fprintf_ftype) fprintf;
1412 info->stream = stdout;
1413 if (info->bytes_per_line != 0)
1414 octets_per_line = info->bytes_per_line;
1418 printf ("%s\n", sfile.buffer);
1426 octets = octets_per_line;
1427 if (addr_offset + octets / opb > stop_offset)
1428 octets = (stop_offset - addr_offset) * opb;
1430 for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1432 if (ISPRINT (data[j]))
1433 buf[j - addr_offset * opb] = data[j];
1435 buf[j - addr_offset * opb] = '.';
1437 buf[j - addr_offset * opb] = '\0';
1440 if (prefix_addresses
1442 : show_raw_insn >= 0)
1446 /* If ! prefix_addresses and ! wide_output, we print
1447 octets_per_line octets per line. */
1449 if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1450 pb = octets_per_line;
1452 if (info->bytes_per_chunk)
1453 bpc = info->bytes_per_chunk;
1457 for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1461 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1463 for (k = bpc - 1; k >= 0; k--)
1464 printf ("%02x", (unsigned) data[j + k]);
1469 for (k = 0; k < bpc; k++)
1470 printf ("%02x", (unsigned) data[j + k]);
1475 for (; pb < octets_per_line; pb += bpc)
1479 for (k = 0; k < bpc; k++)
1484 /* Separate raw data from instruction by extra space. */
1494 printf ("%s", sfile.buffer);
1496 if (prefix_addresses
1498 : show_raw_insn >= 0)
1506 j = addr_offset * opb + pb;
1508 bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
1509 for (s = buf + skip_addr_chars; *s == '0'; s++)
1513 printf ("%s:\t", buf + skip_addr_chars);
1515 pb += octets_per_line;
1518 for (; j < addr_offset * opb + pb; j += bpc)
1522 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1524 for (k = bpc - 1; k >= 0; k--)
1525 printf ("%02x", (unsigned) data[j + k]);
1530 for (k = 0; k < bpc; k++)
1531 printf ("%02x", (unsigned) data[j + k]);
1544 while ((*relppp) < relppend
1545 && (**relppp)->address < rel_offset + addr_offset + octets / opb)
1547 if (dump_reloc_info || dump_dynamic_reloc_info)
1558 objdump_print_value (section->vma - rel_offset + q->address,
1561 if (q->howto == NULL)
1562 printf (": *unknown*\t");
1563 else if (q->howto->name)
1564 printf (": %s\t", q->howto->name);
1566 printf (": %d\t", q->howto->type);
1568 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1569 printf ("*unknown*");
1572 const char *sym_name;
1574 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1575 if (sym_name != NULL && *sym_name != '\0')
1576 objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
1581 sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1582 sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1583 if (sym_name == NULL || *sym_name == '\0')
1584 sym_name = "*unknown*";
1585 printf ("%s", sym_name);
1592 objdump_print_value (q->addend, info, TRUE);
1604 addr_offset += octets / opb;
1607 free (sfile.buffer);
1611 disassemble_section (bfd *abfd, asection *section, void *info)
1613 struct disassemble_info * pinfo = (struct disassemble_info *) info;
1614 struct objdump_disasm_info * paux;
1615 unsigned int opb = pinfo->octets_per_byte;
1616 bfd_byte * data = NULL;
1617 bfd_size_type datasize = 0;
1618 arelent ** rel_pp = NULL;
1619 arelent ** rel_ppstart = NULL;
1620 arelent ** rel_ppend;
1621 unsigned long stop_offset;
1622 asymbol * sym = NULL;
1626 unsigned long addr_offset;
1628 /* Sections that do not contain machine
1629 code are not normally disassembled. */
1630 if (! disassemble_all
1632 && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
1633 != (SEC_CODE | SEC_HAS_CONTENTS)))
1636 if (! process_section_p (section))
1639 datasize = bfd_get_section_size (section);
1643 /* Decide which set of relocs to use. Load them if necessary. */
1644 paux = (struct objdump_disasm_info *) pinfo->application_data;
1645 if (paux->dynrelbuf)
1647 rel_pp = paux->dynrelbuf;
1648 rel_count = paux->dynrelcount;
1649 /* Dynamic reloc addresses are absolute, non-dynamic are section
1650 relative. REL_OFFSET specifies the reloc address corresponding
1651 to the start of this section. */
1652 rel_offset = section->vma;
1660 if ((section->flags & SEC_RELOC) != 0
1661 && (dump_reloc_info || pinfo->disassembler_needs_relocs))
1665 relsize = bfd_get_reloc_upper_bound (abfd, section);
1667 bfd_fatal (bfd_get_filename (abfd));
1671 rel_ppstart = rel_pp = xmalloc (relsize);
1672 rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
1674 bfd_fatal (bfd_get_filename (abfd));
1676 /* Sort the relocs by address. */
1677 qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
1682 rel_ppend = rel_pp + rel_count;
1684 data = xmalloc (datasize);
1686 bfd_get_section_contents (abfd, section, data, 0, datasize);
1688 paux->sec = section;
1689 pinfo->buffer = data;
1690 pinfo->buffer_vma = section->vma;
1691 pinfo->buffer_length = datasize;
1692 pinfo->section = section;
1694 if (start_address == (bfd_vma) -1
1695 || start_address < pinfo->buffer_vma)
1698 addr_offset = start_address - pinfo->buffer_vma;
1700 if (stop_address == (bfd_vma) -1)
1701 stop_offset = datasize / opb;
1704 if (stop_address < pinfo->buffer_vma)
1707 stop_offset = stop_address - pinfo->buffer_vma;
1708 if (stop_offset > pinfo->buffer_length / opb)
1709 stop_offset = pinfo->buffer_length / opb;
1712 /* Skip over the relocs belonging to addresses below the
1714 while (rel_pp < rel_ppend
1715 && (*rel_pp)->address < rel_offset + addr_offset)
1718 printf (_("Disassembly of section %s:\n"), section->name);
1720 /* Find the nearest symbol forwards from our current position. */
1721 paux->require_sec = TRUE;
1722 sym = find_symbol_for_address (section->vma + addr_offset, info, &place);
1723 paux->require_sec = FALSE;
1725 /* Disassemble a block of instructions up to the address associated with
1726 the symbol we have just found. Then print the symbol and find the
1727 next symbol on. Repeat until we have disassembled the entire section
1728 or we have reached the end of the address range we are interested in. */
1729 while (addr_offset < stop_offset)
1733 unsigned long nextstop_offset;
1736 addr = section->vma + addr_offset;
1738 if (sym != NULL && bfd_asymbol_value (sym) <= addr)
1743 (x < sorted_symcount
1744 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
1748 pinfo->symbols = sorted_syms + place;
1749 pinfo->num_symbols = x - place;
1750 pinfo->symtab_pos = place;
1754 pinfo->symbols = NULL;
1755 pinfo->num_symbols = 0;
1756 pinfo->symtab_pos = -1;
1759 if (! prefix_addresses)
1761 pinfo->fprintf_func (pinfo->stream, "\n");
1762 objdump_print_addr_with_sym (abfd, section, sym, addr,
1764 pinfo->fprintf_func (pinfo->stream, ":\n");
1767 if (sym != NULL && bfd_asymbol_value (sym) > addr)
1769 else if (sym == NULL)
1773 #define is_valid_next_sym(SYM) \
1774 ((SYM)->section == section \
1775 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1776 && pinfo->symbol_is_valid (SYM, pinfo))
1778 /* Search forward for the next appropriate symbol in
1779 SECTION. Note that all the symbols are sorted
1780 together into one big array, and that some sections
1781 may have overlapping addresses. */
1782 while (place < sorted_symcount
1783 && ! is_valid_next_sym (sorted_syms [place]))
1786 if (place >= sorted_symcount)
1789 nextsym = sorted_syms[place];
1792 if (sym != NULL && bfd_asymbol_value (sym) > addr)
1793 nextstop_offset = bfd_asymbol_value (sym) - section->vma;
1794 else if (nextsym == NULL)
1795 nextstop_offset = stop_offset;
1797 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
1799 if (nextstop_offset > stop_offset)
1800 nextstop_offset = stop_offset;
1802 /* If a symbol is explicitly marked as being an object
1803 rather than a function, just dump the bytes without
1804 disassembling them. */
1807 || bfd_asymbol_value (sym) > addr
1808 || ((sym->flags & BSF_OBJECT) == 0
1809 && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1811 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1813 || (sym->flags & BSF_FUNCTION) != 0)
1818 disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
1819 addr_offset, nextstop_offset,
1820 rel_offset, &rel_pp, rel_ppend);
1822 addr_offset = nextstop_offset;
1828 if (rel_ppstart != NULL)
1832 /* Disassemble the contents of an object file. */
1835 disassemble_data (bfd *abfd)
1837 struct disassemble_info disasm_info;
1838 struct objdump_disasm_info aux;
1842 prev_functionname = NULL;
1845 /* We make a copy of syms to sort. We don't want to sort syms
1846 because that will screw up the relocs. */
1847 sorted_symcount = symcount ? symcount : dynsymcount;
1848 sorted_syms = xmalloc ((sorted_symcount + synthcount) * sizeof (asymbol *));
1849 memcpy (sorted_syms, symcount ? syms : dynsyms,
1850 sorted_symcount * sizeof (asymbol *));
1852 sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
1854 for (i = 0; i < synthcount; ++i)
1856 sorted_syms[sorted_symcount] = synthsyms + i;
1860 /* Sort the symbols into section and symbol order. */
1861 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
1863 init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
1865 disasm_info.application_data = (void *) &aux;
1867 aux.require_sec = FALSE;
1868 aux.dynrelbuf = NULL;
1869 aux.dynrelcount = 0;
1872 disasm_info.print_address_func = objdump_print_address;
1873 disasm_info.symbol_at_address_func = objdump_symbol_at_address;
1875 if (machine != NULL)
1877 const bfd_arch_info_type *info = bfd_scan_arch (machine);
1880 fatal (_("Can't use supplied machine %s"), machine);
1882 abfd->arch_info = info;
1885 if (endian != BFD_ENDIAN_UNKNOWN)
1887 struct bfd_target *xvec;
1889 xvec = xmalloc (sizeof (struct bfd_target));
1890 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
1891 xvec->byteorder = endian;
1895 /* Use libopcodes to locate a suitable disassembler. */
1896 aux.disassemble_fn = disassembler (abfd);
1897 if (!aux.disassemble_fn)
1899 non_fatal (_("Can't disassemble for architecture %s\n"),
1900 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
1905 disasm_info.flavour = bfd_get_flavour (abfd);
1906 disasm_info.arch = bfd_get_arch (abfd);
1907 disasm_info.mach = bfd_get_mach (abfd);
1908 disasm_info.disassembler_options = disassembler_options;
1909 disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
1910 disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
1911 disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
1912 disasm_info.disassembler_needs_relocs = FALSE;
1914 if (bfd_big_endian (abfd))
1915 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
1916 else if (bfd_little_endian (abfd))
1917 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
1919 /* ??? Aborting here seems too drastic. We could default to big or little
1921 disasm_info.endian = BFD_ENDIAN_UNKNOWN;
1923 /* Allow the target to customize the info structure. */
1924 disassemble_init_for_target (& disasm_info);
1926 /* Pre-load the dynamic relocs if we are going
1927 to be dumping them along with the disassembly. */
1928 if (dump_dynamic_reloc_info)
1930 long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
1933 bfd_fatal (bfd_get_filename (abfd));
1937 aux.dynrelbuf = xmalloc (relsize);
1938 aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
1941 if (aux.dynrelcount < 0)
1942 bfd_fatal (bfd_get_filename (abfd));
1944 /* Sort the relocs by address. */
1945 qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
1949 disasm_info.symtab = sorted_syms;
1950 disasm_info.symtab_size = sorted_symcount;
1952 bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
1954 if (aux.dynrelbuf != NULL)
1955 free (aux.dynrelbuf);
1960 load_debug_section (enum dwarf_section_display_enum debug, void *file)
1962 struct dwarf_section *section = &debug_displays [debug].section;
1967 /* If it is already loaded, do nothing. */
1968 if (section->start != NULL)
1971 /* Locate the debug section. */
1972 sec = bfd_get_section_by_name (abfd, section->name);
1976 section->address = bfd_get_section_vma (abfd, sec);
1977 section->size = bfd_get_section_size (sec);
1978 section->start = xmalloc (section->size);
1980 if (is_relocatable && debug_displays [debug].relocate)
1981 ret = bfd_simple_get_relocated_section_contents (abfd,
1986 ret = bfd_get_section_contents (abfd, sec, section->start, 0,
1991 free_debug_section (debug);
1992 printf (_("\nCan't get contents for section '%s'.\n"),
2000 free_debug_section (enum dwarf_section_display_enum debug)
2002 struct dwarf_section *section = &debug_displays [debug].section;
2004 if (section->start == NULL)
2007 free ((char *) section->start);
2008 section->start = NULL;
2009 section->address = 0;
2014 dump_dwarf_section (bfd *abfd, asection *section,
2015 void *arg ATTRIBUTE_UNUSED)
2017 const char *name = bfd_get_section_name (abfd, section);
2019 enum dwarf_section_display_enum i;
2021 if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
2022 match = ".debug_info";
2026 for (i = 0; i < max; i++)
2027 if (strcmp (debug_displays[i].section.name, match) == 0)
2029 if (!debug_displays[i].eh_frame)
2031 struct dwarf_section *sec = &debug_displays [i].section;
2033 if (load_debug_section (i, abfd))
2035 debug_displays[i].display (sec, abfd);
2037 if (i != info && i != abbrev)
2038 free_debug_section (i);
2045 static const char *mach_o_dwarf_sections [] = {
2046 "LC_SEGMENT.__DWARFA.__debug_abbrev", /* .debug_abbrev */
2047 "LC_SEGMENT.__DWARFA.__debug_aranges", /* .debug_aranges */
2048 "LC_SEGMENT.__DWARFA.__debug_frame", /* .debug_frame */
2049 "LC_SEGMENT.__DWARFA.__debug_info", /* .debug_info */
2050 "LC_SEGMENT.__DWARFA.__debug_line", /* .debug_line */
2051 "LC_SEGMENT.__DWARFA.__debug_pubnames", /* .debug_pubnames */
2052 ".eh_frame", /* .eh_frame */
2053 "LC_SEGMENT.__DWARFA.__debug_macinfo", /* .debug_macinfo */
2054 "LC_SEGMENT.__DWARFA.__debug_str", /* .debug_str */
2055 "LC_SEGMENT.__DWARFA.__debug_loc", /* .debug_loc */
2056 "LC_SEGMENT.__DWARFA.__debug_pubtypes", /* .debug_pubtypes */
2057 "LC_SEGMENT.__DWARFA.__debug_ranges", /* .debug_ranges */
2058 "LC_SEGMENT.__DWARFA.__debug_static_func", /* .debug_static_func */
2059 "LC_SEGMENT.__DWARFA.__debug_static_vars", /* .debug_static_vars */
2060 "LC_SEGMENT.__DWARFA.__debug_types", /* .debug_types */
2061 "LC_SEGMENT.__DWARFA.__debug_weaknames" /* .debug_weaknames */
2064 static const char *generic_dwarf_sections [max];
2067 check_mach_o_dwarf (bfd *abfd)
2069 static enum bfd_flavour old_flavour = bfd_target_unknown_flavour;
2070 enum bfd_flavour current_flavour = bfd_get_flavour (abfd);
2071 enum dwarf_section_display_enum i;
2073 if (generic_dwarf_sections [0] == NULL)
2074 for (i = 0; i < max; i++)
2075 generic_dwarf_sections [i] = debug_displays[i].section.name;
2077 if (old_flavour != current_flavour)
2079 if (current_flavour == bfd_target_mach_o_flavour)
2080 for (i = 0; i < max; i++)
2081 debug_displays[i].section.name = mach_o_dwarf_sections [i];
2082 else if (old_flavour == bfd_target_mach_o_flavour)
2083 for (i = 0; i < max; i++)
2084 debug_displays[i].section.name = generic_dwarf_sections [i];
2086 old_flavour = current_flavour;
2090 /* Dump the dwarf debugging information. */
2093 dump_dwarf (bfd *abfd)
2095 is_relocatable = ((abfd->flags & (HAS_RELOC | EXEC_P | DYNAMIC))
2098 /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
2099 targets will return 64. */
2100 eh_addr_size = bfd_get_arch_size (abfd) == 64 ? 8 : 4;
2102 if (bfd_big_endian (abfd))
2103 byte_get = byte_get_big_endian;
2104 else if (bfd_little_endian (abfd))
2105 byte_get = byte_get_little_endian;
2109 check_mach_o_dwarf (abfd);
2111 bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2113 free_debug_memory ();
2116 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2117 it. Return NULL on failure. */
2120 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
2126 stabsect = bfd_get_section_by_name (abfd, sect_name);
2127 if (stabsect == NULL)
2129 printf (_("No %s section present\n\n"), sect_name);
2133 size = bfd_section_size (abfd, stabsect);
2134 contents = xmalloc (size);
2136 if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
2138 non_fatal (_("Reading %s section of %s failed: %s"),
2139 sect_name, bfd_get_filename (abfd),
2140 bfd_errmsg (bfd_get_error ()));
2151 /* Stabs entries use a 12 byte format:
2152 4 byte string table index
2154 1 byte stab other field
2155 2 byte stab desc field
2157 FIXME: This will have to change for a 64 bit object format. */
2159 #define STRDXOFF (0)
2161 #define OTHEROFF (5)
2164 #define STABSIZE (12)
2166 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2167 using string table section STRSECT_NAME (in `strtab'). */
2170 print_section_stabs (bfd *abfd,
2171 const char *stabsect_name,
2172 unsigned *string_offset_ptr)
2175 unsigned file_string_table_offset = 0;
2176 unsigned next_file_string_table_offset = *string_offset_ptr;
2177 bfd_byte *stabp, *stabs_end;
2180 stabs_end = stabp + stab_size;
2182 printf (_("Contents of %s section:\n\n"), stabsect_name);
2183 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2185 /* Loop through all symbols and print them.
2187 We start the index at -1 because there is a dummy symbol on
2188 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2189 for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
2193 unsigned char type, other;
2194 unsigned short desc;
2197 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2198 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2199 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2200 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2201 value = bfd_h_get_32 (abfd, stabp + VALOFF);
2203 printf ("\n%-6d ", i);
2204 /* Either print the stab name, or, if unnamed, print its number
2205 again (makes consistent formatting for tools like awk). */
2206 name = bfd_get_stab_name (type);
2208 printf ("%-6s", name);
2209 else if (type == N_UNDF)
2212 printf ("%-6d", type);
2213 printf (" %-6d %-6d ", other, desc);
2214 bfd_printf_vma (abfd, value);
2215 printf (" %-6lu", strx);
2217 /* Symbols with type == 0 (N_UNDF) specify the length of the
2218 string table associated with this file. We use that info
2219 to know how to relocate the *next* file's string table indices. */
2222 file_string_table_offset = next_file_string_table_offset;
2223 next_file_string_table_offset += value;
2227 /* Using the (possibly updated) string table offset, print the
2228 string (if any) associated with this symbol. */
2229 if ((strx + file_string_table_offset) < stabstr_size)
2230 printf (" %s", &strtab[strx + file_string_table_offset]);
2236 *string_offset_ptr = next_file_string_table_offset;
2241 const char * section_name;
2242 const char * string_section_name;
2243 unsigned string_offset;
2248 find_stabs_section (bfd *abfd, asection *section, void *names)
2251 stab_section_names * sought = (stab_section_names *) names;
2253 /* Check for section names for which stabsect_name is a prefix, to
2254 handle .stab.N, etc. */
2255 len = strlen (sought->section_name);
2257 /* If the prefix matches, and the files section name ends with a
2258 nul or a digit, then we match. I.e., we want either an exact
2259 match or a section followed by a number. */
2260 if (strncmp (sought->section_name, section->name, len) == 0
2261 && (section->name[len] == 0
2262 || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2265 strtab = read_section_stabs (abfd, sought->string_section_name,
2270 stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2273 print_section_stabs (abfd, section->name, &sought->string_offset);
2279 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2281 stab_section_names s;
2283 s.section_name = stabsect_name;
2284 s.string_section_name = strsect_name;
2285 s.string_offset = 0;
2287 bfd_map_over_sections (abfd, find_stabs_section, & s);
2293 /* Dump the any sections containing stabs debugging information. */
2296 dump_stabs (bfd *abfd)
2298 dump_stabs_section (abfd, ".stab", ".stabstr");
2299 dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2300 dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2301 dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2305 dump_bfd_header (bfd *abfd)
2309 printf (_("architecture: %s, "),
2310 bfd_printable_arch_mach (bfd_get_arch (abfd),
2311 bfd_get_mach (abfd)));
2312 printf (_("flags 0x%08x:\n"), abfd->flags);
2314 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2315 PF (HAS_RELOC, "HAS_RELOC");
2316 PF (EXEC_P, "EXEC_P");
2317 PF (HAS_LINENO, "HAS_LINENO");
2318 PF (HAS_DEBUG, "HAS_DEBUG");
2319 PF (HAS_SYMS, "HAS_SYMS");
2320 PF (HAS_LOCALS, "HAS_LOCALS");
2321 PF (DYNAMIC, "DYNAMIC");
2322 PF (WP_TEXT, "WP_TEXT");
2323 PF (D_PAGED, "D_PAGED");
2324 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2325 PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
2326 printf (_("\nstart address 0x"));
2327 bfd_printf_vma (abfd, abfd->start_address);
2333 dump_bfd_private_header (bfd *abfd)
2335 bfd_print_private_bfd_data (abfd, stdout);
2339 /* Display a section in hexadecimal format with associated characters.
2340 Each line prefixed by the zero padded address. */
2343 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2346 bfd_size_type datasize;
2347 bfd_size_type addr_offset;
2348 bfd_size_type start_offset;
2349 bfd_size_type stop_offset;
2350 unsigned int opb = bfd_octets_per_byte (abfd);
2351 /* Bytes per line. */
2352 const int onaline = 16;
2357 if ((section->flags & SEC_HAS_CONTENTS) == 0)
2360 if (! process_section_p (section))
2363 if ((datasize = bfd_section_size (abfd, section)) == 0)
2366 printf (_("Contents of section %s:\n"), section->name);
2368 data = xmalloc (datasize);
2370 bfd_get_section_contents (abfd, section, data, 0, datasize);
2372 /* Compute the address range to display. */
2373 if (start_address == (bfd_vma) -1
2374 || start_address < section->vma)
2377 start_offset = start_address - section->vma;
2379 if (stop_address == (bfd_vma) -1)
2380 stop_offset = datasize / opb;
2383 if (stop_address < section->vma)
2386 stop_offset = stop_address - section->vma;
2388 if (stop_offset > datasize / opb)
2389 stop_offset = datasize / opb;
2394 bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2395 if (strlen (buf) >= sizeof (buf))
2399 while (buf[count] == '0' && buf[count+1] != '\0')
2401 count = strlen (buf) - count;
2405 bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2406 if (strlen (buf) >= sizeof (buf))
2410 while (buf[count] == '0' && buf[count+1] != '\0')
2412 count = strlen (buf) - count;
2416 for (addr_offset = start_offset;
2417 addr_offset < stop_offset; addr_offset += onaline / opb)
2421 bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2422 count = strlen (buf);
2423 if ((size_t) count >= sizeof (buf))
2427 while (count < width)
2432 fputs (buf + count - width, stdout);
2435 for (j = addr_offset * opb;
2436 j < addr_offset * opb + onaline; j++)
2438 if (j < stop_offset * opb)
2439 printf ("%02x", (unsigned) (data[j]));
2447 for (j = addr_offset * opb;
2448 j < addr_offset * opb + onaline; j++)
2450 if (j >= stop_offset * opb)
2453 printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2460 /* Actually display the various requested regions. */
2463 dump_data (bfd *abfd)
2465 bfd_map_over_sections (abfd, dump_section, NULL);
2468 /* Should perhaps share code and display with nm? */
2471 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2481 printf ("DYNAMIC SYMBOL TABLE:\n");
2487 printf ("SYMBOL TABLE:\n");
2491 printf (_("no symbols\n"));
2493 for (count = 0; count < max; count++)
2497 if (*current == NULL)
2498 printf (_("no information for symbol number %ld\n"), count);
2500 else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2501 printf (_("could not determine the type of symbol number %ld\n"),
2504 else if (process_section_p ((* current)->section)
2505 && (dump_special_syms
2506 || !bfd_is_target_special_symbol (cur_bfd, *current)))
2508 const char *name = (*current)->name;
2510 if (do_demangle && name != NULL && *name != '\0')
2514 /* If we want to demangle the name, we demangle it
2515 here, and temporarily clobber it while calling
2516 bfd_print_symbol. FIXME: This is a gross hack. */
2517 alloc = demangle (cur_bfd, name);
2518 (*current)->name = alloc;
2519 bfd_print_symbol (cur_bfd, stdout, *current,
2520 bfd_print_symbol_all);
2521 (*current)->name = name;
2525 bfd_print_symbol (cur_bfd, stdout, *current,
2526 bfd_print_symbol_all);
2536 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2539 char *last_filename, *last_functionname;
2540 unsigned int last_line;
2542 /* Get column headers lined up reasonably. */
2550 bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2551 width = strlen (buf) - 7;
2553 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2556 last_filename = NULL;
2557 last_functionname = NULL;
2560 for (p = relpp; relcount && *p != NULL; p++, relcount--)
2563 const char *filename, *functionname;
2565 const char *sym_name;
2566 const char *section_name;
2568 if (start_address != (bfd_vma) -1
2569 && q->address < start_address)
2571 if (stop_address != (bfd_vma) -1
2572 && q->address > stop_address)
2575 if (with_line_numbers
2577 && bfd_find_nearest_line (abfd, sec, syms, q->address,
2578 &filename, &functionname, &line))
2580 if (functionname != NULL
2581 && (last_functionname == NULL
2582 || strcmp (functionname, last_functionname) != 0))
2584 printf ("%s():\n", functionname);
2585 if (last_functionname != NULL)
2586 free (last_functionname);
2587 last_functionname = xstrdup (functionname);
2591 && (line != last_line
2592 || (filename != NULL
2593 && last_filename != NULL
2594 && strcmp (filename, last_filename) != 0)))
2596 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2598 if (last_filename != NULL)
2599 free (last_filename);
2600 if (filename == NULL)
2601 last_filename = NULL;
2603 last_filename = xstrdup (filename);
2607 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2609 sym_name = (*(q->sym_ptr_ptr))->name;
2610 section_name = (*(q->sym_ptr_ptr))->section->name;
2615 section_name = NULL;
2618 bfd_printf_vma (abfd, q->address);
2619 if (q->howto == NULL)
2620 printf (" *unknown* ");
2621 else if (q->howto->name)
2622 printf (" %-16s ", q->howto->name);
2624 printf (" %-16d ", q->howto->type);
2626 objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
2629 if (section_name == NULL)
2630 section_name = "*unknown*";
2631 printf ("[%s]", section_name);
2637 bfd_printf_vma (abfd, q->addend);
2645 dump_relocs_in_section (bfd *abfd,
2647 void *dummy ATTRIBUTE_UNUSED)
2653 if ( bfd_is_abs_section (section)
2654 || bfd_is_und_section (section)
2655 || bfd_is_com_section (section)
2656 || (! process_section_p (section))
2657 || ((section->flags & SEC_RELOC) == 0))
2660 relsize = bfd_get_reloc_upper_bound (abfd, section);
2662 bfd_fatal (bfd_get_filename (abfd));
2664 printf ("RELOCATION RECORDS FOR [%s]:", section->name);
2668 printf (" (none)\n\n");
2672 relpp = xmalloc (relsize);
2673 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
2676 bfd_fatal (bfd_get_filename (abfd));
2677 else if (relcount == 0)
2678 printf (" (none)\n\n");
2682 dump_reloc_set (abfd, section, relpp, relcount);
2689 dump_relocs (bfd *abfd)
2691 bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
2695 dump_dynamic_relocs (bfd *abfd)
2701 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2703 bfd_fatal (bfd_get_filename (abfd));
2705 printf ("DYNAMIC RELOCATION RECORDS");
2708 printf (" (none)\n\n");
2711 relpp = xmalloc (relsize);
2712 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2715 bfd_fatal (bfd_get_filename (abfd));
2716 else if (relcount == 0)
2717 printf (" (none)\n\n");
2721 dump_reloc_set (abfd, NULL, relpp, relcount);
2728 /* Creates a table of paths, to search for source files. */
2731 add_include_path (const char *path)
2735 include_path_count++;
2736 include_paths = xrealloc (include_paths,
2737 include_path_count * sizeof (*include_paths));
2738 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2739 if (path[1] == ':' && path[2] == 0)
2740 path = concat (path, ".", (const char *) 0);
2742 include_paths[include_path_count - 1] = path;
2746 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
2750 if ((section->flags & SEC_DEBUGGING) == 0)
2752 bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
2753 section->vma += adjust_section_vma;
2755 section->lma += adjust_section_vma;
2759 /* Dump selected contents of ABFD. */
2762 dump_bfd (bfd *abfd)
2764 /* If we are adjusting section VMA's, change them all now. Changing
2765 the BFD information is a hack. However, we must do it, or
2766 bfd_find_nearest_line will not do the right thing. */
2767 if (adjust_section_vma != 0)
2769 bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
2770 bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
2773 if (! dump_debugging_tags)
2774 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
2777 print_arelt_descr (stdout, abfd, TRUE);
2778 if (dump_file_header)
2779 dump_bfd_header (abfd);
2780 if (dump_private_headers)
2781 dump_bfd_private_header (abfd);
2782 if (! dump_debugging_tags)
2784 if (dump_section_headers)
2785 dump_headers (abfd);
2791 || dump_dwarf_section_info)
2792 syms = slurp_symtab (abfd);
2793 if (dump_dynamic_symtab || dump_dynamic_reloc_info
2794 || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
2795 dynsyms = slurp_dynamic_symtab (abfd);
2798 synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
2799 dynsymcount, dynsyms, &synthsyms);
2805 dump_symbols (abfd, FALSE);
2806 if (dump_dynamic_symtab)
2807 dump_symbols (abfd, TRUE);
2808 if (dump_dwarf_section_info)
2810 if (dump_stab_section_info)
2812 if (dump_reloc_info && ! disassemble)
2814 if (dump_dynamic_reloc_info && ! disassemble)
2815 dump_dynamic_relocs (abfd);
2816 if (dump_section_contents)
2819 disassemble_data (abfd);
2825 dhandle = read_debugging_info (abfd, syms, symcount);
2826 if (dhandle != NULL)
2828 if (! print_debugging_info (stdout, dhandle, abfd, syms, demangle,
2829 dump_debugging_tags ? TRUE : FALSE))
2831 non_fatal (_("%s: printing debugging information failed"),
2832 bfd_get_filename (abfd));
2862 display_bfd (bfd *abfd)
2866 if (bfd_check_format_matches (abfd, bfd_object, &matching))
2872 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2874 nonfatal (bfd_get_filename (abfd));
2875 list_matching_formats (matching);
2880 if (bfd_get_error () != bfd_error_file_not_recognized)
2882 nonfatal (bfd_get_filename (abfd));
2886 if (bfd_check_format_matches (abfd, bfd_core, &matching))
2892 nonfatal (bfd_get_filename (abfd));
2894 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2896 list_matching_formats (matching);
2902 display_file (char *filename, char *target)
2907 if (get_file_size (filename) < 1)
2913 file = bfd_openr (filename, target);
2916 nonfatal (filename);
2920 /* If the file is an archive, process all of its elements. */
2921 if (bfd_check_format (file, bfd_archive))
2923 bfd *last_arfile = NULL;
2925 printf (_("In archive %s:\n"), bfd_get_filename (file));
2928 bfd_set_error (bfd_error_no_error);
2930 arfile = bfd_openr_next_archived_file (file, arfile);
2933 if (bfd_get_error () != bfd_error_no_more_archived_files)
2934 nonfatal (bfd_get_filename (file));
2938 display_bfd (arfile);
2940 if (last_arfile != NULL)
2941 bfd_close (last_arfile);
2942 last_arfile = arfile;
2945 if (last_arfile != NULL)
2946 bfd_close (last_arfile);
2955 main (int argc, char **argv)
2958 char *target = default_target;
2959 bfd_boolean seenflag = FALSE;
2961 #if defined (HAVE_SETLOCALE)
2962 #if defined (HAVE_LC_MESSAGES)
2963 setlocale (LC_MESSAGES, "");
2965 setlocale (LC_CTYPE, "");
2968 bindtextdomain (PACKAGE, LOCALEDIR);
2969 textdomain (PACKAGE);
2971 program_name = *argv;
2972 xmalloc_set_program_name (program_name);
2974 START_PROGRESS (program_name, 0);
2976 expandargv (&argc, &argv);
2979 set_default_bfd_target ();
2981 while ((c = getopt_long (argc, argv, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeGW",
2982 long_options, (int *) 0))
2988 break; /* We've been given a long option. */
2993 if (disassembler_options)
2994 /* Ignore potential memory leak for now. */
2995 disassembler_options = concat (disassembler_options, ",",
2998 disassembler_options = optarg;
3001 if (only_used == only_size)
3004 only = xrealloc (only, only_size * sizeof (char *));
3006 only [only_used++] = optarg;
3009 with_line_numbers = TRUE;
3018 enum demangling_styles style;
3020 style = cplus_demangle_name_to_style (optarg);
3021 if (style == unknown_demangling)
3022 fatal (_("unknown demangling style `%s'"),
3025 cplus_demangle_set_style (style);
3031 case OPTION_ADJUST_VMA:
3032 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3034 case OPTION_START_ADDRESS:
3035 start_address = parse_vma (optarg, "--start-address");
3037 case OPTION_STOP_ADDRESS:
3038 stop_address = parse_vma (optarg, "--stop-address");
3041 if (strcmp (optarg, "B") == 0)
3042 endian = BFD_ENDIAN_BIG;
3043 else if (strcmp (optarg, "L") == 0)
3044 endian = BFD_ENDIAN_LITTLE;
3047 non_fatal (_("unrecognized -E option"));
3052 if (strncmp (optarg, "big", strlen (optarg)) == 0)
3053 endian = BFD_ENDIAN_BIG;
3054 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3055 endian = BFD_ENDIAN_LITTLE;
3058 non_fatal (_("unrecognized --endian type `%s'"), optarg);
3064 dump_file_header = TRUE;
3068 formats_info = TRUE;
3072 add_include_path (optarg);
3075 dump_private_headers = TRUE;
3079 dump_private_headers = TRUE;
3081 dump_reloc_info = TRUE;
3082 dump_file_header = TRUE;
3083 dump_ar_hdrs = TRUE;
3084 dump_section_headers = TRUE;
3092 dump_dynamic_symtab = TRUE;
3100 disassemble_zeroes = TRUE;
3104 disassemble_all = TRUE;
3109 with_source_code = TRUE;
3118 dump_debugging_tags = 1;
3123 dump_dwarf_section_info = TRUE;
3126 do_debug_abbrevs = 1;
3128 do_debug_pubnames = 1;
3129 do_debug_aranges = 1;
3130 do_debug_ranges = 1;
3131 do_debug_frames = 1;
3132 do_debug_macinfo = 1;
3137 dump_stab_section_info = TRUE;
3141 dump_section_contents = TRUE;
3145 dump_reloc_info = TRUE;
3149 dump_dynamic_reloc_info = TRUE;
3153 dump_ar_hdrs = TRUE;
3157 dump_section_headers = TRUE;
3165 show_version = TRUE;
3175 print_version ("objdump");
3181 exit_status = display_info ();
3185 display_file ("a.out", target);
3187 for (; optind < argc;)
3188 display_file (argv[optind++], target);
3191 END_PROGRESS (program_name);