1 /* objdump.c -- dump information about an object file.
2 Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 1999
3 Free Software Foundation, Inc.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
27 #include "libiberty.h"
32 #ifdef ANSI_PROTOTYPES
38 /* Internal headers for the ELF .stab-dump code - sorry. */
39 #define BYTES_IN_WORD 32
40 #include "aout/aout64.h"
42 #ifdef NEED_DECLARATION_FPRINTF
43 /* This is needed by INIT_DISASSEMBLE_INFO. */
44 extern int fprintf
PARAMS ((FILE *, const char *, ...));
48 static int exit_status
= 0;
50 static char *default_target
= NULL
; /* default at runtime */
52 static int show_version
= 0; /* show the version number */
53 static int dump_section_contents
; /* -s */
54 static int dump_section_headers
; /* -h */
55 static boolean dump_file_header
; /* -f */
56 static int dump_symtab
; /* -t */
57 static int dump_dynamic_symtab
; /* -T */
58 static int dump_reloc_info
; /* -r */
59 static int dump_dynamic_reloc_info
; /* -R */
60 static int dump_ar_hdrs
; /* -a */
61 static int dump_private_headers
; /* -p */
62 static int prefix_addresses
; /* --prefix-addresses */
63 static int with_line_numbers
; /* -l */
64 static boolean with_source_code
; /* -S */
65 static int show_raw_insn
; /* --show-raw-insn */
66 static int dump_stab_section_info
; /* --stabs */
67 static int do_demangle
; /* -C, --demangle */
68 static boolean disassemble
; /* -d */
69 static boolean disassemble_all
; /* -D */
70 static int disassemble_zeroes
; /* --disassemble-zeroes */
71 static boolean formats_info
; /* -i */
72 static char *only
; /* -j secname */
73 static int wide_output
; /* -w */
74 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
75 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
76 static int dump_debugging
; /* --debugging */
77 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
79 /* Extra info to pass to the disassembler address printing function. */
80 struct objdump_disasm_info
{
86 /* Architecture to disassemble for, or default if NULL. */
87 static char *machine
= (char *) NULL
;
89 /* Target specific options to the disassembler. */
90 static char *disassembler_options
= (char *) NULL
;
92 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
93 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
95 /* The symbol table. */
96 static asymbol
**syms
;
98 /* Number of symbols in `syms'. */
99 static long symcount
= 0;
101 /* The sorted symbol table. */
102 static asymbol
**sorted_syms
;
104 /* Number of symbols in `sorted_syms'. */
105 static long sorted_symcount
= 0;
107 /* The dynamic symbol table. */
108 static asymbol
**dynsyms
;
110 /* Number of symbols in `dynsyms'. */
111 static long dynsymcount
= 0;
113 /* Static declarations. */
116 usage
PARAMS ((FILE *, int));
119 nonfatal
PARAMS ((const char *));
122 display_file
PARAMS ((char *filename
, char *target
));
125 dump_section_header
PARAMS ((bfd
*, asection
*, PTR
));
128 dump_headers
PARAMS ((bfd
*));
131 dump_data
PARAMS ((bfd
*abfd
));
134 dump_relocs
PARAMS ((bfd
*abfd
));
137 dump_dynamic_relocs
PARAMS ((bfd
* abfd
));
140 dump_reloc_set
PARAMS ((bfd
*, asection
*, arelent
**, long));
143 dump_symbols
PARAMS ((bfd
*abfd
, boolean dynamic
));
146 dump_bfd_header
PARAMS ((bfd
*));
149 dump_bfd_private_header
PARAMS ((bfd
*));
152 display_bfd
PARAMS ((bfd
*abfd
));
155 display_target_list
PARAMS ((void));
158 display_info_table
PARAMS ((int, int));
161 display_target_tables
PARAMS ((void));
164 display_info
PARAMS ((void));
167 objdump_print_value
PARAMS ((bfd_vma
, struct disassemble_info
*, boolean
));
170 objdump_print_symname
PARAMS ((bfd
*, struct disassemble_info
*, asymbol
*));
173 find_symbol_for_address
PARAMS ((bfd
*, asection
*, bfd_vma
, boolean
, long *));
176 objdump_print_addr_with_sym
PARAMS ((bfd
*, asection
*, asymbol
*, bfd_vma
,
177 struct disassemble_info
*, boolean
));
180 objdump_print_addr
PARAMS ((bfd_vma
, struct disassemble_info
*, boolean
));
183 objdump_print_address
PARAMS ((bfd_vma
, struct disassemble_info
*));
186 show_line
PARAMS ((bfd
*, asection
*, bfd_vma
));
189 disassemble_bytes
PARAMS ((struct disassemble_info
*, disassembler_ftype
,
190 boolean
, bfd_byte
*, bfd_vma
, bfd_vma
,
191 arelent
***, arelent
**));
194 disassemble_data
PARAMS ((bfd
*));
197 endian_string
PARAMS ((enum bfd_endian
));
200 slurp_symtab
PARAMS ((bfd
*));
203 slurp_dynamic_symtab
PARAMS ((bfd
*));
206 remove_useless_symbols
PARAMS ((asymbol
**, long));
209 compare_symbols
PARAMS ((const PTR
, const PTR
));
212 compare_relocs
PARAMS ((const PTR
, const PTR
));
215 dump_stabs
PARAMS ((bfd
*));
218 read_section_stabs
PARAMS ((bfd
*, const char *, const char *));
221 print_section_stabs
PARAMS ((bfd
*, const char *, const char *));
224 usage (stream
, status
)
228 fprintf (stream
, _("Usage: %s <switches> file(s)\n"), program_name
);
229 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
230 fprintf (stream
, _("\
231 -a --archive-headers Display archive header information\n\
232 -f --file-headers Display the contents of the overall file header\n\
233 -p --private-headers Display object format specific file header contents\n\
234 -h --[section-]headers Display the contents of the section headers\n\
235 -x --all-headers Display the contents of all headers\n\
236 -d --disassemble Display assembler contents of executable sections\n\
237 -D --disassemble-all Display assembler contents of all sections\n\
238 -S --source Intermix source code with disassembly\n\
239 -s --full-contents Display the full contents of all sections requested\n\
240 -g --debugging Display debug information in object file\n\
241 -G --stabs Display the STABS contents of an ELF format file\n\
242 -t --syms Display the contents of the symbol table(s)\n\
243 -T --dynamic-syms Display the contents of the dynamic symbol table\n\
244 -r --reloc Display the relocation entries in the file\n\
245 -R --dynamic-reloc Display the dynamic relocation entries in the file\n\
246 -V --version Display this program's version number\n\
247 -i --info List object formats and architectures supported\n\
248 -H --help Display this information\n\
252 fprintf (stream
, _("\n The following switches are optional:\n"));
253 fprintf (stream
, _("\
254 -b --target <bfdname> Specify the target object format as <bfdname>\n\
255 -m --architecture <machine> Specify the target architecture as <machine>\n\
256 -j --section <name> Only display information for section <name>\n\
257 -M --disassembler-options <o> Pass text <o> on to the disassembler\n\
258 -EB --endian=big Assume big endian format when disassembling\n\
259 -EL --endian=little Assume little endian format when disassembling\n\
260 -l --line-numbers Include line numbers and filenames in output\n\
261 -C --demangle Decode mangled/processed symbol names\n\
262 -w --wide Format output for more than 80 columns\n\
263 -z --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
264 --start-address <addr> Only process data whoes address is >= <addr>\n\
265 --stop-address <addr> Only process data whoes address is <= <addr>\n\
266 --prefix-addresses Print complete address alongside disassembly\n\
267 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
268 --adjust-vma <offset> Add <offset> to all displayed section addresses\n\
270 list_supported_targets (program_name
, stream
);
272 disassembler_usage (stream
);
275 fprintf (stream
, _("Report bugs to bug-gnu-utils@gnu.org\n"));
279 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
281 #define OPTION_ENDIAN (150)
282 #define OPTION_START_ADDRESS (OPTION_ENDIAN + 1)
283 #define OPTION_STOP_ADDRESS (OPTION_START_ADDRESS + 1)
284 #define OPTION_ADJUST_VMA (OPTION_STOP_ADDRESS + 1)
286 static struct option long_options
[]=
288 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
289 {"all-headers", no_argument
, NULL
, 'x'},
290 {"private-headers", no_argument
, NULL
, 'p'},
291 {"architecture", required_argument
, NULL
, 'm'},
292 {"archive-headers", no_argument
, NULL
, 'a'},
293 {"debugging", no_argument
, NULL
, 'g'},
294 {"demangle", no_argument
, NULL
, 'C'},
295 {"disassemble", no_argument
, NULL
, 'd'},
296 {"disassemble-all", no_argument
, NULL
, 'D'},
297 {"disassembler-options", required_argument
, NULL
, 'M'},
298 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
299 {"dynamic-reloc", no_argument
, NULL
, 'R'},
300 {"dynamic-syms", no_argument
, NULL
, 'T'},
301 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
302 {"file-headers", no_argument
, NULL
, 'f'},
303 {"full-contents", no_argument
, NULL
, 's'},
304 {"headers", no_argument
, NULL
, 'h'},
305 {"help", no_argument
, NULL
, 'H'},
306 {"info", no_argument
, NULL
, 'i'},
307 {"line-numbers", no_argument
, NULL
, 'l'},
308 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
309 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
310 {"reloc", no_argument
, NULL
, 'r'},
311 {"section", required_argument
, NULL
, 'j'},
312 {"section-headers", no_argument
, NULL
, 'h'},
313 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
314 {"source", no_argument
, NULL
, 'S'},
315 {"stabs", no_argument
, NULL
, 'G'},
316 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
317 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
318 {"syms", no_argument
, NULL
, 't'},
319 {"target", required_argument
, NULL
, 'b'},
320 {"version", no_argument
, NULL
, 'V'},
321 {"wide", no_argument
, NULL
, 'w'},
322 {0, no_argument
, 0, 0}
334 dump_section_header (abfd
, section
, ignored
)
335 bfd
*abfd ATTRIBUTE_UNUSED
;
337 PTR ignored ATTRIBUTE_UNUSED
;
341 printf ("%3d %-13s %08lx ", section
->index
,
342 bfd_get_section_name (abfd
, section
),
343 (unsigned long) bfd_section_size (abfd
, section
));
344 printf_vma (bfd_get_section_vma (abfd
, section
));
346 printf_vma (section
->lma
);
347 printf (" %08lx 2**%u", section
->filepos
,
348 bfd_get_section_alignment (abfd
, section
));
354 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
356 PF (SEC_HAS_CONTENTS
, "CONTENTS");
357 PF (SEC_ALLOC
, "ALLOC");
358 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
359 PF (SEC_CONSTRUCTOR_TEXT
, "CONSTRUCTOR TEXT");
360 PF (SEC_CONSTRUCTOR_DATA
, "CONSTRUCTOR DATA");
361 PF (SEC_CONSTRUCTOR_BSS
, "CONSTRUCTOR BSS");
362 PF (SEC_LOAD
, "LOAD");
363 PF (SEC_RELOC
, "RELOC");
365 PF (SEC_BALIGN
, "BALIGN");
367 PF (SEC_READONLY
, "READONLY");
368 PF (SEC_CODE
, "CODE");
369 PF (SEC_DATA
, "DATA");
371 PF (SEC_DEBUGGING
, "DEBUGGING");
372 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
373 PF (SEC_EXCLUDE
, "EXCLUDE");
374 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
375 PF (SEC_SMALL_DATA
, "SMALL_DATA");
376 PF (SEC_SHARED
, "SHARED");
378 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
382 switch (section
->flags
& SEC_LINK_DUPLICATES
)
386 case SEC_LINK_DUPLICATES_DISCARD
:
387 ls
= "LINK_ONCE_DISCARD";
389 case SEC_LINK_DUPLICATES_ONE_ONLY
:
390 ls
= "LINK_ONCE_ONE_ONLY";
392 case SEC_LINK_DUPLICATES_SAME_SIZE
:
393 ls
= "LINK_ONCE_SAME_SIZE";
395 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
396 ls
= "LINK_ONCE_SAME_CONTENTS";
399 printf ("%s%s", comma
, ls
);
401 if (section
->comdat
!= NULL
)
402 printf (" (COMDAT %s %ld)", section
->comdat
->name
,
403 section
->comdat
->symbol
);
416 printf (_("Sections:\n"));
419 printf (_("Idx Name Size VMA LMA File off Algn"));
421 printf (_("Idx Name Size VMA LMA File off Algn"));
425 printf (_(" Flags"));
428 bfd_map_over_sections (abfd
, dump_section_header
, (PTR
) NULL
);
435 asymbol
**sy
= (asymbol
**) NULL
;
438 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
440 fprintf (stderr
, _("%s: no symbols\n"), bfd_get_filename (abfd
));
445 storage
= bfd_get_symtab_upper_bound (abfd
);
447 bfd_fatal (bfd_get_filename (abfd
));
451 sy
= (asymbol
**) xmalloc (storage
);
453 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
455 bfd_fatal (bfd_get_filename (abfd
));
457 fprintf (stderr
, _("%s: no symbols\n"), bfd_get_filename (abfd
));
461 /* Read in the dynamic symbols. */
464 slurp_dynamic_symtab (abfd
)
467 asymbol
**sy
= (asymbol
**) NULL
;
470 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
473 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
475 fprintf (stderr
, _("%s: %s: not a dynamic object\n"),
476 program_name
, bfd_get_filename (abfd
));
481 bfd_fatal (bfd_get_filename (abfd
));
486 sy
= (asymbol
**) xmalloc (storage
);
488 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
490 bfd_fatal (bfd_get_filename (abfd
));
491 if (dynsymcount
== 0)
492 fprintf (stderr
, _("%s: %s: No dynamic symbols\n"),
493 program_name
, bfd_get_filename (abfd
));
497 /* Filter out (in place) symbols that are useless for disassembly.
498 COUNT is the number of elements in SYMBOLS.
499 Return the number of useful symbols. */
502 remove_useless_symbols (symbols
, count
)
506 register asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
510 asymbol
*sym
= *in_ptr
++;
512 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
514 if (sym
->flags
& (BSF_DEBUGGING
))
516 if (bfd_is_und_section (sym
->section
)
517 || bfd_is_com_section (sym
->section
))
522 return out_ptr
- symbols
;
525 /* Sort symbols into value order. */
528 compare_symbols (ap
, bp
)
532 const asymbol
*a
= *(const asymbol
**)ap
;
533 const asymbol
*b
= *(const asymbol
**)bp
;
537 flagword aflags
, bflags
;
539 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
541 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
544 if (a
->section
> b
->section
)
546 else if (a
->section
< b
->section
)
549 an
= bfd_asymbol_name (a
);
550 bn
= bfd_asymbol_name (b
);
554 /* The symbols gnu_compiled and gcc2_compiled convey no real
555 information, so put them after other symbols with the same value. */
557 af
= (strstr (an
, "gnu_compiled") != NULL
558 || strstr (an
, "gcc2_compiled") != NULL
);
559 bf
= (strstr (bn
, "gnu_compiled") != NULL
560 || strstr (bn
, "gcc2_compiled") != NULL
);
567 /* We use a heuristic for the file name, to try to sort it after
568 more useful symbols. It may not work on non Unix systems, but it
569 doesn't really matter; the only difference is precisely which
570 symbol names get printed. */
572 #define file_symbol(s, sn, snl) \
573 (((s)->flags & BSF_FILE) != 0 \
574 || ((sn)[(snl) - 2] == '.' \
575 && ((sn)[(snl) - 1] == 'o' \
576 || (sn)[(snl) - 1] == 'a')))
578 af
= file_symbol (a
, an
, anl
);
579 bf
= file_symbol (b
, bn
, bnl
);
586 /* Try to sort global symbols before local symbols before function
587 symbols before debugging symbols. */
592 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
594 if ((aflags
& BSF_DEBUGGING
) != 0)
599 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
601 if ((aflags
& BSF_FUNCTION
) != 0)
606 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
608 if ((aflags
& BSF_LOCAL
) != 0)
613 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
615 if ((aflags
& BSF_GLOBAL
) != 0)
621 /* Symbols that start with '.' might be section names, so sort them
622 after symbols that don't start with '.'. */
623 if (an
[0] == '.' && bn
[0] != '.')
625 if (an
[0] != '.' && bn
[0] == '.')
628 /* Finally, if we can't distinguish them in any other way, try to
629 get consistent results by sorting the symbols by name. */
630 return strcmp (an
, bn
);
633 /* Sort relocs into address order. */
636 compare_relocs (ap
, bp
)
640 const arelent
*a
= *(const arelent
**)ap
;
641 const arelent
*b
= *(const arelent
**)bp
;
643 if (a
->address
> b
->address
)
645 else if (a
->address
< b
->address
)
648 /* So that associated relocations tied to the same address show up
649 in the correct order, we don't do any further sorting. */
658 /* Print VMA to STREAM. If SKIP_ZEROES is true, omit leading zeroes. */
661 objdump_print_value (vma
, info
, skip_zeroes
)
663 struct disassemble_info
*info
;
669 sprintf_vma (buf
, vma
);
674 for (p
= buf
; *p
== '0'; ++p
)
679 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
682 /* Print the name of a symbol. */
685 objdump_print_symname (abfd
, info
, sym
)
687 struct disassemble_info
*info
;
695 name
= bfd_asymbol_name (sym
);
696 if (! do_demangle
|| name
[0] == '\0')
700 /* Demangle the name. */
701 if (bfd_get_symbol_leading_char (abfd
) == name
[0])
704 alloc
= cplus_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
712 (*info
->fprintf_func
) (info
->stream
, "%s", print
);
714 printf ("%s", print
);
720 /* Locate a symbol given a bfd, a section, and a VMA. If REQUIRE_SEC
721 is true, then always require the symbol to be in the section. This
722 returns NULL if there is no suitable symbol. If PLACE is not NULL,
723 then *PLACE is set to the index of the symbol in sorted_syms. */
726 find_symbol_for_address (abfd
, sec
, vma
, require_sec
, place
)
733 /* @@ Would it speed things up to cache the last two symbols returned,
734 and maybe their address ranges? For many processors, only one memory
735 operand can be present at a time, so the 2-entry cache wouldn't be
736 constantly churned by code doing heavy memory accesses. */
738 /* Indices in `sorted_syms'. */
740 long max
= sorted_symcount
;
743 if (sorted_symcount
< 1)
746 /* Perform a binary search looking for the closest symbol to the
747 required value. We are searching the range (min, max]. */
748 while (min
+ 1 < max
)
752 thisplace
= (max
+ min
) / 2;
753 sym
= sorted_syms
[thisplace
];
755 if (bfd_asymbol_value (sym
) > vma
)
757 else if (bfd_asymbol_value (sym
) < vma
)
766 /* The symbol we want is now in min, the low end of the range we
767 were searching. If there are several symbols with the same
768 value, we want the first one. */
771 && (bfd_asymbol_value (sorted_syms
[thisplace
])
772 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
775 /* If the file is relocateable, and the symbol could be from this
776 section, prefer a symbol from this section over symbols from
777 others, even if the other symbol's value might be closer.
779 Note that this may be wrong for some symbol references if the
780 sections have overlapping memory ranges, but in that case there's
781 no way to tell what's desired without looking at the relocation
784 if (sorted_syms
[thisplace
]->section
!= sec
786 || ((abfd
->flags
& HAS_RELOC
) != 0
787 && vma
>= bfd_get_section_vma (abfd
, sec
)
788 && vma
< (bfd_get_section_vma (abfd
, sec
)
789 + bfd_section_size (abfd
, sec
)))))
793 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
795 if (bfd_asymbol_value (sorted_syms
[i
])
796 != bfd_asymbol_value (sorted_syms
[thisplace
]))
802 if (sorted_syms
[i
]->section
== sec
804 || sorted_syms
[i
- 1]->section
!= sec
805 || (bfd_asymbol_value (sorted_syms
[i
])
806 != bfd_asymbol_value (sorted_syms
[i
- 1]))))
813 if (sorted_syms
[thisplace
]->section
!= sec
)
815 /* We didn't find a good symbol with a smaller value.
816 Look for one with a larger value. */
817 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
819 if (sorted_syms
[i
]->section
== sec
)
827 if (sorted_syms
[thisplace
]->section
!= sec
829 || ((abfd
->flags
& HAS_RELOC
) != 0
830 && vma
>= bfd_get_section_vma (abfd
, sec
)
831 && vma
< (bfd_get_section_vma (abfd
, sec
)
832 + bfd_section_size (abfd
, sec
)))))
834 /* There is no suitable symbol. */
842 return sorted_syms
[thisplace
];
845 /* Print an address to INFO symbolically. */
848 objdump_print_addr_with_sym (abfd
, sec
, sym
, vma
, info
, skip_zeroes
)
853 struct disassemble_info
*info
;
856 objdump_print_value (vma
, info
, skip_zeroes
);
862 (*info
->fprintf_func
) (info
->stream
, " <%s",
863 bfd_get_section_name (abfd
, sec
));
864 secaddr
= bfd_get_section_vma (abfd
, sec
);
867 (*info
->fprintf_func
) (info
->stream
, "-0x");
868 objdump_print_value (secaddr
- vma
, info
, true);
870 else if (vma
> secaddr
)
872 (*info
->fprintf_func
) (info
->stream
, "+0x");
873 objdump_print_value (vma
- secaddr
, info
, true);
875 (*info
->fprintf_func
) (info
->stream
, ">");
879 (*info
->fprintf_func
) (info
->stream
, " <");
880 objdump_print_symname (abfd
, info
, sym
);
881 if (bfd_asymbol_value (sym
) > vma
)
883 (*info
->fprintf_func
) (info
->stream
, "-0x");
884 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, true);
886 else if (vma
> bfd_asymbol_value (sym
))
888 (*info
->fprintf_func
) (info
->stream
, "+0x");
889 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, true);
891 (*info
->fprintf_func
) (info
->stream
, ">");
895 /* Print VMA to INFO, symbolically if possible. If SKIP_ZEROES is
896 true, don't output leading zeroes. */
899 objdump_print_addr (vma
, info
, skip_zeroes
)
901 struct disassemble_info
*info
;
904 struct objdump_disasm_info
*aux
;
907 if (sorted_symcount
< 1)
909 (*info
->fprintf_func
) (info
->stream
, "0x");
910 objdump_print_value (vma
, info
, skip_zeroes
);
914 aux
= (struct objdump_disasm_info
*) info
->application_data
;
915 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
917 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
921 /* Print VMA to INFO. This function is passed to the disassembler
925 objdump_print_address (vma
, info
)
927 struct disassemble_info
*info
;
929 objdump_print_addr (vma
, info
, ! prefix_addresses
);
932 /* Determine of the given address has a symbol associated with it. */
935 objdump_symbol_at_address (vma
, info
)
937 struct disassemble_info
* info
;
939 struct objdump_disasm_info
* aux
;
942 /* No symbols - do not bother checking. */
943 if (sorted_symcount
< 1)
946 aux
= (struct objdump_disasm_info
*) info
->application_data
;
947 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
950 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
953 /* Hold the last function name and the last line number we displayed
956 static char *prev_functionname
;
957 static unsigned int prev_line
;
959 /* We keep a list of all files that we have seen when doing a
960 dissassembly with source, so that we know how much of the file to
961 display. This can be important for inlined functions. */
963 struct print_file_list
965 struct print_file_list
*next
;
971 static struct print_file_list
*print_files
;
973 /* The number of preceding context lines to show when we start
974 displaying a file for the first time. */
976 #define SHOW_PRECEDING_CONTEXT_LINES (5)
978 /* Skip ahead to a given line in a file, optionally printing each
982 skip_to_line
PARAMS ((struct print_file_list
*, unsigned int, boolean
));
985 skip_to_line (p
, line
, show
)
986 struct print_file_list
*p
;
990 while (p
->line
< line
)
994 if (fgets (buf
, sizeof buf
, p
->f
) == NULL
)
1004 if (strchr (buf
, '\n') != NULL
)
1009 /* Show the line number, or the source line, in a dissassembly
1013 show_line (abfd
, section
, off
)
1018 CONST
char *filename
;
1019 CONST
char *functionname
;
1022 if (! with_line_numbers
&& ! with_source_code
)
1025 if (! bfd_find_nearest_line (abfd
, section
, syms
, off
, &filename
,
1026 &functionname
, &line
))
1029 if (filename
!= NULL
&& *filename
== '\0')
1031 if (functionname
!= NULL
&& *functionname
== '\0')
1032 functionname
= NULL
;
1034 if (with_line_numbers
)
1036 if (functionname
!= NULL
1037 && (prev_functionname
== NULL
1038 || strcmp (functionname
, prev_functionname
) != 0))
1039 printf ("%s():\n", functionname
);
1040 if (line
> 0 && line
!= prev_line
)
1041 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
1044 if (with_source_code
1048 struct print_file_list
**pp
, *p
;
1050 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1051 if (strcmp ((*pp
)->filename
, filename
) == 0)
1057 if (p
!= print_files
)
1061 /* We have reencountered a file name which we saw
1062 earlier. This implies that either we are dumping out
1063 code from an included file, or the same file was
1064 linked in more than once. There are two common cases
1065 of an included file: inline functions in a header
1066 file, and a bison or flex skeleton file. In the
1067 former case we want to just start printing (but we
1068 back up a few lines to give context); in the latter
1069 case we want to continue from where we left off. I
1070 can't think of a good way to distinguish the cases,
1071 so I used a heuristic based on the file name. */
1072 if (strcmp (p
->filename
+ strlen (p
->filename
) - 2, ".h") != 0)
1076 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1083 p
->f
= fopen (p
->filename
, "r");
1087 skip_to_line (p
, l
, false);
1089 if (print_files
->f
!= NULL
)
1091 fclose (print_files
->f
);
1092 print_files
->f
= NULL
;
1098 skip_to_line (p
, line
, true);
1100 p
->next
= print_files
;
1108 f
= fopen (filename
, "r");
1113 p
= ((struct print_file_list
*)
1114 xmalloc (sizeof (struct print_file_list
)));
1115 p
->filename
= xmalloc (strlen (filename
) + 1);
1116 strcpy (p
->filename
, filename
);
1120 if (print_files
!= NULL
&& print_files
->f
!= NULL
)
1122 fclose (print_files
->f
);
1123 print_files
->f
= NULL
;
1125 p
->next
= print_files
;
1128 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1131 skip_to_line (p
, l
, false);
1133 skip_to_line (p
, line
, true);
1138 if (functionname
!= NULL
1139 && (prev_functionname
== NULL
1140 || strcmp (functionname
, prev_functionname
) != 0))
1142 if (prev_functionname
!= NULL
)
1143 free (prev_functionname
);
1144 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1145 strcpy (prev_functionname
, functionname
);
1148 if (line
> 0 && line
!= prev_line
)
1152 /* Pseudo FILE object for strings. */
1160 /* sprintf to a "stream" */
1163 #ifdef ANSI_PROTOTYPES
1164 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1166 objdump_sprintf (va_alist
)
1170 #ifndef ANSI_PROTOTYPES
1178 #ifdef ANSI_PROTOTYPES
1179 va_start (args
, format
);
1182 f
= va_arg (args
, SFILE
*);
1183 format
= va_arg (args
, const char *);
1186 vasprintf (&buf
, format
, args
);
1192 fprintf (stderr
, _("Out of virtual memory\n"));
1198 while ((size_t) ((f
->buffer
+ f
->size
) - f
->current
) < n
+ 1)
1202 curroff
= f
->current
- f
->buffer
;
1204 f
->buffer
= xrealloc (f
->buffer
, f
->size
);
1205 f
->current
= f
->buffer
+ curroff
;
1208 memcpy (f
->current
, buf
, n
);
1210 f
->current
[0] = '\0';
1217 /* The number of zeroes we want to see before we start skipping them.
1218 The number is arbitrarily chosen. */
1220 #define SKIP_ZEROES (8)
1222 /* The number of zeroes to skip at the end of a section. If the
1223 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1224 SKIP_ZEROES, they will be disassembled. If there are fewer than
1225 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1226 attempt to avoid disassembling zeroes inserted by section
1229 #define SKIP_ZEROES_AT_END (3)
1231 /* Disassemble some data in memory between given values. */
1234 disassemble_bytes (info
, disassemble_fn
, insns
, data
, start
, stop
, relppp
,
1236 struct disassemble_info
*info
;
1237 disassembler_ftype disassemble_fn
;
1245 struct objdump_disasm_info
*aux
;
1249 int skip_addr_chars
;
1252 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1258 bytes_per_line
= 16;
1260 /* Figure out how many characters to skip at the start of an
1261 address, to make the disassembly look nicer. We discard leading
1262 zeroes in chunks of 4, ensuring that there is always a leading
1264 skip_addr_chars
= 0;
1265 if (! prefix_addresses
)
1271 section
->vma
+ bfd_section_size (section
->owner
, section
));
1273 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1276 skip_addr_chars
+= 4;
1281 info
->insn_info_valid
= 0;
1289 boolean need_nl
= false;
1291 /* If we see more than SKIP_ZEROES bytes of zeroes, we just
1293 for (z
= i
; z
< stop
; z
++)
1296 if (! disassemble_zeroes
1297 && (info
->insn_info_valid
== 0
1298 || info
->branch_delay_insns
== 0)
1299 && (z
- i
>= SKIP_ZEROES
1300 || (z
== stop
&& z
- i
< SKIP_ZEROES_AT_END
)))
1304 /* If there are more nonzero bytes to follow, we only skip
1305 zeroes in multiples of 4, to try to avoid running over
1306 the start of an instruction which happens to start with
1309 z
= i
+ ((z
- i
) &~ 3);
1322 if (with_line_numbers
|| with_source_code
)
1323 show_line (aux
->abfd
, section
, i
);
1325 if (! prefix_addresses
)
1329 sprintf_vma (buf
, section
->vma
+ i
);
1330 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1334 printf ("%s:\t", buf
+ skip_addr_chars
);
1338 aux
->require_sec
= true;
1339 objdump_print_address (section
->vma
+ i
, info
);
1340 aux
->require_sec
= false;
1347 sfile
.buffer
= xmalloc (sfile
.size
);
1348 sfile
.current
= sfile
.buffer
;
1349 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1350 info
->stream
= (FILE *) &sfile
;
1351 info
->bytes_per_line
= 0;
1352 info
->bytes_per_chunk
= 0;
1354 /* FIXME: This is wrong. It tests the number of bytes
1355 in the last instruction, not the current one. */
1356 if (*relppp
< relppend
1357 && (**relppp
)->address
>= i
1358 && (**relppp
)->address
< i
+ bytes
)
1359 info
->flags
= INSN_HAS_RELOC
;
1363 bytes
= (*disassemble_fn
) (section
->vma
+ i
, info
);
1364 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1365 info
->stream
= stdout
;
1366 if (info
->bytes_per_line
!= 0)
1367 bytes_per_line
= info
->bytes_per_line
;
1370 if (sfile
.current
!= sfile
.buffer
)
1371 printf ("%s\n", sfile
.buffer
);
1372 free (sfile
.buffer
);
1380 bytes
= bytes_per_line
;
1381 if (i
+ bytes
> stop
)
1384 for (j
= i
; j
< i
+ bytes
; ++j
)
1386 if (isprint (data
[j
]))
1387 buf
[j
- i
] = data
[j
];
1394 if (prefix_addresses
1396 : show_raw_insn
>= 0)
1400 /* If ! prefix_addresses and ! wide_output, we print
1401 bytes_per_line bytes per line. */
1403 if (pb
> bytes_per_line
&& ! prefix_addresses
&& ! wide_output
)
1404 pb
= bytes_per_line
;
1406 if (info
->bytes_per_chunk
)
1407 bpc
= info
->bytes_per_chunk
;
1411 for (j
= i
; j
< i
+ pb
; j
+= bpc
)
1414 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1416 for (k
= bpc
- 1; k
>= 0; k
--)
1417 printf ("%02x", (unsigned) data
[j
+ k
]);
1422 for (k
= 0; k
< bpc
; k
++)
1423 printf ("%02x", (unsigned) data
[j
+ k
]);
1428 for (; pb
< bytes_per_line
; pb
+= bpc
)
1432 for (k
= 0; k
< bpc
; k
++)
1437 /* Separate raw data from instruction by extra space. */
1448 printf ("%s", sfile
.buffer
);
1449 free (sfile
.buffer
);
1452 if (prefix_addresses
1454 : show_raw_insn
>= 0)
1464 sprintf_vma (buf
, section
->vma
+ j
);
1465 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1469 printf ("%s:\t", buf
+ skip_addr_chars
);
1471 pb
+= bytes_per_line
;
1474 for (; j
< i
+ pb
; j
+= bpc
)
1478 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1480 for (k
= bpc
- 1; k
>= 0; k
--)
1481 printf ("%02x", (unsigned) data
[j
+ k
]);
1486 for (k
= 0; k
< bpc
; k
++)
1487 printf ("%02x", (unsigned) data
[j
+ k
]);
1501 && (section
->flags
& SEC_RELOC
) != 0)
1503 while ((*relppp
) < relppend
1504 && ((**relppp
)->address
>= (bfd_vma
) i
1505 && (**relppp
)->address
< (bfd_vma
) i
+ bytes
))
1516 objdump_print_value (section
->vma
+ q
->address
, info
, true);
1518 printf (": %s\t", q
->howto
->name
);
1520 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1521 printf ("*unknown*");
1524 const char *sym_name
;
1526 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1527 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1528 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1533 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1534 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1535 if (sym_name
== NULL
|| *sym_name
== '\0')
1536 sym_name
= "*unknown*";
1537 printf ("%s", sym_name
);
1544 objdump_print_value (q
->addend
, info
, true);
1560 /* Disassemble the contents of an object file. */
1563 disassemble_data (abfd
)
1567 disassembler_ftype disassemble_fn
;
1568 struct disassemble_info disasm_info
;
1569 struct objdump_disasm_info aux
;
1573 prev_functionname
= NULL
;
1576 /* We make a copy of syms to sort. We don't want to sort syms
1577 because that will screw up the relocs. */
1578 sorted_syms
= (asymbol
**) xmalloc (symcount
* sizeof (asymbol
*));
1579 memcpy (sorted_syms
, syms
, symcount
* sizeof (asymbol
*));
1581 sorted_symcount
= remove_useless_symbols (sorted_syms
, symcount
);
1583 /* Sort the symbols into section and symbol order */
1584 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1586 INIT_DISASSEMBLE_INFO(disasm_info
, stdout
, fprintf
);
1587 disasm_info
.application_data
= (PTR
) &aux
;
1589 aux
.require_sec
= false;
1590 disasm_info
.print_address_func
= objdump_print_address
;
1591 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1593 if (machine
!= (char *) NULL
)
1595 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1598 fprintf (stderr
, _("%s: Can't use supplied machine %s\n"),
1603 abfd
->arch_info
= info
;
1606 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1608 struct bfd_target
*xvec
;
1610 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
1611 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1612 xvec
->byteorder
= endian
;
1616 disassemble_fn
= disassembler (abfd
);
1617 if (!disassemble_fn
)
1619 fprintf (stderr
, _("%s: Can't disassemble for architecture %s\n"),
1621 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1626 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1627 disasm_info
.arch
= bfd_get_arch (abfd
);
1628 disasm_info
.mach
= bfd_get_mach (abfd
);
1629 disasm_info
.disassembler_options
= disassembler_options
;
1631 if (bfd_big_endian (abfd
))
1632 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1633 else if (bfd_little_endian (abfd
))
1634 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1636 /* ??? Aborting here seems too drastic. We could default to big or little
1638 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1640 for (section
= abfd
->sections
;
1641 section
!= (asection
*) NULL
;
1642 section
= section
->next
)
1644 bfd_byte
*data
= NULL
;
1645 bfd_size_type datasize
= 0;
1646 arelent
**relbuf
= NULL
;
1647 arelent
**relpp
= NULL
;
1648 arelent
**relppend
= NULL
;
1650 asymbol
*sym
= NULL
;
1653 if ((section
->flags
& SEC_LOAD
) == 0
1654 || (! disassemble_all
1656 && (section
->flags
& SEC_CODE
) == 0))
1658 if (only
!= (char *) NULL
&& strcmp (only
, section
->name
) != 0)
1662 && (section
->flags
& SEC_RELOC
) != 0)
1666 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1668 bfd_fatal (bfd_get_filename (abfd
));
1674 relbuf
= (arelent
**) xmalloc (relsize
);
1675 relcount
= bfd_canonicalize_reloc (abfd
, section
, relbuf
, syms
);
1677 bfd_fatal (bfd_get_filename (abfd
));
1679 /* Sort the relocs by address. */
1680 qsort (relbuf
, relcount
, sizeof (arelent
*), compare_relocs
);
1683 relppend
= relpp
+ relcount
;
1685 /* Skip over the relocs belonging to addresses below the
1687 if (start_address
!= (bfd_vma
) -1)
1689 while (relpp
< relppend
1690 && (*relpp
)->address
< start_address
)
1696 printf (_("Disassembly of section %s:\n"), section
->name
);
1698 datasize
= bfd_get_section_size_before_reloc (section
);
1702 data
= (bfd_byte
*) xmalloc ((size_t) datasize
);
1704 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1707 disasm_info
.buffer
= data
;
1708 disasm_info
.buffer_vma
= section
->vma
;
1709 disasm_info
.buffer_length
= datasize
;
1710 if (start_address
== (bfd_vma
) -1
1711 || start_address
< disasm_info
.buffer_vma
)
1714 i
= start_address
- disasm_info
.buffer_vma
;
1715 if (stop_address
== (bfd_vma
) -1)
1719 if (stop_address
< disasm_info
.buffer_vma
)
1722 stop
= stop_address
- disasm_info
.buffer_vma
;
1723 if (stop
> disasm_info
.buffer_length
)
1724 stop
= disasm_info
.buffer_length
;
1727 sym
= find_symbol_for_address (abfd
, section
, section
->vma
+ i
,
1736 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= section
->vma
+ i
)
1741 (x
< sorted_symcount
1742 && bfd_asymbol_value (sorted_syms
[x
]) <= section
->vma
+ i
);
1745 disasm_info
.symbols
= & sorted_syms
[place
];
1746 disasm_info
.num_symbols
= x
- place
;
1749 disasm_info
.symbols
= NULL
;
1751 if (! prefix_addresses
)
1754 objdump_print_addr_with_sym (abfd
, section
, sym
,
1761 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ i
)
1763 else if (sym
== NULL
)
1767 /* Search forward for the next appropriate symbol in
1768 SECTION. Note that all the symbols are sorted
1769 together into one big array, and that some sections
1770 may have overlapping addresses. */
1771 while (place
< sorted_symcount
1772 && (sorted_syms
[place
]->section
!= section
1773 || (bfd_asymbol_value (sorted_syms
[place
])
1774 <= bfd_asymbol_value (sym
))))
1776 if (place
>= sorted_symcount
)
1779 nextsym
= sorted_syms
[place
];
1782 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ i
)
1784 nextstop
= bfd_asymbol_value (sym
) - section
->vma
;
1785 if (nextstop
> stop
)
1788 else if (nextsym
== NULL
)
1792 nextstop
= bfd_asymbol_value (nextsym
) - section
->vma
;
1793 if (nextstop
> stop
)
1797 /* If a symbol is explicitly marked as being an object
1798 rather than a function, just dump the bytes without
1799 disassembling them. */
1802 || bfd_asymbol_value (sym
) > section
->vma
+ i
1803 || ((sym
->flags
& BSF_OBJECT
) == 0
1804 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1806 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1808 || (sym
->flags
& BSF_FUNCTION
) != 0)
1813 disassemble_bytes (&disasm_info
, disassemble_fn
, insns
, data
, i
,
1814 nextstop
, &relpp
, relppend
);
1828 /* Define a table of stab values and print-strings. We wish the initializer
1829 could be a direct-mapped table, but instead we build one the first
1832 static void dump_section_stabs
PARAMS ((bfd
*abfd
, char *stabsect_name
,
1833 char *strsect_name
));
1835 /* Dump the stabs sections from an object file that has a section that
1836 uses Sun stabs encoding. */
1842 dump_section_stabs (abfd
, ".stab", ".stabstr");
1843 dump_section_stabs (abfd
, ".stab.excl", ".stab.exclstr");
1844 dump_section_stabs (abfd
, ".stab.index", ".stab.indexstr");
1845 dump_section_stabs (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1848 static bfd_byte
*stabs
;
1849 static bfd_size_type stab_size
;
1851 static char *strtab
;
1852 static bfd_size_type stabstr_size
;
1854 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1855 and string table section STRSECT_NAME into `strtab'.
1856 If the section exists and was read, allocate the space and return true.
1857 Otherwise return false. */
1860 read_section_stabs (abfd
, stabsect_name
, strsect_name
)
1862 const char *stabsect_name
;
1863 const char *strsect_name
;
1865 asection
*stabsect
, *stabstrsect
;
1867 stabsect
= bfd_get_section_by_name (abfd
, stabsect_name
);
1870 printf (_("No %s section present\n\n"), stabsect_name
);
1874 stabstrsect
= bfd_get_section_by_name (abfd
, strsect_name
);
1875 if (0 == stabstrsect
)
1877 fprintf (stderr
, _("%s: %s has no %s section\n"), program_name
,
1878 bfd_get_filename (abfd
), strsect_name
);
1883 stab_size
= bfd_section_size (abfd
, stabsect
);
1884 stabstr_size
= bfd_section_size (abfd
, stabstrsect
);
1886 stabs
= (bfd_byte
*) xmalloc (stab_size
);
1887 strtab
= (char *) xmalloc (stabstr_size
);
1889 if (! bfd_get_section_contents (abfd
, stabsect
, (PTR
) stabs
, 0, stab_size
))
1891 fprintf (stderr
, _("%s: Reading %s section of %s failed: %s\n"),
1892 program_name
, stabsect_name
, bfd_get_filename (abfd
),
1893 bfd_errmsg (bfd_get_error ()));
1900 if (! bfd_get_section_contents (abfd
, stabstrsect
, (PTR
) strtab
, 0,
1903 fprintf (stderr
, _("%s: Reading %s section of %s failed: %s\n"),
1904 program_name
, strsect_name
, bfd_get_filename (abfd
),
1905 bfd_errmsg (bfd_get_error ()));
1915 /* Stabs entries use a 12 byte format:
1916 4 byte string table index
1918 1 byte stab other field
1919 2 byte stab desc field
1921 FIXME: This will have to change for a 64 bit object format. */
1923 #define STRDXOFF (0)
1925 #define OTHEROFF (5)
1928 #define STABSIZE (12)
1930 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1931 using string table section STRSECT_NAME (in `strtab'). */
1934 print_section_stabs (abfd
, stabsect_name
, strsect_name
)
1936 const char *stabsect_name
;
1937 const char *strsect_name ATTRIBUTE_UNUSED
;
1940 unsigned file_string_table_offset
= 0, next_file_string_table_offset
= 0;
1941 bfd_byte
*stabp
, *stabs_end
;
1944 stabs_end
= stabp
+ stab_size
;
1946 printf (_("Contents of %s section:\n\n"), stabsect_name
);
1947 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1949 /* Loop through all symbols and print them.
1951 We start the index at -1 because there is a dummy symbol on
1952 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1954 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
1958 unsigned char type
, other
;
1959 unsigned short desc
;
1962 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
1963 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
1964 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
1965 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
1966 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
1968 printf ("\n%-6d ", i
);
1969 /* Either print the stab name, or, if unnamed, print its number
1970 again (makes consistent formatting for tools like awk). */
1971 name
= bfd_get_stab_name (type
);
1973 printf ("%-6s", name
);
1974 else if (type
== N_UNDF
)
1977 printf ("%-6d", type
);
1978 printf (" %-6d %-6d ", other
, desc
);
1980 printf (" %-6lu", strx
);
1982 /* Symbols with type == 0 (N_UNDF) specify the length of the
1983 string table associated with this file. We use that info
1984 to know how to relocate the *next* file's string table indices. */
1988 file_string_table_offset
= next_file_string_table_offset
;
1989 next_file_string_table_offset
+= value
;
1993 /* Using the (possibly updated) string table offset, print the
1994 string (if any) associated with this symbol. */
1996 if ((strx
+ file_string_table_offset
) < stabstr_size
)
1997 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
2006 dump_section_stabs (abfd
, stabsect_name
, strsect_name
)
2008 char *stabsect_name
;
2013 /* Check for section names for which stabsect_name is a prefix, to
2014 handle .stab0, etc. */
2015 for (s
= abfd
->sections
;
2021 len
= strlen (stabsect_name
);
2023 /* If the prefix matches, and the files section name ends with a
2024 nul or a digit, then we match. I.e., we want either an exact
2025 match or a section followed by a number. */
2026 if (strncmp (stabsect_name
, s
->name
, len
) == 0
2027 && (s
->name
[len
] == '\000'
2028 || isdigit ((unsigned char) s
->name
[len
])))
2030 if (read_section_stabs (abfd
, s
->name
, strsect_name
))
2032 print_section_stabs (abfd
, s
->name
, strsect_name
);
2041 dump_bfd_header (abfd
)
2046 printf (_("architecture: %s, "),
2047 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2048 bfd_get_mach (abfd
)));
2049 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2051 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2052 PF (HAS_RELOC
, "HAS_RELOC");
2053 PF (EXEC_P
, "EXEC_P");
2054 PF (HAS_LINENO
, "HAS_LINENO");
2055 PF (HAS_DEBUG
, "HAS_DEBUG");
2056 PF (HAS_SYMS
, "HAS_SYMS");
2057 PF (HAS_LOCALS
, "HAS_LOCALS");
2058 PF (DYNAMIC
, "DYNAMIC");
2059 PF (WP_TEXT
, "WP_TEXT");
2060 PF (D_PAGED
, "D_PAGED");
2061 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2062 printf (_("\nstart address 0x"));
2063 printf_vma (abfd
->start_address
);
2068 dump_bfd_private_header (abfd
)
2071 bfd_print_private_bfd_data (abfd
, stdout
);
2074 /* Dump selected contents of ABFD */
2080 /* If we are adjusting section VMA's, change them all now. Changing
2081 the BFD information is a hack. However, we must do it, or
2082 bfd_find_nearest_line will not do the right thing. */
2083 if (adjust_section_vma
!= 0)
2087 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2089 s
->vma
+= adjust_section_vma
;
2090 s
->lma
+= adjust_section_vma
;
2094 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2097 print_arelt_descr (stdout
, abfd
, true);
2098 if (dump_file_header
)
2099 dump_bfd_header (abfd
);
2100 if (dump_private_headers
)
2101 dump_bfd_private_header (abfd
);
2103 if (dump_section_headers
)
2104 dump_headers (abfd
);
2105 if (dump_symtab
|| dump_reloc_info
|| disassemble
|| dump_debugging
)
2107 syms
= slurp_symtab (abfd
);
2109 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
)
2111 dynsyms
= slurp_dynamic_symtab (abfd
);
2114 dump_symbols (abfd
, false);
2115 if (dump_dynamic_symtab
)
2116 dump_symbols (abfd
, true);
2117 if (dump_stab_section_info
)
2119 if (dump_reloc_info
&& ! disassemble
)
2121 if (dump_dynamic_reloc_info
)
2122 dump_dynamic_relocs (abfd
);
2123 if (dump_section_contents
)
2126 disassemble_data (abfd
);
2131 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2132 if (dhandle
!= NULL
)
2134 if (! print_debugging_info (stdout
, dhandle
))
2137 _("%s: printing debugging information failed\n"),
2138 bfd_get_filename (abfd
));
2161 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2167 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2169 nonfatal (bfd_get_filename (abfd
));
2170 list_matching_formats (matching
);
2175 if (bfd_get_error () != bfd_error_file_not_recognized
)
2177 nonfatal (bfd_get_filename (abfd
));
2181 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
2187 nonfatal (bfd_get_filename (abfd
));
2189 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2191 list_matching_formats (matching
);
2197 display_file (filename
, target
)
2201 bfd
*file
, *arfile
= (bfd
*) NULL
;
2203 file
= bfd_openr (filename
, target
);
2206 nonfatal (filename
);
2210 if (bfd_check_format (file
, bfd_archive
) == true)
2212 bfd
*last_arfile
= NULL
;
2214 printf (_("In archive %s:\n"), bfd_get_filename (file
));
2217 bfd_set_error (bfd_error_no_error
);
2219 arfile
= bfd_openr_next_archived_file (file
, arfile
);
2222 if (bfd_get_error () != bfd_error_no_more_archived_files
)
2223 nonfatal (bfd_get_filename (file
));
2227 display_bfd (arfile
);
2229 if (last_arfile
!= NULL
)
2230 bfd_close (last_arfile
);
2231 last_arfile
= arfile
;
2234 if (last_arfile
!= NULL
)
2235 bfd_close (last_arfile
);
2243 /* Actually display the various requested regions */
2251 bfd_size_type datasize
= 0;
2253 bfd_size_type start
, stop
;
2255 for (section
= abfd
->sections
; section
!= NULL
; section
=
2260 if (only
== (char *) NULL
||
2261 strcmp (only
, section
->name
) == 0)
2263 if (section
->flags
& SEC_HAS_CONTENTS
)
2265 printf (_("Contents of section %s:\n"), section
->name
);
2267 if (bfd_section_size (abfd
, section
) == 0)
2269 data
= (bfd_byte
*) xmalloc ((size_t) bfd_section_size (abfd
, section
));
2270 datasize
= bfd_section_size (abfd
, section
);
2273 bfd_get_section_contents (abfd
, section
, (PTR
) data
, 0, bfd_section_size (abfd
, section
));
2275 if (start_address
== (bfd_vma
) -1
2276 || start_address
< section
->vma
)
2279 start
= start_address
- section
->vma
;
2280 if (stop_address
== (bfd_vma
) -1)
2281 stop
= bfd_section_size (abfd
, section
);
2284 if (stop_address
< section
->vma
)
2287 stop
= stop_address
- section
->vma
;
2288 if (stop
> bfd_section_size (abfd
, section
))
2289 stop
= bfd_section_size (abfd
, section
);
2291 for (i
= start
; i
< stop
; i
+= onaline
)
2295 printf (" %04lx ", (unsigned long int) (i
+ section
->vma
));
2296 for (j
= i
; j
< i
+ onaline
; j
++)
2299 printf ("%02x", (unsigned) (data
[j
]));
2307 for (j
= i
; j
< i
+ onaline
; j
++)
2312 printf ("%c", isprint (data
[j
]) ? data
[j
] : '.');
2322 /* Should perhaps share code and display with nm? */
2324 dump_symbols (abfd
, dynamic
)
2325 bfd
*abfd ATTRIBUTE_UNUSED
;
2338 printf ("DYNAMIC SYMBOL TABLE:\n");
2346 printf ("SYMBOL TABLE:\n");
2349 for (count
= 0; count
< max
; count
++)
2353 bfd
*cur_bfd
= bfd_asymbol_bfd (*current
);
2355 if (cur_bfd
!= NULL
)
2360 name
= bfd_asymbol_name (*current
);
2362 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2366 /* If we want to demangle the name, we demangle it
2367 here, and temporarily clobber it while calling
2368 bfd_print_symbol. FIXME: This is a gross hack. */
2371 if (bfd_get_symbol_leading_char (cur_bfd
) == *n
)
2373 alloc
= cplus_demangle (n
, DMGL_ANSI
| DMGL_PARAMS
);
2375 (*current
)->name
= alloc
;
2377 (*current
)->name
= n
;
2380 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2381 bfd_print_symbol_all
);
2383 (*current
)->name
= name
;
2404 for (a
= abfd
->sections
; a
!= (asection
*) NULL
; a
= a
->next
)
2408 if (bfd_is_abs_section (a
))
2410 if (bfd_is_und_section (a
))
2412 if (bfd_is_com_section (a
))
2417 if (strcmp (only
, a
->name
))
2420 else if ((a
->flags
& SEC_RELOC
) == 0)
2423 relsize
= bfd_get_reloc_upper_bound (abfd
, a
);
2425 bfd_fatal (bfd_get_filename (abfd
));
2427 printf ("RELOCATION RECORDS FOR [%s]:", a
->name
);
2431 printf (" (none)\n\n");
2435 relpp
= (arelent
**) xmalloc (relsize
);
2436 relcount
= bfd_canonicalize_reloc (abfd
, a
, relpp
, syms
);
2438 bfd_fatal (bfd_get_filename (abfd
));
2439 else if (relcount
== 0)
2441 printf (" (none)\n\n");
2446 dump_reloc_set (abfd
, a
, relpp
, relcount
);
2455 dump_dynamic_relocs (abfd
)
2462 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2464 bfd_fatal (bfd_get_filename (abfd
));
2466 printf ("DYNAMIC RELOCATION RECORDS");
2470 printf (" (none)\n\n");
2474 relpp
= (arelent
**) xmalloc (relsize
);
2475 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2477 bfd_fatal (bfd_get_filename (abfd
));
2478 else if (relcount
== 0)
2480 printf (" (none)\n\n");
2485 dump_reloc_set (abfd
, (asection
*) NULL
, relpp
, relcount
);
2493 dump_reloc_set (abfd
, sec
, relpp
, relcount
)
2500 char *last_filename
, *last_functionname
;
2501 unsigned int last_line
;
2503 /* Get column headers lined up reasonably. */
2509 sprintf_vma (buf
, (bfd_vma
) -1);
2510 width
= strlen (buf
) - 7;
2512 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2515 last_filename
= NULL
;
2516 last_functionname
= NULL
;
2519 for (p
= relpp
; relcount
&& *p
!= (arelent
*) NULL
; p
++, relcount
--)
2522 const char *filename
, *functionname
;
2524 const char *sym_name
;
2525 const char *section_name
;
2527 if (start_address
!= (bfd_vma
) -1
2528 && q
->address
< start_address
)
2530 if (stop_address
!= (bfd_vma
) -1
2531 && q
->address
> stop_address
)
2534 if (with_line_numbers
2536 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2537 &filename
, &functionname
, &line
))
2539 if (functionname
!= NULL
2540 && (last_functionname
== NULL
2541 || strcmp (functionname
, last_functionname
) != 0))
2543 printf ("%s():\n", functionname
);
2544 if (last_functionname
!= NULL
)
2545 free (last_functionname
);
2546 last_functionname
= xstrdup (functionname
);
2549 && (line
!= last_line
2550 || (filename
!= NULL
2551 && last_filename
!= NULL
2552 && strcmp (filename
, last_filename
) != 0)))
2554 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2556 if (last_filename
!= NULL
)
2557 free (last_filename
);
2558 if (filename
== NULL
)
2559 last_filename
= NULL
;
2561 last_filename
= xstrdup (filename
);
2565 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2567 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2568 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2573 section_name
= NULL
;
2577 printf_vma (q
->address
);
2579 printf (" %-16s ", q
->howto
->name
);
2581 printf (" %-16d ", q
->howto
->type
);
2582 objdump_print_symname (abfd
, (struct disassemble_info
*) NULL
,
2587 if (section_name
== (CONST
char *) NULL
)
2588 section_name
= "*unknown*";
2589 printf_vma (q
->address
);
2590 printf (" %-16s [%s]",
2597 printf_vma (q
->addend
);
2603 /* The length of the longest architecture name + 1. */
2604 #define LONGEST_ARCH sizeof("rs6000:6000")
2607 endian_string (endian
)
2608 enum bfd_endian endian
;
2610 if (endian
== BFD_ENDIAN_BIG
)
2611 return "big endian";
2612 else if (endian
== BFD_ENDIAN_LITTLE
)
2613 return "little endian";
2615 return "endianness unknown";
2618 /* List the targets that BFD is configured to support, each followed
2619 by its endianness and the architectures it supports. */
2622 display_target_list ()
2624 extern bfd_target
*bfd_target_vector
[];
2628 dummy_name
= choose_temp_base ();
2629 for (t
= 0; bfd_target_vector
[t
]; t
++)
2631 bfd_target
*p
= bfd_target_vector
[t
];
2632 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2635 printf ("%s\n (header %s, data %s)\n", p
->name
,
2636 endian_string (p
->header_byteorder
),
2637 endian_string (p
->byteorder
));
2641 nonfatal (dummy_name
);
2645 if (! bfd_set_format (abfd
, bfd_object
))
2647 if (bfd_get_error () != bfd_error_invalid_operation
)
2652 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2653 if (bfd_set_arch_mach (abfd
, (enum bfd_architecture
) a
, 0))
2655 bfd_printable_arch_mach ((enum bfd_architecture
) a
, 0));
2657 unlink (dummy_name
);
2661 /* Print a table showing which architectures are supported for entries
2662 FIRST through LAST-1 of bfd_target_vector (targets across,
2663 architectures down). */
2666 display_info_table (first
, last
)
2670 extern bfd_target
*bfd_target_vector
[];
2674 /* Print heading of target names. */
2675 printf ("\n%*s", (int) LONGEST_ARCH
, " ");
2676 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2677 printf ("%s ", bfd_target_vector
[t
]->name
);
2680 dummy_name
= choose_temp_base ();
2681 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2682 if (strcmp (bfd_printable_arch_mach (a
, 0), "UNKNOWN!") != 0)
2684 printf ("%*s ", (int) LONGEST_ARCH
- 1,
2685 bfd_printable_arch_mach (a
, 0));
2686 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2688 bfd_target
*p
= bfd_target_vector
[t
];
2690 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2700 if (! bfd_set_format (abfd
, bfd_object
))
2702 if (bfd_get_error () != bfd_error_invalid_operation
)
2710 if (! bfd_set_arch_mach (abfd
, a
, 0))
2715 printf ("%s ", p
->name
);
2718 int l
= strlen (p
->name
);
2726 unlink (dummy_name
);
2730 /* Print tables of all the target-architecture combinations that
2731 BFD has been configured to support. */
2734 display_target_tables ()
2737 extern bfd_target
*bfd_target_vector
[];
2741 colum
= getenv ("COLUMNS");
2743 columns
= atoi (colum
);
2748 while (bfd_target_vector
[t
] != NULL
)
2752 wid
= LONGEST_ARCH
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2754 while (wid
< columns
&& bfd_target_vector
[t
] != NULL
)
2758 newwid
= wid
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2759 if (newwid
>= columns
)
2764 display_info_table (oldt
, t
);
2771 printf (_("BFD header file version %s\n"), BFD_VERSION
);
2772 display_target_list ();
2773 display_target_tables ();
2782 char *target
= default_target
;
2783 boolean seenflag
= false;
2785 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
2786 setlocale (LC_MESSAGES
, "");
2788 bindtextdomain (PACKAGE
, LOCALEDIR
);
2789 textdomain (PACKAGE
);
2791 program_name
= *argv
;
2792 xmalloc_set_program_name (program_name
);
2794 START_PROGRESS (program_name
, 0);
2797 set_default_bfd_target ();
2799 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VCdDlfahHrRtTxsSj:wE:zgG",
2800 long_options
, (int *) 0))
2806 break; /* we've been given a long option */
2811 disassembler_options
= optarg
;
2817 with_line_numbers
= true;
2828 case OPTION_ADJUST_VMA
:
2829 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
2831 case OPTION_START_ADDRESS
:
2832 start_address
= parse_vma (optarg
, "--start-address");
2834 case OPTION_STOP_ADDRESS
:
2835 stop_address
= parse_vma (optarg
, "--stop-address");
2838 if (strcmp (optarg
, "B") == 0)
2839 endian
= BFD_ENDIAN_BIG
;
2840 else if (strcmp (optarg
, "L") == 0)
2841 endian
= BFD_ENDIAN_LITTLE
;
2844 fprintf (stderr
, _("%s: unrecognized -E option\n"),
2850 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
2851 endian
= BFD_ENDIAN_BIG
;
2852 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
2853 endian
= BFD_ENDIAN_LITTLE
;
2856 fprintf (stderr
, _("%s: unrecognized --endian type `%s'\n"),
2857 program_name
, optarg
);
2863 dump_file_header
= true;
2867 formats_info
= true;
2871 dump_private_headers
= true;
2875 dump_private_headers
= true;
2877 dump_reloc_info
= true;
2878 dump_file_header
= true;
2879 dump_ar_hdrs
= true;
2880 dump_section_headers
= true;
2888 dump_dynamic_symtab
= true;
2896 disassemble_zeroes
= true;
2900 disassemble_all
= true;
2905 with_source_code
= true;
2913 dump_stab_section_info
= true;
2917 dump_section_contents
= true;
2921 dump_reloc_info
= true;
2925 dump_dynamic_reloc_info
= true;
2929 dump_ar_hdrs
= true;
2933 dump_section_headers
= true;
2940 show_version
= true;
2950 print_version ("objdump");
2952 if (seenflag
== false)
2960 display_file ("a.out", target
);
2962 for (; optind
< argc
;)
2963 display_file (argv
[optind
++], target
);
2966 END_PROGRESS (program_name
);