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_section_name (section
)),
549 (unsigned long) bfd_section_size (section
) / opb
);
550 bfd_printf_vma (abfd
, bfd_section_vma (section
));
552 bfd_printf_vma (abfd
, section
->lma
);
553 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
554 bfd_section_alignment (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 ATTRIBUTE_UNUSED
,
635 asection
*section
, void *data
)
637 int *longest_so_far
= (int *) data
;
641 /* Ignore linker created section. */
642 if (section
->flags
& SEC_LINKER_CREATED
)
645 /* Skip sections that we are ignoring. */
646 if (! process_section_p (section
))
649 name
= bfd_section_name (section
);
650 len
= (int) strlen (name
);
651 if (len
> *longest_so_far
)
652 *longest_so_far
= len
;
656 dump_headers (bfd
*abfd
)
658 /* The default width of 13 is just an arbitrary choice. */
659 int max_section_name_length
= 13;
665 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
666 if (bfd_get_arch_size (abfd
) == 32)
672 printf (_("Sections:\n"));
675 bfd_map_over_sections (abfd
, find_longest_section_name
,
676 &max_section_name_length
);
678 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
679 max_section_name_length
, "Name",
680 bfd_vma_width
, "VMA",
681 bfd_vma_width
, "LMA");
684 printf (_(" Flags"));
687 bfd_map_over_sections (abfd
, dump_section_header
,
688 &max_section_name_length
);
692 slurp_symtab (bfd
*abfd
)
697 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
703 storage
= bfd_get_symtab_upper_bound (abfd
);
706 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
707 bfd_fatal (_("error message was"));
711 off_t filesize
= bfd_get_file_size (abfd
);
715 && filesize
< storage
716 /* The MMO file format supports its own special compression
717 technique, so its sections can be larger than the file size. */
718 && bfd_get_flavour (abfd
) != bfd_target_mmo_flavour
)
720 bfd_nonfatal_message (bfd_get_filename (abfd
), abfd
, NULL
,
721 _("error: symbol table size (%#lx) is larger than filesize (%#lx)"),
722 storage
, (long) filesize
);
728 sy
= (asymbol
**) xmalloc (storage
);
731 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
733 bfd_fatal (bfd_get_filename (abfd
));
737 /* Read in the dynamic symbols. */
740 slurp_dynamic_symtab (bfd
*abfd
)
745 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
748 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
750 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
756 bfd_fatal (bfd_get_filename (abfd
));
759 sy
= (asymbol
**) xmalloc (storage
);
761 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
763 bfd_fatal (bfd_get_filename (abfd
));
767 /* Some symbol names are significant and should be kept in the
768 table of sorted symbol names, even if they are marked as
769 debugging/section symbols. */
772 is_significant_symbol_name (const char * name
)
774 return strncmp (name
, ".plt", 4) == 0 || strcmp (name
, ".got") == 0;
777 /* Filter out (in place) symbols that are useless for disassembly.
778 COUNT is the number of elements in SYMBOLS.
779 Return the number of useful symbols. */
782 remove_useless_symbols (asymbol
**symbols
, long count
)
784 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
788 asymbol
*sym
= *in_ptr
++;
790 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
792 if ((sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
793 && ! is_significant_symbol_name (sym
->name
))
795 if (bfd_is_und_section (sym
->section
)
796 || bfd_is_com_section (sym
->section
))
801 return out_ptr
- symbols
;
804 /* Sort symbols into value order. */
807 compare_symbols (const void *ap
, const void *bp
)
809 const asymbol
*a
= * (const asymbol
**) ap
;
810 const asymbol
*b
= * (const asymbol
**) bp
;
820 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
822 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
825 if (a
->section
> b
->section
)
827 else if (a
->section
< b
->section
)
830 an
= bfd_asymbol_name (a
);
831 bn
= bfd_asymbol_name (b
);
835 /* The symbols gnu_compiled and gcc2_compiled convey no real
836 information, so put them after other symbols with the same value. */
837 af
= (strstr (an
, "gnu_compiled") != NULL
838 || strstr (an
, "gcc2_compiled") != NULL
);
839 bf
= (strstr (bn
, "gnu_compiled") != NULL
840 || strstr (bn
, "gcc2_compiled") != NULL
);
847 /* We use a heuristic for the file name, to try to sort it after
848 more useful symbols. It may not work on non Unix systems, but it
849 doesn't really matter; the only difference is precisely which
850 symbol names get printed. */
852 #define file_symbol(s, sn, snl) \
853 (((s)->flags & BSF_FILE) != 0 \
854 || ((sn)[(snl) - 2] == '.' \
855 && ((sn)[(snl) - 1] == 'o' \
856 || (sn)[(snl) - 1] == 'a')))
858 af
= file_symbol (a
, an
, anl
);
859 bf
= file_symbol (b
, bn
, bnl
);
866 /* Try to sort global symbols before local symbols before function
867 symbols before debugging symbols. */
872 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
874 if ((aflags
& BSF_DEBUGGING
) != 0)
879 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
881 if ((aflags
& BSF_FUNCTION
) != 0)
886 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
888 if ((aflags
& BSF_LOCAL
) != 0)
893 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
895 if ((aflags
& BSF_GLOBAL
) != 0)
901 if (bfd_get_flavour (bfd_asymbol_bfd (a
)) == bfd_target_elf_flavour
902 && bfd_get_flavour (bfd_asymbol_bfd (b
)) == bfd_target_elf_flavour
)
907 if ((a
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
908 asz
= ((elf_symbol_type
*) a
)->internal_elf_sym
.st_size
;
910 if ((b
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
911 bsz
= ((elf_symbol_type
*) b
)->internal_elf_sym
.st_size
;
913 return asz
> bsz
? -1 : 1;
916 /* Symbols that start with '.' might be section names, so sort them
917 after symbols that don't start with '.'. */
918 if (an
[0] == '.' && bn
[0] != '.')
920 if (an
[0] != '.' && bn
[0] == '.')
923 /* Finally, if we can't distinguish them in any other way, try to
924 get consistent results by sorting the symbols by name. */
925 return strcmp (an
, bn
);
928 /* Sort relocs into address order. */
931 compare_relocs (const void *ap
, const void *bp
)
933 const arelent
*a
= * (const arelent
**) ap
;
934 const arelent
*b
= * (const arelent
**) bp
;
936 if (a
->address
> b
->address
)
938 else if (a
->address
< b
->address
)
941 /* So that associated relocations tied to the same address show up
942 in the correct order, we don't do any further sorting. */
951 /* Print an address (VMA) to the output stream in INFO.
952 If SKIP_ZEROES is TRUE, omit leading zeroes. */
955 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
956 bfd_boolean skip_zeroes
)
960 struct objdump_disasm_info
*aux
;
962 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
963 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
968 for (p
= buf
; *p
== '0'; ++p
)
973 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
976 /* Print the name of a symbol. */
979 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
983 const char *name
, *version_string
= NULL
;
984 bfd_boolean hidden
= FALSE
;
987 name
= bfd_asymbol_name (sym
);
988 if (do_demangle
&& name
[0] != '\0')
990 /* Demangle the name. */
991 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
996 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
997 version_string
= bfd_get_symbol_version_string (abfd
, sym
, &hidden
);
999 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1002 name
= sanitize_string (name
);
1006 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
1007 if (version_string
&& *version_string
!= '\0')
1008 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
1013 printf ("%s", name
);
1014 if (version_string
&& *version_string
!= '\0')
1015 printf (hidden
? "@%s" : "@@%s", version_string
);
1022 static inline bfd_boolean
1023 sym_ok (bfd_boolean want_section
,
1024 bfd
* abfd ATTRIBUTE_UNUSED
,
1027 struct disassemble_info
* inf
)
1031 /* Note - we cannot just compare section pointers because they could
1032 be different, but the same... Ie the symbol that we are trying to
1033 find could have come from a separate debug info file. Under such
1034 circumstances the symbol will be associated with a section in the
1035 debug info file, whilst the section we want is in a normal file.
1036 So the section pointers will be different, but the section names
1037 will be the same. */
1038 if (strcmp (bfd_section_name (sorted_syms
[place
]->section
),
1039 bfd_section_name (sec
)) != 0)
1043 return inf
->symbol_is_valid (sorted_syms
[place
], inf
);
1046 /* Locate a symbol given a bfd and a section (from INFO->application_data),
1047 and a VMA. If INFO->application_data->require_sec is TRUE, then always
1048 require the symbol to be in the section. Returns NULL if there is no
1049 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
1050 of the symbol in sorted_syms. */
1053 find_symbol_for_address (bfd_vma vma
,
1054 struct disassemble_info
*inf
,
1057 /* @@ Would it speed things up to cache the last two symbols returned,
1058 and maybe their address ranges? For many processors, only one memory
1059 operand can be present at a time, so the 2-entry cache wouldn't be
1060 constantly churned by code doing heavy memory accesses. */
1062 /* Indices in `sorted_syms'. */
1064 long max_count
= sorted_symcount
;
1066 struct objdump_disasm_info
*aux
;
1070 bfd_boolean want_section
;
1073 if (sorted_symcount
< 1)
1076 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1079 opb
= inf
->octets_per_byte
;
1081 /* Perform a binary search looking for the closest symbol to the
1082 required value. We are searching the range (min, max_count]. */
1083 while (min
+ 1 < max_count
)
1087 thisplace
= (max_count
+ min
) / 2;
1088 sym
= sorted_syms
[thisplace
];
1090 if (bfd_asymbol_value (sym
) > vma
)
1091 max_count
= thisplace
;
1092 else if (bfd_asymbol_value (sym
) < vma
)
1101 /* The symbol we want is now in min, the low end of the range we
1102 were searching. If there are several symbols with the same
1103 value, we want the first (non-section/non-debugging) one. */
1105 while (thisplace
> 0
1106 && (bfd_asymbol_value (sorted_syms
[thisplace
])
1107 == bfd_asymbol_value (sorted_syms
[thisplace
- 1]))
1108 && ((sorted_syms
[thisplace
- 1]->flags
1109 & (BSF_SECTION_SYM
| BSF_DEBUGGING
)) == 0)
1113 /* Prefer a symbol in the current section if we have multple symbols
1114 with the same value, as can occur with overlays or zero size
1117 while (min
< max_count
1118 && (bfd_asymbol_value (sorted_syms
[min
])
1119 == bfd_asymbol_value (sorted_syms
[thisplace
])))
1121 if (sym_ok (TRUE
, abfd
, min
, sec
, inf
))
1128 return sorted_syms
[thisplace
];
1133 /* If the file is relocatable, and the symbol could be from this
1134 section, prefer a symbol from this section over symbols from
1135 others, even if the other symbol's value might be closer.
1137 Note that this may be wrong for some symbol references if the
1138 sections have overlapping memory ranges, but in that case there's
1139 no way to tell what's desired without looking at the relocation
1142 Also give the target a chance to reject symbols. */
1143 want_section
= (aux
->require_sec
1144 || ((abfd
->flags
& HAS_RELOC
) != 0
1145 && vma
>= bfd_section_vma (sec
)
1146 && vma
< (bfd_section_vma (sec
)
1147 + bfd_section_size (sec
) / opb
)));
1149 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1152 long newplace
= sorted_symcount
;
1154 for (i
= min
- 1; i
>= 0; i
--)
1156 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1158 if (newplace
== sorted_symcount
)
1161 if (bfd_asymbol_value (sorted_syms
[i
])
1162 != bfd_asymbol_value (sorted_syms
[newplace
]))
1165 /* Remember this symbol and keep searching until we reach
1166 an earlier address. */
1171 if (newplace
!= sorted_symcount
)
1172 thisplace
= newplace
;
1175 /* We didn't find a good symbol with a smaller value.
1176 Look for one with a larger value. */
1177 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1179 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1187 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1188 /* There is no suitable symbol. */
1192 /* If we have not found an exact match for the specified address
1193 and we have dynamic relocations available, then we can produce
1194 a better result by matching a relocation to the address and
1195 using the symbol associated with that relocation. */
1196 rel_count
= aux
->dynrelcount
;
1198 && sorted_syms
[thisplace
]->value
!= vma
1200 && aux
->dynrelbuf
!= NULL
1201 && aux
->dynrelbuf
[0]->address
<= vma
1202 && aux
->dynrelbuf
[rel_count
- 1]->address
>= vma
1203 /* If we have matched a synthetic symbol, then stick with that. */
1204 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1207 arelent
** rel_high
;
1209 rel_low
= aux
->dynrelbuf
;
1210 rel_high
= rel_low
+ rel_count
- 1;
1211 while (rel_low
<= rel_high
)
1213 arelent
**rel_mid
= &rel_low
[(rel_high
- rel_low
) / 2];
1214 arelent
* rel
= *rel_mid
;
1216 if (rel
->address
== vma
)
1218 /* Absolute relocations do not provide a more helpful
1219 symbolic address. Find a non-absolute relocation
1220 with the same address. */
1221 arelent
**rel_vma
= rel_mid
;
1223 rel_mid
>= rel_low
&& rel_mid
[0]->address
== vma
;
1227 for (; rel_vma
<= rel_high
&& rel_vma
[0]->address
== vma
;
1231 if (rel
->sym_ptr_ptr
!= NULL
1232 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1235 * place
= thisplace
;
1236 return * rel
->sym_ptr_ptr
;
1242 if (vma
< rel
->address
)
1244 else if (vma
>= rel_mid
[1]->address
)
1245 rel_low
= rel_mid
+ 1;
1254 return sorted_syms
[thisplace
];
1257 /* Print an address and the offset to the nearest symbol. */
1260 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1261 bfd_vma vma
, struct disassemble_info
*inf
,
1262 bfd_boolean skip_zeroes
)
1264 objdump_print_value (vma
, inf
, skip_zeroes
);
1270 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
1271 sanitize_string (bfd_section_name (sec
)));
1272 secaddr
= bfd_section_vma (sec
);
1275 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1276 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
1278 else if (vma
> secaddr
)
1280 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1281 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
1283 (*inf
->fprintf_func
) (inf
->stream
, ">");
1287 (*inf
->fprintf_func
) (inf
->stream
, " <");
1289 objdump_print_symname (abfd
, inf
, sym
);
1291 if (bfd_asymbol_value (sym
) == vma
)
1293 /* Undefined symbols in an executables and dynamic objects do not have
1294 a value associated with them, so it does not make sense to display
1295 an offset relative to them. Normally we would not be provided with
1296 this kind of symbol, but the target backend might choose to do so,
1297 and the code in find_symbol_for_address might return an as yet
1298 unresolved symbol associated with a dynamic reloc. */
1299 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1300 && bfd_is_und_section (sym
->section
))
1302 else if (bfd_asymbol_value (sym
) > vma
)
1304 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1305 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1307 else if (vma
> bfd_asymbol_value (sym
))
1309 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1310 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1313 (*inf
->fprintf_func
) (inf
->stream
, ">");
1316 if (display_file_offsets
)
1317 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1318 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1321 /* Print an address (VMA), symbolically if possible.
1322 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1325 objdump_print_addr (bfd_vma vma
,
1326 struct disassemble_info
*inf
,
1327 bfd_boolean skip_zeroes
)
1329 struct objdump_disasm_info
*aux
;
1330 asymbol
*sym
= NULL
;
1331 bfd_boolean skip_find
= FALSE
;
1333 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1335 if (sorted_symcount
< 1)
1337 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1338 objdump_print_value (vma
, inf
, skip_zeroes
);
1340 if (display_file_offsets
)
1341 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1342 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
1346 if (aux
->reloc
!= NULL
1347 && aux
->reloc
->sym_ptr_ptr
!= NULL
1348 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1350 sym
= * aux
->reloc
->sym_ptr_ptr
;
1352 /* Adjust the vma to the reloc. */
1353 vma
+= bfd_asymbol_value (sym
);
1355 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1360 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1362 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, inf
,
1366 /* Print VMA to INFO. This function is passed to the disassembler
1370 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1372 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1375 /* Determine if the given address has a symbol associated with it. */
1378 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1382 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1384 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1387 /* Hold the last function name and the last line number we displayed
1388 in a disassembly. */
1390 static char *prev_functionname
;
1391 static unsigned int prev_line
;
1392 static unsigned int prev_discriminator
;
1394 /* We keep a list of all files that we have seen when doing a
1395 disassembly with source, so that we know how much of the file to
1396 display. This can be important for inlined functions. */
1398 struct print_file_list
1400 struct print_file_list
*next
;
1401 const char *filename
;
1402 const char *modname
;
1405 const char **linemap
;
1408 unsigned max_printed
;
1412 static struct print_file_list
*print_files
;
1414 /* The number of preceding context lines to show when we start
1415 displaying a file for the first time. */
1417 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1419 /* Read a complete file into memory. */
1422 slurp_file (const char *fn
, size_t *size
, struct stat
*fst
)
1425 int ps
= getpagesize ();
1429 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1433 if (fstat (fd
, fst
) < 0)
1438 *size
= fst
->st_size
;
1440 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1441 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1442 if (map
!= (char *) -1L)
1448 map
= (const char *) malloc (*size
);
1449 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1451 free ((void *) map
);
1458 #define line_map_decrease 5
1460 /* Precompute array of lines for a mapped file. */
1462 static const char **
1463 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1465 const char *p
, *lstart
, *end
;
1466 int chars_per_line
= 45; /* First iteration will use 40. */
1467 unsigned int lineno
;
1468 const char **linemap
= NULL
;
1469 unsigned long line_map_size
= 0;
1475 for (p
= map
; p
< end
; p
++)
1479 if (p
+ 1 < end
&& p
[1] == '\r')
1482 else if (*p
== '\r')
1484 if (p
+ 1 < end
&& p
[1] == '\n')
1490 /* End of line found. */
1492 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1494 unsigned long newsize
;
1496 chars_per_line
-= line_map_decrease
;
1497 if (chars_per_line
<= 1)
1499 line_map_size
= size
/ chars_per_line
+ 1;
1500 if (line_map_size
< lineno
+ 1)
1501 line_map_size
= lineno
+ 1;
1502 newsize
= line_map_size
* sizeof (char *);
1503 linemap
= (const char **) xrealloc (linemap
, newsize
);
1506 linemap
[lineno
++] = lstart
;
1514 /* Tries to open MODNAME, and if successful adds a node to print_files
1515 linked list and returns that node. Returns NULL on failure. */
1517 static struct print_file_list
*
1518 try_print_file_open (const char *origname
, const char *modname
, struct stat
*fst
)
1520 struct print_file_list
*p
;
1522 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1524 p
->map
= slurp_file (modname
, &p
->mapsize
, fst
);
1531 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1534 p
->filename
= origname
;
1535 p
->modname
= modname
;
1536 p
->next
= print_files
;
1542 /* If the source file, as described in the symtab, is not found
1543 try to locate it in one of the paths specified with -I
1544 If found, add location to print_files linked list. */
1546 static struct print_file_list
*
1547 update_source_path (const char *filename
, bfd
*abfd
)
1549 struct print_file_list
*p
;
1554 p
= try_print_file_open (filename
, filename
, &fst
);
1557 if (include_path_count
== 0)
1560 /* Get the name of the file. */
1561 fname
= lbasename (filename
);
1563 /* If file exists under a new path, we need to add it to the list
1564 so that show_line knows about it. */
1565 for (i
= 0; i
< include_path_count
; i
++)
1567 char *modname
= concat (include_paths
[i
], "/", fname
,
1570 p
= try_print_file_open (filename
, modname
, &fst
);
1580 long mtime
= bfd_get_mtime (abfd
);
1582 if (fst
.st_mtime
> mtime
)
1583 warn (_("source file %s is more recent than object file\n"),
1590 /* Print a source file line. */
1593 print_line (struct print_file_list
*p
, unsigned int linenum
)
1599 if (linenum
>= p
->maxline
)
1601 l
= p
->linemap
[linenum
];
1602 if (source_comment
!= NULL
&& strlen (l
) > 0)
1603 printf ("%s", source_comment
);
1604 len
= strcspn (l
, "\n\r");
1605 /* Test fwrite return value to quiet glibc warning. */
1606 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1610 /* Print a range of source code lines. */
1613 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1617 while (start
<= end
)
1619 print_line (p
, start
);
1624 /* Show the line number, or the source line, in a disassembly
1628 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1630 const char *filename
;
1631 const char *functionname
;
1632 unsigned int linenumber
;
1633 unsigned int discriminator
;
1637 if (! with_line_numbers
&& ! with_source_code
)
1640 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1641 &filename
, &functionname
,
1642 &linenumber
, &discriminator
))
1645 if (filename
!= NULL
&& *filename
== '\0')
1647 if (functionname
!= NULL
&& *functionname
== '\0')
1648 functionname
= NULL
;
1651 && IS_ABSOLUTE_PATH (filename
)
1655 const char *fname
= filename
;
1657 path
= xmalloc (prefix_length
+ PATH_MAX
+ 1);
1660 memcpy (path
, prefix
, prefix_length
);
1661 path_up
= path
+ prefix_length
;
1663 /* Build relocated filename, stripping off leading directories
1664 from the initial filename if requested. */
1665 if (prefix_strip
> 0)
1670 /* Skip selected directory levels. */
1671 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1672 if (IS_DIR_SEPARATOR(*s
))
1679 /* Update complete filename. */
1680 strncpy (path_up
, fname
, PATH_MAX
);
1681 path_up
[PATH_MAX
] = '\0';
1689 if (with_line_numbers
)
1691 if (functionname
!= NULL
1692 && (prev_functionname
== NULL
1693 || strcmp (functionname
, prev_functionname
) != 0))
1695 printf ("%s():\n", sanitize_string (functionname
));
1699 && (linenumber
!= prev_line
1700 || discriminator
!= prev_discriminator
))
1702 if (discriminator
> 0)
1703 printf ("%s:%u (discriminator %u)\n",
1704 filename
== NULL
? "???" : sanitize_string (filename
),
1705 linenumber
, discriminator
);
1707 printf ("%s:%u\n", filename
== NULL
1708 ? "???" : sanitize_string (filename
),
1713 const char *filename2
;
1714 const char *functionname2
;
1717 while (bfd_find_inliner_info (abfd
, &filename2
, &functionname2
,
1720 printf ("inlined by %s:%u",
1721 sanitize_string (filename2
), line2
);
1722 printf (" (%s)\n", sanitize_string (functionname2
));
1727 if (with_source_code
1731 struct print_file_list
**pp
, *p
;
1734 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1735 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1742 filename
= xstrdup (filename
);
1743 p
= update_source_path (filename
, abfd
);
1746 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1748 if (file_start_context
&& p
->first
)
1752 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1753 if (l
>= linenumber
)
1755 if (p
->max_printed
>= l
)
1757 if (p
->max_printed
< linenumber
)
1758 l
= p
->max_printed
+ 1;
1763 dump_lines (p
, l
, linenumber
);
1764 if (p
->max_printed
< linenumber
)
1765 p
->max_printed
= linenumber
;
1766 p
->last_line
= linenumber
;
1771 if (functionname
!= NULL
1772 && (prev_functionname
== NULL
1773 || strcmp (functionname
, prev_functionname
) != 0))
1775 if (prev_functionname
!= NULL
)
1776 free (prev_functionname
);
1777 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1778 strcpy (prev_functionname
, functionname
);
1781 if (linenumber
> 0 && linenumber
!= prev_line
)
1782 prev_line
= linenumber
;
1784 if (discriminator
!= prev_discriminator
)
1785 prev_discriminator
= discriminator
;
1791 /* Pseudo FILE object for strings. */
1799 /* sprintf to a "stream". */
1801 static int ATTRIBUTE_PRINTF_2
1802 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1809 size_t space
= f
->alloc
- f
->pos
;
1811 va_start (args
, format
);
1812 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1818 f
->alloc
= (f
->alloc
+ n
) * 2;
1819 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1826 /* The number of zeroes we want to see before we start skipping them.
1827 The number is arbitrarily chosen. */
1829 #define DEFAULT_SKIP_ZEROES 8
1831 /* The number of zeroes to skip at the end of a section. If the
1832 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1833 SKIP_ZEROES, they will be disassembled. If there are fewer than
1834 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1835 attempt to avoid disassembling zeroes inserted by section
1838 #define DEFAULT_SKIP_ZEROES_AT_END 3
1841 null_print (const void * stream ATTRIBUTE_UNUSED
, const char * format ATTRIBUTE_UNUSED
, ...)
1846 /* Disassemble some data in memory between given values. */
1849 disassemble_bytes (struct disassemble_info
* inf
,
1850 disassembler_ftype disassemble_fn
,
1853 bfd_vma start_offset
,
1854 bfd_vma stop_offset
,
1857 arelent
** relppend
)
1859 struct objdump_disasm_info
*aux
;
1861 int octets_per_line
;
1862 int skip_addr_chars
;
1863 bfd_vma addr_offset
;
1864 unsigned int opb
= inf
->octets_per_byte
;
1865 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1866 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1870 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1874 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1878 octets_per_line
= insn_width
;
1880 octets_per_line
= 4;
1882 octets_per_line
= 16;
1884 /* Figure out how many characters to skip at the start of an
1885 address, to make the disassembly look nicer. We discard leading
1886 zeroes in chunks of 4, ensuring that there is always a leading
1888 skip_addr_chars
= 0;
1889 if (! prefix_addresses
)
1893 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1895 while (buf
[skip_addr_chars
] == '0')
1898 /* Don't discard zeros on overflow. */
1899 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1900 skip_addr_chars
= 0;
1902 if (skip_addr_chars
!= 0)
1903 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1906 inf
->insn_info_valid
= 0;
1908 addr_offset
= start_offset
;
1909 while (addr_offset
< stop_offset
)
1912 bfd_boolean need_nl
= FALSE
;
1916 /* Make sure we don't use relocs from previous instructions. */
1919 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1921 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1924 if (! disassemble_zeroes
1925 && (inf
->insn_info_valid
== 0
1926 || inf
->branch_delay_insns
== 0)
1927 && (z
- addr_offset
* opb
>= skip_zeroes
1928 || (z
== stop_offset
* opb
&&
1929 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1931 /* If there are more nonzero octets to follow, we only skip
1932 zeroes in multiples of 4, to try to avoid running over
1933 the start of an instruction which happens to start with
1935 if (z
!= stop_offset
* opb
)
1936 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1938 octets
= z
- addr_offset
* opb
;
1940 /* If we are going to display more data, and we are displaying
1941 file offsets, then tell the user how many zeroes we skip
1942 and the file offset from where we resume dumping. */
1943 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1944 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1946 (unsigned long) (section
->filepos
1947 + (addr_offset
+ (octets
/ opb
))));
1957 if (with_line_numbers
|| with_source_code
)
1958 show_line (aux
->abfd
, section
, addr_offset
);
1960 if (! prefix_addresses
)
1964 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1965 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1969 printf ("%s:\t", buf
+ skip_addr_chars
);
1973 aux
->require_sec
= TRUE
;
1974 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1975 aux
->require_sec
= FALSE
;
1982 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1983 inf
->stream
= &sfile
;
1984 inf
->bytes_per_line
= 0;
1985 inf
->bytes_per_chunk
= 0;
1986 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
1987 | (wide_output
? WIDE_OUTPUT
: 0));
1989 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1991 if (inf
->disassembler_needs_relocs
1992 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1993 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1994 && *relppp
< relppend
)
1996 bfd_signed_vma distance_to_rel
;
1998 int max_reloc_offset
1999 = aux
->abfd
->arch_info
->max_reloc_offset_into_insn
;
2001 distance_to_rel
= ((**relppp
)->address
- rel_offset
2004 if (distance_to_rel
> 0
2005 && (max_reloc_offset
< 0
2006 || distance_to_rel
<= max_reloc_offset
))
2008 /* This reloc *might* apply to the current insn,
2009 starting somewhere inside it. Discover the length
2010 of the current insn so that the check below will
2013 insn_size
= insn_width
;
2016 /* We find the length by calling the dissassembler
2017 function with a dummy print handler. This should
2018 work unless the disassembler is not expecting to
2019 be called multiple times for the same address.
2021 This does mean disassembling the instruction
2022 twice, but we only do this when there is a high
2023 probability that there is a reloc that will
2024 affect the instruction. */
2025 inf
->fprintf_func
= (fprintf_ftype
) null_print
;
2026 insn_size
= disassemble_fn (section
->vma
2027 + addr_offset
, inf
);
2028 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2032 /* Check to see if the current reloc is associated with
2033 the instruction that we are about to disassemble. */
2034 if (distance_to_rel
== 0
2035 || (distance_to_rel
> 0
2036 && distance_to_rel
< insn_size
/ (int) opb
))
2038 inf
->flags
|= INSN_HAS_RELOC
;
2039 aux
->reloc
= **relppp
;
2043 if (! disassemble_all
2044 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2045 == (SEC_CODE
| SEC_HAS_CONTENTS
))
2046 /* Set a stop_vma so that the disassembler will not read
2047 beyond the next symbol. We assume that symbols appear on
2048 the boundaries between instructions. We only do this when
2049 disassembling code of course, and when -D is in effect. */
2050 inf
->stop_vma
= section
->vma
+ stop_offset
;
2052 inf
->stop_offset
= stop_offset
;
2053 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2056 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2057 inf
->stream
= stdout
;
2058 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
2059 octets_per_line
= inf
->bytes_per_line
;
2060 if (octets
< (int) opb
)
2063 printf ("%s\n", sfile
.buffer
);
2066 non_fatal (_("disassemble_fn returned length %d"),
2077 octets
= octets_per_line
;
2078 if (addr_offset
+ octets
/ opb
> stop_offset
)
2079 octets
= (stop_offset
- addr_offset
) * opb
;
2081 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
2083 if (ISPRINT (data
[j
]))
2084 buf
[j
- addr_offset
* opb
] = data
[j
];
2086 buf
[j
- addr_offset
* opb
] = '.';
2088 buf
[j
- addr_offset
* opb
] = '\0';
2091 if (prefix_addresses
2093 : show_raw_insn
>= 0)
2097 /* If ! prefix_addresses and ! wide_output, we print
2098 octets_per_line octets per line. */
2100 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
2101 pb
= octets_per_line
;
2103 if (inf
->bytes_per_chunk
)
2104 bpc
= inf
->bytes_per_chunk
;
2108 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2110 /* PR 21580: Check for a buffer ending early. */
2111 if (j
+ bpc
<= stop_offset
* opb
)
2115 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2117 for (k
= bpc
- 1; k
>= 0; k
--)
2118 printf ("%02x", (unsigned) data
[j
+ k
]);
2122 for (k
= 0; k
< bpc
; k
++)
2123 printf ("%02x", (unsigned) data
[j
+ k
]);
2129 for (; pb
< octets_per_line
; pb
+= bpc
)
2133 for (k
= 0; k
< bpc
; k
++)
2138 /* Separate raw data from instruction by extra space. */
2148 printf ("%s", sfile
.buffer
);
2150 if (prefix_addresses
2152 : show_raw_insn
>= 0)
2160 j
= addr_offset
* opb
+ pb
;
2162 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
2163 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2167 printf ("%s:\t", buf
+ skip_addr_chars
);
2169 pb
+= octets_per_line
;
2172 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2174 /* PR 21619: Check for a buffer ending early. */
2175 if (j
+ bpc
<= stop_offset
* opb
)
2179 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2181 for (k
= bpc
- 1; k
>= 0; k
--)
2182 printf ("%02x", (unsigned) data
[j
+ k
]);
2186 for (k
= 0; k
< bpc
; k
++)
2187 printf ("%02x", (unsigned) data
[j
+ k
]);
2201 while ((*relppp
) < relppend
2202 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
2204 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
2215 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
2218 if (q
->howto
== NULL
)
2219 printf (": *unknown*\t");
2220 else if (q
->howto
->name
)
2221 printf (": %s\t", q
->howto
->name
);
2223 printf (": %d\t", q
->howto
->type
);
2225 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
2226 printf ("*unknown*");
2229 const char *sym_name
;
2231 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
2232 if (sym_name
!= NULL
&& *sym_name
!= '\0')
2233 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
2238 sym_sec
= bfd_asymbol_section (*q
->sym_ptr_ptr
);
2239 sym_name
= bfd_section_name (sym_sec
);
2240 if (sym_name
== NULL
|| *sym_name
== '\0')
2241 sym_name
= "*unknown*";
2242 printf ("%s", sanitize_string (sym_name
));
2248 bfd_signed_vma addend
= q
->addend
;
2256 objdump_print_value (addend
, inf
, TRUE
);
2268 addr_offset
+= octets
/ opb
;
2271 free (sfile
.buffer
);
2275 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
2277 const struct elf_backend_data
* bed
;
2278 bfd_vma sign_adjust
= 0;
2279 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
2280 struct objdump_disasm_info
* paux
;
2281 unsigned int opb
= pinfo
->octets_per_byte
;
2282 bfd_byte
* data
= NULL
;
2283 bfd_size_type datasize
= 0;
2284 arelent
** rel_pp
= NULL
;
2285 arelent
** rel_ppstart
= NULL
;
2286 arelent
** rel_ppend
;
2287 bfd_vma stop_offset
;
2288 asymbol
* sym
= NULL
;
2292 unsigned long addr_offset
;
2293 bfd_boolean do_print
;
2296 stop_offset_reached
,
2301 /* Sections that do not contain machine
2302 code are not normally disassembled. */
2303 if (! disassemble_all
2304 && only_list
== NULL
2305 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2306 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
2309 if (! process_section_p (section
))
2312 datasize
= bfd_section_size (section
);
2316 if (start_address
== (bfd_vma
) -1
2317 || start_address
< section
->vma
)
2320 addr_offset
= start_address
- section
->vma
;
2322 if (stop_address
== (bfd_vma
) -1)
2323 stop_offset
= datasize
/ opb
;
2326 if (stop_address
< section
->vma
)
2329 stop_offset
= stop_address
- section
->vma
;
2330 if (stop_offset
> datasize
/ opb
)
2331 stop_offset
= datasize
/ opb
;
2334 if (addr_offset
>= stop_offset
)
2337 /* Decide which set of relocs to use. Load them if necessary. */
2338 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
2339 if (paux
->dynrelbuf
&& dump_dynamic_reloc_info
)
2341 rel_pp
= paux
->dynrelbuf
;
2342 rel_count
= paux
->dynrelcount
;
2343 /* Dynamic reloc addresses are absolute, non-dynamic are section
2344 relative. REL_OFFSET specifies the reloc address corresponding
2345 to the start of this section. */
2346 rel_offset
= section
->vma
;
2354 if ((section
->flags
& SEC_RELOC
) != 0
2355 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
2359 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2361 bfd_fatal (bfd_get_filename (abfd
));
2365 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
2366 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
2368 bfd_fatal (bfd_get_filename (abfd
));
2370 /* Sort the relocs by address. */
2371 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
2375 rel_ppend
= rel_pp
+ rel_count
;
2377 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2379 non_fatal (_("Reading section %s failed because: %s"),
2380 section
->name
, bfd_errmsg (bfd_get_error ()));
2384 paux
->sec
= section
;
2385 pinfo
->buffer
= data
;
2386 pinfo
->buffer_vma
= section
->vma
;
2387 pinfo
->buffer_length
= datasize
;
2388 pinfo
->section
= section
;
2390 /* Skip over the relocs belonging to addresses below the
2392 while (rel_pp
< rel_ppend
2393 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
2396 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
2398 /* Find the nearest symbol forwards from our current position. */
2399 paux
->require_sec
= TRUE
;
2400 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
2401 (struct disassemble_info
*) inf
,
2403 paux
->require_sec
= FALSE
;
2405 /* PR 9774: If the target used signed addresses then we must make
2406 sure that we sign extend the value that we calculate for 'addr'
2407 in the loop below. */
2408 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2409 && (bed
= get_elf_backend_data (abfd
)) != NULL
2410 && bed
->sign_extend_vma
)
2411 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2413 /* Disassemble a block of instructions up to the address associated with
2414 the symbol we have just found. Then print the symbol and find the
2415 next symbol on. Repeat until we have disassembled the entire section
2416 or we have reached the end of the address range we are interested in. */
2417 do_print
= paux
->symbol
== NULL
;
2418 loop_until
= stop_offset_reached
;
2420 while (addr_offset
< stop_offset
)
2424 bfd_vma nextstop_offset
;
2427 addr
= section
->vma
+ addr_offset
;
2428 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2430 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2435 (x
< sorted_symcount
2436 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2440 pinfo
->symbols
= sorted_syms
+ place
;
2441 pinfo
->num_symbols
= x
- place
;
2442 pinfo
->symtab_pos
= place
;
2446 pinfo
->symbols
= NULL
;
2447 pinfo
->num_symbols
= 0;
2448 pinfo
->symtab_pos
= -1;
2451 /* If we are only disassembling from a specific symbol,
2452 check to see if we should start or stop displaying. */
2453 if (sym
&& paux
->symbol
)
2457 /* See if we should stop printing. */
2461 if (sym
->flags
& BSF_FUNCTION
)
2465 case stop_offset_reached
:
2466 /* Handled by the while loop. */
2470 /* FIXME: There is an implicit assumption here
2471 that the name of sym is different from
2473 if (! bfd_is_local_label (abfd
, sym
))
2480 const char * name
= bfd_asymbol_name (sym
);
2481 char * alloc
= NULL
;
2483 if (do_demangle
&& name
[0] != '\0')
2485 /* Demangle the name. */
2486 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
2491 /* We are not currently printing. Check to see
2492 if the current symbol matches the requested symbol. */
2493 if (streq (name
, paux
->symbol
))
2497 if (sym
->flags
& BSF_FUNCTION
)
2499 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2500 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
2502 /* Sym is a function symbol with a size associated
2503 with it. Turn on automatic disassembly for the
2504 next VALUE bytes. */
2505 stop_offset
= addr_offset
2506 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
2507 loop_until
= stop_offset_reached
;
2511 /* Otherwise we need to tell the loop heuristic to
2512 loop until the next function symbol is encountered. */
2513 loop_until
= function_sym
;
2518 /* Otherwise loop until the next symbol is encountered. */
2519 loop_until
= next_sym
;
2527 if (! prefix_addresses
&& do_print
)
2529 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2530 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2532 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2535 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2537 else if (sym
== NULL
)
2541 #define is_valid_next_sym(SYM) \
2542 (strcmp (bfd_section_name ((SYM)->section), bfd_section_name (section)) == 0 \
2543 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2544 && pinfo->symbol_is_valid (SYM, pinfo))
2546 /* Search forward for the next appropriate symbol in
2547 SECTION. Note that all the symbols are sorted
2548 together into one big array, and that some sections
2549 may have overlapping addresses. */
2550 while (place
< sorted_symcount
2551 && ! is_valid_next_sym (sorted_syms
[place
]))
2554 if (place
>= sorted_symcount
)
2557 nextsym
= sorted_syms
[place
];
2560 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2561 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2562 else if (nextsym
== NULL
)
2563 nextstop_offset
= stop_offset
;
2565 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2567 if (nextstop_offset
> stop_offset
2568 || nextstop_offset
<= addr_offset
)
2569 nextstop_offset
= stop_offset
;
2571 /* If a symbol is explicitly marked as being an object
2572 rather than a function, just dump the bytes without
2573 disassembling them. */
2576 || sym
->section
!= section
2577 || bfd_asymbol_value (sym
) > addr
2578 || ((sym
->flags
& BSF_OBJECT
) == 0
2579 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2581 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2583 || (sym
->flags
& BSF_FUNCTION
) != 0)
2589 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2590 addr_offset
, nextstop_offset
,
2591 rel_offset
, &rel_pp
, rel_ppend
);
2593 addr_offset
= nextstop_offset
;
2599 if (rel_ppstart
!= NULL
)
2603 /* Disassemble the contents of an object file. */
2606 disassemble_data (bfd
*abfd
)
2608 struct disassemble_info disasm_info
;
2609 struct objdump_disasm_info aux
;
2613 prev_functionname
= NULL
;
2615 prev_discriminator
= 0;
2617 /* We make a copy of syms to sort. We don't want to sort syms
2618 because that will screw up the relocs. */
2619 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2620 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2621 * sizeof (asymbol
*));
2622 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2623 sorted_symcount
* sizeof (asymbol
*));
2625 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2627 for (i
= 0; i
< synthcount
; ++i
)
2629 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2633 /* Sort the symbols into section and symbol order. */
2634 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2636 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2638 disasm_info
.application_data
= (void *) &aux
;
2640 aux
.require_sec
= FALSE
;
2641 aux
.dynrelbuf
= NULL
;
2642 aux
.dynrelcount
= 0;
2644 aux
.symbol
= disasm_sym
;
2646 disasm_info
.print_address_func
= objdump_print_address
;
2647 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2649 if (machine
!= NULL
)
2651 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2654 fatal (_("can't use supplied machine %s"), machine
);
2656 abfd
->arch_info
= inf
;
2659 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2661 struct bfd_target
*xvec
;
2663 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2664 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2665 xvec
->byteorder
= endian
;
2669 /* Use libopcodes to locate a suitable disassembler. */
2670 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
2671 bfd_big_endian (abfd
),
2672 bfd_get_mach (abfd
), abfd
);
2673 if (!aux
.disassemble_fn
)
2675 non_fatal (_("can't disassemble for architecture %s\n"),
2676 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2681 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2682 disasm_info
.arch
= bfd_get_arch (abfd
);
2683 disasm_info
.mach
= bfd_get_mach (abfd
);
2684 disasm_info
.disassembler_options
= disassembler_options
;
2685 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2686 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2687 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2688 disasm_info
.disassembler_needs_relocs
= FALSE
;
2690 if (bfd_big_endian (abfd
))
2691 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2692 else if (bfd_little_endian (abfd
))
2693 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2695 /* ??? Aborting here seems too drastic. We could default to big or little
2697 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2699 /* Allow the target to customize the info structure. */
2700 disassemble_init_for_target (& disasm_info
);
2702 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
2704 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2706 if (relsize
< 0 && dump_dynamic_reloc_info
)
2707 bfd_fatal (bfd_get_filename (abfd
));
2711 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2712 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2715 if (aux
.dynrelcount
< 0)
2716 bfd_fatal (bfd_get_filename (abfd
));
2718 /* Sort the relocs by address. */
2719 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2723 disasm_info
.symtab
= sorted_syms
;
2724 disasm_info
.symtab_size
= sorted_symcount
;
2726 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2728 if (aux
.dynrelbuf
!= NULL
)
2729 free (aux
.dynrelbuf
);
2734 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2735 asection
*sec
, void *file
)
2737 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2738 bfd
*abfd
= (bfd
*) file
;
2743 if (section
->start
!= NULL
)
2745 /* If it is already loaded, do nothing. */
2746 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2748 free (section
->start
);
2751 section
->filename
= bfd_get_filename (abfd
);
2752 section
->reloc_info
= NULL
;
2753 section
->num_relocs
= 0;
2754 section
->address
= bfd_section_vma (sec
);
2755 section
->user_data
= sec
;
2756 section
->size
= bfd_section_size (sec
);
2757 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
2758 alloced
= amt
= section
->size
+ 1;
2759 if (alloced
!= amt
|| alloced
== 0)
2761 section
->start
= NULL
;
2762 free_debug_section (debug
);
2763 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
2764 sanitize_string (section
->name
),
2765 (unsigned long long) section
->size
);
2768 section
->start
= contents
= malloc (alloced
);
2769 if (section
->start
== NULL
2770 || !bfd_get_full_section_contents (abfd
, sec
, &contents
))
2772 free_debug_section (debug
);
2773 printf (_("\nCan't get contents for section '%s'.\n"),
2774 sanitize_string (section
->name
));
2777 /* Ensure any string section has a terminating NUL. */
2778 section
->start
[section
->size
] = 0;
2780 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
2781 && debug_displays
[debug
].relocate
)
2786 bfd_cache_section_contents (sec
, section
->start
);
2788 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2795 free_debug_section (debug
);
2796 printf (_("\nCan't get contents for section '%s'.\n"),
2797 sanitize_string (section
->name
));
2801 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
2804 unsigned long reloc_count
;
2807 relocs
= (arelent
**) xmalloc (reloc_size
);
2809 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
2810 if (reloc_count
== 0)
2814 section
->reloc_info
= relocs
;
2815 section
->num_relocs
= reloc_count
;
2824 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
2829 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
2832 relocs
= (arelent
**) dsec
->reloc_info
;
2834 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
2835 if (rp
->address
== offset
)
2842 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2844 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2845 bfd
*abfd
= (bfd
*) file
;
2848 /* If it is already loaded, do nothing. */
2849 if (section
->start
!= NULL
)
2851 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2855 /* Locate the debug section. */
2856 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2858 section
->name
= section
->uncompressed_name
;
2861 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2863 section
->name
= section
->compressed_name
;
2868 return load_specific_debug_section (debug
, sec
, file
);
2872 free_debug_section (enum dwarf_section_display_enum debug
)
2874 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2876 if (section
->start
== NULL
)
2879 /* PR 17512: file: 0f67f69d. */
2880 if (section
->user_data
!= NULL
)
2882 asection
* sec
= (asection
*) section
->user_data
;
2884 /* If we are freeing contents that are also pointed to by the BFD
2885 library's section structure then make sure to update those pointers
2886 too. Otherwise, the next time we try to load data for this section
2887 we can end up using a stale pointer. */
2888 if (section
->start
== sec
->contents
)
2890 sec
->contents
= NULL
;
2891 sec
->flags
&= ~ SEC_IN_MEMORY
;
2892 sec
->compress_status
= COMPRESS_SECTION_NONE
;
2896 free ((char *) section
->start
);
2897 section
->start
= NULL
;
2898 section
->address
= 0;
2903 close_debug_file (void * file
)
2905 bfd
* abfd
= (bfd
*) file
;
2911 open_debug_file (const char * pathname
)
2915 data
= bfd_openr (pathname
, NULL
);
2919 if (! bfd_check_format (data
, bfd_object
))
2926 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2927 void *arg ATTRIBUTE_UNUSED
)
2929 const char *name
= bfd_section_name (section
);
2933 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2934 match
= ".debug_info";
2938 for (i
= 0; i
< max
; i
++)
2939 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2940 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2941 && debug_displays
[i
].enabled
!= NULL
2942 && *debug_displays
[i
].enabled
)
2944 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2946 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2947 sec
->name
= sec
->uncompressed_name
;
2949 sec
->name
= sec
->compressed_name
;
2950 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2953 debug_displays
[i
].display (sec
, abfd
);
2955 if (i
!= info
&& i
!= abbrev
)
2956 free_debug_section ((enum dwarf_section_display_enum
) i
);
2962 /* Dump the dwarf debugging information. */
2965 dump_dwarf (bfd
*abfd
)
2967 /* The byte_get pointer should have been set at the start of dump_bfd(). */
2968 if (byte_get
== NULL
)
2970 warn (_("File %s does not contain any dwarf debug information\n"),
2971 bfd_get_filename (abfd
));
2975 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2977 switch (bfd_get_arch (abfd
))
2980 switch (bfd_get_mach (abfd
))
2982 case bfd_mach_x86_64
:
2983 case bfd_mach_x86_64_intel_syntax
:
2984 case bfd_mach_x86_64_nacl
:
2985 case bfd_mach_x64_32
:
2986 case bfd_mach_x64_32_intel_syntax
:
2987 case bfd_mach_x64_32_nacl
:
2988 init_dwarf_regnames_x86_64 ();
2992 init_dwarf_regnames_i386 ();
2997 case bfd_arch_iamcu
:
2998 init_dwarf_regnames_iamcu ();
3001 case bfd_arch_aarch64
:
3002 init_dwarf_regnames_aarch64();
3006 init_dwarf_regnames_s390 ();
3009 case bfd_arch_riscv
:
3010 init_dwarf_regnames_riscv ();
3014 /* S12Z has a 24 bit address space. But the only known
3015 producer of dwarf_info encodes addresses into 32 bits. */
3023 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
3026 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
3027 it. Return NULL on failure. */
3030 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
3031 bfd_size_type
*entsize_ptr
)
3036 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
3037 if (stabsect
== NULL
)
3039 printf (_("No %s section present\n\n"),
3040 sanitize_string (sect_name
));
3044 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
3046 non_fatal (_("reading %s section of %s failed: %s"),
3047 sect_name
, bfd_get_filename (abfd
),
3048 bfd_errmsg (bfd_get_error ()));
3054 *size_ptr
= bfd_section_size (stabsect
);
3056 *entsize_ptr
= stabsect
->entsize
;
3061 /* Stabs entries use a 12 byte format:
3062 4 byte string table index
3064 1 byte stab other field
3065 2 byte stab desc field
3067 FIXME: This will have to change for a 64 bit object format. */
3069 #define STRDXOFF (0)
3071 #define OTHEROFF (5)
3074 #define STABSIZE (12)
3076 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3077 using string table section STRSECT_NAME (in `strtab'). */
3080 print_section_stabs (bfd
*abfd
,
3081 const char *stabsect_name
,
3082 unsigned *string_offset_ptr
)
3085 unsigned file_string_table_offset
= 0;
3086 unsigned next_file_string_table_offset
= *string_offset_ptr
;
3087 bfd_byte
*stabp
, *stabs_end
;
3090 stabs_end
= stabp
+ stab_size
;
3092 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
3093 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3095 /* Loop through all symbols and print them.
3097 We start the index at -1 because there is a dummy symbol on
3098 the front of stabs-in-{coff,elf} sections that supplies sizes. */
3099 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
3103 unsigned char type
, other
;
3104 unsigned short desc
;
3107 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
3108 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
3109 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
3110 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
3111 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
3113 printf ("\n%-6d ", i
);
3114 /* Either print the stab name, or, if unnamed, print its number
3115 again (makes consistent formatting for tools like awk). */
3116 name
= bfd_get_stab_name (type
);
3118 printf ("%-6s", sanitize_string (name
));
3119 else if (type
== N_UNDF
)
3122 printf ("%-6d", type
);
3123 printf (" %-6d %-6d ", other
, desc
);
3124 bfd_printf_vma (abfd
, value
);
3125 printf (" %-6lu", strx
);
3127 /* Symbols with type == 0 (N_UNDF) specify the length of the
3128 string table associated with this file. We use that info
3129 to know how to relocate the *next* file's string table indices. */
3132 file_string_table_offset
= next_file_string_table_offset
;
3133 next_file_string_table_offset
+= value
;
3137 bfd_size_type amt
= strx
+ file_string_table_offset
;
3139 /* Using the (possibly updated) string table offset, print the
3140 string (if any) associated with this symbol. */
3141 if (amt
< stabstr_size
)
3142 /* PR 17512: file: 079-79389-0.001:0.1.
3143 FIXME: May need to sanitize this string before displaying. */
3144 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
3150 *string_offset_ptr
= next_file_string_table_offset
;
3155 const char * section_name
;
3156 const char * string_section_name
;
3157 unsigned string_offset
;
3162 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
3165 stab_section_names
* sought
= (stab_section_names
*) names
;
3167 /* Check for section names for which stabsect_name is a prefix, to
3168 handle .stab.N, etc. */
3169 len
= strlen (sought
->section_name
);
3171 /* If the prefix matches, and the files section name ends with a
3172 nul or a digit, then we match. I.e., we want either an exact
3173 match or a section followed by a number. */
3174 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
3175 && (section
->name
[len
] == 0
3176 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
3179 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
3180 &stabstr_size
, NULL
);
3184 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
, NULL
);
3186 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
3192 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
3194 stab_section_names s
;
3196 s
.section_name
= stabsect_name
;
3197 s
.string_section_name
= strsect_name
;
3198 s
.string_offset
= 0;
3200 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
3206 /* Dump the any sections containing stabs debugging information. */
3209 dump_stabs (bfd
*abfd
)
3211 dump_stabs_section (abfd
, ".stab", ".stabstr");
3212 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
3213 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
3216 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3218 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3222 dump_bfd_header (bfd
*abfd
)
3226 printf (_("architecture: %s, "),
3227 bfd_printable_arch_mach (bfd_get_arch (abfd
),
3228 bfd_get_mach (abfd
)));
3229 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
3231 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
3232 PF (HAS_RELOC
, "HAS_RELOC");
3233 PF (EXEC_P
, "EXEC_P");
3234 PF (HAS_LINENO
, "HAS_LINENO");
3235 PF (HAS_DEBUG
, "HAS_DEBUG");
3236 PF (HAS_SYMS
, "HAS_SYMS");
3237 PF (HAS_LOCALS
, "HAS_LOCALS");
3238 PF (DYNAMIC
, "DYNAMIC");
3239 PF (WP_TEXT
, "WP_TEXT");
3240 PF (D_PAGED
, "D_PAGED");
3241 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
3242 printf (_("\nstart address 0x"));
3243 bfd_printf_vma (abfd
, abfd
->start_address
);
3248 /* Formatting callback function passed to ctf_dump. Returns either the pointer
3249 it is passed, or a pointer to newly-allocated storage, in which case
3250 dump_ctf() will free it when it no longer needs it. */
3253 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
3256 const char *blanks
= arg
;
3259 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
3264 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
3266 make_ctfsect (const char *name
, bfd_byte
*data
,
3271 ctfsect
.cts_name
= name
;
3272 ctfsect
.cts_entsize
= 1;
3273 ctfsect
.cts_size
= size
;
3274 ctfsect
.cts_data
= data
;
3279 /* Dump one CTF archive member. */
3282 dump_ctf_archive_member (ctf_file_t
*ctf
, const char *name
, void *arg
)
3284 ctf_file_t
*parent
= (ctf_file_t
*) arg
;
3285 const char *things
[] = {"Header", "Labels", "Data objects",
3286 "Function objects", "Variables", "Types", "Strings",
3291 /* Only print out the name of non-default-named archive members.
3292 The name .ctf appears everywhere, even for things that aren't
3293 really archives, so printing it out is liable to be confusing.
3295 The parent, if there is one, is the default-owned archive member:
3296 avoid importing it into itself. (This does no harm, but looks
3299 if (strcmp (name
, ".ctf") != 0)
3301 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name
));
3302 ctf_import (ctf
, parent
);
3305 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
3307 ctf_dump_state_t
*s
= NULL
;
3310 printf ("\n %s:\n", *thing
);
3311 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
3312 (void *) " ")) != NULL
)
3314 printf ("%s\n", item
);
3318 if (ctf_errno (ctf
))
3320 non_fatal (_("Iteration failed: %s, %s\n"), *thing
,
3321 ctf_errmsg (ctf_errno (ctf
)));
3328 /* Dump the CTF debugging information. */
3331 dump_ctf (bfd
*abfd
, const char *sect_name
, const char *parent_name
)
3333 ctf_archive_t
*ctfa
, *parenta
= NULL
, *lookparent
;
3334 bfd_byte
*ctfdata
, *parentdata
= NULL
;
3335 bfd_size_type ctfsize
, parentsize
;
3337 ctf_file_t
*parent
= NULL
;
3340 if ((ctfdata
= read_section_stabs (abfd
, sect_name
, &ctfsize
, NULL
)) == NULL
)
3341 bfd_fatal (bfd_get_filename (abfd
));
3344 && (parentdata
= read_section_stabs (abfd
, parent_name
, &parentsize
,
3346 bfd_fatal (bfd_get_filename (abfd
));
3348 /* Load the CTF file and dump it. */
3350 ctfsect
= make_ctfsect (sect_name
, ctfdata
, ctfsize
);
3351 if ((ctfa
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
3353 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3354 bfd_fatal (bfd_get_filename (abfd
));
3359 ctfsect
= make_ctfsect (parent_name
, parentdata
, parentsize
);
3360 if ((parenta
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
3362 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3363 bfd_fatal (bfd_get_filename (abfd
));
3366 lookparent
= parenta
;
3371 /* Assume that the applicable parent archive member is the default one.
3372 (This is what all known implementations are expected to do, if they
3373 put CTFs and their parents in archives together.) */
3374 if ((parent
= ctf_arc_open_by_name (lookparent
, NULL
, &err
)) == NULL
)
3376 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3377 bfd_fatal (bfd_get_filename (abfd
));
3380 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name
));
3382 ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
);
3383 ctf_file_close (parent
);
3385 ctf_close (parenta
);
3392 dump_bfd_private_header (bfd
*abfd
)
3394 if (!bfd_print_private_bfd_data (abfd
, stdout
))
3395 non_fatal (_("warning: private headers incomplete: %s"),
3396 bfd_errmsg (bfd_get_error ()));
3400 dump_target_specific (bfd
*abfd
)
3402 const struct objdump_private_desc
* const *desc
;
3403 struct objdump_private_option
*opt
;
3406 /* Find the desc. */
3407 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
3408 if ((*desc
)->filter (abfd
))
3413 non_fatal (_("option -P/--private not supported by this file"));
3417 /* Clear all options. */
3418 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3419 opt
->selected
= FALSE
;
3421 /* Decode options. */
3422 b
= dump_private_options
;
3425 e
= strchr (b
, ',');
3430 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3431 if (strcmp (opt
->name
, b
) == 0)
3433 opt
->selected
= TRUE
;
3436 if (opt
->name
== NULL
)
3437 non_fatal (_("target specific dump '%s' not supported"), b
);
3448 (*desc
)->dump (abfd
);
3451 /* Display a section in hexadecimal format with associated characters.
3452 Each line prefixed by the zero padded address. */
3455 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
3457 bfd_byte
*data
= NULL
;
3458 bfd_size_type datasize
;
3459 bfd_vma addr_offset
;
3460 bfd_vma start_offset
;
3461 bfd_vma stop_offset
;
3462 unsigned int opb
= bfd_octets_per_byte (abfd
);
3463 /* Bytes per line. */
3464 const int onaline
= 16;
3469 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
3472 if (! process_section_p (section
))
3475 if ((datasize
= bfd_section_size (section
)) == 0)
3478 /* Compute the address range to display. */
3479 if (start_address
== (bfd_vma
) -1
3480 || start_address
< section
->vma
)
3483 start_offset
= start_address
- section
->vma
;
3485 if (stop_address
== (bfd_vma
) -1)
3486 stop_offset
= datasize
/ opb
;
3489 if (stop_address
< section
->vma
)
3492 stop_offset
= stop_address
- section
->vma
;
3494 if (stop_offset
> datasize
/ opb
)
3495 stop_offset
= datasize
/ opb
;
3498 if (start_offset
>= stop_offset
)
3501 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
3502 if (display_file_offsets
)
3503 printf (_(" (Starting at file offset: 0x%lx)"),
3504 (unsigned long) (section
->filepos
+ start_offset
));
3507 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
3509 non_fatal (_("Reading section %s failed because: %s"),
3510 section
->name
, bfd_errmsg (bfd_get_error ()));
3516 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
3517 if (strlen (buf
) >= sizeof (buf
))
3521 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3523 count
= strlen (buf
) - count
;
3527 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
3528 if (strlen (buf
) >= sizeof (buf
))
3532 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3534 count
= strlen (buf
) - count
;
3538 for (addr_offset
= start_offset
;
3539 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
3543 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
3544 count
= strlen (buf
);
3545 if ((size_t) count
>= sizeof (buf
))
3549 while (count
< width
)
3554 fputs (buf
+ count
- width
, stdout
);
3557 for (j
= addr_offset
* opb
;
3558 j
< addr_offset
* opb
+ onaline
; j
++)
3560 if (j
< stop_offset
* opb
)
3561 printf ("%02x", (unsigned) (data
[j
]));
3569 for (j
= addr_offset
* opb
;
3570 j
< addr_offset
* opb
+ onaline
; j
++)
3572 if (j
>= stop_offset
* opb
)
3575 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
3582 /* Actually display the various requested regions. */
3585 dump_data (bfd
*abfd
)
3587 bfd_map_over_sections (abfd
, dump_section
, NULL
);
3590 /* Should perhaps share code and display with nm? */
3593 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
3602 max_count
= dynsymcount
;
3603 printf ("DYNAMIC SYMBOL TABLE:\n");
3608 max_count
= symcount
;
3609 printf ("SYMBOL TABLE:\n");
3613 printf (_("no symbols\n"));
3615 for (count
= 0; count
< max_count
; count
++)
3619 if (*current
== NULL
)
3620 printf (_("no information for symbol number %ld\n"), count
);
3622 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
3623 printf (_("could not determine the type of symbol number %ld\n"),
3626 else if (process_section_p ((* current
)->section
)
3627 && (dump_special_syms
3628 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
3630 const char *name
= (*current
)->name
;
3632 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
3636 /* If we want to demangle the name, we demangle it
3637 here, and temporarily clobber it while calling
3638 bfd_print_symbol. FIXME: This is a gross hack. */
3639 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
3641 (*current
)->name
= alloc
;
3642 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3643 bfd_print_symbol_all
);
3646 (*current
)->name
= name
;
3651 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3652 bfd_print_symbol_all
);
3662 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
3665 char *last_filename
, *last_functionname
;
3666 unsigned int last_line
;
3667 unsigned int last_discriminator
;
3669 /* Get column headers lined up reasonably. */
3677 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
3678 width
= strlen (buf
) - 7;
3680 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
3683 last_filename
= NULL
;
3684 last_functionname
= NULL
;
3686 last_discriminator
= 0;
3688 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
3691 const char *filename
, *functionname
;
3692 unsigned int linenumber
;
3693 unsigned int discriminator
;
3694 const char *sym_name
;
3695 const char *section_name
;
3696 bfd_vma addend2
= 0;
3698 if (start_address
!= (bfd_vma
) -1
3699 && q
->address
< start_address
)
3701 if (stop_address
!= (bfd_vma
) -1
3702 && q
->address
> stop_address
)
3705 if (with_line_numbers
3707 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
3708 &filename
, &functionname
,
3709 &linenumber
, &discriminator
))
3711 if (functionname
!= NULL
3712 && (last_functionname
== NULL
3713 || strcmp (functionname
, last_functionname
) != 0))
3715 printf ("%s():\n", sanitize_string (functionname
));
3716 if (last_functionname
!= NULL
)
3717 free (last_functionname
);
3718 last_functionname
= xstrdup (functionname
);
3722 && (linenumber
!= last_line
3723 || (filename
!= NULL
3724 && last_filename
!= NULL
3725 && filename_cmp (filename
, last_filename
) != 0)
3726 || (discriminator
!= last_discriminator
)))
3728 if (discriminator
> 0)
3729 printf ("%s:%u\n", filename
== NULL
? "???" :
3730 sanitize_string (filename
), linenumber
);
3732 printf ("%s:%u (discriminator %u)\n",
3733 filename
== NULL
? "???" : sanitize_string (filename
),
3734 linenumber
, discriminator
);
3735 last_line
= linenumber
;
3736 last_discriminator
= discriminator
;
3737 if (last_filename
!= NULL
)
3738 free (last_filename
);
3739 if (filename
== NULL
)
3740 last_filename
= NULL
;
3742 last_filename
= xstrdup (filename
);
3746 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
3748 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
3749 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
3754 section_name
= NULL
;
3757 bfd_printf_vma (abfd
, q
->address
);
3758 if (q
->howto
== NULL
)
3759 printf (" *unknown* ");
3760 else if (q
->howto
->name
)
3762 const char *name
= q
->howto
->name
;
3764 /* R_SPARC_OLO10 relocations contain two addends.
3765 But because 'arelent' lacks enough storage to
3766 store them both, the 64-bit ELF Sparc backend
3767 records this as two relocations. One R_SPARC_LO10
3768 and one R_SPARC_13, both pointing to the same
3769 address. This is merely so that we have some
3770 place to store both addend fields.
3772 Undo this transformation, otherwise the output
3773 will be confusing. */
3774 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3775 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3777 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3779 arelent
*q2
= *(p
+ 1);
3782 && q
->address
== q2
->address
3783 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3785 name
= "R_SPARC_OLO10";
3786 addend2
= q2
->addend
;
3790 printf (" %-16s ", name
);
3793 printf (" %-16d ", q
->howto
->type
);
3797 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3801 if (section_name
== NULL
)
3802 section_name
= "*unknown*";
3803 printf ("[%s]", sanitize_string (section_name
));
3808 bfd_signed_vma addend
= q
->addend
;
3816 bfd_printf_vma (abfd
, addend
);
3821 bfd_printf_vma (abfd
, addend2
);
3827 if (last_filename
!= NULL
)
3828 free (last_filename
);
3829 if (last_functionname
!= NULL
)
3830 free (last_functionname
);
3834 dump_relocs_in_section (bfd
*abfd
,
3836 void *dummy ATTRIBUTE_UNUSED
)
3838 arelent
**relpp
= NULL
;
3842 if ( bfd_is_abs_section (section
)
3843 || bfd_is_und_section (section
)
3844 || bfd_is_com_section (section
)
3845 || (! process_section_p (section
))
3846 || ((section
->flags
& SEC_RELOC
) == 0))
3849 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
3851 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3854 printf (" (none)\n\n");
3862 relpp
= (arelent
**) xmalloc (relsize
);
3863 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3869 non_fatal (_("failed to read relocs in: %s"),
3870 sanitize_string (bfd_get_filename (abfd
)));
3871 bfd_fatal (_("error message was"));
3873 else if (relcount
== 0)
3874 printf (" (none)\n\n");
3878 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3885 dump_relocs (bfd
*abfd
)
3887 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3891 dump_dynamic_relocs (bfd
*abfd
)
3897 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3899 bfd_fatal (bfd_get_filename (abfd
));
3901 printf ("DYNAMIC RELOCATION RECORDS");
3904 printf (" (none)\n\n");
3907 relpp
= (arelent
**) xmalloc (relsize
);
3908 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3911 bfd_fatal (bfd_get_filename (abfd
));
3912 else if (relcount
== 0)
3913 printf (" (none)\n\n");
3917 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3924 /* Creates a table of paths, to search for source files. */
3927 add_include_path (const char *path
)
3931 include_path_count
++;
3932 include_paths
= (const char **)
3933 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3934 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3935 if (path
[1] == ':' && path
[2] == 0)
3936 path
= concat (path
, ".", (const char *) 0);
3938 include_paths
[include_path_count
- 1] = path
;
3942 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3946 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3948 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3949 section
->vma
+= adjust_section_vma
;
3951 section
->lma
+= adjust_section_vma
;
3955 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
3958 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
3963 mask
= (bfd_vma
) 1 << (arch_size
- 1);
3964 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
3967 /* Dump selected contents of ABFD. */
3970 dump_bfd (bfd
*abfd
, bfd_boolean is_mainfile
)
3972 const struct elf_backend_data
* bed
;
3974 if (bfd_big_endian (abfd
))
3975 byte_get
= byte_get_big_endian
;
3976 else if (bfd_little_endian (abfd
))
3977 byte_get
= byte_get_little_endian
;
3981 /* Load any separate debug information files.
3982 We do this now and without checking do_follow_links because separate
3983 debug info files may contain symbol tables that we will need when
3984 displaying information about the main file. Any memory allocated by
3985 load_separate_debug_files will be released when we call
3986 free_debug_memory below.
3988 The test on is_mainfile is there because the chain of separate debug
3989 info files is a global variable shared by all invocations of dump_bfd. */
3992 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
3994 /* If asked to do so, recursively dump the separate files. */
3995 if (do_follow_links
)
3999 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4000 dump_bfd (i
->handle
, FALSE
);
4004 /* Adjust user-specified start and stop limits for targets that use
4005 signed addresses. */
4006 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
4007 && (bed
= get_elf_backend_data (abfd
)) != NULL
4008 && bed
->sign_extend_vma
)
4010 start_address
= sign_extend_address (abfd
, start_address
,
4012 stop_address
= sign_extend_address (abfd
, stop_address
,
4016 /* If we are adjusting section VMA's, change them all now. Changing
4017 the BFD information is a hack. However, we must do it, or
4018 bfd_find_nearest_line will not do the right thing. */
4019 if (adjust_section_vma
!= 0)
4021 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
4022 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
4025 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4026 printf (_("\n%s: file format %s\n"),
4027 sanitize_string (bfd_get_filename (abfd
)),
4030 print_arelt_descr (stdout
, abfd
, TRUE
, FALSE
);
4031 if (dump_file_header
)
4032 dump_bfd_header (abfd
);
4033 if (dump_private_headers
)
4034 dump_bfd_private_header (abfd
);
4035 if (dump_private_options
!= NULL
)
4036 dump_target_specific (abfd
);
4037 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4044 || dump_dwarf_section_info
)
4046 syms
= slurp_symtab (abfd
);
4048 /* If following links, load any symbol tables from the linked files as well. */
4049 if (do_follow_links
&& is_mainfile
)
4053 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4055 asymbol
** extra_syms
;
4056 long old_symcount
= symcount
;
4058 extra_syms
= slurp_symtab (i
->handle
);
4062 if (old_symcount
== 0)
4068 syms
= xrealloc (syms
, (symcount
+ old_symcount
) * sizeof (asymbol
*));
4069 memcpy (syms
+ old_symcount
,
4071 symcount
* sizeof (asymbol
*));
4075 symcount
+= old_symcount
;
4080 if (dump_section_headers
)
4081 dump_headers (abfd
);
4083 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
4084 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
4085 dynsyms
= slurp_dynamic_symtab (abfd
);
4089 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
4090 dynsymcount
, dynsyms
, &synthsyms
);
4096 dump_symbols (abfd
, FALSE
);
4097 if (dump_dynamic_symtab
)
4098 dump_symbols (abfd
, TRUE
);
4099 if (dump_dwarf_section_info
)
4101 if (dump_ctf_section_info
)
4102 dump_ctf (abfd
, dump_ctf_section_name
, dump_ctf_parent_name
);
4103 if (dump_stab_section_info
)
4105 if (dump_reloc_info
&& ! disassemble
)
4107 if (dump_dynamic_reloc_info
&& ! disassemble
)
4108 dump_dynamic_relocs (abfd
);
4109 if (dump_section_contents
)
4112 disassemble_data (abfd
);
4118 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
4119 if (dhandle
!= NULL
)
4121 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
4123 dump_debugging_tags
? TRUE
: FALSE
))
4125 non_fatal (_("%s: printing debugging information failed"),
4126 bfd_get_filename (abfd
));
4132 /* PR 6483: If there was no STABS debug info in the file, try
4134 else if (! dump_dwarf_section_info
)
4136 dwarf_select_sections_all ();
4164 free_debug_memory ();
4168 display_object_bfd (bfd
*abfd
)
4172 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
4174 dump_bfd (abfd
, TRUE
);
4178 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4180 nonfatal (bfd_get_filename (abfd
));
4181 list_matching_formats (matching
);
4186 if (bfd_get_error () != bfd_error_file_not_recognized
)
4188 nonfatal (bfd_get_filename (abfd
));
4192 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
4194 dump_bfd (abfd
, TRUE
);
4198 nonfatal (bfd_get_filename (abfd
));
4200 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4202 list_matching_formats (matching
);
4208 display_any_bfd (bfd
*file
, int level
)
4210 /* Decompress sections unless dumping the section contents. */
4211 if (!dump_section_contents
)
4212 file
->flags
|= BFD_DECOMPRESS
;
4214 /* If the file is an archive, process all of its elements. */
4215 if (bfd_check_format (file
, bfd_archive
))
4218 bfd
*last_arfile
= NULL
;
4221 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
4222 else if (level
> 100)
4224 /* Prevent corrupted files from spinning us into an
4225 infinite loop. 100 is an arbitrary heuristic. */
4226 fatal (_("Archive nesting is too deep"));
4230 printf (_("In nested archive %s:\n"),
4231 sanitize_string (bfd_get_filename (file
)));
4235 bfd_set_error (bfd_error_no_error
);
4237 arfile
= bfd_openr_next_archived_file (file
, arfile
);
4240 if (bfd_get_error () != bfd_error_no_more_archived_files
)
4241 nonfatal (bfd_get_filename (file
));
4245 display_any_bfd (arfile
, level
+ 1);
4247 if (last_arfile
!= NULL
)
4249 bfd_close (last_arfile
);
4250 /* PR 17512: file: ac585d01. */
4251 if (arfile
== last_arfile
)
4257 last_arfile
= arfile
;
4260 if (last_arfile
!= NULL
)
4261 bfd_close (last_arfile
);
4264 display_object_bfd (file
);
4268 display_file (char *filename
, char *target
, bfd_boolean last_file
)
4272 if (get_file_size (filename
) < 1)
4278 file
= bfd_openr (filename
, target
);
4281 nonfatal (filename
);
4285 display_any_bfd (file
, 0);
4287 /* This is an optimization to improve the speed of objdump, especially when
4288 dumping a file with lots of associated debug informatiom. Calling
4289 bfd_close on such a file can take a non-trivial amount of time as there
4290 are lots of lists to walk and buffers to free. This is only really
4291 necessary however if we are about to load another file and we need the
4292 memory back. Otherwise, if we are about to exit, then we can save (a lot
4293 of) time by only doing a quick close, and allowing the OS to reclaim the
4298 bfd_close_all_done (file
);
4302 main (int argc
, char **argv
)
4305 char *target
= default_target
;
4306 bfd_boolean seenflag
= FALSE
;
4308 #if defined (HAVE_SETLOCALE)
4309 #if defined (HAVE_LC_MESSAGES)
4310 setlocale (LC_MESSAGES
, "");
4312 setlocale (LC_CTYPE
, "");
4315 bindtextdomain (PACKAGE
, LOCALEDIR
);
4316 textdomain (PACKAGE
);
4318 program_name
= *argv
;
4319 xmalloc_set_program_name (program_name
);
4320 bfd_set_error_program_name (program_name
);
4322 START_PROGRESS (program_name
, 0);
4324 expandargv (&argc
, &argv
);
4326 if (bfd_init () != BFD_INIT_MAGIC
)
4327 fatal (_("fatal error: libbfd ABI mismatch"));
4328 set_default_bfd_target ();
4330 while ((c
= getopt_long (argc
, argv
,
4331 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
4332 long_options
, (int *) 0))
4338 break; /* We've been given a long option. */
4345 if (disassembler_options
)
4346 /* Ignore potential memory leak for now. */
4347 options
= concat (disassembler_options
, ",",
4348 optarg
, (const char *) NULL
);
4351 disassembler_options
= remove_whitespace_and_extra_commas (options
);
4358 display_file_offsets
= TRUE
;
4361 with_line_numbers
= TRUE
;
4370 enum demangling_styles style
;
4372 style
= cplus_demangle_name_to_style (optarg
);
4373 if (style
== unknown_demangling
)
4374 fatal (_("unknown demangling style `%s'"),
4377 cplus_demangle_set_style (style
);
4380 case OPTION_RECURSE_LIMIT
:
4381 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
4383 case OPTION_NO_RECURSE_LIMIT
:
4384 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
4387 do_wide
= wide_output
= TRUE
;
4389 case OPTION_ADJUST_VMA
:
4390 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
4392 case OPTION_START_ADDRESS
:
4393 start_address
= parse_vma (optarg
, "--start-address");
4394 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4395 fatal (_("error: the start address should be before the end address"));
4397 case OPTION_STOP_ADDRESS
:
4398 stop_address
= parse_vma (optarg
, "--stop-address");
4399 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4400 fatal (_("error: the stop address should be after the start address"));
4404 prefix_length
= strlen (prefix
);
4405 /* Remove an unnecessary trailing '/' */
4406 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
4409 case OPTION_PREFIX_STRIP
:
4410 prefix_strip
= atoi (optarg
);
4411 if (prefix_strip
< 0)
4412 fatal (_("error: prefix strip must be non-negative"));
4414 case OPTION_INSN_WIDTH
:
4415 insn_width
= strtoul (optarg
, NULL
, 0);
4416 if (insn_width
<= 0)
4417 fatal (_("error: instruction width must be positive"));
4419 case OPTION_INLINES
:
4420 unwind_inlines
= TRUE
;
4423 if (strcmp (optarg
, "B") == 0)
4424 endian
= BFD_ENDIAN_BIG
;
4425 else if (strcmp (optarg
, "L") == 0)
4426 endian
= BFD_ENDIAN_LITTLE
;
4429 nonfatal (_("unrecognized -E option"));
4434 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
4435 endian
= BFD_ENDIAN_BIG
;
4436 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
4437 endian
= BFD_ENDIAN_LITTLE
;
4440 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
4447 dump_file_header
= TRUE
;
4451 formats_info
= TRUE
;
4455 add_include_path (optarg
);
4458 dump_private_headers
= TRUE
;
4462 dump_private_options
= optarg
;
4466 dump_private_headers
= TRUE
;
4468 dump_reloc_info
= TRUE
;
4469 dump_file_header
= TRUE
;
4470 dump_ar_hdrs
= TRUE
;
4471 dump_section_headers
= TRUE
;
4479 dump_dynamic_symtab
= TRUE
;
4485 disasm_sym
= optarg
;
4488 disassemble_zeroes
= TRUE
;
4492 disassemble_all
= TRUE
;
4497 with_source_code
= TRUE
;
4500 case OPTION_SOURCE_COMMENT
:
4502 with_source_code
= TRUE
;
4505 source_comment
= xstrdup (sanitize_string (optarg
));
4507 source_comment
= xstrdup ("# ");
4515 dump_debugging_tags
= 1;
4520 dump_dwarf_section_info
= TRUE
;
4523 dwarf_select_sections_by_letters (optarg
);
4525 dwarf_select_sections_all ();
4528 dump_dwarf_section_info
= TRUE
;
4531 dwarf_select_sections_by_names (optarg
);
4533 dwarf_select_sections_all ();
4535 case OPTION_DWARF_DEPTH
:
4538 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4541 case OPTION_DWARF_START
:
4544 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4545 suppress_bfd_header
= 1;
4548 case OPTION_DWARF_CHECK
:
4552 dump_ctf_section_info
= TRUE
;
4553 dump_ctf_section_name
= xstrdup (optarg
);
4556 case OPTION_CTF_PARENT
:
4557 dump_ctf_parent_name
= xstrdup (optarg
);
4560 dump_stab_section_info
= TRUE
;
4564 dump_section_contents
= TRUE
;
4568 dump_reloc_info
= TRUE
;
4572 dump_dynamic_reloc_info
= TRUE
;
4576 dump_ar_hdrs
= TRUE
;
4580 dump_section_headers
= TRUE
;
4585 show_version
= TRUE
;
4591 /* No need to set seenflag or to break - usage() does not return. */
4598 print_version ("objdump");
4604 exit_status
= display_info ();
4608 display_file ("a.out", target
, TRUE
);
4610 for (; optind
< argc
;)
4612 display_file (argv
[optind
], target
, optind
== argc
- 1);
4618 free (dump_ctf_section_name
);
4619 free (dump_ctf_parent_name
);
4620 free ((void *) source_comment
);
4622 END_PROGRESS (program_name
);