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
, section
);
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
)
588 PF (SEC_ELF_OCTETS
, "OCTETS");
589 PF (SEC_ELF_PURECODE
, "PURECODE");
591 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
592 PF (SEC_GROUP
, "GROUP");
593 if (bfd_get_arch (abfd
) == bfd_arch_mep
)
595 PF (SEC_MEP_VLIW
, "VLIW");
598 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
601 struct coff_comdat_info
*comdat
;
603 switch (section
->flags
& SEC_LINK_DUPLICATES
)
607 case SEC_LINK_DUPLICATES_DISCARD
:
608 ls
= "LINK_ONCE_DISCARD";
610 case SEC_LINK_DUPLICATES_ONE_ONLY
:
611 ls
= "LINK_ONCE_ONE_ONLY";
613 case SEC_LINK_DUPLICATES_SAME_SIZE
:
614 ls
= "LINK_ONCE_SAME_SIZE";
616 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
617 ls
= "LINK_ONCE_SAME_CONTENTS";
620 printf ("%s%s", comma
, ls
);
622 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
624 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
633 /* Called on each SECTION in ABFD, update the int variable pointed to by
634 DATA which contains the string length of the longest section name. */
637 find_longest_section_name (bfd
*abfd ATTRIBUTE_UNUSED
,
638 asection
*section
, void *data
)
640 int *longest_so_far
= (int *) data
;
644 /* Ignore linker created section. */
645 if (section
->flags
& SEC_LINKER_CREATED
)
648 /* Skip sections that we are ignoring. */
649 if (! process_section_p (section
))
652 name
= bfd_section_name (section
);
653 len
= (int) strlen (name
);
654 if (len
> *longest_so_far
)
655 *longest_so_far
= len
;
659 dump_headers (bfd
*abfd
)
661 /* The default width of 13 is just an arbitrary choice. */
662 int max_section_name_length
= 13;
668 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
669 if (bfd_get_arch_size (abfd
) == 32)
675 printf (_("Sections:\n"));
678 bfd_map_over_sections (abfd
, find_longest_section_name
,
679 &max_section_name_length
);
681 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
682 max_section_name_length
, "Name",
683 bfd_vma_width
, "VMA",
684 bfd_vma_width
, "LMA");
687 printf (_(" Flags"));
690 bfd_map_over_sections (abfd
, dump_section_header
,
691 &max_section_name_length
);
695 slurp_symtab (bfd
*abfd
)
700 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
706 storage
= bfd_get_symtab_upper_bound (abfd
);
709 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
710 bfd_fatal (_("error message was"));
714 off_t filesize
= bfd_get_file_size (abfd
);
718 && filesize
< storage
719 /* The MMO file format supports its own special compression
720 technique, so its sections can be larger than the file size. */
721 && bfd_get_flavour (abfd
) != bfd_target_mmo_flavour
)
723 bfd_nonfatal_message (bfd_get_filename (abfd
), abfd
, NULL
,
724 _("error: symbol table size (%#lx) is larger than filesize (%#lx)"),
725 storage
, (long) filesize
);
731 sy
= (asymbol
**) xmalloc (storage
);
734 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
736 bfd_fatal (bfd_get_filename (abfd
));
740 /* Read in the dynamic symbols. */
743 slurp_dynamic_symtab (bfd
*abfd
)
748 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
751 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
753 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
759 bfd_fatal (bfd_get_filename (abfd
));
762 sy
= (asymbol
**) xmalloc (storage
);
764 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
766 bfd_fatal (bfd_get_filename (abfd
));
770 /* Some symbol names are significant and should be kept in the
771 table of sorted symbol names, even if they are marked as
772 debugging/section symbols. */
775 is_significant_symbol_name (const char * name
)
777 return strncmp (name
, ".plt", 4) == 0 || strcmp (name
, ".got") == 0;
780 /* Filter out (in place) symbols that are useless for disassembly.
781 COUNT is the number of elements in SYMBOLS.
782 Return the number of useful symbols. */
785 remove_useless_symbols (asymbol
**symbols
, long count
)
787 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
791 asymbol
*sym
= *in_ptr
++;
793 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
795 if ((sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
796 && ! is_significant_symbol_name (sym
->name
))
798 if (bfd_is_und_section (sym
->section
)
799 || bfd_is_com_section (sym
->section
))
804 return out_ptr
- symbols
;
807 /* Sort symbols into value order. */
810 compare_symbols (const void *ap
, const void *bp
)
812 const asymbol
*a
= * (const asymbol
**) ap
;
813 const asymbol
*b
= * (const asymbol
**) bp
;
823 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
825 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
828 if (a
->section
> b
->section
)
830 else if (a
->section
< b
->section
)
833 an
= bfd_asymbol_name (a
);
834 bn
= bfd_asymbol_name (b
);
838 /* The symbols gnu_compiled and gcc2_compiled convey no real
839 information, so put them after other symbols with the same value. */
840 af
= (strstr (an
, "gnu_compiled") != NULL
841 || strstr (an
, "gcc2_compiled") != NULL
);
842 bf
= (strstr (bn
, "gnu_compiled") != NULL
843 || strstr (bn
, "gcc2_compiled") != NULL
);
850 /* We use a heuristic for the file name, to try to sort it after
851 more useful symbols. It may not work on non Unix systems, but it
852 doesn't really matter; the only difference is precisely which
853 symbol names get printed. */
855 #define file_symbol(s, sn, snl) \
856 (((s)->flags & BSF_FILE) != 0 \
857 || ((sn)[(snl) - 2] == '.' \
858 && ((sn)[(snl) - 1] == 'o' \
859 || (sn)[(snl) - 1] == 'a')))
861 af
= file_symbol (a
, an
, anl
);
862 bf
= file_symbol (b
, bn
, bnl
);
869 /* Try to sort global symbols before local symbols before function
870 symbols before debugging symbols. */
875 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
877 if ((aflags
& BSF_DEBUGGING
) != 0)
882 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
884 if ((aflags
& BSF_FUNCTION
) != 0)
889 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
891 if ((aflags
& BSF_LOCAL
) != 0)
896 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
898 if ((aflags
& BSF_GLOBAL
) != 0)
904 if (bfd_get_flavour (bfd_asymbol_bfd (a
)) == bfd_target_elf_flavour
905 && bfd_get_flavour (bfd_asymbol_bfd (b
)) == bfd_target_elf_flavour
)
910 if ((a
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
911 asz
= ((elf_symbol_type
*) a
)->internal_elf_sym
.st_size
;
913 if ((b
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
914 bsz
= ((elf_symbol_type
*) b
)->internal_elf_sym
.st_size
;
916 return asz
> bsz
? -1 : 1;
919 /* Symbols that start with '.' might be section names, so sort them
920 after symbols that don't start with '.'. */
921 if (an
[0] == '.' && bn
[0] != '.')
923 if (an
[0] != '.' && bn
[0] == '.')
926 /* Finally, if we can't distinguish them in any other way, try to
927 get consistent results by sorting the symbols by name. */
928 return strcmp (an
, bn
);
931 /* Sort relocs into address order. */
934 compare_relocs (const void *ap
, const void *bp
)
936 const arelent
*a
= * (const arelent
**) ap
;
937 const arelent
*b
= * (const arelent
**) bp
;
939 if (a
->address
> b
->address
)
941 else if (a
->address
< b
->address
)
944 /* So that associated relocations tied to the same address show up
945 in the correct order, we don't do any further sorting. */
954 /* Print an address (VMA) to the output stream in INFO.
955 If SKIP_ZEROES is TRUE, omit leading zeroes. */
958 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
959 bfd_boolean skip_zeroes
)
963 struct objdump_disasm_info
*aux
;
965 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
966 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
971 for (p
= buf
; *p
== '0'; ++p
)
976 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
979 /* Print the name of a symbol. */
982 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
986 const char *name
, *version_string
= NULL
;
987 bfd_boolean hidden
= FALSE
;
990 name
= bfd_asymbol_name (sym
);
991 if (do_demangle
&& name
[0] != '\0')
993 /* Demangle the name. */
994 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
999 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
1000 version_string
= bfd_get_symbol_version_string (abfd
, sym
, &hidden
);
1002 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1005 name
= sanitize_string (name
);
1009 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
1010 if (version_string
&& *version_string
!= '\0')
1011 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
1016 printf ("%s", name
);
1017 if (version_string
&& *version_string
!= '\0')
1018 printf (hidden
? "@%s" : "@@%s", version_string
);
1025 static inline bfd_boolean
1026 sym_ok (bfd_boolean want_section
,
1027 bfd
* abfd ATTRIBUTE_UNUSED
,
1030 struct disassemble_info
* inf
)
1034 /* Note - we cannot just compare section pointers because they could
1035 be different, but the same... Ie the symbol that we are trying to
1036 find could have come from a separate debug info file. Under such
1037 circumstances the symbol will be associated with a section in the
1038 debug info file, whilst the section we want is in a normal file.
1039 So the section pointers will be different, but the section names
1040 will be the same. */
1041 if (strcmp (bfd_section_name (sorted_syms
[place
]->section
),
1042 bfd_section_name (sec
)) != 0)
1046 return inf
->symbol_is_valid (sorted_syms
[place
], inf
);
1049 /* Locate a symbol given a bfd and a section (from INFO->application_data),
1050 and a VMA. If INFO->application_data->require_sec is TRUE, then always
1051 require the symbol to be in the section. Returns NULL if there is no
1052 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
1053 of the symbol in sorted_syms. */
1056 find_symbol_for_address (bfd_vma vma
,
1057 struct disassemble_info
*inf
,
1060 /* @@ Would it speed things up to cache the last two symbols returned,
1061 and maybe their address ranges? For many processors, only one memory
1062 operand can be present at a time, so the 2-entry cache wouldn't be
1063 constantly churned by code doing heavy memory accesses. */
1065 /* Indices in `sorted_syms'. */
1067 long max_count
= sorted_symcount
;
1069 struct objdump_disasm_info
*aux
;
1073 bfd_boolean want_section
;
1076 if (sorted_symcount
< 1)
1079 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1082 opb
= inf
->octets_per_byte
;
1084 /* Perform a binary search looking for the closest symbol to the
1085 required value. We are searching the range (min, max_count]. */
1086 while (min
+ 1 < max_count
)
1090 thisplace
= (max_count
+ min
) / 2;
1091 sym
= sorted_syms
[thisplace
];
1093 if (bfd_asymbol_value (sym
) > vma
)
1094 max_count
= thisplace
;
1095 else if (bfd_asymbol_value (sym
) < vma
)
1104 /* The symbol we want is now in min, the low end of the range we
1105 were searching. If there are several symbols with the same
1106 value, we want the first (non-section/non-debugging) one. */
1108 while (thisplace
> 0
1109 && (bfd_asymbol_value (sorted_syms
[thisplace
])
1110 == bfd_asymbol_value (sorted_syms
[thisplace
- 1]))
1111 && ((sorted_syms
[thisplace
- 1]->flags
1112 & (BSF_SECTION_SYM
| BSF_DEBUGGING
)) == 0)
1116 /* Prefer a symbol in the current section if we have multple symbols
1117 with the same value, as can occur with overlays or zero size
1120 while (min
< max_count
1121 && (bfd_asymbol_value (sorted_syms
[min
])
1122 == bfd_asymbol_value (sorted_syms
[thisplace
])))
1124 if (sym_ok (TRUE
, abfd
, min
, sec
, inf
))
1131 return sorted_syms
[thisplace
];
1136 /* If the file is relocatable, and the symbol could be from this
1137 section, prefer a symbol from this section over symbols from
1138 others, even if the other symbol's value might be closer.
1140 Note that this may be wrong for some symbol references if the
1141 sections have overlapping memory ranges, but in that case there's
1142 no way to tell what's desired without looking at the relocation
1145 Also give the target a chance to reject symbols. */
1146 want_section
= (aux
->require_sec
1147 || ((abfd
->flags
& HAS_RELOC
) != 0
1148 && vma
>= bfd_section_vma (sec
)
1149 && vma
< (bfd_section_vma (sec
)
1150 + bfd_section_size (sec
) / opb
)));
1152 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1155 long newplace
= sorted_symcount
;
1157 for (i
= min
- 1; i
>= 0; i
--)
1159 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1161 if (newplace
== sorted_symcount
)
1164 if (bfd_asymbol_value (sorted_syms
[i
])
1165 != bfd_asymbol_value (sorted_syms
[newplace
]))
1168 /* Remember this symbol and keep searching until we reach
1169 an earlier address. */
1174 if (newplace
!= sorted_symcount
)
1175 thisplace
= newplace
;
1178 /* We didn't find a good symbol with a smaller value.
1179 Look for one with a larger value. */
1180 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1182 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1190 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1191 /* There is no suitable symbol. */
1195 /* If we have not found an exact match for the specified address
1196 and we have dynamic relocations available, then we can produce
1197 a better result by matching a relocation to the address and
1198 using the symbol associated with that relocation. */
1199 rel_count
= aux
->dynrelcount
;
1201 && sorted_syms
[thisplace
]->value
!= vma
1203 && aux
->dynrelbuf
!= NULL
1204 && aux
->dynrelbuf
[0]->address
<= vma
1205 && aux
->dynrelbuf
[rel_count
- 1]->address
>= vma
1206 /* If we have matched a synthetic symbol, then stick with that. */
1207 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1210 arelent
** rel_high
;
1212 rel_low
= aux
->dynrelbuf
;
1213 rel_high
= rel_low
+ rel_count
- 1;
1214 while (rel_low
<= rel_high
)
1216 arelent
**rel_mid
= &rel_low
[(rel_high
- rel_low
) / 2];
1217 arelent
* rel
= *rel_mid
;
1219 if (rel
->address
== vma
)
1221 /* Absolute relocations do not provide a more helpful
1222 symbolic address. Find a non-absolute relocation
1223 with the same address. */
1224 arelent
**rel_vma
= rel_mid
;
1226 rel_mid
>= rel_low
&& rel_mid
[0]->address
== vma
;
1230 for (; rel_vma
<= rel_high
&& rel_vma
[0]->address
== vma
;
1234 if (rel
->sym_ptr_ptr
!= NULL
1235 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1238 * place
= thisplace
;
1239 return * rel
->sym_ptr_ptr
;
1245 if (vma
< rel
->address
)
1247 else if (vma
>= rel_mid
[1]->address
)
1248 rel_low
= rel_mid
+ 1;
1257 return sorted_syms
[thisplace
];
1260 /* Print an address and the offset to the nearest symbol. */
1263 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1264 bfd_vma vma
, struct disassemble_info
*inf
,
1265 bfd_boolean skip_zeroes
)
1267 objdump_print_value (vma
, inf
, skip_zeroes
);
1273 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
1274 sanitize_string (bfd_section_name (sec
)));
1275 secaddr
= bfd_section_vma (sec
);
1278 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1279 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
1281 else if (vma
> secaddr
)
1283 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1284 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
1286 (*inf
->fprintf_func
) (inf
->stream
, ">");
1290 (*inf
->fprintf_func
) (inf
->stream
, " <");
1292 objdump_print_symname (abfd
, inf
, sym
);
1294 if (bfd_asymbol_value (sym
) == vma
)
1296 /* Undefined symbols in an executables and dynamic objects do not have
1297 a value associated with them, so it does not make sense to display
1298 an offset relative to them. Normally we would not be provided with
1299 this kind of symbol, but the target backend might choose to do so,
1300 and the code in find_symbol_for_address might return an as yet
1301 unresolved symbol associated with a dynamic reloc. */
1302 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1303 && bfd_is_und_section (sym
->section
))
1305 else if (bfd_asymbol_value (sym
) > vma
)
1307 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1308 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1310 else if (vma
> bfd_asymbol_value (sym
))
1312 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1313 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1316 (*inf
->fprintf_func
) (inf
->stream
, ">");
1319 if (display_file_offsets
)
1320 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1321 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1324 /* Print an address (VMA), symbolically if possible.
1325 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1328 objdump_print_addr (bfd_vma vma
,
1329 struct disassemble_info
*inf
,
1330 bfd_boolean skip_zeroes
)
1332 struct objdump_disasm_info
*aux
;
1333 asymbol
*sym
= NULL
;
1334 bfd_boolean skip_find
= FALSE
;
1336 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1338 if (sorted_symcount
< 1)
1340 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1341 objdump_print_value (vma
, inf
, skip_zeroes
);
1343 if (display_file_offsets
)
1344 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1345 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
1349 if (aux
->reloc
!= NULL
1350 && aux
->reloc
->sym_ptr_ptr
!= NULL
1351 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1353 sym
= * aux
->reloc
->sym_ptr_ptr
;
1355 /* Adjust the vma to the reloc. */
1356 vma
+= bfd_asymbol_value (sym
);
1358 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1363 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1365 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, inf
,
1369 /* Print VMA to INFO. This function is passed to the disassembler
1373 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1375 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1378 /* Determine if the given address has a symbol associated with it. */
1381 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1385 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1387 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1390 /* Hold the last function name and the last line number we displayed
1391 in a disassembly. */
1393 static char *prev_functionname
;
1394 static unsigned int prev_line
;
1395 static unsigned int prev_discriminator
;
1397 /* We keep a list of all files that we have seen when doing a
1398 disassembly with source, so that we know how much of the file to
1399 display. This can be important for inlined functions. */
1401 struct print_file_list
1403 struct print_file_list
*next
;
1404 const char *filename
;
1405 const char *modname
;
1408 const char **linemap
;
1411 unsigned max_printed
;
1415 static struct print_file_list
*print_files
;
1417 /* The number of preceding context lines to show when we start
1418 displaying a file for the first time. */
1420 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1422 /* Read a complete file into memory. */
1425 slurp_file (const char *fn
, size_t *size
, struct stat
*fst
)
1428 int ps
= getpagesize ();
1432 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1436 if (fstat (fd
, fst
) < 0)
1441 *size
= fst
->st_size
;
1443 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1444 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1445 if (map
!= (char *) -1L)
1451 map
= (const char *) malloc (*size
);
1452 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1454 free ((void *) map
);
1461 #define line_map_decrease 5
1463 /* Precompute array of lines for a mapped file. */
1465 static const char **
1466 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1468 const char *p
, *lstart
, *end
;
1469 int chars_per_line
= 45; /* First iteration will use 40. */
1470 unsigned int lineno
;
1471 const char **linemap
= NULL
;
1472 unsigned long line_map_size
= 0;
1478 for (p
= map
; p
< end
; p
++)
1482 if (p
+ 1 < end
&& p
[1] == '\r')
1485 else if (*p
== '\r')
1487 if (p
+ 1 < end
&& p
[1] == '\n')
1493 /* End of line found. */
1495 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1497 unsigned long newsize
;
1499 chars_per_line
-= line_map_decrease
;
1500 if (chars_per_line
<= 1)
1502 line_map_size
= size
/ chars_per_line
+ 1;
1503 if (line_map_size
< lineno
+ 1)
1504 line_map_size
= lineno
+ 1;
1505 newsize
= line_map_size
* sizeof (char *);
1506 linemap
= (const char **) xrealloc (linemap
, newsize
);
1509 linemap
[lineno
++] = lstart
;
1517 /* Tries to open MODNAME, and if successful adds a node to print_files
1518 linked list and returns that node. Returns NULL on failure. */
1520 static struct print_file_list
*
1521 try_print_file_open (const char *origname
, const char *modname
, struct stat
*fst
)
1523 struct print_file_list
*p
;
1525 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1527 p
->map
= slurp_file (modname
, &p
->mapsize
, fst
);
1534 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1537 p
->filename
= origname
;
1538 p
->modname
= modname
;
1539 p
->next
= print_files
;
1545 /* If the source file, as described in the symtab, is not found
1546 try to locate it in one of the paths specified with -I
1547 If found, add location to print_files linked list. */
1549 static struct print_file_list
*
1550 update_source_path (const char *filename
, bfd
*abfd
)
1552 struct print_file_list
*p
;
1557 p
= try_print_file_open (filename
, filename
, &fst
);
1560 if (include_path_count
== 0)
1563 /* Get the name of the file. */
1564 fname
= lbasename (filename
);
1566 /* If file exists under a new path, we need to add it to the list
1567 so that show_line knows about it. */
1568 for (i
= 0; i
< include_path_count
; i
++)
1570 char *modname
= concat (include_paths
[i
], "/", fname
,
1573 p
= try_print_file_open (filename
, modname
, &fst
);
1583 long mtime
= bfd_get_mtime (abfd
);
1585 if (fst
.st_mtime
> mtime
)
1586 warn (_("source file %s is more recent than object file\n"),
1593 /* Print a source file line. */
1596 print_line (struct print_file_list
*p
, unsigned int linenum
)
1602 if (linenum
>= p
->maxline
)
1604 l
= p
->linemap
[linenum
];
1605 if (source_comment
!= NULL
&& strlen (l
) > 0)
1606 printf ("%s", source_comment
);
1607 len
= strcspn (l
, "\n\r");
1608 /* Test fwrite return value to quiet glibc warning. */
1609 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1613 /* Print a range of source code lines. */
1616 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1620 while (start
<= end
)
1622 print_line (p
, start
);
1627 /* Show the line number, or the source line, in a disassembly
1631 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1633 const char *filename
;
1634 const char *functionname
;
1635 unsigned int linenumber
;
1636 unsigned int discriminator
;
1640 if (! with_line_numbers
&& ! with_source_code
)
1643 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1644 &filename
, &functionname
,
1645 &linenumber
, &discriminator
))
1648 if (filename
!= NULL
&& *filename
== '\0')
1650 if (functionname
!= NULL
&& *functionname
== '\0')
1651 functionname
= NULL
;
1654 && IS_ABSOLUTE_PATH (filename
)
1658 const char *fname
= filename
;
1660 path
= xmalloc (prefix_length
+ PATH_MAX
+ 1);
1663 memcpy (path
, prefix
, prefix_length
);
1664 path_up
= path
+ prefix_length
;
1666 /* Build relocated filename, stripping off leading directories
1667 from the initial filename if requested. */
1668 if (prefix_strip
> 0)
1673 /* Skip selected directory levels. */
1674 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1675 if (IS_DIR_SEPARATOR(*s
))
1682 /* Update complete filename. */
1683 strncpy (path_up
, fname
, PATH_MAX
);
1684 path_up
[PATH_MAX
] = '\0';
1692 if (with_line_numbers
)
1694 if (functionname
!= NULL
1695 && (prev_functionname
== NULL
1696 || strcmp (functionname
, prev_functionname
) != 0))
1698 printf ("%s():\n", sanitize_string (functionname
));
1702 && (linenumber
!= prev_line
1703 || discriminator
!= prev_discriminator
))
1705 if (discriminator
> 0)
1706 printf ("%s:%u (discriminator %u)\n",
1707 filename
== NULL
? "???" : sanitize_string (filename
),
1708 linenumber
, discriminator
);
1710 printf ("%s:%u\n", filename
== NULL
1711 ? "???" : sanitize_string (filename
),
1716 const char *filename2
;
1717 const char *functionname2
;
1720 while (bfd_find_inliner_info (abfd
, &filename2
, &functionname2
,
1723 printf ("inlined by %s:%u",
1724 sanitize_string (filename2
), line2
);
1725 printf (" (%s)\n", sanitize_string (functionname2
));
1730 if (with_source_code
1734 struct print_file_list
**pp
, *p
;
1737 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1738 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1745 filename
= xstrdup (filename
);
1746 p
= update_source_path (filename
, abfd
);
1749 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1751 if (file_start_context
&& p
->first
)
1755 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1756 if (l
>= linenumber
)
1758 if (p
->max_printed
>= l
)
1760 if (p
->max_printed
< linenumber
)
1761 l
= p
->max_printed
+ 1;
1766 dump_lines (p
, l
, linenumber
);
1767 if (p
->max_printed
< linenumber
)
1768 p
->max_printed
= linenumber
;
1769 p
->last_line
= linenumber
;
1774 if (functionname
!= NULL
1775 && (prev_functionname
== NULL
1776 || strcmp (functionname
, prev_functionname
) != 0))
1778 if (prev_functionname
!= NULL
)
1779 free (prev_functionname
);
1780 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1781 strcpy (prev_functionname
, functionname
);
1784 if (linenumber
> 0 && linenumber
!= prev_line
)
1785 prev_line
= linenumber
;
1787 if (discriminator
!= prev_discriminator
)
1788 prev_discriminator
= discriminator
;
1794 /* Pseudo FILE object for strings. */
1802 /* sprintf to a "stream". */
1804 static int ATTRIBUTE_PRINTF_2
1805 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1812 size_t space
= f
->alloc
- f
->pos
;
1814 va_start (args
, format
);
1815 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1821 f
->alloc
= (f
->alloc
+ n
) * 2;
1822 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1829 /* The number of zeroes we want to see before we start skipping them.
1830 The number is arbitrarily chosen. */
1832 #define DEFAULT_SKIP_ZEROES 8
1834 /* The number of zeroes to skip at the end of a section. If the
1835 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1836 SKIP_ZEROES, they will be disassembled. If there are fewer than
1837 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1838 attempt to avoid disassembling zeroes inserted by section
1841 #define DEFAULT_SKIP_ZEROES_AT_END 3
1844 null_print (const void * stream ATTRIBUTE_UNUSED
, const char * format ATTRIBUTE_UNUSED
, ...)
1849 /* Disassemble some data in memory between given values. */
1852 disassemble_bytes (struct disassemble_info
* inf
,
1853 disassembler_ftype disassemble_fn
,
1856 bfd_vma start_offset
,
1857 bfd_vma stop_offset
,
1860 arelent
** relppend
)
1862 struct objdump_disasm_info
*aux
;
1864 int octets_per_line
;
1865 int skip_addr_chars
;
1866 bfd_vma addr_offset
;
1867 unsigned int opb
= inf
->octets_per_byte
;
1868 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1869 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1873 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1877 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1881 octets_per_line
= insn_width
;
1883 octets_per_line
= 4;
1885 octets_per_line
= 16;
1887 /* Figure out how many characters to skip at the start of an
1888 address, to make the disassembly look nicer. We discard leading
1889 zeroes in chunks of 4, ensuring that there is always a leading
1891 skip_addr_chars
= 0;
1892 if (! prefix_addresses
)
1896 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1898 while (buf
[skip_addr_chars
] == '0')
1901 /* Don't discard zeros on overflow. */
1902 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1903 skip_addr_chars
= 0;
1905 if (skip_addr_chars
!= 0)
1906 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1909 inf
->insn_info_valid
= 0;
1911 addr_offset
= start_offset
;
1912 while (addr_offset
< stop_offset
)
1915 bfd_boolean need_nl
= FALSE
;
1919 /* Make sure we don't use relocs from previous instructions. */
1922 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1924 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1927 if (! disassemble_zeroes
1928 && (inf
->insn_info_valid
== 0
1929 || inf
->branch_delay_insns
== 0)
1930 && (z
- addr_offset
* opb
>= skip_zeroes
1931 || (z
== stop_offset
* opb
&&
1932 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1934 /* If there are more nonzero octets to follow, we only skip
1935 zeroes in multiples of 4, to try to avoid running over
1936 the start of an instruction which happens to start with
1938 if (z
!= stop_offset
* opb
)
1939 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1941 octets
= z
- addr_offset
* opb
;
1943 /* If we are going to display more data, and we are displaying
1944 file offsets, then tell the user how many zeroes we skip
1945 and the file offset from where we resume dumping. */
1946 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1947 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1949 (unsigned long) (section
->filepos
1950 + (addr_offset
+ (octets
/ opb
))));
1960 if (with_line_numbers
|| with_source_code
)
1961 show_line (aux
->abfd
, section
, addr_offset
);
1963 if (! prefix_addresses
)
1967 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1968 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1972 printf ("%s:\t", buf
+ skip_addr_chars
);
1976 aux
->require_sec
= TRUE
;
1977 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1978 aux
->require_sec
= FALSE
;
1985 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1986 inf
->stream
= &sfile
;
1987 inf
->bytes_per_line
= 0;
1988 inf
->bytes_per_chunk
= 0;
1989 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
1990 | (wide_output
? WIDE_OUTPUT
: 0));
1992 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1994 if (inf
->disassembler_needs_relocs
1995 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1996 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1997 && *relppp
< relppend
)
1999 bfd_signed_vma distance_to_rel
;
2001 int max_reloc_offset
2002 = aux
->abfd
->arch_info
->max_reloc_offset_into_insn
;
2004 distance_to_rel
= ((**relppp
)->address
- rel_offset
2007 if (distance_to_rel
> 0
2008 && (max_reloc_offset
< 0
2009 || distance_to_rel
<= max_reloc_offset
))
2011 /* This reloc *might* apply to the current insn,
2012 starting somewhere inside it. Discover the length
2013 of the current insn so that the check below will
2016 insn_size
= insn_width
;
2019 /* We find the length by calling the dissassembler
2020 function with a dummy print handler. This should
2021 work unless the disassembler is not expecting to
2022 be called multiple times for the same address.
2024 This does mean disassembling the instruction
2025 twice, but we only do this when there is a high
2026 probability that there is a reloc that will
2027 affect the instruction. */
2028 inf
->fprintf_func
= (fprintf_ftype
) null_print
;
2029 insn_size
= disassemble_fn (section
->vma
2030 + addr_offset
, inf
);
2031 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2035 /* Check to see if the current reloc is associated with
2036 the instruction that we are about to disassemble. */
2037 if (distance_to_rel
== 0
2038 || (distance_to_rel
> 0
2039 && distance_to_rel
< insn_size
/ (int) opb
))
2041 inf
->flags
|= INSN_HAS_RELOC
;
2042 aux
->reloc
= **relppp
;
2046 if (! disassemble_all
2047 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2048 == (SEC_CODE
| SEC_HAS_CONTENTS
))
2049 /* Set a stop_vma so that the disassembler will not read
2050 beyond the next symbol. We assume that symbols appear on
2051 the boundaries between instructions. We only do this when
2052 disassembling code of course, and when -D is in effect. */
2053 inf
->stop_vma
= section
->vma
+ stop_offset
;
2055 inf
->stop_offset
= stop_offset
;
2056 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2059 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2060 inf
->stream
= stdout
;
2061 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
2062 octets_per_line
= inf
->bytes_per_line
;
2063 if (octets
< (int) opb
)
2066 printf ("%s\n", sfile
.buffer
);
2069 non_fatal (_("disassemble_fn returned length %d"),
2080 octets
= octets_per_line
;
2081 if (addr_offset
+ octets
/ opb
> stop_offset
)
2082 octets
= (stop_offset
- addr_offset
) * opb
;
2084 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
2086 if (ISPRINT (data
[j
]))
2087 buf
[j
- addr_offset
* opb
] = data
[j
];
2089 buf
[j
- addr_offset
* opb
] = '.';
2091 buf
[j
- addr_offset
* opb
] = '\0';
2094 if (prefix_addresses
2096 : show_raw_insn
>= 0)
2100 /* If ! prefix_addresses and ! wide_output, we print
2101 octets_per_line octets per line. */
2103 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
2104 pb
= octets_per_line
;
2106 if (inf
->bytes_per_chunk
)
2107 bpc
= inf
->bytes_per_chunk
;
2111 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2113 /* PR 21580: Check for a buffer ending early. */
2114 if (j
+ bpc
<= stop_offset
* opb
)
2118 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2120 for (k
= bpc
- 1; k
>= 0; k
--)
2121 printf ("%02x", (unsigned) data
[j
+ k
]);
2125 for (k
= 0; k
< bpc
; k
++)
2126 printf ("%02x", (unsigned) data
[j
+ k
]);
2132 for (; pb
< octets_per_line
; pb
+= bpc
)
2136 for (k
= 0; k
< bpc
; k
++)
2141 /* Separate raw data from instruction by extra space. */
2151 printf ("%s", sfile
.buffer
);
2153 if (prefix_addresses
2155 : show_raw_insn
>= 0)
2163 j
= addr_offset
* opb
+ pb
;
2165 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
2166 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2170 printf ("%s:\t", buf
+ skip_addr_chars
);
2172 pb
+= octets_per_line
;
2175 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2177 /* PR 21619: Check for a buffer ending early. */
2178 if (j
+ bpc
<= stop_offset
* opb
)
2182 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2184 for (k
= bpc
- 1; k
>= 0; k
--)
2185 printf ("%02x", (unsigned) data
[j
+ k
]);
2189 for (k
= 0; k
< bpc
; k
++)
2190 printf ("%02x", (unsigned) data
[j
+ k
]);
2204 while ((*relppp
) < relppend
2205 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
2207 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
2218 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
2221 if (q
->howto
== NULL
)
2222 printf (": *unknown*\t");
2223 else if (q
->howto
->name
)
2224 printf (": %s\t", q
->howto
->name
);
2226 printf (": %d\t", q
->howto
->type
);
2228 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
2229 printf ("*unknown*");
2232 const char *sym_name
;
2234 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
2235 if (sym_name
!= NULL
&& *sym_name
!= '\0')
2236 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
2241 sym_sec
= bfd_asymbol_section (*q
->sym_ptr_ptr
);
2242 sym_name
= bfd_section_name (sym_sec
);
2243 if (sym_name
== NULL
|| *sym_name
== '\0')
2244 sym_name
= "*unknown*";
2245 printf ("%s", sanitize_string (sym_name
));
2251 bfd_signed_vma addend
= q
->addend
;
2259 objdump_print_value (addend
, inf
, TRUE
);
2271 addr_offset
+= octets
/ opb
;
2274 free (sfile
.buffer
);
2278 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
2280 const struct elf_backend_data
* bed
;
2281 bfd_vma sign_adjust
= 0;
2282 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
2283 struct objdump_disasm_info
* paux
;
2284 unsigned int opb
= pinfo
->octets_per_byte
;
2285 bfd_byte
* data
= NULL
;
2286 bfd_size_type datasize
= 0;
2287 arelent
** rel_pp
= NULL
;
2288 arelent
** rel_ppstart
= NULL
;
2289 arelent
** rel_ppend
;
2290 bfd_vma stop_offset
;
2291 asymbol
* sym
= NULL
;
2295 unsigned long addr_offset
;
2296 bfd_boolean do_print
;
2299 stop_offset_reached
,
2304 /* Sections that do not contain machine
2305 code are not normally disassembled. */
2306 if (! disassemble_all
2307 && only_list
== NULL
2308 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2309 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
2312 if (! process_section_p (section
))
2315 datasize
= bfd_section_size (section
);
2319 if (start_address
== (bfd_vma
) -1
2320 || start_address
< section
->vma
)
2323 addr_offset
= start_address
- section
->vma
;
2325 if (stop_address
== (bfd_vma
) -1)
2326 stop_offset
= datasize
/ opb
;
2329 if (stop_address
< section
->vma
)
2332 stop_offset
= stop_address
- section
->vma
;
2333 if (stop_offset
> datasize
/ opb
)
2334 stop_offset
= datasize
/ opb
;
2337 if (addr_offset
>= stop_offset
)
2340 /* Decide which set of relocs to use. Load them if necessary. */
2341 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
2342 if (paux
->dynrelbuf
&& dump_dynamic_reloc_info
)
2344 rel_pp
= paux
->dynrelbuf
;
2345 rel_count
= paux
->dynrelcount
;
2346 /* Dynamic reloc addresses are absolute, non-dynamic are section
2347 relative. REL_OFFSET specifies the reloc address corresponding
2348 to the start of this section. */
2349 rel_offset
= section
->vma
;
2357 if ((section
->flags
& SEC_RELOC
) != 0
2358 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
2362 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2364 bfd_fatal (bfd_get_filename (abfd
));
2368 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
2369 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
2371 bfd_fatal (bfd_get_filename (abfd
));
2373 /* Sort the relocs by address. */
2374 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
2378 rel_ppend
= rel_pp
+ rel_count
;
2380 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2382 non_fatal (_("Reading section %s failed because: %s"),
2383 section
->name
, bfd_errmsg (bfd_get_error ()));
2387 paux
->sec
= section
;
2388 pinfo
->buffer
= data
;
2389 pinfo
->buffer_vma
= section
->vma
;
2390 pinfo
->buffer_length
= datasize
;
2391 pinfo
->section
= section
;
2393 /* Skip over the relocs belonging to addresses below the
2395 while (rel_pp
< rel_ppend
2396 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
2399 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
2401 /* Find the nearest symbol forwards from our current position. */
2402 paux
->require_sec
= TRUE
;
2403 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
2404 (struct disassemble_info
*) inf
,
2406 paux
->require_sec
= FALSE
;
2408 /* PR 9774: If the target used signed addresses then we must make
2409 sure that we sign extend the value that we calculate for 'addr'
2410 in the loop below. */
2411 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2412 && (bed
= get_elf_backend_data (abfd
)) != NULL
2413 && bed
->sign_extend_vma
)
2414 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2416 /* Disassemble a block of instructions up to the address associated with
2417 the symbol we have just found. Then print the symbol and find the
2418 next symbol on. Repeat until we have disassembled the entire section
2419 or we have reached the end of the address range we are interested in. */
2420 do_print
= paux
->symbol
== NULL
;
2421 loop_until
= stop_offset_reached
;
2423 while (addr_offset
< stop_offset
)
2427 bfd_vma nextstop_offset
;
2430 addr
= section
->vma
+ addr_offset
;
2431 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2433 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2438 (x
< sorted_symcount
2439 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2443 pinfo
->symbols
= sorted_syms
+ place
;
2444 pinfo
->num_symbols
= x
- place
;
2445 pinfo
->symtab_pos
= place
;
2449 pinfo
->symbols
= NULL
;
2450 pinfo
->num_symbols
= 0;
2451 pinfo
->symtab_pos
= -1;
2454 /* If we are only disassembling from a specific symbol,
2455 check to see if we should start or stop displaying. */
2456 if (sym
&& paux
->symbol
)
2460 /* See if we should stop printing. */
2464 if (sym
->flags
& BSF_FUNCTION
)
2468 case stop_offset_reached
:
2469 /* Handled by the while loop. */
2473 /* FIXME: There is an implicit assumption here
2474 that the name of sym is different from
2476 if (! bfd_is_local_label (abfd
, sym
))
2483 const char * name
= bfd_asymbol_name (sym
);
2484 char * alloc
= NULL
;
2486 if (do_demangle
&& name
[0] != '\0')
2488 /* Demangle the name. */
2489 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
2494 /* We are not currently printing. Check to see
2495 if the current symbol matches the requested symbol. */
2496 if (streq (name
, paux
->symbol
))
2500 if (sym
->flags
& BSF_FUNCTION
)
2502 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2503 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
2505 /* Sym is a function symbol with a size associated
2506 with it. Turn on automatic disassembly for the
2507 next VALUE bytes. */
2508 stop_offset
= addr_offset
2509 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
2510 loop_until
= stop_offset_reached
;
2514 /* Otherwise we need to tell the loop heuristic to
2515 loop until the next function symbol is encountered. */
2516 loop_until
= function_sym
;
2521 /* Otherwise loop until the next symbol is encountered. */
2522 loop_until
= next_sym
;
2530 if (! prefix_addresses
&& do_print
)
2532 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2533 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2535 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2538 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2540 else if (sym
== NULL
)
2544 #define is_valid_next_sym(SYM) \
2545 (strcmp (bfd_section_name ((SYM)->section), bfd_section_name (section)) == 0 \
2546 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2547 && pinfo->symbol_is_valid (SYM, pinfo))
2549 /* Search forward for the next appropriate symbol in
2550 SECTION. Note that all the symbols are sorted
2551 together into one big array, and that some sections
2552 may have overlapping addresses. */
2553 while (place
< sorted_symcount
2554 && ! is_valid_next_sym (sorted_syms
[place
]))
2557 if (place
>= sorted_symcount
)
2560 nextsym
= sorted_syms
[place
];
2563 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2564 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2565 else if (nextsym
== NULL
)
2566 nextstop_offset
= stop_offset
;
2568 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2570 if (nextstop_offset
> stop_offset
2571 || nextstop_offset
<= addr_offset
)
2572 nextstop_offset
= stop_offset
;
2574 /* If a symbol is explicitly marked as being an object
2575 rather than a function, just dump the bytes without
2576 disassembling them. */
2579 || sym
->section
!= section
2580 || bfd_asymbol_value (sym
) > addr
2581 || ((sym
->flags
& BSF_OBJECT
) == 0
2582 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2584 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2586 || (sym
->flags
& BSF_FUNCTION
) != 0)
2592 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2593 addr_offset
, nextstop_offset
,
2594 rel_offset
, &rel_pp
, rel_ppend
);
2596 addr_offset
= nextstop_offset
;
2602 if (rel_ppstart
!= NULL
)
2606 /* Disassemble the contents of an object file. */
2609 disassemble_data (bfd
*abfd
)
2611 struct disassemble_info disasm_info
;
2612 struct objdump_disasm_info aux
;
2616 prev_functionname
= NULL
;
2618 prev_discriminator
= 0;
2620 /* We make a copy of syms to sort. We don't want to sort syms
2621 because that will screw up the relocs. */
2622 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2623 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2624 * sizeof (asymbol
*));
2625 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2626 sorted_symcount
* sizeof (asymbol
*));
2628 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2630 for (i
= 0; i
< synthcount
; ++i
)
2632 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2636 /* Sort the symbols into section and symbol order. */
2637 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2639 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2641 disasm_info
.application_data
= (void *) &aux
;
2643 aux
.require_sec
= FALSE
;
2644 aux
.dynrelbuf
= NULL
;
2645 aux
.dynrelcount
= 0;
2647 aux
.symbol
= disasm_sym
;
2649 disasm_info
.print_address_func
= objdump_print_address
;
2650 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2652 if (machine
!= NULL
)
2654 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2657 fatal (_("can't use supplied machine %s"), machine
);
2659 abfd
->arch_info
= inf
;
2662 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2664 struct bfd_target
*xvec
;
2666 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2667 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2668 xvec
->byteorder
= endian
;
2672 /* Use libopcodes to locate a suitable disassembler. */
2673 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
2674 bfd_big_endian (abfd
),
2675 bfd_get_mach (abfd
), abfd
);
2676 if (!aux
.disassemble_fn
)
2678 non_fatal (_("can't disassemble for architecture %s\n"),
2679 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2684 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2685 disasm_info
.arch
= bfd_get_arch (abfd
);
2686 disasm_info
.mach
= bfd_get_mach (abfd
);
2687 disasm_info
.disassembler_options
= disassembler_options
;
2688 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
, NULL
);
2689 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2690 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2691 disasm_info
.disassembler_needs_relocs
= FALSE
;
2693 if (bfd_big_endian (abfd
))
2694 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2695 else if (bfd_little_endian (abfd
))
2696 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2698 /* ??? Aborting here seems too drastic. We could default to big or little
2700 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2702 /* Allow the target to customize the info structure. */
2703 disassemble_init_for_target (& disasm_info
);
2705 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
2707 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2709 if (relsize
< 0 && dump_dynamic_reloc_info
)
2710 bfd_fatal (bfd_get_filename (abfd
));
2714 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2715 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2718 if (aux
.dynrelcount
< 0)
2719 bfd_fatal (bfd_get_filename (abfd
));
2721 /* Sort the relocs by address. */
2722 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2726 disasm_info
.symtab
= sorted_syms
;
2727 disasm_info
.symtab_size
= sorted_symcount
;
2729 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2731 if (aux
.dynrelbuf
!= NULL
)
2732 free (aux
.dynrelbuf
);
2737 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2738 asection
*sec
, void *file
)
2740 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2741 bfd
*abfd
= (bfd
*) file
;
2746 if (section
->start
!= NULL
)
2748 /* If it is already loaded, do nothing. */
2749 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2751 free (section
->start
);
2754 section
->filename
= bfd_get_filename (abfd
);
2755 section
->reloc_info
= NULL
;
2756 section
->num_relocs
= 0;
2757 section
->address
= bfd_section_vma (sec
);
2758 section
->user_data
= sec
;
2759 section
->size
= bfd_section_size (sec
);
2760 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
2761 alloced
= amt
= section
->size
+ 1;
2762 if (alloced
!= amt
|| alloced
== 0)
2764 section
->start
= NULL
;
2765 free_debug_section (debug
);
2766 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
2767 sanitize_string (section
->name
),
2768 (unsigned long long) section
->size
);
2771 section
->start
= contents
= malloc (alloced
);
2772 if (section
->start
== NULL
2773 || !bfd_get_full_section_contents (abfd
, sec
, &contents
))
2775 free_debug_section (debug
);
2776 printf (_("\nCan't get contents for section '%s'.\n"),
2777 sanitize_string (section
->name
));
2780 /* Ensure any string section has a terminating NUL. */
2781 section
->start
[section
->size
] = 0;
2783 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
2784 && debug_displays
[debug
].relocate
)
2789 bfd_cache_section_contents (sec
, section
->start
);
2791 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2798 free_debug_section (debug
);
2799 printf (_("\nCan't get contents for section '%s'.\n"),
2800 sanitize_string (section
->name
));
2804 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
2807 unsigned long reloc_count
;
2810 relocs
= (arelent
**) xmalloc (reloc_size
);
2812 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
2813 if (reloc_count
== 0)
2817 section
->reloc_info
= relocs
;
2818 section
->num_relocs
= reloc_count
;
2827 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
2832 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
2835 relocs
= (arelent
**) dsec
->reloc_info
;
2837 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
2838 if (rp
->address
== offset
)
2845 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2847 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2848 bfd
*abfd
= (bfd
*) file
;
2851 /* If it is already loaded, do nothing. */
2852 if (section
->start
!= NULL
)
2854 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2858 /* Locate the debug section. */
2859 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2861 section
->name
= section
->uncompressed_name
;
2864 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2866 section
->name
= section
->compressed_name
;
2871 return load_specific_debug_section (debug
, sec
, file
);
2875 free_debug_section (enum dwarf_section_display_enum debug
)
2877 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2879 if (section
->start
== NULL
)
2882 /* PR 17512: file: 0f67f69d. */
2883 if (section
->user_data
!= NULL
)
2885 asection
* sec
= (asection
*) section
->user_data
;
2887 /* If we are freeing contents that are also pointed to by the BFD
2888 library's section structure then make sure to update those pointers
2889 too. Otherwise, the next time we try to load data for this section
2890 we can end up using a stale pointer. */
2891 if (section
->start
== sec
->contents
)
2893 sec
->contents
= NULL
;
2894 sec
->flags
&= ~ SEC_IN_MEMORY
;
2895 sec
->compress_status
= COMPRESS_SECTION_NONE
;
2899 free ((char *) section
->start
);
2900 section
->start
= NULL
;
2901 section
->address
= 0;
2906 close_debug_file (void * file
)
2908 bfd
* abfd
= (bfd
*) file
;
2914 open_debug_file (const char * pathname
)
2918 data
= bfd_openr (pathname
, NULL
);
2922 if (! bfd_check_format (data
, bfd_object
))
2929 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2930 void *arg ATTRIBUTE_UNUSED
)
2932 const char *name
= bfd_section_name (section
);
2936 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2937 match
= ".debug_info";
2941 for (i
= 0; i
< max
; i
++)
2942 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2943 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2944 && debug_displays
[i
].enabled
!= NULL
2945 && *debug_displays
[i
].enabled
)
2947 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2949 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2950 sec
->name
= sec
->uncompressed_name
;
2952 sec
->name
= sec
->compressed_name
;
2953 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2956 debug_displays
[i
].display (sec
, abfd
);
2958 if (i
!= info
&& i
!= abbrev
)
2959 free_debug_section ((enum dwarf_section_display_enum
) i
);
2965 /* Dump the dwarf debugging information. */
2968 dump_dwarf (bfd
*abfd
)
2970 /* The byte_get pointer should have been set at the start of dump_bfd(). */
2971 if (byte_get
== NULL
)
2973 warn (_("File %s does not contain any dwarf debug information\n"),
2974 bfd_get_filename (abfd
));
2978 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2980 switch (bfd_get_arch (abfd
))
2983 switch (bfd_get_mach (abfd
))
2985 case bfd_mach_x86_64
:
2986 case bfd_mach_x86_64_intel_syntax
:
2987 case bfd_mach_x86_64_nacl
:
2988 case bfd_mach_x64_32
:
2989 case bfd_mach_x64_32_intel_syntax
:
2990 case bfd_mach_x64_32_nacl
:
2991 init_dwarf_regnames_x86_64 ();
2995 init_dwarf_regnames_i386 ();
3000 case bfd_arch_iamcu
:
3001 init_dwarf_regnames_iamcu ();
3004 case bfd_arch_aarch64
:
3005 init_dwarf_regnames_aarch64();
3009 init_dwarf_regnames_s390 ();
3012 case bfd_arch_riscv
:
3013 init_dwarf_regnames_riscv ();
3017 /* S12Z has a 24 bit address space. But the only known
3018 producer of dwarf_info encodes addresses into 32 bits. */
3026 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
3029 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
3030 it. Return NULL on failure. */
3033 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
3034 bfd_size_type
*entsize_ptr
)
3039 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
3040 if (stabsect
== NULL
)
3042 printf (_("No %s section present\n\n"),
3043 sanitize_string (sect_name
));
3047 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
3049 non_fatal (_("reading %s section of %s failed: %s"),
3050 sect_name
, bfd_get_filename (abfd
),
3051 bfd_errmsg (bfd_get_error ()));
3057 *size_ptr
= bfd_section_size (stabsect
);
3059 *entsize_ptr
= stabsect
->entsize
;
3064 /* Stabs entries use a 12 byte format:
3065 4 byte string table index
3067 1 byte stab other field
3068 2 byte stab desc field
3070 FIXME: This will have to change for a 64 bit object format. */
3072 #define STRDXOFF (0)
3074 #define OTHEROFF (5)
3077 #define STABSIZE (12)
3079 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3080 using string table section STRSECT_NAME (in `strtab'). */
3083 print_section_stabs (bfd
*abfd
,
3084 const char *stabsect_name
,
3085 unsigned *string_offset_ptr
)
3088 unsigned file_string_table_offset
= 0;
3089 unsigned next_file_string_table_offset
= *string_offset_ptr
;
3090 bfd_byte
*stabp
, *stabs_end
;
3093 stabs_end
= stabp
+ stab_size
;
3095 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
3096 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3098 /* Loop through all symbols and print them.
3100 We start the index at -1 because there is a dummy symbol on
3101 the front of stabs-in-{coff,elf} sections that supplies sizes. */
3102 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
3106 unsigned char type
, other
;
3107 unsigned short desc
;
3110 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
3111 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
3112 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
3113 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
3114 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
3116 printf ("\n%-6d ", i
);
3117 /* Either print the stab name, or, if unnamed, print its number
3118 again (makes consistent formatting for tools like awk). */
3119 name
= bfd_get_stab_name (type
);
3121 printf ("%-6s", sanitize_string (name
));
3122 else if (type
== N_UNDF
)
3125 printf ("%-6d", type
);
3126 printf (" %-6d %-6d ", other
, desc
);
3127 bfd_printf_vma (abfd
, value
);
3128 printf (" %-6lu", strx
);
3130 /* Symbols with type == 0 (N_UNDF) specify the length of the
3131 string table associated with this file. We use that info
3132 to know how to relocate the *next* file's string table indices. */
3135 file_string_table_offset
= next_file_string_table_offset
;
3136 next_file_string_table_offset
+= value
;
3140 bfd_size_type amt
= strx
+ file_string_table_offset
;
3142 /* Using the (possibly updated) string table offset, print the
3143 string (if any) associated with this symbol. */
3144 if (amt
< stabstr_size
)
3145 /* PR 17512: file: 079-79389-0.001:0.1.
3146 FIXME: May need to sanitize this string before displaying. */
3147 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
3153 *string_offset_ptr
= next_file_string_table_offset
;
3158 const char * section_name
;
3159 const char * string_section_name
;
3160 unsigned string_offset
;
3165 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
3168 stab_section_names
* sought
= (stab_section_names
*) names
;
3170 /* Check for section names for which stabsect_name is a prefix, to
3171 handle .stab.N, etc. */
3172 len
= strlen (sought
->section_name
);
3174 /* If the prefix matches, and the files section name ends with a
3175 nul or a digit, then we match. I.e., we want either an exact
3176 match or a section followed by a number. */
3177 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
3178 && (section
->name
[len
] == 0
3179 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
3182 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
3183 &stabstr_size
, NULL
);
3187 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
, NULL
);
3189 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
3195 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
3197 stab_section_names s
;
3199 s
.section_name
= stabsect_name
;
3200 s
.string_section_name
= strsect_name
;
3201 s
.string_offset
= 0;
3203 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
3209 /* Dump the any sections containing stabs debugging information. */
3212 dump_stabs (bfd
*abfd
)
3214 dump_stabs_section (abfd
, ".stab", ".stabstr");
3215 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
3216 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
3219 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3221 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3225 dump_bfd_header (bfd
*abfd
)
3229 printf (_("architecture: %s, "),
3230 bfd_printable_arch_mach (bfd_get_arch (abfd
),
3231 bfd_get_mach (abfd
)));
3232 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
3234 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
3235 PF (HAS_RELOC
, "HAS_RELOC");
3236 PF (EXEC_P
, "EXEC_P");
3237 PF (HAS_LINENO
, "HAS_LINENO");
3238 PF (HAS_DEBUG
, "HAS_DEBUG");
3239 PF (HAS_SYMS
, "HAS_SYMS");
3240 PF (HAS_LOCALS
, "HAS_LOCALS");
3241 PF (DYNAMIC
, "DYNAMIC");
3242 PF (WP_TEXT
, "WP_TEXT");
3243 PF (D_PAGED
, "D_PAGED");
3244 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
3245 printf (_("\nstart address 0x"));
3246 bfd_printf_vma (abfd
, abfd
->start_address
);
3251 /* Formatting callback function passed to ctf_dump. Returns either the pointer
3252 it is passed, or a pointer to newly-allocated storage, in which case
3253 dump_ctf() will free it when it no longer needs it. */
3256 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
3259 const char *blanks
= arg
;
3262 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
3267 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
3269 make_ctfsect (const char *name
, bfd_byte
*data
,
3274 ctfsect
.cts_name
= name
;
3275 ctfsect
.cts_entsize
= 1;
3276 ctfsect
.cts_size
= size
;
3277 ctfsect
.cts_data
= data
;
3282 /* Dump one CTF archive member. */
3285 dump_ctf_archive_member (ctf_file_t
*ctf
, const char *name
, void *arg
)
3287 ctf_file_t
*parent
= (ctf_file_t
*) arg
;
3288 const char *things
[] = {"Header", "Labels", "Data objects",
3289 "Function objects", "Variables", "Types", "Strings",
3294 /* Only print out the name of non-default-named archive members.
3295 The name .ctf appears everywhere, even for things that aren't
3296 really archives, so printing it out is liable to be confusing.
3298 The parent, if there is one, is the default-owned archive member:
3299 avoid importing it into itself. (This does no harm, but looks
3302 if (strcmp (name
, ".ctf") != 0)
3304 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name
));
3305 ctf_import (ctf
, parent
);
3308 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
3310 ctf_dump_state_t
*s
= NULL
;
3313 printf ("\n %s:\n", *thing
);
3314 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
3315 (void *) " ")) != NULL
)
3317 printf ("%s\n", item
);
3321 if (ctf_errno (ctf
))
3323 non_fatal (_("Iteration failed: %s, %s\n"), *thing
,
3324 ctf_errmsg (ctf_errno (ctf
)));
3331 /* Dump the CTF debugging information. */
3334 dump_ctf (bfd
*abfd
, const char *sect_name
, const char *parent_name
)
3336 ctf_archive_t
*ctfa
, *parenta
= NULL
, *lookparent
;
3337 bfd_byte
*ctfdata
, *parentdata
= NULL
;
3338 bfd_size_type ctfsize
, parentsize
;
3340 ctf_file_t
*parent
= NULL
;
3343 if ((ctfdata
= read_section_stabs (abfd
, sect_name
, &ctfsize
, NULL
)) == NULL
)
3344 bfd_fatal (bfd_get_filename (abfd
));
3347 && (parentdata
= read_section_stabs (abfd
, parent_name
, &parentsize
,
3349 bfd_fatal (bfd_get_filename (abfd
));
3351 /* Load the CTF file and dump it. */
3353 ctfsect
= make_ctfsect (sect_name
, ctfdata
, ctfsize
);
3354 if ((ctfa
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
3356 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3357 bfd_fatal (bfd_get_filename (abfd
));
3362 ctfsect
= make_ctfsect (parent_name
, parentdata
, parentsize
);
3363 if ((parenta
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
3365 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3366 bfd_fatal (bfd_get_filename (abfd
));
3369 lookparent
= parenta
;
3374 /* Assume that the applicable parent archive member is the default one.
3375 (This is what all known implementations are expected to do, if they
3376 put CTFs and their parents in archives together.) */
3377 if ((parent
= ctf_arc_open_by_name (lookparent
, NULL
, &err
)) == NULL
)
3379 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3380 bfd_fatal (bfd_get_filename (abfd
));
3383 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name
));
3385 ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
);
3386 ctf_file_close (parent
);
3388 ctf_close (parenta
);
3395 dump_bfd_private_header (bfd
*abfd
)
3397 if (!bfd_print_private_bfd_data (abfd
, stdout
))
3398 non_fatal (_("warning: private headers incomplete: %s"),
3399 bfd_errmsg (bfd_get_error ()));
3403 dump_target_specific (bfd
*abfd
)
3405 const struct objdump_private_desc
* const *desc
;
3406 struct objdump_private_option
*opt
;
3409 /* Find the desc. */
3410 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
3411 if ((*desc
)->filter (abfd
))
3416 non_fatal (_("option -P/--private not supported by this file"));
3420 /* Clear all options. */
3421 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3422 opt
->selected
= FALSE
;
3424 /* Decode options. */
3425 b
= dump_private_options
;
3428 e
= strchr (b
, ',');
3433 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3434 if (strcmp (opt
->name
, b
) == 0)
3436 opt
->selected
= TRUE
;
3439 if (opt
->name
== NULL
)
3440 non_fatal (_("target specific dump '%s' not supported"), b
);
3451 (*desc
)->dump (abfd
);
3454 /* Display a section in hexadecimal format with associated characters.
3455 Each line prefixed by the zero padded address. */
3458 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
3460 bfd_byte
*data
= NULL
;
3461 bfd_size_type datasize
;
3462 bfd_vma addr_offset
;
3463 bfd_vma start_offset
;
3464 bfd_vma stop_offset
;
3465 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
3466 /* Bytes per line. */
3467 const int onaline
= 16;
3472 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
3475 if (! process_section_p (section
))
3478 if ((datasize
= bfd_section_size (section
)) == 0)
3481 /* Compute the address range to display. */
3482 if (start_address
== (bfd_vma
) -1
3483 || start_address
< section
->vma
)
3486 start_offset
= start_address
- section
->vma
;
3488 if (stop_address
== (bfd_vma
) -1)
3489 stop_offset
= datasize
/ opb
;
3492 if (stop_address
< section
->vma
)
3495 stop_offset
= stop_address
- section
->vma
;
3497 if (stop_offset
> datasize
/ opb
)
3498 stop_offset
= datasize
/ opb
;
3501 if (start_offset
>= stop_offset
)
3504 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
3505 if (display_file_offsets
)
3506 printf (_(" (Starting at file offset: 0x%lx)"),
3507 (unsigned long) (section
->filepos
+ start_offset
));
3510 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
3512 non_fatal (_("Reading section %s failed because: %s"),
3513 section
->name
, bfd_errmsg (bfd_get_error ()));
3519 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
3520 if (strlen (buf
) >= sizeof (buf
))
3524 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3526 count
= strlen (buf
) - count
;
3530 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
3531 if (strlen (buf
) >= sizeof (buf
))
3535 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3537 count
= strlen (buf
) - count
;
3541 for (addr_offset
= start_offset
;
3542 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
3546 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
3547 count
= strlen (buf
);
3548 if ((size_t) count
>= sizeof (buf
))
3552 while (count
< width
)
3557 fputs (buf
+ count
- width
, stdout
);
3560 for (j
= addr_offset
* opb
;
3561 j
< addr_offset
* opb
+ onaline
; j
++)
3563 if (j
< stop_offset
* opb
)
3564 printf ("%02x", (unsigned) (data
[j
]));
3572 for (j
= addr_offset
* opb
;
3573 j
< addr_offset
* opb
+ onaline
; j
++)
3575 if (j
>= stop_offset
* opb
)
3578 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
3585 /* Actually display the various requested regions. */
3588 dump_data (bfd
*abfd
)
3590 bfd_map_over_sections (abfd
, dump_section
, NULL
);
3593 /* Should perhaps share code and display with nm? */
3596 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
3605 max_count
= dynsymcount
;
3606 printf ("DYNAMIC SYMBOL TABLE:\n");
3611 max_count
= symcount
;
3612 printf ("SYMBOL TABLE:\n");
3616 printf (_("no symbols\n"));
3618 for (count
= 0; count
< max_count
; count
++)
3622 if (*current
== NULL
)
3623 printf (_("no information for symbol number %ld\n"), count
);
3625 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
3626 printf (_("could not determine the type of symbol number %ld\n"),
3629 else if (process_section_p ((* current
)->section
)
3630 && (dump_special_syms
3631 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
3633 const char *name
= (*current
)->name
;
3635 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
3639 /* If we want to demangle the name, we demangle it
3640 here, and temporarily clobber it while calling
3641 bfd_print_symbol. FIXME: This is a gross hack. */
3642 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
3644 (*current
)->name
= alloc
;
3645 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3646 bfd_print_symbol_all
);
3649 (*current
)->name
= name
;
3654 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3655 bfd_print_symbol_all
);
3665 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
3668 char *last_filename
, *last_functionname
;
3669 unsigned int last_line
;
3670 unsigned int last_discriminator
;
3672 /* Get column headers lined up reasonably. */
3680 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
3681 width
= strlen (buf
) - 7;
3683 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
3686 last_filename
= NULL
;
3687 last_functionname
= NULL
;
3689 last_discriminator
= 0;
3691 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
3694 const char *filename
, *functionname
;
3695 unsigned int linenumber
;
3696 unsigned int discriminator
;
3697 const char *sym_name
;
3698 const char *section_name
;
3699 bfd_vma addend2
= 0;
3701 if (start_address
!= (bfd_vma
) -1
3702 && q
->address
< start_address
)
3704 if (stop_address
!= (bfd_vma
) -1
3705 && q
->address
> stop_address
)
3708 if (with_line_numbers
3710 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
3711 &filename
, &functionname
,
3712 &linenumber
, &discriminator
))
3714 if (functionname
!= NULL
3715 && (last_functionname
== NULL
3716 || strcmp (functionname
, last_functionname
) != 0))
3718 printf ("%s():\n", sanitize_string (functionname
));
3719 if (last_functionname
!= NULL
)
3720 free (last_functionname
);
3721 last_functionname
= xstrdup (functionname
);
3725 && (linenumber
!= last_line
3726 || (filename
!= NULL
3727 && last_filename
!= NULL
3728 && filename_cmp (filename
, last_filename
) != 0)
3729 || (discriminator
!= last_discriminator
)))
3731 if (discriminator
> 0)
3732 printf ("%s:%u\n", filename
== NULL
? "???" :
3733 sanitize_string (filename
), linenumber
);
3735 printf ("%s:%u (discriminator %u)\n",
3736 filename
== NULL
? "???" : sanitize_string (filename
),
3737 linenumber
, discriminator
);
3738 last_line
= linenumber
;
3739 last_discriminator
= discriminator
;
3740 if (last_filename
!= NULL
)
3741 free (last_filename
);
3742 if (filename
== NULL
)
3743 last_filename
= NULL
;
3745 last_filename
= xstrdup (filename
);
3749 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
3751 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
3752 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
3757 section_name
= NULL
;
3760 bfd_printf_vma (abfd
, q
->address
);
3761 if (q
->howto
== NULL
)
3762 printf (" *unknown* ");
3763 else if (q
->howto
->name
)
3765 const char *name
= q
->howto
->name
;
3767 /* R_SPARC_OLO10 relocations contain two addends.
3768 But because 'arelent' lacks enough storage to
3769 store them both, the 64-bit ELF Sparc backend
3770 records this as two relocations. One R_SPARC_LO10
3771 and one R_SPARC_13, both pointing to the same
3772 address. This is merely so that we have some
3773 place to store both addend fields.
3775 Undo this transformation, otherwise the output
3776 will be confusing. */
3777 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3778 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3780 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3782 arelent
*q2
= *(p
+ 1);
3785 && q
->address
== q2
->address
3786 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3788 name
= "R_SPARC_OLO10";
3789 addend2
= q2
->addend
;
3793 printf (" %-16s ", name
);
3796 printf (" %-16d ", q
->howto
->type
);
3800 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3804 if (section_name
== NULL
)
3805 section_name
= "*unknown*";
3806 printf ("[%s]", sanitize_string (section_name
));
3811 bfd_signed_vma addend
= q
->addend
;
3819 bfd_printf_vma (abfd
, addend
);
3824 bfd_printf_vma (abfd
, addend2
);
3830 if (last_filename
!= NULL
)
3831 free (last_filename
);
3832 if (last_functionname
!= NULL
)
3833 free (last_functionname
);
3837 dump_relocs_in_section (bfd
*abfd
,
3839 void *dummy ATTRIBUTE_UNUSED
)
3841 arelent
**relpp
= NULL
;
3845 if ( bfd_is_abs_section (section
)
3846 || bfd_is_und_section (section
)
3847 || bfd_is_com_section (section
)
3848 || (! process_section_p (section
))
3849 || ((section
->flags
& SEC_RELOC
) == 0))
3852 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
3854 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3857 printf (" (none)\n\n");
3865 relpp
= (arelent
**) xmalloc (relsize
);
3866 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3872 non_fatal (_("failed to read relocs in: %s"),
3873 sanitize_string (bfd_get_filename (abfd
)));
3874 bfd_fatal (_("error message was"));
3876 else if (relcount
== 0)
3877 printf (" (none)\n\n");
3881 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3888 dump_relocs (bfd
*abfd
)
3890 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3894 dump_dynamic_relocs (bfd
*abfd
)
3900 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3902 bfd_fatal (bfd_get_filename (abfd
));
3904 printf ("DYNAMIC RELOCATION RECORDS");
3907 printf (" (none)\n\n");
3910 relpp
= (arelent
**) xmalloc (relsize
);
3911 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3914 bfd_fatal (bfd_get_filename (abfd
));
3915 else if (relcount
== 0)
3916 printf (" (none)\n\n");
3920 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3927 /* Creates a table of paths, to search for source files. */
3930 add_include_path (const char *path
)
3934 include_path_count
++;
3935 include_paths
= (const char **)
3936 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3937 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3938 if (path
[1] == ':' && path
[2] == 0)
3939 path
= concat (path
, ".", (const char *) 0);
3941 include_paths
[include_path_count
- 1] = path
;
3945 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3949 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3951 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3952 section
->vma
+= adjust_section_vma
;
3954 section
->lma
+= adjust_section_vma
;
3958 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
3961 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
3966 mask
= (bfd_vma
) 1 << (arch_size
- 1);
3967 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
3970 /* Dump selected contents of ABFD. */
3973 dump_bfd (bfd
*abfd
, bfd_boolean is_mainfile
)
3975 const struct elf_backend_data
* bed
;
3977 if (bfd_big_endian (abfd
))
3978 byte_get
= byte_get_big_endian
;
3979 else if (bfd_little_endian (abfd
))
3980 byte_get
= byte_get_little_endian
;
3984 /* Load any separate debug information files.
3985 We do this now and without checking do_follow_links because separate
3986 debug info files may contain symbol tables that we will need when
3987 displaying information about the main file. Any memory allocated by
3988 load_separate_debug_files will be released when we call
3989 free_debug_memory below.
3991 The test on is_mainfile is there because the chain of separate debug
3992 info files is a global variable shared by all invocations of dump_bfd. */
3995 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
3997 /* If asked to do so, recursively dump the separate files. */
3998 if (do_follow_links
)
4002 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4003 dump_bfd (i
->handle
, FALSE
);
4007 /* Adjust user-specified start and stop limits for targets that use
4008 signed addresses. */
4009 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
4010 && (bed
= get_elf_backend_data (abfd
)) != NULL
4011 && bed
->sign_extend_vma
)
4013 start_address
= sign_extend_address (abfd
, start_address
,
4015 stop_address
= sign_extend_address (abfd
, stop_address
,
4019 /* If we are adjusting section VMA's, change them all now. Changing
4020 the BFD information is a hack. However, we must do it, or
4021 bfd_find_nearest_line will not do the right thing. */
4022 if (adjust_section_vma
!= 0)
4024 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
4025 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
4028 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4029 printf (_("\n%s: file format %s\n"),
4030 sanitize_string (bfd_get_filename (abfd
)),
4033 print_arelt_descr (stdout
, abfd
, TRUE
, FALSE
);
4034 if (dump_file_header
)
4035 dump_bfd_header (abfd
);
4036 if (dump_private_headers
)
4037 dump_bfd_private_header (abfd
);
4038 if (dump_private_options
!= NULL
)
4039 dump_target_specific (abfd
);
4040 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4047 || dump_dwarf_section_info
)
4049 syms
= slurp_symtab (abfd
);
4051 /* If following links, load any symbol tables from the linked files as well. */
4052 if (do_follow_links
&& is_mainfile
)
4056 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4058 asymbol
** extra_syms
;
4059 long old_symcount
= symcount
;
4061 extra_syms
= slurp_symtab (i
->handle
);
4065 if (old_symcount
== 0)
4071 syms
= xrealloc (syms
, (symcount
+ old_symcount
) * sizeof (asymbol
*));
4072 memcpy (syms
+ old_symcount
,
4074 symcount
* sizeof (asymbol
*));
4078 symcount
+= old_symcount
;
4083 if (dump_section_headers
)
4084 dump_headers (abfd
);
4086 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
4087 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
4088 dynsyms
= slurp_dynamic_symtab (abfd
);
4092 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
4093 dynsymcount
, dynsyms
, &synthsyms
);
4099 dump_symbols (abfd
, FALSE
);
4100 if (dump_dynamic_symtab
)
4101 dump_symbols (abfd
, TRUE
);
4102 if (dump_dwarf_section_info
)
4104 if (dump_ctf_section_info
)
4105 dump_ctf (abfd
, dump_ctf_section_name
, dump_ctf_parent_name
);
4106 if (dump_stab_section_info
)
4108 if (dump_reloc_info
&& ! disassemble
)
4110 if (dump_dynamic_reloc_info
&& ! disassemble
)
4111 dump_dynamic_relocs (abfd
);
4112 if (dump_section_contents
)
4115 disassemble_data (abfd
);
4121 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
4122 if (dhandle
!= NULL
)
4124 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
4126 dump_debugging_tags
? TRUE
: FALSE
))
4128 non_fatal (_("%s: printing debugging information failed"),
4129 bfd_get_filename (abfd
));
4135 /* PR 6483: If there was no STABS debug info in the file, try
4137 else if (! dump_dwarf_section_info
)
4139 dwarf_select_sections_all ();
4167 free_debug_memory ();
4171 display_object_bfd (bfd
*abfd
)
4175 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
4177 dump_bfd (abfd
, TRUE
);
4181 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4183 nonfatal (bfd_get_filename (abfd
));
4184 list_matching_formats (matching
);
4189 if (bfd_get_error () != bfd_error_file_not_recognized
)
4191 nonfatal (bfd_get_filename (abfd
));
4195 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
4197 dump_bfd (abfd
, TRUE
);
4201 nonfatal (bfd_get_filename (abfd
));
4203 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4205 list_matching_formats (matching
);
4211 display_any_bfd (bfd
*file
, int level
)
4213 /* Decompress sections unless dumping the section contents. */
4214 if (!dump_section_contents
)
4215 file
->flags
|= BFD_DECOMPRESS
;
4217 /* If the file is an archive, process all of its elements. */
4218 if (bfd_check_format (file
, bfd_archive
))
4221 bfd
*last_arfile
= NULL
;
4224 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
4225 else if (level
> 100)
4227 /* Prevent corrupted files from spinning us into an
4228 infinite loop. 100 is an arbitrary heuristic. */
4229 fatal (_("Archive nesting is too deep"));
4233 printf (_("In nested archive %s:\n"),
4234 sanitize_string (bfd_get_filename (file
)));
4238 bfd_set_error (bfd_error_no_error
);
4240 arfile
= bfd_openr_next_archived_file (file
, arfile
);
4243 if (bfd_get_error () != bfd_error_no_more_archived_files
)
4244 nonfatal (bfd_get_filename (file
));
4248 display_any_bfd (arfile
, level
+ 1);
4250 if (last_arfile
!= NULL
)
4252 bfd_close (last_arfile
);
4253 /* PR 17512: file: ac585d01. */
4254 if (arfile
== last_arfile
)
4260 last_arfile
= arfile
;
4263 if (last_arfile
!= NULL
)
4264 bfd_close (last_arfile
);
4267 display_object_bfd (file
);
4271 display_file (char *filename
, char *target
, bfd_boolean last_file
)
4275 if (get_file_size (filename
) < 1)
4281 file
= bfd_openr (filename
, target
);
4284 nonfatal (filename
);
4288 display_any_bfd (file
, 0);
4290 /* This is an optimization to improve the speed of objdump, especially when
4291 dumping a file with lots of associated debug informatiom. Calling
4292 bfd_close on such a file can take a non-trivial amount of time as there
4293 are lots of lists to walk and buffers to free. This is only really
4294 necessary however if we are about to load another file and we need the
4295 memory back. Otherwise, if we are about to exit, then we can save (a lot
4296 of) time by only doing a quick close, and allowing the OS to reclaim the
4301 bfd_close_all_done (file
);
4305 main (int argc
, char **argv
)
4308 char *target
= default_target
;
4309 bfd_boolean seenflag
= FALSE
;
4311 #if defined (HAVE_SETLOCALE)
4312 #if defined (HAVE_LC_MESSAGES)
4313 setlocale (LC_MESSAGES
, "");
4315 setlocale (LC_CTYPE
, "");
4318 bindtextdomain (PACKAGE
, LOCALEDIR
);
4319 textdomain (PACKAGE
);
4321 program_name
= *argv
;
4322 xmalloc_set_program_name (program_name
);
4323 bfd_set_error_program_name (program_name
);
4325 START_PROGRESS (program_name
, 0);
4327 expandargv (&argc
, &argv
);
4329 if (bfd_init () != BFD_INIT_MAGIC
)
4330 fatal (_("fatal error: libbfd ABI mismatch"));
4331 set_default_bfd_target ();
4333 while ((c
= getopt_long (argc
, argv
,
4334 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
4335 long_options
, (int *) 0))
4341 break; /* We've been given a long option. */
4348 if (disassembler_options
)
4349 /* Ignore potential memory leak for now. */
4350 options
= concat (disassembler_options
, ",",
4351 optarg
, (const char *) NULL
);
4354 disassembler_options
= remove_whitespace_and_extra_commas (options
);
4361 display_file_offsets
= TRUE
;
4364 with_line_numbers
= TRUE
;
4373 enum demangling_styles style
;
4375 style
= cplus_demangle_name_to_style (optarg
);
4376 if (style
== unknown_demangling
)
4377 fatal (_("unknown demangling style `%s'"),
4380 cplus_demangle_set_style (style
);
4383 case OPTION_RECURSE_LIMIT
:
4384 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
4386 case OPTION_NO_RECURSE_LIMIT
:
4387 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
4390 do_wide
= wide_output
= TRUE
;
4392 case OPTION_ADJUST_VMA
:
4393 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
4395 case OPTION_START_ADDRESS
:
4396 start_address
= parse_vma (optarg
, "--start-address");
4397 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4398 fatal (_("error: the start address should be before the end address"));
4400 case OPTION_STOP_ADDRESS
:
4401 stop_address
= parse_vma (optarg
, "--stop-address");
4402 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4403 fatal (_("error: the stop address should be after the start address"));
4407 prefix_length
= strlen (prefix
);
4408 /* Remove an unnecessary trailing '/' */
4409 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
4412 case OPTION_PREFIX_STRIP
:
4413 prefix_strip
= atoi (optarg
);
4414 if (prefix_strip
< 0)
4415 fatal (_("error: prefix strip must be non-negative"));
4417 case OPTION_INSN_WIDTH
:
4418 insn_width
= strtoul (optarg
, NULL
, 0);
4419 if (insn_width
<= 0)
4420 fatal (_("error: instruction width must be positive"));
4422 case OPTION_INLINES
:
4423 unwind_inlines
= TRUE
;
4426 if (strcmp (optarg
, "B") == 0)
4427 endian
= BFD_ENDIAN_BIG
;
4428 else if (strcmp (optarg
, "L") == 0)
4429 endian
= BFD_ENDIAN_LITTLE
;
4432 nonfatal (_("unrecognized -E option"));
4437 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
4438 endian
= BFD_ENDIAN_BIG
;
4439 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
4440 endian
= BFD_ENDIAN_LITTLE
;
4443 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
4450 dump_file_header
= TRUE
;
4454 formats_info
= TRUE
;
4458 add_include_path (optarg
);
4461 dump_private_headers
= TRUE
;
4465 dump_private_options
= optarg
;
4469 dump_private_headers
= TRUE
;
4471 dump_reloc_info
= TRUE
;
4472 dump_file_header
= TRUE
;
4473 dump_ar_hdrs
= TRUE
;
4474 dump_section_headers
= TRUE
;
4482 dump_dynamic_symtab
= TRUE
;
4488 disasm_sym
= optarg
;
4491 disassemble_zeroes
= TRUE
;
4495 disassemble_all
= TRUE
;
4500 with_source_code
= TRUE
;
4503 case OPTION_SOURCE_COMMENT
:
4505 with_source_code
= TRUE
;
4508 source_comment
= xstrdup (sanitize_string (optarg
));
4510 source_comment
= xstrdup ("# ");
4518 dump_debugging_tags
= 1;
4523 dump_dwarf_section_info
= TRUE
;
4526 dwarf_select_sections_by_letters (optarg
);
4528 dwarf_select_sections_all ();
4531 dump_dwarf_section_info
= TRUE
;
4534 dwarf_select_sections_by_names (optarg
);
4536 dwarf_select_sections_all ();
4538 case OPTION_DWARF_DEPTH
:
4541 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4544 case OPTION_DWARF_START
:
4547 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4548 suppress_bfd_header
= 1;
4551 case OPTION_DWARF_CHECK
:
4555 dump_ctf_section_info
= TRUE
;
4556 dump_ctf_section_name
= xstrdup (optarg
);
4559 case OPTION_CTF_PARENT
:
4560 dump_ctf_parent_name
= xstrdup (optarg
);
4563 dump_stab_section_info
= TRUE
;
4567 dump_section_contents
= TRUE
;
4571 dump_reloc_info
= TRUE
;
4575 dump_dynamic_reloc_info
= TRUE
;
4579 dump_ar_hdrs
= TRUE
;
4583 dump_section_headers
= TRUE
;
4588 show_version
= TRUE
;
4594 /* No need to set seenflag or to break - usage() does not return. */
4601 print_version ("objdump");
4607 exit_status
= display_info ();
4611 display_file ("a.out", target
, TRUE
);
4613 for (; optind
< argc
;)
4615 display_file (argv
[optind
], target
, optind
== argc
- 1);
4621 free (dump_ctf_section_name
);
4622 free (dump_ctf_parent_name
);
4623 free ((void *) source_comment
);
4625 END_PROGRESS (program_name
);