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 /* Target specific options to the disassembler. */
87 static char *disassembler_options
= (char *) NULL
;
89 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
90 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
92 /* The symbol table. */
93 static asymbol
**syms
;
95 /* Number of symbols in `syms'. */
96 static long symcount
= 0;
98 /* The sorted symbol table. */
99 static asymbol
**sorted_syms
;
101 /* Number of symbols in `sorted_syms'. */
102 static long sorted_symcount
= 0;
104 /* The dynamic symbol table. */
105 static asymbol
**dynsyms
;
107 /* Number of symbols in `dynsyms'. */
108 static long dynsymcount
= 0;
110 /* Static declarations. */
113 usage
PARAMS ((FILE *, int));
116 display_file
PARAMS ((char *filename
, char *target
));
119 dump_section_header
PARAMS ((bfd
*, asection
*, PTR
));
122 dump_headers
PARAMS ((bfd
*));
125 dump_data
PARAMS ((bfd
*abfd
));
128 dump_relocs
PARAMS ((bfd
*abfd
));
131 dump_dynamic_relocs
PARAMS ((bfd
* abfd
));
134 dump_reloc_set
PARAMS ((bfd
*, asection
*, arelent
**, long));
137 dump_symbols
PARAMS ((bfd
*abfd
, boolean dynamic
));
140 dump_bfd_header
PARAMS ((bfd
*));
143 dump_bfd_private_header
PARAMS ((bfd
*));
146 display_bfd
PARAMS ((bfd
*abfd
));
149 display_target_list
PARAMS ((void));
152 display_info_table
PARAMS ((int, int));
155 display_target_tables
PARAMS ((void));
158 display_info
PARAMS ((void));
161 objdump_print_value
PARAMS ((bfd_vma
, struct disassemble_info
*, boolean
));
164 objdump_print_symname
PARAMS ((bfd
*, struct disassemble_info
*, asymbol
*));
167 find_symbol_for_address
PARAMS ((bfd
*, asection
*, bfd_vma
, boolean
, long *));
170 objdump_print_addr_with_sym
PARAMS ((bfd
*, asection
*, asymbol
*, bfd_vma
,
171 struct disassemble_info
*, boolean
));
174 objdump_print_addr
PARAMS ((bfd_vma
, struct disassemble_info
*, boolean
));
177 objdump_print_address
PARAMS ((bfd_vma
, struct disassemble_info
*));
180 show_line
PARAMS ((bfd
*, asection
*, bfd_vma
));
183 disassemble_bytes
PARAMS ((struct disassemble_info
*, disassembler_ftype
,
184 boolean
, bfd_byte
*, bfd_vma
, bfd_vma
,
185 arelent
***, arelent
**));
188 disassemble_data
PARAMS ((bfd
*));
191 endian_string
PARAMS ((enum bfd_endian
));
194 slurp_symtab
PARAMS ((bfd
*));
197 slurp_dynamic_symtab
PARAMS ((bfd
*));
200 remove_useless_symbols
PARAMS ((asymbol
**, long));
203 compare_symbols
PARAMS ((const PTR
, const PTR
));
206 compare_relocs
PARAMS ((const PTR
, const PTR
));
209 dump_stabs
PARAMS ((bfd
*));
212 read_section_stabs
PARAMS ((bfd
*, const char *, const char *));
215 print_section_stabs
PARAMS ((bfd
*, const char *, const char *));
218 usage (stream
, status
)
222 fprintf (stream
, _("\
223 Usage: %s [-ahifCdDprRtTxsSlw] [-b bfdname] [-m machine] \n\
224 [-j section-name] [-M disassembler-options]\n\
225 [--archive-headers] [--target=bfdname] [--debugging] [--disassemble]\n\
226 [--disassemble-all] [--disassemble-zeroes] [--file-headers]\n\
227 [--section-headers] [--headers]\n\
228 [--info] [--section=section-name] [--line-numbers] [--source]\n"),
230 fprintf (stream
, _("\
231 [--architecture=machine] [--reloc] [--full-contents] [--stabs]\n\
232 [--syms] [--all-headers] [--dynamic-syms] [--dynamic-reloc]\n\
233 [--wide] [--version] [--help] [--private-headers]\n\
234 [--start-address=addr] [--stop-address=addr]\n\
235 [--prefix-addresses] [--[no-]show-raw-insn] [--demangle]\n\
236 [--adjust-vma=offset] [-EB|-EL] [--endian={big|little}] objfile...\n\
237 at least one option besides -l (--line-numbers) must be given\n"));
238 list_supported_targets (program_name
, stream
);
240 fprintf (stream
, _("Report bugs to bug-gnu-utils@gnu.org\n"));
244 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
246 #define OPTION_ENDIAN (150)
247 #define OPTION_START_ADDRESS (OPTION_ENDIAN + 1)
248 #define OPTION_STOP_ADDRESS (OPTION_START_ADDRESS + 1)
249 #define OPTION_ADJUST_VMA (OPTION_STOP_ADDRESS + 1)
251 static struct option long_options
[]=
253 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
254 {"all-headers", no_argument
, NULL
, 'x'},
255 {"private-headers", no_argument
, NULL
, 'p'},
256 {"architecture", required_argument
, NULL
, 'm'},
257 {"archive-headers", no_argument
, NULL
, 'a'},
258 {"debugging", no_argument
, &dump_debugging
, 1},
259 {"demangle", no_argument
, &do_demangle
, 1},
260 {"disassemble", no_argument
, NULL
, 'd'},
261 {"disassemble-all", no_argument
, NULL
, 'D'},
262 {"disassembler-options", required_argument
, NULL
, 'M'},
263 {"disassemble-zeroes", no_argument
, &disassemble_zeroes
, 1},
264 {"dynamic-reloc", no_argument
, NULL
, 'R'},
265 {"dynamic-syms", no_argument
, NULL
, 'T'},
266 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
267 {"file-headers", no_argument
, NULL
, 'f'},
268 {"full-contents", no_argument
, NULL
, 's'},
269 {"headers", no_argument
, NULL
, 'h'},
270 {"help", no_argument
, NULL
, 'H'},
271 {"info", no_argument
, NULL
, 'i'},
272 {"line-numbers", no_argument
, NULL
, 'l'},
273 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
274 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
275 {"reloc", no_argument
, NULL
, 'r'},
276 {"section", required_argument
, NULL
, 'j'},
277 {"section-headers", no_argument
, NULL
, 'h'},
278 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
279 {"source", no_argument
, NULL
, 'S'},
280 {"stabs", no_argument
, &dump_stab_section_info
, 1},
281 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
282 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
283 {"syms", no_argument
, NULL
, 't'},
284 {"target", required_argument
, NULL
, 'b'},
285 {"version", no_argument
, &show_version
, 1},
286 {"wide", no_argument
, &wide_output
, 'w'},
287 {0, no_argument
, 0, 0}
291 dump_section_header (abfd
, section
, ignored
)
292 bfd
*abfd ATTRIBUTE_UNUSED
;
294 PTR ignored ATTRIBUTE_UNUSED
;
298 printf ("%3d %-13s %08lx ", section
->index
,
299 bfd_get_section_name (abfd
, section
),
300 (unsigned long) bfd_section_size (abfd
, section
));
301 printf_vma (bfd_get_section_vma (abfd
, section
));
303 printf_vma (section
->lma
);
304 printf (" %08lx 2**%u", section
->filepos
,
305 bfd_get_section_alignment (abfd
, section
));
311 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
313 PF (SEC_HAS_CONTENTS
, "CONTENTS");
314 PF (SEC_ALLOC
, "ALLOC");
315 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
316 PF (SEC_CONSTRUCTOR_TEXT
, "CONSTRUCTOR TEXT");
317 PF (SEC_CONSTRUCTOR_DATA
, "CONSTRUCTOR DATA");
318 PF (SEC_CONSTRUCTOR_BSS
, "CONSTRUCTOR BSS");
319 PF (SEC_LOAD
, "LOAD");
320 PF (SEC_RELOC
, "RELOC");
322 PF (SEC_BALIGN
, "BALIGN");
324 PF (SEC_READONLY
, "READONLY");
325 PF (SEC_CODE
, "CODE");
326 PF (SEC_DATA
, "DATA");
328 PF (SEC_DEBUGGING
, "DEBUGGING");
329 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
330 PF (SEC_EXCLUDE
, "EXCLUDE");
331 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
332 PF (SEC_SMALL_DATA
, "SMALL_DATA");
333 PF (SEC_SHARED
, "SHARED");
335 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
339 switch (section
->flags
& SEC_LINK_DUPLICATES
)
343 case SEC_LINK_DUPLICATES_DISCARD
:
344 ls
= "LINK_ONCE_DISCARD";
346 case SEC_LINK_DUPLICATES_ONE_ONLY
:
347 ls
= "LINK_ONCE_ONE_ONLY";
349 case SEC_LINK_DUPLICATES_SAME_SIZE
:
350 ls
= "LINK_ONCE_SAME_SIZE";
352 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
353 ls
= "LINK_ONCE_SAME_CONTENTS";
356 printf ("%s%s", comma
, ls
);
368 printf (_("Sections:\n"));
370 printf (_("Idx Name Size VMA LMA File off Algn\n"));
372 printf (_("Idx Name Size VMA LMA File off Algn\n"));
374 bfd_map_over_sections (abfd
, dump_section_header
, (PTR
) NULL
);
381 asymbol
**sy
= (asymbol
**) NULL
;
384 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
386 fprintf (stderr
, _("%s: no symbols\n"), bfd_get_filename (abfd
));
391 storage
= bfd_get_symtab_upper_bound (abfd
);
393 bfd_fatal (bfd_get_filename (abfd
));
397 sy
= (asymbol
**) xmalloc (storage
);
399 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
401 bfd_fatal (bfd_get_filename (abfd
));
403 fprintf (stderr
, _("%s: no symbols\n"), bfd_get_filename (abfd
));
407 /* Read in the dynamic symbols. */
410 slurp_dynamic_symtab (abfd
)
413 asymbol
**sy
= (asymbol
**) NULL
;
416 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
419 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
421 fprintf (stderr
, _("%s: %s: not a dynamic object\n"),
422 program_name
, bfd_get_filename (abfd
));
427 bfd_fatal (bfd_get_filename (abfd
));
432 sy
= (asymbol
**) xmalloc (storage
);
434 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
436 bfd_fatal (bfd_get_filename (abfd
));
437 if (dynsymcount
== 0)
438 fprintf (stderr
, _("%s: %s: No dynamic symbols\n"),
439 program_name
, bfd_get_filename (abfd
));
443 /* Filter out (in place) symbols that are useless for disassembly.
444 COUNT is the number of elements in SYMBOLS.
445 Return the number of useful symbols. */
448 remove_useless_symbols (symbols
, count
)
452 register asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
456 asymbol
*sym
= *in_ptr
++;
458 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
460 if (sym
->flags
& (BSF_DEBUGGING
))
462 if (bfd_is_und_section (sym
->section
)
463 || bfd_is_com_section (sym
->section
))
468 return out_ptr
- symbols
;
471 /* Sort symbols into value order. */
474 compare_symbols (ap
, bp
)
478 const asymbol
*a
= *(const asymbol
**)ap
;
479 const asymbol
*b
= *(const asymbol
**)bp
;
483 flagword aflags
, bflags
;
485 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
487 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
490 if (a
->section
> b
->section
)
492 else if (a
->section
< b
->section
)
495 an
= bfd_asymbol_name (a
);
496 bn
= bfd_asymbol_name (b
);
500 /* The symbols gnu_compiled and gcc2_compiled convey no real
501 information, so put them after other symbols with the same value. */
503 af
= (strstr (an
, "gnu_compiled") != NULL
504 || strstr (an
, "gcc2_compiled") != NULL
);
505 bf
= (strstr (bn
, "gnu_compiled") != NULL
506 || strstr (bn
, "gcc2_compiled") != NULL
);
513 /* We use a heuristic for the file name, to try to sort it after
514 more useful symbols. It may not work on non Unix systems, but it
515 doesn't really matter; the only difference is precisely which
516 symbol names get printed. */
518 #define file_symbol(s, sn, snl) \
519 (((s)->flags & BSF_FILE) != 0 \
520 || ((sn)[(snl) - 2] == '.' \
521 && ((sn)[(snl) - 1] == 'o' \
522 || (sn)[(snl) - 1] == 'a')))
524 af
= file_symbol (a
, an
, anl
);
525 bf
= file_symbol (b
, bn
, bnl
);
532 /* Try to sort global symbols before local symbols before function
533 symbols before debugging symbols. */
538 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
540 if ((aflags
& BSF_DEBUGGING
) != 0)
545 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
547 if ((aflags
& BSF_FUNCTION
) != 0)
552 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
554 if ((aflags
& BSF_LOCAL
) != 0)
559 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
561 if ((aflags
& BSF_GLOBAL
) != 0)
567 /* Symbols that start with '.' might be section names, so sort them
568 after symbols that don't start with '.'. */
569 if (an
[0] == '.' && bn
[0] != '.')
571 if (an
[0] != '.' && bn
[0] == '.')
574 /* Finally, if we can't distinguish them in any other way, try to
575 get consistent results by sorting the symbols by name. */
576 return strcmp (an
, bn
);
579 /* Sort relocs into address order. */
582 compare_relocs (ap
, bp
)
586 const arelent
*a
= *(const arelent
**)ap
;
587 const arelent
*b
= *(const arelent
**)bp
;
589 if (a
->address
> b
->address
)
591 else if (a
->address
< b
->address
)
594 /* So that associated relocations tied to the same address show up
595 in the correct order, we don't do any further sorting. */
604 /* Print VMA to STREAM. If SKIP_ZEROES is true, omit leading zeroes. */
607 objdump_print_value (vma
, info
, skip_zeroes
)
609 struct disassemble_info
*info
;
615 sprintf_vma (buf
, vma
);
620 for (p
= buf
; *p
== '0'; ++p
)
625 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
628 /* Print the name of a symbol. */
631 objdump_print_symname (abfd
, info
, sym
)
633 struct disassemble_info
*info
;
641 name
= bfd_asymbol_name (sym
);
642 if (! do_demangle
|| name
[0] == '\0')
646 /* Demangle the name. */
647 if (bfd_get_symbol_leading_char (abfd
) == name
[0])
650 alloc
= cplus_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
658 (*info
->fprintf_func
) (info
->stream
, "%s", print
);
660 printf ("%s", print
);
666 /* Locate a symbol given a bfd, a section, and a VMA. If REQUIRE_SEC
667 is true, then always require the symbol to be in the section. This
668 returns NULL if there is no suitable symbol. If PLACE is not NULL,
669 then *PLACE is set to the index of the symbol in sorted_syms. */
672 find_symbol_for_address (abfd
, sec
, vma
, require_sec
, place
)
679 /* @@ Would it speed things up to cache the last two symbols returned,
680 and maybe their address ranges? For many processors, only one memory
681 operand can be present at a time, so the 2-entry cache wouldn't be
682 constantly churned by code doing heavy memory accesses. */
684 /* Indices in `sorted_syms'. */
686 long max
= sorted_symcount
;
689 if (sorted_symcount
< 1)
692 /* Perform a binary search looking for the closest symbol to the
693 required value. We are searching the range (min, max]. */
694 while (min
+ 1 < max
)
698 thisplace
= (max
+ min
) / 2;
699 sym
= sorted_syms
[thisplace
];
701 if (bfd_asymbol_value (sym
) > vma
)
703 else if (bfd_asymbol_value (sym
) < vma
)
712 /* The symbol we want is now in min, the low end of the range we
713 were searching. If there are several symbols with the same
714 value, we want the first one. */
717 && (bfd_asymbol_value (sorted_syms
[thisplace
])
718 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
721 /* If the file is relocateable, and the symbol could be from this
722 section, prefer a symbol from this section over symbols from
723 others, even if the other symbol's value might be closer.
725 Note that this may be wrong for some symbol references if the
726 sections have overlapping memory ranges, but in that case there's
727 no way to tell what's desired without looking at the relocation
730 if (sorted_syms
[thisplace
]->section
!= sec
732 || ((abfd
->flags
& HAS_RELOC
) != 0
733 && vma
>= bfd_get_section_vma (abfd
, sec
)
734 && vma
< (bfd_get_section_vma (abfd
, sec
)
735 + bfd_section_size (abfd
, sec
)))))
739 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
741 if (bfd_asymbol_value (sorted_syms
[i
])
742 != bfd_asymbol_value (sorted_syms
[thisplace
]))
748 if (sorted_syms
[i
]->section
== sec
750 || sorted_syms
[i
- 1]->section
!= sec
751 || (bfd_asymbol_value (sorted_syms
[i
])
752 != bfd_asymbol_value (sorted_syms
[i
- 1]))))
759 if (sorted_syms
[thisplace
]->section
!= sec
)
761 /* We didn't find a good symbol with a smaller value.
762 Look for one with a larger value. */
763 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
765 if (sorted_syms
[i
]->section
== sec
)
773 if (sorted_syms
[thisplace
]->section
!= sec
775 || ((abfd
->flags
& HAS_RELOC
) != 0
776 && vma
>= bfd_get_section_vma (abfd
, sec
)
777 && vma
< (bfd_get_section_vma (abfd
, sec
)
778 + bfd_section_size (abfd
, sec
)))))
780 /* There is no suitable symbol. */
788 return sorted_syms
[thisplace
];
791 /* Print an address to INFO symbolically. */
794 objdump_print_addr_with_sym (abfd
, sec
, sym
, vma
, info
, skip_zeroes
)
799 struct disassemble_info
*info
;
802 objdump_print_value (vma
, info
, skip_zeroes
);
808 (*info
->fprintf_func
) (info
->stream
, " <%s",
809 bfd_get_section_name (abfd
, sec
));
810 secaddr
= bfd_get_section_vma (abfd
, sec
);
813 (*info
->fprintf_func
) (info
->stream
, "-0x");
814 objdump_print_value (secaddr
- vma
, info
, true);
816 else if (vma
> secaddr
)
818 (*info
->fprintf_func
) (info
->stream
, "+0x");
819 objdump_print_value (vma
- secaddr
, info
, true);
821 (*info
->fprintf_func
) (info
->stream
, ">");
825 (*info
->fprintf_func
) (info
->stream
, " <");
826 objdump_print_symname (abfd
, info
, sym
);
827 if (bfd_asymbol_value (sym
) > vma
)
829 (*info
->fprintf_func
) (info
->stream
, "-0x");
830 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, true);
832 else if (vma
> bfd_asymbol_value (sym
))
834 (*info
->fprintf_func
) (info
->stream
, "+0x");
835 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, true);
837 (*info
->fprintf_func
) (info
->stream
, ">");
841 /* Print VMA to INFO, symbolically if possible. If SKIP_ZEROES is
842 true, don't output leading zeroes. */
845 objdump_print_addr (vma
, info
, skip_zeroes
)
847 struct disassemble_info
*info
;
850 struct objdump_disasm_info
*aux
;
853 if (sorted_symcount
< 1)
855 (*info
->fprintf_func
) (info
->stream
, "0x");
856 objdump_print_value (vma
, info
, skip_zeroes
);
860 aux
= (struct objdump_disasm_info
*) info
->application_data
;
861 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
863 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
867 /* Print VMA to INFO. This function is passed to the disassembler
871 objdump_print_address (vma
, info
)
873 struct disassemble_info
*info
;
875 objdump_print_addr (vma
, info
, ! prefix_addresses
);
878 /* Determine of the given address has a symbol associated with it. */
881 objdump_symbol_at_address (vma
, info
)
883 struct disassemble_info
* info
;
885 struct objdump_disasm_info
* aux
;
888 /* No symbols - do not bother checking. */
889 if (sorted_symcount
< 1)
892 aux
= (struct objdump_disasm_info
*) info
->application_data
;
893 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
896 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
899 /* Hold the last function name and the last line number we displayed
902 static char *prev_functionname
;
903 static unsigned int prev_line
;
905 /* We keep a list of all files that we have seen when doing a
906 dissassembly with source, so that we know how much of the file to
907 display. This can be important for inlined functions. */
909 struct print_file_list
911 struct print_file_list
*next
;
917 static struct print_file_list
*print_files
;
919 /* The number of preceding context lines to show when we start
920 displaying a file for the first time. */
922 #define SHOW_PRECEDING_CONTEXT_LINES (5)
924 /* Skip ahead to a given line in a file, optionally printing each
928 skip_to_line
PARAMS ((struct print_file_list
*, unsigned int, boolean
));
931 skip_to_line (p
, line
, show
)
932 struct print_file_list
*p
;
936 while (p
->line
< line
)
940 if (fgets (buf
, sizeof buf
, p
->f
) == NULL
)
950 if (strchr (buf
, '\n') != NULL
)
955 /* Show the line number, or the source line, in a dissassembly
959 show_line (abfd
, section
, off
)
964 CONST
char *filename
;
965 CONST
char *functionname
;
968 if (! with_line_numbers
&& ! with_source_code
)
971 if (! bfd_find_nearest_line (abfd
, section
, syms
, off
, &filename
,
972 &functionname
, &line
))
975 if (filename
!= NULL
&& *filename
== '\0')
977 if (functionname
!= NULL
&& *functionname
== '\0')
980 if (with_line_numbers
)
982 if (functionname
!= NULL
983 && (prev_functionname
== NULL
984 || strcmp (functionname
, prev_functionname
) != 0))
985 printf ("%s():\n", functionname
);
986 if (line
> 0 && line
!= prev_line
)
987 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
994 struct print_file_list
**pp
, *p
;
996 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
997 if (strcmp ((*pp
)->filename
, filename
) == 0)
1003 if (p
!= print_files
)
1007 /* We have reencountered a file name which we saw
1008 earlier. This implies that either we are dumping out
1009 code from an included file, or the same file was
1010 linked in more than once. There are two common cases
1011 of an included file: inline functions in a header
1012 file, and a bison or flex skeleton file. In the
1013 former case we want to just start printing (but we
1014 back up a few lines to give context); in the latter
1015 case we want to continue from where we left off. I
1016 can't think of a good way to distinguish the cases,
1017 so I used a heuristic based on the file name. */
1018 if (strcmp (p
->filename
+ strlen (p
->filename
) - 2, ".h") != 0)
1022 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1029 p
->f
= fopen (p
->filename
, "r");
1033 skip_to_line (p
, l
, false);
1035 if (print_files
->f
!= NULL
)
1037 fclose (print_files
->f
);
1038 print_files
->f
= NULL
;
1044 skip_to_line (p
, line
, true);
1046 p
->next
= print_files
;
1054 f
= fopen (filename
, "r");
1059 p
= ((struct print_file_list
*)
1060 xmalloc (sizeof (struct print_file_list
)));
1061 p
->filename
= xmalloc (strlen (filename
) + 1);
1062 strcpy (p
->filename
, filename
);
1066 if (print_files
!= NULL
&& print_files
->f
!= NULL
)
1068 fclose (print_files
->f
);
1069 print_files
->f
= NULL
;
1071 p
->next
= print_files
;
1074 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1077 skip_to_line (p
, l
, false);
1079 skip_to_line (p
, line
, true);
1084 if (functionname
!= NULL
1085 && (prev_functionname
== NULL
1086 || strcmp (functionname
, prev_functionname
) != 0))
1088 if (prev_functionname
!= NULL
)
1089 free (prev_functionname
);
1090 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1091 strcpy (prev_functionname
, functionname
);
1094 if (line
> 0 && line
!= prev_line
)
1098 /* Pseudo FILE object for strings. */
1106 /* sprintf to a "stream" */
1109 #ifdef ANSI_PROTOTYPES
1110 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1112 objdump_sprintf (va_alist
)
1116 #ifndef ANSI_PROTOTYPES
1124 #ifdef ANSI_PROTOTYPES
1125 va_start (args
, format
);
1128 f
= va_arg (args
, SFILE
*);
1129 format
= va_arg (args
, const char *);
1132 vasprintf (&buf
, format
, args
);
1138 fprintf (stderr
, _("Out of virtual memory\n"));
1144 while ((size_t) ((f
->buffer
+ f
->size
) - f
->current
) < n
+ 1)
1148 curroff
= f
->current
- f
->buffer
;
1150 f
->buffer
= xrealloc (f
->buffer
, f
->size
);
1151 f
->current
= f
->buffer
+ curroff
;
1154 memcpy (f
->current
, buf
, n
);
1156 f
->current
[0] = '\0';
1163 /* The number of zeroes we want to see before we start skipping them.
1164 The number is arbitrarily chosen. */
1166 #define SKIP_ZEROES (8)
1168 /* The number of zeroes to skip at the end of a section. If the
1169 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1170 SKIP_ZEROES, they will be disassembled. If there are fewer than
1171 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1172 attempt to avoid disassembling zeroes inserted by section
1175 #define SKIP_ZEROES_AT_END (3)
1177 /* Disassemble some data in memory between given values. */
1180 disassemble_bytes (info
, disassemble_fn
, insns
, data
, start
, stop
, relppp
,
1182 struct disassemble_info
*info
;
1183 disassembler_ftype disassemble_fn
;
1191 struct objdump_disasm_info
*aux
;
1195 int skip_addr_chars
;
1198 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1204 bytes_per_line
= 16;
1206 /* Figure out how many characters to skip at the start of an
1207 address, to make the disassembly look nicer. We discard leading
1208 zeroes in chunks of 4, ensuring that there is always a leading
1210 skip_addr_chars
= 0;
1211 if (! prefix_addresses
)
1217 section
->vma
+ bfd_section_size (section
->owner
, section
));
1219 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1222 skip_addr_chars
+= 4;
1227 info
->insn_info_valid
= 0;
1235 boolean need_nl
= false;
1237 /* If we see more than SKIP_ZEROES bytes of zeroes, we just
1239 for (z
= i
; z
< stop
; z
++)
1242 if (! disassemble_zeroes
1243 && (info
->insn_info_valid
== 0
1244 || info
->branch_delay_insns
== 0)
1245 && (z
- i
>= SKIP_ZEROES
1246 || (z
== stop
&& z
- i
< SKIP_ZEROES_AT_END
)))
1250 /* If there are more nonzero bytes to follow, we only skip
1251 zeroes in multiples of 4, to try to avoid running over
1252 the start of an instruction which happens to start with
1255 z
= i
+ ((z
- i
) &~ 3);
1268 if (with_line_numbers
|| with_source_code
)
1269 show_line (aux
->abfd
, section
, i
);
1271 if (! prefix_addresses
)
1275 sprintf_vma (buf
, section
->vma
+ i
);
1276 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1280 printf ("%s:\t", buf
+ skip_addr_chars
);
1284 aux
->require_sec
= true;
1285 objdump_print_address (section
->vma
+ i
, info
);
1286 aux
->require_sec
= false;
1293 sfile
.buffer
= xmalloc (sfile
.size
);
1294 sfile
.current
= sfile
.buffer
;
1295 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1296 info
->stream
= (FILE *) &sfile
;
1297 info
->bytes_per_line
= 0;
1298 info
->bytes_per_chunk
= 0;
1300 /* FIXME: This is wrong. It tests the number of bytes
1301 in the last instruction, not the current one. */
1302 if (*relppp
< relppend
1303 && (**relppp
)->address
>= i
1304 && (**relppp
)->address
< i
+ bytes
)
1305 info
->flags
= INSN_HAS_RELOC
;
1309 bytes
= (*disassemble_fn
) (section
->vma
+ i
, info
);
1310 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1311 info
->stream
= stdout
;
1312 if (info
->bytes_per_line
!= 0)
1313 bytes_per_line
= info
->bytes_per_line
;
1316 if (sfile
.current
!= sfile
.buffer
)
1317 printf ("%s\n", sfile
.buffer
);
1318 free (sfile
.buffer
);
1326 bytes
= bytes_per_line
;
1327 if (i
+ bytes
> stop
)
1330 for (j
= i
; j
< i
+ bytes
; ++j
)
1332 if (isprint (data
[j
]))
1333 buf
[j
- i
] = data
[j
];
1340 if (prefix_addresses
1342 : show_raw_insn
>= 0)
1346 /* If ! prefix_addresses and ! wide_output, we print
1347 bytes_per_line bytes per line. */
1349 if (pb
> bytes_per_line
&& ! prefix_addresses
&& ! wide_output
)
1350 pb
= bytes_per_line
;
1352 if (info
->bytes_per_chunk
)
1353 bpc
= info
->bytes_per_chunk
;
1357 for (j
= i
; j
< i
+ pb
; j
+= bpc
)
1360 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1362 for (k
= bpc
- 1; k
>= 0; k
--)
1363 printf ("%02x", (unsigned) data
[j
+ k
]);
1368 for (k
= 0; k
< bpc
; k
++)
1369 printf ("%02x", (unsigned) data
[j
+ k
]);
1374 for (; pb
< bytes_per_line
; pb
+= bpc
)
1378 for (k
= 0; k
< bpc
; k
++)
1383 /* Separate raw data from instruction by extra space. */
1394 printf ("%s", sfile
.buffer
);
1395 free (sfile
.buffer
);
1398 if (prefix_addresses
1400 : show_raw_insn
>= 0)
1410 sprintf_vma (buf
, section
->vma
+ j
);
1411 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1415 printf ("%s:\t", buf
+ skip_addr_chars
);
1417 pb
+= bytes_per_line
;
1420 for (; j
< i
+ pb
; j
+= bpc
)
1424 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1426 for (k
= bpc
- 1; k
>= 0; k
--)
1427 printf ("%02x", (unsigned) data
[j
+ k
]);
1432 for (k
= 0; k
< bpc
; k
++)
1433 printf ("%02x", (unsigned) data
[j
+ k
]);
1447 && (section
->flags
& SEC_RELOC
) != 0)
1449 while ((*relppp
) < relppend
1450 && ((**relppp
)->address
>= (bfd_vma
) i
1451 && (**relppp
)->address
< (bfd_vma
) i
+ bytes
))
1462 objdump_print_value (section
->vma
+ q
->address
, info
, true);
1464 printf (": %s\t", q
->howto
->name
);
1466 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1467 printf ("*unknown*");
1470 const char *sym_name
;
1472 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1473 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1474 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1479 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1480 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1481 if (sym_name
== NULL
|| *sym_name
== '\0')
1482 sym_name
= "*unknown*";
1483 printf ("%s", sym_name
);
1490 objdump_print_value (q
->addend
, info
, true);
1506 /* Disassemble the contents of an object file. */
1509 disassemble_data (abfd
)
1513 disassembler_ftype disassemble_fn
;
1514 struct disassemble_info disasm_info
;
1515 struct objdump_disasm_info aux
;
1519 prev_functionname
= NULL
;
1522 /* We make a copy of syms to sort. We don't want to sort syms
1523 because that will screw up the relocs. */
1524 sorted_syms
= (asymbol
**) xmalloc (symcount
* sizeof (asymbol
*));
1525 memcpy (sorted_syms
, syms
, symcount
* sizeof (asymbol
*));
1527 sorted_symcount
= remove_useless_symbols (sorted_syms
, symcount
);
1529 /* Sort the symbols into section and symbol order */
1530 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1532 INIT_DISASSEMBLE_INFO(disasm_info
, stdout
, fprintf
);
1533 disasm_info
.application_data
= (PTR
) &aux
;
1535 aux
.require_sec
= false;
1536 disasm_info
.print_address_func
= objdump_print_address
;
1537 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1539 if (machine
!= (char *) NULL
)
1541 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1544 fprintf (stderr
, _("%s: Can't use supplied machine %s\n"),
1549 abfd
->arch_info
= info
;
1552 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1554 struct bfd_target
*xvec
;
1556 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
1557 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1558 xvec
->byteorder
= endian
;
1562 disassemble_fn
= disassembler (abfd
);
1563 if (!disassemble_fn
)
1565 fprintf (stderr
, _("%s: Can't disassemble for architecture %s\n"),
1567 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1571 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1572 disasm_info
.arch
= bfd_get_arch (abfd
);
1573 disasm_info
.mach
= bfd_get_mach (abfd
);
1574 disasm_info
.disassembler_options
= disassembler_options
;
1576 if (bfd_big_endian (abfd
))
1577 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1578 else if (bfd_little_endian (abfd
))
1579 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1581 /* ??? Aborting here seems too drastic. We could default to big or little
1583 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1585 for (section
= abfd
->sections
;
1586 section
!= (asection
*) NULL
;
1587 section
= section
->next
)
1589 bfd_byte
*data
= NULL
;
1590 bfd_size_type datasize
= 0;
1591 arelent
**relbuf
= NULL
;
1592 arelent
**relpp
= NULL
;
1593 arelent
**relppend
= NULL
;
1595 asymbol
*sym
= NULL
;
1598 if ((section
->flags
& SEC_LOAD
) == 0
1599 || (! disassemble_all
1601 && (section
->flags
& SEC_CODE
) == 0))
1603 if (only
!= (char *) NULL
&& strcmp (only
, section
->name
) != 0)
1607 && (section
->flags
& SEC_RELOC
) != 0)
1611 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1613 bfd_fatal (bfd_get_filename (abfd
));
1619 relbuf
= (arelent
**) xmalloc (relsize
);
1620 relcount
= bfd_canonicalize_reloc (abfd
, section
, relbuf
, syms
);
1622 bfd_fatal (bfd_get_filename (abfd
));
1624 /* Sort the relocs by address. */
1625 qsort (relbuf
, relcount
, sizeof (arelent
*), compare_relocs
);
1628 relppend
= relpp
+ relcount
;
1630 /* Skip over the relocs belonging to addresses below the
1632 if (start_address
!= (bfd_vma
) -1)
1634 while (relpp
< relppend
1635 && (*relpp
)->address
< start_address
)
1641 printf (_("Disassembly of section %s:\n"), section
->name
);
1643 datasize
= bfd_get_section_size_before_reloc (section
);
1647 data
= (bfd_byte
*) xmalloc ((size_t) datasize
);
1649 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1652 disasm_info
.buffer
= data
;
1653 disasm_info
.buffer_vma
= section
->vma
;
1654 disasm_info
.buffer_length
= datasize
;
1655 if (start_address
== (bfd_vma
) -1
1656 || start_address
< disasm_info
.buffer_vma
)
1659 i
= start_address
- disasm_info
.buffer_vma
;
1660 if (stop_address
== (bfd_vma
) -1)
1664 if (stop_address
< disasm_info
.buffer_vma
)
1667 stop
= stop_address
- disasm_info
.buffer_vma
;
1668 if (stop
> disasm_info
.buffer_length
)
1669 stop
= disasm_info
.buffer_length
;
1672 sym
= find_symbol_for_address (abfd
, section
, section
->vma
+ i
,
1681 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= section
->vma
+ i
)
1686 (x
< sorted_symcount
1687 && bfd_asymbol_value (sorted_syms
[x
]) <= section
->vma
+ i
);
1690 disasm_info
.symbols
= & sorted_syms
[place
];
1691 disasm_info
.num_symbols
= x
- place
;
1694 disasm_info
.symbols
= NULL
;
1696 if (! prefix_addresses
)
1699 objdump_print_addr_with_sym (abfd
, section
, sym
,
1706 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ i
)
1708 else if (sym
== NULL
)
1712 while (place
< sorted_symcount
1713 /* ??? Why the test for != section? */
1714 && (sorted_syms
[place
]->section
!= section
1715 || (bfd_asymbol_value (sorted_syms
[place
])
1716 <= bfd_asymbol_value (sym
))))
1718 if (place
>= sorted_symcount
)
1721 nextsym
= sorted_syms
[place
];
1724 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ i
)
1726 nextstop
= bfd_asymbol_value (sym
) - section
->vma
;
1727 if (nextstop
> stop
)
1730 else if (nextsym
== NULL
)
1734 nextstop
= bfd_asymbol_value (nextsym
) - section
->vma
;
1735 if (nextstop
> stop
)
1739 /* If a symbol is explicitly marked as being an object
1740 rather than a function, just dump the bytes without
1741 disassembling them. */
1744 || bfd_asymbol_value (sym
) > section
->vma
+ i
1745 || ((sym
->flags
& BSF_OBJECT
) == 0
1746 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1748 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1750 || (sym
->flags
& BSF_FUNCTION
) != 0)
1755 disassemble_bytes (&disasm_info
, disassemble_fn
, insns
, data
, i
,
1756 nextstop
, &relpp
, relppend
);
1770 /* Define a table of stab values and print-strings. We wish the initializer
1771 could be a direct-mapped table, but instead we build one the first
1774 static void dump_section_stabs
PARAMS ((bfd
*abfd
, char *stabsect_name
,
1775 char *strsect_name
));
1777 /* Dump the stabs sections from an object file that has a section that
1778 uses Sun stabs encoding. */
1784 dump_section_stabs (abfd
, ".stab", ".stabstr");
1785 dump_section_stabs (abfd
, ".stab.excl", ".stab.exclstr");
1786 dump_section_stabs (abfd
, ".stab.index", ".stab.indexstr");
1787 dump_section_stabs (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1790 static bfd_byte
*stabs
;
1791 static bfd_size_type stab_size
;
1793 static char *strtab
;
1794 static bfd_size_type stabstr_size
;
1796 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1797 and string table section STRSECT_NAME into `strtab'.
1798 If the section exists and was read, allocate the space and return true.
1799 Otherwise return false. */
1802 read_section_stabs (abfd
, stabsect_name
, strsect_name
)
1804 const char *stabsect_name
;
1805 const char *strsect_name
;
1807 asection
*stabsect
, *stabstrsect
;
1809 stabsect
= bfd_get_section_by_name (abfd
, stabsect_name
);
1812 printf (_("No %s section present\n\n"), stabsect_name
);
1816 stabstrsect
= bfd_get_section_by_name (abfd
, strsect_name
);
1817 if (0 == stabstrsect
)
1819 fprintf (stderr
, _("%s: %s has no %s section\n"), program_name
,
1820 bfd_get_filename (abfd
), strsect_name
);
1824 stab_size
= bfd_section_size (abfd
, stabsect
);
1825 stabstr_size
= bfd_section_size (abfd
, stabstrsect
);
1827 stabs
= (bfd_byte
*) xmalloc (stab_size
);
1828 strtab
= (char *) xmalloc (stabstr_size
);
1830 if (! bfd_get_section_contents (abfd
, stabsect
, (PTR
) stabs
, 0, stab_size
))
1832 fprintf (stderr
, _("%s: Reading %s section of %s failed: %s\n"),
1833 program_name
, stabsect_name
, bfd_get_filename (abfd
),
1834 bfd_errmsg (bfd_get_error ()));
1840 if (! bfd_get_section_contents (abfd
, stabstrsect
, (PTR
) strtab
, 0,
1843 fprintf (stderr
, _("%s: Reading %s section of %s failed: %s\n"),
1844 program_name
, strsect_name
, bfd_get_filename (abfd
),
1845 bfd_errmsg (bfd_get_error ()));
1854 /* Stabs entries use a 12 byte format:
1855 4 byte string table index
1857 1 byte stab other field
1858 2 byte stab desc field
1860 FIXME: This will have to change for a 64 bit object format. */
1862 #define STRDXOFF (0)
1864 #define OTHEROFF (5)
1867 #define STABSIZE (12)
1869 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1870 using string table section STRSECT_NAME (in `strtab'). */
1873 print_section_stabs (abfd
, stabsect_name
, strsect_name
)
1875 const char *stabsect_name
;
1876 const char *strsect_name ATTRIBUTE_UNUSED
;
1879 unsigned file_string_table_offset
= 0, next_file_string_table_offset
= 0;
1880 bfd_byte
*stabp
, *stabs_end
;
1883 stabs_end
= stabp
+ stab_size
;
1885 printf (_("Contents of %s section:\n\n"), stabsect_name
);
1886 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1888 /* Loop through all symbols and print them.
1890 We start the index at -1 because there is a dummy symbol on
1891 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1893 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
1897 unsigned char type
, other
;
1898 unsigned short desc
;
1901 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
1902 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
1903 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
1904 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
1905 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
1907 printf ("\n%-6d ", i
);
1908 /* Either print the stab name, or, if unnamed, print its number
1909 again (makes consistent formatting for tools like awk). */
1910 name
= bfd_get_stab_name (type
);
1912 printf ("%-6s", name
);
1913 else if (type
== N_UNDF
)
1916 printf ("%-6d", type
);
1917 printf (" %-6d %-6d ", other
, desc
);
1919 printf (" %-6lu", strx
);
1921 /* Symbols with type == 0 (N_UNDF) specify the length of the
1922 string table associated with this file. We use that info
1923 to know how to relocate the *next* file's string table indices. */
1927 file_string_table_offset
= next_file_string_table_offset
;
1928 next_file_string_table_offset
+= value
;
1932 /* Using the (possibly updated) string table offset, print the
1933 string (if any) associated with this symbol. */
1935 if ((strx
+ file_string_table_offset
) < stabstr_size
)
1936 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
1945 dump_section_stabs (abfd
, stabsect_name
, strsect_name
)
1947 char *stabsect_name
;
1952 /* Check for section names for which stabsect_name is a prefix, to
1953 handle .stab0, etc. */
1954 for (s
= abfd
->sections
;
1960 len
= strlen (stabsect_name
);
1962 /* If the prefix matches, and the files section name ends with a
1963 nul or a digit, then we match. I.e., we want either an exact
1964 match or a section followed by a number. */
1965 if (strncmp (stabsect_name
, s
->name
, len
) == 0
1966 && (s
->name
[len
] == '\000'
1967 || isdigit ((unsigned char) s
->name
[len
])))
1969 if (read_section_stabs (abfd
, s
->name
, strsect_name
))
1971 print_section_stabs (abfd
, s
->name
, strsect_name
);
1980 dump_bfd_header (abfd
)
1985 printf (_("architecture: %s, "),
1986 bfd_printable_arch_mach (bfd_get_arch (abfd
),
1987 bfd_get_mach (abfd
)));
1988 printf (_("flags 0x%08x:\n"), abfd
->flags
);
1990 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
1991 PF (HAS_RELOC
, "HAS_RELOC");
1992 PF (EXEC_P
, "EXEC_P");
1993 PF (HAS_LINENO
, "HAS_LINENO");
1994 PF (HAS_DEBUG
, "HAS_DEBUG");
1995 PF (HAS_SYMS
, "HAS_SYMS");
1996 PF (HAS_LOCALS
, "HAS_LOCALS");
1997 PF (DYNAMIC
, "DYNAMIC");
1998 PF (WP_TEXT
, "WP_TEXT");
1999 PF (D_PAGED
, "D_PAGED");
2000 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2001 printf (_("\nstart address 0x"));
2002 printf_vma (abfd
->start_address
);
2007 dump_bfd_private_header (abfd
)
2010 bfd_print_private_bfd_data (abfd
, stdout
);
2019 if (!bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2021 bfd_nonfatal (bfd_get_filename (abfd
));
2022 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2024 list_matching_formats (matching
);
2030 /* If we are adjusting section VMA's, change them all now. Changing
2031 the BFD information is a hack. However, we must do it, or
2032 bfd_find_nearest_line will not do the right thing. */
2033 if (adjust_section_vma
!= 0)
2037 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2039 s
->vma
+= adjust_section_vma
;
2040 s
->lma
+= adjust_section_vma
;
2044 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2047 print_arelt_descr (stdout
, abfd
, true);
2048 if (dump_file_header
)
2049 dump_bfd_header (abfd
);
2050 if (dump_private_headers
)
2051 dump_bfd_private_header (abfd
);
2053 if (dump_section_headers
)
2054 dump_headers (abfd
);
2055 if (dump_symtab
|| dump_reloc_info
|| disassemble
|| dump_debugging
)
2057 syms
= slurp_symtab (abfd
);
2059 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
)
2061 dynsyms
= slurp_dynamic_symtab (abfd
);
2064 dump_symbols (abfd
, false);
2065 if (dump_dynamic_symtab
)
2066 dump_symbols (abfd
, true);
2067 if (dump_stab_section_info
)
2069 if (dump_reloc_info
&& ! disassemble
)
2071 if (dump_dynamic_reloc_info
)
2072 dump_dynamic_relocs (abfd
);
2073 if (dump_section_contents
)
2076 disassemble_data (abfd
);
2081 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2082 if (dhandle
!= NULL
)
2084 if (! print_debugging_info (stdout
, dhandle
))
2085 fprintf (stderr
, _("%s: printing debugging information failed\n"),
2086 bfd_get_filename (abfd
));
2102 display_file (filename
, target
)
2106 bfd
*file
, *arfile
= (bfd
*) NULL
;
2108 file
= bfd_openr (filename
, target
);
2111 bfd_nonfatal (filename
);
2115 if (bfd_check_format (file
, bfd_archive
) == true)
2117 bfd
*last_arfile
= NULL
;
2119 printf (_("In archive %s:\n"), bfd_get_filename (file
));
2122 bfd_set_error (bfd_error_no_error
);
2124 arfile
= bfd_openr_next_archived_file (file
, arfile
);
2127 if (bfd_get_error () != bfd_error_no_more_archived_files
)
2129 bfd_nonfatal (bfd_get_filename (file
));
2134 display_bfd (arfile
);
2136 if (last_arfile
!= NULL
)
2137 bfd_close (last_arfile
);
2138 last_arfile
= arfile
;
2141 if (last_arfile
!= NULL
)
2142 bfd_close (last_arfile
);
2150 /* Actually display the various requested regions */
2158 bfd_size_type datasize
= 0;
2160 bfd_size_type start
, stop
;
2162 for (section
= abfd
->sections
; section
!= NULL
; section
=
2167 if (only
== (char *) NULL
||
2168 strcmp (only
, section
->name
) == 0)
2170 if (section
->flags
& SEC_HAS_CONTENTS
)
2172 printf (_("Contents of section %s:\n"), section
->name
);
2174 if (bfd_section_size (abfd
, section
) == 0)
2176 data
= (bfd_byte
*) xmalloc ((size_t) bfd_section_size (abfd
, section
));
2177 datasize
= bfd_section_size (abfd
, section
);
2180 bfd_get_section_contents (abfd
, section
, (PTR
) data
, 0, bfd_section_size (abfd
, section
));
2182 if (start_address
== (bfd_vma
) -1
2183 || start_address
< section
->vma
)
2186 start
= start_address
- section
->vma
;
2187 if (stop_address
== (bfd_vma
) -1)
2188 stop
= bfd_section_size (abfd
, section
);
2191 if (stop_address
< section
->vma
)
2194 stop
= stop_address
- section
->vma
;
2195 if (stop
> bfd_section_size (abfd
, section
))
2196 stop
= bfd_section_size (abfd
, section
);
2198 for (i
= start
; i
< stop
; i
+= onaline
)
2202 printf (" %04lx ", (unsigned long int) (i
+ section
->vma
));
2203 for (j
= i
; j
< i
+ onaline
; j
++)
2206 printf ("%02x", (unsigned) (data
[j
]));
2214 for (j
= i
; j
< i
+ onaline
; j
++)
2219 printf ("%c", isprint (data
[j
]) ? data
[j
] : '.');
2229 /* Should perhaps share code and display with nm? */
2231 dump_symbols (abfd
, dynamic
)
2232 bfd
*abfd ATTRIBUTE_UNUSED
;
2245 printf ("DYNAMIC SYMBOL TABLE:\n");
2253 printf ("SYMBOL TABLE:\n");
2256 for (count
= 0; count
< max
; count
++)
2260 bfd
*cur_bfd
= bfd_asymbol_bfd (*current
);
2262 if (cur_bfd
!= NULL
)
2267 name
= bfd_asymbol_name (*current
);
2269 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2273 /* If we want to demangle the name, we demangle it
2274 here, and temporarily clobber it while calling
2275 bfd_print_symbol. FIXME: This is a gross hack. */
2278 if (bfd_get_symbol_leading_char (cur_bfd
) == *n
)
2280 alloc
= cplus_demangle (n
, DMGL_ANSI
| DMGL_PARAMS
);
2282 (*current
)->name
= alloc
;
2284 (*current
)->name
= n
;
2287 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2288 bfd_print_symbol_all
);
2290 (*current
)->name
= name
;
2311 for (a
= abfd
->sections
; a
!= (asection
*) NULL
; a
= a
->next
)
2315 if (bfd_is_abs_section (a
))
2317 if (bfd_is_und_section (a
))
2319 if (bfd_is_com_section (a
))
2324 if (strcmp (only
, a
->name
))
2327 else if ((a
->flags
& SEC_RELOC
) == 0)
2330 relsize
= bfd_get_reloc_upper_bound (abfd
, a
);
2332 bfd_fatal (bfd_get_filename (abfd
));
2334 printf ("RELOCATION RECORDS FOR [%s]:", a
->name
);
2338 printf (" (none)\n\n");
2342 relpp
= (arelent
**) xmalloc (relsize
);
2343 relcount
= bfd_canonicalize_reloc (abfd
, a
, relpp
, syms
);
2345 bfd_fatal (bfd_get_filename (abfd
));
2346 else if (relcount
== 0)
2348 printf (" (none)\n\n");
2353 dump_reloc_set (abfd
, a
, relpp
, relcount
);
2362 dump_dynamic_relocs (abfd
)
2369 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2371 bfd_fatal (bfd_get_filename (abfd
));
2373 printf ("DYNAMIC RELOCATION RECORDS");
2377 printf (" (none)\n\n");
2381 relpp
= (arelent
**) xmalloc (relsize
);
2382 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2384 bfd_fatal (bfd_get_filename (abfd
));
2385 else if (relcount
== 0)
2387 printf (" (none)\n\n");
2392 dump_reloc_set (abfd
, (asection
*) NULL
, relpp
, relcount
);
2400 dump_reloc_set (abfd
, sec
, relpp
, relcount
)
2407 char *last_filename
, *last_functionname
;
2408 unsigned int last_line
;
2410 /* Get column headers lined up reasonably. */
2416 sprintf_vma (buf
, (bfd_vma
) -1);
2417 width
= strlen (buf
) - 7;
2419 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2422 last_filename
= NULL
;
2423 last_functionname
= NULL
;
2426 for (p
= relpp
; relcount
&& *p
!= (arelent
*) NULL
; p
++, relcount
--)
2429 const char *filename
, *functionname
;
2431 const char *sym_name
;
2432 const char *section_name
;
2434 if (start_address
!= (bfd_vma
) -1
2435 && q
->address
< start_address
)
2437 if (stop_address
!= (bfd_vma
) -1
2438 && q
->address
> stop_address
)
2441 if (with_line_numbers
2443 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2444 &filename
, &functionname
, &line
))
2446 if (functionname
!= NULL
2447 && (last_functionname
== NULL
2448 || strcmp (functionname
, last_functionname
) != 0))
2450 printf ("%s():\n", functionname
);
2451 if (last_functionname
!= NULL
)
2452 free (last_functionname
);
2453 last_functionname
= xstrdup (functionname
);
2456 && (line
!= last_line
2457 || (filename
!= NULL
2458 && last_filename
!= NULL
2459 && strcmp (filename
, last_filename
) != 0)))
2461 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2463 if (last_filename
!= NULL
)
2464 free (last_filename
);
2465 if (filename
== NULL
)
2466 last_filename
= NULL
;
2468 last_filename
= xstrdup (filename
);
2472 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2474 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2475 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2480 section_name
= NULL
;
2484 printf_vma (q
->address
);
2486 printf (" %-16s ", q
->howto
->name
);
2488 printf (" %-16d ", q
->howto
->type
);
2489 objdump_print_symname (abfd
, (struct disassemble_info
*) NULL
,
2494 if (section_name
== (CONST
char *) NULL
)
2495 section_name
= "*unknown*";
2496 printf_vma (q
->address
);
2497 printf (" %-16s [%s]",
2504 printf_vma (q
->addend
);
2510 /* The length of the longest architecture name + 1. */
2511 #define LONGEST_ARCH sizeof("rs6000:6000")
2514 endian_string (endian
)
2515 enum bfd_endian endian
;
2517 if (endian
== BFD_ENDIAN_BIG
)
2518 return "big endian";
2519 else if (endian
== BFD_ENDIAN_LITTLE
)
2520 return "little endian";
2522 return "endianness unknown";
2525 /* List the targets that BFD is configured to support, each followed
2526 by its endianness and the architectures it supports. */
2529 display_target_list ()
2531 extern bfd_target
*bfd_target_vector
[];
2535 dummy_name
= choose_temp_base ();
2536 for (t
= 0; bfd_target_vector
[t
]; t
++)
2538 bfd_target
*p
= bfd_target_vector
[t
];
2539 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2542 printf ("%s\n (header %s, data %s)\n", p
->name
,
2543 endian_string (p
->header_byteorder
),
2544 endian_string (p
->byteorder
));
2548 bfd_nonfatal (dummy_name
);
2552 if (! bfd_set_format (abfd
, bfd_object
))
2554 if (bfd_get_error () != bfd_error_invalid_operation
)
2555 bfd_nonfatal (p
->name
);
2559 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2560 if (bfd_set_arch_mach (abfd
, (enum bfd_architecture
) a
, 0))
2562 bfd_printable_arch_mach ((enum bfd_architecture
) a
, 0));
2564 unlink (dummy_name
);
2568 /* Print a table showing which architectures are supported for entries
2569 FIRST through LAST-1 of bfd_target_vector (targets across,
2570 architectures down). */
2573 display_info_table (first
, last
)
2577 extern bfd_target
*bfd_target_vector
[];
2581 /* Print heading of target names. */
2582 printf ("\n%*s", (int) LONGEST_ARCH
, " ");
2583 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2584 printf ("%s ", bfd_target_vector
[t
]->name
);
2587 dummy_name
= choose_temp_base ();
2588 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2589 if (strcmp (bfd_printable_arch_mach (a
, 0), "UNKNOWN!") != 0)
2591 printf ("%*s ", (int) LONGEST_ARCH
- 1,
2592 bfd_printable_arch_mach (a
, 0));
2593 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2595 bfd_target
*p
= bfd_target_vector
[t
];
2597 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2601 bfd_nonfatal (p
->name
);
2607 if (! bfd_set_format (abfd
, bfd_object
))
2609 if (bfd_get_error () != bfd_error_invalid_operation
)
2610 bfd_nonfatal (p
->name
);
2617 if (! bfd_set_arch_mach (abfd
, a
, 0))
2622 printf ("%s ", p
->name
);
2625 int l
= strlen (p
->name
);
2633 unlink (dummy_name
);
2637 /* Print tables of all the target-architecture combinations that
2638 BFD has been configured to support. */
2641 display_target_tables ()
2644 extern bfd_target
*bfd_target_vector
[];
2648 colum
= getenv ("COLUMNS");
2650 columns
= atoi (colum
);
2655 while (bfd_target_vector
[t
] != NULL
)
2659 wid
= LONGEST_ARCH
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2661 while (wid
< columns
&& bfd_target_vector
[t
] != NULL
)
2665 newwid
= wid
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2666 if (newwid
>= columns
)
2671 display_info_table (oldt
, t
);
2678 printf (_("BFD header file version %s\n"), BFD_VERSION
);
2679 display_target_list ();
2680 display_target_tables ();
2689 char *target
= default_target
;
2690 boolean seenflag
= false;
2692 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
2693 setlocale (LC_MESSAGES
, "");
2695 bindtextdomain (PACKAGE
, LOCALEDIR
);
2696 textdomain (PACKAGE
);
2698 program_name
= *argv
;
2699 xmalloc_set_program_name (program_name
);
2701 START_PROGRESS (program_name
, 0);
2704 set_default_bfd_target ();
2706 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VCdDlfahrRtTxsSj:wE:",
2707 long_options
, (int *) 0))
2710 if (c
!= 'l' && c
!= OPTION_START_ADDRESS
&& c
!= OPTION_STOP_ADDRESS
)
2715 break; /* we've been given a long option */
2720 disassembler_options
= optarg
;
2726 with_line_numbers
= 1;
2732 dump_file_header
= true;
2735 formats_info
= true;
2738 dump_private_headers
= 1;
2741 dump_private_headers
= 1;
2743 dump_reloc_info
= 1;
2744 dump_file_header
= true;
2746 dump_section_headers
= 1;
2752 dump_dynamic_symtab
= 1;
2761 disassemble
= disassemble_all
= true;
2765 with_source_code
= true;
2768 dump_section_contents
= 1;
2771 dump_reloc_info
= 1;
2774 dump_dynamic_reloc_info
= 1;
2780 dump_section_headers
= 1;
2790 case OPTION_ADJUST_VMA
:
2791 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
2793 case OPTION_START_ADDRESS
:
2794 start_address
= parse_vma (optarg
, "--start-address");
2796 case OPTION_STOP_ADDRESS
:
2797 stop_address
= parse_vma (optarg
, "--stop-address");
2800 if (strcmp (optarg
, "B") == 0)
2801 endian
= BFD_ENDIAN_BIG
;
2802 else if (strcmp (optarg
, "L") == 0)
2803 endian
= BFD_ENDIAN_LITTLE
;
2806 fprintf (stderr
, _("%s: unrecognized -E option\n"), program_name
);
2811 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
2812 endian
= BFD_ENDIAN_BIG
;
2813 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
2814 endian
= BFD_ENDIAN_LITTLE
;
2817 fprintf (stderr
, _("%s: unrecognized --endian type `%s'\n"),
2818 program_name
, optarg
);
2828 print_version ("objdump");
2830 if (seenflag
== false)
2840 display_file ("a.out", target
);
2842 for (; optind
< argc
;)
2843 display_file (argv
[optind
++], target
);
2846 END_PROGRESS (program_name
);