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. */
27 #include "safe-ctype.h"
29 #include "libiberty.h"
34 /* Internal headers for the ELF .stab-dump code - sorry. */
35 #define BYTES_IN_WORD 32
36 #include "aout/aout64.h"
38 #ifdef NEED_DECLARATION_FPRINTF
39 /* This is needed by INIT_DISASSEMBLE_INFO. */
40 extern int fprintf
PARAMS ((FILE *, const char *, ...));
44 static int exit_status
= 0;
46 static char *default_target
= NULL
; /* default at runtime */
48 static int show_version
= 0; /* show the version number */
49 static int dump_section_contents
; /* -s */
50 static int dump_section_headers
; /* -h */
51 static boolean dump_file_header
; /* -f */
52 static int dump_symtab
; /* -t */
53 static int dump_dynamic_symtab
; /* -T */
54 static int dump_reloc_info
; /* -r */
55 static int dump_dynamic_reloc_info
; /* -R */
56 static int dump_ar_hdrs
; /* -a */
57 static int dump_private_headers
; /* -p */
58 static int prefix_addresses
; /* --prefix-addresses */
59 static int with_line_numbers
; /* -l */
60 static boolean with_source_code
; /* -S */
61 static int show_raw_insn
; /* --show-raw-insn */
62 static int dump_stab_section_info
; /* --stabs */
63 static int do_demangle
; /* -C, --demangle */
64 static boolean disassemble
; /* -d */
65 static boolean disassemble_all
; /* -D */
66 static int disassemble_zeroes
; /* --disassemble-zeroes */
67 static boolean formats_info
; /* -i */
68 static char *only
; /* -j secname */
69 static int wide_output
; /* -w */
70 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
71 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
72 static int dump_debugging
; /* --debugging */
73 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
74 static int file_start_context
= 0; /* --file-start-context */
76 /* Extra info to pass to the disassembler address printing function. */
77 struct objdump_disasm_info
84 /* Architecture to disassemble for, or default if NULL. */
85 static char *machine
= (char *) NULL
;
87 /* Target specific options to the disassembler. */
88 static char *disassembler_options
= (char *) NULL
;
90 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
91 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
93 /* The symbol table. */
94 static asymbol
**syms
;
96 /* Number of symbols in `syms'. */
97 static long symcount
= 0;
99 /* The sorted symbol table. */
100 static asymbol
**sorted_syms
;
102 /* Number of symbols in `sorted_syms'. */
103 static long sorted_symcount
= 0;
105 /* The dynamic symbol table. */
106 static asymbol
**dynsyms
;
108 /* Number of symbols in `dynsyms'. */
109 static long dynsymcount
= 0;
111 /* Static declarations. */
113 static void usage
PARAMS ((FILE *, int));
114 static void nonfatal
PARAMS ((const char *));
115 static void display_file
PARAMS ((char *filename
, char *target
));
116 static void dump_section_header
PARAMS ((bfd
*, asection
*, PTR
));
117 static void dump_headers
PARAMS ((bfd
*));
118 static void dump_data
PARAMS ((bfd
*abfd
));
119 static void dump_relocs
PARAMS ((bfd
*abfd
));
120 static void dump_dynamic_relocs
PARAMS ((bfd
* abfd
));
121 static void dump_reloc_set
PARAMS ((bfd
*, asection
*, arelent
**, long));
122 static void dump_symbols
PARAMS ((bfd
*abfd
, boolean dynamic
));
123 static void dump_bfd_header
PARAMS ((bfd
*));
124 static void dump_bfd_private_header
PARAMS ((bfd
*));
125 static void dump_bfd
PARAMS ((bfd
*));
126 static void display_bfd
PARAMS ((bfd
*abfd
));
127 static void display_target_list
PARAMS ((void));
128 static void display_info_table
PARAMS ((int, int));
129 static void display_target_tables
PARAMS ((void));
130 static void display_info
PARAMS ((void));
131 static void objdump_print_value
132 PARAMS ((bfd_vma
, struct disassemble_info
*, boolean
));
133 static void objdump_print_symname
134 PARAMS ((bfd
*, struct disassemble_info
*, asymbol
*));
135 static asymbol
*find_symbol_for_address
136 PARAMS ((bfd
*, asection
*, bfd_vma
, boolean
, long *));
137 static void objdump_print_addr_with_sym
138 PARAMS ((bfd
*, asection
*, asymbol
*, bfd_vma
,
139 struct disassemble_info
*, boolean
));
140 static void objdump_print_addr
141 PARAMS ((bfd_vma
, struct disassemble_info
*, boolean
));
142 static void objdump_print_address
143 PARAMS ((bfd_vma
, struct disassemble_info
*));
144 static int objdump_symbol_at_address
145 PARAMS ((bfd_vma
, struct disassemble_info
*));
146 static void show_line
PARAMS ((bfd
*, asection
*, bfd_vma
));
147 static void disassemble_bytes
148 PARAMS ((struct disassemble_info
*, disassembler_ftype
, boolean
,
149 bfd_byte
*, bfd_vma
, bfd_vma
, arelent
***, arelent
**));
150 static void disassemble_data
PARAMS ((bfd
*));
151 static const char *endian_string
PARAMS ((enum bfd_endian
));
152 static asymbol
** slurp_symtab
PARAMS ((bfd
*));
153 static asymbol
** slurp_dynamic_symtab
PARAMS ((bfd
*));
154 static long remove_useless_symbols
PARAMS ((asymbol
**, long));
155 static int compare_symbols
PARAMS ((const PTR
, const PTR
));
156 static int compare_relocs
PARAMS ((const PTR
, const PTR
));
157 static void dump_stabs
PARAMS ((bfd
*));
158 static boolean read_section_stabs
PARAMS ((bfd
*, const char *, const char *));
159 static void print_section_stabs
PARAMS ((bfd
*, const char *, const char *));
162 usage (stream
, status
)
166 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
167 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
168 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
169 fprintf (stream
, _("\
170 -a, --archive-headers Display archive header information\n\
171 -f, --file-headers Display the contents of the overall file header\n\
172 -p, --private-headers Display object format specific file header contents\n\
173 -h, --[section-]headers Display the contents of the section headers\n\
174 -x, --all-headers Display the contents of all headers\n\
175 -d, --disassemble Display assembler contents of executable sections\n\
176 -D, --disassemble-all Display assembler contents of all sections\n\
177 -S, --source Intermix source code with disassembly\n\
178 -s, --full-contents Display the full contents of all sections requested\n\
179 -g, --debugging Display debug information in object file\n\
180 -G, --stabs Display (in raw form) any STABS info in the file\n\
181 -t, --syms Display the contents of the symbol table(s)\n\
182 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
183 -r, --reloc Display the relocation entries in the file\n\
184 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
185 -v, --version Display this program's version number\n\
186 -i, --info List object formats and architectures supported\n\
187 -H, --help Display this information\n\
191 fprintf (stream
, _("\n The following switches are optional:\n"));
192 fprintf (stream
, _("\
193 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
194 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
195 -j, --section=NAME Only display information for section NAME\n\
196 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
197 -EB --endian=big Assume big endian format when disassembling\n\
198 -EL --endian=little Assume little endian format when disassembling\n\
199 --file-start-context Include context from start of file (with -S)\n\
200 -l, --line-numbers Include line numbers and filenames in output\n\
201 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
202 The STYLE, if specified, can be `auto', 'gnu',\n\
203 'lucid', 'arm', 'hp', 'edg', or 'gnu-v3'\n\
204 -w, --wide Format output for more than 80 columns\n\
205 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
206 --start-address=ADDR Only process data whoes address is >= ADDR\n\
207 --stop-address=ADDR Only process data whoes address is <= ADDR\n\
208 --prefix-addresses Print complete address alongside disassembly\n\
209 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
210 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
212 list_supported_targets (program_name
, stream
);
213 list_supported_architectures (program_name
, stream
);
215 disassembler_usage (stream
);
218 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
222 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
224 #define OPTION_ENDIAN (150)
225 #define OPTION_START_ADDRESS (OPTION_ENDIAN + 1)
226 #define OPTION_STOP_ADDRESS (OPTION_START_ADDRESS + 1)
227 #define OPTION_ADJUST_VMA (OPTION_STOP_ADDRESS + 1)
229 static struct option long_options
[]=
231 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
232 {"all-headers", no_argument
, NULL
, 'x'},
233 {"private-headers", no_argument
, NULL
, 'p'},
234 {"architecture", required_argument
, NULL
, 'm'},
235 {"archive-headers", no_argument
, NULL
, 'a'},
236 {"debugging", no_argument
, NULL
, 'g'},
237 {"demangle", optional_argument
, NULL
, 'C'},
238 {"disassemble", no_argument
, NULL
, 'd'},
239 {"disassemble-all", no_argument
, NULL
, 'D'},
240 {"disassembler-options", required_argument
, NULL
, 'M'},
241 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
242 {"dynamic-reloc", no_argument
, NULL
, 'R'},
243 {"dynamic-syms", no_argument
, NULL
, 'T'},
244 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
245 {"file-headers", no_argument
, NULL
, 'f'},
246 {"file-start-context", no_argument
, &file_start_context
, 1},
247 {"full-contents", no_argument
, NULL
, 's'},
248 {"headers", no_argument
, NULL
, 'h'},
249 {"help", no_argument
, NULL
, 'H'},
250 {"info", no_argument
, NULL
, 'i'},
251 {"line-numbers", no_argument
, NULL
, 'l'},
252 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
253 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
254 {"reloc", no_argument
, NULL
, 'r'},
255 {"section", required_argument
, NULL
, 'j'},
256 {"section-headers", no_argument
, NULL
, 'h'},
257 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
258 {"source", no_argument
, NULL
, 'S'},
259 {"stabs", no_argument
, NULL
, 'G'},
260 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
261 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
262 {"syms", no_argument
, NULL
, 't'},
263 {"target", required_argument
, NULL
, 'b'},
264 {"version", no_argument
, NULL
, 'V'},
265 {"wide", no_argument
, NULL
, 'w'},
266 {0, no_argument
, 0, 0}
278 dump_section_header (abfd
, section
, ignored
)
279 bfd
*abfd ATTRIBUTE_UNUSED
;
281 PTR ignored ATTRIBUTE_UNUSED
;
284 unsigned int opb
= bfd_octets_per_byte (abfd
);
286 printf ("%3d %-13s %08lx ", section
->index
,
287 bfd_get_section_name (abfd
, section
),
288 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
289 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
291 bfd_printf_vma (abfd
, section
->lma
);
292 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
293 bfd_get_section_alignment (abfd
, section
));
299 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
301 PF (SEC_HAS_CONTENTS
, "CONTENTS");
302 PF (SEC_ALLOC
, "ALLOC");
303 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
304 PF (SEC_LOAD
, "LOAD");
305 PF (SEC_RELOC
, "RELOC");
306 PF (SEC_READONLY
, "READONLY");
307 PF (SEC_CODE
, "CODE");
308 PF (SEC_DATA
, "DATA");
310 PF (SEC_DEBUGGING
, "DEBUGGING");
311 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
312 PF (SEC_EXCLUDE
, "EXCLUDE");
313 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
314 PF (SEC_BLOCK
, "BLOCK");
315 PF (SEC_CLINK
, "CLINK");
316 PF (SEC_SMALL_DATA
, "SMALL_DATA");
317 PF (SEC_SHARED
, "SHARED");
318 PF (SEC_ARCH_BIT_0
, "ARCH_BIT_0");
319 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
321 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
325 switch (section
->flags
& SEC_LINK_DUPLICATES
)
329 case SEC_LINK_DUPLICATES_DISCARD
:
330 ls
= "LINK_ONCE_DISCARD";
332 case SEC_LINK_DUPLICATES_ONE_ONLY
:
333 ls
= "LINK_ONCE_ONE_ONLY";
335 case SEC_LINK_DUPLICATES_SAME_SIZE
:
336 ls
= "LINK_ONCE_SAME_SIZE";
338 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
339 ls
= "LINK_ONCE_SAME_CONTENTS";
342 printf ("%s%s", comma
, ls
);
344 if (section
->comdat
!= NULL
)
345 printf (" (COMDAT %s %ld)", section
->comdat
->name
,
346 section
->comdat
->symbol
);
359 printf (_("Sections:\n"));
362 printf (_("Idx Name Size VMA LMA File off Algn"));
364 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
365 if (bfd_get_arch_size (abfd
) == 32)
366 printf (_("Idx Name Size VMA LMA File off Algn"));
368 printf (_("Idx Name Size VMA LMA File off Algn"));
372 printf (_(" Flags"));
373 if (abfd
->flags
& HAS_LOAD_PAGE
)
377 bfd_map_over_sections (abfd
, dump_section_header
, (PTR
) NULL
);
384 asymbol
**sy
= (asymbol
**) NULL
;
387 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
393 storage
= bfd_get_symtab_upper_bound (abfd
);
395 bfd_fatal (bfd_get_filename (abfd
));
397 sy
= (asymbol
**) xmalloc (storage
);
399 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
401 bfd_fatal (bfd_get_filename (abfd
));
405 /* Read in the dynamic symbols. */
408 slurp_dynamic_symtab (abfd
)
411 asymbol
**sy
= (asymbol
**) NULL
;
414 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
417 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
419 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
424 bfd_fatal (bfd_get_filename (abfd
));
427 sy
= (asymbol
**) xmalloc (storage
);
429 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
431 bfd_fatal (bfd_get_filename (abfd
));
435 /* Filter out (in place) symbols that are useless for disassembly.
436 COUNT is the number of elements in SYMBOLS.
437 Return the number of useful symbols. */
440 remove_useless_symbols (symbols
, count
)
444 register asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
448 asymbol
*sym
= *in_ptr
++;
450 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
452 if (sym
->flags
& (BSF_DEBUGGING
))
454 if (bfd_is_und_section (sym
->section
)
455 || bfd_is_com_section (sym
->section
))
460 return out_ptr
- symbols
;
463 /* Sort symbols into value order. */
466 compare_symbols (ap
, bp
)
470 const asymbol
*a
= *(const asymbol
**)ap
;
471 const asymbol
*b
= *(const asymbol
**)bp
;
475 flagword aflags
, bflags
;
477 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
479 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
482 if (a
->section
> b
->section
)
484 else if (a
->section
< b
->section
)
487 an
= bfd_asymbol_name (a
);
488 bn
= bfd_asymbol_name (b
);
492 /* The symbols gnu_compiled and gcc2_compiled convey no real
493 information, so put them after other symbols with the same value. */
495 af
= (strstr (an
, "gnu_compiled") != NULL
496 || strstr (an
, "gcc2_compiled") != NULL
);
497 bf
= (strstr (bn
, "gnu_compiled") != NULL
498 || strstr (bn
, "gcc2_compiled") != NULL
);
505 /* We use a heuristic for the file name, to try to sort it after
506 more useful symbols. It may not work on non Unix systems, but it
507 doesn't really matter; the only difference is precisely which
508 symbol names get printed. */
510 #define file_symbol(s, sn, snl) \
511 (((s)->flags & BSF_FILE) != 0 \
512 || ((sn)[(snl) - 2] == '.' \
513 && ((sn)[(snl) - 1] == 'o' \
514 || (sn)[(snl) - 1] == 'a')))
516 af
= file_symbol (a
, an
, anl
);
517 bf
= file_symbol (b
, bn
, bnl
);
524 /* Try to sort global symbols before local symbols before function
525 symbols before debugging symbols. */
530 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
532 if ((aflags
& BSF_DEBUGGING
) != 0)
537 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
539 if ((aflags
& BSF_FUNCTION
) != 0)
544 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
546 if ((aflags
& BSF_LOCAL
) != 0)
551 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
553 if ((aflags
& BSF_GLOBAL
) != 0)
559 /* Symbols that start with '.' might be section names, so sort them
560 after symbols that don't start with '.'. */
561 if (an
[0] == '.' && bn
[0] != '.')
563 if (an
[0] != '.' && bn
[0] == '.')
566 /* Finally, if we can't distinguish them in any other way, try to
567 get consistent results by sorting the symbols by name. */
568 return strcmp (an
, bn
);
571 /* Sort relocs into address order. */
574 compare_relocs (ap
, bp
)
578 const arelent
*a
= *(const arelent
**)ap
;
579 const arelent
*b
= *(const arelent
**)bp
;
581 if (a
->address
> b
->address
)
583 else if (a
->address
< b
->address
)
586 /* So that associated relocations tied to the same address show up
587 in the correct order, we don't do any further sorting. */
596 /* Print VMA to STREAM. If SKIP_ZEROES is true, omit leading zeroes. */
599 objdump_print_value (vma
, info
, skip_zeroes
)
601 struct disassemble_info
*info
;
606 struct objdump_disasm_info
*aux
607 = (struct objdump_disasm_info
*) info
->application_data
;
609 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
614 for (p
= buf
; *p
== '0'; ++p
)
619 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
622 /* Print the name of a symbol. */
625 objdump_print_symname (abfd
, info
, sym
)
627 struct disassemble_info
*info
;
634 name
= bfd_asymbol_name (sym
);
635 if (do_demangle
&& name
[0] != '\0')
637 /* Demangle the name. */
638 alloc
= demangle (abfd
, name
);
643 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
651 /* Locate a symbol given a bfd, a section, and a VMA. If REQUIRE_SEC
652 is true, then always require the symbol to be in the section. This
653 returns NULL if there is no suitable symbol. If PLACE is not NULL,
654 then *PLACE is set to the index of the symbol in sorted_syms. */
657 find_symbol_for_address (abfd
, sec
, vma
, require_sec
, place
)
664 /* @@ Would it speed things up to cache the last two symbols returned,
665 and maybe their address ranges? For many processors, only one memory
666 operand can be present at a time, so the 2-entry cache wouldn't be
667 constantly churned by code doing heavy memory accesses. */
669 /* Indices in `sorted_syms'. */
671 long max
= sorted_symcount
;
673 unsigned int opb
= bfd_octets_per_byte (abfd
);
675 if (sorted_symcount
< 1)
678 /* Perform a binary search looking for the closest symbol to the
679 required value. We are searching the range (min, max]. */
680 while (min
+ 1 < max
)
684 thisplace
= (max
+ min
) / 2;
685 sym
= sorted_syms
[thisplace
];
687 if (bfd_asymbol_value (sym
) > vma
)
689 else if (bfd_asymbol_value (sym
) < vma
)
698 /* The symbol we want is now in min, the low end of the range we
699 were searching. If there are several symbols with the same
700 value, we want the first one. */
703 && (bfd_asymbol_value (sorted_syms
[thisplace
])
704 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
707 /* If the file is relocateable, and the symbol could be from this
708 section, prefer a symbol from this section over symbols from
709 others, even if the other symbol's value might be closer.
711 Note that this may be wrong for some symbol references if the
712 sections have overlapping memory ranges, but in that case there's
713 no way to tell what's desired without looking at the relocation
716 if (sorted_syms
[thisplace
]->section
!= sec
718 || ((abfd
->flags
& HAS_RELOC
) != 0
719 && vma
>= bfd_get_section_vma (abfd
, sec
)
720 && vma
< (bfd_get_section_vma (abfd
, sec
)
721 + bfd_section_size (abfd
, sec
) / opb
))))
725 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
727 if (bfd_asymbol_value (sorted_syms
[i
])
728 != bfd_asymbol_value (sorted_syms
[thisplace
]))
734 if (sorted_syms
[i
]->section
== sec
736 || sorted_syms
[i
- 1]->section
!= sec
737 || (bfd_asymbol_value (sorted_syms
[i
])
738 != bfd_asymbol_value (sorted_syms
[i
- 1]))))
745 if (sorted_syms
[thisplace
]->section
!= sec
)
747 /* We didn't find a good symbol with a smaller value.
748 Look for one with a larger value. */
749 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
751 if (sorted_syms
[i
]->section
== sec
)
759 if (sorted_syms
[thisplace
]->section
!= sec
761 || ((abfd
->flags
& HAS_RELOC
) != 0
762 && vma
>= bfd_get_section_vma (abfd
, sec
)
763 && vma
< (bfd_get_section_vma (abfd
, sec
)
764 + bfd_section_size (abfd
, sec
)))))
766 /* There is no suitable symbol. */
774 return sorted_syms
[thisplace
];
777 /* Print an address to INFO symbolically. */
780 objdump_print_addr_with_sym (abfd
, sec
, sym
, vma
, info
, skip_zeroes
)
785 struct disassemble_info
*info
;
788 objdump_print_value (vma
, info
, skip_zeroes
);
794 (*info
->fprintf_func
) (info
->stream
, " <%s",
795 bfd_get_section_name (abfd
, sec
));
796 secaddr
= bfd_get_section_vma (abfd
, sec
);
799 (*info
->fprintf_func
) (info
->stream
, "-0x");
800 objdump_print_value (secaddr
- vma
, info
, true);
802 else if (vma
> secaddr
)
804 (*info
->fprintf_func
) (info
->stream
, "+0x");
805 objdump_print_value (vma
- secaddr
, info
, true);
807 (*info
->fprintf_func
) (info
->stream
, ">");
811 (*info
->fprintf_func
) (info
->stream
, " <");
812 objdump_print_symname (abfd
, info
, sym
);
813 if (bfd_asymbol_value (sym
) > vma
)
815 (*info
->fprintf_func
) (info
->stream
, "-0x");
816 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, true);
818 else if (vma
> bfd_asymbol_value (sym
))
820 (*info
->fprintf_func
) (info
->stream
, "+0x");
821 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, true);
823 (*info
->fprintf_func
) (info
->stream
, ">");
827 /* Print VMA to INFO, symbolically if possible. If SKIP_ZEROES is
828 true, don't output leading zeroes. */
831 objdump_print_addr (vma
, info
, skip_zeroes
)
833 struct disassemble_info
*info
;
836 struct objdump_disasm_info
*aux
;
839 if (sorted_symcount
< 1)
841 (*info
->fprintf_func
) (info
->stream
, "0x");
842 objdump_print_value (vma
, info
, skip_zeroes
);
846 aux
= (struct objdump_disasm_info
*) info
->application_data
;
847 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
849 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
853 /* Print VMA to INFO. This function is passed to the disassembler
857 objdump_print_address (vma
, info
)
859 struct disassemble_info
*info
;
861 objdump_print_addr (vma
, info
, ! prefix_addresses
);
864 /* Determine of the given address has a symbol associated with it. */
867 objdump_symbol_at_address (vma
, info
)
869 struct disassemble_info
* info
;
871 struct objdump_disasm_info
* aux
;
874 /* No symbols - do not bother checking. */
875 if (sorted_symcount
< 1)
878 aux
= (struct objdump_disasm_info
*) info
->application_data
;
879 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
882 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
885 /* Hold the last function name and the last line number we displayed
888 static char *prev_functionname
;
889 static unsigned int prev_line
;
891 /* We keep a list of all files that we have seen when doing a
892 dissassembly with source, so that we know how much of the file to
893 display. This can be important for inlined functions. */
895 struct print_file_list
897 struct print_file_list
*next
;
903 static struct print_file_list
*print_files
;
905 /* The number of preceding context lines to show when we start
906 displaying a file for the first time. */
908 #define SHOW_PRECEDING_CONTEXT_LINES (5)
910 /* Skip ahead to a given line in a file, optionally printing each
914 skip_to_line
PARAMS ((struct print_file_list
*, unsigned int, boolean
));
917 skip_to_line (p
, line
, show
)
918 struct print_file_list
*p
;
922 while (p
->line
< line
)
926 if (fgets (buf
, sizeof buf
, p
->f
) == NULL
)
936 if (strchr (buf
, '\n') != NULL
)
941 /* Show the line number, or the source line, in a dissassembly
945 show_line (abfd
, section
, addr_offset
)
950 const char *filename
;
951 const char *functionname
;
954 if (! with_line_numbers
&& ! with_source_code
)
957 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
958 &functionname
, &line
))
961 if (filename
!= NULL
&& *filename
== '\0')
963 if (functionname
!= NULL
&& *functionname
== '\0')
966 if (with_line_numbers
)
968 if (functionname
!= NULL
969 && (prev_functionname
== NULL
970 || strcmp (functionname
, prev_functionname
) != 0))
971 printf ("%s():\n", functionname
);
972 if (line
> 0 && line
!= prev_line
)
973 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
980 struct print_file_list
**pp
, *p
;
982 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
983 if (strcmp ((*pp
)->filename
, filename
) == 0)
989 if (p
!= print_files
)
993 /* We have reencountered a file name which we saw
994 earlier. This implies that either we are dumping out
995 code from an included file, or the same file was
996 linked in more than once. There are two common cases
997 of an included file: inline functions in a header
998 file, and a bison or flex skeleton file. In the
999 former case we want to just start printing (but we
1000 back up a few lines to give context); in the latter
1001 case we want to continue from where we left off. I
1002 can't think of a good way to distinguish the cases,
1003 so I used a heuristic based on the file name. */
1004 if (strcmp (p
->filename
+ strlen (p
->filename
) - 2, ".h") != 0)
1008 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1015 p
->f
= fopen (p
->filename
, "r");
1019 skip_to_line (p
, l
, false);
1021 if (print_files
->f
!= NULL
)
1023 fclose (print_files
->f
);
1024 print_files
->f
= NULL
;
1030 skip_to_line (p
, line
, true);
1032 p
->next
= print_files
;
1040 f
= fopen (filename
, "r");
1045 p
= ((struct print_file_list
*)
1046 xmalloc (sizeof (struct print_file_list
)));
1047 p
->filename
= xmalloc (strlen (filename
) + 1);
1048 strcpy (p
->filename
, filename
);
1052 if (print_files
!= NULL
&& print_files
->f
!= NULL
)
1054 fclose (print_files
->f
);
1055 print_files
->f
= NULL
;
1057 p
->next
= print_files
;
1060 if (file_start_context
)
1063 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1066 skip_to_line (p
, l
, false);
1068 skip_to_line (p
, line
, true);
1073 if (functionname
!= NULL
1074 && (prev_functionname
== NULL
1075 || strcmp (functionname
, prev_functionname
) != 0))
1077 if (prev_functionname
!= NULL
)
1078 free (prev_functionname
);
1079 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1080 strcpy (prev_functionname
, functionname
);
1083 if (line
> 0 && line
!= prev_line
)
1087 /* Pseudo FILE object for strings. */
1095 /* sprintf to a "stream" */
1098 objdump_sprintf
VPARAMS ((SFILE
*f
, const char *format
, ...))
1103 VA_OPEN (args
, format
);
1104 VA_FIXEDARG (args
, SFILE
*, f
);
1105 VA_FIXEDARG (args
, const char *, format
);
1107 vasprintf (&buf
, format
, args
);
1112 fatal (_("Out of virtual memory"));
1117 while ((size_t) ((f
->buffer
+ f
->size
) - f
->current
) < n
+ 1)
1121 curroff
= f
->current
- f
->buffer
;
1123 f
->buffer
= xrealloc (f
->buffer
, f
->size
);
1124 f
->current
= f
->buffer
+ curroff
;
1127 memcpy (f
->current
, buf
, n
);
1129 f
->current
[0] = '\0';
1137 /* The number of zeroes we want to see before we start skipping them.
1138 The number is arbitrarily chosen. */
1141 #define SKIP_ZEROES (8)
1144 /* The number of zeroes to skip at the end of a section. If the
1145 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1146 SKIP_ZEROES, they will be disassembled. If there are fewer than
1147 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1148 attempt to avoid disassembling zeroes inserted by section
1151 #ifndef SKIP_ZEROES_AT_END
1152 #define SKIP_ZEROES_AT_END (3)
1155 /* Disassemble some data in memory between given values. */
1158 disassemble_bytes (info
, disassemble_fn
, insns
, data
,
1159 start_offset
, stop_offset
, relppp
,
1161 struct disassemble_info
*info
;
1162 disassembler_ftype disassemble_fn
;
1165 bfd_vma start_offset
;
1166 bfd_vma stop_offset
;
1170 struct objdump_disasm_info
*aux
;
1172 int octets_per_line
;
1174 int skip_addr_chars
;
1175 bfd_vma addr_offset
;
1176 int opb
= info
->octets_per_byte
;
1178 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1182 octets_per_line
= 4;
1184 octets_per_line
= 16;
1186 /* Figure out how many characters to skip at the start of an
1187 address, to make the disassembly look nicer. We discard leading
1188 zeroes in chunks of 4, ensuring that there is always a leading
1190 skip_addr_chars
= 0;
1191 if (! prefix_addresses
)
1199 + bfd_section_size (section
->owner
, section
) / opb
));
1201 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1204 skip_addr_chars
+= 4;
1209 info
->insn_info_valid
= 0;
1212 addr_offset
= start_offset
;
1213 while (addr_offset
< stop_offset
)
1217 boolean need_nl
= false;
1219 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1221 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1224 if (! disassemble_zeroes
1225 && (info
->insn_info_valid
== 0
1226 || info
->branch_delay_insns
== 0)
1227 && (z
- addr_offset
* opb
>= SKIP_ZEROES
1228 || (z
== stop_offset
* opb
&&
1229 z
- addr_offset
* opb
< SKIP_ZEROES_AT_END
)))
1233 /* If there are more nonzero octets to follow, we only skip
1234 zeroes in multiples of 4, to try to avoid running over
1235 the start of an instruction which happens to start with
1237 if (z
!= stop_offset
* opb
)
1238 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1240 octets
= z
- addr_offset
* opb
;
1251 if (with_line_numbers
|| with_source_code
)
1252 /* The line number tables will refer to unadjusted
1253 section VMAs, so we must undo any VMA modifications
1254 when calling show_line. */
1255 show_line (aux
->abfd
, section
, addr_offset
- adjust_section_vma
);
1257 if (! prefix_addresses
)
1261 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1262 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1266 printf ("%s:\t", buf
+ skip_addr_chars
);
1270 aux
->require_sec
= true;
1271 objdump_print_address (section
->vma
+ addr_offset
, info
);
1272 aux
->require_sec
= false;
1279 sfile
.buffer
= xmalloc (sfile
.size
);
1280 sfile
.current
= sfile
.buffer
;
1281 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1282 info
->stream
= (FILE *) &sfile
;
1283 info
->bytes_per_line
= 0;
1284 info
->bytes_per_chunk
= 0;
1286 #ifdef DISASSEMBLER_NEEDS_RELOCS
1287 /* FIXME: This is wrong. It tests the number of octets
1288 in the last instruction, not the current one. */
1289 if (*relppp
< relppend
1290 && (**relppp
)->address
>= addr_offset
1291 && (**relppp
)->address
<= addr_offset
+ octets
/ opb
)
1292 info
->flags
= INSN_HAS_RELOC
;
1297 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, info
);
1298 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1299 info
->stream
= stdout
;
1300 if (info
->bytes_per_line
!= 0)
1301 octets_per_line
= info
->bytes_per_line
;
1304 if (sfile
.current
!= sfile
.buffer
)
1305 printf ("%s\n", sfile
.buffer
);
1306 free (sfile
.buffer
);
1314 octets
= octets_per_line
;
1315 if (addr_offset
+ octets
/ opb
> stop_offset
)
1316 octets
= (stop_offset
- addr_offset
) * opb
;
1318 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1320 if (ISPRINT (data
[j
]))
1321 buf
[j
- addr_offset
* opb
] = data
[j
];
1323 buf
[j
- addr_offset
* opb
] = '.';
1325 buf
[j
- addr_offset
* opb
] = '\0';
1328 if (prefix_addresses
1330 : show_raw_insn
>= 0)
1334 /* If ! prefix_addresses and ! wide_output, we print
1335 octets_per_line octets per line. */
1337 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1338 pb
= octets_per_line
;
1340 if (info
->bytes_per_chunk
)
1341 bpc
= info
->bytes_per_chunk
;
1345 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1348 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1350 for (k
= bpc
- 1; k
>= 0; k
--)
1351 printf ("%02x", (unsigned) data
[j
+ k
]);
1356 for (k
= 0; k
< bpc
; k
++)
1357 printf ("%02x", (unsigned) data
[j
+ k
]);
1362 for (; pb
< octets_per_line
; pb
+= bpc
)
1366 for (k
= 0; k
< bpc
; k
++)
1371 /* Separate raw data from instruction by extra space. */
1382 printf ("%s", sfile
.buffer
);
1383 free (sfile
.buffer
);
1386 if (prefix_addresses
1388 : show_raw_insn
>= 0)
1396 j
= addr_offset
* opb
+ pb
;
1398 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1399 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1403 printf ("%s:\t", buf
+ skip_addr_chars
);
1405 pb
+= octets_per_line
;
1408 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1412 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1414 for (k
= bpc
- 1; k
>= 0; k
--)
1415 printf ("%02x", (unsigned) data
[j
+ k
]);
1420 for (k
= 0; k
< bpc
; k
++)
1421 printf ("%02x", (unsigned) data
[j
+ k
]);
1434 if ((section
->flags
& SEC_RELOC
) != 0
1435 #ifndef DISASSEMBLER_NEEDS_RELOCS
1440 while ((*relppp
) < relppend
1441 && ((**relppp
)->address
>= (bfd_vma
) addr_offset
1442 && (**relppp
)->address
< (bfd_vma
) addr_offset
+ octets
/ opb
))
1443 #ifdef DISASSEMBLER_NEEDS_RELOCS
1444 if (! dump_reloc_info
)
1458 objdump_print_value (section
->vma
+ q
->address
, info
, true);
1460 printf (": %s\t", q
->howto
->name
);
1462 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1463 printf ("*unknown*");
1466 const char *sym_name
;
1468 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1469 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1470 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1475 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1476 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1477 if (sym_name
== NULL
|| *sym_name
== '\0')
1478 sym_name
= "*unknown*";
1479 printf ("%s", sym_name
);
1486 objdump_print_value (q
->addend
, info
, true);
1498 addr_offset
+= octets
/ opb
;
1502 /* Disassemble the contents of an object file. */
1505 disassemble_data (abfd
)
1508 unsigned long addr_offset
;
1509 disassembler_ftype disassemble_fn
;
1510 struct disassemble_info disasm_info
;
1511 struct objdump_disasm_info aux
;
1516 prev_functionname
= NULL
;
1519 /* We make a copy of syms to sort. We don't want to sort syms
1520 because that will screw up the relocs. */
1521 sorted_syms
= (asymbol
**) xmalloc (symcount
* sizeof (asymbol
*));
1522 memcpy (sorted_syms
, syms
, symcount
* sizeof (asymbol
*));
1524 sorted_symcount
= remove_useless_symbols (sorted_syms
, symcount
);
1526 /* Sort the symbols into section and symbol order */
1527 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1529 INIT_DISASSEMBLE_INFO(disasm_info
, stdout
, fprintf
);
1530 disasm_info
.application_data
= (PTR
) &aux
;
1532 aux
.require_sec
= false;
1533 disasm_info
.print_address_func
= objdump_print_address
;
1534 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1536 if (machine
!= (char *) NULL
)
1538 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1541 fatal (_("Can't use supplied machine %s"), machine
);
1543 abfd
->arch_info
= info
;
1546 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1548 struct bfd_target
*xvec
;
1550 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
1551 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1552 xvec
->byteorder
= endian
;
1556 disassemble_fn
= disassembler (abfd
);
1557 if (!disassemble_fn
)
1559 non_fatal (_("Can't disassemble for architecture %s\n"),
1560 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1565 opb
= bfd_octets_per_byte (abfd
);
1567 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1568 disasm_info
.arch
= bfd_get_arch (abfd
);
1569 disasm_info
.mach
= bfd_get_mach (abfd
);
1570 disasm_info
.disassembler_options
= disassembler_options
;
1571 disasm_info
.octets_per_byte
= opb
;
1573 if (bfd_big_endian (abfd
))
1574 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1575 else if (bfd_little_endian (abfd
))
1576 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1578 /* ??? Aborting here seems too drastic. We could default to big or little
1580 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1582 for (section
= abfd
->sections
;
1583 section
!= (asection
*) NULL
;
1584 section
= section
->next
)
1586 bfd_byte
*data
= NULL
;
1587 bfd_size_type datasize
= 0;
1588 arelent
**relbuf
= NULL
;
1589 arelent
**relpp
= NULL
;
1590 arelent
**relppend
= NULL
;
1591 unsigned long stop_offset
;
1592 asymbol
*sym
= NULL
;
1595 if ((section
->flags
& SEC_LOAD
) == 0
1596 || (! disassemble_all
1598 && (section
->flags
& SEC_CODE
) == 0))
1600 if (only
!= (char *) NULL
&& strcmp (only
, section
->name
) != 0)
1603 if ((section
->flags
& SEC_RELOC
) != 0
1604 #ifndef DISASSEMBLER_NEEDS_RELOCS
1611 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1613 bfd_fatal (bfd_get_filename (abfd
));
1619 relbuf
= (arelent
**) xmalloc (relsize
);
1620 relcount
= bfd_canonicalize_reloc (abfd
, section
, relbuf
, syms
);
1622 bfd_fatal (bfd_get_filename (abfd
));
1624 /* Sort the relocs by address. */
1625 qsort (relbuf
, relcount
, sizeof (arelent
*), compare_relocs
);
1628 relppend
= relpp
+ relcount
;
1630 /* Skip over the relocs belonging to addresses below the
1632 if (start_address
!= (bfd_vma
) -1)
1634 while (relpp
< relppend
1635 && (*relpp
)->address
< start_address
)
1641 printf (_("Disassembly of section %s:\n"), section
->name
);
1643 datasize
= bfd_get_section_size_before_reloc (section
);
1647 data
= (bfd_byte
*) xmalloc ((size_t) datasize
);
1649 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1652 disasm_info
.buffer
= data
;
1653 disasm_info
.buffer_vma
= section
->vma
;
1654 disasm_info
.buffer_length
= datasize
;
1655 disasm_info
.section
= section
;
1656 if (start_address
== (bfd_vma
) -1
1657 || start_address
< disasm_info
.buffer_vma
)
1660 addr_offset
= start_address
- disasm_info
.buffer_vma
;
1661 if (stop_address
== (bfd_vma
) -1)
1662 stop_offset
= datasize
/ opb
;
1665 if (stop_address
< disasm_info
.buffer_vma
)
1668 stop_offset
= stop_address
- disasm_info
.buffer_vma
;
1669 if (stop_offset
> disasm_info
.buffer_length
/ opb
)
1670 stop_offset
= disasm_info
.buffer_length
/ opb
;
1673 sym
= find_symbol_for_address (abfd
, section
, section
->vma
+ addr_offset
,
1676 while (addr_offset
< stop_offset
)
1679 unsigned long nextstop_offset
;
1682 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= section
->vma
+ addr_offset
)
1687 (x
< sorted_symcount
1688 && bfd_asymbol_value (sorted_syms
[x
]) <= section
->vma
+ addr_offset
);
1691 disasm_info
.symbols
= & sorted_syms
[place
];
1692 disasm_info
.num_symbols
= x
- place
;
1695 disasm_info
.symbols
= NULL
;
1697 if (! prefix_addresses
)
1700 objdump_print_addr_with_sym (abfd
, section
, sym
,
1701 section
->vma
+ addr_offset
,
1707 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
)
1709 else if (sym
== NULL
)
1713 /* Search forward for the next appropriate symbol in
1714 SECTION. Note that all the symbols are sorted
1715 together into one big array, and that some sections
1716 may have overlapping addresses. */
1717 while (place
< sorted_symcount
1718 && (sorted_syms
[place
]->section
!= section
1719 || (bfd_asymbol_value (sorted_syms
[place
])
1720 <= bfd_asymbol_value (sym
))))
1722 if (place
>= sorted_symcount
)
1725 nextsym
= sorted_syms
[place
];
1728 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
)
1730 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1731 if (nextstop_offset
> stop_offset
)
1732 nextstop_offset
= stop_offset
;
1734 else if (nextsym
== NULL
)
1735 nextstop_offset
= stop_offset
;
1738 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1739 if (nextstop_offset
> stop_offset
)
1740 nextstop_offset
= stop_offset
;
1743 /* If a symbol is explicitly marked as being an object
1744 rather than a function, just dump the bytes without
1745 disassembling them. */
1748 || bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
1749 || ((sym
->flags
& BSF_OBJECT
) == 0
1750 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1752 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1754 || (sym
->flags
& BSF_FUNCTION
) != 0)
1759 disassemble_bytes (&disasm_info
, disassemble_fn
, insns
, data
,
1760 addr_offset
, nextstop_offset
, &relpp
, relppend
);
1762 addr_offset
= nextstop_offset
;
1774 /* Define a table of stab values and print-strings. We wish the initializer
1775 could be a direct-mapped table, but instead we build one the first
1778 static void dump_section_stabs
PARAMS ((bfd
*abfd
, char *stabsect_name
,
1779 char *strsect_name
));
1781 /* Dump the stabs sections from an object file that has a section that
1782 uses Sun stabs encoding. */
1788 dump_section_stabs (abfd
, ".stab", ".stabstr");
1789 dump_section_stabs (abfd
, ".stab.excl", ".stab.exclstr");
1790 dump_section_stabs (abfd
, ".stab.index", ".stab.indexstr");
1791 dump_section_stabs (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1794 static bfd_byte
*stabs
;
1795 static bfd_size_type stab_size
;
1797 static char *strtab
;
1798 static bfd_size_type stabstr_size
;
1800 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1801 and string table section STRSECT_NAME into `strtab'.
1802 If the section exists and was read, allocate the space and return true.
1803 Otherwise return false. */
1806 read_section_stabs (abfd
, stabsect_name
, strsect_name
)
1808 const char *stabsect_name
;
1809 const char *strsect_name
;
1811 asection
*stabsect
, *stabstrsect
;
1813 stabsect
= bfd_get_section_by_name (abfd
, stabsect_name
);
1816 printf (_("No %s section present\n\n"), stabsect_name
);
1820 stabstrsect
= bfd_get_section_by_name (abfd
, strsect_name
);
1821 if (0 == stabstrsect
)
1823 non_fatal (_("%s has no %s section"),
1824 bfd_get_filename (abfd
), strsect_name
);
1829 stab_size
= bfd_section_size (abfd
, stabsect
);
1830 stabstr_size
= bfd_section_size (abfd
, stabstrsect
);
1832 stabs
= (bfd_byte
*) xmalloc (stab_size
);
1833 strtab
= (char *) xmalloc (stabstr_size
);
1835 if (! bfd_get_section_contents (abfd
, stabsect
, (PTR
) stabs
, 0, stab_size
))
1837 non_fatal (_("Reading %s section of %s failed: %s"),
1838 stabsect_name
, bfd_get_filename (abfd
),
1839 bfd_errmsg (bfd_get_error ()));
1846 if (! bfd_get_section_contents (abfd
, stabstrsect
, (PTR
) strtab
, 0,
1849 non_fatal (_("Reading %s section of %s failed: %s\n"),
1850 strsect_name
, bfd_get_filename (abfd
),
1851 bfd_errmsg (bfd_get_error ()));
1861 /* Stabs entries use a 12 byte format:
1862 4 byte string table index
1864 1 byte stab other field
1865 2 byte stab desc field
1867 FIXME: This will have to change for a 64 bit object format. */
1869 #define STRDXOFF (0)
1871 #define OTHEROFF (5)
1874 #define STABSIZE (12)
1876 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1877 using string table section STRSECT_NAME (in `strtab'). */
1880 print_section_stabs (abfd
, stabsect_name
, strsect_name
)
1882 const char *stabsect_name
;
1883 const char *strsect_name ATTRIBUTE_UNUSED
;
1886 unsigned file_string_table_offset
= 0, next_file_string_table_offset
= 0;
1887 bfd_byte
*stabp
, *stabs_end
;
1890 stabs_end
= stabp
+ stab_size
;
1892 printf (_("Contents of %s section:\n\n"), stabsect_name
);
1893 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1895 /* Loop through all symbols and print them.
1897 We start the index at -1 because there is a dummy symbol on
1898 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1900 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
1904 unsigned char type
, other
;
1905 unsigned short desc
;
1908 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
1909 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
1910 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
1911 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
1912 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
1914 printf ("\n%-6d ", i
);
1915 /* Either print the stab name, or, if unnamed, print its number
1916 again (makes consistent formatting for tools like awk). */
1917 name
= bfd_get_stab_name (type
);
1919 printf ("%-6s", name
);
1920 else if (type
== N_UNDF
)
1923 printf ("%-6d", type
);
1924 printf (" %-6d %-6d ", other
, desc
);
1925 bfd_printf_vma (abfd
, value
);
1926 printf (" %-6lu", strx
);
1928 /* Symbols with type == 0 (N_UNDF) specify the length of the
1929 string table associated with this file. We use that info
1930 to know how to relocate the *next* file's string table indices. */
1934 file_string_table_offset
= next_file_string_table_offset
;
1935 next_file_string_table_offset
+= value
;
1939 /* Using the (possibly updated) string table offset, print the
1940 string (if any) associated with this symbol. */
1942 if ((strx
+ file_string_table_offset
) < stabstr_size
)
1943 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
1952 dump_section_stabs (abfd
, stabsect_name
, strsect_name
)
1954 char *stabsect_name
;
1959 /* Check for section names for which stabsect_name is a prefix, to
1960 handle .stab0, etc. */
1961 for (s
= abfd
->sections
;
1967 len
= strlen (stabsect_name
);
1969 /* If the prefix matches, and the files section name ends with a
1970 nul or a digit, then we match. I.e., we want either an exact
1971 match or a section followed by a number. */
1972 if (strncmp (stabsect_name
, s
->name
, len
) == 0
1973 && (s
->name
[len
] == '\000'
1974 || ISDIGIT (s
->name
[len
])))
1976 if (read_section_stabs (abfd
, s
->name
, strsect_name
))
1978 print_section_stabs (abfd
, s
->name
, strsect_name
);
1987 dump_bfd_header (abfd
)
1992 printf (_("architecture: %s, "),
1993 bfd_printable_arch_mach (bfd_get_arch (abfd
),
1994 bfd_get_mach (abfd
)));
1995 printf (_("flags 0x%08x:\n"), abfd
->flags
);
1997 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
1998 PF (HAS_RELOC
, "HAS_RELOC");
1999 PF (EXEC_P
, "EXEC_P");
2000 PF (HAS_LINENO
, "HAS_LINENO");
2001 PF (HAS_DEBUG
, "HAS_DEBUG");
2002 PF (HAS_SYMS
, "HAS_SYMS");
2003 PF (HAS_LOCALS
, "HAS_LOCALS");
2004 PF (DYNAMIC
, "DYNAMIC");
2005 PF (WP_TEXT
, "WP_TEXT");
2006 PF (D_PAGED
, "D_PAGED");
2007 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2008 PF (HAS_LOAD_PAGE
, "HAS_LOAD_PAGE");
2009 printf (_("\nstart address 0x"));
2010 bfd_printf_vma (abfd
, abfd
->start_address
);
2015 dump_bfd_private_header (abfd
)
2018 bfd_print_private_bfd_data (abfd
, stdout
);
2021 /* Dump selected contents of ABFD */
2027 /* If we are adjusting section VMA's, change them all now. Changing
2028 the BFD information is a hack. However, we must do it, or
2029 bfd_find_nearest_line will not do the right thing. */
2030 if (adjust_section_vma
!= 0)
2034 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2036 s
->vma
+= adjust_section_vma
;
2037 s
->lma
+= adjust_section_vma
;
2042 print_arelt_descr (stdout
, abfd
, true);
2043 if (dump_file_header
)
2044 dump_bfd_header (abfd
);
2045 if (dump_private_headers
)
2046 dump_bfd_private_header (abfd
);
2048 if (dump_section_headers
)
2049 dump_headers (abfd
);
2051 if (dump_symtab
|| dump_reloc_info
|| disassemble
|| dump_debugging
)
2052 syms
= slurp_symtab (abfd
);
2053 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
)
2054 dynsyms
= slurp_dynamic_symtab (abfd
);
2057 dump_symbols (abfd
, false);
2058 if (dump_dynamic_symtab
)
2059 dump_symbols (abfd
, true);
2060 if (dump_stab_section_info
)
2062 if (dump_reloc_info
&& ! disassemble
)
2064 if (dump_dynamic_reloc_info
)
2065 dump_dynamic_relocs (abfd
);
2066 if (dump_section_contents
)
2069 disassemble_data (abfd
);
2074 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2075 if (dhandle
!= NULL
)
2077 if (! print_debugging_info (stdout
, dhandle
))
2079 non_fatal (_("%s: printing debugging information failed"),
2080 bfd_get_filename (abfd
));
2105 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2111 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2113 nonfatal (bfd_get_filename (abfd
));
2114 list_matching_formats (matching
);
2119 if (bfd_get_error () != bfd_error_file_not_recognized
)
2121 nonfatal (bfd_get_filename (abfd
));
2125 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
2131 nonfatal (bfd_get_filename (abfd
));
2133 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2135 list_matching_formats (matching
);
2141 display_file (filename
, target
)
2145 bfd
*file
, *arfile
= (bfd
*) NULL
;
2147 file
= bfd_openr (filename
, target
);
2150 nonfatal (filename
);
2154 if (bfd_check_format (file
, bfd_archive
) == true)
2156 bfd
*last_arfile
= NULL
;
2158 printf (_("In archive %s:\n"), bfd_get_filename (file
));
2161 bfd_set_error (bfd_error_no_error
);
2163 arfile
= bfd_openr_next_archived_file (file
, arfile
);
2166 if (bfd_get_error () != bfd_error_no_more_archived_files
)
2167 nonfatal (bfd_get_filename (file
));
2171 display_bfd (arfile
);
2173 if (last_arfile
!= NULL
)
2174 bfd_close (last_arfile
);
2175 last_arfile
= arfile
;
2178 if (last_arfile
!= NULL
)
2179 bfd_close (last_arfile
);
2187 /* Actually display the various requested regions */
2195 bfd_size_type datasize
= 0;
2196 bfd_size_type addr_offset
;
2197 bfd_size_type start_offset
, stop_offset
;
2198 unsigned int opb
= bfd_octets_per_byte (abfd
);
2200 for (section
= abfd
->sections
; section
!= NULL
; section
=
2205 if (only
== (char *) NULL
||
2206 strcmp (only
, section
->name
) == 0)
2208 if (section
->flags
& SEC_HAS_CONTENTS
)
2210 printf (_("Contents of section %s:\n"), section
->name
);
2212 if (bfd_section_size (abfd
, section
) == 0)
2214 data
= (bfd_byte
*) xmalloc ((size_t) bfd_section_size (abfd
, section
));
2215 datasize
= bfd_section_size (abfd
, section
);
2218 bfd_get_section_contents (abfd
, section
, (PTR
) data
, 0, bfd_section_size (abfd
, section
));
2220 if (start_address
== (bfd_vma
) -1
2221 || start_address
< section
->vma
)
2224 start_offset
= start_address
- section
->vma
;
2225 if (stop_address
== (bfd_vma
) -1)
2226 stop_offset
= bfd_section_size (abfd
, section
) / opb
;
2229 if (stop_address
< section
->vma
)
2232 stop_offset
= stop_address
- section
->vma
;
2233 if (stop_offset
> bfd_section_size (abfd
, section
) / opb
)
2234 stop_offset
= bfd_section_size (abfd
, section
) / opb
;
2236 for (addr_offset
= start_offset
;
2237 addr_offset
< stop_offset
; addr_offset
+= onaline
)
2241 printf (" %04lx ", (unsigned long int)
2242 (addr_offset
+ section
->vma
));
2243 for (j
= addr_offset
* opb
;
2244 j
< addr_offset
* opb
+ onaline
; j
++)
2246 if (j
< stop_offset
* opb
)
2247 printf ("%02x", (unsigned) (data
[j
]));
2255 for (j
= addr_offset
; j
< addr_offset
* opb
+ onaline
; j
++)
2257 if (j
>= stop_offset
* opb
)
2260 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2270 /* Should perhaps share code and display with nm? */
2272 dump_symbols (abfd
, dynamic
)
2273 bfd
*abfd ATTRIBUTE_UNUSED
;
2284 printf ("DYNAMIC SYMBOL TABLE:\n");
2290 printf ("SYMBOL TABLE:\n");
2294 printf (_("no symbols\n"));
2296 for (count
= 0; count
< max
; count
++)
2300 bfd
*cur_bfd
= bfd_asymbol_bfd (*current
);
2302 if (cur_bfd
!= NULL
)
2307 name
= (*current
)->name
;
2309 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2311 /* If we want to demangle the name, we demangle it
2312 here, and temporarily clobber it while calling
2313 bfd_print_symbol. FIXME: This is a gross hack. */
2315 alloc
= demangle (cur_bfd
, name
);
2316 (*current
)->name
= alloc
;
2319 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2320 bfd_print_symbol_all
);
2322 (*current
)->name
= name
;
2343 for (a
= abfd
->sections
; a
!= (asection
*) NULL
; a
= a
->next
)
2347 if (bfd_is_abs_section (a
))
2349 if (bfd_is_und_section (a
))
2351 if (bfd_is_com_section (a
))
2356 if (strcmp (only
, a
->name
))
2359 else if ((a
->flags
& SEC_RELOC
) == 0)
2362 relsize
= bfd_get_reloc_upper_bound (abfd
, a
);
2364 bfd_fatal (bfd_get_filename (abfd
));
2366 printf ("RELOCATION RECORDS FOR [%s]:", a
->name
);
2370 printf (" (none)\n\n");
2374 relpp
= (arelent
**) xmalloc (relsize
);
2375 relcount
= bfd_canonicalize_reloc (abfd
, a
, relpp
, syms
);
2377 bfd_fatal (bfd_get_filename (abfd
));
2378 else if (relcount
== 0)
2380 printf (" (none)\n\n");
2385 dump_reloc_set (abfd
, a
, relpp
, relcount
);
2394 dump_dynamic_relocs (abfd
)
2401 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2403 bfd_fatal (bfd_get_filename (abfd
));
2405 printf ("DYNAMIC RELOCATION RECORDS");
2409 printf (" (none)\n\n");
2413 relpp
= (arelent
**) xmalloc (relsize
);
2414 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2416 bfd_fatal (bfd_get_filename (abfd
));
2417 else if (relcount
== 0)
2419 printf (" (none)\n\n");
2424 dump_reloc_set (abfd
, (asection
*) NULL
, relpp
, relcount
);
2432 dump_reloc_set (abfd
, sec
, relpp
, relcount
)
2439 char *last_filename
, *last_functionname
;
2440 unsigned int last_line
;
2442 /* Get column headers lined up reasonably. */
2448 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2449 width
= strlen (buf
) - 7;
2451 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2454 last_filename
= NULL
;
2455 last_functionname
= NULL
;
2458 for (p
= relpp
; relcount
&& *p
!= (arelent
*) NULL
; p
++, relcount
--)
2461 const char *filename
, *functionname
;
2463 const char *sym_name
;
2464 const char *section_name
;
2466 if (start_address
!= (bfd_vma
) -1
2467 && q
->address
< start_address
)
2469 if (stop_address
!= (bfd_vma
) -1
2470 && q
->address
> stop_address
)
2473 if (with_line_numbers
2475 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2476 &filename
, &functionname
, &line
))
2478 if (functionname
!= NULL
2479 && (last_functionname
== NULL
2480 || strcmp (functionname
, last_functionname
) != 0))
2482 printf ("%s():\n", functionname
);
2483 if (last_functionname
!= NULL
)
2484 free (last_functionname
);
2485 last_functionname
= xstrdup (functionname
);
2488 && (line
!= last_line
2489 || (filename
!= NULL
2490 && last_filename
!= NULL
2491 && strcmp (filename
, last_filename
) != 0)))
2493 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2495 if (last_filename
!= NULL
)
2496 free (last_filename
);
2497 if (filename
== NULL
)
2498 last_filename
= NULL
;
2500 last_filename
= xstrdup (filename
);
2504 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2506 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2507 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2512 section_name
= NULL
;
2516 bfd_printf_vma (abfd
, q
->address
);
2518 printf (" %-16s ", q
->howto
->name
);
2520 printf (" %-16d ", q
->howto
->type
);
2521 objdump_print_symname (abfd
, (struct disassemble_info
*) NULL
,
2526 if (section_name
== (const char *) NULL
)
2527 section_name
= "*unknown*";
2528 bfd_printf_vma (abfd
, q
->address
);
2529 printf (" %-16s [%s]",
2536 bfd_printf_vma (abfd
, q
->addend
);
2542 /* The length of the longest architecture name + 1. */
2543 #define LONGEST_ARCH sizeof("powerpc:common")
2546 endian_string (endian
)
2547 enum bfd_endian endian
;
2549 if (endian
== BFD_ENDIAN_BIG
)
2550 return "big endian";
2551 else if (endian
== BFD_ENDIAN_LITTLE
)
2552 return "little endian";
2554 return "endianness unknown";
2557 /* List the targets that BFD is configured to support, each followed
2558 by its endianness and the architectures it supports. */
2561 display_target_list ()
2563 extern const bfd_target
*const *bfd_target_vector
;
2567 dummy_name
= make_temp_file (NULL
);
2568 for (t
= 0; bfd_target_vector
[t
]; t
++)
2570 const bfd_target
*p
= bfd_target_vector
[t
];
2571 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2574 printf ("%s\n (header %s, data %s)\n", p
->name
,
2575 endian_string (p
->header_byteorder
),
2576 endian_string (p
->byteorder
));
2580 nonfatal (dummy_name
);
2584 if (! bfd_set_format (abfd
, bfd_object
))
2586 if (bfd_get_error () != bfd_error_invalid_operation
)
2588 bfd_close_all_done (abfd
);
2592 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2593 if (bfd_set_arch_mach (abfd
, (enum bfd_architecture
) a
, 0))
2595 bfd_printable_arch_mach ((enum bfd_architecture
) a
, 0));
2596 bfd_close_all_done (abfd
);
2598 unlink (dummy_name
);
2602 /* Print a table showing which architectures are supported for entries
2603 FIRST through LAST-1 of bfd_target_vector (targets across,
2604 architectures down). */
2607 display_info_table (first
, last
)
2611 extern const bfd_target
*const *bfd_target_vector
;
2615 /* Print heading of target names. */
2616 printf ("\n%*s", (int) LONGEST_ARCH
, " ");
2617 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2618 printf ("%s ", bfd_target_vector
[t
]->name
);
2621 dummy_name
= make_temp_file (NULL
);
2622 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2623 if (strcmp (bfd_printable_arch_mach (a
, 0), "UNKNOWN!") != 0)
2625 printf ("%*s ", (int) LONGEST_ARCH
- 1,
2626 bfd_printable_arch_mach (a
, 0));
2627 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2629 const bfd_target
*p
= bfd_target_vector
[t
];
2631 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2641 if (! bfd_set_format (abfd
, bfd_object
))
2643 if (bfd_get_error () != bfd_error_invalid_operation
)
2651 if (! bfd_set_arch_mach (abfd
, a
, 0))
2656 printf ("%s ", p
->name
);
2659 int l
= strlen (p
->name
);
2665 bfd_close_all_done (abfd
);
2669 unlink (dummy_name
);
2673 /* Print tables of all the target-architecture combinations that
2674 BFD has been configured to support. */
2677 display_target_tables ()
2680 extern const bfd_target
*const *bfd_target_vector
;
2684 colum
= getenv ("COLUMNS");
2686 columns
= atoi (colum
);
2691 while (bfd_target_vector
[t
] != NULL
)
2695 wid
= LONGEST_ARCH
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2697 while (wid
< columns
&& bfd_target_vector
[t
] != NULL
)
2701 newwid
= wid
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2702 if (newwid
>= columns
)
2707 display_info_table (oldt
, t
);
2714 printf (_("BFD header file version %s\n"), BFD_VERSION_STRING
);
2715 display_target_list ();
2716 display_target_tables ();
2719 int main
PARAMS ((int, char **));
2727 char *target
= default_target
;
2728 boolean seenflag
= false;
2730 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
2731 setlocale (LC_MESSAGES
, "");
2733 #if defined (HAVE_SETLOCALE)
2734 setlocale (LC_CTYPE
, "");
2736 bindtextdomain (PACKAGE
, LOCALEDIR
);
2737 textdomain (PACKAGE
);
2739 program_name
= *argv
;
2740 xmalloc_set_program_name (program_name
);
2742 START_PROGRESS (program_name
, 0);
2745 set_default_bfd_target ();
2747 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VvCdDlfaHhrRtTxsSj:wE:zgG",
2748 long_options
, (int *) 0))
2754 break; /* We've been given a long option. */
2759 disassembler_options
= optarg
;
2765 with_line_numbers
= true;
2774 enum demangling_styles style
;
2776 style
= cplus_demangle_name_to_style (optarg
);
2777 if (style
== unknown_demangling
)
2778 fatal (_("unknown demangling style `%s'"),
2781 cplus_demangle_set_style (style
);
2787 case OPTION_ADJUST_VMA
:
2788 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
2790 case OPTION_START_ADDRESS
:
2791 start_address
= parse_vma (optarg
, "--start-address");
2793 case OPTION_STOP_ADDRESS
:
2794 stop_address
= parse_vma (optarg
, "--stop-address");
2797 if (strcmp (optarg
, "B") == 0)
2798 endian
= BFD_ENDIAN_BIG
;
2799 else if (strcmp (optarg
, "L") == 0)
2800 endian
= BFD_ENDIAN_LITTLE
;
2803 non_fatal (_("unrecognized -E option"));
2808 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
2809 endian
= BFD_ENDIAN_BIG
;
2810 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
2811 endian
= BFD_ENDIAN_LITTLE
;
2814 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
2820 dump_file_header
= true;
2824 formats_info
= true;
2828 dump_private_headers
= true;
2832 dump_private_headers
= true;
2834 dump_reloc_info
= true;
2835 dump_file_header
= true;
2836 dump_ar_hdrs
= true;
2837 dump_section_headers
= true;
2845 dump_dynamic_symtab
= true;
2853 disassemble_zeroes
= true;
2857 disassemble_all
= true;
2862 with_source_code
= true;
2870 dump_stab_section_info
= true;
2874 dump_section_contents
= true;
2878 dump_reloc_info
= true;
2882 dump_dynamic_reloc_info
= true;
2886 dump_ar_hdrs
= true;
2890 dump_section_headers
= true;
2898 show_version
= true;
2908 print_version ("objdump");
2910 if (seenflag
== false)
2918 display_file ("a.out", target
);
2920 for (; optind
< argc
;)
2921 display_file (argv
[optind
++], target
);
2924 END_PROGRESS (program_name
);