1 /* objdump.c -- dump information about an object file.
2 Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
3 Free Software Foundation, Inc.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
27 #include "libiberty.h"
32 /* Internal headers for the ELF .stab-dump code - sorry. */
33 #define BYTES_IN_WORD 32
34 #include "aout/aout64.h"
36 #ifdef NEED_DECLARATION_FPRINTF
37 /* This is needed by INIT_DISASSEMBLE_INFO. */
38 extern int fprintf PARAMS ((FILE *, const char *, ...));
42 static int exit_status = 0;
44 static char *default_target = NULL; /* default at runtime */
46 static int show_version = 0; /* show the version number */
47 static int dump_section_contents; /* -s */
48 static int dump_section_headers; /* -h */
49 static boolean dump_file_header; /* -f */
50 static int dump_symtab; /* -t */
51 static int dump_dynamic_symtab; /* -T */
52 static int dump_reloc_info; /* -r */
53 static int dump_dynamic_reloc_info; /* -R */
54 static int dump_ar_hdrs; /* -a */
55 static int dump_private_headers; /* -p */
56 static int prefix_addresses; /* --prefix-addresses */
57 static int with_line_numbers; /* -l */
58 static boolean with_source_code; /* -S */
59 static int show_raw_insn; /* --show-raw-insn */
60 static int dump_stab_section_info; /* --stabs */
61 static int do_demangle; /* -C, --demangle */
62 static boolean disassemble; /* -d */
63 static boolean disassemble_all; /* -D */
64 static int disassemble_zeroes; /* --disassemble-zeroes */
65 static boolean formats_info; /* -i */
66 static char *only; /* -j secname */
67 static int wide_output; /* -w */
68 static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
69 static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */
70 static int dump_debugging; /* --debugging */
71 static bfd_vma adjust_section_vma = 0; /* --adjust-vma */
72 static int file_start_context = 0; /* --file-start-context */
74 /* Extra info to pass to the disassembler address printing function. */
75 struct objdump_disasm_info {
81 /* Architecture to disassemble for, or default if NULL. */
82 static char *machine = (char *) NULL;
84 /* Target specific options to the disassembler. */
85 static char *disassembler_options = (char *) NULL;
87 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
88 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
90 /* The symbol table. */
91 static asymbol **syms;
93 /* Number of symbols in `syms'. */
94 static long symcount = 0;
96 /* The sorted symbol table. */
97 static asymbol **sorted_syms;
99 /* Number of symbols in `sorted_syms'. */
100 static long sorted_symcount = 0;
102 /* The dynamic symbol table. */
103 static asymbol **dynsyms;
105 /* Number of symbols in `dynsyms'. */
106 static long dynsymcount = 0;
108 /* Static declarations. */
111 usage PARAMS ((FILE *, int));
114 nonfatal PARAMS ((const char *));
117 display_file PARAMS ((char *filename, char *target));
120 dump_section_header PARAMS ((bfd *, asection *, PTR));
123 dump_headers PARAMS ((bfd *));
126 dump_data PARAMS ((bfd *abfd));
129 dump_relocs PARAMS ((bfd *abfd));
132 dump_dynamic_relocs PARAMS ((bfd * abfd));
135 dump_reloc_set PARAMS ((bfd *, asection *, arelent **, long));
138 dump_symbols PARAMS ((bfd *abfd, boolean dynamic));
141 dump_bfd_header PARAMS ((bfd *));
144 dump_bfd_private_header PARAMS ((bfd *));
147 display_bfd PARAMS ((bfd *abfd));
150 display_target_list PARAMS ((void));
153 display_info_table PARAMS ((int, int));
156 display_target_tables PARAMS ((void));
159 display_info PARAMS ((void));
162 objdump_print_value PARAMS ((bfd_vma, struct disassemble_info *, boolean));
165 objdump_print_symname PARAMS ((bfd *, struct disassemble_info *, asymbol *));
168 find_symbol_for_address PARAMS ((bfd *, asection *, bfd_vma, boolean, long *));
171 objdump_print_addr_with_sym PARAMS ((bfd *, asection *, asymbol *, bfd_vma,
172 struct disassemble_info *, boolean));
175 objdump_print_addr PARAMS ((bfd_vma, struct disassemble_info *, boolean));
178 objdump_print_address PARAMS ((bfd_vma, struct disassemble_info *));
181 show_line PARAMS ((bfd *, asection *, bfd_vma));
184 disassemble_bytes PARAMS ((struct disassemble_info *, disassembler_ftype,
185 boolean, bfd_byte *, bfd_vma, bfd_vma,
186 arelent ***, arelent **));
189 disassemble_data PARAMS ((bfd *));
192 endian_string PARAMS ((enum bfd_endian));
195 slurp_symtab PARAMS ((bfd *));
198 slurp_dynamic_symtab PARAMS ((bfd *));
201 remove_useless_symbols PARAMS ((asymbol **, long));
204 compare_symbols PARAMS ((const PTR, const PTR));
207 compare_relocs PARAMS ((const PTR, const PTR));
210 dump_stabs PARAMS ((bfd *));
213 read_section_stabs PARAMS ((bfd *, const char *, const char *));
216 print_section_stabs PARAMS ((bfd *, const char *, const char *));
219 usage (stream, status)
223 fprintf (stream, _("Usage: %s OPTION... FILE...\n"), program_name);
224 fprintf (stream, _("Display information from object FILE.\n"));
225 fprintf (stream, _("\n At least one of the following switches must be given:\n"));
226 fprintf (stream, _("\
227 -a, --archive-headers Display archive header information\n\
228 -f, --file-headers Display the contents of the overall file header\n\
229 -p, --private-headers Display object format specific file header contents\n\
230 -h, --[section-]headers Display the contents of the section headers\n\
231 -x, --all-headers Display the contents of all headers\n\
232 -d, --disassemble Display assembler contents of executable sections\n\
233 -D, --disassemble-all Display assembler contents of all sections\n\
234 -S, --source Intermix source code with disassembly\n\
235 -s, --full-contents Display the full contents of all sections requested\n\
236 -g, --debugging Display debug information in object file\n\
237 -G, --stabs Display (in raw form) any STABS info in the file\n\
238 -t, --syms Display the contents of the symbol table(s)\n\
239 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
240 -r, --reloc Display the relocation entries in the file\n\
241 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
242 -V, --version Display this program's version number\n\
243 -i, --info List object formats and architectures supported\n\
244 -H, --help Display this information\n\
248 fprintf (stream, _("\n The following switches are optional:\n"));
249 fprintf (stream, _("\
250 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
251 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
252 -j, --section=NAME Only display information for section NAME\n\
253 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
254 -EB --endian=big Assume big endian format when disassembling\n\
255 -EL --endian=little Assume little endian format when disassembling\n\
256 --file-start-context Include context from start of file (with -S)\n\
257 -l, --line-numbers Include line numbers and filenames in output\n\
258 -C, --demangle Decode mangled/processed symbol names\n\
259 -w, --wide Format output for more than 80 columns\n\
260 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
261 --start-address=ADDR Only process data whoes address is >= ADDR\n\
262 --stop-address=ADDR Only process data whoes address is <= ADDR\n\
263 --prefix-addresses Print complete address alongside disassembly\n\
264 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
265 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
267 list_supported_targets (program_name, stream);
269 disassembler_usage (stream);
272 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
276 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
278 #define OPTION_ENDIAN (150)
279 #define OPTION_START_ADDRESS (OPTION_ENDIAN + 1)
280 #define OPTION_STOP_ADDRESS (OPTION_START_ADDRESS + 1)
281 #define OPTION_ADJUST_VMA (OPTION_STOP_ADDRESS + 1)
283 static struct option long_options[]=
285 {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
286 {"all-headers", no_argument, NULL, 'x'},
287 {"private-headers", no_argument, NULL, 'p'},
288 {"architecture", required_argument, NULL, 'm'},
289 {"archive-headers", no_argument, NULL, 'a'},
290 {"debugging", no_argument, NULL, 'g'},
291 {"demangle", no_argument, NULL, 'C'},
292 {"disassemble", no_argument, NULL, 'd'},
293 {"disassemble-all", no_argument, NULL, 'D'},
294 {"disassembler-options", required_argument, NULL, 'M'},
295 {"disassemble-zeroes", no_argument, NULL, 'z'},
296 {"dynamic-reloc", no_argument, NULL, 'R'},
297 {"dynamic-syms", no_argument, NULL, 'T'},
298 {"endian", required_argument, NULL, OPTION_ENDIAN},
299 {"file-headers", no_argument, NULL, 'f'},
300 {"file-start-context", no_argument, &file_start_context, 1},
301 {"full-contents", no_argument, NULL, 's'},
302 {"headers", no_argument, NULL, 'h'},
303 {"help", no_argument, NULL, 'H'},
304 {"info", no_argument, NULL, 'i'},
305 {"line-numbers", no_argument, NULL, 'l'},
306 {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
307 {"prefix-addresses", no_argument, &prefix_addresses, 1},
308 {"reloc", no_argument, NULL, 'r'},
309 {"section", required_argument, NULL, 'j'},
310 {"section-headers", no_argument, NULL, 'h'},
311 {"show-raw-insn", no_argument, &show_raw_insn, 1},
312 {"source", no_argument, NULL, 'S'},
313 {"stabs", no_argument, NULL, 'G'},
314 {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
315 {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
316 {"syms", no_argument, NULL, 't'},
317 {"target", required_argument, NULL, 'b'},
318 {"version", no_argument, NULL, 'V'},
319 {"wide", no_argument, NULL, 'w'},
320 {0, no_argument, 0, 0}
332 dump_section_header (abfd, section, ignored)
333 bfd *abfd ATTRIBUTE_UNUSED;
335 PTR ignored ATTRIBUTE_UNUSED;
338 unsigned int opb = bfd_octets_per_byte (abfd);
340 printf ("%3d %-13s %08lx ", section->index,
341 bfd_get_section_name (abfd, section),
342 (unsigned long) bfd_section_size (abfd, section) / opb);
343 printf_vma (bfd_get_section_vma (abfd, section));
345 printf_vma (section->lma);
346 printf (" %08lx 2**%u", section->filepos,
347 bfd_get_section_alignment (abfd, section));
353 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
355 PF (SEC_HAS_CONTENTS, "CONTENTS");
356 PF (SEC_ALLOC, "ALLOC");
357 PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
358 PF (SEC_CONSTRUCTOR_TEXT, "CONSTRUCTOR TEXT");
359 PF (SEC_CONSTRUCTOR_DATA, "CONSTRUCTOR DATA");
360 PF (SEC_CONSTRUCTOR_BSS, "CONSTRUCTOR BSS");
361 PF (SEC_LOAD, "LOAD");
362 PF (SEC_RELOC, "RELOC");
364 PF (SEC_BALIGN, "BALIGN");
366 PF (SEC_READONLY, "READONLY");
367 PF (SEC_CODE, "CODE");
368 PF (SEC_DATA, "DATA");
370 PF (SEC_DEBUGGING, "DEBUGGING");
371 PF (SEC_NEVER_LOAD, "NEVER_LOAD");
372 PF (SEC_EXCLUDE, "EXCLUDE");
373 PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
374 PF (SEC_BLOCK, "BLOCK");
375 PF (SEC_CLINK, "CLINK");
376 PF (SEC_SMALL_DATA, "SMALL_DATA");
377 PF (SEC_SHARED, "SHARED");
379 if ((section->flags & SEC_LINK_ONCE) != 0)
383 switch (section->flags & SEC_LINK_DUPLICATES)
387 case SEC_LINK_DUPLICATES_DISCARD:
388 ls = "LINK_ONCE_DISCARD";
390 case SEC_LINK_DUPLICATES_ONE_ONLY:
391 ls = "LINK_ONCE_ONE_ONLY";
393 case SEC_LINK_DUPLICATES_SAME_SIZE:
394 ls = "LINK_ONCE_SAME_SIZE";
396 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
397 ls = "LINK_ONCE_SAME_CONTENTS";
400 printf ("%s%s", comma, ls);
402 if (section->comdat != NULL)
403 printf (" (COMDAT %s %ld)", section->comdat->name,
404 section->comdat->symbol);
417 printf (_("Sections:\n"));
420 printf (_("Idx Name Size VMA LMA File off Algn"));
422 printf (_("Idx Name Size VMA LMA File off Algn"));
426 printf (_(" Flags"));
429 bfd_map_over_sections (abfd, dump_section_header, (PTR) NULL);
436 asymbol **sy = (asymbol **) NULL;
439 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
441 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
446 storage = bfd_get_symtab_upper_bound (abfd);
448 bfd_fatal (bfd_get_filename (abfd));
452 sy = (asymbol **) xmalloc (storage);
454 symcount = bfd_canonicalize_symtab (abfd, sy);
456 bfd_fatal (bfd_get_filename (abfd));
458 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
462 /* Read in the dynamic symbols. */
465 slurp_dynamic_symtab (abfd)
468 asymbol **sy = (asymbol **) NULL;
471 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
474 if (!(bfd_get_file_flags (abfd) & DYNAMIC))
476 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
481 bfd_fatal (bfd_get_filename (abfd));
486 sy = (asymbol **) xmalloc (storage);
488 dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
490 bfd_fatal (bfd_get_filename (abfd));
491 if (dynsymcount == 0)
492 non_fatal (_("%s: No dynamic symbols"), bfd_get_filename (abfd));
496 /* Filter out (in place) symbols that are useless for disassembly.
497 COUNT is the number of elements in SYMBOLS.
498 Return the number of useful symbols. */
501 remove_useless_symbols (symbols, count)
505 register asymbol **in_ptr = symbols, **out_ptr = symbols;
509 asymbol *sym = *in_ptr++;
511 if (sym->name == NULL || sym->name[0] == '\0')
513 if (sym->flags & (BSF_DEBUGGING))
515 if (bfd_is_und_section (sym->section)
516 || bfd_is_com_section (sym->section))
521 return out_ptr - symbols;
524 /* Sort symbols into value order. */
527 compare_symbols (ap, bp)
531 const asymbol *a = *(const asymbol **)ap;
532 const asymbol *b = *(const asymbol **)bp;
536 flagword aflags, bflags;
538 if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
540 else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
543 if (a->section > b->section)
545 else if (a->section < b->section)
548 an = bfd_asymbol_name (a);
549 bn = bfd_asymbol_name (b);
553 /* The symbols gnu_compiled and gcc2_compiled convey no real
554 information, so put them after other symbols with the same value. */
556 af = (strstr (an, "gnu_compiled") != NULL
557 || strstr (an, "gcc2_compiled") != NULL);
558 bf = (strstr (bn, "gnu_compiled") != NULL
559 || strstr (bn, "gcc2_compiled") != NULL);
566 /* We use a heuristic for the file name, to try to sort it after
567 more useful symbols. It may not work on non Unix systems, but it
568 doesn't really matter; the only difference is precisely which
569 symbol names get printed. */
571 #define file_symbol(s, sn, snl) \
572 (((s)->flags & BSF_FILE) != 0 \
573 || ((sn)[(snl) - 2] == '.' \
574 && ((sn)[(snl) - 1] == 'o' \
575 || (sn)[(snl) - 1] == 'a')))
577 af = file_symbol (a, an, anl);
578 bf = file_symbol (b, bn, bnl);
585 /* Try to sort global symbols before local symbols before function
586 symbols before debugging symbols. */
591 if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
593 if ((aflags & BSF_DEBUGGING) != 0)
598 if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
600 if ((aflags & BSF_FUNCTION) != 0)
605 if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
607 if ((aflags & BSF_LOCAL) != 0)
612 if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
614 if ((aflags & BSF_GLOBAL) != 0)
620 /* Symbols that start with '.' might be section names, so sort them
621 after symbols that don't start with '.'. */
622 if (an[0] == '.' && bn[0] != '.')
624 if (an[0] != '.' && bn[0] == '.')
627 /* Finally, if we can't distinguish them in any other way, try to
628 get consistent results by sorting the symbols by name. */
629 return strcmp (an, bn);
632 /* Sort relocs into address order. */
635 compare_relocs (ap, bp)
639 const arelent *a = *(const arelent **)ap;
640 const arelent *b = *(const arelent **)bp;
642 if (a->address > b->address)
644 else if (a->address < b->address)
647 /* So that associated relocations tied to the same address show up
648 in the correct order, we don't do any further sorting. */
657 /* Print VMA to STREAM. If SKIP_ZEROES is true, omit leading zeroes. */
660 objdump_print_value (vma, info, skip_zeroes)
662 struct disassemble_info *info;
668 sprintf_vma (buf, vma);
673 for (p = buf; *p == '0'; ++p)
678 (*info->fprintf_func) (info->stream, "%s", p);
681 /* Print the name of a symbol. */
684 objdump_print_symname (abfd, info, sym)
686 struct disassemble_info *info;
694 name = bfd_asymbol_name (sym);
695 if (! do_demangle || name[0] == '\0')
699 /* Demangle the name. */
700 if (bfd_get_symbol_leading_char (abfd) == name[0])
703 alloc = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS);
711 (*info->fprintf_func) (info->stream, "%s", print);
713 printf ("%s", print);
719 /* Locate a symbol given a bfd, a section, and a VMA. If REQUIRE_SEC
720 is true, then always require the symbol to be in the section. This
721 returns NULL if there is no suitable symbol. If PLACE is not NULL,
722 then *PLACE is set to the index of the symbol in sorted_syms. */
725 find_symbol_for_address (abfd, sec, vma, require_sec, place)
732 /* @@ Would it speed things up to cache the last two symbols returned,
733 and maybe their address ranges? For many processors, only one memory
734 operand can be present at a time, so the 2-entry cache wouldn't be
735 constantly churned by code doing heavy memory accesses. */
737 /* Indices in `sorted_syms'. */
739 long max = sorted_symcount;
741 unsigned int opb = bfd_octets_per_byte (abfd);
743 if (sorted_symcount < 1)
746 /* Perform a binary search looking for the closest symbol to the
747 required value. We are searching the range (min, max]. */
748 while (min + 1 < max)
752 thisplace = (max + min) / 2;
753 sym = sorted_syms[thisplace];
755 if (bfd_asymbol_value (sym) > vma)
757 else if (bfd_asymbol_value (sym) < vma)
766 /* The symbol we want is now in min, the low end of the range we
767 were searching. If there are several symbols with the same
768 value, we want the first one. */
771 && (bfd_asymbol_value (sorted_syms[thisplace])
772 == bfd_asymbol_value (sorted_syms[thisplace - 1])))
775 /* If the file is relocateable, and the symbol could be from this
776 section, prefer a symbol from this section over symbols from
777 others, even if the other symbol's value might be closer.
779 Note that this may be wrong for some symbol references if the
780 sections have overlapping memory ranges, but in that case there's
781 no way to tell what's desired without looking at the relocation
784 if (sorted_syms[thisplace]->section != sec
786 || ((abfd->flags & HAS_RELOC) != 0
787 && vma >= bfd_get_section_vma (abfd, sec)
788 && vma < (bfd_get_section_vma (abfd, sec)
789 + bfd_section_size (abfd, sec) / opb))))
793 for (i = thisplace + 1; i < sorted_symcount; i++)
795 if (bfd_asymbol_value (sorted_syms[i])
796 != bfd_asymbol_value (sorted_syms[thisplace]))
802 if (sorted_syms[i]->section == sec
804 || sorted_syms[i - 1]->section != sec
805 || (bfd_asymbol_value (sorted_syms[i])
806 != bfd_asymbol_value (sorted_syms[i - 1]))))
813 if (sorted_syms[thisplace]->section != sec)
815 /* We didn't find a good symbol with a smaller value.
816 Look for one with a larger value. */
817 for (i = thisplace + 1; i < sorted_symcount; i++)
819 if (sorted_syms[i]->section == sec)
827 if (sorted_syms[thisplace]->section != sec
829 || ((abfd->flags & HAS_RELOC) != 0
830 && vma >= bfd_get_section_vma (abfd, sec)
831 && vma < (bfd_get_section_vma (abfd, sec)
832 + bfd_section_size (abfd, sec)))))
834 /* There is no suitable symbol. */
842 return sorted_syms[thisplace];
845 /* Print an address to INFO symbolically. */
848 objdump_print_addr_with_sym (abfd, sec, sym, vma, info, skip_zeroes)
853 struct disassemble_info *info;
856 objdump_print_value (vma, info, skip_zeroes);
862 (*info->fprintf_func) (info->stream, " <%s",
863 bfd_get_section_name (abfd, sec));
864 secaddr = bfd_get_section_vma (abfd, sec);
867 (*info->fprintf_func) (info->stream, "-0x");
868 objdump_print_value (secaddr - vma, info, true);
870 else if (vma > secaddr)
872 (*info->fprintf_func) (info->stream, "+0x");
873 objdump_print_value (vma - secaddr, info, true);
875 (*info->fprintf_func) (info->stream, ">");
879 (*info->fprintf_func) (info->stream, " <");
880 objdump_print_symname (abfd, info, sym);
881 if (bfd_asymbol_value (sym) > vma)
883 (*info->fprintf_func) (info->stream, "-0x");
884 objdump_print_value (bfd_asymbol_value (sym) - vma, info, true);
886 else if (vma > bfd_asymbol_value (sym))
888 (*info->fprintf_func) (info->stream, "+0x");
889 objdump_print_value (vma - bfd_asymbol_value (sym), info, true);
891 (*info->fprintf_func) (info->stream, ">");
895 /* Print VMA to INFO, symbolically if possible. If SKIP_ZEROES is
896 true, don't output leading zeroes. */
899 objdump_print_addr (vma, info, skip_zeroes)
901 struct disassemble_info *info;
904 struct objdump_disasm_info *aux;
907 if (sorted_symcount < 1)
909 (*info->fprintf_func) (info->stream, "0x");
910 objdump_print_value (vma, info, skip_zeroes);
914 aux = (struct objdump_disasm_info *) info->application_data;
915 sym = find_symbol_for_address (aux->abfd, aux->sec, vma, aux->require_sec,
917 objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, info,
921 /* Print VMA to INFO. This function is passed to the disassembler
925 objdump_print_address (vma, info)
927 struct disassemble_info *info;
929 objdump_print_addr (vma, info, ! prefix_addresses);
932 /* Determine of the given address has a symbol associated with it. */
935 objdump_symbol_at_address (vma, info)
937 struct disassemble_info * info;
939 struct objdump_disasm_info * aux;
942 /* No symbols - do not bother checking. */
943 if (sorted_symcount < 1)
946 aux = (struct objdump_disasm_info *) info->application_data;
947 sym = find_symbol_for_address (aux->abfd, aux->sec, vma, aux->require_sec,
950 return (sym != NULL && (bfd_asymbol_value (sym) == vma));
953 /* Hold the last function name and the last line number we displayed
956 static char *prev_functionname;
957 static unsigned int prev_line;
959 /* We keep a list of all files that we have seen when doing a
960 dissassembly with source, so that we know how much of the file to
961 display. This can be important for inlined functions. */
963 struct print_file_list
965 struct print_file_list *next;
971 static struct print_file_list *print_files;
973 /* The number of preceding context lines to show when we start
974 displaying a file for the first time. */
976 #define SHOW_PRECEDING_CONTEXT_LINES (5)
978 /* Skip ahead to a given line in a file, optionally printing each
982 skip_to_line PARAMS ((struct print_file_list *, unsigned int, boolean));
985 skip_to_line (p, line, show)
986 struct print_file_list *p;
990 while (p->line < line)
994 if (fgets (buf, sizeof buf, p->f) == NULL)
1004 if (strchr (buf, '\n') != NULL)
1009 /* Show the line number, or the source line, in a dissassembly
1013 show_line (abfd, section, addr_offset)
1016 bfd_vma addr_offset;
1018 CONST char *filename;
1019 CONST char *functionname;
1022 if (! with_line_numbers && ! with_source_code)
1025 if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename,
1026 &functionname, &line))
1029 if (filename != NULL && *filename == '\0')
1031 if (functionname != NULL && *functionname == '\0')
1032 functionname = NULL;
1034 if (with_line_numbers)
1036 if (functionname != NULL
1037 && (prev_functionname == NULL
1038 || strcmp (functionname, prev_functionname) != 0))
1039 printf ("%s():\n", functionname);
1040 if (line > 0 && line != prev_line)
1041 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
1044 if (with_source_code
1048 struct print_file_list **pp, *p;
1050 for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1051 if (strcmp ((*pp)->filename, filename) == 0)
1057 if (p != print_files)
1061 /* We have reencountered a file name which we saw
1062 earlier. This implies that either we are dumping out
1063 code from an included file, or the same file was
1064 linked in more than once. There are two common cases
1065 of an included file: inline functions in a header
1066 file, and a bison or flex skeleton file. In the
1067 former case we want to just start printing (but we
1068 back up a few lines to give context); in the latter
1069 case we want to continue from where we left off. I
1070 can't think of a good way to distinguish the cases,
1071 so I used a heuristic based on the file name. */
1072 if (strcmp (p->filename + strlen (p->filename) - 2, ".h") != 0)
1076 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1083 p->f = fopen (p->filename, "r");
1087 skip_to_line (p, l, false);
1089 if (print_files->f != NULL)
1091 fclose (print_files->f);
1092 print_files->f = NULL;
1098 skip_to_line (p, line, true);
1100 p->next = print_files;
1108 f = fopen (filename, "r");
1113 p = ((struct print_file_list *)
1114 xmalloc (sizeof (struct print_file_list)));
1115 p->filename = xmalloc (strlen (filename) + 1);
1116 strcpy (p->filename, filename);
1120 if (print_files != NULL && print_files->f != NULL)
1122 fclose (print_files->f);
1123 print_files->f = NULL;
1125 p->next = print_files;
1128 if (file_start_context)
1131 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1134 skip_to_line (p, l, false);
1136 skip_to_line (p, line, true);
1141 if (functionname != NULL
1142 && (prev_functionname == NULL
1143 || strcmp (functionname, prev_functionname) != 0))
1145 if (prev_functionname != NULL)
1146 free (prev_functionname);
1147 prev_functionname = xmalloc (strlen (functionname) + 1);
1148 strcpy (prev_functionname, functionname);
1151 if (line > 0 && line != prev_line)
1155 /* Pseudo FILE object for strings. */
1163 /* sprintf to a "stream" */
1166 #ifdef ANSI_PROTOTYPES
1167 objdump_sprintf (SFILE *f, const char *format, ...)
1169 objdump_sprintf (va_alist)
1173 #ifndef ANSI_PROTOTYPES
1181 #ifdef ANSI_PROTOTYPES
1182 va_start (args, format);
1185 f = va_arg (args, SFILE *);
1186 format = va_arg (args, const char *);
1189 vasprintf (&buf, format, args);
1195 fatal (_("Out of virtual memory"));
1200 while ((size_t) ((f->buffer + f->size) - f->current) < n + 1)
1204 curroff = f->current - f->buffer;
1206 f->buffer = xrealloc (f->buffer, f->size);
1207 f->current = f->buffer + curroff;
1210 memcpy (f->current, buf, n);
1212 f->current[0] = '\0';
1219 /* The number of zeroes we want to see before we start skipping them.
1220 The number is arbitrarily chosen. */
1222 #define SKIP_ZEROES (8)
1224 /* The number of zeroes to skip at the end of a section. If the
1225 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1226 SKIP_ZEROES, they will be disassembled. If there are fewer than
1227 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1228 attempt to avoid disassembling zeroes inserted by section
1231 #define SKIP_ZEROES_AT_END (3)
1233 /* Disassemble some data in memory between given values. */
1236 disassemble_bytes (info, disassemble_fn, insns, data,
1237 start_offset, stop_offset, relppp,
1239 struct disassemble_info *info;
1240 disassembler_ftype disassemble_fn;
1243 bfd_vma start_offset;
1244 bfd_vma stop_offset;
1248 struct objdump_disasm_info *aux;
1250 int octets_per_line;
1252 int skip_addr_chars;
1253 bfd_vma addr_offset;
1254 int opb = info->octets_per_byte;
1256 aux = (struct objdump_disasm_info *) info->application_data;
1260 octets_per_line = 4;
1262 octets_per_line = 16;
1264 /* Figure out how many characters to skip at the start of an
1265 address, to make the disassembly look nicer. We discard leading
1266 zeroes in chunks of 4, ensuring that there is always a leading
1268 skip_addr_chars = 0;
1269 if (! prefix_addresses)
1274 sprintf_vma (buf, section->vma +
1275 bfd_section_size (section->owner, section) / opb);
1277 while (s[0] == '0' && s[1] == '0' && s[2] == '0' && s[3] == '0'
1280 skip_addr_chars += 4;
1285 info->insn_info_valid = 0;
1288 addr_offset = start_offset;
1289 while (addr_offset < stop_offset)
1293 boolean need_nl = false;
1295 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1297 for (z = addr_offset * opb; z < stop_offset * opb; z++)
1300 if (! disassemble_zeroes
1301 && (info->insn_info_valid == 0
1302 || info->branch_delay_insns == 0)
1303 && (z - addr_offset * opb >= SKIP_ZEROES
1304 || (z == stop_offset * opb &&
1305 z - addr_offset * opb < SKIP_ZEROES_AT_END)))
1309 /* If there are more nonzero octets to follow, we only skip
1310 zeroes in multiples of 4, to try to avoid running over
1311 the start of an instruction which happens to start with
1313 if (z != stop_offset * opb)
1314 z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1316 octets = z - addr_offset * opb;
1327 if (with_line_numbers || with_source_code)
1328 show_line (aux->abfd, section, addr_offset);
1330 if (! prefix_addresses)
1334 sprintf_vma (buf, section->vma + addr_offset);
1335 for (s = buf + skip_addr_chars; *s == '0'; s++)
1339 printf ("%s:\t", buf + skip_addr_chars);
1343 aux->require_sec = true;
1344 objdump_print_address (section->vma + addr_offset, info);
1345 aux->require_sec = false;
1352 sfile.buffer = xmalloc (sfile.size);
1353 sfile.current = sfile.buffer;
1354 info->fprintf_func = (fprintf_ftype) objdump_sprintf;
1355 info->stream = (FILE *) &sfile;
1356 info->bytes_per_line = 0;
1357 info->bytes_per_chunk = 0;
1359 /* FIXME: This is wrong. It tests the number of octets
1360 in the last instruction, not the current one. */
1361 if (*relppp < relppend
1362 && (**relppp)->address >= addr_offset
1363 && (**relppp)->address < addr_offset + octets / opb)
1364 info->flags = INSN_HAS_RELOC;
1368 octets = (*disassemble_fn) (section->vma + addr_offset, info);
1369 info->fprintf_func = (fprintf_ftype) fprintf;
1370 info->stream = stdout;
1371 if (info->bytes_per_line != 0)
1372 octets_per_line = info->bytes_per_line;
1375 if (sfile.current != sfile.buffer)
1376 printf ("%s\n", sfile.buffer);
1377 free (sfile.buffer);
1385 octets = octets_per_line;
1386 if (addr_offset + octets / opb > stop_offset)
1387 octets = (stop_offset - addr_offset) * opb;
1389 for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1391 if (isprint (data[j]))
1392 buf[j - addr_offset * opb] = data[j];
1394 buf[j - addr_offset * opb] = '.';
1396 buf[j - addr_offset * opb] = '\0';
1399 if (prefix_addresses
1401 : show_raw_insn >= 0)
1405 /* If ! prefix_addresses and ! wide_output, we print
1406 octets_per_line octets per line. */
1408 if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1409 pb = octets_per_line;
1411 if (info->bytes_per_chunk)
1412 bpc = info->bytes_per_chunk;
1416 for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1419 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1421 for (k = bpc - 1; k >= 0; k--)
1422 printf ("%02x", (unsigned) data[j + k]);
1427 for (k = 0; k < bpc; k++)
1428 printf ("%02x", (unsigned) data[j + k]);
1433 for (; pb < octets_per_line; pb += bpc)
1437 for (k = 0; k < bpc; k++)
1442 /* Separate raw data from instruction by extra space. */
1453 printf ("%s", sfile.buffer);
1454 free (sfile.buffer);
1457 if (prefix_addresses
1459 : show_raw_insn >= 0)
1467 j = addr_offset * opb + pb;
1469 sprintf_vma (buf, section->vma + j / opb);
1470 for (s = buf + skip_addr_chars; *s == '0'; s++)
1474 printf ("%s:\t", buf + skip_addr_chars);
1476 pb += octets_per_line;
1479 for (; j < addr_offset * opb + pb; j += bpc)
1483 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1485 for (k = bpc - 1; k >= 0; k--)
1486 printf ("%02x", (unsigned) data[j + k]);
1491 for (k = 0; k < bpc; k++)
1492 printf ("%02x", (unsigned) data[j + k]);
1506 && (section->flags & SEC_RELOC) != 0)
1508 while ((*relppp) < relppend
1509 && ((**relppp)->address >= (bfd_vma) addr_offset
1510 && (**relppp)->address < (bfd_vma) addr_offset + octets / opb))
1521 objdump_print_value (section->vma + q->address, info, true);
1523 printf (": %s\t", q->howto->name);
1525 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1526 printf ("*unknown*");
1529 const char *sym_name;
1531 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1532 if (sym_name != NULL && *sym_name != '\0')
1533 objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
1538 sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1539 sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1540 if (sym_name == NULL || *sym_name == '\0')
1541 sym_name = "*unknown*";
1542 printf ("%s", sym_name);
1549 objdump_print_value (q->addend, info, true);
1561 addr_offset += octets / opb;
1565 /* Disassemble the contents of an object file. */
1568 disassemble_data (abfd)
1571 unsigned long addr_offset;
1572 disassembler_ftype disassemble_fn;
1573 struct disassemble_info disasm_info;
1574 struct objdump_disasm_info aux;
1579 prev_functionname = NULL;
1582 /* We make a copy of syms to sort. We don't want to sort syms
1583 because that will screw up the relocs. */
1584 sorted_syms = (asymbol **) xmalloc (symcount * sizeof (asymbol *));
1585 memcpy (sorted_syms, syms, symcount * sizeof (asymbol *));
1587 sorted_symcount = remove_useless_symbols (sorted_syms, symcount);
1589 /* Sort the symbols into section and symbol order */
1590 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
1592 INIT_DISASSEMBLE_INFO(disasm_info, stdout, fprintf);
1593 disasm_info.application_data = (PTR) &aux;
1595 aux.require_sec = false;
1596 disasm_info.print_address_func = objdump_print_address;
1597 disasm_info.symbol_at_address_func = objdump_symbol_at_address;
1599 if (machine != (char *) NULL)
1601 const bfd_arch_info_type *info = bfd_scan_arch (machine);
1604 fatal (_("Can't use supplied machine %s"), machine);
1606 abfd->arch_info = info;
1609 if (endian != BFD_ENDIAN_UNKNOWN)
1611 struct bfd_target *xvec;
1613 xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target));
1614 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
1615 xvec->byteorder = endian;
1619 disassemble_fn = disassembler (abfd);
1620 if (!disassemble_fn)
1622 non_fatal (_("Can't disassemble for architecture %s\n"),
1623 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
1628 opb = bfd_octets_per_byte (abfd);
1630 disasm_info.flavour = bfd_get_flavour (abfd);
1631 disasm_info.arch = bfd_get_arch (abfd);
1632 disasm_info.mach = bfd_get_mach (abfd);
1633 disasm_info.disassembler_options = disassembler_options;
1634 disasm_info.octets_per_byte = opb;
1636 if (bfd_big_endian (abfd))
1637 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
1638 else if (bfd_little_endian (abfd))
1639 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
1641 /* ??? Aborting here seems too drastic. We could default to big or little
1643 disasm_info.endian = BFD_ENDIAN_UNKNOWN;
1645 for (section = abfd->sections;
1646 section != (asection *) NULL;
1647 section = section->next)
1649 bfd_byte *data = NULL;
1650 bfd_size_type datasize = 0;
1651 arelent **relbuf = NULL;
1652 arelent **relpp = NULL;
1653 arelent **relppend = NULL;
1654 unsigned long stop_offset;
1655 asymbol *sym = NULL;
1658 if ((section->flags & SEC_LOAD) == 0
1659 || (! disassemble_all
1661 && (section->flags & SEC_CODE) == 0))
1663 if (only != (char *) NULL && strcmp (only, section->name) != 0)
1667 && (section->flags & SEC_RELOC) != 0)
1671 relsize = bfd_get_reloc_upper_bound (abfd, section);
1673 bfd_fatal (bfd_get_filename (abfd));
1679 relbuf = (arelent **) xmalloc (relsize);
1680 relcount = bfd_canonicalize_reloc (abfd, section, relbuf, syms);
1682 bfd_fatal (bfd_get_filename (abfd));
1684 /* Sort the relocs by address. */
1685 qsort (relbuf, relcount, sizeof (arelent *), compare_relocs);
1688 relppend = relpp + relcount;
1690 /* Skip over the relocs belonging to addresses below the
1692 if (start_address != (bfd_vma) -1)
1694 while (relpp < relppend
1695 && (*relpp)->address < start_address)
1701 printf (_("Disassembly of section %s:\n"), section->name);
1703 datasize = bfd_get_section_size_before_reloc (section);
1707 data = (bfd_byte *) xmalloc ((size_t) datasize);
1709 bfd_get_section_contents (abfd, section, data, 0, datasize);
1712 disasm_info.buffer = data;
1713 disasm_info.buffer_vma = section->vma;
1714 disasm_info.buffer_length = datasize;
1715 if (start_address == (bfd_vma) -1
1716 || start_address < disasm_info.buffer_vma)
1719 addr_offset = start_address - disasm_info.buffer_vma;
1720 if (stop_address == (bfd_vma) -1)
1721 stop_offset = datasize / opb;
1724 if (stop_address < disasm_info.buffer_vma)
1727 stop_offset = stop_address - disasm_info.buffer_vma;
1728 if (stop_offset > disasm_info.buffer_length / opb)
1729 stop_offset = disasm_info.buffer_length / opb;
1732 sym = find_symbol_for_address (abfd, section, section->vma + addr_offset,
1735 while (addr_offset < stop_offset)
1738 unsigned long nextstop_offset;
1741 if (sym != NULL && bfd_asymbol_value (sym) <= section->vma + addr_offset)
1746 (x < sorted_symcount
1747 && bfd_asymbol_value (sorted_syms[x]) <= section->vma + addr_offset);
1750 disasm_info.symbols = & sorted_syms[place];
1751 disasm_info.num_symbols = x - place;
1754 disasm_info.symbols = NULL;
1756 if (! prefix_addresses)
1759 objdump_print_addr_with_sym (abfd, section, sym,
1760 section->vma + addr_offset,
1766 if (sym != NULL && bfd_asymbol_value (sym) > section->vma + addr_offset)
1768 else if (sym == NULL)
1772 /* Search forward for the next appropriate symbol in
1773 SECTION. Note that all the symbols are sorted
1774 together into one big array, and that some sections
1775 may have overlapping addresses. */
1776 while (place < sorted_symcount
1777 && (sorted_syms[place]->section != section
1778 || (bfd_asymbol_value (sorted_syms[place])
1779 <= bfd_asymbol_value (sym))))
1781 if (place >= sorted_symcount)
1784 nextsym = sorted_syms[place];
1787 if (sym != NULL && bfd_asymbol_value (sym) > section->vma + addr_offset)
1789 nextstop_offset = bfd_asymbol_value (sym) - section->vma;
1790 if (nextstop_offset > stop_offset)
1791 nextstop_offset = stop_offset;
1793 else if (nextsym == NULL)
1794 nextstop_offset = stop_offset;
1797 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
1798 if (nextstop_offset > stop_offset)
1799 nextstop_offset = stop_offset;
1802 /* If a symbol is explicitly marked as being an object
1803 rather than a function, just dump the bytes without
1804 disassembling them. */
1807 || bfd_asymbol_value (sym) > section->vma + addr_offset
1808 || ((sym->flags & BSF_OBJECT) == 0
1809 && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1811 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1813 || (sym->flags & BSF_FUNCTION) != 0)
1818 disassemble_bytes (&disasm_info, disassemble_fn, insns, data,
1819 addr_offset, nextstop_offset, &relpp, relppend);
1821 addr_offset = nextstop_offset;
1833 /* Define a table of stab values and print-strings. We wish the initializer
1834 could be a direct-mapped table, but instead we build one the first
1837 static void dump_section_stabs PARAMS ((bfd *abfd, char *stabsect_name,
1838 char *strsect_name));
1840 /* Dump the stabs sections from an object file that has a section that
1841 uses Sun stabs encoding. */
1847 dump_section_stabs (abfd, ".stab", ".stabstr");
1848 dump_section_stabs (abfd, ".stab.excl", ".stab.exclstr");
1849 dump_section_stabs (abfd, ".stab.index", ".stab.indexstr");
1850 dump_section_stabs (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1853 static bfd_byte *stabs;
1854 static bfd_size_type stab_size;
1856 static char *strtab;
1857 static bfd_size_type stabstr_size;
1859 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1860 and string table section STRSECT_NAME into `strtab'.
1861 If the section exists and was read, allocate the space and return true.
1862 Otherwise return false. */
1865 read_section_stabs (abfd, stabsect_name, strsect_name)
1867 const char *stabsect_name;
1868 const char *strsect_name;
1870 asection *stabsect, *stabstrsect;
1872 stabsect = bfd_get_section_by_name (abfd, stabsect_name);
1875 printf (_("No %s section present\n\n"), stabsect_name);
1879 stabstrsect = bfd_get_section_by_name (abfd, strsect_name);
1880 if (0 == stabstrsect)
1882 non_fatal (_("%s has no %s section"),
1883 bfd_get_filename (abfd), strsect_name);
1888 stab_size = bfd_section_size (abfd, stabsect);
1889 stabstr_size = bfd_section_size (abfd, stabstrsect);
1891 stabs = (bfd_byte *) xmalloc (stab_size);
1892 strtab = (char *) xmalloc (stabstr_size);
1894 if (! bfd_get_section_contents (abfd, stabsect, (PTR) stabs, 0, stab_size))
1896 non_fatal (_("Reading %s section of %s failed: %s"),
1897 stabsect_name, bfd_get_filename (abfd),
1898 bfd_errmsg (bfd_get_error ()));
1905 if (! bfd_get_section_contents (abfd, stabstrsect, (PTR) strtab, 0,
1908 non_fatal (_("Reading %s section of %s failed: %s\n"),
1909 strsect_name, bfd_get_filename (abfd),
1910 bfd_errmsg (bfd_get_error ()));
1920 /* Stabs entries use a 12 byte format:
1921 4 byte string table index
1923 1 byte stab other field
1924 2 byte stab desc field
1926 FIXME: This will have to change for a 64 bit object format. */
1928 #define STRDXOFF (0)
1930 #define OTHEROFF (5)
1933 #define STABSIZE (12)
1935 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1936 using string table section STRSECT_NAME (in `strtab'). */
1939 print_section_stabs (abfd, stabsect_name, strsect_name)
1941 const char *stabsect_name;
1942 const char *strsect_name ATTRIBUTE_UNUSED;
1945 unsigned file_string_table_offset = 0, next_file_string_table_offset = 0;
1946 bfd_byte *stabp, *stabs_end;
1949 stabs_end = stabp + stab_size;
1951 printf (_("Contents of %s section:\n\n"), stabsect_name);
1952 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1954 /* Loop through all symbols and print them.
1956 We start the index at -1 because there is a dummy symbol on
1957 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1959 for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
1963 unsigned char type, other;
1964 unsigned short desc;
1967 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
1968 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
1969 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
1970 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
1971 value = bfd_h_get_32 (abfd, stabp + VALOFF);
1973 printf ("\n%-6d ", i);
1974 /* Either print the stab name, or, if unnamed, print its number
1975 again (makes consistent formatting for tools like awk). */
1976 name = bfd_get_stab_name (type);
1978 printf ("%-6s", name);
1979 else if (type == N_UNDF)
1982 printf ("%-6d", type);
1983 printf (" %-6d %-6d ", other, desc);
1985 printf (" %-6lu", strx);
1987 /* Symbols with type == 0 (N_UNDF) specify the length of the
1988 string table associated with this file. We use that info
1989 to know how to relocate the *next* file's string table indices. */
1993 file_string_table_offset = next_file_string_table_offset;
1994 next_file_string_table_offset += value;
1998 /* Using the (possibly updated) string table offset, print the
1999 string (if any) associated with this symbol. */
2001 if ((strx + file_string_table_offset) < stabstr_size)
2002 printf (" %s", &strtab[strx + file_string_table_offset]);
2011 dump_section_stabs (abfd, stabsect_name, strsect_name)
2013 char *stabsect_name;
2018 /* Check for section names for which stabsect_name is a prefix, to
2019 handle .stab0, etc. */
2020 for (s = abfd->sections;
2026 len = strlen (stabsect_name);
2028 /* If the prefix matches, and the files section name ends with a
2029 nul or a digit, then we match. I.e., we want either an exact
2030 match or a section followed by a number. */
2031 if (strncmp (stabsect_name, s->name, len) == 0
2032 && (s->name[len] == '\000'
2033 || isdigit ((unsigned char) s->name[len])))
2035 if (read_section_stabs (abfd, s->name, strsect_name))
2037 print_section_stabs (abfd, s->name, strsect_name);
2046 dump_bfd_header (abfd)
2051 printf (_("architecture: %s, "),
2052 bfd_printable_arch_mach (bfd_get_arch (abfd),
2053 bfd_get_mach (abfd)));
2054 printf (_("flags 0x%08x:\n"), abfd->flags);
2056 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2057 PF (HAS_RELOC, "HAS_RELOC");
2058 PF (EXEC_P, "EXEC_P");
2059 PF (HAS_LINENO, "HAS_LINENO");
2060 PF (HAS_DEBUG, "HAS_DEBUG");
2061 PF (HAS_SYMS, "HAS_SYMS");
2062 PF (HAS_LOCALS, "HAS_LOCALS");
2063 PF (DYNAMIC, "DYNAMIC");
2064 PF (WP_TEXT, "WP_TEXT");
2065 PF (D_PAGED, "D_PAGED");
2066 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2067 printf (_("\nstart address 0x"));
2068 printf_vma (abfd->start_address);
2073 dump_bfd_private_header (abfd)
2076 bfd_print_private_bfd_data (abfd, stdout);
2079 /* Dump selected contents of ABFD */
2085 /* If we are adjusting section VMA's, change them all now. Changing
2086 the BFD information is a hack. However, we must do it, or
2087 bfd_find_nearest_line will not do the right thing. */
2088 if (adjust_section_vma != 0)
2092 for (s = abfd->sections; s != NULL; s = s->next)
2094 s->vma += adjust_section_vma;
2095 s->lma += adjust_section_vma;
2099 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
2102 print_arelt_descr (stdout, abfd, true);
2103 if (dump_file_header)
2104 dump_bfd_header (abfd);
2105 if (dump_private_headers)
2106 dump_bfd_private_header (abfd);
2108 if (dump_section_headers)
2109 dump_headers (abfd);
2110 if (dump_symtab || dump_reloc_info || disassemble || dump_debugging)
2112 syms = slurp_symtab (abfd);
2114 if (dump_dynamic_symtab || dump_dynamic_reloc_info)
2116 dynsyms = slurp_dynamic_symtab (abfd);
2119 dump_symbols (abfd, false);
2120 if (dump_dynamic_symtab)
2121 dump_symbols (abfd, true);
2122 if (dump_stab_section_info)
2124 if (dump_reloc_info && ! disassemble)
2126 if (dump_dynamic_reloc_info)
2127 dump_dynamic_relocs (abfd);
2128 if (dump_section_contents)
2131 disassemble_data (abfd);
2136 dhandle = read_debugging_info (abfd, syms, symcount);
2137 if (dhandle != NULL)
2139 if (! print_debugging_info (stdout, dhandle))
2141 non_fatal (_("%s: printing debugging information failed"),
2142 bfd_get_filename (abfd));
2165 if (bfd_check_format_matches (abfd, bfd_object, &matching))
2171 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2173 nonfatal (bfd_get_filename (abfd));
2174 list_matching_formats (matching);
2179 if (bfd_get_error () != bfd_error_file_not_recognized)
2181 nonfatal (bfd_get_filename (abfd));
2185 if (bfd_check_format_matches (abfd, bfd_core, &matching))
2191 nonfatal (bfd_get_filename (abfd));
2193 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2195 list_matching_formats (matching);
2201 display_file (filename, target)
2205 bfd *file, *arfile = (bfd *) NULL;
2207 file = bfd_openr (filename, target);
2210 nonfatal (filename);
2214 if (bfd_check_format (file, bfd_archive) == true)
2216 bfd *last_arfile = NULL;
2218 printf (_("In archive %s:\n"), bfd_get_filename (file));
2221 bfd_set_error (bfd_error_no_error);
2223 arfile = bfd_openr_next_archived_file (file, arfile);
2226 if (bfd_get_error () != bfd_error_no_more_archived_files)
2227 nonfatal (bfd_get_filename (file));
2231 display_bfd (arfile);
2233 if (last_arfile != NULL)
2234 bfd_close (last_arfile);
2235 last_arfile = arfile;
2238 if (last_arfile != NULL)
2239 bfd_close (last_arfile);
2247 /* Actually display the various requested regions */
2255 bfd_size_type datasize = 0;
2256 bfd_size_type addr_offset;
2257 bfd_size_type start_offset, stop_offset;
2258 unsigned int opb = bfd_octets_per_byte (abfd);
2260 for (section = abfd->sections; section != NULL; section =
2265 if (only == (char *) NULL ||
2266 strcmp (only, section->name) == 0)
2268 if (section->flags & SEC_HAS_CONTENTS)
2270 printf (_("Contents of section %s:\n"), section->name);
2272 if (bfd_section_size (abfd, section) == 0)
2274 data = (bfd_byte *) xmalloc ((size_t) bfd_section_size (abfd, section));
2275 datasize = bfd_section_size (abfd, section);
2278 bfd_get_section_contents (abfd, section, (PTR) data, 0, bfd_section_size (abfd, section));
2280 if (start_address == (bfd_vma) -1
2281 || start_address < section->vma)
2284 start_offset = start_address - section->vma;
2285 if (stop_address == (bfd_vma) -1)
2286 stop_offset = bfd_section_size (abfd, section) / opb;
2289 if (stop_address < section->vma)
2292 stop_offset = stop_address - section->vma;
2293 if (stop_offset > bfd_section_size (abfd, section) / opb)
2294 stop_offset = bfd_section_size (abfd, section) / opb;
2296 for (addr_offset = start_offset;
2297 addr_offset < stop_offset; addr_offset += onaline)
2301 printf (" %04lx ", (unsigned long int)
2302 (addr_offset + section->vma));
2303 for (j = addr_offset * opb;
2304 j < addr_offset * opb + onaline; j++)
2306 if (j < stop_offset * opb)
2307 printf ("%02x", (unsigned) (data[j]));
2315 for (j = addr_offset; j < addr_offset * opb + onaline; j++)
2317 if (j >= stop_offset * opb)
2320 printf ("%c", isprint (data[j]) ? data[j] : '.');
2330 /* Should perhaps share code and display with nm? */
2332 dump_symbols (abfd, dynamic)
2333 bfd *abfd ATTRIBUTE_UNUSED;
2346 printf ("DYNAMIC SYMBOL TABLE:\n");
2354 printf ("SYMBOL TABLE:\n");
2357 for (count = 0; count < max; count++)
2361 bfd *cur_bfd = bfd_asymbol_bfd (*current);
2363 if (cur_bfd != NULL)
2368 name = bfd_asymbol_name (*current);
2370 if (do_demangle && name != NULL && *name != '\0')
2374 /* If we want to demangle the name, we demangle it
2375 here, and temporarily clobber it while calling
2376 bfd_print_symbol. FIXME: This is a gross hack. */
2379 if (bfd_get_symbol_leading_char (cur_bfd) == *n)
2381 alloc = cplus_demangle (n, DMGL_ANSI | DMGL_PARAMS);
2383 (*current)->name = alloc;
2385 (*current)->name = n;
2388 bfd_print_symbol (cur_bfd, stdout, *current,
2389 bfd_print_symbol_all);
2391 (*current)->name = name;
2412 for (a = abfd->sections; a != (asection *) NULL; a = a->next)
2416 if (bfd_is_abs_section (a))
2418 if (bfd_is_und_section (a))
2420 if (bfd_is_com_section (a))
2425 if (strcmp (only, a->name))
2428 else if ((a->flags & SEC_RELOC) == 0)
2431 relsize = bfd_get_reloc_upper_bound (abfd, a);
2433 bfd_fatal (bfd_get_filename (abfd));
2435 printf ("RELOCATION RECORDS FOR [%s]:", a->name);
2439 printf (" (none)\n\n");
2443 relpp = (arelent **) xmalloc (relsize);
2444 relcount = bfd_canonicalize_reloc (abfd, a, relpp, syms);
2446 bfd_fatal (bfd_get_filename (abfd));
2447 else if (relcount == 0)
2449 printf (" (none)\n\n");
2454 dump_reloc_set (abfd, a, relpp, relcount);
2463 dump_dynamic_relocs (abfd)
2470 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2472 bfd_fatal (bfd_get_filename (abfd));
2474 printf ("DYNAMIC RELOCATION RECORDS");
2478 printf (" (none)\n\n");
2482 relpp = (arelent **) xmalloc (relsize);
2483 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2485 bfd_fatal (bfd_get_filename (abfd));
2486 else if (relcount == 0)
2488 printf (" (none)\n\n");
2493 dump_reloc_set (abfd, (asection *) NULL, relpp, relcount);
2501 dump_reloc_set (abfd, sec, relpp, relcount)
2508 char *last_filename, *last_functionname;
2509 unsigned int last_line;
2511 /* Get column headers lined up reasonably. */
2517 sprintf_vma (buf, (bfd_vma) -1);
2518 width = strlen (buf) - 7;
2520 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2523 last_filename = NULL;
2524 last_functionname = NULL;
2527 for (p = relpp; relcount && *p != (arelent *) NULL; p++, relcount--)
2530 const char *filename, *functionname;
2532 const char *sym_name;
2533 const char *section_name;
2535 if (start_address != (bfd_vma) -1
2536 && q->address < start_address)
2538 if (stop_address != (bfd_vma) -1
2539 && q->address > stop_address)
2542 if (with_line_numbers
2544 && bfd_find_nearest_line (abfd, sec, syms, q->address,
2545 &filename, &functionname, &line))
2547 if (functionname != NULL
2548 && (last_functionname == NULL
2549 || strcmp (functionname, last_functionname) != 0))
2551 printf ("%s():\n", functionname);
2552 if (last_functionname != NULL)
2553 free (last_functionname);
2554 last_functionname = xstrdup (functionname);
2557 && (line != last_line
2558 || (filename != NULL
2559 && last_filename != NULL
2560 && strcmp (filename, last_filename) != 0)))
2562 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2564 if (last_filename != NULL)
2565 free (last_filename);
2566 if (filename == NULL)
2567 last_filename = NULL;
2569 last_filename = xstrdup (filename);
2573 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2575 sym_name = (*(q->sym_ptr_ptr))->name;
2576 section_name = (*(q->sym_ptr_ptr))->section->name;
2581 section_name = NULL;
2585 printf_vma (q->address);
2587 printf (" %-16s ", q->howto->name);
2589 printf (" %-16d ", q->howto->type);
2590 objdump_print_symname (abfd, (struct disassemble_info *) NULL,
2595 if (section_name == (CONST char *) NULL)
2596 section_name = "*unknown*";
2597 printf_vma (q->address);
2598 printf (" %-16s [%s]",
2605 printf_vma (q->addend);
2611 /* The length of the longest architecture name + 1. */
2612 #define LONGEST_ARCH sizeof("rs6000:6000")
2615 endian_string (endian)
2616 enum bfd_endian endian;
2618 if (endian == BFD_ENDIAN_BIG)
2619 return "big endian";
2620 else if (endian == BFD_ENDIAN_LITTLE)
2621 return "little endian";
2623 return "endianness unknown";
2626 /* List the targets that BFD is configured to support, each followed
2627 by its endianness and the architectures it supports. */
2630 display_target_list ()
2632 extern bfd_target *bfd_target_vector[];
2636 dummy_name = make_temp_file (NULL);
2637 for (t = 0; bfd_target_vector[t]; t++)
2639 bfd_target *p = bfd_target_vector[t];
2640 bfd *abfd = bfd_openw (dummy_name, p->name);
2643 printf ("%s\n (header %s, data %s)\n", p->name,
2644 endian_string (p->header_byteorder),
2645 endian_string (p->byteorder));
2649 nonfatal (dummy_name);
2653 if (! bfd_set_format (abfd, bfd_object))
2655 if (bfd_get_error () != bfd_error_invalid_operation)
2657 bfd_close_all_done (abfd);
2661 for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++)
2662 if (bfd_set_arch_mach (abfd, (enum bfd_architecture) a, 0))
2664 bfd_printable_arch_mach ((enum bfd_architecture) a, 0));
2665 bfd_close_all_done (abfd);
2667 unlink (dummy_name);
2671 /* Print a table showing which architectures are supported for entries
2672 FIRST through LAST-1 of bfd_target_vector (targets across,
2673 architectures down). */
2676 display_info_table (first, last)
2680 extern bfd_target *bfd_target_vector[];
2684 /* Print heading of target names. */
2685 printf ("\n%*s", (int) LONGEST_ARCH, " ");
2686 for (t = first; t < last && bfd_target_vector[t]; t++)
2687 printf ("%s ", bfd_target_vector[t]->name);
2690 dummy_name = make_temp_file (NULL);
2691 for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++)
2692 if (strcmp (bfd_printable_arch_mach (a, 0), "UNKNOWN!") != 0)
2694 printf ("%*s ", (int) LONGEST_ARCH - 1,
2695 bfd_printable_arch_mach (a, 0));
2696 for (t = first; t < last && bfd_target_vector[t]; t++)
2698 bfd_target *p = bfd_target_vector[t];
2700 bfd *abfd = bfd_openw (dummy_name, p->name);
2710 if (! bfd_set_format (abfd, bfd_object))
2712 if (bfd_get_error () != bfd_error_invalid_operation)
2720 if (! bfd_set_arch_mach (abfd, a, 0))
2725 printf ("%s ", p->name);
2728 int l = strlen (p->name);
2734 bfd_close_all_done (abfd);
2738 unlink (dummy_name);
2742 /* Print tables of all the target-architecture combinations that
2743 BFD has been configured to support. */
2746 display_target_tables ()
2749 extern bfd_target *bfd_target_vector[];
2753 colum = getenv ("COLUMNS");
2755 columns = atoi (colum);
2760 while (bfd_target_vector[t] != NULL)
2764 wid = LONGEST_ARCH + strlen (bfd_target_vector[t]->name) + 1;
2766 while (wid < columns && bfd_target_vector[t] != NULL)
2770 newwid = wid + strlen (bfd_target_vector[t]->name) + 1;
2771 if (newwid >= columns)
2776 display_info_table (oldt, t);
2783 printf (_("BFD header file version %s\n"), BFD_VERSION);
2784 display_target_list ();
2785 display_target_tables ();
2794 char *target = default_target;
2795 boolean seenflag = false;
2797 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
2798 setlocale (LC_MESSAGES, "");
2800 bindtextdomain (PACKAGE, LOCALEDIR);
2801 textdomain (PACKAGE);
2803 program_name = *argv;
2804 xmalloc_set_program_name (program_name);
2806 START_PROGRESS (program_name, 0);
2809 set_default_bfd_target ();
2811 while ((c = getopt_long (argc, argv, "pib:m:M:VCdDlfahHrRtTxsSj:wE:zgG",
2812 long_options, (int *) 0))
2818 break; /* we've been given a long option */
2823 disassembler_options = optarg;
2829 with_line_numbers = true;
2840 case OPTION_ADJUST_VMA:
2841 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
2843 case OPTION_START_ADDRESS:
2844 start_address = parse_vma (optarg, "--start-address");
2846 case OPTION_STOP_ADDRESS:
2847 stop_address = parse_vma (optarg, "--stop-address");
2850 if (strcmp (optarg, "B") == 0)
2851 endian = BFD_ENDIAN_BIG;
2852 else if (strcmp (optarg, "L") == 0)
2853 endian = BFD_ENDIAN_LITTLE;
2856 non_fatal (_("unrecognized -E option"));
2861 if (strncmp (optarg, "big", strlen (optarg)) == 0)
2862 endian = BFD_ENDIAN_BIG;
2863 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
2864 endian = BFD_ENDIAN_LITTLE;
2867 non_fatal (_("unrecognized --endian type `%s'"), optarg);
2873 dump_file_header = true;
2877 formats_info = true;
2881 dump_private_headers = true;
2885 dump_private_headers = true;
2887 dump_reloc_info = true;
2888 dump_file_header = true;
2889 dump_ar_hdrs = true;
2890 dump_section_headers = true;
2898 dump_dynamic_symtab = true;
2906 disassemble_zeroes = true;
2910 disassemble_all = true;
2915 with_source_code = true;
2923 dump_stab_section_info = true;
2927 dump_section_contents = true;
2931 dump_reloc_info = true;
2935 dump_dynamic_reloc_info = true;
2939 dump_ar_hdrs = true;
2943 dump_section_headers = true;
2950 show_version = true;
2960 print_version ("objdump");
2962 if (seenflag == false)
2970 display_file ("a.out", target);
2972 for (; optind < argc;)
2973 display_file (argv[optind++], target);
2976 END_PROGRESS (program_name);