1 /* objdump.c -- dump information about an object file.
2 Copyright (C) 1990-2019 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
24 Objdump displays information about one or more object files, either on
25 their own, or inside libraries. It is commonly used as a disassembler,
26 but it can also display information about file headers, symbol tables,
27 relocations, debugging directives and more.
29 The flow of execution is as follows:
31 1. Command line arguments are checked for control switches and the
32 information to be displayed is selected.
34 2. Any remaining arguments are assumed to be object files, and they are
35 processed in order by display_bfd(). If the file is an archive each
36 of its elements is processed in turn.
38 3. The file's target architecture and binary file format are determined
39 by bfd_check_format(). If they are recognised, then dump_bfd() is
42 4. dump_bfd() in turn calls separate functions to display the requested
43 item(s) of information(s). For example disassemble_data() is called if
44 a disassembly has been requested.
46 When disassembling the code loops through blocks of instructions bounded
47 by symbols, calling disassemble_bytes() on each block. The actual
48 disassembling is done by the libopcodes library, via a function pointer
49 supplied by the disassembler() function. */
61 #include "safe-ctype.h"
63 #include "libiberty.h"
65 #include "filenames.h"
74 /* Internal headers for the ELF .stab-dump code - sorry. */
75 #define BYTES_IN_WORD 32
76 #include "aout/aout64.h"
79 static int exit_status
= 0;
81 static char *default_target
= NULL
; /* Default at runtime. */
83 /* The following variables are set based on arguments passed on the
85 static int show_version
= 0; /* Show the version number. */
86 static int dump_section_contents
; /* -s */
87 static int dump_section_headers
; /* -h */
88 static bfd_boolean dump_file_header
; /* -f */
89 static int dump_symtab
; /* -t */
90 static int dump_dynamic_symtab
; /* -T */
91 static int dump_reloc_info
; /* -r */
92 static int dump_dynamic_reloc_info
; /* -R */
93 static int dump_ar_hdrs
; /* -a */
94 static int dump_private_headers
; /* -p */
95 static char *dump_private_options
; /* -P */
96 static int prefix_addresses
; /* --prefix-addresses */
97 static int with_line_numbers
; /* -l */
98 static bfd_boolean with_source_code
; /* -S */
99 static int show_raw_insn
; /* --show-raw-insn */
100 static int dump_dwarf_section_info
; /* --dwarf */
101 static int dump_stab_section_info
; /* --stabs */
102 static int dump_ctf_section_info
; /* --ctf */
103 static char *dump_ctf_section_name
;
104 static char *dump_ctf_parent_name
; /* --ctf-parent */
105 static int do_demangle
; /* -C, --demangle */
106 static bfd_boolean disassemble
; /* -d */
107 static bfd_boolean disassemble_all
; /* -D */
108 static int disassemble_zeroes
; /* --disassemble-zeroes */
109 static bfd_boolean formats_info
; /* -i */
110 static int wide_output
; /* -w */
111 static int insn_width
; /* --insn-width */
112 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
113 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
114 static int dump_debugging
; /* --debugging */
115 static int dump_debugging_tags
; /* --debugging-tags */
116 static int suppress_bfd_header
;
117 static int dump_special_syms
= 0; /* --special-syms */
118 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
119 static int file_start_context
= 0; /* --file-start-context */
120 static bfd_boolean display_file_offsets
;/* -F */
121 static const char *prefix
; /* --prefix */
122 static int prefix_strip
; /* --prefix-strip */
123 static size_t prefix_length
;
124 static bfd_boolean unwind_inlines
; /* --inlines. */
125 static const char * disasm_sym
; /* Disassembly start symbol. */
126 static const char * source_comment
; /* --source_comment. */
128 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
130 /* A structure to record the sections mentioned in -j switches. */
133 const char * name
; /* The name of the section. */
134 bfd_boolean seen
; /* A flag to indicate that the section has been found in one or more input files. */
135 struct only
* next
; /* Pointer to the next structure in the list. */
137 /* Pointer to an array of 'only' structures.
138 This pointer is NULL if the -j switch has not been used. */
139 static struct only
* only_list
= NULL
;
141 /* Variables for handling include file path table. */
142 static const char **include_paths
;
143 static int include_path_count
;
145 /* Extra info to pass to the section disassembler and address printing
147 struct objdump_disasm_info
151 bfd_boolean require_sec
;
152 arelent
** dynrelbuf
;
154 disassembler_ftype disassemble_fn
;
159 /* Architecture to disassemble for, or default if NULL. */
160 static char *machine
= NULL
;
162 /* Target specific options to the disassembler. */
163 static char *disassembler_options
= NULL
;
165 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
166 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
168 /* The symbol table. */
169 static asymbol
**syms
;
171 /* Number of symbols in `syms'. */
172 static long symcount
= 0;
174 /* The sorted symbol table. */
175 static asymbol
**sorted_syms
;
177 /* Number of symbols in `sorted_syms'. */
178 static long sorted_symcount
= 0;
180 /* The dynamic symbol table. */
181 static asymbol
**dynsyms
;
183 /* The synthetic symbol table. */
184 static asymbol
*synthsyms
;
185 static long synthcount
= 0;
187 /* Number of symbols in `dynsyms'. */
188 static long dynsymcount
= 0;
190 static bfd_byte
*stabs
;
191 static bfd_size_type stab_size
;
193 static bfd_byte
*strtab
;
194 static bfd_size_type stabstr_size
;
196 /* Handlers for -P/--private. */
197 static const struct objdump_private_desc
* const objdump_private_vectors
[] =
199 OBJDUMP_PRIVATE_VECTORS
203 static void usage (FILE *, int) ATTRIBUTE_NORETURN
;
205 usage (FILE *stream
, int status
)
207 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
208 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
209 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
210 fprintf (stream
, _("\
211 -a, --archive-headers Display archive header information\n\
212 -f, --file-headers Display the contents of the overall file header\n\
213 -p, --private-headers Display object format specific file header contents\n\
214 -P, --private=OPT,OPT... Display object format specific contents\n\
215 -h, --[section-]headers Display the contents of the section headers\n\
216 -x, --all-headers Display the contents of all headers\n\
217 -d, --disassemble Display assembler contents of executable sections\n\
218 -D, --disassemble-all Display assembler contents of all sections\n\
219 --disassemble=<sym> Display assembler contents from <sym>\n\
220 -S, --source Intermix source code with disassembly\n\
221 --source-comment[=<txt>] Prefix lines of source code with <txt>\n\
222 -s, --full-contents Display the full contents of all sections requested\n\
223 -g, --debugging Display debug information in object file\n\
224 -e, --debugging-tags Display debug information using ctags style\n\
225 -G, --stabs Display (in raw form) any STABS info in the file\n\
226 -W[lLiaprmfFsoRtUuTgAckK] or\n\
227 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
228 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
229 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
230 =addr,=cu_index,=links,=follow-links]\n\
231 Display DWARF info in the file\n\
232 --ctf=SECTION Display CTF info from SECTION\n\
233 -t, --syms Display the contents of the symbol table(s)\n\
234 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
235 -r, --reloc Display the relocation entries in the file\n\
236 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
237 @<file> Read options from <file>\n\
238 -v, --version Display this program's version number\n\
239 -i, --info List object formats and architectures supported\n\
240 -H, --help Display this information\n\
244 const struct objdump_private_desc
* const *desc
;
246 fprintf (stream
, _("\n The following switches are optional:\n"));
247 fprintf (stream
, _("\
248 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
249 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
250 -j, --section=NAME Only display information for section NAME\n\
251 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
252 -EB --endian=big Assume big endian format when disassembling\n\
253 -EL --endian=little Assume little endian format when disassembling\n\
254 --file-start-context Include context from start of file (with -S)\n\
255 -I, --include=DIR Add DIR to search list for source files\n\
256 -l, --line-numbers Include line numbers and filenames in output\n\
257 -F, --file-offsets Include file offsets when displaying information\n\
258 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
259 The STYLE, if specified, can be `auto', `gnu',\n\
260 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
262 --recurse-limit Enable a limit on recursion whilst demangling. [Default]\n\
263 --no-recurse-limit Disable a limit on recursion whilst demangling\n\
264 -w, --wide Format output for more than 80 columns\n\
265 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
266 --start-address=ADDR Only process data whose address is >= ADDR\n\
267 --stop-address=ADDR Only process data whose address is <= ADDR\n\
268 --prefix-addresses Print complete address alongside disassembly\n\
269 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
270 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
271 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
272 --special-syms Include special symbols in symbol dumps\n\
273 --inlines Print all inlines for source line (with -l)\n\
274 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
275 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
276 fprintf (stream
, _("\
277 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
278 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
280 --dwarf-check Make additional dwarf internal consistency checks.\
282 --ctf-parent=SECTION Use SECTION as the CTF parent\n\n"));
283 list_supported_targets (program_name
, stream
);
284 list_supported_architectures (program_name
, stream
);
286 disassembler_usage (stream
);
288 if (objdump_private_vectors
[0] != NULL
)
291 _("\nOptions supported for -P/--private switch:\n"));
292 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
293 (*desc
)->help (stream
);
296 if (REPORT_BUGS_TO
[0] && status
== 0)
297 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
301 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
305 OPTION_START_ADDRESS
,
315 OPTION_RECURSE_LIMIT
,
316 OPTION_NO_RECURSE_LIMIT
,
318 OPTION_SOURCE_COMMENT
,
323 static struct option long_options
[]=
325 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
326 {"all-headers", no_argument
, NULL
, 'x'},
327 {"private-headers", no_argument
, NULL
, 'p'},
328 {"private", required_argument
, NULL
, 'P'},
329 {"architecture", required_argument
, NULL
, 'm'},
330 {"archive-headers", no_argument
, NULL
, 'a'},
331 {"debugging", no_argument
, NULL
, 'g'},
332 {"debugging-tags", no_argument
, NULL
, 'e'},
333 {"demangle", optional_argument
, NULL
, 'C'},
334 {"disassemble", optional_argument
, NULL
, 'd'},
335 {"disassemble-all", no_argument
, NULL
, 'D'},
336 {"disassembler-options", required_argument
, NULL
, 'M'},
337 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
338 {"dynamic-reloc", no_argument
, NULL
, 'R'},
339 {"dynamic-syms", no_argument
, NULL
, 'T'},
340 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
341 {"file-headers", no_argument
, NULL
, 'f'},
342 {"file-offsets", no_argument
, NULL
, 'F'},
343 {"file-start-context", no_argument
, &file_start_context
, 1},
344 {"full-contents", no_argument
, NULL
, 's'},
345 {"headers", no_argument
, NULL
, 'h'},
346 {"help", no_argument
, NULL
, 'H'},
347 {"info", no_argument
, NULL
, 'i'},
348 {"line-numbers", no_argument
, NULL
, 'l'},
349 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
350 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
351 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
352 {"recursion-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
353 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
354 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
355 {"reloc", no_argument
, NULL
, 'r'},
356 {"section", required_argument
, NULL
, 'j'},
357 {"section-headers", no_argument
, NULL
, 'h'},
358 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
359 {"source", no_argument
, NULL
, 'S'},
360 {"source-comment", optional_argument
, NULL
, OPTION_SOURCE_COMMENT
},
361 {"special-syms", no_argument
, &dump_special_syms
, 1},
362 {"include", required_argument
, NULL
, 'I'},
363 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
364 {"ctf", required_argument
, NULL
, OPTION_CTF
},
365 {"ctf-parent", required_argument
, NULL
, OPTION_CTF_PARENT
},
366 {"stabs", no_argument
, NULL
, 'G'},
367 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
368 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
369 {"syms", no_argument
, NULL
, 't'},
370 {"target", required_argument
, NULL
, 'b'},
371 {"version", no_argument
, NULL
, 'V'},
372 {"wide", no_argument
, NULL
, 'w'},
373 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
374 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
375 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
376 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
377 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
378 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
379 {"inlines", no_argument
, 0, OPTION_INLINES
},
380 {0, no_argument
, 0, 0}
384 nonfatal (const char *msg
)
390 /* Returns a version of IN with any control characters
391 replaced by escape sequences. Uses a static buffer
395 sanitize_string (const char * in
)
397 static char * buffer
= NULL
;
398 static size_t buffer_len
= 0;
399 const char * original
= in
;
406 /* See if any conversion is necessary. In the majority
407 of cases it will not be needed. */
420 /* Copy the input, translating as needed. */
422 if (buffer_len
< (strlen (in
) * 2))
424 free ((void *) buffer
);
425 buffer_len
= strlen (in
) * 2;
426 buffer
= xmalloc (buffer_len
+ 1);
452 /* Returns TRUE if the specified section should be dumped. */
455 process_section_p (asection
* section
)
459 if (only_list
== NULL
)
462 for (only
= only_list
; only
; only
= only
->next
)
463 if (strcmp (only
->name
, section
->name
) == 0)
472 /* Add an entry to the 'only' list. */
475 add_only (char * name
)
479 /* First check to make sure that we do not
480 already have an entry for this name. */
481 for (only
= only_list
; only
; only
= only
->next
)
482 if (strcmp (only
->name
, name
) == 0)
485 only
= xmalloc (sizeof * only
);
488 only
->next
= only_list
;
492 /* Release the memory used by the 'only' list.
493 PR 11225: Issue a warning message for unseen sections.
494 Only do this if none of the sections were seen. This is mainly to support
495 tools like the GAS testsuite where an object file is dumped with a list of
496 generic section names known to be present in a range of different file
500 free_only_list (void)
502 bfd_boolean at_least_one_seen
= FALSE
;
506 if (only_list
== NULL
)
509 for (only
= only_list
; only
; only
= only
->next
)
512 at_least_one_seen
= TRUE
;
516 for (only
= only_list
; only
; only
= next
)
518 if (! at_least_one_seen
)
520 non_fatal (_("section '%s' mentioned in a -j option, "
521 "but not found in any input file"),
532 dump_section_header (bfd
*abfd
, asection
*section
, void *data
)
535 unsigned int opb
= bfd_octets_per_byte (abfd
);
536 int longest_section_name
= *((int *) data
);
538 /* Ignore linker created section. See elfNN_ia64_object_p in
540 if (section
->flags
& SEC_LINKER_CREATED
)
543 /* PR 10413: Skip sections that we are ignoring. */
544 if (! process_section_p (section
))
547 printf ("%3d %-*s %08lx ", section
->index
, longest_section_name
,
548 sanitize_string (bfd_get_section_name (abfd
, section
)),
549 (unsigned long) bfd_section_size (abfd
, section
) / opb
);
550 bfd_printf_vma (abfd
, bfd_get_section_vma (abfd
, section
));
552 bfd_printf_vma (abfd
, section
->lma
);
553 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
554 bfd_get_section_alignment (abfd
, section
));
560 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
562 PF (SEC_HAS_CONTENTS
, "CONTENTS");
563 PF (SEC_ALLOC
, "ALLOC");
564 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
565 PF (SEC_LOAD
, "LOAD");
566 PF (SEC_RELOC
, "RELOC");
567 PF (SEC_READONLY
, "READONLY");
568 PF (SEC_CODE
, "CODE");
569 PF (SEC_DATA
, "DATA");
571 PF (SEC_DEBUGGING
, "DEBUGGING");
572 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
573 PF (SEC_EXCLUDE
, "EXCLUDE");
574 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
575 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
577 PF (SEC_TIC54X_BLOCK
, "BLOCK");
578 PF (SEC_TIC54X_CLINK
, "CLINK");
580 PF (SEC_SMALL_DATA
, "SMALL_DATA");
581 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
583 PF (SEC_COFF_SHARED
, "SHARED");
584 PF (SEC_COFF_NOREAD
, "NOREAD");
586 else if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
587 PF (SEC_ELF_PURECODE
, "PURECODE");
588 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
589 PF (SEC_GROUP
, "GROUP");
590 if (bfd_get_arch (abfd
) == bfd_arch_mep
)
592 PF (SEC_MEP_VLIW
, "VLIW");
595 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
598 struct coff_comdat_info
*comdat
;
600 switch (section
->flags
& SEC_LINK_DUPLICATES
)
604 case SEC_LINK_DUPLICATES_DISCARD
:
605 ls
= "LINK_ONCE_DISCARD";
607 case SEC_LINK_DUPLICATES_ONE_ONLY
:
608 ls
= "LINK_ONCE_ONE_ONLY";
610 case SEC_LINK_DUPLICATES_SAME_SIZE
:
611 ls
= "LINK_ONCE_SAME_SIZE";
613 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
614 ls
= "LINK_ONCE_SAME_CONTENTS";
617 printf ("%s%s", comma
, ls
);
619 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
621 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
630 /* Called on each SECTION in ABFD, update the int variable pointed to by
631 DATA which contains the string length of the longest section name. */
634 find_longest_section_name (bfd
*abfd
, asection
*section
, void *data
)
636 int *longest_so_far
= (int *) data
;
640 /* Ignore linker created section. */
641 if (section
->flags
& SEC_LINKER_CREATED
)
644 /* Skip sections that we are ignoring. */
645 if (! process_section_p (section
))
648 name
= bfd_get_section_name (abfd
, section
);
649 len
= (int) strlen (name
);
650 if (len
> *longest_so_far
)
651 *longest_so_far
= len
;
655 dump_headers (bfd
*abfd
)
657 /* The default width of 13 is just an arbitrary choice. */
658 int max_section_name_length
= 13;
664 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
665 if (bfd_get_arch_size (abfd
) == 32)
671 printf (_("Sections:\n"));
674 bfd_map_over_sections (abfd
, find_longest_section_name
,
675 &max_section_name_length
);
677 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
678 max_section_name_length
, "Name",
679 bfd_vma_width
, "VMA",
680 bfd_vma_width
, "LMA");
683 printf (_(" Flags"));
686 bfd_map_over_sections (abfd
, dump_section_header
,
687 &max_section_name_length
);
691 slurp_symtab (bfd
*abfd
)
696 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
702 storage
= bfd_get_symtab_upper_bound (abfd
);
705 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
706 bfd_fatal (_("error message was"));
710 off_t filesize
= bfd_get_file_size (abfd
);
714 && filesize
< storage
715 /* The MMO file format supports its own special compression
716 technique, so its sections can be larger than the file size. */
717 && bfd_get_flavour (abfd
) != bfd_target_mmo_flavour
)
719 bfd_nonfatal_message (bfd_get_filename (abfd
), abfd
, NULL
,
720 _("error: symbol table size (%#lx) is larger than filesize (%#lx)"),
721 storage
, (long) filesize
);
727 sy
= (asymbol
**) xmalloc (storage
);
730 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
732 bfd_fatal (bfd_get_filename (abfd
));
736 /* Read in the dynamic symbols. */
739 slurp_dynamic_symtab (bfd
*abfd
)
744 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
747 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
749 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
755 bfd_fatal (bfd_get_filename (abfd
));
758 sy
= (asymbol
**) xmalloc (storage
);
760 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
762 bfd_fatal (bfd_get_filename (abfd
));
766 /* Some symbol names are significant and should be kept in the
767 table of sorted symbol names, even if they are marked as
768 debugging/section symbols. */
771 is_significant_symbol_name (const char * name
)
773 return strncmp (name
, ".plt", 4) == 0 || strcmp (name
, ".got") == 0;
776 /* Filter out (in place) symbols that are useless for disassembly.
777 COUNT is the number of elements in SYMBOLS.
778 Return the number of useful symbols. */
781 remove_useless_symbols (asymbol
**symbols
, long count
)
783 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
787 asymbol
*sym
= *in_ptr
++;
789 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
791 if ((sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
792 && ! is_significant_symbol_name (sym
->name
))
794 if (bfd_is_und_section (sym
->section
)
795 || bfd_is_com_section (sym
->section
))
800 return out_ptr
- symbols
;
803 /* Sort symbols into value order. */
806 compare_symbols (const void *ap
, const void *bp
)
808 const asymbol
*a
= * (const asymbol
**) ap
;
809 const asymbol
*b
= * (const asymbol
**) bp
;
819 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
821 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
824 if (a
->section
> b
->section
)
826 else if (a
->section
< b
->section
)
829 an
= bfd_asymbol_name (a
);
830 bn
= bfd_asymbol_name (b
);
834 /* The symbols gnu_compiled and gcc2_compiled convey no real
835 information, so put them after other symbols with the same value. */
836 af
= (strstr (an
, "gnu_compiled") != NULL
837 || strstr (an
, "gcc2_compiled") != NULL
);
838 bf
= (strstr (bn
, "gnu_compiled") != NULL
839 || strstr (bn
, "gcc2_compiled") != NULL
);
846 /* We use a heuristic for the file name, to try to sort it after
847 more useful symbols. It may not work on non Unix systems, but it
848 doesn't really matter; the only difference is precisely which
849 symbol names get printed. */
851 #define file_symbol(s, sn, snl) \
852 (((s)->flags & BSF_FILE) != 0 \
853 || ((sn)[(snl) - 2] == '.' \
854 && ((sn)[(snl) - 1] == 'o' \
855 || (sn)[(snl) - 1] == 'a')))
857 af
= file_symbol (a
, an
, anl
);
858 bf
= file_symbol (b
, bn
, bnl
);
865 /* Try to sort global symbols before local symbols before function
866 symbols before debugging symbols. */
871 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
873 if ((aflags
& BSF_DEBUGGING
) != 0)
878 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
880 if ((aflags
& BSF_FUNCTION
) != 0)
885 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
887 if ((aflags
& BSF_LOCAL
) != 0)
892 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
894 if ((aflags
& BSF_GLOBAL
) != 0)
900 if (bfd_get_flavour (bfd_asymbol_bfd (a
)) == bfd_target_elf_flavour
901 && bfd_get_flavour (bfd_asymbol_bfd (b
)) == bfd_target_elf_flavour
)
906 if ((a
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
907 asz
= ((elf_symbol_type
*) a
)->internal_elf_sym
.st_size
;
909 if ((b
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
910 bsz
= ((elf_symbol_type
*) b
)->internal_elf_sym
.st_size
;
912 return asz
> bsz
? -1 : 1;
915 /* Symbols that start with '.' might be section names, so sort them
916 after symbols that don't start with '.'. */
917 if (an
[0] == '.' && bn
[0] != '.')
919 if (an
[0] != '.' && bn
[0] == '.')
922 /* Finally, if we can't distinguish them in any other way, try to
923 get consistent results by sorting the symbols by name. */
924 return strcmp (an
, bn
);
927 /* Sort relocs into address order. */
930 compare_relocs (const void *ap
, const void *bp
)
932 const arelent
*a
= * (const arelent
**) ap
;
933 const arelent
*b
= * (const arelent
**) bp
;
935 if (a
->address
> b
->address
)
937 else if (a
->address
< b
->address
)
940 /* So that associated relocations tied to the same address show up
941 in the correct order, we don't do any further sorting. */
950 /* Print an address (VMA) to the output stream in INFO.
951 If SKIP_ZEROES is TRUE, omit leading zeroes. */
954 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
955 bfd_boolean skip_zeroes
)
959 struct objdump_disasm_info
*aux
;
961 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
962 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
967 for (p
= buf
; *p
== '0'; ++p
)
972 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
975 /* Print the name of a symbol. */
978 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
982 const char *name
, *version_string
= NULL
;
983 bfd_boolean hidden
= FALSE
;
986 name
= bfd_asymbol_name (sym
);
987 if (do_demangle
&& name
[0] != '\0')
989 /* Demangle the name. */
990 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
995 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
996 version_string
= bfd_get_symbol_version_string (abfd
, sym
, &hidden
);
998 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1001 name
= sanitize_string (name
);
1005 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
1006 if (version_string
&& *version_string
!= '\0')
1007 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
1012 printf ("%s", name
);
1013 if (version_string
&& *version_string
!= '\0')
1014 printf (hidden
? "@%s" : "@@%s", version_string
);
1021 static inline bfd_boolean
1022 sym_ok (bfd_boolean want_section
,
1023 bfd
* abfd ATTRIBUTE_UNUSED
,
1026 struct disassemble_info
* inf
)
1030 /* Note - we cannot just compare section pointers because they could
1031 be different, but the same... Ie the symbol that we are trying to
1032 find could have come from a separate debug info file. Under such
1033 circumstances the symbol will be associated with a section in the
1034 debug info file, whilst the section we want is in a normal file.
1035 So the section pointers will be different, but the section names
1036 will be the same. */
1037 if (strcmp (bfd_section_name (abfd
, sorted_syms
[place
]->section
),
1038 bfd_section_name (abfd
, sec
)) != 0)
1042 return inf
->symbol_is_valid (sorted_syms
[place
], inf
);
1045 /* Locate a symbol given a bfd and a section (from INFO->application_data),
1046 and a VMA. If INFO->application_data->require_sec is TRUE, then always
1047 require the symbol to be in the section. Returns NULL if there is no
1048 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
1049 of the symbol in sorted_syms. */
1052 find_symbol_for_address (bfd_vma vma
,
1053 struct disassemble_info
*inf
,
1056 /* @@ Would it speed things up to cache the last two symbols returned,
1057 and maybe their address ranges? For many processors, only one memory
1058 operand can be present at a time, so the 2-entry cache wouldn't be
1059 constantly churned by code doing heavy memory accesses. */
1061 /* Indices in `sorted_syms'. */
1063 long max_count
= sorted_symcount
;
1065 struct objdump_disasm_info
*aux
;
1069 bfd_boolean want_section
;
1072 if (sorted_symcount
< 1)
1075 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1078 opb
= inf
->octets_per_byte
;
1080 /* Perform a binary search looking for the closest symbol to the
1081 required value. We are searching the range (min, max_count]. */
1082 while (min
+ 1 < max_count
)
1086 thisplace
= (max_count
+ min
) / 2;
1087 sym
= sorted_syms
[thisplace
];
1089 if (bfd_asymbol_value (sym
) > vma
)
1090 max_count
= thisplace
;
1091 else if (bfd_asymbol_value (sym
) < vma
)
1100 /* The symbol we want is now in min, the low end of the range we
1101 were searching. If there are several symbols with the same
1102 value, we want the first (non-section/non-debugging) one. */
1104 while (thisplace
> 0
1105 && (bfd_asymbol_value (sorted_syms
[thisplace
])
1106 == bfd_asymbol_value (sorted_syms
[thisplace
- 1]))
1107 && ((sorted_syms
[thisplace
- 1]->flags
1108 & (BSF_SECTION_SYM
| BSF_DEBUGGING
)) == 0)
1112 /* Prefer a symbol in the current section if we have multple symbols
1113 with the same value, as can occur with overlays or zero size
1116 while (min
< max_count
1117 && (bfd_asymbol_value (sorted_syms
[min
])
1118 == bfd_asymbol_value (sorted_syms
[thisplace
])))
1120 if (sym_ok (TRUE
, abfd
, min
, sec
, inf
))
1127 return sorted_syms
[thisplace
];
1132 /* If the file is relocatable, and the symbol could be from this
1133 section, prefer a symbol from this section over symbols from
1134 others, even if the other symbol's value might be closer.
1136 Note that this may be wrong for some symbol references if the
1137 sections have overlapping memory ranges, but in that case there's
1138 no way to tell what's desired without looking at the relocation
1141 Also give the target a chance to reject symbols. */
1142 want_section
= (aux
->require_sec
1143 || ((abfd
->flags
& HAS_RELOC
) != 0
1144 && vma
>= bfd_get_section_vma (abfd
, sec
)
1145 && vma
< (bfd_get_section_vma (abfd
, sec
)
1146 + bfd_section_size (abfd
, sec
) / opb
)));
1148 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1151 long newplace
= sorted_symcount
;
1153 for (i
= min
- 1; i
>= 0; i
--)
1155 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1157 if (newplace
== sorted_symcount
)
1160 if (bfd_asymbol_value (sorted_syms
[i
])
1161 != bfd_asymbol_value (sorted_syms
[newplace
]))
1164 /* Remember this symbol and keep searching until we reach
1165 an earlier address. */
1170 if (newplace
!= sorted_symcount
)
1171 thisplace
= newplace
;
1174 /* We didn't find a good symbol with a smaller value.
1175 Look for one with a larger value. */
1176 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1178 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1186 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1187 /* There is no suitable symbol. */
1191 /* If we have not found an exact match for the specified address
1192 and we have dynamic relocations available, then we can produce
1193 a better result by matching a relocation to the address and
1194 using the symbol associated with that relocation. */
1195 rel_count
= aux
->dynrelcount
;
1197 && sorted_syms
[thisplace
]->value
!= vma
1199 && aux
->dynrelbuf
!= NULL
1200 && aux
->dynrelbuf
[0]->address
<= vma
1201 && aux
->dynrelbuf
[rel_count
- 1]->address
>= vma
1202 /* If we have matched a synthetic symbol, then stick with that. */
1203 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1206 arelent
** rel_high
;
1208 rel_low
= aux
->dynrelbuf
;
1209 rel_high
= rel_low
+ rel_count
- 1;
1210 while (rel_low
<= rel_high
)
1212 arelent
**rel_mid
= &rel_low
[(rel_high
- rel_low
) / 2];
1213 arelent
* rel
= *rel_mid
;
1215 if (rel
->address
== vma
)
1217 /* Absolute relocations do not provide a more helpful
1218 symbolic address. Find a non-absolute relocation
1219 with the same address. */
1220 arelent
**rel_vma
= rel_mid
;
1222 rel_mid
>= rel_low
&& rel_mid
[0]->address
== vma
;
1226 for (; rel_vma
<= rel_high
&& rel_vma
[0]->address
== vma
;
1230 if (rel
->sym_ptr_ptr
!= NULL
1231 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1234 * place
= thisplace
;
1235 return * rel
->sym_ptr_ptr
;
1241 if (vma
< rel
->address
)
1243 else if (vma
>= rel_mid
[1]->address
)
1244 rel_low
= rel_mid
+ 1;
1253 return sorted_syms
[thisplace
];
1256 /* Print an address and the offset to the nearest symbol. */
1259 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1260 bfd_vma vma
, struct disassemble_info
*inf
,
1261 bfd_boolean skip_zeroes
)
1263 objdump_print_value (vma
, inf
, skip_zeroes
);
1269 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
1270 sanitize_string (bfd_get_section_name (abfd
, sec
)));
1271 secaddr
= bfd_get_section_vma (abfd
, sec
);
1274 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1275 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
1277 else if (vma
> secaddr
)
1279 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1280 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
1282 (*inf
->fprintf_func
) (inf
->stream
, ">");
1286 (*inf
->fprintf_func
) (inf
->stream
, " <");
1288 objdump_print_symname (abfd
, inf
, sym
);
1290 if (bfd_asymbol_value (sym
) == vma
)
1292 /* Undefined symbols in an executables and dynamic objects do not have
1293 a value associated with them, so it does not make sense to display
1294 an offset relative to them. Normally we would not be provided with
1295 this kind of symbol, but the target backend might choose to do so,
1296 and the code in find_symbol_for_address might return an as yet
1297 unresolved symbol associated with a dynamic reloc. */
1298 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1299 && bfd_is_und_section (sym
->section
))
1301 else if (bfd_asymbol_value (sym
) > vma
)
1303 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1304 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1306 else if (vma
> bfd_asymbol_value (sym
))
1308 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1309 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1312 (*inf
->fprintf_func
) (inf
->stream
, ">");
1315 if (display_file_offsets
)
1316 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1317 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1320 /* Print an address (VMA), symbolically if possible.
1321 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1324 objdump_print_addr (bfd_vma vma
,
1325 struct disassemble_info
*inf
,
1326 bfd_boolean skip_zeroes
)
1328 struct objdump_disasm_info
*aux
;
1329 asymbol
*sym
= NULL
;
1330 bfd_boolean skip_find
= FALSE
;
1332 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1334 if (sorted_symcount
< 1)
1336 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1337 objdump_print_value (vma
, inf
, skip_zeroes
);
1339 if (display_file_offsets
)
1340 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1341 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
1345 if (aux
->reloc
!= NULL
1346 && aux
->reloc
->sym_ptr_ptr
!= NULL
1347 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1349 sym
= * aux
->reloc
->sym_ptr_ptr
;
1351 /* Adjust the vma to the reloc. */
1352 vma
+= bfd_asymbol_value (sym
);
1354 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1359 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1361 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, inf
,
1365 /* Print VMA to INFO. This function is passed to the disassembler
1369 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1371 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1374 /* Determine if the given address has a symbol associated with it. */
1377 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1381 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1383 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1386 /* Hold the last function name and the last line number we displayed
1387 in a disassembly. */
1389 static char *prev_functionname
;
1390 static unsigned int prev_line
;
1391 static unsigned int prev_discriminator
;
1393 /* We keep a list of all files that we have seen when doing a
1394 disassembly with source, so that we know how much of the file to
1395 display. This can be important for inlined functions. */
1397 struct print_file_list
1399 struct print_file_list
*next
;
1400 const char *filename
;
1401 const char *modname
;
1404 const char **linemap
;
1407 unsigned max_printed
;
1411 static struct print_file_list
*print_files
;
1413 /* The number of preceding context lines to show when we start
1414 displaying a file for the first time. */
1416 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1418 /* Read a complete file into memory. */
1421 slurp_file (const char *fn
, size_t *size
, struct stat
*fst
)
1424 int ps
= getpagesize ();
1428 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1432 if (fstat (fd
, fst
) < 0)
1437 *size
= fst
->st_size
;
1439 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1440 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1441 if (map
!= (char *) -1L)
1447 map
= (const char *) malloc (*size
);
1448 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1450 free ((void *) map
);
1457 #define line_map_decrease 5
1459 /* Precompute array of lines for a mapped file. */
1461 static const char **
1462 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1464 const char *p
, *lstart
, *end
;
1465 int chars_per_line
= 45; /* First iteration will use 40. */
1466 unsigned int lineno
;
1467 const char **linemap
= NULL
;
1468 unsigned long line_map_size
= 0;
1474 for (p
= map
; p
< end
; p
++)
1478 if (p
+ 1 < end
&& p
[1] == '\r')
1481 else if (*p
== '\r')
1483 if (p
+ 1 < end
&& p
[1] == '\n')
1489 /* End of line found. */
1491 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1493 unsigned long newsize
;
1495 chars_per_line
-= line_map_decrease
;
1496 if (chars_per_line
<= 1)
1498 line_map_size
= size
/ chars_per_line
+ 1;
1499 if (line_map_size
< lineno
+ 1)
1500 line_map_size
= lineno
+ 1;
1501 newsize
= line_map_size
* sizeof (char *);
1502 linemap
= (const char **) xrealloc (linemap
, newsize
);
1505 linemap
[lineno
++] = lstart
;
1513 /* Tries to open MODNAME, and if successful adds a node to print_files
1514 linked list and returns that node. Returns NULL on failure. */
1516 static struct print_file_list
*
1517 try_print_file_open (const char *origname
, const char *modname
, struct stat
*fst
)
1519 struct print_file_list
*p
;
1521 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1523 p
->map
= slurp_file (modname
, &p
->mapsize
, fst
);
1530 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1533 p
->filename
= origname
;
1534 p
->modname
= modname
;
1535 p
->next
= print_files
;
1541 /* If the source file, as described in the symtab, is not found
1542 try to locate it in one of the paths specified with -I
1543 If found, add location to print_files linked list. */
1545 static struct print_file_list
*
1546 update_source_path (const char *filename
, bfd
*abfd
)
1548 struct print_file_list
*p
;
1553 p
= try_print_file_open (filename
, filename
, &fst
);
1556 if (include_path_count
== 0)
1559 /* Get the name of the file. */
1560 fname
= lbasename (filename
);
1562 /* If file exists under a new path, we need to add it to the list
1563 so that show_line knows about it. */
1564 for (i
= 0; i
< include_path_count
; i
++)
1566 char *modname
= concat (include_paths
[i
], "/", fname
,
1569 p
= try_print_file_open (filename
, modname
, &fst
);
1579 long mtime
= bfd_get_mtime (abfd
);
1581 if (fst
.st_mtime
> mtime
)
1582 warn (_("source file %s is more recent than object file\n"),
1589 /* Print a source file line. */
1592 print_line (struct print_file_list
*p
, unsigned int linenum
)
1598 if (linenum
>= p
->maxline
)
1600 l
= p
->linemap
[linenum
];
1601 if (source_comment
!= NULL
&& strlen (l
) > 0)
1602 printf ("%s", source_comment
);
1603 len
= strcspn (l
, "\n\r");
1604 /* Test fwrite return value to quiet glibc warning. */
1605 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1609 /* Print a range of source code lines. */
1612 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1616 while (start
<= end
)
1618 print_line (p
, start
);
1623 /* Show the line number, or the source line, in a disassembly
1627 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1629 const char *filename
;
1630 const char *functionname
;
1631 unsigned int linenumber
;
1632 unsigned int discriminator
;
1636 if (! with_line_numbers
&& ! with_source_code
)
1639 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1640 &filename
, &functionname
,
1641 &linenumber
, &discriminator
))
1644 if (filename
!= NULL
&& *filename
== '\0')
1646 if (functionname
!= NULL
&& *functionname
== '\0')
1647 functionname
= NULL
;
1650 && IS_ABSOLUTE_PATH (filename
)
1654 const char *fname
= filename
;
1656 path
= xmalloc (prefix_length
+ PATH_MAX
+ 1);
1659 memcpy (path
, prefix
, prefix_length
);
1660 path_up
= path
+ prefix_length
;
1662 /* Build relocated filename, stripping off leading directories
1663 from the initial filename if requested. */
1664 if (prefix_strip
> 0)
1669 /* Skip selected directory levels. */
1670 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1671 if (IS_DIR_SEPARATOR(*s
))
1678 /* Update complete filename. */
1679 strncpy (path_up
, fname
, PATH_MAX
);
1680 path_up
[PATH_MAX
] = '\0';
1688 if (with_line_numbers
)
1690 if (functionname
!= NULL
1691 && (prev_functionname
== NULL
1692 || strcmp (functionname
, prev_functionname
) != 0))
1694 printf ("%s():\n", sanitize_string (functionname
));
1698 && (linenumber
!= prev_line
1699 || discriminator
!= prev_discriminator
))
1701 if (discriminator
> 0)
1702 printf ("%s:%u (discriminator %u)\n",
1703 filename
== NULL
? "???" : sanitize_string (filename
),
1704 linenumber
, discriminator
);
1706 printf ("%s:%u\n", filename
== NULL
1707 ? "???" : sanitize_string (filename
),
1712 const char *filename2
;
1713 const char *functionname2
;
1716 while (bfd_find_inliner_info (abfd
, &filename2
, &functionname2
,
1719 printf ("inlined by %s:%u",
1720 sanitize_string (filename2
), line2
);
1721 printf (" (%s)\n", sanitize_string (functionname2
));
1726 if (with_source_code
1730 struct print_file_list
**pp
, *p
;
1733 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1734 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1741 filename
= xstrdup (filename
);
1742 p
= update_source_path (filename
, abfd
);
1745 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1747 if (file_start_context
&& p
->first
)
1751 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1752 if (l
>= linenumber
)
1754 if (p
->max_printed
>= l
)
1756 if (p
->max_printed
< linenumber
)
1757 l
= p
->max_printed
+ 1;
1762 dump_lines (p
, l
, linenumber
);
1763 if (p
->max_printed
< linenumber
)
1764 p
->max_printed
= linenumber
;
1765 p
->last_line
= linenumber
;
1770 if (functionname
!= NULL
1771 && (prev_functionname
== NULL
1772 || strcmp (functionname
, prev_functionname
) != 0))
1774 if (prev_functionname
!= NULL
)
1775 free (prev_functionname
);
1776 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1777 strcpy (prev_functionname
, functionname
);
1780 if (linenumber
> 0 && linenumber
!= prev_line
)
1781 prev_line
= linenumber
;
1783 if (discriminator
!= prev_discriminator
)
1784 prev_discriminator
= discriminator
;
1790 /* Pseudo FILE object for strings. */
1798 /* sprintf to a "stream". */
1800 static int ATTRIBUTE_PRINTF_2
1801 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1808 size_t space
= f
->alloc
- f
->pos
;
1810 va_start (args
, format
);
1811 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1817 f
->alloc
= (f
->alloc
+ n
) * 2;
1818 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1825 /* The number of zeroes we want to see before we start skipping them.
1826 The number is arbitrarily chosen. */
1828 #define DEFAULT_SKIP_ZEROES 8
1830 /* The number of zeroes to skip at the end of a section. If the
1831 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1832 SKIP_ZEROES, they will be disassembled. If there are fewer than
1833 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1834 attempt to avoid disassembling zeroes inserted by section
1837 #define DEFAULT_SKIP_ZEROES_AT_END 3
1840 null_print (const void * stream ATTRIBUTE_UNUSED
, const char * format ATTRIBUTE_UNUSED
, ...)
1845 /* Disassemble some data in memory between given values. */
1848 disassemble_bytes (struct disassemble_info
* inf
,
1849 disassembler_ftype disassemble_fn
,
1852 bfd_vma start_offset
,
1853 bfd_vma stop_offset
,
1856 arelent
** relppend
)
1858 struct objdump_disasm_info
*aux
;
1860 int octets_per_line
;
1861 int skip_addr_chars
;
1862 bfd_vma addr_offset
;
1863 unsigned int opb
= inf
->octets_per_byte
;
1864 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1865 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1869 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1873 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1877 octets_per_line
= insn_width
;
1879 octets_per_line
= 4;
1881 octets_per_line
= 16;
1883 /* Figure out how many characters to skip at the start of an
1884 address, to make the disassembly look nicer. We discard leading
1885 zeroes in chunks of 4, ensuring that there is always a leading
1887 skip_addr_chars
= 0;
1888 if (! prefix_addresses
)
1892 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1894 while (buf
[skip_addr_chars
] == '0')
1897 /* Don't discard zeros on overflow. */
1898 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1899 skip_addr_chars
= 0;
1901 if (skip_addr_chars
!= 0)
1902 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1905 inf
->insn_info_valid
= 0;
1907 addr_offset
= start_offset
;
1908 while (addr_offset
< stop_offset
)
1911 bfd_boolean need_nl
= FALSE
;
1915 /* Make sure we don't use relocs from previous instructions. */
1918 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1920 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1923 if (! disassemble_zeroes
1924 && (inf
->insn_info_valid
== 0
1925 || inf
->branch_delay_insns
== 0)
1926 && (z
- addr_offset
* opb
>= skip_zeroes
1927 || (z
== stop_offset
* opb
&&
1928 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1930 /* If there are more nonzero octets to follow, we only skip
1931 zeroes in multiples of 4, to try to avoid running over
1932 the start of an instruction which happens to start with
1934 if (z
!= stop_offset
* opb
)
1935 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1937 octets
= z
- addr_offset
* opb
;
1939 /* If we are going to display more data, and we are displaying
1940 file offsets, then tell the user how many zeroes we skip
1941 and the file offset from where we resume dumping. */
1942 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1943 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1945 (unsigned long) (section
->filepos
1946 + (addr_offset
+ (octets
/ opb
))));
1956 if (with_line_numbers
|| with_source_code
)
1957 show_line (aux
->abfd
, section
, addr_offset
);
1959 if (! prefix_addresses
)
1963 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1964 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1968 printf ("%s:\t", buf
+ skip_addr_chars
);
1972 aux
->require_sec
= TRUE
;
1973 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1974 aux
->require_sec
= FALSE
;
1981 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1982 inf
->stream
= &sfile
;
1983 inf
->bytes_per_line
= 0;
1984 inf
->bytes_per_chunk
= 0;
1985 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
1986 | (wide_output
? WIDE_OUTPUT
: 0));
1988 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1990 if (inf
->disassembler_needs_relocs
1991 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1992 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1993 && *relppp
< relppend
)
1995 bfd_signed_vma distance_to_rel
;
1997 int max_reloc_offset
1998 = aux
->abfd
->arch_info
->max_reloc_offset_into_insn
;
2000 distance_to_rel
= ((**relppp
)->address
- rel_offset
2003 if (distance_to_rel
> 0
2004 && (max_reloc_offset
< 0
2005 || distance_to_rel
<= max_reloc_offset
))
2007 /* This reloc *might* apply to the current insn,
2008 starting somewhere inside it. Discover the length
2009 of the current insn so that the check below will
2012 insn_size
= insn_width
;
2015 /* We find the length by calling the dissassembler
2016 function with a dummy print handler. This should
2017 work unless the disassembler is not expecting to
2018 be called multiple times for the same address.
2020 This does mean disassembling the instruction
2021 twice, but we only do this when there is a high
2022 probability that there is a reloc that will
2023 affect the instruction. */
2024 inf
->fprintf_func
= (fprintf_ftype
) null_print
;
2025 insn_size
= disassemble_fn (section
->vma
2026 + addr_offset
, inf
);
2027 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2031 /* Check to see if the current reloc is associated with
2032 the instruction that we are about to disassemble. */
2033 if (distance_to_rel
== 0
2034 || (distance_to_rel
> 0
2035 && distance_to_rel
< insn_size
/ (int) opb
))
2037 inf
->flags
|= INSN_HAS_RELOC
;
2038 aux
->reloc
= **relppp
;
2042 if (! disassemble_all
2043 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2044 == (SEC_CODE
| SEC_HAS_CONTENTS
))
2045 /* Set a stop_vma so that the disassembler will not read
2046 beyond the next symbol. We assume that symbols appear on
2047 the boundaries between instructions. We only do this when
2048 disassembling code of course, and when -D is in effect. */
2049 inf
->stop_vma
= section
->vma
+ stop_offset
;
2051 inf
->stop_offset
= stop_offset
;
2052 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2055 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2056 inf
->stream
= stdout
;
2057 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
2058 octets_per_line
= inf
->bytes_per_line
;
2059 if (octets
< (int) opb
)
2062 printf ("%s\n", sfile
.buffer
);
2065 non_fatal (_("disassemble_fn returned length %d"),
2076 octets
= octets_per_line
;
2077 if (addr_offset
+ octets
/ opb
> stop_offset
)
2078 octets
= (stop_offset
- addr_offset
) * opb
;
2080 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
2082 if (ISPRINT (data
[j
]))
2083 buf
[j
- addr_offset
* opb
] = data
[j
];
2085 buf
[j
- addr_offset
* opb
] = '.';
2087 buf
[j
- addr_offset
* opb
] = '\0';
2090 if (prefix_addresses
2092 : show_raw_insn
>= 0)
2096 /* If ! prefix_addresses and ! wide_output, we print
2097 octets_per_line octets per line. */
2099 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
2100 pb
= octets_per_line
;
2102 if (inf
->bytes_per_chunk
)
2103 bpc
= inf
->bytes_per_chunk
;
2107 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2109 /* PR 21580: Check for a buffer ending early. */
2110 if (j
+ bpc
<= stop_offset
* opb
)
2114 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2116 for (k
= bpc
- 1; k
>= 0; k
--)
2117 printf ("%02x", (unsigned) data
[j
+ k
]);
2121 for (k
= 0; k
< bpc
; k
++)
2122 printf ("%02x", (unsigned) data
[j
+ k
]);
2128 for (; pb
< octets_per_line
; pb
+= bpc
)
2132 for (k
= 0; k
< bpc
; k
++)
2137 /* Separate raw data from instruction by extra space. */
2147 printf ("%s", sfile
.buffer
);
2149 if (prefix_addresses
2151 : show_raw_insn
>= 0)
2159 j
= addr_offset
* opb
+ pb
;
2161 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
2162 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2166 printf ("%s:\t", buf
+ skip_addr_chars
);
2168 pb
+= octets_per_line
;
2171 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2173 /* PR 21619: Check for a buffer ending early. */
2174 if (j
+ bpc
<= stop_offset
* opb
)
2178 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2180 for (k
= bpc
- 1; k
>= 0; k
--)
2181 printf ("%02x", (unsigned) data
[j
+ k
]);
2185 for (k
= 0; k
< bpc
; k
++)
2186 printf ("%02x", (unsigned) data
[j
+ k
]);
2200 while ((*relppp
) < relppend
2201 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
2203 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
2214 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
2217 if (q
->howto
== NULL
)
2218 printf (": *unknown*\t");
2219 else if (q
->howto
->name
)
2220 printf (": %s\t", q
->howto
->name
);
2222 printf (": %d\t", q
->howto
->type
);
2224 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
2225 printf ("*unknown*");
2228 const char *sym_name
;
2230 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
2231 if (sym_name
!= NULL
&& *sym_name
!= '\0')
2232 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
2237 sym_sec
= bfd_asymbol_section (*q
->sym_ptr_ptr
);
2238 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
2239 if (sym_name
== NULL
|| *sym_name
== '\0')
2240 sym_name
= "*unknown*";
2241 printf ("%s", sanitize_string (sym_name
));
2247 bfd_signed_vma addend
= q
->addend
;
2255 objdump_print_value (addend
, inf
, TRUE
);
2267 addr_offset
+= octets
/ opb
;
2270 free (sfile
.buffer
);
2274 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
2276 const struct elf_backend_data
* bed
;
2277 bfd_vma sign_adjust
= 0;
2278 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
2279 struct objdump_disasm_info
* paux
;
2280 unsigned int opb
= pinfo
->octets_per_byte
;
2281 bfd_byte
* data
= NULL
;
2282 bfd_size_type datasize
= 0;
2283 arelent
** rel_pp
= NULL
;
2284 arelent
** rel_ppstart
= NULL
;
2285 arelent
** rel_ppend
;
2286 bfd_vma stop_offset
;
2287 asymbol
* sym
= NULL
;
2291 unsigned long addr_offset
;
2292 bfd_boolean do_print
;
2295 stop_offset_reached
,
2300 /* Sections that do not contain machine
2301 code are not normally disassembled. */
2302 if (! disassemble_all
2303 && only_list
== NULL
2304 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2305 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
2308 if (! process_section_p (section
))
2311 datasize
= bfd_get_section_size (section
);
2315 if (start_address
== (bfd_vma
) -1
2316 || start_address
< section
->vma
)
2319 addr_offset
= start_address
- section
->vma
;
2321 if (stop_address
== (bfd_vma
) -1)
2322 stop_offset
= datasize
/ opb
;
2325 if (stop_address
< section
->vma
)
2328 stop_offset
= stop_address
- section
->vma
;
2329 if (stop_offset
> datasize
/ opb
)
2330 stop_offset
= datasize
/ opb
;
2333 if (addr_offset
>= stop_offset
)
2336 /* Decide which set of relocs to use. Load them if necessary. */
2337 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
2338 if (paux
->dynrelbuf
&& dump_dynamic_reloc_info
)
2340 rel_pp
= paux
->dynrelbuf
;
2341 rel_count
= paux
->dynrelcount
;
2342 /* Dynamic reloc addresses are absolute, non-dynamic are section
2343 relative. REL_OFFSET specifies the reloc address corresponding
2344 to the start of this section. */
2345 rel_offset
= section
->vma
;
2353 if ((section
->flags
& SEC_RELOC
) != 0
2354 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
2358 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2360 bfd_fatal (bfd_get_filename (abfd
));
2364 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
2365 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
2367 bfd_fatal (bfd_get_filename (abfd
));
2369 /* Sort the relocs by address. */
2370 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
2374 rel_ppend
= rel_pp
+ rel_count
;
2376 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2378 non_fatal (_("Reading section %s failed because: %s"),
2379 section
->name
, bfd_errmsg (bfd_get_error ()));
2383 paux
->sec
= section
;
2384 pinfo
->buffer
= data
;
2385 pinfo
->buffer_vma
= section
->vma
;
2386 pinfo
->buffer_length
= datasize
;
2387 pinfo
->section
= section
;
2389 /* Skip over the relocs belonging to addresses below the
2391 while (rel_pp
< rel_ppend
2392 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
2395 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
2397 /* Find the nearest symbol forwards from our current position. */
2398 paux
->require_sec
= TRUE
;
2399 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
2400 (struct disassemble_info
*) inf
,
2402 paux
->require_sec
= FALSE
;
2404 /* PR 9774: If the target used signed addresses then we must make
2405 sure that we sign extend the value that we calculate for 'addr'
2406 in the loop below. */
2407 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2408 && (bed
= get_elf_backend_data (abfd
)) != NULL
2409 && bed
->sign_extend_vma
)
2410 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2412 /* Disassemble a block of instructions up to the address associated with
2413 the symbol we have just found. Then print the symbol and find the
2414 next symbol on. Repeat until we have disassembled the entire section
2415 or we have reached the end of the address range we are interested in. */
2416 do_print
= paux
->symbol
== NULL
;
2417 loop_until
= stop_offset_reached
;
2419 while (addr_offset
< stop_offset
)
2423 bfd_vma nextstop_offset
;
2426 addr
= section
->vma
+ addr_offset
;
2427 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2429 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2434 (x
< sorted_symcount
2435 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2439 pinfo
->symbols
= sorted_syms
+ place
;
2440 pinfo
->num_symbols
= x
- place
;
2441 pinfo
->symtab_pos
= place
;
2445 pinfo
->symbols
= NULL
;
2446 pinfo
->num_symbols
= 0;
2447 pinfo
->symtab_pos
= -1;
2450 /* If we are only disassembling from a specific symbol,
2451 check to see if we should start or stop displaying. */
2452 if (sym
&& paux
->symbol
)
2456 /* See if we should stop printing. */
2460 if (sym
->flags
& BSF_FUNCTION
)
2464 case stop_offset_reached
:
2465 /* Handled by the while loop. */
2469 /* FIXME: There is an implicit assumption here
2470 that the name of sym is different from
2472 if (! bfd_is_local_label (abfd
, sym
))
2479 const char * name
= bfd_asymbol_name (sym
);
2480 char * alloc
= NULL
;
2482 if (do_demangle
&& name
[0] != '\0')
2484 /* Demangle the name. */
2485 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
2490 /* We are not currently printing. Check to see
2491 if the current symbol matches the requested symbol. */
2492 if (streq (name
, paux
->symbol
))
2496 if (sym
->flags
& BSF_FUNCTION
)
2498 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2499 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
2501 /* Sym is a function symbol with a size associated
2502 with it. Turn on automatic disassembly for the
2503 next VALUE bytes. */
2504 stop_offset
= addr_offset
2505 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
2506 loop_until
= stop_offset_reached
;
2510 /* Otherwise we need to tell the loop heuristic to
2511 loop until the next function symbol is encountered. */
2512 loop_until
= function_sym
;
2517 /* Otherwise loop until the next symbol is encountered. */
2518 loop_until
= next_sym
;
2526 if (! prefix_addresses
&& do_print
)
2528 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2529 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2531 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2534 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2536 else if (sym
== NULL
)
2540 #define is_valid_next_sym(SYM) \
2541 (strcmp (bfd_section_name (abfd, (SYM)->section), bfd_section_name (abfd, section)) == 0 \
2542 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2543 && pinfo->symbol_is_valid (SYM, pinfo))
2545 /* Search forward for the next appropriate symbol in
2546 SECTION. Note that all the symbols are sorted
2547 together into one big array, and that some sections
2548 may have overlapping addresses. */
2549 while (place
< sorted_symcount
2550 && ! is_valid_next_sym (sorted_syms
[place
]))
2553 if (place
>= sorted_symcount
)
2556 nextsym
= sorted_syms
[place
];
2559 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2560 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2561 else if (nextsym
== NULL
)
2562 nextstop_offset
= stop_offset
;
2564 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2566 if (nextstop_offset
> stop_offset
2567 || nextstop_offset
<= addr_offset
)
2568 nextstop_offset
= stop_offset
;
2570 /* If a symbol is explicitly marked as being an object
2571 rather than a function, just dump the bytes without
2572 disassembling them. */
2575 || sym
->section
!= section
2576 || bfd_asymbol_value (sym
) > addr
2577 || ((sym
->flags
& BSF_OBJECT
) == 0
2578 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2580 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2582 || (sym
->flags
& BSF_FUNCTION
) != 0)
2588 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2589 addr_offset
, nextstop_offset
,
2590 rel_offset
, &rel_pp
, rel_ppend
);
2592 addr_offset
= nextstop_offset
;
2598 if (rel_ppstart
!= NULL
)
2602 /* Disassemble the contents of an object file. */
2605 disassemble_data (bfd
*abfd
)
2607 struct disassemble_info disasm_info
;
2608 struct objdump_disasm_info aux
;
2612 prev_functionname
= NULL
;
2614 prev_discriminator
= 0;
2616 /* We make a copy of syms to sort. We don't want to sort syms
2617 because that will screw up the relocs. */
2618 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2619 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2620 * sizeof (asymbol
*));
2621 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2622 sorted_symcount
* sizeof (asymbol
*));
2624 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2626 for (i
= 0; i
< synthcount
; ++i
)
2628 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2632 /* Sort the symbols into section and symbol order. */
2633 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2635 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2637 disasm_info
.application_data
= (void *) &aux
;
2639 aux
.require_sec
= FALSE
;
2640 aux
.dynrelbuf
= NULL
;
2641 aux
.dynrelcount
= 0;
2643 aux
.symbol
= disasm_sym
;
2645 disasm_info
.print_address_func
= objdump_print_address
;
2646 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2648 if (machine
!= NULL
)
2650 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2653 fatal (_("can't use supplied machine %s"), machine
);
2655 abfd
->arch_info
= inf
;
2658 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2660 struct bfd_target
*xvec
;
2662 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2663 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2664 xvec
->byteorder
= endian
;
2668 /* Use libopcodes to locate a suitable disassembler. */
2669 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
2670 bfd_big_endian (abfd
),
2671 bfd_get_mach (abfd
), abfd
);
2672 if (!aux
.disassemble_fn
)
2674 non_fatal (_("can't disassemble for architecture %s\n"),
2675 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2680 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2681 disasm_info
.arch
= bfd_get_arch (abfd
);
2682 disasm_info
.mach
= bfd_get_mach (abfd
);
2683 disasm_info
.disassembler_options
= disassembler_options
;
2684 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2685 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2686 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2687 disasm_info
.disassembler_needs_relocs
= FALSE
;
2689 if (bfd_big_endian (abfd
))
2690 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2691 else if (bfd_little_endian (abfd
))
2692 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2694 /* ??? Aborting here seems too drastic. We could default to big or little
2696 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2698 /* Allow the target to customize the info structure. */
2699 disassemble_init_for_target (& disasm_info
);
2701 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
2703 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2705 if (relsize
< 0 && dump_dynamic_reloc_info
)
2706 bfd_fatal (bfd_get_filename (abfd
));
2710 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2711 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2714 if (aux
.dynrelcount
< 0)
2715 bfd_fatal (bfd_get_filename (abfd
));
2717 /* Sort the relocs by address. */
2718 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2722 disasm_info
.symtab
= sorted_syms
;
2723 disasm_info
.symtab_size
= sorted_symcount
;
2725 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2727 if (aux
.dynrelbuf
!= NULL
)
2728 free (aux
.dynrelbuf
);
2733 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2734 asection
*sec
, void *file
)
2736 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2737 bfd
*abfd
= (bfd
*) file
;
2742 if (section
->start
!= NULL
)
2744 /* If it is already loaded, do nothing. */
2745 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2747 free (section
->start
);
2750 section
->filename
= bfd_get_filename (abfd
);
2751 section
->reloc_info
= NULL
;
2752 section
->num_relocs
= 0;
2753 section
->address
= bfd_get_section_vma (abfd
, sec
);
2754 section
->user_data
= sec
;
2755 section
->size
= bfd_get_section_size (sec
);
2756 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
2757 alloced
= amt
= section
->size
+ 1;
2758 if (alloced
!= amt
|| alloced
== 0)
2760 section
->start
= NULL
;
2761 free_debug_section (debug
);
2762 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
2763 sanitize_string (section
->name
),
2764 (unsigned long long) section
->size
);
2767 section
->start
= contents
= malloc (alloced
);
2768 if (section
->start
== NULL
2769 || !bfd_get_full_section_contents (abfd
, sec
, &contents
))
2771 free_debug_section (debug
);
2772 printf (_("\nCan't get contents for section '%s'.\n"),
2773 sanitize_string (section
->name
));
2776 /* Ensure any string section has a terminating NUL. */
2777 section
->start
[section
->size
] = 0;
2779 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
2780 && debug_displays
[debug
].relocate
)
2785 bfd_cache_section_contents (sec
, section
->start
);
2787 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2794 free_debug_section (debug
);
2795 printf (_("\nCan't get contents for section '%s'.\n"),
2796 sanitize_string (section
->name
));
2800 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
2803 unsigned long reloc_count
;
2806 relocs
= (arelent
**) xmalloc (reloc_size
);
2808 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
2809 if (reloc_count
== 0)
2813 section
->reloc_info
= relocs
;
2814 section
->num_relocs
= reloc_count
;
2823 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
2828 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
2831 relocs
= (arelent
**) dsec
->reloc_info
;
2833 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
2834 if (rp
->address
== offset
)
2841 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2843 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2844 bfd
*abfd
= (bfd
*) file
;
2847 /* If it is already loaded, do nothing. */
2848 if (section
->start
!= NULL
)
2850 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2854 /* Locate the debug section. */
2855 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2857 section
->name
= section
->uncompressed_name
;
2860 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2862 section
->name
= section
->compressed_name
;
2867 return load_specific_debug_section (debug
, sec
, file
);
2871 free_debug_section (enum dwarf_section_display_enum debug
)
2873 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2875 if (section
->start
== NULL
)
2878 /* PR 17512: file: 0f67f69d. */
2879 if (section
->user_data
!= NULL
)
2881 asection
* sec
= (asection
*) section
->user_data
;
2883 /* If we are freeing contents that are also pointed to by the BFD
2884 library's section structure then make sure to update those pointers
2885 too. Otherwise, the next time we try to load data for this section
2886 we can end up using a stale pointer. */
2887 if (section
->start
== sec
->contents
)
2889 sec
->contents
= NULL
;
2890 sec
->flags
&= ~ SEC_IN_MEMORY
;
2891 sec
->compress_status
= COMPRESS_SECTION_NONE
;
2895 free ((char *) section
->start
);
2896 section
->start
= NULL
;
2897 section
->address
= 0;
2902 close_debug_file (void * file
)
2904 bfd
* abfd
= (bfd
*) file
;
2910 open_debug_file (const char * pathname
)
2914 data
= bfd_openr (pathname
, NULL
);
2918 if (! bfd_check_format (data
, bfd_object
))
2925 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2926 void *arg ATTRIBUTE_UNUSED
)
2928 const char *name
= bfd_get_section_name (abfd
, section
);
2932 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2933 match
= ".debug_info";
2937 for (i
= 0; i
< max
; i
++)
2938 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2939 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2940 && debug_displays
[i
].enabled
!= NULL
2941 && *debug_displays
[i
].enabled
)
2943 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2945 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2946 sec
->name
= sec
->uncompressed_name
;
2948 sec
->name
= sec
->compressed_name
;
2949 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2952 debug_displays
[i
].display (sec
, abfd
);
2954 if (i
!= info
&& i
!= abbrev
)
2955 free_debug_section ((enum dwarf_section_display_enum
) i
);
2961 /* Dump the dwarf debugging information. */
2964 dump_dwarf (bfd
*abfd
)
2966 /* The byte_get pointer should have been set at the start of dump_bfd(). */
2967 if (byte_get
== NULL
)
2969 warn (_("File %s does not contain any dwarf debug information\n"),
2970 bfd_get_filename (abfd
));
2974 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2976 switch (bfd_get_arch (abfd
))
2979 switch (bfd_get_mach (abfd
))
2981 case bfd_mach_x86_64
:
2982 case bfd_mach_x86_64_intel_syntax
:
2983 case bfd_mach_x86_64_nacl
:
2984 case bfd_mach_x64_32
:
2985 case bfd_mach_x64_32_intel_syntax
:
2986 case bfd_mach_x64_32_nacl
:
2987 init_dwarf_regnames_x86_64 ();
2991 init_dwarf_regnames_i386 ();
2996 case bfd_arch_iamcu
:
2997 init_dwarf_regnames_iamcu ();
3000 case bfd_arch_aarch64
:
3001 init_dwarf_regnames_aarch64();
3005 init_dwarf_regnames_s390 ();
3008 case bfd_arch_riscv
:
3009 init_dwarf_regnames_riscv ();
3013 /* S12Z has a 24 bit address space. But the only known
3014 producer of dwarf_info encodes addresses into 32 bits. */
3022 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
3025 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
3026 it. Return NULL on failure. */
3029 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
3030 bfd_size_type
*entsize_ptr
)
3035 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
3036 if (stabsect
== NULL
)
3038 printf (_("No %s section present\n\n"),
3039 sanitize_string (sect_name
));
3043 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
3045 non_fatal (_("reading %s section of %s failed: %s"),
3046 sect_name
, bfd_get_filename (abfd
),
3047 bfd_errmsg (bfd_get_error ()));
3053 *size_ptr
= bfd_section_size (abfd
, stabsect
);
3055 *entsize_ptr
= stabsect
->entsize
;
3060 /* Stabs entries use a 12 byte format:
3061 4 byte string table index
3063 1 byte stab other field
3064 2 byte stab desc field
3066 FIXME: This will have to change for a 64 bit object format. */
3068 #define STRDXOFF (0)
3070 #define OTHEROFF (5)
3073 #define STABSIZE (12)
3075 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3076 using string table section STRSECT_NAME (in `strtab'). */
3079 print_section_stabs (bfd
*abfd
,
3080 const char *stabsect_name
,
3081 unsigned *string_offset_ptr
)
3084 unsigned file_string_table_offset
= 0;
3085 unsigned next_file_string_table_offset
= *string_offset_ptr
;
3086 bfd_byte
*stabp
, *stabs_end
;
3089 stabs_end
= stabp
+ stab_size
;
3091 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
3092 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3094 /* Loop through all symbols and print them.
3096 We start the index at -1 because there is a dummy symbol on
3097 the front of stabs-in-{coff,elf} sections that supplies sizes. */
3098 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
3102 unsigned char type
, other
;
3103 unsigned short desc
;
3106 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
3107 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
3108 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
3109 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
3110 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
3112 printf ("\n%-6d ", i
);
3113 /* Either print the stab name, or, if unnamed, print its number
3114 again (makes consistent formatting for tools like awk). */
3115 name
= bfd_get_stab_name (type
);
3117 printf ("%-6s", sanitize_string (name
));
3118 else if (type
== N_UNDF
)
3121 printf ("%-6d", type
);
3122 printf (" %-6d %-6d ", other
, desc
);
3123 bfd_printf_vma (abfd
, value
);
3124 printf (" %-6lu", strx
);
3126 /* Symbols with type == 0 (N_UNDF) specify the length of the
3127 string table associated with this file. We use that info
3128 to know how to relocate the *next* file's string table indices. */
3131 file_string_table_offset
= next_file_string_table_offset
;
3132 next_file_string_table_offset
+= value
;
3136 bfd_size_type amt
= strx
+ file_string_table_offset
;
3138 /* Using the (possibly updated) string table offset, print the
3139 string (if any) associated with this symbol. */
3140 if (amt
< stabstr_size
)
3141 /* PR 17512: file: 079-79389-0.001:0.1.
3142 FIXME: May need to sanitize this string before displaying. */
3143 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
3149 *string_offset_ptr
= next_file_string_table_offset
;
3154 const char * section_name
;
3155 const char * string_section_name
;
3156 unsigned string_offset
;
3161 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
3164 stab_section_names
* sought
= (stab_section_names
*) names
;
3166 /* Check for section names for which stabsect_name is a prefix, to
3167 handle .stab.N, etc. */
3168 len
= strlen (sought
->section_name
);
3170 /* If the prefix matches, and the files section name ends with a
3171 nul or a digit, then we match. I.e., we want either an exact
3172 match or a section followed by a number. */
3173 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
3174 && (section
->name
[len
] == 0
3175 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
3178 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
3179 &stabstr_size
, NULL
);
3183 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
, NULL
);
3185 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
3191 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
3193 stab_section_names s
;
3195 s
.section_name
= stabsect_name
;
3196 s
.string_section_name
= strsect_name
;
3197 s
.string_offset
= 0;
3199 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
3205 /* Dump the any sections containing stabs debugging information. */
3208 dump_stabs (bfd
*abfd
)
3210 dump_stabs_section (abfd
, ".stab", ".stabstr");
3211 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
3212 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
3215 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3217 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3221 dump_bfd_header (bfd
*abfd
)
3225 printf (_("architecture: %s, "),
3226 bfd_printable_arch_mach (bfd_get_arch (abfd
),
3227 bfd_get_mach (abfd
)));
3228 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
3230 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
3231 PF (HAS_RELOC
, "HAS_RELOC");
3232 PF (EXEC_P
, "EXEC_P");
3233 PF (HAS_LINENO
, "HAS_LINENO");
3234 PF (HAS_DEBUG
, "HAS_DEBUG");
3235 PF (HAS_SYMS
, "HAS_SYMS");
3236 PF (HAS_LOCALS
, "HAS_LOCALS");
3237 PF (DYNAMIC
, "DYNAMIC");
3238 PF (WP_TEXT
, "WP_TEXT");
3239 PF (D_PAGED
, "D_PAGED");
3240 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
3241 printf (_("\nstart address 0x"));
3242 bfd_printf_vma (abfd
, abfd
->start_address
);
3247 /* Formatting callback function passed to ctf_dump. Returns either the pointer
3248 it is passed, or a pointer to newly-allocated storage, in which case
3249 dump_ctf() will free it when it no longer needs it. */
3252 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
3255 const char *blanks
= arg
;
3258 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
3263 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
3265 make_ctfsect (const char *name
, bfd_byte
*data
,
3270 ctfsect
.cts_name
= name
;
3271 ctfsect
.cts_entsize
= 1;
3272 ctfsect
.cts_size
= size
;
3273 ctfsect
.cts_data
= data
;
3278 /* Dump one CTF archive member. */
3281 dump_ctf_archive_member (ctf_file_t
*ctf
, const char *name
, void *arg
)
3283 ctf_file_t
*parent
= (ctf_file_t
*) arg
;
3284 const char *things
[] = {"Labels", "Data objects", "Function objects",
3285 "Variables", "Types", "Strings", ""};
3289 /* Only print out the name of non-default-named archive members.
3290 The name .ctf appears everywhere, even for things that aren't
3291 really archives, so printing it out is liable to be confusing. */
3292 if (strcmp (name
, ".ctf") != 0)
3293 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name
));
3295 ctf_import (ctf
, parent
);
3296 for (i
= 1, thing
= things
; *thing
[0]; thing
++, i
++)
3298 ctf_dump_state_t
*s
= NULL
;
3301 printf ("\n %s:\n", *thing
);
3302 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
3303 (void *) " ")) != NULL
)
3305 printf ("%s\n", item
);
3309 if (ctf_errno (ctf
))
3311 non_fatal (_("Iteration failed: %s, %s\n"), *thing
,
3312 ctf_errmsg (ctf_errno (ctf
)));
3319 /* Dump the CTF debugging information. */
3322 dump_ctf (bfd
*abfd
, const char *sect_name
, const char *parent_name
)
3324 ctf_archive_t
*ctfa
, *parenta
= NULL
;
3325 bfd_byte
*ctfdata
, *parentdata
= NULL
;
3326 bfd_size_type ctfsize
, parentsize
;
3328 ctf_file_t
*parent
= NULL
;
3331 if ((ctfdata
= read_section_stabs (abfd
, sect_name
, &ctfsize
, NULL
)) == NULL
)
3332 bfd_fatal (bfd_get_filename (abfd
));
3335 && (parentdata
= read_section_stabs (abfd
, parent_name
, &parentsize
,
3337 bfd_fatal (bfd_get_filename (abfd
));
3339 /* Load the CTF file and dump it. */
3341 ctfsect
= make_ctfsect (sect_name
, ctfdata
, ctfsize
);
3342 if ((ctfa
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
3344 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3345 bfd_fatal (bfd_get_filename (abfd
));
3350 ctfsect
= make_ctfsect (parent_name
, parentdata
, parentsize
);
3351 if ((parenta
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
3353 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3354 bfd_fatal (bfd_get_filename (abfd
));
3357 /* Assume that the applicable parent archive member is the default one.
3358 (This is what all known implementations are expected to do, if they
3359 put CTFs and their parents in archives together.) */
3360 if ((parent
= ctf_arc_open_by_name (parenta
, NULL
, &err
)) == NULL
)
3362 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3363 bfd_fatal (bfd_get_filename (abfd
));
3367 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name
));
3369 ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
);
3370 ctf_file_close (parent
);
3372 ctf_close (parenta
);
3379 dump_bfd_private_header (bfd
*abfd
)
3381 if (!bfd_print_private_bfd_data (abfd
, stdout
))
3382 non_fatal (_("warning: private headers incomplete: %s"),
3383 bfd_errmsg (bfd_get_error ()));
3387 dump_target_specific (bfd
*abfd
)
3389 const struct objdump_private_desc
* const *desc
;
3390 struct objdump_private_option
*opt
;
3393 /* Find the desc. */
3394 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
3395 if ((*desc
)->filter (abfd
))
3400 non_fatal (_("option -P/--private not supported by this file"));
3404 /* Clear all options. */
3405 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3406 opt
->selected
= FALSE
;
3408 /* Decode options. */
3409 b
= dump_private_options
;
3412 e
= strchr (b
, ',');
3417 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3418 if (strcmp (opt
->name
, b
) == 0)
3420 opt
->selected
= TRUE
;
3423 if (opt
->name
== NULL
)
3424 non_fatal (_("target specific dump '%s' not supported"), b
);
3435 (*desc
)->dump (abfd
);
3438 /* Display a section in hexadecimal format with associated characters.
3439 Each line prefixed by the zero padded address. */
3442 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
3444 bfd_byte
*data
= NULL
;
3445 bfd_size_type datasize
;
3446 bfd_vma addr_offset
;
3447 bfd_vma start_offset
;
3448 bfd_vma stop_offset
;
3449 unsigned int opb
= bfd_octets_per_byte (abfd
);
3450 /* Bytes per line. */
3451 const int onaline
= 16;
3456 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
3459 if (! process_section_p (section
))
3462 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
3465 /* Compute the address range to display. */
3466 if (start_address
== (bfd_vma
) -1
3467 || start_address
< section
->vma
)
3470 start_offset
= start_address
- section
->vma
;
3472 if (stop_address
== (bfd_vma
) -1)
3473 stop_offset
= datasize
/ opb
;
3476 if (stop_address
< section
->vma
)
3479 stop_offset
= stop_address
- section
->vma
;
3481 if (stop_offset
> datasize
/ opb
)
3482 stop_offset
= datasize
/ opb
;
3485 if (start_offset
>= stop_offset
)
3488 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
3489 if (display_file_offsets
)
3490 printf (_(" (Starting at file offset: 0x%lx)"),
3491 (unsigned long) (section
->filepos
+ start_offset
));
3494 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
3496 non_fatal (_("Reading section %s failed because: %s"),
3497 section
->name
, bfd_errmsg (bfd_get_error ()));
3503 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
3504 if (strlen (buf
) >= sizeof (buf
))
3508 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3510 count
= strlen (buf
) - count
;
3514 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
3515 if (strlen (buf
) >= sizeof (buf
))
3519 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3521 count
= strlen (buf
) - count
;
3525 for (addr_offset
= start_offset
;
3526 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
3530 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
3531 count
= strlen (buf
);
3532 if ((size_t) count
>= sizeof (buf
))
3536 while (count
< width
)
3541 fputs (buf
+ count
- width
, stdout
);
3544 for (j
= addr_offset
* opb
;
3545 j
< addr_offset
* opb
+ onaline
; j
++)
3547 if (j
< stop_offset
* opb
)
3548 printf ("%02x", (unsigned) (data
[j
]));
3556 for (j
= addr_offset
* opb
;
3557 j
< addr_offset
* opb
+ onaline
; j
++)
3559 if (j
>= stop_offset
* opb
)
3562 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
3569 /* Actually display the various requested regions. */
3572 dump_data (bfd
*abfd
)
3574 bfd_map_over_sections (abfd
, dump_section
, NULL
);
3577 /* Should perhaps share code and display with nm? */
3580 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
3589 max_count
= dynsymcount
;
3590 printf ("DYNAMIC SYMBOL TABLE:\n");
3595 max_count
= symcount
;
3596 printf ("SYMBOL TABLE:\n");
3600 printf (_("no symbols\n"));
3602 for (count
= 0; count
< max_count
; count
++)
3606 if (*current
== NULL
)
3607 printf (_("no information for symbol number %ld\n"), count
);
3609 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
3610 printf (_("could not determine the type of symbol number %ld\n"),
3613 else if (process_section_p ((* current
)->section
)
3614 && (dump_special_syms
3615 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
3617 const char *name
= (*current
)->name
;
3619 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
3623 /* If we want to demangle the name, we demangle it
3624 here, and temporarily clobber it while calling
3625 bfd_print_symbol. FIXME: This is a gross hack. */
3626 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
3628 (*current
)->name
= alloc
;
3629 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3630 bfd_print_symbol_all
);
3633 (*current
)->name
= name
;
3638 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3639 bfd_print_symbol_all
);
3649 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
3652 char *last_filename
, *last_functionname
;
3653 unsigned int last_line
;
3654 unsigned int last_discriminator
;
3656 /* Get column headers lined up reasonably. */
3664 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
3665 width
= strlen (buf
) - 7;
3667 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
3670 last_filename
= NULL
;
3671 last_functionname
= NULL
;
3673 last_discriminator
= 0;
3675 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
3678 const char *filename
, *functionname
;
3679 unsigned int linenumber
;
3680 unsigned int discriminator
;
3681 const char *sym_name
;
3682 const char *section_name
;
3683 bfd_vma addend2
= 0;
3685 if (start_address
!= (bfd_vma
) -1
3686 && q
->address
< start_address
)
3688 if (stop_address
!= (bfd_vma
) -1
3689 && q
->address
> stop_address
)
3692 if (with_line_numbers
3694 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
3695 &filename
, &functionname
,
3696 &linenumber
, &discriminator
))
3698 if (functionname
!= NULL
3699 && (last_functionname
== NULL
3700 || strcmp (functionname
, last_functionname
) != 0))
3702 printf ("%s():\n", sanitize_string (functionname
));
3703 if (last_functionname
!= NULL
)
3704 free (last_functionname
);
3705 last_functionname
= xstrdup (functionname
);
3709 && (linenumber
!= last_line
3710 || (filename
!= NULL
3711 && last_filename
!= NULL
3712 && filename_cmp (filename
, last_filename
) != 0)
3713 || (discriminator
!= last_discriminator
)))
3715 if (discriminator
> 0)
3716 printf ("%s:%u\n", filename
== NULL
? "???" :
3717 sanitize_string (filename
), linenumber
);
3719 printf ("%s:%u (discriminator %u)\n",
3720 filename
== NULL
? "???" : sanitize_string (filename
),
3721 linenumber
, discriminator
);
3722 last_line
= linenumber
;
3723 last_discriminator
= discriminator
;
3724 if (last_filename
!= NULL
)
3725 free (last_filename
);
3726 if (filename
== NULL
)
3727 last_filename
= NULL
;
3729 last_filename
= xstrdup (filename
);
3733 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
3735 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
3736 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
3741 section_name
= NULL
;
3744 bfd_printf_vma (abfd
, q
->address
);
3745 if (q
->howto
== NULL
)
3746 printf (" *unknown* ");
3747 else if (q
->howto
->name
)
3749 const char *name
= q
->howto
->name
;
3751 /* R_SPARC_OLO10 relocations contain two addends.
3752 But because 'arelent' lacks enough storage to
3753 store them both, the 64-bit ELF Sparc backend
3754 records this as two relocations. One R_SPARC_LO10
3755 and one R_SPARC_13, both pointing to the same
3756 address. This is merely so that we have some
3757 place to store both addend fields.
3759 Undo this transformation, otherwise the output
3760 will be confusing. */
3761 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3762 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3764 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3766 arelent
*q2
= *(p
+ 1);
3769 && q
->address
== q2
->address
3770 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3772 name
= "R_SPARC_OLO10";
3773 addend2
= q2
->addend
;
3777 printf (" %-16s ", name
);
3780 printf (" %-16d ", q
->howto
->type
);
3784 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3788 if (section_name
== NULL
)
3789 section_name
= "*unknown*";
3790 printf ("[%s]", sanitize_string (section_name
));
3795 bfd_signed_vma addend
= q
->addend
;
3803 bfd_printf_vma (abfd
, addend
);
3808 bfd_printf_vma (abfd
, addend2
);
3814 if (last_filename
!= NULL
)
3815 free (last_filename
);
3816 if (last_functionname
!= NULL
)
3817 free (last_functionname
);
3821 dump_relocs_in_section (bfd
*abfd
,
3823 void *dummy ATTRIBUTE_UNUSED
)
3825 arelent
**relpp
= NULL
;
3829 if ( bfd_is_abs_section (section
)
3830 || bfd_is_und_section (section
)
3831 || bfd_is_com_section (section
)
3832 || (! process_section_p (section
))
3833 || ((section
->flags
& SEC_RELOC
) == 0))
3836 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
3838 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3841 printf (" (none)\n\n");
3849 relpp
= (arelent
**) xmalloc (relsize
);
3850 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3856 non_fatal (_("failed to read relocs in: %s"),
3857 sanitize_string (bfd_get_filename (abfd
)));
3858 bfd_fatal (_("error message was"));
3860 else if (relcount
== 0)
3861 printf (" (none)\n\n");
3865 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3872 dump_relocs (bfd
*abfd
)
3874 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3878 dump_dynamic_relocs (bfd
*abfd
)
3884 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3886 bfd_fatal (bfd_get_filename (abfd
));
3888 printf ("DYNAMIC RELOCATION RECORDS");
3891 printf (" (none)\n\n");
3894 relpp
= (arelent
**) xmalloc (relsize
);
3895 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3898 bfd_fatal (bfd_get_filename (abfd
));
3899 else if (relcount
== 0)
3900 printf (" (none)\n\n");
3904 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3911 /* Creates a table of paths, to search for source files. */
3914 add_include_path (const char *path
)
3918 include_path_count
++;
3919 include_paths
= (const char **)
3920 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3921 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3922 if (path
[1] == ':' && path
[2] == 0)
3923 path
= concat (path
, ".", (const char *) 0);
3925 include_paths
[include_path_count
- 1] = path
;
3929 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3933 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3935 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3936 section
->vma
+= adjust_section_vma
;
3938 section
->lma
+= adjust_section_vma
;
3942 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
3945 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
3950 mask
= (bfd_vma
) 1 << (arch_size
- 1);
3951 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
3954 /* Dump selected contents of ABFD. */
3957 dump_bfd (bfd
*abfd
, bfd_boolean is_mainfile
)
3959 const struct elf_backend_data
* bed
;
3961 if (bfd_big_endian (abfd
))
3962 byte_get
= byte_get_big_endian
;
3963 else if (bfd_little_endian (abfd
))
3964 byte_get
= byte_get_little_endian
;
3968 /* Load any separate debug information files.
3969 We do this now and without checking do_follow_links because separate
3970 debug info files may contain symbol tables that we will need when
3971 displaying information about the main file. Any memory allocated by
3972 load_separate_debug_files will be released when we call
3973 free_debug_memory below.
3975 The test on is_mainfile is there because the chain of separate debug
3976 info files is a global variable shared by all invocations of dump_bfd. */
3979 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
3981 /* If asked to do so, recursively dump the separate files. */
3982 if (do_follow_links
)
3986 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3987 dump_bfd (i
->handle
, FALSE
);
3991 /* Adjust user-specified start and stop limits for targets that use
3992 signed addresses. */
3993 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3994 && (bed
= get_elf_backend_data (abfd
)) != NULL
3995 && bed
->sign_extend_vma
)
3997 start_address
= sign_extend_address (abfd
, start_address
,
3999 stop_address
= sign_extend_address (abfd
, stop_address
,
4003 /* If we are adjusting section VMA's, change them all now. Changing
4004 the BFD information is a hack. However, we must do it, or
4005 bfd_find_nearest_line will not do the right thing. */
4006 if (adjust_section_vma
!= 0)
4008 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
4009 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
4012 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4013 printf (_("\n%s: file format %s\n"),
4014 sanitize_string (bfd_get_filename (abfd
)),
4017 print_arelt_descr (stdout
, abfd
, TRUE
, FALSE
);
4018 if (dump_file_header
)
4019 dump_bfd_header (abfd
);
4020 if (dump_private_headers
)
4021 dump_bfd_private_header (abfd
);
4022 if (dump_private_options
!= NULL
)
4023 dump_target_specific (abfd
);
4024 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4031 || dump_dwarf_section_info
)
4033 syms
= slurp_symtab (abfd
);
4035 /* If following links, load any symbol tables from the linked files as well. */
4036 if (do_follow_links
&& is_mainfile
)
4040 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4042 asymbol
** extra_syms
;
4043 long old_symcount
= symcount
;
4045 extra_syms
= slurp_symtab (i
->handle
);
4049 if (old_symcount
== 0)
4055 syms
= xrealloc (syms
, (symcount
+ old_symcount
) * sizeof (asymbol
*));
4056 memcpy (syms
+ old_symcount
,
4058 symcount
* sizeof (asymbol
*));
4062 symcount
+= old_symcount
;
4067 if (dump_section_headers
)
4068 dump_headers (abfd
);
4070 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
4071 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
4072 dynsyms
= slurp_dynamic_symtab (abfd
);
4076 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
4077 dynsymcount
, dynsyms
, &synthsyms
);
4083 dump_symbols (abfd
, FALSE
);
4084 if (dump_dynamic_symtab
)
4085 dump_symbols (abfd
, TRUE
);
4086 if (dump_dwarf_section_info
)
4088 if (dump_ctf_section_info
)
4089 dump_ctf (abfd
, dump_ctf_section_name
, dump_ctf_parent_name
);
4090 if (dump_stab_section_info
)
4092 if (dump_reloc_info
&& ! disassemble
)
4094 if (dump_dynamic_reloc_info
&& ! disassemble
)
4095 dump_dynamic_relocs (abfd
);
4096 if (dump_section_contents
)
4099 disassemble_data (abfd
);
4105 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
4106 if (dhandle
!= NULL
)
4108 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
4110 dump_debugging_tags
? TRUE
: FALSE
))
4112 non_fatal (_("%s: printing debugging information failed"),
4113 bfd_get_filename (abfd
));
4119 /* PR 6483: If there was no STABS debug info in the file, try
4121 else if (! dump_dwarf_section_info
)
4123 dwarf_select_sections_all ();
4151 free_debug_memory ();
4155 display_object_bfd (bfd
*abfd
)
4159 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
4161 dump_bfd (abfd
, TRUE
);
4165 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4167 nonfatal (bfd_get_filename (abfd
));
4168 list_matching_formats (matching
);
4173 if (bfd_get_error () != bfd_error_file_not_recognized
)
4175 nonfatal (bfd_get_filename (abfd
));
4179 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
4181 dump_bfd (abfd
, TRUE
);
4185 nonfatal (bfd_get_filename (abfd
));
4187 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4189 list_matching_formats (matching
);
4195 display_any_bfd (bfd
*file
, int level
)
4197 /* Decompress sections unless dumping the section contents. */
4198 if (!dump_section_contents
)
4199 file
->flags
|= BFD_DECOMPRESS
;
4201 /* If the file is an archive, process all of its elements. */
4202 if (bfd_check_format (file
, bfd_archive
))
4205 bfd
*last_arfile
= NULL
;
4208 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
4209 else if (level
> 100)
4211 /* Prevent corrupted files from spinning us into an
4212 infinite loop. 100 is an arbitrary heuristic. */
4213 fatal (_("Archive nesting is too deep"));
4217 printf (_("In nested archive %s:\n"),
4218 sanitize_string (bfd_get_filename (file
)));
4222 bfd_set_error (bfd_error_no_error
);
4224 arfile
= bfd_openr_next_archived_file (file
, arfile
);
4227 if (bfd_get_error () != bfd_error_no_more_archived_files
)
4228 nonfatal (bfd_get_filename (file
));
4232 display_any_bfd (arfile
, level
+ 1);
4234 if (last_arfile
!= NULL
)
4236 bfd_close (last_arfile
);
4237 /* PR 17512: file: ac585d01. */
4238 if (arfile
== last_arfile
)
4244 last_arfile
= arfile
;
4247 if (last_arfile
!= NULL
)
4248 bfd_close (last_arfile
);
4251 display_object_bfd (file
);
4255 display_file (char *filename
, char *target
, bfd_boolean last_file
)
4259 if (get_file_size (filename
) < 1)
4265 file
= bfd_openr (filename
, target
);
4268 nonfatal (filename
);
4272 display_any_bfd (file
, 0);
4274 /* This is an optimization to improve the speed of objdump, especially when
4275 dumping a file with lots of associated debug informatiom. Calling
4276 bfd_close on such a file can take a non-trivial amount of time as there
4277 are lots of lists to walk and buffers to free. This is only really
4278 necessary however if we are about to load another file and we need the
4279 memory back. Otherwise, if we are about to exit, then we can save (a lot
4280 of) time by only doing a quick close, and allowing the OS to reclaim the
4285 bfd_close_all_done (file
);
4289 main (int argc
, char **argv
)
4292 char *target
= default_target
;
4293 bfd_boolean seenflag
= FALSE
;
4295 #if defined (HAVE_SETLOCALE)
4296 #if defined (HAVE_LC_MESSAGES)
4297 setlocale (LC_MESSAGES
, "");
4299 setlocale (LC_CTYPE
, "");
4302 bindtextdomain (PACKAGE
, LOCALEDIR
);
4303 textdomain (PACKAGE
);
4305 program_name
= *argv
;
4306 xmalloc_set_program_name (program_name
);
4307 bfd_set_error_program_name (program_name
);
4309 START_PROGRESS (program_name
, 0);
4311 expandargv (&argc
, &argv
);
4313 if (bfd_init () != BFD_INIT_MAGIC
)
4314 fatal (_("fatal error: libbfd ABI mismatch"));
4315 set_default_bfd_target ();
4317 while ((c
= getopt_long (argc
, argv
,
4318 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
4319 long_options
, (int *) 0))
4325 break; /* We've been given a long option. */
4332 if (disassembler_options
)
4333 /* Ignore potential memory leak for now. */
4334 options
= concat (disassembler_options
, ",",
4335 optarg
, (const char *) NULL
);
4338 disassembler_options
= remove_whitespace_and_extra_commas (options
);
4345 display_file_offsets
= TRUE
;
4348 with_line_numbers
= TRUE
;
4357 enum demangling_styles style
;
4359 style
= cplus_demangle_name_to_style (optarg
);
4360 if (style
== unknown_demangling
)
4361 fatal (_("unknown demangling style `%s'"),
4364 cplus_demangle_set_style (style
);
4367 case OPTION_RECURSE_LIMIT
:
4368 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
4370 case OPTION_NO_RECURSE_LIMIT
:
4371 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
4374 do_wide
= wide_output
= TRUE
;
4376 case OPTION_ADJUST_VMA
:
4377 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
4379 case OPTION_START_ADDRESS
:
4380 start_address
= parse_vma (optarg
, "--start-address");
4381 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4382 fatal (_("error: the start address should be before the end address"));
4384 case OPTION_STOP_ADDRESS
:
4385 stop_address
= parse_vma (optarg
, "--stop-address");
4386 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4387 fatal (_("error: the stop address should be after the start address"));
4391 prefix_length
= strlen (prefix
);
4392 /* Remove an unnecessary trailing '/' */
4393 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
4396 case OPTION_PREFIX_STRIP
:
4397 prefix_strip
= atoi (optarg
);
4398 if (prefix_strip
< 0)
4399 fatal (_("error: prefix strip must be non-negative"));
4401 case OPTION_INSN_WIDTH
:
4402 insn_width
= strtoul (optarg
, NULL
, 0);
4403 if (insn_width
<= 0)
4404 fatal (_("error: instruction width must be positive"));
4406 case OPTION_INLINES
:
4407 unwind_inlines
= TRUE
;
4410 if (strcmp (optarg
, "B") == 0)
4411 endian
= BFD_ENDIAN_BIG
;
4412 else if (strcmp (optarg
, "L") == 0)
4413 endian
= BFD_ENDIAN_LITTLE
;
4416 nonfatal (_("unrecognized -E option"));
4421 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
4422 endian
= BFD_ENDIAN_BIG
;
4423 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
4424 endian
= BFD_ENDIAN_LITTLE
;
4427 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
4434 dump_file_header
= TRUE
;
4438 formats_info
= TRUE
;
4442 add_include_path (optarg
);
4445 dump_private_headers
= TRUE
;
4449 dump_private_options
= optarg
;
4453 dump_private_headers
= TRUE
;
4455 dump_reloc_info
= TRUE
;
4456 dump_file_header
= TRUE
;
4457 dump_ar_hdrs
= TRUE
;
4458 dump_section_headers
= TRUE
;
4466 dump_dynamic_symtab
= TRUE
;
4472 disasm_sym
= optarg
;
4475 disassemble_zeroes
= TRUE
;
4479 disassemble_all
= TRUE
;
4484 with_source_code
= TRUE
;
4487 case OPTION_SOURCE_COMMENT
:
4489 with_source_code
= TRUE
;
4492 source_comment
= xstrdup (sanitize_string (optarg
));
4494 source_comment
= xstrdup ("# ");
4502 dump_debugging_tags
= 1;
4507 dump_dwarf_section_info
= TRUE
;
4510 dwarf_select_sections_by_letters (optarg
);
4512 dwarf_select_sections_all ();
4515 dump_dwarf_section_info
= TRUE
;
4518 dwarf_select_sections_by_names (optarg
);
4520 dwarf_select_sections_all ();
4522 case OPTION_DWARF_DEPTH
:
4525 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4528 case OPTION_DWARF_START
:
4531 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4532 suppress_bfd_header
= 1;
4535 case OPTION_DWARF_CHECK
:
4539 dump_ctf_section_info
= TRUE
;
4540 dump_ctf_section_name
= xstrdup (optarg
);
4543 case OPTION_CTF_PARENT
:
4544 dump_ctf_parent_name
= xstrdup (optarg
);
4547 dump_stab_section_info
= TRUE
;
4551 dump_section_contents
= TRUE
;
4555 dump_reloc_info
= TRUE
;
4559 dump_dynamic_reloc_info
= TRUE
;
4563 dump_ar_hdrs
= TRUE
;
4567 dump_section_headers
= TRUE
;
4572 show_version
= TRUE
;
4578 /* No need to set seenflag or to break - usage() does not return. */
4585 print_version ("objdump");
4591 exit_status
= display_info ();
4595 display_file ("a.out", target
, TRUE
);
4597 for (; optind
< argc
;)
4599 display_file (argv
[optind
], target
, optind
== argc
- 1);
4605 free (dump_ctf_section_name
);
4606 free (dump_ctf_parent_name
);
4607 free ((void *) source_comment
);
4609 END_PROGRESS (program_name
);