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 *, ...));
47 static char *default_target = NULL; /* default at runtime */
49 static int show_version = 0; /* show the version number */
50 static int dump_section_contents; /* -s */
51 static int dump_section_headers; /* -h */
52 static boolean dump_file_header; /* -f */
53 static int dump_symtab; /* -t */
54 static int dump_dynamic_symtab; /* -T */
55 static int dump_reloc_info; /* -r */
56 static int dump_dynamic_reloc_info; /* -R */
57 static int dump_ar_hdrs; /* -a */
58 static int dump_private_headers; /* -p */
59 static int prefix_addresses; /* --prefix-addresses */
60 static int with_line_numbers; /* -l */
61 static boolean with_source_code; /* -S */
62 static int show_raw_insn; /* --show-raw-insn */
63 static int dump_stab_section_info; /* --stabs */
64 static int do_demangle; /* -C, --demangle */
65 static boolean disassemble; /* -d */
66 static boolean disassemble_all; /* -D */
67 static int disassemble_zeroes; /* --disassemble-zeroes */
68 static boolean formats_info; /* -i */
69 static char *only; /* -j secname */
70 static int wide_output; /* -w */
71 static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
72 static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */
73 static int dump_debugging; /* --debugging */
74 static bfd_vma adjust_section_vma = 0; /* --adjust-vma */
76 /* Extra info to pass to the disassembler address printing function. */
77 struct objdump_disasm_info {
83 /* Architecture to disassemble for, or default if NULL. */
84 static char *machine = (char *) NULL;
86 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
87 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
89 /* The symbol table. */
90 static asymbol **syms;
92 /* Number of symbols in `syms'. */
93 static long symcount = 0;
95 /* The sorted symbol table. */
96 static asymbol **sorted_syms;
98 /* Number of symbols in `sorted_syms'. */
99 static long sorted_symcount = 0;
101 /* The dynamic symbol table. */
102 static asymbol **dynsyms;
104 /* Number of symbols in `dynsyms'. */
105 static long dynsymcount = 0;
107 /* Static declarations. */
110 usage PARAMS ((FILE *, int));
113 display_file PARAMS ((char *filename, char *target));
116 dump_section_header PARAMS ((bfd *, asection *, PTR));
119 dump_headers PARAMS ((bfd *));
122 dump_data PARAMS ((bfd *abfd));
125 dump_relocs PARAMS ((bfd *abfd));
128 dump_dynamic_relocs PARAMS ((bfd * abfd));
131 dump_reloc_set PARAMS ((bfd *, asection *, arelent **, long));
134 dump_symbols PARAMS ((bfd *abfd, boolean dynamic));
137 dump_bfd_header PARAMS ((bfd *));
140 dump_bfd_private_header PARAMS ((bfd *));
143 display_bfd PARAMS ((bfd *abfd));
146 display_target_list PARAMS ((void));
149 display_info_table PARAMS ((int, int));
152 display_target_tables PARAMS ((void));
155 display_info PARAMS ((void));
158 objdump_print_value PARAMS ((bfd_vma, struct disassemble_info *, boolean));
161 objdump_print_symname PARAMS ((bfd *, struct disassemble_info *, asymbol *));
164 find_symbol_for_address PARAMS ((bfd *, asection *, bfd_vma, boolean, long *));
167 objdump_print_addr_with_sym PARAMS ((bfd *, asection *, asymbol *, bfd_vma,
168 struct disassemble_info *, boolean));
171 objdump_print_addr PARAMS ((bfd_vma, struct disassemble_info *, boolean));
174 objdump_print_address PARAMS ((bfd_vma, struct disassemble_info *));
177 show_line PARAMS ((bfd *, asection *, bfd_vma));
180 disassemble_bytes PARAMS ((struct disassemble_info *, disassembler_ftype,
181 boolean, bfd_byte *, bfd_vma, bfd_vma,
182 arelent ***, arelent **));
185 disassemble_data PARAMS ((bfd *));
188 endian_string PARAMS ((enum bfd_endian));
191 slurp_symtab PARAMS ((bfd *));
194 slurp_dynamic_symtab PARAMS ((bfd *));
197 remove_useless_symbols PARAMS ((asymbol **, long));
200 compare_symbols PARAMS ((const PTR, const PTR));
203 compare_relocs PARAMS ((const PTR, const PTR));
206 dump_stabs PARAMS ((bfd *));
209 read_section_stabs PARAMS ((bfd *, const char *, const char *));
212 print_section_stabs PARAMS ((bfd *, const char *, const char *));
215 usage (stream, status)
219 fprintf (stream, _("\
220 Usage: %s [-ahifCdDprRtTxsSlw] [-b bfdname] [-m machine] [-j section-name]\n\
221 [--archive-headers] [--target=bfdname] [--debugging] [--disassemble]\n\
222 [--disassemble-all] [--disassemble-zeroes] [--file-headers]\n\
223 [--section-headers] [--headers]\n\
224 [--info] [--section=section-name] [--line-numbers] [--source]\n"),
226 fprintf (stream, _("\
227 [--architecture=machine] [--reloc] [--full-contents] [--stabs]\n\
228 [--syms] [--all-headers] [--dynamic-syms] [--dynamic-reloc]\n\
229 [--wide] [--version] [--help] [--private-headers]\n\
230 [--start-address=addr] [--stop-address=addr]\n\
231 [--prefix-addresses] [--[no-]show-raw-insn] [--demangle]\n\
232 [--adjust-vma=offset] [-EB|-EL] [--endian={big|little}] objfile...\n\
233 at least one option besides -l (--line-numbers) must be given\n"));
234 list_supported_targets (program_name, stream);
236 fprintf (stream, _("Report bugs to bug-gnu-utils@gnu.org\n"));
240 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
242 #define OPTION_ENDIAN (150)
243 #define OPTION_START_ADDRESS (OPTION_ENDIAN + 1)
244 #define OPTION_STOP_ADDRESS (OPTION_START_ADDRESS + 1)
245 #define OPTION_ADJUST_VMA (OPTION_STOP_ADDRESS + 1)
247 static struct option long_options[]=
249 {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
250 {"all-headers", no_argument, NULL, 'x'},
251 {"private-headers", no_argument, NULL, 'p'},
252 {"architecture", required_argument, NULL, 'm'},
253 {"archive-headers", no_argument, NULL, 'a'},
254 {"debugging", no_argument, &dump_debugging, 1},
255 {"demangle", no_argument, &do_demangle, 1},
256 {"disassemble", no_argument, NULL, 'd'},
257 {"disassemble-all", no_argument, NULL, 'D'},
258 {"disassemble-zeroes", no_argument, &disassemble_zeroes, 1},
259 {"dynamic-reloc", no_argument, NULL, 'R'},
260 {"dynamic-syms", no_argument, NULL, 'T'},
261 {"endian", required_argument, NULL, OPTION_ENDIAN},
262 {"file-headers", no_argument, NULL, 'f'},
263 {"full-contents", no_argument, NULL, 's'},
264 {"headers", no_argument, NULL, 'h'},
265 {"help", no_argument, NULL, 'H'},
266 {"info", no_argument, NULL, 'i'},
267 {"line-numbers", no_argument, NULL, 'l'},
268 {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
269 {"prefix-addresses", no_argument, &prefix_addresses, 1},
270 {"reloc", no_argument, NULL, 'r'},
271 {"section", required_argument, NULL, 'j'},
272 {"section-headers", no_argument, NULL, 'h'},
273 {"show-raw-insn", no_argument, &show_raw_insn, 1},
274 {"source", no_argument, NULL, 'S'},
275 {"stabs", no_argument, &dump_stab_section_info, 1},
276 {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
277 {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
278 {"syms", no_argument, NULL, 't'},
279 {"target", required_argument, NULL, 'b'},
280 {"version", no_argument, &show_version, 1},
281 {"wide", no_argument, &wide_output, 'w'},
282 {0, no_argument, 0, 0}
286 dump_section_header (abfd, section, ignored)
293 printf ("%3d %-13s %08lx ", section->index,
294 bfd_get_section_name (abfd, section),
295 (unsigned long) bfd_section_size (abfd, section));
296 printf_vma (bfd_get_section_vma (abfd, section));
298 printf_vma (section->lma);
299 printf (" %08lx 2**%u", section->filepos,
300 bfd_get_section_alignment (abfd, section));
306 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
308 PF (SEC_HAS_CONTENTS, "CONTENTS");
309 PF (SEC_ALLOC, "ALLOC");
310 PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
311 PF (SEC_CONSTRUCTOR_TEXT, "CONSTRUCTOR TEXT");
312 PF (SEC_CONSTRUCTOR_DATA, "CONSTRUCTOR DATA");
313 PF (SEC_CONSTRUCTOR_BSS, "CONSTRUCTOR BSS");
314 PF (SEC_LOAD, "LOAD");
315 PF (SEC_RELOC, "RELOC");
317 PF (SEC_BALIGN, "BALIGN");
319 PF (SEC_READONLY, "READONLY");
320 PF (SEC_CODE, "CODE");
321 PF (SEC_DATA, "DATA");
323 PF (SEC_DEBUGGING, "DEBUGGING");
324 PF (SEC_NEVER_LOAD, "NEVER_LOAD");
325 PF (SEC_EXCLUDE, "EXCLUDE");
326 PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
328 if ((section->flags & SEC_LINK_ONCE) != 0)
332 switch (section->flags & SEC_LINK_DUPLICATES)
336 case SEC_LINK_DUPLICATES_DISCARD:
337 ls = "LINK_ONCE_DISCARD";
339 case SEC_LINK_DUPLICATES_ONE_ONLY:
340 ls = "LINK_ONCE_ONE_ONLY";
342 case SEC_LINK_DUPLICATES_SAME_SIZE:
343 ls = "LINK_ONCE_SAME_SIZE";
345 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
346 ls = "LINK_ONCE_SAME_CONTENTS";
349 printf ("%s%s", comma, ls);
361 printf (_("Sections:\n"));
363 printf (_("Idx Name Size VMA LMA File off Algn\n"));
365 printf (_("Idx Name Size VMA LMA File off Algn\n"));
367 bfd_map_over_sections (abfd, dump_section_header, (PTR) NULL);
374 asymbol **sy = (asymbol **) NULL;
377 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
379 fprintf (stderr, _("%s: no symbols\n"), bfd_get_filename (abfd));
384 storage = bfd_get_symtab_upper_bound (abfd);
386 bfd_fatal (bfd_get_filename (abfd));
390 sy = (asymbol **) xmalloc (storage);
392 symcount = bfd_canonicalize_symtab (abfd, sy);
394 bfd_fatal (bfd_get_filename (abfd));
396 fprintf (stderr, _("%s: no symbols\n"), bfd_get_filename (abfd));
400 /* Read in the dynamic symbols. */
403 slurp_dynamic_symtab (abfd)
406 asymbol **sy = (asymbol **) NULL;
409 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
412 if (!(bfd_get_file_flags (abfd) & DYNAMIC))
414 fprintf (stderr, _("%s: %s: not a dynamic object\n"),
415 program_name, bfd_get_filename (abfd));
420 bfd_fatal (bfd_get_filename (abfd));
425 sy = (asymbol **) xmalloc (storage);
427 dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
429 bfd_fatal (bfd_get_filename (abfd));
430 if (dynsymcount == 0)
431 fprintf (stderr, _("%s: %s: No dynamic symbols\n"),
432 program_name, bfd_get_filename (abfd));
436 /* Filter out (in place) symbols that are useless for disassembly.
437 COUNT is the number of elements in SYMBOLS.
438 Return the number of useful symbols. */
441 remove_useless_symbols (symbols, count)
445 register asymbol **in_ptr = symbols, **out_ptr = symbols;
449 asymbol *sym = *in_ptr++;
451 if (sym->name == NULL || sym->name[0] == '\0')
453 if (sym->flags & (BSF_DEBUGGING))
455 if (bfd_is_und_section (sym->section)
456 || bfd_is_com_section (sym->section))
461 return out_ptr - symbols;
464 /* Sort symbols into value order. */
467 compare_symbols (ap, bp)
471 const asymbol *a = *(const asymbol **)ap;
472 const asymbol *b = *(const asymbol **)bp;
476 flagword aflags, bflags;
478 if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
480 else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
483 if (a->section > b->section)
485 else if (a->section < b->section)
488 an = bfd_asymbol_name (a);
489 bn = bfd_asymbol_name (b);
493 /* The symbols gnu_compiled and gcc2_compiled convey no real
494 information, so put them after other symbols with the same value. */
496 af = (strstr (an, "gnu_compiled") != NULL
497 || strstr (an, "gcc2_compiled") != NULL);
498 bf = (strstr (bn, "gnu_compiled") != NULL
499 || strstr (bn, "gcc2_compiled") != NULL);
506 /* We use a heuristic for the file name, to try to sort it after
507 more useful symbols. It may not work on non Unix systems, but it
508 doesn't really matter; the only difference is precisely which
509 symbol names get printed. */
511 #define file_symbol(s, sn, snl) \
512 (((s)->flags & BSF_FILE) != 0 \
513 || ((sn)[(snl) - 2] == '.' \
514 && ((sn)[(snl) - 1] == 'o' \
515 || (sn)[(snl) - 1] == 'a')))
517 af = file_symbol (a, an, anl);
518 bf = file_symbol (b, bn, bnl);
525 /* Try to sort global symbols before local symbols before function
526 symbols before debugging symbols. */
531 if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
533 if ((aflags & BSF_DEBUGGING) != 0)
538 if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
540 if ((aflags & BSF_FUNCTION) != 0)
545 if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
547 if ((aflags & BSF_LOCAL) != 0)
552 if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
554 if ((aflags & BSF_GLOBAL) != 0)
560 /* Symbols that start with '.' might be section names, so sort them
561 after symbols that don't start with '.'. */
562 if (an[0] == '.' && bn[0] != '.')
564 if (an[0] != '.' && bn[0] == '.')
567 /* Finally, if we can't distinguish them in any other way, try to
568 get consistent results by sorting the symbols by name. */
569 return strcmp (an, bn);
572 /* Sort relocs into address order. */
575 compare_relocs (ap, bp)
579 const arelent *a = *(const arelent **)ap;
580 const arelent *b = *(const arelent **)bp;
582 if (a->address > b->address)
584 else if (a->address < b->address)
587 /* So that associated relocations tied to the same address show up
588 in the correct order, we don't do any further sorting. */
597 /* Print VMA to STREAM. If SKIP_ZEROES is true, omit leading zeroes. */
600 objdump_print_value (vma, info, skip_zeroes)
602 struct disassemble_info *info;
608 sprintf_vma (buf, vma);
613 for (p = buf; *p == '0'; ++p)
618 (*info->fprintf_func) (info->stream, "%s", p);
621 /* Print the name of a symbol. */
624 objdump_print_symname (abfd, info, sym)
626 struct disassemble_info *info;
634 name = bfd_asymbol_name (sym);
635 if (! do_demangle || name[0] == '\0')
639 /* Demangle the name. */
640 if (bfd_get_symbol_leading_char (abfd) == name[0])
643 alloc = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS);
651 (*info->fprintf_func) (info->stream, "%s", print);
653 printf ("%s", print);
659 /* Locate a symbol given a bfd, a section, and a VMA. If REQUIRE_SEC
660 is true, then always require the symbol to be in the section. This
661 returns NULL if there is no suitable symbol. If PLACE is not NULL,
662 then *PLACE is set to the index of the symbol in sorted_syms. */
665 find_symbol_for_address (abfd, sec, vma, require_sec, place)
672 /* @@ Would it speed things up to cache the last two symbols returned,
673 and maybe their address ranges? For many processors, only one memory
674 operand can be present at a time, so the 2-entry cache wouldn't be
675 constantly churned by code doing heavy memory accesses. */
677 /* Indices in `sorted_syms'. */
679 long max = sorted_symcount;
682 if (sorted_symcount < 1)
685 /* Perform a binary search looking for the closest symbol to the
686 required value. We are searching the range (min, max]. */
687 while (min + 1 < max)
691 thisplace = (max + min) / 2;
692 sym = sorted_syms[thisplace];
694 if (bfd_asymbol_value (sym) > vma)
696 else if (bfd_asymbol_value (sym) < vma)
705 /* The symbol we want is now in min, the low end of the range we
706 were searching. If there are several symbols with the same
707 value, we want the first one. */
710 && (bfd_asymbol_value (sorted_syms[thisplace])
711 == bfd_asymbol_value (sorted_syms[thisplace - 1])))
714 /* If the file is relocateable, and the symbol could be from this
715 section, prefer a symbol from this section over symbols from
716 others, even if the other symbol's value might be closer.
718 Note that this may be wrong for some symbol references if the
719 sections have overlapping memory ranges, but in that case there's
720 no way to tell what's desired without looking at the relocation
723 if (sorted_syms[thisplace]->section != sec
725 || ((abfd->flags & HAS_RELOC) != 0
726 && vma >= bfd_get_section_vma (abfd, sec)
727 && vma < (bfd_get_section_vma (abfd, sec)
728 + bfd_section_size (abfd, sec)))))
732 for (i = thisplace + 1; i < sorted_symcount; i++)
734 if (bfd_asymbol_value (sorted_syms[i])
735 != bfd_asymbol_value (sorted_syms[thisplace]))
741 if (sorted_syms[i]->section == sec
743 || sorted_syms[i - 1]->section != sec
744 || (bfd_asymbol_value (sorted_syms[i])
745 != bfd_asymbol_value (sorted_syms[i - 1]))))
752 if (sorted_syms[thisplace]->section != sec)
754 /* We didn't find a good symbol with a smaller value.
755 Look for one with a larger value. */
756 for (i = thisplace + 1; i < sorted_symcount; i++)
758 if (sorted_syms[i]->section == sec)
766 if (sorted_syms[thisplace]->section != sec
768 || ((abfd->flags & HAS_RELOC) != 0
769 && vma >= bfd_get_section_vma (abfd, sec)
770 && vma < (bfd_get_section_vma (abfd, sec)
771 + bfd_section_size (abfd, sec)))))
773 /* There is no suitable symbol. */
781 return sorted_syms[thisplace];
784 /* Print an address to INFO symbolically. */
787 objdump_print_addr_with_sym (abfd, sec, sym, vma, info, skip_zeroes)
792 struct disassemble_info *info;
795 objdump_print_value (vma, info, skip_zeroes);
801 (*info->fprintf_func) (info->stream, " <%s",
802 bfd_get_section_name (abfd, sec));
803 secaddr = bfd_get_section_vma (abfd, sec);
806 (*info->fprintf_func) (info->stream, "-0x");
807 objdump_print_value (secaddr - vma, info, true);
809 else if (vma > secaddr)
811 (*info->fprintf_func) (info->stream, "+0x");
812 objdump_print_value (vma - secaddr, info, true);
814 (*info->fprintf_func) (info->stream, ">");
818 (*info->fprintf_func) (info->stream, " <");
819 objdump_print_symname (abfd, info, sym);
820 if (bfd_asymbol_value (sym) > vma)
822 (*info->fprintf_func) (info->stream, "-0x");
823 objdump_print_value (bfd_asymbol_value (sym) - vma, info, true);
825 else if (vma > bfd_asymbol_value (sym))
827 (*info->fprintf_func) (info->stream, "+0x");
828 objdump_print_value (vma - bfd_asymbol_value (sym), info, true);
830 (*info->fprintf_func) (info->stream, ">");
834 /* Print VMA to INFO, symbolically if possible. If SKIP_ZEROES is
835 true, don't output leading zeroes. */
838 objdump_print_addr (vma, info, skip_zeroes)
840 struct disassemble_info *info;
843 struct objdump_disasm_info *aux;
846 if (sorted_symcount < 1)
848 (*info->fprintf_func) (info->stream, "0x");
849 objdump_print_value (vma, info, skip_zeroes);
853 aux = (struct objdump_disasm_info *) info->application_data;
854 sym = find_symbol_for_address (aux->abfd, aux->sec, vma, aux->require_sec,
856 objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, info,
860 /* Print VMA to INFO. This function is passed to the disassembler
864 objdump_print_address (vma, info)
866 struct disassemble_info *info;
868 objdump_print_addr (vma, info, ! prefix_addresses);
871 /* Determine of the given address has a symbol associated with it. */
874 objdump_symbol_at_address (vma, info)
876 struct disassemble_info * info;
878 struct objdump_disasm_info * aux;
881 /* No symbols - do not bother checking. */
882 if (sorted_symcount < 1)
885 aux = (struct objdump_disasm_info *) info->application_data;
886 sym = find_symbol_for_address (aux->abfd, aux->sec, vma, aux->require_sec,
889 return (sym != NULL && (bfd_asymbol_value (sym) == vma));
892 /* Hold the last function name and the last line number we displayed
895 static char *prev_functionname;
896 static unsigned int prev_line;
898 /* We keep a list of all files that we have seen when doing a
899 dissassembly with source, so that we know how much of the file to
900 display. This can be important for inlined functions. */
902 struct print_file_list
904 struct print_file_list *next;
910 static struct print_file_list *print_files;
912 /* The number of preceding context lines to show when we start
913 displaying a file for the first time. */
915 #define SHOW_PRECEDING_CONTEXT_LINES (5)
917 /* Skip ahead to a given line in a file, optionally printing each
921 skip_to_line PARAMS ((struct print_file_list *, unsigned int, boolean));
924 skip_to_line (p, line, show)
925 struct print_file_list *p;
929 while (p->line < line)
933 if (fgets (buf, sizeof buf, p->f) == NULL)
943 if (strchr (buf, '\n') != NULL)
948 /* Show the line number, or the source line, in a dissassembly
952 show_line (abfd, section, off)
957 CONST char *filename;
958 CONST char *functionname;
961 if (! with_line_numbers && ! with_source_code)
964 if (! bfd_find_nearest_line (abfd, section, syms, off, &filename,
965 &functionname, &line))
968 if (filename != NULL && *filename == '\0')
970 if (functionname != NULL && *functionname == '\0')
973 if (with_line_numbers)
975 if (functionname != NULL
976 && (prev_functionname == NULL
977 || strcmp (functionname, prev_functionname) != 0))
978 printf ("%s():\n", functionname);
979 if (line > 0 && line != prev_line)
980 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
987 struct print_file_list **pp, *p;
989 for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
990 if (strcmp ((*pp)->filename, filename) == 0)
996 if (p != print_files)
1000 /* We have reencountered a file name which we saw
1001 earlier. This implies that either we are dumping out
1002 code from an included file, or the same file was
1003 linked in more than once. There are two common cases
1004 of an included file: inline functions in a header
1005 file, and a bison or flex skeleton file. In the
1006 former case we want to just start printing (but we
1007 back up a few lines to give context); in the latter
1008 case we want to continue from where we left off. I
1009 can't think of a good way to distinguish the cases,
1010 so I used a heuristic based on the file name. */
1011 if (strcmp (p->filename + strlen (p->filename) - 2, ".h") != 0)
1015 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1022 p->f = fopen (p->filename, "r");
1026 skip_to_line (p, l, false);
1028 if (print_files->f != NULL)
1030 fclose (print_files->f);
1031 print_files->f = NULL;
1037 skip_to_line (p, line, true);
1039 p->next = print_files;
1047 f = fopen (filename, "r");
1052 p = ((struct print_file_list *)
1053 xmalloc (sizeof (struct print_file_list)));
1054 p->filename = xmalloc (strlen (filename) + 1);
1055 strcpy (p->filename, filename);
1059 if (print_files != NULL && print_files->f != NULL)
1061 fclose (print_files->f);
1062 print_files->f = NULL;
1064 p->next = print_files;
1067 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1070 skip_to_line (p, l, false);
1072 skip_to_line (p, line, true);
1077 if (functionname != NULL
1078 && (prev_functionname == NULL
1079 || strcmp (functionname, prev_functionname) != 0))
1081 if (prev_functionname != NULL)
1082 free (prev_functionname);
1083 prev_functionname = xmalloc (strlen (functionname) + 1);
1084 strcpy (prev_functionname, functionname);
1087 if (line > 0 && line != prev_line)
1091 /* Pseudo FILE object for strings. */
1099 /* sprintf to a "stream" */
1102 #ifdef ANSI_PROTOTYPES
1103 objdump_sprintf (SFILE *f, const char *format, ...)
1105 objdump_sprintf (va_alist)
1109 #ifndef ANSI_PROTOTYPES
1117 #ifdef ANSI_PROTOTYPES
1118 va_start (args, format);
1121 f = va_arg (args, SFILE *);
1122 format = va_arg (args, const char *);
1125 vasprintf (&buf, format, args);
1131 fprintf (stderr, _("Out of virtual memory\n"));
1137 while ((f->buffer + f->size) - f->current < n + 1)
1141 curroff = f->current - f->buffer;
1143 f->buffer = xrealloc (f->buffer, f->size);
1144 f->current = f->buffer + curroff;
1147 memcpy (f->current, buf, n);
1149 f->current[0] = '\0';
1156 /* The number of zeroes we want to see before we start skipping them.
1157 The number is arbitrarily chosen. */
1159 #define SKIP_ZEROES (8)
1161 /* The number of zeroes to skip at the end of a section. If the
1162 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1163 SKIP_ZEROES, they will be disassembled. If there are fewer than
1164 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1165 attempt to avoid disassembling zeroes inserted by section
1168 #define SKIP_ZEROES_AT_END (3)
1170 /* Disassemble some data in memory between given values. */
1173 disassemble_bytes (info, disassemble_fn, insns, data, start, stop, relppp,
1175 struct disassemble_info *info;
1176 disassembler_ftype disassemble_fn;
1184 struct objdump_disasm_info *aux;
1188 int skip_addr_chars;
1191 aux = (struct objdump_disasm_info *) info->application_data;
1197 bytes_per_line = 16;
1199 /* Figure out how many characters to skip at the start of an
1200 address, to make the disassembly look nicer. We discard leading
1201 zeroes in chunks of 4, ensuring that there is always a leading
1203 skip_addr_chars = 0;
1204 if (! prefix_addresses)
1210 section->vma + bfd_section_size (section->owner, section));
1212 while (s[0] == '0' && s[1] == '0' && s[2] == '0' && s[3] == '0'
1215 skip_addr_chars += 4;
1220 info->insn_info_valid = 0;
1228 boolean need_nl = false;
1230 /* If we see more than SKIP_ZEROES bytes of zeroes, we just
1232 for (z = i; z < stop; z++)
1235 if (! disassemble_zeroes
1236 && (info->insn_info_valid == 0
1237 || info->branch_delay_insns == 0)
1238 && (z - i >= SKIP_ZEROES
1239 || (z == stop && z - i < SKIP_ZEROES_AT_END)))
1243 /* If there are more nonzero bytes to follow, we only skip
1244 zeroes in multiples of 4, to try to avoid running over
1245 the start of an instruction which happens to start with
1248 z = i + ((z - i) &~ 3);
1261 if (with_line_numbers || with_source_code)
1262 show_line (aux->abfd, section, i);
1264 if (! prefix_addresses)
1268 sprintf_vma (buf, section->vma + i);
1269 for (s = buf + skip_addr_chars; *s == '0'; s++)
1273 printf ("%s:\t", buf + skip_addr_chars);
1277 aux->require_sec = true;
1278 objdump_print_address (section->vma + i, info);
1279 aux->require_sec = false;
1286 sfile.buffer = xmalloc (sfile.size);
1287 sfile.current = sfile.buffer;
1288 info->fprintf_func = (fprintf_ftype) objdump_sprintf;
1289 info->stream = (FILE *) &sfile;
1290 info->bytes_per_line = 0;
1291 info->bytes_per_chunk = 0;
1293 /* FIXME: This is wrong. It tests the number of bytes
1294 in the last instruction, not the current one. */
1295 if (*relppp < relppend
1296 && (**relppp)->address >= i
1297 && (**relppp)->address < i + bytes)
1298 info->flags = INSN_HAS_RELOC;
1302 bytes = (*disassemble_fn) (section->vma + i, info);
1303 info->fprintf_func = (fprintf_ftype) fprintf;
1304 info->stream = stdout;
1305 if (info->bytes_per_line != 0)
1306 bytes_per_line = info->bytes_per_line;
1314 bytes = bytes_per_line;
1315 if (i + bytes > stop)
1318 for (j = i; j < i + bytes; ++j)
1320 if (isprint (data[j]))
1321 buf[j - i] = data[j];
1328 if (prefix_addresses
1330 : show_raw_insn >= 0)
1334 /* If ! prefix_addresses and ! wide_output, we print
1335 bytes_per_line bytes per line. */
1337 if (pb > bytes_per_line && ! prefix_addresses && ! wide_output)
1338 pb = bytes_per_line;
1340 if (info->bytes_per_chunk)
1341 bpc = info->bytes_per_chunk;
1345 for (j = i; j < i + pb; j += bpc)
1348 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1350 for (k = bpc - 1; k >= 0; k--)
1351 printf ("%02x", (unsigned) data[j + k]);
1356 for (k = 0; k < bpc; k++)
1357 printf ("%02x", (unsigned) data[j + k]);
1362 for (; pb < bytes_per_line; pb += bpc)
1366 for (k = 0; k < bpc; k++)
1371 /* Separate raw data from instruction by extra space. */
1382 printf ("%s", sfile.buffer);
1383 free (sfile.buffer);
1386 if (prefix_addresses
1388 : show_raw_insn >= 0)
1398 sprintf_vma (buf, section->vma + j);
1399 for (s = buf + skip_addr_chars; *s == '0'; s++)
1403 printf ("%s:\t", buf + skip_addr_chars);
1405 pb += bytes_per_line;
1408 for (; j < i + pb; j += bpc)
1412 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1414 for (k = bpc - 1; k >= 0; k--)
1415 printf ("%02x", (unsigned) data[j + k]);
1420 for (k = 0; k < bpc; k++)
1421 printf ("%02x", (unsigned) data[j + k]);
1435 && (section->flags & SEC_RELOC) != 0)
1437 while ((*relppp) < relppend
1438 && ((**relppp)->address >= (bfd_vma) i
1439 && (**relppp)->address < (bfd_vma) i + bytes))
1450 objdump_print_value (section->vma + q->address, info, true);
1452 printf (": %s\t", q->howto->name);
1454 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1455 printf ("*unknown*");
1458 const char *sym_name;
1460 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1461 if (sym_name != NULL && *sym_name != '\0')
1462 objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
1467 sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1468 sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1469 if (sym_name == NULL || *sym_name == '\0')
1470 sym_name = "*unknown*";
1471 printf ("%s", sym_name);
1478 objdump_print_value (q->addend, info, true);
1494 /* Disassemble the contents of an object file. */
1497 disassemble_data (abfd)
1501 disassembler_ftype disassemble_fn;
1502 struct disassemble_info disasm_info;
1503 struct objdump_disasm_info aux;
1507 prev_functionname = NULL;
1510 /* We make a copy of syms to sort. We don't want to sort syms
1511 because that will screw up the relocs. */
1512 sorted_syms = (asymbol **) xmalloc (symcount * sizeof (asymbol *));
1513 memcpy (sorted_syms, syms, symcount * sizeof (asymbol *));
1515 sorted_symcount = remove_useless_symbols (sorted_syms, symcount);
1517 /* Sort the symbols into section and symbol order */
1518 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
1520 INIT_DISASSEMBLE_INFO(disasm_info, stdout, fprintf);
1521 disasm_info.application_data = (PTR) &aux;
1523 aux.require_sec = false;
1524 disasm_info.print_address_func = objdump_print_address;
1525 disasm_info.symbol_at_address_func = objdump_symbol_at_address;
1527 if (machine != (char *) NULL)
1529 const bfd_arch_info_type *info = bfd_scan_arch (machine);
1532 fprintf (stderr, _("%s: Can't use supplied machine %s\n"),
1537 abfd->arch_info = info;
1540 if (endian != BFD_ENDIAN_UNKNOWN)
1542 struct bfd_target *xvec;
1544 xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target));
1545 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
1546 xvec->byteorder = endian;
1550 disassemble_fn = disassembler (abfd);
1551 if (!disassemble_fn)
1553 fprintf (stderr, _("%s: Can't disassemble for architecture %s\n"),
1555 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
1559 disasm_info.flavour = bfd_get_flavour (abfd);
1560 disasm_info.arch = bfd_get_arch (abfd);
1561 disasm_info.mach = bfd_get_mach (abfd);
1562 if (bfd_big_endian (abfd))
1563 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
1564 else if (bfd_little_endian (abfd))
1565 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
1567 /* ??? Aborting here seems too drastic. We could default to big or little
1569 disasm_info.endian = BFD_ENDIAN_UNKNOWN;
1571 for (section = abfd->sections;
1572 section != (asection *) NULL;
1573 section = section->next)
1575 bfd_byte *data = NULL;
1576 bfd_size_type datasize = 0;
1577 arelent **relbuf = NULL;
1578 arelent **relpp = NULL;
1579 arelent **relppend = NULL;
1581 asymbol *sym = NULL;
1584 if ((section->flags & SEC_LOAD) == 0
1585 || (! disassemble_all
1587 && (section->flags & SEC_CODE) == 0))
1589 if (only != (char *) NULL && strcmp (only, section->name) != 0)
1593 && (section->flags & SEC_RELOC) != 0)
1597 relsize = bfd_get_reloc_upper_bound (abfd, section);
1599 bfd_fatal (bfd_get_filename (abfd));
1605 relbuf = (arelent **) xmalloc (relsize);
1606 relcount = bfd_canonicalize_reloc (abfd, section, relbuf, syms);
1608 bfd_fatal (bfd_get_filename (abfd));
1610 /* Sort the relocs by address. */
1611 qsort (relbuf, relcount, sizeof (arelent *), compare_relocs);
1614 relppend = relpp + relcount;
1616 /* Skip over the relocs belonging to addresses below the
1618 if (start_address != (bfd_vma) -1)
1620 while (relpp < relppend
1621 && (*relpp)->address < start_address)
1627 printf (_("Disassembly of section %s:\n"), section->name);
1629 datasize = bfd_get_section_size_before_reloc (section);
1633 data = (bfd_byte *) xmalloc ((size_t) datasize);
1635 bfd_get_section_contents (abfd, section, data, 0, datasize);
1638 disasm_info.buffer = data;
1639 disasm_info.buffer_vma = section->vma;
1640 disasm_info.buffer_length = datasize;
1641 if (start_address == (bfd_vma) -1
1642 || start_address < disasm_info.buffer_vma)
1645 i = start_address - disasm_info.buffer_vma;
1646 if (stop_address == (bfd_vma) -1)
1650 if (stop_address < disasm_info.buffer_vma)
1653 stop = stop_address - disasm_info.buffer_vma;
1654 if (stop > disasm_info.buffer_length)
1655 stop = disasm_info.buffer_length;
1658 sym = find_symbol_for_address (abfd, section, section->vma + i,
1667 if (sym != NULL && bfd_asymbol_value (sym) <= section->vma + i)
1672 (x < sorted_symcount
1673 && bfd_asymbol_value (sorted_syms[x]) <= section->vma + i);
1676 disasm_info.symbols = & sorted_syms[place];
1677 disasm_info.num_symbols = x - place;
1680 disasm_info.symbols = NULL;
1682 if (! prefix_addresses)
1685 objdump_print_addr_with_sym (abfd, section, sym,
1692 if (sym != NULL && bfd_asymbol_value (sym) > section->vma + i)
1694 else if (sym == NULL)
1698 while (place < sorted_symcount
1699 /* ??? Why the test for != section? */
1700 && (sorted_syms[place]->section != section
1701 || (bfd_asymbol_value (sorted_syms[place])
1702 <= bfd_asymbol_value (sym))))
1704 if (place >= sorted_symcount)
1707 nextsym = sorted_syms[place];
1710 if (sym != NULL && bfd_asymbol_value (sym) > section->vma + i)
1712 nextstop = bfd_asymbol_value (sym) - section->vma;
1713 if (nextstop > stop)
1716 else if (nextsym == NULL)
1720 nextstop = bfd_asymbol_value (nextsym) - section->vma;
1721 if (nextstop > stop)
1725 /* If a symbol is explicitly marked as being an object
1726 rather than a function, just dump the bytes without
1727 disassembling them. */
1730 || bfd_asymbol_value (sym) > section->vma + i
1731 || ((sym->flags & BSF_OBJECT) == 0
1732 && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1734 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1736 || (sym->flags & BSF_FUNCTION) != 0)
1741 disassemble_bytes (&disasm_info, disassemble_fn, insns, data, i,
1742 nextstop, &relpp, relppend);
1756 /* Define a table of stab values and print-strings. We wish the initializer
1757 could be a direct-mapped table, but instead we build one the first
1760 static void dump_section_stabs PARAMS ((bfd *abfd, char *stabsect_name,
1761 char *strsect_name));
1763 /* Dump the stabs sections from an object file that has a section that
1764 uses Sun stabs encoding. */
1770 dump_section_stabs (abfd, ".stab", ".stabstr");
1771 dump_section_stabs (abfd, ".stab.excl", ".stab.exclstr");
1772 dump_section_stabs (abfd, ".stab.index", ".stab.indexstr");
1773 dump_section_stabs (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1776 static bfd_byte *stabs;
1777 static bfd_size_type stab_size;
1779 static char *strtab;
1780 static bfd_size_type stabstr_size;
1782 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1783 and string table section STRSECT_NAME into `strtab'.
1784 If the section exists and was read, allocate the space and return true.
1785 Otherwise return false. */
1788 read_section_stabs (abfd, stabsect_name, strsect_name)
1790 const char *stabsect_name;
1791 const char *strsect_name;
1793 asection *stabsect, *stabstrsect;
1795 stabsect = bfd_get_section_by_name (abfd, stabsect_name);
1798 printf (_("No %s section present\n\n"), stabsect_name);
1802 stabstrsect = bfd_get_section_by_name (abfd, strsect_name);
1803 if (0 == stabstrsect)
1805 fprintf (stderr, _("%s: %s has no %s section\n"), program_name,
1806 bfd_get_filename (abfd), strsect_name);
1810 stab_size = bfd_section_size (abfd, stabsect);
1811 stabstr_size = bfd_section_size (abfd, stabstrsect);
1813 stabs = (bfd_byte *) xmalloc (stab_size);
1814 strtab = (char *) xmalloc (stabstr_size);
1816 if (! bfd_get_section_contents (abfd, stabsect, (PTR) stabs, 0, stab_size))
1818 fprintf (stderr, _("%s: Reading %s section of %s failed: %s\n"),
1819 program_name, stabsect_name, bfd_get_filename (abfd),
1820 bfd_errmsg (bfd_get_error ()));
1826 if (! bfd_get_section_contents (abfd, stabstrsect, (PTR) strtab, 0,
1829 fprintf (stderr, _("%s: Reading %s section of %s failed: %s\n"),
1830 program_name, strsect_name, bfd_get_filename (abfd),
1831 bfd_errmsg (bfd_get_error ()));
1840 /* Stabs entries use a 12 byte format:
1841 4 byte string table index
1843 1 byte stab other field
1844 2 byte stab desc field
1846 FIXME: This will have to change for a 64 bit object format. */
1848 #define STRDXOFF (0)
1850 #define OTHEROFF (5)
1853 #define STABSIZE (12)
1855 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1856 using string table section STRSECT_NAME (in `strtab'). */
1859 print_section_stabs (abfd, stabsect_name, strsect_name)
1861 const char *stabsect_name;
1862 const char *strsect_name;
1865 unsigned file_string_table_offset = 0, next_file_string_table_offset = 0;
1866 bfd_byte *stabp, *stabs_end;
1869 stabs_end = stabp + stab_size;
1871 printf (_("Contents of %s section:\n\n"), stabsect_name);
1872 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1874 /* Loop through all symbols and print them.
1876 We start the index at -1 because there is a dummy symbol on
1877 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1879 for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
1883 unsigned char type, other;
1884 unsigned short desc;
1887 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
1888 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
1889 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
1890 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
1891 value = bfd_h_get_32 (abfd, stabp + VALOFF);
1893 printf ("\n%-6d ", i);
1894 /* Either print the stab name, or, if unnamed, print its number
1895 again (makes consistent formatting for tools like awk). */
1896 name = bfd_get_stab_name (type);
1898 printf ("%-6s", name);
1899 else if (type == N_UNDF)
1902 printf ("%-6d", type);
1903 printf (" %-6d %-6d ", other, desc);
1905 printf (" %-6lu", strx);
1907 /* Symbols with type == 0 (N_UNDF) specify the length of the
1908 string table associated with this file. We use that info
1909 to know how to relocate the *next* file's string table indices. */
1913 file_string_table_offset = next_file_string_table_offset;
1914 next_file_string_table_offset += value;
1918 /* Using the (possibly updated) string table offset, print the
1919 string (if any) associated with this symbol. */
1921 if ((strx + file_string_table_offset) < stabstr_size)
1922 printf (" %s", &strtab[strx + file_string_table_offset]);
1931 dump_section_stabs (abfd, stabsect_name, strsect_name)
1933 char *stabsect_name;
1938 /* Check for section names for which stabsect_name is a prefix, to
1939 handle .stab0, etc. */
1940 for (s = abfd->sections;
1946 len = strlen (stabsect_name);
1948 /* If the prefix matches, and the files section name ends with a
1949 nul or a digit, then we match. I.e., we want either an exact
1950 match or a section followed by a number. */
1951 if (strncmp (stabsect_name, s->name, len) == 0
1952 && (s->name[len] == '\000'
1953 || isdigit ((unsigned char) s->name[len])))
1955 if (read_section_stabs (abfd, s->name, strsect_name))
1957 print_section_stabs (abfd, s->name, strsect_name);
1966 dump_bfd_header (abfd)
1971 printf (_("architecture: %s, "),
1972 bfd_printable_arch_mach (bfd_get_arch (abfd),
1973 bfd_get_mach (abfd)));
1974 printf (_("flags 0x%08x:\n"), abfd->flags);
1976 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
1977 PF (HAS_RELOC, "HAS_RELOC");
1978 PF (EXEC_P, "EXEC_P");
1979 PF (HAS_LINENO, "HAS_LINENO");
1980 PF (HAS_DEBUG, "HAS_DEBUG");
1981 PF (HAS_SYMS, "HAS_SYMS");
1982 PF (HAS_LOCALS, "HAS_LOCALS");
1983 PF (DYNAMIC, "DYNAMIC");
1984 PF (WP_TEXT, "WP_TEXT");
1985 PF (D_PAGED, "D_PAGED");
1986 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
1987 printf (_("\nstart address 0x"));
1988 printf_vma (abfd->start_address);
1993 dump_bfd_private_header (abfd)
1996 bfd_print_private_bfd_data (abfd, stdout);
2005 if (!bfd_check_format_matches (abfd, bfd_object, &matching))
2007 bfd_nonfatal (bfd_get_filename (abfd));
2008 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2010 list_matching_formats (matching);
2016 /* If we are adjusting section VMA's, change them all now. Changing
2017 the BFD information is a hack. However, we must do it, or
2018 bfd_find_nearest_line will not do the right thing. */
2019 if (adjust_section_vma != 0)
2023 for (s = abfd->sections; s != NULL; s = s->next)
2025 s->vma += adjust_section_vma;
2026 s->lma += adjust_section_vma;
2030 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
2033 print_arelt_descr (stdout, abfd, true);
2034 if (dump_file_header)
2035 dump_bfd_header (abfd);
2036 if (dump_private_headers)
2037 dump_bfd_private_header (abfd);
2039 if (dump_section_headers)
2040 dump_headers (abfd);
2041 if (dump_symtab || dump_reloc_info || disassemble || dump_debugging)
2043 syms = slurp_symtab (abfd);
2045 if (dump_dynamic_symtab || dump_dynamic_reloc_info)
2047 dynsyms = slurp_dynamic_symtab (abfd);
2050 dump_symbols (abfd, false);
2051 if (dump_dynamic_symtab)
2052 dump_symbols (abfd, true);
2053 if (dump_stab_section_info)
2055 if (dump_reloc_info && ! disassemble)
2057 if (dump_dynamic_reloc_info)
2058 dump_dynamic_relocs (abfd);
2059 if (dump_section_contents)
2062 disassemble_data (abfd);
2067 dhandle = read_debugging_info (abfd, syms, symcount);
2068 if (dhandle != NULL)
2070 if (! print_debugging_info (stdout, dhandle))
2071 fprintf (stderr, _("%s: printing debugging information failed\n"),
2072 bfd_get_filename (abfd));
2088 display_file (filename, target)
2092 bfd *file, *arfile = (bfd *) NULL;
2094 file = bfd_openr (filename, target);
2097 bfd_nonfatal (filename);
2101 if (bfd_check_format (file, bfd_archive) == true)
2103 bfd *last_arfile = NULL;
2105 printf (_("In archive %s:\n"), bfd_get_filename (file));
2108 bfd_set_error (bfd_error_no_error);
2110 arfile = bfd_openr_next_archived_file (file, arfile);
2113 if (bfd_get_error () != bfd_error_no_more_archived_files)
2115 bfd_nonfatal (bfd_get_filename (file));
2120 display_bfd (arfile);
2122 if (last_arfile != NULL)
2123 bfd_close (last_arfile);
2124 last_arfile = arfile;
2127 if (last_arfile != NULL)
2128 bfd_close (last_arfile);
2136 /* Actually display the various requested regions */
2144 bfd_size_type datasize = 0;
2146 bfd_size_type start, stop;
2148 for (section = abfd->sections; section != NULL; section =
2153 if (only == (char *) NULL ||
2154 strcmp (only, section->name) == 0)
2156 if (section->flags & SEC_HAS_CONTENTS)
2158 printf (_("Contents of section %s:\n"), section->name);
2160 if (bfd_section_size (abfd, section) == 0)
2162 data = (bfd_byte *) xmalloc ((size_t) bfd_section_size (abfd, section));
2163 datasize = bfd_section_size (abfd, section);
2166 bfd_get_section_contents (abfd, section, (PTR) data, 0, bfd_section_size (abfd, section));
2168 if (start_address == (bfd_vma) -1
2169 || start_address < section->vma)
2172 start = start_address - section->vma;
2173 if (stop_address == (bfd_vma) -1)
2174 stop = bfd_section_size (abfd, section);
2177 if (stop_address < section->vma)
2180 stop = stop_address - section->vma;
2181 if (stop > bfd_section_size (abfd, section))
2182 stop = bfd_section_size (abfd, section);
2184 for (i = start; i < stop; i += onaline)
2188 printf (" %04lx ", (unsigned long int) (i + section->vma));
2189 for (j = i; j < i + onaline; j++)
2192 printf ("%02x", (unsigned) (data[j]));
2200 for (j = i; j < i + onaline; j++)
2205 printf ("%c", isprint (data[j]) ? data[j] : '.');
2215 /* Should perhaps share code and display with nm? */
2217 dump_symbols (abfd, dynamic)
2231 printf ("DYNAMIC SYMBOL TABLE:\n");
2239 printf ("SYMBOL TABLE:\n");
2242 for (count = 0; count < max; count++)
2246 bfd *cur_bfd = bfd_asymbol_bfd (*current);
2248 if (cur_bfd != NULL)
2253 name = bfd_asymbol_name (*current);
2255 if (do_demangle && name != NULL && *name != '\0')
2259 /* If we want to demangle the name, we demangle it
2260 here, and temporarily clobber it while calling
2261 bfd_print_symbol. FIXME: This is a gross hack. */
2264 if (bfd_get_symbol_leading_char (cur_bfd) == *n)
2266 alloc = cplus_demangle (n, DMGL_ANSI | DMGL_PARAMS);
2268 (*current)->name = alloc;
2270 (*current)->name = n;
2273 bfd_print_symbol (cur_bfd, stdout, *current,
2274 bfd_print_symbol_all);
2276 (*current)->name = name;
2297 for (a = abfd->sections; a != (asection *) NULL; a = a->next)
2301 if (bfd_is_abs_section (a))
2303 if (bfd_is_und_section (a))
2305 if (bfd_is_com_section (a))
2310 if (strcmp (only, a->name))
2313 else if ((a->flags & SEC_RELOC) == 0)
2316 relsize = bfd_get_reloc_upper_bound (abfd, a);
2318 bfd_fatal (bfd_get_filename (abfd));
2320 printf ("RELOCATION RECORDS FOR [%s]:", a->name);
2324 printf (" (none)\n\n");
2328 relpp = (arelent **) xmalloc (relsize);
2329 relcount = bfd_canonicalize_reloc (abfd, a, relpp, syms);
2331 bfd_fatal (bfd_get_filename (abfd));
2332 else if (relcount == 0)
2334 printf (" (none)\n\n");
2339 dump_reloc_set (abfd, a, relpp, relcount);
2348 dump_dynamic_relocs (abfd)
2355 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2357 bfd_fatal (bfd_get_filename (abfd));
2359 printf ("DYNAMIC RELOCATION RECORDS");
2363 printf (" (none)\n\n");
2367 relpp = (arelent **) xmalloc (relsize);
2368 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2370 bfd_fatal (bfd_get_filename (abfd));
2371 else if (relcount == 0)
2373 printf (" (none)\n\n");
2378 dump_reloc_set (abfd, (asection *) NULL, relpp, relcount);
2386 dump_reloc_set (abfd, sec, relpp, relcount)
2393 char *last_filename, *last_functionname;
2394 unsigned int last_line;
2396 /* Get column headers lined up reasonably. */
2402 sprintf_vma (buf, (bfd_vma) -1);
2403 width = strlen (buf) - 7;
2405 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2408 last_filename = NULL;
2409 last_functionname = NULL;
2412 for (p = relpp; relcount && *p != (arelent *) NULL; p++, relcount--)
2415 const char *filename, *functionname;
2417 const char *sym_name;
2418 const char *section_name;
2420 if (start_address != (bfd_vma) -1
2421 && q->address < start_address)
2423 if (stop_address != (bfd_vma) -1
2424 && q->address > stop_address)
2427 if (with_line_numbers
2429 && bfd_find_nearest_line (abfd, sec, syms, q->address,
2430 &filename, &functionname, &line))
2432 if (functionname != NULL
2433 && (last_functionname == NULL
2434 || strcmp (functionname, last_functionname) != 0))
2436 printf ("%s():\n", functionname);
2437 if (last_functionname != NULL)
2438 free (last_functionname);
2439 last_functionname = xstrdup (functionname);
2442 && (line != last_line
2443 || (filename != NULL
2444 && last_filename != NULL
2445 && strcmp (filename, last_filename) != 0)))
2447 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2449 if (last_filename != NULL)
2450 free (last_filename);
2451 if (filename == NULL)
2452 last_filename = NULL;
2454 last_filename = xstrdup (filename);
2458 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2460 sym_name = (*(q->sym_ptr_ptr))->name;
2461 section_name = (*(q->sym_ptr_ptr))->section->name;
2466 section_name = NULL;
2470 printf_vma (q->address);
2471 printf (" %-16s ", q->howto->name);
2472 objdump_print_symname (abfd, (struct disassemble_info *) NULL,
2477 if (section_name == (CONST char *) NULL)
2478 section_name = "*unknown*";
2479 printf_vma (q->address);
2480 printf (" %-16s [%s]",
2487 printf_vma (q->addend);
2493 /* The length of the longest architecture name + 1. */
2494 #define LONGEST_ARCH sizeof("rs6000:6000")
2497 endian_string (endian)
2498 enum bfd_endian endian;
2500 if (endian == BFD_ENDIAN_BIG)
2501 return "big endian";
2502 else if (endian == BFD_ENDIAN_LITTLE)
2503 return "little endian";
2505 return "endianness unknown";
2508 /* List the targets that BFD is configured to support, each followed
2509 by its endianness and the architectures it supports. */
2512 display_target_list ()
2514 extern bfd_target *bfd_target_vector[];
2518 dummy_name = choose_temp_base ();
2519 for (t = 0; bfd_target_vector[t]; t++)
2521 bfd_target *p = bfd_target_vector[t];
2522 bfd *abfd = bfd_openw (dummy_name, p->name);
2525 printf ("%s\n (header %s, data %s)\n", p->name,
2526 endian_string (p->header_byteorder),
2527 endian_string (p->byteorder));
2531 bfd_nonfatal (dummy_name);
2535 if (! bfd_set_format (abfd, bfd_object))
2537 if (bfd_get_error () != bfd_error_invalid_operation)
2538 bfd_nonfatal (p->name);
2542 for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++)
2543 if (bfd_set_arch_mach (abfd, (enum bfd_architecture) a, 0))
2545 bfd_printable_arch_mach ((enum bfd_architecture) a, 0));
2547 unlink (dummy_name);
2551 /* Print a table showing which architectures are supported for entries
2552 FIRST through LAST-1 of bfd_target_vector (targets across,
2553 architectures down). */
2556 display_info_table (first, last)
2560 extern bfd_target *bfd_target_vector[];
2564 /* Print heading of target names. */
2565 printf ("\n%*s", (int) LONGEST_ARCH, " ");
2566 for (t = first; t < last && bfd_target_vector[t]; t++)
2567 printf ("%s ", bfd_target_vector[t]->name);
2570 dummy_name = choose_temp_base ();
2571 for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++)
2572 if (strcmp (bfd_printable_arch_mach (a, 0), "UNKNOWN!") != 0)
2574 printf ("%*s ", (int) LONGEST_ARCH - 1,
2575 bfd_printable_arch_mach (a, 0));
2576 for (t = first; t < last && bfd_target_vector[t]; t++)
2578 bfd_target *p = bfd_target_vector[t];
2580 bfd *abfd = bfd_openw (dummy_name, p->name);
2584 bfd_nonfatal (p->name);
2590 if (! bfd_set_format (abfd, bfd_object))
2592 if (bfd_get_error () != bfd_error_invalid_operation)
2593 bfd_nonfatal (p->name);
2600 if (! bfd_set_arch_mach (abfd, a, 0))
2605 printf ("%s ", p->name);
2608 int l = strlen (p->name);
2616 unlink (dummy_name);
2620 /* Print tables of all the target-architecture combinations that
2621 BFD has been configured to support. */
2624 display_target_tables ()
2627 extern bfd_target *bfd_target_vector[];
2631 colum = getenv ("COLUMNS");
2633 columns = atoi (colum);
2638 while (bfd_target_vector[t] != NULL)
2642 wid = LONGEST_ARCH + strlen (bfd_target_vector[t]->name) + 1;
2644 while (wid < columns && bfd_target_vector[t] != NULL)
2648 newwid = wid + strlen (bfd_target_vector[t]->name) + 1;
2649 if (newwid >= columns)
2654 display_info_table (oldt, t);
2661 printf (_("BFD header file version %s\n"), BFD_VERSION);
2662 display_target_list ();
2663 display_target_tables ();
2672 char *target = default_target;
2673 boolean seenflag = false;
2675 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
2676 setlocale (LC_MESSAGES, "");
2678 bindtextdomain (PACKAGE, LOCALEDIR);
2679 textdomain (PACKAGE);
2681 program_name = *argv;
2682 xmalloc_set_program_name (program_name);
2684 START_PROGRESS (program_name, 0);
2687 set_default_bfd_target ();
2689 while ((c = getopt_long (argc, argv, "pib:m:VCdDlfahrRtTxsSj:wE:",
2690 long_options, (int *) 0))
2693 if (c != 'l' && c != OPTION_START_ADDRESS && c != OPTION_STOP_ADDRESS)
2698 break; /* we've been given a long option */
2706 with_line_numbers = 1;
2712 dump_file_header = true;
2715 formats_info = true;
2718 dump_private_headers = 1;
2721 dump_private_headers = 1;
2723 dump_reloc_info = 1;
2724 dump_file_header = true;
2726 dump_section_headers = 1;
2732 dump_dynamic_symtab = 1;
2741 disassemble = disassemble_all = true;
2745 with_source_code = true;
2748 dump_section_contents = 1;
2751 dump_reloc_info = 1;
2754 dump_dynamic_reloc_info = 1;
2760 dump_section_headers = 1;
2770 case OPTION_ADJUST_VMA:
2771 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
2773 case OPTION_START_ADDRESS:
2774 start_address = parse_vma (optarg, "--start-address");
2776 case OPTION_STOP_ADDRESS:
2777 stop_address = parse_vma (optarg, "--stop-address");
2780 if (strcmp (optarg, "B") == 0)
2781 endian = BFD_ENDIAN_BIG;
2782 else if (strcmp (optarg, "L") == 0)
2783 endian = BFD_ENDIAN_LITTLE;
2786 fprintf (stderr, _("%s: unrecognized -E option\n"), program_name);
2791 if (strncmp (optarg, "big", strlen (optarg)) == 0)
2792 endian = BFD_ENDIAN_BIG;
2793 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
2794 endian = BFD_ENDIAN_LITTLE;
2797 fprintf (stderr, _("%s: unrecognized --endian type `%s'\n"),
2798 program_name, optarg);
2808 print_version ("objdump");
2810 if (seenflag == false)
2820 display_file ("a.out", target);
2822 for (; optind < argc;)
2823 display_file (argv[optind++], target);
2826 END_PROGRESS (program_name);