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
, ">");
834 /* Print VMA to INFO, symbolically if possible. If SKIP_ZEROES is
835 true, don't output leading zeroes. */
838 objdump_print_addr (vma
, info
, skip_zeroes
)
840 struct disassemble_info
*info
;
843 struct objdump_disasm_info
*aux
;
846 if (sorted_symcount
< 1)
849 objdump_print_value (vma
, info
, skip_zeroes
);
853 aux
= (struct objdump_disasm_info
*) info
->application_data
;
854 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
856 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
860 /* Print VMA to INFO. This function is passed to the disassembler
864 objdump_print_address (vma
, info
)
866 struct disassemble_info
*info
;
868 objdump_print_addr (vma
, info
, ! prefix_addresses
);
871 /* Hold the last function name and the last line number we displayed
874 static char *prev_functionname
;
875 static unsigned int prev_line
;
877 /* We keep a list of all files that we have seen when doing a
878 dissassembly with source, so that we know how much of the file to
879 display. This can be important for inlined functions. */
881 struct print_file_list
883 struct print_file_list
*next
;
889 static struct print_file_list
*print_files
;
891 /* The number of preceding context lines to show when we start
892 displaying a file for the first time. */
894 #define SHOW_PRECEDING_CONTEXT_LINES (5)
896 /* Skip ahead to a given line in a file, optionally printing each
900 skip_to_line
PARAMS ((struct print_file_list
*, unsigned int, boolean
));
903 skip_to_line (p
, line
, show
)
904 struct print_file_list
*p
;
908 while (p
->line
< line
)
912 if (fgets (buf
, sizeof buf
, p
->f
) == NULL
)
922 if (strchr (buf
, '\n') != NULL
)
927 /* Show the line number, or the source line, in a dissassembly
931 show_line (abfd
, section
, off
)
936 CONST
char *filename
;
937 CONST
char *functionname
;
940 if (! with_line_numbers
&& ! with_source_code
)
943 if (! bfd_find_nearest_line (abfd
, section
, syms
, off
, &filename
,
944 &functionname
, &line
))
947 if (filename
!= NULL
&& *filename
== '\0')
949 if (functionname
!= NULL
&& *functionname
== '\0')
952 if (with_line_numbers
)
954 if (functionname
!= NULL
955 && (prev_functionname
== NULL
956 || strcmp (functionname
, prev_functionname
) != 0))
957 printf ("%s():\n", functionname
);
958 if (line
> 0 && line
!= prev_line
)
959 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
966 struct print_file_list
**pp
, *p
;
968 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
969 if (strcmp ((*pp
)->filename
, filename
) == 0)
975 if (p
!= print_files
)
979 /* We have reencountered a file name which we saw
980 earlier. This implies that either we are dumping out
981 code from an included file, or the same file was
982 linked in more than once. There are two common cases
983 of an included file: inline functions in a header
984 file, and a bison or flex skeleton file. In the
985 former case we want to just start printing (but we
986 back up a few lines to give context); in the latter
987 case we want to continue from where we left off. I
988 can't think of a good way to distinguish the cases,
989 so I used a heuristic based on the file name. */
990 if (strcmp (p
->filename
+ strlen (p
->filename
) - 2, ".h") != 0)
994 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1001 p
->f
= fopen (p
->filename
, "r");
1005 skip_to_line (p
, l
, false);
1007 if (print_files
->f
!= NULL
)
1009 fclose (print_files
->f
);
1010 print_files
->f
= NULL
;
1016 skip_to_line (p
, line
, true);
1018 p
->next
= print_files
;
1026 f
= fopen (filename
, "r");
1031 p
= ((struct print_file_list
*)
1032 xmalloc (sizeof (struct print_file_list
)));
1033 p
->filename
= xmalloc (strlen (filename
) + 1);
1034 strcpy (p
->filename
, filename
);
1038 if (print_files
!= NULL
&& print_files
->f
!= NULL
)
1040 fclose (print_files
->f
);
1041 print_files
->f
= NULL
;
1043 p
->next
= print_files
;
1046 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1049 skip_to_line (p
, l
, false);
1051 skip_to_line (p
, line
, true);
1056 if (functionname
!= NULL
1057 && (prev_functionname
== NULL
1058 || strcmp (functionname
, prev_functionname
) != 0))
1060 if (prev_functionname
!= NULL
)
1061 free (prev_functionname
);
1062 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1063 strcpy (prev_functionname
, functionname
);
1066 if (line
> 0 && line
!= prev_line
)
1070 /* Pseudo FILE object for strings. */
1076 /* sprintf to a "stream" */
1078 #ifdef ANSI_PROTOTYPES
1080 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1085 va_start (args
, format
);
1086 vsprintf (f
->current
, format
, args
);
1087 f
->current
+= n
= strlen (f
->current
);
1093 objdump_sprintf (va_alist
)
1102 f
= va_arg (args
, SFILE
*);
1103 format
= va_arg (args
, const char *);
1104 vsprintf (f
->current
, format
, args
);
1105 f
->current
+= n
= strlen (f
->current
);
1111 /* The number of zeroes we want to see before we start skipping them.
1112 The number is arbitrarily chosen. */
1114 #define SKIP_ZEROES (8)
1116 /* The number of zeroes to skip at the end of a section. If the
1117 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1118 SKIP_ZEROES, they will be disassembled. If there are fewer than
1119 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1120 attempt to avoid disassembling zeroes inserted by section
1123 #define SKIP_ZEROES_AT_END (3)
1125 /* Disassemble some data in memory between given values. */
1128 disassemble_bytes (info
, disassemble_fn
, insns
, data
, start
, stop
, relppp
,
1130 struct disassemble_info
*info
;
1131 disassembler_ftype disassemble_fn
;
1139 struct objdump_disasm_info
*aux
;
1143 int skip_addr_chars
;
1146 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1152 bytes_per_line
= 16;
1154 /* Figure out how many characters to skip at the start of an
1155 address, to make the disassembly look nicer. We discard leading
1156 zeroes in chunks of 4, ensuring that there is always a leading
1158 skip_addr_chars
= 0;
1159 if (! prefix_addresses
)
1165 section
->vma
+ bfd_section_size (section
->owner
, section
));
1167 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1170 skip_addr_chars
+= 4;
1175 info
->insn_info_valid
= 0;
1183 boolean need_nl
= false;
1185 /* If we see more than SKIP_ZEROES bytes of zeroes, we just
1187 for (z
= i
; z
< stop
; z
++)
1190 if (! disassemble_zeroes
1191 && (info
->insn_info_valid
== 0
1192 || info
->branch_delay_insns
== 0)
1193 && (z
- i
>= SKIP_ZEROES
1194 || (z
== stop
&& z
- i
< SKIP_ZEROES_AT_END
)))
1198 /* If there are more nonzero bytes to follow, we only skip
1199 zeroes in multiples of 4, to try to avoid running over
1200 the start of an instruction which happens to start with
1203 z
= i
+ ((z
- i
) &~ 3);
1215 if (with_line_numbers
|| with_source_code
)
1216 show_line (aux
->abfd
, section
, i
);
1218 if (! prefix_addresses
)
1222 sprintf_vma (buf
, section
->vma
+ i
);
1223 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1227 printf ("%s:\t", buf
+ skip_addr_chars
);
1231 aux
->require_sec
= true;
1232 objdump_print_address (section
->vma
+ i
, info
);
1233 aux
->require_sec
= false;
1239 sfile
.buffer
= sfile
.current
= buf
;
1240 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1241 info
->stream
= (FILE *) &sfile
;
1242 info
->bytes_per_line
= 0;
1243 info
->bytes_per_chunk
= 0;
1244 bytes
= (*disassemble_fn
) (section
->vma
+ i
, info
);
1245 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1246 info
->stream
= stdout
;
1247 if (info
->bytes_per_line
!= 0)
1248 bytes_per_line
= info
->bytes_per_line
;
1256 bytes
= bytes_per_line
;
1257 if (i
+ bytes
> stop
)
1260 for (j
= i
; j
< i
+ bytes
; ++j
)
1262 if (isprint (data
[j
]))
1263 buf
[j
- i
] = data
[j
];
1270 if (prefix_addresses
1272 : show_raw_insn
>= 0)
1276 /* If ! prefix_addresses and ! wide_output, we print
1277 bytes_per_line bytes per line. */
1279 if (pb
> bytes_per_line
&& ! prefix_addresses
&& ! wide_output
)
1280 pb
= bytes_per_line
;
1282 if (info
->bytes_per_chunk
)
1283 bpc
= info
->bytes_per_chunk
;
1287 for (j
= i
; j
< i
+ pb
; j
+= bpc
)
1290 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1292 for (k
= bpc
- 1; k
>= 0; k
--)
1293 printf ("%02x", (unsigned) data
[j
+ k
]);
1298 for (k
= 0; k
< bpc
; k
++)
1299 printf ("%02x", (unsigned) data
[j
+ k
]);
1304 for (; pb
< bytes_per_line
; pb
+= bpc
)
1308 for (k
= 0; k
< bpc
; k
++)
1313 /* Separate raw data from instruction by extra space. */
1322 if (prefix_addresses
1324 : show_raw_insn
>= 0)
1334 sprintf_vma (buf
, section
->vma
+ j
);
1335 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1339 printf ("%s:\t", buf
+ skip_addr_chars
);
1341 pb
+= bytes_per_line
;
1344 for (; j
< i
+ pb
; j
+= bpc
)
1348 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1350 for (k
= bpc
- 1; k
>= 0; k
--)
1351 printf ("%02x", (unsigned) data
[j
+ k
]);
1356 for (k
= 0; k
< bpc
; k
++)
1357 printf ("%02x", (unsigned) data
[j
+ k
]);
1371 && (section
->flags
& SEC_RELOC
) != 0)
1373 while ((*relppp
) < relppend
1374 && ((**relppp
)->address
>= (bfd_vma
) i
1375 && (**relppp
)->address
< (bfd_vma
) i
+ bytes
))
1386 objdump_print_value (section
->vma
+ q
->address
, info
, true);
1388 printf (": %s\t", q
->howto
->name
);
1390 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1391 printf ("*unknown*");
1394 const char *sym_name
;
1396 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1397 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1398 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1403 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1404 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1405 if (sym_name
== NULL
|| *sym_name
== '\0')
1406 sym_name
= "*unknown*";
1407 printf ("%s", sym_name
);
1414 objdump_print_value (q
->addend
, info
, true);
1430 /* Disassemble the contents of an object file. */
1433 disassemble_data (abfd
)
1437 disassembler_ftype disassemble_fn
;
1438 struct disassemble_info disasm_info
;
1439 struct objdump_disasm_info aux
;
1443 prev_functionname
= NULL
;
1446 /* We make a copy of syms to sort. We don't want to sort syms
1447 because that will screw up the relocs. */
1448 sorted_syms
= (asymbol
**) xmalloc (symcount
* sizeof (asymbol
*));
1449 memcpy (sorted_syms
, syms
, symcount
* sizeof (asymbol
*));
1451 sorted_symcount
= remove_useless_symbols (sorted_syms
, symcount
);
1453 /* Sort the symbols into section and symbol order */
1454 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1456 INIT_DISASSEMBLE_INFO(disasm_info
, stdout
, fprintf
);
1457 disasm_info
.application_data
= (PTR
) &aux
;
1459 aux
.require_sec
= false;
1460 disasm_info
.print_address_func
= objdump_print_address
;
1462 if (machine
!= (char *) NULL
)
1464 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1467 fprintf (stderr
, "%s: Can't use supplied machine %s\n",
1472 abfd
->arch_info
= info
;
1475 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1477 struct bfd_target
*xvec
;
1479 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
1480 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1481 xvec
->byteorder
= endian
;
1485 disassemble_fn
= disassembler (abfd
);
1486 if (!disassemble_fn
)
1488 fprintf (stderr
, "%s: Can't disassemble for architecture %s\n",
1490 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1494 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1495 disasm_info
.arch
= bfd_get_arch (abfd
);
1496 disasm_info
.mach
= bfd_get_mach (abfd
);
1497 if (bfd_big_endian (abfd
))
1498 disasm_info
.endian
= BFD_ENDIAN_BIG
;
1499 else if (bfd_little_endian (abfd
))
1500 disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1502 /* ??? Aborting here seems too drastic. We could default to big or little
1504 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1506 for (section
= abfd
->sections
;
1507 section
!= (asection
*) NULL
;
1508 section
= section
->next
)
1510 bfd_byte
*data
= NULL
;
1511 bfd_size_type datasize
= 0;
1512 arelent
**relbuf
= NULL
;
1513 arelent
**relpp
= NULL
;
1514 arelent
**relppend
= NULL
;
1517 if ((section
->flags
& SEC_LOAD
) == 0
1518 || (! disassemble_all
1520 && (section
->flags
& SEC_CODE
) == 0))
1522 if (only
!= (char *) NULL
&& strcmp (only
, section
->name
) != 0)
1526 && (section
->flags
& SEC_RELOC
) != 0)
1530 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1532 bfd_fatal (bfd_get_filename (abfd
));
1538 relbuf
= (arelent
**) xmalloc (relsize
);
1539 relcount
= bfd_canonicalize_reloc (abfd
, section
, relbuf
, syms
);
1541 bfd_fatal (bfd_get_filename (abfd
));
1543 /* Sort the relocs by address. */
1544 qsort (relbuf
, relcount
, sizeof (arelent
*), compare_relocs
);
1547 relppend
= relpp
+ relcount
;
1551 printf ("Disassembly of section %s:\n", section
->name
);
1553 datasize
= bfd_get_section_size_before_reloc (section
);
1557 data
= (bfd_byte
*) xmalloc ((size_t) datasize
);
1559 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1562 disasm_info
.buffer
= data
;
1563 disasm_info
.buffer_vma
= section
->vma
;
1564 disasm_info
.buffer_length
= datasize
;
1565 if (start_address
== (bfd_vma
) -1
1566 || start_address
< disasm_info
.buffer_vma
)
1569 i
= start_address
- disasm_info
.buffer_vma
;
1570 if (stop_address
== (bfd_vma
) -1)
1574 if (stop_address
< disasm_info
.buffer_vma
)
1577 stop
= stop_address
- disasm_info
.buffer_vma
;
1578 if (stop
> disasm_info
.buffer_length
)
1579 stop
= disasm_info
.buffer_length
;
1582 if(1) /* with or without prefix_addresses */
1587 sym
= find_symbol_for_address (abfd
, section
, section
->vma
+ i
,
1596 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= section
->vma
+ i
)
1597 disasm_info
.symbol
= sym
;
1599 disasm_info
.symbol
= NULL
;
1601 if (! prefix_addresses
)
1604 objdump_print_addr_with_sym (abfd
, section
, sym
,
1611 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ i
)
1613 else if (sym
== NULL
)
1617 while (place
< sorted_symcount
1618 && (sorted_syms
[place
]->section
!= section
1619 || (bfd_asymbol_value (sorted_syms
[place
])
1620 <= bfd_asymbol_value (sym
))))
1622 if (place
>= sorted_symcount
)
1625 nextsym
= sorted_syms
[place
];
1628 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ i
)
1630 nextstop
= bfd_asymbol_value (sym
) - section
->vma
;
1631 if (nextstop
> stop
)
1634 else if (nextsym
== NULL
)
1638 nextstop
= bfd_asymbol_value (nextsym
) - section
->vma
;
1639 if (nextstop
> stop
)
1643 /* If a symbol is explicitly marked as being an object
1644 rather than a function, just dump the bytes without
1645 disassembling them. */
1648 || bfd_asymbol_value (sym
) > section
->vma
+ i
1649 || ((sym
->flags
& BSF_OBJECT
) == 0
1650 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1652 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1654 || (sym
->flags
& BSF_FUNCTION
) != 0)
1659 disassemble_bytes (&disasm_info
, disassemble_fn
, insns
, data
, i
,
1660 nextstop
, &relpp
, relppend
);
1675 /* Define a table of stab values and print-strings. We wish the initializer
1676 could be a direct-mapped table, but instead we build one the first
1679 static void dump_section_stabs
PARAMS ((bfd
*abfd
, char *stabsect_name
,
1680 char *strsect_name
));
1682 /* Dump the stabs sections from an object file that has a section that
1683 uses Sun stabs encoding. */
1689 dump_section_stabs (abfd
, ".stab", ".stabstr");
1690 dump_section_stabs (abfd
, ".stab.excl", ".stab.exclstr");
1691 dump_section_stabs (abfd
, ".stab.index", ".stab.indexstr");
1692 dump_section_stabs (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1695 static bfd_byte
*stabs
;
1696 static bfd_size_type stab_size
;
1698 static char *strtab
;
1699 static bfd_size_type stabstr_size
;
1701 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1702 and string table section STRSECT_NAME into `strtab'.
1703 If the section exists and was read, allocate the space and return true.
1704 Otherwise return false. */
1707 read_section_stabs (abfd
, stabsect_name
, strsect_name
)
1709 const char *stabsect_name
;
1710 const char *strsect_name
;
1712 asection
*stabsect
, *stabstrsect
;
1714 stabsect
= bfd_get_section_by_name (abfd
, stabsect_name
);
1717 printf ("No %s section present\n\n", stabsect_name
);
1721 stabstrsect
= bfd_get_section_by_name (abfd
, strsect_name
);
1722 if (0 == stabstrsect
)
1724 fprintf (stderr
, "%s: %s has no %s section\n", program_name
,
1725 bfd_get_filename (abfd
), strsect_name
);
1729 stab_size
= bfd_section_size (abfd
, stabsect
);
1730 stabstr_size
= bfd_section_size (abfd
, stabstrsect
);
1732 stabs
= (bfd_byte
*) xmalloc (stab_size
);
1733 strtab
= (char *) xmalloc (stabstr_size
);
1735 if (! bfd_get_section_contents (abfd
, stabsect
, (PTR
) stabs
, 0, stab_size
))
1737 fprintf (stderr
, "%s: Reading %s section of %s failed: %s\n",
1738 program_name
, stabsect_name
, bfd_get_filename (abfd
),
1739 bfd_errmsg (bfd_get_error ()));
1745 if (! bfd_get_section_contents (abfd
, stabstrsect
, (PTR
) strtab
, 0,
1748 fprintf (stderr
, "%s: Reading %s section of %s failed: %s\n",
1749 program_name
, strsect_name
, bfd_get_filename (abfd
),
1750 bfd_errmsg (bfd_get_error ()));
1759 /* Stabs entries use a 12 byte format:
1760 4 byte string table index
1762 1 byte stab other field
1763 2 byte stab desc field
1765 FIXME: This will have to change for a 64 bit object format. */
1767 #define STRDXOFF (0)
1769 #define OTHEROFF (5)
1772 #define STABSIZE (12)
1774 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1775 using string table section STRSECT_NAME (in `strtab'). */
1778 print_section_stabs (abfd
, stabsect_name
, strsect_name
)
1780 const char *stabsect_name
;
1781 const char *strsect_name
;
1784 unsigned file_string_table_offset
= 0, next_file_string_table_offset
= 0;
1785 bfd_byte
*stabp
, *stabs_end
;
1788 stabs_end
= stabp
+ stab_size
;
1790 printf ("Contents of %s section:\n\n", stabsect_name
);
1791 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1793 /* Loop through all symbols and print them.
1795 We start the index at -1 because there is a dummy symbol on
1796 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1798 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
1802 unsigned char type
, other
;
1803 unsigned short desc
;
1806 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
1807 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
1808 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
1809 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
1810 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
1812 printf ("\n%-6d ", i
);
1813 /* Either print the stab name, or, if unnamed, print its number
1814 again (makes consistent formatting for tools like awk). */
1815 name
= bfd_get_stab_name (type
);
1817 printf ("%-6s", name
);
1818 else if (type
== N_UNDF
)
1821 printf ("%-6d", type
);
1822 printf (" %-6d %-6d ", other
, desc
);
1824 printf (" %-6lu", strx
);
1826 /* Symbols with type == 0 (N_UNDF) specify the length of the
1827 string table associated with this file. We use that info
1828 to know how to relocate the *next* file's string table indices. */
1832 file_string_table_offset
= next_file_string_table_offset
;
1833 next_file_string_table_offset
+= value
;
1837 /* Using the (possibly updated) string table offset, print the
1838 string (if any) associated with this symbol. */
1840 if ((strx
+ file_string_table_offset
) < stabstr_size
)
1841 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
1850 dump_section_stabs (abfd
, stabsect_name
, strsect_name
)
1852 char *stabsect_name
;
1857 /* Check for section names for which stabsect_name is a prefix, to
1858 handle .stab0, etc. */
1859 for (s
= abfd
->sections
;
1865 len
= strlen (stabsect_name
);
1867 /* If the prefix matches, and the files section name ends with a nul or a digit,
1868 then we match. Ie: we want either an exact match or a a section followed by
1870 if (strncmp (stabsect_name
, s
->name
, len
) == 0
1871 && (s
->name
[len
] == '\000' || isdigit (s
->name
[len
])))
1873 if (read_section_stabs (abfd
, s
->name
, strsect_name
))
1875 print_section_stabs (abfd
, s
->name
, strsect_name
);
1884 dump_bfd_header (abfd
)
1889 printf ("architecture: %s, ",
1890 bfd_printable_arch_mach (bfd_get_arch (abfd
),
1891 bfd_get_mach (abfd
)));
1892 printf ("flags 0x%08x:\n", abfd
->flags
);
1894 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
1895 PF (HAS_RELOC
, "HAS_RELOC");
1896 PF (EXEC_P
, "EXEC_P");
1897 PF (HAS_LINENO
, "HAS_LINENO");
1898 PF (HAS_DEBUG
, "HAS_DEBUG");
1899 PF (HAS_SYMS
, "HAS_SYMS");
1900 PF (HAS_LOCALS
, "HAS_LOCALS");
1901 PF (DYNAMIC
, "DYNAMIC");
1902 PF (WP_TEXT
, "WP_TEXT");
1903 PF (D_PAGED
, "D_PAGED");
1904 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
1905 printf ("\nstart address 0x");
1906 printf_vma (abfd
->start_address
);
1911 dump_bfd_private_header (abfd
)
1914 bfd_print_private_bfd_data (abfd
, stdout
);
1923 if (!bfd_check_format_matches (abfd
, bfd_object
, &matching
))
1925 bfd_nonfatal (bfd_get_filename (abfd
));
1926 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1928 list_matching_formats (matching
);
1934 /* If we are adjusting section VMA's, change them all now. Changing
1935 the BFD information is a hack. However, we must do it, or
1936 bfd_find_nearest_line will not do the right thing. */
1937 if (adjust_section_vma
!= 0)
1941 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1943 s
->vma
+= adjust_section_vma
;
1944 s
->lma
+= adjust_section_vma
;
1948 printf ("\n%s: file format %s\n", bfd_get_filename (abfd
),
1951 print_arelt_descr (stdout
, abfd
, true);
1952 if (dump_file_header
)
1953 dump_bfd_header (abfd
);
1954 if (dump_private_headers
)
1955 dump_bfd_private_header (abfd
);
1957 if (dump_section_headers
)
1958 dump_headers (abfd
);
1959 if (dump_symtab
|| dump_reloc_info
|| disassemble
|| dump_debugging
)
1961 syms
= slurp_symtab (abfd
);
1963 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
)
1965 dynsyms
= slurp_dynamic_symtab (abfd
);
1968 dump_symbols (abfd
, false);
1969 if (dump_dynamic_symtab
)
1970 dump_symbols (abfd
, true);
1971 if (dump_stab_section_info
)
1973 if (dump_reloc_info
&& ! disassemble
)
1975 if (dump_dynamic_reloc_info
)
1976 dump_dynamic_relocs (abfd
);
1977 if (dump_section_contents
)
1980 disassemble_data (abfd
);
1985 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
1986 if (dhandle
!= NULL
)
1988 if (! print_debugging_info (stdout
, dhandle
))
1989 fprintf (stderr
, "%s: printing debugging information failed\n",
1990 bfd_get_filename (abfd
));
2006 display_file (filename
, target
)
2010 bfd
*file
, *arfile
= (bfd
*) NULL
;
2012 file
= bfd_openr (filename
, target
);
2015 bfd_nonfatal (filename
);
2019 if (bfd_check_format (file
, bfd_archive
) == true)
2021 bfd
*last_arfile
= NULL
;
2023 printf ("In archive %s:\n", bfd_get_filename (file
));
2026 bfd_set_error (bfd_error_no_error
);
2028 arfile
= bfd_openr_next_archived_file (file
, arfile
);
2031 if (bfd_get_error () != bfd_error_no_more_archived_files
)
2033 bfd_nonfatal (bfd_get_filename (file
));
2038 display_bfd (arfile
);
2040 if (last_arfile
!= NULL
)
2041 bfd_close (last_arfile
);
2042 last_arfile
= arfile
;
2045 if (last_arfile
!= NULL
)
2046 bfd_close (last_arfile
);
2054 /* Actually display the various requested regions */
2062 bfd_size_type datasize
= 0;
2064 bfd_size_type start
, stop
;
2066 for (section
= abfd
->sections
; section
!= NULL
; section
=
2071 if (only
== (char *) NULL
||
2072 strcmp (only
, section
->name
) == 0)
2074 if (section
->flags
& SEC_HAS_CONTENTS
)
2076 printf ("Contents of section %s:\n", section
->name
);
2078 if (bfd_section_size (abfd
, section
) == 0)
2080 data
= (bfd_byte
*) xmalloc ((size_t) bfd_section_size (abfd
, section
));
2081 datasize
= bfd_section_size (abfd
, section
);
2084 bfd_get_section_contents (abfd
, section
, (PTR
) data
, 0, bfd_section_size (abfd
, section
));
2086 if (start_address
== (bfd_vma
) -1
2087 || start_address
< section
->vma
)
2090 start
= start_address
- section
->vma
;
2091 if (stop_address
== (bfd_vma
) -1)
2092 stop
= bfd_section_size (abfd
, section
);
2095 if (stop_address
< section
->vma
)
2098 stop
= stop_address
- section
->vma
;
2099 if (stop
> bfd_section_size (abfd
, section
))
2100 stop
= bfd_section_size (abfd
, section
);
2102 for (i
= start
; i
< stop
; i
+= onaline
)
2106 printf (" %04lx ", (unsigned long int) (i
+ section
->vma
));
2107 for (j
= i
; j
< i
+ onaline
; j
++)
2110 printf ("%02x", (unsigned) (data
[j
]));
2118 for (j
= i
; j
< i
+ onaline
; j
++)
2123 printf ("%c", isprint (data
[j
]) ? data
[j
] : '.');
2133 /* Should perhaps share code and display with nm? */
2135 dump_symbols (abfd
, dynamic
)
2149 printf ("DYNAMIC SYMBOL TABLE:\n");
2157 printf ("SYMBOL TABLE:\n");
2160 for (count
= 0; count
< max
; count
++)
2164 bfd
*cur_bfd
= bfd_asymbol_bfd (*current
);
2166 if (cur_bfd
!= NULL
)
2171 name
= bfd_asymbol_name (*current
);
2173 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2177 /* If we want to demangle the name, we demangle it
2178 here, and temporarily clobber it while calling
2179 bfd_print_symbol. FIXME: This is a gross hack. */
2182 if (bfd_get_symbol_leading_char (cur_bfd
) == *n
)
2184 alloc
= cplus_demangle (n
, DMGL_ANSI
| DMGL_PARAMS
);
2186 (*current
)->name
= alloc
;
2188 (*current
)->name
= n
;
2191 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2192 bfd_print_symbol_all
);
2194 (*current
)->name
= name
;
2215 for (a
= abfd
->sections
; a
!= (asection
*) NULL
; a
= a
->next
)
2219 if (bfd_is_abs_section (a
))
2221 if (bfd_is_und_section (a
))
2223 if (bfd_is_com_section (a
))
2228 if (strcmp (only
, a
->name
))
2231 else if ((a
->flags
& SEC_RELOC
) == 0)
2234 relsize
= bfd_get_reloc_upper_bound (abfd
, a
);
2236 bfd_fatal (bfd_get_filename (abfd
));
2238 printf ("RELOCATION RECORDS FOR [%s]:", a
->name
);
2242 printf (" (none)\n\n");
2246 relpp
= (arelent
**) xmalloc (relsize
);
2247 relcount
= bfd_canonicalize_reloc (abfd
, a
, relpp
, syms
);
2249 bfd_fatal (bfd_get_filename (abfd
));
2250 else if (relcount
== 0)
2252 printf (" (none)\n\n");
2257 dump_reloc_set (abfd
, a
, relpp
, relcount
);
2266 dump_dynamic_relocs (abfd
)
2273 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2275 bfd_fatal (bfd_get_filename (abfd
));
2277 printf ("DYNAMIC RELOCATION RECORDS");
2281 printf (" (none)\n\n");
2285 relpp
= (arelent
**) xmalloc (relsize
);
2286 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2288 bfd_fatal (bfd_get_filename (abfd
));
2289 else if (relcount
== 0)
2291 printf (" (none)\n\n");
2296 dump_reloc_set (abfd
, (asection
*) NULL
, relpp
, relcount
);
2304 dump_reloc_set (abfd
, sec
, relpp
, relcount
)
2311 char *last_filename
, *last_functionname
;
2312 unsigned int last_line
;
2314 /* Get column headers lined up reasonably. */
2320 sprintf_vma (buf
, (bfd_vma
) -1);
2321 width
= strlen (buf
) - 7;
2323 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2326 last_filename
= NULL
;
2327 last_functionname
= NULL
;
2330 for (p
= relpp
; relcount
&& *p
!= (arelent
*) NULL
; p
++, relcount
--)
2333 const char *filename
, *functionname
;
2335 const char *sym_name
;
2336 const char *section_name
;
2338 if (start_address
!= (bfd_vma
) -1
2339 && q
->address
< start_address
)
2341 if (stop_address
!= (bfd_vma
) -1
2342 && q
->address
> stop_address
)
2345 if (with_line_numbers
2347 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2348 &filename
, &functionname
, &line
))
2350 if (functionname
!= NULL
2351 && (last_functionname
== NULL
2352 || strcmp (functionname
, last_functionname
) != 0))
2354 printf ("%s():\n", functionname
);
2355 if (last_functionname
!= NULL
)
2356 free (last_functionname
);
2357 last_functionname
= xstrdup (functionname
);
2360 && (line
!= last_line
2361 || (filename
!= NULL
2362 && last_filename
!= NULL
2363 && strcmp (filename
, last_filename
) != 0)))
2365 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2367 if (last_filename
!= NULL
)
2368 free (last_filename
);
2369 if (filename
== NULL
)
2370 last_filename
= NULL
;
2372 last_filename
= xstrdup (filename
);
2376 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2378 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2379 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2384 section_name
= NULL
;
2388 printf_vma (q
->address
);
2389 printf (" %-16s ", q
->howto
->name
);
2390 objdump_print_symname (abfd
, (struct disassemble_info
*) NULL
,
2395 if (section_name
== (CONST
char *) NULL
)
2396 section_name
= "*unknown*";
2397 printf_vma (q
->address
);
2398 printf (" %-16s [%s]",
2405 printf_vma (q
->addend
);
2411 /* The length of the longest architecture name + 1. */
2412 #define LONGEST_ARCH sizeof("rs6000:6000")
2415 endian_string (endian
)
2416 enum bfd_endian endian
;
2418 if (endian
== BFD_ENDIAN_BIG
)
2419 return "big endian";
2420 else if (endian
== BFD_ENDIAN_LITTLE
)
2421 return "little endian";
2423 return "endianness unknown";
2426 /* List the targets that BFD is configured to support, each followed
2427 by its endianness and the architectures it supports. */
2430 display_target_list ()
2432 extern bfd_target
*bfd_target_vector
[];
2436 dummy_name
= choose_temp_base ();
2437 for (t
= 0; bfd_target_vector
[t
]; t
++)
2439 bfd_target
*p
= bfd_target_vector
[t
];
2440 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2443 printf ("%s\n (header %s, data %s)\n", p
->name
,
2444 endian_string (p
->header_byteorder
),
2445 endian_string (p
->byteorder
));
2449 bfd_nonfatal (dummy_name
);
2453 if (! bfd_set_format (abfd
, bfd_object
))
2455 if (bfd_get_error () != bfd_error_invalid_operation
)
2456 bfd_nonfatal (p
->name
);
2460 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2461 if (bfd_set_arch_mach (abfd
, (enum bfd_architecture
) a
, 0))
2463 bfd_printable_arch_mach ((enum bfd_architecture
) a
, 0));
2465 unlink (dummy_name
);
2469 /* Print a table showing which architectures are supported for entries
2470 FIRST through LAST-1 of bfd_target_vector (targets across,
2471 architectures down). */
2474 display_info_table (first
, last
)
2478 extern bfd_target
*bfd_target_vector
[];
2482 /* Print heading of target names. */
2483 printf ("\n%*s", (int) LONGEST_ARCH
, " ");
2484 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2485 printf ("%s ", bfd_target_vector
[t
]->name
);
2488 dummy_name
= choose_temp_base ();
2489 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2490 if (strcmp (bfd_printable_arch_mach (a
, 0), "UNKNOWN!") != 0)
2492 printf ("%*s ", (int) LONGEST_ARCH
- 1,
2493 bfd_printable_arch_mach (a
, 0));
2494 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2496 bfd_target
*p
= bfd_target_vector
[t
];
2498 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2502 bfd_nonfatal (p
->name
);
2508 if (! bfd_set_format (abfd
, bfd_object
))
2510 if (bfd_get_error () != bfd_error_invalid_operation
)
2511 bfd_nonfatal (p
->name
);
2518 if (! bfd_set_arch_mach (abfd
, a
, 0))
2523 printf ("%s ", p
->name
);
2526 int l
= strlen (p
->name
);
2534 unlink (dummy_name
);
2538 /* Print tables of all the target-architecture combinations that
2539 BFD has been configured to support. */
2542 display_target_tables ()
2545 extern bfd_target
*bfd_target_vector
[];
2549 colum
= getenv ("COLUMNS");
2551 columns
= atoi (colum
);
2556 while (bfd_target_vector
[t
] != NULL
)
2560 wid
= LONGEST_ARCH
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2562 while (wid
< columns
&& bfd_target_vector
[t
] != NULL
)
2566 newwid
= wid
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2567 if (newwid
>= columns
)
2572 display_info_table (oldt
, t
);
2579 printf ("BFD header file version %s\n", BFD_VERSION
);
2580 display_target_list ();
2581 display_target_tables ();
2590 char *target
= default_target
;
2591 boolean seenflag
= false;
2593 program_name
= *argv
;
2594 xmalloc_set_program_name (program_name
);
2596 START_PROGRESS (program_name
, 0);
2599 set_default_bfd_target ();
2601 while ((c
= getopt_long (argc
, argv
, "pib:m:VCdDlfahrRtTxsSj:wE:",
2602 long_options
, (int *) 0))
2605 if (c
!= 'l' && c
!= OPTION_START_ADDRESS
&& c
!= OPTION_STOP_ADDRESS
)
2610 break; /* we've been given a long option */
2618 with_line_numbers
= 1;
2624 dump_file_header
= true;
2627 formats_info
= true;
2630 dump_private_headers
= 1;
2633 dump_private_headers
= 1;
2635 dump_reloc_info
= 1;
2636 dump_file_header
= true;
2638 dump_section_headers
= 1;
2644 dump_dynamic_symtab
= 1;
2653 disassemble
= disassemble_all
= true;
2657 with_source_code
= true;
2660 dump_section_contents
= 1;
2663 dump_reloc_info
= 1;
2666 dump_dynamic_reloc_info
= 1;
2672 dump_section_headers
= 1;
2682 case OPTION_ADJUST_VMA
:
2683 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
2685 case OPTION_START_ADDRESS
:
2686 start_address
= parse_vma (optarg
, "--start-address");
2688 case OPTION_STOP_ADDRESS
:
2689 stop_address
= parse_vma (optarg
, "--stop-address");
2692 if (strcmp (optarg
, "B") == 0)
2693 endian
= BFD_ENDIAN_BIG
;
2694 else if (strcmp (optarg
, "L") == 0)
2695 endian
= BFD_ENDIAN_LITTLE
;
2698 fprintf (stderr
, "%s: unrecognized -E option\n", program_name
);
2703 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
2704 endian
= BFD_ENDIAN_BIG
;
2705 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
2706 endian
= BFD_ENDIAN_LITTLE
;
2709 fprintf (stderr
, "%s: unrecognized --endian type `%s'\n",
2710 program_name
, optarg
);
2720 print_version ("objdump");
2722 if (seenflag
== false)
2732 display_file ("a.out", target
);
2734 for (; optind
< argc
;)
2735 display_file (argv
[optind
++], target
);
2738 END_PROGRESS (program_name
);