1 /* objdump.c -- dump information about an object file.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 Free Software Foundation, Inc.
6 This file is part of GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 #include "safe-ctype.h"
30 #include "libiberty.h"
35 /* Internal headers for the ELF .stab-dump code - sorry. */
36 #define BYTES_IN_WORD 32
37 #include "aout/aout64.h"
39 #ifdef NEED_DECLARATION_FPRINTF
40 /* This is needed by INIT_DISASSEMBLE_INFO. */
42 PARAMS ((FILE *, const char *, ...));
46 static int exit_status
= 0;
48 static char *default_target
= NULL
; /* default at runtime */
50 static int show_version
= 0; /* show the version number */
51 static int dump_section_contents
; /* -s */
52 static int dump_section_headers
; /* -h */
53 static bfd_boolean dump_file_header
; /* -f */
54 static int dump_symtab
; /* -t */
55 static int dump_dynamic_symtab
; /* -T */
56 static int dump_reloc_info
; /* -r */
57 static int dump_dynamic_reloc_info
; /* -R */
58 static int dump_ar_hdrs
; /* -a */
59 static int dump_private_headers
; /* -p */
60 static int prefix_addresses
; /* --prefix-addresses */
61 static int with_line_numbers
; /* -l */
62 static bfd_boolean with_source_code
; /* -S */
63 static int show_raw_insn
; /* --show-raw-insn */
64 static int dump_stab_section_info
; /* --stabs */
65 static int do_demangle
; /* -C, --demangle */
66 static bfd_boolean disassemble
; /* -d */
67 static bfd_boolean disassemble_all
; /* -D */
68 static int disassemble_zeroes
; /* --disassemble-zeroes */
69 static bfd_boolean formats_info
; /* -i */
70 static char *only
; /* -j secname */
71 static int wide_output
; /* -w */
72 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
73 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
74 static int dump_debugging
; /* --debugging */
75 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
76 static int file_start_context
= 0; /* --file-start-context */
78 /* Extra info to pass to the disassembler address printing function. */
79 struct objdump_disasm_info
83 bfd_boolean require_sec
;
86 /* Architecture to disassemble for, or default if NULL. */
87 static char *machine
= (char *) NULL
;
89 /* Target specific options to the disassembler. */
90 static char *disassembler_options
= (char *) NULL
;
92 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
93 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
95 /* The symbol table. */
96 static asymbol
**syms
;
98 /* Number of symbols in `syms'. */
99 static long symcount
= 0;
101 /* The sorted symbol table. */
102 static asymbol
**sorted_syms
;
104 /* Number of symbols in `sorted_syms'. */
105 static long sorted_symcount
= 0;
107 /* The dynamic symbol table. */
108 static asymbol
**dynsyms
;
110 /* Number of symbols in `dynsyms'. */
111 static long dynsymcount
= 0;
113 /* Static declarations. */
116 PARAMS ((FILE *, int));
118 PARAMS ((const char *));
119 static void display_file
120 PARAMS ((char *filename
, char *target
));
121 static void dump_section_header
122 PARAMS ((bfd
*, asection
*, PTR
));
123 static void dump_headers
125 static void dump_data
126 PARAMS ((bfd
*abfd
));
127 static void dump_relocs
128 PARAMS ((bfd
*abfd
));
129 static void dump_dynamic_relocs
130 PARAMS ((bfd
* abfd
));
131 static void dump_reloc_set
132 PARAMS ((bfd
*, asection
*, arelent
**, long));
133 static void dump_symbols
134 PARAMS ((bfd
*abfd
, bfd_boolean dynamic
));
135 static void dump_bfd_header
137 static void dump_bfd_private_header
141 static void display_bfd
142 PARAMS ((bfd
*abfd
));
143 static void display_target_list
145 static void display_info_table
147 static void display_target_tables
149 static void display_info
151 static void objdump_print_value
152 PARAMS ((bfd_vma
, struct disassemble_info
*, bfd_boolean
));
153 static void objdump_print_symname
154 PARAMS ((bfd
*, struct disassemble_info
*, asymbol
*));
155 static asymbol
*find_symbol_for_address
156 PARAMS ((bfd
*, asection
*, bfd_vma
, bfd_boolean
, long *));
157 static void objdump_print_addr_with_sym
158 PARAMS ((bfd
*, asection
*, asymbol
*, bfd_vma
,
159 struct disassemble_info
*, bfd_boolean
));
160 static void objdump_print_addr
161 PARAMS ((bfd_vma
, struct disassemble_info
*, bfd_boolean
));
162 static void objdump_print_address
163 PARAMS ((bfd_vma
, struct disassemble_info
*));
164 static int objdump_symbol_at_address
165 PARAMS ((bfd_vma
, struct disassemble_info
*));
166 static void show_line
167 PARAMS ((bfd
*, asection
*, bfd_vma
));
168 static void disassemble_bytes
169 PARAMS ((struct disassemble_info
*, disassembler_ftype
, bfd_boolean
,
170 bfd_byte
*, bfd_vma
, bfd_vma
, arelent
***, arelent
**));
171 static void disassemble_data
173 static const char *endian_string
174 PARAMS ((enum bfd_endian
));
175 static asymbol
** slurp_symtab
177 static asymbol
** slurp_dynamic_symtab
179 static long remove_useless_symbols
180 PARAMS ((asymbol
**, long));
181 static int compare_symbols
182 PARAMS ((const PTR
, const PTR
));
183 static int compare_relocs
184 PARAMS ((const PTR
, const PTR
));
185 static void dump_stabs
187 static bfd_boolean read_section_stabs
188 PARAMS ((bfd
*, const char *, const char *));
189 static void print_section_stabs
190 PARAMS ((bfd
*, const char *, const char *));
193 usage (stream
, status
)
197 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
198 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
199 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
200 fprintf (stream
, _("\
201 -a, --archive-headers Display archive header information\n\
202 -f, --file-headers Display the contents of the overall file header\n\
203 -p, --private-headers Display object format specific file header contents\n\
204 -h, --[section-]headers Display the contents of the section headers\n\
205 -x, --all-headers Display the contents of all headers\n\
206 -d, --disassemble Display assembler contents of executable sections\n\
207 -D, --disassemble-all Display assembler contents of all sections\n\
208 -S, --source Intermix source code with disassembly\n\
209 -s, --full-contents Display the full contents of all sections requested\n\
210 -g, --debugging Display debug information in object file\n\
211 -G, --stabs Display (in raw form) any STABS info in the file\n\
212 -t, --syms Display the contents of the symbol table(s)\n\
213 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
214 -r, --reloc Display the relocation entries in the file\n\
215 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
216 -v, --version Display this program's version number\n\
217 -i, --info List object formats and architectures supported\n\
218 -H, --help Display this information\n\
222 fprintf (stream
, _("\n The following switches are optional:\n"));
223 fprintf (stream
, _("\
224 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
225 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
226 -j, --section=NAME Only display information for section NAME\n\
227 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
228 -EB --endian=big Assume big endian format when disassembling\n\
229 -EL --endian=little Assume little endian format when disassembling\n\
230 --file-start-context Include context from start of file (with -S)\n\
231 -l, --line-numbers Include line numbers and filenames in output\n\
232 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
233 The STYLE, if specified, can be `auto', `gnu',\n\
234 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
236 -w, --wide Format output for more than 80 columns\n\
237 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
238 --start-address=ADDR Only process data whose address is >= ADDR\n\
239 --stop-address=ADDR Only process data whose address is <= ADDR\n\
240 --prefix-addresses Print complete address alongside disassembly\n\
241 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
242 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
244 list_supported_targets (program_name
, stream
);
245 list_supported_architectures (program_name
, stream
);
247 disassembler_usage (stream
);
250 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
254 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
256 #define OPTION_ENDIAN (150)
257 #define OPTION_START_ADDRESS (OPTION_ENDIAN + 1)
258 #define OPTION_STOP_ADDRESS (OPTION_START_ADDRESS + 1)
259 #define OPTION_ADJUST_VMA (OPTION_STOP_ADDRESS + 1)
261 static struct option long_options
[]=
263 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
264 {"all-headers", no_argument
, NULL
, 'x'},
265 {"private-headers", no_argument
, NULL
, 'p'},
266 {"architecture", required_argument
, NULL
, 'm'},
267 {"archive-headers", no_argument
, NULL
, 'a'},
268 {"debugging", no_argument
, NULL
, 'g'},
269 {"demangle", optional_argument
, NULL
, 'C'},
270 {"disassemble", no_argument
, NULL
, 'd'},
271 {"disassemble-all", no_argument
, NULL
, 'D'},
272 {"disassembler-options", required_argument
, NULL
, 'M'},
273 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
274 {"dynamic-reloc", no_argument
, NULL
, 'R'},
275 {"dynamic-syms", no_argument
, NULL
, 'T'},
276 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
277 {"file-headers", no_argument
, NULL
, 'f'},
278 {"file-start-context", no_argument
, &file_start_context
, 1},
279 {"full-contents", no_argument
, NULL
, 's'},
280 {"headers", no_argument
, NULL
, 'h'},
281 {"help", no_argument
, NULL
, 'H'},
282 {"info", no_argument
, NULL
, 'i'},
283 {"line-numbers", no_argument
, NULL
, 'l'},
284 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
285 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
286 {"reloc", no_argument
, NULL
, 'r'},
287 {"section", required_argument
, NULL
, 'j'},
288 {"section-headers", no_argument
, NULL
, 'h'},
289 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
290 {"source", no_argument
, NULL
, 'S'},
291 {"stabs", no_argument
, NULL
, 'G'},
292 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
293 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
294 {"syms", no_argument
, NULL
, 't'},
295 {"target", required_argument
, NULL
, 'b'},
296 {"version", no_argument
, NULL
, 'V'},
297 {"wide", no_argument
, NULL
, 'w'},
298 {0, no_argument
, 0, 0}
310 dump_section_header (abfd
, section
, ignored
)
311 bfd
*abfd ATTRIBUTE_UNUSED
;
313 PTR ignored ATTRIBUTE_UNUSED
;
316 unsigned int opb
= bfd_octets_per_byte (abfd
);
318 printf ("%3d %-13s %08lx ", section
->index
,
319 bfd_get_section_name (abfd
, section
),
320 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
321 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
323 bfd_printf_vma (abfd
, section
->lma
);
324 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
325 bfd_get_section_alignment (abfd
, section
));
331 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
333 PF (SEC_HAS_CONTENTS
, "CONTENTS");
334 PF (SEC_ALLOC
, "ALLOC");
335 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
336 PF (SEC_LOAD
, "LOAD");
337 PF (SEC_RELOC
, "RELOC");
338 PF (SEC_READONLY
, "READONLY");
339 PF (SEC_CODE
, "CODE");
340 PF (SEC_DATA
, "DATA");
342 PF (SEC_DEBUGGING
, "DEBUGGING");
343 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
344 PF (SEC_EXCLUDE
, "EXCLUDE");
345 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
346 PF (SEC_BLOCK
, "BLOCK");
347 PF (SEC_CLINK
, "CLINK");
348 PF (SEC_SMALL_DATA
, "SMALL_DATA");
349 PF (SEC_SHARED
, "SHARED");
350 PF (SEC_ARCH_BIT_0
, "ARCH_BIT_0");
351 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
353 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
357 switch (section
->flags
& SEC_LINK_DUPLICATES
)
361 case SEC_LINK_DUPLICATES_DISCARD
:
362 ls
= "LINK_ONCE_DISCARD";
364 case SEC_LINK_DUPLICATES_ONE_ONLY
:
365 ls
= "LINK_ONCE_ONE_ONLY";
367 case SEC_LINK_DUPLICATES_SAME_SIZE
:
368 ls
= "LINK_ONCE_SAME_SIZE";
370 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
371 ls
= "LINK_ONCE_SAME_CONTENTS";
374 printf ("%s%s", comma
, ls
);
376 if (section
->comdat
!= NULL
)
377 printf (" (COMDAT %s %ld)", section
->comdat
->name
,
378 section
->comdat
->symbol
);
391 printf (_("Sections:\n"));
394 printf (_("Idx Name Size VMA LMA File off Algn"));
396 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
397 if (bfd_get_arch_size (abfd
) == 32)
398 printf (_("Idx Name Size VMA LMA File off Algn"));
400 printf (_("Idx Name Size VMA LMA File off Algn"));
404 printf (_(" Flags"));
405 if (abfd
->flags
& HAS_LOAD_PAGE
)
409 bfd_map_over_sections (abfd
, dump_section_header
, (PTR
) NULL
);
416 asymbol
**sy
= (asymbol
**) NULL
;
419 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
425 storage
= bfd_get_symtab_upper_bound (abfd
);
427 bfd_fatal (bfd_get_filename (abfd
));
429 sy
= (asymbol
**) xmalloc (storage
);
431 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
433 bfd_fatal (bfd_get_filename (abfd
));
437 /* Read in the dynamic symbols. */
440 slurp_dynamic_symtab (abfd
)
443 asymbol
**sy
= (asymbol
**) NULL
;
446 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
449 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
451 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
456 bfd_fatal (bfd_get_filename (abfd
));
459 sy
= (asymbol
**) xmalloc (storage
);
461 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
463 bfd_fatal (bfd_get_filename (abfd
));
467 /* Filter out (in place) symbols that are useless for disassembly.
468 COUNT is the number of elements in SYMBOLS.
469 Return the number of useful symbols. */
472 remove_useless_symbols (symbols
, count
)
476 register asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
480 asymbol
*sym
= *in_ptr
++;
482 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
484 if (sym
->flags
& (BSF_DEBUGGING
))
486 if (bfd_is_und_section (sym
->section
)
487 || bfd_is_com_section (sym
->section
))
492 return out_ptr
- symbols
;
495 /* Sort symbols into value order. */
498 compare_symbols (ap
, bp
)
502 const asymbol
*a
= *(const asymbol
**)ap
;
503 const asymbol
*b
= *(const asymbol
**)bp
;
507 flagword aflags
, bflags
;
509 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
511 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
514 if (a
->section
> b
->section
)
516 else if (a
->section
< b
->section
)
519 an
= bfd_asymbol_name (a
);
520 bn
= bfd_asymbol_name (b
);
524 /* The symbols gnu_compiled and gcc2_compiled convey no real
525 information, so put them after other symbols with the same value. */
527 af
= (strstr (an
, "gnu_compiled") != NULL
528 || strstr (an
, "gcc2_compiled") != NULL
);
529 bf
= (strstr (bn
, "gnu_compiled") != NULL
530 || strstr (bn
, "gcc2_compiled") != NULL
);
537 /* We use a heuristic for the file name, to try to sort it after
538 more useful symbols. It may not work on non Unix systems, but it
539 doesn't really matter; the only difference is precisely which
540 symbol names get printed. */
542 #define file_symbol(s, sn, snl) \
543 (((s)->flags & BSF_FILE) != 0 \
544 || ((sn)[(snl) - 2] == '.' \
545 && ((sn)[(snl) - 1] == 'o' \
546 || (sn)[(snl) - 1] == 'a')))
548 af
= file_symbol (a
, an
, anl
);
549 bf
= file_symbol (b
, bn
, bnl
);
556 /* Try to sort global symbols before local symbols before function
557 symbols before debugging symbols. */
562 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
564 if ((aflags
& BSF_DEBUGGING
) != 0)
569 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
571 if ((aflags
& BSF_FUNCTION
) != 0)
576 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
578 if ((aflags
& BSF_LOCAL
) != 0)
583 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
585 if ((aflags
& BSF_GLOBAL
) != 0)
591 /* Symbols that start with '.' might be section names, so sort them
592 after symbols that don't start with '.'. */
593 if (an
[0] == '.' && bn
[0] != '.')
595 if (an
[0] != '.' && bn
[0] == '.')
598 /* Finally, if we can't distinguish them in any other way, try to
599 get consistent results by sorting the symbols by name. */
600 return strcmp (an
, bn
);
603 /* Sort relocs into address order. */
606 compare_relocs (ap
, bp
)
610 const arelent
*a
= *(const arelent
**)ap
;
611 const arelent
*b
= *(const arelent
**)bp
;
613 if (a
->address
> b
->address
)
615 else if (a
->address
< b
->address
)
618 /* So that associated relocations tied to the same address show up
619 in the correct order, we don't do any further sorting. */
628 /* Print VMA to STREAM. If SKIP_ZEROES is TRUE, omit leading zeroes. */
631 objdump_print_value (vma
, info
, skip_zeroes
)
633 struct disassemble_info
*info
;
634 bfd_boolean skip_zeroes
;
638 struct objdump_disasm_info
*aux
639 = (struct objdump_disasm_info
*) info
->application_data
;
641 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
646 for (p
= buf
; *p
== '0'; ++p
)
651 (*info
->fprintf_func
) (info
->stream
, "%s", p
);
654 /* Print the name of a symbol. */
657 objdump_print_symname (abfd
, info
, sym
)
659 struct disassemble_info
*info
;
666 name
= bfd_asymbol_name (sym
);
667 if (do_demangle
&& name
[0] != '\0')
669 /* Demangle the name. */
670 alloc
= demangle (abfd
, name
);
675 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
683 /* Locate a symbol given a bfd, a section, and a VMA. If REQUIRE_SEC
684 is TRUE, then always require the symbol to be in the section. This
685 returns NULL if there is no suitable symbol. If PLACE is not NULL,
686 then *PLACE is set to the index of the symbol in sorted_syms. */
689 find_symbol_for_address (abfd
, sec
, vma
, require_sec
, place
)
693 bfd_boolean require_sec
;
696 /* @@ Would it speed things up to cache the last two symbols returned,
697 and maybe their address ranges? For many processors, only one memory
698 operand can be present at a time, so the 2-entry cache wouldn't be
699 constantly churned by code doing heavy memory accesses. */
701 /* Indices in `sorted_syms'. */
703 long max
= sorted_symcount
;
705 unsigned int opb
= bfd_octets_per_byte (abfd
);
707 if (sorted_symcount
< 1)
710 /* Perform a binary search looking for the closest symbol to the
711 required value. We are searching the range (min, max]. */
712 while (min
+ 1 < max
)
716 thisplace
= (max
+ min
) / 2;
717 sym
= sorted_syms
[thisplace
];
719 if (bfd_asymbol_value (sym
) > vma
)
721 else if (bfd_asymbol_value (sym
) < vma
)
730 /* The symbol we want is now in min, the low end of the range we
731 were searching. If there are several symbols with the same
732 value, we want the first one. */
735 && (bfd_asymbol_value (sorted_syms
[thisplace
])
736 == bfd_asymbol_value (sorted_syms
[thisplace
- 1])))
739 /* If the file is relocateable, and the symbol could be from this
740 section, prefer a symbol from this section over symbols from
741 others, even if the other symbol's value might be closer.
743 Note that this may be wrong for some symbol references if the
744 sections have overlapping memory ranges, but in that case there's
745 no way to tell what's desired without looking at the relocation
748 if (sorted_syms
[thisplace
]->section
!= sec
750 || ((abfd
->flags
& HAS_RELOC
) != 0
751 && vma
>= bfd_get_section_vma (abfd
, sec
)
752 && vma
< (bfd_get_section_vma (abfd
, sec
)
753 + bfd_section_size (abfd
, sec
) / opb
))))
757 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
759 if (bfd_asymbol_value (sorted_syms
[i
])
760 != bfd_asymbol_value (sorted_syms
[thisplace
]))
766 if (sorted_syms
[i
]->section
== sec
768 || sorted_syms
[i
- 1]->section
!= sec
769 || (bfd_asymbol_value (sorted_syms
[i
])
770 != bfd_asymbol_value (sorted_syms
[i
- 1]))))
777 if (sorted_syms
[thisplace
]->section
!= sec
)
779 /* We didn't find a good symbol with a smaller value.
780 Look for one with a larger value. */
781 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
783 if (sorted_syms
[i
]->section
== sec
)
791 if (sorted_syms
[thisplace
]->section
!= sec
793 || ((abfd
->flags
& HAS_RELOC
) != 0
794 && vma
>= bfd_get_section_vma (abfd
, sec
)
795 && vma
< (bfd_get_section_vma (abfd
, sec
)
796 + bfd_section_size (abfd
, sec
)))))
798 /* There is no suitable symbol. */
806 return sorted_syms
[thisplace
];
809 /* Print an address to INFO symbolically. */
812 objdump_print_addr_with_sym (abfd
, sec
, sym
, vma
, info
, skip_zeroes
)
817 struct disassemble_info
*info
;
818 bfd_boolean skip_zeroes
;
820 objdump_print_value (vma
, info
, skip_zeroes
);
826 (*info
->fprintf_func
) (info
->stream
, " <%s",
827 bfd_get_section_name (abfd
, sec
));
828 secaddr
= bfd_get_section_vma (abfd
, sec
);
831 (*info
->fprintf_func
) (info
->stream
, "-0x");
832 objdump_print_value (secaddr
- vma
, info
, TRUE
);
834 else if (vma
> secaddr
)
836 (*info
->fprintf_func
) (info
->stream
, "+0x");
837 objdump_print_value (vma
- secaddr
, info
, TRUE
);
839 (*info
->fprintf_func
) (info
->stream
, ">");
843 (*info
->fprintf_func
) (info
->stream
, " <");
844 objdump_print_symname (abfd
, info
, sym
);
845 if (bfd_asymbol_value (sym
) > vma
)
847 (*info
->fprintf_func
) (info
->stream
, "-0x");
848 objdump_print_value (bfd_asymbol_value (sym
) - vma
, info
, TRUE
);
850 else if (vma
> bfd_asymbol_value (sym
))
852 (*info
->fprintf_func
) (info
->stream
, "+0x");
853 objdump_print_value (vma
- bfd_asymbol_value (sym
), info
, TRUE
);
855 (*info
->fprintf_func
) (info
->stream
, ">");
859 /* Print VMA to INFO, symbolically if possible. If SKIP_ZEROES is
860 TRUE, don't output leading zeroes. */
863 objdump_print_addr (vma
, info
, skip_zeroes
)
865 struct disassemble_info
*info
;
866 bfd_boolean skip_zeroes
;
868 struct objdump_disasm_info
*aux
;
871 if (sorted_symcount
< 1)
873 (*info
->fprintf_func
) (info
->stream
, "0x");
874 objdump_print_value (vma
, info
, skip_zeroes
);
878 aux
= (struct objdump_disasm_info
*) info
->application_data
;
879 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
881 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, info
,
885 /* Print VMA to INFO. This function is passed to the disassembler
889 objdump_print_address (vma
, info
)
891 struct disassemble_info
*info
;
893 objdump_print_addr (vma
, info
, ! prefix_addresses
);
896 /* Determine of the given address has a symbol associated with it. */
899 objdump_symbol_at_address (vma
, info
)
901 struct disassemble_info
* info
;
903 struct objdump_disasm_info
* aux
;
906 /* No symbols - do not bother checking. */
907 if (sorted_symcount
< 1)
910 aux
= (struct objdump_disasm_info
*) info
->application_data
;
911 sym
= find_symbol_for_address (aux
->abfd
, aux
->sec
, vma
, aux
->require_sec
,
914 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
917 /* Hold the last function name and the last line number we displayed
920 static char *prev_functionname
;
921 static unsigned int prev_line
;
923 /* We keep a list of all files that we have seen when doing a
924 dissassembly with source, so that we know how much of the file to
925 display. This can be important for inlined functions. */
927 struct print_file_list
929 struct print_file_list
*next
;
935 static struct print_file_list
*print_files
;
937 /* The number of preceding context lines to show when we start
938 displaying a file for the first time. */
940 #define SHOW_PRECEDING_CONTEXT_LINES (5)
942 /* Skip ahead to a given line in a file, optionally printing each
945 static void skip_to_line
946 PARAMS ((struct print_file_list
*, unsigned int, bfd_boolean
));
949 skip_to_line (p
, line
, show
)
950 struct print_file_list
*p
;
954 while (p
->line
< line
)
958 if (fgets (buf
, sizeof buf
, p
->f
) == NULL
)
968 if (strchr (buf
, '\n') != NULL
)
973 /* Show the line number, or the source line, in a dissassembly
977 show_line (abfd
, section
, addr_offset
)
982 const char *filename
;
983 const char *functionname
;
986 if (! with_line_numbers
&& ! with_source_code
)
989 if (! bfd_find_nearest_line (abfd
, section
, syms
, addr_offset
, &filename
,
990 &functionname
, &line
))
993 if (filename
!= NULL
&& *filename
== '\0')
995 if (functionname
!= NULL
&& *functionname
== '\0')
998 if (with_line_numbers
)
1000 if (functionname
!= NULL
1001 && (prev_functionname
== NULL
1002 || strcmp (functionname
, prev_functionname
) != 0))
1003 printf ("%s():\n", functionname
);
1004 if (line
> 0 && line
!= prev_line
)
1005 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
1008 if (with_source_code
1012 struct print_file_list
**pp
, *p
;
1014 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1015 if (strcmp ((*pp
)->filename
, filename
) == 0)
1021 if (p
!= print_files
)
1025 /* We have reencountered a file name which we saw
1026 earlier. This implies that either we are dumping out
1027 code from an included file, or the same file was
1028 linked in more than once. There are two common cases
1029 of an included file: inline functions in a header
1030 file, and a bison or flex skeleton file. In the
1031 former case we want to just start printing (but we
1032 back up a few lines to give context); in the latter
1033 case we want to continue from where we left off. I
1034 can't think of a good way to distinguish the cases,
1035 so I used a heuristic based on the file name. */
1036 if (strcmp (p
->filename
+ strlen (p
->filename
) - 2, ".h") != 0)
1040 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1047 p
->f
= fopen (p
->filename
, "r");
1051 skip_to_line (p
, l
, FALSE
);
1053 if (print_files
->f
!= NULL
)
1055 fclose (print_files
->f
);
1056 print_files
->f
= NULL
;
1062 skip_to_line (p
, line
, TRUE
);
1064 p
->next
= print_files
;
1072 f
= fopen (filename
, "r");
1077 p
= ((struct print_file_list
*)
1078 xmalloc (sizeof (struct print_file_list
)));
1079 p
->filename
= xmalloc (strlen (filename
) + 1);
1080 strcpy (p
->filename
, filename
);
1084 if (print_files
!= NULL
&& print_files
->f
!= NULL
)
1086 fclose (print_files
->f
);
1087 print_files
->f
= NULL
;
1089 p
->next
= print_files
;
1092 if (file_start_context
)
1095 l
= line
- SHOW_PRECEDING_CONTEXT_LINES
;
1098 skip_to_line (p
, l
, FALSE
);
1100 skip_to_line (p
, line
, TRUE
);
1105 if (functionname
!= NULL
1106 && (prev_functionname
== NULL
1107 || strcmp (functionname
, prev_functionname
) != 0))
1109 if (prev_functionname
!= NULL
)
1110 free (prev_functionname
);
1111 prev_functionname
= xmalloc (strlen (functionname
) + 1);
1112 strcpy (prev_functionname
, functionname
);
1115 if (line
> 0 && line
!= prev_line
)
1119 /* Pseudo FILE object for strings. */
1127 /* sprintf to a "stream" */
1130 objdump_sprintf
VPARAMS ((SFILE
*f
, const char *format
, ...))
1135 VA_OPEN (args
, format
);
1136 VA_FIXEDARG (args
, SFILE
*, f
);
1137 VA_FIXEDARG (args
, const char *, format
);
1139 vasprintf (&buf
, format
, args
);
1144 fatal (_("Out of virtual memory"));
1149 while ((size_t) ((f
->buffer
+ f
->size
) - f
->current
) < n
+ 1)
1153 curroff
= f
->current
- f
->buffer
;
1155 f
->buffer
= xrealloc (f
->buffer
, f
->size
);
1156 f
->current
= f
->buffer
+ curroff
;
1159 memcpy (f
->current
, buf
, n
);
1161 f
->current
[0] = '\0';
1169 /* The number of zeroes we want to see before we start skipping them.
1170 The number is arbitrarily chosen. */
1173 #define SKIP_ZEROES (8)
1176 /* The number of zeroes to skip at the end of a section. If the
1177 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1178 SKIP_ZEROES, they will be disassembled. If there are fewer than
1179 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1180 attempt to avoid disassembling zeroes inserted by section
1183 #ifndef SKIP_ZEROES_AT_END
1184 #define SKIP_ZEROES_AT_END (3)
1187 /* Disassemble some data in memory between given values. */
1190 disassemble_bytes (info
, disassemble_fn
, insns
, data
,
1191 start_offset
, stop_offset
, relppp
,
1193 struct disassemble_info
*info
;
1194 disassembler_ftype disassemble_fn
;
1197 bfd_vma start_offset
;
1198 bfd_vma stop_offset
;
1202 struct objdump_disasm_info
*aux
;
1204 int octets_per_line
;
1205 bfd_boolean done_dot
;
1206 int skip_addr_chars
;
1207 bfd_vma addr_offset
;
1208 int opb
= info
->octets_per_byte
;
1210 aux
= (struct objdump_disasm_info
*) info
->application_data
;
1214 octets_per_line
= 4;
1216 octets_per_line
= 16;
1218 /* Figure out how many characters to skip at the start of an
1219 address, to make the disassembly look nicer. We discard leading
1220 zeroes in chunks of 4, ensuring that there is always a leading
1222 skip_addr_chars
= 0;
1223 if (! prefix_addresses
)
1231 + bfd_section_size (section
->owner
, section
) / opb
));
1233 while (s
[0] == '0' && s
[1] == '0' && s
[2] == '0' && s
[3] == '0'
1236 skip_addr_chars
+= 4;
1241 info
->insn_info_valid
= 0;
1244 addr_offset
= start_offset
;
1245 while (addr_offset
< stop_offset
)
1249 bfd_boolean need_nl
= FALSE
;
1251 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1253 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1256 if (! disassemble_zeroes
1257 && (info
->insn_info_valid
== 0
1258 || info
->branch_delay_insns
== 0)
1259 && (z
- addr_offset
* opb
>= SKIP_ZEROES
1260 || (z
== stop_offset
* opb
&&
1261 z
- addr_offset
* opb
< SKIP_ZEROES_AT_END
)))
1265 /* If there are more nonzero octets to follow, we only skip
1266 zeroes in multiples of 4, to try to avoid running over
1267 the start of an instruction which happens to start with
1269 if (z
!= stop_offset
* opb
)
1270 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1272 octets
= z
- addr_offset
* opb
;
1283 if (with_line_numbers
|| with_source_code
)
1284 /* The line number tables will refer to unadjusted
1285 section VMAs, so we must undo any VMA modifications
1286 when calling show_line. */
1287 show_line (aux
->abfd
, section
, addr_offset
- adjust_section_vma
);
1289 if (! prefix_addresses
)
1293 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1294 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1298 printf ("%s:\t", buf
+ skip_addr_chars
);
1302 aux
->require_sec
= TRUE
;
1303 objdump_print_address (section
->vma
+ addr_offset
, info
);
1304 aux
->require_sec
= FALSE
;
1311 sfile
.buffer
= xmalloc (sfile
.size
);
1312 sfile
.current
= sfile
.buffer
;
1313 info
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1314 info
->stream
= (FILE *) &sfile
;
1315 info
->bytes_per_line
= 0;
1316 info
->bytes_per_chunk
= 0;
1318 #ifdef DISASSEMBLER_NEEDS_RELOCS
1319 /* FIXME: This is wrong. It tests the number of octets
1320 in the last instruction, not the current one. */
1321 if (*relppp
< relppend
1322 && (**relppp
)->address
>= addr_offset
1323 && (**relppp
)->address
<= addr_offset
+ octets
/ opb
)
1324 info
->flags
= INSN_HAS_RELOC
;
1329 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, info
);
1330 info
->fprintf_func
= (fprintf_ftype
) fprintf
;
1331 info
->stream
= stdout
;
1332 if (info
->bytes_per_line
!= 0)
1333 octets_per_line
= info
->bytes_per_line
;
1336 if (sfile
.current
!= sfile
.buffer
)
1337 printf ("%s\n", sfile
.buffer
);
1338 free (sfile
.buffer
);
1346 octets
= octets_per_line
;
1347 if (addr_offset
+ octets
/ opb
> stop_offset
)
1348 octets
= (stop_offset
- addr_offset
) * opb
;
1350 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
1352 if (ISPRINT (data
[j
]))
1353 buf
[j
- addr_offset
* opb
] = data
[j
];
1355 buf
[j
- addr_offset
* opb
] = '.';
1357 buf
[j
- addr_offset
* opb
] = '\0';
1360 if (prefix_addresses
1362 : show_raw_insn
>= 0)
1366 /* If ! prefix_addresses and ! wide_output, we print
1367 octets_per_line octets per line. */
1369 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
1370 pb
= octets_per_line
;
1372 if (info
->bytes_per_chunk
)
1373 bpc
= info
->bytes_per_chunk
;
1377 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1380 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1382 for (k
= bpc
- 1; k
>= 0; k
--)
1383 printf ("%02x", (unsigned) data
[j
+ k
]);
1388 for (k
= 0; k
< bpc
; k
++)
1389 printf ("%02x", (unsigned) data
[j
+ k
]);
1394 for (; pb
< octets_per_line
; pb
+= bpc
)
1398 for (k
= 0; k
< bpc
; k
++)
1403 /* Separate raw data from instruction by extra space. */
1414 printf ("%s", sfile
.buffer
);
1415 free (sfile
.buffer
);
1418 if (prefix_addresses
1420 : show_raw_insn
>= 0)
1428 j
= addr_offset
* opb
+ pb
;
1430 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
1431 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1435 printf ("%s:\t", buf
+ skip_addr_chars
);
1437 pb
+= octets_per_line
;
1440 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
1444 if (bpc
> 1 && info
->display_endian
== BFD_ENDIAN_LITTLE
)
1446 for (k
= bpc
- 1; k
>= 0; k
--)
1447 printf ("%02x", (unsigned) data
[j
+ k
]);
1452 for (k
= 0; k
< bpc
; k
++)
1453 printf ("%02x", (unsigned) data
[j
+ k
]);
1466 if ((section
->flags
& SEC_RELOC
) != 0
1467 #ifndef DISASSEMBLER_NEEDS_RELOCS
1472 while ((*relppp
) < relppend
1473 && ((**relppp
)->address
>= (bfd_vma
) addr_offset
1474 && (**relppp
)->address
< (bfd_vma
) addr_offset
+ octets
/ opb
))
1475 #ifdef DISASSEMBLER_NEEDS_RELOCS
1476 if (! dump_reloc_info
)
1490 objdump_print_value (section
->vma
+ q
->address
, info
, TRUE
);
1492 printf (": %s\t", q
->howto
->name
);
1494 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
1495 printf ("*unknown*");
1498 const char *sym_name
;
1500 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
1501 if (sym_name
!= NULL
&& *sym_name
!= '\0')
1502 objdump_print_symname (aux
->abfd
, info
, *q
->sym_ptr_ptr
);
1507 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
1508 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
1509 if (sym_name
== NULL
|| *sym_name
== '\0')
1510 sym_name
= "*unknown*";
1511 printf ("%s", sym_name
);
1518 objdump_print_value (q
->addend
, info
, TRUE
);
1530 addr_offset
+= octets
/ opb
;
1534 /* Disassemble the contents of an object file. */
1537 disassemble_data (abfd
)
1540 unsigned long addr_offset
;
1541 disassembler_ftype disassemble_fn
;
1542 struct disassemble_info disasm_info
;
1543 struct objdump_disasm_info aux
;
1548 prev_functionname
= NULL
;
1551 /* We make a copy of syms to sort. We don't want to sort syms
1552 because that will screw up the relocs. */
1553 sorted_syms
= (asymbol
**) xmalloc (symcount
* sizeof (asymbol
*));
1554 memcpy (sorted_syms
, syms
, symcount
* sizeof (asymbol
*));
1556 sorted_symcount
= remove_useless_symbols (sorted_syms
, symcount
);
1558 /* Sort the symbols into section and symbol order */
1559 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
1561 INIT_DISASSEMBLE_INFO(disasm_info
, stdout
, fprintf
);
1562 disasm_info
.application_data
= (PTR
) &aux
;
1564 aux
.require_sec
= FALSE
;
1565 disasm_info
.print_address_func
= objdump_print_address
;
1566 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
1568 if (machine
!= (char *) NULL
)
1570 const bfd_arch_info_type
*info
= bfd_scan_arch (machine
);
1573 fatal (_("Can't use supplied machine %s"), machine
);
1575 abfd
->arch_info
= info
;
1578 if (endian
!= BFD_ENDIAN_UNKNOWN
)
1580 struct bfd_target
*xvec
;
1582 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
1583 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
1584 xvec
->byteorder
= endian
;
1588 disassemble_fn
= disassembler (abfd
);
1589 if (!disassemble_fn
)
1591 non_fatal (_("Can't disassemble for architecture %s\n"),
1592 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
1597 opb
= bfd_octets_per_byte (abfd
);
1599 disasm_info
.flavour
= bfd_get_flavour (abfd
);
1600 disasm_info
.arch
= bfd_get_arch (abfd
);
1601 disasm_info
.mach
= bfd_get_mach (abfd
);
1602 disasm_info
.disassembler_options
= disassembler_options
;
1603 disasm_info
.octets_per_byte
= opb
;
1605 if (bfd_big_endian (abfd
))
1606 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
1607 else if (bfd_little_endian (abfd
))
1608 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1610 /* ??? Aborting here seems too drastic. We could default to big or little
1612 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
1614 for (section
= abfd
->sections
;
1615 section
!= (asection
*) NULL
;
1616 section
= section
->next
)
1618 bfd_byte
*data
= NULL
;
1619 bfd_size_type datasize
= 0;
1620 arelent
**relbuf
= NULL
;
1621 arelent
**relpp
= NULL
;
1622 arelent
**relppend
= NULL
;
1623 unsigned long stop_offset
;
1624 asymbol
*sym
= NULL
;
1627 if ((section
->flags
& SEC_LOAD
) == 0
1628 || (! disassemble_all
1630 && (section
->flags
& SEC_CODE
) == 0))
1632 if (only
!= (char *) NULL
&& strcmp (only
, section
->name
) != 0)
1635 if ((section
->flags
& SEC_RELOC
) != 0
1636 #ifndef DISASSEMBLER_NEEDS_RELOCS
1643 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
1645 bfd_fatal (bfd_get_filename (abfd
));
1651 relbuf
= (arelent
**) xmalloc (relsize
);
1652 relcount
= bfd_canonicalize_reloc (abfd
, section
, relbuf
, syms
);
1654 bfd_fatal (bfd_get_filename (abfd
));
1656 /* Sort the relocs by address. */
1657 qsort (relbuf
, relcount
, sizeof (arelent
*), compare_relocs
);
1660 relppend
= relpp
+ relcount
;
1662 /* Skip over the relocs belonging to addresses below the
1664 if (start_address
!= (bfd_vma
) -1)
1666 while (relpp
< relppend
1667 && (*relpp
)->address
< start_address
)
1673 printf (_("Disassembly of section %s:\n"), section
->name
);
1675 datasize
= bfd_get_section_size_before_reloc (section
);
1679 data
= (bfd_byte
*) xmalloc ((size_t) datasize
);
1681 bfd_get_section_contents (abfd
, section
, data
, 0, datasize
);
1684 disasm_info
.buffer
= data
;
1685 disasm_info
.buffer_vma
= section
->vma
;
1686 disasm_info
.buffer_length
= datasize
;
1687 disasm_info
.section
= section
;
1688 if (start_address
== (bfd_vma
) -1
1689 || start_address
< disasm_info
.buffer_vma
)
1692 addr_offset
= start_address
- disasm_info
.buffer_vma
;
1693 if (stop_address
== (bfd_vma
) -1)
1694 stop_offset
= datasize
/ opb
;
1697 if (stop_address
< disasm_info
.buffer_vma
)
1700 stop_offset
= stop_address
- disasm_info
.buffer_vma
;
1701 if (stop_offset
> disasm_info
.buffer_length
/ opb
)
1702 stop_offset
= disasm_info
.buffer_length
/ opb
;
1705 sym
= find_symbol_for_address (abfd
, section
, section
->vma
+ addr_offset
,
1708 while (addr_offset
< stop_offset
)
1711 unsigned long nextstop_offset
;
1714 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= section
->vma
+ addr_offset
)
1719 (x
< sorted_symcount
1720 && bfd_asymbol_value (sorted_syms
[x
]) <= section
->vma
+ addr_offset
);
1723 disasm_info
.symbols
= & sorted_syms
[place
];
1724 disasm_info
.num_symbols
= x
- place
;
1727 disasm_info
.symbols
= NULL
;
1729 if (! prefix_addresses
)
1732 objdump_print_addr_with_sym (abfd
, section
, sym
,
1733 section
->vma
+ addr_offset
,
1739 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
)
1741 else if (sym
== NULL
)
1745 /* Search forward for the next appropriate symbol in
1746 SECTION. Note that all the symbols are sorted
1747 together into one big array, and that some sections
1748 may have overlapping addresses. */
1749 while (place
< sorted_symcount
1750 && (sorted_syms
[place
]->section
!= section
1751 || (bfd_asymbol_value (sorted_syms
[place
])
1752 <= bfd_asymbol_value (sym
))))
1754 if (place
>= sorted_symcount
)
1757 nextsym
= sorted_syms
[place
];
1760 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
)
1762 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
1763 if (nextstop_offset
> stop_offset
)
1764 nextstop_offset
= stop_offset
;
1766 else if (nextsym
== NULL
)
1767 nextstop_offset
= stop_offset
;
1770 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
1771 if (nextstop_offset
> stop_offset
)
1772 nextstop_offset
= stop_offset
;
1775 /* If a symbol is explicitly marked as being an object
1776 rather than a function, just dump the bytes without
1777 disassembling them. */
1780 || bfd_asymbol_value (sym
) > section
->vma
+ addr_offset
1781 || ((sym
->flags
& BSF_OBJECT
) == 0
1782 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
1784 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
1786 || (sym
->flags
& BSF_FUNCTION
) != 0)
1791 disassemble_bytes (&disasm_info
, disassemble_fn
, insns
, data
,
1792 addr_offset
, nextstop_offset
, &relpp
, relppend
);
1794 addr_offset
= nextstop_offset
;
1806 /* Define a table of stab values and print-strings. We wish the initializer
1807 could be a direct-mapped table, but instead we build one the first
1810 static void dump_section_stabs
1811 PARAMS ((bfd
*abfd
, char *stabsect_name
, char *strsect_name
));
1813 /* Dump the stabs sections from an object file that has a section that
1814 uses Sun stabs encoding. */
1820 dump_section_stabs (abfd
, ".stab", ".stabstr");
1821 dump_section_stabs (abfd
, ".stab.excl", ".stab.exclstr");
1822 dump_section_stabs (abfd
, ".stab.index", ".stab.indexstr");
1823 dump_section_stabs (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1826 static bfd_byte
*stabs
;
1827 static bfd_size_type stab_size
;
1829 static char *strtab
;
1830 static bfd_size_type stabstr_size
;
1832 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1833 and string table section STRSECT_NAME into `strtab'.
1834 If the section exists and was read, allocate the space and return TRUE.
1835 Otherwise return FALSE. */
1838 read_section_stabs (abfd
, stabsect_name
, strsect_name
)
1840 const char *stabsect_name
;
1841 const char *strsect_name
;
1843 asection
*stabsect
, *stabstrsect
;
1845 stabsect
= bfd_get_section_by_name (abfd
, stabsect_name
);
1848 printf (_("No %s section present\n\n"), stabsect_name
);
1852 stabstrsect
= bfd_get_section_by_name (abfd
, strsect_name
);
1853 if (0 == stabstrsect
)
1855 non_fatal (_("%s has no %s section"),
1856 bfd_get_filename (abfd
), strsect_name
);
1861 stab_size
= bfd_section_size (abfd
, stabsect
);
1862 stabstr_size
= bfd_section_size (abfd
, stabstrsect
);
1864 stabs
= (bfd_byte
*) xmalloc (stab_size
);
1865 strtab
= (char *) xmalloc (stabstr_size
);
1867 if (! bfd_get_section_contents (abfd
, stabsect
, (PTR
) stabs
, 0, stab_size
))
1869 non_fatal (_("Reading %s section of %s failed: %s"),
1870 stabsect_name
, bfd_get_filename (abfd
),
1871 bfd_errmsg (bfd_get_error ()));
1878 if (! bfd_get_section_contents (abfd
, stabstrsect
, (PTR
) strtab
, 0,
1881 non_fatal (_("Reading %s section of %s failed: %s\n"),
1882 strsect_name
, bfd_get_filename (abfd
),
1883 bfd_errmsg (bfd_get_error ()));
1893 /* Stabs entries use a 12 byte format:
1894 4 byte string table index
1896 1 byte stab other field
1897 2 byte stab desc field
1899 FIXME: This will have to change for a 64 bit object format. */
1901 #define STRDXOFF (0)
1903 #define OTHEROFF (5)
1906 #define STABSIZE (12)
1908 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1909 using string table section STRSECT_NAME (in `strtab'). */
1912 print_section_stabs (abfd
, stabsect_name
, strsect_name
)
1914 const char *stabsect_name
;
1915 const char *strsect_name ATTRIBUTE_UNUSED
;
1918 unsigned file_string_table_offset
= 0, next_file_string_table_offset
= 0;
1919 bfd_byte
*stabp
, *stabs_end
;
1922 stabs_end
= stabp
+ stab_size
;
1924 printf (_("Contents of %s section:\n\n"), stabsect_name
);
1925 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
1927 /* Loop through all symbols and print them.
1929 We start the index at -1 because there is a dummy symbol on
1930 the front of stabs-in-{coff,elf} sections that supplies sizes. */
1932 for (i
= -1; stabp
< stabs_end
; stabp
+= STABSIZE
, i
++)
1936 unsigned char type
, other
;
1937 unsigned short desc
;
1940 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
1941 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
1942 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
1943 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
1944 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
1946 printf ("\n%-6d ", i
);
1947 /* Either print the stab name, or, if unnamed, print its number
1948 again (makes consistent formatting for tools like awk). */
1949 name
= bfd_get_stab_name (type
);
1951 printf ("%-6s", name
);
1952 else if (type
== N_UNDF
)
1955 printf ("%-6d", type
);
1956 printf (" %-6d %-6d ", other
, desc
);
1957 bfd_printf_vma (abfd
, value
);
1958 printf (" %-6lu", strx
);
1960 /* Symbols with type == 0 (N_UNDF) specify the length of the
1961 string table associated with this file. We use that info
1962 to know how to relocate the *next* file's string table indices. */
1966 file_string_table_offset
= next_file_string_table_offset
;
1967 next_file_string_table_offset
+= value
;
1971 /* Using the (possibly updated) string table offset, print the
1972 string (if any) associated with this symbol. */
1974 if ((strx
+ file_string_table_offset
) < stabstr_size
)
1975 printf (" %s", &strtab
[strx
+ file_string_table_offset
]);
1984 dump_section_stabs (abfd
, stabsect_name
, strsect_name
)
1986 char *stabsect_name
;
1991 /* Check for section names for which stabsect_name is a prefix, to
1992 handle .stab0, etc. */
1993 for (s
= abfd
->sections
;
1999 len
= strlen (stabsect_name
);
2001 /* If the prefix matches, and the files section name ends with a
2002 nul or a digit, then we match. I.e., we want either an exact
2003 match or a section followed by a number. */
2004 if (strncmp (stabsect_name
, s
->name
, len
) == 0
2005 && (s
->name
[len
] == '\000'
2006 || ISDIGIT (s
->name
[len
])))
2008 if (read_section_stabs (abfd
, s
->name
, strsect_name
))
2010 print_section_stabs (abfd
, s
->name
, strsect_name
);
2019 dump_bfd_header (abfd
)
2024 printf (_("architecture: %s, "),
2025 bfd_printable_arch_mach (bfd_get_arch (abfd
),
2026 bfd_get_mach (abfd
)));
2027 printf (_("flags 0x%08x:\n"), abfd
->flags
);
2029 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2030 PF (HAS_RELOC
, "HAS_RELOC");
2031 PF (EXEC_P
, "EXEC_P");
2032 PF (HAS_LINENO
, "HAS_LINENO");
2033 PF (HAS_DEBUG
, "HAS_DEBUG");
2034 PF (HAS_SYMS
, "HAS_SYMS");
2035 PF (HAS_LOCALS
, "HAS_LOCALS");
2036 PF (DYNAMIC
, "DYNAMIC");
2037 PF (WP_TEXT
, "WP_TEXT");
2038 PF (D_PAGED
, "D_PAGED");
2039 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
2040 PF (HAS_LOAD_PAGE
, "HAS_LOAD_PAGE");
2041 printf (_("\nstart address 0x"));
2042 bfd_printf_vma (abfd
, abfd
->start_address
);
2047 dump_bfd_private_header (abfd
)
2050 bfd_print_private_bfd_data (abfd
, stdout
);
2053 /* Dump selected contents of ABFD */
2059 /* If we are adjusting section VMA's, change them all now. Changing
2060 the BFD information is a hack. However, we must do it, or
2061 bfd_find_nearest_line will not do the right thing. */
2062 if (adjust_section_vma
!= 0)
2066 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2068 s
->vma
+= adjust_section_vma
;
2069 s
->lma
+= adjust_section_vma
;
2073 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd
),
2076 print_arelt_descr (stdout
, abfd
, TRUE
);
2077 if (dump_file_header
)
2078 dump_bfd_header (abfd
);
2079 if (dump_private_headers
)
2080 dump_bfd_private_header (abfd
);
2082 if (dump_section_headers
)
2083 dump_headers (abfd
);
2085 if (dump_symtab
|| dump_reloc_info
|| disassemble
|| dump_debugging
)
2086 syms
= slurp_symtab (abfd
);
2087 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
)
2088 dynsyms
= slurp_dynamic_symtab (abfd
);
2091 dump_symbols (abfd
, FALSE
);
2092 if (dump_dynamic_symtab
)
2093 dump_symbols (abfd
, TRUE
);
2094 if (dump_stab_section_info
)
2096 if (dump_reloc_info
&& ! disassemble
)
2098 if (dump_dynamic_reloc_info
)
2099 dump_dynamic_relocs (abfd
);
2100 if (dump_section_contents
)
2103 disassemble_data (abfd
);
2108 dhandle
= read_debugging_info (abfd
, syms
, symcount
);
2109 if (dhandle
!= NULL
)
2111 if (! print_debugging_info (stdout
, dhandle
))
2113 non_fatal (_("%s: printing debugging information failed"),
2114 bfd_get_filename (abfd
));
2139 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
2145 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2147 nonfatal (bfd_get_filename (abfd
));
2148 list_matching_formats (matching
);
2153 if (bfd_get_error () != bfd_error_file_not_recognized
)
2155 nonfatal (bfd_get_filename (abfd
));
2159 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
2165 nonfatal (bfd_get_filename (abfd
));
2167 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
2169 list_matching_formats (matching
);
2175 display_file (filename
, target
)
2179 bfd
*file
, *arfile
= (bfd
*) NULL
;
2181 file
= bfd_openr (filename
, target
);
2184 nonfatal (filename
);
2188 if (bfd_check_format (file
, bfd_archive
))
2190 bfd
*last_arfile
= NULL
;
2192 printf (_("In archive %s:\n"), bfd_get_filename (file
));
2195 bfd_set_error (bfd_error_no_error
);
2197 arfile
= bfd_openr_next_archived_file (file
, arfile
);
2200 if (bfd_get_error () != bfd_error_no_more_archived_files
)
2201 nonfatal (bfd_get_filename (file
));
2205 display_bfd (arfile
);
2207 if (last_arfile
!= NULL
)
2208 bfd_close (last_arfile
);
2209 last_arfile
= arfile
;
2212 if (last_arfile
!= NULL
)
2213 bfd_close (last_arfile
);
2221 /* Actually display the various requested regions */
2229 bfd_size_type datasize
= 0;
2230 bfd_size_type addr_offset
;
2231 bfd_size_type start_offset
, stop_offset
;
2232 unsigned int opb
= bfd_octets_per_byte (abfd
);
2234 for (section
= abfd
->sections
; section
!= NULL
; section
=
2239 if (only
== (char *) NULL
||
2240 strcmp (only
, section
->name
) == 0)
2242 if (section
->flags
& SEC_HAS_CONTENTS
)
2244 printf (_("Contents of section %s:\n"), section
->name
);
2246 if (bfd_section_size (abfd
, section
) == 0)
2248 data
= (bfd_byte
*) xmalloc ((size_t) bfd_section_size (abfd
, section
));
2249 datasize
= bfd_section_size (abfd
, section
);
2252 bfd_get_section_contents (abfd
, section
, (PTR
) data
, 0, bfd_section_size (abfd
, section
));
2254 if (start_address
== (bfd_vma
) -1
2255 || start_address
< section
->vma
)
2258 start_offset
= start_address
- section
->vma
;
2259 if (stop_address
== (bfd_vma
) -1)
2260 stop_offset
= bfd_section_size (abfd
, section
) / opb
;
2263 if (stop_address
< section
->vma
)
2266 stop_offset
= stop_address
- section
->vma
;
2267 if (stop_offset
> bfd_section_size (abfd
, section
) / opb
)
2268 stop_offset
= bfd_section_size (abfd
, section
) / opb
;
2270 for (addr_offset
= start_offset
;
2271 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
2275 printf (" %04lx ", (unsigned long int)
2276 (addr_offset
+ section
->vma
));
2277 for (j
= addr_offset
* opb
;
2278 j
< addr_offset
* opb
+ onaline
; j
++)
2280 if (j
< stop_offset
* opb
)
2281 printf ("%02x", (unsigned) (data
[j
]));
2289 for (j
= addr_offset
* opb
;
2290 j
< addr_offset
* opb
+ onaline
; j
++)
2292 if (j
>= stop_offset
* opb
)
2295 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
2305 /* Should perhaps share code and display with nm? */
2307 dump_symbols (abfd
, dynamic
)
2308 bfd
*abfd ATTRIBUTE_UNUSED
;
2309 bfd_boolean dynamic
;
2319 printf ("DYNAMIC SYMBOL TABLE:\n");
2325 printf ("SYMBOL TABLE:\n");
2329 printf (_("no symbols\n"));
2331 for (count
= 0; count
< max
; count
++)
2335 bfd
*cur_bfd
= bfd_asymbol_bfd (*current
);
2337 if (cur_bfd
!= NULL
)
2342 name
= (*current
)->name
;
2344 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
2346 /* If we want to demangle the name, we demangle it
2347 here, and temporarily clobber it while calling
2348 bfd_print_symbol. FIXME: This is a gross hack. */
2350 alloc
= demangle (cur_bfd
, name
);
2351 (*current
)->name
= alloc
;
2354 bfd_print_symbol (cur_bfd
, stdout
, *current
,
2355 bfd_print_symbol_all
);
2357 (*current
)->name
= name
;
2378 for (a
= abfd
->sections
; a
!= (asection
*) NULL
; a
= a
->next
)
2382 if (bfd_is_abs_section (a
))
2384 if (bfd_is_und_section (a
))
2386 if (bfd_is_com_section (a
))
2391 if (strcmp (only
, a
->name
))
2394 else if ((a
->flags
& SEC_RELOC
) == 0)
2397 relsize
= bfd_get_reloc_upper_bound (abfd
, a
);
2399 bfd_fatal (bfd_get_filename (abfd
));
2401 printf ("RELOCATION RECORDS FOR [%s]:", a
->name
);
2405 printf (" (none)\n\n");
2409 relpp
= (arelent
**) xmalloc (relsize
);
2410 relcount
= bfd_canonicalize_reloc (abfd
, a
, relpp
, syms
);
2412 bfd_fatal (bfd_get_filename (abfd
));
2413 else if (relcount
== 0)
2415 printf (" (none)\n\n");
2420 dump_reloc_set (abfd
, a
, relpp
, relcount
);
2429 dump_dynamic_relocs (abfd
)
2436 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2438 bfd_fatal (bfd_get_filename (abfd
));
2440 printf ("DYNAMIC RELOCATION RECORDS");
2444 printf (" (none)\n\n");
2448 relpp
= (arelent
**) xmalloc (relsize
);
2449 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
2451 bfd_fatal (bfd_get_filename (abfd
));
2452 else if (relcount
== 0)
2454 printf (" (none)\n\n");
2459 dump_reloc_set (abfd
, (asection
*) NULL
, relpp
, relcount
);
2467 dump_reloc_set (abfd
, sec
, relpp
, relcount
)
2474 char *last_filename
, *last_functionname
;
2475 unsigned int last_line
;
2477 /* Get column headers lined up reasonably. */
2483 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
2484 width
= strlen (buf
) - 7;
2486 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
2489 last_filename
= NULL
;
2490 last_functionname
= NULL
;
2493 for (p
= relpp
; relcount
&& *p
!= (arelent
*) NULL
; p
++, relcount
--)
2496 const char *filename
, *functionname
;
2498 const char *sym_name
;
2499 const char *section_name
;
2501 if (start_address
!= (bfd_vma
) -1
2502 && q
->address
< start_address
)
2504 if (stop_address
!= (bfd_vma
) -1
2505 && q
->address
> stop_address
)
2508 if (with_line_numbers
2510 && bfd_find_nearest_line (abfd
, sec
, syms
, q
->address
,
2511 &filename
, &functionname
, &line
))
2513 if (functionname
!= NULL
2514 && (last_functionname
== NULL
2515 || strcmp (functionname
, last_functionname
) != 0))
2517 printf ("%s():\n", functionname
);
2518 if (last_functionname
!= NULL
)
2519 free (last_functionname
);
2520 last_functionname
= xstrdup (functionname
);
2523 && (line
!= last_line
2524 || (filename
!= NULL
2525 && last_filename
!= NULL
2526 && strcmp (filename
, last_filename
) != 0)))
2528 printf ("%s:%u\n", filename
== NULL
? "???" : filename
, line
);
2530 if (last_filename
!= NULL
)
2531 free (last_filename
);
2532 if (filename
== NULL
)
2533 last_filename
= NULL
;
2535 last_filename
= xstrdup (filename
);
2539 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
2541 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
2542 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
2547 section_name
= NULL
;
2551 bfd_printf_vma (abfd
, q
->address
);
2553 printf (" %-16s ", q
->howto
->name
);
2555 printf (" %-16d ", q
->howto
->type
);
2556 objdump_print_symname (abfd
, (struct disassemble_info
*) NULL
,
2561 if (section_name
== (const char *) NULL
)
2562 section_name
= "*unknown*";
2563 bfd_printf_vma (abfd
, q
->address
);
2564 printf (" %-16s [%s]",
2571 bfd_printf_vma (abfd
, q
->addend
);
2577 /* The length of the longest architecture name + 1. */
2578 #define LONGEST_ARCH sizeof("powerpc:common")
2581 endian_string (endian
)
2582 enum bfd_endian endian
;
2584 if (endian
== BFD_ENDIAN_BIG
)
2585 return "big endian";
2586 else if (endian
== BFD_ENDIAN_LITTLE
)
2587 return "little endian";
2589 return "endianness unknown";
2592 /* List the targets that BFD is configured to support, each followed
2593 by its endianness and the architectures it supports. */
2596 display_target_list ()
2598 extern const bfd_target
*const *bfd_target_vector
;
2602 dummy_name
= make_temp_file (NULL
);
2603 for (t
= 0; bfd_target_vector
[t
]; t
++)
2605 const bfd_target
*p
= bfd_target_vector
[t
];
2606 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2609 printf ("%s\n (header %s, data %s)\n", p
->name
,
2610 endian_string (p
->header_byteorder
),
2611 endian_string (p
->byteorder
));
2615 nonfatal (dummy_name
);
2619 if (! bfd_set_format (abfd
, bfd_object
))
2621 if (bfd_get_error () != bfd_error_invalid_operation
)
2623 bfd_close_all_done (abfd
);
2627 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2628 if (bfd_set_arch_mach (abfd
, (enum bfd_architecture
) a
, 0))
2630 bfd_printable_arch_mach ((enum bfd_architecture
) a
, 0));
2631 bfd_close_all_done (abfd
);
2633 unlink (dummy_name
);
2637 /* Print a table showing which architectures are supported for entries
2638 FIRST through LAST-1 of bfd_target_vector (targets across,
2639 architectures down). */
2642 display_info_table (first
, last
)
2646 extern const bfd_target
*const *bfd_target_vector
;
2650 /* Print heading of target names. */
2651 printf ("\n%*s", (int) LONGEST_ARCH
, " ");
2652 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2653 printf ("%s ", bfd_target_vector
[t
]->name
);
2656 dummy_name
= make_temp_file (NULL
);
2657 for (a
= (int) bfd_arch_obscure
+ 1; a
< (int) bfd_arch_last
; a
++)
2658 if (strcmp (bfd_printable_arch_mach (a
, 0), "UNKNOWN!") != 0)
2660 printf ("%*s ", (int) LONGEST_ARCH
- 1,
2661 bfd_printable_arch_mach (a
, 0));
2662 for (t
= first
; t
< last
&& bfd_target_vector
[t
]; t
++)
2664 const bfd_target
*p
= bfd_target_vector
[t
];
2665 bfd_boolean ok
= TRUE
;
2666 bfd
*abfd
= bfd_openw (dummy_name
, p
->name
);
2676 if (! bfd_set_format (abfd
, bfd_object
))
2678 if (bfd_get_error () != bfd_error_invalid_operation
)
2686 if (! bfd_set_arch_mach (abfd
, a
, 0))
2691 printf ("%s ", p
->name
);
2694 int l
= strlen (p
->name
);
2700 bfd_close_all_done (abfd
);
2704 unlink (dummy_name
);
2708 /* Print tables of all the target-architecture combinations that
2709 BFD has been configured to support. */
2712 display_target_tables ()
2715 extern const bfd_target
*const *bfd_target_vector
;
2719 colum
= getenv ("COLUMNS");
2721 columns
= atoi (colum
);
2726 while (bfd_target_vector
[t
] != NULL
)
2730 wid
= LONGEST_ARCH
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2732 while (wid
< columns
&& bfd_target_vector
[t
] != NULL
)
2736 newwid
= wid
+ strlen (bfd_target_vector
[t
]->name
) + 1;
2737 if (newwid
>= columns
)
2742 display_info_table (oldt
, t
);
2749 printf (_("BFD header file version %s\n"), BFD_VERSION_STRING
);
2750 display_target_list ();
2751 display_target_tables ();
2754 int main
PARAMS ((int, char **));
2762 char *target
= default_target
;
2763 bfd_boolean seenflag
= FALSE
;
2765 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
2766 setlocale (LC_MESSAGES
, "");
2768 #if defined (HAVE_SETLOCALE)
2769 setlocale (LC_CTYPE
, "");
2771 bindtextdomain (PACKAGE
, LOCALEDIR
);
2772 textdomain (PACKAGE
);
2774 program_name
= *argv
;
2775 xmalloc_set_program_name (program_name
);
2777 START_PROGRESS (program_name
, 0);
2780 set_default_bfd_target ();
2782 while ((c
= getopt_long (argc
, argv
, "pib:m:M:VvCdDlfaHhrRtTxsSj:wE:zgG",
2783 long_options
, (int *) 0))
2789 break; /* We've been given a long option. */
2794 disassembler_options
= optarg
;
2800 with_line_numbers
= TRUE
;
2809 enum demangling_styles style
;
2811 style
= cplus_demangle_name_to_style (optarg
);
2812 if (style
== unknown_demangling
)
2813 fatal (_("unknown demangling style `%s'"),
2816 cplus_demangle_set_style (style
);
2822 case OPTION_ADJUST_VMA
:
2823 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
2825 case OPTION_START_ADDRESS
:
2826 start_address
= parse_vma (optarg
, "--start-address");
2828 case OPTION_STOP_ADDRESS
:
2829 stop_address
= parse_vma (optarg
, "--stop-address");
2832 if (strcmp (optarg
, "B") == 0)
2833 endian
= BFD_ENDIAN_BIG
;
2834 else if (strcmp (optarg
, "L") == 0)
2835 endian
= BFD_ENDIAN_LITTLE
;
2838 non_fatal (_("unrecognized -E option"));
2843 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
2844 endian
= BFD_ENDIAN_BIG
;
2845 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
2846 endian
= BFD_ENDIAN_LITTLE
;
2849 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
2855 dump_file_header
= TRUE
;
2859 formats_info
= TRUE
;
2863 dump_private_headers
= TRUE
;
2867 dump_private_headers
= TRUE
;
2869 dump_reloc_info
= TRUE
;
2870 dump_file_header
= TRUE
;
2871 dump_ar_hdrs
= TRUE
;
2872 dump_section_headers
= TRUE
;
2880 dump_dynamic_symtab
= TRUE
;
2888 disassemble_zeroes
= TRUE
;
2892 disassemble_all
= TRUE
;
2897 with_source_code
= TRUE
;
2905 dump_stab_section_info
= TRUE
;
2909 dump_section_contents
= TRUE
;
2913 dump_reloc_info
= TRUE
;
2917 dump_dynamic_reloc_info
= TRUE
;
2921 dump_ar_hdrs
= TRUE
;
2925 dump_section_headers
= TRUE
;
2933 show_version
= TRUE
;
2943 print_version ("objdump");
2953 display_file ("a.out", target
);
2955 for (; optind
< argc
;)
2956 display_file (argv
[optind
++], target
);
2959 END_PROGRESS (program_name
);