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
4 Free Software Foundation, Inc.
6 This file is part of GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
24 Objdump displays information about one or more object files, either on
25 their own, or inside libraries. It is commonly used as a disassembler,
26 but it can also display information about file headers, symbol tables,
27 relocations, debugging directives and more.
29 The flow of execution is as follows:
31 1. Command line arguments are checked for control switches and the
32 information to be displayed is selected.
34 2. Any remaining arguments are assumed to be object files, and they are
35 processed in order by display_bfd(). If the file is an archive each
36 of its elements is processed in turn.
38 3. The file's target architecture and binary file format are determined
39 by bfd_check_format(). If they are recognised, then dump_bfd() is
42 4. dump_bfd() in turn calls separate functions to display the requested
43 item(s) of information(s). For example disassemble_data() is called if
44 a disassembly has been requested.
46 When disassembling the code loops through blocks of instructions bounded
47 by symbols, calling disassemble_bytes() on each block. The actual
48 disassembling is done by the libopcodes library, via a function pointer
49 supplied by the disassembler() function. */
57 #include "safe-ctype.h"
59 #include "libiberty.h"
64 /* Internal headers for the ELF .stab-dump code - sorry. */
65 #define BYTES_IN_WORD 32
66 #include "aout/aout64.h"
68 #ifdef NEED_DECLARATION_FPRINTF
69 /* This is needed by init_disassemble_info(). */
70 extern int fprintf (FILE *, const char *, ...);
74 static int exit_status = 0;
76 static char *default_target = NULL; /* Default at runtime. */
78 /* The following variables are set based on arguments passed on the
80 static int show_version = 0; /* Show the version number. */
81 static int dump_section_contents; /* -s */
82 static int dump_section_headers; /* -h */
83 static bfd_boolean dump_file_header; /* -f */
84 static int dump_symtab; /* -t */
85 static int dump_dynamic_symtab; /* -T */
86 static int dump_reloc_info; /* -r */
87 static int dump_dynamic_reloc_info; /* -R */
88 static int dump_ar_hdrs; /* -a */
89 static int dump_private_headers; /* -p */
90 static int prefix_addresses; /* --prefix-addresses */
91 static int with_line_numbers; /* -l */
92 static bfd_boolean with_source_code; /* -S */
93 static int show_raw_insn; /* --show-raw-insn */
94 static int dump_stab_section_info; /* --stabs */
95 static int do_demangle; /* -C, --demangle */
96 static bfd_boolean disassemble; /* -d */
97 static bfd_boolean disassemble_all; /* -D */
98 static int disassemble_zeroes; /* --disassemble-zeroes */
99 static bfd_boolean formats_info; /* -i */
100 static int wide_output; /* -w */
101 static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
102 static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */
103 static int dump_debugging; /* --debugging */
104 static int dump_debugging_tags; /* --debugging-tags */
105 static int dump_special_syms = 0; /* --special-syms */
106 static bfd_vma adjust_section_vma = 0; /* --adjust-vma */
107 static int file_start_context = 0; /* --file-start-context */
109 /* Pointer to an array of section names provided by
110 one or more "-j secname" command line options. */
112 /* The total number of slots in the only[] array. */
113 static size_t only_size = 0;
114 /* The number of occupied slots in the only[] array. */
115 static size_t only_used = 0;
117 /* Variables for handling include file path table. */
118 static const char **include_paths;
119 static int include_path_count;
121 /* Extra info to pass to the section disassembler and address printing
123 struct objdump_disasm_info
127 bfd_boolean require_sec;
128 arelent ** dynrelbuf;
130 disassembler_ftype disassemble_fn;
133 /* Architecture to disassemble for, or default if NULL. */
134 static char *machine = NULL;
136 /* Target specific options to the disassembler. */
137 static char *disassembler_options = NULL;
139 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
140 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
142 /* The symbol table. */
143 static asymbol **syms;
145 /* Number of symbols in `syms'. */
146 static long symcount = 0;
148 /* The sorted symbol table. */
149 static asymbol **sorted_syms;
151 /* Number of symbols in `sorted_syms'. */
152 static long sorted_symcount = 0;
154 /* The dynamic symbol table. */
155 static asymbol **dynsyms;
157 /* The synthetic symbol table. */
158 static asymbol *synthsyms;
159 static long synthcount = 0;
161 /* Number of symbols in `dynsyms'. */
162 static long dynsymcount = 0;
164 static bfd_byte *stabs;
165 static bfd_size_type stab_size;
168 static bfd_size_type stabstr_size;
171 usage (FILE *stream, int status)
173 fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
174 fprintf (stream, _(" Display information from object <file(s)>.\n"));
175 fprintf (stream, _(" At least one of the following switches must be given:\n"));
176 fprintf (stream, _("\
177 -a, --archive-headers Display archive header information\n\
178 -f, --file-headers Display the contents of the overall file header\n\
179 -p, --private-headers Display object format specific file header contents\n\
180 -h, --[section-]headers Display the contents of the section headers\n\
181 -x, --all-headers Display the contents of all headers\n\
182 -d, --disassemble Display assembler contents of executable sections\n\
183 -D, --disassemble-all Display assembler contents of all sections\n\
184 -S, --source Intermix source code with disassembly\n\
185 -s, --full-contents Display the full contents of all sections requested\n\
186 -g, --debugging Display debug information in object file\n\
187 -e, --debugging-tags Display debug information using ctags style\n\
188 -G, --stabs Display (in raw form) any STABS info in the file\n\
189 -t, --syms Display the contents of the symbol table(s)\n\
190 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
191 -r, --reloc Display the relocation entries in the file\n\
192 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
193 -v, --version Display this program's version number\n\
194 -i, --info List object formats and architectures supported\n\
195 -H, --help Display this information\n\
199 fprintf (stream, _("\n The following switches are optional:\n"));
200 fprintf (stream, _("\
201 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
202 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
203 -j, --section=NAME Only display information for section NAME\n\
204 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
205 -EB --endian=big Assume big endian format when disassembling\n\
206 -EL --endian=little Assume little endian format when disassembling\n\
207 --file-start-context Include context from start of file (with -S)\n\
208 -I, --include=DIR Add DIR to search list for source files\n\
209 -l, --line-numbers Include line numbers and filenames in output\n\
210 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
211 The STYLE, if specified, can be `auto', `gnu',\n\
212 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
214 -w, --wide Format output for more than 80 columns\n\
215 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
216 --start-address=ADDR Only process data whose address is >= ADDR\n\
217 --stop-address=ADDR Only process data whose address is <= ADDR\n\
218 --prefix-addresses Print complete address alongside disassembly\n\
219 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
220 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
221 --special-syms Include special symbols in symbol dumps\n\
223 list_supported_targets (program_name, stream);
224 list_supported_architectures (program_name, stream);
226 disassembler_usage (stream);
229 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
233 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
237 OPTION_START_ADDRESS,
242 static struct option long_options[]=
244 {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
245 {"all-headers", no_argument, NULL, 'x'},
246 {"private-headers", no_argument, NULL, 'p'},
247 {"architecture", required_argument, NULL, 'm'},
248 {"archive-headers", no_argument, NULL, 'a'},
249 {"debugging", no_argument, NULL, 'g'},
250 {"debugging-tags", no_argument, NULL, 'e'},
251 {"demangle", optional_argument, NULL, 'C'},
252 {"disassemble", no_argument, NULL, 'd'},
253 {"disassemble-all", no_argument, NULL, 'D'},
254 {"disassembler-options", required_argument, NULL, 'M'},
255 {"disassemble-zeroes", no_argument, NULL, 'z'},
256 {"dynamic-reloc", no_argument, NULL, 'R'},
257 {"dynamic-syms", no_argument, NULL, 'T'},
258 {"endian", required_argument, NULL, OPTION_ENDIAN},
259 {"file-headers", no_argument, NULL, 'f'},
260 {"file-start-context", no_argument, &file_start_context, 1},
261 {"full-contents", no_argument, NULL, 's'},
262 {"headers", no_argument, NULL, 'h'},
263 {"help", no_argument, NULL, 'H'},
264 {"info", no_argument, NULL, 'i'},
265 {"line-numbers", no_argument, NULL, 'l'},
266 {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
267 {"prefix-addresses", no_argument, &prefix_addresses, 1},
268 {"reloc", no_argument, NULL, 'r'},
269 {"section", required_argument, NULL, 'j'},
270 {"section-headers", no_argument, NULL, 'h'},
271 {"show-raw-insn", no_argument, &show_raw_insn, 1},
272 {"source", no_argument, NULL, 'S'},
273 {"special-syms", no_argument, &dump_special_syms, 1},
274 {"include", required_argument, NULL, 'I'},
275 {"stabs", no_argument, NULL, 'G'},
276 {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
277 {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
278 {"syms", no_argument, NULL, 't'},
279 {"target", required_argument, NULL, 'b'},
280 {"version", no_argument, NULL, 'V'},
281 {"wide", no_argument, NULL, 'w'},
282 {0, no_argument, 0, 0}
286 nonfatal (const char *msg)
293 dump_section_header (bfd *abfd ATTRIBUTE_UNUSED, asection *section,
294 void *ignored ATTRIBUTE_UNUSED)
297 unsigned int opb = bfd_octets_per_byte (abfd);
299 printf ("%3d %-13s %08lx ", section->index,
300 bfd_get_section_name (abfd, section),
301 (unsigned long) bfd_section_size (abfd, section) / opb);
302 bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
304 bfd_printf_vma (abfd, section->lma);
305 printf (" %08lx 2**%u", (unsigned long) section->filepos,
306 bfd_get_section_alignment (abfd, section));
312 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
314 PF (SEC_HAS_CONTENTS, "CONTENTS");
315 PF (SEC_ALLOC, "ALLOC");
316 PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
317 PF (SEC_LOAD, "LOAD");
318 PF (SEC_RELOC, "RELOC");
319 PF (SEC_READONLY, "READONLY");
320 PF (SEC_CODE, "CODE");
321 PF (SEC_DATA, "DATA");
323 PF (SEC_DEBUGGING, "DEBUGGING");
324 PF (SEC_NEVER_LOAD, "NEVER_LOAD");
325 PF (SEC_EXCLUDE, "EXCLUDE");
326 PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
327 PF (SEC_BLOCK, "BLOCK");
328 PF (SEC_CLINK, "CLINK");
329 PF (SEC_SMALL_DATA, "SMALL_DATA");
330 PF (SEC_SHARED, "SHARED");
331 PF (SEC_ARCH_BIT_0, "ARCH_BIT_0");
332 PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
334 if ((section->flags & SEC_LINK_ONCE) != 0)
337 struct coff_comdat_info *comdat;
339 switch (section->flags & SEC_LINK_DUPLICATES)
343 case SEC_LINK_DUPLICATES_DISCARD:
344 ls = "LINK_ONCE_DISCARD";
346 case SEC_LINK_DUPLICATES_ONE_ONLY:
347 ls = "LINK_ONCE_ONE_ONLY";
349 case SEC_LINK_DUPLICATES_SAME_SIZE:
350 ls = "LINK_ONCE_SAME_SIZE";
352 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
353 ls = "LINK_ONCE_SAME_CONTENTS";
356 printf ("%s%s", comma, ls);
358 comdat = bfd_coff_get_comdat_section (abfd, section);
360 printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);
370 dump_headers (bfd *abfd)
372 printf (_("Sections:\n"));
375 printf (_("Idx Name Size VMA LMA File off Algn"));
377 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
378 if (bfd_get_arch_size (abfd) == 32)
379 printf (_("Idx Name Size VMA LMA File off Algn"));
381 printf (_("Idx Name Size VMA LMA File off Algn"));
385 printf (_(" Flags"));
386 if (abfd->flags & HAS_LOAD_PAGE)
390 bfd_map_over_sections (abfd, dump_section_header, NULL);
394 slurp_symtab (bfd *abfd)
399 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
405 storage = bfd_get_symtab_upper_bound (abfd);
407 bfd_fatal (bfd_get_filename (abfd));
409 sy = xmalloc (storage);
411 symcount = bfd_canonicalize_symtab (abfd, sy);
413 bfd_fatal (bfd_get_filename (abfd));
417 /* Read in the dynamic symbols. */
420 slurp_dynamic_symtab (bfd *abfd)
425 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
428 if (!(bfd_get_file_flags (abfd) & DYNAMIC))
430 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
435 bfd_fatal (bfd_get_filename (abfd));
438 sy = xmalloc (storage);
440 dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
442 bfd_fatal (bfd_get_filename (abfd));
446 /* Filter out (in place) symbols that are useless for disassembly.
447 COUNT is the number of elements in SYMBOLS.
448 Return the number of useful symbols. */
451 remove_useless_symbols (asymbol **symbols, long count)
453 asymbol **in_ptr = symbols, **out_ptr = symbols;
457 asymbol *sym = *in_ptr++;
459 if (sym->name == NULL || sym->name[0] == '\0')
461 if (sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
463 if (bfd_is_und_section (sym->section)
464 || bfd_is_com_section (sym->section))
469 return out_ptr - symbols;
472 /* Sort symbols into value order. */
475 compare_symbols (const void *ap, const void *bp)
477 const asymbol *a = * (const asymbol **) ap;
478 const asymbol *b = * (const asymbol **) bp;
488 if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
490 else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
493 if (a->section > b->section)
495 else if (a->section < b->section)
498 an = bfd_asymbol_name (a);
499 bn = bfd_asymbol_name (b);
503 /* The symbols gnu_compiled and gcc2_compiled convey no real
504 information, so put them after other symbols with the same value. */
505 af = (strstr (an, "gnu_compiled") != NULL
506 || strstr (an, "gcc2_compiled") != NULL);
507 bf = (strstr (bn, "gnu_compiled") != NULL
508 || strstr (bn, "gcc2_compiled") != NULL);
515 /* We use a heuristic for the file name, to try to sort it after
516 more useful symbols. It may not work on non Unix systems, but it
517 doesn't really matter; the only difference is precisely which
518 symbol names get printed. */
520 #define file_symbol(s, sn, snl) \
521 (((s)->flags & BSF_FILE) != 0 \
522 || ((sn)[(snl) - 2] == '.' \
523 && ((sn)[(snl) - 1] == 'o' \
524 || (sn)[(snl) - 1] == 'a')))
526 af = file_symbol (a, an, anl);
527 bf = file_symbol (b, bn, bnl);
534 /* Try to sort global symbols before local symbols before function
535 symbols before debugging symbols. */
540 if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
542 if ((aflags & BSF_DEBUGGING) != 0)
547 if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
549 if ((aflags & BSF_FUNCTION) != 0)
554 if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
556 if ((aflags & BSF_LOCAL) != 0)
561 if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
563 if ((aflags & BSF_GLOBAL) != 0)
569 /* Symbols that start with '.' might be section names, so sort them
570 after symbols that don't start with '.'. */
571 if (an[0] == '.' && bn[0] != '.')
573 if (an[0] != '.' && bn[0] == '.')
576 /* Finally, if we can't distinguish them in any other way, try to
577 get consistent results by sorting the symbols by name. */
578 return strcmp (an, bn);
581 /* Sort relocs into address order. */
584 compare_relocs (const void *ap, const void *bp)
586 const arelent *a = * (const arelent **) ap;
587 const arelent *b = * (const arelent **) bp;
589 if (a->address > b->address)
591 else if (a->address < b->address)
594 /* So that associated relocations tied to the same address show up
595 in the correct order, we don't do any further sorting. */
604 /* Print an address (VMA) to the output stream in INFO.
605 If SKIP_ZEROES is TRUE, omit leading zeroes. */
608 objdump_print_value (bfd_vma vma, struct disassemble_info *info,
609 bfd_boolean skip_zeroes)
613 struct objdump_disasm_info *aux;
615 aux = (struct objdump_disasm_info *) info->application_data;
616 bfd_sprintf_vma (aux->abfd, buf, vma);
621 for (p = buf; *p == '0'; ++p)
626 (*info->fprintf_func) (info->stream, "%s", p);
629 /* Print the name of a symbol. */
632 objdump_print_symname (bfd *abfd, struct disassemble_info *info,
639 name = bfd_asymbol_name (sym);
640 if (do_demangle && name[0] != '\0')
642 /* Demangle the name. */
643 alloc = demangle (abfd, name);
648 (*info->fprintf_func) (info->stream, "%s", name);
656 /* Locate a symbol given a bfd and a section (from INFO->application_data),
657 and a VMA. If INFO->application_data->require_sec is TRUE, then always
658 require the symbol to be in the section. Returns NULL if there is no
659 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
660 of the symbol in sorted_syms. */
663 find_symbol_for_address (bfd_vma vma,
664 struct disassemble_info *info,
667 /* @@ Would it speed things up to cache the last two symbols returned,
668 and maybe their address ranges? For many processors, only one memory
669 operand can be present at a time, so the 2-entry cache wouldn't be
670 constantly churned by code doing heavy memory accesses. */
672 /* Indices in `sorted_syms'. */
674 long max = sorted_symcount;
676 struct objdump_disasm_info *aux;
681 if (sorted_symcount < 1)
684 aux = (struct objdump_disasm_info *) info->application_data;
687 opb = bfd_octets_per_byte (abfd);
689 /* Perform a binary search looking for the closest symbol to the
690 required value. We are searching the range (min, max]. */
691 while (min + 1 < max)
695 thisplace = (max + min) / 2;
696 sym = sorted_syms[thisplace];
698 if (bfd_asymbol_value (sym) > vma)
700 else if (bfd_asymbol_value (sym) < vma)
709 /* The symbol we want is now in min, the low end of the range we
710 were searching. If there are several symbols with the same
711 value, we want the first one. */
714 && (bfd_asymbol_value (sorted_syms[thisplace])
715 == bfd_asymbol_value (sorted_syms[thisplace - 1])))
718 /* If the file is relocatable, and the symbol could be from this
719 section, prefer a symbol from this section over symbols from
720 others, even if the other symbol's value might be closer.
722 Note that this may be wrong for some symbol references if the
723 sections have overlapping memory ranges, but in that case there's
724 no way to tell what's desired without looking at the relocation
726 if (sorted_syms[thisplace]->section != sec
728 || ((abfd->flags & HAS_RELOC) != 0
729 && vma >= bfd_get_section_vma (abfd, sec)
730 && vma < (bfd_get_section_vma (abfd, sec)
731 + bfd_section_size (abfd, sec) / opb))))
735 for (i = thisplace + 1; i < sorted_symcount; i++)
737 if (bfd_asymbol_value (sorted_syms[i])
738 != bfd_asymbol_value (sorted_syms[thisplace]))
746 if (sorted_syms[i]->section == sec
748 || sorted_syms[i - 1]->section != sec
749 || (bfd_asymbol_value (sorted_syms[i])
750 != bfd_asymbol_value (sorted_syms[i - 1]))))
757 if (sorted_syms[thisplace]->section != sec)
759 /* We didn't find a good symbol with a smaller value.
760 Look for one with a larger value. */
761 for (i = thisplace + 1; i < sorted_symcount; i++)
763 if (sorted_syms[i]->section == sec)
771 if (sorted_syms[thisplace]->section != sec
773 || ((abfd->flags & HAS_RELOC) != 0
774 && vma >= bfd_get_section_vma (abfd, sec)
775 && vma < (bfd_get_section_vma (abfd, sec)
776 + bfd_section_size (abfd, sec)))))
777 /* There is no suitable symbol. */
781 /* Give the target a chance to reject the symbol. */
782 while (! info->symbol_is_valid (sorted_syms [thisplace], info))
785 if (thisplace >= sorted_symcount
786 || bfd_asymbol_value (sorted_syms [thisplace]) > vma)
793 return sorted_syms[thisplace];
796 /* Print an address and the offset to the nearest symbol. */
799 objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
800 bfd_vma vma, struct disassemble_info *info,
801 bfd_boolean skip_zeroes)
803 objdump_print_value (vma, info, skip_zeroes);
809 (*info->fprintf_func) (info->stream, " <%s",
810 bfd_get_section_name (abfd, sec));
811 secaddr = bfd_get_section_vma (abfd, sec);
814 (*info->fprintf_func) (info->stream, "-0x");
815 objdump_print_value (secaddr - vma, info, TRUE);
817 else if (vma > secaddr)
819 (*info->fprintf_func) (info->stream, "+0x");
820 objdump_print_value (vma - secaddr, info, TRUE);
822 (*info->fprintf_func) (info->stream, ">");
826 (*info->fprintf_func) (info->stream, " <");
827 objdump_print_symname (abfd, info, sym);
828 if (bfd_asymbol_value (sym) > vma)
830 (*info->fprintf_func) (info->stream, "-0x");
831 objdump_print_value (bfd_asymbol_value (sym) - vma, info, TRUE);
833 else if (vma > bfd_asymbol_value (sym))
835 (*info->fprintf_func) (info->stream, "+0x");
836 objdump_print_value (vma - bfd_asymbol_value (sym), info, TRUE);
838 (*info->fprintf_func) (info->stream, ">");
842 /* Print an address (VMA), symbolically if possible.
843 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
846 objdump_print_addr (bfd_vma vma,
847 struct disassemble_info *info,
848 bfd_boolean skip_zeroes)
850 struct objdump_disasm_info *aux;
853 if (sorted_symcount < 1)
855 (*info->fprintf_func) (info->stream, "0x");
856 objdump_print_value (vma, info, skip_zeroes);
860 aux = (struct objdump_disasm_info *) info->application_data;
861 sym = find_symbol_for_address (vma, info, NULL);
862 objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, info,
866 /* Print VMA to INFO. This function is passed to the disassembler
870 objdump_print_address (bfd_vma vma, struct disassemble_info *info)
872 objdump_print_addr (vma, info, ! prefix_addresses);
875 /* Determine of the given address has a symbol associated with it. */
878 objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * info)
882 sym = find_symbol_for_address (vma, info, NULL);
884 return (sym != NULL && (bfd_asymbol_value (sym) == vma));
887 /* Hold the last function name and the last line number we displayed
890 static char *prev_functionname;
891 static unsigned int prev_line;
893 /* We keep a list of all files that we have seen when doing a
894 disassembly with source, so that we know how much of the file to
895 display. This can be important for inlined functions. */
897 struct print_file_list
899 struct print_file_list *next;
900 const char *filename;
906 static struct print_file_list *print_files;
908 /* The number of preceding context lines to show when we start
909 displaying a file for the first time. */
911 #define SHOW_PRECEDING_CONTEXT_LINES (5)
913 /* Tries to open MODNAME, and if successful adds a node to print_files
914 linked list and returns that node. Returns NULL on failure. */
916 static struct print_file_list *
917 try_print_file_open (const char *origname, const char *modname)
919 struct print_file_list *p;
922 f = fopen (modname, "r");
926 if (print_files != NULL && print_files->f != NULL)
928 fclose (print_files->f);
929 print_files->f = NULL;
932 p = xmalloc (sizeof (struct print_file_list));
933 p->filename = origname;
934 p->modname = modname;
937 p->next = print_files;
942 /* If the the source file, as described in the symtab, is not found
943 try to locate it in one of the paths specified with -I
944 If found, add location to print_files linked list. */
946 static struct print_file_list *
947 update_source_path (const char *filename)
949 struct print_file_list *p;
953 if (filename == NULL)
956 p = try_print_file_open (filename, filename);
960 if (include_path_count == 0)
963 /* Get the name of the file. */
964 fname = strrchr (filename, '/');
965 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
967 /* We could have a mixed forward/back slash case. */
968 char *backslash = strrchr (filename, '\\');
969 if (fname == NULL || (backslash != NULL && backslash > fname))
971 if (fname == NULL && filename[0] != '\0' && filename[1] == ':')
972 fname = filename + 1;
980 /* If file exists under a new path, we need to add it to the list
981 so that show_line knows about it. */
982 for (i = 0; i < include_path_count; i++)
984 char *modname = concat (include_paths[i], "/", fname, (const char *) 0);
986 p = try_print_file_open (filename, modname);
996 /* Skip ahead to a given line in a file, optionally printing each
1000 skip_to_line (struct print_file_list *p, unsigned int line,
1003 while (p->line < line)
1007 if (fgets (buf, sizeof buf, p->f) == NULL)
1017 if (strchr (buf, '\n') != NULL)
1022 /* Show the line number, or the source line, in a disassembly
1026 show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
1028 const char *filename;
1029 const char *functionname;
1032 if (! with_line_numbers && ! with_source_code)
1035 if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename,
1036 &functionname, &line))
1039 if (filename != NULL && *filename == '\0')
1041 if (functionname != NULL && *functionname == '\0')
1042 functionname = NULL;
1044 if (with_line_numbers)
1046 if (functionname != NULL
1047 && (prev_functionname == NULL
1048 || strcmp (functionname, prev_functionname) != 0))
1049 printf ("%s():\n", functionname);
1050 if (line > 0 && line != prev_line)
1051 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
1054 if (with_source_code
1058 struct print_file_list **pp, *p;
1060 for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1061 if (strcmp ((*pp)->filename, filename) == 0)
1067 if (p != print_files)
1071 /* We have reencountered a file name which we saw
1072 earlier. This implies that either we are dumping out
1073 code from an included file, or the same file was
1074 linked in more than once. There are two common cases
1075 of an included file: inline functions in a header
1076 file, and a bison or flex skeleton file. In the
1077 former case we want to just start printing (but we
1078 back up a few lines to give context); in the latter
1079 case we want to continue from where we left off. I
1080 can't think of a good way to distinguish the cases,
1081 so I used a heuristic based on the file name. */
1082 if (strcmp (p->filename + strlen (p->filename) - 2, ".h") != 0)
1086 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1093 p->f = fopen (p->modname, "r");
1097 skip_to_line (p, l, FALSE);
1099 if (print_files->f != NULL)
1101 fclose (print_files->f);
1102 print_files->f = NULL;
1108 skip_to_line (p, line, TRUE);
1110 p->next = print_files;
1116 p = update_source_path (filename);
1122 if (file_start_context)
1125 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1128 skip_to_line (p, l, FALSE);
1130 skip_to_line (p, line, TRUE);
1135 if (functionname != NULL
1136 && (prev_functionname == NULL
1137 || strcmp (functionname, prev_functionname) != 0))
1139 if (prev_functionname != NULL)
1140 free (prev_functionname);
1141 prev_functionname = xmalloc (strlen (functionname) + 1);
1142 strcpy (prev_functionname, functionname);
1145 if (line > 0 && line != prev_line)
1149 /* Pseudo FILE object for strings. */
1157 /* sprintf to a "stream". */
1160 objdump_sprintf (SFILE *f, const char *format, ...)
1167 size_t space = f->alloc - f->pos;
1169 va_start (args, format);
1170 n = vsnprintf (f->buffer + f->pos, space, format, args);
1176 f->alloc = (f->alloc + n) * 2;
1177 f->buffer = xrealloc (f->buffer, f->alloc);
1184 /* Returns TRUE if the specified section should be dumped. */
1187 process_section_p (asection * section)
1194 for (i = 0; i < only_used; i++)
1195 if (strcmp (only [i], section->name) == 0)
1202 /* The number of zeroes we want to see before we start skipping them.
1203 The number is arbitrarily chosen. */
1205 #define DEFAULT_SKIP_ZEROES 8
1207 /* The number of zeroes to skip at the end of a section. If the
1208 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1209 SKIP_ZEROES, they will be disassembled. If there are fewer than
1210 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1211 attempt to avoid disassembling zeroes inserted by section
1214 #define DEFAULT_SKIP_ZEROES_AT_END 3
1216 /* Disassemble some data in memory between given values. */
1219 disassemble_bytes (struct disassemble_info * info,
1220 disassembler_ftype disassemble_fn,
1223 bfd_vma start_offset,
1224 bfd_vma stop_offset,
1227 arelent ** relppend)
1229 struct objdump_disasm_info *aux;
1231 int octets_per_line;
1232 bfd_boolean done_dot;
1233 int skip_addr_chars;
1234 bfd_vma addr_offset;
1235 unsigned int opb = info->octets_per_byte;
1236 unsigned int skip_zeroes = info->skip_zeroes;
1237 unsigned int skip_zeroes_at_end = info->skip_zeroes_at_end;
1240 aux = (struct objdump_disasm_info *) info->application_data;
1244 sfile.buffer = xmalloc (sfile.alloc);
1248 octets_per_line = 4;
1250 octets_per_line = 16;
1252 /* Figure out how many characters to skip at the start of an
1253 address, to make the disassembly look nicer. We discard leading
1254 zeroes in chunks of 4, ensuring that there is always a leading
1256 skip_addr_chars = 0;
1257 if (! prefix_addresses)
1265 + bfd_section_size (section->owner, section) / opb));
1267 while (s[0] == '0' && s[1] == '0' && s[2] == '0' && s[3] == '0'
1270 skip_addr_chars += 4;
1275 info->insn_info_valid = 0;
1278 addr_offset = start_offset;
1279 while (addr_offset < stop_offset)
1283 bfd_boolean need_nl = FALSE;
1285 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1287 for (z = addr_offset * opb; z < stop_offset * opb; z++)
1290 if (! disassemble_zeroes
1291 && (info->insn_info_valid == 0
1292 || info->branch_delay_insns == 0)
1293 && (z - addr_offset * opb >= skip_zeroes
1294 || (z == stop_offset * opb &&
1295 z - addr_offset * opb < skip_zeroes_at_end)))
1299 /* If there are more nonzero octets to follow, we only skip
1300 zeroes in multiples of 4, to try to avoid running over
1301 the start of an instruction which happens to start with
1303 if (z != stop_offset * opb)
1304 z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1306 octets = z - addr_offset * opb;
1316 if (with_line_numbers || with_source_code)
1317 /* The line number tables will refer to unadjusted
1318 section VMAs, so we must undo any VMA modifications
1319 when calling show_line. */
1320 show_line (aux->abfd, section, addr_offset - adjust_section_vma);
1322 if (! prefix_addresses)
1326 bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
1327 for (s = buf + skip_addr_chars; *s == '0'; s++)
1331 printf ("%s:\t", buf + skip_addr_chars);
1335 aux->require_sec = TRUE;
1336 objdump_print_address (section->vma + addr_offset, info);
1337 aux->require_sec = FALSE;
1344 info->fprintf_func = (fprintf_ftype) objdump_sprintf;
1345 info->stream = (FILE *) &sfile;
1346 info->bytes_per_line = 0;
1347 info->bytes_per_chunk = 0;
1349 #ifdef DISASSEMBLER_NEEDS_RELOCS
1350 /* FIXME: This is wrong. It tests the number of octets
1351 in the last instruction, not the current one. */
1352 if (*relppp < relppend
1353 && (**relppp)->address >= rel_offset + addr_offset
1354 && ((**relppp)->address
1355 < rel_offset + addr_offset + octets / opb))
1356 info->flags = INSN_HAS_RELOC;
1361 octets = (*disassemble_fn) (section->vma + addr_offset, info);
1362 info->fprintf_func = (fprintf_ftype) fprintf;
1363 info->stream = stdout;
1364 if (info->bytes_per_line != 0)
1365 octets_per_line = info->bytes_per_line;
1369 printf ("%s\n", sfile.buffer);
1377 octets = octets_per_line;
1378 if (addr_offset + octets / opb > stop_offset)
1379 octets = (stop_offset - addr_offset) * opb;
1381 for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1383 if (ISPRINT (data[j]))
1384 buf[j - addr_offset * opb] = data[j];
1386 buf[j - addr_offset * opb] = '.';
1388 buf[j - addr_offset * opb] = '\0';
1391 if (prefix_addresses
1393 : show_raw_insn >= 0)
1397 /* If ! prefix_addresses and ! wide_output, we print
1398 octets_per_line octets per line. */
1400 if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1401 pb = octets_per_line;
1403 if (info->bytes_per_chunk)
1404 bpc = info->bytes_per_chunk;
1408 for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1412 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1414 for (k = bpc - 1; k >= 0; k--)
1415 printf ("%02x", (unsigned) data[j + k]);
1420 for (k = 0; k < bpc; k++)
1421 printf ("%02x", (unsigned) data[j + k]);
1426 for (; pb < octets_per_line; pb += bpc)
1430 for (k = 0; k < bpc; k++)
1435 /* Separate raw data from instruction by extra space. */
1445 printf ("%s", sfile.buffer);
1447 if (prefix_addresses
1449 : show_raw_insn >= 0)
1457 j = addr_offset * opb + pb;
1459 bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
1460 for (s = buf + skip_addr_chars; *s == '0'; s++)
1464 printf ("%s:\t", buf + skip_addr_chars);
1466 pb += octets_per_line;
1469 for (; j < addr_offset * opb + pb; j += bpc)
1473 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1475 for (k = bpc - 1; k >= 0; k--)
1476 printf ("%02x", (unsigned) data[j + k]);
1481 for (k = 0; k < bpc; k++)
1482 printf ("%02x", (unsigned) data[j + k]);
1495 while ((*relppp) < relppend
1496 && (**relppp)->address < rel_offset + addr_offset + octets / opb)
1498 if (dump_reloc_info || dump_dynamic_reloc_info)
1509 objdump_print_value (section->vma - rel_offset + q->address,
1512 printf (": %s\t", q->howto->name);
1514 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1515 printf ("*unknown*");
1518 const char *sym_name;
1520 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1521 if (sym_name != NULL && *sym_name != '\0')
1522 objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
1527 sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1528 sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1529 if (sym_name == NULL || *sym_name == '\0')
1530 sym_name = "*unknown*";
1531 printf ("%s", sym_name);
1538 objdump_print_value (q->addend, info, TRUE);
1550 addr_offset += octets / opb;
1553 free (sfile.buffer);
1557 disassemble_section (bfd *abfd, asection *section, void *info)
1559 struct disassemble_info * pinfo = (struct disassemble_info *) info;
1560 struct objdump_disasm_info * paux;
1561 unsigned int opb = pinfo->octets_per_byte;
1562 bfd_byte * data = NULL;
1563 bfd_size_type datasize = 0;
1564 arelent ** rel_pp = NULL;
1565 arelent ** rel_ppstart = NULL;
1566 arelent ** rel_ppend;
1567 unsigned long stop_offset;
1568 asymbol * sym = NULL;
1572 unsigned long addr_offset;
1574 /* Sections that do not contain machine
1575 code are not normally disassembled. */
1576 if (! disassemble_all
1578 && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
1579 != (SEC_CODE | SEC_HAS_CONTENTS)))
1582 if (! process_section_p (section))
1585 datasize = bfd_get_section_size (section);
1589 /* Decide which set of relocs to use. Load them if necessary. */
1590 paux = (struct objdump_disasm_info *) pinfo->application_data;
1591 if (paux->dynrelbuf)
1593 rel_pp = paux->dynrelbuf;
1594 rel_count = paux->dynrelcount;
1595 /* Dynamic reloc addresses are absolute, non-dynamic are section
1596 relative. REL_OFFSET specifies the reloc address corresponding
1597 to the start of this section. */
1598 rel_offset = section->vma;
1606 if ((section->flags & SEC_RELOC) != 0
1607 #ifndef DISASSEMBLER_NEEDS_RELOCS
1614 relsize = bfd_get_reloc_upper_bound (abfd, section);
1616 bfd_fatal (bfd_get_filename (abfd));
1620 rel_ppstart = rel_pp = xmalloc (relsize);
1621 rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
1623 bfd_fatal (bfd_get_filename (abfd));
1625 /* Sort the relocs by address. */
1626 qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
1631 rel_ppend = rel_pp + rel_count;
1633 data = xmalloc (datasize);
1635 bfd_get_section_contents (abfd, section, data, 0, datasize);
1637 paux->sec = section;
1638 pinfo->buffer = data;
1639 pinfo->buffer_vma = section->vma;
1640 pinfo->buffer_length = datasize;
1641 pinfo->section = section;
1643 if (start_address == (bfd_vma) -1
1644 || start_address < pinfo->buffer_vma)
1647 addr_offset = start_address - pinfo->buffer_vma;
1649 if (stop_address == (bfd_vma) -1)
1650 stop_offset = datasize / opb;
1653 if (stop_address < pinfo->buffer_vma)
1656 stop_offset = stop_address - pinfo->buffer_vma;
1657 if (stop_offset > pinfo->buffer_length / opb)
1658 stop_offset = pinfo->buffer_length / opb;
1661 /* Skip over the relocs belonging to addresses below the
1663 while (rel_pp < rel_ppend
1664 && (*rel_pp)->address < rel_offset + addr_offset)
1667 printf (_("Disassembly of section %s:\n"), section->name);
1669 /* Find the nearest symbol forwards from our current position. */
1670 paux->require_sec = TRUE;
1671 sym = find_symbol_for_address (section->vma + addr_offset, info, &place);
1672 paux->require_sec = FALSE;
1674 /* Disassemble a block of instructions up to the address associated with
1675 the symbol we have just found. Then print the symbol and find the
1676 next symbol on. Repeat until we have disassembled the entire section
1677 or we have reached the end of the address range we are interested in. */
1678 while (addr_offset < stop_offset)
1682 unsigned long nextstop_offset;
1685 addr = section->vma + addr_offset;
1687 if (sym != NULL && bfd_asymbol_value (sym) <= addr)
1692 (x < sorted_symcount
1693 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
1697 pinfo->symbols = sorted_syms + place;
1698 pinfo->num_symbols = x - place;
1702 pinfo->symbols = NULL;
1703 pinfo->num_symbols = 0;
1706 if (! prefix_addresses)
1708 pinfo->fprintf_func (pinfo->stream, "\n");
1709 objdump_print_addr_with_sym (abfd, section, sym, addr,
1711 pinfo->fprintf_func (pinfo->stream, ":\n");
1714 if (sym != NULL && bfd_asymbol_value (sym) > addr)
1716 else if (sym == NULL)
1720 #define is_valid_next_sym(SYM) \
1721 ((SYM)->section == section \
1722 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1723 && pinfo->symbol_is_valid (SYM, pinfo))
1725 /* Search forward for the next appropriate symbol in
1726 SECTION. Note that all the symbols are sorted
1727 together into one big array, and that some sections
1728 may have overlapping addresses. */
1729 while (place < sorted_symcount
1730 && ! is_valid_next_sym (sorted_syms [place]))
1733 if (place >= sorted_symcount)
1736 nextsym = sorted_syms[place];
1739 if (sym != NULL && bfd_asymbol_value (sym) > addr)
1740 nextstop_offset = bfd_asymbol_value (sym) - section->vma;
1741 else if (nextsym == NULL)
1742 nextstop_offset = stop_offset;
1744 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
1746 if (nextstop_offset > stop_offset)
1747 nextstop_offset = stop_offset;
1749 /* If a symbol is explicitly marked as being an object
1750 rather than a function, just dump the bytes without
1751 disassembling them. */
1754 || bfd_asymbol_value (sym) > addr
1755 || ((sym->flags & BSF_OBJECT) == 0
1756 && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1758 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1760 || (sym->flags & BSF_FUNCTION) != 0)
1765 disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
1766 addr_offset, nextstop_offset,
1767 rel_offset, &rel_pp, rel_ppend);
1769 addr_offset = nextstop_offset;
1775 if (rel_ppstart != NULL)
1779 /* Disassemble the contents of an object file. */
1782 disassemble_data (bfd *abfd)
1784 struct disassemble_info disasm_info;
1785 struct objdump_disasm_info aux;
1789 prev_functionname = NULL;
1792 /* We make a copy of syms to sort. We don't want to sort syms
1793 because that will screw up the relocs. */
1794 sorted_symcount = symcount ? symcount : dynsymcount;
1795 sorted_syms = xmalloc ((sorted_symcount + synthcount) * sizeof (asymbol *));
1796 memcpy (sorted_syms, symcount ? syms : dynsyms,
1797 sorted_symcount * sizeof (asymbol *));
1799 sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
1801 for (i = 0; i < synthcount; ++i)
1803 sorted_syms[sorted_symcount] = synthsyms + i;
1807 /* Sort the symbols into section and symbol order. */
1808 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
1810 init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
1812 disasm_info.application_data = (void *) &aux;
1814 aux.require_sec = FALSE;
1815 aux.dynrelbuf = NULL;
1816 aux.dynrelcount = 0;
1818 disasm_info.print_address_func = objdump_print_address;
1819 disasm_info.symbol_at_address_func = objdump_symbol_at_address;
1821 if (machine != NULL)
1823 const bfd_arch_info_type *info = bfd_scan_arch (machine);
1826 fatal (_("Can't use supplied machine %s"), machine);
1828 abfd->arch_info = info;
1831 if (endian != BFD_ENDIAN_UNKNOWN)
1833 struct bfd_target *xvec;
1835 xvec = xmalloc (sizeof (struct bfd_target));
1836 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
1837 xvec->byteorder = endian;
1841 /* Use libopcodes to locate a suitable disassembler. */
1842 aux.disassemble_fn = disassembler (abfd);
1843 if (!aux.disassemble_fn)
1845 non_fatal (_("Can't disassemble for architecture %s\n"),
1846 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
1851 disasm_info.flavour = bfd_get_flavour (abfd);
1852 disasm_info.arch = bfd_get_arch (abfd);
1853 disasm_info.mach = bfd_get_mach (abfd);
1854 disasm_info.disassembler_options = disassembler_options;
1855 disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
1856 disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
1857 disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
1859 if (bfd_big_endian (abfd))
1860 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
1861 else if (bfd_little_endian (abfd))
1862 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
1864 /* ??? Aborting here seems too drastic. We could default to big or little
1866 disasm_info.endian = BFD_ENDIAN_UNKNOWN;
1868 /* Allow the target to customize the info structure. */
1869 disassemble_init_for_target (& disasm_info);
1871 /* Pre-load the dynamic relocs if we are going
1872 to be dumping them along with the disassembly. */
1873 if (dump_dynamic_reloc_info)
1875 long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
1878 bfd_fatal (bfd_get_filename (abfd));
1882 aux.dynrelbuf = xmalloc (relsize);
1883 aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
1886 if (aux.dynrelcount < 0)
1887 bfd_fatal (bfd_get_filename (abfd));
1889 /* Sort the relocs by address. */
1890 qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
1895 bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
1897 if (aux.dynrelbuf != NULL)
1898 free (aux.dynrelbuf);
1902 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
1903 it. Return NULL on failure. */
1906 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
1912 stabsect = bfd_get_section_by_name (abfd, sect_name);
1913 if (stabsect == NULL)
1915 printf (_("No %s section present\n\n"), sect_name);
1919 size = bfd_section_size (abfd, stabsect);
1920 contents = xmalloc (size);
1922 if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
1924 non_fatal (_("Reading %s section of %s failed: %s"),
1925 sect_name, bfd_get_filename (abfd),
1926 bfd_errmsg (bfd_get_error ()));
1937 /* Stabs entries use a 12 byte format:
1938 4 byte string table index
1940 1 byte stab other field
1941 2 byte stab desc field
1943 FIXME: This will have to change for a 64 bit object format. */
1945 #define STRDXOFF (0)
1947 #define OTHEROFF (5)
1950 #define STABSIZE (12)
1952 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1953 using string table section STRSECT_NAME (in `strtab'). */
1956 print_section_stabs (bfd *abfd,
1957 const char *stabsect_name,
1958 unsigned *string_offset_ptr)
1961 unsigned file_string_table_offset = 0;
1962 unsigned next_file_string_table_offset = *string_offset_ptr;
1963 bfd_byte *stabp, *stabs_end;
1966 stabs_end = stabp + stab_size;
1968 printf (_("Contents of %s section:\n\n"), stabsect_name);
1969 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1971 /* Loop through all symbols and print them.
1973 We start the index at -1 because there is a dummy symbol on
1974 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1975 for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
1979 unsigned char type, other;
1980 unsigned short desc;
1983 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
1984 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
1985 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
1986 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
1987 value = bfd_h_get_32 (abfd, stabp + VALOFF);
1989 printf ("\n%-6d ", i);
1990 /* Either print the stab name, or, if unnamed, print its number
1991 again (makes consistent formatting for tools like awk). */
1992 name = bfd_get_stab_name (type);
1994 printf ("%-6s", name);
1995 else if (type == N_UNDF)
1998 printf ("%-6d", type);
1999 printf (" %-6d %-6d ", other, desc);
2000 bfd_printf_vma (abfd, value);
2001 printf (" %-6lu", strx);
2003 /* Symbols with type == 0 (N_UNDF) specify the length of the
2004 string table associated with this file. We use that info
2005 to know how to relocate the *next* file's string table indices. */
2008 file_string_table_offset = next_file_string_table_offset;
2009 next_file_string_table_offset += value;
2013 /* Using the (possibly updated) string table offset, print the
2014 string (if any) associated with this symbol. */
2015 if ((strx + file_string_table_offset) < stabstr_size)
2016 printf (" %s", &strtab[strx + file_string_table_offset]);
2022 *string_offset_ptr = next_file_string_table_offset;
2027 const char * section_name;
2028 const char * string_section_name;
2029 unsigned string_offset;
2034 find_stabs_section (bfd *abfd, asection *section, void *names)
2037 stab_section_names * sought = (stab_section_names *) names;
2039 /* Check for section names for which stabsect_name is a prefix, to
2040 handle .stab.N, etc. */
2041 len = strlen (sought->section_name);
2043 /* If the prefix matches, and the files section name ends with a
2044 nul or a digit, then we match. I.e., we want either an exact
2045 match or a section followed by a number. */
2046 if (strncmp (sought->section_name, section->name, len) == 0
2047 && (section->name[len] == 0
2048 || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2051 strtab = read_section_stabs (abfd, sought->string_section_name,
2056 stabs = read_section_stabs (abfd, section->name, &stab_size);
2058 print_section_stabs (abfd, section->name, &sought->string_offset);
2064 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2066 stab_section_names s;
2068 s.section_name = stabsect_name;
2069 s.string_section_name = strsect_name;
2070 s.string_offset = 0;
2072 bfd_map_over_sections (abfd, find_stabs_section, & s);
2078 /* Dump the any sections containing stabs debugging information. */
2081 dump_stabs (bfd *abfd)
2083 dump_stabs_section (abfd, ".stab", ".stabstr");
2084 dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2085 dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2086 dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2090 dump_bfd_header (bfd *abfd)
2094 printf (_("architecture: %s, "),
2095 bfd_printable_arch_mach (bfd_get_arch (abfd),
2096 bfd_get_mach (abfd)));
2097 printf (_("flags 0x%08x:\n"), abfd->flags);
2099 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2100 PF (HAS_RELOC, "HAS_RELOC");
2101 PF (EXEC_P, "EXEC_P");
2102 PF (HAS_LINENO, "HAS_LINENO");
2103 PF (HAS_DEBUG, "HAS_DEBUG");
2104 PF (HAS_SYMS, "HAS_SYMS");
2105 PF (HAS_LOCALS, "HAS_LOCALS");
2106 PF (DYNAMIC, "DYNAMIC");
2107 PF (WP_TEXT, "WP_TEXT");
2108 PF (D_PAGED, "D_PAGED");
2109 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2110 PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
2111 printf (_("\nstart address 0x"));
2112 bfd_printf_vma (abfd, abfd->start_address);
2118 dump_bfd_private_header (bfd *abfd)
2120 bfd_print_private_bfd_data (abfd, stdout);
2124 /* Display a section in hexadecimal format with associated characters.
2125 Each line prefixed by the zero padded address. */
2128 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2131 bfd_size_type datasize;
2132 bfd_size_type addr_offset;
2133 bfd_size_type start_offset;
2134 bfd_size_type stop_offset;
2135 unsigned int opb = bfd_octets_per_byte (abfd);
2136 /* Bytes per line. */
2137 const int onaline = 16;
2142 if ((section->flags & SEC_HAS_CONTENTS) == 0)
2145 if (! process_section_p (section))
2148 if ((datasize = bfd_section_size (abfd, section)) == 0)
2151 printf (_("Contents of section %s:\n"), section->name);
2153 data = xmalloc (datasize);
2155 bfd_get_section_contents (abfd, section, data, 0, datasize);
2157 /* Compute the address range to display. */
2158 if (start_address == (bfd_vma) -1
2159 || start_address < section->vma)
2162 start_offset = start_address - section->vma;
2164 if (stop_address == (bfd_vma) -1)
2165 stop_offset = datasize / opb;
2168 if (stop_address < section->vma)
2171 stop_offset = stop_address - section->vma;
2173 if (stop_offset > datasize / opb)
2174 stop_offset = datasize / opb;
2179 bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2180 if (strlen (buf) >= sizeof (buf))
2184 while (buf[count] == '0' && buf[count+1] != '\0')
2186 count = strlen (buf) - count;
2190 bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2191 if (strlen (buf) >= sizeof (buf))
2195 while (buf[count] == '0' && buf[count+1] != '\0')
2197 count = strlen (buf) - count;
2201 for (addr_offset = start_offset;
2202 addr_offset < stop_offset; addr_offset += onaline / opb)
2206 bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2207 count = strlen (buf);
2208 if ((size_t) count >= sizeof (buf))
2212 while (count < width)
2217 fputs (buf + count - width, stdout);
2220 for (j = addr_offset * opb;
2221 j < addr_offset * opb + onaline; j++)
2223 if (j < stop_offset * opb)
2224 printf ("%02x", (unsigned) (data[j]));
2232 for (j = addr_offset * opb;
2233 j < addr_offset * opb + onaline; j++)
2235 if (j >= stop_offset * opb)
2238 printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2245 /* Actually display the various requested regions. */
2248 dump_data (bfd *abfd)
2250 bfd_map_over_sections (abfd, dump_section, NULL);
2253 /* Should perhaps share code and display with nm? */
2256 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2266 printf ("DYNAMIC SYMBOL TABLE:\n");
2272 printf ("SYMBOL TABLE:\n");
2276 printf (_("no symbols\n"));
2278 for (count = 0; count < max; count++)
2282 if (*current == NULL)
2283 printf (_("no information for symbol number %ld\n"), count);
2285 else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2286 printf (_("could not determine the type of symbol number %ld\n"),
2289 else if (dump_special_syms
2290 || !bfd_is_target_special_symbol (cur_bfd, *current))
2292 const char *name = (*current)->name;
2294 if (do_demangle && name != NULL && *name != '\0')
2298 /* If we want to demangle the name, we demangle it
2299 here, and temporarily clobber it while calling
2300 bfd_print_symbol. FIXME: This is a gross hack. */
2301 alloc = demangle (cur_bfd, name);
2302 (*current)->name = alloc;
2303 bfd_print_symbol (cur_bfd, stdout, *current,
2304 bfd_print_symbol_all);
2305 (*current)->name = name;
2309 bfd_print_symbol (cur_bfd, stdout, *current,
2310 bfd_print_symbol_all);
2319 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2322 char *last_filename, *last_functionname;
2323 unsigned int last_line;
2325 /* Get column headers lined up reasonably. */
2333 bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2334 width = strlen (buf) - 7;
2336 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2339 last_filename = NULL;
2340 last_functionname = NULL;
2343 for (p = relpp; relcount && *p != NULL; p++, relcount--)
2346 const char *filename, *functionname;
2348 const char *sym_name;
2349 const char *section_name;
2351 if (start_address != (bfd_vma) -1
2352 && q->address < start_address)
2354 if (stop_address != (bfd_vma) -1
2355 && q->address > stop_address)
2358 if (with_line_numbers
2360 && bfd_find_nearest_line (abfd, sec, syms, q->address,
2361 &filename, &functionname, &line))
2363 if (functionname != NULL
2364 && (last_functionname == NULL
2365 || strcmp (functionname, last_functionname) != 0))
2367 printf ("%s():\n", functionname);
2368 if (last_functionname != NULL)
2369 free (last_functionname);
2370 last_functionname = xstrdup (functionname);
2374 && (line != last_line
2375 || (filename != NULL
2376 && last_filename != NULL
2377 && strcmp (filename, last_filename) != 0)))
2379 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2381 if (last_filename != NULL)
2382 free (last_filename);
2383 if (filename == NULL)
2384 last_filename = NULL;
2386 last_filename = xstrdup (filename);
2390 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2392 sym_name = (*(q->sym_ptr_ptr))->name;
2393 section_name = (*(q->sym_ptr_ptr))->section->name;
2398 section_name = NULL;
2403 bfd_printf_vma (abfd, q->address);
2405 printf (" %-16s ", q->howto->name);
2407 printf (" %-16d ", q->howto->type);
2408 objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
2412 if (section_name == NULL)
2413 section_name = "*unknown*";
2414 bfd_printf_vma (abfd, q->address);
2415 printf (" %-16s [%s]",
2423 bfd_printf_vma (abfd, q->addend);
2431 dump_relocs_in_section (bfd *abfd,
2433 void *dummy ATTRIBUTE_UNUSED)
2439 if ( bfd_is_abs_section (section)
2440 || bfd_is_und_section (section)
2441 || bfd_is_com_section (section)
2442 || (! process_section_p (section))
2443 || ((section->flags & SEC_RELOC) == 0))
2446 relsize = bfd_get_reloc_upper_bound (abfd, section);
2448 bfd_fatal (bfd_get_filename (abfd));
2450 printf ("RELOCATION RECORDS FOR [%s]:", section->name);
2454 printf (" (none)\n\n");
2458 relpp = xmalloc (relsize);
2459 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
2462 bfd_fatal (bfd_get_filename (abfd));
2463 else if (relcount == 0)
2464 printf (" (none)\n\n");
2468 dump_reloc_set (abfd, section, relpp, relcount);
2475 dump_relocs (bfd *abfd)
2477 bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
2481 dump_dynamic_relocs (bfd *abfd)
2487 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2489 bfd_fatal (bfd_get_filename (abfd));
2491 printf ("DYNAMIC RELOCATION RECORDS");
2494 printf (" (none)\n\n");
2497 relpp = xmalloc (relsize);
2498 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2501 bfd_fatal (bfd_get_filename (abfd));
2502 else if (relcount == 0)
2503 printf (" (none)\n\n");
2507 dump_reloc_set (abfd, NULL, relpp, relcount);
2514 /* Creates a table of paths, to search for source files. */
2517 add_include_path (const char *path)
2521 include_path_count++;
2522 include_paths = xrealloc (include_paths,
2523 include_path_count * sizeof (*include_paths));
2524 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2525 if (path[1] == ':' && path[2] == 0)
2526 path = concat (path, ".", (const char *) 0);
2528 include_paths[include_path_count - 1] = path;
2532 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
2534 void *dummy ATTRIBUTE_UNUSED)
2536 section->vma += adjust_section_vma;
2537 section->lma += adjust_section_vma;
2540 /* Dump selected contents of ABFD. */
2543 dump_bfd (bfd *abfd)
2545 /* If we are adjusting section VMA's, change them all now. Changing
2546 the BFD information is a hack. However, we must do it, or
2547 bfd_find_nearest_line will not do the right thing. */
2548 if (adjust_section_vma != 0)
2549 bfd_map_over_sections (abfd, adjust_addresses, NULL);
2551 if (! dump_debugging_tags)
2552 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
2555 print_arelt_descr (stdout, abfd, TRUE);
2556 if (dump_file_header)
2557 dump_bfd_header (abfd);
2558 if (dump_private_headers)
2559 dump_bfd_private_header (abfd);
2560 if (! dump_debugging_tags)
2562 if (dump_section_headers)
2563 dump_headers (abfd);
2565 if (dump_symtab || dump_reloc_info || disassemble || dump_debugging)
2566 syms = slurp_symtab (abfd);
2567 if (dump_dynamic_symtab || dump_dynamic_reloc_info
2568 || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
2569 dynsyms = slurp_dynamic_symtab (abfd);
2572 synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
2573 dynsymcount, dynsyms, &synthsyms);
2579 dump_symbols (abfd, FALSE);
2580 if (dump_dynamic_symtab)
2581 dump_symbols (abfd, TRUE);
2582 if (dump_stab_section_info)
2584 if (dump_reloc_info && ! disassemble)
2586 if (dump_dynamic_reloc_info && ! disassemble)
2587 dump_dynamic_relocs (abfd);
2588 if (dump_section_contents)
2591 disassemble_data (abfd);
2597 dhandle = read_debugging_info (abfd, syms, symcount);
2598 if (dhandle != NULL)
2600 if (! print_debugging_info (stdout, dhandle, abfd, syms, demangle,
2601 dump_debugging_tags ? TRUE : FALSE))
2603 non_fatal (_("%s: printing debugging information failed"),
2604 bfd_get_filename (abfd));
2634 display_bfd (bfd *abfd)
2638 if (bfd_check_format_matches (abfd, bfd_object, &matching))
2644 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2646 nonfatal (bfd_get_filename (abfd));
2647 list_matching_formats (matching);
2652 if (bfd_get_error () != bfd_error_file_not_recognized)
2654 nonfatal (bfd_get_filename (abfd));
2658 if (bfd_check_format_matches (abfd, bfd_core, &matching))
2664 nonfatal (bfd_get_filename (abfd));
2666 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2668 list_matching_formats (matching);
2674 display_file (char *filename, char *target)
2679 if (get_file_size (filename) < 1)
2682 file = bfd_openr (filename, target);
2685 nonfatal (filename);
2689 /* If the file is an archive, process all of its elements. */
2690 if (bfd_check_format (file, bfd_archive))
2692 bfd *last_arfile = NULL;
2694 printf (_("In archive %s:\n"), bfd_get_filename (file));
2697 bfd_set_error (bfd_error_no_error);
2699 arfile = bfd_openr_next_archived_file (file, arfile);
2702 if (bfd_get_error () != bfd_error_no_more_archived_files)
2703 nonfatal (bfd_get_filename (file));
2707 display_bfd (arfile);
2709 if (last_arfile != NULL)
2710 bfd_close (last_arfile);
2711 last_arfile = arfile;
2714 if (last_arfile != NULL)
2715 bfd_close (last_arfile);
2724 main (int argc, char **argv)
2727 char *target = default_target;
2728 bfd_boolean seenflag = FALSE;
2730 #if defined (HAVE_SETLOCALE)
2731 #if defined (HAVE_LC_MESSAGES)
2732 setlocale (LC_MESSAGES, "");
2734 setlocale (LC_CTYPE, "");
2737 bindtextdomain (PACKAGE, LOCALEDIR);
2738 textdomain (PACKAGE);
2740 program_name = *argv;
2741 xmalloc_set_program_name (program_name);
2743 START_PROGRESS (program_name, 0);
2746 set_default_bfd_target ();
2748 while ((c = getopt_long (argc, argv, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeG",
2749 long_options, (int *) 0))
2755 break; /* We've been given a long option. */
2760 if (disassembler_options)
2761 /* Ignore potential memory leak for now. */
2762 disassembler_options = concat (disassembler_options, ",",
2765 disassembler_options = optarg;
2768 if (only_used == only_size)
2771 only = xrealloc (only, only_size * sizeof (char *));
2773 only [only_used++] = optarg;
2776 with_line_numbers = TRUE;
2785 enum demangling_styles style;
2787 style = cplus_demangle_name_to_style (optarg);
2788 if (style == unknown_demangling)
2789 fatal (_("unknown demangling style `%s'"),
2792 cplus_demangle_set_style (style);
2798 case OPTION_ADJUST_VMA:
2799 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
2801 case OPTION_START_ADDRESS:
2802 start_address = parse_vma (optarg, "--start-address");
2804 case OPTION_STOP_ADDRESS:
2805 stop_address = parse_vma (optarg, "--stop-address");
2808 if (strcmp (optarg, "B") == 0)
2809 endian = BFD_ENDIAN_BIG;
2810 else if (strcmp (optarg, "L") == 0)
2811 endian = BFD_ENDIAN_LITTLE;
2814 non_fatal (_("unrecognized -E option"));
2819 if (strncmp (optarg, "big", strlen (optarg)) == 0)
2820 endian = BFD_ENDIAN_BIG;
2821 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
2822 endian = BFD_ENDIAN_LITTLE;
2825 non_fatal (_("unrecognized --endian type `%s'"), optarg);
2831 dump_file_header = TRUE;
2835 formats_info = TRUE;
2839 add_include_path (optarg);
2842 dump_private_headers = TRUE;
2846 dump_private_headers = TRUE;
2848 dump_reloc_info = TRUE;
2849 dump_file_header = TRUE;
2850 dump_ar_hdrs = TRUE;
2851 dump_section_headers = TRUE;
2859 dump_dynamic_symtab = TRUE;
2867 disassemble_zeroes = TRUE;
2871 disassemble_all = TRUE;
2876 with_source_code = TRUE;
2885 dump_debugging_tags = 1;
2890 dump_stab_section_info = TRUE;
2894 dump_section_contents = TRUE;
2898 dump_reloc_info = TRUE;
2902 dump_dynamic_reloc_info = TRUE;
2906 dump_ar_hdrs = TRUE;
2910 dump_section_headers = TRUE;
2918 show_version = TRUE;
2928 print_version ("objdump");
2934 exit_status = display_info ();
2938 display_file ("a.out", target);
2940 for (; optind < argc;)
2941 display_file (argv[optind++], target);
2944 END_PROGRESS (program_name);