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 || sym->section != section
1907 || bfd_asymbol_value (sym) > addr
1908 || ((sym->flags & BSF_OBJECT) == 0
1909 && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1911 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1913 || (sym->flags & BSF_FUNCTION) != 0)
1918 disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
1919 addr_offset, nextstop_offset,
1920 rel_offset, &rel_pp, rel_ppend);
1922 addr_offset = nextstop_offset;
1928 if (rel_ppstart != NULL)
1932 /* Disassemble the contents of an object file. */
1935 disassemble_data (bfd *abfd)
1937 struct disassemble_info disasm_info;
1938 struct objdump_disasm_info aux;
1942 prev_functionname = NULL;
1945 /* We make a copy of syms to sort. We don't want to sort syms
1946 because that will screw up the relocs. */
1947 sorted_symcount = symcount ? symcount : dynsymcount;
1948 sorted_syms = xmalloc ((sorted_symcount + synthcount) * sizeof (asymbol *));
1949 memcpy (sorted_syms, symcount ? syms : dynsyms,
1950 sorted_symcount * sizeof (asymbol *));
1952 sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
1954 for (i = 0; i < synthcount; ++i)
1956 sorted_syms[sorted_symcount] = synthsyms + i;
1960 /* Sort the symbols into section and symbol order. */
1961 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
1963 init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
1965 disasm_info.application_data = (void *) &aux;
1967 aux.require_sec = FALSE;
1968 aux.dynrelbuf = NULL;
1969 aux.dynrelcount = 0;
1972 disasm_info.print_address_func = objdump_print_address;
1973 disasm_info.symbol_at_address_func = objdump_symbol_at_address;
1975 if (machine != NULL)
1977 const bfd_arch_info_type *info = bfd_scan_arch (machine);
1980 fatal (_("Can't use supplied machine %s"), machine);
1982 abfd->arch_info = info;
1985 if (endian != BFD_ENDIAN_UNKNOWN)
1987 struct bfd_target *xvec;
1989 xvec = xmalloc (sizeof (struct bfd_target));
1990 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
1991 xvec->byteorder = endian;
1995 /* Use libopcodes to locate a suitable disassembler. */
1996 aux.disassemble_fn = disassembler (abfd);
1997 if (!aux.disassemble_fn)
1999 non_fatal (_("Can't disassemble for architecture %s\n"),
2000 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
2005 disasm_info.flavour = bfd_get_flavour (abfd);
2006 disasm_info.arch = bfd_get_arch (abfd);
2007 disasm_info.mach = bfd_get_mach (abfd);
2008 disasm_info.disassembler_options = disassembler_options;
2009 disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
2010 disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
2011 disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
2012 disasm_info.disassembler_needs_relocs = FALSE;
2014 if (bfd_big_endian (abfd))
2015 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
2016 else if (bfd_little_endian (abfd))
2017 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
2019 /* ??? Aborting here seems too drastic. We could default to big or little
2021 disasm_info.endian = BFD_ENDIAN_UNKNOWN;
2023 /* Allow the target to customize the info structure. */
2024 disassemble_init_for_target (& disasm_info);
2026 /* Pre-load the dynamic relocs if we are going
2027 to be dumping them along with the disassembly. */
2028 if (dump_dynamic_reloc_info)
2030 long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2033 bfd_fatal (bfd_get_filename (abfd));
2037 aux.dynrelbuf = xmalloc (relsize);
2038 aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
2041 if (aux.dynrelcount < 0)
2042 bfd_fatal (bfd_get_filename (abfd));
2044 /* Sort the relocs by address. */
2045 qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
2049 disasm_info.symtab = sorted_syms;
2050 disasm_info.symtab_size = sorted_symcount;
2052 bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
2054 if (aux.dynrelbuf != NULL)
2055 free (aux.dynrelbuf);
2060 load_debug_section (enum dwarf_section_display_enum debug, void *file)
2062 struct dwarf_section *section = &debug_displays [debug].section;
2066 int section_is_compressed;
2068 /* If it is already loaded, do nothing. */
2069 if (section->start != NULL)
2072 /* Locate the debug section. */
2073 sec = bfd_get_section_by_name (abfd, section->uncompressed_name);
2075 section->name = section->uncompressed_name;
2078 sec = bfd_get_section_by_name (abfd, section->compressed_name);
2080 section->name = section->compressed_name;
2084 section_is_compressed = section->name == section->compressed_name;
2086 section->address = 0;
2087 section->size = bfd_get_section_size (sec);
2088 section->start = xmalloc (section->size);
2090 if (is_relocatable && debug_displays [debug].relocate)
2091 ret = bfd_simple_get_relocated_section_contents (abfd,
2096 ret = bfd_get_section_contents (abfd, sec, section->start, 0,
2101 free_debug_section (debug);
2102 printf (_("\nCan't get contents for section '%s'.\n"),
2107 if (section_is_compressed)
2109 bfd_size_type size = section->size;
2110 if (! bfd_uncompress_section_contents (§ion->start, &size))
2112 free_debug_section (debug);
2113 printf (_("\nCan't uncompress section '%s'.\n"), section->name);
2116 section->size = size;
2123 free_debug_section (enum dwarf_section_display_enum debug)
2125 struct dwarf_section *section = &debug_displays [debug].section;
2127 if (section->start == NULL)
2130 free ((char *) section->start);
2131 section->start = NULL;
2132 section->address = 0;
2137 dump_dwarf_section (bfd *abfd, asection *section,
2138 void *arg ATTRIBUTE_UNUSED)
2140 const char *name = bfd_get_section_name (abfd, section);
2142 enum dwarf_section_display_enum i;
2144 if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
2145 match = ".debug_info";
2149 for (i = 0; i < max; i++)
2150 if (strcmp (debug_displays [i].section.uncompressed_name, match) == 0
2151 || strcmp (debug_displays [i].section.compressed_name, match) == 0)
2153 if (!debug_displays [i].eh_frame)
2155 struct dwarf_section *sec = &debug_displays [i].section;
2157 if (load_debug_section (i, abfd))
2159 debug_displays [i].display (sec, abfd);
2161 if (i != info && i != abbrev)
2162 free_debug_section (i);
2169 /* Dump the dwarf debugging information. */
2172 dump_dwarf (bfd *abfd)
2174 is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2176 /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
2177 targets will return 64. */
2178 eh_addr_size = bfd_get_arch_size (abfd) == 64 ? 8 : 4;
2180 if (bfd_big_endian (abfd))
2181 byte_get = byte_get_big_endian;
2182 else if (bfd_little_endian (abfd))
2183 byte_get = byte_get_little_endian;
2187 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
2189 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2190 init_dwarf_regnames (bed->elf_machine_code);
2193 bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2195 free_debug_memory ();
2198 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2199 it. Return NULL on failure. */
2202 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
2208 stabsect = bfd_get_section_by_name (abfd, sect_name);
2209 if (stabsect == NULL)
2211 printf (_("No %s section present\n\n"), sect_name);
2215 size = bfd_section_size (abfd, stabsect);
2216 contents = xmalloc (size);
2218 if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
2220 non_fatal (_("Reading %s section of %s failed: %s"),
2221 sect_name, bfd_get_filename (abfd),
2222 bfd_errmsg (bfd_get_error ()));
2233 /* Stabs entries use a 12 byte format:
2234 4 byte string table index
2236 1 byte stab other field
2237 2 byte stab desc field
2239 FIXME: This will have to change for a 64 bit object format. */
2241 #define STRDXOFF (0)
2243 #define OTHEROFF (5)
2246 #define STABSIZE (12)
2248 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2249 using string table section STRSECT_NAME (in `strtab'). */
2252 print_section_stabs (bfd *abfd,
2253 const char *stabsect_name,
2254 unsigned *string_offset_ptr)
2257 unsigned file_string_table_offset = 0;
2258 unsigned next_file_string_table_offset = *string_offset_ptr;
2259 bfd_byte *stabp, *stabs_end;
2262 stabs_end = stabp + stab_size;
2264 printf (_("Contents of %s section:\n\n"), stabsect_name);
2265 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2267 /* Loop through all symbols and print them.
2269 We start the index at -1 because there is a dummy symbol on
2270 the front of stabs-in-{coff,elf} sections that supplies sizes. */
2271 for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
2275 unsigned char type, other;
2276 unsigned short desc;
2279 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2280 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2281 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2282 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2283 value = bfd_h_get_32 (abfd, stabp + VALOFF);
2285 printf ("\n%-6d ", i);
2286 /* Either print the stab name, or, if unnamed, print its number
2287 again (makes consistent formatting for tools like awk). */
2288 name = bfd_get_stab_name (type);
2290 printf ("%-6s", name);
2291 else if (type == N_UNDF)
2294 printf ("%-6d", type);
2295 printf (" %-6d %-6d ", other, desc);
2296 bfd_printf_vma (abfd, value);
2297 printf (" %-6lu", strx);
2299 /* Symbols with type == 0 (N_UNDF) specify the length of the
2300 string table associated with this file. We use that info
2301 to know how to relocate the *next* file's string table indices. */
2304 file_string_table_offset = next_file_string_table_offset;
2305 next_file_string_table_offset += value;
2309 /* Using the (possibly updated) string table offset, print the
2310 string (if any) associated with this symbol. */
2311 if ((strx + file_string_table_offset) < stabstr_size)
2312 printf (" %s", &strtab[strx + file_string_table_offset]);
2318 *string_offset_ptr = next_file_string_table_offset;
2323 const char * section_name;
2324 const char * string_section_name;
2325 unsigned string_offset;
2330 find_stabs_section (bfd *abfd, asection *section, void *names)
2333 stab_section_names * sought = (stab_section_names *) names;
2335 /* Check for section names for which stabsect_name is a prefix, to
2336 handle .stab.N, etc. */
2337 len = strlen (sought->section_name);
2339 /* If the prefix matches, and the files section name ends with a
2340 nul or a digit, then we match. I.e., we want either an exact
2341 match or a section followed by a number. */
2342 if (strncmp (sought->section_name, section->name, len) == 0
2343 && (section->name[len] == 0
2344 || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2347 strtab = read_section_stabs (abfd, sought->string_section_name,
2352 stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2355 print_section_stabs (abfd, section->name, &sought->string_offset);
2361 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2363 stab_section_names s;
2365 s.section_name = stabsect_name;
2366 s.string_section_name = strsect_name;
2367 s.string_offset = 0;
2369 bfd_map_over_sections (abfd, find_stabs_section, & s);
2375 /* Dump the any sections containing stabs debugging information. */
2378 dump_stabs (bfd *abfd)
2380 dump_stabs_section (abfd, ".stab", ".stabstr");
2381 dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2382 dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2385 dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2387 dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2391 dump_bfd_header (bfd *abfd)
2395 printf (_("architecture: %s, "),
2396 bfd_printable_arch_mach (bfd_get_arch (abfd),
2397 bfd_get_mach (abfd)));
2398 printf (_("flags 0x%08x:\n"), abfd->flags);
2400 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2401 PF (HAS_RELOC, "HAS_RELOC");
2402 PF (EXEC_P, "EXEC_P");
2403 PF (HAS_LINENO, "HAS_LINENO");
2404 PF (HAS_DEBUG, "HAS_DEBUG");
2405 PF (HAS_SYMS, "HAS_SYMS");
2406 PF (HAS_LOCALS, "HAS_LOCALS");
2407 PF (DYNAMIC, "DYNAMIC");
2408 PF (WP_TEXT, "WP_TEXT");
2409 PF (D_PAGED, "D_PAGED");
2410 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2411 PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
2412 printf (_("\nstart address 0x"));
2413 bfd_printf_vma (abfd, abfd->start_address);
2419 dump_bfd_private_header (bfd *abfd)
2421 bfd_print_private_bfd_data (abfd, stdout);
2425 /* Display a section in hexadecimal format with associated characters.
2426 Each line prefixed by the zero padded address. */
2429 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2432 bfd_size_type datasize;
2433 bfd_size_type addr_offset;
2434 bfd_size_type start_offset;
2435 bfd_size_type stop_offset;
2436 unsigned int opb = bfd_octets_per_byte (abfd);
2437 /* Bytes per line. */
2438 const int onaline = 16;
2443 if ((section->flags & SEC_HAS_CONTENTS) == 0)
2446 if (! process_section_p (section))
2449 if ((datasize = bfd_section_size (abfd, section)) == 0)
2452 /* Compute the address range to display. */
2453 if (start_address == (bfd_vma) -1
2454 || start_address < section->vma)
2457 start_offset = start_address - section->vma;
2459 if (stop_address == (bfd_vma) -1)
2460 stop_offset = datasize / opb;
2463 if (stop_address < section->vma)
2466 stop_offset = stop_address - section->vma;
2468 if (stop_offset > datasize / opb)
2469 stop_offset = datasize / opb;
2472 if (start_offset >= stop_offset)
2475 printf (_("Contents of section %s:"), section->name);
2476 if (display_file_offsets)
2477 printf (_(" (Starting at file offset: 0x%lx)"),
2478 (unsigned long) (section->filepos + start_offset));
2481 data = xmalloc (datasize);
2483 bfd_get_section_contents (abfd, section, data, 0, datasize);
2487 bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2488 if (strlen (buf) >= sizeof (buf))
2492 while (buf[count] == '0' && buf[count+1] != '\0')
2494 count = strlen (buf) - count;
2498 bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2499 if (strlen (buf) >= sizeof (buf))
2503 while (buf[count] == '0' && buf[count+1] != '\0')
2505 count = strlen (buf) - count;
2509 for (addr_offset = start_offset;
2510 addr_offset < stop_offset; addr_offset += onaline / opb)
2514 bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2515 count = strlen (buf);
2516 if ((size_t) count >= sizeof (buf))
2520 while (count < width)
2525 fputs (buf + count - width, stdout);
2528 for (j = addr_offset * opb;
2529 j < addr_offset * opb + onaline; j++)
2531 if (j < stop_offset * opb)
2532 printf ("%02x", (unsigned) (data[j]));
2540 for (j = addr_offset * opb;
2541 j < addr_offset * opb + onaline; j++)
2543 if (j >= stop_offset * opb)
2546 printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2553 /* Actually display the various requested regions. */
2556 dump_data (bfd *abfd)
2558 bfd_map_over_sections (abfd, dump_section, NULL);
2561 /* Should perhaps share code and display with nm? */
2564 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2574 printf ("DYNAMIC SYMBOL TABLE:\n");
2580 printf ("SYMBOL TABLE:\n");
2584 printf (_("no symbols\n"));
2586 for (count = 0; count < max; count++)
2590 if (*current == NULL)
2591 printf (_("no information for symbol number %ld\n"), count);
2593 else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2594 printf (_("could not determine the type of symbol number %ld\n"),
2597 else if (process_section_p ((* current)->section)
2598 && (dump_special_syms
2599 || !bfd_is_target_special_symbol (cur_bfd, *current)))
2601 const char *name = (*current)->name;
2603 if (do_demangle && name != NULL && *name != '\0')
2607 /* If we want to demangle the name, we demangle it
2608 here, and temporarily clobber it while calling
2609 bfd_print_symbol. FIXME: This is a gross hack. */
2610 alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS);
2612 (*current)->name = alloc;
2613 bfd_print_symbol (cur_bfd, stdout, *current,
2614 bfd_print_symbol_all);
2617 (*current)->name = name;
2622 bfd_print_symbol (cur_bfd, stdout, *current,
2623 bfd_print_symbol_all);
2633 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2636 char *last_filename, *last_functionname;
2637 unsigned int last_line;
2639 /* Get column headers lined up reasonably. */
2647 bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2648 width = strlen (buf) - 7;
2650 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2653 last_filename = NULL;
2654 last_functionname = NULL;
2657 for (p = relpp; relcount && *p != NULL; p++, relcount--)
2660 const char *filename, *functionname;
2662 const char *sym_name;
2663 const char *section_name;
2665 if (start_address != (bfd_vma) -1
2666 && q->address < start_address)
2668 if (stop_address != (bfd_vma) -1
2669 && q->address > stop_address)
2672 if (with_line_numbers
2674 && bfd_find_nearest_line (abfd, sec, syms, q->address,
2675 &filename, &functionname, &line))
2677 if (functionname != NULL
2678 && (last_functionname == NULL
2679 || strcmp (functionname, last_functionname) != 0))
2681 printf ("%s():\n", functionname);
2682 if (last_functionname != NULL)
2683 free (last_functionname);
2684 last_functionname = xstrdup (functionname);
2688 && (line != last_line
2689 || (filename != NULL
2690 && last_filename != NULL
2691 && strcmp (filename, last_filename) != 0)))
2693 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2695 if (last_filename != NULL)
2696 free (last_filename);
2697 if (filename == NULL)
2698 last_filename = NULL;
2700 last_filename = xstrdup (filename);
2704 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2706 sym_name = (*(q->sym_ptr_ptr))->name;
2707 section_name = (*(q->sym_ptr_ptr))->section->name;
2712 section_name = NULL;
2715 bfd_printf_vma (abfd, q->address);
2716 if (q->howto == NULL)
2717 printf (" *unknown* ");
2718 else if (q->howto->name)
2719 printf (" %-16s ", q->howto->name);
2721 printf (" %-16d ", q->howto->type);
2725 objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
2729 if (section_name == NULL)
2730 section_name = "*unknown*";
2731 printf ("[%s]", section_name);
2737 bfd_printf_vma (abfd, q->addend);
2745 dump_relocs_in_section (bfd *abfd,
2747 void *dummy ATTRIBUTE_UNUSED)
2753 if ( bfd_is_abs_section (section)
2754 || bfd_is_und_section (section)
2755 || bfd_is_com_section (section)
2756 || (! process_section_p (section))
2757 || ((section->flags & SEC_RELOC) == 0))
2760 relsize = bfd_get_reloc_upper_bound (abfd, section);
2762 bfd_fatal (bfd_get_filename (abfd));
2764 printf ("RELOCATION RECORDS FOR [%s]:", section->name);
2768 printf (" (none)\n\n");
2772 relpp = xmalloc (relsize);
2773 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
2776 bfd_fatal (bfd_get_filename (abfd));
2777 else if (relcount == 0)
2778 printf (" (none)\n\n");
2782 dump_reloc_set (abfd, section, relpp, relcount);
2789 dump_relocs (bfd *abfd)
2791 bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
2795 dump_dynamic_relocs (bfd *abfd)
2801 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2803 bfd_fatal (bfd_get_filename (abfd));
2805 printf ("DYNAMIC RELOCATION RECORDS");
2808 printf (" (none)\n\n");
2811 relpp = xmalloc (relsize);
2812 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2815 bfd_fatal (bfd_get_filename (abfd));
2816 else if (relcount == 0)
2817 printf (" (none)\n\n");
2821 dump_reloc_set (abfd, NULL, relpp, relcount);
2828 /* Creates a table of paths, to search for source files. */
2831 add_include_path (const char *path)
2835 include_path_count++;
2836 include_paths = xrealloc (include_paths,
2837 include_path_count * sizeof (*include_paths));
2838 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2839 if (path[1] == ':' && path[2] == 0)
2840 path = concat (path, ".", (const char *) 0);
2842 include_paths[include_path_count - 1] = path;
2846 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
2850 if ((section->flags & SEC_DEBUGGING) == 0)
2852 bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
2853 section->vma += adjust_section_vma;
2855 section->lma += adjust_section_vma;
2859 /* Dump selected contents of ABFD. */
2862 dump_bfd (bfd *abfd)
2864 /* If we are adjusting section VMA's, change them all now. Changing
2865 the BFD information is a hack. However, we must do it, or
2866 bfd_find_nearest_line will not do the right thing. */
2867 if (adjust_section_vma != 0)
2869 bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
2870 bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
2873 if (! dump_debugging_tags)
2874 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
2877 print_arelt_descr (stdout, abfd, TRUE);
2878 if (dump_file_header)
2879 dump_bfd_header (abfd);
2880 if (dump_private_headers)
2881 dump_bfd_private_header (abfd);
2882 if (! dump_debugging_tags)
2884 if (dump_section_headers)
2885 dump_headers (abfd);
2891 || dump_dwarf_section_info)
2892 syms = slurp_symtab (abfd);
2893 if (dump_dynamic_symtab || dump_dynamic_reloc_info
2894 || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
2895 dynsyms = slurp_dynamic_symtab (abfd);
2898 synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
2899 dynsymcount, dynsyms, &synthsyms);
2905 dump_symbols (abfd, FALSE);
2906 if (dump_dynamic_symtab)
2907 dump_symbols (abfd, TRUE);
2908 if (dump_dwarf_section_info)
2910 if (dump_stab_section_info)
2912 if (dump_reloc_info && ! disassemble)
2914 if (dump_dynamic_reloc_info && ! disassemble)
2915 dump_dynamic_relocs (abfd);
2916 if (dump_section_contents)
2919 disassemble_data (abfd);
2925 dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
2926 if (dhandle != NULL)
2928 if (!print_debugging_info (stdout, dhandle, abfd, syms,
2930 dump_debugging_tags ? TRUE : FALSE))
2932 non_fatal (_("%s: printing debugging information failed"),
2933 bfd_get_filename (abfd));
2937 /* PR 6483: If there was no STABS or IEEE debug
2938 info in the file, try DWARF instead. */
2939 else if (! dump_dwarf_section_info)
2969 display_bfd (bfd *abfd)
2973 if (bfd_check_format_matches (abfd, bfd_object, &matching))
2979 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2981 nonfatal (bfd_get_filename (abfd));
2982 list_matching_formats (matching);
2987 if (bfd_get_error () != bfd_error_file_not_recognized)
2989 nonfatal (bfd_get_filename (abfd));
2993 if (bfd_check_format_matches (abfd, bfd_core, &matching))
2999 nonfatal (bfd_get_filename (abfd));
3001 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3003 list_matching_formats (matching);
3009 display_file (char *filename, char *target)
3014 if (get_file_size (filename) < 1)
3020 file = bfd_openr (filename, target);
3023 nonfatal (filename);
3027 /* If the file is an archive, process all of its elements. */
3028 if (bfd_check_format (file, bfd_archive))
3030 bfd *last_arfile = NULL;
3032 printf (_("In archive %s:\n"), bfd_get_filename (file));
3035 bfd_set_error (bfd_error_no_error);
3037 arfile = bfd_openr_next_archived_file (file, arfile);
3040 if (bfd_get_error () != bfd_error_no_more_archived_files)
3041 nonfatal (bfd_get_filename (file));
3045 display_bfd (arfile);
3047 if (last_arfile != NULL)
3048 bfd_close (last_arfile);
3049 last_arfile = arfile;
3052 if (last_arfile != NULL)
3053 bfd_close (last_arfile);
3062 main (int argc, char **argv)
3065 char *target = default_target;
3066 bfd_boolean seenflag = FALSE;
3068 #if defined (HAVE_SETLOCALE)
3069 #if defined (HAVE_LC_MESSAGES)
3070 setlocale (LC_MESSAGES, "");
3072 setlocale (LC_CTYPE, "");
3075 bindtextdomain (PACKAGE, LOCALEDIR);
3076 textdomain (PACKAGE);
3078 program_name = *argv;
3079 xmalloc_set_program_name (program_name);
3081 START_PROGRESS (program_name, 0);
3083 expandargv (&argc, &argv);
3086 set_default_bfd_target ();
3088 while ((c = getopt_long (argc, argv, "pib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW",
3089 long_options, (int *) 0))
3095 break; /* We've been given a long option. */
3100 if (disassembler_options)
3101 /* Ignore potential memory leak for now. */
3102 disassembler_options = concat (disassembler_options, ",",
3103 optarg, (const char *) NULL);
3105 disassembler_options = optarg;
3108 if (only_used == only_size)
3111 only = xrealloc (only, only_size * sizeof (char *));
3113 only [only_used++] = optarg;
3116 display_file_offsets = TRUE;
3119 with_line_numbers = TRUE;
3128 enum demangling_styles style;
3130 style = cplus_demangle_name_to_style (optarg);
3131 if (style == unknown_demangling)
3132 fatal (_("unknown demangling style `%s'"),
3135 cplus_demangle_set_style (style);
3141 case OPTION_ADJUST_VMA:
3142 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3144 case OPTION_START_ADDRESS:
3145 start_address = parse_vma (optarg, "--start-address");
3146 if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
3147 fatal (_("error: the start address should be before the end address"));
3149 case OPTION_STOP_ADDRESS:
3150 stop_address = parse_vma (optarg, "--stop-address");
3151 if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
3152 fatal (_("error: the stop address should be after the start address"));
3155 if (strcmp (optarg, "B") == 0)
3156 endian = BFD_ENDIAN_BIG;
3157 else if (strcmp (optarg, "L") == 0)
3158 endian = BFD_ENDIAN_LITTLE;
3161 non_fatal (_("unrecognized -E option"));
3166 if (strncmp (optarg, "big", strlen (optarg)) == 0)
3167 endian = BFD_ENDIAN_BIG;
3168 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3169 endian = BFD_ENDIAN_LITTLE;
3172 non_fatal (_("unrecognized --endian type `%s'"), optarg);
3178 dump_file_header = TRUE;
3182 formats_info = TRUE;
3186 add_include_path (optarg);
3189 dump_private_headers = TRUE;
3193 dump_private_headers = TRUE;
3195 dump_reloc_info = TRUE;
3196 dump_file_header = TRUE;
3197 dump_ar_hdrs = TRUE;
3198 dump_section_headers = TRUE;
3206 dump_dynamic_symtab = TRUE;
3214 disassemble_zeroes = TRUE;
3218 disassemble_all = TRUE;
3223 with_source_code = TRUE;
3232 dump_debugging_tags = 1;
3237 dump_dwarf_section_info = TRUE;
3240 do_debug_abbrevs = 1;
3242 do_debug_pubnames = 1;
3243 do_debug_aranges = 1;
3244 do_debug_ranges = 1;
3245 do_debug_frames = 1;
3246 do_debug_macinfo = 1;
3251 dump_stab_section_info = TRUE;
3255 dump_section_contents = TRUE;
3259 dump_reloc_info = TRUE;
3263 dump_dynamic_reloc_info = TRUE;
3267 dump_ar_hdrs = TRUE;
3271 dump_section_headers = TRUE;
3279 show_version = TRUE;
3289 print_version ("objdump");
3295 exit_status = display_info ();
3299 display_file ("a.out", target);
3301 for (; optind < argc;)
3302 display_file (argv[optind++], target);
3305 END_PROGRESS (program_name);