1 /* objdump.c -- dump information about an object file.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
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 disassmebly 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 command line. */
79 static int show_version = 0; /* Show the version number. */
80 static int dump_section_contents; /* -s */
81 static int dump_section_headers; /* -h */
82 static bfd_boolean dump_file_header; /* -f */
83 static int dump_symtab; /* -t */
84 static int dump_dynamic_symtab; /* -T */
85 static int dump_reloc_info; /* -r */
86 static int dump_dynamic_reloc_info; /* -R */
87 static int dump_ar_hdrs; /* -a */
88 static int dump_private_headers; /* -p */
89 static int prefix_addresses; /* --prefix-addresses */
90 static int with_line_numbers; /* -l */
91 static bfd_boolean with_source_code; /* -S */
92 static int show_raw_insn; /* --show-raw-insn */
93 static int dump_stab_section_info; /* --stabs */
94 static int do_demangle; /* -C, --demangle */
95 static bfd_boolean disassemble; /* -d */
96 static bfd_boolean disassemble_all; /* -D */
97 static int disassemble_zeroes; /* --disassemble-zeroes */
98 static bfd_boolean formats_info; /* -i */
99 static int wide_output; /* -w */
100 static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
101 static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */
102 static int dump_debugging; /* --debugging */
103 static int dump_debugging_tags; /* --debugging-tags */
104 static bfd_vma adjust_section_vma = 0; /* --adjust-vma */
105 static int file_start_context = 0; /* --file-start-context */
107 /* Pointer to an array of section names provided by
108 one or more "-j secname" command line options. */
110 /* The total number of slots in the only[] array. */
111 static size_t only_size = 0;
112 /* The number of occupied slots in the only[] array. */
113 static size_t only_used = 0;
115 /* Variables for handling include file path table. */
116 static const char **include_paths;
117 static int include_path_count;
119 /* Extra info to pass to the section disassembler and address printing function. */
120 struct objdump_disasm_info
124 bfd_boolean require_sec;
125 arelent ** dynrelbuf;
127 disassembler_ftype disassemble_fn;
130 /* Architecture to disassemble for, or default if NULL. */
131 static char *machine = NULL;
133 /* Target specific options to the disassembler. */
134 static char *disassembler_options = NULL;
136 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
137 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
139 /* The symbol table. */
140 static asymbol **syms;
142 /* Number of symbols in `syms'. */
143 static long symcount = 0;
145 /* The sorted symbol table. */
146 static asymbol **sorted_syms;
148 /* Number of symbols in `sorted_syms'. */
149 static long sorted_symcount = 0;
151 /* The dynamic symbol table. */
152 static asymbol **dynsyms;
154 /* Number of symbols in `dynsyms'. */
155 static long dynsymcount = 0;
157 static bfd_byte *stabs;
158 static bfd_size_type stab_size;
161 static bfd_size_type stabstr_size;
164 usage (FILE *stream, int status)
166 fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
167 fprintf (stream, _(" Display information from object <file(s)>.\n"));
168 fprintf (stream, _(" At least one of the following switches must be given:\n"));
169 fprintf (stream, _("\
170 -a, --archive-headers Display archive header information\n\
171 -f, --file-headers Display the contents of the overall file header\n\
172 -p, --private-headers Display object format specific file header contents\n\
173 -h, --[section-]headers Display the contents of the section headers\n\
174 -x, --all-headers Display the contents of all headers\n\
175 -d, --disassemble Display assembler contents of executable sections\n\
176 -D, --disassemble-all Display assembler contents of all sections\n\
177 -S, --source Intermix source code with disassembly\n\
178 -s, --full-contents Display the full contents of all sections requested\n\
179 -g, --debugging Display debug information in object file\n\
180 -e, --debugging-tags Display debug information using ctags style\n\
181 -G, --stabs Display (in raw form) any STABS info in the file\n\
182 -t, --syms Display the contents of the symbol table(s)\n\
183 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
184 -r, --reloc Display the relocation entries in the file\n\
185 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
186 -v, --version Display this program's version number\n\
187 -i, --info List object formats and architectures supported\n\
188 -H, --help Display this information\n\
192 fprintf (stream, _("\n The following switches are optional:\n"));
193 fprintf (stream, _("\
194 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
195 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
196 -j, --section=NAME Only display information for section NAME\n\
197 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
198 -EB --endian=big Assume big endian format when disassembling\n\
199 -EL --endian=little Assume little endian format when disassembling\n\
200 --file-start-context Include context from start of file (with -S)\n\
201 -I, --include=DIR Add DIR to search list for source files\n\
202 -l, --line-numbers Include line numbers and filenames in output\n\
203 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
204 The STYLE, if specified, can be `auto', `gnu',\n\
205 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
207 -w, --wide Format output for more than 80 columns\n\
208 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
209 --start-address=ADDR Only process data whose address is >= ADDR\n\
210 --stop-address=ADDR Only process data whose address is <= ADDR\n\
211 --prefix-addresses Print complete address alongside disassembly\n\
212 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
213 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
215 list_supported_targets (program_name, stream);
216 list_supported_architectures (program_name, stream);
218 disassembler_usage (stream);
221 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
225 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
229 OPTION_START_ADDRESS,
234 static struct option long_options[]=
236 {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
237 {"all-headers", no_argument, NULL, 'x'},
238 {"private-headers", no_argument, NULL, 'p'},
239 {"architecture", required_argument, NULL, 'm'},
240 {"archive-headers", no_argument, NULL, 'a'},
241 {"debugging", no_argument, NULL, 'g'},
242 {"debugging-tags", no_argument, NULL, 'e'},
243 {"demangle", optional_argument, NULL, 'C'},
244 {"disassemble", no_argument, NULL, 'd'},
245 {"disassemble-all", no_argument, NULL, 'D'},
246 {"disassembler-options", required_argument, NULL, 'M'},
247 {"disassemble-zeroes", no_argument, NULL, 'z'},
248 {"dynamic-reloc", no_argument, NULL, 'R'},
249 {"dynamic-syms", no_argument, NULL, 'T'},
250 {"endian", required_argument, NULL, OPTION_ENDIAN},
251 {"file-headers", no_argument, NULL, 'f'},
252 {"file-start-context", no_argument, &file_start_context, 1},
253 {"full-contents", no_argument, NULL, 's'},
254 {"headers", no_argument, NULL, 'h'},
255 {"help", no_argument, NULL, 'H'},
256 {"info", no_argument, NULL, 'i'},
257 {"line-numbers", no_argument, NULL, 'l'},
258 {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
259 {"prefix-addresses", no_argument, &prefix_addresses, 1},
260 {"reloc", no_argument, NULL, 'r'},
261 {"section", required_argument, NULL, 'j'},
262 {"section-headers", no_argument, NULL, 'h'},
263 {"show-raw-insn", no_argument, &show_raw_insn, 1},
264 {"source", no_argument, NULL, 'S'},
265 {"include", required_argument, NULL, 'I'},
266 {"stabs", no_argument, NULL, 'G'},
267 {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
268 {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
269 {"syms", no_argument, NULL, 't'},
270 {"target", required_argument, NULL, 'b'},
271 {"version", no_argument, NULL, 'V'},
272 {"wide", no_argument, NULL, 'w'},
273 {0, no_argument, 0, 0}
277 nonfatal (const char *msg)
284 dump_section_header (bfd *abfd ATTRIBUTE_UNUSED, asection *section,
285 void *ignored ATTRIBUTE_UNUSED)
288 unsigned int opb = bfd_octets_per_byte (abfd);
290 printf ("%3d %-13s %08lx ", section->index,
291 bfd_get_section_name (abfd, section),
292 (unsigned long) bfd_section_size (abfd, section) / opb);
293 bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
295 bfd_printf_vma (abfd, section->lma);
296 printf (" %08lx 2**%u", (unsigned long) section->filepos,
297 bfd_get_section_alignment (abfd, section));
303 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
305 PF (SEC_HAS_CONTENTS, "CONTENTS");
306 PF (SEC_ALLOC, "ALLOC");
307 PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
308 PF (SEC_LOAD, "LOAD");
309 PF (SEC_RELOC, "RELOC");
310 PF (SEC_READONLY, "READONLY");
311 PF (SEC_CODE, "CODE");
312 PF (SEC_DATA, "DATA");
314 PF (SEC_DEBUGGING, "DEBUGGING");
315 PF (SEC_NEVER_LOAD, "NEVER_LOAD");
316 PF (SEC_EXCLUDE, "EXCLUDE");
317 PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
318 PF (SEC_BLOCK, "BLOCK");
319 PF (SEC_CLINK, "CLINK");
320 PF (SEC_SMALL_DATA, "SMALL_DATA");
321 PF (SEC_SHARED, "SHARED");
322 PF (SEC_ARCH_BIT_0, "ARCH_BIT_0");
323 PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
325 if ((section->flags & SEC_LINK_ONCE) != 0)
329 switch (section->flags & SEC_LINK_DUPLICATES)
333 case SEC_LINK_DUPLICATES_DISCARD:
334 ls = "LINK_ONCE_DISCARD";
336 case SEC_LINK_DUPLICATES_ONE_ONLY:
337 ls = "LINK_ONCE_ONE_ONLY";
339 case SEC_LINK_DUPLICATES_SAME_SIZE:
340 ls = "LINK_ONCE_SAME_SIZE";
342 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
343 ls = "LINK_ONCE_SAME_CONTENTS";
346 printf ("%s%s", comma, ls);
348 if (section->comdat != NULL)
349 printf (" (COMDAT %s %ld)", section->comdat->name,
350 section->comdat->symbol);
360 dump_headers (bfd *abfd)
362 printf (_("Sections:\n"));
365 printf (_("Idx Name Size VMA LMA File off Algn"));
367 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
368 if (bfd_get_arch_size (abfd) == 32)
369 printf (_("Idx Name Size VMA LMA File off Algn"));
371 printf (_("Idx Name Size VMA LMA File off Algn"));
375 printf (_(" Flags"));
376 if (abfd->flags & HAS_LOAD_PAGE)
380 bfd_map_over_sections (abfd, dump_section_header, NULL);
384 slurp_symtab (bfd *abfd)
389 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
395 storage = bfd_get_symtab_upper_bound (abfd);
397 bfd_fatal (bfd_get_filename (abfd));
399 sy = xmalloc (storage);
401 symcount = bfd_canonicalize_symtab (abfd, sy);
403 bfd_fatal (bfd_get_filename (abfd));
407 /* Read in the dynamic symbols. */
410 slurp_dynamic_symtab (bfd *abfd)
415 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
418 if (!(bfd_get_file_flags (abfd) & DYNAMIC))
420 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
425 bfd_fatal (bfd_get_filename (abfd));
428 sy = xmalloc (storage);
430 dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
432 bfd_fatal (bfd_get_filename (abfd));
436 /* Filter out (in place) symbols that are useless for disassembly.
437 COUNT is the number of elements in SYMBOLS.
438 Return the number of useful symbols. */
441 remove_useless_symbols (asymbol **symbols, long count)
443 asymbol **in_ptr = symbols, **out_ptr = symbols;
447 asymbol *sym = *in_ptr++;
449 if (sym->name == NULL || sym->name[0] == '\0')
451 if (sym->flags & (BSF_DEBUGGING))
453 if (bfd_is_und_section (sym->section)
454 || bfd_is_com_section (sym->section))
459 return out_ptr - symbols;
462 /* Sort symbols into value order. */
465 compare_symbols (const void *ap, const void *bp)
467 const asymbol *a = * (const asymbol **) ap;
468 const asymbol *b = * (const asymbol **) bp;
478 if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
480 else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
483 if (a->section > b->section)
485 else if (a->section < b->section)
488 an = bfd_asymbol_name (a);
489 bn = bfd_asymbol_name (b);
493 /* The symbols gnu_compiled and gcc2_compiled convey no real
494 information, so put them after other symbols with the same value. */
495 af = (strstr (an, "gnu_compiled") != NULL
496 || strstr (an, "gcc2_compiled") != NULL);
497 bf = (strstr (bn, "gnu_compiled") != NULL
498 || strstr (bn, "gcc2_compiled") != NULL);
505 /* We use a heuristic for the file name, to try to sort it after
506 more useful symbols. It may not work on non Unix systems, but it
507 doesn't really matter; the only difference is precisely which
508 symbol names get printed. */
510 #define file_symbol(s, sn, snl) \
511 (((s)->flags & BSF_FILE) != 0 \
512 || ((sn)[(snl) - 2] == '.' \
513 && ((sn)[(snl) - 1] == 'o' \
514 || (sn)[(snl) - 1] == 'a')))
516 af = file_symbol (a, an, anl);
517 bf = file_symbol (b, bn, bnl);
524 /* Try to sort global symbols before local symbols before function
525 symbols before debugging symbols. */
530 if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
532 if ((aflags & BSF_DEBUGGING) != 0)
537 if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
539 if ((aflags & BSF_FUNCTION) != 0)
544 if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
546 if ((aflags & BSF_LOCAL) != 0)
551 if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
553 if ((aflags & BSF_GLOBAL) != 0)
559 /* Symbols that start with '.' might be section names, so sort them
560 after symbols that don't start with '.'. */
561 if (an[0] == '.' && bn[0] != '.')
563 if (an[0] != '.' && bn[0] == '.')
566 /* Finally, if we can't distinguish them in any other way, try to
567 get consistent results by sorting the symbols by name. */
568 return strcmp (an, bn);
571 /* Sort relocs into address order. */
574 compare_relocs (const void *ap, const void *bp)
576 const arelent *a = * (const arelent **) ap;
577 const arelent *b = * (const arelent **) bp;
579 if (a->address > b->address)
581 else if (a->address < b->address)
584 /* So that associated relocations tied to the same address show up
585 in the correct order, we don't do any further sorting. */
594 /* Print an address (VMA) to the output stream in INFO.
595 If SKIP_ZEROES is TRUE, omit leading zeroes. */
598 objdump_print_value (bfd_vma vma, struct disassemble_info *info,
599 bfd_boolean skip_zeroes)
603 struct objdump_disasm_info *aux
604 = (struct objdump_disasm_info *) info->application_data;
606 bfd_sprintf_vma (aux->abfd, buf, vma);
611 for (p = buf; *p == '0'; ++p)
616 (*info->fprintf_func) (info->stream, "%s", p);
619 /* Print the name of a symbol. */
622 objdump_print_symname (bfd *abfd, struct disassemble_info *info,
629 name = bfd_asymbol_name (sym);
630 if (do_demangle && name[0] != '\0')
632 /* Demangle the name. */
633 alloc = demangle (abfd, name);
638 (*info->fprintf_func) (info->stream, "%s", name);
646 /* Locate a symbol given a bfd, a section, and a VMA. If REQUIRE_SEC
647 is TRUE, then always require the symbol to be in the section. This
648 returns NULL if there is no suitable symbol. If PLACE is not NULL,
649 then *PLACE is set to the index of the symbol in sorted_syms. */
652 find_symbol_for_address (bfd *abfd, asection *sec, bfd_vma vma,
653 bfd_boolean require_sec, long *place)
655 /* @@ Would it speed things up to cache the last two symbols returned,
656 and maybe their address ranges? For many processors, only one memory
657 operand can be present at a time, so the 2-entry cache wouldn't be
658 constantly churned by code doing heavy memory accesses. */
660 /* Indices in `sorted_syms'. */
662 long max = sorted_symcount;
664 unsigned int opb = bfd_octets_per_byte (abfd);
666 if (sorted_symcount < 1)
669 /* Perform a binary search looking for the closest symbol to the
670 required value. We are searching the range (min, max]. */
671 while (min + 1 < max)
675 thisplace = (max + min) / 2;
676 sym = sorted_syms[thisplace];
678 if (bfd_asymbol_value (sym) > vma)
680 else if (bfd_asymbol_value (sym) < vma)
689 /* The symbol we want is now in min, the low end of the range we
690 were searching. If there are several symbols with the same
691 value, we want the first one. */
694 && (bfd_asymbol_value (sorted_syms[thisplace])
695 == bfd_asymbol_value (sorted_syms[thisplace - 1])))
698 /* If the file is relocatable, and the symbol could be from this
699 section, prefer a symbol from this section over symbols from
700 others, even if the other symbol's value might be closer.
702 Note that this may be wrong for some symbol references if the
703 sections have overlapping memory ranges, but in that case there's
704 no way to tell what's desired without looking at the relocation
706 if (sorted_syms[thisplace]->section != sec
708 || ((abfd->flags & HAS_RELOC) != 0
709 && vma >= bfd_get_section_vma (abfd, sec)
710 && vma < (bfd_get_section_vma (abfd, sec)
711 + bfd_section_size (abfd, sec) / opb))))
715 for (i = thisplace + 1; i < sorted_symcount; i++)
717 if (bfd_asymbol_value (sorted_syms[i])
718 != bfd_asymbol_value (sorted_syms[thisplace]))
726 if (sorted_syms[i]->section == sec
728 || sorted_syms[i - 1]->section != sec
729 || (bfd_asymbol_value (sorted_syms[i])
730 != bfd_asymbol_value (sorted_syms[i - 1]))))
737 if (sorted_syms[thisplace]->section != sec)
739 /* We didn't find a good symbol with a smaller value.
740 Look for one with a larger value. */
741 for (i = thisplace + 1; i < sorted_symcount; i++)
743 if (sorted_syms[i]->section == sec)
751 if (sorted_syms[thisplace]->section != sec
753 || ((abfd->flags & HAS_RELOC) != 0
754 && vma >= bfd_get_section_vma (abfd, sec)
755 && vma < (bfd_get_section_vma (abfd, sec)
756 + bfd_section_size (abfd, sec)))))
758 /* There is no suitable symbol. */
766 return sorted_syms[thisplace];
769 /* Print an address and the offset to the nearest symbol. */
772 objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
773 bfd_vma vma, struct disassemble_info *info,
774 bfd_boolean skip_zeroes)
776 objdump_print_value (vma, info, skip_zeroes);
782 (*info->fprintf_func) (info->stream, " <%s",
783 bfd_get_section_name (abfd, sec));
784 secaddr = bfd_get_section_vma (abfd, sec);
787 (*info->fprintf_func) (info->stream, "-0x");
788 objdump_print_value (secaddr - vma, info, TRUE);
790 else if (vma > secaddr)
792 (*info->fprintf_func) (info->stream, "+0x");
793 objdump_print_value (vma - secaddr, info, TRUE);
795 (*info->fprintf_func) (info->stream, ">");
799 (*info->fprintf_func) (info->stream, " <");
800 objdump_print_symname (abfd, info, sym);
801 if (bfd_asymbol_value (sym) > vma)
803 (*info->fprintf_func) (info->stream, "-0x");
804 objdump_print_value (bfd_asymbol_value (sym) - vma, info, TRUE);
806 else if (vma > bfd_asymbol_value (sym))
808 (*info->fprintf_func) (info->stream, "+0x");
809 objdump_print_value (vma - bfd_asymbol_value (sym), info, TRUE);
811 (*info->fprintf_func) (info->stream, ">");
815 /* Print an address (VMA), symbolically if possible.
816 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
819 objdump_print_addr (bfd_vma vma, struct disassemble_info *info,
820 bfd_boolean skip_zeroes)
822 struct objdump_disasm_info *aux;
825 if (sorted_symcount < 1)
827 (*info->fprintf_func) (info->stream, "0x");
828 objdump_print_value (vma, info, skip_zeroes);
832 aux = (struct objdump_disasm_info *) info->application_data;
833 sym = find_symbol_for_address (aux->abfd, aux->sec, vma, aux->require_sec,
835 objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, info,
839 /* Print VMA to INFO. This function is passed to the disassembler
843 objdump_print_address (bfd_vma vma, struct disassemble_info *info)
845 objdump_print_addr (vma, info, ! prefix_addresses);
848 /* Determine of the given address has a symbol associated with it. */
851 objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * info)
853 struct objdump_disasm_info * aux;
856 /* No symbols - do not bother checking. */
857 if (sorted_symcount < 1)
860 aux = (struct objdump_disasm_info *) info->application_data;
861 sym = find_symbol_for_address (aux->abfd, aux->sec, vma, aux->require_sec,
864 return (sym != NULL && (bfd_asymbol_value (sym) == vma));
867 /* Hold the last function name and the last line number we displayed
870 static char *prev_functionname;
871 static unsigned int prev_line;
873 /* We keep a list of all files that we have seen when doing a
874 disassembly with source, so that we know how much of the file to
875 display. This can be important for inlined functions. */
877 struct print_file_list
879 struct print_file_list *next;
880 const char *filename;
886 static struct print_file_list *print_files;
888 /* The number of preceding context lines to show when we start
889 displaying a file for the first time. */
891 #define SHOW_PRECEDING_CONTEXT_LINES (5)
893 /* Tries to open MODNAME, and if successful adds a node to print_files
894 linked list and returns that node. Returns NULL on failure. */
896 static struct print_file_list *
897 try_print_file_open (const char *origname, const char *modname)
899 struct print_file_list *p;
902 f = fopen (modname, "r");
906 if (print_files != NULL && print_files->f != NULL)
908 fclose (print_files->f);
909 print_files->f = NULL;
912 p = xmalloc (sizeof (struct print_file_list));
913 p->filename = origname;
914 p->modname = modname;
917 p->next = print_files;
922 /* If the the source file, as described in the symtab, is not found
923 try to locate it in one of the paths specified with -I
924 If found, add location to print_files linked list. */
926 static struct print_file_list *
927 update_source_path (const char *filename)
929 struct print_file_list *p;
933 if (filename == NULL)
936 p = try_print_file_open (filename, filename);
940 if (include_path_count == 0)
943 /* Get the name of the file. */
944 fname = strrchr (filename, '/');
945 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
947 /* We could have a mixed forward/back slash case. */
948 char *backslash = strrchr (filename, '\\');
949 if (fname == NULL || (backslash != NULL && backslash > fname))
951 if (fname == NULL && filename[0] != '\0' && filename[1] == ':')
952 fname = filename + 1;
960 /* If file exists under a new path, we need to add it to the list
961 so that show_line knows about it. */
962 for (i = 0; i < include_path_count; i++)
964 char *modname = concat (include_paths[i], "/", fname, (const char *) 0);
966 p = try_print_file_open (filename, modname);
976 /* Skip ahead to a given line in a file, optionally printing each
980 skip_to_line (struct print_file_list *p, unsigned int line,
983 while (p->line < line)
987 if (fgets (buf, sizeof buf, p->f) == NULL)
997 if (strchr (buf, '\n') != NULL)
1002 /* Show the line number, or the source line, in a disassembly
1006 show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
1008 const char *filename;
1009 const char *functionname;
1012 if (! with_line_numbers && ! with_source_code)
1015 if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename,
1016 &functionname, &line))
1019 if (filename != NULL && *filename == '\0')
1021 if (functionname != NULL && *functionname == '\0')
1022 functionname = NULL;
1024 if (with_line_numbers)
1026 if (functionname != NULL
1027 && (prev_functionname == NULL
1028 || strcmp (functionname, prev_functionname) != 0))
1029 printf ("%s():\n", functionname);
1030 if (line > 0 && line != prev_line)
1031 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
1034 if (with_source_code
1038 struct print_file_list **pp, *p;
1040 for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1041 if (strcmp ((*pp)->filename, filename) == 0)
1047 if (p != print_files)
1051 /* We have reencountered a file name which we saw
1052 earlier. This implies that either we are dumping out
1053 code from an included file, or the same file was
1054 linked in more than once. There are two common cases
1055 of an included file: inline functions in a header
1056 file, and a bison or flex skeleton file. In the
1057 former case we want to just start printing (but we
1058 back up a few lines to give context); in the latter
1059 case we want to continue from where we left off. I
1060 can't think of a good way to distinguish the cases,
1061 so I used a heuristic based on the file name. */
1062 if (strcmp (p->filename + strlen (p->filename) - 2, ".h") != 0)
1066 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1073 p->f = fopen (p->modname, "r");
1077 skip_to_line (p, l, FALSE);
1079 if (print_files->f != NULL)
1081 fclose (print_files->f);
1082 print_files->f = NULL;
1088 skip_to_line (p, line, TRUE);
1090 p->next = print_files;
1096 p = update_source_path (filename);
1102 if (file_start_context)
1105 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1108 skip_to_line (p, l, FALSE);
1110 skip_to_line (p, line, TRUE);
1115 if (functionname != NULL
1116 && (prev_functionname == NULL
1117 || strcmp (functionname, prev_functionname) != 0))
1119 if (prev_functionname != NULL)
1120 free (prev_functionname);
1121 prev_functionname = xmalloc (strlen (functionname) + 1);
1122 strcpy (prev_functionname, functionname);
1125 if (line > 0 && line != prev_line)
1129 /* Pseudo FILE object for strings. */
1137 /* sprintf to a "stream". */
1140 objdump_sprintf (SFILE *f, const char *format, ...)
1146 va_start (args, format);
1148 vasprintf (&buf, format, args);
1153 fatal (_("Out of virtual memory"));
1158 while ((size_t) ((f->buffer + f->size) - f->current) < n + 1)
1162 curroff = f->current - f->buffer;
1164 f->buffer = xrealloc (f->buffer, f->size);
1165 f->current = f->buffer + curroff;
1168 memcpy (f->current, buf, n);
1170 f->current[0] = '\0';
1178 /* Returns TRUE if the specified section should be dumped. */
1181 process_section_p (asection * section)
1188 for (i = 0; i < only_used; i++)
1189 if (strcmp (only [i], section->name) == 0)
1196 /* The number of zeroes we want to see before we start skipping them.
1197 The number is arbitrarily chosen. */
1200 #define SKIP_ZEROES (8)
1203 /* The number of zeroes to skip at the end of a section. If the
1204 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1205 SKIP_ZEROES, they will be disassembled. If there are fewer than
1206 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1207 attempt to avoid disassembling zeroes inserted by section
1210 #ifndef SKIP_ZEROES_AT_END
1211 #define SKIP_ZEROES_AT_END (3)
1214 /* Disassemble some data in memory between given values. */
1217 disassemble_bytes (struct disassemble_info * info,
1218 disassembler_ftype disassemble_fn,
1221 bfd_vma start_offset,
1222 bfd_vma stop_offset,
1225 arelent ** relppend)
1227 struct objdump_disasm_info *aux;
1229 int octets_per_line;
1230 bfd_boolean done_dot;
1231 int skip_addr_chars;
1232 bfd_vma addr_offset;
1233 int opb = info->octets_per_byte;
1235 aux = (struct objdump_disasm_info *) info->application_data;
1239 octets_per_line = 4;
1241 octets_per_line = 16;
1243 /* Figure out how many characters to skip at the start of an
1244 address, to make the disassembly look nicer. We discard leading
1245 zeroes in chunks of 4, ensuring that there is always a leading
1247 skip_addr_chars = 0;
1248 if (! prefix_addresses)
1256 + bfd_section_size (section->owner, section) / opb));
1258 while (s[0] == '0' && s[1] == '0' && s[2] == '0' && s[3] == '0'
1261 skip_addr_chars += 4;
1266 info->insn_info_valid = 0;
1269 addr_offset = start_offset;
1270 while (addr_offset < stop_offset)
1274 bfd_boolean need_nl = FALSE;
1276 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1278 for (z = addr_offset * opb; z < stop_offset * opb; z++)
1281 if (! disassemble_zeroes
1282 && (info->insn_info_valid == 0
1283 || info->branch_delay_insns == 0)
1284 && (z - addr_offset * opb >= SKIP_ZEROES
1285 || (z == stop_offset * opb &&
1286 z - addr_offset * opb < SKIP_ZEROES_AT_END)))
1290 /* If there are more nonzero octets to follow, we only skip
1291 zeroes in multiples of 4, to try to avoid running over
1292 the start of an instruction which happens to start with
1294 if (z != stop_offset * opb)
1295 z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1297 octets = z - addr_offset * opb;
1308 if (with_line_numbers || with_source_code)
1309 /* The line number tables will refer to unadjusted
1310 section VMAs, so we must undo any VMA modifications
1311 when calling show_line. */
1312 show_line (aux->abfd, section, addr_offset - adjust_section_vma);
1314 if (! prefix_addresses)
1318 bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
1319 for (s = buf + skip_addr_chars; *s == '0'; s++)
1323 printf ("%s:\t", buf + skip_addr_chars);
1327 aux->require_sec = TRUE;
1328 objdump_print_address (section->vma + addr_offset, info);
1329 aux->require_sec = FALSE;
1336 sfile.buffer = xmalloc (sfile.size);
1337 sfile.current = sfile.buffer;
1338 info->fprintf_func = (fprintf_ftype) objdump_sprintf;
1339 info->stream = (FILE *) &sfile;
1340 info->bytes_per_line = 0;
1341 info->bytes_per_chunk = 0;
1343 #ifdef DISASSEMBLER_NEEDS_RELOCS
1344 /* FIXME: This is wrong. It tests the number of octets
1345 in the last instruction, not the current one. */
1346 if (*relppp < relppend
1347 && (**relppp)->address >= rel_offset + addr_offset
1348 && ((**relppp)->address
1349 < rel_offset + addr_offset + octets / opb))
1350 info->flags = INSN_HAS_RELOC;
1355 octets = (*disassemble_fn) (section->vma + addr_offset, info);
1356 info->fprintf_func = (fprintf_ftype) fprintf;
1357 info->stream = stdout;
1358 if (info->bytes_per_line != 0)
1359 octets_per_line = info->bytes_per_line;
1362 if (sfile.current != sfile.buffer)
1363 printf ("%s\n", sfile.buffer);
1364 free (sfile.buffer);
1372 octets = octets_per_line;
1373 if (addr_offset + octets / opb > stop_offset)
1374 octets = (stop_offset - addr_offset) * opb;
1376 for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1378 if (ISPRINT (data[j]))
1379 buf[j - addr_offset * opb] = data[j];
1381 buf[j - addr_offset * opb] = '.';
1383 buf[j - addr_offset * opb] = '\0';
1386 if (prefix_addresses
1388 : show_raw_insn >= 0)
1392 /* If ! prefix_addresses and ! wide_output, we print
1393 octets_per_line octets per line. */
1395 if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1396 pb = octets_per_line;
1398 if (info->bytes_per_chunk)
1399 bpc = info->bytes_per_chunk;
1403 for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1406 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1408 for (k = bpc - 1; k >= 0; k--)
1409 printf ("%02x", (unsigned) data[j + k]);
1414 for (k = 0; k < bpc; k++)
1415 printf ("%02x", (unsigned) data[j + k]);
1420 for (; pb < octets_per_line; pb += bpc)
1424 for (k = 0; k < bpc; k++)
1429 /* Separate raw data from instruction by extra space. */
1440 printf ("%s", sfile.buffer);
1441 free (sfile.buffer);
1444 if (prefix_addresses
1446 : show_raw_insn >= 0)
1454 j = addr_offset * opb + pb;
1456 bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
1457 for (s = buf + skip_addr_chars; *s == '0'; s++)
1461 printf ("%s:\t", buf + skip_addr_chars);
1463 pb += octets_per_line;
1466 for (; j < addr_offset * opb + pb; j += bpc)
1470 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1472 for (k = bpc - 1; k >= 0; k--)
1473 printf ("%02x", (unsigned) data[j + k]);
1478 for (k = 0; k < bpc; k++)
1479 printf ("%02x", (unsigned) data[j + k]);
1492 while ((*relppp) < relppend
1493 && (**relppp)->address < rel_offset + addr_offset + octets / opb)
1495 if (dump_reloc_info || dump_dynamic_reloc_info)
1506 objdump_print_value (section->vma + q->address, info, TRUE);
1508 printf (": %s\t", q->howto->name);
1510 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1511 printf ("*unknown*");
1514 const char *sym_name;
1516 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1517 if (sym_name != NULL && *sym_name != '\0')
1518 objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
1523 sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1524 sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1525 if (sym_name == NULL || *sym_name == '\0')
1526 sym_name = "*unknown*";
1527 printf ("%s", sym_name);
1534 objdump_print_value (q->addend, info, TRUE);
1546 addr_offset += octets / opb;
1551 disassemble_section (bfd *abfd, asection *section, void *info)
1553 struct disassemble_info * pinfo = (struct disassemble_info *) info;
1554 struct objdump_disasm_info * paux = (struct objdump_disasm_info *) pinfo->application_data;
1555 unsigned int opb = pinfo->octets_per_byte;
1556 bfd_byte * data = NULL;
1557 bfd_size_type datasize = 0;
1558 arelent ** rel_pp = NULL;
1559 arelent ** rel_ppstart = NULL;
1560 arelent ** rel_ppend;
1561 unsigned long stop_offset;
1562 asymbol * sym = NULL;
1566 unsigned long addr_offset;
1568 /* Sections that do not contain machine
1569 code are not normally disassembled. */
1570 if (! disassemble_all
1572 && (section->flags & SEC_CODE) == 0)
1575 if (! process_section_p (section))
1578 datasize = bfd_get_section_size_before_reloc (section);
1582 /* Decide which set of relocs to use. Load them if necessary. */
1583 if (paux->dynrelbuf)
1585 rel_pp = paux->dynrelbuf;
1586 rel_count = paux->dynrelcount;
1587 /* Dynamic reloc addresses are absolute, non-dynamic are section
1588 relative. REL_OFFSET specifies the reloc address corresponding
1589 to the start of this section. */
1590 rel_offset = pinfo->buffer_vma;
1598 if ((section->flags & SEC_RELOC) != 0
1599 #ifndef DISASSEMBLER_NEEDS_RELOCS
1606 relsize = bfd_get_reloc_upper_bound (abfd, section);
1608 bfd_fatal (bfd_get_filename (abfd));
1612 rel_ppstart = rel_pp = xmalloc (relsize);
1613 rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
1615 bfd_fatal (bfd_get_filename (abfd));
1617 /* Sort the relocs by address. */
1618 qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
1623 rel_ppend = rel_pp + rel_count;
1625 data = xmalloc (datasize);
1627 bfd_get_section_contents (abfd, section, data, 0, datasize);
1629 paux->sec = section;
1630 pinfo->buffer = data;
1631 pinfo->buffer_vma = section->vma;
1632 pinfo->buffer_length = datasize;
1633 pinfo->section = section;
1635 if (start_address == (bfd_vma) -1
1636 || start_address < pinfo->buffer_vma)
1639 addr_offset = start_address - pinfo->buffer_vma;
1641 if (stop_address == (bfd_vma) -1)
1642 stop_offset = datasize / opb;
1645 if (stop_address < pinfo->buffer_vma)
1648 stop_offset = stop_address - pinfo->buffer_vma;
1649 if (stop_offset > pinfo->buffer_length / opb)
1650 stop_offset = pinfo->buffer_length / opb;
1653 /* Skip over the relocs belonging to addresses below the
1655 while (rel_pp < rel_ppend
1656 && (*rel_pp)->address < rel_offset + addr_offset)
1659 printf (_("Disassembly of section %s:\n"), section->name);
1661 /* Find the nearest symbol forwards from our current position. */
1662 sym = find_symbol_for_address (abfd, section, section->vma + addr_offset,
1665 /* Disassemble a block of instructions up to the address associated with
1666 the symbol we have just found. Then print the symbol and find the
1667 next symbol on. Repeat until we have disassembled the entire section
1668 or we have reached the end of the address range we are interested in. */
1669 while (addr_offset < stop_offset)
1672 unsigned long nextstop_offset;
1676 && bfd_asymbol_value (sym) <= section->vma + addr_offset)
1681 (x < sorted_symcount
1682 && (bfd_asymbol_value (sorted_syms[x])
1683 <= section->vma + addr_offset));
1687 pinfo->symbols = & sorted_syms[place];
1688 pinfo->num_symbols = x - place;
1691 pinfo->symbols = NULL;
1693 if (! prefix_addresses)
1695 pinfo->fprintf_func (pinfo->stream, "\n");
1696 objdump_print_addr_with_sym (abfd, section, sym,
1697 section->vma + addr_offset,
1699 pinfo->fprintf_func (pinfo->stream, ":\n");
1703 && bfd_asymbol_value (sym) > section->vma + addr_offset)
1705 else if (sym == NULL)
1709 /* Search forward for the next appropriate symbol in
1710 SECTION. Note that all the symbols are sorted
1711 together into one big array, and that some sections
1712 may have overlapping addresses. */
1713 while (place < sorted_symcount
1714 && (sorted_syms[place]->section != section
1715 || (bfd_asymbol_value (sorted_syms[place])
1716 <= bfd_asymbol_value (sym))))
1718 if (place >= sorted_symcount)
1721 nextsym = sorted_syms[place];
1725 && bfd_asymbol_value (sym) > section->vma + addr_offset)
1727 nextstop_offset = bfd_asymbol_value (sym) - section->vma;
1728 if (nextstop_offset > stop_offset)
1729 nextstop_offset = stop_offset;
1731 else if (nextsym == NULL)
1732 nextstop_offset = stop_offset;
1735 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
1736 if (nextstop_offset > stop_offset)
1737 nextstop_offset = stop_offset;
1740 /* If a symbol is explicitly marked as being an object
1741 rather than a function, just dump the bytes without
1742 disassembling them. */
1745 || bfd_asymbol_value (sym) > section->vma + addr_offset
1746 || ((sym->flags & BSF_OBJECT) == 0
1747 && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1749 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1751 || (sym->flags & BSF_FUNCTION) != 0)
1756 disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
1757 addr_offset, nextstop_offset,
1758 rel_offset, &rel_pp, rel_ppend);
1760 addr_offset = nextstop_offset;
1766 if (rel_ppstart != NULL)
1770 /* Disassemble the contents of an object file. */
1773 disassemble_data (bfd *abfd)
1775 struct disassemble_info disasm_info;
1776 struct objdump_disasm_info aux;
1779 prev_functionname = NULL;
1782 /* We make a copy of syms to sort. We don't want to sort syms
1783 because that will screw up the relocs. */
1784 sorted_syms = xmalloc (symcount * sizeof (asymbol *));
1785 memcpy (sorted_syms, syms, symcount * sizeof (asymbol *));
1787 sorted_symcount = remove_useless_symbols (sorted_syms, symcount);
1789 /* Sort the symbols into section and symbol order. */
1790 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
1792 init_disassemble_info (&disasm_info, stdout, fprintf);
1794 disasm_info.application_data = (void *) &aux;
1796 aux.require_sec = FALSE;
1797 aux.dynrelbuf = NULL;
1798 aux.dynrelcount = 0;
1800 disasm_info.print_address_func = objdump_print_address;
1801 disasm_info.symbol_at_address_func = objdump_symbol_at_address;
1803 if (machine != NULL)
1805 const bfd_arch_info_type *info = bfd_scan_arch (machine);
1808 fatal (_("Can't use supplied machine %s"), machine);
1810 abfd->arch_info = info;
1813 if (endian != BFD_ENDIAN_UNKNOWN)
1815 struct bfd_target *xvec;
1817 xvec = xmalloc (sizeof (struct bfd_target));
1818 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
1819 xvec->byteorder = endian;
1823 /* Use libopcodes to locate a suitable disassembler. */
1824 aux.disassemble_fn = disassembler (abfd);
1825 if (!aux.disassemble_fn)
1827 non_fatal (_("Can't disassemble for architecture %s\n"),
1828 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
1833 disasm_info.flavour = bfd_get_flavour (abfd);
1834 disasm_info.arch = bfd_get_arch (abfd);
1835 disasm_info.mach = bfd_get_mach (abfd);
1836 disasm_info.disassembler_options = disassembler_options;
1837 disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
1839 if (bfd_big_endian (abfd))
1840 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
1841 else if (bfd_little_endian (abfd))
1842 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
1844 /* ??? Aborting here seems too drastic. We could default to big or little
1846 disasm_info.endian = BFD_ENDIAN_UNKNOWN;
1848 /* Pre-load the dynamic relocs if we are going
1849 to be dumping them along with the disassembly. */
1850 if (dump_dynamic_reloc_info)
1852 long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
1855 bfd_fatal (bfd_get_filename (abfd));
1859 aux.dynrelbuf = xmalloc (relsize);
1860 aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd, aux.dynrelbuf, dynsyms);
1861 if (aux.dynrelcount < 0)
1862 bfd_fatal (bfd_get_filename (abfd));
1864 /* Sort the relocs by address. */
1865 qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *), compare_relocs);
1869 bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
1871 if (aux.dynrelbuf != NULL)
1872 free (aux.dynrelbuf);
1876 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
1877 it. Return NULL on failure. */
1880 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
1886 stabsect = bfd_get_section_by_name (abfd, sect_name);
1887 if (stabsect == NULL)
1889 printf (_("No %s section present\n\n"), sect_name);
1893 size = bfd_section_size (abfd, stabsect);
1894 contents = xmalloc (size);
1896 if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
1898 non_fatal (_("Reading %s section of %s failed: %s"),
1899 sect_name, bfd_get_filename (abfd),
1900 bfd_errmsg (bfd_get_error ()));
1911 /* Stabs entries use a 12 byte format:
1912 4 byte string table index
1914 1 byte stab other field
1915 2 byte stab desc field
1917 FIXME: This will have to change for a 64 bit object format. */
1919 #define STRDXOFF (0)
1921 #define OTHEROFF (5)
1924 #define STABSIZE (12)
1926 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1927 using string table section STRSECT_NAME (in `strtab'). */
1930 print_section_stabs (bfd *abfd, const char *stabsect_name, unsigned *string_offset_ptr)
1933 unsigned file_string_table_offset = 0;
1934 unsigned next_file_string_table_offset = *string_offset_ptr;
1935 bfd_byte *stabp, *stabs_end;
1938 stabs_end = stabp + stab_size;
1940 printf (_("Contents of %s section:\n\n"), stabsect_name);
1941 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1943 /* Loop through all symbols and print them.
1945 We start the index at -1 because there is a dummy symbol on
1946 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1947 for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
1951 unsigned char type, other;
1952 unsigned short desc;
1955 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
1956 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
1957 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
1958 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
1959 value = bfd_h_get_32 (abfd, stabp + VALOFF);
1961 printf ("\n%-6d ", i);
1962 /* Either print the stab name, or, if unnamed, print its number
1963 again (makes consistent formatting for tools like awk). */
1964 name = bfd_get_stab_name (type);
1966 printf ("%-6s", name);
1967 else if (type == N_UNDF)
1970 printf ("%-6d", type);
1971 printf (" %-6d %-6d ", other, desc);
1972 bfd_printf_vma (abfd, value);
1973 printf (" %-6lu", strx);
1975 /* Symbols with type == 0 (N_UNDF) specify the length of the
1976 string table associated with this file. We use that info
1977 to know how to relocate the *next* file's string table indices. */
1980 file_string_table_offset = next_file_string_table_offset;
1981 next_file_string_table_offset += value;
1985 /* Using the (possibly updated) string table offset, print the
1986 string (if any) associated with this symbol. */
1987 if ((strx + file_string_table_offset) < stabstr_size)
1988 printf (" %s", &strtab[strx + file_string_table_offset]);
1994 *string_offset_ptr = next_file_string_table_offset;
1999 const char * section_name;
2000 const char * string_section_name;
2001 unsigned string_offset;
2006 find_stabs_section (bfd *abfd, asection *section, void *names)
2009 stab_section_names * sought = (stab_section_names *) names;
2011 /* Check for section names for which stabsect_name is a prefix, to
2012 handle .stab.N, etc. */
2013 len = strlen (sought->section_name);
2015 /* If the prefix matches, and the files section name ends with a
2016 nul or a digit, then we match. I.e., we want either an exact
2017 match or a section followed by a number. */
2018 if (strncmp (sought->section_name, section->name, len) == 0
2019 && (section->name[len] == 0
2020 || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2023 strtab = read_section_stabs (abfd, sought->string_section_name,
2028 stabs = read_section_stabs (abfd, section->name, &stab_size);
2030 print_section_stabs (abfd, section->name, &sought->string_offset);
2036 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2038 stab_section_names s;
2040 s.section_name = stabsect_name;
2041 s.string_section_name = strsect_name;
2042 s.string_offset = 0;
2044 bfd_map_over_sections (abfd, find_stabs_section, & s);
2050 /* Dump the any sections containing stabs debugging information. */
2053 dump_stabs (bfd *abfd)
2055 dump_stabs_section (abfd, ".stab", ".stabstr");
2056 dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2057 dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2058 dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2062 dump_bfd_header (bfd *abfd)
2066 printf (_("architecture: %s, "),
2067 bfd_printable_arch_mach (bfd_get_arch (abfd),
2068 bfd_get_mach (abfd)));
2069 printf (_("flags 0x%08x:\n"), abfd->flags);
2071 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2072 PF (HAS_RELOC, "HAS_RELOC");
2073 PF (EXEC_P, "EXEC_P");
2074 PF (HAS_LINENO, "HAS_LINENO");
2075 PF (HAS_DEBUG, "HAS_DEBUG");
2076 PF (HAS_SYMS, "HAS_SYMS");
2077 PF (HAS_LOCALS, "HAS_LOCALS");
2078 PF (DYNAMIC, "DYNAMIC");
2079 PF (WP_TEXT, "WP_TEXT");
2080 PF (D_PAGED, "D_PAGED");
2081 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2082 PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
2083 printf (_("\nstart address 0x"));
2084 bfd_printf_vma (abfd, abfd->start_address);
2090 dump_bfd_private_header (bfd *abfd)
2092 bfd_print_private_bfd_data (abfd, stdout);
2096 /* Display a section in hexadecimal format with associated characters.
2097 Each line prefixed by the zero padded address. */
2100 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2103 bfd_size_type datasize;
2104 bfd_size_type addr_offset;
2105 bfd_size_type start_offset;
2106 bfd_size_type stop_offset;
2107 unsigned int opb = bfd_octets_per_byte (abfd);
2108 /* Bytes per line. */
2109 const int onaline = 16;
2114 if ((section->flags & SEC_HAS_CONTENTS) == 0)
2117 if (! process_section_p (section))
2120 if ((datasize = bfd_section_size (abfd, section)) == 0)
2123 printf (_("Contents of section %s:\n"), section->name);
2125 data = xmalloc (datasize);
2127 bfd_get_section_contents (abfd, section, data, 0, datasize);
2129 /* Compute the address range to display. */
2130 if (start_address == (bfd_vma) -1
2131 || start_address < section->vma)
2134 start_offset = start_address - section->vma;
2136 if (stop_address == (bfd_vma) -1)
2137 stop_offset = datasize / opb;
2140 if (stop_address < section->vma)
2143 stop_offset = stop_address - section->vma;
2145 if (stop_offset > datasize / opb)
2146 stop_offset = datasize / opb;
2151 bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2152 if (strlen (buf) >= sizeof (buf))
2156 while (buf[count] == '0' && buf[count+1] != '\0')
2158 count = strlen (buf) - count;
2162 bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2163 if (strlen (buf) >= sizeof (buf))
2167 while (buf[count] == '0' && buf[count+1] != '\0')
2169 count = strlen (buf) - count;
2173 for (addr_offset = start_offset;
2174 addr_offset < stop_offset; addr_offset += onaline / opb)
2178 bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2179 count = strlen (buf);
2180 if ((size_t) count >= sizeof (buf))
2184 while (count < width)
2189 fputs (buf + count - width, stdout);
2192 for (j = addr_offset * opb;
2193 j < addr_offset * opb + onaline; j++)
2195 if (j < stop_offset * opb)
2196 printf ("%02x", (unsigned) (data[j]));
2204 for (j = addr_offset * opb;
2205 j < addr_offset * opb + onaline; j++)
2207 if (j >= stop_offset * opb)
2210 printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2217 /* Actually display the various requested regions. */
2220 dump_data (bfd *abfd)
2222 bfd_map_over_sections (abfd, dump_section, NULL);
2225 /* Should perhaps share code and display with nm? */
2228 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2238 printf ("DYNAMIC SYMBOL TABLE:\n");
2244 printf ("SYMBOL TABLE:\n");
2248 printf (_("no symbols\n"));
2250 for (count = 0; count < max; count++)
2254 if (*current == NULL)
2255 printf (_("no information for the %ld'th symbol"), count);
2257 else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2258 printf (_("could not determine the type of the %ld'th symbol"),
2263 const char *name = (*current)->name;
2265 if (do_demangle && name != NULL && *name != '\0')
2269 /* If we want to demangle the name, we demangle it
2270 here, and temporarily clobber it while calling
2271 bfd_print_symbol. FIXME: This is a gross hack. */
2272 alloc = demangle (cur_bfd, name);
2273 (*current)->name = alloc;
2274 bfd_print_symbol (cur_bfd, stdout, *current,
2275 bfd_print_symbol_all);
2276 (*current)->name = name;
2280 bfd_print_symbol (cur_bfd, stdout, *current,
2281 bfd_print_symbol_all);
2291 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2294 char *last_filename, *last_functionname;
2295 unsigned int last_line;
2297 /* Get column headers lined up reasonably. */
2305 bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2306 width = strlen (buf) - 7;
2308 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2311 last_filename = NULL;
2312 last_functionname = NULL;
2315 for (p = relpp; relcount && *p != NULL; p++, relcount--)
2318 const char *filename, *functionname;
2320 const char *sym_name;
2321 const char *section_name;
2323 if (start_address != (bfd_vma) -1
2324 && q->address < start_address)
2326 if (stop_address != (bfd_vma) -1
2327 && q->address > stop_address)
2330 if (with_line_numbers
2332 && bfd_find_nearest_line (abfd, sec, syms, q->address,
2333 &filename, &functionname, &line))
2335 if (functionname != NULL
2336 && (last_functionname == NULL
2337 || strcmp (functionname, last_functionname) != 0))
2339 printf ("%s():\n", functionname);
2340 if (last_functionname != NULL)
2341 free (last_functionname);
2342 last_functionname = xstrdup (functionname);
2346 && (line != last_line
2347 || (filename != NULL
2348 && last_filename != NULL
2349 && strcmp (filename, last_filename) != 0)))
2351 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2353 if (last_filename != NULL)
2354 free (last_filename);
2355 if (filename == NULL)
2356 last_filename = NULL;
2358 last_filename = xstrdup (filename);
2362 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2364 sym_name = (*(q->sym_ptr_ptr))->name;
2365 section_name = (*(q->sym_ptr_ptr))->section->name;
2370 section_name = NULL;
2375 bfd_printf_vma (abfd, q->address);
2377 printf (" %-16s ", q->howto->name);
2379 printf (" %-16d ", q->howto->type);
2380 objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
2384 if (section_name == NULL)
2385 section_name = "*unknown*";
2386 bfd_printf_vma (abfd, q->address);
2387 printf (" %-16s [%s]",
2395 bfd_printf_vma (abfd, q->addend);
2403 dump_relocs_in_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2409 if ( bfd_is_abs_section (section)
2410 || bfd_is_und_section (section)
2411 || bfd_is_com_section (section)
2412 || (! process_section_p (section))
2413 || ((section->flags & SEC_RELOC) == 0))
2416 relsize = bfd_get_reloc_upper_bound (abfd, section);
2418 bfd_fatal (bfd_get_filename (abfd));
2420 printf ("RELOCATION RECORDS FOR [%s]:", section->name);
2424 printf (" (none)\n\n");
2428 relpp = xmalloc (relsize);
2429 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
2432 bfd_fatal (bfd_get_filename (abfd));
2433 else if (relcount == 0)
2434 printf (" (none)\n\n");
2438 dump_reloc_set (abfd, section, relpp, relcount);
2445 dump_relocs (bfd *abfd)
2447 bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
2451 dump_dynamic_relocs (bfd *abfd)
2457 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2459 bfd_fatal (bfd_get_filename (abfd));
2461 printf ("DYNAMIC RELOCATION RECORDS");
2464 printf (" (none)\n\n");
2467 relpp = xmalloc (relsize);
2468 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2471 bfd_fatal (bfd_get_filename (abfd));
2472 else if (relcount == 0)
2473 printf (" (none)\n\n");
2477 dump_reloc_set (abfd, NULL, relpp, relcount);
2484 /* Creates a table of paths, to search for source files. */
2487 add_include_path (const char *path)
2491 include_path_count++;
2492 include_paths = xrealloc (include_paths,
2493 include_path_count * sizeof (*include_paths));
2494 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2495 if (path[1] == ':' && path[2] == 0)
2496 path = concat (path, ".", (const char *) 0);
2498 include_paths[include_path_count - 1] = path;
2502 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *dummy ATTRIBUTE_UNUSED)
2504 section->vma += adjust_section_vma;
2505 section->lma += adjust_section_vma;
2508 /* Dump selected contents of ABFD. */
2511 dump_bfd (bfd *abfd)
2513 /* If we are adjusting section VMA's, change them all now. Changing
2514 the BFD information is a hack. However, we must do it, or
2515 bfd_find_nearest_line will not do the right thing. */
2516 if (adjust_section_vma != 0)
2517 bfd_map_over_sections (abfd, adjust_addresses, NULL);
2519 if (! dump_debugging_tags)
2520 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
2523 print_arelt_descr (stdout, abfd, TRUE);
2524 if (dump_file_header)
2525 dump_bfd_header (abfd);
2526 if (dump_private_headers)
2527 dump_bfd_private_header (abfd);
2528 if (! dump_debugging_tags)
2530 if (dump_section_headers)
2531 dump_headers (abfd);
2533 if (dump_symtab || dump_reloc_info || disassemble || dump_debugging)
2534 syms = slurp_symtab (abfd);
2535 if (dump_dynamic_symtab || dump_dynamic_reloc_info)
2536 dynsyms = slurp_dynamic_symtab (abfd);
2539 dump_symbols (abfd, FALSE);
2540 if (dump_dynamic_symtab)
2541 dump_symbols (abfd, TRUE);
2542 if (dump_stab_section_info)
2544 if (dump_reloc_info && ! disassemble)
2546 if (dump_dynamic_reloc_info && ! disassemble)
2547 dump_dynamic_relocs (abfd);
2548 if (dump_section_contents)
2551 disassemble_data (abfd);
2557 dhandle = read_debugging_info (abfd, syms, symcount);
2558 if (dhandle != NULL)
2560 if (! print_debugging_info (stdout, dhandle, abfd, syms, demangle,
2561 dump_debugging_tags ? TRUE : FALSE))
2563 non_fatal (_("%s: printing debugging information failed"),
2564 bfd_get_filename (abfd));
2584 display_bfd (bfd *abfd)
2588 if (bfd_check_format_matches (abfd, bfd_object, &matching))
2594 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2596 nonfatal (bfd_get_filename (abfd));
2597 list_matching_formats (matching);
2602 if (bfd_get_error () != bfd_error_file_not_recognized)
2604 nonfatal (bfd_get_filename (abfd));
2608 if (bfd_check_format_matches (abfd, bfd_core, &matching))
2614 nonfatal (bfd_get_filename (abfd));
2616 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2618 list_matching_formats (matching);
2624 display_file (char *filename, char *target)
2629 if (get_file_size (filename) < 1)
2632 file = bfd_openr (filename, target);
2635 nonfatal (filename);
2639 /* If the file is an archive, process all of its elements. */
2640 if (bfd_check_format (file, bfd_archive))
2642 bfd *last_arfile = NULL;
2644 printf (_("In archive %s:\n"), bfd_get_filename (file));
2647 bfd_set_error (bfd_error_no_error);
2649 arfile = bfd_openr_next_archived_file (file, arfile);
2652 if (bfd_get_error () != bfd_error_no_more_archived_files)
2653 nonfatal (bfd_get_filename (file));
2657 display_bfd (arfile);
2659 if (last_arfile != NULL)
2660 bfd_close (last_arfile);
2661 last_arfile = arfile;
2664 if (last_arfile != NULL)
2665 bfd_close (last_arfile);
2674 main (int argc, char **argv)
2677 char *target = default_target;
2678 bfd_boolean seenflag = FALSE;
2680 #if defined (HAVE_SETLOCALE)
2681 #if defined (HAVE_LC_MESSAGES)
2682 setlocale (LC_MESSAGES, "");
2684 setlocale (LC_CTYPE, "");
2687 bindtextdomain (PACKAGE, LOCALEDIR);
2688 textdomain (PACKAGE);
2690 program_name = *argv;
2691 xmalloc_set_program_name (program_name);
2693 START_PROGRESS (program_name, 0);
2696 set_default_bfd_target ();
2698 while ((c = getopt_long (argc, argv, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeG",
2699 long_options, (int *) 0))
2705 break; /* We've been given a long option. */
2710 if (disassembler_options)
2711 /* Ignore potential memory leak for now. */
2712 disassembler_options = concat (disassembler_options, ",",
2715 disassembler_options = optarg;
2718 if (only_used == only_size)
2721 only = xrealloc (only, only_size * sizeof (char *));
2723 only [only_used++] = optarg;
2726 with_line_numbers = TRUE;
2735 enum demangling_styles style;
2737 style = cplus_demangle_name_to_style (optarg);
2738 if (style == unknown_demangling)
2739 fatal (_("unknown demangling style `%s'"),
2742 cplus_demangle_set_style (style);
2748 case OPTION_ADJUST_VMA:
2749 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
2751 case OPTION_START_ADDRESS:
2752 start_address = parse_vma (optarg, "--start-address");
2754 case OPTION_STOP_ADDRESS:
2755 stop_address = parse_vma (optarg, "--stop-address");
2758 if (strcmp (optarg, "B") == 0)
2759 endian = BFD_ENDIAN_BIG;
2760 else if (strcmp (optarg, "L") == 0)
2761 endian = BFD_ENDIAN_LITTLE;
2764 non_fatal (_("unrecognized -E option"));
2769 if (strncmp (optarg, "big", strlen (optarg)) == 0)
2770 endian = BFD_ENDIAN_BIG;
2771 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
2772 endian = BFD_ENDIAN_LITTLE;
2775 non_fatal (_("unrecognized --endian type `%s'"), optarg);
2781 dump_file_header = TRUE;
2785 formats_info = TRUE;
2789 add_include_path (optarg);
2792 dump_private_headers = TRUE;
2796 dump_private_headers = TRUE;
2798 dump_reloc_info = TRUE;
2799 dump_file_header = TRUE;
2800 dump_ar_hdrs = TRUE;
2801 dump_section_headers = TRUE;
2809 dump_dynamic_symtab = TRUE;
2817 disassemble_zeroes = TRUE;
2821 disassemble_all = TRUE;
2826 with_source_code = TRUE;
2835 dump_debugging_tags = 1;
2840 dump_stab_section_info = TRUE;
2844 dump_section_contents = TRUE;
2848 dump_reloc_info = TRUE;
2852 dump_dynamic_reloc_info = TRUE;
2856 dump_ar_hdrs = TRUE;
2860 dump_section_headers = TRUE;
2868 show_version = TRUE;
2878 print_version ("objdump");
2884 exit_status = display_info ();
2888 display_file ("a.out", target);
2890 for (; optind < argc;)
2891 display_file (argv[optind++], target);
2894 END_PROGRESS (program_name);