1 /* objdump.c -- dump information about an object file.
2 Copyright (C) 1990-2019 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
24 Objdump displays information about one or more object files, either on
25 their own, or inside libraries. It is commonly used as a disassembler,
26 but it can also display information about file headers, symbol tables,
27 relocations, debugging directives and more.
29 The flow of execution is as follows:
31 1. Command line arguments are checked for control switches and the
32 information to be displayed is selected.
34 2. Any remaining arguments are assumed to be object files, and they are
35 processed in order by display_bfd(). If the file is an archive each
36 of its elements is processed in turn.
38 3. The file's target architecture and binary file format are determined
39 by bfd_check_format(). If they are recognised, then dump_bfd() is
42 4. dump_bfd() in turn calls separate functions to display the requested
43 item(s) of information(s). For example disassemble_data() is called if
44 a disassembly has been requested.
46 When disassembling the code loops through blocks of instructions bounded
47 by symbols, calling disassemble_bytes() on each block. The actual
48 disassembling is done by the libopcodes library, via a function pointer
49 supplied by the disassembler() function. */
61 #include "safe-ctype.h"
63 #include "libiberty.h"
65 #include "filenames.h"
74 /* Internal headers for the ELF .stab-dump code - sorry. */
75 #define BYTES_IN_WORD 32
76 #include "aout/aout64.h"
79 static int exit_status
= 0;
81 static char *default_target
= NULL
; /* Default at runtime. */
83 /* The following variables are set based on arguments passed on the
85 static int show_version
= 0; /* Show the version number. */
86 static int dump_section_contents
; /* -s */
87 static int dump_section_headers
; /* -h */
88 static bfd_boolean dump_file_header
; /* -f */
89 static int dump_symtab
; /* -t */
90 static int dump_dynamic_symtab
; /* -T */
91 static int dump_reloc_info
; /* -r */
92 static int dump_dynamic_reloc_info
; /* -R */
93 static int dump_ar_hdrs
; /* -a */
94 static int dump_private_headers
; /* -p */
95 static char *dump_private_options
; /* -P */
96 static int prefix_addresses
; /* --prefix-addresses */
97 static int with_line_numbers
; /* -l */
98 static bfd_boolean with_source_code
; /* -S */
99 static int show_raw_insn
; /* --show-raw-insn */
100 static int dump_dwarf_section_info
; /* --dwarf */
101 static int dump_stab_section_info
; /* --stabs */
102 static int dump_ctf_section_info
; /* --ctf */
103 static char *dump_ctf_section_name
;
104 static char *dump_ctf_parent_name
; /* --ctf-parent */
105 static int do_demangle
; /* -C, --demangle */
106 static bfd_boolean disassemble
; /* -d */
107 static bfd_boolean disassemble_all
; /* -D */
108 static int disassemble_zeroes
; /* --disassemble-zeroes */
109 static bfd_boolean formats_info
; /* -i */
110 static int wide_output
; /* -w */
111 static int insn_width
; /* --insn-width */
112 static bfd_vma start_address
= (bfd_vma
) -1; /* --start-address */
113 static bfd_vma stop_address
= (bfd_vma
) -1; /* --stop-address */
114 static int dump_debugging
; /* --debugging */
115 static int dump_debugging_tags
; /* --debugging-tags */
116 static int suppress_bfd_header
;
117 static int dump_special_syms
= 0; /* --special-syms */
118 static bfd_vma adjust_section_vma
= 0; /* --adjust-vma */
119 static int file_start_context
= 0; /* --file-start-context */
120 static bfd_boolean display_file_offsets
;/* -F */
121 static const char *prefix
; /* --prefix */
122 static int prefix_strip
; /* --prefix-strip */
123 static size_t prefix_length
;
124 static bfd_boolean unwind_inlines
; /* --inlines. */
125 static const char * disasm_sym
; /* Disassembly start symbol. */
126 static const char * source_comment
; /* --source_comment. */
128 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
130 /* A structure to record the sections mentioned in -j switches. */
133 const char * name
; /* The name of the section. */
134 bfd_boolean seen
; /* A flag to indicate that the section has been found in one or more input files. */
135 struct only
* next
; /* Pointer to the next structure in the list. */
137 /* Pointer to an array of 'only' structures.
138 This pointer is NULL if the -j switch has not been used. */
139 static struct only
* only_list
= NULL
;
141 /* Variables for handling include file path table. */
142 static const char **include_paths
;
143 static int include_path_count
;
145 /* Extra info to pass to the section disassembler and address printing
147 struct objdump_disasm_info
151 bfd_boolean require_sec
;
152 arelent
** dynrelbuf
;
154 disassembler_ftype disassemble_fn
;
159 /* Architecture to disassemble for, or default if NULL. */
160 static char *machine
= NULL
;
162 /* Target specific options to the disassembler. */
163 static char *disassembler_options
= NULL
;
165 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
166 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
168 /* The symbol table. */
169 static asymbol
**syms
;
171 /* Number of symbols in `syms'. */
172 static long symcount
= 0;
174 /* The sorted symbol table. */
175 static asymbol
**sorted_syms
;
177 /* Number of symbols in `sorted_syms'. */
178 static long sorted_symcount
= 0;
180 /* The dynamic symbol table. */
181 static asymbol
**dynsyms
;
183 /* The synthetic symbol table. */
184 static asymbol
*synthsyms
;
185 static long synthcount
= 0;
187 /* Number of symbols in `dynsyms'. */
188 static long dynsymcount
= 0;
190 static bfd_byte
*stabs
;
191 static bfd_size_type stab_size
;
193 static bfd_byte
*strtab
;
194 static bfd_size_type stabstr_size
;
196 /* Handlers for -P/--private. */
197 static const struct objdump_private_desc
* const objdump_private_vectors
[] =
199 OBJDUMP_PRIVATE_VECTORS
203 static void usage (FILE *, int) ATTRIBUTE_NORETURN
;
205 usage (FILE *stream
, int status
)
207 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
208 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
209 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
210 fprintf (stream
, _("\
211 -a, --archive-headers Display archive header information\n\
212 -f, --file-headers Display the contents of the overall file header\n\
213 -p, --private-headers Display object format specific file header contents\n\
214 -P, --private=OPT,OPT... Display object format specific contents\n\
215 -h, --[section-]headers Display the contents of the section headers\n\
216 -x, --all-headers Display the contents of all headers\n\
217 -d, --disassemble Display assembler contents of executable sections\n\
218 -D, --disassemble-all Display assembler contents of all sections\n\
219 --disassemble=<sym> Display assembler contents from <sym>\n\
220 -S, --source Intermix source code with disassembly\n\
221 --source-comment[=<txt>] Prefix lines of source code with <txt>\n\
222 -s, --full-contents Display the full contents of all sections requested\n\
223 -g, --debugging Display debug information in object file\n\
224 -e, --debugging-tags Display debug information using ctags style\n\
225 -G, --stabs Display (in raw form) any STABS info in the file\n\
226 -W[lLiaprmfFsoRtUuTgAckK] or\n\
227 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
228 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
229 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
230 =addr,=cu_index,=links,=follow-links]\n\
231 Display DWARF info in the file\n\
232 --ctf=SECTION Display CTF info from SECTION\n\
233 -t, --syms Display the contents of the symbol table(s)\n\
234 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
235 -r, --reloc Display the relocation entries in the file\n\
236 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
237 @<file> Read options from <file>\n\
238 -v, --version Display this program's version number\n\
239 -i, --info List object formats and architectures supported\n\
240 -H, --help Display this information\n\
244 const struct objdump_private_desc
* const *desc
;
246 fprintf (stream
, _("\n The following switches are optional:\n"));
247 fprintf (stream
, _("\
248 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
249 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
250 -j, --section=NAME Only display information for section NAME\n\
251 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
252 -EB --endian=big Assume big endian format when disassembling\n\
253 -EL --endian=little Assume little endian format when disassembling\n\
254 --file-start-context Include context from start of file (with -S)\n\
255 -I, --include=DIR Add DIR to search list for source files\n\
256 -l, --line-numbers Include line numbers and filenames in output\n\
257 -F, --file-offsets Include file offsets when displaying information\n\
258 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
259 The STYLE, if specified, can be `auto', `gnu',\n\
260 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
262 --recurse-limit Enable a limit on recursion whilst demangling. [Default]\n\
263 --no-recurse-limit Disable a limit on recursion whilst demangling\n\
264 -w, --wide Format output for more than 80 columns\n\
265 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
266 --start-address=ADDR Only process data whose address is >= ADDR\n\
267 --stop-address=ADDR Only process data whose address is <= ADDR\n\
268 --prefix-addresses Print complete address alongside disassembly\n\
269 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
270 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
271 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
272 --special-syms Include special symbols in symbol dumps\n\
273 --inlines Print all inlines for source line (with -l)\n\
274 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
275 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
276 fprintf (stream
, _("\
277 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
278 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
280 --dwarf-check Make additional dwarf internal consistency checks.\
282 --ctf-parent=SECTION Use SECTION as the CTF parent\n\n"));
283 list_supported_targets (program_name
, stream
);
284 list_supported_architectures (program_name
, stream
);
286 disassembler_usage (stream
);
288 if (objdump_private_vectors
[0] != NULL
)
291 _("\nOptions supported for -P/--private switch:\n"));
292 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
293 (*desc
)->help (stream
);
296 if (REPORT_BUGS_TO
[0] && status
== 0)
297 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
301 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
305 OPTION_START_ADDRESS
,
315 OPTION_RECURSE_LIMIT
,
316 OPTION_NO_RECURSE_LIMIT
,
318 OPTION_SOURCE_COMMENT
,
323 static struct option long_options
[]=
325 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
326 {"all-headers", no_argument
, NULL
, 'x'},
327 {"private-headers", no_argument
, NULL
, 'p'},
328 {"private", required_argument
, NULL
, 'P'},
329 {"architecture", required_argument
, NULL
, 'm'},
330 {"archive-headers", no_argument
, NULL
, 'a'},
331 {"debugging", no_argument
, NULL
, 'g'},
332 {"debugging-tags", no_argument
, NULL
, 'e'},
333 {"demangle", optional_argument
, NULL
, 'C'},
334 {"disassemble", optional_argument
, NULL
, 'd'},
335 {"disassemble-all", no_argument
, NULL
, 'D'},
336 {"disassembler-options", required_argument
, NULL
, 'M'},
337 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
338 {"dynamic-reloc", no_argument
, NULL
, 'R'},
339 {"dynamic-syms", no_argument
, NULL
, 'T'},
340 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
341 {"file-headers", no_argument
, NULL
, 'f'},
342 {"file-offsets", no_argument
, NULL
, 'F'},
343 {"file-start-context", no_argument
, &file_start_context
, 1},
344 {"full-contents", no_argument
, NULL
, 's'},
345 {"headers", no_argument
, NULL
, 'h'},
346 {"help", no_argument
, NULL
, 'H'},
347 {"info", no_argument
, NULL
, 'i'},
348 {"line-numbers", no_argument
, NULL
, 'l'},
349 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
350 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
351 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
352 {"recursion-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
353 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
354 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
355 {"reloc", no_argument
, NULL
, 'r'},
356 {"section", required_argument
, NULL
, 'j'},
357 {"section-headers", no_argument
, NULL
, 'h'},
358 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
359 {"source", no_argument
, NULL
, 'S'},
360 {"source-comment", optional_argument
, NULL
, OPTION_SOURCE_COMMENT
},
361 {"special-syms", no_argument
, &dump_special_syms
, 1},
362 {"include", required_argument
, NULL
, 'I'},
363 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
364 {"ctf", required_argument
, NULL
, OPTION_CTF
},
365 {"ctf-parent", required_argument
, NULL
, OPTION_CTF_PARENT
},
366 {"stabs", no_argument
, NULL
, 'G'},
367 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
368 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
369 {"syms", no_argument
, NULL
, 't'},
370 {"target", required_argument
, NULL
, 'b'},
371 {"version", no_argument
, NULL
, 'V'},
372 {"wide", no_argument
, NULL
, 'w'},
373 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
374 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
375 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
376 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
377 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
378 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
379 {"inlines", no_argument
, 0, OPTION_INLINES
},
380 {0, no_argument
, 0, 0}
384 nonfatal (const char *msg
)
390 /* Returns a version of IN with any control characters
391 replaced by escape sequences. Uses a static buffer
395 sanitize_string (const char * in
)
397 static char * buffer
= NULL
;
398 static size_t buffer_len
= 0;
399 const char * original
= in
;
406 /* See if any conversion is necessary. In the majority
407 of cases it will not be needed. */
420 /* Copy the input, translating as needed. */
422 if (buffer_len
< (strlen (in
) * 2))
424 free ((void *) buffer
);
425 buffer_len
= strlen (in
) * 2;
426 buffer
= xmalloc (buffer_len
+ 1);
452 /* Returns TRUE if the specified section should be dumped. */
455 process_section_p (asection
* section
)
459 if (only_list
== NULL
)
462 for (only
= only_list
; only
; only
= only
->next
)
463 if (strcmp (only
->name
, section
->name
) == 0)
472 /* Add an entry to the 'only' list. */
475 add_only (char * name
)
479 /* First check to make sure that we do not
480 already have an entry for this name. */
481 for (only
= only_list
; only
; only
= only
->next
)
482 if (strcmp (only
->name
, name
) == 0)
485 only
= xmalloc (sizeof * only
);
488 only
->next
= only_list
;
492 /* Release the memory used by the 'only' list.
493 PR 11225: Issue a warning message for unseen sections.
494 Only do this if none of the sections were seen. This is mainly to support
495 tools like the GAS testsuite where an object file is dumped with a list of
496 generic section names known to be present in a range of different file
500 free_only_list (void)
502 bfd_boolean at_least_one_seen
= FALSE
;
506 if (only_list
== NULL
)
509 for (only
= only_list
; only
; only
= only
->next
)
512 at_least_one_seen
= TRUE
;
516 for (only
= only_list
; only
; only
= next
)
518 if (! at_least_one_seen
)
520 non_fatal (_("section '%s' mentioned in a -j option, "
521 "but not found in any input file"),
532 dump_section_header (bfd
*abfd
, asection
*section
, void *data
)
535 unsigned int opb
= bfd_octets_per_byte (abfd
);
536 int longest_section_name
= *((int *) data
);
538 /* Ignore linker created section. See elfNN_ia64_object_p in
540 if (section
->flags
& SEC_LINKER_CREATED
)
543 /* PR 10413: Skip sections that we are ignoring. */
544 if (! process_section_p (section
))
547 printf ("%3d %-*s %08lx ", section
->index
, longest_section_name
,
548 sanitize_string (bfd_section_name (section
)),
549 (unsigned long) bfd_section_size (section
) / opb
);
550 bfd_printf_vma (abfd
, bfd_section_vma (section
));
552 bfd_printf_vma (abfd
, section
->lma
);
553 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
554 bfd_section_alignment (section
));
560 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
562 PF (SEC_HAS_CONTENTS
, "CONTENTS");
563 PF (SEC_ALLOC
, "ALLOC");
564 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
565 PF (SEC_LOAD
, "LOAD");
566 PF (SEC_RELOC
, "RELOC");
567 PF (SEC_READONLY
, "READONLY");
568 PF (SEC_CODE
, "CODE");
569 PF (SEC_DATA
, "DATA");
571 PF (SEC_DEBUGGING
, "DEBUGGING");
572 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
573 PF (SEC_EXCLUDE
, "EXCLUDE");
574 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
575 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
577 PF (SEC_TIC54X_BLOCK
, "BLOCK");
578 PF (SEC_TIC54X_CLINK
, "CLINK");
580 PF (SEC_SMALL_DATA
, "SMALL_DATA");
581 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
583 PF (SEC_COFF_SHARED
, "SHARED");
584 PF (SEC_COFF_NOREAD
, "NOREAD");
586 else if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
587 PF (SEC_ELF_PURECODE
, "PURECODE");
588 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
589 PF (SEC_GROUP
, "GROUP");
590 if (bfd_get_arch (abfd
) == bfd_arch_mep
)
592 PF (SEC_MEP_VLIW
, "VLIW");
595 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
598 struct coff_comdat_info
*comdat
;
600 switch (section
->flags
& SEC_LINK_DUPLICATES
)
604 case SEC_LINK_DUPLICATES_DISCARD
:
605 ls
= "LINK_ONCE_DISCARD";
607 case SEC_LINK_DUPLICATES_ONE_ONLY
:
608 ls
= "LINK_ONCE_ONE_ONLY";
610 case SEC_LINK_DUPLICATES_SAME_SIZE
:
611 ls
= "LINK_ONCE_SAME_SIZE";
613 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
614 ls
= "LINK_ONCE_SAME_CONTENTS";
617 printf ("%s%s", comma
, ls
);
619 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
621 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
630 /* Called on each SECTION in ABFD, update the int variable pointed to by
631 DATA which contains the string length of the longest section name. */
634 find_longest_section_name (bfd
*abfd ATTRIBUTE_UNUSED
,
635 asection
*section
, void *data
)
637 int *longest_so_far
= (int *) data
;
641 /* Ignore linker created section. */
642 if (section
->flags
& SEC_LINKER_CREATED
)
645 /* Skip sections that we are ignoring. */
646 if (! process_section_p (section
))
649 name
= bfd_section_name (section
);
650 len
= (int) strlen (name
);
651 if (len
> *longest_so_far
)
652 *longest_so_far
= len
;
656 dump_headers (bfd
*abfd
)
658 /* The default width of 13 is just an arbitrary choice. */
659 int max_section_name_length
= 13;
665 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
666 if (bfd_get_arch_size (abfd
) == 32)
672 printf (_("Sections:\n"));
675 bfd_map_over_sections (abfd
, find_longest_section_name
,
676 &max_section_name_length
);
678 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
679 max_section_name_length
, "Name",
680 bfd_vma_width
, "VMA",
681 bfd_vma_width
, "LMA");
684 printf (_(" Flags"));
687 bfd_map_over_sections (abfd
, dump_section_header
,
688 &max_section_name_length
);
692 slurp_symtab (bfd
*abfd
)
697 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
703 storage
= bfd_get_symtab_upper_bound (abfd
);
706 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
707 bfd_fatal (_("error message was"));
711 off_t filesize
= bfd_get_file_size (abfd
);
715 && filesize
< storage
716 /* The MMO file format supports its own special compression
717 technique, so its sections can be larger than the file size. */
718 && bfd_get_flavour (abfd
) != bfd_target_mmo_flavour
)
720 bfd_nonfatal_message (bfd_get_filename (abfd
), abfd
, NULL
,
721 _("error: symbol table size (%#lx) is larger than filesize (%#lx)"),
722 storage
, (long) filesize
);
728 sy
= (asymbol
**) xmalloc (storage
);
731 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
733 bfd_fatal (bfd_get_filename (abfd
));
737 /* Read in the dynamic symbols. */
740 slurp_dynamic_symtab (bfd
*abfd
)
745 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
748 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
750 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
756 bfd_fatal (bfd_get_filename (abfd
));
759 sy
= (asymbol
**) xmalloc (storage
);
761 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
763 bfd_fatal (bfd_get_filename (abfd
));
767 /* Some symbol names are significant and should be kept in the
768 table of sorted symbol names, even if they are marked as
769 debugging/section symbols. */
772 is_significant_symbol_name (const char * name
)
774 return strncmp (name
, ".plt", 4) == 0 || strcmp (name
, ".got") == 0;
777 /* Filter out (in place) symbols that are useless for disassembly.
778 COUNT is the number of elements in SYMBOLS.
779 Return the number of useful symbols. */
782 remove_useless_symbols (asymbol
**symbols
, long count
)
784 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
788 asymbol
*sym
= *in_ptr
++;
790 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
792 if ((sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
793 && ! is_significant_symbol_name (sym
->name
))
795 if (bfd_is_und_section (sym
->section
)
796 || bfd_is_com_section (sym
->section
))
801 return out_ptr
- symbols
;
804 /* Sort symbols into value order. */
807 compare_symbols (const void *ap
, const void *bp
)
809 const asymbol
*a
= * (const asymbol
**) ap
;
810 const asymbol
*b
= * (const asymbol
**) bp
;
820 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
822 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
825 if (a
->section
> b
->section
)
827 else if (a
->section
< b
->section
)
830 an
= bfd_asymbol_name (a
);
831 bn
= bfd_asymbol_name (b
);
835 /* The symbols gnu_compiled and gcc2_compiled convey no real
836 information, so put them after other symbols with the same value. */
837 af
= (strstr (an
, "gnu_compiled") != NULL
838 || strstr (an
, "gcc2_compiled") != NULL
);
839 bf
= (strstr (bn
, "gnu_compiled") != NULL
840 || strstr (bn
, "gcc2_compiled") != NULL
);
847 /* We use a heuristic for the file name, to try to sort it after
848 more useful symbols. It may not work on non Unix systems, but it
849 doesn't really matter; the only difference is precisely which
850 symbol names get printed. */
852 #define file_symbol(s, sn, snl) \
853 (((s)->flags & BSF_FILE) != 0 \
854 || ((sn)[(snl) - 2] == '.' \
855 && ((sn)[(snl) - 1] == 'o' \
856 || (sn)[(snl) - 1] == 'a')))
858 af
= file_symbol (a
, an
, anl
);
859 bf
= file_symbol (b
, bn
, bnl
);
866 /* Try to sort global symbols before local symbols before function
867 symbols before debugging symbols. */
872 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
874 if ((aflags
& BSF_DEBUGGING
) != 0)
879 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
881 if ((aflags
& BSF_FUNCTION
) != 0)
886 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
888 if ((aflags
& BSF_LOCAL
) != 0)
893 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
895 if ((aflags
& BSF_GLOBAL
) != 0)
901 if (bfd_get_flavour (bfd_asymbol_bfd (a
)) == bfd_target_elf_flavour
902 && bfd_get_flavour (bfd_asymbol_bfd (b
)) == bfd_target_elf_flavour
)
907 if ((a
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
908 asz
= ((elf_symbol_type
*) a
)->internal_elf_sym
.st_size
;
910 if ((b
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
911 bsz
= ((elf_symbol_type
*) b
)->internal_elf_sym
.st_size
;
913 return asz
> bsz
? -1 : 1;
916 /* Symbols that start with '.' might be section names, so sort them
917 after symbols that don't start with '.'. */
918 if (an
[0] == '.' && bn
[0] != '.')
920 if (an
[0] != '.' && bn
[0] == '.')
923 /* Finally, if we can't distinguish them in any other way, try to
924 get consistent results by sorting the symbols by name. */
925 return strcmp (an
, bn
);
928 /* Sort relocs into address order. */
931 compare_relocs (const void *ap
, const void *bp
)
933 const arelent
*a
= * (const arelent
**) ap
;
934 const arelent
*b
= * (const arelent
**) bp
;
936 if (a
->address
> b
->address
)
938 else if (a
->address
< b
->address
)
941 /* So that associated relocations tied to the same address show up
942 in the correct order, we don't do any further sorting. */
951 /* Print an address (VMA) to the output stream in INFO.
952 If SKIP_ZEROES is TRUE, omit leading zeroes. */
955 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
956 bfd_boolean skip_zeroes
)
960 struct objdump_disasm_info
*aux
;
962 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
963 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
968 for (p
= buf
; *p
== '0'; ++p
)
973 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
976 /* Print the name of a symbol. */
979 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
983 const char *name
, *version_string
= NULL
;
984 bfd_boolean hidden
= FALSE
;
987 name
= bfd_asymbol_name (sym
);
988 if (do_demangle
&& name
[0] != '\0')
990 /* Demangle the name. */
991 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
996 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
997 version_string
= bfd_get_symbol_version_string (abfd
, sym
, &hidden
);
999 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1002 name
= sanitize_string (name
);
1006 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
1007 if (version_string
&& *version_string
!= '\0')
1008 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
1013 printf ("%s", name
);
1014 if (version_string
&& *version_string
!= '\0')
1015 printf (hidden
? "@%s" : "@@%s", version_string
);
1022 static inline bfd_boolean
1023 sym_ok (bfd_boolean want_section
,
1024 bfd
* abfd ATTRIBUTE_UNUSED
,
1027 struct disassemble_info
* inf
)
1031 /* Note - we cannot just compare section pointers because they could
1032 be different, but the same... Ie the symbol that we are trying to
1033 find could have come from a separate debug info file. Under such
1034 circumstances the symbol will be associated with a section in the
1035 debug info file, whilst the section we want is in a normal file.
1036 So the section pointers will be different, but the section names
1037 will be the same. */
1038 if (strcmp (bfd_section_name (sorted_syms
[place
]->section
),
1039 bfd_section_name (sec
)) != 0)
1043 return inf
->symbol_is_valid (sorted_syms
[place
], inf
);
1046 /* Locate a symbol given a bfd and a section (from INFO->application_data),
1047 and a VMA. If INFO->application_data->require_sec is TRUE, then always
1048 require the symbol to be in the section. Returns NULL if there is no
1049 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
1050 of the symbol in sorted_syms. */
1053 find_symbol_for_address (bfd_vma vma
,
1054 struct disassemble_info
*inf
,
1057 /* @@ Would it speed things up to cache the last two symbols returned,
1058 and maybe their address ranges? For many processors, only one memory
1059 operand can be present at a time, so the 2-entry cache wouldn't be
1060 constantly churned by code doing heavy memory accesses. */
1062 /* Indices in `sorted_syms'. */
1064 long max_count
= sorted_symcount
;
1066 struct objdump_disasm_info
*aux
;
1070 bfd_boolean want_section
;
1073 if (sorted_symcount
< 1)
1076 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1079 opb
= inf
->octets_per_byte
;
1081 /* Perform a binary search looking for the closest symbol to the
1082 required value. We are searching the range (min, max_count]. */
1083 while (min
+ 1 < max_count
)
1087 thisplace
= (max_count
+ min
) / 2;
1088 sym
= sorted_syms
[thisplace
];
1090 if (bfd_asymbol_value (sym
) > vma
)
1091 max_count
= thisplace
;
1092 else if (bfd_asymbol_value (sym
) < vma
)
1101 /* The symbol we want is now in min, the low end of the range we
1102 were searching. If there are several symbols with the same
1103 value, we want the first (non-section/non-debugging) one. */
1105 while (thisplace
> 0
1106 && (bfd_asymbol_value (sorted_syms
[thisplace
])
1107 == bfd_asymbol_value (sorted_syms
[thisplace
- 1]))
1108 && ((sorted_syms
[thisplace
- 1]->flags
1109 & (BSF_SECTION_SYM
| BSF_DEBUGGING
)) == 0)
1113 /* Prefer a symbol in the current section if we have multple symbols
1114 with the same value, as can occur with overlays or zero size
1117 while (min
< max_count
1118 && (bfd_asymbol_value (sorted_syms
[min
])
1119 == bfd_asymbol_value (sorted_syms
[thisplace
])))
1121 if (sym_ok (TRUE
, abfd
, min
, sec
, inf
))
1128 return sorted_syms
[thisplace
];
1133 /* If the file is relocatable, and the symbol could be from this
1134 section, prefer a symbol from this section over symbols from
1135 others, even if the other symbol's value might be closer.
1137 Note that this may be wrong for some symbol references if the
1138 sections have overlapping memory ranges, but in that case there's
1139 no way to tell what's desired without looking at the relocation
1142 Also give the target a chance to reject symbols. */
1143 want_section
= (aux
->require_sec
1144 || ((abfd
->flags
& HAS_RELOC
) != 0
1145 && vma
>= bfd_section_vma (sec
)
1146 && vma
< (bfd_section_vma (sec
)
1147 + bfd_section_size (sec
) / opb
)));
1149 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1152 long newplace
= sorted_symcount
;
1154 for (i
= min
- 1; i
>= 0; i
--)
1156 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1158 if (newplace
== sorted_symcount
)
1161 if (bfd_asymbol_value (sorted_syms
[i
])
1162 != bfd_asymbol_value (sorted_syms
[newplace
]))
1165 /* Remember this symbol and keep searching until we reach
1166 an earlier address. */
1171 if (newplace
!= sorted_symcount
)
1172 thisplace
= newplace
;
1175 /* We didn't find a good symbol with a smaller value.
1176 Look for one with a larger value. */
1177 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1179 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1187 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1188 /* There is no suitable symbol. */
1192 /* If we have not found an exact match for the specified address
1193 and we have dynamic relocations available, then we can produce
1194 a better result by matching a relocation to the address and
1195 using the symbol associated with that relocation. */
1196 rel_count
= aux
->dynrelcount
;
1198 && sorted_syms
[thisplace
]->value
!= vma
1200 && aux
->dynrelbuf
!= NULL
1201 && aux
->dynrelbuf
[0]->address
<= vma
1202 && aux
->dynrelbuf
[rel_count
- 1]->address
>= vma
1203 /* If we have matched a synthetic symbol, then stick with that. */
1204 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1207 arelent
** rel_high
;
1209 rel_low
= aux
->dynrelbuf
;
1210 rel_high
= rel_low
+ rel_count
- 1;
1211 while (rel_low
<= rel_high
)
1213 arelent
**rel_mid
= &rel_low
[(rel_high
- rel_low
) / 2];
1214 arelent
* rel
= *rel_mid
;
1216 if (rel
->address
== vma
)
1218 /* Absolute relocations do not provide a more helpful
1219 symbolic address. Find a non-absolute relocation
1220 with the same address. */
1221 arelent
**rel_vma
= rel_mid
;
1223 rel_mid
>= rel_low
&& rel_mid
[0]->address
== vma
;
1227 for (; rel_vma
<= rel_high
&& rel_vma
[0]->address
== vma
;
1231 if (rel
->sym_ptr_ptr
!= NULL
1232 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1235 * place
= thisplace
;
1236 return * rel
->sym_ptr_ptr
;
1242 if (vma
< rel
->address
)
1244 else if (vma
>= rel_mid
[1]->address
)
1245 rel_low
= rel_mid
+ 1;
1254 return sorted_syms
[thisplace
];
1257 /* Print an address and the offset to the nearest symbol. */
1260 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1261 bfd_vma vma
, struct disassemble_info
*inf
,
1262 bfd_boolean skip_zeroes
)
1264 objdump_print_value (vma
, inf
, skip_zeroes
);
1270 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
1271 sanitize_string (bfd_section_name (sec
)));
1272 secaddr
= bfd_section_vma (sec
);
1275 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1276 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
1278 else if (vma
> secaddr
)
1280 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1281 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
1283 (*inf
->fprintf_func
) (inf
->stream
, ">");
1287 (*inf
->fprintf_func
) (inf
->stream
, " <");
1289 objdump_print_symname (abfd
, inf
, sym
);
1291 if (bfd_asymbol_value (sym
) == vma
)
1293 /* Undefined symbols in an executables and dynamic objects do not have
1294 a value associated with them, so it does not make sense to display
1295 an offset relative to them. Normally we would not be provided with
1296 this kind of symbol, but the target backend might choose to do so,
1297 and the code in find_symbol_for_address might return an as yet
1298 unresolved symbol associated with a dynamic reloc. */
1299 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1300 && bfd_is_und_section (sym
->section
))
1302 else if (bfd_asymbol_value (sym
) > vma
)
1304 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1305 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1307 else if (vma
> bfd_asymbol_value (sym
))
1309 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1310 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1313 (*inf
->fprintf_func
) (inf
->stream
, ">");
1316 if (display_file_offsets
)
1317 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1318 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1321 /* Print an address (VMA), symbolically if possible.
1322 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1325 objdump_print_addr (bfd_vma vma
,
1326 struct disassemble_info
*inf
,
1327 bfd_boolean skip_zeroes
)
1329 struct objdump_disasm_info
*aux
;
1330 asymbol
*sym
= NULL
;
1331 bfd_boolean skip_find
= FALSE
;
1333 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1335 if (sorted_symcount
< 1)
1337 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1338 objdump_print_value (vma
, inf
, skip_zeroes
);
1340 if (display_file_offsets
)
1341 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1342 (long int)(aux
->sec
->filepos
+ (vma
- aux
->sec
->vma
)));
1346 if (aux
->reloc
!= NULL
1347 && aux
->reloc
->sym_ptr_ptr
!= NULL
1348 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1350 sym
= * aux
->reloc
->sym_ptr_ptr
;
1352 /* Adjust the vma to the reloc. */
1353 vma
+= bfd_asymbol_value (sym
);
1355 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1360 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1362 objdump_print_addr_with_sym (aux
->abfd
, aux
->sec
, sym
, vma
, inf
,
1366 /* Print VMA to INFO. This function is passed to the disassembler
1370 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1372 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1375 /* Determine if the given address has a symbol associated with it. */
1378 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1382 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1384 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1387 /* Hold the last function name and the last line number we displayed
1388 in a disassembly. */
1390 static char *prev_functionname
;
1391 static unsigned int prev_line
;
1392 static unsigned int prev_discriminator
;
1394 /* We keep a list of all files that we have seen when doing a
1395 disassembly with source, so that we know how much of the file to
1396 display. This can be important for inlined functions. */
1398 struct print_file_list
1400 struct print_file_list
*next
;
1401 const char *filename
;
1402 const char *modname
;
1405 const char **linemap
;
1408 unsigned max_printed
;
1412 static struct print_file_list
*print_files
;
1414 /* The number of preceding context lines to show when we start
1415 displaying a file for the first time. */
1417 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1419 /* Read a complete file into memory. */
1422 slurp_file (const char *fn
, size_t *size
, struct stat
*fst
)
1425 int ps
= getpagesize ();
1429 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1433 if (fstat (fd
, fst
) < 0)
1438 *size
= fst
->st_size
;
1440 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1441 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1442 if (map
!= (char *) -1L)
1448 map
= (const char *) malloc (*size
);
1449 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1451 free ((void *) map
);
1458 #define line_map_decrease 5
1460 /* Precompute array of lines for a mapped file. */
1462 static const char **
1463 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1465 const char *p
, *lstart
, *end
;
1466 int chars_per_line
= 45; /* First iteration will use 40. */
1467 unsigned int lineno
;
1468 const char **linemap
= NULL
;
1469 unsigned long line_map_size
= 0;
1475 for (p
= map
; p
< end
; p
++)
1479 if (p
+ 1 < end
&& p
[1] == '\r')
1482 else if (*p
== '\r')
1484 if (p
+ 1 < end
&& p
[1] == '\n')
1490 /* End of line found. */
1492 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1494 unsigned long newsize
;
1496 chars_per_line
-= line_map_decrease
;
1497 if (chars_per_line
<= 1)
1499 line_map_size
= size
/ chars_per_line
+ 1;
1500 if (line_map_size
< lineno
+ 1)
1501 line_map_size
= lineno
+ 1;
1502 newsize
= line_map_size
* sizeof (char *);
1503 linemap
= (const char **) xrealloc (linemap
, newsize
);
1506 linemap
[lineno
++] = lstart
;
1514 /* Tries to open MODNAME, and if successful adds a node to print_files
1515 linked list and returns that node. Returns NULL on failure. */
1517 static struct print_file_list
*
1518 try_print_file_open (const char *origname
, const char *modname
, struct stat
*fst
)
1520 struct print_file_list
*p
;
1522 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1524 p
->map
= slurp_file (modname
, &p
->mapsize
, fst
);
1531 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1534 p
->filename
= origname
;
1535 p
->modname
= modname
;
1536 p
->next
= print_files
;
1542 /* If the source file, as described in the symtab, is not found
1543 try to locate it in one of the paths specified with -I
1544 If found, add location to print_files linked list. */
1546 static struct print_file_list
*
1547 update_source_path (const char *filename
, bfd
*abfd
)
1549 struct print_file_list
*p
;
1554 p
= try_print_file_open (filename
, filename
, &fst
);
1557 if (include_path_count
== 0)
1560 /* Get the name of the file. */
1561 fname
= lbasename (filename
);
1563 /* If file exists under a new path, we need to add it to the list
1564 so that show_line knows about it. */
1565 for (i
= 0; i
< include_path_count
; i
++)
1567 char *modname
= concat (include_paths
[i
], "/", fname
,
1570 p
= try_print_file_open (filename
, modname
, &fst
);
1580 long mtime
= bfd_get_mtime (abfd
);
1582 if (fst
.st_mtime
> mtime
)
1583 warn (_("source file %s is more recent than object file\n"),
1590 /* Print a source file line. */
1593 print_line (struct print_file_list
*p
, unsigned int linenum
)
1599 if (linenum
>= p
->maxline
)
1601 l
= p
->linemap
[linenum
];
1602 if (source_comment
!= NULL
&& strlen (l
) > 0)
1603 printf ("%s", source_comment
);
1604 len
= strcspn (l
, "\n\r");
1605 /* Test fwrite return value to quiet glibc warning. */
1606 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1610 /* Print a range of source code lines. */
1613 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1617 while (start
<= end
)
1619 print_line (p
, start
);
1624 /* Show the line number, or the source line, in a disassembly
1628 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1630 const char *filename
;
1631 const char *functionname
;
1632 unsigned int linenumber
;
1633 unsigned int discriminator
;
1637 if (! with_line_numbers
&& ! with_source_code
)
1640 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1641 &filename
, &functionname
,
1642 &linenumber
, &discriminator
))
1645 if (filename
!= NULL
&& *filename
== '\0')
1647 if (functionname
!= NULL
&& *functionname
== '\0')
1648 functionname
= NULL
;
1651 && IS_ABSOLUTE_PATH (filename
)
1655 const char *fname
= filename
;
1657 path
= xmalloc (prefix_length
+ PATH_MAX
+ 1);
1660 memcpy (path
, prefix
, prefix_length
);
1661 path_up
= path
+ prefix_length
;
1663 /* Build relocated filename, stripping off leading directories
1664 from the initial filename if requested. */
1665 if (prefix_strip
> 0)
1670 /* Skip selected directory levels. */
1671 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1672 if (IS_DIR_SEPARATOR(*s
))
1679 /* Update complete filename. */
1680 strncpy (path_up
, fname
, PATH_MAX
);
1681 path_up
[PATH_MAX
] = '\0';
1689 if (with_line_numbers
)
1691 if (functionname
!= NULL
1692 && (prev_functionname
== NULL
1693 || strcmp (functionname
, prev_functionname
) != 0))
1695 printf ("%s():\n", sanitize_string (functionname
));
1699 && (linenumber
!= prev_line
1700 || discriminator
!= prev_discriminator
))
1702 if (discriminator
> 0)
1703 printf ("%s:%u (discriminator %u)\n",
1704 filename
== NULL
? "???" : sanitize_string (filename
),
1705 linenumber
, discriminator
);
1707 printf ("%s:%u\n", filename
== NULL
1708 ? "???" : sanitize_string (filename
),
1713 const char *filename2
;
1714 const char *functionname2
;
1717 while (bfd_find_inliner_info (abfd
, &filename2
, &functionname2
,
1720 printf ("inlined by %s:%u",
1721 sanitize_string (filename2
), line2
);
1722 printf (" (%s)\n", sanitize_string (functionname2
));
1727 if (with_source_code
1731 struct print_file_list
**pp
, *p
;
1734 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1735 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1742 filename
= xstrdup (filename
);
1743 p
= update_source_path (filename
, abfd
);
1746 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1748 if (file_start_context
&& p
->first
)
1752 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1753 if (l
>= linenumber
)
1755 if (p
->max_printed
>= l
)
1757 if (p
->max_printed
< linenumber
)
1758 l
= p
->max_printed
+ 1;
1763 dump_lines (p
, l
, linenumber
);
1764 if (p
->max_printed
< linenumber
)
1765 p
->max_printed
= linenumber
;
1766 p
->last_line
= linenumber
;
1771 if (functionname
!= NULL
1772 && (prev_functionname
== NULL
1773 || strcmp (functionname
, prev_functionname
) != 0))
1775 if (prev_functionname
!= NULL
)
1776 free (prev_functionname
);
1777 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1778 strcpy (prev_functionname
, functionname
);
1781 if (linenumber
> 0 && linenumber
!= prev_line
)
1782 prev_line
= linenumber
;
1784 if (discriminator
!= prev_discriminator
)
1785 prev_discriminator
= discriminator
;
1791 /* Pseudo FILE object for strings. */
1799 /* sprintf to a "stream". */
1801 static int ATTRIBUTE_PRINTF_2
1802 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1809 size_t space
= f
->alloc
- f
->pos
;
1811 va_start (args
, format
);
1812 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1818 f
->alloc
= (f
->alloc
+ n
) * 2;
1819 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1826 /* The number of zeroes we want to see before we start skipping them.
1827 The number is arbitrarily chosen. */
1829 #define DEFAULT_SKIP_ZEROES 8
1831 /* The number of zeroes to skip at the end of a section. If the
1832 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1833 SKIP_ZEROES, they will be disassembled. If there are fewer than
1834 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1835 attempt to avoid disassembling zeroes inserted by section
1838 #define DEFAULT_SKIP_ZEROES_AT_END 3
1841 null_print (const void * stream ATTRIBUTE_UNUSED
, const char * format ATTRIBUTE_UNUSED
, ...)
1846 /* Disassemble some data in memory between given values. */
1849 disassemble_bytes (struct disassemble_info
* inf
,
1850 disassembler_ftype disassemble_fn
,
1853 bfd_vma start_offset
,
1854 bfd_vma stop_offset
,
1857 arelent
** relppend
)
1859 struct objdump_disasm_info
*aux
;
1861 int octets_per_line
;
1862 int skip_addr_chars
;
1863 bfd_vma addr_offset
;
1864 unsigned int opb
= inf
->octets_per_byte
;
1865 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1866 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1870 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1874 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1878 octets_per_line
= insn_width
;
1880 octets_per_line
= 4;
1882 octets_per_line
= 16;
1884 /* Figure out how many characters to skip at the start of an
1885 address, to make the disassembly look nicer. We discard leading
1886 zeroes in chunks of 4, ensuring that there is always a leading
1888 skip_addr_chars
= 0;
1889 if (! prefix_addresses
)
1893 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1895 while (buf
[skip_addr_chars
] == '0')
1898 /* Don't discard zeros on overflow. */
1899 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1900 skip_addr_chars
= 0;
1902 if (skip_addr_chars
!= 0)
1903 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1906 inf
->insn_info_valid
= 0;
1908 addr_offset
= start_offset
;
1909 while (addr_offset
< stop_offset
)
1912 bfd_boolean need_nl
= FALSE
;
1916 /* Make sure we don't use relocs from previous instructions. */
1919 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1921 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1924 if (! disassemble_zeroes
1925 && (inf
->insn_info_valid
== 0
1926 || inf
->branch_delay_insns
== 0)
1927 && (z
- addr_offset
* opb
>= skip_zeroes
1928 || (z
== stop_offset
* opb
&&
1929 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1931 /* If there are more nonzero octets to follow, we only skip
1932 zeroes in multiples of 4, to try to avoid running over
1933 the start of an instruction which happens to start with
1935 if (z
!= stop_offset
* opb
)
1936 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1938 octets
= z
- addr_offset
* opb
;
1940 /* If we are going to display more data, and we are displaying
1941 file offsets, then tell the user how many zeroes we skip
1942 and the file offset from where we resume dumping. */
1943 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1944 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1946 (unsigned long) (section
->filepos
1947 + (addr_offset
+ (octets
/ opb
))));
1957 if (with_line_numbers
|| with_source_code
)
1958 show_line (aux
->abfd
, section
, addr_offset
);
1960 if (! prefix_addresses
)
1964 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1965 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1969 printf ("%s:\t", buf
+ skip_addr_chars
);
1973 aux
->require_sec
= TRUE
;
1974 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1975 aux
->require_sec
= FALSE
;
1982 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1983 inf
->stream
= &sfile
;
1984 inf
->bytes_per_line
= 0;
1985 inf
->bytes_per_chunk
= 0;
1986 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
1987 | (wide_output
? WIDE_OUTPUT
: 0));
1989 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1991 if (inf
->disassembler_needs_relocs
1992 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1993 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1994 && *relppp
< relppend
)
1996 bfd_signed_vma distance_to_rel
;
1998 int max_reloc_offset
1999 = aux
->abfd
->arch_info
->max_reloc_offset_into_insn
;
2001 distance_to_rel
= ((**relppp
)->address
- rel_offset
2004 if (distance_to_rel
> 0
2005 && (max_reloc_offset
< 0
2006 || distance_to_rel
<= max_reloc_offset
))
2008 /* This reloc *might* apply to the current insn,
2009 starting somewhere inside it. Discover the length
2010 of the current insn so that the check below will
2013 insn_size
= insn_width
;
2016 /* We find the length by calling the dissassembler
2017 function with a dummy print handler. This should
2018 work unless the disassembler is not expecting to
2019 be called multiple times for the same address.
2021 This does mean disassembling the instruction
2022 twice, but we only do this when there is a high
2023 probability that there is a reloc that will
2024 affect the instruction. */
2025 inf
->fprintf_func
= (fprintf_ftype
) null_print
;
2026 insn_size
= disassemble_fn (section
->vma
2027 + addr_offset
, inf
);
2028 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2032 /* Check to see if the current reloc is associated with
2033 the instruction that we are about to disassemble. */
2034 if (distance_to_rel
== 0
2035 || (distance_to_rel
> 0
2036 && distance_to_rel
< insn_size
/ (int) opb
))
2038 inf
->flags
|= INSN_HAS_RELOC
;
2039 aux
->reloc
= **relppp
;
2043 if (! disassemble_all
2044 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2045 == (SEC_CODE
| SEC_HAS_CONTENTS
))
2046 /* Set a stop_vma so that the disassembler will not read
2047 beyond the next symbol. We assume that symbols appear on
2048 the boundaries between instructions. We only do this when
2049 disassembling code of course, and when -D is in effect. */
2050 inf
->stop_vma
= section
->vma
+ stop_offset
;
2052 inf
->stop_offset
= stop_offset
;
2053 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2056 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2057 inf
->stream
= stdout
;
2058 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
2059 octets_per_line
= inf
->bytes_per_line
;
2060 if (octets
< (int) opb
)
2063 printf ("%s\n", sfile
.buffer
);
2066 non_fatal (_("disassemble_fn returned length %d"),
2077 octets
= octets_per_line
;
2078 if (addr_offset
+ octets
/ opb
> stop_offset
)
2079 octets
= (stop_offset
- addr_offset
) * opb
;
2081 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
2083 if (ISPRINT (data
[j
]))
2084 buf
[j
- addr_offset
* opb
] = data
[j
];
2086 buf
[j
- addr_offset
* opb
] = '.';
2088 buf
[j
- addr_offset
* opb
] = '\0';
2091 if (prefix_addresses
2093 : show_raw_insn
>= 0)
2097 /* If ! prefix_addresses and ! wide_output, we print
2098 octets_per_line octets per line. */
2100 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
2101 pb
= octets_per_line
;
2103 if (inf
->bytes_per_chunk
)
2104 bpc
= inf
->bytes_per_chunk
;
2108 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2110 /* PR 21580: Check for a buffer ending early. */
2111 if (j
+ bpc
<= stop_offset
* opb
)
2115 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2117 for (k
= bpc
- 1; k
>= 0; k
--)
2118 printf ("%02x", (unsigned) data
[j
+ k
]);
2122 for (k
= 0; k
< bpc
; k
++)
2123 printf ("%02x", (unsigned) data
[j
+ k
]);
2129 for (; pb
< octets_per_line
; pb
+= bpc
)
2133 for (k
= 0; k
< bpc
; k
++)
2138 /* Separate raw data from instruction by extra space. */
2148 printf ("%s", sfile
.buffer
);
2150 if (prefix_addresses
2152 : show_raw_insn
>= 0)
2160 j
= addr_offset
* opb
+ pb
;
2162 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
2163 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2167 printf ("%s:\t", buf
+ skip_addr_chars
);
2169 pb
+= octets_per_line
;
2172 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2174 /* PR 21619: Check for a buffer ending early. */
2175 if (j
+ bpc
<= stop_offset
* opb
)
2179 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2181 for (k
= bpc
- 1; k
>= 0; k
--)
2182 printf ("%02x", (unsigned) data
[j
+ k
]);
2186 for (k
= 0; k
< bpc
; k
++)
2187 printf ("%02x", (unsigned) data
[j
+ k
]);
2201 while ((*relppp
) < relppend
2202 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
2204 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
2215 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
2218 if (q
->howto
== NULL
)
2219 printf (": *unknown*\t");
2220 else if (q
->howto
->name
)
2221 printf (": %s\t", q
->howto
->name
);
2223 printf (": %d\t", q
->howto
->type
);
2225 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
2226 printf ("*unknown*");
2229 const char *sym_name
;
2231 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
2232 if (sym_name
!= NULL
&& *sym_name
!= '\0')
2233 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
2238 sym_sec
= bfd_asymbol_section (*q
->sym_ptr_ptr
);
2239 sym_name
= bfd_section_name (sym_sec
);
2240 if (sym_name
== NULL
|| *sym_name
== '\0')
2241 sym_name
= "*unknown*";
2242 printf ("%s", sanitize_string (sym_name
));
2248 bfd_signed_vma addend
= q
->addend
;
2256 objdump_print_value (addend
, inf
, TRUE
);
2268 addr_offset
+= octets
/ opb
;
2271 free (sfile
.buffer
);
2275 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
2277 const struct elf_backend_data
* bed
;
2278 bfd_vma sign_adjust
= 0;
2279 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
2280 struct objdump_disasm_info
* paux
;
2281 unsigned int opb
= pinfo
->octets_per_byte
;
2282 bfd_byte
* data
= NULL
;
2283 bfd_size_type datasize
= 0;
2284 arelent
** rel_pp
= NULL
;
2285 arelent
** rel_ppstart
= NULL
;
2286 arelent
** rel_ppend
;
2287 bfd_vma stop_offset
;
2288 asymbol
* sym
= NULL
;
2292 unsigned long addr_offset
;
2293 bfd_boolean do_print
;
2296 stop_offset_reached
,
2301 /* Sections that do not contain machine
2302 code are not normally disassembled. */
2303 if (! disassemble_all
2304 && only_list
== NULL
2305 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2306 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
2309 if (! process_section_p (section
))
2312 datasize
= bfd_section_size (section
);
2316 if (start_address
== (bfd_vma
) -1
2317 || start_address
< section
->vma
)
2320 addr_offset
= start_address
- section
->vma
;
2322 if (stop_address
== (bfd_vma
) -1)
2323 stop_offset
= datasize
/ opb
;
2326 if (stop_address
< section
->vma
)
2329 stop_offset
= stop_address
- section
->vma
;
2330 if (stop_offset
> datasize
/ opb
)
2331 stop_offset
= datasize
/ opb
;
2334 if (addr_offset
>= stop_offset
)
2337 /* Decide which set of relocs to use. Load them if necessary. */
2338 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
2339 if (paux
->dynrelbuf
&& dump_dynamic_reloc_info
)
2341 rel_pp
= paux
->dynrelbuf
;
2342 rel_count
= paux
->dynrelcount
;
2343 /* Dynamic reloc addresses are absolute, non-dynamic are section
2344 relative. REL_OFFSET specifies the reloc address corresponding
2345 to the start of this section. */
2346 rel_offset
= section
->vma
;
2354 if ((section
->flags
& SEC_RELOC
) != 0
2355 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
2359 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2361 bfd_fatal (bfd_get_filename (abfd
));
2365 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
2366 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
2368 bfd_fatal (bfd_get_filename (abfd
));
2370 /* Sort the relocs by address. */
2371 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
2375 rel_ppend
= rel_pp
+ rel_count
;
2377 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2379 non_fatal (_("Reading section %s failed because: %s"),
2380 section
->name
, bfd_errmsg (bfd_get_error ()));
2384 paux
->sec
= section
;
2385 pinfo
->buffer
= data
;
2386 pinfo
->buffer_vma
= section
->vma
;
2387 pinfo
->buffer_length
= datasize
;
2388 pinfo
->section
= section
;
2390 /* Skip over the relocs belonging to addresses below the
2392 while (rel_pp
< rel_ppend
2393 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
2396 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
2398 /* Find the nearest symbol forwards from our current position. */
2399 paux
->require_sec
= TRUE
;
2400 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
2401 (struct disassemble_info
*) inf
,
2403 paux
->require_sec
= FALSE
;
2405 /* PR 9774: If the target used signed addresses then we must make
2406 sure that we sign extend the value that we calculate for 'addr'
2407 in the loop below. */
2408 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2409 && (bed
= get_elf_backend_data (abfd
)) != NULL
2410 && bed
->sign_extend_vma
)
2411 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2413 /* Disassemble a block of instructions up to the address associated with
2414 the symbol we have just found. Then print the symbol and find the
2415 next symbol on. Repeat until we have disassembled the entire section
2416 or we have reached the end of the address range we are interested in. */
2417 do_print
= paux
->symbol
== NULL
;
2418 loop_until
= stop_offset_reached
;
2420 while (addr_offset
< stop_offset
)
2424 bfd_vma nextstop_offset
;
2427 addr
= section
->vma
+ addr_offset
;
2428 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2430 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2435 (x
< sorted_symcount
2436 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2440 pinfo
->symbols
= sorted_syms
+ place
;
2441 pinfo
->num_symbols
= x
- place
;
2442 pinfo
->symtab_pos
= place
;
2446 pinfo
->symbols
= NULL
;
2447 pinfo
->num_symbols
= 0;
2448 pinfo
->symtab_pos
= -1;
2451 /* If we are only disassembling from a specific symbol,
2452 check to see if we should start or stop displaying. */
2453 if (sym
&& paux
->symbol
)
2457 /* See if we should stop printing. */
2461 if (sym
->flags
& BSF_FUNCTION
)
2465 case stop_offset_reached
:
2466 /* Handled by the while loop. */
2470 /* FIXME: There is an implicit assumption here
2471 that the name of sym is different from
2473 if (! bfd_is_local_label (abfd
, sym
))
2480 const char * name
= bfd_asymbol_name (sym
);
2481 char * alloc
= NULL
;
2483 if (do_demangle
&& name
[0] != '\0')
2485 /* Demangle the name. */
2486 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
2491 /* We are not currently printing. Check to see
2492 if the current symbol matches the requested symbol. */
2493 if (streq (name
, paux
->symbol
))
2497 if (sym
->flags
& BSF_FUNCTION
)
2499 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2500 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
2502 /* Sym is a function symbol with a size associated
2503 with it. Turn on automatic disassembly for the
2504 next VALUE bytes. */
2505 stop_offset
= addr_offset
2506 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
2507 loop_until
= stop_offset_reached
;
2511 /* Otherwise we need to tell the loop heuristic to
2512 loop until the next function symbol is encountered. */
2513 loop_until
= function_sym
;
2518 /* Otherwise loop until the next symbol is encountered. */
2519 loop_until
= next_sym
;
2527 if (! prefix_addresses
&& do_print
)
2529 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2530 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2532 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2535 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2537 else if (sym
== NULL
)
2541 #define is_valid_next_sym(SYM) \
2542 (strcmp (bfd_section_name ((SYM)->section), bfd_section_name (section)) == 0 \
2543 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2544 && pinfo->symbol_is_valid (SYM, pinfo))
2546 /* Search forward for the next appropriate symbol in
2547 SECTION. Note that all the symbols are sorted
2548 together into one big array, and that some sections
2549 may have overlapping addresses. */
2550 while (place
< sorted_symcount
2551 && ! is_valid_next_sym (sorted_syms
[place
]))
2554 if (place
>= sorted_symcount
)
2557 nextsym
= sorted_syms
[place
];
2560 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2561 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2562 else if (nextsym
== NULL
)
2563 nextstop_offset
= stop_offset
;
2565 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2567 if (nextstop_offset
> stop_offset
2568 || nextstop_offset
<= addr_offset
)
2569 nextstop_offset
= stop_offset
;
2571 /* If a symbol is explicitly marked as being an object
2572 rather than a function, just dump the bytes without
2573 disassembling them. */
2576 || sym
->section
!= section
2577 || bfd_asymbol_value (sym
) > addr
2578 || ((sym
->flags
& BSF_OBJECT
) == 0
2579 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2581 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2583 || (sym
->flags
& BSF_FUNCTION
) != 0)
2589 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2590 addr_offset
, nextstop_offset
,
2591 rel_offset
, &rel_pp
, rel_ppend
);
2593 addr_offset
= nextstop_offset
;
2599 if (rel_ppstart
!= NULL
)
2603 /* Disassemble the contents of an object file. */
2606 disassemble_data (bfd
*abfd
)
2608 struct disassemble_info disasm_info
;
2609 struct objdump_disasm_info aux
;
2613 prev_functionname
= NULL
;
2615 prev_discriminator
= 0;
2617 /* We make a copy of syms to sort. We don't want to sort syms
2618 because that will screw up the relocs. */
2619 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2620 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2621 * sizeof (asymbol
*));
2622 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2623 sorted_symcount
* sizeof (asymbol
*));
2625 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2627 for (i
= 0; i
< synthcount
; ++i
)
2629 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2633 /* Sort the symbols into section and symbol order. */
2634 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2636 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2638 disasm_info
.application_data
= (void *) &aux
;
2640 aux
.require_sec
= FALSE
;
2641 aux
.dynrelbuf
= NULL
;
2642 aux
.dynrelcount
= 0;
2644 aux
.symbol
= disasm_sym
;
2646 disasm_info
.print_address_func
= objdump_print_address
;
2647 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2649 if (machine
!= NULL
)
2651 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2654 fatal (_("can't use supplied machine %s"), machine
);
2656 abfd
->arch_info
= inf
;
2659 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2661 struct bfd_target
*xvec
;
2663 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2664 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2665 xvec
->byteorder
= endian
;
2669 /* Use libopcodes to locate a suitable disassembler. */
2670 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
2671 bfd_big_endian (abfd
),
2672 bfd_get_mach (abfd
), abfd
);
2673 if (!aux
.disassemble_fn
)
2675 non_fatal (_("can't disassemble for architecture %s\n"),
2676 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2681 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2682 disasm_info
.arch
= bfd_get_arch (abfd
);
2683 disasm_info
.mach
= bfd_get_mach (abfd
);
2684 disasm_info
.disassembler_options
= disassembler_options
;
2685 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
);
2686 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2687 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2688 disasm_info
.disassembler_needs_relocs
= FALSE
;
2690 if (bfd_big_endian (abfd
))
2691 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2692 else if (bfd_little_endian (abfd
))
2693 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2695 /* ??? Aborting here seems too drastic. We could default to big or little
2697 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2699 /* Allow the target to customize the info structure. */
2700 disassemble_init_for_target (& disasm_info
);
2702 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
2704 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2706 if (relsize
< 0 && dump_dynamic_reloc_info
)
2707 bfd_fatal (bfd_get_filename (abfd
));
2711 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2712 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2715 if (aux
.dynrelcount
< 0)
2716 bfd_fatal (bfd_get_filename (abfd
));
2718 /* Sort the relocs by address. */
2719 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2723 disasm_info
.symtab
= sorted_syms
;
2724 disasm_info
.symtab_size
= sorted_symcount
;
2726 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2728 if (aux
.dynrelbuf
!= NULL
)
2729 free (aux
.dynrelbuf
);
2734 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2735 asection
*sec
, void *file
)
2737 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2738 bfd
*abfd
= (bfd
*) file
;
2743 if (section
->start
!= NULL
)
2745 /* If it is already loaded, do nothing. */
2746 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2748 free (section
->start
);
2751 section
->filename
= bfd_get_filename (abfd
);
2752 section
->reloc_info
= NULL
;
2753 section
->num_relocs
= 0;
2754 section
->address
= bfd_section_vma (sec
);
2755 section
->user_data
= sec
;
2756 section
->size
= bfd_section_size (sec
);
2757 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
2758 alloced
= amt
= section
->size
+ 1;
2759 if (alloced
!= amt
|| alloced
== 0)
2761 section
->start
= NULL
;
2762 free_debug_section (debug
);
2763 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
2764 sanitize_string (section
->name
),
2765 (unsigned long long) section
->size
);
2768 section
->start
= contents
= malloc (alloced
);
2769 if (section
->start
== NULL
2770 || !bfd_get_full_section_contents (abfd
, sec
, &contents
))
2772 free_debug_section (debug
);
2773 printf (_("\nCan't get contents for section '%s'.\n"),
2774 sanitize_string (section
->name
));
2777 /* Ensure any string section has a terminating NUL. */
2778 section
->start
[section
->size
] = 0;
2780 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
2781 && debug_displays
[debug
].relocate
)
2786 bfd_cache_section_contents (sec
, section
->start
);
2788 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2795 free_debug_section (debug
);
2796 printf (_("\nCan't get contents for section '%s'.\n"),
2797 sanitize_string (section
->name
));
2801 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
2804 unsigned long reloc_count
;
2807 relocs
= (arelent
**) xmalloc (reloc_size
);
2809 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
2810 if (reloc_count
== 0)
2814 section
->reloc_info
= relocs
;
2815 section
->num_relocs
= reloc_count
;
2824 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
2829 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
2832 relocs
= (arelent
**) dsec
->reloc_info
;
2834 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
2835 if (rp
->address
== offset
)
2842 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2844 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2845 bfd
*abfd
= (bfd
*) file
;
2848 /* If it is already loaded, do nothing. */
2849 if (section
->start
!= NULL
)
2851 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2855 /* Locate the debug section. */
2856 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2858 section
->name
= section
->uncompressed_name
;
2861 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2863 section
->name
= section
->compressed_name
;
2868 return load_specific_debug_section (debug
, sec
, file
);
2872 free_debug_section (enum dwarf_section_display_enum debug
)
2874 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2876 if (section
->start
== NULL
)
2879 /* PR 17512: file: 0f67f69d. */
2880 if (section
->user_data
!= NULL
)
2882 asection
* sec
= (asection
*) section
->user_data
;
2884 /* If we are freeing contents that are also pointed to by the BFD
2885 library's section structure then make sure to update those pointers
2886 too. Otherwise, the next time we try to load data for this section
2887 we can end up using a stale pointer. */
2888 if (section
->start
== sec
->contents
)
2890 sec
->contents
= NULL
;
2891 sec
->flags
&= ~ SEC_IN_MEMORY
;
2892 sec
->compress_status
= COMPRESS_SECTION_NONE
;
2896 free ((char *) section
->start
);
2897 section
->start
= NULL
;
2898 section
->address
= 0;
2903 close_debug_file (void * file
)
2905 bfd
* abfd
= (bfd
*) file
;
2911 open_debug_file (const char * pathname
)
2915 data
= bfd_openr (pathname
, NULL
);
2919 if (! bfd_check_format (data
, bfd_object
))
2926 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2927 void *arg ATTRIBUTE_UNUSED
)
2929 const char *name
= bfd_section_name (section
);
2933 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2934 match
= ".debug_info";
2938 for (i
= 0; i
< max
; i
++)
2939 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2940 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2941 && debug_displays
[i
].enabled
!= NULL
2942 && *debug_displays
[i
].enabled
)
2944 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2946 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2947 sec
->name
= sec
->uncompressed_name
;
2949 sec
->name
= sec
->compressed_name
;
2950 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2953 debug_displays
[i
].display (sec
, abfd
);
2955 if (i
!= info
&& i
!= abbrev
)
2956 free_debug_section ((enum dwarf_section_display_enum
) i
);
2962 /* Dump the dwarf debugging information. */
2965 dump_dwarf (bfd
*abfd
)
2967 /* The byte_get pointer should have been set at the start of dump_bfd(). */
2968 if (byte_get
== NULL
)
2970 warn (_("File %s does not contain any dwarf debug information\n"),
2971 bfd_get_filename (abfd
));
2975 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2977 switch (bfd_get_arch (abfd
))
2980 switch (bfd_get_mach (abfd
))
2982 case bfd_mach_x86_64
:
2983 case bfd_mach_x86_64_intel_syntax
:
2984 case bfd_mach_x86_64_nacl
:
2985 case bfd_mach_x64_32
:
2986 case bfd_mach_x64_32_intel_syntax
:
2987 case bfd_mach_x64_32_nacl
:
2988 init_dwarf_regnames_x86_64 ();
2992 init_dwarf_regnames_i386 ();
2997 case bfd_arch_iamcu
:
2998 init_dwarf_regnames_iamcu ();
3001 case bfd_arch_aarch64
:
3002 init_dwarf_regnames_aarch64();
3006 init_dwarf_regnames_s390 ();
3009 case bfd_arch_riscv
:
3010 init_dwarf_regnames_riscv ();
3014 /* S12Z has a 24 bit address space. But the only known
3015 producer of dwarf_info encodes addresses into 32 bits. */
3023 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
3026 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
3027 it. Return NULL on failure. */
3030 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
3031 bfd_size_type
*entsize_ptr
)
3036 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
3037 if (stabsect
== NULL
)
3039 printf (_("No %s section present\n\n"),
3040 sanitize_string (sect_name
));
3044 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
3046 non_fatal (_("reading %s section of %s failed: %s"),
3047 sect_name
, bfd_get_filename (abfd
),
3048 bfd_errmsg (bfd_get_error ()));
3054 *size_ptr
= bfd_section_size (stabsect
);
3056 *entsize_ptr
= stabsect
->entsize
;
3061 /* Stabs entries use a 12 byte format:
3062 4 byte string table index
3064 1 byte stab other field
3065 2 byte stab desc field
3067 FIXME: This will have to change for a 64 bit object format. */
3069 #define STRDXOFF (0)
3071 #define OTHEROFF (5)
3074 #define STABSIZE (12)
3076 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3077 using string table section STRSECT_NAME (in `strtab'). */
3080 print_section_stabs (bfd
*abfd
,
3081 const char *stabsect_name
,
3082 unsigned *string_offset_ptr
)
3085 unsigned file_string_table_offset
= 0;
3086 unsigned next_file_string_table_offset
= *string_offset_ptr
;
3087 bfd_byte
*stabp
, *stabs_end
;
3090 stabs_end
= stabp
+ stab_size
;
3092 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
3093 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3095 /* Loop through all symbols and print them.
3097 We start the index at -1 because there is a dummy symbol on
3098 the front of stabs-in-{coff,elf} sections that supplies sizes. */
3099 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
3103 unsigned char type
, other
;
3104 unsigned short desc
;
3107 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
3108 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
3109 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
3110 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
3111 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
3113 printf ("\n%-6d ", i
);
3114 /* Either print the stab name, or, if unnamed, print its number
3115 again (makes consistent formatting for tools like awk). */
3116 name
= bfd_get_stab_name (type
);
3118 printf ("%-6s", sanitize_string (name
));
3119 else if (type
== N_UNDF
)
3122 printf ("%-6d", type
);
3123 printf (" %-6d %-6d ", other
, desc
);
3124 bfd_printf_vma (abfd
, value
);
3125 printf (" %-6lu", strx
);
3127 /* Symbols with type == 0 (N_UNDF) specify the length of the
3128 string table associated with this file. We use that info
3129 to know how to relocate the *next* file's string table indices. */
3132 file_string_table_offset
= next_file_string_table_offset
;
3133 next_file_string_table_offset
+= value
;
3137 bfd_size_type amt
= strx
+ file_string_table_offset
;
3139 /* Using the (possibly updated) string table offset, print the
3140 string (if any) associated with this symbol. */
3141 if (amt
< stabstr_size
)
3142 /* PR 17512: file: 079-79389-0.001:0.1.
3143 FIXME: May need to sanitize this string before displaying. */
3144 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
3150 *string_offset_ptr
= next_file_string_table_offset
;
3155 const char * section_name
;
3156 const char * string_section_name
;
3157 unsigned string_offset
;
3162 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
3165 stab_section_names
* sought
= (stab_section_names
*) names
;
3167 /* Check for section names for which stabsect_name is a prefix, to
3168 handle .stab.N, etc. */
3169 len
= strlen (sought
->section_name
);
3171 /* If the prefix matches, and the files section name ends with a
3172 nul or a digit, then we match. I.e., we want either an exact
3173 match or a section followed by a number. */
3174 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
3175 && (section
->name
[len
] == 0
3176 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
3179 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
3180 &stabstr_size
, NULL
);
3184 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
, NULL
);
3186 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
3192 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
3194 stab_section_names s
;
3196 s
.section_name
= stabsect_name
;
3197 s
.string_section_name
= strsect_name
;
3198 s
.string_offset
= 0;
3200 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
3206 /* Dump the any sections containing stabs debugging information. */
3209 dump_stabs (bfd
*abfd
)
3211 dump_stabs_section (abfd
, ".stab", ".stabstr");
3212 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
3213 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
3216 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3218 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3222 dump_bfd_header (bfd
*abfd
)
3226 printf (_("architecture: %s, "),
3227 bfd_printable_arch_mach (bfd_get_arch (abfd
),
3228 bfd_get_mach (abfd
)));
3229 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
3231 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
3232 PF (HAS_RELOC
, "HAS_RELOC");
3233 PF (EXEC_P
, "EXEC_P");
3234 PF (HAS_LINENO
, "HAS_LINENO");
3235 PF (HAS_DEBUG
, "HAS_DEBUG");
3236 PF (HAS_SYMS
, "HAS_SYMS");
3237 PF (HAS_LOCALS
, "HAS_LOCALS");
3238 PF (DYNAMIC
, "DYNAMIC");
3239 PF (WP_TEXT
, "WP_TEXT");
3240 PF (D_PAGED
, "D_PAGED");
3241 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
3242 printf (_("\nstart address 0x"));
3243 bfd_printf_vma (abfd
, abfd
->start_address
);
3248 /* Formatting callback function passed to ctf_dump. Returns either the pointer
3249 it is passed, or a pointer to newly-allocated storage, in which case
3250 dump_ctf() will free it when it no longer needs it. */
3253 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
3256 const char *blanks
= arg
;
3259 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
3264 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
3266 make_ctfsect (const char *name
, bfd_byte
*data
,
3271 ctfsect
.cts_name
= name
;
3272 ctfsect
.cts_entsize
= 1;
3273 ctfsect
.cts_size
= size
;
3274 ctfsect
.cts_data
= data
;
3279 /* Dump one CTF archive member. */
3282 dump_ctf_archive_member (ctf_file_t
*ctf
, const char *name
, void *arg
)
3284 ctf_file_t
*parent
= (ctf_file_t
*) arg
;
3285 const char *things
[] = {"Labels", "Data objects", "Function objects",
3286 "Variables", "Types", "Strings", ""};
3290 /* Only print out the name of non-default-named archive members.
3291 The name .ctf appears everywhere, even for things that aren't
3292 really archives, so printing it out is liable to be confusing. */
3293 if (strcmp (name
, ".ctf") != 0)
3294 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name
));
3296 ctf_import (ctf
, parent
);
3297 for (i
= 1, thing
= things
; *thing
[0]; thing
++, i
++)
3299 ctf_dump_state_t
*s
= NULL
;
3302 printf ("\n %s:\n", *thing
);
3303 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
3304 (void *) " ")) != NULL
)
3306 printf ("%s\n", item
);
3310 if (ctf_errno (ctf
))
3312 non_fatal (_("Iteration failed: %s, %s\n"), *thing
,
3313 ctf_errmsg (ctf_errno (ctf
)));
3320 /* Dump the CTF debugging information. */
3323 dump_ctf (bfd
*abfd
, const char *sect_name
, const char *parent_name
)
3325 ctf_archive_t
*ctfa
, *parenta
= NULL
;
3326 bfd_byte
*ctfdata
, *parentdata
= NULL
;
3327 bfd_size_type ctfsize
, parentsize
;
3329 ctf_file_t
*parent
= NULL
;
3332 if ((ctfdata
= read_section_stabs (abfd
, sect_name
, &ctfsize
, NULL
)) == NULL
)
3333 bfd_fatal (bfd_get_filename (abfd
));
3336 && (parentdata
= read_section_stabs (abfd
, parent_name
, &parentsize
,
3338 bfd_fatal (bfd_get_filename (abfd
));
3340 /* Load the CTF file and dump it. */
3342 ctfsect
= make_ctfsect (sect_name
, ctfdata
, ctfsize
);
3343 if ((ctfa
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
3345 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3346 bfd_fatal (bfd_get_filename (abfd
));
3351 ctfsect
= make_ctfsect (parent_name
, parentdata
, parentsize
);
3352 if ((parenta
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
3354 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3355 bfd_fatal (bfd_get_filename (abfd
));
3358 /* Assume that the applicable parent archive member is the default one.
3359 (This is what all known implementations are expected to do, if they
3360 put CTFs and their parents in archives together.) */
3361 if ((parent
= ctf_arc_open_by_name (parenta
, NULL
, &err
)) == NULL
)
3363 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3364 bfd_fatal (bfd_get_filename (abfd
));
3368 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name
));
3370 ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
);
3371 ctf_file_close (parent
);
3373 ctf_close (parenta
);
3380 dump_bfd_private_header (bfd
*abfd
)
3382 if (!bfd_print_private_bfd_data (abfd
, stdout
))
3383 non_fatal (_("warning: private headers incomplete: %s"),
3384 bfd_errmsg (bfd_get_error ()));
3388 dump_target_specific (bfd
*abfd
)
3390 const struct objdump_private_desc
* const *desc
;
3391 struct objdump_private_option
*opt
;
3394 /* Find the desc. */
3395 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
3396 if ((*desc
)->filter (abfd
))
3401 non_fatal (_("option -P/--private not supported by this file"));
3405 /* Clear all options. */
3406 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3407 opt
->selected
= FALSE
;
3409 /* Decode options. */
3410 b
= dump_private_options
;
3413 e
= strchr (b
, ',');
3418 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3419 if (strcmp (opt
->name
, b
) == 0)
3421 opt
->selected
= TRUE
;
3424 if (opt
->name
== NULL
)
3425 non_fatal (_("target specific dump '%s' not supported"), b
);
3436 (*desc
)->dump (abfd
);
3439 /* Display a section in hexadecimal format with associated characters.
3440 Each line prefixed by the zero padded address. */
3443 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
3445 bfd_byte
*data
= NULL
;
3446 bfd_size_type datasize
;
3447 bfd_vma addr_offset
;
3448 bfd_vma start_offset
;
3449 bfd_vma stop_offset
;
3450 unsigned int opb
= bfd_octets_per_byte (abfd
);
3451 /* Bytes per line. */
3452 const int onaline
= 16;
3457 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
3460 if (! process_section_p (section
))
3463 if ((datasize
= bfd_section_size (section
)) == 0)
3466 /* Compute the address range to display. */
3467 if (start_address
== (bfd_vma
) -1
3468 || start_address
< section
->vma
)
3471 start_offset
= start_address
- section
->vma
;
3473 if (stop_address
== (bfd_vma
) -1)
3474 stop_offset
= datasize
/ opb
;
3477 if (stop_address
< section
->vma
)
3480 stop_offset
= stop_address
- section
->vma
;
3482 if (stop_offset
> datasize
/ opb
)
3483 stop_offset
= datasize
/ opb
;
3486 if (start_offset
>= stop_offset
)
3489 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
3490 if (display_file_offsets
)
3491 printf (_(" (Starting at file offset: 0x%lx)"),
3492 (unsigned long) (section
->filepos
+ start_offset
));
3495 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
3497 non_fatal (_("Reading section %s failed because: %s"),
3498 section
->name
, bfd_errmsg (bfd_get_error ()));
3504 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
3505 if (strlen (buf
) >= sizeof (buf
))
3509 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3511 count
= strlen (buf
) - count
;
3515 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
3516 if (strlen (buf
) >= sizeof (buf
))
3520 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3522 count
= strlen (buf
) - count
;
3526 for (addr_offset
= start_offset
;
3527 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
3531 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
3532 count
= strlen (buf
);
3533 if ((size_t) count
>= sizeof (buf
))
3537 while (count
< width
)
3542 fputs (buf
+ count
- width
, stdout
);
3545 for (j
= addr_offset
* opb
;
3546 j
< addr_offset
* opb
+ onaline
; j
++)
3548 if (j
< stop_offset
* opb
)
3549 printf ("%02x", (unsigned) (data
[j
]));
3557 for (j
= addr_offset
* opb
;
3558 j
< addr_offset
* opb
+ onaline
; j
++)
3560 if (j
>= stop_offset
* opb
)
3563 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
3570 /* Actually display the various requested regions. */
3573 dump_data (bfd
*abfd
)
3575 bfd_map_over_sections (abfd
, dump_section
, NULL
);
3578 /* Should perhaps share code and display with nm? */
3581 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
3590 max_count
= dynsymcount
;
3591 printf ("DYNAMIC SYMBOL TABLE:\n");
3596 max_count
= symcount
;
3597 printf ("SYMBOL TABLE:\n");
3601 printf (_("no symbols\n"));
3603 for (count
= 0; count
< max_count
; count
++)
3607 if (*current
== NULL
)
3608 printf (_("no information for symbol number %ld\n"), count
);
3610 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
3611 printf (_("could not determine the type of symbol number %ld\n"),
3614 else if (process_section_p ((* current
)->section
)
3615 && (dump_special_syms
3616 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
3618 const char *name
= (*current
)->name
;
3620 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
3624 /* If we want to demangle the name, we demangle it
3625 here, and temporarily clobber it while calling
3626 bfd_print_symbol. FIXME: This is a gross hack. */
3627 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
3629 (*current
)->name
= alloc
;
3630 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3631 bfd_print_symbol_all
);
3634 (*current
)->name
= name
;
3639 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3640 bfd_print_symbol_all
);
3650 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
3653 char *last_filename
, *last_functionname
;
3654 unsigned int last_line
;
3655 unsigned int last_discriminator
;
3657 /* Get column headers lined up reasonably. */
3665 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
3666 width
= strlen (buf
) - 7;
3668 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
3671 last_filename
= NULL
;
3672 last_functionname
= NULL
;
3674 last_discriminator
= 0;
3676 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
3679 const char *filename
, *functionname
;
3680 unsigned int linenumber
;
3681 unsigned int discriminator
;
3682 const char *sym_name
;
3683 const char *section_name
;
3684 bfd_vma addend2
= 0;
3686 if (start_address
!= (bfd_vma
) -1
3687 && q
->address
< start_address
)
3689 if (stop_address
!= (bfd_vma
) -1
3690 && q
->address
> stop_address
)
3693 if (with_line_numbers
3695 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
3696 &filename
, &functionname
,
3697 &linenumber
, &discriminator
))
3699 if (functionname
!= NULL
3700 && (last_functionname
== NULL
3701 || strcmp (functionname
, last_functionname
) != 0))
3703 printf ("%s():\n", sanitize_string (functionname
));
3704 if (last_functionname
!= NULL
)
3705 free (last_functionname
);
3706 last_functionname
= xstrdup (functionname
);
3710 && (linenumber
!= last_line
3711 || (filename
!= NULL
3712 && last_filename
!= NULL
3713 && filename_cmp (filename
, last_filename
) != 0)
3714 || (discriminator
!= last_discriminator
)))
3716 if (discriminator
> 0)
3717 printf ("%s:%u\n", filename
== NULL
? "???" :
3718 sanitize_string (filename
), linenumber
);
3720 printf ("%s:%u (discriminator %u)\n",
3721 filename
== NULL
? "???" : sanitize_string (filename
),
3722 linenumber
, discriminator
);
3723 last_line
= linenumber
;
3724 last_discriminator
= discriminator
;
3725 if (last_filename
!= NULL
)
3726 free (last_filename
);
3727 if (filename
== NULL
)
3728 last_filename
= NULL
;
3730 last_filename
= xstrdup (filename
);
3734 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
3736 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
3737 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
3742 section_name
= NULL
;
3745 bfd_printf_vma (abfd
, q
->address
);
3746 if (q
->howto
== NULL
)
3747 printf (" *unknown* ");
3748 else if (q
->howto
->name
)
3750 const char *name
= q
->howto
->name
;
3752 /* R_SPARC_OLO10 relocations contain two addends.
3753 But because 'arelent' lacks enough storage to
3754 store them both, the 64-bit ELF Sparc backend
3755 records this as two relocations. One R_SPARC_LO10
3756 and one R_SPARC_13, both pointing to the same
3757 address. This is merely so that we have some
3758 place to store both addend fields.
3760 Undo this transformation, otherwise the output
3761 will be confusing. */
3762 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3763 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3765 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3767 arelent
*q2
= *(p
+ 1);
3770 && q
->address
== q2
->address
3771 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3773 name
= "R_SPARC_OLO10";
3774 addend2
= q2
->addend
;
3778 printf (" %-16s ", name
);
3781 printf (" %-16d ", q
->howto
->type
);
3785 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3789 if (section_name
== NULL
)
3790 section_name
= "*unknown*";
3791 printf ("[%s]", sanitize_string (section_name
));
3796 bfd_signed_vma addend
= q
->addend
;
3804 bfd_printf_vma (abfd
, addend
);
3809 bfd_printf_vma (abfd
, addend2
);
3815 if (last_filename
!= NULL
)
3816 free (last_filename
);
3817 if (last_functionname
!= NULL
)
3818 free (last_functionname
);
3822 dump_relocs_in_section (bfd
*abfd
,
3824 void *dummy ATTRIBUTE_UNUSED
)
3826 arelent
**relpp
= NULL
;
3830 if ( bfd_is_abs_section (section
)
3831 || bfd_is_und_section (section
)
3832 || bfd_is_com_section (section
)
3833 || (! process_section_p (section
))
3834 || ((section
->flags
& SEC_RELOC
) == 0))
3837 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
3839 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3842 printf (" (none)\n\n");
3850 relpp
= (arelent
**) xmalloc (relsize
);
3851 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3857 non_fatal (_("failed to read relocs in: %s"),
3858 sanitize_string (bfd_get_filename (abfd
)));
3859 bfd_fatal (_("error message was"));
3861 else if (relcount
== 0)
3862 printf (" (none)\n\n");
3866 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3873 dump_relocs (bfd
*abfd
)
3875 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3879 dump_dynamic_relocs (bfd
*abfd
)
3885 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3887 bfd_fatal (bfd_get_filename (abfd
));
3889 printf ("DYNAMIC RELOCATION RECORDS");
3892 printf (" (none)\n\n");
3895 relpp
= (arelent
**) xmalloc (relsize
);
3896 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3899 bfd_fatal (bfd_get_filename (abfd
));
3900 else if (relcount
== 0)
3901 printf (" (none)\n\n");
3905 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3912 /* Creates a table of paths, to search for source files. */
3915 add_include_path (const char *path
)
3919 include_path_count
++;
3920 include_paths
= (const char **)
3921 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3922 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3923 if (path
[1] == ':' && path
[2] == 0)
3924 path
= concat (path
, ".", (const char *) 0);
3926 include_paths
[include_path_count
- 1] = path
;
3930 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3934 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3936 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3937 section
->vma
+= adjust_section_vma
;
3939 section
->lma
+= adjust_section_vma
;
3943 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
3946 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
3951 mask
= (bfd_vma
) 1 << (arch_size
- 1);
3952 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
3955 /* Dump selected contents of ABFD. */
3958 dump_bfd (bfd
*abfd
, bfd_boolean is_mainfile
)
3960 const struct elf_backend_data
* bed
;
3962 if (bfd_big_endian (abfd
))
3963 byte_get
= byte_get_big_endian
;
3964 else if (bfd_little_endian (abfd
))
3965 byte_get
= byte_get_little_endian
;
3969 /* Load any separate debug information files.
3970 We do this now and without checking do_follow_links because separate
3971 debug info files may contain symbol tables that we will need when
3972 displaying information about the main file. Any memory allocated by
3973 load_separate_debug_files will be released when we call
3974 free_debug_memory below.
3976 The test on is_mainfile is there because the chain of separate debug
3977 info files is a global variable shared by all invocations of dump_bfd. */
3980 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
3982 /* If asked to do so, recursively dump the separate files. */
3983 if (do_follow_links
)
3987 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3988 dump_bfd (i
->handle
, FALSE
);
3992 /* Adjust user-specified start and stop limits for targets that use
3993 signed addresses. */
3994 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3995 && (bed
= get_elf_backend_data (abfd
)) != NULL
3996 && bed
->sign_extend_vma
)
3998 start_address
= sign_extend_address (abfd
, start_address
,
4000 stop_address
= sign_extend_address (abfd
, stop_address
,
4004 /* If we are adjusting section VMA's, change them all now. Changing
4005 the BFD information is a hack. However, we must do it, or
4006 bfd_find_nearest_line will not do the right thing. */
4007 if (adjust_section_vma
!= 0)
4009 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
4010 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
4013 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4014 printf (_("\n%s: file format %s\n"),
4015 sanitize_string (bfd_get_filename (abfd
)),
4018 print_arelt_descr (stdout
, abfd
, TRUE
, FALSE
);
4019 if (dump_file_header
)
4020 dump_bfd_header (abfd
);
4021 if (dump_private_headers
)
4022 dump_bfd_private_header (abfd
);
4023 if (dump_private_options
!= NULL
)
4024 dump_target_specific (abfd
);
4025 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4032 || dump_dwarf_section_info
)
4034 syms
= slurp_symtab (abfd
);
4036 /* If following links, load any symbol tables from the linked files as well. */
4037 if (do_follow_links
&& is_mainfile
)
4041 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4043 asymbol
** extra_syms
;
4044 long old_symcount
= symcount
;
4046 extra_syms
= slurp_symtab (i
->handle
);
4050 if (old_symcount
== 0)
4056 syms
= xrealloc (syms
, (symcount
+ old_symcount
) * sizeof (asymbol
*));
4057 memcpy (syms
+ old_symcount
,
4059 symcount
* sizeof (asymbol
*));
4063 symcount
+= old_symcount
;
4068 if (dump_section_headers
)
4069 dump_headers (abfd
);
4071 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
4072 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
4073 dynsyms
= slurp_dynamic_symtab (abfd
);
4077 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
4078 dynsymcount
, dynsyms
, &synthsyms
);
4084 dump_symbols (abfd
, FALSE
);
4085 if (dump_dynamic_symtab
)
4086 dump_symbols (abfd
, TRUE
);
4087 if (dump_dwarf_section_info
)
4089 if (dump_ctf_section_info
)
4090 dump_ctf (abfd
, dump_ctf_section_name
, dump_ctf_parent_name
);
4091 if (dump_stab_section_info
)
4093 if (dump_reloc_info
&& ! disassemble
)
4095 if (dump_dynamic_reloc_info
&& ! disassemble
)
4096 dump_dynamic_relocs (abfd
);
4097 if (dump_section_contents
)
4100 disassemble_data (abfd
);
4106 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
4107 if (dhandle
!= NULL
)
4109 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
4111 dump_debugging_tags
? TRUE
: FALSE
))
4113 non_fatal (_("%s: printing debugging information failed"),
4114 bfd_get_filename (abfd
));
4120 /* PR 6483: If there was no STABS debug info in the file, try
4122 else if (! dump_dwarf_section_info
)
4124 dwarf_select_sections_all ();
4152 free_debug_memory ();
4156 display_object_bfd (bfd
*abfd
)
4160 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
4162 dump_bfd (abfd
, TRUE
);
4166 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4168 nonfatal (bfd_get_filename (abfd
));
4169 list_matching_formats (matching
);
4174 if (bfd_get_error () != bfd_error_file_not_recognized
)
4176 nonfatal (bfd_get_filename (abfd
));
4180 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
4182 dump_bfd (abfd
, TRUE
);
4186 nonfatal (bfd_get_filename (abfd
));
4188 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4190 list_matching_formats (matching
);
4196 display_any_bfd (bfd
*file
, int level
)
4198 /* Decompress sections unless dumping the section contents. */
4199 if (!dump_section_contents
)
4200 file
->flags
|= BFD_DECOMPRESS
;
4202 /* If the file is an archive, process all of its elements. */
4203 if (bfd_check_format (file
, bfd_archive
))
4206 bfd
*last_arfile
= NULL
;
4209 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
4210 else if (level
> 100)
4212 /* Prevent corrupted files from spinning us into an
4213 infinite loop. 100 is an arbitrary heuristic. */
4214 fatal (_("Archive nesting is too deep"));
4218 printf (_("In nested archive %s:\n"),
4219 sanitize_string (bfd_get_filename (file
)));
4223 bfd_set_error (bfd_error_no_error
);
4225 arfile
= bfd_openr_next_archived_file (file
, arfile
);
4228 if (bfd_get_error () != bfd_error_no_more_archived_files
)
4229 nonfatal (bfd_get_filename (file
));
4233 display_any_bfd (arfile
, level
+ 1);
4235 if (last_arfile
!= NULL
)
4237 bfd_close (last_arfile
);
4238 /* PR 17512: file: ac585d01. */
4239 if (arfile
== last_arfile
)
4245 last_arfile
= arfile
;
4248 if (last_arfile
!= NULL
)
4249 bfd_close (last_arfile
);
4252 display_object_bfd (file
);
4256 display_file (char *filename
, char *target
, bfd_boolean last_file
)
4260 if (get_file_size (filename
) < 1)
4266 file
= bfd_openr (filename
, target
);
4269 nonfatal (filename
);
4273 display_any_bfd (file
, 0);
4275 /* This is an optimization to improve the speed of objdump, especially when
4276 dumping a file with lots of associated debug informatiom. Calling
4277 bfd_close on such a file can take a non-trivial amount of time as there
4278 are lots of lists to walk and buffers to free. This is only really
4279 necessary however if we are about to load another file and we need the
4280 memory back. Otherwise, if we are about to exit, then we can save (a lot
4281 of) time by only doing a quick close, and allowing the OS to reclaim the
4286 bfd_close_all_done (file
);
4290 main (int argc
, char **argv
)
4293 char *target
= default_target
;
4294 bfd_boolean seenflag
= FALSE
;
4296 #if defined (HAVE_SETLOCALE)
4297 #if defined (HAVE_LC_MESSAGES)
4298 setlocale (LC_MESSAGES
, "");
4300 setlocale (LC_CTYPE
, "");
4303 bindtextdomain (PACKAGE
, LOCALEDIR
);
4304 textdomain (PACKAGE
);
4306 program_name
= *argv
;
4307 xmalloc_set_program_name (program_name
);
4308 bfd_set_error_program_name (program_name
);
4310 START_PROGRESS (program_name
, 0);
4312 expandargv (&argc
, &argv
);
4314 if (bfd_init () != BFD_INIT_MAGIC
)
4315 fatal (_("fatal error: libbfd ABI mismatch"));
4316 set_default_bfd_target ();
4318 while ((c
= getopt_long (argc
, argv
,
4319 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
4320 long_options
, (int *) 0))
4326 break; /* We've been given a long option. */
4333 if (disassembler_options
)
4334 /* Ignore potential memory leak for now. */
4335 options
= concat (disassembler_options
, ",",
4336 optarg
, (const char *) NULL
);
4339 disassembler_options
= remove_whitespace_and_extra_commas (options
);
4346 display_file_offsets
= TRUE
;
4349 with_line_numbers
= TRUE
;
4358 enum demangling_styles style
;
4360 style
= cplus_demangle_name_to_style (optarg
);
4361 if (style
== unknown_demangling
)
4362 fatal (_("unknown demangling style `%s'"),
4365 cplus_demangle_set_style (style
);
4368 case OPTION_RECURSE_LIMIT
:
4369 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
4371 case OPTION_NO_RECURSE_LIMIT
:
4372 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
4375 do_wide
= wide_output
= TRUE
;
4377 case OPTION_ADJUST_VMA
:
4378 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
4380 case OPTION_START_ADDRESS
:
4381 start_address
= parse_vma (optarg
, "--start-address");
4382 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4383 fatal (_("error: the start address should be before the end address"));
4385 case OPTION_STOP_ADDRESS
:
4386 stop_address
= parse_vma (optarg
, "--stop-address");
4387 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4388 fatal (_("error: the stop address should be after the start address"));
4392 prefix_length
= strlen (prefix
);
4393 /* Remove an unnecessary trailing '/' */
4394 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
4397 case OPTION_PREFIX_STRIP
:
4398 prefix_strip
= atoi (optarg
);
4399 if (prefix_strip
< 0)
4400 fatal (_("error: prefix strip must be non-negative"));
4402 case OPTION_INSN_WIDTH
:
4403 insn_width
= strtoul (optarg
, NULL
, 0);
4404 if (insn_width
<= 0)
4405 fatal (_("error: instruction width must be positive"));
4407 case OPTION_INLINES
:
4408 unwind_inlines
= TRUE
;
4411 if (strcmp (optarg
, "B") == 0)
4412 endian
= BFD_ENDIAN_BIG
;
4413 else if (strcmp (optarg
, "L") == 0)
4414 endian
= BFD_ENDIAN_LITTLE
;
4417 nonfatal (_("unrecognized -E option"));
4422 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
4423 endian
= BFD_ENDIAN_BIG
;
4424 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
4425 endian
= BFD_ENDIAN_LITTLE
;
4428 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
4435 dump_file_header
= TRUE
;
4439 formats_info
= TRUE
;
4443 add_include_path (optarg
);
4446 dump_private_headers
= TRUE
;
4450 dump_private_options
= optarg
;
4454 dump_private_headers
= TRUE
;
4456 dump_reloc_info
= TRUE
;
4457 dump_file_header
= TRUE
;
4458 dump_ar_hdrs
= TRUE
;
4459 dump_section_headers
= TRUE
;
4467 dump_dynamic_symtab
= TRUE
;
4473 disasm_sym
= optarg
;
4476 disassemble_zeroes
= TRUE
;
4480 disassemble_all
= TRUE
;
4485 with_source_code
= TRUE
;
4488 case OPTION_SOURCE_COMMENT
:
4490 with_source_code
= TRUE
;
4493 source_comment
= xstrdup (sanitize_string (optarg
));
4495 source_comment
= xstrdup ("# ");
4503 dump_debugging_tags
= 1;
4508 dump_dwarf_section_info
= TRUE
;
4511 dwarf_select_sections_by_letters (optarg
);
4513 dwarf_select_sections_all ();
4516 dump_dwarf_section_info
= TRUE
;
4519 dwarf_select_sections_by_names (optarg
);
4521 dwarf_select_sections_all ();
4523 case OPTION_DWARF_DEPTH
:
4526 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4529 case OPTION_DWARF_START
:
4532 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4533 suppress_bfd_header
= 1;
4536 case OPTION_DWARF_CHECK
:
4540 dump_ctf_section_info
= TRUE
;
4541 dump_ctf_section_name
= xstrdup (optarg
);
4544 case OPTION_CTF_PARENT
:
4545 dump_ctf_parent_name
= xstrdup (optarg
);
4548 dump_stab_section_info
= TRUE
;
4552 dump_section_contents
= TRUE
;
4556 dump_reloc_info
= TRUE
;
4560 dump_dynamic_reloc_info
= TRUE
;
4564 dump_ar_hdrs
= TRUE
;
4568 dump_section_headers
= TRUE
;
4573 show_version
= TRUE
;
4579 /* No need to set seenflag or to break - usage() does not return. */
4586 print_version ("objdump");
4592 exit_status
= display_info ();
4596 display_file ("a.out", target
, TRUE
);
4598 for (; optind
< argc
;)
4600 display_file (argv
[optind
], target
, optind
== argc
- 1);
4606 free (dump_ctf_section_name
);
4607 free (dump_ctf_parent_name
);
4608 free ((void *) source_comment
);
4610 END_PROGRESS (program_name
);