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 bfd_vma adjust_section_vma = 0; /* --adjust-vma */
106 static int file_start_context = 0; /* --file-start-context */
108 /* Pointer to an array of section names provided by
109 one or more "-j secname" command line options. */
111 /* The total number of slots in the only[] array. */
112 static size_t only_size = 0;
113 /* The number of occupied slots in the only[] array. */
114 static size_t only_used = 0;
116 /* Variables for handling include file path table. */
117 static const char **include_paths;
118 static int include_path_count;
120 /* Extra info to pass to the section disassembler and address printing
122 struct objdump_disasm_info
126 bfd_boolean require_sec;
127 arelent ** dynrelbuf;
129 disassembler_ftype disassemble_fn;
132 /* Architecture to disassemble for, or default if NULL. */
133 static char *machine = NULL;
135 /* Target specific options to the disassembler. */
136 static char *disassembler_options = NULL;
138 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
139 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
141 /* The symbol table. */
142 static asymbol **syms;
144 /* Number of symbols in `syms'. */
145 static long symcount = 0;
147 /* The sorted symbol table. */
148 static asymbol **sorted_syms;
150 /* Number of symbols in `sorted_syms'. */
151 static long sorted_symcount = 0;
153 /* The dynamic symbol table. */
154 static asymbol **dynsyms;
156 /* The synthetic symbol table. */
157 static asymbol *synthsyms;
158 static long synthcount = 0;
160 /* Number of symbols in `dynsyms'. */
161 static long dynsymcount = 0;
163 static bfd_byte *stabs;
164 static bfd_size_type stab_size;
167 static bfd_size_type stabstr_size;
170 usage (FILE *stream, int status)
172 fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
173 fprintf (stream, _(" Display information from object <file(s)>.\n"));
174 fprintf (stream, _(" At least one of the following switches must be given:\n"));
175 fprintf (stream, _("\
176 -a, --archive-headers Display archive header information\n\
177 -f, --file-headers Display the contents of the overall file header\n\
178 -p, --private-headers Display object format specific file header contents\n\
179 -h, --[section-]headers Display the contents of the section headers\n\
180 -x, --all-headers Display the contents of all headers\n\
181 -d, --disassemble Display assembler contents of executable sections\n\
182 -D, --disassemble-all Display assembler contents of all sections\n\
183 -S, --source Intermix source code with disassembly\n\
184 -s, --full-contents Display the full contents of all sections requested\n\
185 -g, --debugging Display debug information in object file\n\
186 -e, --debugging-tags Display debug information using ctags style\n\
187 -G, --stabs Display (in raw form) any STABS info in the file\n\
188 -t, --syms Display the contents of the symbol table(s)\n\
189 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
190 -r, --reloc Display the relocation entries in the file\n\
191 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
192 -v, --version Display this program's version number\n\
193 -i, --info List object formats and architectures supported\n\
194 -H, --help Display this information\n\
198 fprintf (stream, _("\n The following switches are optional:\n"));
199 fprintf (stream, _("\
200 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
201 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
202 -j, --section=NAME Only display information for section NAME\n\
203 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
204 -EB --endian=big Assume big endian format when disassembling\n\
205 -EL --endian=little Assume little endian format when disassembling\n\
206 --file-start-context Include context from start of file (with -S)\n\
207 -I, --include=DIR Add DIR to search list for source files\n\
208 -l, --line-numbers Include line numbers and filenames in output\n\
209 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
210 The STYLE, if specified, can be `auto', `gnu',\n\
211 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
213 -w, --wide Format output for more than 80 columns\n\
214 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
215 --start-address=ADDR Only process data whose address is >= ADDR\n\
216 --stop-address=ADDR Only process data whose address is <= ADDR\n\
217 --prefix-addresses Print complete address alongside disassembly\n\
218 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
219 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
221 list_supported_targets (program_name, stream);
222 list_supported_architectures (program_name, stream);
224 disassembler_usage (stream);
227 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
231 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
235 OPTION_START_ADDRESS,
240 static struct option long_options[]=
242 {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
243 {"all-headers", no_argument, NULL, 'x'},
244 {"private-headers", no_argument, NULL, 'p'},
245 {"architecture", required_argument, NULL, 'm'},
246 {"archive-headers", no_argument, NULL, 'a'},
247 {"debugging", no_argument, NULL, 'g'},
248 {"debugging-tags", no_argument, NULL, 'e'},
249 {"demangle", optional_argument, NULL, 'C'},
250 {"disassemble", no_argument, NULL, 'd'},
251 {"disassemble-all", no_argument, NULL, 'D'},
252 {"disassembler-options", required_argument, NULL, 'M'},
253 {"disassemble-zeroes", no_argument, NULL, 'z'},
254 {"dynamic-reloc", no_argument, NULL, 'R'},
255 {"dynamic-syms", no_argument, NULL, 'T'},
256 {"endian", required_argument, NULL, OPTION_ENDIAN},
257 {"file-headers", no_argument, NULL, 'f'},
258 {"file-start-context", no_argument, &file_start_context, 1},
259 {"full-contents", no_argument, NULL, 's'},
260 {"headers", no_argument, NULL, 'h'},
261 {"help", no_argument, NULL, 'H'},
262 {"info", no_argument, NULL, 'i'},
263 {"line-numbers", no_argument, NULL, 'l'},
264 {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
265 {"prefix-addresses", no_argument, &prefix_addresses, 1},
266 {"reloc", no_argument, NULL, 'r'},
267 {"section", required_argument, NULL, 'j'},
268 {"section-headers", no_argument, NULL, 'h'},
269 {"show-raw-insn", no_argument, &show_raw_insn, 1},
270 {"source", no_argument, NULL, 'S'},
271 {"include", required_argument, NULL, 'I'},
272 {"stabs", no_argument, NULL, 'G'},
273 {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
274 {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
275 {"syms", no_argument, NULL, 't'},
276 {"target", required_argument, NULL, 'b'},
277 {"version", no_argument, NULL, 'V'},
278 {"wide", no_argument, NULL, 'w'},
279 {0, no_argument, 0, 0}
283 nonfatal (const char *msg)
290 dump_section_header (bfd *abfd ATTRIBUTE_UNUSED, asection *section,
291 void *ignored ATTRIBUTE_UNUSED)
294 unsigned int opb = bfd_octets_per_byte (abfd);
296 printf ("%3d %-13s %08lx ", section->index,
297 bfd_get_section_name (abfd, section),
298 (unsigned long) bfd_section_size (abfd, section) / opb);
299 bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
301 bfd_printf_vma (abfd, section->lma);
302 printf (" %08lx 2**%u", (unsigned long) section->filepos,
303 bfd_get_section_alignment (abfd, section));
309 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
311 PF (SEC_HAS_CONTENTS, "CONTENTS");
312 PF (SEC_ALLOC, "ALLOC");
313 PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
314 PF (SEC_LOAD, "LOAD");
315 PF (SEC_RELOC, "RELOC");
316 PF (SEC_READONLY, "READONLY");
317 PF (SEC_CODE, "CODE");
318 PF (SEC_DATA, "DATA");
320 PF (SEC_DEBUGGING, "DEBUGGING");
321 PF (SEC_NEVER_LOAD, "NEVER_LOAD");
322 PF (SEC_EXCLUDE, "EXCLUDE");
323 PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
324 PF (SEC_BLOCK, "BLOCK");
325 PF (SEC_CLINK, "CLINK");
326 PF (SEC_SMALL_DATA, "SMALL_DATA");
327 PF (SEC_SHARED, "SHARED");
328 PF (SEC_ARCH_BIT_0, "ARCH_BIT_0");
329 PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
331 if ((section->flags & SEC_LINK_ONCE) != 0)
335 switch (section->flags & SEC_LINK_DUPLICATES)
339 case SEC_LINK_DUPLICATES_DISCARD:
340 ls = "LINK_ONCE_DISCARD";
342 case SEC_LINK_DUPLICATES_ONE_ONLY:
343 ls = "LINK_ONCE_ONE_ONLY";
345 case SEC_LINK_DUPLICATES_SAME_SIZE:
346 ls = "LINK_ONCE_SAME_SIZE";
348 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
349 ls = "LINK_ONCE_SAME_CONTENTS";
352 printf ("%s%s", comma, ls);
354 if (section->comdat != NULL)
355 printf (" (COMDAT %s %ld)", section->comdat->name,
356 section->comdat->symbol);
366 dump_headers (bfd *abfd)
368 printf (_("Sections:\n"));
371 printf (_("Idx Name Size VMA LMA File off Algn"));
373 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
374 if (bfd_get_arch_size (abfd) == 32)
375 printf (_("Idx Name Size VMA LMA File off Algn"));
377 printf (_("Idx Name Size VMA LMA File off Algn"));
381 printf (_(" Flags"));
382 if (abfd->flags & HAS_LOAD_PAGE)
386 bfd_map_over_sections (abfd, dump_section_header, NULL);
390 slurp_symtab (bfd *abfd)
395 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
401 storage = bfd_get_symtab_upper_bound (abfd);
403 bfd_fatal (bfd_get_filename (abfd));
405 sy = xmalloc (storage);
407 symcount = bfd_canonicalize_symtab (abfd, sy);
409 bfd_fatal (bfd_get_filename (abfd));
413 /* Read in the dynamic symbols. */
416 slurp_dynamic_symtab (bfd *abfd)
421 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
424 if (!(bfd_get_file_flags (abfd) & DYNAMIC))
426 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
431 bfd_fatal (bfd_get_filename (abfd));
434 sy = xmalloc (storage);
436 dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
438 bfd_fatal (bfd_get_filename (abfd));
442 /* Filter out (in place) symbols that are useless for disassembly.
443 COUNT is the number of elements in SYMBOLS.
444 Return the number of useful symbols. */
447 remove_useless_symbols (asymbol **symbols, long count)
449 asymbol **in_ptr = symbols, **out_ptr = symbols;
453 asymbol *sym = *in_ptr++;
455 if (sym->name == NULL || sym->name[0] == '\0')
457 if (sym->flags & (BSF_DEBUGGING))
459 if (bfd_is_und_section (sym->section)
460 || bfd_is_com_section (sym->section))
465 return out_ptr - symbols;
468 /* Sort symbols into value order. */
471 compare_symbols (const void *ap, const void *bp)
473 const asymbol *a = * (const asymbol **) ap;
474 const asymbol *b = * (const asymbol **) bp;
484 if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
486 else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
489 if (a->section > b->section)
491 else if (a->section < b->section)
494 an = bfd_asymbol_name (a);
495 bn = bfd_asymbol_name (b);
499 /* The symbols gnu_compiled and gcc2_compiled convey no real
500 information, so put them after other symbols with the same value. */
501 af = (strstr (an, "gnu_compiled") != NULL
502 || strstr (an, "gcc2_compiled") != NULL);
503 bf = (strstr (bn, "gnu_compiled") != NULL
504 || strstr (bn, "gcc2_compiled") != NULL);
511 /* We use a heuristic for the file name, to try to sort it after
512 more useful symbols. It may not work on non Unix systems, but it
513 doesn't really matter; the only difference is precisely which
514 symbol names get printed. */
516 #define file_symbol(s, sn, snl) \
517 (((s)->flags & BSF_FILE) != 0 \
518 || ((sn)[(snl) - 2] == '.' \
519 && ((sn)[(snl) - 1] == 'o' \
520 || (sn)[(snl) - 1] == 'a')))
522 af = file_symbol (a, an, anl);
523 bf = file_symbol (b, bn, bnl);
530 /* Try to sort global symbols before local symbols before function
531 symbols before debugging symbols. */
536 if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
538 if ((aflags & BSF_DEBUGGING) != 0)
543 if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
545 if ((aflags & BSF_FUNCTION) != 0)
550 if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
552 if ((aflags & BSF_LOCAL) != 0)
557 if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
559 if ((aflags & BSF_GLOBAL) != 0)
565 /* Symbols that start with '.' might be section names, so sort them
566 after symbols that don't start with '.'. */
567 if (an[0] == '.' && bn[0] != '.')
569 if (an[0] != '.' && bn[0] == '.')
572 /* Finally, if we can't distinguish them in any other way, try to
573 get consistent results by sorting the symbols by name. */
574 return strcmp (an, bn);
577 /* Sort relocs into address order. */
580 compare_relocs (const void *ap, const void *bp)
582 const arelent *a = * (const arelent **) ap;
583 const arelent *b = * (const arelent **) bp;
585 if (a->address > b->address)
587 else if (a->address < b->address)
590 /* So that associated relocations tied to the same address show up
591 in the correct order, we don't do any further sorting. */
600 /* Print an address (VMA) to the output stream in INFO.
601 If SKIP_ZEROES is TRUE, omit leading zeroes. */
604 objdump_print_value (bfd_vma vma, struct disassemble_info *info,
605 bfd_boolean skip_zeroes)
609 struct objdump_disasm_info *aux;
611 aux = (struct objdump_disasm_info *) info->application_data;
612 bfd_sprintf_vma (aux->abfd, buf, vma);
617 for (p = buf; *p == '0'; ++p)
622 (*info->fprintf_func) (info->stream, "%s", p);
625 /* Print the name of a symbol. */
628 objdump_print_symname (bfd *abfd, struct disassemble_info *info,
635 name = bfd_asymbol_name (sym);
636 if (do_demangle && name[0] != '\0')
638 /* Demangle the name. */
639 alloc = demangle (abfd, name);
644 (*info->fprintf_func) (info->stream, "%s", name);
652 /* Locate a symbol given a bfd and a section (from INFO->application_data),
653 and a VMA. If INFO->application_data->require_sec is TRUE, then always
654 require the symbol to be in the section. Returns NULL if there is no
655 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
656 of the symbol in sorted_syms. */
659 find_symbol_for_address (bfd_vma vma,
660 struct disassemble_info *info,
663 /* @@ Would it speed things up to cache the last two symbols returned,
664 and maybe their address ranges? For many processors, only one memory
665 operand can be present at a time, so the 2-entry cache wouldn't be
666 constantly churned by code doing heavy memory accesses. */
668 /* Indices in `sorted_syms'. */
670 long max = sorted_symcount;
672 struct objdump_disasm_info *aux;
677 if (sorted_symcount < 1)
680 aux = (struct objdump_disasm_info *) info->application_data;
683 opb = bfd_octets_per_byte (abfd);
685 /* Perform a binary search looking for the closest symbol to the
686 required value. We are searching the range (min, max]. */
687 while (min + 1 < max)
691 thisplace = (max + min) / 2;
692 sym = sorted_syms[thisplace];
694 if (bfd_asymbol_value (sym) > vma)
696 else if (bfd_asymbol_value (sym) < vma)
705 /* The symbol we want is now in min, the low end of the range we
706 were searching. If there are several symbols with the same
707 value, we want the first one. */
710 && (bfd_asymbol_value (sorted_syms[thisplace])
711 == bfd_asymbol_value (sorted_syms[thisplace - 1])))
714 /* If the file is relocatable, and the symbol could be from this
715 section, prefer a symbol from this section over symbols from
716 others, even if the other symbol's value might be closer.
718 Note that this may be wrong for some symbol references if the
719 sections have overlapping memory ranges, but in that case there's
720 no way to tell what's desired without looking at the relocation
722 if (sorted_syms[thisplace]->section != sec
724 || ((abfd->flags & HAS_RELOC) != 0
725 && vma >= bfd_get_section_vma (abfd, sec)
726 && vma < (bfd_get_section_vma (abfd, sec)
727 + bfd_section_size (abfd, sec) / opb))))
731 for (i = thisplace + 1; i < sorted_symcount; i++)
733 if (bfd_asymbol_value (sorted_syms[i])
734 != bfd_asymbol_value (sorted_syms[thisplace]))
742 if (sorted_syms[i]->section == sec
744 || sorted_syms[i - 1]->section != sec
745 || (bfd_asymbol_value (sorted_syms[i])
746 != bfd_asymbol_value (sorted_syms[i - 1]))))
753 if (sorted_syms[thisplace]->section != sec)
755 /* We didn't find a good symbol with a smaller value.
756 Look for one with a larger value. */
757 for (i = thisplace + 1; i < sorted_symcount; i++)
759 if (sorted_syms[i]->section == sec)
767 if (sorted_syms[thisplace]->section != sec
769 || ((abfd->flags & HAS_RELOC) != 0
770 && vma >= bfd_get_section_vma (abfd, sec)
771 && vma < (bfd_get_section_vma (abfd, sec)
772 + bfd_section_size (abfd, sec)))))
773 /* There is no suitable symbol. */
777 /* Give the target a chance to reject the symbol. */
778 while (! info->symbol_is_valid (sorted_syms [thisplace], info))
781 if (thisplace >= sorted_symcount
782 || bfd_asymbol_value (sorted_syms [thisplace]) > vma)
789 return sorted_syms[thisplace];
792 /* Print an address and the offset to the nearest symbol. */
795 objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
796 bfd_vma vma, struct disassemble_info *info,
797 bfd_boolean skip_zeroes)
799 objdump_print_value (vma, info, skip_zeroes);
805 (*info->fprintf_func) (info->stream, " <%s",
806 bfd_get_section_name (abfd, sec));
807 secaddr = bfd_get_section_vma (abfd, sec);
810 (*info->fprintf_func) (info->stream, "-0x");
811 objdump_print_value (secaddr - vma, info, TRUE);
813 else if (vma > secaddr)
815 (*info->fprintf_func) (info->stream, "+0x");
816 objdump_print_value (vma - secaddr, info, TRUE);
818 (*info->fprintf_func) (info->stream, ">");
822 (*info->fprintf_func) (info->stream, " <");
823 objdump_print_symname (abfd, info, sym);
824 if (bfd_asymbol_value (sym) > vma)
826 (*info->fprintf_func) (info->stream, "-0x");
827 objdump_print_value (bfd_asymbol_value (sym) - vma, info, TRUE);
829 else if (vma > bfd_asymbol_value (sym))
831 (*info->fprintf_func) (info->stream, "+0x");
832 objdump_print_value (vma - bfd_asymbol_value (sym), info, TRUE);
834 (*info->fprintf_func) (info->stream, ">");
838 /* Print an address (VMA), symbolically if possible.
839 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
842 objdump_print_addr (bfd_vma vma,
843 struct disassemble_info *info,
844 bfd_boolean skip_zeroes)
846 struct objdump_disasm_info *aux;
849 if (sorted_symcount < 1)
851 (*info->fprintf_func) (info->stream, "0x");
852 objdump_print_value (vma, info, skip_zeroes);
856 aux = (struct objdump_disasm_info *) info->application_data;
857 sym = find_symbol_for_address (vma, info, NULL);
858 objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, info,
862 /* Print VMA to INFO. This function is passed to the disassembler
866 objdump_print_address (bfd_vma vma, struct disassemble_info *info)
868 objdump_print_addr (vma, info, ! prefix_addresses);
871 /* Determine of the given address has a symbol associated with it. */
874 objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * info)
878 sym = find_symbol_for_address (vma, info, NULL);
880 return (sym != NULL && (bfd_asymbol_value (sym) == vma));
883 /* Hold the last function name and the last line number we displayed
886 static char *prev_functionname;
887 static unsigned int prev_line;
889 /* We keep a list of all files that we have seen when doing a
890 disassembly with source, so that we know how much of the file to
891 display. This can be important for inlined functions. */
893 struct print_file_list
895 struct print_file_list *next;
896 const char *filename;
902 static struct print_file_list *print_files;
904 /* The number of preceding context lines to show when we start
905 displaying a file for the first time. */
907 #define SHOW_PRECEDING_CONTEXT_LINES (5)
909 /* Tries to open MODNAME, and if successful adds a node to print_files
910 linked list and returns that node. Returns NULL on failure. */
912 static struct print_file_list *
913 try_print_file_open (const char *origname, const char *modname)
915 struct print_file_list *p;
918 f = fopen (modname, "r");
922 if (print_files != NULL && print_files->f != NULL)
924 fclose (print_files->f);
925 print_files->f = NULL;
928 p = xmalloc (sizeof (struct print_file_list));
929 p->filename = origname;
930 p->modname = modname;
933 p->next = print_files;
938 /* If the the source file, as described in the symtab, is not found
939 try to locate it in one of the paths specified with -I
940 If found, add location to print_files linked list. */
942 static struct print_file_list *
943 update_source_path (const char *filename)
945 struct print_file_list *p;
949 if (filename == NULL)
952 p = try_print_file_open (filename, filename);
956 if (include_path_count == 0)
959 /* Get the name of the file. */
960 fname = strrchr (filename, '/');
961 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
963 /* We could have a mixed forward/back slash case. */
964 char *backslash = strrchr (filename, '\\');
965 if (fname == NULL || (backslash != NULL && backslash > fname))
967 if (fname == NULL && filename[0] != '\0' && filename[1] == ':')
968 fname = filename + 1;
976 /* If file exists under a new path, we need to add it to the list
977 so that show_line knows about it. */
978 for (i = 0; i < include_path_count; i++)
980 char *modname = concat (include_paths[i], "/", fname, (const char *) 0);
982 p = try_print_file_open (filename, modname);
992 /* Skip ahead to a given line in a file, optionally printing each
996 skip_to_line (struct print_file_list *p, unsigned int line,
999 while (p->line < line)
1003 if (fgets (buf, sizeof buf, p->f) == NULL)
1013 if (strchr (buf, '\n') != NULL)
1018 /* Show the line number, or the source line, in a disassembly
1022 show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
1024 const char *filename;
1025 const char *functionname;
1028 if (! with_line_numbers && ! with_source_code)
1031 if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename,
1032 &functionname, &line))
1035 if (filename != NULL && *filename == '\0')
1037 if (functionname != NULL && *functionname == '\0')
1038 functionname = NULL;
1040 if (with_line_numbers)
1042 if (functionname != NULL
1043 && (prev_functionname == NULL
1044 || strcmp (functionname, prev_functionname) != 0))
1045 printf ("%s():\n", functionname);
1046 if (line > 0 && line != prev_line)
1047 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
1050 if (with_source_code
1054 struct print_file_list **pp, *p;
1056 for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1057 if (strcmp ((*pp)->filename, filename) == 0)
1063 if (p != print_files)
1067 /* We have reencountered a file name which we saw
1068 earlier. This implies that either we are dumping out
1069 code from an included file, or the same file was
1070 linked in more than once. There are two common cases
1071 of an included file: inline functions in a header
1072 file, and a bison or flex skeleton file. In the
1073 former case we want to just start printing (but we
1074 back up a few lines to give context); in the latter
1075 case we want to continue from where we left off. I
1076 can't think of a good way to distinguish the cases,
1077 so I used a heuristic based on the file name. */
1078 if (strcmp (p->filename + strlen (p->filename) - 2, ".h") != 0)
1082 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1089 p->f = fopen (p->modname, "r");
1093 skip_to_line (p, l, FALSE);
1095 if (print_files->f != NULL)
1097 fclose (print_files->f);
1098 print_files->f = NULL;
1104 skip_to_line (p, line, TRUE);
1106 p->next = print_files;
1112 p = update_source_path (filename);
1118 if (file_start_context)
1121 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1124 skip_to_line (p, l, FALSE);
1126 skip_to_line (p, line, TRUE);
1131 if (functionname != NULL
1132 && (prev_functionname == NULL
1133 || strcmp (functionname, prev_functionname) != 0))
1135 if (prev_functionname != NULL)
1136 free (prev_functionname);
1137 prev_functionname = xmalloc (strlen (functionname) + 1);
1138 strcpy (prev_functionname, functionname);
1141 if (line > 0 && line != prev_line)
1145 /* Pseudo FILE object for strings. */
1153 /* sprintf to a "stream". */
1156 objdump_sprintf (SFILE *f, const char *format, ...)
1163 size_t space = f->alloc - f->pos;
1165 va_start (args, format);
1166 n = vsnprintf (f->buffer + f->pos, space, format, args);
1172 f->alloc = (f->alloc + n) * 2;
1173 f->buffer = xrealloc (f->buffer, f->alloc);
1180 /* Returns TRUE if the specified section should be dumped. */
1183 process_section_p (asection * section)
1190 for (i = 0; i < only_used; i++)
1191 if (strcmp (only [i], section->name) == 0)
1198 /* The number of zeroes we want to see before we start skipping them.
1199 The number is arbitrarily chosen. */
1202 #define SKIP_ZEROES (8)
1205 /* The number of zeroes to skip at the end of a section. If the
1206 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1207 SKIP_ZEROES, they will be disassembled. If there are fewer than
1208 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1209 attempt to avoid disassembling zeroes inserted by section
1212 #ifndef SKIP_ZEROES_AT_END
1213 #define 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 int opb = info->octets_per_byte;
1238 aux = (struct objdump_disasm_info *) info->application_data;
1242 sfile.buffer = xmalloc (sfile.alloc);
1246 octets_per_line = 4;
1248 octets_per_line = 16;
1250 /* Figure out how many characters to skip at the start of an
1251 address, to make the disassembly look nicer. We discard leading
1252 zeroes in chunks of 4, ensuring that there is always a leading
1254 skip_addr_chars = 0;
1255 if (! prefix_addresses)
1263 + bfd_section_size (section->owner, section) / opb));
1265 while (s[0] == '0' && s[1] == '0' && s[2] == '0' && s[3] == '0'
1268 skip_addr_chars += 4;
1273 info->insn_info_valid = 0;
1276 addr_offset = start_offset;
1277 while (addr_offset < stop_offset)
1281 bfd_boolean need_nl = FALSE;
1283 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1285 for (z = addr_offset * opb; z < stop_offset * opb; z++)
1288 if (! disassemble_zeroes
1289 && (info->insn_info_valid == 0
1290 || info->branch_delay_insns == 0)
1291 && (z - addr_offset * opb >= SKIP_ZEROES
1292 || (z == stop_offset * opb &&
1293 z - addr_offset * opb < SKIP_ZEROES_AT_END)))
1297 /* If there are more nonzero octets to follow, we only skip
1298 zeroes in multiples of 4, to try to avoid running over
1299 the start of an instruction which happens to start with
1301 if (z != stop_offset * opb)
1302 z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1304 octets = z - addr_offset * opb;
1314 if (with_line_numbers || with_source_code)
1315 /* The line number tables will refer to unadjusted
1316 section VMAs, so we must undo any VMA modifications
1317 when calling show_line. */
1318 show_line (aux->abfd, section, addr_offset - adjust_section_vma);
1320 if (! prefix_addresses)
1324 bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
1325 for (s = buf + skip_addr_chars; *s == '0'; s++)
1329 printf ("%s:\t", buf + skip_addr_chars);
1333 aux->require_sec = TRUE;
1334 objdump_print_address (section->vma + addr_offset, info);
1335 aux->require_sec = FALSE;
1342 info->fprintf_func = (fprintf_ftype) objdump_sprintf;
1343 info->stream = (FILE *) &sfile;
1344 info->bytes_per_line = 0;
1345 info->bytes_per_chunk = 0;
1347 #ifdef DISASSEMBLER_NEEDS_RELOCS
1348 /* FIXME: This is wrong. It tests the number of octets
1349 in the last instruction, not the current one. */
1350 if (*relppp < relppend
1351 && (**relppp)->address >= rel_offset + addr_offset
1352 && ((**relppp)->address
1353 < rel_offset + addr_offset + octets / opb))
1354 info->flags = INSN_HAS_RELOC;
1359 octets = (*disassemble_fn) (section->vma + addr_offset, info);
1360 info->fprintf_func = (fprintf_ftype) fprintf;
1361 info->stream = stdout;
1362 if (info->bytes_per_line != 0)
1363 octets_per_line = info->bytes_per_line;
1367 printf ("%s\n", sfile.buffer);
1375 octets = octets_per_line;
1376 if (addr_offset + octets / opb > stop_offset)
1377 octets = (stop_offset - addr_offset) * opb;
1379 for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1381 if (ISPRINT (data[j]))
1382 buf[j - addr_offset * opb] = data[j];
1384 buf[j - addr_offset * opb] = '.';
1386 buf[j - addr_offset * opb] = '\0';
1389 if (prefix_addresses
1391 : show_raw_insn >= 0)
1395 /* If ! prefix_addresses and ! wide_output, we print
1396 octets_per_line octets per line. */
1398 if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1399 pb = octets_per_line;
1401 if (info->bytes_per_chunk)
1402 bpc = info->bytes_per_chunk;
1406 for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1409 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1411 for (k = bpc - 1; k >= 0; k--)
1412 printf ("%02x", (unsigned) data[j + k]);
1417 for (k = 0; k < bpc; k++)
1418 printf ("%02x", (unsigned) data[j + k]);
1423 for (; pb < octets_per_line; pb += bpc)
1427 for (k = 0; k < bpc; k++)
1432 /* Separate raw data from instruction by extra space. */
1442 printf ("%s", 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 - rel_offset + q->address,
1509 printf (": %s\t", q->howto->name);
1511 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1512 printf ("*unknown*");
1515 const char *sym_name;
1517 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1518 if (sym_name != NULL && *sym_name != '\0')
1519 objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
1524 sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1525 sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1526 if (sym_name == NULL || *sym_name == '\0')
1527 sym_name = "*unknown*";
1528 printf ("%s", sym_name);
1535 objdump_print_value (q->addend, info, TRUE);
1547 addr_offset += octets / opb;
1550 free (sfile.buffer);
1554 disassemble_section (bfd *abfd, asection *section, void *info)
1556 struct disassemble_info * pinfo = (struct disassemble_info *) info;
1557 struct objdump_disasm_info * paux;
1558 unsigned int opb = pinfo->octets_per_byte;
1559 bfd_byte * data = NULL;
1560 bfd_size_type datasize = 0;
1561 arelent ** rel_pp = NULL;
1562 arelent ** rel_ppstart = NULL;
1563 arelent ** rel_ppend;
1564 unsigned long stop_offset;
1565 asymbol * sym = NULL;
1569 unsigned long addr_offset;
1571 /* Sections that do not contain machine
1572 code are not normally disassembled. */
1573 if (! disassemble_all
1575 && (section->flags & SEC_CODE) == 0)
1578 if (! process_section_p (section))
1581 datasize = bfd_get_section_size_before_reloc (section);
1585 /* Decide which set of relocs to use. Load them if necessary. */
1586 paux = (struct objdump_disasm_info *) pinfo->application_data;
1587 if (paux->dynrelbuf)
1589 rel_pp = paux->dynrelbuf;
1590 rel_count = paux->dynrelcount;
1591 /* Dynamic reloc addresses are absolute, non-dynamic are section
1592 relative. REL_OFFSET specifies the reloc address corresponding
1593 to the start of this section. */
1594 rel_offset = section->vma;
1602 if ((section->flags & SEC_RELOC) != 0
1603 #ifndef DISASSEMBLER_NEEDS_RELOCS
1610 relsize = bfd_get_reloc_upper_bound (abfd, section);
1612 bfd_fatal (bfd_get_filename (abfd));
1616 rel_ppstart = rel_pp = xmalloc (relsize);
1617 rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
1619 bfd_fatal (bfd_get_filename (abfd));
1621 /* Sort the relocs by address. */
1622 qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
1627 rel_ppend = rel_pp + rel_count;
1629 data = xmalloc (datasize);
1631 bfd_get_section_contents (abfd, section, data, 0, datasize);
1633 paux->sec = section;
1634 pinfo->buffer = data;
1635 pinfo->buffer_vma = section->vma;
1636 pinfo->buffer_length = datasize;
1637 pinfo->section = section;
1639 if (start_address == (bfd_vma) -1
1640 || start_address < pinfo->buffer_vma)
1643 addr_offset = start_address - pinfo->buffer_vma;
1645 if (stop_address == (bfd_vma) -1)
1646 stop_offset = datasize / opb;
1649 if (stop_address < pinfo->buffer_vma)
1652 stop_offset = stop_address - pinfo->buffer_vma;
1653 if (stop_offset > pinfo->buffer_length / opb)
1654 stop_offset = pinfo->buffer_length / opb;
1657 /* Skip over the relocs belonging to addresses below the
1659 while (rel_pp < rel_ppend
1660 && (*rel_pp)->address < rel_offset + addr_offset)
1663 printf (_("Disassembly of section %s:\n"), section->name);
1665 /* Find the nearest symbol forwards from our current position. */
1666 paux->require_sec = TRUE;
1667 sym = find_symbol_for_address (section->vma + addr_offset, info, &place);
1668 paux->require_sec = FALSE;
1670 /* Disassemble a block of instructions up to the address associated with
1671 the symbol we have just found. Then print the symbol and find the
1672 next symbol on. Repeat until we have disassembled the entire section
1673 or we have reached the end of the address range we are interested in. */
1674 while (addr_offset < stop_offset)
1678 unsigned long nextstop_offset;
1681 addr = section->vma + addr_offset;
1683 if (sym != NULL && bfd_asymbol_value (sym) <= addr)
1688 (x < sorted_symcount
1689 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
1693 pinfo->symbols = sorted_syms + place;
1694 pinfo->num_symbols = x - place;
1698 pinfo->symbols = NULL;
1699 pinfo->num_symbols = 0;
1702 if (! prefix_addresses)
1704 pinfo->fprintf_func (pinfo->stream, "\n");
1705 objdump_print_addr_with_sym (abfd, section, sym, addr,
1707 pinfo->fprintf_func (pinfo->stream, ":\n");
1710 if (sym != NULL && bfd_asymbol_value (sym) > addr)
1712 else if (sym == NULL)
1716 #define is_valid_next_sym(SYM) \
1717 ((SYM)->section == section \
1718 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1719 && pinfo->symbol_is_valid (SYM, pinfo))
1721 /* Search forward for the next appropriate symbol in
1722 SECTION. Note that all the symbols are sorted
1723 together into one big array, and that some sections
1724 may have overlapping addresses. */
1725 while (place < sorted_symcount
1726 && ! is_valid_next_sym (sorted_syms [place]))
1729 if (place >= sorted_symcount)
1732 nextsym = sorted_syms[place];
1735 if (sym != NULL && bfd_asymbol_value (sym) > addr)
1736 nextstop_offset = bfd_asymbol_value (sym) - section->vma;
1737 else if (nextsym == NULL)
1738 nextstop_offset = stop_offset;
1740 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
1742 if (nextstop_offset > stop_offset)
1743 nextstop_offset = stop_offset;
1745 /* If a symbol is explicitly marked as being an object
1746 rather than a function, just dump the bytes without
1747 disassembling them. */
1750 || bfd_asymbol_value (sym) > addr
1751 || ((sym->flags & BSF_OBJECT) == 0
1752 && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1754 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1756 || (sym->flags & BSF_FUNCTION) != 0)
1761 disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
1762 addr_offset, nextstop_offset,
1763 rel_offset, &rel_pp, rel_ppend);
1765 addr_offset = nextstop_offset;
1771 if (rel_ppstart != NULL)
1775 /* Disassemble the contents of an object file. */
1778 disassemble_data (bfd *abfd)
1780 struct disassemble_info disasm_info;
1781 struct objdump_disasm_info aux;
1785 prev_functionname = NULL;
1788 /* We make a copy of syms to sort. We don't want to sort syms
1789 because that will screw up the relocs. */
1790 sorted_symcount = symcount ? symcount : dynsymcount;
1791 sorted_syms = xmalloc ((sorted_symcount + synthcount) * sizeof (asymbol *));
1792 memcpy (sorted_syms, symcount ? syms : dynsyms,
1793 sorted_symcount * sizeof (asymbol *));
1795 sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
1797 for (i = 0; i < synthcount; ++i)
1799 sorted_syms[sorted_symcount] = synthsyms + i;
1803 /* Sort the symbols into section and symbol order. */
1804 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
1806 init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
1808 disasm_info.application_data = (void *) &aux;
1810 aux.require_sec = FALSE;
1811 aux.dynrelbuf = NULL;
1812 aux.dynrelcount = 0;
1814 disasm_info.print_address_func = objdump_print_address;
1815 disasm_info.symbol_at_address_func = objdump_symbol_at_address;
1817 if (machine != NULL)
1819 const bfd_arch_info_type *info = bfd_scan_arch (machine);
1822 fatal (_("Can't use supplied machine %s"), machine);
1824 abfd->arch_info = info;
1827 if (endian != BFD_ENDIAN_UNKNOWN)
1829 struct bfd_target *xvec;
1831 xvec = xmalloc (sizeof (struct bfd_target));
1832 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
1833 xvec->byteorder = endian;
1837 /* Use libopcodes to locate a suitable disassembler. */
1838 aux.disassemble_fn = disassembler (abfd);
1839 if (!aux.disassemble_fn)
1841 non_fatal (_("Can't disassemble for architecture %s\n"),
1842 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
1847 disasm_info.flavour = bfd_get_flavour (abfd);
1848 disasm_info.arch = bfd_get_arch (abfd);
1849 disasm_info.mach = bfd_get_mach (abfd);
1850 disasm_info.disassembler_options = disassembler_options;
1851 disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
1853 if (bfd_big_endian (abfd))
1854 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
1855 else if (bfd_little_endian (abfd))
1856 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
1858 /* ??? Aborting here seems too drastic. We could default to big or little
1860 disasm_info.endian = BFD_ENDIAN_UNKNOWN;
1862 /* Allow the target to customize the info structure. */
1863 disassemble_init_for_target (& disasm_info);
1865 /* Pre-load the dynamic relocs if we are going
1866 to be dumping them along with the disassembly. */
1867 if (dump_dynamic_reloc_info)
1869 long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
1872 bfd_fatal (bfd_get_filename (abfd));
1876 aux.dynrelbuf = xmalloc (relsize);
1877 aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
1880 if (aux.dynrelcount < 0)
1881 bfd_fatal (bfd_get_filename (abfd));
1883 /* Sort the relocs by address. */
1884 qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
1889 bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
1891 if (aux.dynrelbuf != NULL)
1892 free (aux.dynrelbuf);
1896 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
1897 it. Return NULL on failure. */
1900 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
1906 stabsect = bfd_get_section_by_name (abfd, sect_name);
1907 if (stabsect == NULL)
1909 printf (_("No %s section present\n\n"), sect_name);
1913 size = bfd_section_size (abfd, stabsect);
1914 contents = xmalloc (size);
1916 if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
1918 non_fatal (_("Reading %s section of %s failed: %s"),
1919 sect_name, bfd_get_filename (abfd),
1920 bfd_errmsg (bfd_get_error ()));
1931 /* Stabs entries use a 12 byte format:
1932 4 byte string table index
1934 1 byte stab other field
1935 2 byte stab desc field
1937 FIXME: This will have to change for a 64 bit object format. */
1939 #define STRDXOFF (0)
1941 #define OTHEROFF (5)
1944 #define STABSIZE (12)
1946 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1947 using string table section STRSECT_NAME (in `strtab'). */
1950 print_section_stabs (bfd *abfd,
1951 const char *stabsect_name,
1952 unsigned *string_offset_ptr)
1955 unsigned file_string_table_offset = 0;
1956 unsigned next_file_string_table_offset = *string_offset_ptr;
1957 bfd_byte *stabp, *stabs_end;
1960 stabs_end = stabp + stab_size;
1962 printf (_("Contents of %s section:\n\n"), stabsect_name);
1963 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1965 /* Loop through all symbols and print them.
1967 We start the index at -1 because there is a dummy symbol on
1968 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1969 for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
1973 unsigned char type, other;
1974 unsigned short desc;
1977 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
1978 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
1979 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
1980 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
1981 value = bfd_h_get_32 (abfd, stabp + VALOFF);
1983 printf ("\n%-6d ", i);
1984 /* Either print the stab name, or, if unnamed, print its number
1985 again (makes consistent formatting for tools like awk). */
1986 name = bfd_get_stab_name (type);
1988 printf ("%-6s", name);
1989 else if (type == N_UNDF)
1992 printf ("%-6d", type);
1993 printf (" %-6d %-6d ", other, desc);
1994 bfd_printf_vma (abfd, value);
1995 printf (" %-6lu", strx);
1997 /* Symbols with type == 0 (N_UNDF) specify the length of the
1998 string table associated with this file. We use that info
1999 to know how to relocate the *next* file's string table indices. */
2002 file_string_table_offset = next_file_string_table_offset;
2003 next_file_string_table_offset += value;
2007 /* Using the (possibly updated) string table offset, print the
2008 string (if any) associated with this symbol. */
2009 if ((strx + file_string_table_offset) < stabstr_size)
2010 printf (" %s", &strtab[strx + file_string_table_offset]);
2016 *string_offset_ptr = next_file_string_table_offset;
2021 const char * section_name;
2022 const char * string_section_name;
2023 unsigned string_offset;
2028 find_stabs_section (bfd *abfd, asection *section, void *names)
2031 stab_section_names * sought = (stab_section_names *) names;
2033 /* Check for section names for which stabsect_name is a prefix, to
2034 handle .stab.N, etc. */
2035 len = strlen (sought->section_name);
2037 /* If the prefix matches, and the files section name ends with a
2038 nul or a digit, then we match. I.e., we want either an exact
2039 match or a section followed by a number. */
2040 if (strncmp (sought->section_name, section->name, len) == 0
2041 && (section->name[len] == 0
2042 || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2045 strtab = read_section_stabs (abfd, sought->string_section_name,
2050 stabs = read_section_stabs (abfd, section->name, &stab_size);
2052 print_section_stabs (abfd, section->name, &sought->string_offset);
2058 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2060 stab_section_names s;
2062 s.section_name = stabsect_name;
2063 s.string_section_name = strsect_name;
2064 s.string_offset = 0;
2066 bfd_map_over_sections (abfd, find_stabs_section, & s);
2072 /* Dump the any sections containing stabs debugging information. */
2075 dump_stabs (bfd *abfd)
2077 dump_stabs_section (abfd, ".stab", ".stabstr");
2078 dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2079 dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2080 dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2084 dump_bfd_header (bfd *abfd)
2088 printf (_("architecture: %s, "),
2089 bfd_printable_arch_mach (bfd_get_arch (abfd),
2090 bfd_get_mach (abfd)));
2091 printf (_("flags 0x%08x:\n"), abfd->flags);
2093 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2094 PF (HAS_RELOC, "HAS_RELOC");
2095 PF (EXEC_P, "EXEC_P");
2096 PF (HAS_LINENO, "HAS_LINENO");
2097 PF (HAS_DEBUG, "HAS_DEBUG");
2098 PF (HAS_SYMS, "HAS_SYMS");
2099 PF (HAS_LOCALS, "HAS_LOCALS");
2100 PF (DYNAMIC, "DYNAMIC");
2101 PF (WP_TEXT, "WP_TEXT");
2102 PF (D_PAGED, "D_PAGED");
2103 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2104 PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
2105 printf (_("\nstart address 0x"));
2106 bfd_printf_vma (abfd, abfd->start_address);
2112 dump_bfd_private_header (bfd *abfd)
2114 bfd_print_private_bfd_data (abfd, stdout);
2118 /* Display a section in hexadecimal format with associated characters.
2119 Each line prefixed by the zero padded address. */
2122 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2125 bfd_size_type datasize;
2126 bfd_size_type addr_offset;
2127 bfd_size_type start_offset;
2128 bfd_size_type stop_offset;
2129 unsigned int opb = bfd_octets_per_byte (abfd);
2130 /* Bytes per line. */
2131 const int onaline = 16;
2136 if ((section->flags & SEC_HAS_CONTENTS) == 0)
2139 if (! process_section_p (section))
2142 if ((datasize = bfd_section_size (abfd, section)) == 0)
2145 printf (_("Contents of section %s:\n"), section->name);
2147 data = xmalloc (datasize);
2149 bfd_get_section_contents (abfd, section, data, 0, datasize);
2151 /* Compute the address range to display. */
2152 if (start_address == (bfd_vma) -1
2153 || start_address < section->vma)
2156 start_offset = start_address - section->vma;
2158 if (stop_address == (bfd_vma) -1)
2159 stop_offset = datasize / opb;
2162 if (stop_address < section->vma)
2165 stop_offset = stop_address - section->vma;
2167 if (stop_offset > datasize / opb)
2168 stop_offset = datasize / opb;
2173 bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2174 if (strlen (buf) >= sizeof (buf))
2178 while (buf[count] == '0' && buf[count+1] != '\0')
2180 count = strlen (buf) - count;
2184 bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2185 if (strlen (buf) >= sizeof (buf))
2189 while (buf[count] == '0' && buf[count+1] != '\0')
2191 count = strlen (buf) - count;
2195 for (addr_offset = start_offset;
2196 addr_offset < stop_offset; addr_offset += onaline / opb)
2200 bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2201 count = strlen (buf);
2202 if ((size_t) count >= sizeof (buf))
2206 while (count < width)
2211 fputs (buf + count - width, stdout);
2214 for (j = addr_offset * opb;
2215 j < addr_offset * opb + onaline; j++)
2217 if (j < stop_offset * opb)
2218 printf ("%02x", (unsigned) (data[j]));
2226 for (j = addr_offset * opb;
2227 j < addr_offset * opb + onaline; j++)
2229 if (j >= stop_offset * opb)
2232 printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2239 /* Actually display the various requested regions. */
2242 dump_data (bfd *abfd)
2244 bfd_map_over_sections (abfd, dump_section, NULL);
2247 /* Should perhaps share code and display with nm? */
2250 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2260 printf ("DYNAMIC SYMBOL TABLE:\n");
2266 printf ("SYMBOL TABLE:\n");
2270 printf (_("no symbols\n"));
2272 for (count = 0; count < max; count++)
2276 if (*current == NULL)
2277 printf (_("no information for the %ld'th symbol"), count);
2279 else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2280 printf (_("could not determine the type of the %ld'th symbol"),
2285 const char *name = (*current)->name;
2287 if (do_demangle && name != NULL && *name != '\0')
2291 /* If we want to demangle the name, we demangle it
2292 here, and temporarily clobber it while calling
2293 bfd_print_symbol. FIXME: This is a gross hack. */
2294 alloc = demangle (cur_bfd, name);
2295 (*current)->name = alloc;
2296 bfd_print_symbol (cur_bfd, stdout, *current,
2297 bfd_print_symbol_all);
2298 (*current)->name = name;
2302 bfd_print_symbol (cur_bfd, stdout, *current,
2303 bfd_print_symbol_all);
2313 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2316 char *last_filename, *last_functionname;
2317 unsigned int last_line;
2319 /* Get column headers lined up reasonably. */
2327 bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2328 width = strlen (buf) - 7;
2330 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2333 last_filename = NULL;
2334 last_functionname = NULL;
2337 for (p = relpp; relcount && *p != NULL; p++, relcount--)
2340 const char *filename, *functionname;
2342 const char *sym_name;
2343 const char *section_name;
2345 if (start_address != (bfd_vma) -1
2346 && q->address < start_address)
2348 if (stop_address != (bfd_vma) -1
2349 && q->address > stop_address)
2352 if (with_line_numbers
2354 && bfd_find_nearest_line (abfd, sec, syms, q->address,
2355 &filename, &functionname, &line))
2357 if (functionname != NULL
2358 && (last_functionname == NULL
2359 || strcmp (functionname, last_functionname) != 0))
2361 printf ("%s():\n", functionname);
2362 if (last_functionname != NULL)
2363 free (last_functionname);
2364 last_functionname = xstrdup (functionname);
2368 && (line != last_line
2369 || (filename != NULL
2370 && last_filename != NULL
2371 && strcmp (filename, last_filename) != 0)))
2373 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2375 if (last_filename != NULL)
2376 free (last_filename);
2377 if (filename == NULL)
2378 last_filename = NULL;
2380 last_filename = xstrdup (filename);
2384 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2386 sym_name = (*(q->sym_ptr_ptr))->name;
2387 section_name = (*(q->sym_ptr_ptr))->section->name;
2392 section_name = NULL;
2397 bfd_printf_vma (abfd, q->address);
2399 printf (" %-16s ", q->howto->name);
2401 printf (" %-16d ", q->howto->type);
2402 objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
2406 if (section_name == NULL)
2407 section_name = "*unknown*";
2408 bfd_printf_vma (abfd, q->address);
2409 printf (" %-16s [%s]",
2417 bfd_printf_vma (abfd, q->addend);
2425 dump_relocs_in_section (bfd *abfd,
2427 void *dummy ATTRIBUTE_UNUSED)
2433 if ( bfd_is_abs_section (section)
2434 || bfd_is_und_section (section)
2435 || bfd_is_com_section (section)
2436 || (! process_section_p (section))
2437 || ((section->flags & SEC_RELOC) == 0))
2440 relsize = bfd_get_reloc_upper_bound (abfd, section);
2442 bfd_fatal (bfd_get_filename (abfd));
2444 printf ("RELOCATION RECORDS FOR [%s]:", section->name);
2448 printf (" (none)\n\n");
2452 relpp = xmalloc (relsize);
2453 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
2456 bfd_fatal (bfd_get_filename (abfd));
2457 else if (relcount == 0)
2458 printf (" (none)\n\n");
2462 dump_reloc_set (abfd, section, relpp, relcount);
2469 dump_relocs (bfd *abfd)
2471 bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
2475 dump_dynamic_relocs (bfd *abfd)
2481 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2483 bfd_fatal (bfd_get_filename (abfd));
2485 printf ("DYNAMIC RELOCATION RECORDS");
2488 printf (" (none)\n\n");
2491 relpp = xmalloc (relsize);
2492 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2495 bfd_fatal (bfd_get_filename (abfd));
2496 else if (relcount == 0)
2497 printf (" (none)\n\n");
2501 dump_reloc_set (abfd, NULL, relpp, relcount);
2508 /* Creates a table of paths, to search for source files. */
2511 add_include_path (const char *path)
2515 include_path_count++;
2516 include_paths = xrealloc (include_paths,
2517 include_path_count * sizeof (*include_paths));
2518 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2519 if (path[1] == ':' && path[2] == 0)
2520 path = concat (path, ".", (const char *) 0);
2522 include_paths[include_path_count - 1] = path;
2526 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
2528 void *dummy ATTRIBUTE_UNUSED)
2530 section->vma += adjust_section_vma;
2531 section->lma += adjust_section_vma;
2534 /* Dump selected contents of ABFD. */
2537 dump_bfd (bfd *abfd)
2539 /* If we are adjusting section VMA's, change them all now. Changing
2540 the BFD information is a hack. However, we must do it, or
2541 bfd_find_nearest_line will not do the right thing. */
2542 if (adjust_section_vma != 0)
2543 bfd_map_over_sections (abfd, adjust_addresses, NULL);
2545 if (! dump_debugging_tags)
2546 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
2549 print_arelt_descr (stdout, abfd, TRUE);
2550 if (dump_file_header)
2551 dump_bfd_header (abfd);
2552 if (dump_private_headers)
2553 dump_bfd_private_header (abfd);
2554 if (! dump_debugging_tags)
2556 if (dump_section_headers)
2557 dump_headers (abfd);
2559 if (dump_symtab || dump_reloc_info || disassemble || dump_debugging)
2560 syms = slurp_symtab (abfd);
2561 if (dump_dynamic_symtab || dump_dynamic_reloc_info
2562 || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
2563 dynsyms = slurp_dynamic_symtab (abfd);
2564 if (disassemble && dynsymcount > 0)
2566 synthcount = bfd_get_synthetic_symtab (abfd, dynsyms, &synthsyms);
2567 if (synthcount < 0) synthcount = 0;
2571 dump_symbols (abfd, FALSE);
2572 if (dump_dynamic_symtab)
2573 dump_symbols (abfd, TRUE);
2574 if (dump_stab_section_info)
2576 if (dump_reloc_info && ! disassemble)
2578 if (dump_dynamic_reloc_info && ! disassemble)
2579 dump_dynamic_relocs (abfd);
2580 if (dump_section_contents)
2583 disassemble_data (abfd);
2589 dhandle = read_debugging_info (abfd, syms, symcount);
2590 if (dhandle != NULL)
2592 if (! print_debugging_info (stdout, dhandle, abfd, syms, demangle,
2593 dump_debugging_tags ? TRUE : FALSE))
2595 non_fatal (_("%s: printing debugging information failed"),
2596 bfd_get_filename (abfd));
2626 display_bfd (bfd *abfd)
2630 if (bfd_check_format_matches (abfd, bfd_object, &matching))
2636 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2638 nonfatal (bfd_get_filename (abfd));
2639 list_matching_formats (matching);
2644 if (bfd_get_error () != bfd_error_file_not_recognized)
2646 nonfatal (bfd_get_filename (abfd));
2650 if (bfd_check_format_matches (abfd, bfd_core, &matching))
2656 nonfatal (bfd_get_filename (abfd));
2658 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2660 list_matching_formats (matching);
2666 display_file (char *filename, char *target)
2671 if (get_file_size (filename) < 1)
2674 file = bfd_openr (filename, target);
2677 nonfatal (filename);
2681 /* If the file is an archive, process all of its elements. */
2682 if (bfd_check_format (file, bfd_archive))
2684 bfd *last_arfile = NULL;
2686 printf (_("In archive %s:\n"), bfd_get_filename (file));
2689 bfd_set_error (bfd_error_no_error);
2691 arfile = bfd_openr_next_archived_file (file, arfile);
2694 if (bfd_get_error () != bfd_error_no_more_archived_files)
2695 nonfatal (bfd_get_filename (file));
2699 display_bfd (arfile);
2701 if (last_arfile != NULL)
2702 bfd_close (last_arfile);
2703 last_arfile = arfile;
2706 if (last_arfile != NULL)
2707 bfd_close (last_arfile);
2716 main (int argc, char **argv)
2719 char *target = default_target;
2720 bfd_boolean seenflag = FALSE;
2722 #if defined (HAVE_SETLOCALE)
2723 #if defined (HAVE_LC_MESSAGES)
2724 setlocale (LC_MESSAGES, "");
2726 setlocale (LC_CTYPE, "");
2729 bindtextdomain (PACKAGE, LOCALEDIR);
2730 textdomain (PACKAGE);
2732 program_name = *argv;
2733 xmalloc_set_program_name (program_name);
2735 START_PROGRESS (program_name, 0);
2738 set_default_bfd_target ();
2740 while ((c = getopt_long (argc, argv, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeG",
2741 long_options, (int *) 0))
2747 break; /* We've been given a long option. */
2752 if (disassembler_options)
2753 /* Ignore potential memory leak for now. */
2754 disassembler_options = concat (disassembler_options, ",",
2757 disassembler_options = optarg;
2760 if (only_used == only_size)
2763 only = xrealloc (only, only_size * sizeof (char *));
2765 only [only_used++] = optarg;
2768 with_line_numbers = TRUE;
2777 enum demangling_styles style;
2779 style = cplus_demangle_name_to_style (optarg);
2780 if (style == unknown_demangling)
2781 fatal (_("unknown demangling style `%s'"),
2784 cplus_demangle_set_style (style);
2790 case OPTION_ADJUST_VMA:
2791 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
2793 case OPTION_START_ADDRESS:
2794 start_address = parse_vma (optarg, "--start-address");
2796 case OPTION_STOP_ADDRESS:
2797 stop_address = parse_vma (optarg, "--stop-address");
2800 if (strcmp (optarg, "B") == 0)
2801 endian = BFD_ENDIAN_BIG;
2802 else if (strcmp (optarg, "L") == 0)
2803 endian = BFD_ENDIAN_LITTLE;
2806 non_fatal (_("unrecognized -E option"));
2811 if (strncmp (optarg, "big", strlen (optarg)) == 0)
2812 endian = BFD_ENDIAN_BIG;
2813 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
2814 endian = BFD_ENDIAN_LITTLE;
2817 non_fatal (_("unrecognized --endian type `%s'"), optarg);
2823 dump_file_header = TRUE;
2827 formats_info = TRUE;
2831 add_include_path (optarg);
2834 dump_private_headers = TRUE;
2838 dump_private_headers = TRUE;
2840 dump_reloc_info = TRUE;
2841 dump_file_header = TRUE;
2842 dump_ar_hdrs = TRUE;
2843 dump_section_headers = TRUE;
2851 dump_dynamic_symtab = TRUE;
2859 disassemble_zeroes = TRUE;
2863 disassemble_all = TRUE;
2868 with_source_code = TRUE;
2877 dump_debugging_tags = 1;
2882 dump_stab_section_info = TRUE;
2886 dump_section_contents = TRUE;
2890 dump_reloc_info = TRUE;
2894 dump_dynamic_reloc_info = TRUE;
2898 dump_ar_hdrs = TRUE;
2902 dump_section_headers = TRUE;
2910 show_version = TRUE;
2920 print_version ("objdump");
2926 exit_status = display_info ();
2930 display_file ("a.out", target);
2932 for (; optind < argc;)
2933 display_file (argv[optind++], target);
2936 END_PROGRESS (program_name);