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, 2008
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 3, 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,
21 MA 02110-1301, USA. */
26 Objdump displays information about one or more object files, either on
27 their own, or inside libraries. It is commonly used as a disassembler,
28 but it can also display information about file headers, symbol tables,
29 relocations, debugging directives and more.
31 The flow of execution is as follows:
33 1. Command line arguments are checked for control switches and the
34 information to be displayed is selected.
36 2. Any remaining arguments are assumed to be object files, and they are
37 processed in order by display_bfd(). If the file is an archive each
38 of its elements is processed in turn.
40 3. The file's target architecture and binary file format are determined
41 by bfd_check_format(). If they are recognised, then dump_bfd() is
44 4. dump_bfd() in turn calls separate functions to display the requested
45 item(s) of information(s). For example disassemble_data() is called if
46 a disassembly has been requested.
48 When disassembling the code loops through blocks of instructions bounded
49 by symbols, calling disassemble_bytes() on each block. The actual
50 disassembling is done by the libopcodes library, via a function pointer
51 supplied by the disassembler() function. */
60 #include "safe-ctype.h"
62 #include "libiberty.h"
73 /* Internal headers for the ELF .stab-dump code - sorry. */
74 #define BYTES_IN_WORD 32
75 #include "aout/aout64.h"
78 static int exit_status = 0;
80 static char *default_target = NULL; /* Default at runtime. */
82 /* The following variables are set based on arguments passed on the
84 static int show_version = 0; /* Show the version number. */
85 static int dump_section_contents; /* -s */
86 static int dump_section_headers; /* -h */
87 static bfd_boolean dump_file_header; /* -f */
88 static int dump_symtab; /* -t */
89 static int dump_dynamic_symtab; /* -T */
90 static int dump_reloc_info; /* -r */
91 static int dump_dynamic_reloc_info; /* -R */
92 static int dump_ar_hdrs; /* -a */
93 static int dump_private_headers; /* -p */
94 static int prefix_addresses; /* --prefix-addresses */
95 static int with_line_numbers; /* -l */
96 static bfd_boolean with_source_code; /* -S */
97 static int show_raw_insn; /* --show-raw-insn */
98 static int dump_dwarf_section_info; /* --dwarf */
99 static int dump_stab_section_info; /* --stabs */
100 static int do_demangle; /* -C, --demangle */
101 static bfd_boolean disassemble; /* -d */
102 static bfd_boolean disassemble_all; /* -D */
103 static int disassemble_zeroes; /* --disassemble-zeroes */
104 static bfd_boolean formats_info; /* -i */
105 static int wide_output; /* -w */
106 static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
107 static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */
108 static int dump_debugging; /* --debugging */
109 static int dump_debugging_tags; /* --debugging-tags */
110 static int dump_special_syms = 0; /* --special-syms */
111 static bfd_vma adjust_section_vma = 0; /* --adjust-vma */
112 static int file_start_context = 0; /* --file-start-context */
113 static bfd_boolean display_file_offsets;/* -F */
115 /* Pointer to an array of section names provided by
116 one or more "-j secname" command line options. */
118 /* The total number of slots in the only[] array. */
119 static size_t only_size = 0;
120 /* The number of occupied slots in the only[] array. */
121 static size_t only_used = 0;
123 /* Variables for handling include file path table. */
124 static const char **include_paths;
125 static int include_path_count;
127 /* Extra info to pass to the section disassembler and address printing
129 struct objdump_disasm_info
133 bfd_boolean require_sec;
134 arelent ** dynrelbuf;
136 disassembler_ftype disassemble_fn;
140 /* Architecture to disassemble for, or default if NULL. */
141 static char *machine = NULL;
143 /* Target specific options to the disassembler. */
144 static char *disassembler_options = NULL;
146 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
147 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
149 /* The symbol table. */
150 static asymbol **syms;
152 /* Number of symbols in `syms'. */
153 static long symcount = 0;
155 /* The sorted symbol table. */
156 static asymbol **sorted_syms;
158 /* Number of symbols in `sorted_syms'. */
159 static long sorted_symcount = 0;
161 /* The dynamic symbol table. */
162 static asymbol **dynsyms;
164 /* The synthetic symbol table. */
165 static asymbol *synthsyms;
166 static long synthcount = 0;
168 /* Number of symbols in `dynsyms'. */
169 static long dynsymcount = 0;
171 static bfd_byte *stabs;
172 static bfd_size_type stab_size;
175 static bfd_size_type stabstr_size;
177 static bfd_boolean is_relocatable = FALSE;
180 usage (FILE *stream, int status)
182 fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
183 fprintf (stream, _(" Display information from object <file(s)>.\n"));
184 fprintf (stream, _(" At least one of the following switches must be given:\n"));
185 fprintf (stream, _("\
186 -a, --archive-headers Display archive header information\n\
187 -f, --file-headers Display the contents of the overall file header\n\
188 -p, --private-headers Display object format specific file header contents\n\
189 -h, --[section-]headers Display the contents of the section headers\n\
190 -x, --all-headers Display the contents of all headers\n\
191 -d, --disassemble Display assembler contents of executable sections\n\
192 -D, --disassemble-all Display assembler contents of all sections\n\
193 -S, --source Intermix source code with disassembly\n\
194 -s, --full-contents Display the full contents of all sections requested\n\
195 -g, --debugging Display debug information in object file\n\
196 -e, --debugging-tags Display debug information using ctags style\n\
197 -G, --stabs Display (in raw form) any STABS info in the file\n\
198 -W, --dwarf Display DWARF info in the file\n\
199 -t, --syms Display the contents of the symbol table(s)\n\
200 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
201 -r, --reloc Display the relocation entries in the file\n\
202 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
203 @<file> Read options from <file>\n\
204 -v, --version Display this program's version number\n\
205 -i, --info List object formats and architectures supported\n\
206 -H, --help Display this information\n\
210 fprintf (stream, _("\n The following switches are optional:\n"));
211 fprintf (stream, _("\
212 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
213 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
214 -j, --section=NAME Only display information for section NAME\n\
215 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
216 -EB --endian=big Assume big endian format when disassembling\n\
217 -EL --endian=little Assume little endian format when disassembling\n\
218 --file-start-context Include context from start of file (with -S)\n\
219 -I, --include=DIR Add DIR to search list for source files\n\
220 -l, --line-numbers Include line numbers and filenames in output\n\
221 -F, --file-offsets Include file offsets when displaying information\n\
222 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
223 The STYLE, if specified, can be `auto', `gnu',\n\
224 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
226 -w, --wide Format output for more than 80 columns\n\
227 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
228 --start-address=ADDR Only process data whose address is >= ADDR\n\
229 --stop-address=ADDR Only process data whose address is <= ADDR\n\
230 --prefix-addresses Print complete address alongside disassembly\n\
231 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
232 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
233 --special-syms Include special symbols in symbol dumps\n\
235 list_supported_targets (program_name, stream);
236 list_supported_architectures (program_name, stream);
238 disassembler_usage (stream);
240 if (REPORT_BUGS_TO[0] && status == 0)
241 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
245 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
249 OPTION_START_ADDRESS,
254 static struct option long_options[]=
256 {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
257 {"all-headers", no_argument, NULL, 'x'},
258 {"private-headers", no_argument, NULL, 'p'},
259 {"architecture", required_argument, NULL, 'm'},
260 {"archive-headers", no_argument, NULL, 'a'},
261 {"debugging", no_argument, NULL, 'g'},
262 {"debugging-tags", no_argument, NULL, 'e'},
263 {"demangle", optional_argument, NULL, 'C'},
264 {"disassemble", no_argument, NULL, 'd'},
265 {"disassemble-all", no_argument, NULL, 'D'},
266 {"disassembler-options", required_argument, NULL, 'M'},
267 {"disassemble-zeroes", no_argument, NULL, 'z'},
268 {"dynamic-reloc", no_argument, NULL, 'R'},
269 {"dynamic-syms", no_argument, NULL, 'T'},
270 {"endian", required_argument, NULL, OPTION_ENDIAN},
271 {"file-headers", no_argument, NULL, 'f'},
272 {"file-offsets", no_argument, NULL, 'F'},
273 {"file-start-context", no_argument, &file_start_context, 1},
274 {"full-contents", no_argument, NULL, 's'},
275 {"headers", no_argument, NULL, 'h'},
276 {"help", no_argument, NULL, 'H'},
277 {"info", no_argument, NULL, 'i'},
278 {"line-numbers", no_argument, NULL, 'l'},
279 {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
280 {"prefix-addresses", no_argument, &prefix_addresses, 1},
281 {"reloc", no_argument, NULL, 'r'},
282 {"section", required_argument, NULL, 'j'},
283 {"section-headers", no_argument, NULL, 'h'},
284 {"show-raw-insn", no_argument, &show_raw_insn, 1},
285 {"source", no_argument, NULL, 'S'},
286 {"special-syms", no_argument, &dump_special_syms, 1},
287 {"include", required_argument, NULL, 'I'},
288 {"dwarf", no_argument, NULL, 'W'},
289 {"stabs", no_argument, NULL, 'G'},
290 {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
291 {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
292 {"syms", no_argument, NULL, 't'},
293 {"target", required_argument, NULL, 'b'},
294 {"version", no_argument, NULL, 'V'},
295 {"wide", no_argument, NULL, 'w'},
296 {0, no_argument, 0, 0}
300 nonfatal (const char *msg)
307 dump_section_header (bfd *abfd, asection *section,
308 void *ignored ATTRIBUTE_UNUSED)
311 unsigned int opb = bfd_octets_per_byte (abfd);
313 /* Ignore linker created section. See elfNN_ia64_object_p in
315 if (section->flags & SEC_LINKER_CREATED)
318 printf ("%3d %-13s %08lx ", section->index,
319 bfd_get_section_name (abfd, section),
320 (unsigned long) bfd_section_size (abfd, section) / opb);
321 bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
323 bfd_printf_vma (abfd, section->lma);
324 printf (" %08lx 2**%u", (unsigned long) section->filepos,
325 bfd_get_section_alignment (abfd, section));
331 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
333 PF (SEC_HAS_CONTENTS, "CONTENTS");
334 PF (SEC_ALLOC, "ALLOC");
335 PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
336 PF (SEC_LOAD, "LOAD");
337 PF (SEC_RELOC, "RELOC");
338 PF (SEC_READONLY, "READONLY");
339 PF (SEC_CODE, "CODE");
340 PF (SEC_DATA, "DATA");
342 PF (SEC_DEBUGGING, "DEBUGGING");
343 PF (SEC_NEVER_LOAD, "NEVER_LOAD");
344 PF (SEC_EXCLUDE, "EXCLUDE");
345 PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
346 if (bfd_get_arch (abfd) == bfd_arch_tic54x)
348 PF (SEC_TIC54X_BLOCK, "BLOCK");
349 PF (SEC_TIC54X_CLINK, "CLINK");
351 PF (SEC_SMALL_DATA, "SMALL_DATA");
352 if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
353 PF (SEC_COFF_SHARED, "SHARED");
354 PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
355 PF (SEC_GROUP, "GROUP");
357 if ((section->flags & SEC_LINK_ONCE) != 0)
360 struct coff_comdat_info *comdat;
362 switch (section->flags & SEC_LINK_DUPLICATES)
366 case SEC_LINK_DUPLICATES_DISCARD:
367 ls = "LINK_ONCE_DISCARD";
369 case SEC_LINK_DUPLICATES_ONE_ONLY:
370 ls = "LINK_ONCE_ONE_ONLY";
372 case SEC_LINK_DUPLICATES_SAME_SIZE:
373 ls = "LINK_ONCE_SAME_SIZE";
375 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
376 ls = "LINK_ONCE_SAME_CONTENTS";
379 printf ("%s%s", comma, ls);
381 comdat = bfd_coff_get_comdat_section (abfd, section);
383 printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);
393 dump_headers (bfd *abfd)
395 printf (_("Sections:\n"));
398 printf (_("Idx Name Size VMA LMA File off Algn"));
400 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
401 if (bfd_get_arch_size (abfd) == 32)
402 printf (_("Idx Name Size VMA LMA File off Algn"));
404 printf (_("Idx Name Size VMA LMA File off Algn"));
408 printf (_(" Flags"));
409 if (abfd->flags & HAS_LOAD_PAGE)
413 bfd_map_over_sections (abfd, dump_section_header, NULL);
417 slurp_symtab (bfd *abfd)
422 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
428 storage = bfd_get_symtab_upper_bound (abfd);
430 bfd_fatal (bfd_get_filename (abfd));
432 sy = xmalloc (storage);
434 symcount = bfd_canonicalize_symtab (abfd, sy);
436 bfd_fatal (bfd_get_filename (abfd));
440 /* Read in the dynamic symbols. */
443 slurp_dynamic_symtab (bfd *abfd)
448 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
451 if (!(bfd_get_file_flags (abfd) & DYNAMIC))
453 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
458 bfd_fatal (bfd_get_filename (abfd));
461 sy = xmalloc (storage);
463 dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
465 bfd_fatal (bfd_get_filename (abfd));
469 /* Filter out (in place) symbols that are useless for disassembly.
470 COUNT is the number of elements in SYMBOLS.
471 Return the number of useful symbols. */
474 remove_useless_symbols (asymbol **symbols, long count)
476 asymbol **in_ptr = symbols, **out_ptr = symbols;
480 asymbol *sym = *in_ptr++;
482 if (sym->name == NULL || sym->name[0] == '\0')
484 if (sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
486 if (bfd_is_und_section (sym->section)
487 || bfd_is_com_section (sym->section))
492 return out_ptr - symbols;
495 /* Sort symbols into value order. */
498 compare_symbols (const void *ap, const void *bp)
500 const asymbol *a = * (const asymbol **) ap;
501 const asymbol *b = * (const asymbol **) bp;
511 if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
513 else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
516 if (a->section > b->section)
518 else if (a->section < b->section)
521 an = bfd_asymbol_name (a);
522 bn = bfd_asymbol_name (b);
526 /* The symbols gnu_compiled and gcc2_compiled convey no real
527 information, so put them after other symbols with the same value. */
528 af = (strstr (an, "gnu_compiled") != NULL
529 || strstr (an, "gcc2_compiled") != NULL);
530 bf = (strstr (bn, "gnu_compiled") != NULL
531 || strstr (bn, "gcc2_compiled") != NULL);
538 /* We use a heuristic for the file name, to try to sort it after
539 more useful symbols. It may not work on non Unix systems, but it
540 doesn't really matter; the only difference is precisely which
541 symbol names get printed. */
543 #define file_symbol(s, sn, snl) \
544 (((s)->flags & BSF_FILE) != 0 \
545 || ((sn)[(snl) - 2] == '.' \
546 && ((sn)[(snl) - 1] == 'o' \
547 || (sn)[(snl) - 1] == 'a')))
549 af = file_symbol (a, an, anl);
550 bf = file_symbol (b, bn, bnl);
557 /* Try to sort global symbols before local symbols before function
558 symbols before debugging symbols. */
563 if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
565 if ((aflags & BSF_DEBUGGING) != 0)
570 if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
572 if ((aflags & BSF_FUNCTION) != 0)
577 if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
579 if ((aflags & BSF_LOCAL) != 0)
584 if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
586 if ((aflags & BSF_GLOBAL) != 0)
592 /* Symbols that start with '.' might be section names, so sort them
593 after symbols that don't start with '.'. */
594 if (an[0] == '.' && bn[0] != '.')
596 if (an[0] != '.' && bn[0] == '.')
599 /* Finally, if we can't distinguish them in any other way, try to
600 get consistent results by sorting the symbols by name. */
601 return strcmp (an, bn);
604 /* Sort relocs into address order. */
607 compare_relocs (const void *ap, const void *bp)
609 const arelent *a = * (const arelent **) ap;
610 const arelent *b = * (const arelent **) bp;
612 if (a->address > b->address)
614 else if (a->address < b->address)
617 /* So that associated relocations tied to the same address show up
618 in the correct order, we don't do any further sorting. */
627 /* Print an address (VMA) to the output stream in INFO.
628 If SKIP_ZEROES is TRUE, omit leading zeroes. */
631 objdump_print_value (bfd_vma vma, struct disassemble_info *info,
632 bfd_boolean skip_zeroes)
636 struct objdump_disasm_info *aux;
638 aux = (struct objdump_disasm_info *) info->application_data;
639 bfd_sprintf_vma (aux->abfd, buf, vma);
644 for (p = buf; *p == '0'; ++p)
649 (*info->fprintf_func) (info->stream, "%s", p);
652 /* Print the name of a symbol. */
655 objdump_print_symname (bfd *abfd, struct disassemble_info *info,
662 name = bfd_asymbol_name (sym);
663 if (do_demangle && name[0] != '\0')
665 /* Demangle the name. */
666 alloc = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
672 (*info->fprintf_func) (info->stream, "%s", name);
680 /* Locate a symbol given a bfd and a section (from INFO->application_data),
681 and a VMA. If INFO->application_data->require_sec is TRUE, then always
682 require the symbol to be in the section. Returns NULL if there is no
683 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
684 of the symbol in sorted_syms. */
687 find_symbol_for_address (bfd_vma vma,
688 struct disassemble_info *info,
691 /* @@ Would it speed things up to cache the last two symbols returned,
692 and maybe their address ranges? For many processors, only one memory
693 operand can be present at a time, so the 2-entry cache wouldn't be
694 constantly churned by code doing heavy memory accesses. */
696 /* Indices in `sorted_syms'. */
698 long max = sorted_symcount;
700 struct objdump_disasm_info *aux;
704 bfd_boolean want_section;
706 if (sorted_symcount < 1)
709 aux = (struct objdump_disasm_info *) info->application_data;
712 opb = bfd_octets_per_byte (abfd);
714 /* Perform a binary search looking for the closest symbol to the
715 required value. We are searching the range (min, max]. */
716 while (min + 1 < max)
720 thisplace = (max + min) / 2;
721 sym = sorted_syms[thisplace];
723 if (bfd_asymbol_value (sym) > vma)
725 else if (bfd_asymbol_value (sym) < vma)
734 /* The symbol we want is now in min, the low end of the range we
735 were searching. If there are several symbols with the same
736 value, we want the first one. */
739 && (bfd_asymbol_value (sorted_syms[thisplace])
740 == bfd_asymbol_value (sorted_syms[thisplace - 1])))
743 /* Prefer a symbol in the current section if we have multple symbols
744 with the same value, as can occur with overlays or zero size
748 && (bfd_asymbol_value (sorted_syms[min])
749 == bfd_asymbol_value (sorted_syms[thisplace])))
751 if (sorted_syms[min]->section == sec
752 && info->symbol_is_valid (sorted_syms[min], info))
759 return sorted_syms[thisplace];
764 /* If the file is relocatable, and the symbol could be from this
765 section, prefer a symbol from this section over symbols from
766 others, even if the other symbol's value might be closer.
768 Note that this may be wrong for some symbol references if the
769 sections have overlapping memory ranges, but in that case there's
770 no way to tell what's desired without looking at the relocation
773 Also give the target a chance to reject symbols. */
774 want_section = (aux->require_sec
775 || ((abfd->flags & HAS_RELOC) != 0
776 && vma >= bfd_get_section_vma (abfd, sec)
777 && vma < (bfd_get_section_vma (abfd, sec)
778 + bfd_section_size (abfd, sec) / opb)));
779 if ((sorted_syms[thisplace]->section != sec && want_section)
780 || !info->symbol_is_valid (sorted_syms[thisplace], info))
783 long newplace = sorted_symcount;
785 for (i = min - 1; i >= 0; i--)
787 if ((sorted_syms[i]->section == sec || !want_section)
788 && info->symbol_is_valid (sorted_syms[i], info))
790 if (newplace == sorted_symcount)
793 if (bfd_asymbol_value (sorted_syms[i])
794 != bfd_asymbol_value (sorted_syms[newplace]))
797 /* Remember this symbol and keep searching until we reach
798 an earlier address. */
803 if (newplace != sorted_symcount)
804 thisplace = newplace;
807 /* We didn't find a good symbol with a smaller value.
808 Look for one with a larger value. */
809 for (i = thisplace + 1; i < sorted_symcount; i++)
811 if ((sorted_syms[i]->section == sec || !want_section)
812 && info->symbol_is_valid (sorted_syms[i], info))
820 if ((sorted_syms[thisplace]->section != sec && want_section)
821 || !info->symbol_is_valid (sorted_syms[thisplace], info))
822 /* There is no suitable symbol. */
829 return sorted_syms[thisplace];
832 /* Print an address and the offset to the nearest symbol. */
835 objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
836 bfd_vma vma, struct disassemble_info *info,
837 bfd_boolean skip_zeroes)
839 objdump_print_value (vma, info, skip_zeroes);
845 (*info->fprintf_func) (info->stream, " <%s",
846 bfd_get_section_name (abfd, sec));
847 secaddr = bfd_get_section_vma (abfd, sec);
850 (*info->fprintf_func) (info->stream, "-0x");
851 objdump_print_value (secaddr - vma, info, TRUE);
853 else if (vma > secaddr)
855 (*info->fprintf_func) (info->stream, "+0x");
856 objdump_print_value (vma - secaddr, info, TRUE);
858 (*info->fprintf_func) (info->stream, ">");
862 (*info->fprintf_func) (info->stream, " <");
863 objdump_print_symname (abfd, info, sym);
864 if (bfd_asymbol_value (sym) > vma)
866 (*info->fprintf_func) (info->stream, "-0x");
867 objdump_print_value (bfd_asymbol_value (sym) - vma, info, TRUE);
869 else if (vma > bfd_asymbol_value (sym))
871 (*info->fprintf_func) (info->stream, "+0x");
872 objdump_print_value (vma - bfd_asymbol_value (sym), info, TRUE);
874 (*info->fprintf_func) (info->stream, ">");
877 if (display_file_offsets)
878 info->fprintf_func (info->stream, _(" (File Offset: 0x%lx)"),
879 (long int)(sec->filepos + (vma - sec->vma)));
882 /* Print an address (VMA), symbolically if possible.
883 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
886 objdump_print_addr (bfd_vma vma,
887 struct disassemble_info *info,
888 bfd_boolean skip_zeroes)
890 struct objdump_disasm_info *aux;
892 bfd_boolean skip_find = FALSE;
894 aux = (struct objdump_disasm_info *) info->application_data;
896 if (sorted_symcount < 1)
898 (*info->fprintf_func) (info->stream, "0x");
899 objdump_print_value (vma, info, skip_zeroes);
901 if (display_file_offsets)
902 info->fprintf_func (info->stream, _(" (File Offset: 0x%lx)"),
903 (long int)(aux->sec->filepos + (vma - aux->sec->vma)));
907 if (aux->reloc != NULL
908 && aux->reloc->sym_ptr_ptr != NULL
909 && * aux->reloc->sym_ptr_ptr != NULL)
911 sym = * aux->reloc->sym_ptr_ptr;
913 /* Adjust the vma to the reloc. */
914 vma += bfd_asymbol_value (sym);
916 if (bfd_is_und_section (bfd_get_section (sym)))
921 sym = find_symbol_for_address (vma, info, NULL);
923 objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, info,
927 /* Print VMA to INFO. This function is passed to the disassembler
931 objdump_print_address (bfd_vma vma, struct disassemble_info *info)
933 objdump_print_addr (vma, info, ! prefix_addresses);
936 /* Determine if the given address has a symbol associated with it. */
939 objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * info)
943 sym = find_symbol_for_address (vma, info, NULL);
945 return (sym != NULL && (bfd_asymbol_value (sym) == vma));
948 /* Hold the last function name and the last line number we displayed
951 static char *prev_functionname;
952 static unsigned int prev_line;
954 /* We keep a list of all files that we have seen when doing a
955 disassembly with source, so that we know how much of the file to
956 display. This can be important for inlined functions. */
958 struct print_file_list
960 struct print_file_list *next;
961 const char *filename;
965 const char **linemap;
971 static struct print_file_list *print_files;
973 /* The number of preceding context lines to show when we start
974 displaying a file for the first time. */
976 #define SHOW_PRECEDING_CONTEXT_LINES (5)
978 /* Read a complete file into memory. */
981 slurp_file (const char *fn, size_t *size)
984 int ps = getpagesize ();
989 int fd = open (fn, O_RDONLY | O_BINARY);
993 if (fstat (fd, &st) < 0)
997 msize = (*size + ps - 1) & ~(ps - 1);
998 map = mmap (NULL, msize, PROT_READ, MAP_SHARED, fd, 0);
999 if (map != (char *)-1L)
1005 map = malloc (*size);
1006 if (!map || (size_t) read (fd, (char *)map, *size) != *size)
1015 #define line_map_decrease 5
1017 /* Precompute array of lines for a mapped file. */
1019 static const char **
1020 index_file (const char *map, size_t size, unsigned int *maxline)
1022 const char *p, *lstart, *end;
1023 int chars_per_line = 45; /* First iteration will use 40. */
1024 unsigned int lineno;
1025 const char **linemap = NULL;
1026 unsigned long line_map_size = 0;
1032 for (p = map; p < end; p++)
1036 if (p + 1 < end && p[1] == '\r')
1039 else if (*p == '\r')
1041 if (p + 1 < end && p[1] == '\n')
1047 /* End of line found. */
1049 if (linemap == NULL || line_map_size < lineno + 1)
1051 unsigned long newsize;
1053 chars_per_line -= line_map_decrease;
1054 if (chars_per_line <= 1)
1056 line_map_size = size / chars_per_line + 1;
1057 if (line_map_size < lineno + 1)
1058 line_map_size = lineno + 1;
1059 newsize = line_map_size * sizeof (char *);
1060 linemap = xrealloc (linemap, newsize);
1063 linemap[lineno++] = lstart;
1071 /* Tries to open MODNAME, and if successful adds a node to print_files
1072 linked list and returns that node. Returns NULL on failure. */
1074 static struct print_file_list *
1075 try_print_file_open (const char *origname, const char *modname)
1077 struct print_file_list *p;
1079 p = xmalloc (sizeof (struct print_file_list));
1081 p->map = slurp_file (modname, &p->mapsize);
1088 p->linemap = index_file (p->map, p->mapsize, &p->maxline);
1090 p->filename = origname;
1091 p->modname = modname;
1092 p->next = print_files;
1098 /* If the the source file, as described in the symtab, is not found
1099 try to locate it in one of the paths specified with -I
1100 If found, add location to print_files linked list. */
1102 static struct print_file_list *
1103 update_source_path (const char *filename)
1105 struct print_file_list *p;
1109 if (filename == NULL)
1112 p = try_print_file_open (filename, filename);
1116 if (include_path_count == 0)
1119 /* Get the name of the file. */
1120 fname = strrchr (filename, '/');
1121 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1123 /* We could have a mixed forward/back slash case. */
1124 char *backslash = strrchr (filename, '\\');
1125 if (fname == NULL || (backslash != NULL && backslash > fname))
1127 if (fname == NULL && filename[0] != '\0' && filename[1] == ':')
1128 fname = filename + 1;
1136 /* If file exists under a new path, we need to add it to the list
1137 so that show_line knows about it. */
1138 for (i = 0; i < include_path_count; i++)
1140 char *modname = concat (include_paths[i], "/", fname, (const char *) 0);
1142 p = try_print_file_open (filename, modname);
1152 /* Print a source file line. */
1155 print_line (struct print_file_list *p, unsigned int line)
1161 if (line >= p->maxline)
1163 l = p->linemap [line];
1164 /* Test fwrite return value to quiet glibc warning. */
1165 len = strcspn (l, "\n\r");
1166 if (len == 0 || fwrite (l, len, 1, stdout) == 1)
1170 /* Print a range of source code lines. */
1173 dump_lines (struct print_file_list *p, unsigned int start, unsigned int end)
1177 while (start <= end)
1179 print_line (p, start);
1184 /* Show the line number, or the source line, in a disassembly
1188 show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
1190 const char *filename;
1191 const char *functionname;
1194 if (! with_line_numbers && ! with_source_code)
1197 if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename,
1198 &functionname, &line))
1201 if (filename != NULL && *filename == '\0')
1203 if (functionname != NULL && *functionname == '\0')
1204 functionname = NULL;
1206 if (with_line_numbers)
1208 if (functionname != NULL
1209 && (prev_functionname == NULL
1210 || strcmp (functionname, prev_functionname) != 0))
1211 printf ("%s():\n", functionname);
1212 if (line > 0 && line != prev_line)
1213 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
1216 if (with_source_code
1220 struct print_file_list **pp, *p;
1223 for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1224 if (strcmp ((*pp)->filename, filename) == 0)
1229 p = update_source_path (filename);
1231 if (p != NULL && line != p->last_line)
1233 if (file_start_context && p->first)
1237 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1240 if (p->last_line >= l && p->last_line <= line)
1241 l = p->last_line + 1;
1243 dump_lines (p, l, line);
1244 p->last_line = line;
1249 if (functionname != NULL
1250 && (prev_functionname == NULL
1251 || strcmp (functionname, prev_functionname) != 0))
1253 if (prev_functionname != NULL)
1254 free (prev_functionname);
1255 prev_functionname = xmalloc (strlen (functionname) + 1);
1256 strcpy (prev_functionname, functionname);
1259 if (line > 0 && line != prev_line)
1263 /* Pseudo FILE object for strings. */
1271 /* sprintf to a "stream". */
1273 static int ATTRIBUTE_PRINTF_2
1274 objdump_sprintf (SFILE *f, const char *format, ...)
1281 size_t space = f->alloc - f->pos;
1283 va_start (args, format);
1284 n = vsnprintf (f->buffer + f->pos, space, format, args);
1290 f->alloc = (f->alloc + n) * 2;
1291 f->buffer = xrealloc (f->buffer, f->alloc);
1298 /* Returns TRUE if the specified section should be dumped. */
1301 process_section_p (asection * section)
1308 for (i = 0; i < only_used; i++)
1309 if (strcmp (only [i], section->name) == 0)
1316 /* The number of zeroes we want to see before we start skipping them.
1317 The number is arbitrarily chosen. */
1319 #define DEFAULT_SKIP_ZEROES 8
1321 /* The number of zeroes to skip at the end of a section. If the
1322 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1323 SKIP_ZEROES, they will be disassembled. If there are fewer than
1324 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1325 attempt to avoid disassembling zeroes inserted by section
1328 #define DEFAULT_SKIP_ZEROES_AT_END 3
1330 /* Disassemble some data in memory between given values. */
1333 disassemble_bytes (struct disassemble_info * info,
1334 disassembler_ftype disassemble_fn,
1337 bfd_vma start_offset,
1338 bfd_vma stop_offset,
1341 arelent ** relppend)
1343 struct objdump_disasm_info *aux;
1345 int octets_per_line;
1346 bfd_boolean done_dot;
1347 int skip_addr_chars;
1348 bfd_vma addr_offset;
1349 unsigned int opb = info->octets_per_byte;
1350 unsigned int skip_zeroes = info->skip_zeroes;
1351 unsigned int skip_zeroes_at_end = info->skip_zeroes_at_end;
1355 aux = (struct objdump_disasm_info *) info->application_data;
1359 sfile.buffer = xmalloc (sfile.alloc);
1363 octets_per_line = 4;
1365 octets_per_line = 16;
1367 /* Figure out how many characters to skip at the start of an
1368 address, to make the disassembly look nicer. We discard leading
1369 zeroes in chunks of 4, ensuring that there is always a leading
1371 skip_addr_chars = 0;
1372 if (! prefix_addresses)
1376 bfd_sprintf_vma (aux->abfd, buf, section->vma + section->size / opb);
1378 while (buf[skip_addr_chars] == '0')
1381 /* Don't discard zeros on overflow. */
1382 if (buf[skip_addr_chars] == '\0' && section->vma != 0)
1383 skip_addr_chars = 0;
1385 if (skip_addr_chars != 0)
1386 skip_addr_chars = (skip_addr_chars - 1) & -4;
1389 info->insn_info_valid = 0;
1392 addr_offset = start_offset;
1393 while (addr_offset < stop_offset)
1396 bfd_boolean need_nl = FALSE;
1397 int previous_octets;
1399 /* Remember the length of the previous instruction. */
1400 previous_octets = octets;
1403 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1405 for (z = addr_offset * opb; z < stop_offset * opb; z++)
1408 if (! disassemble_zeroes
1409 && (info->insn_info_valid == 0
1410 || info->branch_delay_insns == 0)
1411 && (z - addr_offset * opb >= skip_zeroes
1412 || (z == stop_offset * opb &&
1413 z - addr_offset * opb < skip_zeroes_at_end)))
1415 /* If there are more nonzero octets to follow, we only skip
1416 zeroes in multiples of 4, to try to avoid running over
1417 the start of an instruction which happens to start with
1419 if (z != stop_offset * opb)
1420 z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1422 octets = z - addr_offset * opb;
1424 /* If we are going to display more data, and we are displaying
1425 file offsets, then tell the user how many zeroes we skip
1426 and the file offset from where we resume dumping. */
1427 if (display_file_offsets && ((addr_offset + (octets / opb)) < stop_offset))
1428 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1430 (unsigned long) (section->filepos
1431 + (addr_offset + (octets / opb))));
1443 if (with_line_numbers || with_source_code)
1444 show_line (aux->abfd, section, addr_offset);
1446 if (! prefix_addresses)
1450 bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
1451 for (s = buf + skip_addr_chars; *s == '0'; s++)
1455 printf ("%s:\t", buf + skip_addr_chars);
1459 aux->require_sec = TRUE;
1460 objdump_print_address (section->vma + addr_offset, info);
1461 aux->require_sec = FALSE;
1468 info->fprintf_func = (fprintf_ftype) objdump_sprintf;
1469 info->stream = &sfile;
1470 info->bytes_per_line = 0;
1471 info->bytes_per_chunk = 0;
1474 if (info->disassembler_needs_relocs
1475 && (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0
1476 && (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0
1477 && *relppp < relppend)
1479 bfd_signed_vma distance_to_rel;
1481 distance_to_rel = (**relppp)->address
1482 - (rel_offset + addr_offset);
1484 /* Check to see if the current reloc is associated with
1485 the instruction that we are about to disassemble. */
1486 if (distance_to_rel == 0
1487 /* FIXME: This is wrong. We are trying to catch
1488 relocs that are addressed part way through the
1489 current instruction, as might happen with a packed
1490 VLIW instruction. Unfortunately we do not know the
1491 length of the current instruction since we have not
1492 disassembled it yet. Instead we take a guess based
1493 upon the length of the previous instruction. The
1494 proper solution is to have a new target-specific
1495 disassembler function which just returns the length
1496 of an instruction at a given address without trying
1497 to display its disassembly. */
1498 || (distance_to_rel > 0
1499 && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
1501 info->flags = INSN_HAS_RELOC;
1502 aux->reloc = **relppp;
1508 octets = (*disassemble_fn) (section->vma + addr_offset, info);
1509 info->fprintf_func = (fprintf_ftype) fprintf;
1510 info->stream = stdout;
1511 if (info->bytes_per_line != 0)
1512 octets_per_line = info->bytes_per_line;
1516 printf ("%s\n", sfile.buffer);
1524 octets = octets_per_line;
1525 if (addr_offset + octets / opb > stop_offset)
1526 octets = (stop_offset - addr_offset) * opb;
1528 for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1530 if (ISPRINT (data[j]))
1531 buf[j - addr_offset * opb] = data[j];
1533 buf[j - addr_offset * opb] = '.';
1535 buf[j - addr_offset * opb] = '\0';
1538 if (prefix_addresses
1540 : show_raw_insn >= 0)
1544 /* If ! prefix_addresses and ! wide_output, we print
1545 octets_per_line octets per line. */
1547 if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1548 pb = octets_per_line;
1550 if (info->bytes_per_chunk)
1551 bpc = info->bytes_per_chunk;
1555 for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1559 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1561 for (k = bpc - 1; k >= 0; k--)
1562 printf ("%02x", (unsigned) data[j + k]);
1567 for (k = 0; k < bpc; k++)
1568 printf ("%02x", (unsigned) data[j + k]);
1573 for (; pb < octets_per_line; pb += bpc)
1577 for (k = 0; k < bpc; k++)
1582 /* Separate raw data from instruction by extra space. */
1592 printf ("%s", sfile.buffer);
1594 if (prefix_addresses
1596 : show_raw_insn >= 0)
1604 j = addr_offset * opb + pb;
1606 bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
1607 for (s = buf + skip_addr_chars; *s == '0'; s++)
1611 printf ("%s:\t", buf + skip_addr_chars);
1613 pb += octets_per_line;
1616 for (; j < addr_offset * opb + pb; j += bpc)
1620 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1622 for (k = bpc - 1; k >= 0; k--)
1623 printf ("%02x", (unsigned) data[j + k]);
1628 for (k = 0; k < bpc; k++)
1629 printf ("%02x", (unsigned) data[j + k]);
1642 while ((*relppp) < relppend
1643 && (**relppp)->address < rel_offset + addr_offset + octets / opb)
1645 if (dump_reloc_info || dump_dynamic_reloc_info)
1656 objdump_print_value (section->vma - rel_offset + q->address,
1659 if (q->howto == NULL)
1660 printf (": *unknown*\t");
1661 else if (q->howto->name)
1662 printf (": %s\t", q->howto->name);
1664 printf (": %d\t", q->howto->type);
1666 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1667 printf ("*unknown*");
1670 const char *sym_name;
1672 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1673 if (sym_name != NULL && *sym_name != '\0')
1674 objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
1679 sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1680 sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1681 if (sym_name == NULL || *sym_name == '\0')
1682 sym_name = "*unknown*";
1683 printf ("%s", sym_name);
1690 objdump_print_value (q->addend, info, TRUE);
1702 addr_offset += octets / opb;
1705 free (sfile.buffer);
1709 disassemble_section (bfd *abfd, asection *section, void *info)
1711 struct disassemble_info * pinfo = (struct disassemble_info *) info;
1712 struct objdump_disasm_info * paux;
1713 unsigned int opb = pinfo->octets_per_byte;
1714 bfd_byte * data = NULL;
1715 bfd_size_type datasize = 0;
1716 arelent ** rel_pp = NULL;
1717 arelent ** rel_ppstart = NULL;
1718 arelent ** rel_ppend;
1719 unsigned long stop_offset;
1720 asymbol * sym = NULL;
1724 unsigned long addr_offset;
1726 /* Sections that do not contain machine
1727 code are not normally disassembled. */
1728 if (! disassemble_all
1730 && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
1731 != (SEC_CODE | SEC_HAS_CONTENTS)))
1734 if (! process_section_p (section))
1737 datasize = bfd_get_section_size (section);
1741 /* Decide which set of relocs to use. Load them if necessary. */
1742 paux = (struct objdump_disasm_info *) pinfo->application_data;
1743 if (paux->dynrelbuf)
1745 rel_pp = paux->dynrelbuf;
1746 rel_count = paux->dynrelcount;
1747 /* Dynamic reloc addresses are absolute, non-dynamic are section
1748 relative. REL_OFFSET specifies the reloc address corresponding
1749 to the start of this section. */
1750 rel_offset = section->vma;
1758 if ((section->flags & SEC_RELOC) != 0
1759 && (dump_reloc_info || pinfo->disassembler_needs_relocs))
1763 relsize = bfd_get_reloc_upper_bound (abfd, section);
1765 bfd_fatal (bfd_get_filename (abfd));
1769 rel_ppstart = rel_pp = xmalloc (relsize);
1770 rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
1772 bfd_fatal (bfd_get_filename (abfd));
1774 /* Sort the relocs by address. */
1775 qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
1780 rel_ppend = rel_pp + rel_count;
1782 data = xmalloc (datasize);
1784 bfd_get_section_contents (abfd, section, data, 0, datasize);
1786 paux->sec = section;
1787 pinfo->buffer = data;
1788 pinfo->buffer_vma = section->vma;
1789 pinfo->buffer_length = datasize;
1790 pinfo->section = section;
1792 if (start_address == (bfd_vma) -1
1793 || start_address < pinfo->buffer_vma)
1796 addr_offset = start_address - pinfo->buffer_vma;
1798 if (stop_address == (bfd_vma) -1)
1799 stop_offset = datasize / opb;
1802 if (stop_address < pinfo->buffer_vma)
1805 stop_offset = stop_address - pinfo->buffer_vma;
1806 if (stop_offset > pinfo->buffer_length / opb)
1807 stop_offset = pinfo->buffer_length / opb;
1810 /* Skip over the relocs belonging to addresses below the
1812 while (rel_pp < rel_ppend
1813 && (*rel_pp)->address < rel_offset + addr_offset)
1816 if (addr_offset < stop_offset)
1817 printf (_("\nDisassembly of section %s:\n"), section->name);
1819 /* Find the nearest symbol forwards from our current position. */
1820 paux->require_sec = TRUE;
1821 sym = find_symbol_for_address (section->vma + addr_offset, info, &place);
1822 paux->require_sec = FALSE;
1824 /* Disassemble a block of instructions up to the address associated with
1825 the symbol we have just found. Then print the symbol and find the
1826 next symbol on. Repeat until we have disassembled the entire section
1827 or we have reached the end of the address range we are interested in. */
1828 while (addr_offset < stop_offset)
1832 unsigned long nextstop_offset;
1835 addr = section->vma + addr_offset;
1837 if (sym != NULL && bfd_asymbol_value (sym) <= addr)
1842 (x < sorted_symcount
1843 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
1847 pinfo->symbols = sorted_syms + place;
1848 pinfo->num_symbols = x - place;
1849 pinfo->symtab_pos = place;
1853 pinfo->symbols = NULL;
1854 pinfo->num_symbols = 0;
1855 pinfo->symtab_pos = -1;
1858 if (! prefix_addresses)
1860 pinfo->fprintf_func (pinfo->stream, "\n");
1861 objdump_print_addr_with_sym (abfd, section, sym, addr,
1863 pinfo->fprintf_func (pinfo->stream, ":\n");
1866 if (sym != NULL && bfd_asymbol_value (sym) > addr)
1868 else if (sym == NULL)
1872 #define is_valid_next_sym(SYM) \
1873 ((SYM)->section == section \
1874 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1875 && pinfo->symbol_is_valid (SYM, pinfo))
1877 /* Search forward for the next appropriate symbol in
1878 SECTION. Note that all the symbols are sorted
1879 together into one big array, and that some sections
1880 may have overlapping addresses. */
1881 while (place < sorted_symcount
1882 && ! is_valid_next_sym (sorted_syms [place]))
1885 if (place >= sorted_symcount)
1888 nextsym = sorted_syms[place];
1891 if (sym != NULL && bfd_asymbol_value (sym) > addr)
1892 nextstop_offset = bfd_asymbol_value (sym) - section->vma;
1893 else if (nextsym == NULL)
1894 nextstop_offset = stop_offset;
1896 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
1898 if (nextstop_offset > stop_offset)
1899 nextstop_offset = stop_offset;
1901 /* If a symbol is explicitly marked as being an object
1902 rather than a function, just dump the bytes without
1903 disassembling them. */
1906 || bfd_asymbol_value (sym) > addr
1907 || ((sym->flags & BSF_OBJECT) == 0
1908 && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1910 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1912 || (sym->flags & BSF_FUNCTION) != 0)
1917 disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
1918 addr_offset, nextstop_offset,
1919 rel_offset, &rel_pp, rel_ppend);
1921 addr_offset = nextstop_offset;
1927 if (rel_ppstart != NULL)
1931 /* Disassemble the contents of an object file. */
1934 disassemble_data (bfd *abfd)
1936 struct disassemble_info disasm_info;
1937 struct objdump_disasm_info aux;
1941 prev_functionname = NULL;
1944 /* We make a copy of syms to sort. We don't want to sort syms
1945 because that will screw up the relocs. */
1946 sorted_symcount = symcount ? symcount : dynsymcount;
1947 sorted_syms = xmalloc ((sorted_symcount + synthcount) * sizeof (asymbol *));
1948 memcpy (sorted_syms, symcount ? syms : dynsyms,
1949 sorted_symcount * sizeof (asymbol *));
1951 sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
1953 for (i = 0; i < synthcount; ++i)
1955 sorted_syms[sorted_symcount] = synthsyms + i;
1959 /* Sort the symbols into section and symbol order. */
1960 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
1962 init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
1964 disasm_info.application_data = (void *) &aux;
1966 aux.require_sec = FALSE;
1967 aux.dynrelbuf = NULL;
1968 aux.dynrelcount = 0;
1971 disasm_info.print_address_func = objdump_print_address;
1972 disasm_info.symbol_at_address_func = objdump_symbol_at_address;
1974 if (machine != NULL)
1976 const bfd_arch_info_type *info = bfd_scan_arch (machine);
1979 fatal (_("Can't use supplied machine %s"), machine);
1981 abfd->arch_info = info;
1984 if (endian != BFD_ENDIAN_UNKNOWN)
1986 struct bfd_target *xvec;
1988 xvec = xmalloc (sizeof (struct bfd_target));
1989 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
1990 xvec->byteorder = endian;
1994 /* Use libopcodes to locate a suitable disassembler. */
1995 aux.disassemble_fn = disassembler (abfd);
1996 if (!aux.disassemble_fn)
1998 non_fatal (_("Can't disassemble for architecture %s\n"),
1999 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
2004 disasm_info.flavour = bfd_get_flavour (abfd);
2005 disasm_info.arch = bfd_get_arch (abfd);
2006 disasm_info.mach = bfd_get_mach (abfd);
2007 disasm_info.disassembler_options = disassembler_options;
2008 disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
2009 disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
2010 disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
2011 disasm_info.disassembler_needs_relocs = FALSE;
2013 if (bfd_big_endian (abfd))
2014 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
2015 else if (bfd_little_endian (abfd))
2016 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
2018 /* ??? Aborting here seems too drastic. We could default to big or little
2020 disasm_info.endian = BFD_ENDIAN_UNKNOWN;
2022 /* Allow the target to customize the info structure. */
2023 disassemble_init_for_target (& disasm_info);
2025 /* Pre-load the dynamic relocs if we are going
2026 to be dumping them along with the disassembly. */
2027 if (dump_dynamic_reloc_info)
2029 long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2032 bfd_fatal (bfd_get_filename (abfd));
2036 aux.dynrelbuf = xmalloc (relsize);
2037 aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
2040 if (aux.dynrelcount < 0)
2041 bfd_fatal (bfd_get_filename (abfd));
2043 /* Sort the relocs by address. */
2044 qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
2048 disasm_info.symtab = sorted_syms;
2049 disasm_info.symtab_size = sorted_symcount;
2051 bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
2053 if (aux.dynrelbuf != NULL)
2054 free (aux.dynrelbuf);
2059 load_debug_section (enum dwarf_section_display_enum debug, void *file)
2061 struct dwarf_section *section = &debug_displays [debug].section;
2065 int section_is_compressed;
2067 /* If it is already loaded, do nothing. */
2068 if (section->start != NULL)
2071 /* Locate the debug section. */
2072 sec = bfd_get_section_by_name (abfd, section->uncompressed_name);
2074 section->name = section->uncompressed_name;
2077 sec = bfd_get_section_by_name (abfd, section->compressed_name);
2079 section->name = section->compressed_name;
2083 section_is_compressed = section->name == section->compressed_name;
2085 section->address = 0;
2086 section->size = bfd_get_section_size (sec);
2087 section->start = xmalloc (section->size);
2089 if (is_relocatable && debug_displays [debug].relocate)
2090 ret = bfd_simple_get_relocated_section_contents (abfd,
2095 ret = bfd_get_section_contents (abfd, sec, section->start, 0,
2100 free_debug_section (debug);
2101 printf (_("\nCan't get contents for section '%s'.\n"),
2106 if (section_is_compressed)
2108 bfd_size_type size = section->size;
2109 if (! bfd_uncompress_section_contents (§ion->start, &size))
2111 free_debug_section (debug);
2112 printf (_("\nCan't uncompress section '%s'.\n"), section->name);
2115 section->size = size;
2122 free_debug_section (enum dwarf_section_display_enum debug)
2124 struct dwarf_section *section = &debug_displays [debug].section;
2126 if (section->start == NULL)
2129 free ((char *) section->start);
2130 section->start = NULL;
2131 section->address = 0;
2136 dump_dwarf_section (bfd *abfd, asection *section,
2137 void *arg ATTRIBUTE_UNUSED)
2139 const char *name = bfd_get_section_name (abfd, section);
2141 enum dwarf_section_display_enum i;
2143 if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
2144 match = ".debug_info";
2148 for (i = 0; i < max; i++)
2149 if (strcmp (debug_displays [i].section.uncompressed_name, match) == 0
2150 || strcmp (debug_displays [i].section.compressed_name, match) == 0)
2152 if (!debug_displays [i].eh_frame)
2154 struct dwarf_section *sec = &debug_displays [i].section;
2156 if (load_debug_section (i, abfd))
2158 debug_displays [i].display (sec, abfd);
2160 if (i != info && i != abbrev)
2161 free_debug_section (i);
2168 /* Dump the dwarf debugging information. */
2171 dump_dwarf (bfd *abfd)
2173 is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2175 /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
2176 targets will return 64. */
2177 eh_addr_size = bfd_get_arch_size (abfd) == 64 ? 8 : 4;
2179 if (bfd_big_endian (abfd))
2180 byte_get = byte_get_big_endian;
2181 else if (bfd_little_endian (abfd))
2182 byte_get = byte_get_little_endian;
2186 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
2188 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2189 init_dwarf_regnames (bed->elf_machine_code);
2192 bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2194 free_debug_memory ();
2197 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2198 it. Return NULL on failure. */
2201 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
2207 stabsect = bfd_get_section_by_name (abfd, sect_name);
2208 if (stabsect == NULL)
2210 printf (_("No %s section present\n\n"), sect_name);
2214 size = bfd_section_size (abfd, stabsect);
2215 contents = xmalloc (size);
2217 if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
2219 non_fatal (_("Reading %s section of %s failed: %s"),
2220 sect_name, bfd_get_filename (abfd),
2221 bfd_errmsg (bfd_get_error ()));
2232 /* Stabs entries use a 12 byte format:
2233 4 byte string table index
2235 1 byte stab other field
2236 2 byte stab desc field
2238 FIXME: This will have to change for a 64 bit object format. */
2240 #define STRDXOFF (0)
2242 #define OTHEROFF (5)
2245 #define STABSIZE (12)
2247 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2248 using string table section STRSECT_NAME (in `strtab'). */
2251 print_section_stabs (bfd *abfd,
2252 const char *stabsect_name,
2253 unsigned *string_offset_ptr)
2256 unsigned file_string_table_offset = 0;
2257 unsigned next_file_string_table_offset = *string_offset_ptr;
2258 bfd_byte *stabp, *stabs_end;
2261 stabs_end = stabp + stab_size;
2263 printf (_("Contents of %s section:\n\n"), stabsect_name);
2264 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2266 /* Loop through all symbols and print them.
2268 We start the index at -1 because there is a dummy symbol on
2269 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2270 for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
2274 unsigned char type, other;
2275 unsigned short desc;
2278 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2279 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2280 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2281 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2282 value = bfd_h_get_32 (abfd, stabp + VALOFF);
2284 printf ("\n%-6d ", i);
2285 /* Either print the stab name, or, if unnamed, print its number
2286 again (makes consistent formatting for tools like awk). */
2287 name = bfd_get_stab_name (type);
2289 printf ("%-6s", name);
2290 else if (type == N_UNDF)
2293 printf ("%-6d", type);
2294 printf (" %-6d %-6d ", other, desc);
2295 bfd_printf_vma (abfd, value);
2296 printf (" %-6lu", strx);
2298 /* Symbols with type == 0 (N_UNDF) specify the length of the
2299 string table associated with this file. We use that info
2300 to know how to relocate the *next* file's string table indices. */
2303 file_string_table_offset = next_file_string_table_offset;
2304 next_file_string_table_offset += value;
2308 /* Using the (possibly updated) string table offset, print the
2309 string (if any) associated with this symbol. */
2310 if ((strx + file_string_table_offset) < stabstr_size)
2311 printf (" %s", &strtab[strx + file_string_table_offset]);
2317 *string_offset_ptr = next_file_string_table_offset;
2322 const char * section_name;
2323 const char * string_section_name;
2324 unsigned string_offset;
2329 find_stabs_section (bfd *abfd, asection *section, void *names)
2332 stab_section_names * sought = (stab_section_names *) names;
2334 /* Check for section names for which stabsect_name is a prefix, to
2335 handle .stab.N, etc. */
2336 len = strlen (sought->section_name);
2338 /* If the prefix matches, and the files section name ends with a
2339 nul or a digit, then we match. I.e., we want either an exact
2340 match or a section followed by a number. */
2341 if (strncmp (sought->section_name, section->name, len) == 0
2342 && (section->name[len] == 0
2343 || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2346 strtab = read_section_stabs (abfd, sought->string_section_name,
2351 stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2354 print_section_stabs (abfd, section->name, &sought->string_offset);
2360 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2362 stab_section_names s;
2364 s.section_name = stabsect_name;
2365 s.string_section_name = strsect_name;
2366 s.string_offset = 0;
2368 bfd_map_over_sections (abfd, find_stabs_section, & s);
2374 /* Dump the any sections containing stabs debugging information. */
2377 dump_stabs (bfd *abfd)
2379 dump_stabs_section (abfd, ".stab", ".stabstr");
2380 dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2381 dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2384 dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2386 dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2390 dump_bfd_header (bfd *abfd)
2394 printf (_("architecture: %s, "),
2395 bfd_printable_arch_mach (bfd_get_arch (abfd),
2396 bfd_get_mach (abfd)));
2397 printf (_("flags 0x%08x:\n"), abfd->flags);
2399 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2400 PF (HAS_RELOC, "HAS_RELOC");
2401 PF (EXEC_P, "EXEC_P");
2402 PF (HAS_LINENO, "HAS_LINENO");
2403 PF (HAS_DEBUG, "HAS_DEBUG");
2404 PF (HAS_SYMS, "HAS_SYMS");
2405 PF (HAS_LOCALS, "HAS_LOCALS");
2406 PF (DYNAMIC, "DYNAMIC");
2407 PF (WP_TEXT, "WP_TEXT");
2408 PF (D_PAGED, "D_PAGED");
2409 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2410 PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
2411 printf (_("\nstart address 0x"));
2412 bfd_printf_vma (abfd, abfd->start_address);
2418 dump_bfd_private_header (bfd *abfd)
2420 bfd_print_private_bfd_data (abfd, stdout);
2424 /* Display a section in hexadecimal format with associated characters.
2425 Each line prefixed by the zero padded address. */
2428 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2431 bfd_size_type datasize;
2432 bfd_size_type addr_offset;
2433 bfd_size_type start_offset;
2434 bfd_size_type stop_offset;
2435 unsigned int opb = bfd_octets_per_byte (abfd);
2436 /* Bytes per line. */
2437 const int onaline = 16;
2442 if ((section->flags & SEC_HAS_CONTENTS) == 0)
2445 if (! process_section_p (section))
2448 if ((datasize = bfd_section_size (abfd, section)) == 0)
2451 /* Compute the address range to display. */
2452 if (start_address == (bfd_vma) -1
2453 || start_address < section->vma)
2456 start_offset = start_address - section->vma;
2458 if (stop_address == (bfd_vma) -1)
2459 stop_offset = datasize / opb;
2462 if (stop_address < section->vma)
2465 stop_offset = stop_address - section->vma;
2467 if (stop_offset > datasize / opb)
2468 stop_offset = datasize / opb;
2471 if (start_offset >= stop_offset)
2474 printf (_("Contents of section %s:"), section->name);
2475 if (display_file_offsets)
2476 printf (_(" (Starting at file offset: 0x%lx)"),
2477 (unsigned long) (section->filepos + start_offset));
2480 data = xmalloc (datasize);
2482 bfd_get_section_contents (abfd, section, data, 0, datasize);
2486 bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2487 if (strlen (buf) >= sizeof (buf))
2491 while (buf[count] == '0' && buf[count+1] != '\0')
2493 count = strlen (buf) - count;
2497 bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2498 if (strlen (buf) >= sizeof (buf))
2502 while (buf[count] == '0' && buf[count+1] != '\0')
2504 count = strlen (buf) - count;
2508 for (addr_offset = start_offset;
2509 addr_offset < stop_offset; addr_offset += onaline / opb)
2513 bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2514 count = strlen (buf);
2515 if ((size_t) count >= sizeof (buf))
2519 while (count < width)
2524 fputs (buf + count - width, stdout);
2527 for (j = addr_offset * opb;
2528 j < addr_offset * opb + onaline; j++)
2530 if (j < stop_offset * opb)
2531 printf ("%02x", (unsigned) (data[j]));
2539 for (j = addr_offset * opb;
2540 j < addr_offset * opb + onaline; j++)
2542 if (j >= stop_offset * opb)
2545 printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2552 /* Actually display the various requested regions. */
2555 dump_data (bfd *abfd)
2557 bfd_map_over_sections (abfd, dump_section, NULL);
2560 /* Should perhaps share code and display with nm? */
2563 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2573 printf ("DYNAMIC SYMBOL TABLE:\n");
2579 printf ("SYMBOL TABLE:\n");
2583 printf (_("no symbols\n"));
2585 for (count = 0; count < max; count++)
2589 if (*current == NULL)
2590 printf (_("no information for symbol number %ld\n"), count);
2592 else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2593 printf (_("could not determine the type of symbol number %ld\n"),
2596 else if (process_section_p ((* current)->section)
2597 && (dump_special_syms
2598 || !bfd_is_target_special_symbol (cur_bfd, *current)))
2600 const char *name = (*current)->name;
2602 if (do_demangle && name != NULL && *name != '\0')
2606 /* If we want to demangle the name, we demangle it
2607 here, and temporarily clobber it while calling
2608 bfd_print_symbol. FIXME: This is a gross hack. */
2609 alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS);
2611 (*current)->name = alloc;
2612 bfd_print_symbol (cur_bfd, stdout, *current,
2613 bfd_print_symbol_all);
2616 (*current)->name = name;
2621 bfd_print_symbol (cur_bfd, stdout, *current,
2622 bfd_print_symbol_all);
2632 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2635 char *last_filename, *last_functionname;
2636 unsigned int last_line;
2638 /* Get column headers lined up reasonably. */
2646 bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2647 width = strlen (buf) - 7;
2649 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2652 last_filename = NULL;
2653 last_functionname = NULL;
2656 for (p = relpp; relcount && *p != NULL; p++, relcount--)
2659 const char *filename, *functionname;
2661 const char *sym_name;
2662 const char *section_name;
2664 if (start_address != (bfd_vma) -1
2665 && q->address < start_address)
2667 if (stop_address != (bfd_vma) -1
2668 && q->address > stop_address)
2671 if (with_line_numbers
2673 && bfd_find_nearest_line (abfd, sec, syms, q->address,
2674 &filename, &functionname, &line))
2676 if (functionname != NULL
2677 && (last_functionname == NULL
2678 || strcmp (functionname, last_functionname) != 0))
2680 printf ("%s():\n", functionname);
2681 if (last_functionname != NULL)
2682 free (last_functionname);
2683 last_functionname = xstrdup (functionname);
2687 && (line != last_line
2688 || (filename != NULL
2689 && last_filename != NULL
2690 && strcmp (filename, last_filename) != 0)))
2692 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2694 if (last_filename != NULL)
2695 free (last_filename);
2696 if (filename == NULL)
2697 last_filename = NULL;
2699 last_filename = xstrdup (filename);
2703 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2705 sym_name = (*(q->sym_ptr_ptr))->name;
2706 section_name = (*(q->sym_ptr_ptr))->section->name;
2711 section_name = NULL;
2714 bfd_printf_vma (abfd, q->address);
2715 if (q->howto == NULL)
2716 printf (" *unknown* ");
2717 else if (q->howto->name)
2718 printf (" %-16s ", q->howto->name);
2720 printf (" %-16d ", q->howto->type);
2722 objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
2725 if (section_name == NULL)
2726 section_name = "*unknown*";
2727 printf ("[%s]", section_name);
2733 bfd_printf_vma (abfd, q->addend);
2741 dump_relocs_in_section (bfd *abfd,
2743 void *dummy ATTRIBUTE_UNUSED)
2749 if ( bfd_is_abs_section (section)
2750 || bfd_is_und_section (section)
2751 || bfd_is_com_section (section)
2752 || (! process_section_p (section))
2753 || ((section->flags & SEC_RELOC) == 0))
2756 relsize = bfd_get_reloc_upper_bound (abfd, section);
2758 bfd_fatal (bfd_get_filename (abfd));
2760 printf ("RELOCATION RECORDS FOR [%s]:", section->name);
2764 printf (" (none)\n\n");
2768 relpp = xmalloc (relsize);
2769 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
2772 bfd_fatal (bfd_get_filename (abfd));
2773 else if (relcount == 0)
2774 printf (" (none)\n\n");
2778 dump_reloc_set (abfd, section, relpp, relcount);
2785 dump_relocs (bfd *abfd)
2787 bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
2791 dump_dynamic_relocs (bfd *abfd)
2797 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2799 bfd_fatal (bfd_get_filename (abfd));
2801 printf ("DYNAMIC RELOCATION RECORDS");
2804 printf (" (none)\n\n");
2807 relpp = xmalloc (relsize);
2808 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2811 bfd_fatal (bfd_get_filename (abfd));
2812 else if (relcount == 0)
2813 printf (" (none)\n\n");
2817 dump_reloc_set (abfd, NULL, relpp, relcount);
2824 /* Creates a table of paths, to search for source files. */
2827 add_include_path (const char *path)
2831 include_path_count++;
2832 include_paths = xrealloc (include_paths,
2833 include_path_count * sizeof (*include_paths));
2834 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2835 if (path[1] == ':' && path[2] == 0)
2836 path = concat (path, ".", (const char *) 0);
2838 include_paths[include_path_count - 1] = path;
2842 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
2846 if ((section->flags & SEC_DEBUGGING) == 0)
2848 bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
2849 section->vma += adjust_section_vma;
2851 section->lma += adjust_section_vma;
2855 /* Dump selected contents of ABFD. */
2858 dump_bfd (bfd *abfd)
2860 /* If we are adjusting section VMA's, change them all now. Changing
2861 the BFD information is a hack. However, we must do it, or
2862 bfd_find_nearest_line will not do the right thing. */
2863 if (adjust_section_vma != 0)
2865 bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
2866 bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
2869 if (! dump_debugging_tags)
2870 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
2873 print_arelt_descr (stdout, abfd, TRUE);
2874 if (dump_file_header)
2875 dump_bfd_header (abfd);
2876 if (dump_private_headers)
2877 dump_bfd_private_header (abfd);
2878 if (! dump_debugging_tags)
2880 if (dump_section_headers)
2881 dump_headers (abfd);
2887 || dump_dwarf_section_info)
2888 syms = slurp_symtab (abfd);
2889 if (dump_dynamic_symtab || dump_dynamic_reloc_info
2890 || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
2891 dynsyms = slurp_dynamic_symtab (abfd);
2894 synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
2895 dynsymcount, dynsyms, &synthsyms);
2901 dump_symbols (abfd, FALSE);
2902 if (dump_dynamic_symtab)
2903 dump_symbols (abfd, TRUE);
2904 if (dump_dwarf_section_info)
2906 if (dump_stab_section_info)
2908 if (dump_reloc_info && ! disassemble)
2910 if (dump_dynamic_reloc_info && ! disassemble)
2911 dump_dynamic_relocs (abfd);
2912 if (dump_section_contents)
2915 disassemble_data (abfd);
2921 dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
2922 if (dhandle != NULL)
2924 if (!print_debugging_info (stdout, dhandle, abfd, syms,
2926 dump_debugging_tags ? TRUE : FALSE))
2928 non_fatal (_("%s: printing debugging information failed"),
2929 bfd_get_filename (abfd));
2933 /* PR 6483: If there was no STABS or IEEE debug
2934 info in the file, try DWARF instead. */
2935 else if (! dump_dwarf_section_info)
2965 display_bfd (bfd *abfd)
2969 if (bfd_check_format_matches (abfd, bfd_object, &matching))
2975 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2977 nonfatal (bfd_get_filename (abfd));
2978 list_matching_formats (matching);
2983 if (bfd_get_error () != bfd_error_file_not_recognized)
2985 nonfatal (bfd_get_filename (abfd));
2989 if (bfd_check_format_matches (abfd, bfd_core, &matching))
2995 nonfatal (bfd_get_filename (abfd));
2997 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2999 list_matching_formats (matching);
3005 display_file (char *filename, char *target)
3010 if (get_file_size (filename) < 1)
3016 file = bfd_openr (filename, target);
3019 nonfatal (filename);
3023 /* If the file is an archive, process all of its elements. */
3024 if (bfd_check_format (file, bfd_archive))
3026 bfd *last_arfile = NULL;
3028 printf (_("In archive %s:\n"), bfd_get_filename (file));
3031 bfd_set_error (bfd_error_no_error);
3033 arfile = bfd_openr_next_archived_file (file, arfile);
3036 if (bfd_get_error () != bfd_error_no_more_archived_files)
3037 nonfatal (bfd_get_filename (file));
3041 display_bfd (arfile);
3043 if (last_arfile != NULL)
3044 bfd_close (last_arfile);
3045 last_arfile = arfile;
3048 if (last_arfile != NULL)
3049 bfd_close (last_arfile);
3058 main (int argc, char **argv)
3061 char *target = default_target;
3062 bfd_boolean seenflag = FALSE;
3064 #if defined (HAVE_SETLOCALE)
3065 #if defined (HAVE_LC_MESSAGES)
3066 setlocale (LC_MESSAGES, "");
3068 setlocale (LC_CTYPE, "");
3071 bindtextdomain (PACKAGE, LOCALEDIR);
3072 textdomain (PACKAGE);
3074 program_name = *argv;
3075 xmalloc_set_program_name (program_name);
3077 START_PROGRESS (program_name, 0);
3079 expandargv (&argc, &argv);
3082 set_default_bfd_target ();
3084 while ((c = getopt_long (argc, argv, "pib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW",
3085 long_options, (int *) 0))
3091 break; /* We've been given a long option. */
3096 if (disassembler_options)
3097 /* Ignore potential memory leak for now. */
3098 disassembler_options = concat (disassembler_options, ",",
3099 optarg, (const char *) NULL);
3101 disassembler_options = optarg;
3104 if (only_used == only_size)
3107 only = xrealloc (only, only_size * sizeof (char *));
3109 only [only_used++] = optarg;
3112 display_file_offsets = TRUE;
3115 with_line_numbers = TRUE;
3124 enum demangling_styles style;
3126 style = cplus_demangle_name_to_style (optarg);
3127 if (style == unknown_demangling)
3128 fatal (_("unknown demangling style `%s'"),
3131 cplus_demangle_set_style (style);
3137 case OPTION_ADJUST_VMA:
3138 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3140 case OPTION_START_ADDRESS:
3141 start_address = parse_vma (optarg, "--start-address");
3142 if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
3143 fatal (_("error: the start address should be before the end address"));
3145 case OPTION_STOP_ADDRESS:
3146 stop_address = parse_vma (optarg, "--stop-address");
3147 if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
3148 fatal (_("error: the stop address should be after the start address"));
3151 if (strcmp (optarg, "B") == 0)
3152 endian = BFD_ENDIAN_BIG;
3153 else if (strcmp (optarg, "L") == 0)
3154 endian = BFD_ENDIAN_LITTLE;
3157 non_fatal (_("unrecognized -E option"));
3162 if (strncmp (optarg, "big", strlen (optarg)) == 0)
3163 endian = BFD_ENDIAN_BIG;
3164 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3165 endian = BFD_ENDIAN_LITTLE;
3168 non_fatal (_("unrecognized --endian type `%s'"), optarg);
3174 dump_file_header = TRUE;
3178 formats_info = TRUE;
3182 add_include_path (optarg);
3185 dump_private_headers = TRUE;
3189 dump_private_headers = TRUE;
3191 dump_reloc_info = TRUE;
3192 dump_file_header = TRUE;
3193 dump_ar_hdrs = TRUE;
3194 dump_section_headers = TRUE;
3202 dump_dynamic_symtab = TRUE;
3210 disassemble_zeroes = TRUE;
3214 disassemble_all = TRUE;
3219 with_source_code = TRUE;
3228 dump_debugging_tags = 1;
3233 dump_dwarf_section_info = TRUE;
3236 do_debug_abbrevs = 1;
3238 do_debug_pubnames = 1;
3239 do_debug_aranges = 1;
3240 do_debug_ranges = 1;
3241 do_debug_frames = 1;
3242 do_debug_macinfo = 1;
3247 dump_stab_section_info = TRUE;
3251 dump_section_contents = TRUE;
3255 dump_reloc_info = TRUE;
3259 dump_dynamic_reloc_info = TRUE;
3263 dump_ar_hdrs = TRUE;
3267 dump_section_headers = TRUE;
3275 show_version = TRUE;
3285 print_version ("objdump");
3291 exit_status = display_info ();
3295 display_file ("a.out", target);
3297 for (; optind < argc;)
3298 display_file (argv[optind++], target);
3301 END_PROGRESS (program_name);