1 /* objdump.c -- dump information about an object file.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 Free Software Foundation, Inc.
6 This file is part of GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 #include "libiberty.h"
33 /* Internal headers for the ELF .stab-dump code - sorry. */
34 #define BYTES_IN_WORD 32
35 #include "aout/aout64.h"
37 #ifdef NEED_DECLARATION_FPRINTF
38 /* This is needed by INIT_DISASSEMBLE_INFO. */
39 extern int fprintf PARAMS ((FILE *, const char *, ...));
43 static int exit_status = 0;
45 static char *default_target = NULL; /* default at runtime */
47 static int show_version = 0; /* show the version number */
48 static int dump_section_contents; /* -s */
49 static int dump_section_headers; /* -h */
50 static boolean dump_file_header; /* -f */
51 static int dump_symtab; /* -t */
52 static int dump_dynamic_symtab; /* -T */
53 static int dump_reloc_info; /* -r */
54 static int dump_dynamic_reloc_info; /* -R */
55 static int dump_ar_hdrs; /* -a */
56 static int dump_private_headers; /* -p */
57 static int prefix_addresses; /* --prefix-addresses */
58 static int with_line_numbers; /* -l */
59 static boolean with_source_code; /* -S */
60 static int show_raw_insn; /* --show-raw-insn */
61 static int dump_stab_section_info; /* --stabs */
62 static int do_demangle; /* -C, --demangle */
63 static boolean disassemble; /* -d */
64 static boolean disassemble_all; /* -D */
65 static int disassemble_zeroes; /* --disassemble-zeroes */
66 static boolean formats_info; /* -i */
67 static char *only; /* -j secname */
68 static int wide_output; /* -w */
69 static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
70 static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */
71 static int dump_debugging; /* --debugging */
72 static bfd_vma adjust_section_vma = 0; /* --adjust-vma */
73 static int file_start_context = 0; /* --file-start-context */
75 /* Extra info to pass to the disassembler address printing function. */
76 struct objdump_disasm_info {
82 /* Architecture to disassemble for, or default if NULL. */
83 static char *machine = (char *) NULL;
85 /* Target specific options to the disassembler. */
86 static char *disassembler_options = (char *) NULL;
88 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
89 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
91 /* The symbol table. */
92 static asymbol **syms;
94 /* Number of symbols in `syms'. */
95 static long symcount = 0;
97 /* The sorted symbol table. */
98 static asymbol **sorted_syms;
100 /* Number of symbols in `sorted_syms'. */
101 static long sorted_symcount = 0;
103 /* The dynamic symbol table. */
104 static asymbol **dynsyms;
106 /* Number of symbols in `dynsyms'. */
107 static long dynsymcount = 0;
109 /* Static declarations. */
112 usage PARAMS ((FILE *, int));
115 nonfatal PARAMS ((const char *));
118 display_file PARAMS ((char *filename, char *target));
121 dump_section_header PARAMS ((bfd *, asection *, PTR));
124 dump_headers PARAMS ((bfd *));
127 dump_data PARAMS ((bfd *abfd));
130 dump_relocs PARAMS ((bfd *abfd));
133 dump_dynamic_relocs PARAMS ((bfd * abfd));
136 dump_reloc_set PARAMS ((bfd *, asection *, arelent **, long));
139 dump_symbols PARAMS ((bfd *abfd, boolean dynamic));
142 dump_bfd_header PARAMS ((bfd *));
145 dump_bfd_private_header PARAMS ((bfd *));
148 display_bfd PARAMS ((bfd *abfd));
151 display_target_list PARAMS ((void));
154 display_info_table PARAMS ((int, int));
157 display_target_tables PARAMS ((void));
160 display_info PARAMS ((void));
163 objdump_print_value PARAMS ((bfd_vma, struct disassemble_info *, boolean));
166 objdump_print_symname PARAMS ((bfd *, struct disassemble_info *, asymbol *));
169 find_symbol_for_address PARAMS ((bfd *, asection *, bfd_vma, boolean, long *));
172 objdump_print_addr_with_sym PARAMS ((bfd *, asection *, asymbol *, bfd_vma,
173 struct disassemble_info *, boolean));
176 objdump_print_addr PARAMS ((bfd_vma, struct disassemble_info *, boolean));
179 objdump_print_address PARAMS ((bfd_vma, struct disassemble_info *));
182 show_line PARAMS ((bfd *, asection *, bfd_vma));
185 disassemble_bytes PARAMS ((struct disassemble_info *, disassembler_ftype,
186 boolean, bfd_byte *, bfd_vma, bfd_vma,
187 arelent ***, arelent **));
190 disassemble_data PARAMS ((bfd *));
193 endian_string PARAMS ((enum bfd_endian));
196 slurp_symtab PARAMS ((bfd *));
199 slurp_dynamic_symtab PARAMS ((bfd *));
202 remove_useless_symbols PARAMS ((asymbol **, long));
205 compare_symbols PARAMS ((const PTR, const PTR));
208 compare_relocs PARAMS ((const PTR, const PTR));
211 dump_stabs PARAMS ((bfd *));
214 read_section_stabs PARAMS ((bfd *, const char *, const char *));
217 print_section_stabs PARAMS ((bfd *, const char *, const char *));
220 usage (stream, status)
224 fprintf (stream, _("Usage: %s OPTION... FILE...\n"), program_name);
225 fprintf (stream, _("Display information from object FILE.\n"));
226 fprintf (stream, _("\n At least one of the following switches must be given:\n"));
227 fprintf (stream, _("\
228 -a, --archive-headers Display archive header information\n\
229 -f, --file-headers Display the contents of the overall file header\n\
230 -p, --private-headers Display object format specific file header contents\n\
231 -h, --[section-]headers Display the contents of the section headers\n\
232 -x, --all-headers Display the contents of all headers\n\
233 -d, --disassemble Display assembler contents of executable sections\n\
234 -D, --disassemble-all Display assembler contents of all sections\n\
235 -S, --source Intermix source code with disassembly\n\
236 -s, --full-contents Display the full contents of all sections requested\n\
237 -g, --debugging Display debug information in object file\n\
238 -G, --stabs Display (in raw form) any STABS info in the file\n\
239 -t, --syms Display the contents of the symbol table(s)\n\
240 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
241 -r, --reloc Display the relocation entries in the file\n\
242 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
243 -V, --version Display this program's version number\n\
244 -i, --info List object formats and architectures supported\n\
245 -H, --help Display this information\n\
249 fprintf (stream, _("\n The following switches are optional:\n"));
250 fprintf (stream, _("\
251 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
252 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
253 -j, --section=NAME Only display information for section NAME\n\
254 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
255 -EB --endian=big Assume big endian format when disassembling\n\
256 -EL --endian=little Assume little endian format when disassembling\n\
257 --file-start-context Include context from start of file (with -S)\n\
258 -l, --line-numbers Include line numbers and filenames in output\n\
259 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
260 The STYLE, if specified, can be `auto', 'gnu',\n\
261 'lucid', 'arm', 'hp', 'edg', or 'gnu-new-abi'\n\
262 -w, --wide Format output for more than 80 columns\n\
263 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
264 --start-address=ADDR Only process data whoes address is >= ADDR\n\
265 --stop-address=ADDR Only process data whoes address is <= ADDR\n\
266 --prefix-addresses Print complete address alongside disassembly\n\
267 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
268 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
270 list_supported_targets (program_name, stream);
272 disassembler_usage (stream);
275 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
279 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
281 #define OPTION_ENDIAN (150)
282 #define OPTION_START_ADDRESS (OPTION_ENDIAN + 1)
283 #define OPTION_STOP_ADDRESS (OPTION_START_ADDRESS + 1)
284 #define OPTION_ADJUST_VMA (OPTION_STOP_ADDRESS + 1)
286 static struct option long_options[]=
288 {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
289 {"all-headers", no_argument, NULL, 'x'},
290 {"private-headers", no_argument, NULL, 'p'},
291 {"architecture", required_argument, NULL, 'm'},
292 {"archive-headers", no_argument, NULL, 'a'},
293 {"debugging", no_argument, NULL, 'g'},
294 {"demangle", optional_argument, NULL, 'C'},
295 {"disassemble", no_argument, NULL, 'd'},
296 {"disassemble-all", no_argument, NULL, 'D'},
297 {"disassembler-options", required_argument, NULL, 'M'},
298 {"disassemble-zeroes", no_argument, NULL, 'z'},
299 {"dynamic-reloc", no_argument, NULL, 'R'},
300 {"dynamic-syms", no_argument, NULL, 'T'},
301 {"endian", required_argument, NULL, OPTION_ENDIAN},
302 {"file-headers", no_argument, NULL, 'f'},
303 {"file-start-context", no_argument, &file_start_context, 1},
304 {"full-contents", no_argument, NULL, 's'},
305 {"headers", no_argument, NULL, 'h'},
306 {"help", no_argument, NULL, 'H'},
307 {"info", no_argument, NULL, 'i'},
308 {"line-numbers", no_argument, NULL, 'l'},
309 {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
310 {"prefix-addresses", no_argument, &prefix_addresses, 1},
311 {"reloc", no_argument, NULL, 'r'},
312 {"section", required_argument, NULL, 'j'},
313 {"section-headers", no_argument, NULL, 'h'},
314 {"show-raw-insn", no_argument, &show_raw_insn, 1},
315 {"source", no_argument, NULL, 'S'},
316 {"stabs", no_argument, NULL, 'G'},
317 {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
318 {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
319 {"syms", no_argument, NULL, 't'},
320 {"target", required_argument, NULL, 'b'},
321 {"version", no_argument, NULL, 'V'},
322 {"wide", no_argument, NULL, 'w'},
323 {0, no_argument, 0, 0}
335 dump_section_header (abfd, section, ignored)
336 bfd *abfd ATTRIBUTE_UNUSED;
338 PTR ignored ATTRIBUTE_UNUSED;
341 unsigned int opb = bfd_octets_per_byte (abfd);
343 printf ("%3d %-13s %08lx ", section->index,
344 bfd_get_section_name (abfd, section),
345 (unsigned long) bfd_section_size (abfd, section) / opb);
346 printf_vma (bfd_get_section_vma (abfd, section));
348 printf_vma (section->lma);
349 printf (" %08lx 2**%u", section->filepos,
350 bfd_get_section_alignment (abfd, section));
356 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
358 PF (SEC_HAS_CONTENTS, "CONTENTS");
359 PF (SEC_ALLOC, "ALLOC");
360 PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
361 PF (SEC_CONSTRUCTOR_TEXT, "CONSTRUCTOR TEXT");
362 PF (SEC_CONSTRUCTOR_DATA, "CONSTRUCTOR DATA");
363 PF (SEC_CONSTRUCTOR_BSS, "CONSTRUCTOR BSS");
364 PF (SEC_LOAD, "LOAD");
365 PF (SEC_RELOC, "RELOC");
367 PF (SEC_BALIGN, "BALIGN");
369 PF (SEC_READONLY, "READONLY");
370 PF (SEC_CODE, "CODE");
371 PF (SEC_DATA, "DATA");
373 PF (SEC_DEBUGGING, "DEBUGGING");
374 PF (SEC_NEVER_LOAD, "NEVER_LOAD");
375 PF (SEC_EXCLUDE, "EXCLUDE");
376 PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
377 PF (SEC_BLOCK, "BLOCK");
378 PF (SEC_CLINK, "CLINK");
379 PF (SEC_SMALL_DATA, "SMALL_DATA");
380 PF (SEC_SHARED, "SHARED");
382 if ((section->flags & SEC_LINK_ONCE) != 0)
386 switch (section->flags & SEC_LINK_DUPLICATES)
390 case SEC_LINK_DUPLICATES_DISCARD:
391 ls = "LINK_ONCE_DISCARD";
393 case SEC_LINK_DUPLICATES_ONE_ONLY:
394 ls = "LINK_ONCE_ONE_ONLY";
396 case SEC_LINK_DUPLICATES_SAME_SIZE:
397 ls = "LINK_ONCE_SAME_SIZE";
399 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
400 ls = "LINK_ONCE_SAME_CONTENTS";
403 printf ("%s%s", comma, ls);
405 if (section->comdat != NULL)
406 printf (" (COMDAT %s %ld)", section->comdat->name,
407 section->comdat->symbol);
420 printf (_("Sections:\n"));
423 printf (_("Idx Name Size VMA LMA File off Algn"));
425 printf (_("Idx Name Size VMA LMA File off Algn"));
429 printf (_(" Flags"));
432 bfd_map_over_sections (abfd, dump_section_header, (PTR) NULL);
439 asymbol **sy = (asymbol **) NULL;
442 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
444 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
449 storage = bfd_get_symtab_upper_bound (abfd);
451 bfd_fatal (bfd_get_filename (abfd));
455 sy = (asymbol **) xmalloc (storage);
457 symcount = bfd_canonicalize_symtab (abfd, sy);
459 bfd_fatal (bfd_get_filename (abfd));
461 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
465 /* Read in the dynamic symbols. */
468 slurp_dynamic_symtab (abfd)
471 asymbol **sy = (asymbol **) NULL;
474 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
477 if (!(bfd_get_file_flags (abfd) & DYNAMIC))
479 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
484 bfd_fatal (bfd_get_filename (abfd));
489 sy = (asymbol **) xmalloc (storage);
491 dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
493 bfd_fatal (bfd_get_filename (abfd));
494 if (dynsymcount == 0)
495 non_fatal (_("%s: No dynamic symbols"), bfd_get_filename (abfd));
499 /* Filter out (in place) symbols that are useless for disassembly.
500 COUNT is the number of elements in SYMBOLS.
501 Return the number of useful symbols. */
504 remove_useless_symbols (symbols, count)
508 register asymbol **in_ptr = symbols, **out_ptr = symbols;
512 asymbol *sym = *in_ptr++;
514 if (sym->name == NULL || sym->name[0] == '\0')
516 if (sym->flags & (BSF_DEBUGGING))
518 if (bfd_is_und_section (sym->section)
519 || bfd_is_com_section (sym->section))
524 return out_ptr - symbols;
527 /* Sort symbols into value order. */
530 compare_symbols (ap, bp)
534 const asymbol *a = *(const asymbol **)ap;
535 const asymbol *b = *(const asymbol **)bp;
539 flagword aflags, bflags;
541 if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
543 else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
546 if (a->section > b->section)
548 else if (a->section < b->section)
551 an = bfd_asymbol_name (a);
552 bn = bfd_asymbol_name (b);
556 /* The symbols gnu_compiled and gcc2_compiled convey no real
557 information, so put them after other symbols with the same value. */
559 af = (strstr (an, "gnu_compiled") != NULL
560 || strstr (an, "gcc2_compiled") != NULL);
561 bf = (strstr (bn, "gnu_compiled") != NULL
562 || strstr (bn, "gcc2_compiled") != NULL);
569 /* We use a heuristic for the file name, to try to sort it after
570 more useful symbols. It may not work on non Unix systems, but it
571 doesn't really matter; the only difference is precisely which
572 symbol names get printed. */
574 #define file_symbol(s, sn, snl) \
575 (((s)->flags & BSF_FILE) != 0 \
576 || ((sn)[(snl) - 2] == '.' \
577 && ((sn)[(snl) - 1] == 'o' \
578 || (sn)[(snl) - 1] == 'a')))
580 af = file_symbol (a, an, anl);
581 bf = file_symbol (b, bn, bnl);
588 /* Try to sort global symbols before local symbols before function
589 symbols before debugging symbols. */
594 if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
596 if ((aflags & BSF_DEBUGGING) != 0)
601 if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
603 if ((aflags & BSF_FUNCTION) != 0)
608 if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
610 if ((aflags & BSF_LOCAL) != 0)
615 if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
617 if ((aflags & BSF_GLOBAL) != 0)
623 /* Symbols that start with '.' might be section names, so sort them
624 after symbols that don't start with '.'. */
625 if (an[0] == '.' && bn[0] != '.')
627 if (an[0] != '.' && bn[0] == '.')
630 /* Finally, if we can't distinguish them in any other way, try to
631 get consistent results by sorting the symbols by name. */
632 return strcmp (an, bn);
635 /* Sort relocs into address order. */
638 compare_relocs (ap, bp)
642 const arelent *a = *(const arelent **)ap;
643 const arelent *b = *(const arelent **)bp;
645 if (a->address > b->address)
647 else if (a->address < b->address)
650 /* So that associated relocations tied to the same address show up
651 in the correct order, we don't do any further sorting. */
660 /* Print VMA to STREAM. If SKIP_ZEROES is true, omit leading zeroes. */
663 objdump_print_value (vma, info, skip_zeroes)
665 struct disassemble_info *info;
671 sprintf_vma (buf, vma);
676 for (p = buf; *p == '0'; ++p)
681 (*info->fprintf_func) (info->stream, "%s", p);
684 /* Print the name of a symbol. */
687 objdump_print_symname (abfd, info, sym)
689 struct disassemble_info *info;
697 name = bfd_asymbol_name (sym);
698 if (! do_demangle || name[0] == '\0')
702 /* Demangle the name. */
703 if (bfd_get_symbol_leading_char (abfd) == name[0])
706 alloc = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS);
714 (*info->fprintf_func) (info->stream, "%s", print);
716 printf ("%s", print);
722 /* Locate a symbol given a bfd, a section, and a VMA. If REQUIRE_SEC
723 is true, then always require the symbol to be in the section. This
724 returns NULL if there is no suitable symbol. If PLACE is not NULL,
725 then *PLACE is set to the index of the symbol in sorted_syms. */
728 find_symbol_for_address (abfd, sec, vma, require_sec, place)
735 /* @@ Would it speed things up to cache the last two symbols returned,
736 and maybe their address ranges? For many processors, only one memory
737 operand can be present at a time, so the 2-entry cache wouldn't be
738 constantly churned by code doing heavy memory accesses. */
740 /* Indices in `sorted_syms'. */
742 long max = sorted_symcount;
744 unsigned int opb = bfd_octets_per_byte (abfd);
746 if (sorted_symcount < 1)
749 /* Perform a binary search looking for the closest symbol to the
750 required value. We are searching the range (min, max]. */
751 while (min + 1 < max)
755 thisplace = (max + min) / 2;
756 sym = sorted_syms[thisplace];
758 if (bfd_asymbol_value (sym) > vma)
760 else if (bfd_asymbol_value (sym) < vma)
769 /* The symbol we want is now in min, the low end of the range we
770 were searching. If there are several symbols with the same
771 value, we want the first one. */
774 && (bfd_asymbol_value (sorted_syms[thisplace])
775 == bfd_asymbol_value (sorted_syms[thisplace - 1])))
778 /* If the file is relocateable, and the symbol could be from this
779 section, prefer a symbol from this section over symbols from
780 others, even if the other symbol's value might be closer.
782 Note that this may be wrong for some symbol references if the
783 sections have overlapping memory ranges, but in that case there's
784 no way to tell what's desired without looking at the relocation
787 if (sorted_syms[thisplace]->section != sec
789 || ((abfd->flags & HAS_RELOC) != 0
790 && vma >= bfd_get_section_vma (abfd, sec)
791 && vma < (bfd_get_section_vma (abfd, sec)
792 + bfd_section_size (abfd, sec) / opb))))
796 for (i = thisplace + 1; i < sorted_symcount; i++)
798 if (bfd_asymbol_value (sorted_syms[i])
799 != bfd_asymbol_value (sorted_syms[thisplace]))
805 if (sorted_syms[i]->section == sec
807 || sorted_syms[i - 1]->section != sec
808 || (bfd_asymbol_value (sorted_syms[i])
809 != bfd_asymbol_value (sorted_syms[i - 1]))))
816 if (sorted_syms[thisplace]->section != sec)
818 /* We didn't find a good symbol with a smaller value.
819 Look for one with a larger value. */
820 for (i = thisplace + 1; i < sorted_symcount; i++)
822 if (sorted_syms[i]->section == sec)
830 if (sorted_syms[thisplace]->section != sec
832 || ((abfd->flags & HAS_RELOC) != 0
833 && vma >= bfd_get_section_vma (abfd, sec)
834 && vma < (bfd_get_section_vma (abfd, sec)
835 + bfd_section_size (abfd, sec)))))
837 /* There is no suitable symbol. */
845 return sorted_syms[thisplace];
848 /* Print an address to INFO symbolically. */
851 objdump_print_addr_with_sym (abfd, sec, sym, vma, info, skip_zeroes)
856 struct disassemble_info *info;
859 objdump_print_value (vma, info, skip_zeroes);
865 (*info->fprintf_func) (info->stream, " <%s",
866 bfd_get_section_name (abfd, sec));
867 secaddr = bfd_get_section_vma (abfd, sec);
870 (*info->fprintf_func) (info->stream, "-0x");
871 objdump_print_value (secaddr - vma, info, true);
873 else if (vma > secaddr)
875 (*info->fprintf_func) (info->stream, "+0x");
876 objdump_print_value (vma - secaddr, info, true);
878 (*info->fprintf_func) (info->stream, ">");
882 (*info->fprintf_func) (info->stream, " <");
883 objdump_print_symname (abfd, info, sym);
884 if (bfd_asymbol_value (sym) > vma)
886 (*info->fprintf_func) (info->stream, "-0x");
887 objdump_print_value (bfd_asymbol_value (sym) - vma, info, true);
889 else if (vma > bfd_asymbol_value (sym))
891 (*info->fprintf_func) (info->stream, "+0x");
892 objdump_print_value (vma - bfd_asymbol_value (sym), info, true);
894 (*info->fprintf_func) (info->stream, ">");
898 /* Print VMA to INFO, symbolically if possible. If SKIP_ZEROES is
899 true, don't output leading zeroes. */
902 objdump_print_addr (vma, info, skip_zeroes)
904 struct disassemble_info *info;
907 struct objdump_disasm_info *aux;
910 if (sorted_symcount < 1)
912 (*info->fprintf_func) (info->stream, "0x");
913 objdump_print_value (vma, info, skip_zeroes);
917 aux = (struct objdump_disasm_info *) info->application_data;
918 sym = find_symbol_for_address (aux->abfd, aux->sec, vma, aux->require_sec,
920 objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, info,
924 /* Print VMA to INFO. This function is passed to the disassembler
928 objdump_print_address (vma, info)
930 struct disassemble_info *info;
932 objdump_print_addr (vma, info, ! prefix_addresses);
935 /* Determine of the given address has a symbol associated with it. */
938 objdump_symbol_at_address (vma, info)
940 struct disassemble_info * info;
942 struct objdump_disasm_info * aux;
945 /* No symbols - do not bother checking. */
946 if (sorted_symcount < 1)
949 aux = (struct objdump_disasm_info *) info->application_data;
950 sym = find_symbol_for_address (aux->abfd, aux->sec, vma, aux->require_sec,
953 return (sym != NULL && (bfd_asymbol_value (sym) == vma));
956 /* Hold the last function name and the last line number we displayed
959 static char *prev_functionname;
960 static unsigned int prev_line;
962 /* We keep a list of all files that we have seen when doing a
963 dissassembly with source, so that we know how much of the file to
964 display. This can be important for inlined functions. */
966 struct print_file_list
968 struct print_file_list *next;
974 static struct print_file_list *print_files;
976 /* The number of preceding context lines to show when we start
977 displaying a file for the first time. */
979 #define SHOW_PRECEDING_CONTEXT_LINES (5)
981 /* Skip ahead to a given line in a file, optionally printing each
985 skip_to_line PARAMS ((struct print_file_list *, unsigned int, boolean));
988 skip_to_line (p, line, show)
989 struct print_file_list *p;
993 while (p->line < line)
997 if (fgets (buf, sizeof buf, p->f) == NULL)
1007 if (strchr (buf, '\n') != NULL)
1012 /* Show the line number, or the source line, in a dissassembly
1016 show_line (abfd, section, addr_offset)
1019 bfd_vma addr_offset;
1021 CONST char *filename;
1022 CONST char *functionname;
1025 if (! with_line_numbers && ! with_source_code)
1028 if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename,
1029 &functionname, &line))
1032 if (filename != NULL && *filename == '\0')
1034 if (functionname != NULL && *functionname == '\0')
1035 functionname = NULL;
1037 if (with_line_numbers)
1039 if (functionname != NULL
1040 && (prev_functionname == NULL
1041 || strcmp (functionname, prev_functionname) != 0))
1042 printf ("%s():\n", functionname);
1043 if (line > 0 && line != prev_line)
1044 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
1047 if (with_source_code
1051 struct print_file_list **pp, *p;
1053 for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1054 if (strcmp ((*pp)->filename, filename) == 0)
1060 if (p != print_files)
1064 /* We have reencountered a file name which we saw
1065 earlier. This implies that either we are dumping out
1066 code from an included file, or the same file was
1067 linked in more than once. There are two common cases
1068 of an included file: inline functions in a header
1069 file, and a bison or flex skeleton file. In the
1070 former case we want to just start printing (but we
1071 back up a few lines to give context); in the latter
1072 case we want to continue from where we left off. I
1073 can't think of a good way to distinguish the cases,
1074 so I used a heuristic based on the file name. */
1075 if (strcmp (p->filename + strlen (p->filename) - 2, ".h") != 0)
1079 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1086 p->f = fopen (p->filename, "r");
1090 skip_to_line (p, l, false);
1092 if (print_files->f != NULL)
1094 fclose (print_files->f);
1095 print_files->f = NULL;
1101 skip_to_line (p, line, true);
1103 p->next = print_files;
1111 f = fopen (filename, "r");
1116 p = ((struct print_file_list *)
1117 xmalloc (sizeof (struct print_file_list)));
1118 p->filename = xmalloc (strlen (filename) + 1);
1119 strcpy (p->filename, filename);
1123 if (print_files != NULL && print_files->f != NULL)
1125 fclose (print_files->f);
1126 print_files->f = NULL;
1128 p->next = print_files;
1131 if (file_start_context)
1134 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1137 skip_to_line (p, l, false);
1139 skip_to_line (p, line, true);
1144 if (functionname != NULL
1145 && (prev_functionname == NULL
1146 || strcmp (functionname, prev_functionname) != 0))
1148 if (prev_functionname != NULL)
1149 free (prev_functionname);
1150 prev_functionname = xmalloc (strlen (functionname) + 1);
1151 strcpy (prev_functionname, functionname);
1154 if (line > 0 && line != prev_line)
1158 /* Pseudo FILE object for strings. */
1166 /* sprintf to a "stream" */
1169 #ifdef ANSI_PROTOTYPES
1170 objdump_sprintf (SFILE *f, const char *format, ...)
1172 objdump_sprintf (va_alist)
1176 #ifndef ANSI_PROTOTYPES
1184 #ifdef ANSI_PROTOTYPES
1185 va_start (args, format);
1188 f = va_arg (args, SFILE *);
1189 format = va_arg (args, const char *);
1192 vasprintf (&buf, format, args);
1198 fatal (_("Out of virtual memory"));
1203 while ((size_t) ((f->buffer + f->size) - f->current) < n + 1)
1207 curroff = f->current - f->buffer;
1209 f->buffer = xrealloc (f->buffer, f->size);
1210 f->current = f->buffer + curroff;
1213 memcpy (f->current, buf, n);
1215 f->current[0] = '\0';
1222 /* The number of zeroes we want to see before we start skipping them.
1223 The number is arbitrarily chosen. */
1226 #define SKIP_ZEROES (8)
1229 /* The number of zeroes to skip at the end of a section. If the
1230 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1231 SKIP_ZEROES, they will be disassembled. If there are fewer than
1232 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1233 attempt to avoid disassembling zeroes inserted by section
1236 #ifndef SKIP_ZEROES_AT_END
1237 #define SKIP_ZEROES_AT_END (3)
1240 /* Disassemble some data in memory between given values. */
1243 disassemble_bytes (info, disassemble_fn, insns, data,
1244 start_offset, stop_offset, relppp,
1246 struct disassemble_info *info;
1247 disassembler_ftype disassemble_fn;
1250 bfd_vma start_offset;
1251 bfd_vma stop_offset;
1255 struct objdump_disasm_info *aux;
1257 int octets_per_line;
1259 int skip_addr_chars;
1260 bfd_vma addr_offset;
1261 int opb = info->octets_per_byte;
1263 aux = (struct objdump_disasm_info *) info->application_data;
1267 octets_per_line = 4;
1269 octets_per_line = 16;
1271 /* Figure out how many characters to skip at the start of an
1272 address, to make the disassembly look nicer. We discard leading
1273 zeroes in chunks of 4, ensuring that there is always a leading
1275 skip_addr_chars = 0;
1276 if (! prefix_addresses)
1281 sprintf_vma (buf, section->vma +
1282 bfd_section_size (section->owner, section) / opb);
1284 while (s[0] == '0' && s[1] == '0' && s[2] == '0' && s[3] == '0'
1287 skip_addr_chars += 4;
1292 info->insn_info_valid = 0;
1295 addr_offset = start_offset;
1296 while (addr_offset < stop_offset)
1300 boolean need_nl = false;
1302 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1304 for (z = addr_offset * opb; z < stop_offset * opb; z++)
1307 if (! disassemble_zeroes
1308 && (info->insn_info_valid == 0
1309 || info->branch_delay_insns == 0)
1310 && (z - addr_offset * opb >= SKIP_ZEROES
1311 || (z == stop_offset * opb &&
1312 z - addr_offset * opb < SKIP_ZEROES_AT_END)))
1316 /* If there are more nonzero octets to follow, we only skip
1317 zeroes in multiples of 4, to try to avoid running over
1318 the start of an instruction which happens to start with
1320 if (z != stop_offset * opb)
1321 z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1323 octets = z - addr_offset * opb;
1334 if (with_line_numbers || with_source_code)
1335 /* The line number tables will refer to unadjusted
1336 section VMAs, so we must undo any VMA modifications
1337 when calling show_line. */
1338 show_line (aux->abfd, section, addr_offset - adjust_section_vma);
1340 if (! prefix_addresses)
1344 sprintf_vma (buf, section->vma + addr_offset);
1345 for (s = buf + skip_addr_chars; *s == '0'; s++)
1349 printf ("%s:\t", buf + skip_addr_chars);
1353 aux->require_sec = true;
1354 objdump_print_address (section->vma + addr_offset, info);
1355 aux->require_sec = false;
1362 sfile.buffer = xmalloc (sfile.size);
1363 sfile.current = sfile.buffer;
1364 info->fprintf_func = (fprintf_ftype) objdump_sprintf;
1365 info->stream = (FILE *) &sfile;
1366 info->bytes_per_line = 0;
1367 info->bytes_per_chunk = 0;
1369 #ifdef DISASSEMBLER_NEEDS_RELOCS
1370 /* FIXME: This is wrong. It tests the number of octets
1371 in the last instruction, not the current one. */
1372 if (*relppp < relppend
1373 && (**relppp)->address >= addr_offset
1374 && (**relppp)->address <= addr_offset + octets / opb)
1375 info->flags = INSN_HAS_RELOC;
1380 octets = (*disassemble_fn) (section->vma + addr_offset, info);
1381 info->fprintf_func = (fprintf_ftype) fprintf;
1382 info->stream = stdout;
1383 if (info->bytes_per_line != 0)
1384 octets_per_line = info->bytes_per_line;
1387 if (sfile.current != sfile.buffer)
1388 printf ("%s\n", sfile.buffer);
1389 free (sfile.buffer);
1397 octets = octets_per_line;
1398 if (addr_offset + octets / opb > stop_offset)
1399 octets = (stop_offset - addr_offset) * opb;
1401 for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1403 if (isprint (data[j]))
1404 buf[j - addr_offset * opb] = data[j];
1406 buf[j - addr_offset * opb] = '.';
1408 buf[j - addr_offset * opb] = '\0';
1411 if (prefix_addresses
1413 : show_raw_insn >= 0)
1417 /* If ! prefix_addresses and ! wide_output, we print
1418 octets_per_line octets per line. */
1420 if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1421 pb = octets_per_line;
1423 if (info->bytes_per_chunk)
1424 bpc = info->bytes_per_chunk;
1428 for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1431 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1433 for (k = bpc - 1; k >= 0; k--)
1434 printf ("%02x", (unsigned) data[j + k]);
1439 for (k = 0; k < bpc; k++)
1440 printf ("%02x", (unsigned) data[j + k]);
1445 for (; pb < octets_per_line; pb += bpc)
1449 for (k = 0; k < bpc; k++)
1454 /* Separate raw data from instruction by extra space. */
1465 printf ("%s", sfile.buffer);
1466 free (sfile.buffer);
1469 if (prefix_addresses
1471 : show_raw_insn >= 0)
1479 j = addr_offset * opb + pb;
1481 sprintf_vma (buf, section->vma + j / opb);
1482 for (s = buf + skip_addr_chars; *s == '0'; s++)
1486 printf ("%s:\t", buf + skip_addr_chars);
1488 pb += octets_per_line;
1491 for (; j < addr_offset * opb + pb; j += bpc)
1495 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1497 for (k = bpc - 1; k >= 0; k--)
1498 printf ("%02x", (unsigned) data[j + k]);
1503 for (k = 0; k < bpc; k++)
1504 printf ("%02x", (unsigned) data[j + k]);
1517 if ((section->flags & SEC_RELOC) != 0
1518 #ifndef DISASSEMBLER_NEEDS_RELOCS
1523 while ((*relppp) < relppend
1524 && ((**relppp)->address >= (bfd_vma) addr_offset
1525 && (**relppp)->address < (bfd_vma) addr_offset + octets / opb))
1526 #ifdef DISASSEMBLER_NEEDS_RELOCS
1527 if (! dump_reloc_info)
1541 objdump_print_value (section->vma + q->address, info, true);
1543 printf (": %s\t", q->howto->name);
1545 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1546 printf ("*unknown*");
1549 const char *sym_name;
1551 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1552 if (sym_name != NULL && *sym_name != '\0')
1553 objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
1558 sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1559 sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1560 if (sym_name == NULL || *sym_name == '\0')
1561 sym_name = "*unknown*";
1562 printf ("%s", sym_name);
1569 objdump_print_value (q->addend, info, true);
1581 addr_offset += octets / opb;
1585 /* Disassemble the contents of an object file. */
1588 disassemble_data (abfd)
1591 unsigned long addr_offset;
1592 disassembler_ftype disassemble_fn;
1593 struct disassemble_info disasm_info;
1594 struct objdump_disasm_info aux;
1599 prev_functionname = NULL;
1602 /* We make a copy of syms to sort. We don't want to sort syms
1603 because that will screw up the relocs. */
1604 sorted_syms = (asymbol **) xmalloc (symcount * sizeof (asymbol *));
1605 memcpy (sorted_syms, syms, symcount * sizeof (asymbol *));
1607 sorted_symcount = remove_useless_symbols (sorted_syms, symcount);
1609 /* Sort the symbols into section and symbol order */
1610 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
1612 INIT_DISASSEMBLE_INFO(disasm_info, stdout, fprintf);
1613 disasm_info.application_data = (PTR) &aux;
1615 aux.require_sec = false;
1616 disasm_info.print_address_func = objdump_print_address;
1617 disasm_info.symbol_at_address_func = objdump_symbol_at_address;
1619 if (machine != (char *) NULL)
1621 const bfd_arch_info_type *info = bfd_scan_arch (machine);
1624 fatal (_("Can't use supplied machine %s"), machine);
1626 abfd->arch_info = info;
1629 if (endian != BFD_ENDIAN_UNKNOWN)
1631 struct bfd_target *xvec;
1633 xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target));
1634 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
1635 xvec->byteorder = endian;
1639 disassemble_fn = disassembler (abfd);
1640 if (!disassemble_fn)
1642 non_fatal (_("Can't disassemble for architecture %s\n"),
1643 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
1648 opb = bfd_octets_per_byte (abfd);
1650 disasm_info.flavour = bfd_get_flavour (abfd);
1651 disasm_info.arch = bfd_get_arch (abfd);
1652 disasm_info.mach = bfd_get_mach (abfd);
1653 disasm_info.disassembler_options = disassembler_options;
1654 disasm_info.octets_per_byte = opb;
1656 if (bfd_big_endian (abfd))
1657 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
1658 else if (bfd_little_endian (abfd))
1659 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
1661 /* ??? Aborting here seems too drastic. We could default to big or little
1663 disasm_info.endian = BFD_ENDIAN_UNKNOWN;
1665 for (section = abfd->sections;
1666 section != (asection *) NULL;
1667 section = section->next)
1669 bfd_byte *data = NULL;
1670 bfd_size_type datasize = 0;
1671 arelent **relbuf = NULL;
1672 arelent **relpp = NULL;
1673 arelent **relppend = NULL;
1674 unsigned long stop_offset;
1675 asymbol *sym = NULL;
1678 if ((section->flags & SEC_LOAD) == 0
1679 || (! disassemble_all
1681 && (section->flags & SEC_CODE) == 0))
1683 if (only != (char *) NULL && strcmp (only, section->name) != 0)
1686 if ((section->flags & SEC_RELOC) != 0
1687 #ifndef DISASSEMBLER_NEEDS_RELOCS
1694 relsize = bfd_get_reloc_upper_bound (abfd, section);
1696 bfd_fatal (bfd_get_filename (abfd));
1702 relbuf = (arelent **) xmalloc (relsize);
1703 relcount = bfd_canonicalize_reloc (abfd, section, relbuf, syms);
1705 bfd_fatal (bfd_get_filename (abfd));
1707 /* Sort the relocs by address. */
1708 qsort (relbuf, relcount, sizeof (arelent *), compare_relocs);
1711 relppend = relpp + relcount;
1713 /* Skip over the relocs belonging to addresses below the
1715 if (start_address != (bfd_vma) -1)
1717 while (relpp < relppend
1718 && (*relpp)->address < start_address)
1724 printf (_("Disassembly of section %s:\n"), section->name);
1726 datasize = bfd_get_section_size_before_reloc (section);
1730 data = (bfd_byte *) xmalloc ((size_t) datasize);
1732 bfd_get_section_contents (abfd, section, data, 0, datasize);
1735 disasm_info.buffer = data;
1736 disasm_info.buffer_vma = section->vma;
1737 disasm_info.buffer_length = datasize;
1738 if (start_address == (bfd_vma) -1
1739 || start_address < disasm_info.buffer_vma)
1742 addr_offset = start_address - disasm_info.buffer_vma;
1743 if (stop_address == (bfd_vma) -1)
1744 stop_offset = datasize / opb;
1747 if (stop_address < disasm_info.buffer_vma)
1750 stop_offset = stop_address - disasm_info.buffer_vma;
1751 if (stop_offset > disasm_info.buffer_length / opb)
1752 stop_offset = disasm_info.buffer_length / opb;
1755 sym = find_symbol_for_address (abfd, section, section->vma + addr_offset,
1758 while (addr_offset < stop_offset)
1761 unsigned long nextstop_offset;
1764 if (sym != NULL && bfd_asymbol_value (sym) <= section->vma + addr_offset)
1769 (x < sorted_symcount
1770 && bfd_asymbol_value (sorted_syms[x]) <= section->vma + addr_offset);
1773 disasm_info.symbols = & sorted_syms[place];
1774 disasm_info.num_symbols = x - place;
1777 disasm_info.symbols = NULL;
1779 if (! prefix_addresses)
1782 objdump_print_addr_with_sym (abfd, section, sym,
1783 section->vma + addr_offset,
1789 if (sym != NULL && bfd_asymbol_value (sym) > section->vma + addr_offset)
1791 else if (sym == NULL)
1795 /* Search forward for the next appropriate symbol in
1796 SECTION. Note that all the symbols are sorted
1797 together into one big array, and that some sections
1798 may have overlapping addresses. */
1799 while (place < sorted_symcount
1800 && (sorted_syms[place]->section != section
1801 || (bfd_asymbol_value (sorted_syms[place])
1802 <= bfd_asymbol_value (sym))))
1804 if (place >= sorted_symcount)
1807 nextsym = sorted_syms[place];
1810 if (sym != NULL && bfd_asymbol_value (sym) > section->vma + addr_offset)
1812 nextstop_offset = bfd_asymbol_value (sym) - section->vma;
1813 if (nextstop_offset > stop_offset)
1814 nextstop_offset = stop_offset;
1816 else if (nextsym == NULL)
1817 nextstop_offset = stop_offset;
1820 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
1821 if (nextstop_offset > stop_offset)
1822 nextstop_offset = stop_offset;
1825 /* If a symbol is explicitly marked as being an object
1826 rather than a function, just dump the bytes without
1827 disassembling them. */
1830 || bfd_asymbol_value (sym) > section->vma + addr_offset
1831 || ((sym->flags & BSF_OBJECT) == 0
1832 && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1834 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1836 || (sym->flags & BSF_FUNCTION) != 0)
1841 disassemble_bytes (&disasm_info, disassemble_fn, insns, data,
1842 addr_offset, nextstop_offset, &relpp, relppend);
1844 addr_offset = nextstop_offset;
1856 /* Define a table of stab values and print-strings. We wish the initializer
1857 could be a direct-mapped table, but instead we build one the first
1860 static void dump_section_stabs PARAMS ((bfd *abfd, char *stabsect_name,
1861 char *strsect_name));
1863 /* Dump the stabs sections from an object file that has a section that
1864 uses Sun stabs encoding. */
1870 dump_section_stabs (abfd, ".stab", ".stabstr");
1871 dump_section_stabs (abfd, ".stab.excl", ".stab.exclstr");
1872 dump_section_stabs (abfd, ".stab.index", ".stab.indexstr");
1873 dump_section_stabs (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1876 static bfd_byte *stabs;
1877 static bfd_size_type stab_size;
1879 static char *strtab;
1880 static bfd_size_type stabstr_size;
1882 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1883 and string table section STRSECT_NAME into `strtab'.
1884 If the section exists and was read, allocate the space and return true.
1885 Otherwise return false. */
1888 read_section_stabs (abfd, stabsect_name, strsect_name)
1890 const char *stabsect_name;
1891 const char *strsect_name;
1893 asection *stabsect, *stabstrsect;
1895 stabsect = bfd_get_section_by_name (abfd, stabsect_name);
1898 printf (_("No %s section present\n\n"), stabsect_name);
1902 stabstrsect = bfd_get_section_by_name (abfd, strsect_name);
1903 if (0 == stabstrsect)
1905 non_fatal (_("%s has no %s section"),
1906 bfd_get_filename (abfd), strsect_name);
1911 stab_size = bfd_section_size (abfd, stabsect);
1912 stabstr_size = bfd_section_size (abfd, stabstrsect);
1914 stabs = (bfd_byte *) xmalloc (stab_size);
1915 strtab = (char *) xmalloc (stabstr_size);
1917 if (! bfd_get_section_contents (abfd, stabsect, (PTR) stabs, 0, stab_size))
1919 non_fatal (_("Reading %s section of %s failed: %s"),
1920 stabsect_name, bfd_get_filename (abfd),
1921 bfd_errmsg (bfd_get_error ()));
1928 if (! bfd_get_section_contents (abfd, stabstrsect, (PTR) strtab, 0,
1931 non_fatal (_("Reading %s section of %s failed: %s\n"),
1932 strsect_name, bfd_get_filename (abfd),
1933 bfd_errmsg (bfd_get_error ()));
1943 /* Stabs entries use a 12 byte format:
1944 4 byte string table index
1946 1 byte stab other field
1947 2 byte stab desc field
1949 FIXME: This will have to change for a 64 bit object format. */
1951 #define STRDXOFF (0)
1953 #define OTHEROFF (5)
1956 #define STABSIZE (12)
1958 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1959 using string table section STRSECT_NAME (in `strtab'). */
1962 print_section_stabs (abfd, stabsect_name, strsect_name)
1964 const char *stabsect_name;
1965 const char *strsect_name ATTRIBUTE_UNUSED;
1968 unsigned file_string_table_offset = 0, next_file_string_table_offset = 0;
1969 bfd_byte *stabp, *stabs_end;
1972 stabs_end = stabp + stab_size;
1974 printf (_("Contents of %s section:\n\n"), stabsect_name);
1975 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1977 /* Loop through all symbols and print them.
1979 We start the index at -1 because there is a dummy symbol on
1980 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1982 for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
1986 unsigned char type, other;
1987 unsigned short desc;
1990 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
1991 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
1992 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
1993 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
1994 value = bfd_h_get_32 (abfd, stabp + VALOFF);
1996 printf ("\n%-6d ", i);
1997 /* Either print the stab name, or, if unnamed, print its number
1998 again (makes consistent formatting for tools like awk). */
1999 name = bfd_get_stab_name (type);
2001 printf ("%-6s", name);
2002 else if (type == N_UNDF)
2005 printf ("%-6d", type);
2006 printf (" %-6d %-6d ", other, desc);
2008 printf (" %-6lu", strx);
2010 /* Symbols with type == 0 (N_UNDF) specify the length of the
2011 string table associated with this file. We use that info
2012 to know how to relocate the *next* file's string table indices. */
2016 file_string_table_offset = next_file_string_table_offset;
2017 next_file_string_table_offset += value;
2021 /* Using the (possibly updated) string table offset, print the
2022 string (if any) associated with this symbol. */
2024 if ((strx + file_string_table_offset) < stabstr_size)
2025 printf (" %s", &strtab[strx + file_string_table_offset]);
2034 dump_section_stabs (abfd, stabsect_name, strsect_name)
2036 char *stabsect_name;
2041 /* Check for section names for which stabsect_name is a prefix, to
2042 handle .stab0, etc. */
2043 for (s = abfd->sections;
2049 len = strlen (stabsect_name);
2051 /* If the prefix matches, and the files section name ends with a
2052 nul or a digit, then we match. I.e., we want either an exact
2053 match or a section followed by a number. */
2054 if (strncmp (stabsect_name, s->name, len) == 0
2055 && (s->name[len] == '\000'
2056 || isdigit ((unsigned char) s->name[len])))
2058 if (read_section_stabs (abfd, s->name, strsect_name))
2060 print_section_stabs (abfd, s->name, strsect_name);
2069 dump_bfd_header (abfd)
2074 printf (_("architecture: %s, "),
2075 bfd_printable_arch_mach (bfd_get_arch (abfd),
2076 bfd_get_mach (abfd)));
2077 printf (_("flags 0x%08x:\n"), abfd->flags);
2079 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2080 PF (HAS_RELOC, "HAS_RELOC");
2081 PF (EXEC_P, "EXEC_P");
2082 PF (HAS_LINENO, "HAS_LINENO");
2083 PF (HAS_DEBUG, "HAS_DEBUG");
2084 PF (HAS_SYMS, "HAS_SYMS");
2085 PF (HAS_LOCALS, "HAS_LOCALS");
2086 PF (DYNAMIC, "DYNAMIC");
2087 PF (WP_TEXT, "WP_TEXT");
2088 PF (D_PAGED, "D_PAGED");
2089 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2090 printf (_("\nstart address 0x"));
2091 printf_vma (abfd->start_address);
2096 dump_bfd_private_header (abfd)
2099 bfd_print_private_bfd_data (abfd, stdout);
2102 /* Dump selected contents of ABFD */
2108 /* If we are adjusting section VMA's, change them all now. Changing
2109 the BFD information is a hack. However, we must do it, or
2110 bfd_find_nearest_line will not do the right thing. */
2111 if (adjust_section_vma != 0)
2115 for (s = abfd->sections; s != NULL; s = s->next)
2117 s->vma += adjust_section_vma;
2118 s->lma += adjust_section_vma;
2122 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
2125 print_arelt_descr (stdout, abfd, true);
2126 if (dump_file_header)
2127 dump_bfd_header (abfd);
2128 if (dump_private_headers)
2129 dump_bfd_private_header (abfd);
2131 if (dump_section_headers)
2132 dump_headers (abfd);
2133 if (dump_symtab || dump_reloc_info || disassemble || dump_debugging)
2135 syms = slurp_symtab (abfd);
2137 if (dump_dynamic_symtab || dump_dynamic_reloc_info)
2139 dynsyms = slurp_dynamic_symtab (abfd);
2142 dump_symbols (abfd, false);
2143 if (dump_dynamic_symtab)
2144 dump_symbols (abfd, true);
2145 if (dump_stab_section_info)
2147 if (dump_reloc_info && ! disassemble)
2149 if (dump_dynamic_reloc_info)
2150 dump_dynamic_relocs (abfd);
2151 if (dump_section_contents)
2154 disassemble_data (abfd);
2159 dhandle = read_debugging_info (abfd, syms, symcount);
2160 if (dhandle != NULL)
2162 if (! print_debugging_info (stdout, dhandle))
2164 non_fatal (_("%s: printing debugging information failed"),
2165 bfd_get_filename (abfd));
2188 if (bfd_check_format_matches (abfd, bfd_object, &matching))
2194 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2196 nonfatal (bfd_get_filename (abfd));
2197 list_matching_formats (matching);
2202 if (bfd_get_error () != bfd_error_file_not_recognized)
2204 nonfatal (bfd_get_filename (abfd));
2208 if (bfd_check_format_matches (abfd, bfd_core, &matching))
2214 nonfatal (bfd_get_filename (abfd));
2216 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2218 list_matching_formats (matching);
2224 display_file (filename, target)
2228 bfd *file, *arfile = (bfd *) NULL;
2230 file = bfd_openr (filename, target);
2233 nonfatal (filename);
2237 if (bfd_check_format (file, bfd_archive) == true)
2239 bfd *last_arfile = NULL;
2241 printf (_("In archive %s:\n"), bfd_get_filename (file));
2244 bfd_set_error (bfd_error_no_error);
2246 arfile = bfd_openr_next_archived_file (file, arfile);
2249 if (bfd_get_error () != bfd_error_no_more_archived_files)
2250 nonfatal (bfd_get_filename (file));
2254 display_bfd (arfile);
2256 if (last_arfile != NULL)
2257 bfd_close (last_arfile);
2258 last_arfile = arfile;
2261 if (last_arfile != NULL)
2262 bfd_close (last_arfile);
2270 /* Actually display the various requested regions */
2278 bfd_size_type datasize = 0;
2279 bfd_size_type addr_offset;
2280 bfd_size_type start_offset, stop_offset;
2281 unsigned int opb = bfd_octets_per_byte (abfd);
2283 for (section = abfd->sections; section != NULL; section =
2288 if (only == (char *) NULL ||
2289 strcmp (only, section->name) == 0)
2291 if (section->flags & SEC_HAS_CONTENTS)
2293 printf (_("Contents of section %s:\n"), section->name);
2295 if (bfd_section_size (abfd, section) == 0)
2297 data = (bfd_byte *) xmalloc ((size_t) bfd_section_size (abfd, section));
2298 datasize = bfd_section_size (abfd, section);
2301 bfd_get_section_contents (abfd, section, (PTR) data, 0, bfd_section_size (abfd, section));
2303 if (start_address == (bfd_vma) -1
2304 || start_address < section->vma)
2307 start_offset = start_address - section->vma;
2308 if (stop_address == (bfd_vma) -1)
2309 stop_offset = bfd_section_size (abfd, section) / opb;
2312 if (stop_address < section->vma)
2315 stop_offset = stop_address - section->vma;
2316 if (stop_offset > bfd_section_size (abfd, section) / opb)
2317 stop_offset = bfd_section_size (abfd, section) / opb;
2319 for (addr_offset = start_offset;
2320 addr_offset < stop_offset; addr_offset += onaline)
2324 printf (" %04lx ", (unsigned long int)
2325 (addr_offset + section->vma));
2326 for (j = addr_offset * opb;
2327 j < addr_offset * opb + onaline; j++)
2329 if (j < stop_offset * opb)
2330 printf ("%02x", (unsigned) (data[j]));
2338 for (j = addr_offset; j < addr_offset * opb + onaline; j++)
2340 if (j >= stop_offset * opb)
2343 printf ("%c", isprint (data[j]) ? data[j] : '.');
2353 /* Should perhaps share code and display with nm? */
2355 dump_symbols (abfd, dynamic)
2356 bfd *abfd ATTRIBUTE_UNUSED;
2369 printf ("DYNAMIC SYMBOL TABLE:\n");
2377 printf ("SYMBOL TABLE:\n");
2380 for (count = 0; count < max; count++)
2384 bfd *cur_bfd = bfd_asymbol_bfd (*current);
2386 if (cur_bfd != NULL)
2391 name = bfd_asymbol_name (*current);
2393 if (do_demangle && name != NULL && *name != '\0')
2397 /* If we want to demangle the name, we demangle it
2398 here, and temporarily clobber it while calling
2399 bfd_print_symbol. FIXME: This is a gross hack. */
2402 if (bfd_get_symbol_leading_char (cur_bfd) == *n)
2404 alloc = cplus_demangle (n, DMGL_ANSI | DMGL_PARAMS);
2406 (*current)->name = alloc;
2408 (*current)->name = n;
2411 bfd_print_symbol (cur_bfd, stdout, *current,
2412 bfd_print_symbol_all);
2414 (*current)->name = name;
2435 for (a = abfd->sections; a != (asection *) NULL; a = a->next)
2439 if (bfd_is_abs_section (a))
2441 if (bfd_is_und_section (a))
2443 if (bfd_is_com_section (a))
2448 if (strcmp (only, a->name))
2451 else if ((a->flags & SEC_RELOC) == 0)
2454 relsize = bfd_get_reloc_upper_bound (abfd, a);
2456 bfd_fatal (bfd_get_filename (abfd));
2458 printf ("RELOCATION RECORDS FOR [%s]:", a->name);
2462 printf (" (none)\n\n");
2466 relpp = (arelent **) xmalloc (relsize);
2467 relcount = bfd_canonicalize_reloc (abfd, a, relpp, syms);
2469 bfd_fatal (bfd_get_filename (abfd));
2470 else if (relcount == 0)
2472 printf (" (none)\n\n");
2477 dump_reloc_set (abfd, a, relpp, relcount);
2486 dump_dynamic_relocs (abfd)
2493 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2495 bfd_fatal (bfd_get_filename (abfd));
2497 printf ("DYNAMIC RELOCATION RECORDS");
2501 printf (" (none)\n\n");
2505 relpp = (arelent **) xmalloc (relsize);
2506 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2508 bfd_fatal (bfd_get_filename (abfd));
2509 else if (relcount == 0)
2511 printf (" (none)\n\n");
2516 dump_reloc_set (abfd, (asection *) NULL, relpp, relcount);
2524 dump_reloc_set (abfd, sec, relpp, relcount)
2531 char *last_filename, *last_functionname;
2532 unsigned int last_line;
2534 /* Get column headers lined up reasonably. */
2540 sprintf_vma (buf, (bfd_vma) -1);
2541 width = strlen (buf) - 7;
2543 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2546 last_filename = NULL;
2547 last_functionname = NULL;
2550 for (p = relpp; relcount && *p != (arelent *) NULL; p++, relcount--)
2553 const char *filename, *functionname;
2555 const char *sym_name;
2556 const char *section_name;
2558 if (start_address != (bfd_vma) -1
2559 && q->address < start_address)
2561 if (stop_address != (bfd_vma) -1
2562 && q->address > stop_address)
2565 if (with_line_numbers
2567 && bfd_find_nearest_line (abfd, sec, syms, q->address,
2568 &filename, &functionname, &line))
2570 if (functionname != NULL
2571 && (last_functionname == NULL
2572 || strcmp (functionname, last_functionname) != 0))
2574 printf ("%s():\n", functionname);
2575 if (last_functionname != NULL)
2576 free (last_functionname);
2577 last_functionname = xstrdup (functionname);
2580 && (line != last_line
2581 || (filename != NULL
2582 && last_filename != NULL
2583 && strcmp (filename, last_filename) != 0)))
2585 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2587 if (last_filename != NULL)
2588 free (last_filename);
2589 if (filename == NULL)
2590 last_filename = NULL;
2592 last_filename = xstrdup (filename);
2596 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2598 sym_name = (*(q->sym_ptr_ptr))->name;
2599 section_name = (*(q->sym_ptr_ptr))->section->name;
2604 section_name = NULL;
2608 printf_vma (q->address);
2610 printf (" %-16s ", q->howto->name);
2612 printf (" %-16d ", q->howto->type);
2613 objdump_print_symname (abfd, (struct disassemble_info *) NULL,
2618 if (section_name == (CONST char *) NULL)
2619 section_name = "*unknown*";
2620 printf_vma (q->address);
2621 printf (" %-16s [%s]",
2628 printf_vma (q->addend);
2634 /* The length of the longest architecture name + 1. */
2635 #define LONGEST_ARCH sizeof("powerpc:common")
2638 endian_string (endian)
2639 enum bfd_endian endian;
2641 if (endian == BFD_ENDIAN_BIG)
2642 return "big endian";
2643 else if (endian == BFD_ENDIAN_LITTLE)
2644 return "little endian";
2646 return "endianness unknown";
2649 /* List the targets that BFD is configured to support, each followed
2650 by its endianness and the architectures it supports. */
2653 display_target_list ()
2655 extern const bfd_target *const *bfd_target_vector;
2659 dummy_name = make_temp_file (NULL);
2660 for (t = 0; bfd_target_vector[t]; t++)
2662 const bfd_target *p = bfd_target_vector[t];
2663 bfd *abfd = bfd_openw (dummy_name, p->name);
2666 printf ("%s\n (header %s, data %s)\n", p->name,
2667 endian_string (p->header_byteorder),
2668 endian_string (p->byteorder));
2672 nonfatal (dummy_name);
2676 if (! bfd_set_format (abfd, bfd_object))
2678 if (bfd_get_error () != bfd_error_invalid_operation)
2680 bfd_close_all_done (abfd);
2684 for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++)
2685 if (bfd_set_arch_mach (abfd, (enum bfd_architecture) a, 0))
2687 bfd_printable_arch_mach ((enum bfd_architecture) a, 0));
2688 bfd_close_all_done (abfd);
2690 unlink (dummy_name);
2694 /* Print a table showing which architectures are supported for entries
2695 FIRST through LAST-1 of bfd_target_vector (targets across,
2696 architectures down). */
2699 display_info_table (first, last)
2703 extern const bfd_target *const *bfd_target_vector;
2707 /* Print heading of target names. */
2708 printf ("\n%*s", (int) LONGEST_ARCH, " ");
2709 for (t = first; t < last && bfd_target_vector[t]; t++)
2710 printf ("%s ", bfd_target_vector[t]->name);
2713 dummy_name = make_temp_file (NULL);
2714 for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++)
2715 if (strcmp (bfd_printable_arch_mach (a, 0), "UNKNOWN!") != 0)
2717 printf ("%*s ", (int) LONGEST_ARCH - 1,
2718 bfd_printable_arch_mach (a, 0));
2719 for (t = first; t < last && bfd_target_vector[t]; t++)
2721 const bfd_target *p = bfd_target_vector[t];
2723 bfd *abfd = bfd_openw (dummy_name, p->name);
2733 if (! bfd_set_format (abfd, bfd_object))
2735 if (bfd_get_error () != bfd_error_invalid_operation)
2743 if (! bfd_set_arch_mach (abfd, a, 0))
2748 printf ("%s ", p->name);
2751 int l = strlen (p->name);
2757 bfd_close_all_done (abfd);
2761 unlink (dummy_name);
2765 /* Print tables of all the target-architecture combinations that
2766 BFD has been configured to support. */
2769 display_target_tables ()
2772 extern const bfd_target *const *bfd_target_vector;
2776 colum = getenv ("COLUMNS");
2778 columns = atoi (colum);
2783 while (bfd_target_vector[t] != NULL)
2787 wid = LONGEST_ARCH + strlen (bfd_target_vector[t]->name) + 1;
2789 while (wid < columns && bfd_target_vector[t] != NULL)
2793 newwid = wid + strlen (bfd_target_vector[t]->name) + 1;
2794 if (newwid >= columns)
2799 display_info_table (oldt, t);
2806 printf (_("BFD header file version %s\n"), BFD_VERSION);
2807 display_target_list ();
2808 display_target_tables ();
2817 char *target = default_target;
2818 boolean seenflag = false;
2820 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
2821 setlocale (LC_MESSAGES, "");
2823 bindtextdomain (PACKAGE, LOCALEDIR);
2824 textdomain (PACKAGE);
2826 program_name = *argv;
2827 xmalloc_set_program_name (program_name);
2829 START_PROGRESS (program_name, 0);
2832 set_default_bfd_target ();
2834 while ((c = getopt_long (argc, argv, "pib:m:M:VCdDlfahHrRtTxsSj:wE:zgG",
2835 long_options, (int *) 0))
2841 break; /* we've been given a long option */
2846 disassembler_options = optarg;
2852 with_line_numbers = true;
2861 enum demangling_styles style;
2863 style = cplus_demangle_name_to_style (optarg);
2864 if (style == unknown_demangling)
2865 fatal (_("unknown demangling style `%s'"),
2868 cplus_demangle_set_style (style);
2874 case OPTION_ADJUST_VMA:
2875 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
2877 case OPTION_START_ADDRESS:
2878 start_address = parse_vma (optarg, "--start-address");
2880 case OPTION_STOP_ADDRESS:
2881 stop_address = parse_vma (optarg, "--stop-address");
2884 if (strcmp (optarg, "B") == 0)
2885 endian = BFD_ENDIAN_BIG;
2886 else if (strcmp (optarg, "L") == 0)
2887 endian = BFD_ENDIAN_LITTLE;
2890 non_fatal (_("unrecognized -E option"));
2895 if (strncmp (optarg, "big", strlen (optarg)) == 0)
2896 endian = BFD_ENDIAN_BIG;
2897 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
2898 endian = BFD_ENDIAN_LITTLE;
2901 non_fatal (_("unrecognized --endian type `%s'"), optarg);
2907 dump_file_header = true;
2911 formats_info = true;
2915 dump_private_headers = true;
2919 dump_private_headers = true;
2921 dump_reloc_info = true;
2922 dump_file_header = true;
2923 dump_ar_hdrs = true;
2924 dump_section_headers = true;
2932 dump_dynamic_symtab = true;
2940 disassemble_zeroes = true;
2944 disassemble_all = true;
2949 with_source_code = true;
2957 dump_stab_section_info = true;
2961 dump_section_contents = true;
2965 dump_reloc_info = true;
2969 dump_dynamic_reloc_info = true;
2973 dump_ar_hdrs = true;
2977 dump_section_headers = true;
2984 show_version = true;
2994 print_version ("objdump");
2996 if (seenflag == false)
3004 display_file ("a.out", target);
3006 for (; optind < argc;)
3007 display_file (argv[optind++], target);
3010 END_PROGRESS (program_name);