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_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");
307 PF (SEC_READONLY
, "READONLY");
308 PF (SEC_CODE
, "CODE");
309 PF (SEC_DATA
, "DATA");
311 PF (SEC_DEBUGGING
, "DEBUGGING");
312 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
313 PF (SEC_EXCLUDE
, "EXCLUDE");
314 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
315 PF (SEC_BLOCK
, "BLOCK");
316 PF (SEC_CLINK
, "CLINK");
317 PF (SEC_SMALL_DATA
, "SMALL_DATA");
318 PF (SEC_SHARED
, "SHARED");
319 PF (SEC_ARCH_BIT_0
, "ARCH_BIT_0");
321 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
325 switch (section
->flags
& SEC_LINK_DUPLICATES
)
329 case SEC_LINK_DUPLICATES_DISCARD
:
330 ls
= "LINK_ONCE_DISCARD";
332 case SEC_LINK_DUPLICATES_ONE_ONLY
:
333 ls
= "LINK_ONCE_ONE_ONLY";
335 case SEC_LINK_DUPLICATES_SAME_SIZE
:
336 ls
= "LINK_ONCE_SAME_SIZE";
338 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
339 ls
= "LINK_ONCE_SAME_CONTENTS";
342 printf ("%s%s", comma
, ls
);
344 if (section
->comdat
!= NULL
)
345 printf (" (COMDAT %s %ld)", section
->comdat
->name
,
346 section
->comdat
->symbol
);
359 printf (_("Sections:\n"));
362 printf (_("Idx Name Size VMA LMA File off Algn"));
364 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
365 if (bfd_get_arch_size (abfd
) == 32)
366 printf (_("Idx Name Size VMA LMA File off Algn"));
368 printf (_("Idx Name Size VMA LMA File off Algn"));
372 printf (_(" Flags"));
375 bfd_map_over_sections (abfd
, dump_section_header
, (PTR
) NULL
);
382 asymbol
**sy
= (asymbol
**) NULL
;
385 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
387 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
392 storage
= bfd_get_symtab_upper_bound (abfd
);
394 bfd_fatal (bfd_get_filename (abfd
));
398 sy
= (asymbol
**) xmalloc (storage
);
400 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
402 bfd_fatal (bfd_get_filename (abfd
));
404 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
408 /* Read in the dynamic symbols. */
411 slurp_dynamic_symtab (abfd
)
414 asymbol
**sy
= (asymbol
**) NULL
;
417 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
420 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
422 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
427 bfd_fatal (bfd_get_filename (abfd
));
432 sy
= (asymbol
**) xmalloc (storage
);
434 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
436 bfd_fatal (bfd_get_filename (abfd
));
437 if (dynsymcount
== 0)
438 non_fatal (_("%s: No dynamic symbols"), bfd_get_filename (abfd
));
442 /* Filter out (in place) symbols that are useless for disassembly.
443 COUNT is the number of elements in SYMBOLS.
444 Return the number of useful symbols. */
447 remove_useless_symbols (symbols
, count
)
451 register asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
455 asymbol
*sym
= *in_ptr
++;
457 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
459 if (sym
->flags
& (BSF_DEBUGGING
))
461 if (bfd_is_und_section (sym
->section
)
462 || bfd_is_com_section (sym
->section
))
467 return out_ptr
- symbols
;
470 /* Sort symbols into value order. */
473 compare_symbols (ap
, bp
)
477 const asymbol
*a
= *(const asymbol
**)ap
;
478 const asymbol
*b
= *(const asymbol
**)bp
;
482 flagword aflags
, bflags
;
484 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
486 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
489 if (a
->section
> b
->section
)
491 else if (a
->section
< b
->section
)
494 an
= bfd_asymbol_name (a
);
495 bn
= bfd_asymbol_name (b
);
499 /* The symbols gnu_compiled and gcc2_compiled convey no real
500 information, so put them after other symbols with the same value. */
502 af
= (strstr (an
, "gnu_compiled") != NULL
503 || strstr (an
, "gcc2_compiled") != NULL
);
504 bf
= (strstr (bn
, "gnu_compiled") != NULL
505 || strstr (bn
, "gcc2_compiled") != NULL
);
512 /* We use a heuristic for the file name, to try to sort it after
513 more useful symbols. It may not work on non Unix systems, but it
514 doesn't really matter; the only difference is precisely which
515 symbol names get printed. */
517 #define file_symbol(s, sn, snl) \
518 (((s)->flags & BSF_FILE) != 0 \
519 || ((sn)[(snl) - 2] == '.' \
520 && ((sn)[(snl) - 1] == 'o' \
521 || (sn)[(snl) - 1] == 'a')))
523 af
= file_symbol (a
, an
, anl
);
524 bf
= file_symbol (b
, bn
, bnl
);
531 /* Try to sort global symbols before local symbols before function
532 symbols before debugging symbols. */
537 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
539 if ((aflags
& BSF_DEBUGGING
) != 0)
544 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
546 if ((aflags
& BSF_FUNCTION
) != 0)
551 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
553 if ((aflags
& BSF_LOCAL
) != 0)
558 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
560 if ((aflags
& BSF_GLOBAL
) != 0)
566 /* Symbols that start with '.' might be section names, so sort them
567 after symbols that don't start with '.'. */
568 if (an
[0] == '.' && bn
[0] != '.')
570 if (an
[0] != '.' && bn
[0] == '.')
573 /* Finally, if we can't distinguish them in any other way, try to
574 get consistent results by sorting the symbols by name. */
575 return strcmp (an
, bn
);
578 /* Sort relocs into address order. */
581 compare_relocs (ap
, bp
)
585 const arelent
*a
= *(const arelent
**)ap
;
586 const arelent
*b
= *(const arelent
**)bp
;
588 if (a
->address
> b
->address
)
590 else if (a
->address
< b
->address
)
593 /* So that associated relocations tied to the same address show up
594 in the correct order, we don't do any further sorting. */
603 /* Print VMA to STREAM. If SKIP_ZEROES is true, omit leading zeroes. */
606 objdump_print_value (vma
, info
, skip_zeroes
)
608 struct disassemble_info
*info
;
613 struct objdump_disasm_info
*aux
614 = (struct objdump_disasm_info
*) info
->application_data
;
616 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
621 for (p
= buf
; *p
== '0'; ++p
)
626 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
629 /* Print the name of a symbol. */
632 objdump_print_symname (abfd
, info
, sym
)
634 struct disassemble_info
*info
;
642 name
= bfd_asymbol_name (sym
);
643 if (! do_demangle
|| name
[0] == '\0')
647 /* Demangle the name. */
648 if (bfd_get_symbol_leading_char (abfd
) == name
[0])
651 alloc
= cplus_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
659 (*info
->fprintf_func
) (info
->stream
, "%s", print
);
661 printf ("%s", print
);
667 /* Locate a symbol given a bfd, a section, and a VMA. If REQUIRE_SEC
668 is true, then always require the symbol to be in the section. This
669 returns NULL if there is no suitable symbol. If PLACE is not NULL,
670 then *PLACE is set to the index of the symbol in sorted_syms. */
673 find_symbol_for_address (abfd
, sec
, vma
, require_sec
, place
)
680 /* @@ Would it speed things up to cache the last two symbols returned,
681 and maybe their address ranges? For many processors, only one memory
682 operand can be present at a time, so the 2-entry cache wouldn't be
683 constantly churned by code doing heavy memory accesses. */
685 /* Indices in `sorted_syms'. */
687 long max
= sorted_symcount
;
689 unsigned int opb
= bfd_octets_per_byte (abfd
);
691 if (sorted_symcount
< 1)
694 /* Perform a binary search looking for the closest symbol to the
695 required value. We are searching the range (min, max]. */
696 while (min
+ 1 < max
)
700 thisplace
= (max
+ min
) / 2;
701 sym
= sorted_syms
[thisplace
];
703 if (bfd_asymbol_value (sym
) > vma
)
705 else if (bfd_asymbol_value (sym
) < vma
)
714 /* The symbol we want is now in min, the low end of the range we
715 were searching. If there are several symbols with the same
716 value, we want the first one. */
719 && (bfd_asymbol_value (sorted_syms
[thisplace
])
720 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
723 /* If the file is relocateable, and the symbol could be from this
724 section, prefer a symbol from this section over symbols from
725 others, even if the other symbol's value might be closer.
727 Note that this may be wrong for some symbol references if the
728 sections have overlapping memory ranges, but in that case there's
729 no way to tell what's desired without looking at the relocation
732 if (sorted_syms
[thisplace
]->section
!= sec
734 || ((abfd
->flags
& HAS_RELOC
) != 0
735 && vma
>= bfd_get_section_vma (abfd
, sec
)
736 && vma
< (bfd_get_section_vma (abfd
, sec
)
737 + bfd_section_size (abfd
, sec
) / opb
))))
741 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
743 if (bfd_asymbol_value (sorted_syms
[i
])
744 != bfd_asymbol_value (sorted_syms
[thisplace
]))
750 if (sorted_syms
[i
]->section
== sec
752 || sorted_syms
[i
- 1]->section
!= sec
753 || (bfd_asymbol_value (sorted_syms
[i
])
754 != bfd_asymbol_value (sorted_syms
[i
- 1]))))
761 if (sorted_syms
[thisplace
]->section
!= sec
)
763 /* We didn't find a good symbol with a smaller value.
764 Look for one with a larger value. */
765 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
767 if (sorted_syms
[i
]->section
== sec
)
775 if (sorted_syms
[thisplace
]->section
!= sec
777 || ((abfd
->flags
& HAS_RELOC
) != 0
778 && vma
>= bfd_get_section_vma (abfd
, sec
)
779 && vma
< (bfd_get_section_vma (abfd
, sec
)
780 + bfd_section_size (abfd
, sec
)))))
782 /* There is no suitable symbol. */
790 return sorted_syms
[thisplace
];
793 /* Print an address to INFO symbolically. */
796 objdump_print_addr_with_sym (abfd
, sec
, sym
, vma
, info
, skip_zeroes
)
801 struct disassemble_info
*info
;
804 objdump_print_value (vma
, info
, skip_zeroes
);
810 (*info
->fprintf_func
) (info
->stream
, " <%s",
811 bfd_get_section_name (abfd
, sec
));
812 secaddr
= bfd_get_section_vma (abfd
, sec
);
815 (*info
->fprintf_func
) (info
->stream
, "-0x");
816 objdump_print_value (secaddr
- vma
, info
, true);
818 else if (vma
> secaddr
)
820 (*info
->fprintf_func
) (info
->stream
, "+0x");
821 objdump_print_value (vma
- secaddr
, info
, true);
823 (*info
->fprintf_func
) (info
->stream
, ">");
827 (*info
->fprintf_func
) (info
->stream
, " <");
828 objdump_print_symname (abfd
, info
, sym
);
829 if (bfd_asymbol_value (sym
) > vma
)
831 (*info
->fprintf_func
) (info
->stream
, "-0x");
832 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, true);
834 else if (vma
> bfd_asymbol_value (sym
))
836 (*info
->fprintf_func
) (info
->stream
, "+0x");
837 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, true);
839 (*info
->fprintf_func
) (info
->stream
, ">");
843 /* Print VMA to INFO, symbolically if possible. If SKIP_ZEROES is
844 true, don't output leading zeroes. */
847 objdump_print_addr (vma
, info
, skip_zeroes
)
849 struct disassemble_info
*info
;
852 struct objdump_disasm_info
*aux
;
855 if (sorted_symcount
< 1)
857 (*info
->fprintf_func
) (info
->stream
, "0x");
858 objdump_print_value (vma
, info
, skip_zeroes
);
862 aux
= (struct objdump_disasm_info
*) info
->application_data
;
863 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
865 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
869 /* Print VMA to INFO. This function is passed to the disassembler
873 objdump_print_address (vma
, info
)
875 struct disassemble_info
*info
;
877 objdump_print_addr (vma
, info
, ! prefix_addresses
);
880 /* Determine of the given address has a symbol associated with it. */
883 objdump_symbol_at_address (vma
, info
)
885 struct disassemble_info
* info
;
887 struct objdump_disasm_info
* aux
;
890 /* No symbols - do not bother checking. */
891 if (sorted_symcount
< 1)
894 aux
= (struct objdump_disasm_info
*) info
->application_data
;
895 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
898 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
901 /* Hold the last function name and the last line number we displayed
904 static char *prev_functionname
;
905 static unsigned int prev_line
;
907 /* We keep a list of all files that we have seen when doing a
908 dissassembly with source, so that we know how much of the file to
909 display. This can be important for inlined functions. */
911 struct print_file_list
913 struct print_file_list
*next
;
919 static struct print_file_list
*print_files
;
921 /* The number of preceding context lines to show when we start
922 displaying a file for the first time. */
924 #define SHOW_PRECEDING_CONTEXT_LINES (5)
926 /* Skip ahead to a given line in a file, optionally printing each
930 skip_to_line
PARAMS ((struct print_file_list
*, unsigned int, boolean
));
933 skip_to_line (p
, line
, show
)
934 struct print_file_list
*p
;
938 while (p
->line
< line
)
942 if (fgets (buf
, sizeof buf
, p
->f
) == NULL
)
952 if (strchr (buf
, '\n') != NULL
)
957 /* Show the line number, or the source line, in a dissassembly
961 show_line (abfd
, section
, addr_offset
)
966 CONST
char *filename
;
967 CONST
char *functionname
;
970 if (! with_line_numbers
&& ! with_source_code
)
973 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
974 &functionname
, &line
))
977 if (filename
!= NULL
&& *filename
== '\0')
979 if (functionname
!= NULL
&& *functionname
== '\0')
982 if (with_line_numbers
)
984 if (functionname
!= NULL
985 && (prev_functionname
== NULL
986 || strcmp (functionname
, prev_functionname
) != 0))
987 printf ("%s():\n", functionname
);
988 if (line
> 0 && line
!= prev_line
)
989 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
996 struct print_file_list
**pp
, *p
;
998 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
999 if (strcmp ((*pp
)->filename
, filename
) == 0)
1005 if (p
!= print_files
)
1009 /* We have reencountered a file name which we saw
1010 earlier. This implies that either we are dumping out
1011 code from an included file, or the same file was
1012 linked in more than once. There are two common cases
1013 of an included file: inline functions in a header
1014 file, and a bison or flex skeleton file. In the
1015 former case we want to just start printing (but we
1016 back up a few lines to give context); in the latter
1017 case we want to continue from where we left off. I
1018 can't think of a good way to distinguish the cases,
1019 so I used a heuristic based on the file name. */
1020 if (strcmp (p
->filename
+ strlen (p
->filename
) - 2, ".h") != 0)
1024 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1031 p
->f
= fopen (p
->filename
, "r");
1035 skip_to_line (p
, l
, false);
1037 if (print_files
->f
!= NULL
)
1039 fclose (print_files
->f
);
1040 print_files
->f
= NULL
;
1046 skip_to_line (p
, line
, true);
1048 p
->next
= print_files
;
1056 f
= fopen (filename
, "r");
1061 p
= ((struct print_file_list
*)
1062 xmalloc (sizeof (struct print_file_list
)));
1063 p
->filename
= xmalloc (strlen (filename
) + 1);
1064 strcpy (p
->filename
, filename
);
1068 if (print_files
!= NULL
&& print_files
->f
!= NULL
)
1070 fclose (print_files
->f
);
1071 print_files
->f
= NULL
;
1073 p
->next
= print_files
;
1076 if (file_start_context
)
1079 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1082 skip_to_line (p
, l
, false);
1084 skip_to_line (p
, line
, true);
1089 if (functionname
!= NULL
1090 && (prev_functionname
== NULL
1091 || strcmp (functionname
, prev_functionname
) != 0))
1093 if (prev_functionname
!= NULL
)
1094 free (prev_functionname
);
1095 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1096 strcpy (prev_functionname
, functionname
);
1099 if (line
> 0 && line
!= prev_line
)
1103 /* Pseudo FILE object for strings. */
1111 /* sprintf to a "stream" */
1114 objdump_sprintf
VPARAMS ((SFILE
*f
, const char *format
, ...))
1119 VA_OPEN (args
, format
);
1120 VA_FIXEDARG (args
, SFILE
*, f
);
1121 VA_FIXEDARG (args
, const char *, format
);
1123 vasprintf (&buf
, format
, args
);
1128 fatal (_("Out of virtual memory"));
1133 while ((size_t) ((f
->buffer
+ f
->size
) - f
->current
) < n
+ 1)
1137 curroff
= f
->current
- f
->buffer
;
1139 f
->buffer
= xrealloc (f
->buffer
, f
->size
);
1140 f
->current
= f
->buffer
+ curroff
;
1143 memcpy (f
->current
, buf
, n
);
1145 f
->current
[0] = '\0';
1153 /* The number of zeroes we want to see before we start skipping them.
1154 The number is arbitrarily chosen. */
1157 #define SKIP_ZEROES (8)
1160 /* The number of zeroes to skip at the end of a section. If the
1161 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1162 SKIP_ZEROES, they will be disassembled. If there are fewer than
1163 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1164 attempt to avoid disassembling zeroes inserted by section
1167 #ifndef SKIP_ZEROES_AT_END
1168 #define SKIP_ZEROES_AT_END (3)
1171 /* Disassemble some data in memory between given values. */
1174 disassemble_bytes (info
, disassemble_fn
, insns
, data
,
1175 start_offset
, stop_offset
, relppp
,
1177 struct disassemble_info
*info
;
1178 disassembler_ftype disassemble_fn
;
1181 bfd_vma start_offset
;
1182 bfd_vma stop_offset
;
1186 struct objdump_disasm_info
*aux
;
1188 int octets_per_line
;
1190 int skip_addr_chars
;
1191 bfd_vma addr_offset
;
1192 int opb
= info
->octets_per_byte
;
1194 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1198 octets_per_line
= 4;
1200 octets_per_line
= 16;
1202 /* Figure out how many characters to skip at the start of an
1203 address, to make the disassembly look nicer. We discard leading
1204 zeroes in chunks of 4, ensuring that there is always a leading
1206 skip_addr_chars
= 0;
1207 if (! prefix_addresses
)
1215 + bfd_section_size (section
->owner
, section
) / opb
));
1217 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1220 skip_addr_chars
+= 4;
1225 info
->insn_info_valid
= 0;
1228 addr_offset
= start_offset
;
1229 while (addr_offset
< stop_offset
)
1233 boolean need_nl
= false;
1235 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1237 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1240 if (! disassemble_zeroes
1241 && (info
->insn_info_valid
== 0
1242 || info
->branch_delay_insns
== 0)
1243 && (z
- addr_offset
* opb
>= SKIP_ZEROES
1244 || (z
== stop_offset
* opb
&&
1245 z
- addr_offset
* opb
< SKIP_ZEROES_AT_END
)))
1249 /* If there are more nonzero octets to follow, we only skip
1250 zeroes in multiples of 4, to try to avoid running over
1251 the start of an instruction which happens to start with
1253 if (z
!= stop_offset
* opb
)
1254 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1256 octets
= z
- addr_offset
* opb
;
1267 if (with_line_numbers
|| with_source_code
)
1268 /* The line number tables will refer to unadjusted
1269 section VMAs, so we must undo any VMA modifications
1270 when calling show_line. */
1271 show_line (aux
->abfd
, section
, addr_offset
- adjust_section_vma
);
1273 if (! prefix_addresses
)
1277 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1278 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1282 printf ("%s:\t", buf
+ skip_addr_chars
);
1286 aux
->require_sec
= true;
1287 objdump_print_address (section
->vma
+ addr_offset
, info
);
1288 aux
->require_sec
= false;
1295 sfile
.buffer
= xmalloc (sfile
.size
);
1296 sfile
.current
= sfile
.buffer
;
1297 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1298 info
->stream
= (FILE *) &sfile
;
1299 info
->bytes_per_line
= 0;
1300 info
->bytes_per_chunk
= 0;
1302 #ifdef DISASSEMBLER_NEEDS_RELOCS
1303 /* FIXME: This is wrong. It tests the number of octets
1304 in the last instruction, not the current one. */
1305 if (*relppp
< relppend
1306 && (**relppp
)->address
>= addr_offset
1307 && (**relppp
)->address
<= addr_offset
+ octets
/ opb
)
1308 info
->flags
= INSN_HAS_RELOC
;
1313 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, info
);
1314 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1315 info
->stream
= stdout
;
1316 if (info
->bytes_per_line
!= 0)
1317 octets_per_line
= info
->bytes_per_line
;
1320 if (sfile
.current
!= sfile
.buffer
)
1321 printf ("%s\n", sfile
.buffer
);
1322 free (sfile
.buffer
);
1330 octets
= octets_per_line
;
1331 if (addr_offset
+ octets
/ opb
> stop_offset
)
1332 octets
= (stop_offset
- addr_offset
) * opb
;
1334 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1336 if (ISPRINT (data
[j
]))
1337 buf
[j
- addr_offset
* opb
] = data
[j
];
1339 buf
[j
- addr_offset
* opb
] = '.';
1341 buf
[j
- addr_offset
* opb
] = '\0';
1344 if (prefix_addresses
1346 : show_raw_insn
>= 0)
1350 /* If ! prefix_addresses and ! wide_output, we print
1351 octets_per_line octets per line. */
1353 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1354 pb
= octets_per_line
;
1356 if (info
->bytes_per_chunk
)
1357 bpc
= info
->bytes_per_chunk
;
1361 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1364 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1366 for (k
= bpc
- 1; k
>= 0; k
--)
1367 printf ("%02x", (unsigned) data
[j
+ k
]);
1372 for (k
= 0; k
< bpc
; k
++)
1373 printf ("%02x", (unsigned) data
[j
+ k
]);
1378 for (; pb
< octets_per_line
; pb
+= bpc
)
1382 for (k
= 0; k
< bpc
; k
++)
1387 /* Separate raw data from instruction by extra space. */
1398 printf ("%s", sfile
.buffer
);
1399 free (sfile
.buffer
);
1402 if (prefix_addresses
1404 : show_raw_insn
>= 0)
1412 j
= addr_offset
* opb
+ pb
;
1414 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1415 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1419 printf ("%s:\t", buf
+ skip_addr_chars
);
1421 pb
+= octets_per_line
;
1424 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1428 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1430 for (k
= bpc
- 1; k
>= 0; k
--)
1431 printf ("%02x", (unsigned) data
[j
+ k
]);
1436 for (k
= 0; k
< bpc
; k
++)
1437 printf ("%02x", (unsigned) data
[j
+ k
]);
1450 if ((section
->flags
& SEC_RELOC
) != 0
1451 #ifndef DISASSEMBLER_NEEDS_RELOCS
1456 while ((*relppp
) < relppend
1457 && ((**relppp
)->address
>= (bfd_vma
) addr_offset
1458 && (**relppp
)->address
< (bfd_vma
) addr_offset
+ octets
/ opb
))
1459 #ifdef DISASSEMBLER_NEEDS_RELOCS
1460 if (! dump_reloc_info
)
1474 objdump_print_value (section
->vma
+ q
->address
, info
, true);
1476 printf (": %s\t", q
->howto
->name
);
1478 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1479 printf ("*unknown*");
1482 const char *sym_name
;
1484 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1485 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1486 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1491 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1492 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1493 if (sym_name
== NULL
|| *sym_name
== '\0')
1494 sym_name
= "*unknown*";
1495 printf ("%s", sym_name
);
1502 objdump_print_value (q
->addend
, info
, true);
1514 addr_offset
+= octets
/ opb
;
1518 /* Disassemble the contents of an object file. */
1521 disassemble_data (abfd
)
1524 unsigned long addr_offset
;
1525 disassembler_ftype disassemble_fn
;
1526 struct disassemble_info disasm_info
;
1527 struct objdump_disasm_info aux
;
1532 prev_functionname
= NULL
;
1535 /* We make a copy of syms to sort. We don't want to sort syms
1536 because that will screw up the relocs. */
1537 sorted_syms
= (asymbol
**) xmalloc (symcount
* sizeof (asymbol
*));
1538 memcpy (sorted_syms
, syms
, symcount
* sizeof (asymbol
*));
1540 sorted_symcount
= remove_useless_symbols (sorted_syms
, symcount
);
1542 /* Sort the symbols into section and symbol order */
1543 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1545 INIT_DISASSEMBLE_INFO(disasm_info
, stdout
, fprintf
);
1546 disasm_info
.application_data
= (PTR
) &aux
;
1548 aux
.require_sec
= false;
1549 disasm_info
.print_address_func
= objdump_print_address
;
1550 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1552 if (machine
!= (char *) NULL
)
1554 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1557 fatal (_("Can't use supplied machine %s"), machine
);
1559 abfd
->arch_info
= info
;
1562 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1564 struct bfd_target
*xvec
;
1566 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
1567 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1568 xvec
->byteorder
= endian
;
1572 disassemble_fn
= disassembler (abfd
);
1573 if (!disassemble_fn
)
1575 non_fatal (_("Can't disassemble for architecture %s\n"),
1576 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1581 opb
= bfd_octets_per_byte (abfd
);
1583 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1584 disasm_info
.arch
= bfd_get_arch (abfd
);
1585 disasm_info
.mach
= bfd_get_mach (abfd
);
1586 disasm_info
.disassembler_options
= disassembler_options
;
1587 disasm_info
.octets_per_byte
= opb
;
1589 if (bfd_big_endian (abfd
))
1590 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1591 else if (bfd_little_endian (abfd
))
1592 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1594 /* ??? Aborting here seems too drastic. We could default to big or little
1596 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1598 for (section
= abfd
->sections
;
1599 section
!= (asection
*) NULL
;
1600 section
= section
->next
)
1602 bfd_byte
*data
= NULL
;
1603 bfd_size_type datasize
= 0;
1604 arelent
**relbuf
= NULL
;
1605 arelent
**relpp
= NULL
;
1606 arelent
**relppend
= NULL
;
1607 unsigned long stop_offset
;
1608 asymbol
*sym
= NULL
;
1611 if ((section
->flags
& SEC_LOAD
) == 0
1612 || (! disassemble_all
1614 && (section
->flags
& SEC_CODE
) == 0))
1616 if (only
!= (char *) NULL
&& strcmp (only
, section
->name
) != 0)
1619 if ((section
->flags
& SEC_RELOC
) != 0
1620 #ifndef DISASSEMBLER_NEEDS_RELOCS
1627 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1629 bfd_fatal (bfd_get_filename (abfd
));
1635 relbuf
= (arelent
**) xmalloc (relsize
);
1636 relcount
= bfd_canonicalize_reloc (abfd
, section
, relbuf
, syms
);
1638 bfd_fatal (bfd_get_filename (abfd
));
1640 /* Sort the relocs by address. */
1641 qsort (relbuf
, relcount
, sizeof (arelent
*), compare_relocs
);
1644 relppend
= relpp
+ relcount
;
1646 /* Skip over the relocs belonging to addresses below the
1648 if (start_address
!= (bfd_vma
) -1)
1650 while (relpp
< relppend
1651 && (*relpp
)->address
< start_address
)
1657 printf (_("Disassembly of section %s:\n"), section
->name
);
1659 datasize
= bfd_get_section_size_before_reloc (section
);
1663 data
= (bfd_byte
*) xmalloc ((size_t) datasize
);
1665 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1668 disasm_info
.buffer
= data
;
1669 disasm_info
.buffer_vma
= section
->vma
;
1670 disasm_info
.buffer_length
= datasize
;
1671 disasm_info
.section
= section
;
1672 if (start_address
== (bfd_vma
) -1
1673 || start_address
< disasm_info
.buffer_vma
)
1676 addr_offset
= start_address
- disasm_info
.buffer_vma
;
1677 if (stop_address
== (bfd_vma
) -1)
1678 stop_offset
= datasize
/ opb
;
1681 if (stop_address
< disasm_info
.buffer_vma
)
1684 stop_offset
= stop_address
- disasm_info
.buffer_vma
;
1685 if (stop_offset
> disasm_info
.buffer_length
/ opb
)
1686 stop_offset
= disasm_info
.buffer_length
/ opb
;
1689 sym
= find_symbol_for_address (abfd
, section
, section
->vma
+ addr_offset
,
1692 while (addr_offset
< stop_offset
)
1695 unsigned long nextstop_offset
;
1698 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= section
->vma
+ addr_offset
)
1703 (x
< sorted_symcount
1704 && bfd_asymbol_value (sorted_syms
[x
]) <= section
->vma
+ addr_offset
);
1707 disasm_info
.symbols
= & sorted_syms
[place
];
1708 disasm_info
.num_symbols
= x
- place
;
1711 disasm_info
.symbols
= NULL
;
1713 if (! prefix_addresses
)
1716 objdump_print_addr_with_sym (abfd
, section
, sym
,
1717 section
->vma
+ addr_offset
,
1723 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
)
1725 else if (sym
== NULL
)
1729 /* Search forward for the next appropriate symbol in
1730 SECTION. Note that all the symbols are sorted
1731 together into one big array, and that some sections
1732 may have overlapping addresses. */
1733 while (place
< sorted_symcount
1734 && (sorted_syms
[place
]->section
!= section
1735 || (bfd_asymbol_value (sorted_syms
[place
])
1736 <= bfd_asymbol_value (sym
))))
1738 if (place
>= sorted_symcount
)
1741 nextsym
= sorted_syms
[place
];
1744 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
)
1746 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1747 if (nextstop_offset
> stop_offset
)
1748 nextstop_offset
= stop_offset
;
1750 else if (nextsym
== NULL
)
1751 nextstop_offset
= stop_offset
;
1754 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1755 if (nextstop_offset
> stop_offset
)
1756 nextstop_offset
= stop_offset
;
1759 /* If a symbol is explicitly marked as being an object
1760 rather than a function, just dump the bytes without
1761 disassembling them. */
1764 || bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
1765 || ((sym
->flags
& BSF_OBJECT
) == 0
1766 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1768 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1770 || (sym
->flags
& BSF_FUNCTION
) != 0)
1775 disassemble_bytes (&disasm_info
, disassemble_fn
, insns
, data
,
1776 addr_offset
, nextstop_offset
, &relpp
, relppend
);
1778 addr_offset
= nextstop_offset
;
1790 /* Define a table of stab values and print-strings. We wish the initializer
1791 could be a direct-mapped table, but instead we build one the first
1794 static void dump_section_stabs
PARAMS ((bfd
*abfd
, char *stabsect_name
,
1795 char *strsect_name
));
1797 /* Dump the stabs sections from an object file that has a section that
1798 uses Sun stabs encoding. */
1804 dump_section_stabs (abfd
, ".stab", ".stabstr");
1805 dump_section_stabs (abfd
, ".stab.excl", ".stab.exclstr");
1806 dump_section_stabs (abfd
, ".stab.index", ".stab.indexstr");
1807 dump_section_stabs (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1810 static bfd_byte
*stabs
;
1811 static bfd_size_type stab_size
;
1813 static char *strtab
;
1814 static bfd_size_type stabstr_size
;
1816 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1817 and string table section STRSECT_NAME into `strtab'.
1818 If the section exists and was read, allocate the space and return true.
1819 Otherwise return false. */
1822 read_section_stabs (abfd
, stabsect_name
, strsect_name
)
1824 const char *stabsect_name
;
1825 const char *strsect_name
;
1827 asection
*stabsect
, *stabstrsect
;
1829 stabsect
= bfd_get_section_by_name (abfd
, stabsect_name
);
1832 printf (_("No %s section present\n\n"), stabsect_name
);
1836 stabstrsect
= bfd_get_section_by_name (abfd
, strsect_name
);
1837 if (0 == stabstrsect
)
1839 non_fatal (_("%s has no %s section"),
1840 bfd_get_filename (abfd
), strsect_name
);
1845 stab_size
= bfd_section_size (abfd
, stabsect
);
1846 stabstr_size
= bfd_section_size (abfd
, stabstrsect
);
1848 stabs
= (bfd_byte
*) xmalloc (stab_size
);
1849 strtab
= (char *) xmalloc (stabstr_size
);
1851 if (! bfd_get_section_contents (abfd
, stabsect
, (PTR
) stabs
, 0, stab_size
))
1853 non_fatal (_("Reading %s section of %s failed: %s"),
1854 stabsect_name
, bfd_get_filename (abfd
),
1855 bfd_errmsg (bfd_get_error ()));
1862 if (! bfd_get_section_contents (abfd
, stabstrsect
, (PTR
) strtab
, 0,
1865 non_fatal (_("Reading %s section of %s failed: %s\n"),
1866 strsect_name
, bfd_get_filename (abfd
),
1867 bfd_errmsg (bfd_get_error ()));
1877 /* Stabs entries use a 12 byte format:
1878 4 byte string table index
1880 1 byte stab other field
1881 2 byte stab desc field
1883 FIXME: This will have to change for a 64 bit object format. */
1885 #define STRDXOFF (0)
1887 #define OTHEROFF (5)
1890 #define STABSIZE (12)
1892 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1893 using string table section STRSECT_NAME (in `strtab'). */
1896 print_section_stabs (abfd
, stabsect_name
, strsect_name
)
1898 const char *stabsect_name
;
1899 const char *strsect_name ATTRIBUTE_UNUSED
;
1902 unsigned file_string_table_offset
= 0, next_file_string_table_offset
= 0;
1903 bfd_byte
*stabp
, *stabs_end
;
1906 stabs_end
= stabp
+ stab_size
;
1908 printf (_("Contents of %s section:\n\n"), stabsect_name
);
1909 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1911 /* Loop through all symbols and print them.
1913 We start the index at -1 because there is a dummy symbol on
1914 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1916 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
1920 unsigned char type
, other
;
1921 unsigned short desc
;
1924 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
1925 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
1926 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
1927 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
1928 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
1930 printf ("\n%-6d ", i
);
1931 /* Either print the stab name, or, if unnamed, print its number
1932 again (makes consistent formatting for tools like awk). */
1933 name
= bfd_get_stab_name (type
);
1935 printf ("%-6s", name
);
1936 else if (type
== N_UNDF
)
1939 printf ("%-6d", type
);
1940 printf (" %-6d %-6d ", other
, desc
);
1941 bfd_printf_vma (abfd
, value
);
1942 printf (" %-6lu", strx
);
1944 /* Symbols with type == 0 (N_UNDF) specify the length of the
1945 string table associated with this file. We use that info
1946 to know how to relocate the *next* file's string table indices. */
1950 file_string_table_offset
= next_file_string_table_offset
;
1951 next_file_string_table_offset
+= value
;
1955 /* Using the (possibly updated) string table offset, print the
1956 string (if any) associated with this symbol. */
1958 if ((strx
+ file_string_table_offset
) < stabstr_size
)
1959 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
1968 dump_section_stabs (abfd
, stabsect_name
, strsect_name
)
1970 char *stabsect_name
;
1975 /* Check for section names for which stabsect_name is a prefix, to
1976 handle .stab0, etc. */
1977 for (s
= abfd
->sections
;
1983 len
= strlen (stabsect_name
);
1985 /* If the prefix matches, and the files section name ends with a
1986 nul or a digit, then we match. I.e., we want either an exact
1987 match or a section followed by a number. */
1988 if (strncmp (stabsect_name
, s
->name
, len
) == 0
1989 && (s
->name
[len
] == '\000'
1990 || ISDIGIT (s
->name
[len
])))
1992 if (read_section_stabs (abfd
, s
->name
, strsect_name
))
1994 print_section_stabs (abfd
, s
->name
, strsect_name
);
2003 dump_bfd_header (abfd
)
2008 printf (_("architecture: %s, "),
2009 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2010 bfd_get_mach (abfd
)));
2011 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2013 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2014 PF (HAS_RELOC
, "HAS_RELOC");
2015 PF (EXEC_P
, "EXEC_P");
2016 PF (HAS_LINENO
, "HAS_LINENO");
2017 PF (HAS_DEBUG
, "HAS_DEBUG");
2018 PF (HAS_SYMS
, "HAS_SYMS");
2019 PF (HAS_LOCALS
, "HAS_LOCALS");
2020 PF (DYNAMIC
, "DYNAMIC");
2021 PF (WP_TEXT
, "WP_TEXT");
2022 PF (D_PAGED
, "D_PAGED");
2023 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2024 printf (_("\nstart address 0x"));
2025 bfd_printf_vma (abfd
, abfd
->start_address
);
2030 dump_bfd_private_header (abfd
)
2033 bfd_print_private_bfd_data (abfd
, stdout
);
2036 /* Dump selected contents of ABFD */
2042 /* If we are adjusting section VMA's, change them all now. Changing
2043 the BFD information is a hack. However, we must do it, or
2044 bfd_find_nearest_line will not do the right thing. */
2045 if (adjust_section_vma
!= 0)
2049 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2051 s
->vma
+= adjust_section_vma
;
2052 s
->lma
+= adjust_section_vma
;
2056 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2059 print_arelt_descr (stdout
, abfd
, true);
2060 if (dump_file_header
)
2061 dump_bfd_header (abfd
);
2062 if (dump_private_headers
)
2063 dump_bfd_private_header (abfd
);
2065 if (dump_section_headers
)
2066 dump_headers (abfd
);
2067 if (dump_symtab
|| dump_reloc_info
|| disassemble
|| dump_debugging
)
2069 syms
= slurp_symtab (abfd
);
2071 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
)
2073 dynsyms
= slurp_dynamic_symtab (abfd
);
2076 dump_symbols (abfd
, false);
2077 if (dump_dynamic_symtab
)
2078 dump_symbols (abfd
, true);
2079 if (dump_stab_section_info
)
2081 if (dump_reloc_info
&& ! disassemble
)
2083 if (dump_dynamic_reloc_info
)
2084 dump_dynamic_relocs (abfd
);
2085 if (dump_section_contents
)
2088 disassemble_data (abfd
);
2093 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2094 if (dhandle
!= NULL
)
2096 if (! print_debugging_info (stdout
, dhandle
))
2098 non_fatal (_("%s: printing debugging information failed"),
2099 bfd_get_filename (abfd
));
2122 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2128 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2130 nonfatal (bfd_get_filename (abfd
));
2131 list_matching_formats (matching
);
2136 if (bfd_get_error () != bfd_error_file_not_recognized
)
2138 nonfatal (bfd_get_filename (abfd
));
2142 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
2148 nonfatal (bfd_get_filename (abfd
));
2150 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2152 list_matching_formats (matching
);
2158 display_file (filename
, target
)
2162 bfd
*file
, *arfile
= (bfd
*) NULL
;
2164 file
= bfd_openr (filename
, target
);
2167 nonfatal (filename
);
2171 if (bfd_check_format (file
, bfd_archive
) == true)
2173 bfd
*last_arfile
= NULL
;
2175 printf (_("In archive %s:\n"), bfd_get_filename (file
));
2178 bfd_set_error (bfd_error_no_error
);
2180 arfile
= bfd_openr_next_archived_file (file
, arfile
);
2183 if (bfd_get_error () != bfd_error_no_more_archived_files
)
2184 nonfatal (bfd_get_filename (file
));
2188 display_bfd (arfile
);
2190 if (last_arfile
!= NULL
)
2191 bfd_close (last_arfile
);
2192 last_arfile
= arfile
;
2195 if (last_arfile
!= NULL
)
2196 bfd_close (last_arfile
);
2204 /* Actually display the various requested regions */
2212 bfd_size_type datasize
= 0;
2213 bfd_size_type addr_offset
;
2214 bfd_size_type start_offset
, stop_offset
;
2215 unsigned int opb
= bfd_octets_per_byte (abfd
);
2217 for (section
= abfd
->sections
; section
!= NULL
; section
=
2222 if (only
== (char *) NULL
||
2223 strcmp (only
, section
->name
) == 0)
2225 if (section
->flags
& SEC_HAS_CONTENTS
)
2227 printf (_("Contents of section %s:\n"), section
->name
);
2229 if (bfd_section_size (abfd
, section
) == 0)
2231 data
= (bfd_byte
*) xmalloc ((size_t) bfd_section_size (abfd
, section
));
2232 datasize
= bfd_section_size (abfd
, section
);
2235 bfd_get_section_contents (abfd
, section
, (PTR
) data
, 0, bfd_section_size (abfd
, section
));
2237 if (start_address
== (bfd_vma
) -1
2238 || start_address
< section
->vma
)
2241 start_offset
= start_address
- section
->vma
;
2242 if (stop_address
== (bfd_vma
) -1)
2243 stop_offset
= bfd_section_size (abfd
, section
) / opb
;
2246 if (stop_address
< section
->vma
)
2249 stop_offset
= stop_address
- section
->vma
;
2250 if (stop_offset
> bfd_section_size (abfd
, section
) / opb
)
2251 stop_offset
= bfd_section_size (abfd
, section
) / opb
;
2253 for (addr_offset
= start_offset
;
2254 addr_offset
< stop_offset
; addr_offset
+= onaline
)
2258 printf (" %04lx ", (unsigned long int)
2259 (addr_offset
+ section
->vma
));
2260 for (j
= addr_offset
* opb
;
2261 j
< addr_offset
* opb
+ onaline
; j
++)
2263 if (j
< stop_offset
* opb
)
2264 printf ("%02x", (unsigned) (data
[j
]));
2272 for (j
= addr_offset
; j
< addr_offset
* opb
+ onaline
; j
++)
2274 if (j
>= stop_offset
* opb
)
2277 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2287 /* Should perhaps share code and display with nm? */
2289 dump_symbols (abfd
, dynamic
)
2290 bfd
*abfd ATTRIBUTE_UNUSED
;
2303 printf ("DYNAMIC SYMBOL TABLE:\n");
2311 printf ("SYMBOL TABLE:\n");
2314 for (count
= 0; count
< max
; count
++)
2318 bfd
*cur_bfd
= bfd_asymbol_bfd (*current
);
2320 if (cur_bfd
!= NULL
)
2325 name
= bfd_asymbol_name (*current
);
2327 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2331 /* If we want to demangle the name, we demangle it
2332 here, and temporarily clobber it while calling
2333 bfd_print_symbol. FIXME: This is a gross hack. */
2336 if (bfd_get_symbol_leading_char (cur_bfd
) == *n
)
2338 alloc
= cplus_demangle (n
, DMGL_ANSI
| DMGL_PARAMS
);
2340 (*current
)->name
= alloc
;
2342 (*current
)->name
= n
;
2345 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2346 bfd_print_symbol_all
);
2348 (*current
)->name
= name
;
2369 for (a
= abfd
->sections
; a
!= (asection
*) NULL
; a
= a
->next
)
2373 if (bfd_is_abs_section (a
))
2375 if (bfd_is_und_section (a
))
2377 if (bfd_is_com_section (a
))
2382 if (strcmp (only
, a
->name
))
2385 else if ((a
->flags
& SEC_RELOC
) == 0)
2388 relsize
= bfd_get_reloc_upper_bound (abfd
, a
);
2390 bfd_fatal (bfd_get_filename (abfd
));
2392 printf ("RELOCATION RECORDS FOR [%s]:", a
->name
);
2396 printf (" (none)\n\n");
2400 relpp
= (arelent
**) xmalloc (relsize
);
2401 relcount
= bfd_canonicalize_reloc (abfd
, a
, relpp
, syms
);
2403 bfd_fatal (bfd_get_filename (abfd
));
2404 else if (relcount
== 0)
2406 printf (" (none)\n\n");
2411 dump_reloc_set (abfd
, a
, relpp
, relcount
);
2420 dump_dynamic_relocs (abfd
)
2427 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2429 bfd_fatal (bfd_get_filename (abfd
));
2431 printf ("DYNAMIC RELOCATION RECORDS");
2435 printf (" (none)\n\n");
2439 relpp
= (arelent
**) xmalloc (relsize
);
2440 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2442 bfd_fatal (bfd_get_filename (abfd
));
2443 else if (relcount
== 0)
2445 printf (" (none)\n\n");
2450 dump_reloc_set (abfd
, (asection
*) NULL
, relpp
, relcount
);
2458 dump_reloc_set (abfd
, sec
, relpp
, relcount
)
2465 char *last_filename
, *last_functionname
;
2466 unsigned int last_line
;
2468 /* Get column headers lined up reasonably. */
2474 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2475 width
= strlen (buf
) - 7;
2477 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2480 last_filename
= NULL
;
2481 last_functionname
= NULL
;
2484 for (p
= relpp
; relcount
&& *p
!= (arelent
*) NULL
; p
++, relcount
--)
2487 const char *filename
, *functionname
;
2489 const char *sym_name
;
2490 const char *section_name
;
2492 if (start_address
!= (bfd_vma
) -1
2493 && q
->address
< start_address
)
2495 if (stop_address
!= (bfd_vma
) -1
2496 && q
->address
> stop_address
)
2499 if (with_line_numbers
2501 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2502 &filename
, &functionname
, &line
))
2504 if (functionname
!= NULL
2505 && (last_functionname
== NULL
2506 || strcmp (functionname
, last_functionname
) != 0))
2508 printf ("%s():\n", functionname
);
2509 if (last_functionname
!= NULL
)
2510 free (last_functionname
);
2511 last_functionname
= xstrdup (functionname
);
2514 && (line
!= last_line
2515 || (filename
!= NULL
2516 && last_filename
!= NULL
2517 && strcmp (filename
, last_filename
) != 0)))
2519 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2521 if (last_filename
!= NULL
)
2522 free (last_filename
);
2523 if (filename
== NULL
)
2524 last_filename
= NULL
;
2526 last_filename
= xstrdup (filename
);
2530 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2532 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2533 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2538 section_name
= NULL
;
2542 bfd_printf_vma (abfd
, q
->address
);
2544 printf (" %-16s ", q
->howto
->name
);
2546 printf (" %-16d ", q
->howto
->type
);
2547 objdump_print_symname (abfd
, (struct disassemble_info
*) NULL
,
2552 if (section_name
== (CONST
char *) NULL
)
2553 section_name
= "*unknown*";
2554 bfd_printf_vma (abfd
, q
->address
);
2555 printf (" %-16s [%s]",
2562 bfd_printf_vma (abfd
, q
->addend
);
2568 /* The length of the longest architecture name + 1. */
2569 #define LONGEST_ARCH sizeof("powerpc:common")
2572 endian_string (endian
)
2573 enum bfd_endian endian
;
2575 if (endian
== BFD_ENDIAN_BIG
)
2576 return "big endian";
2577 else if (endian
== BFD_ENDIAN_LITTLE
)
2578 return "little endian";
2580 return "endianness unknown";
2583 /* List the targets that BFD is configured to support, each followed
2584 by its endianness and the architectures it supports. */
2587 display_target_list ()
2589 extern const bfd_target
*const *bfd_target_vector
;
2593 dummy_name
= make_temp_file (NULL
);
2594 for (t
= 0; bfd_target_vector
[t
]; t
++)
2596 const bfd_target
*p
= bfd_target_vector
[t
];
2597 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2600 printf ("%s\n (header %s, data %s)\n", p
->name
,
2601 endian_string (p
->header_byteorder
),
2602 endian_string (p
->byteorder
));
2606 nonfatal (dummy_name
);
2610 if (! bfd_set_format (abfd
, bfd_object
))
2612 if (bfd_get_error () != bfd_error_invalid_operation
)
2614 bfd_close_all_done (abfd
);
2618 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2619 if (bfd_set_arch_mach (abfd
, (enum bfd_architecture
) a
, 0))
2621 bfd_printable_arch_mach ((enum bfd_architecture
) a
, 0));
2622 bfd_close_all_done (abfd
);
2624 unlink (dummy_name
);
2628 /* Print a table showing which architectures are supported for entries
2629 FIRST through LAST-1 of bfd_target_vector (targets across,
2630 architectures down). */
2633 display_info_table (first
, last
)
2637 extern const bfd_target
*const *bfd_target_vector
;
2641 /* Print heading of target names. */
2642 printf ("\n%*s", (int) LONGEST_ARCH
, " ");
2643 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2644 printf ("%s ", bfd_target_vector
[t
]->name
);
2647 dummy_name
= make_temp_file (NULL
);
2648 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2649 if (strcmp (bfd_printable_arch_mach (a
, 0), "UNKNOWN!") != 0)
2651 printf ("%*s ", (int) LONGEST_ARCH
- 1,
2652 bfd_printable_arch_mach (a
, 0));
2653 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2655 const bfd_target
*p
= bfd_target_vector
[t
];
2657 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2667 if (! bfd_set_format (abfd
, bfd_object
))
2669 if (bfd_get_error () != bfd_error_invalid_operation
)
2677 if (! bfd_set_arch_mach (abfd
, a
, 0))
2682 printf ("%s ", p
->name
);
2685 int l
= strlen (p
->name
);
2691 bfd_close_all_done (abfd
);
2695 unlink (dummy_name
);
2699 /* Print tables of all the target-architecture combinations that
2700 BFD has been configured to support. */
2703 display_target_tables ()
2706 extern const bfd_target
*const *bfd_target_vector
;
2710 colum
= getenv ("COLUMNS");
2712 columns
= atoi (colum
);
2717 while (bfd_target_vector
[t
] != NULL
)
2721 wid
= LONGEST_ARCH
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2723 while (wid
< columns
&& bfd_target_vector
[t
] != NULL
)
2727 newwid
= wid
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2728 if (newwid
>= columns
)
2733 display_info_table (oldt
, t
);
2740 printf (_("BFD header file version %s\n"), BFD_VERSION_STRING
);
2741 display_target_list ();
2742 display_target_tables ();
2745 int main
PARAMS ((int, char **));
2753 char *target
= default_target
;
2754 boolean seenflag
= false;
2756 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
2757 setlocale (LC_MESSAGES
, "");
2759 #if defined (HAVE_SETLOCALE)
2760 setlocale (LC_CTYPE
, "");
2762 bindtextdomain (PACKAGE
, LOCALEDIR
);
2763 textdomain (PACKAGE
);
2765 program_name
= *argv
;
2766 xmalloc_set_program_name (program_name
);
2768 START_PROGRESS (program_name
, 0);
2771 set_default_bfd_target ();
2773 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VvCdDlfaHhrRtTxsSj:wE:zgG",
2774 long_options
, (int *) 0))
2780 break; /* We've been given a long option. */
2785 disassembler_options
= optarg
;
2791 with_line_numbers
= true;
2800 enum demangling_styles style
;
2802 style
= cplus_demangle_name_to_style (optarg
);
2803 if (style
== unknown_demangling
)
2804 fatal (_("unknown demangling style `%s'"),
2807 cplus_demangle_set_style (style
);
2813 case OPTION_ADJUST_VMA
:
2814 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
2816 case OPTION_START_ADDRESS
:
2817 start_address
= parse_vma (optarg
, "--start-address");
2819 case OPTION_STOP_ADDRESS
:
2820 stop_address
= parse_vma (optarg
, "--stop-address");
2823 if (strcmp (optarg
, "B") == 0)
2824 endian
= BFD_ENDIAN_BIG
;
2825 else if (strcmp (optarg
, "L") == 0)
2826 endian
= BFD_ENDIAN_LITTLE
;
2829 non_fatal (_("unrecognized -E option"));
2834 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
2835 endian
= BFD_ENDIAN_BIG
;
2836 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
2837 endian
= BFD_ENDIAN_LITTLE
;
2840 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
2846 dump_file_header
= true;
2850 formats_info
= true;
2854 dump_private_headers
= true;
2858 dump_private_headers
= true;
2860 dump_reloc_info
= true;
2861 dump_file_header
= true;
2862 dump_ar_hdrs
= true;
2863 dump_section_headers
= true;
2871 dump_dynamic_symtab
= true;
2879 disassemble_zeroes
= true;
2883 disassemble_all
= true;
2888 with_source_code
= true;
2896 dump_stab_section_info
= true;
2900 dump_section_contents
= true;
2904 dump_reloc_info
= true;
2908 dump_dynamic_reloc_info
= true;
2912 dump_ar_hdrs
= true;
2916 dump_section_headers
= true;
2924 show_version
= true;
2934 print_version ("objdump");
2936 if (seenflag
== false)
2944 display_file ("a.out", target
);
2946 for (; optind
< argc
;)
2947 display_file (argv
[optind
++], target
);
2950 END_PROGRESS (program_name
);