1 /* objdump.c -- dump information about an object file.
2 Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 1999
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 #ifdef ANSI_PROTOTYPES
38 /* Internal headers for the ELF .stab-dump code - sorry. */
39 #define BYTES_IN_WORD 32
40 #include "aout/aout64.h"
42 #ifdef NEED_DECLARATION_FPRINTF
43 /* This is needed by INIT_DISASSEMBLE_INFO. */
44 extern int fprintf PARAMS ((FILE *, const char *, ...));
48 static int exit_status = 0;
50 static char *default_target = NULL; /* default at runtime */
52 static int show_version = 0; /* show the version number */
53 static int dump_section_contents; /* -s */
54 static int dump_section_headers; /* -h */
55 static boolean dump_file_header; /* -f */
56 static int dump_symtab; /* -t */
57 static int dump_dynamic_symtab; /* -T */
58 static int dump_reloc_info; /* -r */
59 static int dump_dynamic_reloc_info; /* -R */
60 static int dump_ar_hdrs; /* -a */
61 static int dump_private_headers; /* -p */
62 static int prefix_addresses; /* --prefix-addresses */
63 static int with_line_numbers; /* -l */
64 static boolean with_source_code; /* -S */
65 static int show_raw_insn; /* --show-raw-insn */
66 static int dump_stab_section_info; /* --stabs */
67 static int do_demangle; /* -C, --demangle */
68 static boolean disassemble; /* -d */
69 static boolean disassemble_all; /* -D */
70 static int disassemble_zeroes; /* --disassemble-zeroes */
71 static boolean formats_info; /* -i */
72 static char *only; /* -j secname */
73 static int wide_output; /* -w */
74 static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
75 static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */
76 static int dump_debugging; /* --debugging */
77 static bfd_vma adjust_section_vma = 0; /* --adjust-vma */
78 static int file_start_context = 0; /* --file-start-context */
80 /* Extra info to pass to the disassembler address printing function. */
81 struct objdump_disasm_info {
87 /* Architecture to disassemble for, or default if NULL. */
88 static char *machine = (char *) NULL;
90 /* Target specific options to the disassembler. */
91 static char *disassembler_options = (char *) NULL;
93 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
94 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
96 /* The symbol table. */
97 static asymbol **syms;
99 /* Number of symbols in `syms'. */
100 static long symcount = 0;
102 /* The sorted symbol table. */
103 static asymbol **sorted_syms;
105 /* Number of symbols in `sorted_syms'. */
106 static long sorted_symcount = 0;
108 /* The dynamic symbol table. */
109 static asymbol **dynsyms;
111 /* Number of symbols in `dynsyms'. */
112 static long dynsymcount = 0;
114 /* Static declarations. */
117 usage PARAMS ((FILE *, int));
120 nonfatal PARAMS ((const char *));
123 display_file PARAMS ((char *filename, char *target));
126 dump_section_header PARAMS ((bfd *, asection *, PTR));
129 dump_headers PARAMS ((bfd *));
132 dump_data PARAMS ((bfd *abfd));
135 dump_relocs PARAMS ((bfd *abfd));
138 dump_dynamic_relocs PARAMS ((bfd * abfd));
141 dump_reloc_set PARAMS ((bfd *, asection *, arelent **, long));
144 dump_symbols PARAMS ((bfd *abfd, boolean dynamic));
147 dump_bfd_header PARAMS ((bfd *));
150 dump_bfd_private_header PARAMS ((bfd *));
153 display_bfd PARAMS ((bfd *abfd));
156 display_target_list PARAMS ((void));
159 display_info_table PARAMS ((int, int));
162 display_target_tables PARAMS ((void));
165 display_info PARAMS ((void));
168 objdump_print_value PARAMS ((bfd_vma, struct disassemble_info *, boolean));
171 objdump_print_symname PARAMS ((bfd *, struct disassemble_info *, asymbol *));
174 find_symbol_for_address PARAMS ((bfd *, asection *, bfd_vma, boolean, long *));
177 objdump_print_addr_with_sym PARAMS ((bfd *, asection *, asymbol *, bfd_vma,
178 struct disassemble_info *, boolean));
181 objdump_print_addr PARAMS ((bfd_vma, struct disassemble_info *, boolean));
184 objdump_print_address PARAMS ((bfd_vma, struct disassemble_info *));
187 show_line PARAMS ((bfd *, asection *, bfd_vma));
190 disassemble_bytes PARAMS ((struct disassemble_info *, disassembler_ftype,
191 boolean, bfd_byte *, bfd_vma, bfd_vma,
192 arelent ***, arelent **));
195 disassemble_data PARAMS ((bfd *));
198 endian_string PARAMS ((enum bfd_endian));
201 slurp_symtab PARAMS ((bfd *));
204 slurp_dynamic_symtab PARAMS ((bfd *));
207 remove_useless_symbols PARAMS ((asymbol **, long));
210 compare_symbols PARAMS ((const PTR, const PTR));
213 compare_relocs PARAMS ((const PTR, const PTR));
216 dump_stabs PARAMS ((bfd *));
219 read_section_stabs PARAMS ((bfd *, const char *, const char *));
222 print_section_stabs PARAMS ((bfd *, const char *, const char *));
225 usage (stream, status)
229 fprintf (stream, _("Usage: %s <switches> file(s)\n"), program_name);
230 fprintf (stream, _(" At least one of the following switches must be given:\n"));
231 fprintf (stream, _("\
232 -a --archive-headers Display archive header information\n\
233 -f --file-headers Display the contents of the overall file header\n\
234 -p --private-headers Display object format specific file header contents\n\
235 -h --[section-]headers Display the contents of the section headers\n\
236 -x --all-headers Display the contents of all headers\n\
237 -d --disassemble Display assembler contents of executable sections\n\
238 -D --disassemble-all Display assembler contents of all sections\n\
239 -S --source Intermix source code with disassembly\n\
240 -s --full-contents Display the full contents of all sections requested\n\
241 -g --debugging Display debug information in object file\n\
242 -G --stabs Display the STABS contents of an ELF format file\n\
243 -t --syms Display the contents of the symbol table(s)\n\
244 -T --dynamic-syms Display the contents of the dynamic symbol table\n\
245 -r --reloc Display the relocation entries in the file\n\
246 -R --dynamic-reloc Display the dynamic relocation entries in the file\n\
247 -V --version Display this program's version number\n\
248 -i --info List object formats and architectures supported\n\
249 -H --help Display this information\n\
253 fprintf (stream, _("\n The following switches are optional:\n"));
254 fprintf (stream, _("\
255 -b --target <bfdname> Specify the target object format as <bfdname>\n\
256 -m --architecture <machine> Specify the target architecture as <machine>\n\
257 -j --section <name> Only display information for section <name>\n\
258 -M --disassembler-options <o> Pass text <o> on to the disassembler\n\
259 -EB --endian=big Assume big endian format when disassembling\n\
260 -EL --endian=little Assume little endian format when disassembling\n\
261 --file-start-context Include context from start of file (with -S)\n\
262 -l --line-numbers Include line numbers and filenames in output\n\
263 -C --demangle Decode mangled/processed symbol names\n\
264 -w --wide Format output for more than 80 columns\n\
265 -z --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
266 --start-address <addr> Only process data whoes address is >= <addr>\n\
267 --stop-address <addr> Only process data whoes address is <= <addr>\n\
268 --prefix-addresses Print complete address alongside disassembly\n\
269 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
270 --adjust-vma <offset> Add <offset> to all displayed section addresses\n\
272 list_supported_targets (program_name, stream);
274 disassembler_usage (stream);
277 fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
281 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
283 #define OPTION_ENDIAN (150)
284 #define OPTION_START_ADDRESS (OPTION_ENDIAN + 1)
285 #define OPTION_STOP_ADDRESS (OPTION_START_ADDRESS + 1)
286 #define OPTION_ADJUST_VMA (OPTION_STOP_ADDRESS + 1)
288 static struct option long_options[]=
290 {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
291 {"all-headers", no_argument, NULL, 'x'},
292 {"private-headers", no_argument, NULL, 'p'},
293 {"architecture", required_argument, NULL, 'm'},
294 {"archive-headers", no_argument, NULL, 'a'},
295 {"debugging", no_argument, NULL, 'g'},
296 {"demangle", no_argument, NULL, 'C'},
297 {"disassemble", no_argument, NULL, 'd'},
298 {"disassemble-all", no_argument, NULL, 'D'},
299 {"disassembler-options", required_argument, NULL, 'M'},
300 {"disassemble-zeroes", no_argument, NULL, 'z'},
301 {"dynamic-reloc", no_argument, NULL, 'R'},
302 {"dynamic-syms", no_argument, NULL, 'T'},
303 {"endian", required_argument, NULL, OPTION_ENDIAN},
304 {"file-headers", no_argument, NULL, 'f'},
305 {"file-start-context", no_argument, &file_start_context, 1},
306 {"full-contents", no_argument, NULL, 's'},
307 {"headers", no_argument, NULL, 'h'},
308 {"help", no_argument, NULL, 'H'},
309 {"info", no_argument, NULL, 'i'},
310 {"line-numbers", no_argument, NULL, 'l'},
311 {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
312 {"prefix-addresses", no_argument, &prefix_addresses, 1},
313 {"reloc", no_argument, NULL, 'r'},
314 {"section", required_argument, NULL, 'j'},
315 {"section-headers", no_argument, NULL, 'h'},
316 {"show-raw-insn", no_argument, &show_raw_insn, 1},
317 {"source", no_argument, NULL, 'S'},
318 {"stabs", no_argument, NULL, 'G'},
319 {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
320 {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
321 {"syms", no_argument, NULL, 't'},
322 {"target", required_argument, NULL, 'b'},
323 {"version", no_argument, NULL, 'V'},
324 {"wide", no_argument, NULL, 'w'},
325 {0, no_argument, 0, 0}
337 dump_section_header (abfd, section, ignored)
338 bfd *abfd ATTRIBUTE_UNUSED;
340 PTR ignored ATTRIBUTE_UNUSED;
343 unsigned int opb = bfd_octets_per_byte (abfd);
345 printf ("%3d %-13s %08lx ", section->index,
346 bfd_get_section_name (abfd, section),
347 (unsigned long) bfd_section_size (abfd, section) / opb);
348 printf_vma (bfd_get_section_vma (abfd, section));
350 printf_vma (section->lma);
351 printf (" %08lx 2**%u", section->filepos,
352 bfd_get_section_alignment (abfd, section));
358 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
360 PF (SEC_HAS_CONTENTS, "CONTENTS");
361 PF (SEC_ALLOC, "ALLOC");
362 PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
363 PF (SEC_CONSTRUCTOR_TEXT, "CONSTRUCTOR TEXT");
364 PF (SEC_CONSTRUCTOR_DATA, "CONSTRUCTOR DATA");
365 PF (SEC_CONSTRUCTOR_BSS, "CONSTRUCTOR BSS");
366 PF (SEC_LOAD, "LOAD");
367 PF (SEC_RELOC, "RELOC");
369 PF (SEC_BALIGN, "BALIGN");
371 PF (SEC_READONLY, "READONLY");
372 PF (SEC_CODE, "CODE");
373 PF (SEC_DATA, "DATA");
375 PF (SEC_DEBUGGING, "DEBUGGING");
376 PF (SEC_NEVER_LOAD, "NEVER_LOAD");
377 PF (SEC_EXCLUDE, "EXCLUDE");
378 PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
379 PF (SEC_BLOCK, "BLOCK");
380 PF (SEC_CLINK, "CLINK");
381 PF (SEC_SMALL_DATA, "SMALL_DATA");
382 PF (SEC_SHARED, "SHARED");
384 if ((section->flags & SEC_LINK_ONCE) != 0)
388 switch (section->flags & SEC_LINK_DUPLICATES)
392 case SEC_LINK_DUPLICATES_DISCARD:
393 ls = "LINK_ONCE_DISCARD";
395 case SEC_LINK_DUPLICATES_ONE_ONLY:
396 ls = "LINK_ONCE_ONE_ONLY";
398 case SEC_LINK_DUPLICATES_SAME_SIZE:
399 ls = "LINK_ONCE_SAME_SIZE";
401 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
402 ls = "LINK_ONCE_SAME_CONTENTS";
405 printf ("%s%s", comma, ls);
407 if (section->comdat != NULL)
408 printf (" (COMDAT %s %ld)", section->comdat->name,
409 section->comdat->symbol);
422 printf (_("Sections:\n"));
425 printf (_("Idx Name Size VMA LMA File off Algn"));
427 printf (_("Idx Name Size VMA LMA File off Algn"));
431 printf (_(" Flags"));
434 bfd_map_over_sections (abfd, dump_section_header, (PTR) NULL);
441 asymbol **sy = (asymbol **) NULL;
444 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
446 fprintf (stderr, _("%s: no symbols\n"), bfd_get_filename (abfd));
451 storage = bfd_get_symtab_upper_bound (abfd);
453 bfd_fatal (bfd_get_filename (abfd));
457 sy = (asymbol **) xmalloc (storage);
459 symcount = bfd_canonicalize_symtab (abfd, sy);
461 bfd_fatal (bfd_get_filename (abfd));
463 fprintf (stderr, _("%s: no symbols\n"), bfd_get_filename (abfd));
467 /* Read in the dynamic symbols. */
470 slurp_dynamic_symtab (abfd)
473 asymbol **sy = (asymbol **) NULL;
476 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
479 if (!(bfd_get_file_flags (abfd) & DYNAMIC))
481 fprintf (stderr, _("%s: %s: not a dynamic object\n"),
482 program_name, bfd_get_filename (abfd));
487 bfd_fatal (bfd_get_filename (abfd));
492 sy = (asymbol **) xmalloc (storage);
494 dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
496 bfd_fatal (bfd_get_filename (abfd));
497 if (dynsymcount == 0)
498 fprintf (stderr, _("%s: %s: No dynamic symbols\n"),
499 program_name, bfd_get_filename (abfd));
503 /* Filter out (in place) symbols that are useless for disassembly.
504 COUNT is the number of elements in SYMBOLS.
505 Return the number of useful symbols. */
508 remove_useless_symbols (symbols, count)
512 register asymbol **in_ptr = symbols, **out_ptr = symbols;
516 asymbol *sym = *in_ptr++;
518 if (sym->name == NULL || sym->name[0] == '\0')
520 if (sym->flags & (BSF_DEBUGGING))
522 if (bfd_is_und_section (sym->section)
523 || bfd_is_com_section (sym->section))
528 return out_ptr - symbols;
531 /* Sort symbols into value order. */
534 compare_symbols (ap, bp)
538 const asymbol *a = *(const asymbol **)ap;
539 const asymbol *b = *(const asymbol **)bp;
543 flagword aflags, bflags;
545 if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
547 else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
550 if (a->section > b->section)
552 else if (a->section < b->section)
555 an = bfd_asymbol_name (a);
556 bn = bfd_asymbol_name (b);
560 /* The symbols gnu_compiled and gcc2_compiled convey no real
561 information, so put them after other symbols with the same value. */
563 af = (strstr (an, "gnu_compiled") != NULL
564 || strstr (an, "gcc2_compiled") != NULL);
565 bf = (strstr (bn, "gnu_compiled") != NULL
566 || strstr (bn, "gcc2_compiled") != NULL);
573 /* We use a heuristic for the file name, to try to sort it after
574 more useful symbols. It may not work on non Unix systems, but it
575 doesn't really matter; the only difference is precisely which
576 symbol names get printed. */
578 #define file_symbol(s, sn, snl) \
579 (((s)->flags & BSF_FILE) != 0 \
580 || ((sn)[(snl) - 2] == '.' \
581 && ((sn)[(snl) - 1] == 'o' \
582 || (sn)[(snl) - 1] == 'a')))
584 af = file_symbol (a, an, anl);
585 bf = file_symbol (b, bn, bnl);
592 /* Try to sort global symbols before local symbols before function
593 symbols before debugging symbols. */
598 if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
600 if ((aflags & BSF_DEBUGGING) != 0)
605 if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
607 if ((aflags & BSF_FUNCTION) != 0)
612 if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
614 if ((aflags & BSF_LOCAL) != 0)
619 if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
621 if ((aflags & BSF_GLOBAL) != 0)
627 /* Symbols that start with '.' might be section names, so sort them
628 after symbols that don't start with '.'. */
629 if (an[0] == '.' && bn[0] != '.')
631 if (an[0] != '.' && bn[0] == '.')
634 /* Finally, if we can't distinguish them in any other way, try to
635 get consistent results by sorting the symbols by name. */
636 return strcmp (an, bn);
639 /* Sort relocs into address order. */
642 compare_relocs (ap, bp)
646 const arelent *a = *(const arelent **)ap;
647 const arelent *b = *(const arelent **)bp;
649 if (a->address > b->address)
651 else if (a->address < b->address)
654 /* So that associated relocations tied to the same address show up
655 in the correct order, we don't do any further sorting. */
664 /* Print VMA to STREAM. If SKIP_ZEROES is true, omit leading zeroes. */
667 objdump_print_value (vma, info, skip_zeroes)
669 struct disassemble_info *info;
675 sprintf_vma (buf, vma);
680 for (p = buf; *p == '0'; ++p)
685 (*info->fprintf_func) (info->stream, "%s", p);
688 /* Print the name of a symbol. */
691 objdump_print_symname (abfd, info, sym)
693 struct disassemble_info *info;
701 name = bfd_asymbol_name (sym);
702 if (! do_demangle || name[0] == '\0')
706 /* Demangle the name. */
707 if (bfd_get_symbol_leading_char (abfd) == name[0])
710 alloc = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS);
718 (*info->fprintf_func) (info->stream, "%s", print);
720 printf ("%s", print);
726 /* Locate a symbol given a bfd, a section, and a VMA. If REQUIRE_SEC
727 is true, then always require the symbol to be in the section. This
728 returns NULL if there is no suitable symbol. If PLACE is not NULL,
729 then *PLACE is set to the index of the symbol in sorted_syms. */
732 find_symbol_for_address (abfd, sec, vma, require_sec, place)
739 /* @@ Would it speed things up to cache the last two symbols returned,
740 and maybe their address ranges? For many processors, only one memory
741 operand can be present at a time, so the 2-entry cache wouldn't be
742 constantly churned by code doing heavy memory accesses. */
744 /* Indices in `sorted_syms'. */
746 long max = sorted_symcount;
748 unsigned int opb = bfd_octets_per_byte (abfd);
750 if (sorted_symcount < 1)
753 /* Perform a binary search looking for the closest symbol to the
754 required value. We are searching the range (min, max]. */
755 while (min + 1 < max)
759 thisplace = (max + min) / 2;
760 sym = sorted_syms[thisplace];
762 if (bfd_asymbol_value (sym) > vma)
764 else if (bfd_asymbol_value (sym) < vma)
773 /* The symbol we want is now in min, the low end of the range we
774 were searching. If there are several symbols with the same
775 value, we want the first one. */
778 && (bfd_asymbol_value (sorted_syms[thisplace])
779 == bfd_asymbol_value (sorted_syms[thisplace - 1])))
782 /* If the file is relocateable, and the symbol could be from this
783 section, prefer a symbol from this section over symbols from
784 others, even if the other symbol's value might be closer.
786 Note that this may be wrong for some symbol references if the
787 sections have overlapping memory ranges, but in that case there's
788 no way to tell what's desired without looking at the relocation
791 if (sorted_syms[thisplace]->section != sec
793 || ((abfd->flags & HAS_RELOC) != 0
794 && vma >= bfd_get_section_vma (abfd, sec)
795 && vma < (bfd_get_section_vma (abfd, sec)
796 + bfd_section_size (abfd, sec) / opb))))
800 for (i = thisplace + 1; i < sorted_symcount; i++)
802 if (bfd_asymbol_value (sorted_syms[i])
803 != bfd_asymbol_value (sorted_syms[thisplace]))
809 if (sorted_syms[i]->section == sec
811 || sorted_syms[i - 1]->section != sec
812 || (bfd_asymbol_value (sorted_syms[i])
813 != bfd_asymbol_value (sorted_syms[i - 1]))))
820 if (sorted_syms[thisplace]->section != sec)
822 /* We didn't find a good symbol with a smaller value.
823 Look for one with a larger value. */
824 for (i = thisplace + 1; i < sorted_symcount; i++)
826 if (sorted_syms[i]->section == sec)
834 if (sorted_syms[thisplace]->section != sec
836 || ((abfd->flags & HAS_RELOC) != 0
837 && vma >= bfd_get_section_vma (abfd, sec)
838 && vma < (bfd_get_section_vma (abfd, sec)
839 + bfd_section_size (abfd, sec)))))
841 /* There is no suitable symbol. */
849 return sorted_syms[thisplace];
852 /* Print an address to INFO symbolically. */
855 objdump_print_addr_with_sym (abfd, sec, sym, vma, info, skip_zeroes)
860 struct disassemble_info *info;
863 objdump_print_value (vma, info, skip_zeroes);
869 (*info->fprintf_func) (info->stream, " <%s",
870 bfd_get_section_name (abfd, sec));
871 secaddr = bfd_get_section_vma (abfd, sec);
874 (*info->fprintf_func) (info->stream, "-0x");
875 objdump_print_value (secaddr - vma, info, true);
877 else if (vma > secaddr)
879 (*info->fprintf_func) (info->stream, "+0x");
880 objdump_print_value (vma - secaddr, info, true);
882 (*info->fprintf_func) (info->stream, ">");
886 (*info->fprintf_func) (info->stream, " <");
887 objdump_print_symname (abfd, info, sym);
888 if (bfd_asymbol_value (sym) > vma)
890 (*info->fprintf_func) (info->stream, "-0x");
891 objdump_print_value (bfd_asymbol_value (sym) - vma, info, true);
893 else if (vma > bfd_asymbol_value (sym))
895 (*info->fprintf_func) (info->stream, "+0x");
896 objdump_print_value (vma - bfd_asymbol_value (sym), info, true);
898 (*info->fprintf_func) (info->stream, ">");
902 /* Print VMA to INFO, symbolically if possible. If SKIP_ZEROES is
903 true, don't output leading zeroes. */
906 objdump_print_addr (vma, info, skip_zeroes)
908 struct disassemble_info *info;
911 struct objdump_disasm_info *aux;
914 if (sorted_symcount < 1)
916 (*info->fprintf_func) (info->stream, "0x");
917 objdump_print_value (vma, info, skip_zeroes);
921 aux = (struct objdump_disasm_info *) info->application_data;
922 sym = find_symbol_for_address (aux->abfd, aux->sec, vma, aux->require_sec,
924 objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, info,
928 /* Print VMA to INFO. This function is passed to the disassembler
932 objdump_print_address (vma, info)
934 struct disassemble_info *info;
936 objdump_print_addr (vma, info, ! prefix_addresses);
939 /* Determine of the given address has a symbol associated with it. */
942 objdump_symbol_at_address (vma, info)
944 struct disassemble_info * info;
946 struct objdump_disasm_info * aux;
949 /* No symbols - do not bother checking. */
950 if (sorted_symcount < 1)
953 aux = (struct objdump_disasm_info *) info->application_data;
954 sym = find_symbol_for_address (aux->abfd, aux->sec, vma, aux->require_sec,
957 return (sym != NULL && (bfd_asymbol_value (sym) == vma));
960 /* Hold the last function name and the last line number we displayed
963 static char *prev_functionname;
964 static unsigned int prev_line;
966 /* We keep a list of all files that we have seen when doing a
967 dissassembly with source, so that we know how much of the file to
968 display. This can be important for inlined functions. */
970 struct print_file_list
972 struct print_file_list *next;
978 static struct print_file_list *print_files;
980 /* The number of preceding context lines to show when we start
981 displaying a file for the first time. */
983 #define SHOW_PRECEDING_CONTEXT_LINES (5)
985 /* Skip ahead to a given line in a file, optionally printing each
989 skip_to_line PARAMS ((struct print_file_list *, unsigned int, boolean));
992 skip_to_line (p, line, show)
993 struct print_file_list *p;
997 while (p->line < line)
1001 if (fgets (buf, sizeof buf, p->f) == NULL)
1011 if (strchr (buf, '\n') != NULL)
1016 /* Show the line number, or the source line, in a dissassembly
1020 show_line (abfd, section, addr_offset)
1023 bfd_vma addr_offset;
1025 CONST char *filename;
1026 CONST char *functionname;
1029 if (! with_line_numbers && ! with_source_code)
1032 if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename,
1033 &functionname, &line))
1036 if (filename != NULL && *filename == '\0')
1038 if (functionname != NULL && *functionname == '\0')
1039 functionname = NULL;
1041 if (with_line_numbers)
1043 if (functionname != NULL
1044 && (prev_functionname == NULL
1045 || strcmp (functionname, prev_functionname) != 0))
1046 printf ("%s():\n", functionname);
1047 if (line > 0 && line != prev_line)
1048 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
1051 if (with_source_code
1055 struct print_file_list **pp, *p;
1057 for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1058 if (strcmp ((*pp)->filename, filename) == 0)
1064 if (p != print_files)
1068 /* We have reencountered a file name which we saw
1069 earlier. This implies that either we are dumping out
1070 code from an included file, or the same file was
1071 linked in more than once. There are two common cases
1072 of an included file: inline functions in a header
1073 file, and a bison or flex skeleton file. In the
1074 former case we want to just start printing (but we
1075 back up a few lines to give context); in the latter
1076 case we want to continue from where we left off. I
1077 can't think of a good way to distinguish the cases,
1078 so I used a heuristic based on the file name. */
1079 if (strcmp (p->filename + strlen (p->filename) - 2, ".h") != 0)
1083 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1090 p->f = fopen (p->filename, "r");
1094 skip_to_line (p, l, false);
1096 if (print_files->f != NULL)
1098 fclose (print_files->f);
1099 print_files->f = NULL;
1105 skip_to_line (p, line, true);
1107 p->next = print_files;
1115 f = fopen (filename, "r");
1120 p = ((struct print_file_list *)
1121 xmalloc (sizeof (struct print_file_list)));
1122 p->filename = xmalloc (strlen (filename) + 1);
1123 strcpy (p->filename, filename);
1127 if (print_files != NULL && print_files->f != NULL)
1129 fclose (print_files->f);
1130 print_files->f = NULL;
1132 p->next = print_files;
1135 if (file_start_context)
1138 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1141 skip_to_line (p, l, false);
1143 skip_to_line (p, line, true);
1148 if (functionname != NULL
1149 && (prev_functionname == NULL
1150 || strcmp (functionname, prev_functionname) != 0))
1152 if (prev_functionname != NULL)
1153 free (prev_functionname);
1154 prev_functionname = xmalloc (strlen (functionname) + 1);
1155 strcpy (prev_functionname, functionname);
1158 if (line > 0 && line != prev_line)
1162 /* Pseudo FILE object for strings. */
1170 /* sprintf to a "stream" */
1173 #ifdef ANSI_PROTOTYPES
1174 objdump_sprintf (SFILE *f, const char *format, ...)
1176 objdump_sprintf (va_alist)
1180 #ifndef ANSI_PROTOTYPES
1188 #ifdef ANSI_PROTOTYPES
1189 va_start (args, format);
1192 f = va_arg (args, SFILE *);
1193 format = va_arg (args, const char *);
1196 vasprintf (&buf, format, args);
1202 fprintf (stderr, _("Out of virtual memory\n"));
1208 while ((size_t) ((f->buffer + f->size) - f->current) < n + 1)
1212 curroff = f->current - f->buffer;
1214 f->buffer = xrealloc (f->buffer, f->size);
1215 f->current = f->buffer + curroff;
1218 memcpy (f->current, buf, n);
1220 f->current[0] = '\0';
1227 /* The number of zeroes we want to see before we start skipping them.
1228 The number is arbitrarily chosen. */
1230 #define SKIP_ZEROES (8)
1232 /* The number of zeroes to skip at the end of a section. If the
1233 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1234 SKIP_ZEROES, they will be disassembled. If there are fewer than
1235 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1236 attempt to avoid disassembling zeroes inserted by section
1239 #define SKIP_ZEROES_AT_END (3)
1241 /* Disassemble some data in memory between given values. */
1244 disassemble_bytes (info, disassemble_fn, insns, data,
1245 start_offset, stop_offset, relppp,
1247 struct disassemble_info *info;
1248 disassembler_ftype disassemble_fn;
1251 bfd_vma start_offset;
1252 bfd_vma stop_offset;
1256 struct objdump_disasm_info *aux;
1258 int octets_per_line;
1260 int skip_addr_chars;
1261 bfd_vma addr_offset;
1262 int opb = info->octets_per_byte;
1264 aux = (struct objdump_disasm_info *) info->application_data;
1268 octets_per_line = 4;
1270 octets_per_line = 16;
1272 /* Figure out how many characters to skip at the start of an
1273 address, to make the disassembly look nicer. We discard leading
1274 zeroes in chunks of 4, ensuring that there is always a leading
1276 skip_addr_chars = 0;
1277 if (! prefix_addresses)
1282 sprintf_vma (buf, section->vma +
1283 bfd_section_size (section->owner, section) / opb);
1285 while (s[0] == '0' && s[1] == '0' && s[2] == '0' && s[3] == '0'
1288 skip_addr_chars += 4;
1293 info->insn_info_valid = 0;
1296 addr_offset = start_offset;
1297 while (addr_offset < stop_offset)
1301 boolean need_nl = false;
1303 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1305 for (z = addr_offset * opb; z < stop_offset * opb; z++)
1308 if (! disassemble_zeroes
1309 && (info->insn_info_valid == 0
1310 || info->branch_delay_insns == 0)
1311 && (z - addr_offset * opb >= SKIP_ZEROES
1312 || (z == stop_offset * opb &&
1313 z - addr_offset * opb < SKIP_ZEROES_AT_END)))
1317 /* If there are more nonzero octets to follow, we only skip
1318 zeroes in multiples of 4, to try to avoid running over
1319 the start of an instruction which happens to start with
1321 if (z != stop_offset * opb)
1322 z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1324 octets = z - addr_offset * opb;
1335 if (with_line_numbers || with_source_code)
1336 show_line (aux->abfd, section, addr_offset);
1338 if (! prefix_addresses)
1342 sprintf_vma (buf, section->vma + addr_offset);
1343 for (s = buf + skip_addr_chars; *s == '0'; s++)
1347 printf ("%s:\t", buf + skip_addr_chars);
1351 aux->require_sec = true;
1352 objdump_print_address (section->vma + addr_offset, info);
1353 aux->require_sec = false;
1360 sfile.buffer = xmalloc (sfile.size);
1361 sfile.current = sfile.buffer;
1362 info->fprintf_func = (fprintf_ftype) objdump_sprintf;
1363 info->stream = (FILE *) &sfile;
1364 info->bytes_per_line = 0;
1365 info->bytes_per_chunk = 0;
1367 /* FIXME: This is wrong. It tests the number of octets
1368 in the last instruction, not the current one. */
1369 if (*relppp < relppend
1370 && (**relppp)->address >= addr_offset
1371 && (**relppp)->address < addr_offset + octets / opb)
1372 info->flags = INSN_HAS_RELOC;
1376 octets = (*disassemble_fn) (section->vma + addr_offset, info);
1377 info->fprintf_func = (fprintf_ftype) fprintf;
1378 info->stream = stdout;
1379 if (info->bytes_per_line != 0)
1380 octets_per_line = info->bytes_per_line;
1383 if (sfile.current != sfile.buffer)
1384 printf ("%s\n", sfile.buffer);
1385 free (sfile.buffer);
1393 octets = octets_per_line;
1394 if (addr_offset + octets / opb > stop_offset)
1395 octets = (stop_offset - addr_offset) * opb;
1397 for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1399 if (isprint (data[j]))
1400 buf[j - addr_offset * opb] = data[j];
1402 buf[j - addr_offset * opb] = '.';
1404 buf[j - addr_offset * opb] = '\0';
1407 if (prefix_addresses
1409 : show_raw_insn >= 0)
1413 /* If ! prefix_addresses and ! wide_output, we print
1414 octets_per_line octets per line. */
1416 if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1417 pb = octets_per_line;
1419 if (info->bytes_per_chunk)
1420 bpc = info->bytes_per_chunk;
1424 for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1427 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1429 for (k = bpc - 1; k >= 0; k--)
1430 printf ("%02x", (unsigned) data[j + k]);
1435 for (k = 0; k < bpc; k++)
1436 printf ("%02x", (unsigned) data[j + k]);
1441 for (; pb < octets_per_line; pb += bpc)
1445 for (k = 0; k < bpc; k++)
1450 /* Separate raw data from instruction by extra space. */
1461 printf ("%s", sfile.buffer);
1462 free (sfile.buffer);
1465 if (prefix_addresses
1467 : show_raw_insn >= 0)
1475 j = addr_offset * opb + pb;
1477 sprintf_vma (buf, section->vma + j / opb);
1478 for (s = buf + skip_addr_chars; *s == '0'; s++)
1482 printf ("%s:\t", buf + skip_addr_chars);
1484 pb += octets_per_line;
1487 for (; j < addr_offset * opb + pb; j += bpc)
1491 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1493 for (k = bpc - 1; k >= 0; k--)
1494 printf ("%02x", (unsigned) data[j + k]);
1499 for (k = 0; k < bpc; k++)
1500 printf ("%02x", (unsigned) data[j + k]);
1514 && (section->flags & SEC_RELOC) != 0)
1516 while ((*relppp) < relppend
1517 && ((**relppp)->address >= (bfd_vma) addr_offset
1518 && (**relppp)->address < (bfd_vma) addr_offset + octets / opb))
1529 objdump_print_value (section->vma + q->address, info, true);
1531 printf (": %s\t", q->howto->name);
1533 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1534 printf ("*unknown*");
1537 const char *sym_name;
1539 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1540 if (sym_name != NULL && *sym_name != '\0')
1541 objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
1546 sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1547 sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1548 if (sym_name == NULL || *sym_name == '\0')
1549 sym_name = "*unknown*";
1550 printf ("%s", sym_name);
1557 objdump_print_value (q->addend, info, true);
1569 addr_offset += octets / opb;
1573 /* Disassemble the contents of an object file. */
1576 disassemble_data (abfd)
1579 unsigned long addr_offset;
1580 disassembler_ftype disassemble_fn;
1581 struct disassemble_info disasm_info;
1582 struct objdump_disasm_info aux;
1584 unsigned int opb = bfd_octets_per_byte (abfd);
1587 prev_functionname = NULL;
1590 /* We make a copy of syms to sort. We don't want to sort syms
1591 because that will screw up the relocs. */
1592 sorted_syms = (asymbol **) xmalloc (symcount * sizeof (asymbol *));
1593 memcpy (sorted_syms, syms, symcount * sizeof (asymbol *));
1595 sorted_symcount = remove_useless_symbols (sorted_syms, symcount);
1597 /* Sort the symbols into section and symbol order */
1598 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
1600 INIT_DISASSEMBLE_INFO(disasm_info, stdout, fprintf);
1601 disasm_info.application_data = (PTR) &aux;
1603 aux.require_sec = false;
1604 disasm_info.print_address_func = objdump_print_address;
1605 disasm_info.symbol_at_address_func = objdump_symbol_at_address;
1606 disasm_info.octets_per_byte = opb;
1608 if (machine != (char *) NULL)
1610 const bfd_arch_info_type *info = bfd_scan_arch (machine);
1613 fprintf (stderr, _("%s: Can't use supplied machine %s\n"),
1618 abfd->arch_info = info;
1621 if (endian != BFD_ENDIAN_UNKNOWN)
1623 struct bfd_target *xvec;
1625 xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target));
1626 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
1627 xvec->byteorder = endian;
1631 disassemble_fn = disassembler (abfd);
1632 if (!disassemble_fn)
1634 fprintf (stderr, _("%s: Can't disassemble for architecture %s\n"),
1636 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
1641 disasm_info.flavour = bfd_get_flavour (abfd);
1642 disasm_info.arch = bfd_get_arch (abfd);
1643 disasm_info.mach = bfd_get_mach (abfd);
1644 disasm_info.disassembler_options = disassembler_options;
1646 if (bfd_big_endian (abfd))
1647 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
1648 else if (bfd_little_endian (abfd))
1649 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
1651 /* ??? Aborting here seems too drastic. We could default to big or little
1653 disasm_info.endian = BFD_ENDIAN_UNKNOWN;
1655 for (section = abfd->sections;
1656 section != (asection *) NULL;
1657 section = section->next)
1659 bfd_byte *data = NULL;
1660 bfd_size_type datasize = 0;
1661 arelent **relbuf = NULL;
1662 arelent **relpp = NULL;
1663 arelent **relppend = NULL;
1664 unsigned long stop_offset;
1665 asymbol *sym = NULL;
1668 if ((section->flags & SEC_LOAD) == 0
1669 || (! disassemble_all
1671 && (section->flags & SEC_CODE) == 0))
1673 if (only != (char *) NULL && strcmp (only, section->name) != 0)
1677 && (section->flags & SEC_RELOC) != 0)
1681 relsize = bfd_get_reloc_upper_bound (abfd, section);
1683 bfd_fatal (bfd_get_filename (abfd));
1689 relbuf = (arelent **) xmalloc (relsize);
1690 relcount = bfd_canonicalize_reloc (abfd, section, relbuf, syms);
1692 bfd_fatal (bfd_get_filename (abfd));
1694 /* Sort the relocs by address. */
1695 qsort (relbuf, relcount, sizeof (arelent *), compare_relocs);
1698 relppend = relpp + relcount;
1700 /* Skip over the relocs belonging to addresses below the
1702 if (start_address != (bfd_vma) -1)
1704 while (relpp < relppend
1705 && (*relpp)->address < start_address)
1711 printf (_("Disassembly of section %s:\n"), section->name);
1713 datasize = bfd_get_section_size_before_reloc (section);
1717 data = (bfd_byte *) xmalloc ((size_t) datasize);
1719 bfd_get_section_contents (abfd, section, data, 0, datasize);
1722 disasm_info.buffer = data;
1723 disasm_info.buffer_vma = section->vma;
1724 disasm_info.buffer_length = datasize;
1725 if (start_address == (bfd_vma) -1
1726 || start_address < disasm_info.buffer_vma)
1729 addr_offset = start_address - disasm_info.buffer_vma;
1730 if (stop_address == (bfd_vma) -1)
1731 stop_offset = datasize / opb;
1734 if (stop_address < disasm_info.buffer_vma)
1737 stop_offset = stop_address - disasm_info.buffer_vma;
1738 if (stop_offset > disasm_info.buffer_length / opb)
1739 stop_offset = disasm_info.buffer_length / opb;
1742 sym = find_symbol_for_address (abfd, section, section->vma + addr_offset,
1745 while (addr_offset < stop_offset)
1748 unsigned long nextstop_offset;
1751 if (sym != NULL && bfd_asymbol_value (sym) <= section->vma + addr_offset)
1756 (x < sorted_symcount
1757 && bfd_asymbol_value (sorted_syms[x]) <= section->vma + addr_offset);
1760 disasm_info.symbols = & sorted_syms[place];
1761 disasm_info.num_symbols = x - place;
1764 disasm_info.symbols = NULL;
1766 if (! prefix_addresses)
1769 objdump_print_addr_with_sym (abfd, section, sym,
1770 section->vma + addr_offset,
1776 if (sym != NULL && bfd_asymbol_value (sym) > section->vma + addr_offset)
1778 else if (sym == NULL)
1782 /* Search forward for the next appropriate symbol in
1783 SECTION. Note that all the symbols are sorted
1784 together into one big array, and that some sections
1785 may have overlapping addresses. */
1786 while (place < sorted_symcount
1787 && (sorted_syms[place]->section != section
1788 || (bfd_asymbol_value (sorted_syms[place])
1789 <= bfd_asymbol_value (sym))))
1791 if (place >= sorted_symcount)
1794 nextsym = sorted_syms[place];
1797 if (sym != NULL && bfd_asymbol_value (sym) > section->vma + addr_offset)
1799 nextstop_offset = bfd_asymbol_value (sym) - section->vma;
1800 if (nextstop_offset > stop_offset)
1801 nextstop_offset = stop_offset;
1803 else if (nextsym == NULL)
1804 nextstop_offset = stop_offset;
1807 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
1808 if (nextstop_offset > stop_offset)
1809 nextstop_offset = stop_offset;
1812 /* If a symbol is explicitly marked as being an object
1813 rather than a function, just dump the bytes without
1814 disassembling them. */
1817 || bfd_asymbol_value (sym) > section->vma + addr_offset
1818 || ((sym->flags & BSF_OBJECT) == 0
1819 && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1821 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1823 || (sym->flags & BSF_FUNCTION) != 0)
1828 disassemble_bytes (&disasm_info, disassemble_fn, insns, data,
1829 addr_offset, nextstop_offset, &relpp, relppend);
1831 addr_offset = nextstop_offset;
1843 /* Define a table of stab values and print-strings. We wish the initializer
1844 could be a direct-mapped table, but instead we build one the first
1847 static void dump_section_stabs PARAMS ((bfd *abfd, char *stabsect_name,
1848 char *strsect_name));
1850 /* Dump the stabs sections from an object file that has a section that
1851 uses Sun stabs encoding. */
1857 dump_section_stabs (abfd, ".stab", ".stabstr");
1858 dump_section_stabs (abfd, ".stab.excl", ".stab.exclstr");
1859 dump_section_stabs (abfd, ".stab.index", ".stab.indexstr");
1860 dump_section_stabs (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1863 static bfd_byte *stabs;
1864 static bfd_size_type stab_size;
1866 static char *strtab;
1867 static bfd_size_type stabstr_size;
1869 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1870 and string table section STRSECT_NAME into `strtab'.
1871 If the section exists and was read, allocate the space and return true.
1872 Otherwise return false. */
1875 read_section_stabs (abfd, stabsect_name, strsect_name)
1877 const char *stabsect_name;
1878 const char *strsect_name;
1880 asection *stabsect, *stabstrsect;
1882 stabsect = bfd_get_section_by_name (abfd, stabsect_name);
1885 printf (_("No %s section present\n\n"), stabsect_name);
1889 stabstrsect = bfd_get_section_by_name (abfd, strsect_name);
1890 if (0 == stabstrsect)
1892 fprintf (stderr, _("%s: %s has no %s section\n"), program_name,
1893 bfd_get_filename (abfd), strsect_name);
1898 stab_size = bfd_section_size (abfd, stabsect);
1899 stabstr_size = bfd_section_size (abfd, stabstrsect);
1901 stabs = (bfd_byte *) xmalloc (stab_size);
1902 strtab = (char *) xmalloc (stabstr_size);
1904 if (! bfd_get_section_contents (abfd, stabsect, (PTR) stabs, 0, stab_size))
1906 fprintf (stderr, _("%s: Reading %s section of %s failed: %s\n"),
1907 program_name, stabsect_name, bfd_get_filename (abfd),
1908 bfd_errmsg (bfd_get_error ()));
1915 if (! bfd_get_section_contents (abfd, stabstrsect, (PTR) strtab, 0,
1918 fprintf (stderr, _("%s: Reading %s section of %s failed: %s\n"),
1919 program_name, strsect_name, bfd_get_filename (abfd),
1920 bfd_errmsg (bfd_get_error ()));
1930 /* Stabs entries use a 12 byte format:
1931 4 byte string table index
1933 1 byte stab other field
1934 2 byte stab desc field
1936 FIXME: This will have to change for a 64 bit object format. */
1938 #define STRDXOFF (0)
1940 #define OTHEROFF (5)
1943 #define STABSIZE (12)
1945 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1946 using string table section STRSECT_NAME (in `strtab'). */
1949 print_section_stabs (abfd, stabsect_name, strsect_name)
1951 const char *stabsect_name;
1952 const char *strsect_name ATTRIBUTE_UNUSED;
1955 unsigned file_string_table_offset = 0, next_file_string_table_offset = 0;
1956 bfd_byte *stabp, *stabs_end;
1959 stabs_end = stabp + stab_size;
1961 printf (_("Contents of %s section:\n\n"), stabsect_name);
1962 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1964 /* Loop through all symbols and print them.
1966 We start the index at -1 because there is a dummy symbol on
1967 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1969 for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
1973 unsigned char type, other;
1974 unsigned short desc;
1977 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
1978 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
1979 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
1980 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
1981 value = bfd_h_get_32 (abfd, stabp + VALOFF);
1983 printf ("\n%-6d ", i);
1984 /* Either print the stab name, or, if unnamed, print its number
1985 again (makes consistent formatting for tools like awk). */
1986 name = bfd_get_stab_name (type);
1988 printf ("%-6s", name);
1989 else if (type == N_UNDF)
1992 printf ("%-6d", type);
1993 printf (" %-6d %-6d ", other, desc);
1995 printf (" %-6lu", strx);
1997 /* Symbols with type == 0 (N_UNDF) specify the length of the
1998 string table associated with this file. We use that info
1999 to know how to relocate the *next* file's string table indices. */
2003 file_string_table_offset = next_file_string_table_offset;
2004 next_file_string_table_offset += value;
2008 /* Using the (possibly updated) string table offset, print the
2009 string (if any) associated with this symbol. */
2011 if ((strx + file_string_table_offset) < stabstr_size)
2012 printf (" %s", &strtab[strx + file_string_table_offset]);
2021 dump_section_stabs (abfd, stabsect_name, strsect_name)
2023 char *stabsect_name;
2028 /* Check for section names for which stabsect_name is a prefix, to
2029 handle .stab0, etc. */
2030 for (s = abfd->sections;
2036 len = strlen (stabsect_name);
2038 /* If the prefix matches, and the files section name ends with a
2039 nul or a digit, then we match. I.e., we want either an exact
2040 match or a section followed by a number. */
2041 if (strncmp (stabsect_name, s->name, len) == 0
2042 && (s->name[len] == '\000'
2043 || isdigit ((unsigned char) s->name[len])))
2045 if (read_section_stabs (abfd, s->name, strsect_name))
2047 print_section_stabs (abfd, s->name, strsect_name);
2056 dump_bfd_header (abfd)
2061 printf (_("architecture: %s, "),
2062 bfd_printable_arch_mach (bfd_get_arch (abfd),
2063 bfd_get_mach (abfd)));
2064 printf (_("flags 0x%08x:\n"), abfd->flags);
2066 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2067 PF (HAS_RELOC, "HAS_RELOC");
2068 PF (EXEC_P, "EXEC_P");
2069 PF (HAS_LINENO, "HAS_LINENO");
2070 PF (HAS_DEBUG, "HAS_DEBUG");
2071 PF (HAS_SYMS, "HAS_SYMS");
2072 PF (HAS_LOCALS, "HAS_LOCALS");
2073 PF (DYNAMIC, "DYNAMIC");
2074 PF (WP_TEXT, "WP_TEXT");
2075 PF (D_PAGED, "D_PAGED");
2076 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2077 printf (_("\nstart address 0x"));
2078 printf_vma (abfd->start_address);
2083 dump_bfd_private_header (abfd)
2086 bfd_print_private_bfd_data (abfd, stdout);
2089 /* Dump selected contents of ABFD */
2095 /* If we are adjusting section VMA's, change them all now. Changing
2096 the BFD information is a hack. However, we must do it, or
2097 bfd_find_nearest_line will not do the right thing. */
2098 if (adjust_section_vma != 0)
2102 for (s = abfd->sections; s != NULL; s = s->next)
2104 s->vma += adjust_section_vma;
2105 s->lma += adjust_section_vma;
2109 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
2112 print_arelt_descr (stdout, abfd, true);
2113 if (dump_file_header)
2114 dump_bfd_header (abfd);
2115 if (dump_private_headers)
2116 dump_bfd_private_header (abfd);
2118 if (dump_section_headers)
2119 dump_headers (abfd);
2120 if (dump_symtab || dump_reloc_info || disassemble || dump_debugging)
2122 syms = slurp_symtab (abfd);
2124 if (dump_dynamic_symtab || dump_dynamic_reloc_info)
2126 dynsyms = slurp_dynamic_symtab (abfd);
2129 dump_symbols (abfd, false);
2130 if (dump_dynamic_symtab)
2131 dump_symbols (abfd, true);
2132 if (dump_stab_section_info)
2134 if (dump_reloc_info && ! disassemble)
2136 if (dump_dynamic_reloc_info)
2137 dump_dynamic_relocs (abfd);
2138 if (dump_section_contents)
2141 disassemble_data (abfd);
2146 dhandle = read_debugging_info (abfd, syms, symcount);
2147 if (dhandle != NULL)
2149 if (! print_debugging_info (stdout, dhandle))
2152 _("%s: printing debugging information failed\n"),
2153 bfd_get_filename (abfd));
2176 if (bfd_check_format_matches (abfd, bfd_object, &matching))
2182 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2184 nonfatal (bfd_get_filename (abfd));
2185 list_matching_formats (matching);
2190 if (bfd_get_error () != bfd_error_file_not_recognized)
2192 nonfatal (bfd_get_filename (abfd));
2196 if (bfd_check_format_matches (abfd, bfd_core, &matching))
2202 nonfatal (bfd_get_filename (abfd));
2204 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2206 list_matching_formats (matching);
2212 display_file (filename, target)
2216 bfd *file, *arfile = (bfd *) NULL;
2218 file = bfd_openr (filename, target);
2221 nonfatal (filename);
2225 if (bfd_check_format (file, bfd_archive) == true)
2227 bfd *last_arfile = NULL;
2229 printf (_("In archive %s:\n"), bfd_get_filename (file));
2232 bfd_set_error (bfd_error_no_error);
2234 arfile = bfd_openr_next_archived_file (file, arfile);
2237 if (bfd_get_error () != bfd_error_no_more_archived_files)
2238 nonfatal (bfd_get_filename (file));
2242 display_bfd (arfile);
2244 if (last_arfile != NULL)
2245 bfd_close (last_arfile);
2246 last_arfile = arfile;
2249 if (last_arfile != NULL)
2250 bfd_close (last_arfile);
2258 /* Actually display the various requested regions */
2266 bfd_size_type datasize = 0;
2267 bfd_size_type addr_offset;
2268 bfd_size_type start_offset, stop_offset;
2269 unsigned int opb = bfd_octets_per_byte (abfd);
2271 for (section = abfd->sections; section != NULL; section =
2276 if (only == (char *) NULL ||
2277 strcmp (only, section->name) == 0)
2279 if (section->flags & SEC_HAS_CONTENTS)
2281 printf (_("Contents of section %s:\n"), section->name);
2283 if (bfd_section_size (abfd, section) == 0)
2285 data = (bfd_byte *) xmalloc ((size_t) bfd_section_size (abfd, section));
2286 datasize = bfd_section_size (abfd, section);
2289 bfd_get_section_contents (abfd, section, (PTR) data, 0, bfd_section_size (abfd, section));
2291 if (start_address == (bfd_vma) -1
2292 || start_address < section->vma)
2295 start_offset = start_address - section->vma;
2296 if (stop_address == (bfd_vma) -1)
2297 stop_offset = bfd_section_size (abfd, section) / opb;
2300 if (stop_address < section->vma)
2303 stop_offset = stop_address - section->vma;
2304 if (stop_offset > bfd_section_size (abfd, section) / opb)
2305 stop_offset = bfd_section_size (abfd, section) / opb;
2307 for (addr_offset = start_offset;
2308 addr_offset < stop_offset; addr_offset += onaline)
2312 printf (" %04lx ", (unsigned long int)
2313 (addr_offset + section->vma));
2314 for (j = addr_offset * opb;
2315 j < addr_offset * opb + onaline; j++)
2317 if (j < stop_offset * opb)
2318 printf ("%02x", (unsigned) (data[j]));
2326 for (j = addr_offset; j < addr_offset * opb + onaline; j++)
2328 if (j >= stop_offset * opb)
2331 printf ("%c", isprint (data[j]) ? data[j] : '.');
2341 /* Should perhaps share code and display with nm? */
2343 dump_symbols (abfd, dynamic)
2344 bfd *abfd ATTRIBUTE_UNUSED;
2357 printf ("DYNAMIC SYMBOL TABLE:\n");
2365 printf ("SYMBOL TABLE:\n");
2368 for (count = 0; count < max; count++)
2372 bfd *cur_bfd = bfd_asymbol_bfd (*current);
2374 if (cur_bfd != NULL)
2379 name = bfd_asymbol_name (*current);
2381 if (do_demangle && name != NULL && *name != '\0')
2385 /* If we want to demangle the name, we demangle it
2386 here, and temporarily clobber it while calling
2387 bfd_print_symbol. FIXME: This is a gross hack. */
2390 if (bfd_get_symbol_leading_char (cur_bfd) == *n)
2392 alloc = cplus_demangle (n, DMGL_ANSI | DMGL_PARAMS);
2394 (*current)->name = alloc;
2396 (*current)->name = n;
2399 bfd_print_symbol (cur_bfd, stdout, *current,
2400 bfd_print_symbol_all);
2402 (*current)->name = name;
2423 for (a = abfd->sections; a != (asection *) NULL; a = a->next)
2427 if (bfd_is_abs_section (a))
2429 if (bfd_is_und_section (a))
2431 if (bfd_is_com_section (a))
2436 if (strcmp (only, a->name))
2439 else if ((a->flags & SEC_RELOC) == 0)
2442 relsize = bfd_get_reloc_upper_bound (abfd, a);
2444 bfd_fatal (bfd_get_filename (abfd));
2446 printf ("RELOCATION RECORDS FOR [%s]:", a->name);
2450 printf (" (none)\n\n");
2454 relpp = (arelent **) xmalloc (relsize);
2455 relcount = bfd_canonicalize_reloc (abfd, a, relpp, syms);
2457 bfd_fatal (bfd_get_filename (abfd));
2458 else if (relcount == 0)
2460 printf (" (none)\n\n");
2465 dump_reloc_set (abfd, a, relpp, relcount);
2474 dump_dynamic_relocs (abfd)
2481 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2483 bfd_fatal (bfd_get_filename (abfd));
2485 printf ("DYNAMIC RELOCATION RECORDS");
2489 printf (" (none)\n\n");
2493 relpp = (arelent **) xmalloc (relsize);
2494 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2496 bfd_fatal (bfd_get_filename (abfd));
2497 else if (relcount == 0)
2499 printf (" (none)\n\n");
2504 dump_reloc_set (abfd, (asection *) NULL, relpp, relcount);
2512 dump_reloc_set (abfd, sec, relpp, relcount)
2519 char *last_filename, *last_functionname;
2520 unsigned int last_line;
2522 /* Get column headers lined up reasonably. */
2528 sprintf_vma (buf, (bfd_vma) -1);
2529 width = strlen (buf) - 7;
2531 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2534 last_filename = NULL;
2535 last_functionname = NULL;
2538 for (p = relpp; relcount && *p != (arelent *) NULL; p++, relcount--)
2541 const char *filename, *functionname;
2543 const char *sym_name;
2544 const char *section_name;
2546 if (start_address != (bfd_vma) -1
2547 && q->address < start_address)
2549 if (stop_address != (bfd_vma) -1
2550 && q->address > stop_address)
2553 if (with_line_numbers
2555 && bfd_find_nearest_line (abfd, sec, syms, q->address,
2556 &filename, &functionname, &line))
2558 if (functionname != NULL
2559 && (last_functionname == NULL
2560 || strcmp (functionname, last_functionname) != 0))
2562 printf ("%s():\n", functionname);
2563 if (last_functionname != NULL)
2564 free (last_functionname);
2565 last_functionname = xstrdup (functionname);
2568 && (line != last_line
2569 || (filename != NULL
2570 && last_filename != NULL
2571 && strcmp (filename, last_filename) != 0)))
2573 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2575 if (last_filename != NULL)
2576 free (last_filename);
2577 if (filename == NULL)
2578 last_filename = NULL;
2580 last_filename = xstrdup (filename);
2584 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2586 sym_name = (*(q->sym_ptr_ptr))->name;
2587 section_name = (*(q->sym_ptr_ptr))->section->name;
2592 section_name = NULL;
2596 printf_vma (q->address);
2598 printf (" %-16s ", q->howto->name);
2600 printf (" %-16d ", q->howto->type);
2601 objdump_print_symname (abfd, (struct disassemble_info *) NULL,
2606 if (section_name == (CONST char *) NULL)
2607 section_name = "*unknown*";
2608 printf_vma (q->address);
2609 printf (" %-16s [%s]",
2616 printf_vma (q->addend);
2622 /* The length of the longest architecture name + 1. */
2623 #define LONGEST_ARCH sizeof("rs6000:6000")
2626 endian_string (endian)
2627 enum bfd_endian endian;
2629 if (endian == BFD_ENDIAN_BIG)
2630 return "big endian";
2631 else if (endian == BFD_ENDIAN_LITTLE)
2632 return "little endian";
2634 return "endianness unknown";
2637 /* List the targets that BFD is configured to support, each followed
2638 by its endianness and the architectures it supports. */
2641 display_target_list ()
2643 extern bfd_target *bfd_target_vector[];
2647 dummy_name = choose_temp_base ();
2648 for (t = 0; bfd_target_vector[t]; t++)
2650 bfd_target *p = bfd_target_vector[t];
2651 bfd *abfd = bfd_openw (dummy_name, p->name);
2654 printf ("%s\n (header %s, data %s)\n", p->name,
2655 endian_string (p->header_byteorder),
2656 endian_string (p->byteorder));
2660 nonfatal (dummy_name);
2664 if (! bfd_set_format (abfd, bfd_object))
2666 if (bfd_get_error () != bfd_error_invalid_operation)
2671 for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++)
2672 if (bfd_set_arch_mach (abfd, (enum bfd_architecture) a, 0))
2674 bfd_printable_arch_mach ((enum bfd_architecture) a, 0));
2676 unlink (dummy_name);
2680 /* Print a table showing which architectures are supported for entries
2681 FIRST through LAST-1 of bfd_target_vector (targets across,
2682 architectures down). */
2685 display_info_table (first, last)
2689 extern bfd_target *bfd_target_vector[];
2693 /* Print heading of target names. */
2694 printf ("\n%*s", (int) LONGEST_ARCH, " ");
2695 for (t = first; t < last && bfd_target_vector[t]; t++)
2696 printf ("%s ", bfd_target_vector[t]->name);
2699 dummy_name = choose_temp_base ();
2700 for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++)
2701 if (strcmp (bfd_printable_arch_mach (a, 0), "UNKNOWN!") != 0)
2703 printf ("%*s ", (int) LONGEST_ARCH - 1,
2704 bfd_printable_arch_mach (a, 0));
2705 for (t = first; t < last && bfd_target_vector[t]; t++)
2707 bfd_target *p = bfd_target_vector[t];
2709 bfd *abfd = bfd_openw (dummy_name, p->name);
2719 if (! bfd_set_format (abfd, bfd_object))
2721 if (bfd_get_error () != bfd_error_invalid_operation)
2729 if (! bfd_set_arch_mach (abfd, a, 0))
2734 printf ("%s ", p->name);
2737 int l = strlen (p->name);
2745 unlink (dummy_name);
2749 /* Print tables of all the target-architecture combinations that
2750 BFD has been configured to support. */
2753 display_target_tables ()
2756 extern bfd_target *bfd_target_vector[];
2760 colum = getenv ("COLUMNS");
2762 columns = atoi (colum);
2767 while (bfd_target_vector[t] != NULL)
2771 wid = LONGEST_ARCH + strlen (bfd_target_vector[t]->name) + 1;
2773 while (wid < columns && bfd_target_vector[t] != NULL)
2777 newwid = wid + strlen (bfd_target_vector[t]->name) + 1;
2778 if (newwid >= columns)
2783 display_info_table (oldt, t);
2790 printf (_("BFD header file version %s\n"), BFD_VERSION);
2791 display_target_list ();
2792 display_target_tables ();
2801 char *target = default_target;
2802 boolean seenflag = false;
2804 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
2805 setlocale (LC_MESSAGES, "");
2807 bindtextdomain (PACKAGE, LOCALEDIR);
2808 textdomain (PACKAGE);
2810 program_name = *argv;
2811 xmalloc_set_program_name (program_name);
2813 START_PROGRESS (program_name, 0);
2816 set_default_bfd_target ();
2818 while ((c = getopt_long (argc, argv, "pib:m:M:VCdDlfahHrRtTxsSj:wE:zgG",
2819 long_options, (int *) 0))
2825 break; /* we've been given a long option */
2830 disassembler_options = optarg;
2836 with_line_numbers = true;
2847 case OPTION_ADJUST_VMA:
2848 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
2850 case OPTION_START_ADDRESS:
2851 start_address = parse_vma (optarg, "--start-address");
2853 case OPTION_STOP_ADDRESS:
2854 stop_address = parse_vma (optarg, "--stop-address");
2857 if (strcmp (optarg, "B") == 0)
2858 endian = BFD_ENDIAN_BIG;
2859 else if (strcmp (optarg, "L") == 0)
2860 endian = BFD_ENDIAN_LITTLE;
2863 fprintf (stderr, _("%s: unrecognized -E option\n"),
2869 if (strncmp (optarg, "big", strlen (optarg)) == 0)
2870 endian = BFD_ENDIAN_BIG;
2871 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
2872 endian = BFD_ENDIAN_LITTLE;
2875 fprintf (stderr, _("%s: unrecognized --endian type `%s'\n"),
2876 program_name, optarg);
2882 dump_file_header = true;
2886 formats_info = true;
2890 dump_private_headers = true;
2894 dump_private_headers = true;
2896 dump_reloc_info = true;
2897 dump_file_header = true;
2898 dump_ar_hdrs = true;
2899 dump_section_headers = true;
2907 dump_dynamic_symtab = true;
2915 disassemble_zeroes = true;
2919 disassemble_all = true;
2924 with_source_code = true;
2932 dump_stab_section_info = true;
2936 dump_section_contents = true;
2940 dump_reloc_info = true;
2944 dump_dynamic_reloc_info = true;
2948 dump_ar_hdrs = true;
2952 dump_section_headers = true;
2959 show_version = true;
2969 print_version ("objdump");
2971 if (seenflag == false)
2979 display_file ("a.out", target);
2981 for (; optind < argc;)
2982 display_file (argv[optind++], target);
2985 END_PROGRESS (program_name);