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 = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
658 (*info->fprintf_func) (info->stream, "%s", name);
666 /* Locate a symbol given a bfd and a section (from INFO->application_data),
667 and a VMA. If INFO->application_data->require_sec is TRUE, then always
668 require the symbol to be in the section. Returns NULL if there is no
669 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
670 of the symbol in sorted_syms. */
673 find_symbol_for_address (bfd_vma vma,
674 struct disassemble_info *info,
677 /* @@ Would it speed things up to cache the last two symbols returned,
678 and maybe their address ranges? For many processors, only one memory
679 operand can be present at a time, so the 2-entry cache wouldn't be
680 constantly churned by code doing heavy memory accesses. */
682 /* Indices in `sorted_syms'. */
684 long max = sorted_symcount;
686 struct objdump_disasm_info *aux;
691 if (sorted_symcount < 1)
694 aux = (struct objdump_disasm_info *) info->application_data;
697 opb = bfd_octets_per_byte (abfd);
699 /* Perform a binary search looking for the closest symbol to the
700 required value. We are searching the range (min, max]. */
701 while (min + 1 < max)
705 thisplace = (max + min) / 2;
706 sym = sorted_syms[thisplace];
708 if (bfd_asymbol_value (sym) > vma)
710 else if (bfd_asymbol_value (sym) < vma)
719 /* The symbol we want is now in min, the low end of the range we
720 were searching. If there are several symbols with the same
721 value, we want the first one. */
724 && (bfd_asymbol_value (sorted_syms[thisplace])
725 == bfd_asymbol_value (sorted_syms[thisplace - 1])))
728 /* If the file is relocatable, and the symbol could be from this
729 section, prefer a symbol from this section over symbols from
730 others, even if the other symbol's value might be closer.
732 Note that this may be wrong for some symbol references if the
733 sections have overlapping memory ranges, but in that case there's
734 no way to tell what's desired without looking at the relocation
736 if (sorted_syms[thisplace]->section != sec
738 || ((abfd->flags & HAS_RELOC) != 0
739 && vma >= bfd_get_section_vma (abfd, sec)
740 && vma < (bfd_get_section_vma (abfd, sec)
741 + bfd_section_size (abfd, sec) / opb))))
745 for (i = thisplace + 1; i < sorted_symcount; i++)
747 if (bfd_asymbol_value (sorted_syms[i])
748 != bfd_asymbol_value (sorted_syms[thisplace]))
756 if (sorted_syms[i]->section == sec
758 || sorted_syms[i - 1]->section != sec
759 || (bfd_asymbol_value (sorted_syms[i])
760 != bfd_asymbol_value (sorted_syms[i - 1]))))
767 if (sorted_syms[thisplace]->section != sec)
769 /* We didn't find a good symbol with a smaller value.
770 Look for one with a larger value. */
771 for (i = thisplace + 1; i < sorted_symcount; i++)
773 if (sorted_syms[i]->section == sec)
781 if (sorted_syms[thisplace]->section != sec
783 || ((abfd->flags & HAS_RELOC) != 0
784 && vma >= bfd_get_section_vma (abfd, sec)
785 && vma < (bfd_get_section_vma (abfd, sec)
786 + bfd_section_size (abfd, sec)))))
787 /* There is no suitable symbol. */
791 /* Give the target a chance to reject the symbol. */
792 while (! info->symbol_is_valid (sorted_syms [thisplace], info))
795 if (thisplace >= sorted_symcount
796 || bfd_asymbol_value (sorted_syms [thisplace]) > vma)
803 return sorted_syms[thisplace];
806 /* Print an address and the offset to the nearest symbol. */
809 objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
810 bfd_vma vma, struct disassemble_info *info,
811 bfd_boolean skip_zeroes)
813 objdump_print_value (vma, info, skip_zeroes);
819 (*info->fprintf_func) (info->stream, " <%s",
820 bfd_get_section_name (abfd, sec));
821 secaddr = bfd_get_section_vma (abfd, sec);
824 (*info->fprintf_func) (info->stream, "-0x");
825 objdump_print_value (secaddr - vma, info, TRUE);
827 else if (vma > secaddr)
829 (*info->fprintf_func) (info->stream, "+0x");
830 objdump_print_value (vma - secaddr, info, TRUE);
832 (*info->fprintf_func) (info->stream, ">");
836 (*info->fprintf_func) (info->stream, " <");
837 objdump_print_symname (abfd, info, sym);
838 if (bfd_asymbol_value (sym) > vma)
840 (*info->fprintf_func) (info->stream, "-0x");
841 objdump_print_value (bfd_asymbol_value (sym) - vma, info, TRUE);
843 else if (vma > bfd_asymbol_value (sym))
845 (*info->fprintf_func) (info->stream, "+0x");
846 objdump_print_value (vma - bfd_asymbol_value (sym), info, TRUE);
848 (*info->fprintf_func) (info->stream, ">");
852 /* Print an address (VMA), symbolically if possible.
853 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
856 objdump_print_addr (bfd_vma vma,
857 struct disassemble_info *info,
858 bfd_boolean skip_zeroes)
860 struct objdump_disasm_info *aux;
861 asymbol *sym = NULL; /* Initialize to avoid compiler warning. */
862 bfd_boolean skip_find = FALSE;
864 if (sorted_symcount < 1)
866 (*info->fprintf_func) (info->stream, "0x");
867 objdump_print_value (vma, info, skip_zeroes);
871 aux = (struct objdump_disasm_info *) info->application_data;
873 if (aux->reloc != NULL
874 && aux->reloc->sym_ptr_ptr != NULL
875 && * aux->reloc->sym_ptr_ptr != NULL)
877 sym = * aux->reloc->sym_ptr_ptr;
879 /* Adjust the vma to the reloc. */
880 vma += bfd_asymbol_value (sym);
882 if (bfd_is_und_section (bfd_get_section (sym)))
887 sym = find_symbol_for_address (vma, info, NULL);
889 objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, info,
893 /* Print VMA to INFO. This function is passed to the disassembler
897 objdump_print_address (bfd_vma vma, struct disassemble_info *info)
899 objdump_print_addr (vma, info, ! prefix_addresses);
902 /* Determine if the given address has a symbol associated with it. */
905 objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * info)
909 sym = find_symbol_for_address (vma, info, NULL);
911 return (sym != NULL && (bfd_asymbol_value (sym) == vma));
914 /* Hold the last function name and the last line number we displayed
917 static char *prev_functionname;
918 static unsigned int prev_line;
920 /* We keep a list of all files that we have seen when doing a
921 disassembly with source, so that we know how much of the file to
922 display. This can be important for inlined functions. */
924 struct print_file_list
926 struct print_file_list *next;
927 const char *filename;
933 static struct print_file_list *print_files;
935 /* The number of preceding context lines to show when we start
936 displaying a file for the first time. */
938 #define SHOW_PRECEDING_CONTEXT_LINES (5)
940 /* Tries to open MODNAME, and if successful adds a node to print_files
941 linked list and returns that node. Returns NULL on failure. */
943 static struct print_file_list *
944 try_print_file_open (const char *origname, const char *modname)
946 struct print_file_list *p;
949 f = fopen (modname, "r");
953 if (print_files != NULL && print_files->f != NULL)
955 fclose (print_files->f);
956 print_files->f = NULL;
959 p = xmalloc (sizeof (struct print_file_list));
960 p->filename = origname;
961 p->modname = modname;
964 p->next = print_files;
969 /* If the the source file, as described in the symtab, is not found
970 try to locate it in one of the paths specified with -I
971 If found, add location to print_files linked list. */
973 static struct print_file_list *
974 update_source_path (const char *filename)
976 struct print_file_list *p;
980 if (filename == NULL)
983 p = try_print_file_open (filename, filename);
987 if (include_path_count == 0)
990 /* Get the name of the file. */
991 fname = strrchr (filename, '/');
992 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
994 /* We could have a mixed forward/back slash case. */
995 char *backslash = strrchr (filename, '\\');
996 if (fname == NULL || (backslash != NULL && backslash > fname))
998 if (fname == NULL && filename[0] != '\0' && filename[1] == ':')
999 fname = filename + 1;
1007 /* If file exists under a new path, we need to add it to the list
1008 so that show_line knows about it. */
1009 for (i = 0; i < include_path_count; i++)
1011 char *modname = concat (include_paths[i], "/", fname, (const char *) 0);
1013 p = try_print_file_open (filename, modname);
1023 /* Skip ahead to a given line in a file, optionally printing each
1027 skip_to_line (struct print_file_list *p, unsigned int line,
1030 while (p->line < line)
1034 if (fgets (buf, sizeof buf, p->f) == NULL)
1044 if (strchr (buf, '\n') != NULL)
1049 /* Show the line number, or the source line, in a disassembly
1053 show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
1055 const char *filename;
1056 const char *functionname;
1059 if (! with_line_numbers && ! with_source_code)
1062 if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename,
1063 &functionname, &line))
1066 if (filename != NULL && *filename == '\0')
1068 if (functionname != NULL && *functionname == '\0')
1069 functionname = NULL;
1071 if (with_line_numbers)
1073 if (functionname != NULL
1074 && (prev_functionname == NULL
1075 || strcmp (functionname, prev_functionname) != 0))
1076 printf ("%s():\n", functionname);
1077 if (line > 0 && line != prev_line)
1078 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
1081 if (with_source_code
1085 struct print_file_list **pp, *p;
1087 for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1088 if (strcmp ((*pp)->filename, filename) == 0)
1094 if (p != print_files)
1098 /* We have reencountered a file name which we saw
1099 earlier. This implies that either we are dumping out
1100 code from an included file, or the same file was
1101 linked in more than once. There are two common cases
1102 of an included file: inline functions in a header
1103 file, and a bison or flex skeleton file. In the
1104 former case we want to just start printing (but we
1105 back up a few lines to give context); in the latter
1106 case we want to continue from where we left off. I
1107 can't think of a good way to distinguish the cases,
1108 so I used a heuristic based on the file name. */
1109 if (strcmp (p->filename + strlen (p->filename) - 2, ".h") != 0)
1113 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1120 p->f = fopen (p->modname, "r");
1124 skip_to_line (p, l, FALSE);
1126 if (print_files->f != NULL)
1128 fclose (print_files->f);
1129 print_files->f = NULL;
1135 skip_to_line (p, line, TRUE);
1137 p->next = print_files;
1143 p = update_source_path (filename);
1149 if (file_start_context)
1152 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1155 skip_to_line (p, l, FALSE);
1157 skip_to_line (p, line, TRUE);
1162 if (functionname != NULL
1163 && (prev_functionname == NULL
1164 || strcmp (functionname, prev_functionname) != 0))
1166 if (prev_functionname != NULL)
1167 free (prev_functionname);
1168 prev_functionname = xmalloc (strlen (functionname) + 1);
1169 strcpy (prev_functionname, functionname);
1172 if (line > 0 && line != prev_line)
1176 /* Pseudo FILE object for strings. */
1184 /* sprintf to a "stream". */
1186 static int ATTRIBUTE_PRINTF_2
1187 objdump_sprintf (SFILE *f, const char *format, ...)
1194 size_t space = f->alloc - f->pos;
1196 va_start (args, format);
1197 n = vsnprintf (f->buffer + f->pos, space, format, args);
1203 f->alloc = (f->alloc + n) * 2;
1204 f->buffer = xrealloc (f->buffer, f->alloc);
1211 /* Returns TRUE if the specified section should be dumped. */
1214 process_section_p (asection * section)
1221 for (i = 0; i < only_used; i++)
1222 if (strcmp (only [i], section->name) == 0)
1229 /* The number of zeroes we want to see before we start skipping them.
1230 The number is arbitrarily chosen. */
1232 #define DEFAULT_SKIP_ZEROES 8
1234 /* The number of zeroes to skip at the end of a section. If the
1235 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1236 SKIP_ZEROES, they will be disassembled. If there are fewer than
1237 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1238 attempt to avoid disassembling zeroes inserted by section
1241 #define DEFAULT_SKIP_ZEROES_AT_END 3
1243 /* Disassemble some data in memory between given values. */
1246 disassemble_bytes (struct disassemble_info * info,
1247 disassembler_ftype disassemble_fn,
1250 bfd_vma start_offset,
1251 bfd_vma stop_offset,
1254 arelent ** relppend)
1256 struct objdump_disasm_info *aux;
1258 int octets_per_line;
1259 bfd_boolean done_dot;
1260 int skip_addr_chars;
1261 bfd_vma addr_offset;
1262 unsigned int opb = info->octets_per_byte;
1263 unsigned int skip_zeroes = info->skip_zeroes;
1264 unsigned int skip_zeroes_at_end = info->skip_zeroes_at_end;
1268 aux = (struct objdump_disasm_info *) info->application_data;
1272 sfile.buffer = xmalloc (sfile.alloc);
1276 octets_per_line = 4;
1278 octets_per_line = 16;
1280 /* Figure out how many characters to skip at the start of an
1281 address, to make the disassembly look nicer. We discard leading
1282 zeroes in chunks of 4, ensuring that there is always a leading
1284 skip_addr_chars = 0;
1285 if (! prefix_addresses)
1293 + bfd_section_size (section->owner, section) / opb));
1295 while (s[0] == '0' && s[1] == '0' && s[2] == '0' && s[3] == '0'
1298 skip_addr_chars += 4;
1303 info->insn_info_valid = 0;
1306 addr_offset = start_offset;
1307 while (addr_offset < stop_offset)
1310 bfd_boolean need_nl = FALSE;
1311 int previous_octets;
1313 /* Remember the length of the previous instruction. */
1314 previous_octets = octets;
1317 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1319 for (z = addr_offset * opb; z < stop_offset * opb; z++)
1322 if (! disassemble_zeroes
1323 && (info->insn_info_valid == 0
1324 || info->branch_delay_insns == 0)
1325 && (z - addr_offset * opb >= skip_zeroes
1326 || (z == stop_offset * opb &&
1327 z - addr_offset * opb < skip_zeroes_at_end)))
1331 /* If there are more nonzero octets to follow, we only skip
1332 zeroes in multiples of 4, to try to avoid running over
1333 the start of an instruction which happens to start with
1335 if (z != stop_offset * opb)
1336 z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1338 octets = z - addr_offset * opb;
1348 if (with_line_numbers || with_source_code)
1349 show_line (aux->abfd, section, addr_offset);
1351 if (! prefix_addresses)
1355 bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
1356 for (s = buf + skip_addr_chars; *s == '0'; s++)
1360 printf ("%s:\t", buf + skip_addr_chars);
1364 aux->require_sec = TRUE;
1365 objdump_print_address (section->vma + addr_offset, info);
1366 aux->require_sec = FALSE;
1373 info->fprintf_func = (fprintf_ftype) objdump_sprintf;
1374 info->stream = &sfile;
1375 info->bytes_per_line = 0;
1376 info->bytes_per_chunk = 0;
1379 if (info->disassembler_needs_relocs
1380 && *relppp < relppend)
1382 bfd_signed_vma distance_to_rel;
1384 distance_to_rel = (**relppp)->address
1385 - (rel_offset + addr_offset);
1387 /* Check to see if the current reloc is associated with
1388 the instruction that we are about to disassemble. */
1389 if (distance_to_rel == 0
1390 /* FIXME: This is wrong. We are trying to catch
1391 relocs that are addressed part way through the
1392 current instruction, as might happen with a packed
1393 VLIW instruction. Unfortunately we do not know the
1394 length of the current instruction since we have not
1395 disassembled it yet. Instead we take a guess based
1396 upon the length of the previous instruction. The
1397 proper solution is to have a new target-specific
1398 disassembler function which just returns the length
1399 of an instruction at a given address without trying
1400 to display its disassembly. */
1401 || (distance_to_rel > 0
1402 && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
1404 info->flags = INSN_HAS_RELOC;
1405 aux->reloc = **relppp;
1411 octets = (*disassemble_fn) (section->vma + addr_offset, info);
1412 info->fprintf_func = (fprintf_ftype) fprintf;
1413 info->stream = stdout;
1414 if (info->bytes_per_line != 0)
1415 octets_per_line = info->bytes_per_line;
1419 printf ("%s\n", sfile.buffer);
1427 octets = octets_per_line;
1428 if (addr_offset + octets / opb > stop_offset)
1429 octets = (stop_offset - addr_offset) * opb;
1431 for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1433 if (ISPRINT (data[j]))
1434 buf[j - addr_offset * opb] = data[j];
1436 buf[j - addr_offset * opb] = '.';
1438 buf[j - addr_offset * opb] = '\0';
1441 if (prefix_addresses
1443 : show_raw_insn >= 0)
1447 /* If ! prefix_addresses and ! wide_output, we print
1448 octets_per_line octets per line. */
1450 if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1451 pb = octets_per_line;
1453 if (info->bytes_per_chunk)
1454 bpc = info->bytes_per_chunk;
1458 for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1462 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1464 for (k = bpc - 1; k >= 0; k--)
1465 printf ("%02x", (unsigned) data[j + k]);
1470 for (k = 0; k < bpc; k++)
1471 printf ("%02x", (unsigned) data[j + k]);
1476 for (; pb < octets_per_line; pb += bpc)
1480 for (k = 0; k < bpc; k++)
1485 /* Separate raw data from instruction by extra space. */
1495 printf ("%s", sfile.buffer);
1497 if (prefix_addresses
1499 : show_raw_insn >= 0)
1507 j = addr_offset * opb + pb;
1509 bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
1510 for (s = buf + skip_addr_chars; *s == '0'; s++)
1514 printf ("%s:\t", buf + skip_addr_chars);
1516 pb += octets_per_line;
1519 for (; j < addr_offset * opb + pb; j += bpc)
1523 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1525 for (k = bpc - 1; k >= 0; k--)
1526 printf ("%02x", (unsigned) data[j + k]);
1531 for (k = 0; k < bpc; k++)
1532 printf ("%02x", (unsigned) data[j + k]);
1545 while ((*relppp) < relppend
1546 && (**relppp)->address < rel_offset + addr_offset + octets / opb)
1548 if (dump_reloc_info || dump_dynamic_reloc_info)
1559 objdump_print_value (section->vma - rel_offset + q->address,
1562 if (q->howto == NULL)
1563 printf (": *unknown*\t");
1564 else if (q->howto->name)
1565 printf (": %s\t", q->howto->name);
1567 printf (": %d\t", q->howto->type);
1569 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1570 printf ("*unknown*");
1573 const char *sym_name;
1575 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1576 if (sym_name != NULL && *sym_name != '\0')
1577 objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
1582 sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1583 sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1584 if (sym_name == NULL || *sym_name == '\0')
1585 sym_name = "*unknown*";
1586 printf ("%s", sym_name);
1593 objdump_print_value (q->addend, info, TRUE);
1605 addr_offset += octets / opb;
1608 free (sfile.buffer);
1612 disassemble_section (bfd *abfd, asection *section, void *info)
1614 struct disassemble_info * pinfo = (struct disassemble_info *) info;
1615 struct objdump_disasm_info * paux;
1616 unsigned int opb = pinfo->octets_per_byte;
1617 bfd_byte * data = NULL;
1618 bfd_size_type datasize = 0;
1619 arelent ** rel_pp = NULL;
1620 arelent ** rel_ppstart = NULL;
1621 arelent ** rel_ppend;
1622 unsigned long stop_offset;
1623 asymbol * sym = NULL;
1627 unsigned long addr_offset;
1629 /* Sections that do not contain machine
1630 code are not normally disassembled. */
1631 if (! disassemble_all
1633 && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
1634 != (SEC_CODE | SEC_HAS_CONTENTS)))
1637 if (! process_section_p (section))
1640 datasize = bfd_get_section_size (section);
1644 /* Decide which set of relocs to use. Load them if necessary. */
1645 paux = (struct objdump_disasm_info *) pinfo->application_data;
1646 if (paux->dynrelbuf)
1648 rel_pp = paux->dynrelbuf;
1649 rel_count = paux->dynrelcount;
1650 /* Dynamic reloc addresses are absolute, non-dynamic are section
1651 relative. REL_OFFSET specifies the reloc address corresponding
1652 to the start of this section. */
1653 rel_offset = section->vma;
1661 if ((section->flags & SEC_RELOC) != 0
1662 && (dump_reloc_info || pinfo->disassembler_needs_relocs))
1666 relsize = bfd_get_reloc_upper_bound (abfd, section);
1668 bfd_fatal (bfd_get_filename (abfd));
1672 rel_ppstart = rel_pp = xmalloc (relsize);
1673 rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
1675 bfd_fatal (bfd_get_filename (abfd));
1677 /* Sort the relocs by address. */
1678 qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
1683 rel_ppend = rel_pp + rel_count;
1685 data = xmalloc (datasize);
1687 bfd_get_section_contents (abfd, section, data, 0, datasize);
1689 paux->sec = section;
1690 pinfo->buffer = data;
1691 pinfo->buffer_vma = section->vma;
1692 pinfo->buffer_length = datasize;
1693 pinfo->section = section;
1695 if (start_address == (bfd_vma) -1
1696 || start_address < pinfo->buffer_vma)
1699 addr_offset = start_address - pinfo->buffer_vma;
1701 if (stop_address == (bfd_vma) -1)
1702 stop_offset = datasize / opb;
1705 if (stop_address < pinfo->buffer_vma)
1708 stop_offset = stop_address - pinfo->buffer_vma;
1709 if (stop_offset > pinfo->buffer_length / opb)
1710 stop_offset = pinfo->buffer_length / opb;
1713 /* Skip over the relocs belonging to addresses below the
1715 while (rel_pp < rel_ppend
1716 && (*rel_pp)->address < rel_offset + addr_offset)
1719 printf (_("Disassembly of section %s:\n"), section->name);
1721 /* Find the nearest symbol forwards from our current position. */
1722 paux->require_sec = TRUE;
1723 sym = find_symbol_for_address (section->vma + addr_offset, info, &place);
1724 paux->require_sec = FALSE;
1726 /* Disassemble a block of instructions up to the address associated with
1727 the symbol we have just found. Then print the symbol and find the
1728 next symbol on. Repeat until we have disassembled the entire section
1729 or we have reached the end of the address range we are interested in. */
1730 while (addr_offset < stop_offset)
1734 unsigned long nextstop_offset;
1737 addr = section->vma + addr_offset;
1739 if (sym != NULL && bfd_asymbol_value (sym) <= addr)
1744 (x < sorted_symcount
1745 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
1749 pinfo->symbols = sorted_syms + place;
1750 pinfo->num_symbols = x - place;
1751 pinfo->symtab_pos = place;
1755 pinfo->symbols = NULL;
1756 pinfo->num_symbols = 0;
1757 pinfo->symtab_pos = -1;
1760 if (! prefix_addresses)
1762 pinfo->fprintf_func (pinfo->stream, "\n");
1763 objdump_print_addr_with_sym (abfd, section, sym, addr,
1765 pinfo->fprintf_func (pinfo->stream, ":\n");
1768 if (sym != NULL && bfd_asymbol_value (sym) > addr)
1770 else if (sym == NULL)
1774 #define is_valid_next_sym(SYM) \
1775 ((SYM)->section == section \
1776 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1777 && pinfo->symbol_is_valid (SYM, pinfo))
1779 /* Search forward for the next appropriate symbol in
1780 SECTION. Note that all the symbols are sorted
1781 together into one big array, and that some sections
1782 may have overlapping addresses. */
1783 while (place < sorted_symcount
1784 && ! is_valid_next_sym (sorted_syms [place]))
1787 if (place >= sorted_symcount)
1790 nextsym = sorted_syms[place];
1793 if (sym != NULL && bfd_asymbol_value (sym) > addr)
1794 nextstop_offset = bfd_asymbol_value (sym) - section->vma;
1795 else if (nextsym == NULL)
1796 nextstop_offset = stop_offset;
1798 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
1800 if (nextstop_offset > stop_offset)
1801 nextstop_offset = stop_offset;
1803 /* If a symbol is explicitly marked as being an object
1804 rather than a function, just dump the bytes without
1805 disassembling them. */
1808 || bfd_asymbol_value (sym) > addr
1809 || ((sym->flags & BSF_OBJECT) == 0
1810 && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1812 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1814 || (sym->flags & BSF_FUNCTION) != 0)
1819 disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
1820 addr_offset, nextstop_offset,
1821 rel_offset, &rel_pp, rel_ppend);
1823 addr_offset = nextstop_offset;
1829 if (rel_ppstart != NULL)
1833 /* Disassemble the contents of an object file. */
1836 disassemble_data (bfd *abfd)
1838 struct disassemble_info disasm_info;
1839 struct objdump_disasm_info aux;
1843 prev_functionname = NULL;
1846 /* We make a copy of syms to sort. We don't want to sort syms
1847 because that will screw up the relocs. */
1848 sorted_symcount = symcount ? symcount : dynsymcount;
1849 sorted_syms = xmalloc ((sorted_symcount + synthcount) * sizeof (asymbol *));
1850 memcpy (sorted_syms, symcount ? syms : dynsyms,
1851 sorted_symcount * sizeof (asymbol *));
1853 sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
1855 for (i = 0; i < synthcount; ++i)
1857 sorted_syms[sorted_symcount] = synthsyms + i;
1861 /* Sort the symbols into section and symbol order. */
1862 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
1864 init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
1866 disasm_info.application_data = (void *) &aux;
1868 aux.require_sec = FALSE;
1869 aux.dynrelbuf = NULL;
1870 aux.dynrelcount = 0;
1873 disasm_info.print_address_func = objdump_print_address;
1874 disasm_info.symbol_at_address_func = objdump_symbol_at_address;
1876 if (machine != NULL)
1878 const bfd_arch_info_type *info = bfd_scan_arch (machine);
1881 fatal (_("Can't use supplied machine %s"), machine);
1883 abfd->arch_info = info;
1886 if (endian != BFD_ENDIAN_UNKNOWN)
1888 struct bfd_target *xvec;
1890 xvec = xmalloc (sizeof (struct bfd_target));
1891 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
1892 xvec->byteorder = endian;
1896 /* Use libopcodes to locate a suitable disassembler. */
1897 aux.disassemble_fn = disassembler (abfd);
1898 if (!aux.disassemble_fn)
1900 non_fatal (_("Can't disassemble for architecture %s\n"),
1901 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
1906 disasm_info.flavour = bfd_get_flavour (abfd);
1907 disasm_info.arch = bfd_get_arch (abfd);
1908 disasm_info.mach = bfd_get_mach (abfd);
1909 disasm_info.disassembler_options = disassembler_options;
1910 disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
1911 disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
1912 disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
1913 disasm_info.disassembler_needs_relocs = FALSE;
1915 if (bfd_big_endian (abfd))
1916 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
1917 else if (bfd_little_endian (abfd))
1918 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
1920 /* ??? Aborting here seems too drastic. We could default to big or little
1922 disasm_info.endian = BFD_ENDIAN_UNKNOWN;
1924 /* Allow the target to customize the info structure. */
1925 disassemble_init_for_target (& disasm_info);
1927 /* Pre-load the dynamic relocs if we are going
1928 to be dumping them along with the disassembly. */
1929 if (dump_dynamic_reloc_info)
1931 long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
1934 bfd_fatal (bfd_get_filename (abfd));
1938 aux.dynrelbuf = xmalloc (relsize);
1939 aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
1942 if (aux.dynrelcount < 0)
1943 bfd_fatal (bfd_get_filename (abfd));
1945 /* Sort the relocs by address. */
1946 qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
1950 disasm_info.symtab = sorted_syms;
1951 disasm_info.symtab_size = sorted_symcount;
1953 bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
1955 if (aux.dynrelbuf != NULL)
1956 free (aux.dynrelbuf);
1961 load_debug_section (enum dwarf_section_display_enum debug, void *file)
1963 struct dwarf_section *section = &debug_displays [debug].section;
1968 /* If it is already loaded, do nothing. */
1969 if (section->start != NULL)
1972 /* Locate the debug section. */
1973 sec = bfd_get_section_by_name (abfd, section->name);
1977 /* Compute a bias to be added to offsets found within the DWARF debug
1978 information. These offsets are meant to be relative to the start of
1979 the dwarf section, and hence the bias should be 0. For MACH-O however
1980 a dwarf section is really just a region of a much larger section and so
1981 the bias is the address of the start of that area within the larger
1982 section. This test is important for PE and COFF based targets which
1983 use DWARF debug information, since unlike ELF, they do not allow the
1984 dwarf sections to be placed at address 0. */
1985 if (bfd_get_flavour (abfd) == bfd_target_mach_o_flavour)
1986 section->address = bfd_get_section_vma (abfd, sec);
1988 section->address = 0;
1990 section->size = bfd_get_section_size (sec);
1991 section->start = xmalloc (section->size);
1993 if (is_relocatable && debug_displays [debug].relocate)
1994 ret = bfd_simple_get_relocated_section_contents (abfd,
1999 ret = bfd_get_section_contents (abfd, sec, section->start, 0,
2004 free_debug_section (debug);
2005 printf (_("\nCan't get contents for section '%s'.\n"),
2013 free_debug_section (enum dwarf_section_display_enum debug)
2015 struct dwarf_section *section = &debug_displays [debug].section;
2017 if (section->start == NULL)
2020 free ((char *) section->start);
2021 section->start = NULL;
2022 section->address = 0;
2027 dump_dwarf_section (bfd *abfd, asection *section,
2028 void *arg ATTRIBUTE_UNUSED)
2030 const char *name = bfd_get_section_name (abfd, section);
2032 enum dwarf_section_display_enum i;
2034 if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
2035 match = ".debug_info";
2039 for (i = 0; i < max; i++)
2040 if (strcmp (debug_displays[i].section.name, match) == 0)
2042 if (!debug_displays[i].eh_frame)
2044 struct dwarf_section *sec = &debug_displays [i].section;
2046 if (load_debug_section (i, abfd))
2048 debug_displays[i].display (sec, abfd);
2050 if (i != info && i != abbrev)
2051 free_debug_section (i);
2058 static const char *mach_o_dwarf_sections [] = {
2059 "LC_SEGMENT.__DWARFA.__debug_abbrev", /* .debug_abbrev */
2060 "LC_SEGMENT.__DWARFA.__debug_aranges", /* .debug_aranges */
2061 "LC_SEGMENT.__DWARFA.__debug_frame", /* .debug_frame */
2062 "LC_SEGMENT.__DWARFA.__debug_info", /* .debug_info */
2063 "LC_SEGMENT.__DWARFA.__debug_line", /* .debug_line */
2064 "LC_SEGMENT.__DWARFA.__debug_pubnames", /* .debug_pubnames */
2065 ".eh_frame", /* .eh_frame */
2066 "LC_SEGMENT.__DWARFA.__debug_macinfo", /* .debug_macinfo */
2067 "LC_SEGMENT.__DWARFA.__debug_str", /* .debug_str */
2068 "LC_SEGMENT.__DWARFA.__debug_loc", /* .debug_loc */
2069 "LC_SEGMENT.__DWARFA.__debug_pubtypes", /* .debug_pubtypes */
2070 "LC_SEGMENT.__DWARFA.__debug_ranges", /* .debug_ranges */
2071 "LC_SEGMENT.__DWARFA.__debug_static_func", /* .debug_static_func */
2072 "LC_SEGMENT.__DWARFA.__debug_static_vars", /* .debug_static_vars */
2073 "LC_SEGMENT.__DWARFA.__debug_types", /* .debug_types */
2074 "LC_SEGMENT.__DWARFA.__debug_weaknames" /* .debug_weaknames */
2077 static const char *generic_dwarf_sections [max];
2080 check_mach_o_dwarf (bfd *abfd)
2082 static enum bfd_flavour old_flavour = bfd_target_unknown_flavour;
2083 enum bfd_flavour current_flavour = bfd_get_flavour (abfd);
2084 enum dwarf_section_display_enum i;
2086 if (generic_dwarf_sections [0] == NULL)
2087 for (i = 0; i < max; i++)
2088 generic_dwarf_sections [i] = debug_displays[i].section.name;
2090 if (old_flavour != current_flavour)
2092 if (current_flavour == bfd_target_mach_o_flavour)
2093 for (i = 0; i < max; i++)
2094 debug_displays[i].section.name = mach_o_dwarf_sections [i];
2095 else if (old_flavour == bfd_target_mach_o_flavour)
2096 for (i = 0; i < max; i++)
2097 debug_displays[i].section.name = generic_dwarf_sections [i];
2099 old_flavour = current_flavour;
2103 /* Dump the dwarf debugging information. */
2106 dump_dwarf (bfd *abfd)
2108 is_relocatable = ((abfd->flags & (HAS_RELOC | EXEC_P | DYNAMIC))
2111 /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
2112 targets will return 64. */
2113 eh_addr_size = bfd_get_arch_size (abfd) == 64 ? 8 : 4;
2115 if (bfd_big_endian (abfd))
2116 byte_get = byte_get_big_endian;
2117 else if (bfd_little_endian (abfd))
2118 byte_get = byte_get_little_endian;
2122 check_mach_o_dwarf (abfd);
2124 bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2126 free_debug_memory ();
2129 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2130 it. Return NULL on failure. */
2133 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
2139 stabsect = bfd_get_section_by_name (abfd, sect_name);
2140 if (stabsect == NULL)
2142 printf (_("No %s section present\n\n"), sect_name);
2146 size = bfd_section_size (abfd, stabsect);
2147 contents = xmalloc (size);
2149 if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
2151 non_fatal (_("Reading %s section of %s failed: %s"),
2152 sect_name, bfd_get_filename (abfd),
2153 bfd_errmsg (bfd_get_error ()));
2164 /* Stabs entries use a 12 byte format:
2165 4 byte string table index
2167 1 byte stab other field
2168 2 byte stab desc field
2170 FIXME: This will have to change for a 64 bit object format. */
2172 #define STRDXOFF (0)
2174 #define OTHEROFF (5)
2177 #define STABSIZE (12)
2179 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2180 using string table section STRSECT_NAME (in `strtab'). */
2183 print_section_stabs (bfd *abfd,
2184 const char *stabsect_name,
2185 unsigned *string_offset_ptr)
2188 unsigned file_string_table_offset = 0;
2189 unsigned next_file_string_table_offset = *string_offset_ptr;
2190 bfd_byte *stabp, *stabs_end;
2193 stabs_end = stabp + stab_size;
2195 printf (_("Contents of %s section:\n\n"), stabsect_name);
2196 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2198 /* Loop through all symbols and print them.
2200 We start the index at -1 because there is a dummy symbol on
2201 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2202 for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
2206 unsigned char type, other;
2207 unsigned short desc;
2210 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2211 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2212 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2213 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2214 value = bfd_h_get_32 (abfd, stabp + VALOFF);
2216 printf ("\n%-6d ", i);
2217 /* Either print the stab name, or, if unnamed, print its number
2218 again (makes consistent formatting for tools like awk). */
2219 name = bfd_get_stab_name (type);
2221 printf ("%-6s", name);
2222 else if (type == N_UNDF)
2225 printf ("%-6d", type);
2226 printf (" %-6d %-6d ", other, desc);
2227 bfd_printf_vma (abfd, value);
2228 printf (" %-6lu", strx);
2230 /* Symbols with type == 0 (N_UNDF) specify the length of the
2231 string table associated with this file. We use that info
2232 to know how to relocate the *next* file's string table indices. */
2235 file_string_table_offset = next_file_string_table_offset;
2236 next_file_string_table_offset += value;
2240 /* Using the (possibly updated) string table offset, print the
2241 string (if any) associated with this symbol. */
2242 if ((strx + file_string_table_offset) < stabstr_size)
2243 printf (" %s", &strtab[strx + file_string_table_offset]);
2249 *string_offset_ptr = next_file_string_table_offset;
2254 const char * section_name;
2255 const char * string_section_name;
2256 unsigned string_offset;
2261 find_stabs_section (bfd *abfd, asection *section, void *names)
2264 stab_section_names * sought = (stab_section_names *) names;
2266 /* Check for section names for which stabsect_name is a prefix, to
2267 handle .stab.N, etc. */
2268 len = strlen (sought->section_name);
2270 /* If the prefix matches, and the files section name ends with a
2271 nul or a digit, then we match. I.e., we want either an exact
2272 match or a section followed by a number. */
2273 if (strncmp (sought->section_name, section->name, len) == 0
2274 && (section->name[len] == 0
2275 || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2278 strtab = read_section_stabs (abfd, sought->string_section_name,
2283 stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2286 print_section_stabs (abfd, section->name, &sought->string_offset);
2292 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2294 stab_section_names s;
2296 s.section_name = stabsect_name;
2297 s.string_section_name = strsect_name;
2298 s.string_offset = 0;
2300 bfd_map_over_sections (abfd, find_stabs_section, & s);
2306 /* Dump the any sections containing stabs debugging information. */
2309 dump_stabs (bfd *abfd)
2311 dump_stabs_section (abfd, ".stab", ".stabstr");
2312 dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2313 dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2314 dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2318 dump_bfd_header (bfd *abfd)
2322 printf (_("architecture: %s, "),
2323 bfd_printable_arch_mach (bfd_get_arch (abfd),
2324 bfd_get_mach (abfd)));
2325 printf (_("flags 0x%08x:\n"), abfd->flags);
2327 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2328 PF (HAS_RELOC, "HAS_RELOC");
2329 PF (EXEC_P, "EXEC_P");
2330 PF (HAS_LINENO, "HAS_LINENO");
2331 PF (HAS_DEBUG, "HAS_DEBUG");
2332 PF (HAS_SYMS, "HAS_SYMS");
2333 PF (HAS_LOCALS, "HAS_LOCALS");
2334 PF (DYNAMIC, "DYNAMIC");
2335 PF (WP_TEXT, "WP_TEXT");
2336 PF (D_PAGED, "D_PAGED");
2337 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2338 PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
2339 printf (_("\nstart address 0x"));
2340 bfd_printf_vma (abfd, abfd->start_address);
2346 dump_bfd_private_header (bfd *abfd)
2348 bfd_print_private_bfd_data (abfd, stdout);
2352 /* Display a section in hexadecimal format with associated characters.
2353 Each line prefixed by the zero padded address. */
2356 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2359 bfd_size_type datasize;
2360 bfd_size_type addr_offset;
2361 bfd_size_type start_offset;
2362 bfd_size_type stop_offset;
2363 unsigned int opb = bfd_octets_per_byte (abfd);
2364 /* Bytes per line. */
2365 const int onaline = 16;
2370 if ((section->flags & SEC_HAS_CONTENTS) == 0)
2373 if (! process_section_p (section))
2376 if ((datasize = bfd_section_size (abfd, section)) == 0)
2379 printf (_("Contents of section %s:\n"), section->name);
2381 data = xmalloc (datasize);
2383 bfd_get_section_contents (abfd, section, data, 0, datasize);
2385 /* Compute the address range to display. */
2386 if (start_address == (bfd_vma) -1
2387 || start_address < section->vma)
2390 start_offset = start_address - section->vma;
2392 if (stop_address == (bfd_vma) -1)
2393 stop_offset = datasize / opb;
2396 if (stop_address < section->vma)
2399 stop_offset = stop_address - section->vma;
2401 if (stop_offset > datasize / opb)
2402 stop_offset = datasize / opb;
2407 bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2408 if (strlen (buf) >= sizeof (buf))
2412 while (buf[count] == '0' && buf[count+1] != '\0')
2414 count = strlen (buf) - count;
2418 bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2419 if (strlen (buf) >= sizeof (buf))
2423 while (buf[count] == '0' && buf[count+1] != '\0')
2425 count = strlen (buf) - count;
2429 for (addr_offset = start_offset;
2430 addr_offset < stop_offset; addr_offset += onaline / opb)
2434 bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2435 count = strlen (buf);
2436 if ((size_t) count >= sizeof (buf))
2440 while (count < width)
2445 fputs (buf + count - width, stdout);
2448 for (j = addr_offset * opb;
2449 j < addr_offset * opb + onaline; j++)
2451 if (j < stop_offset * opb)
2452 printf ("%02x", (unsigned) (data[j]));
2460 for (j = addr_offset * opb;
2461 j < addr_offset * opb + onaline; j++)
2463 if (j >= stop_offset * opb)
2466 printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2473 /* Actually display the various requested regions. */
2476 dump_data (bfd *abfd)
2478 bfd_map_over_sections (abfd, dump_section, NULL);
2481 /* Should perhaps share code and display with nm? */
2484 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2494 printf ("DYNAMIC SYMBOL TABLE:\n");
2500 printf ("SYMBOL TABLE:\n");
2504 printf (_("no symbols\n"));
2506 for (count = 0; count < max; count++)
2510 if (*current == NULL)
2511 printf (_("no information for symbol number %ld\n"), count);
2513 else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2514 printf (_("could not determine the type of symbol number %ld\n"),
2517 else if (process_section_p ((* current)->section)
2518 && (dump_special_syms
2519 || !bfd_is_target_special_symbol (cur_bfd, *current)))
2521 const char *name = (*current)->name;
2523 if (do_demangle && name != NULL && *name != '\0')
2527 /* If we want to demangle the name, we demangle it
2528 here, and temporarily clobber it while calling
2529 bfd_print_symbol. FIXME: This is a gross hack. */
2530 alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS);
2532 (*current)->name = alloc;
2533 bfd_print_symbol (cur_bfd, stdout, *current,
2534 bfd_print_symbol_all);
2537 (*current)->name = name;
2542 bfd_print_symbol (cur_bfd, stdout, *current,
2543 bfd_print_symbol_all);
2553 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2556 char *last_filename, *last_functionname;
2557 unsigned int last_line;
2559 /* Get column headers lined up reasonably. */
2567 bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2568 width = strlen (buf) - 7;
2570 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2573 last_filename = NULL;
2574 last_functionname = NULL;
2577 for (p = relpp; relcount && *p != NULL; p++, relcount--)
2580 const char *filename, *functionname;
2582 const char *sym_name;
2583 const char *section_name;
2585 if (start_address != (bfd_vma) -1
2586 && q->address < start_address)
2588 if (stop_address != (bfd_vma) -1
2589 && q->address > stop_address)
2592 if (with_line_numbers
2594 && bfd_find_nearest_line (abfd, sec, syms, q->address,
2595 &filename, &functionname, &line))
2597 if (functionname != NULL
2598 && (last_functionname == NULL
2599 || strcmp (functionname, last_functionname) != 0))
2601 printf ("%s():\n", functionname);
2602 if (last_functionname != NULL)
2603 free (last_functionname);
2604 last_functionname = xstrdup (functionname);
2608 && (line != last_line
2609 || (filename != NULL
2610 && last_filename != NULL
2611 && strcmp (filename, last_filename) != 0)))
2613 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2615 if (last_filename != NULL)
2616 free (last_filename);
2617 if (filename == NULL)
2618 last_filename = NULL;
2620 last_filename = xstrdup (filename);
2624 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2626 sym_name = (*(q->sym_ptr_ptr))->name;
2627 section_name = (*(q->sym_ptr_ptr))->section->name;
2632 section_name = NULL;
2635 bfd_printf_vma (abfd, q->address);
2636 if (q->howto == NULL)
2637 printf (" *unknown* ");
2638 else if (q->howto->name)
2639 printf (" %-16s ", q->howto->name);
2641 printf (" %-16d ", q->howto->type);
2643 objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
2646 if (section_name == NULL)
2647 section_name = "*unknown*";
2648 printf ("[%s]", section_name);
2654 bfd_printf_vma (abfd, q->addend);
2662 dump_relocs_in_section (bfd *abfd,
2664 void *dummy ATTRIBUTE_UNUSED)
2670 if ( bfd_is_abs_section (section)
2671 || bfd_is_und_section (section)
2672 || bfd_is_com_section (section)
2673 || (! process_section_p (section))
2674 || ((section->flags & SEC_RELOC) == 0))
2677 relsize = bfd_get_reloc_upper_bound (abfd, section);
2679 bfd_fatal (bfd_get_filename (abfd));
2681 printf ("RELOCATION RECORDS FOR [%s]:", section->name);
2685 printf (" (none)\n\n");
2689 relpp = xmalloc (relsize);
2690 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
2693 bfd_fatal (bfd_get_filename (abfd));
2694 else if (relcount == 0)
2695 printf (" (none)\n\n");
2699 dump_reloc_set (abfd, section, relpp, relcount);
2706 dump_relocs (bfd *abfd)
2708 bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
2712 dump_dynamic_relocs (bfd *abfd)
2718 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2720 bfd_fatal (bfd_get_filename (abfd));
2722 printf ("DYNAMIC RELOCATION RECORDS");
2725 printf (" (none)\n\n");
2728 relpp = xmalloc (relsize);
2729 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2732 bfd_fatal (bfd_get_filename (abfd));
2733 else if (relcount == 0)
2734 printf (" (none)\n\n");
2738 dump_reloc_set (abfd, NULL, relpp, relcount);
2745 /* Creates a table of paths, to search for source files. */
2748 add_include_path (const char *path)
2752 include_path_count++;
2753 include_paths = xrealloc (include_paths,
2754 include_path_count * sizeof (*include_paths));
2755 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2756 if (path[1] == ':' && path[2] == 0)
2757 path = concat (path, ".", (const char *) 0);
2759 include_paths[include_path_count - 1] = path;
2763 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
2767 if ((section->flags & SEC_DEBUGGING) == 0)
2769 bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
2770 section->vma += adjust_section_vma;
2772 section->lma += adjust_section_vma;
2776 /* Dump selected contents of ABFD. */
2779 dump_bfd (bfd *abfd)
2781 /* If we are adjusting section VMA's, change them all now. Changing
2782 the BFD information is a hack. However, we must do it, or
2783 bfd_find_nearest_line will not do the right thing. */
2784 if (adjust_section_vma != 0)
2786 bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
2787 bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
2790 if (! dump_debugging_tags)
2791 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
2794 print_arelt_descr (stdout, abfd, TRUE);
2795 if (dump_file_header)
2796 dump_bfd_header (abfd);
2797 if (dump_private_headers)
2798 dump_bfd_private_header (abfd);
2799 if (! dump_debugging_tags)
2801 if (dump_section_headers)
2802 dump_headers (abfd);
2808 || dump_dwarf_section_info)
2809 syms = slurp_symtab (abfd);
2810 if (dump_dynamic_symtab || dump_dynamic_reloc_info
2811 || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
2812 dynsyms = slurp_dynamic_symtab (abfd);
2815 synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
2816 dynsymcount, dynsyms, &synthsyms);
2822 dump_symbols (abfd, FALSE);
2823 if (dump_dynamic_symtab)
2824 dump_symbols (abfd, TRUE);
2825 if (dump_dwarf_section_info)
2827 if (dump_stab_section_info)
2829 if (dump_reloc_info && ! disassemble)
2831 if (dump_dynamic_reloc_info && ! disassemble)
2832 dump_dynamic_relocs (abfd);
2833 if (dump_section_contents)
2836 disassemble_data (abfd);
2842 dhandle = read_debugging_info (abfd, syms, symcount);
2843 if (dhandle != NULL)
2845 if (!print_debugging_info (stdout, dhandle, abfd, syms,
2847 dump_debugging_tags ? TRUE : FALSE))
2849 non_fatal (_("%s: printing debugging information failed"),
2850 bfd_get_filename (abfd));
2880 display_bfd (bfd *abfd)
2884 if (bfd_check_format_matches (abfd, bfd_object, &matching))
2890 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2892 nonfatal (bfd_get_filename (abfd));
2893 list_matching_formats (matching);
2898 if (bfd_get_error () != bfd_error_file_not_recognized)
2900 nonfatal (bfd_get_filename (abfd));
2904 if (bfd_check_format_matches (abfd, bfd_core, &matching))
2910 nonfatal (bfd_get_filename (abfd));
2912 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2914 list_matching_formats (matching);
2920 display_file (char *filename, char *target)
2925 if (get_file_size (filename) < 1)
2931 file = bfd_openr (filename, target);
2934 nonfatal (filename);
2938 /* If the file is an archive, process all of its elements. */
2939 if (bfd_check_format (file, bfd_archive))
2941 bfd *last_arfile = NULL;
2943 printf (_("In archive %s:\n"), bfd_get_filename (file));
2946 bfd_set_error (bfd_error_no_error);
2948 arfile = bfd_openr_next_archived_file (file, arfile);
2951 if (bfd_get_error () != bfd_error_no_more_archived_files)
2952 nonfatal (bfd_get_filename (file));
2956 display_bfd (arfile);
2958 if (last_arfile != NULL)
2959 bfd_close (last_arfile);
2960 last_arfile = arfile;
2963 if (last_arfile != NULL)
2964 bfd_close (last_arfile);
2973 main (int argc, char **argv)
2976 char *target = default_target;
2977 bfd_boolean seenflag = FALSE;
2979 #if defined (HAVE_SETLOCALE)
2980 #if defined (HAVE_LC_MESSAGES)
2981 setlocale (LC_MESSAGES, "");
2983 setlocale (LC_CTYPE, "");
2986 bindtextdomain (PACKAGE, LOCALEDIR);
2987 textdomain (PACKAGE);
2989 program_name = *argv;
2990 xmalloc_set_program_name (program_name);
2992 START_PROGRESS (program_name, 0);
2994 expandargv (&argc, &argv);
2997 set_default_bfd_target ();
2999 while ((c = getopt_long (argc, argv, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeGW",
3000 long_options, (int *) 0))
3006 break; /* We've been given a long option. */
3011 if (disassembler_options)
3012 /* Ignore potential memory leak for now. */
3013 disassembler_options = concat (disassembler_options, ",",
3016 disassembler_options = optarg;
3019 if (only_used == only_size)
3022 only = xrealloc (only, only_size * sizeof (char *));
3024 only [only_used++] = optarg;
3027 with_line_numbers = TRUE;
3036 enum demangling_styles style;
3038 style = cplus_demangle_name_to_style (optarg);
3039 if (style == unknown_demangling)
3040 fatal (_("unknown demangling style `%s'"),
3043 cplus_demangle_set_style (style);
3049 case OPTION_ADJUST_VMA:
3050 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3052 case OPTION_START_ADDRESS:
3053 start_address = parse_vma (optarg, "--start-address");
3055 case OPTION_STOP_ADDRESS:
3056 stop_address = parse_vma (optarg, "--stop-address");
3059 if (strcmp (optarg, "B") == 0)
3060 endian = BFD_ENDIAN_BIG;
3061 else if (strcmp (optarg, "L") == 0)
3062 endian = BFD_ENDIAN_LITTLE;
3065 non_fatal (_("unrecognized -E option"));
3070 if (strncmp (optarg, "big", strlen (optarg)) == 0)
3071 endian = BFD_ENDIAN_BIG;
3072 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3073 endian = BFD_ENDIAN_LITTLE;
3076 non_fatal (_("unrecognized --endian type `%s'"), optarg);
3082 dump_file_header = TRUE;
3086 formats_info = TRUE;
3090 add_include_path (optarg);
3093 dump_private_headers = TRUE;
3097 dump_private_headers = TRUE;
3099 dump_reloc_info = TRUE;
3100 dump_file_header = TRUE;
3101 dump_ar_hdrs = TRUE;
3102 dump_section_headers = TRUE;
3110 dump_dynamic_symtab = TRUE;
3118 disassemble_zeroes = TRUE;
3122 disassemble_all = TRUE;
3127 with_source_code = TRUE;
3136 dump_debugging_tags = 1;
3141 dump_dwarf_section_info = TRUE;
3144 do_debug_abbrevs = 1;
3146 do_debug_pubnames = 1;
3147 do_debug_aranges = 1;
3148 do_debug_ranges = 1;
3149 do_debug_frames = 1;
3150 do_debug_macinfo = 1;
3155 dump_stab_section_info = TRUE;
3159 dump_section_contents = TRUE;
3163 dump_reloc_info = TRUE;
3167 dump_dynamic_reloc_info = TRUE;
3171 dump_ar_hdrs = TRUE;
3175 dump_section_headers = TRUE;
3183 show_version = TRUE;
3193 print_version ("objdump");
3199 exit_status = display_info ();
3203 display_file ("a.out", target);
3205 for (; optind < argc;)
3206 display_file (argv[optind++], target);
3209 END_PROGRESS (program_name);