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_get_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_get_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
;
1998 distance_to_rel
= (**relppp
)->address
1999 - (rel_offset
+ addr_offset
);
2001 if (distance_to_rel
> 0
2002 && aux
->abfd
->arch_info
->max_reloc_offset_into_insn
<= distance_to_rel
)
2004 /* This reloc *might* apply to the current insn,
2005 starting somewhere inside it. Discover the length
2006 of the current insn so that the check below will
2009 insn_size
= insn_width
;
2012 /* We find the length by calling the dissassembler
2013 function with a dummy print handler. This should
2014 work unless the disassembler is not expecting to
2015 be called multiple times for the same address.
2017 This does mean disassembling the instruction
2018 twice, but we only do this when there is a high
2019 probability that there is a reloc that will
2020 affect the instruction. */
2021 inf
->fprintf_func
= (fprintf_ftype
) null_print
;
2022 insn_size
= disassemble_fn (section
->vma
2023 + addr_offset
, inf
);
2024 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2028 /* Check to see if the current reloc is associated with
2029 the instruction that we are about to disassemble. */
2030 if (distance_to_rel
== 0
2031 || (distance_to_rel
> 0
2032 && distance_to_rel
< (bfd_signed_vma
) (insn_size
/ opb
)))
2034 inf
->flags
|= INSN_HAS_RELOC
;
2035 aux
->reloc
= **relppp
;
2039 if (! disassemble_all
2040 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2041 == (SEC_CODE
| SEC_HAS_CONTENTS
))
2042 /* Set a stop_vma so that the disassembler will not read
2043 beyond the next symbol. We assume that symbols appear on
2044 the boundaries between instructions. We only do this when
2045 disassembling code of course, and when -D is in effect. */
2046 inf
->stop_vma
= section
->vma
+ stop_offset
;
2048 inf
->stop_offset
= stop_offset
;
2049 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2052 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2053 inf
->stream
= stdout
;
2054 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
2055 octets_per_line
= inf
->bytes_per_line
;
2056 if (octets
< (int) opb
)
2059 printf ("%s\n", sfile
.buffer
);
2062 non_fatal (_("disassemble_fn returned length %d"),
2073 octets
= octets_per_line
;
2074 if (addr_offset
+ octets
/ opb
> stop_offset
)
2075 octets
= (stop_offset
- addr_offset
) * opb
;
2077 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
2079 if (ISPRINT (data
[j
]))
2080 buf
[j
- addr_offset
* opb
] = data
[j
];
2082 buf
[j
- addr_offset
* opb
] = '.';
2084 buf
[j
- addr_offset
* opb
] = '\0';
2087 if (prefix_addresses
2089 : show_raw_insn
>= 0)
2093 /* If ! prefix_addresses and ! wide_output, we print
2094 octets_per_line octets per line. */
2096 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
2097 pb
= octets_per_line
;
2099 if (inf
->bytes_per_chunk
)
2100 bpc
= inf
->bytes_per_chunk
;
2104 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2106 /* PR 21580: Check for a buffer ending early. */
2107 if (j
+ bpc
<= stop_offset
* opb
)
2111 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2113 for (k
= bpc
- 1; k
>= 0; k
--)
2114 printf ("%02x", (unsigned) data
[j
+ k
]);
2118 for (k
= 0; k
< bpc
; k
++)
2119 printf ("%02x", (unsigned) data
[j
+ k
]);
2125 for (; pb
< octets_per_line
; pb
+= bpc
)
2129 for (k
= 0; k
< bpc
; k
++)
2134 /* Separate raw data from instruction by extra space. */
2144 printf ("%s", sfile
.buffer
);
2146 if (prefix_addresses
2148 : show_raw_insn
>= 0)
2156 j
= addr_offset
* opb
+ pb
;
2158 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
2159 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2163 printf ("%s:\t", buf
+ skip_addr_chars
);
2165 pb
+= octets_per_line
;
2168 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2170 /* PR 21619: Check for a buffer ending early. */
2171 if (j
+ bpc
<= stop_offset
* opb
)
2175 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2177 for (k
= bpc
- 1; k
>= 0; k
--)
2178 printf ("%02x", (unsigned) data
[j
+ k
]);
2182 for (k
= 0; k
< bpc
; k
++)
2183 printf ("%02x", (unsigned) data
[j
+ k
]);
2197 while ((*relppp
) < relppend
2198 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
2200 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
2211 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
2214 if (q
->howto
== NULL
)
2215 printf (": *unknown*\t");
2216 else if (q
->howto
->name
)
2217 printf (": %s\t", q
->howto
->name
);
2219 printf (": %d\t", q
->howto
->type
);
2221 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
2222 printf ("*unknown*");
2225 const char *sym_name
;
2227 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
2228 if (sym_name
!= NULL
&& *sym_name
!= '\0')
2229 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
2234 sym_sec
= bfd_get_section (*q
->sym_ptr_ptr
);
2235 sym_name
= bfd_get_section_name (aux
->abfd
, sym_sec
);
2236 if (sym_name
== NULL
|| *sym_name
== '\0')
2237 sym_name
= "*unknown*";
2238 printf ("%s", sanitize_string (sym_name
));
2244 bfd_signed_vma addend
= q
->addend
;
2252 objdump_print_value (addend
, inf
, TRUE
);
2264 addr_offset
+= octets
/ opb
;
2267 free (sfile
.buffer
);
2271 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
2273 const struct elf_backend_data
* bed
;
2274 bfd_vma sign_adjust
= 0;
2275 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
2276 struct objdump_disasm_info
* paux
;
2277 unsigned int opb
= pinfo
->octets_per_byte
;
2278 bfd_byte
* data
= NULL
;
2279 bfd_size_type datasize
= 0;
2280 arelent
** rel_pp
= NULL
;
2281 arelent
** rel_ppstart
= NULL
;
2282 arelent
** rel_ppend
;
2283 bfd_vma stop_offset
;
2284 asymbol
* sym
= NULL
;
2288 unsigned long addr_offset
;
2289 bfd_boolean do_print
;
2292 stop_offset_reached
,
2297 /* Sections that do not contain machine
2298 code are not normally disassembled. */
2299 if (! disassemble_all
2300 && only_list
== NULL
2301 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2302 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
2305 if (! process_section_p (section
))
2308 datasize
= bfd_get_section_size (section
);
2312 if (start_address
== (bfd_vma
) -1
2313 || start_address
< section
->vma
)
2316 addr_offset
= start_address
- section
->vma
;
2318 if (stop_address
== (bfd_vma
) -1)
2319 stop_offset
= datasize
/ opb
;
2322 if (stop_address
< section
->vma
)
2325 stop_offset
= stop_address
- section
->vma
;
2326 if (stop_offset
> datasize
/ opb
)
2327 stop_offset
= datasize
/ opb
;
2330 if (addr_offset
>= stop_offset
)
2333 /* Decide which set of relocs to use. Load them if necessary. */
2334 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
2335 if (paux
->dynrelbuf
&& dump_dynamic_reloc_info
)
2337 rel_pp
= paux
->dynrelbuf
;
2338 rel_count
= paux
->dynrelcount
;
2339 /* Dynamic reloc addresses are absolute, non-dynamic are section
2340 relative. REL_OFFSET specifies the reloc address corresponding
2341 to the start of this section. */
2342 rel_offset
= section
->vma
;
2350 if ((section
->flags
& SEC_RELOC
) != 0
2351 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
2355 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2357 bfd_fatal (bfd_get_filename (abfd
));
2361 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
2362 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
2364 bfd_fatal (bfd_get_filename (abfd
));
2366 /* Sort the relocs by address. */
2367 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
2371 rel_ppend
= rel_pp
+ rel_count
;
2373 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2375 non_fatal (_("Reading section %s failed because: %s"),
2376 section
->name
, bfd_errmsg (bfd_get_error ()));
2380 paux
->sec
= section
;
2381 pinfo
->buffer
= data
;
2382 pinfo
->buffer_vma
= section
->vma
;
2383 pinfo
->buffer_length
= datasize
;
2384 pinfo
->section
= section
;
2386 /* Skip over the relocs belonging to addresses below the
2388 while (rel_pp
< rel_ppend
2389 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
2392 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
2394 /* Find the nearest symbol forwards from our current position. */
2395 paux
->require_sec
= TRUE
;
2396 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
2397 (struct disassemble_info
*) inf
,
2399 paux
->require_sec
= FALSE
;
2401 /* PR 9774: If the target used signed addresses then we must make
2402 sure that we sign extend the value that we calculate for 'addr'
2403 in the loop below. */
2404 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2405 && (bed
= get_elf_backend_data (abfd
)) != NULL
2406 && bed
->sign_extend_vma
)
2407 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2409 /* Disassemble a block of instructions up to the address associated with
2410 the symbol we have just found. Then print the symbol and find the
2411 next symbol on. Repeat until we have disassembled the entire section
2412 or we have reached the end of the address range we are interested in. */
2413 do_print
= paux
->symbol
== NULL
;
2414 loop_until
= stop_offset_reached
;
2416 while (addr_offset
< stop_offset
)
2420 bfd_vma nextstop_offset
;
2423 addr
= section
->vma
+ addr_offset
;
2424 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2426 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2431 (x
< sorted_symcount
2432 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2436 pinfo
->symbols
= sorted_syms
+ place
;
2437 pinfo
->num_symbols
= x
- place
;
2438 pinfo
->symtab_pos
= place
;
2442 pinfo
->symbols
= NULL
;
2443 pinfo
->num_symbols
= 0;
2444 pinfo
->symtab_pos
= -1;
2447 /* If we are only disassembling from a specific symbol,
2448 check to see if we should start or stop displaying. */
2449 if (sym
&& paux
->symbol
)
2453 /* See if we should stop printing. */
2457 if (sym
->flags
& BSF_FUNCTION
)
2461 case stop_offset_reached
:
2462 /* Handled by the while loop. */
2466 /* FIXME: There is an implicit assumption here
2467 that the name of sym is different from
2469 if (! bfd_is_local_label (abfd
, sym
))
2476 const char * name
= bfd_asymbol_name (sym
);
2477 char * alloc
= NULL
;
2479 if (do_demangle
&& name
[0] != '\0')
2481 /* Demangle the name. */
2482 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
2487 /* We are not currently printing. Check to see
2488 if the current symbol matches the requested symbol. */
2489 if (streq (name
, paux
->symbol
))
2493 if (sym
->flags
& BSF_FUNCTION
)
2495 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2496 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
2498 /* Sym is a function symbol with a size associated
2499 with it. Turn on automatic disassembly for the
2500 next VALUE bytes. */
2501 stop_offset
= addr_offset
2502 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
2503 loop_until
= stop_offset_reached
;
2507 /* Otherwise we need to tell the loop heuristic to
2508 loop until the next function symbol is encountered. */
2509 loop_until
= function_sym
;
2514 /* Otherwise loop until the next symbol is encountered. */
2515 loop_until
= next_sym
;
2523 if (! prefix_addresses
&& do_print
)
2525 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2526 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2528 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2531 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2533 else if (sym
== NULL
)
2537 #define is_valid_next_sym(SYM) \
2538 (strcmp (bfd_section_name (abfd, (SYM)->section), bfd_section_name (abfd, section)) == 0 \
2539 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2540 && pinfo->symbol_is_valid (SYM, pinfo))
2542 /* Search forward for the next appropriate symbol in
2543 SECTION. Note that all the symbols are sorted
2544 together into one big array, and that some sections
2545 may have overlapping addresses. */
2546 while (place
< sorted_symcount
2547 && ! is_valid_next_sym (sorted_syms
[place
]))
2550 if (place
>= sorted_symcount
)
2553 nextsym
= sorted_syms
[place
];
2556 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2557 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2558 else if (nextsym
== NULL
)
2559 nextstop_offset
= stop_offset
;
2561 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2563 if (nextstop_offset
> stop_offset
2564 || nextstop_offset
<= addr_offset
)
2565 nextstop_offset
= stop_offset
;
2567 /* If a symbol is explicitly marked as being an object
2568 rather than a function, just dump the bytes without
2569 disassembling them. */
2572 || sym
->section
!= section
2573 || bfd_asymbol_value (sym
) > addr
2574 || ((sym
->flags
& BSF_OBJECT
) == 0
2575 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2577 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2579 || (sym
->flags
& BSF_FUNCTION
) != 0)
2585 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2586 addr_offset
, nextstop_offset
,
2587 rel_offset
, &rel_pp
, rel_ppend
);
2589 addr_offset
= nextstop_offset
;
2595 if (rel_ppstart
!= NULL
)
2599 /* Disassemble the contents of an object file. */
2602 disassemble_data (bfd
*abfd
)
2604 struct disassemble_info disasm_info
;
2605 struct objdump_disasm_info aux
;
2609 prev_functionname
= NULL
;
2611 prev_discriminator
= 0;
2613 /* We make a copy of syms to sort. We don't want to sort syms
2614 because that will screw up the relocs. */
2615 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2616 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2617 * sizeof (asymbol
*));
2618 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2619 sorted_symcount
* sizeof (asymbol
*));
2621 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2623 for (i
= 0; i
< synthcount
; ++i
)
2625 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2629 /* Sort the symbols into section and symbol order. */
2630 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2632 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2634 disasm_info
.application_data
= (void *) &aux
;
2636 aux
.require_sec
= FALSE
;
2637 aux
.dynrelbuf
= NULL
;
2638 aux
.dynrelcount
= 0;
2640 aux
.symbol
= disasm_sym
;
2642 disasm_info
.print_address_func
= objdump_print_address
;
2643 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2645 if (machine
!= NULL
)
2647 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2650 fatal (_("can't use supplied machine %s"), machine
);
2652 abfd
->arch_info
= inf
;
2655 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2657 struct bfd_target
*xvec
;
2659 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2660 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2661 xvec
->byteorder
= endian
;
2665 /* Use libopcodes to locate a suitable disassembler. */
2666 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
2667 bfd_big_endian (abfd
),
2668 bfd_get_mach (abfd
), abfd
);
2669 if (!aux
.disassemble_fn
)
2671 non_fatal (_("can't disassemble for architecture %s\n"),
2672 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2677 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2678 disasm_info
.arch
= bfd_get_arch (abfd
);
2679 disasm_info
.mach
= bfd_get_mach (abfd
);
2680 disasm_info
.disassembler_options
= disassembler_options
;
2681 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2682 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2683 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2684 disasm_info
.disassembler_needs_relocs
= FALSE
;
2686 if (bfd_big_endian (abfd
))
2687 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2688 else if (bfd_little_endian (abfd
))
2689 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2691 /* ??? Aborting here seems too drastic. We could default to big or little
2693 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2695 /* Allow the target to customize the info structure. */
2696 disassemble_init_for_target (& disasm_info
);
2698 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
2700 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2702 if (relsize
< 0 && dump_dynamic_reloc_info
)
2703 bfd_fatal (bfd_get_filename (abfd
));
2707 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2708 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2711 if (aux
.dynrelcount
< 0)
2712 bfd_fatal (bfd_get_filename (abfd
));
2714 /* Sort the relocs by address. */
2715 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2719 disasm_info
.symtab
= sorted_syms
;
2720 disasm_info
.symtab_size
= sorted_symcount
;
2722 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2724 if (aux
.dynrelbuf
!= NULL
)
2725 free (aux
.dynrelbuf
);
2730 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2731 asection
*sec
, void *file
)
2733 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2734 bfd
*abfd
= (bfd
*) file
;
2739 if (section
->start
!= NULL
)
2741 /* If it is already loaded, do nothing. */
2742 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2744 free (section
->start
);
2747 section
->filename
= bfd_get_filename (abfd
);
2748 section
->reloc_info
= NULL
;
2749 section
->num_relocs
= 0;
2750 section
->address
= bfd_get_section_vma (abfd
, sec
);
2751 section
->user_data
= sec
;
2752 section
->size
= bfd_get_section_size (sec
);
2753 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
2754 alloced
= amt
= section
->size
+ 1;
2755 if (alloced
!= amt
|| alloced
== 0)
2757 section
->start
= NULL
;
2758 free_debug_section (debug
);
2759 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
2760 sanitize_string (section
->name
),
2761 (unsigned long long) section
->size
);
2764 section
->start
= contents
= malloc (alloced
);
2765 if (section
->start
== NULL
2766 || !bfd_get_full_section_contents (abfd
, sec
, &contents
))
2768 free_debug_section (debug
);
2769 printf (_("\nCan't get contents for section '%s'.\n"),
2770 sanitize_string (section
->name
));
2773 /* Ensure any string section has a terminating NUL. */
2774 section
->start
[section
->size
] = 0;
2776 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
2777 && debug_displays
[debug
].relocate
)
2782 bfd_cache_section_contents (sec
, section
->start
);
2784 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2791 free_debug_section (debug
);
2792 printf (_("\nCan't get contents for section '%s'.\n"),
2793 sanitize_string (section
->name
));
2797 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
2800 unsigned long reloc_count
;
2803 relocs
= (arelent
**) xmalloc (reloc_size
);
2805 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
2806 if (reloc_count
== 0)
2810 section
->reloc_info
= relocs
;
2811 section
->num_relocs
= reloc_count
;
2820 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
2825 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
2828 relocs
= (arelent
**) dsec
->reloc_info
;
2830 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
2831 if (rp
->address
== offset
)
2838 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2840 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2841 bfd
*abfd
= (bfd
*) file
;
2844 /* If it is already loaded, do nothing. */
2845 if (section
->start
!= NULL
)
2847 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2851 /* Locate the debug section. */
2852 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2854 section
->name
= section
->uncompressed_name
;
2857 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2859 section
->name
= section
->compressed_name
;
2864 return load_specific_debug_section (debug
, sec
, file
);
2868 free_debug_section (enum dwarf_section_display_enum debug
)
2870 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2872 if (section
->start
== NULL
)
2875 /* PR 17512: file: 0f67f69d. */
2876 if (section
->user_data
!= NULL
)
2878 asection
* sec
= (asection
*) section
->user_data
;
2880 /* If we are freeing contents that are also pointed to by the BFD
2881 library's section structure then make sure to update those pointers
2882 too. Otherwise, the next time we try to load data for this section
2883 we can end up using a stale pointer. */
2884 if (section
->start
== sec
->contents
)
2886 sec
->contents
= NULL
;
2887 sec
->flags
&= ~ SEC_IN_MEMORY
;
2888 sec
->compress_status
= COMPRESS_SECTION_NONE
;
2892 free ((char *) section
->start
);
2893 section
->start
= NULL
;
2894 section
->address
= 0;
2899 close_debug_file (void * file
)
2901 bfd
* abfd
= (bfd
*) file
;
2907 open_debug_file (const char * pathname
)
2911 data
= bfd_openr (pathname
, NULL
);
2915 if (! bfd_check_format (data
, bfd_object
))
2922 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2923 void *arg ATTRIBUTE_UNUSED
)
2925 const char *name
= bfd_get_section_name (abfd
, section
);
2929 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2930 match
= ".debug_info";
2934 for (i
= 0; i
< max
; i
++)
2935 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2936 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2937 && debug_displays
[i
].enabled
!= NULL
2938 && *debug_displays
[i
].enabled
)
2940 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2942 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2943 sec
->name
= sec
->uncompressed_name
;
2945 sec
->name
= sec
->compressed_name
;
2946 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2949 debug_displays
[i
].display (sec
, abfd
);
2951 if (i
!= info
&& i
!= abbrev
)
2952 free_debug_section ((enum dwarf_section_display_enum
) i
);
2958 /* Dump the dwarf debugging information. */
2961 dump_dwarf (bfd
*abfd
)
2963 /* The byte_get pointer should have been set at the start of dump_bfd(). */
2964 if (byte_get
== NULL
)
2966 warn (_("File %s does not contain any dwarf debug information\n"),
2967 bfd_get_filename (abfd
));
2971 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2973 switch (bfd_get_arch (abfd
))
2976 switch (bfd_get_mach (abfd
))
2978 case bfd_mach_x86_64
:
2979 case bfd_mach_x86_64_intel_syntax
:
2980 case bfd_mach_x86_64_nacl
:
2981 case bfd_mach_x64_32
:
2982 case bfd_mach_x64_32_intel_syntax
:
2983 case bfd_mach_x64_32_nacl
:
2984 init_dwarf_regnames_x86_64 ();
2988 init_dwarf_regnames_i386 ();
2993 case bfd_arch_iamcu
:
2994 init_dwarf_regnames_iamcu ();
2997 case bfd_arch_aarch64
:
2998 init_dwarf_regnames_aarch64();
3002 init_dwarf_regnames_s390 ();
3005 case bfd_arch_riscv
:
3006 init_dwarf_regnames_riscv ();
3010 /* S12Z has a 24 bit address space. But the only known
3011 producer of dwarf_info encodes addresses into 32 bits. */
3019 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
3022 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
3023 it. Return NULL on failure. */
3026 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
3027 bfd_size_type
*entsize_ptr
)
3032 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
3033 if (stabsect
== NULL
)
3035 printf (_("No %s section present\n\n"),
3036 sanitize_string (sect_name
));
3040 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
3042 non_fatal (_("reading %s section of %s failed: %s"),
3043 sect_name
, bfd_get_filename (abfd
),
3044 bfd_errmsg (bfd_get_error ()));
3050 *size_ptr
= bfd_section_size (abfd
, stabsect
);
3052 *entsize_ptr
= stabsect
->entsize
;
3057 /* Stabs entries use a 12 byte format:
3058 4 byte string table index
3060 1 byte stab other field
3061 2 byte stab desc field
3063 FIXME: This will have to change for a 64 bit object format. */
3065 #define STRDXOFF (0)
3067 #define OTHEROFF (5)
3070 #define STABSIZE (12)
3072 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3073 using string table section STRSECT_NAME (in `strtab'). */
3076 print_section_stabs (bfd
*abfd
,
3077 const char *stabsect_name
,
3078 unsigned *string_offset_ptr
)
3081 unsigned file_string_table_offset
= 0;
3082 unsigned next_file_string_table_offset
= *string_offset_ptr
;
3083 bfd_byte
*stabp
, *stabs_end
;
3086 stabs_end
= stabp
+ stab_size
;
3088 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
3089 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3091 /* Loop through all symbols and print them.
3093 We start the index at -1 because there is a dummy symbol on
3094 the front of stabs-in-{coff,elf} sections that supplies sizes. */
3095 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
3099 unsigned char type
, other
;
3100 unsigned short desc
;
3103 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
3104 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
3105 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
3106 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
3107 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
3109 printf ("\n%-6d ", i
);
3110 /* Either print the stab name, or, if unnamed, print its number
3111 again (makes consistent formatting for tools like awk). */
3112 name
= bfd_get_stab_name (type
);
3114 printf ("%-6s", sanitize_string (name
));
3115 else if (type
== N_UNDF
)
3118 printf ("%-6d", type
);
3119 printf (" %-6d %-6d ", other
, desc
);
3120 bfd_printf_vma (abfd
, value
);
3121 printf (" %-6lu", strx
);
3123 /* Symbols with type == 0 (N_UNDF) specify the length of the
3124 string table associated with this file. We use that info
3125 to know how to relocate the *next* file's string table indices. */
3128 file_string_table_offset
= next_file_string_table_offset
;
3129 next_file_string_table_offset
+= value
;
3133 bfd_size_type amt
= strx
+ file_string_table_offset
;
3135 /* Using the (possibly updated) string table offset, print the
3136 string (if any) associated with this symbol. */
3137 if (amt
< stabstr_size
)
3138 /* PR 17512: file: 079-79389-0.001:0.1.
3139 FIXME: May need to sanitize this string before displaying. */
3140 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
3146 *string_offset_ptr
= next_file_string_table_offset
;
3151 const char * section_name
;
3152 const char * string_section_name
;
3153 unsigned string_offset
;
3158 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
3161 stab_section_names
* sought
= (stab_section_names
*) names
;
3163 /* Check for section names for which stabsect_name is a prefix, to
3164 handle .stab.N, etc. */
3165 len
= strlen (sought
->section_name
);
3167 /* If the prefix matches, and the files section name ends with a
3168 nul or a digit, then we match. I.e., we want either an exact
3169 match or a section followed by a number. */
3170 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
3171 && (section
->name
[len
] == 0
3172 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
3175 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
3176 &stabstr_size
, NULL
);
3180 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
, NULL
);
3182 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
3188 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
3190 stab_section_names s
;
3192 s
.section_name
= stabsect_name
;
3193 s
.string_section_name
= strsect_name
;
3194 s
.string_offset
= 0;
3196 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
3202 /* Dump the any sections containing stabs debugging information. */
3205 dump_stabs (bfd
*abfd
)
3207 dump_stabs_section (abfd
, ".stab", ".stabstr");
3208 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
3209 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
3212 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3214 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3218 dump_bfd_header (bfd
*abfd
)
3222 printf (_("architecture: %s, "),
3223 bfd_printable_arch_mach (bfd_get_arch (abfd
),
3224 bfd_get_mach (abfd
)));
3225 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
3227 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
3228 PF (HAS_RELOC
, "HAS_RELOC");
3229 PF (EXEC_P
, "EXEC_P");
3230 PF (HAS_LINENO
, "HAS_LINENO");
3231 PF (HAS_DEBUG
, "HAS_DEBUG");
3232 PF (HAS_SYMS
, "HAS_SYMS");
3233 PF (HAS_LOCALS
, "HAS_LOCALS");
3234 PF (DYNAMIC
, "DYNAMIC");
3235 PF (WP_TEXT
, "WP_TEXT");
3236 PF (D_PAGED
, "D_PAGED");
3237 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
3238 printf (_("\nstart address 0x"));
3239 bfd_printf_vma (abfd
, abfd
->start_address
);
3244 /* Formatting callback function passed to ctf_dump. Returns either the pointer
3245 it is passed, or a pointer to newly-allocated storage, in which case
3246 dump_ctf() will free it when it no longer needs it. */
3249 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
3252 const char *blanks
= arg
;
3255 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
3260 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
3262 make_ctfsect (const char *name
, bfd_byte
*data
,
3267 ctfsect
.cts_name
= name
;
3268 ctfsect
.cts_entsize
= 1;
3269 ctfsect
.cts_size
= size
;
3270 ctfsect
.cts_data
= data
;
3275 /* Dump one CTF archive member. */
3278 dump_ctf_archive_member (ctf_file_t
*ctf
, const char *name
, void *arg
)
3280 ctf_file_t
*parent
= (ctf_file_t
*) arg
;
3281 const char *things
[] = {"Labels", "Data objects", "Function objects",
3282 "Variables", "Types", "Strings", ""};
3286 /* Only print out the name of non-default-named archive members.
3287 The name .ctf appears everywhere, even for things that aren't
3288 really archives, so printing it out is liable to be confusing. */
3289 if (strcmp (name
, ".ctf") != 0)
3290 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name
));
3292 ctf_import (ctf
, parent
);
3293 for (i
= 1, thing
= things
; *thing
[0]; thing
++, i
++)
3295 ctf_dump_state_t
*s
= NULL
;
3298 printf ("\n %s:\n", *thing
);
3299 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
3300 (void *) " ")) != NULL
)
3302 printf ("%s\n", item
);
3306 if (ctf_errno (ctf
))
3308 non_fatal (_("Iteration failed: %s, %s\n"), *thing
,
3309 ctf_errmsg (ctf_errno (ctf
)));
3316 /* Dump the CTF debugging information. */
3319 dump_ctf (bfd
*abfd
, const char *sect_name
, const char *parent_name
)
3321 ctf_archive_t
*ctfa
, *parenta
= NULL
;
3322 bfd_byte
*ctfdata
, *parentdata
= NULL
;
3323 bfd_size_type ctfsize
, parentsize
;
3325 ctf_file_t
*parent
= NULL
;
3328 if ((ctfdata
= read_section_stabs (abfd
, sect_name
, &ctfsize
, NULL
)) == NULL
)
3329 bfd_fatal (bfd_get_filename (abfd
));
3332 && (parentdata
= read_section_stabs (abfd
, parent_name
, &parentsize
,
3334 bfd_fatal (bfd_get_filename (abfd
));
3336 /* Load the CTF file and dump it. */
3338 ctfsect
= make_ctfsect (sect_name
, ctfdata
, ctfsize
);
3339 if ((ctfa
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
3341 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3342 bfd_fatal (bfd_get_filename (abfd
));
3347 ctfsect
= make_ctfsect (parent_name
, parentdata
, parentsize
);
3348 if ((parenta
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
3350 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3351 bfd_fatal (bfd_get_filename (abfd
));
3354 /* Assume that the applicable parent archive member is the default one.
3355 (This is what all known implementations are expected to do, if they
3356 put CTFs and their parents in archives together.) */
3357 if ((parent
= ctf_arc_open_by_name (parenta
, NULL
, &err
)) == NULL
)
3359 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3360 bfd_fatal (bfd_get_filename (abfd
));
3364 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name
));
3366 ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
);
3367 ctf_file_close (parent
);
3369 ctf_close (parenta
);
3376 dump_bfd_private_header (bfd
*abfd
)
3378 if (!bfd_print_private_bfd_data (abfd
, stdout
))
3379 non_fatal (_("warning: private headers incomplete: %s"),
3380 bfd_errmsg (bfd_get_error ()));
3384 dump_target_specific (bfd
*abfd
)
3386 const struct objdump_private_desc
* const *desc
;
3387 struct objdump_private_option
*opt
;
3390 /* Find the desc. */
3391 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
3392 if ((*desc
)->filter (abfd
))
3397 non_fatal (_("option -P/--private not supported by this file"));
3401 /* Clear all options. */
3402 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3403 opt
->selected
= FALSE
;
3405 /* Decode options. */
3406 b
= dump_private_options
;
3409 e
= strchr (b
, ',');
3414 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3415 if (strcmp (opt
->name
, b
) == 0)
3417 opt
->selected
= TRUE
;
3420 if (opt
->name
== NULL
)
3421 non_fatal (_("target specific dump '%s' not supported"), b
);
3432 (*desc
)->dump (abfd
);
3435 /* Display a section in hexadecimal format with associated characters.
3436 Each line prefixed by the zero padded address. */
3439 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
3441 bfd_byte
*data
= NULL
;
3442 bfd_size_type datasize
;
3443 bfd_vma addr_offset
;
3444 bfd_vma start_offset
;
3445 bfd_vma stop_offset
;
3446 unsigned int opb
= bfd_octets_per_byte (abfd
);
3447 /* Bytes per line. */
3448 const int onaline
= 16;
3453 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
3456 if (! process_section_p (section
))
3459 if ((datasize
= bfd_section_size (abfd
, section
)) == 0)
3462 /* Compute the address range to display. */
3463 if (start_address
== (bfd_vma
) -1
3464 || start_address
< section
->vma
)
3467 start_offset
= start_address
- section
->vma
;
3469 if (stop_address
== (bfd_vma
) -1)
3470 stop_offset
= datasize
/ opb
;
3473 if (stop_address
< section
->vma
)
3476 stop_offset
= stop_address
- section
->vma
;
3478 if (stop_offset
> datasize
/ opb
)
3479 stop_offset
= datasize
/ opb
;
3482 if (start_offset
>= stop_offset
)
3485 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
3486 if (display_file_offsets
)
3487 printf (_(" (Starting at file offset: 0x%lx)"),
3488 (unsigned long) (section
->filepos
+ start_offset
));
3491 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
3493 non_fatal (_("Reading section %s failed because: %s"),
3494 section
->name
, bfd_errmsg (bfd_get_error ()));
3500 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
3501 if (strlen (buf
) >= sizeof (buf
))
3505 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3507 count
= strlen (buf
) - count
;
3511 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
3512 if (strlen (buf
) >= sizeof (buf
))
3516 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3518 count
= strlen (buf
) - count
;
3522 for (addr_offset
= start_offset
;
3523 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
3527 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
3528 count
= strlen (buf
);
3529 if ((size_t) count
>= sizeof (buf
))
3533 while (count
< width
)
3538 fputs (buf
+ count
- width
, stdout
);
3541 for (j
= addr_offset
* opb
;
3542 j
< addr_offset
* opb
+ onaline
; j
++)
3544 if (j
< stop_offset
* opb
)
3545 printf ("%02x", (unsigned) (data
[j
]));
3553 for (j
= addr_offset
* opb
;
3554 j
< addr_offset
* opb
+ onaline
; j
++)
3556 if (j
>= stop_offset
* opb
)
3559 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
3566 /* Actually display the various requested regions. */
3569 dump_data (bfd
*abfd
)
3571 bfd_map_over_sections (abfd
, dump_section
, NULL
);
3574 /* Should perhaps share code and display with nm? */
3577 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
3586 max_count
= dynsymcount
;
3587 printf ("DYNAMIC SYMBOL TABLE:\n");
3592 max_count
= symcount
;
3593 printf ("SYMBOL TABLE:\n");
3597 printf (_("no symbols\n"));
3599 for (count
= 0; count
< max_count
; count
++)
3603 if (*current
== NULL
)
3604 printf (_("no information for symbol number %ld\n"), count
);
3606 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
3607 printf (_("could not determine the type of symbol number %ld\n"),
3610 else if (process_section_p ((* current
)->section
)
3611 && (dump_special_syms
3612 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
3614 const char *name
= (*current
)->name
;
3616 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
3620 /* If we want to demangle the name, we demangle it
3621 here, and temporarily clobber it while calling
3622 bfd_print_symbol. FIXME: This is a gross hack. */
3623 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
3625 (*current
)->name
= alloc
;
3626 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3627 bfd_print_symbol_all
);
3630 (*current
)->name
= name
;
3635 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3636 bfd_print_symbol_all
);
3646 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
3649 char *last_filename
, *last_functionname
;
3650 unsigned int last_line
;
3651 unsigned int last_discriminator
;
3653 /* Get column headers lined up reasonably. */
3661 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
3662 width
= strlen (buf
) - 7;
3664 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
3667 last_filename
= NULL
;
3668 last_functionname
= NULL
;
3670 last_discriminator
= 0;
3672 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
3675 const char *filename
, *functionname
;
3676 unsigned int linenumber
;
3677 unsigned int discriminator
;
3678 const char *sym_name
;
3679 const char *section_name
;
3680 bfd_vma addend2
= 0;
3682 if (start_address
!= (bfd_vma
) -1
3683 && q
->address
< start_address
)
3685 if (stop_address
!= (bfd_vma
) -1
3686 && q
->address
> stop_address
)
3689 if (with_line_numbers
3691 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
3692 &filename
, &functionname
,
3693 &linenumber
, &discriminator
))
3695 if (functionname
!= NULL
3696 && (last_functionname
== NULL
3697 || strcmp (functionname
, last_functionname
) != 0))
3699 printf ("%s():\n", sanitize_string (functionname
));
3700 if (last_functionname
!= NULL
)
3701 free (last_functionname
);
3702 last_functionname
= xstrdup (functionname
);
3706 && (linenumber
!= last_line
3707 || (filename
!= NULL
3708 && last_filename
!= NULL
3709 && filename_cmp (filename
, last_filename
) != 0)
3710 || (discriminator
!= last_discriminator
)))
3712 if (discriminator
> 0)
3713 printf ("%s:%u\n", filename
== NULL
? "???" :
3714 sanitize_string (filename
), linenumber
);
3716 printf ("%s:%u (discriminator %u)\n",
3717 filename
== NULL
? "???" : sanitize_string (filename
),
3718 linenumber
, discriminator
);
3719 last_line
= linenumber
;
3720 last_discriminator
= discriminator
;
3721 if (last_filename
!= NULL
)
3722 free (last_filename
);
3723 if (filename
== NULL
)
3724 last_filename
= NULL
;
3726 last_filename
= xstrdup (filename
);
3730 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
3732 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
3733 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
3738 section_name
= NULL
;
3741 bfd_printf_vma (abfd
, q
->address
);
3742 if (q
->howto
== NULL
)
3743 printf (" *unknown* ");
3744 else if (q
->howto
->name
)
3746 const char *name
= q
->howto
->name
;
3748 /* R_SPARC_OLO10 relocations contain two addends.
3749 But because 'arelent' lacks enough storage to
3750 store them both, the 64-bit ELF Sparc backend
3751 records this as two relocations. One R_SPARC_LO10
3752 and one R_SPARC_13, both pointing to the same
3753 address. This is merely so that we have some
3754 place to store both addend fields.
3756 Undo this transformation, otherwise the output
3757 will be confusing. */
3758 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3759 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3761 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3763 arelent
*q2
= *(p
+ 1);
3766 && q
->address
== q2
->address
3767 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3769 name
= "R_SPARC_OLO10";
3770 addend2
= q2
->addend
;
3774 printf (" %-16s ", name
);
3777 printf (" %-16d ", q
->howto
->type
);
3781 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3785 if (section_name
== NULL
)
3786 section_name
= "*unknown*";
3787 printf ("[%s]", sanitize_string (section_name
));
3792 bfd_signed_vma addend
= q
->addend
;
3800 bfd_printf_vma (abfd
, addend
);
3805 bfd_printf_vma (abfd
, addend2
);
3811 if (last_filename
!= NULL
)
3812 free (last_filename
);
3813 if (last_functionname
!= NULL
)
3814 free (last_functionname
);
3818 dump_relocs_in_section (bfd
*abfd
,
3820 void *dummy ATTRIBUTE_UNUSED
)
3822 arelent
**relpp
= NULL
;
3826 if ( bfd_is_abs_section (section
)
3827 || bfd_is_und_section (section
)
3828 || bfd_is_com_section (section
)
3829 || (! process_section_p (section
))
3830 || ((section
->flags
& SEC_RELOC
) == 0))
3833 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
3835 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3838 printf (" (none)\n\n");
3846 relpp
= (arelent
**) xmalloc (relsize
);
3847 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3853 non_fatal (_("failed to read relocs in: %s"),
3854 sanitize_string (bfd_get_filename (abfd
)));
3855 bfd_fatal (_("error message was"));
3857 else if (relcount
== 0)
3858 printf (" (none)\n\n");
3862 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3869 dump_relocs (bfd
*abfd
)
3871 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3875 dump_dynamic_relocs (bfd
*abfd
)
3881 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3883 bfd_fatal (bfd_get_filename (abfd
));
3885 printf ("DYNAMIC RELOCATION RECORDS");
3888 printf (" (none)\n\n");
3891 relpp
= (arelent
**) xmalloc (relsize
);
3892 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3895 bfd_fatal (bfd_get_filename (abfd
));
3896 else if (relcount
== 0)
3897 printf (" (none)\n\n");
3901 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3908 /* Creates a table of paths, to search for source files. */
3911 add_include_path (const char *path
)
3915 include_path_count
++;
3916 include_paths
= (const char **)
3917 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3918 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3919 if (path
[1] == ':' && path
[2] == 0)
3920 path
= concat (path
, ".", (const char *) 0);
3922 include_paths
[include_path_count
- 1] = path
;
3926 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3930 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3932 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3933 section
->vma
+= adjust_section_vma
;
3935 section
->lma
+= adjust_section_vma
;
3939 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
3942 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
3947 mask
= (bfd_vma
) 1 << (arch_size
- 1);
3948 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
3951 /* Dump selected contents of ABFD. */
3954 dump_bfd (bfd
*abfd
, bfd_boolean is_mainfile
)
3956 const struct elf_backend_data
* bed
;
3958 if (bfd_big_endian (abfd
))
3959 byte_get
= byte_get_big_endian
;
3960 else if (bfd_little_endian (abfd
))
3961 byte_get
= byte_get_little_endian
;
3965 /* Load any separate debug information files.
3966 We do this now and without checking do_follow_links because separate
3967 debug info files may contain symbol tables that we will need when
3968 displaying information about the main file. Any memory allocated by
3969 load_separate_debug_files will be released when we call
3970 free_debug_memory below.
3972 The test on is_mainfile is there because the chain of separate debug
3973 info files is a global variable shared by all invocations of dump_bfd. */
3976 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
3978 /* If asked to do so, recursively dump the separate files. */
3979 if (do_follow_links
)
3983 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3984 dump_bfd (i
->handle
, FALSE
);
3988 /* Adjust user-specified start and stop limits for targets that use
3989 signed addresses. */
3990 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3991 && (bed
= get_elf_backend_data (abfd
)) != NULL
3992 && bed
->sign_extend_vma
)
3994 start_address
= sign_extend_address (abfd
, start_address
,
3996 stop_address
= sign_extend_address (abfd
, stop_address
,
4000 /* If we are adjusting section VMA's, change them all now. Changing
4001 the BFD information is a hack. However, we must do it, or
4002 bfd_find_nearest_line will not do the right thing. */
4003 if (adjust_section_vma
!= 0)
4005 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
4006 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
4009 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4010 printf (_("\n%s: file format %s\n"),
4011 sanitize_string (bfd_get_filename (abfd
)),
4014 print_arelt_descr (stdout
, abfd
, TRUE
, FALSE
);
4015 if (dump_file_header
)
4016 dump_bfd_header (abfd
);
4017 if (dump_private_headers
)
4018 dump_bfd_private_header (abfd
);
4019 if (dump_private_options
!= NULL
)
4020 dump_target_specific (abfd
);
4021 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4028 || dump_dwarf_section_info
)
4030 syms
= slurp_symtab (abfd
);
4032 /* If following links, load any symbol tables from the linked files as well. */
4033 if (do_follow_links
&& is_mainfile
)
4037 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4039 asymbol
** extra_syms
;
4040 long old_symcount
= symcount
;
4042 extra_syms
= slurp_symtab (i
->handle
);
4046 if (old_symcount
== 0)
4052 syms
= xrealloc (syms
, (symcount
+ old_symcount
) * sizeof (asymbol
*));
4053 memcpy (syms
+ old_symcount
,
4055 symcount
* sizeof (asymbol
*));
4059 symcount
+= old_symcount
;
4064 if (dump_section_headers
)
4065 dump_headers (abfd
);
4067 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
4068 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
4069 dynsyms
= slurp_dynamic_symtab (abfd
);
4073 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
4074 dynsymcount
, dynsyms
, &synthsyms
);
4080 dump_symbols (abfd
, FALSE
);
4081 if (dump_dynamic_symtab
)
4082 dump_symbols (abfd
, TRUE
);
4083 if (dump_dwarf_section_info
)
4085 if (dump_ctf_section_info
)
4086 dump_ctf (abfd
, dump_ctf_section_name
, dump_ctf_parent_name
);
4087 if (dump_stab_section_info
)
4089 if (dump_reloc_info
&& ! disassemble
)
4091 if (dump_dynamic_reloc_info
&& ! disassemble
)
4092 dump_dynamic_relocs (abfd
);
4093 if (dump_section_contents
)
4096 disassemble_data (abfd
);
4102 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
4103 if (dhandle
!= NULL
)
4105 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
4107 dump_debugging_tags
? TRUE
: FALSE
))
4109 non_fatal (_("%s: printing debugging information failed"),
4110 bfd_get_filename (abfd
));
4116 /* PR 6483: If there was no STABS debug info in the file, try
4118 else if (! dump_dwarf_section_info
)
4120 dwarf_select_sections_all ();
4148 free_debug_memory ();
4152 display_object_bfd (bfd
*abfd
)
4156 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
4158 dump_bfd (abfd
, TRUE
);
4162 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4164 nonfatal (bfd_get_filename (abfd
));
4165 list_matching_formats (matching
);
4170 if (bfd_get_error () != bfd_error_file_not_recognized
)
4172 nonfatal (bfd_get_filename (abfd
));
4176 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
4178 dump_bfd (abfd
, TRUE
);
4182 nonfatal (bfd_get_filename (abfd
));
4184 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4186 list_matching_formats (matching
);
4192 display_any_bfd (bfd
*file
, int level
)
4194 /* Decompress sections unless dumping the section contents. */
4195 if (!dump_section_contents
)
4196 file
->flags
|= BFD_DECOMPRESS
;
4198 /* If the file is an archive, process all of its elements. */
4199 if (bfd_check_format (file
, bfd_archive
))
4202 bfd
*last_arfile
= NULL
;
4205 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
4206 else if (level
> 100)
4208 /* Prevent corrupted files from spinning us into an
4209 infinite loop. 100 is an arbitrary heuristic. */
4210 fatal (_("Archive nesting is too deep"));
4214 printf (_("In nested archive %s:\n"),
4215 sanitize_string (bfd_get_filename (file
)));
4219 bfd_set_error (bfd_error_no_error
);
4221 arfile
= bfd_openr_next_archived_file (file
, arfile
);
4224 if (bfd_get_error () != bfd_error_no_more_archived_files
)
4225 nonfatal (bfd_get_filename (file
));
4229 display_any_bfd (arfile
, level
+ 1);
4231 if (last_arfile
!= NULL
)
4233 bfd_close (last_arfile
);
4234 /* PR 17512: file: ac585d01. */
4235 if (arfile
== last_arfile
)
4241 last_arfile
= arfile
;
4244 if (last_arfile
!= NULL
)
4245 bfd_close (last_arfile
);
4248 display_object_bfd (file
);
4252 display_file (char *filename
, char *target
, bfd_boolean last_file
)
4256 if (get_file_size (filename
) < 1)
4262 file
= bfd_openr (filename
, target
);
4265 nonfatal (filename
);
4269 display_any_bfd (file
, 0);
4271 /* This is an optimization to improve the speed of objdump, especially when
4272 dumping a file with lots of associated debug informatiom. Calling
4273 bfd_close on such a file can take a non-trivial amount of time as there
4274 are lots of lists to walk and buffers to free. This is only really
4275 necessary however if we are about to load another file and we need the
4276 memory back. Otherwise, if we are about to exit, then we can save (a lot
4277 of) time by only doing a quick close, and allowing the OS to reclaim the
4282 bfd_close_all_done (file
);
4286 main (int argc
, char **argv
)
4289 char *target
= default_target
;
4290 bfd_boolean seenflag
= FALSE
;
4292 #if defined (HAVE_SETLOCALE)
4293 #if defined (HAVE_LC_MESSAGES)
4294 setlocale (LC_MESSAGES
, "");
4296 setlocale (LC_CTYPE
, "");
4299 bindtextdomain (PACKAGE
, LOCALEDIR
);
4300 textdomain (PACKAGE
);
4302 program_name
= *argv
;
4303 xmalloc_set_program_name (program_name
);
4304 bfd_set_error_program_name (program_name
);
4306 START_PROGRESS (program_name
, 0);
4308 expandargv (&argc
, &argv
);
4310 if (bfd_init () != BFD_INIT_MAGIC
)
4311 fatal (_("fatal error: libbfd ABI mismatch"));
4312 set_default_bfd_target ();
4314 while ((c
= getopt_long (argc
, argv
,
4315 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
4316 long_options
, (int *) 0))
4322 break; /* We've been given a long option. */
4329 if (disassembler_options
)
4330 /* Ignore potential memory leak for now. */
4331 options
= concat (disassembler_options
, ",",
4332 optarg
, (const char *) NULL
);
4335 disassembler_options
= remove_whitespace_and_extra_commas (options
);
4342 display_file_offsets
= TRUE
;
4345 with_line_numbers
= TRUE
;
4354 enum demangling_styles style
;
4356 style
= cplus_demangle_name_to_style (optarg
);
4357 if (style
== unknown_demangling
)
4358 fatal (_("unknown demangling style `%s'"),
4361 cplus_demangle_set_style (style
);
4364 case OPTION_RECURSE_LIMIT
:
4365 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
4367 case OPTION_NO_RECURSE_LIMIT
:
4368 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
4371 do_wide
= wide_output
= TRUE
;
4373 case OPTION_ADJUST_VMA
:
4374 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
4376 case OPTION_START_ADDRESS
:
4377 start_address
= parse_vma (optarg
, "--start-address");
4378 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4379 fatal (_("error: the start address should be before the end address"));
4381 case OPTION_STOP_ADDRESS
:
4382 stop_address
= parse_vma (optarg
, "--stop-address");
4383 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4384 fatal (_("error: the stop address should be after the start address"));
4388 prefix_length
= strlen (prefix
);
4389 /* Remove an unnecessary trailing '/' */
4390 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
4393 case OPTION_PREFIX_STRIP
:
4394 prefix_strip
= atoi (optarg
);
4395 if (prefix_strip
< 0)
4396 fatal (_("error: prefix strip must be non-negative"));
4398 case OPTION_INSN_WIDTH
:
4399 insn_width
= strtoul (optarg
, NULL
, 0);
4400 if (insn_width
<= 0)
4401 fatal (_("error: instruction width must be positive"));
4403 case OPTION_INLINES
:
4404 unwind_inlines
= TRUE
;
4407 if (strcmp (optarg
, "B") == 0)
4408 endian
= BFD_ENDIAN_BIG
;
4409 else if (strcmp (optarg
, "L") == 0)
4410 endian
= BFD_ENDIAN_LITTLE
;
4413 nonfatal (_("unrecognized -E option"));
4418 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
4419 endian
= BFD_ENDIAN_BIG
;
4420 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
4421 endian
= BFD_ENDIAN_LITTLE
;
4424 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
4431 dump_file_header
= TRUE
;
4435 formats_info
= TRUE
;
4439 add_include_path (optarg
);
4442 dump_private_headers
= TRUE
;
4446 dump_private_options
= optarg
;
4450 dump_private_headers
= TRUE
;
4452 dump_reloc_info
= TRUE
;
4453 dump_file_header
= TRUE
;
4454 dump_ar_hdrs
= TRUE
;
4455 dump_section_headers
= TRUE
;
4463 dump_dynamic_symtab
= TRUE
;
4469 disasm_sym
= optarg
;
4472 disassemble_zeroes
= TRUE
;
4476 disassemble_all
= TRUE
;
4481 with_source_code
= TRUE
;
4484 case OPTION_SOURCE_COMMENT
:
4486 with_source_code
= TRUE
;
4489 source_comment
= xstrdup (sanitize_string (optarg
));
4491 source_comment
= xstrdup ("# ");
4499 dump_debugging_tags
= 1;
4504 dump_dwarf_section_info
= TRUE
;
4507 dwarf_select_sections_by_letters (optarg
);
4509 dwarf_select_sections_all ();
4512 dump_dwarf_section_info
= TRUE
;
4515 dwarf_select_sections_by_names (optarg
);
4517 dwarf_select_sections_all ();
4519 case OPTION_DWARF_DEPTH
:
4522 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4525 case OPTION_DWARF_START
:
4528 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4529 suppress_bfd_header
= 1;
4532 case OPTION_DWARF_CHECK
:
4536 dump_ctf_section_info
= TRUE
;
4537 dump_ctf_section_name
= xstrdup (optarg
);
4540 case OPTION_CTF_PARENT
:
4541 dump_ctf_parent_name
= xstrdup (optarg
);
4544 dump_stab_section_info
= TRUE
;
4548 dump_section_contents
= TRUE
;
4552 dump_reloc_info
= TRUE
;
4556 dump_dynamic_reloc_info
= TRUE
;
4560 dump_ar_hdrs
= TRUE
;
4564 dump_section_headers
= TRUE
;
4569 show_version
= TRUE
;
4575 /* No need to set seenflag or to break - usage() does not return. */
4582 print_version ("objdump");
4588 exit_status
= display_info ();
4592 display_file ("a.out", target
, TRUE
);
4594 for (; optind
< argc
;)
4596 display_file (argv
[optind
], target
, optind
== argc
- 1);
4602 free (dump_ctf_section_name
);
4603 free (dump_ctf_parent_name
);
4604 free ((void *) source_comment
);
4606 END_PROGRESS (program_name
);