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 if (start_address
== (bfd_vma
) -1
1740 || start_address
< disasm_info
.buffer_vma
)
1743 addr_offset
= start_address
- disasm_info
.buffer_vma
;
1744 if (stop_address
== (bfd_vma
) -1)
1745 stop_offset
= datasize
/ opb
;
1748 if (stop_address
< disasm_info
.buffer_vma
)
1751 stop_offset
= stop_address
- disasm_info
.buffer_vma
;
1752 if (stop_offset
> disasm_info
.buffer_length
/ opb
)
1753 stop_offset
= disasm_info
.buffer_length
/ opb
;
1756 sym
= find_symbol_for_address (abfd
, section
, section
->vma
+ addr_offset
,
1759 while (addr_offset
< stop_offset
)
1762 unsigned long nextstop_offset
;
1765 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= section
->vma
+ addr_offset
)
1770 (x
< sorted_symcount
1771 && bfd_asymbol_value (sorted_syms
[x
]) <= section
->vma
+ addr_offset
);
1774 disasm_info
.symbols
= & sorted_syms
[place
];
1775 disasm_info
.num_symbols
= x
- place
;
1778 disasm_info
.symbols
= NULL
;
1780 if (! prefix_addresses
)
1783 objdump_print_addr_with_sym (abfd
, section
, sym
,
1784 section
->vma
+ addr_offset
,
1790 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
)
1792 else if (sym
== NULL
)
1796 /* Search forward for the next appropriate symbol in
1797 SECTION. Note that all the symbols are sorted
1798 together into one big array, and that some sections
1799 may have overlapping addresses. */
1800 while (place
< sorted_symcount
1801 && (sorted_syms
[place
]->section
!= section
1802 || (bfd_asymbol_value (sorted_syms
[place
])
1803 <= bfd_asymbol_value (sym
))))
1805 if (place
>= sorted_symcount
)
1808 nextsym
= sorted_syms
[place
];
1811 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
)
1813 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1814 if (nextstop_offset
> stop_offset
)
1815 nextstop_offset
= stop_offset
;
1817 else if (nextsym
== NULL
)
1818 nextstop_offset
= stop_offset
;
1821 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1822 if (nextstop_offset
> stop_offset
)
1823 nextstop_offset
= stop_offset
;
1826 /* If a symbol is explicitly marked as being an object
1827 rather than a function, just dump the bytes without
1828 disassembling them. */
1831 || bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
1832 || ((sym
->flags
& BSF_OBJECT
) == 0
1833 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1835 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1837 || (sym
->flags
& BSF_FUNCTION
) != 0)
1842 disassemble_bytes (&disasm_info
, disassemble_fn
, insns
, data
,
1843 addr_offset
, nextstop_offset
, &relpp
, relppend
);
1845 addr_offset
= nextstop_offset
;
1857 /* Define a table of stab values and print-strings. We wish the initializer
1858 could be a direct-mapped table, but instead we build one the first
1861 static void dump_section_stabs
PARAMS ((bfd
*abfd
, char *stabsect_name
,
1862 char *strsect_name
));
1864 /* Dump the stabs sections from an object file that has a section that
1865 uses Sun stabs encoding. */
1871 dump_section_stabs (abfd
, ".stab", ".stabstr");
1872 dump_section_stabs (abfd
, ".stab.excl", ".stab.exclstr");
1873 dump_section_stabs (abfd
, ".stab.index", ".stab.indexstr");
1874 dump_section_stabs (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1877 static bfd_byte
*stabs
;
1878 static bfd_size_type stab_size
;
1880 static char *strtab
;
1881 static bfd_size_type stabstr_size
;
1883 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1884 and string table section STRSECT_NAME into `strtab'.
1885 If the section exists and was read, allocate the space and return true.
1886 Otherwise return false. */
1889 read_section_stabs (abfd
, stabsect_name
, strsect_name
)
1891 const char *stabsect_name
;
1892 const char *strsect_name
;
1894 asection
*stabsect
, *stabstrsect
;
1896 stabsect
= bfd_get_section_by_name (abfd
, stabsect_name
);
1899 printf (_("No %s section present\n\n"), stabsect_name
);
1903 stabstrsect
= bfd_get_section_by_name (abfd
, strsect_name
);
1904 if (0 == stabstrsect
)
1906 non_fatal (_("%s has no %s section"),
1907 bfd_get_filename (abfd
), strsect_name
);
1912 stab_size
= bfd_section_size (abfd
, stabsect
);
1913 stabstr_size
= bfd_section_size (abfd
, stabstrsect
);
1915 stabs
= (bfd_byte
*) xmalloc (stab_size
);
1916 strtab
= (char *) xmalloc (stabstr_size
);
1918 if (! bfd_get_section_contents (abfd
, stabsect
, (PTR
) stabs
, 0, stab_size
))
1920 non_fatal (_("Reading %s section of %s failed: %s"),
1921 stabsect_name
, bfd_get_filename (abfd
),
1922 bfd_errmsg (bfd_get_error ()));
1929 if (! bfd_get_section_contents (abfd
, stabstrsect
, (PTR
) strtab
, 0,
1932 non_fatal (_("Reading %s section of %s failed: %s\n"),
1933 strsect_name
, bfd_get_filename (abfd
),
1934 bfd_errmsg (bfd_get_error ()));
1944 /* Stabs entries use a 12 byte format:
1945 4 byte string table index
1947 1 byte stab other field
1948 2 byte stab desc field
1950 FIXME: This will have to change for a 64 bit object format. */
1952 #define STRDXOFF (0)
1954 #define OTHEROFF (5)
1957 #define STABSIZE (12)
1959 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1960 using string table section STRSECT_NAME (in `strtab'). */
1963 print_section_stabs (abfd
, stabsect_name
, strsect_name
)
1965 const char *stabsect_name
;
1966 const char *strsect_name ATTRIBUTE_UNUSED
;
1969 unsigned file_string_table_offset
= 0, next_file_string_table_offset
= 0;
1970 bfd_byte
*stabp
, *stabs_end
;
1973 stabs_end
= stabp
+ stab_size
;
1975 printf (_("Contents of %s section:\n\n"), stabsect_name
);
1976 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1978 /* Loop through all symbols and print them.
1980 We start the index at -1 because there is a dummy symbol on
1981 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1983 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
1987 unsigned char type
, other
;
1988 unsigned short desc
;
1991 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
1992 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
1993 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
1994 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
1995 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
1997 printf ("\n%-6d ", i
);
1998 /* Either print the stab name, or, if unnamed, print its number
1999 again (makes consistent formatting for tools like awk). */
2000 name
= bfd_get_stab_name (type
);
2002 printf ("%-6s", name
);
2003 else if (type
== N_UNDF
)
2006 printf ("%-6d", type
);
2007 printf (" %-6d %-6d ", other
, desc
);
2009 printf (" %-6lu", strx
);
2011 /* Symbols with type == 0 (N_UNDF) specify the length of the
2012 string table associated with this file. We use that info
2013 to know how to relocate the *next* file's string table indices. */
2017 file_string_table_offset
= next_file_string_table_offset
;
2018 next_file_string_table_offset
+= value
;
2022 /* Using the (possibly updated) string table offset, print the
2023 string (if any) associated with this symbol. */
2025 if ((strx
+ file_string_table_offset
) < stabstr_size
)
2026 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
2035 dump_section_stabs (abfd
, stabsect_name
, strsect_name
)
2037 char *stabsect_name
;
2042 /* Check for section names for which stabsect_name is a prefix, to
2043 handle .stab0, etc. */
2044 for (s
= abfd
->sections
;
2050 len
= strlen (stabsect_name
);
2052 /* If the prefix matches, and the files section name ends with a
2053 nul or a digit, then we match. I.e., we want either an exact
2054 match or a section followed by a number. */
2055 if (strncmp (stabsect_name
, s
->name
, len
) == 0
2056 && (s
->name
[len
] == '\000'
2057 || isdigit ((unsigned char) s
->name
[len
])))
2059 if (read_section_stabs (abfd
, s
->name
, strsect_name
))
2061 print_section_stabs (abfd
, s
->name
, strsect_name
);
2070 dump_bfd_header (abfd
)
2075 printf (_("architecture: %s, "),
2076 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2077 bfd_get_mach (abfd
)));
2078 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2080 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2081 PF (HAS_RELOC
, "HAS_RELOC");
2082 PF (EXEC_P
, "EXEC_P");
2083 PF (HAS_LINENO
, "HAS_LINENO");
2084 PF (HAS_DEBUG
, "HAS_DEBUG");
2085 PF (HAS_SYMS
, "HAS_SYMS");
2086 PF (HAS_LOCALS
, "HAS_LOCALS");
2087 PF (DYNAMIC
, "DYNAMIC");
2088 PF (WP_TEXT
, "WP_TEXT");
2089 PF (D_PAGED
, "D_PAGED");
2090 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2091 printf (_("\nstart address 0x"));
2092 printf_vma (abfd
->start_address
);
2097 dump_bfd_private_header (abfd
)
2100 bfd_print_private_bfd_data (abfd
, stdout
);
2103 /* Dump selected contents of ABFD */
2109 /* If we are adjusting section VMA's, change them all now. Changing
2110 the BFD information is a hack. However, we must do it, or
2111 bfd_find_nearest_line will not do the right thing. */
2112 if (adjust_section_vma
!= 0)
2116 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2118 s
->vma
+= adjust_section_vma
;
2119 s
->lma
+= adjust_section_vma
;
2123 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2126 print_arelt_descr (stdout
, abfd
, true);
2127 if (dump_file_header
)
2128 dump_bfd_header (abfd
);
2129 if (dump_private_headers
)
2130 dump_bfd_private_header (abfd
);
2132 if (dump_section_headers
)
2133 dump_headers (abfd
);
2134 if (dump_symtab
|| dump_reloc_info
|| disassemble
|| dump_debugging
)
2136 syms
= slurp_symtab (abfd
);
2138 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
)
2140 dynsyms
= slurp_dynamic_symtab (abfd
);
2143 dump_symbols (abfd
, false);
2144 if (dump_dynamic_symtab
)
2145 dump_symbols (abfd
, true);
2146 if (dump_stab_section_info
)
2148 if (dump_reloc_info
&& ! disassemble
)
2150 if (dump_dynamic_reloc_info
)
2151 dump_dynamic_relocs (abfd
);
2152 if (dump_section_contents
)
2155 disassemble_data (abfd
);
2160 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2161 if (dhandle
!= NULL
)
2163 if (! print_debugging_info (stdout
, dhandle
))
2165 non_fatal (_("%s: printing debugging information failed"),
2166 bfd_get_filename (abfd
));
2189 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2195 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2197 nonfatal (bfd_get_filename (abfd
));
2198 list_matching_formats (matching
);
2203 if (bfd_get_error () != bfd_error_file_not_recognized
)
2205 nonfatal (bfd_get_filename (abfd
));
2209 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
2215 nonfatal (bfd_get_filename (abfd
));
2217 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2219 list_matching_formats (matching
);
2225 display_file (filename
, target
)
2229 bfd
*file
, *arfile
= (bfd
*) NULL
;
2231 file
= bfd_openr (filename
, target
);
2234 nonfatal (filename
);
2238 if (bfd_check_format (file
, bfd_archive
) == true)
2240 bfd
*last_arfile
= NULL
;
2242 printf (_("In archive %s:\n"), bfd_get_filename (file
));
2245 bfd_set_error (bfd_error_no_error
);
2247 arfile
= bfd_openr_next_archived_file (file
, arfile
);
2250 if (bfd_get_error () != bfd_error_no_more_archived_files
)
2251 nonfatal (bfd_get_filename (file
));
2255 display_bfd (arfile
);
2257 if (last_arfile
!= NULL
)
2258 bfd_close (last_arfile
);
2259 last_arfile
= arfile
;
2262 if (last_arfile
!= NULL
)
2263 bfd_close (last_arfile
);
2271 /* Actually display the various requested regions */
2279 bfd_size_type datasize
= 0;
2280 bfd_size_type addr_offset
;
2281 bfd_size_type start_offset
, stop_offset
;
2282 unsigned int opb
= bfd_octets_per_byte (abfd
);
2284 for (section
= abfd
->sections
; section
!= NULL
; section
=
2289 if (only
== (char *) NULL
||
2290 strcmp (only
, section
->name
) == 0)
2292 if (section
->flags
& SEC_HAS_CONTENTS
)
2294 printf (_("Contents of section %s:\n"), section
->name
);
2296 if (bfd_section_size (abfd
, section
) == 0)
2298 data
= (bfd_byte
*) xmalloc ((size_t) bfd_section_size (abfd
, section
));
2299 datasize
= bfd_section_size (abfd
, section
);
2302 bfd_get_section_contents (abfd
, section
, (PTR
) data
, 0, bfd_section_size (abfd
, section
));
2304 if (start_address
== (bfd_vma
) -1
2305 || start_address
< section
->vma
)
2308 start_offset
= start_address
- section
->vma
;
2309 if (stop_address
== (bfd_vma
) -1)
2310 stop_offset
= bfd_section_size (abfd
, section
) / opb
;
2313 if (stop_address
< section
->vma
)
2316 stop_offset
= stop_address
- section
->vma
;
2317 if (stop_offset
> bfd_section_size (abfd
, section
) / opb
)
2318 stop_offset
= bfd_section_size (abfd
, section
) / opb
;
2320 for (addr_offset
= start_offset
;
2321 addr_offset
< stop_offset
; addr_offset
+= onaline
)
2325 printf (" %04lx ", (unsigned long int)
2326 (addr_offset
+ section
->vma
));
2327 for (j
= addr_offset
* opb
;
2328 j
< addr_offset
* opb
+ onaline
; j
++)
2330 if (j
< stop_offset
* opb
)
2331 printf ("%02x", (unsigned) (data
[j
]));
2339 for (j
= addr_offset
; j
< addr_offset
* opb
+ onaline
; j
++)
2341 if (j
>= stop_offset
* opb
)
2344 printf ("%c", isprint (data
[j
]) ? data
[j
] : '.');
2354 /* Should perhaps share code and display with nm? */
2356 dump_symbols (abfd
, dynamic
)
2357 bfd
*abfd ATTRIBUTE_UNUSED
;
2370 printf ("DYNAMIC SYMBOL TABLE:\n");
2378 printf ("SYMBOL TABLE:\n");
2381 for (count
= 0; count
< max
; count
++)
2385 bfd
*cur_bfd
= bfd_asymbol_bfd (*current
);
2387 if (cur_bfd
!= NULL
)
2392 name
= bfd_asymbol_name (*current
);
2394 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2398 /* If we want to demangle the name, we demangle it
2399 here, and temporarily clobber it while calling
2400 bfd_print_symbol. FIXME: This is a gross hack. */
2403 if (bfd_get_symbol_leading_char (cur_bfd
) == *n
)
2405 alloc
= cplus_demangle (n
, DMGL_ANSI
| DMGL_PARAMS
);
2407 (*current
)->name
= alloc
;
2409 (*current
)->name
= n
;
2412 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2413 bfd_print_symbol_all
);
2415 (*current
)->name
= name
;
2436 for (a
= abfd
->sections
; a
!= (asection
*) NULL
; a
= a
->next
)
2440 if (bfd_is_abs_section (a
))
2442 if (bfd_is_und_section (a
))
2444 if (bfd_is_com_section (a
))
2449 if (strcmp (only
, a
->name
))
2452 else if ((a
->flags
& SEC_RELOC
) == 0)
2455 relsize
= bfd_get_reloc_upper_bound (abfd
, a
);
2457 bfd_fatal (bfd_get_filename (abfd
));
2459 printf ("RELOCATION RECORDS FOR [%s]:", a
->name
);
2463 printf (" (none)\n\n");
2467 relpp
= (arelent
**) xmalloc (relsize
);
2468 relcount
= bfd_canonicalize_reloc (abfd
, a
, relpp
, syms
);
2470 bfd_fatal (bfd_get_filename (abfd
));
2471 else if (relcount
== 0)
2473 printf (" (none)\n\n");
2478 dump_reloc_set (abfd
, a
, relpp
, relcount
);
2487 dump_dynamic_relocs (abfd
)
2494 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2496 bfd_fatal (bfd_get_filename (abfd
));
2498 printf ("DYNAMIC RELOCATION RECORDS");
2502 printf (" (none)\n\n");
2506 relpp
= (arelent
**) xmalloc (relsize
);
2507 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2509 bfd_fatal (bfd_get_filename (abfd
));
2510 else if (relcount
== 0)
2512 printf (" (none)\n\n");
2517 dump_reloc_set (abfd
, (asection
*) NULL
, relpp
, relcount
);
2525 dump_reloc_set (abfd
, sec
, relpp
, relcount
)
2532 char *last_filename
, *last_functionname
;
2533 unsigned int last_line
;
2535 /* Get column headers lined up reasonably. */
2541 sprintf_vma (buf
, (bfd_vma
) -1);
2542 width
= strlen (buf
) - 7;
2544 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2547 last_filename
= NULL
;
2548 last_functionname
= NULL
;
2551 for (p
= relpp
; relcount
&& *p
!= (arelent
*) NULL
; p
++, relcount
--)
2554 const char *filename
, *functionname
;
2556 const char *sym_name
;
2557 const char *section_name
;
2559 if (start_address
!= (bfd_vma
) -1
2560 && q
->address
< start_address
)
2562 if (stop_address
!= (bfd_vma
) -1
2563 && q
->address
> stop_address
)
2566 if (with_line_numbers
2568 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2569 &filename
, &functionname
, &line
))
2571 if (functionname
!= NULL
2572 && (last_functionname
== NULL
2573 || strcmp (functionname
, last_functionname
) != 0))
2575 printf ("%s():\n", functionname
);
2576 if (last_functionname
!= NULL
)
2577 free (last_functionname
);
2578 last_functionname
= xstrdup (functionname
);
2581 && (line
!= last_line
2582 || (filename
!= NULL
2583 && last_filename
!= NULL
2584 && strcmp (filename
, last_filename
) != 0)))
2586 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2588 if (last_filename
!= NULL
)
2589 free (last_filename
);
2590 if (filename
== NULL
)
2591 last_filename
= NULL
;
2593 last_filename
= xstrdup (filename
);
2597 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2599 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2600 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2605 section_name
= NULL
;
2609 printf_vma (q
->address
);
2611 printf (" %-16s ", q
->howto
->name
);
2613 printf (" %-16d ", q
->howto
->type
);
2614 objdump_print_symname (abfd
, (struct disassemble_info
*) NULL
,
2619 if (section_name
== (CONST
char *) NULL
)
2620 section_name
= "*unknown*";
2621 printf_vma (q
->address
);
2622 printf (" %-16s [%s]",
2629 printf_vma (q
->addend
);
2635 /* The length of the longest architecture name + 1. */
2636 #define LONGEST_ARCH sizeof("powerpc:common")
2639 endian_string (endian
)
2640 enum bfd_endian endian
;
2642 if (endian
== BFD_ENDIAN_BIG
)
2643 return "big endian";
2644 else if (endian
== BFD_ENDIAN_LITTLE
)
2645 return "little endian";
2647 return "endianness unknown";
2650 /* List the targets that BFD is configured to support, each followed
2651 by its endianness and the architectures it supports. */
2654 display_target_list ()
2656 extern const bfd_target
*const *bfd_target_vector
;
2660 dummy_name
= make_temp_file (NULL
);
2661 for (t
= 0; bfd_target_vector
[t
]; t
++)
2663 const bfd_target
*p
= bfd_target_vector
[t
];
2664 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2667 printf ("%s\n (header %s, data %s)\n", p
->name
,
2668 endian_string (p
->header_byteorder
),
2669 endian_string (p
->byteorder
));
2673 nonfatal (dummy_name
);
2677 if (! bfd_set_format (abfd
, bfd_object
))
2679 if (bfd_get_error () != bfd_error_invalid_operation
)
2681 bfd_close_all_done (abfd
);
2685 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2686 if (bfd_set_arch_mach (abfd
, (enum bfd_architecture
) a
, 0))
2688 bfd_printable_arch_mach ((enum bfd_architecture
) a
, 0));
2689 bfd_close_all_done (abfd
);
2691 unlink (dummy_name
);
2695 /* Print a table showing which architectures are supported for entries
2696 FIRST through LAST-1 of bfd_target_vector (targets across,
2697 architectures down). */
2700 display_info_table (first
, last
)
2704 extern const bfd_target
*const *bfd_target_vector
;
2708 /* Print heading of target names. */
2709 printf ("\n%*s", (int) LONGEST_ARCH
, " ");
2710 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2711 printf ("%s ", bfd_target_vector
[t
]->name
);
2714 dummy_name
= make_temp_file (NULL
);
2715 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2716 if (strcmp (bfd_printable_arch_mach (a
, 0), "UNKNOWN!") != 0)
2718 printf ("%*s ", (int) LONGEST_ARCH
- 1,
2719 bfd_printable_arch_mach (a
, 0));
2720 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2722 const bfd_target
*p
= bfd_target_vector
[t
];
2724 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2734 if (! bfd_set_format (abfd
, bfd_object
))
2736 if (bfd_get_error () != bfd_error_invalid_operation
)
2744 if (! bfd_set_arch_mach (abfd
, a
, 0))
2749 printf ("%s ", p
->name
);
2752 int l
= strlen (p
->name
);
2758 bfd_close_all_done (abfd
);
2762 unlink (dummy_name
);
2766 /* Print tables of all the target-architecture combinations that
2767 BFD has been configured to support. */
2770 display_target_tables ()
2773 extern const bfd_target
*const *bfd_target_vector
;
2777 colum
= getenv ("COLUMNS");
2779 columns
= atoi (colum
);
2784 while (bfd_target_vector
[t
] != NULL
)
2788 wid
= LONGEST_ARCH
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2790 while (wid
< columns
&& bfd_target_vector
[t
] != NULL
)
2794 newwid
= wid
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2795 if (newwid
>= columns
)
2800 display_info_table (oldt
, t
);
2807 printf (_("BFD header file version %s\n"), BFD_VERSION
);
2808 display_target_list ();
2809 display_target_tables ();
2818 char *target
= default_target
;
2819 boolean seenflag
= false;
2821 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
2822 setlocale (LC_MESSAGES
, "");
2824 bindtextdomain (PACKAGE
, LOCALEDIR
);
2825 textdomain (PACKAGE
);
2827 program_name
= *argv
;
2828 xmalloc_set_program_name (program_name
);
2830 START_PROGRESS (program_name
, 0);
2833 set_default_bfd_target ();
2835 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VCdDlfahHrRtTxsSj:wE:zgG",
2836 long_options
, (int *) 0))
2842 break; /* we've been given a long option */
2847 disassembler_options
= optarg
;
2853 with_line_numbers
= true;
2862 enum demangling_styles style
;
2864 style
= cplus_demangle_name_to_style (optarg
);
2865 if (style
== unknown_demangling
)
2866 fatal (_("unknown demangling style `%s'"),
2869 cplus_demangle_set_style (style
);
2875 case OPTION_ADJUST_VMA
:
2876 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
2878 case OPTION_START_ADDRESS
:
2879 start_address
= parse_vma (optarg
, "--start-address");
2881 case OPTION_STOP_ADDRESS
:
2882 stop_address
= parse_vma (optarg
, "--stop-address");
2885 if (strcmp (optarg
, "B") == 0)
2886 endian
= BFD_ENDIAN_BIG
;
2887 else if (strcmp (optarg
, "L") == 0)
2888 endian
= BFD_ENDIAN_LITTLE
;
2891 non_fatal (_("unrecognized -E option"));
2896 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
2897 endian
= BFD_ENDIAN_BIG
;
2898 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
2899 endian
= BFD_ENDIAN_LITTLE
;
2902 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
2908 dump_file_header
= true;
2912 formats_info
= true;
2916 dump_private_headers
= true;
2920 dump_private_headers
= true;
2922 dump_reloc_info
= true;
2923 dump_file_header
= true;
2924 dump_ar_hdrs
= true;
2925 dump_section_headers
= true;
2933 dump_dynamic_symtab
= true;
2941 disassemble_zeroes
= true;
2945 disassemble_all
= true;
2950 with_source_code
= true;
2958 dump_stab_section_info
= true;
2962 dump_section_contents
= true;
2966 dump_reloc_info
= true;
2970 dump_dynamic_reloc_info
= true;
2974 dump_ar_hdrs
= true;
2978 dump_section_headers
= true;
2985 show_version
= true;
2995 print_version ("objdump");
2997 if (seenflag
== false)
3005 display_file ("a.out", target
);
3007 for (; optind
< argc
;)
3008 display_file (argv
[optind
++], target
);
3011 END_PROGRESS (program_name
);