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_SHORT
, "SHORT");
334 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
338 switch (section
->flags
& SEC_LINK_DUPLICATES
)
342 case SEC_LINK_DUPLICATES_DISCARD
:
343 ls
= "LINK_ONCE_DISCARD";
345 case SEC_LINK_DUPLICATES_ONE_ONLY
:
346 ls
= "LINK_ONCE_ONE_ONLY";
348 case SEC_LINK_DUPLICATES_SAME_SIZE
:
349 ls
= "LINK_ONCE_SAME_SIZE";
351 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
352 ls
= "LINK_ONCE_SAME_CONTENTS";
355 printf ("%s%s", comma
, ls
);
367 printf (_("Sections:\n"));
369 printf (_("Idx Name Size VMA LMA File off Algn\n"));
371 printf (_("Idx Name Size VMA LMA File off Algn\n"));
373 bfd_map_over_sections (abfd
, dump_section_header
, (PTR
) NULL
);
380 asymbol
**sy
= (asymbol
**) NULL
;
383 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
385 fprintf (stderr
, _("%s: no symbols\n"), bfd_get_filename (abfd
));
390 storage
= bfd_get_symtab_upper_bound (abfd
);
392 bfd_fatal (bfd_get_filename (abfd
));
396 sy
= (asymbol
**) xmalloc (storage
);
398 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
400 bfd_fatal (bfd_get_filename (abfd
));
402 fprintf (stderr
, _("%s: no symbols\n"), bfd_get_filename (abfd
));
406 /* Read in the dynamic symbols. */
409 slurp_dynamic_symtab (abfd
)
412 asymbol
**sy
= (asymbol
**) NULL
;
415 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
418 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
420 fprintf (stderr
, _("%s: %s: not a dynamic object\n"),
421 program_name
, bfd_get_filename (abfd
));
426 bfd_fatal (bfd_get_filename (abfd
));
431 sy
= (asymbol
**) xmalloc (storage
);
433 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
435 bfd_fatal (bfd_get_filename (abfd
));
436 if (dynsymcount
== 0)
437 fprintf (stderr
, _("%s: %s: No dynamic symbols\n"),
438 program_name
, bfd_get_filename (abfd
));
442 /* Filter out (in place) symbols that are useless for disassembly.
443 COUNT is the number of elements in SYMBOLS.
444 Return the number of useful symbols. */
447 remove_useless_symbols (symbols
, count
)
451 register asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
455 asymbol
*sym
= *in_ptr
++;
457 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
459 if (sym
->flags
& (BSF_DEBUGGING
))
461 if (bfd_is_und_section (sym
->section
)
462 || bfd_is_com_section (sym
->section
))
467 return out_ptr
- symbols
;
470 /* Sort symbols into value order. */
473 compare_symbols (ap
, bp
)
477 const asymbol
*a
= *(const asymbol
**)ap
;
478 const asymbol
*b
= *(const asymbol
**)bp
;
482 flagword aflags
, bflags
;
484 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
486 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
489 if (a
->section
> b
->section
)
491 else if (a
->section
< b
->section
)
494 an
= bfd_asymbol_name (a
);
495 bn
= bfd_asymbol_name (b
);
499 /* The symbols gnu_compiled and gcc2_compiled convey no real
500 information, so put them after other symbols with the same value. */
502 af
= (strstr (an
, "gnu_compiled") != NULL
503 || strstr (an
, "gcc2_compiled") != NULL
);
504 bf
= (strstr (bn
, "gnu_compiled") != NULL
505 || strstr (bn
, "gcc2_compiled") != NULL
);
512 /* We use a heuristic for the file name, to try to sort it after
513 more useful symbols. It may not work on non Unix systems, but it
514 doesn't really matter; the only difference is precisely which
515 symbol names get printed. */
517 #define file_symbol(s, sn, snl) \
518 (((s)->flags & BSF_FILE) != 0 \
519 || ((sn)[(snl) - 2] == '.' \
520 && ((sn)[(snl) - 1] == 'o' \
521 || (sn)[(snl) - 1] == 'a')))
523 af
= file_symbol (a
, an
, anl
);
524 bf
= file_symbol (b
, bn
, bnl
);
531 /* Try to sort global symbols before local symbols before function
532 symbols before debugging symbols. */
537 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
539 if ((aflags
& BSF_DEBUGGING
) != 0)
544 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
546 if ((aflags
& BSF_FUNCTION
) != 0)
551 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
553 if ((aflags
& BSF_LOCAL
) != 0)
558 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
560 if ((aflags
& BSF_GLOBAL
) != 0)
566 /* Symbols that start with '.' might be section names, so sort them
567 after symbols that don't start with '.'. */
568 if (an
[0] == '.' && bn
[0] != '.')
570 if (an
[0] != '.' && bn
[0] == '.')
573 /* Finally, if we can't distinguish them in any other way, try to
574 get consistent results by sorting the symbols by name. */
575 return strcmp (an
, bn
);
578 /* Sort relocs into address order. */
581 compare_relocs (ap
, bp
)
585 const arelent
*a
= *(const arelent
**)ap
;
586 const arelent
*b
= *(const arelent
**)bp
;
588 if (a
->address
> b
->address
)
590 else if (a
->address
< b
->address
)
593 /* So that associated relocations tied to the same address show up
594 in the correct order, we don't do any further sorting. */
603 /* Print VMA to STREAM. If SKIP_ZEROES is true, omit leading zeroes. */
606 objdump_print_value (vma
, info
, skip_zeroes
)
608 struct disassemble_info
*info
;
614 sprintf_vma (buf
, vma
);
619 for (p
= buf
; *p
== '0'; ++p
)
624 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
627 /* Print the name of a symbol. */
630 objdump_print_symname (abfd
, info
, sym
)
632 struct disassemble_info
*info
;
640 name
= bfd_asymbol_name (sym
);
641 if (! do_demangle
|| name
[0] == '\0')
645 /* Demangle the name. */
646 if (bfd_get_symbol_leading_char (abfd
) == name
[0])
649 alloc
= cplus_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
657 (*info
->fprintf_func
) (info
->stream
, "%s", print
);
659 printf ("%s", print
);
665 /* Locate a symbol given a bfd, a section, and a VMA. If REQUIRE_SEC
666 is true, then always require the symbol to be in the section. This
667 returns NULL if there is no suitable symbol. If PLACE is not NULL,
668 then *PLACE is set to the index of the symbol in sorted_syms. */
671 find_symbol_for_address (abfd
, sec
, vma
, require_sec
, place
)
678 /* @@ Would it speed things up to cache the last two symbols returned,
679 and maybe their address ranges? For many processors, only one memory
680 operand can be present at a time, so the 2-entry cache wouldn't be
681 constantly churned by code doing heavy memory accesses. */
683 /* Indices in `sorted_syms'. */
685 long max
= sorted_symcount
;
688 if (sorted_symcount
< 1)
691 /* Perform a binary search looking for the closest symbol to the
692 required value. We are searching the range (min, max]. */
693 while (min
+ 1 < max
)
697 thisplace
= (max
+ min
) / 2;
698 sym
= sorted_syms
[thisplace
];
700 if (bfd_asymbol_value (sym
) > vma
)
702 else if (bfd_asymbol_value (sym
) < vma
)
711 /* The symbol we want is now in min, the low end of the range we
712 were searching. If there are several symbols with the same
713 value, we want the first one. */
716 && (bfd_asymbol_value (sorted_syms
[thisplace
])
717 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
720 /* If the file is relocateable, and the symbol could be from this
721 section, prefer a symbol from this section over symbols from
722 others, even if the other symbol's value might be closer.
724 Note that this may be wrong for some symbol references if the
725 sections have overlapping memory ranges, but in that case there's
726 no way to tell what's desired without looking at the relocation
729 if (sorted_syms
[thisplace
]->section
!= sec
731 || ((abfd
->flags
& HAS_RELOC
) != 0
732 && vma
>= bfd_get_section_vma (abfd
, sec
)
733 && vma
< (bfd_get_section_vma (abfd
, sec
)
734 + bfd_section_size (abfd
, sec
)))))
738 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
740 if (bfd_asymbol_value (sorted_syms
[i
])
741 != bfd_asymbol_value (sorted_syms
[thisplace
]))
747 if (sorted_syms
[i
]->section
== sec
749 || sorted_syms
[i
- 1]->section
!= sec
750 || (bfd_asymbol_value (sorted_syms
[i
])
751 != bfd_asymbol_value (sorted_syms
[i
- 1]))))
758 if (sorted_syms
[thisplace
]->section
!= sec
)
760 /* We didn't find a good symbol with a smaller value.
761 Look for one with a larger value. */
762 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
764 if (sorted_syms
[i
]->section
== sec
)
772 if (sorted_syms
[thisplace
]->section
!= sec
774 || ((abfd
->flags
& HAS_RELOC
) != 0
775 && vma
>= bfd_get_section_vma (abfd
, sec
)
776 && vma
< (bfd_get_section_vma (abfd
, sec
)
777 + bfd_section_size (abfd
, sec
)))))
779 /* There is no suitable symbol. */
787 return sorted_syms
[thisplace
];
790 /* Print an address to INFO symbolically. */
793 objdump_print_addr_with_sym (abfd
, sec
, sym
, vma
, info
, skip_zeroes
)
798 struct disassemble_info
*info
;
801 objdump_print_value (vma
, info
, skip_zeroes
);
807 (*info
->fprintf_func
) (info
->stream
, " <%s",
808 bfd_get_section_name (abfd
, sec
));
809 secaddr
= bfd_get_section_vma (abfd
, sec
);
812 (*info
->fprintf_func
) (info
->stream
, "-0x");
813 objdump_print_value (secaddr
- vma
, info
, true);
815 else if (vma
> secaddr
)
817 (*info
->fprintf_func
) (info
->stream
, "+0x");
818 objdump_print_value (vma
- secaddr
, info
, true);
820 (*info
->fprintf_func
) (info
->stream
, ">");
824 (*info
->fprintf_func
) (info
->stream
, " <");
825 objdump_print_symname (abfd
, info
, sym
);
826 if (bfd_asymbol_value (sym
) > vma
)
828 (*info
->fprintf_func
) (info
->stream
, "-0x");
829 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, true);
831 else if (vma
> bfd_asymbol_value (sym
))
833 (*info
->fprintf_func
) (info
->stream
, "+0x");
834 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, true);
836 (*info
->fprintf_func
) (info
->stream
, ">");
840 /* Print VMA to INFO, symbolically if possible. If SKIP_ZEROES is
841 true, don't output leading zeroes. */
844 objdump_print_addr (vma
, info
, skip_zeroes
)
846 struct disassemble_info
*info
;
849 struct objdump_disasm_info
*aux
;
852 if (sorted_symcount
< 1)
854 (*info
->fprintf_func
) (info
->stream
, "0x");
855 objdump_print_value (vma
, info
, skip_zeroes
);
859 aux
= (struct objdump_disasm_info
*) info
->application_data
;
860 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
862 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
866 /* Print VMA to INFO. This function is passed to the disassembler
870 objdump_print_address (vma
, info
)
872 struct disassemble_info
*info
;
874 objdump_print_addr (vma
, info
, ! prefix_addresses
);
877 /* Determine of the given address has a symbol associated with it. */
880 objdump_symbol_at_address (vma
, info
)
882 struct disassemble_info
* info
;
884 struct objdump_disasm_info
* aux
;
887 /* No symbols - do not bother checking. */
888 if (sorted_symcount
< 1)
891 aux
= (struct objdump_disasm_info
*) info
->application_data
;
892 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
895 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
898 /* Hold the last function name and the last line number we displayed
901 static char *prev_functionname
;
902 static unsigned int prev_line
;
904 /* We keep a list of all files that we have seen when doing a
905 dissassembly with source, so that we know how much of the file to
906 display. This can be important for inlined functions. */
908 struct print_file_list
910 struct print_file_list
*next
;
916 static struct print_file_list
*print_files
;
918 /* The number of preceding context lines to show when we start
919 displaying a file for the first time. */
921 #define SHOW_PRECEDING_CONTEXT_LINES (5)
923 /* Skip ahead to a given line in a file, optionally printing each
927 skip_to_line
PARAMS ((struct print_file_list
*, unsigned int, boolean
));
930 skip_to_line (p
, line
, show
)
931 struct print_file_list
*p
;
935 while (p
->line
< line
)
939 if (fgets (buf
, sizeof buf
, p
->f
) == NULL
)
949 if (strchr (buf
, '\n') != NULL
)
954 /* Show the line number, or the source line, in a dissassembly
958 show_line (abfd
, section
, off
)
963 CONST
char *filename
;
964 CONST
char *functionname
;
967 if (! with_line_numbers
&& ! with_source_code
)
970 if (! bfd_find_nearest_line (abfd
, section
, syms
, off
, &filename
,
971 &functionname
, &line
))
974 if (filename
!= NULL
&& *filename
== '\0')
976 if (functionname
!= NULL
&& *functionname
== '\0')
979 if (with_line_numbers
)
981 if (functionname
!= NULL
982 && (prev_functionname
== NULL
983 || strcmp (functionname
, prev_functionname
) != 0))
984 printf ("%s():\n", functionname
);
985 if (line
> 0 && line
!= prev_line
)
986 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
993 struct print_file_list
**pp
, *p
;
995 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
996 if (strcmp ((*pp
)->filename
, filename
) == 0)
1002 if (p
!= print_files
)
1006 /* We have reencountered a file name which we saw
1007 earlier. This implies that either we are dumping out
1008 code from an included file, or the same file was
1009 linked in more than once. There are two common cases
1010 of an included file: inline functions in a header
1011 file, and a bison or flex skeleton file. In the
1012 former case we want to just start printing (but we
1013 back up a few lines to give context); in the latter
1014 case we want to continue from where we left off. I
1015 can't think of a good way to distinguish the cases,
1016 so I used a heuristic based on the file name. */
1017 if (strcmp (p
->filename
+ strlen (p
->filename
) - 2, ".h") != 0)
1021 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1028 p
->f
= fopen (p
->filename
, "r");
1032 skip_to_line (p
, l
, false);
1034 if (print_files
->f
!= NULL
)
1036 fclose (print_files
->f
);
1037 print_files
->f
= NULL
;
1043 skip_to_line (p
, line
, true);
1045 p
->next
= print_files
;
1053 f
= fopen (filename
, "r");
1058 p
= ((struct print_file_list
*)
1059 xmalloc (sizeof (struct print_file_list
)));
1060 p
->filename
= xmalloc (strlen (filename
) + 1);
1061 strcpy (p
->filename
, filename
);
1065 if (print_files
!= NULL
&& print_files
->f
!= NULL
)
1067 fclose (print_files
->f
);
1068 print_files
->f
= NULL
;
1070 p
->next
= print_files
;
1073 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1076 skip_to_line (p
, l
, false);
1078 skip_to_line (p
, line
, true);
1083 if (functionname
!= NULL
1084 && (prev_functionname
== NULL
1085 || strcmp (functionname
, prev_functionname
) != 0))
1087 if (prev_functionname
!= NULL
)
1088 free (prev_functionname
);
1089 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1090 strcpy (prev_functionname
, functionname
);
1093 if (line
> 0 && line
!= prev_line
)
1097 /* Pseudo FILE object for strings. */
1105 /* sprintf to a "stream" */
1108 #ifdef ANSI_PROTOTYPES
1109 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1111 objdump_sprintf (va_alist
)
1115 #ifndef ANSI_PROTOTYPES
1123 #ifdef ANSI_PROTOTYPES
1124 va_start (args
, format
);
1127 f
= va_arg (args
, SFILE
*);
1128 format
= va_arg (args
, const char *);
1131 vasprintf (&buf
, format
, args
);
1137 fprintf (stderr
, _("Out of virtual memory\n"));
1143 while ((size_t) ((f
->buffer
+ f
->size
) - f
->current
) < n
+ 1)
1147 curroff
= f
->current
- f
->buffer
;
1149 f
->buffer
= xrealloc (f
->buffer
, f
->size
);
1150 f
->current
= f
->buffer
+ curroff
;
1153 memcpy (f
->current
, buf
, n
);
1155 f
->current
[0] = '\0';
1162 /* The number of zeroes we want to see before we start skipping them.
1163 The number is arbitrarily chosen. */
1165 #define SKIP_ZEROES (8)
1167 /* The number of zeroes to skip at the end of a section. If the
1168 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1169 SKIP_ZEROES, they will be disassembled. If there are fewer than
1170 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1171 attempt to avoid disassembling zeroes inserted by section
1174 #define SKIP_ZEROES_AT_END (3)
1176 /* Disassemble some data in memory between given values. */
1179 disassemble_bytes (info
, disassemble_fn
, insns
, data
, start
, stop
, relppp
,
1181 struct disassemble_info
*info
;
1182 disassembler_ftype disassemble_fn
;
1190 struct objdump_disasm_info
*aux
;
1194 int skip_addr_chars
;
1197 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1203 bytes_per_line
= 16;
1205 /* Figure out how many characters to skip at the start of an
1206 address, to make the disassembly look nicer. We discard leading
1207 zeroes in chunks of 4, ensuring that there is always a leading
1209 skip_addr_chars
= 0;
1210 if (! prefix_addresses
)
1216 section
->vma
+ bfd_section_size (section
->owner
, section
));
1218 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1221 skip_addr_chars
+= 4;
1226 info
->insn_info_valid
= 0;
1234 boolean need_nl
= false;
1236 /* If we see more than SKIP_ZEROES bytes of zeroes, we just
1238 for (z
= i
; z
< stop
; z
++)
1241 if (! disassemble_zeroes
1242 && (info
->insn_info_valid
== 0
1243 || info
->branch_delay_insns
== 0)
1244 && (z
- i
>= SKIP_ZEROES
1245 || (z
== stop
&& z
- i
< SKIP_ZEROES_AT_END
)))
1249 /* If there are more nonzero bytes to follow, we only skip
1250 zeroes in multiples of 4, to try to avoid running over
1251 the start of an instruction which happens to start with
1254 z
= i
+ ((z
- i
) &~ 3);
1267 if (with_line_numbers
|| with_source_code
)
1268 show_line (aux
->abfd
, section
, i
);
1270 if (! prefix_addresses
)
1274 sprintf_vma (buf
, section
->vma
+ i
);
1275 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1279 printf ("%s:\t", buf
+ skip_addr_chars
);
1283 aux
->require_sec
= true;
1284 objdump_print_address (section
->vma
+ i
, info
);
1285 aux
->require_sec
= false;
1292 sfile
.buffer
= xmalloc (sfile
.size
);
1293 sfile
.current
= sfile
.buffer
;
1294 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1295 info
->stream
= (FILE *) &sfile
;
1296 info
->bytes_per_line
= 0;
1297 info
->bytes_per_chunk
= 0;
1299 /* FIXME: This is wrong. It tests the number of bytes
1300 in the last instruction, not the current one. */
1301 if (*relppp
< relppend
1302 && (**relppp
)->address
>= i
1303 && (**relppp
)->address
< i
+ bytes
)
1304 info
->flags
= INSN_HAS_RELOC
;
1308 bytes
= (*disassemble_fn
) (section
->vma
+ i
, info
);
1309 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1310 info
->stream
= stdout
;
1311 if (info
->bytes_per_line
!= 0)
1312 bytes_per_line
= info
->bytes_per_line
;
1315 if (sfile
.current
!= sfile
.buffer
)
1316 printf ("%s\n", sfile
.buffer
);
1317 free (sfile
.buffer
);
1325 bytes
= bytes_per_line
;
1326 if (i
+ bytes
> stop
)
1329 for (j
= i
; j
< i
+ bytes
; ++j
)
1331 if (isprint (data
[j
]))
1332 buf
[j
- i
] = data
[j
];
1339 if (prefix_addresses
1341 : show_raw_insn
>= 0)
1345 /* If ! prefix_addresses and ! wide_output, we print
1346 bytes_per_line bytes per line. */
1348 if (pb
> bytes_per_line
&& ! prefix_addresses
&& ! wide_output
)
1349 pb
= bytes_per_line
;
1351 if (info
->bytes_per_chunk
)
1352 bpc
= info
->bytes_per_chunk
;
1356 for (j
= i
; j
< i
+ pb
; j
+= bpc
)
1359 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1361 for (k
= bpc
- 1; k
>= 0; k
--)
1362 printf ("%02x", (unsigned) data
[j
+ k
]);
1367 for (k
= 0; k
< bpc
; k
++)
1368 printf ("%02x", (unsigned) data
[j
+ k
]);
1373 for (; pb
< bytes_per_line
; pb
+= bpc
)
1377 for (k
= 0; k
< bpc
; k
++)
1382 /* Separate raw data from instruction by extra space. */
1393 printf ("%s", sfile
.buffer
);
1394 free (sfile
.buffer
);
1397 if (prefix_addresses
1399 : show_raw_insn
>= 0)
1409 sprintf_vma (buf
, section
->vma
+ j
);
1410 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1414 printf ("%s:\t", buf
+ skip_addr_chars
);
1416 pb
+= bytes_per_line
;
1419 for (; j
< i
+ pb
; j
+= bpc
)
1423 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1425 for (k
= bpc
- 1; k
>= 0; k
--)
1426 printf ("%02x", (unsigned) data
[j
+ k
]);
1431 for (k
= 0; k
< bpc
; k
++)
1432 printf ("%02x", (unsigned) data
[j
+ k
]);
1446 && (section
->flags
& SEC_RELOC
) != 0)
1448 while ((*relppp
) < relppend
1449 && ((**relppp
)->address
>= (bfd_vma
) i
1450 && (**relppp
)->address
< (bfd_vma
) i
+ bytes
))
1461 objdump_print_value (section
->vma
+ q
->address
, info
, true);
1463 printf (": %s\t", q
->howto
->name
);
1465 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1466 printf ("*unknown*");
1469 const char *sym_name
;
1471 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1472 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1473 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1478 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1479 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1480 if (sym_name
== NULL
|| *sym_name
== '\0')
1481 sym_name
= "*unknown*";
1482 printf ("%s", sym_name
);
1489 objdump_print_value (q
->addend
, info
, true);
1505 /* Disassemble the contents of an object file. */
1508 disassemble_data (abfd
)
1512 disassembler_ftype disassemble_fn
;
1513 struct disassemble_info disasm_info
;
1514 struct objdump_disasm_info aux
;
1518 prev_functionname
= NULL
;
1521 /* We make a copy of syms to sort. We don't want to sort syms
1522 because that will screw up the relocs. */
1523 sorted_syms
= (asymbol
**) xmalloc (symcount
* sizeof (asymbol
*));
1524 memcpy (sorted_syms
, syms
, symcount
* sizeof (asymbol
*));
1526 sorted_symcount
= remove_useless_symbols (sorted_syms
, symcount
);
1528 /* Sort the symbols into section and symbol order */
1529 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1531 INIT_DISASSEMBLE_INFO(disasm_info
, stdout
, fprintf
);
1532 disasm_info
.application_data
= (PTR
) &aux
;
1534 aux
.require_sec
= false;
1535 disasm_info
.print_address_func
= objdump_print_address
;
1536 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1538 if (machine
!= (char *) NULL
)
1540 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1543 fprintf (stderr
, _("%s: Can't use supplied machine %s\n"),
1548 abfd
->arch_info
= info
;
1551 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1553 struct bfd_target
*xvec
;
1555 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
1556 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1557 xvec
->byteorder
= endian
;
1561 disassemble_fn
= disassembler (abfd
);
1562 if (!disassemble_fn
)
1564 fprintf (stderr
, _("%s: Can't disassemble for architecture %s\n"),
1566 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1570 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1571 disasm_info
.arch
= bfd_get_arch (abfd
);
1572 disasm_info
.mach
= bfd_get_mach (abfd
);
1573 disasm_info
.disassembler_options
= disassembler_options
;
1575 if (bfd_big_endian (abfd
))
1576 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1577 else if (bfd_little_endian (abfd
))
1578 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1580 /* ??? Aborting here seems too drastic. We could default to big or little
1582 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1584 for (section
= abfd
->sections
;
1585 section
!= (asection
*) NULL
;
1586 section
= section
->next
)
1588 bfd_byte
*data
= NULL
;
1589 bfd_size_type datasize
= 0;
1590 arelent
**relbuf
= NULL
;
1591 arelent
**relpp
= NULL
;
1592 arelent
**relppend
= NULL
;
1594 asymbol
*sym
= NULL
;
1597 if ((section
->flags
& SEC_LOAD
) == 0
1598 || (! disassemble_all
1600 && (section
->flags
& SEC_CODE
) == 0))
1602 if (only
!= (char *) NULL
&& strcmp (only
, section
->name
) != 0)
1606 && (section
->flags
& SEC_RELOC
) != 0)
1610 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1612 bfd_fatal (bfd_get_filename (abfd
));
1618 relbuf
= (arelent
**) xmalloc (relsize
);
1619 relcount
= bfd_canonicalize_reloc (abfd
, section
, relbuf
, syms
);
1621 bfd_fatal (bfd_get_filename (abfd
));
1623 /* Sort the relocs by address. */
1624 qsort (relbuf
, relcount
, sizeof (arelent
*), compare_relocs
);
1627 relppend
= relpp
+ relcount
;
1629 /* Skip over the relocs belonging to addresses below the
1631 if (start_address
!= (bfd_vma
) -1)
1633 while (relpp
< relppend
1634 && (*relpp
)->address
< start_address
)
1640 printf (_("Disassembly of section %s:\n"), section
->name
);
1642 datasize
= bfd_get_section_size_before_reloc (section
);
1646 data
= (bfd_byte
*) xmalloc ((size_t) datasize
);
1648 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1651 disasm_info
.buffer
= data
;
1652 disasm_info
.buffer_vma
= section
->vma
;
1653 disasm_info
.buffer_length
= datasize
;
1654 if (start_address
== (bfd_vma
) -1
1655 || start_address
< disasm_info
.buffer_vma
)
1658 i
= start_address
- disasm_info
.buffer_vma
;
1659 if (stop_address
== (bfd_vma
) -1)
1663 if (stop_address
< disasm_info
.buffer_vma
)
1666 stop
= stop_address
- disasm_info
.buffer_vma
;
1667 if (stop
> disasm_info
.buffer_length
)
1668 stop
= disasm_info
.buffer_length
;
1671 sym
= find_symbol_for_address (abfd
, section
, section
->vma
+ i
,
1680 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= section
->vma
+ i
)
1685 (x
< sorted_symcount
1686 && bfd_asymbol_value (sorted_syms
[x
]) <= section
->vma
+ i
);
1689 disasm_info
.symbols
= & sorted_syms
[place
];
1690 disasm_info
.num_symbols
= x
- place
;
1693 disasm_info
.symbols
= NULL
;
1695 if (! prefix_addresses
)
1698 objdump_print_addr_with_sym (abfd
, section
, sym
,
1705 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ i
)
1707 else if (sym
== NULL
)
1711 while (place
< sorted_symcount
1712 /* ??? Why the test for != section? */
1713 && (sorted_syms
[place
]->section
!= section
1714 || (bfd_asymbol_value (sorted_syms
[place
])
1715 <= bfd_asymbol_value (sym
))))
1717 if (place
>= sorted_symcount
)
1720 nextsym
= sorted_syms
[place
];
1723 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ i
)
1725 nextstop
= bfd_asymbol_value (sym
) - section
->vma
;
1726 if (nextstop
> stop
)
1729 else if (nextsym
== NULL
)
1733 nextstop
= bfd_asymbol_value (nextsym
) - section
->vma
;
1734 if (nextstop
> stop
)
1738 /* If a symbol is explicitly marked as being an object
1739 rather than a function, just dump the bytes without
1740 disassembling them. */
1743 || bfd_asymbol_value (sym
) > section
->vma
+ i
1744 || ((sym
->flags
& BSF_OBJECT
) == 0
1745 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1747 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1749 || (sym
->flags
& BSF_FUNCTION
) != 0)
1754 disassemble_bytes (&disasm_info
, disassemble_fn
, insns
, data
, i
,
1755 nextstop
, &relpp
, relppend
);
1769 /* Define a table of stab values and print-strings. We wish the initializer
1770 could be a direct-mapped table, but instead we build one the first
1773 static void dump_section_stabs
PARAMS ((bfd
*abfd
, char *stabsect_name
,
1774 char *strsect_name
));
1776 /* Dump the stabs sections from an object file that has a section that
1777 uses Sun stabs encoding. */
1783 dump_section_stabs (abfd
, ".stab", ".stabstr");
1784 dump_section_stabs (abfd
, ".stab.excl", ".stab.exclstr");
1785 dump_section_stabs (abfd
, ".stab.index", ".stab.indexstr");
1786 dump_section_stabs (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1789 static bfd_byte
*stabs
;
1790 static bfd_size_type stab_size
;
1792 static char *strtab
;
1793 static bfd_size_type stabstr_size
;
1795 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1796 and string table section STRSECT_NAME into `strtab'.
1797 If the section exists and was read, allocate the space and return true.
1798 Otherwise return false. */
1801 read_section_stabs (abfd
, stabsect_name
, strsect_name
)
1803 const char *stabsect_name
;
1804 const char *strsect_name
;
1806 asection
*stabsect
, *stabstrsect
;
1808 stabsect
= bfd_get_section_by_name (abfd
, stabsect_name
);
1811 printf (_("No %s section present\n\n"), stabsect_name
);
1815 stabstrsect
= bfd_get_section_by_name (abfd
, strsect_name
);
1816 if (0 == stabstrsect
)
1818 fprintf (stderr
, _("%s: %s has no %s section\n"), program_name
,
1819 bfd_get_filename (abfd
), strsect_name
);
1823 stab_size
= bfd_section_size (abfd
, stabsect
);
1824 stabstr_size
= bfd_section_size (abfd
, stabstrsect
);
1826 stabs
= (bfd_byte
*) xmalloc (stab_size
);
1827 strtab
= (char *) xmalloc (stabstr_size
);
1829 if (! bfd_get_section_contents (abfd
, stabsect
, (PTR
) stabs
, 0, stab_size
))
1831 fprintf (stderr
, _("%s: Reading %s section of %s failed: %s\n"),
1832 program_name
, stabsect_name
, bfd_get_filename (abfd
),
1833 bfd_errmsg (bfd_get_error ()));
1839 if (! bfd_get_section_contents (abfd
, stabstrsect
, (PTR
) strtab
, 0,
1842 fprintf (stderr
, _("%s: Reading %s section of %s failed: %s\n"),
1843 program_name
, strsect_name
, bfd_get_filename (abfd
),
1844 bfd_errmsg (bfd_get_error ()));
1853 /* Stabs entries use a 12 byte format:
1854 4 byte string table index
1856 1 byte stab other field
1857 2 byte stab desc field
1859 FIXME: This will have to change for a 64 bit object format. */
1861 #define STRDXOFF (0)
1863 #define OTHEROFF (5)
1866 #define STABSIZE (12)
1868 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1869 using string table section STRSECT_NAME (in `strtab'). */
1872 print_section_stabs (abfd
, stabsect_name
, strsect_name
)
1874 const char *stabsect_name
;
1875 const char *strsect_name ATTRIBUTE_UNUSED
;
1878 unsigned file_string_table_offset
= 0, next_file_string_table_offset
= 0;
1879 bfd_byte
*stabp
, *stabs_end
;
1882 stabs_end
= stabp
+ stab_size
;
1884 printf (_("Contents of %s section:\n\n"), stabsect_name
);
1885 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1887 /* Loop through all symbols and print them.
1889 We start the index at -1 because there is a dummy symbol on
1890 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1892 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
1896 unsigned char type
, other
;
1897 unsigned short desc
;
1900 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
1901 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
1902 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
1903 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
1904 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
1906 printf ("\n%-6d ", i
);
1907 /* Either print the stab name, or, if unnamed, print its number
1908 again (makes consistent formatting for tools like awk). */
1909 name
= bfd_get_stab_name (type
);
1911 printf ("%-6s", name
);
1912 else if (type
== N_UNDF
)
1915 printf ("%-6d", type
);
1916 printf (" %-6d %-6d ", other
, desc
);
1918 printf (" %-6lu", strx
);
1920 /* Symbols with type == 0 (N_UNDF) specify the length of the
1921 string table associated with this file. We use that info
1922 to know how to relocate the *next* file's string table indices. */
1926 file_string_table_offset
= next_file_string_table_offset
;
1927 next_file_string_table_offset
+= value
;
1931 /* Using the (possibly updated) string table offset, print the
1932 string (if any) associated with this symbol. */
1934 if ((strx
+ file_string_table_offset
) < stabstr_size
)
1935 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
1944 dump_section_stabs (abfd
, stabsect_name
, strsect_name
)
1946 char *stabsect_name
;
1951 /* Check for section names for which stabsect_name is a prefix, to
1952 handle .stab0, etc. */
1953 for (s
= abfd
->sections
;
1959 len
= strlen (stabsect_name
);
1961 /* If the prefix matches, and the files section name ends with a
1962 nul or a digit, then we match. I.e., we want either an exact
1963 match or a section followed by a number. */
1964 if (strncmp (stabsect_name
, s
->name
, len
) == 0
1965 && (s
->name
[len
] == '\000'
1966 || isdigit ((unsigned char) s
->name
[len
])))
1968 if (read_section_stabs (abfd
, s
->name
, strsect_name
))
1970 print_section_stabs (abfd
, s
->name
, strsect_name
);
1979 dump_bfd_header (abfd
)
1984 printf (_("architecture: %s, "),
1985 bfd_printable_arch_mach (bfd_get_arch (abfd
),
1986 bfd_get_mach (abfd
)));
1987 printf (_("flags 0x%08x:\n"), abfd
->flags
);
1989 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
1990 PF (HAS_RELOC
, "HAS_RELOC");
1991 PF (EXEC_P
, "EXEC_P");
1992 PF (HAS_LINENO
, "HAS_LINENO");
1993 PF (HAS_DEBUG
, "HAS_DEBUG");
1994 PF (HAS_SYMS
, "HAS_SYMS");
1995 PF (HAS_LOCALS
, "HAS_LOCALS");
1996 PF (DYNAMIC
, "DYNAMIC");
1997 PF (WP_TEXT
, "WP_TEXT");
1998 PF (D_PAGED
, "D_PAGED");
1999 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2000 printf (_("\nstart address 0x"));
2001 printf_vma (abfd
->start_address
);
2006 dump_bfd_private_header (abfd
)
2009 bfd_print_private_bfd_data (abfd
, stdout
);
2018 if (!bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2020 bfd_nonfatal (bfd_get_filename (abfd
));
2021 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2023 list_matching_formats (matching
);
2029 /* If we are adjusting section VMA's, change them all now. Changing
2030 the BFD information is a hack. However, we must do it, or
2031 bfd_find_nearest_line will not do the right thing. */
2032 if (adjust_section_vma
!= 0)
2036 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2038 s
->vma
+= adjust_section_vma
;
2039 s
->lma
+= adjust_section_vma
;
2043 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2046 print_arelt_descr (stdout
, abfd
, true);
2047 if (dump_file_header
)
2048 dump_bfd_header (abfd
);
2049 if (dump_private_headers
)
2050 dump_bfd_private_header (abfd
);
2052 if (dump_section_headers
)
2053 dump_headers (abfd
);
2054 if (dump_symtab
|| dump_reloc_info
|| disassemble
|| dump_debugging
)
2056 syms
= slurp_symtab (abfd
);
2058 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
)
2060 dynsyms
= slurp_dynamic_symtab (abfd
);
2063 dump_symbols (abfd
, false);
2064 if (dump_dynamic_symtab
)
2065 dump_symbols (abfd
, true);
2066 if (dump_stab_section_info
)
2068 if (dump_reloc_info
&& ! disassemble
)
2070 if (dump_dynamic_reloc_info
)
2071 dump_dynamic_relocs (abfd
);
2072 if (dump_section_contents
)
2075 disassemble_data (abfd
);
2080 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2081 if (dhandle
!= NULL
)
2083 if (! print_debugging_info (stdout
, dhandle
))
2084 fprintf (stderr
, _("%s: printing debugging information failed\n"),
2085 bfd_get_filename (abfd
));
2101 display_file (filename
, target
)
2105 bfd
*file
, *arfile
= (bfd
*) NULL
;
2107 file
= bfd_openr (filename
, target
);
2110 bfd_nonfatal (filename
);
2114 if (bfd_check_format (file
, bfd_archive
) == true)
2116 bfd
*last_arfile
= NULL
;
2118 printf (_("In archive %s:\n"), bfd_get_filename (file
));
2121 bfd_set_error (bfd_error_no_error
);
2123 arfile
= bfd_openr_next_archived_file (file
, arfile
);
2126 if (bfd_get_error () != bfd_error_no_more_archived_files
)
2128 bfd_nonfatal (bfd_get_filename (file
));
2133 display_bfd (arfile
);
2135 if (last_arfile
!= NULL
)
2136 bfd_close (last_arfile
);
2137 last_arfile
= arfile
;
2140 if (last_arfile
!= NULL
)
2141 bfd_close (last_arfile
);
2149 /* Actually display the various requested regions */
2157 bfd_size_type datasize
= 0;
2159 bfd_size_type start
, stop
;
2161 for (section
= abfd
->sections
; section
!= NULL
; section
=
2166 if (only
== (char *) NULL
||
2167 strcmp (only
, section
->name
) == 0)
2169 if (section
->flags
& SEC_HAS_CONTENTS
)
2171 printf (_("Contents of section %s:\n"), section
->name
);
2173 if (bfd_section_size (abfd
, section
) == 0)
2175 data
= (bfd_byte
*) xmalloc ((size_t) bfd_section_size (abfd
, section
));
2176 datasize
= bfd_section_size (abfd
, section
);
2179 bfd_get_section_contents (abfd
, section
, (PTR
) data
, 0, bfd_section_size (abfd
, section
));
2181 if (start_address
== (bfd_vma
) -1
2182 || start_address
< section
->vma
)
2185 start
= start_address
- section
->vma
;
2186 if (stop_address
== (bfd_vma
) -1)
2187 stop
= bfd_section_size (abfd
, section
);
2190 if (stop_address
< section
->vma
)
2193 stop
= stop_address
- section
->vma
;
2194 if (stop
> bfd_section_size (abfd
, section
))
2195 stop
= bfd_section_size (abfd
, section
);
2197 for (i
= start
; i
< stop
; i
+= onaline
)
2201 printf (" %04lx ", (unsigned long int) (i
+ section
->vma
));
2202 for (j
= i
; j
< i
+ onaline
; j
++)
2205 printf ("%02x", (unsigned) (data
[j
]));
2213 for (j
= i
; j
< i
+ onaline
; j
++)
2218 printf ("%c", isprint (data
[j
]) ? data
[j
] : '.');
2228 /* Should perhaps share code and display with nm? */
2230 dump_symbols (abfd
, dynamic
)
2231 bfd
*abfd ATTRIBUTE_UNUSED
;
2244 printf ("DYNAMIC SYMBOL TABLE:\n");
2252 printf ("SYMBOL TABLE:\n");
2255 for (count
= 0; count
< max
; count
++)
2259 bfd
*cur_bfd
= bfd_asymbol_bfd (*current
);
2261 if (cur_bfd
!= NULL
)
2266 name
= bfd_asymbol_name (*current
);
2268 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2272 /* If we want to demangle the name, we demangle it
2273 here, and temporarily clobber it while calling
2274 bfd_print_symbol. FIXME: This is a gross hack. */
2277 if (bfd_get_symbol_leading_char (cur_bfd
) == *n
)
2279 alloc
= cplus_demangle (n
, DMGL_ANSI
| DMGL_PARAMS
);
2281 (*current
)->name
= alloc
;
2283 (*current
)->name
= n
;
2286 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2287 bfd_print_symbol_all
);
2289 (*current
)->name
= name
;
2310 for (a
= abfd
->sections
; a
!= (asection
*) NULL
; a
= a
->next
)
2314 if (bfd_is_abs_section (a
))
2316 if (bfd_is_und_section (a
))
2318 if (bfd_is_com_section (a
))
2323 if (strcmp (only
, a
->name
))
2326 else if ((a
->flags
& SEC_RELOC
) == 0)
2329 relsize
= bfd_get_reloc_upper_bound (abfd
, a
);
2331 bfd_fatal (bfd_get_filename (abfd
));
2333 printf ("RELOCATION RECORDS FOR [%s]:", a
->name
);
2337 printf (" (none)\n\n");
2341 relpp
= (arelent
**) xmalloc (relsize
);
2342 relcount
= bfd_canonicalize_reloc (abfd
, a
, relpp
, syms
);
2344 bfd_fatal (bfd_get_filename (abfd
));
2345 else if (relcount
== 0)
2347 printf (" (none)\n\n");
2352 dump_reloc_set (abfd
, a
, relpp
, relcount
);
2361 dump_dynamic_relocs (abfd
)
2368 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2370 bfd_fatal (bfd_get_filename (abfd
));
2372 printf ("DYNAMIC RELOCATION RECORDS");
2376 printf (" (none)\n\n");
2380 relpp
= (arelent
**) xmalloc (relsize
);
2381 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2383 bfd_fatal (bfd_get_filename (abfd
));
2384 else if (relcount
== 0)
2386 printf (" (none)\n\n");
2391 dump_reloc_set (abfd
, (asection
*) NULL
, relpp
, relcount
);
2399 dump_reloc_set (abfd
, sec
, relpp
, relcount
)
2406 char *last_filename
, *last_functionname
;
2407 unsigned int last_line
;
2409 /* Get column headers lined up reasonably. */
2415 sprintf_vma (buf
, (bfd_vma
) -1);
2416 width
= strlen (buf
) - 7;
2418 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2421 last_filename
= NULL
;
2422 last_functionname
= NULL
;
2425 for (p
= relpp
; relcount
&& *p
!= (arelent
*) NULL
; p
++, relcount
--)
2428 const char *filename
, *functionname
;
2430 const char *sym_name
;
2431 const char *section_name
;
2433 if (start_address
!= (bfd_vma
) -1
2434 && q
->address
< start_address
)
2436 if (stop_address
!= (bfd_vma
) -1
2437 && q
->address
> stop_address
)
2440 if (with_line_numbers
2442 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2443 &filename
, &functionname
, &line
))
2445 if (functionname
!= NULL
2446 && (last_functionname
== NULL
2447 || strcmp (functionname
, last_functionname
) != 0))
2449 printf ("%s():\n", functionname
);
2450 if (last_functionname
!= NULL
)
2451 free (last_functionname
);
2452 last_functionname
= xstrdup (functionname
);
2455 && (line
!= last_line
2456 || (filename
!= NULL
2457 && last_filename
!= NULL
2458 && strcmp (filename
, last_filename
) != 0)))
2460 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2462 if (last_filename
!= NULL
)
2463 free (last_filename
);
2464 if (filename
== NULL
)
2465 last_filename
= NULL
;
2467 last_filename
= xstrdup (filename
);
2471 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2473 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2474 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2479 section_name
= NULL
;
2483 printf_vma (q
->address
);
2485 printf (" %-16s ", q
->howto
->name
);
2487 printf (" %-16d ", q
->howto
->type
);
2488 objdump_print_symname (abfd
, (struct disassemble_info
*) NULL
,
2493 if (section_name
== (CONST
char *) NULL
)
2494 section_name
= "*unknown*";
2495 printf_vma (q
->address
);
2496 printf (" %-16s [%s]",
2503 printf_vma (q
->addend
);
2509 /* The length of the longest architecture name + 1. */
2510 #define LONGEST_ARCH sizeof("rs6000:6000")
2513 endian_string (endian
)
2514 enum bfd_endian endian
;
2516 if (endian
== BFD_ENDIAN_BIG
)
2517 return "big endian";
2518 else if (endian
== BFD_ENDIAN_LITTLE
)
2519 return "little endian";
2521 return "endianness unknown";
2524 /* List the targets that BFD is configured to support, each followed
2525 by its endianness and the architectures it supports. */
2528 display_target_list ()
2530 extern bfd_target
*bfd_target_vector
[];
2534 dummy_name
= choose_temp_base ();
2535 for (t
= 0; bfd_target_vector
[t
]; t
++)
2537 bfd_target
*p
= bfd_target_vector
[t
];
2538 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2541 printf ("%s\n (header %s, data %s)\n", p
->name
,
2542 endian_string (p
->header_byteorder
),
2543 endian_string (p
->byteorder
));
2547 bfd_nonfatal (dummy_name
);
2551 if (! bfd_set_format (abfd
, bfd_object
))
2553 if (bfd_get_error () != bfd_error_invalid_operation
)
2554 bfd_nonfatal (p
->name
);
2558 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2559 if (bfd_set_arch_mach (abfd
, (enum bfd_architecture
) a
, 0))
2561 bfd_printable_arch_mach ((enum bfd_architecture
) a
, 0));
2563 unlink (dummy_name
);
2567 /* Print a table showing which architectures are supported for entries
2568 FIRST through LAST-1 of bfd_target_vector (targets across,
2569 architectures down). */
2572 display_info_table (first
, last
)
2576 extern bfd_target
*bfd_target_vector
[];
2580 /* Print heading of target names. */
2581 printf ("\n%*s", (int) LONGEST_ARCH
, " ");
2582 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2583 printf ("%s ", bfd_target_vector
[t
]->name
);
2586 dummy_name
= choose_temp_base ();
2587 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2588 if (strcmp (bfd_printable_arch_mach (a
, 0), "UNKNOWN!") != 0)
2590 printf ("%*s ", (int) LONGEST_ARCH
- 1,
2591 bfd_printable_arch_mach (a
, 0));
2592 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2594 bfd_target
*p
= bfd_target_vector
[t
];
2596 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2600 bfd_nonfatal (p
->name
);
2606 if (! bfd_set_format (abfd
, bfd_object
))
2608 if (bfd_get_error () != bfd_error_invalid_operation
)
2609 bfd_nonfatal (p
->name
);
2616 if (! bfd_set_arch_mach (abfd
, a
, 0))
2621 printf ("%s ", p
->name
);
2624 int l
= strlen (p
->name
);
2632 unlink (dummy_name
);
2636 /* Print tables of all the target-architecture combinations that
2637 BFD has been configured to support. */
2640 display_target_tables ()
2643 extern bfd_target
*bfd_target_vector
[];
2647 colum
= getenv ("COLUMNS");
2649 columns
= atoi (colum
);
2654 while (bfd_target_vector
[t
] != NULL
)
2658 wid
= LONGEST_ARCH
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2660 while (wid
< columns
&& bfd_target_vector
[t
] != NULL
)
2664 newwid
= wid
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2665 if (newwid
>= columns
)
2670 display_info_table (oldt
, t
);
2677 printf (_("BFD header file version %s\n"), BFD_VERSION
);
2678 display_target_list ();
2679 display_target_tables ();
2688 char *target
= default_target
;
2689 boolean seenflag
= false;
2691 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
2692 setlocale (LC_MESSAGES
, "");
2694 bindtextdomain (PACKAGE
, LOCALEDIR
);
2695 textdomain (PACKAGE
);
2697 program_name
= *argv
;
2698 xmalloc_set_program_name (program_name
);
2700 START_PROGRESS (program_name
, 0);
2703 set_default_bfd_target ();
2705 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VCdDlfahrRtTxsSj:wE:",
2706 long_options
, (int *) 0))
2709 if (c
!= 'l' && c
!= OPTION_START_ADDRESS
&& c
!= OPTION_STOP_ADDRESS
)
2714 break; /* we've been given a long option */
2719 disassembler_options
= optarg
;
2725 with_line_numbers
= 1;
2731 dump_file_header
= true;
2734 formats_info
= true;
2737 dump_private_headers
= 1;
2740 dump_private_headers
= 1;
2742 dump_reloc_info
= 1;
2743 dump_file_header
= true;
2745 dump_section_headers
= 1;
2751 dump_dynamic_symtab
= 1;
2760 disassemble
= disassemble_all
= true;
2764 with_source_code
= true;
2767 dump_section_contents
= 1;
2770 dump_reloc_info
= 1;
2773 dump_dynamic_reloc_info
= 1;
2779 dump_section_headers
= 1;
2789 case OPTION_ADJUST_VMA
:
2790 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
2792 case OPTION_START_ADDRESS
:
2793 start_address
= parse_vma (optarg
, "--start-address");
2795 case OPTION_STOP_ADDRESS
:
2796 stop_address
= parse_vma (optarg
, "--stop-address");
2799 if (strcmp (optarg
, "B") == 0)
2800 endian
= BFD_ENDIAN_BIG
;
2801 else if (strcmp (optarg
, "L") == 0)
2802 endian
= BFD_ENDIAN_LITTLE
;
2805 fprintf (stderr
, _("%s: unrecognized -E option\n"), program_name
);
2810 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
2811 endian
= BFD_ENDIAN_BIG
;
2812 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
2813 endian
= BFD_ENDIAN_LITTLE
;
2816 fprintf (stderr
, _("%s: unrecognized --endian type `%s'\n"),
2817 program_name
, optarg
);
2827 print_version ("objdump");
2829 if (seenflag
== false)
2839 display_file ("a.out", target
);
2841 for (; optind
< argc
;)
2842 display_file (argv
[optind
++], target
);
2845 END_PROGRESS (program_name
);