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
;
1309 if (sfile
.current
!= sfile
.buffer
)
1310 printf ("%s\n", sfile
.buffer
);
1311 free (sfile
.buffer
);
1319 bytes
= bytes_per_line
;
1320 if (i
+ bytes
> stop
)
1323 for (j
= i
; j
< i
+ bytes
; ++j
)
1325 if (isprint (data
[j
]))
1326 buf
[j
- i
] = data
[j
];
1333 if (prefix_addresses
1335 : show_raw_insn
>= 0)
1339 /* If ! prefix_addresses and ! wide_output, we print
1340 bytes_per_line bytes per line. */
1342 if (pb
> bytes_per_line
&& ! prefix_addresses
&& ! wide_output
)
1343 pb
= bytes_per_line
;
1345 if (info
->bytes_per_chunk
)
1346 bpc
= info
->bytes_per_chunk
;
1350 for (j
= i
; j
< i
+ pb
; j
+= bpc
)
1353 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1355 for (k
= bpc
- 1; k
>= 0; k
--)
1356 printf ("%02x", (unsigned) data
[j
+ k
]);
1361 for (k
= 0; k
< bpc
; k
++)
1362 printf ("%02x", (unsigned) data
[j
+ k
]);
1367 for (; pb
< bytes_per_line
; pb
+= bpc
)
1371 for (k
= 0; k
< bpc
; k
++)
1376 /* Separate raw data from instruction by extra space. */
1387 printf ("%s", sfile
.buffer
);
1388 free (sfile
.buffer
);
1391 if (prefix_addresses
1393 : show_raw_insn
>= 0)
1403 sprintf_vma (buf
, section
->vma
+ j
);
1404 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1408 printf ("%s:\t", buf
+ skip_addr_chars
);
1410 pb
+= bytes_per_line
;
1413 for (; j
< i
+ pb
; j
+= bpc
)
1417 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1419 for (k
= bpc
- 1; k
>= 0; k
--)
1420 printf ("%02x", (unsigned) data
[j
+ k
]);
1425 for (k
= 0; k
< bpc
; k
++)
1426 printf ("%02x", (unsigned) data
[j
+ k
]);
1440 && (section
->flags
& SEC_RELOC
) != 0)
1442 while ((*relppp
) < relppend
1443 && ((**relppp
)->address
>= (bfd_vma
) i
1444 && (**relppp
)->address
< (bfd_vma
) i
+ bytes
))
1455 objdump_print_value (section
->vma
+ q
->address
, info
, true);
1457 printf (": %s\t", q
->howto
->name
);
1459 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1460 printf ("*unknown*");
1463 const char *sym_name
;
1465 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1466 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1467 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1472 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1473 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1474 if (sym_name
== NULL
|| *sym_name
== '\0')
1475 sym_name
= "*unknown*";
1476 printf ("%s", sym_name
);
1483 objdump_print_value (q
->addend
, info
, true);
1499 /* Disassemble the contents of an object file. */
1502 disassemble_data (abfd
)
1506 disassembler_ftype disassemble_fn
;
1507 struct disassemble_info disasm_info
;
1508 struct objdump_disasm_info aux
;
1512 prev_functionname
= NULL
;
1515 /* We make a copy of syms to sort. We don't want to sort syms
1516 because that will screw up the relocs. */
1517 sorted_syms
= (asymbol
**) xmalloc (symcount
* sizeof (asymbol
*));
1518 memcpy (sorted_syms
, syms
, symcount
* sizeof (asymbol
*));
1520 sorted_symcount
= remove_useless_symbols (sorted_syms
, symcount
);
1522 /* Sort the symbols into section and symbol order */
1523 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1525 INIT_DISASSEMBLE_INFO(disasm_info
, stdout
, fprintf
);
1526 disasm_info
.application_data
= (PTR
) &aux
;
1528 aux
.require_sec
= false;
1529 disasm_info
.print_address_func
= objdump_print_address
;
1530 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1532 if (machine
!= (char *) NULL
)
1534 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1537 fprintf (stderr
, _("%s: Can't use supplied machine %s\n"),
1542 abfd
->arch_info
= info
;
1545 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1547 struct bfd_target
*xvec
;
1549 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
1550 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1551 xvec
->byteorder
= endian
;
1555 disassemble_fn
= disassembler (abfd
);
1556 if (!disassemble_fn
)
1558 fprintf (stderr
, _("%s: Can't disassemble for architecture %s\n"),
1560 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1564 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1565 disasm_info
.arch
= bfd_get_arch (abfd
);
1566 disasm_info
.mach
= bfd_get_mach (abfd
);
1567 if (bfd_big_endian (abfd
))
1568 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1569 else if (bfd_little_endian (abfd
))
1570 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1572 /* ??? Aborting here seems too drastic. We could default to big or little
1574 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1576 for (section
= abfd
->sections
;
1577 section
!= (asection
*) NULL
;
1578 section
= section
->next
)
1580 bfd_byte
*data
= NULL
;
1581 bfd_size_type datasize
= 0;
1582 arelent
**relbuf
= NULL
;
1583 arelent
**relpp
= NULL
;
1584 arelent
**relppend
= NULL
;
1586 asymbol
*sym
= NULL
;
1589 if ((section
->flags
& SEC_LOAD
) == 0
1590 || (! disassemble_all
1592 && (section
->flags
& SEC_CODE
) == 0))
1594 if (only
!= (char *) NULL
&& strcmp (only
, section
->name
) != 0)
1598 && (section
->flags
& SEC_RELOC
) != 0)
1602 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1604 bfd_fatal (bfd_get_filename (abfd
));
1610 relbuf
= (arelent
**) xmalloc (relsize
);
1611 relcount
= bfd_canonicalize_reloc (abfd
, section
, relbuf
, syms
);
1613 bfd_fatal (bfd_get_filename (abfd
));
1615 /* Sort the relocs by address. */
1616 qsort (relbuf
, relcount
, sizeof (arelent
*), compare_relocs
);
1619 relppend
= relpp
+ relcount
;
1621 /* Skip over the relocs belonging to addresses below the
1623 if (start_address
!= (bfd_vma
) -1)
1625 while (relpp
< relppend
1626 && (*relpp
)->address
< start_address
)
1632 printf (_("Disassembly of section %s:\n"), section
->name
);
1634 datasize
= bfd_get_section_size_before_reloc (section
);
1638 data
= (bfd_byte
*) xmalloc ((size_t) datasize
);
1640 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1643 disasm_info
.buffer
= data
;
1644 disasm_info
.buffer_vma
= section
->vma
;
1645 disasm_info
.buffer_length
= datasize
;
1646 if (start_address
== (bfd_vma
) -1
1647 || start_address
< disasm_info
.buffer_vma
)
1650 i
= start_address
- disasm_info
.buffer_vma
;
1651 if (stop_address
== (bfd_vma
) -1)
1655 if (stop_address
< disasm_info
.buffer_vma
)
1658 stop
= stop_address
- disasm_info
.buffer_vma
;
1659 if (stop
> disasm_info
.buffer_length
)
1660 stop
= disasm_info
.buffer_length
;
1663 sym
= find_symbol_for_address (abfd
, section
, section
->vma
+ i
,
1672 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= section
->vma
+ i
)
1677 (x
< sorted_symcount
1678 && bfd_asymbol_value (sorted_syms
[x
]) <= section
->vma
+ i
);
1681 disasm_info
.symbols
= & sorted_syms
[place
];
1682 disasm_info
.num_symbols
= x
- place
;
1685 disasm_info
.symbols
= NULL
;
1687 if (! prefix_addresses
)
1690 objdump_print_addr_with_sym (abfd
, section
, sym
,
1697 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ i
)
1699 else if (sym
== NULL
)
1703 while (place
< sorted_symcount
1704 /* ??? Why the test for != section? */
1705 && (sorted_syms
[place
]->section
!= section
1706 || (bfd_asymbol_value (sorted_syms
[place
])
1707 <= bfd_asymbol_value (sym
))))
1709 if (place
>= sorted_symcount
)
1712 nextsym
= sorted_syms
[place
];
1715 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ i
)
1717 nextstop
= bfd_asymbol_value (sym
) - section
->vma
;
1718 if (nextstop
> stop
)
1721 else if (nextsym
== NULL
)
1725 nextstop
= bfd_asymbol_value (nextsym
) - section
->vma
;
1726 if (nextstop
> stop
)
1730 /* If a symbol is explicitly marked as being an object
1731 rather than a function, just dump the bytes without
1732 disassembling them. */
1735 || bfd_asymbol_value (sym
) > section
->vma
+ i
1736 || ((sym
->flags
& BSF_OBJECT
) == 0
1737 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1739 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1741 || (sym
->flags
& BSF_FUNCTION
) != 0)
1746 disassemble_bytes (&disasm_info
, disassemble_fn
, insns
, data
, i
,
1747 nextstop
, &relpp
, relppend
);
1761 /* Define a table of stab values and print-strings. We wish the initializer
1762 could be a direct-mapped table, but instead we build one the first
1765 static void dump_section_stabs
PARAMS ((bfd
*abfd
, char *stabsect_name
,
1766 char *strsect_name
));
1768 /* Dump the stabs sections from an object file that has a section that
1769 uses Sun stabs encoding. */
1775 dump_section_stabs (abfd
, ".stab", ".stabstr");
1776 dump_section_stabs (abfd
, ".stab.excl", ".stab.exclstr");
1777 dump_section_stabs (abfd
, ".stab.index", ".stab.indexstr");
1778 dump_section_stabs (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1781 static bfd_byte
*stabs
;
1782 static bfd_size_type stab_size
;
1784 static char *strtab
;
1785 static bfd_size_type stabstr_size
;
1787 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1788 and string table section STRSECT_NAME into `strtab'.
1789 If the section exists and was read, allocate the space and return true.
1790 Otherwise return false. */
1793 read_section_stabs (abfd
, stabsect_name
, strsect_name
)
1795 const char *stabsect_name
;
1796 const char *strsect_name
;
1798 asection
*stabsect
, *stabstrsect
;
1800 stabsect
= bfd_get_section_by_name (abfd
, stabsect_name
);
1803 printf (_("No %s section present\n\n"), stabsect_name
);
1807 stabstrsect
= bfd_get_section_by_name (abfd
, strsect_name
);
1808 if (0 == stabstrsect
)
1810 fprintf (stderr
, _("%s: %s has no %s section\n"), program_name
,
1811 bfd_get_filename (abfd
), strsect_name
);
1815 stab_size
= bfd_section_size (abfd
, stabsect
);
1816 stabstr_size
= bfd_section_size (abfd
, stabstrsect
);
1818 stabs
= (bfd_byte
*) xmalloc (stab_size
);
1819 strtab
= (char *) xmalloc (stabstr_size
);
1821 if (! bfd_get_section_contents (abfd
, stabsect
, (PTR
) stabs
, 0, stab_size
))
1823 fprintf (stderr
, _("%s: Reading %s section of %s failed: %s\n"),
1824 program_name
, stabsect_name
, bfd_get_filename (abfd
),
1825 bfd_errmsg (bfd_get_error ()));
1831 if (! bfd_get_section_contents (abfd
, stabstrsect
, (PTR
) strtab
, 0,
1834 fprintf (stderr
, _("%s: Reading %s section of %s failed: %s\n"),
1835 program_name
, strsect_name
, bfd_get_filename (abfd
),
1836 bfd_errmsg (bfd_get_error ()));
1845 /* Stabs entries use a 12 byte format:
1846 4 byte string table index
1848 1 byte stab other field
1849 2 byte stab desc field
1851 FIXME: This will have to change for a 64 bit object format. */
1853 #define STRDXOFF (0)
1855 #define OTHEROFF (5)
1858 #define STABSIZE (12)
1860 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1861 using string table section STRSECT_NAME (in `strtab'). */
1864 print_section_stabs (abfd
, stabsect_name
, strsect_name
)
1866 const char *stabsect_name
;
1867 const char *strsect_name
;
1870 unsigned file_string_table_offset
= 0, next_file_string_table_offset
= 0;
1871 bfd_byte
*stabp
, *stabs_end
;
1874 stabs_end
= stabp
+ stab_size
;
1876 printf (_("Contents of %s section:\n\n"), stabsect_name
);
1877 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1879 /* Loop through all symbols and print them.
1881 We start the index at -1 because there is a dummy symbol on
1882 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1884 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
1888 unsigned char type
, other
;
1889 unsigned short desc
;
1892 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
1893 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
1894 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
1895 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
1896 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
1898 printf ("\n%-6d ", i
);
1899 /* Either print the stab name, or, if unnamed, print its number
1900 again (makes consistent formatting for tools like awk). */
1901 name
= bfd_get_stab_name (type
);
1903 printf ("%-6s", name
);
1904 else if (type
== N_UNDF
)
1907 printf ("%-6d", type
);
1908 printf (" %-6d %-6d ", other
, desc
);
1910 printf (" %-6lu", strx
);
1912 /* Symbols with type == 0 (N_UNDF) specify the length of the
1913 string table associated with this file. We use that info
1914 to know how to relocate the *next* file's string table indices. */
1918 file_string_table_offset
= next_file_string_table_offset
;
1919 next_file_string_table_offset
+= value
;
1923 /* Using the (possibly updated) string table offset, print the
1924 string (if any) associated with this symbol. */
1926 if ((strx
+ file_string_table_offset
) < stabstr_size
)
1927 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
1936 dump_section_stabs (abfd
, stabsect_name
, strsect_name
)
1938 char *stabsect_name
;
1943 /* Check for section names for which stabsect_name is a prefix, to
1944 handle .stab0, etc. */
1945 for (s
= abfd
->sections
;
1951 len
= strlen (stabsect_name
);
1953 /* If the prefix matches, and the files section name ends with a
1954 nul or a digit, then we match. I.e., we want either an exact
1955 match or a section followed by a number. */
1956 if (strncmp (stabsect_name
, s
->name
, len
) == 0
1957 && (s
->name
[len
] == '\000'
1958 || isdigit ((unsigned char) s
->name
[len
])))
1960 if (read_section_stabs (abfd
, s
->name
, strsect_name
))
1962 print_section_stabs (abfd
, s
->name
, strsect_name
);
1971 dump_bfd_header (abfd
)
1976 printf (_("architecture: %s, "),
1977 bfd_printable_arch_mach (bfd_get_arch (abfd
),
1978 bfd_get_mach (abfd
)));
1979 printf (_("flags 0x%08x:\n"), abfd
->flags
);
1981 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
1982 PF (HAS_RELOC
, "HAS_RELOC");
1983 PF (EXEC_P
, "EXEC_P");
1984 PF (HAS_LINENO
, "HAS_LINENO");
1985 PF (HAS_DEBUG
, "HAS_DEBUG");
1986 PF (HAS_SYMS
, "HAS_SYMS");
1987 PF (HAS_LOCALS
, "HAS_LOCALS");
1988 PF (DYNAMIC
, "DYNAMIC");
1989 PF (WP_TEXT
, "WP_TEXT");
1990 PF (D_PAGED
, "D_PAGED");
1991 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
1992 printf (_("\nstart address 0x"));
1993 printf_vma (abfd
->start_address
);
1998 dump_bfd_private_header (abfd
)
2001 bfd_print_private_bfd_data (abfd
, stdout
);
2010 if (!bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2012 bfd_nonfatal (bfd_get_filename (abfd
));
2013 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2015 list_matching_formats (matching
);
2021 /* If we are adjusting section VMA's, change them all now. Changing
2022 the BFD information is a hack. However, we must do it, or
2023 bfd_find_nearest_line will not do the right thing. */
2024 if (adjust_section_vma
!= 0)
2028 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2030 s
->vma
+= adjust_section_vma
;
2031 s
->lma
+= adjust_section_vma
;
2035 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2038 print_arelt_descr (stdout
, abfd
, true);
2039 if (dump_file_header
)
2040 dump_bfd_header (abfd
);
2041 if (dump_private_headers
)
2042 dump_bfd_private_header (abfd
);
2044 if (dump_section_headers
)
2045 dump_headers (abfd
);
2046 if (dump_symtab
|| dump_reloc_info
|| disassemble
|| dump_debugging
)
2048 syms
= slurp_symtab (abfd
);
2050 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
)
2052 dynsyms
= slurp_dynamic_symtab (abfd
);
2055 dump_symbols (abfd
, false);
2056 if (dump_dynamic_symtab
)
2057 dump_symbols (abfd
, true);
2058 if (dump_stab_section_info
)
2060 if (dump_reloc_info
&& ! disassemble
)
2062 if (dump_dynamic_reloc_info
)
2063 dump_dynamic_relocs (abfd
);
2064 if (dump_section_contents
)
2067 disassemble_data (abfd
);
2072 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2073 if (dhandle
!= NULL
)
2075 if (! print_debugging_info (stdout
, dhandle
))
2076 fprintf (stderr
, _("%s: printing debugging information failed\n"),
2077 bfd_get_filename (abfd
));
2093 display_file (filename
, target
)
2097 bfd
*file
, *arfile
= (bfd
*) NULL
;
2099 file
= bfd_openr (filename
, target
);
2102 bfd_nonfatal (filename
);
2106 if (bfd_check_format (file
, bfd_archive
) == true)
2108 bfd
*last_arfile
= NULL
;
2110 printf (_("In archive %s:\n"), bfd_get_filename (file
));
2113 bfd_set_error (bfd_error_no_error
);
2115 arfile
= bfd_openr_next_archived_file (file
, arfile
);
2118 if (bfd_get_error () != bfd_error_no_more_archived_files
)
2120 bfd_nonfatal (bfd_get_filename (file
));
2125 display_bfd (arfile
);
2127 if (last_arfile
!= NULL
)
2128 bfd_close (last_arfile
);
2129 last_arfile
= arfile
;
2132 if (last_arfile
!= NULL
)
2133 bfd_close (last_arfile
);
2141 /* Actually display the various requested regions */
2149 bfd_size_type datasize
= 0;
2151 bfd_size_type start
, stop
;
2153 for (section
= abfd
->sections
; section
!= NULL
; section
=
2158 if (only
== (char *) NULL
||
2159 strcmp (only
, section
->name
) == 0)
2161 if (section
->flags
& SEC_HAS_CONTENTS
)
2163 printf (_("Contents of section %s:\n"), section
->name
);
2165 if (bfd_section_size (abfd
, section
) == 0)
2167 data
= (bfd_byte
*) xmalloc ((size_t) bfd_section_size (abfd
, section
));
2168 datasize
= bfd_section_size (abfd
, section
);
2171 bfd_get_section_contents (abfd
, section
, (PTR
) data
, 0, bfd_section_size (abfd
, section
));
2173 if (start_address
== (bfd_vma
) -1
2174 || start_address
< section
->vma
)
2177 start
= start_address
- section
->vma
;
2178 if (stop_address
== (bfd_vma
) -1)
2179 stop
= bfd_section_size (abfd
, section
);
2182 if (stop_address
< section
->vma
)
2185 stop
= stop_address
- section
->vma
;
2186 if (stop
> bfd_section_size (abfd
, section
))
2187 stop
= bfd_section_size (abfd
, section
);
2189 for (i
= start
; i
< stop
; i
+= onaline
)
2193 printf (" %04lx ", (unsigned long int) (i
+ section
->vma
));
2194 for (j
= i
; j
< i
+ onaline
; j
++)
2197 printf ("%02x", (unsigned) (data
[j
]));
2205 for (j
= i
; j
< i
+ onaline
; j
++)
2210 printf ("%c", isprint (data
[j
]) ? data
[j
] : '.');
2220 /* Should perhaps share code and display with nm? */
2222 dump_symbols (abfd
, dynamic
)
2236 printf ("DYNAMIC SYMBOL TABLE:\n");
2244 printf ("SYMBOL TABLE:\n");
2247 for (count
= 0; count
< max
; count
++)
2251 bfd
*cur_bfd
= bfd_asymbol_bfd (*current
);
2253 if (cur_bfd
!= NULL
)
2258 name
= bfd_asymbol_name (*current
);
2260 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2264 /* If we want to demangle the name, we demangle it
2265 here, and temporarily clobber it while calling
2266 bfd_print_symbol. FIXME: This is a gross hack. */
2269 if (bfd_get_symbol_leading_char (cur_bfd
) == *n
)
2271 alloc
= cplus_demangle (n
, DMGL_ANSI
| DMGL_PARAMS
);
2273 (*current
)->name
= alloc
;
2275 (*current
)->name
= n
;
2278 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2279 bfd_print_symbol_all
);
2281 (*current
)->name
= name
;
2302 for (a
= abfd
->sections
; a
!= (asection
*) NULL
; a
= a
->next
)
2306 if (bfd_is_abs_section (a
))
2308 if (bfd_is_und_section (a
))
2310 if (bfd_is_com_section (a
))
2315 if (strcmp (only
, a
->name
))
2318 else if ((a
->flags
& SEC_RELOC
) == 0)
2321 relsize
= bfd_get_reloc_upper_bound (abfd
, a
);
2323 bfd_fatal (bfd_get_filename (abfd
));
2325 printf ("RELOCATION RECORDS FOR [%s]:", a
->name
);
2329 printf (" (none)\n\n");
2333 relpp
= (arelent
**) xmalloc (relsize
);
2334 relcount
= bfd_canonicalize_reloc (abfd
, a
, relpp
, syms
);
2336 bfd_fatal (bfd_get_filename (abfd
));
2337 else if (relcount
== 0)
2339 printf (" (none)\n\n");
2344 dump_reloc_set (abfd
, a
, relpp
, relcount
);
2353 dump_dynamic_relocs (abfd
)
2360 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2362 bfd_fatal (bfd_get_filename (abfd
));
2364 printf ("DYNAMIC RELOCATION RECORDS");
2368 printf (" (none)\n\n");
2372 relpp
= (arelent
**) xmalloc (relsize
);
2373 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2375 bfd_fatal (bfd_get_filename (abfd
));
2376 else if (relcount
== 0)
2378 printf (" (none)\n\n");
2383 dump_reloc_set (abfd
, (asection
*) NULL
, relpp
, relcount
);
2391 dump_reloc_set (abfd
, sec
, relpp
, relcount
)
2398 char *last_filename
, *last_functionname
;
2399 unsigned int last_line
;
2401 /* Get column headers lined up reasonably. */
2407 sprintf_vma (buf
, (bfd_vma
) -1);
2408 width
= strlen (buf
) - 7;
2410 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2413 last_filename
= NULL
;
2414 last_functionname
= NULL
;
2417 for (p
= relpp
; relcount
&& *p
!= (arelent
*) NULL
; p
++, relcount
--)
2420 const char *filename
, *functionname
;
2422 const char *sym_name
;
2423 const char *section_name
;
2425 if (start_address
!= (bfd_vma
) -1
2426 && q
->address
< start_address
)
2428 if (stop_address
!= (bfd_vma
) -1
2429 && q
->address
> stop_address
)
2432 if (with_line_numbers
2434 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2435 &filename
, &functionname
, &line
))
2437 if (functionname
!= NULL
2438 && (last_functionname
== NULL
2439 || strcmp (functionname
, last_functionname
) != 0))
2441 printf ("%s():\n", functionname
);
2442 if (last_functionname
!= NULL
)
2443 free (last_functionname
);
2444 last_functionname
= xstrdup (functionname
);
2447 && (line
!= last_line
2448 || (filename
!= NULL
2449 && last_filename
!= NULL
2450 && strcmp (filename
, last_filename
) != 0)))
2452 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2454 if (last_filename
!= NULL
)
2455 free (last_filename
);
2456 if (filename
== NULL
)
2457 last_filename
= NULL
;
2459 last_filename
= xstrdup (filename
);
2463 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2465 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2466 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2471 section_name
= NULL
;
2475 printf_vma (q
->address
);
2477 printf (" %-16s ", q
->howto
->name
);
2479 printf (" %-16d ", q
->howto
->type
);
2480 objdump_print_symname (abfd
, (struct disassemble_info
*) NULL
,
2485 if (section_name
== (CONST
char *) NULL
)
2486 section_name
= "*unknown*";
2487 printf_vma (q
->address
);
2488 printf (" %-16s [%s]",
2495 printf_vma (q
->addend
);
2501 /* The length of the longest architecture name + 1. */
2502 #define LONGEST_ARCH sizeof("rs6000:6000")
2505 endian_string (endian
)
2506 enum bfd_endian endian
;
2508 if (endian
== BFD_ENDIAN_BIG
)
2509 return "big endian";
2510 else if (endian
== BFD_ENDIAN_LITTLE
)
2511 return "little endian";
2513 return "endianness unknown";
2516 /* List the targets that BFD is configured to support, each followed
2517 by its endianness and the architectures it supports. */
2520 display_target_list ()
2522 extern bfd_target
*bfd_target_vector
[];
2526 dummy_name
= choose_temp_base ();
2527 for (t
= 0; bfd_target_vector
[t
]; t
++)
2529 bfd_target
*p
= bfd_target_vector
[t
];
2530 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2533 printf ("%s\n (header %s, data %s)\n", p
->name
,
2534 endian_string (p
->header_byteorder
),
2535 endian_string (p
->byteorder
));
2539 bfd_nonfatal (dummy_name
);
2543 if (! bfd_set_format (abfd
, bfd_object
))
2545 if (bfd_get_error () != bfd_error_invalid_operation
)
2546 bfd_nonfatal (p
->name
);
2550 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2551 if (bfd_set_arch_mach (abfd
, (enum bfd_architecture
) a
, 0))
2553 bfd_printable_arch_mach ((enum bfd_architecture
) a
, 0));
2555 unlink (dummy_name
);
2559 /* Print a table showing which architectures are supported for entries
2560 FIRST through LAST-1 of bfd_target_vector (targets across,
2561 architectures down). */
2564 display_info_table (first
, last
)
2568 extern bfd_target
*bfd_target_vector
[];
2572 /* Print heading of target names. */
2573 printf ("\n%*s", (int) LONGEST_ARCH
, " ");
2574 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2575 printf ("%s ", bfd_target_vector
[t
]->name
);
2578 dummy_name
= choose_temp_base ();
2579 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2580 if (strcmp (bfd_printable_arch_mach (a
, 0), "UNKNOWN!") != 0)
2582 printf ("%*s ", (int) LONGEST_ARCH
- 1,
2583 bfd_printable_arch_mach (a
, 0));
2584 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2586 bfd_target
*p
= bfd_target_vector
[t
];
2588 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2592 bfd_nonfatal (p
->name
);
2598 if (! bfd_set_format (abfd
, bfd_object
))
2600 if (bfd_get_error () != bfd_error_invalid_operation
)
2601 bfd_nonfatal (p
->name
);
2608 if (! bfd_set_arch_mach (abfd
, a
, 0))
2613 printf ("%s ", p
->name
);
2616 int l
= strlen (p
->name
);
2624 unlink (dummy_name
);
2628 /* Print tables of all the target-architecture combinations that
2629 BFD has been configured to support. */
2632 display_target_tables ()
2635 extern bfd_target
*bfd_target_vector
[];
2639 colum
= getenv ("COLUMNS");
2641 columns
= atoi (colum
);
2646 while (bfd_target_vector
[t
] != NULL
)
2650 wid
= LONGEST_ARCH
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2652 while (wid
< columns
&& bfd_target_vector
[t
] != NULL
)
2656 newwid
= wid
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2657 if (newwid
>= columns
)
2662 display_info_table (oldt
, t
);
2669 printf (_("BFD header file version %s\n"), BFD_VERSION
);
2670 display_target_list ();
2671 display_target_tables ();
2680 char *target
= default_target
;
2681 boolean seenflag
= false;
2683 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
2684 setlocale (LC_MESSAGES
, "");
2686 bindtextdomain (PACKAGE
, LOCALEDIR
);
2687 textdomain (PACKAGE
);
2689 program_name
= *argv
;
2690 xmalloc_set_program_name (program_name
);
2692 START_PROGRESS (program_name
, 0);
2695 set_default_bfd_target ();
2697 while ((c
= getopt_long (argc
, argv
, "pib:m:VCdDlfahrRtTxsSj:wE:",
2698 long_options
, (int *) 0))
2701 if (c
!= 'l' && c
!= OPTION_START_ADDRESS
&& c
!= OPTION_STOP_ADDRESS
)
2706 break; /* we've been given a long option */
2714 with_line_numbers
= 1;
2720 dump_file_header
= true;
2723 formats_info
= true;
2726 dump_private_headers
= 1;
2729 dump_private_headers
= 1;
2731 dump_reloc_info
= 1;
2732 dump_file_header
= true;
2734 dump_section_headers
= 1;
2740 dump_dynamic_symtab
= 1;
2749 disassemble
= disassemble_all
= true;
2753 with_source_code
= true;
2756 dump_section_contents
= 1;
2759 dump_reloc_info
= 1;
2762 dump_dynamic_reloc_info
= 1;
2768 dump_section_headers
= 1;
2778 case OPTION_ADJUST_VMA
:
2779 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
2781 case OPTION_START_ADDRESS
:
2782 start_address
= parse_vma (optarg
, "--start-address");
2784 case OPTION_STOP_ADDRESS
:
2785 stop_address
= parse_vma (optarg
, "--stop-address");
2788 if (strcmp (optarg
, "B") == 0)
2789 endian
= BFD_ENDIAN_BIG
;
2790 else if (strcmp (optarg
, "L") == 0)
2791 endian
= BFD_ENDIAN_LITTLE
;
2794 fprintf (stderr
, _("%s: unrecognized -E option\n"), program_name
);
2799 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
2800 endian
= BFD_ENDIAN_BIG
;
2801 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
2802 endian
= BFD_ENDIAN_LITTLE
;
2805 fprintf (stderr
, _("%s: unrecognized --endian type `%s'\n"),
2806 program_name
, optarg
);
2816 print_version ("objdump");
2818 if (seenflag
== false)
2828 display_file ("a.out", target
);
2830 for (; optind
< argc
;)
2831 display_file (argv
[optind
++], target
);
2834 END_PROGRESS (program_name
);