1 /* objdump.c -- dump information about an object file.
2 Copyright 1990, 91, 92, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26 #include "libiberty.h"
31 #ifdef ANSI_PROTOTYPES
37 /* Internal headers for the ELF .stab-dump code - sorry. */
38 #define BYTES_IN_WORD 32
39 #include "aout/aout64.h"
41 #ifdef NEED_DECLARATION_FPRINTF
42 /* This is needed by INIT_DISASSEMBLE_INFO. */
43 extern int fprintf
PARAMS ((FILE *, const char *, ...));
46 static char *default_target
= NULL
; /* default at runtime */
48 static int show_version
= 0; /* show the version number */
49 static int dump_section_contents
; /* -s */
50 static int dump_section_headers
; /* -h */
51 static boolean dump_file_header
; /* -f */
52 static int dump_symtab
; /* -t */
53 static int dump_dynamic_symtab
; /* -T */
54 static int dump_reloc_info
; /* -r */
55 static int dump_dynamic_reloc_info
; /* -R */
56 static int dump_ar_hdrs
; /* -a */
57 static int dump_private_headers
; /* -p */
58 static int prefix_addresses
; /* --prefix-addresses */
59 static int with_line_numbers
; /* -l */
60 static boolean with_source_code
; /* -S */
61 static int show_raw_insn
; /* --show-raw-insn */
62 static int dump_stab_section_info
; /* --stabs */
63 static int do_demangle
; /* -C, --demangle */
64 static boolean disassemble
; /* -d */
65 static boolean disassemble_all
; /* -D */
66 static int disassemble_zeroes
; /* --disassemble-zeroes */
67 static boolean formats_info
; /* -i */
68 static char *only
; /* -j secname */
69 static int wide_output
; /* -w */
70 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
71 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
72 static int dump_debugging
; /* --debugging */
73 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
75 /* Extra info to pass to the disassembler address printing function. */
76 struct objdump_disasm_info
{
82 /* Architecture to disassemble for, or default if NULL. */
83 static char *machine
= (char *) NULL
;
85 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
86 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
88 /* The symbol table. */
89 static asymbol
**syms
;
91 /* Number of symbols in `syms'. */
92 static long symcount
= 0;
94 /* The sorted symbol table. */
95 static asymbol
**sorted_syms
;
97 /* Number of symbols in `sorted_syms'. */
98 static long sorted_symcount
= 0;
100 /* The dynamic symbol table. */
101 static asymbol
**dynsyms
;
103 /* Number of symbols in `dynsyms'. */
104 static long dynsymcount
= 0;
106 /* Static declarations. */
109 usage
PARAMS ((FILE *, int));
112 display_file
PARAMS ((char *filename
, char *target
));
115 dump_section_header
PARAMS ((bfd
*, asection
*, PTR
));
118 dump_headers
PARAMS ((bfd
*));
121 dump_data
PARAMS ((bfd
*abfd
));
124 dump_relocs
PARAMS ((bfd
*abfd
));
127 dump_dynamic_relocs
PARAMS ((bfd
* abfd
));
130 dump_reloc_set
PARAMS ((bfd
*, asection
*, arelent
**, long));
133 dump_symbols
PARAMS ((bfd
*abfd
, boolean dynamic
));
136 dump_bfd_header
PARAMS ((bfd
*));
139 dump_bfd_private_header
PARAMS ((bfd
*));
142 display_bfd
PARAMS ((bfd
*abfd
));
145 display_target_list
PARAMS ((void));
148 display_info_table
PARAMS ((int, int));
151 display_target_tables
PARAMS ((void));
154 display_info
PARAMS ((void));
157 objdump_print_value
PARAMS ((bfd_vma
, struct disassemble_info
*, boolean
));
160 objdump_print_symname
PARAMS ((bfd
*, struct disassemble_info
*, asymbol
*));
163 find_symbol_for_address
PARAMS ((bfd
*, asection
*, bfd_vma
, boolean
, long *));
166 objdump_print_addr_with_sym
PARAMS ((bfd
*, asection
*, asymbol
*, bfd_vma
,
167 struct disassemble_info
*, boolean
));
170 objdump_print_addr
PARAMS ((bfd_vma
, struct disassemble_info
*, boolean
));
173 objdump_print_address
PARAMS ((bfd_vma
, struct disassemble_info
*));
176 show_line
PARAMS ((bfd
*, asection
*, bfd_vma
));
179 disassemble_bytes
PARAMS ((struct disassemble_info
*, disassembler_ftype
,
180 boolean
, bfd_byte
*, long, long, arelent
***,
184 disassemble_data
PARAMS ((bfd
*));
187 endian_string
PARAMS ((enum bfd_endian
));
190 slurp_symtab
PARAMS ((bfd
*));
193 slurp_dynamic_symtab
PARAMS ((bfd
*));
196 remove_useless_symbols
PARAMS ((asymbol
**, long));
199 compare_symbols
PARAMS ((const PTR
, const PTR
));
202 compare_relocs
PARAMS ((const PTR
, const PTR
));
205 dump_stabs
PARAMS ((bfd
*));
208 read_section_stabs
PARAMS ((bfd
*, const char *, const char *));
211 print_section_stabs
PARAMS ((bfd
*, const char *, const char *));
214 usage (stream
, status
)
219 Usage: %s [-ahifCdDprRtTxsSlw] [-b bfdname] [-m machine] [-j section-name]\n\
220 [--archive-headers] [--target=bfdname] [--debugging] [--disassemble]\n\
221 [--disassemble-all] [--disassemble-zeroes] [--file-headers]\n\
222 [--section-headers] [--headers]\n\
223 [--info] [--section=section-name] [--line-numbers] [--source]\n",
226 [--architecture=machine] [--reloc] [--full-contents] [--stabs]\n\
227 [--syms] [--all-headers] [--dynamic-syms] [--dynamic-reloc]\n\
228 [--wide] [--version] [--help] [--private-headers]\n\
229 [--start-address=addr] [--stop-address=addr]\n\
230 [--prefix-addresses] [--[no-]show-raw-insn] [--demangle]\n\
231 [--adjust-vma=offset] [-EB|-EL] [--endian={big|little}] objfile...\n\
232 at least one option besides -l (--line-numbers) must be given\n");
233 list_supported_targets (program_name
, stream
);
235 fprintf (stream
, "Report bugs to bug-gnu-utils@prep.ai.mit.edu\n");
239 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
241 #define OPTION_ENDIAN (150)
242 #define OPTION_START_ADDRESS (OPTION_ENDIAN + 1)
243 #define OPTION_STOP_ADDRESS (OPTION_START_ADDRESS + 1)
244 #define OPTION_ADJUST_VMA (OPTION_STOP_ADDRESS + 1)
246 static struct option long_options
[]=
248 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
249 {"all-headers", no_argument
, NULL
, 'x'},
250 {"private-headers", no_argument
, NULL
, 'p'},
251 {"architecture", required_argument
, NULL
, 'm'},
252 {"archive-headers", no_argument
, NULL
, 'a'},
253 {"debugging", no_argument
, &dump_debugging
, 1},
254 {"demangle", no_argument
, &do_demangle
, 1},
255 {"disassemble", no_argument
, NULL
, 'd'},
256 {"disassemble-all", no_argument
, NULL
, 'D'},
257 {"disassemble-zeroes", no_argument
, &disassemble_zeroes
, 1},
258 {"dynamic-reloc", no_argument
, NULL
, 'R'},
259 {"dynamic-syms", no_argument
, NULL
, 'T'},
260 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
261 {"file-headers", no_argument
, NULL
, 'f'},
262 {"full-contents", no_argument
, NULL
, 's'},
263 {"headers", no_argument
, NULL
, 'h'},
264 {"help", no_argument
, NULL
, 'H'},
265 {"info", no_argument
, NULL
, 'i'},
266 {"line-numbers", no_argument
, NULL
, 'l'},
267 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
268 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
269 {"reloc", no_argument
, NULL
, 'r'},
270 {"section", required_argument
, NULL
, 'j'},
271 {"section-headers", no_argument
, NULL
, 'h'},
272 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
273 {"source", no_argument
, NULL
, 'S'},
274 {"stabs", no_argument
, &dump_stab_section_info
, 1},
275 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
276 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
277 {"syms", no_argument
, NULL
, 't'},
278 {"target", required_argument
, NULL
, 'b'},
279 {"version", no_argument
, &show_version
, 1},
280 {"wide", no_argument
, &wide_output
, 'w'},
281 {0, no_argument
, 0, 0}
285 dump_section_header (abfd
, section
, ignored
)
292 printf ("%3d %-13s %08lx ", section
->index
,
293 bfd_get_section_name (abfd
, section
),
294 (unsigned long) bfd_section_size (abfd
, section
));
295 printf_vma (bfd_get_section_vma (abfd
, section
));
297 printf_vma (section
->lma
);
298 printf (" %08lx 2**%u", section
->filepos
,
299 bfd_get_section_alignment (abfd
, section
));
305 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
307 PF (SEC_HAS_CONTENTS
, "CONTENTS");
308 PF (SEC_ALLOC
, "ALLOC");
309 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
310 PF (SEC_CONSTRUCTOR_TEXT
, "CONSTRUCTOR TEXT");
311 PF (SEC_CONSTRUCTOR_DATA
, "CONSTRUCTOR DATA");
312 PF (SEC_CONSTRUCTOR_BSS
, "CONSTRUCTOR BSS");
313 PF (SEC_LOAD
, "LOAD");
314 PF (SEC_RELOC
, "RELOC");
316 PF (SEC_BALIGN
, "BALIGN");
318 PF (SEC_READONLY
, "READONLY");
319 PF (SEC_CODE
, "CODE");
320 PF (SEC_DATA
, "DATA");
322 PF (SEC_DEBUGGING
, "DEBUGGING");
323 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
324 PF (SEC_EXCLUDE
, "EXCLUDE");
325 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
327 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
331 switch (section
->flags
& SEC_LINK_DUPLICATES
)
335 case SEC_LINK_DUPLICATES_DISCARD
:
336 ls
= "LINK_ONCE_DISCARD";
338 case SEC_LINK_DUPLICATES_ONE_ONLY
:
339 ls
= "LINK_ONCE_ONE_ONLY";
341 case SEC_LINK_DUPLICATES_SAME_SIZE
:
342 ls
= "LINK_ONCE_SAME_SIZE";
344 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
345 ls
= "LINK_ONCE_SAME_CONTENTS";
348 printf ("%s%s", comma
, ls
);
360 printf ("Sections:\n");
362 printf ("Idx Name Size VMA LMA File off Algn\n");
364 printf ("Idx Name Size VMA LMA File off Algn\n");
366 bfd_map_over_sections (abfd
, dump_section_header
, (PTR
) NULL
);
373 asymbol
**sy
= (asymbol
**) NULL
;
376 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
378 printf ("No symbols in \"%s\".\n", bfd_get_filename (abfd
));
383 storage
= bfd_get_symtab_upper_bound (abfd
);
385 bfd_fatal (bfd_get_filename (abfd
));
389 sy
= (asymbol
**) xmalloc (storage
);
391 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
393 bfd_fatal (bfd_get_filename (abfd
));
395 fprintf (stderr
, "%s: %s: No symbols\n",
396 program_name
, bfd_get_filename (abfd
));
400 /* Read in the dynamic symbols. */
403 slurp_dynamic_symtab (abfd
)
406 asymbol
**sy
= (asymbol
**) NULL
;
409 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
412 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
414 fprintf (stderr
, "%s: %s: not a dynamic object\n",
415 program_name
, bfd_get_filename (abfd
));
420 bfd_fatal (bfd_get_filename (abfd
));
425 sy
= (asymbol
**) xmalloc (storage
);
427 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
429 bfd_fatal (bfd_get_filename (abfd
));
430 if (dynsymcount
== 0)
431 fprintf (stderr
, "%s: %s: No dynamic symbols\n",
432 program_name
, bfd_get_filename (abfd
));
436 /* Filter out (in place) symbols that are useless for disassembly.
437 COUNT is the number of elements in SYMBOLS.
438 Return the number of useful symbols. */
441 remove_useless_symbols (symbols
, count
)
445 register asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
449 asymbol
*sym
= *in_ptr
++;
451 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
453 if (sym
->flags
& (BSF_DEBUGGING
))
455 if (bfd_is_und_section (sym
->section
)
456 || bfd_is_com_section (sym
->section
))
461 return out_ptr
- symbols
;
464 /* Sort symbols into value order. */
467 compare_symbols (ap
, bp
)
471 const asymbol
*a
= *(const asymbol
**)ap
;
472 const asymbol
*b
= *(const asymbol
**)bp
;
476 flagword aflags
, bflags
;
478 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
480 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
483 if (a
->section
> b
->section
)
485 else if (a
->section
< b
->section
)
488 an
= bfd_asymbol_name (a
);
489 bn
= bfd_asymbol_name (b
);
493 /* The symbols gnu_compiled and gcc2_compiled convey no real
494 information, so put them after other symbols with the same value. */
496 af
= (strstr (an
, "gnu_compiled") != NULL
497 || strstr (an
, "gcc2_compiled") != NULL
);
498 bf
= (strstr (bn
, "gnu_compiled") != NULL
499 || strstr (bn
, "gcc2_compiled") != NULL
);
506 /* We use a heuristic for the file name, to try to sort it after
507 more useful symbols. It may not work on non Unix systems, but it
508 doesn't really matter; the only difference is precisely which
509 symbol names get printed. */
511 #define file_symbol(s, sn, snl) \
512 (((s)->flags & BSF_FILE) != 0 \
513 || ((sn)[(snl) - 2] == '.' \
514 && ((sn)[(snl) - 1] == 'o' \
515 || (sn)[(snl) - 1] == 'a')))
517 af
= file_symbol (a
, an
, anl
);
518 bf
= file_symbol (b
, bn
, bnl
);
525 /* Try to sort global symbols before local symbols before function
526 symbols before debugging symbols. */
531 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
533 if ((aflags
& BSF_DEBUGGING
) != 0)
538 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
540 if ((aflags
& BSF_FUNCTION
) != 0)
545 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
547 if ((aflags
& BSF_LOCAL
) != 0)
552 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
554 if ((aflags
& BSF_GLOBAL
) != 0)
560 /* Symbols that start with '.' might be section names, so sort them
561 after symbols that don't start with '.'. */
562 if (an
[0] == '.' && bn
[0] != '.')
564 if (an
[0] != '.' && bn
[0] == '.')
567 /* Finally, if we can't distinguish them in any other way, try to
568 get consistent results by sorting the symbols by name. */
569 return strcmp (an
, bn
);
572 /* Sort relocs into address order. */
575 compare_relocs (ap
, bp
)
579 const arelent
*a
= *(const arelent
**)ap
;
580 const arelent
*b
= *(const arelent
**)bp
;
582 if (a
->address
> b
->address
)
584 else if (a
->address
< b
->address
)
587 /* So that associated relocations tied to the same address show up
588 in the correct order, we don't do any further sorting. */
597 /* Print VMA to STREAM. If SKIP_ZEROES is true, omit leading zeroes. */
600 objdump_print_value (vma
, info
, skip_zeroes
)
602 struct disassemble_info
*info
;
608 sprintf_vma (buf
, vma
);
613 for (p
= buf
; *p
== '0'; ++p
)
618 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
621 /* Print the name of a symbol. */
624 objdump_print_symname (abfd
, info
, sym
)
626 struct disassemble_info
*info
;
634 name
= bfd_asymbol_name (sym
);
635 if (! do_demangle
|| name
[0] == '\0')
639 /* Demangle the name. */
640 if (bfd_get_symbol_leading_char (abfd
) == name
[0])
643 alloc
= cplus_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
651 (*info
->fprintf_func
) (info
->stream
, "%s", print
);
653 printf ("%s", print
);
659 /* Locate a symbol given a bfd, a section, and a VMA. If REQUIRE_SEC
660 is true, then always require the symbol to be in the section. This
661 returns NULL if there is no suitable symbol. If PLACE is not NULL,
662 then *PLACE is set to the index of the symbol in sorted_syms. */
665 find_symbol_for_address (abfd
, sec
, vma
, require_sec
, place
)
672 /* @@ Would it speed things up to cache the last two symbols returned,
673 and maybe their address ranges? For many processors, only one memory
674 operand can be present at a time, so the 2-entry cache wouldn't be
675 constantly churned by code doing heavy memory accesses. */
677 /* Indices in `sorted_syms'. */
679 long max
= sorted_symcount
;
682 if (sorted_symcount
< 1)
685 /* Perform a binary search looking for the closest symbol to the
686 required value. We are searching the range (min, max]. */
687 while (min
+ 1 < max
)
691 thisplace
= (max
+ min
) / 2;
692 sym
= sorted_syms
[thisplace
];
694 if (bfd_asymbol_value (sym
) > vma
)
696 else if (bfd_asymbol_value (sym
) < vma
)
705 /* The symbol we want is now in min, the low end of the range we
706 were searching. If there are several symbols with the same
707 value, we want the first one. */
710 && (bfd_asymbol_value (sorted_syms
[thisplace
])
711 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
714 /* If the file is relocateable, and the symbol could be from this
715 section, prefer a symbol from this section over symbols from
716 others, even if the other symbol's value might be closer.
718 Note that this may be wrong for some symbol references if the
719 sections have overlapping memory ranges, but in that case there's
720 no way to tell what's desired without looking at the relocation
723 if (sorted_syms
[thisplace
]->section
!= sec
725 || ((abfd
->flags
& HAS_RELOC
) != 0
726 && vma
>= bfd_get_section_vma (abfd
, sec
)
727 && vma
< (bfd_get_section_vma (abfd
, sec
)
728 + bfd_section_size (abfd
, sec
)))))
732 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
734 if (bfd_asymbol_value (sorted_syms
[i
])
735 != bfd_asymbol_value (sorted_syms
[thisplace
]))
741 if (sorted_syms
[i
]->section
== sec
743 || sorted_syms
[i
- 1]->section
!= sec
744 || (bfd_asymbol_value (sorted_syms
[i
])
745 != bfd_asymbol_value (sorted_syms
[i
- 1]))))
752 if (sorted_syms
[thisplace
]->section
!= sec
)
754 /* We didn't find a good symbol with a smaller value.
755 Look for one with a larger value. */
756 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
758 if (sorted_syms
[i
]->section
== sec
)
766 if (sorted_syms
[thisplace
]->section
!= sec
768 || ((abfd
->flags
& HAS_RELOC
) != 0
769 && vma
>= bfd_get_section_vma (abfd
, sec
)
770 && vma
< (bfd_get_section_vma (abfd
, sec
)
771 + bfd_section_size (abfd
, sec
)))))
773 /* There is no suitable symbol. */
781 return sorted_syms
[thisplace
];
784 /* Print an address to INFO symbolically. */
787 objdump_print_addr_with_sym (abfd
, sec
, sym
, vma
, info
, skip_zeroes
)
792 struct disassemble_info
*info
;
795 objdump_print_value (vma
, info
, skip_zeroes
);
801 (*info
->fprintf_func
) (info
->stream
, " <%s",
802 bfd_get_section_name (abfd
, sec
));
803 secaddr
= bfd_get_section_vma (abfd
, sec
);
806 (*info
->fprintf_func
) (info
->stream
, "-0x");
807 objdump_print_value (secaddr
- vma
, info
, true);
809 else if (vma
> secaddr
)
811 (*info
->fprintf_func
) (info
->stream
, "+0x");
812 objdump_print_value (vma
- secaddr
, info
, true);
814 (*info
->fprintf_func
) (info
->stream
, ">");
818 (*info
->fprintf_func
) (info
->stream
, " <");
819 objdump_print_symname (abfd
, info
, sym
);
820 if (bfd_asymbol_value (sym
) > vma
)
822 (*info
->fprintf_func
) (info
->stream
, "-0x");
823 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, true);
825 else if (vma
> bfd_asymbol_value (sym
))
827 (*info
->fprintf_func
) (info
->stream
, "+0x");
828 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, true);
830 (*info
->fprintf_func
) (info
->stream
, ">");
832 /* Notify the disassembler of the symbol being used: */
833 disasm_symaddr (sym
, info
);
837 /* Print VMA to INFO, symbolically if possible. If SKIP_ZEROES is
838 true, don't output leading zeroes. */
841 objdump_print_addr (vma
, info
, skip_zeroes
)
843 struct disassemble_info
*info
;
846 struct objdump_disasm_info
*aux
;
849 if (sorted_symcount
< 1)
851 (*info
->fprintf_func
) (info
->stream
, "0x");
852 objdump_print_value (vma
, info
, skip_zeroes
);
856 aux
= (struct objdump_disasm_info
*) info
->application_data
;
857 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
859 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
863 /* Print VMA to INFO. This function is passed to the disassembler
867 objdump_print_address (vma
, info
)
869 struct disassemble_info
*info
;
871 objdump_print_addr (vma
, info
, ! prefix_addresses
);
874 /* Determine of the given address has a symbol associated with it. */
877 objdump_symbol_at_address (vma
, info
)
879 struct disassemble_info
* info
;
881 struct objdump_disasm_info
* aux
;
884 /* No symbols - do not bother checking. */
885 if (sorted_symcount
< 1)
888 aux
= (struct objdump_disasm_info
*) info
->application_data
;
889 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
892 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
895 /* Hold the last function name and the last line number we displayed
898 static char *prev_functionname
;
899 static unsigned int prev_line
;
901 /* We keep a list of all files that we have seen when doing a
902 dissassembly with source, so that we know how much of the file to
903 display. This can be important for inlined functions. */
905 struct print_file_list
907 struct print_file_list
*next
;
913 static struct print_file_list
*print_files
;
915 /* The number of preceding context lines to show when we start
916 displaying a file for the first time. */
918 #define SHOW_PRECEDING_CONTEXT_LINES (5)
920 /* Skip ahead to a given line in a file, optionally printing each
924 skip_to_line
PARAMS ((struct print_file_list
*, unsigned int, boolean
));
927 skip_to_line (p
, line
, show
)
928 struct print_file_list
*p
;
932 while (p
->line
< line
)
936 if (fgets (buf
, sizeof buf
, p
->f
) == NULL
)
946 if (strchr (buf
, '\n') != NULL
)
951 /* Show the line number, or the source line, in a dissassembly
955 show_line (abfd
, section
, off
)
960 CONST
char *filename
;
961 CONST
char *functionname
;
964 if (! with_line_numbers
&& ! with_source_code
)
967 if (! bfd_find_nearest_line (abfd
, section
, syms
, off
, &filename
,
968 &functionname
, &line
))
971 if (filename
!= NULL
&& *filename
== '\0')
973 if (functionname
!= NULL
&& *functionname
== '\0')
976 if (with_line_numbers
)
978 if (functionname
!= NULL
979 && (prev_functionname
== NULL
980 || strcmp (functionname
, prev_functionname
) != 0))
981 printf ("%s():\n", functionname
);
982 if (line
> 0 && line
!= prev_line
)
983 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
990 struct print_file_list
**pp
, *p
;
992 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
993 if (strcmp ((*pp
)->filename
, filename
) == 0)
999 if (p
!= print_files
)
1003 /* We have reencountered a file name which we saw
1004 earlier. This implies that either we are dumping out
1005 code from an included file, or the same file was
1006 linked in more than once. There are two common cases
1007 of an included file: inline functions in a header
1008 file, and a bison or flex skeleton file. In the
1009 former case we want to just start printing (but we
1010 back up a few lines to give context); in the latter
1011 case we want to continue from where we left off. I
1012 can't think of a good way to distinguish the cases,
1013 so I used a heuristic based on the file name. */
1014 if (strcmp (p
->filename
+ strlen (p
->filename
) - 2, ".h") != 0)
1018 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1025 p
->f
= fopen (p
->filename
, "r");
1029 skip_to_line (p
, l
, false);
1031 if (print_files
->f
!= NULL
)
1033 fclose (print_files
->f
);
1034 print_files
->f
= NULL
;
1040 skip_to_line (p
, line
, true);
1042 p
->next
= print_files
;
1050 f
= fopen (filename
, "r");
1055 p
= ((struct print_file_list
*)
1056 xmalloc (sizeof (struct print_file_list
)));
1057 p
->filename
= xmalloc (strlen (filename
) + 1);
1058 strcpy (p
->filename
, filename
);
1062 if (print_files
!= NULL
&& print_files
->f
!= NULL
)
1064 fclose (print_files
->f
);
1065 print_files
->f
= NULL
;
1067 p
->next
= print_files
;
1070 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1073 skip_to_line (p
, l
, false);
1075 skip_to_line (p
, line
, true);
1080 if (functionname
!= NULL
1081 && (prev_functionname
== NULL
1082 || strcmp (functionname
, prev_functionname
) != 0))
1084 if (prev_functionname
!= NULL
)
1085 free (prev_functionname
);
1086 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1087 strcpy (prev_functionname
, functionname
);
1090 if (line
> 0 && line
!= prev_line
)
1094 /* Pseudo FILE object for strings. */
1100 /* sprintf to a "stream" */
1102 #ifdef ANSI_PROTOTYPES
1104 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1109 va_start (args
, format
);
1110 vsprintf (f
->current
, format
, args
);
1111 f
->current
+= n
= strlen (f
->current
);
1117 objdump_sprintf (va_alist
)
1126 f
= va_arg (args
, SFILE
*);
1127 format
= va_arg (args
, const char *);
1128 vsprintf (f
->current
, format
, args
);
1129 f
->current
+= n
= strlen (f
->current
);
1135 /* The number of zeroes we want to see before we start skipping them.
1136 The number is arbitrarily chosen. */
1138 #define SKIP_ZEROES (8)
1140 /* The number of zeroes to skip at the end of a section. If the
1141 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1142 SKIP_ZEROES, they will be disassembled. If there are fewer than
1143 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1144 attempt to avoid disassembling zeroes inserted by section
1147 #define SKIP_ZEROES_AT_END (3)
1149 /* Disassemble some data in memory between given values. */
1152 disassemble_bytes (info
, disassemble_fn
, insns
, data
, start
, stop
, relppp
,
1154 struct disassemble_info
*info
;
1155 disassembler_ftype disassemble_fn
;
1163 struct objdump_disasm_info
*aux
;
1167 int skip_addr_chars
;
1170 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1176 bytes_per_line
= 16;
1178 /* Figure out how many characters to skip at the start of an
1179 address, to make the disassembly look nicer. We discard leading
1180 zeroes in chunks of 4, ensuring that there is always a leading
1182 skip_addr_chars
= 0;
1183 if (! prefix_addresses
)
1189 section
->vma
+ bfd_section_size (section
->owner
, section
));
1191 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1194 skip_addr_chars
+= 4;
1199 info
->insn_info_valid
= 0;
1207 boolean need_nl
= false;
1209 /* If we see more than SKIP_ZEROES bytes of zeroes, we just
1211 for (z
= i
; z
< stop
; z
++)
1214 if (! disassemble_zeroes
1215 && (info
->insn_info_valid
== 0
1216 || info
->branch_delay_insns
== 0)
1217 && (z
- i
>= SKIP_ZEROES
1218 || (z
== stop
&& z
- i
< SKIP_ZEROES_AT_END
)))
1222 /* If there are more nonzero bytes to follow, we only skip
1223 zeroes in multiples of 4, to try to avoid running over
1224 the start of an instruction which happens to start with
1227 z
= i
+ ((z
- i
) &~ 3);
1239 if (with_line_numbers
|| with_source_code
)
1240 show_line (aux
->abfd
, section
, i
);
1242 if (! prefix_addresses
)
1246 sprintf_vma (buf
, section
->vma
+ i
);
1247 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1251 printf ("%s:\t", buf
+ skip_addr_chars
);
1255 aux
->require_sec
= true;
1256 objdump_print_address (section
->vma
+ i
, info
);
1257 aux
->require_sec
= false;
1263 sfile
.buffer
= sfile
.current
= buf
;
1264 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1265 info
->stream
= (FILE *) &sfile
;
1266 info
->bytes_per_line
= 0;
1267 info
->bytes_per_chunk
= 0;
1268 bytes
= (*disassemble_fn
) (section
->vma
+ i
, info
);
1269 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1270 info
->stream
= stdout
;
1271 if (info
->bytes_per_line
!= 0)
1272 bytes_per_line
= info
->bytes_per_line
;
1280 bytes
= bytes_per_line
;
1281 if (i
+ bytes
> stop
)
1284 for (j
= i
; j
< i
+ bytes
; ++j
)
1286 if (isprint (data
[j
]))
1287 buf
[j
- i
] = data
[j
];
1294 if (prefix_addresses
1296 : show_raw_insn
>= 0)
1300 /* If ! prefix_addresses and ! wide_output, we print
1301 bytes_per_line bytes per line. */
1303 if (pb
> bytes_per_line
&& ! prefix_addresses
&& ! wide_output
)
1304 pb
= bytes_per_line
;
1306 if (info
->bytes_per_chunk
)
1307 bpc
= info
->bytes_per_chunk
;
1311 for (j
= i
; j
< i
+ pb
; j
+= bpc
)
1314 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1316 for (k
= bpc
- 1; k
>= 0; k
--)
1317 printf ("%02x", (unsigned) data
[j
+ k
]);
1322 for (k
= 0; k
< bpc
; k
++)
1323 printf ("%02x", (unsigned) data
[j
+ k
]);
1328 for (; pb
< bytes_per_line
; pb
+= bpc
)
1332 for (k
= 0; k
< bpc
; k
++)
1337 /* Separate raw data from instruction by extra space. */
1346 if (prefix_addresses
1348 : show_raw_insn
>= 0)
1358 sprintf_vma (buf
, section
->vma
+ j
);
1359 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1363 printf ("%s:\t", buf
+ skip_addr_chars
);
1365 pb
+= bytes_per_line
;
1368 for (; j
< i
+ pb
; j
+= bpc
)
1372 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1374 for (k
= bpc
- 1; k
>= 0; k
--)
1375 printf ("%02x", (unsigned) data
[j
+ k
]);
1380 for (k
= 0; k
< bpc
; k
++)
1381 printf ("%02x", (unsigned) data
[j
+ k
]);
1395 && (section
->flags
& SEC_RELOC
) != 0)
1397 while ((*relppp
) < relppend
1398 && ((**relppp
)->address
>= (bfd_vma
) i
1399 && (**relppp
)->address
< (bfd_vma
) i
+ bytes
))
1410 objdump_print_value (section
->vma
+ q
->address
, info
, true);
1412 printf (": %s\t", q
->howto
->name
);
1414 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1415 printf ("*unknown*");
1418 const char *sym_name
;
1420 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1421 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1422 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1427 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1428 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1429 if (sym_name
== NULL
|| *sym_name
== '\0')
1430 sym_name
= "*unknown*";
1431 printf ("%s", sym_name
);
1438 objdump_print_value (q
->addend
, info
, true);
1454 /* Disassemble the contents of an object file. */
1457 disassemble_data (abfd
)
1461 disassembler_ftype disassemble_fn
;
1462 struct disassemble_info disasm_info
;
1463 struct objdump_disasm_info aux
;
1467 prev_functionname
= NULL
;
1470 /* We make a copy of syms to sort. We don't want to sort syms
1471 because that will screw up the relocs. */
1472 sorted_syms
= (asymbol
**) xmalloc (symcount
* sizeof (asymbol
*));
1473 memcpy (sorted_syms
, syms
, symcount
* sizeof (asymbol
*));
1475 sorted_symcount
= remove_useless_symbols (sorted_syms
, symcount
);
1477 /* Sort the symbols into section and symbol order */
1478 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1480 INIT_DISASSEMBLE_INFO(disasm_info
, stdout
, fprintf
);
1481 disasm_info
.application_data
= (PTR
) &aux
;
1483 aux
.require_sec
= false;
1484 disasm_info
.print_address_func
= objdump_print_address
;
1485 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1487 if (machine
!= (char *) NULL
)
1489 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1492 fprintf (stderr
, "%s: Can't use supplied machine %s\n",
1497 abfd
->arch_info
= info
;
1500 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1502 struct bfd_target
*xvec
;
1504 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
1505 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1506 xvec
->byteorder
= endian
;
1510 disassemble_fn
= disassembler (abfd
);
1511 if (!disassemble_fn
)
1513 fprintf (stderr
, "%s: Can't disassemble for architecture %s\n",
1515 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1519 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1520 disasm_info
.arch
= bfd_get_arch (abfd
);
1521 disasm_info
.mach
= bfd_get_mach (abfd
);
1522 if (bfd_big_endian (abfd
))
1523 disasm_info
.endian
= BFD_ENDIAN_BIG
;
1524 else if (bfd_little_endian (abfd
))
1525 disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1527 /* ??? Aborting here seems too drastic. We could default to big or little
1529 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1531 for (section
= abfd
->sections
;
1532 section
!= (asection
*) NULL
;
1533 section
= section
->next
)
1535 bfd_byte
*data
= NULL
;
1536 bfd_size_type datasize
= 0;
1537 arelent
**relbuf
= NULL
;
1538 arelent
**relpp
= NULL
;
1539 arelent
**relppend
= NULL
;
1541 asymbol
*sym
= NULL
;
1544 if ((section
->flags
& SEC_LOAD
) == 0
1545 || (! disassemble_all
1547 && (section
->flags
& SEC_CODE
) == 0))
1549 if (only
!= (char *) NULL
&& strcmp (only
, section
->name
) != 0)
1553 && (section
->flags
& SEC_RELOC
) != 0)
1557 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1559 bfd_fatal (bfd_get_filename (abfd
));
1565 relbuf
= (arelent
**) xmalloc (relsize
);
1566 relcount
= bfd_canonicalize_reloc (abfd
, section
, relbuf
, syms
);
1568 bfd_fatal (bfd_get_filename (abfd
));
1570 /* Sort the relocs by address. */
1571 qsort (relbuf
, relcount
, sizeof (arelent
*), compare_relocs
);
1574 relppend
= relpp
+ relcount
;
1578 printf ("Disassembly of section %s:\n", section
->name
);
1580 datasize
= bfd_get_section_size_before_reloc (section
);
1584 data
= (bfd_byte
*) xmalloc ((size_t) datasize
);
1586 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1589 disasm_info
.buffer
= data
;
1590 disasm_info
.buffer_vma
= section
->vma
;
1591 disasm_info
.buffer_length
= datasize
;
1592 if (start_address
== (bfd_vma
) -1
1593 || start_address
< disasm_info
.buffer_vma
)
1596 i
= start_address
- disasm_info
.buffer_vma
;
1597 if (stop_address
== (bfd_vma
) -1)
1601 if (stop_address
< disasm_info
.buffer_vma
)
1604 stop
= stop_address
- disasm_info
.buffer_vma
;
1605 if (stop
> disasm_info
.buffer_length
)
1606 stop
= disasm_info
.buffer_length
;
1609 sym
= find_symbol_for_address (abfd
, section
, section
->vma
+ i
,
1618 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= section
->vma
+ i
)
1619 disasm_info
.symbol
= sym
;
1621 disasm_info
.symbol
= NULL
;
1623 if (! prefix_addresses
)
1626 objdump_print_addr_with_sym (abfd
, section
, sym
,
1633 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ i
)
1635 else if (sym
== NULL
)
1639 while (place
< sorted_symcount
1640 && (sorted_syms
[place
]->section
!= section
1641 || (bfd_asymbol_value (sorted_syms
[place
])
1642 <= bfd_asymbol_value (sym
))))
1644 if (place
>= sorted_symcount
)
1647 nextsym
= sorted_syms
[place
];
1650 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ i
)
1652 nextstop
= bfd_asymbol_value (sym
) - section
->vma
;
1653 if (nextstop
> stop
)
1656 else if (nextsym
== NULL
)
1660 nextstop
= bfd_asymbol_value (nextsym
) - section
->vma
;
1661 if (nextstop
> stop
)
1665 /* If a symbol is explicitly marked as being an object
1666 rather than a function, just dump the bytes without
1667 disassembling them. */
1670 || bfd_asymbol_value (sym
) > section
->vma
+ i
1671 || ((sym
->flags
& BSF_OBJECT
) == 0
1672 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1674 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1676 || (sym
->flags
& BSF_FUNCTION
) != 0)
1681 disassemble_bytes (&disasm_info
, disassemble_fn
, insns
, data
, i
,
1682 nextstop
, &relpp
, relppend
);
1696 /* Define a table of stab values and print-strings. We wish the initializer
1697 could be a direct-mapped table, but instead we build one the first
1700 static void dump_section_stabs
PARAMS ((bfd
*abfd
, char *stabsect_name
,
1701 char *strsect_name
));
1703 /* Dump the stabs sections from an object file that has a section that
1704 uses Sun stabs encoding. */
1710 dump_section_stabs (abfd
, ".stab", ".stabstr");
1711 dump_section_stabs (abfd
, ".stab.excl", ".stab.exclstr");
1712 dump_section_stabs (abfd
, ".stab.index", ".stab.indexstr");
1713 dump_section_stabs (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1716 static bfd_byte
*stabs
;
1717 static bfd_size_type stab_size
;
1719 static char *strtab
;
1720 static bfd_size_type stabstr_size
;
1722 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1723 and string table section STRSECT_NAME into `strtab'.
1724 If the section exists and was read, allocate the space and return true.
1725 Otherwise return false. */
1728 read_section_stabs (abfd
, stabsect_name
, strsect_name
)
1730 const char *stabsect_name
;
1731 const char *strsect_name
;
1733 asection
*stabsect
, *stabstrsect
;
1735 stabsect
= bfd_get_section_by_name (abfd
, stabsect_name
);
1738 printf ("No %s section present\n\n", stabsect_name
);
1742 stabstrsect
= bfd_get_section_by_name (abfd
, strsect_name
);
1743 if (0 == stabstrsect
)
1745 fprintf (stderr
, "%s: %s has no %s section\n", program_name
,
1746 bfd_get_filename (abfd
), strsect_name
);
1750 stab_size
= bfd_section_size (abfd
, stabsect
);
1751 stabstr_size
= bfd_section_size (abfd
, stabstrsect
);
1753 stabs
= (bfd_byte
*) xmalloc (stab_size
);
1754 strtab
= (char *) xmalloc (stabstr_size
);
1756 if (! bfd_get_section_contents (abfd
, stabsect
, (PTR
) stabs
, 0, stab_size
))
1758 fprintf (stderr
, "%s: Reading %s section of %s failed: %s\n",
1759 program_name
, stabsect_name
, bfd_get_filename (abfd
),
1760 bfd_errmsg (bfd_get_error ()));
1766 if (! bfd_get_section_contents (abfd
, stabstrsect
, (PTR
) strtab
, 0,
1769 fprintf (stderr
, "%s: Reading %s section of %s failed: %s\n",
1770 program_name
, strsect_name
, bfd_get_filename (abfd
),
1771 bfd_errmsg (bfd_get_error ()));
1780 /* Stabs entries use a 12 byte format:
1781 4 byte string table index
1783 1 byte stab other field
1784 2 byte stab desc field
1786 FIXME: This will have to change for a 64 bit object format. */
1788 #define STRDXOFF (0)
1790 #define OTHEROFF (5)
1793 #define STABSIZE (12)
1795 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1796 using string table section STRSECT_NAME (in `strtab'). */
1799 print_section_stabs (abfd
, stabsect_name
, strsect_name
)
1801 const char *stabsect_name
;
1802 const char *strsect_name
;
1805 unsigned file_string_table_offset
= 0, next_file_string_table_offset
= 0;
1806 bfd_byte
*stabp
, *stabs_end
;
1809 stabs_end
= stabp
+ stab_size
;
1811 printf ("Contents of %s section:\n\n", stabsect_name
);
1812 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1814 /* Loop through all symbols and print them.
1816 We start the index at -1 because there is a dummy symbol on
1817 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1819 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
1823 unsigned char type
, other
;
1824 unsigned short desc
;
1827 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
1828 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
1829 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
1830 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
1831 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
1833 printf ("\n%-6d ", i
);
1834 /* Either print the stab name, or, if unnamed, print its number
1835 again (makes consistent formatting for tools like awk). */
1836 name
= bfd_get_stab_name (type
);
1838 printf ("%-6s", name
);
1839 else if (type
== N_UNDF
)
1842 printf ("%-6d", type
);
1843 printf (" %-6d %-6d ", other
, desc
);
1845 printf (" %-6lu", strx
);
1847 /* Symbols with type == 0 (N_UNDF) specify the length of the
1848 string table associated with this file. We use that info
1849 to know how to relocate the *next* file's string table indices. */
1853 file_string_table_offset
= next_file_string_table_offset
;
1854 next_file_string_table_offset
+= value
;
1858 /* Using the (possibly updated) string table offset, print the
1859 string (if any) associated with this symbol. */
1861 if ((strx
+ file_string_table_offset
) < stabstr_size
)
1862 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
1871 dump_section_stabs (abfd
, stabsect_name
, strsect_name
)
1873 char *stabsect_name
;
1878 /* Check for section names for which stabsect_name is a prefix, to
1879 handle .stab0, etc. */
1880 for (s
= abfd
->sections
;
1886 len
= strlen (stabsect_name
);
1888 /* If the prefix matches, and the files section name ends with a nul or a digit,
1889 then we match. Ie: we want either an exact match or a a section followed by
1891 if (strncmp (stabsect_name
, s
->name
, len
) == 0
1892 && (s
->name
[len
] == '\000' || isdigit (s
->name
[len
])))
1894 if (read_section_stabs (abfd
, s
->name
, strsect_name
))
1896 print_section_stabs (abfd
, s
->name
, strsect_name
);
1905 dump_bfd_header (abfd
)
1910 printf ("architecture: %s, ",
1911 bfd_printable_arch_mach (bfd_get_arch (abfd
),
1912 bfd_get_mach (abfd
)));
1913 printf ("flags 0x%08x:\n", abfd
->flags
);
1915 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
1916 PF (HAS_RELOC
, "HAS_RELOC");
1917 PF (EXEC_P
, "EXEC_P");
1918 PF (HAS_LINENO
, "HAS_LINENO");
1919 PF (HAS_DEBUG
, "HAS_DEBUG");
1920 PF (HAS_SYMS
, "HAS_SYMS");
1921 PF (HAS_LOCALS
, "HAS_LOCALS");
1922 PF (DYNAMIC
, "DYNAMIC");
1923 PF (WP_TEXT
, "WP_TEXT");
1924 PF (D_PAGED
, "D_PAGED");
1925 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
1926 printf ("\nstart address 0x");
1927 printf_vma (abfd
->start_address
);
1932 dump_bfd_private_header (abfd
)
1935 bfd_print_private_bfd_data (abfd
, stdout
);
1944 if (!bfd_check_format_matches (abfd
, bfd_object
, &matching
))
1946 bfd_nonfatal (bfd_get_filename (abfd
));
1947 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1949 list_matching_formats (matching
);
1955 /* If we are adjusting section VMA's, change them all now. Changing
1956 the BFD information is a hack. However, we must do it, or
1957 bfd_find_nearest_line will not do the right thing. */
1958 if (adjust_section_vma
!= 0)
1962 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1964 s
->vma
+= adjust_section_vma
;
1965 s
->lma
+= adjust_section_vma
;
1969 printf ("\n%s: file format %s\n", bfd_get_filename (abfd
),
1972 print_arelt_descr (stdout
, abfd
, true);
1973 if (dump_file_header
)
1974 dump_bfd_header (abfd
);
1975 if (dump_private_headers
)
1976 dump_bfd_private_header (abfd
);
1978 if (dump_section_headers
)
1979 dump_headers (abfd
);
1980 if (dump_symtab
|| dump_reloc_info
|| disassemble
|| dump_debugging
)
1982 syms
= slurp_symtab (abfd
);
1984 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
)
1986 dynsyms
= slurp_dynamic_symtab (abfd
);
1989 dump_symbols (abfd
, false);
1990 if (dump_dynamic_symtab
)
1991 dump_symbols (abfd
, true);
1992 if (dump_stab_section_info
)
1994 if (dump_reloc_info
&& ! disassemble
)
1996 if (dump_dynamic_reloc_info
)
1997 dump_dynamic_relocs (abfd
);
1998 if (dump_section_contents
)
2001 disassemble_data (abfd
);
2006 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2007 if (dhandle
!= NULL
)
2009 if (! print_debugging_info (stdout
, dhandle
))
2010 fprintf (stderr
, "%s: printing debugging information failed\n",
2011 bfd_get_filename (abfd
));
2027 display_file (filename
, target
)
2031 bfd
*file
, *arfile
= (bfd
*) NULL
;
2033 file
= bfd_openr (filename
, target
);
2036 bfd_nonfatal (filename
);
2040 if (bfd_check_format (file
, bfd_archive
) == true)
2042 bfd
*last_arfile
= NULL
;
2044 printf ("In archive %s:\n", bfd_get_filename (file
));
2047 bfd_set_error (bfd_error_no_error
);
2049 arfile
= bfd_openr_next_archived_file (file
, arfile
);
2052 if (bfd_get_error () != bfd_error_no_more_archived_files
)
2054 bfd_nonfatal (bfd_get_filename (file
));
2059 display_bfd (arfile
);
2061 if (last_arfile
!= NULL
)
2062 bfd_close (last_arfile
);
2063 last_arfile
= arfile
;
2066 if (last_arfile
!= NULL
)
2067 bfd_close (last_arfile
);
2075 /* Actually display the various requested regions */
2083 bfd_size_type datasize
= 0;
2085 bfd_size_type start
, stop
;
2087 for (section
= abfd
->sections
; section
!= NULL
; section
=
2092 if (only
== (char *) NULL
||
2093 strcmp (only
, section
->name
) == 0)
2095 if (section
->flags
& SEC_HAS_CONTENTS
)
2097 printf ("Contents of section %s:\n", section
->name
);
2099 if (bfd_section_size (abfd
, section
) == 0)
2101 data
= (bfd_byte
*) xmalloc ((size_t) bfd_section_size (abfd
, section
));
2102 datasize
= bfd_section_size (abfd
, section
);
2105 bfd_get_section_contents (abfd
, section
, (PTR
) data
, 0, bfd_section_size (abfd
, section
));
2107 if (start_address
== (bfd_vma
) -1
2108 || start_address
< section
->vma
)
2111 start
= start_address
- section
->vma
;
2112 if (stop_address
== (bfd_vma
) -1)
2113 stop
= bfd_section_size (abfd
, section
);
2116 if (stop_address
< section
->vma
)
2119 stop
= stop_address
- section
->vma
;
2120 if (stop
> bfd_section_size (abfd
, section
))
2121 stop
= bfd_section_size (abfd
, section
);
2123 for (i
= start
; i
< stop
; i
+= onaline
)
2127 printf (" %04lx ", (unsigned long int) (i
+ section
->vma
));
2128 for (j
= i
; j
< i
+ onaline
; j
++)
2131 printf ("%02x", (unsigned) (data
[j
]));
2139 for (j
= i
; j
< i
+ onaline
; j
++)
2144 printf ("%c", isprint (data
[j
]) ? data
[j
] : '.');
2154 /* Should perhaps share code and display with nm? */
2156 dump_symbols (abfd
, dynamic
)
2170 printf ("DYNAMIC SYMBOL TABLE:\n");
2178 printf ("SYMBOL TABLE:\n");
2181 for (count
= 0; count
< max
; count
++)
2185 bfd
*cur_bfd
= bfd_asymbol_bfd (*current
);
2187 if (cur_bfd
!= NULL
)
2192 name
= bfd_asymbol_name (*current
);
2194 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2198 /* If we want to demangle the name, we demangle it
2199 here, and temporarily clobber it while calling
2200 bfd_print_symbol. FIXME: This is a gross hack. */
2203 if (bfd_get_symbol_leading_char (cur_bfd
) == *n
)
2205 alloc
= cplus_demangle (n
, DMGL_ANSI
| DMGL_PARAMS
);
2207 (*current
)->name
= alloc
;
2209 (*current
)->name
= n
;
2212 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2213 bfd_print_symbol_all
);
2215 (*current
)->name
= name
;
2236 for (a
= abfd
->sections
; a
!= (asection
*) NULL
; a
= a
->next
)
2240 if (bfd_is_abs_section (a
))
2242 if (bfd_is_und_section (a
))
2244 if (bfd_is_com_section (a
))
2249 if (strcmp (only
, a
->name
))
2252 else if ((a
->flags
& SEC_RELOC
) == 0)
2255 relsize
= bfd_get_reloc_upper_bound (abfd
, a
);
2257 bfd_fatal (bfd_get_filename (abfd
));
2259 printf ("RELOCATION RECORDS FOR [%s]:", a
->name
);
2263 printf (" (none)\n\n");
2267 relpp
= (arelent
**) xmalloc (relsize
);
2268 relcount
= bfd_canonicalize_reloc (abfd
, a
, relpp
, syms
);
2270 bfd_fatal (bfd_get_filename (abfd
));
2271 else if (relcount
== 0)
2273 printf (" (none)\n\n");
2278 dump_reloc_set (abfd
, a
, relpp
, relcount
);
2287 dump_dynamic_relocs (abfd
)
2294 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2296 bfd_fatal (bfd_get_filename (abfd
));
2298 printf ("DYNAMIC RELOCATION RECORDS");
2302 printf (" (none)\n\n");
2306 relpp
= (arelent
**) xmalloc (relsize
);
2307 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2309 bfd_fatal (bfd_get_filename (abfd
));
2310 else if (relcount
== 0)
2312 printf (" (none)\n\n");
2317 dump_reloc_set (abfd
, (asection
*) NULL
, relpp
, relcount
);
2325 dump_reloc_set (abfd
, sec
, relpp
, relcount
)
2332 char *last_filename
, *last_functionname
;
2333 unsigned int last_line
;
2335 /* Get column headers lined up reasonably. */
2341 sprintf_vma (buf
, (bfd_vma
) -1);
2342 width
= strlen (buf
) - 7;
2344 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2347 last_filename
= NULL
;
2348 last_functionname
= NULL
;
2351 for (p
= relpp
; relcount
&& *p
!= (arelent
*) NULL
; p
++, relcount
--)
2354 const char *filename
, *functionname
;
2356 const char *sym_name
;
2357 const char *section_name
;
2359 if (start_address
!= (bfd_vma
) -1
2360 && q
->address
< start_address
)
2362 if (stop_address
!= (bfd_vma
) -1
2363 && q
->address
> stop_address
)
2366 if (with_line_numbers
2368 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2369 &filename
, &functionname
, &line
))
2371 if (functionname
!= NULL
2372 && (last_functionname
== NULL
2373 || strcmp (functionname
, last_functionname
) != 0))
2375 printf ("%s():\n", functionname
);
2376 if (last_functionname
!= NULL
)
2377 free (last_functionname
);
2378 last_functionname
= xstrdup (functionname
);
2381 && (line
!= last_line
2382 || (filename
!= NULL
2383 && last_filename
!= NULL
2384 && strcmp (filename
, last_filename
) != 0)))
2386 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2388 if (last_filename
!= NULL
)
2389 free (last_filename
);
2390 if (filename
== NULL
)
2391 last_filename
= NULL
;
2393 last_filename
= xstrdup (filename
);
2397 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2399 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2400 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2405 section_name
= NULL
;
2409 printf_vma (q
->address
);
2410 printf (" %-16s ", q
->howto
->name
);
2411 objdump_print_symname (abfd
, (struct disassemble_info
*) NULL
,
2416 if (section_name
== (CONST
char *) NULL
)
2417 section_name
= "*unknown*";
2418 printf_vma (q
->address
);
2419 printf (" %-16s [%s]",
2426 printf_vma (q
->addend
);
2432 /* The length of the longest architecture name + 1. */
2433 #define LONGEST_ARCH sizeof("rs6000:6000")
2436 endian_string (endian
)
2437 enum bfd_endian endian
;
2439 if (endian
== BFD_ENDIAN_BIG
)
2440 return "big endian";
2441 else if (endian
== BFD_ENDIAN_LITTLE
)
2442 return "little endian";
2444 return "endianness unknown";
2447 /* List the targets that BFD is configured to support, each followed
2448 by its endianness and the architectures it supports. */
2451 display_target_list ()
2453 extern bfd_target
*bfd_target_vector
[];
2457 dummy_name
= choose_temp_base ();
2458 for (t
= 0; bfd_target_vector
[t
]; t
++)
2460 bfd_target
*p
= bfd_target_vector
[t
];
2461 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2464 printf ("%s\n (header %s, data %s)\n", p
->name
,
2465 endian_string (p
->header_byteorder
),
2466 endian_string (p
->byteorder
));
2470 bfd_nonfatal (dummy_name
);
2474 if (! bfd_set_format (abfd
, bfd_object
))
2476 if (bfd_get_error () != bfd_error_invalid_operation
)
2477 bfd_nonfatal (p
->name
);
2481 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2482 if (bfd_set_arch_mach (abfd
, (enum bfd_architecture
) a
, 0))
2484 bfd_printable_arch_mach ((enum bfd_architecture
) a
, 0));
2486 unlink (dummy_name
);
2490 /* Print a table showing which architectures are supported for entries
2491 FIRST through LAST-1 of bfd_target_vector (targets across,
2492 architectures down). */
2495 display_info_table (first
, last
)
2499 extern bfd_target
*bfd_target_vector
[];
2503 /* Print heading of target names. */
2504 printf ("\n%*s", (int) LONGEST_ARCH
, " ");
2505 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2506 printf ("%s ", bfd_target_vector
[t
]->name
);
2509 dummy_name
= choose_temp_base ();
2510 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2511 if (strcmp (bfd_printable_arch_mach (a
, 0), "UNKNOWN!") != 0)
2513 printf ("%*s ", (int) LONGEST_ARCH
- 1,
2514 bfd_printable_arch_mach (a
, 0));
2515 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2517 bfd_target
*p
= bfd_target_vector
[t
];
2519 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2523 bfd_nonfatal (p
->name
);
2529 if (! bfd_set_format (abfd
, bfd_object
))
2531 if (bfd_get_error () != bfd_error_invalid_operation
)
2532 bfd_nonfatal (p
->name
);
2539 if (! bfd_set_arch_mach (abfd
, a
, 0))
2544 printf ("%s ", p
->name
);
2547 int l
= strlen (p
->name
);
2555 unlink (dummy_name
);
2559 /* Print tables of all the target-architecture combinations that
2560 BFD has been configured to support. */
2563 display_target_tables ()
2566 extern bfd_target
*bfd_target_vector
[];
2570 colum
= getenv ("COLUMNS");
2572 columns
= atoi (colum
);
2577 while (bfd_target_vector
[t
] != NULL
)
2581 wid
= LONGEST_ARCH
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2583 while (wid
< columns
&& bfd_target_vector
[t
] != NULL
)
2587 newwid
= wid
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2588 if (newwid
>= columns
)
2593 display_info_table (oldt
, t
);
2600 printf ("BFD header file version %s\n", BFD_VERSION
);
2601 display_target_list ();
2602 display_target_tables ();
2611 char *target
= default_target
;
2612 boolean seenflag
= false;
2614 program_name
= *argv
;
2615 xmalloc_set_program_name (program_name
);
2617 START_PROGRESS (program_name
, 0);
2620 set_default_bfd_target ();
2622 while ((c
= getopt_long (argc
, argv
, "pib:m:VCdDlfahrRtTxsSj:wE:",
2623 long_options
, (int *) 0))
2626 if (c
!= 'l' && c
!= OPTION_START_ADDRESS
&& c
!= OPTION_STOP_ADDRESS
)
2631 break; /* we've been given a long option */
2639 with_line_numbers
= 1;
2645 dump_file_header
= true;
2648 formats_info
= true;
2651 dump_private_headers
= 1;
2654 dump_private_headers
= 1;
2656 dump_reloc_info
= 1;
2657 dump_file_header
= true;
2659 dump_section_headers
= 1;
2665 dump_dynamic_symtab
= 1;
2674 disassemble
= disassemble_all
= true;
2678 with_source_code
= true;
2681 dump_section_contents
= 1;
2684 dump_reloc_info
= 1;
2687 dump_dynamic_reloc_info
= 1;
2693 dump_section_headers
= 1;
2703 case OPTION_ADJUST_VMA
:
2704 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
2706 case OPTION_START_ADDRESS
:
2707 start_address
= parse_vma (optarg
, "--start-address");
2709 case OPTION_STOP_ADDRESS
:
2710 stop_address
= parse_vma (optarg
, "--stop-address");
2713 if (strcmp (optarg
, "B") == 0)
2714 endian
= BFD_ENDIAN_BIG
;
2715 else if (strcmp (optarg
, "L") == 0)
2716 endian
= BFD_ENDIAN_LITTLE
;
2719 fprintf (stderr
, "%s: unrecognized -E option\n", program_name
);
2724 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
2725 endian
= BFD_ENDIAN_BIG
;
2726 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
2727 endian
= BFD_ENDIAN_LITTLE
;
2730 fprintf (stderr
, "%s: unrecognized --endian type `%s'\n",
2731 program_name
, optarg
);
2741 print_version ("objdump");
2743 if (seenflag
== false)
2753 display_file ("a.out", target
);
2755 for (; optind
< argc
;)
2756 display_file (argv
[optind
++], target
);
2759 END_PROGRESS (program_name
);