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
{
83 /* Architecture to disassemble for, or default if NULL. */
84 static char *machine
= (char *) NULL
;
86 /* Target specific options to the disassembler. */
87 static char *disassembler_options
= (char *) NULL
;
89 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
90 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
92 /* The symbol table. */
93 static asymbol
**syms
;
95 /* Number of symbols in `syms'. */
96 static long symcount
= 0;
98 /* The sorted symbol table. */
99 static asymbol
**sorted_syms
;
101 /* Number of symbols in `sorted_syms'. */
102 static long sorted_symcount
= 0;
104 /* The dynamic symbol table. */
105 static asymbol
**dynsyms
;
107 /* Number of symbols in `dynsyms'. */
108 static long dynsymcount
= 0;
110 /* Static declarations. */
112 static void usage
PARAMS ((FILE *, int));
113 static void nonfatal
PARAMS ((const char *));
114 static void display_file
PARAMS ((char *filename
, char *target
));
115 static void dump_section_header
PARAMS ((bfd
*, asection
*, PTR
));
116 static void dump_headers
PARAMS ((bfd
*));
117 static void dump_data
PARAMS ((bfd
*abfd
));
118 static void dump_relocs
PARAMS ((bfd
*abfd
));
119 static void dump_dynamic_relocs
PARAMS ((bfd
* abfd
));
120 static void dump_reloc_set
PARAMS ((bfd
*, asection
*, arelent
**, long));
121 static void dump_symbols
PARAMS ((bfd
*abfd
, boolean dynamic
));
122 static void dump_bfd_header
PARAMS ((bfd
*));
123 static void dump_bfd_private_header
PARAMS ((bfd
*));
124 static void dump_bfd
PARAMS ((bfd
*));
125 static void display_bfd
PARAMS ((bfd
*abfd
));
126 static void display_target_list
PARAMS ((void));
127 static void display_info_table
PARAMS ((int, int));
128 static void display_target_tables
PARAMS ((void));
129 static void display_info
PARAMS ((void));
130 static void objdump_print_value
131 PARAMS ((bfd_vma
, struct disassemble_info
*, boolean
));
132 static void objdump_print_symname
133 PARAMS ((bfd
*, struct disassemble_info
*, asymbol
*));
134 static asymbol
*find_symbol_for_address
135 PARAMS ((bfd
*, asection
*, bfd_vma
, boolean
, long *));
136 static void objdump_print_addr_with_sym
137 PARAMS ((bfd
*, asection
*, asymbol
*, bfd_vma
,
138 struct disassemble_info
*, boolean
));
139 static void objdump_print_addr
140 PARAMS ((bfd_vma
, struct disassemble_info
*, boolean
));
141 static void objdump_print_address
142 PARAMS ((bfd_vma
, struct disassemble_info
*));
143 static int objdump_symbol_at_address
144 PARAMS ((bfd_vma
, struct disassemble_info
*));
145 static void show_line
PARAMS ((bfd
*, asection
*, bfd_vma
));
146 static void disassemble_bytes
147 PARAMS ((struct disassemble_info
*, disassembler_ftype
, boolean
,
148 bfd_byte
*, bfd_vma
, bfd_vma
, arelent
***, arelent
**));
149 static void disassemble_data
PARAMS ((bfd
*));
150 static const char *endian_string
PARAMS ((enum bfd_endian
));
151 static asymbol
** slurp_symtab
PARAMS ((bfd
*));
152 static asymbol
** slurp_dynamic_symtab
PARAMS ((bfd
*));
153 static long remove_useless_symbols
PARAMS ((asymbol
**, long));
154 static int compare_symbols
PARAMS ((const PTR
, const PTR
));
155 static int compare_relocs
PARAMS ((const PTR
, const PTR
));
156 static void dump_stabs
PARAMS ((bfd
*));
157 static boolean read_section_stabs
PARAMS ((bfd
*, const char *, const char *));
158 static void print_section_stabs
PARAMS ((bfd
*, const char *, const char *));
161 usage (stream
, status
)
165 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
166 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
167 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
168 fprintf (stream
, _("\
169 -a, --archive-headers Display archive header information\n\
170 -f, --file-headers Display the contents of the overall file header\n\
171 -p, --private-headers Display object format specific file header contents\n\
172 -h, --[section-]headers Display the contents of the section headers\n\
173 -x, --all-headers Display the contents of all headers\n\
174 -d, --disassemble Display assembler contents of executable sections\n\
175 -D, --disassemble-all Display assembler contents of all sections\n\
176 -S, --source Intermix source code with disassembly\n\
177 -s, --full-contents Display the full contents of all sections requested\n\
178 -g, --debugging Display debug information in object file\n\
179 -G, --stabs Display (in raw form) any STABS info in the file\n\
180 -t, --syms Display the contents of the symbol table(s)\n\
181 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
182 -r, --reloc Display the relocation entries in the file\n\
183 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
184 -v, --version Display this program's version number\n\
185 -i, --info List object formats and architectures supported\n\
186 -H, --help Display this information\n\
190 fprintf (stream
, _("\n The following switches are optional:\n"));
191 fprintf (stream
, _("\
192 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
193 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
194 -j, --section=NAME Only display information for section NAME\n\
195 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
196 -EB --endian=big Assume big endian format when disassembling\n\
197 -EL --endian=little Assume little endian format when disassembling\n\
198 --file-start-context Include context from start of file (with -S)\n\
199 -l, --line-numbers Include line numbers and filenames in output\n\
200 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
201 The STYLE, if specified, can be `auto', 'gnu',\n\
202 'lucid', 'arm', 'hp', 'edg', or 'gnu-v3'\n\
203 -w, --wide Format output for more than 80 columns\n\
204 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
205 --start-address=ADDR Only process data whoes address is >= ADDR\n\
206 --stop-address=ADDR Only process data whoes address is <= ADDR\n\
207 --prefix-addresses Print complete address alongside disassembly\n\
208 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
209 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
211 list_supported_targets (program_name
, stream
);
212 list_supported_architectures (program_name
, stream
);
214 disassembler_usage (stream
);
217 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
221 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
223 #define OPTION_ENDIAN (150)
224 #define OPTION_START_ADDRESS (OPTION_ENDIAN + 1)
225 #define OPTION_STOP_ADDRESS (OPTION_START_ADDRESS + 1)
226 #define OPTION_ADJUST_VMA (OPTION_STOP_ADDRESS + 1)
228 static struct option long_options
[]=
230 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
231 {"all-headers", no_argument
, NULL
, 'x'},
232 {"private-headers", no_argument
, NULL
, 'p'},
233 {"architecture", required_argument
, NULL
, 'm'},
234 {"archive-headers", no_argument
, NULL
, 'a'},
235 {"debugging", no_argument
, NULL
, 'g'},
236 {"demangle", optional_argument
, NULL
, 'C'},
237 {"disassemble", no_argument
, NULL
, 'd'},
238 {"disassemble-all", no_argument
, NULL
, 'D'},
239 {"disassembler-options", required_argument
, NULL
, 'M'},
240 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
241 {"dynamic-reloc", no_argument
, NULL
, 'R'},
242 {"dynamic-syms", no_argument
, NULL
, 'T'},
243 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
244 {"file-headers", no_argument
, NULL
, 'f'},
245 {"file-start-context", no_argument
, &file_start_context
, 1},
246 {"full-contents", no_argument
, NULL
, 's'},
247 {"headers", no_argument
, NULL
, 'h'},
248 {"help", no_argument
, NULL
, 'H'},
249 {"info", no_argument
, NULL
, 'i'},
250 {"line-numbers", no_argument
, NULL
, 'l'},
251 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
252 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
253 {"reloc", no_argument
, NULL
, 'r'},
254 {"section", required_argument
, NULL
, 'j'},
255 {"section-headers", no_argument
, NULL
, 'h'},
256 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
257 {"source", no_argument
, NULL
, 'S'},
258 {"stabs", no_argument
, NULL
, 'G'},
259 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
260 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
261 {"syms", no_argument
, NULL
, 't'},
262 {"target", required_argument
, NULL
, 'b'},
263 {"version", no_argument
, NULL
, 'V'},
264 {"wide", no_argument
, NULL
, 'w'},
265 {0, no_argument
, 0, 0}
277 dump_section_header (abfd
, section
, ignored
)
278 bfd
*abfd ATTRIBUTE_UNUSED
;
280 PTR ignored ATTRIBUTE_UNUSED
;
283 unsigned int opb
= bfd_octets_per_byte (abfd
);
285 printf ("%3d %-13s %08lx ", section
->index
,
286 bfd_get_section_name (abfd
, section
),
287 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
288 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
290 bfd_printf_vma (abfd
, section
->lma
);
291 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
292 bfd_get_section_alignment (abfd
, section
));
298 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
300 PF (SEC_HAS_CONTENTS
, "CONTENTS");
301 PF (SEC_ALLOC
, "ALLOC");
302 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
303 PF (SEC_LOAD
, "LOAD");
304 PF (SEC_RELOC
, "RELOC");
305 PF (SEC_READONLY
, "READONLY");
306 PF (SEC_CODE
, "CODE");
307 PF (SEC_DATA
, "DATA");
309 PF (SEC_DEBUGGING
, "DEBUGGING");
310 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
311 PF (SEC_EXCLUDE
, "EXCLUDE");
312 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
313 PF (SEC_BLOCK
, "BLOCK");
314 PF (SEC_CLINK
, "CLINK");
315 PF (SEC_SMALL_DATA
, "SMALL_DATA");
316 PF (SEC_SHARED
, "SHARED");
317 PF (SEC_ARCH_BIT_0
, "ARCH_BIT_0");
318 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
320 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
324 switch (section
->flags
& SEC_LINK_DUPLICATES
)
328 case SEC_LINK_DUPLICATES_DISCARD
:
329 ls
= "LINK_ONCE_DISCARD";
331 case SEC_LINK_DUPLICATES_ONE_ONLY
:
332 ls
= "LINK_ONCE_ONE_ONLY";
334 case SEC_LINK_DUPLICATES_SAME_SIZE
:
335 ls
= "LINK_ONCE_SAME_SIZE";
337 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
338 ls
= "LINK_ONCE_SAME_CONTENTS";
341 printf ("%s%s", comma
, ls
);
343 if (section
->comdat
!= NULL
)
344 printf (" (COMDAT %s %ld)", section
->comdat
->name
,
345 section
->comdat
->symbol
);
358 printf (_("Sections:\n"));
361 printf (_("Idx Name Size VMA LMA File off Algn"));
363 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
364 if (bfd_get_arch_size (abfd
) == 32)
365 printf (_("Idx Name Size VMA LMA File off Algn"));
367 printf (_("Idx Name Size VMA LMA File off Algn"));
371 printf (_(" Flags"));
374 bfd_map_over_sections (abfd
, dump_section_header
, (PTR
) NULL
);
381 asymbol
**sy
= (asymbol
**) NULL
;
384 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
390 storage
= bfd_get_symtab_upper_bound (abfd
);
392 bfd_fatal (bfd_get_filename (abfd
));
394 sy
= (asymbol
**) xmalloc (storage
);
396 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
398 bfd_fatal (bfd_get_filename (abfd
));
402 /* Read in the dynamic symbols. */
405 slurp_dynamic_symtab (abfd
)
408 asymbol
**sy
= (asymbol
**) NULL
;
411 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
414 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
416 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
421 bfd_fatal (bfd_get_filename (abfd
));
424 sy
= (asymbol
**) xmalloc (storage
);
426 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
428 bfd_fatal (bfd_get_filename (abfd
));
432 /* Filter out (in place) symbols that are useless for disassembly.
433 COUNT is the number of elements in SYMBOLS.
434 Return the number of useful symbols. */
437 remove_useless_symbols (symbols
, count
)
441 register asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
445 asymbol
*sym
= *in_ptr
++;
447 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
449 if (sym
->flags
& (BSF_DEBUGGING
))
451 if (bfd_is_und_section (sym
->section
)
452 || bfd_is_com_section (sym
->section
))
457 return out_ptr
- symbols
;
460 /* Sort symbols into value order. */
463 compare_symbols (ap
, bp
)
467 const asymbol
*a
= *(const asymbol
**)ap
;
468 const asymbol
*b
= *(const asymbol
**)bp
;
472 flagword aflags
, bflags
;
474 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
476 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
479 if (a
->section
> b
->section
)
481 else if (a
->section
< b
->section
)
484 an
= bfd_asymbol_name (a
);
485 bn
= bfd_asymbol_name (b
);
489 /* The symbols gnu_compiled and gcc2_compiled convey no real
490 information, so put them after other symbols with the same value. */
492 af
= (strstr (an
, "gnu_compiled") != NULL
493 || strstr (an
, "gcc2_compiled") != NULL
);
494 bf
= (strstr (bn
, "gnu_compiled") != NULL
495 || strstr (bn
, "gcc2_compiled") != NULL
);
502 /* We use a heuristic for the file name, to try to sort it after
503 more useful symbols. It may not work on non Unix systems, but it
504 doesn't really matter; the only difference is precisely which
505 symbol names get printed. */
507 #define file_symbol(s, sn, snl) \
508 (((s)->flags & BSF_FILE) != 0 \
509 || ((sn)[(snl) - 2] == '.' \
510 && ((sn)[(snl) - 1] == 'o' \
511 || (sn)[(snl) - 1] == 'a')))
513 af
= file_symbol (a
, an
, anl
);
514 bf
= file_symbol (b
, bn
, bnl
);
521 /* Try to sort global symbols before local symbols before function
522 symbols before debugging symbols. */
527 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
529 if ((aflags
& BSF_DEBUGGING
) != 0)
534 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
536 if ((aflags
& BSF_FUNCTION
) != 0)
541 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
543 if ((aflags
& BSF_LOCAL
) != 0)
548 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
550 if ((aflags
& BSF_GLOBAL
) != 0)
556 /* Symbols that start with '.' might be section names, so sort them
557 after symbols that don't start with '.'. */
558 if (an
[0] == '.' && bn
[0] != '.')
560 if (an
[0] != '.' && bn
[0] == '.')
563 /* Finally, if we can't distinguish them in any other way, try to
564 get consistent results by sorting the symbols by name. */
565 return strcmp (an
, bn
);
568 /* Sort relocs into address order. */
571 compare_relocs (ap
, bp
)
575 const arelent
*a
= *(const arelent
**)ap
;
576 const arelent
*b
= *(const arelent
**)bp
;
578 if (a
->address
> b
->address
)
580 else if (a
->address
< b
->address
)
583 /* So that associated relocations tied to the same address show up
584 in the correct order, we don't do any further sorting. */
593 /* Print VMA to STREAM. If SKIP_ZEROES is true, omit leading zeroes. */
596 objdump_print_value (vma
, info
, skip_zeroes
)
598 struct disassemble_info
*info
;
603 struct objdump_disasm_info
*aux
604 = (struct objdump_disasm_info
*) info
->application_data
;
606 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
611 for (p
= buf
; *p
== '0'; ++p
)
616 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
619 /* Print the name of a symbol. */
622 objdump_print_symname (abfd
, info
, sym
)
624 struct disassemble_info
*info
;
631 name
= bfd_asymbol_name (sym
);
632 if (do_demangle
&& name
[0] != '\0')
634 /* Demangle the name. */
635 alloc
= demangle (abfd
, name
);
640 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
648 /* Locate a symbol given a bfd, a section, and a VMA. If REQUIRE_SEC
649 is true, then always require the symbol to be in the section. This
650 returns NULL if there is no suitable symbol. If PLACE is not NULL,
651 then *PLACE is set to the index of the symbol in sorted_syms. */
654 find_symbol_for_address (abfd
, sec
, vma
, require_sec
, place
)
661 /* @@ Would it speed things up to cache the last two symbols returned,
662 and maybe their address ranges? For many processors, only one memory
663 operand can be present at a time, so the 2-entry cache wouldn't be
664 constantly churned by code doing heavy memory accesses. */
666 /* Indices in `sorted_syms'. */
668 long max
= sorted_symcount
;
670 unsigned int opb
= bfd_octets_per_byte (abfd
);
672 if (sorted_symcount
< 1)
675 /* Perform a binary search looking for the closest symbol to the
676 required value. We are searching the range (min, max]. */
677 while (min
+ 1 < max
)
681 thisplace
= (max
+ min
) / 2;
682 sym
= sorted_syms
[thisplace
];
684 if (bfd_asymbol_value (sym
) > vma
)
686 else if (bfd_asymbol_value (sym
) < vma
)
695 /* The symbol we want is now in min, the low end of the range we
696 were searching. If there are several symbols with the same
697 value, we want the first one. */
700 && (bfd_asymbol_value (sorted_syms
[thisplace
])
701 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
704 /* If the file is relocateable, and the symbol could be from this
705 section, prefer a symbol from this section over symbols from
706 others, even if the other symbol's value might be closer.
708 Note that this may be wrong for some symbol references if the
709 sections have overlapping memory ranges, but in that case there's
710 no way to tell what's desired without looking at the relocation
713 if (sorted_syms
[thisplace
]->section
!= sec
715 || ((abfd
->flags
& HAS_RELOC
) != 0
716 && vma
>= bfd_get_section_vma (abfd
, sec
)
717 && vma
< (bfd_get_section_vma (abfd
, sec
)
718 + bfd_section_size (abfd
, sec
) / opb
))))
722 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
724 if (bfd_asymbol_value (sorted_syms
[i
])
725 != bfd_asymbol_value (sorted_syms
[thisplace
]))
731 if (sorted_syms
[i
]->section
== sec
733 || sorted_syms
[i
- 1]->section
!= sec
734 || (bfd_asymbol_value (sorted_syms
[i
])
735 != bfd_asymbol_value (sorted_syms
[i
- 1]))))
742 if (sorted_syms
[thisplace
]->section
!= sec
)
744 /* We didn't find a good symbol with a smaller value.
745 Look for one with a larger value. */
746 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
748 if (sorted_syms
[i
]->section
== sec
)
756 if (sorted_syms
[thisplace
]->section
!= sec
758 || ((abfd
->flags
& HAS_RELOC
) != 0
759 && vma
>= bfd_get_section_vma (abfd
, sec
)
760 && vma
< (bfd_get_section_vma (abfd
, sec
)
761 + bfd_section_size (abfd
, sec
)))))
763 /* There is no suitable symbol. */
771 return sorted_syms
[thisplace
];
774 /* Print an address to INFO symbolically. */
777 objdump_print_addr_with_sym (abfd
, sec
, sym
, vma
, info
, skip_zeroes
)
782 struct disassemble_info
*info
;
785 objdump_print_value (vma
, info
, skip_zeroes
);
791 (*info
->fprintf_func
) (info
->stream
, " <%s",
792 bfd_get_section_name (abfd
, sec
));
793 secaddr
= bfd_get_section_vma (abfd
, sec
);
796 (*info
->fprintf_func
) (info
->stream
, "-0x");
797 objdump_print_value (secaddr
- vma
, info
, true);
799 else if (vma
> secaddr
)
801 (*info
->fprintf_func
) (info
->stream
, "+0x");
802 objdump_print_value (vma
- secaddr
, info
, true);
804 (*info
->fprintf_func
) (info
->stream
, ">");
808 (*info
->fprintf_func
) (info
->stream
, " <");
809 objdump_print_symname (abfd
, info
, sym
);
810 if (bfd_asymbol_value (sym
) > vma
)
812 (*info
->fprintf_func
) (info
->stream
, "-0x");
813 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, true);
815 else if (vma
> bfd_asymbol_value (sym
))
817 (*info
->fprintf_func
) (info
->stream
, "+0x");
818 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, true);
820 (*info
->fprintf_func
) (info
->stream
, ">");
824 /* Print VMA to INFO, symbolically if possible. If SKIP_ZEROES is
825 true, don't output leading zeroes. */
828 objdump_print_addr (vma
, info
, skip_zeroes
)
830 struct disassemble_info
*info
;
833 struct objdump_disasm_info
*aux
;
836 if (sorted_symcount
< 1)
838 (*info
->fprintf_func
) (info
->stream
, "0x");
839 objdump_print_value (vma
, info
, skip_zeroes
);
843 aux
= (struct objdump_disasm_info
*) info
->application_data
;
844 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
846 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
850 /* Print VMA to INFO. This function is passed to the disassembler
854 objdump_print_address (vma
, info
)
856 struct disassemble_info
*info
;
858 objdump_print_addr (vma
, info
, ! prefix_addresses
);
861 /* Determine of the given address has a symbol associated with it. */
864 objdump_symbol_at_address (vma
, info
)
866 struct disassemble_info
* info
;
868 struct objdump_disasm_info
* aux
;
871 /* No symbols - do not bother checking. */
872 if (sorted_symcount
< 1)
875 aux
= (struct objdump_disasm_info
*) info
->application_data
;
876 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
879 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
882 /* Hold the last function name and the last line number we displayed
885 static char *prev_functionname
;
886 static unsigned int prev_line
;
888 /* We keep a list of all files that we have seen when doing a
889 dissassembly with source, so that we know how much of the file to
890 display. This can be important for inlined functions. */
892 struct print_file_list
894 struct print_file_list
*next
;
900 static struct print_file_list
*print_files
;
902 /* The number of preceding context lines to show when we start
903 displaying a file for the first time. */
905 #define SHOW_PRECEDING_CONTEXT_LINES (5)
907 /* Skip ahead to a given line in a file, optionally printing each
911 skip_to_line
PARAMS ((struct print_file_list
*, unsigned int, boolean
));
914 skip_to_line (p
, line
, show
)
915 struct print_file_list
*p
;
919 while (p
->line
< line
)
923 if (fgets (buf
, sizeof buf
, p
->f
) == NULL
)
933 if (strchr (buf
, '\n') != NULL
)
938 /* Show the line number, or the source line, in a dissassembly
942 show_line (abfd
, section
, addr_offset
)
947 const char *filename
;
948 const char *functionname
;
951 if (! with_line_numbers
&& ! with_source_code
)
954 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
955 &functionname
, &line
))
958 if (filename
!= NULL
&& *filename
== '\0')
960 if (functionname
!= NULL
&& *functionname
== '\0')
963 if (with_line_numbers
)
965 if (functionname
!= NULL
966 && (prev_functionname
== NULL
967 || strcmp (functionname
, prev_functionname
) != 0))
968 printf ("%s():\n", functionname
);
969 if (line
> 0 && line
!= prev_line
)
970 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
977 struct print_file_list
**pp
, *p
;
979 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
980 if (strcmp ((*pp
)->filename
, filename
) == 0)
986 if (p
!= print_files
)
990 /* We have reencountered a file name which we saw
991 earlier. This implies that either we are dumping out
992 code from an included file, or the same file was
993 linked in more than once. There are two common cases
994 of an included file: inline functions in a header
995 file, and a bison or flex skeleton file. In the
996 former case we want to just start printing (but we
997 back up a few lines to give context); in the latter
998 case we want to continue from where we left off. I
999 can't think of a good way to distinguish the cases,
1000 so I used a heuristic based on the file name. */
1001 if (strcmp (p
->filename
+ strlen (p
->filename
) - 2, ".h") != 0)
1005 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1012 p
->f
= fopen (p
->filename
, "r");
1016 skip_to_line (p
, l
, false);
1018 if (print_files
->f
!= NULL
)
1020 fclose (print_files
->f
);
1021 print_files
->f
= NULL
;
1027 skip_to_line (p
, line
, true);
1029 p
->next
= print_files
;
1037 f
= fopen (filename
, "r");
1042 p
= ((struct print_file_list
*)
1043 xmalloc (sizeof (struct print_file_list
)));
1044 p
->filename
= xmalloc (strlen (filename
) + 1);
1045 strcpy (p
->filename
, filename
);
1049 if (print_files
!= NULL
&& print_files
->f
!= NULL
)
1051 fclose (print_files
->f
);
1052 print_files
->f
= NULL
;
1054 p
->next
= print_files
;
1057 if (file_start_context
)
1060 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1063 skip_to_line (p
, l
, false);
1065 skip_to_line (p
, line
, true);
1070 if (functionname
!= NULL
1071 && (prev_functionname
== NULL
1072 || strcmp (functionname
, prev_functionname
) != 0))
1074 if (prev_functionname
!= NULL
)
1075 free (prev_functionname
);
1076 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1077 strcpy (prev_functionname
, functionname
);
1080 if (line
> 0 && line
!= prev_line
)
1084 /* Pseudo FILE object for strings. */
1092 /* sprintf to a "stream" */
1095 objdump_sprintf
VPARAMS ((SFILE
*f
, const char *format
, ...))
1100 VA_OPEN (args
, format
);
1101 VA_FIXEDARG (args
, SFILE
*, f
);
1102 VA_FIXEDARG (args
, const char *, format
);
1104 vasprintf (&buf
, format
, args
);
1109 fatal (_("Out of virtual memory"));
1114 while ((size_t) ((f
->buffer
+ f
->size
) - f
->current
) < n
+ 1)
1118 curroff
= f
->current
- f
->buffer
;
1120 f
->buffer
= xrealloc (f
->buffer
, f
->size
);
1121 f
->current
= f
->buffer
+ curroff
;
1124 memcpy (f
->current
, buf
, n
);
1126 f
->current
[0] = '\0';
1134 /* The number of zeroes we want to see before we start skipping them.
1135 The number is arbitrarily chosen. */
1138 #define SKIP_ZEROES (8)
1141 /* The number of zeroes to skip at the end of a section. If the
1142 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1143 SKIP_ZEROES, they will be disassembled. If there are fewer than
1144 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1145 attempt to avoid disassembling zeroes inserted by section
1148 #ifndef SKIP_ZEROES_AT_END
1149 #define SKIP_ZEROES_AT_END (3)
1152 /* Disassemble some data in memory between given values. */
1155 disassemble_bytes (info
, disassemble_fn
, insns
, data
,
1156 start_offset
, stop_offset
, relppp
,
1158 struct disassemble_info
*info
;
1159 disassembler_ftype disassemble_fn
;
1162 bfd_vma start_offset
;
1163 bfd_vma stop_offset
;
1167 struct objdump_disasm_info
*aux
;
1169 int octets_per_line
;
1171 int skip_addr_chars
;
1172 bfd_vma addr_offset
;
1173 int opb
= info
->octets_per_byte
;
1175 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1179 octets_per_line
= 4;
1181 octets_per_line
= 16;
1183 /* Figure out how many characters to skip at the start of an
1184 address, to make the disassembly look nicer. We discard leading
1185 zeroes in chunks of 4, ensuring that there is always a leading
1187 skip_addr_chars
= 0;
1188 if (! prefix_addresses
)
1196 + bfd_section_size (section
->owner
, section
) / opb
));
1198 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1201 skip_addr_chars
+= 4;
1206 info
->insn_info_valid
= 0;
1209 addr_offset
= start_offset
;
1210 while (addr_offset
< stop_offset
)
1214 boolean need_nl
= false;
1216 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1218 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1221 if (! disassemble_zeroes
1222 && (info
->insn_info_valid
== 0
1223 || info
->branch_delay_insns
== 0)
1224 && (z
- addr_offset
* opb
>= SKIP_ZEROES
1225 || (z
== stop_offset
* opb
&&
1226 z
- addr_offset
* opb
< SKIP_ZEROES_AT_END
)))
1230 /* If there are more nonzero octets to follow, we only skip
1231 zeroes in multiples of 4, to try to avoid running over
1232 the start of an instruction which happens to start with
1234 if (z
!= stop_offset
* opb
)
1235 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1237 octets
= z
- addr_offset
* opb
;
1248 if (with_line_numbers
|| with_source_code
)
1249 /* The line number tables will refer to unadjusted
1250 section VMAs, so we must undo any VMA modifications
1251 when calling show_line. */
1252 show_line (aux
->abfd
, section
, addr_offset
- adjust_section_vma
);
1254 if (! prefix_addresses
)
1258 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1259 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1263 printf ("%s:\t", buf
+ skip_addr_chars
);
1267 aux
->require_sec
= true;
1268 objdump_print_address (section
->vma
+ addr_offset
, info
);
1269 aux
->require_sec
= false;
1276 sfile
.buffer
= xmalloc (sfile
.size
);
1277 sfile
.current
= sfile
.buffer
;
1278 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1279 info
->stream
= (FILE *) &sfile
;
1280 info
->bytes_per_line
= 0;
1281 info
->bytes_per_chunk
= 0;
1283 #ifdef DISASSEMBLER_NEEDS_RELOCS
1284 /* FIXME: This is wrong. It tests the number of octets
1285 in the last instruction, not the current one. */
1286 if (*relppp
< relppend
1287 && (**relppp
)->address
>= addr_offset
1288 && (**relppp
)->address
<= addr_offset
+ octets
/ opb
)
1289 info
->flags
= INSN_HAS_RELOC
;
1294 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, info
);
1295 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1296 info
->stream
= stdout
;
1297 if (info
->bytes_per_line
!= 0)
1298 octets_per_line
= info
->bytes_per_line
;
1301 if (sfile
.current
!= sfile
.buffer
)
1302 printf ("%s\n", sfile
.buffer
);
1303 free (sfile
.buffer
);
1311 octets
= octets_per_line
;
1312 if (addr_offset
+ octets
/ opb
> stop_offset
)
1313 octets
= (stop_offset
- addr_offset
) * opb
;
1315 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1317 if (ISPRINT (data
[j
]))
1318 buf
[j
- addr_offset
* opb
] = data
[j
];
1320 buf
[j
- addr_offset
* opb
] = '.';
1322 buf
[j
- addr_offset
* opb
] = '\0';
1325 if (prefix_addresses
1327 : show_raw_insn
>= 0)
1331 /* If ! prefix_addresses and ! wide_output, we print
1332 octets_per_line octets per line. */
1334 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1335 pb
= octets_per_line
;
1337 if (info
->bytes_per_chunk
)
1338 bpc
= info
->bytes_per_chunk
;
1342 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1345 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1347 for (k
= bpc
- 1; k
>= 0; k
--)
1348 printf ("%02x", (unsigned) data
[j
+ k
]);
1353 for (k
= 0; k
< bpc
; k
++)
1354 printf ("%02x", (unsigned) data
[j
+ k
]);
1359 for (; pb
< octets_per_line
; pb
+= bpc
)
1363 for (k
= 0; k
< bpc
; k
++)
1368 /* Separate raw data from instruction by extra space. */
1379 printf ("%s", sfile
.buffer
);
1380 free (sfile
.buffer
);
1383 if (prefix_addresses
1385 : show_raw_insn
>= 0)
1393 j
= addr_offset
* opb
+ pb
;
1395 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1396 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1400 printf ("%s:\t", buf
+ skip_addr_chars
);
1402 pb
+= octets_per_line
;
1405 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1409 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1411 for (k
= bpc
- 1; k
>= 0; k
--)
1412 printf ("%02x", (unsigned) data
[j
+ k
]);
1417 for (k
= 0; k
< bpc
; k
++)
1418 printf ("%02x", (unsigned) data
[j
+ k
]);
1431 if ((section
->flags
& SEC_RELOC
) != 0
1432 #ifndef DISASSEMBLER_NEEDS_RELOCS
1437 while ((*relppp
) < relppend
1438 && ((**relppp
)->address
>= (bfd_vma
) addr_offset
1439 && (**relppp
)->address
< (bfd_vma
) addr_offset
+ octets
/ opb
))
1440 #ifdef DISASSEMBLER_NEEDS_RELOCS
1441 if (! dump_reloc_info
)
1455 objdump_print_value (section
->vma
+ q
->address
, info
, true);
1457 printf (": %s\t", q
->howto
->name
);
1459 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1460 printf ("*unknown*");
1463 const char *sym_name
;
1465 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1466 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1467 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1472 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1473 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1474 if (sym_name
== NULL
|| *sym_name
== '\0')
1475 sym_name
= "*unknown*";
1476 printf ("%s", sym_name
);
1483 objdump_print_value (q
->addend
, info
, true);
1495 addr_offset
+= octets
/ opb
;
1499 /* Disassemble the contents of an object file. */
1502 disassemble_data (abfd
)
1505 unsigned long addr_offset
;
1506 disassembler_ftype disassemble_fn
;
1507 struct disassemble_info disasm_info
;
1508 struct objdump_disasm_info aux
;
1513 prev_functionname
= NULL
;
1516 /* We make a copy of syms to sort. We don't want to sort syms
1517 because that will screw up the relocs. */
1518 sorted_syms
= (asymbol
**) xmalloc (symcount
* sizeof (asymbol
*));
1519 memcpy (sorted_syms
, syms
, symcount
* sizeof (asymbol
*));
1521 sorted_symcount
= remove_useless_symbols (sorted_syms
, symcount
);
1523 /* Sort the symbols into section and symbol order */
1524 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1526 INIT_DISASSEMBLE_INFO(disasm_info
, stdout
, fprintf
);
1527 disasm_info
.application_data
= (PTR
) &aux
;
1529 aux
.require_sec
= false;
1530 disasm_info
.print_address_func
= objdump_print_address
;
1531 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1533 if (machine
!= (char *) NULL
)
1535 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1538 fatal (_("Can't use supplied machine %s"), machine
);
1540 abfd
->arch_info
= info
;
1543 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1545 struct bfd_target
*xvec
;
1547 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
1548 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1549 xvec
->byteorder
= endian
;
1553 disassemble_fn
= disassembler (abfd
);
1554 if (!disassemble_fn
)
1556 non_fatal (_("Can't disassemble for architecture %s\n"),
1557 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1562 opb
= bfd_octets_per_byte (abfd
);
1564 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1565 disasm_info
.arch
= bfd_get_arch (abfd
);
1566 disasm_info
.mach
= bfd_get_mach (abfd
);
1567 disasm_info
.disassembler_options
= disassembler_options
;
1568 disasm_info
.octets_per_byte
= opb
;
1570 if (bfd_big_endian (abfd
))
1571 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1572 else if (bfd_little_endian (abfd
))
1573 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1575 /* ??? Aborting here seems too drastic. We could default to big or little
1577 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1579 for (section
= abfd
->sections
;
1580 section
!= (asection
*) NULL
;
1581 section
= section
->next
)
1583 bfd_byte
*data
= NULL
;
1584 bfd_size_type datasize
= 0;
1585 arelent
**relbuf
= NULL
;
1586 arelent
**relpp
= NULL
;
1587 arelent
**relppend
= NULL
;
1588 unsigned long stop_offset
;
1589 asymbol
*sym
= NULL
;
1592 if ((section
->flags
& SEC_LOAD
) == 0
1593 || (! disassemble_all
1595 && (section
->flags
& SEC_CODE
) == 0))
1597 if (only
!= (char *) NULL
&& strcmp (only
, section
->name
) != 0)
1600 if ((section
->flags
& SEC_RELOC
) != 0
1601 #ifndef DISASSEMBLER_NEEDS_RELOCS
1608 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1610 bfd_fatal (bfd_get_filename (abfd
));
1616 relbuf
= (arelent
**) xmalloc (relsize
);
1617 relcount
= bfd_canonicalize_reloc (abfd
, section
, relbuf
, syms
);
1619 bfd_fatal (bfd_get_filename (abfd
));
1621 /* Sort the relocs by address. */
1622 qsort (relbuf
, relcount
, sizeof (arelent
*), compare_relocs
);
1625 relppend
= relpp
+ relcount
;
1627 /* Skip over the relocs belonging to addresses below the
1629 if (start_address
!= (bfd_vma
) -1)
1631 while (relpp
< relppend
1632 && (*relpp
)->address
< start_address
)
1638 printf (_("Disassembly of section %s:\n"), section
->name
);
1640 datasize
= bfd_get_section_size_before_reloc (section
);
1644 data
= (bfd_byte
*) xmalloc ((size_t) datasize
);
1646 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1649 disasm_info
.buffer
= data
;
1650 disasm_info
.buffer_vma
= section
->vma
;
1651 disasm_info
.buffer_length
= datasize
;
1652 disasm_info
.section
= section
;
1653 if (start_address
== (bfd_vma
) -1
1654 || start_address
< disasm_info
.buffer_vma
)
1657 addr_offset
= start_address
- disasm_info
.buffer_vma
;
1658 if (stop_address
== (bfd_vma
) -1)
1659 stop_offset
= datasize
/ opb
;
1662 if (stop_address
< disasm_info
.buffer_vma
)
1665 stop_offset
= stop_address
- disasm_info
.buffer_vma
;
1666 if (stop_offset
> disasm_info
.buffer_length
/ opb
)
1667 stop_offset
= disasm_info
.buffer_length
/ opb
;
1670 sym
= find_symbol_for_address (abfd
, section
, section
->vma
+ addr_offset
,
1673 while (addr_offset
< stop_offset
)
1676 unsigned long nextstop_offset
;
1679 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= section
->vma
+ addr_offset
)
1684 (x
< sorted_symcount
1685 && bfd_asymbol_value (sorted_syms
[x
]) <= section
->vma
+ addr_offset
);
1688 disasm_info
.symbols
= & sorted_syms
[place
];
1689 disasm_info
.num_symbols
= x
- place
;
1692 disasm_info
.symbols
= NULL
;
1694 if (! prefix_addresses
)
1697 objdump_print_addr_with_sym (abfd
, section
, sym
,
1698 section
->vma
+ addr_offset
,
1704 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
)
1706 else if (sym
== NULL
)
1710 /* Search forward for the next appropriate symbol in
1711 SECTION. Note that all the symbols are sorted
1712 together into one big array, and that some sections
1713 may have overlapping addresses. */
1714 while (place
< sorted_symcount
1715 && (sorted_syms
[place
]->section
!= section
1716 || (bfd_asymbol_value (sorted_syms
[place
])
1717 <= bfd_asymbol_value (sym
))))
1719 if (place
>= sorted_symcount
)
1722 nextsym
= sorted_syms
[place
];
1725 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
)
1727 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1728 if (nextstop_offset
> stop_offset
)
1729 nextstop_offset
= stop_offset
;
1731 else if (nextsym
== NULL
)
1732 nextstop_offset
= stop_offset
;
1735 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1736 if (nextstop_offset
> stop_offset
)
1737 nextstop_offset
= stop_offset
;
1740 /* If a symbol is explicitly marked as being an object
1741 rather than a function, just dump the bytes without
1742 disassembling them. */
1745 || bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
1746 || ((sym
->flags
& BSF_OBJECT
) == 0
1747 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1749 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1751 || (sym
->flags
& BSF_FUNCTION
) != 0)
1756 disassemble_bytes (&disasm_info
, disassemble_fn
, insns
, data
,
1757 addr_offset
, nextstop_offset
, &relpp
, relppend
);
1759 addr_offset
= nextstop_offset
;
1771 /* Define a table of stab values and print-strings. We wish the initializer
1772 could be a direct-mapped table, but instead we build one the first
1775 static void dump_section_stabs
PARAMS ((bfd
*abfd
, char *stabsect_name
,
1776 char *strsect_name
));
1778 /* Dump the stabs sections from an object file that has a section that
1779 uses Sun stabs encoding. */
1785 dump_section_stabs (abfd
, ".stab", ".stabstr");
1786 dump_section_stabs (abfd
, ".stab.excl", ".stab.exclstr");
1787 dump_section_stabs (abfd
, ".stab.index", ".stab.indexstr");
1788 dump_section_stabs (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1791 static bfd_byte
*stabs
;
1792 static bfd_size_type stab_size
;
1794 static char *strtab
;
1795 static bfd_size_type stabstr_size
;
1797 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1798 and string table section STRSECT_NAME into `strtab'.
1799 If the section exists and was read, allocate the space and return true.
1800 Otherwise return false. */
1803 read_section_stabs (abfd
, stabsect_name
, strsect_name
)
1805 const char *stabsect_name
;
1806 const char *strsect_name
;
1808 asection
*stabsect
, *stabstrsect
;
1810 stabsect
= bfd_get_section_by_name (abfd
, stabsect_name
);
1813 printf (_("No %s section present\n\n"), stabsect_name
);
1817 stabstrsect
= bfd_get_section_by_name (abfd
, strsect_name
);
1818 if (0 == stabstrsect
)
1820 non_fatal (_("%s has no %s section"),
1821 bfd_get_filename (abfd
), strsect_name
);
1826 stab_size
= bfd_section_size (abfd
, stabsect
);
1827 stabstr_size
= bfd_section_size (abfd
, stabstrsect
);
1829 stabs
= (bfd_byte
*) xmalloc (stab_size
);
1830 strtab
= (char *) xmalloc (stabstr_size
);
1832 if (! bfd_get_section_contents (abfd
, stabsect
, (PTR
) stabs
, 0, stab_size
))
1834 non_fatal (_("Reading %s section of %s failed: %s"),
1835 stabsect_name
, bfd_get_filename (abfd
),
1836 bfd_errmsg (bfd_get_error ()));
1843 if (! bfd_get_section_contents (abfd
, stabstrsect
, (PTR
) strtab
, 0,
1846 non_fatal (_("Reading %s section of %s failed: %s\n"),
1847 strsect_name
, bfd_get_filename (abfd
),
1848 bfd_errmsg (bfd_get_error ()));
1858 /* Stabs entries use a 12 byte format:
1859 4 byte string table index
1861 1 byte stab other field
1862 2 byte stab desc field
1864 FIXME: This will have to change for a 64 bit object format. */
1866 #define STRDXOFF (0)
1868 #define OTHEROFF (5)
1871 #define STABSIZE (12)
1873 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1874 using string table section STRSECT_NAME (in `strtab'). */
1877 print_section_stabs (abfd
, stabsect_name
, strsect_name
)
1879 const char *stabsect_name
;
1880 const char *strsect_name ATTRIBUTE_UNUSED
;
1883 unsigned file_string_table_offset
= 0, next_file_string_table_offset
= 0;
1884 bfd_byte
*stabp
, *stabs_end
;
1887 stabs_end
= stabp
+ stab_size
;
1889 printf (_("Contents of %s section:\n\n"), stabsect_name
);
1890 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1892 /* Loop through all symbols and print them.
1894 We start the index at -1 because there is a dummy symbol on
1895 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1897 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
1901 unsigned char type
, other
;
1902 unsigned short desc
;
1905 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
1906 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
1907 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
1908 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
1909 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
1911 printf ("\n%-6d ", i
);
1912 /* Either print the stab name, or, if unnamed, print its number
1913 again (makes consistent formatting for tools like awk). */
1914 name
= bfd_get_stab_name (type
);
1916 printf ("%-6s", name
);
1917 else if (type
== N_UNDF
)
1920 printf ("%-6d", type
);
1921 printf (" %-6d %-6d ", other
, desc
);
1922 bfd_printf_vma (abfd
, value
);
1923 printf (" %-6lu", strx
);
1925 /* Symbols with type == 0 (N_UNDF) specify the length of the
1926 string table associated with this file. We use that info
1927 to know how to relocate the *next* file's string table indices. */
1931 file_string_table_offset
= next_file_string_table_offset
;
1932 next_file_string_table_offset
+= value
;
1936 /* Using the (possibly updated) string table offset, print the
1937 string (if any) associated with this symbol. */
1939 if ((strx
+ file_string_table_offset
) < stabstr_size
)
1940 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
1949 dump_section_stabs (abfd
, stabsect_name
, strsect_name
)
1951 char *stabsect_name
;
1956 /* Check for section names for which stabsect_name is a prefix, to
1957 handle .stab0, etc. */
1958 for (s
= abfd
->sections
;
1964 len
= strlen (stabsect_name
);
1966 /* If the prefix matches, and the files section name ends with a
1967 nul or a digit, then we match. I.e., we want either an exact
1968 match or a section followed by a number. */
1969 if (strncmp (stabsect_name
, s
->name
, len
) == 0
1970 && (s
->name
[len
] == '\000'
1971 || ISDIGIT (s
->name
[len
])))
1973 if (read_section_stabs (abfd
, s
->name
, strsect_name
))
1975 print_section_stabs (abfd
, s
->name
, strsect_name
);
1984 dump_bfd_header (abfd
)
1989 printf (_("architecture: %s, "),
1990 bfd_printable_arch_mach (bfd_get_arch (abfd
),
1991 bfd_get_mach (abfd
)));
1992 printf (_("flags 0x%08x:\n"), abfd
->flags
);
1994 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
1995 PF (HAS_RELOC
, "HAS_RELOC");
1996 PF (EXEC_P
, "EXEC_P");
1997 PF (HAS_LINENO
, "HAS_LINENO");
1998 PF (HAS_DEBUG
, "HAS_DEBUG");
1999 PF (HAS_SYMS
, "HAS_SYMS");
2000 PF (HAS_LOCALS
, "HAS_LOCALS");
2001 PF (DYNAMIC
, "DYNAMIC");
2002 PF (WP_TEXT
, "WP_TEXT");
2003 PF (D_PAGED
, "D_PAGED");
2004 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2005 printf (_("\nstart address 0x"));
2006 bfd_printf_vma (abfd
, abfd
->start_address
);
2011 dump_bfd_private_header (abfd
)
2014 bfd_print_private_bfd_data (abfd
, stdout
);
2017 /* Dump selected contents of ABFD */
2023 /* If we are adjusting section VMA's, change them all now. Changing
2024 the BFD information is a hack. However, we must do it, or
2025 bfd_find_nearest_line will not do the right thing. */
2026 if (adjust_section_vma
!= 0)
2030 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2032 s
->vma
+= adjust_section_vma
;
2033 s
->lma
+= adjust_section_vma
;
2037 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2040 print_arelt_descr (stdout
, abfd
, true);
2041 if (dump_file_header
)
2042 dump_bfd_header (abfd
);
2043 if (dump_private_headers
)
2044 dump_bfd_private_header (abfd
);
2046 if (dump_section_headers
)
2047 dump_headers (abfd
);
2048 if (dump_symtab
|| dump_reloc_info
|| disassemble
|| dump_debugging
)
2050 syms
= slurp_symtab (abfd
);
2052 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
));
2103 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2109 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2111 nonfatal (bfd_get_filename (abfd
));
2112 list_matching_formats (matching
);
2117 if (bfd_get_error () != bfd_error_file_not_recognized
)
2119 nonfatal (bfd_get_filename (abfd
));
2123 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
2129 nonfatal (bfd_get_filename (abfd
));
2131 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2133 list_matching_formats (matching
);
2139 display_file (filename
, target
)
2143 bfd
*file
, *arfile
= (bfd
*) NULL
;
2145 file
= bfd_openr (filename
, target
);
2148 nonfatal (filename
);
2152 if (bfd_check_format (file
, bfd_archive
) == true)
2154 bfd
*last_arfile
= NULL
;
2156 printf (_("In archive %s:\n"), bfd_get_filename (file
));
2159 bfd_set_error (bfd_error_no_error
);
2161 arfile
= bfd_openr_next_archived_file (file
, arfile
);
2164 if (bfd_get_error () != bfd_error_no_more_archived_files
)
2165 nonfatal (bfd_get_filename (file
));
2169 display_bfd (arfile
);
2171 if (last_arfile
!= NULL
)
2172 bfd_close (last_arfile
);
2173 last_arfile
= arfile
;
2176 if (last_arfile
!= NULL
)
2177 bfd_close (last_arfile
);
2185 /* Actually display the various requested regions */
2193 bfd_size_type datasize
= 0;
2194 bfd_size_type addr_offset
;
2195 bfd_size_type start_offset
, stop_offset
;
2196 unsigned int opb
= bfd_octets_per_byte (abfd
);
2198 for (section
= abfd
->sections
; section
!= NULL
; section
=
2203 if (only
== (char *) NULL
||
2204 strcmp (only
, section
->name
) == 0)
2206 if (section
->flags
& SEC_HAS_CONTENTS
)
2208 printf (_("Contents of section %s:\n"), section
->name
);
2210 if (bfd_section_size (abfd
, section
) == 0)
2212 data
= (bfd_byte
*) xmalloc ((size_t) bfd_section_size (abfd
, section
));
2213 datasize
= bfd_section_size (abfd
, section
);
2216 bfd_get_section_contents (abfd
, section
, (PTR
) data
, 0, bfd_section_size (abfd
, section
));
2218 if (start_address
== (bfd_vma
) -1
2219 || start_address
< section
->vma
)
2222 start_offset
= start_address
- section
->vma
;
2223 if (stop_address
== (bfd_vma
) -1)
2224 stop_offset
= bfd_section_size (abfd
, section
) / opb
;
2227 if (stop_address
< section
->vma
)
2230 stop_offset
= stop_address
- section
->vma
;
2231 if (stop_offset
> bfd_section_size (abfd
, section
) / opb
)
2232 stop_offset
= bfd_section_size (abfd
, section
) / opb
;
2234 for (addr_offset
= start_offset
;
2235 addr_offset
< stop_offset
; addr_offset
+= onaline
)
2239 printf (" %04lx ", (unsigned long int)
2240 (addr_offset
+ section
->vma
));
2241 for (j
= addr_offset
* opb
;
2242 j
< addr_offset
* opb
+ onaline
; j
++)
2244 if (j
< stop_offset
* opb
)
2245 printf ("%02x", (unsigned) (data
[j
]));
2253 for (j
= addr_offset
; j
< addr_offset
* opb
+ onaline
; j
++)
2255 if (j
>= stop_offset
* opb
)
2258 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2268 /* Should perhaps share code and display with nm? */
2270 dump_symbols (abfd
, dynamic
)
2271 bfd
*abfd ATTRIBUTE_UNUSED
;
2282 printf ("DYNAMIC SYMBOL TABLE:\n");
2288 printf ("SYMBOL TABLE:\n");
2292 printf (_("no symbols\n"));
2294 for (count
= 0; count
< max
; count
++)
2298 bfd
*cur_bfd
= bfd_asymbol_bfd (*current
);
2300 if (cur_bfd
!= NULL
)
2305 name
= (*current
)->name
;
2307 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2309 /* If we want to demangle the name, we demangle it
2310 here, and temporarily clobber it while calling
2311 bfd_print_symbol. FIXME: This is a gross hack. */
2313 alloc
= demangle (cur_bfd
, name
);
2314 (*current
)->name
= alloc
;
2317 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2318 bfd_print_symbol_all
);
2320 (*current
)->name
= name
;
2341 for (a
= abfd
->sections
; a
!= (asection
*) NULL
; a
= a
->next
)
2345 if (bfd_is_abs_section (a
))
2347 if (bfd_is_und_section (a
))
2349 if (bfd_is_com_section (a
))
2354 if (strcmp (only
, a
->name
))
2357 else if ((a
->flags
& SEC_RELOC
) == 0)
2360 relsize
= bfd_get_reloc_upper_bound (abfd
, a
);
2362 bfd_fatal (bfd_get_filename (abfd
));
2364 printf ("RELOCATION RECORDS FOR [%s]:", a
->name
);
2368 printf (" (none)\n\n");
2372 relpp
= (arelent
**) xmalloc (relsize
);
2373 relcount
= bfd_canonicalize_reloc (abfd
, a
, relpp
, syms
);
2375 bfd_fatal (bfd_get_filename (abfd
));
2376 else if (relcount
== 0)
2378 printf (" (none)\n\n");
2383 dump_reloc_set (abfd
, a
, relpp
, relcount
);
2392 dump_dynamic_relocs (abfd
)
2399 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2401 bfd_fatal (bfd_get_filename (abfd
));
2403 printf ("DYNAMIC RELOCATION RECORDS");
2407 printf (" (none)\n\n");
2411 relpp
= (arelent
**) xmalloc (relsize
);
2412 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2414 bfd_fatal (bfd_get_filename (abfd
));
2415 else if (relcount
== 0)
2417 printf (" (none)\n\n");
2422 dump_reloc_set (abfd
, (asection
*) NULL
, relpp
, relcount
);
2430 dump_reloc_set (abfd
, sec
, relpp
, relcount
)
2437 char *last_filename
, *last_functionname
;
2438 unsigned int last_line
;
2440 /* Get column headers lined up reasonably. */
2446 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2447 width
= strlen (buf
) - 7;
2449 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2452 last_filename
= NULL
;
2453 last_functionname
= NULL
;
2456 for (p
= relpp
; relcount
&& *p
!= (arelent
*) NULL
; p
++, relcount
--)
2459 const char *filename
, *functionname
;
2461 const char *sym_name
;
2462 const char *section_name
;
2464 if (start_address
!= (bfd_vma
) -1
2465 && q
->address
< start_address
)
2467 if (stop_address
!= (bfd_vma
) -1
2468 && q
->address
> stop_address
)
2471 if (with_line_numbers
2473 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2474 &filename
, &functionname
, &line
))
2476 if (functionname
!= NULL
2477 && (last_functionname
== NULL
2478 || strcmp (functionname
, last_functionname
) != 0))
2480 printf ("%s():\n", functionname
);
2481 if (last_functionname
!= NULL
)
2482 free (last_functionname
);
2483 last_functionname
= xstrdup (functionname
);
2486 && (line
!= last_line
2487 || (filename
!= NULL
2488 && last_filename
!= NULL
2489 && strcmp (filename
, last_filename
) != 0)))
2491 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2493 if (last_filename
!= NULL
)
2494 free (last_filename
);
2495 if (filename
== NULL
)
2496 last_filename
= NULL
;
2498 last_filename
= xstrdup (filename
);
2502 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2504 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2505 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2510 section_name
= NULL
;
2514 bfd_printf_vma (abfd
, q
->address
);
2516 printf (" %-16s ", q
->howto
->name
);
2518 printf (" %-16d ", q
->howto
->type
);
2519 objdump_print_symname (abfd
, (struct disassemble_info
*) NULL
,
2524 if (section_name
== (const char *) NULL
)
2525 section_name
= "*unknown*";
2526 bfd_printf_vma (abfd
, q
->address
);
2527 printf (" %-16s [%s]",
2534 bfd_printf_vma (abfd
, q
->addend
);
2540 /* The length of the longest architecture name + 1. */
2541 #define LONGEST_ARCH sizeof("powerpc:common")
2544 endian_string (endian
)
2545 enum bfd_endian endian
;
2547 if (endian
== BFD_ENDIAN_BIG
)
2548 return "big endian";
2549 else if (endian
== BFD_ENDIAN_LITTLE
)
2550 return "little endian";
2552 return "endianness unknown";
2555 /* List the targets that BFD is configured to support, each followed
2556 by its endianness and the architectures it supports. */
2559 display_target_list ()
2561 extern const bfd_target
*const *bfd_target_vector
;
2565 dummy_name
= make_temp_file (NULL
);
2566 for (t
= 0; bfd_target_vector
[t
]; t
++)
2568 const bfd_target
*p
= bfd_target_vector
[t
];
2569 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2572 printf ("%s\n (header %s, data %s)\n", p
->name
,
2573 endian_string (p
->header_byteorder
),
2574 endian_string (p
->byteorder
));
2578 nonfatal (dummy_name
);
2582 if (! bfd_set_format (abfd
, bfd_object
))
2584 if (bfd_get_error () != bfd_error_invalid_operation
)
2586 bfd_close_all_done (abfd
);
2590 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2591 if (bfd_set_arch_mach (abfd
, (enum bfd_architecture
) a
, 0))
2593 bfd_printable_arch_mach ((enum bfd_architecture
) a
, 0));
2594 bfd_close_all_done (abfd
);
2596 unlink (dummy_name
);
2600 /* Print a table showing which architectures are supported for entries
2601 FIRST through LAST-1 of bfd_target_vector (targets across,
2602 architectures down). */
2605 display_info_table (first
, last
)
2609 extern const bfd_target
*const *bfd_target_vector
;
2613 /* Print heading of target names. */
2614 printf ("\n%*s", (int) LONGEST_ARCH
, " ");
2615 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2616 printf ("%s ", bfd_target_vector
[t
]->name
);
2619 dummy_name
= make_temp_file (NULL
);
2620 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2621 if (strcmp (bfd_printable_arch_mach (a
, 0), "UNKNOWN!") != 0)
2623 printf ("%*s ", (int) LONGEST_ARCH
- 1,
2624 bfd_printable_arch_mach (a
, 0));
2625 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2627 const bfd_target
*p
= bfd_target_vector
[t
];
2629 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2639 if (! bfd_set_format (abfd
, bfd_object
))
2641 if (bfd_get_error () != bfd_error_invalid_operation
)
2649 if (! bfd_set_arch_mach (abfd
, a
, 0))
2654 printf ("%s ", p
->name
);
2657 int l
= strlen (p
->name
);
2663 bfd_close_all_done (abfd
);
2667 unlink (dummy_name
);
2671 /* Print tables of all the target-architecture combinations that
2672 BFD has been configured to support. */
2675 display_target_tables ()
2678 extern const bfd_target
*const *bfd_target_vector
;
2682 colum
= getenv ("COLUMNS");
2684 columns
= atoi (colum
);
2689 while (bfd_target_vector
[t
] != NULL
)
2693 wid
= LONGEST_ARCH
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2695 while (wid
< columns
&& bfd_target_vector
[t
] != NULL
)
2699 newwid
= wid
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2700 if (newwid
>= columns
)
2705 display_info_table (oldt
, t
);
2712 printf (_("BFD header file version %s\n"), BFD_VERSION_STRING
);
2713 display_target_list ();
2714 display_target_tables ();
2717 int main
PARAMS ((int, char **));
2725 char *target
= default_target
;
2726 boolean seenflag
= false;
2728 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
2729 setlocale (LC_MESSAGES
, "");
2731 #if defined (HAVE_SETLOCALE)
2732 setlocale (LC_CTYPE
, "");
2734 bindtextdomain (PACKAGE
, LOCALEDIR
);
2735 textdomain (PACKAGE
);
2737 program_name
= *argv
;
2738 xmalloc_set_program_name (program_name
);
2740 START_PROGRESS (program_name
, 0);
2743 set_default_bfd_target ();
2745 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VvCdDlfaHhrRtTxsSj:wE:zgG",
2746 long_options
, (int *) 0))
2752 break; /* We've been given a long option. */
2757 disassembler_options
= optarg
;
2763 with_line_numbers
= true;
2772 enum demangling_styles style
;
2774 style
= cplus_demangle_name_to_style (optarg
);
2775 if (style
== unknown_demangling
)
2776 fatal (_("unknown demangling style `%s'"),
2779 cplus_demangle_set_style (style
);
2785 case OPTION_ADJUST_VMA
:
2786 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
2788 case OPTION_START_ADDRESS
:
2789 start_address
= parse_vma (optarg
, "--start-address");
2791 case OPTION_STOP_ADDRESS
:
2792 stop_address
= parse_vma (optarg
, "--stop-address");
2795 if (strcmp (optarg
, "B") == 0)
2796 endian
= BFD_ENDIAN_BIG
;
2797 else if (strcmp (optarg
, "L") == 0)
2798 endian
= BFD_ENDIAN_LITTLE
;
2801 non_fatal (_("unrecognized -E option"));
2806 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
2807 endian
= BFD_ENDIAN_BIG
;
2808 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
2809 endian
= BFD_ENDIAN_LITTLE
;
2812 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
2818 dump_file_header
= true;
2822 formats_info
= true;
2826 dump_private_headers
= true;
2830 dump_private_headers
= true;
2832 dump_reloc_info
= true;
2833 dump_file_header
= true;
2834 dump_ar_hdrs
= true;
2835 dump_section_headers
= true;
2843 dump_dynamic_symtab
= true;
2851 disassemble_zeroes
= true;
2855 disassemble_all
= true;
2860 with_source_code
= true;
2868 dump_stab_section_info
= true;
2872 dump_section_contents
= true;
2876 dump_reloc_info
= true;
2880 dump_dynamic_reloc_info
= true;
2884 dump_ar_hdrs
= true;
2888 dump_section_headers
= true;
2896 show_version
= true;
2906 print_version ("objdump");
2908 if (seenflag
== false)
2916 display_file ("a.out", target
);
2918 for (; optind
< argc
;)
2919 display_file (argv
[optind
++], target
);
2922 END_PROGRESS (program_name
);