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
);
272 disassembler_usage (stream
);
275 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
279 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
281 #define OPTION_ENDIAN (150)
282 #define OPTION_START_ADDRESS (OPTION_ENDIAN + 1)
283 #define OPTION_STOP_ADDRESS (OPTION_START_ADDRESS + 1)
284 #define OPTION_ADJUST_VMA (OPTION_STOP_ADDRESS + 1)
286 static struct option long_options
[]=
288 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
289 {"all-headers", no_argument
, NULL
, 'x'},
290 {"private-headers", no_argument
, NULL
, 'p'},
291 {"architecture", required_argument
, NULL
, 'm'},
292 {"archive-headers", no_argument
, NULL
, 'a'},
293 {"debugging", no_argument
, NULL
, 'g'},
294 {"demangle", optional_argument
, NULL
, 'C'},
295 {"disassemble", no_argument
, NULL
, 'd'},
296 {"disassemble-all", no_argument
, NULL
, 'D'},
297 {"disassembler-options", required_argument
, NULL
, 'M'},
298 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
299 {"dynamic-reloc", no_argument
, NULL
, 'R'},
300 {"dynamic-syms", no_argument
, NULL
, 'T'},
301 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
302 {"file-headers", no_argument
, NULL
, 'f'},
303 {"file-start-context", no_argument
, &file_start_context
, 1},
304 {"full-contents", no_argument
, NULL
, 's'},
305 {"headers", no_argument
, NULL
, 'h'},
306 {"help", no_argument
, NULL
, 'H'},
307 {"info", no_argument
, NULL
, 'i'},
308 {"line-numbers", no_argument
, NULL
, 'l'},
309 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
310 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
311 {"reloc", no_argument
, NULL
, 'r'},
312 {"section", required_argument
, NULL
, 'j'},
313 {"section-headers", no_argument
, NULL
, 'h'},
314 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
315 {"source", no_argument
, NULL
, 'S'},
316 {"stabs", no_argument
, NULL
, 'G'},
317 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
318 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
319 {"syms", no_argument
, NULL
, 't'},
320 {"target", required_argument
, NULL
, 'b'},
321 {"version", no_argument
, NULL
, 'V'},
322 {"wide", no_argument
, NULL
, 'w'},
323 {0, no_argument
, 0, 0}
335 dump_section_header (abfd
, section
, ignored
)
336 bfd
*abfd ATTRIBUTE_UNUSED
;
338 PTR ignored ATTRIBUTE_UNUSED
;
341 unsigned int opb
= bfd_octets_per_byte (abfd
);
343 printf ("%3d %-13s %08lx ", section
->index
,
344 bfd_get_section_name (abfd
, section
),
345 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
346 printf_vma (bfd_get_section_vma (abfd
, section
));
348 printf_vma (section
->lma
);
349 printf (" %08lx 2**%u", section
->filepos
,
350 bfd_get_section_alignment (abfd
, section
));
356 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
358 PF (SEC_HAS_CONTENTS
, "CONTENTS");
359 PF (SEC_ALLOC
, "ALLOC");
360 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
361 PF (SEC_CONSTRUCTOR_TEXT
, "CONSTRUCTOR TEXT");
362 PF (SEC_CONSTRUCTOR_DATA
, "CONSTRUCTOR DATA");
363 PF (SEC_CONSTRUCTOR_BSS
, "CONSTRUCTOR BSS");
364 PF (SEC_LOAD
, "LOAD");
365 PF (SEC_RELOC
, "RELOC");
367 PF (SEC_BALIGN
, "BALIGN");
369 PF (SEC_READONLY
, "READONLY");
370 PF (SEC_CODE
, "CODE");
371 PF (SEC_DATA
, "DATA");
373 PF (SEC_DEBUGGING
, "DEBUGGING");
374 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
375 PF (SEC_EXCLUDE
, "EXCLUDE");
376 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
377 PF (SEC_BLOCK
, "BLOCK");
378 PF (SEC_CLINK
, "CLINK");
379 PF (SEC_SMALL_DATA
, "SMALL_DATA");
380 PF (SEC_SHARED
, "SHARED");
382 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
386 switch (section
->flags
& SEC_LINK_DUPLICATES
)
390 case SEC_LINK_DUPLICATES_DISCARD
:
391 ls
= "LINK_ONCE_DISCARD";
393 case SEC_LINK_DUPLICATES_ONE_ONLY
:
394 ls
= "LINK_ONCE_ONE_ONLY";
396 case SEC_LINK_DUPLICATES_SAME_SIZE
:
397 ls
= "LINK_ONCE_SAME_SIZE";
399 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
400 ls
= "LINK_ONCE_SAME_CONTENTS";
403 printf ("%s%s", comma
, ls
);
405 if (section
->comdat
!= NULL
)
406 printf (" (COMDAT %s %ld)", section
->comdat
->name
,
407 section
->comdat
->symbol
);
420 printf (_("Sections:\n"));
423 printf (_("Idx Name Size VMA LMA File off Algn"));
425 printf (_("Idx Name Size VMA LMA File off Algn"));
429 printf (_(" Flags"));
432 bfd_map_over_sections (abfd
, dump_section_header
, (PTR
) NULL
);
439 asymbol
**sy
= (asymbol
**) NULL
;
442 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
444 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
449 storage
= bfd_get_symtab_upper_bound (abfd
);
451 bfd_fatal (bfd_get_filename (abfd
));
455 sy
= (asymbol
**) xmalloc (storage
);
457 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
459 bfd_fatal (bfd_get_filename (abfd
));
461 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
465 /* Read in the dynamic symbols. */
468 slurp_dynamic_symtab (abfd
)
471 asymbol
**sy
= (asymbol
**) NULL
;
474 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
477 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
479 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
484 bfd_fatal (bfd_get_filename (abfd
));
489 sy
= (asymbol
**) xmalloc (storage
);
491 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
493 bfd_fatal (bfd_get_filename (abfd
));
494 if (dynsymcount
== 0)
495 non_fatal (_("%s: No dynamic symbols"), bfd_get_filename (abfd
));
499 /* Filter out (in place) symbols that are useless for disassembly.
500 COUNT is the number of elements in SYMBOLS.
501 Return the number of useful symbols. */
504 remove_useless_symbols (symbols
, count
)
508 register asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
512 asymbol
*sym
= *in_ptr
++;
514 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
516 if (sym
->flags
& (BSF_DEBUGGING
))
518 if (bfd_is_und_section (sym
->section
)
519 || bfd_is_com_section (sym
->section
))
524 return out_ptr
- symbols
;
527 /* Sort symbols into value order. */
530 compare_symbols (ap
, bp
)
534 const asymbol
*a
= *(const asymbol
**)ap
;
535 const asymbol
*b
= *(const asymbol
**)bp
;
539 flagword aflags
, bflags
;
541 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
543 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
546 if (a
->section
> b
->section
)
548 else if (a
->section
< b
->section
)
551 an
= bfd_asymbol_name (a
);
552 bn
= bfd_asymbol_name (b
);
556 /* The symbols gnu_compiled and gcc2_compiled convey no real
557 information, so put them after other symbols with the same value. */
559 af
= (strstr (an
, "gnu_compiled") != NULL
560 || strstr (an
, "gcc2_compiled") != NULL
);
561 bf
= (strstr (bn
, "gnu_compiled") != NULL
562 || strstr (bn
, "gcc2_compiled") != NULL
);
569 /* We use a heuristic for the file name, to try to sort it after
570 more useful symbols. It may not work on non Unix systems, but it
571 doesn't really matter; the only difference is precisely which
572 symbol names get printed. */
574 #define file_symbol(s, sn, snl) \
575 (((s)->flags & BSF_FILE) != 0 \
576 || ((sn)[(snl) - 2] == '.' \
577 && ((sn)[(snl) - 1] == 'o' \
578 || (sn)[(snl) - 1] == 'a')))
580 af
= file_symbol (a
, an
, anl
);
581 bf
= file_symbol (b
, bn
, bnl
);
588 /* Try to sort global symbols before local symbols before function
589 symbols before debugging symbols. */
594 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
596 if ((aflags
& BSF_DEBUGGING
) != 0)
601 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
603 if ((aflags
& BSF_FUNCTION
) != 0)
608 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
610 if ((aflags
& BSF_LOCAL
) != 0)
615 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
617 if ((aflags
& BSF_GLOBAL
) != 0)
623 /* Symbols that start with '.' might be section names, so sort them
624 after symbols that don't start with '.'. */
625 if (an
[0] == '.' && bn
[0] != '.')
627 if (an
[0] != '.' && bn
[0] == '.')
630 /* Finally, if we can't distinguish them in any other way, try to
631 get consistent results by sorting the symbols by name. */
632 return strcmp (an
, bn
);
635 /* Sort relocs into address order. */
638 compare_relocs (ap
, bp
)
642 const arelent
*a
= *(const arelent
**)ap
;
643 const arelent
*b
= *(const arelent
**)bp
;
645 if (a
->address
> b
->address
)
647 else if (a
->address
< b
->address
)
650 /* So that associated relocations tied to the same address show up
651 in the correct order, we don't do any further sorting. */
660 /* Print VMA to STREAM. If SKIP_ZEROES is true, omit leading zeroes. */
663 objdump_print_value (vma
, info
, skip_zeroes
)
665 struct disassemble_info
*info
;
671 sprintf_vma (buf
, vma
);
676 for (p
= buf
; *p
== '0'; ++p
)
681 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
684 /* Print the name of a symbol. */
687 objdump_print_symname (abfd
, info
, sym
)
689 struct disassemble_info
*info
;
697 name
= bfd_asymbol_name (sym
);
698 if (! do_demangle
|| name
[0] == '\0')
702 /* Demangle the name. */
703 if (bfd_get_symbol_leading_char (abfd
) == name
[0])
706 alloc
= cplus_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
714 (*info
->fprintf_func
) (info
->stream
, "%s", print
);
716 printf ("%s", print
);
722 /* Locate a symbol given a bfd, a section, and a VMA. If REQUIRE_SEC
723 is true, then always require the symbol to be in the section. This
724 returns NULL if there is no suitable symbol. If PLACE is not NULL,
725 then *PLACE is set to the index of the symbol in sorted_syms. */
728 find_symbol_for_address (abfd
, sec
, vma
, require_sec
, place
)
735 /* @@ Would it speed things up to cache the last two symbols returned,
736 and maybe their address ranges? For many processors, only one memory
737 operand can be present at a time, so the 2-entry cache wouldn't be
738 constantly churned by code doing heavy memory accesses. */
740 /* Indices in `sorted_syms'. */
742 long max
= sorted_symcount
;
744 unsigned int opb
= bfd_octets_per_byte (abfd
);
746 if (sorted_symcount
< 1)
749 /* Perform a binary search looking for the closest symbol to the
750 required value. We are searching the range (min, max]. */
751 while (min
+ 1 < max
)
755 thisplace
= (max
+ min
) / 2;
756 sym
= sorted_syms
[thisplace
];
758 if (bfd_asymbol_value (sym
) > vma
)
760 else if (bfd_asymbol_value (sym
) < vma
)
769 /* The symbol we want is now in min, the low end of the range we
770 were searching. If there are several symbols with the same
771 value, we want the first one. */
774 && (bfd_asymbol_value (sorted_syms
[thisplace
])
775 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
778 /* If the file is relocateable, and the symbol could be from this
779 section, prefer a symbol from this section over symbols from
780 others, even if the other symbol's value might be closer.
782 Note that this may be wrong for some symbol references if the
783 sections have overlapping memory ranges, but in that case there's
784 no way to tell what's desired without looking at the relocation
787 if (sorted_syms
[thisplace
]->section
!= sec
789 || ((abfd
->flags
& HAS_RELOC
) != 0
790 && vma
>= bfd_get_section_vma (abfd
, sec
)
791 && vma
< (bfd_get_section_vma (abfd
, sec
)
792 + bfd_section_size (abfd
, sec
) / opb
))))
796 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
798 if (bfd_asymbol_value (sorted_syms
[i
])
799 != bfd_asymbol_value (sorted_syms
[thisplace
]))
805 if (sorted_syms
[i
]->section
== sec
807 || sorted_syms
[i
- 1]->section
!= sec
808 || (bfd_asymbol_value (sorted_syms
[i
])
809 != bfd_asymbol_value (sorted_syms
[i
- 1]))))
816 if (sorted_syms
[thisplace
]->section
!= sec
)
818 /* We didn't find a good symbol with a smaller value.
819 Look for one with a larger value. */
820 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
822 if (sorted_syms
[i
]->section
== sec
)
830 if (sorted_syms
[thisplace
]->section
!= sec
832 || ((abfd
->flags
& HAS_RELOC
) != 0
833 && vma
>= bfd_get_section_vma (abfd
, sec
)
834 && vma
< (bfd_get_section_vma (abfd
, sec
)
835 + bfd_section_size (abfd
, sec
)))))
837 /* There is no suitable symbol. */
845 return sorted_syms
[thisplace
];
848 /* Print an address to INFO symbolically. */
851 objdump_print_addr_with_sym (abfd
, sec
, sym
, vma
, info
, skip_zeroes
)
856 struct disassemble_info
*info
;
859 objdump_print_value (vma
, info
, skip_zeroes
);
865 (*info
->fprintf_func
) (info
->stream
, " <%s",
866 bfd_get_section_name (abfd
, sec
));
867 secaddr
= bfd_get_section_vma (abfd
, sec
);
870 (*info
->fprintf_func
) (info
->stream
, "-0x");
871 objdump_print_value (secaddr
- vma
, info
, true);
873 else if (vma
> secaddr
)
875 (*info
->fprintf_func
) (info
->stream
, "+0x");
876 objdump_print_value (vma
- secaddr
, info
, true);
878 (*info
->fprintf_func
) (info
->stream
, ">");
882 (*info
->fprintf_func
) (info
->stream
, " <");
883 objdump_print_symname (abfd
, info
, sym
);
884 if (bfd_asymbol_value (sym
) > vma
)
886 (*info
->fprintf_func
) (info
->stream
, "-0x");
887 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, true);
889 else if (vma
> bfd_asymbol_value (sym
))
891 (*info
->fprintf_func
) (info
->stream
, "+0x");
892 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, true);
894 (*info
->fprintf_func
) (info
->stream
, ">");
898 /* Print VMA to INFO, symbolically if possible. If SKIP_ZEROES is
899 true, don't output leading zeroes. */
902 objdump_print_addr (vma
, info
, skip_zeroes
)
904 struct disassemble_info
*info
;
907 struct objdump_disasm_info
*aux
;
910 if (sorted_symcount
< 1)
912 (*info
->fprintf_func
) (info
->stream
, "0x");
913 objdump_print_value (vma
, info
, skip_zeroes
);
917 aux
= (struct objdump_disasm_info
*) info
->application_data
;
918 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
920 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
924 /* Print VMA to INFO. This function is passed to the disassembler
928 objdump_print_address (vma
, info
)
930 struct disassemble_info
*info
;
932 objdump_print_addr (vma
, info
, ! prefix_addresses
);
935 /* Determine of the given address has a symbol associated with it. */
938 objdump_symbol_at_address (vma
, info
)
940 struct disassemble_info
* info
;
942 struct objdump_disasm_info
* aux
;
945 /* No symbols - do not bother checking. */
946 if (sorted_symcount
< 1)
949 aux
= (struct objdump_disasm_info
*) info
->application_data
;
950 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
953 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
956 /* Hold the last function name and the last line number we displayed
959 static char *prev_functionname
;
960 static unsigned int prev_line
;
962 /* We keep a list of all files that we have seen when doing a
963 dissassembly with source, so that we know how much of the file to
964 display. This can be important for inlined functions. */
966 struct print_file_list
968 struct print_file_list
*next
;
974 static struct print_file_list
*print_files
;
976 /* The number of preceding context lines to show when we start
977 displaying a file for the first time. */
979 #define SHOW_PRECEDING_CONTEXT_LINES (5)
981 /* Skip ahead to a given line in a file, optionally printing each
985 skip_to_line
PARAMS ((struct print_file_list
*, unsigned int, boolean
));
988 skip_to_line (p
, line
, show
)
989 struct print_file_list
*p
;
993 while (p
->line
< line
)
997 if (fgets (buf
, sizeof buf
, p
->f
) == NULL
)
1007 if (strchr (buf
, '\n') != NULL
)
1012 /* Show the line number, or the source line, in a dissassembly
1016 show_line (abfd
, section
, addr_offset
)
1019 bfd_vma addr_offset
;
1021 CONST
char *filename
;
1022 CONST
char *functionname
;
1025 if (! with_line_numbers
&& ! with_source_code
)
1028 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
1029 &functionname
, &line
))
1032 if (filename
!= NULL
&& *filename
== '\0')
1034 if (functionname
!= NULL
&& *functionname
== '\0')
1035 functionname
= NULL
;
1037 if (with_line_numbers
)
1039 if (functionname
!= NULL
1040 && (prev_functionname
== NULL
1041 || strcmp (functionname
, prev_functionname
) != 0))
1042 printf ("%s():\n", functionname
);
1043 if (line
> 0 && line
!= prev_line
)
1044 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
1047 if (with_source_code
1051 struct print_file_list
**pp
, *p
;
1053 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1054 if (strcmp ((*pp
)->filename
, filename
) == 0)
1060 if (p
!= print_files
)
1064 /* We have reencountered a file name which we saw
1065 earlier. This implies that either we are dumping out
1066 code from an included file, or the same file was
1067 linked in more than once. There are two common cases
1068 of an included file: inline functions in a header
1069 file, and a bison or flex skeleton file. In the
1070 former case we want to just start printing (but we
1071 back up a few lines to give context); in the latter
1072 case we want to continue from where we left off. I
1073 can't think of a good way to distinguish the cases,
1074 so I used a heuristic based on the file name. */
1075 if (strcmp (p
->filename
+ strlen (p
->filename
) - 2, ".h") != 0)
1079 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1086 p
->f
= fopen (p
->filename
, "r");
1090 skip_to_line (p
, l
, false);
1092 if (print_files
->f
!= NULL
)
1094 fclose (print_files
->f
);
1095 print_files
->f
= NULL
;
1101 skip_to_line (p
, line
, true);
1103 p
->next
= print_files
;
1111 f
= fopen (filename
, "r");
1116 p
= ((struct print_file_list
*)
1117 xmalloc (sizeof (struct print_file_list
)));
1118 p
->filename
= xmalloc (strlen (filename
) + 1);
1119 strcpy (p
->filename
, filename
);
1123 if (print_files
!= NULL
&& print_files
->f
!= NULL
)
1125 fclose (print_files
->f
);
1126 print_files
->f
= NULL
;
1128 p
->next
= print_files
;
1131 if (file_start_context
)
1134 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1137 skip_to_line (p
, l
, false);
1139 skip_to_line (p
, line
, true);
1144 if (functionname
!= NULL
1145 && (prev_functionname
== NULL
1146 || strcmp (functionname
, prev_functionname
) != 0))
1148 if (prev_functionname
!= NULL
)
1149 free (prev_functionname
);
1150 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1151 strcpy (prev_functionname
, functionname
);
1154 if (line
> 0 && line
!= prev_line
)
1158 /* Pseudo FILE object for strings. */
1166 /* sprintf to a "stream" */
1169 #ifdef ANSI_PROTOTYPES
1170 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1172 objdump_sprintf (va_alist
)
1176 #ifndef ANSI_PROTOTYPES
1184 #ifdef ANSI_PROTOTYPES
1185 va_start (args
, format
);
1188 f
= va_arg (args
, SFILE
*);
1189 format
= va_arg (args
, const char *);
1192 vasprintf (&buf
, format
, args
);
1198 fatal (_("Out of virtual memory"));
1203 while ((size_t) ((f
->buffer
+ f
->size
) - f
->current
) < n
+ 1)
1207 curroff
= f
->current
- f
->buffer
;
1209 f
->buffer
= xrealloc (f
->buffer
, f
->size
);
1210 f
->current
= f
->buffer
+ curroff
;
1213 memcpy (f
->current
, buf
, n
);
1215 f
->current
[0] = '\0';
1222 /* The number of zeroes we want to see before we start skipping them.
1223 The number is arbitrarily chosen. */
1225 #define SKIP_ZEROES (8)
1227 /* The number of zeroes to skip at the end of a section. If the
1228 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1229 SKIP_ZEROES, they will be disassembled. If there are fewer than
1230 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1231 attempt to avoid disassembling zeroes inserted by section
1234 #define SKIP_ZEROES_AT_END (3)
1236 /* Disassemble some data in memory between given values. */
1239 disassemble_bytes (info
, disassemble_fn
, insns
, data
,
1240 start_offset
, stop_offset
, relppp
,
1242 struct disassemble_info
*info
;
1243 disassembler_ftype disassemble_fn
;
1246 bfd_vma start_offset
;
1247 bfd_vma stop_offset
;
1251 struct objdump_disasm_info
*aux
;
1253 int octets_per_line
;
1255 int skip_addr_chars
;
1256 bfd_vma addr_offset
;
1257 int opb
= info
->octets_per_byte
;
1259 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1263 octets_per_line
= 4;
1265 octets_per_line
= 16;
1267 /* Figure out how many characters to skip at the start of an
1268 address, to make the disassembly look nicer. We discard leading
1269 zeroes in chunks of 4, ensuring that there is always a leading
1271 skip_addr_chars
= 0;
1272 if (! prefix_addresses
)
1277 sprintf_vma (buf
, section
->vma
+
1278 bfd_section_size (section
->owner
, section
) / opb
);
1280 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1283 skip_addr_chars
+= 4;
1288 info
->insn_info_valid
= 0;
1291 addr_offset
= start_offset
;
1292 while (addr_offset
< stop_offset
)
1296 boolean need_nl
= false;
1298 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1300 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1303 if (! disassemble_zeroes
1304 && (info
->insn_info_valid
== 0
1305 || info
->branch_delay_insns
== 0)
1306 && (z
- addr_offset
* opb
>= SKIP_ZEROES
1307 || (z
== stop_offset
* opb
&&
1308 z
- addr_offset
* opb
< SKIP_ZEROES_AT_END
)))
1312 /* If there are more nonzero octets to follow, we only skip
1313 zeroes in multiples of 4, to try to avoid running over
1314 the start of an instruction which happens to start with
1316 if (z
!= stop_offset
* opb
)
1317 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1319 octets
= z
- addr_offset
* opb
;
1330 if (with_line_numbers
|| with_source_code
)
1331 /* The line number tables will refer to unadjusted
1332 section VMAs, so we must undo any VMA modifications
1333 when calling show_line. */
1334 show_line (aux
->abfd
, section
, addr_offset
- adjust_section_vma
);
1336 if (! prefix_addresses
)
1340 sprintf_vma (buf
, section
->vma
+ addr_offset
);
1341 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1345 printf ("%s:\t", buf
+ skip_addr_chars
);
1349 aux
->require_sec
= true;
1350 objdump_print_address (section
->vma
+ addr_offset
, info
);
1351 aux
->require_sec
= false;
1358 sfile
.buffer
= xmalloc (sfile
.size
);
1359 sfile
.current
= sfile
.buffer
;
1360 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1361 info
->stream
= (FILE *) &sfile
;
1362 info
->bytes_per_line
= 0;
1363 info
->bytes_per_chunk
= 0;
1365 #ifdef DISASSEMBLER_NEEDS_RELOCS
1366 /* FIXME: This is wrong. It tests the number of octets
1367 in the last instruction, not the current one. */
1368 if (*relppp
< relppend
1369 && (**relppp
)->address
>= addr_offset
1370 && (**relppp
)->address
<= addr_offset
+ octets
/ opb
)
1371 info
->flags
= INSN_HAS_RELOC
;
1376 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, info
);
1377 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1378 info
->stream
= stdout
;
1379 if (info
->bytes_per_line
!= 0)
1380 octets_per_line
= info
->bytes_per_line
;
1383 if (sfile
.current
!= sfile
.buffer
)
1384 printf ("%s\n", sfile
.buffer
);
1385 free (sfile
.buffer
);
1393 octets
= octets_per_line
;
1394 if (addr_offset
+ octets
/ opb
> stop_offset
)
1395 octets
= (stop_offset
- addr_offset
) * opb
;
1397 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1399 if (isprint (data
[j
]))
1400 buf
[j
- addr_offset
* opb
] = data
[j
];
1402 buf
[j
- addr_offset
* opb
] = '.';
1404 buf
[j
- addr_offset
* opb
] = '\0';
1407 if (prefix_addresses
1409 : show_raw_insn
>= 0)
1413 /* If ! prefix_addresses and ! wide_output, we print
1414 octets_per_line octets per line. */
1416 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1417 pb
= octets_per_line
;
1419 if (info
->bytes_per_chunk
)
1420 bpc
= info
->bytes_per_chunk
;
1424 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1427 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1429 for (k
= bpc
- 1; k
>= 0; k
--)
1430 printf ("%02x", (unsigned) data
[j
+ k
]);
1435 for (k
= 0; k
< bpc
; k
++)
1436 printf ("%02x", (unsigned) data
[j
+ k
]);
1441 for (; pb
< octets_per_line
; pb
+= bpc
)
1445 for (k
= 0; k
< bpc
; k
++)
1450 /* Separate raw data from instruction by extra space. */
1461 printf ("%s", sfile
.buffer
);
1462 free (sfile
.buffer
);
1465 if (prefix_addresses
1467 : show_raw_insn
>= 0)
1475 j
= addr_offset
* opb
+ pb
;
1477 sprintf_vma (buf
, section
->vma
+ j
/ opb
);
1478 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1482 printf ("%s:\t", buf
+ skip_addr_chars
);
1484 pb
+= octets_per_line
;
1487 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1491 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1493 for (k
= bpc
- 1; k
>= 0; k
--)
1494 printf ("%02x", (unsigned) data
[j
+ k
]);
1499 for (k
= 0; k
< bpc
; k
++)
1500 printf ("%02x", (unsigned) data
[j
+ k
]);
1513 if ((section
->flags
& SEC_RELOC
) != 0
1514 #ifndef DISASSEMBLER_NEEDS_RELOCS
1519 while ((*relppp
) < relppend
1520 && ((**relppp
)->address
>= (bfd_vma
) addr_offset
1521 && (**relppp
)->address
< (bfd_vma
) addr_offset
+ octets
/ opb
))
1522 #ifdef DISASSEMBLER_NEEDS_RELOCS
1523 if (! dump_reloc_info
)
1537 objdump_print_value (section
->vma
+ q
->address
, info
, true);
1539 printf (": %s\t", q
->howto
->name
);
1541 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1542 printf ("*unknown*");
1545 const char *sym_name
;
1547 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1548 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1549 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1554 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1555 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1556 if (sym_name
== NULL
|| *sym_name
== '\0')
1557 sym_name
= "*unknown*";
1558 printf ("%s", sym_name
);
1565 objdump_print_value (q
->addend
, info
, true);
1577 addr_offset
+= octets
/ opb
;
1581 /* Disassemble the contents of an object file. */
1584 disassemble_data (abfd
)
1587 unsigned long addr_offset
;
1588 disassembler_ftype disassemble_fn
;
1589 struct disassemble_info disasm_info
;
1590 struct objdump_disasm_info aux
;
1595 prev_functionname
= NULL
;
1598 /* We make a copy of syms to sort. We don't want to sort syms
1599 because that will screw up the relocs. */
1600 sorted_syms
= (asymbol
**) xmalloc (symcount
* sizeof (asymbol
*));
1601 memcpy (sorted_syms
, syms
, symcount
* sizeof (asymbol
*));
1603 sorted_symcount
= remove_useless_symbols (sorted_syms
, symcount
);
1605 /* Sort the symbols into section and symbol order */
1606 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1608 INIT_DISASSEMBLE_INFO(disasm_info
, stdout
, fprintf
);
1609 disasm_info
.application_data
= (PTR
) &aux
;
1611 aux
.require_sec
= false;
1612 disasm_info
.print_address_func
= objdump_print_address
;
1613 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1615 if (machine
!= (char *) NULL
)
1617 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1620 fatal (_("Can't use supplied machine %s"), machine
);
1622 abfd
->arch_info
= info
;
1625 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1627 struct bfd_target
*xvec
;
1629 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
1630 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1631 xvec
->byteorder
= endian
;
1635 disassemble_fn
= disassembler (abfd
);
1636 if (!disassemble_fn
)
1638 non_fatal (_("Can't disassemble for architecture %s\n"),
1639 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1644 opb
= bfd_octets_per_byte (abfd
);
1646 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1647 disasm_info
.arch
= bfd_get_arch (abfd
);
1648 disasm_info
.mach
= bfd_get_mach (abfd
);
1649 disasm_info
.disassembler_options
= disassembler_options
;
1650 disasm_info
.octets_per_byte
= opb
;
1652 if (bfd_big_endian (abfd
))
1653 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1654 else if (bfd_little_endian (abfd
))
1655 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1657 /* ??? Aborting here seems too drastic. We could default to big or little
1659 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1661 for (section
= abfd
->sections
;
1662 section
!= (asection
*) NULL
;
1663 section
= section
->next
)
1665 bfd_byte
*data
= NULL
;
1666 bfd_size_type datasize
= 0;
1667 arelent
**relbuf
= NULL
;
1668 arelent
**relpp
= NULL
;
1669 arelent
**relppend
= NULL
;
1670 unsigned long stop_offset
;
1671 asymbol
*sym
= NULL
;
1674 if ((section
->flags
& SEC_LOAD
) == 0
1675 || (! disassemble_all
1677 && (section
->flags
& SEC_CODE
) == 0))
1679 if (only
!= (char *) NULL
&& strcmp (only
, section
->name
) != 0)
1682 if ((section
->flags
& SEC_RELOC
) != 0
1683 #ifndef DISASSEMBLER_NEEDS_RELOCS
1690 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1692 bfd_fatal (bfd_get_filename (abfd
));
1698 relbuf
= (arelent
**) xmalloc (relsize
);
1699 relcount
= bfd_canonicalize_reloc (abfd
, section
, relbuf
, syms
);
1701 bfd_fatal (bfd_get_filename (abfd
));
1703 /* Sort the relocs by address. */
1704 qsort (relbuf
, relcount
, sizeof (arelent
*), compare_relocs
);
1707 relppend
= relpp
+ relcount
;
1709 /* Skip over the relocs belonging to addresses below the
1711 if (start_address
!= (bfd_vma
) -1)
1713 while (relpp
< relppend
1714 && (*relpp
)->address
< start_address
)
1720 printf (_("Disassembly of section %s:\n"), section
->name
);
1722 datasize
= bfd_get_section_size_before_reloc (section
);
1726 data
= (bfd_byte
*) xmalloc ((size_t) datasize
);
1728 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1731 disasm_info
.buffer
= data
;
1732 disasm_info
.buffer_vma
= section
->vma
;
1733 disasm_info
.buffer_length
= datasize
;
1734 if (start_address
== (bfd_vma
) -1
1735 || start_address
< disasm_info
.buffer_vma
)
1738 addr_offset
= start_address
- disasm_info
.buffer_vma
;
1739 if (stop_address
== (bfd_vma
) -1)
1740 stop_offset
= datasize
/ opb
;
1743 if (stop_address
< disasm_info
.buffer_vma
)
1746 stop_offset
= stop_address
- disasm_info
.buffer_vma
;
1747 if (stop_offset
> disasm_info
.buffer_length
/ opb
)
1748 stop_offset
= disasm_info
.buffer_length
/ opb
;
1751 sym
= find_symbol_for_address (abfd
, section
, section
->vma
+ addr_offset
,
1754 while (addr_offset
< stop_offset
)
1757 unsigned long nextstop_offset
;
1760 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= section
->vma
+ addr_offset
)
1765 (x
< sorted_symcount
1766 && bfd_asymbol_value (sorted_syms
[x
]) <= section
->vma
+ addr_offset
);
1769 disasm_info
.symbols
= & sorted_syms
[place
];
1770 disasm_info
.num_symbols
= x
- place
;
1773 disasm_info
.symbols
= NULL
;
1775 if (! prefix_addresses
)
1778 objdump_print_addr_with_sym (abfd
, section
, sym
,
1779 section
->vma
+ addr_offset
,
1785 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
)
1787 else if (sym
== NULL
)
1791 /* Search forward for the next appropriate symbol in
1792 SECTION. Note that all the symbols are sorted
1793 together into one big array, and that some sections
1794 may have overlapping addresses. */
1795 while (place
< sorted_symcount
1796 && (sorted_syms
[place
]->section
!= section
1797 || (bfd_asymbol_value (sorted_syms
[place
])
1798 <= bfd_asymbol_value (sym
))))
1800 if (place
>= sorted_symcount
)
1803 nextsym
= sorted_syms
[place
];
1806 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
)
1808 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1809 if (nextstop_offset
> stop_offset
)
1810 nextstop_offset
= stop_offset
;
1812 else if (nextsym
== NULL
)
1813 nextstop_offset
= stop_offset
;
1816 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1817 if (nextstop_offset
> stop_offset
)
1818 nextstop_offset
= stop_offset
;
1821 /* If a symbol is explicitly marked as being an object
1822 rather than a function, just dump the bytes without
1823 disassembling them. */
1826 || bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
1827 || ((sym
->flags
& BSF_OBJECT
) == 0
1828 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1830 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1832 || (sym
->flags
& BSF_FUNCTION
) != 0)
1837 disassemble_bytes (&disasm_info
, disassemble_fn
, insns
, data
,
1838 addr_offset
, nextstop_offset
, &relpp
, relppend
);
1840 addr_offset
= nextstop_offset
;
1852 /* Define a table of stab values and print-strings. We wish the initializer
1853 could be a direct-mapped table, but instead we build one the first
1856 static void dump_section_stabs
PARAMS ((bfd
*abfd
, char *stabsect_name
,
1857 char *strsect_name
));
1859 /* Dump the stabs sections from an object file that has a section that
1860 uses Sun stabs encoding. */
1866 dump_section_stabs (abfd
, ".stab", ".stabstr");
1867 dump_section_stabs (abfd
, ".stab.excl", ".stab.exclstr");
1868 dump_section_stabs (abfd
, ".stab.index", ".stab.indexstr");
1869 dump_section_stabs (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1872 static bfd_byte
*stabs
;
1873 static bfd_size_type stab_size
;
1875 static char *strtab
;
1876 static bfd_size_type stabstr_size
;
1878 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1879 and string table section STRSECT_NAME into `strtab'.
1880 If the section exists and was read, allocate the space and return true.
1881 Otherwise return false. */
1884 read_section_stabs (abfd
, stabsect_name
, strsect_name
)
1886 const char *stabsect_name
;
1887 const char *strsect_name
;
1889 asection
*stabsect
, *stabstrsect
;
1891 stabsect
= bfd_get_section_by_name (abfd
, stabsect_name
);
1894 printf (_("No %s section present\n\n"), stabsect_name
);
1898 stabstrsect
= bfd_get_section_by_name (abfd
, strsect_name
);
1899 if (0 == stabstrsect
)
1901 non_fatal (_("%s has no %s section"),
1902 bfd_get_filename (abfd
), strsect_name
);
1907 stab_size
= bfd_section_size (abfd
, stabsect
);
1908 stabstr_size
= bfd_section_size (abfd
, stabstrsect
);
1910 stabs
= (bfd_byte
*) xmalloc (stab_size
);
1911 strtab
= (char *) xmalloc (stabstr_size
);
1913 if (! bfd_get_section_contents (abfd
, stabsect
, (PTR
) stabs
, 0, stab_size
))
1915 non_fatal (_("Reading %s section of %s failed: %s"),
1916 stabsect_name
, bfd_get_filename (abfd
),
1917 bfd_errmsg (bfd_get_error ()));
1924 if (! bfd_get_section_contents (abfd
, stabstrsect
, (PTR
) strtab
, 0,
1927 non_fatal (_("Reading %s section of %s failed: %s\n"),
1928 strsect_name
, bfd_get_filename (abfd
),
1929 bfd_errmsg (bfd_get_error ()));
1939 /* Stabs entries use a 12 byte format:
1940 4 byte string table index
1942 1 byte stab other field
1943 2 byte stab desc field
1945 FIXME: This will have to change for a 64 bit object format. */
1947 #define STRDXOFF (0)
1949 #define OTHEROFF (5)
1952 #define STABSIZE (12)
1954 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1955 using string table section STRSECT_NAME (in `strtab'). */
1958 print_section_stabs (abfd
, stabsect_name
, strsect_name
)
1960 const char *stabsect_name
;
1961 const char *strsect_name ATTRIBUTE_UNUSED
;
1964 unsigned file_string_table_offset
= 0, next_file_string_table_offset
= 0;
1965 bfd_byte
*stabp
, *stabs_end
;
1968 stabs_end
= stabp
+ stab_size
;
1970 printf (_("Contents of %s section:\n\n"), stabsect_name
);
1971 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1973 /* Loop through all symbols and print them.
1975 We start the index at -1 because there is a dummy symbol on
1976 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1978 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
1982 unsigned char type
, other
;
1983 unsigned short desc
;
1986 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
1987 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
1988 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
1989 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
1990 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
1992 printf ("\n%-6d ", i
);
1993 /* Either print the stab name, or, if unnamed, print its number
1994 again (makes consistent formatting for tools like awk). */
1995 name
= bfd_get_stab_name (type
);
1997 printf ("%-6s", name
);
1998 else if (type
== N_UNDF
)
2001 printf ("%-6d", type
);
2002 printf (" %-6d %-6d ", other
, desc
);
2004 printf (" %-6lu", strx
);
2006 /* Symbols with type == 0 (N_UNDF) specify the length of the
2007 string table associated with this file. We use that info
2008 to know how to relocate the *next* file's string table indices. */
2012 file_string_table_offset
= next_file_string_table_offset
;
2013 next_file_string_table_offset
+= value
;
2017 /* Using the (possibly updated) string table offset, print the
2018 string (if any) associated with this symbol. */
2020 if ((strx
+ file_string_table_offset
) < stabstr_size
)
2021 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
2030 dump_section_stabs (abfd
, stabsect_name
, strsect_name
)
2032 char *stabsect_name
;
2037 /* Check for section names for which stabsect_name is a prefix, to
2038 handle .stab0, etc. */
2039 for (s
= abfd
->sections
;
2045 len
= strlen (stabsect_name
);
2047 /* If the prefix matches, and the files section name ends with a
2048 nul or a digit, then we match. I.e., we want either an exact
2049 match or a section followed by a number. */
2050 if (strncmp (stabsect_name
, s
->name
, len
) == 0
2051 && (s
->name
[len
] == '\000'
2052 || isdigit ((unsigned char) s
->name
[len
])))
2054 if (read_section_stabs (abfd
, s
->name
, strsect_name
))
2056 print_section_stabs (abfd
, s
->name
, strsect_name
);
2065 dump_bfd_header (abfd
)
2070 printf (_("architecture: %s, "),
2071 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2072 bfd_get_mach (abfd
)));
2073 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2075 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2076 PF (HAS_RELOC
, "HAS_RELOC");
2077 PF (EXEC_P
, "EXEC_P");
2078 PF (HAS_LINENO
, "HAS_LINENO");
2079 PF (HAS_DEBUG
, "HAS_DEBUG");
2080 PF (HAS_SYMS
, "HAS_SYMS");
2081 PF (HAS_LOCALS
, "HAS_LOCALS");
2082 PF (DYNAMIC
, "DYNAMIC");
2083 PF (WP_TEXT
, "WP_TEXT");
2084 PF (D_PAGED
, "D_PAGED");
2085 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2086 printf (_("\nstart address 0x"));
2087 printf_vma (abfd
->start_address
);
2092 dump_bfd_private_header (abfd
)
2095 bfd_print_private_bfd_data (abfd
, stdout
);
2098 /* Dump selected contents of ABFD */
2104 /* If we are adjusting section VMA's, change them all now. Changing
2105 the BFD information is a hack. However, we must do it, or
2106 bfd_find_nearest_line will not do the right thing. */
2107 if (adjust_section_vma
!= 0)
2111 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2113 s
->vma
+= adjust_section_vma
;
2114 s
->lma
+= adjust_section_vma
;
2118 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2121 print_arelt_descr (stdout
, abfd
, true);
2122 if (dump_file_header
)
2123 dump_bfd_header (abfd
);
2124 if (dump_private_headers
)
2125 dump_bfd_private_header (abfd
);
2127 if (dump_section_headers
)
2128 dump_headers (abfd
);
2129 if (dump_symtab
|| dump_reloc_info
|| disassemble
|| dump_debugging
)
2131 syms
= slurp_symtab (abfd
);
2133 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
)
2135 dynsyms
= slurp_dynamic_symtab (abfd
);
2138 dump_symbols (abfd
, false);
2139 if (dump_dynamic_symtab
)
2140 dump_symbols (abfd
, true);
2141 if (dump_stab_section_info
)
2143 if (dump_reloc_info
&& ! disassemble
)
2145 if (dump_dynamic_reloc_info
)
2146 dump_dynamic_relocs (abfd
);
2147 if (dump_section_contents
)
2150 disassemble_data (abfd
);
2155 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2156 if (dhandle
!= NULL
)
2158 if (! print_debugging_info (stdout
, dhandle
))
2160 non_fatal (_("%s: printing debugging information failed"),
2161 bfd_get_filename (abfd
));
2184 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2190 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2192 nonfatal (bfd_get_filename (abfd
));
2193 list_matching_formats (matching
);
2198 if (bfd_get_error () != bfd_error_file_not_recognized
)
2200 nonfatal (bfd_get_filename (abfd
));
2204 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
2210 nonfatal (bfd_get_filename (abfd
));
2212 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2214 list_matching_formats (matching
);
2220 display_file (filename
, target
)
2224 bfd
*file
, *arfile
= (bfd
*) NULL
;
2226 file
= bfd_openr (filename
, target
);
2229 nonfatal (filename
);
2233 if (bfd_check_format (file
, bfd_archive
) == true)
2235 bfd
*last_arfile
= NULL
;
2237 printf (_("In archive %s:\n"), bfd_get_filename (file
));
2240 bfd_set_error (bfd_error_no_error
);
2242 arfile
= bfd_openr_next_archived_file (file
, arfile
);
2245 if (bfd_get_error () != bfd_error_no_more_archived_files
)
2246 nonfatal (bfd_get_filename (file
));
2250 display_bfd (arfile
);
2252 if (last_arfile
!= NULL
)
2253 bfd_close (last_arfile
);
2254 last_arfile
= arfile
;
2257 if (last_arfile
!= NULL
)
2258 bfd_close (last_arfile
);
2266 /* Actually display the various requested regions */
2274 bfd_size_type datasize
= 0;
2275 bfd_size_type addr_offset
;
2276 bfd_size_type start_offset
, stop_offset
;
2277 unsigned int opb
= bfd_octets_per_byte (abfd
);
2279 for (section
= abfd
->sections
; section
!= NULL
; section
=
2284 if (only
== (char *) NULL
||
2285 strcmp (only
, section
->name
) == 0)
2287 if (section
->flags
& SEC_HAS_CONTENTS
)
2289 printf (_("Contents of section %s:\n"), section
->name
);
2291 if (bfd_section_size (abfd
, section
) == 0)
2293 data
= (bfd_byte
*) xmalloc ((size_t) bfd_section_size (abfd
, section
));
2294 datasize
= bfd_section_size (abfd
, section
);
2297 bfd_get_section_contents (abfd
, section
, (PTR
) data
, 0, bfd_section_size (abfd
, section
));
2299 if (start_address
== (bfd_vma
) -1
2300 || start_address
< section
->vma
)
2303 start_offset
= start_address
- section
->vma
;
2304 if (stop_address
== (bfd_vma
) -1)
2305 stop_offset
= bfd_section_size (abfd
, section
) / opb
;
2308 if (stop_address
< section
->vma
)
2311 stop_offset
= stop_address
- section
->vma
;
2312 if (stop_offset
> bfd_section_size (abfd
, section
) / opb
)
2313 stop_offset
= bfd_section_size (abfd
, section
) / opb
;
2315 for (addr_offset
= start_offset
;
2316 addr_offset
< stop_offset
; addr_offset
+= onaline
)
2320 printf (" %04lx ", (unsigned long int)
2321 (addr_offset
+ section
->vma
));
2322 for (j
= addr_offset
* opb
;
2323 j
< addr_offset
* opb
+ onaline
; j
++)
2325 if (j
< stop_offset
* opb
)
2326 printf ("%02x", (unsigned) (data
[j
]));
2334 for (j
= addr_offset
; j
< addr_offset
* opb
+ onaline
; j
++)
2336 if (j
>= stop_offset
* opb
)
2339 printf ("%c", isprint (data
[j
]) ? data
[j
] : '.');
2349 /* Should perhaps share code and display with nm? */
2351 dump_symbols (abfd
, dynamic
)
2352 bfd
*abfd ATTRIBUTE_UNUSED
;
2365 printf ("DYNAMIC SYMBOL TABLE:\n");
2373 printf ("SYMBOL TABLE:\n");
2376 for (count
= 0; count
< max
; count
++)
2380 bfd
*cur_bfd
= bfd_asymbol_bfd (*current
);
2382 if (cur_bfd
!= NULL
)
2387 name
= bfd_asymbol_name (*current
);
2389 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2393 /* If we want to demangle the name, we demangle it
2394 here, and temporarily clobber it while calling
2395 bfd_print_symbol. FIXME: This is a gross hack. */
2398 if (bfd_get_symbol_leading_char (cur_bfd
) == *n
)
2400 alloc
= cplus_demangle (n
, DMGL_ANSI
| DMGL_PARAMS
);
2402 (*current
)->name
= alloc
;
2404 (*current
)->name
= n
;
2407 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2408 bfd_print_symbol_all
);
2410 (*current
)->name
= name
;
2431 for (a
= abfd
->sections
; a
!= (asection
*) NULL
; a
= a
->next
)
2435 if (bfd_is_abs_section (a
))
2437 if (bfd_is_und_section (a
))
2439 if (bfd_is_com_section (a
))
2444 if (strcmp (only
, a
->name
))
2447 else if ((a
->flags
& SEC_RELOC
) == 0)
2450 relsize
= bfd_get_reloc_upper_bound (abfd
, a
);
2452 bfd_fatal (bfd_get_filename (abfd
));
2454 printf ("RELOCATION RECORDS FOR [%s]:", a
->name
);
2458 printf (" (none)\n\n");
2462 relpp
= (arelent
**) xmalloc (relsize
);
2463 relcount
= bfd_canonicalize_reloc (abfd
, a
, relpp
, syms
);
2465 bfd_fatal (bfd_get_filename (abfd
));
2466 else if (relcount
== 0)
2468 printf (" (none)\n\n");
2473 dump_reloc_set (abfd
, a
, relpp
, relcount
);
2482 dump_dynamic_relocs (abfd
)
2489 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2491 bfd_fatal (bfd_get_filename (abfd
));
2493 printf ("DYNAMIC RELOCATION RECORDS");
2497 printf (" (none)\n\n");
2501 relpp
= (arelent
**) xmalloc (relsize
);
2502 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2504 bfd_fatal (bfd_get_filename (abfd
));
2505 else if (relcount
== 0)
2507 printf (" (none)\n\n");
2512 dump_reloc_set (abfd
, (asection
*) NULL
, relpp
, relcount
);
2520 dump_reloc_set (abfd
, sec
, relpp
, relcount
)
2527 char *last_filename
, *last_functionname
;
2528 unsigned int last_line
;
2530 /* Get column headers lined up reasonably. */
2536 sprintf_vma (buf
, (bfd_vma
) -1);
2537 width
= strlen (buf
) - 7;
2539 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2542 last_filename
= NULL
;
2543 last_functionname
= NULL
;
2546 for (p
= relpp
; relcount
&& *p
!= (arelent
*) NULL
; p
++, relcount
--)
2549 const char *filename
, *functionname
;
2551 const char *sym_name
;
2552 const char *section_name
;
2554 if (start_address
!= (bfd_vma
) -1
2555 && q
->address
< start_address
)
2557 if (stop_address
!= (bfd_vma
) -1
2558 && q
->address
> stop_address
)
2561 if (with_line_numbers
2563 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2564 &filename
, &functionname
, &line
))
2566 if (functionname
!= NULL
2567 && (last_functionname
== NULL
2568 || strcmp (functionname
, last_functionname
) != 0))
2570 printf ("%s():\n", functionname
);
2571 if (last_functionname
!= NULL
)
2572 free (last_functionname
);
2573 last_functionname
= xstrdup (functionname
);
2576 && (line
!= last_line
2577 || (filename
!= NULL
2578 && last_filename
!= NULL
2579 && strcmp (filename
, last_filename
) != 0)))
2581 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2583 if (last_filename
!= NULL
)
2584 free (last_filename
);
2585 if (filename
== NULL
)
2586 last_filename
= NULL
;
2588 last_filename
= xstrdup (filename
);
2592 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2594 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2595 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2600 section_name
= NULL
;
2604 printf_vma (q
->address
);
2606 printf (" %-16s ", q
->howto
->name
);
2608 printf (" %-16d ", q
->howto
->type
);
2609 objdump_print_symname (abfd
, (struct disassemble_info
*) NULL
,
2614 if (section_name
== (CONST
char *) NULL
)
2615 section_name
= "*unknown*";
2616 printf_vma (q
->address
);
2617 printf (" %-16s [%s]",
2624 printf_vma (q
->addend
);
2630 /* The length of the longest architecture name + 1. */
2631 #define LONGEST_ARCH sizeof("powerpc:common")
2634 endian_string (endian
)
2635 enum bfd_endian endian
;
2637 if (endian
== BFD_ENDIAN_BIG
)
2638 return "big endian";
2639 else if (endian
== BFD_ENDIAN_LITTLE
)
2640 return "little endian";
2642 return "endianness unknown";
2645 /* List the targets that BFD is configured to support, each followed
2646 by its endianness and the architectures it supports. */
2649 display_target_list ()
2651 extern const bfd_target
*const *bfd_target_vector
;
2655 dummy_name
= make_temp_file (NULL
);
2656 for (t
= 0; bfd_target_vector
[t
]; t
++)
2658 const bfd_target
*p
= bfd_target_vector
[t
];
2659 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2662 printf ("%s\n (header %s, data %s)\n", p
->name
,
2663 endian_string (p
->header_byteorder
),
2664 endian_string (p
->byteorder
));
2668 nonfatal (dummy_name
);
2672 if (! bfd_set_format (abfd
, bfd_object
))
2674 if (bfd_get_error () != bfd_error_invalid_operation
)
2676 bfd_close_all_done (abfd
);
2680 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2681 if (bfd_set_arch_mach (abfd
, (enum bfd_architecture
) a
, 0))
2683 bfd_printable_arch_mach ((enum bfd_architecture
) a
, 0));
2684 bfd_close_all_done (abfd
);
2686 unlink (dummy_name
);
2690 /* Print a table showing which architectures are supported for entries
2691 FIRST through LAST-1 of bfd_target_vector (targets across,
2692 architectures down). */
2695 display_info_table (first
, last
)
2699 extern const bfd_target
*const *bfd_target_vector
;
2703 /* Print heading of target names. */
2704 printf ("\n%*s", (int) LONGEST_ARCH
, " ");
2705 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2706 printf ("%s ", bfd_target_vector
[t
]->name
);
2709 dummy_name
= make_temp_file (NULL
);
2710 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2711 if (strcmp (bfd_printable_arch_mach (a
, 0), "UNKNOWN!") != 0)
2713 printf ("%*s ", (int) LONGEST_ARCH
- 1,
2714 bfd_printable_arch_mach (a
, 0));
2715 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2717 const bfd_target
*p
= bfd_target_vector
[t
];
2719 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2729 if (! bfd_set_format (abfd
, bfd_object
))
2731 if (bfd_get_error () != bfd_error_invalid_operation
)
2739 if (! bfd_set_arch_mach (abfd
, a
, 0))
2744 printf ("%s ", p
->name
);
2747 int l
= strlen (p
->name
);
2753 bfd_close_all_done (abfd
);
2757 unlink (dummy_name
);
2761 /* Print tables of all the target-architecture combinations that
2762 BFD has been configured to support. */
2765 display_target_tables ()
2768 extern const bfd_target
*const *bfd_target_vector
;
2772 colum
= getenv ("COLUMNS");
2774 columns
= atoi (colum
);
2779 while (bfd_target_vector
[t
] != NULL
)
2783 wid
= LONGEST_ARCH
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2785 while (wid
< columns
&& bfd_target_vector
[t
] != NULL
)
2789 newwid
= wid
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2790 if (newwid
>= columns
)
2795 display_info_table (oldt
, t
);
2802 printf (_("BFD header file version %s\n"), BFD_VERSION
);
2803 display_target_list ();
2804 display_target_tables ();
2813 char *target
= default_target
;
2814 boolean seenflag
= false;
2816 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
2817 setlocale (LC_MESSAGES
, "");
2819 bindtextdomain (PACKAGE
, LOCALEDIR
);
2820 textdomain (PACKAGE
);
2822 program_name
= *argv
;
2823 xmalloc_set_program_name (program_name
);
2825 START_PROGRESS (program_name
, 0);
2828 set_default_bfd_target ();
2830 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VCdDlfahHrRtTxsSj:wE:zgG",
2831 long_options
, (int *) 0))
2837 break; /* we've been given a long option */
2842 disassembler_options
= optarg
;
2848 with_line_numbers
= true;
2857 enum demangling_styles style
;
2859 style
= cplus_demangle_name_to_style (optarg
);
2860 if (style
== unknown_demangling
)
2861 fatal (_("unknown demangling style `%s'"),
2864 cplus_demangle_set_style (style
);
2870 case OPTION_ADJUST_VMA
:
2871 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
2873 case OPTION_START_ADDRESS
:
2874 start_address
= parse_vma (optarg
, "--start-address");
2876 case OPTION_STOP_ADDRESS
:
2877 stop_address
= parse_vma (optarg
, "--stop-address");
2880 if (strcmp (optarg
, "B") == 0)
2881 endian
= BFD_ENDIAN_BIG
;
2882 else if (strcmp (optarg
, "L") == 0)
2883 endian
= BFD_ENDIAN_LITTLE
;
2886 non_fatal (_("unrecognized -E option"));
2891 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
2892 endian
= BFD_ENDIAN_BIG
;
2893 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
2894 endian
= BFD_ENDIAN_LITTLE
;
2897 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
2903 dump_file_header
= true;
2907 formats_info
= true;
2911 dump_private_headers
= true;
2915 dump_private_headers
= true;
2917 dump_reloc_info
= true;
2918 dump_file_header
= true;
2919 dump_ar_hdrs
= true;
2920 dump_section_headers
= true;
2928 dump_dynamic_symtab
= true;
2936 disassemble_zeroes
= true;
2940 disassemble_all
= true;
2945 with_source_code
= true;
2953 dump_stab_section_info
= true;
2957 dump_section_contents
= true;
2961 dump_reloc_info
= true;
2965 dump_dynamic_reloc_info
= true;
2969 dump_ar_hdrs
= true;
2973 dump_section_headers
= true;
2980 show_version
= true;
2990 print_version ("objdump");
2992 if (seenflag
== false)
3000 display_file ("a.out", target
);
3002 for (; optind
< argc
;)
3003 display_file (argv
[optind
++], target
);
3006 END_PROGRESS (program_name
);