1 /* objdump.c -- dump information about an object file.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 Free Software Foundation, Inc.
6 This file is part of GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 #include "libiberty.h"
33 /* Internal headers for the ELF .stab-dump code - sorry. */
34 #define BYTES_IN_WORD 32
35 #include "aout/aout64.h"
37 #ifdef NEED_DECLARATION_FPRINTF
38 /* This is needed by INIT_DISASSEMBLE_INFO. */
39 extern int fprintf
PARAMS ((FILE *, const char *, ...));
43 static int exit_status
= 0;
45 static char *default_target
= NULL
; /* default at runtime */
47 static int show_version
= 0; /* show the version number */
48 static int dump_section_contents
; /* -s */
49 static int dump_section_headers
; /* -h */
50 static boolean dump_file_header
; /* -f */
51 static int dump_symtab
; /* -t */
52 static int dump_dynamic_symtab
; /* -T */
53 static int dump_reloc_info
; /* -r */
54 static int dump_dynamic_reloc_info
; /* -R */
55 static int dump_ar_hdrs
; /* -a */
56 static int dump_private_headers
; /* -p */
57 static int prefix_addresses
; /* --prefix-addresses */
58 static int with_line_numbers
; /* -l */
59 static boolean with_source_code
; /* -S */
60 static int show_raw_insn
; /* --show-raw-insn */
61 static int dump_stab_section_info
; /* --stabs */
62 static int do_demangle
; /* -C, --demangle */
63 static boolean disassemble
; /* -d */
64 static boolean disassemble_all
; /* -D */
65 static int disassemble_zeroes
; /* --disassemble-zeroes */
66 static boolean formats_info
; /* -i */
67 static char *only
; /* -j secname */
68 static int wide_output
; /* -w */
69 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
70 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
71 static int dump_debugging
; /* --debugging */
72 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
73 static int file_start_context
= 0; /* --file-start-context */
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 /* Target specific options to the disassembler. */
86 static char *disassembler_options
= (char *) NULL
;
88 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
89 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
91 /* The symbol table. */
92 static asymbol
**syms
;
94 /* Number of symbols in `syms'. */
95 static long symcount
= 0;
97 /* The sorted symbol table. */
98 static asymbol
**sorted_syms
;
100 /* Number of symbols in `sorted_syms'. */
101 static long sorted_symcount
= 0;
103 /* The dynamic symbol table. */
104 static asymbol
**dynsyms
;
106 /* Number of symbols in `dynsyms'. */
107 static long dynsymcount
= 0;
109 /* Static declarations. */
112 usage
PARAMS ((FILE *, int));
115 nonfatal
PARAMS ((const char *));
118 display_file
PARAMS ((char *filename
, char *target
));
121 dump_section_header
PARAMS ((bfd
*, asection
*, PTR
));
124 dump_headers
PARAMS ((bfd
*));
127 dump_data
PARAMS ((bfd
*abfd
));
130 dump_relocs
PARAMS ((bfd
*abfd
));
133 dump_dynamic_relocs
PARAMS ((bfd
* abfd
));
136 dump_reloc_set
PARAMS ((bfd
*, asection
*, arelent
**, long));
139 dump_symbols
PARAMS ((bfd
*abfd
, boolean dynamic
));
142 dump_bfd_header
PARAMS ((bfd
*));
145 dump_bfd_private_header
PARAMS ((bfd
*));
148 display_bfd
PARAMS ((bfd
*abfd
));
151 display_target_list
PARAMS ((void));
154 display_info_table
PARAMS ((int, int));
157 display_target_tables
PARAMS ((void));
160 display_info
PARAMS ((void));
163 objdump_print_value
PARAMS ((bfd_vma
, struct disassemble_info
*, boolean
));
166 objdump_print_symname
PARAMS ((bfd
*, struct disassemble_info
*, asymbol
*));
169 find_symbol_for_address
PARAMS ((bfd
*, asection
*, bfd_vma
, boolean
, long *));
172 objdump_print_addr_with_sym
PARAMS ((bfd
*, asection
*, asymbol
*, bfd_vma
,
173 struct disassemble_info
*, boolean
));
176 objdump_print_addr
PARAMS ((bfd_vma
, struct disassemble_info
*, boolean
));
179 objdump_print_address
PARAMS ((bfd_vma
, struct disassemble_info
*));
182 show_line
PARAMS ((bfd
*, asection
*, bfd_vma
));
185 disassemble_bytes
PARAMS ((struct disassemble_info
*, disassembler_ftype
,
186 boolean
, bfd_byte
*, bfd_vma
, bfd_vma
,
187 arelent
***, arelent
**));
190 disassemble_data
PARAMS ((bfd
*));
193 endian_string
PARAMS ((enum bfd_endian
));
196 slurp_symtab
PARAMS ((bfd
*));
199 slurp_dynamic_symtab
PARAMS ((bfd
*));
202 remove_useless_symbols
PARAMS ((asymbol
**, long));
205 compare_symbols
PARAMS ((const PTR
, const PTR
));
208 compare_relocs
PARAMS ((const PTR
, const PTR
));
211 dump_stabs
PARAMS ((bfd
*));
214 read_section_stabs
PARAMS ((bfd
*, const char *, const char *));
217 print_section_stabs
PARAMS ((bfd
*, const char *, const char *));
220 usage (stream
, status
)
224 fprintf (stream
, _("Usage: %s OPTION... FILE...\n"), program_name
);
225 fprintf (stream
, _("Display information from object FILE.\n"));
226 fprintf (stream
, _("\n At least one of the following switches must be given:\n"));
227 fprintf (stream
, _("\
228 -a, --archive-headers Display archive header information\n\
229 -f, --file-headers Display the contents of the overall file header\n\
230 -p, --private-headers Display object format specific file header contents\n\
231 -h, --[section-]headers Display the contents of the section headers\n\
232 -x, --all-headers Display the contents of all headers\n\
233 -d, --disassemble Display assembler contents of executable sections\n\
234 -D, --disassemble-all Display assembler contents of all sections\n\
235 -S, --source Intermix source code with disassembly\n\
236 -s, --full-contents Display the full contents of all sections requested\n\
237 -g, --debugging Display debug information in object file\n\
238 -G, --stabs Display (in raw form) any STABS info in the file\n\
239 -t, --syms Display the contents of the symbol table(s)\n\
240 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
241 -r, --reloc Display the relocation entries in the file\n\
242 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
243 -V, --version Display this program's version number\n\
244 -i, --info List object formats and architectures supported\n\
245 -H, --help Display this information\n\
249 fprintf (stream
, _("\n The following switches are optional:\n"));
250 fprintf (stream
, _("\
251 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
252 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
253 -j, --section=NAME Only display information for section NAME\n\
254 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
255 -EB --endian=big Assume big endian format when disassembling\n\
256 -EL --endian=little Assume little endian format when disassembling\n\
257 --file-start-context Include context from start of file (with -S)\n\
258 -l, --line-numbers Include line numbers and filenames in output\n\
259 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
260 The STYLE, if specified, can be `auto', 'gnu',\n\
261 'lucid', 'arm', 'hp', 'edg', or 'gnu-new-abi'\n\
262 -w, --wide Format output for more than 80 columns\n\
263 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
264 --start-address=ADDR Only process data whoes address is >= ADDR\n\
265 --stop-address=ADDR Only process data whoes address is <= ADDR\n\
266 --prefix-addresses Print complete address alongside disassembly\n\
267 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
268 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
270 list_supported_targets (program_name
, stream
);
271 list_supported_architectures (program_name
, stream
);
273 disassembler_usage (stream
);
276 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
280 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
282 #define OPTION_ENDIAN (150)
283 #define OPTION_START_ADDRESS (OPTION_ENDIAN + 1)
284 #define OPTION_STOP_ADDRESS (OPTION_START_ADDRESS + 1)
285 #define OPTION_ADJUST_VMA (OPTION_STOP_ADDRESS + 1)
287 static struct option long_options
[]=
289 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
290 {"all-headers", no_argument
, NULL
, 'x'},
291 {"private-headers", no_argument
, NULL
, 'p'},
292 {"architecture", required_argument
, NULL
, 'm'},
293 {"archive-headers", no_argument
, NULL
, 'a'},
294 {"debugging", no_argument
, NULL
, 'g'},
295 {"demangle", optional_argument
, NULL
, 'C'},
296 {"disassemble", no_argument
, NULL
, 'd'},
297 {"disassemble-all", no_argument
, NULL
, 'D'},
298 {"disassembler-options", required_argument
, NULL
, 'M'},
299 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
300 {"dynamic-reloc", no_argument
, NULL
, 'R'},
301 {"dynamic-syms", no_argument
, NULL
, 'T'},
302 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
303 {"file-headers", no_argument
, NULL
, 'f'},
304 {"file-start-context", no_argument
, &file_start_context
, 1},
305 {"full-contents", no_argument
, NULL
, 's'},
306 {"headers", no_argument
, NULL
, 'h'},
307 {"help", no_argument
, NULL
, 'H'},
308 {"info", no_argument
, NULL
, 'i'},
309 {"line-numbers", no_argument
, NULL
, 'l'},
310 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
311 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
312 {"reloc", no_argument
, NULL
, 'r'},
313 {"section", required_argument
, NULL
, 'j'},
314 {"section-headers", no_argument
, NULL
, 'h'},
315 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
316 {"source", no_argument
, NULL
, 'S'},
317 {"stabs", no_argument
, NULL
, 'G'},
318 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
319 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
320 {"syms", no_argument
, NULL
, 't'},
321 {"target", required_argument
, NULL
, 'b'},
322 {"version", no_argument
, NULL
, 'V'},
323 {"wide", no_argument
, NULL
, 'w'},
324 {0, no_argument
, 0, 0}
336 dump_section_header (abfd
, section
, ignored
)
337 bfd
*abfd ATTRIBUTE_UNUSED
;
339 PTR ignored ATTRIBUTE_UNUSED
;
342 unsigned int opb
= bfd_octets_per_byte (abfd
);
344 printf ("%3d %-13s %08lx ", section
->index
,
345 bfd_get_section_name (abfd
, section
),
346 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
347 printf_vma (bfd_get_section_vma (abfd
, section
));
349 printf_vma (section
->lma
);
350 printf (" %08lx 2**%u", section
->filepos
,
351 bfd_get_section_alignment (abfd
, section
));
357 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
359 PF (SEC_HAS_CONTENTS
, "CONTENTS");
360 PF (SEC_ALLOC
, "ALLOC");
361 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
362 PF (SEC_CONSTRUCTOR_TEXT
, "CONSTRUCTOR TEXT");
363 PF (SEC_CONSTRUCTOR_DATA
, "CONSTRUCTOR DATA");
364 PF (SEC_CONSTRUCTOR_BSS
, "CONSTRUCTOR BSS");
365 PF (SEC_LOAD
, "LOAD");
366 PF (SEC_RELOC
, "RELOC");
368 PF (SEC_BALIGN
, "BALIGN");
370 PF (SEC_READONLY
, "READONLY");
371 PF (SEC_CODE
, "CODE");
372 PF (SEC_DATA
, "DATA");
374 PF (SEC_DEBUGGING
, "DEBUGGING");
375 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
376 PF (SEC_EXCLUDE
, "EXCLUDE");
377 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
378 PF (SEC_BLOCK
, "BLOCK");
379 PF (SEC_CLINK
, "CLINK");
380 PF (SEC_SMALL_DATA
, "SMALL_DATA");
381 PF (SEC_SHARED
, "SHARED");
383 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
387 switch (section
->flags
& SEC_LINK_DUPLICATES
)
391 case SEC_LINK_DUPLICATES_DISCARD
:
392 ls
= "LINK_ONCE_DISCARD";
394 case SEC_LINK_DUPLICATES_ONE_ONLY
:
395 ls
= "LINK_ONCE_ONE_ONLY";
397 case SEC_LINK_DUPLICATES_SAME_SIZE
:
398 ls
= "LINK_ONCE_SAME_SIZE";
400 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
401 ls
= "LINK_ONCE_SAME_CONTENTS";
404 printf ("%s%s", comma
, ls
);
406 if (section
->comdat
!= NULL
)
407 printf (" (COMDAT %s %ld)", section
->comdat
->name
,
408 section
->comdat
->symbol
);
421 printf (_("Sections:\n"));
424 printf (_("Idx Name Size VMA LMA File off Algn"));
426 printf (_("Idx Name Size VMA LMA File off Algn"));
430 printf (_(" Flags"));
433 bfd_map_over_sections (abfd
, dump_section_header
, (PTR
) NULL
);
440 asymbol
**sy
= (asymbol
**) NULL
;
443 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
445 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
450 storage
= bfd_get_symtab_upper_bound (abfd
);
452 bfd_fatal (bfd_get_filename (abfd
));
456 sy
= (asymbol
**) xmalloc (storage
);
458 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
460 bfd_fatal (bfd_get_filename (abfd
));
462 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
466 /* Read in the dynamic symbols. */
469 slurp_dynamic_symtab (abfd
)
472 asymbol
**sy
= (asymbol
**) NULL
;
475 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
478 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
480 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
485 bfd_fatal (bfd_get_filename (abfd
));
490 sy
= (asymbol
**) xmalloc (storage
);
492 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
494 bfd_fatal (bfd_get_filename (abfd
));
495 if (dynsymcount
== 0)
496 non_fatal (_("%s: No dynamic symbols"), bfd_get_filename (abfd
));
500 /* Filter out (in place) symbols that are useless for disassembly.
501 COUNT is the number of elements in SYMBOLS.
502 Return the number of useful symbols. */
505 remove_useless_symbols (symbols
, count
)
509 register asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
513 asymbol
*sym
= *in_ptr
++;
515 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
517 if (sym
->flags
& (BSF_DEBUGGING
))
519 if (bfd_is_und_section (sym
->section
)
520 || bfd_is_com_section (sym
->section
))
525 return out_ptr
- symbols
;
528 /* Sort symbols into value order. */
531 compare_symbols (ap
, bp
)
535 const asymbol
*a
= *(const asymbol
**)ap
;
536 const asymbol
*b
= *(const asymbol
**)bp
;
540 flagword aflags
, bflags
;
542 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
544 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
547 if (a
->section
> b
->section
)
549 else if (a
->section
< b
->section
)
552 an
= bfd_asymbol_name (a
);
553 bn
= bfd_asymbol_name (b
);
557 /* The symbols gnu_compiled and gcc2_compiled convey no real
558 information, so put them after other symbols with the same value. */
560 af
= (strstr (an
, "gnu_compiled") != NULL
561 || strstr (an
, "gcc2_compiled") != NULL
);
562 bf
= (strstr (bn
, "gnu_compiled") != NULL
563 || strstr (bn
, "gcc2_compiled") != NULL
);
570 /* We use a heuristic for the file name, to try to sort it after
571 more useful symbols. It may not work on non Unix systems, but it
572 doesn't really matter; the only difference is precisely which
573 symbol names get printed. */
575 #define file_symbol(s, sn, snl) \
576 (((s)->flags & BSF_FILE) != 0 \
577 || ((sn)[(snl) - 2] == '.' \
578 && ((sn)[(snl) - 1] == 'o' \
579 || (sn)[(snl) - 1] == 'a')))
581 af
= file_symbol (a
, an
, anl
);
582 bf
= file_symbol (b
, bn
, bnl
);
589 /* Try to sort global symbols before local symbols before function
590 symbols before debugging symbols. */
595 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
597 if ((aflags
& BSF_DEBUGGING
) != 0)
602 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
604 if ((aflags
& BSF_FUNCTION
) != 0)
609 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
611 if ((aflags
& BSF_LOCAL
) != 0)
616 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
618 if ((aflags
& BSF_GLOBAL
) != 0)
624 /* Symbols that start with '.' might be section names, so sort them
625 after symbols that don't start with '.'. */
626 if (an
[0] == '.' && bn
[0] != '.')
628 if (an
[0] != '.' && bn
[0] == '.')
631 /* Finally, if we can't distinguish them in any other way, try to
632 get consistent results by sorting the symbols by name. */
633 return strcmp (an
, bn
);
636 /* Sort relocs into address order. */
639 compare_relocs (ap
, bp
)
643 const arelent
*a
= *(const arelent
**)ap
;
644 const arelent
*b
= *(const arelent
**)bp
;
646 if (a
->address
> b
->address
)
648 else if (a
->address
< b
->address
)
651 /* So that associated relocations tied to the same address show up
652 in the correct order, we don't do any further sorting. */
661 /* Print VMA to STREAM. If SKIP_ZEROES is true, omit leading zeroes. */
664 objdump_print_value (vma
, info
, skip_zeroes
)
666 struct disassemble_info
*info
;
672 sprintf_vma (buf
, vma
);
677 for (p
= buf
; *p
== '0'; ++p
)
682 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
685 /* Print the name of a symbol. */
688 objdump_print_symname (abfd
, info
, sym
)
690 struct disassemble_info
*info
;
698 name
= bfd_asymbol_name (sym
);
699 if (! do_demangle
|| name
[0] == '\0')
703 /* Demangle the name. */
704 if (bfd_get_symbol_leading_char (abfd
) == name
[0])
707 alloc
= cplus_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
715 (*info
->fprintf_func
) (info
->stream
, "%s", print
);
717 printf ("%s", print
);
723 /* Locate a symbol given a bfd, a section, and a VMA. If REQUIRE_SEC
724 is true, then always require the symbol to be in the section. This
725 returns NULL if there is no suitable symbol. If PLACE is not NULL,
726 then *PLACE is set to the index of the symbol in sorted_syms. */
729 find_symbol_for_address (abfd
, sec
, vma
, require_sec
, place
)
736 /* @@ Would it speed things up to cache the last two symbols returned,
737 and maybe their address ranges? For many processors, only one memory
738 operand can be present at a time, so the 2-entry cache wouldn't be
739 constantly churned by code doing heavy memory accesses. */
741 /* Indices in `sorted_syms'. */
743 long max
= sorted_symcount
;
745 unsigned int opb
= bfd_octets_per_byte (abfd
);
747 if (sorted_symcount
< 1)
750 /* Perform a binary search looking for the closest symbol to the
751 required value. We are searching the range (min, max]. */
752 while (min
+ 1 < max
)
756 thisplace
= (max
+ min
) / 2;
757 sym
= sorted_syms
[thisplace
];
759 if (bfd_asymbol_value (sym
) > vma
)
761 else if (bfd_asymbol_value (sym
) < vma
)
770 /* The symbol we want is now in min, the low end of the range we
771 were searching. If there are several symbols with the same
772 value, we want the first one. */
775 && (bfd_asymbol_value (sorted_syms
[thisplace
])
776 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
779 /* If the file is relocateable, and the symbol could be from this
780 section, prefer a symbol from this section over symbols from
781 others, even if the other symbol's value might be closer.
783 Note that this may be wrong for some symbol references if the
784 sections have overlapping memory ranges, but in that case there's
785 no way to tell what's desired without looking at the relocation
788 if (sorted_syms
[thisplace
]->section
!= sec
790 || ((abfd
->flags
& HAS_RELOC
) != 0
791 && vma
>= bfd_get_section_vma (abfd
, sec
)
792 && vma
< (bfd_get_section_vma (abfd
, sec
)
793 + bfd_section_size (abfd
, sec
) / opb
))))
797 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
799 if (bfd_asymbol_value (sorted_syms
[i
])
800 != bfd_asymbol_value (sorted_syms
[thisplace
]))
806 if (sorted_syms
[i
]->section
== sec
808 || sorted_syms
[i
- 1]->section
!= sec
809 || (bfd_asymbol_value (sorted_syms
[i
])
810 != bfd_asymbol_value (sorted_syms
[i
- 1]))))
817 if (sorted_syms
[thisplace
]->section
!= sec
)
819 /* We didn't find a good symbol with a smaller value.
820 Look for one with a larger value. */
821 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
823 if (sorted_syms
[i
]->section
== sec
)
831 if (sorted_syms
[thisplace
]->section
!= sec
833 || ((abfd
->flags
& HAS_RELOC
) != 0
834 && vma
>= bfd_get_section_vma (abfd
, sec
)
835 && vma
< (bfd_get_section_vma (abfd
, sec
)
836 + bfd_section_size (abfd
, sec
)))))
838 /* There is no suitable symbol. */
846 return sorted_syms
[thisplace
];
849 /* Print an address to INFO symbolically. */
852 objdump_print_addr_with_sym (abfd
, sec
, sym
, vma
, info
, skip_zeroes
)
857 struct disassemble_info
*info
;
860 objdump_print_value (vma
, info
, skip_zeroes
);
866 (*info
->fprintf_func
) (info
->stream
, " <%s",
867 bfd_get_section_name (abfd
, sec
));
868 secaddr
= bfd_get_section_vma (abfd
, sec
);
871 (*info
->fprintf_func
) (info
->stream
, "-0x");
872 objdump_print_value (secaddr
- vma
, info
, true);
874 else if (vma
> secaddr
)
876 (*info
->fprintf_func
) (info
->stream
, "+0x");
877 objdump_print_value (vma
- secaddr
, info
, true);
879 (*info
->fprintf_func
) (info
->stream
, ">");
883 (*info
->fprintf_func
) (info
->stream
, " <");
884 objdump_print_symname (abfd
, info
, sym
);
885 if (bfd_asymbol_value (sym
) > vma
)
887 (*info
->fprintf_func
) (info
->stream
, "-0x");
888 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, true);
890 else if (vma
> bfd_asymbol_value (sym
))
892 (*info
->fprintf_func
) (info
->stream
, "+0x");
893 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, true);
895 (*info
->fprintf_func
) (info
->stream
, ">");
899 /* Print VMA to INFO, symbolically if possible. If SKIP_ZEROES is
900 true, don't output leading zeroes. */
903 objdump_print_addr (vma
, info
, skip_zeroes
)
905 struct disassemble_info
*info
;
908 struct objdump_disasm_info
*aux
;
911 if (sorted_symcount
< 1)
913 (*info
->fprintf_func
) (info
->stream
, "0x");
914 objdump_print_value (vma
, info
, skip_zeroes
);
918 aux
= (struct objdump_disasm_info
*) info
->application_data
;
919 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
921 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
925 /* Print VMA to INFO. This function is passed to the disassembler
929 objdump_print_address (vma
, info
)
931 struct disassemble_info
*info
;
933 objdump_print_addr (vma
, info
, ! prefix_addresses
);
936 /* Determine of the given address has a symbol associated with it. */
939 objdump_symbol_at_address (vma
, info
)
941 struct disassemble_info
* info
;
943 struct objdump_disasm_info
* aux
;
946 /* No symbols - do not bother checking. */
947 if (sorted_symcount
< 1)
950 aux
= (struct objdump_disasm_info
*) info
->application_data
;
951 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
954 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
957 /* Hold the last function name and the last line number we displayed
960 static char *prev_functionname
;
961 static unsigned int prev_line
;
963 /* We keep a list of all files that we have seen when doing a
964 dissassembly with source, so that we know how much of the file to
965 display. This can be important for inlined functions. */
967 struct print_file_list
969 struct print_file_list
*next
;
975 static struct print_file_list
*print_files
;
977 /* The number of preceding context lines to show when we start
978 displaying a file for the first time. */
980 #define SHOW_PRECEDING_CONTEXT_LINES (5)
982 /* Skip ahead to a given line in a file, optionally printing each
986 skip_to_line
PARAMS ((struct print_file_list
*, unsigned int, boolean
));
989 skip_to_line (p
, line
, show
)
990 struct print_file_list
*p
;
994 while (p
->line
< line
)
998 if (fgets (buf
, sizeof buf
, p
->f
) == NULL
)
1008 if (strchr (buf
, '\n') != NULL
)
1013 /* Show the line number, or the source line, in a dissassembly
1017 show_line (abfd
, section
, addr_offset
)
1020 bfd_vma addr_offset
;
1022 CONST
char *filename
;
1023 CONST
char *functionname
;
1026 if (! with_line_numbers
&& ! with_source_code
)
1029 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
1030 &functionname
, &line
))
1033 if (filename
!= NULL
&& *filename
== '\0')
1035 if (functionname
!= NULL
&& *functionname
== '\0')
1036 functionname
= NULL
;
1038 if (with_line_numbers
)
1040 if (functionname
!= NULL
1041 && (prev_functionname
== NULL
1042 || strcmp (functionname
, prev_functionname
) != 0))
1043 printf ("%s():\n", functionname
);
1044 if (line
> 0 && line
!= prev_line
)
1045 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
1048 if (with_source_code
1052 struct print_file_list
**pp
, *p
;
1054 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1055 if (strcmp ((*pp
)->filename
, filename
) == 0)
1061 if (p
!= print_files
)
1065 /* We have reencountered a file name which we saw
1066 earlier. This implies that either we are dumping out
1067 code from an included file, or the same file was
1068 linked in more than once. There are two common cases
1069 of an included file: inline functions in a header
1070 file, and a bison or flex skeleton file. In the
1071 former case we want to just start printing (but we
1072 back up a few lines to give context); in the latter
1073 case we want to continue from where we left off. I
1074 can't think of a good way to distinguish the cases,
1075 so I used a heuristic based on the file name. */
1076 if (strcmp (p
->filename
+ strlen (p
->filename
) - 2, ".h") != 0)
1080 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1087 p
->f
= fopen (p
->filename
, "r");
1091 skip_to_line (p
, l
, false);
1093 if (print_files
->f
!= NULL
)
1095 fclose (print_files
->f
);
1096 print_files
->f
= NULL
;
1102 skip_to_line (p
, line
, true);
1104 p
->next
= print_files
;
1112 f
= fopen (filename
, "r");
1117 p
= ((struct print_file_list
*)
1118 xmalloc (sizeof (struct print_file_list
)));
1119 p
->filename
= xmalloc (strlen (filename
) + 1);
1120 strcpy (p
->filename
, filename
);
1124 if (print_files
!= NULL
&& print_files
->f
!= NULL
)
1126 fclose (print_files
->f
);
1127 print_files
->f
= NULL
;
1129 p
->next
= print_files
;
1132 if (file_start_context
)
1135 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1138 skip_to_line (p
, l
, false);
1140 skip_to_line (p
, line
, true);
1145 if (functionname
!= NULL
1146 && (prev_functionname
== NULL
1147 || strcmp (functionname
, prev_functionname
) != 0))
1149 if (prev_functionname
!= NULL
)
1150 free (prev_functionname
);
1151 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1152 strcpy (prev_functionname
, functionname
);
1155 if (line
> 0 && line
!= prev_line
)
1159 /* Pseudo FILE object for strings. */
1167 /* sprintf to a "stream" */
1170 #ifdef ANSI_PROTOTYPES
1171 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1173 objdump_sprintf (va_alist
)
1177 #ifndef ANSI_PROTOTYPES
1185 #ifdef ANSI_PROTOTYPES
1186 va_start (args
, format
);
1189 f
= va_arg (args
, SFILE
*);
1190 format
= va_arg (args
, const char *);
1193 vasprintf (&buf
, format
, args
);
1199 fatal (_("Out of virtual memory"));
1204 while ((size_t) ((f
->buffer
+ f
->size
) - f
->current
) < n
+ 1)
1208 curroff
= f
->current
- f
->buffer
;
1210 f
->buffer
= xrealloc (f
->buffer
, f
->size
);
1211 f
->current
= f
->buffer
+ curroff
;
1214 memcpy (f
->current
, buf
, n
);
1216 f
->current
[0] = '\0';
1223 /* The number of zeroes we want to see before we start skipping them.
1224 The number is arbitrarily chosen. */
1227 #define SKIP_ZEROES (8)
1230 /* The number of zeroes to skip at the end of a section. If the
1231 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1232 SKIP_ZEROES, they will be disassembled. If there are fewer than
1233 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1234 attempt to avoid disassembling zeroes inserted by section
1237 #ifndef SKIP_ZEROES_AT_END
1238 #define SKIP_ZEROES_AT_END (3)
1241 /* Disassemble some data in memory between given values. */
1244 disassemble_bytes (info
, disassemble_fn
, insns
, data
,
1245 start_offset
, stop_offset
, relppp
,
1247 struct disassemble_info
*info
;
1248 disassembler_ftype disassemble_fn
;
1251 bfd_vma start_offset
;
1252 bfd_vma stop_offset
;
1256 struct objdump_disasm_info
*aux
;
1258 int octets_per_line
;
1260 int skip_addr_chars
;
1261 bfd_vma addr_offset
;
1262 int opb
= info
->octets_per_byte
;
1264 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1268 octets_per_line
= 4;
1270 octets_per_line
= 16;
1272 /* Figure out how many characters to skip at the start of an
1273 address, to make the disassembly look nicer. We discard leading
1274 zeroes in chunks of 4, ensuring that there is always a leading
1276 skip_addr_chars
= 0;
1277 if (! prefix_addresses
)
1282 sprintf_vma (buf
, section
->vma
+
1283 bfd_section_size (section
->owner
, section
) / opb
);
1285 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1288 skip_addr_chars
+= 4;
1293 info
->insn_info_valid
= 0;
1296 addr_offset
= start_offset
;
1297 while (addr_offset
< stop_offset
)
1301 boolean need_nl
= false;
1303 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1305 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1308 if (! disassemble_zeroes
1309 && (info
->insn_info_valid
== 0
1310 || info
->branch_delay_insns
== 0)
1311 && (z
- addr_offset
* opb
>= SKIP_ZEROES
1312 || (z
== stop_offset
* opb
&&
1313 z
- addr_offset
* opb
< SKIP_ZEROES_AT_END
)))
1317 /* If there are more nonzero octets to follow, we only skip
1318 zeroes in multiples of 4, to try to avoid running over
1319 the start of an instruction which happens to start with
1321 if (z
!= stop_offset
* opb
)
1322 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1324 octets
= z
- addr_offset
* opb
;
1335 if (with_line_numbers
|| with_source_code
)
1336 /* The line number tables will refer to unadjusted
1337 section VMAs, so we must undo any VMA modifications
1338 when calling show_line. */
1339 show_line (aux
->abfd
, section
, addr_offset
- adjust_section_vma
);
1341 if (! prefix_addresses
)
1345 sprintf_vma (buf
, section
->vma
+ addr_offset
);
1346 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1350 printf ("%s:\t", buf
+ skip_addr_chars
);
1354 aux
->require_sec
= true;
1355 objdump_print_address (section
->vma
+ addr_offset
, info
);
1356 aux
->require_sec
= false;
1363 sfile
.buffer
= xmalloc (sfile
.size
);
1364 sfile
.current
= sfile
.buffer
;
1365 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1366 info
->stream
= (FILE *) &sfile
;
1367 info
->bytes_per_line
= 0;
1368 info
->bytes_per_chunk
= 0;
1370 #ifdef DISASSEMBLER_NEEDS_RELOCS
1371 /* FIXME: This is wrong. It tests the number of octets
1372 in the last instruction, not the current one. */
1373 if (*relppp
< relppend
1374 && (**relppp
)->address
>= addr_offset
1375 && (**relppp
)->address
<= addr_offset
+ octets
/ opb
)
1376 info
->flags
= INSN_HAS_RELOC
;
1381 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, info
);
1382 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1383 info
->stream
= stdout
;
1384 if (info
->bytes_per_line
!= 0)
1385 octets_per_line
= info
->bytes_per_line
;
1388 if (sfile
.current
!= sfile
.buffer
)
1389 printf ("%s\n", sfile
.buffer
);
1390 free (sfile
.buffer
);
1398 octets
= octets_per_line
;
1399 if (addr_offset
+ octets
/ opb
> stop_offset
)
1400 octets
= (stop_offset
- addr_offset
) * opb
;
1402 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1404 if (isprint (data
[j
]))
1405 buf
[j
- addr_offset
* opb
] = data
[j
];
1407 buf
[j
- addr_offset
* opb
] = '.';
1409 buf
[j
- addr_offset
* opb
] = '\0';
1412 if (prefix_addresses
1414 : show_raw_insn
>= 0)
1418 /* If ! prefix_addresses and ! wide_output, we print
1419 octets_per_line octets per line. */
1421 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1422 pb
= octets_per_line
;
1424 if (info
->bytes_per_chunk
)
1425 bpc
= info
->bytes_per_chunk
;
1429 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1432 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1434 for (k
= bpc
- 1; k
>= 0; k
--)
1435 printf ("%02x", (unsigned) data
[j
+ k
]);
1440 for (k
= 0; k
< bpc
; k
++)
1441 printf ("%02x", (unsigned) data
[j
+ k
]);
1446 for (; pb
< octets_per_line
; pb
+= bpc
)
1450 for (k
= 0; k
< bpc
; k
++)
1455 /* Separate raw data from instruction by extra space. */
1466 printf ("%s", sfile
.buffer
);
1467 free (sfile
.buffer
);
1470 if (prefix_addresses
1472 : show_raw_insn
>= 0)
1480 j
= addr_offset
* opb
+ pb
;
1482 sprintf_vma (buf
, section
->vma
+ j
/ opb
);
1483 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1487 printf ("%s:\t", buf
+ skip_addr_chars
);
1489 pb
+= octets_per_line
;
1492 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1496 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1498 for (k
= bpc
- 1; k
>= 0; k
--)
1499 printf ("%02x", (unsigned) data
[j
+ k
]);
1504 for (k
= 0; k
< bpc
; k
++)
1505 printf ("%02x", (unsigned) data
[j
+ k
]);
1518 if ((section
->flags
& SEC_RELOC
) != 0
1519 #ifndef DISASSEMBLER_NEEDS_RELOCS
1524 while ((*relppp
) < relppend
1525 && ((**relppp
)->address
>= (bfd_vma
) addr_offset
1526 && (**relppp
)->address
< (bfd_vma
) addr_offset
+ octets
/ opb
))
1527 #ifdef DISASSEMBLER_NEEDS_RELOCS
1528 if (! dump_reloc_info
)
1542 objdump_print_value (section
->vma
+ q
->address
, info
, true);
1544 printf (": %s\t", q
->howto
->name
);
1546 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1547 printf ("*unknown*");
1550 const char *sym_name
;
1552 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1553 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1554 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1559 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1560 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1561 if (sym_name
== NULL
|| *sym_name
== '\0')
1562 sym_name
= "*unknown*";
1563 printf ("%s", sym_name
);
1570 objdump_print_value (q
->addend
, info
, true);
1582 addr_offset
+= octets
/ opb
;
1586 /* Disassemble the contents of an object file. */
1589 disassemble_data (abfd
)
1592 unsigned long addr_offset
;
1593 disassembler_ftype disassemble_fn
;
1594 struct disassemble_info disasm_info
;
1595 struct objdump_disasm_info aux
;
1600 prev_functionname
= NULL
;
1603 /* We make a copy of syms to sort. We don't want to sort syms
1604 because that will screw up the relocs. */
1605 sorted_syms
= (asymbol
**) xmalloc (symcount
* sizeof (asymbol
*));
1606 memcpy (sorted_syms
, syms
, symcount
* sizeof (asymbol
*));
1608 sorted_symcount
= remove_useless_symbols (sorted_syms
, symcount
);
1610 /* Sort the symbols into section and symbol order */
1611 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1613 INIT_DISASSEMBLE_INFO(disasm_info
, stdout
, fprintf
);
1614 disasm_info
.application_data
= (PTR
) &aux
;
1616 aux
.require_sec
= false;
1617 disasm_info
.print_address_func
= objdump_print_address
;
1618 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1620 if (machine
!= (char *) NULL
)
1622 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1625 fatal (_("Can't use supplied machine %s"), machine
);
1627 abfd
->arch_info
= info
;
1630 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1632 struct bfd_target
*xvec
;
1634 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
1635 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1636 xvec
->byteorder
= endian
;
1640 disassemble_fn
= disassembler (abfd
);
1641 if (!disassemble_fn
)
1643 non_fatal (_("Can't disassemble for architecture %s\n"),
1644 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1649 opb
= bfd_octets_per_byte (abfd
);
1651 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1652 disasm_info
.arch
= bfd_get_arch (abfd
);
1653 disasm_info
.mach
= bfd_get_mach (abfd
);
1654 disasm_info
.disassembler_options
= disassembler_options
;
1655 disasm_info
.octets_per_byte
= opb
;
1657 if (bfd_big_endian (abfd
))
1658 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1659 else if (bfd_little_endian (abfd
))
1660 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1662 /* ??? Aborting here seems too drastic. We could default to big or little
1664 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1666 for (section
= abfd
->sections
;
1667 section
!= (asection
*) NULL
;
1668 section
= section
->next
)
1670 bfd_byte
*data
= NULL
;
1671 bfd_size_type datasize
= 0;
1672 arelent
**relbuf
= NULL
;
1673 arelent
**relpp
= NULL
;
1674 arelent
**relppend
= NULL
;
1675 unsigned long stop_offset
;
1676 asymbol
*sym
= NULL
;
1679 if ((section
->flags
& SEC_LOAD
) == 0
1680 || (! disassemble_all
1682 && (section
->flags
& SEC_CODE
) == 0))
1684 if (only
!= (char *) NULL
&& strcmp (only
, section
->name
) != 0)
1687 if ((section
->flags
& SEC_RELOC
) != 0
1688 #ifndef DISASSEMBLER_NEEDS_RELOCS
1695 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1697 bfd_fatal (bfd_get_filename (abfd
));
1703 relbuf
= (arelent
**) xmalloc (relsize
);
1704 relcount
= bfd_canonicalize_reloc (abfd
, section
, relbuf
, syms
);
1706 bfd_fatal (bfd_get_filename (abfd
));
1708 /* Sort the relocs by address. */
1709 qsort (relbuf
, relcount
, sizeof (arelent
*), compare_relocs
);
1712 relppend
= relpp
+ relcount
;
1714 /* Skip over the relocs belonging to addresses below the
1716 if (start_address
!= (bfd_vma
) -1)
1718 while (relpp
< relppend
1719 && (*relpp
)->address
< start_address
)
1725 printf (_("Disassembly of section %s:\n"), section
->name
);
1727 datasize
= bfd_get_section_size_before_reloc (section
);
1731 data
= (bfd_byte
*) xmalloc ((size_t) datasize
);
1733 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1736 disasm_info
.buffer
= data
;
1737 disasm_info
.buffer_vma
= section
->vma
;
1738 disasm_info
.buffer_length
= datasize
;
1739 disasm_info
.section
= section
;
1740 if (start_address
== (bfd_vma
) -1
1741 || start_address
< disasm_info
.buffer_vma
)
1744 addr_offset
= start_address
- disasm_info
.buffer_vma
;
1745 if (stop_address
== (bfd_vma
) -1)
1746 stop_offset
= datasize
/ opb
;
1749 if (stop_address
< disasm_info
.buffer_vma
)
1752 stop_offset
= stop_address
- disasm_info
.buffer_vma
;
1753 if (stop_offset
> disasm_info
.buffer_length
/ opb
)
1754 stop_offset
= disasm_info
.buffer_length
/ opb
;
1757 sym
= find_symbol_for_address (abfd
, section
, section
->vma
+ addr_offset
,
1760 while (addr_offset
< stop_offset
)
1763 unsigned long nextstop_offset
;
1766 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= section
->vma
+ addr_offset
)
1771 (x
< sorted_symcount
1772 && bfd_asymbol_value (sorted_syms
[x
]) <= section
->vma
+ addr_offset
);
1775 disasm_info
.symbols
= & sorted_syms
[place
];
1776 disasm_info
.num_symbols
= x
- place
;
1779 disasm_info
.symbols
= NULL
;
1781 if (! prefix_addresses
)
1784 objdump_print_addr_with_sym (abfd
, section
, sym
,
1785 section
->vma
+ addr_offset
,
1791 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
)
1793 else if (sym
== NULL
)
1797 /* Search forward for the next appropriate symbol in
1798 SECTION. Note that all the symbols are sorted
1799 together into one big array, and that some sections
1800 may have overlapping addresses. */
1801 while (place
< sorted_symcount
1802 && (sorted_syms
[place
]->section
!= section
1803 || (bfd_asymbol_value (sorted_syms
[place
])
1804 <= bfd_asymbol_value (sym
))))
1806 if (place
>= sorted_symcount
)
1809 nextsym
= sorted_syms
[place
];
1812 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
)
1814 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1815 if (nextstop_offset
> stop_offset
)
1816 nextstop_offset
= stop_offset
;
1818 else if (nextsym
== NULL
)
1819 nextstop_offset
= stop_offset
;
1822 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1823 if (nextstop_offset
> stop_offset
)
1824 nextstop_offset
= stop_offset
;
1827 /* If a symbol is explicitly marked as being an object
1828 rather than a function, just dump the bytes without
1829 disassembling them. */
1832 || bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
1833 || ((sym
->flags
& BSF_OBJECT
) == 0
1834 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1836 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1838 || (sym
->flags
& BSF_FUNCTION
) != 0)
1843 disassemble_bytes (&disasm_info
, disassemble_fn
, insns
, data
,
1844 addr_offset
, nextstop_offset
, &relpp
, relppend
);
1846 addr_offset
= nextstop_offset
;
1858 /* Define a table of stab values and print-strings. We wish the initializer
1859 could be a direct-mapped table, but instead we build one the first
1862 static void dump_section_stabs
PARAMS ((bfd
*abfd
, char *stabsect_name
,
1863 char *strsect_name
));
1865 /* Dump the stabs sections from an object file that has a section that
1866 uses Sun stabs encoding. */
1872 dump_section_stabs (abfd
, ".stab", ".stabstr");
1873 dump_section_stabs (abfd
, ".stab.excl", ".stab.exclstr");
1874 dump_section_stabs (abfd
, ".stab.index", ".stab.indexstr");
1875 dump_section_stabs (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1878 static bfd_byte
*stabs
;
1879 static bfd_size_type stab_size
;
1881 static char *strtab
;
1882 static bfd_size_type stabstr_size
;
1884 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1885 and string table section STRSECT_NAME into `strtab'.
1886 If the section exists and was read, allocate the space and return true.
1887 Otherwise return false. */
1890 read_section_stabs (abfd
, stabsect_name
, strsect_name
)
1892 const char *stabsect_name
;
1893 const char *strsect_name
;
1895 asection
*stabsect
, *stabstrsect
;
1897 stabsect
= bfd_get_section_by_name (abfd
, stabsect_name
);
1900 printf (_("No %s section present\n\n"), stabsect_name
);
1904 stabstrsect
= bfd_get_section_by_name (abfd
, strsect_name
);
1905 if (0 == stabstrsect
)
1907 non_fatal (_("%s has no %s section"),
1908 bfd_get_filename (abfd
), strsect_name
);
1913 stab_size
= bfd_section_size (abfd
, stabsect
);
1914 stabstr_size
= bfd_section_size (abfd
, stabstrsect
);
1916 stabs
= (bfd_byte
*) xmalloc (stab_size
);
1917 strtab
= (char *) xmalloc (stabstr_size
);
1919 if (! bfd_get_section_contents (abfd
, stabsect
, (PTR
) stabs
, 0, stab_size
))
1921 non_fatal (_("Reading %s section of %s failed: %s"),
1922 stabsect_name
, bfd_get_filename (abfd
),
1923 bfd_errmsg (bfd_get_error ()));
1930 if (! bfd_get_section_contents (abfd
, stabstrsect
, (PTR
) strtab
, 0,
1933 non_fatal (_("Reading %s section of %s failed: %s\n"),
1934 strsect_name
, bfd_get_filename (abfd
),
1935 bfd_errmsg (bfd_get_error ()));
1945 /* Stabs entries use a 12 byte format:
1946 4 byte string table index
1948 1 byte stab other field
1949 2 byte stab desc field
1951 FIXME: This will have to change for a 64 bit object format. */
1953 #define STRDXOFF (0)
1955 #define OTHEROFF (5)
1958 #define STABSIZE (12)
1960 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1961 using string table section STRSECT_NAME (in `strtab'). */
1964 print_section_stabs (abfd
, stabsect_name
, strsect_name
)
1966 const char *stabsect_name
;
1967 const char *strsect_name ATTRIBUTE_UNUSED
;
1970 unsigned file_string_table_offset
= 0, next_file_string_table_offset
= 0;
1971 bfd_byte
*stabp
, *stabs_end
;
1974 stabs_end
= stabp
+ stab_size
;
1976 printf (_("Contents of %s section:\n\n"), stabsect_name
);
1977 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1979 /* Loop through all symbols and print them.
1981 We start the index at -1 because there is a dummy symbol on
1982 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1984 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
1988 unsigned char type
, other
;
1989 unsigned short desc
;
1992 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
1993 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
1994 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
1995 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
1996 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
1998 printf ("\n%-6d ", i
);
1999 /* Either print the stab name, or, if unnamed, print its number
2000 again (makes consistent formatting for tools like awk). */
2001 name
= bfd_get_stab_name (type
);
2003 printf ("%-6s", name
);
2004 else if (type
== N_UNDF
)
2007 printf ("%-6d", type
);
2008 printf (" %-6d %-6d ", other
, desc
);
2010 printf (" %-6lu", strx
);
2012 /* Symbols with type == 0 (N_UNDF) specify the length of the
2013 string table associated with this file. We use that info
2014 to know how to relocate the *next* file's string table indices. */
2018 file_string_table_offset
= next_file_string_table_offset
;
2019 next_file_string_table_offset
+= value
;
2023 /* Using the (possibly updated) string table offset, print the
2024 string (if any) associated with this symbol. */
2026 if ((strx
+ file_string_table_offset
) < stabstr_size
)
2027 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
2036 dump_section_stabs (abfd
, stabsect_name
, strsect_name
)
2038 char *stabsect_name
;
2043 /* Check for section names for which stabsect_name is a prefix, to
2044 handle .stab0, etc. */
2045 for (s
= abfd
->sections
;
2051 len
= strlen (stabsect_name
);
2053 /* If the prefix matches, and the files section name ends with a
2054 nul or a digit, then we match. I.e., we want either an exact
2055 match or a section followed by a number. */
2056 if (strncmp (stabsect_name
, s
->name
, len
) == 0
2057 && (s
->name
[len
] == '\000'
2058 || isdigit ((unsigned char) s
->name
[len
])))
2060 if (read_section_stabs (abfd
, s
->name
, strsect_name
))
2062 print_section_stabs (abfd
, s
->name
, strsect_name
);
2071 dump_bfd_header (abfd
)
2076 printf (_("architecture: %s, "),
2077 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2078 bfd_get_mach (abfd
)));
2079 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2081 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2082 PF (HAS_RELOC
, "HAS_RELOC");
2083 PF (EXEC_P
, "EXEC_P");
2084 PF (HAS_LINENO
, "HAS_LINENO");
2085 PF (HAS_DEBUG
, "HAS_DEBUG");
2086 PF (HAS_SYMS
, "HAS_SYMS");
2087 PF (HAS_LOCALS
, "HAS_LOCALS");
2088 PF (DYNAMIC
, "DYNAMIC");
2089 PF (WP_TEXT
, "WP_TEXT");
2090 PF (D_PAGED
, "D_PAGED");
2091 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2092 printf (_("\nstart address 0x"));
2093 printf_vma (abfd
->start_address
);
2098 dump_bfd_private_header (abfd
)
2101 bfd_print_private_bfd_data (abfd
, stdout
);
2104 /* Dump selected contents of ABFD */
2110 /* If we are adjusting section VMA's, change them all now. Changing
2111 the BFD information is a hack. However, we must do it, or
2112 bfd_find_nearest_line will not do the right thing. */
2113 if (adjust_section_vma
!= 0)
2117 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2119 s
->vma
+= adjust_section_vma
;
2120 s
->lma
+= adjust_section_vma
;
2124 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2127 print_arelt_descr (stdout
, abfd
, true);
2128 if (dump_file_header
)
2129 dump_bfd_header (abfd
);
2130 if (dump_private_headers
)
2131 dump_bfd_private_header (abfd
);
2133 if (dump_section_headers
)
2134 dump_headers (abfd
);
2135 if (dump_symtab
|| dump_reloc_info
|| disassemble
|| dump_debugging
)
2137 syms
= slurp_symtab (abfd
);
2139 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
)
2141 dynsyms
= slurp_dynamic_symtab (abfd
);
2144 dump_symbols (abfd
, false);
2145 if (dump_dynamic_symtab
)
2146 dump_symbols (abfd
, true);
2147 if (dump_stab_section_info
)
2149 if (dump_reloc_info
&& ! disassemble
)
2151 if (dump_dynamic_reloc_info
)
2152 dump_dynamic_relocs (abfd
);
2153 if (dump_section_contents
)
2156 disassemble_data (abfd
);
2161 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2162 if (dhandle
!= NULL
)
2164 if (! print_debugging_info (stdout
, dhandle
))
2166 non_fatal (_("%s: printing debugging information failed"),
2167 bfd_get_filename (abfd
));
2190 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2196 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2198 nonfatal (bfd_get_filename (abfd
));
2199 list_matching_formats (matching
);
2204 if (bfd_get_error () != bfd_error_file_not_recognized
)
2206 nonfatal (bfd_get_filename (abfd
));
2210 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
2216 nonfatal (bfd_get_filename (abfd
));
2218 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2220 list_matching_formats (matching
);
2226 display_file (filename
, target
)
2230 bfd
*file
, *arfile
= (bfd
*) NULL
;
2232 file
= bfd_openr (filename
, target
);
2235 nonfatal (filename
);
2239 if (bfd_check_format (file
, bfd_archive
) == true)
2241 bfd
*last_arfile
= NULL
;
2243 printf (_("In archive %s:\n"), bfd_get_filename (file
));
2246 bfd_set_error (bfd_error_no_error
);
2248 arfile
= bfd_openr_next_archived_file (file
, arfile
);
2251 if (bfd_get_error () != bfd_error_no_more_archived_files
)
2252 nonfatal (bfd_get_filename (file
));
2256 display_bfd (arfile
);
2258 if (last_arfile
!= NULL
)
2259 bfd_close (last_arfile
);
2260 last_arfile
= arfile
;
2263 if (last_arfile
!= NULL
)
2264 bfd_close (last_arfile
);
2272 /* Actually display the various requested regions */
2280 bfd_size_type datasize
= 0;
2281 bfd_size_type addr_offset
;
2282 bfd_size_type start_offset
, stop_offset
;
2283 unsigned int opb
= bfd_octets_per_byte (abfd
);
2285 for (section
= abfd
->sections
; section
!= NULL
; section
=
2290 if (only
== (char *) NULL
||
2291 strcmp (only
, section
->name
) == 0)
2293 if (section
->flags
& SEC_HAS_CONTENTS
)
2295 printf (_("Contents of section %s:\n"), section
->name
);
2297 if (bfd_section_size (abfd
, section
) == 0)
2299 data
= (bfd_byte
*) xmalloc ((size_t) bfd_section_size (abfd
, section
));
2300 datasize
= bfd_section_size (abfd
, section
);
2303 bfd_get_section_contents (abfd
, section
, (PTR
) data
, 0, bfd_section_size (abfd
, section
));
2305 if (start_address
== (bfd_vma
) -1
2306 || start_address
< section
->vma
)
2309 start_offset
= start_address
- section
->vma
;
2310 if (stop_address
== (bfd_vma
) -1)
2311 stop_offset
= bfd_section_size (abfd
, section
) / opb
;
2314 if (stop_address
< section
->vma
)
2317 stop_offset
= stop_address
- section
->vma
;
2318 if (stop_offset
> bfd_section_size (abfd
, section
) / opb
)
2319 stop_offset
= bfd_section_size (abfd
, section
) / opb
;
2321 for (addr_offset
= start_offset
;
2322 addr_offset
< stop_offset
; addr_offset
+= onaline
)
2326 printf (" %04lx ", (unsigned long int)
2327 (addr_offset
+ section
->vma
));
2328 for (j
= addr_offset
* opb
;
2329 j
< addr_offset
* opb
+ onaline
; j
++)
2331 if (j
< stop_offset
* opb
)
2332 printf ("%02x", (unsigned) (data
[j
]));
2340 for (j
= addr_offset
; j
< addr_offset
* opb
+ onaline
; j
++)
2342 if (j
>= stop_offset
* opb
)
2345 printf ("%c", isprint (data
[j
]) ? data
[j
] : '.');
2355 /* Should perhaps share code and display with nm? */
2357 dump_symbols (abfd
, dynamic
)
2358 bfd
*abfd ATTRIBUTE_UNUSED
;
2371 printf ("DYNAMIC SYMBOL TABLE:\n");
2379 printf ("SYMBOL TABLE:\n");
2382 for (count
= 0; count
< max
; count
++)
2386 bfd
*cur_bfd
= bfd_asymbol_bfd (*current
);
2388 if (cur_bfd
!= NULL
)
2393 name
= bfd_asymbol_name (*current
);
2395 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2399 /* If we want to demangle the name, we demangle it
2400 here, and temporarily clobber it while calling
2401 bfd_print_symbol. FIXME: This is a gross hack. */
2404 if (bfd_get_symbol_leading_char (cur_bfd
) == *n
)
2406 alloc
= cplus_demangle (n
, DMGL_ANSI
| DMGL_PARAMS
);
2408 (*current
)->name
= alloc
;
2410 (*current
)->name
= n
;
2413 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2414 bfd_print_symbol_all
);
2416 (*current
)->name
= name
;
2437 for (a
= abfd
->sections
; a
!= (asection
*) NULL
; a
= a
->next
)
2441 if (bfd_is_abs_section (a
))
2443 if (bfd_is_und_section (a
))
2445 if (bfd_is_com_section (a
))
2450 if (strcmp (only
, a
->name
))
2453 else if ((a
->flags
& SEC_RELOC
) == 0)
2456 relsize
= bfd_get_reloc_upper_bound (abfd
, a
);
2458 bfd_fatal (bfd_get_filename (abfd
));
2460 printf ("RELOCATION RECORDS FOR [%s]:", a
->name
);
2464 printf (" (none)\n\n");
2468 relpp
= (arelent
**) xmalloc (relsize
);
2469 relcount
= bfd_canonicalize_reloc (abfd
, a
, relpp
, syms
);
2471 bfd_fatal (bfd_get_filename (abfd
));
2472 else if (relcount
== 0)
2474 printf (" (none)\n\n");
2479 dump_reloc_set (abfd
, a
, relpp
, relcount
);
2488 dump_dynamic_relocs (abfd
)
2495 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2497 bfd_fatal (bfd_get_filename (abfd
));
2499 printf ("DYNAMIC RELOCATION RECORDS");
2503 printf (" (none)\n\n");
2507 relpp
= (arelent
**) xmalloc (relsize
);
2508 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2510 bfd_fatal (bfd_get_filename (abfd
));
2511 else if (relcount
== 0)
2513 printf (" (none)\n\n");
2518 dump_reloc_set (abfd
, (asection
*) NULL
, relpp
, relcount
);
2526 dump_reloc_set (abfd
, sec
, relpp
, relcount
)
2533 char *last_filename
, *last_functionname
;
2534 unsigned int last_line
;
2536 /* Get column headers lined up reasonably. */
2542 sprintf_vma (buf
, (bfd_vma
) -1);
2543 width
= strlen (buf
) - 7;
2545 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2548 last_filename
= NULL
;
2549 last_functionname
= NULL
;
2552 for (p
= relpp
; relcount
&& *p
!= (arelent
*) NULL
; p
++, relcount
--)
2555 const char *filename
, *functionname
;
2557 const char *sym_name
;
2558 const char *section_name
;
2560 if (start_address
!= (bfd_vma
) -1
2561 && q
->address
< start_address
)
2563 if (stop_address
!= (bfd_vma
) -1
2564 && q
->address
> stop_address
)
2567 if (with_line_numbers
2569 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2570 &filename
, &functionname
, &line
))
2572 if (functionname
!= NULL
2573 && (last_functionname
== NULL
2574 || strcmp (functionname
, last_functionname
) != 0))
2576 printf ("%s():\n", functionname
);
2577 if (last_functionname
!= NULL
)
2578 free (last_functionname
);
2579 last_functionname
= xstrdup (functionname
);
2582 && (line
!= last_line
2583 || (filename
!= NULL
2584 && last_filename
!= NULL
2585 && strcmp (filename
, last_filename
) != 0)))
2587 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2589 if (last_filename
!= NULL
)
2590 free (last_filename
);
2591 if (filename
== NULL
)
2592 last_filename
= NULL
;
2594 last_filename
= xstrdup (filename
);
2598 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2600 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2601 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2606 section_name
= NULL
;
2610 printf_vma (q
->address
);
2612 printf (" %-16s ", q
->howto
->name
);
2614 printf (" %-16d ", q
->howto
->type
);
2615 objdump_print_symname (abfd
, (struct disassemble_info
*) NULL
,
2620 if (section_name
== (CONST
char *) NULL
)
2621 section_name
= "*unknown*";
2622 printf_vma (q
->address
);
2623 printf (" %-16s [%s]",
2630 printf_vma (q
->addend
);
2636 /* The length of the longest architecture name + 1. */
2637 #define LONGEST_ARCH sizeof("powerpc:common")
2640 endian_string (endian
)
2641 enum bfd_endian endian
;
2643 if (endian
== BFD_ENDIAN_BIG
)
2644 return "big endian";
2645 else if (endian
== BFD_ENDIAN_LITTLE
)
2646 return "little endian";
2648 return "endianness unknown";
2651 /* List the targets that BFD is configured to support, each followed
2652 by its endianness and the architectures it supports. */
2655 display_target_list ()
2657 extern const bfd_target
*const *bfd_target_vector
;
2661 dummy_name
= make_temp_file (NULL
);
2662 for (t
= 0; bfd_target_vector
[t
]; t
++)
2664 const bfd_target
*p
= bfd_target_vector
[t
];
2665 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2668 printf ("%s\n (header %s, data %s)\n", p
->name
,
2669 endian_string (p
->header_byteorder
),
2670 endian_string (p
->byteorder
));
2674 nonfatal (dummy_name
);
2678 if (! bfd_set_format (abfd
, bfd_object
))
2680 if (bfd_get_error () != bfd_error_invalid_operation
)
2682 bfd_close_all_done (abfd
);
2686 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2687 if (bfd_set_arch_mach (abfd
, (enum bfd_architecture
) a
, 0))
2689 bfd_printable_arch_mach ((enum bfd_architecture
) a
, 0));
2690 bfd_close_all_done (abfd
);
2692 unlink (dummy_name
);
2696 /* Print a table showing which architectures are supported for entries
2697 FIRST through LAST-1 of bfd_target_vector (targets across,
2698 architectures down). */
2701 display_info_table (first
, last
)
2705 extern const bfd_target
*const *bfd_target_vector
;
2709 /* Print heading of target names. */
2710 printf ("\n%*s", (int) LONGEST_ARCH
, " ");
2711 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2712 printf ("%s ", bfd_target_vector
[t
]->name
);
2715 dummy_name
= make_temp_file (NULL
);
2716 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2717 if (strcmp (bfd_printable_arch_mach (a
, 0), "UNKNOWN!") != 0)
2719 printf ("%*s ", (int) LONGEST_ARCH
- 1,
2720 bfd_printable_arch_mach (a
, 0));
2721 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2723 const bfd_target
*p
= bfd_target_vector
[t
];
2725 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2735 if (! bfd_set_format (abfd
, bfd_object
))
2737 if (bfd_get_error () != bfd_error_invalid_operation
)
2745 if (! bfd_set_arch_mach (abfd
, a
, 0))
2750 printf ("%s ", p
->name
);
2753 int l
= strlen (p
->name
);
2759 bfd_close_all_done (abfd
);
2763 unlink (dummy_name
);
2767 /* Print tables of all the target-architecture combinations that
2768 BFD has been configured to support. */
2771 display_target_tables ()
2774 extern const bfd_target
*const *bfd_target_vector
;
2778 colum
= getenv ("COLUMNS");
2780 columns
= atoi (colum
);
2785 while (bfd_target_vector
[t
] != NULL
)
2789 wid
= LONGEST_ARCH
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2791 while (wid
< columns
&& bfd_target_vector
[t
] != NULL
)
2795 newwid
= wid
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2796 if (newwid
>= columns
)
2801 display_info_table (oldt
, t
);
2808 printf (_("BFD header file version %s\n"), BFD_VERSION
);
2809 display_target_list ();
2810 display_target_tables ();
2819 char *target
= default_target
;
2820 boolean seenflag
= false;
2822 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
2823 setlocale (LC_MESSAGES
, "");
2825 bindtextdomain (PACKAGE
, LOCALEDIR
);
2826 textdomain (PACKAGE
);
2828 program_name
= *argv
;
2829 xmalloc_set_program_name (program_name
);
2831 START_PROGRESS (program_name
, 0);
2834 set_default_bfd_target ();
2836 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VCdDlfahHrRtTxsSj:wE:zgG",
2837 long_options
, (int *) 0))
2843 break; /* we've been given a long option */
2848 disassembler_options
= optarg
;
2854 with_line_numbers
= true;
2863 enum demangling_styles style
;
2865 style
= cplus_demangle_name_to_style (optarg
);
2866 if (style
== unknown_demangling
)
2867 fatal (_("unknown demangling style `%s'"),
2870 cplus_demangle_set_style (style
);
2876 case OPTION_ADJUST_VMA
:
2877 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
2879 case OPTION_START_ADDRESS
:
2880 start_address
= parse_vma (optarg
, "--start-address");
2882 case OPTION_STOP_ADDRESS
:
2883 stop_address
= parse_vma (optarg
, "--stop-address");
2886 if (strcmp (optarg
, "B") == 0)
2887 endian
= BFD_ENDIAN_BIG
;
2888 else if (strcmp (optarg
, "L") == 0)
2889 endian
= BFD_ENDIAN_LITTLE
;
2892 non_fatal (_("unrecognized -E option"));
2897 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
2898 endian
= BFD_ENDIAN_BIG
;
2899 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
2900 endian
= BFD_ENDIAN_LITTLE
;
2903 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
2909 dump_file_header
= true;
2913 formats_info
= true;
2917 dump_private_headers
= true;
2921 dump_private_headers
= true;
2923 dump_reloc_info
= true;
2924 dump_file_header
= true;
2925 dump_ar_hdrs
= true;
2926 dump_section_headers
= true;
2934 dump_dynamic_symtab
= true;
2942 disassemble_zeroes
= true;
2946 disassemble_all
= true;
2951 with_source_code
= true;
2959 dump_stab_section_info
= true;
2963 dump_section_contents
= true;
2967 dump_reloc_info
= true;
2971 dump_dynamic_reloc_info
= true;
2975 dump_ar_hdrs
= true;
2979 dump_section_headers
= true;
2986 show_version
= true;
2996 print_version ("objdump");
2998 if (seenflag
== false)
3006 display_file ("a.out", target
);
3008 for (; optind
< argc
;)
3009 display_file (argv
[optind
++], target
);
3012 END_PROGRESS (program_name
);