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
150 bfd_boolean require_sec
;
151 arelent
** dynrelbuf
;
153 disassembler_ftype disassemble_fn
;
158 /* Architecture to disassemble for, or default if NULL. */
159 static char *machine
= NULL
;
161 /* Target specific options to the disassembler. */
162 static char *disassembler_options
= NULL
;
164 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
165 static enum bfd_endian endian
= BFD_ENDIAN_UNKNOWN
;
167 /* The symbol table. */
168 static asymbol
**syms
;
170 /* Number of symbols in `syms'. */
171 static long symcount
= 0;
173 /* The sorted symbol table. */
174 static asymbol
**sorted_syms
;
176 /* Number of symbols in `sorted_syms'. */
177 static long sorted_symcount
= 0;
179 /* The dynamic symbol table. */
180 static asymbol
**dynsyms
;
182 /* The synthetic symbol table. */
183 static asymbol
*synthsyms
;
184 static long synthcount
= 0;
186 /* Number of symbols in `dynsyms'. */
187 static long dynsymcount
= 0;
189 static bfd_byte
*stabs
;
190 static bfd_size_type stab_size
;
192 static bfd_byte
*strtab
;
193 static bfd_size_type stabstr_size
;
195 /* Handlers for -P/--private. */
196 static const struct objdump_private_desc
* const objdump_private_vectors
[] =
198 OBJDUMP_PRIVATE_VECTORS
202 static void usage (FILE *, int) ATTRIBUTE_NORETURN
;
204 usage (FILE *stream
, int status
)
206 fprintf (stream
, _("Usage: %s <option(s)> <file(s)>\n"), program_name
);
207 fprintf (stream
, _(" Display information from object <file(s)>.\n"));
208 fprintf (stream
, _(" At least one of the following switches must be given:\n"));
209 fprintf (stream
, _("\
210 -a, --archive-headers Display archive header information\n\
211 -f, --file-headers Display the contents of the overall file header\n\
212 -p, --private-headers Display object format specific file header contents\n\
213 -P, --private=OPT,OPT... Display object format specific contents\n\
214 -h, --[section-]headers Display the contents of the section headers\n\
215 -x, --all-headers Display the contents of all headers\n\
216 -d, --disassemble Display assembler contents of executable sections\n\
217 -D, --disassemble-all Display assembler contents of all sections\n\
218 --disassemble=<sym> Display assembler contents from <sym>\n\
219 -S, --source Intermix source code with disassembly\n\
220 --source-comment[=<txt>] Prefix lines of source code with <txt>\n\
221 -s, --full-contents Display the full contents of all sections requested\n\
222 -g, --debugging Display debug information in object file\n\
223 -e, --debugging-tags Display debug information using ctags style\n\
224 -G, --stabs Display (in raw form) any STABS info in the file\n\
225 -W[lLiaprmfFsoRtUuTgAckK] or\n\
226 --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
227 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
228 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
229 =addr,=cu_index,=links,=follow-links]\n\
230 Display DWARF info in the file\n\
231 --ctf=SECTION Display CTF info from SECTION\n\
232 -t, --syms Display the contents of the symbol table(s)\n\
233 -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
234 -r, --reloc Display the relocation entries in the file\n\
235 -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
236 @<file> Read options from <file>\n\
237 -v, --version Display this program's version number\n\
238 -i, --info List object formats and architectures supported\n\
239 -H, --help Display this information\n\
243 const struct objdump_private_desc
* const *desc
;
245 fprintf (stream
, _("\n The following switches are optional:\n"));
246 fprintf (stream
, _("\
247 -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
248 -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
249 -j, --section=NAME Only display information for section NAME\n\
250 -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
251 -EB --endian=big Assume big endian format when disassembling\n\
252 -EL --endian=little Assume little endian format when disassembling\n\
253 --file-start-context Include context from start of file (with -S)\n\
254 -I, --include=DIR Add DIR to search list for source files\n\
255 -l, --line-numbers Include line numbers and filenames in output\n\
256 -F, --file-offsets Include file offsets when displaying information\n\
257 -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
258 The STYLE, if specified, can be `auto', `gnu',\n\
259 `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
261 --recurse-limit Enable a limit on recursion whilst demangling. [Default]\n\
262 --no-recurse-limit Disable a limit on recursion whilst demangling\n\
263 -w, --wide Format output for more than 80 columns\n\
264 -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
265 --start-address=ADDR Only process data whose address is >= ADDR\n\
266 --stop-address=ADDR Only process data whose address is < ADDR\n\
267 --prefix-addresses Print complete address alongside disassembly\n\
268 --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
269 --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
270 --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
271 --special-syms Include special symbols in symbol dumps\n\
272 --inlines Print all inlines for source line (with -l)\n\
273 --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
274 --prefix-strip=LEVEL Strip initial directory names for -S\n"));
275 fprintf (stream
, _("\
276 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
277 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
279 --dwarf-check Make additional dwarf internal consistency checks.\
281 --ctf-parent=SECTION Use SECTION as the CTF parent\n\n"));
282 list_supported_targets (program_name
, stream
);
283 list_supported_architectures (program_name
, stream
);
285 disassembler_usage (stream
);
287 if (objdump_private_vectors
[0] != NULL
)
290 _("\nOptions supported for -P/--private switch:\n"));
291 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
292 (*desc
)->help (stream
);
295 if (REPORT_BUGS_TO
[0] && status
== 0)
296 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
300 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
304 OPTION_START_ADDRESS
,
314 OPTION_RECURSE_LIMIT
,
315 OPTION_NO_RECURSE_LIMIT
,
317 OPTION_SOURCE_COMMENT
,
322 static struct option long_options
[]=
324 {"adjust-vma", required_argument
, NULL
, OPTION_ADJUST_VMA
},
325 {"all-headers", no_argument
, NULL
, 'x'},
326 {"private-headers", no_argument
, NULL
, 'p'},
327 {"private", required_argument
, NULL
, 'P'},
328 {"architecture", required_argument
, NULL
, 'm'},
329 {"archive-headers", no_argument
, NULL
, 'a'},
330 {"debugging", no_argument
, NULL
, 'g'},
331 {"debugging-tags", no_argument
, NULL
, 'e'},
332 {"demangle", optional_argument
, NULL
, 'C'},
333 {"disassemble", optional_argument
, NULL
, 'd'},
334 {"disassemble-all", no_argument
, NULL
, 'D'},
335 {"disassembler-options", required_argument
, NULL
, 'M'},
336 {"disassemble-zeroes", no_argument
, NULL
, 'z'},
337 {"dynamic-reloc", no_argument
, NULL
, 'R'},
338 {"dynamic-syms", no_argument
, NULL
, 'T'},
339 {"endian", required_argument
, NULL
, OPTION_ENDIAN
},
340 {"file-headers", no_argument
, NULL
, 'f'},
341 {"file-offsets", no_argument
, NULL
, 'F'},
342 {"file-start-context", no_argument
, &file_start_context
, 1},
343 {"full-contents", no_argument
, NULL
, 's'},
344 {"headers", no_argument
, NULL
, 'h'},
345 {"help", no_argument
, NULL
, 'H'},
346 {"info", no_argument
, NULL
, 'i'},
347 {"line-numbers", no_argument
, NULL
, 'l'},
348 {"no-show-raw-insn", no_argument
, &show_raw_insn
, -1},
349 {"prefix-addresses", no_argument
, &prefix_addresses
, 1},
350 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
351 {"recursion-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
352 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
353 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
354 {"reloc", no_argument
, NULL
, 'r'},
355 {"section", required_argument
, NULL
, 'j'},
356 {"section-headers", no_argument
, NULL
, 'h'},
357 {"show-raw-insn", no_argument
, &show_raw_insn
, 1},
358 {"source", no_argument
, NULL
, 'S'},
359 {"source-comment", optional_argument
, NULL
, OPTION_SOURCE_COMMENT
},
360 {"special-syms", no_argument
, &dump_special_syms
, 1},
361 {"include", required_argument
, NULL
, 'I'},
362 {"dwarf", optional_argument
, NULL
, OPTION_DWARF
},
363 {"ctf", required_argument
, NULL
, OPTION_CTF
},
364 {"ctf-parent", required_argument
, NULL
, OPTION_CTF_PARENT
},
365 {"stabs", no_argument
, NULL
, 'G'},
366 {"start-address", required_argument
, NULL
, OPTION_START_ADDRESS
},
367 {"stop-address", required_argument
, NULL
, OPTION_STOP_ADDRESS
},
368 {"syms", no_argument
, NULL
, 't'},
369 {"target", required_argument
, NULL
, 'b'},
370 {"version", no_argument
, NULL
, 'V'},
371 {"wide", no_argument
, NULL
, 'w'},
372 {"prefix", required_argument
, NULL
, OPTION_PREFIX
},
373 {"prefix-strip", required_argument
, NULL
, OPTION_PREFIX_STRIP
},
374 {"insn-width", required_argument
, NULL
, OPTION_INSN_WIDTH
},
375 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
376 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
377 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
378 {"inlines", no_argument
, 0, OPTION_INLINES
},
379 {0, no_argument
, 0, 0}
383 nonfatal (const char *msg
)
389 /* Returns a version of IN with any control characters
390 replaced by escape sequences. Uses a static buffer
394 sanitize_string (const char * in
)
396 static char * buffer
= NULL
;
397 static size_t buffer_len
= 0;
398 const char * original
= in
;
405 /* See if any conversion is necessary. In the majority
406 of cases it will not be needed. */
419 /* Copy the input, translating as needed. */
421 if (buffer_len
< (strlen (in
) * 2))
423 free ((void *) buffer
);
424 buffer_len
= strlen (in
) * 2;
425 buffer
= xmalloc (buffer_len
+ 1);
451 /* Returns TRUE if the specified section should be dumped. */
454 process_section_p (asection
* section
)
458 if (only_list
== NULL
)
461 for (only
= only_list
; only
; only
= only
->next
)
462 if (strcmp (only
->name
, section
->name
) == 0)
471 /* Add an entry to the 'only' list. */
474 add_only (char * name
)
478 /* First check to make sure that we do not
479 already have an entry for this name. */
480 for (only
= only_list
; only
; only
= only
->next
)
481 if (strcmp (only
->name
, name
) == 0)
484 only
= xmalloc (sizeof * only
);
487 only
->next
= only_list
;
491 /* Release the memory used by the 'only' list.
492 PR 11225: Issue a warning message for unseen sections.
493 Only do this if none of the sections were seen. This is mainly to support
494 tools like the GAS testsuite where an object file is dumped with a list of
495 generic section names known to be present in a range of different file
499 free_only_list (void)
501 bfd_boolean at_least_one_seen
= FALSE
;
505 if (only_list
== NULL
)
508 for (only
= only_list
; only
; only
= only
->next
)
511 at_least_one_seen
= TRUE
;
515 for (only
= only_list
; only
; only
= next
)
517 if (! at_least_one_seen
)
519 non_fatal (_("section '%s' mentioned in a -j option, "
520 "but not found in any input file"),
531 dump_section_header (bfd
*abfd
, asection
*section
, void *data
)
534 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
535 int longest_section_name
= *((int *) data
);
537 /* Ignore linker created section. See elfNN_ia64_object_p in
539 if (section
->flags
& SEC_LINKER_CREATED
)
542 /* PR 10413: Skip sections that we are ignoring. */
543 if (! process_section_p (section
))
546 printf ("%3d %-*s %08lx ", section
->index
, longest_section_name
,
547 sanitize_string (bfd_section_name (section
)),
548 (unsigned long) bfd_section_size (section
) / opb
);
549 bfd_printf_vma (abfd
, bfd_section_vma (section
));
551 bfd_printf_vma (abfd
, section
->lma
);
552 printf (" %08lx 2**%u", (unsigned long) section
->filepos
,
553 bfd_section_alignment (section
));
559 if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
561 PF (SEC_HAS_CONTENTS
, "CONTENTS");
562 PF (SEC_ALLOC
, "ALLOC");
563 PF (SEC_CONSTRUCTOR
, "CONSTRUCTOR");
564 PF (SEC_LOAD
, "LOAD");
565 PF (SEC_RELOC
, "RELOC");
566 PF (SEC_READONLY
, "READONLY");
567 PF (SEC_CODE
, "CODE");
568 PF (SEC_DATA
, "DATA");
570 PF (SEC_DEBUGGING
, "DEBUGGING");
571 PF (SEC_NEVER_LOAD
, "NEVER_LOAD");
572 PF (SEC_EXCLUDE
, "EXCLUDE");
573 PF (SEC_SORT_ENTRIES
, "SORT_ENTRIES");
574 if (bfd_get_arch (abfd
) == bfd_arch_tic54x
)
576 PF (SEC_TIC54X_BLOCK
, "BLOCK");
577 PF (SEC_TIC54X_CLINK
, "CLINK");
579 PF (SEC_SMALL_DATA
, "SMALL_DATA");
580 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
582 PF (SEC_COFF_SHARED
, "SHARED");
583 PF (SEC_COFF_NOREAD
, "NOREAD");
585 else if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
587 PF (SEC_ELF_OCTETS
, "OCTETS");
588 PF (SEC_ELF_PURECODE
, "PURECODE");
590 PF (SEC_THREAD_LOCAL
, "THREAD_LOCAL");
591 PF (SEC_GROUP
, "GROUP");
592 if (bfd_get_arch (abfd
) == bfd_arch_mep
)
594 PF (SEC_MEP_VLIW
, "VLIW");
597 if ((section
->flags
& SEC_LINK_ONCE
) != 0)
600 struct coff_comdat_info
*comdat
;
602 switch (section
->flags
& SEC_LINK_DUPLICATES
)
606 case SEC_LINK_DUPLICATES_DISCARD
:
607 ls
= "LINK_ONCE_DISCARD";
609 case SEC_LINK_DUPLICATES_ONE_ONLY
:
610 ls
= "LINK_ONCE_ONE_ONLY";
612 case SEC_LINK_DUPLICATES_SAME_SIZE
:
613 ls
= "LINK_ONCE_SAME_SIZE";
615 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
616 ls
= "LINK_ONCE_SAME_CONTENTS";
619 printf ("%s%s", comma
, ls
);
621 comdat
= bfd_coff_get_comdat_section (abfd
, section
);
623 printf (" (COMDAT %s %ld)", comdat
->name
, comdat
->symbol
);
632 /* Called on each SECTION in ABFD, update the int variable pointed to by
633 DATA which contains the string length of the longest section name. */
636 find_longest_section_name (bfd
*abfd ATTRIBUTE_UNUSED
,
637 asection
*section
, void *data
)
639 int *longest_so_far
= (int *) data
;
643 /* Ignore linker created section. */
644 if (section
->flags
& SEC_LINKER_CREATED
)
647 /* Skip sections that we are ignoring. */
648 if (! process_section_p (section
))
651 name
= bfd_section_name (section
);
652 len
= (int) strlen (name
);
653 if (len
> *longest_so_far
)
654 *longest_so_far
= len
;
658 dump_headers (bfd
*abfd
)
660 /* The default width of 13 is just an arbitrary choice. */
661 int max_section_name_length
= 13;
667 /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
668 if (bfd_get_arch_size (abfd
) == 32)
674 printf (_("Sections:\n"));
677 bfd_map_over_sections (abfd
, find_longest_section_name
,
678 &max_section_name_length
);
680 printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
681 max_section_name_length
, "Name",
682 bfd_vma_width
, "VMA",
683 bfd_vma_width
, "LMA");
686 printf (_(" Flags"));
689 bfd_map_over_sections (abfd
, dump_section_header
,
690 &max_section_name_length
);
694 slurp_symtab (bfd
*abfd
)
699 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
705 storage
= bfd_get_symtab_upper_bound (abfd
);
708 non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd
));
709 bfd_fatal (_("error message was"));
713 off_t filesize
= bfd_get_file_size (abfd
);
717 && filesize
< storage
718 /* The MMO file format supports its own special compression
719 technique, so its sections can be larger than the file size. */
720 && bfd_get_flavour (abfd
) != bfd_target_mmo_flavour
)
722 bfd_nonfatal_message (bfd_get_filename (abfd
), abfd
, NULL
,
723 _("error: symbol table size (%#lx) is larger than filesize (%#lx)"),
724 storage
, (long) filesize
);
730 sy
= (asymbol
**) xmalloc (storage
);
733 symcount
= bfd_canonicalize_symtab (abfd
, sy
);
735 bfd_fatal (bfd_get_filename (abfd
));
739 /* Read in the dynamic symbols. */
742 slurp_dynamic_symtab (bfd
*abfd
)
747 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
750 if (!(bfd_get_file_flags (abfd
) & DYNAMIC
))
752 non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd
));
758 bfd_fatal (bfd_get_filename (abfd
));
761 sy
= (asymbol
**) xmalloc (storage
);
763 dynsymcount
= bfd_canonicalize_dynamic_symtab (abfd
, sy
);
765 bfd_fatal (bfd_get_filename (abfd
));
769 /* Some symbol names are significant and should be kept in the
770 table of sorted symbol names, even if they are marked as
771 debugging/section symbols. */
774 is_significant_symbol_name (const char * name
)
776 return strncmp (name
, ".plt", 4) == 0 || strcmp (name
, ".got") == 0;
779 /* Filter out (in place) symbols that are useless for disassembly.
780 COUNT is the number of elements in SYMBOLS.
781 Return the number of useful symbols. */
784 remove_useless_symbols (asymbol
**symbols
, long count
)
786 asymbol
**in_ptr
= symbols
, **out_ptr
= symbols
;
790 asymbol
*sym
= *in_ptr
++;
792 if (sym
->name
== NULL
|| sym
->name
[0] == '\0')
794 if ((sym
->flags
& (BSF_DEBUGGING
| BSF_SECTION_SYM
))
795 && ! is_significant_symbol_name (sym
->name
))
797 if (bfd_is_und_section (sym
->section
)
798 || bfd_is_com_section (sym
->section
))
803 return out_ptr
- symbols
;
806 /* Sort symbols into value order. */
809 compare_symbols (const void *ap
, const void *bp
)
811 const asymbol
*a
= * (const asymbol
**) ap
;
812 const asymbol
*b
= * (const asymbol
**) bp
;
822 if (bfd_asymbol_value (a
) > bfd_asymbol_value (b
))
824 else if (bfd_asymbol_value (a
) < bfd_asymbol_value (b
))
827 if (a
->section
> b
->section
)
829 else if (a
->section
< b
->section
)
832 an
= bfd_asymbol_name (a
);
833 bn
= bfd_asymbol_name (b
);
837 /* The symbols gnu_compiled and gcc2_compiled convey no real
838 information, so put them after other symbols with the same value. */
839 af
= (strstr (an
, "gnu_compiled") != NULL
840 || strstr (an
, "gcc2_compiled") != NULL
);
841 bf
= (strstr (bn
, "gnu_compiled") != NULL
842 || strstr (bn
, "gcc2_compiled") != NULL
);
849 /* We use a heuristic for the file name, to try to sort it after
850 more useful symbols. It may not work on non Unix systems, but it
851 doesn't really matter; the only difference is precisely which
852 symbol names get printed. */
854 #define file_symbol(s, sn, snl) \
855 (((s)->flags & BSF_FILE) != 0 \
856 || ((sn)[(snl) - 2] == '.' \
857 && ((sn)[(snl) - 1] == 'o' \
858 || (sn)[(snl) - 1] == 'a')))
860 af
= file_symbol (a
, an
, anl
);
861 bf
= file_symbol (b
, bn
, bnl
);
868 /* Try to sort global symbols before local symbols before function
869 symbols before debugging symbols. */
874 if ((aflags
& BSF_DEBUGGING
) != (bflags
& BSF_DEBUGGING
))
876 if ((aflags
& BSF_DEBUGGING
) != 0)
881 if ((aflags
& BSF_FUNCTION
) != (bflags
& BSF_FUNCTION
))
883 if ((aflags
& BSF_FUNCTION
) != 0)
888 if ((aflags
& BSF_LOCAL
) != (bflags
& BSF_LOCAL
))
890 if ((aflags
& BSF_LOCAL
) != 0)
895 if ((aflags
& BSF_GLOBAL
) != (bflags
& BSF_GLOBAL
))
897 if ((aflags
& BSF_GLOBAL
) != 0)
903 if (bfd_get_flavour (bfd_asymbol_bfd (a
)) == bfd_target_elf_flavour
904 && bfd_get_flavour (bfd_asymbol_bfd (b
)) == bfd_target_elf_flavour
)
909 if ((a
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
910 asz
= ((elf_symbol_type
*) a
)->internal_elf_sym
.st_size
;
912 if ((b
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
913 bsz
= ((elf_symbol_type
*) b
)->internal_elf_sym
.st_size
;
915 return asz
> bsz
? -1 : 1;
918 /* Symbols that start with '.' might be section names, so sort them
919 after symbols that don't start with '.'. */
920 if (an
[0] == '.' && bn
[0] != '.')
922 if (an
[0] != '.' && bn
[0] == '.')
925 /* Finally, if we can't distinguish them in any other way, try to
926 get consistent results by sorting the symbols by name. */
927 return strcmp (an
, bn
);
930 /* Sort relocs into address order. */
933 compare_relocs (const void *ap
, const void *bp
)
935 const arelent
*a
= * (const arelent
**) ap
;
936 const arelent
*b
= * (const arelent
**) bp
;
938 if (a
->address
> b
->address
)
940 else if (a
->address
< b
->address
)
943 /* So that associated relocations tied to the same address show up
944 in the correct order, we don't do any further sorting. */
953 /* Print an address (VMA) to the output stream in INFO.
954 If SKIP_ZEROES is TRUE, omit leading zeroes. */
957 objdump_print_value (bfd_vma vma
, struct disassemble_info
*inf
,
958 bfd_boolean skip_zeroes
)
962 struct objdump_disasm_info
*aux
;
964 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
965 bfd_sprintf_vma (aux
->abfd
, buf
, vma
);
970 for (p
= buf
; *p
== '0'; ++p
)
975 (*inf
->fprintf_func
) (inf
->stream
, "%s", p
);
978 /* Print the name of a symbol. */
981 objdump_print_symname (bfd
*abfd
, struct disassemble_info
*inf
,
985 const char *name
, *version_string
= NULL
;
986 bfd_boolean hidden
= FALSE
;
989 name
= bfd_asymbol_name (sym
);
990 if (do_demangle
&& name
[0] != '\0')
992 /* Demangle the name. */
993 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
998 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
999 version_string
= bfd_get_symbol_version_string (abfd
, sym
, &hidden
);
1001 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1004 name
= sanitize_string (name
);
1008 (*inf
->fprintf_func
) (inf
->stream
, "%s", name
);
1009 if (version_string
&& *version_string
!= '\0')
1010 (*inf
->fprintf_func
) (inf
->stream
, hidden
? "@%s" : "@@%s",
1015 printf ("%s", name
);
1016 if (version_string
&& *version_string
!= '\0')
1017 printf (hidden
? "@%s" : "@@%s", version_string
);
1024 static inline bfd_boolean
1025 sym_ok (bfd_boolean want_section
,
1026 bfd
* abfd ATTRIBUTE_UNUSED
,
1029 struct disassemble_info
* inf
)
1033 /* Note - we cannot just compare section pointers because they could
1034 be different, but the same... Ie the symbol that we are trying to
1035 find could have come from a separate debug info file. Under such
1036 circumstances the symbol will be associated with a section in the
1037 debug info file, whilst the section we want is in a normal file.
1038 So the section pointers will be different, but the section names
1039 will be the same. */
1040 if (strcmp (bfd_section_name (sorted_syms
[place
]->section
),
1041 bfd_section_name (sec
)) != 0)
1045 return inf
->symbol_is_valid (sorted_syms
[place
], inf
);
1048 /* Locate a symbol given a bfd and a section (from INFO->application_data),
1049 and a VMA. If INFO->application_data->require_sec is TRUE, then always
1050 require the symbol to be in the section. Returns NULL if there is no
1051 suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
1052 of the symbol in sorted_syms. */
1055 find_symbol_for_address (bfd_vma vma
,
1056 struct disassemble_info
*inf
,
1059 /* @@ Would it speed things up to cache the last two symbols returned,
1060 and maybe their address ranges? For many processors, only one memory
1061 operand can be present at a time, so the 2-entry cache wouldn't be
1062 constantly churned by code doing heavy memory accesses. */
1064 /* Indices in `sorted_syms'. */
1066 long max_count
= sorted_symcount
;
1068 struct objdump_disasm_info
*aux
;
1072 bfd_boolean want_section
;
1075 if (sorted_symcount
< 1)
1078 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1081 opb
= inf
->octets_per_byte
;
1083 /* Perform a binary search looking for the closest symbol to the
1084 required value. We are searching the range (min, max_count]. */
1085 while (min
+ 1 < max_count
)
1089 thisplace
= (max_count
+ min
) / 2;
1090 sym
= sorted_syms
[thisplace
];
1092 if (bfd_asymbol_value (sym
) > vma
)
1093 max_count
= thisplace
;
1094 else if (bfd_asymbol_value (sym
) < vma
)
1103 /* The symbol we want is now in min, the low end of the range we
1104 were searching. If there are several symbols with the same
1105 value, we want the first (non-section/non-debugging) one. */
1107 while (thisplace
> 0
1108 && (bfd_asymbol_value (sorted_syms
[thisplace
])
1109 == bfd_asymbol_value (sorted_syms
[thisplace
- 1]))
1110 && ((sorted_syms
[thisplace
- 1]->flags
1111 & (BSF_SECTION_SYM
| BSF_DEBUGGING
)) == 0)
1115 /* Prefer a symbol in the current section if we have multple symbols
1116 with the same value, as can occur with overlays or zero size
1119 while (min
< max_count
1120 && (bfd_asymbol_value (sorted_syms
[min
])
1121 == bfd_asymbol_value (sorted_syms
[thisplace
])))
1123 if (sym_ok (TRUE
, abfd
, min
, sec
, inf
))
1130 return sorted_syms
[thisplace
];
1135 /* If the file is relocatable, and the symbol could be from this
1136 section, prefer a symbol from this section over symbols from
1137 others, even if the other symbol's value might be closer.
1139 Note that this may be wrong for some symbol references if the
1140 sections have overlapping memory ranges, but in that case there's
1141 no way to tell what's desired without looking at the relocation
1144 Also give the target a chance to reject symbols. */
1145 want_section
= (aux
->require_sec
1146 || ((abfd
->flags
& HAS_RELOC
) != 0
1147 && vma
>= bfd_section_vma (sec
)
1148 && vma
< (bfd_section_vma (sec
)
1149 + bfd_section_size (sec
) / opb
)));
1151 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1154 long newplace
= sorted_symcount
;
1156 for (i
= min
- 1; i
>= 0; i
--)
1158 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1160 if (newplace
== sorted_symcount
)
1163 if (bfd_asymbol_value (sorted_syms
[i
])
1164 != bfd_asymbol_value (sorted_syms
[newplace
]))
1167 /* Remember this symbol and keep searching until we reach
1168 an earlier address. */
1173 if (newplace
!= sorted_symcount
)
1174 thisplace
= newplace
;
1177 /* We didn't find a good symbol with a smaller value.
1178 Look for one with a larger value. */
1179 for (i
= thisplace
+ 1; i
< sorted_symcount
; i
++)
1181 if (sym_ok (want_section
, abfd
, i
, sec
, inf
))
1189 if (! sym_ok (want_section
, abfd
, thisplace
, sec
, inf
))
1190 /* There is no suitable symbol. */
1194 /* If we have not found an exact match for the specified address
1195 and we have dynamic relocations available, then we can produce
1196 a better result by matching a relocation to the address and
1197 using the symbol associated with that relocation. */
1198 rel_count
= aux
->dynrelcount
;
1200 && sorted_syms
[thisplace
]->value
!= vma
1202 && aux
->dynrelbuf
!= NULL
1203 && aux
->dynrelbuf
[0]->address
<= vma
1204 && aux
->dynrelbuf
[rel_count
- 1]->address
>= vma
1205 /* If we have matched a synthetic symbol, then stick with that. */
1206 && (sorted_syms
[thisplace
]->flags
& BSF_SYNTHETIC
) == 0)
1209 arelent
** rel_high
;
1211 rel_low
= aux
->dynrelbuf
;
1212 rel_high
= rel_low
+ rel_count
- 1;
1213 while (rel_low
<= rel_high
)
1215 arelent
**rel_mid
= &rel_low
[(rel_high
- rel_low
) / 2];
1216 arelent
* rel
= *rel_mid
;
1218 if (rel
->address
== vma
)
1220 /* Absolute relocations do not provide a more helpful
1221 symbolic address. Find a non-absolute relocation
1222 with the same address. */
1223 arelent
**rel_vma
= rel_mid
;
1225 rel_mid
>= rel_low
&& rel_mid
[0]->address
== vma
;
1229 for (; rel_vma
<= rel_high
&& rel_vma
[0]->address
== vma
;
1233 if (rel
->sym_ptr_ptr
!= NULL
1234 && ! bfd_is_abs_section ((* rel
->sym_ptr_ptr
)->section
))
1237 * place
= thisplace
;
1238 return * rel
->sym_ptr_ptr
;
1244 if (vma
< rel
->address
)
1246 else if (vma
>= rel_mid
[1]->address
)
1247 rel_low
= rel_mid
+ 1;
1256 return sorted_syms
[thisplace
];
1259 /* Print an address and the offset to the nearest symbol. */
1262 objdump_print_addr_with_sym (bfd
*abfd
, asection
*sec
, asymbol
*sym
,
1263 bfd_vma vma
, struct disassemble_info
*inf
,
1264 bfd_boolean skip_zeroes
)
1266 objdump_print_value (vma
, inf
, skip_zeroes
);
1272 (*inf
->fprintf_func
) (inf
->stream
, " <%s",
1273 sanitize_string (bfd_section_name (sec
)));
1274 secaddr
= bfd_section_vma (sec
);
1277 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1278 objdump_print_value (secaddr
- vma
, inf
, TRUE
);
1280 else if (vma
> secaddr
)
1282 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1283 objdump_print_value (vma
- secaddr
, inf
, TRUE
);
1285 (*inf
->fprintf_func
) (inf
->stream
, ">");
1289 (*inf
->fprintf_func
) (inf
->stream
, " <");
1291 objdump_print_symname (abfd
, inf
, sym
);
1293 if (bfd_asymbol_value (sym
) == vma
)
1295 /* Undefined symbols in an executables and dynamic objects do not have
1296 a value associated with them, so it does not make sense to display
1297 an offset relative to them. Normally we would not be provided with
1298 this kind of symbol, but the target backend might choose to do so,
1299 and the code in find_symbol_for_address might return an as yet
1300 unresolved symbol associated with a dynamic reloc. */
1301 else if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
))
1302 && bfd_is_und_section (sym
->section
))
1304 else if (bfd_asymbol_value (sym
) > vma
)
1306 (*inf
->fprintf_func
) (inf
->stream
, "-0x");
1307 objdump_print_value (bfd_asymbol_value (sym
) - vma
, inf
, TRUE
);
1309 else if (vma
> bfd_asymbol_value (sym
))
1311 (*inf
->fprintf_func
) (inf
->stream
, "+0x");
1312 objdump_print_value (vma
- bfd_asymbol_value (sym
), inf
, TRUE
);
1315 (*inf
->fprintf_func
) (inf
->stream
, ">");
1318 if (display_file_offsets
)
1319 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1320 (long int)(sec
->filepos
+ (vma
- sec
->vma
)));
1323 /* Print an address (VMA), symbolically if possible.
1324 If SKIP_ZEROES is TRUE, don't output leading zeroes. */
1327 objdump_print_addr (bfd_vma vma
,
1328 struct disassemble_info
*inf
,
1329 bfd_boolean skip_zeroes
)
1331 struct objdump_disasm_info
*aux
;
1332 asymbol
*sym
= NULL
;
1333 bfd_boolean skip_find
= FALSE
;
1335 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1337 if (sorted_symcount
< 1)
1339 (*inf
->fprintf_func
) (inf
->stream
, "0x");
1340 objdump_print_value (vma
, inf
, skip_zeroes
);
1342 if (display_file_offsets
)
1343 inf
->fprintf_func (inf
->stream
, _(" (File Offset: 0x%lx)"),
1344 (long int) (inf
->section
->filepos
1345 + (vma
- inf
->section
->vma
)));
1349 if (aux
->reloc
!= NULL
1350 && aux
->reloc
->sym_ptr_ptr
!= NULL
1351 && * aux
->reloc
->sym_ptr_ptr
!= NULL
)
1353 sym
= * aux
->reloc
->sym_ptr_ptr
;
1355 /* Adjust the vma to the reloc. */
1356 vma
+= bfd_asymbol_value (sym
);
1358 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
1363 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1365 objdump_print_addr_with_sym (aux
->abfd
, inf
->section
, sym
, vma
, inf
,
1369 /* Print VMA to INFO. This function is passed to the disassembler
1373 objdump_print_address (bfd_vma vma
, struct disassemble_info
*inf
)
1375 objdump_print_addr (vma
, inf
, ! prefix_addresses
);
1378 /* Determine if the given address has a symbol associated with it. */
1381 objdump_symbol_at_address (bfd_vma vma
, struct disassemble_info
* inf
)
1385 sym
= find_symbol_for_address (vma
, inf
, NULL
);
1387 return (sym
!= NULL
&& (bfd_asymbol_value (sym
) == vma
));
1390 /* Hold the last function name and the last line number we displayed
1391 in a disassembly. */
1393 static char *prev_functionname
;
1394 static unsigned int prev_line
;
1395 static unsigned int prev_discriminator
;
1397 /* We keep a list of all files that we have seen when doing a
1398 disassembly with source, so that we know how much of the file to
1399 display. This can be important for inlined functions. */
1401 struct print_file_list
1403 struct print_file_list
*next
;
1404 const char *filename
;
1405 const char *modname
;
1408 const char **linemap
;
1411 unsigned max_printed
;
1415 static struct print_file_list
*print_files
;
1417 /* The number of preceding context lines to show when we start
1418 displaying a file for the first time. */
1420 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1422 /* Read a complete file into memory. */
1425 slurp_file (const char *fn
, size_t *size
, struct stat
*fst
)
1428 int ps
= getpagesize ();
1432 int fd
= open (fn
, O_RDONLY
| O_BINARY
);
1436 if (fstat (fd
, fst
) < 0)
1441 *size
= fst
->st_size
;
1443 msize
= (*size
+ ps
- 1) & ~(ps
- 1);
1444 map
= mmap (NULL
, msize
, PROT_READ
, MAP_SHARED
, fd
, 0);
1445 if (map
!= (char *) -1L)
1451 map
= (const char *) malloc (*size
);
1452 if (!map
|| (size_t) read (fd
, (char *) map
, *size
) != *size
)
1454 free ((void *) map
);
1461 #define line_map_decrease 5
1463 /* Precompute array of lines for a mapped file. */
1465 static const char **
1466 index_file (const char *map
, size_t size
, unsigned int *maxline
)
1468 const char *p
, *lstart
, *end
;
1469 int chars_per_line
= 45; /* First iteration will use 40. */
1470 unsigned int lineno
;
1471 const char **linemap
= NULL
;
1472 unsigned long line_map_size
= 0;
1478 for (p
= map
; p
< end
; p
++)
1482 if (p
+ 1 < end
&& p
[1] == '\r')
1485 else if (*p
== '\r')
1487 if (p
+ 1 < end
&& p
[1] == '\n')
1493 /* End of line found. */
1495 if (linemap
== NULL
|| line_map_size
< lineno
+ 1)
1497 unsigned long newsize
;
1499 chars_per_line
-= line_map_decrease
;
1500 if (chars_per_line
<= 1)
1502 line_map_size
= size
/ chars_per_line
+ 1;
1503 if (line_map_size
< lineno
+ 1)
1504 line_map_size
= lineno
+ 1;
1505 newsize
= line_map_size
* sizeof (char *);
1506 linemap
= (const char **) xrealloc (linemap
, newsize
);
1509 linemap
[lineno
++] = lstart
;
1517 /* Tries to open MODNAME, and if successful adds a node to print_files
1518 linked list and returns that node. Returns NULL on failure. */
1520 static struct print_file_list
*
1521 try_print_file_open (const char *origname
, const char *modname
, struct stat
*fst
)
1523 struct print_file_list
*p
;
1525 p
= (struct print_file_list
*) xmalloc (sizeof (struct print_file_list
));
1527 p
->map
= slurp_file (modname
, &p
->mapsize
, fst
);
1534 p
->linemap
= index_file (p
->map
, p
->mapsize
, &p
->maxline
);
1537 p
->filename
= origname
;
1538 p
->modname
= modname
;
1539 p
->next
= print_files
;
1545 /* If the source file, as described in the symtab, is not found
1546 try to locate it in one of the paths specified with -I
1547 If found, add location to print_files linked list. */
1549 static struct print_file_list
*
1550 update_source_path (const char *filename
, bfd
*abfd
)
1552 struct print_file_list
*p
;
1557 p
= try_print_file_open (filename
, filename
, &fst
);
1560 if (include_path_count
== 0)
1563 /* Get the name of the file. */
1564 fname
= lbasename (filename
);
1566 /* If file exists under a new path, we need to add it to the list
1567 so that show_line knows about it. */
1568 for (i
= 0; i
< include_path_count
; i
++)
1570 char *modname
= concat (include_paths
[i
], "/", fname
,
1573 p
= try_print_file_open (filename
, modname
, &fst
);
1583 long mtime
= bfd_get_mtime (abfd
);
1585 if (fst
.st_mtime
> mtime
)
1586 warn (_("source file %s is more recent than object file\n"),
1593 /* Print a source file line. */
1596 print_line (struct print_file_list
*p
, unsigned int linenum
)
1602 if (linenum
>= p
->maxline
)
1604 l
= p
->linemap
[linenum
];
1605 if (source_comment
!= NULL
&& strlen (l
) > 0)
1606 printf ("%s", source_comment
);
1607 len
= strcspn (l
, "\n\r");
1608 /* Test fwrite return value to quiet glibc warning. */
1609 if (len
== 0 || fwrite (l
, len
, 1, stdout
) == 1)
1613 /* Print a range of source code lines. */
1616 dump_lines (struct print_file_list
*p
, unsigned int start
, unsigned int end
)
1620 while (start
<= end
)
1622 print_line (p
, start
);
1627 /* Show the line number, or the source line, in a disassembly
1631 show_line (bfd
*abfd
, asection
*section
, bfd_vma addr_offset
)
1633 const char *filename
;
1634 const char *functionname
;
1635 unsigned int linenumber
;
1636 unsigned int discriminator
;
1640 if (! with_line_numbers
&& ! with_source_code
)
1643 if (! bfd_find_nearest_line_discriminator (abfd
, section
, syms
, addr_offset
,
1644 &filename
, &functionname
,
1645 &linenumber
, &discriminator
))
1648 if (filename
!= NULL
&& *filename
== '\0')
1650 if (functionname
!= NULL
&& *functionname
== '\0')
1651 functionname
= NULL
;
1654 && IS_ABSOLUTE_PATH (filename
)
1658 const char *fname
= filename
;
1660 path
= xmalloc (prefix_length
+ PATH_MAX
+ 1);
1663 memcpy (path
, prefix
, prefix_length
);
1664 path_up
= path
+ prefix_length
;
1666 /* Build relocated filename, stripping off leading directories
1667 from the initial filename if requested. */
1668 if (prefix_strip
> 0)
1673 /* Skip selected directory levels. */
1674 for (s
= fname
+ 1; *s
!= '\0' && level
< prefix_strip
; s
++)
1675 if (IS_DIR_SEPARATOR(*s
))
1682 /* Update complete filename. */
1683 strncpy (path_up
, fname
, PATH_MAX
);
1684 path_up
[PATH_MAX
] = '\0';
1692 if (with_line_numbers
)
1694 if (functionname
!= NULL
1695 && (prev_functionname
== NULL
1696 || strcmp (functionname
, prev_functionname
) != 0))
1698 printf ("%s():\n", sanitize_string (functionname
));
1702 && (linenumber
!= prev_line
1703 || discriminator
!= prev_discriminator
))
1705 if (discriminator
> 0)
1706 printf ("%s:%u (discriminator %u)\n",
1707 filename
== NULL
? "???" : sanitize_string (filename
),
1708 linenumber
, discriminator
);
1710 printf ("%s:%u\n", filename
== NULL
1711 ? "???" : sanitize_string (filename
),
1716 const char *filename2
;
1717 const char *functionname2
;
1720 while (bfd_find_inliner_info (abfd
, &filename2
, &functionname2
,
1723 printf ("inlined by %s:%u",
1724 sanitize_string (filename2
), line2
);
1725 printf (" (%s)\n", sanitize_string (functionname2
));
1730 if (with_source_code
1734 struct print_file_list
**pp
, *p
;
1737 for (pp
= &print_files
; *pp
!= NULL
; pp
= &(*pp
)->next
)
1738 if (filename_cmp ((*pp
)->filename
, filename
) == 0)
1745 filename
= xstrdup (filename
);
1746 p
= update_source_path (filename
, abfd
);
1749 if (p
!= NULL
&& linenumber
!= p
->last_line
)
1751 if (file_start_context
&& p
->first
)
1755 l
= linenumber
- SHOW_PRECEDING_CONTEXT_LINES
;
1756 if (l
>= linenumber
)
1758 if (p
->max_printed
>= l
)
1760 if (p
->max_printed
< linenumber
)
1761 l
= p
->max_printed
+ 1;
1766 dump_lines (p
, l
, linenumber
);
1767 if (p
->max_printed
< linenumber
)
1768 p
->max_printed
= linenumber
;
1769 p
->last_line
= linenumber
;
1774 if (functionname
!= NULL
1775 && (prev_functionname
== NULL
1776 || strcmp (functionname
, prev_functionname
) != 0))
1778 if (prev_functionname
!= NULL
)
1779 free (prev_functionname
);
1780 prev_functionname
= (char *) xmalloc (strlen (functionname
) + 1);
1781 strcpy (prev_functionname
, functionname
);
1784 if (linenumber
> 0 && linenumber
!= prev_line
)
1785 prev_line
= linenumber
;
1787 if (discriminator
!= prev_discriminator
)
1788 prev_discriminator
= discriminator
;
1794 /* Pseudo FILE object for strings. */
1802 /* sprintf to a "stream". */
1804 static int ATTRIBUTE_PRINTF_2
1805 objdump_sprintf (SFILE
*f
, const char *format
, ...)
1812 size_t space
= f
->alloc
- f
->pos
;
1814 va_start (args
, format
);
1815 n
= vsnprintf (f
->buffer
+ f
->pos
, space
, format
, args
);
1821 f
->alloc
= (f
->alloc
+ n
) * 2;
1822 f
->buffer
= (char *) xrealloc (f
->buffer
, f
->alloc
);
1829 /* The number of zeroes we want to see before we start skipping them.
1830 The number is arbitrarily chosen. */
1832 #define DEFAULT_SKIP_ZEROES 8
1834 /* The number of zeroes to skip at the end of a section. If the
1835 number of zeroes at the end is between SKIP_ZEROES_AT_END and
1836 SKIP_ZEROES, they will be disassembled. If there are fewer than
1837 SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
1838 attempt to avoid disassembling zeroes inserted by section
1841 #define DEFAULT_SKIP_ZEROES_AT_END 3
1844 null_print (const void * stream ATTRIBUTE_UNUSED
, const char * format ATTRIBUTE_UNUSED
, ...)
1849 /* Disassemble some data in memory between given values. */
1852 disassemble_bytes (struct disassemble_info
* inf
,
1853 disassembler_ftype disassemble_fn
,
1856 bfd_vma start_offset
,
1857 bfd_vma stop_offset
,
1860 arelent
** relppend
)
1862 struct objdump_disasm_info
*aux
;
1864 int octets_per_line
;
1865 int skip_addr_chars
;
1866 bfd_vma addr_offset
;
1867 unsigned int opb
= inf
->octets_per_byte
;
1868 unsigned int skip_zeroes
= inf
->skip_zeroes
;
1869 unsigned int skip_zeroes_at_end
= inf
->skip_zeroes_at_end
;
1873 aux
= (struct objdump_disasm_info
*) inf
->application_data
;
1874 section
= inf
->section
;
1877 sfile
.buffer
= (char *) xmalloc (sfile
.alloc
);
1881 octets_per_line
= insn_width
;
1883 octets_per_line
= 4;
1885 octets_per_line
= 16;
1887 /* Figure out how many characters to skip at the start of an
1888 address, to make the disassembly look nicer. We discard leading
1889 zeroes in chunks of 4, ensuring that there is always a leading
1891 skip_addr_chars
= 0;
1892 if (! prefix_addresses
)
1896 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ section
->size
/ opb
);
1898 while (buf
[skip_addr_chars
] == '0')
1901 /* Don't discard zeros on overflow. */
1902 if (buf
[skip_addr_chars
] == '\0' && section
->vma
!= 0)
1903 skip_addr_chars
= 0;
1905 if (skip_addr_chars
!= 0)
1906 skip_addr_chars
= (skip_addr_chars
- 1) & -4;
1909 inf
->insn_info_valid
= 0;
1911 addr_offset
= start_offset
;
1912 while (addr_offset
< stop_offset
)
1915 bfd_boolean need_nl
= FALSE
;
1919 /* Make sure we don't use relocs from previous instructions. */
1922 /* If we see more than SKIP_ZEROES octets of zeroes, we just
1924 for (z
= addr_offset
* opb
; z
< stop_offset
* opb
; z
++)
1927 if (! disassemble_zeroes
1928 && (inf
->insn_info_valid
== 0
1929 || inf
->branch_delay_insns
== 0)
1930 && (z
- addr_offset
* opb
>= skip_zeroes
1931 || (z
== stop_offset
* opb
&&
1932 z
- addr_offset
* opb
< skip_zeroes_at_end
)))
1934 /* If there are more nonzero octets to follow, we only skip
1935 zeroes in multiples of 4, to try to avoid running over
1936 the start of an instruction which happens to start with
1938 if (z
!= stop_offset
* opb
)
1939 z
= addr_offset
* opb
+ ((z
- addr_offset
* opb
) &~ 3);
1941 octets
= z
- addr_offset
* opb
;
1943 /* If we are going to display more data, and we are displaying
1944 file offsets, then tell the user how many zeroes we skip
1945 and the file offset from where we resume dumping. */
1946 if (display_file_offsets
&& ((addr_offset
+ (octets
/ opb
)) < stop_offset
))
1947 printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1949 (unsigned long) (section
->filepos
1950 + (addr_offset
+ (octets
/ opb
))));
1960 if (with_line_numbers
|| with_source_code
)
1961 show_line (aux
->abfd
, section
, addr_offset
);
1963 if (! prefix_addresses
)
1967 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ addr_offset
);
1968 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
1972 printf ("%s:\t", buf
+ skip_addr_chars
);
1976 aux
->require_sec
= TRUE
;
1977 objdump_print_address (section
->vma
+ addr_offset
, inf
);
1978 aux
->require_sec
= FALSE
;
1985 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
1986 inf
->stream
= &sfile
;
1987 inf
->bytes_per_line
= 0;
1988 inf
->bytes_per_chunk
= 0;
1989 inf
->flags
= ((disassemble_all
? DISASSEMBLE_DATA
: 0)
1990 | (wide_output
? WIDE_OUTPUT
: 0));
1992 inf
->flags
|= USER_SPECIFIED_MACHINE_TYPE
;
1994 if (inf
->disassembler_needs_relocs
1995 && (bfd_get_file_flags (aux
->abfd
) & EXEC_P
) == 0
1996 && (bfd_get_file_flags (aux
->abfd
) & DYNAMIC
) == 0
1997 && *relppp
< relppend
)
1999 bfd_signed_vma distance_to_rel
;
2001 int max_reloc_offset
2002 = aux
->abfd
->arch_info
->max_reloc_offset_into_insn
;
2004 distance_to_rel
= ((**relppp
)->address
- rel_offset
2007 if (distance_to_rel
> 0
2008 && (max_reloc_offset
< 0
2009 || distance_to_rel
<= max_reloc_offset
))
2011 /* This reloc *might* apply to the current insn,
2012 starting somewhere inside it. Discover the length
2013 of the current insn so that the check below will
2016 insn_size
= insn_width
;
2019 /* We find the length by calling the dissassembler
2020 function with a dummy print handler. This should
2021 work unless the disassembler is not expecting to
2022 be called multiple times for the same address.
2024 This does mean disassembling the instruction
2025 twice, but we only do this when there is a high
2026 probability that there is a reloc that will
2027 affect the instruction. */
2028 inf
->fprintf_func
= (fprintf_ftype
) null_print
;
2029 insn_size
= disassemble_fn (section
->vma
2030 + addr_offset
, inf
);
2031 inf
->fprintf_func
= (fprintf_ftype
) objdump_sprintf
;
2035 /* Check to see if the current reloc is associated with
2036 the instruction that we are about to disassemble. */
2037 if (distance_to_rel
== 0
2038 || (distance_to_rel
> 0
2039 && distance_to_rel
< insn_size
/ (int) opb
))
2041 inf
->flags
|= INSN_HAS_RELOC
;
2042 aux
->reloc
= **relppp
;
2046 if (! disassemble_all
2047 && (section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2048 == (SEC_CODE
| SEC_HAS_CONTENTS
))
2049 /* Set a stop_vma so that the disassembler will not read
2050 beyond the next symbol. We assume that symbols appear on
2051 the boundaries between instructions. We only do this when
2052 disassembling code of course, and when -D is in effect. */
2053 inf
->stop_vma
= section
->vma
+ stop_offset
;
2055 inf
->stop_offset
= stop_offset
;
2056 octets
= (*disassemble_fn
) (section
->vma
+ addr_offset
, inf
);
2059 inf
->fprintf_func
= (fprintf_ftype
) fprintf
;
2060 inf
->stream
= stdout
;
2061 if (insn_width
== 0 && inf
->bytes_per_line
!= 0)
2062 octets_per_line
= inf
->bytes_per_line
;
2063 if (octets
< (int) opb
)
2066 printf ("%s\n", sfile
.buffer
);
2069 non_fatal (_("disassemble_fn returned length %d"),
2080 octets
= octets_per_line
;
2081 if (addr_offset
+ octets
/ opb
> stop_offset
)
2082 octets
= (stop_offset
- addr_offset
) * opb
;
2084 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ octets
; ++j
)
2086 if (ISPRINT (data
[j
]))
2087 buf
[j
- addr_offset
* opb
] = data
[j
];
2089 buf
[j
- addr_offset
* opb
] = '.';
2091 buf
[j
- addr_offset
* opb
] = '\0';
2094 if (prefix_addresses
2096 : show_raw_insn
>= 0)
2100 /* If ! prefix_addresses and ! wide_output, we print
2101 octets_per_line octets per line. */
2103 if (pb
> octets_per_line
&& ! prefix_addresses
&& ! wide_output
)
2104 pb
= octets_per_line
;
2106 if (inf
->bytes_per_chunk
)
2107 bpc
= inf
->bytes_per_chunk
;
2111 for (j
= addr_offset
* opb
; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2113 /* PR 21580: Check for a buffer ending early. */
2114 if (j
+ bpc
<= stop_offset
* opb
)
2118 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2120 for (k
= bpc
- 1; k
>= 0; k
--)
2121 printf ("%02x", (unsigned) data
[j
+ k
]);
2125 for (k
= 0; k
< bpc
; k
++)
2126 printf ("%02x", (unsigned) data
[j
+ k
]);
2132 for (; pb
< octets_per_line
; pb
+= bpc
)
2136 for (k
= 0; k
< bpc
; k
++)
2141 /* Separate raw data from instruction by extra space. */
2151 printf ("%s", sfile
.buffer
);
2153 if (prefix_addresses
2155 : show_raw_insn
>= 0)
2163 j
= addr_offset
* opb
+ pb
;
2165 bfd_sprintf_vma (aux
->abfd
, buf
, section
->vma
+ j
/ opb
);
2166 for (s
= buf
+ skip_addr_chars
; *s
== '0'; s
++)
2170 printf ("%s:\t", buf
+ skip_addr_chars
);
2172 pb
+= octets_per_line
;
2175 for (; j
< addr_offset
* opb
+ pb
; j
+= bpc
)
2177 /* PR 21619: Check for a buffer ending early. */
2178 if (j
+ bpc
<= stop_offset
* opb
)
2182 if (inf
->display_endian
== BFD_ENDIAN_LITTLE
)
2184 for (k
= bpc
- 1; k
>= 0; k
--)
2185 printf ("%02x", (unsigned) data
[j
+ k
]);
2189 for (k
= 0; k
< bpc
; k
++)
2190 printf ("%02x", (unsigned) data
[j
+ k
]);
2204 while ((*relppp
) < relppend
2205 && (**relppp
)->address
< rel_offset
+ addr_offset
+ octets
/ opb
)
2207 if (dump_reloc_info
|| dump_dynamic_reloc_info
)
2218 objdump_print_value (section
->vma
- rel_offset
+ q
->address
,
2221 if (q
->howto
== NULL
)
2222 printf (": *unknown*\t");
2223 else if (q
->howto
->name
)
2224 printf (": %s\t", q
->howto
->name
);
2226 printf (": %d\t", q
->howto
->type
);
2228 if (q
->sym_ptr_ptr
== NULL
|| *q
->sym_ptr_ptr
== NULL
)
2229 printf ("*unknown*");
2232 const char *sym_name
;
2234 sym_name
= bfd_asymbol_name (*q
->sym_ptr_ptr
);
2235 if (sym_name
!= NULL
&& *sym_name
!= '\0')
2236 objdump_print_symname (aux
->abfd
, inf
, *q
->sym_ptr_ptr
);
2241 sym_sec
= bfd_asymbol_section (*q
->sym_ptr_ptr
);
2242 sym_name
= bfd_section_name (sym_sec
);
2243 if (sym_name
== NULL
|| *sym_name
== '\0')
2244 sym_name
= "*unknown*";
2245 printf ("%s", sanitize_string (sym_name
));
2251 bfd_signed_vma addend
= q
->addend
;
2259 objdump_print_value (addend
, inf
, TRUE
);
2271 addr_offset
+= octets
/ opb
;
2274 free (sfile
.buffer
);
2278 disassemble_section (bfd
*abfd
, asection
*section
, void *inf
)
2280 const struct elf_backend_data
* bed
;
2281 bfd_vma sign_adjust
= 0;
2282 struct disassemble_info
* pinfo
= (struct disassemble_info
*) inf
;
2283 struct objdump_disasm_info
* paux
;
2284 unsigned int opb
= pinfo
->octets_per_byte
;
2285 bfd_byte
* data
= NULL
;
2286 bfd_size_type datasize
= 0;
2287 arelent
** rel_pp
= NULL
;
2288 arelent
** rel_ppstart
= NULL
;
2289 arelent
** rel_ppend
;
2290 bfd_vma stop_offset
;
2291 asymbol
* sym
= NULL
;
2295 unsigned long addr_offset
;
2296 bfd_boolean do_print
;
2299 stop_offset_reached
,
2304 /* Sections that do not contain machine
2305 code are not normally disassembled. */
2306 if (! disassemble_all
2307 && only_list
== NULL
2308 && ((section
->flags
& (SEC_CODE
| SEC_HAS_CONTENTS
))
2309 != (SEC_CODE
| SEC_HAS_CONTENTS
)))
2312 if (! process_section_p (section
))
2315 datasize
= bfd_section_size (section
);
2319 if (start_address
== (bfd_vma
) -1
2320 || start_address
< section
->vma
)
2323 addr_offset
= start_address
- section
->vma
;
2325 if (stop_address
== (bfd_vma
) -1)
2326 stop_offset
= datasize
/ opb
;
2329 if (stop_address
< section
->vma
)
2332 stop_offset
= stop_address
- section
->vma
;
2333 if (stop_offset
> datasize
/ opb
)
2334 stop_offset
= datasize
/ opb
;
2337 if (addr_offset
>= stop_offset
)
2340 /* Decide which set of relocs to use. Load them if necessary. */
2341 paux
= (struct objdump_disasm_info
*) pinfo
->application_data
;
2342 if (paux
->dynrelbuf
&& dump_dynamic_reloc_info
)
2344 rel_pp
= paux
->dynrelbuf
;
2345 rel_count
= paux
->dynrelcount
;
2346 /* Dynamic reloc addresses are absolute, non-dynamic are section
2347 relative. REL_OFFSET specifies the reloc address corresponding
2348 to the start of this section. */
2349 rel_offset
= section
->vma
;
2357 if ((section
->flags
& SEC_RELOC
) != 0
2358 && (dump_reloc_info
|| pinfo
->disassembler_needs_relocs
))
2362 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
2364 bfd_fatal (bfd_get_filename (abfd
));
2368 rel_ppstart
= rel_pp
= (arelent
**) xmalloc (relsize
);
2369 rel_count
= bfd_canonicalize_reloc (abfd
, section
, rel_pp
, syms
);
2371 bfd_fatal (bfd_get_filename (abfd
));
2373 /* Sort the relocs by address. */
2374 qsort (rel_pp
, rel_count
, sizeof (arelent
*), compare_relocs
);
2378 rel_ppend
= rel_pp
+ rel_count
;
2380 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2382 non_fatal (_("Reading section %s failed because: %s"),
2383 section
->name
, bfd_errmsg (bfd_get_error ()));
2387 pinfo
->buffer
= data
;
2388 pinfo
->buffer_vma
= section
->vma
;
2389 pinfo
->buffer_length
= datasize
;
2390 pinfo
->section
= section
;
2392 /* Skip over the relocs belonging to addresses below the
2394 while (rel_pp
< rel_ppend
2395 && (*rel_pp
)->address
< rel_offset
+ addr_offset
)
2398 printf (_("\nDisassembly of section %s:\n"), sanitize_string (section
->name
));
2400 /* Find the nearest symbol forwards from our current position. */
2401 paux
->require_sec
= TRUE
;
2402 sym
= (asymbol
*) find_symbol_for_address (section
->vma
+ addr_offset
,
2403 (struct disassemble_info
*) inf
,
2405 paux
->require_sec
= FALSE
;
2407 /* PR 9774: If the target used signed addresses then we must make
2408 sure that we sign extend the value that we calculate for 'addr'
2409 in the loop below. */
2410 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2411 && (bed
= get_elf_backend_data (abfd
)) != NULL
2412 && bed
->sign_extend_vma
)
2413 sign_adjust
= (bfd_vma
) 1 << (bed
->s
->arch_size
- 1);
2415 /* Disassemble a block of instructions up to the address associated with
2416 the symbol we have just found. Then print the symbol and find the
2417 next symbol on. Repeat until we have disassembled the entire section
2418 or we have reached the end of the address range we are interested in. */
2419 do_print
= paux
->symbol
== NULL
;
2420 loop_until
= stop_offset_reached
;
2422 while (addr_offset
< stop_offset
)
2426 bfd_vma nextstop_offset
;
2429 addr
= section
->vma
+ addr_offset
;
2430 addr
= ((addr
& ((sign_adjust
<< 1) - 1)) ^ sign_adjust
) - sign_adjust
;
2432 if (sym
!= NULL
&& bfd_asymbol_value (sym
) <= addr
)
2437 (x
< sorted_symcount
2438 && (bfd_asymbol_value (sorted_syms
[x
]) <= addr
));
2442 pinfo
->symbols
= sorted_syms
+ place
;
2443 pinfo
->num_symbols
= x
- place
;
2444 pinfo
->symtab_pos
= place
;
2448 pinfo
->symbols
= NULL
;
2449 pinfo
->num_symbols
= 0;
2450 pinfo
->symtab_pos
= -1;
2453 /* If we are only disassembling from a specific symbol,
2454 check to see if we should start or stop displaying. */
2455 if (sym
&& paux
->symbol
)
2459 /* See if we should stop printing. */
2463 if (sym
->flags
& BSF_FUNCTION
)
2467 case stop_offset_reached
:
2468 /* Handled by the while loop. */
2472 /* FIXME: There is an implicit assumption here
2473 that the name of sym is different from
2475 if (! bfd_is_local_label (abfd
, sym
))
2482 const char * name
= bfd_asymbol_name (sym
);
2483 char * alloc
= NULL
;
2485 if (do_demangle
&& name
[0] != '\0')
2487 /* Demangle the name. */
2488 alloc
= bfd_demangle (abfd
, name
, demangle_flags
);
2493 /* We are not currently printing. Check to see
2494 if the current symbol matches the requested symbol. */
2495 if (streq (name
, paux
->symbol
))
2499 if (sym
->flags
& BSF_FUNCTION
)
2501 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
2502 && ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
> 0)
2504 /* Sym is a function symbol with a size associated
2505 with it. Turn on automatic disassembly for the
2506 next VALUE bytes. */
2507 stop_offset
= addr_offset
2508 + ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
2509 loop_until
= stop_offset_reached
;
2513 /* Otherwise we need to tell the loop heuristic to
2514 loop until the next function symbol is encountered. */
2515 loop_until
= function_sym
;
2520 /* Otherwise loop until the next symbol is encountered. */
2521 loop_until
= next_sym
;
2529 if (! prefix_addresses
&& do_print
)
2531 pinfo
->fprintf_func (pinfo
->stream
, "\n");
2532 objdump_print_addr_with_sym (abfd
, section
, sym
, addr
,
2534 pinfo
->fprintf_func (pinfo
->stream
, ":\n");
2537 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2539 else if (sym
== NULL
)
2543 #define is_valid_next_sym(SYM) \
2544 (strcmp (bfd_section_name ((SYM)->section), bfd_section_name (section)) == 0 \
2545 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2546 && pinfo->symbol_is_valid (SYM, pinfo))
2548 /* Search forward for the next appropriate symbol in
2549 SECTION. Note that all the symbols are sorted
2550 together into one big array, and that some sections
2551 may have overlapping addresses. */
2552 while (place
< sorted_symcount
2553 && ! is_valid_next_sym (sorted_syms
[place
]))
2556 if (place
>= sorted_symcount
)
2559 nextsym
= sorted_syms
[place
];
2562 if (sym
!= NULL
&& bfd_asymbol_value (sym
) > addr
)
2563 nextstop_offset
= bfd_asymbol_value (sym
) - section
->vma
;
2564 else if (nextsym
== NULL
)
2565 nextstop_offset
= stop_offset
;
2567 nextstop_offset
= bfd_asymbol_value (nextsym
) - section
->vma
;
2569 if (nextstop_offset
> stop_offset
2570 || nextstop_offset
<= addr_offset
)
2571 nextstop_offset
= stop_offset
;
2573 /* If a symbol is explicitly marked as being an object
2574 rather than a function, just dump the bytes without
2575 disassembling them. */
2578 || sym
->section
!= section
2579 || bfd_asymbol_value (sym
) > addr
2580 || ((sym
->flags
& BSF_OBJECT
) == 0
2581 && (strstr (bfd_asymbol_name (sym
), "gnu_compiled")
2583 && (strstr (bfd_asymbol_name (sym
), "gcc2_compiled")
2585 || (sym
->flags
& BSF_FUNCTION
) != 0)
2591 disassemble_bytes (pinfo
, paux
->disassemble_fn
, insns
, data
,
2592 addr_offset
, nextstop_offset
,
2593 rel_offset
, &rel_pp
, rel_ppend
);
2595 addr_offset
= nextstop_offset
;
2601 if (rel_ppstart
!= NULL
)
2605 /* Disassemble the contents of an object file. */
2608 disassemble_data (bfd
*abfd
)
2610 struct disassemble_info disasm_info
;
2611 struct objdump_disasm_info aux
;
2615 prev_functionname
= NULL
;
2617 prev_discriminator
= 0;
2619 /* We make a copy of syms to sort. We don't want to sort syms
2620 because that will screw up the relocs. */
2621 sorted_symcount
= symcount
? symcount
: dynsymcount
;
2622 sorted_syms
= (asymbol
**) xmalloc ((sorted_symcount
+ synthcount
)
2623 * sizeof (asymbol
*));
2624 memcpy (sorted_syms
, symcount
? syms
: dynsyms
,
2625 sorted_symcount
* sizeof (asymbol
*));
2627 sorted_symcount
= remove_useless_symbols (sorted_syms
, sorted_symcount
);
2629 for (i
= 0; i
< synthcount
; ++i
)
2631 sorted_syms
[sorted_symcount
] = synthsyms
+ i
;
2635 /* Sort the symbols into section and symbol order. */
2636 qsort (sorted_syms
, sorted_symcount
, sizeof (asymbol
*), compare_symbols
);
2638 init_disassemble_info (&disasm_info
, stdout
, (fprintf_ftype
) fprintf
);
2640 disasm_info
.application_data
= (void *) &aux
;
2642 aux
.require_sec
= FALSE
;
2643 aux
.dynrelbuf
= NULL
;
2644 aux
.dynrelcount
= 0;
2646 aux
.symbol
= disasm_sym
;
2648 disasm_info
.print_address_func
= objdump_print_address
;
2649 disasm_info
.symbol_at_address_func
= objdump_symbol_at_address
;
2651 if (machine
!= NULL
)
2653 const bfd_arch_info_type
*inf
= bfd_scan_arch (machine
);
2656 fatal (_("can't use supplied machine %s"), machine
);
2658 abfd
->arch_info
= inf
;
2661 if (endian
!= BFD_ENDIAN_UNKNOWN
)
2663 struct bfd_target
*xvec
;
2665 xvec
= (struct bfd_target
*) xmalloc (sizeof (struct bfd_target
));
2666 memcpy (xvec
, abfd
->xvec
, sizeof (struct bfd_target
));
2667 xvec
->byteorder
= endian
;
2671 /* Use libopcodes to locate a suitable disassembler. */
2672 aux
.disassemble_fn
= disassembler (bfd_get_arch (abfd
),
2673 bfd_big_endian (abfd
),
2674 bfd_get_mach (abfd
), abfd
);
2675 if (!aux
.disassemble_fn
)
2677 non_fatal (_("can't disassemble for architecture %s\n"),
2678 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0));
2683 disasm_info
.flavour
= bfd_get_flavour (abfd
);
2684 disasm_info
.arch
= bfd_get_arch (abfd
);
2685 disasm_info
.mach
= bfd_get_mach (abfd
);
2686 disasm_info
.disassembler_options
= disassembler_options
;
2687 disasm_info
.octets_per_byte
= bfd_octets_per_byte (abfd
, NULL
);
2688 disasm_info
.skip_zeroes
= DEFAULT_SKIP_ZEROES
;
2689 disasm_info
.skip_zeroes_at_end
= DEFAULT_SKIP_ZEROES_AT_END
;
2690 disasm_info
.disassembler_needs_relocs
= FALSE
;
2692 if (bfd_big_endian (abfd
))
2693 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_BIG
;
2694 else if (bfd_little_endian (abfd
))
2695 disasm_info
.display_endian
= disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
2697 /* ??? Aborting here seems too drastic. We could default to big or little
2699 disasm_info
.endian
= BFD_ENDIAN_UNKNOWN
;
2701 /* Allow the target to customize the info structure. */
2702 disassemble_init_for_target (& disasm_info
);
2704 /* Pre-load the dynamic relocs as we may need them during the disassembly. */
2706 long relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
2708 if (relsize
< 0 && dump_dynamic_reloc_info
)
2709 bfd_fatal (bfd_get_filename (abfd
));
2713 aux
.dynrelbuf
= (arelent
**) xmalloc (relsize
);
2714 aux
.dynrelcount
= bfd_canonicalize_dynamic_reloc (abfd
,
2717 if (aux
.dynrelcount
< 0)
2718 bfd_fatal (bfd_get_filename (abfd
));
2720 /* Sort the relocs by address. */
2721 qsort (aux
.dynrelbuf
, aux
.dynrelcount
, sizeof (arelent
*),
2725 disasm_info
.symtab
= sorted_syms
;
2726 disasm_info
.symtab_size
= sorted_symcount
;
2728 bfd_map_over_sections (abfd
, disassemble_section
, & disasm_info
);
2730 if (aux
.dynrelbuf
!= NULL
)
2731 free (aux
.dynrelbuf
);
2733 disassemble_free_target (&disasm_info
);
2737 load_specific_debug_section (enum dwarf_section_display_enum debug
,
2738 asection
*sec
, void *file
)
2740 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2741 bfd
*abfd
= (bfd
*) file
;
2746 if (section
->start
!= NULL
)
2748 /* If it is already loaded, do nothing. */
2749 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2751 free (section
->start
);
2754 section
->filename
= bfd_get_filename (abfd
);
2755 section
->reloc_info
= NULL
;
2756 section
->num_relocs
= 0;
2757 section
->address
= bfd_section_vma (sec
);
2758 section
->user_data
= sec
;
2759 section
->size
= bfd_section_size (sec
);
2760 /* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
2761 alloced
= amt
= section
->size
+ 1;
2762 if (alloced
!= amt
|| alloced
== 0)
2764 section
->start
= NULL
;
2765 free_debug_section (debug
);
2766 printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
2767 sanitize_string (section
->name
),
2768 (unsigned long long) section
->size
);
2771 section
->start
= contents
= malloc (alloced
);
2772 if (section
->start
== NULL
2773 || !bfd_get_full_section_contents (abfd
, sec
, &contents
))
2775 free_debug_section (debug
);
2776 printf (_("\nCan't get contents for section '%s'.\n"),
2777 sanitize_string (section
->name
));
2780 /* Ensure any string section has a terminating NUL. */
2781 section
->start
[section
->size
] = 0;
2783 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
2784 && debug_displays
[debug
].relocate
)
2789 bfd_cache_section_contents (sec
, section
->start
);
2791 ret
= bfd_simple_get_relocated_section_contents (abfd
,
2798 free_debug_section (debug
);
2799 printf (_("\nCan't get contents for section '%s'.\n"),
2800 sanitize_string (section
->name
));
2804 reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
2807 unsigned long reloc_count
;
2810 relocs
= (arelent
**) xmalloc (reloc_size
);
2812 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, NULL
);
2813 if (reloc_count
== 0)
2817 section
->reloc_info
= relocs
;
2818 section
->num_relocs
= reloc_count
;
2827 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
2832 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
2835 relocs
= (arelent
**) dsec
->reloc_info
;
2837 for (; (rp
= * relocs
) != NULL
; ++ relocs
)
2838 if (rp
->address
== offset
)
2845 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
2847 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2848 bfd
*abfd
= (bfd
*) file
;
2851 /* If it is already loaded, do nothing. */
2852 if (section
->start
!= NULL
)
2854 if (streq (section
->filename
, bfd_get_filename (abfd
)))
2858 /* Locate the debug section. */
2859 sec
= bfd_get_section_by_name (abfd
, section
->uncompressed_name
);
2861 section
->name
= section
->uncompressed_name
;
2864 sec
= bfd_get_section_by_name (abfd
, section
->compressed_name
);
2866 section
->name
= section
->compressed_name
;
2871 return load_specific_debug_section (debug
, sec
, file
);
2875 free_debug_section (enum dwarf_section_display_enum debug
)
2877 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
2879 if (section
->start
== NULL
)
2882 /* PR 17512: file: 0f67f69d. */
2883 if (section
->user_data
!= NULL
)
2885 asection
* sec
= (asection
*) section
->user_data
;
2887 /* If we are freeing contents that are also pointed to by the BFD
2888 library's section structure then make sure to update those pointers
2889 too. Otherwise, the next time we try to load data for this section
2890 we can end up using a stale pointer. */
2891 if (section
->start
== sec
->contents
)
2893 sec
->contents
= NULL
;
2894 sec
->flags
&= ~ SEC_IN_MEMORY
;
2895 sec
->compress_status
= COMPRESS_SECTION_NONE
;
2899 free ((char *) section
->start
);
2900 section
->start
= NULL
;
2901 section
->address
= 0;
2906 close_debug_file (void * file
)
2908 bfd
* abfd
= (bfd
*) file
;
2914 open_debug_file (const char * pathname
)
2918 data
= bfd_openr (pathname
, NULL
);
2922 if (! bfd_check_format (data
, bfd_object
))
2929 dump_dwarf_section (bfd
*abfd
, asection
*section
,
2930 void *arg ATTRIBUTE_UNUSED
)
2932 const char *name
= bfd_section_name (section
);
2936 if (CONST_STRNEQ (name
, ".gnu.linkonce.wi."))
2937 match
= ".debug_info";
2941 for (i
= 0; i
< max
; i
++)
2942 if ((strcmp (debug_displays
[i
].section
.uncompressed_name
, match
) == 0
2943 || strcmp (debug_displays
[i
].section
.compressed_name
, match
) == 0)
2944 && debug_displays
[i
].enabled
!= NULL
2945 && *debug_displays
[i
].enabled
)
2947 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
2949 if (strcmp (sec
->uncompressed_name
, match
) == 0)
2950 sec
->name
= sec
->uncompressed_name
;
2952 sec
->name
= sec
->compressed_name
;
2953 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
2956 debug_displays
[i
].display (sec
, abfd
);
2958 if (i
!= info
&& i
!= abbrev
)
2959 free_debug_section ((enum dwarf_section_display_enum
) i
);
2965 /* Dump the dwarf debugging information. */
2968 dump_dwarf (bfd
*abfd
)
2970 /* The byte_get pointer should have been set at the start of dump_bfd(). */
2971 if (byte_get
== NULL
)
2973 warn (_("File %s does not contain any dwarf debug information\n"),
2974 bfd_get_filename (abfd
));
2978 switch (bfd_get_arch (abfd
))
2981 /* S12Z has a 24 bit address space. But the only known
2982 producer of dwarf_info encodes addresses into 32 bits. */
2987 eh_addr_size
= bfd_arch_bits_per_address (abfd
) / 8;
2991 init_dwarf_regnames_by_bfd_arch_and_mach (bfd_get_arch (abfd
),
2992 bfd_get_mach (abfd
));
2994 bfd_map_over_sections (abfd
, dump_dwarf_section
, NULL
);
2997 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2998 it. Return NULL on failure. */
3001 read_section_stabs (bfd
*abfd
, const char *sect_name
, bfd_size_type
*size_ptr
,
3002 bfd_size_type
*entsize_ptr
)
3007 stabsect
= bfd_get_section_by_name (abfd
, sect_name
);
3008 if (stabsect
== NULL
)
3010 printf (_("No %s section present\n\n"),
3011 sanitize_string (sect_name
));
3015 if (!bfd_malloc_and_get_section (abfd
, stabsect
, &contents
))
3017 non_fatal (_("reading %s section of %s failed: %s"),
3018 sect_name
, bfd_get_filename (abfd
),
3019 bfd_errmsg (bfd_get_error ()));
3025 *size_ptr
= bfd_section_size (stabsect
);
3027 *entsize_ptr
= stabsect
->entsize
;
3032 /* Stabs entries use a 12 byte format:
3033 4 byte string table index
3035 1 byte stab other field
3036 2 byte stab desc field
3038 FIXME: This will have to change for a 64 bit object format. */
3040 #define STRDXOFF (0)
3042 #define OTHEROFF (5)
3045 #define STABSIZE (12)
3047 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3048 using string table section STRSECT_NAME (in `strtab'). */
3051 print_section_stabs (bfd
*abfd
,
3052 const char *stabsect_name
,
3053 unsigned *string_offset_ptr
)
3056 unsigned file_string_table_offset
= 0;
3057 unsigned next_file_string_table_offset
= *string_offset_ptr
;
3058 bfd_byte
*stabp
, *stabs_end
;
3061 stabs_end
= stabp
+ stab_size
;
3063 printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name
));
3064 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
3066 /* Loop through all symbols and print them.
3068 We start the index at -1 because there is a dummy symbol on
3069 the front of stabs-in-{coff,elf} sections that supplies sizes. */
3070 for (i
= -1; stabp
<= stabs_end
- STABSIZE
; stabp
+= STABSIZE
, i
++)
3074 unsigned char type
, other
;
3075 unsigned short desc
;
3078 strx
= bfd_h_get_32 (abfd
, stabp
+ STRDXOFF
);
3079 type
= bfd_h_get_8 (abfd
, stabp
+ TYPEOFF
);
3080 other
= bfd_h_get_8 (abfd
, stabp
+ OTHEROFF
);
3081 desc
= bfd_h_get_16 (abfd
, stabp
+ DESCOFF
);
3082 value
= bfd_h_get_32 (abfd
, stabp
+ VALOFF
);
3084 printf ("\n%-6d ", i
);
3085 /* Either print the stab name, or, if unnamed, print its number
3086 again (makes consistent formatting for tools like awk). */
3087 name
= bfd_get_stab_name (type
);
3089 printf ("%-6s", sanitize_string (name
));
3090 else if (type
== N_UNDF
)
3093 printf ("%-6d", type
);
3094 printf (" %-6d %-6d ", other
, desc
);
3095 bfd_printf_vma (abfd
, value
);
3096 printf (" %-6lu", strx
);
3098 /* Symbols with type == 0 (N_UNDF) specify the length of the
3099 string table associated with this file. We use that info
3100 to know how to relocate the *next* file's string table indices. */
3103 file_string_table_offset
= next_file_string_table_offset
;
3104 next_file_string_table_offset
+= value
;
3108 bfd_size_type amt
= strx
+ file_string_table_offset
;
3110 /* Using the (possibly updated) string table offset, print the
3111 string (if any) associated with this symbol. */
3112 if (amt
< stabstr_size
)
3113 /* PR 17512: file: 079-79389-0.001:0.1.
3114 FIXME: May need to sanitize this string before displaying. */
3115 printf (" %.*s", (int)(stabstr_size
- amt
), strtab
+ amt
);
3121 *string_offset_ptr
= next_file_string_table_offset
;
3126 const char * section_name
;
3127 const char * string_section_name
;
3128 unsigned string_offset
;
3133 find_stabs_section (bfd
*abfd
, asection
*section
, void *names
)
3136 stab_section_names
* sought
= (stab_section_names
*) names
;
3138 /* Check for section names for which stabsect_name is a prefix, to
3139 handle .stab.N, etc. */
3140 len
= strlen (sought
->section_name
);
3142 /* If the prefix matches, and the files section name ends with a
3143 nul or a digit, then we match. I.e., we want either an exact
3144 match or a section followed by a number. */
3145 if (strncmp (sought
->section_name
, section
->name
, len
) == 0
3146 && (section
->name
[len
] == 0
3147 || (section
->name
[len
] == '.' && ISDIGIT (section
->name
[len
+ 1]))))
3150 strtab
= read_section_stabs (abfd
, sought
->string_section_name
,
3151 &stabstr_size
, NULL
);
3155 stabs
= read_section_stabs (abfd
, section
->name
, &stab_size
, NULL
);
3157 print_section_stabs (abfd
, section
->name
, &sought
->string_offset
);
3163 dump_stabs_section (bfd
*abfd
, char *stabsect_name
, char *strsect_name
)
3165 stab_section_names s
;
3167 s
.section_name
= stabsect_name
;
3168 s
.string_section_name
= strsect_name
;
3169 s
.string_offset
= 0;
3171 bfd_map_over_sections (abfd
, find_stabs_section
, & s
);
3177 /* Dump the any sections containing stabs debugging information. */
3180 dump_stabs (bfd
*abfd
)
3182 dump_stabs_section (abfd
, ".stab", ".stabstr");
3183 dump_stabs_section (abfd
, ".stab.excl", ".stab.exclstr");
3184 dump_stabs_section (abfd
, ".stab.index", ".stab.indexstr");
3187 dump_stabs_section (abfd
, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3189 dump_stabs_section (abfd
, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3193 dump_bfd_header (bfd
*abfd
)
3197 printf (_("architecture: %s, "),
3198 bfd_printable_arch_mach (bfd_get_arch (abfd
),
3199 bfd_get_mach (abfd
)));
3200 printf (_("flags 0x%08x:\n"), abfd
->flags
& ~BFD_FLAGS_FOR_BFD_USE_MASK
);
3202 #define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
3203 PF (HAS_RELOC
, "HAS_RELOC");
3204 PF (EXEC_P
, "EXEC_P");
3205 PF (HAS_LINENO
, "HAS_LINENO");
3206 PF (HAS_DEBUG
, "HAS_DEBUG");
3207 PF (HAS_SYMS
, "HAS_SYMS");
3208 PF (HAS_LOCALS
, "HAS_LOCALS");
3209 PF (DYNAMIC
, "DYNAMIC");
3210 PF (WP_TEXT
, "WP_TEXT");
3211 PF (D_PAGED
, "D_PAGED");
3212 PF (BFD_IS_RELAXABLE
, "BFD_IS_RELAXABLE");
3213 printf (_("\nstart address 0x"));
3214 bfd_printf_vma (abfd
, abfd
->start_address
);
3219 /* Formatting callback function passed to ctf_dump. Returns either the pointer
3220 it is passed, or a pointer to newly-allocated storage, in which case
3221 dump_ctf() will free it when it no longer needs it. */
3224 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
3227 const char *blanks
= arg
;
3230 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
3235 /* Make a ctfsect suitable for ctf_bfdopen_ctfsect(). */
3237 make_ctfsect (const char *name
, bfd_byte
*data
,
3242 ctfsect
.cts_name
= name
;
3243 ctfsect
.cts_entsize
= 1;
3244 ctfsect
.cts_size
= size
;
3245 ctfsect
.cts_data
= data
;
3250 /* Dump one CTF archive member. */
3253 dump_ctf_archive_member (ctf_file_t
*ctf
, const char *name
, void *arg
)
3255 ctf_file_t
*parent
= (ctf_file_t
*) arg
;
3256 const char *things
[] = {"Header", "Labels", "Data objects",
3257 "Function objects", "Variables", "Types", "Strings",
3262 /* Only print out the name of non-default-named archive members.
3263 The name .ctf appears everywhere, even for things that aren't
3264 really archives, so printing it out is liable to be confusing.
3266 The parent, if there is one, is the default-owned archive member:
3267 avoid importing it into itself. (This does no harm, but looks
3270 if (strcmp (name
, ".ctf") != 0)
3272 printf (_("\nCTF archive member: %s:\n"), sanitize_string (name
));
3273 ctf_import (ctf
, parent
);
3276 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
3278 ctf_dump_state_t
*s
= NULL
;
3281 printf ("\n %s:\n", *thing
);
3282 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
3283 (void *) " ")) != NULL
)
3285 printf ("%s\n", item
);
3289 if (ctf_errno (ctf
))
3291 non_fatal (_("Iteration failed: %s, %s\n"), *thing
,
3292 ctf_errmsg (ctf_errno (ctf
)));
3299 /* Dump the CTF debugging information. */
3302 dump_ctf (bfd
*abfd
, const char *sect_name
, const char *parent_name
)
3304 ctf_archive_t
*ctfa
, *parenta
= NULL
, *lookparent
;
3305 bfd_byte
*ctfdata
, *parentdata
= NULL
;
3306 bfd_size_type ctfsize
, parentsize
;
3308 ctf_file_t
*parent
= NULL
;
3311 if ((ctfdata
= read_section_stabs (abfd
, sect_name
, &ctfsize
, NULL
)) == NULL
)
3312 bfd_fatal (bfd_get_filename (abfd
));
3315 && (parentdata
= read_section_stabs (abfd
, parent_name
, &parentsize
,
3317 bfd_fatal (bfd_get_filename (abfd
));
3319 /* Load the CTF file and dump it. */
3321 ctfsect
= make_ctfsect (sect_name
, ctfdata
, ctfsize
);
3322 if ((ctfa
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
3324 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3325 bfd_fatal (bfd_get_filename (abfd
));
3330 ctfsect
= make_ctfsect (parent_name
, parentdata
, parentsize
);
3331 if ((parenta
= ctf_bfdopen_ctfsect (abfd
, &ctfsect
, &err
)) == NULL
)
3333 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3334 bfd_fatal (bfd_get_filename (abfd
));
3337 lookparent
= parenta
;
3342 /* Assume that the applicable parent archive member is the default one.
3343 (This is what all known implementations are expected to do, if they
3344 put CTFs and their parents in archives together.) */
3345 if ((parent
= ctf_arc_open_by_name (lookparent
, NULL
, &err
)) == NULL
)
3347 non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err
));
3348 bfd_fatal (bfd_get_filename (abfd
));
3351 printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name
));
3353 ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
);
3354 ctf_file_close (parent
);
3356 ctf_close (parenta
);
3363 dump_bfd_private_header (bfd
*abfd
)
3365 if (!bfd_print_private_bfd_data (abfd
, stdout
))
3366 non_fatal (_("warning: private headers incomplete: %s"),
3367 bfd_errmsg (bfd_get_error ()));
3371 dump_target_specific (bfd
*abfd
)
3373 const struct objdump_private_desc
* const *desc
;
3374 struct objdump_private_option
*opt
;
3377 /* Find the desc. */
3378 for (desc
= objdump_private_vectors
; *desc
!= NULL
; desc
++)
3379 if ((*desc
)->filter (abfd
))
3384 non_fatal (_("option -P/--private not supported by this file"));
3388 /* Clear all options. */
3389 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3390 opt
->selected
= FALSE
;
3392 /* Decode options. */
3393 b
= dump_private_options
;
3396 e
= strchr (b
, ',');
3401 for (opt
= (*desc
)->options
; opt
->name
; opt
++)
3402 if (strcmp (opt
->name
, b
) == 0)
3404 opt
->selected
= TRUE
;
3407 if (opt
->name
== NULL
)
3408 non_fatal (_("target specific dump '%s' not supported"), b
);
3419 (*desc
)->dump (abfd
);
3422 /* Display a section in hexadecimal format with associated characters.
3423 Each line prefixed by the zero padded address. */
3426 dump_section (bfd
*abfd
, asection
*section
, void *dummy ATTRIBUTE_UNUSED
)
3428 bfd_byte
*data
= NULL
;
3429 bfd_size_type datasize
;
3430 bfd_vma addr_offset
;
3431 bfd_vma start_offset
;
3432 bfd_vma stop_offset
;
3433 unsigned int opb
= bfd_octets_per_byte (abfd
, section
);
3434 /* Bytes per line. */
3435 const int onaline
= 16;
3440 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
3443 if (! process_section_p (section
))
3446 if ((datasize
= bfd_section_size (section
)) == 0)
3449 /* Compute the address range to display. */
3450 if (start_address
== (bfd_vma
) -1
3451 || start_address
< section
->vma
)
3454 start_offset
= start_address
- section
->vma
;
3456 if (stop_address
== (bfd_vma
) -1)
3457 stop_offset
= datasize
/ opb
;
3460 if (stop_address
< section
->vma
)
3463 stop_offset
= stop_address
- section
->vma
;
3465 if (stop_offset
> datasize
/ opb
)
3466 stop_offset
= datasize
/ opb
;
3469 if (start_offset
>= stop_offset
)
3472 printf (_("Contents of section %s:"), sanitize_string (section
->name
));
3473 if (display_file_offsets
)
3474 printf (_(" (Starting at file offset: 0x%lx)"),
3475 (unsigned long) (section
->filepos
+ start_offset
));
3478 if (!bfd_get_full_section_contents (abfd
, section
, &data
))
3480 non_fatal (_("Reading section %s failed because: %s"),
3481 section
->name
, bfd_errmsg (bfd_get_error ()));
3487 bfd_sprintf_vma (abfd
, buf
, start_offset
+ section
->vma
);
3488 if (strlen (buf
) >= sizeof (buf
))
3492 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3494 count
= strlen (buf
) - count
;
3498 bfd_sprintf_vma (abfd
, buf
, stop_offset
+ section
->vma
- 1);
3499 if (strlen (buf
) >= sizeof (buf
))
3503 while (buf
[count
] == '0' && buf
[count
+1] != '\0')
3505 count
= strlen (buf
) - count
;
3509 for (addr_offset
= start_offset
;
3510 addr_offset
< stop_offset
; addr_offset
+= onaline
/ opb
)
3514 bfd_sprintf_vma (abfd
, buf
, (addr_offset
+ section
->vma
));
3515 count
= strlen (buf
);
3516 if ((size_t) count
>= sizeof (buf
))
3520 while (count
< width
)
3525 fputs (buf
+ count
- width
, stdout
);
3528 for (j
= addr_offset
* opb
;
3529 j
< addr_offset
* opb
+ onaline
; j
++)
3531 if (j
< stop_offset
* opb
)
3532 printf ("%02x", (unsigned) (data
[j
]));
3540 for (j
= addr_offset
* opb
;
3541 j
< addr_offset
* opb
+ onaline
; j
++)
3543 if (j
>= stop_offset
* opb
)
3546 printf ("%c", ISPRINT (data
[j
]) ? data
[j
] : '.');
3553 /* Actually display the various requested regions. */
3556 dump_data (bfd
*abfd
)
3558 bfd_map_over_sections (abfd
, dump_section
, NULL
);
3561 /* Should perhaps share code and display with nm? */
3564 dump_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_boolean dynamic
)
3573 max_count
= dynsymcount
;
3574 printf ("DYNAMIC SYMBOL TABLE:\n");
3579 max_count
= symcount
;
3580 printf ("SYMBOL TABLE:\n");
3584 printf (_("no symbols\n"));
3586 for (count
= 0; count
< max_count
; count
++)
3590 if (*current
== NULL
)
3591 printf (_("no information for symbol number %ld\n"), count
);
3593 else if ((cur_bfd
= bfd_asymbol_bfd (*current
)) == NULL
)
3594 printf (_("could not determine the type of symbol number %ld\n"),
3597 else if (process_section_p ((* current
)->section
)
3598 && (dump_special_syms
3599 || !bfd_is_target_special_symbol (cur_bfd
, *current
)))
3601 const char *name
= (*current
)->name
;
3603 if (do_demangle
&& name
!= NULL
&& *name
!= '\0')
3607 /* If we want to demangle the name, we demangle it
3608 here, and temporarily clobber it while calling
3609 bfd_print_symbol. FIXME: This is a gross hack. */
3610 alloc
= bfd_demangle (cur_bfd
, name
, demangle_flags
);
3612 (*current
)->name
= alloc
;
3613 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3614 bfd_print_symbol_all
);
3617 (*current
)->name
= name
;
3622 bfd_print_symbol (cur_bfd
, stdout
, *current
,
3623 bfd_print_symbol_all
);
3633 dump_reloc_set (bfd
*abfd
, asection
*sec
, arelent
**relpp
, long relcount
)
3636 char *last_filename
, *last_functionname
;
3637 unsigned int last_line
;
3638 unsigned int last_discriminator
;
3640 /* Get column headers lined up reasonably. */
3648 bfd_sprintf_vma (abfd
, buf
, (bfd_vma
) -1);
3649 width
= strlen (buf
) - 7;
3651 printf ("OFFSET %*s TYPE %*s VALUE \n", width
, "", 12, "");
3654 last_filename
= NULL
;
3655 last_functionname
= NULL
;
3657 last_discriminator
= 0;
3659 for (p
= relpp
; relcount
&& *p
!= NULL
; p
++, relcount
--)
3662 const char *filename
, *functionname
;
3663 unsigned int linenumber
;
3664 unsigned int discriminator
;
3665 const char *sym_name
;
3666 const char *section_name
;
3667 bfd_vma addend2
= 0;
3669 if (start_address
!= (bfd_vma
) -1
3670 && q
->address
< start_address
)
3672 if (stop_address
!= (bfd_vma
) -1
3673 && q
->address
> stop_address
)
3676 if (with_line_numbers
3678 && bfd_find_nearest_line_discriminator (abfd
, sec
, syms
, q
->address
,
3679 &filename
, &functionname
,
3680 &linenumber
, &discriminator
))
3682 if (functionname
!= NULL
3683 && (last_functionname
== NULL
3684 || strcmp (functionname
, last_functionname
) != 0))
3686 printf ("%s():\n", sanitize_string (functionname
));
3687 if (last_functionname
!= NULL
)
3688 free (last_functionname
);
3689 last_functionname
= xstrdup (functionname
);
3693 && (linenumber
!= last_line
3694 || (filename
!= NULL
3695 && last_filename
!= NULL
3696 && filename_cmp (filename
, last_filename
) != 0)
3697 || (discriminator
!= last_discriminator
)))
3699 if (discriminator
> 0)
3700 printf ("%s:%u\n", filename
== NULL
? "???" :
3701 sanitize_string (filename
), linenumber
);
3703 printf ("%s:%u (discriminator %u)\n",
3704 filename
== NULL
? "???" : sanitize_string (filename
),
3705 linenumber
, discriminator
);
3706 last_line
= linenumber
;
3707 last_discriminator
= discriminator
;
3708 if (last_filename
!= NULL
)
3709 free (last_filename
);
3710 if (filename
== NULL
)
3711 last_filename
= NULL
;
3713 last_filename
= xstrdup (filename
);
3717 if (q
->sym_ptr_ptr
&& *q
->sym_ptr_ptr
)
3719 sym_name
= (*(q
->sym_ptr_ptr
))->name
;
3720 section_name
= (*(q
->sym_ptr_ptr
))->section
->name
;
3725 section_name
= NULL
;
3728 bfd_printf_vma (abfd
, q
->address
);
3729 if (q
->howto
== NULL
)
3730 printf (" *unknown* ");
3731 else if (q
->howto
->name
)
3733 const char *name
= q
->howto
->name
;
3735 /* R_SPARC_OLO10 relocations contain two addends.
3736 But because 'arelent' lacks enough storage to
3737 store them both, the 64-bit ELF Sparc backend
3738 records this as two relocations. One R_SPARC_LO10
3739 and one R_SPARC_13, both pointing to the same
3740 address. This is merely so that we have some
3741 place to store both addend fields.
3743 Undo this transformation, otherwise the output
3744 will be confusing. */
3745 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
3746 && elf_tdata(abfd
)->elf_header
->e_machine
== EM_SPARCV9
3748 && !strcmp (q
->howto
->name
, "R_SPARC_LO10"))
3750 arelent
*q2
= *(p
+ 1);
3753 && q
->address
== q2
->address
3754 && !strcmp (q2
->howto
->name
, "R_SPARC_13"))
3756 name
= "R_SPARC_OLO10";
3757 addend2
= q2
->addend
;
3761 printf (" %-16s ", name
);
3764 printf (" %-16d ", q
->howto
->type
);
3768 objdump_print_symname (abfd
, NULL
, *q
->sym_ptr_ptr
);
3772 if (section_name
== NULL
)
3773 section_name
= "*unknown*";
3774 printf ("[%s]", sanitize_string (section_name
));
3779 bfd_signed_vma addend
= q
->addend
;
3787 bfd_printf_vma (abfd
, addend
);
3792 bfd_printf_vma (abfd
, addend2
);
3798 if (last_filename
!= NULL
)
3799 free (last_filename
);
3800 if (last_functionname
!= NULL
)
3801 free (last_functionname
);
3805 dump_relocs_in_section (bfd
*abfd
,
3807 void *dummy ATTRIBUTE_UNUSED
)
3809 arelent
**relpp
= NULL
;
3813 if ( bfd_is_abs_section (section
)
3814 || bfd_is_und_section (section
)
3815 || bfd_is_com_section (section
)
3816 || (! process_section_p (section
))
3817 || ((section
->flags
& SEC_RELOC
) == 0))
3820 printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section
->name
));
3822 relsize
= bfd_get_reloc_upper_bound (abfd
, section
);
3825 printf (" (none)\n\n");
3833 relpp
= (arelent
**) xmalloc (relsize
);
3834 relcount
= bfd_canonicalize_reloc (abfd
, section
, relpp
, syms
);
3840 non_fatal (_("failed to read relocs in: %s"),
3841 sanitize_string (bfd_get_filename (abfd
)));
3842 bfd_fatal (_("error message was"));
3844 else if (relcount
== 0)
3845 printf (" (none)\n\n");
3849 dump_reloc_set (abfd
, section
, relpp
, relcount
);
3856 dump_relocs (bfd
*abfd
)
3858 bfd_map_over_sections (abfd
, dump_relocs_in_section
, NULL
);
3862 dump_dynamic_relocs (bfd
*abfd
)
3868 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
3870 bfd_fatal (bfd_get_filename (abfd
));
3872 printf ("DYNAMIC RELOCATION RECORDS");
3875 printf (" (none)\n\n");
3878 relpp
= (arelent
**) xmalloc (relsize
);
3879 relcount
= bfd_canonicalize_dynamic_reloc (abfd
, relpp
, dynsyms
);
3882 bfd_fatal (bfd_get_filename (abfd
));
3883 else if (relcount
== 0)
3884 printf (" (none)\n\n");
3888 dump_reloc_set (abfd
, NULL
, relpp
, relcount
);
3895 /* Creates a table of paths, to search for source files. */
3898 add_include_path (const char *path
)
3902 include_path_count
++;
3903 include_paths
= (const char **)
3904 xrealloc (include_paths
, include_path_count
* sizeof (*include_paths
));
3905 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3906 if (path
[1] == ':' && path
[2] == 0)
3907 path
= concat (path
, ".", (const char *) 0);
3909 include_paths
[include_path_count
- 1] = path
;
3913 adjust_addresses (bfd
*abfd ATTRIBUTE_UNUSED
,
3917 if ((section
->flags
& SEC_DEBUGGING
) == 0)
3919 bfd_boolean
*has_reloc_p
= (bfd_boolean
*) arg
;
3920 section
->vma
+= adjust_section_vma
;
3922 section
->lma
+= adjust_section_vma
;
3926 /* Return the sign-extended form of an ARCH_SIZE sized VMA. */
3929 sign_extend_address (bfd
*abfd ATTRIBUTE_UNUSED
,
3934 mask
= (bfd_vma
) 1 << (arch_size
- 1);
3935 return (((vma
& ((mask
<< 1) - 1)) ^ mask
) - mask
);
3938 /* Dump selected contents of ABFD. */
3941 dump_bfd (bfd
*abfd
, bfd_boolean is_mainfile
)
3943 const struct elf_backend_data
* bed
;
3945 if (bfd_big_endian (abfd
))
3946 byte_get
= byte_get_big_endian
;
3947 else if (bfd_little_endian (abfd
))
3948 byte_get
= byte_get_little_endian
;
3952 /* Load any separate debug information files.
3953 We do this now and without checking do_follow_links because separate
3954 debug info files may contain symbol tables that we will need when
3955 displaying information about the main file. Any memory allocated by
3956 load_separate_debug_files will be released when we call
3957 free_debug_memory below.
3959 The test on is_mainfile is there because the chain of separate debug
3960 info files is a global variable shared by all invocations of dump_bfd. */
3963 load_separate_debug_files (abfd
, bfd_get_filename (abfd
));
3965 /* If asked to do so, recursively dump the separate files. */
3966 if (do_follow_links
)
3970 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3971 dump_bfd (i
->handle
, FALSE
);
3975 /* Adjust user-specified start and stop limits for targets that use
3976 signed addresses. */
3977 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3978 && (bed
= get_elf_backend_data (abfd
)) != NULL
3979 && bed
->sign_extend_vma
)
3981 start_address
= sign_extend_address (abfd
, start_address
,
3983 stop_address
= sign_extend_address (abfd
, stop_address
,
3987 /* If we are adjusting section VMA's, change them all now. Changing
3988 the BFD information is a hack. However, we must do it, or
3989 bfd_find_nearest_line will not do the right thing. */
3990 if (adjust_section_vma
!= 0)
3992 bfd_boolean has_reloc
= (abfd
->flags
& HAS_RELOC
);
3993 bfd_map_over_sections (abfd
, adjust_addresses
, &has_reloc
);
3996 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
3997 printf (_("\n%s: file format %s\n"),
3998 sanitize_string (bfd_get_filename (abfd
)),
4001 print_arelt_descr (stdout
, abfd
, TRUE
, FALSE
);
4002 if (dump_file_header
)
4003 dump_bfd_header (abfd
);
4004 if (dump_private_headers
)
4005 dump_bfd_private_header (abfd
);
4006 if (dump_private_options
!= NULL
)
4007 dump_target_specific (abfd
);
4008 if (! dump_debugging_tags
&& ! suppress_bfd_header
)
4015 || dump_dwarf_section_info
)
4017 syms
= slurp_symtab (abfd
);
4019 /* If following links, load any symbol tables from the linked files as well. */
4020 if (do_follow_links
&& is_mainfile
)
4024 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
4026 asymbol
** extra_syms
;
4027 long old_symcount
= symcount
;
4029 extra_syms
= slurp_symtab (i
->handle
);
4033 if (old_symcount
== 0)
4039 syms
= xrealloc (syms
, (symcount
+ old_symcount
) * sizeof (asymbol
*));
4040 memcpy (syms
+ old_symcount
,
4042 symcount
* sizeof (asymbol
*));
4046 symcount
+= old_symcount
;
4051 if (dump_section_headers
)
4052 dump_headers (abfd
);
4054 if (dump_dynamic_symtab
|| dump_dynamic_reloc_info
4055 || (disassemble
&& bfd_get_dynamic_symtab_upper_bound (abfd
) > 0))
4056 dynsyms
= slurp_dynamic_symtab (abfd
);
4060 synthcount
= bfd_get_synthetic_symtab (abfd
, symcount
, syms
,
4061 dynsymcount
, dynsyms
, &synthsyms
);
4067 dump_symbols (abfd
, FALSE
);
4068 if (dump_dynamic_symtab
)
4069 dump_symbols (abfd
, TRUE
);
4070 if (dump_dwarf_section_info
)
4072 if (dump_ctf_section_info
)
4073 dump_ctf (abfd
, dump_ctf_section_name
, dump_ctf_parent_name
);
4074 if (dump_stab_section_info
)
4076 if (dump_reloc_info
&& ! disassemble
)
4078 if (dump_dynamic_reloc_info
&& ! disassemble
)
4079 dump_dynamic_relocs (abfd
);
4080 if (dump_section_contents
)
4083 disassemble_data (abfd
);
4089 dhandle
= read_debugging_info (abfd
, syms
, symcount
, TRUE
);
4090 if (dhandle
!= NULL
)
4092 if (!print_debugging_info (stdout
, dhandle
, abfd
, syms
,
4094 dump_debugging_tags
? TRUE
: FALSE
))
4096 non_fatal (_("%s: printing debugging information failed"),
4097 bfd_get_filename (abfd
));
4103 /* PR 6483: If there was no STABS debug info in the file, try
4105 else if (! dump_dwarf_section_info
)
4107 dwarf_select_sections_all ();
4135 free_debug_memory ();
4139 display_object_bfd (bfd
*abfd
)
4143 if (bfd_check_format_matches (abfd
, bfd_object
, &matching
))
4145 dump_bfd (abfd
, TRUE
);
4149 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4151 nonfatal (bfd_get_filename (abfd
));
4152 list_matching_formats (matching
);
4157 if (bfd_get_error () != bfd_error_file_not_recognized
)
4159 nonfatal (bfd_get_filename (abfd
));
4163 if (bfd_check_format_matches (abfd
, bfd_core
, &matching
))
4165 dump_bfd (abfd
, TRUE
);
4169 nonfatal (bfd_get_filename (abfd
));
4171 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
4173 list_matching_formats (matching
);
4179 display_any_bfd (bfd
*file
, int level
)
4181 /* Decompress sections unless dumping the section contents. */
4182 if (!dump_section_contents
)
4183 file
->flags
|= BFD_DECOMPRESS
;
4185 /* If the file is an archive, process all of its elements. */
4186 if (bfd_check_format (file
, bfd_archive
))
4189 bfd
*last_arfile
= NULL
;
4192 printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file
)));
4193 else if (level
> 100)
4195 /* Prevent corrupted files from spinning us into an
4196 infinite loop. 100 is an arbitrary heuristic. */
4197 fatal (_("Archive nesting is too deep"));
4201 printf (_("In nested archive %s:\n"),
4202 sanitize_string (bfd_get_filename (file
)));
4206 bfd_set_error (bfd_error_no_error
);
4208 arfile
= bfd_openr_next_archived_file (file
, arfile
);
4211 if (bfd_get_error () != bfd_error_no_more_archived_files
)
4212 nonfatal (bfd_get_filename (file
));
4216 display_any_bfd (arfile
, level
+ 1);
4218 if (last_arfile
!= NULL
)
4220 bfd_close (last_arfile
);
4221 /* PR 17512: file: ac585d01. */
4222 if (arfile
== last_arfile
)
4228 last_arfile
= arfile
;
4231 if (last_arfile
!= NULL
)
4232 bfd_close (last_arfile
);
4235 display_object_bfd (file
);
4239 display_file (char *filename
, char *target
, bfd_boolean last_file
)
4243 if (get_file_size (filename
) < 1)
4249 file
= bfd_openr (filename
, target
);
4252 nonfatal (filename
);
4256 display_any_bfd (file
, 0);
4258 /* This is an optimization to improve the speed of objdump, especially when
4259 dumping a file with lots of associated debug informatiom. Calling
4260 bfd_close on such a file can take a non-trivial amount of time as there
4261 are lots of lists to walk and buffers to free. This is only really
4262 necessary however if we are about to load another file and we need the
4263 memory back. Otherwise, if we are about to exit, then we can save (a lot
4264 of) time by only doing a quick close, and allowing the OS to reclaim the
4269 bfd_close_all_done (file
);
4273 main (int argc
, char **argv
)
4276 char *target
= default_target
;
4277 bfd_boolean seenflag
= FALSE
;
4279 #if defined (HAVE_SETLOCALE)
4280 #if defined (HAVE_LC_MESSAGES)
4281 setlocale (LC_MESSAGES
, "");
4283 setlocale (LC_CTYPE
, "");
4286 bindtextdomain (PACKAGE
, LOCALEDIR
);
4287 textdomain (PACKAGE
);
4289 program_name
= *argv
;
4290 xmalloc_set_program_name (program_name
);
4291 bfd_set_error_program_name (program_name
);
4293 START_PROGRESS (program_name
, 0);
4295 expandargv (&argc
, &argv
);
4297 if (bfd_init () != BFD_INIT_MAGIC
)
4298 fatal (_("fatal error: libbfd ABI mismatch"));
4299 set_default_bfd_target ();
4301 while ((c
= getopt_long (argc
, argv
,
4302 "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
4303 long_options
, (int *) 0))
4309 break; /* We've been given a long option. */
4316 if (disassembler_options
)
4317 /* Ignore potential memory leak for now. */
4318 options
= concat (disassembler_options
, ",",
4319 optarg
, (const char *) NULL
);
4322 disassembler_options
= remove_whitespace_and_extra_commas (options
);
4329 display_file_offsets
= TRUE
;
4332 with_line_numbers
= TRUE
;
4341 enum demangling_styles style
;
4343 style
= cplus_demangle_name_to_style (optarg
);
4344 if (style
== unknown_demangling
)
4345 fatal (_("unknown demangling style `%s'"),
4348 cplus_demangle_set_style (style
);
4351 case OPTION_RECURSE_LIMIT
:
4352 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
4354 case OPTION_NO_RECURSE_LIMIT
:
4355 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
4358 do_wide
= wide_output
= TRUE
;
4360 case OPTION_ADJUST_VMA
:
4361 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
4363 case OPTION_START_ADDRESS
:
4364 start_address
= parse_vma (optarg
, "--start-address");
4365 if ((stop_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4366 fatal (_("error: the start address should be before the end address"));
4368 case OPTION_STOP_ADDRESS
:
4369 stop_address
= parse_vma (optarg
, "--stop-address");
4370 if ((start_address
!= (bfd_vma
) -1) && stop_address
<= start_address
)
4371 fatal (_("error: the stop address should be after the start address"));
4375 prefix_length
= strlen (prefix
);
4376 /* Remove an unnecessary trailing '/' */
4377 while (IS_DIR_SEPARATOR (prefix
[prefix_length
- 1]))
4380 case OPTION_PREFIX_STRIP
:
4381 prefix_strip
= atoi (optarg
);
4382 if (prefix_strip
< 0)
4383 fatal (_("error: prefix strip must be non-negative"));
4385 case OPTION_INSN_WIDTH
:
4386 insn_width
= strtoul (optarg
, NULL
, 0);
4387 if (insn_width
<= 0)
4388 fatal (_("error: instruction width must be positive"));
4390 case OPTION_INLINES
:
4391 unwind_inlines
= TRUE
;
4394 if (strcmp (optarg
, "B") == 0)
4395 endian
= BFD_ENDIAN_BIG
;
4396 else if (strcmp (optarg
, "L") == 0)
4397 endian
= BFD_ENDIAN_LITTLE
;
4400 nonfatal (_("unrecognized -E option"));
4405 if (strncmp (optarg
, "big", strlen (optarg
)) == 0)
4406 endian
= BFD_ENDIAN_BIG
;
4407 else if (strncmp (optarg
, "little", strlen (optarg
)) == 0)
4408 endian
= BFD_ENDIAN_LITTLE
;
4411 non_fatal (_("unrecognized --endian type `%s'"), optarg
);
4418 dump_file_header
= TRUE
;
4422 formats_info
= TRUE
;
4426 add_include_path (optarg
);
4429 dump_private_headers
= TRUE
;
4433 dump_private_options
= optarg
;
4437 dump_private_headers
= TRUE
;
4439 dump_reloc_info
= TRUE
;
4440 dump_file_header
= TRUE
;
4441 dump_ar_hdrs
= TRUE
;
4442 dump_section_headers
= TRUE
;
4450 dump_dynamic_symtab
= TRUE
;
4456 disasm_sym
= optarg
;
4459 disassemble_zeroes
= TRUE
;
4463 disassemble_all
= TRUE
;
4468 with_source_code
= TRUE
;
4471 case OPTION_SOURCE_COMMENT
:
4473 with_source_code
= TRUE
;
4476 source_comment
= xstrdup (sanitize_string (optarg
));
4478 source_comment
= xstrdup ("# ");
4486 dump_debugging_tags
= 1;
4491 dump_dwarf_section_info
= TRUE
;
4494 dwarf_select_sections_by_letters (optarg
);
4496 dwarf_select_sections_all ();
4499 dump_dwarf_section_info
= TRUE
;
4502 dwarf_select_sections_by_names (optarg
);
4504 dwarf_select_sections_all ();
4506 case OPTION_DWARF_DEPTH
:
4509 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4512 case OPTION_DWARF_START
:
4515 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4516 suppress_bfd_header
= 1;
4519 case OPTION_DWARF_CHECK
:
4523 dump_ctf_section_info
= TRUE
;
4524 dump_ctf_section_name
= xstrdup (optarg
);
4527 case OPTION_CTF_PARENT
:
4528 dump_ctf_parent_name
= xstrdup (optarg
);
4531 dump_stab_section_info
= TRUE
;
4535 dump_section_contents
= TRUE
;
4539 dump_reloc_info
= TRUE
;
4543 dump_dynamic_reloc_info
= TRUE
;
4547 dump_ar_hdrs
= TRUE
;
4551 dump_section_headers
= TRUE
;
4556 show_version
= TRUE
;
4562 /* No need to set seenflag or to break - usage() does not return. */
4569 print_version ("objdump");
4575 exit_status
= display_info ();
4579 display_file ("a.out", target
, TRUE
);
4581 for (; optind
< argc
;)
4583 display_file (argv
[optind
], target
, optind
== argc
- 1);
4589 free (dump_ctf_section_name
);
4590 free (dump_ctf_parent_name
);
4591 free ((void *) source_comment
);
4593 END_PROGRESS (program_name
);