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. */
26 #include "safe-ctype.h"
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(s)> <file(s)>\n"), program_name
);
165 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
166 fprintf (stream
, _(" 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", (unsigned long) 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_LOAD
, "LOAD");
303 PF (SEC_RELOC
, "RELOC");
304 PF (SEC_READONLY
, "READONLY");
305 PF (SEC_CODE
, "CODE");
306 PF (SEC_DATA
, "DATA");
308 PF (SEC_DEBUGGING
, "DEBUGGING");
309 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
310 PF (SEC_EXCLUDE
, "EXCLUDE");
311 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
312 PF (SEC_BLOCK
, "BLOCK");
313 PF (SEC_CLINK
, "CLINK");
314 PF (SEC_SMALL_DATA
, "SMALL_DATA");
315 PF (SEC_SHARED
, "SHARED");
316 PF (SEC_ARCH_BIT_0
, "ARCH_BIT_0");
317 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
319 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
323 switch (section
->flags
& SEC_LINK_DUPLICATES
)
327 case SEC_LINK_DUPLICATES_DISCARD
:
328 ls
= "LINK_ONCE_DISCARD";
330 case SEC_LINK_DUPLICATES_ONE_ONLY
:
331 ls
= "LINK_ONCE_ONE_ONLY";
333 case SEC_LINK_DUPLICATES_SAME_SIZE
:
334 ls
= "LINK_ONCE_SAME_SIZE";
336 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
337 ls
= "LINK_ONCE_SAME_CONTENTS";
340 printf ("%s%s", comma
, ls
);
342 if (section
->comdat
!= NULL
)
343 printf (" (COMDAT %s %ld)", section
->comdat
->name
,
344 section
->comdat
->symbol
);
357 printf (_("Sections:\n"));
360 printf (_("Idx Name Size VMA LMA File off Algn"));
362 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
363 if (bfd_get_arch_size (abfd
) == 32)
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 objdump_sprintf
VPARAMS ((SFILE
*f
, const char *format
, ...))
1117 VA_OPEN (args
, format
);
1118 VA_FIXEDARG (args
, SFILE
*, f
);
1119 VA_FIXEDARG (args
, const char *, format
);
1121 vasprintf (&buf
, format
, args
);
1126 fatal (_("Out of virtual memory"));
1131 while ((size_t) ((f
->buffer
+ f
->size
) - f
->current
) < n
+ 1)
1135 curroff
= f
->current
- f
->buffer
;
1137 f
->buffer
= xrealloc (f
->buffer
, f
->size
);
1138 f
->current
= f
->buffer
+ curroff
;
1141 memcpy (f
->current
, buf
, n
);
1143 f
->current
[0] = '\0';
1151 /* The number of zeroes we want to see before we start skipping them.
1152 The number is arbitrarily chosen. */
1155 #define SKIP_ZEROES (8)
1158 /* The number of zeroes to skip at the end of a section. If the
1159 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1160 SKIP_ZEROES, they will be disassembled. If there are fewer than
1161 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1162 attempt to avoid disassembling zeroes inserted by section
1165 #ifndef SKIP_ZEROES_AT_END
1166 #define SKIP_ZEROES_AT_END (3)
1169 /* Disassemble some data in memory between given values. */
1172 disassemble_bytes (info
, disassemble_fn
, insns
, data
,
1173 start_offset
, stop_offset
, relppp
,
1175 struct disassemble_info
*info
;
1176 disassembler_ftype disassemble_fn
;
1179 bfd_vma start_offset
;
1180 bfd_vma stop_offset
;
1184 struct objdump_disasm_info
*aux
;
1186 int octets_per_line
;
1188 int skip_addr_chars
;
1189 bfd_vma addr_offset
;
1190 int opb
= info
->octets_per_byte
;
1192 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1196 octets_per_line
= 4;
1198 octets_per_line
= 16;
1200 /* Figure out how many characters to skip at the start of an
1201 address, to make the disassembly look nicer. We discard leading
1202 zeroes in chunks of 4, ensuring that there is always a leading
1204 skip_addr_chars
= 0;
1205 if (! prefix_addresses
)
1213 + bfd_section_size (section
->owner
, section
) / opb
));
1215 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1218 skip_addr_chars
+= 4;
1223 info
->insn_info_valid
= 0;
1226 addr_offset
= start_offset
;
1227 while (addr_offset
< stop_offset
)
1231 boolean need_nl
= false;
1233 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1235 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1238 if (! disassemble_zeroes
1239 && (info
->insn_info_valid
== 0
1240 || info
->branch_delay_insns
== 0)
1241 && (z
- addr_offset
* opb
>= SKIP_ZEROES
1242 || (z
== stop_offset
* opb
&&
1243 z
- addr_offset
* opb
< SKIP_ZEROES_AT_END
)))
1247 /* If there are more nonzero octets to follow, we only skip
1248 zeroes in multiples of 4, to try to avoid running over
1249 the start of an instruction which happens to start with
1251 if (z
!= stop_offset
* opb
)
1252 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1254 octets
= z
- addr_offset
* opb
;
1265 if (with_line_numbers
|| with_source_code
)
1266 /* The line number tables will refer to unadjusted
1267 section VMAs, so we must undo any VMA modifications
1268 when calling show_line. */
1269 show_line (aux
->abfd
, section
, addr_offset
- adjust_section_vma
);
1271 if (! prefix_addresses
)
1275 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1276 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1280 printf ("%s:\t", buf
+ skip_addr_chars
);
1284 aux
->require_sec
= true;
1285 objdump_print_address (section
->vma
+ addr_offset
, info
);
1286 aux
->require_sec
= false;
1293 sfile
.buffer
= xmalloc (sfile
.size
);
1294 sfile
.current
= sfile
.buffer
;
1295 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1296 info
->stream
= (FILE *) &sfile
;
1297 info
->bytes_per_line
= 0;
1298 info
->bytes_per_chunk
= 0;
1300 #ifdef DISASSEMBLER_NEEDS_RELOCS
1301 /* FIXME: This is wrong. It tests the number of octets
1302 in the last instruction, not the current one. */
1303 if (*relppp
< relppend
1304 && (**relppp
)->address
>= addr_offset
1305 && (**relppp
)->address
<= addr_offset
+ octets
/ opb
)
1306 info
->flags
= INSN_HAS_RELOC
;
1311 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, info
);
1312 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1313 info
->stream
= stdout
;
1314 if (info
->bytes_per_line
!= 0)
1315 octets_per_line
= info
->bytes_per_line
;
1318 if (sfile
.current
!= sfile
.buffer
)
1319 printf ("%s\n", sfile
.buffer
);
1320 free (sfile
.buffer
);
1328 octets
= octets_per_line
;
1329 if (addr_offset
+ octets
/ opb
> stop_offset
)
1330 octets
= (stop_offset
- addr_offset
) * opb
;
1332 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1334 if (ISPRINT (data
[j
]))
1335 buf
[j
- addr_offset
* opb
] = data
[j
];
1337 buf
[j
- addr_offset
* opb
] = '.';
1339 buf
[j
- addr_offset
* opb
] = '\0';
1342 if (prefix_addresses
1344 : show_raw_insn
>= 0)
1348 /* If ! prefix_addresses and ! wide_output, we print
1349 octets_per_line octets per line. */
1351 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1352 pb
= octets_per_line
;
1354 if (info
->bytes_per_chunk
)
1355 bpc
= info
->bytes_per_chunk
;
1359 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1362 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1364 for (k
= bpc
- 1; k
>= 0; k
--)
1365 printf ("%02x", (unsigned) data
[j
+ k
]);
1370 for (k
= 0; k
< bpc
; k
++)
1371 printf ("%02x", (unsigned) data
[j
+ k
]);
1376 for (; pb
< octets_per_line
; pb
+= bpc
)
1380 for (k
= 0; k
< bpc
; k
++)
1385 /* Separate raw data from instruction by extra space. */
1396 printf ("%s", sfile
.buffer
);
1397 free (sfile
.buffer
);
1400 if (prefix_addresses
1402 : show_raw_insn
>= 0)
1410 j
= addr_offset
* opb
+ pb
;
1412 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1413 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1417 printf ("%s:\t", buf
+ skip_addr_chars
);
1419 pb
+= octets_per_line
;
1422 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1426 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1428 for (k
= bpc
- 1; k
>= 0; k
--)
1429 printf ("%02x", (unsigned) data
[j
+ k
]);
1434 for (k
= 0; k
< bpc
; k
++)
1435 printf ("%02x", (unsigned) data
[j
+ k
]);
1448 if ((section
->flags
& SEC_RELOC
) != 0
1449 #ifndef DISASSEMBLER_NEEDS_RELOCS
1454 while ((*relppp
) < relppend
1455 && ((**relppp
)->address
>= (bfd_vma
) addr_offset
1456 && (**relppp
)->address
< (bfd_vma
) addr_offset
+ octets
/ opb
))
1457 #ifdef DISASSEMBLER_NEEDS_RELOCS
1458 if (! dump_reloc_info
)
1472 objdump_print_value (section
->vma
+ q
->address
, info
, true);
1474 printf (": %s\t", q
->howto
->name
);
1476 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1477 printf ("*unknown*");
1480 const char *sym_name
;
1482 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1483 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1484 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1489 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1490 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1491 if (sym_name
== NULL
|| *sym_name
== '\0')
1492 sym_name
= "*unknown*";
1493 printf ("%s", sym_name
);
1500 objdump_print_value (q
->addend
, info
, true);
1512 addr_offset
+= octets
/ opb
;
1516 /* Disassemble the contents of an object file. */
1519 disassemble_data (abfd
)
1522 unsigned long addr_offset
;
1523 disassembler_ftype disassemble_fn
;
1524 struct disassemble_info disasm_info
;
1525 struct objdump_disasm_info aux
;
1530 prev_functionname
= NULL
;
1533 /* We make a copy of syms to sort. We don't want to sort syms
1534 because that will screw up the relocs. */
1535 sorted_syms
= (asymbol
**) xmalloc (symcount
* sizeof (asymbol
*));
1536 memcpy (sorted_syms
, syms
, symcount
* sizeof (asymbol
*));
1538 sorted_symcount
= remove_useless_symbols (sorted_syms
, symcount
);
1540 /* Sort the symbols into section and symbol order */
1541 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1543 INIT_DISASSEMBLE_INFO(disasm_info
, stdout
, fprintf
);
1544 disasm_info
.application_data
= (PTR
) &aux
;
1546 aux
.require_sec
= false;
1547 disasm_info
.print_address_func
= objdump_print_address
;
1548 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1550 if (machine
!= (char *) NULL
)
1552 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1555 fatal (_("Can't use supplied machine %s"), machine
);
1557 abfd
->arch_info
= info
;
1560 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1562 struct bfd_target
*xvec
;
1564 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
1565 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1566 xvec
->byteorder
= endian
;
1570 disassemble_fn
= disassembler (abfd
);
1571 if (!disassemble_fn
)
1573 non_fatal (_("Can't disassemble for architecture %s\n"),
1574 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1579 opb
= bfd_octets_per_byte (abfd
);
1581 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1582 disasm_info
.arch
= bfd_get_arch (abfd
);
1583 disasm_info
.mach
= bfd_get_mach (abfd
);
1584 disasm_info
.disassembler_options
= disassembler_options
;
1585 disasm_info
.octets_per_byte
= opb
;
1587 if (bfd_big_endian (abfd
))
1588 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1589 else if (bfd_little_endian (abfd
))
1590 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1592 /* ??? Aborting here seems too drastic. We could default to big or little
1594 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1596 for (section
= abfd
->sections
;
1597 section
!= (asection
*) NULL
;
1598 section
= section
->next
)
1600 bfd_byte
*data
= NULL
;
1601 bfd_size_type datasize
= 0;
1602 arelent
**relbuf
= NULL
;
1603 arelent
**relpp
= NULL
;
1604 arelent
**relppend
= NULL
;
1605 unsigned long stop_offset
;
1606 asymbol
*sym
= NULL
;
1609 if ((section
->flags
& SEC_LOAD
) == 0
1610 || (! disassemble_all
1612 && (section
->flags
& SEC_CODE
) == 0))
1614 if (only
!= (char *) NULL
&& strcmp (only
, section
->name
) != 0)
1617 if ((section
->flags
& SEC_RELOC
) != 0
1618 #ifndef DISASSEMBLER_NEEDS_RELOCS
1625 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1627 bfd_fatal (bfd_get_filename (abfd
));
1633 relbuf
= (arelent
**) xmalloc (relsize
);
1634 relcount
= bfd_canonicalize_reloc (abfd
, section
, relbuf
, syms
);
1636 bfd_fatal (bfd_get_filename (abfd
));
1638 /* Sort the relocs by address. */
1639 qsort (relbuf
, relcount
, sizeof (arelent
*), compare_relocs
);
1642 relppend
= relpp
+ relcount
;
1644 /* Skip over the relocs belonging to addresses below the
1646 if (start_address
!= (bfd_vma
) -1)
1648 while (relpp
< relppend
1649 && (*relpp
)->address
< start_address
)
1655 printf (_("Disassembly of section %s:\n"), section
->name
);
1657 datasize
= bfd_get_section_size_before_reloc (section
);
1661 data
= (bfd_byte
*) xmalloc ((size_t) datasize
);
1663 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1666 disasm_info
.buffer
= data
;
1667 disasm_info
.buffer_vma
= section
->vma
;
1668 disasm_info
.buffer_length
= datasize
;
1669 disasm_info
.section
= section
;
1670 if (start_address
== (bfd_vma
) -1
1671 || start_address
< disasm_info
.buffer_vma
)
1674 addr_offset
= start_address
- disasm_info
.buffer_vma
;
1675 if (stop_address
== (bfd_vma
) -1)
1676 stop_offset
= datasize
/ opb
;
1679 if (stop_address
< disasm_info
.buffer_vma
)
1682 stop_offset
= stop_address
- disasm_info
.buffer_vma
;
1683 if (stop_offset
> disasm_info
.buffer_length
/ opb
)
1684 stop_offset
= disasm_info
.buffer_length
/ opb
;
1687 sym
= find_symbol_for_address (abfd
, section
, section
->vma
+ addr_offset
,
1690 while (addr_offset
< stop_offset
)
1693 unsigned long nextstop_offset
;
1696 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= section
->vma
+ addr_offset
)
1701 (x
< sorted_symcount
1702 && bfd_asymbol_value (sorted_syms
[x
]) <= section
->vma
+ addr_offset
);
1705 disasm_info
.symbols
= & sorted_syms
[place
];
1706 disasm_info
.num_symbols
= x
- place
;
1709 disasm_info
.symbols
= NULL
;
1711 if (! prefix_addresses
)
1714 objdump_print_addr_with_sym (abfd
, section
, sym
,
1715 section
->vma
+ addr_offset
,
1721 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
)
1723 else if (sym
== NULL
)
1727 /* Search forward for the next appropriate symbol in
1728 SECTION. Note that all the symbols are sorted
1729 together into one big array, and that some sections
1730 may have overlapping addresses. */
1731 while (place
< sorted_symcount
1732 && (sorted_syms
[place
]->section
!= section
1733 || (bfd_asymbol_value (sorted_syms
[place
])
1734 <= bfd_asymbol_value (sym
))))
1736 if (place
>= sorted_symcount
)
1739 nextsym
= sorted_syms
[place
];
1742 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
)
1744 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1745 if (nextstop_offset
> stop_offset
)
1746 nextstop_offset
= stop_offset
;
1748 else if (nextsym
== NULL
)
1749 nextstop_offset
= stop_offset
;
1752 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1753 if (nextstop_offset
> stop_offset
)
1754 nextstop_offset
= stop_offset
;
1757 /* If a symbol is explicitly marked as being an object
1758 rather than a function, just dump the bytes without
1759 disassembling them. */
1762 || bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
1763 || ((sym
->flags
& BSF_OBJECT
) == 0
1764 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1766 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1768 || (sym
->flags
& BSF_FUNCTION
) != 0)
1773 disassemble_bytes (&disasm_info
, disassemble_fn
, insns
, data
,
1774 addr_offset
, nextstop_offset
, &relpp
, relppend
);
1776 addr_offset
= nextstop_offset
;
1788 /* Define a table of stab values and print-strings. We wish the initializer
1789 could be a direct-mapped table, but instead we build one the first
1792 static void dump_section_stabs
PARAMS ((bfd
*abfd
, char *stabsect_name
,
1793 char *strsect_name
));
1795 /* Dump the stabs sections from an object file that has a section that
1796 uses Sun stabs encoding. */
1802 dump_section_stabs (abfd
, ".stab", ".stabstr");
1803 dump_section_stabs (abfd
, ".stab.excl", ".stab.exclstr");
1804 dump_section_stabs (abfd
, ".stab.index", ".stab.indexstr");
1805 dump_section_stabs (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1808 static bfd_byte
*stabs
;
1809 static bfd_size_type stab_size
;
1811 static char *strtab
;
1812 static bfd_size_type stabstr_size
;
1814 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1815 and string table section STRSECT_NAME into `strtab'.
1816 If the section exists and was read, allocate the space and return true.
1817 Otherwise return false. */
1820 read_section_stabs (abfd
, stabsect_name
, strsect_name
)
1822 const char *stabsect_name
;
1823 const char *strsect_name
;
1825 asection
*stabsect
, *stabstrsect
;
1827 stabsect
= bfd_get_section_by_name (abfd
, stabsect_name
);
1830 printf (_("No %s section present\n\n"), stabsect_name
);
1834 stabstrsect
= bfd_get_section_by_name (abfd
, strsect_name
);
1835 if (0 == stabstrsect
)
1837 non_fatal (_("%s has no %s section"),
1838 bfd_get_filename (abfd
), strsect_name
);
1843 stab_size
= bfd_section_size (abfd
, stabsect
);
1844 stabstr_size
= bfd_section_size (abfd
, stabstrsect
);
1846 stabs
= (bfd_byte
*) xmalloc (stab_size
);
1847 strtab
= (char *) xmalloc (stabstr_size
);
1849 if (! bfd_get_section_contents (abfd
, stabsect
, (PTR
) stabs
, 0, stab_size
))
1851 non_fatal (_("Reading %s section of %s failed: %s"),
1852 stabsect_name
, bfd_get_filename (abfd
),
1853 bfd_errmsg (bfd_get_error ()));
1860 if (! bfd_get_section_contents (abfd
, stabstrsect
, (PTR
) strtab
, 0,
1863 non_fatal (_("Reading %s section of %s failed: %s\n"),
1864 strsect_name
, bfd_get_filename (abfd
),
1865 bfd_errmsg (bfd_get_error ()));
1875 /* Stabs entries use a 12 byte format:
1876 4 byte string table index
1878 1 byte stab other field
1879 2 byte stab desc field
1881 FIXME: This will have to change for a 64 bit object format. */
1883 #define STRDXOFF (0)
1885 #define OTHEROFF (5)
1888 #define STABSIZE (12)
1890 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1891 using string table section STRSECT_NAME (in `strtab'). */
1894 print_section_stabs (abfd
, stabsect_name
, strsect_name
)
1896 const char *stabsect_name
;
1897 const char *strsect_name ATTRIBUTE_UNUSED
;
1900 unsigned file_string_table_offset
= 0, next_file_string_table_offset
= 0;
1901 bfd_byte
*stabp
, *stabs_end
;
1904 stabs_end
= stabp
+ stab_size
;
1906 printf (_("Contents of %s section:\n\n"), stabsect_name
);
1907 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1909 /* Loop through all symbols and print them.
1911 We start the index at -1 because there is a dummy symbol on
1912 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1914 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
1918 unsigned char type
, other
;
1919 unsigned short desc
;
1922 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
1923 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
1924 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
1925 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
1926 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
1928 printf ("\n%-6d ", i
);
1929 /* Either print the stab name, or, if unnamed, print its number
1930 again (makes consistent formatting for tools like awk). */
1931 name
= bfd_get_stab_name (type
);
1933 printf ("%-6s", name
);
1934 else if (type
== N_UNDF
)
1937 printf ("%-6d", type
);
1938 printf (" %-6d %-6d ", other
, desc
);
1939 bfd_printf_vma (abfd
, value
);
1940 printf (" %-6lu", strx
);
1942 /* Symbols with type == 0 (N_UNDF) specify the length of the
1943 string table associated with this file. We use that info
1944 to know how to relocate the *next* file's string table indices. */
1948 file_string_table_offset
= next_file_string_table_offset
;
1949 next_file_string_table_offset
+= value
;
1953 /* Using the (possibly updated) string table offset, print the
1954 string (if any) associated with this symbol. */
1956 if ((strx
+ file_string_table_offset
) < stabstr_size
)
1957 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
1966 dump_section_stabs (abfd
, stabsect_name
, strsect_name
)
1968 char *stabsect_name
;
1973 /* Check for section names for which stabsect_name is a prefix, to
1974 handle .stab0, etc. */
1975 for (s
= abfd
->sections
;
1981 len
= strlen (stabsect_name
);
1983 /* If the prefix matches, and the files section name ends with a
1984 nul or a digit, then we match. I.e., we want either an exact
1985 match or a section followed by a number. */
1986 if (strncmp (stabsect_name
, s
->name
, len
) == 0
1987 && (s
->name
[len
] == '\000'
1988 || ISDIGIT (s
->name
[len
])))
1990 if (read_section_stabs (abfd
, s
->name
, strsect_name
))
1992 print_section_stabs (abfd
, s
->name
, strsect_name
);
2001 dump_bfd_header (abfd
)
2006 printf (_("architecture: %s, "),
2007 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2008 bfd_get_mach (abfd
)));
2009 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2011 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2012 PF (HAS_RELOC
, "HAS_RELOC");
2013 PF (EXEC_P
, "EXEC_P");
2014 PF (HAS_LINENO
, "HAS_LINENO");
2015 PF (HAS_DEBUG
, "HAS_DEBUG");
2016 PF (HAS_SYMS
, "HAS_SYMS");
2017 PF (HAS_LOCALS
, "HAS_LOCALS");
2018 PF (DYNAMIC
, "DYNAMIC");
2019 PF (WP_TEXT
, "WP_TEXT");
2020 PF (D_PAGED
, "D_PAGED");
2021 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2022 printf (_("\nstart address 0x"));
2023 bfd_printf_vma (abfd
, abfd
->start_address
);
2028 dump_bfd_private_header (abfd
)
2031 bfd_print_private_bfd_data (abfd
, stdout
);
2034 /* Dump selected contents of ABFD */
2040 /* If we are adjusting section VMA's, change them all now. Changing
2041 the BFD information is a hack. However, we must do it, or
2042 bfd_find_nearest_line will not do the right thing. */
2043 if (adjust_section_vma
!= 0)
2047 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2049 s
->vma
+= adjust_section_vma
;
2050 s
->lma
+= adjust_section_vma
;
2054 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2057 print_arelt_descr (stdout
, abfd
, true);
2058 if (dump_file_header
)
2059 dump_bfd_header (abfd
);
2060 if (dump_private_headers
)
2061 dump_bfd_private_header (abfd
);
2063 if (dump_section_headers
)
2064 dump_headers (abfd
);
2065 if (dump_symtab
|| dump_reloc_info
|| disassemble
|| dump_debugging
)
2067 syms
= slurp_symtab (abfd
);
2069 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
)
2071 dynsyms
= slurp_dynamic_symtab (abfd
);
2074 dump_symbols (abfd
, false);
2075 if (dump_dynamic_symtab
)
2076 dump_symbols (abfd
, true);
2077 if (dump_stab_section_info
)
2079 if (dump_reloc_info
&& ! disassemble
)
2081 if (dump_dynamic_reloc_info
)
2082 dump_dynamic_relocs (abfd
);
2083 if (dump_section_contents
)
2086 disassemble_data (abfd
);
2091 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2092 if (dhandle
!= NULL
)
2094 if (! print_debugging_info (stdout
, dhandle
))
2096 non_fatal (_("%s: printing debugging information failed"),
2097 bfd_get_filename (abfd
));
2120 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2126 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2128 nonfatal (bfd_get_filename (abfd
));
2129 list_matching_formats (matching
);
2134 if (bfd_get_error () != bfd_error_file_not_recognized
)
2136 nonfatal (bfd_get_filename (abfd
));
2140 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
2146 nonfatal (bfd_get_filename (abfd
));
2148 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2150 list_matching_formats (matching
);
2156 display_file (filename
, target
)
2160 bfd
*file
, *arfile
= (bfd
*) NULL
;
2162 file
= bfd_openr (filename
, target
);
2165 nonfatal (filename
);
2169 if (bfd_check_format (file
, bfd_archive
) == true)
2171 bfd
*last_arfile
= NULL
;
2173 printf (_("In archive %s:\n"), bfd_get_filename (file
));
2176 bfd_set_error (bfd_error_no_error
);
2178 arfile
= bfd_openr_next_archived_file (file
, arfile
);
2181 if (bfd_get_error () != bfd_error_no_more_archived_files
)
2182 nonfatal (bfd_get_filename (file
));
2186 display_bfd (arfile
);
2188 if (last_arfile
!= NULL
)
2189 bfd_close (last_arfile
);
2190 last_arfile
= arfile
;
2193 if (last_arfile
!= NULL
)
2194 bfd_close (last_arfile
);
2202 /* Actually display the various requested regions */
2210 bfd_size_type datasize
= 0;
2211 bfd_size_type addr_offset
;
2212 bfd_size_type start_offset
, stop_offset
;
2213 unsigned int opb
= bfd_octets_per_byte (abfd
);
2215 for (section
= abfd
->sections
; section
!= NULL
; section
=
2220 if (only
== (char *) NULL
||
2221 strcmp (only
, section
->name
) == 0)
2223 if (section
->flags
& SEC_HAS_CONTENTS
)
2225 printf (_("Contents of section %s:\n"), section
->name
);
2227 if (bfd_section_size (abfd
, section
) == 0)
2229 data
= (bfd_byte
*) xmalloc ((size_t) bfd_section_size (abfd
, section
));
2230 datasize
= bfd_section_size (abfd
, section
);
2233 bfd_get_section_contents (abfd
, section
, (PTR
) data
, 0, bfd_section_size (abfd
, section
));
2235 if (start_address
== (bfd_vma
) -1
2236 || start_address
< section
->vma
)
2239 start_offset
= start_address
- section
->vma
;
2240 if (stop_address
== (bfd_vma
) -1)
2241 stop_offset
= bfd_section_size (abfd
, section
) / opb
;
2244 if (stop_address
< section
->vma
)
2247 stop_offset
= stop_address
- section
->vma
;
2248 if (stop_offset
> bfd_section_size (abfd
, section
) / opb
)
2249 stop_offset
= bfd_section_size (abfd
, section
) / opb
;
2251 for (addr_offset
= start_offset
;
2252 addr_offset
< stop_offset
; addr_offset
+= onaline
)
2256 printf (" %04lx ", (unsigned long int)
2257 (addr_offset
+ section
->vma
));
2258 for (j
= addr_offset
* opb
;
2259 j
< addr_offset
* opb
+ onaline
; j
++)
2261 if (j
< stop_offset
* opb
)
2262 printf ("%02x", (unsigned) (data
[j
]));
2270 for (j
= addr_offset
; j
< addr_offset
* opb
+ onaline
; j
++)
2272 if (j
>= stop_offset
* opb
)
2275 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2285 /* Should perhaps share code and display with nm? */
2287 dump_symbols (abfd
, dynamic
)
2288 bfd
*abfd ATTRIBUTE_UNUSED
;
2301 printf ("DYNAMIC SYMBOL TABLE:\n");
2309 printf ("SYMBOL TABLE:\n");
2312 for (count
= 0; count
< max
; count
++)
2316 bfd
*cur_bfd
= bfd_asymbol_bfd (*current
);
2318 if (cur_bfd
!= NULL
)
2323 name
= bfd_asymbol_name (*current
);
2325 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2329 /* If we want to demangle the name, we demangle it
2330 here, and temporarily clobber it while calling
2331 bfd_print_symbol. FIXME: This is a gross hack. */
2334 if (bfd_get_symbol_leading_char (cur_bfd
) == *n
)
2336 alloc
= cplus_demangle (n
, DMGL_ANSI
| DMGL_PARAMS
);
2338 (*current
)->name
= alloc
;
2340 (*current
)->name
= n
;
2343 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2344 bfd_print_symbol_all
);
2346 (*current
)->name
= name
;
2367 for (a
= abfd
->sections
; a
!= (asection
*) NULL
; a
= a
->next
)
2371 if (bfd_is_abs_section (a
))
2373 if (bfd_is_und_section (a
))
2375 if (bfd_is_com_section (a
))
2380 if (strcmp (only
, a
->name
))
2383 else if ((a
->flags
& SEC_RELOC
) == 0)
2386 relsize
= bfd_get_reloc_upper_bound (abfd
, a
);
2388 bfd_fatal (bfd_get_filename (abfd
));
2390 printf ("RELOCATION RECORDS FOR [%s]:", a
->name
);
2394 printf (" (none)\n\n");
2398 relpp
= (arelent
**) xmalloc (relsize
);
2399 relcount
= bfd_canonicalize_reloc (abfd
, a
, relpp
, syms
);
2401 bfd_fatal (bfd_get_filename (abfd
));
2402 else if (relcount
== 0)
2404 printf (" (none)\n\n");
2409 dump_reloc_set (abfd
, a
, relpp
, relcount
);
2418 dump_dynamic_relocs (abfd
)
2425 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2427 bfd_fatal (bfd_get_filename (abfd
));
2429 printf ("DYNAMIC RELOCATION RECORDS");
2433 printf (" (none)\n\n");
2437 relpp
= (arelent
**) xmalloc (relsize
);
2438 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2440 bfd_fatal (bfd_get_filename (abfd
));
2441 else if (relcount
== 0)
2443 printf (" (none)\n\n");
2448 dump_reloc_set (abfd
, (asection
*) NULL
, relpp
, relcount
);
2456 dump_reloc_set (abfd
, sec
, relpp
, relcount
)
2463 char *last_filename
, *last_functionname
;
2464 unsigned int last_line
;
2466 /* Get column headers lined up reasonably. */
2472 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2473 width
= strlen (buf
) - 7;
2475 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2478 last_filename
= NULL
;
2479 last_functionname
= NULL
;
2482 for (p
= relpp
; relcount
&& *p
!= (arelent
*) NULL
; p
++, relcount
--)
2485 const char *filename
, *functionname
;
2487 const char *sym_name
;
2488 const char *section_name
;
2490 if (start_address
!= (bfd_vma
) -1
2491 && q
->address
< start_address
)
2493 if (stop_address
!= (bfd_vma
) -1
2494 && q
->address
> stop_address
)
2497 if (with_line_numbers
2499 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2500 &filename
, &functionname
, &line
))
2502 if (functionname
!= NULL
2503 && (last_functionname
== NULL
2504 || strcmp (functionname
, last_functionname
) != 0))
2506 printf ("%s():\n", functionname
);
2507 if (last_functionname
!= NULL
)
2508 free (last_functionname
);
2509 last_functionname
= xstrdup (functionname
);
2512 && (line
!= last_line
2513 || (filename
!= NULL
2514 && last_filename
!= NULL
2515 && strcmp (filename
, last_filename
) != 0)))
2517 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2519 if (last_filename
!= NULL
)
2520 free (last_filename
);
2521 if (filename
== NULL
)
2522 last_filename
= NULL
;
2524 last_filename
= xstrdup (filename
);
2528 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2530 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2531 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2536 section_name
= NULL
;
2540 bfd_printf_vma (abfd
, q
->address
);
2542 printf (" %-16s ", q
->howto
->name
);
2544 printf (" %-16d ", q
->howto
->type
);
2545 objdump_print_symname (abfd
, (struct disassemble_info
*) NULL
,
2550 if (section_name
== (CONST
char *) NULL
)
2551 section_name
= "*unknown*";
2552 bfd_printf_vma (abfd
, q
->address
);
2553 printf (" %-16s [%s]",
2560 bfd_printf_vma (abfd
, q
->addend
);
2566 /* The length of the longest architecture name + 1. */
2567 #define LONGEST_ARCH sizeof("powerpc:common")
2570 endian_string (endian
)
2571 enum bfd_endian endian
;
2573 if (endian
== BFD_ENDIAN_BIG
)
2574 return "big endian";
2575 else if (endian
== BFD_ENDIAN_LITTLE
)
2576 return "little endian";
2578 return "endianness unknown";
2581 /* List the targets that BFD is configured to support, each followed
2582 by its endianness and the architectures it supports. */
2585 display_target_list ()
2587 extern const bfd_target
*const *bfd_target_vector
;
2591 dummy_name
= make_temp_file (NULL
);
2592 for (t
= 0; bfd_target_vector
[t
]; t
++)
2594 const bfd_target
*p
= bfd_target_vector
[t
];
2595 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2598 printf ("%s\n (header %s, data %s)\n", p
->name
,
2599 endian_string (p
->header_byteorder
),
2600 endian_string (p
->byteorder
));
2604 nonfatal (dummy_name
);
2608 if (! bfd_set_format (abfd
, bfd_object
))
2610 if (bfd_get_error () != bfd_error_invalid_operation
)
2612 bfd_close_all_done (abfd
);
2616 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2617 if (bfd_set_arch_mach (abfd
, (enum bfd_architecture
) a
, 0))
2619 bfd_printable_arch_mach ((enum bfd_architecture
) a
, 0));
2620 bfd_close_all_done (abfd
);
2622 unlink (dummy_name
);
2626 /* Print a table showing which architectures are supported for entries
2627 FIRST through LAST-1 of bfd_target_vector (targets across,
2628 architectures down). */
2631 display_info_table (first
, last
)
2635 extern const bfd_target
*const *bfd_target_vector
;
2639 /* Print heading of target names. */
2640 printf ("\n%*s", (int) LONGEST_ARCH
, " ");
2641 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2642 printf ("%s ", bfd_target_vector
[t
]->name
);
2645 dummy_name
= make_temp_file (NULL
);
2646 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2647 if (strcmp (bfd_printable_arch_mach (a
, 0), "UNKNOWN!") != 0)
2649 printf ("%*s ", (int) LONGEST_ARCH
- 1,
2650 bfd_printable_arch_mach (a
, 0));
2651 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2653 const bfd_target
*p
= bfd_target_vector
[t
];
2655 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2665 if (! bfd_set_format (abfd
, bfd_object
))
2667 if (bfd_get_error () != bfd_error_invalid_operation
)
2675 if (! bfd_set_arch_mach (abfd
, a
, 0))
2680 printf ("%s ", p
->name
);
2683 int l
= strlen (p
->name
);
2689 bfd_close_all_done (abfd
);
2693 unlink (dummy_name
);
2697 /* Print tables of all the target-architecture combinations that
2698 BFD has been configured to support. */
2701 display_target_tables ()
2704 extern const bfd_target
*const *bfd_target_vector
;
2708 colum
= getenv ("COLUMNS");
2710 columns
= atoi (colum
);
2715 while (bfd_target_vector
[t
] != NULL
)
2719 wid
= LONGEST_ARCH
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2721 while (wid
< columns
&& bfd_target_vector
[t
] != NULL
)
2725 newwid
= wid
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2726 if (newwid
>= columns
)
2731 display_info_table (oldt
, t
);
2738 printf (_("BFD header file version %s\n"), BFD_VERSION_STRING
);
2739 display_target_list ();
2740 display_target_tables ();
2743 int main
PARAMS ((int, char **));
2751 char *target
= default_target
;
2752 boolean seenflag
= false;
2754 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
2755 setlocale (LC_MESSAGES
, "");
2757 #if defined (HAVE_SETLOCALE)
2758 setlocale (LC_CTYPE
, "");
2760 bindtextdomain (PACKAGE
, LOCALEDIR
);
2761 textdomain (PACKAGE
);
2763 program_name
= *argv
;
2764 xmalloc_set_program_name (program_name
);
2766 START_PROGRESS (program_name
, 0);
2769 set_default_bfd_target ();
2771 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VvCdDlfaHhrRtTxsSj:wE:zgG",
2772 long_options
, (int *) 0))
2778 break; /* We've been given a long option. */
2783 disassembler_options
= optarg
;
2789 with_line_numbers
= true;
2798 enum demangling_styles style
;
2800 style
= cplus_demangle_name_to_style (optarg
);
2801 if (style
== unknown_demangling
)
2802 fatal (_("unknown demangling style `%s'"),
2805 cplus_demangle_set_style (style
);
2811 case OPTION_ADJUST_VMA
:
2812 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
2814 case OPTION_START_ADDRESS
:
2815 start_address
= parse_vma (optarg
, "--start-address");
2817 case OPTION_STOP_ADDRESS
:
2818 stop_address
= parse_vma (optarg
, "--stop-address");
2821 if (strcmp (optarg
, "B") == 0)
2822 endian
= BFD_ENDIAN_BIG
;
2823 else if (strcmp (optarg
, "L") == 0)
2824 endian
= BFD_ENDIAN_LITTLE
;
2827 non_fatal (_("unrecognized -E option"));
2832 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
2833 endian
= BFD_ENDIAN_BIG
;
2834 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
2835 endian
= BFD_ENDIAN_LITTLE
;
2838 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
2844 dump_file_header
= true;
2848 formats_info
= true;
2852 dump_private_headers
= true;
2856 dump_private_headers
= true;
2858 dump_reloc_info
= true;
2859 dump_file_header
= true;
2860 dump_ar_hdrs
= true;
2861 dump_section_headers
= true;
2869 dump_dynamic_symtab
= true;
2877 disassemble_zeroes
= true;
2881 disassemble_all
= true;
2886 with_source_code
= true;
2894 dump_stab_section_info
= true;
2898 dump_section_contents
= true;
2902 dump_reloc_info
= true;
2906 dump_dynamic_reloc_info
= true;
2910 dump_ar_hdrs
= true;
2914 dump_section_headers
= true;
2922 show_version
= true;
2932 print_version ("objdump");
2934 if (seenflag
== false)
2942 display_file ("a.out", target
);
2944 for (; optind
< argc
;)
2945 display_file (argv
[optind
++], target
);
2948 END_PROGRESS (program_name
);