1 /* objdump.c -- dump information about an object file.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 Free Software Foundation, Inc.
6 This file is part of GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 #include "libiberty.h"
33 /* Internal headers for the ELF .stab-dump code - sorry. */
34 #define BYTES_IN_WORD 32
35 #include "aout/aout64.h"
37 #ifdef NEED_DECLARATION_FPRINTF
38 /* This is needed by INIT_DISASSEMBLE_INFO. */
39 extern int fprintf
PARAMS ((FILE *, const char *, ...));
43 static int exit_status
= 0;
45 static char *default_target
= NULL
; /* default at runtime */
47 static int show_version
= 0; /* show the version number */
48 static int dump_section_contents
; /* -s */
49 static int dump_section_headers
; /* -h */
50 static boolean dump_file_header
; /* -f */
51 static int dump_symtab
; /* -t */
52 static int dump_dynamic_symtab
; /* -T */
53 static int dump_reloc_info
; /* -r */
54 static int dump_dynamic_reloc_info
; /* -R */
55 static int dump_ar_hdrs
; /* -a */
56 static int dump_private_headers
; /* -p */
57 static int prefix_addresses
; /* --prefix-addresses */
58 static int with_line_numbers
; /* -l */
59 static boolean with_source_code
; /* -S */
60 static int show_raw_insn
; /* --show-raw-insn */
61 static int dump_stab_section_info
; /* --stabs */
62 static int do_demangle
; /* -C, --demangle */
63 static boolean disassemble
; /* -d */
64 static boolean disassemble_all
; /* -D */
65 static int disassemble_zeroes
; /* --disassemble-zeroes */
66 static boolean formats_info
; /* -i */
67 static char *only
; /* -j secname */
68 static int wide_output
; /* -w */
69 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
70 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
71 static int dump_debugging
; /* --debugging */
72 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
73 static int file_start_context
= 0; /* --file-start-context */
75 /* Extra info to pass to the disassembler address printing function. */
76 struct objdump_disasm_info
{
82 /* Architecture to disassemble for, or default if NULL. */
83 static char *machine
= (char *) NULL
;
85 /* Target specific options to the disassembler. */
86 static char *disassembler_options
= (char *) NULL
;
88 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
89 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
91 /* The symbol table. */
92 static asymbol
**syms
;
94 /* Number of symbols in `syms'. */
95 static long symcount
= 0;
97 /* The sorted symbol table. */
98 static asymbol
**sorted_syms
;
100 /* Number of symbols in `sorted_syms'. */
101 static long sorted_symcount
= 0;
103 /* The dynamic symbol table. */
104 static asymbol
**dynsyms
;
106 /* Number of symbols in `dynsyms'. */
107 static long dynsymcount
= 0;
109 /* Static declarations. */
111 static void usage
PARAMS ((FILE *, int));
112 static void nonfatal
PARAMS ((const char *));
113 static void display_file
PARAMS ((char *filename
, char *target
));
114 static void dump_section_header
PARAMS ((bfd
*, asection
*, PTR
));
115 static void dump_headers
PARAMS ((bfd
*));
116 static void dump_data
PARAMS ((bfd
*abfd
));
117 static void dump_relocs
PARAMS ((bfd
*abfd
));
118 static void dump_dynamic_relocs
PARAMS ((bfd
* abfd
));
119 static void dump_reloc_set
PARAMS ((bfd
*, asection
*, arelent
**, long));
120 static void dump_symbols
PARAMS ((bfd
*abfd
, boolean dynamic
));
121 static void dump_bfd_header
PARAMS ((bfd
*));
122 static void dump_bfd_private_header
PARAMS ((bfd
*));
123 static void dump_bfd
PARAMS ((bfd
*));
124 static void display_bfd
PARAMS ((bfd
*abfd
));
125 static void display_target_list
PARAMS ((void));
126 static void display_info_table
PARAMS ((int, int));
127 static void display_target_tables
PARAMS ((void));
128 static void display_info
PARAMS ((void));
129 static void objdump_print_value
130 PARAMS ((bfd_vma
, struct disassemble_info
*, boolean
));
131 static void objdump_print_symname
132 PARAMS ((bfd
*, struct disassemble_info
*, asymbol
*));
133 static asymbol
*find_symbol_for_address
134 PARAMS ((bfd
*, asection
*, bfd_vma
, boolean
, long *));
135 static void objdump_print_addr_with_sym
136 PARAMS ((bfd
*, asection
*, asymbol
*, bfd_vma
,
137 struct disassemble_info
*, boolean
));
138 static void objdump_print_addr
139 PARAMS ((bfd_vma
, struct disassemble_info
*, boolean
));
140 static void objdump_print_address
141 PARAMS ((bfd_vma
, struct disassemble_info
*));
142 static int objdump_symbol_at_address
143 PARAMS ((bfd_vma
, struct disassemble_info
*));
144 static void show_line
PARAMS ((bfd
*, asection
*, bfd_vma
));
145 static void disassemble_bytes
146 PARAMS ((struct disassemble_info
*, disassembler_ftype
, boolean
,
147 bfd_byte
*, bfd_vma
, bfd_vma
, arelent
***, arelent
**));
148 static void disassemble_data
PARAMS ((bfd
*));
149 static const char *endian_string
PARAMS ((enum bfd_endian
));
150 static asymbol
** slurp_symtab
PARAMS ((bfd
*));
151 static asymbol
** slurp_dynamic_symtab
PARAMS ((bfd
*));
152 static long remove_useless_symbols
PARAMS ((asymbol
**, long));
153 static int compare_symbols
PARAMS ((const PTR
, const PTR
));
154 static int compare_relocs
PARAMS ((const PTR
, const PTR
));
155 static void dump_stabs
PARAMS ((bfd
*));
156 static boolean read_section_stabs
PARAMS ((bfd
*, const char *, const char *));
157 static void print_section_stabs
PARAMS ((bfd
*, const char *, const char *));
160 usage (stream
, status
)
164 fprintf (stream
, _("Usage: %s OPTION... FILE...\n"), program_name
);
165 fprintf (stream
, _("Display information from object FILE.\n"));
166 fprintf (stream
, _("\n At least one of the following switches must be given:\n"));
167 fprintf (stream
, _("\
168 -a, --archive-headers Display archive header information\n\
169 -f, --file-headers Display the contents of the overall file header\n\
170 -p, --private-headers Display object format specific file header contents\n\
171 -h, --[section-]headers Display the contents of the section headers\n\
172 -x, --all-headers Display the contents of all headers\n\
173 -d, --disassemble Display assembler contents of executable sections\n\
174 -D, --disassemble-all Display assembler contents of all sections\n\
175 -S, --source Intermix source code with disassembly\n\
176 -s, --full-contents Display the full contents of all sections requested\n\
177 -g, --debugging Display debug information in object file\n\
178 -G, --stabs Display (in raw form) any STABS info in the file\n\
179 -t, --syms Display the contents of the symbol table(s)\n\
180 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
181 -r, --reloc Display the relocation entries in the file\n\
182 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
183 -V, --version Display this program's version number\n\
184 -i, --info List object formats and architectures supported\n\
185 -H, --help Display this information\n\
189 fprintf (stream
, _("\n The following switches are optional:\n"));
190 fprintf (stream
, _("\
191 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
192 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
193 -j, --section=NAME Only display information for section NAME\n\
194 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
195 -EB --endian=big Assume big endian format when disassembling\n\
196 -EL --endian=little Assume little endian format when disassembling\n\
197 --file-start-context Include context from start of file (with -S)\n\
198 -l, --line-numbers Include line numbers and filenames in output\n\
199 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
200 The STYLE, if specified, can be `auto', 'gnu',\n\
201 'lucid', 'arm', 'hp', 'edg', or 'gnu-new-abi'\n\
202 -w, --wide Format output for more than 80 columns\n\
203 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
204 --start-address=ADDR Only process data whoes address is >= ADDR\n\
205 --stop-address=ADDR Only process data whoes address is <= ADDR\n\
206 --prefix-addresses Print complete address alongside disassembly\n\
207 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
208 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
210 list_supported_targets (program_name
, stream
);
211 list_supported_architectures (program_name
, stream
);
213 disassembler_usage (stream
);
216 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
220 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
222 #define OPTION_ENDIAN (150)
223 #define OPTION_START_ADDRESS (OPTION_ENDIAN + 1)
224 #define OPTION_STOP_ADDRESS (OPTION_START_ADDRESS + 1)
225 #define OPTION_ADJUST_VMA (OPTION_STOP_ADDRESS + 1)
227 static struct option long_options
[]=
229 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
230 {"all-headers", no_argument
, NULL
, 'x'},
231 {"private-headers", no_argument
, NULL
, 'p'},
232 {"architecture", required_argument
, NULL
, 'm'},
233 {"archive-headers", no_argument
, NULL
, 'a'},
234 {"debugging", no_argument
, NULL
, 'g'},
235 {"demangle", optional_argument
, NULL
, 'C'},
236 {"disassemble", no_argument
, NULL
, 'd'},
237 {"disassemble-all", no_argument
, NULL
, 'D'},
238 {"disassembler-options", required_argument
, NULL
, 'M'},
239 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
240 {"dynamic-reloc", no_argument
, NULL
, 'R'},
241 {"dynamic-syms", no_argument
, NULL
, 'T'},
242 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
243 {"file-headers", no_argument
, NULL
, 'f'},
244 {"file-start-context", no_argument
, &file_start_context
, 1},
245 {"full-contents", no_argument
, NULL
, 's'},
246 {"headers", no_argument
, NULL
, 'h'},
247 {"help", no_argument
, NULL
, 'H'},
248 {"info", no_argument
, NULL
, 'i'},
249 {"line-numbers", no_argument
, NULL
, 'l'},
250 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
251 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
252 {"reloc", no_argument
, NULL
, 'r'},
253 {"section", required_argument
, NULL
, 'j'},
254 {"section-headers", no_argument
, NULL
, 'h'},
255 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
256 {"source", no_argument
, NULL
, 'S'},
257 {"stabs", no_argument
, NULL
, 'G'},
258 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
259 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
260 {"syms", no_argument
, NULL
, 't'},
261 {"target", required_argument
, NULL
, 'b'},
262 {"version", no_argument
, NULL
, 'V'},
263 {"wide", no_argument
, NULL
, 'w'},
264 {0, no_argument
, 0, 0}
276 dump_section_header (abfd
, section
, ignored
)
277 bfd
*abfd ATTRIBUTE_UNUSED
;
279 PTR ignored ATTRIBUTE_UNUSED
;
282 unsigned int opb
= bfd_octets_per_byte (abfd
);
284 printf ("%3d %-13s %08lx ", section
->index
,
285 bfd_get_section_name (abfd
, section
),
286 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
287 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
289 bfd_printf_vma (abfd
, section
->lma
);
290 printf (" %08lx 2**%u", section
->filepos
,
291 bfd_get_section_alignment (abfd
, section
));
297 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
299 PF (SEC_HAS_CONTENTS
, "CONTENTS");
300 PF (SEC_ALLOC
, "ALLOC");
301 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
302 PF (SEC_CONSTRUCTOR_TEXT
, "CONSTRUCTOR TEXT");
303 PF (SEC_CONSTRUCTOR_DATA
, "CONSTRUCTOR DATA");
304 PF (SEC_CONSTRUCTOR_BSS
, "CONSTRUCTOR BSS");
305 PF (SEC_LOAD
, "LOAD");
306 PF (SEC_RELOC
, "RELOC");
308 PF (SEC_BALIGN
, "BALIGN");
310 PF (SEC_READONLY
, "READONLY");
311 PF (SEC_CODE
, "CODE");
312 PF (SEC_DATA
, "DATA");
314 PF (SEC_DEBUGGING
, "DEBUGGING");
315 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
316 PF (SEC_EXCLUDE
, "EXCLUDE");
317 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
318 PF (SEC_BLOCK
, "BLOCK");
319 PF (SEC_CLINK
, "CLINK");
320 PF (SEC_SMALL_DATA
, "SMALL_DATA");
321 PF (SEC_SHARED
, "SHARED");
323 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
327 switch (section
->flags
& SEC_LINK_DUPLICATES
)
331 case SEC_LINK_DUPLICATES_DISCARD
:
332 ls
= "LINK_ONCE_DISCARD";
334 case SEC_LINK_DUPLICATES_ONE_ONLY
:
335 ls
= "LINK_ONCE_ONE_ONLY";
337 case SEC_LINK_DUPLICATES_SAME_SIZE
:
338 ls
= "LINK_ONCE_SAME_SIZE";
340 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
341 ls
= "LINK_ONCE_SAME_CONTENTS";
344 printf ("%s%s", comma
, ls
);
346 if (section
->comdat
!= NULL
)
347 printf (" (COMDAT %s %ld)", section
->comdat
->name
,
348 section
->comdat
->symbol
);
361 printf (_("Sections:\n"));
364 printf (_("Idx Name Size VMA LMA File off Algn"));
366 printf (_("Idx Name Size VMA LMA File off Algn"));
370 printf (_(" Flags"));
373 bfd_map_over_sections (abfd
, dump_section_header
, (PTR
) NULL
);
380 asymbol
**sy
= (asymbol
**) NULL
;
383 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
385 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
390 storage
= bfd_get_symtab_upper_bound (abfd
);
392 bfd_fatal (bfd_get_filename (abfd
));
396 sy
= (asymbol
**) xmalloc (storage
);
398 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
400 bfd_fatal (bfd_get_filename (abfd
));
402 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
406 /* Read in the dynamic symbols. */
409 slurp_dynamic_symtab (abfd
)
412 asymbol
**sy
= (asymbol
**) NULL
;
415 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
418 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
420 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
425 bfd_fatal (bfd_get_filename (abfd
));
430 sy
= (asymbol
**) xmalloc (storage
);
432 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
434 bfd_fatal (bfd_get_filename (abfd
));
435 if (dynsymcount
== 0)
436 non_fatal (_("%s: No dynamic symbols"), bfd_get_filename (abfd
));
440 /* Filter out (in place) symbols that are useless for disassembly.
441 COUNT is the number of elements in SYMBOLS.
442 Return the number of useful symbols. */
445 remove_useless_symbols (symbols
, count
)
449 register asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
453 asymbol
*sym
= *in_ptr
++;
455 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
457 if (sym
->flags
& (BSF_DEBUGGING
))
459 if (bfd_is_und_section (sym
->section
)
460 || bfd_is_com_section (sym
->section
))
465 return out_ptr
- symbols
;
468 /* Sort symbols into value order. */
471 compare_symbols (ap
, bp
)
475 const asymbol
*a
= *(const asymbol
**)ap
;
476 const asymbol
*b
= *(const asymbol
**)bp
;
480 flagword aflags
, bflags
;
482 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
484 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
487 if (a
->section
> b
->section
)
489 else if (a
->section
< b
->section
)
492 an
= bfd_asymbol_name (a
);
493 bn
= bfd_asymbol_name (b
);
497 /* The symbols gnu_compiled and gcc2_compiled convey no real
498 information, so put them after other symbols with the same value. */
500 af
= (strstr (an
, "gnu_compiled") != NULL
501 || strstr (an
, "gcc2_compiled") != NULL
);
502 bf
= (strstr (bn
, "gnu_compiled") != NULL
503 || strstr (bn
, "gcc2_compiled") != NULL
);
510 /* We use a heuristic for the file name, to try to sort it after
511 more useful symbols. It may not work on non Unix systems, but it
512 doesn't really matter; the only difference is precisely which
513 symbol names get printed. */
515 #define file_symbol(s, sn, snl) \
516 (((s)->flags & BSF_FILE) != 0 \
517 || ((sn)[(snl) - 2] == '.' \
518 && ((sn)[(snl) - 1] == 'o' \
519 || (sn)[(snl) - 1] == 'a')))
521 af
= file_symbol (a
, an
, anl
);
522 bf
= file_symbol (b
, bn
, bnl
);
529 /* Try to sort global symbols before local symbols before function
530 symbols before debugging symbols. */
535 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
537 if ((aflags
& BSF_DEBUGGING
) != 0)
542 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
544 if ((aflags
& BSF_FUNCTION
) != 0)
549 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
551 if ((aflags
& BSF_LOCAL
) != 0)
556 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
558 if ((aflags
& BSF_GLOBAL
) != 0)
564 /* Symbols that start with '.' might be section names, so sort them
565 after symbols that don't start with '.'. */
566 if (an
[0] == '.' && bn
[0] != '.')
568 if (an
[0] != '.' && bn
[0] == '.')
571 /* Finally, if we can't distinguish them in any other way, try to
572 get consistent results by sorting the symbols by name. */
573 return strcmp (an
, bn
);
576 /* Sort relocs into address order. */
579 compare_relocs (ap
, bp
)
583 const arelent
*a
= *(const arelent
**)ap
;
584 const arelent
*b
= *(const arelent
**)bp
;
586 if (a
->address
> b
->address
)
588 else if (a
->address
< b
->address
)
591 /* So that associated relocations tied to the same address show up
592 in the correct order, we don't do any further sorting. */
601 /* Print VMA to STREAM. If SKIP_ZEROES is true, omit leading zeroes. */
604 objdump_print_value (vma
, info
, skip_zeroes
)
606 struct disassemble_info
*info
;
611 struct objdump_disasm_info
*aux
612 = (struct objdump_disasm_info
*) info
->application_data
;
614 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
619 for (p
= buf
; *p
== '0'; ++p
)
624 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
627 /* Print the name of a symbol. */
630 objdump_print_symname (abfd
, info
, sym
)
632 struct disassemble_info
*info
;
640 name
= bfd_asymbol_name (sym
);
641 if (! do_demangle
|| name
[0] == '\0')
645 /* Demangle the name. */
646 if (bfd_get_symbol_leading_char (abfd
) == name
[0])
649 alloc
= cplus_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
657 (*info
->fprintf_func
) (info
->stream
, "%s", print
);
659 printf ("%s", print
);
665 /* Locate a symbol given a bfd, a section, and a VMA. If REQUIRE_SEC
666 is true, then always require the symbol to be in the section. This
667 returns NULL if there is no suitable symbol. If PLACE is not NULL,
668 then *PLACE is set to the index of the symbol in sorted_syms. */
671 find_symbol_for_address (abfd
, sec
, vma
, require_sec
, place
)
678 /* @@ Would it speed things up to cache the last two symbols returned,
679 and maybe their address ranges? For many processors, only one memory
680 operand can be present at a time, so the 2-entry cache wouldn't be
681 constantly churned by code doing heavy memory accesses. */
683 /* Indices in `sorted_syms'. */
685 long max
= sorted_symcount
;
687 unsigned int opb
= bfd_octets_per_byte (abfd
);
689 if (sorted_symcount
< 1)
692 /* Perform a binary search looking for the closest symbol to the
693 required value. We are searching the range (min, max]. */
694 while (min
+ 1 < max
)
698 thisplace
= (max
+ min
) / 2;
699 sym
= sorted_syms
[thisplace
];
701 if (bfd_asymbol_value (sym
) > vma
)
703 else if (bfd_asymbol_value (sym
) < vma
)
712 /* The symbol we want is now in min, the low end of the range we
713 were searching. If there are several symbols with the same
714 value, we want the first one. */
717 && (bfd_asymbol_value (sorted_syms
[thisplace
])
718 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
721 /* If the file is relocateable, and the symbol could be from this
722 section, prefer a symbol from this section over symbols from
723 others, even if the other symbol's value might be closer.
725 Note that this may be wrong for some symbol references if the
726 sections have overlapping memory ranges, but in that case there's
727 no way to tell what's desired without looking at the relocation
730 if (sorted_syms
[thisplace
]->section
!= sec
732 || ((abfd
->flags
& HAS_RELOC
) != 0
733 && vma
>= bfd_get_section_vma (abfd
, sec
)
734 && vma
< (bfd_get_section_vma (abfd
, sec
)
735 + bfd_section_size (abfd
, sec
) / opb
))))
739 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
741 if (bfd_asymbol_value (sorted_syms
[i
])
742 != bfd_asymbol_value (sorted_syms
[thisplace
]))
748 if (sorted_syms
[i
]->section
== sec
750 || sorted_syms
[i
- 1]->section
!= sec
751 || (bfd_asymbol_value (sorted_syms
[i
])
752 != bfd_asymbol_value (sorted_syms
[i
- 1]))))
759 if (sorted_syms
[thisplace
]->section
!= sec
)
761 /* We didn't find a good symbol with a smaller value.
762 Look for one with a larger value. */
763 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
765 if (sorted_syms
[i
]->section
== sec
)
773 if (sorted_syms
[thisplace
]->section
!= sec
775 || ((abfd
->flags
& HAS_RELOC
) != 0
776 && vma
>= bfd_get_section_vma (abfd
, sec
)
777 && vma
< (bfd_get_section_vma (abfd
, sec
)
778 + bfd_section_size (abfd
, sec
)))))
780 /* There is no suitable symbol. */
788 return sorted_syms
[thisplace
];
791 /* Print an address to INFO symbolically. */
794 objdump_print_addr_with_sym (abfd
, sec
, sym
, vma
, info
, skip_zeroes
)
799 struct disassemble_info
*info
;
802 objdump_print_value (vma
, info
, skip_zeroes
);
808 (*info
->fprintf_func
) (info
->stream
, " <%s",
809 bfd_get_section_name (abfd
, sec
));
810 secaddr
= bfd_get_section_vma (abfd
, sec
);
813 (*info
->fprintf_func
) (info
->stream
, "-0x");
814 objdump_print_value (secaddr
- vma
, info
, true);
816 else if (vma
> secaddr
)
818 (*info
->fprintf_func
) (info
->stream
, "+0x");
819 objdump_print_value (vma
- secaddr
, info
, true);
821 (*info
->fprintf_func
) (info
->stream
, ">");
825 (*info
->fprintf_func
) (info
->stream
, " <");
826 objdump_print_symname (abfd
, info
, sym
);
827 if (bfd_asymbol_value (sym
) > vma
)
829 (*info
->fprintf_func
) (info
->stream
, "-0x");
830 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, true);
832 else if (vma
> bfd_asymbol_value (sym
))
834 (*info
->fprintf_func
) (info
->stream
, "+0x");
835 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, true);
837 (*info
->fprintf_func
) (info
->stream
, ">");
841 /* Print VMA to INFO, symbolically if possible. If SKIP_ZEROES is
842 true, don't output leading zeroes. */
845 objdump_print_addr (vma
, info
, skip_zeroes
)
847 struct disassemble_info
*info
;
850 struct objdump_disasm_info
*aux
;
853 if (sorted_symcount
< 1)
855 (*info
->fprintf_func
) (info
->stream
, "0x");
856 objdump_print_value (vma
, info
, skip_zeroes
);
860 aux
= (struct objdump_disasm_info
*) info
->application_data
;
861 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
863 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
867 /* Print VMA to INFO. This function is passed to the disassembler
871 objdump_print_address (vma
, info
)
873 struct disassemble_info
*info
;
875 objdump_print_addr (vma
, info
, ! prefix_addresses
);
878 /* Determine of the given address has a symbol associated with it. */
881 objdump_symbol_at_address (vma
, info
)
883 struct disassemble_info
* info
;
885 struct objdump_disasm_info
* aux
;
888 /* No symbols - do not bother checking. */
889 if (sorted_symcount
< 1)
892 aux
= (struct objdump_disasm_info
*) info
->application_data
;
893 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
896 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
899 /* Hold the last function name and the last line number we displayed
902 static char *prev_functionname
;
903 static unsigned int prev_line
;
905 /* We keep a list of all files that we have seen when doing a
906 dissassembly with source, so that we know how much of the file to
907 display. This can be important for inlined functions. */
909 struct print_file_list
911 struct print_file_list
*next
;
917 static struct print_file_list
*print_files
;
919 /* The number of preceding context lines to show when we start
920 displaying a file for the first time. */
922 #define SHOW_PRECEDING_CONTEXT_LINES (5)
924 /* Skip ahead to a given line in a file, optionally printing each
928 skip_to_line
PARAMS ((struct print_file_list
*, unsigned int, boolean
));
931 skip_to_line (p
, line
, show
)
932 struct print_file_list
*p
;
936 while (p
->line
< line
)
940 if (fgets (buf
, sizeof buf
, p
->f
) == NULL
)
950 if (strchr (buf
, '\n') != NULL
)
955 /* Show the line number, or the source line, in a dissassembly
959 show_line (abfd
, section
, addr_offset
)
964 CONST
char *filename
;
965 CONST
char *functionname
;
968 if (! with_line_numbers
&& ! with_source_code
)
971 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
972 &functionname
, &line
))
975 if (filename
!= NULL
&& *filename
== '\0')
977 if (functionname
!= NULL
&& *functionname
== '\0')
980 if (with_line_numbers
)
982 if (functionname
!= NULL
983 && (prev_functionname
== NULL
984 || strcmp (functionname
, prev_functionname
) != 0))
985 printf ("%s():\n", functionname
);
986 if (line
> 0 && line
!= prev_line
)
987 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
994 struct print_file_list
**pp
, *p
;
996 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
997 if (strcmp ((*pp
)->filename
, filename
) == 0)
1003 if (p
!= print_files
)
1007 /* We have reencountered a file name which we saw
1008 earlier. This implies that either we are dumping out
1009 code from an included file, or the same file was
1010 linked in more than once. There are two common cases
1011 of an included file: inline functions in a header
1012 file, and a bison or flex skeleton file. In the
1013 former case we want to just start printing (but we
1014 back up a few lines to give context); in the latter
1015 case we want to continue from where we left off. I
1016 can't think of a good way to distinguish the cases,
1017 so I used a heuristic based on the file name. */
1018 if (strcmp (p
->filename
+ strlen (p
->filename
) - 2, ".h") != 0)
1022 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1029 p
->f
= fopen (p
->filename
, "r");
1033 skip_to_line (p
, l
, false);
1035 if (print_files
->f
!= NULL
)
1037 fclose (print_files
->f
);
1038 print_files
->f
= NULL
;
1044 skip_to_line (p
, line
, true);
1046 p
->next
= print_files
;
1054 f
= fopen (filename
, "r");
1059 p
= ((struct print_file_list
*)
1060 xmalloc (sizeof (struct print_file_list
)));
1061 p
->filename
= xmalloc (strlen (filename
) + 1);
1062 strcpy (p
->filename
, filename
);
1066 if (print_files
!= NULL
&& print_files
->f
!= NULL
)
1068 fclose (print_files
->f
);
1069 print_files
->f
= NULL
;
1071 p
->next
= print_files
;
1074 if (file_start_context
)
1077 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1080 skip_to_line (p
, l
, false);
1082 skip_to_line (p
, line
, true);
1087 if (functionname
!= NULL
1088 && (prev_functionname
== NULL
1089 || strcmp (functionname
, prev_functionname
) != 0))
1091 if (prev_functionname
!= NULL
)
1092 free (prev_functionname
);
1093 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1094 strcpy (prev_functionname
, functionname
);
1097 if (line
> 0 && line
!= prev_line
)
1101 /* Pseudo FILE object for strings. */
1109 /* sprintf to a "stream" */
1112 #ifdef ANSI_PROTOTYPES
1113 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1115 objdump_sprintf (va_alist
)
1119 #ifndef ANSI_PROTOTYPES
1127 #ifdef ANSI_PROTOTYPES
1128 va_start (args
, format
);
1131 f
= va_arg (args
, SFILE
*);
1132 format
= va_arg (args
, const char *);
1135 vasprintf (&buf
, format
, args
);
1141 fatal (_("Out of virtual memory"));
1146 while ((size_t) ((f
->buffer
+ f
->size
) - f
->current
) < n
+ 1)
1150 curroff
= f
->current
- f
->buffer
;
1152 f
->buffer
= xrealloc (f
->buffer
, f
->size
);
1153 f
->current
= f
->buffer
+ curroff
;
1156 memcpy (f
->current
, buf
, n
);
1158 f
->current
[0] = '\0';
1165 /* The number of zeroes we want to see before we start skipping them.
1166 The number is arbitrarily chosen. */
1169 #define SKIP_ZEROES (8)
1172 /* The number of zeroes to skip at the end of a section. If the
1173 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1174 SKIP_ZEROES, they will be disassembled. If there are fewer than
1175 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1176 attempt to avoid disassembling zeroes inserted by section
1179 #ifndef SKIP_ZEROES_AT_END
1180 #define SKIP_ZEROES_AT_END (3)
1183 /* Disassemble some data in memory between given values. */
1186 disassemble_bytes (info
, disassemble_fn
, insns
, data
,
1187 start_offset
, stop_offset
, relppp
,
1189 struct disassemble_info
*info
;
1190 disassembler_ftype disassemble_fn
;
1193 bfd_vma start_offset
;
1194 bfd_vma stop_offset
;
1198 struct objdump_disasm_info
*aux
;
1200 int octets_per_line
;
1202 int skip_addr_chars
;
1203 bfd_vma addr_offset
;
1204 int opb
= info
->octets_per_byte
;
1206 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1210 octets_per_line
= 4;
1212 octets_per_line
= 16;
1214 /* Figure out how many characters to skip at the start of an
1215 address, to make the disassembly look nicer. We discard leading
1216 zeroes in chunks of 4, ensuring that there is always a leading
1218 skip_addr_chars
= 0;
1219 if (! prefix_addresses
)
1227 + bfd_section_size (section
->owner
, section
) / opb
));
1229 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1232 skip_addr_chars
+= 4;
1237 info
->insn_info_valid
= 0;
1240 addr_offset
= start_offset
;
1241 while (addr_offset
< stop_offset
)
1245 boolean need_nl
= false;
1247 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1249 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1252 if (! disassemble_zeroes
1253 && (info
->insn_info_valid
== 0
1254 || info
->branch_delay_insns
== 0)
1255 && (z
- addr_offset
* opb
>= SKIP_ZEROES
1256 || (z
== stop_offset
* opb
&&
1257 z
- addr_offset
* opb
< SKIP_ZEROES_AT_END
)))
1261 /* If there are more nonzero octets to follow, we only skip
1262 zeroes in multiples of 4, to try to avoid running over
1263 the start of an instruction which happens to start with
1265 if (z
!= stop_offset
* opb
)
1266 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1268 octets
= z
- addr_offset
* opb
;
1279 if (with_line_numbers
|| with_source_code
)
1280 /* The line number tables will refer to unadjusted
1281 section VMAs, so we must undo any VMA modifications
1282 when calling show_line. */
1283 show_line (aux
->abfd
, section
, addr_offset
- adjust_section_vma
);
1285 if (! prefix_addresses
)
1289 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1290 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1294 printf ("%s:\t", buf
+ skip_addr_chars
);
1298 aux
->require_sec
= true;
1299 objdump_print_address (section
->vma
+ addr_offset
, info
);
1300 aux
->require_sec
= false;
1307 sfile
.buffer
= xmalloc (sfile
.size
);
1308 sfile
.current
= sfile
.buffer
;
1309 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1310 info
->stream
= (FILE *) &sfile
;
1311 info
->bytes_per_line
= 0;
1312 info
->bytes_per_chunk
= 0;
1314 #ifdef DISASSEMBLER_NEEDS_RELOCS
1315 /* FIXME: This is wrong. It tests the number of octets
1316 in the last instruction, not the current one. */
1317 if (*relppp
< relppend
1318 && (**relppp
)->address
>= addr_offset
1319 && (**relppp
)->address
<= addr_offset
+ octets
/ opb
)
1320 info
->flags
= INSN_HAS_RELOC
;
1325 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, info
);
1326 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1327 info
->stream
= stdout
;
1328 if (info
->bytes_per_line
!= 0)
1329 octets_per_line
= info
->bytes_per_line
;
1332 if (sfile
.current
!= sfile
.buffer
)
1333 printf ("%s\n", sfile
.buffer
);
1334 free (sfile
.buffer
);
1342 octets
= octets_per_line
;
1343 if (addr_offset
+ octets
/ opb
> stop_offset
)
1344 octets
= (stop_offset
- addr_offset
) * opb
;
1346 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1348 if (isprint (data
[j
]))
1349 buf
[j
- addr_offset
* opb
] = data
[j
];
1351 buf
[j
- addr_offset
* opb
] = '.';
1353 buf
[j
- addr_offset
* opb
] = '\0';
1356 if (prefix_addresses
1358 : show_raw_insn
>= 0)
1362 /* If ! prefix_addresses and ! wide_output, we print
1363 octets_per_line octets per line. */
1365 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1366 pb
= octets_per_line
;
1368 if (info
->bytes_per_chunk
)
1369 bpc
= info
->bytes_per_chunk
;
1373 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1376 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1378 for (k
= bpc
- 1; k
>= 0; k
--)
1379 printf ("%02x", (unsigned) data
[j
+ k
]);
1384 for (k
= 0; k
< bpc
; k
++)
1385 printf ("%02x", (unsigned) data
[j
+ k
]);
1390 for (; pb
< octets_per_line
; pb
+= bpc
)
1394 for (k
= 0; k
< bpc
; k
++)
1399 /* Separate raw data from instruction by extra space. */
1410 printf ("%s", sfile
.buffer
);
1411 free (sfile
.buffer
);
1414 if (prefix_addresses
1416 : show_raw_insn
>= 0)
1424 j
= addr_offset
* opb
+ pb
;
1426 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1427 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1431 printf ("%s:\t", buf
+ skip_addr_chars
);
1433 pb
+= octets_per_line
;
1436 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1440 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1442 for (k
= bpc
- 1; k
>= 0; k
--)
1443 printf ("%02x", (unsigned) data
[j
+ k
]);
1448 for (k
= 0; k
< bpc
; k
++)
1449 printf ("%02x", (unsigned) data
[j
+ k
]);
1462 if ((section
->flags
& SEC_RELOC
) != 0
1463 #ifndef DISASSEMBLER_NEEDS_RELOCS
1468 while ((*relppp
) < relppend
1469 && ((**relppp
)->address
>= (bfd_vma
) addr_offset
1470 && (**relppp
)->address
< (bfd_vma
) addr_offset
+ octets
/ opb
))
1471 #ifdef DISASSEMBLER_NEEDS_RELOCS
1472 if (! dump_reloc_info
)
1486 objdump_print_value (section
->vma
+ q
->address
, info
, true);
1488 printf (": %s\t", q
->howto
->name
);
1490 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1491 printf ("*unknown*");
1494 const char *sym_name
;
1496 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1497 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1498 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1503 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1504 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1505 if (sym_name
== NULL
|| *sym_name
== '\0')
1506 sym_name
= "*unknown*";
1507 printf ("%s", sym_name
);
1514 objdump_print_value (q
->addend
, info
, true);
1526 addr_offset
+= octets
/ opb
;
1530 /* Disassemble the contents of an object file. */
1533 disassemble_data (abfd
)
1536 unsigned long addr_offset
;
1537 disassembler_ftype disassemble_fn
;
1538 struct disassemble_info disasm_info
;
1539 struct objdump_disasm_info aux
;
1544 prev_functionname
= NULL
;
1547 /* We make a copy of syms to sort. We don't want to sort syms
1548 because that will screw up the relocs. */
1549 sorted_syms
= (asymbol
**) xmalloc (symcount
* sizeof (asymbol
*));
1550 memcpy (sorted_syms
, syms
, symcount
* sizeof (asymbol
*));
1552 sorted_symcount
= remove_useless_symbols (sorted_syms
, symcount
);
1554 /* Sort the symbols into section and symbol order */
1555 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1557 INIT_DISASSEMBLE_INFO(disasm_info
, stdout
, fprintf
);
1558 disasm_info
.application_data
= (PTR
) &aux
;
1560 aux
.require_sec
= false;
1561 disasm_info
.print_address_func
= objdump_print_address
;
1562 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1564 if (machine
!= (char *) NULL
)
1566 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1569 fatal (_("Can't use supplied machine %s"), machine
);
1571 abfd
->arch_info
= info
;
1574 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1576 struct bfd_target
*xvec
;
1578 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
1579 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1580 xvec
->byteorder
= endian
;
1584 disassemble_fn
= disassembler (abfd
);
1585 if (!disassemble_fn
)
1587 non_fatal (_("Can't disassemble for architecture %s\n"),
1588 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1593 opb
= bfd_octets_per_byte (abfd
);
1595 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1596 disasm_info
.arch
= bfd_get_arch (abfd
);
1597 disasm_info
.mach
= bfd_get_mach (abfd
);
1598 disasm_info
.disassembler_options
= disassembler_options
;
1599 disasm_info
.octets_per_byte
= opb
;
1601 if (bfd_big_endian (abfd
))
1602 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1603 else if (bfd_little_endian (abfd
))
1604 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1606 /* ??? Aborting here seems too drastic. We could default to big or little
1608 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1610 for (section
= abfd
->sections
;
1611 section
!= (asection
*) NULL
;
1612 section
= section
->next
)
1614 bfd_byte
*data
= NULL
;
1615 bfd_size_type datasize
= 0;
1616 arelent
**relbuf
= NULL
;
1617 arelent
**relpp
= NULL
;
1618 arelent
**relppend
= NULL
;
1619 unsigned long stop_offset
;
1620 asymbol
*sym
= NULL
;
1623 if ((section
->flags
& SEC_LOAD
) == 0
1624 || (! disassemble_all
1626 && (section
->flags
& SEC_CODE
) == 0))
1628 if (only
!= (char *) NULL
&& strcmp (only
, section
->name
) != 0)
1631 if ((section
->flags
& SEC_RELOC
) != 0
1632 #ifndef DISASSEMBLER_NEEDS_RELOCS
1639 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1641 bfd_fatal (bfd_get_filename (abfd
));
1647 relbuf
= (arelent
**) xmalloc (relsize
);
1648 relcount
= bfd_canonicalize_reloc (abfd
, section
, relbuf
, syms
);
1650 bfd_fatal (bfd_get_filename (abfd
));
1652 /* Sort the relocs by address. */
1653 qsort (relbuf
, relcount
, sizeof (arelent
*), compare_relocs
);
1656 relppend
= relpp
+ relcount
;
1658 /* Skip over the relocs belonging to addresses below the
1660 if (start_address
!= (bfd_vma
) -1)
1662 while (relpp
< relppend
1663 && (*relpp
)->address
< start_address
)
1669 printf (_("Disassembly of section %s:\n"), section
->name
);
1671 datasize
= bfd_get_section_size_before_reloc (section
);
1675 data
= (bfd_byte
*) xmalloc ((size_t) datasize
);
1677 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1680 disasm_info
.buffer
= data
;
1681 disasm_info
.buffer_vma
= section
->vma
;
1682 disasm_info
.buffer_length
= datasize
;
1683 disasm_info
.section
= section
;
1684 if (start_address
== (bfd_vma
) -1
1685 || start_address
< disasm_info
.buffer_vma
)
1688 addr_offset
= start_address
- disasm_info
.buffer_vma
;
1689 if (stop_address
== (bfd_vma
) -1)
1690 stop_offset
= datasize
/ opb
;
1693 if (stop_address
< disasm_info
.buffer_vma
)
1696 stop_offset
= stop_address
- disasm_info
.buffer_vma
;
1697 if (stop_offset
> disasm_info
.buffer_length
/ opb
)
1698 stop_offset
= disasm_info
.buffer_length
/ opb
;
1701 sym
= find_symbol_for_address (abfd
, section
, section
->vma
+ addr_offset
,
1704 while (addr_offset
< stop_offset
)
1707 unsigned long nextstop_offset
;
1710 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= section
->vma
+ addr_offset
)
1715 (x
< sorted_symcount
1716 && bfd_asymbol_value (sorted_syms
[x
]) <= section
->vma
+ addr_offset
);
1719 disasm_info
.symbols
= & sorted_syms
[place
];
1720 disasm_info
.num_symbols
= x
- place
;
1723 disasm_info
.symbols
= NULL
;
1725 if (! prefix_addresses
)
1728 objdump_print_addr_with_sym (abfd
, section
, sym
,
1729 section
->vma
+ addr_offset
,
1735 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
)
1737 else if (sym
== NULL
)
1741 /* Search forward for the next appropriate symbol in
1742 SECTION. Note that all the symbols are sorted
1743 together into one big array, and that some sections
1744 may have overlapping addresses. */
1745 while (place
< sorted_symcount
1746 && (sorted_syms
[place
]->section
!= section
1747 || (bfd_asymbol_value (sorted_syms
[place
])
1748 <= bfd_asymbol_value (sym
))))
1750 if (place
>= sorted_symcount
)
1753 nextsym
= sorted_syms
[place
];
1756 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
)
1758 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1759 if (nextstop_offset
> stop_offset
)
1760 nextstop_offset
= stop_offset
;
1762 else if (nextsym
== NULL
)
1763 nextstop_offset
= stop_offset
;
1766 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1767 if (nextstop_offset
> stop_offset
)
1768 nextstop_offset
= stop_offset
;
1771 /* If a symbol is explicitly marked as being an object
1772 rather than a function, just dump the bytes without
1773 disassembling them. */
1776 || bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
1777 || ((sym
->flags
& BSF_OBJECT
) == 0
1778 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1780 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1782 || (sym
->flags
& BSF_FUNCTION
) != 0)
1787 disassemble_bytes (&disasm_info
, disassemble_fn
, insns
, data
,
1788 addr_offset
, nextstop_offset
, &relpp
, relppend
);
1790 addr_offset
= nextstop_offset
;
1802 /* Define a table of stab values and print-strings. We wish the initializer
1803 could be a direct-mapped table, but instead we build one the first
1806 static void dump_section_stabs
PARAMS ((bfd
*abfd
, char *stabsect_name
,
1807 char *strsect_name
));
1809 /* Dump the stabs sections from an object file that has a section that
1810 uses Sun stabs encoding. */
1816 dump_section_stabs (abfd
, ".stab", ".stabstr");
1817 dump_section_stabs (abfd
, ".stab.excl", ".stab.exclstr");
1818 dump_section_stabs (abfd
, ".stab.index", ".stab.indexstr");
1819 dump_section_stabs (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1822 static bfd_byte
*stabs
;
1823 static bfd_size_type stab_size
;
1825 static char *strtab
;
1826 static bfd_size_type stabstr_size
;
1828 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1829 and string table section STRSECT_NAME into `strtab'.
1830 If the section exists and was read, allocate the space and return true.
1831 Otherwise return false. */
1834 read_section_stabs (abfd
, stabsect_name
, strsect_name
)
1836 const char *stabsect_name
;
1837 const char *strsect_name
;
1839 asection
*stabsect
, *stabstrsect
;
1841 stabsect
= bfd_get_section_by_name (abfd
, stabsect_name
);
1844 printf (_("No %s section present\n\n"), stabsect_name
);
1848 stabstrsect
= bfd_get_section_by_name (abfd
, strsect_name
);
1849 if (0 == stabstrsect
)
1851 non_fatal (_("%s has no %s section"),
1852 bfd_get_filename (abfd
), strsect_name
);
1857 stab_size
= bfd_section_size (abfd
, stabsect
);
1858 stabstr_size
= bfd_section_size (abfd
, stabstrsect
);
1860 stabs
= (bfd_byte
*) xmalloc (stab_size
);
1861 strtab
= (char *) xmalloc (stabstr_size
);
1863 if (! bfd_get_section_contents (abfd
, stabsect
, (PTR
) stabs
, 0, stab_size
))
1865 non_fatal (_("Reading %s section of %s failed: %s"),
1866 stabsect_name
, bfd_get_filename (abfd
),
1867 bfd_errmsg (bfd_get_error ()));
1874 if (! bfd_get_section_contents (abfd
, stabstrsect
, (PTR
) strtab
, 0,
1877 non_fatal (_("Reading %s section of %s failed: %s\n"),
1878 strsect_name
, bfd_get_filename (abfd
),
1879 bfd_errmsg (bfd_get_error ()));
1889 /* Stabs entries use a 12 byte format:
1890 4 byte string table index
1892 1 byte stab other field
1893 2 byte stab desc field
1895 FIXME: This will have to change for a 64 bit object format. */
1897 #define STRDXOFF (0)
1899 #define OTHEROFF (5)
1902 #define STABSIZE (12)
1904 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1905 using string table section STRSECT_NAME (in `strtab'). */
1908 print_section_stabs (abfd
, stabsect_name
, strsect_name
)
1910 const char *stabsect_name
;
1911 const char *strsect_name ATTRIBUTE_UNUSED
;
1914 unsigned file_string_table_offset
= 0, next_file_string_table_offset
= 0;
1915 bfd_byte
*stabp
, *stabs_end
;
1918 stabs_end
= stabp
+ stab_size
;
1920 printf (_("Contents of %s section:\n\n"), stabsect_name
);
1921 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1923 /* Loop through all symbols and print them.
1925 We start the index at -1 because there is a dummy symbol on
1926 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1928 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
1932 unsigned char type
, other
;
1933 unsigned short desc
;
1936 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
1937 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
1938 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
1939 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
1940 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
1942 printf ("\n%-6d ", i
);
1943 /* Either print the stab name, or, if unnamed, print its number
1944 again (makes consistent formatting for tools like awk). */
1945 name
= bfd_get_stab_name (type
);
1947 printf ("%-6s", name
);
1948 else if (type
== N_UNDF
)
1951 printf ("%-6d", type
);
1952 printf (" %-6d %-6d ", other
, desc
);
1953 bfd_printf_vma (abfd
, value
);
1954 printf (" %-6lu", strx
);
1956 /* Symbols with type == 0 (N_UNDF) specify the length of the
1957 string table associated with this file. We use that info
1958 to know how to relocate the *next* file's string table indices. */
1962 file_string_table_offset
= next_file_string_table_offset
;
1963 next_file_string_table_offset
+= value
;
1967 /* Using the (possibly updated) string table offset, print the
1968 string (if any) associated with this symbol. */
1970 if ((strx
+ file_string_table_offset
) < stabstr_size
)
1971 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
1980 dump_section_stabs (abfd
, stabsect_name
, strsect_name
)
1982 char *stabsect_name
;
1987 /* Check for section names for which stabsect_name is a prefix, to
1988 handle .stab0, etc. */
1989 for (s
= abfd
->sections
;
1995 len
= strlen (stabsect_name
);
1997 /* If the prefix matches, and the files section name ends with a
1998 nul or a digit, then we match. I.e., we want either an exact
1999 match or a section followed by a number. */
2000 if (strncmp (stabsect_name
, s
->name
, len
) == 0
2001 && (s
->name
[len
] == '\000'
2002 || isdigit ((unsigned char) s
->name
[len
])))
2004 if (read_section_stabs (abfd
, s
->name
, strsect_name
))
2006 print_section_stabs (abfd
, s
->name
, strsect_name
);
2015 dump_bfd_header (abfd
)
2020 printf (_("architecture: %s, "),
2021 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2022 bfd_get_mach (abfd
)));
2023 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2025 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2026 PF (HAS_RELOC
, "HAS_RELOC");
2027 PF (EXEC_P
, "EXEC_P");
2028 PF (HAS_LINENO
, "HAS_LINENO");
2029 PF (HAS_DEBUG
, "HAS_DEBUG");
2030 PF (HAS_SYMS
, "HAS_SYMS");
2031 PF (HAS_LOCALS
, "HAS_LOCALS");
2032 PF (DYNAMIC
, "DYNAMIC");
2033 PF (WP_TEXT
, "WP_TEXT");
2034 PF (D_PAGED
, "D_PAGED");
2035 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2036 printf (_("\nstart address 0x"));
2037 bfd_printf_vma (abfd
, abfd
->start_address
);
2042 dump_bfd_private_header (abfd
)
2045 bfd_print_private_bfd_data (abfd
, stdout
);
2048 /* Dump selected contents of ABFD */
2054 /* If we are adjusting section VMA's, change them all now. Changing
2055 the BFD information is a hack. However, we must do it, or
2056 bfd_find_nearest_line will not do the right thing. */
2057 if (adjust_section_vma
!= 0)
2061 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2063 s
->vma
+= adjust_section_vma
;
2064 s
->lma
+= adjust_section_vma
;
2068 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2071 print_arelt_descr (stdout
, abfd
, true);
2072 if (dump_file_header
)
2073 dump_bfd_header (abfd
);
2074 if (dump_private_headers
)
2075 dump_bfd_private_header (abfd
);
2077 if (dump_section_headers
)
2078 dump_headers (abfd
);
2079 if (dump_symtab
|| dump_reloc_info
|| disassemble
|| dump_debugging
)
2081 syms
= slurp_symtab (abfd
);
2083 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
)
2085 dynsyms
= slurp_dynamic_symtab (abfd
);
2088 dump_symbols (abfd
, false);
2089 if (dump_dynamic_symtab
)
2090 dump_symbols (abfd
, true);
2091 if (dump_stab_section_info
)
2093 if (dump_reloc_info
&& ! disassemble
)
2095 if (dump_dynamic_reloc_info
)
2096 dump_dynamic_relocs (abfd
);
2097 if (dump_section_contents
)
2100 disassemble_data (abfd
);
2105 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2106 if (dhandle
!= NULL
)
2108 if (! print_debugging_info (stdout
, dhandle
))
2110 non_fatal (_("%s: printing debugging information failed"),
2111 bfd_get_filename (abfd
));
2134 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2140 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2142 nonfatal (bfd_get_filename (abfd
));
2143 list_matching_formats (matching
);
2148 if (bfd_get_error () != bfd_error_file_not_recognized
)
2150 nonfatal (bfd_get_filename (abfd
));
2154 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
2160 nonfatal (bfd_get_filename (abfd
));
2162 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2164 list_matching_formats (matching
);
2170 display_file (filename
, target
)
2174 bfd
*file
, *arfile
= (bfd
*) NULL
;
2176 file
= bfd_openr (filename
, target
);
2179 nonfatal (filename
);
2183 if (bfd_check_format (file
, bfd_archive
) == true)
2185 bfd
*last_arfile
= NULL
;
2187 printf (_("In archive %s:\n"), bfd_get_filename (file
));
2190 bfd_set_error (bfd_error_no_error
);
2192 arfile
= bfd_openr_next_archived_file (file
, arfile
);
2195 if (bfd_get_error () != bfd_error_no_more_archived_files
)
2196 nonfatal (bfd_get_filename (file
));
2200 display_bfd (arfile
);
2202 if (last_arfile
!= NULL
)
2203 bfd_close (last_arfile
);
2204 last_arfile
= arfile
;
2207 if (last_arfile
!= NULL
)
2208 bfd_close (last_arfile
);
2216 /* Actually display the various requested regions */
2224 bfd_size_type datasize
= 0;
2225 bfd_size_type addr_offset
;
2226 bfd_size_type start_offset
, stop_offset
;
2227 unsigned int opb
= bfd_octets_per_byte (abfd
);
2229 for (section
= abfd
->sections
; section
!= NULL
; section
=
2234 if (only
== (char *) NULL
||
2235 strcmp (only
, section
->name
) == 0)
2237 if (section
->flags
& SEC_HAS_CONTENTS
)
2239 printf (_("Contents of section %s:\n"), section
->name
);
2241 if (bfd_section_size (abfd
, section
) == 0)
2243 data
= (bfd_byte
*) xmalloc ((size_t) bfd_section_size (abfd
, section
));
2244 datasize
= bfd_section_size (abfd
, section
);
2247 bfd_get_section_contents (abfd
, section
, (PTR
) data
, 0, bfd_section_size (abfd
, section
));
2249 if (start_address
== (bfd_vma
) -1
2250 || start_address
< section
->vma
)
2253 start_offset
= start_address
- section
->vma
;
2254 if (stop_address
== (bfd_vma
) -1)
2255 stop_offset
= bfd_section_size (abfd
, section
) / opb
;
2258 if (stop_address
< section
->vma
)
2261 stop_offset
= stop_address
- section
->vma
;
2262 if (stop_offset
> bfd_section_size (abfd
, section
) / opb
)
2263 stop_offset
= bfd_section_size (abfd
, section
) / opb
;
2265 for (addr_offset
= start_offset
;
2266 addr_offset
< stop_offset
; addr_offset
+= onaline
)
2270 printf (" %04lx ", (unsigned long int)
2271 (addr_offset
+ section
->vma
));
2272 for (j
= addr_offset
* opb
;
2273 j
< addr_offset
* opb
+ onaline
; j
++)
2275 if (j
< stop_offset
* opb
)
2276 printf ("%02x", (unsigned) (data
[j
]));
2284 for (j
= addr_offset
; j
< addr_offset
* opb
+ onaline
; j
++)
2286 if (j
>= stop_offset
* opb
)
2289 printf ("%c", isprint (data
[j
]) ? data
[j
] : '.');
2299 /* Should perhaps share code and display with nm? */
2301 dump_symbols (abfd
, dynamic
)
2302 bfd
*abfd ATTRIBUTE_UNUSED
;
2315 printf ("DYNAMIC SYMBOL TABLE:\n");
2323 printf ("SYMBOL TABLE:\n");
2326 for (count
= 0; count
< max
; count
++)
2330 bfd
*cur_bfd
= bfd_asymbol_bfd (*current
);
2332 if (cur_bfd
!= NULL
)
2337 name
= bfd_asymbol_name (*current
);
2339 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2343 /* If we want to demangle the name, we demangle it
2344 here, and temporarily clobber it while calling
2345 bfd_print_symbol. FIXME: This is a gross hack. */
2348 if (bfd_get_symbol_leading_char (cur_bfd
) == *n
)
2350 alloc
= cplus_demangle (n
, DMGL_ANSI
| DMGL_PARAMS
);
2352 (*current
)->name
= alloc
;
2354 (*current
)->name
= n
;
2357 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2358 bfd_print_symbol_all
);
2360 (*current
)->name
= name
;
2381 for (a
= abfd
->sections
; a
!= (asection
*) NULL
; a
= a
->next
)
2385 if (bfd_is_abs_section (a
))
2387 if (bfd_is_und_section (a
))
2389 if (bfd_is_com_section (a
))
2394 if (strcmp (only
, a
->name
))
2397 else if ((a
->flags
& SEC_RELOC
) == 0)
2400 relsize
= bfd_get_reloc_upper_bound (abfd
, a
);
2402 bfd_fatal (bfd_get_filename (abfd
));
2404 printf ("RELOCATION RECORDS FOR [%s]:", a
->name
);
2408 printf (" (none)\n\n");
2412 relpp
= (arelent
**) xmalloc (relsize
);
2413 relcount
= bfd_canonicalize_reloc (abfd
, a
, relpp
, syms
);
2415 bfd_fatal (bfd_get_filename (abfd
));
2416 else if (relcount
== 0)
2418 printf (" (none)\n\n");
2423 dump_reloc_set (abfd
, a
, relpp
, relcount
);
2432 dump_dynamic_relocs (abfd
)
2439 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2441 bfd_fatal (bfd_get_filename (abfd
));
2443 printf ("DYNAMIC RELOCATION RECORDS");
2447 printf (" (none)\n\n");
2451 relpp
= (arelent
**) xmalloc (relsize
);
2452 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2454 bfd_fatal (bfd_get_filename (abfd
));
2455 else if (relcount
== 0)
2457 printf (" (none)\n\n");
2462 dump_reloc_set (abfd
, (asection
*) NULL
, relpp
, relcount
);
2470 dump_reloc_set (abfd
, sec
, relpp
, relcount
)
2477 char *last_filename
, *last_functionname
;
2478 unsigned int last_line
;
2480 /* Get column headers lined up reasonably. */
2486 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2487 width
= strlen (buf
) - 7;
2489 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2492 last_filename
= NULL
;
2493 last_functionname
= NULL
;
2496 for (p
= relpp
; relcount
&& *p
!= (arelent
*) NULL
; p
++, relcount
--)
2499 const char *filename
, *functionname
;
2501 const char *sym_name
;
2502 const char *section_name
;
2504 if (start_address
!= (bfd_vma
) -1
2505 && q
->address
< start_address
)
2507 if (stop_address
!= (bfd_vma
) -1
2508 && q
->address
> stop_address
)
2511 if (with_line_numbers
2513 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2514 &filename
, &functionname
, &line
))
2516 if (functionname
!= NULL
2517 && (last_functionname
== NULL
2518 || strcmp (functionname
, last_functionname
) != 0))
2520 printf ("%s():\n", functionname
);
2521 if (last_functionname
!= NULL
)
2522 free (last_functionname
);
2523 last_functionname
= xstrdup (functionname
);
2526 && (line
!= last_line
2527 || (filename
!= NULL
2528 && last_filename
!= NULL
2529 && strcmp (filename
, last_filename
) != 0)))
2531 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2533 if (last_filename
!= NULL
)
2534 free (last_filename
);
2535 if (filename
== NULL
)
2536 last_filename
= NULL
;
2538 last_filename
= xstrdup (filename
);
2542 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2544 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2545 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2550 section_name
= NULL
;
2554 bfd_printf_vma (abfd
, q
->address
);
2556 printf (" %-16s ", q
->howto
->name
);
2558 printf (" %-16d ", q
->howto
->type
);
2559 objdump_print_symname (abfd
, (struct disassemble_info
*) NULL
,
2564 if (section_name
== (CONST
char *) NULL
)
2565 section_name
= "*unknown*";
2566 bfd_printf_vma (abfd
, q
->address
);
2567 printf (" %-16s [%s]",
2574 bfd_printf_vma (abfd
, q
->addend
);
2580 /* The length of the longest architecture name + 1. */
2581 #define LONGEST_ARCH sizeof("powerpc:common")
2584 endian_string (endian
)
2585 enum bfd_endian endian
;
2587 if (endian
== BFD_ENDIAN_BIG
)
2588 return "big endian";
2589 else if (endian
== BFD_ENDIAN_LITTLE
)
2590 return "little endian";
2592 return "endianness unknown";
2595 /* List the targets that BFD is configured to support, each followed
2596 by its endianness and the architectures it supports. */
2599 display_target_list ()
2601 extern const bfd_target
*const *bfd_target_vector
;
2605 dummy_name
= make_temp_file (NULL
);
2606 for (t
= 0; bfd_target_vector
[t
]; t
++)
2608 const bfd_target
*p
= bfd_target_vector
[t
];
2609 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2612 printf ("%s\n (header %s, data %s)\n", p
->name
,
2613 endian_string (p
->header_byteorder
),
2614 endian_string (p
->byteorder
));
2618 nonfatal (dummy_name
);
2622 if (! bfd_set_format (abfd
, bfd_object
))
2624 if (bfd_get_error () != bfd_error_invalid_operation
)
2626 bfd_close_all_done (abfd
);
2630 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2631 if (bfd_set_arch_mach (abfd
, (enum bfd_architecture
) a
, 0))
2633 bfd_printable_arch_mach ((enum bfd_architecture
) a
, 0));
2634 bfd_close_all_done (abfd
);
2636 unlink (dummy_name
);
2640 /* Print a table showing which architectures are supported for entries
2641 FIRST through LAST-1 of bfd_target_vector (targets across,
2642 architectures down). */
2645 display_info_table (first
, last
)
2649 extern const bfd_target
*const *bfd_target_vector
;
2653 /* Print heading of target names. */
2654 printf ("\n%*s", (int) LONGEST_ARCH
, " ");
2655 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2656 printf ("%s ", bfd_target_vector
[t
]->name
);
2659 dummy_name
= make_temp_file (NULL
);
2660 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2661 if (strcmp (bfd_printable_arch_mach (a
, 0), "UNKNOWN!") != 0)
2663 printf ("%*s ", (int) LONGEST_ARCH
- 1,
2664 bfd_printable_arch_mach (a
, 0));
2665 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2667 const bfd_target
*p
= bfd_target_vector
[t
];
2669 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2679 if (! bfd_set_format (abfd
, bfd_object
))
2681 if (bfd_get_error () != bfd_error_invalid_operation
)
2689 if (! bfd_set_arch_mach (abfd
, a
, 0))
2694 printf ("%s ", p
->name
);
2697 int l
= strlen (p
->name
);
2703 bfd_close_all_done (abfd
);
2707 unlink (dummy_name
);
2711 /* Print tables of all the target-architecture combinations that
2712 BFD has been configured to support. */
2715 display_target_tables ()
2718 extern const bfd_target
*const *bfd_target_vector
;
2722 colum
= getenv ("COLUMNS");
2724 columns
= atoi (colum
);
2729 while (bfd_target_vector
[t
] != NULL
)
2733 wid
= LONGEST_ARCH
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2735 while (wid
< columns
&& bfd_target_vector
[t
] != NULL
)
2739 newwid
= wid
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2740 if (newwid
>= columns
)
2745 display_info_table (oldt
, t
);
2752 printf (_("BFD header file version %s\n"), BFD_VERSION
);
2753 display_target_list ();
2754 display_target_tables ();
2763 char *target
= default_target
;
2764 boolean seenflag
= false;
2766 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
2767 setlocale (LC_MESSAGES
, "");
2769 bindtextdomain (PACKAGE
, LOCALEDIR
);
2770 textdomain (PACKAGE
);
2772 program_name
= *argv
;
2773 xmalloc_set_program_name (program_name
);
2775 START_PROGRESS (program_name
, 0);
2778 set_default_bfd_target ();
2780 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VCdDlfahHrRtTxsSj:wE:zgG",
2781 long_options
, (int *) 0))
2787 break; /* we've been given a long option */
2792 disassembler_options
= optarg
;
2798 with_line_numbers
= true;
2807 enum demangling_styles style
;
2809 style
= cplus_demangle_name_to_style (optarg
);
2810 if (style
== unknown_demangling
)
2811 fatal (_("unknown demangling style `%s'"),
2814 cplus_demangle_set_style (style
);
2820 case OPTION_ADJUST_VMA
:
2821 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
2823 case OPTION_START_ADDRESS
:
2824 start_address
= parse_vma (optarg
, "--start-address");
2826 case OPTION_STOP_ADDRESS
:
2827 stop_address
= parse_vma (optarg
, "--stop-address");
2830 if (strcmp (optarg
, "B") == 0)
2831 endian
= BFD_ENDIAN_BIG
;
2832 else if (strcmp (optarg
, "L") == 0)
2833 endian
= BFD_ENDIAN_LITTLE
;
2836 non_fatal (_("unrecognized -E option"));
2841 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
2842 endian
= BFD_ENDIAN_BIG
;
2843 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
2844 endian
= BFD_ENDIAN_LITTLE
;
2847 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
2853 dump_file_header
= true;
2857 formats_info
= true;
2861 dump_private_headers
= true;
2865 dump_private_headers
= true;
2867 dump_reloc_info
= true;
2868 dump_file_header
= true;
2869 dump_ar_hdrs
= true;
2870 dump_section_headers
= true;
2878 dump_dynamic_symtab
= true;
2886 disassemble_zeroes
= true;
2890 disassemble_all
= true;
2895 with_source_code
= true;
2903 dump_stab_section_info
= true;
2907 dump_section_contents
= true;
2911 dump_reloc_info
= true;
2915 dump_dynamic_reloc_info
= true;
2919 dump_ar_hdrs
= true;
2923 dump_section_headers
= true;
2930 show_version
= true;
2940 print_version ("objdump");
2942 if (seenflag
== false)
2950 display_file ("a.out", target
);
2952 for (; optind
< argc
;)
2953 display_file (argv
[optind
++], target
);
2956 END_PROGRESS (program_name
);