1 /* objdump.c -- dump information about an object file.
2 Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 1999
3 Free Software Foundation, Inc.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
27 #include "libiberty.h"
32 #ifdef ANSI_PROTOTYPES
38 /* Internal headers for the ELF .stab-dump code - sorry. */
39 #define BYTES_IN_WORD 32
40 #include "aout/aout64.h"
42 #ifdef NEED_DECLARATION_FPRINTF
43 /* This is needed by INIT_DISASSEMBLE_INFO. */
44 extern int fprintf
PARAMS ((FILE *, const char *, ...));
47 static char *default_target
= NULL
; /* default at runtime */
49 static int show_version
= 0; /* show the version number */
50 static int dump_section_contents
; /* -s */
51 static int dump_section_headers
; /* -h */
52 static boolean dump_file_header
; /* -f */
53 static int dump_symtab
; /* -t */
54 static int dump_dynamic_symtab
; /* -T */
55 static int dump_reloc_info
; /* -r */
56 static int dump_dynamic_reloc_info
; /* -R */
57 static int dump_ar_hdrs
; /* -a */
58 static int dump_private_headers
; /* -p */
59 static int prefix_addresses
; /* --prefix-addresses */
60 static int with_line_numbers
; /* -l */
61 static boolean with_source_code
; /* -S */
62 static int show_raw_insn
; /* --show-raw-insn */
63 static int dump_stab_section_info
; /* --stabs */
64 static int do_demangle
; /* -C, --demangle */
65 static boolean disassemble
; /* -d */
66 static boolean disassemble_all
; /* -D */
67 static int disassemble_zeroes
; /* --disassemble-zeroes */
68 static boolean formats_info
; /* -i */
69 static char *only
; /* -j secname */
70 static int wide_output
; /* -w */
71 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
72 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
73 static int dump_debugging
; /* --debugging */
74 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
76 /* Extra info to pass to the disassembler address printing function. */
77 struct objdump_disasm_info
{
83 /* Architecture to disassemble for, or default if NULL. */
84 static char *machine
= (char *) NULL
;
86 /* Target specific options to the disassembler. */
87 static char *disassembler_options
= (char *) NULL
;
89 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
90 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
92 /* The symbol table. */
93 static asymbol
**syms
;
95 /* Number of symbols in `syms'. */
96 static long symcount
= 0;
98 /* The sorted symbol table. */
99 static asymbol
**sorted_syms
;
101 /* Number of symbols in `sorted_syms'. */
102 static long sorted_symcount
= 0;
104 /* The dynamic symbol table. */
105 static asymbol
**dynsyms
;
107 /* Number of symbols in `dynsyms'. */
108 static long dynsymcount
= 0;
110 /* Static declarations. */
113 usage
PARAMS ((FILE *, int));
116 display_file
PARAMS ((char *filename
, char *target
));
119 dump_section_header
PARAMS ((bfd
*, asection
*, PTR
));
122 dump_headers
PARAMS ((bfd
*));
125 dump_data
PARAMS ((bfd
*abfd
));
128 dump_relocs
PARAMS ((bfd
*abfd
));
131 dump_dynamic_relocs
PARAMS ((bfd
* abfd
));
134 dump_reloc_set
PARAMS ((bfd
*, asection
*, arelent
**, long));
137 dump_symbols
PARAMS ((bfd
*abfd
, boolean dynamic
));
140 dump_bfd_header
PARAMS ((bfd
*));
143 dump_bfd_private_header
PARAMS ((bfd
*));
146 display_bfd
PARAMS ((bfd
*abfd
));
149 display_target_list
PARAMS ((void));
152 display_info_table
PARAMS ((int, int));
155 display_target_tables
PARAMS ((void));
158 display_info
PARAMS ((void));
161 objdump_print_value
PARAMS ((bfd_vma
, struct disassemble_info
*, boolean
));
164 objdump_print_symname
PARAMS ((bfd
*, struct disassemble_info
*, asymbol
*));
167 find_symbol_for_address
PARAMS ((bfd
*, asection
*, bfd_vma
, boolean
, long *));
170 objdump_print_addr_with_sym
PARAMS ((bfd
*, asection
*, asymbol
*, bfd_vma
,
171 struct disassemble_info
*, boolean
));
174 objdump_print_addr
PARAMS ((bfd_vma
, struct disassemble_info
*, boolean
));
177 objdump_print_address
PARAMS ((bfd_vma
, struct disassemble_info
*));
180 show_line
PARAMS ((bfd
*, asection
*, bfd_vma
));
183 disassemble_bytes
PARAMS ((struct disassemble_info
*, disassembler_ftype
,
184 boolean
, bfd_byte
*, bfd_vma
, bfd_vma
,
185 arelent
***, arelent
**));
188 disassemble_data
PARAMS ((bfd
*));
191 endian_string
PARAMS ((enum bfd_endian
));
194 slurp_symtab
PARAMS ((bfd
*));
197 slurp_dynamic_symtab
PARAMS ((bfd
*));
200 remove_useless_symbols
PARAMS ((asymbol
**, long));
203 compare_symbols
PARAMS ((const PTR
, const PTR
));
206 compare_relocs
PARAMS ((const PTR
, const PTR
));
209 dump_stabs
PARAMS ((bfd
*));
212 read_section_stabs
PARAMS ((bfd
*, const char *, const char *));
215 print_section_stabs
PARAMS ((bfd
*, const char *, const char *));
218 usage (stream
, status
)
222 fprintf (stream
, _("\
223 Usage: %s [-ahifCdDprRtTxsSlw] [-b bfdname] [-m machine] \n\
224 [-j section-name] [-M disassembler-options]\n\
225 [--archive-headers] [--target=bfdname] [--debugging] [--disassemble]\n\
226 [--disassemble-all] [--disassemble-zeroes] [--file-headers]\n\
227 [--section-headers] [--headers]\n\
228 [--info] [--section=section-name] [--line-numbers] [--source]\n"),
230 fprintf (stream
, _("\
231 [--architecture=machine] [--reloc] [--full-contents] [--stabs]\n\
232 [--syms] [--all-headers] [--dynamic-syms] [--dynamic-reloc]\n\
233 [--wide] [--version] [--help] [--private-headers]\n\
234 [--start-address=addr] [--stop-address=addr]\n\
235 [--prefix-addresses] [--[no-]show-raw-insn] [--demangle]\n\
236 [--adjust-vma=offset] [-EB|-EL] [--endian={big|little}] objfile...\n\
237 at least one option besides -l (--line-numbers) must be given\n"));
238 list_supported_targets (program_name
, stream
);
240 fprintf (stream
, _("Report bugs to bug-gnu-utils@gnu.org\n"));
244 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
246 #define OPTION_ENDIAN (150)
247 #define OPTION_START_ADDRESS (OPTION_ENDIAN + 1)
248 #define OPTION_STOP_ADDRESS (OPTION_START_ADDRESS + 1)
249 #define OPTION_ADJUST_VMA (OPTION_STOP_ADDRESS + 1)
251 static struct option long_options
[]=
253 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
254 {"all-headers", no_argument
, NULL
, 'x'},
255 {"private-headers", no_argument
, NULL
, 'p'},
256 {"architecture", required_argument
, NULL
, 'm'},
257 {"archive-headers", no_argument
, NULL
, 'a'},
258 {"debugging", no_argument
, &dump_debugging
, 1},
259 {"demangle", no_argument
, &do_demangle
, 1},
260 {"disassemble", no_argument
, NULL
, 'd'},
261 {"disassemble-all", no_argument
, NULL
, 'D'},
262 {"disassembler-options", required_argument
, NULL
, 'M'},
263 {"disassemble-zeroes", no_argument
, &disassemble_zeroes
, 1},
264 {"dynamic-reloc", no_argument
, NULL
, 'R'},
265 {"dynamic-syms", no_argument
, NULL
, 'T'},
266 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
267 {"file-headers", no_argument
, NULL
, 'f'},
268 {"full-contents", no_argument
, NULL
, 's'},
269 {"headers", no_argument
, NULL
, 'h'},
270 {"help", no_argument
, NULL
, 'H'},
271 {"info", no_argument
, NULL
, 'i'},
272 {"line-numbers", no_argument
, NULL
, 'l'},
273 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
274 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
275 {"reloc", no_argument
, NULL
, 'r'},
276 {"section", required_argument
, NULL
, 'j'},
277 {"section-headers", no_argument
, NULL
, 'h'},
278 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
279 {"source", no_argument
, NULL
, 'S'},
280 {"stabs", no_argument
, &dump_stab_section_info
, 1},
281 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
282 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
283 {"syms", no_argument
, NULL
, 't'},
284 {"target", required_argument
, NULL
, 'b'},
285 {"version", no_argument
, &show_version
, 1},
286 {"wide", no_argument
, &wide_output
, 'w'},
287 {0, no_argument
, 0, 0}
291 dump_section_header (abfd
, section
, ignored
)
292 bfd
*abfd ATTRIBUTE_UNUSED
;
294 PTR ignored ATTRIBUTE_UNUSED
;
298 printf ("%3d %-13s %08lx ", section
->index
,
299 bfd_get_section_name (abfd
, section
),
300 (unsigned long) bfd_section_size (abfd
, section
));
301 printf_vma (bfd_get_section_vma (abfd
, section
));
303 printf_vma (section
->lma
);
304 printf (" %08lx 2**%u", section
->filepos
,
305 bfd_get_section_alignment (abfd
, section
));
311 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
313 PF (SEC_HAS_CONTENTS
, "CONTENTS");
314 PF (SEC_ALLOC
, "ALLOC");
315 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
316 PF (SEC_CONSTRUCTOR_TEXT
, "CONSTRUCTOR TEXT");
317 PF (SEC_CONSTRUCTOR_DATA
, "CONSTRUCTOR DATA");
318 PF (SEC_CONSTRUCTOR_BSS
, "CONSTRUCTOR BSS");
319 PF (SEC_LOAD
, "LOAD");
320 PF (SEC_RELOC
, "RELOC");
322 PF (SEC_BALIGN
, "BALIGN");
324 PF (SEC_READONLY
, "READONLY");
325 PF (SEC_CODE
, "CODE");
326 PF (SEC_DATA
, "DATA");
328 PF (SEC_DEBUGGING
, "DEBUGGING");
329 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
330 PF (SEC_EXCLUDE
, "EXCLUDE");
331 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
333 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
337 switch (section
->flags
& SEC_LINK_DUPLICATES
)
341 case SEC_LINK_DUPLICATES_DISCARD
:
342 ls
= "LINK_ONCE_DISCARD";
344 case SEC_LINK_DUPLICATES_ONE_ONLY
:
345 ls
= "LINK_ONCE_ONE_ONLY";
347 case SEC_LINK_DUPLICATES_SAME_SIZE
:
348 ls
= "LINK_ONCE_SAME_SIZE";
350 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
351 ls
= "LINK_ONCE_SAME_CONTENTS";
354 printf ("%s%s", comma
, ls
);
366 printf (_("Sections:\n"));
368 printf (_("Idx Name Size VMA LMA File off Algn\n"));
370 printf (_("Idx Name Size VMA LMA File off Algn\n"));
372 bfd_map_over_sections (abfd
, dump_section_header
, (PTR
) NULL
);
379 asymbol
**sy
= (asymbol
**) NULL
;
382 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
384 fprintf (stderr
, _("%s: no symbols\n"), bfd_get_filename (abfd
));
389 storage
= bfd_get_symtab_upper_bound (abfd
);
391 bfd_fatal (bfd_get_filename (abfd
));
395 sy
= (asymbol
**) xmalloc (storage
);
397 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
399 bfd_fatal (bfd_get_filename (abfd
));
401 fprintf (stderr
, _("%s: no symbols\n"), bfd_get_filename (abfd
));
405 /* Read in the dynamic symbols. */
408 slurp_dynamic_symtab (abfd
)
411 asymbol
**sy
= (asymbol
**) NULL
;
414 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
417 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
419 fprintf (stderr
, _("%s: %s: not a dynamic object\n"),
420 program_name
, bfd_get_filename (abfd
));
425 bfd_fatal (bfd_get_filename (abfd
));
430 sy
= (asymbol
**) xmalloc (storage
);
432 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
434 bfd_fatal (bfd_get_filename (abfd
));
435 if (dynsymcount
== 0)
436 fprintf (stderr
, _("%s: %s: No dynamic symbols\n"),
437 program_name
, bfd_get_filename (abfd
));
441 /* Filter out (in place) symbols that are useless for disassembly.
442 COUNT is the number of elements in SYMBOLS.
443 Return the number of useful symbols. */
446 remove_useless_symbols (symbols
, count
)
450 register asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
454 asymbol
*sym
= *in_ptr
++;
456 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
458 if (sym
->flags
& (BSF_DEBUGGING
))
460 if (bfd_is_und_section (sym
->section
)
461 || bfd_is_com_section (sym
->section
))
466 return out_ptr
- symbols
;
469 /* Sort symbols into value order. */
472 compare_symbols (ap
, bp
)
476 const asymbol
*a
= *(const asymbol
**)ap
;
477 const asymbol
*b
= *(const asymbol
**)bp
;
481 flagword aflags
, bflags
;
483 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
485 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
488 if (a
->section
> b
->section
)
490 else if (a
->section
< b
->section
)
493 an
= bfd_asymbol_name (a
);
494 bn
= bfd_asymbol_name (b
);
498 /* The symbols gnu_compiled and gcc2_compiled convey no real
499 information, so put them after other symbols with the same value. */
501 af
= (strstr (an
, "gnu_compiled") != NULL
502 || strstr (an
, "gcc2_compiled") != NULL
);
503 bf
= (strstr (bn
, "gnu_compiled") != NULL
504 || strstr (bn
, "gcc2_compiled") != NULL
);
511 /* We use a heuristic for the file name, to try to sort it after
512 more useful symbols. It may not work on non Unix systems, but it
513 doesn't really matter; the only difference is precisely which
514 symbol names get printed. */
516 #define file_symbol(s, sn, snl) \
517 (((s)->flags & BSF_FILE) != 0 \
518 || ((sn)[(snl) - 2] == '.' \
519 && ((sn)[(snl) - 1] == 'o' \
520 || (sn)[(snl) - 1] == 'a')))
522 af
= file_symbol (a
, an
, anl
);
523 bf
= file_symbol (b
, bn
, bnl
);
530 /* Try to sort global symbols before local symbols before function
531 symbols before debugging symbols. */
536 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
538 if ((aflags
& BSF_DEBUGGING
) != 0)
543 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
545 if ((aflags
& BSF_FUNCTION
) != 0)
550 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
552 if ((aflags
& BSF_LOCAL
) != 0)
557 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
559 if ((aflags
& BSF_GLOBAL
) != 0)
565 /* Symbols that start with '.' might be section names, so sort them
566 after symbols that don't start with '.'. */
567 if (an
[0] == '.' && bn
[0] != '.')
569 if (an
[0] != '.' && bn
[0] == '.')
572 /* Finally, if we can't distinguish them in any other way, try to
573 get consistent results by sorting the symbols by name. */
574 return strcmp (an
, bn
);
577 /* Sort relocs into address order. */
580 compare_relocs (ap
, bp
)
584 const arelent
*a
= *(const arelent
**)ap
;
585 const arelent
*b
= *(const arelent
**)bp
;
587 if (a
->address
> b
->address
)
589 else if (a
->address
< b
->address
)
592 /* So that associated relocations tied to the same address show up
593 in the correct order, we don't do any further sorting. */
602 /* Print VMA to STREAM. If SKIP_ZEROES is true, omit leading zeroes. */
605 objdump_print_value (vma
, info
, skip_zeroes
)
607 struct disassemble_info
*info
;
613 sprintf_vma (buf
, vma
);
618 for (p
= buf
; *p
== '0'; ++p
)
623 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
626 /* Print the name of a symbol. */
629 objdump_print_symname (abfd
, info
, sym
)
631 struct disassemble_info
*info
;
639 name
= bfd_asymbol_name (sym
);
640 if (! do_demangle
|| name
[0] == '\0')
644 /* Demangle the name. */
645 if (bfd_get_symbol_leading_char (abfd
) == name
[0])
648 alloc
= cplus_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
656 (*info
->fprintf_func
) (info
->stream
, "%s", print
);
658 printf ("%s", print
);
664 /* Locate a symbol given a bfd, a section, and a VMA. If REQUIRE_SEC
665 is true, then always require the symbol to be in the section. This
666 returns NULL if there is no suitable symbol. If PLACE is not NULL,
667 then *PLACE is set to the index of the symbol in sorted_syms. */
670 find_symbol_for_address (abfd
, sec
, vma
, require_sec
, place
)
677 /* @@ Would it speed things up to cache the last two symbols returned,
678 and maybe their address ranges? For many processors, only one memory
679 operand can be present at a time, so the 2-entry cache wouldn't be
680 constantly churned by code doing heavy memory accesses. */
682 /* Indices in `sorted_syms'. */
684 long max
= sorted_symcount
;
687 if (sorted_symcount
< 1)
690 /* Perform a binary search looking for the closest symbol to the
691 required value. We are searching the range (min, max]. */
692 while (min
+ 1 < max
)
696 thisplace
= (max
+ min
) / 2;
697 sym
= sorted_syms
[thisplace
];
699 if (bfd_asymbol_value (sym
) > vma
)
701 else if (bfd_asymbol_value (sym
) < vma
)
710 /* The symbol we want is now in min, the low end of the range we
711 were searching. If there are several symbols with the same
712 value, we want the first one. */
715 && (bfd_asymbol_value (sorted_syms
[thisplace
])
716 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
719 /* If the file is relocateable, and the symbol could be from this
720 section, prefer a symbol from this section over symbols from
721 others, even if the other symbol's value might be closer.
723 Note that this may be wrong for some symbol references if the
724 sections have overlapping memory ranges, but in that case there's
725 no way to tell what's desired without looking at the relocation
728 if (sorted_syms
[thisplace
]->section
!= sec
730 || ((abfd
->flags
& HAS_RELOC
) != 0
731 && vma
>= bfd_get_section_vma (abfd
, sec
)
732 && vma
< (bfd_get_section_vma (abfd
, sec
)
733 + bfd_section_size (abfd
, sec
)))))
737 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
739 if (bfd_asymbol_value (sorted_syms
[i
])
740 != bfd_asymbol_value (sorted_syms
[thisplace
]))
746 if (sorted_syms
[i
]->section
== sec
748 || sorted_syms
[i
- 1]->section
!= sec
749 || (bfd_asymbol_value (sorted_syms
[i
])
750 != bfd_asymbol_value (sorted_syms
[i
- 1]))))
757 if (sorted_syms
[thisplace
]->section
!= sec
)
759 /* We didn't find a good symbol with a smaller value.
760 Look for one with a larger value. */
761 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
763 if (sorted_syms
[i
]->section
== sec
)
771 if (sorted_syms
[thisplace
]->section
!= sec
773 || ((abfd
->flags
& HAS_RELOC
) != 0
774 && vma
>= bfd_get_section_vma (abfd
, sec
)
775 && vma
< (bfd_get_section_vma (abfd
, sec
)
776 + bfd_section_size (abfd
, sec
)))))
778 /* There is no suitable symbol. */
786 return sorted_syms
[thisplace
];
789 /* Print an address to INFO symbolically. */
792 objdump_print_addr_with_sym (abfd
, sec
, sym
, vma
, info
, skip_zeroes
)
797 struct disassemble_info
*info
;
800 objdump_print_value (vma
, info
, skip_zeroes
);
806 (*info
->fprintf_func
) (info
->stream
, " <%s",
807 bfd_get_section_name (abfd
, sec
));
808 secaddr
= bfd_get_section_vma (abfd
, sec
);
811 (*info
->fprintf_func
) (info
->stream
, "-0x");
812 objdump_print_value (secaddr
- vma
, info
, true);
814 else if (vma
> secaddr
)
816 (*info
->fprintf_func
) (info
->stream
, "+0x");
817 objdump_print_value (vma
- secaddr
, info
, true);
819 (*info
->fprintf_func
) (info
->stream
, ">");
823 (*info
->fprintf_func
) (info
->stream
, " <");
824 objdump_print_symname (abfd
, info
, sym
);
825 if (bfd_asymbol_value (sym
) > vma
)
827 (*info
->fprintf_func
) (info
->stream
, "-0x");
828 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, true);
830 else if (vma
> bfd_asymbol_value (sym
))
832 (*info
->fprintf_func
) (info
->stream
, "+0x");
833 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, true);
835 (*info
->fprintf_func
) (info
->stream
, ">");
839 /* Print VMA to INFO, symbolically if possible. If SKIP_ZEROES is
840 true, don't output leading zeroes. */
843 objdump_print_addr (vma
, info
, skip_zeroes
)
845 struct disassemble_info
*info
;
848 struct objdump_disasm_info
*aux
;
851 if (sorted_symcount
< 1)
853 (*info
->fprintf_func
) (info
->stream
, "0x");
854 objdump_print_value (vma
, info
, skip_zeroes
);
858 aux
= (struct objdump_disasm_info
*) info
->application_data
;
859 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
861 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
865 /* Print VMA to INFO. This function is passed to the disassembler
869 objdump_print_address (vma
, info
)
871 struct disassemble_info
*info
;
873 objdump_print_addr (vma
, info
, ! prefix_addresses
);
876 /* Determine of the given address has a symbol associated with it. */
879 objdump_symbol_at_address (vma
, info
)
881 struct disassemble_info
* info
;
883 struct objdump_disasm_info
* aux
;
886 /* No symbols - do not bother checking. */
887 if (sorted_symcount
< 1)
890 aux
= (struct objdump_disasm_info
*) info
->application_data
;
891 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
894 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
897 /* Hold the last function name and the last line number we displayed
900 static char *prev_functionname
;
901 static unsigned int prev_line
;
903 /* We keep a list of all files that we have seen when doing a
904 dissassembly with source, so that we know how much of the file to
905 display. This can be important for inlined functions. */
907 struct print_file_list
909 struct print_file_list
*next
;
915 static struct print_file_list
*print_files
;
917 /* The number of preceding context lines to show when we start
918 displaying a file for the first time. */
920 #define SHOW_PRECEDING_CONTEXT_LINES (5)
922 /* Skip ahead to a given line in a file, optionally printing each
926 skip_to_line
PARAMS ((struct print_file_list
*, unsigned int, boolean
));
929 skip_to_line (p
, line
, show
)
930 struct print_file_list
*p
;
934 while (p
->line
< line
)
938 if (fgets (buf
, sizeof buf
, p
->f
) == NULL
)
948 if (strchr (buf
, '\n') != NULL
)
953 /* Show the line number, or the source line, in a dissassembly
957 show_line (abfd
, section
, off
)
962 CONST
char *filename
;
963 CONST
char *functionname
;
966 if (! with_line_numbers
&& ! with_source_code
)
969 if (! bfd_find_nearest_line (abfd
, section
, syms
, off
, &filename
,
970 &functionname
, &line
))
973 if (filename
!= NULL
&& *filename
== '\0')
975 if (functionname
!= NULL
&& *functionname
== '\0')
978 if (with_line_numbers
)
980 if (functionname
!= NULL
981 && (prev_functionname
== NULL
982 || strcmp (functionname
, prev_functionname
) != 0))
983 printf ("%s():\n", functionname
);
984 if (line
> 0 && line
!= prev_line
)
985 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
992 struct print_file_list
**pp
, *p
;
994 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
995 if (strcmp ((*pp
)->filename
, filename
) == 0)
1001 if (p
!= print_files
)
1005 /* We have reencountered a file name which we saw
1006 earlier. This implies that either we are dumping out
1007 code from an included file, or the same file was
1008 linked in more than once. There are two common cases
1009 of an included file: inline functions in a header
1010 file, and a bison or flex skeleton file. In the
1011 former case we want to just start printing (but we
1012 back up a few lines to give context); in the latter
1013 case we want to continue from where we left off. I
1014 can't think of a good way to distinguish the cases,
1015 so I used a heuristic based on the file name. */
1016 if (strcmp (p
->filename
+ strlen (p
->filename
) - 2, ".h") != 0)
1020 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1027 p
->f
= fopen (p
->filename
, "r");
1031 skip_to_line (p
, l
, false);
1033 if (print_files
->f
!= NULL
)
1035 fclose (print_files
->f
);
1036 print_files
->f
= NULL
;
1042 skip_to_line (p
, line
, true);
1044 p
->next
= print_files
;
1052 f
= fopen (filename
, "r");
1057 p
= ((struct print_file_list
*)
1058 xmalloc (sizeof (struct print_file_list
)));
1059 p
->filename
= xmalloc (strlen (filename
) + 1);
1060 strcpy (p
->filename
, filename
);
1064 if (print_files
!= NULL
&& print_files
->f
!= NULL
)
1066 fclose (print_files
->f
);
1067 print_files
->f
= NULL
;
1069 p
->next
= print_files
;
1072 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1075 skip_to_line (p
, l
, false);
1077 skip_to_line (p
, line
, true);
1082 if (functionname
!= NULL
1083 && (prev_functionname
== NULL
1084 || strcmp (functionname
, prev_functionname
) != 0))
1086 if (prev_functionname
!= NULL
)
1087 free (prev_functionname
);
1088 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1089 strcpy (prev_functionname
, functionname
);
1092 if (line
> 0 && line
!= prev_line
)
1096 /* Pseudo FILE object for strings. */
1104 /* sprintf to a "stream" */
1107 #ifdef ANSI_PROTOTYPES
1108 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1110 objdump_sprintf (va_alist
)
1114 #ifndef ANSI_PROTOTYPES
1122 #ifdef ANSI_PROTOTYPES
1123 va_start (args
, format
);
1126 f
= va_arg (args
, SFILE
*);
1127 format
= va_arg (args
, const char *);
1130 vasprintf (&buf
, format
, args
);
1136 fprintf (stderr
, _("Out of virtual memory\n"));
1142 while ((size_t) ((f
->buffer
+ f
->size
) - f
->current
) < n
+ 1)
1146 curroff
= f
->current
- f
->buffer
;
1148 f
->buffer
= xrealloc (f
->buffer
, f
->size
);
1149 f
->current
= f
->buffer
+ curroff
;
1152 memcpy (f
->current
, buf
, n
);
1154 f
->current
[0] = '\0';
1161 /* The number of zeroes we want to see before we start skipping them.
1162 The number is arbitrarily chosen. */
1164 #define SKIP_ZEROES (8)
1166 /* The number of zeroes to skip at the end of a section. If the
1167 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1168 SKIP_ZEROES, they will be disassembled. If there are fewer than
1169 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1170 attempt to avoid disassembling zeroes inserted by section
1173 #define SKIP_ZEROES_AT_END (3)
1175 /* Disassemble some data in memory between given values. */
1178 disassemble_bytes (info
, disassemble_fn
, insns
, data
, start
, stop
, relppp
,
1180 struct disassemble_info
*info
;
1181 disassembler_ftype disassemble_fn
;
1189 struct objdump_disasm_info
*aux
;
1193 int skip_addr_chars
;
1196 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1202 bytes_per_line
= 16;
1204 /* Figure out how many characters to skip at the start of an
1205 address, to make the disassembly look nicer. We discard leading
1206 zeroes in chunks of 4, ensuring that there is always a leading
1208 skip_addr_chars
= 0;
1209 if (! prefix_addresses
)
1215 section
->vma
+ bfd_section_size (section
->owner
, section
));
1217 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1220 skip_addr_chars
+= 4;
1225 info
->insn_info_valid
= 0;
1233 boolean need_nl
= false;
1235 /* If we see more than SKIP_ZEROES bytes of zeroes, we just
1237 for (z
= i
; z
< stop
; z
++)
1240 if (! disassemble_zeroes
1241 && (info
->insn_info_valid
== 0
1242 || info
->branch_delay_insns
== 0)
1243 && (z
- i
>= SKIP_ZEROES
1244 || (z
== stop
&& z
- i
< SKIP_ZEROES_AT_END
)))
1248 /* If there are more nonzero bytes to follow, we only skip
1249 zeroes in multiples of 4, to try to avoid running over
1250 the start of an instruction which happens to start with
1253 z
= i
+ ((z
- i
) &~ 3);
1266 if (with_line_numbers
|| with_source_code
)
1267 show_line (aux
->abfd
, section
, i
);
1269 if (! prefix_addresses
)
1273 sprintf_vma (buf
, section
->vma
+ i
);
1274 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1278 printf ("%s:\t", buf
+ skip_addr_chars
);
1282 aux
->require_sec
= true;
1283 objdump_print_address (section
->vma
+ i
, info
);
1284 aux
->require_sec
= false;
1291 sfile
.buffer
= xmalloc (sfile
.size
);
1292 sfile
.current
= sfile
.buffer
;
1293 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1294 info
->stream
= (FILE *) &sfile
;
1295 info
->bytes_per_line
= 0;
1296 info
->bytes_per_chunk
= 0;
1298 /* FIXME: This is wrong. It tests the number of bytes
1299 in the last instruction, not the current one. */
1300 if (*relppp
< relppend
1301 && (**relppp
)->address
>= i
1302 && (**relppp
)->address
< i
+ bytes
)
1303 info
->flags
= INSN_HAS_RELOC
;
1307 bytes
= (*disassemble_fn
) (section
->vma
+ i
, info
);
1308 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1309 info
->stream
= stdout
;
1310 if (info
->bytes_per_line
!= 0)
1311 bytes_per_line
= info
->bytes_per_line
;
1314 if (sfile
.current
!= sfile
.buffer
)
1315 printf ("%s\n", sfile
.buffer
);
1316 free (sfile
.buffer
);
1324 bytes
= bytes_per_line
;
1325 if (i
+ bytes
> stop
)
1328 for (j
= i
; j
< i
+ bytes
; ++j
)
1330 if (isprint (data
[j
]))
1331 buf
[j
- i
] = data
[j
];
1338 if (prefix_addresses
1340 : show_raw_insn
>= 0)
1344 /* If ! prefix_addresses and ! wide_output, we print
1345 bytes_per_line bytes per line. */
1347 if (pb
> bytes_per_line
&& ! prefix_addresses
&& ! wide_output
)
1348 pb
= bytes_per_line
;
1350 if (info
->bytes_per_chunk
)
1351 bpc
= info
->bytes_per_chunk
;
1355 for (j
= i
; j
< i
+ pb
; j
+= bpc
)
1358 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1360 for (k
= bpc
- 1; k
>= 0; k
--)
1361 printf ("%02x", (unsigned) data
[j
+ k
]);
1366 for (k
= 0; k
< bpc
; k
++)
1367 printf ("%02x", (unsigned) data
[j
+ k
]);
1372 for (; pb
< bytes_per_line
; pb
+= bpc
)
1376 for (k
= 0; k
< bpc
; k
++)
1381 /* Separate raw data from instruction by extra space. */
1392 printf ("%s", sfile
.buffer
);
1393 free (sfile
.buffer
);
1396 if (prefix_addresses
1398 : show_raw_insn
>= 0)
1408 sprintf_vma (buf
, section
->vma
+ j
);
1409 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1413 printf ("%s:\t", buf
+ skip_addr_chars
);
1415 pb
+= bytes_per_line
;
1418 for (; j
< i
+ pb
; j
+= bpc
)
1422 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1424 for (k
= bpc
- 1; k
>= 0; k
--)
1425 printf ("%02x", (unsigned) data
[j
+ k
]);
1430 for (k
= 0; k
< bpc
; k
++)
1431 printf ("%02x", (unsigned) data
[j
+ k
]);
1445 && (section
->flags
& SEC_RELOC
) != 0)
1447 while ((*relppp
) < relppend
1448 && ((**relppp
)->address
>= (bfd_vma
) i
1449 && (**relppp
)->address
< (bfd_vma
) i
+ bytes
))
1460 objdump_print_value (section
->vma
+ q
->address
, info
, true);
1462 printf (": %s\t", q
->howto
->name
);
1464 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1465 printf ("*unknown*");
1468 const char *sym_name
;
1470 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1471 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1472 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1477 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1478 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1479 if (sym_name
== NULL
|| *sym_name
== '\0')
1480 sym_name
= "*unknown*";
1481 printf ("%s", sym_name
);
1488 objdump_print_value (q
->addend
, info
, true);
1504 /* Disassemble the contents of an object file. */
1507 disassemble_data (abfd
)
1511 disassembler_ftype disassemble_fn
;
1512 struct disassemble_info disasm_info
;
1513 struct objdump_disasm_info aux
;
1517 prev_functionname
= NULL
;
1520 /* We make a copy of syms to sort. We don't want to sort syms
1521 because that will screw up the relocs. */
1522 sorted_syms
= (asymbol
**) xmalloc (symcount
* sizeof (asymbol
*));
1523 memcpy (sorted_syms
, syms
, symcount
* sizeof (asymbol
*));
1525 sorted_symcount
= remove_useless_symbols (sorted_syms
, symcount
);
1527 /* Sort the symbols into section and symbol order */
1528 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1530 INIT_DISASSEMBLE_INFO(disasm_info
, stdout
, fprintf
);
1531 disasm_info
.application_data
= (PTR
) &aux
;
1533 aux
.require_sec
= false;
1534 disasm_info
.print_address_func
= objdump_print_address
;
1535 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1537 if (machine
!= (char *) NULL
)
1539 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1542 fprintf (stderr
, _("%s: Can't use supplied machine %s\n"),
1547 abfd
->arch_info
= info
;
1550 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1552 struct bfd_target
*xvec
;
1554 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
1555 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1556 xvec
->byteorder
= endian
;
1560 disassemble_fn
= disassembler (abfd
);
1561 if (!disassemble_fn
)
1563 fprintf (stderr
, _("%s: Can't disassemble for architecture %s\n"),
1565 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1569 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1570 disasm_info
.arch
= bfd_get_arch (abfd
);
1571 disasm_info
.mach
= bfd_get_mach (abfd
);
1572 disasm_info
.disassembler_options
= disassembler_options
;
1574 if (bfd_big_endian (abfd
))
1575 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1576 else if (bfd_little_endian (abfd
))
1577 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1579 /* ??? Aborting here seems too drastic. We could default to big or little
1581 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1583 for (section
= abfd
->sections
;
1584 section
!= (asection
*) NULL
;
1585 section
= section
->next
)
1587 bfd_byte
*data
= NULL
;
1588 bfd_size_type datasize
= 0;
1589 arelent
**relbuf
= NULL
;
1590 arelent
**relpp
= NULL
;
1591 arelent
**relppend
= NULL
;
1593 asymbol
*sym
= NULL
;
1596 if ((section
->flags
& SEC_LOAD
) == 0
1597 || (! disassemble_all
1599 && (section
->flags
& SEC_CODE
) == 0))
1601 if (only
!= (char *) NULL
&& strcmp (only
, section
->name
) != 0)
1605 && (section
->flags
& SEC_RELOC
) != 0)
1609 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1611 bfd_fatal (bfd_get_filename (abfd
));
1617 relbuf
= (arelent
**) xmalloc (relsize
);
1618 relcount
= bfd_canonicalize_reloc (abfd
, section
, relbuf
, syms
);
1620 bfd_fatal (bfd_get_filename (abfd
));
1622 /* Sort the relocs by address. */
1623 qsort (relbuf
, relcount
, sizeof (arelent
*), compare_relocs
);
1626 relppend
= relpp
+ relcount
;
1628 /* Skip over the relocs belonging to addresses below the
1630 if (start_address
!= (bfd_vma
) -1)
1632 while (relpp
< relppend
1633 && (*relpp
)->address
< start_address
)
1639 printf (_("Disassembly of section %s:\n"), section
->name
);
1641 datasize
= bfd_get_section_size_before_reloc (section
);
1645 data
= (bfd_byte
*) xmalloc ((size_t) datasize
);
1647 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1650 disasm_info
.buffer
= data
;
1651 disasm_info
.buffer_vma
= section
->vma
;
1652 disasm_info
.buffer_length
= datasize
;
1653 if (start_address
== (bfd_vma
) -1
1654 || start_address
< disasm_info
.buffer_vma
)
1657 i
= start_address
- disasm_info
.buffer_vma
;
1658 if (stop_address
== (bfd_vma
) -1)
1662 if (stop_address
< disasm_info
.buffer_vma
)
1665 stop
= stop_address
- disasm_info
.buffer_vma
;
1666 if (stop
> disasm_info
.buffer_length
)
1667 stop
= disasm_info
.buffer_length
;
1670 sym
= find_symbol_for_address (abfd
, section
, section
->vma
+ i
,
1679 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= section
->vma
+ i
)
1684 (x
< sorted_symcount
1685 && bfd_asymbol_value (sorted_syms
[x
]) <= section
->vma
+ i
);
1688 disasm_info
.symbols
= & sorted_syms
[place
];
1689 disasm_info
.num_symbols
= x
- place
;
1692 disasm_info
.symbols
= NULL
;
1694 if (! prefix_addresses
)
1697 objdump_print_addr_with_sym (abfd
, section
, sym
,
1704 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ i
)
1706 else if (sym
== NULL
)
1710 while (place
< sorted_symcount
1711 /* ??? Why the test for != section? */
1712 && (sorted_syms
[place
]->section
!= section
1713 || (bfd_asymbol_value (sorted_syms
[place
])
1714 <= bfd_asymbol_value (sym
))))
1716 if (place
>= sorted_symcount
)
1719 nextsym
= sorted_syms
[place
];
1722 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ i
)
1724 nextstop
= bfd_asymbol_value (sym
) - section
->vma
;
1725 if (nextstop
> stop
)
1728 else if (nextsym
== NULL
)
1732 nextstop
= bfd_asymbol_value (nextsym
) - section
->vma
;
1733 if (nextstop
> stop
)
1737 /* If a symbol is explicitly marked as being an object
1738 rather than a function, just dump the bytes without
1739 disassembling them. */
1742 || bfd_asymbol_value (sym
) > section
->vma
+ i
1743 || ((sym
->flags
& BSF_OBJECT
) == 0
1744 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1746 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1748 || (sym
->flags
& BSF_FUNCTION
) != 0)
1753 disassemble_bytes (&disasm_info
, disassemble_fn
, insns
, data
, i
,
1754 nextstop
, &relpp
, relppend
);
1768 /* Define a table of stab values and print-strings. We wish the initializer
1769 could be a direct-mapped table, but instead we build one the first
1772 static void dump_section_stabs
PARAMS ((bfd
*abfd
, char *stabsect_name
,
1773 char *strsect_name
));
1775 /* Dump the stabs sections from an object file that has a section that
1776 uses Sun stabs encoding. */
1782 dump_section_stabs (abfd
, ".stab", ".stabstr");
1783 dump_section_stabs (abfd
, ".stab.excl", ".stab.exclstr");
1784 dump_section_stabs (abfd
, ".stab.index", ".stab.indexstr");
1785 dump_section_stabs (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1788 static bfd_byte
*stabs
;
1789 static bfd_size_type stab_size
;
1791 static char *strtab
;
1792 static bfd_size_type stabstr_size
;
1794 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1795 and string table section STRSECT_NAME into `strtab'.
1796 If the section exists and was read, allocate the space and return true.
1797 Otherwise return false. */
1800 read_section_stabs (abfd
, stabsect_name
, strsect_name
)
1802 const char *stabsect_name
;
1803 const char *strsect_name
;
1805 asection
*stabsect
, *stabstrsect
;
1807 stabsect
= bfd_get_section_by_name (abfd
, stabsect_name
);
1810 printf (_("No %s section present\n\n"), stabsect_name
);
1814 stabstrsect
= bfd_get_section_by_name (abfd
, strsect_name
);
1815 if (0 == stabstrsect
)
1817 fprintf (stderr
, _("%s: %s has no %s section\n"), program_name
,
1818 bfd_get_filename (abfd
), strsect_name
);
1822 stab_size
= bfd_section_size (abfd
, stabsect
);
1823 stabstr_size
= bfd_section_size (abfd
, stabstrsect
);
1825 stabs
= (bfd_byte
*) xmalloc (stab_size
);
1826 strtab
= (char *) xmalloc (stabstr_size
);
1828 if (! bfd_get_section_contents (abfd
, stabsect
, (PTR
) stabs
, 0, stab_size
))
1830 fprintf (stderr
, _("%s: Reading %s section of %s failed: %s\n"),
1831 program_name
, stabsect_name
, bfd_get_filename (abfd
),
1832 bfd_errmsg (bfd_get_error ()));
1838 if (! bfd_get_section_contents (abfd
, stabstrsect
, (PTR
) strtab
, 0,
1841 fprintf (stderr
, _("%s: Reading %s section of %s failed: %s\n"),
1842 program_name
, strsect_name
, bfd_get_filename (abfd
),
1843 bfd_errmsg (bfd_get_error ()));
1852 /* Stabs entries use a 12 byte format:
1853 4 byte string table index
1855 1 byte stab other field
1856 2 byte stab desc field
1858 FIXME: This will have to change for a 64 bit object format. */
1860 #define STRDXOFF (0)
1862 #define OTHEROFF (5)
1865 #define STABSIZE (12)
1867 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1868 using string table section STRSECT_NAME (in `strtab'). */
1871 print_section_stabs (abfd
, stabsect_name
, strsect_name
)
1873 const char *stabsect_name
;
1874 const char *strsect_name ATTRIBUTE_UNUSED
;
1877 unsigned file_string_table_offset
= 0, next_file_string_table_offset
= 0;
1878 bfd_byte
*stabp
, *stabs_end
;
1881 stabs_end
= stabp
+ stab_size
;
1883 printf (_("Contents of %s section:\n\n"), stabsect_name
);
1884 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1886 /* Loop through all symbols and print them.
1888 We start the index at -1 because there is a dummy symbol on
1889 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1891 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
1895 unsigned char type
, other
;
1896 unsigned short desc
;
1899 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
1900 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
1901 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
1902 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
1903 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
1905 printf ("\n%-6d ", i
);
1906 /* Either print the stab name, or, if unnamed, print its number
1907 again (makes consistent formatting for tools like awk). */
1908 name
= bfd_get_stab_name (type
);
1910 printf ("%-6s", name
);
1911 else if (type
== N_UNDF
)
1914 printf ("%-6d", type
);
1915 printf (" %-6d %-6d ", other
, desc
);
1917 printf (" %-6lu", strx
);
1919 /* Symbols with type == 0 (N_UNDF) specify the length of the
1920 string table associated with this file. We use that info
1921 to know how to relocate the *next* file's string table indices. */
1925 file_string_table_offset
= next_file_string_table_offset
;
1926 next_file_string_table_offset
+= value
;
1930 /* Using the (possibly updated) string table offset, print the
1931 string (if any) associated with this symbol. */
1933 if ((strx
+ file_string_table_offset
) < stabstr_size
)
1934 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
1943 dump_section_stabs (abfd
, stabsect_name
, strsect_name
)
1945 char *stabsect_name
;
1950 /* Check for section names for which stabsect_name is a prefix, to
1951 handle .stab0, etc. */
1952 for (s
= abfd
->sections
;
1958 len
= strlen (stabsect_name
);
1960 /* If the prefix matches, and the files section name ends with a
1961 nul or a digit, then we match. I.e., we want either an exact
1962 match or a section followed by a number. */
1963 if (strncmp (stabsect_name
, s
->name
, len
) == 0
1964 && (s
->name
[len
] == '\000'
1965 || isdigit ((unsigned char) s
->name
[len
])))
1967 if (read_section_stabs (abfd
, s
->name
, strsect_name
))
1969 print_section_stabs (abfd
, s
->name
, strsect_name
);
1978 dump_bfd_header (abfd
)
1983 printf (_("architecture: %s, "),
1984 bfd_printable_arch_mach (bfd_get_arch (abfd
),
1985 bfd_get_mach (abfd
)));
1986 printf (_("flags 0x%08x:\n"), abfd
->flags
);
1988 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
1989 PF (HAS_RELOC
, "HAS_RELOC");
1990 PF (EXEC_P
, "EXEC_P");
1991 PF (HAS_LINENO
, "HAS_LINENO");
1992 PF (HAS_DEBUG
, "HAS_DEBUG");
1993 PF (HAS_SYMS
, "HAS_SYMS");
1994 PF (HAS_LOCALS
, "HAS_LOCALS");
1995 PF (DYNAMIC
, "DYNAMIC");
1996 PF (WP_TEXT
, "WP_TEXT");
1997 PF (D_PAGED
, "D_PAGED");
1998 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
1999 printf (_("\nstart address 0x"));
2000 printf_vma (abfd
->start_address
);
2005 dump_bfd_private_header (abfd
)
2008 bfd_print_private_bfd_data (abfd
, stdout
);
2017 if (!bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2019 bfd_nonfatal (bfd_get_filename (abfd
));
2020 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2022 list_matching_formats (matching
);
2028 /* If we are adjusting section VMA's, change them all now. Changing
2029 the BFD information is a hack. However, we must do it, or
2030 bfd_find_nearest_line will not do the right thing. */
2031 if (adjust_section_vma
!= 0)
2035 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2037 s
->vma
+= adjust_section_vma
;
2038 s
->lma
+= adjust_section_vma
;
2042 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2045 print_arelt_descr (stdout
, abfd
, true);
2046 if (dump_file_header
)
2047 dump_bfd_header (abfd
);
2048 if (dump_private_headers
)
2049 dump_bfd_private_header (abfd
);
2051 if (dump_section_headers
)
2052 dump_headers (abfd
);
2053 if (dump_symtab
|| dump_reloc_info
|| disassemble
|| dump_debugging
)
2055 syms
= slurp_symtab (abfd
);
2057 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
)
2059 dynsyms
= slurp_dynamic_symtab (abfd
);
2062 dump_symbols (abfd
, false);
2063 if (dump_dynamic_symtab
)
2064 dump_symbols (abfd
, true);
2065 if (dump_stab_section_info
)
2067 if (dump_reloc_info
&& ! disassemble
)
2069 if (dump_dynamic_reloc_info
)
2070 dump_dynamic_relocs (abfd
);
2071 if (dump_section_contents
)
2074 disassemble_data (abfd
);
2079 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2080 if (dhandle
!= NULL
)
2082 if (! print_debugging_info (stdout
, dhandle
))
2083 fprintf (stderr
, _("%s: printing debugging information failed\n"),
2084 bfd_get_filename (abfd
));
2100 display_file (filename
, target
)
2104 bfd
*file
, *arfile
= (bfd
*) NULL
;
2106 file
= bfd_openr (filename
, target
);
2109 bfd_nonfatal (filename
);
2113 if (bfd_check_format (file
, bfd_archive
) == true)
2115 bfd
*last_arfile
= NULL
;
2117 printf (_("In archive %s:\n"), bfd_get_filename (file
));
2120 bfd_set_error (bfd_error_no_error
);
2122 arfile
= bfd_openr_next_archived_file (file
, arfile
);
2125 if (bfd_get_error () != bfd_error_no_more_archived_files
)
2127 bfd_nonfatal (bfd_get_filename (file
));
2132 display_bfd (arfile
);
2134 if (last_arfile
!= NULL
)
2135 bfd_close (last_arfile
);
2136 last_arfile
= arfile
;
2139 if (last_arfile
!= NULL
)
2140 bfd_close (last_arfile
);
2148 /* Actually display the various requested regions */
2156 bfd_size_type datasize
= 0;
2158 bfd_size_type start
, stop
;
2160 for (section
= abfd
->sections
; section
!= NULL
; section
=
2165 if (only
== (char *) NULL
||
2166 strcmp (only
, section
->name
) == 0)
2168 if (section
->flags
& SEC_HAS_CONTENTS
)
2170 printf (_("Contents of section %s:\n"), section
->name
);
2172 if (bfd_section_size (abfd
, section
) == 0)
2174 data
= (bfd_byte
*) xmalloc ((size_t) bfd_section_size (abfd
, section
));
2175 datasize
= bfd_section_size (abfd
, section
);
2178 bfd_get_section_contents (abfd
, section
, (PTR
) data
, 0, bfd_section_size (abfd
, section
));
2180 if (start_address
== (bfd_vma
) -1
2181 || start_address
< section
->vma
)
2184 start
= start_address
- section
->vma
;
2185 if (stop_address
== (bfd_vma
) -1)
2186 stop
= bfd_section_size (abfd
, section
);
2189 if (stop_address
< section
->vma
)
2192 stop
= stop_address
- section
->vma
;
2193 if (stop
> bfd_section_size (abfd
, section
))
2194 stop
= bfd_section_size (abfd
, section
);
2196 for (i
= start
; i
< stop
; i
+= onaline
)
2200 printf (" %04lx ", (unsigned long int) (i
+ section
->vma
));
2201 for (j
= i
; j
< i
+ onaline
; j
++)
2204 printf ("%02x", (unsigned) (data
[j
]));
2212 for (j
= i
; j
< i
+ onaline
; j
++)
2217 printf ("%c", isprint (data
[j
]) ? data
[j
] : '.');
2227 /* Should perhaps share code and display with nm? */
2229 dump_symbols (abfd
, dynamic
)
2230 bfd
*abfd ATTRIBUTE_UNUSED
;
2243 printf ("DYNAMIC SYMBOL TABLE:\n");
2251 printf ("SYMBOL TABLE:\n");
2254 for (count
= 0; count
< max
; count
++)
2258 bfd
*cur_bfd
= bfd_asymbol_bfd (*current
);
2260 if (cur_bfd
!= NULL
)
2265 name
= bfd_asymbol_name (*current
);
2267 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2271 /* If we want to demangle the name, we demangle it
2272 here, and temporarily clobber it while calling
2273 bfd_print_symbol. FIXME: This is a gross hack. */
2276 if (bfd_get_symbol_leading_char (cur_bfd
) == *n
)
2278 alloc
= cplus_demangle (n
, DMGL_ANSI
| DMGL_PARAMS
);
2280 (*current
)->name
= alloc
;
2282 (*current
)->name
= n
;
2285 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2286 bfd_print_symbol_all
);
2288 (*current
)->name
= name
;
2309 for (a
= abfd
->sections
; a
!= (asection
*) NULL
; a
= a
->next
)
2313 if (bfd_is_abs_section (a
))
2315 if (bfd_is_und_section (a
))
2317 if (bfd_is_com_section (a
))
2322 if (strcmp (only
, a
->name
))
2325 else if ((a
->flags
& SEC_RELOC
) == 0)
2328 relsize
= bfd_get_reloc_upper_bound (abfd
, a
);
2330 bfd_fatal (bfd_get_filename (abfd
));
2332 printf ("RELOCATION RECORDS FOR [%s]:", a
->name
);
2336 printf (" (none)\n\n");
2340 relpp
= (arelent
**) xmalloc (relsize
);
2341 relcount
= bfd_canonicalize_reloc (abfd
, a
, relpp
, syms
);
2343 bfd_fatal (bfd_get_filename (abfd
));
2344 else if (relcount
== 0)
2346 printf (" (none)\n\n");
2351 dump_reloc_set (abfd
, a
, relpp
, relcount
);
2360 dump_dynamic_relocs (abfd
)
2367 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2369 bfd_fatal (bfd_get_filename (abfd
));
2371 printf ("DYNAMIC RELOCATION RECORDS");
2375 printf (" (none)\n\n");
2379 relpp
= (arelent
**) xmalloc (relsize
);
2380 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2382 bfd_fatal (bfd_get_filename (abfd
));
2383 else if (relcount
== 0)
2385 printf (" (none)\n\n");
2390 dump_reloc_set (abfd
, (asection
*) NULL
, relpp
, relcount
);
2398 dump_reloc_set (abfd
, sec
, relpp
, relcount
)
2405 char *last_filename
, *last_functionname
;
2406 unsigned int last_line
;
2408 /* Get column headers lined up reasonably. */
2414 sprintf_vma (buf
, (bfd_vma
) -1);
2415 width
= strlen (buf
) - 7;
2417 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2420 last_filename
= NULL
;
2421 last_functionname
= NULL
;
2424 for (p
= relpp
; relcount
&& *p
!= (arelent
*) NULL
; p
++, relcount
--)
2427 const char *filename
, *functionname
;
2429 const char *sym_name
;
2430 const char *section_name
;
2432 if (start_address
!= (bfd_vma
) -1
2433 && q
->address
< start_address
)
2435 if (stop_address
!= (bfd_vma
) -1
2436 && q
->address
> stop_address
)
2439 if (with_line_numbers
2441 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2442 &filename
, &functionname
, &line
))
2444 if (functionname
!= NULL
2445 && (last_functionname
== NULL
2446 || strcmp (functionname
, last_functionname
) != 0))
2448 printf ("%s():\n", functionname
);
2449 if (last_functionname
!= NULL
)
2450 free (last_functionname
);
2451 last_functionname
= xstrdup (functionname
);
2454 && (line
!= last_line
2455 || (filename
!= NULL
2456 && last_filename
!= NULL
2457 && strcmp (filename
, last_filename
) != 0)))
2459 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2461 if (last_filename
!= NULL
)
2462 free (last_filename
);
2463 if (filename
== NULL
)
2464 last_filename
= NULL
;
2466 last_filename
= xstrdup (filename
);
2470 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2472 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2473 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2478 section_name
= NULL
;
2482 printf_vma (q
->address
);
2484 printf (" %-16s ", q
->howto
->name
);
2486 printf (" %-16d ", q
->howto
->type
);
2487 objdump_print_symname (abfd
, (struct disassemble_info
*) NULL
,
2492 if (section_name
== (CONST
char *) NULL
)
2493 section_name
= "*unknown*";
2494 printf_vma (q
->address
);
2495 printf (" %-16s [%s]",
2502 printf_vma (q
->addend
);
2508 /* The length of the longest architecture name + 1. */
2509 #define LONGEST_ARCH sizeof("rs6000:6000")
2512 endian_string (endian
)
2513 enum bfd_endian endian
;
2515 if (endian
== BFD_ENDIAN_BIG
)
2516 return "big endian";
2517 else if (endian
== BFD_ENDIAN_LITTLE
)
2518 return "little endian";
2520 return "endianness unknown";
2523 /* List the targets that BFD is configured to support, each followed
2524 by its endianness and the architectures it supports. */
2527 display_target_list ()
2529 extern bfd_target
*bfd_target_vector
[];
2533 dummy_name
= choose_temp_base ();
2534 for (t
= 0; bfd_target_vector
[t
]; t
++)
2536 bfd_target
*p
= bfd_target_vector
[t
];
2537 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2540 printf ("%s\n (header %s, data %s)\n", p
->name
,
2541 endian_string (p
->header_byteorder
),
2542 endian_string (p
->byteorder
));
2546 bfd_nonfatal (dummy_name
);
2550 if (! bfd_set_format (abfd
, bfd_object
))
2552 if (bfd_get_error () != bfd_error_invalid_operation
)
2553 bfd_nonfatal (p
->name
);
2557 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2558 if (bfd_set_arch_mach (abfd
, (enum bfd_architecture
) a
, 0))
2560 bfd_printable_arch_mach ((enum bfd_architecture
) a
, 0));
2562 unlink (dummy_name
);
2566 /* Print a table showing which architectures are supported for entries
2567 FIRST through LAST-1 of bfd_target_vector (targets across,
2568 architectures down). */
2571 display_info_table (first
, last
)
2575 extern bfd_target
*bfd_target_vector
[];
2579 /* Print heading of target names. */
2580 printf ("\n%*s", (int) LONGEST_ARCH
, " ");
2581 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2582 printf ("%s ", bfd_target_vector
[t
]->name
);
2585 dummy_name
= choose_temp_base ();
2586 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2587 if (strcmp (bfd_printable_arch_mach (a
, 0), "UNKNOWN!") != 0)
2589 printf ("%*s ", (int) LONGEST_ARCH
- 1,
2590 bfd_printable_arch_mach (a
, 0));
2591 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2593 bfd_target
*p
= bfd_target_vector
[t
];
2595 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2599 bfd_nonfatal (p
->name
);
2605 if (! bfd_set_format (abfd
, bfd_object
))
2607 if (bfd_get_error () != bfd_error_invalid_operation
)
2608 bfd_nonfatal (p
->name
);
2615 if (! bfd_set_arch_mach (abfd
, a
, 0))
2620 printf ("%s ", p
->name
);
2623 int l
= strlen (p
->name
);
2631 unlink (dummy_name
);
2635 /* Print tables of all the target-architecture combinations that
2636 BFD has been configured to support. */
2639 display_target_tables ()
2642 extern bfd_target
*bfd_target_vector
[];
2646 colum
= getenv ("COLUMNS");
2648 columns
= atoi (colum
);
2653 while (bfd_target_vector
[t
] != NULL
)
2657 wid
= LONGEST_ARCH
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2659 while (wid
< columns
&& bfd_target_vector
[t
] != NULL
)
2663 newwid
= wid
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2664 if (newwid
>= columns
)
2669 display_info_table (oldt
, t
);
2676 printf (_("BFD header file version %s\n"), BFD_VERSION
);
2677 display_target_list ();
2678 display_target_tables ();
2687 char *target
= default_target
;
2688 boolean seenflag
= false;
2690 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
2691 setlocale (LC_MESSAGES
, "");
2693 bindtextdomain (PACKAGE
, LOCALEDIR
);
2694 textdomain (PACKAGE
);
2696 program_name
= *argv
;
2697 xmalloc_set_program_name (program_name
);
2699 START_PROGRESS (program_name
, 0);
2702 set_default_bfd_target ();
2704 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VCdDlfahrRtTxsSj:wE:",
2705 long_options
, (int *) 0))
2708 if (c
!= 'l' && c
!= OPTION_START_ADDRESS
&& c
!= OPTION_STOP_ADDRESS
)
2713 break; /* we've been given a long option */
2718 disassembler_options
= optarg
;
2724 with_line_numbers
= 1;
2730 dump_file_header
= true;
2733 formats_info
= true;
2736 dump_private_headers
= 1;
2739 dump_private_headers
= 1;
2741 dump_reloc_info
= 1;
2742 dump_file_header
= true;
2744 dump_section_headers
= 1;
2750 dump_dynamic_symtab
= 1;
2759 disassemble
= disassemble_all
= true;
2763 with_source_code
= true;
2766 dump_section_contents
= 1;
2769 dump_reloc_info
= 1;
2772 dump_dynamic_reloc_info
= 1;
2778 dump_section_headers
= 1;
2788 case OPTION_ADJUST_VMA
:
2789 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
2791 case OPTION_START_ADDRESS
:
2792 start_address
= parse_vma (optarg
, "--start-address");
2794 case OPTION_STOP_ADDRESS
:
2795 stop_address
= parse_vma (optarg
, "--stop-address");
2798 if (strcmp (optarg
, "B") == 0)
2799 endian
= BFD_ENDIAN_BIG
;
2800 else if (strcmp (optarg
, "L") == 0)
2801 endian
= BFD_ENDIAN_LITTLE
;
2804 fprintf (stderr
, _("%s: unrecognized -E option\n"), program_name
);
2809 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
2810 endian
= BFD_ENDIAN_BIG
;
2811 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
2812 endian
= BFD_ENDIAN_LITTLE
;
2815 fprintf (stderr
, _("%s: unrecognized --endian type `%s'\n"),
2816 program_name
, optarg
);
2826 print_version ("objdump");
2828 if (seenflag
== false)
2838 display_file ("a.out", target
);
2840 for (; optind
< argc
;)
2841 display_file (argv
[optind
++], target
);
2844 END_PROGRESS (program_name
);